diff --git a/.clang-tidy b/.clang-tidy
deleted file mode 100644
index d35b8333..00000000
--- a/.clang-tidy
+++ /dev/null
@@ -1,47 +0,0 @@
-# clang-tidy configuration for WoWee
-# Targets C++20. Checks are tuned for a Vulkan/game-engine codebase:
-#   - reinterpret_cast, pointer arithmetic, and magic numbers are frequent
-#     in low-level graphics/network code, so the most aggressive
-#     cppcoreguidelines and readability-magic-numbers checks are disabled.
----
-Checks: >
-  bugprone-*, 
-  clang-analyzer-*, 
-  performance-*, 
-  modernize-use-nullptr, 
-  modernize-use-override, 
-  modernize-use-default-member-init, 
-  modernize-use-emplace, 
-  modernize-loop-convert, 
-  modernize-deprecated-headers, 
-  modernize-make-unique, 
-  modernize-make-shared, 
-  modernize-use-nodiscard, 
-  modernize-use-designated-initializers, 
-  readability-braces-around-statements, 
-  readability-container-size-empty, 
-  readability-delete-null-pointer, 
-  readability-else-after-return, 
-  readability-misplaced-array-index, 
-  readability-non-const-parameter, 
-  readability-redundant-control-flow, 
-  readability-redundant-declaration, 
-  readability-simplify-boolean-expr, 
-  readability-string-compare, 
-  -bugprone-easily-swappable-parameters, 
-  -clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling, 
-  -performance-avoid-endl
-
-WarningsAsErrors: ''
-
-# Suppress the noise from GCC-only LTO flags in compile_commands.json.
-# clang doesn't support -fno-fat-lto-objects; this silences the harmless warning.
-ExtraArgs:
-  - -std=c++20
-  - -Wno-ignored-optimization-argument
-
-HeaderFilterRegex: '^.*/include/.*\.hpp$'
-
-CheckOptions:
-- key: modernize-use-default-member-init.UseAssignment
-  value: true
diff --git a/.claude/scheduled_tasks.lock b/.claude/scheduled_tasks.lock
new file mode 100644
index 00000000..5b970dd9
--- /dev/null
+++ b/.claude/scheduled_tasks.lock
@@ -0,0 +1 @@
+{"sessionId":"55a28c7e-8043-44c2-9829-702f303c84ba","pid":3880168,"acquiredAt":1773085726967}
\ No newline at end of file
diff --git a/.dockerignore b/.dockerignore
deleted file mode 100644
index d2160131..00000000
--- a/.dockerignore
+++ /dev/null
@@ -1,50 +0,0 @@
-# .dockerignore — Exclude files from the Docker build context.
-# Keeps the context small and prevents leaking build artifacts or secrets.
-
-# Build outputs
-build/
-cache/
-
-# Git history
-.git/
-.gitignore
-.github/
-
-# Large external directories (fetched at build time inside the container)
-extern/FidelityFX-FSR2/
-extern/FidelityFX-SDK/
-
-# IDE / editor files
-.vscode/
-.idea/
-*.swp
-*.swo
-*~
-.DS_Store
-
-# Documentation (not needed for build)
-docs/
-*.md
-!container/*.md
-
-# Test / tool outputs
-logs/
-
-# Host build scripts that run outside the container (not needed inside)
-build.sh
-build.bat
-build.ps1
-rebuild.sh
-rebuild.bat
-rebuild.ps1
-clean.sh
-debug_texture.*
-extract_assets.*
-extract_warden_rsa.py
-restart-worldserver.sh
-test.sh
-
-# macOS SDK tarballs that may be temporarily placed here
-*.tar.xz
-*.tar.gz
-*.tar.bz2
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 6576844b..6893f717 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -2,12 +2,11 @@ name: Build
 
 on:
   push:
-    branches: [ master ]
+    branches: [master]
   pull_request:
-    branches: [ master ]
+    branches: [master]
 
 env:
-  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
   WOWEE_AMD_FSR2_REPO: https://github.com/GPUOpen-Effects/FidelityFX-FSR2.git
   WOWEE_AMD_FSR2_REF: master
   WOWEE_FFX_SDK_REPO: https://github.com/Kelsidavis/FidelityFX-SDK.git
@@ -21,110 +20,105 @@ jobs:
       fail-fast: false
       matrix:
         include:
-        - arch: x86-64
-          runner: ubuntu-24.04
-          deb_arch: amd64
-          build_jobs: $(nproc)
-        - arch: arm64
-          runner: ubuntu-24.04-arm
-          deb_arch: arm64
-          build_jobs: 2
+          - arch: x86-64
+            runner: ubuntu-24.04
+            deb_arch: amd64
+          - arch: arm64
+            runner: ubuntu-24.04-arm
+            deb_arch: arm64
 
     steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        submodules: true
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: true
 
-    - name: Cache apt packages
-      uses: actions/cache@v4
-      with:
-        path: /var/cache/apt/archives/*.deb
-        key: apt-${{ matrix.arch }}-${{ hashFiles('.github/workflows/build.yml') }}
-        restore-keys: apt-${{ matrix.arch }}-
+      - name: Cache apt packages
+        uses: actions/cache@v4
+        with:
+          path: /var/cache/apt/archives/*.deb
+          key: apt-${{ matrix.arch }}-${{ hashFiles('.github/workflows/build.yml') }}
+          restore-keys: apt-${{ matrix.arch }}-
 
-    - name: Install dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y \
-          cmake \
-          build-essential \
-          pkg-config \
-          libsdl2-dev \
-          libglew-dev \
-          libglm-dev \
-          libssl-dev \
-          zlib1g-dev \
-          libvulkan-dev \
-          vulkan-tools \
-          glslc \
-          libavformat-dev \
-          libavcodec-dev \
-          libswscale-dev \
-          libavutil-dev \
-          libunicorn-dev \
-          libx11-dev
-        sudo apt-get install -y libstorm-dev || true
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            cmake \
+            build-essential \
+            pkg-config \
+            libsdl2-dev \
+            libglew-dev \
+            libglm-dev \
+            libssl-dev \
+            zlib1g-dev \
+            libvulkan-dev \
+            vulkan-tools \
+            glslc \
+            libavformat-dev \
+            libavcodec-dev \
+            libswscale-dev \
+            libavutil-dev \
+            libunicorn-dev \
+            libx11-dev
+          sudo apt-get install -y libstorm-dev || true
 
-    - name: Fetch AMD FSR2 SDK
-      run: |
-        rm -rf extern/FidelityFX-FSR2
-        git clone --depth 1 --branch "${WOWEE_AMD_FSR2_REF}" "${WOWEE_AMD_FSR2_REPO}" extern/FidelityFX-FSR2
-        rm -rf extern/FidelityFX-SDK
-        git clone --depth 1 --branch "${WOWEE_FFX_SDK_REF}" "${WOWEE_FFX_SDK_REPO}" extern/FidelityFX-SDK
+      - name: Fetch AMD FSR2 SDK
+        run: |
+          rm -rf extern/FidelityFX-FSR2
+          git clone --depth 1 --branch "${WOWEE_AMD_FSR2_REF}" "${WOWEE_AMD_FSR2_REPO}" extern/FidelityFX-FSR2
+          rm -rf extern/FidelityFX-SDK
+          git clone --depth 1 --branch "${WOWEE_FFX_SDK_REF}" "${WOWEE_FFX_SDK_REPO}" extern/FidelityFX-SDK
 
-    - name: Check AMD FSR2 Vulkan permutation headers
-      run: |
-        set -euo pipefail
-        SDK_DIR="$PWD/extern/FidelityFX-FSR2"
-        OUT_DIR="$SDK_DIR/src/ffx-fsr2-api/vk/shaders"
-        if [ -f "$OUT_DIR/ffx_fsr2_accumulate_pass_permutations.h" ]; then
-          echo "AMD FSR2 Vulkan permutation headers detected."
-        else
-          echo "AMD FSR2 Vulkan permutation headers not found in SDK checkout."
-          echo "WoWee CMake will bootstrap vendored headers."
-        fi
+      - name: Check AMD FSR2 Vulkan permutation headers
+        run: |
+          set -euo pipefail
+          SDK_DIR="$PWD/extern/FidelityFX-FSR2"
+          OUT_DIR="$SDK_DIR/src/ffx-fsr2-api/vk/shaders"
+          if [ -f "$OUT_DIR/ffx_fsr2_accumulate_pass_permutations.h" ]; then
+            echo "AMD FSR2 Vulkan permutation headers detected."
+          else
+            echo "AMD FSR2 Vulkan permutation headers not found in SDK checkout."
+            echo "WoWee CMake will bootstrap vendored headers."
+          fi
 
-    - name: Check FidelityFX-SDK Kits framegen headers
-      run: |
-        set -euo pipefail
-        KITS_DIR="$PWD/extern/FidelityFX-SDK/Kits/FidelityFX"
-        test -f "$KITS_DIR/upscalers/fsr3/include/ffx_fsr3upscaler.h"
-        test -f "$KITS_DIR/framegeneration/fsr3/include/ffx_frameinterpolation.h"
-        test -f "$KITS_DIR/framegeneration/fsr3/include/ffx_opticalflow.h"
-        test -f "$KITS_DIR/backend/vk/ffx_vk.h"
-        echo "FidelityFX-SDK Kits framegen headers detected."
+      - name: Check FidelityFX-SDK Kits framegen headers
+        run: |
+          set -euo pipefail
+          KITS_DIR="$PWD/extern/FidelityFX-SDK/Kits/FidelityFX"
+          test -f "$KITS_DIR/upscalers/fsr3/include/ffx_fsr3upscaler.h"
+          test -f "$KITS_DIR/framegeneration/fsr3/include/ffx_frameinterpolation.h"
+          test -f "$KITS_DIR/framegeneration/fsr3/include/ffx_opticalflow.h"
+          test -f "$KITS_DIR/backend/vk/ffx_vk.h"
+          echo "FidelityFX-SDK Kits framegen headers detected."
 
-    - name: Configure (AMD ON)
-      run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DWOWEE_ENABLE_AMD_FSR2=ON -DWOWEE_BUILD_TESTS=ON
+      - name: Configure (AMD ON)
+        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DWOWEE_ENABLE_AMD_FSR2=ON
 
-    - name: Assert AMD FSR2 target
-      run: cmake --build build --target wowee_fsr2_amd_vk --parallel ${{ matrix.build_jobs }}
+      - name: Assert AMD FSR2 target
+        run: cmake --build build --target wowee_fsr2_amd_vk --parallel $(nproc)
 
-    - name: Assert AMD FSR3 framegen probe target (if present)
-      run: |
-        set -euo pipefail
-        if cmake --build build --target help | grep -q 'wowee_fsr3_framegen_amd_vk_probe'; then
-          cmake --build build --target wowee_fsr3_framegen_amd_vk_probe --parallel ${{ matrix.build_jobs }}
-        else
-          echo "FSR3 framegen probe target not generated for this SDK layout; continuing."
-        fi
+      - name: Assert AMD FSR3 framegen probe target (if present)
+        run: |
+          set -euo pipefail
+          if cmake --build build --target help | grep -q 'wowee_fsr3_framegen_amd_vk_probe'; then
+            cmake --build build --target wowee_fsr3_framegen_amd_vk_probe --parallel $(nproc)
+          else
+            echo "FSR3 framegen probe target not generated for this SDK layout; continuing."
+          fi
 
-    - name: Build
-      run: cmake --build build --parallel ${{ matrix.build_jobs }}
+      - name: Build
+        run: cmake --build build --parallel $(nproc)
 
-    - name: Run tests
-      run: cd build && ctest --output-on-failure
+      - name: Package (DEB)
+        run: cd build && cpack -G DEB
 
-    - name: Package (DEB)
-      run: cd build && cpack -G DEB
-
-    - name: Upload DEB
-      uses: actions/upload-artifact@v4
-      with:
-        name: wowee-linux-${{ matrix.arch }}-deb
-        path: build/wowee-*.deb
-        if-no-files-found: error
+      - name: Upload DEB
+        uses: actions/upload-artifact@v4
+        with:
+          name: wowee-linux-${{ matrix.arch }}-deb
+          path: build/wowee-*.deb
+          if-no-files-found: error
 
   build-macos:
     name: Build (macOS ${{ matrix.arch }})
@@ -133,379 +127,311 @@ jobs:
       fail-fast: false
       matrix:
         include:
-        - arch: arm64
-          runner: macos-15
+          - arch: arm64
+            runner: macos-15
 
     steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        submodules: true
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: true
 
-    - name: Install dependencies
-      run: |
-        brew install cmake pkg-config sdl2 glew glm openssl@3 zlib ffmpeg unicorn \
-          stormlib vulkan-loader vulkan-headers shaderc dylibbundler || true
-        # dylibbundler may not be in all brew mirrors; install separately to not block others
-        brew install dylibbundler 2>/dev/null || true
+      - name: Install dependencies
+        run: |
+          brew install cmake pkg-config sdl2 glew glm openssl@3 zlib ffmpeg unicorn \
+            stormlib vulkan-loader vulkan-headers shaderc dylibbundler || true
+          # dylibbundler may not be in all brew mirrors; install separately to not block others
+          brew install dylibbundler 2>/dev/null || true
 
-    - name: Fetch AMD FSR2 SDK
-      run: |
-        rm -rf extern/FidelityFX-FSR2
-        git clone --depth 1 --branch "${WOWEE_AMD_FSR2_REF}" "${WOWEE_AMD_FSR2_REPO}" extern/FidelityFX-FSR2
-        rm -rf extern/FidelityFX-SDK
-        git clone --depth 1 --branch "${WOWEE_FFX_SDK_REF}" "${WOWEE_FFX_SDK_REPO}" extern/FidelityFX-SDK
+      - name: Fetch AMD FSR2 SDK
+        run: |
+          rm -rf extern/FidelityFX-FSR2
+          git clone --depth 1 --branch "${WOWEE_AMD_FSR2_REF}" "${WOWEE_AMD_FSR2_REPO}" extern/FidelityFX-FSR2
+          rm -rf extern/FidelityFX-SDK
+          git clone --depth 1 --branch "${WOWEE_FFX_SDK_REF}" "${WOWEE_FFX_SDK_REPO}" extern/FidelityFX-SDK
 
-    - name: Configure
-      run: |
-        BREW=$(brew --prefix)
-        export PKG_CONFIG_PATH="$BREW/lib/pkgconfig:$(brew --prefix ffmpeg)/lib/pkgconfig:$(brew --prefix openssl@3)/lib/pkgconfig:$(brew --prefix vulkan-loader)/lib/pkgconfig:$(brew --prefix shaderc)/lib/pkgconfig"
-        cmake -S . -B build \
-          -DCMAKE_BUILD_TYPE=Release \
-          -DCMAKE_PREFIX_PATH="$BREW" \
-          -DOPENSSL_ROOT_DIR="$(brew --prefix openssl@3)" \
-          -DWOWEE_ENABLE_AMD_FSR2=ON \
-          -DWOWEE_BUILD_TESTS=ON
+      - name: Configure
+        run: |
+          BREW=$(brew --prefix)
+          export PKG_CONFIG_PATH="$BREW/lib/pkgconfig:$(brew --prefix ffmpeg)/lib/pkgconfig:$(brew --prefix openssl@3)/lib/pkgconfig:$(brew --prefix vulkan-loader)/lib/pkgconfig:$(brew --prefix shaderc)/lib/pkgconfig"
+          cmake -S . -B build \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_PREFIX_PATH="$BREW" \
+            -DOPENSSL_ROOT_DIR="$(brew --prefix openssl@3)" \
+            -DWOWEE_ENABLE_AMD_FSR2=ON
 
-    - name: Assert AMD FSR2 target
-      run: cmake --build build --target wowee_fsr2_amd_vk --parallel $(sysctl -n hw.logicalcpu)
+      - name: Assert AMD FSR2 target
+        run: cmake --build build --target wowee_fsr2_amd_vk --parallel $(sysctl -n hw.logicalcpu)
 
-    - name: Assert AMD FSR3 framegen probe target (if present)
-      run: |
-        if cmake --build build --target help | grep -q 'wowee_fsr3_framegen_amd_vk_probe'; then
-          cmake --build build --target wowee_fsr3_framegen_amd_vk_probe --parallel $(sysctl -n hw.logicalcpu)
-        else
-          echo "FSR3 framegen probe target not generated for this SDK layout; continuing."
-        fi
-
-    - name: Build
-      run: cmake --build build --parallel $(sysctl -n hw.logicalcpu)
-
-    - name: Run tests
-      run: cd build && ctest --output-on-failure
-
-    - name: Create .app bundle
-      run: |
-        mkdir -p Wowee.app/Contents/{MacOS,Frameworks,Resources}
-
-        # Wrapper launch script — cd to MacOS/ so ./assets/ resolves correctly
-        printf '#!/bin/bash\ncd "$(dirname "$0")"\nexec ./wowee_bin "$@"\n' \
-          > Wowee.app/Contents/MacOS/wowee
-        chmod +x Wowee.app/Contents/MacOS/wowee
-
-        # Actual binary
-        cp build/bin/wowee Wowee.app/Contents/MacOS/wowee_bin
-
-        # Assets (exclude proprietary music)
-        rsync -a --exclude='Original Music' build/bin/assets/ \
-          Wowee.app/Contents/MacOS/assets/
-
-        # Bundle dylibs (if dylibbundler available)
-        if command -v dylibbundler &>/dev/null; then
-          dylibbundler -od -b \
-            -x Wowee.app/Contents/MacOS/wowee_bin \
-            -d Wowee.app/Contents/Frameworks/ \
-            -p @executable_path/../Frameworks/
-        fi
-
-        # dylibbundler may miss Homebrew's Vulkan loader on some runner images.
-        # Copy all vulkan-loader dylib names so wowee_bin can resolve whichever
-        # install_name it was linked against (e.g. libvulkan.1.4.341.dylib).
-        VULKAN_LIB_DIR="$(brew --prefix vulkan-loader)/lib"
-        for lib in "${VULKAN_LIB_DIR}"/libvulkan*.dylib; do
-          [ -e "${lib}" ] || continue
-          cp -f "${lib}" Wowee.app/Contents/Frameworks/
-        done
-
-        if ! ls Wowee.app/Contents/Frameworks/libvulkan*.dylib >/dev/null 2>&1; then
-          echo "Missing Vulkan loader dylib(s) in app bundle Frameworks/" >&2
-          exit 1
-        fi
-
-        # dylibbundler may miss Homebrew's OpenSSL on some runner images.
-        # Copy libssl and libcrypto so wowee_bin can resolve them at runtime.
-        OPENSSL_LIB_DIR="$(brew --prefix openssl@3)/lib"
-        for lib in "${OPENSSL_LIB_DIR}"/libssl*.dylib "${OPENSSL_LIB_DIR}"/libcrypto*.dylib; do
-          [ -e "${lib}" ] || continue
-          cp -f "${lib}" Wowee.app/Contents/Frameworks/
-        done
-
-        if ! ls Wowee.app/Contents/Frameworks/libssl*.dylib >/dev/null 2>&1; then
-          echo "Missing OpenSSL libssl dylib(s) in app bundle Frameworks/" >&2
-          exit 1
-        fi
-
-        # Info.plist
-        cat > Wowee.app/Contents/Info.plist << 'EOF'
-        <?xml version="1.0" encoding="UTF-8"?>
-        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
-          "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-        <plist version="1.0"><dict>
-          <key>CFBundleExecutable</key><string>wowee</string>
-          <key>CFBundleIdentifier</key><string>com.wowee.app</string>
-          <key>CFBundleName</key><string>Wowee</string>
-          <key>CFBundleVersion</key><string>1.0.0</string>
-          <key>CFBundleShortVersionString</key><string>1.0.0</string>
-          <key>CFBundlePackageType</key><string>APPL</string>
-        </dict></plist>
-        EOF
-
-        # Ad-hoc codesign (allows running on the local machine)
-        codesign --force --deep --sign - Wowee.app
-
-    - name: Verify bundled dylibs
-      run: |
-        set -euo pipefail
-        echo "=== dylib references for wowee_bin ==="
-        otool -L Wowee.app/Contents/MacOS/wowee_bin
-
-        # Every non-system dylib referenced by the binary must resolve inside
-        # the bundle.  System paths (/usr/lib, /System) are always present on
-        # macOS and don't need bundling.
-        missing=0
-        while IFS= read -r dep; do
-          # Strip leading whitespace and version info: "	/path/to/lib.dylib (compat ...)"
-          path=$(echo "$dep" | sed 's/^[[:space:]]*//;s/ (compat.*//')
-          case "$path" in
-            /usr/lib/*|/System/*|@executable_path/*|@rpath/*) continue ;;
-          esac
-          # Resolve @loader_path relative to the binary
-          resolved="${path/#@loader_path/Wowee.app/Contents/MacOS}"
-          if [ ! -f "$resolved" ]; then
-            basename=$(basename "$path")
-            if [ ! -f "Wowee.app/Contents/Frameworks/$basename" ]; then
-              echo "ERROR: unbundled dylib: $path" >&2
-              missing=$((missing + 1))
-            fi
+      - name: Assert AMD FSR3 framegen probe target (if present)
+        run: |
+          if cmake --build build --target help | grep -q 'wowee_fsr3_framegen_amd_vk_probe'; then
+            cmake --build build --target wowee_fsr3_framegen_amd_vk_probe --parallel $(sysctl -n hw.logicalcpu)
+          else
+            echo "FSR3 framegen probe target not generated for this SDK layout; continuing."
           fi
-        done < <(otool -L Wowee.app/Contents/MacOS/wowee_bin | tail -n +2)
 
-        if [ "$missing" -gt 0 ]; then
-          echo ""
-          echo "=== Frameworks directory ==="
-          ls -la Wowee.app/Contents/Frameworks/
-          echo ""
-          echo "FAIL: $missing dylib(s) missing from app bundle" >&2
-          exit 1
-        fi
-        echo "All non-system dylibs are bundled."
+      - name: Build
+        run: cmake --build build --parallel $(sysctl -n hw.logicalcpu)
 
-    - name: Create DMG
-      run: |
-        set -euo pipefail
-        rm -f Wowee.dmg
-        # CI runners can occasionally leave a mounted volume around; detach if present.
-        if [ -d "/Volumes/Wowee" ]; then
-          hdiutil detach "/Volumes/Wowee" -force || true
-          sleep 2
-        fi
+      - name: Create .app bundle
+        run: |
+          mkdir -p Wowee.app/Contents/{MacOS,Frameworks,Resources}
 
-        ok=0
-        for attempt in 1 2 3 4 5; do
-          if hdiutil create -volname Wowee -srcfolder Wowee.app -ov -format UDZO Wowee.dmg; then
-            ok=1
-            break
+          # Wrapper launch script — cd to MacOS/ so ./assets/ resolves correctly
+          printf '#!/bin/bash\ncd "$(dirname "$0")"\nexec ./wowee_bin "$@"\n' \
+            > Wowee.app/Contents/MacOS/wowee
+          chmod +x Wowee.app/Contents/MacOS/wowee
+
+          # Actual binary
+          cp build/bin/wowee Wowee.app/Contents/MacOS/wowee_bin
+
+          # Assets (exclude proprietary music)
+          rsync -a --exclude='Original Music' build/bin/assets/ \
+            Wowee.app/Contents/MacOS/assets/
+
+          # Bundle dylibs (if dylibbundler available)
+          if command -v dylibbundler &>/dev/null; then
+            dylibbundler -od -b \
+              -x Wowee.app/Contents/MacOS/wowee_bin \
+              -d Wowee.app/Contents/Frameworks/ \
+              -p @executable_path/../Frameworks/
           fi
-          echo "hdiutil create failed on attempt ${attempt}; retrying..."
+
+          # Info.plist
+          cat > Wowee.app/Contents/Info.plist << 'EOF'
+          <?xml version="1.0" encoding="UTF-8"?>
+          <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+            "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+          <plist version="1.0"><dict>
+            <key>CFBundleExecutable</key><string>wowee</string>
+            <key>CFBundleIdentifier</key><string>com.wowee.app</string>
+            <key>CFBundleName</key><string>Wowee</string>
+            <key>CFBundleVersion</key><string>1.0.0</string>
+            <key>CFBundleShortVersionString</key><string>1.0.0</string>
+            <key>CFBundlePackageType</key><string>APPL</string>
+          </dict></plist>
+          EOF
+
+          # Ad-hoc codesign (allows running on the local machine)
+          codesign --force --deep --sign - Wowee.app
+
+      - name: Create DMG
+        run: |
+          set -euo pipefail
+          rm -f Wowee.dmg
+          # CI runners can occasionally leave a mounted volume around; detach if present.
           if [ -d "/Volumes/Wowee" ]; then
             hdiutil detach "/Volumes/Wowee" -force || true
+            sleep 2
           fi
-          sleep 3
-        done
 
-        if [ "$ok" -ne 1 ] || [ ! -f Wowee.dmg ]; then
-          echo "Failed to create Wowee.dmg after retries."
-          exit 1
-        fi
+          ok=0
+          for attempt in 1 2 3 4 5; do
+            if hdiutil create -volname Wowee -srcfolder Wowee.app -ov -format UDZO Wowee.dmg; then
+              ok=1
+              break
+            fi
+            echo "hdiutil create failed on attempt ${attempt}; retrying..."
+            if [ -d "/Volumes/Wowee" ]; then
+              hdiutil detach "/Volumes/Wowee" -force || true
+            fi
+            sleep 3
+          done
 
-    - name: Upload DMG
-      uses: actions/upload-artifact@v4
-      with:
-        name: wowee-macos-${{ matrix.arch }}-dmg
-        path: Wowee.dmg
-        if-no-files-found: error
+          if [ "$ok" -ne 1 ] || [ ! -f Wowee.dmg ]; then
+            echo "Failed to create Wowee.dmg after retries."
+            exit 1
+          fi
+
+      - name: Upload DMG
+        uses: actions/upload-artifact@v4
+        with:
+          name: wowee-macos-${{ matrix.arch }}-dmg
+          path: Wowee.dmg
+          if-no-files-found: error
 
   build-windows-arm:
     name: Build (windows-arm64)
     runs-on: windows-11-arm
     steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        submodules: true
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: true
 
-    - name: Set up MSYS2
-      uses: msys2/setup-msys2@v2
-      with:
-        msystem: CLANGARM64
-        update: true
-        install: >-
-          mingw-w64-clang-aarch64-cmake
-          mingw-w64-clang-aarch64-clang
-          mingw-w64-clang-aarch64-ninja
-          mingw-w64-clang-aarch64-pkgconf
-          mingw-w64-clang-aarch64-SDL2
-          mingw-w64-clang-aarch64-glew
-          mingw-w64-clang-aarch64-glm
-          mingw-w64-clang-aarch64-openssl
-          mingw-w64-clang-aarch64-zlib
-          mingw-w64-clang-aarch64-ffmpeg
-          mingw-w64-clang-aarch64-unicorn
-          mingw-w64-clang-aarch64-vulkan-loader
-          mingw-w64-clang-aarch64-vulkan-headers
-          mingw-w64-clang-aarch64-shaderc
-          git
+      - name: Set up MSYS2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: CLANGARM64
+          update: true
+          install: >-
+            mingw-w64-clang-aarch64-cmake
+            mingw-w64-clang-aarch64-clang
+            mingw-w64-clang-aarch64-ninja
+            mingw-w64-clang-aarch64-pkgconf
+            mingw-w64-clang-aarch64-SDL2
+            mingw-w64-clang-aarch64-glew
+            mingw-w64-clang-aarch64-glm
+            mingw-w64-clang-aarch64-openssl
+            mingw-w64-clang-aarch64-zlib
+            mingw-w64-clang-aarch64-ffmpeg
+            mingw-w64-clang-aarch64-unicorn
+            mingw-w64-clang-aarch64-vulkan-loader
+            mingw-w64-clang-aarch64-vulkan-headers
+            mingw-w64-clang-aarch64-shaderc
+            git
 
-    - name: Build StormLib from source
-      shell: msys2 {0}
-      run: |
-        git clone --depth 1 https://github.com/ladislav-zezula/StormLib.git /tmp/StormLib
-        # Disable x86 inline asm in bundled libtomcrypt (bswapl/movl) —
-        # __MINGW32__ is defined on CLANGARM64 which incorrectly enables x86 asm
-        cmake -S /tmp/StormLib -B /tmp/StormLib/build -G Ninja \
-          -DCMAKE_BUILD_TYPE=Release \
-          -DCMAKE_INSTALL_PREFIX="$MINGW_PREFIX" \
-          -DBUILD_SHARED_LIBS=OFF \
-          -DCMAKE_C_FLAGS="-DLTC_NO_BSWAP" \
-          -DCMAKE_CXX_FLAGS="-DLTC_NO_BSWAP"
-        cmake --build /tmp/StormLib/build --parallel $(nproc)
-        cmake --install /tmp/StormLib/build
+      - name: Build StormLib from source
+        shell: msys2 {0}
+        run: |
+          git clone --depth 1 https://github.com/ladislav-zezula/StormLib.git /tmp/StormLib
+          # Disable x86 inline asm in bundled libtomcrypt (bswapl/movl) —
+          # __MINGW32__ is defined on CLANGARM64 which incorrectly enables x86 asm
+          cmake -S /tmp/StormLib -B /tmp/StormLib/build -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_INSTALL_PREFIX="$MINGW_PREFIX" \
+            -DBUILD_SHARED_LIBS=OFF \
+            -DCMAKE_C_FLAGS="-DLTC_NO_BSWAP" \
+            -DCMAKE_CXX_FLAGS="-DLTC_NO_BSWAP"
+          cmake --build /tmp/StormLib/build --parallel $(nproc)
+          cmake --install /tmp/StormLib/build
 
-    - name: Fetch AMD FSR2 SDK
-      shell: msys2 {0}
-      run: |
-        rm -rf extern/FidelityFX-FSR2
-        git clone --depth 1 --branch "${WOWEE_AMD_FSR2_REF}" "${WOWEE_AMD_FSR2_REPO}" extern/FidelityFX-FSR2
-        rm -rf extern/FidelityFX-SDK
-        git clone --depth 1 --branch "${WOWEE_FFX_SDK_REF}" "${WOWEE_FFX_SDK_REPO}" extern/FidelityFX-SDK
+      - name: Fetch AMD FSR2 SDK
+        shell: msys2 {0}
+        run: |
+          rm -rf extern/FidelityFX-FSR2
+          git clone --depth 1 --branch "${WOWEE_AMD_FSR2_REF}" "${WOWEE_AMD_FSR2_REPO}" extern/FidelityFX-FSR2
+          rm -rf extern/FidelityFX-SDK
+          git clone --depth 1 --branch "${WOWEE_FFX_SDK_REF}" "${WOWEE_FFX_SDK_REPO}" extern/FidelityFX-SDK
 
-    - name: Configure
-      shell: msys2 {0}
-      run: cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -DWOWEE_ENABLE_AMD_FSR2=ON
+      - name: Configure
+        shell: msys2 {0}
+        run: cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -DWOWEE_ENABLE_AMD_FSR2=ON
 
-    - name: Assert AMD FSR2 target
-      shell: msys2 {0}
-      run: cmake --build build --target wowee_fsr2_amd_vk --parallel $(nproc)
+      - name: Assert AMD FSR2 target
+        shell: msys2 {0}
+        run: cmake --build build --target wowee_fsr2_amd_vk --parallel $(nproc)
 
-    - name: Assert AMD FSR3 framegen probe target (if present)
-      shell: msys2 {0}
-      run: |
-        if cmake --build build --target help | grep -q 'wowee_fsr3_framegen_amd_vk_probe'; then
-          cmake --build build --target wowee_fsr3_framegen_amd_vk_probe --parallel $(nproc)
-        else
-          echo "FSR3 framegen probe target not generated for this SDK layout; continuing."
-        fi
+      - name: Assert AMD FSR3 framegen probe target (if present)
+        shell: msys2 {0}
+        run: |
+          if cmake --build build --target help | grep -q 'wowee_fsr3_framegen_amd_vk_probe'; then
+            cmake --build build --target wowee_fsr3_framegen_amd_vk_probe --parallel $(nproc)
+          else
+            echo "FSR3 framegen probe target not generated for this SDK layout; continuing."
+          fi
 
-    - name: Build
-      shell: msys2 {0}
-      run: cmake --build build --parallel $(nproc)
+      - name: Build
+        shell: msys2 {0}
+        run: cmake --build build --parallel $(nproc)
 
-    - name: Bundle DLLs
-      shell: msys2 {0}
-      run: |
-        ldd build/bin/wowee.exe \
-          | awk '/=> \// { print $3 }' \
-          | grep -iv '^/c/Windows' \
-          | xargs -I{} sh -c 'cp -n "{}" build/bin/ 2>/dev/null || true'
+      - name: Bundle DLLs
+        shell: msys2 {0}
+        run: |
+          ldd build/bin/wowee.exe \
+            | awk '/=> \// { print $3 }' \
+            | grep -iv '^/c/Windows' \
+            | xargs -I{} sh -c 'cp -n "{}" build/bin/ 2>/dev/null || true'
 
-    - name: Package (ZIP)
-      shell: msys2 {0}
-      run: cd build && cpack -G ZIP
+      - name: Package (ZIP)
+        shell: msys2 {0}
+        run: cd build && cpack -G ZIP
 
-    - name: Upload ZIP
-      uses: actions/upload-artifact@v4
-      with:
-        name: wowee-windows-arm64-zip
-        path: build/wowee-*.zip
-        if-no-files-found: error
+      - name: Upload ZIP
+        uses: actions/upload-artifact@v4
+        with:
+          name: wowee-windows-arm64-zip
+          path: build/wowee-*.zip
+          if-no-files-found: error
 
   build-windows:
     name: Build (windows-x86-64)
     runs-on: windows-latest
     steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        submodules: true
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: true
 
-    - name: Set up MSYS2
-      uses: msys2/setup-msys2@v2
-      with:
-        msystem: MINGW64
-        update: false
-        install: >-
-          mingw-w64-x86_64-cmake
-          mingw-w64-x86_64-gcc
-          mingw-w64-x86_64-ninja
-          mingw-w64-x86_64-pkgconf
-          mingw-w64-x86_64-SDL2
-          mingw-w64-x86_64-glew
-          mingw-w64-x86_64-glm
-          mingw-w64-x86_64-openssl
-          mingw-w64-x86_64-zlib
-          mingw-w64-x86_64-ffmpeg
-          mingw-w64-x86_64-unicorn
-          mingw-w64-x86_64-vulkan-loader
-          mingw-w64-x86_64-vulkan-headers
-          mingw-w64-x86_64-shaderc
-          mingw-w64-x86_64-nsis
-          git
+      - name: Set up MSYS2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: MINGW64
+          update: false
+          install: >-
+            mingw-w64-x86_64-cmake
+            mingw-w64-x86_64-gcc
+            mingw-w64-x86_64-ninja
+            mingw-w64-x86_64-pkgconf
+            mingw-w64-x86_64-SDL2
+            mingw-w64-x86_64-glew
+            mingw-w64-x86_64-glm
+            mingw-w64-x86_64-openssl
+            mingw-w64-x86_64-zlib
+            mingw-w64-x86_64-ffmpeg
+            mingw-w64-x86_64-unicorn
+            mingw-w64-x86_64-vulkan-loader
+            mingw-w64-x86_64-vulkan-headers
+            mingw-w64-x86_64-shaderc
+            mingw-w64-x86_64-nsis
+            git
 
-    - name: Build StormLib from source
-      shell: msys2 {0}
-      run: |
-        git clone --depth 1 https://github.com/ladislav-zezula/StormLib.git /tmp/StormLib
-        cmake -S /tmp/StormLib -B /tmp/StormLib/build -G Ninja \
-          -DCMAKE_BUILD_TYPE=Release \
-          -DCMAKE_INSTALL_PREFIX="$MINGW_PREFIX" \
-          -DBUILD_SHARED_LIBS=OFF
-        cmake --build /tmp/StormLib/build --parallel $(nproc)
-        cmake --install /tmp/StormLib/build
+      - name: Build StormLib from source
+        shell: msys2 {0}
+        run: |
+          git clone --depth 1 https://github.com/ladislav-zezula/StormLib.git /tmp/StormLib
+          cmake -S /tmp/StormLib -B /tmp/StormLib/build -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_INSTALL_PREFIX="$MINGW_PREFIX" \
+            -DBUILD_SHARED_LIBS=OFF
+          cmake --build /tmp/StormLib/build --parallel $(nproc)
+          cmake --install /tmp/StormLib/build
 
-    - name: Fetch AMD FSR2 SDK
-      shell: msys2 {0}
-      run: |
-        rm -rf extern/FidelityFX-FSR2
-        git clone --depth 1 --branch "${WOWEE_AMD_FSR2_REF}" "${WOWEE_AMD_FSR2_REPO}" extern/FidelityFX-FSR2
-        rm -rf extern/FidelityFX-SDK
-        git clone --depth 1 --branch "${WOWEE_FFX_SDK_REF}" "${WOWEE_FFX_SDK_REPO}" extern/FidelityFX-SDK
+      - name: Fetch AMD FSR2 SDK
+        shell: msys2 {0}
+        run: |
+          rm -rf extern/FidelityFX-FSR2
+          git clone --depth 1 --branch "${WOWEE_AMD_FSR2_REF}" "${WOWEE_AMD_FSR2_REPO}" extern/FidelityFX-FSR2
+          rm -rf extern/FidelityFX-SDK
+          git clone --depth 1 --branch "${WOWEE_FFX_SDK_REF}" "${WOWEE_FFX_SDK_REPO}" extern/FidelityFX-SDK
 
-    - name: Configure
-      shell: msys2 {0}
-      run: cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -DWOWEE_ENABLE_AMD_FSR2=ON
+      - name: Configure
+        shell: msys2 {0}
+        run: cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -DWOWEE_ENABLE_AMD_FSR2=ON
 
-    - name: Assert AMD FSR2 target
-      shell: msys2 {0}
-      run: cmake --build build --target wowee_fsr2_amd_vk --parallel $(nproc)
+      - name: Assert AMD FSR2 target
+        shell: msys2 {0}
+        run: cmake --build build --target wowee_fsr2_amd_vk --parallel $(nproc)
 
-    - name: Assert AMD FSR3 framegen probe target (if present)
-      shell: msys2 {0}
-      run: |
-        if cmake --build build --target help | grep -q 'wowee_fsr3_framegen_amd_vk_probe'; then
-          cmake --build build --target wowee_fsr3_framegen_amd_vk_probe --parallel $(nproc)
-        else
-          echo "FSR3 framegen probe target not generated for this SDK layout; continuing."
-        fi
+      - name: Assert AMD FSR3 framegen probe target (if present)
+        shell: msys2 {0}
+        run: |
+          if cmake --build build --target help | grep -q 'wowee_fsr3_framegen_amd_vk_probe'; then
+            cmake --build build --target wowee_fsr3_framegen_amd_vk_probe --parallel $(nproc)
+          else
+            echo "FSR3 framegen probe target not generated for this SDK layout; continuing."
+          fi
 
-    - name: Build
-      shell: msys2 {0}
-      run: cmake --build build --parallel $(nproc)
+      - name: Build
+        shell: msys2 {0}
+        run: cmake --build build --parallel $(nproc)
 
-    - name: Bundle DLLs
-      shell: msys2 {0}
-      run: |
-        ldd build/bin/wowee.exe \
-          | awk '/=> \// { print $3 }' \
-          | grep -iv '^/c/Windows' \
-          | xargs -I{} sh -c 'cp -n "{}" build/bin/ 2>/dev/null || true'
+      - name: Bundle DLLs
+        shell: msys2 {0}
+        run: |
+          ldd build/bin/wowee.exe \
+            | awk '/=> \// { print $3 }' \
+            | grep -iv '^/c/Windows' \
+            | xargs -I{} sh -c 'cp -n "{}" build/bin/ 2>/dev/null || true'
 
-    - name: Package (NSIS)
-      shell: msys2 {0}
-      run: cd build && cpack -G NSIS
+      - name: Package (NSIS)
+        shell: msys2 {0}
+        run: cd build && cpack -G NSIS
 
-    - name: Upload installer
-      uses: actions/upload-artifact@v4
-      with:
-        name: wowee-windows-x86-64-installer
-        path: build/wowee-*.exe
-        if-no-files-found: error
+      - name: Upload installer
+        uses: actions/upload-artifact@v4
+        with:
+          name: wowee-windows-x86-64-installer
+          path: build/wowee-*.exe
+          if-no-files-found: error
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index c0b9ec23..0698607a 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -2,10 +2,7 @@ name: Release
 
 on:
   push:
-    tags: [ 'v*' ]
-
-env:
-  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
+    tags: ['v*']
 
 permissions:
   contents: write
@@ -18,257 +15,201 @@ jobs:
       fail-fast: false
       matrix:
         include:
-        - arch: x86-64
-          runner: ubuntu-24.04
-        - arch: arm64
-          runner: ubuntu-24.04-arm
+          - arch: x86-64
+            runner: ubuntu-24.04
+          - arch: arm64
+            runner: ubuntu-24.04-arm
 
     steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        submodules: true
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: true
 
-    - name: Cache apt packages
-      uses: actions/cache@v4
-      with:
-        path: /var/cache/apt/archives/*.deb
-        key: apt-${{ matrix.arch }}-${{ hashFiles('.github/workflows/release.yml') }}
-        restore-keys: apt-${{ matrix.arch }}-
+      - name: Cache apt packages
+        uses: actions/cache@v4
+        with:
+          path: /var/cache/apt/archives/*.deb
+          key: apt-${{ matrix.arch }}-${{ hashFiles('.github/workflows/release.yml') }}
+          restore-keys: apt-${{ matrix.arch }}-
 
-    - name: Install dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y \
-          cmake \
-          build-essential \
-          pkg-config \
-          libsdl2-dev \
-          libglew-dev \
-          libglm-dev \
-          libssl-dev \
-          zlib1g-dev \
-          libvulkan-dev \
-          vulkan-tools \
-          glslc \
-          libavformat-dev \
-          libavcodec-dev \
-          libswscale-dev \
-          libavutil-dev \
-          libunicorn-dev \
-          libx11-dev
-        sudo apt-get install -y libstorm-dev || true
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            cmake \
+            build-essential \
+            pkg-config \
+            libsdl2-dev \
+            libglew-dev \
+            libglm-dev \
+            libssl-dev \
+            zlib1g-dev \
+            libvulkan-dev \
+            vulkan-tools \
+            glslc \
+            libavformat-dev \
+            libavcodec-dev \
+            libswscale-dev \
+            libavutil-dev \
+            libunicorn-dev \
+            libx11-dev
+          sudo apt-get install -y libstorm-dev || true
 
-    - name: Configure
-      run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+      - name: Configure
+        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
 
-    - name: Verify Release Config
-      run: |
-        cmake -LA -N build | grep -E '^CMAKE_BUILD_TYPE:STRING=Release$'
+      - name: Verify Release Config
+        run: |
+          cmake -LA -N build | grep -E '^CMAKE_BUILD_TYPE:STRING=Release$'
 
-    - name: Build
-      run: cmake --build build --parallel $(nproc)
+      - name: Build
+        run: cmake --build build --parallel $(nproc)
 
-    - name: Package
-      run: |
-        TAG="${GITHUB_REF_NAME}"
-        STAGING="wowee-${TAG}-linux-${{ matrix.arch }}"
-        mkdir -p "${STAGING}"
+      - name: Package
+        run: |
+          TAG="${GITHUB_REF_NAME}"
+          STAGING="wowee-${TAG}-linux-${{ matrix.arch }}"
+          mkdir -p "${STAGING}"
 
-        # Binary
-        cp build/bin/wowee "${STAGING}/"
+          # Binary
+          cp build/bin/wowee "${STAGING}/"
 
-        # Asset extraction tool (if built — requires StormLib)
-        if [ -f build/bin/asset_extract ]; then
-          cp build/bin/asset_extract "${STAGING}/"
-        fi
+          # Asset extraction tool (if built — requires StormLib)
+          if [ -f build/bin/asset_extract ]; then
+            cp build/bin/asset_extract "${STAGING}/"
+          fi
 
-        # Extraction scripts and GUI
-        cp extract_assets.sh "${STAGING}/"
-        cp tools/asset_pipeline_gui.py "${STAGING}/"
+          # Extraction scripts and GUI
+          cp extract_assets.sh "${STAGING}/"
+          cp tools/asset_pipeline_gui.py "${STAGING}/"
 
-        # Assets (exclude proprietary music)
-        rsync -a --exclude='Original Music' build/bin/assets/ "${STAGING}/assets/"
+          # Assets (exclude proprietary music)
+          rsync -a --exclude='Original Music' build/bin/assets/ "${STAGING}/assets/"
 
-        # Data directory (git-tracked files only)
-        git ls-files Data/ | while read -r f; do
-          mkdir -p "${STAGING}/$(dirname "$f")"
-          cp "$f" "${STAGING}/$f"
-        done
+          # Data directory (git-tracked files only)
+          git ls-files Data/ | while read -r f; do
+            mkdir -p "${STAGING}/$(dirname "$f")"
+            cp "$f" "${STAGING}/$f"
+          done
 
-        tar czf "${STAGING}.tar.gz" "${STAGING}"
+          tar czf "${STAGING}.tar.gz" "${STAGING}"
 
-    - name: Upload artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: wowee-linux-${{ matrix.arch }}
-        path: wowee-*.tar.gz
-        if-no-files-found: error
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: wowee-linux-${{ matrix.arch }}
+          path: wowee-*.tar.gz
+          if-no-files-found: error
 
   build-macos:
     name: Build (macOS arm64)
     runs-on: macos-15
 
     steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        submodules: true
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: true
 
-    - name: Install dependencies
-      run: |
-        brew install cmake pkg-config sdl2 glew glm openssl@3 zlib ffmpeg unicorn \
-          stormlib vulkan-loader vulkan-headers shaderc dylibbundler || true
-        brew install dylibbundler 2>/dev/null || true
+      - name: Install dependencies
+        run: |
+          brew install cmake pkg-config sdl2 glew glm openssl@3 zlib ffmpeg unicorn \
+            stormlib vulkan-loader vulkan-headers shaderc dylibbundler || true
+          brew install dylibbundler 2>/dev/null || true
 
-    - name: Configure
-      run: |
-        BREW=$(brew --prefix)
-        export PKG_CONFIG_PATH="$BREW/lib/pkgconfig:$(brew --prefix ffmpeg)/lib/pkgconfig:$(brew --prefix openssl@3)/lib/pkgconfig:$(brew --prefix vulkan-loader)/lib/pkgconfig:$(brew --prefix shaderc)/lib/pkgconfig"
-        cmake -S . -B build \
-          -DCMAKE_BUILD_TYPE=Release \
-          -DCMAKE_PREFIX_PATH="$BREW" \
-          -DOPENSSL_ROOT_DIR="$(brew --prefix openssl@3)"
+      - name: Configure
+        run: |
+          BREW=$(brew --prefix)
+          export PKG_CONFIG_PATH="$BREW/lib/pkgconfig:$(brew --prefix ffmpeg)/lib/pkgconfig:$(brew --prefix openssl@3)/lib/pkgconfig:$(brew --prefix vulkan-loader)/lib/pkgconfig:$(brew --prefix shaderc)/lib/pkgconfig"
+          cmake -S . -B build \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_PREFIX_PATH="$BREW" \
+            -DOPENSSL_ROOT_DIR="$(brew --prefix openssl@3)"
 
-    - name: Verify Release Config
-      run: |
-        cmake -LA -N build | grep -E '^CMAKE_BUILD_TYPE:STRING=Release$'
+      - name: Verify Release Config
+        run: |
+          cmake -LA -N build | grep -E '^CMAKE_BUILD_TYPE:STRING=Release$'
 
-    - name: Build
-      run: cmake --build build --parallel $(sysctl -n hw.logicalcpu)
+      - name: Build
+        run: cmake --build build --parallel $(sysctl -n hw.logicalcpu)
 
-    - name: Create .app bundle
-      run: |
-        TAG="${GITHUB_REF_NAME}"
-        mkdir -p Wowee.app/Contents/{MacOS,Frameworks,Resources}
+      - name: Create .app bundle
+        run: |
+          TAG="${GITHUB_REF_NAME}"
+          mkdir -p Wowee.app/Contents/{MacOS,Frameworks,Resources}
 
-        # Wrapper launch script
-        printf '#!/bin/bash\ncd "$(dirname "$0")"\nexec ./wowee_bin "$@"\n' \
-          > Wowee.app/Contents/MacOS/wowee
-        chmod +x Wowee.app/Contents/MacOS/wowee
+          # Wrapper launch script
+          printf '#!/bin/bash\ncd "$(dirname "$0")"\nexec ./wowee_bin "$@"\n' \
+            > Wowee.app/Contents/MacOS/wowee
+          chmod +x Wowee.app/Contents/MacOS/wowee
 
-        # Actual binary
-        cp build/bin/wowee Wowee.app/Contents/MacOS/wowee_bin
+          # Actual binary
+          cp build/bin/wowee Wowee.app/Contents/MacOS/wowee_bin
 
-        # Asset extraction tool (if built — requires StormLib)
-        if [ -f build/bin/asset_extract ]; then
-          cp build/bin/asset_extract Wowee.app/Contents/MacOS/
-        fi
+          # Asset extraction tool (if built — requires StormLib)
+          if [ -f build/bin/asset_extract ]; then
+            cp build/bin/asset_extract Wowee.app/Contents/MacOS/
+          fi
 
-        # Extraction scripts and GUI
-        cp extract_assets.sh Wowee.app/Contents/MacOS/
-        cp tools/asset_pipeline_gui.py Wowee.app/Contents/MacOS/
+          # Extraction scripts and GUI
+          cp extract_assets.sh Wowee.app/Contents/MacOS/
+          cp tools/asset_pipeline_gui.py Wowee.app/Contents/MacOS/
 
-        # Assets (exclude proprietary music)
-        rsync -a --exclude='Original Music' build/bin/assets/ \
-          Wowee.app/Contents/MacOS/assets/
+          # Assets (exclude proprietary music)
+          rsync -a --exclude='Original Music' build/bin/assets/ \
+            Wowee.app/Contents/MacOS/assets/
 
-        # Data directory (git-tracked files only)
-        git ls-files Data/ | while read -r f; do
-          mkdir -p "Wowee.app/Contents/MacOS/$(dirname "$f")"
-          cp "$f" "Wowee.app/Contents/MacOS/$f"
-        done
+          # Data directory (git-tracked files only)
+          git ls-files Data/ | while read -r f; do
+            mkdir -p "Wowee.app/Contents/MacOS/$(dirname "$f")"
+            cp "$f" "Wowee.app/Contents/MacOS/$f"
+          done
 
-        # Bundle dylibs
-        if command -v dylibbundler &>/dev/null; then
-          dylibbundler -od -b \
-            -x Wowee.app/Contents/MacOS/wowee_bin \
-            -d Wowee.app/Contents/Frameworks/ \
-            -p @executable_path/../Frameworks/
-          if [ -f Wowee.app/Contents/MacOS/asset_extract ]; then
+          # Bundle dylibs
+          if command -v dylibbundler &>/dev/null; then
             dylibbundler -od -b \
-              -x Wowee.app/Contents/MacOS/asset_extract \
+              -x Wowee.app/Contents/MacOS/wowee_bin \
               -d Wowee.app/Contents/Frameworks/ \
               -p @executable_path/../Frameworks/
-          fi
-        fi
-
-        # dylibbundler may miss Homebrew's Vulkan loader on some runner images.
-        # Copy all vulkan-loader dylib names so wowee_bin can resolve whichever
-        # install_name it was linked against (e.g. libvulkan.1.4.341.dylib).
-        VULKAN_LIB_DIR="$(brew --prefix vulkan-loader)/lib"
-        for lib in "${VULKAN_LIB_DIR}"/libvulkan*.dylib; do
-          [ -e "${lib}" ] || continue
-          cp -f "${lib}" Wowee.app/Contents/Frameworks/
-        done
-
-        if ! ls Wowee.app/Contents/Frameworks/libvulkan*.dylib >/dev/null 2>&1; then
-          echo "Missing Vulkan loader dylib(s) in app bundle Frameworks/" >&2
-          exit 1
-        fi
-
-        # dylibbundler may miss Homebrew's OpenSSL on some runner images.
-        # Copy libssl and libcrypto so wowee_bin can resolve them at runtime.
-        OPENSSL_LIB_DIR="$(brew --prefix openssl@3)/lib"
-        for lib in "${OPENSSL_LIB_DIR}"/libssl*.dylib "${OPENSSL_LIB_DIR}"/libcrypto*.dylib; do
-          [ -e "${lib}" ] || continue
-          cp -f "${lib}" Wowee.app/Contents/Frameworks/
-        done
-
-        if ! ls Wowee.app/Contents/Frameworks/libssl*.dylib >/dev/null 2>&1; then
-          echo "Missing OpenSSL libssl dylib(s) in app bundle Frameworks/" >&2
-          exit 1
-        fi
-
-        # Info.plist
-        cat > Wowee.app/Contents/Info.plist << EOF
-        <?xml version="1.0" encoding="UTF-8"?>
-        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
-          "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-        <plist version="1.0"><dict>
-          <key>CFBundleExecutable</key><string>wowee</string>
-          <key>CFBundleIdentifier</key><string>com.wowee.app</string>
-          <key>CFBundleName</key><string>Wowee</string>
-          <key>CFBundleVersion</key><string>${TAG}</string>
-          <key>CFBundleShortVersionString</key><string>${TAG}</string>
-          <key>CFBundlePackageType</key><string>APPL</string>
-        </dict></plist>
-        EOF
-
-        # Ad-hoc codesign
-        codesign --force --deep --sign - Wowee.app
-
-    - name: Verify bundled dylibs
-      run: |
-        set -euo pipefail
-        echo "=== dylib references for wowee_bin ==="
-        otool -L Wowee.app/Contents/MacOS/wowee_bin
-
-        missing=0
-        while IFS= read -r dep; do
-          path=$(echo "$dep" | sed 's/^[[:space:]]*//;s/ (compat.*//')
-          case "$path" in
-            /usr/lib/*|/System/*|@executable_path/*|@rpath/*) continue ;;
-          esac
-          resolved="${path/#@loader_path/Wowee.app/Contents/MacOS}"
-          if [ ! -f "$resolved" ]; then
-            basename=$(basename "$path")
-            if [ ! -f "Wowee.app/Contents/Frameworks/$basename" ]; then
-              echo "ERROR: unbundled dylib: $path" >&2
-              missing=$((missing + 1))
+            if [ -f Wowee.app/Contents/MacOS/asset_extract ]; then
+              dylibbundler -od -b \
+                -x Wowee.app/Contents/MacOS/asset_extract \
+                -d Wowee.app/Contents/Frameworks/ \
+                -p @executable_path/../Frameworks/
             fi
           fi
-        done < <(otool -L Wowee.app/Contents/MacOS/wowee_bin | tail -n +2)
 
-        if [ "$missing" -gt 0 ]; then
-          ls -la Wowee.app/Contents/Frameworks/
-          echo "FAIL: $missing dylib(s) missing from app bundle" >&2
-          exit 1
-        fi
-        echo "All non-system dylibs are bundled."
+          # Info.plist
+          cat > Wowee.app/Contents/Info.plist << EOF
+          <?xml version="1.0" encoding="UTF-8"?>
+          <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+            "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+          <plist version="1.0"><dict>
+            <key>CFBundleExecutable</key><string>wowee</string>
+            <key>CFBundleIdentifier</key><string>com.wowee.app</string>
+            <key>CFBundleName</key><string>Wowee</string>
+            <key>CFBundleVersion</key><string>${TAG}</string>
+            <key>CFBundleShortVersionString</key><string>${TAG}</string>
+            <key>CFBundlePackageType</key><string>APPL</string>
+          </dict></plist>
+          EOF
 
-    - name: Create DMG
-      run: |
-        TAG="${GITHUB_REF_NAME}"
-        hdiutil create -volname Wowee -srcfolder Wowee.app -ov -format UDZO \
-          "wowee-${TAG}-macos-arm64.dmg"
+          # Ad-hoc codesign
+          codesign --force --deep --sign - Wowee.app
 
-    - name: Upload artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: wowee-macos-arm64
-        path: wowee-*.dmg
-        if-no-files-found: error
+      - name: Create DMG
+        run: |
+          TAG="${GITHUB_REF_NAME}"
+          hdiutil create -volname Wowee -srcfolder Wowee.app -ov -format UDZO \
+            "wowee-${TAG}-macos-arm64.dmg"
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: wowee-macos-arm64
+          path: wowee-*.dmg
+          if-no-files-found: error
 
   build-windows:
     name: Build (windows-${{ matrix.arch }})
@@ -277,145 +218,159 @@ jobs:
       fail-fast: false
       matrix:
         include:
-        - arch: x86-64
-          runner: windows-latest
-          msystem: MINGW64
-          prefix: mingw-w64-x86_64
-        - arch: arm64
-          runner: windows-11-arm
-          msystem: CLANGARM64
-          prefix: mingw-w64-clang-aarch64
+          - arch: x86-64
+            runner: windows-latest
+            msystem: MINGW64
+            prefix: mingw-w64-x86_64
+          - arch: arm64
+            runner: windows-11-arm
+            msystem: CLANGARM64
+            prefix: mingw-w64-clang-aarch64
 
     steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        submodules: true
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: true
 
-    - name: Set up MSYS2
-      uses: msys2/setup-msys2@v2
-      with:
-        msystem: ${{ matrix.msystem }}
-        update: ${{ matrix.arch == 'arm64' }}
-        install: >-
-          ${{ matrix.prefix }}-cmake ${{ matrix.arch == 'x86-64' && format('{0}-gcc', matrix.prefix) || format('{0}-clang', matrix.prefix) }} ${{ matrix.prefix }}-ninja ${{ matrix.prefix }}-pkgconf ${{ matrix.prefix }}-SDL2 ${{ matrix.prefix }}-glew ${{ matrix.prefix }}-glm ${{ matrix.prefix }}-openssl ${{ matrix.prefix }}-zlib ${{ matrix.prefix }}-ffmpeg ${{ matrix.prefix }}-unicorn ${{ matrix.prefix }}-vulkan-loader ${{ matrix.prefix }}-vulkan-headers ${{ matrix.prefix }}-shaderc git
+      - name: Set up MSYS2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: ${{ matrix.msystem }}
+          update: ${{ matrix.arch == 'arm64' }}
+          install: >-
+            ${{ matrix.prefix }}-cmake
+            ${{ matrix.arch == 'x86-64' && format('{0}-gcc', matrix.prefix) || format('{0}-clang', matrix.prefix) }}
+            ${{ matrix.prefix }}-ninja
+            ${{ matrix.prefix }}-pkgconf
+            ${{ matrix.prefix }}-SDL2
+            ${{ matrix.prefix }}-glew
+            ${{ matrix.prefix }}-glm
+            ${{ matrix.prefix }}-openssl
+            ${{ matrix.prefix }}-zlib
+            ${{ matrix.prefix }}-ffmpeg
+            ${{ matrix.prefix }}-unicorn
+            ${{ matrix.prefix }}-vulkan-loader
+            ${{ matrix.prefix }}-vulkan-headers
+            ${{ matrix.prefix }}-shaderc
+            git
 
-    - name: Install optional packages
-      shell: msys2 {0}
-      run: |
-        pacman -S --noconfirm --needed zip
+      - name: Install optional packages
+        shell: msys2 {0}
+        run: |
+          pacman -S --noconfirm --needed zip
 
-    - name: Build StormLib from source
-      shell: msys2 {0}
-      run: |
-        git clone --depth 1 https://github.com/ladislav-zezula/StormLib.git /tmp/StormLib
-        # Disable x86 inline asm in bundled libtomcrypt (bswapl/movl) —
-        # __MINGW32__ is defined on CLANGARM64 which incorrectly enables x86 asm
-        cmake -S /tmp/StormLib -B /tmp/StormLib/build -G Ninja \
-          -DCMAKE_BUILD_TYPE=Release \
-          -DCMAKE_INSTALL_PREFIX="$MINGW_PREFIX" \
-          -DBUILD_SHARED_LIBS=OFF \
-          -DCMAKE_C_FLAGS="-DLTC_NO_BSWAP" \
-          -DCMAKE_CXX_FLAGS="-DLTC_NO_BSWAP"
-        cmake --build /tmp/StormLib/build --parallel $(nproc)
-        cmake --install /tmp/StormLib/build
+      - name: Build StormLib from source
+        shell: msys2 {0}
+        run: |
+          git clone --depth 1 https://github.com/ladislav-zezula/StormLib.git /tmp/StormLib
+          # Disable x86 inline asm in bundled libtomcrypt (bswapl/movl) —
+          # __MINGW32__ is defined on CLANGARM64 which incorrectly enables x86 asm
+          cmake -S /tmp/StormLib -B /tmp/StormLib/build -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_INSTALL_PREFIX="$MINGW_PREFIX" \
+            -DBUILD_SHARED_LIBS=OFF \
+            -DCMAKE_C_FLAGS="-DLTC_NO_BSWAP" \
+            -DCMAKE_CXX_FLAGS="-DLTC_NO_BSWAP"
+          cmake --build /tmp/StormLib/build --parallel $(nproc)
+          cmake --install /tmp/StormLib/build
 
-    - name: Configure
-      shell: msys2 {0}
-      run: cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
+      - name: Configure
+        shell: msys2 {0}
+        run: cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
 
-    - name: Verify Release Config
-      shell: msys2 {0}
-      run: |
-        cmake -LA -N build | grep -E '^CMAKE_BUILD_TYPE:STRING=Release$'
+      - name: Verify Release Config
+        shell: msys2 {0}
+        run: |
+          cmake -LA -N build | grep -E '^CMAKE_BUILD_TYPE:STRING=Release$'
 
-    - name: Build
-      shell: msys2 {0}
-      run: cmake --build build --parallel $(nproc)
+      - name: Build
+        shell: msys2 {0}
+        run: cmake --build build --parallel $(nproc)
 
-    - name: Bundle DLLs
-      shell: msys2 {0}
-      run: |
-        for exe in build/bin/wowee.exe build/bin/asset_extract.exe; do
-          [ -f "$exe" ] || continue
-          ldd "$exe" \
-            | awk '/=> \// { print $3 }' \
-            | grep -iv '^/c/Windows' \
-            | xargs -I{} sh -c 'cp -n "{}" build/bin/ 2>/dev/null || true'
-        done
+      - name: Bundle DLLs
+        shell: msys2 {0}
+        run: |
+          for exe in build/bin/wowee.exe build/bin/asset_extract.exe; do
+            [ -f "$exe" ] || continue
+            ldd "$exe" \
+              | awk '/=> \// { print $3 }' \
+              | grep -iv '^/c/Windows' \
+              | xargs -I{} sh -c 'cp -n "{}" build/bin/ 2>/dev/null || true'
+          done
 
-    - name: Package
-      shell: msys2 {0}
-      run: |
-        TAG="${GITHUB_REF_NAME}"
-        STAGING="wowee-${TAG}-windows-${{ matrix.arch }}"
-        mkdir -p "${STAGING}"
+      - name: Package
+        shell: msys2 {0}
+        run: |
+          TAG="${GITHUB_REF_NAME}"
+          STAGING="wowee-${TAG}-windows-${{ matrix.arch }}"
+          mkdir -p "${STAGING}"
 
-        # Binary and DLLs
-        cp build/bin/wowee.exe "${STAGING}/"
-        cp build/bin/*.dll "${STAGING}/" 2>/dev/null || true
+          # Binary and DLLs
+          cp build/bin/wowee.exe "${STAGING}/"
+          cp build/bin/*.dll "${STAGING}/" 2>/dev/null || true
 
-        # Asset extraction tool (if built — requires StormLib)
-        if [ -f build/bin/asset_extract.exe ]; then
-          cp build/bin/asset_extract.exe "${STAGING}/"
-        fi
+          # Asset extraction tool (if built — requires StormLib)
+          if [ -f build/bin/asset_extract.exe ]; then
+            cp build/bin/asset_extract.exe "${STAGING}/"
+          fi
 
-        # Extraction scripts and GUI
-        cp extract_assets.ps1 "${STAGING}/"
-        cp extract_assets.bat "${STAGING}/"
-        cp tools/asset_pipeline_gui.py "${STAGING}/"
+          # Extraction scripts and GUI
+          cp extract_assets.ps1 "${STAGING}/"
+          cp extract_assets.bat "${STAGING}/"
+          cp tools/asset_pipeline_gui.py "${STAGING}/"
 
-        # Assets (exclude proprietary music)
-        mkdir -p "${STAGING}/assets"
-        for d in build/bin/assets/*/; do
-          dirname="$(basename "$d")"
-          [ "$dirname" = "Original Music" ] && continue
-          cp -r "$d" "${STAGING}/assets/"
-        done
-        # Copy top-level asset files
-        cp build/bin/assets/* "${STAGING}/assets/" 2>/dev/null || true
+          # Assets (exclude proprietary music)
+          mkdir -p "${STAGING}/assets"
+          for d in build/bin/assets/*/; do
+            dirname="$(basename "$d")"
+            [ "$dirname" = "Original Music" ] && continue
+            cp -r "$d" "${STAGING}/assets/"
+          done
+          # Copy top-level asset files
+          cp build/bin/assets/* "${STAGING}/assets/" 2>/dev/null || true
 
-        # Data directory (git-tracked files only)
-        git ls-files Data/ | while read -r f; do
-          mkdir -p "${STAGING}/$(dirname "$f")"
-          cp "$f" "${STAGING}/$f"
-        done
+          # Data directory (git-tracked files only)
+          git ls-files Data/ | while read -r f; do
+            mkdir -p "${STAGING}/$(dirname "$f")"
+            cp "$f" "${STAGING}/$f"
+          done
 
-        # Create ZIP
-        zip -r "${STAGING}.zip" "${STAGING}"
+          # Create ZIP
+          zip -r "${STAGING}.zip" "${STAGING}"
 
-    - name: Upload artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: wowee-windows-${{ matrix.arch }}
-        path: wowee-*.zip
-        if-no-files-found: error
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: wowee-windows-${{ matrix.arch }}
+          path: wowee-*.zip
+          if-no-files-found: error
 
   release:
     name: Create Release
-    needs: [ build-linux, build-macos, build-windows ]
+    needs: [build-linux, build-macos, build-windows]
     runs-on: ubuntu-latest
 
     steps:
-    - name: Download all artifacts
-      uses: actions/download-artifact@v4
-      with:
-        path: artifacts/
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts/
 
-    - name: Create GitHub Release
-      env:
-        GH_TOKEN: ${{ github.token }}
-        GH_REPO: ${{ github.repository }}
-      run: |
-        TAG="${GITHUB_REF_NAME}"
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+          GH_REPO: ${{ github.repository }}
+        run: |
+          TAG="${GITHUB_REF_NAME}"
 
-        # Collect all release files
-        FILES=()
-        for f in artifacts/*/*; do
-          FILES+=("$f")
-        done
+          # Collect all release files
+          FILES=()
+          for f in artifacts/*/*; do
+            FILES+=("$f")
+          done
 
-        gh release create "${TAG}" \
-          --title "Wowee ${TAG}" \
-          --generate-notes \
-          "${FILES[@]}"
+          gh release create "${TAG}" \
+            --title "Wowee ${TAG}" \
+            --generate-notes \
+            "${FILES[@]}"
diff --git a/.github/workflows/security.yml b/.github/workflows/security.yml
index 6e5f63af..4709225b 100644
--- a/.github/workflows/security.yml
+++ b/.github/workflows/security.yml
@@ -7,9 +7,6 @@ on:
     branches: [master]
   workflow_dispatch:
 
-env:
-  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
-
 permissions:
   contents: read
 
diff --git a/.gitignore b/.gitignore
index 7df4f225..4ddf59ab 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,5 @@
 # Build directories
 build/
-build_asan/
-build-debug/
 build-sanitize/
 bin/
 lib/
@@ -36,9 +34,6 @@ Makefile
 *.app
 wowee
 
-# Claude Code internal state
-.claude/
-
 # IDE files
 .vscode/
 .idea/
@@ -47,31 +42,12 @@ wowee
 *~
 .DS_Store
 
-# Compilation database (regenerated by cmake)
-compile_commands.json
-
-# Language server caches
-.ccls
-.ccls-cache/
-.cache/clangd/
-
-# Tags
-tags
-TAGS
-.tags
-cscope.out
-
 # External dependencies (except submodules and vendored headers)
 extern/*
 !extern/.gitkeep
-!extern/catch2
 !extern/imgui
 !extern/vk-bootstrap
-!extern/FidelityFX-SDK
-!extern/FidelityFX-FSR2
 !extern/vk_mem_alloc.h
-!extern/lua-5.1.5
-!extern/VERSIONS.md
 
 # ImGui state
 imgui.ini
@@ -91,9 +67,27 @@ saves/
 wowee_[0-9][0-9][0-9][0-9]
 
 # Extracted assets (run ./extract_assets.sh or .\extract_assets.ps1 to generate)
-Data/*
-!Data/opcodes
-
+Data/db/
+Data/character/
+Data/creature/
+Data/terrain/
+Data/world/
+Data/interface/
+Data/item/
+Data/sound/
+Data/spell/
+Data/environment/
+Data/misc/
+Data/enUS/
+Data/Character/
+Data/Creature/
+Data/World/
+Data/manifest.json
+Data/expansions/*/manifest.json
+Data/expansions/*/assets/
+Data/expansions/*/overlay/
+Data/expansions/*/db/*.csv
+Data/hd/
 ingest/
 
 # Asset pipeline state and texture packs
@@ -106,10 +100,3 @@ node_modules/
 # Python cache artifacts
 tools/__pycache__/
 *.pyc
-
-# artifacts
-.codex-loop/
-
-# Local agent instructions
-AGENTS.md
-codex-loop.sh
diff --git a/.gitmodules b/.gitmodules
index 713e63aa..84acc55c 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -6,13 +6,3 @@
 	path = extern/vk-bootstrap
 	url = https://github.com/charles-lunarg/vk-bootstrap.git
 	shallow = true
-[submodule "extern/FidelityFX-SDK"]
-	path = extern/FidelityFX-SDK
-	url = https://github.com/Kelsidavis/FidelityFX-SDK.git
-        shallow = true
-        update = none
-[submodule "extern/FidelityFX-FSR2"]
-	path = extern/FidelityFX-FSR2
-	url = https://github.com/Kelsidavis/FidelityFX-FSR2.git
-	shallow = true
-	ignore = dirty
diff --git a/.semgrepignore b/.semgrepignore
deleted file mode 100644
index eb36847a..00000000
--- a/.semgrepignore
+++ /dev/null
@@ -1,8 +0,0 @@
-# Vendored third-party code (frozen releases, not ours to modify)
-extern/lua-5.1.5/
-extern/imgui/
-extern/stb_image.h
-extern/stb_image_write.h
-extern/vk-bootstrap/
-extern/FidelityFX-FSR2/
-extern/FidelityFX-SDK/
diff --git a/BUILD_INSTRUCTIONS.md b/BUILD_INSTRUCTIONS.md
index c06296d8..207fbbcd 100644
--- a/BUILD_INSTRUCTIONS.md
+++ b/BUILD_INSTRUCTIONS.md
@@ -12,7 +12,7 @@ This document provides platform-specific build instructions for WoWee.
 sudo apt update
 sudo apt install -y \
   build-essential cmake pkg-config git \
-  libsdl2-dev libglm-dev \
+  libsdl2-dev libglew-dev libglm-dev \
   libssl-dev zlib1g-dev \
   libvulkan-dev vulkan-tools glslc \
   libavcodec-dev libavformat-dev libavutil-dev libswscale-dev \
@@ -28,7 +28,7 @@ sudo apt install -y \
 ```bash
 sudo pacman -S --needed \
   base-devel cmake pkgconf git \
-  sdl2 glm openssl zlib \
+  sdl2 glew glm openssl zlib \
   vulkan-headers vulkan-icd-loader vulkan-tools shaderc \
   ffmpeg unicorn stormlib
 ```
@@ -83,7 +83,7 @@ Vulkan on macOS is provided via MoltenVK (a Vulkan-to-Metal translation layer),
 which is included in the `vulkan-loader` Homebrew package.
 
 ```bash
-brew install cmake pkg-config sdl2 glm openssl@3 zlib ffmpeg unicorn \
+brew install cmake pkg-config sdl2 glew glm openssl@3 zlib ffmpeg unicorn \
   stormlib vulkan-loader vulkan-headers shaderc
 ```
 
@@ -137,6 +137,7 @@ pacman -S --needed \
   mingw-w64-x86_64-ninja \
   mingw-w64-x86_64-pkgconf \
   mingw-w64-x86_64-SDL2 \
+  mingw-w64-x86_64-glew \
   mingw-w64-x86_64-glm \
   mingw-w64-x86_64-openssl \
   mingw-w64-x86_64-zlib \
@@ -173,7 +174,7 @@ For users who prefer Visual Studio over MSYS2.
 ### vcpkg Dependencies
 
 ```powershell
-vcpkg install sdl2 glm openssl zlib ffmpeg stormlib --triplet x64-windows
+vcpkg install sdl2 glew glm openssl zlib ffmpeg stormlib --triplet x64-windows
 ```
 
 ### Clone
diff --git a/CHANGELOG.md b/CHANGELOG.md
deleted file mode 100644
index 866f0918..00000000
--- a/CHANGELOG.md
+++ /dev/null
@@ -1,85 +0,0 @@
-# Changelog
-
-## [Unreleased] — changes since v1.8.9-preview
-
-### Architecture
-- Break Application::getInstance() singleton from GameHandler via GameServices struct
-- EntityController refactoring (SOLID decomposition)
-- Extract 8 domain handler classes from GameHandler
-- Replace 3,300-line switch with dispatch table
-- Multi-platform Docker build system (Linux, macOS arm64/x86_64, Windows cross-compilation)
-
-### Bug Fixes (v1.8.2–v1.8.9)
-- Fix VkTexture ownsSampler_ flag after move/destroy (prevented double-free)
-- Fix unsigned underflow in Warden PE section loading (buffer overflow on malformed modules)
-- Add bounds checks to Warden readLE32/readLE16 (out-of-bounds on untrusted PE data)
-- Fix undefined behavior: SDL_BUTTON(0) computed 1 << -1 (negative shift)
-- Fix BigNum::toHex/toDecimal null dereference on OpenSSL allocation failure
-- Remove duplicate zone weather entry silently overwriting Dustwallow Marsh
-- Fix LLVM apt repo codename (jammy→noble) in macOS Docker build
-- Add missing mkdir in Linux Docker build script
-- Clamp player percentage stats (block/dodge/parry/crit) to prevent NaN from corrupted packets
-- Guard fsPath underflow in tryLoadPngOverride
-
-### Code Quality (v1.8.2–v1.8.9)
-- 30+ named constants replacing magic numbers across game, rendering, and pipeline code
-- 55+ why-comments documenting WoW protocol quirks, format specifics, and design rationale
-- 8 DRY extractions (findOnUseSpellId, createFallbackTextures, finalizeSampler,
-  renderClassRestriction/renderRaceRestriction, and more)
-- Scope macOS -undefined dynamic_lookup linker flag to wowee target only
-- Replace goto patterns with structured control flow (do/while(false), lambdas)
-- Zero out GameServices in Application::shutdown to prevent dangling pointers
-
----
-
-## [v1.8.1-preview] — 2026-03-23
-
-### Performance
-- Eliminate ~70 unnecessary sqrt ops per frame; constexpr reciprocals and cache optimizations
-- Skip bone animation for LOD3 models; frustum-cull water surfaces
-- Eliminate per-frame heap allocations in M2 renderer
-- Convert entity/skill/DBC/warden maps to unordered_map; fix 3x contacts scan
-- Eliminate double map lookups and dynamic_cast in render loops
-- Use second GPU queue for parallel texture/buffer uploads
-- Time-budget tile finalization to prevent 1+ second main-loop stalls
-- Add Vulkan pipeline cache persistence for faster startup
-
-### Bug Fixes
-- Fix spline parsing with expansion context; preload DBC caches at world entry
-- Fix NPC/player attack animation to use weapon-appropriate anim ID
-- Fix equipment visibility and follow-target run speed
-- Fix inspect (packed GUID) and client-side auto-walk for follow
-- Fix mail money uint64, other-player cape textures, zone toast dedup, TCP_NODELAY
-- Guard spline point loop against unsigned underflow; guard hexDecode/stoi/stof
-- Fix infinite recursion in toLowerInPlace and operator precedence bugs
-- Fix 3D audio coords for PLAY_OBJECT_SOUND; correct melee swing sound paths
-- Prevent Vulkan sampler exhaustion crash; skip pipeline cache on NVIDIA
-- Skip FSR3 frame gen on non-AMD GPUs to prevent driver crash
-- Fix chest GO interaction (send GAMEOBJ_USE+LOOT together)
-- Restore WMO wall collision threshold; fix off-screen bag positions
-- Guard texture log dedup sets with mutex for thread safety
-- Fix lua_pcall return check in ACTIONBAR_PAGE_CHANGED
-
-### Features
-- Render equipment on other players (helmets, weapons, belts, wrists, shoulders)
-- Target frame right-click context menu
-- Crafting sounds and Create All button
-- Server-synced bag sort
-- Log GPU vendor/name at init
-
-### Security
-- Add path traversal rejection and packet length validation
-
-### Code Quality
-- Packet API: add readPackedGuid, writePackedGuid, writeFloat, getRemainingSize,
-  hasRemaining, hasData, skipAll (replacing 1300+ verbose expressions)
-- GameHandler helpers: isInWorld, isPreWotlk, guidToUnitId, lookupName,
-  getUnitByGuid, fireAddonEvent, withSoundManager
-- Dispatch table: registerHandler, registerSkipHandler, registerWorldHandler,
-  registerErrorHandler (replacing 120+ lambda wrappers)
-- Shared ui_colors.hpp with named constants replacing 200+ inline color literals
-- Promote 50+ static const arrays to constexpr across audio/core/rendering/UI
-- Deduplicate class name/color functions, enchantment cache, item-set DBC keys
-- Extract settings tabs, GameHandler::update() phases, loadWeaponM2 into methods
-- Remove 12 duplicate dispatch registrations and C-style casts
-- Extract toHexString, toLowerInPlace, duration formatting, Lua return helpers
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 84e84b62..54f39283 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.15)
-project(wowee VERSION 1.0.0 LANGUAGES C CXX)
+project(wowee VERSION 1.0.0 LANGUAGES CXX)
 include(GNUInstallDirs)
 
 set(CMAKE_CXX_STANDARD 20)
@@ -25,9 +25,8 @@ endif()
 
 # Options
 option(BUILD_SHARED_LIBS "Build shared libraries" OFF)
-option(WOWEE_BUILD_TESTS "Build tests" ON)
+option(WOWEE_BUILD_TESTS "Build tests" OFF)
 option(WOWEE_ENABLE_ASAN "Enable AddressSanitizer (Debug builds)" OFF)
-option(WOWEE_ENABLE_TRACY "Enable Tracy profiler instrumentation" OFF)
 option(WOWEE_ENABLE_AMD_FSR2 "Enable AMD FidelityFX FSR2 backend when SDK is present" ON)
 option(WOWEE_ENABLE_AMD_FSR3_FRAMEGEN "Enable AMD FidelityFX SDK FSR3 frame generation interface probe when SDK is present" ON)
 option(WOWEE_BUILD_AMD_FSR3_RUNTIME "Build native AMD FidelityFX VK runtime (Path A) from extern/FidelityFX-SDK/Kits" ON)
@@ -249,98 +248,34 @@ endif()
 find_package(SDL2 REQUIRED)
 find_package(Vulkan QUIET)
 if(NOT Vulkan_FOUND)
-    # For Windows cross-compilation the host pkg-config finds the Linux libvulkan-dev
-    # and injects /usr/include as an INTERFACE_INCLUDE_DIRECTORY, which causes
-    # MinGW clang to pull in glibc headers (bits/libc-header-start.h) instead of
-    # the MinGW sysroot headers.  Skip the host pkg-config path entirely and instead
-    # locate Vulkan via vcpkg-installed vulkan-headers or the MinGW toolchain.
-    if(CMAKE_CROSSCOMPILING AND WIN32)
-        # The cross-compile build script generates a Vulkan import library
-        # (libvulkan-1.a) in ${CMAKE_BINARY_DIR}/vulkan-import from the headers.
-        set(_VULKAN_IMPORT_DIR "${CMAKE_BINARY_DIR}/vulkan-import")
-
-        find_package(VulkanHeaders CONFIG QUIET)
-        if(VulkanHeaders_FOUND)
-            if(NOT TARGET Vulkan::Vulkan)
-                add_library(Vulkan::Vulkan INTERFACE IMPORTED)
-            endif()
-            # Vulkan::Headers is provided by vcpkg's vulkan-headers port and carries
-            # the correct MinGW include path — no Linux system headers involved.
-            set_property(TARGET Vulkan::Vulkan APPEND PROPERTY
-                INTERFACE_LINK_LIBRARIES Vulkan::Headers)
-            # Link against the Vulkan loader import library (vulkan-1.dll).
-            if(EXISTS "${_VULKAN_IMPORT_DIR}/libvulkan-1.a")
+    # Fallback: some distros / CMake versions need pkg-config to locate Vulkan.
+    find_package(PkgConfig QUIET)
+    if(PkgConfig_FOUND)
+        pkg_check_modules(VULKAN_PKG vulkan)
+        if(VULKAN_PKG_FOUND)
+            add_library(Vulkan::Vulkan INTERFACE IMPORTED)
+            set_target_properties(Vulkan::Vulkan PROPERTIES
+                INTERFACE_INCLUDE_DIRECTORIES "${VULKAN_PKG_INCLUDE_DIRS}"
+                INTERFACE_LINK_LIBRARIES "${VULKAN_PKG_LIBRARIES}"
+            )
+            if(VULKAN_PKG_LIBRARY_DIRS)
                 set_property(TARGET Vulkan::Vulkan APPEND PROPERTY
-                    INTERFACE_LINK_DIRECTORIES "${_VULKAN_IMPORT_DIR}")
-                set_property(TARGET Vulkan::Vulkan APPEND PROPERTY
-                    INTERFACE_LINK_LIBRARIES vulkan-1)
+                    INTERFACE_LINK_DIRECTORIES "${VULKAN_PKG_LIBRARY_DIRS}")
             endif()
             set(Vulkan_FOUND TRUE)
-            message(STATUS "Found Vulkan headers for Windows cross-compile via vcpkg VulkanHeaders")
-        else()
-            # Last-resort: check the LLVM-MinGW toolchain sysroot directly.
-            find_path(_VULKAN_MINGW_INCLUDE NAMES vulkan/vulkan.h
-                PATHS /opt/llvm-mingw/x86_64-w64-mingw32/include NO_DEFAULT_PATH)
-            if(_VULKAN_MINGW_INCLUDE)
-                if(NOT TARGET Vulkan::Vulkan)
-                    add_library(Vulkan::Vulkan INTERFACE IMPORTED)
-                endif()
-                set_target_properties(Vulkan::Vulkan PROPERTIES
-                    INTERFACE_INCLUDE_DIRECTORIES "${_VULKAN_MINGW_INCLUDE}")
-                # Link against the Vulkan loader import library (vulkan-1.dll).
-                if(EXISTS "${_VULKAN_IMPORT_DIR}/libvulkan-1.a")
-                    set_property(TARGET Vulkan::Vulkan APPEND PROPERTY
-                        INTERFACE_LINK_DIRECTORIES "${_VULKAN_IMPORT_DIR}")
-                    set_property(TARGET Vulkan::Vulkan APPEND PROPERTY
-                        INTERFACE_LINK_LIBRARIES vulkan-1)
-                endif()
-                set(Vulkan_FOUND TRUE)
-                message(STATUS "Found Vulkan headers in LLVM-MinGW sysroot: ${_VULKAN_MINGW_INCLUDE}")
-            endif()
-        endif()
-    elseif(CMAKE_CROSSCOMPILING AND CMAKE_SYSTEM_NAME STREQUAL "Darwin")
-        # macOS cross-compilation: use vcpkg-installed vulkan-headers.
-        # The host pkg-config would find Linux libvulkan-dev headers which the
-        # macOS cross-compiler cannot use (different sysroot).
-        find_package(VulkanHeaders CONFIG QUIET)
-        if(VulkanHeaders_FOUND)
-            if(NOT TARGET Vulkan::Vulkan)
-                add_library(Vulkan::Vulkan INTERFACE IMPORTED)
-            endif()
-            set_property(TARGET Vulkan::Vulkan APPEND PROPERTY
-                INTERFACE_LINK_LIBRARIES Vulkan::Headers)
-            set(Vulkan_FOUND TRUE)
-            message(STATUS "Found Vulkan headers for macOS cross-compile via vcpkg VulkanHeaders")
-        endif()
-    else()
-        # Fallback: some distros / CMake versions need pkg-config to locate Vulkan.
-        find_package(PkgConfig QUIET)
-        if(PkgConfig_FOUND)
-            pkg_check_modules(VULKAN_PKG vulkan)
-            if(VULKAN_PKG_FOUND)
-                add_library(Vulkan::Vulkan INTERFACE IMPORTED)
-                set_target_properties(Vulkan::Vulkan PROPERTIES
-                    INTERFACE_INCLUDE_DIRECTORIES "${VULKAN_PKG_INCLUDE_DIRS}"
-                    INTERFACE_LINK_LIBRARIES "${VULKAN_PKG_LIBRARIES}"
-                )
-                if(VULKAN_PKG_LIBRARY_DIRS)
-                    set_property(TARGET Vulkan::Vulkan APPEND PROPERTY
-                        INTERFACE_LINK_DIRECTORIES "${VULKAN_PKG_LIBRARY_DIRS}")
-                endif()
-                set(Vulkan_FOUND TRUE)
-                message(STATUS "Found Vulkan via pkg-config: ${VULKAN_PKG_LIBRARIES}")
-            endif()
+            message(STATUS "Found Vulkan via pkg-config: ${VULKAN_PKG_LIBRARIES}")
         endif()
     endif()
     if(NOT Vulkan_FOUND)
         message(FATAL_ERROR "Could not find Vulkan. Install libvulkan-dev (Linux), vulkan-loader (macOS), or the Vulkan SDK (Windows).")
     endif()
 endif()
-# macOS cross-compilation: the Vulkan loader (MoltenVK) is not available at link
-# time. Allow unresolved Vulkan symbols — they are resolved at runtime.
-if(CMAKE_CROSSCOMPILING AND CMAKE_SYSTEM_NAME STREQUAL "Darwin")
-    set(WOWEE_MACOS_CROSS_COMPILE TRUE)
-endif()
+# GL/GLEW kept temporarily for unconverted sub-renderers during Vulkan migration.
+# These files compile against GL types but their code is never called — the Vulkan
+# path is the only active rendering backend. Remove in Phase 7 when all renderers
+# are converted and grep confirms zero GL references.
+find_package(OpenGL QUIET)
+find_package(GLEW QUIET)
 find_package(OpenSSL REQUIRED)
 find_package(Threads REQUIRED)
 find_package(ZLIB REQUIRED)
@@ -487,9 +422,6 @@ endif()
 set(WOWEE_SOURCES
     # Core
     src/core/application.cpp
-    src/core/entity_spawner.cpp
-    src/core/appearance_composer.cpp
-    src/core/world_loader.cpp
     src/core/window.cpp
     src/core/input.cpp
     src/core/logger.cpp
@@ -518,15 +450,6 @@ set(WOWEE_SOURCES
     src/game/opcode_table.cpp
     src/game/update_field_table.cpp
     src/game/game_handler.cpp
-    src/game/chat_handler.cpp
-    src/game/movement_handler.cpp
-    src/game/combat_handler.cpp
-    src/game/spell_handler.cpp
-    src/game/inventory_handler.cpp
-    src/game/social_handler.cpp
-    src/game/quest_handler.cpp
-    src/game/entity_controller.cpp
-    src/game/warden_handler.cpp
     src/game/warden_crypto.cpp
     src/game/warden_module.cpp
     src/game/warden_emulator.cpp
@@ -545,7 +468,6 @@ set(WOWEE_SOURCES
 
     # Audio
     src/audio/audio_engine.cpp
-    src/audio/audio_coordinator.cpp
     src/audio/music_manager.cpp
     src/audio/footstep_manager.cpp
     src/audio/activity_sound_manager.cpp
@@ -583,9 +505,12 @@ set(WOWEE_SOURCES
     # Rendering
     src/rendering/renderer.cpp
     src/rendering/amd_fsr3_runtime.cpp
+    src/rendering/shader.cpp
+    src/rendering/mesh.cpp
     src/rendering/camera.cpp
     src/rendering/camera_controller.cpp
     src/rendering/material.cpp
+    src/rendering/scene.cpp
     src/rendering/terrain_renderer.cpp
     src/rendering/terrain_manager.cpp
     src/rendering/frustum.cpp
@@ -604,8 +529,6 @@ set(WOWEE_SOURCES
     src/rendering/character_preview.cpp
     src/rendering/wmo_renderer.cpp
     src/rendering/m2_renderer.cpp
-    src/rendering/m2_model_classifier.cpp
-    src/rendering/render_graph.cpp
     src/rendering/quest_marker_renderer.cpp
     src/rendering/minimap.cpp
     src/rendering/world_map.cpp
@@ -613,21 +536,8 @@ set(WOWEE_SOURCES
     src/rendering/mount_dust.cpp
     src/rendering/levelup_effect.cpp
     src/rendering/charge_effect.cpp
-    src/rendering/spell_visual_system.cpp
-    src/rendering/post_process_pipeline.cpp
-    src/rendering/animation_controller.cpp
-    src/rendering/animation/animation_ids.cpp
-    src/rendering/animation/emote_registry.cpp
-    src/rendering/animation/footstep_driver.cpp
-    src/rendering/animation/sfx_state_driver.cpp
-    src/rendering/animation/anim_capability_probe.cpp
-    src/rendering/animation/locomotion_fsm.cpp
-    src/rendering/animation/combat_fsm.cpp
-    src/rendering/animation/activity_fsm.cpp
-    src/rendering/animation/mount_fsm.cpp
-    src/rendering/animation/character_animator.cpp  # Renamed from player_animator.cpp; npc_animator.cpp removed
-    src/rendering/animation/animation_manager.cpp
     src/rendering/loading_screen.cpp
+    $<$<BOOL:${HAVE_FFMPEG}>:${CMAKE_CURRENT_SOURCE_DIR}/src/rendering/video_player.cpp>
 
     # UI
     src/ui/ui_manager.cpp
@@ -636,31 +546,10 @@ set(WOWEE_SOURCES
     src/ui/character_create_screen.cpp
     src/ui/character_screen.cpp
     src/ui/game_screen.cpp
-    src/ui/chat_panel.cpp
-    src/ui/toast_manager.cpp
-    src/ui/dialog_manager.cpp
-    src/ui/settings_panel.cpp
-    src/ui/combat_ui.cpp
-    src/ui/social_panel.cpp
-    src/ui/action_bar_panel.cpp
-    src/ui/window_manager.cpp
     src/ui/inventory_screen.cpp
     src/ui/quest_log_screen.cpp
     src/ui/spellbook_screen.cpp
     src/ui/talent_screen.cpp
-    src/ui/keybinding_manager.cpp
-
-    # Addons
-    src/addons/addon_manager.cpp
-    src/addons/lua_engine.cpp
-    src/addons/lua_unit_api.cpp
-    src/addons/lua_spell_api.cpp
-    src/addons/lua_inventory_api.cpp
-    src/addons/lua_quest_api.cpp
-    src/addons/lua_social_api.cpp
-    src/addons/lua_system_api.cpp
-    src/addons/lua_action_api.cpp
-    src/addons/toc_parser.cpp
 
     # Main
     src/main.cpp
@@ -729,9 +618,12 @@ set(WOWEE_HEADERS
     include/rendering/vk_pipeline.hpp
     include/rendering/vk_render_target.hpp
     include/rendering/renderer.hpp
+    include/rendering/shader.hpp
+    include/rendering/mesh.hpp
     include/rendering/camera.hpp
     include/rendering/camera_controller.hpp
     include/rendering/material.hpp
+    include/rendering/scene.hpp
     include/rendering/terrain_renderer.hpp
     include/rendering/terrain_manager.hpp
     include/rendering/frustum.hpp
@@ -750,6 +642,7 @@ set(WOWEE_HEADERS
     include/rendering/character_preview.hpp
     include/rendering/wmo_renderer.hpp
     include/rendering/loading_screen.hpp
+    include/rendering/video_player.hpp
 
     include/ui/ui_manager.hpp
     include/ui/auth_screen.hpp
@@ -760,64 +653,24 @@ set(WOWEE_HEADERS
     include/ui/inventory_screen.hpp
     include/ui/spellbook_screen.hpp
     include/ui/talent_screen.hpp
-    include/ui/keybinding_manager.hpp
 )
 
 set(WOWEE_PLATFORM_SOURCES)
 if(WIN32)
-    # Copy icon into build tree so windres can find it via the relative path
-    # in wowee.rc ("assets\\wowee.ico").  Tell the RC compiler to also search
-    # the build directory — GNU windres uses cwd (already the build dir) but
-    # llvm-windres resolves relative to the .rc file, so it needs the hint.
+    # Copy icon into build tree so llvm-rc can find it via the relative path in wowee.rc
     configure_file(
         ${CMAKE_CURRENT_SOURCE_DIR}/assets/Wowee.ico
         ${CMAKE_CURRENT_BINARY_DIR}/assets/wowee.ico
         COPYONLY
     )
-    set(CMAKE_RC_FLAGS "${CMAKE_RC_FLAGS} -I ${CMAKE_CURRENT_BINARY_DIR} -I ${CMAKE_CURRENT_SOURCE_DIR}")
     list(APPEND WOWEE_PLATFORM_SOURCES resources/wowee.rc)
 endif()
 
-# ---- Lua 5.1.5 (vendored, static library) ----
-set(LUA_DIR ${CMAKE_CURRENT_SOURCE_DIR}/extern/lua-5.1.5/src)
-set(LUA_SOURCES
-    ${LUA_DIR}/lapi.c    ${LUA_DIR}/lcode.c   ${LUA_DIR}/ldebug.c
-    ${LUA_DIR}/ldo.c     ${LUA_DIR}/ldump.c   ${LUA_DIR}/lfunc.c
-    ${LUA_DIR}/lgc.c     ${LUA_DIR}/llex.c    ${LUA_DIR}/lmem.c
-    ${LUA_DIR}/lobject.c ${LUA_DIR}/lopcodes.c ${LUA_DIR}/lparser.c
-    ${LUA_DIR}/lstate.c  ${LUA_DIR}/lstring.c ${LUA_DIR}/ltable.c
-    ${LUA_DIR}/ltm.c     ${LUA_DIR}/lundump.c ${LUA_DIR}/lvm.c
-    ${LUA_DIR}/lzio.c    ${LUA_DIR}/lauxlib.c ${LUA_DIR}/lbaselib.c
-    ${LUA_DIR}/ldblib.c  ${LUA_DIR}/liolib.c  ${LUA_DIR}/lmathlib.c
-    ${LUA_DIR}/loslib.c  ${LUA_DIR}/ltablib.c ${LUA_DIR}/lstrlib.c
-    ${LUA_DIR}/linit.c
-)
-add_library(lua51 STATIC ${LUA_SOURCES})
-set_target_properties(lua51 PROPERTIES LINKER_LANGUAGE C C_STANDARD 99 POSITION_INDEPENDENT_CODE ON)
-target_include_directories(lua51 PUBLIC ${LUA_DIR})
-if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
-    target_compile_options(lua51 PRIVATE -w)
-endif()
-
 # Create executable
 add_executable(wowee ${WOWEE_SOURCES} ${WOWEE_HEADERS} ${WOWEE_PLATFORM_SOURCES})
-
-# Tracy profiler — zero overhead when WOWEE_ENABLE_TRACY is OFF
-if(WOWEE_ENABLE_TRACY)
-    target_sources(wowee PRIVATE ${CMAKE_SOURCE_DIR}/extern/tracy/public/TracyClient.cpp)
-    target_compile_definitions(wowee PRIVATE TRACY_ENABLE)
-    target_include_directories(wowee SYSTEM PRIVATE ${CMAKE_SOURCE_DIR}/extern/tracy/public)
-    message(STATUS "Tracy profiler: ENABLED")
-endif()
-
 if(TARGET opcodes-generate)
     add_dependencies(wowee opcodes-generate)
 endif()
-# macOS cross-compilation: MoltenVK is not available at link time.
-# Allow unresolved Vulkan symbols — resolved at runtime. Scoped to wowee only.
-if(WOWEE_MACOS_CROSS_COMPILE)
-    target_link_options(wowee PRIVATE "-undefined" "dynamic_lookup")
-endif()
 
 # FidelityFX-SDK headers can trigger compiler-specific pragma/unused-static noise
 # when included through the runtime bridge; keep suppression scoped to that TU.
@@ -854,10 +707,17 @@ target_link_libraries(wowee PRIVATE
     OpenSSL::Crypto
     Threads::Threads
     ZLIB::ZLIB
-    lua51
     ${CMAKE_DL_LIBS}
 )
 
+# GL/GLEW linked temporarily for unconverted sub-renderers (removed in Phase 7)
+if(TARGET OpenGL::GL)
+    target_link_libraries(wowee PRIVATE OpenGL::GL)
+endif()
+if(TARGET GLEW::GLEW)
+    target_link_libraries(wowee PRIVATE GLEW::GLEW)
+endif()
+
 if(HAVE_FFMPEG)
     target_compile_definitions(wowee PRIVATE HAVE_FFMPEG)
     target_link_libraries(wowee PRIVATE ${FFMPEG_LIBRARIES})
@@ -947,20 +807,12 @@ else()
     # -g3          — maximum DWARF debug info (includes macro definitions)
     # -Og          — optimise for debugging (better than -O0, keeps most frames)
     # -fno-omit-frame-pointer — preserve frame pointers so stack traces are clean
-    # Frame pointers in all configs (negligible perf cost, critical for crash backtraces)
     target_compile_options(wowee PRIVATE
-        -fno-omit-frame-pointer
-        $<$<CONFIG:Debug>:-g3 -Og>
-        $<$<CONFIG:RelWithDebInfo>:-g>
+        $<$<CONFIG:Debug>:-g3 -Og -fno-omit-frame-pointer>
+        $<$<CONFIG:RelWithDebInfo>:-g -fno-omit-frame-pointer>
     )
 endif()
 
-# ── Unit tests (Catch2) ──────────────────────────────────────
-if(WOWEE_BUILD_TESTS)
-    enable_testing()
-    add_subdirectory(tests)
-endif()
-
 # AddressSanitizer — catch buffer overflows, use-after-free, etc.
 # Enable with:  cmake ... -DWOWEE_ENABLE_ASAN=ON -DCMAKE_BUILD_TYPE=Debug
 if(WOWEE_ENABLE_ASAN)
@@ -972,10 +824,10 @@ if(WOWEE_ENABLE_ASAN)
             $<$<CONFIG:Release>:/MD>
         )
     else()
-        target_compile_options(wowee PRIVATE -fsanitize=address,undefined -fno-omit-frame-pointer)
-        target_link_options(wowee PRIVATE -fsanitize=address,undefined)
+        target_compile_options(wowee PRIVATE -fsanitize=address -fno-omit-frame-pointer)
+        target_link_options(wowee PRIVATE -fsanitize=address)
     endif()
-    message(STATUS "AddressSanitizer + UBSan: ENABLED")
+    message(STATUS "AddressSanitizer: ENABLED")
 endif()
 
 # Release build optimizations
@@ -1002,17 +854,6 @@ add_custom_command(TARGET wowee POST_BUILD
     COMMENT "Syncing assets to $<TARGET_FILE_DIR:wowee>/assets"
 )
 
-# Symlink Data/ next to the executable so expansion profiles, opcode tables,
-# and other runtime data files are found when running from the build directory.
-if(NOT WIN32)
-    add_custom_command(TARGET wowee POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E create_symlink
-            ${CMAKE_CURRENT_SOURCE_DIR}/Data
-            $<TARGET_FILE_DIR:wowee>/Data
-        COMMENT "Symlinking Data to $<TARGET_FILE_DIR:wowee>/Data"
-    )
-endif()
-
 # On Windows, SDL 2.28+ uses LoadLibraryExW with LOAD_LIBRARY_SEARCH_DEFAULT_DIRS
 # which does NOT include System32. Copy vulkan-1.dll into the output directory so
 # SDL_Vulkan_LoadLibrary can locate it without needing a full system PATH search.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
deleted file mode 100644
index aac6cdf0..00000000
--- a/CONTRIBUTING.md
+++ /dev/null
@@ -1,72 +0,0 @@
-# Contributing to Wowee
-
-## Build Setup
-
-See [BUILD_INSTRUCTIONS.md](BUILD_INSTRUCTIONS.md) for full platform-specific details.
-The short version: CMake + Make on Linux/macOS, MSYS2 on Windows.
-
-```
-cmake -B build -DCMAKE_BUILD_TYPE=Debug
-make -C build -j$(nproc)
-```
-
-## Code Style
-
-- **C++20**. Use `#pragma once` for include guards.
-- Namespaces: `wowee::game`, `wowee::rendering`, `wowee::ui`, `wowee::core`, `wowee::network`.
-- Conventional commit messages in imperative mood:
-  - `feat:` new feature
-  - `fix:` bug fix
-  - `refactor:` code restructuring with no behavior change
-  - `perf:` performance improvement
-- Prefer `constexpr` over `static const` for compile-time data.
-- Mark functions whose return value should not be ignored with `[[nodiscard]]`.
-
-## Pull Request Process
-
-1. Branch from `master`.
-2. Keep commits focused -- one logical change per commit.
-3. Describe *what* changed and *why* in the PR description.
-4. Ensure the project compiles cleanly before submitting.
-5. Manual testing against a WoW 3.3.5a server (e.g. AzerothCore/ChromieCraft) is expected
-   for gameplay-affecting changes.
-
-## Architecture Overview
-
-See [docs/architecture.md](docs/architecture.md) for the full picture. Key namespaces:
-
-| Namespace | Responsibility |
-|---|---|
-| `wowee::game` | Game state, packet handling (`GameHandler`), opcode dispatch |
-| `wowee::rendering` | Vulkan renderer, M2/WMO/terrain, sky system |
-| `wowee::ui` | ImGui windows and HUD (`GameScreen`) |
-| `wowee::core` | Coordinates, math, utilities |
-| `wowee::network` | Connection, `Packet` read/write API |
-
-## Packet Handlers
-
-The standard pattern for adding a new server packet handler:
-
-1. Define a `struct FooData` holding the parsed fields.
-2. Write `void GameHandler::handleFoo(network::Packet& packet)` to parse into `FooData`.
-3. Register it in the dispatch table: `registerHandler(LogicalOpcode::SMSG_FOO, &GameHandler::handleFoo)`.
-
-Helper variants: `registerWorldHandler` (requires `isInWorld()`), `registerSkipHandler` (discard),
-`registerErrorHandler` (log warning).
-
-## Testing
-
-There is no automated test suite. Changes are verified by manual testing against
-WoW 3.3.5a private servers (primarily ChromieCraft/AzerothCore). Classic and TBC
-expansion paths are tested against their respective server builds.
-
-## Key Files for New Contributors
-
-| File | What it does |
-|---|---|
-| `include/game/game_handler.hpp` | Central game state and all packet handler declarations |
-| `src/game/game_handler.cpp` | Packet dispatch registration and handler implementations |
-| `include/network/packet.hpp` | `Packet` class -- the read/write API every handler uses |
-| `include/ui/game_screen.hpp` | Main gameplay UI screen (ImGui) |
-| `src/rendering/m2_renderer.cpp` | M2 model loading and rendering |
-| `docs/architecture.md` | High-level system architecture reference |
diff --git a/Data/expansions/classic/dbc_layouts.json b/Data/expansions/classic/dbc_layouts.json
index 459c9046..4ec229d5 100644
--- a/Data/expansions/classic/dbc_layouts.json
+++ b/Data/expansions/classic/dbc_layouts.json
@@ -1,260 +1,96 @@
 {
-  "AreaTable": {
-    "ExploreFlag": 3,
-    "ID": 0,
-    "MapID": 1,
-    "ParentAreaNum": 2
-  },
-  "CharHairGeosets": {
-    "GeosetID": 4,
-    "RaceID": 1,
-    "SexID": 2,
-    "Variation": 3
-  },
-  "CharSections": {
-    "BaseSection": 3,
-    "ColorIndex": 5,
-    "Flags": 9,
-    "RaceID": 1,
-    "SexID": 2,
-    "Texture1": 6,
-    "Texture2": 7,
-    "Texture3": 8,
-    "VariationIndex": 4
-  },
-  "CharacterFacialHairStyles": {
-    "Geoset100": 3,
-    "Geoset200": 5,
-    "Geoset300": 4,
-    "RaceID": 0,
-    "SexID": 1,
-    "Variation": 2
-  },
-  "CreatureDisplayInfo": {
-    "ExtraDisplayId": 3,
-    "ID": 0,
-    "ModelID": 1,
-    "Skin1": 6,
-    "Skin2": 7,
-    "Skin3": 8
-  },
-  "CreatureDisplayInfoExtra": {
-    "BakeName": 20,
-    "EquipDisplay0": 8,
-    "EquipDisplay1": 9,
-    "EquipDisplay10": 18,
-    "EquipDisplay2": 10,
-    "EquipDisplay3": 11,
-    "EquipDisplay4": 12,
-    "EquipDisplay5": 13,
-    "EquipDisplay6": 14,
-    "EquipDisplay7": 15,
-    "EquipDisplay8": 16,
-    "EquipDisplay9": 17,
-    "FaceID": 4,
-    "FacialHairID": 7,
-    "HairColorID": 6,
-    "HairStyleID": 5,
-    "ID": 0,
-    "RaceID": 1,
-    "SexID": 2,
-    "SkinID": 3
-  },
-  "CreatureModelData": {
-    "ID": 0,
-    "ModelPath": 2
-  },
-  "Emotes": {
-    "AnimID": 2,
-    "ID": 0
-  },
-  "EmotesText": {
-    "Command": 1,
-    "EmoteRef": 2,
-    "ID": 0,
-    "OthersNoTargetTextID": 7,
-    "OthersTargetTextID": 3,
-    "SenderNoTargetTextID": 9,
-    "SenderTargetTextID": 5
-  },
-  "EmotesTextData": {
-    "ID": 0,
-    "Text": 1
-  },
-  "Faction": {
-    "ID": 0,
-    "ReputationBase0": 10,
-    "ReputationBase1": 11,
-    "ReputationBase2": 12,
-    "ReputationBase3": 13,
-    "ReputationRaceMask0": 2,
-    "ReputationRaceMask1": 3,
-    "ReputationRaceMask2": 4,
-    "ReputationRaceMask3": 5
-  },
-  "FactionTemplate": {
-    "Enemy0": 6,
-    "Enemy1": 7,
-    "Enemy2": 8,
-    "Enemy3": 9,
-    "EnemyGroup": 5,
-    "Faction": 1,
-    "FactionGroup": 3,
-    "FriendGroup": 4,
-    "ID": 0
-  },
-  "GameObjectDisplayInfo": {
-    "ID": 0,
-    "ModelName": 1
+  "Spell": {
+    "ID": 0, "Attributes": 5, "IconID": 117,
+    "Name": 120, "Tooltip": 147, "Rank": 129, "SchoolEnum": 1
   },
   "ItemDisplayInfo": {
-    "GeosetGroup1": 7,
-    "GeosetGroup3": 9,
-    "ID": 0,
-    "InventoryIcon": 5,
-    "LeftModel": 1,
-    "LeftModelTexture": 3,
-    "TextureArmLower": 15,
-    "TextureArmUpper": 14,
-    "TextureFoot": 21,
-    "TextureHand": 16,
-    "TextureLegLower": 20,
-    "TextureLegUpper": 19,
-    "TextureTorsoLower": 18,
-    "TextureTorsoUpper": 17
+    "ID": 0, "LeftModel": 1, "LeftModelTexture": 3,
+    "InventoryIcon": 5, "GeosetGroup1": 7, "GeosetGroup3": 9,
+    "TextureArmUpper": 14, "TextureArmLower": 15, "TextureHand": 16,
+    "TextureTorsoUpper": 17, "TextureTorsoLower": 18,
+    "TextureLegUpper": 19, "TextureLegLower": 20, "TextureFoot": 21
   },
-  "Light": {
-    "ID": 0,
-    "InnerRadius": 5,
-    "LightParamsID": 7,
-    "LightParamsIDRain": 8,
-    "LightParamsIDUnderwater": 9,
-    "MapID": 1,
-    "OuterRadius": 6,
-    "X": 2,
-    "Y": 4,
-    "Z": 3
+  "CharSections": {
+    "RaceID": 1, "SexID": 2, "BaseSection": 3,
+    "VariationIndex": 4, "ColorIndex": 5,
+    "Texture1": 6, "Texture2": 7, "Texture3": 8,
+    "Flags": 9
   },
-  "LightFloatBand": {
-    "BlockIndex": 1,
-    "NumKeyframes": 2,
-    "TimeKey0": 3,
-    "Value0": 19
+  "SpellIcon": { "ID": 0, "Path": 1 },
+  "FactionTemplate": {
+    "ID": 0, "Faction": 1, "FactionGroup": 3,
+    "FriendGroup": 4, "EnemyGroup": 5,
+    "Enemy0": 6, "Enemy1": 7, "Enemy2": 8, "Enemy3": 9
   },
-  "LightIntBand": {
-    "BlockIndex": 1,
-    "NumKeyframes": 2,
-    "TimeKey0": 3,
-    "Value0": 19
+  "Faction": {
+    "ID": 0, "ReputationRaceMask0": 2, "ReputationRaceMask1": 3,
+    "ReputationRaceMask2": 4, "ReputationRaceMask3": 5,
+    "ReputationBase0": 10, "ReputationBase1": 11,
+    "ReputationBase2": 12, "ReputationBase3": 13
   },
-  "LightParams": {
-    "LightParamsID": 0
+  "AreaTable": { "ID": 0, "ExploreFlag": 3 },
+  "CreatureDisplayInfoExtra": {
+    "ID": 0, "RaceID": 1, "SexID": 2, "SkinID": 3, "FaceID": 4,
+    "HairStyleID": 5, "HairColorID": 6, "FacialHairID": 7,
+    "EquipDisplay0": 8, "EquipDisplay1": 9, "EquipDisplay2": 10,
+    "EquipDisplay3": 11, "EquipDisplay4": 12, "EquipDisplay5": 13,
+    "EquipDisplay6": 14, "EquipDisplay7": 15, "EquipDisplay8": 16,
+    "EquipDisplay9": 17, "EquipDisplay10": 18, "BakeName": 20
   },
-  "Map": {
-    "ID": 0,
-    "InternalName": 1
-  },
-  "SkillLine": {
-    "Category": 1,
-    "ID": 0,
-    "Name": 3
-  },
-  "SkillLineAbility": {
-    "SkillLineID": 1,
-    "SpellID": 2
-  },
-  "Spell": {
-    "Attributes": 5,
-    "AttributesEx": 6,
-    "CastingTimeIndex": 15,
-    "DispelType": 4,
-    "DurationIndex": 40,
-    "EffectBasePoints0": 80,
-    "EffectBasePoints1": 81,
-    "EffectBasePoints2": 82,
-    "ID": 0,
-    "IconID": 117,
-    "ManaCost": 29,
-    "Name": 120,
-    "PowerType": 28,
-    "RangeIndex": 33,
-    "Rank": 129,
-    "SchoolEnum": 1,
-    "Tooltip": 147
-  },
-  "SpellIcon": {
-    "ID": 0,
-    "Path": 1
-  },
-  "SpellRange": {
-    "MaxRange": 2
-  },
-  "SpellVisual": {
-    "CastKit": 2,
-    "ID": 0,
-    "ImpactKit": 3,
-    "MissileModel": 8
-  },
-  "SpellVisualEffectName": {
-    "FilePath": 2,
-    "ID": 0
-  },
-  "SpellVisualKit": {
-    "BaseEffect": 5,
-    "ID": 0,
-    "SpecialEffect0": 11,
-    "SpecialEffect1": 12,
-    "SpecialEffect2": 13
-  },
-  "Talent": {
-    "Column": 3,
-    "ID": 0,
-    "PrereqRank0": 12,
-    "PrereqTalent0": 9,
-    "RankSpell0": 4,
-    "Row": 2,
-    "TabID": 1
-  },
-  "TalentTab": {
-    "BackgroundFile": 15,
-    "ClassMask": 12,
-    "ID": 0,
-    "Name": 1,
-    "OrderIndex": 14
+  "CreatureDisplayInfo": {
+    "ID": 0, "ModelID": 1, "ExtraDisplayId": 3,
+    "Skin1": 6, "Skin2": 7, "Skin3": 8
   },
   "TaxiNodes": {
-    "ID": 0,
-    "MapID": 1,
-    "Name": 5,
-    "X": 2,
-    "Y": 3,
-    "Z": 4
-  },
-  "TaxiPath": {
-    "Cost": 3,
-    "FromNode": 1,
-    "ID": 0,
-    "ToNode": 2
+    "ID": 0, "MapID": 1, "X": 2, "Y": 3, "Z": 4, "Name": 5
   },
+  "TaxiPath": { "ID": 0, "FromNode": 1, "ToNode": 2, "Cost": 3 },
   "TaxiPathNode": {
-    "ID": 0,
-    "MapID": 3,
-    "NodeIndex": 2,
-    "PathID": 1,
-    "X": 4,
-    "Y": 5,
-    "Z": 6
+    "ID": 0, "PathID": 1, "NodeIndex": 2, "MapID": 3,
+    "X": 4, "Y": 5, "Z": 6
+  },
+  "TalentTab": {
+    "ID": 0, "Name": 1, "ClassMask": 12,
+    "OrderIndex": 14, "BackgroundFile": 15
+  },
+  "Talent": {
+    "ID": 0, "TabID": 1, "Row": 2, "Column": 3,
+    "RankSpell0": 4, "PrereqTalent0": 9, "PrereqRank0": 12
+  },
+  "SkillLineAbility": { "SkillLineID": 1, "SpellID": 2 },
+  "SkillLine": { "ID": 0, "Category": 1, "Name": 3 },
+  "Map": { "ID": 0, "InternalName": 1 },
+  "CreatureModelData": { "ID": 0, "ModelPath": 2 },
+  "CharHairGeosets": {
+    "RaceID": 1, "SexID": 2, "Variation": 3, "GeosetID": 4
+  },
+  "CharacterFacialHairStyles": {
+    "RaceID": 0, "SexID": 1, "Variation": 2,
+    "Geoset100": 3, "Geoset300": 4, "Geoset200": 5
+  },
+  "GameObjectDisplayInfo": { "ID": 0, "ModelName": 1 },
+  "Emotes": { "ID": 0, "AnimID": 2 },
+  "EmotesText": {
+    "ID": 0, "Command": 1, "EmoteRef": 2,
+    "OthersTargetTextID": 3, "SenderTargetTextID": 5,
+    "OthersNoTargetTextID": 7, "SenderNoTargetTextID": 9
+  },
+  "EmotesTextData": { "ID": 0, "Text": 1 },
+  "Light": {
+    "ID": 0, "MapID": 1, "X": 2, "Z": 3, "Y": 4,
+    "InnerRadius": 5, "OuterRadius": 6, "LightParamsID": 7,
+    "LightParamsIDRain": 8, "LightParamsIDUnderwater": 9
+  },
+  "LightParams": { "LightParamsID": 0 },
+  "LightIntBand": {
+    "BlockIndex": 1, "NumKeyframes": 2, "TimeKey0": 3, "Value0": 19
+  },
+  "LightFloatBand": {
+    "BlockIndex": 1, "NumKeyframes": 2, "TimeKey0": 3, "Value0": 19
   },
   "WorldMapArea": {
-    "AreaID": 2,
-    "AreaName": 3,
-    "DisplayMapID": 8,
-    "ID": 0,
-    "LocBottom": 7,
-    "LocLeft": 4,
-    "LocRight": 5,
-    "LocTop": 6,
-    "MapID": 1,
-    "ParentWorldMapID": 10
+    "ID": 0, "MapID": 1, "AreaID": 2, "AreaName": 3,
+    "LocLeft": 4, "LocRight": 5, "LocTop": 6, "LocBottom": 7,
+    "DisplayMapID": 8, "ParentWorldMapID": 10
   }
 }
diff --git a/Data/expansions/classic/opcodes.json b/Data/expansions/classic/opcodes.json
index 760647d9..b99e4223 100644
--- a/Data/expansions/classic/opcodes.json
+++ b/Data/expansions/classic/opcodes.json
@@ -273,7 +273,7 @@
   "SMSG_INVENTORY_CHANGE_FAILURE": "0x112",
   "SMSG_OPEN_CONTAINER": "0x113",
   "CMSG_INSPECT": "0x114",
-  "SMSG_INSPECT_RESULTS_UPDATE": "0x115",
+  "SMSG_INSPECT": "0x115",
   "CMSG_INITIATE_TRADE": "0x116",
   "CMSG_BEGIN_TRADE": "0x117",
   "CMSG_BUSY_TRADE": "0x118",
@@ -300,7 +300,7 @@
   "CMSG_NEW_SPELL_SLOT": "0x12D",
   "CMSG_CAST_SPELL": "0x12E",
   "CMSG_CANCEL_CAST": "0x12F",
-  "SMSG_CAST_FAILED": "0x130",
+  "SMSG_CAST_RESULT": "0x130",
   "SMSG_SPELL_START": "0x131",
   "SMSG_SPELL_GO": "0x132",
   "SMSG_SPELL_FAILURE": "0x133",
@@ -504,7 +504,8 @@
   "CMSG_GM_SET_SECURITY_GROUP": "0x1F9",
   "CMSG_GM_NUKE": "0x1FA",
   "MSG_RANDOM_ROLL": "0x1FB",
-  "SMSG_ENVIRONMENTAL_DAMAGE_LOG": "0x1FC",
+  "SMSG_ENVIRONMENTALDAMAGELOG": "0x1FC",
+  "CMSG_RWHOIS_OBSOLETE": "0x1FD",
   "SMSG_RWHOIS": "0x1FE",
   "MSG_LOOKING_FOR_GROUP": "0x1FF",
   "CMSG_SET_LOOKING_FOR_GROUP": "0x200",
@@ -527,6 +528,7 @@
   "CMSG_GMTICKET_GETTICKET": "0x211",
   "SMSG_GMTICKET_GETTICKET": "0x212",
   "CMSG_UNLEARN_TALENTS": "0x213",
+  "SMSG_GAMEOBJECT_SPAWN_ANIM_OBSOLETE": "0x214",
   "SMSG_GAMEOBJECT_DESPAWN_ANIM": "0x215",
   "MSG_CORPSE_QUERY": "0x216",
   "CMSG_GMTICKET_DELETETICKET": "0x217",
@@ -536,7 +538,7 @@
   "SMSG_GMTICKET_SYSTEMSTATUS": "0x21B",
   "CMSG_SPIRIT_HEALER_ACTIVATE": "0x21C",
   "CMSG_SET_STAT_CHEAT": "0x21D",
-  "SMSG_QUEST_FORCE_REMOVE": "0x21E",
+  "SMSG_SET_REST_START": "0x21E",
   "CMSG_SKILL_BUY_STEP": "0x21F",
   "CMSG_SKILL_BUY_RANK": "0x220",
   "CMSG_XP_CHEAT": "0x221",
@@ -569,6 +571,8 @@
   "CMSG_BATTLEFIELD_LIST": "0x23C",
   "SMSG_BATTLEFIELD_LIST": "0x23D",
   "CMSG_BATTLEFIELD_JOIN": "0x23E",
+  "SMSG_BATTLEFIELD_WIN_OBSOLETE": "0x23F",
+  "SMSG_BATTLEFIELD_LOSE_OBSOLETE": "0x240",
   "CMSG_TAXICLEARNODE": "0x241",
   "CMSG_TAXIENABLENODE": "0x242",
   "CMSG_ITEM_TEXT_QUERY": "0x243",
@@ -601,6 +605,7 @@
   "SMSG_AUCTION_BIDDER_NOTIFICATION": "0x25E",
   "SMSG_AUCTION_OWNER_NOTIFICATION": "0x25F",
   "SMSG_PROCRESIST": "0x260",
+  "SMSG_STANDSTATE_CHANGE_FAILURE_OBSOLETE": "0x261",
   "SMSG_DISPEL_FAILED": "0x262",
   "SMSG_SPELLORDAMAGE_IMMUNE": "0x263",
   "CMSG_AUCTION_LIST_BIDDER_ITEMS": "0x264",
@@ -688,8 +693,8 @@
   "SMSG_SCRIPT_MESSAGE": "0x2B6",
   "SMSG_DUEL_COUNTDOWN": "0x2B7",
   "SMSG_AREA_TRIGGER_MESSAGE": "0x2B8",
-  "CMSG_SHOWING_HELM": "0x2B9",
-  "CMSG_SHOWING_CLOAK": "0x2BA",
+  "CMSG_TOGGLE_HELM": "0x2B9",
+  "CMSG_TOGGLE_CLOAK": "0x2BA",
   "SMSG_MEETINGSTONE_JOINFAILED": "0x2BB",
   "SMSG_PLAYER_SKINNED": "0x2BC",
   "SMSG_DURABILITY_DAMAGE_DEATH": "0x2BD",
@@ -816,5 +821,6 @@
   "SMSG_LOTTERY_RESULT_OBSOLETE": "0x337",
   "SMSG_CHARACTER_PROFILE": "0x338",
   "SMSG_CHARACTER_PROFILE_REALM_CONNECTED": "0x339",
+  "SMSG_UNK": "0x33A",
   "SMSG_DEFENSE_MESSAGE": "0x33B"
 }
diff --git a/Data/expansions/classic/update_fields.json b/Data/expansions/classic/update_fields.json
index 5b214f59..5f97f29f 100644
--- a/Data/expansions/classic/update_fields.json
+++ b/Data/expansions/classic/update_fields.json
@@ -1,50 +1,38 @@
 {
-  "CONTAINER_FIELD_NUM_SLOTS": 48,
-  "CONTAINER_FIELD_SLOT_1": 50,
-  "GAMEOBJECT_DISPLAYID": 8,
-  "GAMEOBJECT_BYTES_1": 14,
-  "ITEM_FIELD_DURABILITY": 48,
-  "ITEM_FIELD_MAXDURABILITY": 49,
-  "ITEM_FIELD_STACK_COUNT": 14,
   "OBJECT_FIELD_ENTRY": 3,
-  "OBJECT_FIELD_SCALE_X": 4,
-  "PLAYER_BYTES": 191,
-  "PLAYER_BYTES_2": 192,
-  "PLAYER_END": 1282,
-  "PLAYER_EXPLORED_ZONES_START": 1111,
-  "PLAYER_FIELD_BANKBAG_SLOT_1": 612,
-  "PLAYER_FIELD_BANK_SLOT_1": 564,
-  "PLAYER_FIELD_COINAGE": 1176,
-  "PLAYER_FIELD_INV_SLOT_HEAD": 486,
-  "PLAYER_FIELD_PACK_SLOT_1": 532,
-  "PLAYER_FLAGS": 190,
-  "PLAYER_NEXT_LEVEL_XP": 717,
-  "PLAYER_QUEST_LOG_START": 198,
-  "PLAYER_REST_STATE_EXPERIENCE": 1175,
-  "PLAYER_SKILL_INFO_START": 718,
-  "PLAYER_XP": 716,
-  "UNIT_DYNAMIC_FLAGS": 143,
-  "UNIT_END": 188,
-  "UNIT_FIELD_AURAFLAGS": 98,
-  "UNIT_FIELD_AURAS": 50,
+  "UNIT_FIELD_TARGET_LO": 16,
+  "UNIT_FIELD_TARGET_HI": 17,
   "UNIT_FIELD_BYTES_0": 36,
-  "UNIT_FIELD_BYTES_1": 133,
-  "UNIT_FIELD_DISPLAYID": 131,
-  "UNIT_FIELD_FACTIONTEMPLATE": 35,
-  "UNIT_FIELD_FLAGS": 46,
   "UNIT_FIELD_HEALTH": 22,
-  "UNIT_FIELD_LEVEL": 34,
+  "UNIT_FIELD_POWER1": 23,
   "UNIT_FIELD_MAXHEALTH": 28,
   "UNIT_FIELD_MAXPOWER1": 29,
+  "UNIT_FIELD_LEVEL": 34,
+  "UNIT_FIELD_FACTIONTEMPLATE": 35,
+  "UNIT_FIELD_FLAGS": 46,
+  "UNIT_FIELD_DISPLAYID": 131,
   "UNIT_FIELD_MOUNTDISPLAYID": 133,
-  "UNIT_FIELD_POWER1": 23,
+  "UNIT_FIELD_AURAS": 50,
+  "UNIT_NPC_FLAGS": 147,
+  "UNIT_DYNAMIC_FLAGS": 143,
   "UNIT_FIELD_RESISTANCES": 154,
-  "UNIT_FIELD_STAT0": 138,
-  "UNIT_FIELD_STAT1": 139,
-  "UNIT_FIELD_STAT2": 140,
-  "UNIT_FIELD_STAT3": 141,
-  "UNIT_FIELD_STAT4": 142,
-  "UNIT_FIELD_TARGET_HI": 17,
-  "UNIT_FIELD_TARGET_LO": 16,
-  "UNIT_NPC_FLAGS": 147
+  "UNIT_END": 188,
+  "PLAYER_FLAGS": 190,
+  "PLAYER_BYTES": 191,
+  "PLAYER_BYTES_2": 192,
+  "PLAYER_XP": 716,
+  "PLAYER_NEXT_LEVEL_XP": 717,
+  "PLAYER_FIELD_COINAGE": 1176,
+  "PLAYER_QUEST_LOG_START": 198,
+  "PLAYER_FIELD_INV_SLOT_HEAD": 486,
+  "PLAYER_FIELD_PACK_SLOT_1": 532,
+  "PLAYER_FIELD_BANK_SLOT_1": 564,
+  "PLAYER_FIELD_BANKBAG_SLOT_1": 612,
+  "PLAYER_SKILL_INFO_START": 718,
+  "PLAYER_EXPLORED_ZONES_START": 1111,
+  "PLAYER_END": 1282,
+  "GAMEOBJECT_DISPLAYID": 8,
+  "ITEM_FIELD_STACK_COUNT": 14,
+  "CONTAINER_FIELD_NUM_SLOTS": 48,
+  "CONTAINER_FIELD_SLOT_1": 50
 }
diff --git a/Data/expansions/tbc/dbc_layouts.json b/Data/expansions/tbc/dbc_layouts.json
index e11682cf..d40a5766 100644
--- a/Data/expansions/tbc/dbc_layouts.json
+++ b/Data/expansions/tbc/dbc_layouts.json
@@ -1,307 +1,98 @@
 {
-  "AreaTable": {
-    "ExploreFlag": 3,
-    "ID": 0,
-    "MapID": 1,
-    "ParentAreaNum": 2
-  },
-  "CharHairGeosets": {
-    "GeosetID": 4,
-    "RaceID": 1,
-    "SexID": 2,
-    "Variation": 3
-  },
-  "CharSections": {
-    "BaseSection": 3,
-    "ColorIndex": 5,
-    "Flags": 9,
-    "RaceID": 1,
-    "SexID": 2,
-    "Texture1": 6,
-    "Texture2": 7,
-    "Texture3": 8,
-    "VariationIndex": 4
-  },
-  "CharTitles": {
-    "ID": 0,
-    "Title": 2,
-    "TitleBit": 20
-  },
-  "CharacterFacialHairStyles": {
-    "Geoset100": 3,
-    "Geoset200": 5,
-    "Geoset300": 4,
-    "RaceID": 0,
-    "SexID": 1,
-    "Variation": 2
-  },
-  "CreatureDisplayInfo": {
-    "ExtraDisplayId": 3,
-    "ID": 0,
-    "ModelID": 1,
-    "Skin1": 6,
-    "Skin2": 7,
-    "Skin3": 8
-  },
-  "CreatureDisplayInfoExtra": {
-    "BakeName": 20,
-    "EquipDisplay0": 8,
-    "EquipDisplay1": 9,
-    "EquipDisplay10": 18,
-    "EquipDisplay2": 10,
-    "EquipDisplay3": 11,
-    "EquipDisplay4": 12,
-    "EquipDisplay5": 13,
-    "EquipDisplay6": 14,
-    "EquipDisplay7": 15,
-    "EquipDisplay8": 16,
-    "EquipDisplay9": 17,
-    "FaceID": 4,
-    "FacialHairID": 7,
-    "HairColorID": 6,
-    "HairStyleID": 5,
-    "ID": 0,
-    "RaceID": 1,
-    "SexID": 2,
-    "SkinID": 3
-  },
-  "CreatureModelData": {
-    "ID": 0,
-    "ModelPath": 2
-  },
-  "Emotes": {
-    "AnimID": 2,
-    "ID": 0
-  },
-  "EmotesText": {
-    "Command": 1,
-    "EmoteRef": 2,
-    "ID": 0,
-    "OthersNoTargetTextID": 7,
-    "OthersTargetTextID": 3,
-    "SenderNoTargetTextID": 9,
-    "SenderTargetTextID": 5
-  },
-  "EmotesTextData": {
-    "ID": 0,
-    "Text": 1
-  },
-  "Faction": {
-    "ID": 0,
-    "ReputationBase0": 10,
-    "ReputationBase1": 11,
-    "ReputationBase2": 12,
-    "ReputationBase3": 13,
-    "ReputationRaceMask0": 2,
-    "ReputationRaceMask1": 3,
-    "ReputationRaceMask2": 4,
-    "ReputationRaceMask3": 5
-  },
-  "FactionTemplate": {
-    "Enemy0": 6,
-    "Enemy1": 7,
-    "Enemy2": 8,
-    "Enemy3": 9,
-    "EnemyGroup": 5,
-    "Faction": 1,
-    "FactionGroup": 3,
-    "FriendGroup": 4,
-    "ID": 0
-  },
-  "GameObjectDisplayInfo": {
-    "ID": 0,
-    "ModelName": 1
+  "Spell": {
+    "ID": 0, "Attributes": 5, "IconID": 124,
+    "Name": 127, "Tooltip": 154, "Rank": 136, "SchoolMask": 215
   },
   "ItemDisplayInfo": {
-    "GeosetGroup1": 7,
-    "GeosetGroup3": 9,
-    "ID": 0,
-    "InventoryIcon": 5,
-    "LeftModel": 1,
-    "LeftModelTexture": 3,
-    "TextureArmLower": 15,
-    "TextureArmUpper": 14,
-    "TextureFoot": 21,
-    "TextureHand": 16,
-    "TextureLegLower": 20,
-    "TextureLegUpper": 19,
-    "TextureTorsoLower": 18,
-    "TextureTorsoUpper": 17
+    "ID": 0, "LeftModel": 1, "LeftModelTexture": 3,
+    "InventoryIcon": 5, "GeosetGroup1": 7, "GeosetGroup3": 9,
+    "TextureArmUpper": 14, "TextureArmLower": 15, "TextureHand": 16,
+    "TextureTorsoUpper": 17, "TextureTorsoLower": 18,
+    "TextureLegUpper": 19, "TextureLegLower": 20, "TextureFoot": 21
   },
-  "ItemSet": {
-    "ID": 0,
-    "Item0": 18,
-    "Item1": 19,
-    "Item2": 20,
-    "Item3": 21,
-    "Item4": 22,
-    "Item5": 23,
-    "Item6": 24,
-    "Item7": 25,
-    "Item8": 26,
-    "Item9": 27,
-    "Name": 1,
-    "Spell0": 28,
-    "Spell1": 29,
-    "Spell2": 30,
-    "Spell3": 31,
-    "Spell4": 32,
-    "Spell5": 33,
-    "Spell6": 34,
-    "Spell7": 35,
-    "Spell8": 36,
-    "Spell9": 37,
-    "Threshold0": 38,
-    "Threshold1": 39,
-    "Threshold2": 40,
-    "Threshold3": 41,
-    "Threshold4": 42,
-    "Threshold5": 43,
-    "Threshold6": 44,
-    "Threshold7": 45,
-    "Threshold8": 46,
-    "Threshold9": 47
+  "CharSections": {
+    "RaceID": 1, "SexID": 2, "BaseSection": 3,
+    "VariationIndex": 4, "ColorIndex": 5,
+    "Texture1": 6, "Texture2": 7, "Texture3": 8,
+    "Flags": 9
   },
-  "Light": {
-    "ID": 0,
-    "InnerRadius": 5,
-    "LightParamsID": 7,
-    "LightParamsIDRain": 8,
-    "LightParamsIDUnderwater": 9,
-    "MapID": 1,
-    "OuterRadius": 6,
-    "X": 2,
-    "Y": 4,
-    "Z": 3
+  "SpellIcon": { "ID": 0, "Path": 1 },
+  "FactionTemplate": {
+    "ID": 0, "Faction": 1, "FactionGroup": 3,
+    "FriendGroup": 4, "EnemyGroup": 5,
+    "Enemy0": 6, "Enemy1": 7, "Enemy2": 8, "Enemy3": 9
   },
-  "LightFloatBand": {
-    "BlockIndex": 1,
-    "NumKeyframes": 2,
-    "TimeKey0": 3,
-    "Value0": 19
+  "Faction": {
+    "ID": 0, "ReputationRaceMask0": 2, "ReputationRaceMask1": 3,
+    "ReputationRaceMask2": 4, "ReputationRaceMask3": 5,
+    "ReputationBase0": 10, "ReputationBase1": 11,
+    "ReputationBase2": 12, "ReputationBase3": 13
   },
-  "LightIntBand": {
-    "BlockIndex": 1,
-    "NumKeyframes": 2,
-    "TimeKey0": 3,
-    "Value0": 19
+  "AreaTable": { "ID": 0, "ExploreFlag": 3 },
+  "CreatureDisplayInfoExtra": {
+    "ID": 0, "RaceID": 1, "SexID": 2, "SkinID": 3, "FaceID": 4,
+    "HairStyleID": 5, "HairColorID": 6, "FacialHairID": 7,
+    "EquipDisplay0": 8, "EquipDisplay1": 9, "EquipDisplay2": 10,
+    "EquipDisplay3": 11, "EquipDisplay4": 12, "EquipDisplay5": 13,
+    "EquipDisplay6": 14, "EquipDisplay7": 15, "EquipDisplay8": 16,
+    "EquipDisplay9": 17, "EquipDisplay10": 18, "BakeName": 20
   },
-  "LightParams": {
-    "LightParamsID": 0
-  },
-  "Map": {
-    "ID": 0,
-    "InternalName": 1
-  },
-  "SkillLine": {
-    "Category": 1,
-    "ID": 0,
-    "Name": 3
-  },
-  "SkillLineAbility": {
-    "SkillLineID": 1,
-    "SpellID": 2
-  },
-  "Spell": {
-    "Attributes": 5,
-    "AttributesEx": 6,
-    "CastingTimeIndex": 22,
-    "DispelType": 3,
-    "DurationIndex": 40,
-    "EffectBasePoints0": 80,
-    "EffectBasePoints1": 81,
-    "EffectBasePoints2": 82,
-    "ID": 0,
-    "IconID": 124,
-    "ManaCost": 36,
-    "Name": 127,
-    "PowerType": 35,
-    "RangeIndex": 40,
-    "Rank": 136,
-    "SchoolMask": 215,
-    "Tooltip": 154
-  },
-  "SpellIcon": {
-    "ID": 0,
-    "Path": 1
-  },
-  "SpellItemEnchantment": {
-    "ID": 0,
-    "Name": 8
-  },
-  "SpellRange": {
-    "MaxRange": 4
-  },
-  "SpellVisual": {
-    "CastKit": 2,
-    "ID": 0,
-    "ImpactKit": 3,
-    "MissileModel": 8
-  },
-  "SpellVisualEffectName": {
-    "FilePath": 2,
-    "ID": 0
-  },
-  "SpellVisualKit": {
-    "BaseEffect": 5,
-    "ID": 0,
-    "SpecialEffect0": 11,
-    "SpecialEffect1": 12,
-    "SpecialEffect2": 13
-  },
-  "Talent": {
-    "Column": 3,
-    "ID": 0,
-    "PrereqRank0": 12,
-    "PrereqTalent0": 9,
-    "RankSpell0": 4,
-    "Row": 2,
-    "TabID": 1
-  },
-  "TalentTab": {
-    "BackgroundFile": 15,
-    "ClassMask": 12,
-    "ID": 0,
-    "Name": 1,
-    "OrderIndex": 14
+  "CreatureDisplayInfo": {
+    "ID": 0, "ModelID": 1, "ExtraDisplayId": 3,
+    "Skin1": 6, "Skin2": 7, "Skin3": 8
   },
   "TaxiNodes": {
-    "ID": 0,
-    "MapID": 1,
-    "MountDisplayIdAlliance": 14,
-    "MountDisplayIdAllianceFallback": 12,
-    "MountDisplayIdHorde": 15,
-    "MountDisplayIdHordeFallback": 13,
-    "Name": 5,
-    "X": 2,
-    "Y": 3,
-    "Z": 4
-  },
-  "TaxiPath": {
-    "Cost": 3,
-    "FromNode": 1,
-    "ID": 0,
-    "ToNode": 2
+    "ID": 0, "MapID": 1, "X": 2, "Y": 3, "Z": 4, "Name": 5,
+    "MountDisplayIdAllianceFallback": 12, "MountDisplayIdHordeFallback": 13,
+    "MountDisplayIdAlliance": 14, "MountDisplayIdHorde": 15
   },
+  "TaxiPath": { "ID": 0, "FromNode": 1, "ToNode": 2, "Cost": 3 },
   "TaxiPathNode": {
-    "ID": 0,
-    "MapID": 3,
-    "NodeIndex": 2,
-    "PathID": 1,
-    "X": 4,
-    "Y": 5,
-    "Z": 6
+    "ID": 0, "PathID": 1, "NodeIndex": 2, "MapID": 3,
+    "X": 4, "Y": 5, "Z": 6
+  },
+  "TalentTab": {
+    "ID": 0, "Name": 1, "ClassMask": 12,
+    "OrderIndex": 14, "BackgroundFile": 15
+  },
+  "Talent": {
+    "ID": 0, "TabID": 1, "Row": 2, "Column": 3,
+    "RankSpell0": 4, "PrereqTalent0": 9, "PrereqRank0": 12
+  },
+  "SkillLineAbility": { "SkillLineID": 1, "SpellID": 2 },
+  "SkillLine": { "ID": 0, "Category": 1, "Name": 3 },
+  "Map": { "ID": 0, "InternalName": 1 },
+  "CreatureModelData": { "ID": 0, "ModelPath": 2 },
+  "CharHairGeosets": {
+    "RaceID": 1, "SexID": 2, "Variation": 3, "GeosetID": 4
+  },
+  "CharacterFacialHairStyles": {
+    "RaceID": 0, "SexID": 1, "Variation": 2,
+    "Geoset100": 3, "Geoset300": 4, "Geoset200": 5
+  },
+  "GameObjectDisplayInfo": { "ID": 0, "ModelName": 1 },
+  "Emotes": { "ID": 0, "AnimID": 2 },
+  "EmotesText": {
+    "ID": 0, "Command": 1, "EmoteRef": 2,
+    "OthersTargetTextID": 3, "SenderTargetTextID": 5,
+    "OthersNoTargetTextID": 7, "SenderNoTargetTextID": 9
+  },
+  "EmotesTextData": { "ID": 0, "Text": 1 },
+  "Light": {
+    "ID": 0, "MapID": 1, "X": 2, "Z": 3, "Y": 4,
+    "InnerRadius": 5, "OuterRadius": 6, "LightParamsID": 7,
+    "LightParamsIDRain": 8, "LightParamsIDUnderwater": 9
+  },
+  "LightParams": { "LightParamsID": 0 },
+  "LightIntBand": {
+    "BlockIndex": 1, "NumKeyframes": 2, "TimeKey0": 3, "Value0": 19
+  },
+  "LightFloatBand": {
+    "BlockIndex": 1, "NumKeyframes": 2, "TimeKey0": 3, "Value0": 19
   },
   "WorldMapArea": {
-    "AreaID": 2,
-    "AreaName": 3,
-    "DisplayMapID": 8,
-    "ID": 0,
-    "LocBottom": 7,
-    "LocLeft": 4,
-    "LocRight": 5,
-    "LocTop": 6,
-    "MapID": 1,
-    "ParentWorldMapID": 10
+    "ID": 0, "MapID": 1, "AreaID": 2, "AreaName": 3,
+    "LocLeft": 4, "LocRight": 5, "LocTop": 6, "LocBottom": 7,
+    "DisplayMapID": 8, "ParentWorldMapID": 10
   }
 }
diff --git a/Data/expansions/tbc/update_fields.json b/Data/expansions/tbc/update_fields.json
index 2e75c268..bbcedec5 100644
--- a/Data/expansions/tbc/update_fields.json
+++ b/Data/expansions/tbc/update_fields.json
@@ -1,50 +1,37 @@
 {
-  "CONTAINER_FIELD_NUM_SLOTS": 64,
-  "CONTAINER_FIELD_SLOT_1": 66,
-  "GAMEOBJECT_DISPLAYID": 8,
-  "GAMEOBJECT_BYTES_1": 17,
-  "ITEM_FIELD_DURABILITY": 60,
-  "ITEM_FIELD_MAXDURABILITY": 61,
-  "ITEM_FIELD_STACK_COUNT": 14,
   "OBJECT_FIELD_ENTRY": 3,
-  "OBJECT_FIELD_SCALE_X": 4,
-  "PLAYER_BYTES": 237,
-  "PLAYER_BYTES_2": 238,
-  "PLAYER_EXPLORED_ZONES_START": 1312,
-  "PLAYER_FIELD_ARENA_CURRENCY": 1506,
-  "PLAYER_FIELD_BANKBAG_SLOT_1": 784,
-  "PLAYER_FIELD_BANK_SLOT_1": 728,
-  "PLAYER_FIELD_COINAGE": 1441,
-  "PLAYER_FIELD_HONOR_CURRENCY": 1505,
-  "PLAYER_FIELD_INV_SLOT_HEAD": 650,
-  "PLAYER_FIELD_PACK_SLOT_1": 696,
-  "PLAYER_FLAGS": 236,
-  "PLAYER_NEXT_LEVEL_XP": 927,
-  "PLAYER_QUEST_LOG_START": 244,
-  "PLAYER_REST_STATE_EXPERIENCE": 1440,
-  "PLAYER_SKILL_INFO_START": 928,
-  "PLAYER_XP": 926,
-  "UNIT_DYNAMIC_FLAGS": 164,
-  "UNIT_END": 234,
+  "UNIT_FIELD_TARGET_LO": 16,
+  "UNIT_FIELD_TARGET_HI": 17,
   "UNIT_FIELD_BYTES_0": 36,
-  "UNIT_FIELD_BYTES_1": 137,
-  "UNIT_FIELD_DISPLAYID": 152,
+  "UNIT_FIELD_HEALTH": 22,
+  "UNIT_FIELD_POWER1": 23,
+  "UNIT_FIELD_MAXHEALTH": 28,
+  "UNIT_FIELD_MAXPOWER1": 29,
+  "UNIT_FIELD_LEVEL": 34,
   "UNIT_FIELD_FACTIONTEMPLATE": 35,
   "UNIT_FIELD_FLAGS": 46,
   "UNIT_FIELD_FLAGS_2": 47,
-  "UNIT_FIELD_HEALTH": 22,
-  "UNIT_FIELD_LEVEL": 34,
-  "UNIT_FIELD_MAXHEALTH": 28,
-  "UNIT_FIELD_MAXPOWER1": 29,
+  "UNIT_FIELD_DISPLAYID": 152,
   "UNIT_FIELD_MOUNTDISPLAYID": 154,
-  "UNIT_FIELD_POWER1": 23,
+  "UNIT_NPC_FLAGS": 168,
+  "UNIT_DYNAMIC_FLAGS": 164,
   "UNIT_FIELD_RESISTANCES": 185,
-  "UNIT_FIELD_STAT0": 159,
-  "UNIT_FIELD_STAT1": 160,
-  "UNIT_FIELD_STAT2": 161,
-  "UNIT_FIELD_STAT3": 162,
-  "UNIT_FIELD_STAT4": 163,
-  "UNIT_FIELD_TARGET_HI": 17,
-  "UNIT_FIELD_TARGET_LO": 16,
-  "UNIT_NPC_FLAGS": 168
+  "UNIT_END": 234,
+  "PLAYER_FLAGS": 236,
+  "PLAYER_BYTES": 237,
+  "PLAYER_BYTES_2": 238,
+  "PLAYER_XP": 926,
+  "PLAYER_NEXT_LEVEL_XP": 927,
+  "PLAYER_FIELD_COINAGE": 1441,
+  "PLAYER_QUEST_LOG_START": 244,
+  "PLAYER_FIELD_INV_SLOT_HEAD": 650,
+  "PLAYER_FIELD_PACK_SLOT_1": 696,
+  "PLAYER_FIELD_BANK_SLOT_1": 728,
+  "PLAYER_FIELD_BANKBAG_SLOT_1": 784,
+  "PLAYER_SKILL_INFO_START": 928,
+  "PLAYER_EXPLORED_ZONES_START": 1312,
+  "GAMEOBJECT_DISPLAYID": 8,
+  "ITEM_FIELD_STACK_COUNT": 14,
+  "CONTAINER_FIELD_NUM_SLOTS": 64,
+  "CONTAINER_FIELD_SLOT_1": 66
 }
diff --git a/Data/expansions/turtle/dbc_layouts.json b/Data/expansions/turtle/dbc_layouts.json
index 2f580109..4e86338a 100644
--- a/Data/expansions/turtle/dbc_layouts.json
+++ b/Data/expansions/turtle/dbc_layouts.json
@@ -1,297 +1,96 @@
 {
-  "AreaTable": {
-    "ExploreFlag": 3,
-    "ID": 0,
-    "MapID": 1,
-    "ParentAreaNum": 2
-  },
-  "CharHairGeosets": {
-    "GeosetID": 4,
-    "RaceID": 1,
-    "SexID": 2,
-    "Variation": 3
-  },
-  "CharSections": {
-    "BaseSection": 3,
-    "ColorIndex": 5,
-    "Flags": 9,
-    "RaceID": 1,
-    "SexID": 2,
-    "Texture1": 6,
-    "Texture2": 7,
-    "Texture3": 8,
-    "VariationIndex": 4
-  },
-  "CharacterFacialHairStyles": {
-    "Geoset100": 3,
-    "Geoset200": 5,
-    "Geoset300": 4,
-    "RaceID": 0,
-    "SexID": 1,
-    "Variation": 2
-  },
-  "CreatureDisplayInfo": {
-    "ExtraDisplayId": 3,
-    "ID": 0,
-    "ModelID": 1,
-    "Skin1": 6,
-    "Skin2": 7,
-    "Skin3": 8
-  },
-  "CreatureDisplayInfoExtra": {
-    "BakeName": 18,
-    "EquipDisplay0": 8,
-    "EquipDisplay1": 9,
-    "EquipDisplay2": 10,
-    "EquipDisplay3": 11,
-    "EquipDisplay4": 12,
-    "EquipDisplay5": 13,
-    "EquipDisplay6": 14,
-    "EquipDisplay7": 15,
-    "EquipDisplay8": 16,
-    "EquipDisplay9": 17,
-    "FaceID": 4,
-    "FacialHairID": 7,
-    "HairColorID": 6,
-    "HairStyleID": 5,
-    "ID": 0,
-    "RaceID": 1,
-    "SexID": 2,
-    "SkinID": 3
-  },
-  "CreatureModelData": {
-    "ID": 0,
-    "ModelPath": 2
-  },
-  "Emotes": {
-    "AnimID": 2,
-    "ID": 0
-  },
-  "EmotesText": {
-    "Command": 1,
-    "EmoteRef": 2,
-    "ID": 0,
-    "OthersNoTargetTextID": 7,
-    "OthersTargetTextID": 3,
-    "SenderNoTargetTextID": 9,
-    "SenderTargetTextID": 5
-  },
-  "EmotesTextData": {
-    "ID": 0,
-    "Text": 1
-  },
-  "Faction": {
-    "ID": 0,
-    "ReputationBase0": 10,
-    "ReputationBase1": 11,
-    "ReputationBase2": 12,
-    "ReputationBase3": 13,
-    "ReputationRaceMask0": 2,
-    "ReputationRaceMask1": 3,
-    "ReputationRaceMask2": 4,
-    "ReputationRaceMask3": 5
-  },
-  "FactionTemplate": {
-    "Enemy0": 6,
-    "Enemy1": 7,
-    "Enemy2": 8,
-    "Enemy3": 9,
-    "EnemyGroup": 5,
-    "Faction": 1,
-    "FactionGroup": 3,
-    "FriendGroup": 4,
-    "ID": 0
-  },
-  "GameObjectDisplayInfo": {
-    "ID": 0,
-    "ModelName": 1
+  "Spell": {
+    "ID": 0, "Attributes": 5, "IconID": 117,
+    "Name": 120, "Tooltip": 147, "Rank": 129, "SchoolEnum": 1
   },
   "ItemDisplayInfo": {
-    "GeosetGroup1": 7,
-    "GeosetGroup3": 9,
-    "ID": 0,
-    "InventoryIcon": 5,
-    "LeftModel": 1,
-    "LeftModelTexture": 3,
-    "TextureArmLower": 15,
-    "TextureArmUpper": 14,
-    "TextureFoot": 21,
-    "TextureHand": 16,
-    "TextureLegLower": 20,
-    "TextureLegUpper": 19,
-    "TextureTorsoLower": 18,
-    "TextureTorsoUpper": 17
+    "ID": 0, "LeftModel": 1, "LeftModelTexture": 3,
+    "InventoryIcon": 5, "GeosetGroup1": 7, "GeosetGroup3": 9,
+    "TextureArmUpper": 14, "TextureArmLower": 15, "TextureHand": 16,
+    "TextureTorsoUpper": 17, "TextureTorsoLower": 18,
+    "TextureLegUpper": 19, "TextureLegLower": 20, "TextureFoot": 21
   },
-  "ItemSet": {
-    "ID": 0,
-    "Item0": 10,
-    "Item1": 11,
-    "Item2": 12,
-    "Item3": 13,
-    "Item4": 14,
-    "Item5": 15,
-    "Item6": 16,
-    "Item7": 17,
-    "Item8": 18,
-    "Item9": 19,
-    "Name": 1,
-    "Spell0": 20,
-    "Spell1": 21,
-    "Spell2": 22,
-    "Spell3": 23,
-    "Spell4": 24,
-    "Spell5": 25,
-    "Spell6": 26,
-    "Spell7": 27,
-    "Spell8": 28,
-    "Spell9": 29,
-    "Threshold0": 30,
-    "Threshold1": 31,
-    "Threshold2": 32,
-    "Threshold3": 33,
-    "Threshold4": 34,
-    "Threshold5": 35,
-    "Threshold6": 36,
-    "Threshold7": 37,
-    "Threshold8": 38,
-    "Threshold9": 39
+  "CharSections": {
+    "RaceID": 1, "SexID": 2, "BaseSection": 3,
+    "VariationIndex": 4, "ColorIndex": 5,
+    "Texture1": 6, "Texture2": 7, "Texture3": 8,
+    "Flags": 9
   },
-  "Light": {
-    "ID": 0,
-    "InnerRadius": 5,
-    "LightParamsID": 7,
-    "LightParamsIDRain": 8,
-    "LightParamsIDUnderwater": 9,
-    "MapID": 1,
-    "OuterRadius": 6,
-    "X": 2,
-    "Y": 4,
-    "Z": 3
+  "SpellIcon": { "ID": 0, "Path": 1 },
+  "FactionTemplate": {
+    "ID": 0, "Faction": 1, "FactionGroup": 3,
+    "FriendGroup": 4, "EnemyGroup": 5,
+    "Enemy0": 6, "Enemy1": 7, "Enemy2": 8, "Enemy3": 9
   },
-  "LightFloatBand": {
-    "BlockIndex": 1,
-    "NumKeyframes": 2,
-    "TimeKey0": 3,
-    "Value0": 19
+  "Faction": {
+    "ID": 0, "ReputationRaceMask0": 2, "ReputationRaceMask1": 3,
+    "ReputationRaceMask2": 4, "ReputationRaceMask3": 5,
+    "ReputationBase0": 10, "ReputationBase1": 11,
+    "ReputationBase2": 12, "ReputationBase3": 13
   },
-  "LightIntBand": {
-    "BlockIndex": 1,
-    "NumKeyframes": 2,
-    "TimeKey0": 3,
-    "Value0": 19
+  "AreaTable": { "ID": 0, "ExploreFlag": 3 },
+  "CreatureDisplayInfoExtra": {
+    "ID": 0, "RaceID": 1, "SexID": 2, "SkinID": 3, "FaceID": 4,
+    "HairStyleID": 5, "HairColorID": 6, "FacialHairID": 7,
+    "EquipDisplay0": 8, "EquipDisplay1": 9, "EquipDisplay2": 10,
+    "EquipDisplay3": 11, "EquipDisplay4": 12, "EquipDisplay5": 13,
+    "EquipDisplay6": 14, "EquipDisplay7": 15, "EquipDisplay8": 16,
+    "EquipDisplay9": 17, "BakeName": 18
   },
-  "LightParams": {
-    "LightParamsID": 0
-  },
-  "Map": {
-    "ID": 0,
-    "InternalName": 1
-  },
-  "SkillLine": {
-    "Category": 1,
-    "ID": 0,
-    "Name": 3
-  },
-  "SkillLineAbility": {
-    "SkillLineID": 1,
-    "SpellID": 2
-  },
-  "Spell": {
-    "Attributes": 5,
-    "AttributesEx": 6,
-    "CastingTimeIndex": 15,
-    "DispelType": 4,
-    "DurationIndex": 40,
-    "EffectBasePoints0": 80,
-    "EffectBasePoints1": 81,
-    "EffectBasePoints2": 82,
-    "ID": 0,
-    "IconID": 117,
-    "ManaCost": 29,
-    "Name": 120,
-    "PowerType": 28,
-    "RangeIndex": 33,
-    "Rank": 129,
-    "SchoolEnum": 1,
-    "Tooltip": 147
-  },
-  "SpellIcon": {
-    "ID": 0,
-    "Path": 1
-  },
-  "SpellItemEnchantment": {
-    "ID": 0,
-    "Name": 8
-  },
-  "SpellRange": {
-    "MaxRange": 2
-  },
-  "SpellVisual": {
-    "CastKit": 2,
-    "ID": 0,
-    "ImpactKit": 3,
-    "MissileModel": 8
-  },
-  "SpellVisualEffectName": {
-    "FilePath": 2,
-    "ID": 0
-  },
-  "SpellVisualKit": {
-    "BaseEffect": 5,
-    "ID": 0,
-    "SpecialEffect0": 11,
-    "SpecialEffect1": 12,
-    "SpecialEffect2": 13
-  },
-  "Talent": {
-    "Column": 3,
-    "ID": 0,
-    "PrereqRank0": 12,
-    "PrereqTalent0": 9,
-    "RankSpell0": 4,
-    "Row": 2,
-    "TabID": 1
-  },
-  "TalentTab": {
-    "BackgroundFile": 15,
-    "ClassMask": 12,
-    "ID": 0,
-    "Name": 1,
-    "OrderIndex": 14
+  "CreatureDisplayInfo": {
+    "ID": 0, "ModelID": 1, "ExtraDisplayId": 3,
+    "Skin1": 6, "Skin2": 7, "Skin3": 8
   },
   "TaxiNodes": {
-    "ID": 0,
-    "MapID": 1,
-    "Name": 5,
-    "X": 2,
-    "Y": 3,
-    "Z": 4
-  },
-  "TaxiPath": {
-    "Cost": 3,
-    "FromNode": 1,
-    "ID": 0,
-    "ToNode": 2
+    "ID": 0, "MapID": 1, "X": 2, "Y": 3, "Z": 4, "Name": 5
   },
+  "TaxiPath": { "ID": 0, "FromNode": 1, "ToNode": 2, "Cost": 3 },
   "TaxiPathNode": {
-    "ID": 0,
-    "MapID": 3,
-    "NodeIndex": 2,
-    "PathID": 1,
-    "X": 4,
-    "Y": 5,
-    "Z": 6
+    "ID": 0, "PathID": 1, "NodeIndex": 2, "MapID": 3,
+    "X": 4, "Y": 5, "Z": 6
+  },
+  "TalentTab": {
+    "ID": 0, "Name": 1, "ClassMask": 12,
+    "OrderIndex": 14, "BackgroundFile": 15
+  },
+  "Talent": {
+    "ID": 0, "TabID": 1, "Row": 2, "Column": 3,
+    "RankSpell0": 4, "PrereqTalent0": 9, "PrereqRank0": 12
+  },
+  "SkillLineAbility": { "SkillLineID": 1, "SpellID": 2 },
+  "SkillLine": { "ID": 0, "Category": 1, "Name": 3 },
+  "Map": { "ID": 0, "InternalName": 1 },
+  "CreatureModelData": { "ID": 0, "ModelPath": 2 },
+  "CharHairGeosets": {
+    "RaceID": 1, "SexID": 2, "Variation": 3, "GeosetID": 4
+  },
+  "CharacterFacialHairStyles": {
+    "RaceID": 0, "SexID": 1, "Variation": 2,
+    "Geoset100": 3, "Geoset300": 4, "Geoset200": 5
+  },
+  "GameObjectDisplayInfo": { "ID": 0, "ModelName": 1 },
+  "Emotes": { "ID": 0, "AnimID": 2 },
+  "EmotesText": {
+    "ID": 0, "Command": 1, "EmoteRef": 2,
+    "OthersTargetTextID": 3, "SenderTargetTextID": 5,
+    "OthersNoTargetTextID": 7, "SenderNoTargetTextID": 9
+  },
+  "EmotesTextData": { "ID": 0, "Text": 1 },
+  "Light": {
+    "ID": 0, "MapID": 1, "X": 2, "Z": 3, "Y": 4,
+    "InnerRadius": 5, "OuterRadius": 6, "LightParamsID": 7,
+    "LightParamsIDRain": 8, "LightParamsIDUnderwater": 9
+  },
+  "LightParams": { "LightParamsID": 0 },
+  "LightIntBand": {
+    "BlockIndex": 1, "NumKeyframes": 2, "TimeKey0": 3, "Value0": 19
+  },
+  "LightFloatBand": {
+    "BlockIndex": 1, "NumKeyframes": 2, "TimeKey0": 3, "Value0": 19
   },
   "WorldMapArea": {
-    "AreaID": 2,
-    "AreaName": 3,
-    "DisplayMapID": 8,
-    "ID": 0,
-    "LocBottom": 7,
-    "LocLeft": 4,
-    "LocRight": 5,
-    "LocTop": 6,
-    "MapID": 1,
-    "ParentWorldMapID": 10
+    "ID": 0, "MapID": 1, "AreaID": 2, "AreaName": 3,
+    "LocLeft": 4, "LocRight": 5, "LocTop": 6, "LocBottom": 7,
+    "DisplayMapID": 8, "ParentWorldMapID": 10
   }
 }
diff --git a/Data/expansions/turtle/opcodes.json b/Data/expansions/turtle/opcodes.json
index d0f84599..95a22888 100644
--- a/Data/expansions/turtle/opcodes.json
+++ b/Data/expansions/turtle/opcodes.json
@@ -1,6 +1,300 @@
 {
-  "_extends": "../classic/opcodes.json",
-  "_remove": [
-    "MSG_SET_DUNGEON_DIFFICULTY"
-  ]
+  "CMSG_PING": "0x1DC",
+  "CMSG_AUTH_SESSION": "0x1ED",
+  "CMSG_CHAR_CREATE": "0x036",
+  "CMSG_CHAR_ENUM": "0x037",
+  "CMSG_CHAR_DELETE": "0x038",
+  "CMSG_PLAYER_LOGIN": "0x03D",
+  "MSG_MOVE_START_FORWARD": "0x0B5",
+  "MSG_MOVE_START_BACKWARD": "0x0B6",
+  "MSG_MOVE_STOP": "0x0B7",
+  "MSG_MOVE_START_STRAFE_LEFT": "0x0B8",
+  "MSG_MOVE_START_STRAFE_RIGHT": "0x0B9",
+  "MSG_MOVE_STOP_STRAFE": "0x0BA",
+  "MSG_MOVE_JUMP": "0x0BB",
+  "MSG_MOVE_START_TURN_LEFT": "0x0BC",
+  "MSG_MOVE_START_TURN_RIGHT": "0x0BD",
+  "MSG_MOVE_STOP_TURN": "0x0BE",
+  "MSG_MOVE_SET_FACING": "0x0DA",
+  "MSG_MOVE_FALL_LAND": "0x0C9",
+  "MSG_MOVE_START_SWIM": "0x0CA",
+  "MSG_MOVE_STOP_SWIM": "0x0CB",
+  "MSG_MOVE_HEARTBEAT": "0x0EE",
+  "SMSG_AUTH_CHALLENGE": "0x1EC",
+  "SMSG_AUTH_RESPONSE": "0x1EE",
+  "SMSG_CHAR_CREATE": "0x03A",
+  "SMSG_CHAR_ENUM": "0x03B",
+  "SMSG_CHAR_DELETE": "0x03C",
+  "SMSG_CHARACTER_LOGIN_FAILED": "0x041",
+  "SMSG_PONG": "0x1DD",
+  "SMSG_LOGIN_VERIFY_WORLD": "0x236",
+  "SMSG_INIT_WORLD_STATES": "0x2C2",
+  "SMSG_LOGIN_SETTIMESPEED": "0x042",
+  "SMSG_TUTORIAL_FLAGS": "0x0FD",
+  "SMSG_INITIALIZE_FACTIONS": "0x122",
+  "SMSG_WARDEN_DATA": "0x2E6",
+  "CMSG_WARDEN_DATA": "0x2E7",
+  "SMSG_NOTIFICATION": "0x1CB",
+  "SMSG_ACCOUNT_DATA_TIMES": "0x209",
+  "SMSG_UPDATE_OBJECT": "0x0A9",
+  "SMSG_COMPRESSED_UPDATE_OBJECT": "0x1F6",
+  "SMSG_PARTYKILLLOG": "0x1F5",
+  "SMSG_MONSTER_MOVE_TRANSPORT": "0x2AE",
+  "SMSG_SPLINE_MOVE_SET_WALK_MODE": "0x30E",
+  "SMSG_SPLINE_MOVE_SET_RUN_MODE": "0x30D",
+  "SMSG_SPLINE_SET_RUN_SPEED": "0x2FE",
+  "SMSG_SPLINE_SET_RUN_BACK_SPEED": "0x2FF",
+  "SMSG_SPLINE_SET_SWIM_SPEED": "0x300",
+  "SMSG_DESTROY_OBJECT": "0x0AA",
+  "CMSG_MESSAGECHAT": "0x095",
+  "SMSG_MESSAGECHAT": "0x096",
+  "CMSG_WHO": "0x062",
+  "SMSG_WHO": "0x063",
+  "CMSG_PLAYED_TIME": "0x1CC",
+  "SMSG_PLAYED_TIME": "0x1CD",
+  "CMSG_QUERY_TIME": "0x1CE",
+  "SMSG_QUERY_TIME_RESPONSE": "0x1CF",
+  "SMSG_FRIEND_STATUS": "0x068",
+  "SMSG_CONTACT_LIST": "0x067",
+  "CMSG_ADD_FRIEND": "0x069",
+  "CMSG_DEL_FRIEND": "0x06A",
+  "CMSG_ADD_IGNORE": "0x06C",
+  "CMSG_DEL_IGNORE": "0x06D",
+  "CMSG_PLAYER_LOGOUT": "0x04A",
+  "CMSG_LOGOUT_REQUEST": "0x04B",
+  "CMSG_LOGOUT_CANCEL": "0x04E",
+  "SMSG_LOGOUT_RESPONSE": "0x04C",
+  "SMSG_LOGOUT_COMPLETE": "0x04D",
+  "CMSG_STANDSTATECHANGE": "0x101",
+  "CMSG_SHOWING_HELM": "0x2B9",
+  "CMSG_SHOWING_CLOAK": "0x2BA",
+  "CMSG_TOGGLE_PVP": "0x253",
+  "CMSG_GUILD_INVITE": "0x082",
+  "CMSG_GUILD_ACCEPT": "0x084",
+  "CMSG_GUILD_DECLINE": "0x085",
+  "CMSG_GUILD_INFO": "0x087",
+  "CMSG_GUILD_ROSTER": "0x089",
+  "CMSG_GUILD_PROMOTE": "0x08B",
+  "CMSG_GUILD_DEMOTE": "0x08C",
+  "CMSG_GUILD_LEAVE": "0x08D",
+  "CMSG_GUILD_MOTD": "0x091",
+  "SMSG_GUILD_INFO": "0x088",
+  "SMSG_GUILD_ROSTER": "0x08A",
+  "CMSG_GUILD_QUERY": "0x054",
+  "SMSG_GUILD_QUERY_RESPONSE": "0x055",
+  "SMSG_GUILD_INVITE": "0x083",
+  "CMSG_GUILD_REMOVE": "0x08E",
+  "SMSG_GUILD_EVENT": "0x092",
+  "SMSG_GUILD_COMMAND_RESULT": "0x093",
+  "MSG_RAID_READY_CHECK": "0x322",
+  "SMSG_ITEM_PUSH_RESULT": "0x166",
+  "CMSG_DUEL_ACCEPTED": "0x16C",
+  "CMSG_DUEL_CANCELLED": "0x16D",
+  "SMSG_DUEL_REQUESTED": "0x167",
+  "CMSG_INITIATE_TRADE": "0x116",
+  "MSG_RANDOM_ROLL": "0x1FB",
+  "CMSG_SET_SELECTION": "0x13D",
+  "CMSG_NAME_QUERY": "0x050",
+  "SMSG_NAME_QUERY_RESPONSE": "0x051",
+  "CMSG_CREATURE_QUERY": "0x060",
+  "SMSG_CREATURE_QUERY_RESPONSE": "0x061",
+  "CMSG_GAMEOBJECT_QUERY": "0x05E",
+  "SMSG_GAMEOBJECT_QUERY_RESPONSE": "0x05F",
+  "CMSG_SET_ACTIVE_MOVER": "0x26A",
+  "CMSG_BINDER_ACTIVATE": "0x1B5",
+  "SMSG_LOG_XPGAIN": "0x1D0",
+  "_NOTE_MONSTER_MOVE": "These look swapped vs vanilla (0x0DD/0x2FB) but may be intentional Turtle WoW changes. Check if NPC movement breaks.",
+  "SMSG_MONSTER_MOVE": "0x2FB",
+  "SMSG_COMPRESSED_MOVES": "0x06B",
+  "CMSG_ATTACKSWING": "0x141",
+  "CMSG_ATTACKSTOP": "0x142",
+  "SMSG_ATTACKSTART": "0x143",
+  "SMSG_ATTACKSTOP": "0x144",
+  "SMSG_ATTACKERSTATEUPDATE": "0x14A",
+  "SMSG_AI_REACTION": "0x13C",
+  "SMSG_SPELLNONMELEEDAMAGELOG": "0x250",
+  "SMSG_PLAY_SPELL_VISUAL": "0x1F3",
+  "SMSG_SPELLHEALLOG": "0x150",
+  "SMSG_SPELLENERGIZELOG": "0x151",
+  "SMSG_PERIODICAURALOG": "0x24E",
+  "SMSG_ENVIRONMENTAL_DAMAGE_LOG": "0x1FC",
+  "CMSG_CAST_SPELL": "0x12E",
+  "CMSG_CANCEL_CAST": "0x12F",
+  "CMSG_CANCEL_AURA": "0x136",
+  "SMSG_CAST_FAILED": "0x130",
+  "SMSG_SPELL_START": "0x131",
+  "SMSG_SPELL_GO": "0x132",
+  "SMSG_SPELL_FAILURE": "0x133",
+  "SMSG_SPELL_COOLDOWN": "0x134",
+  "SMSG_COOLDOWN_EVENT": "0x135",
+  "SMSG_EQUIPMENT_SET_SAVED": "0x137",
+  "SMSG_INITIAL_SPELLS": "0x12A",
+  "SMSG_LEARNED_SPELL": "0x12B",
+  "SMSG_SUPERCEDED_SPELL": "0x12C",
+  "SMSG_REMOVED_SPELL": "0x203",
+  "SMSG_SPELL_DELAYED": "0x1E2",
+  "SMSG_SET_FLAT_SPELL_MODIFIER": "0x266",
+  "SMSG_SET_PCT_SPELL_MODIFIER": "0x267",
+  "CMSG_LEARN_TALENT": "0x251",
+  "MSG_TALENT_WIPE_CONFIRM": "0x2AA",
+  "CMSG_GROUP_INVITE": "0x06E",
+  "SMSG_GROUP_INVITE": "0x06F",
+  "CMSG_GROUP_ACCEPT": "0x072",
+  "CMSG_GROUP_DECLINE": "0x073",
+  "SMSG_GROUP_DECLINE": "0x074",
+  "CMSG_GROUP_UNINVITE_GUID": "0x076",
+  "SMSG_GROUP_UNINVITE": "0x077",
+  "CMSG_GROUP_SET_LEADER": "0x078",
+  "SMSG_GROUP_SET_LEADER": "0x079",
+  "CMSG_GROUP_DISBAND": "0x07B",
+  "SMSG_GROUP_LIST": "0x07D",
+  "SMSG_PARTY_COMMAND_RESULT": "0x07F",
+  "MSG_RAID_TARGET_UPDATE": "0x321",
+  "CMSG_REQUEST_RAID_INFO": "0x2CD",
+  "SMSG_RAID_INSTANCE_INFO": "0x2CC",
+  "CMSG_AUTOSTORE_LOOT_ITEM": "0x108",
+  "CMSG_LOOT": "0x15D",
+  "CMSG_LOOT_MONEY": "0x15E",
+  "CMSG_LOOT_RELEASE": "0x15F",
+  "SMSG_LOOT_RESPONSE": "0x160",
+  "SMSG_LOOT_RELEASE_RESPONSE": "0x161",
+  "SMSG_LOOT_REMOVED": "0x162",
+  "SMSG_LOOT_MONEY_NOTIFY": "0x163",
+  "SMSG_LOOT_CLEAR_MONEY": "0x165",
+  "CMSG_ACTIVATETAXI": "0x1AD",
+  "CMSG_GOSSIP_HELLO": "0x17B",
+  "CMSG_GOSSIP_SELECT_OPTION": "0x17C",
+  "SMSG_GOSSIP_MESSAGE": "0x17D",
+  "SMSG_GOSSIP_COMPLETE": "0x17E",
+  "SMSG_NPC_TEXT_UPDATE": "0x180",
+  "CMSG_GAMEOBJ_USE": "0x0B1",
+  "CMSG_QUESTGIVER_STATUS_QUERY": "0x182",
+  "SMSG_QUESTGIVER_STATUS": "0x183",
+  "CMSG_QUESTGIVER_HELLO": "0x184",
+  "SMSG_QUESTGIVER_QUEST_LIST": "0x185",
+  "CMSG_QUESTGIVER_QUERY_QUEST": "0x186",
+  "SMSG_QUESTGIVER_QUEST_DETAILS": "0x188",
+  "CMSG_QUESTGIVER_ACCEPT_QUEST": "0x189",
+  "CMSG_QUESTGIVER_COMPLETE_QUEST": "0x18A",
+  "SMSG_QUESTGIVER_REQUEST_ITEMS": "0x18B",
+  "CMSG_QUESTGIVER_REQUEST_REWARD": "0x18C",
+  "SMSG_QUESTGIVER_OFFER_REWARD": "0x18D",
+  "CMSG_QUESTGIVER_CHOOSE_REWARD": "0x18E",
+  "SMSG_QUESTGIVER_QUEST_INVALID": "0x18F",
+  "SMSG_QUESTGIVER_QUEST_COMPLETE": "0x191",
+  "CMSG_QUESTLOG_REMOVE_QUEST": "0x194",
+  "SMSG_QUESTUPDATE_ADD_KILL": "0x199",
+  "SMSG_QUESTUPDATE_COMPLETE": "0x198",
+  "SMSG_QUEST_FORCE_REMOVE": "0x21E",
+  "CMSG_QUEST_QUERY": "0x05C",
+  "SMSG_QUEST_QUERY_RESPONSE": "0x05D",
+  "SMSG_QUESTLOG_FULL": "0x195",
+  "CMSG_LIST_INVENTORY": "0x19E",
+  "SMSG_LIST_INVENTORY": "0x19F",
+  "CMSG_SELL_ITEM": "0x1A0",
+  "SMSG_SELL_ITEM": "0x1A1",
+  "CMSG_BUY_ITEM": "0x1A2",
+  "CMSG_BUYBACK_ITEM": "0x1A6",
+  "SMSG_BUY_FAILED": "0x1A5",
+  "CMSG_TRAINER_LIST": "0x1B0",
+  "SMSG_TRAINER_LIST": "0x1B1",
+  "CMSG_TRAINER_BUY_SPELL": "0x1B2",
+  "SMSG_TRAINER_BUY_FAILED": "0x1B4",
+  "CMSG_ITEM_QUERY_SINGLE": "0x056",
+  "SMSG_ITEM_QUERY_SINGLE_RESPONSE": "0x058",
+  "CMSG_USE_ITEM": "0x0AB",
+  "CMSG_AUTOEQUIP_ITEM": "0x10A",
+  "CMSG_SWAP_ITEM": "0x10C",
+  "CMSG_SWAP_INV_ITEM": "0x10D",
+  "SMSG_INVENTORY_CHANGE_FAILURE": "0x112",
+  "CMSG_INSPECT": "0x114",
+  "SMSG_INSPECT_RESULTS_UPDATE": "0x115",
+  "CMSG_REPOP_REQUEST": "0x15A",
+  "SMSG_RESURRECT_REQUEST": "0x15B",
+  "CMSG_RESURRECT_RESPONSE": "0x15C",
+  "CMSG_SPIRIT_HEALER_ACTIVATE": "0x21C",
+  "SMSG_SPIRIT_HEALER_CONFIRM": "0x222",
+  "MSG_MOVE_TELEPORT_ACK": "0x0C7",
+  "SMSG_TRANSFER_PENDING": "0x03F",
+  "SMSG_NEW_WORLD": "0x03E",
+  "MSG_MOVE_WORLDPORT_ACK": "0x0DC",
+  "SMSG_TRANSFER_ABORTED": "0x040",
+  "SMSG_FORCE_RUN_SPEED_CHANGE": "0x0E2",
+  "SMSG_CLIENT_CONTROL_UPDATE": "0x159",
+  "CMSG_FORCE_RUN_SPEED_CHANGE_ACK": "0x0E3",
+  "SMSG_SHOWTAXINODES": "0x1A9",
+  "SMSG_ACTIVATETAXIREPLY": "0x1AE",
+  "SMSG_NEW_TAXI_PATH": "0x1AF",
+  "CMSG_ACTIVATETAXIEXPRESS": "0x312",
+  "CMSG_TAXINODE_STATUS_QUERY": "0x1AA",
+  "SMSG_TAXINODE_STATUS": "0x1AB",
+  "SMSG_TRAINER_BUY_SUCCEEDED": "0x1B3",
+  "SMSG_BINDPOINTUPDATE": "0x155",
+  "SMSG_SET_PROFICIENCY": "0x127",
+  "SMSG_ACTION_BUTTONS": "0x129",
+  "SMSG_LEVELUP_INFO": "0x1D4",
+  "SMSG_PLAY_SOUND": "0x2D2",
+  "CMSG_UPDATE_ACCOUNT_DATA": "0x20B",
+  "CMSG_BATTLEFIELD_LIST": "0x23C",
+  "SMSG_BATTLEFIELD_LIST": "0x23D",
+  "CMSG_BATTLEFIELD_JOIN": "0x23E",
+  "CMSG_BATTLEFIELD_STATUS": "0x2D3",
+  "SMSG_BATTLEFIELD_STATUS": "0x2D4",
+  "CMSG_BATTLEFIELD_PORT": "0x2D5",
+  "CMSG_BATTLEMASTER_HELLO": "0x2D7",
+  "MSG_PVP_LOG_DATA": "0x2E0",
+  "CMSG_LEAVE_BATTLEFIELD": "0x2E1",
+  "SMSG_GROUP_JOINED_BATTLEGROUND": "0x2E8",
+  "MSG_BATTLEGROUND_PLAYER_POSITIONS": "0x2E9",
+  "SMSG_BATTLEGROUND_PLAYER_JOINED": "0x2EC",
+  "SMSG_BATTLEGROUND_PLAYER_LEFT": "0x2ED",
+  "CMSG_BATTLEMASTER_JOIN": "0x2EE",
+  "CMSG_EMOTE": "0x102",
+  "SMSG_EMOTE": "0x103",
+  "CMSG_TEXT_EMOTE": "0x104",
+  "SMSG_TEXT_EMOTE": "0x105",
+  "CMSG_JOIN_CHANNEL": "0x097",
+  "CMSG_LEAVE_CHANNEL": "0x098",
+  "SMSG_CHANNEL_NOTIFY": "0x099",
+  "CMSG_CHANNEL_LIST": "0x09A",
+  "SMSG_CHANNEL_LIST": "0x09B",
+  "SMSG_INSPECT_TALENT": "0x3F4",
+  "SMSG_SHOW_MAILBOX": "0x297",
+  "CMSG_GET_MAIL_LIST": "0x23A",
+  "SMSG_MAIL_LIST_RESULT": "0x23B",
+  "CMSG_SEND_MAIL": "0x238",
+  "SMSG_SEND_MAIL_RESULT": "0x239",
+  "CMSG_MAIL_TAKE_MONEY": "0x245",
+  "CMSG_MAIL_TAKE_ITEM": "0x246",
+  "CMSG_MAIL_DELETE": "0x249",
+  "CMSG_MAIL_MARK_AS_READ": "0x247",
+  "SMSG_RECEIVED_MAIL": "0x285",
+  "MSG_QUERY_NEXT_MAIL_TIME": "0x284",
+  "CMSG_BANKER_ACTIVATE": "0x1B7",
+  "SMSG_SHOW_BANK": "0x1B8",
+  "CMSG_BUY_BANK_SLOT": "0x1B9",
+  "SMSG_BUY_BANK_SLOT_RESULT": "0x1BA",
+  "CMSG_AUTOSTORE_BANK_ITEM": "0x282",
+  "CMSG_AUTOBANK_ITEM": "0x283",
+  "MSG_AUCTION_HELLO": "0x255",
+  "CMSG_AUCTION_SELL_ITEM": "0x256",
+  "CMSG_AUCTION_REMOVE_ITEM": "0x257",
+  "CMSG_AUCTION_LIST_ITEMS": "0x258",
+  "CMSG_AUCTION_LIST_OWNER_ITEMS": "0x259",
+  "CMSG_AUCTION_PLACE_BID": "0x25A",
+  "SMSG_AUCTION_COMMAND_RESULT": "0x25B",
+  "SMSG_AUCTION_LIST_RESULT": "0x25C",
+  "SMSG_AUCTION_OWNER_LIST_RESULT": "0x25D",
+  "SMSG_AUCTION_OWNER_NOTIFICATION": "0x25E",
+  "SMSG_AUCTION_BIDDER_NOTIFICATION": "0x260",
+  "CMSG_AUCTION_LIST_BIDDER_ITEMS": "0x264",
+  "SMSG_AUCTION_BIDDER_LIST_RESULT": "0x265",
+  "MSG_MOVE_TIME_SKIPPED": "0x319",
+  "SMSG_CANCEL_AUTO_REPEAT": "0x29C",
+  "SMSG_WEATHER": "0x2F4",
+  "SMSG_QUESTUPDATE_ADD_ITEM": "0x19A",
+  "CMSG_GUILD_DISBAND": "0x08F",
+  "CMSG_GUILD_LEADER": "0x090",
+  "CMSG_GUILD_SET_PUBLIC_NOTE": "0x234",
+  "CMSG_GUILD_SET_OFFICER_NOTE": "0x235"
 }
diff --git a/Data/expansions/turtle/update_fields.json b/Data/expansions/turtle/update_fields.json
index 5b214f59..5f97f29f 100644
--- a/Data/expansions/turtle/update_fields.json
+++ b/Data/expansions/turtle/update_fields.json
@@ -1,50 +1,38 @@
 {
-  "CONTAINER_FIELD_NUM_SLOTS": 48,
-  "CONTAINER_FIELD_SLOT_1": 50,
-  "GAMEOBJECT_DISPLAYID": 8,
-  "GAMEOBJECT_BYTES_1": 14,
-  "ITEM_FIELD_DURABILITY": 48,
-  "ITEM_FIELD_MAXDURABILITY": 49,
-  "ITEM_FIELD_STACK_COUNT": 14,
   "OBJECT_FIELD_ENTRY": 3,
-  "OBJECT_FIELD_SCALE_X": 4,
-  "PLAYER_BYTES": 191,
-  "PLAYER_BYTES_2": 192,
-  "PLAYER_END": 1282,
-  "PLAYER_EXPLORED_ZONES_START": 1111,
-  "PLAYER_FIELD_BANKBAG_SLOT_1": 612,
-  "PLAYER_FIELD_BANK_SLOT_1": 564,
-  "PLAYER_FIELD_COINAGE": 1176,
-  "PLAYER_FIELD_INV_SLOT_HEAD": 486,
-  "PLAYER_FIELD_PACK_SLOT_1": 532,
-  "PLAYER_FLAGS": 190,
-  "PLAYER_NEXT_LEVEL_XP": 717,
-  "PLAYER_QUEST_LOG_START": 198,
-  "PLAYER_REST_STATE_EXPERIENCE": 1175,
-  "PLAYER_SKILL_INFO_START": 718,
-  "PLAYER_XP": 716,
-  "UNIT_DYNAMIC_FLAGS": 143,
-  "UNIT_END": 188,
-  "UNIT_FIELD_AURAFLAGS": 98,
-  "UNIT_FIELD_AURAS": 50,
+  "UNIT_FIELD_TARGET_LO": 16,
+  "UNIT_FIELD_TARGET_HI": 17,
   "UNIT_FIELD_BYTES_0": 36,
-  "UNIT_FIELD_BYTES_1": 133,
-  "UNIT_FIELD_DISPLAYID": 131,
-  "UNIT_FIELD_FACTIONTEMPLATE": 35,
-  "UNIT_FIELD_FLAGS": 46,
   "UNIT_FIELD_HEALTH": 22,
-  "UNIT_FIELD_LEVEL": 34,
+  "UNIT_FIELD_POWER1": 23,
   "UNIT_FIELD_MAXHEALTH": 28,
   "UNIT_FIELD_MAXPOWER1": 29,
+  "UNIT_FIELD_LEVEL": 34,
+  "UNIT_FIELD_FACTIONTEMPLATE": 35,
+  "UNIT_FIELD_FLAGS": 46,
+  "UNIT_FIELD_DISPLAYID": 131,
   "UNIT_FIELD_MOUNTDISPLAYID": 133,
-  "UNIT_FIELD_POWER1": 23,
+  "UNIT_FIELD_AURAS": 50,
+  "UNIT_NPC_FLAGS": 147,
+  "UNIT_DYNAMIC_FLAGS": 143,
   "UNIT_FIELD_RESISTANCES": 154,
-  "UNIT_FIELD_STAT0": 138,
-  "UNIT_FIELD_STAT1": 139,
-  "UNIT_FIELD_STAT2": 140,
-  "UNIT_FIELD_STAT3": 141,
-  "UNIT_FIELD_STAT4": 142,
-  "UNIT_FIELD_TARGET_HI": 17,
-  "UNIT_FIELD_TARGET_LO": 16,
-  "UNIT_NPC_FLAGS": 147
+  "UNIT_END": 188,
+  "PLAYER_FLAGS": 190,
+  "PLAYER_BYTES": 191,
+  "PLAYER_BYTES_2": 192,
+  "PLAYER_XP": 716,
+  "PLAYER_NEXT_LEVEL_XP": 717,
+  "PLAYER_FIELD_COINAGE": 1176,
+  "PLAYER_QUEST_LOG_START": 198,
+  "PLAYER_FIELD_INV_SLOT_HEAD": 486,
+  "PLAYER_FIELD_PACK_SLOT_1": 532,
+  "PLAYER_FIELD_BANK_SLOT_1": 564,
+  "PLAYER_FIELD_BANKBAG_SLOT_1": 612,
+  "PLAYER_SKILL_INFO_START": 718,
+  "PLAYER_EXPLORED_ZONES_START": 1111,
+  "PLAYER_END": 1282,
+  "GAMEOBJECT_DISPLAYID": 8,
+  "ITEM_FIELD_STACK_COUNT": 14,
+  "CONTAINER_FIELD_NUM_SLOTS": 48,
+  "CONTAINER_FIELD_SLOT_1": 50
 }
diff --git a/Data/expansions/wotlk/dbc_layouts.json b/Data/expansions/wotlk/dbc_layouts.json
index e563d2c9..5b500741 100644
--- a/Data/expansions/wotlk/dbc_layouts.json
+++ b/Data/expansions/wotlk/dbc_layouts.json
@@ -1,323 +1,99 @@
 {
-  "Achievement": {
-    "Description": 21,
-    "ID": 0,
-    "Points": 39,
-    "Title": 4
-  },
-  "AchievementCriteria": {
-    "AchievementID": 1,
-    "Description": 9,
-    "ID": 0,
-    "Quantity": 4
-  },
-  "AreaTable": {
-    "ExploreFlag": 3,
-    "ID": 0,
-    "MapID": 1,
-    "ParentAreaNum": 2
-  },
-  "CharHairGeosets": {
-    "GeosetID": 4,
-    "RaceID": 1,
-    "SexID": 2,
-    "Variation": 3
-  },
-  "CharSections": {
-    "BaseSection": 3,
-    "ColorIndex": 5,
-    "Flags": 9,
-    "RaceID": 1,
-    "SexID": 2,
-    "Texture1": 6,
-    "Texture2": 7,
-    "Texture3": 8,
-    "VariationIndex": 4
-  },
-  "CharTitles": {
-    "ID": 0,
-    "Title": 2,
-    "TitleBit": 36
-  },
-  "CharacterFacialHairStyles": {
-    "Geoset100": 3,
-    "Geoset200": 5,
-    "Geoset300": 4,
-    "RaceID": 0,
-    "SexID": 1,
-    "Variation": 2
-  },
-  "CreatureDisplayInfo": {
-    "ExtraDisplayId": 3,
-    "ID": 0,
-    "ModelID": 1,
-    "Skin1": 6,
-    "Skin2": 7,
-    "Skin3": 8
-  },
-  "CreatureDisplayInfoExtra": {
-    "BakeName": 20,
-    "EquipDisplay0": 8,
-    "EquipDisplay1": 9,
-    "EquipDisplay10": 18,
-    "EquipDisplay2": 10,
-    "EquipDisplay3": 11,
-    "EquipDisplay4": 12,
-    "EquipDisplay5": 13,
-    "EquipDisplay6": 14,
-    "EquipDisplay7": 15,
-    "EquipDisplay8": 16,
-    "EquipDisplay9": 17,
-    "FaceID": 4,
-    "FacialHairID": 7,
-    "HairColorID": 6,
-    "HairStyleID": 5,
-    "ID": 0,
-    "RaceID": 1,
-    "SexID": 2,
-    "SkinID": 3
-  },
-  "CreatureModelData": {
-    "ID": 0,
-    "ModelPath": 2
-  },
-  "Emotes": {
-    "AnimID": 2,
-    "ID": 0
-  },
-  "EmotesText": {
-    "Command": 1,
-    "EmoteRef": 2,
-    "ID": 0,
-    "OthersNoTargetTextID": 7,
-    "OthersTargetTextID": 3,
-    "SenderNoTargetTextID": 9,
-    "SenderTargetTextID": 5
-  },
-  "EmotesTextData": {
-    "ID": 0,
-    "Text": 1
-  },
-  "Faction": {
-    "ID": 0,
-    "ReputationBase0": 10,
-    "ReputationBase1": 11,
-    "ReputationBase2": 12,
-    "ReputationBase3": 13,
-    "ReputationRaceMask0": 2,
-    "ReputationRaceMask1": 3,
-    "ReputationRaceMask2": 4,
-    "ReputationRaceMask3": 5
-  },
-  "FactionTemplate": {
-    "Enemy0": 6,
-    "Enemy1": 7,
-    "Enemy2": 8,
-    "Enemy3": 9,
-    "EnemyGroup": 5,
-    "Faction": 1,
-    "FactionGroup": 3,
-    "FriendGroup": 4,
-    "ID": 0
-  },
-  "GameObjectDisplayInfo": {
-    "ID": 0,
-    "ModelName": 1
+  "Spell": {
+    "ID": 0, "Attributes": 4, "IconID": 133,
+    "Name": 136, "Tooltip": 139, "Rank": 153, "SchoolMask": 225
   },
   "ItemDisplayInfo": {
-    "GeosetGroup1": 7,
-    "GeosetGroup3": 9,
-    "ID": 0,
-    "InventoryIcon": 5,
-    "LeftModel": 1,
-    "LeftModelTexture": 3,
-    "TextureArmLower": 15,
-    "TextureArmUpper": 14,
-    "TextureFoot": 21,
-    "TextureHand": 16,
-    "TextureLegLower": 20,
-    "TextureLegUpper": 19,
-    "TextureTorsoLower": 18,
-    "TextureTorsoUpper": 17
+    "ID": 0, "LeftModel": 1, "LeftModelTexture": 3,
+    "InventoryIcon": 5, "GeosetGroup1": 7, "GeosetGroup3": 9,
+    "TextureArmUpper": 14, "TextureArmLower": 15, "TextureHand": 16,
+    "TextureTorsoUpper": 17, "TextureTorsoLower": 18,
+    "TextureLegUpper": 19, "TextureLegLower": 20, "TextureFoot": 21
   },
-  "ItemSet": {
-    "ID": 0,
-    "Item0": 18,
-    "Item1": 19,
-    "Item2": 20,
-    "Item3": 21,
-    "Item4": 22,
-    "Item5": 23,
-    "Item6": 24,
-    "Item7": 25,
-    "Item8": 26,
-    "Item9": 27,
-    "Name": 1,
-    "Spell0": 28,
-    "Spell1": 29,
-    "Spell2": 30,
-    "Spell3": 31,
-    "Spell4": 32,
-    "Spell5": 33,
-    "Spell6": 34,
-    "Spell7": 35,
-    "Spell8": 36,
-    "Spell9": 37,
-    "Threshold0": 38,
-    "Threshold1": 39,
-    "Threshold2": 40,
-    "Threshold3": 41,
-    "Threshold4": 42,
-    "Threshold5": 43,
-    "Threshold6": 44,
-    "Threshold7": 45,
-    "Threshold8": 46,
-    "Threshold9": 47
+  "CharSections": {
+    "RaceID": 1, "SexID": 2, "BaseSection": 3,
+    "VariationIndex": 4, "ColorIndex": 5,
+    "Texture1": 6, "Texture2": 7, "Texture3": 8,
+    "Flags": 9
   },
-  "LFGDungeons": {
-    "ID": 0,
-    "Name": 1
+  "SpellIcon": { "ID": 0, "Path": 1 },
+  "FactionTemplate": {
+    "ID": 0, "Faction": 1, "FactionGroup": 3,
+    "FriendGroup": 4, "EnemyGroup": 5,
+    "Enemy0": 6, "Enemy1": 7, "Enemy2": 8, "Enemy3": 9
   },
-  "Light": {
-    "ID": 0,
-    "InnerRadius": 5,
-    "LightParamsID": 7,
-    "LightParamsIDRain": 8,
-    "LightParamsIDUnderwater": 9,
-    "MapID": 1,
-    "OuterRadius": 6,
-    "X": 2,
-    "Y": 4,
-    "Z": 3
+  "Faction": {
+    "ID": 0, "ReputationRaceMask0": 2, "ReputationRaceMask1": 3,
+    "ReputationRaceMask2": 4, "ReputationRaceMask3": 5,
+    "ReputationBase0": 10, "ReputationBase1": 11,
+    "ReputationBase2": 12, "ReputationBase3": 13
   },
-  "LightFloatBand": {
-    "BlockIndex": 1,
-    "NumKeyframes": 2,
-    "TimeKey0": 3,
-    "Value0": 19
+  "Achievement": { "ID": 0, "Title": 4, "Description": 21 },
+  "AreaTable": { "ID": 0, "ExploreFlag": 3 },
+  "CreatureDisplayInfoExtra": {
+    "ID": 0, "RaceID": 1, "SexID": 2, "SkinID": 3, "FaceID": 4,
+    "HairStyleID": 5, "HairColorID": 6, "FacialHairID": 7,
+    "EquipDisplay0": 8, "EquipDisplay1": 9, "EquipDisplay2": 10,
+    "EquipDisplay3": 11, "EquipDisplay4": 12, "EquipDisplay5": 13,
+    "EquipDisplay6": 14, "EquipDisplay7": 15, "EquipDisplay8": 16,
+    "EquipDisplay9": 17, "EquipDisplay10": 18, "BakeName": 20
   },
-  "LightIntBand": {
-    "BlockIndex": 1,
-    "NumKeyframes": 2,
-    "TimeKey0": 3,
-    "Value0": 19
-  },
-  "LightParams": {
-    "LightParamsID": 0
-  },
-  "Map": {
-    "ID": 0,
-    "InternalName": 1
-  },
-  "SkillLine": {
-    "Category": 1,
-    "ID": 0,
-    "Name": 3
-  },
-  "SkillLineAbility": {
-    "SkillLineID": 1,
-    "SpellID": 2
-  },
-  "Spell": {
-    "Attributes": 4,
-    "AttributesEx": 5,
-    "CastingTimeIndex": 47,
-    "DispelType": 2,
-    "DurationIndex": 40,
-    "EffectBasePoints0": 80,
-    "EffectBasePoints1": 81,
-    "EffectBasePoints2": 82,
-    "ID": 0,
-    "IconID": 133,
-    "ManaCost": 39,
-    "Name": 136,
-    "PowerType": 14,
-    "RangeIndex": 49,
-    "Rank": 153,
-    "SchoolMask": 225,
-    "Tooltip": 139
-  },
-  "SpellIcon": {
-    "ID": 0,
-    "Path": 1
-  },
-  "SpellItemEnchantment": {
-    "ID": 0,
-    "Name": 8
-  },
-  "SpellRange": {
-    "MaxRange": 4
-  },
-  "SpellVisual": {
-    "CastKit": 2,
-    "ID": 0,
-    "ImpactKit": 3,
-    "MissileModel": 8
-  },
-  "SpellVisualEffectName": {
-    "FilePath": 2,
-    "ID": 0
-  },
-  "SpellVisualKit": {
-    "BaseEffect": 5,
-    "ID": 0,
-    "SpecialEffect0": 11,
-    "SpecialEffect1": 12,
-    "SpecialEffect2": 13
-  },
-  "Talent": {
-    "Column": 3,
-    "ID": 0,
-    "PrereqRank0": 12,
-    "PrereqTalent0": 9,
-    "RankSpell0": 4,
-    "Row": 2,
-    "TabID": 1
-  },
-  "TalentTab": {
-    "BackgroundFile": 23,
-    "ClassMask": 20,
-    "ID": 0,
-    "Name": 1,
-    "OrderIndex": 22
+  "CreatureDisplayInfo": {
+    "ID": 0, "ModelID": 1, "ExtraDisplayId": 3,
+    "Skin1": 6, "Skin2": 7, "Skin3": 8
   },
   "TaxiNodes": {
-    "ID": 0,
-    "MapID": 1,
-    "MountDisplayIdAlliance": 22,
-    "MountDisplayIdAllianceFallback": 20,
-    "MountDisplayIdHorde": 23,
-    "MountDisplayIdHordeFallback": 21,
-    "Name": 5,
-    "X": 2,
-    "Y": 3,
-    "Z": 4
-  },
-  "TaxiPath": {
-    "Cost": 3,
-    "FromNode": 1,
-    "ID": 0,
-    "ToNode": 2
+    "ID": 0, "MapID": 1, "X": 2, "Y": 3, "Z": 4, "Name": 5,
+    "MountDisplayIdAllianceFallback": 20, "MountDisplayIdHordeFallback": 21,
+    "MountDisplayIdAlliance": 22, "MountDisplayIdHorde": 23
   },
+  "TaxiPath": { "ID": 0, "FromNode": 1, "ToNode": 2, "Cost": 3 },
   "TaxiPathNode": {
-    "ID": 0,
-    "MapID": 3,
-    "NodeIndex": 2,
-    "PathID": 1,
-    "X": 4,
-    "Y": 5,
-    "Z": 6
+    "ID": 0, "PathID": 1, "NodeIndex": 2, "MapID": 3,
+    "X": 4, "Y": 5, "Z": 6
+  },
+  "TalentTab": {
+    "ID": 0, "Name": 1, "ClassMask": 20,
+    "OrderIndex": 22, "BackgroundFile": 23
+  },
+  "Talent": {
+    "ID": 0, "TabID": 1, "Row": 2, "Column": 3,
+    "RankSpell0": 4, "PrereqTalent0": 9, "PrereqRank0": 12
+  },
+  "SkillLineAbility": { "SkillLineID": 1, "SpellID": 2 },
+  "SkillLine": { "ID": 0, "Category": 1, "Name": 3 },
+  "Map": { "ID": 0, "InternalName": 1 },
+  "CreatureModelData": { "ID": 0, "ModelPath": 2 },
+  "CharHairGeosets": {
+    "RaceID": 1, "SexID": 2, "Variation": 3, "GeosetID": 4
+  },
+  "CharacterFacialHairStyles": {
+    "RaceID": 0, "SexID": 1, "Variation": 2,
+    "Geoset100": 3, "Geoset300": 4, "Geoset200": 5
+  },
+  "GameObjectDisplayInfo": { "ID": 0, "ModelName": 1 },
+  "Emotes": { "ID": 0, "AnimID": 2 },
+  "EmotesText": {
+    "ID": 0, "Command": 1, "EmoteRef": 2,
+    "OthersTargetTextID": 3, "SenderTargetTextID": 5,
+    "OthersNoTargetTextID": 7, "SenderNoTargetTextID": 9
+  },
+  "EmotesTextData": { "ID": 0, "Text": 1 },
+  "Light": {
+    "ID": 0, "MapID": 1, "X": 2, "Z": 3, "Y": 4,
+    "InnerRadius": 5, "OuterRadius": 6, "LightParamsID": 7,
+    "LightParamsIDRain": 8, "LightParamsIDUnderwater": 9
+  },
+  "LightParams": { "LightParamsID": 0 },
+  "LightIntBand": {
+    "BlockIndex": 1, "NumKeyframes": 2, "TimeKey0": 3, "Value0": 19
+  },
+  "LightFloatBand": {
+    "BlockIndex": 1, "NumKeyframes": 2, "TimeKey0": 3, "Value0": 19
   },
   "WorldMapArea": {
-    "AreaID": 2,
-    "AreaName": 3,
-    "DisplayMapID": 8,
-    "ID": 0,
-    "LocBottom": 7,
-    "LocLeft": 4,
-    "LocRight": 5,
-    "LocTop": 6,
-    "MapID": 1,
-    "ParentWorldMapID": 10
+    "ID": 0, "MapID": 1, "AreaID": 2, "AreaName": 3,
+    "LocLeft": 4, "LocRight": 5, "LocTop": 6, "LocBottom": 7,
+    "DisplayMapID": 8, "ParentWorldMapID": 10
   }
 }
diff --git a/Data/expansions/wotlk/update_fields.json b/Data/expansions/wotlk/update_fields.json
index 49fcbdd5..f308cf0d 100644
--- a/Data/expansions/wotlk/update_fields.json
+++ b/Data/expansions/wotlk/update_fields.json
@@ -1,63 +1,37 @@
 {
-  "CONTAINER_FIELD_NUM_SLOTS": 64,
-  "CONTAINER_FIELD_SLOT_1": 66,
-  "GAMEOBJECT_DISPLAYID": 8,
-  "GAMEOBJECT_BYTES_1": 17,
-  "ITEM_FIELD_DURABILITY": 60,
-  "ITEM_FIELD_MAXDURABILITY": 61,
-  "ITEM_FIELD_STACK_COUNT": 14,
   "OBJECT_FIELD_ENTRY": 3,
-  "OBJECT_FIELD_SCALE_X": 4,
-  "PLAYER_BLOCK_PERCENTAGE": 1024,
-  "PLAYER_BYTES": 153,
-  "PLAYER_BYTES_2": 154,
-  "PLAYER_CHOSEN_TITLE": 1349,
-  "PLAYER_CRIT_PERCENTAGE": 1029,
-  "PLAYER_DODGE_PERCENTAGE": 1025,
-  "PLAYER_EXPLORED_ZONES_START": 1041,
-  "PLAYER_FIELD_ARENA_CURRENCY": 1423,
-  "PLAYER_FIELD_BANKBAG_SLOT_1": 458,
-  "PLAYER_FIELD_BANK_SLOT_1": 402,
-  "PLAYER_FIELD_COINAGE": 1170,
-  "PLAYER_FIELD_COMBAT_RATING_1": 1231,
-  "PLAYER_FIELD_HONOR_CURRENCY": 1422,
-  "PLAYER_FIELD_INV_SLOT_HEAD": 324,
-  "PLAYER_FIELD_MOD_DAMAGE_DONE_POS": 1171,
-  "PLAYER_FIELD_MOD_HEALING_DONE_POS": 1192,
-  "PLAYER_FIELD_PACK_SLOT_1": 370,
-  "PLAYER_FLAGS": 150,
-  "PLAYER_NEXT_LEVEL_XP": 635,
-  "PLAYER_PARRY_PERCENTAGE": 1026,
-  "PLAYER_QUEST_LOG_START": 158,
-  "PLAYER_RANGED_CRIT_PERCENTAGE": 1030,
-  "PLAYER_REST_STATE_EXPERIENCE": 1169,
-  "PLAYER_SKILL_INFO_START": 636,
-  "PLAYER_SPELL_CRIT_PERCENTAGE1": 1032,
-  "PLAYER_XP": 634,
-  "UNIT_DYNAMIC_FLAGS": 147,
-  "UNIT_END": 148,
-  "UNIT_FIELD_ATTACK_POWER": 123,
+  "UNIT_FIELD_TARGET_LO": 6,
+  "UNIT_FIELD_TARGET_HI": 7,
   "UNIT_FIELD_BYTES_0": 23,
-  "UNIT_FIELD_BYTES_1": 137,
-  "UNIT_FIELD_DISPLAYID": 67,
+  "UNIT_FIELD_HEALTH": 24,
+  "UNIT_FIELD_POWER1": 25,
+  "UNIT_FIELD_MAXHEALTH": 32,
+  "UNIT_FIELD_MAXPOWER1": 33,
+  "UNIT_FIELD_LEVEL": 54,
   "UNIT_FIELD_FACTIONTEMPLATE": 55,
   "UNIT_FIELD_FLAGS": 59,
   "UNIT_FIELD_FLAGS_2": 60,
-  "UNIT_FIELD_HEALTH": 24,
-  "UNIT_FIELD_LEVEL": 54,
-  "UNIT_FIELD_MAXHEALTH": 32,
-  "UNIT_FIELD_MAXPOWER1": 33,
+  "UNIT_FIELD_DISPLAYID": 67,
   "UNIT_FIELD_MOUNTDISPLAYID": 69,
-  "UNIT_FIELD_POWER1": 25,
-  "UNIT_FIELD_RANGED_ATTACK_POWER": 126,
-  "UNIT_FIELD_RESISTANCES": 99,
-  "UNIT_FIELD_STAT0": 84,
-  "UNIT_FIELD_STAT1": 85,
-  "UNIT_FIELD_STAT2": 86,
-  "UNIT_FIELD_STAT3": 87,
-  "UNIT_FIELD_STAT4": 88,
-  "UNIT_FIELD_TARGET_HI": 7,
-  "UNIT_FIELD_TARGET_LO": 6,
   "UNIT_NPC_FLAGS": 82,
-  "UNIT_NPC_EMOTESTATE": 164
+  "UNIT_DYNAMIC_FLAGS": 147,
+  "UNIT_FIELD_RESISTANCES": 99,
+  "UNIT_END": 148,
+  "PLAYER_FLAGS": 150,
+  "PLAYER_BYTES": 153,
+  "PLAYER_BYTES_2": 154,
+  "PLAYER_XP": 634,
+  "PLAYER_NEXT_LEVEL_XP": 635,
+  "PLAYER_FIELD_COINAGE": 1170,
+  "PLAYER_QUEST_LOG_START": 158,
+  "PLAYER_FIELD_INV_SLOT_HEAD": 324,
+  "PLAYER_FIELD_PACK_SLOT_1": 370,
+  "PLAYER_FIELD_BANK_SLOT_1": 402,
+  "PLAYER_FIELD_BANKBAG_SLOT_1": 458,
+  "PLAYER_SKILL_INFO_START": 636,
+  "PLAYER_EXPLORED_ZONES_START": 1041,
+  "GAMEOBJECT_DISPLAYID": 8,
+  "ITEM_FIELD_STACK_COUNT": 14,
+  "CONTAINER_FIELD_NUM_SLOTS": 64,
+  "CONTAINER_FIELD_SLOT_1": 66
 }
diff --git a/Data/opcodes/aliases.json b/Data/opcodes/aliases.json
index 4677cd5d..e3a67348 100644
--- a/Data/opcodes/aliases.json
+++ b/Data/opcodes/aliases.json
@@ -41,6 +41,7 @@
     "SMSG_SPLINE_MOVE_SET_RUN_BACK_SPEED": "SMSG_SPLINE_SET_RUN_BACK_SPEED",
     "SMSG_SPLINE_MOVE_SET_RUN_SPEED": "SMSG_SPLINE_SET_RUN_SPEED",
     "SMSG_SPLINE_MOVE_SET_SWIM_SPEED": "SMSG_SPLINE_SET_SWIM_SPEED",
+    "SMSG_UPDATE_AURA_DURATION": "SMSG_EQUIPMENT_SET_SAVED",
     "SMSG_VICTIMSTATEUPDATE_OBSOLETE": "SMSG_BATTLEFIELD_PORT_DENIED"
   }
 }
diff --git a/EXPANSION_GUIDE.md b/EXPANSION_GUIDE.md
deleted file mode 100644
index a1257a21..00000000
--- a/EXPANSION_GUIDE.md
+++ /dev/null
@@ -1,130 +0,0 @@
-# Multi-Expansion Architecture Guide
-
-WoWee supports three World of Warcraft expansions in a unified codebase using an expansion profile system. This guide explains how the multi-expansion support works.
-
-## Supported Expansions
-
-- **Vanilla (Classic) 1.12** - Original World of Warcraft
-- **The Burning Crusade (TBC) 2.4.3** - First expansion
-- **Wrath of the Lich King (WotLK) 3.3.5a** - Second expansion
-- **Turtle WoW 1.17** - Custom Vanilla-based server with extended content
-
-## Architecture Overview
-
-The multi-expansion support is built on the **Expansion Profile** system:
-
-1. **ExpansionProfile** (`include/game/expansion_profile.hpp`) - Metadata about each expansion
-   - Defines protocol version, data paths, asset locations
-   - Specifies which packet parsers to use
-
-2. **Packet Parsers** - Expansion-specific message handling
-   - `packet_parsers_classic.cpp` - Vanilla 1.12 / Turtle WoW message parsing
-   - `packet_parsers_tbc.cpp` - TBC 2.4.3 message parsing
-   - Default (WotLK 3.3.5a) parsers in `game_handler.cpp` and domain handlers
-
-3. **Update Fields** - Expansion-specific entity data layout
-   - Loaded from `update_fields.json` in expansion data directory
-   - Defines UNIT_END, OBJECT_END, field indices for stats/health/mana
-
-## How to Use Different Expansions
-
-### At Startup
-
-WoWee auto-detects the expansion based on:
-1. Realm list response (protocol version)
-2. Server build number
-3. Update field count
-
-### Manual Selection
-
-Set environment variable:
-```bash
-WOWEE_EXPANSION=tbc ./wowee    # Force TBC
-WOWEE_EXPANSION=classic ./wowee # Force Classic
-```
-
-## Key Differences Between Expansions
-
-### Packet Format Differences
-
-#### SMSG_SPELL_COOLDOWN
-- **Classic**: 12 bytes per entry (spellId + itemId + cooldown, no flags)
-- **TBC/WotLK**: 8 bytes per entry (spellId + cooldown) + flags byte
-
-#### SMSG_ACTION_BUTTONS
-- **Classic**: 120 slots, no mode byte
-- **TBC**: 132 slots, no mode byte
-- **WotLK**: 144 slots + uint8 mode byte
-
-#### SMSG_PARTY_MEMBER_STATS
-- **Classic/TBC**: Full uint64 for guid, uint16 health
-- **WotLK**: PackedGuid format, uint32 health
-
-### Data Differences
-
-- **Talent trees**: Different spell IDs and tree structure per expansion
-- **Items**: Different ItemDisplayInfo entries
-- **Spells**: Different base stats, cooldowns
-- **Character textures**: Expansion-specific variants for races
-
-## Adding Support for Another Expansion
-
-1. Create new expansion profile entry in `expansion_profile.cpp`
-2. Add packet parser file (`packet_parsers_*.cpp`) for message variants
-3. Create update_fields.json with correct field layout
-4. Test realm connection and character loading
-
-## Code Patterns
-
-### Checking Current Expansion
-
-```cpp
-#include "game/game_utils.hpp"
-
-// Shared helpers (defined in game_utils.hpp)
-if (isActiveExpansion("tbc")) {
-    // TBC-specific code
-}
-
-if (isClassicLikeExpansion()) {
-    // Classic or Turtle WoW
-}
-
-if (isPreWotlk()) {
-    // Classic, Turtle, or TBC (not WotLK)
-}
-```
-
-### Expansion-Specific Packet Parsing
-
-```cpp
-// In packet_parsers_*.cpp, implement expansion-specific logic
-bool TbcPacketParsers::parseXxx(network::Packet& packet, XxxData& data) {
-    // Custom logic for this expansion's packet format
-}
-```
-
-## Common Issues
-
-### "Update fields mismatch" Error
-- Ensure `update_fields.json` matches server's field layout
-- Check OBJECT_END and UNIT_END values
-- Verify field indices for your target expansion
-
-### "Unknown packet" Warnings
-- Expansion-specific opcodes may not be registered
-- Check packet parser registration in `game_handler.cpp`
-- Verify expansion profile is active
-
-### Packet Parsing Failures
-- Each expansion has different struct layouts
-- Always read data size first, then upfront validate
-- Use size capping (e.g., max 100 items in list)
-
-## References
-
-- `include/game/expansion_profile.hpp` - Expansion metadata
-- `include/game/game_utils.hpp` - `isActiveExpansion()`, `isClassicLikeExpansion()`, `isPreWotlk()`
-- `src/game/packet_parsers_classic.cpp` / `packet_parsers_tbc.cpp` - Expansion-specific parsing
-- `docs/status.md` - Current feature support
-- `docs/` directory - Additional protocol documentation
diff --git a/GETTING_STARTED.md b/GETTING_STARTED.md
deleted file mode 100644
index 4240f97e..00000000
--- a/GETTING_STARTED.md
+++ /dev/null
@@ -1,226 +0,0 @@
-# Getting Started with WoWee
-
-WoWee is a native C++ World of Warcraft client that connects to private servers. This guide walks you through setting up and playing WoWee.
-
-## Prerequisites
-
-- **World of Warcraft Game Data** (Vanilla 1.12, TBC 2.4.3, or WotLK 3.3.5a)
-- **A Private Server** (AzerothCore, TrinityCore, Mangos, or Turtle WoW compatible)
-- **System Requirements**: Linux, macOS, or Windows with a Vulkan-capable GPU
-
-## Installation
-
-### Step 1: Build WoWee
-
-See [Building](README.md#building) section in README for detailed build instructions.
-
-**Quick start (Linux/macOS)**:
-```bash
-./build.sh
-cd build/bin
-./wowee
-```
-
-**Quick start (Windows)**:
-```powershell
-.\build.ps1
-cd build\bin
-.\wowee.exe
-```
-
-### Step 2: Extract Game Data
-
-WoWee needs game assets from your WoW installation:
-
-**Using provided script (Linux/macOS)**:
-```bash
-./extract_assets.sh /path/to/wow/directory
-```
-
-**Using provided script (Windows)**:
-```powershell
-.\extract_assets.ps1 "C:\Games\WoW-3.3.5a\Data"
-```
-
-**Manual extraction**:
-1. Install [StormLib](https://github.com/ladislav-zezula/StormLib)
-2. Use `asset_extract` or extract manually to `./Data/`:
-   ```
-   Data/
-   ├── manifest.json          # File index (generated by asset_extract)
-   ├── expansions/<id>/       # Per-expansion config and DB
-   ├── character/             # Character textures
-   ├── creature/              # Creature models/textures
-   ├── interface/             # UI textures and icons
-   ├── item/                  # Item model textures
-   ├── spell/                 # Spell effect models
-   ├── terrain/               # ADT terrain, WMO, M2 doodads
-   ├── world/                 # World map images
-   └── sound/                 # Audio files
-   ```
-
-### Step 3: Connect to a Server
-
-1. **Start WoWee**
-   ```bash
-   cd build/bin && ./wowee
-   ```
-
-2. **Enter Realm Information**
-   - Server Address: e.g., `localhost:3724` or `play.example.com:3724`
-   - WoWee fetches the realm list automatically
-   - Select your realm and click **Connect**
-
-3. **Choose Character**
-   - Select existing character or create new one
-   - Customize appearance and settings
-   - Click **Enter World**
-
-## First Steps in Game
-
-### Default Controls
-
-| Action | Key |
-|--------|-----|
-| Move Forward | W |
-| Move Backward | S |
-| Strafe Left | A |
-| Strafe Right | D |
-| Jump | Space |
-| Toggle Chat | Enter |
-| Open Character Screen | C |
-| Open Inventory | I |
-| Open All Bags | B |
-| Open Spellbook | P |
-| Open Talents | N |
-| Open Quest Log | L |
-| Open World Map | M |
-| Toggle Nameplates | V |
-| Toggle Raid Frames | F |
-| Open Guild Roster | O |
-| Open Dungeon Finder | J |
-| Open Achievements | Y |
-| Open Skills | K |
-| Toggle Settings | Escape |
-| Target Next Enemy | Tab |
-| Target Previous Enemy | Shift+Tab |
-
-### Customizing Controls
-
-Press **Escape** → **Keybindings** to customize hotkeys.
-
-## Recommended First Steps
-
-### 1. Adjust Graphics Settings
-- Press Escape → **Video Settings**
-- Select appropriate **Graphics Preset** for your GPU:
-  - **LOW**: Low-end GPUs or when performance is priority
-  - **MEDIUM**: Balanced quality and performance
-  - **HIGH**: Good GPU with modern drivers
-  - **ULTRA**: High-end GPU for maximum quality
-
-### 2. Adjust Audio
-- Press Escape → **Audio Settings**
-- Set **Master Volume** to preferred level
-- Adjust individual audio tracks (Music, Ambient, UI, etc.)
-- Toggle **Original Soundtrack** if available
-
-### 3. Configure UI
-- Press Escape → **Game Settings**
-- Minimap preferences (rotation, square mode, zoom)
-- Bag settings (separate windows, compact mode)
-- Action bar visibility
-
-### 4. Complete First Quest
-- Talk to nearby NPCs (they have quest markers ! or ?)
-- Accept quest, complete objectives, return for reward
-- Level up and gain experience
-
-## Important Notes
-
-### Data Directory
-Game data is loaded from `Data/` subdirectory:
-- If running from build folder: `../../Data` (symlinked automatically)
-- If running from binary folder: `./Data` (must exist)
-- If running in-place: Ensure `Data/` is in correct location
-
-### Settings
-- Settings are saved to `~/.wowee/settings.cfg` (Linux/macOS)
-- Or `%APPDATA%\wowee\settings.cfg` (Windows)
-- Keybindings, graphics settings, and UI state persist
-
-### Multi-Expansion Support
-WoWee auto-detects expansion from server:
-- **Vanilla 1.12** - Original game
-- **TBC 2.4.3** - Burning Crusade
-- **WotLK 3.3.5a** - Wrath of the Lich King
-
-You can override with environment variable:
-```bash
-WOWEE_EXPANSION=tbc ./wowee    # Force TBC
-```
-
-## Troubleshooting
-
-### "No realm list" or "Connection Failed"
-- Check server address is correct
-- Verify server is running
-- See [Troubleshooting Guide](TROUBLESHOOTING.md#connection-issues)
-
-### Graphics Errors
-- See [Graphics Troubleshooting](TROUBLESHOOTING.md#graphics-issues)
-- Start with LOW graphics preset
-- Update GPU driver
-
-### Audio Not Working
-- Check system audio is enabled
-- Verify audio files are extracted
-- See [Audio Troubleshooting](TROUBLESHOOTING.md#audio-issues)
-
-### General Issues
-- Comprehensive troubleshooting: See [TROUBLESHOOTING.md](TROUBLESHOOTING.md)
-- Check `logs/wowee.log` in the working directory for errors
-- Verify expansion matches server requirements
-
-## Server Configuration
-
-### Tested Servers
-- **AzerothCore** - Full support, recommended for learning
-- **TrinityCore** - Full support, extensive customization
-- **Mangos** - Full support, solid foundation
-- **Turtle WoW** - Full support, 1.17 custom content
-
-### Server Requirements
-- Must support Vanilla, TBC, or WotLK protocol
-- Warden anti-cheat supported (module execution via emulation)
-- Network must allow connections to realm list and world server ports
-
-See [Multi-Expansion Guide](EXPANSION_GUIDE.md) for protocol details.
-
-## Next Steps
-
-1. **Explore the World** - Travel to different zones and enjoy the landscape
-2. **Join a Guild** - Find other players to group with
-3. **Run Dungeons** - Experience instanced content
-4. **PvP** - Engage in player-versus-player combat
-5. **Twink Alt** - Create additional characters
-6. **Customize Settings** - Fine-tune graphics, audio, and UI
-
-## Getting Help
-
-- **Game Issues**: See [TROUBLESHOOTING.md](TROUBLESHOOTING.md)
-- **Graphics Help**: See [Graphics & Performance](README.md#graphics--performance) section
-- **Multi-Expansion**: See [EXPANSION_GUIDE.md](EXPANSION_GUIDE.md)
-- **Building Issues**: See [README.md](README.md#building)
-
-## Tips for Better Performance
-
-- Start with reasonable graphics preset for your GPU
-- Close other applications when testing
-- Keep GPU drivers updated
-- Use FSR2 (if supported) for smooth 60+ FPS on weaker hardware
-- Monitor frame rate with debug overlay (if available)
-
-## Enjoy!
-
-WoWee is a project to experience classic World of Warcraft on a modern engine. Have fun exploring Azeroth!
diff --git a/PKGBUILD b/PKGBUILD
index 15091216..013be0a1 100644
--- a/PKGBUILD
+++ b/PKGBUILD
@@ -9,27 +9,28 @@ arch=('x86_64')
 url="https://github.com/Kelsidavis/WoWee"
 license=('MIT')
 depends=(
-  'sdl2'              # Windowing and event loop
-  'vulkan-icd-loader' # Vulkan runtime (GPU driver communication)
-  'openssl'           # SRP6a auth protocol (key exchange + RC4 encryption)
-  'zlib'              # Network packet decompression and Warden module inflate
-  'ffmpeg'            # Video playback (login cinematics)
-  'unicorn'           # Warden anti-cheat x86 emulation (cross-platform, no Wine)
-  'libx11'            # X11 windowing support
-  'stormlib'          # AUR — MPQ extraction (wowee-extract-assets uses libstorm.so)
+  'sdl2'
+  'vulkan-icd-loader'
+  'openssl'
+  'zlib'
+  'ffmpeg'
+  'unicorn'
+  'glew'
+  'libx11'
+  'stormlib'  # AUR — required at runtime by wowee-extract-assets (libstorm.so)
 )
 makedepends=(
-  'git'               # Clone submodules (imgui, vk-bootstrap)
-  'cmake'             # Build system
-  'pkgconf'           # Dependency detection
-  'glm'               # Header-only math library (vectors, matrices, quaternions)
-  'vulkan-headers'    # Vulkan API definitions (build-time only)
-  'shaderc'           # GLSL → SPIR-V shader compilation
-  'python'            # Opcode registry generation and DBC validation scripts
+  'git'
+  'cmake'
+  'pkgconf'
+  'glm'
+  'vulkan-headers'
+  'shaderc'
+  'python'
 )
 provides=('wowee')
 conflicts=('wowee')
-source=("${pkgname}::git+https://github.com/Kelsidavis/WoWee.git#branch=master"
+source=("${pkgname}::git+https://github.com/Kelsidavis/WoWee.git#branch=main"
         "git+https://github.com/ocornut/imgui.git"
         "git+https://github.com/charles-lunarg/vk-bootstrap.git")
 sha256sums=('SKIP' 'SKIP' 'SKIP')
diff --git a/README.md b/README.md
index 69e0a6dd..54ae7eaa 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@
 A native C++ World of Warcraft client with a custom Vulkan renderer.
 
 [![Sponsor](https://img.shields.io/github/sponsors/Kelsidavis?label=Sponsor&logo=GitHub)](https://github.com/sponsors/Kelsidavis)
-[![Discord](https://img.shields.io/discord/1?label=Discord&logo=discord)](https://discord.gg/PSdMPS8uje)
+[![Discord](https://img.shields.io/discord/1?label=Discord&logo=discord)](https://discord.gg/SDqjA79B)
 
 [![Watch the video](https://img.youtube.com/vi/B-jtpPmiXGM/maxresdefault.jpg)](https://youtu.be/B-jtpPmiXGM)
 
@@ -19,15 +19,13 @@ Protocol Compatible with **Vanilla (Classic) 1.12 + TBC 2.4.3 + WotLK 3.3.5a**.
 
 > **Legal Disclaimer**: This is an educational/research project. It does not include any Blizzard Entertainment assets, data files, or proprietary code. World of Warcraft and all related assets are the property of Blizzard Entertainment, Inc. This project is not affiliated with or endorsed by Blizzard Entertainment. Users are responsible for supplying their own legally obtained game data files and for ensuring compliance with all applicable laws in their jurisdiction.
 
-## Status & Direction (2026-03-30)
+## Status & Direction (2026-03-07)
 
-- **Compatibility**: **Vanilla (Classic) 1.12 + TBC 2.4.3 + WotLK 3.3.5a** are all supported via expansion profiles and per-expansion packet parsers. All three expansions are roughly on par.
-- **Tested against**: AzerothCore/ChromieCraft, TrinityCore, Mangos, and Turtle WoW (1.17).
-- **Current focus**: code quality (SOLID decomposition, documentation), rendering stability, and multi-expansion coverage.
+- **Compatibility**: **Vanilla (Classic) 1.12 + TBC 2.4.3 + WotLK 3.3.5a** are all supported via expansion profiles and per-expansion packet parsers (`src/game/packet_parsers_classic.cpp`, `src/game/packet_parsers_tbc.cpp`). All three expansions are roughly on par — no single one is significantly more complete than the others.
+- **Tested against**: AzerothCore, TrinityCore, Mangos, and Turtle WoW (1.17).
+- **Current focus**: instance dungeons, visual accuracy (lava/water, shadow mapping, WMO interiors), and multi-expansion coverage.
 - **Warden**: Full module execution via Unicorn Engine CPU emulation. Decrypts (RC4→RSA→zlib), parses and relocates the PE module, executes via x86 emulation with Windows API interception. Module cache at `~/.local/share/wowee/warden_cache/`.
-- **CI**: GitHub Actions builds for Linux (x86-64, ARM64), Windows (MSYS2 x86-64 + ARM64), and macOS (ARM64). Security scans via CodeQL, Semgrep, and sanitizers.
-- **Container builds**: Multi-platform Docker build system for Linux, macOS (arm64/x86_64 via osxcross), and Windows (LLVM-MinGW) cross-compilation.
-- **Release**: v1.8.9-preview — 530+ WoW API functions, 140+ events, 664 opcode handlers.
+- **CI**: GitHub Actions builds for Linux (x86-64, ARM64), Windows (MSYS2), and macOS (ARM64). Security scans via CodeQL, Semgrep, and sanitizers.
 
 ## Features
 
@@ -54,7 +52,7 @@ Protocol Compatible with **Vanilla (Classic) 1.12 + TBC 2.4.3 + WotLK 3.3.5a**.
 - **Movement** -- WASD movement, camera orbit, spline path following, transport riding (trams, ships, zeppelins), movement ACK responses
 - **Combat** -- Auto-attack, spell casting with cooldowns, damage calculation, death handling, spirit healer resurrection
 - **Targeting** -- Tab-cycling with hostility filtering, click-to-target, faction-based hostility (using Faction.dbc)
-- **Inventory** -- 23 equipment slots, 16 backpack slots, drag-drop, auto-equip, item tooltips with weapon damage/speed, server-synced bag sort (quality/type/stack), independent bag windows
+- **Inventory** -- 23 equipment slots, 16 backpack slots, drag-drop, auto-equip, item tooltips with weapon damage/speed
 - **Bank** -- Full bank support for all expansions, bag slots, drag-drop, right-click deposit (non-equippable items)
 - **Spells** -- Spellbook with specialty, general, profession, mount, and companion tabs; drag-drop to action bar; item use support
 - **Talents** -- Talent tree UI with proper visuals and functionality
@@ -68,34 +66,10 @@ Protocol Compatible with **Vanilla (Classic) 1.12 + TBC 2.4.3 + WotLK 3.3.5a**.
 - **Gossip** -- NPC interaction, dialogue options
 - **Chat** -- Tabs/channels, emotes, chat bubbles, clickable URLs, clickable item links with tooltips
 - **Party** -- Group invites, party list, out-of-range member health via SMSG_PARTY_MEMBER_STATS
-- **Pets** -- Pet tracking via SMSG_PET_SPELLS, action bar (10 slots with icon/autocast tinting/tooltips), dismiss button
-- **Map Exploration** -- Subzone-level fog-of-war reveal, world map with continent/zone views, quest POI markers, taxi node markers, party member dots
-- **NPC Voices** -- Race/gender-specific NPC greeting, farewell, vendor, pissed, aggro, and flee sounds for all playable races including Blood Elf and Draenei
+- **Pets** -- Pet tracking via SMSG_PET_SPELLS, dismiss pet button
+- **Map Exploration** -- Subzone-level fog-of-war reveal matching retail behavior
 - **Warden** -- Warden anti-cheat module execution via Unicorn Engine x86 emulation (cross-platform, no Wine)
-- **UI** -- Loading screens with progress bar, settings window with graphics quality presets (LOW/MEDIUM/HIGH/ULTRA), shadow distance slider, minimap with zoom/rotation/square mode, top-right minimap mute speaker, separate bag windows with compact-empty mode (aggregate view)
-
-## Graphics & Performance
-
-### Quality Presets
-
-WoWee includes four built-in graphics quality presets to help you quickly balance visual quality and performance:
-
-| Preset | Shadows | MSAA | Normal Mapping | Clutter Density |
-|--------|---------|------|----------------|-----------------|
-| **LOW** | Off | Off | Disabled | 25% |
-| **MEDIUM** | 200m distance | 2x | Basic | 60% |
-| **HIGH** | 350m distance | 4x | Full (0.8x) | 100% |
-| **ULTRA** | 500m distance | 8x | Enhanced (1.2x) | 150% |
-
-Press Escape to open **Video Settings** and select a preset, or adjust individual settings for a custom configuration.
-
-### Performance Tips
-
-- Start with **LOW** or **MEDIUM** if you experience frame drops
-- Shadows and MSAA have the largest impact on performance
-- Reduce **shadow distance** if shadows cause issues
-- Disable **water refraction** if you encounter GPU errors (requires FSR to be active)
-- Use **FSR2** (built-in upscaling) for better frame rates on modern GPUs
+- **UI** -- Loading screens with progress bar, settings window (shadow distance slider), minimap with zoom/rotation/square mode, top-right minimap mute speaker, separate bag windows with compact-empty mode (aggregate view)
 
 ## Building
 
@@ -347,13 +321,3 @@ This project does not include any Blizzard Entertainment proprietary data, asset
 ## Known Issues
 
 MANY issues this is actively under development
-
-## Star History
-
-<a href="https://www.star-history.com/?repos=Kelsidavis%2FWoWee&type=date&legend=top-left">
- <picture>
-   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/image?repos=Kelsidavis/WoWee&type=date&theme=dark&legend=top-left" />
-   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/image?repos=Kelsidavis/WoWee&type=date&legend=top-left" />
-   <img alt="Star History Chart" src="https://api.star-history.com/image?repos=Kelsidavis/WoWee&type=date&legend=top-left" />
- </picture>
-</a>
diff --git a/TESTING.md b/TESTING.md
deleted file mode 100644
index 3846b15d..00000000
--- a/TESTING.md
+++ /dev/null
@@ -1,390 +0,0 @@
-# WoWee Testing Guide
-
-This document covers everything needed to build, run, lint, and extend the WoWee test suite.
-
----
-
-## Table of Contents
-
-1. [Overview](#overview)
-2. [Prerequisites](#prerequisites)
-3. [Test Suite Layout](#test-suite-layout)
-4. [Building the Tests](#building-the-tests)
-   - [Release Build (normal)](#release-build-normal)
-   - [Debug + ASAN/UBSan Build](#debug--asanubsan-build)
-5. [Running Tests](#running-tests)
-   - [test.sh — the unified entry point](#testsh--the-unified-entry-point)
-   - [Running directly with ctest](#running-directly-with-ctest)
-6. [Lint (clang-tidy)](#lint-clang-tidy)
-   - [Running lint](#running-lint)
-   - [Applying auto-fixes](#applying-auto-fixes)
-   - [Configuration (.clang-tidy)](#configuration-clang-tidy)
-7. [ASAN / UBSan](#asan--ubsan)
-8. [Adding New Tests](#adding-new-tests)
-9. [CI Reference](#ci-reference)
-
----
-
-## Overview
-
-WoWee uses **Catch2 v3** (amalgamated) for unit testing and **clang-tidy** for static analysis. The `test.sh` script is the single entry point for both.
-
-| Command | What it does |
-|---|---|
-| `./test.sh` | Runs both unit tests (Release) and lint |
-| `./test.sh --test` | Runs unit tests only (Release build) |
-| `./test.sh --lint` | Runs clang-tidy only |
-| `./test.sh --asan` | Runs unit tests under ASAN + UBSan (Debug build) |
-| `FIX=1 ./test.sh --lint` | Applies clang-tidy auto-fixes in-place |
-
-All commands exit non-zero on any failure.
-
----
-
-## Prerequisites
-
-The test suite requires the same base toolchain used to build the project. See [BUILD_INSTRUCTIONS.md](BUILD_INSTRUCTIONS.md) for platform-specific dependency installation.
-
-### Linux (Ubuntu / Debian)
-
-```bash
-sudo apt update
-sudo apt install -y \
-  build-essential cmake pkg-config git \
-  libssl-dev \
-  clang-tidy
-```
-
-### Linux (Arch)
-
-```bash
-sudo pacman -S --needed base-devel cmake pkgconf git openssl clang
-```
-
-### macOS
-
-```bash
-brew install cmake openssl@3 llvm
-# Add LLVM tools to PATH so clang-tidy is found:
-export PATH="$(brew --prefix llvm)/bin:$PATH"
-```
-
-### Windows (MSYS2)
-
-Install the full toolchain as described in `BUILD_INSTRUCTIONS.md`, then add:
-
-```bash
-pacman -S --needed mingw-w64-x86_64-clang-tools-extra
-```
-
----
-
-## Test Suite Layout
-
-```
-tests/
-  CMakeLists.txt         — CMake test configuration
-  test_packet.cpp        — Network packet encode/decode
-  test_srp.cpp           — SRP-6a authentication math (requires OpenSSL)
-  test_opcode_table.cpp  — Opcode registry lookup
-  test_entity.cpp        — ECS entity basics
-  test_dbc_loader.cpp    — DBC binary file parsing
-  test_m2_structs.cpp    — M2 model struct layout / alignment
-  test_blp_loader.cpp    — BLP texture file parsing
-  test_frustum.cpp       — View-frustum culling math
-```
-
-The Catch2 v3 amalgamated source lives at:
-
-```
-extern/catch2/
-  catch_amalgamated.hpp
-  catch_amalgamated.cpp
-```
-
----
-
-## Building the Tests
-
-Tests are _not_ built by default. Enable them with `-DWOWEE_BUILD_TESTS=ON`.
-
-### Release Build (normal)
-
-> **Note:** Per project rules, always use `rebuild.sh` for a full clean build. Direct `cmake --build` is fine for test-only incremental builds.
-
-```bash
-# Configure (only needed once)
-cmake -B build -DCMAKE_BUILD_TYPE=Release -DWOWEE_BUILD_TESTS=ON
-
-# Build test targets (fast — only compiles tests and Catch2)
-cmake --build build --target \
-  test_packet test_srp test_opcode_table test_entity \
-  test_dbc_loader test_m2_structs test_blp_loader test_frustum
-```
-
-Or simply run a full rebuild (builds everything including the main binary):
-
-```bash
-./rebuild.sh      # ~10 minutes — see BUILD_INSTRUCTIONS.md
-```
-
-### Debug + ASAN/UBSan Build
-
-A separate CMake build directory is used so ASAN flags do not pollute the Release binary.
-
-```bash
-cmake -B build_asan \
-  -DCMAKE_BUILD_TYPE=Debug \
-  -DWOWEE_ENABLE_ASAN=ON \
-  -DWOWEE_BUILD_TESTS=ON
-
-cmake --build build_asan --target \
-  test_packet test_srp test_opcode_table test_entity \
-  test_dbc_loader test_m2_structs test_blp_loader test_frustum
-```
-
-CMake will print: `Test targets: ASAN + UBSan ENABLED` when configured correctly.
-
----
-
-## Running Tests
-
-### test.sh — the unified entry point
-
-`test.sh` is the recommended way to run tests and/or lint. It handles build-directory discovery, dependency checking, and exit-code aggregation across both steps.
-
-```bash
-# Run everything (tests + lint) — default when no flags are given
-./test.sh
-
-# Tests only (Release build)
-./test.sh --test
-
-# Tests only under ASAN+UBSan (Debug build — requires build_asan/)
-./test.sh --asan
-
-# Lint only
-./test.sh --lint
-
-# Both tests and lint explicitly
-./test.sh --test --lint
-
-# Usage summary
-./test.sh --help
-```
-
-**Exit codes:**
-
-| Outcome | Exit code |
-|---|---|
-| All tests passed, lint clean | `0` |
-| Any test failed | `1` |
-| Any lint diagnostic | `1` |
-| Both test failure and lint issues | `1` |
-
-### Running directly with ctest
-
-```bash
-# Release build
-cd build
-ctest --output-on-failure
-
-# ASAN build
-cd build_asan
-ctest --output-on-failure
-
-# Run one specific test suite by name
-ctest --output-on-failure -R srp
-
-# Verbose output (shows every SECTION and REQUIRE)
-ctest --output-on-failure -V
-```
-
-You can also run a test binary directly for detailed Catch2 output:
-
-```bash
-./build/bin/test_srp
-./build/bin/test_srp --reporter console
-./build/bin/test_srp "[authentication]"    # run only tests tagged [authentication]
-```
-
----
-
-## Lint (clang-tidy)
-
-The project uses clang-tidy to enforce C++20 best practices on all first-party sources under `src/`. Third-party code (anything in `extern/`) and generated files are excluded.
-
-### Running lint
-
-```bash
-./test.sh --lint
-```
-
-Under the hood the script:
-
-1. Locates `clang-tidy` (tries versions 14–18, then `clang-tidy`).
-2. Uses `run-clang-tidy` for parallel execution when available; falls back to sequential.
-3. Reads `build/compile_commands.json` (generated by CMake) for compiler flags.
-4. Feeds GCC stdlib include paths as `-isystem` extras so clang-tidy can resolve `<vector>`, `<string>`, etc. when the compile-commands were generated with GCC.
-
-`compile_commands.json` is regenerated automatically by any CMake configure step. If you only want to update it without rebuilding:
-
-```bash
-cmake -B build -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
-```
-
-### Applying auto-fixes
-
-Some clang-tidy checks can apply fixes automatically (e.g. `modernize-*`, `readability-*`):
-
-```bash
-FIX=1 ./test.sh --lint
-```
-
-> **Caution:** Review the diff before committing — automatic fixes occasionally produce non-idiomatic results in complex template code.
-
-### Configuration (.clang-tidy)
-
-The active check set is defined in [.clang-tidy](.clang-tidy) at the repository root.
-
-**Enabled check categories:**
-
-| Category | What it catches |
-|---|---|
-| `bugprone-*` | Common bug patterns (signed overflow, misplaced `=`, etc.) |
-| `clang-analyzer-*` | Deep flow-analysis: null dereferences, memory leaks, dead stores |
-| `performance-*` | Unnecessary copies, inefficient STL usage |
-| `modernize-*` (subset) | Pre-C++11 patterns that should use modern equivalents |
-| `readability-*` (subset) | Control-flow simplification, redundant code |
-
-**Notable suppressions** (see `.clang-tidy` for details):
-
-| Suppressed check | Reason |
-|---|---|
-| `bugprone-easily-swappable-parameters` | High false-positive rate in graphics/math APIs |
-| `clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling` | Intentional low-level buffer code in rendering |
-| `performance-avoid-endl` | `std::endl` is used intentionally for logger flushing |
-
-To suppress a specific warning inline, use:
-
-```cpp
-// NOLINT(bugprone-narrowing-conversions)
-uint8_t byte = static_cast<uint8_t>(value); // NOLINT
-```
-
----
-
-## ASAN / UBSan
-
-AddressSanitizer (ASAN) and Undefined Behaviour Sanitizer (UBSan) are applied to all test targets when `WOWEE_ENABLE_ASAN=ON`.
-
-Both the test executables **and** the `catch2_main` static library are recompiled with:
-
-```
--fsanitize=address,undefined -fno-omit-frame-pointer
-```
-
-This means any heap overflow, stack buffer overflow, use-after-free, null dereference, signed integer overflow, or misaligned access detected during a test will abort the process and print a human-readable report to stderr.
-
-### Workflow
-
-```bash
-# 1. Configure once (only needs to be re-run when CMakeLists.txt changes)
-cmake -B build_asan \
-  -DCMAKE_BUILD_TYPE=Debug \
-  -DWOWEE_ENABLE_ASAN=ON \
-  -DWOWEE_BUILD_TESTS=ON
-
-# 2. Build test binaries (fast incremental after the first build)
-cmake --build build_asan --target test_packet test_srp   # etc.
-
-# 3. Run
-./test.sh --asan
-```
-
-### Interpreting ASAN output
-
-A failing ASAN report looks like:
-
-```
-==12345==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x602000000010
-READ of size 4 at 0x602000000010 thread T0
-    #0 0x... in PacketBuffer::read_uint32 src/network/packet.cpp:42
-    #1 0x... in test_packet tests/test_packet.cpp:88
-```
-
-Address the issue in the source file and re-run. Do **not** suppress ASAN reports without a code fix.
-
----
-
-## Adding New Tests
-
-1. **Create** `tests/test_<name>.cpp` with a standard Catch2 v3 structure:
-
-```cpp
-#include "catch_amalgamated.hpp"
-
-TEST_CASE("SomeFeature does X", "[tag]") {
-    REQUIRE(1 + 1 == 2);
-}
-```
-
-2. **Register** the test in `tests/CMakeLists.txt` following the existing pattern:
-
-```cmake
-# ── test_<name> ──────────────────────────────────────────────
-add_executable(test_<name>
-    test_<name>.cpp
-    ${TEST_COMMON_SOURCES}
-    ${CMAKE_SOURCE_DIR}/src/<module>/<file>.cpp   # source under test
-)
-target_include_directories(test_<name> PRIVATE ${TEST_INCLUDE_DIRS})
-target_include_directories(test_<name> SYSTEM PRIVATE ${TEST_SYSTEM_INCLUDE_DIRS})
-target_link_libraries(test_<name> PRIVATE catch2_main)
-add_test(NAME <name> COMMAND test_<name>)
-register_test_target(test_<name>)   # required — enables ASAN propagation
-```
-
-3. **Build** and verify:
-
-```bash
-cmake --build build --target test_<name>
-./test.sh --test
-```
-
-The `register_test_target()` macro call is **mandatory** — without it the new test will not receive ASAN/UBSan flags when `WOWEE_ENABLE_ASAN=ON`.
-
----
-
-## CI Reference
-
-The following commands map to typical CI jobs:
-
-| Job | Command |
-|---|---|
-| Unit tests (Release) | `./test.sh --test` |
-| Unit tests (ASAN+UBSan) | `./test.sh --asan` |
-| Lint | `./test.sh --lint` |
-| Full check (tests + lint) | `./test.sh` |
-
-**Configuring the ASAN job in CI:**
-
-```yaml
-- name: Configure ASAN build
-  run: |
-    cmake -B build_asan \
-      -DCMAKE_BUILD_TYPE=Debug \
-      -DWOWEE_ENABLE_ASAN=ON \
-      -DWOWEE_BUILD_TESTS=ON
-
-- name: Build test targets
-  run: |
-    cmake --build build_asan --target \
-      test_packet test_srp test_opcode_table test_entity \
-      test_dbc_loader test_m2_structs test_blp_loader test_frustum
-
-- name: Run ASAN tests
-  run: ./test.sh --asan
-```
-
-> See [BUILD_INSTRUCTIONS.md](BUILD_INSTRUCTIONS.md) for full platform dependency installation steps required before any CI job.
diff --git a/TROUBLESHOOTING.md b/TROUBLESHOOTING.md
deleted file mode 100644
index 3673118d..00000000
--- a/TROUBLESHOOTING.md
+++ /dev/null
@@ -1,184 +0,0 @@
-# Troubleshooting Guide
-
-This guide covers common issues and solutions for WoWee.
-
-## Connection Issues
-
-### "Authentication Failed"
-- **Cause**: Incorrect server address, expired realm list, or version mismatch
-- **Solution**:
-  1. Verify server address in realm list is correct
-  2. Ensure your WoW data directory is for the correct expansion (Vanilla/TBC/WotLK)
-  3. Check that the emulator server is running and reachable
-
-### "Realm List Connection Failed"
-- **Cause**: Server is down, firewall blocking connection, or DNS issue
-- **Solution**:
-  1. Verify server IP/hostname is correct
-  2. Test connectivity: `ping realm-server-address`
-  3. Check firewall rules for port 3724 (auth) and 8085 (realm list)
-  4. Try using IP address instead of hostname (DNS issues)
-
-### "Connection Lost During Login"
-- **Cause**: Network timeout, server overload, or incompatible protocol version
-- **Solution**:
-  1. Check your network connection
-  2. Reduce number of assets loading (lower graphics preset)
-  3. Verify server supports this expansion version
-
-## Graphics Issues
-
-### "VK_ERROR_DEVICE_LOST" or Client Crashes
-- **Cause**: GPU driver issue, insufficient VRAM, or graphics feature incompatibility
-- **Solution**:
-  1. **Immediate**: Disable advanced graphics features:
-     - Press Escape → Video Settings
-     - Set graphics preset to **LOW**
-     - Disable Water Refraction (requires FSR)
-     - Disable MSAA (set to Off)
-  2. **Medium term**: Update GPU driver to latest version
-  3. **Verify**: Use a graphics test tool to ensure GPU stability
-  4. **If persists**: Try FSR2 disabled mode - check renderer logs
-
-### Black Screen or Rendering Issues
-- **Cause**: Missing shaders, GPU memory allocation failure, or incorrect graphics settings
-- **Solution**:
-  1. Check logs: Look in `~/.wowee/logs/` for error messages
-  2. Verify shaders compiled: Check for `.spv` files in `assets/shaders/compiled/`
-  3. Reduce shadow distance: Press Escape → Video Settings → Lower shadow distance from 300m to 100m
-  4. Disable shadows entirely if issues persist
-
-### Low FPS or Frame Stuttering
-- **Cause**: Too high graphics settings for your GPU, memory fragmentation, or asset loading
-- **Solution**:
-  1. Apply lower graphics preset: Escape → LOW or MEDIUM
-  2. Disable MSAA: Set to "Off"
-  3. Reduce draw distance: Move further away from complex areas
-  4. Close other applications consuming GPU memory
-  5. Check CPU usage - if high, reduce number of visible entities
-
-### Water/Terrain Flickering
-- **Cause**: Shadow mapping artifacts, terrain LOD issues, or GPU memory pressure
-- **Solution**:
-  1. Increase shadow distance slightly (150m to 200m)
-  2. Disable shadows entirely as last resort
-  3. Check GPU memory usage
-
-## Audio Issues
-
-### No Sound
-- **Cause**: Audio initialization failed, missing audio data, or incorrect mixer setup
-- **Solution**:
-  1. Check system audio is working: Test with another application
-  2. Verify audio files extracted: Check for `.wav` files in `Data/Audio/`
-  3. Unmute audio: Look for speaker icon in minimap (top-right) - click to unmute
-  4. Check settings: Escape → Audio Settings → Master Volume > 0
-
-### Sound Cutting Out
-- **Cause**: Audio buffer underrun, too many simultaneous sounds, or driver issue
-- **Solution**:
-  1. Lower audio volume: Escape → Audio Settings → Reduce Master Volume
-  2. Disable distant ambient sounds: Reduce Ambient Volume
-  3. Reduce number of particle effects
-  4. Update audio driver
-
-## Gameplay Issues
-
-### Character Stuck or Not Moving
-- **Cause**: Network synchronization issue, collision bug, or server desync
-- **Solution**:
-  1. Try pressing Escape to deselect any target, then move
-  2. Jump (Spacebar) to test physics
-  3. Reload the character: Press Escape → Disconnect → Reconnect
-  4. Check for transport/vehicle state: Press 'R' to dismount if applicable
-
-### Spells Not Casting or Showing "Error"
-- **Cause**: Cooldown, mana insufficient, target out of range, or server desync
-- **Solution**:
-  1. Verify spell is off cooldown (action bar shows availability)
-  2. Check mana/energy: Look at player frame (top-left)
-  3. Verify target range: Hover action bar button for range info
-  4. Check server logs for error messages (combat log will show reason)
-
-### Quests Not Updating
-- **Cause**: Objective already completed in different session, quest giver not found, or network desync
-- **Solution**:
-  1. Check quest objective: Open quest log (Q key) → Verify objective requirements
-  2. Re-interact with NPC to trigger update packet
-  3. Reload character if issue persists
-
-### Items Not Appearing in Inventory
-- **Cause**: Inventory full, item filter active, or network desync
-- **Solution**:
-  1. Check inventory space: Open inventory (B key) → Count free slots
-  2. Verify item isn't already there: Search inventory for item name
-  3. Check if bags are full: Open bag windows, consolidate items
-  4. Reload character if item is still missing
-
-## Performance Optimization
-
-### For Low-End GPUs
-```
-Graphics Preset: LOW
-- Shadows: OFF
-- MSAA: OFF
-- Normal Mapping: Disabled
-- Clutter Density: 25%
-- Draw Distance: Minimum
-- Particles: Reduced
-```
-
-### For Mid-Range GPUs
-```
-Graphics Preset: MEDIUM
-- Shadows: 200m
-- MSAA: 2x
-- Normal Mapping: Basic
-- Clutter Density: 60%
-- FSR2: Enabled (if desired)
-```
-
-### For High-End GPUs
-```
-Graphics Preset: HIGH or ULTRA
-- Shadows: 350-500m
-- MSAA: 4-8x
-- Normal Mapping: Full (1.2x strength)
-- Clutter Density: 100-150%
-- FSR2: Optional (for 4K smoothness)
-```
-
-## Getting Help
-
-### Check Logs
-Detailed logs are saved to `logs/wowee.log` in the working directory (typically `build/bin/`).
-
-Include relevant log entries when reporting issues.
-
-### Check Server Compatibility
-- **AzerothCore**: Full support
-- **TrinityCore**: Full support
-- **Mangos**: Full support
-- **Turtle WoW**: Full support (1.17)
-
-### Report Issues
-If you encounter a bug:
-1. Enable logging: Watch console for error messages
-2. Reproduce the issue consistently
-3. Gather system info: GPU, driver version, OS
-4. Check if issue is expansion-specific (Classic/TBC/WotLK)
-5. Report with detailed steps to reproduce
-
-### Clear Cache
-If experiencing persistent issues, clear WoWee's cache:
-```bash
-# Linux/macOS
-rm -rf ~/.wowee/warden_cache/
-rm -rf ~/.wowee/asset_cache/
-
-# Windows
-rmdir %APPDATA%\wowee\warden_cache\ /s
-rmdir %APPDATA%\wowee\asset_cache\ /s
-```
-
-Then restart WoWee to rebuild cache.
diff --git a/assets/shaders/basic.frag b/assets/shaders/basic.frag
new file mode 100644
index 00000000..158eb776
--- /dev/null
+++ b/assets/shaders/basic.frag
@@ -0,0 +1,38 @@
+#version 330 core
+
+in vec3 FragPos;
+in vec3 Normal;
+in vec2 TexCoord;
+
+out vec4 FragColor;
+
+uniform vec3 uLightPos;
+uniform vec3 uViewPos;
+uniform vec4 uColor;
+uniform sampler2D uTexture;
+uniform bool uUseTexture;
+
+void main() {
+    // Ambient
+    vec3 ambient = 0.3 * vec3(1.0);
+
+    // Diffuse
+    vec3 norm = normalize(Normal);
+    vec3 lightDir = normalize(uLightPos - FragPos);
+    float diff = max(dot(norm, lightDir), 0.0);
+    vec3 diffuse = diff * vec3(1.0);
+
+    // Specular
+    vec3 viewDir = normalize(uViewPos - FragPos);
+    vec3 reflectDir = reflect(-lightDir, norm);
+    float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32.0);
+    vec3 specular = 0.5 * spec * vec3(1.0);
+
+    vec3 result = (ambient + diffuse + specular);
+
+    if (uUseTexture) {
+        FragColor = texture(uTexture, TexCoord) * vec4(result, 1.0);
+    } else {
+        FragColor = uColor * vec4(result, 1.0);
+    }
+}
diff --git a/assets/shaders/basic.vert b/assets/shaders/basic.vert
new file mode 100644
index 00000000..141f2270
--- /dev/null
+++ b/assets/shaders/basic.vert
@@ -0,0 +1,22 @@
+#version 330 core
+
+layout (location = 0) in vec3 aPosition;
+layout (location = 1) in vec3 aNormal;
+layout (location = 2) in vec2 aTexCoord;
+
+out vec3 FragPos;
+out vec3 Normal;
+out vec2 TexCoord;
+
+uniform mat4 uModel;
+uniform mat4 uView;
+uniform mat4 uProjection;
+
+void main() {
+    FragPos = vec3(uModel * vec4(aPosition, 1.0));
+    // Use mat3(uModel) directly - avoids expensive inverse() per vertex
+    Normal = mat3(uModel) * aNormal;
+    TexCoord = aTexCoord;
+
+    gl_Position = uProjection * uView * vec4(FragPos, 1.0);
+}
diff --git a/assets/shaders/character.frag.glsl b/assets/shaders/character.frag.glsl
index a4bdada6..b28fa314 100644
--- a/assets/shaders/character.frag.glsl
+++ b/assets/shaders/character.frag.glsl
@@ -126,14 +126,7 @@ void main() {
 
     vec4 texColor = texture(uTexture, finalUV);
 
-    if (alphaTest != 0) {
-        // Screen-space sharpened alpha for alpha-to-coverage anti-aliasing.
-        // Rescales alpha so the 0.5 cutoff maps to exactly the texel boundary,
-        // giving smooth edges when MSAA + alpha-to-coverage is active.
-        float aGrad = fwidth(texColor.a);
-        texColor.a = clamp((texColor.a - 0.5) / max(aGrad, 0.001) * 0.5 + 0.5, 0.0, 1.0);
-        if (texColor.a < 1.0 / 255.0) discard;
-    }
+    if (alphaTest != 0 && texColor.a < 0.5) discard;
     if (colorKeyBlack != 0) {
         float lum = dot(texColor.rgb, vec3(0.299, 0.587, 0.114));
         float ck = smoothstep(0.12, 0.30, lum);
@@ -176,7 +169,7 @@ void main() {
             if (proj.x >= 0.0 && proj.x <= 1.0 &&
                 proj.y >= 0.0 && proj.y <= 1.0 &&
                 proj.z >= 0.0 && proj.z <= 1.0) {
-                float bias = max(0.0005 * (1.0 - abs(dot(norm, ldir))), 0.00005);
+                float bias = max(0.0005 * (1.0 - dot(norm, ldir)), 0.00005);
                 shadow = sampleShadowPCF(uShadowMap, vec3(proj.xy, proj.z - bias));
             }
             shadow = mix(1.0, shadow, shadowParams.y);
diff --git a/assets/shaders/character.frag.spv b/assets/shaders/character.frag.spv
index 7277d275..99c68edf 100644
Binary files a/assets/shaders/character.frag.spv and b/assets/shaders/character.frag.spv differ
diff --git a/assets/shaders/fsr2_sharpen.frag.glsl b/assets/shaders/fsr2_sharpen.frag.glsl
index 392a3a37..9cd1271c 100644
--- a/assets/shaders/fsr2_sharpen.frag.glsl
+++ b/assets/shaders/fsr2_sharpen.frag.glsl
@@ -10,7 +10,9 @@ layout(push_constant) uniform PushConstants {
 } pc;
 
 void main() {
-    vec2 tc = TexCoord;
+    // Undo the vertex shader Y flip (postprocess.vert flips for Vulkan overlay,
+    // but we need standard UV coords for texture sampling)
+    vec2 tc = vec2(TexCoord.x, 1.0 - TexCoord.y);
 
     vec2 texelSize = pc.params.xy;
     float sharpness = pc.params.z;
diff --git a/assets/shaders/fsr2_sharpen.frag.spv b/assets/shaders/fsr2_sharpen.frag.spv
index 24519b93..20672a9e 100644
Binary files a/assets/shaders/fsr2_sharpen.frag.spv and b/assets/shaders/fsr2_sharpen.frag.spv differ
diff --git a/assets/shaders/fsr_easu.frag.glsl b/assets/shaders/fsr_easu.frag.glsl
index 6a36be75..20e5ed32 100644
--- a/assets/shaders/fsr_easu.frag.glsl
+++ b/assets/shaders/fsr_easu.frag.glsl
@@ -21,7 +21,9 @@ vec3 fsrFetch(vec2 p, vec2 off) {
 }
 
 void main() {
-    vec2 tc = TexCoord;
+    // Undo the vertex shader Y flip (postprocess.vert flips for Vulkan overlay,
+    // but we need standard UV coords for texture sampling)
+    vec2 tc = vec2(TexCoord.x, 1.0 - TexCoord.y);
 
     // Map output pixel to input space
     vec2 pp = tc * fsr.con2.xy; // output pixel position
diff --git a/assets/shaders/fsr_easu.frag.spv b/assets/shaders/fsr_easu.frag.spv
index 12780757..5ddc2ea8 100644
Binary files a/assets/shaders/fsr_easu.frag.spv and b/assets/shaders/fsr_easu.frag.spv differ
diff --git a/assets/shaders/fxaa.frag.glsl b/assets/shaders/fxaa.frag.glsl
deleted file mode 100644
index 3da10854..00000000
--- a/assets/shaders/fxaa.frag.glsl
+++ /dev/null
@@ -1,155 +0,0 @@
-#version 450
-
-// FXAA 3.11 — Fast Approximate Anti-Aliasing post-process pass.
-// Reads the resolved scene color and outputs a smoothed result.
-// Push constant: rcpFrame = vec2(1/width, 1/height), sharpness (0=off, 2=max), desaturate (1=ghost grayscale).
-
-layout(set = 0, binding = 0) uniform sampler2D uScene;
-
-layout(location = 0) in vec2 TexCoord;
-layout(location = 0) out vec4 outColor;
-
-layout(push_constant) uniform PC {
-    vec2  rcpFrame;
-    float sharpness;    // 0 = no sharpen, 2 = max (matches FSR2 RCAS range)
-    float desaturate;   // 1 = full grayscale (ghost mode), 0 = normal color
-} pc;
-
-// Quality tuning
-#define FXAA_EDGE_THRESHOLD      (1.0/8.0)   // minimum edge contrast to process
-#define FXAA_EDGE_THRESHOLD_MIN  (1.0/24.0)  // ignore very dark regions
-#define FXAA_SEARCH_STEPS        12
-#define FXAA_SEARCH_THRESHOLD    (1.0/4.0)
-#define FXAA_SUBPIX              0.75
-#define FXAA_SUBPIX_TRIM         (1.0/4.0)
-#define FXAA_SUBPIX_TRIM_SCALE   (1.0/(1.0 - FXAA_SUBPIX_TRIM))
-#define FXAA_SUBPIX_CAP          (3.0/4.0)
-
-float luma(vec3 c) {
-    return dot(c, vec3(0.299, 0.587, 0.114));
-}
-
-void main() {
-    vec2 uv      = TexCoord;
-    vec2 rcp     = pc.rcpFrame;
-
-    // --- Centre and cardinal neighbours ---
-    vec3 rgbM  = texture(uScene, uv).rgb;
-    vec3 rgbN  = texture(uScene, uv + vec2( 0.0, -1.0) * rcp).rgb;
-    vec3 rgbS  = texture(uScene, uv + vec2( 0.0,  1.0) * rcp).rgb;
-    vec3 rgbE  = texture(uScene, uv + vec2( 1.0,  0.0) * rcp).rgb;
-    vec3 rgbW  = texture(uScene, uv + vec2(-1.0,  0.0) * rcp).rgb;
-
-    float lumaN = luma(rgbN);
-    float lumaS = luma(rgbS);
-    float lumaE = luma(rgbE);
-    float lumaW = luma(rgbW);
-    float lumaM = luma(rgbM);
-
-    float lumaMin = min(lumaM, min(min(lumaN, lumaS), min(lumaE, lumaW)));
-    float lumaMax = max(lumaM, max(max(lumaN, lumaS), max(lumaE, lumaW)));
-    float range   = lumaMax - lumaMin;
-
-    // Early exit on smooth regions
-    if (range < max(FXAA_EDGE_THRESHOLD_MIN, lumaMax * FXAA_EDGE_THRESHOLD)) {
-        outColor = vec4(rgbM, 1.0);
-        return;
-    }
-
-    // --- Diagonal neighbours ---
-    vec3 rgbNW = texture(uScene, uv + vec2(-1.0, -1.0) * rcp).rgb;
-    vec3 rgbNE = texture(uScene, uv + vec2( 1.0, -1.0) * rcp).rgb;
-    vec3 rgbSW = texture(uScene, uv + vec2(-1.0,  1.0) * rcp).rgb;
-    vec3 rgbSE = texture(uScene, uv + vec2( 1.0,  1.0) * rcp).rgb;
-
-    float lumaNW = luma(rgbNW);
-    float lumaNE = luma(rgbNE);
-    float lumaSW = luma(rgbSW);
-    float lumaSE = luma(rgbSE);
-
-    // --- Sub-pixel blend factor ---
-    float lumaL  = (lumaN + lumaS + lumaE + lumaW) * 0.25;
-    float rangeL = abs(lumaL - lumaM);
-    float blendL = max(0.0, (rangeL / range) - FXAA_SUBPIX_TRIM) * FXAA_SUBPIX_TRIM_SCALE;
-    blendL = min(FXAA_SUBPIX_CAP, blendL) * FXAA_SUBPIX;
-
-    // --- Edge orientation (horizontal vs. vertical) ---
-    float edgeHorz =
-          abs(-2.0*lumaW + lumaNW + lumaSW)
-        + 2.0*abs(-2.0*lumaM + lumaN + lumaS)
-        + abs(-2.0*lumaE + lumaNE + lumaSE);
-    float edgeVert =
-          abs(-2.0*lumaS + lumaSW + lumaSE)
-        + 2.0*abs(-2.0*lumaM + lumaW + lumaE)
-        + abs(-2.0*lumaN + lumaNW + lumaNE);
-
-    bool  horzSpan  = (edgeHorz >= edgeVert);
-    float lengthSign = horzSpan ? rcp.y : rcp.x;
-
-    float luma1 = horzSpan ? lumaN : lumaW;
-    float luma2 = horzSpan ? lumaS : lumaE;
-    float grad1 = abs(luma1 - lumaM);
-    float grad2 = abs(luma2 - lumaM);
-    lengthSign = (grad1 >= grad2) ? -lengthSign : lengthSign;
-
-    // --- Edge search ---
-    vec2 posB  = uv;
-    vec2 offNP = horzSpan ? vec2(rcp.x, 0.0) : vec2(0.0, rcp.y);
-    if (!horzSpan) posB.x += lengthSign * 0.5;
-    if ( horzSpan) posB.y += lengthSign * 0.5;
-
-    float lumaMLSS       = lumaM - (luma1 + luma2) * 0.5;
-    float gradientScaled = max(grad1, grad2) * 0.25;
-
-    vec2  posN = posB - offNP;
-    vec2  posP = posB + offNP;
-    bool  done1 = false, done2 = false;
-    float lumaEnd1 = 0.0, lumaEnd2 = 0.0;
-
-    for (int i = 0; i < FXAA_SEARCH_STEPS; ++i) {
-        if (!done1) lumaEnd1 = luma(texture(uScene, posN).rgb) - lumaMLSS;
-        if (!done2) lumaEnd2 = luma(texture(uScene, posP).rgb) - lumaMLSS;
-        done1 = done1 || (abs(lumaEnd1) >= gradientScaled * FXAA_SEARCH_THRESHOLD);
-        done2 = done2 || (abs(lumaEnd2) >= gradientScaled * FXAA_SEARCH_THRESHOLD);
-        if (done1 && done2) break;
-        if (!done1) posN -= offNP;
-        if (!done2) posP += offNP;
-    }
-
-    float dstN = horzSpan ? (uv.x - posN.x) : (uv.y - posN.y);
-    float dstP = horzSpan ? (posP.x - uv.x) : (posP.y - uv.y);
-    bool  dirN = (dstN < dstP);
-    float lumaEndFinal = dirN ? lumaEnd1 : lumaEnd2;
-
-    float spanLength      = dstN + dstP;
-    float pixelOffset     = (dirN ? dstN : dstP) / spanLength;
-    bool  goodSpan        = ((lumaEndFinal < 0.0) != (lumaMLSS < 0.0));
-    float pixelOffsetFinal = max(goodSpan ? pixelOffset : 0.0, blendL);
-
-    vec2 finalUV = uv;
-    if ( horzSpan) finalUV.y += pixelOffsetFinal * lengthSign;
-    if (!horzSpan) finalUV.x += pixelOffsetFinal * lengthSign;
-
-    vec3 fxaaResult = texture(uScene, finalUV).rgb;
-
-    // Post-FXAA contrast-adaptive sharpening (unsharp mask).
-    // Counteracts FXAA's sub-pixel blur when sharpness > 0.
-    if (pc.sharpness > 0.0) {
-        vec2 r = pc.rcpFrame;
-        vec3 blur = (texture(uScene, uv + vec2(-r.x, 0)).rgb
-                   + texture(uScene, uv + vec2( r.x, 0)).rgb
-                   + texture(uScene, uv + vec2(0, -r.y)).rgb
-                   + texture(uScene, uv + vec2(0,  r.y)).rgb) * 0.25;
-        // scale sharpness from [0,2] to a modest [0, 0.3] boost factor
-        float s = pc.sharpness * 0.15;
-        fxaaResult = clamp(fxaaResult + s * (fxaaResult - blur), 0.0, 1.0);
-    }
-
-    // Ghost mode: desaturate to grayscale (with a slight cool blue tint).
-    if (pc.desaturate > 0.5) {
-        float gray = dot(fxaaResult, vec3(0.299, 0.587, 0.114));
-        fxaaResult = mix(fxaaResult, vec3(gray, gray, gray * 1.05), pc.desaturate);
-    }
-
-    outColor = vec4(fxaaResult, 1.0);
-}
diff --git a/assets/shaders/fxaa.frag.spv b/assets/shaders/fxaa.frag.spv
deleted file mode 100644
index b87b3dee..00000000
Binary files a/assets/shaders/fxaa.frag.spv and /dev/null differ
diff --git a/assets/shaders/m2.vert.glsl b/assets/shaders/m2.vert.glsl
index 3b8c113e..6f4545c8 100644
--- a/assets/shaders/m2.vert.glsl
+++ b/assets/shaders/m2.vert.glsl
@@ -13,29 +13,19 @@ layout(set = 0, binding = 0) uniform PerFrame {
     vec4 shadowParams;
 };
 
-// Per-draw push constants (batch-level data only)
 layout(push_constant) uniform Push {
-    int texCoordSet;         // UV set index (0 or 1)
-    int isFoliage;           // Foliage wind animation flag
-    int instanceDataOffset;  // Base index into InstanceSSBO for this draw group
+    mat4 model;
+    vec2 uvOffset;
+    int texCoordSet;
+    int useBones;
+    int isFoliage;
+    float fadeAlpha;
 } push;
 
 layout(set = 2, binding = 0) readonly buffer BoneSSBO {
     mat4 bones[];
 };
 
-// Per-instance data read via gl_InstanceIndex (GPU instancing)
-struct InstanceData {
-    mat4 model;
-    vec2 uvOffset;
-    float fadeAlpha;
-    int useBones;
-    int boneBase;
-};
-layout(set = 3, binding = 0) readonly buffer InstanceSSBO {
-    InstanceData instanceData[];
-};
-
 layout(location = 0) in vec3 aPos;
 layout(location = 1) in vec3 aNormal;
 layout(location = 2) in vec2 aTexCoord;
@@ -51,23 +41,15 @@ layout(location = 4) out float ModelHeight;
 layout(location = 5) out float vFadeAlpha;
 
 void main() {
-    // Fetch per-instance data from SSBO
-    int instIdx = push.instanceDataOffset + gl_InstanceIndex;
-    mat4 model = instanceData[instIdx].model;
-    vec2 uvOff = instanceData[instIdx].uvOffset;
-    float fade = instanceData[instIdx].fadeAlpha;
-    int uBones = instanceData[instIdx].useBones;
-    int bBase  = instanceData[instIdx].boneBase;
-
     vec4 pos = vec4(aPos, 1.0);
     vec4 norm = vec4(aNormal, 0.0);
 
-    if (uBones != 0) {
+    if (push.useBones != 0) {
         ivec4 bi = ivec4(aBoneIndicesF);
-        mat4 skinMat = bones[bBase + bi.x] * aBoneWeights.x
-                     + bones[bBase + bi.y] * aBoneWeights.y
-                     + bones[bBase + bi.z] * aBoneWeights.z
-                     + bones[bBase + bi.w] * aBoneWeights.w;
+        mat4 skinMat = bones[bi.x] * aBoneWeights.x
+                     + bones[bi.y] * aBoneWeights.y
+                     + bones[bi.z] * aBoneWeights.z
+                     + bones[bi.w] * aBoneWeights.w;
         pos = skinMat * pos;
         norm = skinMat * norm;
     }
@@ -75,7 +57,7 @@ void main() {
     // Wind animation for foliage
     if (push.isFoliage != 0) {
         float windTime = fogParams.z;
-        vec3 worldRef = model[3].xyz;
+        vec3 worldRef = push.model[3].xyz;
         float heightFactor = clamp(pos.z / 20.0, 0.0, 1.0);
         heightFactor *= heightFactor; // quadratic — base stays grounded
 
@@ -98,15 +80,15 @@ void main() {
         pos.y += trunkSwayY + branchSwayY + leafFlutterY;
     }
 
-    vec4 worldPos = model * pos;
+    vec4 worldPos = push.model * pos;
     FragPos = worldPos.xyz;
-    Normal = mat3(model) * norm.xyz;
+    Normal = mat3(push.model) * norm.xyz;
 
-    TexCoord = (push.texCoordSet == 1 ? aTexCoord2 : aTexCoord) + uvOff;
+    TexCoord = (push.texCoordSet == 1 ? aTexCoord2 : aTexCoord) + push.uvOffset;
 
-    InstanceOrigin = model[3].xyz;
+    InstanceOrigin = push.model[3].xyz;
     ModelHeight = pos.z;
-    vFadeAlpha = fade;
+    vFadeAlpha = push.fadeAlpha;
 
     gl_Position = projection * view * worldPos;
 }
diff --git a/assets/shaders/m2.vert.spv b/assets/shaders/m2.vert.spv
index 11364e67..8397440f 100644
Binary files a/assets/shaders/m2.vert.spv and b/assets/shaders/m2.vert.spv differ
diff --git a/assets/shaders/m2_cull.comp.glsl b/assets/shaders/m2_cull.comp.glsl
deleted file mode 100644
index fd87ff93..00000000
--- a/assets/shaders/m2_cull.comp.glsl
+++ /dev/null
@@ -1,76 +0,0 @@
-#version 450
-
-// GPU Frustum Culling for M2 doodads
-// Each compute thread tests one M2 instance against 6 frustum planes.
-// Input:  per-instance bounding sphere + flags.
-// Output: uint visibility array (1 = visible, 0 = culled).
-
-layout(local_size_x = 64) in;
-
-// Per-instance cull data (uploaded from CPU each frame)
-struct CullInstance {
-    vec4  sphere;              // xyz = world position, w = padded radius
-    float effectiveMaxDistSq;  // adaptive distance cull threshold
-    uint  flags;               // bit 0 = valid, bit 1 = smoke, bit 2 = invisibleTrap
-    float _pad0;
-    float _pad1;
-};
-
-layout(std140, set = 0, binding = 0) uniform CullUniforms {
-    vec4  frustumPlanes[6]; // xyz = normal, w = distance
-    vec4  cameraPos;        // xyz = camera position, w = maxPossibleDistSq
-    uint  instanceCount;
-    uint  _pad0;
-    uint  _pad1;
-    uint  _pad2;
-};
-
-layout(std430, set = 0, binding = 1) readonly buffer CullInput {
-    CullInstance cullInstances[];
-};
-
-layout(std430, set = 0, binding = 2) writeonly buffer CullOutput {
-    uint visibility[];
-};
-
-void main() {
-    uint id = gl_GlobalInvocationID.x;
-    if (id >= instanceCount) return;
-
-    CullInstance inst = cullInstances[id];
-
-    // Flag check: must be valid, not smoke, not invisible trap
-    uint f = inst.flags;
-    if ((f & 1u) == 0u || (f & 6u) != 0u) {
-        visibility[id] = 0u;
-        return;
-    }
-
-    // Early distance rejection (loose upper bound)
-    vec3 toCam = inst.sphere.xyz - cameraPos.xyz;
-    float distSq = dot(toCam, toCam);
-    if (distSq > cameraPos.w) {
-        visibility[id] = 0u;
-        return;
-    }
-
-    // Accurate per-instance distance cull
-    if (distSq > inst.effectiveMaxDistSq) {
-        visibility[id] = 0u;
-        return;
-    }
-
-    // Frustum cull: sphere vs 6 planes
-    float radius = inst.sphere.w;
-    if (radius > 0.0) {
-        for (int i = 0; i < 6; i++) {
-            float d = dot(frustumPlanes[i].xyz, inst.sphere.xyz) + frustumPlanes[i].w;
-            if (d < -radius) {
-                visibility[id] = 0u;
-                return;
-            }
-        }
-    }
-
-    visibility[id] = 1u;
-}
diff --git a/assets/shaders/m2_cull.comp.spv b/assets/shaders/m2_cull.comp.spv
deleted file mode 100644
index ef1a08fd..00000000
Binary files a/assets/shaders/m2_cull.comp.spv and /dev/null differ
diff --git a/assets/shaders/m2_particle.frag.glsl b/assets/shaders/m2_particle.frag.glsl
index 49fac7e1..f91a3fb7 100644
--- a/assets/shaders/m2_particle.frag.glsl
+++ b/assets/shaders/m2_particle.frag.glsl
@@ -25,9 +25,6 @@ void main() {
         if (lum < 0.05) discard;
     }
 
-    // Soft circular falloff for point-sprite edges.
-    float edge = 1.0 - smoothstep(0.4, 0.5, length(p - 0.5));
-    float alpha = texColor.a * vColor.a * edge;
-    vec3 rgb = texColor.rgb * vColor.rgb * alpha;
-    outColor = vec4(rgb, alpha);
+    float edge = smoothstep(0.5, 0.4, length(p - 0.5));
+    outColor = texColor * vColor * vec4(vec3(1.0), edge);
 }
diff --git a/assets/shaders/m2_ribbon.frag.glsl b/assets/shaders/m2_ribbon.frag.glsl
deleted file mode 100644
index 4e0e483e..00000000
--- a/assets/shaders/m2_ribbon.frag.glsl
+++ /dev/null
@@ -1,25 +0,0 @@
-#version 450
-
-// M2 ribbon emitter fragment shader.
-// Samples the ribbon texture, multiplied by vertex color and alpha.
-// Uses additive blending (pipeline-level) for magic/spell trails.
-
-layout(set = 1, binding = 0) uniform sampler2D uTexture;
-
-layout(location = 0) in vec3 vColor;
-layout(location = 1) in float vAlpha;
-layout(location = 2) in vec2 vUV;
-layout(location = 3) in float vFogFactor;
-
-layout(location = 0) out vec4 outColor;
-
-void main() {
-    vec4 tex = texture(uTexture, vUV);
-    // For additive ribbons alpha comes from texture luminance; multiply by vertex alpha.
-    float a = tex.a * vAlpha;
-    if (a < 0.01) discard;
-    vec3 rgb = tex.rgb * vColor;
-    // Ribbons fade slightly with fog (additive blend attenuated toward black = invisible in fog).
-    rgb *= vFogFactor;
-    outColor = vec4(rgb, a);
-}
diff --git a/assets/shaders/m2_ribbon.frag.spv b/assets/shaders/m2_ribbon.frag.spv
deleted file mode 100644
index 9b0a3fe9..00000000
Binary files a/assets/shaders/m2_ribbon.frag.spv and /dev/null differ
diff --git a/assets/shaders/m2_ribbon.vert.glsl b/assets/shaders/m2_ribbon.vert.glsl
deleted file mode 100644
index 492a295e..00000000
--- a/assets/shaders/m2_ribbon.vert.glsl
+++ /dev/null
@@ -1,43 +0,0 @@
-#version 450
-
-// M2 ribbon emitter vertex shader.
-// Ribbon geometry is generated CPU-side as a triangle strip.
-// Vertex format: pos(3) + color(3) + alpha(1) + uv(2) = 9 floats.
-
-layout(set = 0, binding = 0) uniform PerFrame {
-    mat4 view;
-    mat4 projection;
-    mat4 lightSpaceMatrix;
-    vec4 lightDir;
-    vec4 lightColor;
-    vec4 ambientColor;
-    vec4 viewPos;
-    vec4 fogColor;
-    vec4 fogParams;
-    vec4 shadowParams;
-};
-
-layout(location = 0) in vec3 aPos;
-layout(location = 1) in vec3 aColor;
-layout(location = 2) in float aAlpha;
-layout(location = 3) in vec2 aUV;
-
-layout(location = 0) out vec3 vColor;
-layout(location = 1) out float vAlpha;
-layout(location = 2) out vec2 vUV;
-layout(location = 3) out float vFogFactor;
-
-void main() {
-    vec4 worldPos = vec4(aPos, 1.0);
-    vec4 viewPos4  = view * worldPos;
-    gl_Position    = projection * viewPos4;
-
-    float dist      = length(viewPos4.xyz);
-    float fogStart  = fogParams.x;
-    float fogEnd    = fogParams.y;
-    vFogFactor      = clamp((fogEnd - dist) / max(fogEnd - fogStart, 0.001), 0.0, 1.0);
-
-    vColor = aColor;
-    vAlpha = aAlpha;
-    vUV    = aUV;
-}
diff --git a/assets/shaders/m2_ribbon.vert.spv b/assets/shaders/m2_ribbon.vert.spv
deleted file mode 100644
index d74ba750..00000000
Binary files a/assets/shaders/m2_ribbon.vert.spv and /dev/null differ
diff --git a/assets/shaders/minimap_display.frag.glsl b/assets/shaders/minimap_display.frag.glsl
index 476017b9..dacaaed1 100644
--- a/assets/shaders/minimap_display.frag.glsl
+++ b/assets/shaders/minimap_display.frag.glsl
@@ -40,27 +40,23 @@ void main() {
     float cs = cos(push.rotation);
     float sn = sin(push.rotation);
     vec2 rotated = vec2(center.x * cs - center.y * sn, center.x * sn + center.y * cs);
-    vec2 mapUV = push.playerUV + vec2(rotated.x, rotated.y) * push.zoomRadius * 2.0;
+    vec2 mapUV = push.playerUV + vec2(-rotated.x, rotated.y) * push.zoomRadius * 2.0;
 
     vec4 mapColor = texture(uComposite, mapUV);
 
-    // Single player direction indicator (center arrow) rendered in-shader.
-    vec2 local = center; // [-0.5, 0.5] around minimap center
-    float ac = cos(push.arrowRotation);
-    float as = sin(push.arrowRotation);
-    // TexCoord Y grows downward on screen; use negative Y so 0-angle points North (up).
-    vec2 tip   = vec2(0.0, -0.09);
-    vec2 left  = vec2(-0.045, 0.02);
-    vec2 right = vec2( 0.045, 0.02);
-    mat2 rot = mat2(ac, -as, as, ac);
-    tip = rot * tip;
-    left = rot * left;
-    right = rot * right;
-    if (pointInTriangle(local, tip, left, right)) {
-        mapColor.rgb = vec3(1.0, 0.86, 0.05);
+    // Player arrow
+    float acs = cos(push.arrowRotation);
+    float asn = sin(push.arrowRotation);
+    vec2 ac = center;
+    vec2 arrowPos = vec2(-(ac.x * acs - ac.y * asn), ac.x * asn + ac.y * acs);
+
+    vec2 tip = vec2(0.0, -0.04);
+    vec2 left = vec2(-0.02, 0.02);
+    vec2 right = vec2(0.02, 0.02);
+
+    if (pointInTriangle(arrowPos, tip, left, right)) {
+        mapColor = vec4(1.0, 0.8, 0.0, 1.0);
     }
-    float centerDot = smoothstep(0.016, 0.0, length(local));
-    mapColor.rgb = mix(mapColor.rgb, vec3(1.0), centerDot * 0.95);
 
     // Dark border ring
     float border = smoothstep(0.48, 0.5, dist);
diff --git a/assets/shaders/minimap_display.frag.spv b/assets/shaders/minimap_display.frag.spv
index f33deef2..5c0ac7b0 100644
Binary files a/assets/shaders/minimap_display.frag.spv and b/assets/shaders/minimap_display.frag.spv differ
diff --git a/assets/shaders/postprocess.vert.glsl b/assets/shaders/postprocess.vert.glsl
index 2ed8f784..aa78b1b5 100644
--- a/assets/shaders/postprocess.vert.glsl
+++ b/assets/shaders/postprocess.vert.glsl
@@ -6,7 +6,5 @@ void main() {
     // Fullscreen triangle trick: 3 vertices, no vertex buffer
     TexCoord = vec2((gl_VertexIndex << 1) & 2, gl_VertexIndex & 2);
     gl_Position = vec4(TexCoord * 2.0 - 1.0, 0.0, 1.0);
-    // No Y-flip: scene textures use Vulkan convention (v=0 at top),
-    // and NDC y=-1 already maps to framebuffer top, so the triangle
-    // naturally samples the correct row without any inversion.
+    TexCoord.y = 1.0 - TexCoord.y; // flip Y for Vulkan
 }
diff --git a/assets/shaders/postprocess.vert.spv b/assets/shaders/postprocess.vert.spv
index 89065a80..afc10472 100644
Binary files a/assets/shaders/postprocess.vert.spv and b/assets/shaders/postprocess.vert.spv differ
diff --git a/assets/shaders/quest_marker.frag.glsl b/assets/shaders/quest_marker.frag.glsl
index 0e209d8f..020b625d 100644
--- a/assets/shaders/quest_marker.frag.glsl
+++ b/assets/shaders/quest_marker.frag.glsl
@@ -5,7 +5,6 @@ layout(set = 1, binding = 0) uniform sampler2D markerTexture;
 layout(push_constant) uniform Push {
     mat4 model;
     float alpha;
-    float grayscale;  // 0 = full colour, 1 = fully desaturated (trivial quests)
 } push;
 
 layout(location = 0) in vec2 TexCoord;
@@ -15,7 +14,5 @@ layout(location = 0) out vec4 outColor;
 void main() {
     vec4 texColor = texture(markerTexture, TexCoord);
     if (texColor.a < 0.1) discard;
-    float lum = dot(texColor.rgb, vec3(0.299, 0.587, 0.114));
-    vec3 rgb = mix(texColor.rgb, vec3(lum), push.grayscale);
-    outColor = vec4(rgb, texColor.a * push.alpha);
+    outColor = vec4(texColor.rgb, texColor.a * push.alpha);
 }
diff --git a/assets/shaders/quest_marker.frag.spv b/assets/shaders/quest_marker.frag.spv
index 90814c30..e947d04c 100644
Binary files a/assets/shaders/quest_marker.frag.spv and b/assets/shaders/quest_marker.frag.spv differ
diff --git a/assets/shaders/terrain.frag b/assets/shaders/terrain.frag
new file mode 100644
index 00000000..c7677725
--- /dev/null
+++ b/assets/shaders/terrain.frag
@@ -0,0 +1,146 @@
+#version 330 core
+
+in vec3 FragPos;
+in vec3 Normal;
+in vec2 TexCoord;
+in vec2 LayerUV;
+
+out vec4 FragColor;
+
+// Texture layers (up to 4)
+uniform sampler2D uBaseTexture;
+uniform sampler2D uLayer1Texture;
+uniform sampler2D uLayer2Texture;
+uniform sampler2D uLayer3Texture;
+
+// Alpha maps for blending
+uniform sampler2D uLayer1Alpha;
+uniform sampler2D uLayer2Alpha;
+uniform sampler2D uLayer3Alpha;
+
+// Layer control
+uniform int uLayerCount;
+uniform bool uHasLayer1;
+uniform bool uHasLayer2;
+uniform bool uHasLayer3;
+
+// Lighting
+uniform vec3 uLightDir;
+uniform vec3 uLightColor;
+uniform vec3 uAmbientColor;
+
+// Camera
+uniform vec3 uViewPos;
+
+// Fog
+uniform vec3 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+
+// Shadow mapping
+uniform sampler2DShadow uShadowMap;
+uniform mat4 uLightSpaceMatrix;
+uniform bool uShadowEnabled;
+uniform float uShadowStrength;
+
+float calcShadow() {
+    vec4 lsPos = uLightSpaceMatrix * vec4(FragPos, 1.0);
+    vec3 proj = lsPos.xyz / lsPos.w * 0.5 + 0.5;
+    if (proj.z > 1.0) return 1.0;
+    float edgeDist = max(abs(proj.x - 0.5), abs(proj.y - 0.5));
+    float coverageFade = 1.0 - smoothstep(0.40, 0.49, edgeDist);
+    vec3 norm = normalize(Normal);
+    vec3 lightDir = normalize(-uLightDir);
+    float bias = max(0.005 * (1.0 - dot(norm, lightDir)), 0.001);
+    // 5-tap PCF tuned for slightly sharper detail while keeping stability.
+    vec2 texel = vec2(1.0 / 2048.0);
+    float ref = proj.z - bias;
+    vec2 off = texel * 0.7;
+    float shadow = 0.0;
+    shadow += texture(uShadowMap, vec3(proj.xy, ref)) * 0.55;
+    shadow += texture(uShadowMap, vec3(proj.xy + vec2(off.x, 0.0), ref)) * 0.1125;
+    shadow += texture(uShadowMap, vec3(proj.xy - vec2(off.x, 0.0), ref)) * 0.1125;
+    shadow += texture(uShadowMap, vec3(proj.xy + vec2(0.0, off.y), ref)) * 0.1125;
+    shadow += texture(uShadowMap, vec3(proj.xy - vec2(0.0, off.y), ref)) * 0.1125;
+    return mix(1.0, shadow, coverageFade);
+}
+
+float sampleAlpha(sampler2D tex, vec2 uv) {
+    // Slight blur near alpha-map borders to hide seams between chunks.
+    vec2 edge = min(uv, 1.0 - uv);
+    float border = min(edge.x, edge.y);
+    float doBlur = step(border, 2.0 / 64.0); // within ~2 texels of edge
+    if (doBlur < 0.5) {
+        return texture(tex, uv).r;
+    }
+    vec2 texel = vec2(1.0 / 64.0);
+    float a = 0.0;
+    a += texture(tex, uv + vec2(-texel.x, 0.0)).r;
+    a += texture(tex, uv + vec2(texel.x, 0.0)).r;
+    a += texture(tex, uv + vec2(0.0, -texel.y)).r;
+    a += texture(tex, uv + vec2(0.0, texel.y)).r;
+    return a * 0.25;
+}
+
+void main() {
+    // Sample base texture
+    vec4 baseColor = texture(uBaseTexture, TexCoord);
+    vec4 finalColor = baseColor;
+
+    // Apply texture layers with alpha blending
+    // TexCoord = tiling UVs for texture sampling (repeats across chunk)
+    // LayerUV = 0-1 per-chunk UVs for alpha map sampling
+    float a1 = uHasLayer1 ? sampleAlpha(uLayer1Alpha, LayerUV) : 0.0;
+    float a2 = uHasLayer2 ? sampleAlpha(uLayer2Alpha, LayerUV) : 0.0;
+    float a3 = uHasLayer3 ? sampleAlpha(uLayer3Alpha, LayerUV) : 0.0;
+
+    // Normalize weights to reduce quilting seams at chunk borders.
+    float w0 = 1.0;
+    float w1 = a1;
+    float w2 = a2;
+    float w3 = a3;
+    float sum = w0 + w1 + w2 + w3;
+    if (sum > 0.0) {
+        w0 /= sum; w1 /= sum; w2 /= sum; w3 /= sum;
+    }
+
+    finalColor = baseColor * w0;
+    if (uHasLayer1) {
+        vec4 layer1Color = texture(uLayer1Texture, TexCoord);
+        finalColor += layer1Color * w1;
+    }
+    if (uHasLayer2) {
+        vec4 layer2Color = texture(uLayer2Texture, TexCoord);
+        finalColor += layer2Color * w2;
+    }
+    if (uHasLayer3) {
+        vec4 layer3Color = texture(uLayer3Texture, TexCoord);
+        finalColor += layer3Color * w3;
+    }
+
+    // Normalize normal
+    vec3 norm = normalize(Normal);
+    vec3 lightDir = normalize(-uLightDir);
+
+    // Ambient lighting
+    vec3 ambient = uAmbientColor * finalColor.rgb;
+
+    // Diffuse lighting (two-sided for terrain hills)
+    float diff = abs(dot(norm, lightDir));
+    diff = max(diff, 0.2);  // Minimum light to prevent completely dark faces
+    vec3 diffuse = diff * uLightColor * finalColor.rgb;
+
+    // Shadow
+    float shadow = uShadowEnabled ? calcShadow() : 1.0;
+    shadow = mix(1.0, shadow, clamp(uShadowStrength, 0.0, 1.0));
+
+    // Combine lighting (terrain is purely diffuse — no specular on ground)
+    vec3 result = ambient + shadow * diffuse;
+
+    // Apply fog
+    float distance = length(uViewPos - FragPos);
+    float fogFactor = clamp((uFogEnd - distance) / (uFogEnd - uFogStart), 0.0, 1.0);
+    result = mix(uFogColor, result, fogFactor);
+
+    FragColor = vec4(result, 1.0);
+}
diff --git a/assets/shaders/terrain.frag.glsl b/assets/shaders/terrain.frag.glsl
index 0fcdd7dd..0a424090 100644
--- a/assets/shaders/terrain.frag.glsl
+++ b/assets/shaders/terrain.frag.glsl
@@ -116,8 +116,8 @@ void main() {
         vec4 lsPos = lightSpaceMatrix * vec4(biasedPos, 1.0);
         vec3 proj = lsPos.xyz / lsPos.w;
         proj.xy = proj.xy * 0.5 + 0.5;
-        if (proj.x >= 0.0 && proj.x <= 1.0 && proj.y >= 0.0 && proj.y <= 1.0 && proj.z >= 0.0 && proj.z <= 1.0) {
-            float bias = max(0.0005 * (1.0 - abs(dot(norm, ldir))), 0.00005);
+        if (proj.x >= 0.0 && proj.x <= 1.0 && proj.y >= 0.0 && proj.y <= 1.0 && proj.z <= 1.0) {
+            float bias = 0.0002;
             shadow = sampleShadowPCF(uShadowMap, vec3(proj.xy, proj.z - bias));
             shadow = mix(1.0, shadow, shadowParams.y);
         }
diff --git a/assets/shaders/terrain.vert b/assets/shaders/terrain.vert
new file mode 100644
index 00000000..f8a57ae8
--- /dev/null
+++ b/assets/shaders/terrain.vert
@@ -0,0 +1,28 @@
+#version 330 core
+
+layout(location = 0) in vec3 aPosition;
+layout(location = 1) in vec3 aNormal;
+layout(location = 2) in vec2 aTexCoord;
+layout(location = 3) in vec2 aLayerUV;
+
+out vec3 FragPos;
+out vec3 Normal;
+out vec2 TexCoord;
+out vec2 LayerUV;
+
+uniform mat4 uModel;
+uniform mat4 uView;
+uniform mat4 uProjection;
+
+void main() {
+    vec4 worldPos = uModel * vec4(aPosition, 1.0);
+    FragPos = worldPos.xyz;
+
+    // Terrain uses identity model matrix, so normal passes through directly
+    Normal = aNormal;
+
+    TexCoord = aTexCoord;
+    LayerUV = aLayerUV;
+
+    gl_Position = uProjection * uView * worldPos;
+}
diff --git a/assets/shaders/water.frag.glsl b/assets/shaders/water.frag.glsl
index f656b681..5d3af519 100644
--- a/assets/shaders/water.frag.glsl
+++ b/assets/shaders/water.frag.glsl
@@ -47,16 +47,12 @@ layout(location = 0) out vec4 outColor;
 // Dual-scroll detail normals (multi-octave ripple overlay)
 // ============================================================
 vec3 dualScrollWaveNormal(vec2 p, float time) {
-    // Three wave octaves at different angles, frequencies, and speeds.
-    // Directions are non-axis-aligned to prevent visible tiling patterns.
-    // Frequency increases and amplitude decreases per octave (standard
-    // multi-octave noise layering for natural water appearance).
-    vec2 d1 = normalize(vec2(0.86, 0.51));   // ~30° from +X
-    vec2 d2 = normalize(vec2(-0.47, 0.88));  // ~118° (opposing cross-wave)
-    vec2 d3 = normalize(vec2(0.32, -0.95));  // ~-71° (third axis for variety)
-    float f1 = 0.19, f2 = 0.43, f3 = 0.72;  // spatial frequency (higher = tighter ripples)
-    float s1 = 0.95, s2 = 1.73, s3 = 2.40;  // scroll speed (higher octaves move faster)
-    float a1 = 0.22, a2 = 0.10, a3 = 0.05;  // amplitude (decreasing for natural falloff)
+    vec2 d1 = normalize(vec2(0.86, 0.51));
+    vec2 d2 = normalize(vec2(-0.47, 0.88));
+    vec2 d3 = normalize(vec2(0.32, -0.95));
+    float f1 = 0.19, f2 = 0.43, f3 = 0.72;
+    float s1 = 0.95, s2 = 1.73, s3 = 2.40;
+    float a1 = 0.22, a2 = 0.10, a3 = 0.05;
 
     vec2 p1 = p + d1 * (time * s1 * 4.0);
     vec2 p2 = p + d2 * (time * s2 * 4.0);
diff --git a/assets/shaders/wmo.frag.glsl b/assets/shaders/wmo.frag.glsl
index ce29a0d1..a4bae057 100644
--- a/assets/shaders/wmo.frag.glsl
+++ b/assets/shaders/wmo.frag.glsl
@@ -29,9 +29,6 @@ layout(set = 1, binding = 1) uniform WMOMaterial {
     float heightMapVariance;
     float normalMapStrength;
     int isLava;
-    float wmoAmbientR;
-    float wmoAmbientG;
-    float wmoAmbientB;
 };
 
 layout(set = 1, binding = 2) uniform sampler2D uNormalHeightMap;
@@ -176,7 +173,7 @@ void main() {
         if (proj.x >= 0.0 && proj.x <= 1.0 &&
             proj.y >= 0.0 && proj.y <= 1.0 &&
             proj.z >= 0.0 && proj.z <= 1.0) {
-            float bias = max(0.0005 * (1.0 - abs(dot(norm, ldir))), 0.00005);
+            float bias = max(0.0005 * (1.0 - dot(norm, ldir)), 0.00005);
             shadow = sampleShadowPCF(uShadowMap, vec3(proj.xy, proj.z - bias));
         }
         shadow = mix(1.0, shadow, shadowParams.y);
@@ -188,13 +185,7 @@ void main() {
     } else if (unlit != 0) {
         result = texColor.rgb * shadow;
     } else if (isInterior != 0) {
-        // WMO interior: vertex colors (MOCV) are pre-baked lighting from the artist.
-        // The MOHD ambient color tints/floors the vertex colors so dark spots don't
-        // go completely black, matching the WoW client's interior shading.
-        vec3 wmoAmbient = vec3(wmoAmbientR, wmoAmbientG, wmoAmbientB);
-        // Clamp ambient to at least 0.3 to avoid total darkness when MOHD color is zero
-        wmoAmbient = max(wmoAmbient, vec3(0.3));
-        vec3 mocv = max(VertColor.rgb, wmoAmbient);
+        vec3 mocv = max(VertColor.rgb, vec3(0.5));
         result = texColor.rgb * mocv * shadow;
     } else {
         vec3 ldir = normalize(-lightDir.xyz);
diff --git a/assets/shaders/wmo.frag.spv b/assets/shaders/wmo.frag.spv
index 3507f3c9..524dbd1e 100644
Binary files a/assets/shaders/wmo.frag.spv and b/assets/shaders/wmo.frag.spv differ
diff --git a/assets/textures/README.md b/assets/textures/README.md
deleted file mode 100644
index aea06c61..00000000
--- a/assets/textures/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# HD Texture Assets
-
-**Source**: TurtleHD Texture Pack (Turtle WoW)
-**Imported**: 2026-01-27
-**Total Files**: 298 BLP textures
-**Total Size**: 10MB
-
-## Directory Structure
-
-```
-textures/
-├── character/
-│   └── human/          # 274 human male textures
-├── creature/           # 15 creature textures
-├── item/               # (reserved for future)
-└── world/
-    ├── generic/        # 1 generic world texture
-    └── stormwind/      # 8 Stormwind building textures
-```
-
-## Usage
-
-These HD BLP textures are ready for integration with:
-- **WMO Renderer**: Building texture mapping
-- **Character Renderer**: M2 model skin/face textures
-- **Creature Renderer**: NPC texture application
-
-## Integration Status
-
-Textures are loaded via the BLP pipeline and applied to WMO/M2 renderers.
-HD texture overrides (e.g. TurtleHD packs) can be placed as PNG files
-alongside the original BLP paths — the asset manager checks for `.png`
-overrides before loading the `.blp` version.
diff --git a/container/FLOW.md b/container/FLOW.md
deleted file mode 100644
index 619328c0..00000000
--- a/container/FLOW.md
+++ /dev/null
@@ -1,283 +0,0 @@
-# Container Build Flow
-
-Comprehensive documentation of the Docker-based build pipeline for each target platform.
-
----
-
-## Architecture Overview
-
-Each platform follows the same two-phase pattern:
-
-1. **Image Build** (one-time, cached by Docker) — installs compilers, toolchains, and pre-builds vcpkg dependencies.
-2. **Container Run** (each build) — copies source into the container, runs CMake configure + build, outputs artifacts to the host.
-
-```
-Host                              Docker
-─────────────────────────────────────────────────────────────
-run-{platform}.sh/.ps1
-  │
-  ├─ docker build                 builder-{platform}.Dockerfile
-  │    (cached after first run)     ├─ install compilers
-  │                                 ├─ install vcpkg + packages
-  │                                 └─ COPY build-{platform}.sh
-  │
-  └─ docker run                   build-{platform}.sh (entrypoint)
-       ├─ bind /src (readonly)      ├─ tar copy source → /wowee-build-src
-       └─ bind /out (writable)      ├─ git clone FidelityFX SDKs
-                                    ├─ cmake -S . -B /out
-                                    ├─ cmake --build /out
-                                    └─ artifacts appear in /out
-```
-
----
-
-## Linux Build Flow
-
-**Image:** `wowee-builder-linux`  
-**Dockerfile:** `builder-linux.Dockerfile`  
-**Toolchain:** GCC + Ninja (native amd64)  
-**Base:** Ubuntu 24.04
-
-### Docker Image Build Steps
-
-| Step | What | Why |
-|------|------|-----|
-| 1 | `apt-get install` cmake, ninja-build, build-essential, pkg-config, git, python3 | Core build tools |
-| 2 | `apt-get install` glslang-tools, spirv-tools | Vulkan shader compilation |
-| 3 | `apt-get install` libsdl2-dev, libglew-dev, libglm-dev, libssl-dev, zlib1g-dev | Runtime dependencies (system packages) |
-| 4 | `apt-get install` libavformat-dev, libavcodec-dev, libswscale-dev, libavutil-dev | FFmpeg libraries |
-| 5 | `apt-get install` libvulkan-dev, vulkan-tools | Vulkan SDK |
-| 6 | `apt-get install` libstorm-dev, libunicorn-dev | MPQ archive + CPU emulation |
-| 7 | COPY `build-linux.sh` → `/build-platform.sh` | Container entrypoint |
-
-### Container Run Steps (build-linux.sh)
-
-```
-1. tar copy /src → /wowee-build-src (excludes build/, .git/, large Data/ dirs)
-2. git clone FidelityFX-FSR2 (if missing)
-3. git clone FidelityFX-SDK (if missing)
-4. cmake configure:
-     -G Ninja
-     -DCMAKE_BUILD_TYPE=Release
-     -DCMAKE_C_COMPILER=gcc
-     -DCMAKE_CXX_COMPILER=g++
-     -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON
-5. cmake --build (parallel)
-6. Create Data symlink: build/linux/bin/Data → ../../../Data
-```
-
-### Output
-- `build/linux/bin/wowee` — ELF 64-bit x86-64 executable
-- `build/linux/bin/Data` — symlink to project Data/ directory
-
----
-
-## macOS Build Flow
-
-**Image:** `wowee-builder-macos`  
-**Dockerfile:** `builder-macos.Dockerfile` (multi-stage)  
-**Toolchain:** osxcross (Clang 18 + Apple ld64)  
-**Base:** Ubuntu 24.04  
-**Targets:** arm64-apple-darwin24.5 (default), x86_64-apple-darwin24.5
-
-### Docker Image Build — Stage 1: SDK Fetcher
-
-The macOS SDK is fetched automatically from Apple's public software update catalog.
-No manual download required.
-
-| Step | What | Why |
-|------|------|-----|
-| 1 | `FROM ubuntu:24.04 AS sdk-fetcher` | Lightweight stage for SDK download |
-| 2 | `apt-get install` ca-certificates, python3, cpio, tar, gzip, xz-utils | SDK extraction tools |
-| 3 | COPY `macos/sdk-fetcher.py` → `/opt/sdk-fetcher.py` | Python script that scrapes Apple's SUCATALOG |
-| 4 | `python3 /opt/sdk-fetcher.py /opt/sdk` | Downloads, extracts, and packages MacOSX15.5.sdk.tar.gz |
-
-**SDK Fetcher internals** (`macos/sdk-fetcher.py`):
-1. Queries Apple SUCATALOG URLs for the latest macOS package
-2. Downloads the `CLTools_macOSNMOS_SDK.pkg` package
-3. Extracts the XAR archive (using `bsdtar` or pure-Python fallback)
-4. Decompresses the PBZX payload stream
-5. Extracts via `cpio` to get the SDK directory
-6. Packages as `MacOSX<version>.sdk.tar.gz`
-
-### Docker Image Build — Stage 2: Builder
-
-| Step | What | Why |
-|------|------|-----|
-| 1 | `FROM ubuntu:24.04 AS builder` | Full build environment |
-| 2 | `apt-get install` cmake, ninja-build, git, python3, curl, wget, xz-utils, zip, unzip, tar, make, patch, libssl-dev, zlib1g-dev, pkg-config, libbz2-dev, libxml2-dev, uuid-dev | Build tools + osxcross build deps |
-| 3 | Install Clang 18 from LLVM apt repo (`llvm-toolchain-jammy-18`) | Cross-compiler backend |
-| 4 | Symlink clang-18 → clang, clang++-18 → clang++, etc. | osxcross expects unversioned names |
-| 5 | `git clone osxcross` → `/opt/osxcross` | Apple cross-compile toolchain wrapper |
-| 6 | `COPY --from=sdk-fetcher /opt/sdk/ → /opt/osxcross/tarballs/` | SDK from stage 1 |
-| 7 | `UNATTENDED=1 ./build.sh` | Builds osxcross (LLVM wrappers + cctools + ld64) |
-| 8 | Create unprefixed symlinks (install_name_tool, otool, lipo, codesign) | vcpkg/CMake need these without arch prefix |
-| 9 | COPY `macos/osxcross-toolchain.cmake` → `/opt/osxcross-toolchain.cmake` | Auto-detecting CMake toolchain |
-| 10 | COPY `macos/triplets/` → `/opt/vcpkg-triplets/` | vcpkg cross-compile triplet definitions |
-| 11 | `apt-get install` file, nasm | Mach-O detection + ffmpeg x86 asm |
-| 12 | Bootstrap vcpkg → `/opt/vcpkg` | Package manager |
-| 13 | `vcpkg install` sdl2, openssl, glew, glm, zlib, ffmpeg `--triplet arm64-osx-cross` | arm64 dependencies |
-| 14 | `vcpkg install` same packages `--triplet x64-osx-cross` | x86_64 dependencies |
-| 15 | `apt-get install` libvulkan-dev, glslang-tools | Vulkan headers (for compilation, not runtime) |
-| 16 | COPY `build-macos.sh` → `/build-platform.sh` | Container entrypoint |
-
-### Custom Toolchain Files
-
-**`macos/osxcross-toolchain.cmake`** — Auto-detecting CMake toolchain:
-- Detects SDK path via `file(GLOB)` in `/opt/osxcross/target/SDK/MacOSX*.sdk`
-- Detects darwin version from compiler binary names (e.g., `arm64-apple-darwin24.5-clang`)
-- Picks architecture from `CMAKE_OSX_ARCHITECTURES`
-- Sets `CMAKE_C_COMPILER`, `CMAKE_CXX_COMPILER`, `CMAKE_AR`, `CMAKE_RANLIB`, `CMAKE_STRIP`
-
-**`macos/triplets/arm64-osx-cross.cmake`**:
-```cmake
-set(VCPKG_TARGET_ARCHITECTURE arm64)
-set(VCPKG_LIBRARY_LINKAGE static)
-set(VCPKG_CMAKE_SYSTEM_NAME Darwin)
-set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE /opt/osxcross-toolchain.cmake)
-```
-
-### Container Run Steps (build-macos.sh)
-
-```
-1. Determine arch from MACOS_ARCH env (default: arm64)
-2. Pick vcpkg triplet: arm64-osx-cross or x64-osx-cross
-3. Auto-detect darwin target from osxcross binaries
-4. tar copy /src → /wowee-build-src
-5. git clone FidelityFX-FSR2 + FidelityFX-SDK (if missing)
-6. cmake configure:
-     -G Ninja
-     -DCMAKE_BUILD_TYPE=Release
-     -DCMAKE_SYSTEM_NAME=Darwin
-     -DCMAKE_OSX_ARCHITECTURES=${ARCH}
-     -DCMAKE_C_COMPILER=osxcross clang
-     -DCMAKE_CXX_COMPILER=osxcross clang++
-     -DCMAKE_TOOLCHAIN_FILE=vcpkg.cmake
-     -DVCPKG_TARGET_TRIPLET=arm64-osx-cross
-     -DVCPKG_OVERLAY_TRIPLETS=/opt/vcpkg-triplets
-7. cmake --build (parallel)
-```
-
-### CMakeLists.txt Integration
-
-The main CMakeLists.txt has a macOS cross-compile branch that:
-- Finds Vulkan headers via vcpkg (`VulkanHeaders` package) instead of the Vulkan SDK
-- Adds `-undefined dynamic_lookup` linker flag for Vulkan loader symbols (resolved at runtime via MoltenVK)
-
-### Output
-- `build/macos/bin/wowee` — Mach-O 64-bit arm64 (or x86_64) executable (~40 MB)
-
----
-
-## Windows Build Flow
-
-**Image:** `wowee-builder-windows`  
-**Dockerfile:** `builder-windows.Dockerfile`  
-**Toolchain:** LLVM-MinGW (Clang + LLD) targeting x86_64-w64-mingw32-ucrt  
-**Base:** Ubuntu 24.04
-
-### Docker Image Build Steps
-
-| Step | What | Why |
-|------|------|-----|
-| 1 | `apt-get install` ca-certificates, build-essential, cmake, ninja-build, git, python3, curl, zip, unzip, tar, xz-utils, pkg-config, nasm, libssl-dev, zlib1g-dev | Build tools |
-| 2 | Download + extract LLVM-MinGW (v20240619 ucrt) → `/opt/llvm-mingw` | Clang/LLD cross-compiler for Windows |
-| 3 | Add `/opt/llvm-mingw/bin` to PATH | Makes `x86_64-w64-mingw32-clang` etc. available |
-| 4 | Bootstrap vcpkg → `/opt/vcpkg` | Package manager |
-| 5 | `vcpkg install` sdl2, openssl, glew, glm, zlib, ffmpeg `--triplet x64-mingw-static` | Static Windows dependencies |
-| 6 | `apt-get install` libvulkan-dev, glslang-tools | Vulkan headers + shader tools |
-| 7 | Create no-op `powershell.exe` stub | vcpkg MinGW post-build hook needs it |
-| 8 | COPY `build-windows.sh` → `/build-platform.sh` | Container entrypoint |
-
-### Container Run Steps (build-windows.sh)
-
-```
-1. Set up no-op powershell.exe (if not already present)
-2. tar copy /src → /wowee-build-src
-3. git clone FidelityFX-FSR2 + FidelityFX-SDK (if missing)
-4. Generate Vulkan import library:
-     a. Extract vk* symbols from vulkan_core.h
-     b. Create vulkan-1.def file
-     c. Run dlltool to create libvulkan-1.a
-5. Lock PKG_CONFIG_LIBDIR to vcpkg packages only
-6. cmake configure:
-     -G Ninja
-     -DCMAKE_BUILD_TYPE=Release
-     -DCMAKE_SYSTEM_NAME=Windows
-     -DCMAKE_C_COMPILER=x86_64-w64-mingw32-clang
-     -DCMAKE_CXX_COMPILER=x86_64-w64-mingw32-clang++
-     -DCMAKE_RC_COMPILER=x86_64-w64-mingw32-windres
-     -DCMAKE_EXE_LINKER_FLAGS=-fuse-ld=lld
-     -DCMAKE_TOOLCHAIN_FILE=vcpkg.cmake
-     -DVCPKG_TARGET_TRIPLET=x64-mingw-static
-     -DVCPKG_APPLOCAL_DEPS=OFF
-7. cmake --build (parallel)
-```
-
-### Vulkan Import Library Generation
-
-Windows applications link against `vulkan-1.dll` (the Khronos Vulkan loader). Since the LLVM-MinGW toolchain doesn't ship a Vulkan import library, the build script generates one:
-
-1. Parses `vulkan_core.h` for `VKAPI_CALL vk*` function names
-2. Creates a `.def` file mapping symbols to `vulkan-1.dll`
-3. Uses `dlltool` to produce `libvulkan-1.a` (PE import library)
-
-This allows the linker to resolve Vulkan symbols at build time, while deferring actual loading to the runtime DLL.
-
-### Output
-- `build/windows/bin/wowee.exe` — PE32+ x86-64 executable (~135 MB)
-
----
-
-## Shared Patterns
-
-### Source Tree Copy
-
-All three platforms use the same tar-based copy with exclusions:
-```bash
-tar -C /src \
-    --exclude='./build' --exclude='./logs' --exclude='./cache' \
-    --exclude='./container' --exclude='./.git' \
-    --exclude='./Data/character' --exclude='./Data/creature' \
-    --exclude='./Data/db' --exclude='./Data/environment' \
-    --exclude='./Data/interface' --exclude='./Data/item' \
-    --exclude='./Data/misc' --exclude='./Data/sound' \
-    --exclude='./Data/spell' --exclude='./Data/terrain' \
-    --exclude='./Data/world' \
-    -cf - . | tar -C /wowee-build-src -xf -
-```
-
-**Kept:** `Data/opcodes/`, `Data/expansions/` (small, needed at build time for configuration).  
-**Excluded:** Large game asset directories (character, creature, environment, etc.) not needed for compilation.
-
-### FidelityFX SDK Fetch
-
-All platforms clone the same two repos at build time:
-1. **FidelityFX-FSR2** — FSR 2.0 upscaling
-2. **FidelityFX-SDK** — FSR 3.0 frame generation (repo URL/ref configurable via env vars)
-
-### .dockerignore
-
-The `.dockerignore` at the project root minimizes the Docker build context by excluding:
-- `build/`, `cache/`, `logs/`, `.git/`
-- Large external dirs (`extern/FidelityFX-*`)
-- IDE files, documentation, host-only scripts
-- SDK tarballs (`*.tar.xz`, `*.tar.gz`, etc.)
-
----
-
-## Timing Estimates
-
-These are approximate times on a 4-core machine with 16 GB RAM:
-
-| Phase | Linux | macOS | Windows |
-|-------|-------|-------|---------|
-| Docker image build (first time) | ~5 min | ~25 min | ~15 min |
-| Docker image build (cached) | seconds | seconds | seconds |
-| Source copy + SDK fetch | ~10 sec | ~10 sec | ~10 sec |
-| CMake configure | ~20 sec | ~30 sec | ~30 sec |
-| Compilation | ~8 min | ~8 min | ~8 min |
-| **Total (first build)** | **~14 min** | **~34 min** | **~24 min** |
-| **Total (subsequent)** | **~9 min** | **~9 min** | **~9 min** |
-
-macOS image is slowest because osxcross builds a subset of LLVM + cctools, and vcpkg packages are compiled for two architectures (arm64 + x64).
diff --git a/container/README.md b/container/README.md
deleted file mode 100644
index da911f2c..00000000
--- a/container/README.md
+++ /dev/null
@@ -1,119 +0,0 @@
-# Container Builds
-
-Build WoWee for **Linux**, **macOS**, or **Windows** with a single command.  
-All builds run inside Docker — no toolchains to install on your host.
-
-## Prerequisites
-
-- [Docker](https://docs.docker.com/get-docker/) (Docker Desktop on Windows/macOS, or Docker Engine on Linux)
-- ~20 GB free disk space (toolchains + vcpkg packages are cached in the Docker image)
-
-## Quick Start
-
-Run **from the project root directory**.
-
-### Linux (native amd64)
-
-```bash
-# Bash / Linux / macOS terminal
-./container/run-linux.sh
-```
-```powershell
-# PowerShell (Windows)
-.\container\run-linux.ps1
-```
-
-Output: `build/linux/bin/wowee`
-
-### macOS (cross-compile, arm64 default)
-
-```bash
-./container/run-macos.sh
-```
-```powershell
-.\container\run-macos.ps1
-```
-
-Output: `build/macos/bin/wowee`
-
-For Intel (x86_64):
-```bash
-MACOS_ARCH=x86_64 ./container/run-macos.sh
-```
-```powershell
-.\container\run-macos.ps1 -Arch x86_64
-```
-
-### Windows (cross-compile, x86_64)
-
-```bash
-./container/run-windows.sh
-```
-```powershell
-.\container\run-windows.ps1
-```
-
-Output: `build/windows/bin/wowee.exe`
-
-## Options
-
-| Option | Bash | PowerShell | Description |
-|--------|------|------------|-------------|
-| Rebuild image | `--rebuild-image` | `-RebuildImage` | Force a fresh Docker image build |
-| macOS arch | `MACOS_ARCH=x86_64` | `-Arch x86_64` | Build for Intel instead of Apple Silicon |
-| FidelityFX SDK repo | `WOWEE_FFX_SDK_REPO=<url>` | `$env:WOWEE_FFX_SDK_REPO="<url>"` | Custom FidelityFX SDK git URL |
-| FidelityFX SDK ref | `WOWEE_FFX_SDK_REF=<ref>` | `$env:WOWEE_FFX_SDK_REF="<ref>"` | Custom FidelityFX SDK git ref/tag |
-
-## Docker Image Caching
-
-The first build takes longer because Docker builds the toolchain image (installing compilers, vcpkg packages, etc.). Subsequent builds reuse the cached image and only run the compilation step.
-
-To force a full image rebuild:
-```bash
-./container/run-linux.sh --rebuild-image
-```
-
-## Output Locations
-
-| Target | Binary | Size |
-|--------|--------|------|
-| Linux | `build/linux/bin/wowee` | ~135 MB |
-| macOS | `build/macos/bin/wowee` | ~40 MB |
-| Windows | `build/windows/bin/wowee.exe` | ~135 MB |
-
-## File Structure
-
-```
-container/
-├── run-linux.sh / .ps1          # Host launchers (bash / PowerShell)
-├── run-macos.sh / .ps1
-├── run-windows.sh / .ps1
-├── build-linux.sh               # Container entrypoints (run inside Docker)
-├── build-macos.sh
-├── build-windows.sh
-├── builder-linux.Dockerfile     # Docker image definitions
-├── builder-macos.Dockerfile
-├── builder-windows.Dockerfile
-├── macos/
-│   ├── sdk-fetcher.py           # Auto-fetches macOS SDK from Apple's catalog
-│   ├── osxcross-toolchain.cmake # CMake toolchain for osxcross
-│   └── triplets/                # vcpkg cross-compile triplets
-│       ├── arm64-osx-cross.cmake
-│       └── x64-osx-cross.cmake
-├── README.md                    # This file
-└── FLOW.md                      # Detailed build flow documentation
-```
-
-## Troubleshooting
-
-**"docker is not installed or not in PATH"**  
-Install Docker and ensure the `docker` command is available in your terminal.
-
-**Build fails on first run**  
-Some vcpkg packages (ffmpeg, SDL2) take a while to compile. Ensure you have enough RAM (4 GB+) and disk space.
-
-**macOS build: "could not find osxcross compiler"**  
-The Docker image may not have built correctly. Run with `--rebuild-image` to rebuild from scratch.
-
-**Windows build: linker errors about vulkan-1.dll**  
-The build script auto-generates a Vulkan import library. If this fails, ensure the Docker image has `libvulkan-dev` installed (it should, by default).
diff --git a/container/build-in-container.sh b/container/build-in-container.sh
new file mode 100755
index 00000000..cc0822b4
--- /dev/null
+++ b/container/build-in-container.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+
+set -eu 
+set -o pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+
+podman build \
+	-f "${SCRIPT_DIR}/builder-ubuntu.Dockerfile" \
+	-t wowee-builder-ubuntu
+
+BUILD_DIR="$(mktemp --tmpdir -d wowee.XXXXX \
+	--suffix=".$(cd "${PROJECT_ROOT}"; git rev-parse --short HEAD)")"
+podman run \
+	--mount "type=bind,src=${PROJECT_ROOT},dst=/WoWee-src,ro=true" \
+	--mount "type=bind,src=${BUILD_DIR},dst=/build" \
+	localhost/wowee-builder-ubuntu \
+	./build-wowee.sh
diff --git a/container/build-linux.sh b/container/build-linux.sh
deleted file mode 100755
index a87b5e03..00000000
--- a/container/build-linux.sh
+++ /dev/null
@@ -1,63 +0,0 @@
-#!/bin/bash
-# Linux amd64 build entrypoint — runs INSIDE the linux container.
-# Bind-mounts:
-#   /src  (ro) — project source
-#   /out  (rw) — host ./build/linux
-
-set -euo pipefail
-
-SRC=/src
-OUT=/out
-NPROC=$(nproc)
-
-echo "==> [linux] Copying source tree..."
-mkdir -p /wowee-build-src
-tar -C "${SRC}" \
-    --exclude='./build' --exclude='./logs' --exclude='./cache' \
-    --exclude='./container' --exclude='./.git' \
-    --exclude='./Data/character' --exclude='./Data/creature' \
-    --exclude='./Data/db' --exclude='./Data/environment' \
-    --exclude='./Data/interface' --exclude='./Data/item' \
-    --exclude='./Data/misc' --exclude='./Data/sound' \
-    --exclude='./Data/spell' --exclude='./Data/terrain' \
-    --exclude='./Data/world' \
-    -cf - . | tar -C /wowee-build-src -xf -
-
-cd /wowee-build-src
-
-echo "==> [linux] Fetching external SDKs (if needed)..."
-if [ ! -f extern/FidelityFX-FSR2/src/ffx-fsr2-api/ffx_fsr2.h ]; then
-    git clone --depth 1 \
-        https://github.com/GPUOpen-Effects/FidelityFX-FSR2.git \
-        extern/FidelityFX-FSR2 || echo "Warning: FSR2 clone failed — continuing without FSR2"
-fi
-
-SDK_REPO="${WOWEE_FFX_SDK_REPO:-https://github.com/Kelsidavis/FidelityFX-SDK.git}"
-SDK_REF="${WOWEE_FFX_SDK_REF:-main}"
-if [ ! -f "extern/FidelityFX-SDK/sdk/include/FidelityFX/host/ffx_frameinterpolation.h" ]; then
-    git clone --depth 1 --branch "${SDK_REF}" "${SDK_REPO}" extern/FidelityFX-SDK \
-        || echo "Warning: FidelityFX-SDK clone failed — continuing without FSR3"
-fi
-
-echo "==> [linux] Configuring with CMake (Release, Ninja, amd64)..."
-cmake -S . -B "${OUT}" \
-    -G Ninja \
-    -DCMAKE_BUILD_TYPE=Release \
-    -DCMAKE_C_COMPILER=gcc \
-    -DCMAKE_CXX_COMPILER=g++ \
-    -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON
-
-echo "==> [linux] Building with ${NPROC} cores..."
-cmake --build "${OUT}" --parallel "${NPROC}"
-
-echo "==> [linux] Creating Data symlink..."
-mkdir -p "${OUT}/bin"
-if [ ! -e "${OUT}/bin/Data" ]; then
-    # Relative symlink so it resolves correctly on the host:
-    # build/linux/bin/Data -> ../../../Data (project root)
-    ln -s ../../../Data "${OUT}/bin/Data"
-fi
-
-echo ""
-echo "==> [linux] Build complete. Artifacts in: ./build/linux/"
-echo "    Binary: ./build/linux/bin/wowee"
diff --git a/container/build-macos.sh b/container/build-macos.sh
deleted file mode 100755
index 3ead48e1..00000000
--- a/container/build-macos.sh
+++ /dev/null
@@ -1,83 +0,0 @@
-#!/bin/bash
-# macOS cross-compile entrypoint — runs INSIDE the macos container.
-# Toolchain: osxcross + Apple Clang, target: arm64-apple-darwin (default) or
-#            x86_64-apple-darwin when MACOS_ARCH=x86_64.
-# Bind-mounts:
-#   /src  (ro) — project source
-#   /out  (rw) — host ./build/macos
-
-set -euo pipefail
-
-SRC=/src
-OUT=/out
-NPROC=$(nproc)
-
-# Arch selection: arm64 (Apple Silicon) is the default primary target.
-ARCH="${MACOS_ARCH:-arm64}"
-case "${ARCH}" in
-    arm64)   VCPKG_TRIPLET=arm64-osx-cross  ;;
-    x86_64)  VCPKG_TRIPLET=x64-osx-cross    ;;
-    *)  echo "ERROR: unsupported MACOS_ARCH '${ARCH}'. Use arm64 or x86_64." ; exit 1 ;;
-esac
-
-# Auto-detect darwin target from osxcross binaries (e.g. arm64-apple-darwin24.5).
-OSXCROSS_BIN=/opt/osxcross/target/bin
-TARGET=$(basename "$(ls "${OSXCROSS_BIN}/${ARCH}-apple-darwin"*-clang 2>/dev/null | head -1)" | sed 's/-clang$//')
-if [[ -z "${TARGET}" ]]; then
-    echo "ERROR: could not find osxcross ${ARCH} compiler in ${OSXCROSS_BIN}" >&2
-    exit 1
-fi
-echo "==> Detected osxcross target: ${TARGET}"
-
-echo "==> [macos/${ARCH}] Copying source tree..."
-mkdir -p /wowee-build-src
-tar -C "${SRC}" \
-    --exclude='./build' --exclude='./logs' --exclude='./cache' \
-    --exclude='./container' --exclude='./.git' \
-    --exclude='./Data/character' --exclude='./Data/creature' \
-    --exclude='./Data/db' --exclude='./Data/environment' \
-    --exclude='./Data/interface' --exclude='./Data/item' \
-    --exclude='./Data/misc' --exclude='./Data/sound' \
-    --exclude='./Data/spell' --exclude='./Data/terrain' \
-    --exclude='./Data/world' \
-    -cf - . | tar -C /wowee-build-src -xf -
-
-cd /wowee-build-src
-
-echo "==> [macos/${ARCH}] Fetching external SDKs (if needed)..."
-if [ ! -f extern/FidelityFX-FSR2/src/ffx-fsr2-api/ffx_fsr2.h ]; then
-    git clone --depth 1 \
-        https://github.com/GPUOpen-Effects/FidelityFX-FSR2.git \
-        extern/FidelityFX-FSR2 || echo "Warning: FSR2 clone failed"
-fi
-
-SDK_REPO="${WOWEE_FFX_SDK_REPO:-https://github.com/Kelsidavis/FidelityFX-SDK.git}"
-SDK_REF="${WOWEE_FFX_SDK_REF:-main}"
-if [ ! -f "extern/FidelityFX-SDK/sdk/include/FidelityFX/host/ffx_frameinterpolation.h" ]; then
-    git clone --depth 1 --branch "${SDK_REF}" "${SDK_REPO}" extern/FidelityFX-SDK \
-        || echo "Warning: FidelityFX-SDK clone failed"
-fi
-
-echo "==> [macos/${ARCH}] Configuring with CMake (Release, Ninja, osxcross ${TARGET})..."
-cmake -S . -B "${OUT}" \
-    -G Ninja \
-    -DCMAKE_BUILD_TYPE=Release \
-    -DCMAKE_SYSTEM_NAME=Darwin \
-    -DCMAKE_OSX_ARCHITECTURES="${ARCH}" \
-    -DCMAKE_OSX_DEPLOYMENT_TARGET="${MACOSX_DEPLOYMENT_TARGET:-13.0}" \
-    -DCMAKE_C_COMPILER="${OSXCROSS_BIN}/${TARGET}-clang" \
-    -DCMAKE_CXX_COMPILER="${OSXCROSS_BIN}/${TARGET}-clang++" \
-    -DCMAKE_AR="${OSXCROSS_BIN}/${TARGET}-ar" \
-    -DCMAKE_RANLIB="${OSXCROSS_BIN}/${TARGET}-ranlib" \
-    -DCMAKE_TOOLCHAIN_FILE="${VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake" \
-    -DVCPKG_TARGET_TRIPLET="${VCPKG_TRIPLET}" \
-    -DVCPKG_OVERLAY_TRIPLETS=/opt/vcpkg-triplets \
-    -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=OFF \
-    -DWOWEE_ENABLE_ASAN=OFF
-
-echo "==> [macos/${ARCH}] Building with ${NPROC} cores..."
-cmake --build "${OUT}" --parallel "${NPROC}"
-
-echo ""
-echo "==> [macos/${ARCH}] Build complete. Artifacts in: ./build/macos/"
-echo "    Binary: ./build/macos/bin/wowee"
diff --git a/container/build-windows.sh b/container/build-windows.sh
deleted file mode 100755
index 7f0478ef..00000000
--- a/container/build-windows.sh
+++ /dev/null
@@ -1,110 +0,0 @@
-#!/bin/bash
-# Windows cross-compile entrypoint — runs INSIDE the windows container.
-# Toolchain: LLVM-MinGW (Clang + LLD), target: x86_64-w64-mingw32-ucrt
-# Bind-mounts:
-#   /src  (ro) — project source
-#   /out  (rw) — host ./build/windows
-
-set -euo pipefail
-
-SRC=/src
-OUT=/out
-NPROC=$(nproc)
-TARGET=x86_64-w64-mingw32
-
-# vcpkg's MinGW applocal hook always appends a powershell.exe post-build step to
-# copy DLLs next to each binary, even when VCPKG_APPLOCAL_DEPS=OFF.  For the
-# x64-mingw-static triplet the bin/ dir is empty (no DLLs) so the script does
-# nothing — but it still needs to exit 0.  Provide a no-op stub if the real
-# PowerShell isn't available.
-if ! command -v powershell.exe &>/dev/null; then
-    printf '#!/bin/sh\nexit 0\n' > /usr/local/bin/powershell.exe
-    chmod +x /usr/local/bin/powershell.exe
-fi
-
-echo "==> [windows] Copying source tree..."
-mkdir -p /wowee-build-src
-tar -C "${SRC}" \
-    --exclude='./build' --exclude='./logs' --exclude='./cache' \
-    --exclude='./container' --exclude='./.git' \
-    --exclude='./Data/character' --exclude='./Data/creature' \
-    --exclude='./Data/db' --exclude='./Data/environment' \
-    --exclude='./Data/interface' --exclude='./Data/item' \
-    --exclude='./Data/misc' --exclude='./Data/sound' \
-    --exclude='./Data/spell' --exclude='./Data/terrain' \
-    --exclude='./Data/world' \
-    -cf - . | tar -C /wowee-build-src -xf -
-
-
-cd /wowee-build-src
-
-echo "==> [windows] Fetching external SDKs (if needed)..."
-if [ ! -f extern/FidelityFX-FSR2/src/ffx-fsr2-api/ffx_fsr2.h ]; then
-    git clone --depth 1 \
-        https://github.com/GPUOpen-Effects/FidelityFX-FSR2.git \
-        extern/FidelityFX-FSR2 || echo "Warning: FSR2 clone failed"
-fi
-
-SDK_REPO="${WOWEE_FFX_SDK_REPO:-https://github.com/Kelsidavis/FidelityFX-SDK.git}"
-SDK_REF="${WOWEE_FFX_SDK_REF:-main}"
-if [ ! -f "extern/FidelityFX-SDK/sdk/include/FidelityFX/host/ffx_frameinterpolation.h" ]; then
-    git clone --depth 1 --branch "${SDK_REF}" "${SDK_REPO}" extern/FidelityFX-SDK \
-        || echo "Warning: FidelityFX-SDK clone failed"
-fi
-
-echo "==> [windows] Generating Vulkan import library for cross-compile..."
-# Windows applications link against vulkan-1.dll (the Khronos Vulkan loader).
-# The cross-compile toolchain only ships Vulkan *headers* (via vcpkg), not the
-# import library.  Generate a minimal libvulkan-1.a from the header prototypes
-# so the linker can resolve vk* symbols → vulkan-1.dll at runtime.
-# We use the host libvulkan-dev header for function name extraction — the Vulkan
-# API prototypes are platform-independent.
-VULKAN_IMP_DIR="${OUT}/vulkan-import"
-if [ ! -f "${VULKAN_IMP_DIR}/libvulkan-1.a" ]; then
-    mkdir -p "${VULKAN_IMP_DIR}"
-    # Try vcpkg-installed header first (available on incremental builds),
-    # then fall back to the host libvulkan-dev header (always present in the image).
-    VK_HEADER="${OUT}/vcpkg_installed/x64-mingw-static/include/vulkan/vulkan_core.h"
-    if [ ! -f "${VK_HEADER}" ]; then
-        VK_HEADER="/usr/include/vulkan/vulkan_core.h"
-    fi
-    {
-        echo "LIBRARY vulkan-1.dll"
-        echo "EXPORTS"
-        grep -oP 'VKAPI_ATTR \S+ VKAPI_CALL \K(vk\w+)' "${VK_HEADER}" | sort -u | sed 's/^/    /'
-    } > "${VULKAN_IMP_DIR}/vulkan-1.def"
-    "${TARGET}-dlltool" -d "${VULKAN_IMP_DIR}/vulkan-1.def" \
-        -l "${VULKAN_IMP_DIR}/libvulkan-1.a" -m i386:x86-64
-    echo "   Generated $(wc -l < "${VULKAN_IMP_DIR}/vulkan-1.def") export entries"
-fi
-
-echo "==> [windows] Configuring with CMake (Release, Ninja, LLVM-MinGW cross)..."
-# Lock pkg-config to the cross-compiled vcpkg packages only.
-# Without this, CMake's Vulkan pkg-config fallback finds the *Linux* libvulkan-dev
-# and injects /usr/include into every MinGW compile command, which then fails
-# because the glibc-specific bits/libc-header-start.h is not in the MinGW sysroot.
-export PKG_CONFIG_LIBDIR="${OUT}/vcpkg_installed/x64-mingw-static/lib/pkgconfig"
-export PKG_CONFIG_PATH=""
-cmake -S . -B "${OUT}" \
-    -G Ninja \
-    -DCMAKE_BUILD_TYPE=Release \
-    -DCMAKE_SYSTEM_NAME=Windows \
-    -DCMAKE_C_COMPILER="${TARGET}-clang" \
-    -DCMAKE_CXX_COMPILER="${TARGET}-clang++" \
-    -DCMAKE_RC_COMPILER="${TARGET}-windres" \
-    -DCMAKE_AR="/opt/llvm-mingw/bin/llvm-ar" \
-    -DCMAKE_RANLIB="/opt/llvm-mingw/bin/llvm-ranlib" \
-    -DCMAKE_EXE_LINKER_FLAGS="-fuse-ld=lld" \
-    -DCMAKE_SHARED_LINKER_FLAGS="-fuse-ld=lld" \
-    -DCMAKE_TOOLCHAIN_FILE="${VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake" \
-    -DVCPKG_TARGET_TRIPLET=x64-mingw-static \
-    -DVCPKG_APPLOCAL_DEPS=OFF \
-    -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=OFF \
-    -DWOWEE_ENABLE_ASAN=OFF
-
-echo "==> [windows] Building with ${NPROC} cores..."
-cmake --build "${OUT}" --parallel "${NPROC}"
-
-echo ""
-echo "==> [windows] Build complete. Artifacts in: ./build/windows/"
-echo "    Binary: ./build/windows/bin/wowee.exe"
diff --git a/container/build-wowee.sh b/container/build-wowee.sh
new file mode 100755
index 00000000..aabd8396
--- /dev/null
+++ b/container/build-wowee.sh
@@ -0,0 +1,14 @@
+#!/bin/bash
+
+set -eu 
+set -o pipefail
+
+cp -r /WoWee-src /WoWee
+
+pushd /WoWee
+./build.sh
+popd
+
+pushd /WoWee/build
+cmake --install . --prefix=/build
+popd
diff --git a/container/builder-linux.Dockerfile b/container/builder-linux.Dockerfile
deleted file mode 100644
index 1f9e12dc..00000000
--- a/container/builder-linux.Dockerfile
+++ /dev/null
@@ -1,33 +0,0 @@
-FROM ubuntu:24.04
-
-ENV DEBIAN_FRONTEND=noninteractive
-
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
-        cmake \
-        ninja-build \
-        build-essential \
-        pkg-config \
-        git \
-        python3 \
-        glslang-tools \
-        spirv-tools \
-        libsdl2-dev \
-        libglew-dev \
-        libglm-dev \
-        libssl-dev \
-        zlib1g-dev \
-        libavformat-dev \
-        libavcodec-dev \
-        libswscale-dev \
-        libavutil-dev \
-        libvulkan-dev \
-        vulkan-tools \
-        libstorm-dev \
-        libunicorn-dev && \
-    rm -rf /var/lib/apt/lists/*
-
-COPY build-linux.sh /build-platform.sh
-RUN chmod +x /build-platform.sh
-
-ENTRYPOINT ["/build-platform.sh"]
diff --git a/container/builder-macos.Dockerfile b/container/builder-macos.Dockerfile
deleted file mode 100644
index cb3dcb9f..00000000
--- a/container/builder-macos.Dockerfile
+++ /dev/null
@@ -1,142 +0,0 @@
-FROM ubuntu:24.04 AS sdk-fetcher
-
-# Stage 1: Fetch macOS SDK from Apple's public software update catalog.
-# This avoids requiring the user to supply the SDK tarball manually.
-# The SDK is downloaded, extracted, and packaged as a .tar.gz.
-
-ENV DEBIAN_FRONTEND=noninteractive
-
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
-        ca-certificates \
-        python3 \
-        python3-defusedxml \
-        cpio \
-        tar \
-        gzip \
-        xz-utils && \
-    rm -rf /var/lib/apt/lists/*
-
-COPY macos/sdk-fetcher.py /opt/sdk-fetcher.py
-RUN python3 /opt/sdk-fetcher.py /opt/sdk
-
-# ---------------------------------------------------------------------------
-
-FROM ubuntu:24.04 AS builder
-
-# Stage 2: macOS cross-compile image using osxcross + Clang 18.
-#
-# Target triplets (auto-detected from osxcross):
-#   arm64-apple-darwinNN  (Apple Silicon)
-#   x86_64-apple-darwinNN (Intel)
-# Default: arm64. Override with MACOS_ARCH=x86_64 env var at run time.
-
-ENV DEBIAN_FRONTEND=noninteractive
-
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
-        ca-certificates \
-        cmake \
-        ninja-build \
-        git \
-        python3 \
-        curl \
-        wget \
-        xz-utils \
-        zip \
-        unzip \
-        tar \
-        make \
-        patch \
-        libssl-dev \
-        zlib1g-dev \
-        pkg-config \
-        libbz2-dev \
-        libxml2-dev \
-        libz-dev \
-        liblzma-dev \
-        uuid-dev \
-        python3-lxml \
-        gnupg \
-        software-properties-common && \
-    wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add - && \
-    echo "deb http://apt.llvm.org/noble/ llvm-toolchain-noble-18 main" > /etc/apt/sources.list.d/llvm-18.list && \
-    apt-get update && \
-    apt-get install -y --no-install-recommends \
-        clang-18 \
-        lld-18 \
-        llvm-18 && \
-    ln -sf /usr/bin/clang-18 /usr/bin/clang && \
-    ln -sf /usr/bin/clang++-18 /usr/bin/clang++ && \
-    ln -sf /usr/bin/lld-18 /usr/bin/lld && \
-    ln -sf /usr/bin/ld.lld-18 /usr/bin/ld.lld && \
-    ln -sf /usr/bin/llvm-ar-18 /usr/bin/llvm-ar && \
-    rm -rf /var/lib/apt/lists/*
-
-# Build osxcross with SDK from stage 1
-RUN git clone --depth 1 https://github.com/tpoechtrager/osxcross.git /opt/osxcross
-
-COPY --from=sdk-fetcher /opt/sdk/ /opt/osxcross/tarballs/
-
-ENV MACOSX_DEPLOYMENT_TARGET=13.0
-RUN cd /opt/osxcross && \
-    UNATTENDED=1 ./build.sh && \
-    rm -rf /opt/osxcross/build /opt/osxcross/tarballs
-
-ENV PATH="/opt/osxcross/target/bin:${PATH}"
-ENV OSXCROSS_TARGET_DIR="/opt/osxcross/target"
-ENV MACOSX_DEPLOYMENT_TARGET=13.0
-
-# Create unprefixed symlinks for macOS tools that vcpkg/CMake expect
-RUN cd /opt/osxcross/target/bin && \
-    for tool in install_name_tool otool lipo codesign; do \
-      src="$(ls *-apple-darwin*-"${tool}" 2>/dev/null | head -1)"; \
-      if [ -n "$src" ]; then \
-        ln -sf "$src" "$tool"; \
-      fi; \
-    done
-
-# Custom osxcross toolchain + vcpkg triplets
-COPY macos/osxcross-toolchain.cmake /opt/osxcross-toolchain.cmake
-COPY macos/triplets/ /opt/vcpkg-triplets/
-
-# Extra tools needed by vcpkg's Mach-O rpath fixup and ffmpeg x86 asm
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends file nasm && \
-    rm -rf /var/lib/apt/lists/*
-
-# vcpkg — macOS cross triplets (arm64-osx-cross / x64-osx-cross)
-ENV VCPKG_ROOT=/opt/vcpkg
-RUN git clone --depth 1 https://github.com/microsoft/vcpkg.git "${VCPKG_ROOT}" && \
-    "${VCPKG_ROOT}/bootstrap-vcpkg.sh" -disableMetrics
-
-# Pre-install deps for both arches; the launcher script picks the right one at run time.
-RUN "${VCPKG_ROOT}/vcpkg" install \
-        sdl2[vulkan] \
-        openssl \
-        glew \
-        glm \
-        zlib \
-        ffmpeg \
-    --triplet arm64-osx-cross \
-    --overlay-triplets=/opt/vcpkg-triplets
-
-RUN "${VCPKG_ROOT}/vcpkg" install \
-        sdl2[vulkan] \
-        openssl \
-        glew \
-        glm \
-        zlib \
-        ffmpeg \
-    --triplet x64-osx-cross \
-    --overlay-triplets=/opt/vcpkg-triplets
-
-# Vulkan SDK headers (MoltenVK is the runtime — headers only needed to compile)
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends libvulkan-dev glslang-tools && \
-    rm -rf /var/lib/apt/lists/*
-
-COPY build-macos.sh /build-platform.sh
-RUN chmod +x /build-platform.sh
-
-ENTRYPOINT ["/build-platform.sh"]
diff --git a/container/builder-ubuntu.Dockerfile b/container/builder-ubuntu.Dockerfile
new file mode 100644
index 00000000..26f32b50
--- /dev/null
+++ b/container/builder-ubuntu.Dockerfile
@@ -0,0 +1,25 @@
+FROM ubuntu:24.04
+
+RUN apt-get update && \
+	apt install -y \
+		cmake \
+		build-essential \
+		pkg-config \
+		git \
+		libsdl2-dev \
+		libglew-dev \
+		libglm-dev \
+		libssl-dev \
+		zlib1g-dev \
+		libavformat-dev \
+		libavcodec-dev \
+		libswscale-dev \
+		libavutil-dev \
+		libvulkan-dev \
+		vulkan-tools \
+		libstorm-dev && \
+	rm -rf /var/lib/apt/lists/*
+
+COPY build-wowee.sh /
+
+ENTRYPOINT ./build-wowee.sh
diff --git a/container/builder-windows.Dockerfile b/container/builder-windows.Dockerfile
deleted file mode 100644
index 0c5abf83..00000000
--- a/container/builder-windows.Dockerfile
+++ /dev/null
@@ -1,67 +0,0 @@
-FROM ubuntu:24.04
-
-# Windows cross-compile using LLVM-MinGW — best-in-class Clang/LLD toolchain
-# targeting x86_64-w64-mingw32. Produces native .exe/.dll without MSVC or Wine.
-# LLVM-MinGW ships: clang, clang++, lld, libc++ / libunwind headers, winpthreads.
-
-ENV DEBIAN_FRONTEND=noninteractive
-ENV LLVM_MINGW_VERSION=20240619
-ENV LLVM_MINGW_URL=https://github.com/mstorsjo/llvm-mingw/releases/download/${LLVM_MINGW_VERSION}/llvm-mingw-${LLVM_MINGW_VERSION}-ucrt-ubuntu-20.04-x86_64.tar.xz
-
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
-        ca-certificates \
-        build-essential \
-        cmake \
-        ninja-build \
-        git \
-        python3 \
-        curl \
-        zip \
-        unzip \
-        tar \
-        xz-utils \
-        pkg-config \
-        nasm \
-        libssl-dev \
-        zlib1g-dev && \
-    rm -rf /var/lib/apt/lists/*
-
-# Install LLVM-MinGW toolchain
-RUN curl -fsSL "${LLVM_MINGW_URL}" -o /tmp/llvm-mingw.tar.xz && \
-    tar -xf /tmp/llvm-mingw.tar.xz -C /opt && \
-    mv /opt/llvm-mingw-${LLVM_MINGW_VERSION}-ucrt-ubuntu-20.04-x86_64 /opt/llvm-mingw && \
-    rm /tmp/llvm-mingw.tar.xz
-
-ENV PATH="/opt/llvm-mingw/bin:${PATH}"
-
-# Windows dependencies via vcpkg (static, x64-mingw-static triplet)
-ENV VCPKG_ROOT=/opt/vcpkg
-RUN git clone --depth 1 https://github.com/microsoft/vcpkg.git "${VCPKG_ROOT}" && \
-    "${VCPKG_ROOT}/bootstrap-vcpkg.sh" -disableMetrics
-
-ENV VCPKG_DEFAULT_TRIPLET=x64-mingw-static
-RUN "${VCPKG_ROOT}/vcpkg" install \
-        sdl2[vulkan] \
-        openssl \
-        glew \
-        glm \
-        zlib \
-        ffmpeg \
-    --triplet x64-mingw-static
-
-# Vulkan SDK headers (loader is linked statically via SDL2's vulkan surface)
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends libvulkan-dev glslang-tools && \
-    rm -rf /var/lib/apt/lists/*
-
-# Provide a no-op powershell.exe so vcpkg's MinGW applocal post-build hook
-# exits cleanly.  The x64-mingw-static triplet is fully static (no DLLs to
-# copy), so the script has nothing to do — it just needs to not fail.
-RUN printf '#!/bin/sh\nexit 0\n' > /usr/local/bin/powershell.exe && \
-    chmod +x /usr/local/bin/powershell.exe
-
-COPY build-windows.sh /build-platform.sh
-RUN chmod +x /build-platform.sh
-
-ENTRYPOINT ["/build-platform.sh"]
diff --git a/container/macos/osxcross-toolchain.cmake b/container/macos/osxcross-toolchain.cmake
deleted file mode 100644
index c432830d..00000000
--- a/container/macos/osxcross-toolchain.cmake
+++ /dev/null
@@ -1,62 +0,0 @@
-# osxcross CMake toolchain file for cross-compiling to macOS from Linux.
-# Used by vcpkg triplets and the WoWee build.
-# Auto-detects SDK, darwin version, and arch from the osxcross installation
-# and the VCPKG_OSX_ARCHITECTURES / CMAKE_OSX_ARCHITECTURES setting.
-
-set(CMAKE_SYSTEM_NAME Darwin)
-
-# ── osxcross paths ──────────────────────────────────────────────────
-set(_target_dir "/opt/osxcross/target")
-if(DEFINED ENV{OSXCROSS_TARGET_DIR})
-    set(_target_dir "$ENV{OSXCROSS_TARGET_DIR}")
-endif()
-
-# Auto-detect SDK (pick the newest if several are present)
-file(GLOB _sdk_dirs "${_target_dir}/SDK/MacOSX*.sdk")
-list(SORT _sdk_dirs)
-list(GET _sdk_dirs -1 _sdk_dir)
-set(CMAKE_OSX_SYSROOT "${_sdk_dir}" CACHE PATH "" FORCE)
-
-# Deployment target
-set(CMAKE_OSX_DEPLOYMENT_TARGET "13.0" CACHE STRING "" FORCE)
-if(DEFINED ENV{MACOSX_DEPLOYMENT_TARGET})
-    set(CMAKE_OSX_DEPLOYMENT_TARGET "$ENV{MACOSX_DEPLOYMENT_TARGET}" CACHE STRING "" FORCE)
-endif()
-
-# ── auto-detect darwin version from compiler names ──────────────────
-file(GLOB _darwin_compilers "${_target_dir}/bin/*-apple-darwin*-clang")
-list(GET _darwin_compilers 0 _first_compiler)
-get_filename_component(_compiler_name "${_first_compiler}" NAME)
-string(REGEX MATCH "apple-darwin[0-9.]+" _darwin_part "${_compiler_name}")
-
-# ── pick architecture ───────────────────────────────────────────────
-# CMAKE_OSX_ARCHITECTURES is set by vcpkg from VCPKG_OSX_ARCHITECTURES
-if(CMAKE_OSX_ARCHITECTURES STREQUAL "arm64")
-    set(_arch "arm64")
-elseif(CMAKE_OSX_ARCHITECTURES STREQUAL "x86_64")
-    set(_arch "x86_64")
-elseif(DEFINED ENV{OSXCROSS_ARCH})
-    set(_arch "$ENV{OSXCROSS_ARCH}")
-else()
-    set(_arch "arm64")
-endif()
-
-set(_host "${_arch}-${_darwin_part}")
-set(CMAKE_SYSTEM_PROCESSOR "${_arch}" CACHE STRING "" FORCE)
-
-# ── compilers ───────────────────────────────────────────────────────
-set(CMAKE_C_COMPILER   "${_target_dir}/bin/${_host}-clang"   CACHE FILEPATH "" FORCE)
-set(CMAKE_CXX_COMPILER "${_target_dir}/bin/${_host}-clang++" CACHE FILEPATH "" FORCE)
-
-# ── tools ───────────────────────────────────────────────────────────
-set(CMAKE_AR             "${_target_dir}/bin/${_host}-ar"               CACHE FILEPATH "" FORCE)
-set(CMAKE_RANLIB         "${_target_dir}/bin/${_host}-ranlib"           CACHE FILEPATH "" FORCE)
-set(CMAKE_STRIP          "${_target_dir}/bin/${_host}-strip"            CACHE FILEPATH "" FORCE)
-set(CMAKE_INSTALL_NAME_TOOL "${_target_dir}/bin/${_host}-install_name_tool" CACHE FILEPATH "" FORCE)
-
-# ── search paths ────────────────────────────────────────────────────
-set(CMAKE_FIND_ROOT_PATH "${_sdk_dir}" "${_target_dir}")
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
diff --git a/container/macos/sdk-fetcher.py b/container/macos/sdk-fetcher.py
deleted file mode 100644
index 3b556c27..00000000
--- a/container/macos/sdk-fetcher.py
+++ /dev/null
@@ -1,380 +0,0 @@
-#!/usr/bin/env python3
-"""Download and extract macOS SDK from Apple's Command Line Tools package.
-
-Apple publishes Command Line Tools (CLT) packages via their publicly
-accessible software update catalog.  This script downloads the latest CLT,
-extracts just the macOS SDK, and packages it as a .tar.gz tarball suitable
-for osxcross.
-
-No Apple ID or paid developer account required.
-
-Usage:
-    python3 sdk-fetcher.py [output_dir]
-
-The script prints the absolute path of the resulting tarball to stdout.
-All progress / status messages go to stderr.
-If a cached SDK tarball already exists in output_dir, it is reused.
-
-Dependencies: python3 (>= 3.6), cpio, tar, gzip
-Optional:     bsdtar (libarchive-tools) or xar -- faster XAR extraction.
-              Falls back to a pure-Python XAR parser when neither is available.
-"""
-
-import glob
-import gzip
-import lzma
-import os
-import plistlib
-import re
-import shutil
-import struct
-import subprocess
-import sys
-import tempfile
-import urllib.request
-import zlib
-
-try:
-    import defusedxml.ElementTree as ET
-except ImportError as exc:
-    raise ImportError(
-        "defusedxml is required: pip install defusedxml"
-    ) from exc
-
-# -- Configuration -----------------------------------------------------------
-
-CATALOG_URLS = [
-    # Try newest catalog first; first successful fetch wins.
-    "https://swscan.apple.com/content/catalogs/others/"
-    "index-16-15-14-13-12-10.16-10.15-10.14-10.13-10.12-10.11-10.10-10.9-"
-    "mountainlion-lion-snowleopard-leopard.merged-1.sucatalog.gz",
-
-    "https://swscan.apple.com/content/catalogs/others/"
-    "index-15-14-13-12-10.16-10.15-10.14-10.13-10.12-10.11-10.10-10.9-"
-    "mountainlion-lion-snowleopard-leopard.merged-1.sucatalog.gz",
-
-    "https://swscan.apple.com/content/catalogs/others/"
-    "index-14-13-12-10.16-10.15-10.14-10.13-10.12-10.11-10.10-10.9-"
-    "mountainlion-lion-snowleopard-leopard.merged-1.sucatalog.gz",
-]
-
-USER_AGENT = "Software%20Update"
-
-
-# -- Helpers -----------------------------------------------------------------
-
-def _validate_url(url):
-    """Reject non-HTTPS URLs to prevent file:// and other scheme attacks."""
-    if not url.startswith("https://"):
-        raise ValueError(f"Refusing non-HTTPS URL: {url}")
-
-
-def log(msg):
-    print(msg, file=sys.stderr, flush=True)
-
-
-# -- 1) Catalog & URL discovery ----------------------------------------------
-
-def find_sdk_pkg_url():
-    """Search Apple catalogs for the latest CLTools_macOSNMOS_SDK.pkg URL."""
-    for cat_url in CATALOG_URLS:
-        short = cat_url.split("/index-")[1][:25] + "..."
-        log(f"    Trying catalog: {short}")
-        try:
-            _validate_url(cat_url)
-            req = urllib.request.Request(cat_url, headers={"User-Agent": USER_AGENT})
-            with urllib.request.urlopen(req, timeout=60) as resp:  # nosemgrep: python.lang.security.audit.dynamic-urllib-use-detected.dynamic-urllib-use-detected
-                raw = gzip.decompress(resp.read())
-            catalog = plistlib.loads(raw)
-        except Exception as exc:
-            log(f"    -> fetch failed: {exc}")
-            continue
-
-        products = catalog.get("Products", {})
-        candidates = []
-        for pid, product in products.items():
-            post_date = str(product.get("PostDate", ""))
-            for pkg in product.get("Packages", []):
-                url = pkg.get("URL", "")
-                size = pkg.get("Size", 0)
-                if "CLTools_macOSNMOS_SDK" in url and url.endswith(".pkg"):
-                    candidates.append((post_date, url, size, pid))
-
-        if not candidates:
-            log(f"    -> no CLTools SDK packages in this catalog, trying next...")
-            continue
-
-        candidates.sort(reverse=True)
-        _date, url, size, pid = candidates[0]
-        log(f"==> Found: CLTools_macOSNMOS_SDK  (product {pid}, {size // 1048576} MB)")
-        return url
-
-    log("ERROR: No CLTools SDK packages found in any Apple catalog.")
-    sys.exit(1)
-
-
-# -- 2) Download -------------------------------------------------------------
-
-def download(url, dest):
-    """Download *url* to *dest* with a basic progress indicator."""
-    _validate_url(url)
-    req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
-    with urllib.request.urlopen(req, timeout=600) as resp:  # nosemgrep: python.lang.security.audit.dynamic-urllib-use-detected.dynamic-urllib-use-detected
-        total = int(resp.headers.get("Content-Length", 0))
-        done = 0
-        with open(dest, "wb") as f:
-            while True:
-                chunk = resp.read(1 << 20)
-                if not chunk:
-                    break
-                f.write(chunk)
-                done += len(chunk)
-                if total:
-                    pct = done * 100 // total
-                    log(f"\r    {done // 1048576} / {total // 1048576} MB  ({pct}%)")
-    log("")
-
-
-# -- 3) XAR extraction -------------------------------------------------------
-
-def extract_xar(pkg_path, dest_dir):
-    """Extract a XAR (.pkg) archive -- external tool or pure-Python fallback."""
-    for tool in ("bsdtar", "xar"):
-        if shutil.which(tool):
-            log(f"==> Extracting .pkg with {tool}...")
-            r = subprocess.run([tool, "-xf", pkg_path, "-C", dest_dir],
-                               capture_output=True)
-            if r.returncode == 0:
-                return
-            log(f"    {tool} exited {r.returncode}, trying next method...")
-
-    log("==> Extracting .pkg with built-in Python XAR parser...")
-    _extract_xar_python(pkg_path, dest_dir)
-
-
-def _extract_xar_python(pkg_path, dest_dir):
-    """Pure-Python XAR extractor (no external dependencies)."""
-    with open(pkg_path, "rb") as f:
-        raw = f.read(28)
-        if len(raw) < 28:
-            raise ValueError("File too small to be a valid XAR archive")
-        magic, hdr_size, _ver, toc_clen, _toc_ulen, _ck = struct.unpack(
-            ">4sHHQQI", raw,
-        )
-        if magic != b"xar!":
-            raise ValueError(f"Not a XAR file (magic: {magic!r})")
-
-        f.seek(hdr_size)
-        toc_xml = zlib.decompress(f.read(toc_clen))
-        heap_off = hdr_size + toc_clen
-
-        root = ET.fromstring(toc_xml)
-        toc = root.find("toc")
-        if toc is None:
-            raise ValueError("Malformed XAR: no <toc> element")
-
-        def _walk(elem, base):
-            for fe in elem.findall("file"):
-                name = fe.findtext("name", "")
-                ftype = fe.findtext("type", "file")
-                path = os.path.join(base, name)
-
-                if ftype == "directory":
-                    os.makedirs(path, exist_ok=True)
-                    _walk(fe, path)
-                    continue
-
-                de = fe.find("data")
-                if de is None:
-                    continue
-                offset = int(de.findtext("offset", "0"))
-                size = int(de.findtext("size", "0"))
-                enc_el = de.find("encoding")
-                enc = enc_el.get("style", "") if enc_el is not None else ""
-
-                os.makedirs(os.path.dirname(path), exist_ok=True)
-                f.seek(heap_off + offset)
-
-                if "gzip" in enc:
-                    with open(path, "wb") as out:
-                        out.write(zlib.decompress(f.read(size), 15 + 32))
-                elif "bzip2" in enc:
-                    import bz2
-                    with open(path, "wb") as out:
-                        out.write(bz2.decompress(f.read(size)))
-                else:
-                    with open(path, "wb") as out:
-                        rem = size
-                        while rem > 0:
-                            blk = f.read(min(rem, 1 << 20))
-                            if not blk:
-                                break
-                            out.write(blk)
-                            rem -= len(blk)
-
-        _walk(toc, dest_dir)
-
-
-# -- 4) Payload extraction (pbzx / gzip cpio) --------------------------------
-
-def _pbzx_stream(path):
-    """Yield decompressed chunks from a pbzx-compressed file."""
-    with open(path, "rb") as f:
-        if f.read(4) != b"pbzx":
-            raise ValueError("Not a pbzx file")
-        f.read(8)
-        while True:
-            hdr = f.read(16)
-            if len(hdr) < 16:
-                break
-            _usize, csize = struct.unpack(">QQ", hdr)
-            data = f.read(csize)
-            if len(data) < csize:
-                break
-            if csize == _usize:
-                yield data
-            else:
-                yield lzma.decompress(data)
-
-
-def _gzip_stream(path):
-    """Yield decompressed chunks from a gzip file."""
-    with gzip.open(path, "rb") as f:
-        while True:
-            chunk = f.read(1 << 20)
-            if not chunk:
-                break
-            yield chunk
-
-
-def _raw_stream(path):
-    """Yield raw 1 MiB chunks (last resort)."""
-    with open(path, "rb") as f:
-        while True:
-            chunk = f.read(1 << 20)
-            if not chunk:
-                break
-            yield chunk
-
-
-def extract_payload(payload_path, out_dir):
-    """Decompress a CLT Payload (pbzx or gzip cpio) into *out_dir*."""
-    with open(payload_path, "rb") as pf:
-        magic = pf.read(4)
-
-    if magic == b"pbzx":
-        log("    Payload format: pbzx (LZMA chunks)")
-        stream = _pbzx_stream(payload_path)
-    elif magic[:2] == b"\x1f\x8b":
-        log("    Payload format: gzip")
-        stream = _gzip_stream(payload_path)
-    else:
-        log(f"    Payload format: unknown (magic: {magic.hex()}), trying raw cpio...")
-        stream = _raw_stream(payload_path)
-
-    proc = subprocess.Popen(
-        ["cpio", "-id", "--quiet"],
-        stdin=subprocess.PIPE,
-        cwd=out_dir,
-        stderr=subprocess.PIPE,
-    )
-    for chunk in stream:
-        try:
-            proc.stdin.write(chunk)
-        except BrokenPipeError:
-            break
-    proc.stdin.close()
-    proc.wait()
-
-
-# -- Main --------------------------------------------------------------------
-
-def main():
-    output_dir = os.path.abspath(sys.argv[1]) if len(sys.argv) > 1 else os.getcwd()
-    os.makedirs(output_dir, exist_ok=True)
-
-    # Re-use a previously fetched SDK if present.
-    cached = glob.glob(os.path.join(output_dir, "MacOSX*.sdk.tar.*"))
-    if cached:
-        cached.sort()
-        result = os.path.realpath(cached[-1])
-        log(f"==> Using cached SDK: {os.path.basename(result)}")
-        print(result)
-        return
-
-    work = tempfile.mkdtemp(prefix="fetch-macos-sdk-")
-
-    try:
-        # 1 -- Locate SDK package URL from Apple's catalog
-        log("==> Searching Apple software-update catalogs...")
-        sdk_url = find_sdk_pkg_url()
-
-        # 2 -- Download (just the SDK component, ~55 MB)
-        pkg = os.path.join(work, "sdk.pkg")
-        log("==> Downloading CLTools SDK package...")
-        download(sdk_url, pkg)
-
-        # 3 -- Extract the flat .pkg (XAR format) to get the Payload
-        pkg_dir = os.path.join(work, "pkg")
-        os.makedirs(pkg_dir)
-        extract_xar(pkg, pkg_dir)
-        os.unlink(pkg)
-
-        # 4 -- Locate the Payload file
-        log("==> Locating SDK payload...")
-        sdk_payload = None
-        for dirpath, _dirs, files in os.walk(pkg_dir):
-            if "Payload" in files:
-                sdk_payload = os.path.join(dirpath, "Payload")
-                log(f"    Found: {os.path.relpath(sdk_payload, pkg_dir)}")
-                break
-
-        if sdk_payload is None:
-            log("ERROR: No Payload found in extracted package")
-            sys.exit(1)
-
-        # 5 -- Decompress Payload -> cpio -> filesystem
-        sdk_root = os.path.join(work, "sdk")
-        os.makedirs(sdk_root)
-        log("==> Extracting SDK from payload (this may take a minute)...")
-        extract_payload(sdk_payload, sdk_root)
-        shutil.rmtree(pkg_dir)
-
-        # 6 -- Find MacOSX*.sdk directory
-        sdk_found = None
-        for dirpath, dirs, _files in os.walk(sdk_root):
-            for d in dirs:
-                if re.match(r"MacOSX\d+(\.\d+)?\.sdk$", d):
-                    sdk_found = os.path.join(dirpath, d)
-                    break
-            if sdk_found:
-                break
-
-        if not sdk_found:
-            log("ERROR: MacOSX*.sdk directory not found.  Extracted contents:")
-            for dp, ds, fs in os.walk(sdk_root):
-                depth = dp.replace(sdk_root, "").count(os.sep)
-                if depth < 4:
-                    log(f"    {'  ' * depth}{os.path.basename(dp)}/")
-            sys.exit(1)
-
-        sdk_name = os.path.basename(sdk_found)
-        log(f"==> Found: {sdk_name}")
-
-        # 7 -- Package as .tar.gz
-        tarball = os.path.join(output_dir, f"{sdk_name}.tar.gz")
-        log(f"==> Packaging: {sdk_name}.tar.gz ...")
-        subprocess.run(
-            ["tar", "-czf", tarball, "-C", os.path.dirname(sdk_found), sdk_name],
-            check=True,
-        )
-
-        log(f"==> macOS SDK ready: {tarball}")
-        print(tarball)
-
-    finally:
-        shutil.rmtree(work, ignore_errors=True)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/container/macos/triplets/arm64-osx-cross.cmake b/container/macos/triplets/arm64-osx-cross.cmake
deleted file mode 100644
index 5f38d553..00000000
--- a/container/macos/triplets/arm64-osx-cross.cmake
+++ /dev/null
@@ -1,10 +0,0 @@
-set(VCPKG_TARGET_ARCHITECTURE arm64)
-set(VCPKG_CRT_LINKAGE dynamic)
-set(VCPKG_LIBRARY_LINKAGE static)
-set(VCPKG_CMAKE_SYSTEM_NAME Darwin)
-
-set(VCPKG_OSX_ARCHITECTURES arm64)
-set(VCPKG_OSX_DEPLOYMENT_TARGET 13.0)
-
-# osxcross toolchain
-set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE /opt/osxcross-toolchain.cmake)
diff --git a/container/macos/triplets/x64-osx-cross.cmake b/container/macos/triplets/x64-osx-cross.cmake
deleted file mode 100644
index 84161bba..00000000
--- a/container/macos/triplets/x64-osx-cross.cmake
+++ /dev/null
@@ -1,10 +0,0 @@
-set(VCPKG_TARGET_ARCHITECTURE x64)
-set(VCPKG_CRT_LINKAGE dynamic)
-set(VCPKG_LIBRARY_LINKAGE static)
-set(VCPKG_CMAKE_SYSTEM_NAME Darwin)
-
-set(VCPKG_OSX_ARCHITECTURES x86_64)
-set(VCPKG_OSX_DEPLOYMENT_TARGET 13.0)
-
-# osxcross toolchain
-set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE /opt/osxcross-toolchain.cmake)
diff --git a/container/run-linux.ps1 b/container/run-linux.ps1
deleted file mode 100644
index 67ce067f..00000000
--- a/container/run-linux.ps1
+++ /dev/null
@@ -1,64 +0,0 @@
-# run-linux.ps1 — Build WoWee for Linux (amd64) inside a Docker container.
-#
-# Usage (run from project root):
-#   .\container\run-linux.ps1 [-RebuildImage]
-#
-# Environment variables:
-#   WOWEE_FFX_SDK_REPO  — FidelityFX SDK git repo URL (passed through to container)
-#   WOWEE_FFX_SDK_REF   — FidelityFX SDK git ref / tag      (passed through to container)
-
-param(
-    [switch]$RebuildImage
-)
-
-$ErrorActionPreference = "Stop"
-
-$ScriptDir   = Split-Path -Parent $MyInvocation.MyCommand.Definition
-$ProjectRoot = (Resolve-Path "$ScriptDir\..").Path
-
-$ImageName   = "wowee-builder-linux"
-$BuildOutput = "$ProjectRoot\build\linux"
-
-# Verify Docker is available
-if (-not (Get-Command docker -ErrorAction SilentlyContinue)) {
-    Write-Error "docker is not installed or not in PATH."
-    exit 1
-}
-
-# Build the image (skip if already present and -RebuildImage not given)
-$imageExists = docker image inspect $ImageName 2>$null
-if ($RebuildImage -or -not $imageExists) {
-    Write-Host "==> Building Docker image: $ImageName"
-    docker build `
-        -f "$ScriptDir\builder-linux.Dockerfile" `
-        -t $ImageName `
-        "$ScriptDir"
-    if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-} else {
-    Write-Host "==> Using existing Docker image: $ImageName"
-}
-
-# Create output directory on the host
-New-Item -ItemType Directory -Force -Path $BuildOutput | Out-Null
-
-Write-Host "==> Starting Linux build (output: $BuildOutput)"
-
-$dockerArgs = @(
-    "run", "--rm",
-    "--mount", "type=bind,src=$ProjectRoot,dst=/src,readonly",
-    "--mount", "type=bind,src=$BuildOutput,dst=/out"
-)
-
-if ($env:WOWEE_FFX_SDK_REPO) {
-    $dockerArgs += @("--env", "WOWEE_FFX_SDK_REPO=$env:WOWEE_FFX_SDK_REPO")
-}
-if ($env:WOWEE_FFX_SDK_REF) {
-    $dockerArgs += @("--env", "WOWEE_FFX_SDK_REF=$env:WOWEE_FFX_SDK_REF")
-}
-
-$dockerArgs += $ImageName
-
-& docker @dockerArgs
-if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-
-Write-Host "==> Linux build complete. Artifacts in: $BuildOutput"
diff --git a/container/run-linux.sh b/container/run-linux.sh
deleted file mode 100755
index db45bea7..00000000
--- a/container/run-linux.sh
+++ /dev/null
@@ -1,58 +0,0 @@
-#!/usr/bin/env bash
-# run-linux.sh — Build WoWee for Linux (amd64) inside a Docker container.
-#
-# Usage (run from project root):
-#   ./container/run-linux.sh [--rebuild-image]
-#
-# Environment variables:
-#   WOWEE_FFX_SDK_REPO  — FidelityFX SDK git repo URL (passed through to container)
-#   WOWEE_FFX_SDK_REF   — FidelityFX SDK git ref / tag      (passed through to container)
-#   REBUILD_IMAGE       — Set to 1 to force a fresh docker build (same as --rebuild-image)
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
-
-IMAGE_NAME="wowee-builder-linux"
-BUILD_OUTPUT="${PROJECT_ROOT}/build/linux"
-
-# Parse arguments
-REBUILD_IMAGE="${REBUILD_IMAGE:-0}"
-for arg in "$@"; do
-  case "$arg" in
-    --rebuild-image) REBUILD_IMAGE=1 ;;
-    *) echo "Unknown argument: $arg" >&2; exit 1 ;;
-  esac
-done
-
-# Verify Docker is available
-if ! command -v docker &>/dev/null; then
-  echo "Error: docker is not installed or not in PATH." >&2
-  exit 1
-fi
-
-# Build the image (skip if already present and --rebuild-image not given)
-if [[ "$REBUILD_IMAGE" == "1" ]] || ! docker image inspect "$IMAGE_NAME" &>/dev/null; then
-  echo "==> Building Docker image: ${IMAGE_NAME}"
-  docker build \
-    -f "${SCRIPT_DIR}/builder-linux.Dockerfile" \
-    -t "$IMAGE_NAME" \
-    "${SCRIPT_DIR}"
-else
-  echo "==> Using existing Docker image: ${IMAGE_NAME}"
-fi
-
-# Create output directory on the host
-mkdir -p "$BUILD_OUTPUT"
-
-echo "==> Starting Linux build (output: ${BUILD_OUTPUT})"
-
-docker run --rm \
-  --mount "type=bind,src=${PROJECT_ROOT},dst=/src,readonly" \
-  --mount "type=bind,src=${BUILD_OUTPUT},dst=/out" \
-  ${WOWEE_FFX_SDK_REPO:+--env "WOWEE_FFX_SDK_REPO=${WOWEE_FFX_SDK_REPO}"} \
-  ${WOWEE_FFX_SDK_REF:+--env "WOWEE_FFX_SDK_REF=${WOWEE_FFX_SDK_REF}"} \
-  "$IMAGE_NAME"
-
-echo "==> Linux build complete. Artifacts in: ${BUILD_OUTPUT}"
diff --git a/container/run-macos.ps1 b/container/run-macos.ps1
deleted file mode 100644
index b690edfb..00000000
--- a/container/run-macos.ps1
+++ /dev/null
@@ -1,71 +0,0 @@
-# run-macos.ps1 — Cross-compile WoWee for macOS (arm64 or x86_64) inside a Docker container.
-#
-# Usage (run from project root):
-#   .\container\run-macos.ps1 [-RebuildImage] [-Arch arm64|x86_64]
-#
-# The macOS SDK is fetched automatically inside the Docker build from Apple's
-# public software update catalog.  No manual SDK download required.
-#
-# Environment variables:
-#   WOWEE_FFX_SDK_REPO  — FidelityFX SDK git repo URL (passed through to container)
-#   WOWEE_FFX_SDK_REF   — FidelityFX SDK git ref / tag      (passed through to container)
-
-param(
-    [switch]$RebuildImage,
-    [ValidateSet("arm64", "x86_64")]
-    [string]$Arch = "arm64"
-)
-
-$ErrorActionPreference = "Stop"
-
-$ScriptDir   = Split-Path -Parent $MyInvocation.MyCommand.Definition
-$ProjectRoot = (Resolve-Path "$ScriptDir\..").Path
-
-$ImageName   = "wowee-builder-macos"
-$BuildOutput = "$ProjectRoot\build\macos"
-
-# Verify Docker is available
-if (-not (Get-Command docker -ErrorAction SilentlyContinue)) {
-    Write-Error "docker is not installed or not in PATH."
-    exit 1
-}
-
-# Build the image (skip if already present and -RebuildImage not given)
-$imageExists = docker image inspect $ImageName 2>$null
-if ($RebuildImage -or -not $imageExists) {
-    Write-Host "==> Building Docker image: $ImageName"
-    Write-Host "    (SDK will be fetched automatically from Apple's catalog)"
-    docker build `
-        -f "$ScriptDir\builder-macos.Dockerfile" `
-        -t $ImageName `
-        "$ScriptDir"
-    if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-} else {
-    Write-Host "==> Using existing Docker image: $ImageName"
-}
-
-# Create output directory on the host
-New-Item -ItemType Directory -Force -Path $BuildOutput | Out-Null
-
-Write-Host "==> Starting macOS cross-compile build (arch=$Arch, output: $BuildOutput)"
-
-$dockerArgs = @(
-    "run", "--rm",
-    "--mount", "type=bind,src=$ProjectRoot,dst=/src,readonly",
-    "--mount", "type=bind,src=$BuildOutput,dst=/out",
-    "--env", "MACOS_ARCH=$Arch"
-)
-
-if ($env:WOWEE_FFX_SDK_REPO) {
-    $dockerArgs += @("--env", "WOWEE_FFX_SDK_REPO=$env:WOWEE_FFX_SDK_REPO")
-}
-if ($env:WOWEE_FFX_SDK_REF) {
-    $dockerArgs += @("--env", "WOWEE_FFX_SDK_REF=$env:WOWEE_FFX_SDK_REF")
-}
-
-$dockerArgs += $ImageName
-
-& docker @dockerArgs
-if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-
-Write-Host "==> macOS cross-compile build complete. Artifacts in: $BuildOutput"
diff --git a/container/run-macos.sh b/container/run-macos.sh
deleted file mode 100755
index 63e1b971..00000000
--- a/container/run-macos.sh
+++ /dev/null
@@ -1,74 +0,0 @@
-#!/usr/bin/env bash
-# run-macos.sh — Cross-compile WoWee for macOS (arm64 or x86_64) inside a Docker container.
-#
-# Usage (run from project root):
-#   ./container/run-macos.sh [--rebuild-image]
-#
-# The macOS SDK is fetched automatically inside the Docker build from Apple's
-# public software update catalog.  No manual SDK download required.
-#
-# Environment variables:
-#   MACOS_ARCH          — Target arch: arm64 (default) or x86_64
-#   WOWEE_FFX_SDK_REPO  — FidelityFX SDK git repo URL (passed through to container)
-#   WOWEE_FFX_SDK_REF   — FidelityFX SDK git ref / tag      (passed through to container)
-#   REBUILD_IMAGE       — Set to 1 to force a fresh docker build (same as --rebuild-image)
-#
-# Toolchain: osxcross (Clang + Apple ld)
-# vcpkg triplets: arm64-osx-cross (arm64) / x64-osx-cross (x86_64)
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
-
-IMAGE_NAME="wowee-builder-macos"
-MACOS_ARCH="${MACOS_ARCH:-arm64}"
-BUILD_OUTPUT="${PROJECT_ROOT}/build/macos"
-
-# Parse arguments
-REBUILD_IMAGE="${REBUILD_IMAGE:-0}"
-for arg in "$@"; do
-  case "$arg" in
-    --rebuild-image) REBUILD_IMAGE=1 ;;
-    *) echo "Unknown argument: $arg" >&2; exit 1 ;;
-  esac
-done
-
-# Validate arch
-if [[ "$MACOS_ARCH" != "arm64" && "$MACOS_ARCH" != "x86_64" ]]; then
-  echo "Error: MACOS_ARCH must be 'arm64' or 'x86_64' (got: ${MACOS_ARCH})" >&2
-  exit 1
-fi
-
-# Verify Docker is available
-if ! command -v docker &>/dev/null; then
-  echo "Error: docker is not installed or not in PATH." >&2
-  exit 1
-fi
-
-# Build the image (skip if already present and --rebuild-image not given)
-if [[ "$REBUILD_IMAGE" == "1" ]] || ! docker image inspect "$IMAGE_NAME" &>/dev/null; then
-  echo "==> Building Docker image: ${IMAGE_NAME}"
-  echo "    (SDK will be fetched automatically from Apple's catalog)"
-  docker build \
-    -f "${SCRIPT_DIR}/builder-macos.Dockerfile" \
-    -t "$IMAGE_NAME" \
-    "${SCRIPT_DIR}"
-else
-  echo "==> Using existing Docker image: ${IMAGE_NAME}"
-fi
-
-# Create output directory on the host
-mkdir -p "$BUILD_OUTPUT"
-
-echo "==> Starting macOS cross-compile build (arch=${MACOS_ARCH}, output: ${BUILD_OUTPUT})"
-
-docker run --rm \
-  --mount "type=bind,src=${PROJECT_ROOT},dst=/src,readonly" \
-  --mount "type=bind,src=${BUILD_OUTPUT},dst=/out" \
-  --env "MACOS_ARCH=${MACOS_ARCH}" \
-  ${WOWEE_FFX_SDK_REPO:+--env "WOWEE_FFX_SDK_REPO=${WOWEE_FFX_SDK_REPO}"} \
-  ${WOWEE_FFX_SDK_REF:+--env "WOWEE_FFX_SDK_REF=${WOWEE_FFX_SDK_REF}"} \
-  "$IMAGE_NAME"
-
-echo "==> macOS cross-compile build complete. Artifacts in: ${BUILD_OUTPUT}"
diff --git a/container/run-windows.ps1 b/container/run-windows.ps1
deleted file mode 100644
index 1ce6c724..00000000
--- a/container/run-windows.ps1
+++ /dev/null
@@ -1,64 +0,0 @@
-# run-windows.ps1 — Cross-compile WoWee for Windows (x86_64) inside a Docker container.
-#
-# Usage (run from project root):
-#   .\container\run-windows.ps1 [-RebuildImage]
-#
-# Environment variables:
-#   WOWEE_FFX_SDK_REPO  — FidelityFX SDK git repo URL (passed through to container)
-#   WOWEE_FFX_SDK_REF   — FidelityFX SDK git ref / tag      (passed through to container)
-
-param(
-    [switch]$RebuildImage
-)
-
-$ErrorActionPreference = "Stop"
-
-$ScriptDir   = Split-Path -Parent $MyInvocation.MyCommand.Definition
-$ProjectRoot = (Resolve-Path "$ScriptDir\..").Path
-
-$ImageName   = "wowee-builder-windows"
-$BuildOutput = "$ProjectRoot\build\windows"
-
-# Verify Docker is available
-if (-not (Get-Command docker -ErrorAction SilentlyContinue)) {
-    Write-Error "docker is not installed or not in PATH."
-    exit 1
-}
-
-# Build the image (skip if already present and -RebuildImage not given)
-$imageExists = docker image inspect $ImageName 2>$null
-if ($RebuildImage -or -not $imageExists) {
-    Write-Host "==> Building Docker image: $ImageName"
-    docker build `
-        -f "$ScriptDir\builder-windows.Dockerfile" `
-        -t $ImageName `
-        "$ScriptDir"
-    if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-} else {
-    Write-Host "==> Using existing Docker image: $ImageName"
-}
-
-# Create output directory on the host
-New-Item -ItemType Directory -Force -Path $BuildOutput | Out-Null
-
-Write-Host "==> Starting Windows cross-compile build (output: $BuildOutput)"
-
-$dockerArgs = @(
-    "run", "--rm",
-    "--mount", "type=bind,src=$ProjectRoot,dst=/src,readonly",
-    "--mount", "type=bind,src=$BuildOutput,dst=/out"
-)
-
-if ($env:WOWEE_FFX_SDK_REPO) {
-    $dockerArgs += @("--env", "WOWEE_FFX_SDK_REPO=$env:WOWEE_FFX_SDK_REPO")
-}
-if ($env:WOWEE_FFX_SDK_REF) {
-    $dockerArgs += @("--env", "WOWEE_FFX_SDK_REF=$env:WOWEE_FFX_SDK_REF")
-}
-
-$dockerArgs += $ImageName
-
-& docker @dockerArgs
-if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-
-Write-Host "==> Windows cross-compile build complete. Artifacts in: $BuildOutput"
diff --git a/container/run-windows.sh b/container/run-windows.sh
deleted file mode 100755
index b7a89ff7..00000000
--- a/container/run-windows.sh
+++ /dev/null
@@ -1,61 +0,0 @@
-#!/usr/bin/env bash
-# run-windows.sh — Cross-compile WoWee for Windows (x86_64) inside a Docker container.
-#
-# Usage (run from project root):
-#   ./container/run-windows.sh [--rebuild-image]
-#
-# Environment variables:
-#   WOWEE_FFX_SDK_REPO  — FidelityFX SDK git repo URL (passed through to container)
-#   WOWEE_FFX_SDK_REF   — FidelityFX SDK git ref / tag      (passed through to container)
-#   REBUILD_IMAGE       — Set to 1 to force a fresh docker build (same as --rebuild-image)
-#
-# Toolchain: LLVM-MinGW (Clang + LLD) targeting x86_64-w64-mingw32-ucrt
-# vcpkg triplet: x64-mingw-static
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
-
-IMAGE_NAME="wowee-builder-windows"
-BUILD_OUTPUT="${PROJECT_ROOT}/build/windows"
-
-# Parse arguments
-REBUILD_IMAGE="${REBUILD_IMAGE:-0}"
-for arg in "$@"; do
-  case "$arg" in
-    --rebuild-image) REBUILD_IMAGE=1 ;;
-    *) echo "Unknown argument: $arg" >&2; exit 1 ;;
-  esac
-done
-
-# Verify Docker is available
-if ! command -v docker &>/dev/null; then
-  echo "Error: docker is not installed or not in PATH." >&2
-  exit 1
-fi
-
-# Build the image (skip if already present and --rebuild-image not given)
-if [[ "$REBUILD_IMAGE" == "1" ]] || ! docker image inspect "$IMAGE_NAME" &>/dev/null; then
-  echo "==> Building Docker image: ${IMAGE_NAME}"
-  docker build \
-    -f "${SCRIPT_DIR}/builder-windows.Dockerfile" \
-    -t "$IMAGE_NAME" \
-    "${SCRIPT_DIR}"
-else
-  echo "==> Using existing Docker image: ${IMAGE_NAME}"
-fi
-
-# Create output directory on the host
-mkdir -p "$BUILD_OUTPUT"
-
-echo "==> Starting Windows cross-compile build (output: ${BUILD_OUTPUT})"
-
-docker run --rm \
-  --mount "type=bind,src=${PROJECT_ROOT},dst=/src,readonly" \
-  --mount "type=bind,src=${BUILD_OUTPUT},dst=/out" \
-  ${WOWEE_FFX_SDK_REPO:+--env "WOWEE_FFX_SDK_REPO=${WOWEE_FFX_SDK_REPO}"} \
-  ${WOWEE_FFX_SDK_REF:+--env "WOWEE_FFX_SDK_REF=${WOWEE_FFX_SDK_REF}"} \
-  "$IMAGE_NAME"
-
-echo "==> Windows cross-compile build complete. Artifacts in: ${BUILD_OUTPUT}"
diff --git a/docs/ANIMATION_SYSTEM.md b/docs/ANIMATION_SYSTEM.md
deleted file mode 100644
index 6dca06d7..00000000
--- a/docs/ANIMATION_SYSTEM.md
+++ /dev/null
@@ -1,110 +0,0 @@
-# Animation System
-
-Unified, FSM-based animation system for all characters (players, NPCs, companions).
-Every character uses the same `CharacterAnimator` — there is no separate NPC/Mob animator.
-
-## Architecture
-
-```
-AnimationController          (thin adapter — bridges Renderer ↔ CharacterAnimator)
-  └─ CharacterAnimator       (FSM composer — implements ICharacterAnimator)
-       ├─ CombatFSM          (stun, hit reaction, spell cast, melee, ranged, charge)
-       ├─ ActivityFSM         (emote, loot, sit/stand/kneel/sleep)
-       ├─ LocomotionFSM       (idle, walk, run, sprint, jump, swim, strafe)
-       └─ MountFSM            (mount idle, mount run, flight)
-
-AnimationManager             (registry of CharacterAnimator instances by ID)
-AnimCapabilitySet            (probed once per model — cached resolved anim IDs)
-AnimCapabilityProbe          (queries which animations a model supports)
-```
-
-### Priority Resolution
-
-`CharacterAnimator::resolveAnimation()` runs every frame. The first FSM to
-return a valid `AnimOutput` wins:
-
-1. **Mount** — if mounted, return `MOUNT` (overrides everything)
-2. **Combat** — stun > hit reaction > spell > charge > melee/ranged > combat idle
-3. **Activity** — emote > loot > sit/stand transitions
-4. **Locomotion** — run/walk/sprint/jump/swim/strafe/idle
-
-If no FSM produces a valid output, the last animation continues (STAY policy).
-
-### Overlay Layer
-
-After resolution, `applyOverlays()` substitutes stealth animation variants
-(stealth idle, stealth walk, stealth run) without changing sub-FSM state.
-
-## File Map
-
-### Headers (`include/rendering/animation/`)
-
-| File | Purpose |
-|---|---|
-| `i_animator.hpp` | Base interface: `onEvent()`, `update()` |
-| `i_character_animator.hpp` | 20 virtual methods (combat, spells, emotes, mounts, etc.) |
-| `character_animator.hpp` | FSM composer — the single animator class |
-| `locomotion_fsm.hpp` | Movement states: idle, walk, run, sprint, jump, swim |
-| `combat_fsm.hpp` | Combat states: melee, ranged, spell cast, stun, hit reaction |
-| `activity_fsm.hpp` | Activity states: emote, loot, sit/stand/kneel |
-| `mount_fsm.hpp` | Mount states: idle, run, flight, taxi |
-| `anim_capability_set.hpp` | Probed capability flags + resolved animation IDs |
-| `anim_capability_probe.hpp` | Probes a model for available animations |
-| `anim_event.hpp` | `AnimEvent` enum (MOVE_START, MOVE_STOP, JUMP, etc.) |
-| `animation_manager.hpp` | Central registry of CharacterAnimator instances |
-| `weapon_type.hpp` | WeaponLoadout, RangedWeaponType enums |
-| `emote_registry.hpp` | Emote name → animation ID lookup |
-| `footstep_driver.hpp` | Footstep sound event driver |
-| `sfx_state_driver.hpp` | State-transition SFX (jump, land, swim enter/exit) |
-| `i_anim_renderer.hpp` | Interface for renderer animation queries |
-
-### Sources (`src/rendering/animation/`)
-
-| File | Purpose |
-|---|---|
-| `character_animator.cpp` | ICharacterAnimator implementation + priority resolver |
-| `locomotion_fsm.cpp` | Locomotion state transitions + resolve logic |
-| `combat_fsm.cpp` | Combat state transitions + resolve logic |
-| `activity_fsm.cpp` | Activity state transitions + resolve logic |
-| `mount_fsm.cpp` | Mount state transitions + resolve logic |
-| `anim_capability_probe.cpp` | Model animation probing |
-| `animation_manager.cpp` | Registry CRUD + bulk update |
-| `emote_registry.cpp` | Emote database |
-| `footstep_driver.cpp` | Footstep timing logic |
-| `sfx_state_driver.cpp` | SFX transition detection |
-
-### Controller (`include/rendering/animation_controller.hpp` + `src/rendering/animation_controller.cpp`)
-
-Thin adapter that:
-- Collects per-frame input from camera/renderer → `CharacterAnimator::FrameInput`
-- Forwards state changes (combat, emote, spell, mount, etc.) → `CharacterAnimator`
-- Reads `AnimOutput` → applies via `CharacterRenderer`
-- Owns footstep and SFX drivers
-
-## Key Types
-
-- **`AnimEvent`** — discrete events: `MOVE_START`, `MOVE_STOP`, `JUMP`, `LAND`, `MOUNT`, `DISMOUNT`, etc.
-- **`AnimOutput`** — result of FSM resolution: `{animId, loop, valid}`. `valid=false` means STAY.
-- **`AnimCapabilitySet`** — probed once per model load. Caches resolved IDs and capability flags.
-- **`CharacterAnimator::FrameInput`** — per-frame input struct (movement flags, timers, animation state queries).
-
-## Adding a New Animation State
-
-1. Decide which FSM owns the state (combat, activity, locomotion, or mount).
-2. Add the state enum to the FSM's `State` enum.
-3. Add transitions in the FSM's `resolve()` method.
-4. Add resolved ID fields to `AnimCapabilitySet` if the animation needs model probing.
-5. If the state needs external triggering, add a method to `ICharacterAnimator` and implement in `CharacterAnimator`.
-
-## Tests
-
-Each FSM has its own test file in `tests/`:
-- `test_locomotion_fsm.cpp`
-- `test_combat_fsm.cpp`
-- `test_activity_fsm.cpp`
-- `test_anim_capability.cpp`
-
-Run all tests:
-```bash
-cd build && ctest --output-on-failure
-```
diff --git a/docs/WARDEN_IMPLEMENTATION.md b/docs/WARDEN_IMPLEMENTATION.md
index ff4f4a2e..d328c476 100644
--- a/docs/WARDEN_IMPLEMENTATION.md
+++ b/docs/WARDEN_IMPLEMENTATION.md
@@ -93,16 +93,13 @@ The RSA public modulus is extracted from WoW.exe (`.rdata` section at offset 0x0
 ## Key Files
 
 ```
-include/game/warden_handler.hpp      - Packet handler interface
-src/game/warden_handler.cpp          - handleWardenData + module manager init
 include/game/warden_module.hpp       - Module loader interface
 src/game/warden_module.cpp           - 8-step pipeline
 include/game/warden_emulator.hpp     - Emulator interface
 src/game/warden_emulator.cpp         - Unicorn Engine executor + API hooks
 include/game/warden_crypto.hpp       - Crypto interface
 src/game/warden_crypto.cpp           - RC4 / key derivation
-include/game/warden_memory.hpp       - PE image + memory patch interface
-src/game/warden_memory.cpp           - PE loader, runtime globals patching
+src/game/game_handler.cpp            - Packet handler (handleWardenData)
 ```
 
 ---
diff --git a/docs/WARDEN_QUICK_REFERENCE.md b/docs/WARDEN_QUICK_REFERENCE.md
index faba1e71..17c127d3 100644
--- a/docs/WARDEN_QUICK_REFERENCE.md
+++ b/docs/WARDEN_QUICK_REFERENCE.md
@@ -58,11 +58,10 @@ strict Warden enforcement in that mode.
 ## Key Files
 
 ```
-include/game/warden_handler.hpp + src/game/warden_handler.cpp   - Packet handler
-include/game/warden_module.hpp  + src/game/warden_module.cpp    - Module loader (8-step pipeline)
-include/game/warden_emulator.hpp + src/game/warden_emulator.cpp - Unicorn Engine executor
-include/game/warden_crypto.hpp  + src/game/warden_crypto.cpp    - RC4/MD5/SHA1/RSA crypto
-include/game/warden_memory.hpp  + src/game/warden_memory.cpp    - PE image + memory patching
+src/game/warden_module.hpp/cpp     - Module loader (8-step pipeline)
+src/game/warden_emulator.hpp/cpp   - Unicorn Engine executor
+src/game/warden_crypto.hpp/cpp     - RC4/MD5/SHA1/RSA crypto
+src/game/game_handler.cpp          - Packet handler (handleWardenData)
 ```
 
 ---
diff --git a/docs/architecture.md b/docs/architecture.md
index b7da1c6e..65394b57 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -8,7 +8,7 @@ Wowee follows a modular architecture with clear separation of concerns:
 ┌─────────────────────────────────────────────┐
 │           Application (main loop)            │
 │  - State management (auth/realms/game)      │
-│  - Update cycle                             │
+│  - Update cycle (60 FPS)                    │
 │  - Event dispatch                           │
 └──────────────┬──────────────────────────────┘
                │
@@ -16,8 +16,8 @@ Wowee follows a modular architecture with clear separation of concerns:
        │                │
 ┌──────▼──────┐  ┌─────▼──────┐
 │   Window    │  │   Input    │
-│  (SDL2 +    │  │ (Keyboard/ │
-│   Vulkan)   │  │   Mouse)   │
+│  (SDL2)     │  │ (Keyboard/ │
+│             │  │   Mouse)   │
 └──────┬──────┘  └─────┬──────┘
        │                │
        └───────┬────────┘
@@ -26,294 +26,517 @@ Wowee follows a modular architecture with clear separation of concerns:
     │                     │
 ┌───▼────────┐   ┌───────▼──────┐
 │  Renderer  │   │  UI Manager  │
-│  (Vulkan)  │   │   (ImGui)    │
+│ (OpenGL)   │   │   (ImGui)    │
 └───┬────────┘   └──────────────┘
     │
-    ├─ Camera + CameraController
-    ├─ TerrainRenderer (ADT streaming)
-    ├─ WMORenderer (buildings, collision)
-    ├─ M2Renderer (models, particles, ribbons)
-    ├─ CharacterRenderer (skeletal animation)
-    ├─ WaterRenderer (refraction, lava, slime)
-    ├─ SkyBox + StarField + Weather
-    ├─ LightingManager (Light.dbc volumes)
-    └─ SwimEffects, ChargeEffect, Lightning
+    ├─ Camera
+    ├─ Scene Graph
+    ├─ Shaders
+    ├─ Meshes
+    └─ Textures
 ```
 
 ## Core Systems
 
 ### 1. Application Layer (`src/core/`)
 
-**Application** (`application.hpp/cpp`) - Main controller
-- Owns all subsystems (renderer, game handler, asset manager, UI)
-- Manages application state (AUTH → REALM_SELECT → CHAR_SELECT → IN_WORLD)
+**Application** - Main controller
+- Owns all subsystems
+- Manages application state
 - Runs update/render loop
-- Populates `GameServices` struct and passes to `GameHandler` at construction
+- Handles lifecycle (init/shutdown)
 
-**Window** (`window.hpp/cpp`) - SDL2 + Vulkan wrapper
-- Creates SDL2 window with Vulkan surface
-- Owns `VkContext` (Vulkan device, swapchain, render passes)
+**Window** - SDL2 wrapper
+- Creates window and OpenGL context
 - Handles resize events
+- Manages VSync and fullscreen
 
-**Input** (`input.hpp/cpp`) - Input management
-- Keyboard state tracking (SDL scancodes)
-- Mouse position, buttons (1-based SDL indices), wheel delta
-- Per-frame delta calculation
+**Input** - Input management
+- Keyboard state tracking
+- Mouse position and buttons
+- Mouse locking for camera control
 
-**Logger** (`logger.hpp/cpp`) - Thread-safe logging
+**Logger** - Logging system
+- Thread-safe logging
 - Multiple log levels (DEBUG, INFO, WARNING, ERROR, FATAL)
-- File output to `logs/wowee.log`
-- Configurable via `WOWEE_LOG_LEVEL` env var
+- Timestamp formatting
 
 ### 2. Rendering System (`src/rendering/`)
 
-**Renderer** (`renderer.hpp/cpp`) - Main rendering coordinator
-- Manages Vulkan pipeline state
-- Coordinates frame rendering across all sub-renderers
-- Owns camera, sky, weather, lighting, and all sub-renderers
-- Shadow mapping with PCF filtering
+**Renderer** - Main rendering coordinator
+- Manages OpenGL state
+- Coordinates frame rendering
+- Owns camera and scene
 
-**VkContext** (`vk_context.hpp/cpp`) - Vulkan infrastructure
-- Device selection, queue families, swapchain
-- Render passes, framebuffers, command pools
-- Sampler cache (FNV-1a hashed dedup)
-- Pipeline cache persistence for fast startup
-
-**Camera** (`camera.hpp/cpp`) - View/projection matrices
+**Camera** - View/projection matrices
 - Position and orientation
-- FOV, aspect ratio, near/far planes
-- Sub-pixel jitter for TAA/FSR2 (column 2 NDC offset)
-- Frustum extraction for culling
+- FOV and aspect ratio
+- View frustum (for culling)
 
-**TerrainRenderer** - ADT terrain streaming
-- Async chunk loading within configurable radius
-- 4-layer texture splatting with alpha blending
-- Frustum + distance culling
-- Vegetation/foliage placement via deterministic RNG
+**Scene** - Scene graph
+- Mesh collection
+- Spatial organization
+- Visibility determination
 
-**WMORenderer** - World Map Objects (buildings)
-- Multi-material batch rendering
-- Portal-based visibility culling
-- Floor/wall collision (normal-based classification)
-- Interior glass transparency, doodad placement
+**Shader** - GLSL program wrapper
+- Loads vertex/fragment shaders
+- Uniform management
+- Compilation and linking
 
-**M2Renderer** - Models (creatures, doodads, spell effects)
-- Skeletal animation with GPU bone transforms
-- Particle emitters (WotLK FBlock format)
-- Ribbon emitters (charge trails, enchant glows)
-- Portal spin effects, foliage wind displacement
-- Per-instance animation state
+**Mesh** - Geometry container
+- Vertex buffer (position, normal, texcoord)
+- Index buffer
+- VAO/VBO/EBO management
 
-**CharacterRenderer** - Player/NPC character models
-- GPU vertex skinning (256 bones)
-- Race/gender-aware textures via CharSections.dbc
-- Equipment rendering (geoset visibility per slot)
-- Fallback textures (white/transparent/flat-normal) for missing assets
+**Texture** - Texture management
+- Loading (BLP via `AssetManager`, optional PNG overrides for development)
+- OpenGL texture object
+- Mipmap generation
 
-**WaterRenderer** - Terrain and WMO water
-- Refraction/reflection rendering
-- Magma/slime with multi-octave FBM noise flow
-- Beer-Lambert absorption
-
-**Skybox + StarField + Weather**
-- Procedural sky dome with time-of-day lighting
-- Star field with day/night fade (dusk 18:00–20:00, dawn 04:00–06:00)
-- Rain/snow particle systems per zone (via zone weather table)
-
-**LightingManager** - Light.dbc volume sampling
-- Time-of-day color bands (half-minutes, 0–2879)
-- Distance-weighted light volume blending
-- Fog color/distance parameters
+**Material** - Surface properties
+- Shader assignment
+- Texture binding
+- Color/properties
 
 ### 3. Networking (`src/network/`)
 
-**TCPSocket** (`tcp_socket.hpp/cpp`) - Platform TCP
-- Non-blocking I/O with per-frame recv budgets
-- 4 KB recv buffer per call
-- Portable across Linux/macOS/Windows
+**Socket** (Abstract base class)
+- Connection interface
+- Packet send/receive
+- Callback system
 
-**WorldSocket** (`world_socket.hpp/cpp`) - WoW world connection
-- RC4 header encryption (derived from SRP session key)
-- Packet parsing with configurable per-frame budgets
-- Compressed move packet handling
+**TCPSocket** - Linux TCP sockets
+- Non-blocking I/O
+- Raw TCP (replaces WebSocket)
+- Packet framing
 
-**Packet** (`packet.hpp/cpp`) - Binary data container
-- Read/write primitives (uint8–uint64, float, string, packed GUID)
-- Bounds-checked reads (return 0 past end)
+**Packet** - Binary data container
+- Read/write primitives
+- Byte order handling
+- Opcode management
 
 ### 4. Authentication (`src/auth/`)
 
-**AuthHandler** - Auth server protocol (port 3724)
-- SRP6a challenge/proof flow
-- Security flags: PIN (0x01), Matrix (0x02), Authenticator (0x04)
-- Realm list retrieval
+**AuthHandler** - Auth server protocol
+- Connects to port 3724
+- SRP authentication flow
+- Session key generation
 
-**SRP** (`srp.hpp/cpp`) - Secure Remote Password
-- SRP6a with 19-byte (152-bit) ephemeral
-- OpenSSL BIGNUM math
-- Session key generation (40 bytes)
+**SRP** - Secure Remote Password
+- SRP6a algorithm
+- Big integer math
+- Salt and verifier generation
 
-**Integrity** - Client integrity verification
-- Checksum computation for Warden compatibility
+**Crypto** - Cryptographic functions
+- SHA1 hashing (OpenSSL)
+- Random number generation
+- Encryption helpers
 
 ### 5. Game Logic (`src/game/`)
 
-**GameHandler** (`game_handler.hpp/cpp`) - Central game state
-- Dispatch table routing 664+ opcodes to domain handlers
-- Owns all domain handlers via composition
-- Receives dependencies via `GameServices` struct (no singleton access)
+**GameHandler** - World server protocol
+- Connects to port 8085 (configurable)
+- Packet handlers for 100+ opcodes
+- Session management with RC4 encryption
+- Character enumeration and login flow
 
-**Domain Handlers** (SOLID decomposition from GameHandler):
-- `EntityController` - UPDATE_OBJECT parsing, entity spawn/despawn
-- `MovementHandler` - Movement packets, speed, taxi, swimming, flying
-- `CombatHandler` - Damage, healing, death, auto-attack, threat
-- `SpellHandler` - Spell casting, cooldowns, auras, talents, pet spells
-- `InventoryHandler` - Equipment, bags, bank, mail, auction, vendors
-- `QuestHandler` - Quest accept/complete, objectives, progress tracking
-- `SocialHandler` - Party, guild, LFG, friends, who, duel, trade
-- `ChatHandler` - Chat messages, channels, emotes, system messages
-- `WardenHandler` - Anti-cheat module management
+**World** - Game world state
+- Map loading with async terrain streaming
+- Entity management (players, NPCs, creatures)
+- Zone management and exploration
+- Time-of-day synchronization
 
-**OpcodeTable** - Expansion-agnostic opcode mapping
-- `LogicalOpcode` enum → wire opcode via JSON config per expansion
-- Runtime remapping for Classic/TBC/WotLK/Turtle protocol differences
+**Player** - Player character
+- Position and movement (WASD + spline movement)
+- Stats tracking (health, mana, XP, level)
+- Equipment and inventory (23 + 16 slots)
+- Action queue and spell casting
+- Death and resurrection handling
 
-**Entity / EntityManager** - Entity lifecycle
-- Shared entity base class with update fields (uint32 array)
-- Player, Unit, GameObject subtypes
-- GUID-based lookup, field extraction (health, level, display ID, etc.)
+**Character** - Character data
+- Race, class, gender, appearance
+- Creation and customization
+- 3D model preview
+- Online character lifecycle and state synchronization
 
-**TransportManager** - Transport path evaluation
-- Catmull-Rom spline interpolation from TransportAnimation.dbc
-- Clock-based motion with server time synchronization
-- Time-closed looping paths (wrap point duplicated, no index wrapping)
+**Entity** - Game entities
+- NPCs and creatures with display info
+- Animation state (idle, combat, walk, run)
+- GUID management (player, creature, item, gameobject)
+- Targeting and selection
 
-**Expansion Helpers** (`game_utils.hpp`):
-- `isActiveExpansion("classic")` / `isActiveExpansion("tbc")` / `isActiveExpansion("wotlk")`
-- `isClassicLikeExpansion()` (Classic or Turtle WoW)
-- `isPreWotlk()` (Classic, Turtle, or TBC)
+**Inventory** - Item management
+- Equipment slots (head, shoulders, chest, etc.)
+- Backpack storage (16 slots)
+- Item metadata (icons, stats, durability)
+- Drag-drop system
+- Auto-equip and unequip
+
+**NPC Interactions** - handled through `GameHandler`
+- Gossip system
+- Quest givers with markers (! and ?)
+- Vendors (buy/sell)
+- Trainers (placeholder)
+- Combat animations
+
+**ZoneManager** - Zone and area tracking
+- Map exploration
+- Area discovery
+- Zone change detection
+
+**Opcodes** - Protocol definitions
+- 100+ Client→Server opcodes (CMSG_*)
+- 100+ Server→Client opcodes (SMSG_*)
+- WoW 3.3.5a (build 12340) specific
 
 ### 6. Asset Pipeline (`src/pipeline/`)
 
 **AssetManager** - Runtime asset access
-- Extracted loose-file tree indexed by `Data/manifest.json`
+- Loads an extracted loose-file tree indexed by `Data/manifest.json`
 - Layered resolution via optional overlay manifests (multi-expansion dedup)
-- File cache with configurable budget (256 MB min, 12 GB max)
-- PNG override support (checks for .png before .blp)
+- File cache + path normalization
 
 **asset_extract (tool)** - MPQ extraction
 - Uses StormLib to extract MPQs into `Data/` and generate `manifest.json`
-- Driven by `extract_assets.sh` / `extract_assets.ps1`
+- Driven by `extract_assets.sh`
 
-**BLPLoader** - Texture decompression
-- DXT1/3/5 block compression (RGB565 color endpoints)
-- Palette mode with 1/4/8-bit alpha
-- Mipmap extraction
+**BLPLoader** - Texture parser
+- BLP format (Blizzard texture format)
+- DXT1/3/5 compression support
+- Mipmap extraction and generation
+- OpenGL texture object creation
 
-**M2Loader** - Model binary parsing
-- Version-aware header (Classic v256 vs WotLK v264)
-- Skeletal animation tracks (embedded vs external .anim files, flag 0x20)
-- Compressed quaternions (int16 offset mapping)
-- Particle emitters, ribbon emitters, attachment points
-- Geoset support (group × 100 + variant encoding)
+**M2Loader** - Model parser
+- Character/creature models with materials
+- Skeletal animation data (256 bones max)
+- Bone hierarchies and transforms
+- Animation sequences (idle, walk, run, attack, etc.)
+- Particle emitters (WotLK FBlock format)
+- Attachment points (weapons, mounts, etc.)
+- Geoset support (hide/show body parts)
+- Multiple texture units and render batches
 
-**WMOLoader** - World object parsing
-- Multi-group rendering with portal visibility
-- Doodad placement (24-bit name index + 8-bit flags packing)
-- Liquid data, collision geometry
+**WMOLoader** - World object parser
+- Buildings and structures
+- Multi-material batches
+- Portal system (visibility culling)
+- Doodad placement (decorations)
+- Group-based rendering
+- Liquid data (indoor water)
 
-**ADTLoader** - Terrain parsing
-- 64×64 tiles per map, 16×16 chunks per tile (MCNK)
-- MCVT height grid (145 vertices: 9 outer + 8 inner per row × 9 rows)
-- Texture layers (up to 4 with alpha blending, RLE-compressed alpha maps)
+**ADTLoader** - Terrain parser
+- 64x64 tiles per map (map_XX_YY.adt)
+- 16x16 chunks per tile (MCNK)
+- Height map data (9x9 outer + 8x8 inner vertices)
+- Texture layers (up to 4 per chunk with alpha blending)
+- Liquid data (water/lava/slime with height and flags)
+- Object placement (M2 and WMO references)
+- Terrain holes
 - Async loading to prevent frame stalls
 
-**DBCLoader** - Database table parsing
-- Binary DBC format (fixed 4-byte uint32 fields + string block)
-- CSV fallback for pre-extracted data
-- Expansion-aware field layout via `dbc_layouts.json`
-- 20+ DBC files: Spell, Item, Creature, Faction, Map, AreaTable, etc.
+**DBCLoader** - Database parser
+- 20+ DBC files loaded (Spell, Item, Creature, SkillLine, Faction, etc.)
+- Type-safe record access
+- String block parsing
+- Memory-efficient caching
+- Used for:
+  - Spell icons and tooltips (Spell.dbc, SpellIcon.dbc)
+  - Item data (Item.dbc, ItemDisplayInfo.dbc)
+  - Creature display info (CreatureDisplayInfo.dbc, CreatureModelData.dbc)
+  - Class and race info (ChrClasses.dbc, ChrRaces.dbc)
+  - Skill lines (SkillLine.dbc, SkillLineAbility.dbc)
+  - Faction and reputation (Faction.dbc)
+  - Map and area names (Map.dbc, AreaTable.dbc)
 
 ### 7. UI System (`src/ui/`)
 
 **UIManager** - ImGui coordinator
-- ImGui initialization with SDL2/Vulkan backend
-- Screen state management and transitions
+- ImGui initialization with SDL2/OpenGL backend
 - Event handling and input routing
+- Render dispatch with opacity control
+- Screen state management
 
-**Screens:**
-- `AuthScreen` - Login with username/password, server address, security code
-- `RealmScreen` - Realm list with population and type indicators
-- `CharacterScreen` - Character selection with 3D animated preview
-- `CharacterCreateScreen` - Race/class/gender/appearance customization
-- `GameScreen` - Main HUD: chat, action bar, target frame, minimap, nameplates, combat text, tooltips
-- `InventoryScreen` - Equipment paper doll, backpack, bag windows, item tooltips with stats
-- `SpellbookScreen` - Tabbed spell list with icons, drag-drop to action bar
-- `QuestLogScreen` - Quest list with objectives, details, and rewards
-- `TalentScreen` - Talent tree UI with point allocation
-- `SettingsScreen` - Graphics presets (LOW/MEDIUM/HIGH/ULTRA), audio, keybindings
+**AuthScreen** - Login interface
+- Username/password input fields
+- Server address configuration
+- Connection status and error messages
 
-### 8. Audio System (`src/audio/`)
+**RealmScreen** - Server selection
+- Realm list display with names and types
+- Population info (Low/Medium/High/Full)
+- Realm type indicators (PvP/PvE/RP/RPPvP)
+- Auto-select for single realm
 
-**AudioEngine** - miniaudio-based playback
-- WAV decode cache (256 entries, LRU eviction)
-- 2D and 3D positional audio
-- Sample rate preservation (explicit to avoid miniaudio pitch distortion)
+**CharacterScreen** - Character selection
+- Character list with 3D animated preview
+- Stats panel (level, race, class, location)
+- Create/delete character buttons
+- Enter world button
+- Auto-select for single character
 
-**Sound Managers:**
-- `AmbientSoundManager` - Wind, water, fire, birds, crickets, city ambience, bell tolls
-- `ActivitySoundManager` - Swimming strokes, jumping, landing
-- `MovementSoundManager` - Footsteps (terrain-aware), mount movement
-- `MountSoundManager` - Mount-specific movement audio
-- `MusicManager` - Zone music with day/night variants
+**CharacterCreateScreen** - Character creation
+- Race selection (all Alliance and Horde races)
+- Class selection (class availability by race)
+- Gender selection
+- Appearance customization (face, skin, hair, color, features)
+- Name input with validation
+- 3D character preview
 
-### 9. Warden Anti-Cheat (`src/game/`)
+**GameScreen** - In-game HUD
+- Chat window with message history and formatting
+- Action bar (12 slots with icons, cooldowns, keybindings)
+- Target frame (name, level, health, hostile/friendly coloring)
+- Player stats (health, mana/rage/energy)
+- Minimap with quest markers
+- Experience bar
 
-4-layer architecture:
-- `WardenHandler` - Packet handling (SMSG/CMSG_WARDEN_DATA)
-- `WardenModuleManager` - Module lifecycle and caching
-- `WardenModule` - 8-step pipeline: decrypt (RC4), strip RSA-2048 signature, decompress (zlib), parse PE headers, relocate, resolve imports, execute
-- `WardenEmulator` - Unicorn Engine x86 CPU emulation with Windows API interception
-- `WardenMemory` - PE image loading with bounds-checked reads, runtime global patching
+**InventoryScreen** - Inventory management
+- Equipment paper doll (23 slots: head, shoulders, chest, etc.)
+- Backpack grid (16 slots)
+- Item icons with tooltips
+- Drag-drop to equip/unequip
+- Item stats and durability
+- Gold display
+
+**SpellbookScreen** - Spells and abilities
+- Tabbed interface (class specialties + General)
+- Spell icons organized by SkillLine
+- Spell tooltips (name, rank, cost, cooldown, description)
+- Drag-drop to action bar
+- Known spell tracking
+
+**QuestLogScreen** - Quest tracking
+- Active quest list
+- Quest objectives and progress
+- Quest details (description, objectives, rewards)
+- Abandon quest button
+- Quest level and recommended party size
+
+**TalentScreen** - Talent trees
+- Placeholder for talent system
+- Tree visualization (TODO)
+- Talent point allocation (TODO)
+
+**Settings Window** - Configuration
+- UI opacity slider
+- Graphics options (TODO)
+- Audio controls (TODO)
+- Keybinding customization (TODO)
+
+**Loading Screen** - Map loading progress
+- Progress bar with percentage
+- Background image (map-specific, TODO)
+- Loading tips (TODO)
+- Shown during world entry and map transitions
+
+## Data Flow Examples
+
+### Authentication Flow
+```
+User Input (username/password)
+    ↓
+AuthHandler::authenticate()
+    ↓
+SRP::calculateVerifier()
+    ↓
+TCPSocket::send(LOGON_CHALLENGE)
+    ↓
+Server Response (LOGON_CHALLENGE)
+    ↓
+AuthHandler receives packet
+    ↓
+SRP::calculateProof()
+    ↓
+TCPSocket::send(LOGON_PROOF)
+    ↓
+Server Response (LOGON_PROOF) → Success
+    ↓
+Application::setState(REALM_SELECTION)
+```
+
+### Rendering Flow
+```
+Application::render()
+    ↓
+Renderer::beginFrame()
+    ├─ glClearColor() - Clear screen
+    └─ glClear() - Clear buffers
+    ↓
+Renderer::renderWorld(world)
+    ├─ Update camera matrices
+    ├─ Frustum culling
+    ├─ For each visible chunk:
+    │   ├─ Bind shader
+    │   ├─ Set uniforms (matrices, lighting)
+    │   ├─ Bind textures
+    │   └─ Mesh::draw() → glDrawElements()
+    └─ For each entity:
+        ├─ Calculate bone transforms
+        └─ Render skinned mesh
+    ↓
+UIManager::render()
+    ├─ ImGui::NewFrame()
+    ├─ Render current UI screen
+    └─ ImGui::Render()
+    ↓
+Renderer::endFrame()
+    ↓
+Window::swapBuffers()
+```
+
+### Asset Loading Flow
+```
+World::loadMap(mapId)
+    ↓
+AssetManager::readFile("World/Maps/{map}/map.adt")
+    ↓
+ADTLoader::load(adtData)
+    ├─ Parse MCNK chunks (terrain)
+    ├─ Parse MCLY chunks (textures)
+    ├─ Parse MCVT chunks (vertices)
+    └─ Parse MCNR chunks (normals)
+    ↓
+For each texture reference:
+    AssetManager::readFile(texturePath)
+    ↓
+    BLPLoader::load(blpData)
+    ↓
+    Texture::loadFromMemory(imageData)
+    ↓
+Create Mesh from vertices/normals/texcoords
+    ↓
+Add to Scene
+    ↓
+Renderer draws in next frame
+```
 
 ## Threading Model
 
-- **Main thread**: Window events, game logic update, rendering
-- **Async terrain**: Non-blocking chunk loading (std::async)
-- **Network I/O**: Non-blocking recv in main thread with per-frame budgets
-- **Normal maps**: Background CPU generation with mutex-protected result queue
-- **GPU uploads**: Second Vulkan queue for parallel texture/buffer transfers
+Currently **single-threaded** with async operations:
+- Main thread: Window events, update, render
+- Network I/O: Non-blocking in main thread (event-driven)
+- Asset loading: Async terrain streaming (non-blocking chunk loads)
+
+**Async Systems Implemented:**
+- Terrain streaming loads ADT chunks asynchronously to prevent frame stalls
+- Network packets processed in batches per frame
+- UI rendering deferred until after world rendering
+
+**Future multi-threading opportunities:**
+- Asset loading thread pool (background texture/model decompression)
+- Network thread (dedicated for socket I/O)
+- Physics thread (if collision detection is added)
+- Audio streaming thread
 
 ## Memory Management
 
-- **Smart pointers**: `std::unique_ptr` / `std::shared_ptr` throughout
-- **RAII**: All Vulkan resources wrapped with proper destructors
-- **VMA**: Vulkan Memory Allocator for GPU memory
-- **Object pooling**: Weather particles, combat text entries
-- **DBC caching**: Lazy-loaded mutable caches in const getters
+- **Smart pointers:** Used throughout (std::unique_ptr, std::shared_ptr)
+- **RAII:** All resources (OpenGL, SDL) cleaned up automatically
+- **No manual memory management:** No raw new/delete
+- **OpenGL resources:** Wrapped in classes with proper destructors
+
+## Performance Considerations
+
+### Rendering
+- **Frustum culling:** Only render visible chunks (terrain and WMO groups)
+- **Distance culling:** WMO groups culled beyond 160 units
+- **Batching:** Group draw calls by material and shader
+- **LOD:** Distance-based level of detail (TODO)
+- **Occlusion:** Portal-based visibility (WMO system)
+- **GPU skinning:** Character animation computed on GPU (256 bones)
+- **Instancing:** Future optimization for repeated models
+
+### Asset Streaming
+- **Async loading:** Terrain chunks load asynchronously (prevents frame stalls)
+- **Lazy loading:** Load chunks as player moves within streaming radius
+- **Unloading:** Free distant chunks automatically
+- **Caching:** Keep frequently used assets in memory (textures, models)
+- **Priority queue:** Load visible chunks first
+
+### Network
+- **Non-blocking I/O:** Never stall main thread
+- **Packet buffering:** Handle multiple packets per frame
+- **Batch processing:** Process received packets in batches
+- **RC4 encryption:** Efficient header encryption (minimal overhead)
+- **Compression:** Some packets are compressed (TODO)
+
+### Memory Management
+- **Smart pointers:** Automatic cleanup, no memory leaks
+- **Object pooling:** Reuse particle objects (weather system)
+- **DBC caching:** Load once, access fast
+- **Texture sharing:** Same texture used by multiple models
+
+## Error Handling
+
+- **Logging:** All errors logged with context
+- **Graceful degradation:** Missing assets show placeholder
+- **State recovery:** Network disconnect → back to auth screen
+- **No crashes:** Exceptions caught at application level
+
+## Configuration
+
+Currently hardcoded, future config system:
+- Window size and fullscreen
+- Graphics quality settings
+- Server addresses
+- Keybindings
+- Audio volume
+
+## Testing Strategy
+
+**Unit Testing** (TODO):
+- Packet serialization/deserialization
+- SRP math functions
+- Asset parsers with sample files
+- DBC record parsing
+- Inventory slot calculations
+
+**Integration Testing** (TODO):
+- Full auth flow against test server
+- Realm list retrieval
+- Character creation and selection
+- Quest turn-in flow
+- Vendor transactions
+
+**Manual Testing:**
+- Visual verification of rendering (terrain, water, models, particles)
+- Performance profiling (F1 performance HUD)
+- Memory leak checking (valgrind)
+- Online gameplay against AzerothCore/TrinityCore/MaNGOS servers
+- UI interactions (drag-drop, click events)
+
+**Current Test Coverage:**
+- Full authentication flow tested against live servers
+- Character creation and selection verified
+- Quest system tested (accept, track, turn-in)
+- Vendor system tested (buy, sell)
+- Combat system tested (targeting, auto-attack, spells)
+- Inventory system tested (equip, unequip, drag-drop)
 
 ## Build System
 
-**CMake** with modular targets:
-- `wowee` - Main executable
-- `asset_extract` - MPQ extraction tool (requires StormLib)
-- `dbc_to_csv` / `auth_probe` / `blp_convert` - Utility tools
+**CMake:**
+- Modular target structure
+- Automatic dependency discovery
+- Cross-platform (Linux focus, but portable)
+- Out-of-source builds
 
 **Dependencies:**
-- SDL2, Vulkan SDK, OpenSSL, GLM, zlib (system)
+- SDL2 (system)
+- OpenGL/GLEW (system)
+- OpenSSL (system)
+- GLM (system or header-only)
 - ImGui (submodule in extern/)
-- VMA, vk-bootstrap, stb_image (vendored in extern/)
-- StormLib (system, optional — only for asset_extract)
-- Unicorn Engine (system, optional — only for Warden emulation)
-- FFmpeg (system, optional — for video playback)
-
-**CI**: GitHub Actions for Linux (x86-64, ARM64), Windows (MSYS2), macOS (ARM64)
-**Container builds**: Docker cross-compilation for Linux, macOS (osxcross), Windows (LLVM-MinGW)
+- StormLib (system, optional)
 
 ## Code Style
 
 - **C++20 standard**
-- **Namespaces**: `wowee::core`, `wowee::rendering`, `wowee::game`, `wowee::ui`, `wowee::network`, `wowee::auth`, `wowee::audio`, `wowee::pipeline`
-- **Naming**: PascalCase for classes, camelCase for functions/variables, kPascalCase for constants
-- **Headers**: `.hpp` extension, `#pragma once`
-- **Commits**: Conventional style (`feat:`, `fix:`, `refactor:`, `docs:`, `perf:`)
+- **Namespaces:** wowee::core, wowee::rendering, etc.
+- **Naming:** PascalCase for classes, camelCase for functions/variables
+- **Headers:** .hpp extension
+- **Includes:** Relative to project root
+
+---
+
+This architecture provides a solid foundation for a full-featured native WoW client!
diff --git a/docs/authentication.md b/docs/authentication.md
index 19a6f9fe..ff514399 100644
--- a/docs/authentication.md
+++ b/docs/authentication.md
@@ -563,4 +563,5 @@ The client is now ready for character operations and world entry! 🎮
 
 ---
 
-**Implementation Status:** Complete — authentication, character enumeration, and world entry all working.
+**Implementation Status:** 100% Complete for authentication
+**Next Milestone:** Character enumeration and world entry
diff --git a/docs/packet-framing.md b/docs/packet-framing.md
index 157645fd..be7ee3cb 100644
--- a/docs/packet-framing.md
+++ b/docs/packet-framing.md
@@ -397,4 +397,6 @@ The authentication system can now reliably communicate with WoW 3.3.5a servers!
 
 ---
 
-**Status:** ✅ Complete and tested against AzerothCore, TrinityCore, Mangos, and Turtle WoW.
+**Status:** ✅ Complete and tested
+
+**Next Steps:** Test with live server and implement realm list protocol.
diff --git a/docs/perf_baseline.md b/docs/perf_baseline.md
deleted file mode 100644
index 88bdc743..00000000
--- a/docs/perf_baseline.md
+++ /dev/null
@@ -1,79 +0,0 @@
-# Performance Baseline — WoWee
-
-> Phase 0.3 deliverable. Measurements taken before any optimization work.
-> Re-run after each phase to quantify improvement.
-
-## Tracy Profiler Integration
-
-Tracy v0.11.1 integrated under `WOWEE_ENABLE_TRACY` CMake option (default: OFF).
-When enabled, zero-cost zone markers instrument the following critical paths:
-
-### Instrumented Zones
-
-| Zone Name | File | Purpose |
-|-----------|------|---------|
-| `Application::run` | src/core/application.cpp | Main loop entry |
-| `Application::update` | src/core/application.cpp | Per-frame game logic |
-| `Renderer::beginFrame` | src/rendering/renderer.cpp | Vulkan frame begin |
-| `Renderer::endFrame` | src/rendering/renderer.cpp | Post-process + present |
-| `Renderer::update` | src/rendering/renderer.cpp | Renderer per-frame update |
-| `Renderer::renderWorld` | src/rendering/renderer.cpp | Main world draw call |
-| `Renderer::renderShadowPass` | src/rendering/renderer.cpp | Shadow depth pass |
-| `PostProcess::execute` | src/rendering/post_process_pipeline.cpp | FSR/FXAA post-process |
-| `M2::computeBoneMatrices` | src/rendering/m2_renderer.cpp | CPU skeletal animation |
-| `M2Renderer::update` | src/rendering/m2_renderer.cpp | M2 instance update + culling |
-| `TerrainManager::update` | src/rendering/terrain_manager.cpp | Terrain streaming logic |
-| `TerrainManager::processReadyTiles` | src/rendering/terrain_manager.cpp | GPU tile uploads |
-| `ADTLoader::load` | src/pipeline/adt_loader.cpp | ADT binary parsing |
-| `AssetManager::loadTexture` | src/pipeline/asset_manager.cpp | BLP texture loading |
-| `AssetManager::loadDBC` | src/pipeline/asset_manager.cpp | DBC data file loading |
-| `WorldSocket::update` | src/network/world_socket.cpp | Network packet dispatch |
-
-`FrameMark` placed at frame boundary in Application::update to track FPS.
-
-### How to Profile
-
-```bash
-# Build with Tracy enabled
-mkdir -p build_tracy && cd build_tracy
-cmake .. -DCMAKE_BUILD_TYPE=RelWithDebInfo -DWOWEE_ENABLE_TRACY=ON
-cmake --build . --parallel $(nproc)
-
-# Run the client — Tracy will broadcast on default port (8086)
-cd bin && ./wowee
-
-# Connect with Tracy profiler GUI (separate download from https://github.com/wolfpld/tracy/releases)
-# Or capture from CLI: tracy-capture -o trace.tracy
-```
-
-## Baseline Scenarios
-
-> **TODO:** Record measurements once profiler is connected to a running instance.
-> Each scenario should record: avg FPS, frame time (p50/p95/p99), and per-zone timings.
-
-### Scenario 1: Stormwind (Heavy M2/WMO)
-- **Location:** Stormwind City center
-- **Load:** Dense M2 models (NPCs, doodads), multiple WMO interiors
-- **Avg FPS:** _pending_
-- **Frame time (p50/p95/p99):** _pending_
-- **Top zones:** _pending_
-
-### Scenario 2: The Barrens (Heavy Terrain)
-- **Location:** Central Barrens
-- **Load:** Many terrain tiles loaded, sparse M2, large draw distance
-- **Avg FPS:** _pending_
-- **Frame time (p50/p95/p99):** _pending_
-- **Top zones:** _pending_
-
-### Scenario 3: Dungeon Instance (WMO-only)
-- **Location:** Any dungeon instance (e.g., Deadmines entrance)
-- **Load:** WMO interior rendering, no terrain
-- **Avg FPS:** _pending_
-- **Frame time (p50/p95/p99):** _pending_
-- **Top zones:** _pending_
-
-## Notes
-
-- When `WOWEE_ENABLE_TRACY` is OFF (default), all `ZoneScopedN` / `FrameMark` macros expand to nothing — zero runtime overhead.
-- Tracy requires a network connection to capture traces. Run the Tracy profiler GUI or `tracy-capture` CLI alongside the client.
-- Debug builds are significantly slower due to -Og and no LTO; use RelWithDebInfo for representative measurements.
diff --git a/docs/quickstart.md b/docs/quickstart.md
index e5fc0b9a..47bef9d2 100644
--- a/docs/quickstart.md
+++ b/docs/quickstart.md
@@ -19,11 +19,17 @@ For a more honest snapshot of gaps and current direction, see `docs/status.md`.
 ### 1. Clone
 
 ```bash
-git clone --recurse-submodules https://github.com/Kelsidavis/WoWee.git
-cd WoWee
+git clone https://github.com/Kelsidavis/WoWee.git
+cd wowee
 ```
 
-### 2. Build
+### 2. Install ImGui
+
+```bash
+git clone https://github.com/ocornut/imgui.git extern/imgui
+```
+
+### 3. Build
 
 ```bash
 cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
@@ -90,7 +96,7 @@ Use `BUILD_INSTRUCTIONS.md` for distro-specific package lists.
 
 - Verify auth/world server is running
 - Check host/port settings
-- Check server logs and client logs in `logs/wowee.log`
+- Check server logs and client logs in `build/bin/logs/`
 
 ### Missing assets (models/textures/terrain)
 
diff --git a/docs/server-setup.md b/docs/server-setup.md
index ba59fd56..c185b943 100644
--- a/docs/server-setup.md
+++ b/docs/server-setup.md
@@ -609,6 +609,6 @@ Once you have a working local server connection:
 ---
 
 **Status**: Ready for local server testing
-**Last Updated**: 2026-03-30
-**Client Version**: v1.8.9-preview
-**Server Compatibility**: Vanilla 1.12, TBC 2.4.3, WotLK 3.3.5a (12340), Turtle WoW 1.17
+**Last Updated**: 2026-01-27
+**Client Version**: 1.0.3
+**Server Compatibility**: WoW 3.3.5a (12340)
diff --git a/docs/srp-implementation.md b/docs/srp-implementation.md
index e83505ce..084881ed 100644
--- a/docs/srp-implementation.md
+++ b/docs/srp-implementation.md
@@ -351,13 +351,13 @@ The expensive operation (session key computation) only happens once per login.
 2. **No Plaintext Storage:** Password is immediately hashed, never stored
 3. **Forward Secrecy:** Ephemeral keys (a, A) are generated per session
 4. **Mutual Authentication:** Both client and server prove knowledge of password
-5. **Secure Channel:** Session key K is used for RC4 header encryption after auth completes
+5. **Secure Channel:** Session key K can be used for encryption (not implemented yet)
 
 ## References
 
 - [SRP Protocol](http://srp.stanford.edu/)
 - [WoWDev Wiki - SRP](https://wowdev.wiki/SRP)
-- Implementation: `src/auth/srp.cpp`, `include/auth/srp.hpp`
+- Original wowee: `/wowee/src/lib/crypto/srp.js`
 - OpenSSL BIGNUM: https://www.openssl.org/docs/man1.1.1/man3/BN_new.html
 
 ---
diff --git a/docs/status.md b/docs/status.md
index c337ca2f..8244b425 100644
--- a/docs/status.md
+++ b/docs/status.md
@@ -1,6 +1,6 @@
 # Project Status
 
-**Last updated**: 2026-03-30
+**Last updated**: 2026-03-07
 
 ## What This Repo Is
 
@@ -25,23 +25,20 @@ Implemented (working in normal use):
 - Talent tree UI with proper visuals and functionality
 - Pet tracking (SMSG_PET_SPELLS), dismiss pet button
 - Party: group invites, party list, out-of-range member health (SMSG_PARTY_MEMBER_STATS)
-- Nameplates: NPC subtitles, guild names, elite/boss/rare borders, quest/raid indicators, cast bars, debuff dots
-- Floating combat text: world-space damage/heal numbers above entities with 3D projection
-- Target/focus frames: guild name, creature type, rank badges, combo points, cast bars
 - Map exploration: subzone-level fog-of-war reveal
 - Warden anti-cheat: full module execution via Unicorn Engine x86 emulation; module caching
-- Audio: ambient, movement, combat, spell, and UI sound systems; NPC voice lines for all playable races (greeting/farewell/vendor/pissed/aggro/flee)
-- Bag UI: independent bag windows (any bag closable independently), open-bag indicator on bag bar, server-synced bag sort, off-screen position reset, optional collapse-empty mode in aggregate view
-- DBC auto-detection: CharSections.dbc field layout auto-detected at runtime (handles stock WotLK vs HD-textured clients)
+- Audio: ambient, movement, combat, spell, and UI sound systems
+- Bag UI: separate bag windows, open-bag indicator on bag bar, optional collapse-empty mode in aggregate bag view
 - Multi-expansion: Classic/Vanilla, TBC, WotLK, and Turtle WoW (1.17) protocol and asset variants
-- CI: GitHub Actions for Linux (x86-64, ARM64), Windows (MSYS2 x86-64 + ARM64), macOS (ARM64); container builds via Podman
+- CI: GitHub Actions for Linux (x86-64, ARM64), Windows (MSYS2), macOS (ARM64); container builds via Podman
 
 In progress / known gaps:
 
 - Transports: M2 transports (trams) working with position-delta riding; WMO transports (ships, zeppelins) working with path following; some edge cases remain
-- Quest GO interaction: CMSG_GAMEOBJ_USE + CMSG_LOOT sent correctly, but some AzerothCore/ChromieCraft servers don't grant quest credit for chest-type GOs (server-side limitation)
-- Visual edge cases: some M2/WMO rendering gaps (some particle effects)
-- Water refraction: enabled by default; srcAccessMask barrier fix (2026-03-18) resolved prior VK_ERROR_DEVICE_LOST on AMD/Mali GPUs
+- 3D positional audio: not implemented (mono/stereo only)
+- Visual edge cases: some M2/WMO rendering gaps (character shin mesh, some particle effects)
+- Interior rendering: WMO interior shadows disabled (too dark); lava steam particles sparse
+- Water refraction: implemented but disabled by default (can cause VK_ERROR_DEVICE_LOST on some GPUs)
 
 ## Where To Look
 
diff --git a/extern/FidelityFX-FSR2 b/extern/FidelityFX-FSR2
deleted file mode 160000
index 3d22aefd..00000000
--- a/extern/FidelityFX-FSR2
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 3d22aefd90fd861e5cee1c3cde18ff185e221f2d
diff --git a/extern/FidelityFX-SDK b/extern/FidelityFX-SDK
deleted file mode 160000
index ce81c674..00000000
--- a/extern/FidelityFX-SDK
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit ce81c674d92d81ad1253841f39a359811dd738cf
diff --git a/extern/VERSIONS.md b/extern/VERSIONS.md
deleted file mode 100644
index 1d7d2d4b..00000000
--- a/extern/VERSIONS.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# Vendored Library Versions
-
-Versions of third-party libraries vendored in `extern/`. Update this file
-when upgrading any dependency so maintainers can track drift.
-
-| Library | Version | Source | Notes |
-|---------|---------|--------|-------|
-| Dear ImGui | 1.92.6 WIP | https://github.com/ocornut/imgui | Git submodule |
-| vk-bootstrap | latest | https://github.com/charles-lunarg/vk-bootstrap | Git submodule |
-| Vulkan Memory Allocator | 3.4.0 | https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator | Single header |
-| miniaudio | 0.11.24 | https://miniaud.io/ | Single header |
-| stb_image | 2.30 | https://github.com/nothings/stb | Single header |
-| stb_image_write | 1.16 | https://github.com/nothings/stb | Single header |
-| Lua | 5.1.5 | https://www.lua.org/ | Intentionally 5.1 for WoW addon API compatibility |
diff --git a/extern/catch2/catch_amalgamated.cpp b/extern/catch2/catch_amalgamated.cpp
deleted file mode 100644
index f45c18a0..00000000
--- a/extern/catch2/catch_amalgamated.cpp
+++ /dev/null
@@ -1,11811 +0,0 @@
-
-//              Copyright Catch2 Authors
-// Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE.txt or copy at
-//        https://www.boost.org/LICENSE_1_0.txt)
-
-// SPDX-License-Identifier: BSL-1.0
-
-//  Catch v3.7.1
-//  Generated: 2024-09-17 10:36:45.608896
-//  ----------------------------------------------------------
-//  This file is an amalgamation of multiple different files.
-//  You probably shouldn't edit it directly.
-//  ----------------------------------------------------------
-
-#include "catch_amalgamated.hpp"
-
-
-#ifndef CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
-#define CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
-
-
-#if defined(CATCH_PLATFORM_WINDOWS)
-
-// We might end up with the define made globally through the compiler,
-// and we don't want to trigger warnings for this
-#if !defined(NOMINMAX)
-#  define NOMINMAX
-#endif
-#if !defined(WIN32_LEAN_AND_MEAN)
-#  define WIN32_LEAN_AND_MEAN
-#endif
-
-#include <windows.h>
-
-#endif // defined(CATCH_PLATFORM_WINDOWS)
-
-#endif // CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
-
-
-
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            ChronometerConcept::~ChronometerConcept() = default;
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-
-// Adapted from donated nonius code.
-
-
-#include <vector>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last) {
-                if (!cfg.benchmarkNoAnalysis()) {
-                    std::vector<double> samples;
-                    samples.reserve(static_cast<size_t>(last - first));
-                    for (auto current = first; current != last; ++current) {
-                        samples.push_back( current->count() );
-                    }
-
-                    auto analysis = Catch::Benchmark::Detail::analyse_samples(
-                        cfg.benchmarkConfidenceInterval(),
-                        cfg.benchmarkResamples(),
-                        samples.data(),
-                        samples.data() + samples.size() );
-                    auto outliers = Catch::Benchmark::Detail::classify_outliers(
-                        samples.data(), samples.data() + samples.size() );
-
-                    auto wrap_estimate = [](Estimate<double> e) {
-                        return Estimate<FDuration> {
-                            FDuration(e.point),
-                                FDuration(e.lower_bound),
-                                FDuration(e.upper_bound),
-                                e.confidence_interval,
-                        };
-                    };
-                    std::vector<FDuration> samples2;
-                    samples2.reserve(samples.size());
-                    for (auto s : samples) {
-                        samples2.push_back( FDuration( s ) );
-                    }
-
-                    return {
-                        CATCH_MOVE(samples2),
-                        wrap_estimate(analysis.mean),
-                        wrap_estimate(analysis.standard_deviation),
-                        outliers,
-                        analysis.outlier_variance,
-                    };
-                } else {
-                    std::vector<FDuration> samples;
-                    samples.reserve(static_cast<size_t>(last - first));
-
-                    FDuration mean = FDuration(0);
-                    int i = 0;
-                    for (auto it = first; it < last; ++it, ++i) {
-                        samples.push_back(*it);
-                        mean += *it;
-                    }
-                    mean /= i;
-
-                    return SampleAnalysis{
-                        CATCH_MOVE(samples),
-                        Estimate<FDuration>{ mean, mean, mean, 0.0 },
-                        Estimate<FDuration>{ FDuration( 0 ),
-                                             FDuration( 0 ),
-                                             FDuration( 0 ),
-                                             0.0 },
-                        OutlierClassification{},
-                        0.0
-                    };
-                }
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-
-
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            struct do_nothing {
-                void operator()() const {}
-            };
-
-            BenchmarkFunction::callable::~callable() = default;
-            BenchmarkFunction::BenchmarkFunction():
-                f( new model<do_nothing>{ {} } ){}
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-
-
-
-#include <exception>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            struct optimized_away_error : std::exception {
-                const char* what() const noexcept override;
-            };
-
-            const char* optimized_away_error::what() const noexcept {
-                return "could not measure benchmark, maybe it was optimized away";
-            }
-
-            void throw_optimized_away_error() {
-                Catch::throw_exception(optimized_away_error{});
-            }
-
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-
-// Adapted from donated nonius code.
-
-
-
-#include <algorithm>
-#include <cassert>
-#include <cmath>
-#include <cstddef>
-#include <numeric>
-#include <random>
-
-
-#if defined(CATCH_CONFIG_USE_ASYNC)
-#include <future>
-#endif
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            namespace {
-
-                template <typename URng, typename Estimator>
-                static sample
-                resample( URng& rng,
-                          unsigned int resamples,
-                          double const* first,
-                          double const* last,
-                          Estimator& estimator ) {
-                    auto n = static_cast<size_t>( last - first );
-                    Catch::uniform_integer_distribution<size_t> dist( 0, n - 1 );
-
-                    sample out;
-                    out.reserve( resamples );
-                    std::vector<double> resampled;
-                    resampled.reserve( n );
-                    for ( size_t i = 0; i < resamples; ++i ) {
-                        resampled.clear();
-                        for ( size_t s = 0; s < n; ++s ) {
-                            resampled.push_back( first[dist( rng )] );
-                        }
-                        const auto estimate =
-                            estimator( resampled.data(), resampled.data() + resampled.size() );
-                        out.push_back( estimate );
-                    }
-                    std::sort( out.begin(), out.end() );
-                    return out;
-                }
-
-                static double outlier_variance( Estimate<double> mean,
-                                                Estimate<double> stddev,
-                                                int n ) {
-                    double sb = stddev.point;
-                    double mn = mean.point / n;
-                    double mg_min = mn / 2.;
-                    double sg = (std::min)( mg_min / 4., sb / std::sqrt( n ) );
-                    double sg2 = sg * sg;
-                    double sb2 = sb * sb;
-
-                    auto c_max = [n, mn, sb2, sg2]( double x ) -> double {
-                        double k = mn - x;
-                        double d = k * k;
-                        double nd = n * d;
-                        double k0 = -n * nd;
-                        double k1 = sb2 - n * sg2 + nd;
-                        double det = k1 * k1 - 4 * sg2 * k0;
-                        return static_cast<int>( -2. * k0 /
-                                                 ( k1 + std::sqrt( det ) ) );
-                    };
-
-                    auto var_out = [n, sb2, sg2]( double c ) {
-                        double nc = n - c;
-                        return ( nc / n ) * ( sb2 - nc * sg2 );
-                    };
-
-                    return (std::min)( var_out( 1 ),
-                                       var_out(
-                                           (std::min)( c_max( 0. ),
-                                                       c_max( mg_min ) ) ) ) /
-                           sb2;
-                }
-
-                static double erf_inv( double x ) {
-                    // Code accompanying the article "Approximating the erfinv
-                    // function" in GPU Computing Gems, Volume 2
-                    double w, p;
-
-                    w = -log( ( 1.0 - x ) * ( 1.0 + x ) );
-
-                    if ( w < 6.250000 ) {
-                        w = w - 3.125000;
-                        p = -3.6444120640178196996e-21;
-                        p = -1.685059138182016589e-19 + p * w;
-                        p = 1.2858480715256400167e-18 + p * w;
-                        p = 1.115787767802518096e-17 + p * w;
-                        p = -1.333171662854620906e-16 + p * w;
-                        p = 2.0972767875968561637e-17 + p * w;
-                        p = 6.6376381343583238325e-15 + p * w;
-                        p = -4.0545662729752068639e-14 + p * w;
-                        p = -8.1519341976054721522e-14 + p * w;
-                        p = 2.6335093153082322977e-12 + p * w;
-                        p = -1.2975133253453532498e-11 + p * w;
-                        p = -5.4154120542946279317e-11 + p * w;
-                        p = 1.051212273321532285e-09 + p * w;
-                        p = -4.1126339803469836976e-09 + p * w;
-                        p = -2.9070369957882005086e-08 + p * w;
-                        p = 4.2347877827932403518e-07 + p * w;
-                        p = -1.3654692000834678645e-06 + p * w;
-                        p = -1.3882523362786468719e-05 + p * w;
-                        p = 0.0001867342080340571352 + p * w;
-                        p = -0.00074070253416626697512 + p * w;
-                        p = -0.0060336708714301490533 + p * w;
-                        p = 0.24015818242558961693 + p * w;
-                        p = 1.6536545626831027356 + p * w;
-                    } else if ( w < 16.000000 ) {
-                        w = sqrt( w ) - 3.250000;
-                        p = 2.2137376921775787049e-09;
-                        p = 9.0756561938885390979e-08 + p * w;
-                        p = -2.7517406297064545428e-07 + p * w;
-                        p = 1.8239629214389227755e-08 + p * w;
-                        p = 1.5027403968909827627e-06 + p * w;
-                        p = -4.013867526981545969e-06 + p * w;
-                        p = 2.9234449089955446044e-06 + p * w;
-                        p = 1.2475304481671778723e-05 + p * w;
-                        p = -4.7318229009055733981e-05 + p * w;
-                        p = 6.8284851459573175448e-05 + p * w;
-                        p = 2.4031110387097893999e-05 + p * w;
-                        p = -0.0003550375203628474796 + p * w;
-                        p = 0.00095328937973738049703 + p * w;
-                        p = -0.0016882755560235047313 + p * w;
-                        p = 0.0024914420961078508066 + p * w;
-                        p = -0.0037512085075692412107 + p * w;
-                        p = 0.005370914553590063617 + p * w;
-                        p = 1.0052589676941592334 + p * w;
-                        p = 3.0838856104922207635 + p * w;
-                    } else {
-                        w = sqrt( w ) - 5.000000;
-                        p = -2.7109920616438573243e-11;
-                        p = -2.5556418169965252055e-10 + p * w;
-                        p = 1.5076572693500548083e-09 + p * w;
-                        p = -3.7894654401267369937e-09 + p * w;
-                        p = 7.6157012080783393804e-09 + p * w;
-                        p = -1.4960026627149240478e-08 + p * w;
-                        p = 2.9147953450901080826e-08 + p * w;
-                        p = -6.7711997758452339498e-08 + p * w;
-                        p = 2.2900482228026654717e-07 + p * w;
-                        p = -9.9298272942317002539e-07 + p * w;
-                        p = 4.5260625972231537039e-06 + p * w;
-                        p = -1.9681778105531670567e-05 + p * w;
-                        p = 7.5995277030017761139e-05 + p * w;
-                        p = -0.00021503011930044477347 + p * w;
-                        p = -0.00013871931833623122026 + p * w;
-                        p = 1.0103004648645343977 + p * w;
-                        p = 4.8499064014085844221 + p * w;
-                    }
-                    return p * x;
-                }
-
-                static double
-                standard_deviation( double const* first, double const* last ) {
-                    auto m = Catch::Benchmark::Detail::mean( first, last );
-                    double variance =
-                        std::accumulate( first,
-                                         last,
-                                         0.,
-                                         [m]( double a, double b ) {
-                                             double diff = b - m;
-                                             return a + diff * diff;
-                                         } ) /
-                        ( last - first );
-                    return std::sqrt( variance );
-                }
-
-                static sample jackknife( double ( *estimator )( double const*,
-                                                                double const* ),
-                                         double* first,
-                                         double* last ) {
-                    const auto second = first + 1;
-                    sample results;
-                    results.reserve( static_cast<size_t>( last - first ) );
-
-                    for ( auto it = first; it != last; ++it ) {
-                        std::iter_swap( it, first );
-                        results.push_back( estimator( second, last ) );
-                    }
-
-                    return results;
-                }
-
-
-            } // namespace
-        }     // namespace Detail
-    }         // namespace Benchmark
-} // namespace Catch
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-
-            double weighted_average_quantile( int k,
-                                              int q,
-                                              double* first,
-                                              double* last ) {
-                auto count = last - first;
-                double idx = (count - 1) * k / static_cast<double>(q);
-                int j = static_cast<int>(idx);
-                double g = idx - j;
-                std::nth_element(first, first + j, last);
-                auto xj = first[j];
-                if ( Catch::Detail::directCompare( g, 0 ) ) {
-                    return xj;
-                }
-
-                auto xj1 = *std::min_element(first + (j + 1), last);
-                return xj + g * (xj1 - xj);
-            }
-
-            OutlierClassification
-            classify_outliers( double const* first, double const* last ) {
-                std::vector<double> copy( first, last );
-
-                auto q1 = weighted_average_quantile( 1, 4, copy.data(), copy.data() + copy.size() );
-                auto q3 = weighted_average_quantile( 3, 4, copy.data(), copy.data() + copy.size() );
-                auto iqr = q3 - q1;
-                auto los = q1 - ( iqr * 3. );
-                auto lom = q1 - ( iqr * 1.5 );
-                auto him = q3 + ( iqr * 1.5 );
-                auto his = q3 + ( iqr * 3. );
-
-                OutlierClassification o;
-                for ( ; first != last; ++first ) {
-                    const double t = *first;
-                    if ( t < los ) {
-                        ++o.low_severe;
-                    } else if ( t < lom ) {
-                        ++o.low_mild;
-                    } else if ( t > his ) {
-                        ++o.high_severe;
-                    } else if ( t > him ) {
-                        ++o.high_mild;
-                    }
-                    ++o.samples_seen;
-                }
-                return o;
-            }
-
-            double mean( double const* first, double const* last ) {
-                auto count = last - first;
-                double sum = 0.;
-                while (first != last) {
-                    sum += *first;
-                    ++first;
-                }
-                return sum / static_cast<double>(count);
-            }
-
-            double normal_cdf( double x ) {
-                return std::erfc( -x / std::sqrt( 2.0 ) ) / 2.0;
-            }
-
-            double erfc_inv(double x) {
-                return erf_inv(1.0 - x);
-            }
-
-            double normal_quantile(double p) {
-                static const double ROOT_TWO = std::sqrt(2.0);
-
-                double result = 0.0;
-                assert(p >= 0 && p <= 1);
-                if (p < 0 || p > 1) {
-                    return result;
-                }
-
-                result = -erfc_inv(2.0 * p);
-                // result *= normal distribution standard deviation (1.0) * sqrt(2)
-                result *= /*sd * */ ROOT_TWO;
-                // result += normal disttribution mean (0)
-                return result;
-            }
-
-            Estimate<double>
-            bootstrap( double confidence_level,
-                       double* first,
-                       double* last,
-                       sample const& resample,
-                       double ( *estimator )( double const*, double const* ) ) {
-                auto n_samples = last - first;
-
-                double point = estimator( first, last );
-                // Degenerate case with a single sample
-                if ( n_samples == 1 )
-                    return { point, point, point, confidence_level };
-
-                sample jack = jackknife( estimator, first, last );
-                double jack_mean =
-                    mean( jack.data(), jack.data() + jack.size() );
-                double sum_squares = 0, sum_cubes = 0;
-                for ( double x : jack ) {
-                    auto difference = jack_mean - x;
-                    auto square = difference * difference;
-                    auto cube = square * difference;
-                    sum_squares += square;
-                    sum_cubes += cube;
-                }
-
-                double accel = sum_cubes / ( 6 * std::pow( sum_squares, 1.5 ) );
-                long n = static_cast<long>( resample.size() );
-                double prob_n =
-                    std::count_if( resample.begin(),
-                                   resample.end(),
-                                   [point]( double x ) { return x < point; } ) /
-                    static_cast<double>( n );
-                // degenerate case with uniform samples
-                if ( Catch::Detail::directCompare( prob_n, 0. ) ) {
-                    return { point, point, point, confidence_level };
-                }
-
-                double bias = normal_quantile( prob_n );
-                double z1 = normal_quantile( ( 1. - confidence_level ) / 2. );
-
-                auto cumn = [n]( double x ) -> long {
-                    return std::lround( normal_cdf( x ) *
-                                        static_cast<double>( n ) );
-                };
-                auto a = [bias, accel]( double b ) {
-                    return bias + b / ( 1. - accel * b );
-                };
-                double b1 = bias + z1;
-                double b2 = bias - z1;
-                double a1 = a( b1 );
-                double a2 = a( b2 );
-                auto lo = static_cast<size_t>( (std::max)( cumn( a1 ), 0l ) );
-                auto hi =
-                    static_cast<size_t>( (std::min)( cumn( a2 ), n - 1 ) );
-
-                return { point, resample[lo], resample[hi], confidence_level };
-            }
-
-            bootstrap_analysis analyse_samples(double confidence_level,
-                                               unsigned int n_resamples,
-                                               double* first,
-                                               double* last) {
-                auto mean = &Detail::mean;
-                auto stddev = &standard_deviation;
-
-#if defined(CATCH_CONFIG_USE_ASYNC)
-                auto Estimate = [=](double(*f)(double const*, double const*)) {
-                    std::random_device rd;
-                    auto seed = rd();
-                    return std::async(std::launch::async, [=] {
-                        SimplePcg32 rng( seed );
-                        auto resampled = resample(rng, n_resamples, first, last, f);
-                        return bootstrap(confidence_level, first, last, resampled, f);
-                    });
-                };
-
-                auto mean_future = Estimate(mean);
-                auto stddev_future = Estimate(stddev);
-
-                auto mean_estimate = mean_future.get();
-                auto stddev_estimate = stddev_future.get();
-#else
-                auto Estimate = [=](double(*f)(double const* , double const*)) {
-                    std::random_device rd;
-                    auto seed = rd();
-                    SimplePcg32 rng( seed );
-                    auto resampled = resample(rng, n_resamples, first, last, f);
-                    return bootstrap(confidence_level, first, last, resampled, f);
-                };
-
-                auto mean_estimate = Estimate(mean);
-                auto stddev_estimate = Estimate(stddev);
-#endif // CATCH_USE_ASYNC
-
-                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
-                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
-
-                return { mean_estimate, stddev_estimate, outlier_variance };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-
-
-#include <cmath>
-#include <limits>
-
-namespace {
-
-// Performs equivalent check of std::fabs(lhs - rhs) <= margin
-// But without the subtraction to allow for INFINITY in comparison
-bool marginComparison(double lhs, double rhs, double margin) {
-    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
-}
-
-}
-
-namespace Catch {
-
-    Approx::Approx ( double value )
-    :   m_epsilon( static_cast<double>(std::numeric_limits<float>::epsilon())*100. ),
-        m_margin( 0.0 ),
-        m_scale( 0.0 ),
-        m_value( value )
-    {}
-
-    Approx Approx::custom() {
-        return Approx( 0 );
-    }
-
-    Approx Approx::operator-() const {
-        auto temp(*this);
-        temp.m_value = -temp.m_value;
-        return temp;
-    }
-
-
-    std::string Approx::toString() const {
-        ReusableStringStream rss;
-        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
-        return rss.str();
-    }
-
-    bool Approx::equalityComparisonImpl(const double other) const {
-        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
-        // Thanks to Richard Harris for his help refining the scaled margin value
-        return marginComparison(m_value, other, m_margin)
-            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
-    }
-
-    void Approx::setMargin(double newMargin) {
-        CATCH_ENFORCE(newMargin >= 0,
-            "Invalid Approx::margin: " << newMargin << '.'
-            << " Approx::Margin has to be non-negative.");
-        m_margin = newMargin;
-    }
-
-    void Approx::setEpsilon(double newEpsilon) {
-        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
-            "Invalid Approx::epsilon: " << newEpsilon << '.'
-            << " Approx::epsilon has to be in [0, 1]");
-        m_epsilon = newEpsilon;
-    }
-
-namespace literals {
-    Approx operator ""_a(long double val) {
-        return Approx(val);
-    }
-    Approx operator ""_a(unsigned long long val) {
-        return Approx(val);
-    }
-} // end namespace literals
-
-std::string StringMaker<Catch::Approx>::convert(Catch::Approx const& value) {
-    return value.toString();
-}
-
-} // end namespace Catch
-
-
-
-namespace Catch {
-
-    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const& _lazyExpression):
-        lazyExpression(_lazyExpression),
-        resultType(_resultType) {}
-
-    std::string AssertionResultData::reconstructExpression() const {
-
-        if( reconstructedExpression.empty() ) {
-            if( lazyExpression ) {
-                ReusableStringStream rss;
-                rss << lazyExpression;
-                reconstructedExpression = rss.str();
-            }
-        }
-        return reconstructedExpression;
-    }
-
-    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData&& data )
-    :   m_info( info ),
-        m_resultData( CATCH_MOVE(data) )
-    {}
-
-    // Result was a success
-    bool AssertionResult::succeeded() const {
-        return Catch::isOk( m_resultData.resultType );
-    }
-
-    // Result was a success, or failure is suppressed
-    bool AssertionResult::isOk() const {
-        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
-    }
-
-    ResultWas::OfType AssertionResult::getResultType() const {
-        return m_resultData.resultType;
-    }
-
-    bool AssertionResult::hasExpression() const {
-        return !m_info.capturedExpression.empty();
-    }
-
-    bool AssertionResult::hasMessage() const {
-        return !m_resultData.message.empty();
-    }
-
-    std::string AssertionResult::getExpression() const {
-        // Possibly overallocating by 3 characters should be basically free
-        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
-        if (isFalseTest(m_info.resultDisposition)) {
-            expr += "!(";
-        }
-        expr += m_info.capturedExpression;
-        if (isFalseTest(m_info.resultDisposition)) {
-            expr += ')';
-        }
-        return expr;
-    }
-
-    std::string AssertionResult::getExpressionInMacro() const {
-        if ( m_info.macroName.empty() ) {
-            return static_cast<std::string>( m_info.capturedExpression );
-        }
-        std::string expr;
-        expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
-        expr += m_info.macroName;
-        expr += "( ";
-        expr += m_info.capturedExpression;
-        expr += " )";
-        return expr;
-    }
-
-    bool AssertionResult::hasExpandedExpression() const {
-        return hasExpression() && getExpandedExpression() != getExpression();
-    }
-
-    std::string AssertionResult::getExpandedExpression() const {
-        std::string expr = m_resultData.reconstructExpression();
-        return expr.empty()
-                ? getExpression()
-                : expr;
-    }
-
-    StringRef AssertionResult::getMessage() const {
-        return m_resultData.message;
-    }
-    SourceLineInfo AssertionResult::getSourceInfo() const {
-        return m_info.lineInfo;
-    }
-
-    StringRef AssertionResult::getTestMacroName() const {
-        return m_info.macroName;
-    }
-
-} // end namespace Catch
-
-
-
-#include <fstream>
-
-namespace Catch {
-
-    namespace {
-        static bool enableBazelEnvSupport() {
-#if defined( CATCH_CONFIG_BAZEL_SUPPORT )
-            return true;
-#else
-            return Detail::getEnv( "BAZEL_TEST" ) != nullptr;
-#endif
-        }
-
-        struct bazelShardingOptions {
-            unsigned int shardIndex, shardCount;
-            std::string shardFilePath;
-        };
-
-        static Optional<bazelShardingOptions> readBazelShardingOptions() {
-            const auto bazelShardIndex = Detail::getEnv( "TEST_SHARD_INDEX" );
-            const auto bazelShardTotal = Detail::getEnv( "TEST_TOTAL_SHARDS" );
-            const auto bazelShardInfoFile = Detail::getEnv( "TEST_SHARD_STATUS_FILE" );
-
-
-            const bool has_all =
-                bazelShardIndex && bazelShardTotal && bazelShardInfoFile;
-            if ( !has_all ) {
-                // We provide nice warning message if the input is
-                // misconfigured.
-                auto warn = []( const char* env_var ) {
-                    Catch::cerr()
-                        << "Warning: Bazel shard configuration is missing '"
-                        << env_var << "'. Shard configuration is skipped.\n";
-                };
-                if ( !bazelShardIndex ) {
-                    warn( "TEST_SHARD_INDEX" );
-                }
-                if ( !bazelShardTotal ) {
-                    warn( "TEST_TOTAL_SHARDS" );
-                }
-                if ( !bazelShardInfoFile ) {
-                    warn( "TEST_SHARD_STATUS_FILE" );
-                }
-                return {};
-            }
-
-            auto shardIndex = parseUInt( bazelShardIndex );
-            if ( !shardIndex ) {
-                Catch::cerr()
-                    << "Warning: could not parse 'TEST_SHARD_INDEX' ('" << bazelShardIndex
-                    << "') as unsigned int.\n";
-                return {};
-            }
-            auto shardTotal = parseUInt( bazelShardTotal );
-            if ( !shardTotal ) {
-                Catch::cerr()
-                    << "Warning: could not parse 'TEST_TOTAL_SHARD' ('"
-                    << bazelShardTotal << "') as unsigned int.\n";
-                return {};
-            }
-
-            return bazelShardingOptions{
-                *shardIndex, *shardTotal, bazelShardInfoFile };
-
-        }
-    } // end namespace
-
-
-    bool operator==( ProcessedReporterSpec const& lhs,
-                     ProcessedReporterSpec const& rhs ) {
-        return lhs.name == rhs.name &&
-               lhs.outputFilename == rhs.outputFilename &&
-               lhs.colourMode == rhs.colourMode &&
-               lhs.customOptions == rhs.customOptions;
-    }
-
-    Config::Config( ConfigData const& data ):
-        m_data( data ) {
-        // We need to trim filter specs to avoid trouble with superfluous
-        // whitespace (esp. important for bdd macros, as those are manually
-        // aligned with whitespace).
-
-        for (auto& elem : m_data.testsOrTags) {
-            elem = trim(elem);
-        }
-        for (auto& elem : m_data.sectionsToRun) {
-            elem = trim(elem);
-        }
-
-        // Insert the default reporter if user hasn't asked for a specific one
-        if ( m_data.reporterSpecifications.empty() ) {
-#if defined( CATCH_CONFIG_DEFAULT_REPORTER )
-            const auto default_spec = CATCH_CONFIG_DEFAULT_REPORTER;
-#else
-            const auto default_spec = "console";
-#endif
-            auto parsed = parseReporterSpec(default_spec);
-            CATCH_ENFORCE( parsed,
-                           "Cannot parse the provided default reporter spec: '"
-                               << default_spec << '\'' );
-            m_data.reporterSpecifications.push_back( std::move( *parsed ) );
-        }
-
-        if ( enableBazelEnvSupport() ) {
-            readBazelEnvVars();
-        }
-
-        // Bazel support can modify the test specs, so parsing has to happen
-        // after reading Bazel env vars.
-        TestSpecParser parser( ITagAliasRegistry::get() );
-        if ( !m_data.testsOrTags.empty() ) {
-            m_hasTestFilters = true;
-            for ( auto const& testOrTags : m_data.testsOrTags ) {
-                parser.parse( testOrTags );
-            }
-        }
-        m_testSpec = parser.testSpec();
-
-
-        // We now fixup the reporter specs to handle default output spec,
-        // default colour spec, etc
-        bool defaultOutputUsed = false;
-        for ( auto const& reporterSpec : m_data.reporterSpecifications ) {
-            // We do the default-output check separately, while always
-            // using the default output below to make the code simpler
-            // and avoid superfluous copies.
-            if ( reporterSpec.outputFile().none() ) {
-                CATCH_ENFORCE( !defaultOutputUsed,
-                               "Internal error: cannot use default output for "
-                               "multiple reporters" );
-                defaultOutputUsed = true;
-            }
-
-            m_processedReporterSpecs.push_back( ProcessedReporterSpec{
-                reporterSpec.name(),
-                reporterSpec.outputFile() ? *reporterSpec.outputFile()
-                                          : data.defaultOutputFilename,
-                reporterSpec.colourMode().valueOr( data.defaultColourMode ),
-                reporterSpec.customOptions() } );
-        }
-    }
-
-    Config::~Config() = default;
-
-
-    bool Config::listTests() const          { return m_data.listTests; }
-    bool Config::listTags() const           { return m_data.listTags; }
-    bool Config::listReporters() const      { return m_data.listReporters; }
-    bool Config::listListeners() const      { return m_data.listListeners; }
-
-    std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
-    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
-
-    std::vector<ReporterSpec> const& Config::getReporterSpecs() const {
-        return m_data.reporterSpecifications;
-    }
-
-    std::vector<ProcessedReporterSpec> const&
-    Config::getProcessedReporterSpecs() const {
-        return m_processedReporterSpecs;
-    }
-
-    TestSpec const& Config::testSpec() const { return m_testSpec; }
-    bool Config::hasTestFilters() const { return m_hasTestFilters; }
-
-    bool Config::showHelp() const { return m_data.showHelp; }
-
-    // IConfig interface
-    bool Config::allowThrows() const                   { return !m_data.noThrow; }
-    StringRef Config::name() const { return m_data.name.empty() ? m_data.processName : m_data.name; }
-    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
-    bool Config::warnAboutMissingAssertions() const {
-        return !!( m_data.warnings & WarnAbout::NoAssertions );
-    }
-    bool Config::warnAboutUnmatchedTestSpecs() const {
-        return !!( m_data.warnings & WarnAbout::UnmatchedTestSpec );
-    }
-    bool Config::zeroTestsCountAsSuccess() const       { return m_data.allowZeroTests; }
-    ShowDurations Config::showDurations() const        { return m_data.showDurations; }
-    double Config::minDuration() const                 { return m_data.minDuration; }
-    TestRunOrder Config::runOrder() const              { return m_data.runOrder; }
-    uint32_t Config::rngSeed() const                   { return m_data.rngSeed; }
-    unsigned int Config::shardCount() const            { return m_data.shardCount; }
-    unsigned int Config::shardIndex() const            { return m_data.shardIndex; }
-    ColourMode Config::defaultColourMode() const       { return m_data.defaultColourMode; }
-    bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
-    int Config::abortAfter() const                     { return m_data.abortAfter; }
-    bool Config::showInvisibles() const                { return m_data.showInvisibles; }
-    Verbosity Config::verbosity() const                { return m_data.verbosity; }
-
-    bool Config::skipBenchmarks() const                           { return m_data.skipBenchmarks; }
-    bool Config::benchmarkNoAnalysis() const                      { return m_data.benchmarkNoAnalysis; }
-    unsigned int Config::benchmarkSamples() const                 { return m_data.benchmarkSamples; }
-    double Config::benchmarkConfidenceInterval() const            { return m_data.benchmarkConfidenceInterval; }
-    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
-    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
-
-    void Config::readBazelEnvVars() {
-        // Register a JUnit reporter for Bazel. Bazel sets an environment
-        // variable with the path to XML output. If this file is written to
-        // during test, Bazel will not generate a default XML output.
-        // This allows the XML output file to contain higher level of detail
-        // than what is possible otherwise.
-        const auto bazelOutputFile = Detail::getEnv( "XML_OUTPUT_FILE" );
-
-        if ( bazelOutputFile ) {
-            m_data.reporterSpecifications.push_back(
-                { "junit", std::string( bazelOutputFile ), {}, {} } );
-        }
-
-        const auto bazelTestSpec = Detail::getEnv( "TESTBRIDGE_TEST_ONLY" );
-        if ( bazelTestSpec ) {
-            // Presumably the test spec from environment should overwrite
-            // the one we got from CLI (if we got any)
-            m_data.testsOrTags.clear();
-            m_data.testsOrTags.push_back( bazelTestSpec );
-        }
-
-        const auto bazelShardOptions = readBazelShardingOptions();
-        if ( bazelShardOptions ) {
-            std::ofstream f( bazelShardOptions->shardFilePath,
-                             std::ios_base::out | std::ios_base::trunc );
-            if ( f.is_open() ) {
-                f << "";
-                m_data.shardIndex = bazelShardOptions->shardIndex;
-                m_data.shardCount = bazelShardOptions->shardCount;
-            }
-        }
-    }
-
-} // end namespace Catch
-
-
-
-
-
-namespace Catch {
-    std::uint32_t getSeed() {
-        return getCurrentContext().getConfig()->rngSeed();
-    }
-}
-
-
-
-#include <cassert>
-#include <stack>
-
-namespace Catch {
-
-    ////////////////////////////////////////////////////////////////////////////
-
-
-    ScopedMessage::ScopedMessage( MessageBuilder&& builder ):
-        m_info( CATCH_MOVE(builder.m_info) ) {
-        m_info.message = builder.m_stream.str();
-        getResultCapture().pushScopedMessage( m_info );
-    }
-
-    ScopedMessage::ScopedMessage( ScopedMessage&& old ) noexcept:
-        m_info( CATCH_MOVE( old.m_info ) ) {
-        old.m_moved = true;
-    }
-
-    ScopedMessage::~ScopedMessage() {
-        if ( !uncaught_exceptions() && !m_moved ){
-            getResultCapture().popScopedMessage(m_info);
-        }
-    }
-
-
-    Capturer::Capturer( StringRef macroName,
-                        SourceLineInfo const& lineInfo,
-                        ResultWas::OfType resultType,
-                        StringRef names ):
-        m_resultCapture( getResultCapture() ) {
-        auto trimmed = [&] (size_t start, size_t end) {
-            while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) {
-                ++start;
-            }
-            while (names[end] == ',' || isspace(static_cast<unsigned char>(names[end]))) {
-                --end;
-            }
-            return names.substr(start, end - start + 1);
-        };
-        auto skipq = [&] (size_t start, char quote) {
-            for (auto i = start + 1; i < names.size() ; ++i) {
-                if (names[i] == quote)
-                    return i;
-                if (names[i] == '\\')
-                    ++i;
-            }
-            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
-        };
-
-        size_t start = 0;
-        std::stack<char> openings;
-        for (size_t pos = 0; pos < names.size(); ++pos) {
-            char c = names[pos];
-            switch (c) {
-            case '[':
-            case '{':
-            case '(':
-            // It is basically impossible to disambiguate between
-            // comparison and start of template args in this context
-//            case '<':
-                openings.push(c);
-                break;
-            case ']':
-            case '}':
-            case ')':
-//           case '>':
-                openings.pop();
-                break;
-            case '"':
-            case '\'':
-                pos = skipq(pos, c);
-                break;
-            case ',':
-                if (start != pos && openings.empty()) {
-                    m_messages.emplace_back(macroName, lineInfo, resultType);
-                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
-                    m_messages.back().message += " := ";
-                    start = pos;
-                }
-                break;
-            default:; // noop
-            }
-        }
-        assert(openings.empty() && "Mismatched openings");
-        m_messages.emplace_back(macroName, lineInfo, resultType);
-        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
-        m_messages.back().message += " := ";
-    }
-    Capturer::~Capturer() {
-        if ( !uncaught_exceptions() ){
-            assert( m_captured == m_messages.size() );
-            for( size_t i = 0; i < m_captured; ++i  )
-                m_resultCapture.popScopedMessage( m_messages[i] );
-        }
-    }
-
-    void Capturer::captureValue( size_t index, std::string const& value ) {
-        assert( index < m_messages.size() );
-        m_messages[index].message += value;
-        m_resultCapture.pushScopedMessage( m_messages[index] );
-        m_captured++;
-    }
-
-} // end namespace Catch
-
-
-
-
-#include <exception>
-
-namespace Catch {
-
-    namespace {
-
-        class RegistryHub : public IRegistryHub,
-                            public IMutableRegistryHub,
-                            private Detail::NonCopyable {
-
-        public: // IRegistryHub
-            RegistryHub() = default;
-            ReporterRegistry const& getReporterRegistry() const override {
-                return m_reporterRegistry;
-            }
-            ITestCaseRegistry const& getTestCaseRegistry() const override {
-                return m_testCaseRegistry;
-            }
-            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
-                return m_exceptionTranslatorRegistry;
-            }
-            ITagAliasRegistry const& getTagAliasRegistry() const override {
-                return m_tagAliasRegistry;
-            }
-            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
-                return m_exceptionRegistry;
-            }
-
-        public: // IMutableRegistryHub
-            void registerReporter( std::string const& name, IReporterFactoryPtr factory ) override {
-                m_reporterRegistry.registerReporter( name, CATCH_MOVE(factory) );
-            }
-            void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) override {
-                m_reporterRegistry.registerListener( CATCH_MOVE(factory) );
-            }
-            void registerTest( Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker ) override {
-                m_testCaseRegistry.registerTest( CATCH_MOVE(testInfo), CATCH_MOVE(invoker) );
-            }
-            void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) override {
-                m_exceptionTranslatorRegistry.registerTranslator( CATCH_MOVE(translator) );
-            }
-            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
-                m_tagAliasRegistry.add( alias, tag, lineInfo );
-            }
-            void registerStartupException() noexcept override {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-                m_exceptionRegistry.add(std::current_exception());
-#else
-                CATCH_INTERNAL_ERROR("Attempted to register active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
-#endif
-            }
-            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
-                return m_enumValuesRegistry;
-            }
-
-        private:
-            TestRegistry m_testCaseRegistry;
-            ReporterRegistry m_reporterRegistry;
-            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
-            TagAliasRegistry m_tagAliasRegistry;
-            StartupExceptionRegistry m_exceptionRegistry;
-            Detail::EnumValuesRegistry m_enumValuesRegistry;
-        };
-    }
-
-    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
-
-    IRegistryHub const& getRegistryHub() {
-        return RegistryHubSingleton::get();
-    }
-    IMutableRegistryHub& getMutableRegistryHub() {
-        return RegistryHubSingleton::getMutable();
-    }
-    void cleanUp() {
-        cleanupSingletons();
-        cleanUpContext();
-    }
-    std::string translateActiveException() {
-        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
-    }
-
-
-} // end namespace Catch
-
-
-
-#include <algorithm>
-#include <cassert>
-#include <exception>
-#include <iomanip>
-#include <set>
-
-namespace Catch {
-
-    namespace {
-        static constexpr int TestFailureExitCode = 42;
-        static constexpr int UnspecifiedErrorExitCode = 1;
-        static constexpr int AllTestsSkippedExitCode = 4;
-        static constexpr int NoTestsRunExitCode = 2;
-        static constexpr int UnmatchedTestSpecExitCode = 3;
-        static constexpr int InvalidTestSpecExitCode = 5;
-
-
-        IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) {
-            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, CATCH_MOVE(config));
-            CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << '\'');
-
-            return reporter;
-        }
-
-        IEventListenerPtr prepareReporters(Config const* config) {
-            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()
-                    && config->getProcessedReporterSpecs().size() == 1) {
-                auto const& spec = config->getProcessedReporterSpecs()[0];
-                return createReporter(
-                    spec.name,
-                    ReporterConfig( config,
-                                    makeStream( spec.outputFilename ),
-                                    spec.colourMode,
-                                    spec.customOptions ) );
-            }
-
-            auto multi = Detail::make_unique<MultiReporter>(config);
-
-            auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
-            for (auto const& listener : listeners) {
-                multi->addListener(listener->create(config));
-            }
-
-            for ( auto const& reporterSpec : config->getProcessedReporterSpecs() ) {
-                multi->addReporter( createReporter(
-                    reporterSpec.name,
-                    ReporterConfig( config,
-                                    makeStream( reporterSpec.outputFilename ),
-                                    reporterSpec.colourMode,
-                                    reporterSpec.customOptions ) ) );
-            }
-
-            return multi;
-        }
-
-        class TestGroup {
-        public:
-            explicit TestGroup(IEventListenerPtr&& reporter, Config const* config):
-                m_reporter(reporter.get()),
-                m_config{config},
-                m_context{config, CATCH_MOVE(reporter)} {
-
-                assert( m_config->testSpec().getInvalidSpecs().empty() &&
-                        "Invalid test specs should be handled before running tests" );
-
-                auto const& allTestCases = getAllTestCasesSorted(*m_config);
-                auto const& testSpec = m_config->testSpec();
-                if ( !testSpec.hasFilters() ) {
-                    for ( auto const& test : allTestCases ) {
-                        if ( !test.getTestCaseInfo().isHidden() ) {
-                            m_tests.emplace( &test );
-                        }
-                    }
-                } else {
-                    m_matches =
-                        testSpec.matchesByFilter( allTestCases, *m_config );
-                    for ( auto const& match : m_matches ) {
-                        m_tests.insert( match.tests.begin(),
-                                        match.tests.end() );
-                    }
-                }
-
-                m_tests = createShard(m_tests, m_config->shardCount(), m_config->shardIndex());
-            }
-
-            Totals execute() {
-                Totals totals;
-                for (auto const& testCase : m_tests) {
-                    if (!m_context.aborting())
-                        totals += m_context.runTest(*testCase);
-                    else
-                        m_reporter->skipTest(testCase->getTestCaseInfo());
-                }
-
-                for (auto const& match : m_matches) {
-                    if (match.tests.empty()) {
-                        m_unmatchedTestSpecs = true;
-                        m_reporter->noMatchingTestCases( match.name );
-                    }
-                }
-
-                return totals;
-            }
-
-            bool hadUnmatchedTestSpecs() const {
-                return m_unmatchedTestSpecs;
-            }
-
-
-        private:
-            IEventListener* m_reporter;
-            Config const* m_config;
-            RunContext m_context;
-            std::set<TestCaseHandle const*> m_tests;
-            TestSpec::Matches m_matches;
-            bool m_unmatchedTestSpecs = false;
-        };
-
-        void applyFilenamesAsTags() {
-            for (auto const& testInfo : getRegistryHub().getTestCaseRegistry().getAllInfos()) {
-                testInfo->addFilenameTag();
-            }
-        }
-
-    } // anon namespace
-
-    Session::Session() {
-        static bool alreadyInstantiated = false;
-        if( alreadyInstantiated ) {
-            CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
-            CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
-        }
-
-        // There cannot be exceptions at startup in no-exception mode.
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
-        if ( !exceptions.empty() ) {
-            config();
-            getCurrentMutableContext().setConfig(m_config.get());
-
-            m_startupExceptions = true;
-            auto errStream = makeStream( "%stderr" );
-            auto colourImpl = makeColourImpl(
-                ColourMode::PlatformDefault, errStream.get() );
-            auto guard = colourImpl->guardColour( Colour::Red );
-            errStream->stream() << "Errors occurred during startup!" << '\n';
-            // iterate over all exceptions and notify user
-            for ( const auto& ex_ptr : exceptions ) {
-                try {
-                    std::rethrow_exception(ex_ptr);
-                } catch ( std::exception const& ex ) {
-                    errStream->stream() << TextFlow::Column( ex.what() ).indent(2) << '\n';
-                }
-            }
-        }
-#endif
-
-        alreadyInstantiated = true;
-        m_cli = makeCommandLineParser( m_configData );
-    }
-    Session::~Session() {
-        Catch::cleanUp();
-    }
-
-    void Session::showHelp() const {
-        Catch::cout()
-                << "\nCatch2 v" << libraryVersion() << '\n'
-                << m_cli << '\n'
-                << "For more detailed usage please see the project docs\n\n" << std::flush;
-    }
-    void Session::libIdentify() {
-        Catch::cout()
-                << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
-                << std::left << std::setw(16) << "category: " << "testframework\n"
-                << std::left << std::setw(16) << "framework: " << "Catch2\n"
-                << std::left << std::setw(16) << "version: " << libraryVersion() << '\n' << std::flush;
-    }
-
-    int Session::applyCommandLine( int argc, char const * const * argv ) {
-        if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; }
-
-        auto result = m_cli.parse( Clara::Args( argc, argv ) );
-
-        if( !result ) {
-            config();
-            getCurrentMutableContext().setConfig(m_config.get());
-            auto errStream = makeStream( "%stderr" );
-            auto colour = makeColourImpl( ColourMode::PlatformDefault, errStream.get() );
-
-            errStream->stream()
-                << colour->guardColour( Colour::Red )
-                << "\nError(s) in input:\n"
-                << TextFlow::Column( result.errorMessage() ).indent( 2 )
-                << "\n\n";
-            errStream->stream() << "Run with -? for usage\n\n" << std::flush;
-            return UnspecifiedErrorExitCode;
-        }
-
-        if( m_configData.showHelp )
-            showHelp();
-        if( m_configData.libIdentify )
-            libIdentify();
-
-        m_config.reset();
-        return 0;
-    }
-
-#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
-    int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
-
-        char **utf8Argv = new char *[ argc ];
-
-        for ( int i = 0; i < argc; ++i ) {
-            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
-
-            utf8Argv[ i ] = new char[ bufSize ];
-
-            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
-        }
-
-        int returnCode = applyCommandLine( argc, utf8Argv );
-
-        for ( int i = 0; i < argc; ++i )
-            delete [] utf8Argv[ i ];
-
-        delete [] utf8Argv;
-
-        return returnCode;
-    }
-#endif
-
-    void Session::useConfigData( ConfigData const& configData ) {
-        m_configData = configData;
-        m_config.reset();
-    }
-
-    int Session::run() {
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before starting\n" << std::flush;
-            static_cast<void>(std::getchar());
-        }
-        int exitCode = runInternal();
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << '\n' << std::flush;
-            static_cast<void>(std::getchar());
-        }
-        return exitCode;
-    }
-
-    Clara::Parser const& Session::cli() const {
-        return m_cli;
-    }
-    void Session::cli( Clara::Parser const& newParser ) {
-        m_cli = newParser;
-    }
-    ConfigData& Session::configData() {
-        return m_configData;
-    }
-    Config& Session::config() {
-        if( !m_config )
-            m_config = Detail::make_unique<Config>( m_configData );
-        return *m_config;
-    }
-
-    int Session::runInternal() {
-        if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; }
-
-        if (m_configData.showHelp || m_configData.libIdentify) {
-            return 0;
-        }
-
-        if ( m_configData.shardIndex >= m_configData.shardCount ) {
-            Catch::cerr() << "The shard count (" << m_configData.shardCount
-                          << ") must be greater than the shard index ("
-                          << m_configData.shardIndex << ")\n"
-                          << std::flush;
-            return UnspecifiedErrorExitCode;
-        }
-
-        CATCH_TRY {
-            config(); // Force config to be constructed
-
-            seedRng( *m_config );
-
-            if (m_configData.filenamesAsTags) {
-                applyFilenamesAsTags();
-            }
-
-            // Set up global config instance before we start calling into other functions
-            getCurrentMutableContext().setConfig(m_config.get());
-
-            // Create reporter(s) so we can route listings through them
-            auto reporter = prepareReporters(m_config.get());
-
-            auto const& invalidSpecs = m_config->testSpec().getInvalidSpecs();
-            if ( !invalidSpecs.empty() ) {
-                for ( auto const& spec : invalidSpecs ) {
-                    reporter->reportInvalidTestSpec( spec );
-                }
-                return InvalidTestSpecExitCode;
-            }
-
-
-            // Handle list request
-            if (list(*reporter, *m_config)) {
-                return 0;
-            }
-
-            TestGroup tests { CATCH_MOVE(reporter), m_config.get() };
-            auto const totals = tests.execute();
-
-            if ( tests.hadUnmatchedTestSpecs()
-                && m_config->warnAboutUnmatchedTestSpecs() ) {
-                // UnmatchedTestSpecExitCode
-                return UnmatchedTestSpecExitCode;
-            }
-
-            if ( totals.testCases.total() == 0
-                && !m_config->zeroTestsCountAsSuccess() ) {
-                return NoTestsRunExitCode;
-            }
-
-            if ( totals.testCases.total() > 0 &&
-                 totals.testCases.total() == totals.testCases.skipped
-                && !m_config->zeroTestsCountAsSuccess() ) {
-                return AllTestsSkippedExitCode;
-            }
-
-            if ( totals.assertions.failed ) { return TestFailureExitCode; }
-            return 0;
-
-        }
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-        catch( std::exception& ex ) {
-            Catch::cerr() << ex.what() << '\n' << std::flush;
-            return UnspecifiedErrorExitCode;
-        }
-#endif
-    }
-
-} // end namespace Catch
-
-
-
-
-namespace Catch {
-
-    RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
-        CATCH_TRY {
-            getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
-        } CATCH_CATCH_ALL {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
-    }
-
-}
-
-
-
-#include <cassert>
-#include <cctype>
-#include <algorithm>
-
-namespace Catch {
-
-    namespace {
-        using TCP_underlying_type = uint8_t;
-        static_assert(sizeof(TestCaseProperties) == sizeof(TCP_underlying_type),
-                      "The size of the TestCaseProperties is different from the assumed size");
-
-        constexpr TestCaseProperties operator|(TestCaseProperties lhs, TestCaseProperties rhs) {
-            return static_cast<TestCaseProperties>(
-                static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
-            );
-        }
-
-        constexpr TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProperties rhs) {
-            lhs = static_cast<TestCaseProperties>(
-                static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
-            );
-            return lhs;
-        }
-
-        constexpr TestCaseProperties operator&(TestCaseProperties lhs, TestCaseProperties rhs) {
-            return static_cast<TestCaseProperties>(
-                static_cast<TCP_underlying_type>(lhs) & static_cast<TCP_underlying_type>(rhs)
-            );
-        }
-
-        constexpr bool applies(TestCaseProperties tcp) {
-            static_assert(static_cast<TCP_underlying_type>(TestCaseProperties::None) == 0,
-                          "TestCaseProperties::None must be equal to 0");
-            return tcp != TestCaseProperties::None;
-        }
-
-        TestCaseProperties parseSpecialTag( StringRef tag ) {
-            if( !tag.empty() && tag[0] == '.' )
-                return TestCaseProperties::IsHidden;
-            else if( tag == "!throws"_sr )
-                return TestCaseProperties::Throws;
-            else if( tag == "!shouldfail"_sr )
-                return TestCaseProperties::ShouldFail;
-            else if( tag == "!mayfail"_sr )
-                return TestCaseProperties::MayFail;
-            else if( tag == "!nonportable"_sr )
-                return TestCaseProperties::NonPortable;
-            else if( tag == "!benchmark"_sr )
-                return TestCaseProperties::Benchmark | TestCaseProperties::IsHidden;
-            else
-                return TestCaseProperties::None;
-        }
-        bool isReservedTag( StringRef tag ) {
-            return parseSpecialTag( tag ) == TestCaseProperties::None
-                && tag.size() > 0
-                && !std::isalnum( static_cast<unsigned char>(tag[0]) );
-        }
-        void enforceNotReservedTag( StringRef tag, SourceLineInfo const& _lineInfo ) {
-            CATCH_ENFORCE( !isReservedTag(tag),
-                          "Tag name: [" << tag << "] is not allowed.\n"
-                          << "Tag names starting with non alphanumeric characters are reserved\n"
-                          << _lineInfo );
-        }
-
-        std::string makeDefaultName() {
-            static size_t counter = 0;
-            return "Anonymous test case " + std::to_string(++counter);
-        }
-
-        constexpr StringRef extractFilenamePart(StringRef filename) {
-            size_t lastDot = filename.size();
-            while (lastDot > 0 && filename[lastDot - 1] != '.') {
-                --lastDot;
-            }
-            // In theory we could have filename without any extension in it
-            if ( lastDot == 0 ) { return StringRef(); }
-
-            --lastDot;
-            size_t nameStart = lastDot;
-            while (nameStart > 0 && filename[nameStart - 1] != '/' && filename[nameStart - 1] != '\\') {
-                --nameStart;
-            }
-
-            return filename.substr(nameStart, lastDot - nameStart);
-        }
-
-        // Returns the upper bound on size of extra tags ([#file]+[.])
-        constexpr size_t sizeOfExtraTags(StringRef filepath) {
-            // [.] is 3, [#] is another 3
-            const size_t extras = 3 + 3;
-            return extractFilenamePart(filepath).size() + extras;
-        }
-    } // end unnamed namespace
-
-    bool operator<(  Tag const& lhs, Tag const& rhs ) {
-        Detail::CaseInsensitiveLess cmp;
-        return cmp( lhs.original, rhs.original );
-    }
-    bool operator==( Tag const& lhs, Tag const& rhs ) {
-        Detail::CaseInsensitiveEqualTo cmp;
-        return cmp( lhs.original, rhs.original );
-    }
-
-    Detail::unique_ptr<TestCaseInfo>
-        makeTestCaseInfo(StringRef _className,
-                         NameAndTags const& nameAndTags,
-                         SourceLineInfo const& _lineInfo ) {
-        return Detail::make_unique<TestCaseInfo>(_className, nameAndTags, _lineInfo);
-    }
-
-    TestCaseInfo::TestCaseInfo(StringRef _className,
-                               NameAndTags const& _nameAndTags,
-                               SourceLineInfo const& _lineInfo):
-        name( _nameAndTags.name.empty() ? makeDefaultName() : _nameAndTags.name ),
-        className( _className ),
-        lineInfo( _lineInfo )
-    {
-        StringRef originalTags = _nameAndTags.tags;
-        // We need to reserve enough space to store all of the tags
-        // (including optional hidden tag and filename tag)
-        auto requiredSize = originalTags.size() + sizeOfExtraTags(_lineInfo.file);
-        backingTags.reserve(requiredSize);
-
-        // We cannot copy the tags directly, as we need to normalize
-        // some tags, so that [.foo] is copied as [.][foo].
-        size_t tagStart = 0;
-        size_t tagEnd = 0;
-        bool inTag = false;
-        for (size_t idx = 0; idx < originalTags.size(); ++idx) {
-            auto c = originalTags[idx];
-            if (c == '[') {
-                CATCH_ENFORCE(
-                    !inTag,
-                    "Found '[' inside a tag while registering test case '"
-                        << _nameAndTags.name << "' at " << _lineInfo );
-
-                inTag = true;
-                tagStart = idx;
-            }
-            if (c == ']') {
-                CATCH_ENFORCE(
-                    inTag,
-                    "Found unmatched ']' while registering test case '"
-                        << _nameAndTags.name << "' at " << _lineInfo );
-
-                inTag = false;
-                tagEnd = idx;
-                assert(tagStart < tagEnd);
-
-                // We need to check the tag for special meanings, copy
-                // it over to backing storage and actually reference the
-                // backing storage in the saved tags
-                StringRef tagStr = originalTags.substr(tagStart+1, tagEnd - tagStart - 1);
-                CATCH_ENFORCE( !tagStr.empty(),
-                               "Found an empty tag while registering test case '"
-                                   << _nameAndTags.name << "' at "
-                                   << _lineInfo );
-
-                enforceNotReservedTag(tagStr, lineInfo);
-                properties |= parseSpecialTag(tagStr);
-                // When copying a tag to the backing storage, we need to
-                // check if it is a merged hide tag, such as [.foo], and
-                // if it is, we need to handle it as if it was [foo].
-                if (tagStr.size() > 1 && tagStr[0] == '.') {
-                    tagStr = tagStr.substr(1, tagStr.size() - 1);
-                }
-                // We skip over dealing with the [.] tag, as we will add
-                // it later unconditionally and then sort and unique all
-                // the tags.
-                internalAppendTag(tagStr);
-            }
-        }
-        CATCH_ENFORCE( !inTag,
-                       "Found an unclosed tag while registering test case '"
-                           << _nameAndTags.name << "' at " << _lineInfo );
-
-
-        // Add [.] if relevant
-        if (isHidden()) {
-            internalAppendTag("."_sr);
-        }
-
-        // Sort and prepare tags
-        std::sort(begin(tags), end(tags));
-        tags.erase(std::unique(begin(tags), end(tags)),
-                   end(tags));
-    }
-
-    bool TestCaseInfo::isHidden() const {
-        return applies( properties & TestCaseProperties::IsHidden );
-    }
-    bool TestCaseInfo::throws() const {
-        return applies( properties & TestCaseProperties::Throws );
-    }
-    bool TestCaseInfo::okToFail() const {
-        return applies( properties & (TestCaseProperties::ShouldFail | TestCaseProperties::MayFail ) );
-    }
-    bool TestCaseInfo::expectedToFail() const {
-        return applies( properties & (TestCaseProperties::ShouldFail) );
-    }
-
-    void TestCaseInfo::addFilenameTag() {
-        std::string combined("#");
-        combined += extractFilenamePart(lineInfo.file);
-        internalAppendTag(combined);
-    }
-
-    std::string TestCaseInfo::tagsAsString() const {
-        std::string ret;
-        // '[' and ']' per tag
-        std::size_t full_size = 2 * tags.size();
-        for (const auto& tag : tags) {
-            full_size += tag.original.size();
-        }
-        ret.reserve(full_size);
-        for (const auto& tag : tags) {
-            ret.push_back('[');
-            ret += tag.original;
-            ret.push_back(']');
-        }
-
-        return ret;
-    }
-
-    void TestCaseInfo::internalAppendTag(StringRef tagStr) {
-        backingTags += '[';
-        const auto backingStart = backingTags.size();
-        backingTags += tagStr;
-        const auto backingEnd = backingTags.size();
-        backingTags += ']';
-        tags.emplace_back(StringRef(backingTags.c_str() + backingStart, backingEnd - backingStart));
-    }
-
-    bool operator<( TestCaseInfo const& lhs, TestCaseInfo const& rhs ) {
-        // We want to avoid redoing the string comparisons multiple times,
-        // so we store the result of a three-way comparison before using
-        // it in the actual comparison logic.
-        const auto cmpName = lhs.name.compare( rhs.name );
-        if ( cmpName != 0 ) {
-            return cmpName < 0;
-        }
-        const auto cmpClassName = lhs.className.compare( rhs.className );
-        if ( cmpClassName != 0 ) {
-            return cmpClassName < 0;
-        }
-        return lhs.tags < rhs.tags;
-    }
-
-} // end namespace Catch
-
-
-
-#include <algorithm>
-#include <string>
-#include <vector>
-#include <ostream>
-
-namespace Catch {
-
-    TestSpec::Pattern::Pattern( std::string const& name )
-    : m_name( name )
-    {}
-
-    TestSpec::Pattern::~Pattern() = default;
-
-    std::string const& TestSpec::Pattern::name() const {
-        return m_name;
-    }
-
-
-    TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
-    : Pattern( filterString )
-    , m_wildcardPattern( toLower( name ), CaseSensitive::No )
-    {}
-
-    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
-        return m_wildcardPattern.matches( testCase.name );
-    }
-
-    void TestSpec::NamePattern::serializeTo( std::ostream& out ) const {
-        out << '"' << name() << '"';
-    }
-
-
-    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
-    : Pattern( filterString )
-    , m_tag( tag )
-    {}
-
-    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
-        return std::find( begin( testCase.tags ),
-                          end( testCase.tags ),
-                          Tag( m_tag ) ) != end( testCase.tags );
-    }
-
-    void TestSpec::TagPattern::serializeTo( std::ostream& out ) const {
-        out << name();
-    }
-
-    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
-        bool should_use = !testCase.isHidden();
-        for (auto const& pattern : m_required) {
-            should_use = true;
-            if (!pattern->matches(testCase)) {
-                return false;
-            }
-        }
-        for (auto const& pattern : m_forbidden) {
-            if (pattern->matches(testCase)) {
-                return false;
-            }
-        }
-        return should_use;
-    }
-
-    void TestSpec::Filter::serializeTo( std::ostream& out ) const {
-        bool first = true;
-        for ( auto const& pattern : m_required ) {
-            if ( !first ) {
-                out << ' ';
-            }
-            out << *pattern;
-            first = false;
-        }
-        for ( auto const& pattern : m_forbidden ) {
-            if ( !first ) {
-                out << ' ';
-            }
-            out << *pattern;
-            first = false;
-        }
-    }
-
-
-    std::string TestSpec::extractFilterName( Filter const& filter ) {
-        Catch::ReusableStringStream sstr;
-        sstr << filter;
-        return sstr.str();
-    }
-
-    bool TestSpec::hasFilters() const {
-        return !m_filters.empty();
-    }
-
-    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
-        return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
-    }
-
-    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const {
-        Matches matches;
-        matches.reserve( m_filters.size() );
-        for ( auto const& filter : m_filters ) {
-            std::vector<TestCaseHandle const*> currentMatches;
-            for ( auto const& test : testCases )
-                if ( isThrowSafe( test, config ) &&
-                     filter.matches( test.getTestCaseInfo() ) )
-                    currentMatches.emplace_back( &test );
-            matches.push_back(
-                FilterMatch{ extractFilterName( filter ), currentMatches } );
-        }
-        return matches;
-    }
-
-    const TestSpec::vectorStrings& TestSpec::getInvalidSpecs() const {
-        return m_invalidSpecs;
-    }
-
-    void TestSpec::serializeTo( std::ostream& out ) const {
-        bool first = true;
-        for ( auto const& filter : m_filters ) {
-            if ( !first ) {
-                out << ',';
-            }
-            out << filter;
-            first = false;
-        }
-    }
-
-}
-
-
-
-#include <chrono>
-
-namespace Catch {
-
-    namespace {
-        static auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
-            return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
-        }
-    } // end unnamed namespace
-
-    void Timer::start() {
-       m_nanoseconds = getCurrentNanosecondsSinceEpoch();
-    }
-    auto Timer::getElapsedNanoseconds() const -> uint64_t {
-        return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
-    }
-    auto Timer::getElapsedMicroseconds() const -> uint64_t {
-        return getElapsedNanoseconds()/1000;
-    }
-    auto Timer::getElapsedMilliseconds() const -> unsigned int {
-        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
-    }
-    auto Timer::getElapsedSeconds() const -> double {
-        return getElapsedMicroseconds()/1000000.0;
-    }
-
-
-} // namespace Catch
-
-
-
-
-#include <cmath>
-#include <iomanip>
-
-namespace Catch {
-
-namespace Detail {
-
-    namespace {
-        const int hexThreshold = 255;
-
-        struct Endianness {
-            enum Arch { Big, Little };
-
-            static Arch which() {
-                int one = 1;
-                // If the lowest byte we read is non-zero, we can assume
-                // that little endian format is used.
-                auto value = *reinterpret_cast<char*>(&one);
-                return value ? Little : Big;
-            }
-        };
-
-        template<typename T>
-        std::string fpToString(T value, int precision) {
-            if (Catch::isnan(value)) {
-                return "nan";
-            }
-
-            ReusableStringStream rss;
-            rss << std::setprecision(precision)
-                << std::fixed
-                << value;
-            std::string d = rss.str();
-            std::size_t i = d.find_last_not_of('0');
-            if (i != std::string::npos && i != d.size() - 1) {
-                if (d[i] == '.')
-                    i++;
-                d = d.substr(0, i + 1);
-            }
-            return d;
-        }
-    } // end unnamed namespace
-
-    std::string convertIntoString(StringRef string, bool escapeInvisibles) {
-        std::string ret;
-        // This is enough for the "don't escape invisibles" case, and a good
-        // lower bound on the "escape invisibles" case.
-        ret.reserve(string.size() + 2);
-
-        if (!escapeInvisibles) {
-            ret += '"';
-            ret += string;
-            ret += '"';
-            return ret;
-        }
-
-        ret += '"';
-        for (char c : string) {
-            switch (c) {
-            case '\r':
-                ret.append("\\r");
-                break;
-            case '\n':
-                ret.append("\\n");
-                break;
-            case '\t':
-                ret.append("\\t");
-                break;
-            case '\f':
-                ret.append("\\f");
-                break;
-            default:
-                ret.push_back(c);
-                break;
-            }
-        }
-        ret += '"';
-
-        return ret;
-    }
-
-    std::string convertIntoString(StringRef string) {
-        return convertIntoString(string, getCurrentContext().getConfig()->showInvisibles());
-    }
-
-    std::string rawMemoryToString( const void *object, std::size_t size ) {
-        // Reverse order for little endian architectures
-        int i = 0, end = static_cast<int>( size ), inc = 1;
-        if( Endianness::which() == Endianness::Little ) {
-            i = end-1;
-            end = inc = -1;
-        }
-
-        unsigned char const *bytes = static_cast<unsigned char const *>(object);
-        ReusableStringStream rss;
-        rss << "0x" << std::setfill('0') << std::hex;
-        for( ; i != end; i += inc )
-             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
-       return rss.str();
-    }
-} // end Detail namespace
-
-
-
-//// ======================================================= ////
-//
-//   Out-of-line defs for full specialization of StringMaker
-//
-//// ======================================================= ////
-
-std::string StringMaker<std::string>::convert(const std::string& str) {
-    return Detail::convertIntoString( str );
-}
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-std::string StringMaker<std::string_view>::convert(std::string_view str) {
-    return Detail::convertIntoString( StringRef( str.data(), str.size() ) );
-}
-#endif
-
-std::string StringMaker<char const*>::convert(char const* str) {
-    if (str) {
-        return Detail::convertIntoString( str );
-    } else {
-        return{ "{null string}" };
-    }
-}
-std::string StringMaker<char*>::convert(char* str) { // NOLINT(readability-non-const-parameter)
-    if (str) {
-        return Detail::convertIntoString( str );
-    } else {
-        return{ "{null string}" };
-    }
-}
-
-#ifdef CATCH_CONFIG_WCHAR
-std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
-    std::string s;
-    s.reserve(wstr.size());
-    for (auto c : wstr) {
-        s += (c <= 0xff) ? static_cast<char>(c) : '?';
-    }
-    return ::Catch::Detail::stringify(s);
-}
-
-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
-    return StringMaker<std::wstring>::convert(std::wstring(str));
-}
-# endif
-
-std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-#endif
-
-#if defined(CATCH_CONFIG_CPP17_BYTE)
-#include <cstddef>
-std::string StringMaker<std::byte>::convert(std::byte value) {
-    return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
-}
-#endif // defined(CATCH_CONFIG_CPP17_BYTE)
-
-std::string StringMaker<int>::convert(int value) {
-    return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long>::convert(long value) {
-    return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long long>::convert(long long value) {
-    ReusableStringStream rss;
-    rss << value;
-    if (value > Detail::hexThreshold) {
-        rss << " (0x" << std::hex << value << ')';
-    }
-    return rss.str();
-}
-
-std::string StringMaker<unsigned int>::convert(unsigned int value) {
-    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long>::convert(unsigned long value) {
-    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
-    ReusableStringStream rss;
-    rss << value;
-    if (value > Detail::hexThreshold) {
-        rss << " (0x" << std::hex << value << ')';
-    }
-    return rss.str();
-}
-
-std::string StringMaker<signed char>::convert(signed char value) {
-    if (value == '\r') {
-        return "'\\r'";
-    } else if (value == '\f') {
-        return "'\\f'";
-    } else if (value == '\n') {
-        return "'\\n'";
-    } else if (value == '\t') {
-        return "'\\t'";
-    } else if ('\0' <= value && value < ' ') {
-        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
-    } else {
-        char chstr[] = "' '";
-        chstr[1] = value;
-        return chstr;
-    }
-}
-std::string StringMaker<char>::convert(char c) {
-    return ::Catch::Detail::stringify(static_cast<signed char>(c));
-}
-std::string StringMaker<unsigned char>::convert(unsigned char value) {
-    return ::Catch::Detail::stringify(static_cast<char>(value));
-}
-
-int StringMaker<float>::precision = std::numeric_limits<float>::max_digits10;
-
-std::string StringMaker<float>::convert(float value) {
-    return Detail::fpToString(value, precision) + 'f';
-}
-
-int StringMaker<double>::precision = std::numeric_limits<double>::max_digits10;
-
-std::string StringMaker<double>::convert(double value) {
-    return Detail::fpToString(value, precision);
-}
-
-} // end namespace Catch
-
-
-
-namespace Catch {
-
-    Counts Counts::operator - ( Counts const& other ) const {
-        Counts diff;
-        diff.passed = passed - other.passed;
-        diff.failed = failed - other.failed;
-        diff.failedButOk = failedButOk - other.failedButOk;
-        diff.skipped = skipped - other.skipped;
-        return diff;
-    }
-
-    Counts& Counts::operator += ( Counts const& other ) {
-        passed += other.passed;
-        failed += other.failed;
-        failedButOk += other.failedButOk;
-        skipped += other.skipped;
-        return *this;
-    }
-
-    std::uint64_t Counts::total() const {
-        return passed + failed + failedButOk + skipped;
-    }
-    bool Counts::allPassed() const {
-        return failed == 0 && failedButOk == 0 && skipped == 0;
-    }
-    bool Counts::allOk() const {
-        return failed == 0;
-    }
-
-    Totals Totals::operator - ( Totals const& other ) const {
-        Totals diff;
-        diff.assertions = assertions - other.assertions;
-        diff.testCases = testCases - other.testCases;
-        return diff;
-    }
-
-    Totals& Totals::operator += ( Totals const& other ) {
-        assertions += other.assertions;
-        testCases += other.testCases;
-        return *this;
-    }
-
-    Totals Totals::delta( Totals const& prevTotals ) const {
-        Totals diff = *this - prevTotals;
-        if( diff.assertions.failed > 0 )
-            ++diff.testCases.failed;
-        else if( diff.assertions.failedButOk > 0 )
-            ++diff.testCases.failedButOk;
-        else if ( diff.assertions.skipped > 0 )
-            ++ diff.testCases.skipped;
-        else
-            ++diff.testCases.passed;
-        return diff;
-    }
-
-}
-
-
-
-
-namespace Catch {
-    namespace Detail {
-        void registerTranslatorImpl(
-            Detail::unique_ptr<IExceptionTranslator>&& translator ) {
-            getMutableRegistryHub().registerTranslator(
-                CATCH_MOVE( translator ) );
-        }
-    } // namespace Detail
-} // namespace Catch
-
-
-#include <ostream>
-
-namespace Catch {
-
-    Version::Version
-        (   unsigned int _majorVersion,
-            unsigned int _minorVersion,
-            unsigned int _patchNumber,
-            char const * const _branchName,
-            unsigned int _buildNumber )
-    :   majorVersion( _majorVersion ),
-        minorVersion( _minorVersion ),
-        patchNumber( _patchNumber ),
-        branchName( _branchName ),
-        buildNumber( _buildNumber )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, Version const& version ) {
-        os  << version.majorVersion << '.'
-            << version.minorVersion << '.'
-            << version.patchNumber;
-        // branchName is never null -> 0th char is \0 if it is empty
-        if (version.branchName[0]) {
-            os << '-' << version.branchName
-               << '.' << version.buildNumber;
-        }
-        return os;
-    }
-
-    Version const& libraryVersion() {
-        static Version version( 3, 7, 1, "", 0 );
-        return version;
-    }
-
-}
-
-
-
-
-namespace Catch {
-
-    const char* GeneratorException::what() const noexcept {
-        return m_msg;
-    }
-
-} // end namespace Catch
-
-
-
-
-namespace Catch {
-
-    IGeneratorTracker::~IGeneratorTracker() = default;
-
-namespace Generators {
-
-namespace Detail {
-
-    [[noreturn]]
-    void throw_generator_exception(char const* msg) {
-        Catch::throw_exception(GeneratorException{ msg });
-    }
-} // end namespace Detail
-
-    GeneratorUntypedBase::~GeneratorUntypedBase() = default;
-
-    IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, SourceLineInfo const& lineInfo ) {
-        return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo );
-    }
-
-    IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
-                                 SourceLineInfo lineInfo,
-                                 GeneratorBasePtr&& generator ) {
-        return getResultCapture().createGeneratorTracker(
-            generatorName, lineInfo, CATCH_MOVE( generator ) );
-    }
-
-} // namespace Generators
-} // namespace Catch
-
-
-
-
-#include <random>
-
-namespace Catch {
-    namespace Generators {
-        namespace Detail {
-            std::uint32_t getSeed() { return sharedRng()(); }
-        } // namespace Detail
-
-        struct RandomFloatingGenerator<long double>::PImpl {
-            PImpl( long double a, long double b, uint32_t seed ):
-                rng( seed ), dist( a, b ) {}
-
-            Catch::SimplePcg32 rng;
-            std::uniform_real_distribution<long double> dist;
-        };
-
-        RandomFloatingGenerator<long double>::RandomFloatingGenerator(
-            long double a, long double b, std::uint32_t seed) :
-            m_pimpl(Catch::Detail::make_unique<PImpl>(a, b, seed)) {
-            static_cast<void>( next() );
-        }
-
-        RandomFloatingGenerator<long double>::~RandomFloatingGenerator() =
-            default;
-        bool RandomFloatingGenerator<long double>::next() {
-            m_current_number = m_pimpl->dist( m_pimpl->rng );
-            return true;
-        }
-    } // namespace Generators
-} // namespace Catch
-
-
-
-
-namespace Catch {
-    IResultCapture::~IResultCapture() = default;
-}
-
-
-
-
-namespace Catch {
-    IConfig::~IConfig() = default;
-}
-
-
-
-
-namespace Catch {
-    IExceptionTranslator::~IExceptionTranslator() = default;
-    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
-}
-
-
-
-#include <string>
-
-namespace Catch {
-    namespace Generators {
-
-        bool GeneratorUntypedBase::countedNext() {
-            auto ret = next();
-            if ( ret ) {
-                m_stringReprCache.clear();
-                ++m_currentElementIndex;
-            }
-            return ret;
-        }
-
-        StringRef GeneratorUntypedBase::currentElementAsString() const {
-            if ( m_stringReprCache.empty() ) {
-                m_stringReprCache = stringifyImpl();
-            }
-            return m_stringReprCache;
-        }
-
-    } // namespace Generators
-} // namespace Catch
-
-
-
-
-namespace Catch {
-    IRegistryHub::~IRegistryHub() = default;
-    IMutableRegistryHub::~IMutableRegistryHub() = default;
-}
-
-
-
-#include <cassert>
-
-namespace Catch {
-
-    ReporterConfig::ReporterConfig(
-        IConfig const* _fullConfig,
-        Detail::unique_ptr<IStream> _stream,
-        ColourMode colourMode,
-        std::map<std::string, std::string> customOptions ):
-        m_stream( CATCH_MOVE(_stream) ),
-        m_fullConfig( _fullConfig ),
-        m_colourMode( colourMode ),
-        m_customOptions( CATCH_MOVE( customOptions ) ) {}
-
-    Detail::unique_ptr<IStream> ReporterConfig::takeStream() && {
-        assert( m_stream );
-        return CATCH_MOVE( m_stream );
-    }
-    IConfig const * ReporterConfig::fullConfig() const { return m_fullConfig; }
-    ColourMode ReporterConfig::colourMode() const { return m_colourMode; }
-
-    std::map<std::string, std::string> const&
-    ReporterConfig::customOptions() const {
-        return m_customOptions;
-    }
-
-    ReporterConfig::~ReporterConfig() = default;
-
-    AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
-                                    std::vector<MessageInfo> const& _infoMessages,
-                                    Totals const& _totals )
-    :   assertionResult( _assertionResult ),
-        infoMessages( _infoMessages ),
-        totals( _totals )
-    {
-        if( assertionResult.hasMessage() ) {
-            // Copy message into messages list.
-            // !TBD This should have been done earlier, somewhere
-            MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
-            builder.m_info.message = static_cast<std::string>(assertionResult.getMessage());
-
-            infoMessages.push_back( CATCH_MOVE(builder.m_info) );
-        }
-    }
-
-    SectionStats::SectionStats(  SectionInfo&& _sectionInfo,
-                                 Counts const& _assertions,
-                                 double _durationInSeconds,
-                                 bool _missingAssertions )
-    :   sectionInfo( CATCH_MOVE(_sectionInfo) ),
-        assertions( _assertions ),
-        durationInSeconds( _durationInSeconds ),
-        missingAssertions( _missingAssertions )
-    {}
-
-
-    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
-                                   Totals const& _totals,
-                                   std::string&& _stdOut,
-                                   std::string&& _stdErr,
-                                   bool _aborting )
-    : testInfo( &_testInfo ),
-        totals( _totals ),
-        stdOut( CATCH_MOVE(_stdOut) ),
-        stdErr( CATCH_MOVE(_stdErr) ),
-        aborting( _aborting )
-    {}
-
-
-    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
-                    Totals const& _totals,
-                    bool _aborting )
-    :   runInfo( _runInfo ),
-        totals( _totals ),
-        aborting( _aborting )
-    {}
-
-    IEventListener::~IEventListener() = default;
-
-} // end namespace Catch
-
-
-
-
-namespace Catch {
-    IReporterFactory::~IReporterFactory() = default;
-    EventListenerFactory::~EventListenerFactory() = default;
-}
-
-
-
-
-namespace Catch {
-    ITestCaseRegistry::~ITestCaseRegistry() = default;
-}
-
-
-
-namespace Catch {
-
-    AssertionHandler::AssertionHandler
-        (   StringRef macroName,
-            SourceLineInfo const& lineInfo,
-            StringRef capturedExpression,
-            ResultDisposition::Flags resultDisposition )
-    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
-        m_resultCapture( getResultCapture() )
-    {
-        m_resultCapture.notifyAssertionStarted( m_assertionInfo );
-    }
-
-    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
-        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
-    }
-    void AssertionHandler::handleMessage(ResultWas::OfType resultType, std::string&& message) {
-        m_resultCapture.handleMessage( m_assertionInfo, resultType, CATCH_MOVE(message), m_reaction );
-    }
-
-    auto AssertionHandler::allowThrows() const -> bool {
-        return getCurrentContext().getConfig()->allowThrows();
-    }
-
-    void AssertionHandler::complete() {
-        m_completed = true;
-        if( m_reaction.shouldDebugBreak ) {
-
-            // If you find your debugger stopping you here then go one level up on the
-            // call-stack for the code that caused it (typically a failed assertion)
-
-            // (To go back to the test and change execution, jump over the throw, next)
-            CATCH_BREAK_INTO_DEBUGGER();
-        }
-        if (m_reaction.shouldThrow) {
-            throw_test_failure_exception();
-        }
-        if ( m_reaction.shouldSkip ) {
-            throw_test_skip_exception();
-        }
-    }
-
-    void AssertionHandler::handleUnexpectedInflightException() {
-        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
-    }
-
-    void AssertionHandler::handleExceptionThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-    void AssertionHandler::handleExceptionNotThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-
-    void AssertionHandler::handleUnexpectedExceptionNotThrown() {
-        m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
-    }
-
-    void AssertionHandler::handleThrowingCallSkipped() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-
-    // This is the overload that takes a string and infers the Equals matcher from it
-    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str ) {
-        handleExceptionMatchExpr( handler, Matchers::Equals( str ) );
-    }
-
-} // namespace Catch
-
-
-
-
-#include <algorithm>
-
-namespace Catch {
-    namespace Detail {
-
-        bool CaseInsensitiveLess::operator()( StringRef lhs,
-                                              StringRef rhs ) const {
-            return std::lexicographical_compare(
-                lhs.begin(), lhs.end(),
-                rhs.begin(), rhs.end(),
-                []( char l, char r ) { return toLower( l ) < toLower( r ); } );
-        }
-
-        bool
-        CaseInsensitiveEqualTo::operator()( StringRef lhs,
-                                            StringRef rhs ) const {
-            return std::equal(
-                lhs.begin(), lhs.end(),
-                rhs.begin(), rhs.end(),
-                []( char l, char r ) { return toLower( l ) == toLower( r ); } );
-        }
-
-    } // namespace Detail
-} // namespace Catch
-
-
-
-
-#include <algorithm>
-#include <ostream>
-
-namespace {
-    bool isOptPrefix( char c ) {
-        return c == '-'
-#ifdef CATCH_PLATFORM_WINDOWS
-               || c == '/'
-#endif
-            ;
-    }
-
-    Catch::StringRef normaliseOpt( Catch::StringRef optName ) {
-        if ( optName[0] == '-'
-#if defined(CATCH_PLATFORM_WINDOWS)
-             || optName[0] == '/'
-#endif
-        ) {
-            return optName.substr( 1, optName.size() );
-        }
-
-        return optName;
-    }
-
-    static size_t find_first_separator(Catch::StringRef sr) {
-        auto is_separator = []( char c ) {
-            return c == ' ' || c == ':' || c == '=';
-        };
-        size_t pos = 0;
-        while (pos < sr.size()) {
-            if (is_separator(sr[pos])) { return pos; }
-            ++pos;
-        }
-
-        return Catch::StringRef::npos;
-    }
-
-} // namespace
-
-namespace Catch {
-    namespace Clara {
-        namespace Detail {
-
-            void TokenStream::loadBuffer() {
-                m_tokenBuffer.clear();
-
-                // Skip any empty strings
-                while ( it != itEnd && it->empty() ) {
-                    ++it;
-                }
-
-                if ( it != itEnd ) {
-                    StringRef next = *it;
-                    if ( isOptPrefix( next[0] ) ) {
-                        auto delimiterPos = find_first_separator(next);
-                        if ( delimiterPos != StringRef::npos ) {
-                            m_tokenBuffer.push_back(
-                                { TokenType::Option,
-                                  next.substr( 0, delimiterPos ) } );
-                            m_tokenBuffer.push_back(
-                                { TokenType::Argument,
-                                  next.substr( delimiterPos + 1, next.size() ) } );
-                        } else {
-                            if ( next.size() > 1 && next[1] != '-' && next.size() > 2 ) {
-                                // Combined short args, e.g. "-ab" for "-a -b"
-                                for ( size_t i = 1; i < next.size(); ++i ) {
-                                    m_tokenBuffer.push_back(
-                                        { TokenType::Option,
-                                          next.substr( i, 1 ) } );
-                                }
-                            } else {
-                                m_tokenBuffer.push_back(
-                                    { TokenType::Option, next } );
-                            }
-                        }
-                    } else {
-                        m_tokenBuffer.push_back(
-                            { TokenType::Argument, next } );
-                    }
-                }
-            }
-
-            TokenStream::TokenStream( Args const& args ):
-                TokenStream( args.m_args.begin(), args.m_args.end() ) {}
-
-            TokenStream::TokenStream( Iterator it_, Iterator itEnd_ ):
-                it( it_ ), itEnd( itEnd_ ) {
-                loadBuffer();
-            }
-
-            TokenStream& TokenStream::operator++() {
-                if ( m_tokenBuffer.size() >= 2 ) {
-                    m_tokenBuffer.erase( m_tokenBuffer.begin() );
-                } else {
-                    if ( it != itEnd )
-                        ++it;
-                    loadBuffer();
-                }
-                return *this;
-            }
-
-            ParserResult convertInto( std::string const& source,
-                                      std::string& target ) {
-                target = source;
-                return ParserResult::ok( ParseResultType::Matched );
-            }
-
-            ParserResult convertInto( std::string const& source,
-                                      bool& target ) {
-                std::string srcLC = toLower( source );
-
-                if ( srcLC == "y" || srcLC == "1" || srcLC == "true" ||
-                     srcLC == "yes" || srcLC == "on" ) {
-                    target = true;
-                } else if ( srcLC == "n" || srcLC == "0" || srcLC == "false" ||
-                            srcLC == "no" || srcLC == "off" ) {
-                    target = false;
-                } else {
-                    return ParserResult::runtimeError(
-                        "Expected a boolean value but did not recognise: '" +
-                        source + '\'' );
-                }
-                return ParserResult::ok( ParseResultType::Matched );
-            }
-
-            size_t ParserBase::cardinality() const { return 1; }
-
-            InternalParseResult ParserBase::parse( Args const& args ) const {
-                return parse( static_cast<std::string>(args.exeName()), TokenStream( args ) );
-            }
-
-            ParseState::ParseState( ParseResultType type,
-                                    TokenStream remainingTokens ):
-                m_type( type ), m_remainingTokens( CATCH_MOVE(remainingTokens) ) {}
-
-            ParserResult BoundFlagRef::setFlag( bool flag ) {
-                m_ref = flag;
-                return ParserResult::ok( ParseResultType::Matched );
-            }
-
-            ResultBase::~ResultBase() = default;
-
-            bool BoundRef::isContainer() const { return false; }
-
-            bool BoundRef::isFlag() const { return false; }
-
-            bool BoundFlagRefBase::isFlag() const { return true; }
-
-} // namespace Detail
-
-        Detail::InternalParseResult Arg::parse(std::string const&,
-                                               Detail::TokenStream tokens) const {
-            auto validationResult = validate();
-            if (!validationResult)
-                return Detail::InternalParseResult(validationResult);
-
-            auto token = *tokens;
-            if (token.type != Detail::TokenType::Argument)
-                return Detail::InternalParseResult::ok(Detail::ParseState(
-                    ParseResultType::NoMatch, CATCH_MOVE(tokens)));
-
-            assert(!m_ref->isFlag());
-            auto valueRef =
-                static_cast<Detail::BoundValueRefBase*>(m_ref.get());
-
-            auto result = valueRef->setValue(static_cast<std::string>(token.token));
-            if ( !result )
-                return Detail::InternalParseResult( result );
-            else
-                return Detail::InternalParseResult::ok(
-                    Detail::ParseState( ParseResultType::Matched,
-                                        CATCH_MOVE( ++tokens ) ) );
-        }
-
-        Opt::Opt(bool& ref) :
-            ParserRefImpl(std::make_shared<Detail::BoundFlagRef>(ref)) {}
-
-        Detail::HelpColumns Opt::getHelpColumns() const {
-            ReusableStringStream oss;
-            bool first = true;
-            for (auto const& opt : m_optNames) {
-                if (first)
-                    first = false;
-                else
-                    oss << ", ";
-                oss << opt;
-            }
-            if (!m_hint.empty())
-                oss << " <" << m_hint << '>';
-            return { oss.str(), m_description };
-        }
-
-        bool Opt::isMatch(StringRef optToken) const {
-            auto normalisedToken = normaliseOpt(optToken);
-            for (auto const& name : m_optNames) {
-                if (normaliseOpt(name) == normalisedToken)
-                    return true;
-            }
-            return false;
-        }
-
-        Detail::InternalParseResult Opt::parse(std::string const&,
-                                       Detail::TokenStream tokens) const {
-            auto validationResult = validate();
-            if (!validationResult)
-                return Detail::InternalParseResult(validationResult);
-
-            if (tokens &&
-                tokens->type == Detail::TokenType::Option) {
-                auto const& token = *tokens;
-                if (isMatch(token.token)) {
-                    if (m_ref->isFlag()) {
-                        auto flagRef =
-                            static_cast<Detail::BoundFlagRefBase*>(
-                                m_ref.get());
-                        auto result = flagRef->setFlag(true);
-                        if (!result)
-                            return Detail::InternalParseResult(result);
-                        if (result.value() ==
-                            ParseResultType::ShortCircuitAll)
-                            return Detail::InternalParseResult::ok(Detail::ParseState(
-                                result.value(), CATCH_MOVE(tokens)));
-                    } else {
-                        auto valueRef =
-                            static_cast<Detail::BoundValueRefBase*>(
-                                m_ref.get());
-                        ++tokens;
-                        if (!tokens)
-                            return Detail::InternalParseResult::runtimeError(
-                                "Expected argument following " +
-                                token.token);
-                        auto const& argToken = *tokens;
-                        if (argToken.type != Detail::TokenType::Argument)
-                            return Detail::InternalParseResult::runtimeError(
-                                "Expected argument following " +
-                                token.token);
-                        const auto result = valueRef->setValue(static_cast<std::string>(argToken.token));
-                        if (!result)
-                            return Detail::InternalParseResult(result);
-                        if (result.value() ==
-                            ParseResultType::ShortCircuitAll)
-                            return Detail::InternalParseResult::ok(Detail::ParseState(
-                                result.value(), CATCH_MOVE(tokens)));
-                    }
-                    return Detail::InternalParseResult::ok(Detail::ParseState(
-                        ParseResultType::Matched, CATCH_MOVE(++tokens)));
-                }
-            }
-            return Detail::InternalParseResult::ok(
-                Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens)));
-        }
-
-        Detail::Result Opt::validate() const {
-            if (m_optNames.empty())
-                return Detail::Result::logicError("No options supplied to Opt");
-            for (auto const& name : m_optNames) {
-                if (name.empty())
-                    return Detail::Result::logicError(
-                        "Option name cannot be empty");
-#ifdef CATCH_PLATFORM_WINDOWS
-                if (name[0] != '-' && name[0] != '/')
-                    return Detail::Result::logicError(
-                        "Option name must begin with '-' or '/'");
-#else
-                if (name[0] != '-')
-                    return Detail::Result::logicError(
-                        "Option name must begin with '-'");
-#endif
-            }
-            return ParserRefImpl::validate();
-        }
-
-        ExeName::ExeName() :
-            m_name(std::make_shared<std::string>("<executable>")) {}
-
-        ExeName::ExeName(std::string& ref) : ExeName() {
-            m_ref = std::make_shared<Detail::BoundValueRef<std::string>>(ref);
-        }
-
-        Detail::InternalParseResult
-            ExeName::parse(std::string const&,
-                           Detail::TokenStream tokens) const {
-            return Detail::InternalParseResult::ok(
-                Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens)));
-        }
-
-        ParserResult ExeName::set(std::string const& newName) {
-            auto lastSlash = newName.find_last_of("\\/");
-            auto filename = (lastSlash == std::string::npos)
-                ? newName
-                : newName.substr(lastSlash + 1);
-
-            *m_name = filename;
-            if (m_ref)
-                return m_ref->setValue(filename);
-            else
-                return ParserResult::ok(ParseResultType::Matched);
-        }
-
-
-
-
-        Parser& Parser::operator|=( Parser const& other ) {
-            m_options.insert( m_options.end(),
-                              other.m_options.begin(),
-                              other.m_options.end() );
-            m_args.insert(
-                m_args.end(), other.m_args.begin(), other.m_args.end() );
-            return *this;
-        }
-
-        std::vector<Detail::HelpColumns> Parser::getHelpColumns() const {
-            std::vector<Detail::HelpColumns> cols;
-            cols.reserve( m_options.size() );
-            for ( auto const& o : m_options ) {
-                cols.push_back(o.getHelpColumns());
-            }
-            return cols;
-        }
-
-        void Parser::writeToStream( std::ostream& os ) const {
-            if ( !m_exeName.name().empty() ) {
-                os << "usage:\n"
-                   << "  " << m_exeName.name() << ' ';
-                bool required = true, first = true;
-                for ( auto const& arg : m_args ) {
-                    if ( first )
-                        first = false;
-                    else
-                        os << ' ';
-                    if ( arg.isOptional() && required ) {
-                        os << '[';
-                        required = false;
-                    }
-                    os << '<' << arg.hint() << '>';
-                    if ( arg.cardinality() == 0 )
-                        os << " ... ";
-                }
-                if ( !required )
-                    os << ']';
-                if ( !m_options.empty() )
-                    os << " options";
-                os << "\n\nwhere options are:\n";
-            }
-
-            auto rows = getHelpColumns();
-            size_t consoleWidth = CATCH_CONFIG_CONSOLE_WIDTH;
-            size_t optWidth = 0;
-            for ( auto const& cols : rows )
-                optWidth = ( std::max )( optWidth, cols.left.size() + 2 );
-
-            optWidth = ( std::min )( optWidth, consoleWidth / 2 );
-
-            for ( auto& cols : rows ) {
-                auto row = TextFlow::Column( CATCH_MOVE(cols.left) )
-                               .width( optWidth )
-                               .indent( 2 ) +
-                           TextFlow::Spacer( 4 ) +
-                           TextFlow::Column( static_cast<std::string>(cols.descriptions) )
-                               .width( consoleWidth - 7 - optWidth );
-                os << row << '\n';
-            }
-        }
-
-        Detail::Result Parser::validate() const {
-            for ( auto const& opt : m_options ) {
-                auto result = opt.validate();
-                if ( !result )
-                    return result;
-            }
-            for ( auto const& arg : m_args ) {
-                auto result = arg.validate();
-                if ( !result )
-                    return result;
-            }
-            return Detail::Result::ok();
-        }
-
-        Detail::InternalParseResult
-        Parser::parse( std::string const& exeName,
-                       Detail::TokenStream tokens ) const {
-
-            struct ParserInfo {
-                ParserBase const* parser = nullptr;
-                size_t count = 0;
-            };
-            std::vector<ParserInfo> parseInfos;
-            parseInfos.reserve( m_options.size() + m_args.size() );
-            for ( auto const& opt : m_options ) {
-                parseInfos.push_back( { &opt, 0 } );
-            }
-            for ( auto const& arg : m_args ) {
-                parseInfos.push_back( { &arg, 0 } );
-            }
-
-            m_exeName.set( exeName );
-
-            auto result = Detail::InternalParseResult::ok(
-                Detail::ParseState( ParseResultType::NoMatch, CATCH_MOVE(tokens) ) );
-            while ( result.value().remainingTokens() ) {
-                bool tokenParsed = false;
-
-                for ( auto& parseInfo : parseInfos ) {
-                    if ( parseInfo.parser->cardinality() == 0 ||
-                         parseInfo.count < parseInfo.parser->cardinality() ) {
-                        result = parseInfo.parser->parse(
-                            exeName, CATCH_MOVE(result).value().remainingTokens() );
-                        if ( !result )
-                            return result;
-                        if ( result.value().type() !=
-                             ParseResultType::NoMatch ) {
-                            tokenParsed = true;
-                            ++parseInfo.count;
-                            break;
-                        }
-                    }
-                }
-
-                if ( result.value().type() == ParseResultType::ShortCircuitAll )
-                    return result;
-                if ( !tokenParsed )
-                    return Detail::InternalParseResult::runtimeError(
-                        "Unrecognised token: " +
-                        result.value().remainingTokens()->token );
-            }
-            // !TBD Check missing required options
-            return result;
-        }
-
-        Args::Args(int argc, char const* const* argv) :
-            m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}
-
-        Args::Args(std::initializer_list<StringRef> args) :
-            m_exeName(*args.begin()),
-            m_args(args.begin() + 1, args.end()) {}
-
-
-        Help::Help( bool& showHelpFlag ):
-            Opt( [&]( bool flag ) {
-                showHelpFlag = flag;
-                return ParserResult::ok( ParseResultType::ShortCircuitAll );
-            } ) {
-            static_cast<Opt&> ( *this )(
-                "display usage information" )["-?"]["-h"]["--help"]
-                .optional();
-        }
-
-    } // namespace Clara
-} // namespace Catch
-
-
-
-
-#include <fstream>
-#include <string>
-
-namespace Catch {
-
-    Clara::Parser makeCommandLineParser( ConfigData& config ) {
-
-        using namespace Clara;
-
-        auto const setWarning = [&]( std::string const& warning ) {
-            if ( warning == "NoAssertions" ) {
-                config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::NoAssertions);
-                return ParserResult::ok( ParseResultType::Matched );
-            } else if ( warning == "UnmatchedTestSpec" ) {
-                config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::UnmatchedTestSpec);
-                return ParserResult::ok( ParseResultType::Matched );
-            }
-
-            return ParserResult ::runtimeError(
-                "Unrecognised warning option: '" + warning + '\'' );
-        };
-        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
-                std::ifstream f( filename.c_str() );
-                if( !f.is_open() )
-                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + '\'' );
-
-                std::string line;
-                while( std::getline( f, line ) ) {
-                    line = trim(line);
-                    if( !line.empty() && !startsWith( line, '#' ) ) {
-                        if( !startsWith( line, '"' ) )
-                            line = '"' + CATCH_MOVE(line) + '"';
-                        config.testsOrTags.push_back( line );
-                        config.testsOrTags.emplace_back( "," );
-                    }
-                }
-                //Remove comma in the end
-                if(!config.testsOrTags.empty())
-                    config.testsOrTags.erase( config.testsOrTags.end()-1 );
-
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setTestOrder = [&]( std::string const& order ) {
-                if( startsWith( "declared", order ) )
-                    config.runOrder = TestRunOrder::Declared;
-                else if( startsWith( "lexical", order ) )
-                    config.runOrder = TestRunOrder::LexicographicallySorted;
-                else if( startsWith( "random", order ) )
-                    config.runOrder = TestRunOrder::Randomized;
-                else
-                    return ParserResult::runtimeError( "Unrecognised ordering: '" + order + '\'' );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setRngSeed = [&]( std::string const& seed ) {
-                if( seed == "time" ) {
-                    config.rngSeed = generateRandomSeed(GenerateFrom::Time);
-                    return ParserResult::ok(ParseResultType::Matched);
-                } else if (seed == "random-device") {
-                    config.rngSeed = generateRandomSeed(GenerateFrom::RandomDevice);
-                    return ParserResult::ok(ParseResultType::Matched);
-                }
-
-                // TODO: ideally we should be parsing uint32_t directly
-                //       fix this later when we add new parse overload
-                auto parsedSeed = parseUInt( seed, 0 );
-                if ( !parsedSeed ) {
-                    return ParserResult::runtimeError( "Could not parse '" + seed + "' as seed" );
-                }
-                config.rngSeed = *parsedSeed;
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setDefaultColourMode = [&]( std::string const& colourMode ) {
-            Optional<ColourMode> maybeMode = Catch::Detail::stringToColourMode(toLower( colourMode ));
-            if ( !maybeMode ) {
-                return ParserResult::runtimeError(
-                    "colour mode must be one of: default, ansi, win32, "
-                    "or none. '" +
-                    colourMode + "' is not recognised" );
-            }
-            auto mode = *maybeMode;
-            if ( !isColourImplAvailable( mode ) ) {
-                return ParserResult::runtimeError(
-                    "colour mode '" + colourMode +
-                    "' is not supported in this binary" );
-            }
-            config.defaultColourMode = mode;
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
-                auto keypressLc = toLower( keypress );
-                if (keypressLc == "never")
-                    config.waitForKeypress = WaitForKeypress::Never;
-                else if( keypressLc == "start" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStart;
-                else if( keypressLc == "exit" )
-                    config.waitForKeypress = WaitForKeypress::BeforeExit;
-                else if( keypressLc == "both" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
-                else
-                    return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
-            return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setVerbosity = [&]( std::string const& verbosity ) {
-            auto lcVerbosity = toLower( verbosity );
-            if( lcVerbosity == "quiet" )
-                config.verbosity = Verbosity::Quiet;
-            else if( lcVerbosity == "normal" )
-                config.verbosity = Verbosity::Normal;
-            else if( lcVerbosity == "high" )
-                config.verbosity = Verbosity::High;
-            else
-                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + '\'' );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-        auto const setReporter = [&]( std::string const& userReporterSpec ) {
-            if ( userReporterSpec.empty() ) {
-                return ParserResult::runtimeError( "Received empty reporter spec." );
-            }
-
-            Optional<ReporterSpec> parsed =
-                parseReporterSpec( userReporterSpec );
-            if ( !parsed ) {
-                return ParserResult::runtimeError(
-                    "Could not parse reporter spec '" + userReporterSpec +
-                    "'" );
-            }
-
-            auto const& reporterSpec = *parsed;
-
-            auto const& factories =
-                getRegistryHub().getReporterRegistry().getFactories();
-            auto result = factories.find( reporterSpec.name() );
-
-            if ( result == factories.end() ) {
-                return ParserResult::runtimeError(
-                    "Unrecognized reporter, '" + reporterSpec.name() +
-                    "'. Check available with --list-reporters" );
-            }
-
-
-            const bool hadOutputFile = reporterSpec.outputFile().some();
-            config.reporterSpecifications.push_back( CATCH_MOVE( *parsed ) );
-            // It would be enough to check this only once at the very end, but
-            // there is  not a place where we could call this check, so do it
-            // every time it could fail. For valid inputs, this is still called
-            // at most once.
-            if (!hadOutputFile) {
-                int n_reporters_without_file = 0;
-                for (auto const& spec : config.reporterSpecifications) {
-                    if (spec.outputFile().none()) {
-                        n_reporters_without_file++;
-                    }
-                }
-                if (n_reporters_without_file > 1) {
-                    return ParserResult::runtimeError( "Only one reporter may have unspecified output file." );
-                }
-            }
-
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-        auto const setShardCount = [&]( std::string const& shardCount ) {
-            auto parsedCount = parseUInt( shardCount );
-            if ( !parsedCount ) {
-                return ParserResult::runtimeError(
-                    "Could not parse '" + shardCount + "' as shard count" );
-            }
-            if ( *parsedCount == 0 ) {
-                return ParserResult::runtimeError(
-                    "Shard count must be positive" );
-            }
-            config.shardCount = *parsedCount;
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-
-        auto const setShardIndex = [&](std::string const& shardIndex) {
-            auto parsedIndex = parseUInt( shardIndex );
-            if ( !parsedIndex ) {
-                return ParserResult::runtimeError(
-                    "Could not parse '" + shardIndex + "' as shard index" );
-            }
-            config.shardIndex = *parsedIndex;
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-
-        auto cli
-            = ExeName( config.processName )
-            | Help( config.showHelp )
-            | Opt( config.showSuccessfulTests )
-                ["-s"]["--success"]
-                ( "include successful tests in output" )
-            | Opt( config.shouldDebugBreak )
-                ["-b"]["--break"]
-                ( "break into debugger on failure" )
-            | Opt( config.noThrow )
-                ["-e"]["--nothrow"]
-                ( "skip exception tests" )
-            | Opt( config.showInvisibles )
-                ["-i"]["--invisibles"]
-                ( "show invisibles (tabs, newlines)" )
-            | Opt( config.defaultOutputFilename, "filename" )
-                ["-o"]["--out"]
-                ( "default output filename" )
-            | Opt( accept_many, setReporter, "name[::key=value]*" )
-                ["-r"]["--reporter"]
-                ( "reporter to use (defaults to console)" )
-            | Opt( config.name, "name" )
-                ["-n"]["--name"]
-                ( "suite name" )
-            | Opt( [&]( bool ){ config.abortAfter = 1; } )
-                ["-a"]["--abort"]
-                ( "abort at first failure" )
-            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
-                ["-x"]["--abortx"]
-                ( "abort after x failures" )
-            | Opt( accept_many, setWarning, "warning name" )
-                ["-w"]["--warn"]
-                ( "enable warnings" )
-            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
-                ["-d"]["--durations"]
-                ( "show test durations" )
-            | Opt( config.minDuration, "seconds" )
-                ["-D"]["--min-duration"]
-                ( "show test durations for tests taking at least the given number of seconds" )
-            | Opt( loadTestNamesFromFile, "filename" )
-                ["-f"]["--input-file"]
-                ( "load test names to run from a file" )
-            | Opt( config.filenamesAsTags )
-                ["-#"]["--filenames-as-tags"]
-                ( "adds a tag for the filename" )
-            | Opt( config.sectionsToRun, "section name" )
-                ["-c"]["--section"]
-                ( "specify section to run" )
-            | Opt( setVerbosity, "quiet|normal|high" )
-                ["-v"]["--verbosity"]
-                ( "set output verbosity" )
-            | Opt( config.listTests )
-                ["--list-tests"]
-                ( "list all/matching test cases" )
-            | Opt( config.listTags )
-                ["--list-tags"]
-                ( "list all/matching tags" )
-            | Opt( config.listReporters )
-                ["--list-reporters"]
-                ( "list all available reporters" )
-            | Opt( config.listListeners )
-                ["--list-listeners"]
-                ( "list all listeners" )
-            | Opt( setTestOrder, "decl|lex|rand" )
-                ["--order"]
-                ( "test case order (defaults to decl)" )
-            | Opt( setRngSeed, "'time'|'random-device'|number" )
-                ["--rng-seed"]
-                ( "set a specific seed for random numbers" )
-            | Opt( setDefaultColourMode, "ansi|win32|none|default" )
-                ["--colour-mode"]
-                ( "what color mode should be used as default" )
-            | Opt( config.libIdentify )
-                ["--libidentify"]
-                ( "report name and version according to libidentify standard" )
-            | Opt( setWaitForKeypress, "never|start|exit|both" )
-                ["--wait-for-keypress"]
-                ( "waits for a keypress before exiting" )
-            | Opt( config.skipBenchmarks)
-                ["--skip-benchmarks"]
-                ( "disable running benchmarks")
-            | Opt( config.benchmarkSamples, "samples" )
-                ["--benchmark-samples"]
-                ( "number of samples to collect (default: 100)" )
-            | Opt( config.benchmarkResamples, "resamples" )
-                ["--benchmark-resamples"]
-                ( "number of resamples for the bootstrap (default: 100000)" )
-            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
-                ["--benchmark-confidence-interval"]
-                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
-            | Opt( config.benchmarkNoAnalysis )
-                ["--benchmark-no-analysis"]
-                ( "perform only measurements; do not perform any analysis" )
-            | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
-                ["--benchmark-warmup-time"]
-                ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
-            | Opt( setShardCount, "shard count" )
-                ["--shard-count"]
-                ( "split the tests to execute into this many groups" )
-            | Opt( setShardIndex, "shard index" )
-                ["--shard-index"]
-                ( "index of the group of tests to execute (see --shard-count)" )
-            | Opt( config.allowZeroTests )
-                ["--allow-running-no-tests"]
-                ( "Treat 'No tests run' as a success" )
-            | Arg( config.testsOrTags, "test name|pattern|tags" )
-                ( "which test or tests to use" );
-
-        return cli;
-    }
-
-} // end namespace Catch
-
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
-
-
-#include <cassert>
-#include <ostream>
-#include <utility>
-
-namespace Catch {
-
-    ColourImpl::~ColourImpl() = default;
-
-    ColourImpl::ColourGuard ColourImpl::guardColour( Colour::Code colourCode ) {
-        return ColourGuard(colourCode, this );
-    }
-
-    void ColourImpl::ColourGuard::engageImpl( std::ostream& stream ) {
-        assert( &stream == &m_colourImpl->m_stream->stream() &&
-                "Engaging colour guard for different stream than used by the "
-                "parent colour implementation" );
-        static_cast<void>( stream );
-
-        m_engaged = true;
-        m_colourImpl->use( m_code );
-    }
-
-    ColourImpl::ColourGuard::ColourGuard( Colour::Code code,
-                                          ColourImpl const* colour ):
-        m_colourImpl( colour ), m_code( code ) {
-    }
-    ColourImpl::ColourGuard::ColourGuard( ColourGuard&& rhs ) noexcept:
-        m_colourImpl( rhs.m_colourImpl ),
-        m_code( rhs.m_code ),
-        m_engaged( rhs.m_engaged ) {
-        rhs.m_engaged = false;
-    }
-    ColourImpl::ColourGuard&
-    ColourImpl::ColourGuard::operator=( ColourGuard&& rhs ) noexcept {
-        using std::swap;
-        swap( m_colourImpl, rhs.m_colourImpl );
-        swap( m_code, rhs.m_code );
-        swap( m_engaged, rhs.m_engaged );
-
-        return *this;
-    }
-    ColourImpl::ColourGuard::~ColourGuard() {
-        if ( m_engaged ) {
-            m_colourImpl->use( Colour::None );
-        }
-    }
-
-    ColourImpl::ColourGuard&
-    ColourImpl::ColourGuard::engage( std::ostream& stream ) & {
-        engageImpl( stream );
-        return *this;
-    }
-
-    ColourImpl::ColourGuard&&
-    ColourImpl::ColourGuard::engage( std::ostream& stream ) && {
-        engageImpl( stream );
-        return CATCH_MOVE(*this);
-    }
-
-    namespace {
-        //! A do-nothing implementation of colour, used as fallback for unknown
-        //! platforms, and when the user asks to deactivate all colours.
-        class NoColourImpl final : public ColourImpl {
-        public:
-            NoColourImpl( IStream* stream ): ColourImpl( stream ) {}
-
-        private:
-            void use( Colour::Code ) const override {}
-        };
-    } // namespace
-
-
-} // namespace Catch
-
-
-#if defined ( CATCH_CONFIG_COLOUR_WIN32 ) /////////////////////////////////////////
-
-namespace Catch {
-namespace {
-
-    class Win32ColourImpl final : public ColourImpl {
-    public:
-        Win32ColourImpl(IStream* stream):
-            ColourImpl(stream) {
-            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
-            GetConsoleScreenBufferInfo( GetStdHandle( STD_OUTPUT_HANDLE ),
-                                        &csbiInfo );
-            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
-            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
-        }
-
-        static bool useImplementationForStream(IStream const& stream) {
-            // Win32 text colour APIs can only be used on console streams
-            // We cannot check that the output hasn't been redirected,
-            // so we just check that the original stream is console stream.
-            return stream.isConsole();
-        }
-
-    private:
-        void use( Colour::Code _colourCode ) const override {
-            switch( _colourCode ) {
-                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
-                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
-                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
-                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
-                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
-                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
-                case Colour::Grey:      return setTextAttribute( 0 );
-
-                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
-                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
-                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
-                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::BrightYellow:  return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-
-                default:
-                    CATCH_ERROR( "Unknown colour requested" );
-            }
-        }
-
-        void setTextAttribute( WORD _textAttribute ) const {
-            SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ),
-                                     _textAttribute |
-                                         originalBackgroundAttributes );
-        }
-        WORD originalForegroundAttributes;
-        WORD originalBackgroundAttributes;
-    };
-
-} // end anon namespace
-} // end namespace Catch
-
-#endif // Windows/ ANSI/ None
-
-
-#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC )
-#    define CATCH_INTERNAL_HAS_ISATTY
-#    include <unistd.h>
-#endif
-
-namespace Catch {
-namespace {
-
-    class ANSIColourImpl final : public ColourImpl {
-    public:
-        ANSIColourImpl( IStream* stream ): ColourImpl( stream ) {}
-
-        static bool useImplementationForStream(IStream const& stream) {
-            // This is kinda messy due to trying to support a bunch of
-            // different platforms at once.
-            // The basic idea is that if we are asked to do autodetection (as
-            // opposed to being told to use posixy colours outright), then we
-            // only want to use the colours if we are writing to console.
-            // However, console might be redirected, so we make an attempt at
-            // checking for that on platforms where we know how to do that.
-            bool useColour = stream.isConsole();
-#if defined( CATCH_INTERNAL_HAS_ISATTY ) && \
-    !( defined( __DJGPP__ ) && defined( __STRICT_ANSI__ ) )
-            ErrnoGuard _; // for isatty
-            useColour = useColour && isatty( STDOUT_FILENO );
-#    endif
-#    if defined( CATCH_PLATFORM_MAC ) || defined( CATCH_PLATFORM_IPHONE )
-            useColour = useColour && !isDebuggerActive();
-#    endif
-
-            return useColour;
-        }
-
-    private:
-        void use( Colour::Code _colourCode ) const override {
-            auto setColour = [&out =
-                                  m_stream->stream()]( char const* escapeCode ) {
-                // The escape sequence must be flushed to console, otherwise
-                // if stdin and stderr are intermixed, we'd get accidentally
-                // coloured output.
-                out << '\033' << escapeCode << std::flush;
-            };
-            switch( _colourCode ) {
-                case Colour::None:
-                case Colour::White:     return setColour( "[0m" );
-                case Colour::Red:       return setColour( "[0;31m" );
-                case Colour::Green:     return setColour( "[0;32m" );
-                case Colour::Blue:      return setColour( "[0;34m" );
-                case Colour::Cyan:      return setColour( "[0;36m" );
-                case Colour::Yellow:    return setColour( "[0;33m" );
-                case Colour::Grey:      return setColour( "[1;30m" );
-
-                case Colour::LightGrey:     return setColour( "[0;37m" );
-                case Colour::BrightRed:     return setColour( "[1;31m" );
-                case Colour::BrightGreen:   return setColour( "[1;32m" );
-                case Colour::BrightWhite:   return setColour( "[1;37m" );
-                case Colour::BrightYellow:  return setColour( "[1;33m" );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-                default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
-            }
-        }
-    };
-
-} // end anon namespace
-} // end namespace Catch
-
-namespace Catch {
-
-    Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection,
-                                                   IStream* stream ) {
-#if defined( CATCH_CONFIG_COLOUR_WIN32 )
-        if ( colourSelection == ColourMode::Win32 ) {
-            return Detail::make_unique<Win32ColourImpl>( stream );
-        }
-#endif
-        if ( colourSelection == ColourMode::ANSI ) {
-            return Detail::make_unique<ANSIColourImpl>( stream );
-        }
-        if ( colourSelection == ColourMode::None ) {
-            return Detail::make_unique<NoColourImpl>( stream );
-        }
-
-        if ( colourSelection == ColourMode::PlatformDefault) {
-#if defined( CATCH_CONFIG_COLOUR_WIN32 )
-            if ( Win32ColourImpl::useImplementationForStream( *stream ) ) {
-                return Detail::make_unique<Win32ColourImpl>( stream );
-            }
-#endif
-            if ( ANSIColourImpl::useImplementationForStream( *stream ) ) {
-                return Detail::make_unique<ANSIColourImpl>( stream );
-            }
-            return Detail::make_unique<NoColourImpl>( stream );
-        }
-
-        CATCH_ERROR( "Could not create colour impl for selection " << static_cast<int>(colourSelection) );
-    }
-
-    bool isColourImplAvailable( ColourMode colourSelection ) {
-        switch ( colourSelection ) {
-#if defined( CATCH_CONFIG_COLOUR_WIN32 )
-        case ColourMode::Win32:
-#endif
-        case ColourMode::ANSI:
-        case ColourMode::None:
-        case ColourMode::PlatformDefault:
-            return true;
-        default:
-            return false;
-        }
-    }
-
-
-} // end namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-
-
-
-
-namespace Catch {
-
-    Context* Context::currentContext = nullptr;
-
-    void cleanUpContext() {
-        delete Context::currentContext;
-        Context::currentContext = nullptr;
-    }
-    void Context::createContext() {
-        currentContext = new Context();
-    }
-
-    Context& getCurrentMutableContext() {
-        if ( !Context::currentContext ) { Context::createContext(); }
-        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
-        return *Context::currentContext;
-    }
-
-    SimplePcg32& sharedRng() {
-        static SimplePcg32 s_rng;
-        return s_rng;
-    }
-
-}
-
-
-
-
-
-#include <ostream>
-
-#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
-#include <android/log.h>
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
-        }
-    }
-
-#elif defined(CATCH_PLATFORM_WINDOWS)
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            ::OutputDebugStringA( text.c_str() );
-        }
-    }
-
-#else
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            // !TBD: Need a version for Mac/ XCode and other IDEs
-            Catch::cout() << text;
-        }
-    }
-
-#endif // Platform
-
-
-
-#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
-
-#  include <cassert>
-#  include <sys/types.h>
-#  include <unistd.h>
-#  include <cstddef>
-#  include <ostream>
-
-#ifdef __apple_build_version__
-    // These headers will only compile with AppleClang (XCode)
-    // For other compilers (Clang, GCC, ... ) we need to exclude them
-#  include <sys/sysctl.h>
-#endif
-
-    namespace Catch {
-        #ifdef __apple_build_version__
-        // The following function is taken directly from the following technical note:
-        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
-
-        // Returns true if the current process is being debugged (either
-        // running under the debugger or has a debugger attached post facto).
-        bool isDebuggerActive(){
-            int                 mib[4];
-            struct kinfo_proc   info;
-            std::size_t         size;
-
-            // Initialize the flags so that, if sysctl fails for some bizarre
-            // reason, we get a predictable result.
-
-            info.kp_proc.p_flag = 0;
-
-            // Initialize mib, which tells sysctl the info we want, in this case
-            // we're looking for information about a specific process ID.
-
-            mib[0] = CTL_KERN;
-            mib[1] = KERN_PROC;
-            mib[2] = KERN_PROC_PID;
-            mib[3] = getpid();
-
-            // Call sysctl.
-
-            size = sizeof(info);
-            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
-                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n\n" << std::flush;
-                return false;
-            }
-
-            // We're being debugged if the P_TRACED flag is set.
-
-            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
-        }
-        #else
-        bool isDebuggerActive() {
-            // We need to find another way to determine this for non-appleclang compilers on macOS
-            return false;
-        }
-        #endif
-    } // namespace Catch
-
-#elif defined(CATCH_PLATFORM_LINUX)
-    #include <fstream>
-    #include <string>
-
-    namespace Catch{
-        // The standard POSIX way of detecting a debugger is to attempt to
-        // ptrace() the process, but this needs to be done from a child and not
-        // this process itself to still allow attaching to this process later
-        // if wanted, so is rather heavy. Under Linux we have the PID of the
-        // "debugger" (which doesn't need to be gdb, of course, it could also
-        // be strace, for example) in /proc/$PID/status, so just get it from
-        // there instead.
-        bool isDebuggerActive(){
-            // Libstdc++ has a bug, where std::ifstream sets errno to 0
-            // This way our users can properly assert over errno values
-            ErrnoGuard guard;
-            std::ifstream in("/proc/self/status");
-            for( std::string line; std::getline(in, line); ) {
-                static const int PREFIX_LEN = 11;
-                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
-                    // We're traced if the PID is not 0 and no other PID starts
-                    // with 0 digit, so it's enough to check for just a single
-                    // character.
-                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
-                }
-            }
-
-            return false;
-        }
-    } // namespace Catch
-#elif defined(_MSC_VER)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#else
-    namespace Catch {
-       bool isDebuggerActive() { return false; }
-    }
-#endif // Platform
-
-
-
-
-namespace Catch {
-
-    void ITransientExpression::streamReconstructedExpression(
-        std::ostream& os ) const {
-        // We can't make this function pure virtual to keep ITransientExpression
-        // constexpr, so we write error message instead
-        os << "Some class derived from ITransientExpression without overriding streamReconstructedExpression";
-    }
-
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
-        if( lhs.size() + rhs.size() < 40 &&
-                lhs.find('\n') == std::string::npos &&
-                rhs.find('\n') == std::string::npos )
-            os << lhs << ' ' << op << ' ' << rhs;
-        else
-            os << lhs << '\n' << op << '\n' << rhs;
-    }
-}
-
-
-
-#include <stdexcept>
-
-
-namespace Catch {
-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
-    [[noreturn]]
-    void throw_exception(std::exception const& e) {
-        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
-                      << "The message was: " << e.what() << '\n';
-        std::terminate();
-    }
-#endif
-
-    [[noreturn]]
-    void throw_logic_error(std::string const& msg) {
-        throw_exception(std::logic_error(msg));
-    }
-
-    [[noreturn]]
-    void throw_domain_error(std::string const& msg) {
-        throw_exception(std::domain_error(msg));
-    }
-
-    [[noreturn]]
-    void throw_runtime_error(std::string const& msg) {
-        throw_exception(std::runtime_error(msg));
-    }
-
-
-
-} // namespace Catch;
-
-
-
-#include <cassert>
-
-namespace Catch {
-
-    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() = default;
-
-    namespace Detail {
-
-        namespace {
-            // Extracts the actual name part of an enum instance
-            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
-            StringRef extractInstanceName(StringRef enumInstance) {
-                // Find last occurrence of ":"
-                size_t name_start = enumInstance.size();
-                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
-                    --name_start;
-                }
-                return enumInstance.substr(name_start, enumInstance.size() - name_start);
-            }
-        }
-
-        std::vector<StringRef> parseEnums( StringRef enums ) {
-            auto enumValues = splitStringRef( enums, ',' );
-            std::vector<StringRef> parsed;
-            parsed.reserve( enumValues.size() );
-            for( auto const& enumValue : enumValues ) {
-                parsed.push_back(trim(extractInstanceName(enumValue)));
-            }
-            return parsed;
-        }
-
-        EnumInfo::~EnumInfo() = default;
-
-        StringRef EnumInfo::lookup( int value ) const {
-            for( auto const& valueToName : m_values ) {
-                if( valueToName.first == value )
-                    return valueToName.second;
-            }
-            return "{** unexpected enum value **}"_sr;
-        }
-
-        Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            auto enumInfo = Catch::Detail::make_unique<EnumInfo>();
-            enumInfo->m_name = enumName;
-            enumInfo->m_values.reserve( values.size() );
-
-            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
-            assert( valueNames.size() == values.size() );
-            std::size_t i = 0;
-            for( auto value : values )
-                enumInfo->m_values.emplace_back(value, valueNames[i++]);
-
-            return enumInfo;
-        }
-
-        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
-            return *m_enumInfos.back();
-        }
-
-    } // Detail
-} // Catch
-
-
-
-
-
-#include <cerrno>
-
-namespace Catch {
-        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
-        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
-}
-
-
-
-#include <exception>
-
-namespace Catch {
-
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    namespace {
-        static std::string tryTranslators(
-            std::vector<
-                Detail::unique_ptr<IExceptionTranslator const>> const& translators ) {
-            if ( translators.empty() ) {
-                std::rethrow_exception( std::current_exception() );
-            } else {
-                return translators[0]->translate( translators.begin() + 1,
-                                                  translators.end() );
-            }
-        }
-
-    }
-#endif //!defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-
-    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() = default;
-
-    void ExceptionTranslatorRegistry::registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) {
-        m_translators.push_back( CATCH_MOVE( translator ) );
-    }
-
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    std::string ExceptionTranslatorRegistry::translateActiveException() const {
-        // Compiling a mixed mode project with MSVC means that CLR
-        // exceptions will be caught in (...) as well. However, these do
-        // do not fill-in std::current_exception and thus lead to crash
-        // when attempting rethrow.
-        // /EHa switch also causes structured exceptions to be caught
-        // here, but they fill-in current_exception properly, so
-        // at worst the output should be a little weird, instead of
-        // causing a crash.
-        if ( std::current_exception() == nullptr ) {
-            return "Non C++ exception. Possibly a CLR exception.";
-        }
-
-        // First we try user-registered translators. If none of them can
-        // handle the exception, it will be rethrown handled by our defaults.
-        try {
-            return tryTranslators(m_translators);
-        }
-        // To avoid having to handle TFE explicitly everywhere, we just
-        // rethrow it so that it goes back up the caller.
-        catch( TestFailureException& ) {
-            std::rethrow_exception(std::current_exception());
-        }
-        catch( TestSkipException& ) {
-            std::rethrow_exception(std::current_exception());
-        }
-        catch( std::exception const& ex ) {
-            return ex.what();
-        }
-        catch( std::string const& msg ) {
-            return msg;
-        }
-        catch( const char* msg ) {
-            return msg;
-        }
-        catch(...) {
-            return "Unknown exception";
-        }
-    }
-
-#else // ^^ Exceptions are enabled // Exceptions are disabled vv
-    std::string ExceptionTranslatorRegistry::translateActiveException() const {
-        CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
-    }
-#endif
-
-}
-
-
-
-/** \file
- * This file provides platform specific implementations of FatalConditionHandler
- *
- * This means that there is a lot of conditional compilation, and platform
- * specific code. Currently, Catch2 supports a dummy handler (if no
- * handler is desired), and 2 platform specific handlers:
- *  * Windows' SEH
- *  * POSIX signals
- *
- * Consequently, various pieces of code below are compiled if either of
- * the platform specific handlers is enabled, or if none of them are
- * enabled. It is assumed that both cannot be enabled at the same time,
- * and doing so should cause a compilation error.
- *
- * If another platform specific handler is added, the compile guards
- * below will need to be updated taking these assumptions into account.
- */
-
-
-
-#include <algorithm>
-
-#if !defined( CATCH_CONFIG_WINDOWS_SEH ) && !defined( CATCH_CONFIG_POSIX_SIGNALS )
-
-namespace Catch {
-
-    // If neither SEH nor signal handling is required, the handler impls
-    // do not have to do anything, and can be empty.
-    void FatalConditionHandler::engage_platform() {}
-    void FatalConditionHandler::disengage_platform() noexcept {}
-    FatalConditionHandler::FatalConditionHandler() = default;
-    FatalConditionHandler::~FatalConditionHandler() = default;
-
-} // end namespace Catch
-
-#endif // !CATCH_CONFIG_WINDOWS_SEH && !CATCH_CONFIG_POSIX_SIGNALS
-
-#if defined( CATCH_CONFIG_WINDOWS_SEH ) && defined( CATCH_CONFIG_POSIX_SIGNALS )
-#error "Inconsistent configuration: Windows' SEH handling and POSIX signals cannot be enabled at the same time"
-#endif // CATCH_CONFIG_WINDOWS_SEH && CATCH_CONFIG_POSIX_SIGNALS
-
-#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
-
-namespace {
-    //! Signals fatal error message to the run context
-    void reportFatal( char const * const message ) {
-        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
-    }
-
-    //! Minimal size Catch2 needs for its own fatal error handling.
-    //! Picked empirically, so it might not be sufficient on all
-    //! platforms, and for all configurations.
-    constexpr std::size_t minStackSizeForErrors = 32 * 1024;
-} // end unnamed namespace
-
-#endif // CATCH_CONFIG_WINDOWS_SEH || CATCH_CONFIG_POSIX_SIGNALS
-
-#if defined( CATCH_CONFIG_WINDOWS_SEH )
-
-namespace Catch {
-
-    struct SignalDefs { DWORD id; const char* name; };
-
-    // There is no 1-1 mapping between signals and windows exceptions.
-    // Windows can easily distinguish between SO and SigSegV,
-    // but SigInt, SigTerm, etc are handled differently.
-    static SignalDefs signalDefs[] = {
-        { EXCEPTION_ILLEGAL_INSTRUCTION,  "SIGILL - Illegal instruction signal" },
-        { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" },
-        { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" },
-        { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
-    };
-
-    static LONG CALLBACK topLevelExceptionFilter(PEXCEPTION_POINTERS ExceptionInfo) {
-        for (auto const& def : signalDefs) {
-            if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
-                reportFatal(def.name);
-            }
-        }
-        // If its not an exception we care about, pass it along.
-        // This stops us from eating debugger breaks etc.
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-
-    // Since we do not support multiple instantiations, we put these
-    // into global variables and rely on cleaning them up in outlined
-    // constructors/destructors
-    static LPTOP_LEVEL_EXCEPTION_FILTER previousTopLevelExceptionFilter = nullptr;
-
-
-    // For MSVC, we reserve part of the stack memory for handling
-    // memory overflow structured exception.
-    FatalConditionHandler::FatalConditionHandler() {
-        ULONG guaranteeSize = static_cast<ULONG>(minStackSizeForErrors);
-        if (!SetThreadStackGuarantee(&guaranteeSize)) {
-            // We do not want to fully error out, because needing
-            // the stack reserve should be rare enough anyway.
-            Catch::cerr()
-                << "Failed to reserve piece of stack."
-                << " Stack overflows will not be reported successfully.";
-        }
-    }
-
-    // We do not attempt to unset the stack guarantee, because
-    // Windows does not support lowering the stack size guarantee.
-    FatalConditionHandler::~FatalConditionHandler() = default;
-
-
-    void FatalConditionHandler::engage_platform() {
-        // Register as a the top level exception filter.
-        previousTopLevelExceptionFilter = SetUnhandledExceptionFilter(topLevelExceptionFilter);
-    }
-
-    void FatalConditionHandler::disengage_platform() noexcept {
-        if (SetUnhandledExceptionFilter(previousTopLevelExceptionFilter) != topLevelExceptionFilter) {
-            Catch::cerr()
-                << "Unexpected SEH unhandled exception filter on disengage."
-                << " The filter was restored, but might be rolled back unexpectedly.";
-        }
-        previousTopLevelExceptionFilter = nullptr;
-    }
-
-} // end namespace Catch
-
-#endif // CATCH_CONFIG_WINDOWS_SEH
-
-#if defined( CATCH_CONFIG_POSIX_SIGNALS )
-
-#include <signal.h>
-
-namespace Catch {
-
-    struct SignalDefs {
-        int id;
-        const char* name;
-    };
-
-    static SignalDefs signalDefs[] = {
-        { SIGINT,  "SIGINT - Terminal interrupt signal" },
-        { SIGILL,  "SIGILL - Illegal instruction signal" },
-        { SIGFPE,  "SIGFPE - Floating point error signal" },
-        { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
-        { SIGTERM, "SIGTERM - Termination request signal" },
-        { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
-    };
-
-// Older GCCs trigger -Wmissing-field-initializers for T foo = {}
-// which is zero initialization, but not explicit. We want to avoid
-// that.
-#if defined(__GNUC__)
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-#endif
-
-    static char* altStackMem = nullptr;
-    static std::size_t altStackSize = 0;
-    static stack_t oldSigStack{};
-    static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)]{};
-
-    static void restorePreviousSignalHandlers() noexcept {
-        // We set signal handlers back to the previous ones. Hopefully
-        // nobody overwrote them in the meantime, and doesn't expect
-        // their signal handlers to live past ours given that they
-        // installed them after ours..
-        for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
-            sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
-        }
-        // Return the old stack
-        sigaltstack(&oldSigStack, nullptr);
-    }
-
-    static void handleSignal( int sig ) {
-        char const * name = "<unknown signal>";
-        for (auto const& def : signalDefs) {
-            if (sig == def.id) {
-                name = def.name;
-                break;
-            }
-        }
-        // We need to restore previous signal handlers and let them do
-        // their thing, so that the users can have the debugger break
-        // when a signal is raised, and so on.
-        restorePreviousSignalHandlers();
-        reportFatal( name );
-        raise( sig );
-    }
-
-    FatalConditionHandler::FatalConditionHandler() {
-        assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");
-        if (altStackSize == 0) {
-            altStackSize = std::max(static_cast<size_t>(SIGSTKSZ), minStackSizeForErrors);
-        }
-        altStackMem = new char[altStackSize]();
-    }
-
-    FatalConditionHandler::~FatalConditionHandler() {
-        delete[] altStackMem;
-        // We signal that another instance can be constructed by zeroing
-        // out the pointer.
-        altStackMem = nullptr;
-    }
-
-    void FatalConditionHandler::engage_platform() {
-        stack_t sigStack;
-        sigStack.ss_sp = altStackMem;
-        sigStack.ss_size = altStackSize;
-        sigStack.ss_flags = 0;
-        sigaltstack(&sigStack, &oldSigStack);
-        struct sigaction sa = { };
-
-        sa.sa_handler = handleSignal;
-        sa.sa_flags = SA_ONSTACK;
-        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
-            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
-        }
-    }
-
-#if defined(__GNUC__)
-#    pragma GCC diagnostic pop
-#endif
-
-
-    void FatalConditionHandler::disengage_platform() noexcept {
-        restorePreviousSignalHandlers();
-    }
-
-} // end namespace Catch
-
-#endif // CATCH_CONFIG_POSIX_SIGNALS
-
-
-
-
-#include <cstring>
-
-namespace Catch {
-    namespace Detail {
-
-        uint32_t convertToBits(float f) {
-            static_assert(sizeof(float) == sizeof(uint32_t), "Important ULP matcher assumption violated");
-            uint32_t i;
-            std::memcpy(&i, &f, sizeof(f));
-            return i;
-        }
-
-        uint64_t convertToBits(double d) {
-            static_assert(sizeof(double) == sizeof(uint64_t), "Important ULP matcher assumption violated");
-            uint64_t i;
-            std::memcpy(&i, &d, sizeof(d));
-            return i;
-        }
-
-#if defined( __GNUC__ ) || defined( __clang__ )
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-        bool directCompare( float lhs, float rhs ) { return lhs == rhs; }
-        bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
-#if defined( __GNUC__ ) || defined( __clang__ )
-#    pragma GCC diagnostic pop
-#endif
-
-
-    } // end namespace Detail
-} // end namespace Catch
-
-
-
-
-
-
-#include <cstdlib>
-
-namespace Catch {
-    namespace Detail {
-
-#if !defined (CATCH_CONFIG_GETENV)
-        char const* getEnv( char const* ) { return nullptr; }
-#else
-
-        char const* getEnv( char const* varName ) {
-#    if defined( _MSC_VER )
-#        pragma warning( push )
-#        pragma warning( disable : 4996 ) // use getenv_s instead of getenv
-#    endif
-
-            return std::getenv( varName );
-
-#    if defined( _MSC_VER )
-#        pragma warning( pop )
-#    endif
-        }
-#endif
-} // namespace Detail
-} // namespace Catch
-
-
-
-
-#include <cstdio>
-#include <fstream>
-#include <sstream>
-#include <vector>
-
-namespace Catch {
-
-    Catch::IStream::~IStream() = default;
-
-namespace Detail {
-    namespace {
-        template<typename WriterF, std::size_t bufferSize=256>
-        class StreamBufImpl final : public std::streambuf {
-            char data[bufferSize];
-            WriterF m_writer;
-
-        public:
-            StreamBufImpl() {
-                setp( data, data + sizeof(data) );
-            }
-
-            ~StreamBufImpl() noexcept override {
-                StreamBufImpl::sync();
-            }
-
-        private:
-            int overflow( int c ) override {
-                sync();
-
-                if( c != EOF ) {
-                    if( pbase() == epptr() )
-                        m_writer( std::string( 1, static_cast<char>( c ) ) );
-                    else
-                        sputc( static_cast<char>( c ) );
-                }
-                return 0;
-            }
-
-            int sync() override {
-                if( pbase() != pptr() ) {
-                    m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
-                    setp( pbase(), epptr() );
-                }
-                return 0;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        struct OutputDebugWriter {
-
-            void operator()( std::string const& str ) {
-                if ( !str.empty() ) {
-                    writeToDebugConsole( str );
-                }
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class FileStream final : public IStream {
-            std::ofstream m_ofs;
-        public:
-            FileStream( std::string const& filename ) {
-                m_ofs.open( filename.c_str() );
-                CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << '\'' );
-                m_ofs << std::unitbuf;
-            }
-        public: // IStream
-            std::ostream& stream() override {
-                return m_ofs;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class CoutStream final : public IStream {
-            std::ostream m_os;
-        public:
-            // Store the streambuf from cout up-front because
-            // cout may get redirected when running tests
-            CoutStream() : m_os( Catch::cout().rdbuf() ) {}
-
-        public: // IStream
-            std::ostream& stream() override { return m_os; }
-            bool isConsole() const override { return true; }
-        };
-
-        class CerrStream : public IStream {
-            std::ostream m_os;
-
-        public:
-            // Store the streambuf from cerr up-front because
-            // cout may get redirected when running tests
-            CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
-
-        public: // IStream
-            std::ostream& stream() override { return m_os; }
-            bool isConsole() const override { return true; }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class DebugOutStream final : public IStream {
-            Detail::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
-            std::ostream m_os;
-        public:
-            DebugOutStream()
-            :   m_streamBuf( Detail::make_unique<StreamBufImpl<OutputDebugWriter>>() ),
-                m_os( m_streamBuf.get() )
-            {}
-
-        public: // IStream
-            std::ostream& stream() override { return m_os; }
-        };
-
-    } // unnamed namespace
-} // namespace Detail
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream> {
-        if ( filename.empty() || filename == "-" ) {
-            return Detail::make_unique<Detail::CoutStream>();
-        }
-        if( filename[0] == '%' ) {
-            if ( filename == "%debug" ) {
-                return Detail::make_unique<Detail::DebugOutStream>();
-            } else if ( filename == "%stderr" ) {
-                return Detail::make_unique<Detail::CerrStream>();
-            } else if ( filename == "%stdout" ) {
-                return Detail::make_unique<Detail::CoutStream>();
-            } else {
-                CATCH_ERROR( "Unrecognised stream: '" << filename << '\'' );
-            }
-        }
-        return Detail::make_unique<Detail::FileStream>( filename );
-    }
-
-}
-
-
-
-namespace Catch {
-    void JsonUtils::indent( std::ostream& os, std::uint64_t level ) {
-        for ( std::uint64_t i = 0; i < level; ++i ) {
-            os << "  ";
-        }
-    }
-    void JsonUtils::appendCommaNewline( std::ostream& os,
-                                        bool& should_comma,
-                                        std::uint64_t level ) {
-        if ( should_comma ) { os << ','; }
-        should_comma = true;
-        os << '\n';
-        indent( os, level );
-    }
-
-    JsonObjectWriter::JsonObjectWriter( std::ostream& os ):
-        JsonObjectWriter{ os, 0 } {}
-
-    JsonObjectWriter::JsonObjectWriter( std::ostream& os,
-                                        std::uint64_t indent_level ):
-        m_os{ os }, m_indent_level{ indent_level } {
-        m_os << '{';
-    }
-    JsonObjectWriter::JsonObjectWriter( JsonObjectWriter&& source ) noexcept:
-        m_os{ source.m_os },
-        m_indent_level{ source.m_indent_level },
-        m_should_comma{ source.m_should_comma },
-        m_active{ source.m_active } {
-        source.m_active = false;
-    }
-
-    JsonObjectWriter::~JsonObjectWriter() {
-        if ( !m_active ) { return; }
-
-        m_os << '\n';
-        JsonUtils::indent( m_os, m_indent_level );
-        m_os << '}';
-    }
-
-    JsonValueWriter JsonObjectWriter::write( StringRef key ) {
-        JsonUtils::appendCommaNewline(
-            m_os, m_should_comma, m_indent_level + 1 );
-
-        m_os << '"' << key << "\": ";
-        return JsonValueWriter{ m_os, m_indent_level + 1 };
-    }
-
-    JsonArrayWriter::JsonArrayWriter( std::ostream& os ):
-        JsonArrayWriter{ os, 0 } {}
-    JsonArrayWriter::JsonArrayWriter( std::ostream& os,
-                                      std::uint64_t indent_level ):
-        m_os{ os }, m_indent_level{ indent_level } {
-        m_os << '[';
-    }
-    JsonArrayWriter::JsonArrayWriter( JsonArrayWriter&& source ) noexcept:
-        m_os{ source.m_os },
-        m_indent_level{ source.m_indent_level },
-        m_should_comma{ source.m_should_comma },
-        m_active{ source.m_active } {
-        source.m_active = false;
-    }
-    JsonArrayWriter::~JsonArrayWriter() {
-        if ( !m_active ) { return; }
-
-        m_os << '\n';
-        JsonUtils::indent( m_os, m_indent_level );
-        m_os << ']';
-    }
-
-    JsonObjectWriter JsonArrayWriter::writeObject() {
-        JsonUtils::appendCommaNewline(
-            m_os, m_should_comma, m_indent_level + 1 );
-        return JsonObjectWriter{ m_os, m_indent_level + 1 };
-    }
-
-    JsonArrayWriter JsonArrayWriter::writeArray() {
-        JsonUtils::appendCommaNewline(
-            m_os, m_should_comma, m_indent_level + 1 );
-        return JsonArrayWriter{ m_os, m_indent_level + 1 };
-    }
-
-    JsonArrayWriter& JsonArrayWriter::write( bool value ) {
-        return writeImpl( value );
-    }
-
-    JsonValueWriter::JsonValueWriter( std::ostream& os ):
-        JsonValueWriter{ os, 0 } {}
-
-    JsonValueWriter::JsonValueWriter( std::ostream& os,
-                                      std::uint64_t indent_level ):
-        m_os{ os }, m_indent_level{ indent_level } {}
-
-    JsonObjectWriter JsonValueWriter::writeObject() && {
-        return JsonObjectWriter{ m_os, m_indent_level };
-    }
-
-    JsonArrayWriter JsonValueWriter::writeArray() && {
-        return JsonArrayWriter{ m_os, m_indent_level };
-    }
-
-    void JsonValueWriter::write( Catch::StringRef value ) && {
-        writeImpl( value, true );
-    }
-
-    void JsonValueWriter::write( bool value ) && {
-        writeImpl( value ? "true"_sr : "false"_sr, false );
-    }
-
-    void JsonValueWriter::writeImpl( Catch::StringRef value, bool quote ) {
-        if ( quote ) { m_os << '"'; }
-        for (char c : value) {
-            // Escape list taken from https://www.json.org/json-en.html,
-            // string definition.
-            // Note that while forward slash _can_ be escaped, it does
-            // not have to be, if JSON is not further embedded somewhere
-            // where forward slash is meaningful.
-            if ( c == '"' ) {
-                m_os << "\\\"";
-            } else if ( c == '\\' ) {
-                m_os << "\\\\";
-            } else if ( c == '\b' ) {
-                m_os << "\\b";
-            } else if ( c == '\f' ) {
-                m_os << "\\f";
-            } else if ( c == '\n' ) {
-                m_os << "\\n";
-            } else if ( c == '\r' ) {
-                m_os << "\\r";
-            } else if ( c == '\t' ) {
-                m_os << "\\t";
-            } else {
-                m_os << c;
-            }
-        }
-        if ( quote ) { m_os << '"'; }
-    }
-
-} // namespace Catch
-
-
-
-
-namespace Catch {
-
-    auto operator << (std::ostream& os, LazyExpression const& lazyExpr) -> std::ostream& {
-        if (lazyExpr.m_isNegated)
-            os << '!';
-
-        if (lazyExpr) {
-            if (lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression())
-                os << '(' << *lazyExpr.m_transientExpression << ')';
-            else
-                os << *lazyExpr.m_transientExpression;
-        } else {
-            os << "{** error - unchecked empty expression requested **}";
-        }
-        return os;
-    }
-
-} // namespace Catch
-
-
-
-
-#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
-#include <crtdbg.h>
-
-namespace Catch {
-
-    LeakDetector::LeakDetector() {
-        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
-        flag |= _CRTDBG_LEAK_CHECK_DF;
-        flag |= _CRTDBG_ALLOC_MEM_DF;
-        _CrtSetDbgFlag(flag);
-        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
-        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
-        // Change this to leaking allocation's number to break there
-        _CrtSetBreakAlloc(-1);
-    }
-}
-
-#else // ^^ Windows crt debug heap enabled // Windows crt debug heap disabled vv
-
-    Catch::LeakDetector::LeakDetector() = default;
-
-#endif // CATCH_CONFIG_WINDOWS_CRTDBG
-
-Catch::LeakDetector::~LeakDetector() {
-    Catch::cleanUp();
-}
-
-
-
-
-namespace Catch {
-    namespace {
-
-        void listTests(IEventListener& reporter, IConfig const& config) {
-            auto const& testSpec = config.testSpec();
-            auto matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
-            reporter.listTests(matchedTestCases);
-        }
-
-        void listTags(IEventListener& reporter, IConfig const& config) {
-            auto const& testSpec = config.testSpec();
-            std::vector<TestCaseHandle> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
-
-            std::map<StringRef, TagInfo, Detail::CaseInsensitiveLess> tagCounts;
-            for (auto const& testCase : matchedTestCases) {
-                for (auto const& tagName : testCase.getTestCaseInfo().tags) {
-                    auto it = tagCounts.find(tagName.original);
-                    if (it == tagCounts.end())
-                        it = tagCounts.insert(std::make_pair(tagName.original, TagInfo())).first;
-                    it->second.add(tagName.original);
-                }
-            }
-
-            std::vector<TagInfo> infos; infos.reserve(tagCounts.size());
-            for (auto& tagc : tagCounts) {
-                infos.push_back(CATCH_MOVE(tagc.second));
-            }
-
-            reporter.listTags(infos);
-        }
-
-        void listReporters(IEventListener& reporter) {
-            std::vector<ReporterDescription> descriptions;
-
-            auto const& factories = getRegistryHub().getReporterRegistry().getFactories();
-            descriptions.reserve(factories.size());
-            for (auto const& fac : factories) {
-                descriptions.push_back({ fac.first, fac.second->getDescription() });
-            }
-
-            reporter.listReporters(descriptions);
-        }
-
-        void listListeners(IEventListener& reporter) {
-            std::vector<ListenerDescription> descriptions;
-
-            auto const& factories =
-                getRegistryHub().getReporterRegistry().getListeners();
-            descriptions.reserve( factories.size() );
-            for ( auto const& fac : factories ) {
-                descriptions.push_back( { fac->getName(), fac->getDescription() } );
-            }
-
-            reporter.listListeners( descriptions );
-        }
-
-    } // end anonymous namespace
-
-    void TagInfo::add( StringRef spelling ) {
-        ++count;
-        spellings.insert( spelling );
-    }
-
-    std::string TagInfo::all() const {
-        // 2 per tag for brackets '[' and ']'
-        size_t size =  spellings.size() * 2;
-        for (auto const& spelling : spellings) {
-            size += spelling.size();
-        }
-
-        std::string out; out.reserve(size);
-        for (auto const& spelling : spellings) {
-            out += '[';
-            out += spelling;
-            out += ']';
-        }
-        return out;
-    }
-
-    bool list( IEventListener& reporter, Config const& config ) {
-        bool listed = false;
-        if (config.listTests()) {
-            listed = true;
-            listTests(reporter, config);
-        }
-        if (config.listTags()) {
-            listed = true;
-            listTags(reporter, config);
-        }
-        if (config.listReporters()) {
-            listed = true;
-            listReporters(reporter);
-        }
-        if ( config.listListeners() ) {
-            listed = true;
-            listListeners( reporter );
-        }
-        return listed;
-    }
-
-} // end namespace Catch
-
-
-
-namespace Catch {
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-    static LeakDetector leakDetector;
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-}
-
-// Allow users of amalgamated .cpp file to remove our main and provide their own.
-#if !defined(CATCH_AMALGAMATED_CUSTOM_MAIN)
-
-#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
-// Standard C/C++ Win32 Unicode wmain entry point
-extern "C" int __cdecl wmain (int argc, wchar_t * argv[], wchar_t * []) {
-#else
-// Standard C/C++ main entry point
-int main (int argc, char * argv[]) {
-#endif
-
-    // We want to force the linker not to discard the global variable
-    // and its constructor, as it (optionally) registers leak detector
-    (void)&Catch::leakDetector;
-
-    return Catch::Session().run( argc, argv );
-}
-
-#endif // !defined(CATCH_AMALGAMATED_CUSTOM_MAIN
-
-
-
-
-namespace Catch {
-
-    MessageInfo::MessageInfo(   StringRef _macroName,
-                                SourceLineInfo const& _lineInfo,
-                                ResultWas::OfType _type )
-    :   macroName( _macroName ),
-        lineInfo( _lineInfo ),
-        type( _type ),
-        sequence( ++globalCount )
-    {}
-
-    // This may need protecting if threading support is added
-    unsigned int MessageInfo::globalCount = 0;
-
-} // end namespace Catch
-
-
-
-#include <cstdio>
-#include <cstring>
-#include <iosfwd>
-#include <sstream>
-
-#if defined( CATCH_CONFIG_NEW_CAPTURE )
-#    if defined( _MSC_VER )
-#        include <io.h> //_dup and _dup2
-#        define dup _dup
-#        define dup2 _dup2
-#        define fileno _fileno
-#    else
-#        include <unistd.h> // dup and dup2
-#    endif
-#endif
-
-namespace Catch {
-
-    namespace {
-        //! A no-op implementation, used if no reporter wants output
-        //! redirection.
-        class NoopRedirect : public OutputRedirect {
-            void activateImpl() override {}
-            void deactivateImpl() override {}
-            std::string getStdout() override { return {}; }
-            std::string getStderr() override { return {}; }
-            void clearBuffers() override {}
-        };
-
-        /**
-         * Redirects specific stream's rdbuf with another's.
-         *
-         * Redirection can be stopped and started on-demand, assumes
-         * that the underlying stream's rdbuf aren't changed by other
-         * users.
-         */
-        class RedirectedStreamNew {
-            std::ostream& m_originalStream;
-            std::ostream& m_redirectionStream;
-            std::streambuf* m_prevBuf;
-
-        public:
-            RedirectedStreamNew( std::ostream& originalStream,
-                                 std::ostream& redirectionStream ):
-                m_originalStream( originalStream ),
-                m_redirectionStream( redirectionStream ),
-                m_prevBuf( m_originalStream.rdbuf() ) {}
-
-            void startRedirect() {
-                m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
-            }
-            void stopRedirect() { m_originalStream.rdbuf( m_prevBuf ); }
-        };
-
-        /**
-         * Redirects the `std::cout`, `std::cerr`, `std::clog` streams,
-         * but does not touch the actual `stdout`/`stderr` file descriptors.
-         */
-        class StreamRedirect : public OutputRedirect {
-            ReusableStringStream m_redirectedOut, m_redirectedErr;
-            RedirectedStreamNew m_cout, m_cerr, m_clog;
-
-        public:
-            StreamRedirect():
-                m_cout( Catch::cout(), m_redirectedOut.get() ),
-                m_cerr( Catch::cerr(), m_redirectedErr.get() ),
-                m_clog( Catch::clog(), m_redirectedErr.get() ) {}
-
-            void activateImpl() override {
-                m_cout.startRedirect();
-                m_cerr.startRedirect();
-                m_clog.startRedirect();
-            }
-            void deactivateImpl() override {
-                m_cout.stopRedirect();
-                m_cerr.stopRedirect();
-                m_clog.stopRedirect();
-            }
-            std::string getStdout() override { return m_redirectedOut.str(); }
-            std::string getStderr() override { return m_redirectedErr.str(); }
-            void clearBuffers() override {
-                m_redirectedOut.str( "" );
-                m_redirectedErr.str( "" );
-            }
-        };
-
-#if defined( CATCH_CONFIG_NEW_CAPTURE )
-
-        // Windows's implementation of std::tmpfile is terrible (it tries
-        // to create a file inside system folder, thus requiring elevated
-        // privileges for the binary), so we have to use tmpnam(_s) and
-        // create the file ourselves there.
-        class TempFile {
-        public:
-            TempFile( TempFile const& ) = delete;
-            TempFile& operator=( TempFile const& ) = delete;
-            TempFile( TempFile&& ) = delete;
-            TempFile& operator=( TempFile&& ) = delete;
-
-#    if defined( _MSC_VER )
-            TempFile() {
-                if ( tmpnam_s( m_buffer ) ) {
-                    CATCH_RUNTIME_ERROR( "Could not get a temp filename" );
-                }
-                if ( fopen_s( &m_file, m_buffer, "wb+" ) ) {
-                    char buffer[100];
-                    if ( strerror_s( buffer, errno ) ) {
-                        CATCH_RUNTIME_ERROR(
-                            "Could not translate errno to a string" );
-                    }
-                    CATCH_RUNTIME_ERROR( "Could not open the temp file: '"
-                                         << m_buffer
-                                         << "' because: " << buffer );
-                }
-            }
-#    else
-            TempFile() {
-                m_file = std::tmpfile();
-                if ( !m_file ) {
-                    CATCH_RUNTIME_ERROR( "Could not create a temp file." );
-                }
-            }
-#    endif
-
-            ~TempFile() {
-                // TBD: What to do about errors here?
-                std::fclose( m_file );
-                // We manually create the file on Windows only, on Linux
-                // it will be autodeleted
-#    if defined( _MSC_VER )
-                std::remove( m_buffer );
-#    endif
-            }
-
-            std::FILE* getFile() { return m_file; }
-            std::string getContents() {
-                ReusableStringStream sstr;
-                constexpr long buffer_size = 100;
-                char buffer[buffer_size + 1] = {};
-                long current_pos = ftell( m_file );
-                CATCH_ENFORCE( current_pos >= 0,
-                               "ftell failed, errno: " << errno );
-                std::rewind( m_file );
-                while ( current_pos > 0 ) {
-                    auto read_characters =
-                        std::fread( buffer,
-                                    1,
-                                    std::min( buffer_size, current_pos ),
-                                    m_file );
-                    buffer[read_characters] = '\0';
-                    sstr << buffer;
-                    current_pos -= static_cast<long>( read_characters );
-                }
-                return sstr.str();
-            }
-
-            void clear() { std::rewind( m_file ); }
-
-        private:
-            std::FILE* m_file = nullptr;
-            char m_buffer[L_tmpnam] = { 0 };
-        };
-
-        /**
-         * Redirects the actual `stdout`/`stderr` file descriptors.
-         *
-         * Works by replacing the file descriptors numbered 1 and 2
-         * with an open temporary file.
-         */
-        class FileRedirect : public OutputRedirect {
-            TempFile m_outFile, m_errFile;
-            int m_originalOut = -1;
-            int m_originalErr = -1;
-
-            // Flushes cout/cerr/clog streams and stdout/stderr FDs
-            void flushEverything() {
-                Catch::cout() << std::flush;
-                fflush( stdout );
-                // Since we support overriding these streams, we flush cerr
-                // even though std::cerr is unbuffered
-                Catch::cerr() << std::flush;
-                Catch::clog() << std::flush;
-                fflush( stderr );
-            }
-
-        public:
-            FileRedirect():
-                m_originalOut( dup( fileno( stdout ) ) ),
-                m_originalErr( dup( fileno( stderr ) ) ) {
-                CATCH_ENFORCE( m_originalOut >= 0, "Could not dup stdout" );
-                CATCH_ENFORCE( m_originalErr >= 0, "Could not dup stderr" );
-            }
-
-            std::string getStdout() override { return m_outFile.getContents(); }
-            std::string getStderr() override { return m_errFile.getContents(); }
-            void clearBuffers() override {
-                m_outFile.clear();
-                m_errFile.clear();
-            }
-
-            void activateImpl() override {
-                // We flush before starting redirect, to ensure that we do
-                // not capture the end of message sent before activation.
-                flushEverything();
-
-                int ret;
-                ret = dup2( fileno( m_outFile.getFile() ), fileno( stdout ) );
-                CATCH_ENFORCE( ret >= 0,
-                               "dup2 to stdout has failed, errno: " << errno );
-                ret = dup2( fileno( m_errFile.getFile() ), fileno( stderr ) );
-                CATCH_ENFORCE( ret >= 0,
-                               "dup2 to stderr has failed, errno: " << errno );
-            }
-            void deactivateImpl() override {
-                // We flush before ending redirect, to ensure that we
-                // capture all messages sent while the redirect was active.
-                flushEverything();
-
-                int ret;
-                ret = dup2( m_originalOut, fileno( stdout ) );
-                CATCH_ENFORCE(
-                    ret >= 0,
-                    "dup2 of original stdout has failed, errno: " << errno );
-                ret = dup2( m_originalErr, fileno( stderr ) );
-                CATCH_ENFORCE(
-                    ret >= 0,
-                    "dup2 of original stderr has failed, errno: " << errno );
-            }
-        };
-
-#endif // CATCH_CONFIG_NEW_CAPTURE
-
-    } // end namespace
-
-    bool isRedirectAvailable( OutputRedirect::Kind kind ) {
-        switch ( kind ) {
-        // These two are always available
-        case OutputRedirect::None:
-        case OutputRedirect::Streams:
-            return true;
-#if defined( CATCH_CONFIG_NEW_CAPTURE )
-        case OutputRedirect::FileDescriptors:
-            return true;
-#endif
-        default:
-            return false;
-        }
-    }
-
-    Detail::unique_ptr<OutputRedirect> makeOutputRedirect( bool actual ) {
-        if ( actual ) {
-            // TODO: Clean this up later
-#if defined( CATCH_CONFIG_NEW_CAPTURE )
-            return Detail::make_unique<FileRedirect>();
-#else
-            return Detail::make_unique<StreamRedirect>();
-#endif
-        } else {
-            return Detail::make_unique<NoopRedirect>();
-        }
-    }
-
-    RedirectGuard scopedActivate( OutputRedirect& redirectImpl ) {
-        return RedirectGuard( true, redirectImpl );
-    }
-
-    RedirectGuard scopedDeactivate( OutputRedirect& redirectImpl ) {
-        return RedirectGuard( false, redirectImpl );
-    }
-
-    OutputRedirect::~OutputRedirect() = default;
-
-    RedirectGuard::RedirectGuard( bool activate, OutputRedirect& redirectImpl ):
-        m_redirect( &redirectImpl ),
-        m_activate( activate ),
-        m_previouslyActive( redirectImpl.isActive() ) {
-
-        // Skip cases where there is no actual state change.
-        if ( m_activate == m_previouslyActive ) { return; }
-
-        if ( m_activate ) {
-            m_redirect->activate();
-        } else {
-            m_redirect->deactivate();
-        }
-    }
-
-    RedirectGuard::~RedirectGuard() noexcept( false ) {
-        if ( m_moved ) { return; }
-        // Skip cases where there is no actual state change.
-        if ( m_activate == m_previouslyActive ) { return; }
-
-        if ( m_activate ) {
-            m_redirect->deactivate();
-        } else {
-            m_redirect->activate();
-        }
-    }
-
-    RedirectGuard::RedirectGuard( RedirectGuard&& rhs ) noexcept:
-        m_redirect( rhs.m_redirect ),
-        m_activate( rhs.m_activate ),
-        m_previouslyActive( rhs.m_previouslyActive ),
-        m_moved( false ) {
-        rhs.m_moved = true;
-    }
-
-    RedirectGuard& RedirectGuard::operator=( RedirectGuard&& rhs ) noexcept {
-        m_redirect = rhs.m_redirect;
-        m_activate = rhs.m_activate;
-        m_previouslyActive = rhs.m_previouslyActive;
-        m_moved = false;
-        rhs.m_moved = true;
-        return *this;
-    }
-
-} // namespace Catch
-
-#if defined( CATCH_CONFIG_NEW_CAPTURE )
-#    if defined( _MSC_VER )
-#        undef dup
-#        undef dup2
-#        undef fileno
-#    endif
-#endif
-
-
-
-
-#include <limits>
-#include <stdexcept>
-
-namespace Catch {
-
-    Optional<unsigned int> parseUInt(std::string const& input, int base) {
-        auto trimmed = trim( input );
-        // std::stoull is annoying and accepts numbers starting with '-',
-        // it just negates them into unsigned int
-        if ( trimmed.empty() || trimmed[0] == '-' ) {
-            return {};
-        }
-
-        CATCH_TRY {
-            size_t pos = 0;
-            const auto ret = std::stoull( trimmed, &pos, base );
-
-            // We did not consume the whole input, so there is an issue
-            // This can be bunch of different stuff, like multiple numbers
-            // in the input, or invalid digits/characters and so on. Either
-            // way, we do not want to return the partially parsed result.
-            if ( pos != trimmed.size() ) {
-                return {};
-            }
-            // Too large
-            if ( ret > std::numeric_limits<unsigned int>::max() ) {
-                return {};
-            }
-            return static_cast<unsigned int>(ret);
-        }
-        CATCH_CATCH_ANON( std::invalid_argument const& ) {
-            // no conversion could be performed
-        }
-        CATCH_CATCH_ANON( std::out_of_range const& ) {
-            // the input does not fit into an unsigned long long
-        }
-        return {};
-    }
-
-} // namespace Catch
-
-
-
-
-#include <cmath>
-
-namespace Catch {
-
-#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
-    bool isnan(float f) {
-        return std::isnan(f);
-    }
-    bool isnan(double d) {
-        return std::isnan(d);
-    }
-#else
-    // For now we only use this for embarcadero
-    bool isnan(float f) {
-        return std::_isnan(f);
-    }
-    bool isnan(double d) {
-        return std::_isnan(d);
-    }
-#endif
-
-#if !defined( CATCH_CONFIG_GLOBAL_NEXTAFTER )
-    float nextafter( float x, float y ) { return std::nextafter( x, y ); }
-    double nextafter( double x, double y ) { return std::nextafter( x, y ); }
-#else
-    float nextafter( float x, float y ) { return ::nextafterf( x, y ); }
-    double nextafter( double x, double y ) { return ::nextafter( x, y ); }
-#endif
-
-} // end namespace Catch
-
-
-
-namespace Catch {
-
-namespace {
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4146) // we negate uint32 during the rotate
-#endif
-        // Safe rotr implementation thanks to John Regehr
-        uint32_t rotate_right(uint32_t val, uint32_t count) {
-            const uint32_t mask = 31;
-            count &= mask;
-            return (val >> count) | (val << (-count & mask));
-        }
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-}
-
-
-    SimplePcg32::SimplePcg32(result_type seed_) {
-        seed(seed_);
-    }
-
-
-    void SimplePcg32::seed(result_type seed_) {
-        m_state = 0;
-        (*this)();
-        m_state += seed_;
-        (*this)();
-    }
-
-    void SimplePcg32::discard(uint64_t skip) {
-        // We could implement this to run in O(log n) steps, but this
-        // should suffice for our use case.
-        for (uint64_t s = 0; s < skip; ++s) {
-            static_cast<void>((*this)());
-        }
-    }
-
-    SimplePcg32::result_type SimplePcg32::operator()() {
-        // prepare the output value
-        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
-        const auto output = rotate_right(xorshifted, m_state >> 59u);
-
-        // advance state
-        m_state = m_state * 6364136223846793005ULL + s_inc;
-
-        return output;
-    }
-
-    bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
-        return lhs.m_state == rhs.m_state;
-    }
-
-    bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
-        return lhs.m_state != rhs.m_state;
-    }
-}
-
-
-
-
-
-#include <ctime>
-#include <random>
-
-namespace Catch {
-
-    std::uint32_t generateRandomSeed( GenerateFrom from ) {
-        switch ( from ) {
-        case GenerateFrom::Time:
-            return static_cast<std::uint32_t>( std::time( nullptr ) );
-
-        case GenerateFrom::Default:
-        case GenerateFrom::RandomDevice: {
-            std::random_device rd;
-            return Detail::fillBitsFrom<std::uint32_t>( rd );
-        }
-
-        default:
-            CATCH_ERROR("Unknown generation method");
-        }
-    }
-
-} // end namespace Catch
-
-
-
-
-namespace Catch {
-    struct ReporterRegistry::ReporterRegistryImpl {
-        std::vector<Detail::unique_ptr<EventListenerFactory>> listeners;
-        std::map<std::string, IReporterFactoryPtr, Detail::CaseInsensitiveLess>
-            factories;
-    };
-
-    ReporterRegistry::ReporterRegistry():
-        m_impl( Detail::make_unique<ReporterRegistryImpl>() ) {
-        // Because it is impossible to move out of initializer list,
-        // we have to add the elements manually
-        m_impl->factories["Automake"] =
-            Detail::make_unique<ReporterFactory<AutomakeReporter>>();
-        m_impl->factories["compact"] =
-            Detail::make_unique<ReporterFactory<CompactReporter>>();
-        m_impl->factories["console"] =
-            Detail::make_unique<ReporterFactory<ConsoleReporter>>();
-        m_impl->factories["JUnit"] =
-            Detail::make_unique<ReporterFactory<JunitReporter>>();
-        m_impl->factories["SonarQube"] =
-            Detail::make_unique<ReporterFactory<SonarQubeReporter>>();
-        m_impl->factories["TAP"] =
-            Detail::make_unique<ReporterFactory<TAPReporter>>();
-        m_impl->factories["TeamCity"] =
-            Detail::make_unique<ReporterFactory<TeamCityReporter>>();
-        m_impl->factories["XML"] =
-            Detail::make_unique<ReporterFactory<XmlReporter>>();
-        m_impl->factories["JSON"] =
-            Detail::make_unique<ReporterFactory<JsonReporter>>();
-    }
-
-    ReporterRegistry::~ReporterRegistry() = default;
-
-    IEventListenerPtr
-    ReporterRegistry::create( std::string const& name,
-                              ReporterConfig&& config ) const {
-        auto it = m_impl->factories.find( name );
-        if ( it == m_impl->factories.end() ) return nullptr;
-        return it->second->create( CATCH_MOVE( config ) );
-    }
-
-    void ReporterRegistry::registerReporter( std::string const& name,
-                                             IReporterFactoryPtr factory ) {
-        CATCH_ENFORCE( name.find( "::" ) == name.npos,
-                       "'::' is not allowed in reporter name: '" + name +
-                           '\'' );
-        auto ret = m_impl->factories.emplace( name, CATCH_MOVE( factory ) );
-        CATCH_ENFORCE( ret.second,
-                       "reporter using '" + name +
-                           "' as name was already registered" );
-    }
-    void ReporterRegistry::registerListener(
-        Detail::unique_ptr<EventListenerFactory> factory ) {
-        m_impl->listeners.push_back( CATCH_MOVE( factory ) );
-    }
-
-    std::map<std::string,
-             IReporterFactoryPtr,
-             Detail::CaseInsensitiveLess> const&
-    ReporterRegistry::getFactories() const {
-        return m_impl->factories;
-    }
-
-    std::vector<Detail::unique_ptr<EventListenerFactory>> const&
-    ReporterRegistry::getListeners() const {
-        return m_impl->listeners;
-    }
-} // namespace Catch
-
-
-
-
-
-#include <algorithm>
-
-namespace Catch {
-
-    namespace {
-        struct kvPair {
-            StringRef key, value;
-        };
-
-        kvPair splitKVPair(StringRef kvString) {
-            auto splitPos = static_cast<size_t>(
-                std::find( kvString.begin(), kvString.end(), '=' ) -
-                kvString.begin() );
-
-            return { kvString.substr( 0, splitPos ),
-                     kvString.substr( splitPos + 1, kvString.size() ) };
-        }
-    }
-
-    namespace Detail {
-        std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
-            static constexpr auto separator = "::";
-            static constexpr size_t separatorSize = 2;
-
-            size_t separatorPos = 0;
-            auto findNextSeparator = [&reporterSpec]( size_t startPos ) {
-                static_assert(
-                    separatorSize == 2,
-                    "The code below currently assumes 2 char separator" );
-
-                auto currentPos = startPos;
-                do {
-                    while ( currentPos < reporterSpec.size() &&
-                            reporterSpec[currentPos] != separator[0] ) {
-                        ++currentPos;
-                    }
-                    if ( currentPos + 1 < reporterSpec.size() &&
-                         reporterSpec[currentPos + 1] == separator[1] ) {
-                        return currentPos;
-                    }
-                    ++currentPos;
-                } while ( currentPos < reporterSpec.size() );
-
-                return static_cast<size_t>( -1 );
-            };
-
-            std::vector<std::string> parts;
-
-            while ( separatorPos < reporterSpec.size() ) {
-                const auto nextSeparator = findNextSeparator( separatorPos );
-                parts.push_back( static_cast<std::string>( reporterSpec.substr(
-                    separatorPos, nextSeparator - separatorPos ) ) );
-
-                if ( nextSeparator == static_cast<size_t>( -1 ) ) {
-                    break;
-                }
-                separatorPos = nextSeparator + separatorSize;
-            }
-
-            // Handle a separator at the end.
-            // This is not a valid spec, but we want to do validation in a
-            // centralized place
-            if ( separatorPos == reporterSpec.size() ) {
-                parts.emplace_back();
-            }
-
-            return parts;
-        }
-
-        Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
-            if ( colourMode == "default" ) {
-                return ColourMode::PlatformDefault;
-            } else if ( colourMode == "ansi" ) {
-                return ColourMode::ANSI;
-            } else if ( colourMode == "win32" ) {
-                return ColourMode::Win32;
-            } else if ( colourMode == "none" ) {
-                return ColourMode::None;
-            } else {
-                return {};
-            }
-        }
-    } // namespace Detail
-
-
-    bool operator==( ReporterSpec const& lhs, ReporterSpec const& rhs ) {
-        return lhs.m_name == rhs.m_name &&
-               lhs.m_outputFileName == rhs.m_outputFileName &&
-               lhs.m_colourMode == rhs.m_colourMode &&
-               lhs.m_customOptions == rhs.m_customOptions;
-    }
-
-    Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec ) {
-        auto parts = Detail::splitReporterSpec( reporterSpec );
-
-        assert( parts.size() > 0 && "Split should never return empty vector" );
-
-        std::map<std::string, std::string> kvPairs;
-        Optional<std::string> outputFileName;
-        Optional<ColourMode> colourMode;
-
-        // First part is always reporter name, so we skip it
-        for ( size_t i = 1; i < parts.size(); ++i ) {
-            auto kv = splitKVPair( parts[i] );
-            auto key = kv.key, value = kv.value;
-
-            if ( key.empty() || value.empty() ) { // NOLINT(bugprone-branch-clone)
-                return {};
-            } else if ( key[0] == 'X' ) {
-                // This is a reporter-specific option, we don't check these
-                // apart from basic sanity checks
-                if ( key.size() == 1 ) {
-                    return {};
-                }
-
-                auto ret = kvPairs.emplace( std::string(kv.key), std::string(kv.value) );
-                if ( !ret.second ) {
-                    // Duplicated key. We might want to handle this differently,
-                    // e.g. by overwriting the existing value?
-                    return {};
-                }
-            } else if ( key == "out" ) {
-                // Duplicated key
-                if ( outputFileName ) {
-                    return {};
-                }
-                outputFileName = static_cast<std::string>( value );
-            } else if ( key == "colour-mode" ) {
-                // Duplicated key
-                if ( colourMode ) {
-                    return {};
-                }
-                colourMode = Detail::stringToColourMode( value );
-                // Parsing failed
-                if ( !colourMode ) {
-                    return {};
-                }
-            } else {
-                // Unrecognized option
-                return {};
-            }
-        }
-
-        return ReporterSpec{ CATCH_MOVE( parts[0] ),
-                             CATCH_MOVE( outputFileName ),
-                             CATCH_MOVE( colourMode ),
-                             CATCH_MOVE( kvPairs ) };
-    }
-
-ReporterSpec::ReporterSpec(
-        std::string name,
-        Optional<std::string> outputFileName,
-        Optional<ColourMode> colourMode,
-        std::map<std::string, std::string> customOptions ):
-        m_name( CATCH_MOVE( name ) ),
-        m_outputFileName( CATCH_MOVE( outputFileName ) ),
-        m_colourMode( CATCH_MOVE( colourMode ) ),
-        m_customOptions( CATCH_MOVE( customOptions ) ) {}
-
-} // namespace Catch
-
-
-
-#include <cstdio>
-#include <sstream>
-#include <vector>
-
-namespace Catch {
-
-    // This class encapsulates the idea of a pool of ostringstreams that can be reused.
-    struct StringStreams {
-        std::vector<Detail::unique_ptr<std::ostringstream>> m_streams;
-        std::vector<std::size_t> m_unused;
-        std::ostringstream m_referenceStream; // Used for copy state/ flags from
-
-        auto add() -> std::size_t {
-            if( m_unused.empty() ) {
-                m_streams.push_back( Detail::make_unique<std::ostringstream>() );
-                return m_streams.size()-1;
-            }
-            else {
-                auto index = m_unused.back();
-                m_unused.pop_back();
-                return index;
-            }
-        }
-
-        void release( std::size_t index ) {
-            m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
-            m_unused.push_back(index);
-        }
-    };
-
-    ReusableStringStream::ReusableStringStream()
-    :   m_index( Singleton<StringStreams>::getMutable().add() ),
-        m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
-    {}
-
-    ReusableStringStream::~ReusableStringStream() {
-        static_cast<std::ostringstream*>( m_oss )->str("");
-        m_oss->clear();
-        Singleton<StringStreams>::getMutable().release( m_index );
-    }
-
-    std::string ReusableStringStream::str() const {
-        return static_cast<std::ostringstream*>( m_oss )->str();
-    }
-
-    void ReusableStringStream::str( std::string const& str ) {
-        static_cast<std::ostringstream*>( m_oss )->str( str );
-    }
-
-
-}
-
-
-
-
-#include <cassert>
-#include <algorithm>
-
-namespace Catch {
-
-    namespace Generators {
-        namespace {
-            struct GeneratorTracker final : TestCaseTracking::TrackerBase,
-                                      IGeneratorTracker {
-                GeneratorBasePtr m_generator;
-
-                GeneratorTracker(
-                    TestCaseTracking::NameAndLocation&& nameAndLocation,
-                    TrackerContext& ctx,
-                    ITracker* parent ):
-                    TrackerBase( CATCH_MOVE( nameAndLocation ), ctx, parent ) {}
-
-                static GeneratorTracker*
-                acquire( TrackerContext& ctx,
-                         TestCaseTracking::NameAndLocationRef const&
-                             nameAndLocation ) {
-                    GeneratorTracker* tracker;
-
-                    ITracker& currentTracker = ctx.currentTracker();
-                    // Under specific circumstances, the generator we want
-                    // to acquire is also the current tracker. If this is
-                    // the case, we have to avoid looking through current
-                    // tracker's children, and instead return the current
-                    // tracker.
-                    // A case where this check is important is e.g.
-                    //     for (int i = 0; i < 5; ++i) {
-                    //         int n = GENERATE(1, 2);
-                    //     }
-                    //
-                    // without it, the code above creates 5 nested generators.
-                    if ( currentTracker.nameAndLocation() == nameAndLocation ) {
-                        auto thisTracker = currentTracker.parent()->findChild(
-                            nameAndLocation );
-                        assert( thisTracker );
-                        assert( thisTracker->isGeneratorTracker() );
-                        tracker = static_cast<GeneratorTracker*>( thisTracker );
-                    } else if ( ITracker* childTracker =
-                                    currentTracker.findChild(
-                                        nameAndLocation ) ) {
-                        assert( childTracker );
-                        assert( childTracker->isGeneratorTracker() );
-                        tracker =
-                            static_cast<GeneratorTracker*>( childTracker );
-                    } else {
-                        return nullptr;
-                    }
-
-                    if ( !tracker->isComplete() ) { tracker->open(); }
-
-                    return tracker;
-                }
-
-                // TrackerBase interface
-                bool isGeneratorTracker() const override { return true; }
-                auto hasGenerator() const -> bool override {
-                    return !!m_generator;
-                }
-                void close() override {
-                    TrackerBase::close();
-                    // If a generator has a child (it is followed by a section)
-                    // and none of its children have started, then we must wait
-                    // until later to start consuming its values.
-                    // This catches cases where `GENERATE` is placed between two
-                    // `SECTION`s.
-                    // **The check for m_children.empty cannot be removed**.
-                    // doing so would break `GENERATE` _not_ followed by
-                    // `SECTION`s.
-                    const bool should_wait_for_child = [&]() {
-                        // No children -> nobody to wait for
-                        if ( m_children.empty() ) { return false; }
-                        // If at least one child started executing, don't wait
-                        if ( std::find_if(
-                                 m_children.begin(),
-                                 m_children.end(),
-                                 []( TestCaseTracking::ITrackerPtr const&
-                                         tracker ) {
-                                     return tracker->hasStarted();
-                                 } ) != m_children.end() ) {
-                            return false;
-                        }
-
-                        // No children have started. We need to check if they
-                        // _can_ start, and thus we should wait for them, or
-                        // they cannot start (due to filters), and we shouldn't
-                        // wait for them
-                        ITracker* parent = m_parent;
-                        // This is safe: there is always at least one section
-                        // tracker in a test case tracking tree
-                        while ( !parent->isSectionTracker() ) {
-                            parent = parent->parent();
-                        }
-                        assert( parent &&
-                                "Missing root (test case) level section" );
-
-                        auto const& parentSection =
-                            static_cast<SectionTracker const&>( *parent );
-                        auto const& filters = parentSection.getFilters();
-                        // No filters -> no restrictions on running sections
-                        if ( filters.empty() ) { return true; }
-
-                        for ( auto const& child : m_children ) {
-                            if ( child->isSectionTracker() &&
-                                 std::find( filters.begin(),
-                                            filters.end(),
-                                            static_cast<SectionTracker const&>(
-                                                *child )
-                                                .trimmedName() ) !=
-                                     filters.end() ) {
-                                return true;
-                            }
-                        }
-                        return false;
-                    }();
-
-                    // This check is a bit tricky, because m_generator->next()
-                    // has a side-effect, where it consumes generator's current
-                    // value, but we do not want to invoke the side-effect if
-                    // this generator is still waiting for any child to start.
-                    assert( m_generator && "Tracker without generator" );
-                    if ( should_wait_for_child ||
-                         ( m_runState == CompletedSuccessfully &&
-                           m_generator->countedNext() ) ) {
-                        m_children.clear();
-                        m_runState = Executing;
-                    }
-                }
-
-                // IGeneratorTracker interface
-                auto getGenerator() const -> GeneratorBasePtr const& override {
-                    return m_generator;
-                }
-                void setGenerator( GeneratorBasePtr&& generator ) override {
-                    m_generator = CATCH_MOVE( generator );
-                }
-            };
-        } // namespace
-    }
-
-    RunContext::RunContext(IConfig const* _config, IEventListenerPtr&& reporter)
-    :   m_runInfo(_config->name()),
-        m_config(_config),
-        m_reporter(CATCH_MOVE(reporter)),
-        m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
-        m_outputRedirect( makeOutputRedirect( m_reporter->getPreferences().shouldRedirectStdOut ) ),
-        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
-    {
-        getCurrentMutableContext().setResultCapture( this );
-        m_reporter->testRunStarting(m_runInfo);
-    }
-
-    RunContext::~RunContext() {
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
-    }
-
-    Totals RunContext::runTest(TestCaseHandle const& testCase) {
-        const Totals prevTotals = m_totals;
-
-        auto const& testInfo = testCase.getTestCaseInfo();
-        m_reporter->testCaseStarting(testInfo);
-        testCase.prepareTestCase();
-        m_activeTestCase = &testCase;
-
-
-        ITracker& rootTracker = m_trackerContext.startRun();
-        assert(rootTracker.isSectionTracker());
-        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
-
-        // We intentionally only seed the internal RNG once per test case,
-        // before it is first invoked. The reason for that is a complex
-        // interplay of generator/section implementation details and the
-        // Random*Generator types.
-        //
-        // The issue boils down to us needing to seed the Random*Generators
-        // with different seed each, so that they return different sequences
-        // of random numbers. We do this by giving them a number from the
-        // shared RNG instance as their seed.
-        //
-        // However, this runs into an issue if the reseeding happens each
-        // time the test case is entered (as opposed to first time only),
-        // because multiple generators could get the same seed, e.g. in
-        // ```cpp
-        // TEST_CASE() {
-        //     auto i = GENERATE(take(10, random(0, 100));
-        //     SECTION("A") {
-        //         auto j = GENERATE(take(10, random(0, 100));
-        //     }
-        //     SECTION("B") {
-        //         auto k = GENERATE(take(10, random(0, 100));
-        //     }
-        // }
-        // ```
-        // `i` and `j` would properly return values from different sequences,
-        // but `i` and `k` would return the same sequence, because their seed
-        // would be the same.
-        // (The reason their seeds would be the same is that the generator
-        //  for k would be initialized when the test case is entered the second
-        //  time, after the shared RNG instance was reset to the same value
-        //  it had when the generator for i was initialized.)
-        seedRng( *m_config );
-
-        uint64_t testRuns = 0;
-        std::string redirectedCout;
-        std::string redirectedCerr;
-        do {
-            m_trackerContext.startCycle();
-            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocationRef(testInfo.name, testInfo.lineInfo));
-
-            m_reporter->testCasePartialStarting(testInfo, testRuns);
-
-            const auto beforeRunTotals = m_totals;
-            runCurrentTest();
-            std::string oneRunCout = m_outputRedirect->getStdout();
-            std::string oneRunCerr = m_outputRedirect->getStderr();
-            m_outputRedirect->clearBuffers();
-            redirectedCout += oneRunCout;
-            redirectedCerr += oneRunCerr;
-
-            const auto singleRunTotals = m_totals.delta(beforeRunTotals);
-            auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, CATCH_MOVE(oneRunCout), CATCH_MOVE(oneRunCerr), aborting());
-            m_reporter->testCasePartialEnded(statsForOneRun, testRuns);
-
-            ++testRuns;
-        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
-
-        Totals deltaTotals = m_totals.delta(prevTotals);
-        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
-            deltaTotals.assertions.failed++;
-            deltaTotals.testCases.passed--;
-            deltaTotals.testCases.failed++;
-        }
-        m_totals.testCases += deltaTotals.testCases;
-        testCase.tearDownTestCase();
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  CATCH_MOVE(redirectedCout),
-                                  CATCH_MOVE(redirectedCerr),
-                                  aborting()));
-
-        m_activeTestCase = nullptr;
-        m_testCaseTracker = nullptr;
-
-        return deltaTotals;
-    }
-
-
-    void RunContext::assertionEnded(AssertionResult&& result) {
-        if (result.getResultType() == ResultWas::Ok) {
-            m_totals.assertions.passed++;
-            m_lastAssertionPassed = true;
-        } else if (result.getResultType() == ResultWas::ExplicitSkip) {
-            m_totals.assertions.skipped++;
-            m_lastAssertionPassed = true;
-        } else if (!result.succeeded()) {
-            m_lastAssertionPassed = false;
-            if (result.isOk()) {
-            }
-            else if( m_activeTestCase->getTestCaseInfo().okToFail() )
-                m_totals.assertions.failedButOk++;
-            else
-                m_totals.assertions.failed++;
-        }
-        else {
-            m_lastAssertionPassed = true;
-        }
-
-        {
-            auto _ = scopedDeactivate( *m_outputRedirect );
-            m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) );
-        }
-
-        if ( result.getResultType() != ResultWas::Warning ) {
-            m_messageScopes.clear();
-        }
-
-        // Reset working state. assertion info will be reset after
-        // populateReaction is run if it is needed
-        m_lastResult = CATCH_MOVE( result );
-    }
-    void RunContext::resetAssertionInfo() {
-        m_lastAssertionInfo.macroName = StringRef();
-        m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
-        m_lastAssertionInfo.resultDisposition = ResultDisposition::Normal;
-    }
-
-    void RunContext::notifyAssertionStarted( AssertionInfo const& info ) {
-        auto _ = scopedDeactivate( *m_outputRedirect );
-        m_reporter->assertionStarting( info );
-    }
-
-    bool RunContext::sectionStarted( StringRef sectionName,
-                                     SourceLineInfo const& sectionLineInfo,
-                                     Counts& assertions ) {
-        ITracker& sectionTracker =
-            SectionTracker::acquire( m_trackerContext,
-                                     TestCaseTracking::NameAndLocationRef(
-                                         sectionName, sectionLineInfo ) );
-
-        if (!sectionTracker.isOpen())
-            return false;
-        m_activeSections.push_back(&sectionTracker);
-
-        SectionInfo sectionInfo( sectionLineInfo, static_cast<std::string>(sectionName) );
-        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
-
-        {
-            auto _ = scopedDeactivate( *m_outputRedirect );
-            m_reporter->sectionStarting( sectionInfo );
-        }
-
-        assertions = m_totals.assertions;
-
-        return true;
-    }
-    IGeneratorTracker*
-    RunContext::acquireGeneratorTracker( StringRef generatorName,
-                                         SourceLineInfo const& lineInfo ) {
-        using namespace Generators;
-        GeneratorTracker* tracker = GeneratorTracker::acquire(
-            m_trackerContext,
-            TestCaseTracking::NameAndLocationRef(
-                 generatorName, lineInfo ) );
-        m_lastAssertionInfo.lineInfo = lineInfo;
-        return tracker;
-    }
-
-    IGeneratorTracker* RunContext::createGeneratorTracker(
-        StringRef generatorName,
-        SourceLineInfo lineInfo,
-        Generators::GeneratorBasePtr&& generator ) {
-
-        auto nameAndLoc = TestCaseTracking::NameAndLocation( static_cast<std::string>( generatorName ), lineInfo );
-        auto& currentTracker = m_trackerContext.currentTracker();
-        assert(
-            currentTracker.nameAndLocation() != nameAndLoc &&
-            "Trying to create tracker for a genreator that already has one" );
-
-        auto newTracker = Catch::Detail::make_unique<Generators::GeneratorTracker>(
-            CATCH_MOVE(nameAndLoc), m_trackerContext, &currentTracker );
-        auto ret = newTracker.get();
-        currentTracker.addChild( CATCH_MOVE( newTracker ) );
-
-        ret->setGenerator( CATCH_MOVE( generator ) );
-        ret->open();
-        return ret;
-    }
-
-    bool RunContext::testForMissingAssertions(Counts& assertions) {
-        if (assertions.total() != 0)
-            return false;
-        if (!m_config->warnAboutMissingAssertions())
-            return false;
-        if (m_trackerContext.currentTracker().hasChildren())
-            return false;
-        m_totals.assertions.failed++;
-        assertions.failed++;
-        return true;
-    }
-
-    void RunContext::sectionEnded(SectionEndInfo&& endInfo) {
-        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
-
-        if (!m_activeSections.empty()) {
-            m_activeSections.back()->close();
-            m_activeSections.pop_back();
-        }
-
-        {
-            auto _ = scopedDeactivate( *m_outputRedirect );
-            m_reporter->sectionEnded(
-                SectionStats( CATCH_MOVE( endInfo.sectionInfo ),
-                              assertions,
-                              endInfo.durationInSeconds,
-                              missingAssertions ) );
-        }
-
-        m_messages.clear();
-        m_messageScopes.clear();
-    }
-
-    void RunContext::sectionEndedEarly(SectionEndInfo&& endInfo) {
-        if ( m_unfinishedSections.empty() ) {
-            m_activeSections.back()->fail();
-        } else {
-            m_activeSections.back()->close();
-        }
-        m_activeSections.pop_back();
-
-        m_unfinishedSections.push_back(CATCH_MOVE(endInfo));
-    }
-
-    void RunContext::benchmarkPreparing( StringRef name ) {
-        auto _ = scopedDeactivate( *m_outputRedirect );
-        m_reporter->benchmarkPreparing( name );
-    }
-    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
-        auto _ = scopedDeactivate( *m_outputRedirect );
-        m_reporter->benchmarkStarting( info );
-    }
-    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
-        auto _ = scopedDeactivate( *m_outputRedirect );
-        m_reporter->benchmarkEnded( stats );
-    }
-    void RunContext::benchmarkFailed( StringRef error ) {
-        auto _ = scopedDeactivate( *m_outputRedirect );
-        m_reporter->benchmarkFailed( error );
-    }
-
-    void RunContext::pushScopedMessage(MessageInfo const & message) {
-        m_messages.push_back(message);
-    }
-
-    void RunContext::popScopedMessage(MessageInfo const & message) {
-        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
-    }
-
-    void RunContext::emplaceUnscopedMessage( MessageBuilder&& builder ) {
-        m_messageScopes.emplace_back( CATCH_MOVE(builder) );
-    }
-
-    std::string RunContext::getCurrentTestName() const {
-        return m_activeTestCase
-            ? m_activeTestCase->getTestCaseInfo().name
-            : std::string();
-    }
-
-    const AssertionResult * RunContext::getLastResult() const {
-        return &(*m_lastResult);
-    }
-
-    void RunContext::exceptionEarlyReported() {
-        m_shouldReportUnexpected = false;
-    }
-
-    void RunContext::handleFatalErrorCondition( StringRef message ) {
-        // TODO: scoped deactivate here? Just give up and do best effort?
-        //       the deactivation can break things further, OTOH so can the
-        //       capture
-        auto _ = scopedDeactivate( *m_outputRedirect );
-
-        // First notify reporter that bad things happened
-        m_reporter->fatalErrorEncountered( message );
-
-        // Don't rebuild the result -- the stringification itself can cause more fatal errors
-        // Instead, fake a result data.
-        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
-        tempResult.message = static_cast<std::string>(message);
-        AssertionResult result(m_lastAssertionInfo, CATCH_MOVE(tempResult));
-
-        assertionEnded(CATCH_MOVE(result) );
-        resetAssertionInfo();
-
-        // Best effort cleanup for sections that have not been destructed yet
-        // Since this is a fatal error, we have not had and won't have the opportunity to destruct them properly
-        while (!m_activeSections.empty()) {
-            auto nl = m_activeSections.back()->nameAndLocation();
-            SectionEndInfo endInfo{ SectionInfo(CATCH_MOVE(nl.location), CATCH_MOVE(nl.name)), {}, 0.0 };
-            sectionEndedEarly(CATCH_MOVE(endInfo));
-        }
-        handleUnfinishedSections();
-
-        // Recreate section for test case (as we will lose the one that was in scope)
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
-
-        Counts assertions;
-        assertions.failed = 1;
-        SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, 0, false);
-        m_reporter->sectionEnded( testCaseSectionStats );
-
-        auto const& testInfo = m_activeTestCase->getTestCaseInfo();
-
-        Totals deltaTotals;
-        deltaTotals.testCases.failed = 1;
-        deltaTotals.assertions.failed = 1;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  std::string(),
-                                  std::string(),
-                                  false));
-        m_totals.testCases.failed++;
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
-    }
-
-    bool RunContext::lastAssertionPassed() {
-         return m_lastAssertionPassed;
-    }
-
-    void RunContext::assertionPassed() {
-        m_lastAssertionPassed = true;
-        ++m_totals.assertions.passed;
-        resetAssertionInfo();
-        m_messageScopes.clear();
-    }
-
-    bool RunContext::aborting() const {
-        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
-    }
-
-    void RunContext::runCurrentTest() {
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
-        m_reporter->sectionStarting(testCaseSection);
-        Counts prevAssertions = m_totals.assertions;
-        double duration = 0;
-        m_shouldReportUnexpected = true;
-        m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
-
-        Timer timer;
-        CATCH_TRY {
-            {
-                auto _ = scopedActivate( *m_outputRedirect );
-                timer.start();
-                invokeActiveTestCase();
-            }
-            duration = timer.getElapsedSeconds();
-        } CATCH_CATCH_ANON (TestFailureException&) {
-            // This just means the test was aborted due to failure
-        } CATCH_CATCH_ANON (TestSkipException&) {
-            // This just means the test was explicitly skipped
-        } CATCH_CATCH_ALL {
-            // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
-            // are reported without translation at the point of origin.
-            if( m_shouldReportUnexpected ) {
-                AssertionReaction dummyReaction;
-                handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
-            }
-        }
-        Counts assertions = m_totals.assertions - prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
-
-        m_testCaseTracker->close();
-        handleUnfinishedSections();
-        m_messages.clear();
-        m_messageScopes.clear();
-
-        SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, duration, missingAssertions);
-        m_reporter->sectionEnded(testCaseSectionStats);
-    }
-
-    void RunContext::invokeActiveTestCase() {
-        // We need to engage a handler for signals/structured exceptions
-        // before running the tests themselves, or the binary can crash
-        // without failed test being reported.
-        FatalConditionHandlerGuard _(&m_fatalConditionhandler);
-        // We keep having issue where some compilers warn about an unused
-        // variable, even though the type has non-trivial constructor and
-        // destructor. This is annoying and ugly, but it makes them stfu.
-        (void)_;
-
-        m_activeTestCase->invoke();
-    }
-
-    void RunContext::handleUnfinishedSections() {
-        // If sections ended prematurely due to an exception we stored their
-        // infos here so we can tear them down outside the unwind process.
-        for ( auto it = m_unfinishedSections.rbegin(),
-                   itEnd = m_unfinishedSections.rend();
-              it != itEnd;
-              ++it ) {
-            sectionEnded( CATCH_MOVE( *it ) );
-        }
-        m_unfinishedSections.clear();
-    }
-
-    void RunContext::handleExpr(
-        AssertionInfo const& info,
-        ITransientExpression const& expr,
-        AssertionReaction& reaction
-    ) {
-        bool negated = isFalseTest( info.resultDisposition );
-        bool result = expr.getResult() != negated;
-
-        if( result ) {
-            if (!m_includeSuccessfulResults) {
-                assertionPassed();
-            }
-            else {
-                reportExpr(info, ResultWas::Ok, &expr, negated);
-            }
-        }
-        else {
-            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
-            populateReaction( reaction );
-        }
-        resetAssertionInfo();
-    }
-    void RunContext::reportExpr(
-            AssertionInfo const &info,
-            ResultWas::OfType resultType,
-            ITransientExpression const *expr,
-            bool negated ) {
-
-        m_lastAssertionInfo = info;
-        AssertionResultData data( resultType, LazyExpression( negated ) );
-
-        AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
-        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
-
-        assertionEnded( CATCH_MOVE(assertionResult) );
-    }
-
-    void RunContext::handleMessage(
-            AssertionInfo const& info,
-            ResultWas::OfType resultType,
-            std::string&& message,
-            AssertionReaction& reaction
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( resultType, LazyExpression( false ) );
-        data.message = CATCH_MOVE( message );
-        AssertionResult assertionResult{ m_lastAssertionInfo,
-                                         CATCH_MOVE( data ) };
-
-        const auto isOk = assertionResult.isOk();
-        assertionEnded( CATCH_MOVE(assertionResult) );
-        if ( !isOk ) {
-            populateReaction( reaction );
-        } else if ( resultType == ResultWas::ExplicitSkip ) {
-            // TODO: Need to handle this explicitly, as ExplicitSkip is
-            // considered "OK"
-            reaction.shouldSkip = true;
-        }
-        resetAssertionInfo();
-    }
-    void RunContext::handleUnexpectedExceptionNotThrown(
-            AssertionInfo const& info,
-            AssertionReaction& reaction
-    ) {
-        handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
-    }
-
-    void RunContext::handleUnexpectedInflightException(
-            AssertionInfo const& info,
-            std::string&& message,
-            AssertionReaction& reaction
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
-        data.message = CATCH_MOVE(message);
-        AssertionResult assertionResult{ info, CATCH_MOVE(data) };
-        assertionEnded( CATCH_MOVE(assertionResult) );
-        populateReaction( reaction );
-        resetAssertionInfo();
-    }
-
-    void RunContext::populateReaction( AssertionReaction& reaction ) {
-        reaction.shouldDebugBreak = m_config->shouldDebugBreak();
-        reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
-    }
-
-    void RunContext::handleIncomplete(
-            AssertionInfo const& info
-    ) {
-        using namespace std::string_literals;
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
-        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE"s;
-        AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
-        assertionEnded( CATCH_MOVE(assertionResult) );
-        resetAssertionInfo();
-    }
-    void RunContext::handleNonExpr(
-            AssertionInfo const &info,
-            ResultWas::OfType resultType,
-            AssertionReaction &reaction
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( resultType, LazyExpression( false ) );
-        AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
-
-        const auto isOk = assertionResult.isOk();
-        assertionEnded( CATCH_MOVE(assertionResult) );
-        if ( !isOk ) { populateReaction( reaction ); }
-        resetAssertionInfo();
-    }
-
-
-    IResultCapture& getResultCapture() {
-        if (auto* capture = getCurrentContext().getResultCapture())
-            return *capture;
-        else
-            CATCH_INTERNAL_ERROR("No result capture instance");
-    }
-
-    void seedRng(IConfig const& config) {
-        sharedRng().seed(config.rngSeed());
-    }
-
-    unsigned int rngSeed() {
-        return getCurrentContext().getConfig()->rngSeed();
-    }
-
-}
-
-
-
-namespace Catch {
-
-    Section::Section( SectionInfo&& info ):
-        m_info( CATCH_MOVE( info ) ),
-        m_sectionIncluded(
-            getResultCapture().sectionStarted( m_info.name, m_info.lineInfo, m_assertions ) ) {
-        // Non-"included" sections will not use the timing information
-        // anyway, so don't bother with the potential syscall.
-        if (m_sectionIncluded) {
-            m_timer.start();
-        }
-    }
-
-    Section::Section( SourceLineInfo const& _lineInfo,
-                      StringRef _name,
-                      const char* const ):
-        m_info( { "invalid", static_cast<std::size_t>( -1 ) }, std::string{} ),
-        m_sectionIncluded(
-            getResultCapture().sectionStarted( _name, _lineInfo, m_assertions ) ) {
-        // We delay initialization the SectionInfo member until we know
-        // this section needs it, so we avoid allocating std::string for name.
-        // We also delay timer start to avoid the potential syscall unless we
-        // will actually use the result.
-        if ( m_sectionIncluded ) {
-            m_info.name = static_cast<std::string>( _name );
-            m_info.lineInfo = _lineInfo;
-            m_timer.start();
-        }
-    }
-
-    Section::~Section() {
-        if( m_sectionIncluded ) {
-            SectionEndInfo endInfo{ CATCH_MOVE(m_info), m_assertions, m_timer.getElapsedSeconds() };
-            if ( uncaught_exceptions() ) {
-                getResultCapture().sectionEndedEarly( CATCH_MOVE(endInfo) );
-            } else {
-                getResultCapture().sectionEnded( CATCH_MOVE( endInfo ) );
-            }
-        }
-    }
-
-    // This indicates whether the section should be executed or not
-    Section::operator bool() const {
-        return m_sectionIncluded;
-    }
-
-
-} // end namespace Catch
-
-
-
-#include <vector>
-
-namespace Catch {
-
-    namespace {
-        static auto getSingletons() -> std::vector<ISingleton*>*& {
-            static std::vector<ISingleton*>* g_singletons = nullptr;
-            if( !g_singletons )
-                g_singletons = new std::vector<ISingleton*>();
-            return g_singletons;
-        }
-    }
-
-    ISingleton::~ISingleton() = default;
-
-    void addSingleton(ISingleton* singleton ) {
-        getSingletons()->push_back( singleton );
-    }
-    void cleanupSingletons() {
-        auto& singletons = getSingletons();
-        for( auto singleton : *singletons )
-            delete singleton;
-        delete singletons;
-        singletons = nullptr;
-    }
-
-} // namespace Catch
-
-
-
-#include <cstring>
-#include <ostream>
-
-namespace Catch {
-
-    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
-        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
-    }
-    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
-        // We can assume that the same file will usually have the same pointer.
-        // Thus, if the pointers are the same, there is no point in calling the strcmp
-        return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
-    }
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
-#ifndef __GNUG__
-        os << info.file << '(' << info.line << ')';
-#else
-        os << info.file << ':' << info.line;
-#endif
-        return os;
-    }
-
-} // end namespace Catch
-
-
-
-
-namespace Catch {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
-        CATCH_TRY {
-            m_exceptions.push_back(exception);
-        } CATCH_CATCH_ALL {
-            // If we run out of memory during start-up there's really not a lot more we can do about it
-            std::terminate();
-        }
-    }
-
-    std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
-        return m_exceptions;
-    }
-#endif
-
-} // end namespace Catch
-
-
-
-
-
-#include <iostream>
-
-namespace Catch {
-
-// If you #define this you must implement these functions
-#if !defined( CATCH_CONFIG_NOSTDOUT )
-    std::ostream& cout() { return std::cout; }
-    std::ostream& cerr() { return std::cerr; }
-    std::ostream& clog() { return std::clog; }
-#endif
-
-} // namespace Catch
-
-
-
-#include <ostream>
-#include <cstring>
-#include <cctype>
-#include <vector>
-
-namespace Catch {
-
-    bool startsWith( std::string const& s, std::string const& prefix ) {
-        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
-    }
-    bool startsWith( StringRef s, char prefix ) {
-        return !s.empty() && s[0] == prefix;
-    }
-    bool endsWith( std::string const& s, std::string const& suffix ) {
-        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
-    }
-    bool endsWith( std::string const& s, char suffix ) {
-        return !s.empty() && s[s.size()-1] == suffix;
-    }
-    bool contains( std::string const& s, std::string const& infix ) {
-        return s.find( infix ) != std::string::npos;
-    }
-    void toLowerInPlace( std::string& s ) {
-        for ( char& c : s ) {
-            c = toLower( c );
-        }
-    }
-    std::string toLower( std::string const& s ) {
-        std::string lc = s;
-        toLowerInPlace( lc );
-        return lc;
-    }
-    char toLower(char c) {
-        return static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-    }
-
-    std::string trim( std::string const& str ) {
-        static char const* whitespaceChars = "\n\r\t ";
-        std::string::size_type start = str.find_first_not_of( whitespaceChars );
-        std::string::size_type end = str.find_last_not_of( whitespaceChars );
-
-        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
-    }
-
-    StringRef trim(StringRef ref) {
-        const auto is_ws = [](char c) {
-            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
-        };
-        size_t real_begin = 0;
-        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
-        size_t real_end = ref.size();
-        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
-
-        return ref.substr(real_begin, real_end - real_begin);
-    }
-
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
-        std::size_t i = str.find( replaceThis );
-        if (i == std::string::npos) {
-            return false;
-        }
-        std::size_t copyBegin = 0;
-        std::string origStr = CATCH_MOVE(str);
-        str.clear();
-        // There is at least one replacement, so reserve with the best guess
-        // we can make without actually counting the number of occurences.
-        str.reserve(origStr.size() - replaceThis.size() + withThis.size());
-        do {
-            str.append(origStr, copyBegin, i-copyBegin );
-            str += withThis;
-            copyBegin = i + replaceThis.size();
-            if( copyBegin < origStr.size() )
-                i = origStr.find( replaceThis, copyBegin );
-            else
-                i = std::string::npos;
-        } while( i != std::string::npos );
-        if ( copyBegin < origStr.size() ) {
-            str.append(origStr, copyBegin, origStr.size() );
-        }
-        return true;
-    }
-
-    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
-        std::vector<StringRef> subStrings;
-        std::size_t start = 0;
-        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
-            if( str[pos] == delimiter ) {
-                if( pos - start > 1 )
-                    subStrings.push_back( str.substr( start, pos-start ) );
-                start = pos+1;
-            }
-        }
-        if( start < str.size() )
-            subStrings.push_back( str.substr( start, str.size()-start ) );
-        return subStrings;
-    }
-
-    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
-        os << pluraliser.m_count << ' ' << pluraliser.m_label;
-        if( pluraliser.m_count != 1 )
-            os << 's';
-        return os;
-    }
-
-}
-
-
-
-#include <algorithm>
-#include <ostream>
-#include <cstring>
-#include <cstdint>
-
-namespace Catch {
-    StringRef::StringRef( char const* rawChars ) noexcept
-    : StringRef( rawChars, std::strlen(rawChars) )
-    {}
-
-
-    bool StringRef::operator<(StringRef rhs) const noexcept {
-        if (m_size < rhs.m_size) {
-            return strncmp(m_start, rhs.m_start, m_size) <= 0;
-        }
-        return strncmp(m_start, rhs.m_start, rhs.m_size) < 0;
-    }
-
-    int StringRef::compare( StringRef rhs ) const {
-        auto cmpResult =
-            strncmp( m_start, rhs.m_start, std::min( m_size, rhs.m_size ) );
-
-        // This means that strncmp found a difference before the strings
-        // ended, and we can return it directly
-        if ( cmpResult != 0 ) {
-            return cmpResult;
-        }
-
-        // If strings are equal up to length, then their comparison results on
-        // their size
-        if ( m_size < rhs.m_size ) {
-            return -1;
-        } else if ( m_size > rhs.m_size ) {
-            return 1;
-        } else {
-            return 0;
-        }
-    }
-
-    auto operator << ( std::ostream& os, StringRef str ) -> std::ostream& {
-        return os.write(str.data(), static_cast<std::streamsize>(str.size()));
-    }
-
-    std::string operator+(StringRef lhs, StringRef rhs) {
-        std::string ret;
-        ret.reserve(lhs.size() + rhs.size());
-        ret += lhs;
-        ret += rhs;
-        return ret;
-    }
-
-    auto operator+=( std::string& lhs, StringRef rhs ) -> std::string& {
-        lhs.append(rhs.data(), rhs.size());
-        return lhs;
-    }
-
-} // namespace Catch
-
-
-
-namespace Catch {
-
-    TagAliasRegistry::~TagAliasRegistry() = default;
-
-    TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
-        auto it = m_registry.find( alias );
-        if( it != m_registry.end() )
-            return &(it->second);
-        else
-            return nullptr;
-    }
-
-    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
-        std::string expandedTestSpec = unexpandedTestSpec;
-        for( auto const& registryKvp : m_registry ) {
-            std::size_t pos = expandedTestSpec.find( registryKvp.first );
-            if( pos != std::string::npos ) {
-                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
-                                    registryKvp.second.tag +
-                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
-            }
-        }
-        return expandedTestSpec;
-    }
-
-    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
-        CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
-                      "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
-
-        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
-                      "error: tag alias, '" << alias << "' already registered.\n"
-                      << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
-                      << "\tRedefined at: " << lineInfo );
-    }
-
-    ITagAliasRegistry::~ITagAliasRegistry() = default;
-
-    ITagAliasRegistry const& ITagAliasRegistry::get() {
-        return getRegistryHub().getTagAliasRegistry();
-    }
-
-} // end namespace Catch
-
-
-
-
-namespace Catch {
-    TestCaseInfoHasher::TestCaseInfoHasher( hash_t seed ): m_seed( seed ) {}
-
-    uint32_t TestCaseInfoHasher::operator()( TestCaseInfo const& t ) const {
-        // FNV-1a hash algorithm that is designed for uniqueness:
-        const hash_t prime = 1099511628211u;
-        hash_t hash = 14695981039346656037u;
-        for ( const char c : t.name ) {
-            hash ^= c;
-            hash *= prime;
-        }
-        for ( const char c : t.className ) {
-            hash ^= c;
-            hash *= prime;
-        }
-        for ( const Tag& tag : t.tags ) {
-            for ( const char c : tag.original ) {
-                hash ^= c;
-                hash *= prime;
-            }
-        }
-        hash ^= m_seed;
-        hash *= prime;
-        const uint32_t low{ static_cast<uint32_t>( hash ) };
-        const uint32_t high{ static_cast<uint32_t>( hash >> 32 ) };
-        return low * high;
-    }
-} // namespace Catch
-
-
-
-
-#include <algorithm>
-#include <set>
-
-namespace Catch {
-
-    namespace {
-        static void enforceNoDuplicateTestCases(
-            std::vector<TestCaseHandle> const& tests ) {
-            auto testInfoCmp = []( TestCaseInfo const* lhs,
-                                   TestCaseInfo const* rhs ) {
-                return *lhs < *rhs;
-            };
-            std::set<TestCaseInfo const*, decltype( testInfoCmp )&> seenTests(
-                testInfoCmp );
-            for ( auto const& test : tests ) {
-                const auto infoPtr = &test.getTestCaseInfo();
-                const auto prev = seenTests.insert( infoPtr );
-                CATCH_ENFORCE( prev.second,
-                               "error: test case \""
-                                   << infoPtr->name << "\", with tags \""
-                                   << infoPtr->tagsAsString()
-                                   << "\" already defined.\n"
-                                   << "\tFirst seen at "
-                                   << ( *prev.first )->lineInfo << "\n"
-                                   << "\tRedefined at " << infoPtr->lineInfo );
-            }
-        }
-
-        static bool matchTest( TestCaseHandle const& testCase,
-                               TestSpec const& testSpec,
-                               IConfig const& config ) {
-            return testSpec.matches( testCase.getTestCaseInfo() ) &&
-                   isThrowSafe( testCase, config );
-        }
-
-    } // end unnamed namespace
-
-    std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases ) {
-        switch (config.runOrder()) {
-        case TestRunOrder::Declared:
-            return unsortedTestCases;
-
-        case TestRunOrder::LexicographicallySorted: {
-            std::vector<TestCaseHandle> sorted = unsortedTestCases;
-            std::sort(
-                sorted.begin(),
-                sorted.end(),
-                []( TestCaseHandle const& lhs, TestCaseHandle const& rhs ) {
-                    return lhs.getTestCaseInfo() < rhs.getTestCaseInfo();
-                }
-            );
-            return sorted;
-        }
-        case TestRunOrder::Randomized: {
-            using TestWithHash = std::pair<TestCaseInfoHasher::hash_t, TestCaseHandle>;
-
-            TestCaseInfoHasher h{ config.rngSeed() };
-            std::vector<TestWithHash> indexed_tests;
-            indexed_tests.reserve(unsortedTestCases.size());
-
-            for (auto const& handle : unsortedTestCases) {
-                indexed_tests.emplace_back(h(handle.getTestCaseInfo()), handle);
-            }
-
-            std::sort( indexed_tests.begin(),
-                       indexed_tests.end(),
-                       []( TestWithHash const& lhs, TestWithHash const& rhs ) {
-                           if ( lhs.first == rhs.first ) {
-                               return lhs.second.getTestCaseInfo() <
-                                      rhs.second.getTestCaseInfo();
-                           }
-                           return lhs.first < rhs.first;
-                       } );
-
-            std::vector<TestCaseHandle> randomized;
-            randomized.reserve(indexed_tests.size());
-
-            for (auto const& indexed : indexed_tests) {
-                randomized.push_back(indexed.second);
-            }
-
-            return randomized;
-        }
-        }
-
-        CATCH_INTERNAL_ERROR("Unknown test order value!");
-    }
-
-    bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config ) {
-        return !testCase.getTestCaseInfo().throws() || config.allowThrows();
-    }
-
-    std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
-        std::vector<TestCaseHandle> filtered;
-        filtered.reserve( testCases.size() );
-        for (auto const& testCase : testCases) {
-            if ((!testSpec.hasFilters() && !testCase.getTestCaseInfo().isHidden()) ||
-                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
-                filtered.push_back(testCase);
-            }
-        }
-        return createShard(filtered, config.shardCount(), config.shardIndex());
-    }
-    std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config ) {
-        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
-    }
-
-    TestRegistry::~TestRegistry() = default;
-
-    void TestRegistry::registerTest(Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker) {
-        m_handles.emplace_back(testInfo.get(), testInvoker.get());
-        m_viewed_test_infos.push_back(testInfo.get());
-        m_owned_test_infos.push_back(CATCH_MOVE(testInfo));
-        m_invokers.push_back(CATCH_MOVE(testInvoker));
-    }
-
-    std::vector<TestCaseInfo*> const& TestRegistry::getAllInfos() const {
-        return m_viewed_test_infos;
-    }
-
-    std::vector<TestCaseHandle> const& TestRegistry::getAllTests() const {
-        return m_handles;
-    }
-    std::vector<TestCaseHandle> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
-        if( m_sortedFunctions.empty() )
-            enforceNoDuplicateTestCases( m_handles );
-
-        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
-            m_sortedFunctions = sortTests( config, m_handles );
-            m_currentSortOrder = config.runOrder();
-        }
-        return m_sortedFunctions;
-    }
-
-} // end namespace Catch
-
-
-
-
-#include <algorithm>
-#include <cassert>
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
-namespace Catch {
-namespace TestCaseTracking {
-
-    NameAndLocation::NameAndLocation( std::string&& _name, SourceLineInfo const& _location )
-    :   name( CATCH_MOVE(_name) ),
-        location( _location )
-    {}
-
-
-    ITracker::~ITracker() = default;
-
-    void ITracker::markAsNeedingAnotherRun() {
-        m_runState = NeedsAnotherRun;
-    }
-
-    void ITracker::addChild( ITrackerPtr&& child ) {
-        m_children.push_back( CATCH_MOVE(child) );
-    }
-
-    ITracker* ITracker::findChild( NameAndLocationRef const& nameAndLocation ) {
-        auto it = std::find_if(
-            m_children.begin(),
-            m_children.end(),
-            [&nameAndLocation]( ITrackerPtr const& tracker ) {
-                auto const& tnameAndLoc = tracker->nameAndLocation();
-                if ( tnameAndLoc.location.line !=
-                     nameAndLocation.location.line ) {
-                    return false;
-                }
-                return tnameAndLoc == nameAndLocation;
-            } );
-        return ( it != m_children.end() ) ? it->get() : nullptr;
-    }
-
-    bool ITracker::isSectionTracker() const { return false; }
-    bool ITracker::isGeneratorTracker() const { return false; }
-
-    bool ITracker::isOpen() const {
-        return m_runState != NotStarted && !isComplete();
-    }
-
-    bool ITracker::hasStarted() const { return m_runState != NotStarted; }
-
-    void ITracker::openChild() {
-        if (m_runState != ExecutingChildren) {
-            m_runState = ExecutingChildren;
-            if (m_parent) {
-                m_parent->openChild();
-            }
-        }
-    }
-
-    ITracker& TrackerContext::startRun() {
-        using namespace std::string_literals;
-        m_rootTracker = Catch::Detail::make_unique<SectionTracker>(
-            NameAndLocation( "{root}"s, CATCH_INTERNAL_LINEINFO ),
-            *this,
-            nullptr );
-        m_currentTracker = nullptr;
-        m_runState = Executing;
-        return *m_rootTracker;
-    }
-
-    void TrackerContext::completeCycle() {
-        m_runState = CompletedCycle;
-    }
-
-    bool TrackerContext::completedCycle() const {
-        return m_runState == CompletedCycle;
-    }
-    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
-        m_currentTracker = tracker;
-    }
-
-
-    TrackerBase::TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent ):
-        ITracker(CATCH_MOVE(nameAndLocation), parent),
-        m_ctx( ctx )
-    {}
-
-    bool TrackerBase::isComplete() const {
-        return m_runState == CompletedSuccessfully || m_runState == Failed;
-    }
-
-    void TrackerBase::open() {
-        m_runState = Executing;
-        moveToThis();
-        if( m_parent )
-            m_parent->openChild();
-    }
-
-    void TrackerBase::close() {
-
-        // Close any still open children (e.g. generators)
-        while( &m_ctx.currentTracker() != this )
-            m_ctx.currentTracker().close();
-
-        switch( m_runState ) {
-            case NeedsAnotherRun:
-                break;
-
-            case Executing:
-                m_runState = CompletedSuccessfully;
-                break;
-            case ExecutingChildren:
-                if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
-                    m_runState = CompletedSuccessfully;
-                break;
-
-            case NotStarted:
-            case CompletedSuccessfully:
-            case Failed:
-                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
-
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
-        }
-        moveToParent();
-        m_ctx.completeCycle();
-    }
-    void TrackerBase::fail() {
-        m_runState = Failed;
-        if( m_parent )
-            m_parent->markAsNeedingAnotherRun();
-        moveToParent();
-        m_ctx.completeCycle();
-    }
-
-    void TrackerBase::moveToParent() {
-        assert( m_parent );
-        m_ctx.setCurrentTracker( m_parent );
-    }
-    void TrackerBase::moveToThis() {
-        m_ctx.setCurrentTracker( this );
-    }
-
-    SectionTracker::SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   TrackerBase( CATCH_MOVE(nameAndLocation), ctx, parent ),
-        m_trimmed_name(trim(StringRef(ITracker::nameAndLocation().name)))
-    {
-        if( parent ) {
-            while ( !parent->isSectionTracker() ) {
-                parent = parent->parent();
-            }
-
-            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
-            addNextFilters( parentSection.m_filters );
-        }
-    }
-
-    bool SectionTracker::isComplete() const {
-        bool complete = true;
-
-        if (m_filters.empty()
-            || m_filters[0].empty()
-            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
-            complete = TrackerBase::isComplete();
-        }
-        return complete;
-    }
-
-    bool SectionTracker::isSectionTracker() const { return true; }
-
-    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation ) {
-        SectionTracker* tracker;
-
-        ITracker& currentTracker = ctx.currentTracker();
-        if ( ITracker* childTracker =
-                 currentTracker.findChild( nameAndLocation ) ) {
-            assert( childTracker );
-            assert( childTracker->isSectionTracker() );
-            tracker = static_cast<SectionTracker*>( childTracker );
-        } else {
-            auto newTracker = Catch::Detail::make_unique<SectionTracker>(
-                NameAndLocation{ static_cast<std::string>(nameAndLocation.name),
-                                 nameAndLocation.location },
-                ctx,
-                &currentTracker );
-            tracker = newTracker.get();
-            currentTracker.addChild( CATCH_MOVE( newTracker ) );
-        }
-
-        if ( !ctx.completedCycle() ) {
-            tracker->tryOpen();
-        }
-
-        return *tracker;
-    }
-
-    void SectionTracker::tryOpen() {
-        if( !isComplete() )
-            open();
-    }
-
-    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
-        if( !filters.empty() ) {
-            m_filters.reserve( m_filters.size() + filters.size() + 2 );
-            m_filters.emplace_back(StringRef{}); // Root - should never be consulted
-            m_filters.emplace_back(StringRef{}); // Test Case - not a section filter
-            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
-        }
-    }
-    void SectionTracker::addNextFilters( std::vector<StringRef> const& filters ) {
-        if( filters.size() > 1 )
-            m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
-    }
-
-    StringRef SectionTracker::trimmedName() const {
-        return m_trimmed_name;
-    }
-
-} // namespace TestCaseTracking
-
-} // namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-
-
-
-
-namespace Catch {
-
-    void throw_test_failure_exception() {
-#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
-        throw TestFailureException{};
-#else
-        CATCH_ERROR( "Test failure requires aborting test!" );
-#endif
-    }
-
-    void throw_test_skip_exception() {
-#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
-        throw Catch::TestSkipException();
-#else
-        CATCH_ERROR( "Explicitly skipping tests during runtime requires exceptions" );
-#endif
-    }
-
-} // namespace Catch
-
-
-
-#include <algorithm>
-#include <iterator>
-
-namespace Catch {
-    void ITestInvoker::prepareTestCase() {}
-    void ITestInvoker::tearDownTestCase() {}
-    ITestInvoker::~ITestInvoker() = default;
-
-    namespace {
-        static StringRef extractClassName( StringRef classOrMethodName ) {
-            if ( !startsWith( classOrMethodName, '&' ) ) {
-                return classOrMethodName;
-            }
-
-            // Remove the leading '&' to avoid having to special case it later
-            const auto methodName =
-                classOrMethodName.substr( 1, classOrMethodName.size() );
-
-            auto reverseStart = std::make_reverse_iterator( methodName.end() );
-            auto reverseEnd = std::make_reverse_iterator( methodName.begin() );
-
-            // We make a simplifying assumption that ":" is only present
-            // in the input as part of "::" from C++ typenames (this is
-            // relatively safe assumption because the input is generated
-            // as stringification of type through preprocessor).
-            auto lastColons = std::find( reverseStart, reverseEnd, ':' ) + 1;
-            auto secondLastColons =
-                std::find( lastColons + 1, reverseEnd, ':' );
-
-            auto const startIdx = reverseEnd - secondLastColons;
-            auto const classNameSize = secondLastColons - lastColons - 1;
-
-            return methodName.substr(
-                static_cast<std::size_t>( startIdx ),
-                static_cast<std::size_t>( classNameSize ) );
-        }
-
-        class TestInvokerAsFunction final : public ITestInvoker {
-            using TestType = void ( * )();
-            TestType m_testAsFunction;
-
-        public:
-            constexpr TestInvokerAsFunction( TestType testAsFunction ) noexcept:
-                m_testAsFunction( testAsFunction ) {}
-
-            void invoke() const override { m_testAsFunction(); }
-        };
-
-    } // namespace
-
-    Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() ) {
-        return Detail::make_unique<TestInvokerAsFunction>( testAsFunction );
-    }
-
-    AutoReg::AutoReg( Detail::unique_ptr<ITestInvoker> invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept {
-        CATCH_TRY {
-            getMutableRegistryHub()
-                    .registerTest(
-                        makeTestCaseInfo(
-                            extractClassName( classOrMethod ),
-                            nameAndTags,
-                            lineInfo),
-                        CATCH_MOVE(invoker)
-                    );
-        } CATCH_CATCH_ALL {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
-    }
-}
-
-
-
-
-
-namespace Catch {
-
-    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
-
-    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
-        m_mode = None;
-        m_exclusion = false;
-        m_arg = m_tagAliases->expandAliases( arg );
-        m_escapeChars.clear();
-        m_substring.reserve(m_arg.size());
-        m_patternName.reserve(m_arg.size());
-        m_realPatternPos = 0;
-
-        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
-          //if visitChar fails
-           if( !visitChar( m_arg[m_pos] ) ){
-               m_testSpec.m_invalidSpecs.push_back(arg);
-               break;
-           }
-        endMode();
-        return *this;
-    }
-    TestSpec TestSpecParser::testSpec() {
-        addFilter();
-        return CATCH_MOVE(m_testSpec);
-    }
-    bool TestSpecParser::visitChar( char c ) {
-        if( (m_mode != EscapedName) && (c == '\\') ) {
-            escape();
-            addCharToPattern(c);
-            return true;
-        }else if((m_mode != EscapedName) && (c == ',') )  {
-            return separate();
-        }
-
-        switch( m_mode ) {
-        case None:
-            if( processNoneChar( c ) )
-                return true;
-            break;
-        case Name:
-            processNameChar( c );
-            break;
-        case EscapedName:
-            endMode();
-            addCharToPattern(c);
-            return true;
-        default:
-        case Tag:
-        case QuotedName:
-            if( processOtherChar( c ) )
-                return true;
-            break;
-        }
-
-        m_substring += c;
-        if( !isControlChar( c ) ) {
-            m_patternName += c;
-            m_realPatternPos++;
-        }
-        return true;
-    }
-    // Two of the processing methods return true to signal the caller to return
-    // without adding the given character to the current pattern strings
-    bool TestSpecParser::processNoneChar( char c ) {
-        switch( c ) {
-        case ' ':
-            return true;
-        case '~':
-            m_exclusion = true;
-            return false;
-        case '[':
-            startNewMode( Tag );
-            return false;
-        case '"':
-            startNewMode( QuotedName );
-            return false;
-        default:
-            startNewMode( Name );
-            return false;
-        }
-    }
-    void TestSpecParser::processNameChar( char c ) {
-        if( c == '[' ) {
-            if( m_substring == "exclude:" )
-                m_exclusion = true;
-            else
-                endMode();
-            startNewMode( Tag );
-        }
-    }
-    bool TestSpecParser::processOtherChar( char c ) {
-        if( !isControlChar( c ) )
-            return false;
-        m_substring += c;
-        endMode();
-        return true;
-    }
-    void TestSpecParser::startNewMode( Mode mode ) {
-        m_mode = mode;
-    }
-    void TestSpecParser::endMode() {
-        switch( m_mode ) {
-        case Name:
-        case QuotedName:
-            return addNamePattern();
-        case Tag:
-            return addTagPattern();
-        case EscapedName:
-            revertBackToLastMode();
-            return;
-        case None:
-        default:
-            return startNewMode( None );
-        }
-    }
-    void TestSpecParser::escape() {
-        saveLastMode();
-        m_mode = EscapedName;
-        m_escapeChars.push_back(m_realPatternPos);
-    }
-    bool TestSpecParser::isControlChar( char c ) const {
-        switch( m_mode ) {
-            default:
-                return false;
-            case None:
-                return c == '~';
-            case Name:
-                return c == '[';
-            case EscapedName:
-                return true;
-            case QuotedName:
-                return c == '"';
-            case Tag:
-                return c == '[' || c == ']';
-        }
-    }
-
-    void TestSpecParser::addFilter() {
-        if( !m_currentFilter.m_required.empty() || !m_currentFilter.m_forbidden.empty() ) {
-            m_testSpec.m_filters.push_back( CATCH_MOVE(m_currentFilter) );
-            m_currentFilter = TestSpec::Filter();
-        }
-    }
-
-    void TestSpecParser::saveLastMode() {
-      lastMode = m_mode;
-    }
-
-    void TestSpecParser::revertBackToLastMode() {
-      m_mode = lastMode;
-    }
-
-    bool TestSpecParser::separate() {
-      if( (m_mode==QuotedName) || (m_mode==Tag) ){
-         //invalid argument, signal failure to previous scope.
-         m_mode = None;
-         m_pos = m_arg.size();
-         m_substring.clear();
-         m_patternName.clear();
-         m_realPatternPos = 0;
-         return false;
-      }
-      endMode();
-      addFilter();
-      return true; //success
-    }
-
-    std::string TestSpecParser::preprocessPattern() {
-        std::string token = m_patternName;
-        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
-            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
-        m_escapeChars.clear();
-        if (startsWith(token, "exclude:")) {
-            m_exclusion = true;
-            token = token.substr(8);
-        }
-
-        m_patternName.clear();
-        m_realPatternPos = 0;
-
-        return token;
-    }
-
-    void TestSpecParser::addNamePattern() {
-        auto token = preprocessPattern();
-
-        if (!token.empty()) {
-            if (m_exclusion) {
-                m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring));
-            } else {
-                m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring));
-            }
-        }
-        m_substring.clear();
-        m_exclusion = false;
-        m_mode = None;
-    }
-
-    void TestSpecParser::addTagPattern() {
-        auto token = preprocessPattern();
-
-        if (!token.empty()) {
-            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
-            // we have to create a separate hide tag and shorten the real one
-            if (token.size() > 1 && token[0] == '.') {
-                token.erase(token.begin());
-                if (m_exclusion) {
-                    m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
-                } else {
-                    m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
-                }
-            }
-            if (m_exclusion) {
-                m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
-            } else {
-                m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
-            }
-        }
-        m_substring.clear();
-        m_exclusion = false;
-        m_mode = None;
-    }
-
-} // namespace Catch
-
-
-
-#include <algorithm>
-#include <cstring>
-#include <ostream>
-
-namespace {
-    bool isWhitespace( char c ) {
-        return c == ' ' || c == '\t' || c == '\n' || c == '\r';
-    }
-
-    bool isBreakableBefore( char c ) {
-        static const char chars[] = "[({<|";
-        return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
-    }
-
-    bool isBreakableAfter( char c ) {
-        static const char chars[] = "])}>.,:;*+-=&/\\";
-        return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
-    }
-
-} // namespace
-
-namespace Catch {
-    namespace TextFlow {
-        void AnsiSkippingString::preprocessString() {
-            for ( auto it = m_string.begin(); it != m_string.end(); ) {
-                // try to read through an ansi sequence
-                while ( it != m_string.end() && *it == '\033' &&
-                        it + 1 != m_string.end() && *( it + 1 ) == '[' ) {
-                    auto cursor = it + 2;
-                    while ( cursor != m_string.end() &&
-                            ( isdigit( *cursor ) || *cursor == ';' ) ) {
-                        ++cursor;
-                    }
-                    if ( cursor == m_string.end() || *cursor != 'm' ) {
-                        break;
-                    }
-                    // 'm' -> 0xff
-                    *cursor = AnsiSkippingString::sentinel;
-                    // if we've read an ansi sequence, set the iterator and
-                    // return to the top of the loop
-                    it = cursor + 1;
-                }
-                if ( it != m_string.end() ) {
-                    ++m_size;
-                    ++it;
-                }
-            }
-        }
-
-        AnsiSkippingString::AnsiSkippingString( std::string const& text ):
-            m_string( text ) {
-            preprocessString();
-        }
-
-        AnsiSkippingString::AnsiSkippingString( std::string&& text ):
-            m_string( CATCH_MOVE( text ) ) {
-            preprocessString();
-        }
-
-        AnsiSkippingString::const_iterator AnsiSkippingString::begin() const {
-            return const_iterator( m_string );
-        }
-
-        AnsiSkippingString::const_iterator AnsiSkippingString::end() const {
-            return const_iterator( m_string, const_iterator::EndTag{} );
-        }
-
-        std::string AnsiSkippingString::substring( const_iterator begin,
-                                                   const_iterator end ) const {
-            // There's one caveat here to an otherwise simple substring: when
-            // making a begin iterator we might have skipped ansi sequences at
-            // the start. If `begin` here is a begin iterator, skipped over
-            // initial ansi sequences, we'll use the true beginning of the
-            // string. Lastly: We need to transform any chars we replaced with
-            // 0xff back to 'm'
-            auto str = std::string( begin == this->begin() ? m_string.begin()
-                                                           : begin.m_it,
-                                    end.m_it );
-            std::transform( str.begin(), str.end(), str.begin(), []( char c ) {
-                return c == AnsiSkippingString::sentinel ? 'm' : c;
-            } );
-            return str;
-        }
-
-        void AnsiSkippingString::const_iterator::tryParseAnsiEscapes() {
-            // check if we've landed on an ansi sequence, and if so read through
-            // it
-            while ( m_it != m_string->end() && *m_it == '\033' &&
-                    m_it + 1 != m_string->end() &&  *( m_it + 1 ) == '[' ) {
-                auto cursor = m_it + 2;
-                while ( cursor != m_string->end() &&
-                        ( isdigit( *cursor ) || *cursor == ';' ) ) {
-                    ++cursor;
-                }
-                if ( cursor == m_string->end() ||
-                     *cursor != AnsiSkippingString::sentinel ) {
-                    break;
-                }
-                // if we've read an ansi sequence, set the iterator and
-                // return to the top of the loop
-                m_it = cursor + 1;
-            }
-        }
-
-        void AnsiSkippingString::const_iterator::advance() {
-            assert( m_it != m_string->end() );
-            m_it++;
-            tryParseAnsiEscapes();
-        }
-
-        void AnsiSkippingString::const_iterator::unadvance() {
-            assert( m_it != m_string->begin() );
-            m_it--;
-            // if *m_it is 0xff, scan back to the \033 and then m_it-- once more
-            // (and repeat check)
-            while ( *m_it == AnsiSkippingString::sentinel ) {
-                while ( *m_it != '\033' ) {
-                    assert( m_it != m_string->begin() );
-                    m_it--;
-                }
-                // if this happens, we must have been a begin iterator that had
-                // skipped over ansi sequences at the start of a string
-                assert( m_it != m_string->begin() );
-                assert( *m_it == '\033' );
-                m_it--;
-            }
-        }
-
-        static bool isBoundary( AnsiSkippingString const& line,
-                                AnsiSkippingString::const_iterator it ) {
-            return it == line.end() ||
-                   ( isWhitespace( *it ) &&
-                     !isWhitespace( *it.oneBefore() ) ) ||
-                   isBreakableBefore( *it ) ||
-                   isBreakableAfter( *it.oneBefore() );
-        }
-
-        void Column::const_iterator::calcLength() {
-            m_addHyphen = false;
-            m_parsedTo = m_lineStart;
-            AnsiSkippingString const& current_line = m_column.m_string;
-
-            if ( m_parsedTo == current_line.end() ) {
-                m_lineEnd = m_parsedTo;
-                return;
-            }
-
-            assert( m_lineStart != current_line.end() );
-            if ( *m_lineStart == '\n' ) { ++m_parsedTo; }
-
-            const auto maxLineLength = m_column.m_width - indentSize();
-            std::size_t lineLength = 0;
-            while ( m_parsedTo != current_line.end() &&
-                    lineLength < maxLineLength && *m_parsedTo != '\n' ) {
-                ++m_parsedTo;
-                ++lineLength;
-            }
-
-            // If we encountered a newline before the column is filled,
-            // then we linebreak at the newline and consider this line
-            // finished.
-            if ( lineLength < maxLineLength ) {
-                m_lineEnd = m_parsedTo;
-            } else {
-                // Look for a natural linebreak boundary in the column
-                // (We look from the end, so that the first found boundary is
-                // the right one)
-                m_lineEnd = m_parsedTo;
-                while ( lineLength > 0 &&
-                        !isBoundary( current_line, m_lineEnd ) ) {
-                    --lineLength;
-                    --m_lineEnd;
-                }
-                while ( lineLength > 0 &&
-                        isWhitespace( *m_lineEnd.oneBefore() ) ) {
-                    --lineLength;
-                    --m_lineEnd;
-                }
-
-                // If we found one, then that is where we linebreak, otherwise
-                // we have to split text with a hyphen
-                if ( lineLength == 0 ) {
-                    m_addHyphen = true;
-                    m_lineEnd = m_parsedTo.oneBefore();
-                }
-            }
-        }
-
-        size_t Column::const_iterator::indentSize() const {
-            auto initial = m_lineStart == m_column.m_string.begin()
-                               ? m_column.m_initialIndent
-                               : std::string::npos;
-            return initial == std::string::npos ? m_column.m_indent : initial;
-        }
-
-        std::string Column::const_iterator::addIndentAndSuffix(
-            AnsiSkippingString::const_iterator start,
-            AnsiSkippingString::const_iterator end ) const {
-            std::string ret;
-            const auto desired_indent = indentSize();
-            // ret.reserve( desired_indent + (end - start) + m_addHyphen );
-            ret.append( desired_indent, ' ' );
-            // ret.append( start, end );
-            ret += m_column.m_string.substring( start, end );
-            if ( m_addHyphen ) { ret.push_back( '-' ); }
-
-            return ret;
-        }
-
-        Column::const_iterator::const_iterator( Column const& column ):
-            m_column( column ),
-            m_lineStart( column.m_string.begin() ),
-            m_lineEnd( column.m_string.begin() ),
-            m_parsedTo( column.m_string.begin() ) {
-            assert( m_column.m_width > m_column.m_indent );
-            assert( m_column.m_initialIndent == std::string::npos ||
-                    m_column.m_width > m_column.m_initialIndent );
-            calcLength();
-            if ( m_lineStart == m_lineEnd ) {
-                m_lineStart = m_column.m_string.end();
-            }
-        }
-
-        std::string Column::const_iterator::operator*() const {
-            assert( m_lineStart <= m_parsedTo );
-            return addIndentAndSuffix( m_lineStart, m_lineEnd );
-        }
-
-        Column::const_iterator& Column::const_iterator::operator++() {
-            m_lineStart = m_lineEnd;
-            AnsiSkippingString const& current_line = m_column.m_string;
-            if ( m_lineStart != current_line.end() && *m_lineStart == '\n' ) {
-                m_lineStart++;
-            } else {
-                while ( m_lineStart != current_line.end() &&
-                        isWhitespace( *m_lineStart ) ) {
-                    ++m_lineStart;
-                }
-            }
-
-            if ( m_lineStart != current_line.end() ) { calcLength(); }
-            return *this;
-        }
-
-        Column::const_iterator Column::const_iterator::operator++( int ) {
-            const_iterator prev( *this );
-            operator++();
-            return prev;
-        }
-
-        std::ostream& operator<<( std::ostream& os, Column const& col ) {
-            bool first = true;
-            for ( auto line : col ) {
-                if ( first ) {
-                    first = false;
-                } else {
-                    os << '\n';
-                }
-                os << line;
-            }
-            return os;
-        }
-
-        Column Spacer( size_t spaceWidth ) {
-            Column ret{ "" };
-            ret.width( spaceWidth );
-            return ret;
-        }
-
-        Columns::iterator::iterator( Columns const& columns, EndTag ):
-            m_columns( columns.m_columns ), m_activeIterators( 0 ) {
-
-            m_iterators.reserve( m_columns.size() );
-            for ( auto const& col : m_columns ) {
-                m_iterators.push_back( col.end() );
-            }
-        }
-
-        Columns::iterator::iterator( Columns const& columns ):
-            m_columns( columns.m_columns ),
-            m_activeIterators( m_columns.size() ) {
-
-            m_iterators.reserve( m_columns.size() );
-            for ( auto const& col : m_columns ) {
-                m_iterators.push_back( col.begin() );
-            }
-        }
-
-        std::string Columns::iterator::operator*() const {
-            std::string row, padding;
-
-            for ( size_t i = 0; i < m_columns.size(); ++i ) {
-                const auto width = m_columns[i].width();
-                if ( m_iterators[i] != m_columns[i].end() ) {
-                    std::string col = *m_iterators[i];
-                    row += padding;
-                    row += col;
-
-                    padding.clear();
-                    if ( col.size() < width ) {
-                        padding.append( width - col.size(), ' ' );
-                    }
-                } else {
-                    padding.append( width, ' ' );
-                }
-            }
-            return row;
-        }
-
-        Columns::iterator& Columns::iterator::operator++() {
-            for ( size_t i = 0; i < m_columns.size(); ++i ) {
-                if ( m_iterators[i] != m_columns[i].end() ) {
-                    ++m_iterators[i];
-                }
-            }
-            return *this;
-        }
-
-        Columns::iterator Columns::iterator::operator++( int ) {
-            iterator prev( *this );
-            operator++();
-            return prev;
-        }
-
-        std::ostream& operator<<( std::ostream& os, Columns const& cols ) {
-            bool first = true;
-            for ( auto line : cols ) {
-                if ( first ) {
-                    first = false;
-                } else {
-                    os << '\n';
-                }
-                os << line;
-            }
-            return os;
-        }
-
-        Columns operator+( Column const& lhs, Column const& rhs ) {
-            Columns cols;
-            cols += lhs;
-            cols += rhs;
-            return cols;
-        }
-        Columns operator+( Column&& lhs, Column&& rhs ) {
-            Columns cols;
-            cols += CATCH_MOVE( lhs );
-            cols += CATCH_MOVE( rhs );
-            return cols;
-        }
-
-        Columns& operator+=( Columns& lhs, Column const& rhs ) {
-            lhs.m_columns.push_back( rhs );
-            return lhs;
-        }
-        Columns& operator+=( Columns& lhs, Column&& rhs ) {
-            lhs.m_columns.push_back( CATCH_MOVE( rhs ) );
-            return lhs;
-        }
-        Columns operator+( Columns const& lhs, Column const& rhs ) {
-            auto combined( lhs );
-            combined += rhs;
-            return combined;
-        }
-        Columns operator+( Columns&& lhs, Column&& rhs ) {
-            lhs += CATCH_MOVE( rhs );
-            return CATCH_MOVE( lhs );
-        }
-
-    } // namespace TextFlow
-} // namespace Catch
-
-
-
-
-#include <exception>
-
-namespace Catch {
-    bool uncaught_exceptions() {
-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-        return false;
-#elif defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-        return std::uncaught_exceptions() > 0;
-#else
-        return std::uncaught_exception();
-#endif
-  }
-} // end namespace Catch
-
-
-
-namespace Catch {
-
-    WildcardPattern::WildcardPattern( std::string const& pattern,
-                                      CaseSensitive caseSensitivity )
-    :   m_caseSensitivity( caseSensitivity ),
-        m_pattern( normaliseString( pattern ) )
-    {
-        if( startsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 1 );
-            m_wildcard = WildcardAtStart;
-        }
-        if( endsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
-            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
-        }
-    }
-
-    bool WildcardPattern::matches( std::string const& str ) const {
-        switch( m_wildcard ) {
-            case NoWildcard:
-                return m_pattern == normaliseString( str );
-            case WildcardAtStart:
-                return endsWith( normaliseString( str ), m_pattern );
-            case WildcardAtEnd:
-                return startsWith( normaliseString( str ), m_pattern );
-            case WildcardAtBothEnds:
-                return contains( normaliseString( str ), m_pattern );
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown enum" );
-        }
-    }
-
-    std::string WildcardPattern::normaliseString( std::string const& str ) const {
-        return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
-    }
-}
-
-
-// Note: swapping these two includes around causes MSVC to error out
-//       while in /permissive- mode. No, I don't know why.
-//       Tested on VS 2019, 18.{3, 4}.x
-
-#include <cstdint>
-#include <iomanip>
-#include <type_traits>
-
-namespace Catch {
-
-namespace {
-
-    size_t trailingBytes(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return 2;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return 3;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return 4;
-        }
-        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
-
-    uint32_t headerValue(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return c & 0x1F;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return c & 0x0F;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return c & 0x07;
-        }
-        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
-
-    void hexEscapeChar(std::ostream& os, unsigned char c) {
-        std::ios_base::fmtflags f(os.flags());
-        os << "\\x"
-            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
-            << static_cast<int>(c);
-        os.flags(f);
-    }
-
-    constexpr bool shouldNewline(XmlFormatting fmt) {
-        return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Newline));
-    }
-
-    constexpr bool shouldIndent(XmlFormatting fmt) {
-        return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Indent));
-    }
-
-} // anonymous namespace
-
-    void XmlEncode::encodeTo( std::ostream& os ) const {
-        // Apostrophe escaping not necessary if we always use " to write attributes
-        // (see: http://www.w3.org/TR/xml/#syntax)
-
-        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
-            unsigned char c = static_cast<unsigned char>(m_str[idx]);
-            switch (c) {
-            case '<':   os << "&lt;"; break;
-            case '&':   os << "&amp;"; break;
-
-            case '>':
-                // See: http://www.w3.org/TR/xml/#syntax
-                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
-                    os << "&gt;";
-                else
-                    os << c;
-                break;
-
-            case '\"':
-                if (m_forWhat == ForAttributes)
-                    os << "&quot;";
-                else
-                    os << c;
-                break;
-
-            default:
-                // Check for control characters and invalid utf-8
-
-                // Escape control characters in standard ascii
-                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
-                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                // Plain ASCII: Write it to stream
-                if (c < 0x7F) {
-                    os << c;
-                    break;
-                }
-
-                // UTF-8 territory
-                // Check if the encoding is valid and if it is not, hex escape bytes.
-                // Important: We do not check the exact decoded values for validity, only the encoding format
-                // First check that this bytes is a valid lead byte:
-                // This means that it is not encoded as 1111 1XXX
-                // Or as 10XX XXXX
-                if (c <  0xC0 ||
-                    c >= 0xF8) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                auto encBytes = trailingBytes(c);
-                // Are there enough bytes left to avoid accessing out-of-bounds memory?
-                if (idx + encBytes - 1 >= m_str.size()) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-                // The header is valid, check data
-                // The next encBytes bytes must together be a valid utf-8
-                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
-                bool valid = true;
-                uint32_t value = headerValue(c);
-                for (std::size_t n = 1; n < encBytes; ++n) {
-                    unsigned char nc = static_cast<unsigned char>(m_str[idx + n]);
-                    valid &= ((nc & 0xC0) == 0x80);
-                    value = (value << 6) | (nc & 0x3F);
-                }
-
-                if (
-                    // Wrong bit pattern of following bytes
-                    (!valid) ||
-                    // Overlong encodings
-                    (value < 0x80) ||
-                    (0x80 <= value && value < 0x800   && encBytes > 2) ||
-                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
-                    // Encoded value out of range
-                    (value >= 0x110000)
-                    ) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                // If we got here, this is in fact a valid(ish) utf-8 sequence
-                for (std::size_t n = 0; n < encBytes; ++n) {
-                    os << m_str[idx + n];
-                }
-                idx += encBytes - 1;
-                break;
-            }
-        }
-    }
-
-    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
-        xmlEncode.encodeTo( os );
-        return os;
-    }
-
-    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
-    :   m_writer( writer ),
-        m_fmt(fmt)
-    {}
-
-    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
-    :   m_writer( other.m_writer ),
-        m_fmt(other.m_fmt)
-    {
-        other.m_writer = nullptr;
-        other.m_fmt = XmlFormatting::None;
-    }
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
-        if ( m_writer ) {
-            m_writer->endElement();
-        }
-        m_writer = other.m_writer;
-        other.m_writer = nullptr;
-        m_fmt = other.m_fmt;
-        other.m_fmt = XmlFormatting::None;
-        return *this;
-    }
-
-
-    XmlWriter::ScopedElement::~ScopedElement() {
-        if (m_writer) {
-            m_writer->endElement(m_fmt);
-        }
-    }
-
-    XmlWriter::ScopedElement&
-    XmlWriter::ScopedElement::writeText( StringRef text, XmlFormatting fmt ) {
-        m_writer->writeText( text, fmt );
-        return *this;
-    }
-
-    XmlWriter::ScopedElement&
-    XmlWriter::ScopedElement::writeAttribute( StringRef name,
-                                              StringRef attribute ) {
-        m_writer->writeAttribute( name, attribute );
-        return *this;
-    }
-
-
-    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
-    {
-        writeDeclaration();
-    }
-
-    XmlWriter::~XmlWriter() {
-        while (!m_tags.empty()) {
-            endElement();
-        }
-        newlineIfNecessary();
-    }
-
-    XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
-        ensureTagClosed();
-        newlineIfNecessary();
-        if (shouldIndent(fmt)) {
-            m_os << m_indent;
-            m_indent += "  ";
-        }
-        m_os << '<' << name;
-        m_tags.push_back( name );
-        m_tagIsOpen = true;
-        applyFormatting(fmt);
-        return *this;
-    }
-
-    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
-        ScopedElement scoped( this, fmt );
-        startElement( name, fmt );
-        return scoped;
-    }
-
-    XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
-        m_indent = m_indent.substr(0, m_indent.size() - 2);
-
-        if( m_tagIsOpen ) {
-            m_os << "/>";
-            m_tagIsOpen = false;
-        } else {
-            newlineIfNecessary();
-            if (shouldIndent(fmt)) {
-                m_os << m_indent;
-            }
-            m_os << "</" << m_tags.back() << '>';
-        }
-        m_os << std::flush;
-        applyFormatting(fmt);
-        m_tags.pop_back();
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( StringRef name,
-                                          StringRef attribute ) {
-        if( !name.empty() && !attribute.empty() )
-            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( StringRef name, bool attribute ) {
-        writeAttribute(name, (attribute ? "true"_sr : "false"_sr));
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( StringRef name,
-                                          char const* attribute ) {
-        writeAttribute( name, StringRef( attribute ) );
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeText( StringRef text, XmlFormatting fmt ) {
-        CATCH_ENFORCE(!m_tags.empty(), "Cannot write text as top level element");
-        if( !text.empty() ){
-            bool tagWasOpen = m_tagIsOpen;
-            ensureTagClosed();
-            if (tagWasOpen && shouldIndent(fmt)) {
-                m_os << m_indent;
-            }
-            m_os << XmlEncode( text, XmlEncode::ForTextNodes );
-            applyFormatting(fmt);
-        }
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeComment( StringRef text, XmlFormatting fmt ) {
-        ensureTagClosed();
-        if (shouldIndent(fmt)) {
-            m_os << m_indent;
-        }
-        m_os << "<!-- " << text << " -->";
-        applyFormatting(fmt);
-        return *this;
-    }
-
-    void XmlWriter::writeStylesheetRef( StringRef url ) {
-        m_os << R"(<?xml-stylesheet type="text/xsl" href=")" << url << R"("?>)" << '\n';
-    }
-
-    void XmlWriter::ensureTagClosed() {
-        if( m_tagIsOpen ) {
-            m_os << '>' << std::flush;
-            newlineIfNecessary();
-            m_tagIsOpen = false;
-        }
-    }
-
-    void XmlWriter::applyFormatting(XmlFormatting fmt) {
-        m_needsNewline = shouldNewline(fmt);
-    }
-
-    void XmlWriter::writeDeclaration() {
-        m_os << R"(<?xml version="1.0" encoding="UTF-8"?>)" << '\n';
-    }
-
-    void XmlWriter::newlineIfNecessary() {
-        if( m_needsNewline ) {
-            m_os << '\n' << std::flush;
-            m_needsNewline = false;
-        }
-    }
-}
-
-
-
-
-
-namespace Catch {
-namespace Matchers {
-
-    std::string MatcherUntypedBase::toString() const {
-        if (m_cachedToString.empty()) {
-            m_cachedToString = describe();
-        }
-        return m_cachedToString;
-    }
-
-    MatcherUntypedBase::~MatcherUntypedBase() = default;
-
-} // namespace Matchers
-} // namespace Catch
-
-
-
-
-namespace Catch {
-namespace Matchers {
-
-    std::string IsEmptyMatcher::describe() const {
-        return "is empty";
-    }
-
-    std::string HasSizeMatcher::describe() const {
-        ReusableStringStream sstr;
-        sstr << "has size == " << m_target_size;
-        return sstr.str();
-    }
-
-    IsEmptyMatcher IsEmpty() {
-        return {};
-    }
-
-    HasSizeMatcher SizeIs(std::size_t sz) {
-        return HasSizeMatcher{ sz };
-    }
-
-} // end namespace Matchers
-} // end namespace Catch
-
-
-
-namespace Catch {
-namespace Matchers {
-
-bool ExceptionMessageMatcher::match(std::exception const& ex) const {
-    return ex.what() == m_message;
-}
-
-std::string ExceptionMessageMatcher::describe() const {
-    return "exception message matches \"" + m_message + '"';
-}
-
-ExceptionMessageMatcher Message(std::string const& message) {
-    return ExceptionMessageMatcher(message);
-}
-
-} // namespace Matchers
-} // namespace Catch
-
-
-
-#include <algorithm>
-#include <cmath>
-#include <cstdlib>
-#include <cstdint>
-#include <sstream>
-#include <iomanip>
-#include <limits>
-
-
-namespace Catch {
-namespace {
-
-    template <typename FP>
-    bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
-        // Comparison with NaN should always be false.
-        // This way we can rule it out before getting into the ugly details
-        if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
-            return false;
-        }
-
-        // This should also handle positive and negative zeros, infinities
-        const auto ulpDist = ulpDistance(lhs, rhs);
-
-        return ulpDist <= maxUlpDiff;
-    }
-
-
-template <typename FP>
-FP step(FP start, FP direction, uint64_t steps) {
-    for (uint64_t i = 0; i < steps; ++i) {
-        start = Catch::nextafter(start, direction);
-    }
-    return start;
-}
-
-// Performs equivalent check of std::fabs(lhs - rhs) <= margin
-// But without the subtraction to allow for INFINITY in comparison
-bool marginComparison(double lhs, double rhs, double margin) {
-    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
-}
-
-template <typename FloatingPoint>
-void write(std::ostream& out, FloatingPoint num) {
-    out << std::scientific
-        << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
-        << num;
-}
-
-} // end anonymous namespace
-
-namespace Matchers {
-namespace Detail {
-
-    enum class FloatingPointKind : uint8_t {
-        Float,
-        Double
-    };
-
-} // end namespace Detail
-
-
-    WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
-        :m_target{ target }, m_margin{ margin } {
-        CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
-            << " Margin has to be non-negative.");
-    }
-
-    // Performs equivalent check of std::fabs(lhs - rhs) <= margin
-    // But without the subtraction to allow for INFINITY in comparison
-    bool WithinAbsMatcher::match(double const& matchee) const {
-        return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
-    }
-
-    std::string WithinAbsMatcher::describe() const {
-        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
-    }
-
-
-    WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, Detail::FloatingPointKind baseType)
-        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
-        CATCH_ENFORCE(m_type == Detail::FloatingPointKind::Double
-                   || m_ulps < (std::numeric_limits<uint32_t>::max)(),
-            "Provided ULP is impossibly large for a float comparison.");
-        CATCH_ENFORCE( std::numeric_limits<double>::is_iec559,
-                       "WithinUlp matcher only supports platforms with "
-                       "IEEE-754 compatible floating point representation" );
-    }
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-// Clang <3.5 reports on the default branch in the switch below
-#pragma clang diagnostic ignored "-Wunreachable-code"
-#endif
-
-    bool WithinUlpsMatcher::match(double const& matchee) const {
-        switch (m_type) {
-        case Detail::FloatingPointKind::Float:
-            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
-        case Detail::FloatingPointKind::Double:
-            return almostEqualUlps<double>(matchee, m_target, m_ulps);
-        default:
-            CATCH_INTERNAL_ERROR( "Unknown Detail::FloatingPointKind value" );
-        }
-    }
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-    std::string WithinUlpsMatcher::describe() const {
-        std::stringstream ret;
-
-        ret << "is within " << m_ulps << " ULPs of ";
-
-        if (m_type == Detail::FloatingPointKind::Float) {
-            write(ret, static_cast<float>(m_target));
-            ret << 'f';
-        } else {
-            write(ret, m_target);
-        }
-
-        ret << " ([";
-        if (m_type == Detail::FloatingPointKind::Double) {
-            write( ret,
-                   step( m_target,
-                         -std::numeric_limits<double>::infinity(),
-                         m_ulps ) );
-            ret << ", ";
-            write( ret,
-                   step( m_target,
-                         std::numeric_limits<double>::infinity(),
-                         m_ulps ) );
-        } else {
-            // We have to cast INFINITY to float because of MinGW, see #1782
-            write( ret,
-                   step( static_cast<float>( m_target ),
-                         -std::numeric_limits<float>::infinity(),
-                         m_ulps ) );
-            ret << ", ";
-            write( ret,
-                   step( static_cast<float>( m_target ),
-                         std::numeric_limits<float>::infinity(),
-                         m_ulps ) );
-        }
-        ret << "])";
-
-        return ret.str();
-    }
-
-    WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
-        m_target(target),
-        m_epsilon(epsilon){
-        CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon <  0 does not make sense.");
-        CATCH_ENFORCE(m_epsilon  < 1., "Relative comparison with epsilon >= 1 does not make sense.");
-    }
-
-    bool WithinRelMatcher::match(double const& matchee) const {
-        const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
-        return marginComparison(matchee, m_target,
-                                std::isinf(relMargin)? 0 : relMargin);
-    }
-
-    std::string WithinRelMatcher::describe() const {
-        Catch::ReusableStringStream sstr;
-        sstr << "and " << ::Catch::Detail::stringify(m_target) << " are within " << m_epsilon * 100. << "% of each other";
-        return sstr.str();
-    }
-
-
-WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
-    return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Double);
-}
-
-WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
-    return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Float);
-}
-
-WithinAbsMatcher WithinAbs(double target, double margin) {
-    return WithinAbsMatcher(target, margin);
-}
-
-WithinRelMatcher WithinRel(double target, double eps) {
-    return WithinRelMatcher(target, eps);
-}
-
-WithinRelMatcher WithinRel(double target) {
-    return WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
-}
-
-WithinRelMatcher WithinRel(float target, float eps) {
-    return WithinRelMatcher(target, eps);
-}
-
-WithinRelMatcher WithinRel(float target) {
-    return WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
-}
-
-
-
-bool IsNaNMatcher::match( double const& matchee ) const {
-    return std::isnan( matchee );
-}
-
-std::string IsNaNMatcher::describe() const {
-    using namespace std::string_literals;
-    return "is NaN"s;
-}
-
-IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
-
-    } // namespace Matchers
-} // namespace Catch
-
-
-
-
-std::string Catch::Matchers::Detail::finalizeDescription(const std::string& desc) {
-    if (desc.empty()) {
-        return "matches undescribed predicate";
-    } else {
-        return "matches predicate: \"" + desc + '"';
-    }
-}
-
-
-
-namespace Catch {
-    namespace Matchers {
-        std::string AllTrueMatcher::describe() const { return "contains only true"; }
-
-        AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
-
-        std::string NoneTrueMatcher::describe() const { return "contains no true"; }
-
-        NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
-
-        std::string AnyTrueMatcher::describe() const { return "contains at least one true"; }
-
-        AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
-    } // namespace Matchers
-} // namespace Catch
-
-
-
-#include <regex>
-
-namespace Catch {
-namespace Matchers {
-
-    CasedString::CasedString( std::string const& str, CaseSensitive caseSensitivity )
-    :   m_caseSensitivity( caseSensitivity ),
-        m_str( adjustString( str ) )
-    {}
-    std::string CasedString::adjustString( std::string const& str ) const {
-        return m_caseSensitivity == CaseSensitive::No
-               ? toLower( str )
-               : str;
-    }
-    StringRef CasedString::caseSensitivitySuffix() const {
-        return m_caseSensitivity == CaseSensitive::Yes
-                   ? StringRef()
-                   : " (case insensitive)"_sr;
-    }
-
-
-    StringMatcherBase::StringMatcherBase( StringRef operation, CasedString const& comparator )
-    : m_comparator( comparator ),
-      m_operation( operation ) {
-    }
-
-    std::string StringMatcherBase::describe() const {
-        std::string description;
-        description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
-                                    m_comparator.caseSensitivitySuffix().size());
-        description += m_operation;
-        description += ": \"";
-        description += m_comparator.m_str;
-        description += '"';
-        description += m_comparator.caseSensitivitySuffix();
-        return description;
-    }
-
-    StringEqualsMatcher::StringEqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals"_sr, comparator ) {}
-
-    bool StringEqualsMatcher::match( std::string const& source ) const {
-        return m_comparator.adjustString( source ) == m_comparator.m_str;
-    }
-
-
-    StringContainsMatcher::StringContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains"_sr, comparator ) {}
-
-    bool StringContainsMatcher::match( std::string const& source ) const {
-        return contains( m_comparator.adjustString( source ), m_comparator.m_str );
-    }
-
-
-    StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with"_sr, comparator ) {}
-
-    bool StartsWithMatcher::match( std::string const& source ) const {
-        return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-    }
-
-
-    EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with"_sr, comparator ) {}
-
-    bool EndsWithMatcher::match( std::string const& source ) const {
-        return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-    }
-
-
-
-    RegexMatcher::RegexMatcher(std::string regex, CaseSensitive caseSensitivity): m_regex(CATCH_MOVE(regex)), m_caseSensitivity(caseSensitivity) {}
-
-    bool RegexMatcher::match(std::string const& matchee) const {
-        auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
-        if (m_caseSensitivity == CaseSensitive::No) {
-            flags |= std::regex::icase;
-        }
-        auto reg = std::regex(m_regex, flags);
-        return std::regex_match(matchee, reg);
-    }
-
-    std::string RegexMatcher::describe() const {
-        return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Yes)? " case sensitively" : " case insensitively");
-    }
-
-
-    StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity ) {
-        return StringEqualsMatcher( CasedString( str, caseSensitivity) );
-    }
-    StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity ) {
-        return StringContainsMatcher( CasedString( str, caseSensitivity) );
-    }
-    EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity ) {
-        return EndsWithMatcher( CasedString( str, caseSensitivity) );
-    }
-    StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity ) {
-        return StartsWithMatcher( CasedString( str, caseSensitivity) );
-    }
-
-    RegexMatcher Matches(std::string const& regex, CaseSensitive caseSensitivity) {
-        return RegexMatcher(regex, caseSensitivity);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-
-
-
-namespace Catch {
-namespace Matchers {
-    MatcherGenericBase::~MatcherGenericBase() = default;
-
-    namespace Detail {
-
-        std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end) {
-            std::string description;
-            std::size_t combined_size = 4;
-            for ( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) {
-                combined_size += desc->size();
-            }
-            combined_size += static_cast<size_t>(descriptions_end - descriptions_begin - 1) * combine.size();
-
-            description.reserve(combined_size);
-
-            description += "( ";
-            bool first = true;
-            for( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) {
-                if( first )
-                    first = false;
-                else
-                    description += combine;
-                description += *desc;
-            }
-            description += " )";
-            return description;
-        }
-
-    } // namespace Detail
-} // namespace Matchers
-} // namespace Catch
-
-
-
-
-namespace Catch {
-
-    // This is the general overload that takes a any string matcher
-    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
-    // the Equals matcher (so the header does not mention matchers)
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher ) {
-        std::string exceptionMessage = Catch::translateActiveException();
-        MatchExpr<std::string, StringMatcher const&> expr( CATCH_MOVE(exceptionMessage), matcher );
-        handler.handleExpr( expr );
-    }
-
-} // namespace Catch
-
-
-
-#include <ostream>
-
-namespace Catch {
-
-    AutomakeReporter::~AutomakeReporter() = default;
-
-    void AutomakeReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
-        // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
-        m_stream << ":test-result: ";
-        if ( _testCaseStats.totals.testCases.skipped > 0 ) {
-            m_stream << "SKIP";
-        } else if (_testCaseStats.totals.assertions.allPassed()) {
-            m_stream << "PASS";
-        } else if (_testCaseStats.totals.assertions.allOk()) {
-            m_stream << "XFAIL";
-        } else {
-            m_stream << "FAIL";
-        }
-        m_stream << ' ' << _testCaseStats.testInfo->name << '\n';
-        StreamingReporterBase::testCaseEnded(_testCaseStats);
-    }
-
-    void AutomakeReporter::skipTest(TestCaseInfo const& testInfo) {
-        m_stream << ":test-result: SKIP " << testInfo.name << '\n';
-    }
-
-} // end namespace Catch
-
-
-
-
-
-
-namespace Catch {
-    ReporterBase::ReporterBase( ReporterConfig&& config ):
-        IEventListener( config.fullConfig() ),
-        m_wrapped_stream( CATCH_MOVE(config).takeStream() ),
-        m_stream( m_wrapped_stream->stream() ),
-        m_colour( makeColourImpl( config.colourMode(), m_wrapped_stream.get() ) ),
-        m_customOptions( config.customOptions() )
-    {}
-
-    ReporterBase::~ReporterBase() = default;
-
-    void ReporterBase::listReporters(
-        std::vector<ReporterDescription> const& descriptions ) {
-        defaultListReporters(m_stream, descriptions, m_config->verbosity());
-    }
-
-    void ReporterBase::listListeners(
-        std::vector<ListenerDescription> const& descriptions ) {
-        defaultListListeners( m_stream, descriptions );
-    }
-
-    void ReporterBase::listTests(std::vector<TestCaseHandle> const& tests) {
-        defaultListTests(m_stream,
-                         m_colour.get(),
-                         tests,
-                         m_config->hasTestFilters(),
-                         m_config->verbosity());
-    }
-
-    void ReporterBase::listTags(std::vector<TagInfo> const& tags) {
-        defaultListTags( m_stream, tags, m_config->hasTestFilters() );
-    }
-
-} // namespace Catch
-
-
-
-
-#include <ostream>
-
-namespace Catch {
-namespace {
-
-    // Colour::LightGrey
-    static constexpr Colour::Code compactDimColour = Colour::FileName;
-
-#ifdef CATCH_PLATFORM_MAC
-    static constexpr Catch::StringRef compactFailedString = "FAILED"_sr;
-    static constexpr Catch::StringRef compactPassedString = "PASSED"_sr;
-#else
-    static constexpr Catch::StringRef compactFailedString = "failed"_sr;
-    static constexpr Catch::StringRef compactPassedString = "passed"_sr;
-#endif
-
-// Implementation of CompactReporter formatting
-class AssertionPrinter {
-public:
-    AssertionPrinter& operator= (AssertionPrinter const&) = delete;
-    AssertionPrinter(AssertionPrinter const&) = delete;
-    AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages, ColourImpl* colourImpl_)
-        : stream(_stream)
-        , result(_stats.assertionResult)
-        , messages(_stats.infoMessages)
-        , itMessage(_stats.infoMessages.begin())
-        , printInfoMessages(_printInfoMessages)
-        , colourImpl(colourImpl_)
-    {}
-
-    void print() {
-        printSourceInfo();
-
-        itMessage = messages.begin();
-
-        switch (result.getResultType()) {
-        case ResultWas::Ok:
-            printResultType(Colour::ResultSuccess, compactPassedString);
-            printOriginalExpression();
-            printReconstructedExpression();
-            if (!result.hasExpression())
-                printRemainingMessages(Colour::None);
-            else
-                printRemainingMessages();
-            break;
-        case ResultWas::ExpressionFailed:
-            if (result.isOk())
-                printResultType(Colour::ResultSuccess, compactFailedString + " - but was ok"_sr);
-            else
-                printResultType(Colour::Error, compactFailedString);
-            printOriginalExpression();
-            printReconstructedExpression();
-            printRemainingMessages();
-            break;
-        case ResultWas::ThrewException:
-            printResultType(Colour::Error, compactFailedString);
-            printIssue("unexpected exception with message:");
-            printMessage();
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::FatalErrorCondition:
-            printResultType(Colour::Error, compactFailedString);
-            printIssue("fatal error condition with message:");
-            printMessage();
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::DidntThrowException:
-            printResultType(Colour::Error, compactFailedString);
-            printIssue("expected exception, got none");
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::Info:
-            printResultType(Colour::None, "info"_sr);
-            printMessage();
-            printRemainingMessages();
-            break;
-        case ResultWas::Warning:
-            printResultType(Colour::None, "warning"_sr);
-            printMessage();
-            printRemainingMessages();
-            break;
-        case ResultWas::ExplicitFailure:
-            printResultType(Colour::Error, compactFailedString);
-            printIssue("explicitly");
-            printRemainingMessages(Colour::None);
-            break;
-        case ResultWas::ExplicitSkip:
-            printResultType(Colour::Skip, "skipped"_sr);
-            printMessage();
-            printRemainingMessages();
-            break;
-            // These cases are here to prevent compiler warnings
-        case ResultWas::Unknown:
-        case ResultWas::FailureBit:
-        case ResultWas::Exception:
-            printResultType(Colour::Error, "** internal error **");
-            break;
-        }
-    }
-
-private:
-    void printSourceInfo() const {
-        stream << colourImpl->guardColour( Colour::FileName )
-               << result.getSourceInfo() << ':';
-    }
-
-    void printResultType(Colour::Code colour, StringRef passOrFail) const {
-        if (!passOrFail.empty()) {
-            stream << colourImpl->guardColour(colour) << ' ' << passOrFail;
-            stream << ':';
-        }
-    }
-
-    void printIssue(char const* issue) const {
-        stream << ' ' << issue;
-    }
-
-    void printExpressionWas() {
-        if (result.hasExpression()) {
-            stream << ';';
-            {
-                stream << colourImpl->guardColour(compactDimColour) << " expression was:";
-            }
-            printOriginalExpression();
-        }
-    }
-
-    void printOriginalExpression() const {
-        if (result.hasExpression()) {
-            stream << ' ' << result.getExpression();
-        }
-    }
-
-    void printReconstructedExpression() const {
-        if (result.hasExpandedExpression()) {
-            stream << colourImpl->guardColour(compactDimColour) << " for: ";
-            stream << result.getExpandedExpression();
-        }
-    }
-
-    void printMessage() {
-        if (itMessage != messages.end()) {
-            stream << " '" << itMessage->message << '\'';
-            ++itMessage;
-        }
-    }
-
-    void printRemainingMessages(Colour::Code colour = compactDimColour) {
-        if (itMessage == messages.end())
-            return;
-
-        const auto itEnd = messages.cend();
-        const auto N = static_cast<std::size_t>(itEnd - itMessage);
-
-        stream << colourImpl->guardColour( colour ) << " with "
-               << pluralise( N, "message"_sr ) << ':';
-
-        while (itMessage != itEnd) {
-            // If this assertion is a warning ignore any INFO messages
-            if (printInfoMessages || itMessage->type != ResultWas::Info) {
-                printMessage();
-                if (itMessage != itEnd) {
-                    stream << colourImpl->guardColour(compactDimColour) << " and";
-                }
-                continue;
-            }
-            ++itMessage;
-        }
-    }
-
-private:
-    std::ostream& stream;
-    AssertionResult const& result;
-    std::vector<MessageInfo> const& messages;
-    std::vector<MessageInfo>::const_iterator itMessage;
-    bool printInfoMessages;
-    ColourImpl* colourImpl;
-};
-
-} // anon namespace
-
-        std::string CompactReporter::getDescription() {
-            return "Reports test results on a single line, suitable for IDEs";
-        }
-
-        void CompactReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
-            m_stream << "No test cases matched '" << unmatchedSpec << "'\n";
-        }
-
-        void CompactReporter::testRunStarting( TestRunInfo const& ) {
-            if ( m_config->testSpec().hasFilters() ) {
-                m_stream << m_colour->guardColour( Colour::BrightYellow )
-                         << "Filters: "
-                         << m_config->testSpec()
-                         << '\n';
-            }
-            m_stream << "RNG seed: " << getSeed() << '\n';
-        }
-
-        void CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
-            AssertionResult const& result = _assertionStats.assertionResult;
-
-            bool printInfoMessages = true;
-
-            // Drop out if result was successful and we're not printing those
-            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
-                if( result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip )
-                    return;
-                printInfoMessages = false;
-            }
-
-            AssertionPrinter printer( m_stream, _assertionStats, printInfoMessages, m_colour.get() );
-            printer.print();
-
-            m_stream << '\n' << std::flush;
-        }
-
-        void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
-            double dur = _sectionStats.durationInSeconds;
-            if ( shouldShowDuration( *m_config, dur ) ) {
-                m_stream << getFormattedDuration( dur ) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush;
-            }
-        }
-
-        void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
-            printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
-            m_stream << "\n\n" << std::flush;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-        CompactReporter::~CompactReporter() = default;
-
-} // end namespace Catch
-
-
-
-
-#include <cstdio>
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
- // Note that 4062 (not all labels are handled and default is missing) is enabled
-#endif
-
-#if defined(__clang__)
-#  pragma clang diagnostic push
-// For simplicity, benchmarking-only helpers are always enabled
-#  pragma clang diagnostic ignored "-Wunused-function"
-#endif
-
-
-
-namespace Catch {
-
-namespace {
-
-// Formatter impl for ConsoleReporter
-class ConsoleAssertionPrinter {
-public:
-    ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
-    ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
-    ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, ColourImpl* colourImpl_, bool _printInfoMessages)
-        : stream(_stream),
-        stats(_stats),
-        result(_stats.assertionResult),
-        colour(Colour::None),
-        messages(_stats.infoMessages),
-        colourImpl(colourImpl_),
-        printInfoMessages(_printInfoMessages) {
-        switch (result.getResultType()) {
-        case ResultWas::Ok:
-            colour = Colour::Success;
-            passOrFail = "PASSED"_sr;
-            //if( result.hasMessage() )
-            if (messages.size() == 1)
-                messageLabel = "with message"_sr;
-            if (messages.size() > 1)
-                messageLabel = "with messages"_sr;
-            break;
-        case ResultWas::ExpressionFailed:
-            if (result.isOk()) {
-                colour = Colour::Success;
-                passOrFail = "FAILED - but was ok"_sr;
-            } else {
-                colour = Colour::Error;
-                passOrFail = "FAILED"_sr;
-            }
-            if (messages.size() == 1)
-                messageLabel = "with message"_sr;
-            if (messages.size() > 1)
-                messageLabel = "with messages"_sr;
-            break;
-        case ResultWas::ThrewException:
-            colour = Colour::Error;
-            passOrFail = "FAILED"_sr;
-            // todo switch
-            switch (messages.size()) { case 0:
-                messageLabel = "due to unexpected exception with "_sr;
-                break;
-            case 1:
-                messageLabel = "due to unexpected exception with message"_sr;
-                break;
-            default:
-                messageLabel = "due to unexpected exception with messages"_sr;
-                break;
-            }
-            break;
-        case ResultWas::FatalErrorCondition:
-            colour = Colour::Error;
-            passOrFail = "FAILED"_sr;
-            messageLabel = "due to a fatal error condition"_sr;
-            break;
-        case ResultWas::DidntThrowException:
-            colour = Colour::Error;
-            passOrFail = "FAILED"_sr;
-            messageLabel = "because no exception was thrown where one was expected"_sr;
-            break;
-        case ResultWas::Info:
-            messageLabel = "info"_sr;
-            break;
-        case ResultWas::Warning:
-            messageLabel = "warning"_sr;
-            break;
-        case ResultWas::ExplicitFailure:
-            passOrFail = "FAILED"_sr;
-            colour = Colour::Error;
-            if (messages.size() == 1)
-                messageLabel = "explicitly with message"_sr;
-            if (messages.size() > 1)
-                messageLabel = "explicitly with messages"_sr;
-            break;
-        case ResultWas::ExplicitSkip:
-            colour = Colour::Skip;
-            passOrFail = "SKIPPED"_sr;
-            if (messages.size() == 1)
-                messageLabel = "explicitly with message"_sr;
-            if (messages.size() > 1)
-                messageLabel = "explicitly with messages"_sr;
-            break;
-            // These cases are here to prevent compiler warnings
-        case ResultWas::Unknown:
-        case ResultWas::FailureBit:
-        case ResultWas::Exception:
-            passOrFail = "** internal error **"_sr;
-            colour = Colour::Error;
-            break;
-        }
-    }
-
-    void print() const {
-        printSourceInfo();
-        if (stats.totals.assertions.total() > 0) {
-            printResultType();
-            printOriginalExpression();
-            printReconstructedExpression();
-        } else {
-            stream << '\n';
-        }
-        printMessage();
-    }
-
-private:
-    void printResultType() const {
-        if (!passOrFail.empty()) {
-            stream << colourImpl->guardColour(colour) << passOrFail << ":\n";
-        }
-    }
-    void printOriginalExpression() const {
-        if (result.hasExpression()) {
-            stream << colourImpl->guardColour( Colour::OriginalExpression )
-                   << "  " << result.getExpressionInMacro() << '\n';
-        }
-    }
-    void printReconstructedExpression() const {
-        if (result.hasExpandedExpression()) {
-            stream << "with expansion:\n";
-            stream << colourImpl->guardColour( Colour::ReconstructedExpression )
-                   << TextFlow::Column( result.getExpandedExpression() )
-                          .indent( 2 )
-                   << '\n';
-        }
-    }
-    void printMessage() const {
-        if (!messageLabel.empty())
-            stream << messageLabel << ':' << '\n';
-        for (auto const& msg : messages) {
-            // If this assertion is a warning ignore any INFO messages
-            if (printInfoMessages || msg.type != ResultWas::Info)
-                stream << TextFlow::Column(msg.message).indent(2) << '\n';
-        }
-    }
-    void printSourceInfo() const {
-        stream << colourImpl->guardColour( Colour::FileName )
-               << result.getSourceInfo() << ": ";
-    }
-
-    std::ostream& stream;
-    AssertionStats const& stats;
-    AssertionResult const& result;
-    Colour::Code colour;
-    StringRef passOrFail;
-    StringRef messageLabel;
-    std::vector<MessageInfo> const& messages;
-    ColourImpl* colourImpl;
-    bool printInfoMessages;
-};
-
-std::size_t makeRatio( std::uint64_t number, std::uint64_t total ) {
-    const auto ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
-    return (ratio == 0 && number > 0) ? 1 : static_cast<std::size_t>(ratio);
-}
-
-std::size_t&
-findMax( std::size_t& i, std::size_t& j, std::size_t& k, std::size_t& l ) {
-    if (i > j && i > k && i > l)
-        return i;
-    else if (j > k && j > l)
-        return j;
-    else if (k > l)
-        return k;
-    else
-        return l;
-}
-
-struct ColumnBreak {};
-struct RowBreak {};
-struct OutputFlush {};
-
-class Duration {
-    enum class Unit {
-        Auto,
-        Nanoseconds,
-        Microseconds,
-        Milliseconds,
-        Seconds,
-        Minutes
-    };
-    static const uint64_t s_nanosecondsInAMicrosecond = 1000;
-    static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
-    static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
-    static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
-
-    double m_inNanoseconds;
-    Unit m_units;
-
-public:
-    explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
-        : m_inNanoseconds(inNanoseconds),
-        m_units(units) {
-        if (m_units == Unit::Auto) {
-            if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
-                m_units = Unit::Nanoseconds;
-            else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
-                m_units = Unit::Microseconds;
-            else if (m_inNanoseconds < s_nanosecondsInASecond)
-                m_units = Unit::Milliseconds;
-            else if (m_inNanoseconds < s_nanosecondsInAMinute)
-                m_units = Unit::Seconds;
-            else
-                m_units = Unit::Minutes;
-        }
-
-    }
-
-    auto value() const -> double {
-        switch (m_units) {
-        case Unit::Microseconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
-        case Unit::Milliseconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
-        case Unit::Seconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
-        case Unit::Minutes:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
-        default:
-            return m_inNanoseconds;
-        }
-    }
-    StringRef unitsAsString() const {
-        switch (m_units) {
-        case Unit::Nanoseconds:
-            return "ns"_sr;
-        case Unit::Microseconds:
-            return "us"_sr;
-        case Unit::Milliseconds:
-            return "ms"_sr;
-        case Unit::Seconds:
-            return "s"_sr;
-        case Unit::Minutes:
-            return "m"_sr;
-        default:
-            return "** internal error **"_sr;
-        }
-
-    }
-    friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
-        return os << duration.value() << ' ' << duration.unitsAsString();
-    }
-};
-} // end anon namespace
-
-enum class Justification { Left, Right };
-
-struct ColumnInfo {
-    std::string name;
-    std::size_t width;
-    Justification justification;
-};
-
-class TablePrinter {
-    std::ostream& m_os;
-    std::vector<ColumnInfo> m_columnInfos;
-    ReusableStringStream m_oss;
-    int m_currentColumn = -1;
-    bool m_isOpen = false;
-
-public:
-    TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
-    :   m_os( os ),
-        m_columnInfos( CATCH_MOVE( columnInfos ) ) {}
-
-    auto columnInfos() const -> std::vector<ColumnInfo> const& {
-        return m_columnInfos;
-    }
-
-    void open() {
-        if (!m_isOpen) {
-            m_isOpen = true;
-            *this << RowBreak();
-
-			TextFlow::Columns headerCols;
-			for (auto const& info : m_columnInfos) {
-                assert(info.width > 2);
-				headerCols += TextFlow::Column(info.name).width(info.width - 2);
-                headerCols += TextFlow::Spacer( 2 );
-			}
-			m_os << headerCols << '\n';
-
-            m_os << lineOfChars('-') << '\n';
-        }
-    }
-    void close() {
-        if (m_isOpen) {
-            *this << RowBreak();
-            m_os << '\n' << std::flush;
-            m_isOpen = false;
-        }
-    }
-
-    template<typename T>
-    friend TablePrinter& operator<< (TablePrinter& tp, T const& value) {
-        tp.m_oss << value;
-        return tp;
-    }
-
-    friend TablePrinter& operator<< (TablePrinter& tp, ColumnBreak) {
-        auto colStr = tp.m_oss.str();
-        const auto strSize = colStr.size();
-        tp.m_oss.str("");
-        tp.open();
-        if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
-            tp.m_currentColumn = -1;
-            tp.m_os << '\n';
-        }
-        tp.m_currentColumn++;
-
-        auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
-        auto padding = (strSize + 1 < colInfo.width)
-            ? std::string(colInfo.width - (strSize + 1), ' ')
-            : std::string();
-        if (colInfo.justification == Justification::Left)
-            tp.m_os << colStr << padding << ' ';
-        else
-            tp.m_os << padding << colStr << ' ';
-        return tp;
-    }
-
-    friend TablePrinter& operator<< (TablePrinter& tp, RowBreak) {
-        if (tp.m_currentColumn > 0) {
-            tp.m_os << '\n';
-            tp.m_currentColumn = -1;
-        }
-        return tp;
-    }
-
-    friend TablePrinter& operator<<(TablePrinter& tp, OutputFlush) {
-        tp.m_os << std::flush;
-        return tp;
-    }
-};
-
-ConsoleReporter::ConsoleReporter(ReporterConfig&& config):
-    StreamingReporterBase( CATCH_MOVE( config ) ),
-    m_tablePrinter(Detail::make_unique<TablePrinter>(m_stream,
-        [&config]() -> std::vector<ColumnInfo> {
-        if (config.fullConfig()->benchmarkNoAnalysis())
-        {
-            return{
-                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left },
-                { "     samples", 14, Justification::Right },
-                { "  iterations", 14, Justification::Right },
-                { "        mean", 14, Justification::Right }
-            };
-        }
-        else
-        {
-            return{
-                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left },
-                { "samples      mean       std dev", 14, Justification::Right },
-                { "iterations   low mean   low std dev", 14, Justification::Right },
-                { "est run time high mean  high std dev", 14, Justification::Right }
-            };
-        }
-    }())) {}
-ConsoleReporter::~ConsoleReporter() = default;
-
-std::string ConsoleReporter::getDescription() {
-    return "Reports test results as plain lines of text";
-}
-
-void ConsoleReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
-    m_stream << "No test cases matched '" << unmatchedSpec << "'\n";
-}
-
-void ConsoleReporter::reportInvalidTestSpec( StringRef arg ) {
-    m_stream << "Invalid Filter: " << arg << '\n';
-}
-
-void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
-
-void ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
-    AssertionResult const& result = _assertionStats.assertionResult;
-
-    bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-    // Drop out if result was successful but we're not printing them.
-    // TODO: Make configurable whether skips should be printed
-    if (!includeResults && result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip)
-        return;
-
-    lazyPrint();
-
-    ConsoleAssertionPrinter printer(m_stream, _assertionStats, m_colour.get(), includeResults);
-    printer.print();
-    m_stream << '\n' << std::flush;
-}
-
-void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
-    m_tablePrinter->close();
-    m_headerPrinted = false;
-    StreamingReporterBase::sectionStarting(_sectionInfo);
-}
-void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
-    m_tablePrinter->close();
-    if (_sectionStats.missingAssertions) {
-        lazyPrint();
-        auto guard =
-            m_colour->guardColour( Colour::ResultError ).engage( m_stream );
-        if (m_sectionStack.size() > 1)
-            m_stream << "\nNo assertions in section";
-        else
-            m_stream << "\nNo assertions in test case";
-        m_stream << " '" << _sectionStats.sectionInfo.name << "'\n\n" << std::flush;
-    }
-    double dur = _sectionStats.durationInSeconds;
-    if (shouldShowDuration(*m_config, dur)) {
-        m_stream << getFormattedDuration(dur) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush;
-    }
-    if (m_headerPrinted) {
-        m_headerPrinted = false;
-    }
-    StreamingReporterBase::sectionEnded(_sectionStats);
-}
-
-void ConsoleReporter::benchmarkPreparing( StringRef name ) {
-	lazyPrintWithoutClosingBenchmarkTable();
-
-	auto nameCol = TextFlow::Column( static_cast<std::string>( name ) )
-                       .width( m_tablePrinter->columnInfos()[0].width - 2 );
-
-	bool firstLine = true;
-	for (auto line : nameCol) {
-		if (!firstLine)
-			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
-		else
-			firstLine = false;
-
-		(*m_tablePrinter) << line << ColumnBreak();
-	}
-}
-
-void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
-    (*m_tablePrinter) << info.samples << ColumnBreak()
-        << info.iterations << ColumnBreak();
-    if ( !m_config->benchmarkNoAnalysis() ) {
-        ( *m_tablePrinter )
-            << Duration( info.estimatedDuration ) << ColumnBreak();
-    }
-    ( *m_tablePrinter ) << OutputFlush{};
-}
-void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
-    if (m_config->benchmarkNoAnalysis())
-    {
-        (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
-    }
-    else
-    {
-        (*m_tablePrinter) << ColumnBreak()
-            << Duration(stats.mean.point.count()) << ColumnBreak()
-            << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
-            << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
-            << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
-            << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
-            << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
-    }
-}
-
-void ConsoleReporter::benchmarkFailed( StringRef error ) {
-    auto guard = m_colour->guardColour( Colour::Red ).engage( m_stream );
-    (*m_tablePrinter)
-        << "Benchmark failed (" << error << ')'
-        << ColumnBreak() << RowBreak();
-}
-
-void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
-    m_tablePrinter->close();
-    StreamingReporterBase::testCaseEnded(_testCaseStats);
-    m_headerPrinted = false;
-}
-void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
-    printTotalsDivider(_testRunStats.totals);
-    printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
-    m_stream << '\n' << std::flush;
-    StreamingReporterBase::testRunEnded(_testRunStats);
-}
-void ConsoleReporter::testRunStarting(TestRunInfo const& _testRunInfo) {
-    StreamingReporterBase::testRunStarting(_testRunInfo);
-    if ( m_config->testSpec().hasFilters() ) {
-        m_stream << m_colour->guardColour( Colour::BrightYellow ) << "Filters: "
-                 << m_config->testSpec() << '\n';
-    }
-    m_stream << "Randomness seeded to: " << getSeed() << '\n';
-}
-
-void ConsoleReporter::lazyPrint() {
-
-    m_tablePrinter->close();
-    lazyPrintWithoutClosingBenchmarkTable();
-}
-
-void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
-
-    if ( !m_testRunInfoPrinted ) {
-        lazyPrintRunInfo();
-    }
-    if (!m_headerPrinted) {
-        printTestCaseAndSectionHeader();
-        m_headerPrinted = true;
-    }
-}
-void ConsoleReporter::lazyPrintRunInfo() {
-    m_stream << '\n'
-             << lineOfChars( '~' ) << '\n'
-             << m_colour->guardColour( Colour::SecondaryText )
-             << currentTestRunInfo.name << " is a Catch2 v" << libraryVersion()
-             << " host application.\n"
-             << "Run with -? for options\n\n";
-
-    m_testRunInfoPrinted = true;
-}
-void ConsoleReporter::printTestCaseAndSectionHeader() {
-    assert(!m_sectionStack.empty());
-    printOpenHeader(currentTestCaseInfo->name);
-
-    if (m_sectionStack.size() > 1) {
-        auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );
-
-        auto
-            it = m_sectionStack.begin() + 1, // Skip first section (test case)
-            itEnd = m_sectionStack.end();
-        for (; it != itEnd; ++it)
-            printHeaderString(it->name, 2);
-    }
-
-    SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
-
-
-    m_stream << lineOfChars( '-' ) << '\n'
-             << m_colour->guardColour( Colour::FileName ) << lineInfo << '\n'
-             << lineOfChars( '.' ) << "\n\n"
-             << std::flush;
-}
-
-void ConsoleReporter::printClosedHeader(std::string const& _name) {
-    printOpenHeader(_name);
-    m_stream << lineOfChars('.') << '\n';
-}
-void ConsoleReporter::printOpenHeader(std::string const& _name) {
-    m_stream << lineOfChars('-') << '\n';
-    {
-        auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );
-        printHeaderString(_name);
-    }
-}
-
-void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
-    // We want to get a bit fancy with line breaking here, so that subsequent
-    // lines start after ":" if one is present, e.g.
-    // ```
-    // blablabla: Fancy
-    //            linebreaking
-    // ```
-    // but we also want to avoid problems with overly long indentation causing
-    // the text to take up too many lines, e.g.
-    // ```
-    // blablabla: F
-    //            a
-    //            n
-    //            c
-    //            y
-    //            .
-    //            .
-    //            .
-    // ```
-    // So we limit the prefix indentation check to first quarter of the possible
-    // width
-    std::size_t idx = _string.find( ": " );
-    if ( idx != std::string::npos && idx < CATCH_CONFIG_CONSOLE_WIDTH / 4 ) {
-        idx += 2;
-    } else {
-        idx = 0;
-    }
-    m_stream << TextFlow::Column( _string )
-                  .indent( indent + idx )
-                  .initialIndent( indent )
-           << '\n';
-}
-
-void ConsoleReporter::printTotalsDivider(Totals const& totals) {
-    if (totals.testCases.total() > 0) {
-        std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
-        std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
-        std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
-        std::size_t skippedRatio = makeRatio(totals.testCases.skipped, totals.testCases.total());
-        while (failedRatio + failedButOkRatio + passedRatio + skippedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
-            findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)++;
-        while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
-            findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)--;
-
-        m_stream << m_colour->guardColour( Colour::Error )
-                 << std::string( failedRatio, '=' )
-                 << m_colour->guardColour( Colour::ResultExpectedFailure )
-                 << std::string( failedButOkRatio, '=' );
-        if ( totals.testCases.allPassed() ) {
-            m_stream << m_colour->guardColour( Colour::ResultSuccess )
-                     << std::string( passedRatio, '=' );
-        } else {
-            m_stream << m_colour->guardColour( Colour::Success )
-                     << std::string( passedRatio, '=' );
-        }
-        m_stream << m_colour->guardColour( Colour::Skip )
-                 << std::string( skippedRatio, '=' );
-    } else {
-        m_stream << m_colour->guardColour( Colour::Warning )
-                 << std::string( CATCH_CONFIG_CONSOLE_WIDTH - 1, '=' );
-    }
-    m_stream << '\n';
-}
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-#if defined(__clang__)
-#  pragma clang diagnostic pop
-#endif
-
-
-
-
-#include <algorithm>
-#include <cassert>
-
-namespace Catch {
-    namespace {
-        struct BySectionInfo {
-            BySectionInfo( SectionInfo const& other ): m_other( other ) {}
-            BySectionInfo( BySectionInfo const& other ) = default;
-            bool operator()(
-                Detail::unique_ptr<CumulativeReporterBase::SectionNode> const&
-                    node ) const {
-                return (
-                    ( node->stats.sectionInfo.name == m_other.name ) &&
-                    ( node->stats.sectionInfo.lineInfo == m_other.lineInfo ) );
-            }
-            void operator=( BySectionInfo const& ) = delete;
-
-        private:
-            SectionInfo const& m_other;
-        };
-
-    } // namespace
-
-    namespace Detail {
-        AssertionOrBenchmarkResult::AssertionOrBenchmarkResult(
-            AssertionStats const& assertion ):
-            m_assertion( assertion ) {}
-
-        AssertionOrBenchmarkResult::AssertionOrBenchmarkResult(
-            BenchmarkStats<> const& benchmark ):
-            m_benchmark( benchmark ) {}
-
-        bool AssertionOrBenchmarkResult::isAssertion() const {
-            return m_assertion.some();
-        }
-        bool AssertionOrBenchmarkResult::isBenchmark() const {
-            return m_benchmark.some();
-        }
-
-        AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
-            assert(m_assertion.some());
-
-            return *m_assertion;
-        }
-        BenchmarkStats<> const& AssertionOrBenchmarkResult::asBenchmark() const {
-            assert(m_benchmark.some());
-
-            return *m_benchmark;
-        }
-
-    }
-
-    CumulativeReporterBase::~CumulativeReporterBase() = default;
-
-    void CumulativeReporterBase::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
-        m_sectionStack.back()->assertionsAndBenchmarks.emplace_back(benchmarkStats);
-    }
-
-    void
-    CumulativeReporterBase::sectionStarting( SectionInfo const& sectionInfo ) {
-        // We need a copy, because SectionStats expect to take ownership
-        SectionStats incompleteStats( SectionInfo(sectionInfo), Counts(), 0, false );
-        SectionNode* node;
-        if ( m_sectionStack.empty() ) {
-            if ( !m_rootSection ) {
-                m_rootSection =
-                    Detail::make_unique<SectionNode>( incompleteStats );
-            }
-            node = m_rootSection.get();
-        } else {
-            SectionNode& parentNode = *m_sectionStack.back();
-            auto it = std::find_if( parentNode.childSections.begin(),
-                                    parentNode.childSections.end(),
-                                    BySectionInfo( sectionInfo ) );
-            if ( it == parentNode.childSections.end() ) {
-                auto newNode =
-                    Detail::make_unique<SectionNode>( incompleteStats );
-                node = newNode.get();
-                parentNode.childSections.push_back( CATCH_MOVE( newNode ) );
-            } else {
-                node = it->get();
-            }
-        }
-
-        m_deepestSection = node;
-        m_sectionStack.push_back( node );
-    }
-
-    void CumulativeReporterBase::assertionEnded(
-        AssertionStats const& assertionStats ) {
-        assert( !m_sectionStack.empty() );
-        // AssertionResult holds a pointer to a temporary DecomposedExpression,
-        // which getExpandedExpression() calls to build the expression string.
-        // Our section stack copy of the assertionResult will likely outlive the
-        // temporary, so it must be expanded or discarded now to avoid calling
-        // a destroyed object later.
-        if ( m_shouldStoreFailedAssertions &&
-             !assertionStats.assertionResult.isOk() ) {
-            static_cast<void>(
-                assertionStats.assertionResult.getExpandedExpression() );
-        }
-        if ( m_shouldStoreSuccesfulAssertions &&
-             assertionStats.assertionResult.isOk() ) {
-            static_cast<void>(
-                assertionStats.assertionResult.getExpandedExpression() );
-        }
-        SectionNode& sectionNode = *m_sectionStack.back();
-        sectionNode.assertionsAndBenchmarks.emplace_back( assertionStats );
-    }
-
-    void CumulativeReporterBase::sectionEnded( SectionStats const& sectionStats ) {
-        assert( !m_sectionStack.empty() );
-        SectionNode& node = *m_sectionStack.back();
-        node.stats = sectionStats;
-        m_sectionStack.pop_back();
-    }
-
-    void CumulativeReporterBase::testCaseEnded(
-        TestCaseStats const& testCaseStats ) {
-        auto node = Detail::make_unique<TestCaseNode>( testCaseStats );
-        assert( m_sectionStack.size() == 0 );
-        node->children.push_back( CATCH_MOVE(m_rootSection) );
-        m_testCases.push_back( CATCH_MOVE(node) );
-
-        assert( m_deepestSection );
-        m_deepestSection->stdOut = testCaseStats.stdOut;
-        m_deepestSection->stdErr = testCaseStats.stdErr;
-    }
-
-
-    void CumulativeReporterBase::testRunEnded( TestRunStats const& testRunStats ) {
-        assert(!m_testRun && "CumulativeReporterBase assumes there can only be one test run");
-        m_testRun = Detail::make_unique<TestRunNode>( testRunStats );
-        m_testRun->children.swap( m_testCases );
-        testRunEndedCumulative();
-    }
-
-    bool CumulativeReporterBase::SectionNode::hasAnyAssertions() const {
-        return std::any_of(
-            assertionsAndBenchmarks.begin(),
-            assertionsAndBenchmarks.end(),
-            []( Detail::AssertionOrBenchmarkResult const& res ) {
-                return res.isAssertion();
-            } );
-    }
-
-} // end namespace Catch
-
-
-
-
-namespace Catch {
-
-    void EventListenerBase::fatalErrorEncountered( StringRef ) {}
-
-    void EventListenerBase::benchmarkPreparing( StringRef ) {}
-    void EventListenerBase::benchmarkStarting( BenchmarkInfo const& ) {}
-    void EventListenerBase::benchmarkEnded( BenchmarkStats<> const& ) {}
-    void EventListenerBase::benchmarkFailed( StringRef ) {}
-
-    void EventListenerBase::assertionStarting( AssertionInfo const& ) {}
-
-    void EventListenerBase::assertionEnded( AssertionStats const& ) {}
-    void EventListenerBase::listReporters(
-        std::vector<ReporterDescription> const& ) {}
-    void EventListenerBase::listListeners(
-        std::vector<ListenerDescription> const& ) {}
-    void EventListenerBase::listTests( std::vector<TestCaseHandle> const& ) {}
-    void EventListenerBase::listTags( std::vector<TagInfo> const& ) {}
-    void EventListenerBase::noMatchingTestCases( StringRef ) {}
-    void EventListenerBase::reportInvalidTestSpec( StringRef ) {}
-    void EventListenerBase::testRunStarting( TestRunInfo const& ) {}
-    void EventListenerBase::testCaseStarting( TestCaseInfo const& ) {}
-    void EventListenerBase::testCasePartialStarting(TestCaseInfo const&, uint64_t) {}
-    void EventListenerBase::sectionStarting( SectionInfo const& ) {}
-    void EventListenerBase::sectionEnded( SectionStats const& ) {}
-    void EventListenerBase::testCasePartialEnded(TestCaseStats const&, uint64_t) {}
-    void EventListenerBase::testCaseEnded( TestCaseStats const& ) {}
-    void EventListenerBase::testRunEnded( TestRunStats const& ) {}
-    void EventListenerBase::skipTest( TestCaseInfo const& ) {}
-} // namespace Catch
-
-
-
-
-#include <algorithm>
-#include <cfloat>
-#include <cstdio>
-#include <ostream>
-#include <iomanip>
-
-namespace Catch {
-
-    namespace {
-        void listTestNamesOnly(std::ostream& out,
-                               std::vector<TestCaseHandle> const& tests) {
-            for (auto const& test : tests) {
-                auto const& testCaseInfo = test.getTestCaseInfo();
-
-                if (startsWith(testCaseInfo.name, '#')) {
-                    out << '"' << testCaseInfo.name << '"';
-                } else {
-                    out << testCaseInfo.name;
-                }
-
-                out << '\n';
-            }
-            out << std::flush;
-        }
-    } // end unnamed namespace
-
-
-    // Because formatting using c++ streams is stateful, drop down to C is
-    // required Alternatively we could use stringstream, but its performance
-    // is... not good.
-    std::string getFormattedDuration( double duration ) {
-        // Max exponent + 1 is required to represent the whole part
-        // + 1 for decimal point
-        // + 3 for the 3 decimal places
-        // + 1 for null terminator
-        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
-        char buffer[maxDoubleSize];
-
-        // Save previous errno, to prevent sprintf from overwriting it
-        ErrnoGuard guard;
-#ifdef _MSC_VER
-        size_t printedLength = static_cast<size_t>(
-            sprintf_s( buffer, "%.3f", duration ) );
-#else
-        size_t printedLength = static_cast<size_t>(
-            std::snprintf( buffer, maxDoubleSize, "%.3f", duration ) );
-#endif
-        return std::string( buffer, printedLength );
-    }
-
-    bool shouldShowDuration( IConfig const& config, double duration ) {
-        if ( config.showDurations() == ShowDurations::Always ) {
-            return true;
-        }
-        if ( config.showDurations() == ShowDurations::Never ) {
-            return false;
-        }
-        const double min = config.minDuration();
-        return min >= 0 && duration >= min;
-    }
-
-    std::string serializeFilters( std::vector<std::string> const& filters ) {
-        // We add a ' ' separator between each filter
-        size_t serialized_size = filters.size() - 1;
-        for (auto const& filter : filters) {
-            serialized_size += filter.size();
-        }
-
-        std::string serialized;
-        serialized.reserve(serialized_size);
-        bool first = true;
-
-        for (auto const& filter : filters) {
-            if (!first) {
-                serialized.push_back(' ');
-            }
-            first = false;
-            serialized.append(filter);
-        }
-
-        return serialized;
-    }
-
-    std::ostream& operator<<( std::ostream& out, lineOfChars value ) {
-        for ( size_t idx = 0; idx < CATCH_CONFIG_CONSOLE_WIDTH - 1; ++idx ) {
-            out.put( value.c );
-        }
-        return out;
-    }
-
-    void
-    defaultListReporters( std::ostream& out,
-                          std::vector<ReporterDescription> const& descriptions,
-                          Verbosity verbosity ) {
-        out << "Available reporters:\n";
-        const auto maxNameLen =
-            std::max_element( descriptions.begin(),
-                              descriptions.end(),
-                              []( ReporterDescription const& lhs,
-                                  ReporterDescription const& rhs ) {
-                                  return lhs.name.size() < rhs.name.size();
-                              } )
-                ->name.size();
-
-        for ( auto const& desc : descriptions ) {
-            if ( verbosity == Verbosity::Quiet ) {
-                out << TextFlow::Column( desc.name )
-                           .indent( 2 )
-                           .width( 5 + maxNameLen )
-                    << '\n';
-            } else {
-                out << TextFlow::Column( desc.name + ':' )
-                               .indent( 2 )
-                               .width( 5 + maxNameLen ) +
-                           TextFlow::Column( desc.description )
-                               .initialIndent( 0 )
-                               .indent( 2 )
-                               .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 )
-                    << '\n';
-            }
-        }
-        out << '\n' << std::flush;
-    }
-
-    void defaultListListeners( std::ostream& out,
-                               std::vector<ListenerDescription> const& descriptions ) {
-        out << "Registered listeners:\n";
-
-        if(descriptions.empty()) {
-            return;
-        }
-
-        const auto maxNameLen =
-            std::max_element( descriptions.begin(),
-                              descriptions.end(),
-                              []( ListenerDescription const& lhs,
-                                  ListenerDescription const& rhs ) {
-                                  return lhs.name.size() < rhs.name.size();
-                              } )
-                ->name.size();
-
-        for ( auto const& desc : descriptions ) {
-            out << TextFlow::Column( static_cast<std::string>( desc.name ) +
-                                     ':' )
-                           .indent( 2 )
-                           .width( maxNameLen + 5 ) +
-                       TextFlow::Column( desc.description )
-                           .initialIndent( 0 )
-                           .indent( 2 )
-                           .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 )
-                << '\n';
-        }
-
-        out << '\n' << std::flush;
-    }
-
-    void defaultListTags( std::ostream& out,
-                          std::vector<TagInfo> const& tags,
-                          bool isFiltered ) {
-        if ( isFiltered ) {
-            out << "Tags for matching test cases:\n";
-        } else {
-            out << "All available tags:\n";
-        }
-
-        for ( auto const& tagCount : tags ) {
-            ReusableStringStream rss;
-            rss << "  " << std::setw( 2 ) << tagCount.count << "  ";
-            auto str = rss.str();
-            auto wrapper = TextFlow::Column( tagCount.all() )
-                               .initialIndent( 0 )
-                               .indent( str.size() )
-                               .width( CATCH_CONFIG_CONSOLE_WIDTH - 10 );
-            out << str << wrapper << '\n';
-        }
-        out << pluralise(tags.size(), "tag"_sr) << "\n\n" << std::flush;
-    }
-
-    void defaultListTests(std::ostream& out, ColourImpl* streamColour, std::vector<TestCaseHandle> const& tests, bool isFiltered, Verbosity verbosity) {
-        // We special case this to provide the equivalent of old
-        // `--list-test-names-only`, which could then be used by the
-        // `--input-file` option.
-        if (verbosity == Verbosity::Quiet) {
-            listTestNamesOnly(out, tests);
-            return;
-        }
-
-        if (isFiltered) {
-            out << "Matching test cases:\n";
-        } else {
-            out << "All available test cases:\n";
-        }
-
-        for (auto const& test : tests) {
-            auto const& testCaseInfo = test.getTestCaseInfo();
-            Colour::Code colour = testCaseInfo.isHidden()
-                ? Colour::SecondaryText
-                : Colour::None;
-            auto colourGuard = streamColour->guardColour( colour ).engage( out );
-
-            out << TextFlow::Column(testCaseInfo.name).indent(2) << '\n';
-            if (verbosity >= Verbosity::High) {
-                out << TextFlow::Column(Catch::Detail::stringify(testCaseInfo.lineInfo)).indent(4) << '\n';
-            }
-            if (!testCaseInfo.tags.empty() &&
-                verbosity > Verbosity::Quiet) {
-                out << TextFlow::Column(testCaseInfo.tagsAsString()).indent(6) << '\n';
-            }
-        }
-
-        if (isFiltered) {
-            out << pluralise(tests.size(), "matching test case"_sr);
-        } else {
-            out << pluralise(tests.size(), "test case"_sr);
-        }
-        out << "\n\n" << std::flush;
-    }
-
-    namespace {
-        class SummaryColumn {
-        public:
-            SummaryColumn( std::string suffix, Colour::Code colour ):
-                m_suffix( CATCH_MOVE( suffix ) ), m_colour( colour ) {}
-
-            SummaryColumn&& addRow( std::uint64_t count ) && {
-                std::string row = std::to_string(count);
-                auto const new_width = std::max( m_width, row.size() );
-                if ( new_width > m_width ) {
-                    for ( auto& oldRow : m_rows ) {
-                        oldRow.insert( 0, new_width - m_width, ' ' );
-                    }
-                } else {
-                    row.insert( 0, m_width - row.size(), ' ' );
-                }
-                m_width = new_width;
-                m_rows.push_back( row );
-                return std::move( *this );
-            }
-
-            std::string const& getSuffix() const { return m_suffix; }
-            Colour::Code getColour() const { return m_colour; }
-            std::string const& getRow( std::size_t index ) const {
-                return m_rows[index];
-            }
-
-        private:
-            std::string m_suffix;
-            Colour::Code m_colour;
-            std::size_t m_width = 0;
-            std::vector<std::string> m_rows;
-        };
-
-        void printSummaryRow( std::ostream& stream,
-                              ColourImpl& colour,
-                              StringRef label,
-                              std::vector<SummaryColumn> const& cols,
-                              std::size_t row ) {
-            for ( auto const& col : cols ) {
-                auto const& value = col.getRow( row );
-                auto const& suffix = col.getSuffix();
-                if ( suffix.empty() ) {
-                    stream << label << ": ";
-                    if ( value != "0" ) {
-                        stream << value;
-                    } else {
-                        stream << colour.guardColour( Colour::Warning )
-                               << "- none -";
-                    }
-                } else if ( value != "0" ) {
-                    stream << colour.guardColour( Colour::LightGrey ) << " | "
-                           << colour.guardColour( col.getColour() ) << value
-                           << ' ' << suffix;
-                }
-            }
-            stream << '\n';
-        }
-    } // namespace
-
-    void printTestRunTotals( std::ostream& stream,
-                             ColourImpl& streamColour,
-                             Totals const& totals ) {
-        if ( totals.testCases.total() == 0 ) {
-            stream << streamColour.guardColour( Colour::Warning )
-                   << "No tests ran\n";
-            return;
-        }
-
-        if ( totals.assertions.total() > 0 && totals.testCases.allPassed() ) {
-            stream << streamColour.guardColour( Colour::ResultSuccess )
-                   << "All tests passed";
-            stream << " ("
-                   << pluralise( totals.assertions.passed, "assertion"_sr )
-                   << " in "
-                   << pluralise( totals.testCases.passed, "test case"_sr )
-                   << ')' << '\n';
-            return;
-        }
-
-        std::vector<SummaryColumn> columns;
-        // Don't include "skipped assertions" in total count
-        const auto totalAssertionCount =
-            totals.assertions.total() - totals.assertions.skipped;
-        columns.push_back( SummaryColumn( "", Colour::None )
-                               .addRow( totals.testCases.total() )
-                               .addRow( totalAssertionCount ) );
-        columns.push_back( SummaryColumn( "passed", Colour::Success )
-                               .addRow( totals.testCases.passed )
-                               .addRow( totals.assertions.passed ) );
-        columns.push_back( SummaryColumn( "failed", Colour::ResultError )
-                               .addRow( totals.testCases.failed )
-                               .addRow( totals.assertions.failed ) );
-        columns.push_back( SummaryColumn( "skipped", Colour::Skip )
-                               .addRow( totals.testCases.skipped )
-                               // Don't print "skipped assertions"
-                               .addRow( 0 ) );
-        columns.push_back(
-            SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
-                .addRow( totals.testCases.failedButOk )
-                .addRow( totals.assertions.failedButOk ) );
-        printSummaryRow( stream, streamColour, "test cases"_sr, columns, 0 );
-        printSummaryRow( stream, streamColour, "assertions"_sr, columns, 1 );
-    }
-
-} // namespace Catch
-
-
-//
-
-namespace Catch {
-    namespace {
-        void writeSourceInfo( JsonObjectWriter& writer,
-                              SourceLineInfo const& sourceInfo ) {
-            auto source_location_writer =
-                writer.write( "source-location"_sr ).writeObject();
-            source_location_writer.write( "filename"_sr )
-                .write( sourceInfo.file );
-            source_location_writer.write( "line"_sr ).write( sourceInfo.line );
-        }
-
-        void writeTags( JsonArrayWriter writer, std::vector<Tag> const& tags ) {
-            for ( auto const& tag : tags ) {
-                writer.write( tag.original );
-            }
-        }
-
-        void writeProperties( JsonArrayWriter writer,
-                              TestCaseInfo const& info ) {
-            if ( info.isHidden() ) { writer.write( "is-hidden"_sr ); }
-            if ( info.okToFail() ) { writer.write( "ok-to-fail"_sr ); }
-            if ( info.expectedToFail() ) {
-                writer.write( "expected-to-fail"_sr );
-            }
-            if ( info.throws() ) { writer.write( "throws"_sr ); }
-        }
-
-    } // namespace
-
-    JsonReporter::JsonReporter( ReporterConfig&& config ):
-        StreamingReporterBase{ CATCH_MOVE( config ) } {
-
-        m_preferences.shouldRedirectStdOut = true;
-        // TBD: Do we want to report all assertions? XML reporter does
-        //      not, but for machine-parseable reporters I think the answer
-        //      should be yes.
-        m_preferences.shouldReportAllAssertions = true;
-
-        m_objectWriters.emplace( m_stream );
-        m_writers.emplace( Writer::Object );
-        auto& writer = m_objectWriters.top();
-
-        writer.write( "version"_sr ).write( 1 );
-
-        {
-            auto metadata_writer = writer.write( "metadata"_sr ).writeObject();
-            metadata_writer.write( "name"_sr ).write( m_config->name() );
-            metadata_writer.write( "rng-seed"_sr ).write( m_config->rngSeed() );
-            metadata_writer.write( "catch2-version"_sr )
-                .write( libraryVersion() );
-            if ( m_config->testSpec().hasFilters() ) {
-                metadata_writer.write( "filters"_sr )
-                    .write( m_config->testSpec() );
-            }
-        }
-    }
-
-    JsonReporter::~JsonReporter() {
-        endListing();
-        // TODO: Ensure this closes the top level object, add asserts
-        assert( m_writers.size() == 1 && "Only the top level object should be open" );
-        assert( m_writers.top() == Writer::Object );
-        endObject();
-        m_stream << '\n' << std::flush;
-        assert( m_writers.empty() );
-    }
-
-    JsonArrayWriter& JsonReporter::startArray() {
-        m_arrayWriters.emplace( m_arrayWriters.top().writeArray() );
-        m_writers.emplace( Writer::Array );
-        return m_arrayWriters.top();
-    }
-    JsonArrayWriter& JsonReporter::startArray( StringRef key ) {
-        m_arrayWriters.emplace(
-            m_objectWriters.top().write( key ).writeArray() );
-        m_writers.emplace( Writer::Array );
-        return m_arrayWriters.top();
-    }
-
-    JsonObjectWriter& JsonReporter::startObject() {
-        m_objectWriters.emplace( m_arrayWriters.top().writeObject() );
-        m_writers.emplace( Writer::Object );
-        return m_objectWriters.top();
-    }
-    JsonObjectWriter& JsonReporter::startObject( StringRef key ) {
-        m_objectWriters.emplace(
-            m_objectWriters.top().write( key ).writeObject() );
-        m_writers.emplace( Writer::Object );
-        return m_objectWriters.top();
-    }
-
-    void JsonReporter::endObject() {
-        assert( isInside( Writer::Object ) );
-        m_objectWriters.pop();
-        m_writers.pop();
-    }
-    void JsonReporter::endArray() {
-        assert( isInside( Writer::Array ) );
-        m_arrayWriters.pop();
-        m_writers.pop();
-    }
-
-    bool JsonReporter::isInside( Writer writer ) {
-        return !m_writers.empty() && m_writers.top() == writer;
-    }
-
-    void JsonReporter::startListing() {
-        if ( !m_startedListing ) { startObject( "listings"_sr ); }
-        m_startedListing = true;
-    }
-    void JsonReporter::endListing() {
-        if ( m_startedListing ) { endObject(); }
-        m_startedListing = false;
-    }
-
-    std::string JsonReporter::getDescription() {
-        return "Outputs listings as JSON. Test listing is Work-in-Progress!";
-    }
-
-    void JsonReporter::testRunStarting( TestRunInfo const& runInfo ) {
-        StreamingReporterBase::testRunStarting( runInfo );
-        endListing();
-
-        assert( isInside( Writer::Object ) );
-        startObject( "test-run"_sr );
-        startArray( "test-cases"_sr );
-    }
-
-     static void writeCounts( JsonObjectWriter&& writer, Counts const& counts ) {
-        writer.write( "passed"_sr ).write( counts.passed );
-        writer.write( "failed"_sr ).write( counts.failed );
-        writer.write( "fail-but-ok"_sr ).write( counts.failedButOk );
-        writer.write( "skipped"_sr ).write( counts.skipped );
-    }
-
-    void JsonReporter::testRunEnded(TestRunStats const& runStats) {
-        assert( isInside( Writer::Array ) );
-        // End "test-cases"
-        endArray();
-
-        {
-            auto totals =
-                m_objectWriters.top().write( "totals"_sr ).writeObject();
-            writeCounts( totals.write( "assertions"_sr ).writeObject(),
-                         runStats.totals.assertions );
-            writeCounts( totals.write( "test-cases"_sr ).writeObject(),
-                         runStats.totals.testCases );
-        }
-
-        // End the "test-run" object
-        endObject();
-    }
-
-    void JsonReporter::testCaseStarting( TestCaseInfo const& tcInfo ) {
-        StreamingReporterBase::testCaseStarting( tcInfo );
-
-        assert( isInside( Writer::Array ) &&
-                "We should be in the 'test-cases' array" );
-        startObject();
-        // "test-info" prelude
-        {
-            auto testInfo =
-                m_objectWriters.top().write( "test-info"_sr ).writeObject();
-            // TODO: handle testName vs className!!
-            testInfo.write( "name"_sr ).write( tcInfo.name );
-            writeSourceInfo(testInfo, tcInfo.lineInfo);
-            writeTags( testInfo.write( "tags"_sr ).writeArray(), tcInfo.tags );
-            writeProperties( testInfo.write( "properties"_sr ).writeArray(),
-                             tcInfo );
-        }
-
-
-        // Start the array for individual test runs (testCasePartial pairs)
-        startArray( "runs"_sr );
-    }
-
-    void JsonReporter::testCaseEnded( TestCaseStats const& tcStats ) {
-        StreamingReporterBase::testCaseEnded( tcStats );
-
-        // We need to close the 'runs' array before finishing the test case
-        assert( isInside( Writer::Array ) );
-        endArray();
-
-        {
-            auto totals =
-                m_objectWriters.top().write( "totals"_sr ).writeObject();
-            writeCounts( totals.write( "assertions"_sr ).writeObject(),
-                         tcStats.totals.assertions );
-            // We do not write the test case totals, because there will always be just one test case here.
-            // TODO: overall "result" -> success, skip, fail here? Or in partial result?
-        }
-        // We do not write out stderr/stdout, because we instead wrote those out in partial runs
-
-        // TODO: aborting?
-
-        // And we also close this test case's object
-        assert( isInside( Writer::Object ) );
-        endObject();
-    }
-
-    void JsonReporter::testCasePartialStarting( TestCaseInfo const& /*tcInfo*/,
-                                                uint64_t index ) {
-        startObject();
-        m_objectWriters.top().write( "run-idx"_sr ).write( index );
-        startArray( "path"_sr );
-        // TODO: we want to delay most of the printing to the 'root' section
-        // TODO: childSection key name?
-    }
-
-    void JsonReporter::testCasePartialEnded( TestCaseStats const& tcStats,
-                                             uint64_t /*index*/ ) {
-        // Fixme: the top level section handles this.
-        //// path object
-        endArray();
-        if ( !tcStats.stdOut.empty() ) {
-            m_objectWriters.top()
-                .write( "captured-stdout"_sr )
-                .write( tcStats.stdOut );
-        }
-        if ( !tcStats.stdErr.empty() ) {
-            m_objectWriters.top()
-                .write( "captured-stderr"_sr )
-                .write( tcStats.stdErr );
-        }
-        {
-            auto totals =
-                m_objectWriters.top().write( "totals"_sr ).writeObject();
-            writeCounts( totals.write( "assertions"_sr ).writeObject(),
-                         tcStats.totals.assertions );
-            // We do not write the test case totals, because there will
-            // always be just one test case here.
-            // TODO: overall "result" -> success, skip, fail here? Or in
-            // partial result?
-        }
-        // TODO: aborting?
-        // run object
-        endObject();
-    }
-
-    void JsonReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        assert( isInside( Writer::Array ) &&
-                "Section should always start inside an object" );
-        // We want to nest top level sections, even though it shares name
-        // and source loc with the TEST_CASE
-        auto& sectionObject = startObject();
-        sectionObject.write( "kind"_sr ).write( "section"_sr );
-        sectionObject.write( "name"_sr ).write( sectionInfo.name );
-        writeSourceInfo( m_objectWriters.top(), sectionInfo.lineInfo );
-
-
-        // TBD: Do we want to create this event lazily? It would become
-        //      rather complex, but we could do it, and it would look
-        //      better for empty sections. OTOH, empty sections should
-        //      be rare.
-        startArray( "path"_sr );
-    }
-    void JsonReporter::sectionEnded( SectionStats const& /*sectionStats */) {
-        // End the subpath array
-        endArray();
-        // TODO: metadata
-        // TODO: what info do we have here?
-
-        // End the section object
-        endObject();
-    }
-
-    void JsonReporter::assertionStarting( AssertionInfo const& /*assertionInfo*/ ) {}
-    void JsonReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        // TODO: There is lot of different things to handle here, but
-        //       we can fill it in later, after we show that the basic
-        //       outline and streaming reporter impl works well enough.
-        //if ( !m_config->includeSuccessfulResults()
-        //    && assertionStats.assertionResult.isOk() ) {
-        //    return;
-        //}
-        assert( isInside( Writer::Array ) );
-        auto assertionObject = m_arrayWriters.top().writeObject();
-
-        assertionObject.write( "kind"_sr ).write( "assertion"_sr );
-        writeSourceInfo( assertionObject,
-                         assertionStats.assertionResult.getSourceInfo() );
-        assertionObject.write( "status"_sr )
-            .write( assertionStats.assertionResult.isOk() );
-        // TODO: handling of result.
-        // TODO: messages
-        // TODO: totals?
-    }
-
-
-    void JsonReporter::benchmarkPreparing( StringRef name ) { (void)name; }
-    void JsonReporter::benchmarkStarting( BenchmarkInfo const& ) {}
-    void JsonReporter::benchmarkEnded( BenchmarkStats<> const& ) {}
-    void JsonReporter::benchmarkFailed( StringRef error ) { (void)error; }
-
-    void JsonReporter::listReporters(
-        std::vector<ReporterDescription> const& descriptions ) {
-        startListing();
-
-        auto writer =
-            m_objectWriters.top().write( "reporters"_sr ).writeArray();
-        for ( auto const& desc : descriptions ) {
-            auto desc_writer = writer.writeObject();
-            desc_writer.write( "name"_sr ).write( desc.name );
-            desc_writer.write( "description"_sr ).write( desc.description );
-        }
-    }
-    void JsonReporter::listListeners(
-        std::vector<ListenerDescription> const& descriptions ) {
-        startListing();
-
-        auto writer =
-            m_objectWriters.top().write( "listeners"_sr ).writeArray();
-
-        for ( auto const& desc : descriptions ) {
-            auto desc_writer = writer.writeObject();
-            desc_writer.write( "name"_sr ).write( desc.name );
-            desc_writer.write( "description"_sr ).write( desc.description );
-        }
-    }
-    void JsonReporter::listTests( std::vector<TestCaseHandle> const& tests ) {
-        startListing();
-
-        auto writer = m_objectWriters.top().write( "tests"_sr ).writeArray();
-
-        for ( auto const& test : tests ) {
-            auto desc_writer = writer.writeObject();
-            auto const& info = test.getTestCaseInfo();
-
-            desc_writer.write( "name"_sr ).write( info.name );
-            desc_writer.write( "class-name"_sr ).write( info.className );
-            {
-                auto tag_writer = desc_writer.write( "tags"_sr ).writeArray();
-                for ( auto const& tag : info.tags ) {
-                    tag_writer.write( tag.original );
-                }
-            }
-            writeSourceInfo( desc_writer, info.lineInfo );
-        }
-    }
-    void JsonReporter::listTags( std::vector<TagInfo> const& tags ) {
-        startListing();
-
-        auto writer = m_objectWriters.top().write( "tags"_sr ).writeArray();
-        for ( auto const& tag : tags ) {
-            auto tag_writer = writer.writeObject();
-            {
-                auto aliases_writer =
-                    tag_writer.write( "aliases"_sr ).writeArray();
-                for ( auto alias : tag.spellings ) {
-                    aliases_writer.write( alias );
-                }
-            }
-            tag_writer.write( "count"_sr ).write( tag.count );
-        }
-    }
-} // namespace Catch
-
-
-
-
-#include <cassert>
-#include <ctime>
-#include <algorithm>
-#include <iomanip>
-
-namespace Catch {
-
-    namespace {
-        std::string getCurrentTimestamp() {
-            time_t rawtime;
-            std::time(&rawtime);
-
-            std::tm timeInfo = {};
-#if defined (_MSC_VER) || defined (__MINGW32__)
-            gmtime_s(&timeInfo, &rawtime);
-#elif defined (CATCH_PLATFORM_PLAYSTATION)
-            gmtime_s(&rawtime, &timeInfo);
-#elif defined (__IAR_SYSTEMS_ICC__)
-            timeInfo = *std::gmtime(&rawtime);
-#else
-            gmtime_r(&rawtime, &timeInfo);
-#endif
-
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
-
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-
-            return std::string(timeStamp, timeStampSize - 1);
-        }
-
-        std::string fileNameTag(std::vector<Tag> const& tags) {
-            auto it = std::find_if(begin(tags),
-                                   end(tags),
-                                   [] (Tag const& tag) {
-                                       return tag.original.size() > 0
-                                           && tag.original[0] == '#'; });
-            if (it != tags.end()) {
-                return static_cast<std::string>(
-                    it->original.substr(1, it->original.size() - 1)
-                );
-            }
-            return std::string();
-        }
-
-        // Formats the duration in seconds to 3 decimal places.
-        // This is done because some genius defined Maven Surefire schema
-        // in a way that only accepts 3 decimal places, and tools like
-        // Jenkins use that schema for validation JUnit reporter output.
-        std::string formatDuration( double seconds ) {
-            ReusableStringStream rss;
-            rss << std::fixed << std::setprecision( 3 ) << seconds;
-            return rss.str();
-        }
-
-        static void normalizeNamespaceMarkers(std::string& str) {
-            std::size_t pos = str.find( "::" );
-            while ( pos != std::string::npos ) {
-                str.replace( pos, 2, "." );
-                pos += 1;
-                pos = str.find( "::", pos );
-            }
-        }
-
-    } // anonymous namespace
-
-    JunitReporter::JunitReporter( ReporterConfig&& _config )
-        :   CumulativeReporterBase( CATCH_MOVE(_config) ),
-            xml( m_stream )
-        {
-            m_preferences.shouldRedirectStdOut = true;
-            m_preferences.shouldReportAllAssertions = false;
-            m_shouldStoreSuccesfulAssertions = false;
-        }
-
-    std::string JunitReporter::getDescription() {
-        return "Reports test results in an XML format that looks like Ant's junitreport target";
-    }
-
-    void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
-        CumulativeReporterBase::testRunStarting( runInfo );
-        xml.startElement( "testsuites" );
-        suiteTimer.start();
-        stdOutForSuite.clear();
-        stdErrForSuite.clear();
-        unexpectedExceptions = 0;
-    }
-
-    void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
-        m_okToFail = testCaseInfo.okToFail();
-    }
-
-    void JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
-            unexpectedExceptions++;
-        CumulativeReporterBase::assertionEnded( assertionStats );
-    }
-
-    void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        stdOutForSuite += testCaseStats.stdOut;
-        stdErrForSuite += testCaseStats.stdErr;
-        CumulativeReporterBase::testCaseEnded( testCaseStats );
-    }
-
-    void JunitReporter::testRunEndedCumulative() {
-        const auto suiteTime = suiteTimer.getElapsedSeconds();
-        writeRun( *m_testRun, suiteTime );
-        xml.endElement();
-    }
-
-    void JunitReporter::writeRun( TestRunNode const& testRunNode, double suiteTime ) {
-        XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
-
-        TestRunStats const& stats = testRunNode.value;
-        xml.writeAttribute( "name"_sr, stats.runInfo.name );
-        xml.writeAttribute( "errors"_sr, unexpectedExceptions );
-        xml.writeAttribute( "failures"_sr, stats.totals.assertions.failed-unexpectedExceptions );
-        xml.writeAttribute( "skipped"_sr, stats.totals.assertions.skipped );
-        xml.writeAttribute( "tests"_sr, stats.totals.assertions.total() );
-        xml.writeAttribute( "hostname"_sr, "tbd"_sr ); // !TBD
-        if( m_config->showDurations() == ShowDurations::Never )
-            xml.writeAttribute( "time"_sr, ""_sr );
-        else
-            xml.writeAttribute( "time"_sr, formatDuration( suiteTime ) );
-        xml.writeAttribute( "timestamp"_sr, getCurrentTimestamp() );
-
-        // Write properties
-        {
-            auto properties = xml.scopedElement("properties");
-            xml.scopedElement("property")
-                .writeAttribute("name"_sr, "random-seed"_sr)
-                .writeAttribute("value"_sr, m_config->rngSeed());
-            if (m_config->testSpec().hasFilters()) {
-                xml.scopedElement("property")
-                    .writeAttribute("name"_sr, "filters"_sr)
-                    .writeAttribute("value"_sr, m_config->testSpec());
-            }
-        }
-
-        // Write test cases
-        for( auto const& child : testRunNode.children )
-            writeTestCase( *child );
-
-        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
-        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
-    }
-
-    void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
-        TestCaseStats const& stats = testCaseNode.value;
-
-        // All test cases have exactly one section - which represents the
-        // test case itself. That section may have 0-n nested sections
-        assert( testCaseNode.children.size() == 1 );
-        SectionNode const& rootSection = *testCaseNode.children.front();
-
-        std::string className =
-            static_cast<std::string>( stats.testInfo->className );
-
-        if( className.empty() ) {
-            className = fileNameTag(stats.testInfo->tags);
-            if ( className.empty() ) {
-                className = "global";
-            }
-        }
-
-        if ( !m_config->name().empty() )
-            className = static_cast<std::string>(m_config->name()) + '.' + className;
-
-        normalizeNamespaceMarkers(className);
-
-        writeSection( className, "", rootSection, stats.testInfo->okToFail() );
-    }
-
-    void JunitReporter::writeSection( std::string const& className,
-                                      std::string const& rootName,
-                                      SectionNode const& sectionNode,
-                                      bool testOkToFail) {
-        std::string name = trim( sectionNode.stats.sectionInfo.name );
-        if( !rootName.empty() )
-            name = rootName + '/' + name;
-
-        if ( sectionNode.stats.assertions.total() > 0
-           || !sectionNode.stdOut.empty()
-           || !sectionNode.stdErr.empty() ) {
-            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
-            if( className.empty() ) {
-                xml.writeAttribute( "classname"_sr, name );
-                xml.writeAttribute( "name"_sr, "root"_sr );
-            }
-            else {
-                xml.writeAttribute( "classname"_sr, className );
-                xml.writeAttribute( "name"_sr, name );
-            }
-            xml.writeAttribute( "time"_sr, formatDuration( sectionNode.stats.durationInSeconds ) );
-            // This is not ideal, but it should be enough to mimic gtest's
-            // junit output.
-            // Ideally the JUnit reporter would also handle `skipTest`
-            // events and write those out appropriately.
-            xml.writeAttribute( "status"_sr, "run"_sr );
-
-            if (sectionNode.stats.assertions.failedButOk) {
-                xml.scopedElement("skipped")
-                    .writeAttribute("message", "TEST_CASE tagged with !mayfail");
-            }
-
-            writeAssertions( sectionNode );
-
-
-            if( !sectionNode.stdOut.empty() )
-                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
-            if( !sectionNode.stdErr.empty() )
-                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
-        }
-        for( auto const& childNode : sectionNode.childSections )
-            if( className.empty() )
-                writeSection( name, "", *childNode, testOkToFail );
-            else
-                writeSection( className, name, *childNode, testOkToFail );
-    }
-
-    void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
-        for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) {
-            if (assertionOrBenchmark.isAssertion()) {
-                writeAssertion(assertionOrBenchmark.asAssertion());
-            }
-        }
-    }
-
-    void JunitReporter::writeAssertion( AssertionStats const& stats ) {
-        AssertionResult const& result = stats.assertionResult;
-        if ( !result.isOk() ||
-             result.getResultType() == ResultWas::ExplicitSkip ) {
-            std::string elementName;
-            switch( result.getResultType() ) {
-                case ResultWas::ThrewException:
-                case ResultWas::FatalErrorCondition:
-                    elementName = "error";
-                    break;
-                case ResultWas::ExplicitFailure:
-                case ResultWas::ExpressionFailed:
-                case ResultWas::DidntThrowException:
-                    elementName = "failure";
-                    break;
-                case ResultWas::ExplicitSkip:
-                    elementName = "skipped";
-                    break;
-                // We should never see these here:
-                case ResultWas::Info:
-                case ResultWas::Warning:
-                case ResultWas::Ok:
-                case ResultWas::Unknown:
-                case ResultWas::FailureBit:
-                case ResultWas::Exception:
-                    elementName = "internalError";
-                    break;
-            }
-
-            XmlWriter::ScopedElement e = xml.scopedElement( elementName );
-
-            xml.writeAttribute( "message"_sr, result.getExpression() );
-            xml.writeAttribute( "type"_sr, result.getTestMacroName() );
-
-            ReusableStringStream rss;
-            if ( result.getResultType() == ResultWas::ExplicitSkip ) {
-                rss << "SKIPPED\n";
-            } else {
-                rss << "FAILED" << ":\n";
-                if (result.hasExpression()) {
-                    rss << "  ";
-                    rss << result.getExpressionInMacro();
-                    rss << '\n';
-                }
-                if (result.hasExpandedExpression()) {
-                    rss << "with expansion:\n";
-                    rss << TextFlow::Column(result.getExpandedExpression()).indent(2) << '\n';
-                }
-            }
-
-            if( result.hasMessage() )
-                rss << result.getMessage() << '\n';
-            for( auto const& msg : stats.infoMessages )
-                if( msg.type == ResultWas::Info )
-                    rss << msg.message << '\n';
-
-            rss << "at " << result.getSourceInfo();
-            xml.writeText( rss.str(), XmlFormatting::Newline );
-        }
-    }
-
-} // end namespace Catch
-
-
-
-
-#include <ostream>
-
-namespace Catch {
-    void MultiReporter::updatePreferences(IEventListener const& reporterish) {
-        m_preferences.shouldRedirectStdOut |=
-            reporterish.getPreferences().shouldRedirectStdOut;
-        m_preferences.shouldReportAllAssertions |=
-            reporterish.getPreferences().shouldReportAllAssertions;
-    }
-
-    void MultiReporter::addListener( IEventListenerPtr&& listener ) {
-        updatePreferences(*listener);
-        m_reporterLikes.insert(m_reporterLikes.begin() + m_insertedListeners, CATCH_MOVE(listener) );
-        ++m_insertedListeners;
-    }
-
-    void MultiReporter::addReporter( IEventListenerPtr&& reporter ) {
-        updatePreferences(*reporter);
-
-        // We will need to output the captured stdout if there are reporters
-        // that do not want it captured.
-        // We do not consider listeners, because it is generally assumed that
-        // listeners are output-transparent, even though they can ask for stdout
-        // capture to do something with it.
-        m_haveNoncapturingReporters |= !reporter->getPreferences().shouldRedirectStdOut;
-
-        // Reporters can always be placed to the back without breaking the
-        // reporting order
-        m_reporterLikes.push_back( CATCH_MOVE( reporter ) );
-    }
-
-    void MultiReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->noMatchingTestCases( unmatchedSpec );
-        }
-    }
-
-    void MultiReporter::fatalErrorEncountered( StringRef error ) {
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->fatalErrorEncountered( error );
-        }
-    }
-
-    void MultiReporter::reportInvalidTestSpec( StringRef arg ) {
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->reportInvalidTestSpec( arg );
-        }
-    }
-
-    void MultiReporter::benchmarkPreparing( StringRef name ) {
-        for (auto& reporterish : m_reporterLikes) {
-            reporterish->benchmarkPreparing(name);
-        }
-    }
-    void MultiReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->benchmarkStarting( benchmarkInfo );
-        }
-    }
-    void MultiReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->benchmarkEnded( benchmarkStats );
-        }
-    }
-
-    void MultiReporter::benchmarkFailed( StringRef error ) {
-        for (auto& reporterish : m_reporterLikes) {
-            reporterish->benchmarkFailed(error);
-        }
-    }
-
-    void MultiReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->testRunStarting( testRunInfo );
-        }
-    }
-
-    void MultiReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->testCaseStarting( testInfo );
-        }
-    }
-
-    void
-    MultiReporter::testCasePartialStarting( TestCaseInfo const& testInfo,
-                                                uint64_t partNumber ) {
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->testCasePartialStarting( testInfo, partNumber );
-        }
-    }
-
-    void MultiReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->sectionStarting( sectionInfo );
-        }
-    }
-
-    void MultiReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->assertionStarting( assertionInfo );
-        }
-    }
-
-    void MultiReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        const bool reportByDefault =
-            assertionStats.assertionResult.getResultType() != ResultWas::Ok ||
-            m_config->includeSuccessfulResults();
-
-        for ( auto & reporterish : m_reporterLikes ) {
-            if ( reportByDefault ||
-                 reporterish->getPreferences().shouldReportAllAssertions ) {
-                    reporterish->assertionEnded( assertionStats );
-            }
-        }
-    }
-
-    void MultiReporter::sectionEnded( SectionStats const& sectionStats ) {
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->sectionEnded( sectionStats );
-        }
-    }
-
-    void MultiReporter::testCasePartialEnded( TestCaseStats const& testStats,
-                                                  uint64_t partNumber ) {
-        if ( m_preferences.shouldRedirectStdOut &&
-             m_haveNoncapturingReporters ) {
-            if ( !testStats.stdOut.empty() ) {
-                Catch::cout() << testStats.stdOut << std::flush;
-            }
-            if ( !testStats.stdErr.empty() ) {
-                Catch::cerr() << testStats.stdErr << std::flush;
-            }
-        }
-
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->testCasePartialEnded( testStats, partNumber );
-        }
-    }
-
-    void MultiReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->testCaseEnded( testCaseStats );
-        }
-    }
-
-    void MultiReporter::testRunEnded( TestRunStats const& testRunStats ) {
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->testRunEnded( testRunStats );
-        }
-    }
-
-
-    void MultiReporter::skipTest( TestCaseInfo const& testInfo ) {
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->skipTest( testInfo );
-        }
-    }
-
-    void MultiReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
-        for (auto& reporterish : m_reporterLikes) {
-            reporterish->listReporters(descriptions);
-        }
-    }
-
-    void MultiReporter::listListeners(
-        std::vector<ListenerDescription> const& descriptions ) {
-        for ( auto& reporterish : m_reporterLikes ) {
-            reporterish->listListeners( descriptions );
-        }
-    }
-
-    void MultiReporter::listTests(std::vector<TestCaseHandle> const& tests) {
-        for (auto& reporterish : m_reporterLikes) {
-            reporterish->listTests(tests);
-        }
-    }
-
-    void MultiReporter::listTags(std::vector<TagInfo> const& tags) {
-        for (auto& reporterish : m_reporterLikes) {
-            reporterish->listTags(tags);
-        }
-    }
-
-} // end namespace Catch
-
-
-
-
-
-namespace Catch {
-    namespace Detail {
-
-        void registerReporterImpl( std::string const& name,
-                                   IReporterFactoryPtr reporterPtr ) {
-            CATCH_TRY {
-                getMutableRegistryHub().registerReporter(
-                    name, CATCH_MOVE( reporterPtr ) );
-            }
-            CATCH_CATCH_ALL {
-                // Do not throw when constructing global objects, instead
-                // register the exception to be processed later
-                getMutableRegistryHub().registerStartupException();
-            }
-        }
-
-        void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory ) {
-            getMutableRegistryHub().registerListener( CATCH_MOVE(listenerFactory) );
-        }
-
-
-    } // namespace Detail
-} // namespace Catch
-
-
-
-
-#include <map>
-
-namespace Catch {
-
-    namespace {
-        std::string createMetadataString(IConfig const& config) {
-            ReusableStringStream sstr;
-            if ( config.testSpec().hasFilters() ) {
-                sstr << "filters='"
-                         << config.testSpec()
-                         << "' ";
-            }
-            sstr << "rng-seed=" << config.rngSeed();
-            return sstr.str();
-        }
-    }
-
-    void SonarQubeReporter::testRunStarting(TestRunInfo const& testRunInfo) {
-        CumulativeReporterBase::testRunStarting(testRunInfo);
-
-        xml.writeComment( createMetadataString( *m_config ) );
-        xml.startElement("testExecutions");
-        xml.writeAttribute("version"_sr, '1');
-    }
-
-    void SonarQubeReporter::writeRun( TestRunNode const& runNode ) {
-        std::map<StringRef, std::vector<TestCaseNode const*>> testsPerFile;
-
-        for ( auto const& child : runNode.children ) {
-            testsPerFile[child->value.testInfo->lineInfo.file].push_back(
-                child.get() );
-        }
-
-        for ( auto const& kv : testsPerFile ) {
-            writeTestFile( kv.first, kv.second );
-        }
-    }
-
-    void SonarQubeReporter::writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes) {
-        XmlWriter::ScopedElement e = xml.scopedElement("file");
-        xml.writeAttribute("path"_sr, filename);
-
-        for (auto const& child : testCaseNodes)
-            writeTestCase(*child);
-    }
-
-    void SonarQubeReporter::writeTestCase(TestCaseNode const& testCaseNode) {
-        // All test cases have exactly one section - which represents the
-        // test case itself. That section may have 0-n nested sections
-        assert(testCaseNode.children.size() == 1);
-        SectionNode const& rootSection = *testCaseNode.children.front();
-        writeSection("", rootSection, testCaseNode.value.testInfo->okToFail());
-    }
-
-    void SonarQubeReporter::writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
-        std::string name = trim(sectionNode.stats.sectionInfo.name);
-        if (!rootName.empty())
-            name = rootName + '/' + name;
-
-        if ( sectionNode.stats.assertions.total() > 0
-            || !sectionNode.stdOut.empty()
-            || !sectionNode.stdErr.empty() ) {
-            XmlWriter::ScopedElement e = xml.scopedElement("testCase");
-            xml.writeAttribute("name"_sr, name);
-            xml.writeAttribute("duration"_sr, static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
-
-            writeAssertions(sectionNode, okToFail);
-        }
-
-        for (auto const& childNode : sectionNode.childSections)
-            writeSection(name, *childNode, okToFail);
-    }
-
-    void SonarQubeReporter::writeAssertions(SectionNode const& sectionNode, bool okToFail) {
-        for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) {
-            if (assertionOrBenchmark.isAssertion()) {
-                writeAssertion(assertionOrBenchmark.asAssertion(), okToFail);
-            }
-        }
-    }
-
-    void SonarQubeReporter::writeAssertion(AssertionStats const& stats, bool okToFail) {
-        AssertionResult const& result = stats.assertionResult;
-        if ( !result.isOk() ||
-             result.getResultType() == ResultWas::ExplicitSkip ) {
-            std::string elementName;
-            if (okToFail) {
-                elementName = "skipped";
-            } else {
-                switch (result.getResultType()) {
-                case ResultWas::ThrewException:
-                case ResultWas::FatalErrorCondition:
-                    elementName = "error";
-                    break;
-                case ResultWas::ExplicitFailure:
-                case ResultWas::ExpressionFailed:
-                case ResultWas::DidntThrowException:
-                    elementName = "failure";
-                    break;
-                case ResultWas::ExplicitSkip:
-                    elementName = "skipped";
-                    break;
-                    // We should never see these here:
-                case ResultWas::Info:
-                case ResultWas::Warning:
-                case ResultWas::Ok:
-                case ResultWas::Unknown:
-                case ResultWas::FailureBit:
-                case ResultWas::Exception:
-                    elementName = "internalError";
-                    break;
-                }
-            }
-
-            XmlWriter::ScopedElement e = xml.scopedElement(elementName);
-
-            ReusableStringStream messageRss;
-            messageRss << result.getTestMacroName() << '(' << result.getExpression() << ')';
-            xml.writeAttribute("message"_sr, messageRss.str());
-
-            ReusableStringStream textRss;
-            if ( result.getResultType() == ResultWas::ExplicitSkip ) {
-                textRss << "SKIPPED\n";
-            } else {
-                textRss << "FAILED:\n";
-                if (result.hasExpression()) {
-                    textRss << '\t' << result.getExpressionInMacro() << '\n';
-                }
-                if (result.hasExpandedExpression()) {
-                    textRss << "with expansion:\n\t" << result.getExpandedExpression() << '\n';
-                }
-            }
-
-            if (result.hasMessage())
-                textRss << result.getMessage() << '\n';
-
-            for (auto const& msg : stats.infoMessages)
-                if (msg.type == ResultWas::Info)
-                    textRss << msg.message << '\n';
-
-            textRss << "at " << result.getSourceInfo();
-            xml.writeText(textRss.str(), XmlFormatting::Newline);
-        }
-    }
-
-} // end namespace Catch
-
-
-
-namespace Catch {
-
-    StreamingReporterBase::~StreamingReporterBase() = default;
-
-    void
-    StreamingReporterBase::testRunStarting( TestRunInfo const& _testRunInfo ) {
-        currentTestRunInfo = _testRunInfo;
-    }
-
-    void StreamingReporterBase::testRunEnded( TestRunStats const& ) {
-        currentTestCaseInfo = nullptr;
-    }
-
-} // end namespace Catch
-
-
-
-#include <algorithm>
-#include <ostream>
-
-namespace Catch {
-
-    namespace {
-        // Yes, this has to be outside the class and namespaced by naming.
-        // Making older compiler happy is hard.
-        static constexpr StringRef tapFailedString = "not ok"_sr;
-        static constexpr StringRef tapPassedString = "ok"_sr;
-        static constexpr Colour::Code tapDimColour = Colour::FileName;
-
-        class TapAssertionPrinter {
-        public:
-            TapAssertionPrinter& operator= (TapAssertionPrinter const&) = delete;
-            TapAssertionPrinter(TapAssertionPrinter const&) = delete;
-            TapAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter, ColourImpl* colour_)
-                : stream(_stream)
-                , result(_stats.assertionResult)
-                , messages(_stats.infoMessages)
-                , itMessage(_stats.infoMessages.begin())
-                , printInfoMessages(true)
-                , counter(_counter)
-                , colourImpl( colour_ ) {}
-
-            void print() {
-                itMessage = messages.begin();
-
-                switch (result.getResultType()) {
-                case ResultWas::Ok:
-                    printResultType(tapPassedString);
-                    printOriginalExpression();
-                    printReconstructedExpression();
-                    if (!result.hasExpression())
-                        printRemainingMessages(Colour::None);
-                    else
-                        printRemainingMessages();
-                    break;
-                case ResultWas::ExpressionFailed:
-                    if (result.isOk()) {
-                        printResultType(tapPassedString);
-                    } else {
-                        printResultType(tapFailedString);
-                    }
-                    printOriginalExpression();
-                    printReconstructedExpression();
-                    if (result.isOk()) {
-                        printIssue(" # TODO");
-                    }
-                    printRemainingMessages();
-                    break;
-                case ResultWas::ThrewException:
-                    printResultType(tapFailedString);
-                    printIssue("unexpected exception with message:"_sr);
-                    printMessage();
-                    printExpressionWas();
-                    printRemainingMessages();
-                    break;
-                case ResultWas::FatalErrorCondition:
-                    printResultType(tapFailedString);
-                    printIssue("fatal error condition with message:"_sr);
-                    printMessage();
-                    printExpressionWas();
-                    printRemainingMessages();
-                    break;
-                case ResultWas::DidntThrowException:
-                    printResultType(tapFailedString);
-                    printIssue("expected exception, got none"_sr);
-                    printExpressionWas();
-                    printRemainingMessages();
-                    break;
-                case ResultWas::Info:
-                    printResultType("info"_sr);
-                    printMessage();
-                    printRemainingMessages();
-                    break;
-                case ResultWas::Warning:
-                    printResultType("warning"_sr);
-                    printMessage();
-                    printRemainingMessages();
-                    break;
-                case ResultWas::ExplicitFailure:
-                    printResultType(tapFailedString);
-                    printIssue("explicitly"_sr);
-                    printRemainingMessages(Colour::None);
-                    break;
-                case ResultWas::ExplicitSkip:
-                    printResultType(tapPassedString);
-                    printIssue(" # SKIP"_sr);
-                    printMessage();
-                    printRemainingMessages();
-                    break;
-                    // These cases are here to prevent compiler warnings
-                case ResultWas::Unknown:
-                case ResultWas::FailureBit:
-                case ResultWas::Exception:
-                    printResultType("** internal error **"_sr);
-                    break;
-                }
-            }
-
-        private:
-            void printResultType(StringRef passOrFail) const {
-                if (!passOrFail.empty()) {
-                    stream << passOrFail << ' ' << counter << " -";
-                }
-            }
-
-            void printIssue(StringRef issue) const {
-                stream << ' ' << issue;
-            }
-
-            void printExpressionWas() {
-                if (result.hasExpression()) {
-                    stream << ';';
-                    stream << colourImpl->guardColour( tapDimColour )
-                           << " expression was:";
-                    printOriginalExpression();
-                }
-            }
-
-            void printOriginalExpression() const {
-                if (result.hasExpression()) {
-                    stream << ' ' << result.getExpression();
-                }
-            }
-
-            void printReconstructedExpression() const {
-                if (result.hasExpandedExpression()) {
-                    stream << colourImpl->guardColour( tapDimColour ) << " for: ";
-
-                    std::string expr = result.getExpandedExpression();
-                    std::replace(expr.begin(), expr.end(), '\n', ' ');
-                    stream << expr;
-                }
-            }
-
-            void printMessage() {
-                if (itMessage != messages.end()) {
-                    stream << " '" << itMessage->message << '\'';
-                    ++itMessage;
-                }
-            }
-
-            void printRemainingMessages(Colour::Code colour = tapDimColour) {
-                if (itMessage == messages.end()) {
-                    return;
-                }
-
-                // using messages.end() directly (or auto) yields compilation error:
-                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
-                const std::size_t N = static_cast<std::size_t>(itEnd - itMessage);
-
-                stream << colourImpl->guardColour( colour ) << " with "
-                       << pluralise( N, "message"_sr ) << ':';
-
-                for (; itMessage != itEnd; ) {
-                    // If this assertion is a warning ignore any INFO messages
-                    if (printInfoMessages || itMessage->type != ResultWas::Info) {
-                        stream << " '" << itMessage->message << '\'';
-                        if (++itMessage != itEnd) {
-                            stream << colourImpl->guardColour(tapDimColour) << " and";
-                        }
-                    }
-                }
-            }
-
-        private:
-            std::ostream& stream;
-            AssertionResult const& result;
-            std::vector<MessageInfo> const& messages;
-            std::vector<MessageInfo>::const_iterator itMessage;
-            bool printInfoMessages;
-            std::size_t counter;
-            ColourImpl* colourImpl;
-        };
-
-    } // End anonymous namespace
-
-    void TAPReporter::testRunStarting( TestRunInfo const& ) {
-        if ( m_config->testSpec().hasFilters() ) {
-            m_stream << "# filters: " << m_config->testSpec() << '\n';
-        }
-        m_stream << "# rng-seed: " << m_config->rngSeed() << '\n';
-    }
-
-    void TAPReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
-        m_stream << "# No test cases matched '" << unmatchedSpec << "'\n";
-    }
-
-    void TAPReporter::assertionEnded(AssertionStats const& _assertionStats) {
-        ++counter;
-
-        m_stream << "# " << currentTestCaseInfo->name << '\n';
-        TapAssertionPrinter printer(m_stream, _assertionStats, counter, m_colour.get());
-        printer.print();
-
-        m_stream << '\n' << std::flush;
-    }
-
-    void TAPReporter::testRunEnded(TestRunStats const& _testRunStats) {
-        m_stream << "1.." << _testRunStats.totals.assertions.total();
-        if (_testRunStats.totals.testCases.total() == 0) {
-            m_stream << " # Skipped: No tests ran.";
-        }
-        m_stream << "\n\n" << std::flush;
-        StreamingReporterBase::testRunEnded(_testRunStats);
-    }
-
-
-
-
-} // end namespace Catch
-
-
-
-
-#include <cassert>
-#include <ostream>
-
-namespace Catch {
-
-    namespace {
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        void printHeaderString(std::ostream& os, std::string const& _string, std::size_t indent = 0) {
-            std::size_t i = _string.find(": ");
-            if (i != std::string::npos)
-                i += 2;
-            else
-                i = 0;
-            os << TextFlow::Column(_string)
-                  .indent(indent + i)
-                  .initialIndent(indent) << '\n';
-        }
-
-        std::string escape(StringRef str) {
-            std::string escaped = static_cast<std::string>(str);
-            replaceInPlace(escaped, "|", "||");
-            replaceInPlace(escaped, "'", "|'");
-            replaceInPlace(escaped, "\n", "|n");
-            replaceInPlace(escaped, "\r", "|r");
-            replaceInPlace(escaped, "[", "|[");
-            replaceInPlace(escaped, "]", "|]");
-            return escaped;
-        }
-    } // end anonymous namespace
-
-
-    TeamCityReporter::~TeamCityReporter() = default;
-
-    void TeamCityReporter::testRunStarting( TestRunInfo const& runInfo ) {
-        m_stream << "##teamcity[testSuiteStarted name='" << escape( runInfo.name )
-               << "']\n";
-    }
-
-    void TeamCityReporter::testRunEnded( TestRunStats const& runStats ) {
-        m_stream << "##teamcity[testSuiteFinished name='"
-               << escape( runStats.runInfo.name ) << "']\n";
-    }
-
-    void TeamCityReporter::assertionEnded(AssertionStats const& assertionStats) {
-        AssertionResult const& result = assertionStats.assertionResult;
-        if ( !result.isOk() ||
-             result.getResultType() == ResultWas::ExplicitSkip ) {
-
-            ReusableStringStream msg;
-            if (!m_headerPrintedForThisSection)
-                printSectionHeader(msg.get());
-            m_headerPrintedForThisSection = true;
-
-            msg << result.getSourceInfo() << '\n';
-
-            switch (result.getResultType()) {
-            case ResultWas::ExpressionFailed:
-                msg << "expression failed";
-                break;
-            case ResultWas::ThrewException:
-                msg << "unexpected exception";
-                break;
-            case ResultWas::FatalErrorCondition:
-                msg << "fatal error condition";
-                break;
-            case ResultWas::DidntThrowException:
-                msg << "no exception was thrown where one was expected";
-                break;
-            case ResultWas::ExplicitFailure:
-                msg << "explicit failure";
-                break;
-            case ResultWas::ExplicitSkip:
-                msg << "explicit skip";
-                break;
-
-                // We shouldn't get here because of the isOk() test
-            case ResultWas::Ok:
-            case ResultWas::Info:
-            case ResultWas::Warning:
-                CATCH_ERROR("Internal error in TeamCity reporter");
-                // These cases are here to prevent compiler warnings
-            case ResultWas::Unknown:
-            case ResultWas::FailureBit:
-            case ResultWas::Exception:
-                CATCH_ERROR("Not implemented");
-            }
-            if (assertionStats.infoMessages.size() == 1)
-                msg << " with message:";
-            if (assertionStats.infoMessages.size() > 1)
-                msg << " with messages:";
-            for (auto const& messageInfo : assertionStats.infoMessages)
-                msg << "\n  \"" << messageInfo.message << '"';
-
-
-            if (result.hasExpression()) {
-                msg <<
-                    "\n  " << result.getExpressionInMacro() << "\n"
-                    "with expansion:\n"
-                    "  " << result.getExpandedExpression() << '\n';
-            }
-
-            if ( result.getResultType() == ResultWas::ExplicitSkip ) {
-                m_stream << "##teamcity[testIgnored";
-            } else if ( currentTestCaseInfo->okToFail() ) {
-                msg << "- failure ignore as test marked as 'ok to fail'\n";
-                m_stream << "##teamcity[testIgnored";
-            } else {
-                m_stream << "##teamcity[testFailed";
-            }
-            m_stream << " name='" << escape( currentTestCaseInfo->name ) << '\''
-                     << " message='" << escape( msg.str() ) << '\'' << "]\n";
-        }
-        m_stream.flush();
-    }
-
-    void TeamCityReporter::testCaseStarting(TestCaseInfo const& testInfo) {
-        m_testTimer.start();
-        StreamingReporterBase::testCaseStarting(testInfo);
-        m_stream << "##teamcity[testStarted name='"
-            << escape(testInfo.name) << "']\n";
-        m_stream.flush();
-    }
-
-    void TeamCityReporter::testCaseEnded(TestCaseStats const& testCaseStats) {
-        StreamingReporterBase::testCaseEnded(testCaseStats);
-        auto const& testCaseInfo = *testCaseStats.testInfo;
-        if (!testCaseStats.stdOut.empty())
-            m_stream << "##teamcity[testStdOut name='"
-            << escape(testCaseInfo.name)
-            << "' out='" << escape(testCaseStats.stdOut) << "']\n";
-        if (!testCaseStats.stdErr.empty())
-            m_stream << "##teamcity[testStdErr name='"
-            << escape(testCaseInfo.name)
-            << "' out='" << escape(testCaseStats.stdErr) << "']\n";
-        m_stream << "##teamcity[testFinished name='"
-            << escape(testCaseInfo.name) << "' duration='"
-            << m_testTimer.getElapsedMilliseconds() << "']\n";
-        m_stream.flush();
-    }
-
-    void TeamCityReporter::printSectionHeader(std::ostream& os) {
-        assert(!m_sectionStack.empty());
-
-        if (m_sectionStack.size() > 1) {
-            os << lineOfChars('-') << '\n';
-
-            std::vector<SectionInfo>::const_iterator
-                it = m_sectionStack.begin() + 1, // Skip first section (test case)
-                itEnd = m_sectionStack.end();
-            for (; it != itEnd; ++it)
-                printHeaderString(os, it->name);
-            os << lineOfChars('-') << '\n';
-        }
-
-        SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
-
-        os << lineInfo << '\n';
-        os << lineOfChars('.') << "\n\n";
-    }
-
-} // end namespace Catch
-
-
-
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
-#endif
-
-namespace Catch {
-    XmlReporter::XmlReporter( ReporterConfig&& _config )
-    :   StreamingReporterBase( CATCH_MOVE(_config) ),
-        m_xml(m_stream)
-    {
-        m_preferences.shouldRedirectStdOut = true;
-        m_preferences.shouldReportAllAssertions = true;
-    }
-
-    XmlReporter::~XmlReporter() = default;
-
-    std::string XmlReporter::getDescription() {
-        return "Reports test results as an XML document";
-    }
-
-    std::string XmlReporter::getStylesheetRef() const {
-        return std::string();
-    }
-
-    void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
-        m_xml
-            .writeAttribute( "filename"_sr, sourceInfo.file )
-            .writeAttribute( "line"_sr, sourceInfo.line );
-    }
-
-    void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
-        StreamingReporterBase::testRunStarting( testInfo );
-        std::string stylesheetRef = getStylesheetRef();
-        if( !stylesheetRef.empty() )
-            m_xml.writeStylesheetRef( stylesheetRef );
-        m_xml.startElement("Catch2TestRun")
-             .writeAttribute("name"_sr, m_config->name())
-             .writeAttribute("rng-seed"_sr, m_config->rngSeed())
-             .writeAttribute("xml-format-version"_sr, 3)
-             .writeAttribute("catch2-version"_sr, libraryVersion());
-        if ( m_config->testSpec().hasFilters() ) {
-            m_xml.writeAttribute( "filters"_sr, m_config->testSpec() );
-        }
-    }
-
-    void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        StreamingReporterBase::testCaseStarting(testInfo);
-        m_xml.startElement( "TestCase" )
-            .writeAttribute( "name"_sr, trim( StringRef(testInfo.name) ) )
-            .writeAttribute( "tags"_sr, testInfo.tagsAsString() );
-
-        writeSourceInfo( testInfo.lineInfo );
-
-        if ( m_config->showDurations() == ShowDurations::Always )
-            m_testCaseTimer.start();
-        m_xml.ensureTagClosed();
-    }
-
-    void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        StreamingReporterBase::sectionStarting( sectionInfo );
-        if( m_sectionDepth++ > 0 ) {
-            m_xml.startElement( "Section" )
-                .writeAttribute( "name"_sr, trim( StringRef(sectionInfo.name) ) );
-            writeSourceInfo( sectionInfo.lineInfo );
-            m_xml.ensureTagClosed();
-        }
-    }
-
-    void XmlReporter::assertionStarting( AssertionInfo const& ) { }
-
-    void XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
-
-        AssertionResult const& result = assertionStats.assertionResult;
-
-        bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-        if( includeResults || result.getResultType() == ResultWas::Warning ) {
-            // Print any info messages in <Info> tags.
-            for( auto const& msg : assertionStats.infoMessages ) {
-                if( msg.type == ResultWas::Info && includeResults ) {
-                    auto t = m_xml.scopedElement( "Info" );
-                    writeSourceInfo( msg.lineInfo );
-                    t.writeText( msg.message );
-                } else if ( msg.type == ResultWas::Warning ) {
-                    auto t = m_xml.scopedElement( "Warning" );
-                    writeSourceInfo( msg.lineInfo );
-                    t.writeText( msg.message );
-                }
-            }
-        }
-
-        // Drop out if result was successful but we're not printing them.
-        if ( !includeResults && result.getResultType() != ResultWas::Warning &&
-             result.getResultType() != ResultWas::ExplicitSkip ) {
-            return;
-        }
-
-        // Print the expression if there is one.
-        if( result.hasExpression() ) {
-            m_xml.startElement( "Expression" )
-                .writeAttribute( "success"_sr, result.succeeded() )
-                .writeAttribute( "type"_sr, result.getTestMacroName() );
-
-            writeSourceInfo( result.getSourceInfo() );
-
-            m_xml.scopedElement( "Original" )
-                .writeText( result.getExpression() );
-            m_xml.scopedElement( "Expanded" )
-                .writeText( result.getExpandedExpression() );
-        }
-
-        // And... Print a result applicable to each result type.
-        switch( result.getResultType() ) {
-            case ResultWas::ThrewException:
-                m_xml.startElement( "Exception" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            case ResultWas::FatalErrorCondition:
-                m_xml.startElement( "FatalErrorCondition" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            case ResultWas::Info:
-                m_xml.scopedElement( "Info" )
-                     .writeText( result.getMessage() );
-                break;
-            case ResultWas::Warning:
-                // Warning will already have been written
-                break;
-            case ResultWas::ExplicitFailure:
-                m_xml.startElement( "Failure" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            case ResultWas::ExplicitSkip:
-                m_xml.startElement( "Skip" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            default:
-                break;
-        }
-
-        if( result.hasExpression() )
-            m_xml.endElement();
-    }
-
-    void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
-        StreamingReporterBase::sectionEnded( sectionStats );
-        if ( --m_sectionDepth > 0 ) {
-            {
-                XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
-                e.writeAttribute( "successes"_sr, sectionStats.assertions.passed );
-                e.writeAttribute( "failures"_sr, sectionStats.assertions.failed );
-                e.writeAttribute( "expectedFailures"_sr, sectionStats.assertions.failedButOk );
-                e.writeAttribute( "skipped"_sr, sectionStats.assertions.skipped > 0 );
-
-                if ( m_config->showDurations() == ShowDurations::Always )
-                    e.writeAttribute( "durationInSeconds"_sr, sectionStats.durationInSeconds );
-            }
-            // Ends assertion tag
-            m_xml.endElement();
-        }
-    }
-
-    void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        StreamingReporterBase::testCaseEnded( testCaseStats );
-        XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
-        e.writeAttribute( "success"_sr, testCaseStats.totals.assertions.allOk() );
-        e.writeAttribute( "skips"_sr, testCaseStats.totals.assertions.skipped );
-
-        if ( m_config->showDurations() == ShowDurations::Always )
-            e.writeAttribute( "durationInSeconds"_sr, m_testCaseTimer.getElapsedSeconds() );
-        if( !testCaseStats.stdOut.empty() )
-            m_xml.scopedElement( "StdOut" ).writeText( trim( StringRef(testCaseStats.stdOut) ), XmlFormatting::Newline );
-        if( !testCaseStats.stdErr.empty() )
-            m_xml.scopedElement( "StdErr" ).writeText( trim( StringRef(testCaseStats.stdErr) ), XmlFormatting::Newline );
-
-        m_xml.endElement();
-    }
-
-    void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
-        StreamingReporterBase::testRunEnded( testRunStats );
-        m_xml.scopedElement( "OverallResults" )
-            .writeAttribute( "successes"_sr, testRunStats.totals.assertions.passed )
-            .writeAttribute( "failures"_sr, testRunStats.totals.assertions.failed )
-            .writeAttribute( "expectedFailures"_sr, testRunStats.totals.assertions.failedButOk )
-            .writeAttribute( "skips"_sr, testRunStats.totals.assertions.skipped );
-        m_xml.scopedElement( "OverallResultsCases")
-            .writeAttribute( "successes"_sr, testRunStats.totals.testCases.passed )
-            .writeAttribute( "failures"_sr, testRunStats.totals.testCases.failed )
-            .writeAttribute( "expectedFailures"_sr, testRunStats.totals.testCases.failedButOk )
-            .writeAttribute( "skips"_sr, testRunStats.totals.testCases.skipped );
-        m_xml.endElement();
-    }
-
-    void XmlReporter::benchmarkPreparing( StringRef name ) {
-        m_xml.startElement("BenchmarkResults")
-             .writeAttribute("name"_sr, name);
-    }
-
-    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
-        m_xml.writeAttribute("samples"_sr, info.samples)
-            .writeAttribute("resamples"_sr, info.resamples)
-            .writeAttribute("iterations"_sr, info.iterations)
-            .writeAttribute("clockResolution"_sr, info.clockResolution)
-            .writeAttribute("estimatedDuration"_sr, info.estimatedDuration)
-            .writeComment("All values in nano seconds"_sr);
-    }
-
-    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
-        m_xml.scopedElement("mean")
-            .writeAttribute("value"_sr, benchmarkStats.mean.point.count())
-            .writeAttribute("lowerBound"_sr, benchmarkStats.mean.lower_bound.count())
-            .writeAttribute("upperBound"_sr, benchmarkStats.mean.upper_bound.count())
-            .writeAttribute("ci"_sr, benchmarkStats.mean.confidence_interval);
-        m_xml.scopedElement("standardDeviation")
-            .writeAttribute("value"_sr, benchmarkStats.standardDeviation.point.count())
-            .writeAttribute("lowerBound"_sr, benchmarkStats.standardDeviation.lower_bound.count())
-            .writeAttribute("upperBound"_sr, benchmarkStats.standardDeviation.upper_bound.count())
-            .writeAttribute("ci"_sr, benchmarkStats.standardDeviation.confidence_interval);
-        m_xml.scopedElement("outliers")
-            .writeAttribute("variance"_sr, benchmarkStats.outlierVariance)
-            .writeAttribute("lowMild"_sr, benchmarkStats.outliers.low_mild)
-            .writeAttribute("lowSevere"_sr, benchmarkStats.outliers.low_severe)
-            .writeAttribute("highMild"_sr, benchmarkStats.outliers.high_mild)
-            .writeAttribute("highSevere"_sr, benchmarkStats.outliers.high_severe);
-        m_xml.endElement();
-    }
-
-    void XmlReporter::benchmarkFailed(StringRef error) {
-        m_xml.scopedElement("failed").
-            writeAttribute("message"_sr, error);
-        m_xml.endElement();
-    }
-
-    void XmlReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
-        auto outerTag = m_xml.scopedElement("AvailableReporters");
-        for (auto const& reporter : descriptions) {
-            auto inner = m_xml.scopedElement("Reporter");
-            m_xml.startElement("Name", XmlFormatting::Indent)
-                 .writeText(reporter.name, XmlFormatting::None)
-                 .endElement(XmlFormatting::Newline);
-            m_xml.startElement("Description", XmlFormatting::Indent)
-                 .writeText(reporter.description, XmlFormatting::None)
-                 .endElement(XmlFormatting::Newline);
-        }
-    }
-
-    void XmlReporter::listListeners(std::vector<ListenerDescription> const& descriptions) {
-        auto outerTag = m_xml.scopedElement( "RegisteredListeners" );
-        for ( auto const& listener : descriptions ) {
-            auto inner = m_xml.scopedElement( "Listener" );
-            m_xml.startElement( "Name", XmlFormatting::Indent )
-                .writeText( listener.name, XmlFormatting::None )
-                .endElement( XmlFormatting::Newline );
-            m_xml.startElement( "Description", XmlFormatting::Indent )
-                .writeText( listener.description, XmlFormatting::None )
-                .endElement( XmlFormatting::Newline );
-        }
-    }
-
-    void XmlReporter::listTests(std::vector<TestCaseHandle> const& tests) {
-        auto outerTag = m_xml.scopedElement("MatchingTests");
-        for (auto const& test : tests) {
-            auto innerTag = m_xml.scopedElement("TestCase");
-            auto const& testInfo = test.getTestCaseInfo();
-            m_xml.startElement("Name", XmlFormatting::Indent)
-                 .writeText(testInfo.name, XmlFormatting::None)
-                 .endElement(XmlFormatting::Newline);
-            m_xml.startElement("ClassName", XmlFormatting::Indent)
-                 .writeText(testInfo.className, XmlFormatting::None)
-                 .endElement(XmlFormatting::Newline);
-            m_xml.startElement("Tags", XmlFormatting::Indent)
-                 .writeText(testInfo.tagsAsString(), XmlFormatting::None)
-                 .endElement(XmlFormatting::Newline);
-
-            auto sourceTag = m_xml.scopedElement("SourceInfo");
-            m_xml.startElement("File", XmlFormatting::Indent)
-                 .writeText(testInfo.lineInfo.file, XmlFormatting::None)
-                 .endElement(XmlFormatting::Newline);
-            m_xml.startElement("Line", XmlFormatting::Indent)
-                 .writeText(std::to_string(testInfo.lineInfo.line), XmlFormatting::None)
-                 .endElement(XmlFormatting::Newline);
-        }
-    }
-
-    void XmlReporter::listTags(std::vector<TagInfo> const& tags) {
-        auto outerTag = m_xml.scopedElement("TagsFromMatchingTests");
-        for (auto const& tag : tags) {
-            auto innerTag = m_xml.scopedElement("Tag");
-            m_xml.startElement("Count", XmlFormatting::Indent)
-                 .writeText(std::to_string(tag.count), XmlFormatting::None)
-                 .endElement(XmlFormatting::Newline);
-            auto aliasTag = m_xml.scopedElement("Aliases");
-            for (auto const& alias : tag.spellings) {
-                m_xml.startElement("Alias", XmlFormatting::Indent)
-                     .writeText(alias, XmlFormatting::None)
-                     .endElement(XmlFormatting::Newline);
-            }
-        }
-    }
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
diff --git a/extern/catch2/catch_amalgamated.hpp b/extern/catch2/catch_amalgamated.hpp
deleted file mode 100644
index b7c768b8..00000000
--- a/extern/catch2/catch_amalgamated.hpp
+++ /dev/null
@@ -1,14106 +0,0 @@
-
-//              Copyright Catch2 Authors
-// Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE.txt or copy at
-//        https://www.boost.org/LICENSE_1_0.txt)
-
-// SPDX-License-Identifier: BSL-1.0
-
-//  Catch v3.7.1
-//  Generated: 2024-09-17 10:36:40.974985
-//  ----------------------------------------------------------
-//  This file is an amalgamation of multiple different files.
-//  You probably shouldn't edit it directly.
-//  ----------------------------------------------------------
-#ifndef CATCH_AMALGAMATED_HPP_INCLUDED
-#define CATCH_AMALGAMATED_HPP_INCLUDED
-
-
-/** \file
- * This is a convenience header for Catch2. It includes **all** of Catch2 headers.
- *
- * Generally the Catch2 users should use specific includes they need,
- * but this header can be used instead for ease-of-experimentation, or
- * just plain convenience, at the cost of (significantly) increased
- * compilation times.
- *
- * When a new header is added to either the top level folder, or to the
- * corresponding internal subfolder, it should be added here. Headers
- * added to the various subparts (e.g. matchers, generators, etc...),
- * should go their respective catch-all headers.
- */
-
-#ifndef CATCH_ALL_HPP_INCLUDED
-#define CATCH_ALL_HPP_INCLUDED
-
-
-
-/** \file
- * This is a convenience header for Catch2's benchmarking. It includes
- * **all** of Catch2 headers related to benchmarking.
- *
- * Generally the Catch2 users should use specific includes they need,
- * but this header can be used instead for ease-of-experimentation, or
- * just plain convenience, at the cost of (significantly) increased
- * compilation times.
- *
- * When a new header is added to either the `benchmark` folder, or to
- * the corresponding internal (detail) subfolder, it should be added here.
- */
-
-#ifndef CATCH_BENCHMARK_ALL_HPP_INCLUDED
-#define CATCH_BENCHMARK_ALL_HPP_INCLUDED
-
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_BENCHMARK_HPP_INCLUDED
-#define CATCH_BENCHMARK_HPP_INCLUDED
-
-
-
-#ifndef CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
-#define CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
-
-// Detect a number of compiler features - by compiler
-// The following features are defined:
-//
-// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
-// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
-// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
-// ****************
-// Note to maintainers: if new toggles are added please document them
-// in configuration.md, too
-// ****************
-
-// In general each macro has a _NO_<feature name> form
-// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
-// Many features, at point of detection, define an _INTERNAL_ macro, so they
-// can be combined, en-mass, with the _NO_ forms later.
-
-
-
-#ifndef CATCH_PLATFORM_HPP_INCLUDED
-#define CATCH_PLATFORM_HPP_INCLUDED
-
-// See e.g.:
-// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html
-#ifdef __APPLE__
-#  ifndef __has_extension
-#    define __has_extension(x) 0
-#  endif
-#  include <TargetConditionals.h>
-#  if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \
-      (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1)
-#    define CATCH_PLATFORM_MAC
-#  elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1)
-#    define CATCH_PLATFORM_IPHONE
-#  endif
-
-#elif defined(linux) || defined(__linux) || defined(__linux__)
-#  define CATCH_PLATFORM_LINUX
-
-#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
-#  define CATCH_PLATFORM_WINDOWS
-
-#  if defined( WINAPI_FAMILY ) && ( WINAPI_FAMILY == WINAPI_FAMILY_APP )
-#      define CATCH_PLATFORM_WINDOWS_UWP
-#  endif
-
-#elif defined(__ORBIS__) || defined(__PROSPERO__)
-#  define CATCH_PLATFORM_PLAYSTATION
-
-#endif
-
-#endif // CATCH_PLATFORM_HPP_INCLUDED
-
-#ifdef __cplusplus
-
-#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-#    define CATCH_CPP17_OR_GREATER
-#  endif
-
-#  if (__cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
-#    define CATCH_CPP20_OR_GREATER
-#  endif
-
-#endif
-
-// Only GCC compiler should be used in this block, so other compilers trying to
-// mask themselves as GCC should be ignored.
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__) && !defined(__NVCOMPILER)
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )
-
-// This only works on GCC 9+. so we have to also add a global suppression of Wparentheses
-// for older versions of GCC.
-#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-         _Pragma( "GCC diagnostic ignored \"-Wparentheses\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
-         _Pragma( "GCC diagnostic ignored \"-Wunused-result\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
-         _Pragma( "GCC diagnostic ignored \"-Wunused-variable\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
-         _Pragma( "GCC diagnostic ignored \"-Wuseless-cast\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
-         _Pragma( "GCC diagnostic ignored \"-Wshadow\"" )
-
-#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
-
-#endif
-
-#if defined(__NVCOMPILER)
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "diag push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "diag pop" )
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress declared_but_not_referenced" )
-#endif
-
-#if defined(__CUDACC__) && !defined(__clang__)
-#  ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
-// New pragmas introduced in CUDA 11.5+
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "nv_diagnostic pop" )
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "nv_diag_suppress 177" )
-#  else
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress 177" )
-#  endif
-#endif
-
-// clang-cl defines _MSC_VER as well as __clang__, which could cause the
-// start/stop internal suppression macros to be double defined.
-#if defined(__clang__) && !defined(_MSC_VER)
-
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
-
-#endif // __clang__ && !_MSC_VER
-
-#if defined(__clang__)
-
-// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
-// which results in calls to destructors being emitted for each temporary,
-// without a matching initialization. In practice, this can result in something
-// like `std::string::~string` being called on an uninitialized value.
-//
-// For example, this code will likely segfault under IBM XL:
-// ```
-// REQUIRE(std::string("12") + "34" == "1234")
-// ```
-//
-// Similarly, NVHPC's implementation of `__builtin_constant_p` has a bug which
-// results in calls to the immediately evaluated lambda expressions to be
-// reported as unevaluated lambdas.
-// https://developer.nvidia.com/nvidia_bug/3321845.
-//
-// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
-#  if !defined(__ibmxl__) && !defined(__CUDACC__) && !defined( __NVCOMPILER )
-#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
-#  endif
-
-
-#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
-         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
-
-#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
-        _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
-        _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
-
-#endif // __clang__
-
-
-////////////////////////////////////////////////////////////////////////////////
-// We know some environments not to support full POSIX signals
-#if defined( CATCH_PLATFORM_WINDOWS ) ||                                       \
-    defined( CATCH_PLATFORM_PLAYSTATION ) ||                                   \
-    defined( __CYGWIN__ ) ||                                                   \
-    defined( __QNX__ ) ||                                                      \
-    defined( __EMSCRIPTEN__ ) ||                                               \
-    defined( __DJGPP__ ) ||                                                    \
-    defined( __OS400__ )
-#    define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
-#else
-#    define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Assume that some platforms do not support getenv.
-#if defined( CATCH_PLATFORM_WINDOWS_UWP ) ||                                   \
-    defined( CATCH_PLATFORM_PLAYSTATION ) ||                                   \
-    defined( _GAMING_XBOX )
-#    define CATCH_INTERNAL_CONFIG_NO_GETENV
-#else
-#    define CATCH_INTERNAL_CONFIG_GETENV
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Android somehow still does not support std::to_string
-#if defined(__ANDROID__)
-#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Not all Windows environments support SEH properly
-#if defined(__MINGW32__)
-#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// PS4
-#if defined(__ORBIS__)
-#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Cygwin
-#ifdef __CYGWIN__
-
-// Required for some versions of Cygwin to declare gettimeofday
-// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
-#   define _BSD_SOURCE
-// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
-// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
-# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
-           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
-
-#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
-
-# endif
-#endif // __CYGWIN__
-
-////////////////////////////////////////////////////////////////////////////////
-// Visual C++
-#if defined(_MSC_VER)
-
-// We want to defer to nvcc-specific warning suppression if we are compiled
-// with nvcc masquerading for MSVC.
-#    if !defined( __CUDACC__ )
-#        define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-            __pragma( warning( push ) )
-#        define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-            __pragma( warning( pop ) )
-#    endif
-
-// Universal Windows platform does not support SEH
-// Or console colours (or console at all...)
-#  if defined(CATCH_PLATFORM_WINDOWS_UWP)
-#    define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
-#  else
-#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
-#  endif
-
-// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
-// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
-// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
-#  if !defined(__clang__) // Handle Clang masquerading for msvc
-#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
-#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#    endif // MSVC_TRADITIONAL
-#  endif // __clang__
-
-#endif // _MSC_VER
-
-#if defined(_REENTRANT) || defined(_MSC_VER)
-// Enable async processing, as -pthread is specified or no additional linking is required
-# define CATCH_INTERNAL_CONFIG_USE_ASYNC
-#endif // _MSC_VER
-
-////////////////////////////////////////////////////////////////////////////////
-// Check if we are compiled with -fno-exceptions or equivalent
-#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
-#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
-#endif
-
-
-////////////////////////////////////////////////////////////////////////////////
-// Embarcadero C++Build
-#if defined(__BORLANDC__)
-    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-
-// RTX is a special version of Windows that is real time.
-// This means that it is detected as Windows, but does not provide
-// the same set of capabilities as real Windows does.
-#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
-    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
-    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
-    #define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
-#endif
-
-#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
-#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
-#endif
-
-// Various stdlib support checks that require __has_include
-#if defined(__has_include)
-  // Check if string_view is available and usable
-  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
-  #endif
-
-  // Check if optional is available and usable
-  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
-  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-
-  // Check if byte is available and usable
-  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-  #    include <cstddef>
-  #    if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0)
-  #      define CATCH_INTERNAL_CONFIG_CPP17_BYTE
-  #    endif
-  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-
-  // Check if variant is available and usable
-  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-  #    if defined(__clang__) && (__clang_major__ < 8)
-         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
-         // fix should be in clang 8, workaround in libstdc++ 8.2
-  #      include <ciso646>
-  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #        define CATCH_CONFIG_NO_CPP17_VARIANT
-  #      else
-  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #    else
-  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #    endif // defined(__clang__) && (__clang_major__ < 8)
-  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-#endif // defined(__has_include)
-
-
-#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
-#   define CATCH_CONFIG_WINDOWS_SEH
-#endif
-// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
-#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
-#   define CATCH_CONFIG_POSIX_SIGNALS
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_GETENV) && !defined(CATCH_INTERNAL_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_GETENV)
-#   define CATCH_CONFIG_GETENV
-#endif
-
-#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
-#    define CATCH_CONFIG_CPP11_TO_STRING
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
-#  define CATCH_CONFIG_CPP17_OPTIONAL
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
-#  define CATCH_CONFIG_CPP17_STRING_VIEW
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
-#  define CATCH_CONFIG_CPP17_VARIANT
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
-#  define CATCH_CONFIG_CPP17_BYTE
-#endif
-
-
-#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
-#  define CATCH_CONFIG_NEW_CAPTURE
-#endif
-
-#if !defined( CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED ) && \
-    !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS ) &&          \
-    !defined( CATCH_CONFIG_NO_DISABLE_EXCEPTIONS )
-#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
-#  define CATCH_CONFIG_POLYFILL_ISNAN
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
-#  define CATCH_CONFIG_USE_ASYNC
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
-#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
-#endif
-
-
-// Even if we do not think the compiler has that warning, we still have
-// to provide a macro that can be used by the code.
-#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
-#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
-#endif
-#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
-#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT)
-#   define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
-#endif
-#if !defined( CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS )
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#endif
-#if !defined( CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS )
-#    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS
-#endif
-#if !defined( CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS )
-#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS
-#endif
-
-
-// The goal of this macro is to avoid evaluation of the arguments, but
-// still have the compiler warn on problems inside...
-#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
-#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
-#endif
-
-#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
-#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#elif defined(__clang__) && (__clang_major__ < 5)
-#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#endif
-
-
-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-#define CATCH_TRY if ((true))
-#define CATCH_CATCH_ALL if ((false))
-#define CATCH_CATCH_ANON(type) if ((false))
-#else
-#define CATCH_TRY try
-#define CATCH_CATCH_ALL catch (...)
-#define CATCH_CATCH_ANON(type) catch (type)
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
-#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#endif
-
-#if defined( CATCH_PLATFORM_WINDOWS ) &&       \
-    !defined( CATCH_CONFIG_COLOUR_WIN32 ) && \
-    !defined( CATCH_CONFIG_NO_COLOUR_WIN32 ) && \
-    !defined( CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32 )
-#    define CATCH_CONFIG_COLOUR_WIN32
-#endif
-
-#if defined( CATCH_CONFIG_SHARED_LIBRARY ) && defined( _MSC_VER ) && \
-    !defined( CATCH_CONFIG_STATIC )
-#    ifdef Catch2_EXPORTS
-#        define CATCH_EXPORT //__declspec( dllexport ) // not needed
-#    else
-#        define CATCH_EXPORT __declspec( dllimport )
-#    endif
-#else
-#    define CATCH_EXPORT
-#endif
-
-#endif // CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
-
-
-#ifndef CATCH_CONTEXT_HPP_INCLUDED
-#define CATCH_CONTEXT_HPP_INCLUDED
-
-
-namespace Catch {
-
-    class IResultCapture;
-    class IConfig;
-
-    class Context {
-        IConfig const* m_config = nullptr;
-        IResultCapture* m_resultCapture = nullptr;
-
-        CATCH_EXPORT static Context* currentContext;
-        friend Context& getCurrentMutableContext();
-        friend Context const& getCurrentContext();
-        static void createContext();
-        friend void cleanUpContext();
-
-    public:
-        constexpr IResultCapture* getResultCapture() const {
-            return m_resultCapture;
-        }
-        constexpr IConfig const* getConfig() const { return m_config; }
-        constexpr void setResultCapture( IResultCapture* resultCapture ) {
-            m_resultCapture = resultCapture;
-        }
-        constexpr void setConfig( IConfig const* config ) { m_config = config; }
-
-    };
-
-    Context& getCurrentMutableContext();
-
-    inline Context const& getCurrentContext() {
-        // We duplicate the logic from `getCurrentMutableContext` here,
-        // to avoid paying the call overhead in debug mode.
-        if ( !Context::currentContext ) { Context::createContext(); }
-        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
-        return *Context::currentContext;
-    }
-
-    void cleanUpContext();
-
-    class SimplePcg32;
-    SimplePcg32& sharedRng();
-}
-
-#endif // CATCH_CONTEXT_HPP_INCLUDED
-
-
-#ifndef CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
-#define CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
-
-#include <type_traits>
-
-//! Replacement for std::move with better compile time performance
-#define CATCH_MOVE(...) static_cast<std::remove_reference_t<decltype(__VA_ARGS__)>&&>(__VA_ARGS__)
-
-//! Replacement for std::forward with better compile time performance
-#define CATCH_FORWARD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)
-
-#endif // CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
-
-
-#ifndef CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
-#define CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
-
-namespace Catch {
-
-    //! Used to signal that an assertion macro failed
-    struct TestFailureException{};
-    //! Used to signal that the remainder of a test should be skipped
-    struct TestSkipException {};
-
-    /**
-     * Outlines throwing of `TestFailureException` into a single TU
-     *
-     * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers.
-     */
-    [[noreturn]] void throw_test_failure_exception();
-
-    /**
-     * Outlines throwing of `TestSkipException` into a single TU
-     *
-     * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers.
-     */
-    [[noreturn]] void throw_test_skip_exception();
-
-} // namespace Catch
-
-#endif // CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
-
-
-#ifndef CATCH_UNIQUE_NAME_HPP_INCLUDED
-#define CATCH_UNIQUE_NAME_HPP_INCLUDED
-
-
-
-
-/** \file
- * Wrapper for the CONFIG configuration option
- *
- * When generating internal unique names, there are two options. Either
- * we mix in the current line number, or mix in an incrementing number.
- * We prefer the latter, using `__COUNTER__`, but users might want to
- * use the former.
- */
-
-#ifndef CATCH_CONFIG_COUNTER_HPP_INCLUDED
-#define CATCH_CONFIG_COUNTER_HPP_INCLUDED
-
-
-#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
-    #define CATCH_INTERNAL_CONFIG_COUNTER
-#endif
-
-#if defined( CATCH_INTERNAL_CONFIG_COUNTER ) && \
-    !defined( CATCH_CONFIG_NO_COUNTER ) && \
-    !defined( CATCH_CONFIG_COUNTER )
-#    define CATCH_CONFIG_COUNTER
-#endif
-
-
-#endif // CATCH_CONFIG_COUNTER_HPP_INCLUDED
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
-#ifdef CATCH_CONFIG_COUNTER
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
-#else
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
-#endif
-
-#endif // CATCH_UNIQUE_NAME_HPP_INCLUDED
-
-
-#ifndef CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
-#define CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
-
-#include <string>
-
-
-
-#ifndef CATCH_STRINGREF_HPP_INCLUDED
-#define CATCH_STRINGREF_HPP_INCLUDED
-
-#include <cstddef>
-#include <string>
-#include <iosfwd>
-#include <cassert>
-
-#include <cstring>
-
-namespace Catch {
-
-    /// A non-owning string class (similar to the forthcoming std::string_view)
-    /// Note that, because a StringRef may be a substring of another string,
-    /// it may not be null terminated.
-    class StringRef {
-    public:
-        using size_type = std::size_t;
-        using const_iterator = const char*;
-
-        static constexpr size_type npos{ static_cast<size_type>( -1 ) };
-
-    private:
-        static constexpr char const* const s_empty = "";
-
-        char const* m_start = s_empty;
-        size_type m_size = 0;
-
-    public: // construction
-        constexpr StringRef() noexcept = default;
-
-        StringRef( char const* rawChars ) noexcept;
-
-        constexpr StringRef( char const* rawChars, size_type size ) noexcept
-        :   m_start( rawChars ),
-            m_size( size )
-        {}
-
-        StringRef( std::string const& stdString ) noexcept
-        :   m_start( stdString.c_str() ),
-            m_size( stdString.size() )
-        {}
-
-        explicit operator std::string() const {
-            return std::string(m_start, m_size);
-        }
-
-    public: // operators
-        auto operator == ( StringRef other ) const noexcept -> bool {
-            return m_size == other.m_size
-                && (std::memcmp( m_start, other.m_start, m_size ) == 0);
-        }
-        auto operator != (StringRef other) const noexcept -> bool {
-            return !(*this == other);
-        }
-
-        constexpr auto operator[] ( size_type index ) const noexcept -> char {
-            assert(index < m_size);
-            return m_start[index];
-        }
-
-        bool operator<(StringRef rhs) const noexcept;
-
-    public: // named queries
-        constexpr auto empty() const noexcept -> bool {
-            return m_size == 0;
-        }
-        constexpr auto size() const noexcept -> size_type {
-            return m_size;
-        }
-
-        // Returns a substring of [start, start + length).
-        // If start + length > size(), then the substring is [start, size()).
-        // If start > size(), then the substring is empty.
-        constexpr StringRef substr(size_type start, size_type length) const noexcept {
-            if (start < m_size) {
-                const auto shortened_size = m_size - start;
-                return StringRef(m_start + start, (shortened_size < length) ? shortened_size : length);
-            } else {
-                return StringRef();
-            }
-        }
-
-        // Returns the current start pointer. May not be null-terminated.
-        constexpr char const* data() const noexcept {
-            return m_start;
-        }
-
-        constexpr const_iterator begin() const { return m_start; }
-        constexpr const_iterator end() const { return m_start + m_size; }
-
-
-        friend std::string& operator += (std::string& lhs, StringRef rhs);
-        friend std::ostream& operator << (std::ostream& os, StringRef str);
-        friend std::string operator+(StringRef lhs, StringRef rhs);
-
-        /**
-         * Provides a three-way comparison with rhs
-         *
-         * Returns negative number if lhs < rhs, 0 if lhs == rhs, and a positive
-         * number if lhs > rhs
-         */
-        int compare( StringRef rhs ) const;
-    };
-
-
-    constexpr auto operator ""_sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
-        return StringRef( rawChars, size );
-    }
-} // namespace Catch
-
-constexpr auto operator ""_catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
-    return Catch::StringRef( rawChars, size );
-}
-
-#endif // CATCH_STRINGREF_HPP_INCLUDED
-
-
-#ifndef CATCH_RESULT_TYPE_HPP_INCLUDED
-#define CATCH_RESULT_TYPE_HPP_INCLUDED
-
-namespace Catch {
-
-    // ResultWas::OfType enum
-    struct ResultWas { enum OfType {
-        Unknown = -1,
-        Ok = 0,
-        Info = 1,
-        Warning = 2,
-        // TODO: Should explicit skip be considered "not OK" (cf. isOk)? I.e., should it have the failure bit?
-        ExplicitSkip = 4,
-
-        FailureBit = 0x10,
-
-        ExpressionFailed = FailureBit | 1,
-        ExplicitFailure = FailureBit | 2,
-
-        Exception = 0x100 | FailureBit,
-
-        ThrewException = Exception | 1,
-        DidntThrowException = Exception | 2,
-
-        FatalErrorCondition = 0x200 | FailureBit
-
-    }; };
-
-    constexpr bool isOk( ResultWas::OfType resultType ) {
-        return ( resultType & ResultWas::FailureBit ) == 0;
-    }
-    constexpr bool isJustInfo( int flags ) { return flags == ResultWas::Info; }
-
-
-    // ResultDisposition::Flags enum
-    struct ResultDisposition { enum Flags {
-        Normal = 0x01,
-
-        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
-        FalseTest = 0x04,           // Prefix expression with !
-        SuppressFail = 0x08         // Failures are reported but do not fail the test
-    }; };
-
-    constexpr ResultDisposition::Flags operator|( ResultDisposition::Flags lhs,
-                                        ResultDisposition::Flags rhs ) {
-        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) |
-                                                      static_cast<int>( rhs ) );
-    }
-
-    constexpr bool isFalseTest( int flags ) {
-        return ( flags & ResultDisposition::FalseTest ) != 0;
-    }
-    constexpr bool shouldSuppressFailure( int flags ) {
-        return ( flags & ResultDisposition::SuppressFail ) != 0;
-    }
-
-} // end namespace Catch
-
-#endif // CATCH_RESULT_TYPE_HPP_INCLUDED
-
-
-#ifndef CATCH_UNIQUE_PTR_HPP_INCLUDED
-#define CATCH_UNIQUE_PTR_HPP_INCLUDED
-
-#include <cassert>
-#include <type_traits>
-
-
-namespace Catch {
-namespace Detail {
-    /**
-     * A reimplementation of `std::unique_ptr` for improved compilation performance
-     *
-     * Does not support arrays nor custom deleters.
-     */
-    template <typename T>
-    class unique_ptr {
-        T* m_ptr;
-    public:
-        constexpr unique_ptr(std::nullptr_t = nullptr):
-            m_ptr{}
-        {}
-        explicit constexpr unique_ptr(T* ptr):
-            m_ptr(ptr)
-        {}
-
-        template <typename U, typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-        unique_ptr(unique_ptr<U>&& from):
-            m_ptr(from.release())
-        {}
-
-        template <typename U, typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-        unique_ptr& operator=(unique_ptr<U>&& from) {
-            reset(from.release());
-
-            return *this;
-        }
-
-        unique_ptr(unique_ptr const&) = delete;
-        unique_ptr& operator=(unique_ptr const&) = delete;
-
-        unique_ptr(unique_ptr&& rhs) noexcept:
-            m_ptr(rhs.m_ptr) {
-            rhs.m_ptr = nullptr;
-        }
-        unique_ptr& operator=(unique_ptr&& rhs) noexcept {
-            reset(rhs.release());
-
-            return *this;
-        }
-
-        ~unique_ptr() {
-            delete m_ptr;
-        }
-
-        T& operator*() {
-            assert(m_ptr);
-            return *m_ptr;
-        }
-        T const& operator*() const {
-            assert(m_ptr);
-            return *m_ptr;
-        }
-        T* operator->() noexcept {
-            assert(m_ptr);
-            return m_ptr;
-        }
-        T const* operator->() const noexcept {
-            assert(m_ptr);
-            return m_ptr;
-        }
-
-        T* get() { return m_ptr; }
-        T const* get() const { return m_ptr; }
-
-        void reset(T* ptr = nullptr) {
-            delete m_ptr;
-            m_ptr = ptr;
-        }
-
-        T* release() {
-            auto temp = m_ptr;
-            m_ptr = nullptr;
-            return temp;
-        }
-
-        explicit operator bool() const {
-            return m_ptr;
-        }
-
-        friend void swap(unique_ptr& lhs, unique_ptr& rhs) {
-            auto temp = lhs.m_ptr;
-            lhs.m_ptr = rhs.m_ptr;
-            rhs.m_ptr = temp;
-        }
-    };
-
-    //! Specialization to cause compile-time error for arrays
-    template <typename T>
-    class unique_ptr<T[]>;
-
-    template <typename T, typename... Args>
-    unique_ptr<T> make_unique(Args&&... args) {
-        return unique_ptr<T>(new T(CATCH_FORWARD(args)...));
-    }
-
-
-} // end namespace Detail
-} // end namespace Catch
-
-#endif // CATCH_UNIQUE_PTR_HPP_INCLUDED
-
-
-#ifndef CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
-#define CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
-
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_CLOCK_HPP_INCLUDED
-#define CATCH_CLOCK_HPP_INCLUDED
-
-#include <chrono>
-
-namespace Catch {
-    namespace Benchmark {
-        using IDuration = std::chrono::nanoseconds;
-        using FDuration = std::chrono::duration<double, std::nano>;
-
-        template <typename Clock>
-        using TimePoint = typename Clock::time_point;
-
-        using default_clock = std::chrono::steady_clock;
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_CLOCK_HPP_INCLUDED
-
-namespace Catch {
-
-    // We cannot forward declare the type with default template argument
-    // multiple times, so it is split out into a separate header so that
-    // we can prevent multiple declarations in dependees
-    template <typename Duration = Benchmark::FDuration>
-    struct BenchmarkStats;
-
-} // end namespace Catch
-
-#endif // CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
-
-namespace Catch {
-
-    class AssertionResult;
-    struct AssertionInfo;
-    struct SectionInfo;
-    struct SectionEndInfo;
-    struct MessageInfo;
-    struct MessageBuilder;
-    struct Counts;
-    struct AssertionReaction;
-    struct SourceLineInfo;
-
-    class ITransientExpression;
-    class IGeneratorTracker;
-
-    struct BenchmarkInfo;
-
-    namespace Generators {
-        class GeneratorUntypedBase;
-        using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
-    }
-
-
-    class IResultCapture {
-    public:
-        virtual ~IResultCapture();
-
-        virtual void notifyAssertionStarted( AssertionInfo const& info ) = 0;
-        virtual bool sectionStarted( StringRef sectionName,
-                                     SourceLineInfo const& sectionLineInfo,
-                                     Counts& assertions ) = 0;
-        virtual void sectionEnded( SectionEndInfo&& endInfo ) = 0;
-        virtual void sectionEndedEarly( SectionEndInfo&& endInfo ) = 0;
-
-        virtual IGeneratorTracker*
-        acquireGeneratorTracker( StringRef generatorName,
-                                 SourceLineInfo const& lineInfo ) = 0;
-        virtual IGeneratorTracker*
-        createGeneratorTracker( StringRef generatorName,
-                                SourceLineInfo lineInfo,
-                                Generators::GeneratorBasePtr&& generator ) = 0;
-
-        virtual void benchmarkPreparing( StringRef name ) = 0;
-        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
-        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
-        virtual void benchmarkFailed( StringRef error ) = 0;
-
-        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
-        virtual void popScopedMessage( MessageInfo const& message ) = 0;
-
-        virtual void emplaceUnscopedMessage( MessageBuilder&& builder ) = 0;
-
-        virtual void handleFatalErrorCondition( StringRef message ) = 0;
-
-        virtual void handleExpr
-                (   AssertionInfo const& info,
-                    ITransientExpression const& expr,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleMessage
-                (   AssertionInfo const& info,
-                    ResultWas::OfType resultType,
-                    std::string&& message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedExceptionNotThrown
-                (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedInflightException
-                (   AssertionInfo const& info,
-                    std::string&& message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleIncomplete
-                (   AssertionInfo const& info ) = 0;
-        virtual void handleNonExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) = 0;
-
-
-
-        virtual bool lastAssertionPassed() = 0;
-        virtual void assertionPassed() = 0;
-
-        // Deprecated, do not use:
-        virtual std::string getCurrentTestName() const = 0;
-        virtual const AssertionResult* getLastResult() const = 0;
-        virtual void exceptionEarlyReported() = 0;
-    };
-
-    IResultCapture& getResultCapture();
-}
-
-#endif // CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
-
-
-#ifndef CATCH_INTERFACES_CONFIG_HPP_INCLUDED
-#define CATCH_INTERFACES_CONFIG_HPP_INCLUDED
-
-
-
-#ifndef CATCH_NONCOPYABLE_HPP_INCLUDED
-#define CATCH_NONCOPYABLE_HPP_INCLUDED
-
-namespace Catch {
-    namespace Detail {
-
-        //! Deriving classes become noncopyable and nonmovable
-        class NonCopyable {
-            NonCopyable( NonCopyable const& ) = delete;
-            NonCopyable( NonCopyable&& ) = delete;
-            NonCopyable& operator=( NonCopyable const& ) = delete;
-            NonCopyable& operator=( NonCopyable&& ) = delete;
-
-        protected:
-            NonCopyable() noexcept = default;
-        };
-
-    } // namespace Detail
-} // namespace Catch
-
-#endif // CATCH_NONCOPYABLE_HPP_INCLUDED
-
-#include <chrono>
-#include <iosfwd>
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    enum class Verbosity {
-        Quiet = 0,
-        Normal,
-        High
-    };
-
-    struct WarnAbout { enum What {
-        Nothing = 0x00,
-        //! A test case or leaf section did not run any assertions
-        NoAssertions = 0x01,
-        //! A command line test spec matched no test cases
-        UnmatchedTestSpec = 0x02,
-    }; };
-
-    enum class ShowDurations {
-        DefaultForReporter,
-        Always,
-        Never
-    };
-    enum class TestRunOrder {
-        Declared,
-        LexicographicallySorted,
-        Randomized
-    };
-    enum class ColourMode : std::uint8_t {
-        //! Let Catch2 pick implementation based on platform detection
-        PlatformDefault,
-        //! Use ANSI colour code escapes
-        ANSI,
-        //! Use Win32 console colour API
-        Win32,
-        //! Don't use any colour
-        None
-    };
-    struct WaitForKeypress { enum When {
-        Never,
-        BeforeStart = 1,
-        BeforeExit = 2,
-        BeforeStartAndExit = BeforeStart | BeforeExit
-    }; };
-
-    class TestSpec;
-    class IStream;
-
-    class IConfig : public Detail::NonCopyable {
-    public:
-        virtual ~IConfig();
-
-        virtual bool allowThrows() const = 0;
-        virtual StringRef name() const = 0;
-        virtual bool includeSuccessfulResults() const = 0;
-        virtual bool shouldDebugBreak() const = 0;
-        virtual bool warnAboutMissingAssertions() const = 0;
-        virtual bool warnAboutUnmatchedTestSpecs() const = 0;
-        virtual bool zeroTestsCountAsSuccess() const = 0;
-        virtual int abortAfter() const = 0;
-        virtual bool showInvisibles() const = 0;
-        virtual ShowDurations showDurations() const = 0;
-        virtual double minDuration() const = 0;
-        virtual TestSpec const& testSpec() const = 0;
-        virtual bool hasTestFilters() const = 0;
-        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
-        virtual TestRunOrder runOrder() const = 0;
-        virtual uint32_t rngSeed() const = 0;
-        virtual unsigned int shardCount() const = 0;
-        virtual unsigned int shardIndex() const = 0;
-        virtual ColourMode defaultColourMode() const = 0;
-        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
-        virtual Verbosity verbosity() const = 0;
-
-        virtual bool skipBenchmarks() const = 0;
-        virtual bool benchmarkNoAnalysis() const = 0;
-        virtual unsigned int benchmarkSamples() const = 0;
-        virtual double benchmarkConfidenceInterval() const = 0;
-        virtual unsigned int benchmarkResamples() const = 0;
-        virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
-    };
-}
-
-#endif // CATCH_INTERFACES_CONFIG_HPP_INCLUDED
-
-
-#ifndef CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
-#define CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
-
-
-#include <string>
-
-namespace Catch {
-
-    class TestCaseHandle;
-    struct TestCaseInfo;
-    class ITestCaseRegistry;
-    class IExceptionTranslatorRegistry;
-    class IExceptionTranslator;
-    class ReporterRegistry;
-    class IReporterFactory;
-    class ITagAliasRegistry;
-    class ITestInvoker;
-    class IMutableEnumValuesRegistry;
-    struct SourceLineInfo;
-
-    class StartupExceptionRegistry;
-    class EventListenerFactory;
-
-    using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
-
-    class IRegistryHub {
-    public:
-        virtual ~IRegistryHub(); // = default
-
-        virtual ReporterRegistry const& getReporterRegistry() const = 0;
-        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
-        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
-        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
-
-
-        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
-    };
-
-    class IMutableRegistryHub {
-    public:
-        virtual ~IMutableRegistryHub(); // = default
-        virtual void registerReporter( std::string const& name, IReporterFactoryPtr factory ) = 0;
-        virtual void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) = 0;
-        virtual void registerTest(Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker) = 0;
-        virtual void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) = 0;
-        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
-        virtual void registerStartupException() noexcept = 0;
-        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
-    };
-
-    IRegistryHub const& getRegistryHub();
-    IMutableRegistryHub& getMutableRegistryHub();
-    void cleanUp();
-    std::string translateActiveException();
-
-}
-
-#endif // CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
-
-
-#ifndef CATCH_BENCHMARK_STATS_HPP_INCLUDED
-#define CATCH_BENCHMARK_STATS_HPP_INCLUDED
-
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_ESTIMATE_HPP_INCLUDED
-#define CATCH_ESTIMATE_HPP_INCLUDED
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Type>
-        struct Estimate {
-            Type point;
-            Type lower_bound;
-            Type upper_bound;
-            double confidence_interval;
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_ESTIMATE_HPP_INCLUDED
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
-#define CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
-
-namespace Catch {
-    namespace Benchmark {
-        struct OutlierClassification {
-            int samples_seen = 0;
-            int low_severe = 0;     // more than 3 times IQR below Q1
-            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
-            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
-            int high_severe = 0;    // more than 3 times IQR above Q3
-
-            constexpr int total() const {
-                return low_severe + low_mild + high_mild + high_severe;
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_OUTLIERS_CLASSIFICATION_HPP_INCLUDED
-// The fwd decl & default specialization needs to be seen by VS2017 before
-// BenchmarkStats itself, or VS2017 will report compilation error.
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    struct BenchmarkInfo {
-        std::string name;
-        double estimatedDuration;
-        int iterations;
-        unsigned int samples;
-        unsigned int resamples;
-        double clockResolution;
-        double clockCost;
-    };
-
-    // We need to keep template parameter for backwards compatibility,
-    // but we also do not want to use the template paraneter.
-    template <class Dummy>
-    struct BenchmarkStats {
-        BenchmarkInfo info;
-
-        std::vector<Benchmark::FDuration> samples;
-        Benchmark::Estimate<Benchmark::FDuration> mean;
-        Benchmark::Estimate<Benchmark::FDuration> standardDeviation;
-        Benchmark::OutlierClassification outliers;
-        double outlierVariance;
-    };
-
-
-} // end namespace Catch
-
-#endif // CATCH_BENCHMARK_STATS_HPP_INCLUDED
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_ENVIRONMENT_HPP_INCLUDED
-#define CATCH_ENVIRONMENT_HPP_INCLUDED
-
-
-namespace Catch {
-    namespace Benchmark {
-        struct EnvironmentEstimate {
-            FDuration mean;
-            OutlierClassification outliers;
-        };
-        struct Environment {
-            EnvironmentEstimate clock_resolution;
-            EnvironmentEstimate clock_cost;
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_ENVIRONMENT_HPP_INCLUDED
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_EXECUTION_PLAN_HPP_INCLUDED
-#define CATCH_EXECUTION_PLAN_HPP_INCLUDED
-
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
-#define CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
-
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_CHRONOMETER_HPP_INCLUDED
-#define CATCH_CHRONOMETER_HPP_INCLUDED
-
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_OPTIMIZER_HPP_INCLUDED
-#define CATCH_OPTIMIZER_HPP_INCLUDED
-
-#if defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)
-#   include <atomic> // atomic_thread_fence
-#endif
-
-
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-#if defined(__GNUC__) || defined(__clang__)
-        template <typename T>
-        inline void keep_memory(T* p) {
-            asm volatile("" : : "g"(p) : "memory");
-        }
-        inline void keep_memory() {
-            asm volatile("" : : : "memory");
-        }
-
-        namespace Detail {
-            inline void optimizer_barrier() { keep_memory(); }
-        } // namespace Detail
-#elif defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)
-
-#if defined(_MSVC_VER)
-#pragma optimize("", off)
-#elif defined(__IAR_SYSTEMS_ICC__)
-// For IAR the pragma only affects the following function
-#pragma optimize=disable
-#endif
-        template <typename T>
-        inline void keep_memory(T* p) {
-            // thanks @milleniumbug
-            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
-        }
-        // TODO equivalent keep_memory()
-#if defined(_MSVC_VER)
-#pragma optimize("", on)
-#endif
-
-        namespace Detail {
-            inline void optimizer_barrier() {
-                std::atomic_thread_fence(std::memory_order_seq_cst);
-            }
-        } // namespace Detail
-
-#endif
-
-        template <typename T>
-        inline void deoptimize_value(T&& x) {
-            keep_memory(&x);
-        }
-
-        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<!std::is_same<void, decltype(fn(args...))>::value> {
-            deoptimize_value(CATCH_FORWARD(fn) (CATCH_FORWARD(args)...));
-        }
-
-        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<std::is_same<void, decltype(fn(args...))>::value> {
-            CATCH_FORWARD((fn)) (CATCH_FORWARD(args)...);
-        }
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_OPTIMIZER_HPP_INCLUDED
-
-
-#ifndef CATCH_META_HPP_INCLUDED
-#define CATCH_META_HPP_INCLUDED
-
-#include <type_traits>
-
-namespace Catch {
-    template <typename>
-    struct true_given : std::true_type {};
-
-    struct is_callable_tester {
-        template <typename Fun, typename... Args>
-        static true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> test(int);
-        template <typename...>
-        static std::false_type test(...);
-    };
-
-    template <typename T>
-    struct is_callable;
-
-    template <typename Fun, typename... Args>
-    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
-
-
-#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
-    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
-    // replaced with std::invoke_result here.
-    template <typename Func, typename... U>
-    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U...>>>;
-#else
-    template <typename Func, typename... U>
-    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::result_of_t<Func(U...)>>>;
-#endif
-
-} // namespace Catch
-
-namespace mpl_{
-    struct na;
-}
-
-#endif // CATCH_META_HPP_INCLUDED
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            struct ChronometerConcept {
-                virtual void start() = 0;
-                virtual void finish() = 0;
-                virtual ~ChronometerConcept(); // = default;
-
-                ChronometerConcept() = default;
-                ChronometerConcept(ChronometerConcept const&) = default;
-                ChronometerConcept& operator=(ChronometerConcept const&) = default;
-            };
-            template <typename Clock>
-            struct ChronometerModel final : public ChronometerConcept {
-                void start() override { started = Clock::now(); }
-                void finish() override { finished = Clock::now(); }
-
-                IDuration elapsed() const {
-                    return std::chrono::duration_cast<std::chrono::nanoseconds>(
-                        finished - started );
-                }
-
-                TimePoint<Clock> started;
-                TimePoint<Clock> finished;
-            };
-        } // namespace Detail
-
-        struct Chronometer {
-        public:
-            template <typename Fun>
-            void measure(Fun&& fun) { measure(CATCH_FORWARD(fun), is_callable<Fun(int)>()); }
-
-            int runs() const { return repeats; }
-
-            Chronometer(Detail::ChronometerConcept& meter, int repeats_)
-                : impl(&meter)
-                , repeats(repeats_) {}
-
-        private:
-            template <typename Fun>
-            void measure(Fun&& fun, std::false_type) {
-                measure([&fun](int) { return fun(); }, std::true_type());
-            }
-
-            template <typename Fun>
-            void measure(Fun&& fun, std::true_type) {
-                Detail::optimizer_barrier();
-                impl->start();
-                for (int i = 0; i < repeats; ++i) invoke_deoptimized(fun, i);
-                impl->finish();
-                Detail::optimizer_barrier();
-            }
-
-            Detail::ChronometerConcept* impl;
-            int repeats;
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_CHRONOMETER_HPP_INCLUDED
-
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T, typename U>
-            struct is_related
-                : std::is_same<std::decay_t<T>, std::decay_t<U>> {};
-
-            /// We need to reinvent std::function because every piece of code that might add overhead
-            /// in a measurement context needs to have consistent performance characteristics so that we
-            /// can account for it in the measurement.
-            /// Implementations of std::function with optimizations that aren't always applicable, like
-            /// small buffer optimizations, are not uncommon.
-            /// This is effectively an implementation of std::function without any such optimizations;
-            /// it may be slow, but it is consistently slow.
-            struct BenchmarkFunction {
-            private:
-                struct callable {
-                    virtual void call(Chronometer meter) const = 0;
-                    virtual ~callable(); // = default;
-
-                    callable() = default;
-                    callable(callable&&) = default;
-                    callable& operator=(callable&&) = default;
-                };
-                template <typename Fun>
-                struct model : public callable {
-                    model(Fun&& fun_) : fun(CATCH_MOVE(fun_)) {}
-                    model(Fun const& fun_) : fun(fun_) {}
-
-                    void call(Chronometer meter) const override {
-                        call(meter, is_callable<Fun(Chronometer)>());
-                    }
-                    void call(Chronometer meter, std::true_type) const {
-                        fun(meter);
-                    }
-                    void call(Chronometer meter, std::false_type) const {
-                        meter.measure(fun);
-                    }
-
-                    Fun fun;
-                };
-
-            public:
-                BenchmarkFunction();
-
-                template <typename Fun,
-                    std::enable_if_t<!is_related<Fun, BenchmarkFunction>::value, int> = 0>
-                    BenchmarkFunction(Fun&& fun)
-                    : f(new model<std::decay_t<Fun>>(CATCH_FORWARD(fun))) {}
-
-                BenchmarkFunction( BenchmarkFunction&& that ) noexcept:
-                    f( CATCH_MOVE( that.f ) ) {}
-
-                BenchmarkFunction&
-                operator=( BenchmarkFunction&& that ) noexcept {
-                    f = CATCH_MOVE( that.f );
-                    return *this;
-                }
-
-                void operator()(Chronometer meter) const { f->call(meter); }
-
-            private:
-                Catch::Detail::unique_ptr<callable> f;
-            };
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_REPEAT_HPP_INCLUDED
-#define CATCH_REPEAT_HPP_INCLUDED
-
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Fun>
-            struct repeater {
-                void operator()(int k) const {
-                    for (int i = 0; i < k; ++i) {
-                        fun();
-                    }
-                }
-                Fun fun;
-            };
-            template <typename Fun>
-            repeater<std::decay_t<Fun>> repeat(Fun&& fun) {
-                return { CATCH_FORWARD(fun) };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_REPEAT_HPP_INCLUDED
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
-#define CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
-
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_MEASURE_HPP_INCLUDED
-#define CATCH_MEASURE_HPP_INCLUDED
-
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_COMPLETE_INVOKE_HPP_INCLUDED
-#define CATCH_COMPLETE_INVOKE_HPP_INCLUDED
-
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T>
-            struct CompleteType { using type = T; };
-            template <>
-            struct CompleteType<void> { struct type {}; };
-
-            template <typename T>
-            using CompleteType_t = typename CompleteType<T>::type;
-
-            template <typename Result>
-            struct CompleteInvoker {
-                template <typename Fun, typename... Args>
-                static Result invoke(Fun&& fun, Args&&... args) {
-                    return CATCH_FORWARD(fun)(CATCH_FORWARD(args)...);
-                }
-            };
-            template <>
-            struct CompleteInvoker<void> {
-                template <typename Fun, typename... Args>
-                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
-                    CATCH_FORWARD(fun)(CATCH_FORWARD(args)...);
-                    return {};
-                }
-            };
-
-            // invoke and not return void :(
-            template <typename Fun, typename... Args>
-            CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(Fun&& fun, Args&&... args) {
-                return CompleteInvoker<FunctionReturnType<Fun, Args...>>::invoke(CATCH_FORWARD(fun), CATCH_FORWARD(args)...);
-            }
-
-        } // namespace Detail
-
-        template <typename Fun>
-        Detail::CompleteType_t<FunctionReturnType<Fun>> user_code(Fun&& fun) {
-            return Detail::complete_invoke(CATCH_FORWARD(fun));
-        }
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_COMPLETE_INVOKE_HPP_INCLUDED
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_TIMING_HPP_INCLUDED
-#define CATCH_TIMING_HPP_INCLUDED
-
-
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Result>
-        struct Timing {
-            IDuration elapsed;
-            Result result;
-            int iterations;
-        };
-        template <typename Func, typename... Args>
-        using TimingOf = Timing<Detail::CompleteType_t<FunctionReturnType<Func, Args...>>>;
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_TIMING_HPP_INCLUDED
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock, typename Fun, typename... Args>
-            TimingOf<Fun, Args...> measure(Fun&& fun, Args&&... args) {
-                auto start = Clock::now();
-                auto&& r = Detail::complete_invoke(CATCH_FORWARD(fun), CATCH_FORWARD(args)...);
-                auto end = Clock::now();
-                auto delta = end - start;
-                return { delta, CATCH_FORWARD(r), 1 };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_MEASURE_HPP_INCLUDED
-
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock, typename Fun>
-            TimingOf<Fun, int> measure_one(Fun&& fun, int iters, std::false_type) {
-                return Detail::measure<Clock>(fun, iters);
-            }
-            template <typename Clock, typename Fun>
-            TimingOf<Fun, Chronometer> measure_one(Fun&& fun, int iters, std::true_type) {
-                Detail::ChronometerModel<Clock> meter;
-                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
-
-                return { meter.elapsed(), CATCH_MOVE(result), iters };
-            }
-
-            template <typename Clock, typename Fun>
-            using run_for_at_least_argument_t = std::conditional_t<is_callable<Fun(Chronometer)>::value, Chronometer, int>;
-
-
-            [[noreturn]]
-            void throw_optimized_away_error();
-
-            template <typename Clock, typename Fun>
-            TimingOf<Fun, run_for_at_least_argument_t<Clock, Fun>>
-                run_for_at_least(IDuration how_long,
-                                 const int initial_iterations,
-                                 Fun&& fun) {
-                auto iters = initial_iterations;
-                while (iters < (1 << 30)) {
-                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
-
-                    if (Timing.elapsed >= how_long) {
-                        return { Timing.elapsed, CATCH_MOVE(Timing.result), iters };
-                    }
-                    iters *= 2;
-                }
-                throw_optimized_away_error();
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
-
-#include <vector>
-
-namespace Catch {
-    namespace Benchmark {
-        struct ExecutionPlan {
-            int iterations_per_sample;
-            FDuration estimated_duration;
-            Detail::BenchmarkFunction benchmark;
-            FDuration warmup_time;
-            int warmup_iterations;
-
-            template <typename Clock>
-            std::vector<FDuration> run(const IConfig &cfg, Environment env) const {
-                // warmup a bit
-                Detail::run_for_at_least<Clock>(
-                    std::chrono::duration_cast<IDuration>( warmup_time ),
-                    warmup_iterations,
-                    Detail::repeat( []() { return Clock::now(); } )
-                );
-
-                std::vector<FDuration> times;
-                const auto num_samples = cfg.benchmarkSamples();
-                times.reserve( num_samples );
-                for ( size_t i = 0; i < num_samples; ++i ) {
-                    Detail::ChronometerModel<Clock> model;
-                    this->benchmark( Chronometer( model, iterations_per_sample ) );
-                    auto sample_time = model.elapsed() - env.clock_cost.mean;
-                    if ( sample_time < FDuration::zero() ) {
-                        sample_time = FDuration::zero();
-                    }
-                    times.push_back(sample_time / iterations_per_sample);
-                }
-                return times;
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_EXECUTION_PLAN_HPP_INCLUDED
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
-#define CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
-
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_STATS_HPP_INCLUDED
-#define CATCH_STATS_HPP_INCLUDED
-
-
-#include <vector>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            using sample = std::vector<double>;
-
-            double weighted_average_quantile( int k,
-                                              int q,
-                                              double* first,
-                                              double* last );
-
-            OutlierClassification
-            classify_outliers( double const* first, double const* last );
-
-            double mean( double const* first, double const* last );
-
-            double normal_cdf( double x );
-
-            double erfc_inv(double x);
-
-            double normal_quantile(double p);
-
-            Estimate<double>
-            bootstrap( double confidence_level,
-                       double* first,
-                       double* last,
-                       sample const& resample,
-                       double ( *estimator )( double const*, double const* ) );
-
-            struct bootstrap_analysis {
-                Estimate<double> mean;
-                Estimate<double> standard_deviation;
-                double outlier_variance;
-            };
-
-            bootstrap_analysis analyse_samples(double confidence_level,
-                                               unsigned int n_resamples,
-                                               double* first,
-                                               double* last);
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_STATS_HPP_INCLUDED
-
-#include <algorithm>
-#include <vector>
-#include <cmath>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock>
-            std::vector<double> resolution(int k) {
-                const size_t points = static_cast<size_t>( k + 1 );
-                // To avoid overhead from the branch inside vector::push_back,
-                // we allocate them all and then overwrite.
-                std::vector<TimePoint<Clock>> times(points);
-                for ( auto& time : times ) {
-                    time = Clock::now();
-                }
-
-                std::vector<double> deltas;
-                deltas.reserve(static_cast<size_t>(k));
-                for ( size_t idx = 1; idx < points; ++idx ) {
-                    deltas.push_back( static_cast<double>(
-                        ( times[idx] - times[idx - 1] ).count() ) );
-                }
-
-                return deltas;
-            }
-
-            constexpr auto warmup_iterations = 10000;
-            constexpr auto warmup_time = std::chrono::milliseconds(100);
-            constexpr auto minimum_ticks = 1000;
-            constexpr auto warmup_seed = 10000;
-            constexpr auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
-            constexpr auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
-            constexpr auto clock_cost_estimation_tick_limit = 100000;
-            constexpr auto clock_cost_estimation_time = std::chrono::milliseconds(10);
-            constexpr auto clock_cost_estimation_iterations = 10000;
-
-            template <typename Clock>
-            int warmup() {
-                return run_for_at_least<Clock>(warmup_time, warmup_seed, &resolution<Clock>)
-                    .iterations;
-            }
-            template <typename Clock>
-            EnvironmentEstimate estimate_clock_resolution(int iterations) {
-                auto r = run_for_at_least<Clock>(clock_resolution_estimation_time, iterations, &resolution<Clock>)
-                    .result;
-                return {
-                    FDuration(mean(r.data(), r.data() + r.size())),
-                    classify_outliers(r.data(), r.data() + r.size()),
-                };
-            }
-            template <typename Clock>
-            EnvironmentEstimate estimate_clock_cost(FDuration resolution) {
-                auto time_limit = (std::min)(
-                    resolution * clock_cost_estimation_tick_limit,
-                    FDuration(clock_cost_estimation_time_limit));
-                auto time_clock = [](int k) {
-                    return Detail::measure<Clock>([k] {
-                        for (int i = 0; i < k; ++i) {
-                            volatile auto ignored = Clock::now();
-                            (void)ignored;
-                        }
-                    }).elapsed;
-                };
-                time_clock(1);
-                int iters = clock_cost_estimation_iterations;
-                auto&& r = run_for_at_least<Clock>(clock_cost_estimation_time, iters, time_clock);
-                std::vector<double> times;
-                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
-                times.reserve(static_cast<size_t>(nsamples));
-                for ( int s = 0; s < nsamples; ++s ) {
-                    times.push_back( static_cast<double>(
-                        ( time_clock( r.iterations ) / r.iterations )
-                            .count() ) );
-                }
-                return {
-                    FDuration(mean(times.data(), times.data() + times.size())),
-                    classify_outliers(times.data(), times.data() + times.size()),
-                };
-            }
-
-            template <typename Clock>
-            Environment measure_environment() {
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-                static Catch::Detail::unique_ptr<Environment> env;
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-                if (env) {
-                    return *env;
-                }
-
-                auto iters = Detail::warmup<Clock>();
-                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
-                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
-
-                env = Catch::Detail::make_unique<Environment>( Environment{resolution, cost} );
-                return *env;
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_ANALYSE_HPP_INCLUDED
-#define CATCH_ANALYSE_HPP_INCLUDED
-
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
-#define CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
-
-
-#include <vector>
-
-namespace Catch {
-    namespace Benchmark {
-        struct SampleAnalysis {
-            std::vector<FDuration> samples;
-            Estimate<FDuration> mean;
-            Estimate<FDuration> standard_deviation;
-            OutlierClassification outliers;
-            double outlier_variance;
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
-
-
-namespace Catch {
-    class IConfig;
-
-    namespace Benchmark {
-        namespace Detail {
-            SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last);
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_ANALYSE_HPP_INCLUDED
-
-#include <algorithm>
-#include <chrono>
-#include <exception>
-#include <string>
-#include <cmath>
-
-namespace Catch {
-    namespace Benchmark {
-        struct Benchmark {
-            Benchmark(std::string&& benchmarkName)
-                : name(CATCH_MOVE(benchmarkName)) {}
-
-            template <class FUN>
-            Benchmark(std::string&& benchmarkName , FUN &&func)
-                : fun(CATCH_MOVE(func)), name(CATCH_MOVE(benchmarkName)) {}
-
-            template <typename Clock>
-            ExecutionPlan prepare(const IConfig &cfg, Environment env) {
-                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
-                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
-                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<IDuration>(run_time), 1, fun);
-                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
-                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), CATCH_MOVE(fun), std::chrono::duration_cast<FDuration>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
-            }
-
-            template <typename Clock = default_clock>
-            void run() {
-                static_assert( Clock::is_steady,
-                               "Benchmarking clock should be steady" );
-                auto const* cfg = getCurrentContext().getConfig();
-
-                auto env = Detail::measure_environment<Clock>();
-
-                getResultCapture().benchmarkPreparing(name);
-                CATCH_TRY{
-                    auto plan = user_code([&] {
-                        return prepare<Clock>(*cfg, env);
-                    });
-
-                    BenchmarkInfo info {
-                        CATCH_MOVE(name),
-                        plan.estimated_duration.count(),
-                        plan.iterations_per_sample,
-                        cfg->benchmarkSamples(),
-                        cfg->benchmarkResamples(),
-                        env.clock_resolution.mean.count(),
-                        env.clock_cost.mean.count()
-                    };
-
-                    getResultCapture().benchmarkStarting(info);
-
-                    auto samples = user_code([&] {
-                        return plan.template run<Clock>(*cfg, env);
-                    });
-
-                    auto analysis = Detail::analyse(*cfg, samples.data(), samples.data() + samples.size());
-                    BenchmarkStats<> stats{ CATCH_MOVE(info), CATCH_MOVE(analysis.samples), analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
-                    getResultCapture().benchmarkEnded(stats);
-                } CATCH_CATCH_ANON (TestFailureException const&) {
-                    getResultCapture().benchmarkFailed("Benchmark failed due to failed assertion"_sr);
-                } CATCH_CATCH_ALL{
-                    getResultCapture().benchmarkFailed(translateActiveException());
-                    // We let the exception go further up so that the
-                    // test case is marked as failed.
-                    std::rethrow_exception(std::current_exception());
-                }
-            }
-
-            // sets lambda to be used in fun *and* executes benchmark!
-            template <typename Fun, std::enable_if_t<!Detail::is_related<Fun, Benchmark>::value, int> = 0>
-                Benchmark & operator=(Fun func) {
-                auto const* cfg = getCurrentContext().getConfig();
-                if (!cfg->skipBenchmarks()) {
-                    fun = Detail::BenchmarkFunction(func);
-                    run();
-                }
-                return *this;
-            }
-
-            explicit operator bool() {
-                return true;
-            }
-
-        private:
-            Detail::BenchmarkFunction fun;
-            std::string name;
-        };
-    }
-} // namespace Catch
-
-#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
-#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
-
-#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
-    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
-        BenchmarkName = [&](int benchmarkIndex)
-
-#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
-    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
-        BenchmarkName = [&]
-
-#if defined(CATCH_CONFIG_PREFIX_ALL)
-
-#define CATCH_BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define CATCH_BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name)
-
-#else
-
-#define BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name)
-
-#endif
-
-#endif // CATCH_BENCHMARK_HPP_INCLUDED
-
-
-// Adapted from donated nonius code.
-
-#ifndef CATCH_CONSTRUCTOR_HPP_INCLUDED
-#define CATCH_CONSTRUCTOR_HPP_INCLUDED
-
-
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T, bool Destruct>
-            struct ObjectStorage
-            {
-                ObjectStorage() = default;
-
-                ObjectStorage(const ObjectStorage& other)
-                {
-                    new(&data) T(other.stored_object());
-                }
-
-                ObjectStorage(ObjectStorage&& other)
-                {
-                    new(data) T(CATCH_MOVE(other.stored_object()));
-                }
-
-                ~ObjectStorage() { destruct_on_exit<T>(); }
-
-                template <typename... Args>
-                void construct(Args&&... args)
-                {
-                    new (data) T(CATCH_FORWARD(args)...);
-                }
-
-                template <bool AllowManualDestruction = !Destruct>
-                std::enable_if_t<AllowManualDestruction> destruct()
-                {
-                    stored_object().~T();
-                }
-
-            private:
-                // If this is a constructor benchmark, destruct the underlying object
-                template <typename U>
-                void destruct_on_exit(std::enable_if_t<Destruct, U>* = nullptr) { destruct<true>(); }
-                // Otherwise, don't
-                template <typename U>
-                void destruct_on_exit(std::enable_if_t<!Destruct, U>* = nullptr) { }
-
-#if defined( __GNUC__ ) && __GNUC__ <= 6
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif
-                T& stored_object() { return *reinterpret_cast<T*>( data ); }
-
-                T const& stored_object() const {
-                    return *reinterpret_cast<T const*>( data );
-                }
-#if defined( __GNUC__ ) && __GNUC__ <= 6
-#    pragma GCC diagnostic pop
-#endif
-
-                alignas( T ) unsigned char data[sizeof( T )]{};
-            };
-        } // namespace Detail
-
-        template <typename T>
-        using storage_for = Detail::ObjectStorage<T, true>;
-
-        template <typename T>
-        using destructable_object = Detail::ObjectStorage<T, false>;
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_CONSTRUCTOR_HPP_INCLUDED
-
-#endif // CATCH_BENCHMARK_ALL_HPP_INCLUDED
-
-
-#ifndef CATCH_APPROX_HPP_INCLUDED
-#define CATCH_APPROX_HPP_INCLUDED
-
-
-
-#ifndef CATCH_TOSTRING_HPP_INCLUDED
-#define CATCH_TOSTRING_HPP_INCLUDED
-
-
-#include <vector>
-#include <cstddef>
-#include <type_traits>
-#include <string>
-
-
-
-
-/** \file
- * Wrapper for the WCHAR configuration option
- *
- * We want to support platforms that do not provide `wchar_t`, so we
- * sometimes have to disable providing wchar_t overloads through Catch2,
- * e.g. the StringMaker specialization for `std::wstring`.
- */
-
-#ifndef CATCH_CONFIG_WCHAR_HPP_INCLUDED
-#define CATCH_CONFIG_WCHAR_HPP_INCLUDED
-
-
-// We assume that WCHAR should be enabled by default, and only disabled
-// for a shortlist (so far only DJGPP) of compilers.
-
-#if defined(__DJGPP__)
-#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
-#endif // __DJGPP__
-
-#if !defined( CATCH_INTERNAL_CONFIG_NO_WCHAR ) && \
-    !defined( CATCH_CONFIG_NO_WCHAR ) && \
-    !defined( CATCH_CONFIG_WCHAR )
-#    define CATCH_CONFIG_WCHAR
-#endif
-
-#endif // CATCH_CONFIG_WCHAR_HPP_INCLUDED
-
-
-#ifndef CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
-#define CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
-
-
-#include <iosfwd>
-#include <cstddef>
-#include <ostream>
-#include <string>
-
-namespace Catch {
-
-    class ReusableStringStream : Detail::NonCopyable {
-        std::size_t m_index;
-        std::ostream* m_oss;
-    public:
-        ReusableStringStream();
-        ~ReusableStringStream();
-
-        //! Returns the serialized state
-        std::string str() const;
-        //! Sets internal state to `str`
-        void str(std::string const& str);
-
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC diagnostic push
-// Old versions of GCC do not understand -Wnonnull-compare
-#pragma GCC diagnostic ignored "-Wpragmas"
-// Streaming a function pointer triggers Waddress and Wnonnull-compare
-// on GCC, because it implicitly converts it to bool and then decides
-// that the check it uses (a? true : false) is tautological and cannot
-// be null...
-#pragma GCC diagnostic ignored "-Waddress"
-#pragma GCC diagnostic ignored "-Wnonnull-compare"
-#endif
-
-        template<typename T>
-        auto operator << ( T const& value ) -> ReusableStringStream& {
-            *m_oss << value;
-            return *this;
-        }
-
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-        auto get() -> std::ostream& { return *m_oss; }
-    };
-}
-
-#endif // CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
-
-
-#ifndef CATCH_VOID_TYPE_HPP_INCLUDED
-#define CATCH_VOID_TYPE_HPP_INCLUDED
-
-
-namespace Catch {
-    namespace Detail {
-
-        template <typename...>
-        struct make_void { using type = void; };
-
-        template <typename... Ts>
-        using void_t = typename make_void<Ts...>::type;
-
-    } // namespace Detail
-} // namespace Catch
-
-
-#endif // CATCH_VOID_TYPE_HPP_INCLUDED
-
-
-#ifndef CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
-#define CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
-
-
-#include <vector>
-
-namespace Catch {
-
-    namespace Detail {
-        struct EnumInfo {
-            StringRef m_name;
-            std::vector<std::pair<int, StringRef>> m_values;
-
-            ~EnumInfo();
-
-            StringRef lookup( int value ) const;
-        };
-    } // namespace Detail
-
-    class IMutableEnumValuesRegistry {
-    public:
-        virtual ~IMutableEnumValuesRegistry(); // = default;
-
-        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
-
-        template<typename E>
-        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
-            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
-            std::vector<int> intValues;
-            intValues.reserve( values.size() );
-            for( auto enumValue : values )
-                intValues.push_back( static_cast<int>( enumValue ) );
-            return registerEnum( enumName, allEnums, intValues );
-        }
-    };
-
-} // Catch
-
-#endif // CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-#include <string_view>
-#endif
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
-#endif
-
-// We need a dummy global operator<< so we can bring it into Catch namespace later
-struct Catch_global_namespace_dummy{};
-std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
-
-namespace Catch {
-    // Bring in global namespace operator<< for ADL lookup in
-    // `IsStreamInsertable` below.
-    using ::operator<<;
-
-    namespace Detail {
-
-        inline std::size_t catch_strnlen(const char *str, std::size_t n) {
-            auto ret = std::char_traits<char>::find(str, n, '\0');
-            if (ret != nullptr) {
-                return static_cast<std::size_t>(ret - str);
-            }
-            return n;
-        }
-
-        constexpr StringRef unprintableString = "{?}"_sr;
-
-        //! Encases `string in quotes, and optionally escapes invisibles
-        std::string convertIntoString( StringRef string, bool escapeInvisibles );
-
-        //! Encases `string` in quotes, and escapes invisibles if user requested
-        //! it via CLI
-        std::string convertIntoString( StringRef string );
-
-        std::string rawMemoryToString( const void *object, std::size_t size );
-
-        template<typename T>
-        std::string rawMemoryToString( const T& object ) {
-          return rawMemoryToString( &object, sizeof(object) );
-        }
-
-        template<typename T>
-        class IsStreamInsertable {
-            template<typename Stream, typename U>
-            static auto test(int)
-                -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
-
-            template<typename, typename>
-            static auto test(...)->std::false_type;
-
-        public:
-            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
-        };
-
-        template<typename E>
-        std::string convertUnknownEnumToString( E e );
-
-        template<typename T>
-        std::enable_if_t<
-            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
-        std::string> convertUnstreamable( T const& ) {
-            return std::string(Detail::unprintableString);
-        }
-        template<typename T>
-        std::enable_if_t<
-            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
-         std::string> convertUnstreamable(T const& ex) {
-            return ex.what();
-        }
-
-
-        template<typename T>
-        std::enable_if_t<
-            std::is_enum<T>::value,
-        std::string> convertUnstreamable( T const& value ) {
-            return convertUnknownEnumToString( value );
-        }
-
-#if defined(_MANAGED)
-        //! Convert a CLR string to a utf8 std::string
-        template<typename T>
-        std::string clrReferenceToString( T^ ref ) {
-            if (ref == nullptr)
-                return std::string("null");
-            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
-            cli::pin_ptr<System::Byte> p = &bytes[0];
-            return std::string(reinterpret_cast<char const *>(p), bytes->Length);
-        }
-#endif
-
-    } // namespace Detail
-
-
-    template <typename T, typename = void>
-    struct StringMaker {
-        template <typename Fake = T>
-        static
-        std::enable_if_t<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
-            convert(const Fake& value) {
-                ReusableStringStream rss;
-                // NB: call using the function-like syntax to avoid ambiguity with
-                // user-defined templated operator<< under clang.
-                rss.operator<<(value);
-                return rss.str();
-        }
-
-        template <typename Fake = T>
-        static
-        std::enable_if_t<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
-            convert( const Fake& value ) {
-#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
-            return Detail::convertUnstreamable(value);
-#else
-            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
-#endif
-        }
-    };
-
-    namespace Detail {
-
-        // This function dispatches all stringification requests inside of Catch.
-        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
-        template <typename T>
-        std::string stringify(const T& e) {
-            return ::Catch::StringMaker<std::remove_cv_t<std::remove_reference_t<T>>>::convert(e);
-        }
-
-        template<typename E>
-        std::string convertUnknownEnumToString( E e ) {
-            return ::Catch::Detail::stringify(static_cast<std::underlying_type_t<E>>(e));
-        }
-
-#if defined(_MANAGED)
-        template <typename T>
-        std::string stringify( T^ e ) {
-            return ::Catch::StringMaker<T^>::convert(e);
-        }
-#endif
-
-    } // namespace Detail
-
-    // Some predefined specializations
-
-    template<>
-    struct StringMaker<std::string> {
-        static std::string convert(const std::string& str);
-    };
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-    template<>
-    struct StringMaker<std::string_view> {
-        static std::string convert(std::string_view str);
-    };
-#endif
-
-    template<>
-    struct StringMaker<char const *> {
-        static std::string convert(char const * str);
-    };
-    template<>
-    struct StringMaker<char *> {
-        static std::string convert(char * str);
-    };
-
-#if defined(CATCH_CONFIG_WCHAR)
-    template<>
-    struct StringMaker<std::wstring> {
-        static std::string convert(const std::wstring& wstr);
-    };
-
-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-    template<>
-    struct StringMaker<std::wstring_view> {
-        static std::string convert(std::wstring_view str);
-    };
-# endif
-
-    template<>
-    struct StringMaker<wchar_t const *> {
-        static std::string convert(wchar_t const * str);
-    };
-    template<>
-    struct StringMaker<wchar_t *> {
-        static std::string convert(wchar_t * str);
-    };
-#endif // CATCH_CONFIG_WCHAR
-
-    template<size_t SZ>
-    struct StringMaker<char[SZ]> {
-        static std::string convert(char const* str) {
-            return Detail::convertIntoString(
-                StringRef( str, Detail::catch_strnlen( str, SZ ) ) );
-        }
-    };
-    template<size_t SZ>
-    struct StringMaker<signed char[SZ]> {
-        static std::string convert(signed char const* str) {
-            auto reinterpreted = reinterpret_cast<char const*>(str);
-            return Detail::convertIntoString(
-                StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
-        }
-    };
-    template<size_t SZ>
-    struct StringMaker<unsigned char[SZ]> {
-        static std::string convert(unsigned char const* str) {
-            auto reinterpreted = reinterpret_cast<char const*>(str);
-            return Detail::convertIntoString(
-                StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
-        }
-    };
-
-#if defined(CATCH_CONFIG_CPP17_BYTE)
-    template<>
-    struct StringMaker<std::byte> {
-        static std::string convert(std::byte value);
-    };
-#endif // defined(CATCH_CONFIG_CPP17_BYTE)
-    template<>
-    struct StringMaker<int> {
-        static std::string convert(int value);
-    };
-    template<>
-    struct StringMaker<long> {
-        static std::string convert(long value);
-    };
-    template<>
-    struct StringMaker<long long> {
-        static std::string convert(long long value);
-    };
-    template<>
-    struct StringMaker<unsigned int> {
-        static std::string convert(unsigned int value);
-    };
-    template<>
-    struct StringMaker<unsigned long> {
-        static std::string convert(unsigned long value);
-    };
-    template<>
-    struct StringMaker<unsigned long long> {
-        static std::string convert(unsigned long long value);
-    };
-
-    template<>
-    struct StringMaker<bool> {
-        static std::string convert(bool b) {
-            using namespace std::string_literals;
-            return b ? "true"s : "false"s;
-        }
-    };
-
-    template<>
-    struct StringMaker<char> {
-        static std::string convert(char c);
-    };
-    template<>
-    struct StringMaker<signed char> {
-        static std::string convert(signed char value);
-    };
-    template<>
-    struct StringMaker<unsigned char> {
-        static std::string convert(unsigned char value);
-    };
-
-    template<>
-    struct StringMaker<std::nullptr_t> {
-        static std::string convert(std::nullptr_t) {
-            using namespace std::string_literals;
-            return "nullptr"s;
-        }
-    };
-
-    template<>
-    struct StringMaker<float> {
-        static std::string convert(float value);
-        CATCH_EXPORT static int precision;
-    };
-
-    template<>
-    struct StringMaker<double> {
-        static std::string convert(double value);
-        CATCH_EXPORT static int precision;
-    };
-
-    template <typename T>
-    struct StringMaker<T*> {
-        template <typename U>
-        static std::string convert(U* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
-
-    template <typename R, typename C>
-    struct StringMaker<R C::*> {
-        static std::string convert(R C::* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
-
-#if defined(_MANAGED)
-    template <typename T>
-    struct StringMaker<T^> {
-        static std::string convert( T^ ref ) {
-            return ::Catch::Detail::clrReferenceToString(ref);
-        }
-    };
-#endif
-
-    namespace Detail {
-        template<typename InputIterator, typename Sentinel = InputIterator>
-        std::string rangeToString(InputIterator first, Sentinel last) {
-            ReusableStringStream rss;
-            rss << "{ ";
-            if (first != last) {
-                rss << ::Catch::Detail::stringify(*first);
-                for (++first; first != last; ++first)
-                    rss << ", " << ::Catch::Detail::stringify(*first);
-            }
-            rss << " }";
-            return rss.str();
-        }
-    }
-
-} // namespace Catch
-
-//////////////////////////////////////////////////////
-// Separate std-lib types stringification, so it can be selectively enabled
-// This means that we do not bring in their headers
-
-#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
-#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
-#endif
-
-// Separate std::pair specialization
-#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
-#include <utility>
-namespace Catch {
-    template<typename T1, typename T2>
-    struct StringMaker<std::pair<T1, T2> > {
-        static std::string convert(const std::pair<T1, T2>& pair) {
-            ReusableStringStream rss;
-            rss << "{ "
-                << ::Catch::Detail::stringify(pair.first)
-                << ", "
-                << ::Catch::Detail::stringify(pair.second)
-                << " }";
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
-
-#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
-#include <optional>
-namespace Catch {
-    template<typename T>
-    struct StringMaker<std::optional<T> > {
-        static std::string convert(const std::optional<T>& optional) {
-            if (optional.has_value()) {
-                return ::Catch::Detail::stringify(*optional);
-            } else {
-                return "{ }";
-            }
-        }
-    };
-    template <>
-    struct StringMaker<std::nullopt_t> {
-        static std::string convert(const std::nullopt_t&) {
-            return "{ }";
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
-
-// Separate std::tuple specialization
-#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
-#include <tuple>
-namespace Catch {
-    namespace Detail {
-        template<
-            typename Tuple,
-            std::size_t N = 0,
-            bool = (N < std::tuple_size<Tuple>::value)
-            >
-            struct TupleElementPrinter {
-            static void print(const Tuple& tuple, std::ostream& os) {
-                os << (N ? ", " : " ")
-                    << ::Catch::Detail::stringify(std::get<N>(tuple));
-                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
-            }
-        };
-
-        template<
-            typename Tuple,
-            std::size_t N
-        >
-            struct TupleElementPrinter<Tuple, N, false> {
-            static void print(const Tuple&, std::ostream&) {}
-        };
-
-    }
-
-
-    template<typename ...Types>
-    struct StringMaker<std::tuple<Types...>> {
-        static std::string convert(const std::tuple<Types...>& tuple) {
-            ReusableStringStream rss;
-            rss << '{';
-            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
-            rss << " }";
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
-
-#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
-#include <variant>
-namespace Catch {
-    template<>
-    struct StringMaker<std::monostate> {
-        static std::string convert(const std::monostate&) {
-            return "{ }";
-        }
-    };
-
-    template<typename... Elements>
-    struct StringMaker<std::variant<Elements...>> {
-        static std::string convert(const std::variant<Elements...>& variant) {
-            if (variant.valueless_by_exception()) {
-                return "{valueless variant}";
-            } else {
-                return std::visit(
-                    [](const auto& value) {
-                        return ::Catch::Detail::stringify(value);
-                    },
-                    variant
-                );
-            }
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
-
-namespace Catch {
-    // Import begin/ end from std here
-    using std::begin;
-    using std::end;
-
-    namespace Detail {
-        template <typename T, typename = void>
-        struct is_range_impl : std::false_type {};
-
-        template <typename T>
-        struct is_range_impl<T, void_t<decltype(begin(std::declval<T>()))>> : std::true_type {};
-    } // namespace Detail
-
-    template <typename T>
-    struct is_range : Detail::is_range_impl<T> {};
-
-#if defined(_MANAGED) // Managed types are never ranges
-    template <typename T>
-    struct is_range<T^> {
-        static const bool value = false;
-    };
-#endif
-
-    template<typename Range>
-    std::string rangeToString( Range const& range ) {
-        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
-    }
-
-    // Handle vector<bool> specially
-    template<typename Allocator>
-    std::string rangeToString( std::vector<bool, Allocator> const& v ) {
-        ReusableStringStream rss;
-        rss << "{ ";
-        bool first = true;
-        for( bool b : v ) {
-            if( first )
-                first = false;
-            else
-                rss << ", ";
-            rss << ::Catch::Detail::stringify( b );
-        }
-        rss << " }";
-        return rss.str();
-    }
-
-    template<typename R>
-    struct StringMaker<R, std::enable_if_t<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>> {
-        static std::string convert( R const& range ) {
-            return rangeToString( range );
-        }
-    };
-
-    template <typename T, size_t SZ>
-    struct StringMaker<T[SZ]> {
-        static std::string convert(T const(&arr)[SZ]) {
-            return rangeToString(arr);
-        }
-    };
-
-
-} // namespace Catch
-
-// Separate std::chrono::duration specialization
-#include <ctime>
-#include <ratio>
-#include <chrono>
-
-
-namespace Catch {
-
-template <class Ratio>
-struct ratio_string {
-    static std::string symbol() {
-        Catch::ReusableStringStream rss;
-        rss << '[' << Ratio::num << '/'
-            << Ratio::den << ']';
-        return rss.str();
-    }
-};
-
-template <>
-struct ratio_string<std::atto> {
-    static char symbol() { return 'a'; }
-};
-template <>
-struct ratio_string<std::femto> {
-    static char symbol() { return 'f'; }
-};
-template <>
-struct ratio_string<std::pico> {
-    static char symbol() { return 'p'; }
-};
-template <>
-struct ratio_string<std::nano> {
-    static char symbol() { return 'n'; }
-};
-template <>
-struct ratio_string<std::micro> {
-    static char symbol() { return 'u'; }
-};
-template <>
-struct ratio_string<std::milli> {
-    static char symbol() { return 'm'; }
-};
-
-    ////////////
-    // std::chrono::duration specializations
-    template<typename Value, typename Ratio>
-    struct StringMaker<std::chrono::duration<Value, Ratio>> {
-        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " s";
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " m";
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " h";
-            return rss.str();
-        }
-    };
-
-    ////////////
-    // std::chrono::time_point specialization
-    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
-    template<typename Clock, typename Duration>
-    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
-        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
-            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
-        }
-    };
-    // std::chrono::time_point<system_clock> specialization
-    template<typename Duration>
-    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
-        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
-            auto converted = std::chrono::system_clock::to_time_t(time_point);
-
-#ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &converted);
-#else
-            std::tm* timeInfo = std::gmtime(&converted);
-#endif
-
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
-
-#ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-#else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
-#endif
-            return std::string(timeStamp, timeStampSize - 1);
-        }
-    };
-}
-
-
-#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
-namespace Catch { \
-    template<> struct StringMaker<enumName> { \
-        static std::string convert( enumName value ) { \
-            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
-            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
-        } \
-    }; \
-}
-
-#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-#endif // CATCH_TOSTRING_HPP_INCLUDED
-
-#include <type_traits>
-
-namespace Catch {
-
-    class Approx {
-    private:
-        bool equalityComparisonImpl(double other) const;
-        // Sets and validates the new margin (margin >= 0)
-        void setMargin(double margin);
-        // Sets and validates the new epsilon (0 < epsilon < 1)
-        void setEpsilon(double epsilon);
-
-    public:
-        explicit Approx ( double value );
-
-        static Approx custom();
-
-        Approx operator-() const;
-
-        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        Approx operator()( T const& value ) const {
-            Approx approx( static_cast<double>(value) );
-            approx.m_epsilon = m_epsilon;
-            approx.m_margin = m_margin;
-            approx.m_scale = m_scale;
-            return approx;
-        }
-
-        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        explicit Approx( T const& value ): Approx(static_cast<double>(value))
-        {}
-
-
-        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend bool operator == ( const T& lhs, Approx const& rhs ) {
-            auto lhs_v = static_cast<double>(lhs);
-            return rhs.equalityComparisonImpl(lhs_v);
-        }
-
-        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend bool operator == ( Approx const& lhs, const T& rhs ) {
-            return operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend bool operator != ( T const& lhs, Approx const& rhs ) {
-            return !operator==( lhs, rhs );
-        }
-
-        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend bool operator != ( Approx const& lhs, T const& rhs ) {
-            return !operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        Approx& epsilon( T const& newEpsilon ) {
-            const auto epsilonAsDouble = static_cast<double>(newEpsilon);
-            setEpsilon(epsilonAsDouble);
-            return *this;
-        }
-
-        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        Approx& margin( T const& newMargin ) {
-            const auto marginAsDouble = static_cast<double>(newMargin);
-            setMargin(marginAsDouble);
-            return *this;
-        }
-
-        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        Approx& scale( T const& newScale ) {
-            m_scale = static_cast<double>(newScale);
-            return *this;
-        }
-
-        std::string toString() const;
-
-    private:
-        double m_epsilon;
-        double m_margin;
-        double m_scale;
-        double m_value;
-    };
-
-namespace literals {
-    Approx operator ""_a(long double val);
-    Approx operator ""_a(unsigned long long val);
-} // end namespace literals
-
-template<>
-struct StringMaker<Catch::Approx> {
-    static std::string convert(Catch::Approx const& value);
-};
-
-} // end namespace Catch
-
-#endif // CATCH_APPROX_HPP_INCLUDED
-
-
-#ifndef CATCH_ASSERTION_INFO_HPP_INCLUDED
-#define CATCH_ASSERTION_INFO_HPP_INCLUDED
-
-
-
-#ifndef CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
-#define CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
-
-#include <cstddef>
-#include <iosfwd>
-
-namespace Catch {
-
-    struct SourceLineInfo {
-
-        SourceLineInfo() = delete;
-        constexpr SourceLineInfo( char const* _file, std::size_t _line ) noexcept:
-            file( _file ),
-            line( _line )
-        {}
-
-        bool operator == ( SourceLineInfo const& other ) const noexcept;
-        bool operator < ( SourceLineInfo const& other ) const noexcept;
-
-        char const* file;
-        std::size_t line;
-
-        friend std::ostream& operator << (std::ostream& os, SourceLineInfo const& info);
-    };
-}
-
-#define CATCH_INTERNAL_LINEINFO \
-    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
-
-#endif // CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
-
-namespace Catch {
-
-    struct AssertionInfo {
-        // AssertionInfo() = delete;
-
-        StringRef macroName;
-        SourceLineInfo lineInfo;
-        StringRef capturedExpression;
-        ResultDisposition::Flags resultDisposition;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_ASSERTION_INFO_HPP_INCLUDED
-
-
-#ifndef CATCH_ASSERTION_RESULT_HPP_INCLUDED
-#define CATCH_ASSERTION_RESULT_HPP_INCLUDED
-
-
-
-#ifndef CATCH_LAZY_EXPR_HPP_INCLUDED
-#define CATCH_LAZY_EXPR_HPP_INCLUDED
-
-#include <iosfwd>
-
-namespace Catch {
-
-    class ITransientExpression;
-
-    class LazyExpression {
-        friend class AssertionHandler;
-        friend struct AssertionStats;
-        friend class RunContext;
-
-        ITransientExpression const* m_transientExpression = nullptr;
-        bool m_isNegated;
-    public:
-        constexpr LazyExpression( bool isNegated ):
-            m_isNegated(isNegated)
-        {}
-        constexpr LazyExpression(LazyExpression const& other) = default;
-        LazyExpression& operator = ( LazyExpression const& ) = delete;
-
-        constexpr explicit operator bool() const {
-            return m_transientExpression != nullptr;
-        }
-
-        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
-    };
-
-} // namespace Catch
-
-#endif // CATCH_LAZY_EXPR_HPP_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    struct AssertionResultData
-    {
-        AssertionResultData() = delete;
-
-        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
-
-        std::string message;
-        mutable std::string reconstructedExpression;
-        LazyExpression lazyExpression;
-        ResultWas::OfType resultType;
-
-        std::string reconstructExpression() const;
-    };
-
-    class AssertionResult {
-    public:
-        AssertionResult() = delete;
-        AssertionResult( AssertionInfo const& info, AssertionResultData&& data );
-
-        bool isOk() const;
-        bool succeeded() const;
-        ResultWas::OfType getResultType() const;
-        bool hasExpression() const;
-        bool hasMessage() const;
-        std::string getExpression() const;
-        std::string getExpressionInMacro() const;
-        bool hasExpandedExpression() const;
-        std::string getExpandedExpression() const;
-        StringRef getMessage() const;
-        SourceLineInfo getSourceInfo() const;
-        StringRef getTestMacroName() const;
-
-    //protected:
-        AssertionInfo m_info;
-        AssertionResultData m_resultData;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_ASSERTION_RESULT_HPP_INCLUDED
-
-
-#ifndef CATCH_CASE_SENSITIVE_HPP_INCLUDED
-#define CATCH_CASE_SENSITIVE_HPP_INCLUDED
-
-namespace Catch {
-
-    enum class CaseSensitive { Yes, No };
-
-} // namespace Catch
-
-#endif // CATCH_CASE_SENSITIVE_HPP_INCLUDED
-
-
-#ifndef CATCH_CONFIG_HPP_INCLUDED
-#define CATCH_CONFIG_HPP_INCLUDED
-
-
-
-#ifndef CATCH_TEST_SPEC_HPP_INCLUDED
-#define CATCH_TEST_SPEC_HPP_INCLUDED
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-
-
-#ifndef CATCH_WILDCARD_PATTERN_HPP_INCLUDED
-#define CATCH_WILDCARD_PATTERN_HPP_INCLUDED
-
-
-#include <string>
-
-namespace Catch
-{
-    class WildcardPattern {
-        enum WildcardPosition {
-            NoWildcard = 0,
-            WildcardAtStart = 1,
-            WildcardAtEnd = 2,
-            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
-        };
-
-    public:
-
-        WildcardPattern( std::string const& pattern, CaseSensitive caseSensitivity );
-        bool matches( std::string const& str ) const;
-
-    private:
-        std::string normaliseString( std::string const& str ) const;
-        CaseSensitive m_caseSensitivity;
-        WildcardPosition m_wildcard = NoWildcard;
-        std::string m_pattern;
-    };
-}
-
-#endif // CATCH_WILDCARD_PATTERN_HPP_INCLUDED
-
-#include <iosfwd>
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    class IConfig;
-    struct TestCaseInfo;
-    class TestCaseHandle;
-
-    class TestSpec {
-
-        class Pattern {
-        public:
-            explicit Pattern( std::string const& name );
-            virtual ~Pattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
-            std::string const& name() const;
-        private:
-            virtual void serializeTo( std::ostream& out ) const = 0;
-            // Writes string that would be reparsed into the pattern
-            friend std::ostream& operator<<(std::ostream& out,
-                                            Pattern const& pattern) {
-                pattern.serializeTo( out );
-                return out;
-            }
-
-            std::string const m_name;
-        };
-
-        class NamePattern : public Pattern {
-        public:
-            explicit NamePattern( std::string const& name, std::string const& filterString );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            void serializeTo( std::ostream& out ) const override;
-
-            WildcardPattern m_wildcardPattern;
-        };
-
-        class TagPattern : public Pattern {
-        public:
-            explicit TagPattern( std::string const& tag, std::string const& filterString );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            void serializeTo( std::ostream& out ) const override;
-
-            std::string m_tag;
-        };
-
-        struct Filter {
-            std::vector<Detail::unique_ptr<Pattern>> m_required;
-            std::vector<Detail::unique_ptr<Pattern>> m_forbidden;
-
-            //! Serializes this filter into a string that would be parsed into
-            //! an equivalent filter
-            void serializeTo( std::ostream& out ) const;
-            friend std::ostream& operator<<(std::ostream& out, Filter const& f) {
-                f.serializeTo( out );
-                return out;
-            }
-
-            bool matches( TestCaseInfo const& testCase ) const;
-        };
-
-        static std::string extractFilterName( Filter const& filter );
-
-    public:
-        struct FilterMatch {
-            std::string name;
-            std::vector<TestCaseHandle const*> tests;
-        };
-        using Matches = std::vector<FilterMatch>;
-        using vectorStrings = std::vector<std::string>;
-
-        bool hasFilters() const;
-        bool matches( TestCaseInfo const& testCase ) const;
-        Matches matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const;
-        const vectorStrings & getInvalidSpecs() const;
-
-    private:
-        std::vector<Filter> m_filters;
-        std::vector<std::string> m_invalidSpecs;
-
-        friend class TestSpecParser;
-        //! Serializes this test spec into a string that would be parsed into
-        //! equivalent test spec
-        void serializeTo( std::ostream& out ) const;
-        friend std::ostream& operator<<(std::ostream& out,
-                                        TestSpec const& spec) {
-            spec.serializeTo( out );
-            return out;
-        }
-    };
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-#endif // CATCH_TEST_SPEC_HPP_INCLUDED
-
-
-#ifndef CATCH_OPTIONAL_HPP_INCLUDED
-#define CATCH_OPTIONAL_HPP_INCLUDED
-
-
-#include <cassert>
-
-namespace Catch {
-
-    // An optional type
-    template<typename T>
-    class Optional {
-    public:
-        Optional(): nullableValue( nullptr ) {}
-        ~Optional() { reset(); }
-
-        Optional( T const& _value ):
-            nullableValue( new ( storage ) T( _value ) ) {}
-        Optional( T&& _value ):
-            nullableValue( new ( storage ) T( CATCH_MOVE( _value ) ) ) {}
-
-        Optional& operator=( T const& _value ) {
-            reset();
-            nullableValue = new ( storage ) T( _value );
-            return *this;
-        }
-        Optional& operator=( T&& _value ) {
-            reset();
-            nullableValue = new ( storage ) T( CATCH_MOVE( _value ) );
-            return *this;
-        }
-
-        Optional( Optional const& _other ):
-            nullableValue( _other ? new ( storage ) T( *_other ) : nullptr ) {}
-        Optional( Optional&& _other ):
-            nullableValue( _other ? new ( storage ) T( CATCH_MOVE( *_other ) )
-                                  : nullptr ) {}
-
-        Optional& operator=( Optional const& _other ) {
-            if ( &_other != this ) {
-                reset();
-                if ( _other ) { nullableValue = new ( storage ) T( *_other ); }
-            }
-            return *this;
-        }
-        Optional& operator=( Optional&& _other ) {
-            if ( &_other != this ) {
-                reset();
-                if ( _other ) {
-                    nullableValue = new ( storage ) T( CATCH_MOVE( *_other ) );
-                }
-            }
-            return *this;
-        }
-
-        void reset() {
-            if ( nullableValue ) { nullableValue->~T(); }
-            nullableValue = nullptr;
-        }
-
-        T& operator*() {
-            assert(nullableValue);
-            return *nullableValue;
-        }
-        T const& operator*() const {
-            assert(nullableValue);
-            return *nullableValue;
-        }
-        T* operator->() {
-            assert(nullableValue);
-            return nullableValue;
-        }
-        const T* operator->() const {
-            assert(nullableValue);
-            return nullableValue;
-        }
-
-        T valueOr( T const& defaultValue ) const {
-            return nullableValue ? *nullableValue : defaultValue;
-        }
-
-        bool some() const { return nullableValue != nullptr; }
-        bool none() const { return nullableValue == nullptr; }
-
-        bool operator !() const { return nullableValue == nullptr; }
-        explicit operator bool() const {
-            return some();
-        }
-
-        friend bool operator==(Optional const& a, Optional const& b) {
-            if (a.none() && b.none()) {
-                return true;
-            } else if (a.some() && b.some()) {
-                return *a == *b;
-            } else {
-                return false;
-            }
-        }
-        friend bool operator!=(Optional const& a, Optional const& b) {
-            return !( a == b );
-        }
-
-    private:
-        T* nullableValue;
-        alignas(alignof(T)) char storage[sizeof(T)];
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_OPTIONAL_HPP_INCLUDED
-
-
-#ifndef CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
-#define CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
-
-#include <cstdint>
-
-namespace Catch {
-
-    enum class GenerateFrom {
-        Time,
-        RandomDevice,
-        //! Currently equivalent to RandomDevice, but can change at any point
-        Default
-    };
-
-    std::uint32_t generateRandomSeed(GenerateFrom from);
-
-} // end namespace Catch
-
-#endif // CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
-
-
-#ifndef CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
-#define CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
-
-
-#include <map>
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    enum class ColourMode : std::uint8_t;
-
-    namespace Detail {
-        //! Splits the reporter spec into reporter name and kv-pair options
-        std::vector<std::string> splitReporterSpec( StringRef reporterSpec );
-
-        Optional<ColourMode> stringToColourMode( StringRef colourMode );
-    }
-
-    /**
-     * Structured reporter spec that a reporter can be created from
-     *
-     * Parsing has been validated, but semantics have not. This means e.g.
-     * that the colour mode is known to Catch2, but it might not be
-     * compiled into the binary, and the output filename might not be
-     * openable.
-     */
-    class ReporterSpec {
-        std::string m_name;
-        Optional<std::string> m_outputFileName;
-        Optional<ColourMode> m_colourMode;
-        std::map<std::string, std::string> m_customOptions;
-
-        friend bool operator==( ReporterSpec const& lhs,
-                                ReporterSpec const& rhs );
-        friend bool operator!=( ReporterSpec const& lhs,
-                                ReporterSpec const& rhs ) {
-            return !( lhs == rhs );
-        }
-
-    public:
-        ReporterSpec(
-            std::string name,
-            Optional<std::string> outputFileName,
-            Optional<ColourMode> colourMode,
-            std::map<std::string, std::string> customOptions );
-
-        std::string const& name() const { return m_name; }
-
-        Optional<std::string> const& outputFile() const {
-            return m_outputFileName;
-        }
-
-        Optional<ColourMode> const& colourMode() const { return m_colourMode; }
-
-        std::map<std::string, std::string> const& customOptions() const {
-            return m_customOptions;
-        }
-    };
-
-    /**
-     * Parses provided reporter spec string into
-     *
-     * Returns empty optional on errors, e.g.
-     *  * field that is not first and not a key+value pair
-     *  * duplicated keys in kv pair
-     *  * unknown catch reporter option
-     *  * empty key/value in an custom kv pair
-     *  * ...
-     */
-    Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec );
-
-}
-
-#endif // CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
-
-#include <chrono>
-#include <map>
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    class IStream;
-
-    /**
-     * `ReporterSpec` but with the defaults filled in.
-     *
-     * Like `ReporterSpec`, the semantics are unchecked.
-     */
-    struct ProcessedReporterSpec {
-        std::string name;
-        std::string outputFilename;
-        ColourMode colourMode;
-        std::map<std::string, std::string> customOptions;
-        friend bool operator==( ProcessedReporterSpec const& lhs,
-                                ProcessedReporterSpec const& rhs );
-        friend bool operator!=( ProcessedReporterSpec const& lhs,
-                                ProcessedReporterSpec const& rhs ) {
-            return !( lhs == rhs );
-        }
-    };
-
-    struct ConfigData {
-
-        bool listTests = false;
-        bool listTags = false;
-        bool listReporters = false;
-        bool listListeners = false;
-
-        bool showSuccessfulTests = false;
-        bool shouldDebugBreak = false;
-        bool noThrow = false;
-        bool showHelp = false;
-        bool showInvisibles = false;
-        bool filenamesAsTags = false;
-        bool libIdentify = false;
-        bool allowZeroTests = false;
-
-        int abortAfter = -1;
-        uint32_t rngSeed = generateRandomSeed(GenerateFrom::Default);
-
-        unsigned int shardCount = 1;
-        unsigned int shardIndex = 0;
-
-        bool skipBenchmarks = false;
-        bool benchmarkNoAnalysis = false;
-        unsigned int benchmarkSamples = 100;
-        double benchmarkConfidenceInterval = 0.95;
-        unsigned int benchmarkResamples = 100'000;
-        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
-
-        Verbosity verbosity = Verbosity::Normal;
-        WarnAbout::What warnings = WarnAbout::Nothing;
-        ShowDurations showDurations = ShowDurations::DefaultForReporter;
-        double minDuration = -1;
-        TestRunOrder runOrder = TestRunOrder::Declared;
-        ColourMode defaultColourMode = ColourMode::PlatformDefault;
-        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
-
-        std::string defaultOutputFilename;
-        std::string name;
-        std::string processName;
-        std::vector<ReporterSpec> reporterSpecifications;
-
-        std::vector<std::string> testsOrTags;
-        std::vector<std::string> sectionsToRun;
-    };
-
-
-    class Config : public IConfig {
-    public:
-
-        Config() = default;
-        Config( ConfigData const& data );
-        ~Config() override; // = default in the cpp file
-
-        bool listTests() const;
-        bool listTags() const;
-        bool listReporters() const;
-        bool listListeners() const;
-
-        std::vector<ReporterSpec> const& getReporterSpecs() const;
-        std::vector<ProcessedReporterSpec> const&
-        getProcessedReporterSpecs() const;
-
-        std::vector<std::string> const& getTestsOrTags() const override;
-        std::vector<std::string> const& getSectionsToRun() const override;
-
-        TestSpec const& testSpec() const override;
-        bool hasTestFilters() const override;
-
-        bool showHelp() const;
-
-        // IConfig interface
-        bool allowThrows() const override;
-        StringRef name() const override;
-        bool includeSuccessfulResults() const override;
-        bool warnAboutMissingAssertions() const override;
-        bool warnAboutUnmatchedTestSpecs() const override;
-        bool zeroTestsCountAsSuccess() const override;
-        ShowDurations showDurations() const override;
-        double minDuration() const override;
-        TestRunOrder runOrder() const override;
-        uint32_t rngSeed() const override;
-        unsigned int shardCount() const override;
-        unsigned int shardIndex() const override;
-        ColourMode defaultColourMode() const override;
-        bool shouldDebugBreak() const override;
-        int abortAfter() const override;
-        bool showInvisibles() const override;
-        Verbosity verbosity() const override;
-        bool skipBenchmarks() const override;
-        bool benchmarkNoAnalysis() const override;
-        unsigned int benchmarkSamples() const override;
-        double benchmarkConfidenceInterval() const override;
-        unsigned int benchmarkResamples() const override;
-        std::chrono::milliseconds benchmarkWarmupTime() const override;
-
-    private:
-        // Reads Bazel env vars and applies them to the config
-        void readBazelEnvVars();
-
-        ConfigData m_data;
-        std::vector<ProcessedReporterSpec> m_processedReporterSpecs;
-        TestSpec m_testSpec;
-        bool m_hasTestFilters = false;
-    };
-} // end namespace Catch
-
-#endif // CATCH_CONFIG_HPP_INCLUDED
-
-
-#ifndef CATCH_GET_RANDOM_SEED_HPP_INCLUDED
-#define CATCH_GET_RANDOM_SEED_HPP_INCLUDED
-
-#include <cstdint>
-
-namespace Catch {
-    //! Returns Catch2's current RNG seed.
-    std::uint32_t getSeed();
-}
-
-#endif // CATCH_GET_RANDOM_SEED_HPP_INCLUDED
-
-
-#ifndef CATCH_MESSAGE_HPP_INCLUDED
-#define CATCH_MESSAGE_HPP_INCLUDED
-
-
-
-
-/** \file
- * Wrapper for the CATCH_CONFIG_PREFIX_MESSAGES configuration option
- *
- * CATCH_CONFIG_PREFIX_ALL can be used to avoid clashes with other macros
- * by prepending CATCH_. This may not be desirable if the only clashes are with
- * logger macros such as INFO and WARN. In this cases
- * CATCH_CONFIG_PREFIX_MESSAGES can be used to only prefix a small subset
- * of relevant macros.
- *
- */
-
-#ifndef CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
-#define CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
-
-
-#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_PREFIX_MESSAGES)
-    #define CATCH_CONFIG_PREFIX_MESSAGES
-#endif
-
-#endif // CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
-
-
-#ifndef CATCH_STREAM_END_STOP_HPP_INCLUDED
-#define CATCH_STREAM_END_STOP_HPP_INCLUDED
-
-
-namespace Catch {
-
-    // Use this in variadic streaming macros to allow
-    //    << +StreamEndStop
-    // as well as
-    //    << stuff +StreamEndStop
-    struct StreamEndStop {
-        constexpr StringRef operator+() const { return StringRef(); }
-
-        template <typename T>
-        constexpr friend T const& operator+( T const& value, StreamEndStop ) {
-            return value;
-        }
-    };
-
-} // namespace Catch
-
-#endif // CATCH_STREAM_END_STOP_HPP_INCLUDED
-
-
-#ifndef CATCH_MESSAGE_INFO_HPP_INCLUDED
-#define CATCH_MESSAGE_INFO_HPP_INCLUDED
-
-
-#include <string>
-
-namespace Catch {
-
-    struct MessageInfo {
-        MessageInfo(    StringRef _macroName,
-                        SourceLineInfo const& _lineInfo,
-                        ResultWas::OfType _type );
-
-        StringRef macroName;
-        std::string message;
-        SourceLineInfo lineInfo;
-        ResultWas::OfType type;
-        unsigned int sequence;
-
-        bool operator == (MessageInfo const& other) const {
-            return sequence == other.sequence;
-        }
-        bool operator < (MessageInfo const& other) const {
-            return sequence < other.sequence;
-        }
-    private:
-        static unsigned int globalCount;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_MESSAGE_INFO_HPP_INCLUDED
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    struct SourceLineInfo;
-    class IResultCapture;
-
-    struct MessageStream {
-
-        template<typename T>
-        MessageStream& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
-
-        ReusableStringStream m_stream;
-    };
-
-    struct MessageBuilder : MessageStream {
-        MessageBuilder( StringRef macroName,
-                        SourceLineInfo const& lineInfo,
-                        ResultWas::OfType type ):
-            m_info(macroName, lineInfo, type) {}
-
-        template<typename T>
-        MessageBuilder&& operator << ( T const& value ) && {
-            m_stream << value;
-            return CATCH_MOVE(*this);
-        }
-
-        MessageInfo m_info;
-    };
-
-    class ScopedMessage {
-    public:
-        explicit ScopedMessage( MessageBuilder&& builder );
-        ScopedMessage( ScopedMessage& duplicate ) = delete;
-        ScopedMessage( ScopedMessage&& old ) noexcept;
-        ~ScopedMessage();
-
-        MessageInfo m_info;
-        bool m_moved = false;
-    };
-
-    class Capturer {
-        std::vector<MessageInfo> m_messages;
-        IResultCapture& m_resultCapture;
-        size_t m_captured = 0;
-    public:
-        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
-
-        Capturer(Capturer const&) = delete;
-        Capturer& operator=(Capturer const&) = delete;
-
-        ~Capturer();
-
-        void captureValue( size_t index, std::string const& value );
-
-        template<typename T>
-        void captureValues( size_t index, T const& value ) {
-            captureValue( index, Catch::Detail::stringify( value ) );
-        }
-
-        template<typename T, typename... Ts>
-        void captureValues( size_t index, T const& value, Ts const&... values ) {
-            captureValue( index, Catch::Detail::stringify(value) );
-            captureValues( index+1, values... );
-        }
-    };
-
-} // end namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
-        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
-        catchAssertionHandler.complete(); \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
-    Catch::Capturer varName( macroName##_catch_sr,        \
-                             CATCH_INTERNAL_LINEINFO,     \
-                             Catch::ResultWas::Info,      \
-                             #__VA_ARGS__##_catch_sr );   \
-    varName.captureValues( 0, __VA_ARGS__ )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_INFO( macroName, log ) \
-    const Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
-    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
-
-
-#if defined(CATCH_CONFIG_PREFIX_MESSAGES) && !defined(CATCH_CONFIG_DISABLE)
-
-  #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
-  #define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
-  #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-  #define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE", __VA_ARGS__ )
-
-#elif defined(CATCH_CONFIG_PREFIX_MESSAGES) && defined(CATCH_CONFIG_DISABLE)
-
-  #define CATCH_INFO( msg )          (void)(0)
-  #define CATCH_UNSCOPED_INFO( msg ) (void)(0)
-  #define CATCH_WARN( msg )          (void)(0)
-  #define CATCH_CAPTURE( ... )       (void)(0)
-
-#elif !defined(CATCH_CONFIG_PREFIX_MESSAGES) && !defined(CATCH_CONFIG_DISABLE)
-
-  #define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
-  #define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
-  #define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-  #define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE", __VA_ARGS__ )
-
-#elif !defined(CATCH_CONFIG_PREFIX_MESSAGES) && defined(CATCH_CONFIG_DISABLE)
-
-  #define INFO( msg )          (void)(0)
-  #define UNSCOPED_INFO( msg ) (void)(0)
-  #define WARN( msg )          (void)(0)
-  #define CAPTURE( ... )       (void)(0)
-
-#endif // end of user facing macro declarations
-
-
-
-
-#endif // CATCH_MESSAGE_HPP_INCLUDED
-
-
-#ifndef CATCH_SECTION_INFO_HPP_INCLUDED
-#define CATCH_SECTION_INFO_HPP_INCLUDED
-
-
-
-#ifndef CATCH_TOTALS_HPP_INCLUDED
-#define CATCH_TOTALS_HPP_INCLUDED
-
-#include <cstdint>
-
-namespace Catch {
-
-    struct Counts {
-        Counts operator - ( Counts const& other ) const;
-        Counts& operator += ( Counts const& other );
-
-        std::uint64_t total() const;
-        bool allPassed() const;
-        bool allOk() const;
-
-        std::uint64_t passed = 0;
-        std::uint64_t failed = 0;
-        std::uint64_t failedButOk = 0;
-        std::uint64_t skipped = 0;
-    };
-
-    struct Totals {
-
-        Totals operator - ( Totals const& other ) const;
-        Totals& operator += ( Totals const& other );
-
-        Totals delta( Totals const& prevTotals ) const;
-
-        Counts assertions;
-        Counts testCases;
-    };
-}
-
-#endif // CATCH_TOTALS_HPP_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    struct SectionInfo {
-        // The last argument is ignored, so that people can write
-        // SECTION("ShortName", "Proper description that is long") and
-        // still use the `-c` flag comfortably.
-        SectionInfo( SourceLineInfo const& _lineInfo, std::string _name,
-                    const char* const = nullptr ):
-            name(CATCH_MOVE(_name)),
-            lineInfo(_lineInfo)
-            {}
-
-        std::string name;
-        SourceLineInfo lineInfo;
-    };
-
-    struct SectionEndInfo {
-        SectionInfo sectionInfo;
-        Counts prevAssertions;
-        double durationInSeconds;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_SECTION_INFO_HPP_INCLUDED
-
-
-#ifndef CATCH_SESSION_HPP_INCLUDED
-#define CATCH_SESSION_HPP_INCLUDED
-
-
-
-#ifndef CATCH_COMMANDLINE_HPP_INCLUDED
-#define CATCH_COMMANDLINE_HPP_INCLUDED
-
-
-
-#ifndef CATCH_CLARA_HPP_INCLUDED
-#define CATCH_CLARA_HPP_INCLUDED
-
-#if defined( __clang__ )
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wweak-vtables"
-#    pragma clang diagnostic ignored "-Wshadow"
-#    pragma clang diagnostic ignored "-Wdeprecated"
-#endif
-
-#if defined( __GNUC__ )
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wsign-conversion"
-#endif
-
-#ifndef CLARA_CONFIG_OPTIONAL_TYPE
-#    ifdef __has_include
-#        if __has_include( <optional>) && __cplusplus >= 201703L
-#            include <optional>
-#            define CLARA_CONFIG_OPTIONAL_TYPE std::optional
-#        endif
-#    endif
-#endif
-
-
-#include <cassert>
-#include <memory>
-#include <ostream>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-namespace Catch {
-    namespace Clara {
-
-        class Args;
-        class Parser;
-
-        // enum of result types from a parse
-        enum class ParseResultType {
-            Matched,
-            NoMatch,
-            ShortCircuitAll,
-            ShortCircuitSame
-        };
-
-        struct accept_many_t {};
-        constexpr accept_many_t accept_many {};
-
-        namespace Detail {
-            struct fake_arg {
-                template <typename T>
-                operator T();
-            };
-
-            template <typename F, typename = void>
-            struct is_unary_function : std::false_type {};
-
-            template <typename F>
-            struct is_unary_function<
-                F,
-                Catch::Detail::void_t<decltype(
-                    std::declval<F>()( fake_arg() ) )
-                >
-            > : std::true_type {};
-
-            // Traits for extracting arg and return type of lambdas (for single
-            // argument lambdas)
-            template <typename L>
-            struct UnaryLambdaTraits
-                : UnaryLambdaTraits<decltype( &L::operator() )> {};
-
-            template <typename ClassT, typename ReturnT, typename... Args>
-            struct UnaryLambdaTraits<ReturnT ( ClassT::* )( Args... ) const> {
-                static const bool isValid = false;
-            };
-
-            template <typename ClassT, typename ReturnT, typename ArgT>
-            struct UnaryLambdaTraits<ReturnT ( ClassT::* )( ArgT ) const> {
-                static const bool isValid = true;
-                using ArgType = std::remove_const_t<std::remove_reference_t<ArgT>>;
-                using ReturnType = ReturnT;
-            };
-
-            class TokenStream;
-
-            // Wraps a token coming from a token stream. These may not directly
-            // correspond to strings as a single string may encode an option +
-            // its argument if the : or = form is used
-            enum class TokenType { Option, Argument };
-            struct Token {
-                TokenType type;
-                StringRef token;
-            };
-
-            // Abstracts iterators into args as a stream of tokens, with option
-            // arguments uniformly handled
-            class TokenStream {
-                using Iterator = std::vector<StringRef>::const_iterator;
-                Iterator it;
-                Iterator itEnd;
-                std::vector<Token> m_tokenBuffer;
-                void loadBuffer();
-
-            public:
-                explicit TokenStream( Args const& args );
-                TokenStream( Iterator it, Iterator itEnd );
-
-                explicit operator bool() const {
-                    return !m_tokenBuffer.empty() || it != itEnd;
-                }
-
-                size_t count() const {
-                    return m_tokenBuffer.size() + ( itEnd - it );
-                }
-
-                Token operator*() const {
-                    assert( !m_tokenBuffer.empty() );
-                    return m_tokenBuffer.front();
-                }
-
-                Token const* operator->() const {
-                    assert( !m_tokenBuffer.empty() );
-                    return &m_tokenBuffer.front();
-                }
-
-                TokenStream& operator++();
-            };
-
-            //! Denotes type of a parsing result
-            enum class ResultType {
-                Ok,          ///< No errors
-                LogicError,  ///< Error in user-specified arguments for
-                             ///< construction
-                RuntimeError ///< Error in parsing inputs
-            };
-
-            class ResultBase {
-            protected:
-                ResultBase( ResultType type ): m_type( type ) {}
-                virtual ~ResultBase(); // = default;
-
-
-                ResultBase(ResultBase const&) = default;
-                ResultBase& operator=(ResultBase const&) = default;
-                ResultBase(ResultBase&&) = default;
-                ResultBase& operator=(ResultBase&&) = default;
-
-                virtual void enforceOk() const = 0;
-
-                ResultType m_type;
-            };
-
-            template <typename T>
-            class ResultValueBase : public ResultBase {
-            public:
-                T const& value() const& {
-                    enforceOk();
-                    return m_value;
-                }
-                T&& value() && {
-                    enforceOk();
-                    return CATCH_MOVE( m_value );
-                }
-
-            protected:
-                ResultValueBase( ResultType type ): ResultBase( type ) {}
-
-                ResultValueBase( ResultValueBase const& other ):
-                    ResultBase( other ) {
-                    if ( m_type == ResultType::Ok )
-                        new ( &m_value ) T( other.m_value );
-                }
-                ResultValueBase( ResultValueBase&& other ):
-                    ResultBase( other ) {
-                    if ( m_type == ResultType::Ok )
-                        new ( &m_value ) T( CATCH_MOVE(other.m_value) );
-                }
-
-
-                ResultValueBase( ResultType, T const& value ):
-                    ResultBase( ResultType::Ok ) {
-                    new ( &m_value ) T( value );
-                }
-                ResultValueBase( ResultType, T&& value ):
-                    ResultBase( ResultType::Ok ) {
-                    new ( &m_value ) T( CATCH_MOVE(value) );
-                }
-
-                ResultValueBase& operator=( ResultValueBase const& other ) {
-                    if ( m_type == ResultType::Ok )
-                        m_value.~T();
-                    ResultBase::operator=( other );
-                    if ( m_type == ResultType::Ok )
-                        new ( &m_value ) T( other.m_value );
-                    return *this;
-                }
-                ResultValueBase& operator=( ResultValueBase&& other ) {
-                    if ( m_type == ResultType::Ok ) m_value.~T();
-                    ResultBase::operator=( other );
-                    if ( m_type == ResultType::Ok )
-                        new ( &m_value ) T( CATCH_MOVE(other.m_value) );
-                    return *this;
-                }
-
-
-                ~ResultValueBase() override {
-                    if ( m_type == ResultType::Ok )
-                        m_value.~T();
-                }
-
-                union {
-                    T m_value;
-                };
-            };
-
-            template <> class ResultValueBase<void> : public ResultBase {
-            protected:
-                using ResultBase::ResultBase;
-            };
-
-            template <typename T = void>
-            class BasicResult : public ResultValueBase<T> {
-            public:
-                template <typename U>
-                explicit BasicResult( BasicResult<U> const& other ):
-                    ResultValueBase<T>( other.type() ),
-                    m_errorMessage( other.errorMessage() ) {
-                    assert( type() != ResultType::Ok );
-                }
-
-                template <typename U>
-                static auto ok( U&& value ) -> BasicResult {
-                    return { ResultType::Ok, CATCH_FORWARD(value) };
-                }
-                static auto ok() -> BasicResult { return { ResultType::Ok }; }
-                static auto logicError( std::string&& message )
-                    -> BasicResult {
-                    return { ResultType::LogicError, CATCH_MOVE(message) };
-                }
-                static auto runtimeError( std::string&& message )
-                    -> BasicResult {
-                    return { ResultType::RuntimeError, CATCH_MOVE(message) };
-                }
-
-                explicit operator bool() const {
-                    return m_type == ResultType::Ok;
-                }
-                auto type() const -> ResultType { return m_type; }
-                auto errorMessage() const -> std::string const& {
-                    return m_errorMessage;
-                }
-
-            protected:
-                void enforceOk() const override {
-
-                    // Errors shouldn't reach this point, but if they do
-                    // the actual error message will be in m_errorMessage
-                    assert( m_type != ResultType::LogicError );
-                    assert( m_type != ResultType::RuntimeError );
-                    if ( m_type != ResultType::Ok )
-                        std::abort();
-                }
-
-                std::string
-                    m_errorMessage; // Only populated if resultType is an error
-
-                BasicResult( ResultType type,
-                             std::string&& message ):
-                    ResultValueBase<T>( type ), m_errorMessage( CATCH_MOVE(message) ) {
-                    assert( m_type != ResultType::Ok );
-                }
-
-                using ResultValueBase<T>::ResultValueBase;
-                using ResultBase::m_type;
-            };
-
-            class ParseState {
-            public:
-                ParseState( ParseResultType type,
-                            TokenStream remainingTokens );
-
-                ParseResultType type() const { return m_type; }
-                TokenStream const& remainingTokens() const& {
-                    return m_remainingTokens;
-                }
-                TokenStream&& remainingTokens() && {
-                    return CATCH_MOVE( m_remainingTokens );
-                }
-
-            private:
-                ParseResultType m_type;
-                TokenStream m_remainingTokens;
-            };
-
-            using Result = BasicResult<void>;
-            using ParserResult = BasicResult<ParseResultType>;
-            using InternalParseResult = BasicResult<ParseState>;
-
-            struct HelpColumns {
-                std::string left;
-                StringRef descriptions;
-            };
-
-            template <typename T>
-            ParserResult convertInto( std::string const& source, T& target ) {
-                std::stringstream ss( source );
-                ss >> target;
-                if ( ss.fail() ) {
-                    return ParserResult::runtimeError(
-                        "Unable to convert '" + source +
-                        "' to destination type" );
-                } else {
-                    return ParserResult::ok( ParseResultType::Matched );
-                }
-            }
-            ParserResult convertInto( std::string const& source,
-                                      std::string& target );
-            ParserResult convertInto( std::string const& source, bool& target );
-
-#ifdef CLARA_CONFIG_OPTIONAL_TYPE
-            template <typename T>
-            auto convertInto( std::string const& source,
-                              CLARA_CONFIG_OPTIONAL_TYPE<T>& target )
-                -> ParserResult {
-                T temp;
-                auto result = convertInto( source, temp );
-                if ( result )
-                    target = CATCH_MOVE( temp );
-                return result;
-            }
-#endif // CLARA_CONFIG_OPTIONAL_TYPE
-
-            struct BoundRef : Catch::Detail::NonCopyable {
-                virtual ~BoundRef() = default;
-                virtual bool isContainer() const;
-                virtual bool isFlag() const;
-            };
-            struct BoundValueRefBase : BoundRef {
-                virtual auto setValue( std::string const& arg )
-                    -> ParserResult = 0;
-            };
-            struct BoundFlagRefBase : BoundRef {
-                virtual auto setFlag( bool flag ) -> ParserResult = 0;
-                bool isFlag() const override;
-            };
-
-            template <typename T> struct BoundValueRef : BoundValueRefBase {
-                T& m_ref;
-
-                explicit BoundValueRef( T& ref ): m_ref( ref ) {}
-
-                ParserResult setValue( std::string const& arg ) override {
-                    return convertInto( arg, m_ref );
-                }
-            };
-
-            template <typename T>
-            struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
-                std::vector<T>& m_ref;
-
-                explicit BoundValueRef( std::vector<T>& ref ): m_ref( ref ) {}
-
-                auto isContainer() const -> bool override { return true; }
-
-                auto setValue( std::string const& arg )
-                    -> ParserResult override {
-                    T temp;
-                    auto result = convertInto( arg, temp );
-                    if ( result )
-                        m_ref.push_back( temp );
-                    return result;
-                }
-            };
-
-            struct BoundFlagRef : BoundFlagRefBase {
-                bool& m_ref;
-
-                explicit BoundFlagRef( bool& ref ): m_ref( ref ) {}
-
-                ParserResult setFlag( bool flag ) override;
-            };
-
-            template <typename ReturnType> struct LambdaInvoker {
-                static_assert(
-                    std::is_same<ReturnType, ParserResult>::value,
-                    "Lambda must return void or clara::ParserResult" );
-
-                template <typename L, typename ArgType>
-                static auto invoke( L const& lambda, ArgType const& arg )
-                    -> ParserResult {
-                    return lambda( arg );
-                }
-            };
-
-            template <> struct LambdaInvoker<void> {
-                template <typename L, typename ArgType>
-                static auto invoke( L const& lambda, ArgType const& arg )
-                    -> ParserResult {
-                    lambda( arg );
-                    return ParserResult::ok( ParseResultType::Matched );
-                }
-            };
-
-            template <typename ArgType, typename L>
-            auto invokeLambda( L const& lambda, std::string const& arg )
-                -> ParserResult {
-                ArgType temp{};
-                auto result = convertInto( arg, temp );
-                return !result ? result
-                               : LambdaInvoker<typename UnaryLambdaTraits<
-                                     L>::ReturnType>::invoke( lambda, temp );
-            }
-
-            template <typename L> struct BoundLambda : BoundValueRefBase {
-                L m_lambda;
-
-                static_assert(
-                    UnaryLambdaTraits<L>::isValid,
-                    "Supplied lambda must take exactly one argument" );
-                explicit BoundLambda( L const& lambda ): m_lambda( lambda ) {}
-
-                auto setValue( std::string const& arg )
-                    -> ParserResult override {
-                    return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(
-                        m_lambda, arg );
-                }
-            };
-
-            template <typename L> struct BoundManyLambda : BoundLambda<L> {
-                explicit BoundManyLambda( L const& lambda ): BoundLambda<L>( lambda ) {}
-                bool isContainer() const override { return true; }
-            };
-
-            template <typename L> struct BoundFlagLambda : BoundFlagRefBase {
-                L m_lambda;
-
-                static_assert(
-                    UnaryLambdaTraits<L>::isValid,
-                    "Supplied lambda must take exactly one argument" );
-                static_assert(
-                    std::is_same<typename UnaryLambdaTraits<L>::ArgType,
-                                 bool>::value,
-                    "flags must be boolean" );
-
-                explicit BoundFlagLambda( L const& lambda ):
-                    m_lambda( lambda ) {}
-
-                auto setFlag( bool flag ) -> ParserResult override {
-                    return LambdaInvoker<typename UnaryLambdaTraits<
-                        L>::ReturnType>::invoke( m_lambda, flag );
-                }
-            };
-
-            enum class Optionality { Optional, Required };
-
-            class ParserBase {
-            public:
-                virtual ~ParserBase() = default;
-                virtual auto validate() const -> Result { return Result::ok(); }
-                virtual auto parse( std::string const& exeName,
-                                    TokenStream tokens ) const
-                    -> InternalParseResult = 0;
-                virtual size_t cardinality() const;
-
-                InternalParseResult parse( Args const& args ) const;
-            };
-
-            template <typename DerivedT>
-            class ComposableParserImpl : public ParserBase {
-            public:
-                template <typename T>
-                auto operator|( T const& other ) const -> Parser;
-            };
-
-            // Common code and state for Args and Opts
-            template <typename DerivedT>
-            class ParserRefImpl : public ComposableParserImpl<DerivedT> {
-            protected:
-                Optionality m_optionality = Optionality::Optional;
-                std::shared_ptr<BoundRef> m_ref;
-                StringRef m_hint;
-                StringRef m_description;
-
-                explicit ParserRefImpl( std::shared_ptr<BoundRef> const& ref ):
-                    m_ref( ref ) {}
-
-            public:
-                template <typename LambdaT>
-                ParserRefImpl( accept_many_t,
-                               LambdaT const& ref,
-                               StringRef hint ):
-                    m_ref( std::make_shared<BoundManyLambda<LambdaT>>( ref ) ),
-                    m_hint( hint ) {}
-
-                template <typename T,
-                          typename = typename std::enable_if_t<
-                              !Detail::is_unary_function<T>::value>>
-                ParserRefImpl( T& ref, StringRef hint ):
-                    m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
-                    m_hint( hint ) {}
-
-                template <typename LambdaT,
-                          typename = typename std::enable_if_t<
-                              Detail::is_unary_function<LambdaT>::value>>
-                ParserRefImpl( LambdaT const& ref, StringRef hint ):
-                    m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
-                    m_hint( hint ) {}
-
-                DerivedT& operator()( StringRef description ) & {
-                    m_description = description;
-                    return static_cast<DerivedT&>( *this );
-                }
-                DerivedT&& operator()( StringRef description ) && {
-                    m_description = description;
-                    return static_cast<DerivedT&&>( *this );
-                }
-
-                auto optional() -> DerivedT& {
-                    m_optionality = Optionality::Optional;
-                    return static_cast<DerivedT&>( *this );
-                }
-
-                auto required() -> DerivedT& {
-                    m_optionality = Optionality::Required;
-                    return static_cast<DerivedT&>( *this );
-                }
-
-                auto isOptional() const -> bool {
-                    return m_optionality == Optionality::Optional;
-                }
-
-                auto cardinality() const -> size_t override {
-                    if ( m_ref->isContainer() )
-                        return 0;
-                    else
-                        return 1;
-                }
-
-                StringRef hint() const { return m_hint; }
-            };
-
-        } // namespace detail
-
-
-        // A parser for arguments
-        class Arg : public Detail::ParserRefImpl<Arg> {
-        public:
-            using ParserRefImpl::ParserRefImpl;
-            using ParserBase::parse;
-
-            Detail::InternalParseResult
-                parse(std::string const&,
-                      Detail::TokenStream tokens) const override;
-        };
-
-        // A parser for options
-        class Opt : public Detail::ParserRefImpl<Opt> {
-        protected:
-            std::vector<StringRef> m_optNames;
-
-        public:
-            template <typename LambdaT>
-            explicit Opt(LambdaT const& ref) :
-                ParserRefImpl(
-                    std::make_shared<Detail::BoundFlagLambda<LambdaT>>(ref)) {}
-
-            explicit Opt(bool& ref);
-
-            template <typename LambdaT,
-                      typename = typename std::enable_if_t<
-                          Detail::is_unary_function<LambdaT>::value>>
-            Opt( LambdaT const& ref, StringRef hint ):
-                ParserRefImpl( ref, hint ) {}
-
-            template <typename LambdaT>
-            Opt( accept_many_t, LambdaT const& ref, StringRef hint ):
-                ParserRefImpl( accept_many, ref, hint ) {}
-
-            template <typename T,
-                      typename = typename std::enable_if_t<
-                          !Detail::is_unary_function<T>::value>>
-            Opt( T& ref, StringRef hint ):
-                ParserRefImpl( ref, hint ) {}
-
-            Opt& operator[]( StringRef optName ) & {
-                m_optNames.push_back(optName);
-                return *this;
-            }
-            Opt&& operator[]( StringRef optName ) && {
-                m_optNames.push_back( optName );
-                return CATCH_MOVE(*this);
-            }
-
-            Detail::HelpColumns getHelpColumns() const;
-
-            bool isMatch(StringRef optToken) const;
-
-            using ParserBase::parse;
-
-            Detail::InternalParseResult
-                parse(std::string const&,
-                      Detail::TokenStream tokens) const override;
-
-            Detail::Result validate() const override;
-        };
-
-        // Specifies the name of the executable
-        class ExeName : public Detail::ComposableParserImpl<ExeName> {
-            std::shared_ptr<std::string> m_name;
-            std::shared_ptr<Detail::BoundValueRefBase> m_ref;
-
-        public:
-            ExeName();
-            explicit ExeName(std::string& ref);
-
-            template <typename LambdaT>
-            explicit ExeName(LambdaT const& lambda) : ExeName() {
-                m_ref = std::make_shared<Detail::BoundLambda<LambdaT>>(lambda);
-            }
-
-            // The exe name is not parsed out of the normal tokens, but is
-            // handled specially
-            Detail::InternalParseResult
-                parse(std::string const&,
-                      Detail::TokenStream tokens) const override;
-
-            std::string const& name() const { return *m_name; }
-            Detail::ParserResult set(std::string const& newName);
-        };
-
-
-        // A Combined parser
-        class Parser : Detail::ParserBase {
-            mutable ExeName m_exeName;
-            std::vector<Opt> m_options;
-            std::vector<Arg> m_args;
-
-        public:
-
-            auto operator|=(ExeName const& exeName) -> Parser& {
-                m_exeName = exeName;
-                return *this;
-            }
-
-            auto operator|=(Arg const& arg) -> Parser& {
-                m_args.push_back(arg);
-                return *this;
-            }
-
-            friend Parser& operator|=( Parser& p, Opt const& opt ) {
-                p.m_options.push_back( opt );
-                return p;
-            }
-            friend Parser& operator|=( Parser& p, Opt&& opt ) {
-                p.m_options.push_back( CATCH_MOVE(opt) );
-                return p;
-            }
-
-            Parser& operator|=(Parser const& other);
-
-            template <typename T>
-            friend Parser operator|( Parser const& p, T&& rhs ) {
-                Parser temp( p );
-                temp |= rhs;
-                return temp;
-            }
-
-            template <typename T>
-            friend Parser operator|( Parser&& p, T&& rhs ) {
-                p |= CATCH_FORWARD(rhs);
-                return CATCH_MOVE(p);
-            }
-
-            std::vector<Detail::HelpColumns> getHelpColumns() const;
-
-            void writeToStream(std::ostream& os) const;
-
-            friend auto operator<<(std::ostream& os, Parser const& parser)
-                -> std::ostream& {
-                parser.writeToStream(os);
-                return os;
-            }
-
-            Detail::Result validate() const override;
-
-            using ParserBase::parse;
-            Detail::InternalParseResult
-                parse(std::string const& exeName,
-                      Detail::TokenStream tokens) const override;
-        };
-
-        /**
-         * Wrapper over argc + argv, assumes that the inputs outlive it
-         */
-        class Args {
-            friend Detail::TokenStream;
-            StringRef m_exeName;
-            std::vector<StringRef> m_args;
-
-        public:
-            Args(int argc, char const* const* argv);
-            // Helper constructor for testing
-            Args(std::initializer_list<StringRef> args);
-
-            StringRef exeName() const { return m_exeName; }
-        };
-
-
-        // Convenience wrapper for option parser that specifies the help option
-        struct Help : Opt {
-            Help(bool& showHelpFlag);
-        };
-
-        // Result type for parser operation
-        using Detail::ParserResult;
-
-        namespace Detail {
-            template <typename DerivedT>
-            template <typename T>
-            Parser
-                ComposableParserImpl<DerivedT>::operator|(T const& other) const {
-                return Parser() | static_cast<DerivedT const&>(*this) | other;
-            }
-        }
-
-    } // namespace Clara
-} // namespace Catch
-
-#if defined( __clang__ )
-#    pragma clang diagnostic pop
-#endif
-
-#if defined( __GNUC__ )
-#    pragma GCC diagnostic pop
-#endif
-
-#endif // CATCH_CLARA_HPP_INCLUDED
-
-namespace Catch {
-
-    struct ConfigData;
-
-    Clara::Parser makeCommandLineParser( ConfigData& config );
-
-} // end namespace Catch
-
-#endif // CATCH_COMMANDLINE_HPP_INCLUDED
-
-namespace Catch {
-
-    class Session : Detail::NonCopyable {
-    public:
-
-        Session();
-        ~Session();
-
-        void showHelp() const;
-        void libIdentify();
-
-        int applyCommandLine( int argc, char const * const * argv );
-    #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
-        int applyCommandLine( int argc, wchar_t const * const * argv );
-    #endif
-
-        void useConfigData( ConfigData const& configData );
-
-        template<typename CharT>
-        int run(int argc, CharT const * const argv[]) {
-            if (m_startupExceptions)
-                return 1;
-            int returnCode = applyCommandLine(argc, argv);
-            if (returnCode == 0)
-                returnCode = run();
-            return returnCode;
-        }
-
-        int run();
-
-        Clara::Parser const& cli() const;
-        void cli( Clara::Parser const& newParser );
-        ConfigData& configData();
-        Config& config();
-    private:
-        int runInternal();
-
-        Clara::Parser m_cli;
-        ConfigData m_configData;
-        Detail::unique_ptr<Config> m_config;
-        bool m_startupExceptions = false;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_SESSION_HPP_INCLUDED
-
-
-#ifndef CATCH_TAG_ALIAS_HPP_INCLUDED
-#define CATCH_TAG_ALIAS_HPP_INCLUDED
-
-
-#include <string>
-
-namespace Catch {
-
-    struct TagAlias {
-        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo):
-            tag(_tag),
-            lineInfo(_lineInfo)
-        {}
-
-        std::string tag;
-        SourceLineInfo lineInfo;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_TAG_ALIAS_HPP_INCLUDED
-
-
-#ifndef CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
-#define CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
-
-
-namespace Catch {
-
-    struct RegistrarForTagAliases {
-        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
-    };
-
-} // end namespace Catch
-
-#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#endif // CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
-
-
-#ifndef CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
-#define CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
-
-// We need this suppression to leak, because it took until GCC 10
-// for the front end to handle local suppression via _Pragma properly
-// inside templates (so `TEMPLATE_TEST_CASE` and co).
-// **THIS IS DIFFERENT FOR STANDARD TESTS, WHERE GCC 9 IS SUFFICIENT**
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ < 10
-#pragma GCC diagnostic ignored "-Wparentheses"
-#endif
-
-
-
-
-#ifndef CATCH_TEST_MACROS_HPP_INCLUDED
-#define CATCH_TEST_MACROS_HPP_INCLUDED
-
-
-
-#ifndef CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
-#define CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
-
-
-
-#ifndef CATCH_ASSERTION_HANDLER_HPP_INCLUDED
-#define CATCH_ASSERTION_HANDLER_HPP_INCLUDED
-
-
-
-#ifndef CATCH_DECOMPOSER_HPP_INCLUDED
-#define CATCH_DECOMPOSER_HPP_INCLUDED
-
-
-
-#ifndef CATCH_COMPARE_TRAITS_HPP_INCLUDED
-#define CATCH_COMPARE_TRAITS_HPP_INCLUDED
-
-
-#include <type_traits>
-
-namespace Catch {
-    namespace Detail {
-
-#if defined( __GNUC__ ) && !defined( __clang__ )
-#    pragma GCC diagnostic push
-    // GCC likes to complain about comparing bool with 0, in the decltype()
-    // that defines the comparable traits below.
-#    pragma GCC diagnostic ignored "-Wbool-compare"
-    // "ordered comparison of pointer with integer zero" same as above,
-    // but it does not have a separate warning flag to suppress
-#    pragma GCC diagnostic ignored "-Wextra"
-    // Did you know that comparing floats with `0` directly
-    // is super-duper dangerous in unevaluated context?
-#    pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-
-#if defined( __clang__ )
-#    pragma clang diagnostic push
-    // Did you know that comparing floats with `0` directly
-    // is super-duper dangerous in unevaluated context?
-#    pragma clang diagnostic ignored "-Wfloat-equal"
-#endif
-
-#define CATCH_DEFINE_COMPARABLE_TRAIT( id, op )                               \
-    template <typename, typename, typename = void>                            \
-    struct is_##id##_comparable : std::false_type {};                         \
-    template <typename T, typename U>                                         \
-    struct is_##id##_comparable<                                              \
-        T,                                                                    \
-        U,                                                                    \
-        void_t<decltype( std::declval<T>() op std::declval<U>() )>>           \
-        : std::true_type {};                                                  \
-    template <typename, typename = void>                                      \
-    struct is_##id##_0_comparable : std::false_type {};                       \
-    template <typename T>                                                     \
-    struct is_##id##_0_comparable<T,                                          \
-                                  void_t<decltype( std::declval<T>() op 0 )>> \
-        : std::true_type {};
-
-        // We need all 6 pre-spaceship comparison ops: <, <=, >, >=, ==, !=
-        CATCH_DEFINE_COMPARABLE_TRAIT( lt, < )
-        CATCH_DEFINE_COMPARABLE_TRAIT( le, <= )
-        CATCH_DEFINE_COMPARABLE_TRAIT( gt, > )
-        CATCH_DEFINE_COMPARABLE_TRAIT( ge, >= )
-        CATCH_DEFINE_COMPARABLE_TRAIT( eq, == )
-        CATCH_DEFINE_COMPARABLE_TRAIT( ne, != )
-
-#undef CATCH_DEFINE_COMPARABLE_TRAIT
-
-#if defined( __GNUC__ ) && !defined( __clang__ )
-#    pragma GCC diagnostic pop
-#endif
-#if defined( __clang__ )
-#    pragma clang diagnostic pop
-#endif
-
-
-    } // namespace Detail
-} // namespace Catch
-
-#endif // CATCH_COMPARE_TRAITS_HPP_INCLUDED
-
-
-#ifndef CATCH_LOGICAL_TRAITS_HPP_INCLUDED
-#define CATCH_LOGICAL_TRAITS_HPP_INCLUDED
-
-#include <type_traits>
-
-namespace Catch {
-namespace Detail {
-
-#if defined( __cpp_lib_logical_traits ) && __cpp_lib_logical_traits >= 201510
-
-    using std::conjunction;
-    using std::disjunction;
-    using std::negation;
-
-#else
-
-    template <class...> struct conjunction : std::true_type {};
-    template <class B1> struct conjunction<B1> : B1 {};
-    template <class B1, class... Bn>
-    struct conjunction<B1, Bn...>
-        : std::conditional_t<bool( B1::value ), conjunction<Bn...>, B1> {};
-
-    template <class...> struct disjunction : std::false_type {};
-    template <class B1> struct disjunction<B1> : B1 {};
-    template <class B1, class... Bn>
-    struct disjunction<B1, Bn...>
-        : std::conditional_t<bool( B1::value ), B1, disjunction<Bn...>> {};
-
-    template <class B>
-    struct negation : std::integral_constant<bool, !bool(B::value)> {};
-
-#endif
-
-} // namespace Detail
-} // namespace Catch
-
-#endif // CATCH_LOGICAL_TRAITS_HPP_INCLUDED
-
-#include <type_traits>
-#include <iosfwd>
-
-/** \file
- * Why does decomposing look the way it does:
- *
- * Conceptually, decomposing is simple. We change `REQUIRE( a == b )` into
- * `Decomposer{} <= a == b`, so that `Decomposer{} <= a` is evaluated first,
- * and our custom operator is used for `a == b`, because `a` is transformed
- * into `ExprLhs<T&>` and then into `BinaryExpr<T&, U&>`.
- *
- * In practice, decomposing ends up a mess, because we have to support
- * various fun things.
- *
- * 1) Types that are only comparable with literal 0, and they do this by
- *    comparing against a magic type with pointer constructor and deleted
- *    other constructors. Example: `REQUIRE((a <=> b) == 0)` in libstdc++
- *
- * 2) Types that are only comparable with literal 0, and they do this by
- *    comparing against a magic type with consteval integer constructor.
- *    Example: `REQUIRE((a <=> b) == 0)` in current MSVC STL.
- *
- * 3) Types that have no linkage, and so we cannot form a reference to
- *    them. Example: some implementations of traits.
- *
- * 4) Starting with C++20, when the compiler sees `a == b`, it also uses
- *    `b == a` when constructing the overload set. For us this means that
- *    when the compiler handles `ExprLhs<T> == b`, it also tries to resolve
- *    the overload set for `b == ExprLhs<T>`.
- *
- * To accomodate these use cases, decomposer ended up rather complex.
- *
- * 1) These types are handled by adding SFINAE overloads to our comparison
- *    operators, checking whether `T == U` are comparable with the given
- *    operator, and if not, whether T (or U) are comparable with literal 0.
- *    If yes, the overload compares T (or U) with 0 literal inline in the
- *    definition.
- *
- *    Note that for extra correctness, we check  that the other type is
- *    either an `int` (literal 0 is captured as `int` by templates), or
- *    a `long` (some platforms use 0L for `NULL` and we want to support
- *    that for pointer comparisons).
- *
- * 2) For these types, `is_foo_comparable<T, int>` is true, but letting
- *    them fall into the overload that actually does `T == int` causes
- *    compilation error. Handling them requires that the decomposition
- *    is `constexpr`, so that P2564R3 applies and the `consteval` from
- *    their accompanying magic type is propagated through the `constexpr`
- *    call stack.
- *
- *    However this is not enough to handle these types automatically,
- *    because our default is to capture types by reference, to avoid
- *    runtime copies. While these references cannot become dangling,
- *    they outlive the constexpr context and thus the default capture
- *    path cannot be actually constexpr.
- *
- *    The solution is to capture these types by value, by explicitly
- *    specializing `Catch::capture_by_value` for them. Catch2 provides
- *    specialization for `std::foo_ordering`s, but users can specialize
- *    the trait for their own types as well.
- *
- * 3) If a type has no linkage, we also cannot capture it by reference.
- *    The solution is once again to capture them by value. We handle
- *    the common cases by using `std::is_arithmetic` as the default
- *    for `Catch::capture_by_value`, but that is only a some-effort
- *    heuristic. But as with 2), users can specialize `capture_by_value`
- *    for their own types as needed.
- *
- * 4) To support C++20 and make the SFINAE on our decomposing operators
- *    work, the SFINAE has to happen in return type, rather than in
- *    a template type. This is due to our use of logical type traits
- *    (`conjunction`/`disjunction`/`negation`), that we use to workaround
- *    an issue in older (9-) versions of GCC. I still blame C++20 for
- *    this, because without the comparison order switching, the logical
- *    traits could still be used in template type.
- *
- * There are also other side concerns, e.g. supporting both `REQUIRE(a)`
- * and `REQUIRE(a == b)`, or making `REQUIRE_THAT(a, IsEqual(b))` slot
- * nicely into the same expression handling logic, but these are rather
- * straightforward and add only a bit of complexity (e.g. common base
- * class for decomposed expressions).
- */
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
-#pragma warning(disable:4018) // more "signed/unsigned mismatch"
-#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
-#pragma warning(disable:4180) // qualifier applied to function type has no meaning
-#pragma warning(disable:4800) // Forcing result to true or false
-#endif
-
-#ifdef __clang__
-#  pragma clang diagnostic push
-#  pragma clang diagnostic ignored "-Wsign-compare"
-#  pragma clang diagnostic ignored "-Wnon-virtual-dtor"
-#elif defined __GNUC__
-#  pragma GCC diagnostic push
-#  pragma GCC diagnostic ignored "-Wsign-compare"
-#  pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
-#endif
-
-#if defined(CATCH_CPP20_OR_GREATER) && __has_include(<compare>)
-#  include <compare>
-#    if defined( __cpp_lib_three_way_comparison ) && \
-            __cpp_lib_three_way_comparison >= 201907L
-#      define CATCH_CONFIG_CPP20_COMPARE_OVERLOADS
-#    endif
-#endif
-
-namespace Catch {
-
-    namespace Detail {
-        // This was added in C++20, but we require only C++14 for now.
-        template <typename T>
-        using RemoveCVRef_t = std::remove_cv_t<std::remove_reference_t<T>>;
-    }
-
-    // Note: There is nothing that stops us from extending this,
-    //       e.g. to `std::is_scalar`, but the more encompassing
-    //       traits are usually also more expensive. For now we
-    //       keep this as it used to be and it can be changed later.
-    template <typename T>
-    struct capture_by_value
-        : std::integral_constant<bool, std::is_arithmetic<T>{}> {};
-
-#if defined( CATCH_CONFIG_CPP20_COMPARE_OVERLOADS )
-    template <>
-    struct capture_by_value<std::strong_ordering> : std::true_type {};
-    template <>
-    struct capture_by_value<std::weak_ordering> : std::true_type {};
-    template <>
-    struct capture_by_value<std::partial_ordering> : std::true_type {};
-#endif
-
-    template <typename T>
-    struct always_false : std::false_type {};
-
-    class ITransientExpression {
-        bool m_isBinaryExpression;
-        bool m_result;
-
-    protected:
-        ~ITransientExpression() = default;
-
-    public:
-        constexpr auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
-        constexpr auto getResult() const -> bool { return m_result; }
-        //! This function **has** to be overriden by the derived class.
-        virtual void streamReconstructedExpression( std::ostream& os ) const;
-
-        constexpr ITransientExpression( bool isBinaryExpression, bool result )
-        :   m_isBinaryExpression( isBinaryExpression ),
-            m_result( result )
-        {}
-
-        constexpr ITransientExpression( ITransientExpression const& ) = default;
-        constexpr ITransientExpression& operator=( ITransientExpression const& ) = default;
-
-        friend std::ostream& operator<<(std::ostream& out, ITransientExpression const& expr) {
-            expr.streamReconstructedExpression(out);
-            return out;
-        }
-    };
-
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
-
-    template<typename LhsT, typename RhsT>
-    class BinaryExpr  : public ITransientExpression {
-        LhsT m_lhs;
-        StringRef m_op;
-        RhsT m_rhs;
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            formatReconstructedExpression
-                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
-        }
-
-    public:
-        constexpr BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
-        :   ITransientExpression{ true, comparisonResult },
-            m_lhs( lhs ),
-            m_op( op ),
-            m_rhs( rhs )
-        {}
-
-        template<typename T>
-        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-    };
-
-    template<typename LhsT>
-    class UnaryExpr : public ITransientExpression {
-        LhsT m_lhs;
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            os << Catch::Detail::stringify( m_lhs );
-        }
-
-    public:
-        explicit constexpr UnaryExpr( LhsT lhs )
-        :   ITransientExpression{ false, static_cast<bool>(lhs) },
-            m_lhs( lhs )
-        {}
-    };
-
-
-    template<typename LhsT>
-    class ExprLhs {
-        LhsT m_lhs;
-    public:
-        explicit constexpr ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
-
-#define CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( id, op )           \
-    template <typename RhsT>                                                   \
-    constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )             \
-        -> std::enable_if_t<                                                   \
-            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
-                                Detail::negation<capture_by_value<             \
-                                    Detail::RemoveCVRef_t<RhsT>>>>::value,     \
-            BinaryExpr<LhsT, RhsT const&>> {                                   \
-        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
-    }                                                                          \
-    template <typename RhsT>                                                   \
-    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<                                                   \
-            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
-                                capture_by_value<RhsT>>::value,                \
-            BinaryExpr<LhsT, RhsT>> {                                          \
-        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
-    }                                                                          \
-    template <typename RhsT>                                                   \
-    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<                                                   \
-            Detail::conjunction<                                               \
-                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
-                Detail::is_eq_0_comparable<LhsT>,                              \
-              /* We allow long because we want `ptr op NULL` to be accepted */ \
-                Detail::disjunction<std::is_same<RhsT, int>,                   \
-                                    std::is_same<RhsT, long>>>::value,         \
-            BinaryExpr<LhsT, RhsT>> {                                          \
-        if ( rhs != 0 ) { throw_test_failure_exception(); }                    \
-        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs };   \
-    }                                                                          \
-    template <typename RhsT>                                                   \
-    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<                                                   \
-            Detail::conjunction<                                               \
-                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
-                Detail::is_eq_0_comparable<RhsT>,                              \
-              /* We allow long because we want `ptr op NULL` to be accepted */ \
-                Detail::disjunction<std::is_same<LhsT, int>,                   \
-                                    std::is_same<LhsT, long>>>::value,         \
-            BinaryExpr<LhsT, RhsT>> {                                          \
-        if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); }              \
-        return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs };    \
-    }
-
-        CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( eq, == )
-        CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( ne, != )
-
-    #undef CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR
-
-
-#define CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( id, op )         \
-    template <typename RhsT>                                                   \
-    constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )             \
-        -> std::enable_if_t<                                                   \
-            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
-                                Detail::negation<capture_by_value<             \
-                                    Detail::RemoveCVRef_t<RhsT>>>>::value,     \
-            BinaryExpr<LhsT, RhsT const&>> {                                   \
-        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
-    }                                                                          \
-    template <typename RhsT>                                                   \
-    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<                                                   \
-            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
-                                capture_by_value<RhsT>>::value,                \
-            BinaryExpr<LhsT, RhsT>> {                                          \
-        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
-    }                                                                          \
-    template <typename RhsT>                                                   \
-    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<                                                   \
-            Detail::conjunction<                                               \
-                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
-                Detail::is_##id##_0_comparable<LhsT>,                          \
-                std::is_same<RhsT, int>>::value,                               \
-            BinaryExpr<LhsT, RhsT>> {                                          \
-        if ( rhs != 0 ) { throw_test_failure_exception(); }                    \
-        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs };   \
-    }                                                                          \
-    template <typename RhsT>                                                   \
-    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<                                                   \
-            Detail::conjunction<                                               \
-                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
-                Detail::is_##id##_0_comparable<RhsT>,                          \
-                std::is_same<LhsT, int>>::value,                               \
-            BinaryExpr<LhsT, RhsT>> {                                          \
-        if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); }              \
-        return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs };    \
-    }
-
-        CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( lt, < )
-        CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( le, <= )
-        CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( gt, > )
-        CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( ge, >= )
-
-    #undef CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR
-
-
-#define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR( op )                        \
-    template <typename RhsT>                                                   \
-    constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )             \
-        -> std::enable_if_t<                                                   \
-            !capture_by_value<Detail::RemoveCVRef_t<RhsT>>::value,             \
-            BinaryExpr<LhsT, RhsT const&>> {                                   \
-        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
-    }                                                                          \
-    template <typename RhsT>                                                   \
-    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<capture_by_value<RhsT>::value,                     \
-                            BinaryExpr<LhsT, RhsT>> {                          \
-        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
-    }
-
-        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(|)
-        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(&)
-        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(^)
-
-    #undef CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR
-
-        template<typename RhsT>
-        friend auto operator && ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
-            static_assert(always_false<RhsT>::value,
-            "operator&& is not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename RhsT>
-        friend auto operator || ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
-            static_assert(always_false<RhsT>::value,
-            "operator|| is not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        constexpr auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
-            return UnaryExpr<LhsT>{ m_lhs };
-        }
-    };
-
-    struct Decomposer {
-        template <typename T,
-                  std::enable_if_t<!capture_by_value<Detail::RemoveCVRef_t<T>>::value,
-                      int> = 0>
-        constexpr friend auto operator <= ( Decomposer &&, T && lhs ) -> ExprLhs<T const&> {
-            return ExprLhs<const T&>{ lhs };
-        }
-
-        template <typename T,
-                  std::enable_if_t<capture_by_value<T>::value, int> = 0>
-        constexpr friend auto operator <= ( Decomposer &&, T value ) -> ExprLhs<T> {
-            return ExprLhs<T>{ value };
-        }
-    };
-
-} // end namespace Catch
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-#ifdef __clang__
-#  pragma clang diagnostic pop
-#elif defined __GNUC__
-#  pragma GCC diagnostic pop
-#endif
-
-#endif // CATCH_DECOMPOSER_HPP_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    struct AssertionReaction {
-        bool shouldDebugBreak = false;
-        bool shouldThrow = false;
-        bool shouldSkip = false;
-    };
-
-    class AssertionHandler {
-        AssertionInfo m_assertionInfo;
-        AssertionReaction m_reaction;
-        bool m_completed = false;
-        IResultCapture& m_resultCapture;
-
-    public:
-        AssertionHandler
-            (   StringRef macroName,
-                SourceLineInfo const& lineInfo,
-                StringRef capturedExpression,
-                ResultDisposition::Flags resultDisposition );
-        ~AssertionHandler() {
-            if ( !m_completed ) {
-                m_resultCapture.handleIncomplete( m_assertionInfo );
-            }
-        }
-
-
-        template<typename T>
-        constexpr void handleExpr( ExprLhs<T> const& expr ) {
-            handleExpr( expr.makeUnaryExpr() );
-        }
-        void handleExpr( ITransientExpression const& expr );
-
-        void handleMessage(ResultWas::OfType resultType, std::string&& message);
-
-        void handleExceptionThrownAsExpected();
-        void handleUnexpectedExceptionNotThrown();
-        void handleExceptionNotThrownAsExpected();
-        void handleThrowingCallSkipped();
-        void handleUnexpectedInflightException();
-
-        void complete();
-
-        // query
-        auto allowThrows() const -> bool;
-    };
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str );
-
-} // namespace Catch
-
-#endif // CATCH_ASSERTION_HANDLER_HPP_INCLUDED
-
-
-#ifndef CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
-#define CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
-
-
-#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
-  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__##_catch_sr
-#else
-  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"_catch_sr
-#endif
-
-#endif // CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
-
-// We need this suppression to leak, because it took until GCC 10
-// for the front end to handle local suppression via _Pragma properly
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ <= 9
-  #pragma GCC diagnostic ignored "-Wparentheses"
-#endif
-
-#if !defined(CATCH_CONFIG_DISABLE)
-
-#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-
-///////////////////////////////////////////////////////////////////////////////
-// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
-// macros.
-#define INTERNAL_CATCH_TRY
-#define INTERNAL_CATCH_CATCH( capturer )
-
-#else // CATCH_CONFIG_FAST_COMPILE
-
-#define INTERNAL_CATCH_TRY try
-#define INTERNAL_CATCH_CATCH( handler ) catch(...) { (handler).handleUnexpectedInflightException(); }
-
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
-    do { /* NOLINT(bugprone-infinite-loop) */ \
-        /* The expression should not be evaluated, but warnings should hopefully be checked */ \
-        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
-            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); /* NOLINT(bugprone-chained-comparison) */ \
-            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        catchAssertionHandler.complete(); \
-    } while( (void)0, (false) && static_cast<const bool&>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
-    // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
-    if( Catch::getResultCapture().lastAssertionPassed() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
-    if( !Catch::getResultCapture().lastAssertionPassed() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        try { \
-            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-            CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
-            static_cast<void>(__VA_ARGS__); \
-            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
-        } \
-        catch( ... ) { \
-            catchAssertionHandler.handleUnexpectedInflightException(); \
-        } \
-        catchAssertionHandler.complete(); \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-                CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
-                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
-                static_cast<void>(__VA_ARGS__); \
-                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        catchAssertionHandler.complete(); \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-                CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
-                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
-                static_cast<void>(expr); \
-                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( exceptionType const& ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        catchAssertionHandler.complete(); \
-    } while( false )
-
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Although this is matcher-based, it can be used with just a string
-#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-                CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
-                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
-                static_cast<void>(__VA_ARGS__); \
-                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( ... ) { \
-                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher ); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        catchAssertionHandler.complete(); \
-    } while( false )
-
-#endif // CATCH_CONFIG_DISABLE
-
-#endif // CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
-
-
-#ifndef CATCH_SECTION_HPP_INCLUDED
-#define CATCH_SECTION_HPP_INCLUDED
-
-
-
-
-/** \file
- * Wrapper for the STATIC_ANALYSIS_SUPPORT configuration option
- *
- * Some of Catch2's macros can be defined differently to work better with
- * static analysis tools, like clang-tidy or coverity.
- * Currently the main use case is to show that `SECTION`s are executed
- * exclusively, and not all in one run of a `TEST_CASE`.
- */
-
-#ifndef CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
-#define CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
-
-
-#if defined(__clang_analyzer__) || defined(__COVERITY__)
-    #define CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT
-#endif
-
-#if defined( CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT ) && \
-    !defined( CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT ) && \
-    !defined( CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT )
-#    define CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
-#endif
-
-
-#endif // CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
-
-
-#ifndef CATCH_TIMER_HPP_INCLUDED
-#define CATCH_TIMER_HPP_INCLUDED
-
-#include <cstdint>
-
-namespace Catch {
-
-    class Timer {
-        uint64_t m_nanoseconds = 0;
-    public:
-        void start();
-        auto getElapsedNanoseconds() const -> uint64_t;
-        auto getElapsedMicroseconds() const -> uint64_t;
-        auto getElapsedMilliseconds() const -> unsigned int;
-        auto getElapsedSeconds() const -> double;
-    };
-
-} // namespace Catch
-
-#endif // CATCH_TIMER_HPP_INCLUDED
-
-namespace Catch {
-
-    class Section : Detail::NonCopyable {
-    public:
-        Section( SectionInfo&& info );
-        Section( SourceLineInfo const& _lineInfo,
-                 StringRef _name,
-                 const char* const = nullptr );
-        ~Section();
-
-        // This indicates whether the section should be executed or not
-        explicit operator bool() const;
-
-    private:
-        SectionInfo m_info;
-
-        Counts m_assertions;
-        bool m_sectionIncluded;
-        Timer m_timer;
-    };
-
-} // end namespace Catch
-
-#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT)
-#    define INTERNAL_CATCH_SECTION( ... )                                 \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                         \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                  \
-        if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME(            \
-                 catch_internal_Section ) =                               \
-                 Catch::Section( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#    define INTERNAL_CATCH_DYNAMIC_SECTION( ... )                     \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                     \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS              \
-        if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME(        \
-                 catch_internal_Section ) =                           \
-                 Catch::SectionInfo(                                  \
-                     CATCH_INTERNAL_LINEINFO,                         \
-                     ( Catch::ReusableStringStream() << __VA_ARGS__ ) \
-                         .str() ) )                                   \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#else
-
-// These section definitions imply that at most one section at one level
-// will be intered (because only one section's __LINE__ can be equal to
-// the dummy `catchInternalSectionHint` variable from `TEST_CASE`).
-
-namespace Catch {
-    namespace Detail {
-        // Intentionally without linkage, as it should only be used as a dummy
-        // symbol for static analysis.
-        // The arguments are used as a dummy for checking warnings in the passed
-        // expressions.
-        int GetNewSectionHint( StringRef, const char* const = nullptr );
-    } // namespace Detail
-} // namespace Catch
-
-
-#    define INTERNAL_CATCH_SECTION( ... )                                   \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                           \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                    \
-        CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS                             \
-        if ( [[maybe_unused]] const int catchInternalPreviousSectionHint =  \
-                 catchInternalSectionHint,                                  \
-             catchInternalSectionHint =                                     \
-                 Catch::Detail::GetNewSectionHint(__VA_ARGS__);             \
-             catchInternalPreviousSectionHint == __LINE__ )                 \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#    define INTERNAL_CATCH_DYNAMIC_SECTION( ... )                           \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                           \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                    \
-        CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS                             \
-        if ( [[maybe_unused]] const int catchInternalPreviousSectionHint =  \
-                 catchInternalSectionHint,                                  \
-             catchInternalSectionHint = Catch::Detail::GetNewSectionHint(   \
-                ( Catch::ReusableStringStream() << __VA_ARGS__ ).str());    \
-             catchInternalPreviousSectionHint == __LINE__ )                 \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#endif
-
-
-#endif // CATCH_SECTION_HPP_INCLUDED
-
-
-#ifndef CATCH_TEST_REGISTRY_HPP_INCLUDED
-#define CATCH_TEST_REGISTRY_HPP_INCLUDED
-
-
-
-#ifndef CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
-#define CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
-
-namespace Catch {
-
-    class ITestInvoker {
-    public:
-        virtual void prepareTestCase();
-        virtual void tearDownTestCase();
-        virtual void invoke() const = 0;
-        virtual ~ITestInvoker(); // = default
-    };
-
-} // namespace Catch
-
-#endif // CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
-
-
-#ifndef CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
-#define CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
-
-#define INTERNAL_CATCH_EXPAND1( param ) INTERNAL_CATCH_EXPAND2( param )
-#define INTERNAL_CATCH_EXPAND2( ... ) INTERNAL_CATCH_NO##__VA_ARGS__
-#define INTERNAL_CATCH_DEF( ... ) INTERNAL_CATCH_DEF __VA_ARGS__
-#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
-
-#define INTERNAL_CATCH_REMOVE_PARENS( ... ) \
-    INTERNAL_CATCH_EXPAND1( INTERNAL_CATCH_DEF __VA_ARGS__ )
-
-#endif // CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
-
-// GCC 5 and older do not properly handle disabling unused-variable warning
-// with a _Pragma. This means that we have to leak the suppression to the
-// user code as well :-(
-#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
-#pragma GCC diagnostic ignored "-Wunused-variable"
-#endif
-
-
-
-namespace Catch {
-
-template<typename C>
-class TestInvokerAsMethod : public ITestInvoker {
-    void (C::*m_testAsMethod)();
-public:
-    constexpr TestInvokerAsMethod( void ( C::*testAsMethod )() ) noexcept:
-        m_testAsMethod( testAsMethod ) {}
-
-    void invoke() const override {
-        C obj;
-        (obj.*m_testAsMethod)();
-    }
-};
-
-Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() );
-
-template<typename C>
-Detail::unique_ptr<ITestInvoker> makeTestInvoker( void (C::*testAsMethod)() ) {
-    return Detail::make_unique<TestInvokerAsMethod<C>>( testAsMethod );
-}
-
-template <typename C>
-class TestInvokerFixture : public ITestInvoker {
-    void ( C::*m_testAsMethod )() const;
-    Detail::unique_ptr<C> m_fixture = nullptr;
-
-public:
-    constexpr TestInvokerFixture( void ( C::*testAsMethod )() const ) noexcept:
-        m_testAsMethod( testAsMethod ) {}
-
-    void prepareTestCase() override {
-        m_fixture = Detail::make_unique<C>();
-    }
-
-    void tearDownTestCase() override {
-        m_fixture.reset();
-    }
-
-    void invoke() const override {
-        auto* f = m_fixture.get();
-        ( f->*m_testAsMethod )();
-    }
-};
-
-template<typename C>
-Detail::unique_ptr<ITestInvoker> makeTestInvokerFixture( void ( C::*testAsMethod )() const ) {
-    return Detail::make_unique<TestInvokerFixture<C>>( testAsMethod );
-}
-
-struct NameAndTags {
-    constexpr NameAndTags( StringRef name_ = StringRef(),
-                           StringRef tags_ = StringRef() ) noexcept:
-        name( name_ ), tags( tags_ ) {}
-    StringRef name;
-    StringRef tags;
-};
-
-struct AutoReg : Detail::NonCopyable {
-    AutoReg( Detail::unique_ptr<ITestInvoker> invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept;
-};
-
-} // end namespace Catch
-
-#if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
-        static inline void TestName()
-    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
-        namespace{                        \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
-                void test();              \
-            };                            \
-        }                                 \
-        void TestName::test()
-#endif
-
-
-#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT)
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
-        static void TestName(); \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
-        namespace{ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        static void TestName()
-    #define INTERNAL_CATCH_TESTCASE( ... ) \
-        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__ )
-
-#else  // ^^ !CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT | vv CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
-
-
-// Dummy registrator for the dumy test case macros
-namespace Catch {
-    namespace Detail {
-        struct DummyUse {
-            DummyUse( void ( * )( int ), Catch::NameAndTags const& );
-        };
-    } // namespace Detail
-} // namespace Catch
-
-// Note that both the presence of the argument and its exact name are
-// necessary for the section support.
-
-// We provide a shadowed variable so that a `SECTION` inside non-`TEST_CASE`
-// tests can compile. The redefined `TEST_CASE` shadows this with param.
-static int catchInternalSectionHint = 0;
-
-#    define INTERNAL_CATCH_TESTCASE2( fname, ... )                         \
-        static void fname( int );                                          \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                          \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                           \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                   \
-        static const Catch::Detail::DummyUse INTERNAL_CATCH_UNIQUE_NAME(   \
-            dummyUser )( &(fname), Catch::NameAndTags{ __VA_ARGS__ } );    \
-        CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS                            \
-        static void fname( [[maybe_unused]] int catchInternalSectionHint ) \
-            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-#    define INTERNAL_CATCH_TESTCASE( ... ) \
-        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( dummyFunction ), __VA_ARGS__ )
-
-
-#endif // CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
-        namespace{ \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
-                void test(); \
-            }; \
-            const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
-            Catch::makeTestInvoker( &TestName::test ),                    \
-            CATCH_INTERNAL_LINEINFO,                                      \
-            #ClassName##_catch_sr,                                        \
-            Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
-        } \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        void TestName::test()
-    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
-        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2( TestName, ClassName, ... )      \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                             \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                              \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                      \
-        namespace {                                                           \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS( ClassName ) {     \
-                void test() const;                                            \
-            };                                                                \
-            const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
-                Catch::makeTestInvokerFixture( &TestName::test ),                    \
-                CATCH_INTERNAL_LINEINFO,                                      \
-                #ClassName##_catch_sr,                                        \
-                Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */             \
-        }                                                                     \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                              \
-        void TestName::test() const
-    #define INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( ClassName, ... )    \
-        INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )
-
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
-        namespace {                                                           \
-        const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
-            Catch::makeTestInvoker( &QualifiedMethod ),                   \
-            CATCH_INTERNAL_LINEINFO,                                      \
-            "&" #QualifiedMethod##_catch_sr,                              \
-            Catch::NameAndTags{ __VA_ARGS__ } );                          \
-    } /* NOLINT */ \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
-        do { \
-            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-            CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-            CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
-            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        } while(false)
-
-
-#endif // CATCH_TEST_REGISTRY_HPP_INCLUDED
-
-
-// All of our user-facing macros support configuration toggle, that
-// forces them to be defined prefixed with CATCH_. We also like to
-// support another toggle that can minimize (disable) their implementation.
-// Given this, we have 4 different configuration options below
-
-#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
-
-  #define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-  #define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-  #define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-  #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-  #define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-  #define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-  #define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-  #define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-  #define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-  #define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-  #define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-  #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-  #define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-  #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-  #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-  #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-  #define CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, __VA_ARGS__ )
-  #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-  #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-  #define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-  #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-  #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-  #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-  #define CATCH_SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-
-  #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-    #define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
-    #define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
-    #define CATCH_STATIC_CHECK( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
-    #define CATCH_STATIC_CHECK_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
-  #else
-    #define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
-    #define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
-    #define CATCH_STATIC_CHECK( ... )       CATCH_CHECK( __VA_ARGS__ )
-    #define CATCH_STATIC_CHECK_FALSE( ... ) CATCH_CHECK_FALSE( __VA_ARGS__ )
-  #endif
-
-
-  // "BDD-style" convenience wrappers
-  #define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
-  #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-  #define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-  #define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-  #define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-  #define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-  #define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-  #define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
-
-#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, implemented | vv prefixed, disabled
-
-  #define CATCH_REQUIRE( ... )        (void)(0)
-  #define CATCH_REQUIRE_FALSE( ... )  (void)(0)
-
-  #define CATCH_REQUIRE_THROWS( ... ) (void)(0)
-  #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-  #define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
-
-  #define CATCH_CHECK( ... )         (void)(0)
-  #define CATCH_CHECK_FALSE( ... )   (void)(0)
-  #define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
-  #define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
-  #define CATCH_CHECK_NOFAIL( ... )  (void)(0)
-
-  #define CATCH_CHECK_THROWS( ... )  (void)(0)
-  #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-  #define CATCH_CHECK_NOTHROW( ... ) (void)(0)
-
-  #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
-  #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
-  #define CATCH_METHOD_AS_TEST_CASE( method, ... )
-  #define CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
-  #define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
-  #define CATCH_SECTION( ... )
-  #define CATCH_DYNAMIC_SECTION( ... )
-  #define CATCH_FAIL( ... ) (void)(0)
-  #define CATCH_FAIL_CHECK( ... ) (void)(0)
-  #define CATCH_SUCCEED( ... ) (void)(0)
-  #define CATCH_SKIP( ... ) (void)(0)
-
-  #define CATCH_STATIC_REQUIRE( ... )       (void)(0)
-  #define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
-  #define CATCH_STATIC_CHECK( ... )       (void)(0)
-  #define CATCH_STATIC_CHECK_FALSE( ... ) (void)(0)
-
-  // "BDD-style" convenience wrappers
-  #define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
-  #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), className )
-  #define CATCH_GIVEN( desc )
-  #define CATCH_AND_GIVEN( desc )
-  #define CATCH_WHEN( desc )
-  #define CATCH_AND_WHEN( desc )
-  #define CATCH_THEN( desc )
-  #define CATCH_AND_THEN( desc )
-
-#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, disabled | vv unprefixed, implemented
-
-  #define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
-  #define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-  #define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-  #define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-  #define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-  #define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-  #define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-  #define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-  #define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-  #define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-  #define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-  #define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-  #define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-  #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-  #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-  #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-  #define TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, __VA_ARGS__ )
-  #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-  #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-  #define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-  #define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-  #define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-  #define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-  #define SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-
-  #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-    #define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
-    #define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
-    #define STATIC_CHECK( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
-    #define STATIC_CHECK_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
-  #else
-    #define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
-    #define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
-    #define STATIC_CHECK( ... )       CHECK( __VA_ARGS__ )
-    #define STATIC_CHECK_FALSE( ... ) CHECK_FALSE( __VA_ARGS__ )
-  #endif
-
-  // "BDD-style" convenience wrappers
-  #define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
-  #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-  #define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-  #define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-  #define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-  #define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-  #define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-  #define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
-
-#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ unprefixed, implemented | vv unprefixed, disabled
-
-  #define REQUIRE( ... )       (void)(0)
-  #define REQUIRE_FALSE( ... ) (void)(0)
-
-  #define REQUIRE_THROWS( ... ) (void)(0)
-  #define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-  #define REQUIRE_NOTHROW( ... ) (void)(0)
-
-  #define CHECK( ... ) (void)(0)
-  #define CHECK_FALSE( ... ) (void)(0)
-  #define CHECKED_IF( ... ) if (__VA_ARGS__)
-  #define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
-  #define CHECK_NOFAIL( ... ) (void)(0)
-
-  #define CHECK_THROWS( ... )  (void)(0)
-  #define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-  #define CHECK_NOTHROW( ... ) (void)(0)
-
-  #define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
-  #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
-  #define METHOD_AS_TEST_CASE( method, ... )
-  #define TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
-  #define REGISTER_TEST_CASE( Function, ... ) (void)(0)
-  #define SECTION( ... )
-  #define DYNAMIC_SECTION( ... )
-  #define FAIL( ... ) (void)(0)
-  #define FAIL_CHECK( ... ) (void)(0)
-  #define SUCCEED( ... ) (void)(0)
-  #define SKIP( ... ) (void)(0)
-
-  #define STATIC_REQUIRE( ... )       (void)(0)
-  #define STATIC_REQUIRE_FALSE( ... ) (void)(0)
-  #define STATIC_CHECK( ... )       (void)(0)
-  #define STATIC_CHECK_FALSE( ... ) (void)(0)
-
-  // "BDD-style" convenience wrappers
-  #define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ) )
-  #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), className )
-
-  #define GIVEN( desc )
-  #define AND_GIVEN( desc )
-  #define WHEN( desc )
-  #define AND_WHEN( desc )
-  #define THEN( desc )
-  #define AND_THEN( desc )
-
-#endif // ^^ unprefixed, disabled
-
-// end of user facing macros
-
-#endif // CATCH_TEST_MACROS_HPP_INCLUDED
-
-
-#ifndef CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
-#define CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
-
-
-
-#ifndef CATCH_PREPROCESSOR_HPP_INCLUDED
-#define CATCH_PREPROCESSOR_HPP_INCLUDED
-
-
-#if defined(__GNUC__)
-// We need to silence "empty __VA_ARGS__ warning", and using just _Pragma does not work
-#pragma GCC system_header
-#endif
-
-
-#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
-#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
-
-#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
-// MSVC needs more evaluations
-#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
-#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
-#else
-#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
-#endif
-
-#define CATCH_REC_END(...)
-#define CATCH_REC_OUT
-
-#define CATCH_EMPTY()
-#define CATCH_DEFER(id) id CATCH_EMPTY()
-
-#define CATCH_REC_GET_END2() 0, CATCH_REC_END
-#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
-#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
-#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
-#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
-#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
-
-#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
-
-#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-
-// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
-// and passes userdata as the first parameter to each invocation,
-// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
-#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
-
-#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
-
-#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
-#else
-// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
-#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
-#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
-#endif
-
-#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
-#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
-#else
-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
-#endif
-
-#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
-    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
-
-#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
-#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
-#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
-#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
-#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
-#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
-#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6)
-#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
-#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
-#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
-#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
-
-#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
-
-#define INTERNAL_CATCH_TYPE_GEN\
-    template<typename...> struct TypeList {};\
-    template<typename...Ts>\
-    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
-    template<template<typename...> class...> struct TemplateTypeList{};\
-    template<template<typename...> class...Cs>\
-    constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
-    template<typename...>\
-    struct append;\
-    template<typename...>\
-    struct rewrap;\
-    template<template<typename...> class, typename...>\
-    struct create;\
-    template<template<typename...> class, typename>\
-    struct convert;\
-    \
-    template<typename T> \
-    struct append<T> { using type = T; };\
-    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
-    struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
-    template< template<typename...> class L1, typename...E1, typename...Rest>\
-    struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
-    \
-    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
-    struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
-    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
-    struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
-    \
-    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
-    struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
-    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
-    struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
-
-#define INTERNAL_CATCH_NTTP_1(signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
-    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
-    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
-    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
-    \
-    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
-    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
-    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
-    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
-    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-
-#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-
-#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
-    template<typename Type>\
-    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
-    template<typename Type>\
-    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
-    template<typename TestType> \
-    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
-        void test();\
-    }
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
-    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
-        void test();\
-    }
-
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
-    template<typename TestType> \
-    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
-    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_NTTP_0
-#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
-#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
-#else
-#define INTERNAL_CATCH_NTTP_0(signature)
-#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
-#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
-#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
-#endif
-
-#endif // CATCH_PREPROCESSOR_HPP_INCLUDED
-
-
-// GCC 5 and older do not properly handle disabling unused-variable warning
-// with a _Pragma. This means that we have to leak the suppression to the
-// user code as well :-(
-#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
-#pragma GCC diagnostic ignored "-Wunused-variable"
-#endif
-
-#if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
-        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
-        namespace{                                                                                  \
-            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
-            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-        }                                                                                           \
-        }                                                                                           \
-        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
-    #endif
-#endif
-
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
-        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
-            INTERNAL_CATCH_TYPE_GEN\
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types> \
-            struct TestName{\
-                TestName(){\
-                    size_t index = 0;                                    \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)}; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
-                    using expander = size_t[]; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
-                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
-                }\
-            };\
-            static const int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
-            return 0;\
-        }();\
-        }\
-        }\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                      \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS       \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
-        template<typename TestType> static void TestFuncName();       \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
-            INTERNAL_CATCH_TYPE_GEN                                                  \
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
-            template<typename... Types>                               \
-            struct TestName {                                         \
-                void reg_tests() {                                          \
-                    size_t index = 0;                                    \
-                    using expander = size_t[];                           \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
-                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
-                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + '<' + std::string(types_list[index % num_types]) + '>', Tags } ), index++)... };/* NOLINT */\
-                }                                                     \
-            };                                                        \
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
-                using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
-                TestInit t;                                           \
-                t.reg_tests();                                        \
-                return 0;                                             \
-            }();                                                      \
-        }                                                             \
-        }                                                             \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
-        template<typename TestType>                                   \
-        static void TestFuncName()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename T,__VA_ARGS__)
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename T, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__)
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
-        template<typename TestType> static void TestFunc();       \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
-        INTERNAL_CATCH_TYPE_GEN\
-        template<typename... Types>                               \
-        struct TestName {                                         \
-            void reg_tests() {                                          \
-                size_t index = 0;                                    \
-                using expander = size_t[];                           \
-                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
-            }                                                     \
-        };\
-        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
-                using TestInit = typename convert<TestName, TmplList>::type; \
-                TestInit t;                                           \
-                t.reg_tests();                                        \
-                return 0;                                             \
-            }();                                                      \
-        }}\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
-        template<typename TestType>                                   \
-        static void TestFunc()
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
-        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, TmplList )
-
-
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
-            INTERNAL_CATCH_TYPE_GEN\
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types> \
-            struct TestNameClass{\
-                TestNameClass(){\
-                    size_t index = 0;                                    \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
-                    using expander = size_t[];\
-                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
-                return 0;\
-        }();\
-        }\
-        }\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
-        template<typename TestType> \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
-                void test();\
-            };\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
-            INTERNAL_CATCH_TYPE_GEN                  \
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types>\
-            struct TestNameClass{\
-                void reg_tests(){\
-                    std::size_t index = 0;\
-                    using expander = std::size_t[];\
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
-                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
-                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + '<' + std::string(types_list[index % num_types]) + '>', Tags } ), index++)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
-                TestInit t;\
-                t.reg_tests();\
-                return 0;\
-            }(); \
-        }\
-        }\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        template<typename TestType> \
-        void TestName<TestType>::test()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
-        template<typename TestType> \
-        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
-            void test();\
-        };\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
-            INTERNAL_CATCH_TYPE_GEN\
-            template<typename...Types>\
-            struct TestNameClass{\
-                void reg_tests(){\
-                    size_t index = 0;\
-                    using expander = size_t[];\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName##_catch_sr, Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                using TestInit = typename convert<TestNameClass, TmplList>::type;\
-                TestInit t;\
-                t.reg_tests();\
-                return 0;\
-            }(); \
-        }}\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        template<typename TestType> \
-        void TestName<TestType>::test()
-
-#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
-        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, TmplList )
-
-
-#endif // CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
-
-
-#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
-
-  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-    #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-    #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
-    #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
-  #else
-    #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-    #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-    #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
-    #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-  #endif
-
-#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
-
-  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-    #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-  #else
-    #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-    #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-  #endif
-
-  // When disabled, these can be shared between proper preprocessor and MSVC preprocessor
-  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-  #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE(__VA_ARGS__)
-  #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-
-#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
-
-  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-    #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-    #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-    #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-    #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
-    #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
-  #else
-    #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-    #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-    #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-    #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-    #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
-    #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-  #endif
-
-#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
-
-  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-    #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-  #else
-    #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-    #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-  #endif
-
-  // When disabled, these can be shared between proper preprocessor and MSVC preprocessor
-  #define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-  #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-  #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-  #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-  #define TEMPLATE_LIST_TEST_CASE( ... ) TEMPLATE_TEST_CASE(__VA_ARGS__)
-  #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-
-#endif // end of user facing macro declarations
-
-
-#endif // CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
-
-
-#ifndef CATCH_TEST_CASE_INFO_HPP_INCLUDED
-#define CATCH_TEST_CASE_INFO_HPP_INCLUDED
-
-
-
-#include <cstdint>
-#include <string>
-#include <vector>
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    /**
-     * A **view** of a tag string that provides case insensitive comparisons
-     *
-     * Note that in Catch2 internals, the square brackets around tags are
-     * not a part of tag's representation, so e.g. "[cool-tag]" is represented
-     * as "cool-tag" internally.
-     */
-    struct Tag {
-        constexpr Tag(StringRef original_):
-            original(original_)
-        {}
-        StringRef original;
-
-        friend bool operator< ( Tag const& lhs, Tag const& rhs );
-        friend bool operator==( Tag const& lhs, Tag const& rhs );
-    };
-
-    class ITestInvoker;
-    struct NameAndTags;
-
-    enum class TestCaseProperties : uint8_t {
-        None = 0,
-        IsHidden = 1 << 1,
-        ShouldFail = 1 << 2,
-        MayFail = 1 << 3,
-        Throws = 1 << 4,
-        NonPortable = 1 << 5,
-        Benchmark = 1 << 6
-    };
-
-    /**
-     * Various metadata about the test case.
-     *
-     * A test case is uniquely identified by its (class)name and tags
-     * combination, with source location being ignored, and other properties
-     * being determined from tags.
-     *
-     * Tags are kept sorted.
-     */
-    struct TestCaseInfo : Detail::NonCopyable {
-
-        TestCaseInfo(StringRef _className,
-                     NameAndTags const& _nameAndTags,
-                     SourceLineInfo const& _lineInfo);
-
-        bool isHidden() const;
-        bool throws() const;
-        bool okToFail() const;
-        bool expectedToFail() const;
-
-        // Adds the tag(s) with test's filename (for the -# flag)
-        void addFilenameTag();
-
-        //! Orders by name, classname and tags
-        friend bool operator<( TestCaseInfo const& lhs,
-                               TestCaseInfo const& rhs );
-
-
-        std::string tagsAsString() const;
-
-        std::string name;
-        StringRef className;
-    private:
-        std::string backingTags;
-        // Internally we copy tags to the backing storage and then add
-        // refs to this storage to the tags vector.
-        void internalAppendTag(StringRef tagString);
-    public:
-        std::vector<Tag> tags;
-        SourceLineInfo lineInfo;
-        TestCaseProperties properties = TestCaseProperties::None;
-    };
-
-    /**
-     * Wrapper over the test case information and the test case invoker
-     *
-     * Does not own either, and is specifically made to be cheap
-     * to copy around.
-     */
-    class TestCaseHandle {
-        TestCaseInfo* m_info;
-        ITestInvoker* m_invoker;
-    public:
-        constexpr TestCaseHandle(TestCaseInfo* info, ITestInvoker* invoker) :
-            m_info(info), m_invoker(invoker) {}
-
-        void prepareTestCase() const {
-            m_invoker->prepareTestCase();
-        }
-
-        void tearDownTestCase() const {
-            m_invoker->tearDownTestCase();
-        }
-
-        void invoke() const {
-            m_invoker->invoke();
-        }
-
-        constexpr TestCaseInfo const& getTestCaseInfo() const {
-            return *m_info;
-        }
-    };
-
-    Detail::unique_ptr<TestCaseInfo>
-    makeTestCaseInfo( StringRef className,
-                      NameAndTags const& nameAndTags,
-                      SourceLineInfo const& lineInfo );
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-#endif // CATCH_TEST_CASE_INFO_HPP_INCLUDED
-
-
-#ifndef CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
-#define CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
-
-
-
-#ifndef CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
-#define CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
-
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-    using exceptionTranslateFunction = std::string(*)();
-
-    class IExceptionTranslator;
-    using ExceptionTranslators = std::vector<Detail::unique_ptr<IExceptionTranslator const>>;
-
-    class IExceptionTranslator {
-    public:
-        virtual ~IExceptionTranslator(); // = default
-        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
-    };
-
-    class IExceptionTranslatorRegistry {
-    public:
-        virtual ~IExceptionTranslatorRegistry(); // = default
-        virtual std::string translateActiveException() const = 0;
-    };
-
-} // namespace Catch
-
-#endif // CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
-
-#include <exception>
-
-namespace Catch {
-    namespace Detail {
-        void registerTranslatorImpl(
-            Detail::unique_ptr<IExceptionTranslator>&& translator );
-    }
-
-    class ExceptionTranslatorRegistrar {
-        template<typename T>
-        class ExceptionTranslator : public IExceptionTranslator {
-        public:
-
-            constexpr ExceptionTranslator( std::string(*translateFunction)( T const& ) )
-            : m_translateFunction( translateFunction )
-            {}
-
-            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-                try {
-                    if( it == itEnd )
-                        std::rethrow_exception(std::current_exception());
-                    else
-                        return (*it)->translate( it+1, itEnd );
-                }
-                catch( T const& ex ) {
-                    return m_translateFunction( ex );
-                }
-#else
-                return "You should never get here!";
-#endif
-            }
-
-        protected:
-            std::string(*m_translateFunction)( T const& );
-        };
-
-    public:
-        template<typename T>
-        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T const& ) ) {
-            Detail::registerTranslatorImpl(
-                Detail::make_unique<ExceptionTranslator<T>>(
-                    translateFunction ) );
-        }
-    };
-
-} // namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
-    static std::string translatorName( signature ); \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-    static std::string translatorName( signature )
-
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
-
-#if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
-            static std::string translatorName( signature )
-#endif
-
-
-// This macro is always prefixed
-#if !defined(CATCH_CONFIG_DISABLE)
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
-#else
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
-#endif
-
-
-#endif // CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
-
-
-#ifndef CATCH_VERSION_HPP_INCLUDED
-#define CATCH_VERSION_HPP_INCLUDED
-
-#include <iosfwd>
-
-namespace Catch {
-
-    // Versioning information
-    struct Version {
-        Version( Version const& ) = delete;
-        Version& operator=( Version const& ) = delete;
-        Version(    unsigned int _majorVersion,
-                    unsigned int _minorVersion,
-                    unsigned int _patchNumber,
-                    char const * const _branchName,
-                    unsigned int _buildNumber );
-
-        unsigned int const majorVersion;
-        unsigned int const minorVersion;
-        unsigned int const patchNumber;
-
-        // buildNumber is only used if branchName is not null
-        char const * const branchName;
-        unsigned int const buildNumber;
-
-        friend std::ostream& operator << ( std::ostream& os, Version const& version );
-    };
-
-    Version const& libraryVersion();
-}
-
-#endif // CATCH_VERSION_HPP_INCLUDED
-
-
-#ifndef CATCH_VERSION_MACROS_HPP_INCLUDED
-#define CATCH_VERSION_MACROS_HPP_INCLUDED
-
-#define CATCH_VERSION_MAJOR 3
-#define CATCH_VERSION_MINOR 7
-#define CATCH_VERSION_PATCH 1
-
-#endif // CATCH_VERSION_MACROS_HPP_INCLUDED
-
-
-/** \file
- * This is a convenience header for Catch2's Generator support. It includes
- * **all** of Catch2 headers related to generators.
- *
- * Generally the Catch2 users should use specific includes they need,
- * but this header can be used instead for ease-of-experimentation, or
- * just plain convenience, at the cost of (significantly) increased
- * compilation times.
- *
- * When a new header is added to either the `generators` folder,
- * or to the corresponding internal subfolder, it should be added here.
- */
-
-#ifndef CATCH_GENERATORS_ALL_HPP_INCLUDED
-#define CATCH_GENERATORS_ALL_HPP_INCLUDED
-
-
-
-#ifndef CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
-#define CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
-
-#include <exception>
-
-namespace Catch {
-
-    // Exception type to be thrown when a Generator runs into an error,
-    // e.g. it cannot initialize the first return value based on
-    // runtime information
-    class GeneratorException : public std::exception {
-        const char* const m_msg = "";
-
-    public:
-        GeneratorException(const char* msg):
-            m_msg(msg)
-        {}
-
-        const char* what() const noexcept override final;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
-
-
-#ifndef CATCH_GENERATORS_HPP_INCLUDED
-#define CATCH_GENERATORS_HPP_INCLUDED
-
-
-
-#ifndef CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
-#define CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
-
-
-#include <string>
-
-namespace Catch {
-
-    namespace Generators {
-        class GeneratorUntypedBase {
-            // Caches result from `toStringImpl`, assume that when it is an
-            // empty string, the cache is invalidated.
-            mutable std::string m_stringReprCache;
-
-            // Counts based on `next` returning true
-            std::size_t m_currentElementIndex = 0;
-
-            /**
-             * Attempts to move the generator to the next element
-             *
-             * Returns true iff the move succeeded (and a valid element
-             * can be retrieved).
-             */
-            virtual bool next() = 0;
-
-            //! Customization point for `currentElementAsString`
-            virtual std::string stringifyImpl() const = 0;
-
-        public:
-            GeneratorUntypedBase() = default;
-            // Generation of copy ops is deprecated (and Clang will complain)
-            // if there is a user destructor defined
-            GeneratorUntypedBase(GeneratorUntypedBase const&) = default;
-            GeneratorUntypedBase& operator=(GeneratorUntypedBase const&) = default;
-
-            virtual ~GeneratorUntypedBase(); // = default;
-
-            /**
-             * Attempts to move the generator to the next element
-             *
-             * Serves as a non-virtual interface to `next`, so that the
-             * top level interface can provide sanity checking and shared
-             * features.
-             *
-             * As with `next`, returns true iff the move succeeded and
-             * the generator has new valid element to provide.
-             */
-            bool countedNext();
-
-            std::size_t currentElementIndex() const { return m_currentElementIndex; }
-
-            /**
-             * Returns generator's current element as user-friendly string.
-             *
-             * By default returns string equivalent to calling
-             * `Catch::Detail::stringify` on the current element, but generators
-             * can customize their implementation as needed.
-             *
-             * Not thread-safe due to internal caching.
-             *
-             * The returned ref is valid only until the generator instance
-             * is destructed, or it moves onto the next element, whichever
-             * comes first.
-             */
-            StringRef currentElementAsString() const;
-        };
-        using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
-
-    } // namespace Generators
-
-    class IGeneratorTracker {
-    public:
-        virtual ~IGeneratorTracker(); // = default;
-        virtual auto hasGenerator() const -> bool = 0;
-        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
-        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
-    };
-
-} // namespace Catch
-
-#endif // CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
-
-#include <vector>
-#include <tuple>
-
-namespace Catch {
-
-namespace Generators {
-
-namespace Detail {
-
-    //! Throws GeneratorException with the provided message
-    [[noreturn]]
-    void throw_generator_exception(char const * msg);
-
-} // end namespace detail
-
-    template<typename T>
-    class IGenerator : public GeneratorUntypedBase {
-        std::string stringifyImpl() const override {
-            return ::Catch::Detail::stringify( get() );
-        }
-
-    public:
-        // Returns the current element of the generator
-        //
-        // \Precondition The generator is either freshly constructed,
-        // or the last call to `next()` returned true
-        virtual T const& get() const = 0;
-        using type = T;
-    };
-
-    template <typename T>
-    using GeneratorPtr = Catch::Detail::unique_ptr<IGenerator<T>>;
-
-    template <typename T>
-    class GeneratorWrapper final {
-        GeneratorPtr<T> m_generator;
-    public:
-        //! Takes ownership of the passed pointer.
-        GeneratorWrapper(IGenerator<T>* generator):
-            m_generator(generator) {}
-        GeneratorWrapper(GeneratorPtr<T> generator):
-            m_generator(CATCH_MOVE(generator)) {}
-
-        T const& get() const {
-            return m_generator->get();
-        }
-        bool next() {
-            return m_generator->countedNext();
-        }
-    };
-
-
-    template<typename T>
-    class SingleValueGenerator final : public IGenerator<T> {
-        T m_value;
-    public:
-        SingleValueGenerator(T const& value) :
-            m_value(value)
-        {}
-        SingleValueGenerator(T&& value):
-            m_value(CATCH_MOVE(value))
-        {}
-
-        T const& get() const override {
-            return m_value;
-        }
-        bool next() override {
-            return false;
-        }
-    };
-
-    template<typename T>
-    class FixedValuesGenerator final : public IGenerator<T> {
-        static_assert(!std::is_same<T, bool>::value,
-            "FixedValuesGenerator does not support bools because of std::vector<bool>"
-            "specialization, use SingleValue Generator instead.");
-        std::vector<T> m_values;
-        size_t m_idx = 0;
-    public:
-        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
-
-        T const& get() const override {
-            return m_values[m_idx];
-        }
-        bool next() override {
-            ++m_idx;
-            return m_idx < m_values.size();
-        }
-    };
-
-    template <typename T, typename DecayedT = std::decay_t<T>>
-    GeneratorWrapper<DecayedT> value( T&& value ) {
-        return GeneratorWrapper<DecayedT>(
-            Catch::Detail::make_unique<SingleValueGenerator<DecayedT>>(
-                CATCH_FORWARD( value ) ) );
-    }
-    template <typename T>
-    GeneratorWrapper<T> values(std::initializer_list<T> values) {
-        return GeneratorWrapper<T>(Catch::Detail::make_unique<FixedValuesGenerator<T>>(values));
-    }
-
-    template<typename T>
-    class Generators : public IGenerator<T> {
-        std::vector<GeneratorWrapper<T>> m_generators;
-        size_t m_current = 0;
-
-        void add_generator( GeneratorWrapper<T>&& generator ) {
-            m_generators.emplace_back( CATCH_MOVE( generator ) );
-        }
-        void add_generator( T const& val ) {
-            m_generators.emplace_back( value( val ) );
-        }
-        void add_generator( T&& val ) {
-            m_generators.emplace_back( value( CATCH_MOVE( val ) ) );
-        }
-        template <typename U>
-        std::enable_if_t<!std::is_same<std::decay_t<U>, T>::value>
-        add_generator( U&& val ) {
-            add_generator( T( CATCH_FORWARD( val ) ) );
-        }
-
-        template <typename U> void add_generators( U&& valueOrGenerator ) {
-            add_generator( CATCH_FORWARD( valueOrGenerator ) );
-        }
-
-        template <typename U, typename... Gs>
-        void add_generators( U&& valueOrGenerator, Gs&&... moreGenerators ) {
-            add_generator( CATCH_FORWARD( valueOrGenerator ) );
-            add_generators( CATCH_FORWARD( moreGenerators )... );
-        }
-
-    public:
-        template <typename... Gs>
-        Generators(Gs &&... moreGenerators) {
-            m_generators.reserve(sizeof...(Gs));
-            add_generators(CATCH_FORWARD(moreGenerators)...);
-        }
-
-        T const& get() const override {
-            return m_generators[m_current].get();
-        }
-
-        bool next() override {
-            if (m_current >= m_generators.size()) {
-                return false;
-            }
-            const bool current_status = m_generators[m_current].next();
-            if (!current_status) {
-                ++m_current;
-            }
-            return m_current < m_generators.size();
-        }
-    };
-
-
-    template <typename... Ts>
-    GeneratorWrapper<std::tuple<std::decay_t<Ts>...>>
-    table( std::initializer_list<std::tuple<std::decay_t<Ts>...>> tuples ) {
-        return values<std::tuple<Ts...>>( tuples );
-    }
-
-    // Tag type to signal that a generator sequence should convert arguments to a specific type
-    template <typename T>
-    struct as {};
-
-    template<typename T, typename... Gs>
-    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
-        return Generators<T>(CATCH_MOVE(generator), CATCH_FORWARD(moreGenerators)...);
-    }
-    template<typename T>
-    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
-        return Generators<T>(CATCH_MOVE(generator));
-    }
-    template<typename T, typename... Gs>
-    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<std::decay_t<T>> {
-        return makeGenerators( value( CATCH_FORWARD( val ) ), CATCH_FORWARD( moreGenerators )... );
-    }
-    template<typename T, typename U, typename... Gs>
-    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
-        return makeGenerators( value( T( CATCH_FORWARD( val ) ) ), CATCH_FORWARD( moreGenerators )... );
-    }
-
-    IGeneratorTracker* acquireGeneratorTracker( StringRef generatorName,
-                                                SourceLineInfo const& lineInfo );
-    IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
-                                               SourceLineInfo lineInfo,
-                                               GeneratorBasePtr&& generator );
-
-    template<typename L>
-    auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> typename decltype(generatorExpression())::type {
-        using UnderlyingType = typename decltype(generatorExpression())::type;
-
-        IGeneratorTracker* tracker = acquireGeneratorTracker( generatorName, lineInfo );
-        // Creation of tracker is delayed after generator creation, so
-        // that constructing generator can fail without breaking everything.
-        if (!tracker) {
-            tracker = createGeneratorTracker(
-                generatorName,
-                lineInfo,
-                Catch::Detail::make_unique<Generators<UnderlyingType>>(
-                    generatorExpression() ) );
-        }
-
-        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker->getGenerator() );
-        return generator.get();
-    }
-
-} // namespace Generators
-} // namespace Catch
-
-#define CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL( ... ) #__VA_ARGS__##_catch_sr
-#define CATCH_INTERNAL_GENERATOR_STRINGIZE(...) CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL(__VA_ARGS__)
-
-#define GENERATE( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
-                                 CATCH_INTERNAL_LINEINFO, \
-                                 [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
-#define GENERATE_COPY( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
-                                 CATCH_INTERNAL_LINEINFO, \
-                                 [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
-#define GENERATE_REF( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
-                                 CATCH_INTERNAL_LINEINFO, \
-                                 [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
-
-#endif // CATCH_GENERATORS_HPP_INCLUDED
-
-
-#ifndef CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
-#define CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
-
-
-#include <cassert>
-
-namespace Catch {
-namespace Generators {
-
-    template <typename T>
-    class TakeGenerator final : public IGenerator<T> {
-        GeneratorWrapper<T> m_generator;
-        size_t m_returned = 0;
-        size_t m_target;
-    public:
-        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
-            m_generator(CATCH_MOVE(generator)),
-            m_target(target)
-        {
-            assert(target != 0 && "Empty generators are not allowed");
-        }
-        T const& get() const override {
-            return m_generator.get();
-        }
-        bool next() override {
-            ++m_returned;
-            if (m_returned >= m_target) {
-                return false;
-            }
-
-            const auto success = m_generator.next();
-            // If the underlying generator does not contain enough values
-            // then we cut short as well
-            if (!success) {
-                m_returned = m_target;
-            }
-            return success;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(Catch::Detail::make_unique<TakeGenerator<T>>(target, CATCH_MOVE(generator)));
-    }
-
-
-    template <typename T, typename Predicate>
-    class FilterGenerator final : public IGenerator<T> {
-        GeneratorWrapper<T> m_generator;
-        Predicate m_predicate;
-    public:
-        template <typename P = Predicate>
-        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
-            m_generator(CATCH_MOVE(generator)),
-            m_predicate(CATCH_FORWARD(pred))
-        {
-            if (!m_predicate(m_generator.get())) {
-                // It might happen that there are no values that pass the
-                // filter. In that case we throw an exception.
-                auto has_initial_value = next();
-                if (!has_initial_value) {
-                    Detail::throw_generator_exception("No valid value found in filtered generator");
-                }
-            }
-        }
-
-        T const& get() const override {
-            return m_generator.get();
-        }
-
-        bool next() override {
-            bool success = m_generator.next();
-            if (!success) {
-                return false;
-            }
-            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
-            return success;
-        }
-    };
-
-
-    template <typename T, typename Predicate>
-    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(Catch::Detail::make_unique<FilterGenerator<T, Predicate>>(CATCH_FORWARD(pred), CATCH_MOVE(generator)));
-    }
-
-    template <typename T>
-    class RepeatGenerator final : public IGenerator<T> {
-        static_assert(!std::is_same<T, bool>::value,
-            "RepeatGenerator currently does not support bools"
-            "because of std::vector<bool> specialization");
-        GeneratorWrapper<T> m_generator;
-        mutable std::vector<T> m_returned;
-        size_t m_target_repeats;
-        size_t m_current_repeat = 0;
-        size_t m_repeat_index = 0;
-    public:
-        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
-            m_generator(CATCH_MOVE(generator)),
-            m_target_repeats(repeats)
-        {
-            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
-        }
-
-        T const& get() const override {
-            if (m_current_repeat == 0) {
-                m_returned.push_back(m_generator.get());
-                return m_returned.back();
-            }
-            return m_returned[m_repeat_index];
-        }
-
-        bool next() override {
-            // There are 2 basic cases:
-            // 1) We are still reading the generator
-            // 2) We are reading our own cache
-
-            // In the first case, we need to poke the underlying generator.
-            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
-            if (m_current_repeat == 0) {
-                const auto success = m_generator.next();
-                if (!success) {
-                    ++m_current_repeat;
-                }
-                return m_current_repeat < m_target_repeats;
-            }
-
-            // In the second case, we need to move indices forward and check that we haven't run up against the end
-            ++m_repeat_index;
-            if (m_repeat_index == m_returned.size()) {
-                m_repeat_index = 0;
-                ++m_current_repeat;
-            }
-            return m_current_repeat < m_target_repeats;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(Catch::Detail::make_unique<RepeatGenerator<T>>(repeats, CATCH_MOVE(generator)));
-    }
-
-    template <typename T, typename U, typename Func>
-    class MapGenerator final : public IGenerator<T> {
-        // TBD: provide static assert for mapping function, for friendly error message
-        GeneratorWrapper<U> m_generator;
-        Func m_function;
-        // To avoid returning dangling reference, we have to save the values
-        T m_cache;
-    public:
-        template <typename F2 = Func>
-        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
-            m_generator(CATCH_MOVE(generator)),
-            m_function(CATCH_FORWARD(function)),
-            m_cache(m_function(m_generator.get()))
-        {}
-
-        T const& get() const override {
-            return m_cache;
-        }
-        bool next() override {
-            const auto success = m_generator.next();
-            if (success) {
-                m_cache = m_function(m_generator.get());
-            }
-            return success;
-        }
-    };
-
-    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
-    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
-        return GeneratorWrapper<T>(
-            Catch::Detail::make_unique<MapGenerator<T, U, Func>>(CATCH_FORWARD(function), CATCH_MOVE(generator))
-        );
-    }
-
-    template <typename T, typename U, typename Func>
-    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
-        return GeneratorWrapper<T>(
-            Catch::Detail::make_unique<MapGenerator<T, U, Func>>(CATCH_FORWARD(function), CATCH_MOVE(generator))
-        );
-    }
-
-    template <typename T>
-    class ChunkGenerator final : public IGenerator<std::vector<T>> {
-        std::vector<T> m_chunk;
-        size_t m_chunk_size;
-        GeneratorWrapper<T> m_generator;
-        bool m_used_up = false;
-    public:
-        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
-            m_chunk_size(size), m_generator(CATCH_MOVE(generator))
-        {
-            m_chunk.reserve(m_chunk_size);
-            if (m_chunk_size != 0) {
-                m_chunk.push_back(m_generator.get());
-                for (size_t i = 1; i < m_chunk_size; ++i) {
-                    if (!m_generator.next()) {
-                        Detail::throw_generator_exception("Not enough values to initialize the first chunk");
-                    }
-                    m_chunk.push_back(m_generator.get());
-                }
-            }
-        }
-        std::vector<T> const& get() const override {
-            return m_chunk;
-        }
-        bool next() override {
-            m_chunk.clear();
-            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
-                if (!m_generator.next()) {
-                    return false;
-                }
-                m_chunk.push_back(m_generator.get());
-            }
-            return true;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<std::vector<T>>(
-            Catch::Detail::make_unique<ChunkGenerator<T>>(size, CATCH_MOVE(generator))
-        );
-    }
-
-} // namespace Generators
-} // namespace Catch
-
-
-#endif // CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
-
-
-#ifndef CATCH_GENERATORS_RANDOM_HPP_INCLUDED
-#define CATCH_GENERATORS_RANDOM_HPP_INCLUDED
-
-
-
-#ifndef CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
-#define CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
-
-#include <cstdint>
-
-namespace Catch {
-
-    // This is a simple implementation of C++11 Uniform Random Number
-    // Generator. It does not provide all operators, because Catch2
-    // does not use it, but it should behave as expected inside stdlib's
-    // distributions.
-    // The implementation is based on the PCG family (http://pcg-random.org)
-    class SimplePcg32 {
-        using state_type = std::uint64_t;
-    public:
-        using result_type = std::uint32_t;
-        static constexpr result_type (min)() {
-            return 0;
-        }
-        static constexpr result_type (max)() {
-            return static_cast<result_type>(-1);
-        }
-
-        // Provide some default initial state for the default constructor
-        SimplePcg32():SimplePcg32(0xed743cc4U) {}
-
-        explicit SimplePcg32(result_type seed_);
-
-        void seed(result_type seed_);
-        void discard(uint64_t skip);
-
-        result_type operator()();
-
-    private:
-        friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
-        friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
-
-        // In theory we also need operator<< and operator>>
-        // In practice we do not use them, so we will skip them for now
-
-
-        std::uint64_t m_state;
-        // This part of the state determines which "stream" of the numbers
-        // is chosen -- we take it as a constant for Catch2, so we only
-        // need to deal with seeding the main state.
-        // Picked by reading 8 bytes from `/dev/random` :-)
-        static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
-
-
-
-#ifndef CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
-#define CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
-
-
-
-
-#ifndef CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
-#define CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
-
-#include <climits>
-#include <cstddef>
-#include <cstdint>
-#include <type_traits>
-
-// Note: We use the usual enable-disable-autodetect dance here even though
-//       we do not support these in CMake configuration options (yet?).
-//       It is highly unlikely that we will need to make these actually
-//       user-configurable, but this will make it simpler if weend up needing
-//       it, and it provides an escape hatch to the users who need it.
-#if defined( __SIZEOF_INT128__ )
-#    define CATCH_CONFIG_INTERNAL_UINT128
-// Unlike GCC, MSVC does not polyfill umul as mulh + mul pair on ARM machines.
-// Currently we do not bother doing this ourselves, but we could if it became
-// important for perf.
-#elif defined( _MSC_VER ) && defined( _M_X64 )
-#    define CATCH_CONFIG_INTERNAL_MSVC_UMUL128
-#endif
-
-#if defined( CATCH_CONFIG_INTERNAL_UINT128 ) && \
-    !defined( CATCH_CONFIG_NO_UINT128 ) &&      \
-    !defined( CATCH_CONFIG_UINT128 )
-#define CATCH_CONFIG_UINT128
-#endif
-
-#if defined( CATCH_CONFIG_INTERNAL_MSVC_UMUL128 ) && \
-    !defined( CATCH_CONFIG_NO_MSVC_UMUL128 ) &&      \
-    !defined( CATCH_CONFIG_MSVC_UMUL128 )
-#    define CATCH_CONFIG_MSVC_UMUL128
-#    include <intrin.h>
-#endif
-
-
-namespace Catch {
-    namespace Detail {
-
-        template <std::size_t>
-        struct SizedUnsignedType;
-#define SizedUnsignedTypeHelper( TYPE )        \
-    template <>                                \
-    struct SizedUnsignedType<sizeof( TYPE )> { \
-        using type = TYPE;                     \
-    }
-
-        SizedUnsignedTypeHelper( std::uint8_t );
-        SizedUnsignedTypeHelper( std::uint16_t );
-        SizedUnsignedTypeHelper( std::uint32_t );
-        SizedUnsignedTypeHelper( std::uint64_t );
-#undef SizedUnsignedTypeHelper
-
-        template <std::size_t sz>
-        using SizedUnsignedType_t = typename SizedUnsignedType<sz>::type;
-
-        template <typename T>
-        using DoubleWidthUnsignedType_t = SizedUnsignedType_t<2 * sizeof( T )>;
-
-        template <typename T>
-        struct ExtendedMultResult {
-            T upper;
-            T lower;
-            constexpr bool operator==( ExtendedMultResult const& rhs ) const {
-                return upper == rhs.upper && lower == rhs.lower;
-            }
-        };
-
-        /**
-         * Returns 128 bit result of lhs * rhs using portable C++ code
-         *
-         * This implementation is almost twice as fast as naive long multiplication,
-         * and unlike intrinsic-based approach, it supports constexpr evaluation.
-         */
-        constexpr ExtendedMultResult<std::uint64_t>
-        extendedMultPortable(std::uint64_t lhs, std::uint64_t rhs) {
-#define CarryBits( x ) ( x >> 32 )
-#define Digits( x ) ( x & 0xFF'FF'FF'FF )
-            std::uint64_t lhs_low = Digits( lhs );
-            std::uint64_t rhs_low = Digits( rhs );
-            std::uint64_t low_low = ( lhs_low * rhs_low );
-            std::uint64_t high_high = CarryBits( lhs ) * CarryBits( rhs );
-
-            // We add in carry bits from low-low already
-            std::uint64_t high_low =
-                ( CarryBits( lhs ) * rhs_low ) + CarryBits( low_low );
-            // Note that we can add only low bits from high_low, to avoid
-            // overflow with large inputs
-            std::uint64_t low_high =
-                ( lhs_low * CarryBits( rhs ) ) + Digits( high_low );
-
-            return { high_high + CarryBits( high_low ) + CarryBits( low_high ),
-                     ( low_high << 32 ) | Digits( low_low ) };
-#undef CarryBits
-#undef Digits
-        }
-
-        //! Returns 128 bit result of lhs * rhs
-        inline ExtendedMultResult<std::uint64_t>
-        extendedMult( std::uint64_t lhs, std::uint64_t rhs ) {
-#if defined( CATCH_CONFIG_UINT128 )
-            auto result = __uint128_t( lhs ) * __uint128_t( rhs );
-            return { static_cast<std::uint64_t>( result >> 64 ),
-                     static_cast<std::uint64_t>( result ) };
-#elif defined( CATCH_CONFIG_MSVC_UMUL128 )
-            std::uint64_t high;
-            std::uint64_t low = _umul128( lhs, rhs, &high );
-            return { high, low };
-#else
-            return extendedMultPortable( lhs, rhs );
-#endif
-        }
-
-
-        template <typename UInt>
-        constexpr ExtendedMultResult<UInt> extendedMult( UInt lhs, UInt rhs ) {
-            static_assert( std::is_unsigned<UInt>::value,
-                           "extendedMult can only handle unsigned integers" );
-            static_assert( sizeof( UInt ) < sizeof( std::uint64_t ),
-                           "Generic extendedMult can only handle types smaller "
-                           "than uint64_t" );
-            using WideType = DoubleWidthUnsignedType_t<UInt>;
-
-            auto result = WideType( lhs ) * WideType( rhs );
-            return {
-                static_cast<UInt>( result >> ( CHAR_BIT * sizeof( UInt ) ) ),
-                static_cast<UInt>( result & UInt( -1 ) ) };
-        }
-
-
-        template <typename TargetType,
-                  typename Generator>
-            std::enable_if_t<sizeof(typename Generator::result_type) >= sizeof(TargetType),
-            TargetType> fillBitsFrom(Generator& gen) {
-            using gresult_type = typename Generator::result_type;
-            static_assert( std::is_unsigned<TargetType>::value, "Only unsigned integers are supported" );
-            static_assert( Generator::min() == 0 &&
-                           Generator::max() == static_cast<gresult_type>( -1 ),
-                           "Generator must be able to output all numbers in its result type (effectively it must be a random bit generator)" );
-
-            // We want to return the top bits from a generator, as they are
-            // usually considered higher quality.
-            constexpr auto generated_bits = sizeof( gresult_type ) * CHAR_BIT;
-            constexpr auto return_bits = sizeof( TargetType ) * CHAR_BIT;
-
-            return static_cast<TargetType>( gen() >>
-                                            ( generated_bits - return_bits) );
-        }
-
-        template <typename TargetType,
-                  typename Generator>
-            std::enable_if_t<sizeof(typename Generator::result_type) < sizeof(TargetType),
-            TargetType> fillBitsFrom(Generator& gen) {
-            using gresult_type = typename Generator::result_type;
-            static_assert( std::is_unsigned<TargetType>::value,
-                           "Only unsigned integers are supported" );
-            static_assert( Generator::min() == 0 &&
-                           Generator::max() == static_cast<gresult_type>( -1 ),
-                           "Generator must be able to output all numbers in its result type (effectively it must be a random bit generator)" );
-
-            constexpr auto generated_bits = sizeof( gresult_type ) * CHAR_BIT;
-            constexpr auto return_bits = sizeof( TargetType ) * CHAR_BIT;
-            std::size_t filled_bits = 0;
-            TargetType ret = 0;
-            do {
-                ret <<= generated_bits;
-                ret |= gen();
-                filled_bits += generated_bits;
-            } while ( filled_bits < return_bits );
-
-            return ret;
-        }
-
-        /*
-         * Transposes numbers into unsigned type while keeping their ordering
-         *
-         * This means that signed types are changed so that the ordering is
-         * [INT_MIN, ..., -1, 0, ..., INT_MAX], rather than order we would
-         * get by simple casting ([0, ..., INT_MAX, INT_MIN, ..., -1])
-         */
-        template <typename OriginalType, typename UnsignedType>
-        constexpr
-        std::enable_if_t<std::is_signed<OriginalType>::value, UnsignedType>
-        transposeToNaturalOrder( UnsignedType in ) {
-            static_assert(
-                sizeof( OriginalType ) == sizeof( UnsignedType ),
-                "reordering requires the same sized types on both sides" );
-            static_assert( std::is_unsigned<UnsignedType>::value,
-                           "Input type must be unsigned" );
-            // Assuming 2s complement (standardized in current C++), the
-            // positive and negative numbers are already internally ordered,
-            // and their difference is in the top bit. Swapping it orders
-            // them the desired way.
-            constexpr auto highest_bit =
-                UnsignedType( 1 ) << ( sizeof( UnsignedType ) * CHAR_BIT - 1 );
-            return static_cast<UnsignedType>( in ^ highest_bit );
-        }
-
-
-
-        template <typename OriginalType,
-                  typename UnsignedType>
-        constexpr
-        std::enable_if_t<std::is_unsigned<OriginalType>::value, UnsignedType>
-            transposeToNaturalOrder(UnsignedType in) {
-            static_assert(
-                sizeof( OriginalType ) == sizeof( UnsignedType ),
-                "reordering requires the same sized types on both sides" );
-            static_assert( std::is_unsigned<UnsignedType>::value, "Input type must be unsigned" );
-            // No reordering is needed for unsigned -> unsigned
-            return in;
-        }
-    } // namespace Detail
-} // namespace Catch
-
-#endif // CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
-
-namespace Catch {
-
-/**
- * Implementation of uniform distribution on integers.
- *
- * Unlike `std::uniform_int_distribution`, this implementation supports
- * various 1 byte integral types, including bool (but you should not
- * actually use it for bools).
- *
- * The underlying algorithm is based on the one described in "Fast Random
- * Integer Generation in an Interval" by Daniel Lemire, but has been
- * optimized under the assumption of reuse of the same distribution object.
- */
-template <typename IntegerType>
-class uniform_integer_distribution {
-    static_assert(std::is_integral<IntegerType>::value, "...");
-
-    using UnsignedIntegerType = Detail::SizedUnsignedType_t<sizeof(IntegerType)>;
-
-    // Only the left bound is stored, and we store it converted to its
-    // unsigned image. This avoids having to do the conversions inside
-    // the operator(), at the cost of having to do the conversion in
-    // the a() getter. The right bound is only needed in the b() getter,
-    // so we recompute it there from other stored data.
-    UnsignedIntegerType m_a;
-
-    // How many different values are there in [a, b]. a == b => 1, can be 0 for distribution over all values in the type.
-    UnsignedIntegerType m_ab_distance;
-
-    // We hoisted this out of the main generation function. Technically,
-    // this means that using this distribution will be slower than Lemire's
-    // algorithm if this distribution instance will be used only few times,
-    // but it will be faster if it is used many times. Since Catch2 uses
-    // distributions only to implement random generators, we assume that each
-    // distribution will be reused many times and this is an optimization.
-    UnsignedIntegerType m_rejection_threshold = 0;
-
-    static constexpr UnsignedIntegerType computeDistance(IntegerType a, IntegerType b) {
-        // This overflows and returns 0 if a == 0 and b == TYPE_MAX.
-        // We handle that later when generating the number.
-        return transposeTo(b) - transposeTo(a) + 1;
-    }
-
-    static constexpr UnsignedIntegerType computeRejectionThreshold(UnsignedIntegerType ab_distance) {
-        // distance == 0 means that we will return all possible values from
-        // the type's range, and that we shouldn't reject anything.
-        if ( ab_distance == 0 ) { return 0; }
-        return ( ~ab_distance + 1 ) % ab_distance;
-    }
-
-    static constexpr UnsignedIntegerType transposeTo(IntegerType in) {
-        return Detail::transposeToNaturalOrder<IntegerType>(
-            static_cast<UnsignedIntegerType>( in ) );
-    }
-    static constexpr IntegerType transposeBack(UnsignedIntegerType in) {
-        return static_cast<IntegerType>(
-            Detail::transposeToNaturalOrder<IntegerType>(in) );
-    }
-
-public:
-    using result_type = IntegerType;
-
-    constexpr uniform_integer_distribution( IntegerType a, IntegerType b ):
-        m_a( transposeTo(a) ),
-        m_ab_distance( computeDistance(a, b) ),
-        m_rejection_threshold( computeRejectionThreshold(m_ab_distance) ) {
-        assert( a <= b );
-    }
-
-    template <typename Generator>
-    constexpr result_type operator()( Generator& g ) {
-        // All possible values of result_type are valid.
-        if ( m_ab_distance == 0 ) {
-            return transposeBack( Detail::fillBitsFrom<UnsignedIntegerType>( g ) );
-        }
-
-        auto random_number = Detail::fillBitsFrom<UnsignedIntegerType>( g );
-        auto emul = Detail::extendedMult( random_number, m_ab_distance );
-        // Unlike Lemire's algorithm we skip the ab_distance check, since
-        // we precomputed the rejection threshold, which is always tighter.
-        while (emul.lower < m_rejection_threshold) {
-            random_number = Detail::fillBitsFrom<UnsignedIntegerType>( g );
-            emul = Detail::extendedMult( random_number, m_ab_distance );
-        }
-
-        return transposeBack(m_a + emul.upper);
-    }
-
-    constexpr result_type a() const { return transposeBack(m_a); }
-    constexpr result_type b() const { return transposeBack(m_ab_distance + m_a - 1); }
-};
-
-} // end namespace Catch
-
-#endif // CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
-
-
-
-#ifndef CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
-#define CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
-
-
-
-
-#ifndef CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
-#define CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
-
-
-
-#ifndef CATCH_POLYFILLS_HPP_INCLUDED
-#define CATCH_POLYFILLS_HPP_INCLUDED
-
-namespace Catch {
-
-    bool isnan(float f);
-    bool isnan(double d);
-
-    float nextafter(float x, float y);
-    double nextafter(double x, double y);
-
-}
-
-#endif // CATCH_POLYFILLS_HPP_INCLUDED
-
-#include <cassert>
-#include <cmath>
-#include <cstdint>
-#include <limits>
-#include <type_traits>
-
-namespace Catch {
-
-    namespace Detail {
-        /**
-         * Returns the largest magnitude of 1-ULP distance inside the [a, b] range.
-         *
-         * Assumes `a < b`.
-         */
-        template <typename FloatType>
-        FloatType gamma(FloatType a, FloatType b) {
-            static_assert( std::is_floating_point<FloatType>::value,
-                           "gamma returns the largest ULP magnitude within "
-                           "floating point range [a, b]. This only makes sense "
-                           "for floating point types" );
-            assert( a <= b );
-
-            const auto gamma_up = Catch::nextafter( a, std::numeric_limits<FloatType>::infinity() ) - a;
-            const auto gamma_down = b - Catch::nextafter( b, -std::numeric_limits<FloatType>::infinity() );
-
-            return gamma_up < gamma_down ? gamma_down : gamma_up;
-        }
-
-        template <typename FloatingPoint>
-        struct DistanceTypePicker;
-        template <>
-        struct DistanceTypePicker<float> {
-            using type = std::uint32_t;
-        };
-        template <>
-        struct DistanceTypePicker<double> {
-            using type = std::uint64_t;
-        };
-
-        template <typename T>
-        using DistanceType = typename DistanceTypePicker<T>::type;
-
-#if defined( __GNUC__ ) || defined( __clang__ )
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-        /**
-         * Computes the number of equi-distant floats in [a, b]
-         *
-         * Since not every range can be split into equidistant floats
-         * exactly, we actually compute ceil(b/distance - a/distance),
-         * because in those cases we want to overcount.
-         *
-         * Uses modified Dekker's FastTwoSum algorithm to handle rounding.
-         */
-        template <typename FloatType>
-        DistanceType<FloatType>
-        count_equidistant_floats( FloatType a, FloatType b, FloatType distance ) {
-            assert( a <= b );
-            // We get distance as gamma for our uniform float distribution,
-            // so this will round perfectly.
-            const auto ag = a / distance;
-            const auto bg = b / distance;
-
-            const auto s = bg - ag;
-            const auto err = ( std::fabs( a ) <= std::fabs( b ) )
-                                 ? -ag - ( s - bg )
-                                 : bg - ( s + ag );
-            const auto ceil_s = static_cast<DistanceType<FloatType>>( std::ceil( s ) );
-
-            return ( ceil_s != s ) ? ceil_s : ceil_s + ( err > 0 );
-        }
-#if defined( __GNUC__ ) || defined( __clang__ )
-#    pragma GCC diagnostic pop
-#endif
-
-    }
-
-} // end namespace Catch
-
-#endif // CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
-
-#include <cmath>
-#include <type_traits>
-
-namespace Catch {
-
-    namespace Detail {
-#if defined( __GNUC__ ) || defined( __clang__ )
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-        // The issue with overflow only happens with maximal ULP and HUGE
-        // distance, e.g. when generating numbers in [-inf, inf] for given
-        // type. So we only check for the largest possible ULP in the
-        // type, and return something that does not overflow to inf in 1 mult.
-        constexpr std::uint64_t calculate_max_steps_in_one_go(double gamma) {
-            if ( gamma == 1.99584030953472e+292 ) { return 9007199254740991; }
-            return static_cast<std::uint64_t>( -1 );
-        }
-        constexpr std::uint32_t calculate_max_steps_in_one_go(float gamma) {
-            if ( gamma == 2.028241e+31f ) { return 16777215; }
-            return static_cast<std::uint32_t>( -1 );
-        }
-#if defined( __GNUC__ ) || defined( __clang__ )
-#    pragma GCC diagnostic pop
-#endif
-    }
-
-/**
- * Implementation of uniform distribution on floating point numbers.
- *
- * Note that we support only `float` and `double` types, because these
- * usually mean the same thing across different platform. `long double`
- * varies wildly by platform and thus we cannot provide reproducible
- * implementation. Also note that we don't implement all parts of
- * distribution per standard: this distribution is not serializable, nor
- * can the range be arbitrarily reset.
- *
- * The implementation also uses different approach than the one taken by
- * `std::uniform_real_distribution`, where instead of generating a number
- * between [0, 1) and then multiplying the range bounds with it, we first
- * split the [a, b] range into a set of equidistributed floating point
- * numbers, and then use uniform int distribution to pick which one to
- * return.
- *
- * This has the advantage of guaranteeing uniformity (the multiplication
- * method loses uniformity due to rounding when multiplying floats), except
- * for small non-uniformity at one side of the interval, where we have
- * to deal with the fact that not every interval is splittable into
- * equidistributed floats.
- *
- * Based on "Drawing random floating-point numbers from an interval" by
- * Frederic Goualard.
- */
-template <typename FloatType>
-class uniform_floating_point_distribution {
-    static_assert(std::is_floating_point<FloatType>::value, "...");
-    static_assert(!std::is_same<FloatType, long double>::value,
-                  "We do not support long double due to inconsistent behaviour between platforms");
-
-    using WidthType = Detail::DistanceType<FloatType>;
-
-    FloatType m_a, m_b;
-    FloatType m_ulp_magnitude;
-    WidthType m_floats_in_range;
-    uniform_integer_distribution<WidthType> m_int_dist;
-
-    // In specific cases, we can overflow into `inf` when computing the
-    // `steps * g` offset. To avoid this, we don't offset by more than this
-    // in one multiply + addition.
-    WidthType m_max_steps_in_one_go;
-    // We don't want to do the magnitude check every call to `operator()`
-    bool m_a_has_leq_magnitude;
-
-public:
-    using result_type = FloatType;
-
-    uniform_floating_point_distribution( FloatType a, FloatType b ):
-        m_a( a ),
-        m_b( b ),
-        m_ulp_magnitude( Detail::gamma( m_a, m_b ) ),
-        m_floats_in_range( Detail::count_equidistant_floats( m_a, m_b, m_ulp_magnitude ) ),
-        m_int_dist(0, m_floats_in_range),
-        m_max_steps_in_one_go( Detail::calculate_max_steps_in_one_go(m_ulp_magnitude)),
-        m_a_has_leq_magnitude(std::fabs(m_a) <= std::fabs(m_b))
-    {
-        assert( a <= b );
-    }
-
-    template <typename Generator>
-    result_type operator()( Generator& g ) {
-        WidthType steps = m_int_dist( g );
-        if ( m_a_has_leq_magnitude ) {
-            if ( steps == m_floats_in_range ) { return m_a; }
-            auto b = m_b;
-            while (steps > m_max_steps_in_one_go) {
-                b -= m_max_steps_in_one_go * m_ulp_magnitude;
-                steps -= m_max_steps_in_one_go;
-            }
-            return b - steps * m_ulp_magnitude;
-        } else {
-            if ( steps == m_floats_in_range ) { return m_b; }
-            auto a = m_a;
-            while (steps > m_max_steps_in_one_go) {
-                a += m_max_steps_in_one_go * m_ulp_magnitude;
-                steps -= m_max_steps_in_one_go;
-            }
-            return a + steps * m_ulp_magnitude;
-        }
-    }
-
-    result_type a() const { return m_a; }
-    result_type b() const { return m_b; }
-};
-
-} // end namespace Catch
-
-#endif // CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
-
-namespace Catch {
-namespace Generators {
-namespace Detail {
-    // Returns a suitable seed for a random floating generator based off
-    // the primary internal rng. It does so by taking current value from
-    // the rng and returning it as the seed.
-    std::uint32_t getSeed();
-}
-
-template <typename Float>
-class RandomFloatingGenerator final : public IGenerator<Float> {
-    Catch::SimplePcg32 m_rng;
-    Catch::uniform_floating_point_distribution<Float> m_dist;
-    Float m_current_number;
-public:
-    RandomFloatingGenerator( Float a, Float b, std::uint32_t seed ):
-        m_rng(seed),
-        m_dist(a, b) {
-        static_cast<void>(next());
-    }
-
-    Float const& get() const override {
-        return m_current_number;
-    }
-    bool next() override {
-        m_current_number = m_dist(m_rng);
-        return true;
-    }
-};
-
-template <>
-class RandomFloatingGenerator<long double> final : public IGenerator<long double> {
-    // We still rely on <random> for this specialization, but we don't
-    // want to drag it into the header.
-    struct PImpl;
-    Catch::Detail::unique_ptr<PImpl> m_pimpl;
-    long double m_current_number;
-
-public:
-    RandomFloatingGenerator( long double a, long double b, std::uint32_t seed );
-
-    long double const& get() const override { return m_current_number; }
-    bool next() override;
-
-    ~RandomFloatingGenerator() override; // = default
-};
-
-template <typename Integer>
-class RandomIntegerGenerator final : public IGenerator<Integer> {
-    Catch::SimplePcg32 m_rng;
-    Catch::uniform_integer_distribution<Integer> m_dist;
-    Integer m_current_number;
-public:
-    RandomIntegerGenerator( Integer a, Integer b, std::uint32_t seed ):
-        m_rng(seed),
-        m_dist(a, b) {
-        static_cast<void>(next());
-    }
-
-    Integer const& get() const override {
-        return m_current_number;
-    }
-    bool next() override {
-        m_current_number = m_dist(m_rng);
-        return true;
-    }
-};
-
-template <typename T>
-std::enable_if_t<std::is_integral<T>::value, GeneratorWrapper<T>>
-random(T a, T b) {
-    return GeneratorWrapper<T>(
-        Catch::Detail::make_unique<RandomIntegerGenerator<T>>(a, b, Detail::getSeed())
-    );
-}
-
-template <typename T>
-std::enable_if_t<std::is_floating_point<T>::value,
-GeneratorWrapper<T>>
-random(T a, T b) {
-    return GeneratorWrapper<T>(
-        Catch::Detail::make_unique<RandomFloatingGenerator<T>>(a, b, Detail::getSeed())
-    );
-}
-
-
-} // namespace Generators
-} // namespace Catch
-
-
-#endif // CATCH_GENERATORS_RANDOM_HPP_INCLUDED
-
-
-#ifndef CATCH_GENERATORS_RANGE_HPP_INCLUDED
-#define CATCH_GENERATORS_RANGE_HPP_INCLUDED
-
-
-#include <iterator>
-#include <type_traits>
-
-namespace Catch {
-namespace Generators {
-
-
-template <typename T>
-class RangeGenerator final : public IGenerator<T> {
-    T m_current;
-    T m_end;
-    T m_step;
-    bool m_positive;
-
-public:
-    RangeGenerator(T const& start, T const& end, T const& step):
-        m_current(start),
-        m_end(end),
-        m_step(step),
-        m_positive(m_step > T(0))
-    {
-        assert(m_current != m_end && "Range start and end cannot be equal");
-        assert(m_step != T(0) && "Step size cannot be zero");
-        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
-    }
-
-    RangeGenerator(T const& start, T const& end):
-        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
-    {}
-
-    T const& get() const override {
-        return m_current;
-    }
-
-    bool next() override {
-        m_current += m_step;
-        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
-    }
-};
-
-template <typename T>
-GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
-    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
-    return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end, step));
-}
-
-template <typename T>
-GeneratorWrapper<T> range(T const& start, T const& end) {
-    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
-    return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end));
-}
-
-
-template <typename T>
-class IteratorGenerator final : public IGenerator<T> {
-    static_assert(!std::is_same<T, bool>::value,
-        "IteratorGenerator currently does not support bools"
-        "because of std::vector<bool> specialization");
-
-    std::vector<T> m_elems;
-    size_t m_current = 0;
-public:
-    template <typename InputIterator, typename InputSentinel>
-    IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
-        if (m_elems.empty()) {
-            Detail::throw_generator_exception("IteratorGenerator received no valid values");
-        }
-    }
-
-    T const& get() const override {
-        return m_elems[m_current];
-    }
-
-    bool next() override {
-        ++m_current;
-        return m_current != m_elems.size();
-    }
-};
-
-template <typename InputIterator,
-          typename InputSentinel,
-          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
-GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
-    return GeneratorWrapper<ResultType>(Catch::Detail::make_unique<IteratorGenerator<ResultType>>(from, to));
-}
-
-template <typename Container>
-auto from_range(Container const& cnt) {
-    using std::begin;
-    using std::end;
-    return from_range( begin( cnt ), end( cnt ) );
-}
-
-
-} // namespace Generators
-} // namespace Catch
-
-
-#endif // CATCH_GENERATORS_RANGE_HPP_INCLUDED
-
-#endif // CATCH_GENERATORS_ALL_HPP_INCLUDED
-
-
-/** \file
- * This is a convenience header for Catch2's interfaces. It includes
- * **all** of Catch2 headers related to interfaces.
- *
- * Generally the Catch2 users should use specific includes they need,
- * but this header can be used instead for ease-of-experimentation, or
- * just plain convenience, at the cost of somewhat increased compilation
- * times.
- *
- * When a new header is added to either the `interfaces` folder, or to
- * the corresponding internal subfolder, it should be added here.
- */
-
-
-#ifndef CATCH_INTERFACES_ALL_HPP_INCLUDED
-#define CATCH_INTERFACES_ALL_HPP_INCLUDED
-
-
-
-#ifndef CATCH_INTERFACES_REPORTER_HPP_INCLUDED
-#define CATCH_INTERFACES_REPORTER_HPP_INCLUDED
-
-
-
-#ifndef CATCH_TEST_RUN_INFO_HPP_INCLUDED
-#define CATCH_TEST_RUN_INFO_HPP_INCLUDED
-
-
-namespace Catch {
-
-    struct TestRunInfo {
-        constexpr TestRunInfo(StringRef _name) : name(_name) {}
-        StringRef name;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_TEST_RUN_INFO_HPP_INCLUDED
-
-#include <map>
-#include <string>
-#include <vector>
-#include <iosfwd>
-
-namespace Catch {
-
-    struct ReporterDescription;
-    struct ListenerDescription;
-    struct TagInfo;
-    struct TestCaseInfo;
-    class TestCaseHandle;
-    class IConfig;
-    class IStream;
-    enum class ColourMode : std::uint8_t;
-
-    struct ReporterConfig {
-        ReporterConfig( IConfig const* _fullConfig,
-                        Detail::unique_ptr<IStream> _stream,
-                        ColourMode colourMode,
-                        std::map<std::string, std::string> customOptions );
-
-        ReporterConfig( ReporterConfig&& ) = default;
-        ReporterConfig& operator=( ReporterConfig&& ) = default;
-        ~ReporterConfig(); // = default
-
-        Detail::unique_ptr<IStream> takeStream() &&;
-        IConfig const* fullConfig() const;
-        ColourMode colourMode() const;
-        std::map<std::string, std::string> const& customOptions() const;
-
-    private:
-        Detail::unique_ptr<IStream> m_stream;
-        IConfig const* m_fullConfig;
-        ColourMode m_colourMode;
-        std::map<std::string, std::string> m_customOptions;
-    };
-
-    struct AssertionStats {
-        AssertionStats( AssertionResult const& _assertionResult,
-                        std::vector<MessageInfo> const& _infoMessages,
-                        Totals const& _totals );
-
-        AssertionStats( AssertionStats const& )              = default;
-        AssertionStats( AssertionStats && )                  = default;
-        AssertionStats& operator = ( AssertionStats const& ) = delete;
-        AssertionStats& operator = ( AssertionStats && )     = delete;
-
-        AssertionResult assertionResult;
-        std::vector<MessageInfo> infoMessages;
-        Totals totals;
-    };
-
-    struct SectionStats {
-        SectionStats(   SectionInfo&& _sectionInfo,
-                        Counts const& _assertions,
-                        double _durationInSeconds,
-                        bool _missingAssertions );
-
-        SectionInfo sectionInfo;
-        Counts assertions;
-        double durationInSeconds;
-        bool missingAssertions;
-    };
-
-    struct TestCaseStats {
-        TestCaseStats(  TestCaseInfo const& _testInfo,
-                        Totals const& _totals,
-                        std::string&& _stdOut,
-                        std::string&& _stdErr,
-                        bool _aborting );
-
-        TestCaseInfo const * testInfo;
-        Totals totals;
-        std::string stdOut;
-        std::string stdErr;
-        bool aborting;
-    };
-
-    struct TestRunStats {
-        TestRunStats(   TestRunInfo const& _runInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-
-        TestRunInfo runInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-    //! By setting up its preferences, a reporter can modify Catch2's behaviour
-    //! in some regards, e.g. it can request Catch2 to capture writes to
-    //! stdout/stderr during test execution, and pass them to the reporter.
-    struct ReporterPreferences {
-        //! Catch2 should redirect writes to stdout and pass them to the
-        //! reporter
-        bool shouldRedirectStdOut = false;
-        //! Catch2 should call `Reporter::assertionEnded` even for passing
-        //! assertions
-        bool shouldReportAllAssertions = false;
-    };
-
-    /**
-     * The common base for all reporters and event listeners
-     *
-     * Implementing classes must also implement:
-     *
-     *     //! User-friendly description of the reporter/listener type
-     *     static std::string getDescription()
-     *
-     * Generally shouldn't be derived from by users of Catch2 directly,
-     * instead they should derive from one of the utility bases that
-     * derive from this class.
-     */
-    class IEventListener {
-    protected:
-        //! Derived classes can set up their preferences here
-        ReporterPreferences m_preferences;
-        //! The test run's config as filled in from CLI and defaults
-        IConfig const* m_config;
-
-    public:
-        IEventListener( IConfig const* config ): m_config( config ) {}
-
-        virtual ~IEventListener(); // = default;
-
-        // Implementing class must also provide the following static methods:
-        // static std::string getDescription();
-
-        ReporterPreferences const& getPreferences() const {
-            return m_preferences;
-        }
-
-        //! Called when no test cases match provided test spec
-        virtual void noMatchingTestCases( StringRef unmatchedSpec ) = 0;
-        //! Called for all invalid test specs from the cli
-        virtual void reportInvalidTestSpec( StringRef invalidArgument ) = 0;
-
-        /**
-         * Called once in a testing run before tests are started
-         *
-         * Not called if tests won't be run (e.g. only listing will happen)
-         */
-        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
-
-        //! Called _once_ for each TEST_CASE, no matter how many times it is entered
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
-        //! Called _every time_ a TEST_CASE is entered, including repeats (due to sections)
-        virtual void testCasePartialStarting( TestCaseInfo const& testInfo, uint64_t partNumber ) = 0;
-        //! Called when a `SECTION` is being entered. Not called for skipped sections
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
-
-        //! Called when user-code is being probed before the actual benchmark runs
-        virtual void benchmarkPreparing( StringRef benchmarkName ) = 0;
-        //! Called after probe but before the user-code is being benchmarked
-        virtual void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) = 0;
-        //! Called with the benchmark results if benchmark successfully finishes
-        virtual void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) = 0;
-        //! Called if running the benchmarks fails for any reason
-        virtual void benchmarkFailed( StringRef benchmarkName ) = 0;
-
-        //! Called before assertion success/failure is evaluated
-        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
-
-        //! Called after assertion was fully evaluated
-        virtual void assertionEnded( AssertionStats const& assertionStats ) = 0;
-
-        //! Called after a `SECTION` has finished running
-        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
-        //! Called _every time_ a TEST_CASE is entered, including repeats (due to sections)
-        virtual void testCasePartialEnded(TestCaseStats const& testCaseStats, uint64_t partNumber ) = 0;
-        //! Called _once_ for each TEST_CASE, no matter how many times it is entered
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
-        /**
-         * Called once after all tests in a testing run are finished
-         *
-         * Not called if tests weren't run (e.g. only listings happened)
-         */
-        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
-
-        /**
-         * Called with test cases that are skipped due to the test run aborting.
-         * NOT called for test cases that are explicitly skipped using the `SKIP` macro.
-         *
-         * Deprecated - will be removed in the next major release.
-         */
-        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
-
-        //! Called if a fatal error (signal/structured exception) occurred
-        virtual void fatalErrorEncountered( StringRef error ) = 0;
-
-        //! Writes out information about provided reporters using reporter-specific format
-        virtual void listReporters(std::vector<ReporterDescription> const& descriptions) = 0;
-        //! Writes out the provided listeners descriptions using reporter-specific format
-        virtual void listListeners(std::vector<ListenerDescription> const& descriptions) = 0;
-        //! Writes out information about provided tests using reporter-specific format
-        virtual void listTests(std::vector<TestCaseHandle> const& tests) = 0;
-        //! Writes out information about the provided tags using reporter-specific format
-        virtual void listTags(std::vector<TagInfo> const& tags) = 0;
-    };
-    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
-
-} // end namespace Catch
-
-#endif // CATCH_INTERFACES_REPORTER_HPP_INCLUDED
-
-
-#ifndef CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
-#define CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
-
-
-#include <string>
-
-namespace Catch {
-
-    struct ReporterConfig;
-    class IConfig;
-    class IEventListener;
-    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
-
-
-    class IReporterFactory {
-    public:
-        virtual ~IReporterFactory(); // = default
-
-        virtual IEventListenerPtr
-        create( ReporterConfig&& config ) const = 0;
-        virtual std::string getDescription() const = 0;
-    };
-    using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
-
-    class EventListenerFactory {
-    public:
-        virtual ~EventListenerFactory(); // = default
-        virtual IEventListenerPtr create( IConfig const* config ) const = 0;
-        //! Return a meaningful name for the listener, e.g. its type name
-        virtual StringRef getName() const = 0;
-        //! Return listener's description if available
-        virtual std::string getDescription() const = 0;
-    };
-} // namespace Catch
-
-#endif // CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
-
-
-#ifndef CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
-#define CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    struct TagAlias;
-
-    class ITagAliasRegistry {
-    public:
-        virtual ~ITagAliasRegistry(); // = default
-        // Nullptr if not present
-        virtual TagAlias const* find( std::string const& alias ) const = 0;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
-
-        static ITagAliasRegistry const& get();
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
-
-
-#ifndef CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
-#define CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
-
-#include <vector>
-
-namespace Catch {
-
-    struct TestCaseInfo;
-    class TestCaseHandle;
-    class IConfig;
-
-    class ITestCaseRegistry {
-    public:
-        virtual ~ITestCaseRegistry(); // = default
-        // TODO: this exists only for adding filenames to test cases -- let's expose this in a saner way later
-        virtual std::vector<TestCaseInfo* > const& getAllInfos() const = 0;
-        virtual std::vector<TestCaseHandle> const& getAllTests() const = 0;
-        virtual std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const = 0;
-    };
-
-}
-
-#endif // CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
-
-#endif // CATCH_INTERFACES_ALL_HPP_INCLUDED
-
-
-#ifndef CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
-#define CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
-
-
-namespace Catch {
-    namespace Detail {
-        //! Provides case-insensitive `op<` semantics when called
-        struct CaseInsensitiveLess {
-            bool operator()( StringRef lhs,
-                             StringRef rhs ) const;
-        };
-
-        //! Provides case-insensitive `op==` semantics when called
-        struct CaseInsensitiveEqualTo {
-            bool operator()( StringRef lhs,
-                             StringRef rhs ) const;
-        };
-
-    } // namespace Detail
-} // namespace Catch
-
-#endif // CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
-
-
-
-/** \file
- * Wrapper for ANDROID_LOGWRITE configuration option
- *
- * We want to default to enabling it when compiled for android, but
- * users of the library should also be able to disable it if they want
- * to.
- */
-
-#ifndef CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
-#define CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
-
-
-#if defined(__ANDROID__)
-#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
-#endif
-
-
-#if defined( CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE ) && \
-    !defined( CATCH_CONFIG_NO_ANDROID_LOGWRITE ) &&      \
-    !defined( CATCH_CONFIG_ANDROID_LOGWRITE )
-#    define CATCH_CONFIG_ANDROID_LOGWRITE
-#endif
-
-#endif // CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
-
-
-
-/** \file
- * Wrapper for UNCAUGHT_EXCEPTIONS configuration option
- *
- * For some functionality, Catch2 requires to know whether there is
- * an active exception. Because `std::uncaught_exception` is deprecated
- * in C++17, we want to use `std::uncaught_exceptions` if possible.
- */
-
-#ifndef CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
-#define CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
-
-
-#if defined(_MSC_VER)
-#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
-#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#  endif
-#endif
-
-
-#include <exception>
-
-#if defined(__cpp_lib_uncaught_exceptions) \
-    && !defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-
-#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#endif // __cpp_lib_uncaught_exceptions
-
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) \
-    && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) \
-    && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-
-#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#endif
-
-
-#endif // CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
-
-
-#ifndef CATCH_CONSOLE_COLOUR_HPP_INCLUDED
-#define CATCH_CONSOLE_COLOUR_HPP_INCLUDED
-
-
-#include <iosfwd>
-#include <cstdint>
-
-namespace Catch {
-
-    enum class ColourMode : std::uint8_t;
-    class IStream;
-
-    struct Colour {
-        enum Code {
-            None = 0,
-
-            White,
-            Red,
-            Green,
-            Blue,
-            Cyan,
-            Yellow,
-            Grey,
-
-            Bright = 0x10,
-
-            BrightRed = Bright | Red,
-            BrightGreen = Bright | Green,
-            LightGrey = Bright | Grey,
-            BrightWhite = Bright | White,
-            BrightYellow = Bright | Yellow,
-
-            // By intention
-            FileName = LightGrey,
-            Warning = BrightYellow,
-            ResultError = BrightRed,
-            ResultSuccess = BrightGreen,
-            ResultExpectedFailure = Warning,
-
-            Error = BrightRed,
-            Success = Green,
-            Skip = LightGrey,
-
-            OriginalExpression = Cyan,
-            ReconstructedExpression = BrightYellow,
-
-            SecondaryText = LightGrey,
-            Headers = White
-        };
-    };
-
-    class ColourImpl {
-    protected:
-        //! The associated stream of this ColourImpl instance
-        IStream* m_stream;
-    public:
-        ColourImpl( IStream* stream ): m_stream( stream ) {}
-
-        //! RAII wrapper around writing specific colour of text using specific
-        //! colour impl into a stream.
-        class ColourGuard {
-            ColourImpl const* m_colourImpl;
-            Colour::Code m_code;
-            bool m_engaged = false;
-
-        public:
-            //! Does **not** engage the guard/start the colour
-            ColourGuard( Colour::Code code,
-                         ColourImpl const* colour );
-
-            ColourGuard( ColourGuard const& rhs ) = delete;
-            ColourGuard& operator=( ColourGuard const& rhs ) = delete;
-
-            ColourGuard( ColourGuard&& rhs ) noexcept;
-            ColourGuard& operator=( ColourGuard&& rhs ) noexcept;
-
-            //! Removes colour _if_ the guard was engaged
-            ~ColourGuard();
-
-            /**
-             * Explicitly engages colour for given stream.
-             *
-             * The API based on operator<< should be preferred.
-             */
-            ColourGuard& engage( std::ostream& stream ) &;
-            /**
-             * Explicitly engages colour for given stream.
-             *
-             * The API based on operator<< should be preferred.
-             */
-            ColourGuard&& engage( std::ostream& stream ) &&;
-
-        private:
-            //! Engages the guard and starts using colour
-            friend std::ostream& operator<<( std::ostream& lhs,
-                                             ColourGuard& guard ) {
-                guard.engageImpl( lhs );
-                return lhs;
-            }
-            //! Engages the guard and starts using colour
-            friend std::ostream& operator<<( std::ostream& lhs,
-                                            ColourGuard&& guard) {
-                guard.engageImpl( lhs );
-                return lhs;
-            }
-
-            void engageImpl( std::ostream& stream );
-
-        };
-
-        virtual ~ColourImpl(); // = default
-        /**
-         * Creates a guard object for given colour and this colour impl
-         *
-         * **Important:**
-         * the guard starts disengaged, and has to be engaged explicitly.
-         */
-        ColourGuard guardColour( Colour::Code colourCode );
-
-    private:
-        virtual void use( Colour::Code colourCode ) const = 0;
-    };
-
-    //! Provides ColourImpl based on global config and target compilation platform
-    Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection,
-                                                   IStream* stream );
-
-    //! Checks if specific colour impl has been compiled into the binary
-    bool isColourImplAvailable( ColourMode colourSelection );
-
-} // end namespace Catch
-
-#endif // CATCH_CONSOLE_COLOUR_HPP_INCLUDED
-
-
-#ifndef CATCH_CONSOLE_WIDTH_HPP_INCLUDED
-#define CATCH_CONSOLE_WIDTH_HPP_INCLUDED
-
-// This include must be kept so that user's configured value for CONSOLE_WIDTH
-// is used before we attempt to provide a default value
-
-#ifndef CATCH_CONFIG_CONSOLE_WIDTH
-#define CATCH_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-#endif // CATCH_CONSOLE_WIDTH_HPP_INCLUDED
-
-
-#ifndef CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
-#define CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
-
-
-#include <cstddef>
-#include <initializer_list>
-
-// We want a simple polyfill over `std::empty`, `std::size` and so on
-// for C++14 or C++ libraries with incomplete support.
-// We also have to handle that MSVC std lib will happily provide these
-// under older standards.
-#if defined(CATCH_CPP17_OR_GREATER) || defined(_MSC_VER)
-
-// We are already using this header either way, so there shouldn't
-// be much additional overhead in including it to get the feature
-// test macros
-#include <string>
-
-#  if !defined(__cpp_lib_nonmember_container_access)
-#      define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
-#  endif
-
-#else
-#define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
-#endif
-
-
-
-namespace Catch {
-namespace Detail {
-
-#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
-    template <typename Container>
-    constexpr auto empty(Container const& cont) -> decltype(cont.empty()) {
-        return cont.empty();
-    }
-    template <typename T, std::size_t N>
-    constexpr bool empty(const T (&)[N]) noexcept {
-        // GCC < 7 does not support the const T(&)[] parameter syntax
-        // so we have to ignore the length explicitly
-        (void)N;
-        return false;
-    }
-    template <typename T>
-    constexpr bool empty(std::initializer_list<T> list) noexcept {
-        return list.size() > 0;
-    }
-
-
-    template <typename Container>
-    constexpr auto size(Container const& cont) -> decltype(cont.size()) {
-        return cont.size();
-    }
-    template <typename T, std::size_t N>
-    constexpr std::size_t size(const T(&)[N]) noexcept {
-        return N;
-    }
-#endif // CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
-
-} // end namespace Detail
-} // end namespace Catch
-
-
-
-#endif // CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
-
-
-#ifndef CATCH_DEBUG_CONSOLE_HPP_INCLUDED
-#define CATCH_DEBUG_CONSOLE_HPP_INCLUDED
-
-#include <string>
-
-namespace Catch {
-    void writeToDebugConsole( std::string const& text );
-}
-
-#endif // CATCH_DEBUG_CONSOLE_HPP_INCLUDED
-
-
-#ifndef CATCH_DEBUGGER_HPP_INCLUDED
-#define CATCH_DEBUGGER_HPP_INCLUDED
-
-
-namespace Catch {
-    bool isDebuggerActive();
-}
-
-#ifdef CATCH_PLATFORM_MAC
-
-    #if defined(__i386__) || defined(__x86_64__)
-        #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
-    #elif defined(__aarch64__)
-        #define CATCH_TRAP() __asm__(".inst 0xd43e0000")
-    #elif defined(__POWERPC__)
-        #define CATCH_TRAP() __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
-        : : : "memory","r0","r3","r4" ) /* NOLINT */
-    #endif
-
-#elif defined(CATCH_PLATFORM_IPHONE)
-
-    // use inline assembler
-    #if defined(__i386__) || defined(__x86_64__)
-        #define CATCH_TRAP()  __asm__("int $3")
-    #elif defined(__aarch64__)
-        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
-    #elif defined(__arm__) && !defined(__thumb__)
-        #define CATCH_TRAP()  __asm__(".inst 0xe7f001f0")
-    #elif defined(__arm__) &&  defined(__thumb__)
-        #define CATCH_TRAP()  __asm__(".inst 0xde01")
-    #endif
-
-#elif defined(CATCH_PLATFORM_LINUX)
-    // If we can use inline assembler, do it because this allows us to break
-    // directly at the location of the failing check instead of breaking inside
-    // raise() called from it, i.e. one stack frame below.
-    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
-        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
-    #else // Fall back to the generic way.
-        #include <signal.h>
-
-        #define CATCH_TRAP() raise(SIGTRAP)
-    #endif
-#elif defined(_MSC_VER)
-    #define CATCH_TRAP() __debugbreak()
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
-    #define CATCH_TRAP() DebugBreak()
-#endif
-
-#ifndef CATCH_BREAK_INTO_DEBUGGER
-    #ifdef CATCH_TRAP
-        #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
-    #else
-        #define CATCH_BREAK_INTO_DEBUGGER() []{}()
-    #endif
-#endif
-
-#endif // CATCH_DEBUGGER_HPP_INCLUDED
-
-
-#ifndef CATCH_ENFORCE_HPP_INCLUDED
-#define CATCH_ENFORCE_HPP_INCLUDED
-
-
-#include <exception>
-
-namespace Catch {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    template <typename Ex>
-    [[noreturn]]
-    void throw_exception(Ex const& e) {
-        throw e;
-    }
-#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
-    [[noreturn]]
-    void throw_exception(std::exception const& e);
-#endif
-
-    [[noreturn]]
-    void throw_logic_error(std::string const& msg);
-    [[noreturn]]
-    void throw_domain_error(std::string const& msg);
-    [[noreturn]]
-    void throw_runtime_error(std::string const& msg);
-
-} // namespace Catch;
-
-#define CATCH_MAKE_MSG(...) \
-    (Catch::ReusableStringStream() << __VA_ARGS__).str()
-
-#define CATCH_INTERNAL_ERROR(...) \
-    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
-
-#define CATCH_ERROR(...) \
-    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
-
-#define CATCH_RUNTIME_ERROR(...) \
-    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
-
-#define CATCH_ENFORCE( condition, ... ) \
-    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
-
-
-#endif // CATCH_ENFORCE_HPP_INCLUDED
-
-
-#ifndef CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
-#define CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
-
-
-#include <vector>
-
-namespace Catch {
-
-    namespace Detail {
-
-        Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
-
-        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
-
-            std::vector<Catch::Detail::unique_ptr<EnumInfo>> m_enumInfos;
-
-            EnumInfo const& registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values) override;
-        };
-
-        std::vector<StringRef> parseEnums( StringRef enums );
-
-    } // Detail
-
-} // Catch
-
-#endif // CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
-
-
-#ifndef CATCH_ERRNO_GUARD_HPP_INCLUDED
-#define CATCH_ERRNO_GUARD_HPP_INCLUDED
-
-namespace Catch {
-
-    //! Simple RAII class that stores the value of `errno`
-    //! at construction and restores it at destruction.
-    class ErrnoGuard {
-    public:
-        // Keep these outlined to avoid dragging in macros from <cerrno>
-
-        ErrnoGuard();
-        ~ErrnoGuard();
-    private:
-        int m_oldErrno;
-    };
-
-}
-
-#endif // CATCH_ERRNO_GUARD_HPP_INCLUDED
-
-
-#ifndef CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
-#define CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
-
-
-#include <vector>
-#include <string>
-
-namespace Catch {
-
-    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
-    public:
-        ~ExceptionTranslatorRegistry() override;
-        void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator );
-        std::string translateActiveException() const override;
-
-    private:
-        ExceptionTranslators m_translators;
-    };
-}
-
-#endif // CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
-
-
-#ifndef CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
-#define CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
-
-#include <cassert>
-
-namespace Catch {
-
-    /**
-     * Wrapper for platform-specific fatal error (signals/SEH) handlers
-     *
-     * Tries to be cooperative with other handlers, and not step over
-     * other handlers. This means that unknown structured exceptions
-     * are passed on, previous signal handlers are called, and so on.
-     *
-     * Can only be instantiated once, and assumes that once a signal
-     * is caught, the binary will end up terminating. Thus, there
-     */
-    class FatalConditionHandler {
-        bool m_started = false;
-
-        // Install/disengage implementation for specific platform.
-        // Should be if-defed to work on current platform, can assume
-        // engage-disengage 1:1 pairing.
-        void engage_platform();
-        void disengage_platform() noexcept;
-    public:
-        // Should also have platform-specific implementations as needed
-        FatalConditionHandler();
-        ~FatalConditionHandler();
-
-        void engage() {
-            assert(!m_started && "Handler cannot be installed twice.");
-            m_started = true;
-            engage_platform();
-        }
-
-        void disengage() noexcept {
-            assert(m_started && "Handler cannot be uninstalled without being installed first");
-            m_started = false;
-            disengage_platform();
-        }
-    };
-
-    //! Simple RAII guard for (dis)engaging the FatalConditionHandler
-    class FatalConditionHandlerGuard {
-        FatalConditionHandler* m_handler;
-    public:
-        FatalConditionHandlerGuard(FatalConditionHandler* handler):
-            m_handler(handler) {
-            m_handler->engage();
-        }
-        ~FatalConditionHandlerGuard() {
-            m_handler->disengage();
-        }
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
-
-
-#ifndef CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
-#define CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
-
-
-#include <cassert>
-#include <cmath>
-#include <cstdint>
-#include <utility>
-#include <limits>
-
-namespace Catch {
-    namespace Detail {
-
-        uint32_t convertToBits(float f);
-        uint64_t convertToBits(double d);
-
-        // Used when we know we want == comparison of two doubles
-        // to centralize warning suppression
-        bool directCompare( float lhs, float rhs );
-        bool directCompare( double lhs, double rhs );
-
-    } // end namespace Detail
-
-
-
-#if defined( __GNUC__ ) || defined( __clang__ )
-#    pragma GCC diagnostic push
-    // We do a bunch of direct compensations of floating point numbers,
-    // because we know what we are doing and actually do want the direct
-    // comparison behaviour.
-#    pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-
-    /**
-     * Calculates the ULP distance between two floating point numbers
-     *
-     * The ULP distance of two floating point numbers is the count of
-     * valid floating point numbers representable between them.
-     *
-     * There are some exceptions between how this function counts the
-     * distance, and the interpretation of the standard as implemented.
-     * by e.g. `nextafter`. For this function it always holds that:
-     * * `(x == y) => ulpDistance(x, y) == 0` (so `ulpDistance(-0, 0) == 0`)
-     * * `ulpDistance(maxFinite, INF) == 1`
-     * * `ulpDistance(x, -x) == 2 * ulpDistance(x, 0)`
-     *
-     * \pre `!isnan( lhs )`
-     * \pre `!isnan( rhs )`
-     * \pre floating point numbers are represented in IEEE-754 format
-     */
-    template <typename FP>
-    uint64_t ulpDistance( FP lhs, FP rhs ) {
-        assert( std::numeric_limits<FP>::is_iec559 &&
-            "ulpDistance assumes IEEE-754 format for floating point types" );
-        assert( !Catch::isnan( lhs ) &&
-                "Distance between NaN and number is not meaningful" );
-        assert( !Catch::isnan( rhs ) &&
-                "Distance between NaN and number is not meaningful" );
-
-        // We want X == Y to imply 0 ULP distance even if X and Y aren't
-        // bit-equal (-0 and 0), or X - Y != 0 (same sign infinities).
-        if ( lhs == rhs ) { return 0; }
-
-        // We need a properly typed positive zero for type inference.
-        static constexpr FP positive_zero{};
-
-        // We want to ensure that +/- 0 is always represented as positive zero
-        if ( lhs == positive_zero ) { lhs = positive_zero; }
-        if ( rhs == positive_zero ) { rhs = positive_zero; }
-
-        // If arguments have different signs, we can handle them by summing
-        // how far are they from 0 each.
-        if ( std::signbit( lhs ) != std::signbit( rhs ) ) {
-            return ulpDistance( std::abs( lhs ), positive_zero ) +
-                   ulpDistance( std::abs( rhs ), positive_zero );
-        }
-
-        // When both lhs and rhs are of the same sign, we can just
-        // read the numbers bitwise as integers, and then subtract them
-        // (assuming IEEE).
-        uint64_t lc = Detail::convertToBits( lhs );
-        uint64_t rc = Detail::convertToBits( rhs );
-
-        // The ulp distance between two numbers is symmetric, so to avoid
-        // dealing with overflows we want the bigger converted number on the lhs
-        if ( lc < rc ) {
-            std::swap( lc, rc );
-        }
-
-        return lc - rc;
-    }
-
-#if defined( __GNUC__ ) || defined( __clang__ )
-#    pragma GCC diagnostic pop
-#endif
-
-
-} // end namespace Catch
-
-#endif // CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
-
-
-#ifndef CATCH_GETENV_HPP_INCLUDED
-#define CATCH_GETENV_HPP_INCLUDED
-
-namespace Catch {
-namespace Detail {
-
-    //! Wrapper over `std::getenv` that compiles on UWP (and always returns nullptr there)
-    char const* getEnv(char const* varName);
-
-}
-}
-
-#endif // CATCH_GETENV_HPP_INCLUDED
-
-
-#ifndef CATCH_IS_PERMUTATION_HPP_INCLUDED
-#define CATCH_IS_PERMUTATION_HPP_INCLUDED
-
-#include <algorithm>
-#include <iterator>
-
-namespace Catch {
-    namespace Detail {
-
-        template <typename ForwardIter,
-                  typename Sentinel,
-                  typename T,
-                  typename Comparator>
-        constexpr
-        ForwardIter find_sentinel( ForwardIter start,
-                                   Sentinel sentinel,
-                                   T const& value,
-                                   Comparator cmp ) {
-            while ( start != sentinel ) {
-                if ( cmp( *start, value ) ) { break; }
-                ++start;
-            }
-            return start;
-        }
-
-        template <typename ForwardIter,
-                  typename Sentinel,
-                  typename T,
-                  typename Comparator>
-        constexpr
-        std::ptrdiff_t count_sentinel( ForwardIter start,
-                                       Sentinel sentinel,
-                                       T const& value,
-                                       Comparator cmp ) {
-            std::ptrdiff_t count = 0;
-            while ( start != sentinel ) {
-                if ( cmp( *start, value ) ) { ++count; }
-                ++start;
-            }
-            return count;
-        }
-
-        template <typename ForwardIter, typename Sentinel>
-        constexpr
-        std::enable_if_t<!std::is_same<ForwardIter, Sentinel>::value,
-                         std::ptrdiff_t>
-        sentinel_distance( ForwardIter iter, const Sentinel sentinel ) {
-            std::ptrdiff_t dist = 0;
-            while ( iter != sentinel ) {
-                ++iter;
-                ++dist;
-            }
-            return dist;
-        }
-
-        template <typename ForwardIter>
-        constexpr std::ptrdiff_t sentinel_distance( ForwardIter first,
-                                                    ForwardIter last ) {
-            return std::distance( first, last );
-        }
-
-        template <typename ForwardIter1,
-                  typename Sentinel1,
-                  typename ForwardIter2,
-                  typename Sentinel2,
-                  typename Comparator>
-        constexpr bool check_element_counts( ForwardIter1 first_1,
-                                             const Sentinel1 end_1,
-                                             ForwardIter2 first_2,
-                                             const Sentinel2 end_2,
-                                             Comparator cmp ) {
-            auto cursor = first_1;
-            while ( cursor != end_1 ) {
-                if ( find_sentinel( first_1, cursor, *cursor, cmp ) ==
-                     cursor ) {
-                    // we haven't checked this element yet
-                    const auto count_in_range_2 =
-                        count_sentinel( first_2, end_2, *cursor, cmp );
-                    // Not a single instance in 2nd range, so it cannot be a
-                    // permutation of 1st range
-                    if ( count_in_range_2 == 0 ) { return false; }
-
-                    const auto count_in_range_1 =
-                        count_sentinel( cursor, end_1, *cursor, cmp );
-                    if ( count_in_range_1 != count_in_range_2 ) {
-                        return false;
-                    }
-                }
-
-                ++cursor;
-            }
-
-            return true;
-        }
-
-        template <typename ForwardIter1,
-                  typename Sentinel1,
-                  typename ForwardIter2,
-                  typename Sentinel2,
-                  typename Comparator>
-        constexpr bool is_permutation( ForwardIter1 first_1,
-                                       const Sentinel1 end_1,
-                                       ForwardIter2 first_2,
-                                       const Sentinel2 end_2,
-                                       Comparator cmp ) {
-            // TODO: no optimization for stronger iterators, because we would also have to constrain on sentinel vs not sentinel types
-            // TODO: Comparator has to be "both sides", e.g. a == b => b == a
-            // This skips shared prefix of the two ranges
-            while (first_1 != end_1 && first_2 != end_2 && cmp(*first_1, *first_2)) {
-                ++first_1;
-                ++first_2;
-            }
-
-            // We need to handle case where at least one of the ranges has no more elements
-            if (first_1 == end_1 || first_2 == end_2) {
-                return first_1 == end_1 && first_2 == end_2;
-            }
-
-            // pair counting is n**2, so we pay linear walk to compare the sizes first
-            auto dist_1 = sentinel_distance( first_1, end_1 );
-            auto dist_2 = sentinel_distance( first_2, end_2 );
-
-            if (dist_1 != dist_2) { return false; }
-
-            // Since we do not try to handle stronger iterators pair (e.g.
-            // bidir) optimally, the only thing left to do is to check counts in
-            // the remaining ranges.
-            return check_element_counts( first_1, end_1, first_2, end_2, cmp );
-        }
-
-    } // namespace Detail
-} // namespace Catch
-
-#endif // CATCH_IS_PERMUTATION_HPP_INCLUDED
-
-
-#ifndef CATCH_ISTREAM_HPP_INCLUDED
-#define CATCH_ISTREAM_HPP_INCLUDED
-
-
-#include <iosfwd>
-#include <cstddef>
-#include <ostream>
-#include <string>
-
-namespace Catch {
-
-    class IStream {
-    public:
-        virtual ~IStream(); // = default
-        virtual std::ostream& stream() = 0;
-        /**
-         * Best guess on whether the instance is writing to a console (e.g. via stdout/stderr)
-         *
-         * This is useful for e.g. Win32 colour support, because the Win32
-         * API manipulates console directly, unlike POSIX escape codes,
-         * that can be written anywhere.
-         *
-         * Due to variety of ways to change where the stdout/stderr is
-         * _actually_ being written, users should always assume that
-         * the answer might be wrong.
-         */
-        virtual bool isConsole() const { return false; }
-    };
-
-    /**
-     * Creates a stream wrapper that writes to specific file.
-     *
-     * Also recognizes 4 special filenames
-     * * `-` for stdout
-     * * `%stdout` for stdout
-     * * `%stderr` for stderr
-     * * `%debug` for platform specific debugging output
-     *
-     * \throws if passed an unrecognized %-prefixed stream
-     */
-    auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream>;
-
-}
-
-#endif // CATCH_STREAM_HPP_INCLUDED
-
-
-#ifndef CATCH_JSONWRITER_HPP_INCLUDED
-#define CATCH_JSONWRITER_HPP_INCLUDED
-
-
-#include <cstdint>
-#include <sstream>
-
-namespace Catch {
-    class JsonObjectWriter;
-    class JsonArrayWriter;
-
-    struct JsonUtils {
-        static void indent( std::ostream& os, std::uint64_t level );
-        static void appendCommaNewline( std::ostream& os,
-                                        bool& should_comma,
-                                        std::uint64_t level );
-    };
-
-    class JsonValueWriter {
-    public:
-        JsonValueWriter( std::ostream& os );
-        JsonValueWriter( std::ostream& os, std::uint64_t indent_level );
-
-        JsonObjectWriter writeObject() &&;
-        JsonArrayWriter writeArray() &&;
-
-        template <typename T>
-        void write( T const& value ) && {
-            writeImpl( value, !std::is_arithmetic<T>::value );
-        }
-        void write( StringRef value ) &&;
-        void write( bool value ) &&;
-
-    private:
-        void writeImpl( StringRef value, bool quote );
-
-        // Without this SFINAE, this overload is a better match
-        // for `std::string`, `char const*`, `char const[N]` args.
-        // While it would still work, it would cause code bloat
-        // and multiple iteration over the strings
-        template <typename T,
-                  typename = typename std::enable_if_t<
-                      !std::is_convertible<T, StringRef>::value>>
-        void writeImpl( T const& value, bool quote_value ) {
-            m_sstream << value;
-            writeImpl( m_sstream.str(), quote_value );
-        }
-
-        std::ostream& m_os;
-        std::stringstream m_sstream;
-        std::uint64_t m_indent_level;
-    };
-
-    class JsonObjectWriter {
-    public:
-        JsonObjectWriter( std::ostream& os );
-        JsonObjectWriter( std::ostream& os, std::uint64_t indent_level );
-
-        JsonObjectWriter( JsonObjectWriter&& source ) noexcept;
-        JsonObjectWriter& operator=( JsonObjectWriter&& source ) = delete;
-
-        ~JsonObjectWriter();
-
-        JsonValueWriter write( StringRef key );
-
-    private:
-        std::ostream& m_os;
-        std::uint64_t m_indent_level;
-        bool m_should_comma = false;
-        bool m_active = true;
-    };
-
-    class JsonArrayWriter {
-    public:
-        JsonArrayWriter( std::ostream& os );
-        JsonArrayWriter( std::ostream& os, std::uint64_t indent_level );
-
-        JsonArrayWriter( JsonArrayWriter&& source ) noexcept;
-        JsonArrayWriter& operator=( JsonArrayWriter&& source ) = delete;
-
-        ~JsonArrayWriter();
-
-        JsonObjectWriter writeObject();
-        JsonArrayWriter writeArray();
-
-        template <typename T>
-        JsonArrayWriter& write( T const& value ) {
-            return writeImpl( value );
-        }
-
-        JsonArrayWriter& write( bool value );
-
-    private:
-        template <typename T>
-        JsonArrayWriter& writeImpl( T const& value ) {
-            JsonUtils::appendCommaNewline(
-                m_os, m_should_comma, m_indent_level + 1 );
-            JsonValueWriter{ m_os }.write( value );
-
-            return *this;
-        }
-
-        std::ostream& m_os;
-        std::uint64_t m_indent_level;
-        bool m_should_comma = false;
-        bool m_active = true;
-    };
-
-} // namespace Catch
-
-#endif // CATCH_JSONWRITER_HPP_INCLUDED
-
-
-#ifndef CATCH_LEAK_DETECTOR_HPP_INCLUDED
-#define CATCH_LEAK_DETECTOR_HPP_INCLUDED
-
-namespace Catch {
-
-    struct LeakDetector {
-        LeakDetector();
-        ~LeakDetector();
-    };
-
-}
-#endif // CATCH_LEAK_DETECTOR_HPP_INCLUDED
-
-
-#ifndef CATCH_LIST_HPP_INCLUDED
-#define CATCH_LIST_HPP_INCLUDED
-
-
-#include <set>
-#include <string>
-
-
-namespace Catch {
-
-    class IEventListener;
-    class Config;
-
-
-    struct ReporterDescription {
-        std::string name, description;
-    };
-    struct ListenerDescription {
-        StringRef name;
-        std::string description;
-    };
-
-    struct TagInfo {
-        void add(StringRef spelling);
-        std::string all() const;
-
-        std::set<StringRef> spellings;
-        std::size_t count = 0;
-    };
-
-    bool list( IEventListener& reporter, Config const& config );
-
-} // end namespace Catch
-
-#endif // CATCH_LIST_HPP_INCLUDED
-
-
-#ifndef CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
-#define CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
-
-
-#include <cassert>
-#include <string>
-
-namespace Catch {
-
-    class OutputRedirect {
-        bool m_redirectActive = false;
-        virtual void activateImpl() = 0;
-        virtual void deactivateImpl() = 0;
-    public:
-        enum Kind {
-            //! No redirect (noop implementation)
-            None,
-            //! Redirect std::cout/std::cerr/std::clog streams internally
-            Streams,
-            //! Redirect the stdout/stderr file descriptors into files
-            FileDescriptors,
-        };
-
-        virtual ~OutputRedirect(); // = default;
-
-        // TODO: Do we want to check that redirect is not active before retrieving the output?
-        virtual std::string getStdout() = 0;
-        virtual std::string getStderr() = 0;
-        virtual void clearBuffers() = 0;
-        bool isActive() const { return m_redirectActive; }
-        void activate() {
-            assert( !m_redirectActive && "redirect is already active" );
-            activateImpl();
-            m_redirectActive = true;
-        }
-        void deactivate() {
-            assert( m_redirectActive && "redirect is not active" );
-            deactivateImpl();
-            m_redirectActive = false;
-        }
-    };
-
-    bool isRedirectAvailable( OutputRedirect::Kind kind);
-    Detail::unique_ptr<OutputRedirect> makeOutputRedirect( bool actual );
-
-    class RedirectGuard {
-        OutputRedirect* m_redirect;
-        bool m_activate;
-        bool m_previouslyActive;
-        bool m_moved = false;
-
-    public:
-        RedirectGuard( bool activate, OutputRedirect& redirectImpl );
-        ~RedirectGuard() noexcept( false );
-
-        RedirectGuard( RedirectGuard const& ) = delete;
-        RedirectGuard& operator=( RedirectGuard const& ) = delete;
-
-        // C++14 needs move-able guards to return them from functions
-        RedirectGuard( RedirectGuard&& rhs ) noexcept;
-        RedirectGuard& operator=( RedirectGuard&& rhs ) noexcept;
-    };
-
-    RedirectGuard scopedActivate( OutputRedirect& redirectImpl );
-    RedirectGuard scopedDeactivate( OutputRedirect& redirectImpl );
-
-} // end namespace Catch
-
-#endif // CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
-
-
-#ifndef CATCH_PARSE_NUMBERS_HPP_INCLUDED
-#define CATCH_PARSE_NUMBERS_HPP_INCLUDED
-
-
-#include <string>
-
-namespace Catch {
-
-    /**
-     * Parses unsigned int from the input, using provided base
-     *
-     * Effectively a wrapper around std::stoul but with better error checking
-     * e.g. "-1" is rejected, instead of being parsed as UINT_MAX.
-     */
-    Optional<unsigned int> parseUInt(std::string const& input, int base = 10);
-}
-
-#endif // CATCH_PARSE_NUMBERS_HPP_INCLUDED
-
-
-#ifndef CATCH_REPORTER_REGISTRY_HPP_INCLUDED
-#define CATCH_REPORTER_REGISTRY_HPP_INCLUDED
-
-
-#include <map>
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    class IEventListener;
-    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
-    class IReporterFactory;
-    using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
-    struct ReporterConfig;
-    class EventListenerFactory;
-
-    class ReporterRegistry {
-        struct ReporterRegistryImpl;
-        Detail::unique_ptr<ReporterRegistryImpl> m_impl;
-
-    public:
-        ReporterRegistry();
-        ~ReporterRegistry(); // = default;
-
-        IEventListenerPtr create( std::string const& name,
-                                  ReporterConfig&& config ) const;
-
-        void registerReporter( std::string const& name,
-                               IReporterFactoryPtr factory );
-
-        void
-        registerListener( Detail::unique_ptr<EventListenerFactory> factory );
-
-        std::map<std::string,
-                 IReporterFactoryPtr,
-                 Detail::CaseInsensitiveLess> const&
-        getFactories() const;
-
-        std::vector<Detail::unique_ptr<EventListenerFactory>> const&
-        getListeners() const;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_REGISTRY_HPP_INCLUDED
-
-
-#ifndef CATCH_RUN_CONTEXT_HPP_INCLUDED
-#define CATCH_RUN_CONTEXT_HPP_INCLUDED
-
-
-
-#ifndef CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
-#define CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
-
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-namespace TestCaseTracking {
-
-    struct NameAndLocation {
-        std::string name;
-        SourceLineInfo location;
-
-        NameAndLocation( std::string&& _name, SourceLineInfo const& _location );
-        friend bool operator==(NameAndLocation const& lhs, NameAndLocation const& rhs) {
-            // This is a very cheap check that should have a very high hit rate.
-            // If we get to SourceLineInfo::operator==, we will redo it, but the
-            // cost of repeating is trivial at that point (we will be paying
-            // multiple strcmp/memcmps at that point).
-            if ( lhs.location.line != rhs.location.line ) { return false; }
-            return lhs.name == rhs.name && lhs.location == rhs.location;
-        }
-        friend bool operator!=(NameAndLocation const& lhs,
-                               NameAndLocation const& rhs) {
-            return !( lhs == rhs );
-        }
-    };
-
-    /**
-     * This is a variant of `NameAndLocation` that does not own the name string
-     *
-     * This avoids extra allocations when trying to locate a tracker by its
-     * name and location, as long as we make sure that trackers only keep
-     * around the owning variant.
-     */
-    struct NameAndLocationRef {
-        StringRef name;
-        SourceLineInfo location;
-
-        constexpr NameAndLocationRef( StringRef name_,
-                                      SourceLineInfo location_ ):
-            name( name_ ), location( location_ ) {}
-
-        friend bool operator==( NameAndLocation const& lhs,
-                                NameAndLocationRef const& rhs ) {
-            // This is a very cheap check that should have a very high hit rate.
-            // If we get to SourceLineInfo::operator==, we will redo it, but the
-            // cost of repeating is trivial at that point (we will be paying
-            // multiple strcmp/memcmps at that point).
-            if ( lhs.location.line != rhs.location.line ) { return false; }
-            return StringRef( lhs.name ) == rhs.name &&
-                   lhs.location == rhs.location;
-        }
-        friend bool operator==( NameAndLocationRef const& lhs,
-                                NameAndLocation const& rhs ) {
-            return rhs == lhs;
-        }
-    };
-
-    class ITracker;
-
-    using ITrackerPtr = Catch::Detail::unique_ptr<ITracker>;
-
-    class ITracker {
-        NameAndLocation m_nameAndLocation;
-
-        using Children = std::vector<ITrackerPtr>;
-
-    protected:
-        enum CycleState {
-            NotStarted,
-            Executing,
-            ExecutingChildren,
-            NeedsAnotherRun,
-            CompletedSuccessfully,
-            Failed
-        };
-
-        ITracker* m_parent = nullptr;
-        Children m_children;
-        CycleState m_runState = NotStarted;
-
-    public:
-        ITracker( NameAndLocation&& nameAndLoc, ITracker* parent ):
-            m_nameAndLocation( CATCH_MOVE(nameAndLoc) ),
-            m_parent( parent )
-        {}
-
-
-        // static queries
-        NameAndLocation const& nameAndLocation() const {
-            return m_nameAndLocation;
-        }
-        ITracker* parent() const {
-            return m_parent;
-        }
-
-        virtual ~ITracker(); // = default
-
-
-        // dynamic queries
-
-        //! Returns true if tracker run to completion (successfully or not)
-        virtual bool isComplete() const = 0;
-        //! Returns true if tracker run to completion successfully
-        bool isSuccessfullyCompleted() const {
-            return m_runState == CompletedSuccessfully;
-        }
-        //! Returns true if tracker has started but hasn't been completed
-        bool isOpen() const;
-        //! Returns true iff tracker has started
-        bool hasStarted() const;
-
-        // actions
-        virtual void close() = 0; // Successfully complete
-        virtual void fail() = 0;
-        void markAsNeedingAnotherRun();
-
-        //! Register a nested ITracker
-        void addChild( ITrackerPtr&& child );
-        /**
-         * Returns ptr to specific child if register with this tracker.
-         *
-         * Returns nullptr if not found.
-         */
-        ITracker* findChild( NameAndLocationRef const& nameAndLocation );
-        //! Have any children been added?
-        bool hasChildren() const {
-            return !m_children.empty();
-        }
-
-
-        //! Marks tracker as executing a child, doing se recursively up the tree
-        void openChild();
-
-        /**
-         * Returns true if the instance is a section tracker
-         *
-         * Subclasses should override to true if they are, replaces RTTI
-         * for internal debug checks.
-         */
-        virtual bool isSectionTracker() const;
-        /**
-         * Returns true if the instance is a generator tracker
-         *
-         * Subclasses should override to true if they are, replaces RTTI
-         * for internal debug checks.
-         */
-        virtual bool isGeneratorTracker() const;
-    };
-
-    class TrackerContext {
-
-        enum RunState {
-            NotStarted,
-            Executing,
-            CompletedCycle
-        };
-
-        ITrackerPtr m_rootTracker;
-        ITracker* m_currentTracker = nullptr;
-        RunState m_runState = NotStarted;
-
-    public:
-
-        ITracker& startRun();
-
-        void startCycle() {
-            m_currentTracker = m_rootTracker.get();
-            m_runState = Executing;
-        }
-        void completeCycle();
-
-        bool completedCycle() const;
-        ITracker& currentTracker() { return *m_currentTracker; }
-        void setCurrentTracker( ITracker* tracker );
-    };
-
-    class TrackerBase : public ITracker {
-    protected:
-
-        TrackerContext& m_ctx;
-
-    public:
-        TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );
-
-        bool isComplete() const override;
-
-        void open();
-
-        void close() override;
-        void fail() override;
-
-    private:
-        void moveToParent();
-        void moveToThis();
-    };
-
-    class SectionTracker : public TrackerBase {
-        std::vector<StringRef> m_filters;
-        // Note that lifetime-wise we piggy back off the name stored in the `ITracker` parent`.
-        // Currently it allocates owns the name, so this is safe. If it is later refactored
-        // to not own the name, the name still has to outlive the `ITracker` parent, so
-        // this should still be safe.
-        StringRef m_trimmed_name;
-    public:
-        SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );
-
-        bool isSectionTracker() const override;
-
-        bool isComplete() const override;
-
-        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation );
-
-        void tryOpen();
-
-        void addInitialFilters( std::vector<std::string> const& filters );
-        void addNextFilters( std::vector<StringRef> const& filters );
-        //! Returns filters active in this tracker
-        std::vector<StringRef> const& getFilters() const { return m_filters; }
-        //! Returns whitespace-trimmed name of the tracked section
-        StringRef trimmedName() const;
-    };
-
-} // namespace TestCaseTracking
-
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
-
-} // namespace Catch
-
-#endif // CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    class IGeneratorTracker;
-    class IConfig;
-    class IEventListener;
-    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
-    class OutputRedirect;
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class RunContext final : public IResultCapture {
-
-    public:
-        RunContext( RunContext const& ) = delete;
-        RunContext& operator =( RunContext const& ) = delete;
-
-        explicit RunContext( IConfig const* _config, IEventListenerPtr&& reporter );
-
-        ~RunContext() override;
-
-        Totals runTest(TestCaseHandle const& testCase);
-
-    public: // IResultCapture
-
-        // Assertion handlers
-        void handleExpr
-                (   AssertionInfo const& info,
-                    ITransientExpression const& expr,
-                    AssertionReaction& reaction ) override;
-        void handleMessage
-                (   AssertionInfo const& info,
-                    ResultWas::OfType resultType,
-                    std::string&& message,
-                    AssertionReaction& reaction ) override;
-        void handleUnexpectedExceptionNotThrown
-                (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) override;
-        void handleUnexpectedInflightException
-                (   AssertionInfo const& info,
-                    std::string&& message,
-                    AssertionReaction& reaction ) override;
-        void handleIncomplete
-                (   AssertionInfo const& info ) override;
-        void handleNonExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) override;
-
-        void notifyAssertionStarted( AssertionInfo const& info ) override;
-        bool sectionStarted( StringRef sectionName,
-                             SourceLineInfo const& sectionLineInfo,
-                             Counts& assertions ) override;
-
-        void sectionEnded( SectionEndInfo&& endInfo ) override;
-        void sectionEndedEarly( SectionEndInfo&& endInfo ) override;
-
-        IGeneratorTracker*
-        acquireGeneratorTracker( StringRef generatorName,
-                                 SourceLineInfo const& lineInfo ) override;
-        IGeneratorTracker* createGeneratorTracker(
-            StringRef generatorName,
-            SourceLineInfo lineInfo,
-            Generators::GeneratorBasePtr&& generator ) override;
-
-
-        void benchmarkPreparing( StringRef name ) override;
-        void benchmarkStarting( BenchmarkInfo const& info ) override;
-        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
-        void benchmarkFailed( StringRef error ) override;
-
-        void pushScopedMessage( MessageInfo const& message ) override;
-        void popScopedMessage( MessageInfo const& message ) override;
-
-        void emplaceUnscopedMessage( MessageBuilder&& builder ) override;
-
-        std::string getCurrentTestName() const override;
-
-        const AssertionResult* getLastResult() const override;
-
-        void exceptionEarlyReported() override;
-
-        void handleFatalErrorCondition( StringRef message ) override;
-
-        bool lastAssertionPassed() override;
-
-        void assertionPassed() override;
-
-    public:
-        // !TBD We need to do this another way!
-        bool aborting() const;
-
-    private:
-
-        void runCurrentTest();
-        void invokeActiveTestCase();
-
-        void resetAssertionInfo();
-        bool testForMissingAssertions( Counts& assertions );
-
-        void assertionEnded( AssertionResult&& result );
-        void reportExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    ITransientExpression const *expr,
-                    bool negated );
-
-        void populateReaction( AssertionReaction& reaction );
-
-    private:
-
-        void handleUnfinishedSections();
-
-        TestRunInfo m_runInfo;
-        TestCaseHandle const* m_activeTestCase = nullptr;
-        ITracker* m_testCaseTracker = nullptr;
-        Optional<AssertionResult> m_lastResult;
-
-        IConfig const* m_config;
-        Totals m_totals;
-        IEventListenerPtr m_reporter;
-        std::vector<MessageInfo> m_messages;
-        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
-        AssertionInfo m_lastAssertionInfo;
-        std::vector<SectionEndInfo> m_unfinishedSections;
-        std::vector<ITracker*> m_activeSections;
-        TrackerContext m_trackerContext;
-        Detail::unique_ptr<OutputRedirect> m_outputRedirect;
-        FatalConditionHandler m_fatalConditionhandler;
-        bool m_lastAssertionPassed = false;
-        bool m_shouldReportUnexpected = true;
-        bool m_includeSuccessfulResults;
-    };
-
-    void seedRng(IConfig const& config);
-    unsigned int rngSeed();
-} // end namespace Catch
-
-#endif // CATCH_RUN_CONTEXT_HPP_INCLUDED
-
-
-#ifndef CATCH_SHARDING_HPP_INCLUDED
-#define CATCH_SHARDING_HPP_INCLUDED
-
-#include <cassert>
-#include <cmath>
-#include <algorithm>
-
-namespace Catch {
-
-    template<typename Container>
-    Container createShard(Container const& container, std::size_t const shardCount, std::size_t const shardIndex) {
-        assert(shardCount > shardIndex);
-
-        if (shardCount == 1) {
-            return container;
-        }
-
-        const std::size_t totalTestCount = container.size();
-
-        const std::size_t shardSize = totalTestCount / shardCount;
-        const std::size_t leftoverTests = totalTestCount % shardCount;
-
-        const std::size_t startIndex = shardIndex * shardSize + (std::min)(shardIndex, leftoverTests);
-        const std::size_t endIndex = (shardIndex + 1) * shardSize + (std::min)(shardIndex + 1, leftoverTests);
-
-        auto startIterator = std::next(container.begin(), static_cast<std::ptrdiff_t>(startIndex));
-        auto endIterator = std::next(container.begin(), static_cast<std::ptrdiff_t>(endIndex));
-
-        return Container(startIterator, endIterator);
-    }
-
-}
-
-#endif // CATCH_SHARDING_HPP_INCLUDED
-
-
-#ifndef CATCH_SINGLETONS_HPP_INCLUDED
-#define CATCH_SINGLETONS_HPP_INCLUDED
-
-namespace Catch {
-
-    struct ISingleton {
-        virtual ~ISingleton(); // = default
-    };
-
-
-    void addSingleton( ISingleton* singleton );
-    void cleanupSingletons();
-
-
-    template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
-    class Singleton : SingletonImplT, public ISingleton {
-
-        static auto getInternal() -> Singleton* {
-            static Singleton* s_instance = nullptr;
-            if( !s_instance ) {
-                s_instance = new Singleton;
-                addSingleton( s_instance );
-            }
-            return s_instance;
-        }
-
-    public:
-        static auto get() -> InterfaceT const& {
-            return *getInternal();
-        }
-        static auto getMutable() -> MutableInterfaceT& {
-            return *getInternal();
-        }
-    };
-
-} // namespace Catch
-
-#endif // CATCH_SINGLETONS_HPP_INCLUDED
-
-
-#ifndef CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
-#define CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
-
-
-#include <vector>
-#include <exception>
-
-namespace Catch {
-
-    class StartupExceptionRegistry {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    public:
-        void add(std::exception_ptr const& exception) noexcept;
-        std::vector<std::exception_ptr> const& getExceptions() const noexcept;
-    private:
-        std::vector<std::exception_ptr> m_exceptions;
-#endif
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
-
-
-
-#ifndef CATCH_STDSTREAMS_HPP_INCLUDED
-#define CATCH_STDSTREAMS_HPP_INCLUDED
-
-#include <iosfwd>
-
-namespace Catch {
-
-    std::ostream& cout();
-    std::ostream& cerr();
-    std::ostream& clog();
-
-} // namespace Catch
-
-#endif
-
-
-#ifndef CATCH_STRING_MANIP_HPP_INCLUDED
-#define CATCH_STRING_MANIP_HPP_INCLUDED
-
-
-#include <cstdint>
-#include <string>
-#include <iosfwd>
-#include <vector>
-
-namespace Catch {
-
-    bool startsWith( std::string const& s, std::string const& prefix );
-    bool startsWith( StringRef s, char prefix );
-    bool endsWith( std::string const& s, std::string const& suffix );
-    bool endsWith( std::string const& s, char suffix );
-    bool contains( std::string const& s, std::string const& infix );
-    void toLowerInPlace( std::string& s );
-    std::string toLower( std::string const& s );
-    char toLower( char c );
-    //! Returns a new string without whitespace at the start/end
-    std::string trim( std::string const& str );
-    //! Returns a substring of the original ref without whitespace. Beware lifetimes!
-    StringRef trim(StringRef ref);
-
-    // !!! Be aware, returns refs into original string - make sure original string outlives them
-    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
-
-    /**
-     * Helper for streaming a "count [maybe-plural-of-label]" human-friendly string
-     *
-     * Usage example:
-     * ```cpp
-     * std::cout << "Found " << pluralise(count, "error") << '\n';
-     * ```
-     *
-     * **Important:** The provided string must outlive the instance
-     */
-    class pluralise {
-        std::uint64_t m_count;
-        StringRef m_label;
-
-    public:
-        constexpr pluralise(std::uint64_t count, StringRef label):
-            m_count(count),
-            m_label(label)
-        {}
-
-        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
-    };
-}
-
-#endif // CATCH_STRING_MANIP_HPP_INCLUDED
-
-
-#ifndef CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
-#define CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
-
-
-#include <map>
-#include <string>
-
-namespace Catch {
-    struct SourceLineInfo;
-
-    class TagAliasRegistry : public ITagAliasRegistry {
-    public:
-        ~TagAliasRegistry() override;
-        TagAlias const* find( std::string const& alias ) const override;
-        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
-        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
-
-    private:
-        std::map<std::string, TagAlias> m_registry;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
-
-
-#ifndef CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED
-#define CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED
-
-#include <cstdint>
-
-namespace Catch {
-
-    struct TestCaseInfo;
-
-    class TestCaseInfoHasher {
-    public:
-        using hash_t = std::uint64_t;
-        TestCaseInfoHasher( hash_t seed );
-        uint32_t operator()( TestCaseInfo const& t ) const;
-
-    private:
-        hash_t m_seed;
-    };
-
-} // namespace Catch
-
-#endif /* CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED */
-
-
-#ifndef CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
-#define CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
-
-
-#include <vector>
-
-namespace Catch {
-
-    class IConfig;
-    class ITestInvoker;
-    class TestCaseHandle;
-    class TestSpec;
-
-    std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases );
-
-    bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config );
-
-    std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config );
-
-    class TestRegistry : public ITestCaseRegistry {
-    public:
-        void registerTest( Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker );
-
-        std::vector<TestCaseInfo*> const& getAllInfos() const override;
-        std::vector<TestCaseHandle> const& getAllTests() const override;
-        std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const override;
-
-        ~TestRegistry() override; // = default
-
-    private:
-        std::vector<Detail::unique_ptr<TestCaseInfo>> m_owned_test_infos;
-        // Keeps a materialized vector for `getAllInfos`.
-        // We should get rid of that eventually (see interface note)
-        std::vector<TestCaseInfo*> m_viewed_test_infos;
-
-        std::vector<Detail::unique_ptr<ITestInvoker>> m_invokers;
-        std::vector<TestCaseHandle> m_handles;
-        mutable TestRunOrder m_currentSortOrder = TestRunOrder::Declared;
-        mutable std::vector<TestCaseHandle> m_sortedFunctions;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-
-} // end namespace Catch
-
-
-#endif // CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
-
-
-#ifndef CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
-#define CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-
-#include <vector>
-#include <string>
-
-namespace Catch {
-
-    class ITagAliasRegistry;
-
-    class TestSpecParser {
-        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
-        Mode m_mode = None;
-        Mode lastMode = None;
-        bool m_exclusion = false;
-        std::size_t m_pos = 0;
-        std::size_t m_realPatternPos = 0;
-        std::string m_arg;
-        std::string m_substring;
-        std::string m_patternName;
-        std::vector<std::size_t> m_escapeChars;
-        TestSpec::Filter m_currentFilter;
-        TestSpec m_testSpec;
-        ITagAliasRegistry const* m_tagAliases = nullptr;
-
-    public:
-        TestSpecParser( ITagAliasRegistry const& tagAliases );
-
-        TestSpecParser& parse( std::string const& arg );
-        TestSpec testSpec();
-
-    private:
-        bool visitChar( char c );
-        void startNewMode( Mode mode );
-        bool processNoneChar( char c );
-        void processNameChar( char c );
-        bool processOtherChar( char c );
-        void endMode();
-        void escape();
-        bool isControlChar( char c ) const;
-        void saveLastMode();
-        void revertBackToLastMode();
-        void addFilter();
-        bool separate();
-
-        // Handles common preprocessing of the pattern for name/tag patterns
-        std::string preprocessPattern();
-        // Adds the current pattern as a test name
-        void addNamePattern();
-        // Adds the current pattern as a tag
-        void addTagPattern();
-
-        inline void addCharToPattern(char c) {
-            m_substring += c;
-            m_patternName += c;
-            m_realPatternPos++;
-        }
-
-    };
-
-} // namespace Catch
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-#endif // CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
-
-
-#ifndef CATCH_TEXTFLOW_HPP_INCLUDED
-#define CATCH_TEXTFLOW_HPP_INCLUDED
-
-
-#include <cassert>
-#include <string>
-#include <vector>
-
-namespace Catch {
-    namespace TextFlow {
-
-        class Columns;
-
-        /**
-         * Abstraction for a string with ansi escape sequences that
-         * automatically skips over escapes when iterating. Only graphical
-         * escape sequences are considered.
-         *
-         * Internal representation:
-         * An escape sequence looks like \033[39;49m
-         * We need bidirectional iteration and the unbound length of escape
-         * sequences poses a problem for operator-- To make this work we'll
-         * replace the last `m` with a 0xff (this is a codepoint that won't have
-         * any utf-8 meaning).
-         */
-        class AnsiSkippingString {
-            std::string m_string;
-            std::size_t m_size = 0;
-
-            // perform 0xff replacement and calculate m_size
-            void preprocessString();
-
-        public:
-            class const_iterator;
-            using iterator = const_iterator;
-            // note: must be u-suffixed or this will cause a "truncation of
-            // constant value" warning on MSVC
-            static constexpr char sentinel = static_cast<char>( 0xffu );
-
-            explicit AnsiSkippingString( std::string const& text );
-            explicit AnsiSkippingString( std::string&& text );
-
-            const_iterator begin() const;
-            const_iterator end() const;
-
-            size_t size() const { return m_size; }
-
-            std::string substring( const_iterator begin,
-                                   const_iterator end ) const;
-        };
-
-        class AnsiSkippingString::const_iterator {
-            friend AnsiSkippingString;
-            struct EndTag {};
-
-            const std::string* m_string;
-            std::string::const_iterator m_it;
-
-            explicit const_iterator( const std::string& string, EndTag ):
-                m_string( &string ), m_it( string.end() ) {}
-
-            void tryParseAnsiEscapes();
-            void advance();
-            void unadvance();
-
-        public:
-            using difference_type = std::ptrdiff_t;
-            using value_type = char;
-            using pointer = value_type*;
-            using reference = value_type&;
-            using iterator_category = std::bidirectional_iterator_tag;
-
-            explicit const_iterator( const std::string& string ):
-                m_string( &string ), m_it( string.begin() ) {
-                tryParseAnsiEscapes();
-            }
-
-            char operator*() const { return *m_it; }
-
-            const_iterator& operator++() {
-                advance();
-                return *this;
-            }
-            const_iterator operator++( int ) {
-                iterator prev( *this );
-                operator++();
-                return prev;
-            }
-            const_iterator& operator--() {
-                unadvance();
-                return *this;
-            }
-            const_iterator operator--( int ) {
-                iterator prev( *this );
-                operator--();
-                return prev;
-            }
-
-            bool operator==( const_iterator const& other ) const {
-                return m_it == other.m_it;
-            }
-            bool operator!=( const_iterator const& other ) const {
-                return !operator==( other );
-            }
-            bool operator<=( const_iterator const& other ) const {
-                return m_it <= other.m_it;
-            }
-
-            const_iterator oneBefore() const {
-                auto it = *this;
-                return --it;
-            }
-        };
-
-        /**
-         * Represents a column of text with specific width and indentation
-         *
-         * When written out to a stream, it will perform linebreaking
-         * of the provided text so that the written lines fit within
-         * target width.
-         */
-        class Column {
-            // String to be written out
-            AnsiSkippingString m_string;
-            // Width of the column for linebreaking
-            size_t m_width = CATCH_CONFIG_CONSOLE_WIDTH - 1;
-            // Indentation of other lines (including first if initial indent is
-            // unset)
-            size_t m_indent = 0;
-            // Indentation of the first line
-            size_t m_initialIndent = std::string::npos;
-
-        public:
-            /**
-             * Iterates "lines" in `Column` and returns them
-             */
-            class const_iterator {
-                friend Column;
-                struct EndTag {};
-
-                Column const& m_column;
-                // Where does the current line start?
-                AnsiSkippingString::const_iterator m_lineStart;
-                // How long should the current line be?
-                AnsiSkippingString::const_iterator m_lineEnd;
-                // How far have we checked the string to iterate?
-                AnsiSkippingString::const_iterator m_parsedTo;
-                // Should a '-' be appended to the line?
-                bool m_addHyphen = false;
-
-                const_iterator( Column const& column, EndTag ):
-                    m_column( column ),
-                    m_lineStart( m_column.m_string.end() ),
-                    m_lineEnd( column.m_string.end() ),
-                    m_parsedTo( column.m_string.end() ) {}
-
-                // Calculates the length of the current line
-                void calcLength();
-
-                // Returns current indentation width
-                size_t indentSize() const;
-
-                // Creates an indented and (optionally) suffixed string from
-                // current iterator position, indentation and length.
-                std::string addIndentAndSuffix(
-                    AnsiSkippingString::const_iterator start,
-                    AnsiSkippingString::const_iterator end ) const;
-
-            public:
-                using difference_type = std::ptrdiff_t;
-                using value_type = std::string;
-                using pointer = value_type*;
-                using reference = value_type&;
-                using iterator_category = std::forward_iterator_tag;
-
-                explicit const_iterator( Column const& column );
-
-                std::string operator*() const;
-
-                const_iterator& operator++();
-                const_iterator operator++( int );
-
-                bool operator==( const_iterator const& other ) const {
-                    return m_lineStart == other.m_lineStart &&
-                           &m_column == &other.m_column;
-                }
-                bool operator!=( const_iterator const& other ) const {
-                    return !operator==( other );
-                }
-            };
-            using iterator = const_iterator;
-
-            explicit Column( std::string const& text ): m_string( text ) {}
-            explicit Column( std::string&& text ):
-                m_string( CATCH_MOVE( text ) ) {}
-
-            Column& width( size_t newWidth ) & {
-                assert( newWidth > 0 );
-                m_width = newWidth;
-                return *this;
-            }
-            Column&& width( size_t newWidth ) && {
-                assert( newWidth > 0 );
-                m_width = newWidth;
-                return CATCH_MOVE( *this );
-            }
-            Column& indent( size_t newIndent ) & {
-                m_indent = newIndent;
-                return *this;
-            }
-            Column&& indent( size_t newIndent ) && {
-                m_indent = newIndent;
-                return CATCH_MOVE( *this );
-            }
-            Column& initialIndent( size_t newIndent ) & {
-                m_initialIndent = newIndent;
-                return *this;
-            }
-            Column&& initialIndent( size_t newIndent ) && {
-                m_initialIndent = newIndent;
-                return CATCH_MOVE( *this );
-            }
-
-            size_t width() const { return m_width; }
-            const_iterator begin() const { return const_iterator( *this ); }
-            const_iterator end() const {
-                return { *this, const_iterator::EndTag{} };
-            }
-
-            friend std::ostream& operator<<( std::ostream& os,
-                                             Column const& col );
-
-            friend Columns operator+( Column const& lhs, Column const& rhs );
-            friend Columns operator+( Column&& lhs, Column&& rhs );
-        };
-
-        //! Creates a column that serves as an empty space of specific width
-        Column Spacer( size_t spaceWidth );
-
-        class Columns {
-            std::vector<Column> m_columns;
-
-        public:
-            class iterator {
-                friend Columns;
-                struct EndTag {};
-
-                std::vector<Column> const& m_columns;
-                std::vector<Column::const_iterator> m_iterators;
-                size_t m_activeIterators;
-
-                iterator( Columns const& columns, EndTag );
-
-            public:
-                using difference_type = std::ptrdiff_t;
-                using value_type = std::string;
-                using pointer = value_type*;
-                using reference = value_type&;
-                using iterator_category = std::forward_iterator_tag;
-
-                explicit iterator( Columns const& columns );
-
-                auto operator==( iterator const& other ) const -> bool {
-                    return m_iterators == other.m_iterators;
-                }
-                auto operator!=( iterator const& other ) const -> bool {
-                    return m_iterators != other.m_iterators;
-                }
-                std::string operator*() const;
-                iterator& operator++();
-                iterator operator++( int );
-            };
-            using const_iterator = iterator;
-
-            iterator begin() const { return iterator( *this ); }
-            iterator end() const { return { *this, iterator::EndTag() }; }
-
-            friend Columns& operator+=( Columns& lhs, Column const& rhs );
-            friend Columns& operator+=( Columns& lhs, Column&& rhs );
-            friend Columns operator+( Columns const& lhs, Column const& rhs );
-            friend Columns operator+( Columns&& lhs, Column&& rhs );
-
-            friend std::ostream& operator<<( std::ostream& os,
-                                             Columns const& cols );
-        };
-
-    } // namespace TextFlow
-} // namespace Catch
-#endif // CATCH_TEXTFLOW_HPP_INCLUDED
-
-
-#ifndef CATCH_TO_STRING_HPP_INCLUDED
-#define CATCH_TO_STRING_HPP_INCLUDED
-
-#include <string>
-
-
-namespace Catch {
-    template <typename T>
-    std::string to_string(T const& t) {
-#if defined(CATCH_CONFIG_CPP11_TO_STRING)
-        return std::to_string(t);
-#else
-        ReusableStringStream rss;
-        rss << t;
-        return rss.str();
-#endif
-    }
-} // end namespace Catch
-
-#endif // CATCH_TO_STRING_HPP_INCLUDED
-
-
-#ifndef CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
-#define CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
-
-namespace Catch {
-    bool uncaught_exceptions();
-} // end namespace Catch
-
-#endif // CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
-
-
-#ifndef CATCH_XMLWRITER_HPP_INCLUDED
-#define CATCH_XMLWRITER_HPP_INCLUDED
-
-
-#include <iosfwd>
-#include <vector>
-#include <cstdint>
-
-namespace Catch {
-    enum class XmlFormatting : std::uint8_t {
-        None = 0x00,
-        Indent = 0x01,
-        Newline = 0x02,
-    };
-
-    constexpr XmlFormatting operator|( XmlFormatting lhs, XmlFormatting rhs ) {
-        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) |
-                                           static_cast<std::uint8_t>( rhs ) );
-    }
-
-    constexpr XmlFormatting operator&( XmlFormatting lhs, XmlFormatting rhs ) {
-        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) &
-                                           static_cast<std::uint8_t>( rhs ) );
-    }
-
-
-    /**
-     * Helper for XML-encoding text (escaping angle brackets, quotes, etc)
-     *
-     * Note: doesn't take ownership of passed strings, and thus the
-     *       encoded string must outlive the encoding instance.
-     */
-    class XmlEncode {
-    public:
-        enum ForWhat { ForTextNodes, ForAttributes };
-
-        constexpr XmlEncode( StringRef str, ForWhat forWhat = ForTextNodes ):
-            m_str( str ), m_forWhat( forWhat ) {}
-
-
-        void encodeTo( std::ostream& os ) const;
-
-        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
-
-    private:
-        StringRef m_str;
-        ForWhat m_forWhat;
-    };
-
-    class XmlWriter {
-    public:
-
-        class ScopedElement {
-        public:
-            ScopedElement( XmlWriter* writer, XmlFormatting fmt );
-
-            ScopedElement( ScopedElement&& other ) noexcept;
-            ScopedElement& operator=( ScopedElement&& other ) noexcept;
-
-            ~ScopedElement();
-
-            ScopedElement&
-            writeText( StringRef text,
-                       XmlFormatting fmt = XmlFormatting::Newline |
-                                           XmlFormatting::Indent );
-
-            ScopedElement& writeAttribute( StringRef name,
-                                           StringRef attribute );
-            template <typename T,
-                      // Without this SFINAE, this overload is a better match
-                      // for `std::string`, `char const*`, `char const[N]` args.
-                      // While it would still work, it would cause code bloat
-                      // and multiple iteration over the strings
-                      typename = typename std::enable_if_t<
-                          !std::is_convertible<T, StringRef>::value>>
-            ScopedElement& writeAttribute( StringRef name,
-                                           T const& attribute ) {
-                m_writer->writeAttribute( name, attribute );
-                return *this;
-            }
-
-        private:
-            XmlWriter* m_writer = nullptr;
-            XmlFormatting m_fmt;
-        };
-
-        XmlWriter( std::ostream& os );
-        ~XmlWriter();
-
-        XmlWriter( XmlWriter const& ) = delete;
-        XmlWriter& operator=( XmlWriter const& ) = delete;
-
-        XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        //! The attribute content is XML-encoded
-        XmlWriter& writeAttribute( StringRef name, StringRef attribute );
-
-        //! Writes the attribute as "true/false"
-        XmlWriter& writeAttribute( StringRef name, bool attribute );
-
-        //! The attribute content is XML-encoded
-        XmlWriter& writeAttribute( StringRef name, char const* attribute );
-
-        //! The attribute value must provide op<<(ostream&, T). The resulting
-        //! serialization is XML-encoded
-        template <typename T,
-                  // Without this SFINAE, this overload is a better match
-                  // for `std::string`, `char const*`, `char const[N]` args.
-                  // While it would still work, it would cause code bloat
-                  // and multiple iteration over the strings
-                  typename = typename std::enable_if_t<
-                      !std::is_convertible<T, StringRef>::value>>
-        XmlWriter& writeAttribute( StringRef name, T const& attribute ) {
-            ReusableStringStream rss;
-            rss << attribute;
-            return writeAttribute( name, rss.str() );
-        }
-
-        //! Writes escaped `text` in a element
-        XmlWriter& writeText( StringRef text,
-                              XmlFormatting fmt = XmlFormatting::Newline |
-                                                  XmlFormatting::Indent );
-
-        //! Writes XML comment as "<!-- text -->"
-        XmlWriter& writeComment( StringRef text,
-                                 XmlFormatting fmt = XmlFormatting::Newline |
-                                                     XmlFormatting::Indent );
-
-        void writeStylesheetRef( StringRef url );
-
-        void ensureTagClosed();
-
-    private:
-
-        void applyFormatting(XmlFormatting fmt);
-
-        void writeDeclaration();
-
-        void newlineIfNecessary();
-
-        bool m_tagIsOpen = false;
-        bool m_needsNewline = false;
-        std::vector<std::string> m_tags;
-        std::string m_indent;
-        std::ostream& m_os;
-    };
-
-}
-
-#endif // CATCH_XMLWRITER_HPP_INCLUDED
-
-
-/** \file
- * This is a convenience header for Catch2's Matcher support. It includes
- * **all** of Catch2 headers related to matchers.
- *
- * Generally the Catch2 users should use specific includes they need,
- * but this header can be used instead for ease-of-experimentation, or
- * just plain convenience, at the cost of increased compilation times.
- *
- * When a new header is added to either the `matchers` folder, or to
- * the corresponding internal subfolder, it should be added here.
- */
-
-#ifndef CATCH_MATCHERS_ALL_HPP_INCLUDED
-#define CATCH_MATCHERS_ALL_HPP_INCLUDED
-
-
-
-#ifndef CATCH_MATCHERS_HPP_INCLUDED
-#define CATCH_MATCHERS_HPP_INCLUDED
-
-
-
-#ifndef CATCH_MATCHERS_IMPL_HPP_INCLUDED
-#define CATCH_MATCHERS_IMPL_HPP_INCLUDED
-
-
-#include <string>
-
-namespace Catch {
-
-#ifdef __clang__
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wsign-compare"
-#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
-#elif defined __GNUC__
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wsign-compare"
-#    pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
-#endif
-
-    template<typename ArgT, typename MatcherT>
-    class MatchExpr : public ITransientExpression {
-        ArgT && m_arg;
-        MatcherT const& m_matcher;
-    public:
-        constexpr MatchExpr( ArgT && arg, MatcherT const& matcher )
-        :   ITransientExpression{ true, matcher.match( arg ) }, // not forwarding arg here on purpose
-            m_arg( CATCH_FORWARD(arg) ),
-            m_matcher( matcher )
-        {}
-
-        void streamReconstructedExpression( std::ostream& os ) const override {
-            os << Catch::Detail::stringify( m_arg )
-               << ' '
-               << m_matcher.toString();
-        }
-    };
-
-#ifdef __clang__
-#    pragma clang diagnostic pop
-#elif defined __GNUC__
-#    pragma GCC diagnostic pop
-#endif
-
-
-    namespace Matchers {
-        template <typename ArgT>
-        class MatcherBase;
-    }
-
-    using StringMatcher = Matchers::MatcherBase<std::string>;
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher );
-
-    template<typename ArgT, typename MatcherT>
-    constexpr MatchExpr<ArgT, MatcherT>
-    makeMatchExpr( ArgT&& arg, MatcherT const& matcher ) {
-        return MatchExpr<ArgT, MatcherT>( CATCH_FORWARD(arg), matcher );
-    }
-
-} // namespace Catch
-
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
-            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher ) ); \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        catchAssertionHandler.complete(); \
-    } while( false )
-
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
-                static_cast<void>(__VA_ARGS__ ); \
-                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( exceptionType const& ex ) { \
-                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher ) ); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        catchAssertionHandler.complete(); \
-    } while( false )
-
-
-#endif // CATCH_MATCHERS_IMPL_HPP_INCLUDED
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-namespace Matchers {
-
-    class MatcherUntypedBase {
-    public:
-        MatcherUntypedBase() = default;
-
-        MatcherUntypedBase(MatcherUntypedBase const&) = default;
-        MatcherUntypedBase(MatcherUntypedBase&&) = default;
-
-        MatcherUntypedBase& operator = (MatcherUntypedBase const&) = delete;
-        MatcherUntypedBase& operator = (MatcherUntypedBase&&) = delete;
-
-        std::string toString() const;
-
-    protected:
-        virtual ~MatcherUntypedBase(); // = default;
-        virtual std::string describe() const = 0;
-        mutable std::string m_cachedToString;
-    };
-
-
-    template<typename T>
-    class MatcherBase : public MatcherUntypedBase {
-    public:
-        virtual bool match( T const& arg ) const = 0;
-    };
-
-    namespace Detail {
-
-        template<typename ArgT>
-        class MatchAllOf final : public MatcherBase<ArgT> {
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-
-        public:
-            MatchAllOf() = default;
-            MatchAllOf(MatchAllOf const&) = delete;
-            MatchAllOf& operator=(MatchAllOf const&) = delete;
-            MatchAllOf(MatchAllOf&&) = default;
-            MatchAllOf& operator=(MatchAllOf&&) = default;
-
-
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (!matcher->match(arg))
-                        return false;
-                }
-                return true;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " and ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            friend MatchAllOf operator&& (MatchAllOf&& lhs, MatcherBase<ArgT> const& rhs) {
-                lhs.m_matchers.push_back(&rhs);
-                return CATCH_MOVE(lhs);
-            }
-            friend MatchAllOf operator&& (MatcherBase<ArgT> const& lhs, MatchAllOf&& rhs) {
-                rhs.m_matchers.insert(rhs.m_matchers.begin(), &lhs);
-                return CATCH_MOVE(rhs);
-            }
-        };
-
-        //! lvalue overload is intentionally deleted, users should
-        //! not be trying to compose stored composition matchers
-        template<typename ArgT>
-        MatchAllOf<ArgT> operator&& (MatchAllOf<ArgT> const& lhs, MatcherBase<ArgT> const& rhs) = delete;
-        //! lvalue overload is intentionally deleted, users should
-        //! not be trying to compose stored composition matchers
-        template<typename ArgT>
-        MatchAllOf<ArgT> operator&& (MatcherBase<ArgT> const& lhs, MatchAllOf<ArgT> const& rhs) = delete;
-
-        template<typename ArgT>
-        class MatchAnyOf final : public MatcherBase<ArgT> {
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        public:
-            MatchAnyOf() = default;
-            MatchAnyOf(MatchAnyOf const&) = delete;
-            MatchAnyOf& operator=(MatchAnyOf const&) = delete;
-            MatchAnyOf(MatchAnyOf&&) = default;
-            MatchAnyOf& operator=(MatchAnyOf&&) = default;
-
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (matcher->match(arg))
-                        return true;
-                }
-                return false;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " or ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            friend MatchAnyOf operator|| (MatchAnyOf&& lhs, MatcherBase<ArgT> const& rhs) {
-                lhs.m_matchers.push_back(&rhs);
-                return CATCH_MOVE(lhs);
-            }
-            friend MatchAnyOf operator|| (MatcherBase<ArgT> const& lhs, MatchAnyOf&& rhs) {
-                rhs.m_matchers.insert(rhs.m_matchers.begin(), &lhs);
-                return CATCH_MOVE(rhs);
-            }
-        };
-
-        //! lvalue overload is intentionally deleted, users should
-        //! not be trying to compose stored composition matchers
-        template<typename ArgT>
-        MatchAnyOf<ArgT> operator|| (MatchAnyOf<ArgT> const& lhs, MatcherBase<ArgT> const& rhs) = delete;
-        //! lvalue overload is intentionally deleted, users should
-        //! not be trying to compose stored composition matchers
-        template<typename ArgT>
-        MatchAnyOf<ArgT> operator|| (MatcherBase<ArgT> const& lhs, MatchAnyOf<ArgT> const& rhs) = delete;
-
-        template<typename ArgT>
-        class MatchNotOf final : public MatcherBase<ArgT> {
-            MatcherBase<ArgT> const& m_underlyingMatcher;
-
-        public:
-            explicit MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ):
-                m_underlyingMatcher( underlyingMatcher )
-            {}
-
-            bool match( ArgT const& arg ) const override {
-                return !m_underlyingMatcher.match( arg );
-            }
-
-            std::string describe() const override {
-                return "not " + m_underlyingMatcher.toString();
-            }
-        };
-
-    } // namespace Detail
-
-    template <typename T>
-    Detail::MatchAllOf<T> operator&& (MatcherBase<T> const& lhs, MatcherBase<T> const& rhs) {
-        return Detail::MatchAllOf<T>{} && lhs && rhs;
-    }
-    template <typename T>
-    Detail::MatchAnyOf<T> operator|| (MatcherBase<T> const& lhs, MatcherBase<T> const& rhs) {
-        return Detail::MatchAnyOf<T>{} || lhs || rhs;
-    }
-
-    template <typename T>
-    Detail::MatchNotOf<T> operator! (MatcherBase<T> const& matcher) {
-        return Detail::MatchNotOf<T>{ matcher };
-    }
-
-
-} // namespace Matchers
-} // namespace Catch
-
-
-#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
-  #define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-  #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-
-  #define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-  #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-
-  #define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-  #define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-
-#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
-
-  #define CATCH_REQUIRE_THROWS_WITH( expr, matcher )                   (void)(0)
-  #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-
-  #define CATCH_CHECK_THROWS_WITH( expr, matcher )                     (void)(0)
-  #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher )   (void)(0)
-
-  #define CATCH_CHECK_THAT( arg, matcher )                             (void)(0)
-  #define CATCH_REQUIRE_THAT( arg, matcher )                           (void)(0)
-
-#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
-
-  #define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-  #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-
-  #define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-  #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-
-  #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-  #define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-
-#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
-
-  #define REQUIRE_THROWS_WITH( expr, matcher )                   (void)(0)
-  #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-
-  #define CHECK_THROWS_WITH( expr, matcher )                     (void)(0)
-  #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher )   (void)(0)
-
-  #define CHECK_THAT( arg, matcher )                             (void)(0)
-  #define REQUIRE_THAT( arg, matcher )                           (void)(0)
-
-#endif // end of user facing macro declarations
-
-#endif // CATCH_MATCHERS_HPP_INCLUDED
-
-
-#ifndef CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
-#define CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
-
-
-
-#ifndef CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
-#define CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
-
-
-#include <array>
-#include <algorithm>
-#include <string>
-#include <type_traits>
-
-namespace Catch {
-namespace Matchers {
-    class MatcherGenericBase : public MatcherUntypedBase {
-    public:
-        MatcherGenericBase() = default;
-        ~MatcherGenericBase() override; // = default;
-
-        MatcherGenericBase(MatcherGenericBase const&) = default;
-        MatcherGenericBase(MatcherGenericBase&&) = default;
-
-        MatcherGenericBase& operator=(MatcherGenericBase const&) = delete;
-        MatcherGenericBase& operator=(MatcherGenericBase&&) = delete;
-    };
-
-
-    namespace Detail {
-        template<std::size_t N, std::size_t M>
-        std::array<void const*, N + M> array_cat(std::array<void const*, N> && lhs, std::array<void const*, M> && rhs) {
-            std::array<void const*, N + M> arr{};
-            std::copy_n(lhs.begin(), N, arr.begin());
-            std::copy_n(rhs.begin(), M, arr.begin() + N);
-            return arr;
-        }
-
-        template<std::size_t N>
-        std::array<void const*, N+1> array_cat(std::array<void const*, N> && lhs, void const* rhs) {
-            std::array<void const*, N+1> arr{};
-            std::copy_n(lhs.begin(), N, arr.begin());
-            arr[N] = rhs;
-            return arr;
-        }
-
-        template<std::size_t N>
-        std::array<void const*, N+1> array_cat(void const* lhs, std::array<void const*, N> && rhs) {
-            std::array<void const*, N + 1> arr{ {lhs} };
-            std::copy_n(rhs.begin(), N, arr.begin() + 1);
-            return arr;
-        }
-
-        template<typename T>
-        using is_generic_matcher = std::is_base_of<
-            Catch::Matchers::MatcherGenericBase,
-            std::remove_cv_t<std::remove_reference_t<T>>
-        >;
-
-        template<typename... Ts>
-        using are_generic_matchers = Catch::Detail::conjunction<is_generic_matcher<Ts>...>;
-
-        template<typename T>
-        using is_matcher = std::is_base_of<
-            Catch::Matchers::MatcherUntypedBase,
-            std::remove_cv_t<std::remove_reference_t<T>>
-        >;
-
-
-        template<std::size_t N, typename Arg>
-        bool match_all_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
-            return true;
-        }
-
-        template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
-        bool match_all_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
-            return static_cast<T const*>(matchers[Idx])->match(arg) && match_all_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
-        }
-
-
-        template<std::size_t N, typename Arg>
-        bool match_any_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
-            return false;
-        }
-
-        template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
-        bool match_any_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
-            return static_cast<T const*>(matchers[Idx])->match(arg) || match_any_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
-        }
-
-        std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end);
-
-        template<typename... MatcherTs, std::size_t... Idx>
-        std::string describe_multi_matcher(StringRef combine, std::array<void const*, sizeof...(MatcherTs)> const& matchers, std::index_sequence<Idx...>) {
-            std::array<std::string, sizeof...(MatcherTs)> descriptions {{
-                static_cast<MatcherTs const*>(matchers[Idx])->toString()...
-            }};
-
-            return describe_multi_matcher(combine, descriptions.data(), descriptions.data() + descriptions.size());
-        }
-
-
-        template<typename... MatcherTs>
-        class MatchAllOfGeneric final : public MatcherGenericBase {
-        public:
-            MatchAllOfGeneric(MatchAllOfGeneric const&) = delete;
-            MatchAllOfGeneric& operator=(MatchAllOfGeneric const&) = delete;
-            MatchAllOfGeneric(MatchAllOfGeneric&&) = default;
-            MatchAllOfGeneric& operator=(MatchAllOfGeneric&&) = default;
-
-            MatchAllOfGeneric(MatcherTs const&... matchers) : m_matchers{ {std::addressof(matchers)...} } {}
-            explicit MatchAllOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}
-
-            template<typename Arg>
-            bool match(Arg&& arg) const {
-                return match_all_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
-            }
-
-            std::string describe() const override {
-                return describe_multi_matcher<MatcherTs...>(" and "_sr, m_matchers, std::index_sequence_for<MatcherTs...>{});
-            }
-
-            // Has to be public to enable the concatenating operators
-            // below, because they are not friend of the RHS, only LHS,
-            // and thus cannot access private fields of RHS
-            std::array<void const*, sizeof...( MatcherTs )> m_matchers;
-
-
-            //! Avoids type nesting for `GenericAllOf && GenericAllOf` case
-            template<typename... MatchersRHS>
-            friend
-            MatchAllOfGeneric<MatcherTs..., MatchersRHS...> operator && (
-                    MatchAllOfGeneric<MatcherTs...>&& lhs,
-                    MatchAllOfGeneric<MatchersRHS...>&& rhs) {
-                return MatchAllOfGeneric<MatcherTs..., MatchersRHS...>{array_cat(CATCH_MOVE(lhs.m_matchers), CATCH_MOVE(rhs.m_matchers))};
-            }
-
-            //! Avoids type nesting for `GenericAllOf && some matcher` case
-            template<typename MatcherRHS>
-            friend std::enable_if_t<is_matcher<MatcherRHS>::value,
-            MatchAllOfGeneric<MatcherTs..., MatcherRHS>> operator && (
-                    MatchAllOfGeneric<MatcherTs...>&& lhs,
-                    MatcherRHS const& rhs) {
-                return MatchAllOfGeneric<MatcherTs..., MatcherRHS>{array_cat(CATCH_MOVE(lhs.m_matchers), static_cast<void const*>(&rhs))};
-            }
-
-            //! Avoids type nesting for `some matcher && GenericAllOf` case
-            template<typename MatcherLHS>
-            friend std::enable_if_t<is_matcher<MatcherLHS>::value,
-            MatchAllOfGeneric<MatcherLHS, MatcherTs...>> operator && (
-                    MatcherLHS const& lhs,
-                    MatchAllOfGeneric<MatcherTs...>&& rhs) {
-                return MatchAllOfGeneric<MatcherLHS, MatcherTs...>{array_cat(static_cast<void const*>(std::addressof(lhs)), CATCH_MOVE(rhs.m_matchers))};
-            }
-        };
-
-
-        template<typename... MatcherTs>
-        class MatchAnyOfGeneric final : public MatcherGenericBase {
-        public:
-            MatchAnyOfGeneric(MatchAnyOfGeneric const&) = delete;
-            MatchAnyOfGeneric& operator=(MatchAnyOfGeneric const&) = delete;
-            MatchAnyOfGeneric(MatchAnyOfGeneric&&) = default;
-            MatchAnyOfGeneric& operator=(MatchAnyOfGeneric&&) = default;
-
-            MatchAnyOfGeneric(MatcherTs const&... matchers) : m_matchers{ {std::addressof(matchers)...} } {}
-            explicit MatchAnyOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}
-
-            template<typename Arg>
-            bool match(Arg&& arg) const {
-                return match_any_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
-            }
-
-            std::string describe() const override {
-                return describe_multi_matcher<MatcherTs...>(" or "_sr, m_matchers, std::index_sequence_for<MatcherTs...>{});
-            }
-
-
-            // Has to be public to enable the concatenating operators
-            // below, because they are not friend of the RHS, only LHS,
-            // and thus cannot access private fields of RHS
-            std::array<void const*, sizeof...( MatcherTs )> m_matchers;
-
-            //! Avoids type nesting for `GenericAnyOf || GenericAnyOf` case
-            template<typename... MatchersRHS>
-            friend MatchAnyOfGeneric<MatcherTs..., MatchersRHS...> operator || (
-                    MatchAnyOfGeneric<MatcherTs...>&& lhs,
-                    MatchAnyOfGeneric<MatchersRHS...>&& rhs) {
-                return MatchAnyOfGeneric<MatcherTs..., MatchersRHS...>{array_cat(CATCH_MOVE(lhs.m_matchers), CATCH_MOVE(rhs.m_matchers))};
-            }
-
-            //! Avoids type nesting for `GenericAnyOf || some matcher` case
-            template<typename MatcherRHS>
-            friend std::enable_if_t<is_matcher<MatcherRHS>::value,
-            MatchAnyOfGeneric<MatcherTs..., MatcherRHS>> operator || (
-                    MatchAnyOfGeneric<MatcherTs...>&& lhs,
-                    MatcherRHS const& rhs) {
-                return MatchAnyOfGeneric<MatcherTs..., MatcherRHS>{array_cat(CATCH_MOVE(lhs.m_matchers), static_cast<void const*>(std::addressof(rhs)))};
-            }
-
-            //! Avoids type nesting for `some matcher || GenericAnyOf` case
-            template<typename MatcherLHS>
-            friend std::enable_if_t<is_matcher<MatcherLHS>::value,
-            MatchAnyOfGeneric<MatcherLHS, MatcherTs...>> operator || (
-                MatcherLHS const& lhs,
-                MatchAnyOfGeneric<MatcherTs...>&& rhs) {
-                return MatchAnyOfGeneric<MatcherLHS, MatcherTs...>{array_cat(static_cast<void const*>(std::addressof(lhs)), CATCH_MOVE(rhs.m_matchers))};
-            }
-        };
-
-
-        template<typename MatcherT>
-        class MatchNotOfGeneric final : public MatcherGenericBase {
-            MatcherT const& m_matcher;
-
-        public:
-            MatchNotOfGeneric(MatchNotOfGeneric const&) = delete;
-            MatchNotOfGeneric& operator=(MatchNotOfGeneric const&) = delete;
-            MatchNotOfGeneric(MatchNotOfGeneric&&) = default;
-            MatchNotOfGeneric& operator=(MatchNotOfGeneric&&) = default;
-
-            explicit MatchNotOfGeneric(MatcherT const& matcher) : m_matcher{matcher} {}
-
-            template<typename Arg>
-            bool match(Arg&& arg) const {
-                return !m_matcher.match(arg);
-            }
-
-            std::string describe() const override {
-                return "not " + m_matcher.toString();
-            }
-
-            //! Negating negation can just unwrap and return underlying matcher
-            friend MatcherT const& operator ! (MatchNotOfGeneric<MatcherT> const& matcher) {
-                return matcher.m_matcher;
-            }
-        };
-    } // namespace Detail
-
-
-    // compose only generic matchers
-    template<typename MatcherLHS, typename MatcherRHS>
-    std::enable_if_t<Detail::are_generic_matchers<MatcherLHS, MatcherRHS>::value, Detail::MatchAllOfGeneric<MatcherLHS, MatcherRHS>>
-        operator && (MatcherLHS const& lhs, MatcherRHS const& rhs) {
-        return { lhs, rhs };
-    }
-
-    template<typename MatcherLHS, typename MatcherRHS>
-    std::enable_if_t<Detail::are_generic_matchers<MatcherLHS, MatcherRHS>::value, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherRHS>>
-        operator || (MatcherLHS const& lhs, MatcherRHS const& rhs) {
-        return { lhs, rhs };
-    }
-
-    //! Wrap provided generic matcher in generic negator
-    template<typename MatcherT>
-    std::enable_if_t<Detail::is_generic_matcher<MatcherT>::value, Detail::MatchNotOfGeneric<MatcherT>>
-        operator ! (MatcherT const& matcher) {
-        return Detail::MatchNotOfGeneric<MatcherT>{matcher};
-    }
-
-
-    // compose mixed generic and non-generic matchers
-    template<typename MatcherLHS, typename ArgRHS>
-    std::enable_if_t<Detail::is_generic_matcher<MatcherLHS>::value, Detail::MatchAllOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
-        operator && (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
-        return { lhs, rhs };
-    }
-
-    template<typename ArgLHS, typename MatcherRHS>
-    std::enable_if_t<Detail::is_generic_matcher<MatcherRHS>::value, Detail::MatchAllOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
-        operator && (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
-        return { lhs, rhs };
-    }
-
-    template<typename MatcherLHS, typename ArgRHS>
-    std::enable_if_t<Detail::is_generic_matcher<MatcherLHS>::value, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
-        operator || (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
-        return { lhs, rhs };
-    }
-
-    template<typename ArgLHS, typename MatcherRHS>
-    std::enable_if_t<Detail::is_generic_matcher<MatcherRHS>::value, Detail::MatchAnyOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
-        operator || (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
-        return { lhs, rhs };
-    }
-
-} // namespace Matchers
-} // namespace Catch
-
-#endif // CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
-
-namespace Catch {
-    namespace Matchers {
-
-        class IsEmptyMatcher final : public MatcherGenericBase {
-        public:
-            template <typename RangeLike>
-            bool match(RangeLike&& rng) const {
-#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
-                using Catch::Detail::empty;
-#else
-                using std::empty;
-#endif
-                return empty(rng);
-            }
-
-            std::string describe() const override;
-        };
-
-        class HasSizeMatcher final : public MatcherGenericBase {
-            std::size_t m_target_size;
-        public:
-            explicit HasSizeMatcher(std::size_t target_size):
-                m_target_size(target_size)
-            {}
-
-            template <typename RangeLike>
-            bool match(RangeLike&& rng) const {
-#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
-                using Catch::Detail::size;
-#else
-                using std::size;
-#endif
-                return size(rng) == m_target_size;
-            }
-
-            std::string describe() const override;
-        };
-
-        template <typename Matcher>
-        class SizeMatchesMatcher final : public MatcherGenericBase {
-            Matcher m_matcher;
-        public:
-            explicit SizeMatchesMatcher(Matcher m):
-                m_matcher(CATCH_MOVE(m))
-            {}
-
-            template <typename RangeLike>
-            bool match(RangeLike&& rng) const {
-#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
-                using Catch::Detail::size;
-#else
-                using std::size;
-#endif
-                return m_matcher.match(size(rng));
-            }
-
-            std::string describe() const override {
-                return "size matches " + m_matcher.describe();
-            }
-        };
-
-
-        //! Creates a matcher that accepts empty ranges/containers
-        IsEmptyMatcher IsEmpty();
-        //! Creates a matcher that accepts ranges/containers with specific size
-        HasSizeMatcher SizeIs(std::size_t sz);
-        template <typename Matcher>
-        std::enable_if_t<Detail::is_matcher<Matcher>::value,
-        SizeMatchesMatcher<Matcher>> SizeIs(Matcher&& m) {
-            return SizeMatchesMatcher<Matcher>{CATCH_FORWARD(m)};
-        }
-
-    } // end namespace Matchers
-} // end namespace Catch
-
-#endif // CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
-
-
-#ifndef CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
-#define CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
-
-
-#include <algorithm>
-#include <functional>
-
-namespace Catch {
-    namespace Matchers {
-        //! Matcher for checking that an element in range is equal to specific element
-        template <typename T, typename Equality>
-        class ContainsElementMatcher final : public MatcherGenericBase {
-            T m_desired;
-            Equality m_eq;
-        public:
-            template <typename T2, typename Equality2>
-            ContainsElementMatcher(T2&& target, Equality2&& predicate):
-                m_desired(CATCH_FORWARD(target)),
-                m_eq(CATCH_FORWARD(predicate))
-            {}
-
-            std::string describe() const override {
-                return "contains element " + Catch::Detail::stringify(m_desired);
-            }
-
-            template <typename RangeLike>
-            bool match( RangeLike&& rng ) const {
-                for ( auto&& elem : rng ) {
-                    if ( m_eq( elem, m_desired ) ) { return true; }
-                }
-                return false;
-            }
-        };
-
-        //! Meta-matcher for checking that an element in a range matches a specific matcher
-        template <typename Matcher>
-        class ContainsMatcherMatcher final : public MatcherGenericBase {
-            Matcher m_matcher;
-        public:
-            // Note that we do a copy+move to avoid having to SFINAE this
-            // constructor (and also avoid some perfect forwarding failure
-            // cases)
-            ContainsMatcherMatcher(Matcher matcher):
-                m_matcher(CATCH_MOVE(matcher))
-            {}
-
-            template <typename RangeLike>
-            bool match(RangeLike&& rng) const {
-                for (auto&& elem : rng) {
-                    if (m_matcher.match(elem)) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-
-            std::string describe() const override {
-                return "contains element matching " + m_matcher.describe();
-            }
-        };
-
-        /**
-         * Creates a matcher that checks whether a range contains a specific element.
-         *
-         * Uses `std::equal_to` to do the comparison
-         */
-        template <typename T>
-        std::enable_if_t<!Detail::is_matcher<T>::value,
-        ContainsElementMatcher<T, std::equal_to<>>> Contains(T&& elem) {
-            return { CATCH_FORWARD(elem), std::equal_to<>{} };
-        }
-
-        //! Creates a matcher that checks whether a range contains element matching a matcher
-        template <typename Matcher>
-        std::enable_if_t<Detail::is_matcher<Matcher>::value,
-        ContainsMatcherMatcher<Matcher>> Contains(Matcher&& matcher) {
-            return { CATCH_FORWARD(matcher) };
-        }
-
-        /**
-         * Creates a matcher that checks whether a range contains a specific element.
-         *
-         * Uses `eq` to do the comparisons, the element is provided on the rhs
-         */
-        template <typename T, typename Equality>
-        ContainsElementMatcher<T, Equality> Contains(T&& elem, Equality&& eq) {
-            return { CATCH_FORWARD(elem), CATCH_FORWARD(eq) };
-        }
-
-    }
-}
-
-#endif // CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
-
-
-#ifndef CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
-#define CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
-
-
-namespace Catch {
-namespace Matchers {
-
-class ExceptionMessageMatcher final : public MatcherBase<std::exception> {
-    std::string m_message;
-public:
-
-    ExceptionMessageMatcher(std::string const& message):
-        m_message(message)
-    {}
-
-    bool match(std::exception const& ex) const override;
-
-    std::string describe() const override;
-};
-
-//! Creates a matcher that checks whether a std derived exception has the provided message
-ExceptionMessageMatcher Message(std::string const& message);
-
-template <typename StringMatcherType>
-class ExceptionMessageMatchesMatcher final
-    : public MatcherBase<std::exception> {
-    StringMatcherType m_matcher;
-
-public:
-    ExceptionMessageMatchesMatcher( StringMatcherType matcher ):
-        m_matcher( CATCH_MOVE( matcher ) ) {}
-
-    bool match( std::exception const& ex ) const override {
-        return m_matcher.match( ex.what() );
-    }
-
-    std::string describe() const override {
-        return " matches \"" + m_matcher.describe() + '"';
-    }
-};
-
-//! Creates a matcher that checks whether a message from an std derived
-//! exception matches a provided matcher
-template <typename StringMatcherType>
-ExceptionMessageMatchesMatcher<StringMatcherType>
-MessageMatches( StringMatcherType&& matcher ) {
-    return { CATCH_FORWARD( matcher ) };
-}
-
-} // namespace Matchers
-} // namespace Catch
-
-#endif // CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
-
-
-#ifndef CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
-#define CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
-
-
-namespace Catch {
-namespace Matchers {
-
-    namespace Detail {
-        enum class FloatingPointKind : uint8_t;
-    }
-
-    class  WithinAbsMatcher final : public MatcherBase<double> {
-    public:
-        WithinAbsMatcher(double target, double margin);
-        bool match(double const& matchee) const override;
-        std::string describe() const override;
-    private:
-        double m_target;
-        double m_margin;
-    };
-
-    //! Creates a matcher that accepts numbers within certain range of target
-    WithinAbsMatcher WithinAbs( double target, double margin );
-
-
-
-    class WithinUlpsMatcher final : public MatcherBase<double> {
-    public:
-        WithinUlpsMatcher( double target,
-                           uint64_t ulps,
-                           Detail::FloatingPointKind baseType );
-        bool match(double const& matchee) const override;
-        std::string describe() const override;
-    private:
-        double m_target;
-        uint64_t m_ulps;
-        Detail::FloatingPointKind m_type;
-    };
-
-    //! Creates a matcher that accepts doubles within certain ULP range of target
-    WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
-    //! Creates a matcher that accepts floats within certain ULP range of target
-    WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
-
-
-
-    // Given IEEE-754 format for floats and doubles, we can assume
-    // that float -> double promotion is lossless. Given this, we can
-    // assume that if we do the standard relative comparison of
-    // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
-    // the same result if we do this for floats, as if we do this for
-    // doubles that were promoted from floats.
-    class WithinRelMatcher final : public MatcherBase<double> {
-    public:
-        WithinRelMatcher( double target, double epsilon );
-        bool match(double const& matchee) const override;
-        std::string describe() const override;
-    private:
-        double m_target;
-        double m_epsilon;
-    };
-
-    //! Creates a matcher that accepts doubles within certain relative range of target
-    WithinRelMatcher WithinRel(double target, double eps);
-    //! Creates a matcher that accepts doubles within 100*DBL_EPS relative range of target
-    WithinRelMatcher WithinRel(double target);
-    //! Creates a matcher that accepts doubles within certain relative range of target
-    WithinRelMatcher WithinRel(float target, float eps);
-    //! Creates a matcher that accepts floats within 100*FLT_EPS relative range of target
-    WithinRelMatcher WithinRel(float target);
-
-
-
-    class IsNaNMatcher final : public MatcherBase<double> {
-    public:
-        IsNaNMatcher() = default;
-        bool match( double const& matchee ) const override;
-        std::string describe() const override;
-    };
-
-    IsNaNMatcher IsNaN();
-
-} // namespace Matchers
-} // namespace Catch
-
-#endif // CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
-
-
-#ifndef CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
-#define CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
-
-
-#include <string>
-
-namespace Catch {
-namespace Matchers {
-
-namespace Detail {
-    std::string finalizeDescription(const std::string& desc);
-} // namespace Detail
-
-template <typename T, typename Predicate>
-class PredicateMatcher final : public MatcherBase<T> {
-    Predicate m_predicate;
-    std::string m_description;
-public:
-
-    PredicateMatcher(Predicate&& elem, std::string const& descr)
-        :m_predicate(CATCH_FORWARD(elem)),
-        m_description(Detail::finalizeDescription(descr))
-    {}
-
-    bool match( T const& item ) const override {
-        return m_predicate(item);
-    }
-
-    std::string describe() const override {
-        return m_description;
-    }
-};
-
-    /**
-     * Creates a matcher that calls delegates `match` to the provided predicate.
-     *
-     * The user has to explicitly specify the argument type to the matcher
-     */
-    template<typename T, typename Pred>
-    PredicateMatcher<T, Pred> Predicate(Pred&& predicate, std::string const& description = "") {
-        static_assert(is_callable<Pred(T)>::value, "Predicate not callable with argument T");
-        static_assert(std::is_same<bool, FunctionReturnType<Pred, T>>::value, "Predicate does not return bool");
-        return PredicateMatcher<T, Pred>(CATCH_FORWARD(predicate), description);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-
-#endif // CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
-
-
-#ifndef CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
-#define CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
-
-
-namespace Catch {
-    namespace Matchers {
-        // Matcher for checking that all elements in range matches a given matcher.
-        template <typename Matcher>
-        class AllMatchMatcher final : public MatcherGenericBase {
-            Matcher m_matcher;
-        public:
-            AllMatchMatcher(Matcher matcher):
-                m_matcher(CATCH_MOVE(matcher))
-            {}
-
-            std::string describe() const override {
-                return "all match " + m_matcher.describe();
-            }
-
-            template <typename RangeLike>
-            bool match(RangeLike&& rng) const {
-                for (auto&& elem : rng) {
-                    if (!m_matcher.match(elem)) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-        };
-
-        // Matcher for checking that no element in range matches a given matcher.
-        template <typename Matcher>
-        class NoneMatchMatcher final : public MatcherGenericBase {
-            Matcher m_matcher;
-        public:
-            NoneMatchMatcher(Matcher matcher):
-                m_matcher(CATCH_MOVE(matcher))
-            {}
-
-            std::string describe() const override {
-                return "none match " + m_matcher.describe();
-            }
-
-            template <typename RangeLike>
-            bool match(RangeLike&& rng) const {
-                for (auto&& elem : rng) {
-                    if (m_matcher.match(elem)) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-        };
-
-        // Matcher for checking that at least one element in range matches a given matcher.
-        template <typename Matcher>
-        class AnyMatchMatcher final : public MatcherGenericBase {
-            Matcher m_matcher;
-        public:
-            AnyMatchMatcher(Matcher matcher):
-                m_matcher(CATCH_MOVE(matcher))
-            {}
-
-            std::string describe() const override {
-                return "any match " + m_matcher.describe();
-            }
-
-            template <typename RangeLike>
-            bool match(RangeLike&& rng) const {
-                for (auto&& elem : rng) {
-                    if (m_matcher.match(elem)) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-        };
-
-        // Matcher for checking that all elements in range are true.
-        class AllTrueMatcher final : public MatcherGenericBase {
-        public:
-            std::string describe() const override;
-
-            template <typename RangeLike>
-            bool match(RangeLike&& rng) const {
-                for (auto&& elem : rng) {
-                    if (!elem) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-        };
-
-        // Matcher for checking that no element in range is true.
-        class NoneTrueMatcher final : public MatcherGenericBase {
-        public:
-            std::string describe() const override;
-
-            template <typename RangeLike>
-            bool match(RangeLike&& rng) const {
-                for (auto&& elem : rng) {
-                    if (elem) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-        };
-
-        // Matcher for checking that any element in range is true.
-        class AnyTrueMatcher final : public MatcherGenericBase {
-        public:
-            std::string describe() const override;
-
-            template <typename RangeLike>
-            bool match(RangeLike&& rng) const {
-                for (auto&& elem : rng) {
-                    if (elem) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-        };
-
-        // Creates a matcher that checks whether all elements in a range match a matcher
-        template <typename Matcher>
-        AllMatchMatcher<Matcher> AllMatch(Matcher&& matcher) {
-            return { CATCH_FORWARD(matcher) };
-        }
-
-        // Creates a matcher that checks whether no element in a range matches a matcher.
-        template <typename Matcher>
-        NoneMatchMatcher<Matcher> NoneMatch(Matcher&& matcher) {
-            return { CATCH_FORWARD(matcher) };
-        }
-
-        // Creates a matcher that checks whether any element in a range matches a matcher.
-        template <typename Matcher>
-        AnyMatchMatcher<Matcher> AnyMatch(Matcher&& matcher) {
-            return { CATCH_FORWARD(matcher) };
-        }
-
-        // Creates a matcher that checks whether all elements in a range are true
-        AllTrueMatcher AllTrue();
-
-        // Creates a matcher that checks whether no element in a range is true
-        NoneTrueMatcher NoneTrue();
-
-        // Creates a matcher that checks whether any element in a range is true
-        AnyTrueMatcher AnyTrue();
-    }
-}
-
-#endif // CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
-
-
-#ifndef CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
-#define CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
-
-
-#include <algorithm>
-#include <utility>
-
-namespace Catch {
-    namespace Matchers {
-
-        /**
-         * Matcher for checking that an element contains the same
-         * elements in the same order
-         */
-        template <typename TargetRangeLike, typename Equality>
-        class RangeEqualsMatcher final : public MatcherGenericBase {
-            TargetRangeLike m_desired;
-            Equality m_predicate;
-
-        public:
-            template <typename TargetRangeLike2, typename Equality2>
-            constexpr
-            RangeEqualsMatcher( TargetRangeLike2&& range,
-                                Equality2&& predicate ):
-                m_desired( CATCH_FORWARD( range ) ),
-                m_predicate( CATCH_FORWARD( predicate ) ) {}
-
-            template <typename RangeLike>
-            constexpr
-            bool match( RangeLike&& rng ) const {
-                auto rng_start = begin( rng );
-                const auto rng_end = end( rng );
-                auto target_start = begin( m_desired );
-                const auto target_end = end( m_desired );
-
-                while (rng_start != rng_end && target_start != target_end) {
-                    if (!m_predicate(*rng_start, *target_start)) {
-                        return false;
-                    }
-                    ++rng_start;
-                    ++target_start;
-                }
-                return rng_start == rng_end && target_start == target_end;
-            }
-
-            std::string describe() const override {
-                return "elements are " + Catch::Detail::stringify( m_desired );
-            }
-        };
-
-        /**
-         * Matcher for checking that an element contains the same
-         * elements (but not necessarily in the same order)
-         */
-        template <typename TargetRangeLike, typename Equality>
-        class UnorderedRangeEqualsMatcher final : public MatcherGenericBase {
-            TargetRangeLike m_desired;
-            Equality m_predicate;
-
-        public:
-            template <typename TargetRangeLike2, typename Equality2>
-            constexpr
-            UnorderedRangeEqualsMatcher( TargetRangeLike2&& range,
-                                         Equality2&& predicate ):
-                m_desired( CATCH_FORWARD( range ) ),
-                m_predicate( CATCH_FORWARD( predicate ) ) {}
-
-            template <typename RangeLike>
-            constexpr
-            bool match( RangeLike&& rng ) const {
-                using std::begin;
-                using std::end;
-                return Catch::Detail::is_permutation( begin( m_desired ),
-                                                      end( m_desired ),
-                                                      begin( rng ),
-                                                      end( rng ),
-                                                      m_predicate );
-            }
-
-            std::string describe() const override {
-                return "unordered elements are " +
-                       ::Catch::Detail::stringify( m_desired );
-            }
-        };
-
-        /**
-         * Creates a matcher that checks if all elements in a range are equal
-         * to all elements in another range.
-         *
-         * Uses `std::equal_to` to do the comparison
-         */
-        template <typename RangeLike>
-        constexpr
-        std::enable_if_t<!Detail::is_matcher<RangeLike>::value,
-                         RangeEqualsMatcher<RangeLike, std::equal_to<>>>
-        RangeEquals( RangeLike&& range ) {
-            return { CATCH_FORWARD( range ), std::equal_to<>{} };
-        }
-
-        /**
-         * Creates a matcher that checks if all elements in a range are equal
-         * to all elements in another range.
-         *
-         * Uses to provided predicate `predicate` to do the comparisons
-         */
-        template <typename RangeLike, typename Equality>
-        constexpr
-        RangeEqualsMatcher<RangeLike, Equality>
-        RangeEquals( RangeLike&& range, Equality&& predicate ) {
-            return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
-        }
-
-        /**
-         * Creates a matcher that checks if all elements in a range are equal
-         * to all elements in another range, in some permutation
-         *
-         * Uses `std::equal_to` to do the comparison
-         */
-        template <typename RangeLike>
-        constexpr
-        std::enable_if_t<
-            !Detail::is_matcher<RangeLike>::value,
-            UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
-        UnorderedRangeEquals( RangeLike&& range ) {
-            return { CATCH_FORWARD( range ), std::equal_to<>{} };
-        }
-
-        /**
-         * Creates a matcher that checks if all elements in a range are equal
-         * to all elements in another range, in some permutation.
-         *
-         * Uses to provided predicate `predicate` to do the comparisons
-         */
-        template <typename RangeLike, typename Equality>
-        constexpr
-        UnorderedRangeEqualsMatcher<RangeLike, Equality>
-        UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
-            return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
-        }
-    } // namespace Matchers
-} // namespace Catch
-
-#endif // CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
-
-
-#ifndef CATCH_MATCHERS_STRING_HPP_INCLUDED
-#define CATCH_MATCHERS_STRING_HPP_INCLUDED
-
-
-#include <string>
-
-namespace Catch {
-namespace Matchers {
-
-    struct CasedString {
-        CasedString( std::string const& str, CaseSensitive caseSensitivity );
-        std::string adjustString( std::string const& str ) const;
-        StringRef caseSensitivitySuffix() const;
-
-        CaseSensitive m_caseSensitivity;
-        std::string m_str;
-    };
-
-    class StringMatcherBase : public MatcherBase<std::string> {
-    protected:
-        CasedString m_comparator;
-        StringRef m_operation;
-
-    public:
-        StringMatcherBase( StringRef operation,
-                           CasedString const& comparator );
-        std::string describe() const override;
-    };
-
-    class StringEqualsMatcher final : public StringMatcherBase {
-    public:
-        StringEqualsMatcher( CasedString const& comparator );
-        bool match( std::string const& source ) const override;
-    };
-    class StringContainsMatcher final : public StringMatcherBase {
-    public:
-        StringContainsMatcher( CasedString const& comparator );
-        bool match( std::string const& source ) const override;
-    };
-    class StartsWithMatcher final : public StringMatcherBase {
-    public:
-        StartsWithMatcher( CasedString const& comparator );
-        bool match( std::string const& source ) const override;
-    };
-    class EndsWithMatcher final : public StringMatcherBase {
-    public:
-        EndsWithMatcher( CasedString const& comparator );
-        bool match( std::string const& source ) const override;
-    };
-
-    class RegexMatcher final : public MatcherBase<std::string> {
-        std::string m_regex;
-        CaseSensitive m_caseSensitivity;
-
-    public:
-        RegexMatcher( std::string regex, CaseSensitive caseSensitivity );
-        bool match( std::string const& matchee ) const override;
-        std::string describe() const override;
-    };
-
-    //! Creates matcher that accepts strings that are exactly equal to `str`
-    StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
-    //! Creates matcher that accepts strings that contain `str`
-    StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
-    //! Creates matcher that accepts strings that _end_ with `str`
-    EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
-    //! Creates matcher that accepts strings that _start_ with `str`
-    StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
-    //! Creates matcher that accepts strings matching `regex`
-    RegexMatcher Matches( std::string const& regex, CaseSensitive caseSensitivity = CaseSensitive::Yes );
-
-} // namespace Matchers
-} // namespace Catch
-
-#endif // CATCH_MATCHERS_STRING_HPP_INCLUDED
-
-
-#ifndef CATCH_MATCHERS_VECTOR_HPP_INCLUDED
-#define CATCH_MATCHERS_VECTOR_HPP_INCLUDED
-
-
-#include <algorithm>
-
-namespace Catch {
-namespace Matchers {
-
-    template<typename T, typename Alloc>
-    class VectorContainsElementMatcher final : public MatcherBase<std::vector<T, Alloc>> {
-        T const& m_comparator;
-
-    public:
-        VectorContainsElementMatcher(T const& comparator):
-            m_comparator(comparator)
-        {}
-
-        bool match(std::vector<T, Alloc> const& v) const override {
-            for (auto const& el : v) {
-                if (el == m_comparator) {
-                    return true;
-                }
-            }
-            return false;
-        }
-
-        std::string describe() const override {
-            return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-        }
-    };
-
-    template<typename T, typename AllocComp, typename AllocMatch>
-    class ContainsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
-        std::vector<T, AllocComp> const& m_comparator;
-
-    public:
-        ContainsMatcher(std::vector<T, AllocComp> const& comparator):
-            m_comparator( comparator )
-        {}
-
-        bool match(std::vector<T, AllocMatch> const& v) const override {
-            // !TBD: see note in EqualsMatcher
-            if (m_comparator.size() > v.size())
-                return false;
-            for (auto const& comparator : m_comparator) {
-                auto present = false;
-                for (const auto& el : v) {
-                    if (el == comparator) {
-                        present = true;
-                        break;
-                    }
-                }
-                if (!present) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        std::string describe() const override {
-            return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-        }
-    };
-
-    template<typename T, typename AllocComp, typename AllocMatch>
-    class EqualsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
-        std::vector<T, AllocComp> const& m_comparator;
-
-    public:
-        EqualsMatcher(std::vector<T, AllocComp> const& comparator):
-            m_comparator( comparator )
-        {}
-
-        bool match(std::vector<T, AllocMatch> const& v) const override {
-            // !TBD: This currently works if all elements can be compared using !=
-            // - a more general approach would be via a compare template that defaults
-            // to using !=. but could be specialised for, e.g. std::vector<T> etc
-            // - then just call that directly
-            if ( m_comparator.size() != v.size() ) { return false; }
-            for ( std::size_t i = 0; i < v.size(); ++i ) {
-                if ( !( m_comparator[i] == v[i] ) ) { return false; }
-            }
-            return true;
-        }
-        std::string describe() const override {
-            return "Equals: " + ::Catch::Detail::stringify( m_comparator );
-        }
-    };
-
-    template<typename T, typename AllocComp, typename AllocMatch>
-    class ApproxMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
-        std::vector<T, AllocComp> const& m_comparator;
-        mutable Catch::Approx approx = Catch::Approx::custom();
-
-    public:
-        ApproxMatcher(std::vector<T, AllocComp> const& comparator):
-            m_comparator( comparator )
-        {}
-
-        bool match(std::vector<T, AllocMatch> const& v) const override {
-            if (m_comparator.size() != v.size())
-                return false;
-            for (std::size_t i = 0; i < v.size(); ++i)
-                if (m_comparator[i] != approx(v[i]))
-                    return false;
-            return true;
-        }
-        std::string describe() const override {
-            return "is approx: " + ::Catch::Detail::stringify( m_comparator );
-        }
-        template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        ApproxMatcher& epsilon( T const& newEpsilon ) {
-            approx.epsilon(static_cast<double>(newEpsilon));
-            return *this;
-        }
-        template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        ApproxMatcher& margin( T const& newMargin ) {
-            approx.margin(static_cast<double>(newMargin));
-            return *this;
-        }
-        template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        ApproxMatcher& scale( T const& newScale ) {
-            approx.scale(static_cast<double>(newScale));
-            return *this;
-        }
-    };
-
-    template<typename T, typename AllocComp, typename AllocMatch>
-    class UnorderedEqualsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
-        std::vector<T, AllocComp> const& m_target;
-
-    public:
-        UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target):
-            m_target(target)
-        {}
-        bool match(std::vector<T, AllocMatch> const& vec) const override {
-            if (m_target.size() != vec.size()) {
-                return false;
-            }
-            return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
-        }
-
-        std::string describe() const override {
-            return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
-        }
-    };
-
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-
-    //! Creates a matcher that matches vectors that contain all elements in `comparator`
-    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
-    ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vector<T, AllocComp> const& comparator ) {
-        return ContainsMatcher<T, AllocComp, AllocMatch>(comparator);
-    }
-
-    //! Creates a matcher that matches vectors that contain `comparator` as an element
-    template<typename T, typename Alloc = std::allocator<T>>
-    VectorContainsElementMatcher<T, Alloc> VectorContains( T const& comparator ) {
-        return VectorContainsElementMatcher<T, Alloc>(comparator);
-    }
-
-    //! Creates a matcher that matches vectors that are exactly equal to `comparator`
-    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
-    EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<T, AllocComp> const& comparator ) {
-        return EqualsMatcher<T, AllocComp, AllocMatch>(comparator);
-    }
-
-    //! Creates a matcher that matches vectors that `comparator` as an element
-    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
-    ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<T, AllocComp> const& comparator ) {
-        return ApproxMatcher<T, AllocComp, AllocMatch>(comparator);
-    }
-
-    //! Creates a matcher that matches vectors that is equal to `target` modulo permutation
-    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
-    UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEquals(std::vector<T, AllocComp> const& target) {
-        return UnorderedEqualsMatcher<T, AllocComp, AllocMatch>(target);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-
-#endif // CATCH_MATCHERS_VECTOR_HPP_INCLUDED
-
-#endif // CATCH_MATCHERS_ALL_HPP_INCLUDED
-
-
-/** \file
- * This is a convenience header for Catch2's Reporter support. It includes
- * **all** of Catch2 headers related to reporters, including all reporters.
- *
- * Generally the Catch2 users should use specific includes they need,
- * but this header can be used instead for ease-of-experimentation, or
- * just plain convenience, at the cost of (significantly) increased
- * compilation times.
- *
- * When a new header (reporter) is added to either the `reporter` folder,
- * or to the corresponding internal subfolder, it should be added here.
- */
-
-#ifndef CATCH_REPORTERS_ALL_HPP_INCLUDED
-#define CATCH_REPORTERS_ALL_HPP_INCLUDED
-
-
-
-#ifndef CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
-#define CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
-
-
-
-#ifndef CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
-#define CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
-
-
-
-#ifndef CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
-#define CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
-
-
-#include <map>
-#include <string>
-
-namespace Catch {
-    class ColourImpl;
-
-    /**
-     * This is the base class for all reporters.
-     *
-     * If are writing a reporter, you must derive from this type, or one
-     * of the helper reporter bases that are derived from this type.
-     *
-     * ReporterBase centralizes handling of various common tasks in reporters,
-     * like storing the right stream for the reporters to write to, and
-     * providing the default implementation of the different listing events.
-     */
-    class ReporterBase : public IEventListener {
-    protected:
-        //! The stream wrapper as passed to us by outside code
-        Detail::unique_ptr<IStream> m_wrapped_stream;
-        //! Cached output stream from `m_wrapped_stream` to reduce
-        //! number of indirect calls needed to write output.
-        std::ostream& m_stream;
-        //! Colour implementation this reporter was configured for
-        Detail::unique_ptr<ColourImpl> m_colour;
-        //! The custom reporter options user passed down to the reporter
-        std::map<std::string, std::string> m_customOptions;
-
-    public:
-        ReporterBase( ReporterConfig&& config );
-        ~ReporterBase() override; // = default;
-
-        /**
-         * Provides a simple default listing of reporters.
-         *
-         * Should look roughly like the reporter listing in v2 and earlier
-         * versions of Catch2.
-         */
-        void listReporters(
-            std::vector<ReporterDescription> const& descriptions ) override;
-        /**
-         * Provides a simple default listing of listeners
-         *
-         * Looks similarly to listing of reporters, but with listener type
-         * instead of reporter name.
-         */
-        void listListeners(
-            std::vector<ListenerDescription> const& descriptions ) override;
-        /**
-         * Provides a simple default listing of tests.
-         *
-         * Should look roughly like the test listing in v2 and earlier versions
-         * of Catch2. Especially supports low-verbosity listing that mimics the
-         * old `--list-test-names-only` output.
-         */
-        void listTests( std::vector<TestCaseHandle> const& tests ) override;
-        /**
-         * Provides a simple default listing of tags.
-         *
-         * Should look roughly like the tag listing in v2 and earlier versions
-         * of Catch2.
-         */
-        void listTags( std::vector<TagInfo> const& tags ) override;
-    };
-} // namespace Catch
-
-#endif // CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
-
-#include <vector>
-
-namespace Catch {
-
-    class StreamingReporterBase : public ReporterBase {
-    public:
-        // GCC5 compat: we cannot use inherited constructor, because it
-        //              doesn't implement backport of P0136
-        StreamingReporterBase(ReporterConfig&& _config):
-            ReporterBase(CATCH_MOVE(_config))
-        {}
-        ~StreamingReporterBase() override;
-
-        void benchmarkPreparing( StringRef ) override {}
-        void benchmarkStarting( BenchmarkInfo const& ) override {}
-        void benchmarkEnded( BenchmarkStats<> const& ) override {}
-        void benchmarkFailed( StringRef ) override {}
-
-        void fatalErrorEncountered( StringRef /*error*/ ) override {}
-        void noMatchingTestCases( StringRef /*unmatchedSpec*/ ) override {}
-        void reportInvalidTestSpec( StringRef /*invalidArgument*/ ) override {}
-
-        void testRunStarting( TestRunInfo const& _testRunInfo ) override;
-
-        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
-            currentTestCaseInfo = &_testInfo;
-        }
-        void testCasePartialStarting( TestCaseInfo const&, uint64_t ) override {}
-        void sectionStarting(SectionInfo const& _sectionInfo) override {
-            m_sectionStack.push_back(_sectionInfo);
-        }
-
-        void assertionStarting( AssertionInfo const& ) override {}
-        void assertionEnded( AssertionStats const& ) override {}
-
-        void sectionEnded(SectionStats const& /* _sectionStats */) override {
-            m_sectionStack.pop_back();
-        }
-        void testCasePartialEnded( TestCaseStats const&, uint64_t ) override {}
-        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
-            currentTestCaseInfo = nullptr;
-        }
-        void testRunEnded( TestRunStats const& /* _testRunStats */ ) override;
-
-        void skipTest(TestCaseInfo const&) override {
-            // Don't do anything with this by default.
-            // It can optionally be overridden in the derived class.
-        }
-
-    protected:
-        TestRunInfo currentTestRunInfo{ "test run has not started yet"_sr };
-        TestCaseInfo const* currentTestCaseInfo = nullptr;
-
-        //! Stack of all _active_ sections in the _current_ test case
-        std::vector<SectionInfo> m_sectionStack;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    class AutomakeReporter final : public StreamingReporterBase {
-    public:
-        // GCC5 compat: we cannot use inherited constructor, because it
-        //              doesn't implement backport of P0136
-        AutomakeReporter(ReporterConfig&& _config):
-            StreamingReporterBase(CATCH_MOVE(_config))
-        {}
-        ~AutomakeReporter() override;
-
-        static std::string getDescription() {
-            using namespace std::string_literals;
-            return "Reports test results in the format of Automake .trs files"s;
-        }
-
-        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
-        void skipTest(TestCaseInfo const& testInfo) override;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
-
-
-#ifndef CATCH_REPORTER_COMPACT_HPP_INCLUDED
-#define CATCH_REPORTER_COMPACT_HPP_INCLUDED
-
-
-
-
-namespace Catch {
-
-    class CompactReporter final : public StreamingReporterBase {
-    public:
-        using StreamingReporterBase::StreamingReporterBase;
-
-        ~CompactReporter() override;
-
-        static std::string getDescription();
-
-        void noMatchingTestCases( StringRef unmatchedSpec ) override;
-
-        void testRunStarting( TestRunInfo const& _testInfo ) override;
-
-        void assertionEnded(AssertionStats const& _assertionStats) override;
-
-        void sectionEnded(SectionStats const& _sectionStats) override;
-
-        void testRunEnded(TestRunStats const& _testRunStats) override;
-
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_COMPACT_HPP_INCLUDED
-
-
-#ifndef CATCH_REPORTER_CONSOLE_HPP_INCLUDED
-#define CATCH_REPORTER_CONSOLE_HPP_INCLUDED
-
-
-namespace Catch {
-    // Fwd decls
-    class TablePrinter;
-
-    class ConsoleReporter final : public StreamingReporterBase {
-        Detail::unique_ptr<TablePrinter> m_tablePrinter;
-
-    public:
-        ConsoleReporter(ReporterConfig&& config);
-        ~ConsoleReporter() override;
-        static std::string getDescription();
-
-        void noMatchingTestCases( StringRef unmatchedSpec ) override;
-        void reportInvalidTestSpec( StringRef arg ) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        void assertionEnded(AssertionStats const& _assertionStats) override;
-
-        void sectionStarting(SectionInfo const& _sectionInfo) override;
-        void sectionEnded(SectionStats const& _sectionStats) override;
-
-        void benchmarkPreparing( StringRef name ) override;
-        void benchmarkStarting(BenchmarkInfo const& info) override;
-        void benchmarkEnded(BenchmarkStats<> const& stats) override;
-        void benchmarkFailed( StringRef error ) override;
-
-        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
-        void testRunEnded(TestRunStats const& _testRunStats) override;
-        void testRunStarting(TestRunInfo const& _testRunInfo) override;
-
-    private:
-        void lazyPrint();
-
-        void lazyPrintWithoutClosingBenchmarkTable();
-        void lazyPrintRunInfo();
-        void printTestCaseAndSectionHeader();
-
-        void printClosedHeader(std::string const& _name);
-        void printOpenHeader(std::string const& _name);
-
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        void printHeaderString(std::string const& _string, std::size_t indent = 0);
-
-        void printTotalsDivider(Totals const& totals);
-
-        bool m_headerPrinted = false;
-        bool m_testRunInfoPrinted = false;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_CONSOLE_HPP_INCLUDED
-
-
-#ifndef CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
-#define CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
-
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    namespace Detail {
-
-        //! Represents either an assertion or a benchmark result to be handled by cumulative reporter later
-        class AssertionOrBenchmarkResult {
-            // This should really be a variant, but this is much faster
-            // to write and the data layout here is already terrible
-            // enough that we do not have to care about the object size.
-            Optional<AssertionStats> m_assertion;
-            Optional<BenchmarkStats<>> m_benchmark;
-        public:
-            AssertionOrBenchmarkResult(AssertionStats const& assertion);
-            AssertionOrBenchmarkResult(BenchmarkStats<> const& benchmark);
-
-            bool isAssertion() const;
-            bool isBenchmark() const;
-
-            AssertionStats const& asAssertion() const;
-            BenchmarkStats<> const& asBenchmark() const;
-        };
-    }
-
-    /**
-     * Utility base for reporters that need to handle all results at once
-     *
-     * It stores tree of all test cases, sections and assertions, and after the
-     * test run is finished, calls into `testRunEndedCumulative` to pass the
-     * control to the deriving class.
-     *
-     * If you are deriving from this class and override any testing related
-     * member functions, you should first call into the base's implementation to
-     * avoid breaking the tree construction.
-     *
-     * Due to the way this base functions, it has to expand assertions up-front,
-     * even if they are later unused (e.g. because the deriving reporter does
-     * not report successful assertions, or because the deriving reporter does
-     * not use assertion expansion at all). Derived classes can use two
-     * customization points, `m_shouldStoreSuccesfulAssertions` and
-     * `m_shouldStoreFailedAssertions`, to disable the expansion and gain extra
-     * performance. **Accessing the assertion expansions if it wasn't stored is
-     * UB.**
-     */
-    class CumulativeReporterBase : public ReporterBase {
-    public:
-        template<typename T, typename ChildNodeT>
-        struct Node {
-            explicit Node( T const& _value ) : value( _value ) {}
-
-            using ChildNodes = std::vector<Detail::unique_ptr<ChildNodeT>>;
-            T value;
-            ChildNodes children;
-        };
-        struct SectionNode {
-            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
-
-            bool operator == (SectionNode const& other) const {
-                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
-            }
-
-            bool hasAnyAssertions() const;
-
-            SectionStats stats;
-            std::vector<Detail::unique_ptr<SectionNode>> childSections;
-            std::vector<Detail::AssertionOrBenchmarkResult> assertionsAndBenchmarks;
-            std::string stdOut;
-            std::string stdErr;
-        };
-
-
-        using TestCaseNode = Node<TestCaseStats, SectionNode>;
-        using TestRunNode = Node<TestRunStats, TestCaseNode>;
-
-        // GCC5 compat: we cannot use inherited constructor, because it
-        //              doesn't implement backport of P0136
-        CumulativeReporterBase(ReporterConfig&& _config):
-            ReporterBase(CATCH_MOVE(_config))
-        {}
-        ~CumulativeReporterBase() override;
-
-        void benchmarkPreparing( StringRef ) override {}
-        void benchmarkStarting( BenchmarkInfo const& ) override {}
-        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
-        void benchmarkFailed( StringRef ) override {}
-
-        void noMatchingTestCases( StringRef ) override {}
-        void reportInvalidTestSpec( StringRef ) override {}
-        void fatalErrorEncountered( StringRef /*error*/ ) override {}
-
-        void testRunStarting( TestRunInfo const& ) override {}
-
-        void testCaseStarting( TestCaseInfo const& ) override {}
-        void testCasePartialStarting( TestCaseInfo const&, uint64_t ) override {}
-        void sectionStarting( SectionInfo const& sectionInfo ) override;
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        void assertionEnded( AssertionStats const& assertionStats ) override;
-        void sectionEnded( SectionStats const& sectionStats ) override;
-        void testCasePartialEnded( TestCaseStats const&, uint64_t ) override {}
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
-        void testRunEnded( TestRunStats const& testRunStats ) override;
-        //! Customization point: called after last test finishes (testRunEnded has been handled)
-        virtual void testRunEndedCumulative() = 0;
-
-        void skipTest(TestCaseInfo const&) override {}
-
-    protected:
-        //! Should the cumulative base store the assertion expansion for successful assertions?
-        bool m_shouldStoreSuccesfulAssertions = true;
-        //! Should the cumulative base store the assertion expansion for failed assertions?
-        bool m_shouldStoreFailedAssertions = true;
-
-        // We need lazy construction here. We should probably refactor it
-        // later, after the events are redone.
-        //! The root node of the test run tree.
-        Detail::unique_ptr<TestRunNode> m_testRun;
-
-    private:
-        // Note: We rely on pointer identity being stable, which is why
-        //       we store pointers to the nodes rather than the values.
-        std::vector<Detail::unique_ptr<TestCaseNode>> m_testCases;
-        // Root section of the _current_ test case
-        Detail::unique_ptr<SectionNode> m_rootSection;
-        // Deepest section of the _current_ test case
-        SectionNode* m_deepestSection = nullptr;
-        // Stack of _active_ sections in the _current_ test case
-        std::vector<SectionNode*> m_sectionStack;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
-
-
-#ifndef CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
-#define CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
-
-
-namespace Catch {
-
-    /**
-     * Base class to simplify implementing listeners.
-     *
-     * Provides empty default implementation for all IEventListener member
-     * functions, so that a listener implementation can pick which
-     * member functions it actually cares about.
-     */
-    class EventListenerBase : public IEventListener {
-    public:
-        using IEventListener::IEventListener;
-
-        void reportInvalidTestSpec( StringRef unmatchedSpec ) override;
-        void fatalErrorEncountered( StringRef error ) override;
-
-        void benchmarkPreparing( StringRef name ) override;
-        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
-        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
-        void benchmarkFailed( StringRef error ) override;
-
-        void assertionStarting( AssertionInfo const& assertionInfo ) override;
-        void assertionEnded( AssertionStats const& assertionStats ) override;
-
-        void listReporters(
-            std::vector<ReporterDescription> const& descriptions ) override;
-        void listListeners(
-            std::vector<ListenerDescription> const& descriptions ) override;
-        void listTests( std::vector<TestCaseHandle> const& tests ) override;
-        void listTags( std::vector<TagInfo> const& tagInfos ) override;
-
-        void noMatchingTestCases( StringRef unmatchedSpec ) override;
-        void testRunStarting( TestRunInfo const& testRunInfo ) override;
-        void testCaseStarting( TestCaseInfo const& testInfo ) override;
-        void testCasePartialStarting( TestCaseInfo const& testInfo,
-                                      uint64_t partNumber ) override;
-        void sectionStarting( SectionInfo const& sectionInfo ) override;
-        void sectionEnded( SectionStats const& sectionStats ) override;
-        void testCasePartialEnded( TestCaseStats const& testCaseStats,
-                                   uint64_t partNumber ) override;
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
-        void testRunEnded( TestRunStats const& testRunStats ) override;
-        void skipTest( TestCaseInfo const& testInfo ) override;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
-
-
-#ifndef CATCH_REPORTER_HELPERS_HPP_INCLUDED
-#define CATCH_REPORTER_HELPERS_HPP_INCLUDED
-
-#include <iosfwd>
-#include <string>
-#include <vector>
-
-
-namespace Catch {
-
-    class IConfig;
-    class TestCaseHandle;
-    class ColourImpl;
-
-    // Returns double formatted as %.3f (format expected on output)
-    std::string getFormattedDuration( double duration );
-
-    //! Should the reporter show duration of test given current configuration?
-    bool shouldShowDuration( IConfig const& config, double duration );
-
-    std::string serializeFilters( std::vector<std::string> const& filters );
-
-    struct lineOfChars {
-        char c;
-        constexpr lineOfChars( char c_ ): c( c_ ) {}
-
-        friend std::ostream& operator<<( std::ostream& out, lineOfChars value );
-    };
-
-    /**
-     * Lists reporter descriptions to the provided stream in user-friendly
-     * format
-     *
-     * Used as the default listing implementation by the first party reporter
-     * bases. The output should be backwards compatible with the output of
-     * Catch2 v2 binaries.
-     */
-    void
-    defaultListReporters( std::ostream& out,
-                          std::vector<ReporterDescription> const& descriptions,
-                          Verbosity verbosity );
-
-    /**
-     * Lists listeners descriptions to the provided stream in user-friendly
-     * format
-     */
-    void defaultListListeners( std::ostream& out,
-                               std::vector<ListenerDescription> const& descriptions );
-
-    /**
-     * Lists tag information to the provided stream in user-friendly format
-     *
-     * Used as the default listing implementation by the first party reporter
-     * bases. The output should be backwards compatible with the output of
-     * Catch2 v2 binaries.
-     */
-    void defaultListTags( std::ostream& out, std::vector<TagInfo> const& tags, bool isFiltered );
-
-    /**
-     * Lists test case information to the provided stream in user-friendly
-     * format
-     *
-     * Used as the default listing implementation by the first party reporter
-     * bases. The output is backwards compatible with the output of Catch2
-     * v2 binaries, and also supports the format specific to the old
-     * `--list-test-names-only` option, for people who used it in integrations.
-     */
-    void defaultListTests( std::ostream& out,
-                           ColourImpl* streamColour,
-                           std::vector<TestCaseHandle> const& tests,
-                           bool isFiltered,
-                           Verbosity verbosity );
-
-    /**
-     * Prints test run totals to the provided stream in user-friendly format
-     *
-     * Used by the console and compact reporters.
-     */
-    void printTestRunTotals( std::ostream& stream,
-                      ColourImpl& streamColour,
-                      Totals const& totals );
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_HELPERS_HPP_INCLUDED
-
-
-
-#ifndef CATCH_REPORTER_JSON_HPP_INCLUDED
-#define CATCH_REPORTER_JSON_HPP_INCLUDED
-
-
-#include <stack>
-
-namespace Catch {
-    class JsonReporter : public StreamingReporterBase {
-    public:
-        JsonReporter( ReporterConfig&& config );
-
-        ~JsonReporter() override;
-
-        static std::string getDescription();
-
-    public: // StreamingReporterBase
-        void testRunStarting( TestRunInfo const& runInfo ) override;
-        void testRunEnded( TestRunStats const& runStats ) override;
-
-        void testCaseStarting( TestCaseInfo const& tcInfo ) override;
-        void testCaseEnded( TestCaseStats const& tcStats ) override;
-
-        void testCasePartialStarting( TestCaseInfo const& tcInfo,
-                                      uint64_t index ) override;
-        void testCasePartialEnded( TestCaseStats const& tcStats,
-                                   uint64_t index ) override;
-
-        void sectionStarting( SectionInfo const& sectionInfo ) override;
-        void sectionEnded( SectionStats const& sectionStats ) override;
-
-        void assertionStarting( AssertionInfo const& assertionInfo ) override;
-        void assertionEnded( AssertionStats const& assertionStats ) override;
-
-        //void testRunEndedCumulative() override;
-
-        void benchmarkPreparing( StringRef name ) override;
-        void benchmarkStarting( BenchmarkInfo const& ) override;
-        void benchmarkEnded( BenchmarkStats<> const& ) override;
-        void benchmarkFailed( StringRef error ) override;
-
-        void listReporters(
-            std::vector<ReporterDescription> const& descriptions ) override;
-        void listListeners(
-            std::vector<ListenerDescription> const& descriptions ) override;
-        void listTests( std::vector<TestCaseHandle> const& tests ) override;
-        void listTags( std::vector<TagInfo> const& tags ) override;
-
-    private:
-        Timer m_testCaseTimer;
-        enum class Writer {
-            Object,
-            Array
-        };
-
-        JsonArrayWriter& startArray();
-        JsonArrayWriter& startArray( StringRef key );
-
-        JsonObjectWriter& startObject();
-        JsonObjectWriter& startObject( StringRef key );
-
-        void endObject();
-        void endArray();
-
-        bool isInside( Writer writer );
-
-        void startListing();
-        void endListing();
-
-        // Invariant:
-        // When m_writers is not empty and its top element is
-        // - Writer::Object, then m_objectWriters is not be empty
-        // - Writer::Array,  then m_arrayWriters shall not be empty
-        std::stack<JsonObjectWriter> m_objectWriters{};
-        std::stack<JsonArrayWriter> m_arrayWriters{};
-        std::stack<Writer> m_writers{};
-
-        bool m_startedListing = false;
-
-        // std::size_t m_sectionDepth = 0;
-        // std::size_t m_sectionStarted = 0;
-    };
-} // namespace Catch
-
-#endif // CATCH_REPORTER_JSON_HPP_INCLUDED
-
-
-#ifndef CATCH_REPORTER_JUNIT_HPP_INCLUDED
-#define CATCH_REPORTER_JUNIT_HPP_INCLUDED
-
-
-
-namespace Catch {
-
-    class JunitReporter final : public CumulativeReporterBase {
-    public:
-        JunitReporter(ReporterConfig&& _config);
-
-        static std::string getDescription();
-
-        void testRunStarting(TestRunInfo const& runInfo) override;
-
-        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
-        void assertionEnded(AssertionStats const& assertionStats) override;
-
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
-
-        void testRunEndedCumulative() override;
-
-    private:
-        void writeRun(TestRunNode const& testRunNode, double suiteTime);
-
-        void writeTestCase(TestCaseNode const& testCaseNode);
-
-        void writeSection( std::string const& className,
-                           std::string const& rootName,
-                           SectionNode const& sectionNode,
-                           bool testOkToFail );
-
-        void writeAssertions(SectionNode const& sectionNode);
-        void writeAssertion(AssertionStats const& stats);
-
-        XmlWriter xml;
-        Timer suiteTimer;
-        std::string stdOutForSuite;
-        std::string stdErrForSuite;
-        unsigned int unexpectedExceptions = 0;
-        bool m_okToFail = false;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_JUNIT_HPP_INCLUDED
-
-
-#ifndef CATCH_REPORTER_MULTI_HPP_INCLUDED
-#define CATCH_REPORTER_MULTI_HPP_INCLUDED
-
-
-namespace Catch {
-
-    class MultiReporter final : public IEventListener {
-        /*
-         * Stores all added reporters and listeners
-         *
-         * All Listeners are stored before all reporters, and individual
-         * listeners/reporters are stored in order of insertion.
-         */
-        std::vector<IEventListenerPtr> m_reporterLikes;
-        bool m_haveNoncapturingReporters = false;
-
-        // Keep track of how many listeners we have already inserted,
-        // so that we can insert them into the main vector at the right place
-        size_t m_insertedListeners = 0;
-
-        void updatePreferences(IEventListener const& reporterish);
-
-    public:
-        using IEventListener::IEventListener;
-
-        void addListener( IEventListenerPtr&& listener );
-        void addReporter( IEventListenerPtr&& reporter );
-
-    public: // IEventListener
-
-        void noMatchingTestCases( StringRef unmatchedSpec ) override;
-        void fatalErrorEncountered( StringRef error ) override;
-        void reportInvalidTestSpec( StringRef arg ) override;
-
-        void benchmarkPreparing( StringRef name ) override;
-        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
-        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
-        void benchmarkFailed( StringRef error ) override;
-
-        void testRunStarting( TestRunInfo const& testRunInfo ) override;
-        void testCaseStarting( TestCaseInfo const& testInfo ) override;
-        void testCasePartialStarting(TestCaseInfo const& testInfo, uint64_t partNumber) override;
-        void sectionStarting( SectionInfo const& sectionInfo ) override;
-        void assertionStarting( AssertionInfo const& assertionInfo ) override;
-
-        void assertionEnded( AssertionStats const& assertionStats ) override;
-        void sectionEnded( SectionStats const& sectionStats ) override;
-        void testCasePartialEnded(TestCaseStats const& testStats, uint64_t partNumber) override;
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
-        void testRunEnded( TestRunStats const& testRunStats ) override;
-
-        void skipTest( TestCaseInfo const& testInfo ) override;
-
-        void listReporters(std::vector<ReporterDescription> const& descriptions) override;
-        void listListeners(std::vector<ListenerDescription> const& descriptions) override;
-        void listTests(std::vector<TestCaseHandle> const& tests) override;
-        void listTags(std::vector<TagInfo> const& tags) override;
-
-
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_MULTI_HPP_INCLUDED
-
-
-#ifndef CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
-#define CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
-
-
-#include <type_traits>
-
-namespace Catch {
-
-    namespace Detail {
-
-        template <typename T, typename = void>
-        struct has_description : std::false_type {};
-
-        template <typename T>
-        struct has_description<
-            T,
-            void_t<decltype( T::getDescription() )>>
-            : std::true_type {};
-
-        //! Indirection for reporter registration, so that the error handling is
-        //! independent on the reporter's concrete type
-        void registerReporterImpl( std::string const& name,
-                                   IReporterFactoryPtr reporterPtr );
-        //! Actually registers the factory, independent on listener's concrete type
-        void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory );
-    } // namespace Detail
-
-    class IEventListener;
-    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
-
-    template <typename T>
-    class ReporterFactory : public IReporterFactory {
-
-        IEventListenerPtr create( ReporterConfig&& config ) const override {
-            return Detail::make_unique<T>( CATCH_MOVE(config) );
-        }
-
-        std::string getDescription() const override {
-            return T::getDescription();
-        }
-    };
-
-
-    template<typename T>
-    class ReporterRegistrar {
-    public:
-        explicit ReporterRegistrar( std::string const& name ) {
-            registerReporterImpl( name,
-                                  Detail::make_unique<ReporterFactory<T>>() );
-        }
-    };
-
-    template<typename T>
-    class ListenerRegistrar {
-
-        class TypedListenerFactory : public EventListenerFactory {
-            StringRef m_listenerName;
-
-            std::string getDescriptionImpl( std::true_type ) const {
-                return T::getDescription();
-            }
-
-            std::string getDescriptionImpl( std::false_type ) const {
-                return "(No description provided)";
-            }
-
-        public:
-            TypedListenerFactory( StringRef listenerName ):
-                m_listenerName( listenerName ) {}
-
-            IEventListenerPtr create( IConfig const* config ) const override {
-                return Detail::make_unique<T>( config );
-            }
-
-            StringRef getName() const override {
-                return m_listenerName;
-            }
-
-            std::string getDescription() const override {
-                return getDescriptionImpl( Detail::has_description<T>{} );
-            }
-        };
-
-    public:
-        ListenerRegistrar(StringRef listenerName) {
-            registerListenerImpl( Detail::make_unique<TypedListenerFactory>(listenerName) );
-        }
-    };
-}
-
-#if !defined(CATCH_CONFIG_DISABLE)
-
-#    define CATCH_REGISTER_REPORTER( name, reporterType )                      \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                              \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                               \
-        namespace {                                                            \
-            Catch::ReporterRegistrar<reporterType> INTERNAL_CATCH_UNIQUE_NAME( \
-                catch_internal_RegistrarFor )( name );                         \
-        }                                                                      \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#    define CATCH_REGISTER_LISTENER( listenerType )                            \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                              \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                               \
-        namespace {                                                            \
-            Catch::ListenerRegistrar<listenerType> INTERNAL_CATCH_UNIQUE_NAME( \
-                catch_internal_RegistrarFor )( #listenerType##_catch_sr );     \
-        }                                                                      \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#else // CATCH_CONFIG_DISABLE
-
-#define CATCH_REGISTER_REPORTER(name, reporterType)
-#define CATCH_REGISTER_LISTENER(listenerType)
-
-#endif // CATCH_CONFIG_DISABLE
-
-#endif // CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
-
-
-#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
-#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
-
-
-
-namespace Catch {
-
-    class SonarQubeReporter final : public CumulativeReporterBase {
-    public:
-        SonarQubeReporter(ReporterConfig&& config)
-        : CumulativeReporterBase(CATCH_MOVE(config))
-        , xml(m_stream) {
-            m_preferences.shouldRedirectStdOut = true;
-            m_preferences.shouldReportAllAssertions = false;
-            m_shouldStoreSuccesfulAssertions = false;
-        }
-
-        static std::string getDescription() {
-            using namespace std::string_literals;
-            return "Reports test results in the Generic Test Data SonarQube XML format"s;
-        }
-
-        void testRunStarting( TestRunInfo const& testRunInfo ) override;
-
-        void testRunEndedCumulative() override {
-            writeRun( *m_testRun );
-            xml.endElement();
-        }
-
-        void writeRun( TestRunNode const& runNode );
-
-        void writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes);
-
-        void writeTestCase(TestCaseNode const& testCaseNode);
-
-        void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail);
-
-        void writeAssertions(SectionNode const& sectionNode, bool okToFail);
-
-        void writeAssertion(AssertionStats const& stats, bool okToFail);
-
-    private:
-        XmlWriter xml;
-    };
-
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
-
-
-#ifndef CATCH_REPORTER_TAP_HPP_INCLUDED
-#define CATCH_REPORTER_TAP_HPP_INCLUDED
-
-
-namespace Catch {
-
-    class TAPReporter final : public StreamingReporterBase {
-    public:
-        TAPReporter( ReporterConfig&& config ):
-            StreamingReporterBase( CATCH_MOVE(config) ) {
-            m_preferences.shouldReportAllAssertions = true;
-        }
-
-        static std::string getDescription() {
-            using namespace std::string_literals;
-            return "Reports test results in TAP format, suitable for test harnesses"s;
-        }
-
-        void testRunStarting( TestRunInfo const& testInfo ) override;
-
-        void noMatchingTestCases( StringRef unmatchedSpec ) override;
-
-        void assertionEnded(AssertionStats const& _assertionStats) override;
-
-        void testRunEnded(TestRunStats const& _testRunStats) override;
-
-    private:
-        std::size_t counter = 0;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_TAP_HPP_INCLUDED
-
-
-#ifndef CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
-#define CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
-
-
-#include <cstring>
-
-#ifdef __clang__
-#   pragma clang diagnostic push
-#   pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    class TeamCityReporter final : public StreamingReporterBase {
-    public:
-        TeamCityReporter( ReporterConfig&& _config )
-        :   StreamingReporterBase( CATCH_MOVE(_config) )
-        {
-            m_preferences.shouldRedirectStdOut = true;
-        }
-
-        ~TeamCityReporter() override;
-
-        static std::string getDescription() {
-            using namespace std::string_literals;
-            return "Reports test results as TeamCity service messages"s;
-        }
-
-        void testRunStarting( TestRunInfo const& runInfo ) override;
-        void testRunEnded( TestRunStats const& runStats ) override;
-
-
-        void assertionEnded(AssertionStats const& assertionStats) override;
-
-        void sectionStarting(SectionInfo const& sectionInfo) override {
-            m_headerPrintedForThisSection = false;
-            StreamingReporterBase::sectionStarting( sectionInfo );
-        }
-
-        void testCaseStarting(TestCaseInfo const& testInfo) override;
-
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
-
-    private:
-        void printSectionHeader(std::ostream& os);
-
-        bool m_headerPrintedForThisSection = false;
-        Timer m_testTimer;
-    };
-
-} // end namespace Catch
-
-#ifdef __clang__
-#   pragma clang diagnostic pop
-#endif
-
-#endif // CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
-
-
-#ifndef CATCH_REPORTER_XML_HPP_INCLUDED
-#define CATCH_REPORTER_XML_HPP_INCLUDED
-
-
-
-
-namespace Catch {
-    class XmlReporter : public StreamingReporterBase {
-    public:
-        XmlReporter(ReporterConfig&& _config);
-
-        ~XmlReporter() override;
-
-        static std::string getDescription();
-
-        virtual std::string getStylesheetRef() const;
-
-        void writeSourceInfo(SourceLineInfo const& sourceInfo);
-
-    public: // StreamingReporterBase
-
-        void testRunStarting(TestRunInfo const& testInfo) override;
-
-        void testCaseStarting(TestCaseInfo const& testInfo) override;
-
-        void sectionStarting(SectionInfo const& sectionInfo) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        void assertionEnded(AssertionStats const& assertionStats) override;
-
-        void sectionEnded(SectionStats const& sectionStats) override;
-
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
-
-        void testRunEnded(TestRunStats const& testRunStats) override;
-
-        void benchmarkPreparing( StringRef name ) override;
-        void benchmarkStarting(BenchmarkInfo const&) override;
-        void benchmarkEnded(BenchmarkStats<> const&) override;
-        void benchmarkFailed( StringRef error ) override;
-
-        void listReporters(std::vector<ReporterDescription> const& descriptions) override;
-        void listListeners(std::vector<ListenerDescription> const& descriptions) override;
-        void listTests(std::vector<TestCaseHandle> const& tests) override;
-        void listTags(std::vector<TagInfo> const& tags) override;
-
-    private:
-        Timer m_testCaseTimer;
-        XmlWriter m_xml;
-        int m_sectionDepth = 0;
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_XML_HPP_INCLUDED
-
-#endif // CATCH_REPORTERS_ALL_HPP_INCLUDED
-
-#endif // CATCH_ALL_HPP_INCLUDED
-#endif // CATCH_AMALGAMATED_HPP_INCLUDED
diff --git a/extern/lua-5.1.5/COPYRIGHT b/extern/lua-5.1.5/COPYRIGHT
deleted file mode 100644
index a8602680..00000000
--- a/extern/lua-5.1.5/COPYRIGHT
+++ /dev/null
@@ -1,34 +0,0 @@
-Lua License
------------
-
-Lua is licensed under the terms of the MIT license reproduced below.
-This means that Lua is free software and can be used for both academic
-and commercial purposes at absolutely no cost.
-
-For details and rationale, see http://www.lua.org/license.html .
-
-===============================================================================
-
-Copyright (C) 1994-2012 Lua.org, PUC-Rio.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-===============================================================================
-
-(end of COPYRIGHT)
diff --git a/extern/lua-5.1.5/HISTORY b/extern/lua-5.1.5/HISTORY
deleted file mode 100644
index ce0c95bc..00000000
--- a/extern/lua-5.1.5/HISTORY
+++ /dev/null
@@ -1,183 +0,0 @@
-HISTORY for Lua 5.1
-
-* Changes from version 5.0 to 5.1
-  -------------------------------
-  Language:
-  + new module system.
-  + new semantics for control variables of fors.
-  + new semantics for setn/getn.
-  + new syntax/semantics for varargs.
-  + new long strings and comments.
-  + new `mod' operator (`%')
-  + new length operator #t
-  + metatables for all types
-  API:
-  + new functions: lua_createtable, lua_get(set)field, lua_push(to)integer.
-  + user supplies memory allocator (lua_open becomes lua_newstate).
-  + luaopen_* functions must be called through Lua.
-  Implementation:
-  + new configuration scheme via luaconf.h.
-  + incremental garbage collection.
-  + better handling of end-of-line in the lexer.
-  + fully reentrant parser (new Lua function `load')
-  + better support for 64-bit machines.
-  + native loadlib support for Mac OS X.
-  + standard distribution in only one library (lualib.a merged into lua.a)
-
-* Changes from version 4.0 to 5.0
-  -------------------------------
-  Language:
-  + lexical scoping.
-  + Lua coroutines.
-  + standard libraries now packaged in tables.
-  + tags replaced by metatables and tag methods replaced by metamethods,
-    stored in metatables.
-  + proper tail calls.
-  + each function can have its own global table, which can be shared.
-  + new __newindex metamethod, called when we insert a new key into a table.
-  + new block comments: --[[ ... ]].
-  + new generic for.
-  + new weak tables.
-  + new boolean type.
-  + new syntax "local function".
-  + (f()) returns the first value returned by f.
-  + {f()} fills a table with all values returned by f.
-  + \n ignored in [[\n .
-  + fixed and-or priorities.
-  + more general syntax for function definition (e.g. function a.x.y:f()...end).
-  + more general syntax for function calls (e.g. (print or write)(9)).
-  + new functions (time/date, tmpfile, unpack, require, load*, etc.).
-  API:
-  + chunks are loaded by using lua_load; new luaL_loadfile and luaL_loadbuffer.
-  + introduced lightweight userdata, a simple "void*" without a metatable.
-  + new error handling protocol: the core no longer prints error messages;
-    all errors are reported to the caller on the stack.
-  + new lua_atpanic for host cleanup.
-  + new, signal-safe, hook scheme.
-  Implementation:
-  + new license: MIT.
-  + new, faster, register-based virtual machine.
-  + support for external multithreading and coroutines.
-  + new and consistent error message format.
-  + the core no longer needs "stdio.h" for anything (except for a single
-    use of sprintf to convert numbers to strings).
-  + lua.c now runs the environment variable LUA_INIT, if present. It can
-    be "@filename", to run a file, or the chunk itself.
-  + support for user extensions in lua.c.
-    sample implementation given for command line editing.
-  + new dynamic loading library, active by default on several platforms.
-  + safe garbage-collector metamethods.
-  + precompiled bytecodes checked for integrity (secure binary dostring).
-  + strings are fully aligned.
-  + position capture in string.find.
-  + read('*l') can read lines with embedded zeros.
-
-* Changes from version 3.2 to 4.0
-  -------------------------------
-  Language:
-  + new "break" and "for" statements (both numerical and for tables).
-  + uniform treatment of globals: globals are now stored in a Lua table.
-  + improved error messages.
-  + no more '$debug': full speed *and* full debug information.
-  + new read form: read(N) for next N bytes.
-  + general read patterns now deprecated.
-    (still available with -DCOMPAT_READPATTERNS.)
-  + all return values are passed as arguments for the last function
-    (old semantics still available with -DLUA_COMPAT_ARGRET)
-  + garbage collection tag methods for tables now deprecated.
-  + there is now only one tag method for order.
-  API:
-  + New API: fully re-entrant, simpler, and more efficient.
-  + New debug API.
-  Implementation:
-  + faster than ever: cleaner virtual machine and new hashing algorithm.
-  + non-recursive garbage-collector algorithm.
-  + reduced memory usage for programs with many strings.
-  + improved treatment for memory allocation errors.
-  + improved support for 16-bit machines (we hope).
-  + code now compiles unmodified as both ANSI C and C++.
-  + numbers in bases other than 10 are converted using strtoul.
-  + new -f option in Lua to support #! scripts.
-  + luac can now combine text and binaries.
-
-* Changes from version 3.1 to 3.2
-  -------------------------------
-  + redirected all output in Lua's core to _ERRORMESSAGE and _ALERT.
-  + increased limit on the number of constants and globals per function
-    (from 2^16 to 2^24).
-  + debugging info (lua_debug and hooks) moved into lua_state and new API
-    functions provided to get and set this info.
-  + new debug lib gives full debugging access within Lua.
-  + new table functions "foreachi", "sort", "tinsert", "tremove", "getn".
-  + new io functions "flush", "seek".
-
-* Changes from version 3.0 to 3.1
-  -------------------------------
-  + NEW FEATURE: anonymous functions with closures (via "upvalues").
-  + new syntax:
-    - local variables in chunks.
-    - better scope control with DO block END.
-    - constructors can now be also written: { record-part; list-part }.
-    - more general syntax for function calls and lvalues, e.g.:
-      f(x).y=1
-      o:f(x,y):g(z)
-      f"string" is sugar for f("string")
-  + strings may now contain arbitrary binary data (e.g., embedded zeros).
-  + major code re-organization and clean-up; reduced module interdependecies.
-  + no arbitrary limits on the total number of constants and globals.
-  + support for multiple global contexts.
-  + better syntax error messages.
-  + new traversal functions "foreach" and "foreachvar".
-  + the default for numbers is now double.
-    changing it to use floats or longs is easy.
-  + complete debug information stored in pre-compiled chunks.
-  + sample interpreter now prompts user when run interactively, and also
-    handles control-C interruptions gracefully.
-
-* Changes from version 2.5 to 3.0
-  -------------------------------
-  + NEW CONCEPT: "tag methods".
-    Tag methods replace fallbacks as the meta-mechanism for extending the
-    semantics of Lua. Whereas fallbacks had a global nature, tag methods
-    work on objects having the same tag (e.g., groups of tables).
-    Existing code that uses fallbacks should work without change.
-  + new, general syntax for constructors {[exp] = exp, ... }.
-  + support for handling variable number of arguments in functions (varargs).
-  + support for conditional compilation ($if ... $else ... $end).
-  + cleaner semantics in API simplifies host code.
-  + better support for writing libraries (auxlib.h).
-  + better type checking and error messages in the standard library.
-  + luac can now also undump.
-
-* Changes from version 2.4 to 2.5
-  -------------------------------
-  + io and string libraries are now based on pattern matching;
-    the old libraries are still available for compatibility
-  + dofile and dostring can now return values (via return statement)
-  + better support for 16- and 64-bit machines
-  + expanded documentation, with more examples
-
-* Changes from version 2.2 to 2.4
-  -------------------------------
-  + external compiler creates portable binary files that can be loaded faster
-  + interface for debugging and profiling
-  + new "getglobal" fallback
-  + new functions for handling references to Lua objects
-  + new functions in standard lib
-  + only one copy of each string is stored
-  + expanded documentation, with more examples
-
-* Changes from version 2.1 to 2.2
-  -------------------------------
-  + functions now may be declared with any "lvalue" as a name
-  + garbage collection of functions
-  + support for pipes
-
-* Changes from version 1.1 to 2.1
-  -------------------------------
-  + object-oriented support
-  + fallbacks
-  + simplified syntax for tables
-  + many internal improvements
-
-(end of HISTORY)
diff --git a/extern/lua-5.1.5/INSTALL b/extern/lua-5.1.5/INSTALL
deleted file mode 100644
index 17eb8aee..00000000
--- a/extern/lua-5.1.5/INSTALL
+++ /dev/null
@@ -1,99 +0,0 @@
-INSTALL for Lua 5.1
-
-* Building Lua
-  ------------
-  Lua is built in the src directory, but the build process can be
-  controlled from the top-level Makefile.
-
-  Building Lua on Unix systems should be very easy. First do "make" and
-  see if your platform is listed. If so, just do "make xxx", where xxx
-  is your platform name. The platforms currently supported are:
-    aix ansi bsd freebsd generic linux macosx mingw posix solaris
-
-  If your platform is not listed, try the closest one or posix, generic,
-  ansi, in this order.
-
-  See below for customization instructions and for instructions on how
-  to build with other Windows compilers.
-
-  If you want to check that Lua has been built correctly, do "make test"
-  after building Lua. Also, have a look at the example programs in test.
-
-* Installing Lua
-  --------------
-  Once you have built Lua, you may want to install it in an official
-  place in your system. In this case, do "make install". The official
-  place and the way to install files are defined in Makefile. You must
-  have the right permissions to install files.
-
-  If you want to build and install Lua in one step, do "make xxx install",
-  where xxx is your platform name.
-
-  If you want to install Lua locally, then do "make local". This will
-  create directories bin, include, lib, man, and install Lua there as
-  follows:
-
-    bin:	lua luac
-    include:	lua.h luaconf.h lualib.h lauxlib.h lua.hpp
-    lib:	liblua.a
-    man/man1:	lua.1 luac.1
-
-  These are the only directories you need for development.
-
-  There are man pages for lua and luac, in both nroff and html, and a
-  reference manual in html in doc, some sample code in test, and some
-  useful stuff in etc. You don't need these directories for development.
-
-  If you want to install Lua locally, but in some other directory, do
-  "make install INSTALL_TOP=xxx", where xxx is your chosen directory.
-
-  See below for instructions for Windows and other systems.
-
-* Customization
-  -------------
-  Three things can be customized by editing a file:
-    - Where and how to install Lua -- edit Makefile.
-    - How to build Lua -- edit src/Makefile.
-    - Lua features -- edit src/luaconf.h.
-
-  You don't actually need to edit the Makefiles because you may set the
-  relevant variables when invoking make.
-
-  On the other hand, if you need to select some Lua features, you'll need
-  to edit src/luaconf.h. The edited file will be the one installed, and
-  it will be used by any Lua clients that you build, to ensure consistency.
-
-  We strongly recommend that you enable dynamic loading. This is done
-  automatically for all platforms listed above that have this feature
-  (and also Windows). See src/luaconf.h and also src/Makefile.
-
-* Building Lua on Windows and other systems
-  -----------------------------------------
-  If you're not using the usual Unix tools, then the instructions for
-  building Lua depend on the compiler you use. You'll need to create
-  projects (or whatever your compiler uses) for building the library,
-  the interpreter, and the compiler, as follows:
-
-  library:	lapi.c lcode.c ldebug.c ldo.c ldump.c lfunc.c lgc.c llex.c
-		lmem.c lobject.c lopcodes.c lparser.c lstate.c lstring.c
-		ltable.c ltm.c lundump.c lvm.c lzio.c
-		lauxlib.c lbaselib.c ldblib.c liolib.c lmathlib.c loslib.c
-		ltablib.c lstrlib.c loadlib.c linit.c
-
-  interpreter:	library, lua.c
-
-  compiler:	library, luac.c print.c
-
-  If you use Visual Studio .NET, you can use etc/luavs.bat in its
-  "Command Prompt".
-
-  If all you want is to build the Lua interpreter, you may put all .c files
-  in a single project, except for luac.c and print.c. Or just use etc/all.c.
-
-  To use Lua as a library in your own programs, you'll need to know how to
-  create and use libraries with your compiler.
-
-  As mentioned above, you may edit luaconf.h to select some features before
-  building Lua.
-
-(end of INSTALL)
diff --git a/extern/lua-5.1.5/Makefile b/extern/lua-5.1.5/Makefile
deleted file mode 100644
index 209a1324..00000000
--- a/extern/lua-5.1.5/Makefile
+++ /dev/null
@@ -1,128 +0,0 @@
-# makefile for installing Lua
-# see INSTALL for installation instructions
-# see src/Makefile and src/luaconf.h for further customization
-
-# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
-
-# Your platform. See PLATS for possible values.
-PLAT= none
-
-# Where to install. The installation starts in the src and doc directories,
-# so take care if INSTALL_TOP is not an absolute path.
-INSTALL_TOP= /usr/local
-INSTALL_BIN= $(INSTALL_TOP)/bin
-INSTALL_INC= $(INSTALL_TOP)/include
-INSTALL_LIB= $(INSTALL_TOP)/lib
-INSTALL_MAN= $(INSTALL_TOP)/man/man1
-#
-# You probably want to make INSTALL_LMOD and INSTALL_CMOD consistent with
-# LUA_ROOT, LUA_LDIR, and LUA_CDIR in luaconf.h (and also with etc/lua.pc).
-INSTALL_LMOD= $(INSTALL_TOP)/share/lua/$V
-INSTALL_CMOD= $(INSTALL_TOP)/lib/lua/$V
-
-# How to install. If your install program does not support "-p", then you
-# may have to run ranlib on the installed liblua.a (do "make ranlib").
-INSTALL= install -p
-INSTALL_EXEC= $(INSTALL) -m 0755
-INSTALL_DATA= $(INSTALL) -m 0644
-#
-# If you don't have install you can use cp instead.
-# INSTALL= cp -p
-# INSTALL_EXEC= $(INSTALL)
-# INSTALL_DATA= $(INSTALL)
-
-# Utilities.
-MKDIR= mkdir -p
-RANLIB= ranlib
-
-# == END OF USER SETTINGS. NO NEED TO CHANGE ANYTHING BELOW THIS LINE =========
-
-# Convenience platforms targets.
-PLATS= aix ansi bsd freebsd generic linux macosx mingw posix solaris
-
-# What to install.
-TO_BIN= lua luac
-TO_INC= lua.h luaconf.h lualib.h lauxlib.h ../etc/lua.hpp
-TO_LIB= liblua.a
-TO_MAN= lua.1 luac.1
-
-# Lua version and release.
-V= 5.1
-R= 5.1.5
-
-all:	$(PLAT)
-
-$(PLATS) clean:
-	cd src && $(MAKE) $@
-
-test:	dummy
-	src/lua test/hello.lua
-
-install: dummy
-	cd src && $(MKDIR) $(INSTALL_BIN) $(INSTALL_INC) $(INSTALL_LIB) $(INSTALL_MAN) $(INSTALL_LMOD) $(INSTALL_CMOD)
-	cd src && $(INSTALL_EXEC) $(TO_BIN) $(INSTALL_BIN)
-	cd src && $(INSTALL_DATA) $(TO_INC) $(INSTALL_INC)
-	cd src && $(INSTALL_DATA) $(TO_LIB) $(INSTALL_LIB)
-	cd doc && $(INSTALL_DATA) $(TO_MAN) $(INSTALL_MAN)
-
-ranlib:
-	cd src && cd $(INSTALL_LIB) && $(RANLIB) $(TO_LIB)
-
-local:
-	$(MAKE) install INSTALL_TOP=..
-
-none:
-	@echo "Please do"
-	@echo "   make PLATFORM"
-	@echo "where PLATFORM is one of these:"
-	@echo "   $(PLATS)"
-	@echo "See INSTALL for complete instructions."
-
-# make may get confused with test/ and INSTALL in a case-insensitive OS
-dummy:
-
-# echo config parameters
-echo:
-	@echo ""
-	@echo "These are the parameters currently set in src/Makefile to build Lua $R:"
-	@echo ""
-	@cd src && $(MAKE) -s echo
-	@echo ""
-	@echo "These are the parameters currently set in Makefile to install Lua $R:"
-	@echo ""
-	@echo "PLAT = $(PLAT)"
-	@echo "INSTALL_TOP = $(INSTALL_TOP)"
-	@echo "INSTALL_BIN = $(INSTALL_BIN)"
-	@echo "INSTALL_INC = $(INSTALL_INC)"
-	@echo "INSTALL_LIB = $(INSTALL_LIB)"
-	@echo "INSTALL_MAN = $(INSTALL_MAN)"
-	@echo "INSTALL_LMOD = $(INSTALL_LMOD)"
-	@echo "INSTALL_CMOD = $(INSTALL_CMOD)"
-	@echo "INSTALL_EXEC = $(INSTALL_EXEC)"
-	@echo "INSTALL_DATA = $(INSTALL_DATA)"
-	@echo ""
-	@echo "See also src/luaconf.h ."
-	@echo ""
-
-# echo private config parameters
-pecho:
-	@echo "V = $(V)"
-	@echo "R = $(R)"
-	@echo "TO_BIN = $(TO_BIN)"
-	@echo "TO_INC = $(TO_INC)"
-	@echo "TO_LIB = $(TO_LIB)"
-	@echo "TO_MAN = $(TO_MAN)"
-
-# echo config parameters as Lua code
-# uncomment the last sed expression if you want nil instead of empty strings
-lecho:
-	@echo "-- installation parameters for Lua $R"
-	@echo "VERSION = '$V'"
-	@echo "RELEASE = '$R'"
-	@$(MAKE) echo | grep = | sed -e 's/= /= "/' -e 's/$$/"/' #-e 's/""/nil/'
-	@echo "-- EOF"
-
-# list targets that do not create files (but not all makes understand .PHONY)
-.PHONY: all $(PLATS) clean test install local none dummy echo pecho lecho
-
-# (end of Makefile)
diff --git a/extern/lua-5.1.5/README b/extern/lua-5.1.5/README
deleted file mode 100644
index 11b4dff7..00000000
--- a/extern/lua-5.1.5/README
+++ /dev/null
@@ -1,37 +0,0 @@
-README for Lua 5.1
-
-See INSTALL for installation instructions.
-See HISTORY for a summary of changes since the last released version.
-
-* What is Lua?
-  ------------
-  Lua is a powerful, light-weight programming language designed for extending
-  applications. Lua is also frequently used as a general-purpose, stand-alone
-  language. Lua is free software.
-
-  For complete information, visit Lua's web site at http://www.lua.org/ .
-  For an executive summary, see http://www.lua.org/about.html .
-
-  Lua has been used in many different projects around the world.
-  For a short list, see http://www.lua.org/uses.html .
-
-* Availability
-  ------------
-  Lua is freely available for both academic and commercial purposes.
-  See COPYRIGHT and http://www.lua.org/license.html for details.
-  Lua can be downloaded at http://www.lua.org/download.html .
-
-* Installation
-  ------------
-  Lua is implemented in pure ANSI C, and compiles unmodified in all known
-  platforms that have an ANSI C compiler. In most Unix-like platforms, simply
-  do "make" with a suitable target. See INSTALL for detailed instructions.
-
-* Origin
-  ------
-  Lua is developed at Lua.org, a laboratory of the Department of Computer
-  Science of PUC-Rio (the Pontifical Catholic University of Rio de Janeiro
-  in Brazil).
-  For more information about the authors, see http://www.lua.org/authors.html .
-
-(end of README)
diff --git a/extern/lua-5.1.5/doc/contents.html b/extern/lua-5.1.5/doc/contents.html
deleted file mode 100644
index 3d83da98..00000000
--- a/extern/lua-5.1.5/doc/contents.html
+++ /dev/null
@@ -1,497 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<HTML>
-<HEAD>
-<TITLE>Lua 5.1 Reference Manual - contents</TITLE>
-<LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
-<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=utf-8">
-<STYLE TYPE="text/css">
-ul {
-	list-style-type: none ;
-}
-</STYLE>
-</HEAD>
-
-<BODY>
-
-<HR>
-<H1>
-<A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="" BORDER=0></A>
-Lua 5.1 Reference Manual
-</H1>
-
-<P>
-The reference manual is the official definition of the Lua language.
-For a complete introduction to Lua programming, see the book
-<A HREF="http://www.lua.org/docs.html#pil">Programming in Lua</A>.
-
-<P>
-This manual is also available as a book:
-<BLOCKQUOTE>
-<A HREF="http://www.amazon.com/exec/obidos/ASIN/8590379833/lua-indexmanual-20">
-<IMG SRC="cover.png" ALT="" TITLE="buy from Amazon" BORDER=1 ALIGN="left" HSPACE=12>
-</A>
-<B>Lua 5.1 Reference Manual</B>
-<BR>by R. Ierusalimschy, L. H. de Figueiredo, W. Celes
-<BR>Lua.org, August 2006
-<BR>ISBN 85-903798-3-3
-<BR CLEAR="all">
-</BLOCKQUOTE>
-
-<P>
-<A HREF="http://www.amazon.com/exec/obidos/ASIN/8590379833/lua-indexmanual-20">Buy a copy</A>
-of this book and
-<A HREF="http://www.lua.org/donations.html">help to support</A>
-the Lua project.
-
-<P>
-<A HREF="manual.html">start</A>
-&middot;
-<A HREF="#contents">contents</A>
-&middot;
-<A HREF="#index">index</A>
-&middot;
-<A HREF="http://www.lua.org/manual/">other versions</A>
-<HR>
-<SMALL>
-Copyright &copy; 2006&ndash;2012 Lua.org, PUC-Rio.
-Freely available under the terms of the
-<A HREF="http://www.lua.org/license.html">Lua license</A>.
-</SMALL>
-
-<H2><A NAME="contents">Contents</A></H2>
-<UL style="padding: 0">
-<LI><A HREF="manual.html">1 &ndash; Introduction</A>
-<P>
-<LI><A HREF="manual.html#2">2 &ndash; The Language</A>
-<UL>
-<LI><A HREF="manual.html#2.1">2.1 &ndash; Lexical Conventions</A>
-<LI><A HREF="manual.html#2.2">2.2 &ndash; Values and Types</A>
-<UL>
-<LI><A HREF="manual.html#2.2.1">2.2.1 &ndash; Coercion</A>
-</UL>
-<LI><A HREF="manual.html#2.3">2.3 &ndash; Variables</A>
-<LI><A HREF="manual.html#2.4">2.4 &ndash; Statements</A>
-<UL>
-<LI><A HREF="manual.html#2.4.1">2.4.1 &ndash; Chunks</A>
-<LI><A HREF="manual.html#2.4.2">2.4.2 &ndash; Blocks</A>
-<LI><A HREF="manual.html#2.4.3">2.4.3 &ndash; Assignment</A>
-<LI><A HREF="manual.html#2.4.4">2.4.4 &ndash; Control Structures</A>
-<LI><A HREF="manual.html#2.4.5">2.4.5 &ndash; For Statement</A>
-<LI><A HREF="manual.html#2.4.6">2.4.6 &ndash; Function Calls as Statements</A>
-<LI><A HREF="manual.html#2.4.7">2.4.7 &ndash; Local Declarations</A>
-</UL>
-<LI><A HREF="manual.html#2.5">2.5 &ndash; Expressions</A>
-<UL>
-<LI><A HREF="manual.html#2.5.1">2.5.1 &ndash; Arithmetic Operators</A>
-<LI><A HREF="manual.html#2.5.2">2.5.2 &ndash; Relational Operators</A>
-<LI><A HREF="manual.html#2.5.3">2.5.3 &ndash; Logical Operators</A>
-<LI><A HREF="manual.html#2.5.4">2.5.4 &ndash; Concatenation</A>
-<LI><A HREF="manual.html#2.5.5">2.5.5 &ndash; The Length Operator</A>
-<LI><A HREF="manual.html#2.5.6">2.5.6 &ndash; Precedence</A>
-<LI><A HREF="manual.html#2.5.7">2.5.7 &ndash; Table Constructors</A>
-<LI><A HREF="manual.html#2.5.8">2.5.8 &ndash; Function Calls</A>
-<LI><A HREF="manual.html#2.5.9">2.5.9 &ndash; Function Definitions</A>
-</UL>
-<LI><A HREF="manual.html#2.6">2.6 &ndash; Visibility Rules</A>
-<LI><A HREF="manual.html#2.7">2.7 &ndash; Error Handling</A>
-<LI><A HREF="manual.html#2.8">2.8 &ndash; Metatables</A>
-<LI><A HREF="manual.html#2.9">2.9 &ndash; Environments</A>
-<LI><A HREF="manual.html#2.10">2.10 &ndash; Garbage Collection</A>
-<UL>
-<LI><A HREF="manual.html#2.10.1">2.10.1 &ndash; Garbage-Collection Metamethods</A>
-<LI><A HREF="manual.html#2.10.2">2.10.2 &ndash; Weak Tables</A>
-</UL>
-<LI><A HREF="manual.html#2.11">2.11 &ndash; Coroutines</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#3">3 &ndash; The Application Program Interface</A>
-<UL>
-<LI><A HREF="manual.html#3.1">3.1 &ndash; The Stack</A>
-<LI><A HREF="manual.html#3.2">3.2 &ndash; Stack Size</A>
-<LI><A HREF="manual.html#3.3">3.3 &ndash; Pseudo-Indices</A>
-<LI><A HREF="manual.html#3.4">3.4 &ndash; C Closures</A>
-<LI><A HREF="manual.html#3.5">3.5 &ndash; Registry</A>
-<LI><A HREF="manual.html#3.6">3.6 &ndash; Error Handling in C</A>
-<LI><A HREF="manual.html#3.7">3.7 &ndash; Functions and Types</A>
-<LI><A HREF="manual.html#3.8">3.8 &ndash; The Debug Interface</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#4">4 &ndash; The Auxiliary Library</A>
-<UL>
-<LI><A HREF="manual.html#4.1">4.1 &ndash; Functions and Types</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#5">5 &ndash; Standard Libraries</A>
-<UL>
-<LI><A HREF="manual.html#5.1">5.1 &ndash; Basic Functions</A>
-<LI><A HREF="manual.html#5.2">5.2 &ndash; Coroutine Manipulation</A>
-<LI><A HREF="manual.html#5.3">5.3 &ndash; Modules</A>
-<LI><A HREF="manual.html#5.4">5.4 &ndash; String Manipulation</A>
-<UL>
-<LI><A HREF="manual.html#5.4.1">5.4.1 &ndash; Patterns</A>
-</UL>
-<LI><A HREF="manual.html#5.5">5.5 &ndash; Table Manipulation</A>
-<LI><A HREF="manual.html#5.6">5.6 &ndash; Mathematical Functions</A>
-<LI><A HREF="manual.html#5.7">5.7 &ndash; Input and Output Facilities</A>
-<LI><A HREF="manual.html#5.8">5.8 &ndash; Operating System Facilities</A>
-<LI><A HREF="manual.html#5.9">5.9 &ndash; The Debug Library</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#6">6 &ndash; Lua Stand-alone</A>
-<P>
-<LI><A HREF="manual.html#7">7 &ndash; Incompatibilities with the Previous Version</A>
-<UL>
-<LI><A HREF="manual.html#7.1">7.1 &ndash; Changes in the Language</A>
-<LI><A HREF="manual.html#7.2">7.2 &ndash; Changes in the Libraries</A>
-<LI><A HREF="manual.html#7.3">7.3 &ndash; Changes in the API</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#8">8 &ndash; The Complete Syntax of Lua</A>
-</UL>
-
-<H2><A NAME="index">Index</A></H2>
-<TABLE WIDTH="100%">
-<TR VALIGN="top">
-<TD>
-<H3><A NAME="functions">Lua functions</A></H3>
-<A HREF="manual.html#pdf-_G">_G</A><BR>
-<A HREF="manual.html#pdf-_VERSION">_VERSION</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-assert">assert</A><BR>
-<A HREF="manual.html#pdf-collectgarbage">collectgarbage</A><BR>
-<A HREF="manual.html#pdf-dofile">dofile</A><BR>
-<A HREF="manual.html#pdf-error">error</A><BR>
-<A HREF="manual.html#pdf-getfenv">getfenv</A><BR>
-<A HREF="manual.html#pdf-getmetatable">getmetatable</A><BR>
-<A HREF="manual.html#pdf-ipairs">ipairs</A><BR>
-<A HREF="manual.html#pdf-load">load</A><BR>
-<A HREF="manual.html#pdf-loadfile">loadfile</A><BR>
-<A HREF="manual.html#pdf-loadstring">loadstring</A><BR>
-<A HREF="manual.html#pdf-module">module</A><BR>
-<A HREF="manual.html#pdf-next">next</A><BR>
-<A HREF="manual.html#pdf-pairs">pairs</A><BR>
-<A HREF="manual.html#pdf-pcall">pcall</A><BR>
-<A HREF="manual.html#pdf-print">print</A><BR>
-<A HREF="manual.html#pdf-rawequal">rawequal</A><BR>
-<A HREF="manual.html#pdf-rawget">rawget</A><BR>
-<A HREF="manual.html#pdf-rawset">rawset</A><BR>
-<A HREF="manual.html#pdf-require">require</A><BR>
-<A HREF="manual.html#pdf-select">select</A><BR>
-<A HREF="manual.html#pdf-setfenv">setfenv</A><BR>
-<A HREF="manual.html#pdf-setmetatable">setmetatable</A><BR>
-<A HREF="manual.html#pdf-tonumber">tonumber</A><BR>
-<A HREF="manual.html#pdf-tostring">tostring</A><BR>
-<A HREF="manual.html#pdf-type">type</A><BR>
-<A HREF="manual.html#pdf-unpack">unpack</A><BR>
-<A HREF="manual.html#pdf-xpcall">xpcall</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-coroutine.create">coroutine.create</A><BR>
-<A HREF="manual.html#pdf-coroutine.resume">coroutine.resume</A><BR>
-<A HREF="manual.html#pdf-coroutine.running">coroutine.running</A><BR>
-<A HREF="manual.html#pdf-coroutine.status">coroutine.status</A><BR>
-<A HREF="manual.html#pdf-coroutine.wrap">coroutine.wrap</A><BR>
-<A HREF="manual.html#pdf-coroutine.yield">coroutine.yield</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-debug.debug">debug.debug</A><BR>
-<A HREF="manual.html#pdf-debug.getfenv">debug.getfenv</A><BR>
-<A HREF="manual.html#pdf-debug.gethook">debug.gethook</A><BR>
-<A HREF="manual.html#pdf-debug.getinfo">debug.getinfo</A><BR>
-<A HREF="manual.html#pdf-debug.getlocal">debug.getlocal</A><BR>
-<A HREF="manual.html#pdf-debug.getmetatable">debug.getmetatable</A><BR>
-<A HREF="manual.html#pdf-debug.getregistry">debug.getregistry</A><BR>
-<A HREF="manual.html#pdf-debug.getupvalue">debug.getupvalue</A><BR>
-<A HREF="manual.html#pdf-debug.setfenv">debug.setfenv</A><BR>
-<A HREF="manual.html#pdf-debug.sethook">debug.sethook</A><BR>
-<A HREF="manual.html#pdf-debug.setlocal">debug.setlocal</A><BR>
-<A HREF="manual.html#pdf-debug.setmetatable">debug.setmetatable</A><BR>
-<A HREF="manual.html#pdf-debug.setupvalue">debug.setupvalue</A><BR>
-<A HREF="manual.html#pdf-debug.traceback">debug.traceback</A><BR>
-
-</TD>
-<TD>
-<H3>&nbsp;</H3>
-<A HREF="manual.html#pdf-file:close">file:close</A><BR>
-<A HREF="manual.html#pdf-file:flush">file:flush</A><BR>
-<A HREF="manual.html#pdf-file:lines">file:lines</A><BR>
-<A HREF="manual.html#pdf-file:read">file:read</A><BR>
-<A HREF="manual.html#pdf-file:seek">file:seek</A><BR>
-<A HREF="manual.html#pdf-file:setvbuf">file:setvbuf</A><BR>
-<A HREF="manual.html#pdf-file:write">file:write</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-io.close">io.close</A><BR>
-<A HREF="manual.html#pdf-io.flush">io.flush</A><BR>
-<A HREF="manual.html#pdf-io.input">io.input</A><BR>
-<A HREF="manual.html#pdf-io.lines">io.lines</A><BR>
-<A HREF="manual.html#pdf-io.open">io.open</A><BR>
-<A HREF="manual.html#pdf-io.output">io.output</A><BR>
-<A HREF="manual.html#pdf-io.popen">io.popen</A><BR>
-<A HREF="manual.html#pdf-io.read">io.read</A><BR>
-<A HREF="manual.html#pdf-io.stderr">io.stderr</A><BR>
-<A HREF="manual.html#pdf-io.stdin">io.stdin</A><BR>
-<A HREF="manual.html#pdf-io.stdout">io.stdout</A><BR>
-<A HREF="manual.html#pdf-io.tmpfile">io.tmpfile</A><BR>
-<A HREF="manual.html#pdf-io.type">io.type</A><BR>
-<A HREF="manual.html#pdf-io.write">io.write</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-math.abs">math.abs</A><BR>
-<A HREF="manual.html#pdf-math.acos">math.acos</A><BR>
-<A HREF="manual.html#pdf-math.asin">math.asin</A><BR>
-<A HREF="manual.html#pdf-math.atan">math.atan</A><BR>
-<A HREF="manual.html#pdf-math.atan2">math.atan2</A><BR>
-<A HREF="manual.html#pdf-math.ceil">math.ceil</A><BR>
-<A HREF="manual.html#pdf-math.cos">math.cos</A><BR>
-<A HREF="manual.html#pdf-math.cosh">math.cosh</A><BR>
-<A HREF="manual.html#pdf-math.deg">math.deg</A><BR>
-<A HREF="manual.html#pdf-math.exp">math.exp</A><BR>
-<A HREF="manual.html#pdf-math.floor">math.floor</A><BR>
-<A HREF="manual.html#pdf-math.fmod">math.fmod</A><BR>
-<A HREF="manual.html#pdf-math.frexp">math.frexp</A><BR>
-<A HREF="manual.html#pdf-math.huge">math.huge</A><BR>
-<A HREF="manual.html#pdf-math.ldexp">math.ldexp</A><BR>
-<A HREF="manual.html#pdf-math.log">math.log</A><BR>
-<A HREF="manual.html#pdf-math.log10">math.log10</A><BR>
-<A HREF="manual.html#pdf-math.max">math.max</A><BR>
-<A HREF="manual.html#pdf-math.min">math.min</A><BR>
-<A HREF="manual.html#pdf-math.modf">math.modf</A><BR>
-<A HREF="manual.html#pdf-math.pi">math.pi</A><BR>
-<A HREF="manual.html#pdf-math.pow">math.pow</A><BR>
-<A HREF="manual.html#pdf-math.rad">math.rad</A><BR>
-<A HREF="manual.html#pdf-math.random">math.random</A><BR>
-<A HREF="manual.html#pdf-math.randomseed">math.randomseed</A><BR>
-<A HREF="manual.html#pdf-math.sin">math.sin</A><BR>
-<A HREF="manual.html#pdf-math.sinh">math.sinh</A><BR>
-<A HREF="manual.html#pdf-math.sqrt">math.sqrt</A><BR>
-<A HREF="manual.html#pdf-math.tan">math.tan</A><BR>
-<A HREF="manual.html#pdf-math.tanh">math.tanh</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-os.clock">os.clock</A><BR>
-<A HREF="manual.html#pdf-os.date">os.date</A><BR>
-<A HREF="manual.html#pdf-os.difftime">os.difftime</A><BR>
-<A HREF="manual.html#pdf-os.execute">os.execute</A><BR>
-<A HREF="manual.html#pdf-os.exit">os.exit</A><BR>
-<A HREF="manual.html#pdf-os.getenv">os.getenv</A><BR>
-<A HREF="manual.html#pdf-os.remove">os.remove</A><BR>
-<A HREF="manual.html#pdf-os.rename">os.rename</A><BR>
-<A HREF="manual.html#pdf-os.setlocale">os.setlocale</A><BR>
-<A HREF="manual.html#pdf-os.time">os.time</A><BR>
-<A HREF="manual.html#pdf-os.tmpname">os.tmpname</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-package.cpath">package.cpath</A><BR>
-<A HREF="manual.html#pdf-package.loaded">package.loaded</A><BR>
-<A HREF="manual.html#pdf-package.loaders">package.loaders</A><BR>
-<A HREF="manual.html#pdf-package.loadlib">package.loadlib</A><BR>
-<A HREF="manual.html#pdf-package.path">package.path</A><BR>
-<A HREF="manual.html#pdf-package.preload">package.preload</A><BR>
-<A HREF="manual.html#pdf-package.seeall">package.seeall</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-string.byte">string.byte</A><BR>
-<A HREF="manual.html#pdf-string.char">string.char</A><BR>
-<A HREF="manual.html#pdf-string.dump">string.dump</A><BR>
-<A HREF="manual.html#pdf-string.find">string.find</A><BR>
-<A HREF="manual.html#pdf-string.format">string.format</A><BR>
-<A HREF="manual.html#pdf-string.gmatch">string.gmatch</A><BR>
-<A HREF="manual.html#pdf-string.gsub">string.gsub</A><BR>
-<A HREF="manual.html#pdf-string.len">string.len</A><BR>
-<A HREF="manual.html#pdf-string.lower">string.lower</A><BR>
-<A HREF="manual.html#pdf-string.match">string.match</A><BR>
-<A HREF="manual.html#pdf-string.rep">string.rep</A><BR>
-<A HREF="manual.html#pdf-string.reverse">string.reverse</A><BR>
-<A HREF="manual.html#pdf-string.sub">string.sub</A><BR>
-<A HREF="manual.html#pdf-string.upper">string.upper</A><BR>
-<P>
-
-<A HREF="manual.html#pdf-table.concat">table.concat</A><BR>
-<A HREF="manual.html#pdf-table.insert">table.insert</A><BR>
-<A HREF="manual.html#pdf-table.maxn">table.maxn</A><BR>
-<A HREF="manual.html#pdf-table.remove">table.remove</A><BR>
-<A HREF="manual.html#pdf-table.sort">table.sort</A><BR>
-
-</TD>
-<TD>
-<H3>C API</H3>
-<A HREF="manual.html#lua_Alloc">lua_Alloc</A><BR>
-<A HREF="manual.html#lua_CFunction">lua_CFunction</A><BR>
-<A HREF="manual.html#lua_Debug">lua_Debug</A><BR>
-<A HREF="manual.html#lua_Hook">lua_Hook</A><BR>
-<A HREF="manual.html#lua_Integer">lua_Integer</A><BR>
-<A HREF="manual.html#lua_Number">lua_Number</A><BR>
-<A HREF="manual.html#lua_Reader">lua_Reader</A><BR>
-<A HREF="manual.html#lua_State">lua_State</A><BR>
-<A HREF="manual.html#lua_Writer">lua_Writer</A><BR>
-<P>
-
-<A HREF="manual.html#lua_atpanic">lua_atpanic</A><BR>
-<A HREF="manual.html#lua_call">lua_call</A><BR>
-<A HREF="manual.html#lua_checkstack">lua_checkstack</A><BR>
-<A HREF="manual.html#lua_close">lua_close</A><BR>
-<A HREF="manual.html#lua_concat">lua_concat</A><BR>
-<A HREF="manual.html#lua_cpcall">lua_cpcall</A><BR>
-<A HREF="manual.html#lua_createtable">lua_createtable</A><BR>
-<A HREF="manual.html#lua_dump">lua_dump</A><BR>
-<A HREF="manual.html#lua_equal">lua_equal</A><BR>
-<A HREF="manual.html#lua_error">lua_error</A><BR>
-<A HREF="manual.html#lua_gc">lua_gc</A><BR>
-<A HREF="manual.html#lua_getallocf">lua_getallocf</A><BR>
-<A HREF="manual.html#lua_getfenv">lua_getfenv</A><BR>
-<A HREF="manual.html#lua_getfield">lua_getfield</A><BR>
-<A HREF="manual.html#lua_getglobal">lua_getglobal</A><BR>
-<A HREF="manual.html#lua_gethook">lua_gethook</A><BR>
-<A HREF="manual.html#lua_gethookcount">lua_gethookcount</A><BR>
-<A HREF="manual.html#lua_gethookmask">lua_gethookmask</A><BR>
-<A HREF="manual.html#lua_getinfo">lua_getinfo</A><BR>
-<A HREF="manual.html#lua_getlocal">lua_getlocal</A><BR>
-<A HREF="manual.html#lua_getmetatable">lua_getmetatable</A><BR>
-<A HREF="manual.html#lua_getstack">lua_getstack</A><BR>
-<A HREF="manual.html#lua_gettable">lua_gettable</A><BR>
-<A HREF="manual.html#lua_gettop">lua_gettop</A><BR>
-<A HREF="manual.html#lua_getupvalue">lua_getupvalue</A><BR>
-<A HREF="manual.html#lua_insert">lua_insert</A><BR>
-<A HREF="manual.html#lua_isboolean">lua_isboolean</A><BR>
-<A HREF="manual.html#lua_iscfunction">lua_iscfunction</A><BR>
-<A HREF="manual.html#lua_isfunction">lua_isfunction</A><BR>
-<A HREF="manual.html#lua_islightuserdata">lua_islightuserdata</A><BR>
-<A HREF="manual.html#lua_isnil">lua_isnil</A><BR>
-<A HREF="manual.html#lua_isnone">lua_isnone</A><BR>
-<A HREF="manual.html#lua_isnoneornil">lua_isnoneornil</A><BR>
-<A HREF="manual.html#lua_isnumber">lua_isnumber</A><BR>
-<A HREF="manual.html#lua_isstring">lua_isstring</A><BR>
-<A HREF="manual.html#lua_istable">lua_istable</A><BR>
-<A HREF="manual.html#lua_isthread">lua_isthread</A><BR>
-<A HREF="manual.html#lua_isuserdata">lua_isuserdata</A><BR>
-<A HREF="manual.html#lua_lessthan">lua_lessthan</A><BR>
-<A HREF="manual.html#lua_load">lua_load</A><BR>
-<A HREF="manual.html#lua_newstate">lua_newstate</A><BR>
-<A HREF="manual.html#lua_newtable">lua_newtable</A><BR>
-<A HREF="manual.html#lua_newthread">lua_newthread</A><BR>
-<A HREF="manual.html#lua_newuserdata">lua_newuserdata</A><BR>
-<A HREF="manual.html#lua_next">lua_next</A><BR>
-<A HREF="manual.html#lua_objlen">lua_objlen</A><BR>
-<A HREF="manual.html#lua_pcall">lua_pcall</A><BR>
-<A HREF="manual.html#lua_pop">lua_pop</A><BR>
-<A HREF="manual.html#lua_pushboolean">lua_pushboolean</A><BR>
-<A HREF="manual.html#lua_pushcclosure">lua_pushcclosure</A><BR>
-<A HREF="manual.html#lua_pushcfunction">lua_pushcfunction</A><BR>
-<A HREF="manual.html#lua_pushfstring">lua_pushfstring</A><BR>
-<A HREF="manual.html#lua_pushinteger">lua_pushinteger</A><BR>
-<A HREF="manual.html#lua_pushlightuserdata">lua_pushlightuserdata</A><BR>
-<A HREF="manual.html#lua_pushliteral">lua_pushliteral</A><BR>
-<A HREF="manual.html#lua_pushlstring">lua_pushlstring</A><BR>
-<A HREF="manual.html#lua_pushnil">lua_pushnil</A><BR>
-<A HREF="manual.html#lua_pushnumber">lua_pushnumber</A><BR>
-<A HREF="manual.html#lua_pushstring">lua_pushstring</A><BR>
-<A HREF="manual.html#lua_pushthread">lua_pushthread</A><BR>
-<A HREF="manual.html#lua_pushvalue">lua_pushvalue</A><BR>
-<A HREF="manual.html#lua_pushvfstring">lua_pushvfstring</A><BR>
-<A HREF="manual.html#lua_rawequal">lua_rawequal</A><BR>
-<A HREF="manual.html#lua_rawget">lua_rawget</A><BR>
-<A HREF="manual.html#lua_rawgeti">lua_rawgeti</A><BR>
-<A HREF="manual.html#lua_rawset">lua_rawset</A><BR>
-<A HREF="manual.html#lua_rawseti">lua_rawseti</A><BR>
-<A HREF="manual.html#lua_register">lua_register</A><BR>
-<A HREF="manual.html#lua_remove">lua_remove</A><BR>
-<A HREF="manual.html#lua_replace">lua_replace</A><BR>
-<A HREF="manual.html#lua_resume">lua_resume</A><BR>
-<A HREF="manual.html#lua_setallocf">lua_setallocf</A><BR>
-<A HREF="manual.html#lua_setfenv">lua_setfenv</A><BR>
-<A HREF="manual.html#lua_setfield">lua_setfield</A><BR>
-<A HREF="manual.html#lua_setglobal">lua_setglobal</A><BR>
-<A HREF="manual.html#lua_sethook">lua_sethook</A><BR>
-<A HREF="manual.html#lua_setlocal">lua_setlocal</A><BR>
-<A HREF="manual.html#lua_setmetatable">lua_setmetatable</A><BR>
-<A HREF="manual.html#lua_settable">lua_settable</A><BR>
-<A HREF="manual.html#lua_settop">lua_settop</A><BR>
-<A HREF="manual.html#lua_setupvalue">lua_setupvalue</A><BR>
-<A HREF="manual.html#lua_status">lua_status</A><BR>
-<A HREF="manual.html#lua_toboolean">lua_toboolean</A><BR>
-<A HREF="manual.html#lua_tocfunction">lua_tocfunction</A><BR>
-<A HREF="manual.html#lua_tointeger">lua_tointeger</A><BR>
-<A HREF="manual.html#lua_tolstring">lua_tolstring</A><BR>
-<A HREF="manual.html#lua_tonumber">lua_tonumber</A><BR>
-<A HREF="manual.html#lua_topointer">lua_topointer</A><BR>
-<A HREF="manual.html#lua_tostring">lua_tostring</A><BR>
-<A HREF="manual.html#lua_tothread">lua_tothread</A><BR>
-<A HREF="manual.html#lua_touserdata">lua_touserdata</A><BR>
-<A HREF="manual.html#lua_type">lua_type</A><BR>
-<A HREF="manual.html#lua_typename">lua_typename</A><BR>
-<A HREF="manual.html#lua_upvalueindex">lua_upvalueindex</A><BR>
-<A HREF="manual.html#lua_xmove">lua_xmove</A><BR>
-<A HREF="manual.html#lua_yield">lua_yield</A><BR>
-
-</TD>
-<TD>
-<H3>auxiliary library</H3>
-<A HREF="manual.html#luaL_Buffer">luaL_Buffer</A><BR>
-<A HREF="manual.html#luaL_Reg">luaL_Reg</A><BR>
-<P>
-
-<A HREF="manual.html#luaL_addchar">luaL_addchar</A><BR>
-<A HREF="manual.html#luaL_addlstring">luaL_addlstring</A><BR>
-<A HREF="manual.html#luaL_addsize">luaL_addsize</A><BR>
-<A HREF="manual.html#luaL_addstring">luaL_addstring</A><BR>
-<A HREF="manual.html#luaL_addvalue">luaL_addvalue</A><BR>
-<A HREF="manual.html#luaL_argcheck">luaL_argcheck</A><BR>
-<A HREF="manual.html#luaL_argerror">luaL_argerror</A><BR>
-<A HREF="manual.html#luaL_buffinit">luaL_buffinit</A><BR>
-<A HREF="manual.html#luaL_callmeta">luaL_callmeta</A><BR>
-<A HREF="manual.html#luaL_checkany">luaL_checkany</A><BR>
-<A HREF="manual.html#luaL_checkint">luaL_checkint</A><BR>
-<A HREF="manual.html#luaL_checkinteger">luaL_checkinteger</A><BR>
-<A HREF="manual.html#luaL_checklong">luaL_checklong</A><BR>
-<A HREF="manual.html#luaL_checklstring">luaL_checklstring</A><BR>
-<A HREF="manual.html#luaL_checknumber">luaL_checknumber</A><BR>
-<A HREF="manual.html#luaL_checkoption">luaL_checkoption</A><BR>
-<A HREF="manual.html#luaL_checkstack">luaL_checkstack</A><BR>
-<A HREF="manual.html#luaL_checkstring">luaL_checkstring</A><BR>
-<A HREF="manual.html#luaL_checktype">luaL_checktype</A><BR>
-<A HREF="manual.html#luaL_checkudata">luaL_checkudata</A><BR>
-<A HREF="manual.html#luaL_dofile">luaL_dofile</A><BR>
-<A HREF="manual.html#luaL_dostring">luaL_dostring</A><BR>
-<A HREF="manual.html#luaL_error">luaL_error</A><BR>
-<A HREF="manual.html#luaL_getmetafield">luaL_getmetafield</A><BR>
-<A HREF="manual.html#luaL_getmetatable">luaL_getmetatable</A><BR>
-<A HREF="manual.html#luaL_gsub">luaL_gsub</A><BR>
-<A HREF="manual.html#luaL_loadbuffer">luaL_loadbuffer</A><BR>
-<A HREF="manual.html#luaL_loadfile">luaL_loadfile</A><BR>
-<A HREF="manual.html#luaL_loadstring">luaL_loadstring</A><BR>
-<A HREF="manual.html#luaL_newmetatable">luaL_newmetatable</A><BR>
-<A HREF="manual.html#luaL_newstate">luaL_newstate</A><BR>
-<A HREF="manual.html#luaL_openlibs">luaL_openlibs</A><BR>
-<A HREF="manual.html#luaL_optint">luaL_optint</A><BR>
-<A HREF="manual.html#luaL_optinteger">luaL_optinteger</A><BR>
-<A HREF="manual.html#luaL_optlong">luaL_optlong</A><BR>
-<A HREF="manual.html#luaL_optlstring">luaL_optlstring</A><BR>
-<A HREF="manual.html#luaL_optnumber">luaL_optnumber</A><BR>
-<A HREF="manual.html#luaL_optstring">luaL_optstring</A><BR>
-<A HREF="manual.html#luaL_prepbuffer">luaL_prepbuffer</A><BR>
-<A HREF="manual.html#luaL_pushresult">luaL_pushresult</A><BR>
-<A HREF="manual.html#luaL_ref">luaL_ref</A><BR>
-<A HREF="manual.html#luaL_register">luaL_register</A><BR>
-<A HREF="manual.html#luaL_typename">luaL_typename</A><BR>
-<A HREF="manual.html#luaL_typerror">luaL_typerror</A><BR>
-<A HREF="manual.html#luaL_unref">luaL_unref</A><BR>
-<A HREF="manual.html#luaL_where">luaL_where</A><BR>
-
-</TD>
-</TR>
-</TABLE>
-<P>
-
-<HR>
-<SMALL CLASS="footer">
-Last update:
-Mon Feb 13 18:53:32 BRST 2012
-</SMALL>
-<!--
-Last change: revised for Lua 5.1.5
--->
-
-</BODY>
-</HTML>
diff --git a/extern/lua-5.1.5/doc/cover.png b/extern/lua-5.1.5/doc/cover.png
deleted file mode 100644
index 2dbb1981..00000000
Binary files a/extern/lua-5.1.5/doc/cover.png and /dev/null differ
diff --git a/extern/lua-5.1.5/doc/logo.gif b/extern/lua-5.1.5/doc/logo.gif
deleted file mode 100644
index 2f5e4ac2..00000000
Binary files a/extern/lua-5.1.5/doc/logo.gif and /dev/null differ
diff --git a/extern/lua-5.1.5/doc/lua.1 b/extern/lua-5.1.5/doc/lua.1
deleted file mode 100644
index 24809cc6..00000000
--- a/extern/lua-5.1.5/doc/lua.1
+++ /dev/null
@@ -1,163 +0,0 @@
-.\" $Id: lua.man,v 1.11 2006/01/06 16:03:34 lhf Exp $
-.TH LUA 1 "$Date: 2006/01/06 16:03:34 $"
-.SH NAME
-lua \- Lua interpreter
-.SH SYNOPSIS
-.B lua
-[
-.I options
-]
-[
-.I script
-[
-.I args
-]
-]
-.SH DESCRIPTION
-.B lua
-is the stand-alone Lua interpreter.
-It loads and executes Lua programs,
-either in textual source form or
-in precompiled binary form.
-(Precompiled binaries are output by
-.BR luac ,
-the Lua compiler.)
-.B lua
-can be used as a batch interpreter and also interactively.
-.LP
-The given
-.I options
-(see below)
-are executed and then
-the Lua program in file
-.I script
-is loaded and executed.
-The given
-.I args
-are available to
-.I script
-as strings in a global table named
-.BR arg .
-If these arguments contain spaces or other characters special to the shell,
-then they should be quoted
-(but note that the quotes will be removed by the shell).
-The arguments in
-.B arg
-start at 0,
-which contains the string
-.RI ' script '.
-The index of the last argument is stored in
-.BR arg.n .
-The arguments given in the command line before
-.IR script ,
-including the name of the interpreter,
-are available in negative indices in
-.BR arg .
-.LP
-At the very start,
-before even handling the command line,
-.B lua
-executes the contents of the environment variable
-.BR LUA_INIT ,
-if it is defined.
-If the value of
-.B LUA_INIT
-is of the form
-.RI '@ filename ',
-then
-.I filename
-is executed.
-Otherwise, the string is assumed to be a Lua statement and is executed.
-.LP
-Options start with
-.B '\-'
-and are described below.
-You can use
-.B "'\--'"
-to signal the end of options.
-.LP
-If no arguments are given,
-then
-.B "\-v \-i"
-is assumed when the standard input is a terminal;
-otherwise,
-.B "\-"
-is assumed.
-.LP
-In interactive mode,
-.B lua
-prompts the user,
-reads lines from the standard input,
-and executes them as they are read.
-If a line does not contain a complete statement,
-then a secondary prompt is displayed and
-lines are read until a complete statement is formed or
-a syntax error is found.
-So, one way to interrupt the reading of an incomplete statement is
-to force a syntax error:
-adding a
-.B ';' 
-in the middle of a statement is a sure way of forcing a syntax error
-(except inside multiline strings and comments; these must be closed explicitly).
-If a line starts with
-.BR '=' ,
-then
-.B lua
-displays the values of all the expressions in the remainder of the
-line. The expressions must be separated by commas.
-The primary prompt is the value of the global variable
-.BR _PROMPT ,
-if this value is a string;
-otherwise, the default prompt is used.
-Similarly, the secondary prompt is the value of the global variable
-.BR _PROMPT2 .
-So,
-to change the prompts,
-set the corresponding variable to a string of your choice.
-You can do that after calling the interpreter
-or on the command line
-(but in this case you have to be careful with quotes
-if the prompt string contains a space; otherwise you may confuse the shell.)
-The default prompts are "> " and ">> ".
-.SH OPTIONS
-.TP
-.B \-
-load and execute the standard input as a file,
-that is,
-not interactively,
-even when the standard input is a terminal.
-.TP
-.BI \-e " stat"
-execute statement
-.IR stat .
-You need to quote
-.I stat 
-if it contains spaces, quotes,
-or other characters special to the shell.
-.TP
-.B \-i
-enter interactive mode after
-.I script
-is executed.
-.TP
-.BI \-l " name"
-call
-.BI require(' name ')
-before executing
-.IR script .
-Typically used to load libraries.
-.TP
-.B \-v
-show version information.
-.SH "SEE ALSO"
-.BR luac (1)
-.br
-http://www.lua.org/
-.SH DIAGNOSTICS
-Error messages should be self explanatory.
-.SH AUTHORS
-R. Ierusalimschy,
-L. H. de Figueiredo,
-and
-W. Celes
-.\" EOF
diff --git a/extern/lua-5.1.5/doc/lua.css b/extern/lua-5.1.5/doc/lua.css
deleted file mode 100644
index 7fafbb1b..00000000
--- a/extern/lua-5.1.5/doc/lua.css
+++ /dev/null
@@ -1,83 +0,0 @@
-body {
-	color: #000000 ;
-	background-color: #FFFFFF ;
-	font-family: Helvetica, Arial, sans-serif ;
-	text-align: justify ;
-	margin-right: 30px ;
-	margin-left: 30px ;
-}
-
-h1, h2, h3, h4 {
-	font-family: Verdana, Geneva, sans-serif ;
-	font-weight: normal ;
-	font-style: italic ;
-}
-
-h2 {
-	padding-top: 0.4em ;
-	padding-bottom: 0.4em ;
-	padding-left: 30px ;
-	padding-right: 30px ;
-	margin-left: -30px ;
-	background-color: #E0E0FF ;
-}
-
-h3 {
-	padding-left: 0.5em ;
-	border-left: solid #E0E0FF 1em ;
-}
-
-table h3 {
-	padding-left: 0px ;
-	border-left: none ;
-}
-
-a:link {
-	color: #000080 ;
-	background-color: inherit ;
-	text-decoration: none ;
-}
-
-a:visited {
-	background-color: inherit ;
-	text-decoration: none ;
-}
-
-a:link:hover, a:visited:hover {
-	color: #000080 ;
-	background-color: #E0E0FF ;
-}
-
-a:link:active, a:visited:active {
-	color: #FF0000 ;
-}
-
-hr {
-	border: 0 ;
-	height: 1px ;
-	color: #a0a0a0 ;
-	background-color: #a0a0a0 ;
-}
-
-:target {
-	background-color: #F8F8F8 ;
-	padding: 8px ;
-	border: solid #a0a0a0 2px ;
-}
-
-.footer {
-	color: gray ;
-	font-size: small ;
-}
-
-input[type=text] {
-	border: solid #a0a0a0 2px ;
-	border-radius: 2em ;
-	-moz-border-radius: 2em ;
-	background-image: url('images/search.png') ;
-	background-repeat: no-repeat;
-	background-position: 4px center ;
-	padding-left: 20px ;
-	height: 2em ;
-}
-
diff --git a/extern/lua-5.1.5/doc/lua.html b/extern/lua-5.1.5/doc/lua.html
deleted file mode 100644
index 1d435ab0..00000000
--- a/extern/lua-5.1.5/doc/lua.html
+++ /dev/null
@@ -1,172 +0,0 @@
-<!-- $Id: lua.man,v 1.11 2006/01/06 16:03:34 lhf Exp $ -->
-<HTML>
-<HEAD>
-<TITLE>LUA man page</TITLE>
-<LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
-</HEAD>
-
-<BODY BGCOLOR="#FFFFFF">
-
-<H2>NAME</H2>
-lua - Lua interpreter
-<H2>SYNOPSIS</H2>
-<B>lua</B>
-[
-<I>options</I>
-]
-[
-<I>script</I>
-[
-<I>args</I>
-]
-]
-<H2>DESCRIPTION</H2>
-<B>lua</B>
-is the stand-alone Lua interpreter.
-It loads and executes Lua programs,
-either in textual source form or
-in precompiled binary form.
-(Precompiled binaries are output by
-<B>luac</B>,
-the Lua compiler.)
-<B>lua</B>
-can be used as a batch interpreter and also interactively.
-<P>
-The given
-<I>options</I>
-(see below)
-are executed and then
-the Lua program in file
-<I>script</I>
-is loaded and executed.
-The given
-<I>args</I>
-are available to
-<I>script</I>
-as strings in a global table named
-<B>arg</B>.
-If these arguments contain spaces or other characters special to the shell,
-then they should be quoted
-(but note that the quotes will be removed by the shell).
-The arguments in
-<B>arg</B>
-start at 0,
-which contains the string
-'<I>script</I>'.
-The index of the last argument is stored in
-<B>arg.n</B>.
-The arguments given in the command line before
-<I>script</I>,
-including the name of the interpreter,
-are available in negative indices in
-<B>arg</B>.
-<P>
-At the very start,
-before even handling the command line,
-<B>lua</B>
-executes the contents of the environment variable
-<B>LUA_INIT</B>,
-if it is defined.
-If the value of
-<B>LUA_INIT</B>
-is of the form
-'@<I>filename</I>',
-then
-<I>filename</I>
-is executed.
-Otherwise, the string is assumed to be a Lua statement and is executed.
-<P>
-Options start with
-<B>'-'</B>
-and are described below.
-You can use
-<B>'--'</B>
-to signal the end of options.
-<P>
-If no arguments are given,
-then
-<B>"-v -i"</B>
-is assumed when the standard input is a terminal;
-otherwise,
-<B>"-"</B>
-is assumed.
-<P>
-In interactive mode,
-<B>lua</B>
-prompts the user,
-reads lines from the standard input,
-and executes them as they are read.
-If a line does not contain a complete statement,
-then a secondary prompt is displayed and
-lines are read until a complete statement is formed or
-a syntax error is found.
-So, one way to interrupt the reading of an incomplete statement is
-to force a syntax error:
-adding a
-<B>';'</B>
-in the middle of a statement is a sure way of forcing a syntax error
-(except inside multiline strings and comments; these must be closed explicitly).
-If a line starts with
-<B>'='</B>,
-then
-<B>lua</B>
-displays the values of all the expressions in the remainder of the
-line. The expressions must be separated by commas.
-The primary prompt is the value of the global variable
-<B>_PROMPT</B>,
-if this value is a string;
-otherwise, the default prompt is used.
-Similarly, the secondary prompt is the value of the global variable
-<B>_PROMPT2</B>.
-So,
-to change the prompts,
-set the corresponding variable to a string of your choice.
-You can do that after calling the interpreter
-or on the command line
-(but in this case you have to be careful with quotes
-if the prompt string contains a space; otherwise you may confuse the shell.)
-The default prompts are "&gt; " and "&gt;&gt; ".
-<H2>OPTIONS</H2>
-<P>
-<B>-</B>
-load and execute the standard input as a file,
-that is,
-not interactively,
-even when the standard input is a terminal.
-<P>
-<B>-e </B><I>stat</I>
-execute statement
-<I>stat</I>.
-You need to quote
-<I>stat </I>
-if it contains spaces, quotes,
-or other characters special to the shell.
-<P>
-<B>-i</B>
-enter interactive mode after
-<I>script</I>
-is executed.
-<P>
-<B>-l </B><I>name</I>
-call
-<B>require</B>('<I>name</I>')
-before executing
-<I>script</I>.
-Typically used to load libraries.
-<P>
-<B>-v</B>
-show version information.
-<H2>SEE ALSO</H2>
-<B>luac</B>(1)
-<BR>
-<A HREF="http://www.lua.org/">http://www.lua.org/</A>
-<H2>DIAGNOSTICS</H2>
-Error messages should be self explanatory.
-<H2>AUTHORS</H2>
-R. Ierusalimschy,
-L. H. de Figueiredo,
-and
-W. Celes
-<!-- EOF -->
-</BODY>
-</HTML>
diff --git a/extern/lua-5.1.5/doc/luac.1 b/extern/lua-5.1.5/doc/luac.1
deleted file mode 100644
index d8146782..00000000
--- a/extern/lua-5.1.5/doc/luac.1
+++ /dev/null
@@ -1,136 +0,0 @@
-.\" $Id: luac.man,v 1.28 2006/01/06 16:03:34 lhf Exp $
-.TH LUAC 1 "$Date: 2006/01/06 16:03:34 $"
-.SH NAME
-luac \- Lua compiler
-.SH SYNOPSIS
-.B luac
-[
-.I options
-] [
-.I filenames
-]
-.SH DESCRIPTION
-.B luac
-is the Lua compiler.
-It translates programs written in the Lua programming language
-into binary files that can be later loaded and executed.
-.LP
-The main advantages of precompiling chunks are:
-faster loading,
-protecting source code from accidental user changes,
-and
-off-line syntax checking.
-.LP
-Pre-compiling does not imply faster execution
-because in Lua chunks are always compiled into bytecodes before being executed.
-.B luac
-simply allows those bytecodes to be saved in a file for later execution.
-.LP
-Pre-compiled chunks are not necessarily smaller than the corresponding source.
-The main goal in pre-compiling is faster loading.
-.LP
-The binary files created by
-.B luac
-are portable only among architectures with the same word size and byte order.
-.LP
-.B luac
-produces a single output file containing the bytecodes
-for all source files given.
-By default,
-the output file is named
-.BR luac.out ,
-but you can change this with the
-.B \-o
-option.
-.LP
-In the command line,
-you can mix
-text files containing Lua source and
-binary files containing precompiled chunks.
-This is useful to combine several precompiled chunks,
-even from different (but compatible) platforms,
-into a single precompiled chunk.
-.LP
-You can use
-.B "'\-'"
-to indicate the standard input as a source file
-and
-.B "'\--'"
-to signal the end of options
-(that is,
-all remaining arguments will be treated as files even if they start with
-.BR "'\-'" ).
-.LP
-The internal format of the binary files produced by
-.B luac
-is likely to change when a new version of Lua is released.
-So,
-save the source files of all Lua programs that you precompile.
-.LP
-.SH OPTIONS
-Options must be separate.
-.TP
-.B \-l
-produce a listing of the compiled bytecode for Lua's virtual machine.
-Listing bytecodes is useful to learn about Lua's virtual machine.
-If no files are given, then
-.B luac
-loads
-.B luac.out
-and lists its contents.
-.TP
-.BI \-o " file"
-output to
-.IR file ,
-instead of the default
-.BR luac.out .
-(You can use
-.B "'\-'"
-for standard output,
-but not on platforms that open standard output in text mode.)
-The output file may be a source file because
-all files are loaded before the output file is written.
-Be careful not to overwrite precious files.
-.TP
-.B \-p
-load files but do not generate any output file.
-Used mainly for syntax checking and for testing precompiled chunks:
-corrupted files will probably generate errors when loaded.
-Lua always performs a thorough integrity test on precompiled chunks.
-Bytecode that passes this test is completely safe,
-in the sense that it will not break the interpreter.
-However,
-there is no guarantee that such code does anything sensible.
-(None can be given, because the halting problem is unsolvable.)
-If no files are given, then
-.B luac
-loads
-.B luac.out
-and tests its contents.
-No messages are displayed if the file passes the integrity test.
-.TP
-.B \-s
-strip debug information before writing the output file.
-This saves some space in very large chunks,
-but if errors occur when running a stripped chunk,
-then the error messages may not contain the full information they usually do.
-For instance,
-line numbers and names of local variables are lost.
-.TP
-.B \-v
-show version information.
-.SH FILES
-.TP 15
-.B luac.out
-default output file
-.SH "SEE ALSO"
-.BR lua (1)
-.br
-http://www.lua.org/
-.SH DIAGNOSTICS
-Error messages should be self explanatory.
-.SH AUTHORS
-L. H. de Figueiredo,
-R. Ierusalimschy and
-W. Celes
-.\" EOF
diff --git a/extern/lua-5.1.5/doc/luac.html b/extern/lua-5.1.5/doc/luac.html
deleted file mode 100644
index 179ffe82..00000000
--- a/extern/lua-5.1.5/doc/luac.html
+++ /dev/null
@@ -1,145 +0,0 @@
-<!-- $Id: luac.man,v 1.28 2006/01/06 16:03:34 lhf Exp $ -->
-<HTML>
-<HEAD>
-<TITLE>LUAC man page</TITLE>
-<LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
-</HEAD>
-
-<BODY BGCOLOR="#FFFFFF">
-
-<H2>NAME</H2>
-luac - Lua compiler
-<H2>SYNOPSIS</H2>
-<B>luac</B>
-[
-<I>options</I>
-] [
-<I>filenames</I>
-]
-<H2>DESCRIPTION</H2>
-<B>luac</B>
-is the Lua compiler.
-It translates programs written in the Lua programming language
-into binary files that can be later loaded and executed.
-<P>
-The main advantages of precompiling chunks are:
-faster loading,
-protecting source code from accidental user changes,
-and
-off-line syntax checking.
-<P>
-Precompiling does not imply faster execution
-because in Lua chunks are always compiled into bytecodes before being executed.
-<B>luac</B>
-simply allows those bytecodes to be saved in a file for later execution.
-<P>
-Precompiled chunks are not necessarily smaller than the corresponding source.
-The main goal in precompiling is faster loading.
-<P>
-The binary files created by
-<B>luac</B>
-are portable only among architectures with the same word size and byte order.
-<P>
-<B>luac</B>
-produces a single output file containing the bytecodes
-for all source files given.
-By default,
-the output file is named
-<B>luac.out</B>,
-but you can change this with the
-<B>-o</B>
-option.
-<P>
-In the command line,
-you can mix
-text files containing Lua source and
-binary files containing precompiled chunks.
-This is useful because several precompiled chunks,
-even from different (but compatible) platforms,
-can be combined into a single precompiled chunk.
-<P>
-You can use
-<B>'-'</B>
-to indicate the standard input as a source file
-and
-<B>'--'</B>
-to signal the end of options
-(that is,
-all remaining arguments will be treated as files even if they start with
-<B>'-'</B>).
-<P>
-The internal format of the binary files produced by
-<B>luac</B>
-is likely to change when a new version of Lua is released.
-So,
-save the source files of all Lua programs that you precompile.
-<P>
-<H2>OPTIONS</H2>
-Options must be separate.
-<P>
-<B>-l</B>
-produce a listing of the compiled bytecode for Lua's virtual machine.
-Listing bytecodes is useful to learn about Lua's virtual machine.
-If no files are given, then
-<B>luac</B>
-loads
-<B>luac.out</B>
-and lists its contents.
-<P>
-<B>-o </B><I>file</I>
-output to
-<I>file</I>,
-instead of the default
-<B>luac.out</B>.
-(You can use
-<B>'-'</B>
-for standard output,
-but not on platforms that open standard output in text mode.)
-The output file may be a source file because
-all files are loaded before the output file is written.
-Be careful not to overwrite precious files.
-<P>
-<B>-p</B>
-load files but do not generate any output file.
-Used mainly for syntax checking and for testing precompiled chunks:
-corrupted files will probably generate errors when loaded.
-Lua always performs a thorough integrity test on precompiled chunks.
-Bytecode that passes this test is completely safe,
-in the sense that it will not break the interpreter.
-However,
-there is no guarantee that such code does anything sensible.
-(None can be given, because the halting problem is unsolvable.)
-If no files are given, then
-<B>luac</B>
-loads
-<B>luac.out</B>
-and tests its contents.
-No messages are displayed if the file passes the integrity test.
-<P>
-<B>-s</B>
-strip debug information before writing the output file.
-This saves some space in very large chunks,
-but if errors occur when running a stripped chunk,
-then the error messages may not contain the full information they usually do.
-For instance,
-line numbers and names of local variables are lost.
-<P>
-<B>-v</B>
-show version information.
-<H2>FILES</H2>
-<P>
-<B>luac.out</B>
-default output file
-<H2>SEE ALSO</H2>
-<B>lua</B>(1)
-<BR>
-<A HREF="http://www.lua.org/">http://www.lua.org/</A>
-<H2>DIAGNOSTICS</H2>
-Error messages should be self explanatory.
-<H2>AUTHORS</H2>
-L. H. de Figueiredo,
-R. Ierusalimschy and
-W. Celes
-<!-- EOF -->
-</BODY>
-</HTML>
diff --git a/extern/lua-5.1.5/doc/manual.css b/extern/lua-5.1.5/doc/manual.css
deleted file mode 100644
index b49b3629..00000000
--- a/extern/lua-5.1.5/doc/manual.css
+++ /dev/null
@@ -1,24 +0,0 @@
-h3 code {
-	font-family: inherit ;
-	font-size: inherit ;
-}
-
-pre, code {
-	font-size: 12pt ;
-}
-
-span.apii {
-	float: right ;
-	font-family: inherit ;
-	font-style: normal ;
-	font-size: small ;
-	color: gray ;
-}
-
-p+h1, ul+h1 {
-	padding-top: 0.4em ;
-	padding-bottom: 0.4em ;
-	padding-left: 30px ;
-	margin-left: -30px ;
-	background-color: #E0E0FF ;
-}
diff --git a/extern/lua-5.1.5/doc/manual.html b/extern/lua-5.1.5/doc/manual.html
deleted file mode 100644
index 4e41683d..00000000
--- a/extern/lua-5.1.5/doc/manual.html
+++ /dev/null
@@ -1,8804 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-
-<head>
-<title>Lua 5.1 Reference Manual</title>
-<link rel="stylesheet" type="text/css" href="lua.css">
-<link rel="stylesheet" type="text/css" href="manual.css">
-<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-1">
-</head>
-
-<body>
-
-<hr>
-<h1>
-<a href="http://www.lua.org/"><img src="logo.gif" alt="" border="0"></a>
-Lua 5.1 Reference Manual
-</h1>
-
-by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
-<p>
-<small>
-Copyright &copy; 2006&ndash;2012 Lua.org, PUC-Rio.
-Freely available under the terms of the
-<a href="http://www.lua.org/license.html">Lua license</a>.
-</small>
-<hr>
-<p>
-
-<a href="contents.html#contents">contents</A>
-&middot;
-<a href="contents.html#index">index</A>
-&middot;
-<A HREF="http://www.lua.org/manual/">other versions</A>
-
-<!-- ====================================================================== -->
-<p>
-
-<!-- $Id: manual.of,v 1.49.1.2 2012/01/13 20:23:26 roberto Exp $ -->
-
-
-
-
-<h1>1 - <a name="1">Introduction</a></h1>
-
-<p>
-Lua is an extension programming language designed to support
-general procedural programming with data description
-facilities.
-It also offers good support for object-oriented programming,
-functional programming, and data-driven programming.
-Lua is intended to be used as a powerful, light-weight
-scripting language for any program that needs one.
-Lua is implemented as a library, written in <em>clean</em> C
-(that is, in the common subset of ANSI&nbsp;C and C++).
-
-
-<p>
-Being an extension language, Lua has no notion of a "main" program:
-it only works <em>embedded</em> in a host client,
-called the <em>embedding program</em> or simply the <em>host</em>.
-This host program can invoke functions to execute a piece of Lua code,
-can write and read Lua variables,
-and can register C&nbsp;functions to be called by Lua code.
-Through the use of C&nbsp;functions, Lua can be augmented to cope with
-a wide range of different domains,
-thus creating customized programming languages sharing a syntactical framework.
-The Lua distribution includes a sample host program called <code>lua</code>,
-which uses the Lua library to offer a complete, stand-alone Lua interpreter.
-
-
-<p>
-Lua is free software,
-and is provided as usual with no guarantees,
-as stated in its license.
-The implementation described in this manual is available
-at Lua's official web site, <code>www.lua.org</code>.
-
-
-<p>
-Like any other reference manual,
-this document is dry in places.
-For a discussion of the decisions behind the design of Lua,
-see the technical papers available at Lua's web site.
-For a detailed introduction to programming in Lua,
-see Roberto's book, <em>Programming in Lua (Second Edition)</em>.
-
-
-
-<h1>2 - <a name="2">The Language</a></h1>
-
-<p>
-This section describes the lexis, the syntax, and the semantics of Lua.
-In other words,
-this section describes
-which tokens are valid,
-how they can be combined,
-and what their combinations mean.
-
-
-<p>
-The language constructs will be explained using the usual extended BNF notation,
-in which
-{<em>a</em>}&nbsp;means&nbsp;0 or more <em>a</em>'s, and
-[<em>a</em>]&nbsp;means an optional <em>a</em>.
-Non-terminals are shown like non-terminal,
-keywords are shown like <b>kword</b>,
-and other terminal symbols are shown like `<b>=</b>&acute;.
-The complete syntax of Lua can be found in <a href="#8">&sect;8</a>
-at the end of this manual.
-
-
-
-<h2>2.1 - <a name="2.1">Lexical Conventions</a></h2>
-
-<p>
-<em>Names</em>
-(also called <em>identifiers</em>)
-in Lua can be any string of letters,
-digits, and underscores,
-not beginning with a digit.
-This coincides with the definition of names in most languages.
-(The definition of letter depends on the current locale:
-any character considered alphabetic by the current locale
-can be used in an identifier.)
-Identifiers are used to name variables and table fields.
-
-
-<p>
-The following <em>keywords</em> are reserved
-and cannot be used as names:
-
-
-<pre>
-     and       break     do        else      elseif
-     end       false     for       function  if
-     in        local     nil       not       or
-     repeat    return    then      true      until     while
-</pre>
-
-<p>
-Lua is a case-sensitive language:
-<code>and</code> is a reserved word, but <code>And</code> and <code>AND</code>
-are two different, valid names.
-As a convention, names starting with an underscore followed by
-uppercase letters (such as <a href="#pdf-_VERSION"><code>_VERSION</code></a>)
-are reserved for internal global variables used by Lua.
-
-
-<p>
-The following strings denote other tokens:
-
-<pre>
-     +     -     *     /     %     ^     #
-     ==    ~=    &lt;=    &gt;=    &lt;     &gt;     =
-     (     )     {     }     [     ]
-     ;     :     ,     .     ..    ...
-</pre>
-
-<p>
-<em>Literal strings</em>
-can be delimited by matching single or double quotes,
-and can contain the following C-like escape sequences:
-'<code>\a</code>' (bell),
-'<code>\b</code>' (backspace),
-'<code>\f</code>' (form feed),
-'<code>\n</code>' (newline),
-'<code>\r</code>' (carriage return),
-'<code>\t</code>' (horizontal tab),
-'<code>\v</code>' (vertical tab),
-'<code>\\</code>' (backslash),
-'<code>\"</code>' (quotation mark [double quote]),
-and '<code>\'</code>' (apostrophe [single quote]).
-Moreover, a backslash followed by a real newline
-results in a newline in the string.
-A character in a string can also be specified by its numerical value
-using the escape sequence <code>\<em>ddd</em></code>,
-where <em>ddd</em> is a sequence of up to three decimal digits.
-(Note that if a numerical escape is to be followed by a digit,
-it must be expressed using exactly three digits.)
-Strings in Lua can contain any 8-bit value, including embedded zeros,
-which can be specified as '<code>\0</code>'.
-
-
-<p>
-Literal strings can also be defined using a long format
-enclosed by <em>long brackets</em>.
-We define an <em>opening long bracket of level <em>n</em></em> as an opening
-square bracket followed by <em>n</em> equal signs followed by another
-opening square bracket.
-So, an opening long bracket of level&nbsp;0 is written as <code>[[</code>,
-an opening long bracket of level&nbsp;1 is written as <code>[=[</code>,
-and so on.
-A <em>closing long bracket</em> is defined similarly;
-for instance, a closing long bracket of level&nbsp;4 is written as <code>]====]</code>.
-A long string starts with an opening long bracket of any level and
-ends at the first closing long bracket of the same level.
-Literals in this bracketed form can run for several lines,
-do not interpret any escape sequences,
-and ignore long brackets of any other level.
-They can contain anything except a closing bracket of the proper level.
-
-
-<p>
-For convenience,
-when the opening long bracket is immediately followed by a newline,
-the newline is not included in the string.
-As an example, in a system using ASCII
-(in which '<code>a</code>' is coded as&nbsp;97,
-newline is coded as&nbsp;10, and '<code>1</code>' is coded as&nbsp;49),
-the five literal strings below denote the same string:
-
-<pre>
-     a = 'alo\n123"'
-     a = "alo\n123\""
-     a = '\97lo\10\04923"'
-     a = [[alo
-     123"]]
-     a = [==[
-     alo
-     123"]==]
-</pre>
-
-<p>
-A <em>numerical constant</em> can be written with an optional decimal part
-and an optional decimal exponent.
-Lua also accepts integer hexadecimal constants,
-by prefixing them with <code>0x</code>.
-Examples of valid numerical constants are
-
-<pre>
-     3   3.0   3.1416   314.16e-2   0.31416E1   0xff   0x56
-</pre>
-
-<p>
-A <em>comment</em> starts with a double hyphen (<code>--</code>)
-anywhere outside a string.
-If the text immediately after <code>--</code> is not an opening long bracket,
-the comment is a <em>short comment</em>,
-which runs until the end of the line.
-Otherwise, it is a <em>long comment</em>,
-which runs until the corresponding closing long bracket.
-Long comments are frequently used to disable code temporarily.
-
-
-
-
-
-<h2>2.2 - <a name="2.2">Values and Types</a></h2>
-
-<p>
-Lua is a <em>dynamically typed language</em>.
-This means that
-variables do not have types; only values do.
-There are no type definitions in the language.
-All values carry their own type.
-
-
-<p>
-All values in Lua are <em>first-class values</em>.
-This means that all values can be stored in variables,
-passed as arguments to other functions, and returned as results.
-
-
-<p>
-There are eight basic types in Lua:
-<em>nil</em>, <em>boolean</em>, <em>number</em>,
-<em>string</em>, <em>function</em>, <em>userdata</em>,
-<em>thread</em>, and <em>table</em>.
-<em>Nil</em> is the type of the value <b>nil</b>,
-whose main property is to be different from any other value;
-it usually represents the absence of a useful value.
-<em>Boolean</em> is the type of the values <b>false</b> and <b>true</b>.
-Both <b>nil</b> and <b>false</b> make a condition false;
-any other value makes it true.
-<em>Number</em> represents real (double-precision floating-point) numbers.
-(It is easy to build Lua interpreters that use other
-internal representations for numbers,
-such as single-precision float or long integers;
-see file <code>luaconf.h</code>.)
-<em>String</em> represents arrays of characters.
-
-Lua is 8-bit clean:
-strings can contain any 8-bit character,
-including embedded zeros ('<code>\0</code>') (see <a href="#2.1">&sect;2.1</a>).
-
-
-<p>
-Lua can call (and manipulate) functions written in Lua and
-functions written in C
-(see <a href="#2.5.8">&sect;2.5.8</a>).
-
-
-<p>
-The type <em>userdata</em> is provided to allow arbitrary C&nbsp;data to
-be stored in Lua variables.
-This type corresponds to a block of raw memory
-and has no pre-defined operations in Lua,
-except assignment and identity test.
-However, by using <em>metatables</em>,
-the programmer can define operations for userdata values
-(see <a href="#2.8">&sect;2.8</a>).
-Userdata values cannot be created or modified in Lua,
-only through the C&nbsp;API.
-This guarantees the integrity of data owned by the host program.
-
-
-<p>
-The type <em>thread</em> represents independent threads of execution
-and it is used to implement coroutines (see <a href="#2.11">&sect;2.11</a>).
-Do not confuse Lua threads with operating-system threads.
-Lua supports coroutines on all systems,
-even those that do not support threads.
-
-
-<p>
-The type <em>table</em> implements associative arrays,
-that is, arrays that can be indexed not only with numbers,
-but with any value (except <b>nil</b>).
-Tables can be <em>heterogeneous</em>;
-that is, they can contain values of all types (except <b>nil</b>).
-Tables are the sole data structuring mechanism in Lua;
-they can be used to represent ordinary arrays,
-symbol tables, sets, records, graphs, trees, etc.
-To represent records, Lua uses the field name as an index.
-The language supports this representation by
-providing <code>a.name</code> as syntactic sugar for <code>a["name"]</code>.
-There are several convenient ways to create tables in Lua
-(see <a href="#2.5.7">&sect;2.5.7</a>).
-
-
-<p>
-Like indices,
-the value of a table field can be of any type (except <b>nil</b>).
-In particular,
-because functions are first-class values,
-table fields can contain functions.
-Thus tables can also carry <em>methods</em> (see <a href="#2.5.9">&sect;2.5.9</a>).
-
-
-<p>
-Tables, functions, threads, and (full) userdata values are <em>objects</em>:
-variables do not actually <em>contain</em> these values,
-only <em>references</em> to them.
-Assignment, parameter passing, and function returns
-always manipulate references to such values;
-these operations do not imply any kind of copy.
-
-
-<p>
-The library function <a href="#pdf-type"><code>type</code></a> returns a string describing the type
-of a given value.
-
-
-
-<h3>2.2.1 - <a name="2.2.1">Coercion</a></h3>
-
-<p>
-Lua provides automatic conversion between
-string and number values at run time.
-Any arithmetic operation applied to a string tries to convert
-this string to a number, following the usual conversion rules.
-Conversely, whenever a number is used where a string is expected,
-the number is converted to a string, in a reasonable format.
-For complete control over how numbers are converted to strings,
-use the <code>format</code> function from the string library
-(see <a href="#pdf-string.format"><code>string.format</code></a>).
-
-
-
-
-
-
-
-<h2>2.3 - <a name="2.3">Variables</a></h2>
-
-<p>
-Variables are places that store values.
-
-There are three kinds of variables in Lua:
-global variables, local variables, and table fields.
-
-
-<p>
-A single name can denote a global variable or a local variable
-(or a function's formal parameter,
-which is a particular kind of local variable):
-
-<pre>
-	var ::= Name
-</pre><p>
-Name denotes identifiers, as defined in <a href="#2.1">&sect;2.1</a>.
-
-
-<p>
-Any variable is assumed to be global unless explicitly declared
-as a local (see <a href="#2.4.7">&sect;2.4.7</a>).
-Local variables are <em>lexically scoped</em>:
-local variables can be freely accessed by functions
-defined inside their scope (see <a href="#2.6">&sect;2.6</a>).
-
-
-<p>
-Before the first assignment to a variable, its value is <b>nil</b>.
-
-
-<p>
-Square brackets are used to index a table:
-
-<pre>
-	var ::= prefixexp `<b>[</b>&acute; exp `<b>]</b>&acute;
-</pre><p>
-The meaning of accesses to global variables 
-and table fields can be changed via metatables.
-An access to an indexed variable <code>t[i]</code> is equivalent to
-a call <code>gettable_event(t,i)</code>.
-(See <a href="#2.8">&sect;2.8</a> for a complete description of the
-<code>gettable_event</code> function.
-This function is not defined or callable in Lua.
-We use it here only for explanatory purposes.)
-
-
-<p>
-The syntax <code>var.Name</code> is just syntactic sugar for
-<code>var["Name"]</code>:
-
-<pre>
-	var ::= prefixexp `<b>.</b>&acute; Name
-</pre>
-
-<p>
-All global variables live as fields in ordinary Lua tables,
-called <em>environment tables</em> or simply
-<em>environments</em> (see <a href="#2.9">&sect;2.9</a>).
-Each function has its own reference to an environment,
-so that all global variables in this function
-will refer to this environment table.
-When a function is created,
-it inherits the environment from the function that created it.
-To get the environment table of a Lua function,
-you call <a href="#pdf-getfenv"><code>getfenv</code></a>.
-To replace it,
-you call <a href="#pdf-setfenv"><code>setfenv</code></a>.
-(You can only manipulate the environment of C&nbsp;functions
-through the debug library; (see <a href="#5.9">&sect;5.9</a>).)
-
-
-<p>
-An access to a global variable <code>x</code>
-is equivalent to <code>_env.x</code>,
-which in turn is equivalent to
-
-<pre>
-     gettable_event(_env, "x")
-</pre><p>
-where <code>_env</code> is the environment of the running function.
-(See <a href="#2.8">&sect;2.8</a> for a complete description of the
-<code>gettable_event</code> function.
-This function is not defined or callable in Lua.
-Similarly, the <code>_env</code> variable is not defined in Lua.
-We use them here only for explanatory purposes.)
-
-
-
-
-
-<h2>2.4 - <a name="2.4">Statements</a></h2>
-
-<p>
-Lua supports an almost conventional set of statements,
-similar to those in Pascal or C.
-This set includes
-assignments, control structures, function calls,
-and variable declarations.
-
-
-
-<h3>2.4.1 - <a name="2.4.1">Chunks</a></h3>
-
-<p>
-The unit of execution of Lua is called a <em>chunk</em>.
-A chunk is simply a sequence of statements,
-which are executed sequentially.
-Each statement can be optionally followed by a semicolon:
-
-<pre>
-	chunk ::= {stat [`<b>;</b>&acute;]}
-</pre><p>
-There are no empty statements and thus '<code>;;</code>' is not legal.
-
-
-<p>
-Lua handles a chunk as the body of an anonymous function 
-with a variable number of arguments
-(see <a href="#2.5.9">&sect;2.5.9</a>).
-As such, chunks can define local variables,
-receive arguments, and return values.
-
-
-<p>
-A chunk can be stored in a file or in a string inside the host program.
-To execute a chunk,
-Lua first pre-compiles the chunk into instructions for a virtual machine,
-and then it executes the compiled code
-with an interpreter for the virtual machine.
-
-
-<p>
-Chunks can also be pre-compiled into binary form;
-see program <code>luac</code> for details.
-Programs in source and compiled forms are interchangeable;
-Lua automatically detects the file type and acts accordingly.
-
-
-
-
-
-
-<h3>2.4.2 - <a name="2.4.2">Blocks</a></h3><p>
-A block is a list of statements;
-syntactically, a block is the same as a chunk:
-
-<pre>
-	block ::= chunk
-</pre>
-
-<p>
-A block can be explicitly delimited to produce a single statement:
-
-<pre>
-	stat ::= <b>do</b> block <b>end</b>
-</pre><p>
-Explicit blocks are useful
-to control the scope of variable declarations.
-Explicit blocks are also sometimes used to
-add a <b>return</b> or <b>break</b> statement in the middle
-of another block (see <a href="#2.4.4">&sect;2.4.4</a>).
-
-
-
-
-
-<h3>2.4.3 - <a name="2.4.3">Assignment</a></h3>
-
-<p>
-Lua allows multiple assignments.
-Therefore, the syntax for assignment
-defines a list of variables on the left side
-and a list of expressions on the right side.
-The elements in both lists are separated by commas:
-
-<pre>
-	stat ::= varlist `<b>=</b>&acute; explist
-	varlist ::= var {`<b>,</b>&acute; var}
-	explist ::= exp {`<b>,</b>&acute; exp}
-</pre><p>
-Expressions are discussed in <a href="#2.5">&sect;2.5</a>.
-
-
-<p>
-Before the assignment,
-the list of values is <em>adjusted</em> to the length of
-the list of variables.
-If there are more values than needed,
-the excess values are thrown away.
-If there are fewer values than needed,
-the list is extended with as many  <b>nil</b>'s as needed.
-If the list of expressions ends with a function call,
-then all values returned by that call enter the list of values,
-before the adjustment
-(except when the call is enclosed in parentheses; see <a href="#2.5">&sect;2.5</a>).
-
-
-<p>
-The assignment statement first evaluates all its expressions
-and only then are the assignments performed.
-Thus the code
-
-<pre>
-     i = 3
-     i, a[i] = i+1, 20
-</pre><p>
-sets <code>a[3]</code> to 20, without affecting <code>a[4]</code>
-because the <code>i</code> in <code>a[i]</code> is evaluated (to 3)
-before it is assigned&nbsp;4.
-Similarly, the line
-
-<pre>
-     x, y = y, x
-</pre><p>
-exchanges the values of <code>x</code> and <code>y</code>,
-and
-
-<pre>
-     x, y, z = y, z, x
-</pre><p>
-cyclically permutes the values of <code>x</code>, <code>y</code>, and <code>z</code>.
-
-
-<p>
-The meaning of assignments to global variables
-and table fields can be changed via metatables.
-An assignment to an indexed variable <code>t[i] = val</code> is equivalent to
-<code>settable_event(t,i,val)</code>.
-(See <a href="#2.8">&sect;2.8</a> for a complete description of the
-<code>settable_event</code> function.
-This function is not defined or callable in Lua.
-We use it here only for explanatory purposes.)
-
-
-<p>
-An assignment to a global variable <code>x = val</code>
-is equivalent to the assignment
-<code>_env.x = val</code>,
-which in turn is equivalent to
-
-<pre>
-     settable_event(_env, "x", val)
-</pre><p>
-where <code>_env</code> is the environment of the running function.
-(The <code>_env</code> variable is not defined in Lua.
-We use it here only for explanatory purposes.)
-
-
-
-
-
-<h3>2.4.4 - <a name="2.4.4">Control Structures</a></h3><p>
-The control structures
-<b>if</b>, <b>while</b>, and <b>repeat</b> have the usual meaning and
-familiar syntax:
-
-
-
-
-<pre>
-	stat ::= <b>while</b> exp <b>do</b> block <b>end</b>
-	stat ::= <b>repeat</b> block <b>until</b> exp
-	stat ::= <b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b>
-</pre><p>
-Lua also has a <b>for</b> statement, in two flavors (see <a href="#2.4.5">&sect;2.4.5</a>).
-
-
-<p>
-The condition expression of a
-control structure can return any value.
-Both <b>false</b> and <b>nil</b> are considered false.
-All values different from <b>nil</b> and <b>false</b> are considered true
-(in particular, the number 0 and the empty string are also true).
-
-
-<p>
-In the <b>repeat</b>&ndash;<b>until</b> loop,
-the inner block does not end at the <b>until</b> keyword,
-but only after the condition.
-So, the condition can refer to local variables
-declared inside the loop block.
-
-
-<p>
-The <b>return</b> statement is used to return values
-from a function or a chunk (which is just a function).
-
-Functions and chunks can return more than one value,
-and so the syntax for the <b>return</b> statement is
-
-<pre>
-	stat ::= <b>return</b> [explist]
-</pre>
-
-<p>
-The <b>break</b> statement is used to terminate the execution of a
-<b>while</b>, <b>repeat</b>, or <b>for</b> loop,
-skipping to the next statement after the loop:
-
-
-<pre>
-	stat ::= <b>break</b>
-</pre><p>
-A <b>break</b> ends the innermost enclosing loop.
-
-
-<p>
-The <b>return</b> and <b>break</b>
-statements can only be written as the <em>last</em> statement of a block.
-If it is really necessary to <b>return</b> or <b>break</b> in the
-middle of a block,
-then an explicit inner block can be used,
-as in the idioms
-<code>do return end</code> and <code>do break end</code>,
-because now <b>return</b> and <b>break</b> are the last statements in
-their (inner) blocks.
-
-
-
-
-
-<h3>2.4.5 - <a name="2.4.5">For Statement</a></h3>
-
-<p>
-
-The <b>for</b> statement has two forms:
-one numeric and one generic.
-
-
-<p>
-The numeric <b>for</b> loop repeats a block of code while a
-control variable runs through an arithmetic progression.
-It has the following syntax:
-
-<pre>
-	stat ::= <b>for</b> Name `<b>=</b>&acute; exp `<b>,</b>&acute; exp [`<b>,</b>&acute; exp] <b>do</b> block <b>end</b>
-</pre><p>
-The <em>block</em> is repeated for <em>name</em> starting at the value of
-the first <em>exp</em>, until it passes the second <em>exp</em> by steps of the
-third <em>exp</em>.
-More precisely, a <b>for</b> statement like
-
-<pre>
-     for v = <em>e1</em>, <em>e2</em>, <em>e3</em> do <em>block</em> end
-</pre><p>
-is equivalent to the code:
-
-<pre>
-     do
-       local <em>var</em>, <em>limit</em>, <em>step</em> = tonumber(<em>e1</em>), tonumber(<em>e2</em>), tonumber(<em>e3</em>)
-       if not (<em>var</em> and <em>limit</em> and <em>step</em>) then error() end
-       while (<em>step</em> &gt; 0 and <em>var</em> &lt;= <em>limit</em>) or (<em>step</em> &lt;= 0 and <em>var</em> &gt;= <em>limit</em>) do
-         local v = <em>var</em>
-         <em>block</em>
-         <em>var</em> = <em>var</em> + <em>step</em>
-       end
-     end
-</pre><p>
-Note the following:
-
-<ul>
-
-<li>
-All three control expressions are evaluated only once,
-before the loop starts.
-They must all result in numbers.
-</li>
-
-<li>
-<code><em>var</em></code>, <code><em>limit</em></code>, and <code><em>step</em></code> are invisible variables.
-The names shown here are for explanatory purposes only.
-</li>
-
-<li>
-If the third expression (the step) is absent,
-then a step of&nbsp;1 is used.
-</li>
-
-<li>
-You can use <b>break</b> to exit a <b>for</b> loop.
-</li>
-
-<li>
-The loop variable <code>v</code> is local to the loop;
-you cannot use its value after the <b>for</b> ends or is broken.
-If you need this value,
-assign it to another variable before breaking or exiting the loop.
-</li>
-
-</ul>
-
-<p>
-The generic <b>for</b> statement works over functions,
-called <em>iterators</em>.
-On each iteration, the iterator function is called to produce a new value,
-stopping when this new value is <b>nil</b>.
-The generic <b>for</b> loop has the following syntax:
-
-<pre>
-	stat ::= <b>for</b> namelist <b>in</b> explist <b>do</b> block <b>end</b>
-	namelist ::= Name {`<b>,</b>&acute; Name}
-</pre><p>
-A <b>for</b> statement like
-
-<pre>
-     for <em>var_1</em>, &middot;&middot;&middot;, <em>var_n</em> in <em>explist</em> do <em>block</em> end
-</pre><p>
-is equivalent to the code:
-
-<pre>
-     do
-       local <em>f</em>, <em>s</em>, <em>var</em> = <em>explist</em>
-       while true do
-         local <em>var_1</em>, &middot;&middot;&middot;, <em>var_n</em> = <em>f</em>(<em>s</em>, <em>var</em>)
-         <em>var</em> = <em>var_1</em>
-         if <em>var</em> == nil then break end
-         <em>block</em>
-       end
-     end
-</pre><p>
-Note the following:
-
-<ul>
-
-<li>
-<code><em>explist</em></code> is evaluated only once.
-Its results are an <em>iterator</em> function,
-a <em>state</em>,
-and an initial value for the first <em>iterator variable</em>.
-</li>
-
-<li>
-<code><em>f</em></code>, <code><em>s</em></code>, and <code><em>var</em></code> are invisible variables.
-The names are here for explanatory purposes only.
-</li>
-
-<li>
-You can use <b>break</b> to exit a <b>for</b> loop.
-</li>
-
-<li>
-The loop variables <code><em>var_i</em></code> are local to the loop;
-you cannot use their values after the <b>for</b> ends.
-If you need these values,
-then assign them to other variables before breaking or exiting the loop.
-</li>
-
-</ul>
-
-
-
-
-<h3>2.4.6 - <a name="2.4.6">Function Calls as Statements</a></h3><p>
-To allow possible side-effects,
-function calls can be executed as statements:
-
-<pre>
-	stat ::= functioncall
-</pre><p>
-In this case, all returned values are thrown away.
-Function calls are explained in <a href="#2.5.8">&sect;2.5.8</a>.
-
-
-
-
-
-<h3>2.4.7 - <a name="2.4.7">Local Declarations</a></h3><p>
-Local variables can be declared anywhere inside a block.
-The declaration can include an initial assignment:
-
-<pre>
-	stat ::= <b>local</b> namelist [`<b>=</b>&acute; explist]
-</pre><p>
-If present, an initial assignment has the same semantics
-of a multiple assignment (see <a href="#2.4.3">&sect;2.4.3</a>).
-Otherwise, all variables are initialized with <b>nil</b>.
-
-
-<p>
-A chunk is also a block (see <a href="#2.4.1">&sect;2.4.1</a>),
-and so local variables can be declared in a chunk outside any explicit block.
-The scope of such local variables extends until the end of the chunk.
-
-
-<p>
-The visibility rules for local variables are explained in <a href="#2.6">&sect;2.6</a>.
-
-
-
-
-
-
-
-<h2>2.5 - <a name="2.5">Expressions</a></h2>
-
-<p>
-The basic expressions in Lua are the following:
-
-<pre>
-	exp ::= prefixexp
-	exp ::= <b>nil</b> | <b>false</b> | <b>true</b>
-	exp ::= Number
-	exp ::= String
-	exp ::= function
-	exp ::= tableconstructor
-	exp ::= `<b>...</b>&acute;
-	exp ::= exp binop exp
-	exp ::= unop exp
-	prefixexp ::= var | functioncall | `<b>(</b>&acute; exp `<b>)</b>&acute;
-</pre>
-
-<p>
-Numbers and literal strings are explained in <a href="#2.1">&sect;2.1</a>;
-variables are explained in <a href="#2.3">&sect;2.3</a>;
-function definitions are explained in <a href="#2.5.9">&sect;2.5.9</a>;
-function calls are explained in <a href="#2.5.8">&sect;2.5.8</a>;
-table constructors are explained in <a href="#2.5.7">&sect;2.5.7</a>.
-Vararg expressions,
-denoted by three dots ('<code>...</code>'), can only be used when
-directly inside a vararg function;
-they are explained in <a href="#2.5.9">&sect;2.5.9</a>.
-
-
-<p>
-Binary operators comprise arithmetic operators (see <a href="#2.5.1">&sect;2.5.1</a>),
-relational operators (see <a href="#2.5.2">&sect;2.5.2</a>), logical operators (see <a href="#2.5.3">&sect;2.5.3</a>),
-and the concatenation operator (see <a href="#2.5.4">&sect;2.5.4</a>).
-Unary operators comprise the unary minus (see <a href="#2.5.1">&sect;2.5.1</a>),
-the unary <b>not</b> (see <a href="#2.5.3">&sect;2.5.3</a>),
-and the unary <em>length operator</em> (see <a href="#2.5.5">&sect;2.5.5</a>).
-
-
-<p>
-Both function calls and vararg expressions can result in multiple values.
-If an expression is used as a statement
-(only possible for function calls (see <a href="#2.4.6">&sect;2.4.6</a>)),
-then its return list is adjusted to zero elements,
-thus discarding all returned values.
-If an expression is used as the last (or the only) element
-of a list of expressions,
-then no adjustment is made
-(unless the call is enclosed in parentheses).
-In all other contexts,
-Lua adjusts the result list to one element,
-discarding all values except the first one.
-
-
-<p>
-Here are some examples:
-
-<pre>
-     f()                -- adjusted to 0 results
-     g(f(), x)          -- f() is adjusted to 1 result
-     g(x, f())          -- g gets x plus all results from f()
-     a,b,c = f(), x     -- f() is adjusted to 1 result (c gets nil)
-     a,b = ...          -- a gets the first vararg parameter, b gets
-                        -- the second (both a and b can get nil if there
-                        -- is no corresponding vararg parameter)
-     
-     a,b,c = x, f()     -- f() is adjusted to 2 results
-     a,b,c = f()        -- f() is adjusted to 3 results
-     return f()         -- returns all results from f()
-     return ...         -- returns all received vararg parameters
-     return x,y,f()     -- returns x, y, and all results from f()
-     {f()}              -- creates a list with all results from f()
-     {...}              -- creates a list with all vararg parameters
-     {f(), nil}         -- f() is adjusted to 1 result
-</pre>
-
-<p>
-Any expression enclosed in parentheses always results in only one value.
-Thus,
-<code>(f(x,y,z))</code> is always a single value,
-even if <code>f</code> returns several values.
-(The value of <code>(f(x,y,z))</code> is the first value returned by <code>f</code>
-or <b>nil</b> if <code>f</code> does not return any values.)
-
-
-
-<h3>2.5.1 - <a name="2.5.1">Arithmetic Operators</a></h3><p>
-Lua supports the usual arithmetic operators:
-the binary <code>+</code> (addition),
-<code>-</code> (subtraction), <code>*</code> (multiplication),
-<code>/</code> (division), <code>%</code> (modulo), and <code>^</code> (exponentiation);
-and unary <code>-</code> (negation).
-If the operands are numbers, or strings that can be converted to
-numbers (see <a href="#2.2.1">&sect;2.2.1</a>),
-then all operations have the usual meaning.
-Exponentiation works for any exponent.
-For instance, <code>x^(-0.5)</code> computes the inverse of the square root of <code>x</code>.
-Modulo is defined as
-
-<pre>
-     a % b == a - math.floor(a/b)*b
-</pre><p>
-That is, it is the remainder of a division that rounds
-the quotient towards minus infinity.
-
-
-
-
-
-<h3>2.5.2 - <a name="2.5.2">Relational Operators</a></h3><p>
-The relational operators in Lua are
-
-<pre>
-     ==    ~=    &lt;     &gt;     &lt;=    &gt;=
-</pre><p>
-These operators always result in <b>false</b> or <b>true</b>.
-
-
-<p>
-Equality (<code>==</code>) first compares the type of its operands.
-If the types are different, then the result is <b>false</b>.
-Otherwise, the values of the operands are compared.
-Numbers and strings are compared in the usual way.
-Objects (tables, userdata, threads, and functions)
-are compared by <em>reference</em>:
-two objects are considered equal only if they are the <em>same</em> object.
-Every time you create a new object
-(a table, userdata, thread, or function),
-this new object is different from any previously existing object.
-
-
-<p>
-You can change the way that Lua compares tables and userdata 
-by using the "eq" metamethod (see <a href="#2.8">&sect;2.8</a>).
-
-
-<p>
-The conversion rules of <a href="#2.2.1">&sect;2.2.1</a>
-<em>do not</em> apply to equality comparisons.
-Thus, <code>"0"==0</code> evaluates to <b>false</b>,
-and <code>t[0]</code> and <code>t["0"]</code> denote different
-entries in a table.
-
-
-<p>
-The operator <code>~=</code> is exactly the negation of equality (<code>==</code>).
-
-
-<p>
-The order operators work as follows.
-If both arguments are numbers, then they are compared as such.
-Otherwise, if both arguments are strings,
-then their values are compared according to the current locale.
-Otherwise, Lua tries to call the "lt" or the "le"
-metamethod (see <a href="#2.8">&sect;2.8</a>).
-A comparison <code>a &gt; b</code> is translated to <code>b &lt; a</code>
-and <code>a &gt;= b</code> is translated to <code>b &lt;= a</code>.
-
-
-
-
-
-<h3>2.5.3 - <a name="2.5.3">Logical Operators</a></h3><p>
-The logical operators in Lua are
-<b>and</b>, <b>or</b>, and <b>not</b>.
-Like the control structures (see <a href="#2.4.4">&sect;2.4.4</a>),
-all logical operators consider both <b>false</b> and <b>nil</b> as false
-and anything else as true.
-
-
-<p>
-The negation operator <b>not</b> always returns <b>false</b> or <b>true</b>.
-The conjunction operator <b>and</b> returns its first argument
-if this value is <b>false</b> or <b>nil</b>;
-otherwise, <b>and</b> returns its second argument.
-The disjunction operator <b>or</b> returns its first argument
-if this value is different from <b>nil</b> and <b>false</b>;
-otherwise, <b>or</b> returns its second argument.
-Both <b>and</b> and <b>or</b> use short-cut evaluation;
-that is,
-the second operand is evaluated only if necessary.
-Here are some examples:
-
-<pre>
-     10 or 20            --&gt; 10
-     10 or error()       --&gt; 10
-     nil or "a"          --&gt; "a"
-     nil and 10          --&gt; nil
-     false and error()   --&gt; false
-     false and nil       --&gt; false
-     false or nil        --&gt; nil
-     10 and 20           --&gt; 20
-</pre><p>
-(In this manual,
-<code>--&gt;</code> indicates the result of the preceding expression.)
-
-
-
-
-
-<h3>2.5.4 - <a name="2.5.4">Concatenation</a></h3><p>
-The string concatenation operator in Lua is
-denoted by two dots ('<code>..</code>').
-If both operands are strings or numbers, then they are converted to
-strings according to the rules mentioned in <a href="#2.2.1">&sect;2.2.1</a>.
-Otherwise, the "concat" metamethod is called (see <a href="#2.8">&sect;2.8</a>).
-
-
-
-
-
-<h3>2.5.5 - <a name="2.5.5">The Length Operator</a></h3>
-
-<p>
-The length operator is denoted by the unary operator <code>#</code>.
-The length of a string is its number of bytes
-(that is, the usual meaning of string length when each
-character is one byte).
-
-
-<p>
-The length of a table <code>t</code> is defined to be any
-integer index <code>n</code>
-such that <code>t[n]</code> is not <b>nil</b> and <code>t[n+1]</code> is <b>nil</b>;
-moreover, if <code>t[1]</code> is <b>nil</b>, <code>n</code> can be zero.
-For a regular array, with non-nil values from 1 to a given <code>n</code>,
-its length is exactly that <code>n</code>,
-the index of its last value.
-If the array has "holes"
-(that is, <b>nil</b> values between other non-nil values),
-then <code>#t</code> can be any of the indices that
-directly precedes a <b>nil</b> value
-(that is, it may consider any such <b>nil</b> value as the end of
-the array). 
-
-
-
-
-
-<h3>2.5.6 - <a name="2.5.6">Precedence</a></h3><p>
-Operator precedence in Lua follows the table below,
-from lower to higher priority:
-
-<pre>
-     or
-     and
-     &lt;     &gt;     &lt;=    &gt;=    ~=    ==
-     ..
-     +     -
-     *     /     %
-     not   #     - (unary)
-     ^
-</pre><p>
-As usual,
-you can use parentheses to change the precedences of an expression.
-The concatenation ('<code>..</code>') and exponentiation ('<code>^</code>')
-operators are right associative.
-All other binary operators are left associative.
-
-
-
-
-
-<h3>2.5.7 - <a name="2.5.7">Table Constructors</a></h3><p>
-Table constructors are expressions that create tables.
-Every time a constructor is evaluated, a new table is created.
-A constructor can be used to create an empty table
-or to create a table and initialize some of its fields.
-The general syntax for constructors is
-
-<pre>
-	tableconstructor ::= `<b>{</b>&acute; [fieldlist] `<b>}</b>&acute;
-	fieldlist ::= field {fieldsep field} [fieldsep]
-	field ::= `<b>[</b>&acute; exp `<b>]</b>&acute; `<b>=</b>&acute; exp | Name `<b>=</b>&acute; exp | exp
-	fieldsep ::= `<b>,</b>&acute; | `<b>;</b>&acute;
-</pre>
-
-<p>
-Each field of the form <code>[exp1] = exp2</code> adds to the new table an entry
-with key <code>exp1</code> and value <code>exp2</code>.
-A field of the form <code>name = exp</code> is equivalent to
-<code>["name"] = exp</code>.
-Finally, fields of the form <code>exp</code> are equivalent to
-<code>[i] = exp</code>, where <code>i</code> are consecutive numerical integers,
-starting with 1.
-Fields in the other formats do not affect this counting.
-For example,
-
-<pre>
-     a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }
-</pre><p>
-is equivalent to
-
-<pre>
-     do
-       local t = {}
-       t[f(1)] = g
-       t[1] = "x"         -- 1st exp
-       t[2] = "y"         -- 2nd exp
-       t.x = 1            -- t["x"] = 1
-       t[3] = f(x)        -- 3rd exp
-       t[30] = 23
-       t[4] = 45          -- 4th exp
-       a = t
-     end
-</pre>
-
-<p>
-If the last field in the list has the form <code>exp</code>
-and the expression is a function call or a vararg expression,
-then all values returned by this expression enter the list consecutively
-(see <a href="#2.5.8">&sect;2.5.8</a>).
-To avoid this,
-enclose the function call or the vararg expression
-in parentheses (see <a href="#2.5">&sect;2.5</a>).
-
-
-<p>
-The field list can have an optional trailing separator,
-as a convenience for machine-generated code.
-
-
-
-
-
-<h3>2.5.8 - <a name="2.5.8">Function Calls</a></h3><p>
-A function call in Lua has the following syntax:
-
-<pre>
-	functioncall ::= prefixexp args
-</pre><p>
-In a function call,
-first prefixexp and args are evaluated.
-If the value of prefixexp has type <em>function</em>,
-then this function is called
-with the given arguments.
-Otherwise, the prefixexp "call" metamethod is called,
-having as first parameter the value of prefixexp,
-followed by the original call arguments
-(see <a href="#2.8">&sect;2.8</a>).
-
-
-<p>
-The form
-
-<pre>
-	functioncall ::= prefixexp `<b>:</b>&acute; Name args
-</pre><p>
-can be used to call "methods".
-A call <code>v:name(<em>args</em>)</code>
-is syntactic sugar for <code>v.name(v,<em>args</em>)</code>,
-except that <code>v</code> is evaluated only once.
-
-
-<p>
-Arguments have the following syntax:
-
-<pre>
-	args ::= `<b>(</b>&acute; [explist] `<b>)</b>&acute;
-	args ::= tableconstructor
-	args ::= String
-</pre><p>
-All argument expressions are evaluated before the call.
-A call of the form <code>f{<em>fields</em>}</code> is
-syntactic sugar for <code>f({<em>fields</em>})</code>;
-that is, the argument list is a single new table.
-A call of the form <code>f'<em>string</em>'</code>
-(or <code>f"<em>string</em>"</code> or <code>f[[<em>string</em>]]</code>)
-is syntactic sugar for <code>f('<em>string</em>')</code>;
-that is, the argument list is a single literal string.
-
-
-<p>
-As an exception to the free-format syntax of Lua,
-you cannot put a line break before the '<code>(</code>' in a function call.
-This restriction avoids some ambiguities in the language.
-If you write
-
-<pre>
-     a = f
-     (g).x(a)
-</pre><p>
-Lua would see that as a single statement, <code>a = f(g).x(a)</code>.
-So, if you want two statements, you must add a semi-colon between them.
-If you actually want to call <code>f</code>,
-you must remove the line break before <code>(g)</code>.
-
-
-<p>
-A call of the form <code>return</code> <em>functioncall</em> is called
-a <em>tail call</em>.
-Lua implements <em>proper tail calls</em>
-(or <em>proper tail recursion</em>):
-in a tail call,
-the called function reuses the stack entry of the calling function.
-Therefore, there is no limit on the number of nested tail calls that
-a program can execute.
-However, a tail call erases any debug information about the
-calling function.
-Note that a tail call only happens with a particular syntax,
-where the <b>return</b> has one single function call as argument;
-this syntax makes the calling function return exactly
-the returns of the called function.
-So, none of the following examples are tail calls:
-
-<pre>
-     return (f(x))        -- results adjusted to 1
-     return 2 * f(x)
-     return x, f(x)       -- additional results
-     f(x); return         -- results discarded
-     return x or f(x)     -- results adjusted to 1
-</pre>
-
-
-
-
-<h3>2.5.9 - <a name="2.5.9">Function Definitions</a></h3>
-
-<p>
-The syntax for function definition is
-
-<pre>
-	function ::= <b>function</b> funcbody
-	funcbody ::= `<b>(</b>&acute; [parlist] `<b>)</b>&acute; block <b>end</b>
-</pre>
-
-<p>
-The following syntactic sugar simplifies function definitions:
-
-<pre>
-	stat ::= <b>function</b> funcname funcbody
-	stat ::= <b>local</b> <b>function</b> Name funcbody
-	funcname ::= Name {`<b>.</b>&acute; Name} [`<b>:</b>&acute; Name]
-</pre><p>
-The statement
-
-<pre>
-     function f () <em>body</em> end
-</pre><p>
-translates to
-
-<pre>
-     f = function () <em>body</em> end
-</pre><p>
-The statement
-
-<pre>
-     function t.a.b.c.f () <em>body</em> end
-</pre><p>
-translates to
-
-<pre>
-     t.a.b.c.f = function () <em>body</em> end
-</pre><p>
-The statement
-
-<pre>
-     local function f () <em>body</em> end
-</pre><p>
-translates to
-
-<pre>
-     local f; f = function () <em>body</em> end
-</pre><p>
-<em>not</em> to
-
-<pre>
-     local f = function () <em>body</em> end
-</pre><p>
-(This only makes a difference when the body of the function
-contains references to <code>f</code>.)
-
-
-<p>
-A function definition is an executable expression,
-whose value has type <em>function</em>.
-When Lua pre-compiles a chunk,
-all its function bodies are pre-compiled too.
-Then, whenever Lua executes the function definition,
-the function is <em>instantiated</em> (or <em>closed</em>).
-This function instance (or <em>closure</em>)
-is the final value of the expression.
-Different instances of the same function
-can refer to different  external local variables
-and can have different environment tables.
-
-
-<p>
-Parameters act as local variables that are
-initialized with the argument values:
-
-<pre>
-	parlist ::= namelist [`<b>,</b>&acute; `<b>...</b>&acute;] | `<b>...</b>&acute;
-</pre><p>
-When a function is called,
-the list of arguments is adjusted to
-the length of the list of parameters,
-unless the function is a variadic or <em>vararg function</em>,
-which is
-indicated by three dots ('<code>...</code>') at the end of its parameter list.
-A vararg function does not adjust its argument list;
-instead, it collects all extra arguments and supplies them
-to the function through a <em>vararg expression</em>,
-which is also written as three dots.
-The value of this expression is a list of all actual extra arguments,
-similar to a function with multiple results.
-If a vararg expression is used inside another expression
-or in the middle of a list of expressions,
-then its return list is adjusted to one element.
-If the expression is used as the last element of a list of expressions,
-then no adjustment is made
-(unless that last expression is enclosed in parentheses).
-
-
-<p>
-As an example, consider the following definitions:
-
-<pre>
-     function f(a, b) end
-     function g(a, b, ...) end
-     function r() return 1,2,3 end
-</pre><p>
-Then, we have the following mapping from arguments to parameters and
-to the vararg expression:
-
-<pre>
-     CALL            PARAMETERS
-     
-     f(3)             a=3, b=nil
-     f(3, 4)          a=3, b=4
-     f(3, 4, 5)       a=3, b=4
-     f(r(), 10)       a=1, b=10
-     f(r())           a=1, b=2
-     
-     g(3)             a=3, b=nil, ... --&gt;  (nothing)
-     g(3, 4)          a=3, b=4,   ... --&gt;  (nothing)
-     g(3, 4, 5, 8)    a=3, b=4,   ... --&gt;  5  8
-     g(5, r())        a=5, b=1,   ... --&gt;  2  3
-</pre>
-
-<p>
-Results are returned using the <b>return</b> statement (see <a href="#2.4.4">&sect;2.4.4</a>).
-If control reaches the end of a function
-without encountering a <b>return</b> statement,
-then the function returns with no results.
-
-
-<p>
-The <em>colon</em> syntax
-is used for defining <em>methods</em>,
-that is, functions that have an implicit extra parameter <code>self</code>.
-Thus, the statement
-
-<pre>
-     function t.a.b.c:f (<em>params</em>) <em>body</em> end
-</pre><p>
-is syntactic sugar for
-
-<pre>
-     t.a.b.c.f = function (self, <em>params</em>) <em>body</em> end
-</pre>
-
-
-
-
-
-
-<h2>2.6 - <a name="2.6">Visibility Rules</a></h2>
-
-<p>
-
-Lua is a lexically scoped language.
-The scope of variables begins at the first statement <em>after</em>
-their declaration and lasts until the end of the innermost block that
-includes the declaration.
-Consider the following example:
-
-<pre>
-     x = 10                -- global variable
-     do                    -- new block
-       local x = x         -- new 'x', with value 10
-       print(x)            --&gt; 10
-       x = x+1
-       do                  -- another block
-         local x = x+1     -- another 'x'
-         print(x)          --&gt; 12
-       end
-       print(x)            --&gt; 11
-     end
-     print(x)              --&gt; 10  (the global one)
-</pre>
-
-<p>
-Notice that, in a declaration like <code>local x = x</code>,
-the new <code>x</code> being declared is not in scope yet,
-and so the second <code>x</code> refers to the outside variable.
-
-
-<p>
-Because of the lexical scoping rules,
-local variables can be freely accessed by functions
-defined inside their scope.
-A local variable used by an inner function is called
-an <em>upvalue</em>, or <em>external local variable</em>,
-inside the inner function.
-
-
-<p>
-Notice that each execution of a <b>local</b> statement
-defines new local variables.
-Consider the following example:
-
-<pre>
-     a = {}
-     local x = 20
-     for i=1,10 do
-       local y = 0
-       a[i] = function () y=y+1; return x+y end
-     end
-</pre><p>
-The loop creates ten closures
-(that is, ten instances of the anonymous function).
-Each of these closures uses a different <code>y</code> variable,
-while all of them share the same <code>x</code>.
-
-
-
-
-
-<h2>2.7 - <a name="2.7">Error Handling</a></h2>
-
-<p>
-Because Lua is an embedded extension language,
-all Lua actions start from C&nbsp;code in the host program
-calling a function from the Lua library (see <a href="#lua_pcall"><code>lua_pcall</code></a>).
-Whenever an error occurs during Lua compilation or execution,
-control returns to C,
-which can take appropriate measures
-(such as printing an error message).
-
-
-<p>
-Lua code can explicitly generate an error by calling the
-<a href="#pdf-error"><code>error</code></a> function.
-If you need to catch errors in Lua,
-you can use the <a href="#pdf-pcall"><code>pcall</code></a> function.
-
-
-
-
-
-<h2>2.8 - <a name="2.8">Metatables</a></h2>
-
-<p>
-Every value in Lua can have a <em>metatable</em>.
-This <em>metatable</em> is an ordinary Lua table
-that defines the behavior of the original value
-under certain special operations.
-You can change several aspects of the behavior
-of operations over a value by setting specific fields in its metatable.
-For instance, when a non-numeric value is the operand of an addition,
-Lua checks for a function in the field <code>"__add"</code> in its metatable.
-If it finds one,
-Lua calls this function to perform the addition.
-
-
-<p>
-We call the keys in a metatable <em>events</em>
-and the values <em>metamethods</em>.
-In the previous example, the event is <code>"add"</code> 
-and the metamethod is the function that performs the addition.
-
-
-<p>
-You can query the metatable of any value
-through the <a href="#pdf-getmetatable"><code>getmetatable</code></a> function.
-
-
-<p>
-You can replace the metatable of tables
-through the <a href="#pdf-setmetatable"><code>setmetatable</code></a>
-function.
-You cannot change the metatable of other types from Lua
-(except by using the debug library);
-you must use the C&nbsp;API for that.
-
-
-<p>
-Tables and full userdata have individual metatables
-(although multiple tables and userdata can share their metatables).
-Values of all other types share one single metatable per type;
-that is, there is one single metatable for all numbers,
-one for all strings, etc.
-
-
-<p>
-A metatable controls how an object behaves in arithmetic operations,
-order comparisons, concatenation, length operation, and indexing.
-A metatable also can define a function to be called when a userdata
-is garbage collected.
-For each of these operations Lua associates a specific key
-called an <em>event</em>.
-When Lua performs one of these operations over a value,
-it checks whether this value has a metatable with the corresponding event.
-If so, the value associated with that key (the metamethod)
-controls how Lua will perform the operation.
-
-
-<p>
-Metatables control the operations listed next.
-Each operation is identified by its corresponding name.
-The key for each operation is a string with its name prefixed by
-two underscores, '<code>__</code>';
-for instance, the key for operation "add" is the
-string <code>"__add"</code>.
-The semantics of these operations is better explained by a Lua function
-describing how the interpreter executes the operation.
-
-
-<p>
-The code shown here in Lua is only illustrative;
-the real behavior is hard coded in the interpreter
-and it is much more efficient than this simulation.
-All functions used in these descriptions
-(<a href="#pdf-rawget"><code>rawget</code></a>, <a href="#pdf-tonumber"><code>tonumber</code></a>, etc.)
-are described in <a href="#5.1">&sect;5.1</a>.
-In particular, to retrieve the metamethod of a given object,
-we use the expression
-
-<pre>
-     metatable(obj)[event]
-</pre><p>
-This should be read as
-
-<pre>
-     rawget(getmetatable(obj) or {}, event)
-</pre><p>
-
-That is, the access to a metamethod does not invoke other metamethods,
-and the access to objects with no metatables does not fail
-(it simply results in <b>nil</b>).
-
-
-
-<ul>
-
-<li><b>"add":</b>
-the <code>+</code> operation.
-
-
-
-<p>
-The function <code>getbinhandler</code> below defines how Lua chooses a handler
-for a binary operation.
-First, Lua tries the first operand.
-If its type does not define a handler for the operation,
-then Lua tries the second operand.
-
-<pre>
-     function getbinhandler (op1, op2, event)
-       return metatable(op1)[event] or metatable(op2)[event]
-     end
-</pre><p>
-By using this function,
-the behavior of the <code>op1 + op2</code> is
-
-<pre>
-     function add_event (op1, op2)
-       local o1, o2 = tonumber(op1), tonumber(op2)
-       if o1 and o2 then  -- both operands are numeric?
-         return o1 + o2   -- '+' here is the primitive 'add'
-       else  -- at least one of the operands is not numeric
-         local h = getbinhandler(op1, op2, "__add")
-         if h then
-           -- call the handler with both operands
-           return (h(op1, op2))
-         else  -- no handler available: default behavior
-           error(&middot;&middot;&middot;)
-         end
-       end
-     end
-</pre><p>
-</li>
-
-<li><b>"sub":</b>
-the <code>-</code> operation.
-
-Behavior similar to the "add" operation.
-</li>
-
-<li><b>"mul":</b>
-the <code>*</code> operation.
-
-Behavior similar to the "add" operation.
-</li>
-
-<li><b>"div":</b>
-the <code>/</code> operation.
-
-Behavior similar to the "add" operation.
-</li>
-
-<li><b>"mod":</b>
-the <code>%</code> operation.
-
-Behavior similar to the "add" operation,
-with the operation
-<code>o1 - floor(o1/o2)*o2</code> as the primitive operation.
-</li>
-
-<li><b>"pow":</b>
-the <code>^</code> (exponentiation) operation.
-
-Behavior similar to the "add" operation,
-with the function <code>pow</code> (from the C&nbsp;math library)
-as the primitive operation.
-</li>
-
-<li><b>"unm":</b>
-the unary <code>-</code> operation.
-
-
-<pre>
-     function unm_event (op)
-       local o = tonumber(op)
-       if o then  -- operand is numeric?
-         return -o  -- '-' here is the primitive 'unm'
-       else  -- the operand is not numeric.
-         -- Try to get a handler from the operand
-         local h = metatable(op).__unm
-         if h then
-           -- call the handler with the operand
-           return (h(op))
-         else  -- no handler available: default behavior
-           error(&middot;&middot;&middot;)
-         end
-       end
-     end
-</pre><p>
-</li>
-
-<li><b>"concat":</b>
-the <code>..</code> (concatenation) operation.
-
-
-<pre>
-     function concat_event (op1, op2)
-       if (type(op1) == "string" or type(op1) == "number") and
-          (type(op2) == "string" or type(op2) == "number") then
-         return op1 .. op2  -- primitive string concatenation
-       else
-         local h = getbinhandler(op1, op2, "__concat")
-         if h then
-           return (h(op1, op2))
-         else
-           error(&middot;&middot;&middot;)
-         end
-       end
-     end
-</pre><p>
-</li>
-
-<li><b>"len":</b>
-the <code>#</code> operation.
-
-
-<pre>
-     function len_event (op)
-       if type(op) == "string" then
-         return strlen(op)         -- primitive string length
-       elseif type(op) == "table" then
-         return #op                -- primitive table length
-       else
-         local h = metatable(op).__len
-         if h then
-           -- call the handler with the operand
-           return (h(op))
-         else  -- no handler available: default behavior
-           error(&middot;&middot;&middot;)
-         end
-       end
-     end
-</pre><p>
-See <a href="#2.5.5">&sect;2.5.5</a> for a description of the length of a table.
-</li>
-
-<li><b>"eq":</b>
-the <code>==</code> operation.
-
-The function <code>getcomphandler</code> defines how Lua chooses a metamethod
-for comparison operators.
-A metamethod only is selected when both objects
-being compared have the same type
-and the same metamethod for the selected operation.
-
-<pre>
-     function getcomphandler (op1, op2, event)
-       if type(op1) ~= type(op2) then return nil end
-       local mm1 = metatable(op1)[event]
-       local mm2 = metatable(op2)[event]
-       if mm1 == mm2 then return mm1 else return nil end
-     end
-</pre><p>
-The "eq" event is defined as follows:
-
-<pre>
-     function eq_event (op1, op2)
-       if type(op1) ~= type(op2) then  -- different types?
-         return false   -- different objects
-       end
-       if op1 == op2 then   -- primitive equal?
-         return true   -- objects are equal
-       end
-       -- try metamethod
-       local h = getcomphandler(op1, op2, "__eq")
-       if h then
-         return (h(op1, op2))
-       else
-         return false
-       end
-     end
-</pre><p>
-<code>a ~= b</code> is equivalent to <code>not (a == b)</code>.
-</li>
-
-<li><b>"lt":</b>
-the <code>&lt;</code> operation.
-
-
-<pre>
-     function lt_event (op1, op2)
-       if type(op1) == "number" and type(op2) == "number" then
-         return op1 &lt; op2   -- numeric comparison
-       elseif type(op1) == "string" and type(op2) == "string" then
-         return op1 &lt; op2   -- lexicographic comparison
-       else
-         local h = getcomphandler(op1, op2, "__lt")
-         if h then
-           return (h(op1, op2))
-         else
-           error(&middot;&middot;&middot;)
-         end
-       end
-     end
-</pre><p>
-<code>a &gt; b</code> is equivalent to <code>b &lt; a</code>.
-</li>
-
-<li><b>"le":</b>
-the <code>&lt;=</code> operation.
-
-
-<pre>
-     function le_event (op1, op2)
-       if type(op1) == "number" and type(op2) == "number" then
-         return op1 &lt;= op2   -- numeric comparison
-       elseif type(op1) == "string" and type(op2) == "string" then
-         return op1 &lt;= op2   -- lexicographic comparison
-       else
-         local h = getcomphandler(op1, op2, "__le")
-         if h then
-           return (h(op1, op2))
-         else
-           h = getcomphandler(op1, op2, "__lt")
-           if h then
-             return not h(op2, op1)
-           else
-             error(&middot;&middot;&middot;)
-           end
-         end
-       end
-     end
-</pre><p>
-<code>a &gt;= b</code> is equivalent to <code>b &lt;= a</code>.
-Note that, in the absence of a "le" metamethod,
-Lua tries the "lt", assuming that <code>a &lt;= b</code> is
-equivalent to <code>not (b &lt; a)</code>.
-</li>
-
-<li><b>"index":</b>
-The indexing access <code>table[key]</code>.
-
-
-<pre>
-     function gettable_event (table, key)
-       local h
-       if type(table) == "table" then
-         local v = rawget(table, key)
-         if v ~= nil then return v end
-         h = metatable(table).__index
-         if h == nil then return nil end
-       else
-         h = metatable(table).__index
-         if h == nil then
-           error(&middot;&middot;&middot;)
-         end
-       end
-       if type(h) == "function" then
-         return (h(table, key))     -- call the handler
-       else return h[key]           -- or repeat operation on it
-       end
-     end
-</pre><p>
-</li>
-
-<li><b>"newindex":</b>
-The indexing assignment <code>table[key] = value</code>.
-
-
-<pre>
-     function settable_event (table, key, value)
-       local h
-       if type(table) == "table" then
-         local v = rawget(table, key)
-         if v ~= nil then rawset(table, key, value); return end
-         h = metatable(table).__newindex
-         if h == nil then rawset(table, key, value); return end
-       else
-         h = metatable(table).__newindex
-         if h == nil then
-           error(&middot;&middot;&middot;)
-         end
-       end
-       if type(h) == "function" then
-         h(table, key,value)           -- call the handler
-       else h[key] = value             -- or repeat operation on it
-       end
-     end
-</pre><p>
-</li>
-
-<li><b>"call":</b>
-called when Lua calls a value.
-
-
-<pre>
-     function function_event (func, ...)
-       if type(func) == "function" then
-         return func(...)   -- primitive call
-       else
-         local h = metatable(func).__call
-         if h then
-           return h(func, ...)
-         else
-           error(&middot;&middot;&middot;)
-         end
-       end
-     end
-</pre><p>
-</li>
-
-</ul>
-
-
-
-
-<h2>2.9 - <a name="2.9">Environments</a></h2>
-
-<p>
-Besides metatables,
-objects of types thread, function, and userdata
-have another table associated with them,
-called their <em>environment</em>.
-Like metatables, environments are regular tables and
-multiple objects can share the same environment.
-
-
-<p>
-Threads are created sharing the environment of the creating thread.
-Userdata and C&nbsp;functions are created sharing the environment
-of the creating C&nbsp;function.
-Non-nested Lua functions
-(created by <a href="#pdf-loadfile"><code>loadfile</code></a>, <a href="#pdf-loadstring"><code>loadstring</code></a> or <a href="#pdf-load"><code>load</code></a>)
-are created sharing the environment of the creating thread.
-Nested Lua functions are created sharing the environment of
-the creating Lua function.
-
-
-<p>
-Environments associated with userdata have no meaning for Lua.
-It is only a convenience feature for programmers to associate a table to
-a userdata.
-
-
-<p>
-Environments associated with threads are called
-<em>global environments</em>.
-They are used as the default environment for threads and
-non-nested Lua functions created by the thread
-and can be directly accessed by C&nbsp;code (see <a href="#3.3">&sect;3.3</a>).
-
-
-<p>
-The environment associated with a C&nbsp;function can be directly
-accessed by C&nbsp;code (see <a href="#3.3">&sect;3.3</a>).
-It is used as the default environment for other C&nbsp;functions
-and userdata created by the function.
-
-
-<p>
-Environments associated with Lua functions are used to resolve
-all accesses to global variables within the function (see <a href="#2.3">&sect;2.3</a>).
-They are used as the default environment for nested Lua functions
-created by the function.
-
-
-<p>
-You can change the environment of a Lua function or the
-running thread by calling <a href="#pdf-setfenv"><code>setfenv</code></a>.
-You can get the environment of a Lua function or the running thread
-by calling <a href="#pdf-getfenv"><code>getfenv</code></a>.
-To manipulate the environment of other objects
-(userdata, C&nbsp;functions, other threads) you must
-use the C&nbsp;API.
-
-
-
-
-
-<h2>2.10 - <a name="2.10">Garbage Collection</a></h2>
-
-<p>
-Lua performs automatic memory management.
-This means that
-you have to worry neither about allocating memory for new objects
-nor about freeing it when the objects are no longer needed.
-Lua manages memory automatically by running
-a <em>garbage collector</em> from time to time
-to collect all <em>dead objects</em>
-(that is, objects that are no longer accessible from Lua).
-All memory used by Lua is subject to automatic management:
-tables, userdata, functions, threads, strings, etc.
-
-
-<p>
-Lua implements an incremental mark-and-sweep collector.
-It uses two numbers to control its garbage-collection cycles:
-the <em>garbage-collector pause</em> and
-the <em>garbage-collector step multiplier</em>.
-Both use percentage points as units
-(so that a value of 100 means an internal value of 1).
-
-
-<p>
-The garbage-collector pause
-controls how long the collector waits before starting a new cycle.
-Larger values make the collector less aggressive.
-Values smaller than 100 mean the collector will not wait to
-start a new cycle.
-A value of 200 means that the collector waits for the total memory in use
-to double before starting a new cycle.
-
-
-<p>
-The step multiplier
-controls the relative speed of the collector relative to
-memory allocation.
-Larger values make the collector more aggressive but also increase
-the size of each incremental step.
-Values smaller than 100 make the collector too slow and
-can result in the collector never finishing a cycle.
-The default, 200, means that the collector runs at "twice"
-the speed of memory allocation.
-
-
-<p>
-You can change these numbers by calling <a href="#lua_gc"><code>lua_gc</code></a> in C
-or <a href="#pdf-collectgarbage"><code>collectgarbage</code></a> in Lua.
-With these functions you can also control 
-the collector directly (e.g., stop and restart it).
-
-
-
-<h3>2.10.1 - <a name="2.10.1">Garbage-Collection Metamethods</a></h3>
-
-<p>
-Using the C&nbsp;API,
-you can set garbage-collector metamethods for userdata (see <a href="#2.8">&sect;2.8</a>).
-These metamethods are also called <em>finalizers</em>.
-Finalizers allow you to coordinate Lua's garbage collection
-with external resource management
-(such as closing files, network or database connections,
-or freeing your own memory).
-
-
-<p>
-Garbage userdata with a field <code>__gc</code> in their metatables are not
-collected immediately by the garbage collector.
-Instead, Lua puts them in a list.
-After the collection,
-Lua does the equivalent of the following function
-for each userdata in that list:
-
-<pre>
-     function gc_event (udata)
-       local h = metatable(udata).__gc
-       if h then
-         h(udata)
-       end
-     end
-</pre>
-
-<p>
-At the end of each garbage-collection cycle,
-the finalizers for userdata are called in <em>reverse</em>
-order of their creation,
-among those collected in that cycle.
-That is, the first finalizer to be called is the one associated
-with the userdata created last in the program.
-The userdata itself is freed only in the next garbage-collection cycle.
-
-
-
-
-
-<h3>2.10.2 - <a name="2.10.2">Weak Tables</a></h3>
-
-<p>
-A <em>weak table</em> is a table whose elements are
-<em>weak references</em>.
-A weak reference is ignored by the garbage collector.
-In other words,
-if the only references to an object are weak references,
-then the garbage collector will collect this object.
-
-
-<p>
-A weak table can have weak keys, weak values, or both.
-A table with weak keys allows the collection of its keys,
-but prevents the collection of its values.
-A table with both weak keys and weak values allows the collection of
-both keys and values.
-In any case, if either the key or the value is collected,
-the whole pair is removed from the table.
-The weakness of a table is controlled by the
-<code>__mode</code> field of its metatable.
-If the <code>__mode</code> field is a string containing the character&nbsp;'<code>k</code>',
-the keys in the table are weak.
-If <code>__mode</code> contains '<code>v</code>',
-the values in the table are weak.
-
-
-<p>
-After you use a table as a metatable,
-you should not change the value of its <code>__mode</code> field.
-Otherwise, the weak behavior of the tables controlled by this
-metatable is undefined.
-
-
-
-
-
-
-
-<h2>2.11 - <a name="2.11">Coroutines</a></h2>
-
-<p>
-Lua supports coroutines,
-also called <em>collaborative multithreading</em>.
-A coroutine in Lua represents an independent thread of execution.
-Unlike threads in multithread systems, however,
-a coroutine only suspends its execution by explicitly calling
-a yield function.
-
-
-<p>
-You create a coroutine with a call to <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>.
-Its sole argument is a function
-that is the main function of the coroutine.
-The <code>create</code> function only creates a new coroutine and
-returns a handle to it (an object of type <em>thread</em>);
-it does not start the coroutine execution.
-
-
-<p>
-When you first call <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
-passing as its first argument
-a thread returned by <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>,
-the coroutine starts its execution,
-at the first line of its main function.
-Extra arguments passed to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> are passed on
-to the coroutine main function.
-After the coroutine starts running,
-it runs until it terminates or <em>yields</em>.
-
-
-<p>
-A coroutine can terminate its execution in two ways:
-normally, when its main function returns
-(explicitly or implicitly, after the last instruction);
-and abnormally, if there is an unprotected error.
-In the first case, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>true</b>,
-plus any values returned by the coroutine main function.
-In case of errors, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>false</b>
-plus an error message.
-
-
-<p>
-A coroutine yields by calling <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a>.
-When a coroutine yields,
-the corresponding <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns immediately,
-even if the yield happens inside nested function calls
-(that is, not in the main function,
-but in a function directly or indirectly called by the main function).
-In the case of a yield, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> also returns <b>true</b>,
-plus any values passed to <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a>.
-The next time you resume the same coroutine,
-it continues its execution from the point where it yielded,
-with the call to <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a> returning any extra
-arguments passed to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.
-
-
-<p>
-Like <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>,
-the <a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> function also creates a coroutine,
-but instead of returning the coroutine itself,
-it returns a function that, when called, resumes the coroutine.
-Any arguments passed to this function
-go as extra arguments to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.
-<a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> returns all the values returned by <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
-except the first one (the boolean error code).
-Unlike <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
-<a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> does not catch errors;
-any error is propagated to the caller.
-
-
-<p>
-As an example,
-consider the following code:
-
-<pre>
-     function foo (a)
-       print("foo", a)
-       return coroutine.yield(2*a)
-     end
-     
-     co = coroutine.create(function (a,b)
-           print("co-body", a, b)
-           local r = foo(a+1)
-           print("co-body", r)
-           local r, s = coroutine.yield(a+b, a-b)
-           print("co-body", r, s)
-           return b, "end"
-     end)
-            
-     print("main", coroutine.resume(co, 1, 10))
-     print("main", coroutine.resume(co, "r"))
-     print("main", coroutine.resume(co, "x", "y"))
-     print("main", coroutine.resume(co, "x", "y"))
-</pre><p>
-When you run it, it produces the following output:
-
-<pre>
-     co-body 1       10
-     foo     2
-     
-     main    true    4
-     co-body r
-     main    true    11      -9
-     co-body x       y
-     main    true    10      end
-     main    false   cannot resume dead coroutine
-</pre>
-
-
-
-
-<h1>3 - <a name="3">The Application Program Interface</a></h1>
-
-<p>
-
-This section describes the C&nbsp;API for Lua, that is,
-the set of C&nbsp;functions available to the host program to communicate
-with Lua.
-All API functions and related types and constants
-are declared in the header file <a name="pdf-lua.h"><code>lua.h</code></a>.
-
-
-<p>
-Even when we use the term "function",
-any facility in the API may be provided as a macro instead.
-All such macros use each of their arguments exactly once
-(except for the first argument, which is always a Lua state),
-and so do not generate any hidden side-effects.
-
-
-<p>
-As in most C&nbsp;libraries,
-the Lua API functions do not check their arguments for validity or consistency.
-However, you can change this behavior by compiling Lua
-with a proper definition for the macro <a name="pdf-luai_apicheck"><code>luai_apicheck</code></a>,
-in file <code>luaconf.h</code>.
-
-
-
-<h2>3.1 - <a name="3.1">The Stack</a></h2>
-
-<p>
-Lua uses a <em>virtual stack</em> to pass values to and from C.
-Each element in this stack represents a Lua value
-(<b>nil</b>, number, string, etc.).
-
-
-<p>
-Whenever Lua calls C, the called function gets a new stack,
-which is independent of previous stacks and of stacks of
-C&nbsp;functions that are still active.
-This stack initially contains any arguments to the C&nbsp;function
-and it is where the C&nbsp;function pushes its results
-to be returned to the caller (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>).
-
-
-<p>
-For convenience,
-most query operations in the API do not follow a strict stack discipline.
-Instead, they can refer to any element in the stack
-by using an <em>index</em>:
-A positive index represents an <em>absolute</em> stack position
-(starting at&nbsp;1);
-a negative index represents an <em>offset</em> relative to the top of the stack.
-More specifically, if the stack has <em>n</em> elements,
-then index&nbsp;1 represents the first element
-(that is, the element that was pushed onto the stack first)
-and
-index&nbsp;<em>n</em> represents the last element;
-index&nbsp;-1 also represents the last element
-(that is, the element at the&nbsp;top)
-and index <em>-n</em> represents the first element.
-We say that an index is <em>valid</em>
-if it lies between&nbsp;1 and the stack top
-(that is, if <code>1 &le; abs(index) &le; top</code>).
- 
-
-
-
-
-
-<h2>3.2 - <a name="3.2">Stack Size</a></h2>
-
-<p>
-When you interact with Lua API,
-you are responsible for ensuring consistency.
-In particular,
-<em>you are responsible for controlling stack overflow</em>.
-You can use the function <a href="#lua_checkstack"><code>lua_checkstack</code></a>
-to grow the stack size.
-
-
-<p>
-Whenever Lua calls C,
-it ensures that at least <a name="pdf-LUA_MINSTACK"><code>LUA_MINSTACK</code></a> stack positions are available.
-<code>LUA_MINSTACK</code> is defined as 20,
-so that usually you do not have to worry about stack space
-unless your code has loops pushing elements onto the stack.
-
-
-<p>
-Most query functions accept as indices any value inside the
-available stack space, that is, indices up to the maximum stack size
-you have set through <a href="#lua_checkstack"><code>lua_checkstack</code></a>.
-Such indices are called <em>acceptable indices</em>.
-More formally, we define an <em>acceptable index</em>
-as follows:
-
-<pre>
-     (index &lt; 0 &amp;&amp; abs(index) &lt;= top) ||
-     (index &gt; 0 &amp;&amp; index &lt;= stackspace)
-</pre><p>
-Note that 0 is never an acceptable index.
-
-
-
-
-
-<h2>3.3 - <a name="3.3">Pseudo-Indices</a></h2>
-
-<p>
-Unless otherwise noted,
-any function that accepts valid indices can also be called with
-<em>pseudo-indices</em>,
-which represent some Lua values that are accessible to C&nbsp;code
-but which are not in the stack.
-Pseudo-indices are used to access the thread environment,
-the function environment,
-the registry,
-and the upvalues of a C&nbsp;function (see <a href="#3.4">&sect;3.4</a>).
-
-
-<p>
-The thread environment (where global variables live) is
-always at pseudo-index <a name="pdf-LUA_GLOBALSINDEX"><code>LUA_GLOBALSINDEX</code></a>.
-The environment of the running C&nbsp;function is always
-at pseudo-index <a name="pdf-LUA_ENVIRONINDEX"><code>LUA_ENVIRONINDEX</code></a>.
-
-
-<p>
-To access and change the value of global variables,
-you can use regular table operations over an environment table.
-For instance, to access the value of a global variable, do
-
-<pre>
-     lua_getfield(L, LUA_GLOBALSINDEX, varname);
-</pre>
-
-
-
-
-<h2>3.4 - <a name="3.4">C Closures</a></h2>
-
-<p>
-When a C&nbsp;function is created,
-it is possible to associate some values with it,
-thus creating a <em>C&nbsp;closure</em>;
-these values are called <em>upvalues</em> and are
-accessible to the function whenever it is called
-(see <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a>).
-
-
-<p>
-Whenever a C&nbsp;function is called,
-its upvalues are located at specific pseudo-indices.
-These pseudo-indices are produced by the macro
-<a name="lua_upvalueindex"><code>lua_upvalueindex</code></a>.
-The first value associated with a function is at position
-<code>lua_upvalueindex(1)</code>, and so on.
-Any access to <code>lua_upvalueindex(<em>n</em>)</code>,
-where <em>n</em> is greater than the number of upvalues of the
-current function (but not greater than 256),
-produces an acceptable (but invalid) index.
-
-
-
-
-
-<h2>3.5 - <a name="3.5">Registry</a></h2>
-
-<p>
-Lua provides a <em>registry</em>,
-a pre-defined table that can be used by any C&nbsp;code to
-store whatever Lua value it needs to store.
-This table is always located at pseudo-index
-<a name="pdf-LUA_REGISTRYINDEX"><code>LUA_REGISTRYINDEX</code></a>.
-Any C&nbsp;library can store data into this table,
-but it should take care to choose keys different from those used
-by other libraries, to avoid collisions.
-Typically, you should use as key a string containing your library name
-or a light userdata with the address of a C&nbsp;object in your code.
-
-
-<p>
-The integer keys in the registry are used by the reference mechanism,
-implemented by the auxiliary library,
-and therefore should not be used for other purposes.
-
-
-
-
-
-<h2>3.6 - <a name="3.6">Error Handling in C</a></h2>
-
-<p>
-Internally, Lua uses the C <code>longjmp</code> facility to handle errors.
-(You can also choose to use exceptions if you use C++;
-see file <code>luaconf.h</code>.)
-When Lua faces any error
-(such as memory allocation errors, type errors, syntax errors,
-and runtime errors)
-it <em>raises</em> an error;
-that is, it does a long jump.
-A <em>protected environment</em> uses <code>setjmp</code>
-to set a recover point;
-any error jumps to the most recent active recover point.
-
-
-<p>
-Most functions in the API can throw an error,
-for instance due to a memory allocation error.
-The documentation for each function indicates whether
-it can throw errors.
-
-
-<p>
-Inside a C&nbsp;function you can throw an error by calling <a href="#lua_error"><code>lua_error</code></a>.
-
-
-
-
-
-<h2>3.7 - <a name="3.7">Functions and Types</a></h2>
-
-<p>
-Here we list all functions and types from the C&nbsp;API in
-alphabetical order.
-Each function has an indicator like this:
-<span class="apii">[-o, +p, <em>x</em>]</span>
-
-
-<p>
-The first field, <code>o</code>,
-is how many elements the function pops from the stack.
-The second field, <code>p</code>,
-is how many elements the function pushes onto the stack.
-(Any function always pushes its results after popping its arguments.)
-A field in the form <code>x|y</code> means the function can push (or pop)
-<code>x</code> or <code>y</code> elements,
-depending on the situation;
-an interrogation mark '<code>?</code>' means that
-we cannot know how many elements the function pops/pushes
-by looking only at its arguments
-(e.g., they may depend on what is on the stack).
-The third field, <code>x</code>,
-tells whether the function may throw errors:
-'<code>-</code>' means the function never throws any error;
-'<code>m</code>' means the function may throw an error
-only due to not enough memory;
-'<code>e</code>' means the function may throw other kinds of errors;
-'<code>v</code>' means the function may throw an error on purpose.
-
-
-
-<hr><h3><a name="lua_Alloc"><code>lua_Alloc</code></a></h3>
-<pre>typedef void * (*lua_Alloc) (void *ud,
-                             void *ptr,
-                             size_t osize,
-                             size_t nsize);</pre>
-
-<p>
-The type of the memory-allocation function used by Lua states.
-The allocator function must provide a
-functionality similar to <code>realloc</code>,
-but not exactly the same.
-Its arguments are
-<code>ud</code>, an opaque pointer passed to <a href="#lua_newstate"><code>lua_newstate</code></a>;
-<code>ptr</code>, a pointer to the block being allocated/reallocated/freed;
-<code>osize</code>, the original size of the block;
-<code>nsize</code>, the new size of the block.
-<code>ptr</code> is <code>NULL</code> if and only if <code>osize</code> is zero.
-When <code>nsize</code> is zero, the allocator must return <code>NULL</code>;
-if <code>osize</code> is not zero,
-it should free the block pointed to by <code>ptr</code>.
-When <code>nsize</code> is not zero, the allocator returns <code>NULL</code>
-if and only if it cannot fill the request.
-When <code>nsize</code> is not zero and <code>osize</code> is zero,
-the allocator should behave like <code>malloc</code>.
-When <code>nsize</code> and <code>osize</code> are not zero,
-the allocator behaves like <code>realloc</code>.
-Lua assumes that the allocator never fails when
-<code>osize &gt;= nsize</code>.
-
-
-<p>
-Here is a simple implementation for the allocator function.
-It is used in the auxiliary library by <a href="#luaL_newstate"><code>luaL_newstate</code></a>.
-
-<pre>
-     static void *l_alloc (void *ud, void *ptr, size_t osize,
-                                                size_t nsize) {
-       (void)ud;  (void)osize;  /* not used */
-       if (nsize == 0) {
-         free(ptr);
-         return NULL;
-       }
-       else
-         return realloc(ptr, nsize);
-     }
-</pre><p>
-This code assumes
-that <code>free(NULL)</code> has no effect and that
-<code>realloc(NULL, size)</code> is equivalent to <code>malloc(size)</code>.
-ANSI&nbsp;C ensures both behaviors.
-
-
-
-
-
-<hr><h3><a name="lua_atpanic"><code>lua_atpanic</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);</pre>
-
-<p>
-Sets a new panic function and returns the old one.
-
-
-<p>
-If an error happens outside any protected environment,
-Lua calls a <em>panic function</em>
-and then calls <code>exit(EXIT_FAILURE)</code>,
-thus exiting the host application.
-Your panic function can avoid this exit by
-never returning (e.g., doing a long jump).
-
-
-<p>
-The panic function can access the error message at the top of the stack.
-
-
-
-
-
-<hr><h3><a name="lua_call"><code>lua_call</code></a></h3><p>
-<span class="apii">[-(nargs + 1), +nresults, <em>e</em>]</span>
-<pre>void lua_call (lua_State *L, int nargs, int nresults);</pre>
-
-<p>
-Calls a function.
-
-
-<p>
-To call a function you must use the following protocol:
-first, the function to be called is pushed onto the stack;
-then, the arguments to the function are pushed
-in direct order;
-that is, the first argument is pushed first.
-Finally you call <a href="#lua_call"><code>lua_call</code></a>;
-<code>nargs</code> is the number of arguments that you pushed onto the stack.
-All arguments and the function value are popped from the stack
-when the function is called.
-The function results are pushed onto the stack when the function returns.
-The number of results is adjusted to <code>nresults</code>,
-unless <code>nresults</code> is <a name="pdf-LUA_MULTRET"><code>LUA_MULTRET</code></a>.
-In this case, <em>all</em> results from the function are pushed.
-Lua takes care that the returned values fit into the stack space.
-The function results are pushed onto the stack in direct order
-(the first result is pushed first),
-so that after the call the last result is on the top of the stack.
-
-
-<p>
-Any error inside the called function is propagated upwards
-(with a <code>longjmp</code>).
-
-
-<p>
-The following example shows how the host program can do the
-equivalent to this Lua code:
-
-<pre>
-     a = f("how", t.x, 14)
-</pre><p>
-Here it is in&nbsp;C:
-
-<pre>
-     lua_getfield(L, LUA_GLOBALSINDEX, "f"); /* function to be called */
-     lua_pushstring(L, "how");                        /* 1st argument */
-     lua_getfield(L, LUA_GLOBALSINDEX, "t");   /* table to be indexed */
-     lua_getfield(L, -1, "x");        /* push result of t.x (2nd arg) */
-     lua_remove(L, -2);                  /* remove 't' from the stack */
-     lua_pushinteger(L, 14);                          /* 3rd argument */
-     lua_call(L, 3, 1);     /* call 'f' with 3 arguments and 1 result */
-     lua_setfield(L, LUA_GLOBALSINDEX, "a");        /* set global 'a' */
-</pre><p>
-Note that the code above is "balanced":
-at its end, the stack is back to its original configuration.
-This is considered good programming practice.
-
-
-
-
-
-<hr><h3><a name="lua_CFunction"><code>lua_CFunction</code></a></h3>
-<pre>typedef int (*lua_CFunction) (lua_State *L);</pre>
-
-<p>
-Type for C&nbsp;functions.
-
-
-<p>
-In order to communicate properly with Lua,
-a C&nbsp;function must use the following protocol,
-which defines the way parameters and results are passed:
-a C&nbsp;function receives its arguments from Lua in its stack
-in direct order (the first argument is pushed first).
-So, when the function starts,
-<code>lua_gettop(L)</code> returns the number of arguments received by the function.
-The first argument (if any) is at index 1
-and its last argument is at index <code>lua_gettop(L)</code>.
-To return values to Lua, a C&nbsp;function just pushes them onto the stack,
-in direct order (the first result is pushed first),
-and returns the number of results.
-Any other value in the stack below the results will be properly
-discarded by Lua.
-Like a Lua function, a C&nbsp;function called by Lua can also return
-many results.
-
-
-<p>
-As an example, the following function receives a variable number
-of numerical arguments and returns their average and sum:
-
-<pre>
-     static int foo (lua_State *L) {
-       int n = lua_gettop(L);    /* number of arguments */
-       lua_Number sum = 0;
-       int i;
-       for (i = 1; i &lt;= n; i++) {
-         if (!lua_isnumber(L, i)) {
-           lua_pushstring(L, "incorrect argument");
-           lua_error(L);
-         }
-         sum += lua_tonumber(L, i);
-       }
-       lua_pushnumber(L, sum/n);        /* first result */
-       lua_pushnumber(L, sum);         /* second result */
-       return 2;                   /* number of results */
-     }
-</pre>
-
-
-
-
-<hr><h3><a name="lua_checkstack"><code>lua_checkstack</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>int lua_checkstack (lua_State *L, int extra);</pre>
-
-<p>
-Ensures that there are at least <code>extra</code> free stack slots in the stack.
-It returns false if it cannot grow the stack to that size.
-This function never shrinks the stack;
-if the stack is already larger than the new size,
-it is left unchanged.
-
-
-
-
-
-<hr><h3><a name="lua_close"><code>lua_close</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>void lua_close (lua_State *L);</pre>
-
-<p>
-Destroys all objects in the given Lua state
-(calling the corresponding garbage-collection metamethods, if any)
-and frees all dynamic memory used by this state.
-On several platforms, you may not need to call this function,
-because all resources are naturally released when the host program ends.
-On the other hand, long-running programs,
-such as a daemon or a web server,
-might need to release states as soon as they are not needed,
-to avoid growing too large.
-
-
-
-
-
-<hr><h3><a name="lua_concat"><code>lua_concat</code></a></h3><p>
-<span class="apii">[-n, +1, <em>e</em>]</span>
-<pre>void lua_concat (lua_State *L, int n);</pre>
-
-<p>
-Concatenates the <code>n</code> values at the top of the stack,
-pops them, and leaves the result at the top.
-If <code>n</code>&nbsp;is&nbsp;1, the result is the single value on the stack
-(that is, the function does nothing);
-if <code>n</code> is 0, the result is the empty string.
-Concatenation is performed following the usual semantics of Lua
-(see <a href="#2.5.4">&sect;2.5.4</a>).
-
-
-
-
-
-<hr><h3><a name="lua_cpcall"><code>lua_cpcall</code></a></h3><p>
-<span class="apii">[-0, +(0|1), <em>-</em>]</span>
-<pre>int lua_cpcall (lua_State *L, lua_CFunction func, void *ud);</pre>
-
-<p>
-Calls the C&nbsp;function <code>func</code> in protected mode.
-<code>func</code> starts with only one element in its stack,
-a light userdata containing <code>ud</code>.
-In case of errors,
-<a href="#lua_cpcall"><code>lua_cpcall</code></a> returns the same error codes as <a href="#lua_pcall"><code>lua_pcall</code></a>,
-plus the error object on the top of the stack;
-otherwise, it returns zero, and does not change the stack.
-All values returned by <code>func</code> are discarded.
-
-
-
-
-
-<hr><h3><a name="lua_createtable"><code>lua_createtable</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void lua_createtable (lua_State *L, int narr, int nrec);</pre>
-
-<p>
-Creates a new empty table and pushes it onto the stack.
-The new table has space pre-allocated
-for <code>narr</code> array elements and <code>nrec</code> non-array elements.
-This pre-allocation is useful when you know exactly how many elements
-the table will have.
-Otherwise you can use the function <a href="#lua_newtable"><code>lua_newtable</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_dump"><code>lua_dump</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>int lua_dump (lua_State *L, lua_Writer writer, void *data);</pre>
-
-<p>
-Dumps a function as a binary chunk.
-Receives a Lua function on the top of the stack
-and produces a binary chunk that,
-if loaded again,
-results in a function equivalent to the one dumped.
-As it produces parts of the chunk,
-<a href="#lua_dump"><code>lua_dump</code></a> calls function <code>writer</code> (see <a href="#lua_Writer"><code>lua_Writer</code></a>)
-with the given <code>data</code>
-to write them.
-
-
-<p>
-The value returned is the error code returned by the last
-call to the writer;
-0&nbsp;means no errors.
-
-
-<p>
-This function does not pop the Lua function from the stack.
-
-
-
-
-
-<hr><h3><a name="lua_equal"><code>lua_equal</code></a></h3><p>
-<span class="apii">[-0, +0, <em>e</em>]</span>
-<pre>int lua_equal (lua_State *L, int index1, int index2);</pre>
-
-<p>
-Returns 1 if the two values in acceptable indices <code>index1</code> and
-<code>index2</code> are equal,
-following the semantics of the Lua <code>==</code> operator
-(that is, may call metamethods).
-Otherwise returns&nbsp;0.
-Also returns&nbsp;0 if any of the indices is non valid.
-
-
-
-
-
-<hr><h3><a name="lua_error"><code>lua_error</code></a></h3><p>
-<span class="apii">[-1, +0, <em>v</em>]</span>
-<pre>int lua_error (lua_State *L);</pre>
-
-<p>
-Generates a Lua error.
-The error message (which can actually be a Lua value of any type)
-must be on the stack top.
-This function does a long jump,
-and therefore never returns.
-(see <a href="#luaL_error"><code>luaL_error</code></a>).
-
-
-
-
-
-<hr><h3><a name="lua_gc"><code>lua_gc</code></a></h3><p>
-<span class="apii">[-0, +0, <em>e</em>]</span>
-<pre>int lua_gc (lua_State *L, int what, int data);</pre>
-
-<p>
-Controls the garbage collector.
-
-
-<p>
-This function performs several tasks,
-according to the value of the parameter <code>what</code>:
-
-<ul>
-
-<li><b><code>LUA_GCSTOP</code>:</b>
-stops the garbage collector.
-</li>
-
-<li><b><code>LUA_GCRESTART</code>:</b>
-restarts the garbage collector.
-</li>
-
-<li><b><code>LUA_GCCOLLECT</code>:</b>
-performs a full garbage-collection cycle.
-</li>
-
-<li><b><code>LUA_GCCOUNT</code>:</b>
-returns the current amount of memory (in Kbytes) in use by Lua.
-</li>
-
-<li><b><code>LUA_GCCOUNTB</code>:</b>
-returns the remainder of dividing the current amount of bytes of
-memory in use by Lua by 1024.
-</li>
-
-<li><b><code>LUA_GCSTEP</code>:</b>
-performs an incremental step of garbage collection.
-The step "size" is controlled by <code>data</code>
-(larger values mean more steps) in a non-specified way.
-If you want to control the step size
-you must experimentally tune the value of <code>data</code>.
-The function returns 1 if the step finished a
-garbage-collection cycle.
-</li>
-
-<li><b><code>LUA_GCSETPAUSE</code>:</b>
-sets <code>data</code> as the new value
-for the <em>pause</em> of the collector (see <a href="#2.10">&sect;2.10</a>).
-The function returns the previous value of the pause.
-</li>
-
-<li><b><code>LUA_GCSETSTEPMUL</code>:</b>
-sets <code>data</code> as the new value for the <em>step multiplier</em> of
-the collector (see <a href="#2.10">&sect;2.10</a>).
-The function returns the previous value of the step multiplier.
-</li>
-
-</ul>
-
-
-
-
-<hr><h3><a name="lua_getallocf"><code>lua_getallocf</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_Alloc lua_getallocf (lua_State *L, void **ud);</pre>
-
-<p>
-Returns the memory-allocation function of a given state.
-If <code>ud</code> is not <code>NULL</code>, Lua stores in <code>*ud</code> the
-opaque pointer passed to <a href="#lua_newstate"><code>lua_newstate</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_getfenv"><code>lua_getfenv</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_getfenv (lua_State *L, int index);</pre>
-
-<p>
-Pushes onto the stack the environment table of
-the value at the given index.
-
-
-
-
-
-<hr><h3><a name="lua_getfield"><code>lua_getfield</code></a></h3><p>
-<span class="apii">[-0, +1, <em>e</em>]</span>
-<pre>void lua_getfield (lua_State *L, int index, const char *k);</pre>
-
-<p>
-Pushes onto the stack the value <code>t[k]</code>,
-where <code>t</code> is the value at the given valid index.
-As in Lua, this function may trigger a metamethod
-for the "index" event (see <a href="#2.8">&sect;2.8</a>).
-
-
-
-
-
-<hr><h3><a name="lua_getglobal"><code>lua_getglobal</code></a></h3><p>
-<span class="apii">[-0, +1, <em>e</em>]</span>
-<pre>void lua_getglobal (lua_State *L, const char *name);</pre>
-
-<p>
-Pushes onto the stack the value of the global <code>name</code>.
-It is defined as a macro:
-
-<pre>
-     #define lua_getglobal(L,s)  lua_getfield(L, LUA_GLOBALSINDEX, s)
-</pre>
-
-
-
-
-<hr><h3><a name="lua_getmetatable"><code>lua_getmetatable</code></a></h3><p>
-<span class="apii">[-0, +(0|1), <em>-</em>]</span>
-<pre>int lua_getmetatable (lua_State *L, int index);</pre>
-
-<p>
-Pushes onto the stack the metatable of the value at the given
-acceptable index.
-If the index is not valid,
-or if the value does not have a metatable,
-the function returns&nbsp;0 and pushes nothing on the stack.
-
-
-
-
-
-<hr><h3><a name="lua_gettable"><code>lua_gettable</code></a></h3><p>
-<span class="apii">[-1, +1, <em>e</em>]</span>
-<pre>void lua_gettable (lua_State *L, int index);</pre>
-
-<p>
-Pushes onto the stack the value <code>t[k]</code>,
-where <code>t</code> is the value at the given valid index
-and <code>k</code> is the value at the top of the stack.
-
-
-<p>
-This function pops the key from the stack
-(putting the resulting value in its place).
-As in Lua, this function may trigger a metamethod
-for the "index" event (see <a href="#2.8">&sect;2.8</a>).
-
-
-
-
-
-<hr><h3><a name="lua_gettop"><code>lua_gettop</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_gettop (lua_State *L);</pre>
-
-<p>
-Returns the index of the top element in the stack.
-Because indices start at&nbsp;1,
-this result is equal to the number of elements in the stack
-(and so 0&nbsp;means an empty stack).
-
-
-
-
-
-<hr><h3><a name="lua_insert"><code>lua_insert</code></a></h3><p>
-<span class="apii">[-1, +1, <em>-</em>]</span>
-<pre>void lua_insert (lua_State *L, int index);</pre>
-
-<p>
-Moves the top element into the given valid index,
-shifting up the elements above this index to open space.
-Cannot be called with a pseudo-index,
-because a pseudo-index is not an actual stack position.
-
-
-
-
-
-<hr><h3><a name="lua_Integer"><code>lua_Integer</code></a></h3>
-<pre>typedef ptrdiff_t lua_Integer;</pre>
-
-<p>
-The type used by the Lua API to represent integral values.
-
-
-<p>
-By default it is a <code>ptrdiff_t</code>,
-which is usually the largest signed integral type the machine handles
-"comfortably".
-
-
-
-
-
-<hr><h3><a name="lua_isboolean"><code>lua_isboolean</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isboolean (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index has type boolean,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_iscfunction"><code>lua_iscfunction</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_iscfunction (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a C&nbsp;function,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isfunction"><code>lua_isfunction</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isfunction (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a function
-(either C or Lua), and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_islightuserdata"><code>lua_islightuserdata</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_islightuserdata (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a light userdata,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isnil"><code>lua_isnil</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isnil (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is <b>nil</b>,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isnone"><code>lua_isnone</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isnone (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the given acceptable index is not valid
-(that is, it refers to an element outside the current stack),
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isnoneornil"><code>lua_isnoneornil</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isnoneornil (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the given acceptable index is not valid
-(that is, it refers to an element outside the current stack)
-or if the value at this index is <b>nil</b>,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isnumber"><code>lua_isnumber</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isnumber (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a number
-or a string convertible to a number,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isstring"><code>lua_isstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isstring (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a string
-or a number (which is always convertible to a string),
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_istable"><code>lua_istable</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_istable (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a table,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isthread"><code>lua_isthread</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isthread (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a thread,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isuserdata"><code>lua_isuserdata</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_isuserdata (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given acceptable index is a userdata
-(either full or light), and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_lessthan"><code>lua_lessthan</code></a></h3><p>
-<span class="apii">[-0, +0, <em>e</em>]</span>
-<pre>int lua_lessthan (lua_State *L, int index1, int index2);</pre>
-
-<p>
-Returns 1 if the value at acceptable index <code>index1</code> is smaller
-than the value at acceptable index <code>index2</code>,
-following the semantics of the Lua <code>&lt;</code> operator
-(that is, may call metamethods).
-Otherwise returns&nbsp;0.
-Also returns&nbsp;0 if any of the indices is non valid.
-
-
-
-
-
-<hr><h3><a name="lua_load"><code>lua_load</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>int lua_load (lua_State *L,
-              lua_Reader reader,
-              void *data,
-              const char *chunkname);</pre>
-
-<p>
-Loads a Lua chunk.
-If there are no errors,
-<a href="#lua_load"><code>lua_load</code></a> pushes the compiled chunk as a Lua
-function on top of the stack.
-Otherwise, it pushes an error message.
-The return values of <a href="#lua_load"><code>lua_load</code></a> are:
-
-<ul>
-
-<li><b>0:</b> no errors;</li>
-
-<li><b><a name="pdf-LUA_ERRSYNTAX"><code>LUA_ERRSYNTAX</code></a>:</b>
-syntax error during pre-compilation;</li>
-
-<li><b><a href="#pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>:</b>
-memory allocation error.</li>
-
-</ul>
-
-<p>
-This function only loads a chunk;
-it does not run it.
-
-
-<p>
-<a href="#lua_load"><code>lua_load</code></a> automatically detects whether the chunk is text or binary,
-and loads it accordingly (see program <code>luac</code>).
-
-
-<p>
-The <a href="#lua_load"><code>lua_load</code></a> function uses a user-supplied <code>reader</code> function
-to read the chunk (see <a href="#lua_Reader"><code>lua_Reader</code></a>).
-The <code>data</code> argument is an opaque value passed to the reader function.
-
-
-<p>
-The <code>chunkname</code> argument gives a name to the chunk,
-which is used for error messages and in debug information (see <a href="#3.8">&sect;3.8</a>).
-
-
-
-
-
-<hr><h3><a name="lua_newstate"><code>lua_newstate</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_State *lua_newstate (lua_Alloc f, void *ud);</pre>
-
-<p>
-Creates a new, independent state.
-Returns <code>NULL</code> if cannot create the state
-(due to lack of memory).
-The argument <code>f</code> is the allocator function;
-Lua does all memory allocation for this state through this function.
-The second argument, <code>ud</code>, is an opaque pointer that Lua
-simply passes to the allocator in every call.
-
-
-
-
-
-<hr><h3><a name="lua_newtable"><code>lua_newtable</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void lua_newtable (lua_State *L);</pre>
-
-<p>
-Creates a new empty table and pushes it onto the stack.
-It is equivalent to <code>lua_createtable(L, 0, 0)</code>.
-
-
-
-
-
-<hr><h3><a name="lua_newthread"><code>lua_newthread</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>lua_State *lua_newthread (lua_State *L);</pre>
-
-<p>
-Creates a new thread, pushes it on the stack,
-and returns a pointer to a <a href="#lua_State"><code>lua_State</code></a> that represents this new thread.
-The new state returned by this function shares with the original state
-all global objects (such as tables),
-but has an independent execution stack.
-
-
-<p>
-There is no explicit function to close or to destroy a thread.
-Threads are subject to garbage collection,
-like any Lua object.
-
-
-
-
-
-<hr><h3><a name="lua_newuserdata"><code>lua_newuserdata</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void *lua_newuserdata (lua_State *L, size_t size);</pre>
-
-<p>
-This function allocates a new block of memory with the given size,
-pushes onto the stack a new full userdata with the block address,
-and returns this address.
-
-
-<p>
-Userdata represent C&nbsp;values in Lua.
-A <em>full userdata</em> represents a block of memory.
-It is an object (like a table):
-you must create it, it can have its own metatable,
-and you can detect when it is being collected.
-A full userdata is only equal to itself (under raw equality).
-
-
-<p>
-When Lua collects a full userdata with a <code>gc</code> metamethod,
-Lua calls the metamethod and marks the userdata as finalized.
-When this userdata is collected again then
-Lua frees its corresponding memory.
-
-
-
-
-
-<hr><h3><a name="lua_next"><code>lua_next</code></a></h3><p>
-<span class="apii">[-1, +(2|0), <em>e</em>]</span>
-<pre>int lua_next (lua_State *L, int index);</pre>
-
-<p>
-Pops a key from the stack,
-and pushes a key-value pair from the table at the given index
-(the "next" pair after the given key).
-If there are no more elements in the table,
-then <a href="#lua_next"><code>lua_next</code></a> returns 0 (and pushes nothing).
-
-
-<p>
-A typical traversal looks like this:
-
-<pre>
-     /* table is in the stack at index 't' */
-     lua_pushnil(L);  /* first key */
-     while (lua_next(L, t) != 0) {
-       /* uses 'key' (at index -2) and 'value' (at index -1) */
-       printf("%s - %s\n",
-              lua_typename(L, lua_type(L, -2)),
-              lua_typename(L, lua_type(L, -1)));
-       /* removes 'value'; keeps 'key' for next iteration */
-       lua_pop(L, 1);
-     }
-</pre>
-
-<p>
-While traversing a table,
-do not call <a href="#lua_tolstring"><code>lua_tolstring</code></a> directly on a key,
-unless you know that the key is actually a string.
-Recall that <a href="#lua_tolstring"><code>lua_tolstring</code></a> <em>changes</em>
-the value at the given index;
-this confuses the next call to <a href="#lua_next"><code>lua_next</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_Number"><code>lua_Number</code></a></h3>
-<pre>typedef double lua_Number;</pre>
-
-<p>
-The type of numbers in Lua.
-By default, it is double, but that can be changed in <code>luaconf.h</code>.
-
-
-<p>
-Through the configuration file you can change
-Lua to operate with another type for numbers (e.g., float or long).
-
-
-
-
-
-<hr><h3><a name="lua_objlen"><code>lua_objlen</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>size_t lua_objlen (lua_State *L, int index);</pre>
-
-<p>
-Returns the "length" of the value at the given acceptable index:
-for strings, this is the string length;
-for tables, this is the result of the length operator ('<code>#</code>');
-for userdata, this is the size of the block of memory allocated
-for the userdata;
-for other values, it is&nbsp;0.
-
-
-
-
-
-<hr><h3><a name="lua_pcall"><code>lua_pcall</code></a></h3><p>
-<span class="apii">[-(nargs + 1), +(nresults|1), <em>-</em>]</span>
-<pre>int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);</pre>
-
-<p>
-Calls a function in protected mode.
-
-
-<p>
-Both <code>nargs</code> and <code>nresults</code> have the same meaning as
-in <a href="#lua_call"><code>lua_call</code></a>.
-If there are no errors during the call,
-<a href="#lua_pcall"><code>lua_pcall</code></a> behaves exactly like <a href="#lua_call"><code>lua_call</code></a>.
-However, if there is any error,
-<a href="#lua_pcall"><code>lua_pcall</code></a> catches it,
-pushes a single value on the stack (the error message),
-and returns an error code.
-Like <a href="#lua_call"><code>lua_call</code></a>,
-<a href="#lua_pcall"><code>lua_pcall</code></a> always removes the function
-and its arguments from the stack.
-
-
-<p>
-If <code>errfunc</code> is 0,
-then the error message returned on the stack
-is exactly the original error message.
-Otherwise, <code>errfunc</code> is the stack index of an
-<em>error handler function</em>.
-(In the current implementation, this index cannot be a pseudo-index.)
-In case of runtime errors,
-this function will be called with the error message
-and its return value will be the message returned on the stack by <a href="#lua_pcall"><code>lua_pcall</code></a>.
-
-
-<p>
-Typically, the error handler function is used to add more debug
-information to the error message, such as a stack traceback.
-Such information cannot be gathered after the return of <a href="#lua_pcall"><code>lua_pcall</code></a>,
-since by then the stack has unwound.
-
-
-<p>
-The <a href="#lua_pcall"><code>lua_pcall</code></a> function returns 0 in case of success
-or one of the following error codes
-(defined in <code>lua.h</code>):
-
-<ul>
-
-<li><b><a name="pdf-LUA_ERRRUN"><code>LUA_ERRRUN</code></a>:</b>
-a runtime error.
-</li>
-
-<li><b><a name="pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>:</b>
-memory allocation error.
-For such errors, Lua does not call the error handler function.
-</li>
-
-<li><b><a name="pdf-LUA_ERRERR"><code>LUA_ERRERR</code></a>:</b>
-error while running the error handler function.
-</li>
-
-</ul>
-
-
-
-
-<hr><h3><a name="lua_pop"><code>lua_pop</code></a></h3><p>
-<span class="apii">[-n, +0, <em>-</em>]</span>
-<pre>void lua_pop (lua_State *L, int n);</pre>
-
-<p>
-Pops <code>n</code> elements from the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushboolean"><code>lua_pushboolean</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_pushboolean (lua_State *L, int b);</pre>
-
-<p>
-Pushes a boolean value with value <code>b</code> onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushcclosure"><code>lua_pushcclosure</code></a></h3><p>
-<span class="apii">[-n, +1, <em>m</em>]</span>
-<pre>void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);</pre>
-
-<p>
-Pushes a new C&nbsp;closure onto the stack.
-
-
-<p>
-When a C&nbsp;function is created,
-it is possible to associate some values with it,
-thus creating a C&nbsp;closure (see <a href="#3.4">&sect;3.4</a>);
-these values are then accessible to the function whenever it is called.
-To associate values with a C&nbsp;function,
-first these values should be pushed onto the stack
-(when there are multiple values, the first value is pushed first).
-Then <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a>
-is called to create and push the C&nbsp;function onto the stack,
-with the argument <code>n</code> telling how many values should be
-associated with the function.
-<a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a> also pops these values from the stack.
-
-
-<p>
-The maximum value for <code>n</code> is 255.
-
-
-
-
-
-<hr><h3><a name="lua_pushcfunction"><code>lua_pushcfunction</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void lua_pushcfunction (lua_State *L, lua_CFunction f);</pre>
-
-<p>
-Pushes a C&nbsp;function onto the stack.
-This function receives a pointer to a C function
-and pushes onto the stack a Lua value of type <code>function</code> that,
-when called, invokes the corresponding C&nbsp;function.
-
-
-<p>
-Any function to be registered in Lua must
-follow the correct protocol to receive its parameters
-and return its results (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>).
-
-
-<p>
-<code>lua_pushcfunction</code> is defined as a macro:
-
-<pre>
-     #define lua_pushcfunction(L,f)  lua_pushcclosure(L,f,0)
-</pre>
-
-
-
-
-<hr><h3><a name="lua_pushfstring"><code>lua_pushfstring</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>const char *lua_pushfstring (lua_State *L, const char *fmt, ...);</pre>
-
-<p>
-Pushes onto the stack a formatted string
-and returns a pointer to this string.
-It is similar to the C&nbsp;function <code>sprintf</code>,
-but has some important differences:
-
-<ul>
-
-<li>
-You do not have to allocate space for the result:
-the result is a Lua string and Lua takes care of memory allocation
-(and deallocation, through garbage collection).
-</li>
-
-<li>
-The conversion specifiers are quite restricted.
-There are no flags, widths, or precisions.
-The conversion specifiers can only be
-'<code>%%</code>' (inserts a '<code>%</code>' in the string),
-'<code>%s</code>' (inserts a zero-terminated string, with no size restrictions),
-'<code>%f</code>' (inserts a <a href="#lua_Number"><code>lua_Number</code></a>),
-'<code>%p</code>' (inserts a pointer as a hexadecimal numeral),
-'<code>%d</code>' (inserts an <code>int</code>), and
-'<code>%c</code>' (inserts an <code>int</code> as a character).
-</li>
-
-</ul>
-
-
-
-
-<hr><h3><a name="lua_pushinteger"><code>lua_pushinteger</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_pushinteger (lua_State *L, lua_Integer n);</pre>
-
-<p>
-Pushes a number with value <code>n</code> onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushlightuserdata"><code>lua_pushlightuserdata</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_pushlightuserdata (lua_State *L, void *p);</pre>
-
-<p>
-Pushes a light userdata onto the stack.
-
-
-<p>
-Userdata represent C&nbsp;values in Lua.
-A <em>light userdata</em> represents a pointer.
-It is a value (like a number):
-you do not create it, it has no individual metatable,
-and it is not collected (as it was never created).
-A light userdata is equal to "any"
-light userdata with the same C&nbsp;address.
-
-
-
-
-
-<hr><h3><a name="lua_pushliteral"><code>lua_pushliteral</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void lua_pushliteral (lua_State *L, const char *s);</pre>
-
-<p>
-This macro is equivalent to <a href="#lua_pushlstring"><code>lua_pushlstring</code></a>,
-but can be used only when <code>s</code> is a literal string.
-In these cases, it automatically provides the string length.
-
-
-
-
-
-<hr><h3><a name="lua_pushlstring"><code>lua_pushlstring</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void lua_pushlstring (lua_State *L, const char *s, size_t len);</pre>
-
-<p>
-Pushes the string pointed to by <code>s</code> with size <code>len</code>
-onto the stack.
-Lua makes (or reuses) an internal copy of the given string,
-so the memory at <code>s</code> can be freed or reused immediately after
-the function returns.
-The string can contain embedded zeros.
-
-
-
-
-
-<hr><h3><a name="lua_pushnil"><code>lua_pushnil</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_pushnil (lua_State *L);</pre>
-
-<p>
-Pushes a nil value onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushnumber"><code>lua_pushnumber</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_pushnumber (lua_State *L, lua_Number n);</pre>
-
-<p>
-Pushes a number with value <code>n</code> onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushstring"><code>lua_pushstring</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void lua_pushstring (lua_State *L, const char *s);</pre>
-
-<p>
-Pushes the zero-terminated string pointed to by <code>s</code>
-onto the stack.
-Lua makes (or reuses) an internal copy of the given string,
-so the memory at <code>s</code> can be freed or reused immediately after
-the function returns.
-The string cannot contain embedded zeros;
-it is assumed to end at the first zero.
-
-
-
-
-
-<hr><h3><a name="lua_pushthread"><code>lua_pushthread</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>int lua_pushthread (lua_State *L);</pre>
-
-<p>
-Pushes the thread represented by <code>L</code> onto the stack.
-Returns 1 if this thread is the main thread of its state.
-
-
-
-
-
-<hr><h3><a name="lua_pushvalue"><code>lua_pushvalue</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_pushvalue (lua_State *L, int index);</pre>
-
-<p>
-Pushes a copy of the element at the given valid index
-onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushvfstring"><code>lua_pushvfstring</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>const char *lua_pushvfstring (lua_State *L,
-                              const char *fmt,
-                              va_list argp);</pre>
-
-<p>
-Equivalent to <a href="#lua_pushfstring"><code>lua_pushfstring</code></a>, except that it receives a <code>va_list</code>
-instead of a variable number of arguments.
-
-
-
-
-
-<hr><h3><a name="lua_rawequal"><code>lua_rawequal</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_rawequal (lua_State *L, int index1, int index2);</pre>
-
-<p>
-Returns 1 if the two values in acceptable indices <code>index1</code> and
-<code>index2</code> are primitively equal
-(that is, without calling metamethods).
-Otherwise returns&nbsp;0.
-Also returns&nbsp;0 if any of the indices are non valid.
-
-
-
-
-
-<hr><h3><a name="lua_rawget"><code>lua_rawget</code></a></h3><p>
-<span class="apii">[-1, +1, <em>-</em>]</span>
-<pre>void lua_rawget (lua_State *L, int index);</pre>
-
-<p>
-Similar to <a href="#lua_gettable"><code>lua_gettable</code></a>, but does a raw access
-(i.e., without metamethods).
-
-
-
-
-
-<hr><h3><a name="lua_rawgeti"><code>lua_rawgeti</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void lua_rawgeti (lua_State *L, int index, int n);</pre>
-
-<p>
-Pushes onto the stack the value <code>t[n]</code>,
-where <code>t</code> is the value at the given valid index.
-The access is raw;
-that is, it does not invoke metamethods.
-
-
-
-
-
-<hr><h3><a name="lua_rawset"><code>lua_rawset</code></a></h3><p>
-<span class="apii">[-2, +0, <em>m</em>]</span>
-<pre>void lua_rawset (lua_State *L, int index);</pre>
-
-<p>
-Similar to <a href="#lua_settable"><code>lua_settable</code></a>, but does a raw assignment
-(i.e., without metamethods).
-
-
-
-
-
-<hr><h3><a name="lua_rawseti"><code>lua_rawseti</code></a></h3><p>
-<span class="apii">[-1, +0, <em>m</em>]</span>
-<pre>void lua_rawseti (lua_State *L, int index, int n);</pre>
-
-<p>
-Does the equivalent of <code>t[n] = v</code>,
-where <code>t</code> is the value at the given valid index
-and <code>v</code> is the value at the top of the stack.
-
-
-<p>
-This function pops the value from the stack.
-The assignment is raw;
-that is, it does not invoke metamethods.
-
-
-
-
-
-<hr><h3><a name="lua_Reader"><code>lua_Reader</code></a></h3>
-<pre>typedef const char * (*lua_Reader) (lua_State *L,
-                                    void *data,
-                                    size_t *size);</pre>
-
-<p>
-The reader function used by <a href="#lua_load"><code>lua_load</code></a>.
-Every time it needs another piece of the chunk,
-<a href="#lua_load"><code>lua_load</code></a> calls the reader,
-passing along its <code>data</code> parameter.
-The reader must return a pointer to a block of memory
-with a new piece of the chunk
-and set <code>size</code> to the block size.
-The block must exist until the reader function is called again.
-To signal the end of the chunk,
-the reader must return <code>NULL</code> or set <code>size</code> to zero.
-The reader function may return pieces of any size greater than zero.
-
-
-
-
-
-<hr><h3><a name="lua_register"><code>lua_register</code></a></h3><p>
-<span class="apii">[-0, +0, <em>e</em>]</span>
-<pre>void lua_register (lua_State *L,
-                   const char *name,
-                   lua_CFunction f);</pre>
-
-<p>
-Sets the C function <code>f</code> as the new value of global <code>name</code>.
-It is defined as a macro:
-
-<pre>
-     #define lua_register(L,n,f) \
-            (lua_pushcfunction(L, f), lua_setglobal(L, n))
-</pre>
-
-
-
-
-<hr><h3><a name="lua_remove"><code>lua_remove</code></a></h3><p>
-<span class="apii">[-1, +0, <em>-</em>]</span>
-<pre>void lua_remove (lua_State *L, int index);</pre>
-
-<p>
-Removes the element at the given valid index,
-shifting down the elements above this index to fill the gap.
-Cannot be called with a pseudo-index,
-because a pseudo-index is not an actual stack position.
-
-
-
-
-
-<hr><h3><a name="lua_replace"><code>lua_replace</code></a></h3><p>
-<span class="apii">[-1, +0, <em>-</em>]</span>
-<pre>void lua_replace (lua_State *L, int index);</pre>
-
-<p>
-Moves the top element into the given position (and pops it),
-without shifting any element
-(therefore replacing the value at the given position).
-
-
-
-
-
-<hr><h3><a name="lua_resume"><code>lua_resume</code></a></h3><p>
-<span class="apii">[-?, +?, <em>-</em>]</span>
-<pre>int lua_resume (lua_State *L, int narg);</pre>
-
-<p>
-Starts and resumes a coroutine in a given thread.
-
-
-<p>
-To start a coroutine, you first create a new thread
-(see <a href="#lua_newthread"><code>lua_newthread</code></a>);
-then you push onto its stack the main function plus any arguments;
-then you call <a href="#lua_resume"><code>lua_resume</code></a>,
-with <code>narg</code> being the number of arguments.
-This call returns when the coroutine suspends or finishes its execution.
-When it returns, the stack contains all values passed to <a href="#lua_yield"><code>lua_yield</code></a>,
-or all values returned by the body function.
-<a href="#lua_resume"><code>lua_resume</code></a> returns
-<a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> if the coroutine yields,
-0 if the coroutine finishes its execution
-without errors,
-or an error code in case of errors (see <a href="#lua_pcall"><code>lua_pcall</code></a>).
-In case of errors,
-the stack is not unwound,
-so you can use the debug API over it.
-The error message is on the top of the stack.
-To restart a coroutine, you put on its stack only the values to
-be passed as results from <code>yield</code>,
-and then call <a href="#lua_resume"><code>lua_resume</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_setallocf"><code>lua_setallocf</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);</pre>
-
-<p>
-Changes the allocator function of a given state to <code>f</code>
-with user data <code>ud</code>.
-
-
-
-
-
-<hr><h3><a name="lua_setfenv"><code>lua_setfenv</code></a></h3><p>
-<span class="apii">[-1, +0, <em>-</em>]</span>
-<pre>int lua_setfenv (lua_State *L, int index);</pre>
-
-<p>
-Pops a table from the stack and sets it as
-the new environment for the value at the given index.
-If the value at the given index is
-neither a function nor a thread nor a userdata,
-<a href="#lua_setfenv"><code>lua_setfenv</code></a> returns 0.
-Otherwise it returns 1.
-
-
-
-
-
-<hr><h3><a name="lua_setfield"><code>lua_setfield</code></a></h3><p>
-<span class="apii">[-1, +0, <em>e</em>]</span>
-<pre>void lua_setfield (lua_State *L, int index, const char *k);</pre>
-
-<p>
-Does the equivalent to <code>t[k] = v</code>,
-where <code>t</code> is the value at the given valid index
-and <code>v</code> is the value at the top of the stack.
-
-
-<p>
-This function pops the value from the stack.
-As in Lua, this function may trigger a metamethod
-for the "newindex" event (see <a href="#2.8">&sect;2.8</a>).
-
-
-
-
-
-<hr><h3><a name="lua_setglobal"><code>lua_setglobal</code></a></h3><p>
-<span class="apii">[-1, +0, <em>e</em>]</span>
-<pre>void lua_setglobal (lua_State *L, const char *name);</pre>
-
-<p>
-Pops a value from the stack and
-sets it as the new value of global <code>name</code>.
-It is defined as a macro:
-
-<pre>
-     #define lua_setglobal(L,s)   lua_setfield(L, LUA_GLOBALSINDEX, s)
-</pre>
-
-
-
-
-<hr><h3><a name="lua_setmetatable"><code>lua_setmetatable</code></a></h3><p>
-<span class="apii">[-1, +0, <em>-</em>]</span>
-<pre>int lua_setmetatable (lua_State *L, int index);</pre>
-
-<p>
-Pops a table from the stack and
-sets it as the new metatable for the value at the given
-acceptable index.
-
-
-
-
-
-<hr><h3><a name="lua_settable"><code>lua_settable</code></a></h3><p>
-<span class="apii">[-2, +0, <em>e</em>]</span>
-<pre>void lua_settable (lua_State *L, int index);</pre>
-
-<p>
-Does the equivalent to <code>t[k] = v</code>,
-where <code>t</code> is the value at the given valid index,
-<code>v</code> is the value at the top of the stack,
-and <code>k</code> is the value just below the top.
-
-
-<p>
-This function pops both the key and the value from the stack.
-As in Lua, this function may trigger a metamethod
-for the "newindex" event (see <a href="#2.8">&sect;2.8</a>).
-
-
-
-
-
-<hr><h3><a name="lua_settop"><code>lua_settop</code></a></h3><p>
-<span class="apii">[-?, +?, <em>-</em>]</span>
-<pre>void lua_settop (lua_State *L, int index);</pre>
-
-<p>
-Accepts any acceptable index, or&nbsp;0,
-and sets the stack top to this index.
-If the new top is larger than the old one,
-then the new elements are filled with <b>nil</b>.
-If <code>index</code> is&nbsp;0, then all stack elements are removed.
-
-
-
-
-
-<hr><h3><a name="lua_State"><code>lua_State</code></a></h3>
-<pre>typedef struct lua_State lua_State;</pre>
-
-<p>
-Opaque structure that keeps the whole state of a Lua interpreter.
-The Lua library is fully reentrant:
-it has no global variables.
-All information about a state is kept in this structure.
-
-
-<p>
-A pointer to this state must be passed as the first argument to
-every function in the library, except to <a href="#lua_newstate"><code>lua_newstate</code></a>,
-which creates a Lua state from scratch.
-
-
-
-
-
-<hr><h3><a name="lua_status"><code>lua_status</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_status (lua_State *L);</pre>
-
-<p>
-Returns the status of the thread <code>L</code>.
-
-
-<p>
-The status can be 0 for a normal thread,
-an error code if the thread finished its execution with an error,
-or <a name="pdf-LUA_YIELD"><code>LUA_YIELD</code></a> if the thread is suspended.
-
-
-
-
-
-<hr><h3><a name="lua_toboolean"><code>lua_toboolean</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_toboolean (lua_State *L, int index);</pre>
-
-<p>
-Converts the Lua value at the given acceptable index to a C&nbsp;boolean
-value (0&nbsp;or&nbsp;1).
-Like all tests in Lua,
-<a href="#lua_toboolean"><code>lua_toboolean</code></a> returns 1 for any Lua value
-different from <b>false</b> and <b>nil</b>;
-otherwise it returns 0.
-It also returns 0 when called with a non-valid index.
-(If you want to accept only actual boolean values,
-use <a href="#lua_isboolean"><code>lua_isboolean</code></a> to test the value's type.)
-
-
-
-
-
-<hr><h3><a name="lua_tocfunction"><code>lua_tocfunction</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_CFunction lua_tocfunction (lua_State *L, int index);</pre>
-
-<p>
-Converts a value at the given acceptable index to a C&nbsp;function.
-That value must be a C&nbsp;function;
-otherwise, returns <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_tointeger"><code>lua_tointeger</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_Integer lua_tointeger (lua_State *L, int index);</pre>
-
-<p>
-Converts the Lua value at the given acceptable index
-to the signed integral type <a href="#lua_Integer"><code>lua_Integer</code></a>.
-The Lua value must be a number or a string convertible to a number
-(see <a href="#2.2.1">&sect;2.2.1</a>);
-otherwise, <a href="#lua_tointeger"><code>lua_tointeger</code></a> returns&nbsp;0.
-
-
-<p>
-If the number is not an integer,
-it is truncated in some non-specified way.
-
-
-
-
-
-<hr><h3><a name="lua_tolstring"><code>lua_tolstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>const char *lua_tolstring (lua_State *L, int index, size_t *len);</pre>
-
-<p>
-Converts the Lua value at the given acceptable index to a C&nbsp;string.
-If <code>len</code> is not <code>NULL</code>,
-it also sets <code>*len</code> with the string length.
-The Lua value must be a string or a number;
-otherwise, the function returns <code>NULL</code>.
-If the value is a number,
-then <a href="#lua_tolstring"><code>lua_tolstring</code></a> also
-<em>changes the actual value in the stack to a string</em>.
-(This change confuses <a href="#lua_next"><code>lua_next</code></a>
-when <a href="#lua_tolstring"><code>lua_tolstring</code></a> is applied to keys during a table traversal.)
-
-
-<p>
-<a href="#lua_tolstring"><code>lua_tolstring</code></a> returns a fully aligned pointer
-to a string inside the Lua state.
-This string always has a zero ('<code>\0</code>')
-after its last character (as in&nbsp;C),
-but can contain other zeros in its body.
-Because Lua has garbage collection,
-there is no guarantee that the pointer returned by <a href="#lua_tolstring"><code>lua_tolstring</code></a>
-will be valid after the corresponding value is removed from the stack.
-
-
-
-
-
-<hr><h3><a name="lua_tonumber"><code>lua_tonumber</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_Number lua_tonumber (lua_State *L, int index);</pre>
-
-<p>
-Converts the Lua value at the given acceptable index
-to the C&nbsp;type <a href="#lua_Number"><code>lua_Number</code></a> (see <a href="#lua_Number"><code>lua_Number</code></a>).
-The Lua value must be a number or a string convertible to a number
-(see <a href="#2.2.1">&sect;2.2.1</a>);
-otherwise, <a href="#lua_tonumber"><code>lua_tonumber</code></a> returns&nbsp;0.
-
-
-
-
-
-<hr><h3><a name="lua_topointer"><code>lua_topointer</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>const void *lua_topointer (lua_State *L, int index);</pre>
-
-<p>
-Converts the value at the given acceptable index to a generic
-C&nbsp;pointer (<code>void*</code>).
-The value can be a userdata, a table, a thread, or a function;
-otherwise, <a href="#lua_topointer"><code>lua_topointer</code></a> returns <code>NULL</code>.
-Different objects will give different pointers.
-There is no way to convert the pointer back to its original value.
-
-
-<p>
-Typically this function is used only for debug information.
-
-
-
-
-
-<hr><h3><a name="lua_tostring"><code>lua_tostring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>const char *lua_tostring (lua_State *L, int index);</pre>
-
-<p>
-Equivalent to <a href="#lua_tolstring"><code>lua_tolstring</code></a> with <code>len</code> equal to <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_tothread"><code>lua_tothread</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_State *lua_tothread (lua_State *L, int index);</pre>
-
-<p>
-Converts the value at the given acceptable index to a Lua thread
-(represented as <code>lua_State*</code>).
-This value must be a thread;
-otherwise, the function returns <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_touserdata"><code>lua_touserdata</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>void *lua_touserdata (lua_State *L, int index);</pre>
-
-<p>
-If the value at the given acceptable index is a full userdata,
-returns its block address.
-If the value is a light userdata,
-returns its pointer.
-Otherwise, returns <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_type"><code>lua_type</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_type (lua_State *L, int index);</pre>
-
-<p>
-Returns the type of the value in the given acceptable index,
-or <code>LUA_TNONE</code> for a non-valid index
-(that is, an index to an "empty" stack position).
-The types returned by <a href="#lua_type"><code>lua_type</code></a> are coded by the following constants
-defined in <code>lua.h</code>:
-<code>LUA_TNIL</code>,
-<code>LUA_TNUMBER</code>,
-<code>LUA_TBOOLEAN</code>,
-<code>LUA_TSTRING</code>,
-<code>LUA_TTABLE</code>,
-<code>LUA_TFUNCTION</code>,
-<code>LUA_TUSERDATA</code>,
-<code>LUA_TTHREAD</code>,
-and
-<code>LUA_TLIGHTUSERDATA</code>.
-
-
-
-
-
-<hr><h3><a name="lua_typename"><code>lua_typename</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>const char *lua_typename  (lua_State *L, int tp);</pre>
-
-<p>
-Returns the name of the type encoded by the value <code>tp</code>,
-which must be one the values returned by <a href="#lua_type"><code>lua_type</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_Writer"><code>lua_Writer</code></a></h3>
-<pre>typedef int (*lua_Writer) (lua_State *L,
-                           const void* p,
-                           size_t sz,
-                           void* ud);</pre>
-
-<p>
-The type of the writer function used by <a href="#lua_dump"><code>lua_dump</code></a>.
-Every time it produces another piece of chunk,
-<a href="#lua_dump"><code>lua_dump</code></a> calls the writer,
-passing along the buffer to be written (<code>p</code>),
-its size (<code>sz</code>),
-and the <code>data</code> parameter supplied to <a href="#lua_dump"><code>lua_dump</code></a>.
-
-
-<p>
-The writer returns an error code:
-0&nbsp;means no errors;
-any other value means an error and stops <a href="#lua_dump"><code>lua_dump</code></a> from
-calling the writer again.
-
-
-
-
-
-<hr><h3><a name="lua_xmove"><code>lua_xmove</code></a></h3><p>
-<span class="apii">[-?, +?, <em>-</em>]</span>
-<pre>void lua_xmove (lua_State *from, lua_State *to, int n);</pre>
-
-<p>
-Exchange values between different threads of the <em>same</em> global state.
-
-
-<p>
-This function pops <code>n</code> values from the stack <code>from</code>,
-and pushes them onto the stack <code>to</code>.
-
-
-
-
-
-<hr><h3><a name="lua_yield"><code>lua_yield</code></a></h3><p>
-<span class="apii">[-?, +?, <em>-</em>]</span>
-<pre>int lua_yield  (lua_State *L, int nresults);</pre>
-
-<p>
-Yields a coroutine.
-
-
-<p>
-This function should only be called as the
-return expression of a C&nbsp;function, as follows:
-
-<pre>
-     return lua_yield (L, nresults);
-</pre><p>
-When a C&nbsp;function calls <a href="#lua_yield"><code>lua_yield</code></a> in that way,
-the running coroutine suspends its execution,
-and the call to <a href="#lua_resume"><code>lua_resume</code></a> that started this coroutine returns.
-The parameter <code>nresults</code> is the number of values from the stack
-that are passed as results to <a href="#lua_resume"><code>lua_resume</code></a>.
-
-
-
-
-
-
-
-<h2>3.8 - <a name="3.8">The Debug Interface</a></h2>
-
-<p>
-Lua has no built-in debugging facilities.
-Instead, it offers a special interface
-by means of functions and <em>hooks</em>.
-This interface allows the construction of different
-kinds of debuggers, profilers, and other tools
-that need "inside information" from the interpreter.
-
-
-
-<hr><h3><a name="lua_Debug"><code>lua_Debug</code></a></h3>
-<pre>typedef struct lua_Debug {
-  int event;
-  const char *name;           /* (n) */
-  const char *namewhat;       /* (n) */
-  const char *what;           /* (S) */
-  const char *source;         /* (S) */
-  int currentline;            /* (l) */
-  int nups;                   /* (u) number of upvalues */
-  int linedefined;            /* (S) */
-  int lastlinedefined;        /* (S) */
-  char short_src[LUA_IDSIZE]; /* (S) */
-  /* private part */
-  <em>other fields</em>
-} lua_Debug;</pre>
-
-<p>
-A structure used to carry different pieces of
-information about an active function.
-<a href="#lua_getstack"><code>lua_getstack</code></a> fills only the private part
-of this structure, for later use.
-To fill the other fields of <a href="#lua_Debug"><code>lua_Debug</code></a> with useful information,
-call <a href="#lua_getinfo"><code>lua_getinfo</code></a>.
-
-
-<p>
-The fields of <a href="#lua_Debug"><code>lua_Debug</code></a> have the following meaning:
-
-<ul>
-
-<li><b><code>source</code>:</b>
-If the function was defined in a string,
-then <code>source</code> is that string.
-If the function was defined in a file,
-then <code>source</code> starts with a '<code>@</code>' followed by the file name.
-</li>
-
-<li><b><code>short_src</code>:</b>
-a "printable" version of <code>source</code>, to be used in error messages.
-</li>
-
-<li><b><code>linedefined</code>:</b>
-the line number where the definition of the function starts.
-</li>
-
-<li><b><code>lastlinedefined</code>:</b>
-the line number where the definition of the function ends.
-</li>
-
-<li><b><code>what</code>:</b>
-the string <code>"Lua"</code> if the function is a Lua function,
-<code>"C"</code> if it is a C&nbsp;function,
-<code>"main"</code> if it is the main part of a chunk,
-and <code>"tail"</code> if it was a function that did a tail call.
-In the latter case,
-Lua has no other information about the function.
-</li>
-
-<li><b><code>currentline</code>:</b>
-the current line where the given function is executing.
-When no line information is available,
-<code>currentline</code> is set to -1.
-</li>
-
-<li><b><code>name</code>:</b>
-a reasonable name for the given function.
-Because functions in Lua are first-class values,
-they do not have a fixed name:
-some functions can be the value of multiple global variables,
-while others can be stored only in a table field.
-The <code>lua_getinfo</code> function checks how the function was
-called to find a suitable name.
-If it cannot find a name,
-then <code>name</code> is set to <code>NULL</code>.
-</li>
-
-<li><b><code>namewhat</code>:</b>
-explains the <code>name</code> field.
-The value of <code>namewhat</code> can be
-<code>"global"</code>, <code>"local"</code>, <code>"method"</code>,
-<code>"field"</code>, <code>"upvalue"</code>, or <code>""</code> (the empty string),
-according to how the function was called.
-(Lua uses the empty string when no other option seems to apply.)
-</li>
-
-<li><b><code>nups</code>:</b>
-the number of upvalues of the function.
-</li>
-
-</ul>
-
-
-
-
-<hr><h3><a name="lua_gethook"><code>lua_gethook</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_Hook lua_gethook (lua_State *L);</pre>
-
-<p>
-Returns the current hook function.
-
-
-
-
-
-<hr><h3><a name="lua_gethookcount"><code>lua_gethookcount</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_gethookcount (lua_State *L);</pre>
-
-<p>
-Returns the current hook count.
-
-
-
-
-
-<hr><h3><a name="lua_gethookmask"><code>lua_gethookmask</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_gethookmask (lua_State *L);</pre>
-
-<p>
-Returns the current hook mask.
-
-
-
-
-
-<hr><h3><a name="lua_getinfo"><code>lua_getinfo</code></a></h3><p>
-<span class="apii">[-(0|1), +(0|1|2), <em>m</em>]</span>
-<pre>int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);</pre>
-
-<p>
-Returns information about a specific function or function invocation.
-
-
-<p>
-To get information about a function invocation,
-the parameter <code>ar</code> must be a valid activation record that was
-filled by a previous call to <a href="#lua_getstack"><code>lua_getstack</code></a> or
-given as argument to a hook (see <a href="#lua_Hook"><code>lua_Hook</code></a>).
-
-
-<p>
-To get information about a function you push it onto the stack
-and start the <code>what</code> string with the character '<code>&gt;</code>'.
-(In that case,
-<code>lua_getinfo</code> pops the function in the top of the stack.)
-For instance, to know in which line a function <code>f</code> was defined,
-you can write the following code:
-
-<pre>
-     lua_Debug ar;
-     lua_getfield(L, LUA_GLOBALSINDEX, "f");  /* get global 'f' */
-     lua_getinfo(L, "&gt;S", &amp;ar);
-     printf("%d\n", ar.linedefined);
-</pre>
-
-<p>
-Each character in the string <code>what</code>
-selects some fields of the structure <code>ar</code> to be filled or
-a value to be pushed on the stack:
-
-<ul>
-
-<li><b>'<code>n</code>':</b> fills in the field <code>name</code> and <code>namewhat</code>;
-</li>
-
-<li><b>'<code>S</code>':</b>
-fills in the fields <code>source</code>, <code>short_src</code>,
-<code>linedefined</code>, <code>lastlinedefined</code>, and <code>what</code>;
-</li>
-
-<li><b>'<code>l</code>':</b> fills in the field <code>currentline</code>;
-</li>
-
-<li><b>'<code>u</code>':</b> fills in the field <code>nups</code>;
-</li>
-
-<li><b>'<code>f</code>':</b>
-pushes onto the stack the function that is
-running at the given level;
-</li>
-
-<li><b>'<code>L</code>':</b>
-pushes onto the stack a table whose indices are the
-numbers of the lines that are valid on the function.
-(A <em>valid line</em> is a line with some associated code,
-that is, a line where you can put a break point.
-Non-valid lines include empty lines and comments.)
-</li>
-
-</ul>
-
-<p>
-This function returns 0 on error
-(for instance, an invalid option in <code>what</code>).
-
-
-
-
-
-<hr><h3><a name="lua_getlocal"><code>lua_getlocal</code></a></h3><p>
-<span class="apii">[-0, +(0|1), <em>-</em>]</span>
-<pre>const char *lua_getlocal (lua_State *L, lua_Debug *ar, int n);</pre>
-
-<p>
-Gets information about a local variable of a given activation record.
-The parameter <code>ar</code> must be a valid activation record that was
-filled by a previous call to <a href="#lua_getstack"><code>lua_getstack</code></a> or
-given as argument to a hook (see <a href="#lua_Hook"><code>lua_Hook</code></a>).
-The index <code>n</code> selects which local variable to inspect
-(1 is the first parameter or active local variable, and so on,
-until the last active local variable).
-<a href="#lua_getlocal"><code>lua_getlocal</code></a> pushes the variable's value onto the stack
-and returns its name.
-
-
-<p>
-Variable names starting with '<code>(</code>' (open parentheses)
-represent internal variables
-(loop control variables, temporaries, and C&nbsp;function locals).
-
-
-<p>
-Returns <code>NULL</code> (and pushes nothing)
-when the index is greater than
-the number of active local variables.
-
-
-
-
-
-<hr><h3><a name="lua_getstack"><code>lua_getstack</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_getstack (lua_State *L, int level, lua_Debug *ar);</pre>
-
-<p>
-Get information about the interpreter runtime stack.
-
-
-<p>
-This function fills parts of a <a href="#lua_Debug"><code>lua_Debug</code></a> structure with
-an identification of the <em>activation record</em>
-of the function executing at a given level.
-Level&nbsp;0 is the current running function,
-whereas level <em>n+1</em> is the function that has called level <em>n</em>.
-When there are no errors, <a href="#lua_getstack"><code>lua_getstack</code></a> returns 1;
-when called with a level greater than the stack depth,
-it returns 0.
-
-
-
-
-
-<hr><h3><a name="lua_getupvalue"><code>lua_getupvalue</code></a></h3><p>
-<span class="apii">[-0, +(0|1), <em>-</em>]</span>
-<pre>const char *lua_getupvalue (lua_State *L, int funcindex, int n);</pre>
-
-<p>
-Gets information about a closure's upvalue.
-(For Lua functions,
-upvalues are the external local variables that the function uses,
-and that are consequently included in its closure.)
-<a href="#lua_getupvalue"><code>lua_getupvalue</code></a> gets the index <code>n</code> of an upvalue,
-pushes the upvalue's value onto the stack,
-and returns its name.
-<code>funcindex</code> points to the closure in the stack.
-(Upvalues have no particular order,
-as they are active through the whole function.
-So, they are numbered in an arbitrary order.)
-
-
-<p>
-Returns <code>NULL</code> (and pushes nothing)
-when the index is greater than the number of upvalues.
-For C&nbsp;functions, this function uses the empty string <code>""</code>
-as a name for all upvalues.
-
-
-
-
-
-<hr><h3><a name="lua_Hook"><code>lua_Hook</code></a></h3>
-<pre>typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);</pre>
-
-<p>
-Type for debugging hook functions.
-
-
-<p>
-Whenever a hook is called, its <code>ar</code> argument has its field
-<code>event</code> set to the specific event that triggered the hook.
-Lua identifies these events with the following constants:
-<a name="pdf-LUA_HOOKCALL"><code>LUA_HOOKCALL</code></a>, <a name="pdf-LUA_HOOKRET"><code>LUA_HOOKRET</code></a>,
-<a name="pdf-LUA_HOOKTAILRET"><code>LUA_HOOKTAILRET</code></a>, <a name="pdf-LUA_HOOKLINE"><code>LUA_HOOKLINE</code></a>,
-and <a name="pdf-LUA_HOOKCOUNT"><code>LUA_HOOKCOUNT</code></a>.
-Moreover, for line events, the field <code>currentline</code> is also set.
-To get the value of any other field in <code>ar</code>,
-the hook must call <a href="#lua_getinfo"><code>lua_getinfo</code></a>.
-For return events, <code>event</code> can be <code>LUA_HOOKRET</code>,
-the normal value, or <code>LUA_HOOKTAILRET</code>.
-In the latter case, Lua is simulating a return from
-a function that did a tail call;
-in this case, it is useless to call <a href="#lua_getinfo"><code>lua_getinfo</code></a>.
-
-
-<p>
-While Lua is running a hook, it disables other calls to hooks.
-Therefore, if a hook calls back Lua to execute a function or a chunk,
-this execution occurs without any calls to hooks.
-
-
-
-
-
-<hr><h3><a name="lua_sethook"><code>lua_sethook</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>int lua_sethook (lua_State *L, lua_Hook f, int mask, int count);</pre>
-
-<p>
-Sets the debugging hook function.
-
-
-<p>
-Argument <code>f</code> is the hook function.
-<code>mask</code> specifies on which events the hook will be called:
-it is formed by a bitwise or of the constants
-<a name="pdf-LUA_MASKCALL"><code>LUA_MASKCALL</code></a>,
-<a name="pdf-LUA_MASKRET"><code>LUA_MASKRET</code></a>,
-<a name="pdf-LUA_MASKLINE"><code>LUA_MASKLINE</code></a>,
-and <a name="pdf-LUA_MASKCOUNT"><code>LUA_MASKCOUNT</code></a>.
-The <code>count</code> argument is only meaningful when the mask
-includes <code>LUA_MASKCOUNT</code>.
-For each event, the hook is called as explained below:
-
-<ul>
-
-<li><b>The call hook:</b> is called when the interpreter calls a function.
-The hook is called just after Lua enters the new function,
-before the function gets its arguments.
-</li>
-
-<li><b>The return hook:</b> is called when the interpreter returns from a function.
-The hook is called just before Lua leaves the function.
-You have no access to the values to be returned by the function.
-</li>
-
-<li><b>The line hook:</b> is called when the interpreter is about to
-start the execution of a new line of code,
-or when it jumps back in the code (even to the same line).
-(This event only happens while Lua is executing a Lua function.)
-</li>
-
-<li><b>The count hook:</b> is called after the interpreter executes every
-<code>count</code> instructions.
-(This event only happens while Lua is executing a Lua function.)
-</li>
-
-</ul>
-
-<p>
-A hook is disabled by setting <code>mask</code> to zero.
-
-
-
-
-
-<hr><h3><a name="lua_setlocal"><code>lua_setlocal</code></a></h3><p>
-<span class="apii">[-(0|1), +0, <em>-</em>]</span>
-<pre>const char *lua_setlocal (lua_State *L, lua_Debug *ar, int n);</pre>
-
-<p>
-Sets the value of a local variable of a given activation record.
-Parameters <code>ar</code> and <code>n</code> are as in <a href="#lua_getlocal"><code>lua_getlocal</code></a>
-(see <a href="#lua_getlocal"><code>lua_getlocal</code></a>).
-<a href="#lua_setlocal"><code>lua_setlocal</code></a> assigns the value at the top of the stack
-to the variable and returns its name.
-It also pops the value from the stack.
-
-
-<p>
-Returns <code>NULL</code> (and pops nothing)
-when the index is greater than
-the number of active local variables.
-
-
-
-
-
-<hr><h3><a name="lua_setupvalue"><code>lua_setupvalue</code></a></h3><p>
-<span class="apii">[-(0|1), +0, <em>-</em>]</span>
-<pre>const char *lua_setupvalue (lua_State *L, int funcindex, int n);</pre>
-
-<p>
-Sets the value of a closure's upvalue.
-It assigns the value at the top of the stack
-to the upvalue and returns its name.
-It also pops the value from the stack.
-Parameters <code>funcindex</code> and <code>n</code> are as in the <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>
-(see <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>).
-
-
-<p>
-Returns <code>NULL</code> (and pops nothing)
-when the index is greater than the number of upvalues.
-
-
-
-
-
-
-
-<h1>4 - <a name="4">The Auxiliary Library</a></h1>
-
-<p>
-
-The <em>auxiliary library</em> provides several convenient functions
-to interface C with Lua.
-While the basic API provides the primitive functions for all 
-interactions between C and Lua,
-the auxiliary library provides higher-level functions for some
-common tasks.
-
-
-<p>
-All functions from the auxiliary library
-are defined in header file <code>lauxlib.h</code> and
-have a prefix <code>luaL_</code>.
-
-
-<p>
-All functions in the auxiliary library are built on
-top of the basic API,
-and so they provide nothing that cannot be done with this API.
-
-
-<p>
-Several functions in the auxiliary library are used to
-check C&nbsp;function arguments.
-Their names are always <code>luaL_check*</code> or <code>luaL_opt*</code>.
-All of these functions throw an error if the check is not satisfied.
-Because the error message is formatted for arguments
-(e.g., "<code>bad argument #1</code>"),
-you should not use these functions for other stack values.
-
-
-
-<h2>4.1 - <a name="4.1">Functions and Types</a></h2>
-
-<p>
-Here we list all functions and types from the auxiliary library
-in alphabetical order.
-
-
-
-<hr><h3><a name="luaL_addchar"><code>luaL_addchar</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>void luaL_addchar (luaL_Buffer *B, char c);</pre>
-
-<p>
-Adds the character <code>c</code> to the buffer <code>B</code>
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_addlstring"><code>luaL_addlstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);</pre>
-
-<p>
-Adds the string pointed to by <code>s</code> with length <code>l</code> to
-the buffer <code>B</code>
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-The string may contain embedded zeros.
-
-
-
-
-
-<hr><h3><a name="luaL_addsize"><code>luaL_addsize</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>void luaL_addsize (luaL_Buffer *B, size_t n);</pre>
-
-<p>
-Adds to the buffer <code>B</code> (see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>)
-a string of length <code>n</code> previously copied to the
-buffer area (see <a href="#luaL_prepbuffer"><code>luaL_prepbuffer</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_addstring"><code>luaL_addstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>void luaL_addstring (luaL_Buffer *B, const char *s);</pre>
-
-<p>
-Adds the zero-terminated string pointed to by <code>s</code>
-to the buffer <code>B</code>
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-The string may not contain embedded zeros.
-
-
-
-
-
-<hr><h3><a name="luaL_addvalue"><code>luaL_addvalue</code></a></h3><p>
-<span class="apii">[-1, +0, <em>m</em>]</span>
-<pre>void luaL_addvalue (luaL_Buffer *B);</pre>
-
-<p>
-Adds the value at the top of the stack
-to the buffer <code>B</code>
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-Pops the value.
-
-
-<p>
-This is the only function on string buffers that can (and must)
-be called with an extra element on the stack,
-which is the value to be added to the buffer.
-
-
-
-
-
-<hr><h3><a name="luaL_argcheck"><code>luaL_argcheck</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void luaL_argcheck (lua_State *L,
-                    int cond,
-                    int narg,
-                    const char *extramsg);</pre>
-
-<p>
-Checks whether <code>cond</code> is true.
-If not, raises an error with the following message,
-where <code>func</code> is retrieved from the call stack:
-
-<pre>
-     bad argument #&lt;narg&gt; to &lt;func&gt; (&lt;extramsg&gt;)
-</pre>
-
-
-
-
-<hr><h3><a name="luaL_argerror"><code>luaL_argerror</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_argerror (lua_State *L, int narg, const char *extramsg);</pre>
-
-<p>
-Raises an error with the following message,
-where <code>func</code> is retrieved from the call stack:
-
-<pre>
-     bad argument #&lt;narg&gt; to &lt;func&gt; (&lt;extramsg&gt;)
-</pre>
-
-<p>
-This function never returns,
-but it is an idiom to use it in C&nbsp;functions
-as <code>return luaL_argerror(<em>args</em>)</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_Buffer"><code>luaL_Buffer</code></a></h3>
-<pre>typedef struct luaL_Buffer luaL_Buffer;</pre>
-
-<p>
-Type for a <em>string buffer</em>.
-
-
-<p>
-A string buffer allows C&nbsp;code to build Lua strings piecemeal.
-Its pattern of use is as follows:
-
-<ul>
-
-<li>First you declare a variable <code>b</code> of type <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>.</li>
-
-<li>Then you initialize it with a call <code>luaL_buffinit(L, &amp;b)</code>.</li>
-
-<li>
-Then you add string pieces to the buffer calling any of
-the <code>luaL_add*</code> functions.
-</li>
-
-<li>
-You finish by calling <code>luaL_pushresult(&amp;b)</code>.
-This call leaves the final string on the top of the stack.
-</li>
-
-</ul>
-
-<p>
-During its normal operation,
-a string buffer uses a variable number of stack slots.
-So, while using a buffer, you cannot assume that you know where
-the top of the stack is.
-You can use the stack between successive calls to buffer operations
-as long as that use is balanced;
-that is,
-when you call a buffer operation,
-the stack is at the same level
-it was immediately after the previous buffer operation.
-(The only exception to this rule is <a href="#luaL_addvalue"><code>luaL_addvalue</code></a>.)
-After calling <a href="#luaL_pushresult"><code>luaL_pushresult</code></a> the stack is back to its
-level when the buffer was initialized,
-plus the final string on its top.
-
-
-
-
-
-<hr><h3><a name="luaL_buffinit"><code>luaL_buffinit</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>void luaL_buffinit (lua_State *L, luaL_Buffer *B);</pre>
-
-<p>
-Initializes a buffer <code>B</code>.
-This function does not allocate any space;
-the buffer must be declared as a variable
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_callmeta"><code>luaL_callmeta</code></a></h3><p>
-<span class="apii">[-0, +(0|1), <em>e</em>]</span>
-<pre>int luaL_callmeta (lua_State *L, int obj, const char *e);</pre>
-
-<p>
-Calls a metamethod.
-
-
-<p>
-If the object at index <code>obj</code> has a metatable and this
-metatable has a field <code>e</code>,
-this function calls this field and passes the object as its only argument.
-In this case this function returns 1 and pushes onto the
-stack the value returned by the call.
-If there is no metatable or no metamethod,
-this function returns 0 (without pushing any value on the stack).
-
-
-
-
-
-<hr><h3><a name="luaL_checkany"><code>luaL_checkany</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void luaL_checkany (lua_State *L, int narg);</pre>
-
-<p>
-Checks whether the function has an argument
-of any type (including <b>nil</b>) at position <code>narg</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_checkint"><code>luaL_checkint</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_checkint (lua_State *L, int narg);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a number
-and returns this number cast to an <code>int</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_checkinteger"><code>luaL_checkinteger</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>lua_Integer luaL_checkinteger (lua_State *L, int narg);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a number
-and returns this number cast to a <a href="#lua_Integer"><code>lua_Integer</code></a>.
-
-
-
-
-
-<hr><h3><a name="luaL_checklong"><code>luaL_checklong</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>long luaL_checklong (lua_State *L, int narg);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a number
-and returns this number cast to a <code>long</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_checklstring"><code>luaL_checklstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>const char *luaL_checklstring (lua_State *L, int narg, size_t *l);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a string
-and returns this string;
-if <code>l</code> is not <code>NULL</code> fills <code>*l</code>
-with the string's length.
-
-
-<p>
-This function uses <a href="#lua_tolstring"><code>lua_tolstring</code></a> to get its result,
-so all conversions and caveats of that function apply here.
-
-
-
-
-
-<hr><h3><a name="luaL_checknumber"><code>luaL_checknumber</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>lua_Number luaL_checknumber (lua_State *L, int narg);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a number
-and returns this number.
-
-
-
-
-
-<hr><h3><a name="luaL_checkoption"><code>luaL_checkoption</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_checkoption (lua_State *L,
-                      int narg,
-                      const char *def,
-                      const char *const lst[]);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a string and
-searches for this string in the array <code>lst</code>
-(which must be NULL-terminated).
-Returns the index in the array where the string was found.
-Raises an error if the argument is not a string or
-if the string cannot be found.
-
-
-<p>
-If <code>def</code> is not <code>NULL</code>,
-the function uses <code>def</code> as a default value when
-there is no argument <code>narg</code> or if this argument is <b>nil</b>.
-
-
-<p>
-This is a useful function for mapping strings to C&nbsp;enums.
-(The usual convention in Lua libraries is
-to use strings instead of numbers to select options.)
-
-
-
-
-
-<hr><h3><a name="luaL_checkstack"><code>luaL_checkstack</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void luaL_checkstack (lua_State *L, int sz, const char *msg);</pre>
-
-<p>
-Grows the stack size to <code>top + sz</code> elements,
-raising an error if the stack cannot grow to that size.
-<code>msg</code> is an additional text to go into the error message.
-
-
-
-
-
-<hr><h3><a name="luaL_checkstring"><code>luaL_checkstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>const char *luaL_checkstring (lua_State *L, int narg);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a string
-and returns this string.
-
-
-<p>
-This function uses <a href="#lua_tolstring"><code>lua_tolstring</code></a> to get its result,
-so all conversions and caveats of that function apply here.
-
-
-
-
-
-<hr><h3><a name="luaL_checktype"><code>luaL_checktype</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void luaL_checktype (lua_State *L, int narg, int t);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> has type <code>t</code>.
-See <a href="#lua_type"><code>lua_type</code></a> for the encoding of types for <code>t</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_checkudata"><code>luaL_checkudata</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void *luaL_checkudata (lua_State *L, int narg, const char *tname);</pre>
-
-<p>
-Checks whether the function argument <code>narg</code> is a userdata
-of the type <code>tname</code> (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_dofile"><code>luaL_dofile</code></a></h3><p>
-<span class="apii">[-0, +?, <em>m</em>]</span>
-<pre>int luaL_dofile (lua_State *L, const char *filename);</pre>
-
-<p>
-Loads and runs the given file.
-It is defined as the following macro:
-
-<pre>
-     (luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0))
-</pre><p>
-It returns 0 if there are no errors
-or 1 in case of errors.
-
-
-
-
-
-<hr><h3><a name="luaL_dostring"><code>luaL_dostring</code></a></h3><p>
-<span class="apii">[-0, +?, <em>m</em>]</span>
-<pre>int luaL_dostring (lua_State *L, const char *str);</pre>
-
-<p>
-Loads and runs the given string.
-It is defined as the following macro:
-
-<pre>
-     (luaL_loadstring(L, str) || lua_pcall(L, 0, LUA_MULTRET, 0))
-</pre><p>
-It returns 0 if there are no errors
-or 1 in case of errors.
-
-
-
-
-
-<hr><h3><a name="luaL_error"><code>luaL_error</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_error (lua_State *L, const char *fmt, ...);</pre>
-
-<p>
-Raises an error.
-The error message format is given by <code>fmt</code>
-plus any extra arguments,
-following the same rules of <a href="#lua_pushfstring"><code>lua_pushfstring</code></a>.
-It also adds at the beginning of the message the file name and
-the line number where the error occurred,
-if this information is available.
-
-
-<p>
-This function never returns,
-but it is an idiom to use it in C&nbsp;functions
-as <code>return luaL_error(<em>args</em>)</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_getmetafield"><code>luaL_getmetafield</code></a></h3><p>
-<span class="apii">[-0, +(0|1), <em>m</em>]</span>
-<pre>int luaL_getmetafield (lua_State *L, int obj, const char *e);</pre>
-
-<p>
-Pushes onto the stack the field <code>e</code> from the metatable
-of the object at index <code>obj</code>.
-If the object does not have a metatable,
-or if the metatable does not have this field,
-returns 0 and pushes nothing.
-
-
-
-
-
-<hr><h3><a name="luaL_getmetatable"><code>luaL_getmetatable</code></a></h3><p>
-<span class="apii">[-0, +1, <em>-</em>]</span>
-<pre>void luaL_getmetatable (lua_State *L, const char *tname);</pre>
-
-<p>
-Pushes onto the stack the metatable associated with name <code>tname</code>
-in the registry (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_gsub"><code>luaL_gsub</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>const char *luaL_gsub (lua_State *L,
-                       const char *s,
-                       const char *p,
-                       const char *r);</pre>
-
-<p>
-Creates a copy of string <code>s</code> by replacing
-any occurrence of the string <code>p</code>
-with the string <code>r</code>.
-Pushes the resulting string on the stack and returns it.
-
-
-
-
-
-<hr><h3><a name="luaL_loadbuffer"><code>luaL_loadbuffer</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>int luaL_loadbuffer (lua_State *L,
-                     const char *buff,
-                     size_t sz,
-                     const char *name);</pre>
-
-<p>
-Loads a buffer as a Lua chunk.
-This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in the
-buffer pointed to by <code>buff</code> with size <code>sz</code>.
-
-
-<p>
-This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>.
-<code>name</code> is the chunk name,
-used for debug information and error messages.
-
-
-
-
-
-<hr><h3><a name="luaL_loadfile"><code>luaL_loadfile</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>int luaL_loadfile (lua_State *L, const char *filename);</pre>
-
-<p>
-Loads a file as a Lua chunk.
-This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in the file
-named <code>filename</code>.
-If <code>filename</code> is <code>NULL</code>,
-then it loads from the standard input.
-The first line in the file is ignored if it starts with a <code>#</code>.
-
-
-<p>
-This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>,
-but it has an extra error code <a name="pdf-LUA_ERRFILE"><code>LUA_ERRFILE</code></a>
-if it cannot open/read the file.
-
-
-<p>
-As <a href="#lua_load"><code>lua_load</code></a>, this function only loads the chunk;
-it does not run it.
-
-
-
-
-
-<hr><h3><a name="luaL_loadstring"><code>luaL_loadstring</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>int luaL_loadstring (lua_State *L, const char *s);</pre>
-
-<p>
-Loads a string as a Lua chunk.
-This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in
-the zero-terminated string <code>s</code>.
-
-
-<p>
-This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>.
-
-
-<p>
-Also as <a href="#lua_load"><code>lua_load</code></a>, this function only loads the chunk;
-it does not run it.
-
-
-
-
-
-<hr><h3><a name="luaL_newmetatable"><code>luaL_newmetatable</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>int luaL_newmetatable (lua_State *L, const char *tname);</pre>
-
-<p>
-If the registry already has the key <code>tname</code>,
-returns 0.
-Otherwise,
-creates a new table to be used as a metatable for userdata,
-adds it to the registry with key <code>tname</code>,
-and returns 1.
-
-
-<p>
-In both cases pushes onto the stack the final value associated
-with <code>tname</code> in the registry.
-
-
-
-
-
-<hr><h3><a name="luaL_newstate"><code>luaL_newstate</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>lua_State *luaL_newstate (void);</pre>
-
-<p>
-Creates a new Lua state.
-It calls <a href="#lua_newstate"><code>lua_newstate</code></a> with an
-allocator based on the standard&nbsp;C <code>realloc</code> function
-and then sets a panic function (see <a href="#lua_atpanic"><code>lua_atpanic</code></a>) that prints
-an error message to the standard error output in case of fatal
-errors.
-
-
-<p>
-Returns the new state,
-or <code>NULL</code> if there is a memory allocation error.
-
-
-
-
-
-<hr><h3><a name="luaL_openlibs"><code>luaL_openlibs</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>void luaL_openlibs (lua_State *L);</pre>
-
-<p>
-Opens all standard Lua libraries into the given state.
-
-
-
-
-
-<hr><h3><a name="luaL_optint"><code>luaL_optint</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_optint (lua_State *L, int narg, int d);</pre>
-
-<p>
-If the function argument <code>narg</code> is a number,
-returns this number cast to an <code>int</code>.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-
-
-
-<hr><h3><a name="luaL_optinteger"><code>luaL_optinteger</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>lua_Integer luaL_optinteger (lua_State *L,
-                             int narg,
-                             lua_Integer d);</pre>
-
-<p>
-If the function argument <code>narg</code> is a number,
-returns this number cast to a <a href="#lua_Integer"><code>lua_Integer</code></a>.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-
-
-
-<hr><h3><a name="luaL_optlong"><code>luaL_optlong</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>long luaL_optlong (lua_State *L, int narg, long d);</pre>
-
-<p>
-If the function argument <code>narg</code> is a number,
-returns this number cast to a <code>long</code>.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-
-
-
-<hr><h3><a name="luaL_optlstring"><code>luaL_optlstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>const char *luaL_optlstring (lua_State *L,
-                             int narg,
-                             const char *d,
-                             size_t *l);</pre>
-
-<p>
-If the function argument <code>narg</code> is a string,
-returns this string.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-<p>
-If <code>l</code> is not <code>NULL</code>,
-fills the position <code>*l</code> with the results's length.
-
-
-
-
-
-<hr><h3><a name="luaL_optnumber"><code>luaL_optnumber</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number d);</pre>
-
-<p>
-If the function argument <code>narg</code> is a number,
-returns this number.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-
-
-
-<hr><h3><a name="luaL_optstring"><code>luaL_optstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>const char *luaL_optstring (lua_State *L,
-                            int narg,
-                            const char *d);</pre>
-
-<p>
-If the function argument <code>narg</code> is a string,
-returns this string.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-
-
-
-<hr><h3><a name="luaL_prepbuffer"><code>luaL_prepbuffer</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>char *luaL_prepbuffer (luaL_Buffer *B);</pre>
-
-<p>
-Returns an address to a space of size <a name="pdf-LUAL_BUFFERSIZE"><code>LUAL_BUFFERSIZE</code></a>
-where you can copy a string to be added to buffer <code>B</code>
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-After copying the string into this space you must call
-<a href="#luaL_addsize"><code>luaL_addsize</code></a> with the size of the string to actually add 
-it to the buffer.
-
-
-
-
-
-<hr><h3><a name="luaL_pushresult"><code>luaL_pushresult</code></a></h3><p>
-<span class="apii">[-?, +1, <em>m</em>]</span>
-<pre>void luaL_pushresult (luaL_Buffer *B);</pre>
-
-<p>
-Finishes the use of buffer <code>B</code> leaving the final string on
-the top of the stack.
-
-
-
-
-
-<hr><h3><a name="luaL_ref"><code>luaL_ref</code></a></h3><p>
-<span class="apii">[-1, +0, <em>m</em>]</span>
-<pre>int luaL_ref (lua_State *L, int t);</pre>
-
-<p>
-Creates and returns a <em>reference</em>,
-in the table at index <code>t</code>,
-for the object at the top of the stack (and pops the object).
-
-
-<p>
-A reference is a unique integer key.
-As long as you do not manually add integer keys into table <code>t</code>,
-<a href="#luaL_ref"><code>luaL_ref</code></a> ensures the uniqueness of the key it returns.
-You can retrieve an object referred by reference <code>r</code>
-by calling <code>lua_rawgeti(L, t, r)</code>.
-Function <a href="#luaL_unref"><code>luaL_unref</code></a> frees a reference and its associated object.
-
-
-<p>
-If the object at the top of the stack is <b>nil</b>,
-<a href="#luaL_ref"><code>luaL_ref</code></a> returns the constant <a name="pdf-LUA_REFNIL"><code>LUA_REFNIL</code></a>.
-The constant <a name="pdf-LUA_NOREF"><code>LUA_NOREF</code></a> is guaranteed to be different
-from any reference returned by <a href="#luaL_ref"><code>luaL_ref</code></a>.
-
-
-
-
-
-<hr><h3><a name="luaL_Reg"><code>luaL_Reg</code></a></h3>
-<pre>typedef struct luaL_Reg {
-  const char *name;
-  lua_CFunction func;
-} luaL_Reg;</pre>
-
-<p>
-Type for arrays of functions to be registered by
-<a href="#luaL_register"><code>luaL_register</code></a>.
-<code>name</code> is the function name and <code>func</code> is a pointer to
-the function.
-Any array of <a href="#luaL_Reg"><code>luaL_Reg</code></a> must end with an sentinel entry
-in which both <code>name</code> and <code>func</code> are <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_register"><code>luaL_register</code></a></h3><p>
-<span class="apii">[-(0|1), +1, <em>m</em>]</span>
-<pre>void luaL_register (lua_State *L,
-                    const char *libname,
-                    const luaL_Reg *l);</pre>
-
-<p>
-Opens a library.
-
-
-<p>
-When called with <code>libname</code> equal to <code>NULL</code>,
-it simply registers all functions in the list <code>l</code>
-(see <a href="#luaL_Reg"><code>luaL_Reg</code></a>) into the table on the top of the stack.
-
-
-<p>
-When called with a non-null <code>libname</code>,
-<code>luaL_register</code> creates a new table <code>t</code>,
-sets it as the value of the global variable <code>libname</code>,
-sets it as the value of <code>package.loaded[libname]</code>,
-and registers on it all functions in the list <code>l</code>.
-If there is a table in <code>package.loaded[libname]</code> or in
-variable <code>libname</code>,
-reuses this table instead of creating a new one.
-
-
-<p>
-In any case the function leaves the table
-on the top of the stack.
-
-
-
-
-
-<hr><h3><a name="luaL_typename"><code>luaL_typename</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>const char *luaL_typename (lua_State *L, int index);</pre>
-
-<p>
-Returns the name of the type of the value at the given index.
-
-
-
-
-
-<hr><h3><a name="luaL_typerror"><code>luaL_typerror</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_typerror (lua_State *L, int narg, const char *tname);</pre>
-
-<p>
-Generates an error with a message like the following:
-
-<pre>
-     <em>location</em>: bad argument <em>narg</em> to '<em>func</em>' (<em>tname</em> expected, got <em>rt</em>)
-</pre><p>
-where <code><em>location</em></code> is produced by <a href="#luaL_where"><code>luaL_where</code></a>,
-<code><em>func</em></code> is the name of the current function,
-and <code><em>rt</em></code> is the type name of the actual argument.
-
-
-
-
-
-<hr><h3><a name="luaL_unref"><code>luaL_unref</code></a></h3><p>
-<span class="apii">[-0, +0, <em>-</em>]</span>
-<pre>void luaL_unref (lua_State *L, int t, int ref);</pre>
-
-<p>
-Releases reference <code>ref</code> from the table at index <code>t</code>
-(see <a href="#luaL_ref"><code>luaL_ref</code></a>).
-The entry is removed from the table,
-so that the referred object can be collected.
-The reference <code>ref</code> is also freed to be used again.
-
-
-<p>
-If <code>ref</code> is <a href="#pdf-LUA_NOREF"><code>LUA_NOREF</code></a> or <a href="#pdf-LUA_REFNIL"><code>LUA_REFNIL</code></a>,
-<a href="#luaL_unref"><code>luaL_unref</code></a> does nothing.
-
-
-
-
-
-<hr><h3><a name="luaL_where"><code>luaL_where</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void luaL_where (lua_State *L, int lvl);</pre>
-
-<p>
-Pushes onto the stack a string identifying the current position
-of the control at level <code>lvl</code> in the call stack.
-Typically this string has the following format:
-
-<pre>
-     <em>chunkname</em>:<em>currentline</em>:
-</pre><p>
-Level&nbsp;0 is the running function,
-level&nbsp;1 is the function that called the running function,
-etc.
-
-
-<p>
-This function is used to build a prefix for error messages.
-
-
-
-
-
-
-
-<h1>5 - <a name="5">Standard Libraries</a></h1>
-
-<p>
-The standard Lua libraries provide useful functions
-that are implemented directly through the C&nbsp;API.
-Some of these functions provide essential services to the language
-(e.g., <a href="#pdf-type"><code>type</code></a> and <a href="#pdf-getmetatable"><code>getmetatable</code></a>);
-others provide access to "outside" services (e.g., I/O);
-and others could be implemented in Lua itself,
-but are quite useful or have critical performance requirements that
-deserve an implementation in C (e.g., <a href="#pdf-table.sort"><code>table.sort</code></a>).
-
-
-<p>
-All libraries are implemented through the official C&nbsp;API
-and are provided as separate C&nbsp;modules.
-Currently, Lua has the following standard libraries:
-
-<ul>
-
-<li>basic library, which includes the coroutine sub-library;</li>
-
-<li>package library;</li>
-
-<li>string manipulation;</li>
-
-<li>table manipulation;</li>
-
-<li>mathematical functions (sin, log, etc.);</li>
-
-<li>input and output;</li>
-
-<li>operating system facilities;</li>
-
-<li>debug facilities.</li>
-
-</ul><p>
-Except for the basic and package libraries,
-each library provides all its functions as fields of a global table
-or as methods of its objects.
-
-
-<p>
-To have access to these libraries,
-the C&nbsp;host program should call the <a href="#luaL_openlibs"><code>luaL_openlibs</code></a> function,
-which opens all standard libraries.
-Alternatively,
-it can open them individually by calling
-<a name="pdf-luaopen_base"><code>luaopen_base</code></a> (for the basic library),
-<a name="pdf-luaopen_package"><code>luaopen_package</code></a> (for the package library),
-<a name="pdf-luaopen_string"><code>luaopen_string</code></a> (for the string library),
-<a name="pdf-luaopen_table"><code>luaopen_table</code></a> (for the table library),
-<a name="pdf-luaopen_math"><code>luaopen_math</code></a> (for the mathematical library),
-<a name="pdf-luaopen_io"><code>luaopen_io</code></a> (for the I/O library),
-<a name="pdf-luaopen_os"><code>luaopen_os</code></a> (for the Operating System library),
-and <a name="pdf-luaopen_debug"><code>luaopen_debug</code></a> (for the debug library).
-These functions are declared in <a name="pdf-lualib.h"><code>lualib.h</code></a>
-and should not be called directly:
-you must call them like any other Lua C&nbsp;function,
-e.g., by using <a href="#lua_call"><code>lua_call</code></a>.
-
-
-
-<h2>5.1 - <a name="5.1">Basic Functions</a></h2>
-
-<p>
-The basic library provides some core functions to Lua.
-If you do not include this library in your application,
-you should check carefully whether you need to provide 
-implementations for some of its facilities.
-
-
-<p>
-<hr><h3><a name="pdf-assert"><code>assert (v [, message])</code></a></h3>
-Issues an  error when
-the value of its argument <code>v</code> is false (i.e., <b>nil</b> or <b>false</b>);
-otherwise, returns all its arguments.
-<code>message</code> is an error message;
-when absent, it defaults to "assertion failed!"
-
-
-
-
-<p>
-<hr><h3><a name="pdf-collectgarbage"><code>collectgarbage ([opt [, arg]])</code></a></h3>
-
-
-<p>
-This function is a generic interface to the garbage collector.
-It performs different functions according to its first argument, <code>opt</code>:
-
-<ul>
-
-<li><b>"collect":</b>
-performs a full garbage-collection cycle.
-This is the default option.
-</li>
-
-<li><b>"stop":</b>
-stops the garbage collector.
-</li>
-
-<li><b>"restart":</b>
-restarts the garbage collector.
-</li>
-
-<li><b>"count":</b>
-returns the total memory in use by Lua (in Kbytes).
-</li>
-
-<li><b>"step":</b>
-performs a garbage-collection step.
-The step "size" is controlled by <code>arg</code>
-(larger values mean more steps) in a non-specified way.
-If you want to control the step size
-you must experimentally tune the value of <code>arg</code>.
-Returns <b>true</b> if the step finished a collection cycle.
-</li>
-
-<li><b>"setpause":</b>
-sets <code>arg</code> as the new value for the <em>pause</em> of
-the collector (see <a href="#2.10">&sect;2.10</a>).
-Returns the previous value for <em>pause</em>.
-</li>
-
-<li><b>"setstepmul":</b>
-sets <code>arg</code> as the new value for the <em>step multiplier</em> of
-the collector (see <a href="#2.10">&sect;2.10</a>).
-Returns the previous value for <em>step</em>.
-</li>
-
-</ul>
-
-
-
-<p>
-<hr><h3><a name="pdf-dofile"><code>dofile ([filename])</code></a></h3>
-Opens the named file and executes its contents as a Lua chunk.
-When called without arguments,
-<code>dofile</code> executes the contents of the standard input (<code>stdin</code>).
-Returns all values returned by the chunk.
-In case of errors, <code>dofile</code> propagates the error
-to its caller (that is, <code>dofile</code> does not run in protected mode).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-error"><code>error (message [, level])</code></a></h3>
-Terminates the last protected function called
-and returns <code>message</code> as the error message.
-Function <code>error</code> never returns.
-
-
-<p>
-Usually, <code>error</code> adds some information about the error position
-at the beginning of the message.
-The <code>level</code> argument specifies how to get the error position.
-With level&nbsp;1 (the default), the error position is where the
-<code>error</code> function was called.
-Level&nbsp;2 points the error to where the function
-that called <code>error</code> was called; and so on.
-Passing a level&nbsp;0 avoids the addition of error position information
-to the message.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-_G"><code>_G</code></a></h3>
-A global variable (not a function) that
-holds the global environment (that is, <code>_G._G = _G</code>).
-Lua itself does not use this variable;
-changing its value does not affect any environment,
-nor vice-versa.
-(Use <a href="#pdf-setfenv"><code>setfenv</code></a> to change environments.)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-getfenv"><code>getfenv ([f])</code></a></h3>
-Returns the current environment in use by the function.
-<code>f</code> can be a Lua function or a number
-that specifies the function at that stack level:
-Level&nbsp;1 is the function calling <code>getfenv</code>.
-If the given function is not a Lua function,
-or if <code>f</code> is 0,
-<code>getfenv</code> returns the global environment.
-The default for <code>f</code> is 1.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-getmetatable"><code>getmetatable (object)</code></a></h3>
-
-
-<p>
-If <code>object</code> does not have a metatable, returns <b>nil</b>.
-Otherwise,
-if the object's metatable has a <code>"__metatable"</code> field,
-returns the associated value.
-Otherwise, returns the metatable of the given object.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-ipairs"><code>ipairs (t)</code></a></h3>
-
-
-<p>
-Returns three values: an iterator function, the table <code>t</code>, and 0,
-so that the construction
-
-<pre>
-     for i,v in ipairs(t) do <em>body</em> end
-</pre><p>
-will iterate over the pairs (<code>1,t[1]</code>), (<code>2,t[2]</code>), &middot;&middot;&middot;,
-up to the first integer key absent from the table.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-load"><code>load (func [, chunkname])</code></a></h3>
-
-
-<p>
-Loads a chunk using function <code>func</code> to get its pieces.
-Each call to <code>func</code> must return a string that concatenates
-with previous results.
-A return of an empty string, <b>nil</b>, or no value signals the end of the chunk.
-
-
-<p>
-If there are no errors, 
-returns the compiled chunk as a function;
-otherwise, returns <b>nil</b> plus the error message.
-The environment of the returned function is the global environment.
-
-
-<p>
-<code>chunkname</code> is used as the chunk name for error messages
-and debug information.
-When absent,
-it defaults to "<code>=(load)</code>".
-
-
-
-
-<p>
-<hr><h3><a name="pdf-loadfile"><code>loadfile ([filename])</code></a></h3>
-
-
-<p>
-Similar to <a href="#pdf-load"><code>load</code></a>,
-but gets the chunk from file <code>filename</code>
-or from the standard input,
-if no file name is given.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-loadstring"><code>loadstring (string [, chunkname])</code></a></h3>
-
-
-<p>
-Similar to <a href="#pdf-load"><code>load</code></a>,
-but gets the chunk from the given string.
-
-
-<p>
-To load and run a given string, use the idiom
-
-<pre>
-     assert(loadstring(s))()
-</pre>
-
-<p>
-When absent,
-<code>chunkname</code> defaults to the given string.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-next"><code>next (table [, index])</code></a></h3>
-
-
-<p>
-Allows a program to traverse all fields of a table.
-Its first argument is a table and its second argument
-is an index in this table.
-<code>next</code> returns the next index of the table
-and its associated value.
-When called with <b>nil</b> as its second argument,
-<code>next</code> returns an initial index
-and its associated value.
-When called with the last index,
-or with <b>nil</b> in an empty table,
-<code>next</code> returns <b>nil</b>.
-If the second argument is absent, then it is interpreted as <b>nil</b>.
-In particular,
-you can use <code>next(t)</code> to check whether a table is empty.
-
-
-<p>
-The order in which the indices are enumerated is not specified,
-<em>even for numeric indices</em>.
-(To traverse a table in numeric order,
-use a numerical <b>for</b> or the <a href="#pdf-ipairs"><code>ipairs</code></a> function.)
-
-
-<p>
-The behavior of <code>next</code> is <em>undefined</em> if,
-during the traversal,
-you assign any value to a non-existent field in the table.
-You may however modify existing fields.
-In particular, you may clear existing fields.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-pairs"><code>pairs (t)</code></a></h3>
-
-
-<p>
-Returns three values: the <a href="#pdf-next"><code>next</code></a> function, the table <code>t</code>, and <b>nil</b>,
-so that the construction
-
-<pre>
-     for k,v in pairs(t) do <em>body</em> end
-</pre><p>
-will iterate over all key&ndash;value pairs of table <code>t</code>.
-
-
-<p>
-See function <a href="#pdf-next"><code>next</code></a> for the caveats of modifying
-the table during its traversal.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-pcall"><code>pcall (f, arg1, &middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Calls function <code>f</code> with
-the given arguments in <em>protected mode</em>.
-This means that any error inside&nbsp;<code>f</code> is not propagated;
-instead, <code>pcall</code> catches the error
-and returns a status code.
-Its first result is the status code (a boolean),
-which is true if the call succeeds without errors.
-In such case, <code>pcall</code> also returns all results from the call,
-after this first result.
-In case of any error, <code>pcall</code> returns <b>false</b> plus the error message.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-print"><code>print (&middot;&middot;&middot;)</code></a></h3>
-Receives any number of arguments,
-and prints their values to <code>stdout</code>,
-using the <a href="#pdf-tostring"><code>tostring</code></a> function to convert them to strings.
-<code>print</code> is not intended for formatted output,
-but only as a quick way to show a value,
-typically for debugging.
-For formatted output, use <a href="#pdf-string.format"><code>string.format</code></a>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-rawequal"><code>rawequal (v1, v2)</code></a></h3>
-Checks whether <code>v1</code> is equal to <code>v2</code>,
-without invoking any metamethod.
-Returns a boolean.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-rawget"><code>rawget (table, index)</code></a></h3>
-Gets the real value of <code>table[index]</code>,
-without invoking any metamethod.
-<code>table</code> must be a table;
-<code>index</code> may be any value.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-rawset"><code>rawset (table, index, value)</code></a></h3>
-Sets the real value of <code>table[index]</code> to <code>value</code>,
-without invoking any metamethod.
-<code>table</code> must be a table,
-<code>index</code> any value different from <b>nil</b>,
-and <code>value</code> any Lua value.
-
-
-<p>
-This function returns <code>table</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-select"><code>select (index, &middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-If <code>index</code> is a number,
-returns all arguments after argument number <code>index</code>.
-Otherwise, <code>index</code> must be the string <code>"#"</code>,
-and <code>select</code> returns the total number of extra arguments it received.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-setfenv"><code>setfenv (f, table)</code></a></h3>
-
-
-<p>
-Sets the environment to be used by the given function.
-<code>f</code> can be a Lua function or a number
-that specifies the function at that stack level:
-Level&nbsp;1 is the function calling <code>setfenv</code>.
-<code>setfenv</code> returns the given function.
-
-
-<p>
-As a special case, when <code>f</code> is 0 <code>setfenv</code> changes
-the environment of the running thread.
-In this case, <code>setfenv</code> returns no values.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-setmetatable"><code>setmetatable (table, metatable)</code></a></h3>
-
-
-<p>
-Sets the metatable for the given table.
-(You cannot change the metatable of other types from Lua, only from&nbsp;C.)
-If <code>metatable</code> is <b>nil</b>,
-removes the metatable of the given table.
-If the original metatable has a <code>"__metatable"</code> field,
-raises an error.
-
-
-<p>
-This function returns <code>table</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-tonumber"><code>tonumber (e [, base])</code></a></h3>
-Tries to convert its argument to a number.
-If the argument is already a number or a string convertible
-to a number, then <code>tonumber</code> returns this number;
-otherwise, it returns <b>nil</b>.
-
-
-<p>
-An optional argument specifies the base to interpret the numeral.
-The base may be any integer between 2 and 36, inclusive.
-In bases above&nbsp;10, the letter '<code>A</code>' (in either upper or lower case)
-represents&nbsp;10, '<code>B</code>' represents&nbsp;11, and so forth,
-with '<code>Z</code>' representing 35.
-In base 10 (the default), the number can have a decimal part,
-as well as an optional exponent part (see <a href="#2.1">&sect;2.1</a>).
-In other bases, only unsigned integers are accepted.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-tostring"><code>tostring (e)</code></a></h3>
-Receives an argument of any type and
-converts it to a string in a reasonable format.
-For complete control of how numbers are converted,
-use <a href="#pdf-string.format"><code>string.format</code></a>.
-
-
-<p>
-If the metatable of <code>e</code> has a <code>"__tostring"</code> field,
-then <code>tostring</code> calls the corresponding value
-with <code>e</code> as argument,
-and uses the result of the call as its result.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-type"><code>type (v)</code></a></h3>
-Returns the type of its only argument, coded as a string.
-The possible results of this function are
-"<code>nil</code>" (a string, not the value <b>nil</b>),
-"<code>number</code>",
-"<code>string</code>",
-"<code>boolean</code>",
-"<code>table</code>",
-"<code>function</code>",
-"<code>thread</code>",
-and "<code>userdata</code>".
-
-
-
-
-<p>
-<hr><h3><a name="pdf-unpack"><code>unpack (list [, i [, j]])</code></a></h3>
-Returns the elements from the given table.
-This function is equivalent to
-
-<pre>
-     return list[i], list[i+1], &middot;&middot;&middot;, list[j]
-</pre><p>
-except that the above code can be written only for a fixed number
-of elements.
-By default, <code>i</code> is&nbsp;1 and <code>j</code> is the length of the list,
-as defined by the length operator (see <a href="#2.5.5">&sect;2.5.5</a>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-_VERSION"><code>_VERSION</code></a></h3>
-A global variable (not a function) that
-holds a string containing the current interpreter version.
-The current contents of this variable is "<code>Lua 5.1</code>".
-
-
-
-
-<p>
-<hr><h3><a name="pdf-xpcall"><code>xpcall (f, err)</code></a></h3>
-
-
-<p>
-This function is similar to <a href="#pdf-pcall"><code>pcall</code></a>,
-except that you can set a new error handler.
-
-
-<p>
-<code>xpcall</code> calls function <code>f</code> in protected mode,
-using <code>err</code> as the error handler.
-Any error inside <code>f</code> is not propagated;
-instead, <code>xpcall</code> catches the error,
-calls the <code>err</code> function with the original error object,
-and returns a status code.
-Its first result is the status code (a boolean),
-which is true if the call succeeds without errors.
-In this case, <code>xpcall</code> also returns all results from the call,
-after this first result.
-In case of any error,
-<code>xpcall</code> returns <b>false</b> plus the result from <code>err</code>.
-
-
-
-
-
-
-
-<h2>5.2 - <a name="5.2">Coroutine Manipulation</a></h2>
-
-<p>
-The operations related to coroutines comprise a sub-library of
-the basic library and come inside the table <a name="pdf-coroutine"><code>coroutine</code></a>.
-See <a href="#2.11">&sect;2.11</a> for a general description of coroutines.
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.create"><code>coroutine.create (f)</code></a></h3>
-
-
-<p>
-Creates a new coroutine, with body <code>f</code>.
-<code>f</code> must be a Lua function.
-Returns this new coroutine,
-an object with type <code>"thread"</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.resume"><code>coroutine.resume (co [, val1, &middot;&middot;&middot;])</code></a></h3>
-
-
-<p>
-Starts or continues the execution of coroutine <code>co</code>.
-The first time you resume a coroutine,
-it starts running its body.
-The values <code>val1</code>, &middot;&middot;&middot; are passed
-as the arguments to the body function.
-If the coroutine has yielded,
-<code>resume</code> restarts it;
-the values <code>val1</code>, &middot;&middot;&middot; are passed
-as the results from the yield.
-
-
-<p>
-If the coroutine runs without any errors,
-<code>resume</code> returns <b>true</b> plus any values passed to <code>yield</code>
-(if the coroutine yields) or any values returned by the body function
-(if the coroutine terminates).
-If there is any error,
-<code>resume</code> returns <b>false</b> plus the error message.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.running"><code>coroutine.running ()</code></a></h3>
-
-
-<p>
-Returns the running coroutine,
-or <b>nil</b> when called by the main thread.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.status"><code>coroutine.status (co)</code></a></h3>
-
-
-<p>
-Returns the status of coroutine <code>co</code>, as a string:
-<code>"running"</code>,
-if the coroutine is running (that is, it called <code>status</code>);
-<code>"suspended"</code>, if the coroutine is suspended in a call to <code>yield</code>,
-or if it has not started running yet;
-<code>"normal"</code> if the coroutine is active but not running
-(that is, it has resumed another coroutine);
-and <code>"dead"</code> if the coroutine has finished its body function,
-or if it has stopped with an error.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.wrap"><code>coroutine.wrap (f)</code></a></h3>
-
-
-<p>
-Creates a new coroutine, with body <code>f</code>.
-<code>f</code> must be a Lua function.
-Returns a function that resumes the coroutine each time it is called.
-Any arguments passed to the function behave as the
-extra arguments to <code>resume</code>.
-Returns the same values returned by <code>resume</code>,
-except the first boolean.
-In case of error, propagates the error.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.yield"><code>coroutine.yield (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Suspends the execution of the calling coroutine.
-The coroutine cannot be running a C&nbsp;function,
-a metamethod, or an iterator.
-Any arguments to <code>yield</code> are passed as extra results to <code>resume</code>.
-
-
-
-
-
-
-
-<h2>5.3 - <a name="5.3">Modules</a></h2>
-
-<p>
-The package library provides basic
-facilities for loading and building modules in Lua.
-It exports two of its functions directly in the global environment:
-<a href="#pdf-require"><code>require</code></a> and <a href="#pdf-module"><code>module</code></a>.
-Everything else is exported in a table <a name="pdf-package"><code>package</code></a>.
-
-
-<p>
-<hr><h3><a name="pdf-module"><code>module (name [, &middot;&middot;&middot;])</code></a></h3>
-
-
-<p>
-Creates a module.
-If there is a table in <code>package.loaded[name]</code>,
-this table is the module.
-Otherwise, if there is a global table <code>t</code> with the given name,
-this table is the module.
-Otherwise creates a new table <code>t</code> and
-sets it as the value of the global <code>name</code> and
-the value of <code>package.loaded[name]</code>.
-This function also initializes <code>t._NAME</code> with the given name,
-<code>t._M</code> with the module (<code>t</code> itself),
-and <code>t._PACKAGE</code> with the package name
-(the full module name minus last component; see below).
-Finally, <code>module</code> sets <code>t</code> as the new environment
-of the current function and the new value of <code>package.loaded[name]</code>,
-so that <a href="#pdf-require"><code>require</code></a> returns <code>t</code>.
-
-
-<p>
-If <code>name</code> is a compound name
-(that is, one with components separated by dots),
-<code>module</code> creates (or reuses, if they already exist)
-tables for each component.
-For instance, if <code>name</code> is <code>a.b.c</code>,
-then <code>module</code> stores the module table in field <code>c</code> of
-field <code>b</code> of global <code>a</code>.
-
-
-<p>
-This function can receive optional <em>options</em> after
-the module name,
-where each option is a function to be applied over the module.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-require"><code>require (modname)</code></a></h3>
-
-
-<p>
-Loads the given module.
-The function starts by looking into the <a href="#pdf-package.loaded"><code>package.loaded</code></a> table
-to determine whether <code>modname</code> is already loaded.
-If it is, then <code>require</code> returns the value stored
-at <code>package.loaded[modname]</code>.
-Otherwise, it tries to find a <em>loader</em> for the module.
-
-
-<p>
-To find a loader,
-<code>require</code> is guided by the <a href="#pdf-package.loaders"><code>package.loaders</code></a> array.
-By changing this array,
-we can change how <code>require</code> looks for a module.
-The following explanation is based on the default configuration
-for <a href="#pdf-package.loaders"><code>package.loaders</code></a>.
-
-
-<p>
-First <code>require</code> queries <code>package.preload[modname]</code>.
-If it has a value,
-this value (which should be a function) is the loader.
-Otherwise <code>require</code> searches for a Lua loader using the
-path stored in <a href="#pdf-package.path"><code>package.path</code></a>.
-If that also fails, it searches for a C&nbsp;loader using the
-path stored in <a href="#pdf-package.cpath"><code>package.cpath</code></a>.
-If that also fails,
-it tries an <em>all-in-one</em> loader (see <a href="#pdf-package.loaders"><code>package.loaders</code></a>).
-
-
-<p>
-Once a loader is found,
-<code>require</code> calls the loader with a single argument, <code>modname</code>.
-If the loader returns any value,
-<code>require</code> assigns the returned value to <code>package.loaded[modname]</code>.
-If the loader returns no value and
-has not assigned any value to <code>package.loaded[modname]</code>,
-then <code>require</code> assigns <b>true</b> to this entry.
-In any case, <code>require</code> returns the
-final value of <code>package.loaded[modname]</code>.
-
-
-<p>
-If there is any error loading or running the module,
-or if it cannot find any loader for the module,
-then <code>require</code> signals an error. 
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.cpath"><code>package.cpath</code></a></h3>
-
-
-<p>
-The path used by <a href="#pdf-require"><code>require</code></a> to search for a C&nbsp;loader.
-
-
-<p>
-Lua initializes the C&nbsp;path <a href="#pdf-package.cpath"><code>package.cpath</code></a> in the same way
-it initializes the Lua path <a href="#pdf-package.path"><code>package.path</code></a>,
-using the environment variable <a name="pdf-LUA_CPATH"><code>LUA_CPATH</code></a>
-or a default path defined in <code>luaconf.h</code>.
-
-
-
-
-<p>
-
-<hr><h3><a name="pdf-package.loaded"><code>package.loaded</code></a></h3>
-
-
-<p>
-A table used by <a href="#pdf-require"><code>require</code></a> to control which
-modules are already loaded.
-When you require a module <code>modname</code> and
-<code>package.loaded[modname]</code> is not false,
-<a href="#pdf-require"><code>require</code></a> simply returns the value stored there.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.loaders"><code>package.loaders</code></a></h3>
-
-
-<p>
-A table used by <a href="#pdf-require"><code>require</code></a> to control how to load modules.
-
-
-<p>
-Each entry in this table is a <em>searcher function</em>.
-When looking for a module,
-<a href="#pdf-require"><code>require</code></a> calls each of these searchers in ascending order,
-with the module name (the argument given to <a href="#pdf-require"><code>require</code></a>) as its
-sole parameter.
-The function can return another function (the module <em>loader</em>)
-or a string explaining why it did not find that module
-(or <b>nil</b> if it has nothing to say).
-Lua initializes this table with four functions.
-
-
-<p>
-The first searcher simply looks for a loader in the
-<a href="#pdf-package.preload"><code>package.preload</code></a> table.
-
-
-<p>
-The second searcher looks for a loader as a Lua library,
-using the path stored at <a href="#pdf-package.path"><code>package.path</code></a>.
-A path is a sequence of <em>templates</em> separated by semicolons.
-For each template,
-the searcher will change each interrogation
-mark in the template by <code>filename</code>,
-which is the module name with each dot replaced by a
-"directory separator" (such as "<code>/</code>" in Unix);
-then it will try to open the resulting file name.
-So, for instance, if the Lua path is the string
-
-<pre>
-     "./?.lua;./?.lc;/usr/local/?/init.lua"
-</pre><p>
-the search for a Lua file for module <code>foo</code>
-will try to open the files
-<code>./foo.lua</code>, <code>./foo.lc</code>, and
-<code>/usr/local/foo/init.lua</code>, in that order.
-
-
-<p>
-The third searcher looks for a loader as a C&nbsp;library,
-using the path given by the variable <a href="#pdf-package.cpath"><code>package.cpath</code></a>.
-For instance,
-if the C&nbsp;path is the string
-
-<pre>
-     "./?.so;./?.dll;/usr/local/?/init.so"
-</pre><p>
-the searcher for module <code>foo</code>
-will try to open the files <code>./foo.so</code>, <code>./foo.dll</code>,
-and <code>/usr/local/foo/init.so</code>, in that order.
-Once it finds a C&nbsp;library,
-this searcher first uses a dynamic link facility to link the
-application with the library.
-Then it tries to find a C&nbsp;function inside the library to
-be used as the loader.
-The name of this C&nbsp;function is the string "<code>luaopen_</code>"
-concatenated with a copy of the module name where each dot
-is replaced by an underscore.
-Moreover, if the module name has a hyphen,
-its prefix up to (and including) the first hyphen is removed.
-For instance, if the module name is <code>a.v1-b.c</code>,
-the function name will be <code>luaopen_b_c</code>.
-
-
-<p>
-The fourth searcher tries an <em>all-in-one loader</em>.
-It searches the C&nbsp;path for a library for
-the root name of the given module.
-For instance, when requiring <code>a.b.c</code>,
-it will search for a C&nbsp;library for <code>a</code>.
-If found, it looks into it for an open function for
-the submodule;
-in our example, that would be <code>luaopen_a_b_c</code>.
-With this facility, a package can pack several C&nbsp;submodules
-into one single library,
-with each submodule keeping its original open function.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.loadlib"><code>package.loadlib (libname, funcname)</code></a></h3>
-
-
-<p>
-Dynamically links the host program with the C&nbsp;library <code>libname</code>.
-Inside this library, looks for a function <code>funcname</code>
-and returns this function as a C&nbsp;function.
-(So, <code>funcname</code> must follow the protocol (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>)).
-
-
-<p>
-This is a low-level function.
-It completely bypasses the package and module system.
-Unlike <a href="#pdf-require"><code>require</code></a>,
-it does not perform any path searching and
-does not automatically adds extensions.
-<code>libname</code> must be the complete file name of the C&nbsp;library,
-including if necessary a path and extension.
-<code>funcname</code> must be the exact name exported by the C&nbsp;library
-(which may depend on the C&nbsp;compiler and linker used).
-
-
-<p>
-This function is not supported by ANSI C.
-As such, it is only available on some platforms
-(Windows, Linux, Mac OS X, Solaris, BSD,
-plus other Unix systems that support the <code>dlfcn</code> standard).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.path"><code>package.path</code></a></h3>
-
-
-<p>
-The path used by <a href="#pdf-require"><code>require</code></a> to search for a Lua loader.
-
-
-<p>
-At start-up, Lua initializes this variable with
-the value of the environment variable <a name="pdf-LUA_PATH"><code>LUA_PATH</code></a> or
-with a default path defined in <code>luaconf.h</code>,
-if the environment variable is not defined.
-Any "<code>;;</code>" in the value of the environment variable
-is replaced by the default path.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.preload"><code>package.preload</code></a></h3>
-
-
-<p>
-A table to store loaders for specific modules
-(see <a href="#pdf-require"><code>require</code></a>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.seeall"><code>package.seeall (module)</code></a></h3>
-
-
-<p>
-Sets a metatable for <code>module</code> with
-its <code>__index</code> field referring to the global environment,
-so that this module inherits values
-from the global environment.
-To be used as an option to function <a href="#pdf-module"><code>module</code></a>.
-
-
-
-
-
-
-
-<h2>5.4 - <a name="5.4">String Manipulation</a></h2>
-
-<p>
-This library provides generic functions for string manipulation,
-such as finding and extracting substrings, and pattern matching.
-When indexing a string in Lua, the first character is at position&nbsp;1
-(not at&nbsp;0, as in C).
-Indices are allowed to be negative and are interpreted as indexing backwards,
-from the end of the string.
-Thus, the last character is at position -1, and so on.
-
-
-<p>
-The string library provides all its functions inside the table
-<a name="pdf-string"><code>string</code></a>.
-It also sets a metatable for strings
-where the <code>__index</code> field points to the <code>string</code> table.
-Therefore, you can use the string functions in object-oriented style.
-For instance, <code>string.byte(s, i)</code>
-can be written as <code>s:byte(i)</code>.
-
-
-<p>
-The string library assumes one-byte character encodings.
-
-
-<p>
-<hr><h3><a name="pdf-string.byte"><code>string.byte (s [, i [, j]])</code></a></h3>
-Returns the internal numerical codes of the characters <code>s[i]</code>,
-<code>s[i+1]</code>, &middot;&middot;&middot;, <code>s[j]</code>.
-The default value for <code>i</code> is&nbsp;1;
-the default value for <code>j</code> is&nbsp;<code>i</code>.
-
-
-<p>
-Note that numerical codes are not necessarily portable across platforms.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.char"><code>string.char (&middot;&middot;&middot;)</code></a></h3>
-Receives zero or more integers.
-Returns a string with length equal to the number of arguments,
-in which each character has the internal numerical code equal
-to its corresponding argument.
-
-
-<p>
-Note that numerical codes are not necessarily portable across platforms.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.dump"><code>string.dump (function)</code></a></h3>
-
-
-<p>
-Returns a string containing a binary representation of the given function,
-so that a later <a href="#pdf-loadstring"><code>loadstring</code></a> on this string returns
-a copy of the function.
-<code>function</code> must be a Lua function without upvalues.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.find"><code>string.find (s, pattern [, init [, plain]])</code></a></h3>
-Looks for the first match of
-<code>pattern</code> in the string <code>s</code>.
-If it finds a match, then <code>find</code> returns the indices of&nbsp;<code>s</code>
-where this occurrence starts and ends;
-otherwise, it returns <b>nil</b>.
-A third, optional numerical argument <code>init</code> specifies
-where to start the search;
-its default value is&nbsp;1 and can be negative.
-A value of <b>true</b> as a fourth, optional argument <code>plain</code>
-turns off the pattern matching facilities,
-so the function does a plain "find substring" operation,
-with no characters in <code>pattern</code> being considered "magic".
-Note that if <code>plain</code> is given, then <code>init</code> must be given as well.
-
-
-<p>
-If the pattern has captures,
-then in a successful match
-the captured values are also returned,
-after the two indices.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.format"><code>string.format (formatstring, &middot;&middot;&middot;)</code></a></h3>
-Returns a formatted version of its variable number of arguments
-following the description given in its first argument (which must be a string).
-The format string follows the same rules as the <code>printf</code> family of
-standard C&nbsp;functions.
-The only differences are that the options/modifiers
-<code>*</code>, <code>l</code>, <code>L</code>, <code>n</code>, <code>p</code>,
-and <code>h</code> are not supported
-and that there is an extra option, <code>q</code>.
-The <code>q</code> option formats a string in a form suitable to be safely read
-back by the Lua interpreter:
-the string is written between double quotes,
-and all double quotes, newlines, embedded zeros,
-and backslashes in the string
-are correctly escaped when written.
-For instance, the call
-
-<pre>
-     string.format('%q', 'a string with "quotes" and \n new line')
-</pre><p>
-will produce the string:
-
-<pre>
-     "a string with \"quotes\" and \
-      new line"
-</pre>
-
-<p>
-The options <code>c</code>, <code>d</code>, <code>E</code>, <code>e</code>, <code>f</code>,
-<code>g</code>, <code>G</code>, <code>i</code>, <code>o</code>, <code>u</code>, <code>X</code>, and <code>x</code> all
-expect a number as argument,
-whereas <code>q</code> and <code>s</code> expect a string.
-
-
-<p>
-This function does not accept string values
-containing embedded zeros,
-except as arguments to the <code>q</code> option.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.gmatch"><code>string.gmatch (s, pattern)</code></a></h3>
-Returns an iterator function that,
-each time it is called,
-returns the next captures from <code>pattern</code> over string <code>s</code>.
-If <code>pattern</code> specifies no captures,
-then the whole match is produced in each call.
-
-
-<p>
-As an example, the following loop
-
-<pre>
-     s = "hello world from Lua"
-     for w in string.gmatch(s, "%a+") do
-       print(w)
-     end
-</pre><p>
-will iterate over all the words from string <code>s</code>,
-printing one per line.
-The next example collects all pairs <code>key=value</code> from the
-given string into a table:
-
-<pre>
-     t = {}
-     s = "from=world, to=Lua"
-     for k, v in string.gmatch(s, "(%w+)=(%w+)") do
-       t[k] = v
-     end
-</pre>
-
-<p>
-For this function, a '<code>^</code>' at the start of a pattern does not
-work as an anchor, as this would prevent the iteration.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.gsub"><code>string.gsub (s, pattern, repl [, n])</code></a></h3>
-Returns a copy of <code>s</code>
-in which all (or the first <code>n</code>, if given)
-occurrences of the <code>pattern</code> have been
-replaced by a replacement string specified by <code>repl</code>,
-which can be a string, a table, or a function.
-<code>gsub</code> also returns, as its second value,
-the total number of matches that occurred.
-
-
-<p>
-If <code>repl</code> is a string, then its value is used for replacement.
-The character&nbsp;<code>%</code> works as an escape character:
-any sequence in <code>repl</code> of the form <code>%<em>n</em></code>,
-with <em>n</em> between 1 and 9,
-stands for the value of the <em>n</em>-th captured substring (see below).
-The sequence <code>%0</code> stands for the whole match.
-The sequence <code>%%</code> stands for a single&nbsp;<code>%</code>.
-
-
-<p>
-If <code>repl</code> is a table, then the table is queried for every match,
-using the first capture as the key;
-if the pattern specifies no captures,
-then the whole match is used as the key.
-
-
-<p>
-If <code>repl</code> is a function, then this function is called every time a
-match occurs, with all captured substrings passed as arguments,
-in order;
-if the pattern specifies no captures,
-then the whole match is passed as a sole argument.
-
-
-<p>
-If the value returned by the table query or by the function call
-is a string or a number,
-then it is used as the replacement string;
-otherwise, if it is <b>false</b> or <b>nil</b>,
-then there is no replacement
-(that is, the original match is kept in the string).
-
-
-<p>
-Here are some examples:
-
-<pre>
-     x = string.gsub("hello world", "(%w+)", "%1 %1")
-     --&gt; x="hello hello world world"
-     
-     x = string.gsub("hello world", "%w+", "%0 %0", 1)
-     --&gt; x="hello hello world"
-     
-     x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")
-     --&gt; x="world hello Lua from"
-     
-     x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)
-     --&gt; x="home = /home/roberto, user = roberto"
-     
-     x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
-           return loadstring(s)()
-         end)
-     --&gt; x="4+5 = 9"
-     
-     local t = {name="lua", version="5.1"}
-     x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)
-     --&gt; x="lua-5.1.tar.gz"
-</pre>
-
-
-
-<p>
-<hr><h3><a name="pdf-string.len"><code>string.len (s)</code></a></h3>
-Receives a string and returns its length.
-The empty string <code>""</code> has length 0.
-Embedded zeros are counted,
-so <code>"a\000bc\000"</code> has length 5.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.lower"><code>string.lower (s)</code></a></h3>
-Receives a string and returns a copy of this string with all
-uppercase letters changed to lowercase.
-All other characters are left unchanged.
-The definition of what an uppercase letter is depends on the current locale.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.match"><code>string.match (s, pattern [, init])</code></a></h3>
-Looks for the first <em>match</em> of
-<code>pattern</code> in the string <code>s</code>.
-If it finds one, then <code>match</code> returns
-the captures from the pattern;
-otherwise it returns <b>nil</b>.
-If <code>pattern</code> specifies no captures,
-then the whole match is returned.
-A third, optional numerical argument <code>init</code> specifies
-where to start the search;
-its default value is&nbsp;1 and can be negative.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.rep"><code>string.rep (s, n)</code></a></h3>
-Returns a string that is the concatenation of <code>n</code> copies of
-the string <code>s</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.reverse"><code>string.reverse (s)</code></a></h3>
-Returns a string that is the string <code>s</code> reversed.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.sub"><code>string.sub (s, i [, j])</code></a></h3>
-Returns the substring of <code>s</code> that
-starts at <code>i</code>  and continues until <code>j</code>;
-<code>i</code> and <code>j</code> can be negative.
-If <code>j</code> is absent, then it is assumed to be equal to -1
-(which is the same as the string length).
-In particular,
-the call <code>string.sub(s,1,j)</code> returns a prefix of <code>s</code>
-with length <code>j</code>,
-and <code>string.sub(s, -i)</code> returns a suffix of <code>s</code>
-with length <code>i</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.upper"><code>string.upper (s)</code></a></h3>
-Receives a string and returns a copy of this string with all
-lowercase letters changed to uppercase.
-All other characters are left unchanged.
-The definition of what a lowercase letter is depends on the current locale.
-
-
-
-<h3>5.4.1 - <a name="5.4.1">Patterns</a></h3>
-
-
-<h4>Character Class:</h4><p>
-A <em>character class</em> is used to represent a set of characters.
-The following combinations are allowed in describing a character class:
-
-<ul>
-
-<li><b><em>x</em>:</b>
-(where <em>x</em> is not one of the <em>magic characters</em>
-<code>^$()%.[]*+-?</code>)
-represents the character <em>x</em> itself.
-</li>
-
-<li><b><code>.</code>:</b> (a dot) represents all characters.</li>
-
-<li><b><code>%a</code>:</b> represents all letters.</li>
-
-<li><b><code>%c</code>:</b> represents all control characters.</li>
-
-<li><b><code>%d</code>:</b> represents all digits.</li>
-
-<li><b><code>%l</code>:</b> represents all lowercase letters.</li>
-
-<li><b><code>%p</code>:</b> represents all punctuation characters.</li>
-
-<li><b><code>%s</code>:</b> represents all space characters.</li>
-
-<li><b><code>%u</code>:</b> represents all uppercase letters.</li>
-
-<li><b><code>%w</code>:</b> represents all alphanumeric characters.</li>
-
-<li><b><code>%x</code>:</b> represents all hexadecimal digits.</li>
-
-<li><b><code>%z</code>:</b> represents the character with representation 0.</li>
-
-<li><b><code>%<em>x</em></code>:</b> (where <em>x</em> is any non-alphanumeric character)
-represents the character <em>x</em>.
-This is the standard way to escape the magic characters.
-Any punctuation character (even the non magic)
-can be preceded by a '<code>%</code>'
-when used to represent itself in a pattern.
-</li>
-
-<li><b><code>[<em>set</em>]</code>:</b>
-represents the class which is the union of all
-characters in <em>set</em>.
-A range of characters can be specified by
-separating the end characters of the range with a '<code>-</code>'.
-All classes <code>%</code><em>x</em> described above can also be used as
-components in <em>set</em>.
-All other characters in <em>set</em> represent themselves.
-For example, <code>[%w_]</code> (or <code>[_%w]</code>)
-represents all alphanumeric characters plus the underscore,
-<code>[0-7]</code> represents the octal digits,
-and <code>[0-7%l%-]</code> represents the octal digits plus
-the lowercase letters plus the '<code>-</code>' character.
-
-
-<p>
-The interaction between ranges and classes is not defined.
-Therefore, patterns like <code>[%a-z]</code> or <code>[a-%%]</code>
-have no meaning.
-</li>
-
-<li><b><code>[^<em>set</em>]</code>:</b>
-represents the complement of <em>set</em>,
-where <em>set</em> is interpreted as above.
-</li>
-
-</ul><p>
-For all classes represented by single letters (<code>%a</code>, <code>%c</code>, etc.),
-the corresponding uppercase letter represents the complement of the class.
-For instance, <code>%S</code> represents all non-space characters.
-
-
-<p>
-The definitions of letter, space, and other character groups
-depend on the current locale.
-In particular, the class <code>[a-z]</code> may not be equivalent to <code>%l</code>.
-
-
-
-
-
-<h4>Pattern Item:</h4><p>
-A <em>pattern item</em> can be
-
-<ul>
-
-<li>
-a single character class,
-which matches any single character in the class;
-</li>
-
-<li>
-a single character class followed by '<code>*</code>',
-which matches 0 or more repetitions of characters in the class.
-These repetition items will always match the longest possible sequence;
-</li>
-
-<li>
-a single character class followed by '<code>+</code>',
-which matches 1 or more repetitions of characters in the class.
-These repetition items will always match the longest possible sequence;
-</li>
-
-<li>
-a single character class followed by '<code>-</code>',
-which also matches 0 or more repetitions of characters in the class.
-Unlike '<code>*</code>',
-these repetition items will always match the <em>shortest</em> possible sequence;
-</li>
-
-<li>
-a single character class followed by '<code>?</code>',
-which matches 0 or 1 occurrence of a character in the class;
-</li>
-
-<li>
-<code>%<em>n</em></code>, for <em>n</em> between 1 and 9;
-such item matches a substring equal to the <em>n</em>-th captured string
-(see below);
-</li>
-
-<li>
-<code>%b<em>xy</em></code>, where <em>x</em> and <em>y</em> are two distinct characters;
-such item matches strings that start with&nbsp;<em>x</em>, end with&nbsp;<em>y</em>,
-and where the <em>x</em> and <em>y</em> are <em>balanced</em>.
-This means that, if one reads the string from left to right,
-counting <em>+1</em> for an <em>x</em> and <em>-1</em> for a <em>y</em>,
-the ending <em>y</em> is the first <em>y</em> where the count reaches 0.
-For instance, the item <code>%b()</code> matches expressions with
-balanced parentheses.
-</li>
-
-</ul>
-
-
-
-
-<h4>Pattern:</h4><p>
-A <em>pattern</em> is a sequence of pattern items.
-A '<code>^</code>' at the beginning of a pattern anchors the match at the
-beginning of the subject string.
-A '<code>$</code>' at the end of a pattern anchors the match at the
-end of the subject string.
-At other positions,
-'<code>^</code>' and '<code>$</code>' have no special meaning and represent themselves.
-
-
-
-
-
-<h4>Captures:</h4><p>
-A pattern can contain sub-patterns enclosed in parentheses;
-they describe <em>captures</em>.
-When a match succeeds, the substrings of the subject string
-that match captures are stored (<em>captured</em>) for future use.
-Captures are numbered according to their left parentheses.
-For instance, in the pattern <code>"(a*(.)%w(%s*))"</code>,
-the part of the string matching <code>"a*(.)%w(%s*)"</code> is
-stored as the first capture (and therefore has number&nbsp;1);
-the character matching "<code>.</code>" is captured with number&nbsp;2,
-and the part matching "<code>%s*</code>" has number&nbsp;3.
-
-
-<p>
-As a special case, the empty capture <code>()</code> captures
-the current string position (a number).
-For instance, if we apply the pattern <code>"()aa()"</code> on the
-string <code>"flaaap"</code>, there will be two captures: 3&nbsp;and&nbsp;5.
-
-
-<p>
-A pattern cannot contain embedded zeros.  Use <code>%z</code> instead.
-
-
-
-
-
-
-
-
-
-
-
-<h2>5.5 - <a name="5.5">Table Manipulation</a></h2><p>
-This library provides generic functions for table manipulation.
-It provides all its functions inside the table <a name="pdf-table"><code>table</code></a>.
-
-
-<p>
-Most functions in the table library assume that the table
-represents an array or a list.
-For these functions, when we talk about the "length" of a table
-we mean the result of the length operator.
-
-
-<p>
-<hr><h3><a name="pdf-table.concat"><code>table.concat (table [, sep [, i [, j]]])</code></a></h3>
-Given an array where all elements are strings or numbers,
-returns <code>table[i]..sep..table[i+1] &middot;&middot;&middot; sep..table[j]</code>.
-The default value for <code>sep</code> is the empty string,
-the default for <code>i</code> is 1,
-and the default for <code>j</code> is the length of the table.
-If <code>i</code> is greater than <code>j</code>, returns the empty string.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-table.insert"><code>table.insert (table, [pos,] value)</code></a></h3>
-
-
-<p>
-Inserts element <code>value</code> at position <code>pos</code> in <code>table</code>,
-shifting up other elements to open space, if necessary.
-The default value for <code>pos</code> is <code>n+1</code>,
-where <code>n</code> is the length of the table (see <a href="#2.5.5">&sect;2.5.5</a>),
-so that a call <code>table.insert(t,x)</code> inserts <code>x</code> at the end
-of table <code>t</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-table.maxn"><code>table.maxn (table)</code></a></h3>
-
-
-<p>
-Returns the largest positive numerical index of the given table,
-or zero if the table has no positive numerical indices.
-(To do its job this function does a linear traversal of
-the whole table.) 
-
-
-
-
-<p>
-<hr><h3><a name="pdf-table.remove"><code>table.remove (table [, pos])</code></a></h3>
-
-
-<p>
-Removes from <code>table</code> the element at position <code>pos</code>,
-shifting down other elements to close the space, if necessary.
-Returns the value of the removed element.
-The default value for <code>pos</code> is <code>n</code>,
-where <code>n</code> is the length of the table,
-so that a call <code>table.remove(t)</code> removes the last element
-of table <code>t</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-table.sort"><code>table.sort (table [, comp])</code></a></h3>
-Sorts table elements in a given order, <em>in-place</em>,
-from <code>table[1]</code> to <code>table[n]</code>,
-where <code>n</code> is the length of the table.
-If <code>comp</code> is given,
-then it must be a function that receives two table elements,
-and returns true
-when the first is less than the second
-(so that <code>not comp(a[i+1],a[i])</code> will be true after the sort).
-If <code>comp</code> is not given,
-then the standard Lua operator <code>&lt;</code> is used instead.
-
-
-<p>
-The sort algorithm is not stable;
-that is, elements considered equal by the given order
-may have their relative positions changed by the sort.
-
-
-
-
-
-
-
-<h2>5.6 - <a name="5.6">Mathematical Functions</a></h2>
-
-<p>
-This library is an interface to the standard C&nbsp;math library.
-It provides all its functions inside the table <a name="pdf-math"><code>math</code></a>.
-
-
-<p>
-<hr><h3><a name="pdf-math.abs"><code>math.abs (x)</code></a></h3>
-
-
-<p>
-Returns the absolute value of <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.acos"><code>math.acos (x)</code></a></h3>
-
-
-<p>
-Returns the arc cosine of <code>x</code> (in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.asin"><code>math.asin (x)</code></a></h3>
-
-
-<p>
-Returns the arc sine of <code>x</code> (in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.atan"><code>math.atan (x)</code></a></h3>
-
-
-<p>
-Returns the arc tangent of <code>x</code> (in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.atan2"><code>math.atan2 (y, x)</code></a></h3>
-
-
-<p>
-Returns the arc tangent of <code>y/x</code> (in radians),
-but uses the signs of both parameters to find the
-quadrant of the result.
-(It also handles correctly the case of <code>x</code> being zero.)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.ceil"><code>math.ceil (x)</code></a></h3>
-
-
-<p>
-Returns the smallest integer larger than or equal to <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.cos"><code>math.cos (x)</code></a></h3>
-
-
-<p>
-Returns the cosine of <code>x</code> (assumed to be in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.cosh"><code>math.cosh (x)</code></a></h3>
-
-
-<p>
-Returns the hyperbolic cosine of <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.deg"><code>math.deg (x)</code></a></h3>
-
-
-<p>
-Returns the angle <code>x</code> (given in radians) in degrees.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.exp"><code>math.exp (x)</code></a></h3>
-
-
-<p>
-Returns the value <em>e<sup>x</sup></em>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.floor"><code>math.floor (x)</code></a></h3>
-
-
-<p>
-Returns the largest integer smaller than or equal to <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.fmod"><code>math.fmod (x, y)</code></a></h3>
-
-
-<p>
-Returns the remainder of the division of <code>x</code> by <code>y</code>
-that rounds the quotient towards zero.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.frexp"><code>math.frexp (x)</code></a></h3>
-
-
-<p>
-Returns <code>m</code> and <code>e</code> such that <em>x = m2<sup>e</sup></em>,
-<code>e</code> is an integer and the absolute value of <code>m</code> is
-in the range <em>[0.5, 1)</em>
-(or zero when <code>x</code> is zero).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.huge"><code>math.huge</code></a></h3>
-
-
-<p>
-The value <code>HUGE_VAL</code>,
-a value larger than or equal to any other numerical value.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.ldexp"><code>math.ldexp (m, e)</code></a></h3>
-
-
-<p>
-Returns <em>m2<sup>e</sup></em> (<code>e</code> should be an integer).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.log"><code>math.log (x)</code></a></h3>
-
-
-<p>
-Returns the natural logarithm of <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.log10"><code>math.log10 (x)</code></a></h3>
-
-
-<p>
-Returns the base-10 logarithm of <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.max"><code>math.max (x, &middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Returns the maximum value among its arguments.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.min"><code>math.min (x, &middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Returns the minimum value among its arguments.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.modf"><code>math.modf (x)</code></a></h3>
-
-
-<p>
-Returns two numbers,
-the integral part of <code>x</code> and the fractional part of <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.pi"><code>math.pi</code></a></h3>
-
-
-<p>
-The value of <em>pi</em>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.pow"><code>math.pow (x, y)</code></a></h3>
-
-
-<p>
-Returns <em>x<sup>y</sup></em>.
-(You can also use the expression <code>x^y</code> to compute this value.)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.rad"><code>math.rad (x)</code></a></h3>
-
-
-<p>
-Returns the angle <code>x</code> (given in degrees) in radians.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.random"><code>math.random ([m [, n]])</code></a></h3>
-
-
-<p>
-This function is an interface to the simple
-pseudo-random generator function <code>rand</code> provided by ANSI&nbsp;C.
-(No guarantees can be given for its statistical properties.)
-
-
-<p>
-When called without arguments,
-returns a uniform pseudo-random real number
-in the range <em>[0,1)</em>.  
-When called with an integer number <code>m</code>,
-<code>math.random</code> returns
-a uniform pseudo-random integer in the range <em>[1, m]</em>.
-When called with two integer numbers <code>m</code> and <code>n</code>,
-<code>math.random</code> returns a uniform pseudo-random
-integer in the range <em>[m, n]</em>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.randomseed"><code>math.randomseed (x)</code></a></h3>
-
-
-<p>
-Sets <code>x</code> as the "seed"
-for the pseudo-random generator:
-equal seeds produce equal sequences of numbers.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.sin"><code>math.sin (x)</code></a></h3>
-
-
-<p>
-Returns the sine of <code>x</code> (assumed to be in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.sinh"><code>math.sinh (x)</code></a></h3>
-
-
-<p>
-Returns the hyperbolic sine of <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.sqrt"><code>math.sqrt (x)</code></a></h3>
-
-
-<p>
-Returns the square root of <code>x</code>.
-(You can also use the expression <code>x^0.5</code> to compute this value.)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.tan"><code>math.tan (x)</code></a></h3>
-
-
-<p>
-Returns the tangent of <code>x</code> (assumed to be in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.tanh"><code>math.tanh (x)</code></a></h3>
-
-
-<p>
-Returns the hyperbolic tangent of <code>x</code>.
-
-
-
-
-
-
-
-<h2>5.7 - <a name="5.7">Input and Output Facilities</a></h2>
-
-<p>
-The I/O library provides two different styles for file manipulation.
-The first one uses implicit file descriptors;
-that is, there are operations to set a default input file and a
-default output file,
-and all input/output operations are over these default files.
-The second style uses explicit file descriptors.
-
-
-<p>
-When using implicit file descriptors,
-all operations are supplied by table <a name="pdf-io"><code>io</code></a>.
-When using explicit file descriptors,
-the operation <a href="#pdf-io.open"><code>io.open</code></a> returns a file descriptor
-and then all operations are supplied as methods of the file descriptor.
-
-
-<p>
-The table <code>io</code> also provides
-three predefined file descriptors with their usual meanings from C:
-<a name="pdf-io.stdin"><code>io.stdin</code></a>, <a name="pdf-io.stdout"><code>io.stdout</code></a>, and <a name="pdf-io.stderr"><code>io.stderr</code></a>.
-The I/O library never closes these files.
-
-
-<p>
-Unless otherwise stated,
-all I/O functions return <b>nil</b> on failure
-(plus an error message as a second result and
-a system-dependent error code as a third result)
-and some value different from <b>nil</b> on success.
-
-
-<p>
-<hr><h3><a name="pdf-io.close"><code>io.close ([file])</code></a></h3>
-
-
-<p>
-Equivalent to <code>file:close()</code>.
-Without a <code>file</code>, closes the default output file.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.flush"><code>io.flush ()</code></a></h3>
-
-
-<p>
-Equivalent to <code>file:flush</code> over the default output file.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.input"><code>io.input ([file])</code></a></h3>
-
-
-<p>
-When called with a file name, it opens the named file (in text mode),
-and sets its handle as the default input file.
-When called with a file handle,
-it simply sets this file handle as the default input file.
-When called without parameters,
-it returns the current default input file.
-
-
-<p>
-In case of errors this function raises the error,
-instead of returning an error code.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.lines"><code>io.lines ([filename])</code></a></h3>
-
-
-<p>
-Opens the given file name in read mode
-and returns an iterator function that,
-each time it is called,
-returns a new line from the file.
-Therefore, the construction
-
-<pre>
-     for line in io.lines(filename) do <em>body</em> end
-</pre><p>
-will iterate over all lines of the file.
-When the iterator function detects the end of file,
-it returns <b>nil</b> (to finish the loop) and automatically closes the file.
-
-
-<p>
-The call <code>io.lines()</code> (with no file name) is equivalent
-to <code>io.input():lines()</code>;
-that is, it iterates over the lines of the default input file.
-In this case it does not close the file when the loop ends.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.open"><code>io.open (filename [, mode])</code></a></h3>
-
-
-<p>
-This function opens a file,
-in the mode specified in the string <code>mode</code>.
-It returns a new file handle,
-or, in case of errors, <b>nil</b> plus an error message.
-
-
-<p>
-The <code>mode</code> string can be any of the following:
-
-<ul>
-<li><b>"r":</b> read mode (the default);</li>
-<li><b>"w":</b> write mode;</li>
-<li><b>"a":</b> append mode;</li>
-<li><b>"r+":</b> update mode, all previous data is preserved;</li>
-<li><b>"w+":</b> update mode, all previous data is erased;</li>
-<li><b>"a+":</b> append update mode, previous data is preserved,
-  writing is only allowed at the end of file.</li>
-</ul><p>
-The <code>mode</code> string can also have a '<code>b</code>' at the end,
-which is needed in some systems to open the file in binary mode.
-This string is exactly what is used in the
-standard&nbsp;C function <code>fopen</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.output"><code>io.output ([file])</code></a></h3>
-
-
-<p>
-Similar to <a href="#pdf-io.input"><code>io.input</code></a>, but operates over the default output file.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.popen"><code>io.popen (prog [, mode])</code></a></h3>
-
-
-<p>
-Starts program <code>prog</code> in a separated process and returns
-a file handle that you can use to read data from this program
-(if <code>mode</code> is <code>"r"</code>, the default)
-or to write data to this program
-(if <code>mode</code> is <code>"w"</code>).
-
-
-<p>
-This function is system dependent and is not available
-on all platforms.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.read"><code>io.read (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Equivalent to <code>io.input():read</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.tmpfile"><code>io.tmpfile ()</code></a></h3>
-
-
-<p>
-Returns a handle for a temporary file.
-This file is opened in update mode
-and it is automatically removed when the program ends.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.type"><code>io.type (obj)</code></a></h3>
-
-
-<p>
-Checks whether <code>obj</code> is a valid file handle.
-Returns the string <code>"file"</code> if <code>obj</code> is an open file handle,
-<code>"closed file"</code> if <code>obj</code> is a closed file handle,
-or <b>nil</b> if <code>obj</code> is not a file handle.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.write"><code>io.write (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Equivalent to <code>io.output():write</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:close"><code>file:close ()</code></a></h3>
-
-
-<p>
-Closes <code>file</code>.
-Note that files are automatically closed when
-their handles are garbage collected,
-but that takes an unpredictable amount of time to happen.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:flush"><code>file:flush ()</code></a></h3>
-
-
-<p>
-Saves any written data to <code>file</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:lines"><code>file:lines ()</code></a></h3>
-
-
-<p>
-Returns an iterator function that,
-each time it is called,
-returns a new line from the file.
-Therefore, the construction
-
-<pre>
-     for line in file:lines() do <em>body</em> end
-</pre><p>
-will iterate over all lines of the file.
-(Unlike <a href="#pdf-io.lines"><code>io.lines</code></a>, this function does not close the file
-when the loop ends.)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:read"><code>file:read (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Reads the file <code>file</code>,
-according to the given formats, which specify what to read.
-For each format,
-the function returns a string (or a number) with the characters read,
-or <b>nil</b> if it cannot read data with the specified format.
-When called without formats,
-it uses a default format that reads the entire next line
-(see below).
-
-
-<p>
-The available formats are
-
-<ul>
-
-<li><b>"*n":</b>
-reads a number;
-this is the only format that returns a number instead of a string.
-</li>
-
-<li><b>"*a":</b>
-reads the whole file, starting at the current position.
-On end of file, it returns the empty string.
-</li>
-
-<li><b>"*l":</b>
-reads the next line (skipping the end of line),
-returning <b>nil</b> on end of file.
-This is the default format.
-</li>
-
-<li><b><em>number</em>:</b>
-reads a string with up to this number of characters,
-returning <b>nil</b> on end of file.
-If number is zero,
-it reads nothing and returns an empty string,
-or <b>nil</b> on end of file.
-</li>
-
-</ul>
-
-
-
-<p>
-<hr><h3><a name="pdf-file:seek"><code>file:seek ([whence] [, offset])</code></a></h3>
-
-
-<p>
-Sets and gets the file position,
-measured from the beginning of the file,
-to the position given by <code>offset</code> plus a base
-specified by the string <code>whence</code>, as follows:
-
-<ul>
-<li><b>"set":</b> base is position 0 (beginning of the file);</li>
-<li><b>"cur":</b> base is current position;</li>
-<li><b>"end":</b> base is end of file;</li>
-</ul><p>
-In case of success, function <code>seek</code> returns the final file position,
-measured in bytes from the beginning of the file.
-If this function fails, it returns <b>nil</b>,
-plus a string describing the error.
-
-
-<p>
-The default value for <code>whence</code> is <code>"cur"</code>,
-and for <code>offset</code> is 0.
-Therefore, the call <code>file:seek()</code> returns the current
-file position, without changing it;
-the call <code>file:seek("set")</code> sets the position to the
-beginning of the file (and returns 0);
-and the call <code>file:seek("end")</code> sets the position to the
-end of the file, and returns its size.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:setvbuf"><code>file:setvbuf (mode [, size])</code></a></h3>
-
-
-<p>
-Sets the buffering mode for an output file.
-There are three available modes:
-
-<ul>
-
-<li><b>"no":</b>
-no buffering; the result of any output operation appears immediately.
-</li>
-
-<li><b>"full":</b>
-full buffering; output operation is performed only
-when the buffer is full (or when you explicitly <code>flush</code> the file
-(see <a href="#pdf-io.flush"><code>io.flush</code></a>)).
-</li>
-
-<li><b>"line":</b>
-line buffering; output is buffered until a newline is output
-or there is any input from some special files
-(such as a terminal device).
-</li>
-
-</ul><p>
-For the last two cases, <code>size</code>
-specifies the size of the buffer, in bytes.
-The default is an appropriate size.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:write"><code>file:write (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Writes the value of each of its arguments to
-the <code>file</code>.
-The arguments must be strings or numbers.
-To write other values,
-use <a href="#pdf-tostring"><code>tostring</code></a> or <a href="#pdf-string.format"><code>string.format</code></a> before <code>write</code>.
-
-
-
-
-
-
-
-<h2>5.8 - <a name="5.8">Operating System Facilities</a></h2>
-
-<p>
-This library is implemented through table <a name="pdf-os"><code>os</code></a>.
-
-
-<p>
-<hr><h3><a name="pdf-os.clock"><code>os.clock ()</code></a></h3>
-
-
-<p>
-Returns an approximation of the amount in seconds of CPU time
-used by the program.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.date"><code>os.date ([format [, time]])</code></a></h3>
-
-
-<p>
-Returns a string or a table containing date and time,
-formatted according to the given string <code>format</code>.
-
-
-<p>
-If the <code>time</code> argument is present,
-this is the time to be formatted
-(see the <a href="#pdf-os.time"><code>os.time</code></a> function for a description of this value).
-Otherwise, <code>date</code> formats the current time.
-
-
-<p>
-If <code>format</code> starts with '<code>!</code>',
-then the date is formatted in Coordinated Universal Time.
-After this optional character,
-if <code>format</code> is the string "<code>*t</code>",
-then <code>date</code> returns a table with the following fields:
-<code>year</code> (four digits), <code>month</code> (1--12), <code>day</code> (1--31),
-<code>hour</code> (0--23), <code>min</code> (0--59), <code>sec</code> (0--61),
-<code>wday</code> (weekday, Sunday is&nbsp;1),
-<code>yday</code> (day of the year),
-and <code>isdst</code> (daylight saving flag, a boolean).
-
-
-<p>
-If <code>format</code> is not "<code>*t</code>",
-then <code>date</code> returns the date as a string,
-formatted according to the same rules as the C&nbsp;function <code>strftime</code>.
-
-
-<p>
-When called without arguments,
-<code>date</code> returns a reasonable date and time representation that depends on
-the host system and on the current locale
-(that is, <code>os.date()</code> is equivalent to <code>os.date("%c")</code>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.difftime"><code>os.difftime (t2, t1)</code></a></h3>
-
-
-<p>
-Returns the number of seconds from time <code>t1</code> to time <code>t2</code>.
-In POSIX, Windows, and some other systems,
-this value is exactly <code>t2</code><em>-</em><code>t1</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.execute"><code>os.execute ([command])</code></a></h3>
-
-
-<p>
-This function is equivalent to the C&nbsp;function <code>system</code>.
-It passes <code>command</code> to be executed by an operating system shell.
-It returns a status code, which is system-dependent.
-If <code>command</code> is absent, then it returns nonzero if a shell is available
-and zero otherwise.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.exit"><code>os.exit ([code])</code></a></h3>
-
-
-<p>
-Calls the C&nbsp;function <code>exit</code>,
-with an optional <code>code</code>,
-to terminate the host program.
-The default value for <code>code</code> is the success code.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.getenv"><code>os.getenv (varname)</code></a></h3>
-
-
-<p>
-Returns the value of the process environment variable <code>varname</code>,
-or <b>nil</b> if the variable is not defined.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.remove"><code>os.remove (filename)</code></a></h3>
-
-
-<p>
-Deletes the file or directory with the given name.
-Directories must be empty to be removed.
-If this function fails, it returns <b>nil</b>,
-plus a string describing the error.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.rename"><code>os.rename (oldname, newname)</code></a></h3>
-
-
-<p>
-Renames file or directory named <code>oldname</code> to <code>newname</code>.
-If this function fails, it returns <b>nil</b>,
-plus a string describing the error.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.setlocale"><code>os.setlocale (locale [, category])</code></a></h3>
-
-
-<p>
-Sets the current locale of the program.
-<code>locale</code> is a string specifying a locale;
-<code>category</code> is an optional string describing which category to change:
-<code>"all"</code>, <code>"collate"</code>, <code>"ctype"</code>,
-<code>"monetary"</code>, <code>"numeric"</code>, or <code>"time"</code>;
-the default category is <code>"all"</code>.
-The function returns the name of the new locale,
-or <b>nil</b> if the request cannot be honored.
-
-
-<p>
-If <code>locale</code> is the empty string,
-the current locale is set to an implementation-defined native locale.
-If <code>locale</code> is the string "<code>C</code>",
-the current locale is set to the standard C locale.
-
-
-<p>
-When called with <b>nil</b> as the first argument,
-this function only returns the name of the current locale
-for the given category.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.time"><code>os.time ([table])</code></a></h3>
-
-
-<p>
-Returns the current time when called without arguments,
-or a time representing the date and time specified by the given table.
-This table must have fields <code>year</code>, <code>month</code>, and <code>day</code>,
-and may have fields <code>hour</code>, <code>min</code>, <code>sec</code>, and <code>isdst</code>
-(for a description of these fields, see the <a href="#pdf-os.date"><code>os.date</code></a> function).
-
-
-<p>
-The returned value is a number, whose meaning depends on your system.
-In POSIX, Windows, and some other systems, this number counts the number
-of seconds since some given start time (the "epoch").
-In other systems, the meaning is not specified,
-and the number returned by <code>time</code> can be used only as an argument to
-<code>date</code> and <code>difftime</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.tmpname"><code>os.tmpname ()</code></a></h3>
-
-
-<p>
-Returns a string with a file name that can
-be used for a temporary file.
-The file must be explicitly opened before its use
-and explicitly removed when no longer needed.
-
-
-<p>
-On some systems (POSIX),
-this function also creates a file with that name,
-to avoid security risks.
-(Someone else might create the file with wrong permissions
-in the time between getting the name and creating the file.)
-You still have to open the file to use it
-and to remove it (even if you do not use it).
-
-
-<p>
-When possible,
-you may prefer to use <a href="#pdf-io.tmpfile"><code>io.tmpfile</code></a>,
-which automatically removes the file when the program ends.
-
-
-
-
-
-
-
-<h2>5.9 - <a name="5.9">The Debug Library</a></h2>
-
-<p>
-This library provides
-the functionality of the debug interface to Lua programs.
-You should exert care when using this library.
-The functions provided here should be used exclusively for debugging
-and similar tasks, such as profiling.
-Please resist the temptation to use them as a
-usual programming tool:
-they can be very slow.
-Moreover, several of these functions
-violate some assumptions about Lua code
-(e.g., that variables local to a function
-cannot be accessed from outside or
-that userdata metatables cannot be changed by Lua code)
-and therefore can compromise otherwise secure code.
-
-
-<p>
-All functions in this library are provided
-inside the <a name="pdf-debug"><code>debug</code></a> table.
-All functions that operate over a thread
-have an optional first argument which is the
-thread to operate over.
-The default is always the current thread.
-
-
-<p>
-<hr><h3><a name="pdf-debug.debug"><code>debug.debug ()</code></a></h3>
-
-
-<p>
-Enters an interactive mode with the user,
-running each string that the user enters.
-Using simple commands and other debug facilities,
-the user can inspect global and local variables,
-change their values, evaluate expressions, and so on.
-A line containing only the word <code>cont</code> finishes this function,
-so that the caller continues its execution.
-
-
-<p>
-Note that commands for <code>debug.debug</code> are not lexically nested
-within any function, and so have no direct access to local variables.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getfenv"><code>debug.getfenv (o)</code></a></h3>
-Returns the environment of object <code>o</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.gethook"><code>debug.gethook ([thread])</code></a></h3>
-
-
-<p>
-Returns the current hook settings of the thread, as three values:
-the current hook function, the current hook mask,
-and the current hook count
-(as set by the <a href="#pdf-debug.sethook"><code>debug.sethook</code></a> function).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getinfo"><code>debug.getinfo ([thread,] function [, what])</code></a></h3>
-
-
-<p>
-Returns a table with information about a function.
-You can give the function directly,
-or you can give a number as the value of <code>function</code>,
-which means the function running at level <code>function</code> of the call stack
-of the given thread:
-level&nbsp;0 is the current function (<code>getinfo</code> itself);
-level&nbsp;1 is the function that called <code>getinfo</code>;
-and so on.
-If <code>function</code> is a number larger than the number of active functions,
-then <code>getinfo</code> returns <b>nil</b>.
-
-
-<p>
-The returned table can contain all the fields returned by <a href="#lua_getinfo"><code>lua_getinfo</code></a>,
-with the string <code>what</code> describing which fields to fill in.
-The default for <code>what</code> is to get all information available,
-except the table of valid lines.
-If present,
-the option '<code>f</code>'
-adds a field named <code>func</code> with the function itself.
-If present,
-the option '<code>L</code>'
-adds a field named <code>activelines</code> with the table of
-valid lines.
-
-
-<p>
-For instance, the expression <code>debug.getinfo(1,"n").name</code> returns
-a table with a name for the current function,
-if a reasonable name can be found,
-and the expression <code>debug.getinfo(print)</code>
-returns a table with all available information
-about the <a href="#pdf-print"><code>print</code></a> function.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getlocal"><code>debug.getlocal ([thread,] level, local)</code></a></h3>
-
-
-<p>
-This function returns the name and the value of the local variable
-with index <code>local</code> of the function at level <code>level</code> of the stack.
-(The first parameter or local variable has index&nbsp;1, and so on,
-until the last active local variable.)
-The function returns <b>nil</b> if there is no local
-variable with the given index,
-and raises an error when called with a <code>level</code> out of range.
-(You can call <a href="#pdf-debug.getinfo"><code>debug.getinfo</code></a> to check whether the level is valid.)
-
-
-<p>
-Variable names starting with '<code>(</code>' (open parentheses)
-represent internal variables
-(loop control variables, temporaries, and C&nbsp;function locals).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getmetatable"><code>debug.getmetatable (object)</code></a></h3>
-
-
-<p>
-Returns the metatable of the given <code>object</code>
-or <b>nil</b> if it does not have a metatable.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getregistry"><code>debug.getregistry ()</code></a></h3>
-
-
-<p>
-Returns the registry table (see <a href="#3.5">&sect;3.5</a>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getupvalue"><code>debug.getupvalue (func, up)</code></a></h3>
-
-
-<p>
-This function returns the name and the value of the upvalue
-with index <code>up</code> of the function <code>func</code>.
-The function returns <b>nil</b> if there is no upvalue with the given index.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.setfenv"><code>debug.setfenv (object, table)</code></a></h3>
-
-
-<p>
-Sets the environment of the given <code>object</code> to the given <code>table</code>.
-Returns <code>object</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.sethook"><code>debug.sethook ([thread,] hook, mask [, count])</code></a></h3>
-
-
-<p>
-Sets the given function as a hook.
-The string <code>mask</code> and the number <code>count</code> describe
-when the hook will be called.
-The string mask may have the following characters,
-with the given meaning:
-
-<ul>
-<li><b><code>"c"</code>:</b> the hook is called every time Lua calls a function;</li>
-<li><b><code>"r"</code>:</b> the hook is called every time Lua returns from a function;</li>
-<li><b><code>"l"</code>:</b> the hook is called every time Lua enters a new line of code.</li>
-</ul><p>
-With a <code>count</code> different from zero,
-the hook is called after every <code>count</code> instructions.
-
-
-<p>
-When called without arguments,
-<a href="#pdf-debug.sethook"><code>debug.sethook</code></a> turns off the hook.
-
-
-<p>
-When the hook is called, its first parameter is a string
-describing the event that has triggered its call:
-<code>"call"</code>, <code>"return"</code> (or <code>"tail return"</code>,
-when simulating a return from a tail call),
-<code>"line"</code>, and <code>"count"</code>.
-For line events,
-the hook also gets the new line number as its second parameter.
-Inside a hook,
-you can call <code>getinfo</code> with level&nbsp;2 to get more information about
-the running function
-(level&nbsp;0 is the <code>getinfo</code> function,
-and level&nbsp;1 is the hook function),
-unless the event is <code>"tail return"</code>.
-In this case, Lua is only simulating the return,
-and a call to <code>getinfo</code> will return invalid data.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.setlocal"><code>debug.setlocal ([thread,] level, local, value)</code></a></h3>
-
-
-<p>
-This function assigns the value <code>value</code> to the local variable
-with index <code>local</code> of the function at level <code>level</code> of the stack.
-The function returns <b>nil</b> if there is no local
-variable with the given index,
-and raises an error when called with a <code>level</code> out of range.
-(You can call <code>getinfo</code> to check whether the level is valid.)
-Otherwise, it returns the name of the local variable.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.setmetatable"><code>debug.setmetatable (object, table)</code></a></h3>
-
-
-<p>
-Sets the metatable for the given <code>object</code> to the given <code>table</code>
-(which can be <b>nil</b>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.setupvalue"><code>debug.setupvalue (func, up, value)</code></a></h3>
-
-
-<p>
-This function assigns the value <code>value</code> to the upvalue
-with index <code>up</code> of the function <code>func</code>.
-The function returns <b>nil</b> if there is no upvalue
-with the given index.
-Otherwise, it returns the name of the upvalue.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.traceback"><code>debug.traceback ([thread,] [message [, level]])</code></a></h3>
-
-
-<p>
-Returns a string with a traceback of the call stack.
-An optional <code>message</code> string is appended
-at the beginning of the traceback.
-An optional <code>level</code> number tells at which level
-to start the traceback
-(default is 1, the function calling <code>traceback</code>).
-
-
-
-
-
-
-
-<h1>6 - <a name="6">Lua Stand-alone</a></h1>
-
-<p>
-Although Lua has been designed as an extension language,
-to be embedded in a host C&nbsp;program,
-it is also frequently used as a stand-alone language.
-An interpreter for Lua as a stand-alone language,
-called simply <code>lua</code>,
-is provided with the standard distribution.
-The stand-alone interpreter includes
-all standard libraries, including the debug library.
-Its usage is:
-
-<pre>
-     lua [options] [script [args]]
-</pre><p>
-The options are:
-
-<ul>
-<li><b><code>-e <em>stat</em></code>:</b> executes string <em>stat</em>;</li>
-<li><b><code>-l <em>mod</em></code>:</b> "requires" <em>mod</em>;</li>
-<li><b><code>-i</code>:</b> enters interactive mode after running <em>script</em>;</li>
-<li><b><code>-v</code>:</b> prints version information;</li>
-<li><b><code>--</code>:</b> stops handling options;</li>
-<li><b><code>-</code>:</b> executes <code>stdin</code> as a file and stops handling options.</li>
-</ul><p>
-After handling its options, <code>lua</code> runs the given <em>script</em>,
-passing to it the given <em>args</em> as string arguments.
-When called without arguments,
-<code>lua</code> behaves as <code>lua -v -i</code>
-when the standard input (<code>stdin</code>) is a terminal,
-and as <code>lua -</code> otherwise.
-
-
-<p>
-Before running any argument,
-the interpreter checks for an environment variable <a name="pdf-LUA_INIT"><code>LUA_INIT</code></a>.
-If its format is <code>@<em>filename</em></code>,
-then <code>lua</code> executes the file.
-Otherwise, <code>lua</code> executes the string itself.
-
-
-<p>
-All options are handled in order, except <code>-i</code>.
-For instance, an invocation like
-
-<pre>
-     $ lua -e'a=1' -e 'print(a)' script.lua
-</pre><p>
-will first set <code>a</code> to 1, then print the value of <code>a</code> (which is '<code>1</code>'),
-and finally run the file <code>script.lua</code> with no arguments.
-(Here <code>$</code> is the shell prompt. Your prompt may be different.)
-
-
-<p>
-Before starting to run the script,
-<code>lua</code> collects all arguments in the command line
-in a global table called <code>arg</code>.
-The script name is stored at index 0,
-the first argument after the script name goes to index 1,
-and so on.
-Any arguments before the script name
-(that is, the interpreter name plus the options)
-go to negative indices.
-For instance, in the call
-
-<pre>
-     $ lua -la b.lua t1 t2
-</pre><p>
-the interpreter first runs the file <code>a.lua</code>,
-then creates a table
-
-<pre>
-     arg = { [-2] = "lua", [-1] = "-la",
-             [0] = "b.lua",
-             [1] = "t1", [2] = "t2" }
-</pre><p>
-and finally runs the file <code>b.lua</code>.
-The script is called with <code>arg[1]</code>, <code>arg[2]</code>, &middot;&middot;&middot;
-as arguments;
-it can also access these arguments with the vararg expression '<code>...</code>'.
-
-
-<p>
-In interactive mode,
-if you write an incomplete statement,
-the interpreter waits for its completion
-by issuing a different prompt.
-
-
-<p>
-If the global variable <a name="pdf-_PROMPT"><code>_PROMPT</code></a> contains a string,
-then its value is used as the prompt.
-Similarly, if the global variable <a name="pdf-_PROMPT2"><code>_PROMPT2</code></a> contains a string,
-its value is used as the secondary prompt
-(issued during incomplete statements).
-Therefore, both prompts can be changed directly on the command line
-or in any Lua programs by assigning to <code>_PROMPT</code>.
-See the next example:
-
-<pre>
-     $ lua -e"_PROMPT='myprompt&gt; '" -i
-</pre><p>
-(The outer pair of quotes is for the shell,
-the inner pair is for Lua.)
-Note the use of <code>-i</code> to enter interactive mode;
-otherwise,
-the program would just end silently
-right after the assignment to <code>_PROMPT</code>.
-
-
-<p>
-To allow the use of Lua as a
-script interpreter in Unix systems,
-the stand-alone interpreter skips
-the first line of a chunk if it starts with <code>#</code>.
-Therefore, Lua scripts can be made into executable programs
-by using <code>chmod +x</code> and the&nbsp;<code>#!</code> form,
-as in
-
-<pre>
-     #!/usr/local/bin/lua
-</pre><p>
-(Of course,
-the location of the Lua interpreter may be different in your machine.
-If <code>lua</code> is in your <code>PATH</code>,
-then 
-
-<pre>
-     #!/usr/bin/env lua
-</pre><p>
-is a more portable solution.) 
-
-
-
-<h1>7 - <a name="7">Incompatibilities with the Previous Version</a></h1>
-
-<p>
-Here we list the incompatibilities that you may find when moving a program
-from Lua&nbsp;5.0 to Lua&nbsp;5.1.
-You can avoid most of the incompatibilities compiling Lua with
-appropriate options (see file <code>luaconf.h</code>).
-However,
-all these compatibility options will be removed in the next version of Lua.
-
-
-
-<h2>7.1 - <a name="7.1">Changes in the Language</a></h2>
-<ul>
-
-<li>
-The vararg system changed from the pseudo-argument <code>arg</code> with a
-table with the extra arguments to the vararg expression.
-(See compile-time option <code>LUA_COMPAT_VARARG</code> in <code>luaconf.h</code>.)
-</li>
-
-<li>
-There was a subtle change in the scope of the implicit
-variables of the <b>for</b> statement and for the <b>repeat</b> statement.
-</li>
-
-<li>
-The long string/long comment syntax (<code>[[<em>string</em>]]</code>)
-does not allow nesting.
-You can use the new syntax (<code>[=[<em>string</em>]=]</code>) in these cases.
-(See compile-time option <code>LUA_COMPAT_LSTR</code> in <code>luaconf.h</code>.)
-</li>
-
-</ul>
-
-
-
-
-<h2>7.2 - <a name="7.2">Changes in the Libraries</a></h2>
-<ul>
-
-<li>
-Function <code>string.gfind</code> was renamed <a href="#pdf-string.gmatch"><code>string.gmatch</code></a>.
-(See compile-time option <code>LUA_COMPAT_GFIND</code> in <code>luaconf.h</code>.)
-</li>
-
-<li>
-When <a href="#pdf-string.gsub"><code>string.gsub</code></a> is called with a function as its
-third argument,
-whenever this function returns <b>nil</b> or <b>false</b> the
-replacement string is the whole match,
-instead of the empty string.
-</li>
-
-<li>
-Function <code>table.setn</code> was deprecated.
-Function <code>table.getn</code> corresponds
-to the new length operator (<code>#</code>);
-use the operator instead of the function.
-(See compile-time option <code>LUA_COMPAT_GETN</code> in <code>luaconf.h</code>.)
-</li>
-
-<li>
-Function <code>loadlib</code> was renamed <a href="#pdf-package.loadlib"><code>package.loadlib</code></a>.
-(See compile-time option <code>LUA_COMPAT_LOADLIB</code> in <code>luaconf.h</code>.)
-</li>
-
-<li>
-Function <code>math.mod</code> was renamed <a href="#pdf-math.fmod"><code>math.fmod</code></a>.
-(See compile-time option <code>LUA_COMPAT_MOD</code> in <code>luaconf.h</code>.)
-</li>
-
-<li>
-Functions <code>table.foreach</code> and <code>table.foreachi</code> are deprecated.
-You can use a for loop with <code>pairs</code> or <code>ipairs</code> instead.
-</li>
-
-<li>
-There were substantial changes in function <a href="#pdf-require"><code>require</code></a> due to
-the new module system.
-However, the new behavior is mostly compatible with the old,
-but <code>require</code> gets the path from <a href="#pdf-package.path"><code>package.path</code></a> instead
-of from <code>LUA_PATH</code>.
-</li>
-
-<li>
-Function <a href="#pdf-collectgarbage"><code>collectgarbage</code></a> has different arguments.
-Function <code>gcinfo</code> is deprecated;
-use <code>collectgarbage("count")</code> instead.
-</li>
-
-</ul>
-
-
-
-
-<h2>7.3 - <a name="7.3">Changes in the API</a></h2>
-<ul>
-
-<li>
-The <code>luaopen_*</code> functions (to open libraries)
-cannot be called directly,
-like a regular C function.
-They must be called through Lua,
-like a Lua function.
-</li>
-
-<li>
-Function <code>lua_open</code> was replaced by <a href="#lua_newstate"><code>lua_newstate</code></a> to
-allow the user to set a memory-allocation function.
-You can use <a href="#luaL_newstate"><code>luaL_newstate</code></a> from the standard library to
-create a state with a standard allocation function
-(based on <code>realloc</code>).
-</li>
-
-<li>
-Functions <code>luaL_getn</code> and <code>luaL_setn</code>
-(from the auxiliary library) are deprecated.
-Use <a href="#lua_objlen"><code>lua_objlen</code></a> instead of <code>luaL_getn</code>
-and nothing instead of <code>luaL_setn</code>.
-</li>
-
-<li>
-Function <code>luaL_openlib</code> was replaced by <a href="#luaL_register"><code>luaL_register</code></a>.
-</li>
-
-<li>
-Function <code>luaL_checkudata</code> now throws an error when the given value
-is not a userdata of the expected type.
-(In Lua&nbsp;5.0 it returned <code>NULL</code>.)
-</li>
-
-</ul>
-
-
-
-
-<h1>8 - <a name="8">The Complete Syntax of Lua</a></h1>
-
-<p>
-Here is the complete syntax of Lua in extended BNF.
-(It does not describe operator precedences.)
-
-
-
-
-<pre>
-
-	chunk ::= {stat [`<b>;</b>&acute;]} [laststat [`<b>;</b>&acute;]]
-
-	block ::= chunk
-
-	stat ::=  varlist `<b>=</b>&acute; explist | 
-		 functioncall | 
-		 <b>do</b> block <b>end</b> | 
-		 <b>while</b> exp <b>do</b> block <b>end</b> | 
-		 <b>repeat</b> block <b>until</b> exp | 
-		 <b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b> | 
-		 <b>for</b> Name `<b>=</b>&acute; exp `<b>,</b>&acute; exp [`<b>,</b>&acute; exp] <b>do</b> block <b>end</b> | 
-		 <b>for</b> namelist <b>in</b> explist <b>do</b> block <b>end</b> | 
-		 <b>function</b> funcname funcbody | 
-		 <b>local</b> <b>function</b> Name funcbody | 
-		 <b>local</b> namelist [`<b>=</b>&acute; explist] 
-
-	laststat ::= <b>return</b> [explist] | <b>break</b>
-
-	funcname ::= Name {`<b>.</b>&acute; Name} [`<b>:</b>&acute; Name]
-
-	varlist ::= var {`<b>,</b>&acute; var}
-
-	var ::=  Name | prefixexp `<b>[</b>&acute; exp `<b>]</b>&acute; | prefixexp `<b>.</b>&acute; Name 
-
-	namelist ::= Name {`<b>,</b>&acute; Name}
-
-	explist ::= {exp `<b>,</b>&acute;} exp
-
-	exp ::=  <b>nil</b> | <b>false</b> | <b>true</b> | Number | String | `<b>...</b>&acute; | function | 
-		 prefixexp | tableconstructor | exp binop exp | unop exp 
-
-	prefixexp ::= var | functioncall | `<b>(</b>&acute; exp `<b>)</b>&acute;
-
-	functioncall ::=  prefixexp args | prefixexp `<b>:</b>&acute; Name args 
-
-	args ::=  `<b>(</b>&acute; [explist] `<b>)</b>&acute; | tableconstructor | String 
-
-	function ::= <b>function</b> funcbody
-
-	funcbody ::= `<b>(</b>&acute; [parlist] `<b>)</b>&acute; block <b>end</b>
-
-	parlist ::= namelist [`<b>,</b>&acute; `<b>...</b>&acute;] | `<b>...</b>&acute;
-
-	tableconstructor ::= `<b>{</b>&acute; [fieldlist] `<b>}</b>&acute;
-
-	fieldlist ::= field {fieldsep field} [fieldsep]
-
-	field ::= `<b>[</b>&acute; exp `<b>]</b>&acute; `<b>=</b>&acute; exp | Name `<b>=</b>&acute; exp | exp
-
-	fieldsep ::= `<b>,</b>&acute; | `<b>;</b>&acute;
-
-	binop ::= `<b>+</b>&acute; | `<b>-</b>&acute; | `<b>*</b>&acute; | `<b>/</b>&acute; | `<b>^</b>&acute; | `<b>%</b>&acute; | `<b>..</b>&acute; | 
-		 `<b>&lt;</b>&acute; | `<b>&lt;=</b>&acute; | `<b>&gt;</b>&acute; | `<b>&gt;=</b>&acute; | `<b>==</b>&acute; | `<b>~=</b>&acute; | 
-		 <b>and</b> | <b>or</b>
-
-	unop ::= `<b>-</b>&acute; | <b>not</b> | `<b>#</b>&acute;
-
-</pre>
-
-<p>
-
-
-
-
-
-
-
-<HR>
-<SMALL CLASS="footer">
-Last update:
-Mon Feb 13 18:54:19 BRST 2012
-</SMALL>
-<!--
-Last change: revised for Lua 5.1.5
--->
-
-</body></html>
-
diff --git a/extern/lua-5.1.5/doc/readme.html b/extern/lua-5.1.5/doc/readme.html
deleted file mode 100644
index 3ed6a818..00000000
--- a/extern/lua-5.1.5/doc/readme.html
+++ /dev/null
@@ -1,40 +0,0 @@
-<HTML>
-<HEAD>
-<TITLE>Lua documentation</TITLE>
-<LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
-</HEAD>
-
-<BODY>
-
-<HR>
-<H1>
-<A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="Lua" BORDER=0></A>
-Documentation
-</H1>
-
-This is the documentation included in the source distribution of Lua 5.1.5.
-
-<UL>
-<LI><A HREF="contents.html">Reference manual</A>
-<LI><A HREF="lua.html">lua man page</A>
-<LI><A HREF="luac.html">luac man page</A>
-<LI><A HREF="../README">lua/README</A>
-<LI><A HREF="../etc/README">lua/etc/README</A>
-<LI><A HREF="../test/README">lua/test/README</A>
-</UL>
-
-Lua's
-<A HREF="http://www.lua.org/">official web site</A>
-contains updated documentation,
-especially the
-<A HREF="http://www.lua.org/manual/5.1/">reference manual</A>.
-<P>
-
-<HR>
-<SMALL>
-Last update:
-Fri Feb  3 09:44:42 BRST 2012
-</SMALL>
-
-</BODY>
-</HTML>
diff --git a/extern/lua-5.1.5/etc/Makefile b/extern/lua-5.1.5/etc/Makefile
deleted file mode 100644
index 6d00008d..00000000
--- a/extern/lua-5.1.5/etc/Makefile
+++ /dev/null
@@ -1,44 +0,0 @@
-# makefile for Lua etc
-
-TOP= ..
-LIB= $(TOP)/src
-INC= $(TOP)/src
-BIN= $(TOP)/src
-SRC= $(TOP)/src
-TST= $(TOP)/test
-
-CC= gcc
-CFLAGS= -O2 -Wall -I$(INC) $(MYCFLAGS)
-MYCFLAGS= 
-MYLDFLAGS= -Wl,-E
-MYLIBS= -lm
-#MYLIBS= -lm -Wl,-E -ldl -lreadline -lhistory -lncurses
-RM= rm -f
-
-default:
-	@echo 'Please choose a target: min noparser one strict clean'
-
-min:	min.c
-	$(CC) $(CFLAGS) $@.c -L$(LIB) -llua $(MYLIBS)
-	echo 'print"Hello there!"' | ./a.out
-
-noparser: noparser.o
-	$(CC) noparser.o $(SRC)/lua.o -L$(LIB) -llua $(MYLIBS)
-	$(BIN)/luac $(TST)/hello.lua
-	-./a.out luac.out
-	-./a.out -e'a=1'
-
-one:
-	$(CC) $(CFLAGS) all.c $(MYLIBS)
-	./a.out $(TST)/hello.lua
-
-strict:
-	-$(BIN)/lua -e 'print(a);b=2'
-	-$(BIN)/lua -lstrict -e 'print(a)'
-	-$(BIN)/lua -e 'function f() b=2 end f()'
-	-$(BIN)/lua -lstrict -e 'function f() b=2 end f()'
-
-clean:
-	$(RM) a.out core core.* *.o luac.out
-
-.PHONY:	default min noparser one strict clean
diff --git a/extern/lua-5.1.5/etc/README b/extern/lua-5.1.5/etc/README
deleted file mode 100644
index 5149fc91..00000000
--- a/extern/lua-5.1.5/etc/README
+++ /dev/null
@@ -1,37 +0,0 @@
-This directory contains some useful files and code.
-Unlike the code in ../src, everything here is in the public domain.
-
-If any of the makes fail, you're probably not using the same libraries
-used to build Lua. Set MYLIBS in Makefile accordingly.
-
-all.c
-	Full Lua interpreter in a single file.
-	Do "make one" for a demo.
-
-lua.hpp
-	Lua header files for C++ using 'extern "C"'.
-
-lua.ico
-	A Lua icon for Windows (and web sites: save as favicon.ico).
-	Drawn by hand by Markus Gritsch <gritsch@iue.tuwien.ac.at>.
-
-lua.pc
-	pkg-config data for Lua
-
-luavs.bat
-	Script to build Lua under "Visual Studio .NET Command Prompt".
-	Run it from the toplevel as etc\luavs.bat.
-
-min.c
-	A minimal Lua interpreter.
-	Good for learning and for starting your own.
-	Do "make min" for a demo.
-
-noparser.c
-	Linking with noparser.o avoids loading the parsing modules in lualib.a.
-	Do "make noparser" for a demo.
-
-strict.lua
-	Traps uses of undeclared global variables.
-	Do "make strict" for a demo.
-
diff --git a/extern/lua-5.1.5/etc/all.c b/extern/lua-5.1.5/etc/all.c
deleted file mode 100644
index dab68fac..00000000
--- a/extern/lua-5.1.5/etc/all.c
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
-* all.c -- Lua core, libraries and interpreter in a single file
-*/
-
-#define luaall_c
-
-#include "lapi.c"
-#include "lcode.c"
-#include "ldebug.c"
-#include "ldo.c"
-#include "ldump.c"
-#include "lfunc.c"
-#include "lgc.c"
-#include "llex.c"
-#include "lmem.c"
-#include "lobject.c"
-#include "lopcodes.c"
-#include "lparser.c"
-#include "lstate.c"
-#include "lstring.c"
-#include "ltable.c"
-#include "ltm.c"
-#include "lundump.c"
-#include "lvm.c"
-#include "lzio.c"
-
-#include "lauxlib.c"
-#include "lbaselib.c"
-#include "ldblib.c"
-#include "liolib.c"
-#include "linit.c"
-#include "lmathlib.c"
-#include "loadlib.c"
-#include "loslib.c"
-#include "lstrlib.c"
-#include "ltablib.c"
-
-#include "lua.c"
diff --git a/extern/lua-5.1.5/etc/lua.hpp b/extern/lua-5.1.5/etc/lua.hpp
deleted file mode 100644
index ec417f59..00000000
--- a/extern/lua-5.1.5/etc/lua.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// lua.hpp
-// Lua header files for C++
-// <<extern "C">> not supplied automatically because Lua also compiles as C++
-
-extern "C" {
-#include "lua.h"
-#include "lualib.h"
-#include "lauxlib.h"
-}
diff --git a/extern/lua-5.1.5/etc/lua.ico b/extern/lua-5.1.5/etc/lua.ico
deleted file mode 100644
index ccbabc4e..00000000
Binary files a/extern/lua-5.1.5/etc/lua.ico and /dev/null differ
diff --git a/extern/lua-5.1.5/etc/lua.pc b/extern/lua-5.1.5/etc/lua.pc
deleted file mode 100644
index 07e2852b..00000000
--- a/extern/lua-5.1.5/etc/lua.pc
+++ /dev/null
@@ -1,31 +0,0 @@
-# lua.pc -- pkg-config data for Lua
-
-# vars from install Makefile
-
-# grep '^V=' ../Makefile
-V= 5.1
-# grep '^R=' ../Makefile
-R= 5.1.5
-
-# grep '^INSTALL_.*=' ../Makefile | sed 's/INSTALL_TOP/prefix/'
-prefix= /usr/local
-INSTALL_BIN= ${prefix}/bin
-INSTALL_INC= ${prefix}/include
-INSTALL_LIB= ${prefix}/lib
-INSTALL_MAN= ${prefix}/man/man1
-INSTALL_LMOD= ${prefix}/share/lua/${V}
-INSTALL_CMOD= ${prefix}/lib/lua/${V}
-
-# canonical vars
-exec_prefix=${prefix}
-libdir=${exec_prefix}/lib
-includedir=${prefix}/include
-
-Name: Lua
-Description: An Extensible Extension Language
-Version: ${R}
-Requires: 
-Libs: -L${libdir} -llua -lm
-Cflags: -I${includedir}
-
-# (end of lua.pc)
diff --git a/extern/lua-5.1.5/etc/luavs.bat b/extern/lua-5.1.5/etc/luavs.bat
deleted file mode 100644
index 08c2bedd..00000000
--- a/extern/lua-5.1.5/etc/luavs.bat
+++ /dev/null
@@ -1,28 +0,0 @@
-@rem Script to build Lua under "Visual Studio .NET Command Prompt".
-@rem Do not run from this directory; run it from the toplevel: etc\luavs.bat .
-@rem It creates lua51.dll, lua51.lib, lua.exe, and luac.exe in src.
-@rem (contributed by David Manura and Mike Pall)
-
-@setlocal
-@set MYCOMPILE=cl /nologo /MD /O2 /W3 /c /D_CRT_SECURE_NO_DEPRECATE
-@set MYLINK=link /nologo
-@set MYMT=mt /nologo
-
-cd src
-%MYCOMPILE% /DLUA_BUILD_AS_DLL l*.c
-del lua.obj luac.obj
-%MYLINK% /DLL /out:lua51.dll l*.obj
-if exist lua51.dll.manifest^
-  %MYMT% -manifest lua51.dll.manifest -outputresource:lua51.dll;2
-%MYCOMPILE% /DLUA_BUILD_AS_DLL lua.c
-%MYLINK% /out:lua.exe lua.obj lua51.lib
-if exist lua.exe.manifest^
-  %MYMT% -manifest lua.exe.manifest -outputresource:lua.exe
-%MYCOMPILE% l*.c print.c
-del lua.obj linit.obj lbaselib.obj ldblib.obj liolib.obj lmathlib.obj^
-    loslib.obj ltablib.obj lstrlib.obj loadlib.obj
-%MYLINK% /out:luac.exe *.obj
-if exist luac.exe.manifest^
-  %MYMT% -manifest luac.exe.manifest -outputresource:luac.exe
-del *.obj *.manifest
-cd ..
diff --git a/extern/lua-5.1.5/etc/min.c b/extern/lua-5.1.5/etc/min.c
deleted file mode 100644
index 6a85a4d1..00000000
--- a/extern/lua-5.1.5/etc/min.c
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
-* min.c -- a minimal Lua interpreter
-* loads stdin only with minimal error handling.
-* no interaction, and no standard library, only a "print" function.
-*/
-
-#include <stdio.h>
-
-#include "lua.h"
-#include "lauxlib.h"
-
-static int print(lua_State *L)
-{
- int n=lua_gettop(L);
- int i;
- for (i=1; i<=n; i++)
- {
-  if (i>1) printf("\t");
-  if (lua_isstring(L,i))
-   printf("%s",lua_tostring(L,i));
-  else if (lua_isnil(L,i))
-   printf("%s","nil");
-  else if (lua_isboolean(L,i))
-   printf("%s",lua_toboolean(L,i) ? "true" : "false");
-  else
-   printf("%s:%p",luaL_typename(L,i),lua_topointer(L,i));
- }
- printf("\n");
- return 0;
-}
-
-int main(void)
-{
- lua_State *L=lua_open();
- lua_register(L,"print",print);
- if (luaL_dofile(L,NULL)!=0) fprintf(stderr,"%s\n",lua_tostring(L,-1));
- lua_close(L);
- return 0;
-}
diff --git a/extern/lua-5.1.5/etc/noparser.c b/extern/lua-5.1.5/etc/noparser.c
deleted file mode 100644
index 13ba5462..00000000
--- a/extern/lua-5.1.5/etc/noparser.c
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-* The code below can be used to make a Lua core that does not contain the
-* parsing modules (lcode, llex, lparser), which represent 35% of the total core.
-* You'll only be able to load binary files and strings, precompiled with luac.
-* (Of course, you'll have to build luac with the original parsing modules!)
-*
-* To use this module, simply compile it ("make noparser" does that) and list
-* its object file before the Lua libraries. The linker should then not load
-* the parsing modules. To try it, do "make luab".
-*
-* If you also want to avoid the dump module (ldump.o), define NODUMP.
-* #define NODUMP
-*/
-
-#define LUA_CORE
-
-#include "llex.h"
-#include "lparser.h"
-#include "lzio.h"
-
-LUAI_FUNC void luaX_init (lua_State *L) {
-  UNUSED(L);
-}
-
-LUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
-  UNUSED(z);
-  UNUSED(buff);
-  UNUSED(name);
-  lua_pushliteral(L,"parser not loaded");
-  lua_error(L);
-  return NULL;
-}
-
-#ifdef NODUMP
-#include "lundump.h"
-
-LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip) {
-  UNUSED(f);
-  UNUSED(w);
-  UNUSED(data);
-  UNUSED(strip);
-#if 1
-  UNUSED(L);
-  return 0;
-#else
-  lua_pushliteral(L,"dumper not loaded");
-  lua_error(L);
-#endif
-}
-#endif
diff --git a/extern/lua-5.1.5/etc/strict.lua b/extern/lua-5.1.5/etc/strict.lua
deleted file mode 100644
index 604619dd..00000000
--- a/extern/lua-5.1.5/etc/strict.lua
+++ /dev/null
@@ -1,41 +0,0 @@
---
--- strict.lua
--- checks uses of undeclared global variables
--- All global variables must be 'declared' through a regular assignment
--- (even assigning nil will do) in a main chunk before being used
--- anywhere or assigned to inside a function.
---
-
-local getinfo, error, rawset, rawget = debug.getinfo, error, rawset, rawget
-
-local mt = getmetatable(_G)
-if mt == nil then
-  mt = {}
-  setmetatable(_G, mt)
-end
-
-mt.__declared = {}
-
-local function what ()
-  local d = getinfo(3, "S")
-  return d and d.what or "C"
-end
-
-mt.__newindex = function (t, n, v)
-  if not mt.__declared[n] then
-    local w = what()
-    if w ~= "main" and w ~= "C" then
-      error("assign to undeclared variable '"..n.."'", 2)
-    end
-    mt.__declared[n] = true
-  end
-  rawset(t, n, v)
-end
-  
-mt.__index = function (t, n)
-  if not mt.__declared[n] and what() ~= "C" then
-    error("variable '"..n.."' is not declared", 2)
-  end
-  return rawget(t, n)
-end
-
diff --git a/extern/lua-5.1.5/src/Makefile b/extern/lua-5.1.5/src/Makefile
deleted file mode 100644
index e0d4c9fa..00000000
--- a/extern/lua-5.1.5/src/Makefile
+++ /dev/null
@@ -1,182 +0,0 @@
-# makefile for building Lua
-# see ../INSTALL for installation instructions
-# see ../Makefile and luaconf.h for further customization
-
-# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
-
-# Your platform. See PLATS for possible values.
-PLAT= none
-
-CC= gcc
-CFLAGS= -O2 -Wall $(MYCFLAGS)
-AR= ar rcu
-RANLIB= ranlib
-RM= rm -f
-LIBS= -lm $(MYLIBS)
-
-MYCFLAGS=
-MYLDFLAGS=
-MYLIBS=
-
-# == END OF USER SETTINGS. NO NEED TO CHANGE ANYTHING BELOW THIS LINE =========
-
-PLATS= aix ansi bsd freebsd generic linux macosx mingw posix solaris
-
-LUA_A=	liblua.a
-CORE_O=	lapi.o lcode.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o lmem.o \
-	lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o ltm.o  \
-	lundump.o lvm.o lzio.o
-LIB_O=	lauxlib.o lbaselib.o ldblib.o liolib.o lmathlib.o loslib.o ltablib.o \
-	lstrlib.o loadlib.o linit.o
-
-LUA_T=	lua
-LUA_O=	lua.o
-
-LUAC_T=	luac
-LUAC_O=	luac.o print.o
-
-ALL_O= $(CORE_O) $(LIB_O) $(LUA_O) $(LUAC_O)
-ALL_T= $(LUA_A) $(LUA_T) $(LUAC_T)
-ALL_A= $(LUA_A)
-
-default: $(PLAT)
-
-all:	$(ALL_T)
-
-o:	$(ALL_O)
-
-a:	$(ALL_A)
-
-$(LUA_A): $(CORE_O) $(LIB_O)
-	$(AR) $@ $(CORE_O) $(LIB_O)	# DLL needs all object files
-	$(RANLIB) $@
-
-$(LUA_T): $(LUA_O) $(LUA_A)
-	$(CC) -o $@ $(MYLDFLAGS) $(LUA_O) $(LUA_A) $(LIBS)
-
-$(LUAC_T): $(LUAC_O) $(LUA_A)
-	$(CC) -o $@ $(MYLDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS)
-
-clean:
-	$(RM) $(ALL_T) $(ALL_O)
-
-depend:
-	@$(CC) $(CFLAGS) -MM l*.c print.c
-
-echo:
-	@echo "PLAT = $(PLAT)"
-	@echo "CC = $(CC)"
-	@echo "CFLAGS = $(CFLAGS)"
-	@echo "AR = $(AR)"
-	@echo "RANLIB = $(RANLIB)"
-	@echo "RM = $(RM)"
-	@echo "MYCFLAGS = $(MYCFLAGS)"
-	@echo "MYLDFLAGS = $(MYLDFLAGS)"
-	@echo "MYLIBS = $(MYLIBS)"
-
-# convenience targets for popular platforms
-
-none:
-	@echo "Please choose a platform:"
-	@echo "   $(PLATS)"
-
-aix:
-	$(MAKE) all CC="xlc" CFLAGS="-O2 -DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-ldl" MYLDFLAGS="-brtl -bexpall"
-
-ansi:
-	$(MAKE) all MYCFLAGS=-DLUA_ANSI
-
-bsd:
-	$(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-Wl,-E"
-
-freebsd:
-	$(MAKE) all MYCFLAGS="-DLUA_USE_LINUX" MYLIBS="-Wl,-E -lreadline"
-
-generic:
-	$(MAKE) all MYCFLAGS=
-
-linux:
-	$(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS="-Wl,-E -ldl -lreadline -lhistory -lncurses"
-
-macosx:
-	$(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS="-lreadline"
-# use this on Mac OS X 10.3-
-#	$(MAKE) all MYCFLAGS=-DLUA_USE_MACOSX
-
-mingw:
-	$(MAKE) "LUA_A=lua51.dll" "LUA_T=lua.exe" \
-	"AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
-	"MYCFLAGS=-DLUA_BUILD_AS_DLL" "MYLIBS=" "MYLDFLAGS=-s" lua.exe
-	$(MAKE) "LUAC_T=luac.exe" luac.exe
-
-posix:
-	$(MAKE) all MYCFLAGS=-DLUA_USE_POSIX
-
-solaris:
-	$(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-ldl"
-
-# list targets that do not create files (but not all makes understand .PHONY)
-.PHONY: all $(PLATS) default o a clean depend echo none
-
-# DO NOT DELETE
-
-lapi.o: lapi.c lua.h luaconf.h lapi.h lobject.h llimits.h ldebug.h \
-  lstate.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h \
-  lundump.h lvm.h
-lauxlib.o: lauxlib.c lua.h luaconf.h lauxlib.h
-lbaselib.o: lbaselib.c lua.h luaconf.h lauxlib.h lualib.h
-lcode.o: lcode.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
-  lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h lgc.h \
-  ltable.h
-ldblib.o: ldblib.c lua.h luaconf.h lauxlib.h lualib.h
-ldebug.o: ldebug.c lua.h luaconf.h lapi.h lobject.h llimits.h lcode.h \
-  llex.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h \
-  lfunc.h lstring.h lgc.h ltable.h lvm.h
-ldo.o: ldo.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
-  lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lparser.h lstring.h \
-  ltable.h lundump.h lvm.h
-ldump.o: ldump.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h \
-  lzio.h lmem.h lundump.h
-lfunc.o: lfunc.c lua.h luaconf.h lfunc.h lobject.h llimits.h lgc.h lmem.h \
-  lstate.h ltm.h lzio.h
-lgc.o: lgc.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
-  lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h
-linit.o: linit.c lua.h luaconf.h lualib.h lauxlib.h
-liolib.o: liolib.c lua.h luaconf.h lauxlib.h lualib.h
-llex.o: llex.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h ltm.h \
-  lzio.h lmem.h llex.h lparser.h lstring.h lgc.h ltable.h
-lmathlib.o: lmathlib.c lua.h luaconf.h lauxlib.h lualib.h
-lmem.o: lmem.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
-  ltm.h lzio.h lmem.h ldo.h
-loadlib.o: loadlib.c lua.h luaconf.h lauxlib.h lualib.h
-lobject.o: lobject.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h \
-  ltm.h lzio.h lmem.h lstring.h lgc.h lvm.h
-lopcodes.o: lopcodes.c lopcodes.h llimits.h lua.h luaconf.h
-loslib.o: loslib.c lua.h luaconf.h lauxlib.h lualib.h
-lparser.o: lparser.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
-  lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h \
-  lfunc.h lstring.h lgc.h ltable.h
-lstate.o: lstate.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
-  ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h llex.h lstring.h ltable.h
-lstring.o: lstring.c lua.h luaconf.h lmem.h llimits.h lobject.h lstate.h \
-  ltm.h lzio.h lstring.h lgc.h
-lstrlib.o: lstrlib.c lua.h luaconf.h lauxlib.h lualib.h
-ltable.o: ltable.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
-  ltm.h lzio.h lmem.h ldo.h lgc.h ltable.h
-ltablib.o: ltablib.c lua.h luaconf.h lauxlib.h lualib.h
-ltm.o: ltm.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h lzio.h \
-  lmem.h lstring.h lgc.h ltable.h
-lua.o: lua.c lua.h luaconf.h lauxlib.h lualib.h
-luac.o: luac.c lua.h luaconf.h lauxlib.h ldo.h lobject.h llimits.h \
-  lstate.h ltm.h lzio.h lmem.h lfunc.h lopcodes.h lstring.h lgc.h \
-  lundump.h
-lundump.o: lundump.c lua.h luaconf.h ldebug.h lstate.h lobject.h \
-  llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lstring.h lgc.h lundump.h
-lvm.o: lvm.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
-  lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h ltable.h lvm.h
-lzio.o: lzio.c lua.h luaconf.h llimits.h lmem.h lstate.h lobject.h ltm.h \
-  lzio.h
-print.o: print.c ldebug.h lstate.h lua.h luaconf.h lobject.h llimits.h \
-  ltm.h lzio.h lmem.h lopcodes.h lundump.h
-
-# (end of Makefile)
diff --git a/extern/lua-5.1.5/src/lapi.c b/extern/lua-5.1.5/src/lapi.c
deleted file mode 100644
index 5d5145d2..00000000
--- a/extern/lua-5.1.5/src/lapi.c
+++ /dev/null
@@ -1,1087 +0,0 @@
-/*
-** $Id: lapi.c,v 2.55.1.5 2008/07/04 18:41:18 roberto Exp $
-** Lua API
-** See Copyright Notice in lua.h
-*/
-
-
-#include <assert.h>
-#include <math.h>
-#include <stdarg.h>
-#include <string.h>
-
-#define lapi_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lapi.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-#include "lundump.h"
-#include "lvm.h"
-
-
-
-const char lua_ident[] =
-  "$Lua: " LUA_RELEASE " " LUA_COPYRIGHT " $\n"
-  "$Authors: " LUA_AUTHORS " $\n"
-  "$URL: www.lua.org $\n";
-
-
-
-#define api_checknelems(L, n)	api_check(L, (n) <= (L->top - L->base))
-
-#define api_checkvalidindex(L, i)	api_check(L, (i) != luaO_nilobject)
-
-#define api_incr_top(L)   {api_check(L, L->top < L->ci->top); L->top++;}
-
-
-
-static TValue *index2adr (lua_State *L, int idx) {
-  if (idx > 0) {
-    TValue *o = L->base + (idx - 1);
-    api_check(L, idx <= L->ci->top - L->base);
-    if (o >= L->top) return cast(TValue *, luaO_nilobject);
-    else return o;
-  }
-  else if (idx > LUA_REGISTRYINDEX) {
-    api_check(L, idx != 0 && -idx <= L->top - L->base);
-    return L->top + idx;
-  }
-  else switch (idx) {  /* pseudo-indices */
-    case LUA_REGISTRYINDEX: return registry(L);
-    case LUA_ENVIRONINDEX: {
-      Closure *func = curr_func(L);
-      sethvalue(L, &L->env, func->c.env);
-      return &L->env;
-    }
-    case LUA_GLOBALSINDEX: return gt(L);
-    default: {
-      Closure *func = curr_func(L);
-      idx = LUA_GLOBALSINDEX - idx;
-      return (idx <= func->c.nupvalues)
-                ? &func->c.upvalue[idx-1]
-                : cast(TValue *, luaO_nilobject);
-    }
-  }
-}
-
-
-static Table *getcurrenv (lua_State *L) {
-  if (L->ci == L->base_ci)  /* no enclosing function? */
-    return hvalue(gt(L));  /* use global table as environment */
-  else {
-    Closure *func = curr_func(L);
-    return func->c.env;
-  }
-}
-
-
-void luaA_pushobject (lua_State *L, const TValue *o) {
-  setobj2s(L, L->top, o);
-  api_incr_top(L);
-}
-
-
-LUA_API int lua_checkstack (lua_State *L, int size) {
-  int res = 1;
-  lua_lock(L);
-  if (size > LUAI_MAXCSTACK || (L->top - L->base + size) > LUAI_MAXCSTACK)
-    res = 0;  /* stack overflow */
-  else if (size > 0) {
-    luaD_checkstack(L, size);
-    if (L->ci->top < L->top + size)
-      L->ci->top = L->top + size;
-  }
-  lua_unlock(L);
-  return res;
-}
-
-
-LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
-  int i;
-  if (from == to) return;
-  lua_lock(to);
-  api_checknelems(from, n);
-  api_check(from, G(from) == G(to));
-  api_check(from, to->ci->top - to->top >= n);
-  from->top -= n;
-  for (i = 0; i < n; i++) {
-    setobj2s(to, to->top++, from->top + i);
-  }
-  lua_unlock(to);
-}
-
-
-LUA_API void lua_setlevel (lua_State *from, lua_State *to) {
-  to->nCcalls = from->nCcalls;
-}
-
-
-LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {
-  lua_CFunction old;
-  lua_lock(L);
-  old = G(L)->panic;
-  G(L)->panic = panicf;
-  lua_unlock(L);
-  return old;
-}
-
-
-LUA_API lua_State *lua_newthread (lua_State *L) {
-  lua_State *L1;
-  lua_lock(L);
-  luaC_checkGC(L);
-  L1 = luaE_newthread(L);
-  setthvalue(L, L->top, L1);
-  api_incr_top(L);
-  lua_unlock(L);
-  luai_userstatethread(L, L1);
-  return L1;
-}
-
-
-
-/*
-** basic stack manipulation
-*/
-
-
-LUA_API int lua_gettop (lua_State *L) {
-  return cast_int(L->top - L->base);
-}
-
-
-LUA_API void lua_settop (lua_State *L, int idx) {
-  lua_lock(L);
-  if (idx >= 0) {
-    api_check(L, idx <= L->stack_last - L->base);
-    while (L->top < L->base + idx)
-      setnilvalue(L->top++);
-    L->top = L->base + idx;
-  }
-  else {
-    api_check(L, -(idx+1) <= (L->top - L->base));
-    L->top += idx+1;  /* `subtract' index (index is negative) */
-  }
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_remove (lua_State *L, int idx) {
-  StkId p;
-  lua_lock(L);
-  p = index2adr(L, idx);
-  api_checkvalidindex(L, p);
-  while (++p < L->top) setobjs2s(L, p-1, p);
-  L->top--;
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_insert (lua_State *L, int idx) {
-  StkId p;
-  StkId q;
-  lua_lock(L);
-  p = index2adr(L, idx);
-  api_checkvalidindex(L, p);
-  for (q = L->top; q>p; q--) setobjs2s(L, q, q-1);
-  setobjs2s(L, p, L->top);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_replace (lua_State *L, int idx) {
-  StkId o;
-  lua_lock(L);
-  /* explicit test for incompatible code */
-  if (idx == LUA_ENVIRONINDEX && L->ci == L->base_ci)
-    luaG_runerror(L, "no calling environment");
-  api_checknelems(L, 1);
-  o = index2adr(L, idx);
-  api_checkvalidindex(L, o);
-  if (idx == LUA_ENVIRONINDEX) {
-    Closure *func = curr_func(L);
-    api_check(L, ttistable(L->top - 1)); 
-    func->c.env = hvalue(L->top - 1);
-    luaC_barrier(L, func, L->top - 1);
-  }
-  else {
-    setobj(L, o, L->top - 1);
-    if (idx < LUA_GLOBALSINDEX)  /* function upvalue? */
-      luaC_barrier(L, curr_func(L), L->top - 1);
-  }
-  L->top--;
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushvalue (lua_State *L, int idx) {
-  lua_lock(L);
-  setobj2s(L, L->top, index2adr(L, idx));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-
-/*
-** access functions (stack -> C)
-*/
-
-
-LUA_API int lua_type (lua_State *L, int idx) {
-  StkId o = index2adr(L, idx);
-  return (o == luaO_nilobject) ? LUA_TNONE : ttype(o);
-}
-
-
-LUA_API const char *lua_typename (lua_State *L, int t) {
-  UNUSED(L);
-  return (t == LUA_TNONE) ? "no value" : luaT_typenames[t];
-}
-
-
-LUA_API int lua_iscfunction (lua_State *L, int idx) {
-  StkId o = index2adr(L, idx);
-  return iscfunction(o);
-}
-
-
-LUA_API int lua_isnumber (lua_State *L, int idx) {
-  TValue n;
-  const TValue *o = index2adr(L, idx);
-  return tonumber(o, &n);
-}
-
-
-LUA_API int lua_isstring (lua_State *L, int idx) {
-  int t = lua_type(L, idx);
-  return (t == LUA_TSTRING || t == LUA_TNUMBER);
-}
-
-
-LUA_API int lua_isuserdata (lua_State *L, int idx) {
-  const TValue *o = index2adr(L, idx);
-  return (ttisuserdata(o) || ttislightuserdata(o));
-}
-
-
-LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
-  StkId o1 = index2adr(L, index1);
-  StkId o2 = index2adr(L, index2);
-  return (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
-         : luaO_rawequalObj(o1, o2);
-}
-
-
-LUA_API int lua_equal (lua_State *L, int index1, int index2) {
-  StkId o1, o2;
-  int i;
-  lua_lock(L);  /* may call tag method */
-  o1 = index2adr(L, index1);
-  o2 = index2adr(L, index2);
-  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0 : equalobj(L, o1, o2);
-  lua_unlock(L);
-  return i;
-}
-
-
-LUA_API int lua_lessthan (lua_State *L, int index1, int index2) {
-  StkId o1, o2;
-  int i;
-  lua_lock(L);  /* may call tag method */
-  o1 = index2adr(L, index1);
-  o2 = index2adr(L, index2);
-  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
-       : luaV_lessthan(L, o1, o2);
-  lua_unlock(L);
-  return i;
-}
-
-
-
-LUA_API lua_Number lua_tonumber (lua_State *L, int idx) {
-  TValue n;
-  const TValue *o = index2adr(L, idx);
-  if (tonumber(o, &n))
-    return nvalue(o);
-  else
-    return 0;
-}
-
-
-LUA_API lua_Integer lua_tointeger (lua_State *L, int idx) {
-  TValue n;
-  const TValue *o = index2adr(L, idx);
-  if (tonumber(o, &n)) {
-    lua_Integer res;
-    lua_Number num = nvalue(o);
-    lua_number2integer(res, num);
-    return res;
-  }
-  else
-    return 0;
-}
-
-
-LUA_API int lua_toboolean (lua_State *L, int idx) {
-  const TValue *o = index2adr(L, idx);
-  return !l_isfalse(o);
-}
-
-
-LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {
-  StkId o = index2adr(L, idx);
-  if (!ttisstring(o)) {
-    lua_lock(L);  /* `luaV_tostring' may create a new string */
-    if (!luaV_tostring(L, o)) {  /* conversion failed? */
-      if (len != NULL) *len = 0;
-      lua_unlock(L);
-      return NULL;
-    }
-    luaC_checkGC(L);
-    o = index2adr(L, idx);  /* previous call may reallocate the stack */
-    lua_unlock(L);
-  }
-  if (len != NULL) *len = tsvalue(o)->len;
-  return svalue(o);
-}
-
-
-LUA_API size_t lua_objlen (lua_State *L, int idx) {
-  StkId o = index2adr(L, idx);
-  switch (ttype(o)) {
-    case LUA_TSTRING: return tsvalue(o)->len;
-    case LUA_TUSERDATA: return uvalue(o)->len;
-    case LUA_TTABLE: return luaH_getn(hvalue(o));
-    case LUA_TNUMBER: {
-      size_t l;
-      lua_lock(L);  /* `luaV_tostring' may create a new string */
-      l = (luaV_tostring(L, o) ? tsvalue(o)->len : 0);
-      lua_unlock(L);
-      return l;
-    }
-    default: return 0;
-  }
-}
-
-
-LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {
-  StkId o = index2adr(L, idx);
-  return (!iscfunction(o)) ? NULL : clvalue(o)->c.f;
-}
-
-
-LUA_API void *lua_touserdata (lua_State *L, int idx) {
-  StkId o = index2adr(L, idx);
-  switch (ttype(o)) {
-    case LUA_TUSERDATA: return (rawuvalue(o) + 1);
-    case LUA_TLIGHTUSERDATA: return pvalue(o);
-    default: return NULL;
-  }
-}
-
-
-LUA_API lua_State *lua_tothread (lua_State *L, int idx) {
-  StkId o = index2adr(L, idx);
-  return (!ttisthread(o)) ? NULL : thvalue(o);
-}
-
-
-LUA_API const void *lua_topointer (lua_State *L, int idx) {
-  StkId o = index2adr(L, idx);
-  switch (ttype(o)) {
-    case LUA_TTABLE: return hvalue(o);
-    case LUA_TFUNCTION: return clvalue(o);
-    case LUA_TTHREAD: return thvalue(o);
-    case LUA_TUSERDATA:
-    case LUA_TLIGHTUSERDATA:
-      return lua_touserdata(L, idx);
-    default: return NULL;
-  }
-}
-
-
-
-/*
-** push functions (C -> stack)
-*/
-
-
-LUA_API void lua_pushnil (lua_State *L) {
-  lua_lock(L);
-  setnilvalue(L->top);
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
-  lua_lock(L);
-  setnvalue(L->top, n);
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {
-  lua_lock(L);
-  setnvalue(L->top, cast_num(n));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
-  lua_lock(L);
-  luaC_checkGC(L);
-  setsvalue2s(L, L->top, luaS_newlstr(L, s, len));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushstring (lua_State *L, const char *s) {
-  if (s == NULL)
-    lua_pushnil(L);
-  else
-    lua_pushlstring(L, s, strlen(s));
-}
-
-
-LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,
-                                      va_list argp) {
-  const char *ret;
-  lua_lock(L);
-  luaC_checkGC(L);
-  ret = luaO_pushvfstring(L, fmt, argp);
-  lua_unlock(L);
-  return ret;
-}
-
-
-LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) {
-  const char *ret;
-  va_list argp;
-  lua_lock(L);
-  luaC_checkGC(L);
-  va_start(argp, fmt);
-  ret = luaO_pushvfstring(L, fmt, argp);
-  va_end(argp);
-  lua_unlock(L);
-  return ret;
-}
-
-
-LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
-  Closure *cl;
-  lua_lock(L);
-  luaC_checkGC(L);
-  api_checknelems(L, n);
-  cl = luaF_newCclosure(L, n, getcurrenv(L));
-  cl->c.f = fn;
-  L->top -= n;
-  while (n--)
-    setobj2n(L, &cl->c.upvalue[n], L->top+n);
-  setclvalue(L, L->top, cl);
-  lua_assert(iswhite(obj2gco(cl)));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushboolean (lua_State *L, int b) {
-  lua_lock(L);
-  setbvalue(L->top, (b != 0));  /* ensure that true is 1 */
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushlightuserdata (lua_State *L, void *p) {
-  lua_lock(L);
-  setpvalue(L->top, p);
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API int lua_pushthread (lua_State *L) {
-  lua_lock(L);
-  setthvalue(L, L->top, L);
-  api_incr_top(L);
-  lua_unlock(L);
-  return (G(L)->mainthread == L);
-}
-
-
-
-/*
-** get functions (Lua -> stack)
-*/
-
-
-LUA_API void lua_gettable (lua_State *L, int idx) {
-  StkId t;
-  lua_lock(L);
-  t = index2adr(L, idx);
-  api_checkvalidindex(L, t);
-  luaV_gettable(L, t, L->top - 1, L->top - 1);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
-  StkId t;
-  TValue key;
-  lua_lock(L);
-  t = index2adr(L, idx);
-  api_checkvalidindex(L, t);
-  setsvalue(L, &key, luaS_new(L, k));
-  luaV_gettable(L, t, &key, L->top);
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_rawget (lua_State *L, int idx) {
-  StkId t;
-  lua_lock(L);
-  t = index2adr(L, idx);
-  api_check(L, ttistable(t));
-  setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_rawgeti (lua_State *L, int idx, int n) {
-  StkId o;
-  lua_lock(L);
-  o = index2adr(L, idx);
-  api_check(L, ttistable(o));
-  setobj2s(L, L->top, luaH_getnum(hvalue(o), n));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {
-  lua_lock(L);
-  luaC_checkGC(L);
-  sethvalue(L, L->top, luaH_new(L, narray, nrec));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API int lua_getmetatable (lua_State *L, int objindex) {
-  const TValue *obj;
-  Table *mt = NULL;
-  int res;
-  lua_lock(L);
-  obj = index2adr(L, objindex);
-  switch (ttype(obj)) {
-    case LUA_TTABLE:
-      mt = hvalue(obj)->metatable;
-      break;
-    case LUA_TUSERDATA:
-      mt = uvalue(obj)->metatable;
-      break;
-    default:
-      mt = G(L)->mt[ttype(obj)];
-      break;
-  }
-  if (mt == NULL)
-    res = 0;
-  else {
-    sethvalue(L, L->top, mt);
-    api_incr_top(L);
-    res = 1;
-  }
-  lua_unlock(L);
-  return res;
-}
-
-
-LUA_API void lua_getfenv (lua_State *L, int idx) {
-  StkId o;
-  lua_lock(L);
-  o = index2adr(L, idx);
-  api_checkvalidindex(L, o);
-  switch (ttype(o)) {
-    case LUA_TFUNCTION:
-      sethvalue(L, L->top, clvalue(o)->c.env);
-      break;
-    case LUA_TUSERDATA:
-      sethvalue(L, L->top, uvalue(o)->env);
-      break;
-    case LUA_TTHREAD:
-      setobj2s(L, L->top,  gt(thvalue(o)));
-      break;
-    default:
-      setnilvalue(L->top);
-      break;
-  }
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-/*
-** set functions (stack -> Lua)
-*/
-
-
-LUA_API void lua_settable (lua_State *L, int idx) {
-  StkId t;
-  lua_lock(L);
-  api_checknelems(L, 2);
-  t = index2adr(L, idx);
-  api_checkvalidindex(L, t);
-  luaV_settable(L, t, L->top - 2, L->top - 1);
-  L->top -= 2;  /* pop index and value */
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
-  StkId t;
-  TValue key;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  t = index2adr(L, idx);
-  api_checkvalidindex(L, t);
-  setsvalue(L, &key, luaS_new(L, k));
-  luaV_settable(L, t, &key, L->top - 1);
-  L->top--;  /* pop value */
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_rawset (lua_State *L, int idx) {
-  StkId t;
-  lua_lock(L);
-  api_checknelems(L, 2);
-  t = index2adr(L, idx);
-  api_check(L, ttistable(t));
-  setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);
-  luaC_barriert(L, hvalue(t), L->top-1);
-  L->top -= 2;
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_rawseti (lua_State *L, int idx, int n) {
-  StkId o;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  o = index2adr(L, idx);
-  api_check(L, ttistable(o));
-  setobj2t(L, luaH_setnum(L, hvalue(o), n), L->top-1);
-  luaC_barriert(L, hvalue(o), L->top-1);
-  L->top--;
-  lua_unlock(L);
-}
-
-
-LUA_API int lua_setmetatable (lua_State *L, int objindex) {
-  TValue *obj;
-  Table *mt;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  obj = index2adr(L, objindex);
-  api_checkvalidindex(L, obj);
-  if (ttisnil(L->top - 1))
-    mt = NULL;
-  else {
-    api_check(L, ttistable(L->top - 1));
-    mt = hvalue(L->top - 1);
-  }
-  switch (ttype(obj)) {
-    case LUA_TTABLE: {
-      hvalue(obj)->metatable = mt;
-      if (mt)
-        luaC_objbarriert(L, hvalue(obj), mt);
-      break;
-    }
-    case LUA_TUSERDATA: {
-      uvalue(obj)->metatable = mt;
-      if (mt)
-        luaC_objbarrier(L, rawuvalue(obj), mt);
-      break;
-    }
-    default: {
-      G(L)->mt[ttype(obj)] = mt;
-      break;
-    }
-  }
-  L->top--;
-  lua_unlock(L);
-  return 1;
-}
-
-
-LUA_API int lua_setfenv (lua_State *L, int idx) {
-  StkId o;
-  int res = 1;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  o = index2adr(L, idx);
-  api_checkvalidindex(L, o);
-  api_check(L, ttistable(L->top - 1));
-  switch (ttype(o)) {
-    case LUA_TFUNCTION:
-      clvalue(o)->c.env = hvalue(L->top - 1);
-      break;
-    case LUA_TUSERDATA:
-      uvalue(o)->env = hvalue(L->top - 1);
-      break;
-    case LUA_TTHREAD:
-      sethvalue(L, gt(thvalue(o)), hvalue(L->top - 1));
-      break;
-    default:
-      res = 0;
-      break;
-  }
-  if (res) luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1));
-  L->top--;
-  lua_unlock(L);
-  return res;
-}
-
-
-/*
-** `load' and `call' functions (run Lua code)
-*/
-
-
-#define adjustresults(L,nres) \
-    { if (nres == LUA_MULTRET && L->top >= L->ci->top) L->ci->top = L->top; }
-
-
-#define checkresults(L,na,nr) \
-     api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)))
-	
-
-LUA_API void lua_call (lua_State *L, int nargs, int nresults) {
-  StkId func;
-  lua_lock(L);
-  api_checknelems(L, nargs+1);
-  checkresults(L, nargs, nresults);
-  func = L->top - (nargs+1);
-  luaD_call(L, func, nresults);
-  adjustresults(L, nresults);
-  lua_unlock(L);
-}
-
-
-
-/*
-** Execute a protected call.
-*/
-struct CallS {  /* data to `f_call' */
-  StkId func;
-  int nresults;
-};
-
-
-static void f_call (lua_State *L, void *ud) {
-  struct CallS *c = cast(struct CallS *, ud);
-  luaD_call(L, c->func, c->nresults);
-}
-
-
-
-LUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc) {
-  struct CallS c;
-  int status;
-  ptrdiff_t func;
-  lua_lock(L);
-  api_checknelems(L, nargs+1);
-  checkresults(L, nargs, nresults);
-  if (errfunc == 0)
-    func = 0;
-  else {
-    StkId o = index2adr(L, errfunc);
-    api_checkvalidindex(L, o);
-    func = savestack(L, o);
-  }
-  c.func = L->top - (nargs+1);  /* function to be called */
-  c.nresults = nresults;
-  status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
-  adjustresults(L, nresults);
-  lua_unlock(L);
-  return status;
-}
-
-
-/*
-** Execute a protected C call.
-*/
-struct CCallS {  /* data to `f_Ccall' */
-  lua_CFunction func;
-  void *ud;
-};
-
-
-static void f_Ccall (lua_State *L, void *ud) {
-  struct CCallS *c = cast(struct CCallS *, ud);
-  Closure *cl;
-  cl = luaF_newCclosure(L, 0, getcurrenv(L));
-  cl->c.f = c->func;
-  setclvalue(L, L->top, cl);  /* push function */
-  api_incr_top(L);
-  setpvalue(L->top, c->ud);  /* push only argument */
-  api_incr_top(L);
-  luaD_call(L, L->top - 2, 0);
-}
-
-
-LUA_API int lua_cpcall (lua_State *L, lua_CFunction func, void *ud) {
-  struct CCallS c;
-  int status;
-  lua_lock(L);
-  c.func = func;
-  c.ud = ud;
-  status = luaD_pcall(L, f_Ccall, &c, savestack(L, L->top), 0);
-  lua_unlock(L);
-  return status;
-}
-
-
-LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data,
-                      const char *chunkname) {
-  ZIO z;
-  int status;
-  lua_lock(L);
-  if (!chunkname) chunkname = "?";
-  luaZ_init(L, &z, reader, data);
-  status = luaD_protectedparser(L, &z, chunkname);
-  lua_unlock(L);
-  return status;
-}
-
-
-LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) {
-  int status;
-  TValue *o;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  o = L->top - 1;
-  if (isLfunction(o))
-    status = luaU_dump(L, clvalue(o)->l.p, writer, data, 0);
-  else
-    status = 1;
-  lua_unlock(L);
-  return status;
-}
-
-
-LUA_API int  lua_status (lua_State *L) {
-  return L->status;
-}
-
-
-/*
-** Garbage-collection function
-*/
-
-LUA_API int lua_gc (lua_State *L, int what, int data) {
-  int res = 0;
-  global_State *g;
-  lua_lock(L);
-  g = G(L);
-  switch (what) {
-    case LUA_GCSTOP: {
-      g->GCthreshold = MAX_LUMEM;
-      break;
-    }
-    case LUA_GCRESTART: {
-      g->GCthreshold = g->totalbytes;
-      break;
-    }
-    case LUA_GCCOLLECT: {
-      luaC_fullgc(L);
-      break;
-    }
-    case LUA_GCCOUNT: {
-      /* GC values are expressed in Kbytes: #bytes/2^10 */
-      res = cast_int(g->totalbytes >> 10);
-      break;
-    }
-    case LUA_GCCOUNTB: {
-      res = cast_int(g->totalbytes & 0x3ff);
-      break;
-    }
-    case LUA_GCSTEP: {
-      lu_mem a = (cast(lu_mem, data) << 10);
-      if (a <= g->totalbytes)
-        g->GCthreshold = g->totalbytes - a;
-      else
-        g->GCthreshold = 0;
-      while (g->GCthreshold <= g->totalbytes) {
-        luaC_step(L);
-        if (g->gcstate == GCSpause) {  /* end of cycle? */
-          res = 1;  /* signal it */
-          break;
-        }
-      }
-      break;
-    }
-    case LUA_GCSETPAUSE: {
-      res = g->gcpause;
-      g->gcpause = data;
-      break;
-    }
-    case LUA_GCSETSTEPMUL: {
-      res = g->gcstepmul;
-      g->gcstepmul = data;
-      break;
-    }
-    default: res = -1;  /* invalid option */
-  }
-  lua_unlock(L);
-  return res;
-}
-
-
-
-/*
-** miscellaneous functions
-*/
-
-
-LUA_API int lua_error (lua_State *L) {
-  lua_lock(L);
-  api_checknelems(L, 1);
-  luaG_errormsg(L);
-  lua_unlock(L);
-  return 0;  /* to avoid warnings */
-}
-
-
-LUA_API int lua_next (lua_State *L, int idx) {
-  StkId t;
-  int more;
-  lua_lock(L);
-  t = index2adr(L, idx);
-  api_check(L, ttistable(t));
-  more = luaH_next(L, hvalue(t), L->top - 1);
-  if (more) {
-    api_incr_top(L);
-  }
-  else  /* no more elements */
-    L->top -= 1;  /* remove key */
-  lua_unlock(L);
-  return more;
-}
-
-
-LUA_API void lua_concat (lua_State *L, int n) {
-  lua_lock(L);
-  api_checknelems(L, n);
-  if (n >= 2) {
-    luaC_checkGC(L);
-    luaV_concat(L, n, cast_int(L->top - L->base) - 1);
-    L->top -= (n-1);
-  }
-  else if (n == 0) {  /* push empty string */
-    setsvalue2s(L, L->top, luaS_newlstr(L, "", 0));
-    api_incr_top(L);
-  }
-  /* else n == 1; nothing to do */
-  lua_unlock(L);
-}
-
-
-LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) {
-  lua_Alloc f;
-  lua_lock(L);
-  if (ud) *ud = G(L)->ud;
-  f = G(L)->frealloc;
-  lua_unlock(L);
-  return f;
-}
-
-
-LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud) {
-  lua_lock(L);
-  G(L)->ud = ud;
-  G(L)->frealloc = f;
-  lua_unlock(L);
-}
-
-
-LUA_API void *lua_newuserdata (lua_State *L, size_t size) {
-  Udata *u;
-  lua_lock(L);
-  luaC_checkGC(L);
-  u = luaS_newudata(L, size, getcurrenv(L));
-  setuvalue(L, L->top, u);
-  api_incr_top(L);
-  lua_unlock(L);
-  return u + 1;
-}
-
-
-
-
-static const char *aux_upvalue (StkId fi, int n, TValue **val) {
-  Closure *f;
-  if (!ttisfunction(fi)) return NULL;
-  f = clvalue(fi);
-  if (f->c.isC) {
-    if (!(1 <= n && n <= f->c.nupvalues)) return NULL;
-    *val = &f->c.upvalue[n-1];
-    return "";
-  }
-  else {
-    Proto *p = f->l.p;
-    if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
-    *val = f->l.upvals[n-1]->v;
-    return getstr(p->upvalues[n-1]);
-  }
-}
-
-
-LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {
-  const char *name;
-  TValue *val;
-  lua_lock(L);
-  name = aux_upvalue(index2adr(L, funcindex), n, &val);
-  if (name) {
-    setobj2s(L, L->top, val);
-    api_incr_top(L);
-  }
-  lua_unlock(L);
-  return name;
-}
-
-
-LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
-  const char *name;
-  TValue *val;
-  StkId fi;
-  lua_lock(L);
-  fi = index2adr(L, funcindex);
-  api_checknelems(L, 1);
-  name = aux_upvalue(fi, n, &val);
-  if (name) {
-    L->top--;
-    setobj(L, val, L->top);
-    luaC_barrier(L, clvalue(fi), L->top);
-  }
-  lua_unlock(L);
-  return name;
-}
-
diff --git a/extern/lua-5.1.5/src/lapi.h b/extern/lua-5.1.5/src/lapi.h
deleted file mode 100644
index 2c3fab24..00000000
--- a/extern/lua-5.1.5/src/lapi.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
-** $Id: lapi.h,v 2.2.1.1 2007/12/27 13:02:25 roberto Exp $
-** Auxiliary functions from Lua API
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lapi_h
-#define lapi_h
-
-
-#include "lobject.h"
-
-
-LUAI_FUNC void luaA_pushobject (lua_State *L, const TValue *o);
-
-#endif
diff --git a/extern/lua-5.1.5/src/lauxlib.c b/extern/lua-5.1.5/src/lauxlib.c
deleted file mode 100644
index 10f14e2c..00000000
--- a/extern/lua-5.1.5/src/lauxlib.c
+++ /dev/null
@@ -1,652 +0,0 @@
-/*
-** $Id: lauxlib.c,v 1.159.1.3 2008/01/21 13:20:51 roberto Exp $
-** Auxiliary functions for building Lua libraries
-** See Copyright Notice in lua.h
-*/
-
-
-#include <ctype.h>
-#include <errno.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-
-/* This file uses only the official API of Lua.
-** Any function declared here could be written as an application function.
-*/
-
-#define lauxlib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-
-
-#define FREELIST_REF	0	/* free list of references */
-
-
-/* convert a stack index to positive */
-#define abs_index(L, i)		((i) > 0 || (i) <= LUA_REGISTRYINDEX ? (i) : \
-					lua_gettop(L) + (i) + 1)
-
-
-/*
-** {======================================================
-** Error-report functions
-** =======================================================
-*/
-
-
-LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
-  lua_Debug ar;
-  if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
-    return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);
-  lua_getinfo(L, "n", &ar);
-  if (strcmp(ar.namewhat, "method") == 0) {
-    narg--;  /* do not count `self' */
-    if (narg == 0)  /* error is in the self argument itself? */
-      return luaL_error(L, "calling " LUA_QS " on bad self (%s)",
-                           ar.name, extramsg);
-  }
-  if (ar.name == NULL)
-    ar.name = "?";
-  return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)",
-                        narg, ar.name, extramsg);
-}
-
-
-LUALIB_API int luaL_typerror (lua_State *L, int narg, const char *tname) {
-  const char *msg = lua_pushfstring(L, "%s expected, got %s",
-                                    tname, luaL_typename(L, narg));
-  return luaL_argerror(L, narg, msg);
-}
-
-
-static void tag_error (lua_State *L, int narg, int tag) {
-  luaL_typerror(L, narg, lua_typename(L, tag));
-}
-
-
-LUALIB_API void luaL_where (lua_State *L, int level) {
-  lua_Debug ar;
-  if (lua_getstack(L, level, &ar)) {  /* check function at level */
-    lua_getinfo(L, "Sl", &ar);  /* get info about it */
-    if (ar.currentline > 0) {  /* is there info? */
-      lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.currentline);
-      return;
-    }
-  }
-  lua_pushliteral(L, "");  /* else, no information available... */
-}
-
-
-LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {
-  va_list argp;
-  va_start(argp, fmt);
-  luaL_where(L, 1);
-  lua_pushvfstring(L, fmt, argp);
-  va_end(argp);
-  lua_concat(L, 2);
-  return lua_error(L);
-}
-
-/* }====================================================== */
-
-
-LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def,
-                                 const char *const lst[]) {
-  const char *name = (def) ? luaL_optstring(L, narg, def) :
-                             luaL_checkstring(L, narg);
-  int i;
-  for (i=0; lst[i]; i++)
-    if (strcmp(lst[i], name) == 0)
-      return i;
-  return luaL_argerror(L, narg,
-                       lua_pushfstring(L, "invalid option " LUA_QS, name));
-}
-
-
-LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
-  lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get registry.name */
-  if (!lua_isnil(L, -1))  /* name already in use? */
-    return 0;  /* leave previous value on top, but return 0 */
-  lua_pop(L, 1);
-  lua_newtable(L);  /* create metatable */
-  lua_pushvalue(L, -1);
-  lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
-  return 1;
-}
-
-
-LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {
-  void *p = lua_touserdata(L, ud);
-  if (p != NULL) {  /* value is a userdata? */
-    if (lua_getmetatable(L, ud)) {  /* does it have a metatable? */
-      lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get correct metatable */
-      if (lua_rawequal(L, -1, -2)) {  /* does it have the correct mt? */
-        lua_pop(L, 2);  /* remove both metatables */
-        return p;
-      }
-    }
-  }
-  luaL_typerror(L, ud, tname);  /* else error */
-  return NULL;  /* to avoid warnings */
-}
-
-
-LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *mes) {
-  if (!lua_checkstack(L, space))
-    luaL_error(L, "stack overflow (%s)", mes);
-}
-
-
-LUALIB_API void luaL_checktype (lua_State *L, int narg, int t) {
-  if (lua_type(L, narg) != t)
-    tag_error(L, narg, t);
-}
-
-
-LUALIB_API void luaL_checkany (lua_State *L, int narg) {
-  if (lua_type(L, narg) == LUA_TNONE)
-    luaL_argerror(L, narg, "value expected");
-}
-
-
-LUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) {
-  const char *s = lua_tolstring(L, narg, len);
-  if (!s) tag_error(L, narg, LUA_TSTRING);
-  return s;
-}
-
-
-LUALIB_API const char *luaL_optlstring (lua_State *L, int narg,
-                                        const char *def, size_t *len) {
-  if (lua_isnoneornil(L, narg)) {
-    if (len)
-      *len = (def ? strlen(def) : 0);
-    return def;
-  }
-  else return luaL_checklstring(L, narg, len);
-}
-
-
-LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
-  lua_Number d = lua_tonumber(L, narg);
-  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
-    tag_error(L, narg, LUA_TNUMBER);
-  return d;
-}
-
-
-LUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) {
-  return luaL_opt(L, luaL_checknumber, narg, def);
-}
-
-
-LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {
-  lua_Integer d = lua_tointeger(L, narg);
-  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
-    tag_error(L, narg, LUA_TNUMBER);
-  return d;
-}
-
-
-LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int narg,
-                                                      lua_Integer def) {
-  return luaL_opt(L, luaL_checkinteger, narg, def);
-}
-
-
-LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {
-  if (!lua_getmetatable(L, obj))  /* no metatable? */
-    return 0;
-  lua_pushstring(L, event);
-  lua_rawget(L, -2);
-  if (lua_isnil(L, -1)) {
-    lua_pop(L, 2);  /* remove metatable and metafield */
-    return 0;
-  }
-  else {
-    lua_remove(L, -2);  /* remove only metatable */
-    return 1;
-  }
-}
-
-
-LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
-  obj = abs_index(L, obj);
-  if (!luaL_getmetafield(L, obj, event))  /* no metafield? */
-    return 0;
-  lua_pushvalue(L, obj);
-  lua_call(L, 1, 1);
-  return 1;
-}
-
-
-LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
-                                const luaL_Reg *l) {
-  luaI_openlib(L, libname, l, 0);
-}
-
-
-static int libsize (const luaL_Reg *l) {
-  int size = 0;
-  for (; l->name; l++) size++;
-  return size;
-}
-
-
-LUALIB_API void luaI_openlib (lua_State *L, const char *libname,
-                              const luaL_Reg *l, int nup) {
-  if (libname) {
-    int size = libsize(l);
-    /* check whether lib already exists */
-    luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 1);
-    lua_getfield(L, -1, libname);  /* get _LOADED[libname] */
-    if (!lua_istable(L, -1)) {  /* not found? */
-      lua_pop(L, 1);  /* remove previous result */
-      /* try global variable (and create one if it does not exist) */
-      if (luaL_findtable(L, LUA_GLOBALSINDEX, libname, size) != NULL)
-        luaL_error(L, "name conflict for module " LUA_QS, libname);
-      lua_pushvalue(L, -1);
-      lua_setfield(L, -3, libname);  /* _LOADED[libname] = new table */
-    }
-    lua_remove(L, -2);  /* remove _LOADED table */
-    lua_insert(L, -(nup+1));  /* move library table to below upvalues */
-  }
-  for (; l->name; l++) {
-    int i;
-    for (i=0; i<nup; i++)  /* copy upvalues to the top */
-      lua_pushvalue(L, -nup);
-    lua_pushcclosure(L, l->func, nup);
-    lua_setfield(L, -(nup+2), l->name);
-  }
-  lua_pop(L, nup);  /* remove upvalues */
-}
-
-
-
-/*
-** {======================================================
-** getn-setn: size for arrays
-** =======================================================
-*/
-
-#if defined(LUA_COMPAT_GETN)
-
-static int checkint (lua_State *L, int topop) {
-  int n = (lua_type(L, -1) == LUA_TNUMBER) ? lua_tointeger(L, -1) : -1;
-  lua_pop(L, topop);
-  return n;
-}
-
-
-static void getsizes (lua_State *L) {
-  lua_getfield(L, LUA_REGISTRYINDEX, "LUA_SIZES");
-  if (lua_isnil(L, -1)) {  /* no `size' table? */
-    lua_pop(L, 1);  /* remove nil */
-    lua_newtable(L);  /* create it */
-    lua_pushvalue(L, -1);  /* `size' will be its own metatable */
-    lua_setmetatable(L, -2);
-    lua_pushliteral(L, "kv");
-    lua_setfield(L, -2, "__mode");  /* metatable(N).__mode = "kv" */
-    lua_pushvalue(L, -1);
-    lua_setfield(L, LUA_REGISTRYINDEX, "LUA_SIZES");  /* store in register */
-  }
-}
-
-
-LUALIB_API void luaL_setn (lua_State *L, int t, int n) {
-  t = abs_index(L, t);
-  lua_pushliteral(L, "n");
-  lua_rawget(L, t);
-  if (checkint(L, 1) >= 0) {  /* is there a numeric field `n'? */
-    lua_pushliteral(L, "n");  /* use it */
-    lua_pushinteger(L, n);
-    lua_rawset(L, t);
-  }
-  else {  /* use `sizes' */
-    getsizes(L);
-    lua_pushvalue(L, t);
-    lua_pushinteger(L, n);
-    lua_rawset(L, -3);  /* sizes[t] = n */
-    lua_pop(L, 1);  /* remove `sizes' */
-  }
-}
-
-
-LUALIB_API int luaL_getn (lua_State *L, int t) {
-  int n;
-  t = abs_index(L, t);
-  lua_pushliteral(L, "n");  /* try t.n */
-  lua_rawget(L, t);
-  if ((n = checkint(L, 1)) >= 0) return n;
-  getsizes(L);  /* else try sizes[t] */
-  lua_pushvalue(L, t);
-  lua_rawget(L, -2);
-  if ((n = checkint(L, 2)) >= 0) return n;
-  return (int)lua_objlen(L, t);
-}
-
-#endif
-
-/* }====================================================== */
-
-
-
-LUALIB_API const char *luaL_gsub (lua_State *L, const char *s, const char *p,
-                                                               const char *r) {
-  const char *wild;
-  size_t l = strlen(p);
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  while ((wild = strstr(s, p)) != NULL) {
-    luaL_addlstring(&b, s, wild - s);  /* push prefix */
-    luaL_addstring(&b, r);  /* push replacement in place of pattern */
-    s = wild + l;  /* continue after `p' */
-  }
-  luaL_addstring(&b, s);  /* push last suffix */
-  luaL_pushresult(&b);
-  return lua_tostring(L, -1);
-}
-
-
-LUALIB_API const char *luaL_findtable (lua_State *L, int idx,
-                                       const char *fname, int szhint) {
-  const char *e;
-  lua_pushvalue(L, idx);
-  do {
-    e = strchr(fname, '.');
-    if (e == NULL) e = fname + strlen(fname);
-    lua_pushlstring(L, fname, e - fname);
-    lua_rawget(L, -2);
-    if (lua_isnil(L, -1)) {  /* no such field? */
-      lua_pop(L, 1);  /* remove this nil */
-      lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */
-      lua_pushlstring(L, fname, e - fname);
-      lua_pushvalue(L, -2);
-      lua_settable(L, -4);  /* set new table into field */
-    }
-    else if (!lua_istable(L, -1)) {  /* field has a non-table value? */
-      lua_pop(L, 2);  /* remove table and value */
-      return fname;  /* return problematic part of the name */
-    }
-    lua_remove(L, -2);  /* remove previous table */
-    fname = e + 1;
-  } while (*e == '.');
-  return NULL;
-}
-
-
-
-/*
-** {======================================================
-** Generic Buffer manipulation
-** =======================================================
-*/
-
-
-#define bufflen(B)	((B)->p - (B)->buffer)
-#define bufffree(B)	((size_t)(LUAL_BUFFERSIZE - bufflen(B)))
-
-#define LIMIT	(LUA_MINSTACK/2)
-
-
-static int emptybuffer (luaL_Buffer *B) {
-  size_t l = bufflen(B);
-  if (l == 0) return 0;  /* put nothing on stack */
-  else {
-    lua_pushlstring(B->L, B->buffer, l);
-    B->p = B->buffer;
-    B->lvl++;
-    return 1;
-  }
-}
-
-
-static void adjuststack (luaL_Buffer *B) {
-  if (B->lvl > 1) {
-    lua_State *L = B->L;
-    int toget = 1;  /* number of levels to concat */
-    size_t toplen = lua_strlen(L, -1);
-    do {
-      size_t l = lua_strlen(L, -(toget+1));
-      if (B->lvl - toget + 1 >= LIMIT || toplen > l) {
-        toplen += l;
-        toget++;
-      }
-      else break;
-    } while (toget < B->lvl);
-    lua_concat(L, toget);
-    B->lvl = B->lvl - toget + 1;
-  }
-}
-
-
-LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {
-  if (emptybuffer(B))
-    adjuststack(B);
-  return B->buffer;
-}
-
-
-LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
-  while (l--)
-    luaL_addchar(B, *s++);
-}
-
-
-LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) {
-  luaL_addlstring(B, s, strlen(s));
-}
-
-
-LUALIB_API void luaL_pushresult (luaL_Buffer *B) {
-  emptybuffer(B);
-  lua_concat(B->L, B->lvl);
-  B->lvl = 1;
-}
-
-
-LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
-  lua_State *L = B->L;
-  size_t vl;
-  const char *s = lua_tolstring(L, -1, &vl);
-  if (vl <= bufffree(B)) {  /* fit into buffer? */
-    memcpy(B->p, s, vl);  /* put it there */
-    B->p += vl;
-    lua_pop(L, 1);  /* remove from stack */
-  }
-  else {
-    if (emptybuffer(B))
-      lua_insert(L, -2);  /* put buffer before new value */
-    B->lvl++;  /* add new value into B stack */
-    adjuststack(B);
-  }
-}
-
-
-LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {
-  B->L = L;
-  B->p = B->buffer;
-  B->lvl = 0;
-}
-
-/* }====================================================== */
-
-
-LUALIB_API int luaL_ref (lua_State *L, int t) {
-  int ref;
-  t = abs_index(L, t);
-  if (lua_isnil(L, -1)) {
-    lua_pop(L, 1);  /* remove from stack */
-    return LUA_REFNIL;  /* `nil' has a unique fixed reference */
-  }
-  lua_rawgeti(L, t, FREELIST_REF);  /* get first free element */
-  ref = (int)lua_tointeger(L, -1);  /* ref = t[FREELIST_REF] */
-  lua_pop(L, 1);  /* remove it from stack */
-  if (ref != 0) {  /* any free element? */
-    lua_rawgeti(L, t, ref);  /* remove it from list */
-    lua_rawseti(L, t, FREELIST_REF);  /* (t[FREELIST_REF] = t[ref]) */
-  }
-  else {  /* no free elements */
-    ref = (int)lua_objlen(L, t);
-    ref++;  /* create new reference */
-  }
-  lua_rawseti(L, t, ref);
-  return ref;
-}
-
-
-LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
-  if (ref >= 0) {
-    t = abs_index(L, t);
-    lua_rawgeti(L, t, FREELIST_REF);
-    lua_rawseti(L, t, ref);  /* t[ref] = t[FREELIST_REF] */
-    lua_pushinteger(L, ref);
-    lua_rawseti(L, t, FREELIST_REF);  /* t[FREELIST_REF] = ref */
-  }
-}
-
-
-
-/*
-** {======================================================
-** Load functions
-** =======================================================
-*/
-
-typedef struct LoadF {
-  int extraline;
-  FILE *f;
-  char buff[LUAL_BUFFERSIZE];
-} LoadF;
-
-
-static const char *getF (lua_State *L, void *ud, size_t *size) {
-  LoadF *lf = (LoadF *)ud;
-  (void)L;
-  if (lf->extraline) {
-    lf->extraline = 0;
-    *size = 1;
-    return "\n";
-  }
-  if (feof(lf->f)) return NULL;
-  *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);
-  return (*size > 0) ? lf->buff : NULL;
-}
-
-
-static int errfile (lua_State *L, const char *what, int fnameindex) {
-  const char *serr = strerror(errno);
-  const char *filename = lua_tostring(L, fnameindex) + 1;
-  lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
-  lua_remove(L, fnameindex);
-  return LUA_ERRFILE;
-}
-
-
-LUALIB_API int luaL_loadfile (lua_State *L, const char *filename) {
-  LoadF lf;
-  int status, readstatus;
-  int c;
-  int fnameindex = lua_gettop(L) + 1;  /* index of filename on the stack */
-  lf.extraline = 0;
-  if (filename == NULL) {
-    lua_pushliteral(L, "=stdin");
-    lf.f = stdin;
-  }
-  else {
-    lua_pushfstring(L, "@%s", filename);
-    lf.f = fopen(filename, "r");
-    if (lf.f == NULL) return errfile(L, "open", fnameindex);
-  }
-  c = getc(lf.f);
-  if (c == '#') {  /* Unix exec. file? */
-    lf.extraline = 1;
-    while ((c = getc(lf.f)) != EOF && c != '\n') ;  /* skip first line */
-    if (c == '\n') c = getc(lf.f);
-  }
-  if (c == LUA_SIGNATURE[0] && filename) {  /* binary file? */
-    lf.f = freopen(filename, "rb", lf.f);  /* reopen in binary mode */
-    if (lf.f == NULL) return errfile(L, "reopen", fnameindex);
-    /* skip eventual `#!...' */
-   while ((c = getc(lf.f)) != EOF && c != LUA_SIGNATURE[0]) ;
-    lf.extraline = 0;
-  }
-  ungetc(c, lf.f);
-  status = lua_load(L, getF, &lf, lua_tostring(L, -1));
-  readstatus = ferror(lf.f);
-  if (filename) fclose(lf.f);  /* close file (even in case of errors) */
-  if (readstatus) {
-    lua_settop(L, fnameindex);  /* ignore results from `lua_load' */
-    return errfile(L, "read", fnameindex);
-  }
-  lua_remove(L, fnameindex);
-  return status;
-}
-
-
-typedef struct LoadS {
-  const char *s;
-  size_t size;
-} LoadS;
-
-
-static const char *getS (lua_State *L, void *ud, size_t *size) {
-  LoadS *ls = (LoadS *)ud;
-  (void)L;
-  if (ls->size == 0) return NULL;
-  *size = ls->size;
-  ls->size = 0;
-  return ls->s;
-}
-
-
-LUALIB_API int luaL_loadbuffer (lua_State *L, const char *buff, size_t size,
-                                const char *name) {
-  LoadS ls;
-  ls.s = buff;
-  ls.size = size;
-  return lua_load(L, getS, &ls, name);
-}
-
-
-LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s) {
-  return luaL_loadbuffer(L, s, strlen(s), s);
-}
-
-
-
-/* }====================================================== */
-
-
-static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
-  (void)ud;
-  (void)osize;
-  if (nsize == 0) {
-    free(ptr);
-    return NULL;
-  }
-  else
-    return realloc(ptr, nsize);
-}
-
-
-static int panic (lua_State *L) {
-  (void)L;  /* to avoid warnings */
-  fprintf(stderr, "PANIC: unprotected error in call to Lua API (%s)\n",
-                   lua_tostring(L, -1));
-  return 0;
-}
-
-
-LUALIB_API lua_State *luaL_newstate (void) {
-  lua_State *L = lua_newstate(l_alloc, NULL);
-  if (L) lua_atpanic(L, &panic);
-  return L;
-}
-
diff --git a/extern/lua-5.1.5/src/lauxlib.h b/extern/lua-5.1.5/src/lauxlib.h
deleted file mode 100644
index 34258235..00000000
--- a/extern/lua-5.1.5/src/lauxlib.h
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
-** $Id: lauxlib.h,v 1.88.1.1 2007/12/27 13:02:25 roberto Exp $
-** Auxiliary functions for building Lua libraries
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef lauxlib_h
-#define lauxlib_h
-
-
-#include <stddef.h>
-#include <stdio.h>
-
-#include "lua.h"
-
-
-#if defined(LUA_COMPAT_GETN)
-LUALIB_API int (luaL_getn) (lua_State *L, int t);
-LUALIB_API void (luaL_setn) (lua_State *L, int t, int n);
-#else
-#define luaL_getn(L,i)          ((int)lua_objlen(L, i))
-#define luaL_setn(L,i,j)        ((void)0)  /* no op! */
-#endif
-
-#if defined(LUA_COMPAT_OPENLIB)
-#define luaI_openlib	luaL_openlib
-#endif
-
-
-/* extra error code for `luaL_load' */
-#define LUA_ERRFILE     (LUA_ERRERR+1)
-
-
-typedef struct luaL_Reg {
-  const char *name;
-  lua_CFunction func;
-} luaL_Reg;
-
-
-
-LUALIB_API void (luaI_openlib) (lua_State *L, const char *libname,
-                                const luaL_Reg *l, int nup);
-LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
-                                const luaL_Reg *l);
-LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
-LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
-LUALIB_API int (luaL_typerror) (lua_State *L, int narg, const char *tname);
-LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
-LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
-                                                          size_t *l);
-LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
-                                          const char *def, size_t *l);
-LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
-LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
-
-LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
-LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
-                                          lua_Integer def);
-
-LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
-LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
-LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
-
-LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
-LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
-
-LUALIB_API void (luaL_where) (lua_State *L, int lvl);
-LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
-
-LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
-                                   const char *const lst[]);
-
-LUALIB_API int (luaL_ref) (lua_State *L, int t);
-LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
-
-LUALIB_API int (luaL_loadfile) (lua_State *L, const char *filename);
-LUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz,
-                                  const char *name);
-LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
-
-LUALIB_API lua_State *(luaL_newstate) (void);
-
-
-LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
-                                                  const char *r);
-
-LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx,
-                                         const char *fname, int szhint);
-
-
-
-
-/*
-** ===============================================================
-** some useful macros
-** ===============================================================
-*/
-
-#define luaL_argcheck(L, cond,numarg,extramsg)	\
-		((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
-#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
-#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
-#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
-#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
-#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
-#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
-
-#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
-
-#define luaL_dofile(L, fn) \
-	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
-
-#define luaL_dostring(L, s) \
-	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
-
-#define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))
-
-#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
-
-/*
-** {======================================================
-** Generic Buffer manipulation
-** =======================================================
-*/
-
-
-
-typedef struct luaL_Buffer {
-  char *p;			/* current position in buffer */
-  int lvl;  /* number of strings in the stack (level) */
-  lua_State *L;
-  char buffer[LUAL_BUFFERSIZE];
-} luaL_Buffer;
-
-#define luaL_addchar(B,c) \
-  ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \
-   (*(B)->p++ = (char)(c)))
-
-/* compatibility only */
-#define luaL_putchar(B,c)	luaL_addchar(B,c)
-
-#define luaL_addsize(B,n)	((B)->p += (n))
-
-LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
-LUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B);
-LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
-LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
-LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
-LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
-
-
-/* }====================================================== */
-
-
-/* compatibility with ref system */
-
-/* pre-defined references */
-#define LUA_NOREF       (-2)
-#define LUA_REFNIL      (-1)
-
-#define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \
-      (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0))
-
-#define lua_unref(L,ref)        luaL_unref(L, LUA_REGISTRYINDEX, (ref))
-
-#define lua_getref(L,ref)       lua_rawgeti(L, LUA_REGISTRYINDEX, (ref))
-
-
-#define luaL_reg	luaL_Reg
-
-#endif
-
-
diff --git a/extern/lua-5.1.5/src/lbaselib.c b/extern/lua-5.1.5/src/lbaselib.c
deleted file mode 100644
index 2ab550bd..00000000
--- a/extern/lua-5.1.5/src/lbaselib.c
+++ /dev/null
@@ -1,653 +0,0 @@
-/*
-** $Id: lbaselib.c,v 1.191.1.6 2008/02/14 16:46:22 roberto Exp $
-** Basic library
-** See Copyright Notice in lua.h
-*/
-
-
-
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define lbaselib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-
-
-/*
-** If your system does not support `stdout', you can just remove this function.
-** If you need, you can define your own `print' function, following this
-** model but changing `fputs' to put the strings at a proper place
-** (a console window or a log file, for instance).
-*/
-static int luaB_print (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  int i;
-  lua_getglobal(L, "tostring");
-  for (i=1; i<=n; i++) {
-    const char *s;
-    lua_pushvalue(L, -1);  /* function to be called */
-    lua_pushvalue(L, i);   /* value to print */
-    lua_call(L, 1, 1);
-    s = lua_tostring(L, -1);  /* get result */
-    if (s == NULL)
-      return luaL_error(L, LUA_QL("tostring") " must return a string to "
-                           LUA_QL("print"));
-    if (i>1) fputs("\t", stdout);
-    fputs(s, stdout);
-    lua_pop(L, 1);  /* pop result */
-  }
-  fputs("\n", stdout);
-  return 0;
-}
-
-
-static int luaB_tonumber (lua_State *L) {
-  int base = luaL_optint(L, 2, 10);
-  if (base == 10) {  /* standard conversion */
-    luaL_checkany(L, 1);
-    if (lua_isnumber(L, 1)) {
-      lua_pushnumber(L, lua_tonumber(L, 1));
-      return 1;
-    }
-  }
-  else {
-    const char *s1 = luaL_checkstring(L, 1);
-    char *s2;
-    unsigned long n;
-    luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
-    n = strtoul(s1, &s2, base);
-    if (s1 != s2) {  /* at least one valid digit? */
-      while (isspace((unsigned char)(*s2))) s2++;  /* skip trailing spaces */
-      if (*s2 == '\0') {  /* no invalid trailing characters? */
-        lua_pushnumber(L, (lua_Number)n);
-        return 1;
-      }
-    }
-  }
-  lua_pushnil(L);  /* else not a number */
-  return 1;
-}
-
-
-static int luaB_error (lua_State *L) {
-  int level = luaL_optint(L, 2, 1);
-  lua_settop(L, 1);
-  if (lua_isstring(L, 1) && level > 0) {  /* add extra information? */
-    luaL_where(L, level);
-    lua_pushvalue(L, 1);
-    lua_concat(L, 2);
-  }
-  return lua_error(L);
-}
-
-
-static int luaB_getmetatable (lua_State *L) {
-  luaL_checkany(L, 1);
-  if (!lua_getmetatable(L, 1)) {
-    lua_pushnil(L);
-    return 1;  /* no metatable */
-  }
-  luaL_getmetafield(L, 1, "__metatable");
-  return 1;  /* returns either __metatable field (if present) or metatable */
-}
-
-
-static int luaB_setmetatable (lua_State *L) {
-  int t = lua_type(L, 2);
-  luaL_checktype(L, 1, LUA_TTABLE);
-  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
-                    "nil or table expected");
-  if (luaL_getmetafield(L, 1, "__metatable"))
-    luaL_error(L, "cannot change a protected metatable");
-  lua_settop(L, 2);
-  lua_setmetatable(L, 1);
-  return 1;
-}
-
-
-static void getfunc (lua_State *L, int opt) {
-  if (lua_isfunction(L, 1)) lua_pushvalue(L, 1);
-  else {
-    lua_Debug ar;
-    int level = opt ? luaL_optint(L, 1, 1) : luaL_checkint(L, 1);
-    luaL_argcheck(L, level >= 0, 1, "level must be non-negative");
-    if (lua_getstack(L, level, &ar) == 0)
-      luaL_argerror(L, 1, "invalid level");
-    lua_getinfo(L, "f", &ar);
-    if (lua_isnil(L, -1))
-      luaL_error(L, "no function environment for tail call at level %d",
-                    level);
-  }
-}
-
-
-static int luaB_getfenv (lua_State *L) {
-  getfunc(L, 1);
-  if (lua_iscfunction(L, -1))  /* is a C function? */
-    lua_pushvalue(L, LUA_GLOBALSINDEX);  /* return the thread's global env. */
-  else
-    lua_getfenv(L, -1);
-  return 1;
-}
-
-
-static int luaB_setfenv (lua_State *L) {
-  luaL_checktype(L, 2, LUA_TTABLE);
-  getfunc(L, 0);
-  lua_pushvalue(L, 2);
-  if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0) {
-    /* change environment of current thread */
-    lua_pushthread(L);
-    lua_insert(L, -2);
-    lua_setfenv(L, -2);
-    return 0;
-  }
-  else if (lua_iscfunction(L, -2) || lua_setfenv(L, -2) == 0)
-    luaL_error(L,
-          LUA_QL("setfenv") " cannot change environment of given object");
-  return 1;
-}
-
-
-static int luaB_rawequal (lua_State *L) {
-  luaL_checkany(L, 1);
-  luaL_checkany(L, 2);
-  lua_pushboolean(L, lua_rawequal(L, 1, 2));
-  return 1;
-}
-
-
-static int luaB_rawget (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  luaL_checkany(L, 2);
-  lua_settop(L, 2);
-  lua_rawget(L, 1);
-  return 1;
-}
-
-static int luaB_rawset (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  luaL_checkany(L, 2);
-  luaL_checkany(L, 3);
-  lua_settop(L, 3);
-  lua_rawset(L, 1);
-  return 1;
-}
-
-
-static int luaB_gcinfo (lua_State *L) {
-  lua_pushinteger(L, lua_getgccount(L));
-  return 1;
-}
-
-
-static int luaB_collectgarbage (lua_State *L) {
-  static const char *const opts[] = {"stop", "restart", "collect",
-    "count", "step", "setpause", "setstepmul", NULL};
-  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
-    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL};
-  int o = luaL_checkoption(L, 1, "collect", opts);
-  int ex = luaL_optint(L, 2, 0);
-  int res = lua_gc(L, optsnum[o], ex);
-  switch (optsnum[o]) {
-    case LUA_GCCOUNT: {
-      int b = lua_gc(L, LUA_GCCOUNTB, 0);
-      lua_pushnumber(L, res + ((lua_Number)b/1024));
-      return 1;
-    }
-    case LUA_GCSTEP: {
-      lua_pushboolean(L, res);
-      return 1;
-    }
-    default: {
-      lua_pushnumber(L, res);
-      return 1;
-    }
-  }
-}
-
-
-static int luaB_type (lua_State *L) {
-  luaL_checkany(L, 1);
-  lua_pushstring(L, luaL_typename(L, 1));
-  return 1;
-}
-
-
-static int luaB_next (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  lua_settop(L, 2);  /* create a 2nd argument if there isn't one */
-  if (lua_next(L, 1))
-    return 2;
-  else {
-    lua_pushnil(L);
-    return 1;
-  }
-}
-
-
-static int luaB_pairs (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
-  lua_pushvalue(L, 1);  /* state, */
-  lua_pushnil(L);  /* and initial value */
-  return 3;
-}
-
-
-static int ipairsaux (lua_State *L) {
-  int i = luaL_checkint(L, 2);
-  luaL_checktype(L, 1, LUA_TTABLE);
-  i++;  /* next value */
-  lua_pushinteger(L, i);
-  lua_rawgeti(L, 1, i);
-  return (lua_isnil(L, -1)) ? 0 : 2;
-}
-
-
-static int luaB_ipairs (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
-  lua_pushvalue(L, 1);  /* state, */
-  lua_pushinteger(L, 0);  /* and initial value */
-  return 3;
-}
-
-
-static int load_aux (lua_State *L, int status) {
-  if (status == 0)  /* OK? */
-    return 1;
-  else {
-    lua_pushnil(L);
-    lua_insert(L, -2);  /* put before error message */
-    return 2;  /* return nil plus error message */
-  }
-}
-
-
-static int luaB_loadstring (lua_State *L) {
-  size_t l;
-  const char *s = luaL_checklstring(L, 1, &l);
-  const char *chunkname = luaL_optstring(L, 2, s);
-  return load_aux(L, luaL_loadbuffer(L, s, l, chunkname));
-}
-
-
-static int luaB_loadfile (lua_State *L) {
-  const char *fname = luaL_optstring(L, 1, NULL);
-  return load_aux(L, luaL_loadfile(L, fname));
-}
-
-
-/*
-** Reader for generic `load' function: `lua_load' uses the
-** stack for internal stuff, so the reader cannot change the
-** stack top. Instead, it keeps its resulting string in a
-** reserved slot inside the stack.
-*/
-static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
-  (void)ud;  /* to avoid warnings */
-  luaL_checkstack(L, 2, "too many nested functions");
-  lua_pushvalue(L, 1);  /* get function */
-  lua_call(L, 0, 1);  /* call it */
-  if (lua_isnil(L, -1)) {
-    *size = 0;
-    return NULL;
-  }
-  else if (lua_isstring(L, -1)) {
-    lua_replace(L, 3);  /* save string in a reserved stack slot */
-    return lua_tolstring(L, 3, size);
-  }
-  else luaL_error(L, "reader function must return a string");
-  return NULL;  /* to avoid warnings */
-}
-
-
-static int luaB_load (lua_State *L) {
-  int status;
-  const char *cname = luaL_optstring(L, 2, "=(load)");
-  luaL_checktype(L, 1, LUA_TFUNCTION);
-  lua_settop(L, 3);  /* function, eventual name, plus one reserved slot */
-  status = lua_load(L, generic_reader, NULL, cname);
-  return load_aux(L, status);
-}
-
-
-static int luaB_dofile (lua_State *L) {
-  const char *fname = luaL_optstring(L, 1, NULL);
-  int n = lua_gettop(L);
-  if (luaL_loadfile(L, fname) != 0) lua_error(L);
-  lua_call(L, 0, LUA_MULTRET);
-  return lua_gettop(L) - n;
-}
-
-
-static int luaB_assert (lua_State *L) {
-  luaL_checkany(L, 1);
-  if (!lua_toboolean(L, 1))
-    return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
-  return lua_gettop(L);
-}
-
-
-static int luaB_unpack (lua_State *L) {
-  int i, e, n;
-  luaL_checktype(L, 1, LUA_TTABLE);
-  i = luaL_optint(L, 2, 1);
-  e = luaL_opt(L, luaL_checkint, 3, luaL_getn(L, 1));
-  if (i > e) return 0;  /* empty range */
-  n = e - i + 1;  /* number of elements */
-  if (n <= 0 || !lua_checkstack(L, n))  /* n <= 0 means arith. overflow */
-    return luaL_error(L, "too many results to unpack");
-  lua_rawgeti(L, 1, i);  /* push arg[i] (avoiding overflow problems) */
-  while (i++ < e)  /* push arg[i + 1...e] */
-    lua_rawgeti(L, 1, i);
-  return n;
-}
-
-
-static int luaB_select (lua_State *L) {
-  int n = lua_gettop(L);
-  if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
-    lua_pushinteger(L, n-1);
-    return 1;
-  }
-  else {
-    int i = luaL_checkint(L, 1);
-    if (i < 0) i = n + i;
-    else if (i > n) i = n;
-    luaL_argcheck(L, 1 <= i, 1, "index out of range");
-    return n - i;
-  }
-}
-
-
-static int luaB_pcall (lua_State *L) {
-  int status;
-  luaL_checkany(L, 1);
-  status = lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0);
-  lua_pushboolean(L, (status == 0));
-  lua_insert(L, 1);
-  return lua_gettop(L);  /* return status + all results */
-}
-
-
-static int luaB_xpcall (lua_State *L) {
-  int status;
-  luaL_checkany(L, 2);
-  lua_settop(L, 2);
-  lua_insert(L, 1);  /* put error function under function to be called */
-  status = lua_pcall(L, 0, LUA_MULTRET, 1);
-  lua_pushboolean(L, (status == 0));
-  lua_replace(L, 1);
-  return lua_gettop(L);  /* return status + all results */
-}
-
-
-static int luaB_tostring (lua_State *L) {
-  luaL_checkany(L, 1);
-  if (luaL_callmeta(L, 1, "__tostring"))  /* is there a metafield? */
-    return 1;  /* use its value */
-  switch (lua_type(L, 1)) {
-    case LUA_TNUMBER:
-      lua_pushstring(L, lua_tostring(L, 1));
-      break;
-    case LUA_TSTRING:
-      lua_pushvalue(L, 1);
-      break;
-    case LUA_TBOOLEAN:
-      lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false"));
-      break;
-    case LUA_TNIL:
-      lua_pushliteral(L, "nil");
-      break;
-    default:
-      lua_pushfstring(L, "%s: %p", luaL_typename(L, 1), lua_topointer(L, 1));
-      break;
-  }
-  return 1;
-}
-
-
-static int luaB_newproxy (lua_State *L) {
-  lua_settop(L, 1);
-  lua_newuserdata(L, 0);  /* create proxy */
-  if (lua_toboolean(L, 1) == 0)
-    return 1;  /* no metatable */
-  else if (lua_isboolean(L, 1)) {
-    lua_newtable(L);  /* create a new metatable `m' ... */
-    lua_pushvalue(L, -1);  /* ... and mark `m' as a valid metatable */
-    lua_pushboolean(L, 1);
-    lua_rawset(L, lua_upvalueindex(1));  /* weaktable[m] = true */
-  }
-  else {
-    int validproxy = 0;  /* to check if weaktable[metatable(u)] == true */
-    if (lua_getmetatable(L, 1)) {
-      lua_rawget(L, lua_upvalueindex(1));
-      validproxy = lua_toboolean(L, -1);
-      lua_pop(L, 1);  /* remove value */
-    }
-    luaL_argcheck(L, validproxy, 1, "boolean or proxy expected");
-    lua_getmetatable(L, 1);  /* metatable is valid; get it */
-  }
-  lua_setmetatable(L, 2);
-  return 1;
-}
-
-
-static const luaL_Reg base_funcs[] = {
-  {"assert", luaB_assert},
-  {"collectgarbage", luaB_collectgarbage},
-  {"dofile", luaB_dofile},
-  {"error", luaB_error},
-  {"gcinfo", luaB_gcinfo},
-  {"getfenv", luaB_getfenv},
-  {"getmetatable", luaB_getmetatable},
-  {"loadfile", luaB_loadfile},
-  {"load", luaB_load},
-  {"loadstring", luaB_loadstring},
-  {"next", luaB_next},
-  {"pcall", luaB_pcall},
-  {"print", luaB_print},
-  {"rawequal", luaB_rawequal},
-  {"rawget", luaB_rawget},
-  {"rawset", luaB_rawset},
-  {"select", luaB_select},
-  {"setfenv", luaB_setfenv},
-  {"setmetatable", luaB_setmetatable},
-  {"tonumber", luaB_tonumber},
-  {"tostring", luaB_tostring},
-  {"type", luaB_type},
-  {"unpack", luaB_unpack},
-  {"xpcall", luaB_xpcall},
-  {NULL, NULL}
-};
-
-
-/*
-** {======================================================
-** Coroutine library
-** =======================================================
-*/
-
-#define CO_RUN	0	/* running */
-#define CO_SUS	1	/* suspended */
-#define CO_NOR	2	/* 'normal' (it resumed another coroutine) */
-#define CO_DEAD	3
-
-static const char *const statnames[] =
-    {"running", "suspended", "normal", "dead"};
-
-static int costatus (lua_State *L, lua_State *co) {
-  if (L == co) return CO_RUN;
-  switch (lua_status(co)) {
-    case LUA_YIELD:
-      return CO_SUS;
-    case 0: {
-      lua_Debug ar;
-      if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */
-        return CO_NOR;  /* it is running */
-      else if (lua_gettop(co) == 0)
-          return CO_DEAD;
-      else
-        return CO_SUS;  /* initial state */
-    }
-    default:  /* some error occured */
-      return CO_DEAD;
-  }
-}
-
-
-static int luaB_costatus (lua_State *L) {
-  lua_State *co = lua_tothread(L, 1);
-  luaL_argcheck(L, co, 1, "coroutine expected");
-  lua_pushstring(L, statnames[costatus(L, co)]);
-  return 1;
-}
-
-
-static int auxresume (lua_State *L, lua_State *co, int narg) {
-  int status = costatus(L, co);
-  if (!lua_checkstack(co, narg))
-    luaL_error(L, "too many arguments to resume");
-  if (status != CO_SUS) {
-    lua_pushfstring(L, "cannot resume %s coroutine", statnames[status]);
-    return -1;  /* error flag */
-  }
-  lua_xmove(L, co, narg);
-  lua_setlevel(L, co);
-  status = lua_resume(co, narg);
-  if (status == 0 || status == LUA_YIELD) {
-    int nres = lua_gettop(co);
-    if (!lua_checkstack(L, nres + 1))
-      luaL_error(L, "too many results to resume");
-    lua_xmove(co, L, nres);  /* move yielded values */
-    return nres;
-  }
-  else {
-    lua_xmove(co, L, 1);  /* move error message */
-    return -1;  /* error flag */
-  }
-}
-
-
-static int luaB_coresume (lua_State *L) {
-  lua_State *co = lua_tothread(L, 1);
-  int r;
-  luaL_argcheck(L, co, 1, "coroutine expected");
-  r = auxresume(L, co, lua_gettop(L) - 1);
-  if (r < 0) {
-    lua_pushboolean(L, 0);
-    lua_insert(L, -2);
-    return 2;  /* return false + error message */
-  }
-  else {
-    lua_pushboolean(L, 1);
-    lua_insert(L, -(r + 1));
-    return r + 1;  /* return true + `resume' returns */
-  }
-}
-
-
-static int luaB_auxwrap (lua_State *L) {
-  lua_State *co = lua_tothread(L, lua_upvalueindex(1));
-  int r = auxresume(L, co, lua_gettop(L));
-  if (r < 0) {
-    if (lua_isstring(L, -1)) {  /* error object is a string? */
-      luaL_where(L, 1);  /* add extra info */
-      lua_insert(L, -2);
-      lua_concat(L, 2);
-    }
-    lua_error(L);  /* propagate error */
-  }
-  return r;
-}
-
-
-static int luaB_cocreate (lua_State *L) {
-  lua_State *NL = lua_newthread(L);
-  luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), 1,
-    "Lua function expected");
-  lua_pushvalue(L, 1);  /* move function to top */
-  lua_xmove(L, NL, 1);  /* move function from L to NL */
-  return 1;
-}
-
-
-static int luaB_cowrap (lua_State *L) {
-  luaB_cocreate(L);
-  lua_pushcclosure(L, luaB_auxwrap, 1);
-  return 1;
-}
-
-
-static int luaB_yield (lua_State *L) {
-  return lua_yield(L, lua_gettop(L));
-}
-
-
-static int luaB_corunning (lua_State *L) {
-  if (lua_pushthread(L))
-    lua_pushnil(L);  /* main thread is not a coroutine */
-  return 1;
-}
-
-
-static const luaL_Reg co_funcs[] = {
-  {"create", luaB_cocreate},
-  {"resume", luaB_coresume},
-  {"running", luaB_corunning},
-  {"status", luaB_costatus},
-  {"wrap", luaB_cowrap},
-  {"yield", luaB_yield},
-  {NULL, NULL}
-};
-
-/* }====================================================== */
-
-
-static void auxopen (lua_State *L, const char *name,
-                     lua_CFunction f, lua_CFunction u) {
-  lua_pushcfunction(L, u);
-  lua_pushcclosure(L, f, 1);
-  lua_setfield(L, -2, name);
-}
-
-
-static void base_open (lua_State *L) {
-  /* set global _G */
-  lua_pushvalue(L, LUA_GLOBALSINDEX);
-  lua_setglobal(L, "_G");
-  /* open lib into global table */
-  luaL_register(L, "_G", base_funcs);
-  lua_pushliteral(L, LUA_VERSION);
-  lua_setglobal(L, "_VERSION");  /* set global _VERSION */
-  /* `ipairs' and `pairs' need auxiliary functions as upvalues */
-  auxopen(L, "ipairs", luaB_ipairs, ipairsaux);
-  auxopen(L, "pairs", luaB_pairs, luaB_next);
-  /* `newproxy' needs a weaktable as upvalue */
-  lua_createtable(L, 0, 1);  /* new table `w' */
-  lua_pushvalue(L, -1);  /* `w' will be its own metatable */
-  lua_setmetatable(L, -2);
-  lua_pushliteral(L, "kv");
-  lua_setfield(L, -2, "__mode");  /* metatable(w).__mode = "kv" */
-  lua_pushcclosure(L, luaB_newproxy, 1);
-  lua_setglobal(L, "newproxy");  /* set global `newproxy' */
-}
-
-
-LUALIB_API int luaopen_base (lua_State *L) {
-  base_open(L);
-  luaL_register(L, LUA_COLIBNAME, co_funcs);
-  return 2;
-}
-
diff --git a/extern/lua-5.1.5/src/lcode.c b/extern/lua-5.1.5/src/lcode.c
deleted file mode 100644
index 679cb9cf..00000000
--- a/extern/lua-5.1.5/src/lcode.c
+++ /dev/null
@@ -1,831 +0,0 @@
-/*
-** $Id: lcode.c,v 2.25.1.5 2011/01/31 14:53:16 roberto Exp $
-** Code generator for Lua
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stdlib.h>
-
-#define lcode_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lcode.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lgc.h"
-#include "llex.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lparser.h"
-#include "ltable.h"
-
-
-#define hasjumps(e)	((e)->t != (e)->f)
-
-
-static int isnumeral(expdesc *e) {
-  return (e->k == VKNUM && e->t == NO_JUMP && e->f == NO_JUMP);
-}
-
-
-void luaK_nil (FuncState *fs, int from, int n) {
-  Instruction *previous;
-  if (fs->pc > fs->lasttarget) {  /* no jumps to current position? */
-    if (fs->pc == 0) {  /* function start? */
-      if (from >= fs->nactvar)
-        return;  /* positions are already clean */
-    }
-    else {
-      previous = &fs->f->code[fs->pc-1];
-      if (GET_OPCODE(*previous) == OP_LOADNIL) {
-        int pfrom = GETARG_A(*previous);
-        int pto = GETARG_B(*previous);
-        if (pfrom <= from && from <= pto+1) {  /* can connect both? */
-          if (from+n-1 > pto)
-            SETARG_B(*previous, from+n-1);
-          return;
-        }
-      }
-    }
-  }
-  luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0);  /* else no optimization */
-}
-
-
-int luaK_jump (FuncState *fs) {
-  int jpc = fs->jpc;  /* save list of jumps to here */
-  int j;
-  fs->jpc = NO_JUMP;
-  j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);
-  luaK_concat(fs, &j, jpc);  /* keep them on hold */
-  return j;
-}
-
-
-void luaK_ret (FuncState *fs, int first, int nret) {
-  luaK_codeABC(fs, OP_RETURN, first, nret+1, 0);
-}
-
-
-static int condjump (FuncState *fs, OpCode op, int A, int B, int C) {
-  luaK_codeABC(fs, op, A, B, C);
-  return luaK_jump(fs);
-}
-
-
-static void fixjump (FuncState *fs, int pc, int dest) {
-  Instruction *jmp = &fs->f->code[pc];
-  int offset = dest-(pc+1);
-  lua_assert(dest != NO_JUMP);
-  if (abs(offset) > MAXARG_sBx)
-    luaX_syntaxerror(fs->ls, "control structure too long");
-  SETARG_sBx(*jmp, offset);
-}
-
-
-/*
-** returns current `pc' and marks it as a jump target (to avoid wrong
-** optimizations with consecutive instructions not in the same basic block).
-*/
-int luaK_getlabel (FuncState *fs) {
-  fs->lasttarget = fs->pc;
-  return fs->pc;
-}
-
-
-static int getjump (FuncState *fs, int pc) {
-  int offset = GETARG_sBx(fs->f->code[pc]);
-  if (offset == NO_JUMP)  /* point to itself represents end of list */
-    return NO_JUMP;  /* end of list */
-  else
-    return (pc+1)+offset;  /* turn offset into absolute position */
-}
-
-
-static Instruction *getjumpcontrol (FuncState *fs, int pc) {
-  Instruction *pi = &fs->f->code[pc];
-  if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1))))
-    return pi-1;
-  else
-    return pi;
-}
-
-
-/*
-** check whether list has any jump that do not produce a value
-** (or produce an inverted value)
-*/
-static int need_value (FuncState *fs, int list) {
-  for (; list != NO_JUMP; list = getjump(fs, list)) {
-    Instruction i = *getjumpcontrol(fs, list);
-    if (GET_OPCODE(i) != OP_TESTSET) return 1;
-  }
-  return 0;  /* not found */
-}
-
-
-static int patchtestreg (FuncState *fs, int node, int reg) {
-  Instruction *i = getjumpcontrol(fs, node);
-  if (GET_OPCODE(*i) != OP_TESTSET)
-    return 0;  /* cannot patch other instructions */
-  if (reg != NO_REG && reg != GETARG_B(*i))
-    SETARG_A(*i, reg);
-  else  /* no register to put value or register already has the value */
-    *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i));
-
-  return 1;
-}
-
-
-static void removevalues (FuncState *fs, int list) {
-  for (; list != NO_JUMP; list = getjump(fs, list))
-      patchtestreg(fs, list, NO_REG);
-}
-
-
-static void patchlistaux (FuncState *fs, int list, int vtarget, int reg,
-                          int dtarget) {
-  while (list != NO_JUMP) {
-    int next = getjump(fs, list);
-    if (patchtestreg(fs, list, reg))
-      fixjump(fs, list, vtarget);
-    else
-      fixjump(fs, list, dtarget);  /* jump to default target */
-    list = next;
-  }
-}
-
-
-static void dischargejpc (FuncState *fs) {
-  patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc);
-  fs->jpc = NO_JUMP;
-}
-
-
-void luaK_patchlist (FuncState *fs, int list, int target) {
-  if (target == fs->pc)
-    luaK_patchtohere(fs, list);
-  else {
-    lua_assert(target < fs->pc);
-    patchlistaux(fs, list, target, NO_REG, target);
-  }
-}
-
-
-void luaK_patchtohere (FuncState *fs, int list) {
-  luaK_getlabel(fs);
-  luaK_concat(fs, &fs->jpc, list);
-}
-
-
-void luaK_concat (FuncState *fs, int *l1, int l2) {
-  if (l2 == NO_JUMP) return;
-  else if (*l1 == NO_JUMP)
-    *l1 = l2;
-  else {
-    int list = *l1;
-    int next;
-    while ((next = getjump(fs, list)) != NO_JUMP)  /* find last element */
-      list = next;
-    fixjump(fs, list, l2);
-  }
-}
-
-
-void luaK_checkstack (FuncState *fs, int n) {
-  int newstack = fs->freereg + n;
-  if (newstack > fs->f->maxstacksize) {
-    if (newstack >= MAXSTACK)
-      luaX_syntaxerror(fs->ls, "function or expression too complex");
-    fs->f->maxstacksize = cast_byte(newstack);
-  }
-}
-
-
-void luaK_reserveregs (FuncState *fs, int n) {
-  luaK_checkstack(fs, n);
-  fs->freereg += n;
-}
-
-
-static void freereg (FuncState *fs, int reg) {
-  if (!ISK(reg) && reg >= fs->nactvar) {
-    fs->freereg--;
-    lua_assert(reg == fs->freereg);
-  }
-}
-
-
-static void freeexp (FuncState *fs, expdesc *e) {
-  if (e->k == VNONRELOC)
-    freereg(fs, e->u.s.info);
-}
-
-
-static int addk (FuncState *fs, TValue *k, TValue *v) {
-  lua_State *L = fs->L;
-  TValue *idx = luaH_set(L, fs->h, k);
-  Proto *f = fs->f;
-  int oldsize = f->sizek;
-  if (ttisnumber(idx)) {
-    lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v));
-    return cast_int(nvalue(idx));
-  }
-  else {  /* constant not found; create a new entry */
-    setnvalue(idx, cast_num(fs->nk));
-    luaM_growvector(L, f->k, fs->nk, f->sizek, TValue,
-                    MAXARG_Bx, "constant table overflow");
-    while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
-    setobj(L, &f->k[fs->nk], v);
-    luaC_barrier(L, f, v);
-    return fs->nk++;
-  }
-}
-
-
-int luaK_stringK (FuncState *fs, TString *s) {
-  TValue o;
-  setsvalue(fs->L, &o, s);
-  return addk(fs, &o, &o);
-}
-
-
-int luaK_numberK (FuncState *fs, lua_Number r) {
-  TValue o;
-  setnvalue(&o, r);
-  return addk(fs, &o, &o);
-}
-
-
-static int boolK (FuncState *fs, int b) {
-  TValue o;
-  setbvalue(&o, b);
-  return addk(fs, &o, &o);
-}
-
-
-static int nilK (FuncState *fs) {
-  TValue k, v;
-  setnilvalue(&v);
-  /* cannot use nil as key; instead use table itself to represent nil */
-  sethvalue(fs->L, &k, fs->h);
-  return addk(fs, &k, &v);
-}
-
-
-void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {
-  if (e->k == VCALL) {  /* expression is an open function call? */
-    SETARG_C(getcode(fs, e), nresults+1);
-  }
-  else if (e->k == VVARARG) {
-    SETARG_B(getcode(fs, e), nresults+1);
-    SETARG_A(getcode(fs, e), fs->freereg);
-    luaK_reserveregs(fs, 1);
-  }
-}
-
-
-void luaK_setoneret (FuncState *fs, expdesc *e) {
-  if (e->k == VCALL) {  /* expression is an open function call? */
-    e->k = VNONRELOC;
-    e->u.s.info = GETARG_A(getcode(fs, e));
-  }
-  else if (e->k == VVARARG) {
-    SETARG_B(getcode(fs, e), 2);
-    e->k = VRELOCABLE;  /* can relocate its simple result */
-  }
-}
-
-
-void luaK_dischargevars (FuncState *fs, expdesc *e) {
-  switch (e->k) {
-    case VLOCAL: {
-      e->k = VNONRELOC;
-      break;
-    }
-    case VUPVAL: {
-      e->u.s.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.s.info, 0);
-      e->k = VRELOCABLE;
-      break;
-    }
-    case VGLOBAL: {
-      e->u.s.info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->u.s.info);
-      e->k = VRELOCABLE;
-      break;
-    }
-    case VINDEXED: {
-      freereg(fs, e->u.s.aux);
-      freereg(fs, e->u.s.info);
-      e->u.s.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.s.info, e->u.s.aux);
-      e->k = VRELOCABLE;
-      break;
-    }
-    case VVARARG:
-    case VCALL: {
-      luaK_setoneret(fs, e);
-      break;
-    }
-    default: break;  /* there is one value available (somewhere) */
-  }
-}
-
-
-static int code_label (FuncState *fs, int A, int b, int jump) {
-  luaK_getlabel(fs);  /* those instructions may be jump targets */
-  return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump);
-}
-
-
-static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
-  luaK_dischargevars(fs, e);
-  switch (e->k) {
-    case VNIL: {
-      luaK_nil(fs, reg, 1);
-      break;
-    }
-    case VFALSE:  case VTRUE: {
-      luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
-      break;
-    }
-    case VK: {
-      luaK_codeABx(fs, OP_LOADK, reg, e->u.s.info);
-      break;
-    }
-    case VKNUM: {
-      luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval));
-      break;
-    }
-    case VRELOCABLE: {
-      Instruction *pc = &getcode(fs, e);
-      SETARG_A(*pc, reg);
-      break;
-    }
-    case VNONRELOC: {
-      if (reg != e->u.s.info)
-        luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0);
-      break;
-    }
-    default: {
-      lua_assert(e->k == VVOID || e->k == VJMP);
-      return;  /* nothing to do... */
-    }
-  }
-  e->u.s.info = reg;
-  e->k = VNONRELOC;
-}
-
-
-static void discharge2anyreg (FuncState *fs, expdesc *e) {
-  if (e->k != VNONRELOC) {
-    luaK_reserveregs(fs, 1);
-    discharge2reg(fs, e, fs->freereg-1);
-  }
-}
-
-
-static void exp2reg (FuncState *fs, expdesc *e, int reg) {
-  discharge2reg(fs, e, reg);
-  if (e->k == VJMP)
-    luaK_concat(fs, &e->t, e->u.s.info);  /* put this jump in `t' list */
-  if (hasjumps(e)) {
-    int final;  /* position after whole expression */
-    int p_f = NO_JUMP;  /* position of an eventual LOAD false */
-    int p_t = NO_JUMP;  /* position of an eventual LOAD true */
-    if (need_value(fs, e->t) || need_value(fs, e->f)) {
-      int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);
-      p_f = code_label(fs, reg, 0, 1);
-      p_t = code_label(fs, reg, 1, 0);
-      luaK_patchtohere(fs, fj);
-    }
-    final = luaK_getlabel(fs);
-    patchlistaux(fs, e->f, final, reg, p_f);
-    patchlistaux(fs, e->t, final, reg, p_t);
-  }
-  e->f = e->t = NO_JUMP;
-  e->u.s.info = reg;
-  e->k = VNONRELOC;
-}
-
-
-void luaK_exp2nextreg (FuncState *fs, expdesc *e) {
-  luaK_dischargevars(fs, e);
-  freeexp(fs, e);
-  luaK_reserveregs(fs, 1);
-  exp2reg(fs, e, fs->freereg - 1);
-}
-
-
-int luaK_exp2anyreg (FuncState *fs, expdesc *e) {
-  luaK_dischargevars(fs, e);
-  if (e->k == VNONRELOC) {
-    if (!hasjumps(e)) return e->u.s.info;  /* exp is already in a register */
-    if (e->u.s.info >= fs->nactvar) {  /* reg. is not a local? */
-      exp2reg(fs, e, e->u.s.info);  /* put value on it */
-      return e->u.s.info;
-    }
-  }
-  luaK_exp2nextreg(fs, e);  /* default */
-  return e->u.s.info;
-}
-
-
-void luaK_exp2val (FuncState *fs, expdesc *e) {
-  if (hasjumps(e))
-    luaK_exp2anyreg(fs, e);
-  else
-    luaK_dischargevars(fs, e);
-}
-
-
-int luaK_exp2RK (FuncState *fs, expdesc *e) {
-  luaK_exp2val(fs, e);
-  switch (e->k) {
-    case VKNUM:
-    case VTRUE:
-    case VFALSE:
-    case VNIL: {
-      if (fs->nk <= MAXINDEXRK) {  /* constant fit in RK operand? */
-        e->u.s.info = (e->k == VNIL)  ? nilK(fs) :
-                      (e->k == VKNUM) ? luaK_numberK(fs, e->u.nval) :
-                                        boolK(fs, (e->k == VTRUE));
-        e->k = VK;
-        return RKASK(e->u.s.info);
-      }
-      else break;
-    }
-    case VK: {
-      if (e->u.s.info <= MAXINDEXRK)  /* constant fit in argC? */
-        return RKASK(e->u.s.info);
-      else break;
-    }
-    default: break;
-  }
-  /* not a constant in the right range: put it in a register */
-  return luaK_exp2anyreg(fs, e);
-}
-
-
-void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
-  switch (var->k) {
-    case VLOCAL: {
-      freeexp(fs, ex);
-      exp2reg(fs, ex, var->u.s.info);
-      return;
-    }
-    case VUPVAL: {
-      int e = luaK_exp2anyreg(fs, ex);
-      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0);
-      break;
-    }
-    case VGLOBAL: {
-      int e = luaK_exp2anyreg(fs, ex);
-      luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info);
-      break;
-    }
-    case VINDEXED: {
-      int e = luaK_exp2RK(fs, ex);
-      luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e);
-      break;
-    }
-    default: {
-      lua_assert(0);  /* invalid var kind to store */
-      break;
-    }
-  }
-  freeexp(fs, ex);
-}
-
-
-void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
-  int func;
-  luaK_exp2anyreg(fs, e);
-  freeexp(fs, e);
-  func = fs->freereg;
-  luaK_reserveregs(fs, 2);
-  luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key));
-  freeexp(fs, key);
-  e->u.s.info = func;
-  e->k = VNONRELOC;
-}
-
-
-static void invertjump (FuncState *fs, expdesc *e) {
-  Instruction *pc = getjumpcontrol(fs, e->u.s.info);
-  lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&
-                                           GET_OPCODE(*pc) != OP_TEST);
-  SETARG_A(*pc, !(GETARG_A(*pc)));
-}
-
-
-static int jumponcond (FuncState *fs, expdesc *e, int cond) {
-  if (e->k == VRELOCABLE) {
-    Instruction ie = getcode(fs, e);
-    if (GET_OPCODE(ie) == OP_NOT) {
-      fs->pc--;  /* remove previous OP_NOT */
-      return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond);
-    }
-    /* else go through */
-  }
-  discharge2anyreg(fs, e);
-  freeexp(fs, e);
-  return condjump(fs, OP_TESTSET, NO_REG, e->u.s.info, cond);
-}
-
-
-void luaK_goiftrue (FuncState *fs, expdesc *e) {
-  int pc;  /* pc of last jump */
-  luaK_dischargevars(fs, e);
-  switch (e->k) {
-    case VK: case VKNUM: case VTRUE: {
-      pc = NO_JUMP;  /* always true; do nothing */
-      break;
-    }
-    case VJMP: {
-      invertjump(fs, e);
-      pc = e->u.s.info;
-      break;
-    }
-    default: {
-      pc = jumponcond(fs, e, 0);
-      break;
-    }
-  }
-  luaK_concat(fs, &e->f, pc);  /* insert last jump in `f' list */
-  luaK_patchtohere(fs, e->t);
-  e->t = NO_JUMP;
-}
-
-
-static void luaK_goiffalse (FuncState *fs, expdesc *e) {
-  int pc;  /* pc of last jump */
-  luaK_dischargevars(fs, e);
-  switch (e->k) {
-    case VNIL: case VFALSE: {
-      pc = NO_JUMP;  /* always false; do nothing */
-      break;
-    }
-    case VJMP: {
-      pc = e->u.s.info;
-      break;
-    }
-    default: {
-      pc = jumponcond(fs, e, 1);
-      break;
-    }
-  }
-  luaK_concat(fs, &e->t, pc);  /* insert last jump in `t' list */
-  luaK_patchtohere(fs, e->f);
-  e->f = NO_JUMP;
-}
-
-
-static void codenot (FuncState *fs, expdesc *e) {
-  luaK_dischargevars(fs, e);
-  switch (e->k) {
-    case VNIL: case VFALSE: {
-      e->k = VTRUE;
-      break;
-    }
-    case VK: case VKNUM: case VTRUE: {
-      e->k = VFALSE;
-      break;
-    }
-    case VJMP: {
-      invertjump(fs, e);
-      break;
-    }
-    case VRELOCABLE:
-    case VNONRELOC: {
-      discharge2anyreg(fs, e);
-      freeexp(fs, e);
-      e->u.s.info = luaK_codeABC(fs, OP_NOT, 0, e->u.s.info, 0);
-      e->k = VRELOCABLE;
-      break;
-    }
-    default: {
-      lua_assert(0);  /* cannot happen */
-      break;
-    }
-  }
-  /* interchange true and false lists */
-  { int temp = e->f; e->f = e->t; e->t = temp; }
-  removevalues(fs, e->f);
-  removevalues(fs, e->t);
-}
-
-
-void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
-  t->u.s.aux = luaK_exp2RK(fs, k);
-  t->k = VINDEXED;
-}
-
-
-static int constfolding (OpCode op, expdesc *e1, expdesc *e2) {
-  lua_Number v1, v2, r;
-  if (!isnumeral(e1) || !isnumeral(e2)) return 0;
-  v1 = e1->u.nval;
-  v2 = e2->u.nval;
-  switch (op) {
-    case OP_ADD: r = luai_numadd(v1, v2); break;
-    case OP_SUB: r = luai_numsub(v1, v2); break;
-    case OP_MUL: r = luai_nummul(v1, v2); break;
-    case OP_DIV:
-      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */
-      r = luai_numdiv(v1, v2); break;
-    case OP_MOD:
-      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */
-      r = luai_nummod(v1, v2); break;
-    case OP_POW: r = luai_numpow(v1, v2); break;
-    case OP_UNM: r = luai_numunm(v1); break;
-    case OP_LEN: return 0;  /* no constant folding for 'len' */
-    default: lua_assert(0); r = 0; break;
-  }
-  if (luai_numisnan(r)) return 0;  /* do not attempt to produce NaN */
-  e1->u.nval = r;
-  return 1;
-}
-
-
-static void codearith (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) {
-  if (constfolding(op, e1, e2))
-    return;
-  else {
-    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
-    int o1 = luaK_exp2RK(fs, e1);
-    if (o1 > o2) {
-      freeexp(fs, e1);
-      freeexp(fs, e2);
-    }
-    else {
-      freeexp(fs, e2);
-      freeexp(fs, e1);
-    }
-    e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2);
-    e1->k = VRELOCABLE;
-  }
-}
-
-
-static void codecomp (FuncState *fs, OpCode op, int cond, expdesc *e1,
-                                                          expdesc *e2) {
-  int o1 = luaK_exp2RK(fs, e1);
-  int o2 = luaK_exp2RK(fs, e2);
-  freeexp(fs, e2);
-  freeexp(fs, e1);
-  if (cond == 0 && op != OP_EQ) {
-    int temp;  /* exchange args to replace by `<' or `<=' */
-    temp = o1; o1 = o2; o2 = temp;  /* o1 <==> o2 */
-    cond = 1;
-  }
-  e1->u.s.info = condjump(fs, op, cond, o1, o2);
-  e1->k = VJMP;
-}
-
-
-void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {
-  expdesc e2;
-  e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
-  switch (op) {
-    case OPR_MINUS: {
-      if (!isnumeral(e))
-        luaK_exp2anyreg(fs, e);  /* cannot operate on non-numeric constants */
-      codearith(fs, OP_UNM, e, &e2);
-      break;
-    }
-    case OPR_NOT: codenot(fs, e); break;
-    case OPR_LEN: {
-      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */
-      codearith(fs, OP_LEN, e, &e2);
-      break;
-    }
-    default: lua_assert(0);
-  }
-}
-
-
-void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
-  switch (op) {
-    case OPR_AND: {
-      luaK_goiftrue(fs, v);
-      break;
-    }
-    case OPR_OR: {
-      luaK_goiffalse(fs, v);
-      break;
-    }
-    case OPR_CONCAT: {
-      luaK_exp2nextreg(fs, v);  /* operand must be on the `stack' */
-      break;
-    }
-    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
-    case OPR_MOD: case OPR_POW: {
-      if (!isnumeral(v)) luaK_exp2RK(fs, v);
-      break;
-    }
-    default: {
-      luaK_exp2RK(fs, v);
-      break;
-    }
-  }
-}
-
-
-void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
-  switch (op) {
-    case OPR_AND: {
-      lua_assert(e1->t == NO_JUMP);  /* list must be closed */
-      luaK_dischargevars(fs, e2);
-      luaK_concat(fs, &e2->f, e1->f);
-      *e1 = *e2;
-      break;
-    }
-    case OPR_OR: {
-      lua_assert(e1->f == NO_JUMP);  /* list must be closed */
-      luaK_dischargevars(fs, e2);
-      luaK_concat(fs, &e2->t, e1->t);
-      *e1 = *e2;
-      break;
-    }
-    case OPR_CONCAT: {
-      luaK_exp2val(fs, e2);
-      if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) {
-        lua_assert(e1->u.s.info == GETARG_B(getcode(fs, e2))-1);
-        freeexp(fs, e1);
-        SETARG_B(getcode(fs, e2), e1->u.s.info);
-        e1->k = VRELOCABLE; e1->u.s.info = e2->u.s.info;
-      }
-      else {
-        luaK_exp2nextreg(fs, e2);  /* operand must be on the 'stack' */
-        codearith(fs, OP_CONCAT, e1, e2);
-      }
-      break;
-    }
-    case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
-    case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
-    case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
-    case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
-    case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
-    case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
-    case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
-    case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
-    case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
-    case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
-    case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
-    case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
-    default: lua_assert(0);
-  }
-}
-
-
-void luaK_fixline (FuncState *fs, int line) {
-  fs->f->lineinfo[fs->pc - 1] = line;
-}
-
-
-static int luaK_code (FuncState *fs, Instruction i, int line) {
-  Proto *f = fs->f;
-  dischargejpc(fs);  /* `pc' will change */
-  /* put new instruction in code array */
-  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
-                  MAX_INT, "code size overflow");
-  f->code[fs->pc] = i;
-  /* save corresponding line information */
-  luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
-                  MAX_INT, "code size overflow");
-  f->lineinfo[fs->pc] = line;
-  return fs->pc++;
-}
-
-
-int luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c) {
-  lua_assert(getOpMode(o) == iABC);
-  lua_assert(getBMode(o) != OpArgN || b == 0);
-  lua_assert(getCMode(o) != OpArgN || c == 0);
-  return luaK_code(fs, CREATE_ABC(o, a, b, c), fs->ls->lastline);
-}
-
-
-int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) {
-  lua_assert(getOpMode(o) == iABx || getOpMode(o) == iAsBx);
-  lua_assert(getCMode(o) == OpArgN);
-  return luaK_code(fs, CREATE_ABx(o, a, bc), fs->ls->lastline);
-}
-
-
-void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
-  int c =  (nelems - 1)/LFIELDS_PER_FLUSH + 1;
-  int b = (tostore == LUA_MULTRET) ? 0 : tostore;
-  lua_assert(tostore != 0);
-  if (c <= MAXARG_C)
-    luaK_codeABC(fs, OP_SETLIST, base, b, c);
-  else {
-    luaK_codeABC(fs, OP_SETLIST, base, b, 0);
-    luaK_code(fs, cast(Instruction, c), fs->ls->lastline);
-  }
-  fs->freereg = base + 1;  /* free registers with list values */
-}
-
diff --git a/extern/lua-5.1.5/src/lcode.h b/extern/lua-5.1.5/src/lcode.h
deleted file mode 100644
index b941c607..00000000
--- a/extern/lua-5.1.5/src/lcode.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
-** $Id: lcode.h,v 1.48.1.1 2007/12/27 13:02:25 roberto Exp $
-** Code generator for Lua
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lcode_h
-#define lcode_h
-
-#include "llex.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lparser.h"
-
-
-/*
-** Marks the end of a patch list. It is an invalid value both as an absolute
-** address, and as a list link (would link an element to itself).
-*/
-#define NO_JUMP (-1)
-
-
-/*
-** grep "ORDER OPR" if you change these enums
-*/
-typedef enum BinOpr {
-  OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
-  OPR_CONCAT,
-  OPR_NE, OPR_EQ,
-  OPR_LT, OPR_LE, OPR_GT, OPR_GE,
-  OPR_AND, OPR_OR,
-  OPR_NOBINOPR
-} BinOpr;
-
-
-typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
-
-
-#define getcode(fs,e)	((fs)->f->code[(e)->u.s.info])
-
-#define luaK_codeAsBx(fs,o,A,sBx)	luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
-
-#define luaK_setmultret(fs,e)	luaK_setreturns(fs, e, LUA_MULTRET)
-
-LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
-LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
-LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
-LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
-LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
-LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
-LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
-LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r);
-LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
-LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
-LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
-LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
-LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
-LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
-LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
-LUAI_FUNC int luaK_jump (FuncState *fs);
-LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
-LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
-LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
-LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
-LUAI_FUNC int luaK_getlabel (FuncState *fs);
-LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v);
-LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
-LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2);
-LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
-
-
-#endif
diff --git a/extern/lua-5.1.5/src/ldblib.c b/extern/lua-5.1.5/src/ldblib.c
deleted file mode 100644
index 2027eda5..00000000
--- a/extern/lua-5.1.5/src/ldblib.c
+++ /dev/null
@@ -1,398 +0,0 @@
-/*
-** $Id: ldblib.c,v 1.104.1.4 2009/08/04 18:50:18 roberto Exp $
-** Interface from Lua to its debug API
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define ldblib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-
-static int db_getregistry (lua_State *L) {
-  lua_pushvalue(L, LUA_REGISTRYINDEX);
-  return 1;
-}
-
-
-static int db_getmetatable (lua_State *L) {
-  luaL_checkany(L, 1);
-  if (!lua_getmetatable(L, 1)) {
-    lua_pushnil(L);  /* no metatable */
-  }
-  return 1;
-}
-
-
-static int db_setmetatable (lua_State *L) {
-  int t = lua_type(L, 2);
-  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
-                    "nil or table expected");
-  lua_settop(L, 2);
-  lua_pushboolean(L, lua_setmetatable(L, 1));
-  return 1;
-}
-
-
-static int db_getfenv (lua_State *L) {
-  luaL_checkany(L, 1);
-  lua_getfenv(L, 1);
-  return 1;
-}
-
-
-static int db_setfenv (lua_State *L) {
-  luaL_checktype(L, 2, LUA_TTABLE);
-  lua_settop(L, 2);
-  if (lua_setfenv(L, 1) == 0)
-    luaL_error(L, LUA_QL("setfenv")
-                  " cannot change environment of given object");
-  return 1;
-}
-
-
-static void settabss (lua_State *L, const char *i, const char *v) {
-  lua_pushstring(L, v);
-  lua_setfield(L, -2, i);
-}
-
-
-static void settabsi (lua_State *L, const char *i, int v) {
-  lua_pushinteger(L, v);
-  lua_setfield(L, -2, i);
-}
-
-
-static lua_State *getthread (lua_State *L, int *arg) {
-  if (lua_isthread(L, 1)) {
-    *arg = 1;
-    return lua_tothread(L, 1);
-  }
-  else {
-    *arg = 0;
-    return L;
-  }
-}
-
-
-static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
-  if (L == L1) {
-    lua_pushvalue(L, -2);
-    lua_remove(L, -3);
-  }
-  else
-    lua_xmove(L1, L, 1);
-  lua_setfield(L, -2, fname);
-}
-
-
-static int db_getinfo (lua_State *L) {
-  lua_Debug ar;
-  int arg;
-  lua_State *L1 = getthread(L, &arg);
-  const char *options = luaL_optstring(L, arg+2, "flnSu");
-  if (lua_isnumber(L, arg+1)) {
-    if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) {
-      lua_pushnil(L);  /* level out of range */
-      return 1;
-    }
-  }
-  else if (lua_isfunction(L, arg+1)) {
-    lua_pushfstring(L, ">%s", options);
-    options = lua_tostring(L, -1);
-    lua_pushvalue(L, arg+1);
-    lua_xmove(L, L1, 1);
-  }
-  else
-    return luaL_argerror(L, arg+1, "function or level expected");
-  if (!lua_getinfo(L1, options, &ar))
-    return luaL_argerror(L, arg+2, "invalid option");
-  lua_createtable(L, 0, 2);
-  if (strchr(options, 'S')) {
-    settabss(L, "source", ar.source);
-    settabss(L, "short_src", ar.short_src);
-    settabsi(L, "linedefined", ar.linedefined);
-    settabsi(L, "lastlinedefined", ar.lastlinedefined);
-    settabss(L, "what", ar.what);
-  }
-  if (strchr(options, 'l'))
-    settabsi(L, "currentline", ar.currentline);
-  if (strchr(options, 'u'))
-    settabsi(L, "nups", ar.nups);
-  if (strchr(options, 'n')) {
-    settabss(L, "name", ar.name);
-    settabss(L, "namewhat", ar.namewhat);
-  }
-  if (strchr(options, 'L'))
-    treatstackoption(L, L1, "activelines");
-  if (strchr(options, 'f'))
-    treatstackoption(L, L1, "func");
-  return 1;  /* return table */
-}
-    
-
-static int db_getlocal (lua_State *L) {
-  int arg;
-  lua_State *L1 = getthread(L, &arg);
-  lua_Debug ar;
-  const char *name;
-  if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
-    return luaL_argerror(L, arg+1, "level out of range");
-  name = lua_getlocal(L1, &ar, luaL_checkint(L, arg+2));
-  if (name) {
-    lua_xmove(L1, L, 1);
-    lua_pushstring(L, name);
-    lua_pushvalue(L, -2);
-    return 2;
-  }
-  else {
-    lua_pushnil(L);
-    return 1;
-  }
-}
-
-
-static int db_setlocal (lua_State *L) {
-  int arg;
-  lua_State *L1 = getthread(L, &arg);
-  lua_Debug ar;
-  if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
-    return luaL_argerror(L, arg+1, "level out of range");
-  luaL_checkany(L, arg+3);
-  lua_settop(L, arg+3);
-  lua_xmove(L, L1, 1);
-  lua_pushstring(L, lua_setlocal(L1, &ar, luaL_checkint(L, arg+2)));
-  return 1;
-}
-
-
-static int auxupvalue (lua_State *L, int get) {
-  const char *name;
-  int n = luaL_checkint(L, 2);
-  luaL_checktype(L, 1, LUA_TFUNCTION);
-  if (lua_iscfunction(L, 1)) return 0;  /* cannot touch C upvalues from Lua */
-  name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
-  if (name == NULL) return 0;
-  lua_pushstring(L, name);
-  lua_insert(L, -(get+1));
-  return get + 1;
-}
-
-
-static int db_getupvalue (lua_State *L) {
-  return auxupvalue(L, 1);
-}
-
-
-static int db_setupvalue (lua_State *L) {
-  luaL_checkany(L, 3);
-  return auxupvalue(L, 0);
-}
-
-
-
-static const char KEY_HOOK = 'h';
-
-
-static void hookf (lua_State *L, lua_Debug *ar) {
-  static const char *const hooknames[] =
-    {"call", "return", "line", "count", "tail return"};
-  lua_pushlightuserdata(L, (void *)&KEY_HOOK);
-  lua_rawget(L, LUA_REGISTRYINDEX);
-  lua_pushlightuserdata(L, L);
-  lua_rawget(L, -2);
-  if (lua_isfunction(L, -1)) {
-    lua_pushstring(L, hooknames[(int)ar->event]);
-    if (ar->currentline >= 0)
-      lua_pushinteger(L, ar->currentline);
-    else lua_pushnil(L);
-    lua_assert(lua_getinfo(L, "lS", ar));
-    lua_call(L, 2, 0);
-  }
-}
-
-
-static int makemask (const char *smask, int count) {
-  int mask = 0;
-  if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
-  if (strchr(smask, 'r')) mask |= LUA_MASKRET;
-  if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
-  if (count > 0) mask |= LUA_MASKCOUNT;
-  return mask;
-}
-
-
-static char *unmakemask (int mask, char *smask) {
-  int i = 0;
-  if (mask & LUA_MASKCALL) smask[i++] = 'c';
-  if (mask & LUA_MASKRET) smask[i++] = 'r';
-  if (mask & LUA_MASKLINE) smask[i++] = 'l';
-  smask[i] = '\0';
-  return smask;
-}
-
-
-static void gethooktable (lua_State *L) {
-  lua_pushlightuserdata(L, (void *)&KEY_HOOK);
-  lua_rawget(L, LUA_REGISTRYINDEX);
-  if (!lua_istable(L, -1)) {
-    lua_pop(L, 1);
-    lua_createtable(L, 0, 1);
-    lua_pushlightuserdata(L, (void *)&KEY_HOOK);
-    lua_pushvalue(L, -2);
-    lua_rawset(L, LUA_REGISTRYINDEX);
-  }
-}
-
-
-static int db_sethook (lua_State *L) {
-  int arg, mask, count;
-  lua_Hook func;
-  lua_State *L1 = getthread(L, &arg);
-  if (lua_isnoneornil(L, arg+1)) {
-    lua_settop(L, arg+1);
-    func = NULL; mask = 0; count = 0;  /* turn off hooks */
-  }
-  else {
-    const char *smask = luaL_checkstring(L, arg+2);
-    luaL_checktype(L, arg+1, LUA_TFUNCTION);
-    count = luaL_optint(L, arg+3, 0);
-    func = hookf; mask = makemask(smask, count);
-  }
-  gethooktable(L);
-  lua_pushlightuserdata(L, L1);
-  lua_pushvalue(L, arg+1);
-  lua_rawset(L, -3);  /* set new hook */
-  lua_pop(L, 1);  /* remove hook table */
-  lua_sethook(L1, func, mask, count);  /* set hooks */
-  return 0;
-}
-
-
-static int db_gethook (lua_State *L) {
-  int arg;
-  lua_State *L1 = getthread(L, &arg);
-  char buff[5];
-  int mask = lua_gethookmask(L1);
-  lua_Hook hook = lua_gethook(L1);
-  if (hook != NULL && hook != hookf)  /* external hook? */
-    lua_pushliteral(L, "external hook");
-  else {
-    gethooktable(L);
-    lua_pushlightuserdata(L, L1);
-    lua_rawget(L, -2);   /* get hook */
-    lua_remove(L, -2);  /* remove hook table */
-  }
-  lua_pushstring(L, unmakemask(mask, buff));
-  lua_pushinteger(L, lua_gethookcount(L1));
-  return 3;
-}
-
-
-static int db_debug (lua_State *L) {
-  for (;;) {
-    char buffer[250];
-    fputs("lua_debug> ", stderr);
-    if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
-        strcmp(buffer, "cont\n") == 0)
-      return 0;
-    if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
-        lua_pcall(L, 0, 0, 0)) {
-      fputs(lua_tostring(L, -1), stderr);
-      fputs("\n", stderr);
-    }
-    lua_settop(L, 0);  /* remove eventual returns */
-  }
-}
-
-
-#define LEVELS1	12	/* size of the first part of the stack */
-#define LEVELS2	10	/* size of the second part of the stack */
-
-static int db_errorfb (lua_State *L) {
-  int level;
-  int firstpart = 1;  /* still before eventual `...' */
-  int arg;
-  lua_State *L1 = getthread(L, &arg);
-  lua_Debug ar;
-  if (lua_isnumber(L, arg+2)) {
-    level = (int)lua_tointeger(L, arg+2);
-    lua_pop(L, 1);
-  }
-  else
-    level = (L == L1) ? 1 : 0;  /* level 0 may be this own function */
-  if (lua_gettop(L) == arg)
-    lua_pushliteral(L, "");
-  else if (!lua_isstring(L, arg+1)) return 1;  /* message is not a string */
-  else lua_pushliteral(L, "\n");
-  lua_pushliteral(L, "stack traceback:");
-  while (lua_getstack(L1, level++, &ar)) {
-    if (level > LEVELS1 && firstpart) {
-      /* no more than `LEVELS2' more levels? */
-      if (!lua_getstack(L1, level+LEVELS2, &ar))
-        level--;  /* keep going */
-      else {
-        lua_pushliteral(L, "\n\t...");  /* too many levels */
-        while (lua_getstack(L1, level+LEVELS2, &ar))  /* find last levels */
-          level++;
-      }
-      firstpart = 0;
-      continue;
-    }
-    lua_pushliteral(L, "\n\t");
-    lua_getinfo(L1, "Snl", &ar);
-    lua_pushfstring(L, "%s:", ar.short_src);
-    if (ar.currentline > 0)
-      lua_pushfstring(L, "%d:", ar.currentline);
-    if (*ar.namewhat != '\0')  /* is there a name? */
-        lua_pushfstring(L, " in function " LUA_QS, ar.name);
-    else {
-      if (*ar.what == 'm')  /* main? */
-        lua_pushfstring(L, " in main chunk");
-      else if (*ar.what == 'C' || *ar.what == 't')
-        lua_pushliteral(L, " ?");  /* C function or tail call */
-      else
-        lua_pushfstring(L, " in function <%s:%d>",
-                           ar.short_src, ar.linedefined);
-    }
-    lua_concat(L, lua_gettop(L) - arg);
-  }
-  lua_concat(L, lua_gettop(L) - arg);
-  return 1;
-}
-
-
-static const luaL_Reg dblib[] = {
-  {"debug", db_debug},
-  {"getfenv", db_getfenv},
-  {"gethook", db_gethook},
-  {"getinfo", db_getinfo},
-  {"getlocal", db_getlocal},
-  {"getregistry", db_getregistry},
-  {"getmetatable", db_getmetatable},
-  {"getupvalue", db_getupvalue},
-  {"setfenv", db_setfenv},
-  {"sethook", db_sethook},
-  {"setlocal", db_setlocal},
-  {"setmetatable", db_setmetatable},
-  {"setupvalue", db_setupvalue},
-  {"traceback", db_errorfb},
-  {NULL, NULL}
-};
-
-
-LUALIB_API int luaopen_debug (lua_State *L) {
-  luaL_register(L, LUA_DBLIBNAME, dblib);
-  return 1;
-}
-
diff --git a/extern/lua-5.1.5/src/ldebug.c b/extern/lua-5.1.5/src/ldebug.c
deleted file mode 100644
index 50ad3d38..00000000
--- a/extern/lua-5.1.5/src/ldebug.c
+++ /dev/null
@@ -1,638 +0,0 @@
-/*
-** $Id: ldebug.c,v 2.29.1.6 2008/05/08 16:56:26 roberto Exp $
-** Debug Interface
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stdarg.h>
-#include <stddef.h>
-#include <string.h>
-
-
-#define ldebug_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lapi.h"
-#include "lcode.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-#include "lvm.h"
-
-
-
-static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name);
-
-
-static int currentpc (lua_State *L, CallInfo *ci) {
-  if (!isLua(ci)) return -1;  /* function is not a Lua function? */
-  if (ci == L->ci)
-    ci->savedpc = L->savedpc;
-  return pcRel(ci->savedpc, ci_func(ci)->l.p);
-}
-
-
-static int currentline (lua_State *L, CallInfo *ci) {
-  int pc = currentpc(L, ci);
-  if (pc < 0)
-    return -1;  /* only active lua functions have current-line information */
-  else
-    return getline(ci_func(ci)->l.p, pc);
-}
-
-
-/*
-** this function can be called asynchronous (e.g. during a signal)
-*/
-LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
-  if (func == NULL || mask == 0) {  /* turn off hooks? */
-    mask = 0;
-    func = NULL;
-  }
-  L->hook = func;
-  L->basehookcount = count;
-  resethookcount(L);
-  L->hookmask = cast_byte(mask);
-  return 1;
-}
-
-
-LUA_API lua_Hook lua_gethook (lua_State *L) {
-  return L->hook;
-}
-
-
-LUA_API int lua_gethookmask (lua_State *L) {
-  return L->hookmask;
-}
-
-
-LUA_API int lua_gethookcount (lua_State *L) {
-  return L->basehookcount;
-}
-
-
-LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
-  int status;
-  CallInfo *ci;
-  lua_lock(L);
-  for (ci = L->ci; level > 0 && ci > L->base_ci; ci--) {
-    level--;
-    if (f_isLua(ci))  /* Lua function? */
-      level -= ci->tailcalls;  /* skip lost tail calls */
-  }
-  if (level == 0 && ci > L->base_ci) {  /* level found? */
-    status = 1;
-    ar->i_ci = cast_int(ci - L->base_ci);
-  }
-  else if (level < 0) {  /* level is of a lost tail call? */
-    status = 1;
-    ar->i_ci = 0;
-  }
-  else status = 0;  /* no such level */
-  lua_unlock(L);
-  return status;
-}
-
-
-static Proto *getluaproto (CallInfo *ci) {
-  return (isLua(ci) ? ci_func(ci)->l.p : NULL);
-}
-
-
-static const char *findlocal (lua_State *L, CallInfo *ci, int n) {
-  const char *name;
-  Proto *fp = getluaproto(ci);
-  if (fp && (name = luaF_getlocalname(fp, n, currentpc(L, ci))) != NULL)
-    return name;  /* is a local variable in a Lua function */
-  else {
-    StkId limit = (ci == L->ci) ? L->top : (ci+1)->func;
-    if (limit - ci->base >= n && n > 0)  /* is 'n' inside 'ci' stack? */
-      return "(*temporary)";
-    else
-      return NULL;
-  }
-}
-
-
-LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
-  CallInfo *ci = L->base_ci + ar->i_ci;
-  const char *name = findlocal(L, ci, n);
-  lua_lock(L);
-  if (name)
-      luaA_pushobject(L, ci->base + (n - 1));
-  lua_unlock(L);
-  return name;
-}
-
-
-LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
-  CallInfo *ci = L->base_ci + ar->i_ci;
-  const char *name = findlocal(L, ci, n);
-  lua_lock(L);
-  if (name)
-      setobjs2s(L, ci->base + (n - 1), L->top - 1);
-  L->top--;  /* pop value */
-  lua_unlock(L);
-  return name;
-}
-
-
-static void funcinfo (lua_Debug *ar, Closure *cl) {
-  if (cl->c.isC) {
-    ar->source = "=[C]";
-    ar->linedefined = -1;
-    ar->lastlinedefined = -1;
-    ar->what = "C";
-  }
-  else {
-    ar->source = getstr(cl->l.p->source);
-    ar->linedefined = cl->l.p->linedefined;
-    ar->lastlinedefined = cl->l.p->lastlinedefined;
-    ar->what = (ar->linedefined == 0) ? "main" : "Lua";
-  }
-  luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
-}
-
-
-static void info_tailcall (lua_Debug *ar) {
-  ar->name = ar->namewhat = "";
-  ar->what = "tail";
-  ar->lastlinedefined = ar->linedefined = ar->currentline = -1;
-  ar->source = "=(tail call)";
-  luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
-  ar->nups = 0;
-}
-
-
-static void collectvalidlines (lua_State *L, Closure *f) {
-  if (f == NULL || f->c.isC) {
-    setnilvalue(L->top);
-  }
-  else {
-    Table *t = luaH_new(L, 0, 0);
-    int *lineinfo = f->l.p->lineinfo;
-    int i;
-    for (i=0; i<f->l.p->sizelineinfo; i++)
-      setbvalue(luaH_setnum(L, t, lineinfo[i]), 1);
-    sethvalue(L, L->top, t); 
-  }
-  incr_top(L);
-}
-
-
-static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,
-                    Closure *f, CallInfo *ci) {
-  int status = 1;
-  if (f == NULL) {
-    info_tailcall(ar);
-    return status;
-  }
-  for (; *what; what++) {
-    switch (*what) {
-      case 'S': {
-        funcinfo(ar, f);
-        break;
-      }
-      case 'l': {
-        ar->currentline = (ci) ? currentline(L, ci) : -1;
-        break;
-      }
-      case 'u': {
-        ar->nups = f->c.nupvalues;
-        break;
-      }
-      case 'n': {
-        ar->namewhat = (ci) ? getfuncname(L, ci, &ar->name) : NULL;
-        if (ar->namewhat == NULL) {
-          ar->namewhat = "";  /* not found */
-          ar->name = NULL;
-        }
-        break;
-      }
-      case 'L':
-      case 'f':  /* handled by lua_getinfo */
-        break;
-      default: status = 0;  /* invalid option */
-    }
-  }
-  return status;
-}
-
-
-LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
-  int status;
-  Closure *f = NULL;
-  CallInfo *ci = NULL;
-  lua_lock(L);
-  if (*what == '>') {
-    StkId func = L->top - 1;
-    luai_apicheck(L, ttisfunction(func));
-    what++;  /* skip the '>' */
-    f = clvalue(func);
-    L->top--;  /* pop function */
-  }
-  else if (ar->i_ci != 0) {  /* no tail call? */
-    ci = L->base_ci + ar->i_ci;
-    lua_assert(ttisfunction(ci->func));
-    f = clvalue(ci->func);
-  }
-  status = auxgetinfo(L, what, ar, f, ci);
-  if (strchr(what, 'f')) {
-    if (f == NULL) setnilvalue(L->top);
-    else setclvalue(L, L->top, f);
-    incr_top(L);
-  }
-  if (strchr(what, 'L'))
-    collectvalidlines(L, f);
-  lua_unlock(L);
-  return status;
-}
-
-
-/*
-** {======================================================
-** Symbolic Execution and code checker
-** =======================================================
-*/
-
-#define check(x)		if (!(x)) return 0;
-
-#define checkjump(pt,pc)	check(0 <= pc && pc < pt->sizecode)
-
-#define checkreg(pt,reg)	check((reg) < (pt)->maxstacksize)
-
-
-
-static int precheck (const Proto *pt) {
-  check(pt->maxstacksize <= MAXSTACK);
-  check(pt->numparams+(pt->is_vararg & VARARG_HASARG) <= pt->maxstacksize);
-  check(!(pt->is_vararg & VARARG_NEEDSARG) ||
-              (pt->is_vararg & VARARG_HASARG));
-  check(pt->sizeupvalues <= pt->nups);
-  check(pt->sizelineinfo == pt->sizecode || pt->sizelineinfo == 0);
-  check(pt->sizecode > 0 && GET_OPCODE(pt->code[pt->sizecode-1]) == OP_RETURN);
-  return 1;
-}
-
-
-#define checkopenop(pt,pc)	luaG_checkopenop((pt)->code[(pc)+1])
-
-int luaG_checkopenop (Instruction i) {
-  switch (GET_OPCODE(i)) {
-    case OP_CALL:
-    case OP_TAILCALL:
-    case OP_RETURN:
-    case OP_SETLIST: {
-      check(GETARG_B(i) == 0);
-      return 1;
-    }
-    default: return 0;  /* invalid instruction after an open call */
-  }
-}
-
-
-static int checkArgMode (const Proto *pt, int r, enum OpArgMask mode) {
-  switch (mode) {
-    case OpArgN: check(r == 0); break;
-    case OpArgU: break;
-    case OpArgR: checkreg(pt, r); break;
-    case OpArgK:
-      check(ISK(r) ? INDEXK(r) < pt->sizek : r < pt->maxstacksize);
-      break;
-  }
-  return 1;
-}
-
-
-static Instruction symbexec (const Proto *pt, int lastpc, int reg) {
-  int pc;
-  int last;  /* stores position of last instruction that changed `reg' */
-  last = pt->sizecode-1;  /* points to final return (a `neutral' instruction) */
-  check(precheck(pt));
-  for (pc = 0; pc < lastpc; pc++) {
-    Instruction i = pt->code[pc];
-    OpCode op = GET_OPCODE(i);
-    int a = GETARG_A(i);
-    int b = 0;
-    int c = 0;
-    check(op < NUM_OPCODES);
-    checkreg(pt, a);
-    switch (getOpMode(op)) {
-      case iABC: {
-        b = GETARG_B(i);
-        c = GETARG_C(i);
-        check(checkArgMode(pt, b, getBMode(op)));
-        check(checkArgMode(pt, c, getCMode(op)));
-        break;
-      }
-      case iABx: {
-        b = GETARG_Bx(i);
-        if (getBMode(op) == OpArgK) check(b < pt->sizek);
-        break;
-      }
-      case iAsBx: {
-        b = GETARG_sBx(i);
-        if (getBMode(op) == OpArgR) {
-          int dest = pc+1+b;
-          check(0 <= dest && dest < pt->sizecode);
-          if (dest > 0) {
-            int j;
-            /* check that it does not jump to a setlist count; this
-               is tricky, because the count from a previous setlist may
-               have the same value of an invalid setlist; so, we must
-               go all the way back to the first of them (if any) */
-            for (j = 0; j < dest; j++) {
-              Instruction d = pt->code[dest-1-j];
-              if (!(GET_OPCODE(d) == OP_SETLIST && GETARG_C(d) == 0)) break;
-            }
-            /* if 'j' is even, previous value is not a setlist (even if
-               it looks like one) */
-            check((j&1) == 0);
-          }
-        }
-        break;
-      }
-    }
-    if (testAMode(op)) {
-      if (a == reg) last = pc;  /* change register `a' */
-    }
-    if (testTMode(op)) {
-      check(pc+2 < pt->sizecode);  /* check skip */
-      check(GET_OPCODE(pt->code[pc+1]) == OP_JMP);
-    }
-    switch (op) {
-      case OP_LOADBOOL: {
-        if (c == 1) {  /* does it jump? */
-          check(pc+2 < pt->sizecode);  /* check its jump */
-          check(GET_OPCODE(pt->code[pc+1]) != OP_SETLIST ||
-                GETARG_C(pt->code[pc+1]) != 0);
-        }
-        break;
-      }
-      case OP_LOADNIL: {
-        if (a <= reg && reg <= b)
-          last = pc;  /* set registers from `a' to `b' */
-        break;
-      }
-      case OP_GETUPVAL:
-      case OP_SETUPVAL: {
-        check(b < pt->nups);
-        break;
-      }
-      case OP_GETGLOBAL:
-      case OP_SETGLOBAL: {
-        check(ttisstring(&pt->k[b]));
-        break;
-      }
-      case OP_SELF: {
-        checkreg(pt, a+1);
-        if (reg == a+1) last = pc;
-        break;
-      }
-      case OP_CONCAT: {
-        check(b < c);  /* at least two operands */
-        break;
-      }
-      case OP_TFORLOOP: {
-        check(c >= 1);  /* at least one result (control variable) */
-        checkreg(pt, a+2+c);  /* space for results */
-        if (reg >= a+2) last = pc;  /* affect all regs above its base */
-        break;
-      }
-      case OP_FORLOOP:
-      case OP_FORPREP:
-        checkreg(pt, a+3);
-        /* go through */
-      case OP_JMP: {
-        int dest = pc+1+b;
-        /* not full check and jump is forward and do not skip `lastpc'? */
-        if (reg != NO_REG && pc < dest && dest <= lastpc)
-          pc += b;  /* do the jump */
-        break;
-      }
-      case OP_CALL:
-      case OP_TAILCALL: {
-        if (b != 0) {
-          checkreg(pt, a+b-1);
-        }
-        c--;  /* c = num. returns */
-        if (c == LUA_MULTRET) {
-          check(checkopenop(pt, pc));
-        }
-        else if (c != 0)
-          checkreg(pt, a+c-1);
-        if (reg >= a) last = pc;  /* affect all registers above base */
-        break;
-      }
-      case OP_RETURN: {
-        b--;  /* b = num. returns */
-        if (b > 0) checkreg(pt, a+b-1);
-        break;
-      }
-      case OP_SETLIST: {
-        if (b > 0) checkreg(pt, a + b);
-        if (c == 0) {
-          pc++;
-          check(pc < pt->sizecode - 1);
-        }
-        break;
-      }
-      case OP_CLOSURE: {
-        int nup, j;
-        check(b < pt->sizep);
-        nup = pt->p[b]->nups;
-        check(pc + nup < pt->sizecode);
-        for (j = 1; j <= nup; j++) {
-          OpCode op1 = GET_OPCODE(pt->code[pc + j]);
-          check(op1 == OP_GETUPVAL || op1 == OP_MOVE);
-        }
-        if (reg != NO_REG)  /* tracing? */
-          pc += nup;  /* do not 'execute' these pseudo-instructions */
-        break;
-      }
-      case OP_VARARG: {
-        check((pt->is_vararg & VARARG_ISVARARG) &&
-             !(pt->is_vararg & VARARG_NEEDSARG));
-        b--;
-        if (b == LUA_MULTRET) check(checkopenop(pt, pc));
-        checkreg(pt, a+b-1);
-        break;
-      }
-      default: break;
-    }
-  }
-  return pt->code[last];
-}
-
-#undef check
-#undef checkjump
-#undef checkreg
-
-/* }====================================================== */
-
-
-int luaG_checkcode (const Proto *pt) {
-  return (symbexec(pt, pt->sizecode, NO_REG) != 0);
-}
-
-
-static const char *kname (Proto *p, int c) {
-  if (ISK(c) && ttisstring(&p->k[INDEXK(c)]))
-    return svalue(&p->k[INDEXK(c)]);
-  else
-    return "?";
-}
-
-
-static const char *getobjname (lua_State *L, CallInfo *ci, int stackpos,
-                               const char **name) {
-  if (isLua(ci)) {  /* a Lua function? */
-    Proto *p = ci_func(ci)->l.p;
-    int pc = currentpc(L, ci);
-    Instruction i;
-    *name = luaF_getlocalname(p, stackpos+1, pc);
-    if (*name)  /* is a local? */
-      return "local";
-    i = symbexec(p, pc, stackpos);  /* try symbolic execution */
-    lua_assert(pc != -1);
-    switch (GET_OPCODE(i)) {
-      case OP_GETGLOBAL: {
-        int g = GETARG_Bx(i);  /* global index */
-        lua_assert(ttisstring(&p->k[g]));
-        *name = svalue(&p->k[g]);
-        return "global";
-      }
-      case OP_MOVE: {
-        int a = GETARG_A(i);
-        int b = GETARG_B(i);  /* move from `b' to `a' */
-        if (b < a)
-          return getobjname(L, ci, b, name);  /* get name for `b' */
-        break;
-      }
-      case OP_GETTABLE: {
-        int k = GETARG_C(i);  /* key index */
-        *name = kname(p, k);
-        return "field";
-      }
-      case OP_GETUPVAL: {
-        int u = GETARG_B(i);  /* upvalue index */
-        *name = p->upvalues ? getstr(p->upvalues[u]) : "?";
-        return "upvalue";
-      }
-      case OP_SELF: {
-        int k = GETARG_C(i);  /* key index */
-        *name = kname(p, k);
-        return "method";
-      }
-      default: break;
-    }
-  }
-  return NULL;  /* no useful name found */
-}
-
-
-static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
-  Instruction i;
-  if ((isLua(ci) && ci->tailcalls > 0) || !isLua(ci - 1))
-    return NULL;  /* calling function is not Lua (or is unknown) */
-  ci--;  /* calling function */
-  i = ci_func(ci)->l.p->code[currentpc(L, ci)];
-  if (GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||
-      GET_OPCODE(i) == OP_TFORLOOP)
-    return getobjname(L, ci, GETARG_A(i), name);
-  else
-    return NULL;  /* no useful name can be found */
-}
-
-
-/* only ANSI way to check whether a pointer points to an array */
-static int isinstack (CallInfo *ci, const TValue *o) {
-  StkId p;
-  for (p = ci->base; p < ci->top; p++)
-    if (o == p) return 1;
-  return 0;
-}
-
-
-void luaG_typeerror (lua_State *L, const TValue *o, const char *op) {
-  const char *name = NULL;
-  const char *t = luaT_typenames[ttype(o)];
-  const char *kind = (isinstack(L->ci, o)) ?
-                         getobjname(L, L->ci, cast_int(o - L->base), &name) :
-                         NULL;
-  if (kind)
-    luaG_runerror(L, "attempt to %s %s " LUA_QS " (a %s value)",
-                op, kind, name, t);
-  else
-    luaG_runerror(L, "attempt to %s a %s value", op, t);
-}
-
-
-void luaG_concaterror (lua_State *L, StkId p1, StkId p2) {
-  if (ttisstring(p1) || ttisnumber(p1)) p1 = p2;
-  lua_assert(!ttisstring(p1) && !ttisnumber(p1));
-  luaG_typeerror(L, p1, "concatenate");
-}
-
-
-void luaG_aritherror (lua_State *L, const TValue *p1, const TValue *p2) {
-  TValue temp;
-  if (luaV_tonumber(p1, &temp) == NULL)
-    p2 = p1;  /* first operand is wrong */
-  luaG_typeerror(L, p2, "perform arithmetic on");
-}
-
-
-int luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
-  const char *t1 = luaT_typenames[ttype(p1)];
-  const char *t2 = luaT_typenames[ttype(p2)];
-  if (t1[2] == t2[2])
-    luaG_runerror(L, "attempt to compare two %s values", t1);
-  else
-    luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
-  return 0;
-}
-
-
-static void addinfo (lua_State *L, const char *msg) {
-  CallInfo *ci = L->ci;
-  if (isLua(ci)) {  /* is Lua code? */
-    char buff[LUA_IDSIZE];  /* add file:line information */
-    int line = currentline(L, ci);
-    luaO_chunkid(buff, getstr(getluaproto(ci)->source), LUA_IDSIZE);
-    luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);
-  }
-}
-
-
-void luaG_errormsg (lua_State *L) {
-  if (L->errfunc != 0) {  /* is there an error handling function? */
-    StkId errfunc = restorestack(L, L->errfunc);
-    if (!ttisfunction(errfunc)) luaD_throw(L, LUA_ERRERR);
-    setobjs2s(L, L->top, L->top - 1);  /* move argument */
-    setobjs2s(L, L->top - 1, errfunc);  /* push function */
-    incr_top(L);
-    luaD_call(L, L->top - 2, 1);  /* call it */
-  }
-  luaD_throw(L, LUA_ERRRUN);
-}
-
-
-void luaG_runerror (lua_State *L, const char *fmt, ...) {
-  va_list argp;
-  va_start(argp, fmt);
-  addinfo(L, luaO_pushvfstring(L, fmt, argp));
-  va_end(argp);
-  luaG_errormsg(L);
-}
-
diff --git a/extern/lua-5.1.5/src/ldebug.h b/extern/lua-5.1.5/src/ldebug.h
deleted file mode 100644
index ba28a972..00000000
--- a/extern/lua-5.1.5/src/ldebug.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
-** $Id: ldebug.h,v 2.3.1.1 2007/12/27 13:02:25 roberto Exp $
-** Auxiliary functions from Debug Interface module
-** See Copyright Notice in lua.h
-*/
-
-#ifndef ldebug_h
-#define ldebug_h
-
-
-#include "lstate.h"
-
-
-#define pcRel(pc, p)	(cast(int, (pc) - (p)->code) - 1)
-
-#define getline(f,pc)	(((f)->lineinfo) ? (f)->lineinfo[pc] : 0)
-
-#define resethookcount(L)	(L->hookcount = L->basehookcount)
-
-
-LUAI_FUNC void luaG_typeerror (lua_State *L, const TValue *o,
-                                             const char *opname);
-LUAI_FUNC void luaG_concaterror (lua_State *L, StkId p1, StkId p2);
-LUAI_FUNC void luaG_aritherror (lua_State *L, const TValue *p1,
-                                              const TValue *p2);
-LUAI_FUNC int luaG_ordererror (lua_State *L, const TValue *p1,
-                                             const TValue *p2);
-LUAI_FUNC void luaG_runerror (lua_State *L, const char *fmt, ...);
-LUAI_FUNC void luaG_errormsg (lua_State *L);
-LUAI_FUNC int luaG_checkcode (const Proto *pt);
-LUAI_FUNC int luaG_checkopenop (Instruction i);
-
-#endif
diff --git a/extern/lua-5.1.5/src/ldo.c b/extern/lua-5.1.5/src/ldo.c
deleted file mode 100644
index d1bf786c..00000000
--- a/extern/lua-5.1.5/src/ldo.c
+++ /dev/null
@@ -1,519 +0,0 @@
-/*
-** $Id: ldo.c,v 2.38.1.4 2012/01/18 02:27:10 roberto Exp $
-** Stack and Call structure of Lua
-** See Copyright Notice in lua.h
-*/
-
-
-#include <setjmp.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define ldo_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lparser.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-#include "lundump.h"
-#include "lvm.h"
-#include "lzio.h"
-
-
-
-
-/*
-** {======================================================
-** Error-recovery functions
-** =======================================================
-*/
-
-
-/* chain list of long jump buffers */
-struct lua_longjmp {
-  struct lua_longjmp *previous;
-  luai_jmpbuf b;
-  volatile int status;  /* error code */
-};
-
-
-void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) {
-  switch (errcode) {
-    case LUA_ERRMEM: {
-      setsvalue2s(L, oldtop, luaS_newliteral(L, MEMERRMSG));
-      break;
-    }
-    case LUA_ERRERR: {
-      setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
-      break;
-    }
-    case LUA_ERRSYNTAX:
-    case LUA_ERRRUN: {
-      setobjs2s(L, oldtop, L->top - 1);  /* error message on current top */
-      break;
-    }
-  }
-  L->top = oldtop + 1;
-}
-
-
-static void restore_stack_limit (lua_State *L) {
-  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
-  if (L->size_ci > LUAI_MAXCALLS) {  /* there was an overflow? */
-    int inuse = cast_int(L->ci - L->base_ci);
-    if (inuse + 1 < LUAI_MAXCALLS)  /* can `undo' overflow? */
-      luaD_reallocCI(L, LUAI_MAXCALLS);
-  }
-}
-
-
-static void resetstack (lua_State *L, int status) {
-  L->ci = L->base_ci;
-  L->base = L->ci->base;
-  luaF_close(L, L->base);  /* close eventual pending closures */
-  luaD_seterrorobj(L, status, L->base);
-  L->nCcalls = L->baseCcalls;
-  L->allowhook = 1;
-  restore_stack_limit(L);
-  L->errfunc = 0;
-  L->errorJmp = NULL;
-}
-
-
-void luaD_throw (lua_State *L, int errcode) {
-  if (L->errorJmp) {
-    L->errorJmp->status = errcode;
-    LUAI_THROW(L, L->errorJmp);
-  }
-  else {
-    L->status = cast_byte(errcode);
-    if (G(L)->panic) {
-      resetstack(L, errcode);
-      lua_unlock(L);
-      G(L)->panic(L);
-    }
-    exit(EXIT_FAILURE);
-  }
-}
-
-
-int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
-  struct lua_longjmp lj;
-  lj.status = 0;
-  lj.previous = L->errorJmp;  /* chain new error handler */
-  L->errorJmp = &lj;
-  LUAI_TRY(L, &lj,
-    (*f)(L, ud);
-  );
-  L->errorJmp = lj.previous;  /* restore old error handler */
-  return lj.status;
-}
-
-/* }====================================================== */
-
-
-static void correctstack (lua_State *L, TValue *oldstack) {
-  CallInfo *ci;
-  GCObject *up;
-  L->top = (L->top - oldstack) + L->stack;
-  for (up = L->openupval; up != NULL; up = up->gch.next)
-    gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack;
-  for (ci = L->base_ci; ci <= L->ci; ci++) {
-    ci->top = (ci->top - oldstack) + L->stack;
-    ci->base = (ci->base - oldstack) + L->stack;
-    ci->func = (ci->func - oldstack) + L->stack;
-  }
-  L->base = (L->base - oldstack) + L->stack;
-}
-
-
-void luaD_reallocstack (lua_State *L, int newsize) {
-  TValue *oldstack = L->stack;
-  int realsize = newsize + 1 + EXTRA_STACK;
-  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
-  luaM_reallocvector(L, L->stack, L->stacksize, realsize, TValue);
-  L->stacksize = realsize;
-  L->stack_last = L->stack+newsize;
-  correctstack(L, oldstack);
-}
-
-
-void luaD_reallocCI (lua_State *L, int newsize) {
-  CallInfo *oldci = L->base_ci;
-  luaM_reallocvector(L, L->base_ci, L->size_ci, newsize, CallInfo);
-  L->size_ci = newsize;
-  L->ci = (L->ci - oldci) + L->base_ci;
-  L->end_ci = L->base_ci + L->size_ci - 1;
-}
-
-
-void luaD_growstack (lua_State *L, int n) {
-  if (n <= L->stacksize)  /* double size is enough? */
-    luaD_reallocstack(L, 2*L->stacksize);
-  else
-    luaD_reallocstack(L, L->stacksize + n);
-}
-
-
-static CallInfo *growCI (lua_State *L) {
-  if (L->size_ci > LUAI_MAXCALLS)  /* overflow while handling overflow? */
-    luaD_throw(L, LUA_ERRERR);
-  else {
-    luaD_reallocCI(L, 2*L->size_ci);
-    if (L->size_ci > LUAI_MAXCALLS)
-      luaG_runerror(L, "stack overflow");
-  }
-  return ++L->ci;
-}
-
-
-void luaD_callhook (lua_State *L, int event, int line) {
-  lua_Hook hook = L->hook;
-  if (hook && L->allowhook) {
-    ptrdiff_t top = savestack(L, L->top);
-    ptrdiff_t ci_top = savestack(L, L->ci->top);
-    lua_Debug ar;
-    ar.event = event;
-    ar.currentline = line;
-    if (event == LUA_HOOKTAILRET)
-      ar.i_ci = 0;  /* tail call; no debug information about it */
-    else
-      ar.i_ci = cast_int(L->ci - L->base_ci);
-    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
-    L->ci->top = L->top + LUA_MINSTACK;
-    lua_assert(L->ci->top <= L->stack_last);
-    L->allowhook = 0;  /* cannot call hooks inside a hook */
-    lua_unlock(L);
-    (*hook)(L, &ar);
-    lua_lock(L);
-    lua_assert(!L->allowhook);
-    L->allowhook = 1;
-    L->ci->top = restorestack(L, ci_top);
-    L->top = restorestack(L, top);
-  }
-}
-
-
-static StkId adjust_varargs (lua_State *L, Proto *p, int actual) {
-  int i;
-  int nfixargs = p->numparams;
-  Table *htab = NULL;
-  StkId base, fixed;
-  for (; actual < nfixargs; ++actual)
-    setnilvalue(L->top++);
-#if defined(LUA_COMPAT_VARARG)
-  if (p->is_vararg & VARARG_NEEDSARG) { /* compat. with old-style vararg? */
-    int nvar = actual - nfixargs;  /* number of extra arguments */
-    lua_assert(p->is_vararg & VARARG_HASARG);
-    luaC_checkGC(L);
-    luaD_checkstack(L, p->maxstacksize);
-    htab = luaH_new(L, nvar, 1);  /* create `arg' table */
-    for (i=0; i<nvar; i++)  /* put extra arguments into `arg' table */
-      setobj2n(L, luaH_setnum(L, htab, i+1), L->top - nvar + i);
-    /* store counter in field `n' */
-    setnvalue(luaH_setstr(L, htab, luaS_newliteral(L, "n")), cast_num(nvar));
-  }
-#endif
-  /* move fixed parameters to final position */
-  fixed = L->top - actual;  /* first fixed argument */
-  base = L->top;  /* final position of first argument */
-  for (i=0; i<nfixargs; i++) {
-    setobjs2s(L, L->top++, fixed+i);
-    setnilvalue(fixed+i);
-  }
-  /* add `arg' parameter */
-  if (htab) {
-    sethvalue(L, L->top++, htab);
-    lua_assert(iswhite(obj2gco(htab)));
-  }
-  return base;
-}
-
-
-static StkId tryfuncTM (lua_State *L, StkId func) {
-  const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL);
-  StkId p;
-  ptrdiff_t funcr = savestack(L, func);
-  if (!ttisfunction(tm))
-    luaG_typeerror(L, func, "call");
-  /* Open a hole inside the stack at `func' */
-  for (p = L->top; p > func; p--) setobjs2s(L, p, p-1);
-  incr_top(L);
-  func = restorestack(L, funcr);  /* previous call may change stack */
-  setobj2s(L, func, tm);  /* tag method is the new function to be called */
-  return func;
-}
-
-
-
-#define inc_ci(L) \
-  ((L->ci == L->end_ci) ? growCI(L) : \
-   (condhardstacktests(luaD_reallocCI(L, L->size_ci)), ++L->ci))
-
-
-int luaD_precall (lua_State *L, StkId func, int nresults) {
-  LClosure *cl;
-  ptrdiff_t funcr;
-  if (!ttisfunction(func)) /* `func' is not a function? */
-    func = tryfuncTM(L, func);  /* check the `function' tag method */
-  funcr = savestack(L, func);
-  cl = &clvalue(func)->l;
-  L->ci->savedpc = L->savedpc;
-  if (!cl->isC) {  /* Lua function? prepare its call */
-    CallInfo *ci;
-    StkId st, base;
-    Proto *p = cl->p;
-    luaD_checkstack(L, p->maxstacksize);
-    func = restorestack(L, funcr);
-    if (!p->is_vararg) {  /* no varargs? */
-      base = func + 1;
-      if (L->top > base + p->numparams)
-        L->top = base + p->numparams;
-    }
-    else {  /* vararg function */
-      int nargs = cast_int(L->top - func) - 1;
-      base = adjust_varargs(L, p, nargs);
-      func = restorestack(L, funcr);  /* previous call may change the stack */
-    }
-    ci = inc_ci(L);  /* now `enter' new function */
-    ci->func = func;
-    L->base = ci->base = base;
-    ci->top = L->base + p->maxstacksize;
-    lua_assert(ci->top <= L->stack_last);
-    L->savedpc = p->code;  /* starting point */
-    ci->tailcalls = 0;
-    ci->nresults = nresults;
-    for (st = L->top; st < ci->top; st++)
-      setnilvalue(st);
-    L->top = ci->top;
-    if (L->hookmask & LUA_MASKCALL) {
-      L->savedpc++;  /* hooks assume 'pc' is already incremented */
-      luaD_callhook(L, LUA_HOOKCALL, -1);
-      L->savedpc--;  /* correct 'pc' */
-    }
-    return PCRLUA;
-  }
-  else {  /* if is a C function, call it */
-    CallInfo *ci;
-    int n;
-    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
-    ci = inc_ci(L);  /* now `enter' new function */
-    ci->func = restorestack(L, funcr);
-    L->base = ci->base = ci->func + 1;
-    ci->top = L->top + LUA_MINSTACK;
-    lua_assert(ci->top <= L->stack_last);
-    ci->nresults = nresults;
-    if (L->hookmask & LUA_MASKCALL)
-      luaD_callhook(L, LUA_HOOKCALL, -1);
-    lua_unlock(L);
-    n = (*curr_func(L)->c.f)(L);  /* do the actual call */
-    lua_lock(L);
-    if (n < 0)  /* yielding? */
-      return PCRYIELD;
-    else {
-      luaD_poscall(L, L->top - n);
-      return PCRC;
-    }
-  }
-}
-
-
-static StkId callrethooks (lua_State *L, StkId firstResult) {
-  ptrdiff_t fr = savestack(L, firstResult);  /* next call may change stack */
-  luaD_callhook(L, LUA_HOOKRET, -1);
-  if (f_isLua(L->ci)) {  /* Lua function? */
-    while ((L->hookmask & LUA_MASKRET) && L->ci->tailcalls--) /* tail calls */
-      luaD_callhook(L, LUA_HOOKTAILRET, -1);
-  }
-  return restorestack(L, fr);
-}
-
-
-int luaD_poscall (lua_State *L, StkId firstResult) {
-  StkId res;
-  int wanted, i;
-  CallInfo *ci;
-  if (L->hookmask & LUA_MASKRET)
-    firstResult = callrethooks(L, firstResult);
-  ci = L->ci--;
-  res = ci->func;  /* res == final position of 1st result */
-  wanted = ci->nresults;
-  L->base = (ci - 1)->base;  /* restore base */
-  L->savedpc = (ci - 1)->savedpc;  /* restore savedpc */
-  /* move results to correct place */
-  for (i = wanted; i != 0 && firstResult < L->top; i--)
-    setobjs2s(L, res++, firstResult++);
-  while (i-- > 0)
-    setnilvalue(res++);
-  L->top = res;
-  return (wanted - LUA_MULTRET);  /* 0 iff wanted == LUA_MULTRET */
-}
-
-
-/*
-** Call a function (C or Lua). The function to be called is at *func.
-** The arguments are on the stack, right after the function.
-** When returns, all the results are on the stack, starting at the original
-** function position.
-*/ 
-void luaD_call (lua_State *L, StkId func, int nResults) {
-  if (++L->nCcalls >= LUAI_MAXCCALLS) {
-    if (L->nCcalls == LUAI_MAXCCALLS)
-      luaG_runerror(L, "C stack overflow");
-    else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
-      luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */
-  }
-  if (luaD_precall(L, func, nResults) == PCRLUA)  /* is a Lua function? */
-    luaV_execute(L, 1);  /* call it */
-  L->nCcalls--;
-  luaC_checkGC(L);
-}
-
-
-static void resume (lua_State *L, void *ud) {
-  StkId firstArg = cast(StkId, ud);
-  CallInfo *ci = L->ci;
-  if (L->status == 0) {  /* start coroutine? */
-    lua_assert(ci == L->base_ci && firstArg > L->base);
-    if (luaD_precall(L, firstArg - 1, LUA_MULTRET) != PCRLUA)
-      return;
-  }
-  else {  /* resuming from previous yield */
-    lua_assert(L->status == LUA_YIELD);
-    L->status = 0;
-    if (!f_isLua(ci)) {  /* `common' yield? */
-      /* finish interrupted execution of `OP_CALL' */
-      lua_assert(GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_CALL ||
-                 GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_TAILCALL);
-      if (luaD_poscall(L, firstArg))  /* complete it... */
-        L->top = L->ci->top;  /* and correct top if not multiple results */
-    }
-    else  /* yielded inside a hook: just continue its execution */
-      L->base = L->ci->base;
-  }
-  luaV_execute(L, cast_int(L->ci - L->base_ci));
-}
-
-
-static int resume_error (lua_State *L, const char *msg) {
-  L->top = L->ci->base;
-  setsvalue2s(L, L->top, luaS_new(L, msg));
-  incr_top(L);
-  lua_unlock(L);
-  return LUA_ERRRUN;
-}
-
-
-LUA_API int lua_resume (lua_State *L, int nargs) {
-  int status;
-  lua_lock(L);
-  if (L->status != LUA_YIELD && (L->status != 0 || L->ci != L->base_ci))
-      return resume_error(L, "cannot resume non-suspended coroutine");
-  if (L->nCcalls >= LUAI_MAXCCALLS)
-    return resume_error(L, "C stack overflow");
-  luai_userstateresume(L, nargs);
-  lua_assert(L->errfunc == 0);
-  L->baseCcalls = ++L->nCcalls;
-  status = luaD_rawrunprotected(L, resume, L->top - nargs);
-  if (status != 0) {  /* error? */
-    L->status = cast_byte(status);  /* mark thread as `dead' */
-    luaD_seterrorobj(L, status, L->top);
-    L->ci->top = L->top;
-  }
-  else {
-    lua_assert(L->nCcalls == L->baseCcalls);
-    status = L->status;
-  }
-  --L->nCcalls;
-  lua_unlock(L);
-  return status;
-}
-
-
-LUA_API int lua_yield (lua_State *L, int nresults) {
-  luai_userstateyield(L, nresults);
-  lua_lock(L);
-  if (L->nCcalls > L->baseCcalls)
-    luaG_runerror(L, "attempt to yield across metamethod/C-call boundary");
-  L->base = L->top - nresults;  /* protect stack slots below */
-  L->status = LUA_YIELD;
-  lua_unlock(L);
-  return -1;
-}
-
-
-int luaD_pcall (lua_State *L, Pfunc func, void *u,
-                ptrdiff_t old_top, ptrdiff_t ef) {
-  int status;
-  unsigned short oldnCcalls = L->nCcalls;
-  ptrdiff_t old_ci = saveci(L, L->ci);
-  lu_byte old_allowhooks = L->allowhook;
-  ptrdiff_t old_errfunc = L->errfunc;
-  L->errfunc = ef;
-  status = luaD_rawrunprotected(L, func, u);
-  if (status != 0) {  /* an error occurred? */
-    StkId oldtop = restorestack(L, old_top);
-    luaF_close(L, oldtop);  /* close eventual pending closures */
-    luaD_seterrorobj(L, status, oldtop);
-    L->nCcalls = oldnCcalls;
-    L->ci = restoreci(L, old_ci);
-    L->base = L->ci->base;
-    L->savedpc = L->ci->savedpc;
-    L->allowhook = old_allowhooks;
-    restore_stack_limit(L);
-  }
-  L->errfunc = old_errfunc;
-  return status;
-}
-
-
-
-/*
-** Execute a protected parser.
-*/
-struct SParser {  /* data to `f_parser' */
-  ZIO *z;
-  Mbuffer buff;  /* buffer to be used by the scanner */
-  const char *name;
-};
-
-static void f_parser (lua_State *L, void *ud) {
-  int i;
-  Proto *tf;
-  Closure *cl;
-  struct SParser *p = cast(struct SParser *, ud);
-  int c = luaZ_lookahead(p->z);
-  luaC_checkGC(L);
-  tf = ((c == LUA_SIGNATURE[0]) ? luaU_undump : luaY_parser)(L, p->z,
-                                                             &p->buff, p->name);
-  cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));
-  cl->l.p = tf;
-  for (i = 0; i < tf->nups; i++)  /* initialize eventual upvalues */
-    cl->l.upvals[i] = luaF_newupval(L);
-  setclvalue(L, L->top, cl);
-  incr_top(L);
-}
-
-
-int luaD_protectedparser (lua_State *L, ZIO *z, const char *name) {
-  struct SParser p;
-  int status;
-  p.z = z; p.name = name;
-  luaZ_initbuffer(L, &p.buff);
-  status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);
-  luaZ_freebuffer(L, &p.buff);
-  return status;
-}
-
-
diff --git a/extern/lua-5.1.5/src/ldo.h b/extern/lua-5.1.5/src/ldo.h
deleted file mode 100644
index 98fddac5..00000000
--- a/extern/lua-5.1.5/src/ldo.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-** $Id: ldo.h,v 2.7.1.1 2007/12/27 13:02:25 roberto Exp $
-** Stack and Call structure of Lua
-** See Copyright Notice in lua.h
-*/
-
-#ifndef ldo_h
-#define ldo_h
-
-
-#include "lobject.h"
-#include "lstate.h"
-#include "lzio.h"
-
-
-#define luaD_checkstack(L,n)	\
-  if ((char *)L->stack_last - (char *)L->top <= (n)*(int)sizeof(TValue)) \
-    luaD_growstack(L, n); \
-  else condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1));
-
-
-#define incr_top(L) {luaD_checkstack(L,1); L->top++;}
-
-#define savestack(L,p)		((char *)(p) - (char *)L->stack)
-#define restorestack(L,n)	((TValue *)((char *)L->stack + (n)))
-
-#define saveci(L,p)		((char *)(p) - (char *)L->base_ci)
-#define restoreci(L,n)		((CallInfo *)((char *)L->base_ci + (n)))
-
-
-/* results from luaD_precall */
-#define PCRLUA		0	/* initiated a call to a Lua function */
-#define PCRC		1	/* did a call to a C function */
-#define PCRYIELD	2	/* C funtion yielded */
-
-
-/* type of protected functions, to be ran by `runprotected' */
-typedef void (*Pfunc) (lua_State *L, void *ud);
-
-LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name);
-LUAI_FUNC void luaD_callhook (lua_State *L, int event, int line);
-LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);
-LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);
-LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
-                                        ptrdiff_t oldtop, ptrdiff_t ef);
-LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult);
-LUAI_FUNC void luaD_reallocCI (lua_State *L, int newsize);
-LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
-LUAI_FUNC void luaD_growstack (lua_State *L, int n);
-
-LUAI_FUNC void luaD_throw (lua_State *L, int errcode);
-LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
-
-LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop);
-
-#endif
-
diff --git a/extern/lua-5.1.5/src/ldump.c b/extern/lua-5.1.5/src/ldump.c
deleted file mode 100644
index c9d3d487..00000000
--- a/extern/lua-5.1.5/src/ldump.c
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
-** $Id: ldump.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
-** save precompiled Lua chunks
-** See Copyright Notice in lua.h
-*/
-
-#include <stddef.h>
-
-#define ldump_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lobject.h"
-#include "lstate.h"
-#include "lundump.h"
-
-typedef struct {
- lua_State* L;
- lua_Writer writer;
- void* data;
- int strip;
- int status;
-} DumpState;
-
-#define DumpMem(b,n,size,D)	DumpBlock(b,(n)*(size),D)
-#define DumpVar(x,D)	 	DumpMem(&x,1,sizeof(x),D)
-
-static void DumpBlock(const void* b, size_t size, DumpState* D)
-{
- if (D->status==0)
- {
-  lua_unlock(D->L);
-  D->status=(*D->writer)(D->L,b,size,D->data);
-  lua_lock(D->L);
- }
-}
-
-static void DumpChar(int y, DumpState* D)
-{
- char x=(char)y;
- DumpVar(x,D);
-}
-
-static void DumpInt(int x, DumpState* D)
-{
- DumpVar(x,D);
-}
-
-static void DumpNumber(lua_Number x, DumpState* D)
-{
- DumpVar(x,D);
-}
-
-static void DumpVector(const void* b, int n, size_t size, DumpState* D)
-{
- DumpInt(n,D);
- DumpMem(b,n,size,D);
-}
-
-static void DumpString(const TString* s, DumpState* D)
-{
- if (s==NULL || getstr(s)==NULL)
- {
-  size_t size=0;
-  DumpVar(size,D);
- }
- else
- {
-  size_t size=s->tsv.len+1;		/* include trailing '\0' */
-  DumpVar(size,D);
-  DumpBlock(getstr(s),size,D);
- }
-}
-
-#define DumpCode(f,D)	 DumpVector(f->code,f->sizecode,sizeof(Instruction),D)
-
-static void DumpFunction(const Proto* f, const TString* p, DumpState* D);
-
-static void DumpConstants(const Proto* f, DumpState* D)
-{
- int i,n=f->sizek;
- DumpInt(n,D);
- for (i=0; i<n; i++)
- {
-  const TValue* o=&f->k[i];
-  DumpChar(ttype(o),D);
-  switch (ttype(o))
-  {
-   case LUA_TNIL:
-	break;
-   case LUA_TBOOLEAN:
-	DumpChar(bvalue(o),D);
-	break;
-   case LUA_TNUMBER:
-	DumpNumber(nvalue(o),D);
-	break;
-   case LUA_TSTRING:
-	DumpString(rawtsvalue(o),D);
-	break;
-   default:
-	lua_assert(0);			/* cannot happen */
-	break;
-  }
- }
- n=f->sizep;
- DumpInt(n,D);
- for (i=0; i<n; i++) DumpFunction(f->p[i],f->source,D);
-}
-
-static void DumpDebug(const Proto* f, DumpState* D)
-{
- int i,n;
- n= (D->strip) ? 0 : f->sizelineinfo;
- DumpVector(f->lineinfo,n,sizeof(int),D);
- n= (D->strip) ? 0 : f->sizelocvars;
- DumpInt(n,D);
- for (i=0; i<n; i++)
- {
-  DumpString(f->locvars[i].varname,D);
-  DumpInt(f->locvars[i].startpc,D);
-  DumpInt(f->locvars[i].endpc,D);
- }
- n= (D->strip) ? 0 : f->sizeupvalues;
- DumpInt(n,D);
- for (i=0; i<n; i++) DumpString(f->upvalues[i],D);
-}
-
-static void DumpFunction(const Proto* f, const TString* p, DumpState* D)
-{
- DumpString((f->source==p || D->strip) ? NULL : f->source,D);
- DumpInt(f->linedefined,D);
- DumpInt(f->lastlinedefined,D);
- DumpChar(f->nups,D);
- DumpChar(f->numparams,D);
- DumpChar(f->is_vararg,D);
- DumpChar(f->maxstacksize,D);
- DumpCode(f,D);
- DumpConstants(f,D);
- DumpDebug(f,D);
-}
-
-static void DumpHeader(DumpState* D)
-{
- char h[LUAC_HEADERSIZE];
- luaU_header(h);
- DumpBlock(h,LUAC_HEADERSIZE,D);
-}
-
-/*
-** dump Lua function as precompiled chunk
-*/
-int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
-{
- DumpState D;
- D.L=L;
- D.writer=w;
- D.data=data;
- D.strip=strip;
- D.status=0;
- DumpHeader(&D);
- DumpFunction(f,NULL,&D);
- return D.status;
-}
diff --git a/extern/lua-5.1.5/src/lfunc.c b/extern/lua-5.1.5/src/lfunc.c
deleted file mode 100644
index 813e88f5..00000000
--- a/extern/lua-5.1.5/src/lfunc.c
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
-** $Id: lfunc.c,v 2.12.1.2 2007/12/28 14:58:43 roberto Exp $
-** Auxiliary functions to manipulate prototypes and closures
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stddef.h>
-
-#define lfunc_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lfunc.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-
-
-
-Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e) {
-  Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems)));
-  luaC_link(L, obj2gco(c), LUA_TFUNCTION);
-  c->c.isC = 1;
-  c->c.env = e;
-  c->c.nupvalues = cast_byte(nelems);
-  return c;
-}
-
-
-Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e) {
-  Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems)));
-  luaC_link(L, obj2gco(c), LUA_TFUNCTION);
-  c->l.isC = 0;
-  c->l.env = e;
-  c->l.nupvalues = cast_byte(nelems);
-  while (nelems--) c->l.upvals[nelems] = NULL;
-  return c;
-}
-
-
-UpVal *luaF_newupval (lua_State *L) {
-  UpVal *uv = luaM_new(L, UpVal);
-  luaC_link(L, obj2gco(uv), LUA_TUPVAL);
-  uv->v = &uv->u.value;
-  setnilvalue(uv->v);
-  return uv;
-}
-
-
-UpVal *luaF_findupval (lua_State *L, StkId level) {
-  global_State *g = G(L);
-  GCObject **pp = &L->openupval;
-  UpVal *p;
-  UpVal *uv;
-  while (*pp != NULL && (p = ngcotouv(*pp))->v >= level) {
-    lua_assert(p->v != &p->u.value);
-    if (p->v == level) {  /* found a corresponding upvalue? */
-      if (isdead(g, obj2gco(p)))  /* is it dead? */
-        changewhite(obj2gco(p));  /* ressurect it */
-      return p;
-    }
-    pp = &p->next;
-  }
-  uv = luaM_new(L, UpVal);  /* not found: create a new one */
-  uv->tt = LUA_TUPVAL;
-  uv->marked = luaC_white(g);
-  uv->v = level;  /* current value lives in the stack */
-  uv->next = *pp;  /* chain it in the proper position */
-  *pp = obj2gco(uv);
-  uv->u.l.prev = &g->uvhead;  /* double link it in `uvhead' list */
-  uv->u.l.next = g->uvhead.u.l.next;
-  uv->u.l.next->u.l.prev = uv;
-  g->uvhead.u.l.next = uv;
-  lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
-  return uv;
-}
-
-
-static void unlinkupval (UpVal *uv) {
-  lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
-  uv->u.l.next->u.l.prev = uv->u.l.prev;  /* remove from `uvhead' list */
-  uv->u.l.prev->u.l.next = uv->u.l.next;
-}
-
-
-void luaF_freeupval (lua_State *L, UpVal *uv) {
-  if (uv->v != &uv->u.value)  /* is it open? */
-    unlinkupval(uv);  /* remove from open list */
-  luaM_free(L, uv);  /* free upvalue */
-}
-
-
-void luaF_close (lua_State *L, StkId level) {
-  UpVal *uv;
-  global_State *g = G(L);
-  while (L->openupval != NULL && (uv = ngcotouv(L->openupval))->v >= level) {
-    GCObject *o = obj2gco(uv);
-    lua_assert(!isblack(o) && uv->v != &uv->u.value);
-    L->openupval = uv->next;  /* remove from `open' list */
-    if (isdead(g, o))
-      luaF_freeupval(L, uv);  /* free upvalue */
-    else {
-      unlinkupval(uv);
-      setobj(L, &uv->u.value, uv->v);
-      uv->v = &uv->u.value;  /* now current value lives here */
-      luaC_linkupval(L, uv);  /* link upvalue into `gcroot' list */
-    }
-  }
-}
-
-
-Proto *luaF_newproto (lua_State *L) {
-  Proto *f = luaM_new(L, Proto);
-  luaC_link(L, obj2gco(f), LUA_TPROTO);
-  f->k = NULL;
-  f->sizek = 0;
-  f->p = NULL;
-  f->sizep = 0;
-  f->code = NULL;
-  f->sizecode = 0;
-  f->sizelineinfo = 0;
-  f->sizeupvalues = 0;
-  f->nups = 0;
-  f->upvalues = NULL;
-  f->numparams = 0;
-  f->is_vararg = 0;
-  f->maxstacksize = 0;
-  f->lineinfo = NULL;
-  f->sizelocvars = 0;
-  f->locvars = NULL;
-  f->linedefined = 0;
-  f->lastlinedefined = 0;
-  f->source = NULL;
-  return f;
-}
-
-
-void luaF_freeproto (lua_State *L, Proto *f) {
-  luaM_freearray(L, f->code, f->sizecode, Instruction);
-  luaM_freearray(L, f->p, f->sizep, Proto *);
-  luaM_freearray(L, f->k, f->sizek, TValue);
-  luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);
-  luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);
-  luaM_freearray(L, f->upvalues, f->sizeupvalues, TString *);
-  luaM_free(L, f);
-}
-
-
-void luaF_freeclosure (lua_State *L, Closure *c) {
-  int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) :
-                          sizeLclosure(c->l.nupvalues);
-  luaM_freemem(L, c, size);
-}
-
-
-/*
-** Look for n-th local variable at line `line' in function `func'.
-** Returns NULL if not found.
-*/
-const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
-  int i;
-  for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
-    if (pc < f->locvars[i].endpc) {  /* is variable active? */
-      local_number--;
-      if (local_number == 0)
-        return getstr(f->locvars[i].varname);
-    }
-  }
-  return NULL;  /* not found */
-}
-
diff --git a/extern/lua-5.1.5/src/lfunc.h b/extern/lua-5.1.5/src/lfunc.h
deleted file mode 100644
index a68cf515..00000000
--- a/extern/lua-5.1.5/src/lfunc.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-** $Id: lfunc.h,v 2.4.1.1 2007/12/27 13:02:25 roberto Exp $
-** Auxiliary functions to manipulate prototypes and closures
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lfunc_h
-#define lfunc_h
-
-
-#include "lobject.h"
-
-
-#define sizeCclosure(n)	(cast(int, sizeof(CClosure)) + \
-                         cast(int, sizeof(TValue)*((n)-1)))
-
-#define sizeLclosure(n)	(cast(int, sizeof(LClosure)) + \
-                         cast(int, sizeof(TValue *)*((n)-1)))
-
-
-LUAI_FUNC Proto *luaF_newproto (lua_State *L);
-LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e);
-LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e);
-LUAI_FUNC UpVal *luaF_newupval (lua_State *L);
-LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
-LUAI_FUNC void luaF_close (lua_State *L, StkId level);
-LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
-LUAI_FUNC void luaF_freeclosure (lua_State *L, Closure *c);
-LUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv);
-LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
-                                         int pc);
-
-
-#endif
diff --git a/extern/lua-5.1.5/src/lgc.c b/extern/lua-5.1.5/src/lgc.c
deleted file mode 100644
index e909c79a..00000000
--- a/extern/lua-5.1.5/src/lgc.c
+++ /dev/null
@@ -1,710 +0,0 @@
-/*
-** $Id: lgc.c,v 2.38.1.2 2011/03/18 18:05:38 roberto Exp $
-** Garbage Collector
-** See Copyright Notice in lua.h
-*/
-
-#include <string.h>
-
-#define lgc_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-
-
-#define GCSTEPSIZE	1024u
-#define GCSWEEPMAX	40
-#define GCSWEEPCOST	10
-#define GCFINALIZECOST	100
-
-
-#define maskmarks	cast_byte(~(bitmask(BLACKBIT)|WHITEBITS))
-
-#define makewhite(g,x)	\
-   ((x)->gch.marked = cast_byte(((x)->gch.marked & maskmarks) | luaC_white(g)))
-
-#define white2gray(x)	reset2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
-#define black2gray(x)	resetbit((x)->gch.marked, BLACKBIT)
-
-#define stringmark(s)	reset2bits((s)->tsv.marked, WHITE0BIT, WHITE1BIT)
-
-
-#define isfinalized(u)		testbit((u)->marked, FINALIZEDBIT)
-#define markfinalized(u)	l_setbit((u)->marked, FINALIZEDBIT)
-
-
-#define KEYWEAK         bitmask(KEYWEAKBIT)
-#define VALUEWEAK       bitmask(VALUEWEAKBIT)
-
-
-
-#define markvalue(g,o) { checkconsistency(o); \
-  if (iscollectable(o) && iswhite(gcvalue(o))) reallymarkobject(g,gcvalue(o)); }
-
-#define markobject(g,t) { if (iswhite(obj2gco(t))) \
-		reallymarkobject(g, obj2gco(t)); }
-
-
-#define setthreshold(g)  (g->GCthreshold = (g->estimate/100) * g->gcpause)
-
-
-static void removeentry (Node *n) {
-  lua_assert(ttisnil(gval(n)));
-  if (iscollectable(gkey(n)))
-    setttype(gkey(n), LUA_TDEADKEY);  /* dead key; remove it */
-}
-
-
-static void reallymarkobject (global_State *g, GCObject *o) {
-  lua_assert(iswhite(o) && !isdead(g, o));
-  white2gray(o);
-  switch (o->gch.tt) {
-    case LUA_TSTRING: {
-      return;
-    }
-    case LUA_TUSERDATA: {
-      Table *mt = gco2u(o)->metatable;
-      gray2black(o);  /* udata are never gray */
-      if (mt) markobject(g, mt);
-      markobject(g, gco2u(o)->env);
-      return;
-    }
-    case LUA_TUPVAL: {
-      UpVal *uv = gco2uv(o);
-      markvalue(g, uv->v);
-      if (uv->v == &uv->u.value)  /* closed? */
-        gray2black(o);  /* open upvalues are never black */
-      return;
-    }
-    case LUA_TFUNCTION: {
-      gco2cl(o)->c.gclist = g->gray;
-      g->gray = o;
-      break;
-    }
-    case LUA_TTABLE: {
-      gco2h(o)->gclist = g->gray;
-      g->gray = o;
-      break;
-    }
-    case LUA_TTHREAD: {
-      gco2th(o)->gclist = g->gray;
-      g->gray = o;
-      break;
-    }
-    case LUA_TPROTO: {
-      gco2p(o)->gclist = g->gray;
-      g->gray = o;
-      break;
-    }
-    default: lua_assert(0);
-  }
-}
-
-
-static void marktmu (global_State *g) {
-  GCObject *u = g->tmudata;
-  if (u) {
-    do {
-      u = u->gch.next;
-      makewhite(g, u);  /* may be marked, if left from previous GC */
-      reallymarkobject(g, u);
-    } while (u != g->tmudata);
-  }
-}
-
-
-/* move `dead' udata that need finalization to list `tmudata' */
-size_t luaC_separateudata (lua_State *L, int all) {
-  global_State *g = G(L);
-  size_t deadmem = 0;
-  GCObject **p = &g->mainthread->next;
-  GCObject *curr;
-  while ((curr = *p) != NULL) {
-    if (!(iswhite(curr) || all) || isfinalized(gco2u(curr)))
-      p = &curr->gch.next;  /* don't bother with them */
-    else if (fasttm(L, gco2u(curr)->metatable, TM_GC) == NULL) {
-      markfinalized(gco2u(curr));  /* don't need finalization */
-      p = &curr->gch.next;
-    }
-    else {  /* must call its gc method */
-      deadmem += sizeudata(gco2u(curr));
-      markfinalized(gco2u(curr));
-      *p = curr->gch.next;
-      /* link `curr' at the end of `tmudata' list */
-      if (g->tmudata == NULL)  /* list is empty? */
-        g->tmudata = curr->gch.next = curr;  /* creates a circular list */
-      else {
-        curr->gch.next = g->tmudata->gch.next;
-        g->tmudata->gch.next = curr;
-        g->tmudata = curr;
-      }
-    }
-  }
-  return deadmem;
-}
-
-
-static int traversetable (global_State *g, Table *h) {
-  int i;
-  int weakkey = 0;
-  int weakvalue = 0;
-  const TValue *mode;
-  if (h->metatable)
-    markobject(g, h->metatable);
-  mode = gfasttm(g, h->metatable, TM_MODE);
-  if (mode && ttisstring(mode)) {  /* is there a weak mode? */
-    weakkey = (strchr(svalue(mode), 'k') != NULL);
-    weakvalue = (strchr(svalue(mode), 'v') != NULL);
-    if (weakkey || weakvalue) {  /* is really weak? */
-      h->marked &= ~(KEYWEAK | VALUEWEAK);  /* clear bits */
-      h->marked |= cast_byte((weakkey << KEYWEAKBIT) |
-                             (weakvalue << VALUEWEAKBIT));
-      h->gclist = g->weak;  /* must be cleared after GC, ... */
-      g->weak = obj2gco(h);  /* ... so put in the appropriate list */
-    }
-  }
-  if (weakkey && weakvalue) return 1;
-  if (!weakvalue) {
-    i = h->sizearray;
-    while (i--)
-      markvalue(g, &h->array[i]);
-  }
-  i = sizenode(h);
-  while (i--) {
-    Node *n = gnode(h, i);
-    lua_assert(ttype(gkey(n)) != LUA_TDEADKEY || ttisnil(gval(n)));
-    if (ttisnil(gval(n)))
-      removeentry(n);  /* remove empty entries */
-    else {
-      lua_assert(!ttisnil(gkey(n)));
-      if (!weakkey) markvalue(g, gkey(n));
-      if (!weakvalue) markvalue(g, gval(n));
-    }
-  }
-  return weakkey || weakvalue;
-}
-
-
-/*
-** All marks are conditional because a GC may happen while the
-** prototype is still being created
-*/
-static void traverseproto (global_State *g, Proto *f) {
-  int i;
-  if (f->source) stringmark(f->source);
-  for (i=0; i<f->sizek; i++)  /* mark literals */
-    markvalue(g, &f->k[i]);
-  for (i=0; i<f->sizeupvalues; i++) {  /* mark upvalue names */
-    if (f->upvalues[i])
-      stringmark(f->upvalues[i]);
-  }
-  for (i=0; i<f->sizep; i++) {  /* mark nested protos */
-    if (f->p[i])
-      markobject(g, f->p[i]);
-  }
-  for (i=0; i<f->sizelocvars; i++) {  /* mark local-variable names */
-    if (f->locvars[i].varname)
-      stringmark(f->locvars[i].varname);
-  }
-}
-
-
-
-static void traverseclosure (global_State *g, Closure *cl) {
-  markobject(g, cl->c.env);
-  if (cl->c.isC) {
-    int i;
-    for (i=0; i<cl->c.nupvalues; i++)  /* mark its upvalues */
-      markvalue(g, &cl->c.upvalue[i]);
-  }
-  else {
-    int i;
-    lua_assert(cl->l.nupvalues == cl->l.p->nups);
-    markobject(g, cl->l.p);
-    for (i=0; i<cl->l.nupvalues; i++)  /* mark its upvalues */
-      markobject(g, cl->l.upvals[i]);
-  }
-}
-
-
-static void checkstacksizes (lua_State *L, StkId max) {
-  int ci_used = cast_int(L->ci - L->base_ci);  /* number of `ci' in use */
-  int s_used = cast_int(max - L->stack);  /* part of stack in use */
-  if (L->size_ci > LUAI_MAXCALLS)  /* handling overflow? */
-    return;  /* do not touch the stacks */
-  if (4*ci_used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci)
-    luaD_reallocCI(L, L->size_ci/2);  /* still big enough... */
-  condhardstacktests(luaD_reallocCI(L, ci_used + 1));
-  if (4*s_used < L->stacksize &&
-      2*(BASIC_STACK_SIZE+EXTRA_STACK) < L->stacksize)
-    luaD_reallocstack(L, L->stacksize/2);  /* still big enough... */
-  condhardstacktests(luaD_reallocstack(L, s_used));
-}
-
-
-static void traversestack (global_State *g, lua_State *l) {
-  StkId o, lim;
-  CallInfo *ci;
-  markvalue(g, gt(l));
-  lim = l->top;
-  for (ci = l->base_ci; ci <= l->ci; ci++) {
-    lua_assert(ci->top <= l->stack_last);
-    if (lim < ci->top) lim = ci->top;
-  }
-  for (o = l->stack; o < l->top; o++)
-    markvalue(g, o);
-  for (; o <= lim; o++)
-    setnilvalue(o);
-  checkstacksizes(l, lim);
-}
-
-
-/*
-** traverse one gray object, turning it to black.
-** Returns `quantity' traversed.
-*/
-static l_mem propagatemark (global_State *g) {
-  GCObject *o = g->gray;
-  lua_assert(isgray(o));
-  gray2black(o);
-  switch (o->gch.tt) {
-    case LUA_TTABLE: {
-      Table *h = gco2h(o);
-      g->gray = h->gclist;
-      if (traversetable(g, h))  /* table is weak? */
-        black2gray(o);  /* keep it gray */
-      return sizeof(Table) + sizeof(TValue) * h->sizearray +
-                             sizeof(Node) * sizenode(h);
-    }
-    case LUA_TFUNCTION: {
-      Closure *cl = gco2cl(o);
-      g->gray = cl->c.gclist;
-      traverseclosure(g, cl);
-      return (cl->c.isC) ? sizeCclosure(cl->c.nupvalues) :
-                           sizeLclosure(cl->l.nupvalues);
-    }
-    case LUA_TTHREAD: {
-      lua_State *th = gco2th(o);
-      g->gray = th->gclist;
-      th->gclist = g->grayagain;
-      g->grayagain = o;
-      black2gray(o);
-      traversestack(g, th);
-      return sizeof(lua_State) + sizeof(TValue) * th->stacksize +
-                                 sizeof(CallInfo) * th->size_ci;
-    }
-    case LUA_TPROTO: {
-      Proto *p = gco2p(o);
-      g->gray = p->gclist;
-      traverseproto(g, p);
-      return sizeof(Proto) + sizeof(Instruction) * p->sizecode +
-                             sizeof(Proto *) * p->sizep +
-                             sizeof(TValue) * p->sizek + 
-                             sizeof(int) * p->sizelineinfo +
-                             sizeof(LocVar) * p->sizelocvars +
-                             sizeof(TString *) * p->sizeupvalues;
-    }
-    default: lua_assert(0); return 0;
-  }
-}
-
-
-static size_t propagateall (global_State *g) {
-  size_t m = 0;
-  while (g->gray) m += propagatemark(g);
-  return m;
-}
-
-
-/*
-** The next function tells whether a key or value can be cleared from
-** a weak table. Non-collectable objects are never removed from weak
-** tables. Strings behave as `values', so are never removed too. for
-** other objects: if really collected, cannot keep them; for userdata
-** being finalized, keep them in keys, but not in values
-*/
-static int iscleared (const TValue *o, int iskey) {
-  if (!iscollectable(o)) return 0;
-  if (ttisstring(o)) {
-    stringmark(rawtsvalue(o));  /* strings are `values', so are never weak */
-    return 0;
-  }
-  return iswhite(gcvalue(o)) ||
-    (ttisuserdata(o) && (!iskey && isfinalized(uvalue(o))));
-}
-
-
-/*
-** clear collected entries from weaktables
-*/
-static void cleartable (GCObject *l) {
-  while (l) {
-    Table *h = gco2h(l);
-    int i = h->sizearray;
-    lua_assert(testbit(h->marked, VALUEWEAKBIT) ||
-               testbit(h->marked, KEYWEAKBIT));
-    if (testbit(h->marked, VALUEWEAKBIT)) {
-      while (i--) {
-        TValue *o = &h->array[i];
-        if (iscleared(o, 0))  /* value was collected? */
-          setnilvalue(o);  /* remove value */
-      }
-    }
-    i = sizenode(h);
-    while (i--) {
-      Node *n = gnode(h, i);
-      if (!ttisnil(gval(n)) &&  /* non-empty entry? */
-          (iscleared(key2tval(n), 1) || iscleared(gval(n), 0))) {
-        setnilvalue(gval(n));  /* remove value ... */
-        removeentry(n);  /* remove entry from table */
-      }
-    }
-    l = h->gclist;
-  }
-}
-
-
-static void freeobj (lua_State *L, GCObject *o) {
-  switch (o->gch.tt) {
-    case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
-    case LUA_TFUNCTION: luaF_freeclosure(L, gco2cl(o)); break;
-    case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break;
-    case LUA_TTABLE: luaH_free(L, gco2h(o)); break;
-    case LUA_TTHREAD: {
-      lua_assert(gco2th(o) != L && gco2th(o) != G(L)->mainthread);
-      luaE_freethread(L, gco2th(o));
-      break;
-    }
-    case LUA_TSTRING: {
-      G(L)->strt.nuse--;
-      luaM_freemem(L, o, sizestring(gco2ts(o)));
-      break;
-    }
-    case LUA_TUSERDATA: {
-      luaM_freemem(L, o, sizeudata(gco2u(o)));
-      break;
-    }
-    default: lua_assert(0);
-  }
-}
-
-
-
-#define sweepwholelist(L,p)	sweeplist(L,p,MAX_LUMEM)
-
-
-static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
-  GCObject *curr;
-  global_State *g = G(L);
-  int deadmask = otherwhite(g);
-  while ((curr = *p) != NULL && count-- > 0) {
-    if (curr->gch.tt == LUA_TTHREAD)  /* sweep open upvalues of each thread */
-      sweepwholelist(L, &gco2th(curr)->openupval);
-    if ((curr->gch.marked ^ WHITEBITS) & deadmask) {  /* not dead? */
-      lua_assert(!isdead(g, curr) || testbit(curr->gch.marked, FIXEDBIT));
-      makewhite(g, curr);  /* make it white (for next cycle) */
-      p = &curr->gch.next;
-    }
-    else {  /* must erase `curr' */
-      lua_assert(isdead(g, curr) || deadmask == bitmask(SFIXEDBIT));
-      *p = curr->gch.next;
-      if (curr == g->rootgc)  /* is the first element of the list? */
-        g->rootgc = curr->gch.next;  /* adjust first */
-      freeobj(L, curr);
-    }
-  }
-  return p;
-}
-
-
-static void checkSizes (lua_State *L) {
-  global_State *g = G(L);
-  /* check size of string hash */
-  if (g->strt.nuse < cast(lu_int32, g->strt.size/4) &&
-      g->strt.size > MINSTRTABSIZE*2)
-    luaS_resize(L, g->strt.size/2);  /* table is too big */
-  /* check size of buffer */
-  if (luaZ_sizebuffer(&g->buff) > LUA_MINBUFFER*2) {  /* buffer too big? */
-    size_t newsize = luaZ_sizebuffer(&g->buff) / 2;
-    luaZ_resizebuffer(L, &g->buff, newsize);
-  }
-}
-
-
-static void GCTM (lua_State *L) {
-  global_State *g = G(L);
-  GCObject *o = g->tmudata->gch.next;  /* get first element */
-  Udata *udata = rawgco2u(o);
-  const TValue *tm;
-  /* remove udata from `tmudata' */
-  if (o == g->tmudata)  /* last element? */
-    g->tmudata = NULL;
-  else
-    g->tmudata->gch.next = udata->uv.next;
-  udata->uv.next = g->mainthread->next;  /* return it to `root' list */
-  g->mainthread->next = o;
-  makewhite(g, o);
-  tm = fasttm(L, udata->uv.metatable, TM_GC);
-  if (tm != NULL) {
-    lu_byte oldah = L->allowhook;
-    lu_mem oldt = g->GCthreshold;
-    L->allowhook = 0;  /* stop debug hooks during GC tag method */
-    g->GCthreshold = 2*g->totalbytes;  /* avoid GC steps */
-    setobj2s(L, L->top, tm);
-    setuvalue(L, L->top+1, udata);
-    L->top += 2;
-    luaD_call(L, L->top - 2, 0);
-    L->allowhook = oldah;  /* restore hooks */
-    g->GCthreshold = oldt;  /* restore threshold */
-  }
-}
-
-
-/*
-** Call all GC tag methods
-*/
-void luaC_callGCTM (lua_State *L) {
-  while (G(L)->tmudata)
-    GCTM(L);
-}
-
-
-void luaC_freeall (lua_State *L) {
-  global_State *g = G(L);
-  int i;
-  g->currentwhite = WHITEBITS | bitmask(SFIXEDBIT);  /* mask to collect all elements */
-  sweepwholelist(L, &g->rootgc);
-  for (i = 0; i < g->strt.size; i++)  /* free all string lists */
-    sweepwholelist(L, &g->strt.hash[i]);
-}
-
-
-static void markmt (global_State *g) {
-  int i;
-  for (i=0; i<NUM_TAGS; i++)
-    if (g->mt[i]) markobject(g, g->mt[i]);
-}
-
-
-/* mark root set */
-static void markroot (lua_State *L) {
-  global_State *g = G(L);
-  g->gray = NULL;
-  g->grayagain = NULL;
-  g->weak = NULL;
-  markobject(g, g->mainthread);
-  /* make global table be traversed before main stack */
-  markvalue(g, gt(g->mainthread));
-  markvalue(g, registry(L));
-  markmt(g);
-  g->gcstate = GCSpropagate;
-}
-
-
-static void remarkupvals (global_State *g) {
-  UpVal *uv;
-  for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) {
-    lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
-    if (isgray(obj2gco(uv)))
-      markvalue(g, uv->v);
-  }
-}
-
-
-static void atomic (lua_State *L) {
-  global_State *g = G(L);
-  size_t udsize;  /* total size of userdata to be finalized */
-  /* remark occasional upvalues of (maybe) dead threads */
-  remarkupvals(g);
-  /* traverse objects cautch by write barrier and by 'remarkupvals' */
-  propagateall(g);
-  /* remark weak tables */
-  g->gray = g->weak;
-  g->weak = NULL;
-  lua_assert(!iswhite(obj2gco(g->mainthread)));
-  markobject(g, L);  /* mark running thread */
-  markmt(g);  /* mark basic metatables (again) */
-  propagateall(g);
-  /* remark gray again */
-  g->gray = g->grayagain;
-  g->grayagain = NULL;
-  propagateall(g);
-  udsize = luaC_separateudata(L, 0);  /* separate userdata to be finalized */
-  marktmu(g);  /* mark `preserved' userdata */
-  udsize += propagateall(g);  /* remark, to propagate `preserveness' */
-  cleartable(g->weak);  /* remove collected objects from weak tables */
-  /* flip current white */
-  g->currentwhite = cast_byte(otherwhite(g));
-  g->sweepstrgc = 0;
-  g->sweepgc = &g->rootgc;
-  g->gcstate = GCSsweepstring;
-  g->estimate = g->totalbytes - udsize;  /* first estimate */
-}
-
-
-static l_mem singlestep (lua_State *L) {
-  global_State *g = G(L);
-  /*lua_checkmemory(L);*/
-  switch (g->gcstate) {
-    case GCSpause: {
-      markroot(L);  /* start a new collection */
-      return 0;
-    }
-    case GCSpropagate: {
-      if (g->gray)
-        return propagatemark(g);
-      else {  /* no more `gray' objects */
-        atomic(L);  /* finish mark phase */
-        return 0;
-      }
-    }
-    case GCSsweepstring: {
-      lu_mem old = g->totalbytes;
-      sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);
-      if (g->sweepstrgc >= g->strt.size)  /* nothing more to sweep? */
-        g->gcstate = GCSsweep;  /* end sweep-string phase */
-      lua_assert(old >= g->totalbytes);
-      g->estimate -= old - g->totalbytes;
-      return GCSWEEPCOST;
-    }
-    case GCSsweep: {
-      lu_mem old = g->totalbytes;
-      g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
-      if (*g->sweepgc == NULL) {  /* nothing more to sweep? */
-        checkSizes(L);
-        g->gcstate = GCSfinalize;  /* end sweep phase */
-      }
-      lua_assert(old >= g->totalbytes);
-      g->estimate -= old - g->totalbytes;
-      return GCSWEEPMAX*GCSWEEPCOST;
-    }
-    case GCSfinalize: {
-      if (g->tmudata) {
-        GCTM(L);
-        if (g->estimate > GCFINALIZECOST)
-          g->estimate -= GCFINALIZECOST;
-        return GCFINALIZECOST;
-      }
-      else {
-        g->gcstate = GCSpause;  /* end collection */
-        g->gcdept = 0;
-        return 0;
-      }
-    }
-    default: lua_assert(0); return 0;
-  }
-}
-
-
-void luaC_step (lua_State *L) {
-  global_State *g = G(L);
-  l_mem lim = (GCSTEPSIZE/100) * g->gcstepmul;
-  if (lim == 0)
-    lim = (MAX_LUMEM-1)/2;  /* no limit */
-  g->gcdept += g->totalbytes - g->GCthreshold;
-  do {
-    lim -= singlestep(L);
-    if (g->gcstate == GCSpause)
-      break;
-  } while (lim > 0);
-  if (g->gcstate != GCSpause) {
-    if (g->gcdept < GCSTEPSIZE)
-      g->GCthreshold = g->totalbytes + GCSTEPSIZE;  /* - lim/g->gcstepmul;*/
-    else {
-      g->gcdept -= GCSTEPSIZE;
-      g->GCthreshold = g->totalbytes;
-    }
-  }
-  else {
-    setthreshold(g);
-  }
-}
-
-
-void luaC_fullgc (lua_State *L) {
-  global_State *g = G(L);
-  if (g->gcstate <= GCSpropagate) {
-    /* reset sweep marks to sweep all elements (returning them to white) */
-    g->sweepstrgc = 0;
-    g->sweepgc = &g->rootgc;
-    /* reset other collector lists */
-    g->gray = NULL;
-    g->grayagain = NULL;
-    g->weak = NULL;
-    g->gcstate = GCSsweepstring;
-  }
-  lua_assert(g->gcstate != GCSpause && g->gcstate != GCSpropagate);
-  /* finish any pending sweep phase */
-  while (g->gcstate != GCSfinalize) {
-    lua_assert(g->gcstate == GCSsweepstring || g->gcstate == GCSsweep);
-    singlestep(L);
-  }
-  markroot(L);
-  while (g->gcstate != GCSpause) {
-    singlestep(L);
-  }
-  setthreshold(g);
-}
-
-
-void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v) {
-  global_State *g = G(L);
-  lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
-  lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
-  lua_assert(ttype(&o->gch) != LUA_TTABLE);
-  /* must keep invariant? */
-  if (g->gcstate == GCSpropagate)
-    reallymarkobject(g, v);  /* restore invariant */
-  else  /* don't mind */
-    makewhite(g, o);  /* mark as white just to avoid other barriers */
-}
-
-
-void luaC_barrierback (lua_State *L, Table *t) {
-  global_State *g = G(L);
-  GCObject *o = obj2gco(t);
-  lua_assert(isblack(o) && !isdead(g, o));
-  lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
-  black2gray(o);  /* make table gray (again) */
-  t->gclist = g->grayagain;
-  g->grayagain = o;
-}
-
-
-void luaC_link (lua_State *L, GCObject *o, lu_byte tt) {
-  global_State *g = G(L);
-  o->gch.next = g->rootgc;
-  g->rootgc = o;
-  o->gch.marked = luaC_white(g);
-  o->gch.tt = tt;
-}
-
-
-void luaC_linkupval (lua_State *L, UpVal *uv) {
-  global_State *g = G(L);
-  GCObject *o = obj2gco(uv);
-  o->gch.next = g->rootgc;  /* link upvalue into `rootgc' list */
-  g->rootgc = o;
-  if (isgray(o)) { 
-    if (g->gcstate == GCSpropagate) {
-      gray2black(o);  /* closed upvalues need barrier */
-      luaC_barrier(L, uv, uv->v);
-    }
-    else {  /* sweep phase: sweep it (turning it into white) */
-      makewhite(g, o);
-      lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
-    }
-  }
-}
-
diff --git a/extern/lua-5.1.5/src/lgc.h b/extern/lua-5.1.5/src/lgc.h
deleted file mode 100644
index 5a8dc605..00000000
--- a/extern/lua-5.1.5/src/lgc.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-** $Id: lgc.h,v 2.15.1.1 2007/12/27 13:02:25 roberto Exp $
-** Garbage Collector
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lgc_h
-#define lgc_h
-
-
-#include "lobject.h"
-
-
-/*
-** Possible states of the Garbage Collector
-*/
-#define GCSpause	0
-#define GCSpropagate	1
-#define GCSsweepstring	2
-#define GCSsweep	3
-#define GCSfinalize	4
-
-
-/*
-** some userful bit tricks
-*/
-#define resetbits(x,m)	((x) &= cast(lu_byte, ~(m)))
-#define setbits(x,m)	((x) |= (m))
-#define testbits(x,m)	((x) & (m))
-#define bitmask(b)	(1<<(b))
-#define bit2mask(b1,b2)	(bitmask(b1) | bitmask(b2))
-#define l_setbit(x,b)	setbits(x, bitmask(b))
-#define resetbit(x,b)	resetbits(x, bitmask(b))
-#define testbit(x,b)	testbits(x, bitmask(b))
-#define set2bits(x,b1,b2)	setbits(x, (bit2mask(b1, b2)))
-#define reset2bits(x,b1,b2)	resetbits(x, (bit2mask(b1, b2)))
-#define test2bits(x,b1,b2)	testbits(x, (bit2mask(b1, b2)))
-
-
-
-/*
-** Layout for bit use in `marked' field:
-** bit 0 - object is white (type 0)
-** bit 1 - object is white (type 1)
-** bit 2 - object is black
-** bit 3 - for userdata: has been finalized
-** bit 3 - for tables: has weak keys
-** bit 4 - for tables: has weak values
-** bit 5 - object is fixed (should not be collected)
-** bit 6 - object is "super" fixed (only the main thread)
-*/
-
-
-#define WHITE0BIT	0
-#define WHITE1BIT	1
-#define BLACKBIT	2
-#define FINALIZEDBIT	3
-#define KEYWEAKBIT	3
-#define VALUEWEAKBIT	4
-#define FIXEDBIT	5
-#define SFIXEDBIT	6
-#define WHITEBITS	bit2mask(WHITE0BIT, WHITE1BIT)
-
-
-#define iswhite(x)      test2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
-#define isblack(x)      testbit((x)->gch.marked, BLACKBIT)
-#define isgray(x)	(!isblack(x) && !iswhite(x))
-
-#define otherwhite(g)	(g->currentwhite ^ WHITEBITS)
-#define isdead(g,v)	((v)->gch.marked & otherwhite(g) & WHITEBITS)
-
-#define changewhite(x)	((x)->gch.marked ^= WHITEBITS)
-#define gray2black(x)	l_setbit((x)->gch.marked, BLACKBIT)
-
-#define valiswhite(x)	(iscollectable(x) && iswhite(gcvalue(x)))
-
-#define luaC_white(g)	cast(lu_byte, (g)->currentwhite & WHITEBITS)
-
-
-#define luaC_checkGC(L) { \
-  condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1)); \
-  if (G(L)->totalbytes >= G(L)->GCthreshold) \
-	luaC_step(L); }
-
-
-#define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p)))  \
-	luaC_barrierf(L,obj2gco(p),gcvalue(v)); }
-
-#define luaC_barriert(L,t,v) { if (valiswhite(v) && isblack(obj2gco(t)))  \
-	luaC_barrierback(L,t); }
-
-#define luaC_objbarrier(L,p,o)  \
-	{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \
-		luaC_barrierf(L,obj2gco(p),obj2gco(o)); }
-
-#define luaC_objbarriert(L,t,o)  \
-   { if (iswhite(obj2gco(o)) && isblack(obj2gco(t))) luaC_barrierback(L,t); }
-
-LUAI_FUNC size_t luaC_separateudata (lua_State *L, int all);
-LUAI_FUNC void luaC_callGCTM (lua_State *L);
-LUAI_FUNC void luaC_freeall (lua_State *L);
-LUAI_FUNC void luaC_step (lua_State *L);
-LUAI_FUNC void luaC_fullgc (lua_State *L);
-LUAI_FUNC void luaC_link (lua_State *L, GCObject *o, lu_byte tt);
-LUAI_FUNC void luaC_linkupval (lua_State *L, UpVal *uv);
-LUAI_FUNC void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v);
-LUAI_FUNC void luaC_barrierback (lua_State *L, Table *t);
-
-
-#endif
diff --git a/extern/lua-5.1.5/src/linit.c b/extern/lua-5.1.5/src/linit.c
deleted file mode 100644
index c1f90dfa..00000000
--- a/extern/lua-5.1.5/src/linit.c
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
-** $Id: linit.c,v 1.14.1.1 2007/12/27 13:02:25 roberto Exp $
-** Initialization of libraries for lua.c
-** See Copyright Notice in lua.h
-*/
-
-
-#define linit_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lualib.h"
-#include "lauxlib.h"
-
-
-static const luaL_Reg lualibs[] = {
-  {"", luaopen_base},
-  {LUA_LOADLIBNAME, luaopen_package},
-  {LUA_TABLIBNAME, luaopen_table},
-  {LUA_IOLIBNAME, luaopen_io},
-  {LUA_OSLIBNAME, luaopen_os},
-  {LUA_STRLIBNAME, luaopen_string},
-  {LUA_MATHLIBNAME, luaopen_math},
-  {LUA_DBLIBNAME, luaopen_debug},
-  {NULL, NULL}
-};
-
-
-LUALIB_API void luaL_openlibs (lua_State *L) {
-  const luaL_Reg *lib = lualibs;
-  for (; lib->func; lib++) {
-    lua_pushcfunction(L, lib->func);
-    lua_pushstring(L, lib->name);
-    lua_call(L, 1, 0);
-  }
-}
-
diff --git a/extern/lua-5.1.5/src/liolib.c b/extern/lua-5.1.5/src/liolib.c
deleted file mode 100644
index 649f9a59..00000000
--- a/extern/lua-5.1.5/src/liolib.c
+++ /dev/null
@@ -1,556 +0,0 @@
-/*
-** $Id: liolib.c,v 2.73.1.4 2010/05/14 15:33:51 roberto Exp $
-** Standard I/O (and system) library
-** See Copyright Notice in lua.h
-*/
-
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define liolib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-
-#define IO_INPUT	1
-#define IO_OUTPUT	2
-
-
-static const char *const fnames[] = {"input", "output"};
-
-
-static int pushresult (lua_State *L, int i, const char *filename) {
-  int en = errno;  /* calls to Lua API may change this value */
-  if (i) {
-    lua_pushboolean(L, 1);
-    return 1;
-  }
-  else {
-    lua_pushnil(L);
-    if (filename)
-      lua_pushfstring(L, "%s: %s", filename, strerror(en));
-    else
-      lua_pushfstring(L, "%s", strerror(en));
-    lua_pushinteger(L, en);
-    return 3;
-  }
-}
-
-
-static void fileerror (lua_State *L, int arg, const char *filename) {
-  lua_pushfstring(L, "%s: %s", filename, strerror(errno));
-  luaL_argerror(L, arg, lua_tostring(L, -1));
-}
-
-
-#define tofilep(L)	((FILE **)luaL_checkudata(L, 1, LUA_FILEHANDLE))
-
-
-static int io_type (lua_State *L) {
-  void *ud;
-  luaL_checkany(L, 1);
-  ud = lua_touserdata(L, 1);
-  lua_getfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE);
-  if (ud == NULL || !lua_getmetatable(L, 1) || !lua_rawequal(L, -2, -1))
-    lua_pushnil(L);  /* not a file */
-  else if (*((FILE **)ud) == NULL)
-    lua_pushliteral(L, "closed file");
-  else
-    lua_pushliteral(L, "file");
-  return 1;
-}
-
-
-static FILE *tofile (lua_State *L) {
-  FILE **f = tofilep(L);
-  if (*f == NULL)
-    luaL_error(L, "attempt to use a closed file");
-  return *f;
-}
-
-
-
-/*
-** When creating file handles, always creates a `closed' file handle
-** before opening the actual file; so, if there is a memory error, the
-** file is not left opened.
-*/
-static FILE **newfile (lua_State *L) {
-  FILE **pf = (FILE **)lua_newuserdata(L, sizeof(FILE *));
-  *pf = NULL;  /* file handle is currently `closed' */
-  luaL_getmetatable(L, LUA_FILEHANDLE);
-  lua_setmetatable(L, -2);
-  return pf;
-}
-
-
-/*
-** function to (not) close the standard files stdin, stdout, and stderr
-*/
-static int io_noclose (lua_State *L) {
-  lua_pushnil(L);
-  lua_pushliteral(L, "cannot close standard file");
-  return 2;
-}
-
-
-/*
-** function to close 'popen' files
-*/
-static int io_pclose (lua_State *L) {
-  FILE **p = tofilep(L);
-  int ok = lua_pclose(L, *p);
-  *p = NULL;
-  return pushresult(L, ok, NULL);
-}
-
-
-/*
-** function to close regular files
-*/
-static int io_fclose (lua_State *L) {
-  FILE **p = tofilep(L);
-  int ok = (fclose(*p) == 0);
-  *p = NULL;
-  return pushresult(L, ok, NULL);
-}
-
-
-static int aux_close (lua_State *L) {
-  lua_getfenv(L, 1);
-  lua_getfield(L, -1, "__close");
-  return (lua_tocfunction(L, -1))(L);
-}
-
-
-static int io_close (lua_State *L) {
-  if (lua_isnone(L, 1))
-    lua_rawgeti(L, LUA_ENVIRONINDEX, IO_OUTPUT);
-  tofile(L);  /* make sure argument is a file */
-  return aux_close(L);
-}
-
-
-static int io_gc (lua_State *L) {
-  FILE *f = *tofilep(L);
-  /* ignore closed files */
-  if (f != NULL)
-    aux_close(L);
-  return 0;
-}
-
-
-static int io_tostring (lua_State *L) {
-  FILE *f = *tofilep(L);
-  if (f == NULL)
-    lua_pushliteral(L, "file (closed)");
-  else
-    lua_pushfstring(L, "file (%p)", f);
-  return 1;
-}
-
-
-static int io_open (lua_State *L) {
-  const char *filename = luaL_checkstring(L, 1);
-  const char *mode = luaL_optstring(L, 2, "r");
-  FILE **pf = newfile(L);
-  *pf = fopen(filename, mode);
-  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
-}
-
-
-/*
-** this function has a separated environment, which defines the
-** correct __close for 'popen' files
-*/
-static int io_popen (lua_State *L) {
-  const char *filename = luaL_checkstring(L, 1);
-  const char *mode = luaL_optstring(L, 2, "r");
-  FILE **pf = newfile(L);
-  *pf = lua_popen(L, filename, mode);
-  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
-}
-
-
-static int io_tmpfile (lua_State *L) {
-  FILE **pf = newfile(L);
-  *pf = tmpfile();
-  return (*pf == NULL) ? pushresult(L, 0, NULL) : 1;
-}
-
-
-static FILE *getiofile (lua_State *L, int findex) {
-  FILE *f;
-  lua_rawgeti(L, LUA_ENVIRONINDEX, findex);
-  f = *(FILE **)lua_touserdata(L, -1);
-  if (f == NULL)
-    luaL_error(L, "standard %s file is closed", fnames[findex - 1]);
-  return f;
-}
-
-
-static int g_iofile (lua_State *L, int f, const char *mode) {
-  if (!lua_isnoneornil(L, 1)) {
-    const char *filename = lua_tostring(L, 1);
-    if (filename) {
-      FILE **pf = newfile(L);
-      *pf = fopen(filename, mode);
-      if (*pf == NULL)
-        fileerror(L, 1, filename);
-    }
-    else {
-      tofile(L);  /* check that it's a valid file handle */
-      lua_pushvalue(L, 1);
-    }
-    lua_rawseti(L, LUA_ENVIRONINDEX, f);
-  }
-  /* return current value */
-  lua_rawgeti(L, LUA_ENVIRONINDEX, f);
-  return 1;
-}
-
-
-static int io_input (lua_State *L) {
-  return g_iofile(L, IO_INPUT, "r");
-}
-
-
-static int io_output (lua_State *L) {
-  return g_iofile(L, IO_OUTPUT, "w");
-}
-
-
-static int io_readline (lua_State *L);
-
-
-static void aux_lines (lua_State *L, int idx, int toclose) {
-  lua_pushvalue(L, idx);
-  lua_pushboolean(L, toclose);  /* close/not close file when finished */
-  lua_pushcclosure(L, io_readline, 2);
-}
-
-
-static int f_lines (lua_State *L) {
-  tofile(L);  /* check that it's a valid file handle */
-  aux_lines(L, 1, 0);
-  return 1;
-}
-
-
-static int io_lines (lua_State *L) {
-  if (lua_isnoneornil(L, 1)) {  /* no arguments? */
-    /* will iterate over default input */
-    lua_rawgeti(L, LUA_ENVIRONINDEX, IO_INPUT);
-    return f_lines(L);
-  }
-  else {
-    const char *filename = luaL_checkstring(L, 1);
-    FILE **pf = newfile(L);
-    *pf = fopen(filename, "r");
-    if (*pf == NULL)
-      fileerror(L, 1, filename);
-    aux_lines(L, lua_gettop(L), 1);
-    return 1;
-  }
-}
-
-
-/*
-** {======================================================
-** READ
-** =======================================================
-*/
-
-
-static int read_number (lua_State *L, FILE *f) {
-  lua_Number d;
-  if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {
-    lua_pushnumber(L, d);
-    return 1;
-  }
-  else {
-    lua_pushnil(L);  /* "result" to be removed */
-    return 0;  /* read fails */
-  }
-}
-
-
-static int test_eof (lua_State *L, FILE *f) {
-  int c = getc(f);
-  ungetc(c, f);
-  lua_pushlstring(L, NULL, 0);
-  return (c != EOF);
-}
-
-
-static int read_line (lua_State *L, FILE *f) {
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  for (;;) {
-    size_t l;
-    char *p = luaL_prepbuffer(&b);
-    if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) {  /* eof? */
-      luaL_pushresult(&b);  /* close buffer */
-      return (lua_objlen(L, -1) > 0);  /* check whether read something */
-    }
-    l = strlen(p);
-    if (l == 0 || p[l-1] != '\n')
-      luaL_addsize(&b, l);
-    else {
-      luaL_addsize(&b, l - 1);  /* do not include `eol' */
-      luaL_pushresult(&b);  /* close buffer */
-      return 1;  /* read at least an `eol' */
-    }
-  }
-}
-
-
-static int read_chars (lua_State *L, FILE *f, size_t n) {
-  size_t rlen;  /* how much to read */
-  size_t nr;  /* number of chars actually read */
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  rlen = LUAL_BUFFERSIZE;  /* try to read that much each time */
-  do {
-    char *p = luaL_prepbuffer(&b);
-    if (rlen > n) rlen = n;  /* cannot read more than asked */
-    nr = fread(p, sizeof(char), rlen, f);
-    luaL_addsize(&b, nr);
-    n -= nr;  /* still have to read `n' chars */
-  } while (n > 0 && nr == rlen);  /* until end of count or eof */
-  luaL_pushresult(&b);  /* close buffer */
-  return (n == 0 || lua_objlen(L, -1) > 0);
-}
-
-
-static int g_read (lua_State *L, FILE *f, int first) {
-  int nargs = lua_gettop(L) - 1;
-  int success;
-  int n;
-  clearerr(f);
-  if (nargs == 0) {  /* no arguments? */
-    success = read_line(L, f);
-    n = first+1;  /* to return 1 result */
-  }
-  else {  /* ensure stack space for all results and for auxlib's buffer */
-    luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
-    success = 1;
-    for (n = first; nargs-- && success; n++) {
-      if (lua_type(L, n) == LUA_TNUMBER) {
-        size_t l = (size_t)lua_tointeger(L, n);
-        success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);
-      }
-      else {
-        const char *p = lua_tostring(L, n);
-        luaL_argcheck(L, p && p[0] == '*', n, "invalid option");
-        switch (p[1]) {
-          case 'n':  /* number */
-            success = read_number(L, f);
-            break;
-          case 'l':  /* line */
-            success = read_line(L, f);
-            break;
-          case 'a':  /* file */
-            read_chars(L, f, ~((size_t)0));  /* read MAX_SIZE_T chars */
-            success = 1; /* always success */
-            break;
-          default:
-            return luaL_argerror(L, n, "invalid format");
-        }
-      }
-    }
-  }
-  if (ferror(f))
-    return pushresult(L, 0, NULL);
-  if (!success) {
-    lua_pop(L, 1);  /* remove last result */
-    lua_pushnil(L);  /* push nil instead */
-  }
-  return n - first;
-}
-
-
-static int io_read (lua_State *L) {
-  return g_read(L, getiofile(L, IO_INPUT), 1);
-}
-
-
-static int f_read (lua_State *L) {
-  return g_read(L, tofile(L), 2);
-}
-
-
-static int io_readline (lua_State *L) {
-  FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));
-  int sucess;
-  if (f == NULL)  /* file is already closed? */
-    luaL_error(L, "file is already closed");
-  sucess = read_line(L, f);
-  if (ferror(f))
-    return luaL_error(L, "%s", strerror(errno));
-  if (sucess) return 1;
-  else {  /* EOF */
-    if (lua_toboolean(L, lua_upvalueindex(2))) {  /* generator created file? */
-      lua_settop(L, 0);
-      lua_pushvalue(L, lua_upvalueindex(1));
-      aux_close(L);  /* close it */
-    }
-    return 0;
-  }
-}
-
-/* }====================================================== */
-
-
-static int g_write (lua_State *L, FILE *f, int arg) {
-  int nargs = lua_gettop(L) - 1;
-  int status = 1;
-  for (; nargs--; arg++) {
-    if (lua_type(L, arg) == LUA_TNUMBER) {
-      /* optimization: could be done exactly as for strings */
-      status = status &&
-          fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;
-    }
-    else {
-      size_t l;
-      const char *s = luaL_checklstring(L, arg, &l);
-      status = status && (fwrite(s, sizeof(char), l, f) == l);
-    }
-  }
-  return pushresult(L, status, NULL);
-}
-
-
-static int io_write (lua_State *L) {
-  return g_write(L, getiofile(L, IO_OUTPUT), 1);
-}
-
-
-static int f_write (lua_State *L) {
-  return g_write(L, tofile(L), 2);
-}
-
-
-static int f_seek (lua_State *L) {
-  static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
-  static const char *const modenames[] = {"set", "cur", "end", NULL};
-  FILE *f = tofile(L);
-  int op = luaL_checkoption(L, 2, "cur", modenames);
-  long offset = luaL_optlong(L, 3, 0);
-  op = fseek(f, offset, mode[op]);
-  if (op)
-    return pushresult(L, 0, NULL);  /* error */
-  else {
-    lua_pushinteger(L, ftell(f));
-    return 1;
-  }
-}
-
-
-static int f_setvbuf (lua_State *L) {
-  static const int mode[] = {_IONBF, _IOFBF, _IOLBF};
-  static const char *const modenames[] = {"no", "full", "line", NULL};
-  FILE *f = tofile(L);
-  int op = luaL_checkoption(L, 2, NULL, modenames);
-  lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
-  int res = setvbuf(f, NULL, mode[op], sz);
-  return pushresult(L, res == 0, NULL);
-}
-
-
-
-static int io_flush (lua_State *L) {
-  return pushresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);
-}
-
-
-static int f_flush (lua_State *L) {
-  return pushresult(L, fflush(tofile(L)) == 0, NULL);
-}
-
-
-static const luaL_Reg iolib[] = {
-  {"close", io_close},
-  {"flush", io_flush},
-  {"input", io_input},
-  {"lines", io_lines},
-  {"open", io_open},
-  {"output", io_output},
-  {"popen", io_popen},
-  {"read", io_read},
-  {"tmpfile", io_tmpfile},
-  {"type", io_type},
-  {"write", io_write},
-  {NULL, NULL}
-};
-
-
-static const luaL_Reg flib[] = {
-  {"close", io_close},
-  {"flush", f_flush},
-  {"lines", f_lines},
-  {"read", f_read},
-  {"seek", f_seek},
-  {"setvbuf", f_setvbuf},
-  {"write", f_write},
-  {"__gc", io_gc},
-  {"__tostring", io_tostring},
-  {NULL, NULL}
-};
-
-
-static void createmeta (lua_State *L) {
-  luaL_newmetatable(L, LUA_FILEHANDLE);  /* create metatable for file handles */
-  lua_pushvalue(L, -1);  /* push metatable */
-  lua_setfield(L, -2, "__index");  /* metatable.__index = metatable */
-  luaL_register(L, NULL, flib);  /* file methods */
-}
-
-
-static void createstdfile (lua_State *L, FILE *f, int k, const char *fname) {
-  *newfile(L) = f;
-  if (k > 0) {
-    lua_pushvalue(L, -1);
-    lua_rawseti(L, LUA_ENVIRONINDEX, k);
-  }
-  lua_pushvalue(L, -2);  /* copy environment */
-  lua_setfenv(L, -2);  /* set it */
-  lua_setfield(L, -3, fname);
-}
-
-
-static void newfenv (lua_State *L, lua_CFunction cls) {
-  lua_createtable(L, 0, 1);
-  lua_pushcfunction(L, cls);
-  lua_setfield(L, -2, "__close");
-}
-
-
-LUALIB_API int luaopen_io (lua_State *L) {
-  createmeta(L);
-  /* create (private) environment (with fields IO_INPUT, IO_OUTPUT, __close) */
-  newfenv(L, io_fclose);
-  lua_replace(L, LUA_ENVIRONINDEX);
-  /* open library */
-  luaL_register(L, LUA_IOLIBNAME, iolib);
-  /* create (and set) default files */
-  newfenv(L, io_noclose);  /* close function for default files */
-  createstdfile(L, stdin, IO_INPUT, "stdin");
-  createstdfile(L, stdout, IO_OUTPUT, "stdout");
-  createstdfile(L, stderr, 0, "stderr");
-  lua_pop(L, 1);  /* pop environment for default files */
-  lua_getfield(L, -1, "popen");
-  newfenv(L, io_pclose);  /* create environment for 'popen' */
-  lua_setfenv(L, -2);  /* set fenv for 'popen' */
-  lua_pop(L, 1);  /* pop 'popen' */
-  return 1;
-}
-
diff --git a/extern/lua-5.1.5/src/llex.c b/extern/lua-5.1.5/src/llex.c
deleted file mode 100644
index 88c6790c..00000000
--- a/extern/lua-5.1.5/src/llex.c
+++ /dev/null
@@ -1,463 +0,0 @@
-/*
-** $Id: llex.c,v 2.20.1.2 2009/11/23 14:58:22 roberto Exp $
-** Lexical Analyzer
-** See Copyright Notice in lua.h
-*/
-
-
-#include <ctype.h>
-#include <locale.h>
-#include <string.h>
-
-#define llex_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldo.h"
-#include "llex.h"
-#include "lobject.h"
-#include "lparser.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "lzio.h"
-
-
-
-#define next(ls) (ls->current = zgetc(ls->z))
-
-
-
-
-#define currIsNewline(ls)	(ls->current == '\n' || ls->current == '\r')
-
-
-/* ORDER RESERVED */
-const char *const luaX_tokens [] = {
-    "and", "break", "do", "else", "elseif",
-    "end", "false", "for", "function", "if",
-    "in", "local", "nil", "not", "or", "repeat",
-    "return", "then", "true", "until", "while",
-    "..", "...", "==", ">=", "<=", "~=",
-    "<number>", "<name>", "<string>", "<eof>",
-    NULL
-};
-
-
-#define save_and_next(ls) (save(ls, ls->current), next(ls))
-
-
-static void save (LexState *ls, int c) {
-  Mbuffer *b = ls->buff;
-  if (b->n + 1 > b->buffsize) {
-    size_t newsize;
-    if (b->buffsize >= MAX_SIZET/2)
-      luaX_lexerror(ls, "lexical element too long", 0);
-    newsize = b->buffsize * 2;
-    luaZ_resizebuffer(ls->L, b, newsize);
-  }
-  b->buffer[b->n++] = cast(char, c);
-}
-
-
-void luaX_init (lua_State *L) {
-  int i;
-  for (i=0; i<NUM_RESERVED; i++) {
-    TString *ts = luaS_new(L, luaX_tokens[i]);
-    luaS_fix(ts);  /* reserved words are never collected */
-    lua_assert(strlen(luaX_tokens[i])+1 <= TOKEN_LEN);
-    ts->tsv.reserved = cast_byte(i+1);  /* reserved word */
-  }
-}
-
-
-#define MAXSRC          80
-
-
-const char *luaX_token2str (LexState *ls, int token) {
-  if (token < FIRST_RESERVED) {
-    lua_assert(token == cast(unsigned char, token));
-    return (iscntrl(token)) ? luaO_pushfstring(ls->L, "char(%d)", token) :
-                              luaO_pushfstring(ls->L, "%c", token);
-  }
-  else
-    return luaX_tokens[token-FIRST_RESERVED];
-}
-
-
-static const char *txtToken (LexState *ls, int token) {
-  switch (token) {
-    case TK_NAME:
-    case TK_STRING:
-    case TK_NUMBER:
-      save(ls, '\0');
-      return luaZ_buffer(ls->buff);
-    default:
-      return luaX_token2str(ls, token);
-  }
-}
-
-
-void luaX_lexerror (LexState *ls, const char *msg, int token) {
-  char buff[MAXSRC];
-  luaO_chunkid(buff, getstr(ls->source), MAXSRC);
-  msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg);
-  if (token)
-    luaO_pushfstring(ls->L, "%s near " LUA_QS, msg, txtToken(ls, token));
-  luaD_throw(ls->L, LUA_ERRSYNTAX);
-}
-
-
-void luaX_syntaxerror (LexState *ls, const char *msg) {
-  luaX_lexerror(ls, msg, ls->t.token);
-}
-
-
-TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
-  lua_State *L = ls->L;
-  TString *ts = luaS_newlstr(L, str, l);
-  TValue *o = luaH_setstr(L, ls->fs->h, ts);  /* entry for `str' */
-  if (ttisnil(o)) {
-    setbvalue(o, 1);  /* make sure `str' will not be collected */
-    luaC_checkGC(L);
-  }
-  return ts;
-}
-
-
-static void inclinenumber (LexState *ls) {
-  int old = ls->current;
-  lua_assert(currIsNewline(ls));
-  next(ls);  /* skip `\n' or `\r' */
-  if (currIsNewline(ls) && ls->current != old)
-    next(ls);  /* skip `\n\r' or `\r\n' */
-  if (++ls->linenumber >= MAX_INT)
-    luaX_syntaxerror(ls, "chunk has too many lines");
-}
-
-
-void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source) {
-  ls->decpoint = '.';
-  ls->L = L;
-  ls->lookahead.token = TK_EOS;  /* no look-ahead token */
-  ls->z = z;
-  ls->fs = NULL;
-  ls->linenumber = 1;
-  ls->lastline = 1;
-  ls->source = source;
-  luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */
-  next(ls);  /* read first char */
-}
-
-
-
-/*
-** =======================================================
-** LEXICAL ANALYZER
-** =======================================================
-*/
-
-
-
-static int check_next (LexState *ls, const char *set) {
-  if (!strchr(set, ls->current))
-    return 0;
-  save_and_next(ls);
-  return 1;
-}
-
-
-static void buffreplace (LexState *ls, char from, char to) {
-  size_t n = luaZ_bufflen(ls->buff);
-  char *p = luaZ_buffer(ls->buff);
-  while (n--)
-    if (p[n] == from) p[n] = to;
-}
-
-
-static void trydecpoint (LexState *ls, SemInfo *seminfo) {
-  /* format error: try to update decimal point separator */
-  struct lconv *cv = localeconv();
-  char old = ls->decpoint;
-  ls->decpoint = (cv ? cv->decimal_point[0] : '.');
-  buffreplace(ls, old, ls->decpoint);  /* try updated decimal separator */
-  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r)) {
-    /* format error with correct decimal point: no more options */
-    buffreplace(ls, ls->decpoint, '.');  /* undo change (for error message) */
-    luaX_lexerror(ls, "malformed number", TK_NUMBER);
-  }
-}
-
-
-/* LUA_NUMBER */
-static void read_numeral (LexState *ls, SemInfo *seminfo) {
-  lua_assert(isdigit(ls->current));
-  do {
-    save_and_next(ls);
-  } while (isdigit(ls->current) || ls->current == '.');
-  if (check_next(ls, "Ee"))  /* `E'? */
-    check_next(ls, "+-");  /* optional exponent sign */
-  while (isalnum(ls->current) || ls->current == '_')
-    save_and_next(ls);
-  save(ls, '\0');
-  buffreplace(ls, '.', ls->decpoint);  /* follow locale for decimal point */
-  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r))  /* format error? */
-    trydecpoint(ls, seminfo); /* try to update decimal point separator */
-}
-
-
-static int skip_sep (LexState *ls) {
-  int count = 0;
-  int s = ls->current;
-  lua_assert(s == '[' || s == ']');
-  save_and_next(ls);
-  while (ls->current == '=') {
-    save_and_next(ls);
-    count++;
-  }
-  return (ls->current == s) ? count : (-count) - 1;
-}
-
-
-static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {
-  int cont = 0;
-  (void)(cont);  /* avoid warnings when `cont' is not used */
-  save_and_next(ls);  /* skip 2nd `[' */
-  if (currIsNewline(ls))  /* string starts with a newline? */
-    inclinenumber(ls);  /* skip it */
-  for (;;) {
-    switch (ls->current) {
-      case EOZ:
-        luaX_lexerror(ls, (seminfo) ? "unfinished long string" :
-                                   "unfinished long comment", TK_EOS);
-        break;  /* to avoid warnings */
-#if defined(LUA_COMPAT_LSTR)
-      case '[': {
-        if (skip_sep(ls) == sep) {
-          save_and_next(ls);  /* skip 2nd `[' */
-          cont++;
-#if LUA_COMPAT_LSTR == 1
-          if (sep == 0)
-            luaX_lexerror(ls, "nesting of [[...]] is deprecated", '[');
-#endif
-        }
-        break;
-      }
-#endif
-      case ']': {
-        if (skip_sep(ls) == sep) {
-          save_and_next(ls);  /* skip 2nd `]' */
-#if defined(LUA_COMPAT_LSTR) && LUA_COMPAT_LSTR == 2
-          cont--;
-          if (sep == 0 && cont >= 0) break;
-#endif
-          goto endloop;
-        }
-        break;
-      }
-      case '\n':
-      case '\r': {
-        save(ls, '\n');
-        inclinenumber(ls);
-        if (!seminfo) luaZ_resetbuffer(ls->buff);  /* avoid wasting space */
-        break;
-      }
-      default: {
-        if (seminfo) save_and_next(ls);
-        else next(ls);
-      }
-    }
-  } endloop:
-  if (seminfo)
-    seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),
-                                     luaZ_bufflen(ls->buff) - 2*(2 + sep));
-}
-
-
-static void read_string (LexState *ls, int del, SemInfo *seminfo) {
-  save_and_next(ls);
-  while (ls->current != del) {
-    switch (ls->current) {
-      case EOZ:
-        luaX_lexerror(ls, "unfinished string", TK_EOS);
-        continue;  /* to avoid warnings */
-      case '\n':
-      case '\r':
-        luaX_lexerror(ls, "unfinished string", TK_STRING);
-        continue;  /* to avoid warnings */
-      case '\\': {
-        int c;
-        next(ls);  /* do not save the `\' */
-        switch (ls->current) {
-          case 'a': c = '\a'; break;
-          case 'b': c = '\b'; break;
-          case 'f': c = '\f'; break;
-          case 'n': c = '\n'; break;
-          case 'r': c = '\r'; break;
-          case 't': c = '\t'; break;
-          case 'v': c = '\v'; break;
-          case '\n':  /* go through */
-          case '\r': save(ls, '\n'); inclinenumber(ls); continue;
-          case EOZ: continue;  /* will raise an error next loop */
-          default: {
-            if (!isdigit(ls->current))
-              save_and_next(ls);  /* handles \\, \", \', and \? */
-            else {  /* \xxx */
-              int i = 0;
-              c = 0;
-              do {
-                c = 10*c + (ls->current-'0');
-                next(ls);
-              } while (++i<3 && isdigit(ls->current));
-              if (c > UCHAR_MAX)
-                luaX_lexerror(ls, "escape sequence too large", TK_STRING);
-              save(ls, c);
-            }
-            continue;
-          }
-        }
-        save(ls, c);
-        next(ls);
-        continue;
-      }
-      default:
-        save_and_next(ls);
-    }
-  }
-  save_and_next(ls);  /* skip delimiter */
-  seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1,
-                                   luaZ_bufflen(ls->buff) - 2);
-}
-
-
-static int llex (LexState *ls, SemInfo *seminfo) {
-  luaZ_resetbuffer(ls->buff);
-  for (;;) {
-    switch (ls->current) {
-      case '\n':
-      case '\r': {
-        inclinenumber(ls);
-        continue;
-      }
-      case '-': {
-        next(ls);
-        if (ls->current != '-') return '-';
-        /* else is a comment */
-        next(ls);
-        if (ls->current == '[') {
-          int sep = skip_sep(ls);
-          luaZ_resetbuffer(ls->buff);  /* `skip_sep' may dirty the buffer */
-          if (sep >= 0) {
-            read_long_string(ls, NULL, sep);  /* long comment */
-            luaZ_resetbuffer(ls->buff);
-            continue;
-          }
-        }
-        /* else short comment */
-        while (!currIsNewline(ls) && ls->current != EOZ)
-          next(ls);
-        continue;
-      }
-      case '[': {
-        int sep = skip_sep(ls);
-        if (sep >= 0) {
-          read_long_string(ls, seminfo, sep);
-          return TK_STRING;
-        }
-        else if (sep == -1) return '[';
-        else luaX_lexerror(ls, "invalid long string delimiter", TK_STRING);
-      }
-      case '=': {
-        next(ls);
-        if (ls->current != '=') return '=';
-        else { next(ls); return TK_EQ; }
-      }
-      case '<': {
-        next(ls);
-        if (ls->current != '=') return '<';
-        else { next(ls); return TK_LE; }
-      }
-      case '>': {
-        next(ls);
-        if (ls->current != '=') return '>';
-        else { next(ls); return TK_GE; }
-      }
-      case '~': {
-        next(ls);
-        if (ls->current != '=') return '~';
-        else { next(ls); return TK_NE; }
-      }
-      case '"':
-      case '\'': {
-        read_string(ls, ls->current, seminfo);
-        return TK_STRING;
-      }
-      case '.': {
-        save_and_next(ls);
-        if (check_next(ls, ".")) {
-          if (check_next(ls, "."))
-            return TK_DOTS;   /* ... */
-          else return TK_CONCAT;   /* .. */
-        }
-        else if (!isdigit(ls->current)) return '.';
-        else {
-          read_numeral(ls, seminfo);
-          return TK_NUMBER;
-        }
-      }
-      case EOZ: {
-        return TK_EOS;
-      }
-      default: {
-        if (isspace(ls->current)) {
-          lua_assert(!currIsNewline(ls));
-          next(ls);
-          continue;
-        }
-        else if (isdigit(ls->current)) {
-          read_numeral(ls, seminfo);
-          return TK_NUMBER;
-        }
-        else if (isalpha(ls->current) || ls->current == '_') {
-          /* identifier or reserved word */
-          TString *ts;
-          do {
-            save_and_next(ls);
-          } while (isalnum(ls->current) || ls->current == '_');
-          ts = luaX_newstring(ls, luaZ_buffer(ls->buff),
-                                  luaZ_bufflen(ls->buff));
-          if (ts->tsv.reserved > 0)  /* reserved word? */
-            return ts->tsv.reserved - 1 + FIRST_RESERVED;
-          else {
-            seminfo->ts = ts;
-            return TK_NAME;
-          }
-        }
-        else {
-          int c = ls->current;
-          next(ls);
-          return c;  /* single-char tokens (+ - / ...) */
-        }
-      }
-    }
-  }
-}
-
-
-void luaX_next (LexState *ls) {
-  ls->lastline = ls->linenumber;
-  if (ls->lookahead.token != TK_EOS) {  /* is there a look-ahead token? */
-    ls->t = ls->lookahead;  /* use this one */
-    ls->lookahead.token = TK_EOS;  /* and discharge it */
-  }
-  else
-    ls->t.token = llex(ls, &ls->t.seminfo);  /* read next token */
-}
-
-
-void luaX_lookahead (LexState *ls) {
-  lua_assert(ls->lookahead.token == TK_EOS);
-  ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);
-}
-
diff --git a/extern/lua-5.1.5/src/llex.h b/extern/lua-5.1.5/src/llex.h
deleted file mode 100644
index a9201cee..00000000
--- a/extern/lua-5.1.5/src/llex.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
-** $Id: llex.h,v 1.58.1.1 2007/12/27 13:02:25 roberto Exp $
-** Lexical Analyzer
-** See Copyright Notice in lua.h
-*/
-
-#ifndef llex_h
-#define llex_h
-
-#include "lobject.h"
-#include "lzio.h"
-
-
-#define FIRST_RESERVED	257
-
-/* maximum length of a reserved word */
-#define TOKEN_LEN	(sizeof("function")/sizeof(char))
-
-
-/*
-* WARNING: if you change the order of this enumeration,
-* grep "ORDER RESERVED"
-*/
-enum RESERVED {
-  /* terminal symbols denoted by reserved words */
-  TK_AND = FIRST_RESERVED, TK_BREAK,
-  TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION,
-  TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
-  TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
-  /* other terminal symbols */
-  TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_NUMBER,
-  TK_NAME, TK_STRING, TK_EOS
-};
-
-/* number of reserved words */
-#define NUM_RESERVED	(cast(int, TK_WHILE-FIRST_RESERVED+1))
-
-
-/* array with token `names' */
-LUAI_DATA const char *const luaX_tokens [];
-
-
-typedef union {
-  lua_Number r;
-  TString *ts;
-} SemInfo;  /* semantics information */
-
-
-typedef struct Token {
-  int token;
-  SemInfo seminfo;
-} Token;
-
-
-typedef struct LexState {
-  int current;  /* current character (charint) */
-  int linenumber;  /* input line counter */
-  int lastline;  /* line of last token `consumed' */
-  Token t;  /* current token */
-  Token lookahead;  /* look ahead token */
-  struct FuncState *fs;  /* `FuncState' is private to the parser */
-  struct lua_State *L;
-  ZIO *z;  /* input stream */
-  Mbuffer *buff;  /* buffer for tokens */
-  TString *source;  /* current source name */
-  char decpoint;  /* locale decimal point */
-} LexState;
-
-
-LUAI_FUNC void luaX_init (lua_State *L);
-LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,
-                              TString *source);
-LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);
-LUAI_FUNC void luaX_next (LexState *ls);
-LUAI_FUNC void luaX_lookahead (LexState *ls);
-LUAI_FUNC void luaX_lexerror (LexState *ls, const char *msg, int token);
-LUAI_FUNC void luaX_syntaxerror (LexState *ls, const char *s);
-LUAI_FUNC const char *luaX_token2str (LexState *ls, int token);
-
-
-#endif
diff --git a/extern/lua-5.1.5/src/llimits.h b/extern/lua-5.1.5/src/llimits.h
deleted file mode 100644
index ca8dcb72..00000000
--- a/extern/lua-5.1.5/src/llimits.h
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
-** $Id: llimits.h,v 1.69.1.1 2007/12/27 13:02:25 roberto Exp $
-** Limits, basic types, and some other `installation-dependent' definitions
-** See Copyright Notice in lua.h
-*/
-
-#ifndef llimits_h
-#define llimits_h
-
-
-#include <limits.h>
-#include <stddef.h>
-
-
-#include "lua.h"
-
-
-typedef LUAI_UINT32 lu_int32;
-
-typedef LUAI_UMEM lu_mem;
-
-typedef LUAI_MEM l_mem;
-
-
-
-/* chars used as small naturals (so that `char' is reserved for characters) */
-typedef unsigned char lu_byte;
-
-
-#define MAX_SIZET	((size_t)(~(size_t)0)-2)
-
-#define MAX_LUMEM	((lu_mem)(~(lu_mem)0)-2)
-
-
-#define MAX_INT (INT_MAX-2)  /* maximum value of an int (-2 for safety) */
-
-/*
-** conversion of pointer to integer
-** this is for hashing only; there is no problem if the integer
-** cannot hold the whole pointer value
-*/
-#define IntPoint(p)  ((unsigned int)(lu_mem)(p))
-
-
-
-/* type to ensure maximum alignment */
-typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
-
-
-/* result of a `usual argument conversion' over lua_Number */
-typedef LUAI_UACNUMBER l_uacNumber;
-
-
-/* internal assertions for in-house debugging */
-#ifdef lua_assert
-
-#define check_exp(c,e)		(lua_assert(c), (e))
-#define api_check(l,e)		lua_assert(e)
-
-#else
-
-#define lua_assert(c)		((void)0)
-#define check_exp(c,e)		(e)
-#define api_check		luai_apicheck
-
-#endif
-
-
-#ifndef UNUSED
-#define UNUSED(x)	((void)(x))	/* to avoid warnings */
-#endif
-
-
-#ifndef cast
-#define cast(t, exp)	((t)(exp))
-#endif
-
-#define cast_byte(i)	cast(lu_byte, (i))
-#define cast_num(i)	cast(lua_Number, (i))
-#define cast_int(i)	cast(int, (i))
-
-
-
-/*
-** type for virtual-machine instructions
-** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
-*/
-typedef lu_int32 Instruction;
-
-
-
-/* maximum stack for a Lua function */
-#define MAXSTACK	250
-
-
-
-/* minimum size for the string table (must be power of 2) */
-#ifndef MINSTRTABSIZE
-#define MINSTRTABSIZE	32
-#endif
-
-
-/* minimum size for string buffer */
-#ifndef LUA_MINBUFFER
-#define LUA_MINBUFFER	32
-#endif
-
-
-#ifndef lua_lock
-#define lua_lock(L)     ((void) 0) 
-#define lua_unlock(L)   ((void) 0)
-#endif
-
-#ifndef luai_threadyield
-#define luai_threadyield(L)     {lua_unlock(L); lua_lock(L);}
-#endif
-
-
-/*
-** macro to control inclusion of some hard tests on stack reallocation
-*/ 
-#ifndef HARDSTACKTESTS
-#define condhardstacktests(x)	((void)0)
-#else
-#define condhardstacktests(x)	x
-#endif
-
-#endif
diff --git a/extern/lua-5.1.5/src/lmathlib.c b/extern/lua-5.1.5/src/lmathlib.c
deleted file mode 100644
index 441fbf73..00000000
--- a/extern/lua-5.1.5/src/lmathlib.c
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
-** $Id: lmathlib.c,v 1.67.1.1 2007/12/27 13:02:25 roberto Exp $
-** Standard mathematical library
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stdlib.h>
-#include <math.h>
-
-#define lmathlib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-#undef PI
-#define PI (3.14159265358979323846)
-#define RADIANS_PER_DEGREE (PI/180.0)
-
-
-
-static int math_abs (lua_State *L) {
-  lua_pushnumber(L, fabs(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_sin (lua_State *L) {
-  lua_pushnumber(L, sin(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_sinh (lua_State *L) {
-  lua_pushnumber(L, sinh(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_cos (lua_State *L) {
-  lua_pushnumber(L, cos(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_cosh (lua_State *L) {
-  lua_pushnumber(L, cosh(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_tan (lua_State *L) {
-  lua_pushnumber(L, tan(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_tanh (lua_State *L) {
-  lua_pushnumber(L, tanh(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_asin (lua_State *L) {
-  lua_pushnumber(L, asin(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_acos (lua_State *L) {
-  lua_pushnumber(L, acos(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_atan (lua_State *L) {
-  lua_pushnumber(L, atan(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_atan2 (lua_State *L) {
-  lua_pushnumber(L, atan2(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
-  return 1;
-}
-
-static int math_ceil (lua_State *L) {
-  lua_pushnumber(L, ceil(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_floor (lua_State *L) {
-  lua_pushnumber(L, floor(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_fmod (lua_State *L) {
-  lua_pushnumber(L, fmod(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
-  return 1;
-}
-
-static int math_modf (lua_State *L) {
-  double ip;
-  double fp = modf(luaL_checknumber(L, 1), &ip);
-  lua_pushnumber(L, ip);
-  lua_pushnumber(L, fp);
-  return 2;
-}
-
-static int math_sqrt (lua_State *L) {
-  lua_pushnumber(L, sqrt(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_pow (lua_State *L) {
-  lua_pushnumber(L, pow(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
-  return 1;
-}
-
-static int math_log (lua_State *L) {
-  lua_pushnumber(L, log(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_log10 (lua_State *L) {
-  lua_pushnumber(L, log10(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_exp (lua_State *L) {
-  lua_pushnumber(L, exp(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_deg (lua_State *L) {
-  lua_pushnumber(L, luaL_checknumber(L, 1)/RADIANS_PER_DEGREE);
-  return 1;
-}
-
-static int math_rad (lua_State *L) {
-  lua_pushnumber(L, luaL_checknumber(L, 1)*RADIANS_PER_DEGREE);
-  return 1;
-}
-
-static int math_frexp (lua_State *L) {
-  int e;
-  lua_pushnumber(L, frexp(luaL_checknumber(L, 1), &e));
-  lua_pushinteger(L, e);
-  return 2;
-}
-
-static int math_ldexp (lua_State *L) {
-  lua_pushnumber(L, ldexp(luaL_checknumber(L, 1), luaL_checkint(L, 2)));
-  return 1;
-}
-
-
-
-static int math_min (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  lua_Number dmin = luaL_checknumber(L, 1);
-  int i;
-  for (i=2; i<=n; i++) {
-    lua_Number d = luaL_checknumber(L, i);
-    if (d < dmin)
-      dmin = d;
-  }
-  lua_pushnumber(L, dmin);
-  return 1;
-}
-
-
-static int math_max (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  lua_Number dmax = luaL_checknumber(L, 1);
-  int i;
-  for (i=2; i<=n; i++) {
-    lua_Number d = luaL_checknumber(L, i);
-    if (d > dmax)
-      dmax = d;
-  }
-  lua_pushnumber(L, dmax);
-  return 1;
-}
-
-
-static int math_random (lua_State *L) {
-  /* the `%' avoids the (rare) case of r==1, and is needed also because on
-     some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
-  lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX;
-  switch (lua_gettop(L)) {  /* check number of arguments */
-    case 0: {  /* no arguments */
-      lua_pushnumber(L, r);  /* Number between 0 and 1 */
-      break;
-    }
-    case 1: {  /* only upper limit */
-      int u = luaL_checkint(L, 1);
-      luaL_argcheck(L, 1<=u, 1, "interval is empty");
-      lua_pushnumber(L, floor(r*u)+1);  /* int between 1 and `u' */
-      break;
-    }
-    case 2: {  /* lower and upper limits */
-      int l = luaL_checkint(L, 1);
-      int u = luaL_checkint(L, 2);
-      luaL_argcheck(L, l<=u, 2, "interval is empty");
-      lua_pushnumber(L, floor(r*(u-l+1))+l);  /* int between `l' and `u' */
-      break;
-    }
-    default: return luaL_error(L, "wrong number of arguments");
-  }
-  return 1;
-}
-
-
-static int math_randomseed (lua_State *L) {
-  srand(luaL_checkint(L, 1));
-  return 0;
-}
-
-
-static const luaL_Reg mathlib[] = {
-  {"abs",   math_abs},
-  {"acos",  math_acos},
-  {"asin",  math_asin},
-  {"atan2", math_atan2},
-  {"atan",  math_atan},
-  {"ceil",  math_ceil},
-  {"cosh",   math_cosh},
-  {"cos",   math_cos},
-  {"deg",   math_deg},
-  {"exp",   math_exp},
-  {"floor", math_floor},
-  {"fmod",   math_fmod},
-  {"frexp", math_frexp},
-  {"ldexp", math_ldexp},
-  {"log10", math_log10},
-  {"log",   math_log},
-  {"max",   math_max},
-  {"min",   math_min},
-  {"modf",   math_modf},
-  {"pow",   math_pow},
-  {"rad",   math_rad},
-  {"random",     math_random},
-  {"randomseed", math_randomseed},
-  {"sinh",   math_sinh},
-  {"sin",   math_sin},
-  {"sqrt",  math_sqrt},
-  {"tanh",   math_tanh},
-  {"tan",   math_tan},
-  {NULL, NULL}
-};
-
-
-/*
-** Open math library
-*/
-LUALIB_API int luaopen_math (lua_State *L) {
-  luaL_register(L, LUA_MATHLIBNAME, mathlib);
-  lua_pushnumber(L, PI);
-  lua_setfield(L, -2, "pi");
-  lua_pushnumber(L, HUGE_VAL);
-  lua_setfield(L, -2, "huge");
-#if defined(LUA_COMPAT_MOD)
-  lua_getfield(L, -1, "fmod");
-  lua_setfield(L, -2, "mod");
-#endif
-  return 1;
-}
-
diff --git a/extern/lua-5.1.5/src/lmem.c b/extern/lua-5.1.5/src/lmem.c
deleted file mode 100644
index ae7d8c96..00000000
--- a/extern/lua-5.1.5/src/lmem.c
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
-** $Id: lmem.c,v 1.70.1.1 2007/12/27 13:02:25 roberto Exp $
-** Interface to Memory Manager
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stddef.h>
-
-#define lmem_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-
-
-
-/*
-** About the realloc function:
-** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
-** (`osize' is the old size, `nsize' is the new size)
-**
-** Lua ensures that (ptr == NULL) iff (osize == 0).
-**
-** * frealloc(ud, NULL, 0, x) creates a new block of size `x'
-**
-** * frealloc(ud, p, x, 0) frees the block `p'
-** (in this specific case, frealloc must return NULL).
-** particularly, frealloc(ud, NULL, 0, 0) does nothing
-** (which is equivalent to free(NULL) in ANSI C)
-**
-** frealloc returns NULL if it cannot create or reallocate the area
-** (any reallocation to an equal or smaller size cannot fail!)
-*/
-
-
-
-#define MINSIZEARRAY	4
-
-
-void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
-                     int limit, const char *errormsg) {
-  void *newblock;
-  int newsize;
-  if (*size >= limit/2) {  /* cannot double it? */
-    if (*size >= limit)  /* cannot grow even a little? */
-      luaG_runerror(L, errormsg);
-    newsize = limit;  /* still have at least one free place */
-  }
-  else {
-    newsize = (*size)*2;
-    if (newsize < MINSIZEARRAY)
-      newsize = MINSIZEARRAY;  /* minimum size */
-  }
-  newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
-  *size = newsize;  /* update only when everything else is OK */
-  return newblock;
-}
-
-
-void *luaM_toobig (lua_State *L) {
-  luaG_runerror(L, "memory allocation error: block too big");
-  return NULL;  /* to avoid warnings */
-}
-
-
-
-/*
-** generic allocation routine.
-*/
-void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
-  global_State *g = G(L);
-  lua_assert((osize == 0) == (block == NULL));
-  block = (*g->frealloc)(g->ud, block, osize, nsize);
-  if (block == NULL && nsize > 0)
-    luaD_throw(L, LUA_ERRMEM);
-  lua_assert((nsize == 0) == (block == NULL));
-  g->totalbytes = (g->totalbytes - osize) + nsize;
-  return block;
-}
-
diff --git a/extern/lua-5.1.5/src/lmem.h b/extern/lua-5.1.5/src/lmem.h
deleted file mode 100644
index 7c2dcb32..00000000
--- a/extern/lua-5.1.5/src/lmem.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-** $Id: lmem.h,v 1.31.1.1 2007/12/27 13:02:25 roberto Exp $
-** Interface to Memory Manager
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lmem_h
-#define lmem_h
-
-
-#include <stddef.h>
-
-#include "llimits.h"
-#include "lua.h"
-
-#define MEMERRMSG	"not enough memory"
-
-
-#define luaM_reallocv(L,b,on,n,e) \
-	((cast(size_t, (n)+1) <= MAX_SIZET/(e)) ?  /* +1 to avoid warnings */ \
-		luaM_realloc_(L, (b), (on)*(e), (n)*(e)) : \
-		luaM_toobig(L))
-
-#define luaM_freemem(L, b, s)	luaM_realloc_(L, (b), (s), 0)
-#define luaM_free(L, b)		luaM_realloc_(L, (b), sizeof(*(b)), 0)
-#define luaM_freearray(L, b, n, t)   luaM_reallocv(L, (b), n, 0, sizeof(t))
-
-#define luaM_malloc(L,t)	luaM_realloc_(L, NULL, 0, (t))
-#define luaM_new(L,t)		cast(t *, luaM_malloc(L, sizeof(t)))
-#define luaM_newvector(L,n,t) \
-		cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))
-
-#define luaM_growvector(L,v,nelems,size,t,limit,e) \
-          if ((nelems)+1 > (size)) \
-            ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
-
-#define luaM_reallocvector(L, v,oldn,n,t) \
-   ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))
-
-
-LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
-                                                          size_t size);
-LUAI_FUNC void *luaM_toobig (lua_State *L);
-LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size,
-                               size_t size_elem, int limit,
-                               const char *errormsg);
-
-#endif
-
diff --git a/extern/lua-5.1.5/src/loadlib.c b/extern/lua-5.1.5/src/loadlib.c
deleted file mode 100644
index 6158c535..00000000
--- a/extern/lua-5.1.5/src/loadlib.c
+++ /dev/null
@@ -1,666 +0,0 @@
-/*
-** $Id: loadlib.c,v 1.52.1.4 2009/09/09 13:17:16 roberto Exp $
-** Dynamic library loader for Lua
-** See Copyright Notice in lua.h
-**
-** This module contains an implementation of loadlib for Unix systems
-** that have dlfcn, an implementation for Darwin (Mac OS X), an
-** implementation for Windows, and a stub for other systems.
-*/
-
-
-#include <stdlib.h>
-#include <string.h>
-
-
-#define loadlib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-/* prefix for open functions in C libraries */
-#define LUA_POF		"luaopen_"
-
-/* separator for open functions in C libraries */
-#define LUA_OFSEP	"_"
-
-
-#define LIBPREFIX	"LOADLIB: "
-
-#define POF		LUA_POF
-#define LIB_FAIL	"open"
-
-
-/* error codes for ll_loadfunc */
-#define ERRLIB		1
-#define ERRFUNC		2
-
-#define setprogdir(L)		((void)0)
-
-
-static void ll_unloadlib (void *lib);
-static void *ll_load (lua_State *L, const char *path);
-static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym);
-
-
-
-#if defined(LUA_DL_DLOPEN)
-/*
-** {========================================================================
-** This is an implementation of loadlib based on the dlfcn interface.
-** The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD,
-** NetBSD, AIX 4.2, HPUX 11, and  probably most other Unix flavors, at least
-** as an emulation layer on top of native functions.
-** =========================================================================
-*/
-
-#include <dlfcn.h>
-
-static void ll_unloadlib (void *lib) {
-  dlclose(lib);
-}
-
-
-static void *ll_load (lua_State *L, const char *path) {
-  void *lib = dlopen(path, RTLD_NOW);
-  if (lib == NULL) lua_pushstring(L, dlerror());
-  return lib;
-}
-
-
-static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
-  lua_CFunction f = (lua_CFunction)dlsym(lib, sym);
-  if (f == NULL) lua_pushstring(L, dlerror());
-  return f;
-}
-
-/* }====================================================== */
-
-
-
-#elif defined(LUA_DL_DLL)
-/*
-** {======================================================================
-** This is an implementation of loadlib for Windows using native functions.
-** =======================================================================
-*/
-
-#include <windows.h>
-
-
-#undef setprogdir
-
-static void setprogdir (lua_State *L) {
-  char buff[MAX_PATH + 1];
-  char *lb;
-  DWORD nsize = sizeof(buff)/sizeof(char);
-  DWORD n = GetModuleFileNameA(NULL, buff, nsize);
-  if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL)
-    luaL_error(L, "unable to get ModuleFileName");
-  else {
-    *lb = '\0';
-    luaL_gsub(L, lua_tostring(L, -1), LUA_EXECDIR, buff);
-    lua_remove(L, -2);  /* remove original string */
-  }
-}
-
-
-static void pusherror (lua_State *L) {
-  int error = GetLastError();
-  char buffer[128];
-  if (FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
-      NULL, error, 0, buffer, sizeof(buffer), NULL))
-    lua_pushstring(L, buffer);
-  else
-    lua_pushfstring(L, "system error %d\n", error);
-}
-
-static void ll_unloadlib (void *lib) {
-  FreeLibrary((HINSTANCE)lib);
-}
-
-
-static void *ll_load (lua_State *L, const char *path) {
-  HINSTANCE lib = LoadLibraryA(path);
-  if (lib == NULL) pusherror(L);
-  return lib;
-}
-
-
-static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
-  lua_CFunction f = (lua_CFunction)GetProcAddress((HINSTANCE)lib, sym);
-  if (f == NULL) pusherror(L);
-  return f;
-}
-
-/* }====================================================== */
-
-
-
-#elif defined(LUA_DL_DYLD)
-/*
-** {======================================================================
-** Native Mac OS X / Darwin Implementation
-** =======================================================================
-*/
-
-#include <mach-o/dyld.h>
-
-
-/* Mac appends a `_' before C function names */
-#undef POF
-#define POF	"_" LUA_POF
-
-
-static void pusherror (lua_State *L) {
-  const char *err_str;
-  const char *err_file;
-  NSLinkEditErrors err;
-  int err_num;
-  NSLinkEditError(&err, &err_num, &err_file, &err_str);
-  lua_pushstring(L, err_str);
-}
-
-
-static const char *errorfromcode (NSObjectFileImageReturnCode ret) {
-  switch (ret) {
-    case NSObjectFileImageInappropriateFile:
-      return "file is not a bundle";
-    case NSObjectFileImageArch:
-      return "library is for wrong CPU type";
-    case NSObjectFileImageFormat:
-      return "bad format";
-    case NSObjectFileImageAccess:
-      return "cannot access file";
-    case NSObjectFileImageFailure:
-    default:
-      return "unable to load library";
-  }
-}
-
-
-static void ll_unloadlib (void *lib) {
-  NSUnLinkModule((NSModule)lib, NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES);
-}
-
-
-static void *ll_load (lua_State *L, const char *path) {
-  NSObjectFileImage img;
-  NSObjectFileImageReturnCode ret;
-  /* this would be a rare case, but prevents crashing if it happens */
-  if(!_dyld_present()) {
-    lua_pushliteral(L, "dyld not present");
-    return NULL;
-  }
-  ret = NSCreateObjectFileImageFromFile(path, &img);
-  if (ret == NSObjectFileImageSuccess) {
-    NSModule mod = NSLinkModule(img, path, NSLINKMODULE_OPTION_PRIVATE |
-                       NSLINKMODULE_OPTION_RETURN_ON_ERROR);
-    NSDestroyObjectFileImage(img);
-    if (mod == NULL) pusherror(L);
-    return mod;
-  }
-  lua_pushstring(L, errorfromcode(ret));
-  return NULL;
-}
-
-
-static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
-  NSSymbol nss = NSLookupSymbolInModule((NSModule)lib, sym);
-  if (nss == NULL) {
-    lua_pushfstring(L, "symbol " LUA_QS " not found", sym);
-    return NULL;
-  }
-  return (lua_CFunction)NSAddressOfSymbol(nss);
-}
-
-/* }====================================================== */
-
-
-
-#else
-/*
-** {======================================================
-** Fallback for other systems
-** =======================================================
-*/
-
-#undef LIB_FAIL
-#define LIB_FAIL	"absent"
-
-
-#define DLMSG	"dynamic libraries not enabled; check your Lua installation"
-
-
-static void ll_unloadlib (void *lib) {
-  (void)lib;  /* to avoid warnings */
-}
-
-
-static void *ll_load (lua_State *L, const char *path) {
-  (void)path;  /* to avoid warnings */
-  lua_pushliteral(L, DLMSG);
-  return NULL;
-}
-
-
-static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
-  (void)lib; (void)sym;  /* to avoid warnings */
-  lua_pushliteral(L, DLMSG);
-  return NULL;
-}
-
-/* }====================================================== */
-#endif
-
-
-
-static void **ll_register (lua_State *L, const char *path) {
-  void **plib;
-  lua_pushfstring(L, "%s%s", LIBPREFIX, path);
-  lua_gettable(L, LUA_REGISTRYINDEX);  /* check library in registry? */
-  if (!lua_isnil(L, -1))  /* is there an entry? */
-    plib = (void **)lua_touserdata(L, -1);
-  else {  /* no entry yet; create one */
-    lua_pop(L, 1);
-    plib = (void **)lua_newuserdata(L, sizeof(const void *));
-    *plib = NULL;
-    luaL_getmetatable(L, "_LOADLIB");
-    lua_setmetatable(L, -2);
-    lua_pushfstring(L, "%s%s", LIBPREFIX, path);
-    lua_pushvalue(L, -2);
-    lua_settable(L, LUA_REGISTRYINDEX);
-  }
-  return plib;
-}
-
-
-/*
-** __gc tag method: calls library's `ll_unloadlib' function with the lib
-** handle
-*/
-static int gctm (lua_State *L) {
-  void **lib = (void **)luaL_checkudata(L, 1, "_LOADLIB");
-  if (*lib) ll_unloadlib(*lib);
-  *lib = NULL;  /* mark library as closed */
-  return 0;
-}
-
-
-static int ll_loadfunc (lua_State *L, const char *path, const char *sym) {
-  void **reg = ll_register(L, path);
-  if (*reg == NULL) *reg = ll_load(L, path);
-  if (*reg == NULL)
-    return ERRLIB;  /* unable to load library */
-  else {
-    lua_CFunction f = ll_sym(L, *reg, sym);
-    if (f == NULL)
-      return ERRFUNC;  /* unable to find function */
-    lua_pushcfunction(L, f);
-    return 0;  /* return function */
-  }
-}
-
-
-static int ll_loadlib (lua_State *L) {
-  const char *path = luaL_checkstring(L, 1);
-  const char *init = luaL_checkstring(L, 2);
-  int stat = ll_loadfunc(L, path, init);
-  if (stat == 0)  /* no errors? */
-    return 1;  /* return the loaded function */
-  else {  /* error; error message is on stack top */
-    lua_pushnil(L);
-    lua_insert(L, -2);
-    lua_pushstring(L, (stat == ERRLIB) ?  LIB_FAIL : "init");
-    return 3;  /* return nil, error message, and where */
-  }
-}
-
-
-
-/*
-** {======================================================
-** 'require' function
-** =======================================================
-*/
-
-
-static int readable (const char *filename) {
-  FILE *f = fopen(filename, "r");  /* try to open file */
-  if (f == NULL) return 0;  /* open failed */
-  fclose(f);
-  return 1;
-}
-
-
-static const char *pushnexttemplate (lua_State *L, const char *path) {
-  const char *l;
-  while (*path == *LUA_PATHSEP) path++;  /* skip separators */
-  if (*path == '\0') return NULL;  /* no more templates */
-  l = strchr(path, *LUA_PATHSEP);  /* find next separator */
-  if (l == NULL) l = path + strlen(path);
-  lua_pushlstring(L, path, l - path);  /* template */
-  return l;
-}
-
-
-static const char *findfile (lua_State *L, const char *name,
-                                           const char *pname) {
-  const char *path;
-  name = luaL_gsub(L, name, ".", LUA_DIRSEP);
-  lua_getfield(L, LUA_ENVIRONINDEX, pname);
-  path = lua_tostring(L, -1);
-  if (path == NULL)
-    luaL_error(L, LUA_QL("package.%s") " must be a string", pname);
-  lua_pushliteral(L, "");  /* error accumulator */
-  while ((path = pushnexttemplate(L, path)) != NULL) {
-    const char *filename;
-    filename = luaL_gsub(L, lua_tostring(L, -1), LUA_PATH_MARK, name);
-    lua_remove(L, -2);  /* remove path template */
-    if (readable(filename))  /* does file exist and is readable? */
-      return filename;  /* return that file name */
-    lua_pushfstring(L, "\n\tno file " LUA_QS, filename);
-    lua_remove(L, -2);  /* remove file name */
-    lua_concat(L, 2);  /* add entry to possible error message */
-  }
-  return NULL;  /* not found */
-}
-
-
-static void loaderror (lua_State *L, const char *filename) {
-  luaL_error(L, "error loading module " LUA_QS " from file " LUA_QS ":\n\t%s",
-                lua_tostring(L, 1), filename, lua_tostring(L, -1));
-}
-
-
-static int loader_Lua (lua_State *L) {
-  const char *filename;
-  const char *name = luaL_checkstring(L, 1);
-  filename = findfile(L, name, "path");
-  if (filename == NULL) return 1;  /* library not found in this path */
-  if (luaL_loadfile(L, filename) != 0)
-    loaderror(L, filename);
-  return 1;  /* library loaded successfully */
-}
-
-
-static const char *mkfuncname (lua_State *L, const char *modname) {
-  const char *funcname;
-  const char *mark = strchr(modname, *LUA_IGMARK);
-  if (mark) modname = mark + 1;
-  funcname = luaL_gsub(L, modname, ".", LUA_OFSEP);
-  funcname = lua_pushfstring(L, POF"%s", funcname);
-  lua_remove(L, -2);  /* remove 'gsub' result */
-  return funcname;
-}
-
-
-static int loader_C (lua_State *L) {
-  const char *funcname;
-  const char *name = luaL_checkstring(L, 1);
-  const char *filename = findfile(L, name, "cpath");
-  if (filename == NULL) return 1;  /* library not found in this path */
-  funcname = mkfuncname(L, name);
-  if (ll_loadfunc(L, filename, funcname) != 0)
-    loaderror(L, filename);
-  return 1;  /* library loaded successfully */
-}
-
-
-static int loader_Croot (lua_State *L) {
-  const char *funcname;
-  const char *filename;
-  const char *name = luaL_checkstring(L, 1);
-  const char *p = strchr(name, '.');
-  int stat;
-  if (p == NULL) return 0;  /* is root */
-  lua_pushlstring(L, name, p - name);
-  filename = findfile(L, lua_tostring(L, -1), "cpath");
-  if (filename == NULL) return 1;  /* root not found */
-  funcname = mkfuncname(L, name);
-  if ((stat = ll_loadfunc(L, filename, funcname)) != 0) {
-    if (stat != ERRFUNC) loaderror(L, filename);  /* real error */
-    lua_pushfstring(L, "\n\tno module " LUA_QS " in file " LUA_QS,
-                       name, filename);
-    return 1;  /* function not found */
-  }
-  return 1;
-}
-
-
-static int loader_preload (lua_State *L) {
-  const char *name = luaL_checkstring(L, 1);
-  lua_getfield(L, LUA_ENVIRONINDEX, "preload");
-  if (!lua_istable(L, -1))
-    luaL_error(L, LUA_QL("package.preload") " must be a table");
-  lua_getfield(L, -1, name);
-  if (lua_isnil(L, -1))  /* not found? */
-    lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
-  return 1;
-}
-
-
-static const int sentinel_ = 0;
-#define sentinel	((void *)&sentinel_)
-
-
-static int ll_require (lua_State *L) {
-  const char *name = luaL_checkstring(L, 1);
-  int i;
-  lua_settop(L, 1);  /* _LOADED table will be at index 2 */
-  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
-  lua_getfield(L, 2, name);
-  if (lua_toboolean(L, -1)) {  /* is it there? */
-    if (lua_touserdata(L, -1) == sentinel)  /* check loops */
-      luaL_error(L, "loop or previous error loading module " LUA_QS, name);
-    return 1;  /* package is already loaded */
-  }
-  /* else must load it; iterate over available loaders */
-  lua_getfield(L, LUA_ENVIRONINDEX, "loaders");
-  if (!lua_istable(L, -1))
-    luaL_error(L, LUA_QL("package.loaders") " must be a table");
-  lua_pushliteral(L, "");  /* error message accumulator */
-  for (i=1; ; i++) {
-    lua_rawgeti(L, -2, i);  /* get a loader */
-    if (lua_isnil(L, -1))
-      luaL_error(L, "module " LUA_QS " not found:%s",
-                    name, lua_tostring(L, -2));
-    lua_pushstring(L, name);
-    lua_call(L, 1, 1);  /* call it */
-    if (lua_isfunction(L, -1))  /* did it find module? */
-      break;  /* module loaded successfully */
-    else if (lua_isstring(L, -1))  /* loader returned error message? */
-      lua_concat(L, 2);  /* accumulate it */
-    else
-      lua_pop(L, 1);
-  }
-  lua_pushlightuserdata(L, sentinel);
-  lua_setfield(L, 2, name);  /* _LOADED[name] = sentinel */
-  lua_pushstring(L, name);  /* pass name as argument to module */
-  lua_call(L, 1, 1);  /* run loaded module */
-  if (!lua_isnil(L, -1))  /* non-nil return? */
-    lua_setfield(L, 2, name);  /* _LOADED[name] = returned value */
-  lua_getfield(L, 2, name);
-  if (lua_touserdata(L, -1) == sentinel) {   /* module did not set a value? */
-    lua_pushboolean(L, 1);  /* use true as result */
-    lua_pushvalue(L, -1);  /* extra copy to be returned */
-    lua_setfield(L, 2, name);  /* _LOADED[name] = true */
-  }
-  return 1;
-}
-
-/* }====================================================== */
-
-
-
-/*
-** {======================================================
-** 'module' function
-** =======================================================
-*/
-  
-
-static void setfenv (lua_State *L) {
-  lua_Debug ar;
-  if (lua_getstack(L, 1, &ar) == 0 ||
-      lua_getinfo(L, "f", &ar) == 0 ||  /* get calling function */
-      lua_iscfunction(L, -1))
-    luaL_error(L, LUA_QL("module") " not called from a Lua function");
-  lua_pushvalue(L, -2);
-  lua_setfenv(L, -2);
-  lua_pop(L, 1);
-}
-
-
-static void dooptions (lua_State *L, int n) {
-  int i;
-  for (i = 2; i <= n; i++) {
-    lua_pushvalue(L, i);  /* get option (a function) */
-    lua_pushvalue(L, -2);  /* module */
-    lua_call(L, 1, 0);
-  }
-}
-
-
-static void modinit (lua_State *L, const char *modname) {
-  const char *dot;
-  lua_pushvalue(L, -1);
-  lua_setfield(L, -2, "_M");  /* module._M = module */
-  lua_pushstring(L, modname);
-  lua_setfield(L, -2, "_NAME");
-  dot = strrchr(modname, '.');  /* look for last dot in module name */
-  if (dot == NULL) dot = modname;
-  else dot++;
-  /* set _PACKAGE as package name (full module name minus last part) */
-  lua_pushlstring(L, modname, dot - modname);
-  lua_setfield(L, -2, "_PACKAGE");
-}
-
-
-static int ll_module (lua_State *L) {
-  const char *modname = luaL_checkstring(L, 1);
-  int loaded = lua_gettop(L) + 1;  /* index of _LOADED table */
-  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
-  lua_getfield(L, loaded, modname);  /* get _LOADED[modname] */
-  if (!lua_istable(L, -1)) {  /* not found? */
-    lua_pop(L, 1);  /* remove previous result */
-    /* try global variable (and create one if it does not exist) */
-    if (luaL_findtable(L, LUA_GLOBALSINDEX, modname, 1) != NULL)
-      return luaL_error(L, "name conflict for module " LUA_QS, modname);
-    lua_pushvalue(L, -1);
-    lua_setfield(L, loaded, modname);  /* _LOADED[modname] = new table */
-  }
-  /* check whether table already has a _NAME field */
-  lua_getfield(L, -1, "_NAME");
-  if (!lua_isnil(L, -1))  /* is table an initialized module? */
-    lua_pop(L, 1);
-  else {  /* no; initialize it */
-    lua_pop(L, 1);
-    modinit(L, modname);
-  }
-  lua_pushvalue(L, -1);
-  setfenv(L);
-  dooptions(L, loaded - 1);
-  return 0;
-}
-
-
-static int ll_seeall (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  if (!lua_getmetatable(L, 1)) {
-    lua_createtable(L, 0, 1); /* create new metatable */
-    lua_pushvalue(L, -1);
-    lua_setmetatable(L, 1);
-  }
-  lua_pushvalue(L, LUA_GLOBALSINDEX);
-  lua_setfield(L, -2, "__index");  /* mt.__index = _G */
-  return 0;
-}
-
-
-/* }====================================================== */
-
-
-
-/* auxiliary mark (for internal use) */
-#define AUXMARK		"\1"
-
-static void setpath (lua_State *L, const char *fieldname, const char *envname,
-                                   const char *def) {
-  const char *path = getenv(envname);
-  if (path == NULL)  /* no environment variable? */
-    lua_pushstring(L, def);  /* use default */
-  else {
-    /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */
-    path = luaL_gsub(L, path, LUA_PATHSEP LUA_PATHSEP,
-                              LUA_PATHSEP AUXMARK LUA_PATHSEP);
-    luaL_gsub(L, path, AUXMARK, def);
-    lua_remove(L, -2);
-  }
-  setprogdir(L);
-  lua_setfield(L, -2, fieldname);
-}
-
-
-static const luaL_Reg pk_funcs[] = {
-  {"loadlib", ll_loadlib},
-  {"seeall", ll_seeall},
-  {NULL, NULL}
-};
-
-
-static const luaL_Reg ll_funcs[] = {
-  {"module", ll_module},
-  {"require", ll_require},
-  {NULL, NULL}
-};
-
-
-static const lua_CFunction loaders[] =
-  {loader_preload, loader_Lua, loader_C, loader_Croot, NULL};
-
-
-LUALIB_API int luaopen_package (lua_State *L) {
-  int i;
-  /* create new type _LOADLIB */
-  luaL_newmetatable(L, "_LOADLIB");
-  lua_pushcfunction(L, gctm);
-  lua_setfield(L, -2, "__gc");
-  /* create `package' table */
-  luaL_register(L, LUA_LOADLIBNAME, pk_funcs);
-#if defined(LUA_COMPAT_LOADLIB) 
-  lua_getfield(L, -1, "loadlib");
-  lua_setfield(L, LUA_GLOBALSINDEX, "loadlib");
-#endif
-  lua_pushvalue(L, -1);
-  lua_replace(L, LUA_ENVIRONINDEX);
-  /* create `loaders' table */
-  lua_createtable(L, sizeof(loaders)/sizeof(loaders[0]) - 1, 0);
-  /* fill it with pre-defined loaders */
-  for (i=0; loaders[i] != NULL; i++) {
-    lua_pushcfunction(L, loaders[i]);
-    lua_rawseti(L, -2, i+1);
-  }
-  lua_setfield(L, -2, "loaders");  /* put it in field `loaders' */
-  setpath(L, "path", LUA_PATH, LUA_PATH_DEFAULT);  /* set field `path' */
-  setpath(L, "cpath", LUA_CPATH, LUA_CPATH_DEFAULT); /* set field `cpath' */
-  /* store config information */
-  lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATHSEP "\n" LUA_PATH_MARK "\n"
-                     LUA_EXECDIR "\n" LUA_IGMARK);
-  lua_setfield(L, -2, "config");
-  /* set field `loaded' */
-  luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 2);
-  lua_setfield(L, -2, "loaded");
-  /* set field `preload' */
-  lua_newtable(L);
-  lua_setfield(L, -2, "preload");
-  lua_pushvalue(L, LUA_GLOBALSINDEX);
-  luaL_register(L, NULL, ll_funcs);  /* open lib into global table */
-  lua_pop(L, 1);
-  return 1;  /* return 'package' table */
-}
-
diff --git a/extern/lua-5.1.5/src/lobject.c b/extern/lua-5.1.5/src/lobject.c
deleted file mode 100644
index 4ff50732..00000000
--- a/extern/lua-5.1.5/src/lobject.c
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
-** $Id: lobject.c,v 2.22.1.1 2007/12/27 13:02:25 roberto Exp $
-** Some generic functions over Lua objects
-** See Copyright Notice in lua.h
-*/
-
-#include <ctype.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define lobject_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldo.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "lvm.h"
-
-
-
-const TValue luaO_nilobject_ = {{NULL}, LUA_TNIL};
-
-
-/*
-** converts an integer to a "floating point byte", represented as
-** (eeeeexxx), where the real value is (1xxx) * 2^(eeeee - 1) if
-** eeeee != 0 and (xxx) otherwise.
-*/
-int luaO_int2fb (unsigned int x) {
-  int e = 0;  /* expoent */
-  while (x >= 16) {
-    x = (x+1) >> 1;
-    e++;
-  }
-  if (x < 8) return x;
-  else return ((e+1) << 3) | (cast_int(x) - 8);
-}
-
-
-/* converts back */
-int luaO_fb2int (int x) {
-  int e = (x >> 3) & 31;
-  if (e == 0) return x;
-  else return ((x & 7)+8) << (e - 1);
-}
-
-
-int luaO_log2 (unsigned int x) {
-  static const lu_byte log_2[256] = {
-    0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-    6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
-  };
-  int l = -1;
-  while (x >= 256) { l += 8; x >>= 8; }
-  return l + log_2[x];
-
-}
-
-
-int luaO_rawequalObj (const TValue *t1, const TValue *t2) {
-  if (ttype(t1) != ttype(t2)) return 0;
-  else switch (ttype(t1)) {
-    case LUA_TNIL:
-      return 1;
-    case LUA_TNUMBER:
-      return luai_numeq(nvalue(t1), nvalue(t2));
-    case LUA_TBOOLEAN:
-      return bvalue(t1) == bvalue(t2);  /* boolean true must be 1 !! */
-    case LUA_TLIGHTUSERDATA:
-      return pvalue(t1) == pvalue(t2);
-    default:
-      lua_assert(iscollectable(t1));
-      return gcvalue(t1) == gcvalue(t2);
-  }
-}
-
-
-int luaO_str2d (const char *s, lua_Number *result) {
-  char *endptr;
-  *result = lua_str2number(s, &endptr);
-  if (endptr == s) return 0;  /* conversion failed */
-  if (*endptr == 'x' || *endptr == 'X')  /* maybe an hexadecimal constant? */
-    *result = cast_num(strtoul(s, &endptr, 16));
-  if (*endptr == '\0') return 1;  /* most common case */
-  while (isspace(cast(unsigned char, *endptr))) endptr++;
-  if (*endptr != '\0') return 0;  /* invalid trailing characters? */
-  return 1;
-}
-
-
-
-static void pushstr (lua_State *L, const char *str) {
-  setsvalue2s(L, L->top, luaS_new(L, str));
-  incr_top(L);
-}
-
-
-/* this function handles only `%d', `%c', %f, %p, and `%s' formats */
-const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
-  int n = 1;
-  pushstr(L, "");
-  for (;;) {
-    const char *e = strchr(fmt, '%');
-    if (e == NULL) break;
-    setsvalue2s(L, L->top, luaS_newlstr(L, fmt, e-fmt));
-    incr_top(L);
-    switch (*(e+1)) {
-      case 's': {
-        const char *s = va_arg(argp, char *);
-        if (s == NULL) s = "(null)";
-        pushstr(L, s);
-        break;
-      }
-      case 'c': {
-        char buff[2];
-        buff[0] = cast(char, va_arg(argp, int));
-        buff[1] = '\0';
-        pushstr(L, buff);
-        break;
-      }
-      case 'd': {
-        setnvalue(L->top, cast_num(va_arg(argp, int)));
-        incr_top(L);
-        break;
-      }
-      case 'f': {
-        setnvalue(L->top, cast_num(va_arg(argp, l_uacNumber)));
-        incr_top(L);
-        break;
-      }
-      case 'p': {
-        char buff[4*sizeof(void *) + 8]; /* should be enough space for a `%p' */
-        sprintf(buff, "%p", va_arg(argp, void *));
-        pushstr(L, buff);
-        break;
-      }
-      case '%': {
-        pushstr(L, "%");
-        break;
-      }
-      default: {
-        char buff[3];
-        buff[0] = '%';
-        buff[1] = *(e+1);
-        buff[2] = '\0';
-        pushstr(L, buff);
-        break;
-      }
-    }
-    n += 2;
-    fmt = e+2;
-  }
-  pushstr(L, fmt);
-  luaV_concat(L, n+1, cast_int(L->top - L->base) - 1);
-  L->top -= n;
-  return svalue(L->top - 1);
-}
-
-
-const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) {
-  const char *msg;
-  va_list argp;
-  va_start(argp, fmt);
-  msg = luaO_pushvfstring(L, fmt, argp);
-  va_end(argp);
-  return msg;
-}
-
-
-void luaO_chunkid (char *out, const char *source, size_t bufflen) {
-  if (*source == '=') {
-    strncpy(out, source+1, bufflen);  /* remove first char */
-    out[bufflen-1] = '\0';  /* ensures null termination */
-  }
-  else {  /* out = "source", or "...source" */
-    if (*source == '@') {
-      size_t l;
-      source++;  /* skip the `@' */
-      bufflen -= sizeof(" '...' ");
-      l = strlen(source);
-      strcpy(out, "");
-      if (l > bufflen) {
-        source += (l-bufflen);  /* get last part of file name */
-        strcat(out, "...");
-      }
-      strcat(out, source);
-    }
-    else {  /* out = [string "string"] */
-      size_t len = strcspn(source, "\n\r");  /* stop at first newline */
-      bufflen -= sizeof(" [string \"...\"] ");
-      if (len > bufflen) len = bufflen;
-      strcpy(out, "[string \"");
-      if (source[len] != '\0') {  /* must truncate? */
-        strncat(out, source, len);
-        strcat(out, "...");
-      }
-      else
-        strcat(out, source);
-      strcat(out, "\"]");
-    }
-  }
-}
diff --git a/extern/lua-5.1.5/src/lobject.h b/extern/lua-5.1.5/src/lobject.h
deleted file mode 100644
index f1e447ef..00000000
--- a/extern/lua-5.1.5/src/lobject.h
+++ /dev/null
@@ -1,381 +0,0 @@
-/*
-** $Id: lobject.h,v 2.20.1.2 2008/08/06 13:29:48 roberto Exp $
-** Type definitions for Lua objects
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef lobject_h
-#define lobject_h
-
-
-#include <stdarg.h>
-
-
-#include "llimits.h"
-#include "lua.h"
-
-
-/* tags for values visible from Lua */
-#define LAST_TAG	LUA_TTHREAD
-
-#define NUM_TAGS	(LAST_TAG+1)
-
-
-/*
-** Extra tags for non-values
-*/
-#define LUA_TPROTO	(LAST_TAG+1)
-#define LUA_TUPVAL	(LAST_TAG+2)
-#define LUA_TDEADKEY	(LAST_TAG+3)
-
-
-/*
-** Union of all collectable objects
-*/
-typedef union GCObject GCObject;
-
-
-/*
-** Common Header for all collectable objects (in macro form, to be
-** included in other objects)
-*/
-#define CommonHeader	GCObject *next; lu_byte tt; lu_byte marked
-
-
-/*
-** Common header in struct form
-*/
-typedef struct GCheader {
-  CommonHeader;
-} GCheader;
-
-
-
-
-/*
-** Union of all Lua values
-*/
-typedef union {
-  GCObject *gc;
-  void *p;
-  lua_Number n;
-  int b;
-} Value;
-
-
-/*
-** Tagged Values
-*/
-
-#define TValuefields	Value value; int tt
-
-typedef struct lua_TValue {
-  TValuefields;
-} TValue;
-
-
-/* Macros to test type */
-#define ttisnil(o)	(ttype(o) == LUA_TNIL)
-#define ttisnumber(o)	(ttype(o) == LUA_TNUMBER)
-#define ttisstring(o)	(ttype(o) == LUA_TSTRING)
-#define ttistable(o)	(ttype(o) == LUA_TTABLE)
-#define ttisfunction(o)	(ttype(o) == LUA_TFUNCTION)
-#define ttisboolean(o)	(ttype(o) == LUA_TBOOLEAN)
-#define ttisuserdata(o)	(ttype(o) == LUA_TUSERDATA)
-#define ttisthread(o)	(ttype(o) == LUA_TTHREAD)
-#define ttislightuserdata(o)	(ttype(o) == LUA_TLIGHTUSERDATA)
-
-/* Macros to access values */
-#define ttype(o)	((o)->tt)
-#define gcvalue(o)	check_exp(iscollectable(o), (o)->value.gc)
-#define pvalue(o)	check_exp(ttislightuserdata(o), (o)->value.p)
-#define nvalue(o)	check_exp(ttisnumber(o), (o)->value.n)
-#define rawtsvalue(o)	check_exp(ttisstring(o), &(o)->value.gc->ts)
-#define tsvalue(o)	(&rawtsvalue(o)->tsv)
-#define rawuvalue(o)	check_exp(ttisuserdata(o), &(o)->value.gc->u)
-#define uvalue(o)	(&rawuvalue(o)->uv)
-#define clvalue(o)	check_exp(ttisfunction(o), &(o)->value.gc->cl)
-#define hvalue(o)	check_exp(ttistable(o), &(o)->value.gc->h)
-#define bvalue(o)	check_exp(ttisboolean(o), (o)->value.b)
-#define thvalue(o)	check_exp(ttisthread(o), &(o)->value.gc->th)
-
-#define l_isfalse(o)	(ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0))
-
-/*
-** for internal debug only
-*/
-#define checkconsistency(obj) \
-  lua_assert(!iscollectable(obj) || (ttype(obj) == (obj)->value.gc->gch.tt))
-
-#define checkliveness(g,obj) \
-  lua_assert(!iscollectable(obj) || \
-  ((ttype(obj) == (obj)->value.gc->gch.tt) && !isdead(g, (obj)->value.gc)))
-
-
-/* Macros to set values */
-#define setnilvalue(obj) ((obj)->tt=LUA_TNIL)
-
-#define setnvalue(obj,x) \
-  { TValue *i_o=(obj); i_o->value.n=(x); i_o->tt=LUA_TNUMBER; }
-
-#define setpvalue(obj,x) \
-  { TValue *i_o=(obj); i_o->value.p=(x); i_o->tt=LUA_TLIGHTUSERDATA; }
-
-#define setbvalue(obj,x) \
-  { TValue *i_o=(obj); i_o->value.b=(x); i_o->tt=LUA_TBOOLEAN; }
-
-#define setsvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TSTRING; \
-    checkliveness(G(L),i_o); }
-
-#define setuvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TUSERDATA; \
-    checkliveness(G(L),i_o); }
-
-#define setthvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTHREAD; \
-    checkliveness(G(L),i_o); }
-
-#define setclvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TFUNCTION; \
-    checkliveness(G(L),i_o); }
-
-#define sethvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTABLE; \
-    checkliveness(G(L),i_o); }
-
-#define setptvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TPROTO; \
-    checkliveness(G(L),i_o); }
-
-
-
-
-#define setobj(L,obj1,obj2) \
-  { const TValue *o2=(obj2); TValue *o1=(obj1); \
-    o1->value = o2->value; o1->tt=o2->tt; \
-    checkliveness(G(L),o1); }
-
-
-/*
-** different types of sets, according to destination
-*/
-
-/* from stack to (same) stack */
-#define setobjs2s	setobj
-/* to stack (not from same stack) */
-#define setobj2s	setobj
-#define setsvalue2s	setsvalue
-#define sethvalue2s	sethvalue
-#define setptvalue2s	setptvalue
-/* from table to same table */
-#define setobjt2t	setobj
-/* to table */
-#define setobj2t	setobj
-/* to new object */
-#define setobj2n	setobj
-#define setsvalue2n	setsvalue
-
-#define setttype(obj, tt) (ttype(obj) = (tt))
-
-
-#define iscollectable(o)	(ttype(o) >= LUA_TSTRING)
-
-
-
-typedef TValue *StkId;  /* index to stack elements */
-
-
-/*
-** String headers for string table
-*/
-typedef union TString {
-  L_Umaxalign dummy;  /* ensures maximum alignment for strings */
-  struct {
-    CommonHeader;
-    lu_byte reserved;
-    unsigned int hash;
-    size_t len;
-  } tsv;
-} TString;
-
-
-#define getstr(ts)	cast(const char *, (ts) + 1)
-#define svalue(o)       getstr(rawtsvalue(o))
-
-
-
-typedef union Udata {
-  L_Umaxalign dummy;  /* ensures maximum alignment for `local' udata */
-  struct {
-    CommonHeader;
-    struct Table *metatable;
-    struct Table *env;
-    size_t len;
-  } uv;
-} Udata;
-
-
-
-
-/*
-** Function Prototypes
-*/
-typedef struct Proto {
-  CommonHeader;
-  TValue *k;  /* constants used by the function */
-  Instruction *code;
-  struct Proto **p;  /* functions defined inside the function */
-  int *lineinfo;  /* map from opcodes to source lines */
-  struct LocVar *locvars;  /* information about local variables */
-  TString **upvalues;  /* upvalue names */
-  TString  *source;
-  int sizeupvalues;
-  int sizek;  /* size of `k' */
-  int sizecode;
-  int sizelineinfo;
-  int sizep;  /* size of `p' */
-  int sizelocvars;
-  int linedefined;
-  int lastlinedefined;
-  GCObject *gclist;
-  lu_byte nups;  /* number of upvalues */
-  lu_byte numparams;
-  lu_byte is_vararg;
-  lu_byte maxstacksize;
-} Proto;
-
-
-/* masks for new-style vararg */
-#define VARARG_HASARG		1
-#define VARARG_ISVARARG		2
-#define VARARG_NEEDSARG		4
-
-
-typedef struct LocVar {
-  TString *varname;
-  int startpc;  /* first point where variable is active */
-  int endpc;    /* first point where variable is dead */
-} LocVar;
-
-
-
-/*
-** Upvalues
-*/
-
-typedef struct UpVal {
-  CommonHeader;
-  TValue *v;  /* points to stack or to its own value */
-  union {
-    TValue value;  /* the value (when closed) */
-    struct {  /* double linked list (when open) */
-      struct UpVal *prev;
-      struct UpVal *next;
-    } l;
-  } u;
-} UpVal;
-
-
-/*
-** Closures
-*/
-
-#define ClosureHeader \
-	CommonHeader; lu_byte isC; lu_byte nupvalues; GCObject *gclist; \
-	struct Table *env
-
-typedef struct CClosure {
-  ClosureHeader;
-  lua_CFunction f;
-  TValue upvalue[1];
-} CClosure;
-
-
-typedef struct LClosure {
-  ClosureHeader;
-  struct Proto *p;
-  UpVal *upvals[1];
-} LClosure;
-
-
-typedef union Closure {
-  CClosure c;
-  LClosure l;
-} Closure;
-
-
-#define iscfunction(o)	(ttype(o) == LUA_TFUNCTION && clvalue(o)->c.isC)
-#define isLfunction(o)	(ttype(o) == LUA_TFUNCTION && !clvalue(o)->c.isC)
-
-
-/*
-** Tables
-*/
-
-typedef union TKey {
-  struct {
-    TValuefields;
-    struct Node *next;  /* for chaining */
-  } nk;
-  TValue tvk;
-} TKey;
-
-
-typedef struct Node {
-  TValue i_val;
-  TKey i_key;
-} Node;
-
-
-typedef struct Table {
-  CommonHeader;
-  lu_byte flags;  /* 1<<p means tagmethod(p) is not present */ 
-  lu_byte lsizenode;  /* log2 of size of `node' array */
-  struct Table *metatable;
-  TValue *array;  /* array part */
-  Node *node;
-  Node *lastfree;  /* any free position is before this position */
-  GCObject *gclist;
-  int sizearray;  /* size of `array' array */
-} Table;
-
-
-
-/*
-** `module' operation for hashing (size is always a power of 2)
-*/
-#define lmod(s,size) \
-	(check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1)))))
-
-
-#define twoto(x)	(1<<(x))
-#define sizenode(t)	(twoto((t)->lsizenode))
-
-
-#define luaO_nilobject		(&luaO_nilobject_)
-
-LUAI_DATA const TValue luaO_nilobject_;
-
-#define ceillog2(x)	(luaO_log2((x)-1) + 1)
-
-LUAI_FUNC int luaO_log2 (unsigned int x);
-LUAI_FUNC int luaO_int2fb (unsigned int x);
-LUAI_FUNC int luaO_fb2int (int x);
-LUAI_FUNC int luaO_rawequalObj (const TValue *t1, const TValue *t2);
-LUAI_FUNC int luaO_str2d (const char *s, lua_Number *result);
-LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
-                                                       va_list argp);
-LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);
-LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len);
-
-
-#endif
-
diff --git a/extern/lua-5.1.5/src/lopcodes.c b/extern/lua-5.1.5/src/lopcodes.c
deleted file mode 100644
index 4cc74523..00000000
--- a/extern/lua-5.1.5/src/lopcodes.c
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
-** $Id: lopcodes.c,v 1.37.1.1 2007/12/27 13:02:25 roberto Exp $
-** See Copyright Notice in lua.h
-*/
-
-
-#define lopcodes_c
-#define LUA_CORE
-
-
-#include "lopcodes.h"
-
-
-/* ORDER OP */
-
-const char *const luaP_opnames[NUM_OPCODES+1] = {
-  "MOVE",
-  "LOADK",
-  "LOADBOOL",
-  "LOADNIL",
-  "GETUPVAL",
-  "GETGLOBAL",
-  "GETTABLE",
-  "SETGLOBAL",
-  "SETUPVAL",
-  "SETTABLE",
-  "NEWTABLE",
-  "SELF",
-  "ADD",
-  "SUB",
-  "MUL",
-  "DIV",
-  "MOD",
-  "POW",
-  "UNM",
-  "NOT",
-  "LEN",
-  "CONCAT",
-  "JMP",
-  "EQ",
-  "LT",
-  "LE",
-  "TEST",
-  "TESTSET",
-  "CALL",
-  "TAILCALL",
-  "RETURN",
-  "FORLOOP",
-  "FORPREP",
-  "TFORLOOP",
-  "SETLIST",
-  "CLOSE",
-  "CLOSURE",
-  "VARARG",
-  NULL
-};
-
-
-#define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))
-
-const lu_byte luaP_opmodes[NUM_OPCODES] = {
-/*       T  A    B       C     mode		   opcode	*/
-  opmode(0, 1, OpArgR, OpArgN, iABC) 		/* OP_MOVE */
- ,opmode(0, 1, OpArgK, OpArgN, iABx)		/* OP_LOADK */
- ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_LOADBOOL */
- ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_LOADNIL */
- ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_GETUPVAL */
- ,opmode(0, 1, OpArgK, OpArgN, iABx)		/* OP_GETGLOBAL */
- ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_GETTABLE */
- ,opmode(0, 0, OpArgK, OpArgN, iABx)		/* OP_SETGLOBAL */
- ,opmode(0, 0, OpArgU, OpArgN, iABC)		/* OP_SETUPVAL */
- ,opmode(0, 0, OpArgK, OpArgK, iABC)		/* OP_SETTABLE */
- ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_NEWTABLE */
- ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_SELF */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_ADD */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SUB */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MUL */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_DIV */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MOD */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_POW */
- ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_UNM */
- ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_NOT */
- ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_LEN */
- ,opmode(0, 1, OpArgR, OpArgR, iABC)		/* OP_CONCAT */
- ,opmode(0, 0, OpArgR, OpArgN, iAsBx)		/* OP_JMP */
- ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_EQ */
- ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LT */
- ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LE */
- ,opmode(1, 1, OpArgR, OpArgU, iABC)		/* OP_TEST */
- ,opmode(1, 1, OpArgR, OpArgU, iABC)		/* OP_TESTSET */
- ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_CALL */
- ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_TAILCALL */
- ,opmode(0, 0, OpArgU, OpArgN, iABC)		/* OP_RETURN */
- ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_FORLOOP */
- ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_FORPREP */
- ,opmode(1, 0, OpArgN, OpArgU, iABC)		/* OP_TFORLOOP */
- ,opmode(0, 0, OpArgU, OpArgU, iABC)		/* OP_SETLIST */
- ,opmode(0, 0, OpArgN, OpArgN, iABC)		/* OP_CLOSE */
- ,opmode(0, 1, OpArgU, OpArgN, iABx)		/* OP_CLOSURE */
- ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_VARARG */
-};
-
diff --git a/extern/lua-5.1.5/src/lopcodes.h b/extern/lua-5.1.5/src/lopcodes.h
deleted file mode 100644
index 41224d6e..00000000
--- a/extern/lua-5.1.5/src/lopcodes.h
+++ /dev/null
@@ -1,268 +0,0 @@
-/*
-** $Id: lopcodes.h,v 1.125.1.1 2007/12/27 13:02:25 roberto Exp $
-** Opcodes for Lua virtual machine
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lopcodes_h
-#define lopcodes_h
-
-#include "llimits.h"
-
-
-/*===========================================================================
-  We assume that instructions are unsigned numbers.
-  All instructions have an opcode in the first 6 bits.
-  Instructions can have the following fields:
-	`A' : 8 bits
-	`B' : 9 bits
-	`C' : 9 bits
-	`Bx' : 18 bits (`B' and `C' together)
-	`sBx' : signed Bx
-
-  A signed argument is represented in excess K; that is, the number
-  value is the unsigned value minus K. K is exactly the maximum value
-  for that argument (so that -max is represented by 0, and +max is
-  represented by 2*max), which is half the maximum for the corresponding
-  unsigned argument.
-===========================================================================*/
-
-
-enum OpMode {iABC, iABx, iAsBx};  /* basic instruction format */
-
-
-/*
-** size and position of opcode arguments.
-*/
-#define SIZE_C		9
-#define SIZE_B		9
-#define SIZE_Bx		(SIZE_C + SIZE_B)
-#define SIZE_A		8
-
-#define SIZE_OP		6
-
-#define POS_OP		0
-#define POS_A		(POS_OP + SIZE_OP)
-#define POS_C		(POS_A + SIZE_A)
-#define POS_B		(POS_C + SIZE_C)
-#define POS_Bx		POS_C
-
-
-/*
-** limits for opcode arguments.
-** we use (signed) int to manipulate most arguments,
-** so they must fit in LUAI_BITSINT-1 bits (-1 for sign)
-*/
-#if SIZE_Bx < LUAI_BITSINT-1
-#define MAXARG_Bx        ((1<<SIZE_Bx)-1)
-#define MAXARG_sBx        (MAXARG_Bx>>1)         /* `sBx' is signed */
-#else
-#define MAXARG_Bx        MAX_INT
-#define MAXARG_sBx        MAX_INT
-#endif
-
-
-#define MAXARG_A        ((1<<SIZE_A)-1)
-#define MAXARG_B        ((1<<SIZE_B)-1)
-#define MAXARG_C        ((1<<SIZE_C)-1)
-
-
-/* creates a mask with `n' 1 bits at position `p' */
-#define MASK1(n,p)	((~((~(Instruction)0)<<n))<<p)
-
-/* creates a mask with `n' 0 bits at position `p' */
-#define MASK0(n,p)	(~MASK1(n,p))
-
-/*
-** the following macros help to manipulate instructions
-*/
-
-#define GET_OPCODE(i)	(cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
-#define SET_OPCODE(i,o)	((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
-		((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))
-
-#define GETARG_A(i)	(cast(int, ((i)>>POS_A) & MASK1(SIZE_A,0)))
-#define SETARG_A(i,u)	((i) = (((i)&MASK0(SIZE_A,POS_A)) | \
-		((cast(Instruction, u)<<POS_A)&MASK1(SIZE_A,POS_A))))
-
-#define GETARG_B(i)	(cast(int, ((i)>>POS_B) & MASK1(SIZE_B,0)))
-#define SETARG_B(i,b)	((i) = (((i)&MASK0(SIZE_B,POS_B)) | \
-		((cast(Instruction, b)<<POS_B)&MASK1(SIZE_B,POS_B))))
-
-#define GETARG_C(i)	(cast(int, ((i)>>POS_C) & MASK1(SIZE_C,0)))
-#define SETARG_C(i,b)	((i) = (((i)&MASK0(SIZE_C,POS_C)) | \
-		((cast(Instruction, b)<<POS_C)&MASK1(SIZE_C,POS_C))))
-
-#define GETARG_Bx(i)	(cast(int, ((i)>>POS_Bx) & MASK1(SIZE_Bx,0)))
-#define SETARG_Bx(i,b)	((i) = (((i)&MASK0(SIZE_Bx,POS_Bx)) | \
-		((cast(Instruction, b)<<POS_Bx)&MASK1(SIZE_Bx,POS_Bx))))
-
-#define GETARG_sBx(i)	(GETARG_Bx(i)-MAXARG_sBx)
-#define SETARG_sBx(i,b)	SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx))
-
-
-#define CREATE_ABC(o,a,b,c)	((cast(Instruction, o)<<POS_OP) \
-			| (cast(Instruction, a)<<POS_A) \
-			| (cast(Instruction, b)<<POS_B) \
-			| (cast(Instruction, c)<<POS_C))
-
-#define CREATE_ABx(o,a,bc)	((cast(Instruction, o)<<POS_OP) \
-			| (cast(Instruction, a)<<POS_A) \
-			| (cast(Instruction, bc)<<POS_Bx))
-
-
-/*
-** Macros to operate RK indices
-*/
-
-/* this bit 1 means constant (0 means register) */
-#define BITRK		(1 << (SIZE_B - 1))
-
-/* test whether value is a constant */
-#define ISK(x)		((x) & BITRK)
-
-/* gets the index of the constant */
-#define INDEXK(r)	((int)(r) & ~BITRK)
-
-#define MAXINDEXRK	(BITRK - 1)
-
-/* code a constant index as a RK value */
-#define RKASK(x)	((x) | BITRK)
-
-
-/*
-** invalid register that fits in 8 bits
-*/
-#define NO_REG		MAXARG_A
-
-
-/*
-** R(x) - register
-** Kst(x) - constant (in constant table)
-** RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)
-*/
-
-
-/*
-** grep "ORDER OP" if you change these enums
-*/
-
-typedef enum {
-/*----------------------------------------------------------------------
-name		args	description
-------------------------------------------------------------------------*/
-OP_MOVE,/*	A B	R(A) := R(B)					*/
-OP_LOADK,/*	A Bx	R(A) := Kst(Bx)					*/
-OP_LOADBOOL,/*	A B C	R(A) := (Bool)B; if (C) pc++			*/
-OP_LOADNIL,/*	A B	R(A) := ... := R(B) := nil			*/
-OP_GETUPVAL,/*	A B	R(A) := UpValue[B]				*/
-
-OP_GETGLOBAL,/*	A Bx	R(A) := Gbl[Kst(Bx)]				*/
-OP_GETTABLE,/*	A B C	R(A) := R(B)[RK(C)]				*/
-
-OP_SETGLOBAL,/*	A Bx	Gbl[Kst(Bx)] := R(A)				*/
-OP_SETUPVAL,/*	A B	UpValue[B] := R(A)				*/
-OP_SETTABLE,/*	A B C	R(A)[RK(B)] := RK(C)				*/
-
-OP_NEWTABLE,/*	A B C	R(A) := {} (size = B,C)				*/
-
-OP_SELF,/*	A B C	R(A+1) := R(B); R(A) := R(B)[RK(C)]		*/
-
-OP_ADD,/*	A B C	R(A) := RK(B) + RK(C)				*/
-OP_SUB,/*	A B C	R(A) := RK(B) - RK(C)				*/
-OP_MUL,/*	A B C	R(A) := RK(B) * RK(C)				*/
-OP_DIV,/*	A B C	R(A) := RK(B) / RK(C)				*/
-OP_MOD,/*	A B C	R(A) := RK(B) % RK(C)				*/
-OP_POW,/*	A B C	R(A) := RK(B) ^ RK(C)				*/
-OP_UNM,/*	A B	R(A) := -R(B)					*/
-OP_NOT,/*	A B	R(A) := not R(B)				*/
-OP_LEN,/*	A B	R(A) := length of R(B)				*/
-
-OP_CONCAT,/*	A B C	R(A) := R(B).. ... ..R(C)			*/
-
-OP_JMP,/*	sBx	pc+=sBx					*/
-
-OP_EQ,/*	A B C	if ((RK(B) == RK(C)) ~= A) then pc++		*/
-OP_LT,/*	A B C	if ((RK(B) <  RK(C)) ~= A) then pc++  		*/
-OP_LE,/*	A B C	if ((RK(B) <= RK(C)) ~= A) then pc++  		*/
-
-OP_TEST,/*	A C	if not (R(A) <=> C) then pc++			*/ 
-OP_TESTSET,/*	A B C	if (R(B) <=> C) then R(A) := R(B) else pc++	*/ 
-
-OP_CALL,/*	A B C	R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
-OP_TAILCALL,/*	A B C	return R(A)(R(A+1), ... ,R(A+B-1))		*/
-OP_RETURN,/*	A B	return R(A), ... ,R(A+B-2)	(see note)	*/
-
-OP_FORLOOP,/*	A sBx	R(A)+=R(A+2);
-			if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
-OP_FORPREP,/*	A sBx	R(A)-=R(A+2); pc+=sBx				*/
-
-OP_TFORLOOP,/*	A C	R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2)); 
-                        if R(A+3) ~= nil then R(A+2)=R(A+3) else pc++	*/ 
-OP_SETLIST,/*	A B C	R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B	*/
-
-OP_CLOSE,/*	A 	close all variables in the stack up to (>=) R(A)*/
-OP_CLOSURE,/*	A Bx	R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n))	*/
-
-OP_VARARG/*	A B	R(A), R(A+1), ..., R(A+B-1) = vararg		*/
-} OpCode;
-
-
-#define NUM_OPCODES	(cast(int, OP_VARARG) + 1)
-
-
-
-/*===========================================================================
-  Notes:
-  (*) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1,
-      and can be 0: OP_CALL then sets `top' to last_result+1, so
-      next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use `top'.
-
-  (*) In OP_VARARG, if (B == 0) then use actual number of varargs and
-      set top (like in OP_CALL with C == 0).
-
-  (*) In OP_RETURN, if (B == 0) then return up to `top'
-
-  (*) In OP_SETLIST, if (B == 0) then B = `top';
-      if (C == 0) then next `instruction' is real C
-
-  (*) For comparisons, A specifies what condition the test should accept
-      (true or false).
-
-  (*) All `skips' (pc++) assume that next instruction is a jump
-===========================================================================*/
-
-
-/*
-** masks for instruction properties. The format is:
-** bits 0-1: op mode
-** bits 2-3: C arg mode
-** bits 4-5: B arg mode
-** bit 6: instruction set register A
-** bit 7: operator is a test
-*/  
-
-enum OpArgMask {
-  OpArgN,  /* argument is not used */
-  OpArgU,  /* argument is used */
-  OpArgR,  /* argument is a register or a jump offset */
-  OpArgK   /* argument is a constant or register/constant */
-};
-
-LUAI_DATA const lu_byte luaP_opmodes[NUM_OPCODES];
-
-#define getOpMode(m)	(cast(enum OpMode, luaP_opmodes[m] & 3))
-#define getBMode(m)	(cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3))
-#define getCMode(m)	(cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3))
-#define testAMode(m)	(luaP_opmodes[m] & (1 << 6))
-#define testTMode(m)	(luaP_opmodes[m] & (1 << 7))
-
-
-LUAI_DATA const char *const luaP_opnames[NUM_OPCODES+1];  /* opcode names */
-
-
-/* number of list items to accumulate before a SETLIST instruction */
-#define LFIELDS_PER_FLUSH	50
-
-
-#endif
diff --git a/extern/lua-5.1.5/src/loslib.c b/extern/lua-5.1.5/src/loslib.c
deleted file mode 100644
index da06a572..00000000
--- a/extern/lua-5.1.5/src/loslib.c
+++ /dev/null
@@ -1,243 +0,0 @@
-/*
-** $Id: loslib.c,v 1.19.1.3 2008/01/18 16:38:18 roberto Exp $
-** Standard Operating System library
-** See Copyright Notice in lua.h
-*/
-
-
-#include <errno.h>
-#include <locale.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#define loslib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-static int os_pushresult (lua_State *L, int i, const char *filename) {
-  int en = errno;  /* calls to Lua API may change this value */
-  if (i) {
-    lua_pushboolean(L, 1);
-    return 1;
-  }
-  else {
-    lua_pushnil(L);
-    lua_pushfstring(L, "%s: %s", filename, strerror(en));
-    lua_pushinteger(L, en);
-    return 3;
-  }
-}
-
-
-static int os_execute (lua_State *L) {
-  lua_pushinteger(L, system(luaL_optstring(L, 1, NULL)));
-  return 1;
-}
-
-
-static int os_remove (lua_State *L) {
-  const char *filename = luaL_checkstring(L, 1);
-  return os_pushresult(L, remove(filename) == 0, filename);
-}
-
-
-static int os_rename (lua_State *L) {
-  const char *fromname = luaL_checkstring(L, 1);
-  const char *toname = luaL_checkstring(L, 2);
-  return os_pushresult(L, rename(fromname, toname) == 0, fromname);
-}
-
-
-static int os_tmpname (lua_State *L) {
-  char buff[LUA_TMPNAMBUFSIZE];
-  int err;
-  lua_tmpnam(buff, err);
-  if (err)
-    return luaL_error(L, "unable to generate a unique filename");
-  lua_pushstring(L, buff);
-  return 1;
-}
-
-
-static int os_getenv (lua_State *L) {
-  lua_pushstring(L, getenv(luaL_checkstring(L, 1)));  /* if NULL push nil */
-  return 1;
-}
-
-
-static int os_clock (lua_State *L) {
-  lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC);
-  return 1;
-}
-
-
-/*
-** {======================================================
-** Time/Date operations
-** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S,
-**   wday=%w+1, yday=%j, isdst=? }
-** =======================================================
-*/
-
-static void setfield (lua_State *L, const char *key, int value) {
-  lua_pushinteger(L, value);
-  lua_setfield(L, -2, key);
-}
-
-static void setboolfield (lua_State *L, const char *key, int value) {
-  if (value < 0)  /* undefined? */
-    return;  /* does not set field */
-  lua_pushboolean(L, value);
-  lua_setfield(L, -2, key);
-}
-
-static int getboolfield (lua_State *L, const char *key) {
-  int res;
-  lua_getfield(L, -1, key);
-  res = lua_isnil(L, -1) ? -1 : lua_toboolean(L, -1);
-  lua_pop(L, 1);
-  return res;
-}
-
-
-static int getfield (lua_State *L, const char *key, int d) {
-  int res;
-  lua_getfield(L, -1, key);
-  if (lua_isnumber(L, -1))
-    res = (int)lua_tointeger(L, -1);
-  else {
-    if (d < 0)
-      return luaL_error(L, "field " LUA_QS " missing in date table", key);
-    res = d;
-  }
-  lua_pop(L, 1);
-  return res;
-}
-
-
-static int os_date (lua_State *L) {
-  const char *s = luaL_optstring(L, 1, "%c");
-  time_t t = luaL_opt(L, (time_t)luaL_checknumber, 2, time(NULL));
-  struct tm *stm;
-  if (*s == '!') {  /* UTC? */
-    stm = gmtime(&t);
-    s++;  /* skip `!' */
-  }
-  else
-    stm = localtime(&t);
-  if (stm == NULL)  /* invalid date? */
-    lua_pushnil(L);
-  else if (strcmp(s, "*t") == 0) {
-    lua_createtable(L, 0, 9);  /* 9 = number of fields */
-    setfield(L, "sec", stm->tm_sec);
-    setfield(L, "min", stm->tm_min);
-    setfield(L, "hour", stm->tm_hour);
-    setfield(L, "day", stm->tm_mday);
-    setfield(L, "month", stm->tm_mon+1);
-    setfield(L, "year", stm->tm_year+1900);
-    setfield(L, "wday", stm->tm_wday+1);
-    setfield(L, "yday", stm->tm_yday+1);
-    setboolfield(L, "isdst", stm->tm_isdst);
-  }
-  else {
-    char cc[3];
-    luaL_Buffer b;
-    cc[0] = '%'; cc[2] = '\0';
-    luaL_buffinit(L, &b);
-    for (; *s; s++) {
-      if (*s != '%' || *(s + 1) == '\0')  /* no conversion specifier? */
-        luaL_addchar(&b, *s);
-      else {
-        size_t reslen;
-        char buff[200];  /* should be big enough for any conversion result */
-        cc[1] = *(++s);
-        reslen = strftime(buff, sizeof(buff), cc, stm);
-        luaL_addlstring(&b, buff, reslen);
-      }
-    }
-    luaL_pushresult(&b);
-  }
-  return 1;
-}
-
-
-static int os_time (lua_State *L) {
-  time_t t;
-  if (lua_isnoneornil(L, 1))  /* called without args? */
-    t = time(NULL);  /* get current time */
-  else {
-    struct tm ts;
-    luaL_checktype(L, 1, LUA_TTABLE);
-    lua_settop(L, 1);  /* make sure table is at the top */
-    ts.tm_sec = getfield(L, "sec", 0);
-    ts.tm_min = getfield(L, "min", 0);
-    ts.tm_hour = getfield(L, "hour", 12);
-    ts.tm_mday = getfield(L, "day", -1);
-    ts.tm_mon = getfield(L, "month", -1) - 1;
-    ts.tm_year = getfield(L, "year", -1) - 1900;
-    ts.tm_isdst = getboolfield(L, "isdst");
-    t = mktime(&ts);
-  }
-  if (t == (time_t)(-1))
-    lua_pushnil(L);
-  else
-    lua_pushnumber(L, (lua_Number)t);
-  return 1;
-}
-
-
-static int os_difftime (lua_State *L) {
-  lua_pushnumber(L, difftime((time_t)(luaL_checknumber(L, 1)),
-                             (time_t)(luaL_optnumber(L, 2, 0))));
-  return 1;
-}
-
-/* }====================================================== */
-
-
-static int os_setlocale (lua_State *L) {
-  static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
-                      LC_NUMERIC, LC_TIME};
-  static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
-     "numeric", "time", NULL};
-  const char *l = luaL_optstring(L, 1, NULL);
-  int op = luaL_checkoption(L, 2, "all", catnames);
-  lua_pushstring(L, setlocale(cat[op], l));
-  return 1;
-}
-
-
-static int os_exit (lua_State *L) {
-  exit(luaL_optint(L, 1, EXIT_SUCCESS));
-}
-
-static const luaL_Reg syslib[] = {
-  {"clock",     os_clock},
-  {"date",      os_date},
-  {"difftime",  os_difftime},
-  {"execute",   os_execute},
-  {"exit",      os_exit},
-  {"getenv",    os_getenv},
-  {"remove",    os_remove},
-  {"rename",    os_rename},
-  {"setlocale", os_setlocale},
-  {"time",      os_time},
-  {"tmpname",   os_tmpname},
-  {NULL, NULL}
-};
-
-/* }====================================================== */
-
-
-
-LUALIB_API int luaopen_os (lua_State *L) {
-  luaL_register(L, LUA_OSLIBNAME, syslib);
-  return 1;
-}
-
diff --git a/extern/lua-5.1.5/src/lparser.c b/extern/lua-5.1.5/src/lparser.c
deleted file mode 100644
index dda7488d..00000000
--- a/extern/lua-5.1.5/src/lparser.c
+++ /dev/null
@@ -1,1339 +0,0 @@
-/*
-** $Id: lparser.c,v 2.42.1.4 2011/10/21 19:31:42 roberto Exp $
-** Lua Parser
-** See Copyright Notice in lua.h
-*/
-
-
-#include <string.h>
-
-#define lparser_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lcode.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "llex.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lparser.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-
-
-
-#define hasmultret(k)		((k) == VCALL || (k) == VVARARG)
-
-#define getlocvar(fs, i)	((fs)->f->locvars[(fs)->actvar[i]])
-
-#define luaY_checklimit(fs,v,l,m)	if ((v)>(l)) errorlimit(fs,l,m)
-
-
-/*
-** nodes for block list (list of active blocks)
-*/
-typedef struct BlockCnt {
-  struct BlockCnt *previous;  /* chain */
-  int breaklist;  /* list of jumps out of this loop */
-  lu_byte nactvar;  /* # active locals outside the breakable structure */
-  lu_byte upval;  /* true if some variable in the block is an upvalue */
-  lu_byte isbreakable;  /* true if `block' is a loop */
-} BlockCnt;
-
-
-
-/*
-** prototypes for recursive non-terminal functions
-*/
-static void chunk (LexState *ls);
-static void expr (LexState *ls, expdesc *v);
-
-
-static void anchor_token (LexState *ls) {
-  if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) {
-    TString *ts = ls->t.seminfo.ts;
-    luaX_newstring(ls, getstr(ts), ts->tsv.len);
-  }
-}
-
-
-static void error_expected (LexState *ls, int token) {
-  luaX_syntaxerror(ls,
-      luaO_pushfstring(ls->L, LUA_QS " expected", luaX_token2str(ls, token)));
-}
-
-
-static void errorlimit (FuncState *fs, int limit, const char *what) {
-  const char *msg = (fs->f->linedefined == 0) ?
-    luaO_pushfstring(fs->L, "main function has more than %d %s", limit, what) :
-    luaO_pushfstring(fs->L, "function at line %d has more than %d %s",
-                            fs->f->linedefined, limit, what);
-  luaX_lexerror(fs->ls, msg, 0);
-}
-
-
-static int testnext (LexState *ls, int c) {
-  if (ls->t.token == c) {
-    luaX_next(ls);
-    return 1;
-  }
-  else return 0;
-}
-
-
-static void check (LexState *ls, int c) {
-  if (ls->t.token != c)
-    error_expected(ls, c);
-}
-
-static void checknext (LexState *ls, int c) {
-  check(ls, c);
-  luaX_next(ls);
-}
-
-
-#define check_condition(ls,c,msg)	{ if (!(c)) luaX_syntaxerror(ls, msg); }
-
-
-
-static void check_match (LexState *ls, int what, int who, int where) {
-  if (!testnext(ls, what)) {
-    if (where == ls->linenumber)
-      error_expected(ls, what);
-    else {
-      luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
-             LUA_QS " expected (to close " LUA_QS " at line %d)",
-              luaX_token2str(ls, what), luaX_token2str(ls, who), where));
-    }
-  }
-}
-
-
-static TString *str_checkname (LexState *ls) {
-  TString *ts;
-  check(ls, TK_NAME);
-  ts = ls->t.seminfo.ts;
-  luaX_next(ls);
-  return ts;
-}
-
-
-static void init_exp (expdesc *e, expkind k, int i) {
-  e->f = e->t = NO_JUMP;
-  e->k = k;
-  e->u.s.info = i;
-}
-
-
-static void codestring (LexState *ls, expdesc *e, TString *s) {
-  init_exp(e, VK, luaK_stringK(ls->fs, s));
-}
-
-
-static void checkname(LexState *ls, expdesc *e) {
-  codestring(ls, e, str_checkname(ls));
-}
-
-
-static int registerlocalvar (LexState *ls, TString *varname) {
-  FuncState *fs = ls->fs;
-  Proto *f = fs->f;
-  int oldsize = f->sizelocvars;
-  luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars,
-                  LocVar, SHRT_MAX, "too many local variables");
-  while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL;
-  f->locvars[fs->nlocvars].varname = varname;
-  luaC_objbarrier(ls->L, f, varname);
-  return fs->nlocvars++;
-}
-
-
-#define new_localvarliteral(ls,v,n) \
-  new_localvar(ls, luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char))-1), n)
-
-
-static void new_localvar (LexState *ls, TString *name, int n) {
-  FuncState *fs = ls->fs;
-  luaY_checklimit(fs, fs->nactvar+n+1, LUAI_MAXVARS, "local variables");
-  fs->actvar[fs->nactvar+n] = cast(unsigned short, registerlocalvar(ls, name));
-}
-
-
-static void adjustlocalvars (LexState *ls, int nvars) {
-  FuncState *fs = ls->fs;
-  fs->nactvar = cast_byte(fs->nactvar + nvars);
-  for (; nvars; nvars--) {
-    getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc;
-  }
-}
-
-
-static void removevars (LexState *ls, int tolevel) {
-  FuncState *fs = ls->fs;
-  while (fs->nactvar > tolevel)
-    getlocvar(fs, --fs->nactvar).endpc = fs->pc;
-}
-
-
-static int indexupvalue (FuncState *fs, TString *name, expdesc *v) {
-  int i;
-  Proto *f = fs->f;
-  int oldsize = f->sizeupvalues;
-  for (i=0; i<f->nups; i++) {
-    if (fs->upvalues[i].k == v->k && fs->upvalues[i].info == v->u.s.info) {
-      lua_assert(f->upvalues[i] == name);
-      return i;
-    }
-  }
-  /* new one */
-  luaY_checklimit(fs, f->nups + 1, LUAI_MAXUPVALUES, "upvalues");
-  luaM_growvector(fs->L, f->upvalues, f->nups, f->sizeupvalues,
-                  TString *, MAX_INT, "");
-  while (oldsize < f->sizeupvalues) f->upvalues[oldsize++] = NULL;
-  f->upvalues[f->nups] = name;
-  luaC_objbarrier(fs->L, f, name);
-  lua_assert(v->k == VLOCAL || v->k == VUPVAL);
-  fs->upvalues[f->nups].k = cast_byte(v->k);
-  fs->upvalues[f->nups].info = cast_byte(v->u.s.info);
-  return f->nups++;
-}
-
-
-static int searchvar (FuncState *fs, TString *n) {
-  int i;
-  for (i=fs->nactvar-1; i >= 0; i--) {
-    if (n == getlocvar(fs, i).varname)
-      return i;
-  }
-  return -1;  /* not found */
-}
-
-
-static void markupval (FuncState *fs, int level) {
-  BlockCnt *bl = fs->bl;
-  while (bl && bl->nactvar > level) bl = bl->previous;
-  if (bl) bl->upval = 1;
-}
-
-
-static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
-  if (fs == NULL) {  /* no more levels? */
-    init_exp(var, VGLOBAL, NO_REG);  /* default is global variable */
-    return VGLOBAL;
-  }
-  else {
-    int v = searchvar(fs, n);  /* look up at current level */
-    if (v >= 0) {
-      init_exp(var, VLOCAL, v);
-      if (!base)
-        markupval(fs, v);  /* local will be used as an upval */
-      return VLOCAL;
-    }
-    else {  /* not found at current level; try upper one */
-      if (singlevaraux(fs->prev, n, var, 0) == VGLOBAL)
-        return VGLOBAL;
-      var->u.s.info = indexupvalue(fs, n, var);  /* else was LOCAL or UPVAL */
-      var->k = VUPVAL;  /* upvalue in this level */
-      return VUPVAL;
-    }
-  }
-}
-
-
-static void singlevar (LexState *ls, expdesc *var) {
-  TString *varname = str_checkname(ls);
-  FuncState *fs = ls->fs;
-  if (singlevaraux(fs, varname, var, 1) == VGLOBAL)
-    var->u.s.info = luaK_stringK(fs, varname);  /* info points to global name */
-}
-
-
-static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
-  FuncState *fs = ls->fs;
-  int extra = nvars - nexps;
-  if (hasmultret(e->k)) {
-    extra++;  /* includes call itself */
-    if (extra < 0) extra = 0;
-    luaK_setreturns(fs, e, extra);  /* last exp. provides the difference */
-    if (extra > 1) luaK_reserveregs(fs, extra-1);
-  }
-  else {
-    if (e->k != VVOID) luaK_exp2nextreg(fs, e);  /* close last expression */
-    if (extra > 0) {
-      int reg = fs->freereg;
-      luaK_reserveregs(fs, extra);
-      luaK_nil(fs, reg, extra);
-    }
-  }
-}
-
-
-static void enterlevel (LexState *ls) {
-  if (++ls->L->nCcalls > LUAI_MAXCCALLS)
-	luaX_lexerror(ls, "chunk has too many syntax levels", 0);
-}
-
-
-#define leavelevel(ls)	((ls)->L->nCcalls--)
-
-
-static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isbreakable) {
-  bl->breaklist = NO_JUMP;
-  bl->isbreakable = isbreakable;
-  bl->nactvar = fs->nactvar;
-  bl->upval = 0;
-  bl->previous = fs->bl;
-  fs->bl = bl;
-  lua_assert(fs->freereg == fs->nactvar);
-}
-
-
-static void leaveblock (FuncState *fs) {
-  BlockCnt *bl = fs->bl;
-  fs->bl = bl->previous;
-  removevars(fs->ls, bl->nactvar);
-  if (bl->upval)
-    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
-  /* a block either controls scope or breaks (never both) */
-  lua_assert(!bl->isbreakable || !bl->upval);
-  lua_assert(bl->nactvar == fs->nactvar);
-  fs->freereg = fs->nactvar;  /* free registers */
-  luaK_patchtohere(fs, bl->breaklist);
-}
-
-
-static void pushclosure (LexState *ls, FuncState *func, expdesc *v) {
-  FuncState *fs = ls->fs;
-  Proto *f = fs->f;
-  int oldsize = f->sizep;
-  int i;
-  luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *,
-                  MAXARG_Bx, "constant table overflow");
-  while (oldsize < f->sizep) f->p[oldsize++] = NULL;
-  f->p[fs->np++] = func->f;
-  luaC_objbarrier(ls->L, f, func->f);
-  init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1));
-  for (i=0; i<func->f->nups; i++) {
-    OpCode o = (func->upvalues[i].k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;
-    luaK_codeABC(fs, o, 0, func->upvalues[i].info, 0);
-  }
-}
-
-
-static void open_func (LexState *ls, FuncState *fs) {
-  lua_State *L = ls->L;
-  Proto *f = luaF_newproto(L);
-  fs->f = f;
-  fs->prev = ls->fs;  /* linked list of funcstates */
-  fs->ls = ls;
-  fs->L = L;
-  ls->fs = fs;
-  fs->pc = 0;
-  fs->lasttarget = -1;
-  fs->jpc = NO_JUMP;
-  fs->freereg = 0;
-  fs->nk = 0;
-  fs->np = 0;
-  fs->nlocvars = 0;
-  fs->nactvar = 0;
-  fs->bl = NULL;
-  f->source = ls->source;
-  f->maxstacksize = 2;  /* registers 0/1 are always valid */
-  fs->h = luaH_new(L, 0, 0);
-  /* anchor table of constants and prototype (to avoid being collected) */
-  sethvalue2s(L, L->top, fs->h);
-  incr_top(L);
-  setptvalue2s(L, L->top, f);
-  incr_top(L);
-}
-
-
-static void close_func (LexState *ls) {
-  lua_State *L = ls->L;
-  FuncState *fs = ls->fs;
-  Proto *f = fs->f;
-  removevars(ls, 0);
-  luaK_ret(fs, 0, 0);  /* final return */
-  luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
-  f->sizecode = fs->pc;
-  luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
-  f->sizelineinfo = fs->pc;
-  luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);
-  f->sizek = fs->nk;
-  luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);
-  f->sizep = fs->np;
-  luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
-  f->sizelocvars = fs->nlocvars;
-  luaM_reallocvector(L, f->upvalues, f->sizeupvalues, f->nups, TString *);
-  f->sizeupvalues = f->nups;
-  lua_assert(luaG_checkcode(f));
-  lua_assert(fs->bl == NULL);
-  ls->fs = fs->prev;
-  /* last token read was anchored in defunct function; must reanchor it */
-  if (fs) anchor_token(ls);
-  L->top -= 2;  /* remove table and prototype from the stack */
-}
-
-
-Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
-  struct LexState lexstate;
-  struct FuncState funcstate;
-  lexstate.buff = buff;
-  luaX_setinput(L, &lexstate, z, luaS_new(L, name));
-  open_func(&lexstate, &funcstate);
-  funcstate.f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */
-  luaX_next(&lexstate);  /* read first token */
-  chunk(&lexstate);
-  check(&lexstate, TK_EOS);
-  close_func(&lexstate);
-  lua_assert(funcstate.prev == NULL);
-  lua_assert(funcstate.f->nups == 0);
-  lua_assert(lexstate.fs == NULL);
-  return funcstate.f;
-}
-
-
-
-/*============================================================*/
-/* GRAMMAR RULES */
-/*============================================================*/
-
-
-static void field (LexState *ls, expdesc *v) {
-  /* field -> ['.' | ':'] NAME */
-  FuncState *fs = ls->fs;
-  expdesc key;
-  luaK_exp2anyreg(fs, v);
-  luaX_next(ls);  /* skip the dot or colon */
-  checkname(ls, &key);
-  luaK_indexed(fs, v, &key);
-}
-
-
-static void yindex (LexState *ls, expdesc *v) {
-  /* index -> '[' expr ']' */
-  luaX_next(ls);  /* skip the '[' */
-  expr(ls, v);
-  luaK_exp2val(ls->fs, v);
-  checknext(ls, ']');
-}
-
-
-/*
-** {======================================================================
-** Rules for Constructors
-** =======================================================================
-*/
-
-
-struct ConsControl {
-  expdesc v;  /* last list item read */
-  expdesc *t;  /* table descriptor */
-  int nh;  /* total number of `record' elements */
-  int na;  /* total number of array elements */
-  int tostore;  /* number of array elements pending to be stored */
-};
-
-
-static void recfield (LexState *ls, struct ConsControl *cc) {
-  /* recfield -> (NAME | `['exp1`]') = exp1 */
-  FuncState *fs = ls->fs;
-  int reg = ls->fs->freereg;
-  expdesc key, val;
-  int rkkey;
-  if (ls->t.token == TK_NAME) {
-    luaY_checklimit(fs, cc->nh, MAX_INT, "items in a constructor");
-    checkname(ls, &key);
-  }
-  else  /* ls->t.token == '[' */
-    yindex(ls, &key);
-  cc->nh++;
-  checknext(ls, '=');
-  rkkey = luaK_exp2RK(fs, &key);
-  expr(ls, &val);
-  luaK_codeABC(fs, OP_SETTABLE, cc->t->u.s.info, rkkey, luaK_exp2RK(fs, &val));
-  fs->freereg = reg;  /* free registers */
-}
-
-
-static void closelistfield (FuncState *fs, struct ConsControl *cc) {
-  if (cc->v.k == VVOID) return;  /* there is no list item */
-  luaK_exp2nextreg(fs, &cc->v);
-  cc->v.k = VVOID;
-  if (cc->tostore == LFIELDS_PER_FLUSH) {
-    luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);  /* flush */
-    cc->tostore = 0;  /* no more items pending */
-  }
-}
-
-
-static void lastlistfield (FuncState *fs, struct ConsControl *cc) {
-  if (cc->tostore == 0) return;
-  if (hasmultret(cc->v.k)) {
-    luaK_setmultret(fs, &cc->v);
-    luaK_setlist(fs, cc->t->u.s.info, cc->na, LUA_MULTRET);
-    cc->na--;  /* do not count last expression (unknown number of elements) */
-  }
-  else {
-    if (cc->v.k != VVOID)
-      luaK_exp2nextreg(fs, &cc->v);
-    luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);
-  }
-}
-
-
-static void listfield (LexState *ls, struct ConsControl *cc) {
-  expr(ls, &cc->v);
-  luaY_checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");
-  cc->na++;
-  cc->tostore++;
-}
-
-
-static void constructor (LexState *ls, expdesc *t) {
-  /* constructor -> ?? */
-  FuncState *fs = ls->fs;
-  int line = ls->linenumber;
-  int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);
-  struct ConsControl cc;
-  cc.na = cc.nh = cc.tostore = 0;
-  cc.t = t;
-  init_exp(t, VRELOCABLE, pc);
-  init_exp(&cc.v, VVOID, 0);  /* no value (yet) */
-  luaK_exp2nextreg(ls->fs, t);  /* fix it at stack top (for gc) */
-  checknext(ls, '{');
-  do {
-    lua_assert(cc.v.k == VVOID || cc.tostore > 0);
-    if (ls->t.token == '}') break;
-    closelistfield(fs, &cc);
-    switch(ls->t.token) {
-      case TK_NAME: {  /* may be listfields or recfields */
-        luaX_lookahead(ls);
-        if (ls->lookahead.token != '=')  /* expression? */
-          listfield(ls, &cc);
-        else
-          recfield(ls, &cc);
-        break;
-      }
-      case '[': {  /* constructor_item -> recfield */
-        recfield(ls, &cc);
-        break;
-      }
-      default: {  /* constructor_part -> listfield */
-        listfield(ls, &cc);
-        break;
-      }
-    }
-  } while (testnext(ls, ',') || testnext(ls, ';'));
-  check_match(ls, '}', '{', line);
-  lastlistfield(fs, &cc);
-  SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */
-  SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh));  /* set initial table size */
-}
-
-/* }====================================================================== */
-
-
-
-static void parlist (LexState *ls) {
-  /* parlist -> [ param { `,' param } ] */
-  FuncState *fs = ls->fs;
-  Proto *f = fs->f;
-  int nparams = 0;
-  f->is_vararg = 0;
-  if (ls->t.token != ')') {  /* is `parlist' not empty? */
-    do {
-      switch (ls->t.token) {
-        case TK_NAME: {  /* param -> NAME */
-          new_localvar(ls, str_checkname(ls), nparams++);
-          break;
-        }
-        case TK_DOTS: {  /* param -> `...' */
-          luaX_next(ls);
-#if defined(LUA_COMPAT_VARARG)
-          /* use `arg' as default name */
-          new_localvarliteral(ls, "arg", nparams++);
-          f->is_vararg = VARARG_HASARG | VARARG_NEEDSARG;
-#endif
-          f->is_vararg |= VARARG_ISVARARG;
-          break;
-        }
-        default: luaX_syntaxerror(ls, "<name> or " LUA_QL("...") " expected");
-      }
-    } while (!f->is_vararg && testnext(ls, ','));
-  }
-  adjustlocalvars(ls, nparams);
-  f->numparams = cast_byte(fs->nactvar - (f->is_vararg & VARARG_HASARG));
-  luaK_reserveregs(fs, fs->nactvar);  /* reserve register for parameters */
-}
-
-
-static void body (LexState *ls, expdesc *e, int needself, int line) {
-  /* body ->  `(' parlist `)' chunk END */
-  FuncState new_fs;
-  open_func(ls, &new_fs);
-  new_fs.f->linedefined = line;
-  checknext(ls, '(');
-  if (needself) {
-    new_localvarliteral(ls, "self", 0);
-    adjustlocalvars(ls, 1);
-  }
-  parlist(ls);
-  checknext(ls, ')');
-  chunk(ls);
-  new_fs.f->lastlinedefined = ls->linenumber;
-  check_match(ls, TK_END, TK_FUNCTION, line);
-  close_func(ls);
-  pushclosure(ls, &new_fs, e);
-}
-
-
-static int explist1 (LexState *ls, expdesc *v) {
-  /* explist1 -> expr { `,' expr } */
-  int n = 1;  /* at least one expression */
-  expr(ls, v);
-  while (testnext(ls, ',')) {
-    luaK_exp2nextreg(ls->fs, v);
-    expr(ls, v);
-    n++;
-  }
-  return n;
-}
-
-
-static void funcargs (LexState *ls, expdesc *f) {
-  FuncState *fs = ls->fs;
-  expdesc args;
-  int base, nparams;
-  int line = ls->linenumber;
-  switch (ls->t.token) {
-    case '(': {  /* funcargs -> `(' [ explist1 ] `)' */
-      if (line != ls->lastline)
-        luaX_syntaxerror(ls,"ambiguous syntax (function call x new statement)");
-      luaX_next(ls);
-      if (ls->t.token == ')')  /* arg list is empty? */
-        args.k = VVOID;
-      else {
-        explist1(ls, &args);
-        luaK_setmultret(fs, &args);
-      }
-      check_match(ls, ')', '(', line);
-      break;
-    }
-    case '{': {  /* funcargs -> constructor */
-      constructor(ls, &args);
-      break;
-    }
-    case TK_STRING: {  /* funcargs -> STRING */
-      codestring(ls, &args, ls->t.seminfo.ts);
-      luaX_next(ls);  /* must use `seminfo' before `next' */
-      break;
-    }
-    default: {
-      luaX_syntaxerror(ls, "function arguments expected");
-      return;
-    }
-  }
-  lua_assert(f->k == VNONRELOC);
-  base = f->u.s.info;  /* base register for call */
-  if (hasmultret(args.k))
-    nparams = LUA_MULTRET;  /* open call */
-  else {
-    if (args.k != VVOID)
-      luaK_exp2nextreg(fs, &args);  /* close last argument */
-    nparams = fs->freereg - (base+1);
-  }
-  init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));
-  luaK_fixline(fs, line);
-  fs->freereg = base+1;  /* call remove function and arguments and leaves
-                            (unless changed) one result */
-}
-
-
-
-
-/*
-** {======================================================================
-** Expression parsing
-** =======================================================================
-*/
-
-
-static void prefixexp (LexState *ls, expdesc *v) {
-  /* prefixexp -> NAME | '(' expr ')' */
-  switch (ls->t.token) {
-    case '(': {
-      int line = ls->linenumber;
-      luaX_next(ls);
-      expr(ls, v);
-      check_match(ls, ')', '(', line);
-      luaK_dischargevars(ls->fs, v);
-      return;
-    }
-    case TK_NAME: {
-      singlevar(ls, v);
-      return;
-    }
-    default: {
-      luaX_syntaxerror(ls, "unexpected symbol");
-      return;
-    }
-  }
-}
-
-
-static void primaryexp (LexState *ls, expdesc *v) {
-  /* primaryexp ->
-        prefixexp { `.' NAME | `[' exp `]' | `:' NAME funcargs | funcargs } */
-  FuncState *fs = ls->fs;
-  prefixexp(ls, v);
-  for (;;) {
-    switch (ls->t.token) {
-      case '.': {  /* field */
-        field(ls, v);
-        break;
-      }
-      case '[': {  /* `[' exp1 `]' */
-        expdesc key;
-        luaK_exp2anyreg(fs, v);
-        yindex(ls, &key);
-        luaK_indexed(fs, v, &key);
-        break;
-      }
-      case ':': {  /* `:' NAME funcargs */
-        expdesc key;
-        luaX_next(ls);
-        checkname(ls, &key);
-        luaK_self(fs, v, &key);
-        funcargs(ls, v);
-        break;
-      }
-      case '(': case TK_STRING: case '{': {  /* funcargs */
-        luaK_exp2nextreg(fs, v);
-        funcargs(ls, v);
-        break;
-      }
-      default: return;
-    }
-  }
-}
-
-
-static void simpleexp (LexState *ls, expdesc *v) {
-  /* simpleexp -> NUMBER | STRING | NIL | true | false | ... |
-                  constructor | FUNCTION body | primaryexp */
-  switch (ls->t.token) {
-    case TK_NUMBER: {
-      init_exp(v, VKNUM, 0);
-      v->u.nval = ls->t.seminfo.r;
-      break;
-    }
-    case TK_STRING: {
-      codestring(ls, v, ls->t.seminfo.ts);
-      break;
-    }
-    case TK_NIL: {
-      init_exp(v, VNIL, 0);
-      break;
-    }
-    case TK_TRUE: {
-      init_exp(v, VTRUE, 0);
-      break;
-    }
-    case TK_FALSE: {
-      init_exp(v, VFALSE, 0);
-      break;
-    }
-    case TK_DOTS: {  /* vararg */
-      FuncState *fs = ls->fs;
-      check_condition(ls, fs->f->is_vararg,
-                      "cannot use " LUA_QL("...") " outside a vararg function");
-      fs->f->is_vararg &= ~VARARG_NEEDSARG;  /* don't need 'arg' */
-      init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));
-      break;
-    }
-    case '{': {  /* constructor */
-      constructor(ls, v);
-      return;
-    }
-    case TK_FUNCTION: {
-      luaX_next(ls);
-      body(ls, v, 0, ls->linenumber);
-      return;
-    }
-    default: {
-      primaryexp(ls, v);
-      return;
-    }
-  }
-  luaX_next(ls);
-}
-
-
-static UnOpr getunopr (int op) {
-  switch (op) {
-    case TK_NOT: return OPR_NOT;
-    case '-': return OPR_MINUS;
-    case '#': return OPR_LEN;
-    default: return OPR_NOUNOPR;
-  }
-}
-
-
-static BinOpr getbinopr (int op) {
-  switch (op) {
-    case '+': return OPR_ADD;
-    case '-': return OPR_SUB;
-    case '*': return OPR_MUL;
-    case '/': return OPR_DIV;
-    case '%': return OPR_MOD;
-    case '^': return OPR_POW;
-    case TK_CONCAT: return OPR_CONCAT;
-    case TK_NE: return OPR_NE;
-    case TK_EQ: return OPR_EQ;
-    case '<': return OPR_LT;
-    case TK_LE: return OPR_LE;
-    case '>': return OPR_GT;
-    case TK_GE: return OPR_GE;
-    case TK_AND: return OPR_AND;
-    case TK_OR: return OPR_OR;
-    default: return OPR_NOBINOPR;
-  }
-}
-
-
-static const struct {
-  lu_byte left;  /* left priority for each binary operator */
-  lu_byte right; /* right priority */
-} priority[] = {  /* ORDER OPR */
-   {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7},  /* `+' `-' `/' `%' */
-   {10, 9}, {5, 4},                 /* power and concat (right associative) */
-   {3, 3}, {3, 3},                  /* equality and inequality */
-   {3, 3}, {3, 3}, {3, 3}, {3, 3},  /* order */
-   {2, 2}, {1, 1}                   /* logical (and/or) */
-};
-
-#define UNARY_PRIORITY	8  /* priority for unary operators */
-
-
-/*
-** subexpr -> (simpleexp | unop subexpr) { binop subexpr }
-** where `binop' is any binary operator with a priority higher than `limit'
-*/
-static BinOpr subexpr (LexState *ls, expdesc *v, unsigned int limit) {
-  BinOpr op;
-  UnOpr uop;
-  enterlevel(ls);
-  uop = getunopr(ls->t.token);
-  if (uop != OPR_NOUNOPR) {
-    luaX_next(ls);
-    subexpr(ls, v, UNARY_PRIORITY);
-    luaK_prefix(ls->fs, uop, v);
-  }
-  else simpleexp(ls, v);
-  /* expand while operators have priorities higher than `limit' */
-  op = getbinopr(ls->t.token);
-  while (op != OPR_NOBINOPR && priority[op].left > limit) {
-    expdesc v2;
-    BinOpr nextop;
-    luaX_next(ls);
-    luaK_infix(ls->fs, op, v);
-    /* read sub-expression with higher priority */
-    nextop = subexpr(ls, &v2, priority[op].right);
-    luaK_posfix(ls->fs, op, v, &v2);
-    op = nextop;
-  }
-  leavelevel(ls);
-  return op;  /* return first untreated operator */
-}
-
-
-static void expr (LexState *ls, expdesc *v) {
-  subexpr(ls, v, 0);
-}
-
-/* }==================================================================== */
-
-
-
-/*
-** {======================================================================
-** Rules for Statements
-** =======================================================================
-*/
-
-
-static int block_follow (int token) {
-  switch (token) {
-    case TK_ELSE: case TK_ELSEIF: case TK_END:
-    case TK_UNTIL: case TK_EOS:
-      return 1;
-    default: return 0;
-  }
-}
-
-
-static void block (LexState *ls) {
-  /* block -> chunk */
-  FuncState *fs = ls->fs;
-  BlockCnt bl;
-  enterblock(fs, &bl, 0);
-  chunk(ls);
-  lua_assert(bl.breaklist == NO_JUMP);
-  leaveblock(fs);
-}
-
-
-/*
-** structure to chain all variables in the left-hand side of an
-** assignment
-*/
-struct LHS_assign {
-  struct LHS_assign *prev;
-  expdesc v;  /* variable (global, local, upvalue, or indexed) */
-};
-
-
-/*
-** check whether, in an assignment to a local variable, the local variable
-** is needed in a previous assignment (to a table). If so, save original
-** local value in a safe place and use this safe copy in the previous
-** assignment.
-*/
-static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
-  FuncState *fs = ls->fs;
-  int extra = fs->freereg;  /* eventual position to save local variable */
-  int conflict = 0;
-  for (; lh; lh = lh->prev) {
-    if (lh->v.k == VINDEXED) {
-      if (lh->v.u.s.info == v->u.s.info) {  /* conflict? */
-        conflict = 1;
-        lh->v.u.s.info = extra;  /* previous assignment will use safe copy */
-      }
-      if (lh->v.u.s.aux == v->u.s.info) {  /* conflict? */
-        conflict = 1;
-        lh->v.u.s.aux = extra;  /* previous assignment will use safe copy */
-      }
-    }
-  }
-  if (conflict) {
-    luaK_codeABC(fs, OP_MOVE, fs->freereg, v->u.s.info, 0);  /* make copy */
-    luaK_reserveregs(fs, 1);
-  }
-}
-
-
-static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
-  expdesc e;
-  check_condition(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED,
-                      "syntax error");
-  if (testnext(ls, ',')) {  /* assignment -> `,' primaryexp assignment */
-    struct LHS_assign nv;
-    nv.prev = lh;
-    primaryexp(ls, &nv.v);
-    if (nv.v.k == VLOCAL)
-      check_conflict(ls, lh, &nv.v);
-    luaY_checklimit(ls->fs, nvars, LUAI_MAXCCALLS - ls->L->nCcalls,
-                    "variables in assignment");
-    assignment(ls, &nv, nvars+1);
-  }
-  else {  /* assignment -> `=' explist1 */
-    int nexps;
-    checknext(ls, '=');
-    nexps = explist1(ls, &e);
-    if (nexps != nvars) {
-      adjust_assign(ls, nvars, nexps, &e);
-      if (nexps > nvars)
-        ls->fs->freereg -= nexps - nvars;  /* remove extra values */
-    }
-    else {
-      luaK_setoneret(ls->fs, &e);  /* close last expression */
-      luaK_storevar(ls->fs, &lh->v, &e);
-      return;  /* avoid default */
-    }
-  }
-  init_exp(&e, VNONRELOC, ls->fs->freereg-1);  /* default assignment */
-  luaK_storevar(ls->fs, &lh->v, &e);
-}
-
-
-static int cond (LexState *ls) {
-  /* cond -> exp */
-  expdesc v;
-  expr(ls, &v);  /* read condition */
-  if (v.k == VNIL) v.k = VFALSE;  /* `falses' are all equal here */
-  luaK_goiftrue(ls->fs, &v);
-  return v.f;
-}
-
-
-static void breakstat (LexState *ls) {
-  FuncState *fs = ls->fs;
-  BlockCnt *bl = fs->bl;
-  int upval = 0;
-  while (bl && !bl->isbreakable) {
-    upval |= bl->upval;
-    bl = bl->previous;
-  }
-  if (!bl)
-    luaX_syntaxerror(ls, "no loop to break");
-  if (upval)
-    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
-  luaK_concat(fs, &bl->breaklist, luaK_jump(fs));
-}
-
-
-static void whilestat (LexState *ls, int line) {
-  /* whilestat -> WHILE cond DO block END */
-  FuncState *fs = ls->fs;
-  int whileinit;
-  int condexit;
-  BlockCnt bl;
-  luaX_next(ls);  /* skip WHILE */
-  whileinit = luaK_getlabel(fs);
-  condexit = cond(ls);
-  enterblock(fs, &bl, 1);
-  checknext(ls, TK_DO);
-  block(ls);
-  luaK_patchlist(fs, luaK_jump(fs), whileinit);
-  check_match(ls, TK_END, TK_WHILE, line);
-  leaveblock(fs);
-  luaK_patchtohere(fs, condexit);  /* false conditions finish the loop */
-}
-
-
-static void repeatstat (LexState *ls, int line) {
-  /* repeatstat -> REPEAT block UNTIL cond */
-  int condexit;
-  FuncState *fs = ls->fs;
-  int repeat_init = luaK_getlabel(fs);
-  BlockCnt bl1, bl2;
-  enterblock(fs, &bl1, 1);  /* loop block */
-  enterblock(fs, &bl2, 0);  /* scope block */
-  luaX_next(ls);  /* skip REPEAT */
-  chunk(ls);
-  check_match(ls, TK_UNTIL, TK_REPEAT, line);
-  condexit = cond(ls);  /* read condition (inside scope block) */
-  if (!bl2.upval) {  /* no upvalues? */
-    leaveblock(fs);  /* finish scope */
-    luaK_patchlist(ls->fs, condexit, repeat_init);  /* close the loop */
-  }
-  else {  /* complete semantics when there are upvalues */
-    breakstat(ls);  /* if condition then break */
-    luaK_patchtohere(ls->fs, condexit);  /* else... */
-    leaveblock(fs);  /* finish scope... */
-    luaK_patchlist(ls->fs, luaK_jump(fs), repeat_init);  /* and repeat */
-  }
-  leaveblock(fs);  /* finish loop */
-}
-
-
-static int exp1 (LexState *ls) {
-  expdesc e;
-  int k;
-  expr(ls, &e);
-  k = e.k;
-  luaK_exp2nextreg(ls->fs, &e);
-  return k;
-}
-
-
-static void forbody (LexState *ls, int base, int line, int nvars, int isnum) {
-  /* forbody -> DO block */
-  BlockCnt bl;
-  FuncState *fs = ls->fs;
-  int prep, endfor;
-  adjustlocalvars(ls, 3);  /* control variables */
-  checknext(ls, TK_DO);
-  prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);
-  enterblock(fs, &bl, 0);  /* scope for declared variables */
-  adjustlocalvars(ls, nvars);
-  luaK_reserveregs(fs, nvars);
-  block(ls);
-  leaveblock(fs);  /* end of scope for declared variables */
-  luaK_patchtohere(fs, prep);
-  endfor = (isnum) ? luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP) :
-                     luaK_codeABC(fs, OP_TFORLOOP, base, 0, nvars);
-  luaK_fixline(fs, line);  /* pretend that `OP_FOR' starts the loop */
-  luaK_patchlist(fs, (isnum ? endfor : luaK_jump(fs)), prep + 1);
-}
-
-
-static void fornum (LexState *ls, TString *varname, int line) {
-  /* fornum -> NAME = exp1,exp1[,exp1] forbody */
-  FuncState *fs = ls->fs;
-  int base = fs->freereg;
-  new_localvarliteral(ls, "(for index)", 0);
-  new_localvarliteral(ls, "(for limit)", 1);
-  new_localvarliteral(ls, "(for step)", 2);
-  new_localvar(ls, varname, 3);
-  checknext(ls, '=');
-  exp1(ls);  /* initial value */
-  checknext(ls, ',');
-  exp1(ls);  /* limit */
-  if (testnext(ls, ','))
-    exp1(ls);  /* optional step */
-  else {  /* default step = 1 */
-    luaK_codeABx(fs, OP_LOADK, fs->freereg, luaK_numberK(fs, 1));
-    luaK_reserveregs(fs, 1);
-  }
-  forbody(ls, base, line, 1, 1);
-}
-
-
-static void forlist (LexState *ls, TString *indexname) {
-  /* forlist -> NAME {,NAME} IN explist1 forbody */
-  FuncState *fs = ls->fs;
-  expdesc e;
-  int nvars = 0;
-  int line;
-  int base = fs->freereg;
-  /* create control variables */
-  new_localvarliteral(ls, "(for generator)", nvars++);
-  new_localvarliteral(ls, "(for state)", nvars++);
-  new_localvarliteral(ls, "(for control)", nvars++);
-  /* create declared variables */
-  new_localvar(ls, indexname, nvars++);
-  while (testnext(ls, ','))
-    new_localvar(ls, str_checkname(ls), nvars++);
-  checknext(ls, TK_IN);
-  line = ls->linenumber;
-  adjust_assign(ls, 3, explist1(ls, &e), &e);
-  luaK_checkstack(fs, 3);  /* extra space to call generator */
-  forbody(ls, base, line, nvars - 3, 0);
-}
-
-
-static void forstat (LexState *ls, int line) {
-  /* forstat -> FOR (fornum | forlist) END */
-  FuncState *fs = ls->fs;
-  TString *varname;
-  BlockCnt bl;
-  enterblock(fs, &bl, 1);  /* scope for loop and control variables */
-  luaX_next(ls);  /* skip `for' */
-  varname = str_checkname(ls);  /* first variable name */
-  switch (ls->t.token) {
-    case '=': fornum(ls, varname, line); break;
-    case ',': case TK_IN: forlist(ls, varname); break;
-    default: luaX_syntaxerror(ls, LUA_QL("=") " or " LUA_QL("in") " expected");
-  }
-  check_match(ls, TK_END, TK_FOR, line);
-  leaveblock(fs);  /* loop scope (`break' jumps to this point) */
-}
-
-
-static int test_then_block (LexState *ls) {
-  /* test_then_block -> [IF | ELSEIF] cond THEN block */
-  int condexit;
-  luaX_next(ls);  /* skip IF or ELSEIF */
-  condexit = cond(ls);
-  checknext(ls, TK_THEN);
-  block(ls);  /* `then' part */
-  return condexit;
-}
-
-
-static void ifstat (LexState *ls, int line) {
-  /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */
-  FuncState *fs = ls->fs;
-  int flist;
-  int escapelist = NO_JUMP;
-  flist = test_then_block(ls);  /* IF cond THEN block */
-  while (ls->t.token == TK_ELSEIF) {
-    luaK_concat(fs, &escapelist, luaK_jump(fs));
-    luaK_patchtohere(fs, flist);
-    flist = test_then_block(ls);  /* ELSEIF cond THEN block */
-  }
-  if (ls->t.token == TK_ELSE) {
-    luaK_concat(fs, &escapelist, luaK_jump(fs));
-    luaK_patchtohere(fs, flist);
-    luaX_next(ls);  /* skip ELSE (after patch, for correct line info) */
-    block(ls);  /* `else' part */
-  }
-  else
-    luaK_concat(fs, &escapelist, flist);
-  luaK_patchtohere(fs, escapelist);
-  check_match(ls, TK_END, TK_IF, line);
-}
-
-
-static void localfunc (LexState *ls) {
-  expdesc v, b;
-  FuncState *fs = ls->fs;
-  new_localvar(ls, str_checkname(ls), 0);
-  init_exp(&v, VLOCAL, fs->freereg);
-  luaK_reserveregs(fs, 1);
-  adjustlocalvars(ls, 1);
-  body(ls, &b, 0, ls->linenumber);
-  luaK_storevar(fs, &v, &b);
-  /* debug information will only see the variable after this point! */
-  getlocvar(fs, fs->nactvar - 1).startpc = fs->pc;
-}
-
-
-static void localstat (LexState *ls) {
-  /* stat -> LOCAL NAME {`,' NAME} [`=' explist1] */
-  int nvars = 0;
-  int nexps;
-  expdesc e;
-  do {
-    new_localvar(ls, str_checkname(ls), nvars++);
-  } while (testnext(ls, ','));
-  if (testnext(ls, '='))
-    nexps = explist1(ls, &e);
-  else {
-    e.k = VVOID;
-    nexps = 0;
-  }
-  adjust_assign(ls, nvars, nexps, &e);
-  adjustlocalvars(ls, nvars);
-}
-
-
-static int funcname (LexState *ls, expdesc *v) {
-  /* funcname -> NAME {field} [`:' NAME] */
-  int needself = 0;
-  singlevar(ls, v);
-  while (ls->t.token == '.')
-    field(ls, v);
-  if (ls->t.token == ':') {
-    needself = 1;
-    field(ls, v);
-  }
-  return needself;
-}
-
-
-static void funcstat (LexState *ls, int line) {
-  /* funcstat -> FUNCTION funcname body */
-  int needself;
-  expdesc v, b;
-  luaX_next(ls);  /* skip FUNCTION */
-  needself = funcname(ls, &v);
-  body(ls, &b, needself, line);
-  luaK_storevar(ls->fs, &v, &b);
-  luaK_fixline(ls->fs, line);  /* definition `happens' in the first line */
-}
-
-
-static void exprstat (LexState *ls) {
-  /* stat -> func | assignment */
-  FuncState *fs = ls->fs;
-  struct LHS_assign v;
-  primaryexp(ls, &v.v);
-  if (v.v.k == VCALL)  /* stat -> func */
-    SETARG_C(getcode(fs, &v.v), 1);  /* call statement uses no results */
-  else {  /* stat -> assignment */
-    v.prev = NULL;
-    assignment(ls, &v, 1);
-  }
-}
-
-
-static void retstat (LexState *ls) {
-  /* stat -> RETURN explist */
-  FuncState *fs = ls->fs;
-  expdesc e;
-  int first, nret;  /* registers with returned values */
-  luaX_next(ls);  /* skip RETURN */
-  if (block_follow(ls->t.token) || ls->t.token == ';')
-    first = nret = 0;  /* return no values */
-  else {
-    nret = explist1(ls, &e);  /* optional return values */
-    if (hasmultret(e.k)) {
-      luaK_setmultret(fs, &e);
-      if (e.k == VCALL && nret == 1) {  /* tail call? */
-        SET_OPCODE(getcode(fs,&e), OP_TAILCALL);
-        lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar);
-      }
-      first = fs->nactvar;
-      nret = LUA_MULTRET;  /* return all values */
-    }
-    else {
-      if (nret == 1)  /* only one single value? */
-        first = luaK_exp2anyreg(fs, &e);
-      else {
-        luaK_exp2nextreg(fs, &e);  /* values must go to the `stack' */
-        first = fs->nactvar;  /* return all `active' values */
-        lua_assert(nret == fs->freereg - first);
-      }
-    }
-  }
-  luaK_ret(fs, first, nret);
-}
-
-
-static int statement (LexState *ls) {
-  int line = ls->linenumber;  /* may be needed for error messages */
-  switch (ls->t.token) {
-    case TK_IF: {  /* stat -> ifstat */
-      ifstat(ls, line);
-      return 0;
-    }
-    case TK_WHILE: {  /* stat -> whilestat */
-      whilestat(ls, line);
-      return 0;
-    }
-    case TK_DO: {  /* stat -> DO block END */
-      luaX_next(ls);  /* skip DO */
-      block(ls);
-      check_match(ls, TK_END, TK_DO, line);
-      return 0;
-    }
-    case TK_FOR: {  /* stat -> forstat */
-      forstat(ls, line);
-      return 0;
-    }
-    case TK_REPEAT: {  /* stat -> repeatstat */
-      repeatstat(ls, line);
-      return 0;
-    }
-    case TK_FUNCTION: {
-      funcstat(ls, line);  /* stat -> funcstat */
-      return 0;
-    }
-    case TK_LOCAL: {  /* stat -> localstat */
-      luaX_next(ls);  /* skip LOCAL */
-      if (testnext(ls, TK_FUNCTION))  /* local function? */
-        localfunc(ls);
-      else
-        localstat(ls);
-      return 0;
-    }
-    case TK_RETURN: {  /* stat -> retstat */
-      retstat(ls);
-      return 1;  /* must be last statement */
-    }
-    case TK_BREAK: {  /* stat -> breakstat */
-      luaX_next(ls);  /* skip BREAK */
-      breakstat(ls);
-      return 1;  /* must be last statement */
-    }
-    default: {
-      exprstat(ls);
-      return 0;  /* to avoid warnings */
-    }
-  }
-}
-
-
-static void chunk (LexState *ls) {
-  /* chunk -> { stat [`;'] } */
-  int islast = 0;
-  enterlevel(ls);
-  while (!islast && !block_follow(ls->t.token)) {
-    islast = statement(ls);
-    testnext(ls, ';');
-    lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&
-               ls->fs->freereg >= ls->fs->nactvar);
-    ls->fs->freereg = ls->fs->nactvar;  /* free registers */
-  }
-  leavelevel(ls);
-}
-
-/* }====================================================================== */
diff --git a/extern/lua-5.1.5/src/lparser.h b/extern/lua-5.1.5/src/lparser.h
deleted file mode 100644
index 18836afd..00000000
--- a/extern/lua-5.1.5/src/lparser.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
-** $Id: lparser.h,v 1.57.1.1 2007/12/27 13:02:25 roberto Exp $
-** Lua Parser
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lparser_h
-#define lparser_h
-
-#include "llimits.h"
-#include "lobject.h"
-#include "lzio.h"
-
-
-/*
-** Expression descriptor
-*/
-
-typedef enum {
-  VVOID,	/* no value */
-  VNIL,
-  VTRUE,
-  VFALSE,
-  VK,		/* info = index of constant in `k' */
-  VKNUM,	/* nval = numerical value */
-  VLOCAL,	/* info = local register */
-  VUPVAL,       /* info = index of upvalue in `upvalues' */
-  VGLOBAL,	/* info = index of table; aux = index of global name in `k' */
-  VINDEXED,	/* info = table register; aux = index register (or `k') */
-  VJMP,		/* info = instruction pc */
-  VRELOCABLE,	/* info = instruction pc */
-  VNONRELOC,	/* info = result register */
-  VCALL,	/* info = instruction pc */
-  VVARARG	/* info = instruction pc */
-} expkind;
-
-typedef struct expdesc {
-  expkind k;
-  union {
-    struct { int info, aux; } s;
-    lua_Number nval;
-  } u;
-  int t;  /* patch list of `exit when true' */
-  int f;  /* patch list of `exit when false' */
-} expdesc;
-
-
-typedef struct upvaldesc {
-  lu_byte k;
-  lu_byte info;
-} upvaldesc;
-
-
-struct BlockCnt;  /* defined in lparser.c */
-
-
-/* state needed to generate code for a given function */
-typedef struct FuncState {
-  Proto *f;  /* current function header */
-  Table *h;  /* table to find (and reuse) elements in `k' */
-  struct FuncState *prev;  /* enclosing function */
-  struct LexState *ls;  /* lexical state */
-  struct lua_State *L;  /* copy of the Lua state */
-  struct BlockCnt *bl;  /* chain of current blocks */
-  int pc;  /* next position to code (equivalent to `ncode') */
-  int lasttarget;   /* `pc' of last `jump target' */
-  int jpc;  /* list of pending jumps to `pc' */
-  int freereg;  /* first free register */
-  int nk;  /* number of elements in `k' */
-  int np;  /* number of elements in `p' */
-  short nlocvars;  /* number of elements in `locvars' */
-  lu_byte nactvar;  /* number of active local variables */
-  upvaldesc upvalues[LUAI_MAXUPVALUES];  /* upvalues */
-  unsigned short actvar[LUAI_MAXVARS];  /* declared-variable stack */
-} FuncState;
-
-
-LUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
-                                            const char *name);
-
-
-#endif
diff --git a/extern/lua-5.1.5/src/lstate.c b/extern/lua-5.1.5/src/lstate.c
deleted file mode 100644
index 4313b83a..00000000
--- a/extern/lua-5.1.5/src/lstate.c
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
-** $Id: lstate.c,v 2.36.1.2 2008/01/03 15:20:39 roberto Exp $
-** Global State
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stddef.h>
-
-#define lstate_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "llex.h"
-#include "lmem.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-
-
-#define state_size(x)	(sizeof(x) + LUAI_EXTRASPACE)
-#define fromstate(l)	(cast(lu_byte *, (l)) - LUAI_EXTRASPACE)
-#define tostate(l)   (cast(lua_State *, cast(lu_byte *, l) + LUAI_EXTRASPACE))
-
-
-/*
-** Main thread combines a thread state and the global state
-*/
-typedef struct LG {
-  lua_State l;
-  global_State g;
-} LG;
-  
-
-
-static void stack_init (lua_State *L1, lua_State *L) {
-  /* initialize CallInfo array */
-  L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo);
-  L1->ci = L1->base_ci;
-  L1->size_ci = BASIC_CI_SIZE;
-  L1->end_ci = L1->base_ci + L1->size_ci - 1;
-  /* initialize stack array */
-  L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TValue);
-  L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK;
-  L1->top = L1->stack;
-  L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1;
-  /* initialize first ci */
-  L1->ci->func = L1->top;
-  setnilvalue(L1->top++);  /* `function' entry for this `ci' */
-  L1->base = L1->ci->base = L1->top;
-  L1->ci->top = L1->top + LUA_MINSTACK;
-}
-
-
-static void freestack (lua_State *L, lua_State *L1) {
-  luaM_freearray(L, L1->base_ci, L1->size_ci, CallInfo);
-  luaM_freearray(L, L1->stack, L1->stacksize, TValue);
-}
-
-
-/*
-** open parts that may cause memory-allocation errors
-*/
-static void f_luaopen (lua_State *L, void *ud) {
-  global_State *g = G(L);
-  UNUSED(ud);
-  stack_init(L, L);  /* init stack */
-  sethvalue(L, gt(L), luaH_new(L, 0, 2));  /* table of globals */
-  sethvalue(L, registry(L), luaH_new(L, 0, 2));  /* registry */
-  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
-  luaT_init(L);
-  luaX_init(L);
-  luaS_fix(luaS_newliteral(L, MEMERRMSG));
-  g->GCthreshold = 4*g->totalbytes;
-}
-
-
-static void preinit_state (lua_State *L, global_State *g) {
-  G(L) = g;
-  L->stack = NULL;
-  L->stacksize = 0;
-  L->errorJmp = NULL;
-  L->hook = NULL;
-  L->hookmask = 0;
-  L->basehookcount = 0;
-  L->allowhook = 1;
-  resethookcount(L);
-  L->openupval = NULL;
-  L->size_ci = 0;
-  L->nCcalls = L->baseCcalls = 0;
-  L->status = 0;
-  L->base_ci = L->ci = NULL;
-  L->savedpc = NULL;
-  L->errfunc = 0;
-  setnilvalue(gt(L));
-}
-
-
-static void close_state (lua_State *L) {
-  global_State *g = G(L);
-  luaF_close(L, L->stack);  /* close all upvalues for this thread */
-  luaC_freeall(L);  /* collect all objects */
-  lua_assert(g->rootgc == obj2gco(L));
-  lua_assert(g->strt.nuse == 0);
-  luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *);
-  luaZ_freebuffer(L, &g->buff);
-  freestack(L, L);
-  lua_assert(g->totalbytes == sizeof(LG));
-  (*g->frealloc)(g->ud, fromstate(L), state_size(LG), 0);
-}
-
-
-lua_State *luaE_newthread (lua_State *L) {
-  lua_State *L1 = tostate(luaM_malloc(L, state_size(lua_State)));
-  luaC_link(L, obj2gco(L1), LUA_TTHREAD);
-  preinit_state(L1, G(L));
-  stack_init(L1, L);  /* init stack */
-  setobj2n(L, gt(L1), gt(L));  /* share table of globals */
-  L1->hookmask = L->hookmask;
-  L1->basehookcount = L->basehookcount;
-  L1->hook = L->hook;
-  resethookcount(L1);
-  lua_assert(iswhite(obj2gco(L1)));
-  return L1;
-}
-
-
-void luaE_freethread (lua_State *L, lua_State *L1) {
-  luaF_close(L1, L1->stack);  /* close all upvalues for this thread */
-  lua_assert(L1->openupval == NULL);
-  luai_userstatefree(L1);
-  freestack(L, L1);
-  luaM_freemem(L, fromstate(L1), state_size(lua_State));
-}
-
-
-LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
-  int i;
-  lua_State *L;
-  global_State *g;
-  void *l = (*f)(ud, NULL, 0, state_size(LG));
-  if (l == NULL) return NULL;
-  L = tostate(l);
-  g = &((LG *)L)->g;
-  L->next = NULL;
-  L->tt = LUA_TTHREAD;
-  g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
-  L->marked = luaC_white(g);
-  set2bits(L->marked, FIXEDBIT, SFIXEDBIT);
-  preinit_state(L, g);
-  g->frealloc = f;
-  g->ud = ud;
-  g->mainthread = L;
-  g->uvhead.u.l.prev = &g->uvhead;
-  g->uvhead.u.l.next = &g->uvhead;
-  g->GCthreshold = 0;  /* mark it as unfinished state */
-  g->strt.size = 0;
-  g->strt.nuse = 0;
-  g->strt.hash = NULL;
-  setnilvalue(registry(L));
-  luaZ_initbuffer(L, &g->buff);
-  g->panic = NULL;
-  g->gcstate = GCSpause;
-  g->rootgc = obj2gco(L);
-  g->sweepstrgc = 0;
-  g->sweepgc = &g->rootgc;
-  g->gray = NULL;
-  g->grayagain = NULL;
-  g->weak = NULL;
-  g->tmudata = NULL;
-  g->totalbytes = sizeof(LG);
-  g->gcpause = LUAI_GCPAUSE;
-  g->gcstepmul = LUAI_GCMUL;
-  g->gcdept = 0;
-  for (i=0; i<NUM_TAGS; i++) g->mt[i] = NULL;
-  if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) {
-    /* memory allocation error: free partial state */
-    close_state(L);
-    L = NULL;
-  }
-  else
-    luai_userstateopen(L);
-  return L;
-}
-
-
-static void callallgcTM (lua_State *L, void *ud) {
-  UNUSED(ud);
-  luaC_callGCTM(L);  /* call GC metamethods for all udata */
-}
-
-
-LUA_API void lua_close (lua_State *L) {
-  L = G(L)->mainthread;  /* only the main thread can be closed */
-  lua_lock(L);
-  luaF_close(L, L->stack);  /* close all upvalues for this thread */
-  luaC_separateudata(L, 1);  /* separate udata that have GC metamethods */
-  L->errfunc = 0;  /* no error function during GC metamethods */
-  do {  /* repeat until no more errors */
-    L->ci = L->base_ci;
-    L->base = L->top = L->ci->base;
-    L->nCcalls = L->baseCcalls = 0;
-  } while (luaD_rawrunprotected(L, callallgcTM, NULL) != 0);
-  lua_assert(G(L)->tmudata == NULL);
-  luai_userstateclose(L);
-  close_state(L);
-}
-
diff --git a/extern/lua-5.1.5/src/lstate.h b/extern/lua-5.1.5/src/lstate.h
deleted file mode 100644
index 3bc575b6..00000000
--- a/extern/lua-5.1.5/src/lstate.h
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
-** $Id: lstate.h,v 2.24.1.2 2008/01/03 15:20:39 roberto Exp $
-** Global State
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lstate_h
-#define lstate_h
-
-#include "lua.h"
-
-#include "lobject.h"
-#include "ltm.h"
-#include "lzio.h"
-
-
-
-struct lua_longjmp;  /* defined in ldo.c */
-
-
-/* table of globals */
-#define gt(L)	(&L->l_gt)
-
-/* registry */
-#define registry(L)	(&G(L)->l_registry)
-
-
-/* extra stack space to handle TM calls and some other extras */
-#define EXTRA_STACK   5
-
-
-#define BASIC_CI_SIZE           8
-
-#define BASIC_STACK_SIZE        (2*LUA_MINSTACK)
-
-
-
-typedef struct stringtable {
-  GCObject **hash;
-  lu_int32 nuse;  /* number of elements */
-  int size;
-} stringtable;
-
-
-/*
-** informations about a call
-*/
-typedef struct CallInfo {
-  StkId base;  /* base for this function */
-  StkId func;  /* function index in the stack */
-  StkId	top;  /* top for this function */
-  const Instruction *savedpc;
-  int nresults;  /* expected number of results from this function */
-  int tailcalls;  /* number of tail calls lost under this entry */
-} CallInfo;
-
-
-
-#define curr_func(L)	(clvalue(L->ci->func))
-#define ci_func(ci)	(clvalue((ci)->func))
-#define f_isLua(ci)	(!ci_func(ci)->c.isC)
-#define isLua(ci)	(ttisfunction((ci)->func) && f_isLua(ci))
-
-
-/*
-** `global state', shared by all threads of this state
-*/
-typedef struct global_State {
-  stringtable strt;  /* hash table for strings */
-  lua_Alloc frealloc;  /* function to reallocate memory */
-  void *ud;         /* auxiliary data to `frealloc' */
-  lu_byte currentwhite;
-  lu_byte gcstate;  /* state of garbage collector */
-  int sweepstrgc;  /* position of sweep in `strt' */
-  GCObject *rootgc;  /* list of all collectable objects */
-  GCObject **sweepgc;  /* position of sweep in `rootgc' */
-  GCObject *gray;  /* list of gray objects */
-  GCObject *grayagain;  /* list of objects to be traversed atomically */
-  GCObject *weak;  /* list of weak tables (to be cleared) */
-  GCObject *tmudata;  /* last element of list of userdata to be GC */
-  Mbuffer buff;  /* temporary buffer for string concatentation */
-  lu_mem GCthreshold;
-  lu_mem totalbytes;  /* number of bytes currently allocated */
-  lu_mem estimate;  /* an estimate of number of bytes actually in use */
-  lu_mem gcdept;  /* how much GC is `behind schedule' */
-  int gcpause;  /* size of pause between successive GCs */
-  int gcstepmul;  /* GC `granularity' */
-  lua_CFunction panic;  /* to be called in unprotected errors */
-  TValue l_registry;
-  struct lua_State *mainthread;
-  UpVal uvhead;  /* head of double-linked list of all open upvalues */
-  struct Table *mt[NUM_TAGS];  /* metatables for basic types */
-  TString *tmname[TM_N];  /* array with tag-method names */
-} global_State;
-
-
-/*
-** `per thread' state
-*/
-struct lua_State {
-  CommonHeader;
-  lu_byte status;
-  StkId top;  /* first free slot in the stack */
-  StkId base;  /* base of current function */
-  global_State *l_G;
-  CallInfo *ci;  /* call info for current function */
-  const Instruction *savedpc;  /* `savedpc' of current function */
-  StkId stack_last;  /* last free slot in the stack */
-  StkId stack;  /* stack base */
-  CallInfo *end_ci;  /* points after end of ci array*/
-  CallInfo *base_ci;  /* array of CallInfo's */
-  int stacksize;
-  int size_ci;  /* size of array `base_ci' */
-  unsigned short nCcalls;  /* number of nested C calls */
-  unsigned short baseCcalls;  /* nested C calls when resuming coroutine */
-  lu_byte hookmask;
-  lu_byte allowhook;
-  int basehookcount;
-  int hookcount;
-  lua_Hook hook;
-  TValue l_gt;  /* table of globals */
-  TValue env;  /* temporary place for environments */
-  GCObject *openupval;  /* list of open upvalues in this stack */
-  GCObject *gclist;
-  struct lua_longjmp *errorJmp;  /* current error recover point */
-  ptrdiff_t errfunc;  /* current error handling function (stack index) */
-};
-
-
-#define G(L)	(L->l_G)
-
-
-/*
-** Union of all collectable objects
-*/
-union GCObject {
-  GCheader gch;
-  union TString ts;
-  union Udata u;
-  union Closure cl;
-  struct Table h;
-  struct Proto p;
-  struct UpVal uv;
-  struct lua_State th;  /* thread */
-};
-
-
-/* macros to convert a GCObject into a specific value */
-#define rawgco2ts(o)	check_exp((o)->gch.tt == LUA_TSTRING, &((o)->ts))
-#define gco2ts(o)	(&rawgco2ts(o)->tsv)
-#define rawgco2u(o)	check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u))
-#define gco2u(o)	(&rawgco2u(o)->uv)
-#define gco2cl(o)	check_exp((o)->gch.tt == LUA_TFUNCTION, &((o)->cl))
-#define gco2h(o)	check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h))
-#define gco2p(o)	check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p))
-#define gco2uv(o)	check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv))
-#define ngcotouv(o) \
-	check_exp((o) == NULL || (o)->gch.tt == LUA_TUPVAL, &((o)->uv))
-#define gco2th(o)	check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th))
-
-/* macro to convert any Lua object into a GCObject */
-#define obj2gco(v)	(cast(GCObject *, (v)))
-
-
-LUAI_FUNC lua_State *luaE_newthread (lua_State *L);
-LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
-
-#endif
-
diff --git a/extern/lua-5.1.5/src/lstring.c b/extern/lua-5.1.5/src/lstring.c
deleted file mode 100644
index 49113151..00000000
--- a/extern/lua-5.1.5/src/lstring.c
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
-** $Id: lstring.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
-** String table (keeps all strings handled by Lua)
-** See Copyright Notice in lua.h
-*/
-
-
-#include <string.h>
-
-#define lstring_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-
-
-
-void luaS_resize (lua_State *L, int newsize) {
-  GCObject **newhash;
-  stringtable *tb;
-  int i;
-  if (G(L)->gcstate == GCSsweepstring)
-    return;  /* cannot resize during GC traverse */
-  newhash = luaM_newvector(L, newsize, GCObject *);
-  tb = &G(L)->strt;
-  for (i=0; i<newsize; i++) newhash[i] = NULL;
-  /* rehash */
-  for (i=0; i<tb->size; i++) {
-    GCObject *p = tb->hash[i];
-    while (p) {  /* for each node in the list */
-      GCObject *next = p->gch.next;  /* save next */
-      unsigned int h = gco2ts(p)->hash;
-      int h1 = lmod(h, newsize);  /* new position */
-      lua_assert(cast_int(h%newsize) == lmod(h, newsize));
-      p->gch.next = newhash[h1];  /* chain it */
-      newhash[h1] = p;
-      p = next;
-    }
-  }
-  luaM_freearray(L, tb->hash, tb->size, TString *);
-  tb->size = newsize;
-  tb->hash = newhash;
-}
-
-
-static TString *newlstr (lua_State *L, const char *str, size_t l,
-                                       unsigned int h) {
-  TString *ts;
-  stringtable *tb;
-  if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
-    luaM_toobig(L);
-  ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));
-  ts->tsv.len = l;
-  ts->tsv.hash = h;
-  ts->tsv.marked = luaC_white(G(L));
-  ts->tsv.tt = LUA_TSTRING;
-  ts->tsv.reserved = 0;
-  memcpy(ts+1, str, l*sizeof(char));
-  ((char *)(ts+1))[l] = '\0';  /* ending 0 */
-  tb = &G(L)->strt;
-  h = lmod(h, tb->size);
-  ts->tsv.next = tb->hash[h];  /* chain new entry */
-  tb->hash[h] = obj2gco(ts);
-  tb->nuse++;
-  if (tb->nuse > cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)
-    luaS_resize(L, tb->size*2);  /* too crowded */
-  return ts;
-}
-
-
-TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
-  GCObject *o;
-  unsigned int h = cast(unsigned int, l);  /* seed */
-  size_t step = (l>>5)+1;  /* if string is too long, don't hash all its chars */
-  size_t l1;
-  for (l1=l; l1>=step; l1-=step)  /* compute hash */
-    h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));
-  for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
-       o != NULL;
-       o = o->gch.next) {
-    TString *ts = rawgco2ts(o);
-    if (ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0)) {
-      /* string may be dead */
-      if (isdead(G(L), o)) changewhite(o);
-      return ts;
-    }
-  }
-  return newlstr(L, str, l, h);  /* not found */
-}
-
-
-Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
-  Udata *u;
-  if (s > MAX_SIZET - sizeof(Udata))
-    luaM_toobig(L);
-  u = cast(Udata *, luaM_malloc(L, s + sizeof(Udata)));
-  u->uv.marked = luaC_white(G(L));  /* is not finalized */
-  u->uv.tt = LUA_TUSERDATA;
-  u->uv.len = s;
-  u->uv.metatable = NULL;
-  u->uv.env = e;
-  /* chain it on udata list (after main thread) */
-  u->uv.next = G(L)->mainthread->next;
-  G(L)->mainthread->next = obj2gco(u);
-  return u;
-}
-
diff --git a/extern/lua-5.1.5/src/lstring.h b/extern/lua-5.1.5/src/lstring.h
deleted file mode 100644
index 73a2ff8b..00000000
--- a/extern/lua-5.1.5/src/lstring.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
-** $Id: lstring.h,v 1.43.1.1 2007/12/27 13:02:25 roberto Exp $
-** String table (keep all strings handled by Lua)
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lstring_h
-#define lstring_h
-
-
-#include "lgc.h"
-#include "lobject.h"
-#include "lstate.h"
-
-
-#define sizestring(s)	(sizeof(union TString)+((s)->len+1)*sizeof(char))
-
-#define sizeudata(u)	(sizeof(union Udata)+(u)->len)
-
-#define luaS_new(L, s)	(luaS_newlstr(L, s, strlen(s)))
-#define luaS_newliteral(L, s)	(luaS_newlstr(L, "" s, \
-                                 (sizeof(s)/sizeof(char))-1))
-
-#define luaS_fix(s)	l_setbit((s)->tsv.marked, FIXEDBIT)
-
-LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
-LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e);
-LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
-
-
-#endif
diff --git a/extern/lua-5.1.5/src/lstrlib.c b/extern/lua-5.1.5/src/lstrlib.c
deleted file mode 100644
index 7a03489b..00000000
--- a/extern/lua-5.1.5/src/lstrlib.c
+++ /dev/null
@@ -1,871 +0,0 @@
-/*
-** $Id: lstrlib.c,v 1.132.1.5 2010/05/14 15:34:19 roberto Exp $
-** Standard library for string operations and pattern-matching
-** See Copyright Notice in lua.h
-*/
-
-
-#include <ctype.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define lstrlib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-/* macro to `unsign' a character */
-#define uchar(c)        ((unsigned char)(c))
-
-
-
-static int str_len (lua_State *L) {
-  size_t l;
-  luaL_checklstring(L, 1, &l);
-  lua_pushinteger(L, l);
-  return 1;
-}
-
-
-static ptrdiff_t posrelat (ptrdiff_t pos, size_t len) {
-  /* relative string position: negative means back from end */
-  if (pos < 0) pos += (ptrdiff_t)len + 1;
-  return (pos >= 0) ? pos : 0;
-}
-
-
-static int str_sub (lua_State *L) {
-  size_t l;
-  const char *s = luaL_checklstring(L, 1, &l);
-  ptrdiff_t start = posrelat(luaL_checkinteger(L, 2), l);
-  ptrdiff_t end = posrelat(luaL_optinteger(L, 3, -1), l);
-  if (start < 1) start = 1;
-  if (end > (ptrdiff_t)l) end = (ptrdiff_t)l;
-  if (start <= end)
-    lua_pushlstring(L, s+start-1, end-start+1);
-  else lua_pushliteral(L, "");
-  return 1;
-}
-
-
-static int str_reverse (lua_State *L) {
-  size_t l;
-  luaL_Buffer b;
-  const char *s = luaL_checklstring(L, 1, &l);
-  luaL_buffinit(L, &b);
-  while (l--) luaL_addchar(&b, s[l]);
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-static int str_lower (lua_State *L) {
-  size_t l;
-  size_t i;
-  luaL_Buffer b;
-  const char *s = luaL_checklstring(L, 1, &l);
-  luaL_buffinit(L, &b);
-  for (i=0; i<l; i++)
-    luaL_addchar(&b, tolower(uchar(s[i])));
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-static int str_upper (lua_State *L) {
-  size_t l;
-  size_t i;
-  luaL_Buffer b;
-  const char *s = luaL_checklstring(L, 1, &l);
-  luaL_buffinit(L, &b);
-  for (i=0; i<l; i++)
-    luaL_addchar(&b, toupper(uchar(s[i])));
-  luaL_pushresult(&b);
-  return 1;
-}
-
-static int str_rep (lua_State *L) {
-  size_t l;
-  luaL_Buffer b;
-  const char *s = luaL_checklstring(L, 1, &l);
-  int n = luaL_checkint(L, 2);
-  luaL_buffinit(L, &b);
-  while (n-- > 0)
-    luaL_addlstring(&b, s, l);
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-static int str_byte (lua_State *L) {
-  size_t l;
-  const char *s = luaL_checklstring(L, 1, &l);
-  ptrdiff_t posi = posrelat(luaL_optinteger(L, 2, 1), l);
-  ptrdiff_t pose = posrelat(luaL_optinteger(L, 3, posi), l);
-  int n, i;
-  if (posi <= 0) posi = 1;
-  if ((size_t)pose > l) pose = l;
-  if (posi > pose) return 0;  /* empty interval; return no values */
-  n = (int)(pose -  posi + 1);
-  if (posi + n <= pose)  /* overflow? */
-    luaL_error(L, "string slice too long");
-  luaL_checkstack(L, n, "string slice too long");
-  for (i=0; i<n; i++)
-    lua_pushinteger(L, uchar(s[posi+i-1]));
-  return n;
-}
-
-
-static int str_char (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  int i;
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  for (i=1; i<=n; i++) {
-    int c = luaL_checkint(L, i);
-    luaL_argcheck(L, uchar(c) == c, i, "invalid value");
-    luaL_addchar(&b, uchar(c));
-  }
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-static int writer (lua_State *L, const void* b, size_t size, void* B) {
-  (void)L;
-  luaL_addlstring((luaL_Buffer*) B, (const char *)b, size);
-  return 0;
-}
-
-
-static int str_dump (lua_State *L) {
-  luaL_Buffer b;
-  luaL_checktype(L, 1, LUA_TFUNCTION);
-  lua_settop(L, 1);
-  luaL_buffinit(L,&b);
-  if (lua_dump(L, writer, &b) != 0)
-    luaL_error(L, "unable to dump given function");
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-
-/*
-** {======================================================
-** PATTERN MATCHING
-** =======================================================
-*/
-
-
-#define CAP_UNFINISHED	(-1)
-#define CAP_POSITION	(-2)
-
-typedef struct MatchState {
-  const char *src_init;  /* init of source string */
-  const char *src_end;  /* end (`\0') of source string */
-  lua_State *L;
-  int level;  /* total number of captures (finished or unfinished) */
-  struct {
-    const char *init;
-    ptrdiff_t len;
-  } capture[LUA_MAXCAPTURES];
-} MatchState;
-
-
-#define L_ESC		'%'
-#define SPECIALS	"^$*+?.([%-"
-
-
-static int check_capture (MatchState *ms, int l) {
-  l -= '1';
-  if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
-    return luaL_error(ms->L, "invalid capture index");
-  return l;
-}
-
-
-static int capture_to_close (MatchState *ms) {
-  int level = ms->level;
-  for (level--; level>=0; level--)
-    if (ms->capture[level].len == CAP_UNFINISHED) return level;
-  return luaL_error(ms->L, "invalid pattern capture");
-}
-
-
-static const char *classend (MatchState *ms, const char *p) {
-  switch (*p++) {
-    case L_ESC: {
-      if (*p == '\0')
-        luaL_error(ms->L, "malformed pattern (ends with " LUA_QL("%%") ")");
-      return p+1;
-    }
-    case '[': {
-      if (*p == '^') p++;
-      do {  /* look for a `]' */
-        if (*p == '\0')
-          luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")");
-        if (*(p++) == L_ESC && *p != '\0')
-          p++;  /* skip escapes (e.g. `%]') */
-      } while (*p != ']');
-      return p+1;
-    }
-    default: {
-      return p;
-    }
-  }
-}
-
-
-static int match_class (int c, int cl) {
-  int res;
-  switch (tolower(cl)) {
-    case 'a' : res = isalpha(c); break;
-    case 'c' : res = iscntrl(c); break;
-    case 'd' : res = isdigit(c); break;
-    case 'l' : res = islower(c); break;
-    case 'p' : res = ispunct(c); break;
-    case 's' : res = isspace(c); break;
-    case 'u' : res = isupper(c); break;
-    case 'w' : res = isalnum(c); break;
-    case 'x' : res = isxdigit(c); break;
-    case 'z' : res = (c == 0); break;
-    default: return (cl == c);
-  }
-  return (islower(cl) ? res : !res);
-}
-
-
-static int matchbracketclass (int c, const char *p, const char *ec) {
-  int sig = 1;
-  if (*(p+1) == '^') {
-    sig = 0;
-    p++;  /* skip the `^' */
-  }
-  while (++p < ec) {
-    if (*p == L_ESC) {
-      p++;
-      if (match_class(c, uchar(*p)))
-        return sig;
-    }
-    else if ((*(p+1) == '-') && (p+2 < ec)) {
-      p+=2;
-      if (uchar(*(p-2)) <= c && c <= uchar(*p))
-        return sig;
-    }
-    else if (uchar(*p) == c) return sig;
-  }
-  return !sig;
-}
-
-
-static int singlematch (int c, const char *p, const char *ep) {
-  switch (*p) {
-    case '.': return 1;  /* matches any char */
-    case L_ESC: return match_class(c, uchar(*(p+1)));
-    case '[': return matchbracketclass(c, p, ep-1);
-    default:  return (uchar(*p) == c);
-  }
-}
-
-
-static const char *match (MatchState *ms, const char *s, const char *p);
-
-
-static const char *matchbalance (MatchState *ms, const char *s,
-                                   const char *p) {
-  if (*p == 0 || *(p+1) == 0)
-    luaL_error(ms->L, "unbalanced pattern");
-  if (*s != *p) return NULL;
-  else {
-    int b = *p;
-    int e = *(p+1);
-    int cont = 1;
-    while (++s < ms->src_end) {
-      if (*s == e) {
-        if (--cont == 0) return s+1;
-      }
-      else if (*s == b) cont++;
-    }
-  }
-  return NULL;  /* string ends out of balance */
-}
-
-
-static const char *max_expand (MatchState *ms, const char *s,
-                                 const char *p, const char *ep) {
-  ptrdiff_t i = 0;  /* counts maximum expand for item */
-  while ((s+i)<ms->src_end && singlematch(uchar(*(s+i)), p, ep))
-    i++;
-  /* keeps trying to match with the maximum repetitions */
-  while (i>=0) {
-    const char *res = match(ms, (s+i), ep+1);
-    if (res) return res;
-    i--;  /* else didn't match; reduce 1 repetition to try again */
-  }
-  return NULL;
-}
-
-
-static const char *min_expand (MatchState *ms, const char *s,
-                                 const char *p, const char *ep) {
-  for (;;) {
-    const char *res = match(ms, s, ep+1);
-    if (res != NULL)
-      return res;
-    else if (s<ms->src_end && singlematch(uchar(*s), p, ep))
-      s++;  /* try with one more repetition */
-    else return NULL;
-  }
-}
-
-
-static const char *start_capture (MatchState *ms, const char *s,
-                                    const char *p, int what) {
-  const char *res;
-  int level = ms->level;
-  if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures");
-  ms->capture[level].init = s;
-  ms->capture[level].len = what;
-  ms->level = level+1;
-  if ((res=match(ms, s, p)) == NULL)  /* match failed? */
-    ms->level--;  /* undo capture */
-  return res;
-}
-
-
-static const char *end_capture (MatchState *ms, const char *s,
-                                  const char *p) {
-  int l = capture_to_close(ms);
-  const char *res;
-  ms->capture[l].len = s - ms->capture[l].init;  /* close capture */
-  if ((res = match(ms, s, p)) == NULL)  /* match failed? */
-    ms->capture[l].len = CAP_UNFINISHED;  /* undo capture */
-  return res;
-}
-
-
-static const char *match_capture (MatchState *ms, const char *s, int l) {
-  size_t len;
-  l = check_capture(ms, l);
-  len = ms->capture[l].len;
-  if ((size_t)(ms->src_end-s) >= len &&
-      memcmp(ms->capture[l].init, s, len) == 0)
-    return s+len;
-  else return NULL;
-}
-
-
-static const char *match (MatchState *ms, const char *s, const char *p) {
-  init: /* using goto's to optimize tail recursion */
-  switch (*p) {
-    case '(': {  /* start capture */
-      if (*(p+1) == ')')  /* position capture? */
-        return start_capture(ms, s, p+2, CAP_POSITION);
-      else
-        return start_capture(ms, s, p+1, CAP_UNFINISHED);
-    }
-    case ')': {  /* end capture */
-      return end_capture(ms, s, p+1);
-    }
-    case L_ESC: {
-      switch (*(p+1)) {
-        case 'b': {  /* balanced string? */
-          s = matchbalance(ms, s, p+2);
-          if (s == NULL) return NULL;
-          p+=4; goto init;  /* else return match(ms, s, p+4); */
-        }
-        case 'f': {  /* frontier? */
-          const char *ep; char previous;
-          p += 2;
-          if (*p != '[')
-            luaL_error(ms->L, "missing " LUA_QL("[") " after "
-                               LUA_QL("%%f") " in pattern");
-          ep = classend(ms, p);  /* points to what is next */
-          previous = (s == ms->src_init) ? '\0' : *(s-1);
-          if (matchbracketclass(uchar(previous), p, ep-1) ||
-             !matchbracketclass(uchar(*s), p, ep-1)) return NULL;
-          p=ep; goto init;  /* else return match(ms, s, ep); */
-        }
-        default: {
-          if (isdigit(uchar(*(p+1)))) {  /* capture results (%0-%9)? */
-            s = match_capture(ms, s, uchar(*(p+1)));
-            if (s == NULL) return NULL;
-            p+=2; goto init;  /* else return match(ms, s, p+2) */
-          }
-          goto dflt;  /* case default */
-        }
-      }
-    }
-    case '\0': {  /* end of pattern */
-      return s;  /* match succeeded */
-    }
-    case '$': {
-      if (*(p+1) == '\0')  /* is the `$' the last char in pattern? */
-        return (s == ms->src_end) ? s : NULL;  /* check end of string */
-      else goto dflt;
-    }
-    default: dflt: {  /* it is a pattern item */
-      const char *ep = classend(ms, p);  /* points to what is next */
-      int m = s<ms->src_end && singlematch(uchar(*s), p, ep);
-      switch (*ep) {
-        case '?': {  /* optional */
-          const char *res;
-          if (m && ((res=match(ms, s+1, ep+1)) != NULL))
-            return res;
-          p=ep+1; goto init;  /* else return match(ms, s, ep+1); */
-        }
-        case '*': {  /* 0 or more repetitions */
-          return max_expand(ms, s, p, ep);
-        }
-        case '+': {  /* 1 or more repetitions */
-          return (m ? max_expand(ms, s+1, p, ep) : NULL);
-        }
-        case '-': {  /* 0 or more repetitions (minimum) */
-          return min_expand(ms, s, p, ep);
-        }
-        default: {
-          if (!m) return NULL;
-          s++; p=ep; goto init;  /* else return match(ms, s+1, ep); */
-        }
-      }
-    }
-  }
-}
-
-
-
-static const char *lmemfind (const char *s1, size_t l1,
-                               const char *s2, size_t l2) {
-  if (l2 == 0) return s1;  /* empty strings are everywhere */
-  else if (l2 > l1) return NULL;  /* avoids a negative `l1' */
-  else {
-    const char *init;  /* to search for a `*s2' inside `s1' */
-    l2--;  /* 1st char will be checked by `memchr' */
-    l1 = l1-l2;  /* `s2' cannot be found after that */
-    while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) {
-      init++;   /* 1st char is already checked */
-      if (memcmp(init, s2+1, l2) == 0)
-        return init-1;
-      else {  /* correct `l1' and `s1' to try again */
-        l1 -= init-s1;
-        s1 = init;
-      }
-    }
-    return NULL;  /* not found */
-  }
-}
-
-
-static void push_onecapture (MatchState *ms, int i, const char *s,
-                                                    const char *e) {
-  if (i >= ms->level) {
-    if (i == 0)  /* ms->level == 0, too */
-      lua_pushlstring(ms->L, s, e - s);  /* add whole match */
-    else
-      luaL_error(ms->L, "invalid capture index");
-  }
-  else {
-    ptrdiff_t l = ms->capture[i].len;
-    if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture");
-    if (l == CAP_POSITION)
-      lua_pushinteger(ms->L, ms->capture[i].init - ms->src_init + 1);
-    else
-      lua_pushlstring(ms->L, ms->capture[i].init, l);
-  }
-}
-
-
-static int push_captures (MatchState *ms, const char *s, const char *e) {
-  int i;
-  int nlevels = (ms->level == 0 && s) ? 1 : ms->level;
-  luaL_checkstack(ms->L, nlevels, "too many captures");
-  for (i = 0; i < nlevels; i++)
-    push_onecapture(ms, i, s, e);
-  return nlevels;  /* number of strings pushed */
-}
-
-
-static int str_find_aux (lua_State *L, int find) {
-  size_t l1, l2;
-  const char *s = luaL_checklstring(L, 1, &l1);
-  const char *p = luaL_checklstring(L, 2, &l2);
-  ptrdiff_t init = posrelat(luaL_optinteger(L, 3, 1), l1) - 1;
-  if (init < 0) init = 0;
-  else if ((size_t)(init) > l1) init = (ptrdiff_t)l1;
-  if (find && (lua_toboolean(L, 4) ||  /* explicit request? */
-      strpbrk(p, SPECIALS) == NULL)) {  /* or no special characters? */
-    /* do a plain search */
-    const char *s2 = lmemfind(s+init, l1-init, p, l2);
-    if (s2) {
-      lua_pushinteger(L, s2-s+1);
-      lua_pushinteger(L, s2-s+l2);
-      return 2;
-    }
-  }
-  else {
-    MatchState ms;
-    int anchor = (*p == '^') ? (p++, 1) : 0;
-    const char *s1=s+init;
-    ms.L = L;
-    ms.src_init = s;
-    ms.src_end = s+l1;
-    do {
-      const char *res;
-      ms.level = 0;
-      if ((res=match(&ms, s1, p)) != NULL) {
-        if (find) {
-          lua_pushinteger(L, s1-s+1);  /* start */
-          lua_pushinteger(L, res-s);   /* end */
-          return push_captures(&ms, NULL, 0) + 2;
-        }
-        else
-          return push_captures(&ms, s1, res);
-      }
-    } while (s1++ < ms.src_end && !anchor);
-  }
-  lua_pushnil(L);  /* not found */
-  return 1;
-}
-
-
-static int str_find (lua_State *L) {
-  return str_find_aux(L, 1);
-}
-
-
-static int str_match (lua_State *L) {
-  return str_find_aux(L, 0);
-}
-
-
-static int gmatch_aux (lua_State *L) {
-  MatchState ms;
-  size_t ls;
-  const char *s = lua_tolstring(L, lua_upvalueindex(1), &ls);
-  const char *p = lua_tostring(L, lua_upvalueindex(2));
-  const char *src;
-  ms.L = L;
-  ms.src_init = s;
-  ms.src_end = s+ls;
-  for (src = s + (size_t)lua_tointeger(L, lua_upvalueindex(3));
-       src <= ms.src_end;
-       src++) {
-    const char *e;
-    ms.level = 0;
-    if ((e = match(&ms, src, p)) != NULL) {
-      lua_Integer newstart = e-s;
-      if (e == src) newstart++;  /* empty match? go at least one position */
-      lua_pushinteger(L, newstart);
-      lua_replace(L, lua_upvalueindex(3));
-      return push_captures(&ms, src, e);
-    }
-  }
-  return 0;  /* not found */
-}
-
-
-static int gmatch (lua_State *L) {
-  luaL_checkstring(L, 1);
-  luaL_checkstring(L, 2);
-  lua_settop(L, 2);
-  lua_pushinteger(L, 0);
-  lua_pushcclosure(L, gmatch_aux, 3);
-  return 1;
-}
-
-
-static int gfind_nodef (lua_State *L) {
-  return luaL_error(L, LUA_QL("string.gfind") " was renamed to "
-                       LUA_QL("string.gmatch"));
-}
-
-
-static void add_s (MatchState *ms, luaL_Buffer *b, const char *s,
-                                                   const char *e) {
-  size_t l, i;
-  const char *news = lua_tolstring(ms->L, 3, &l);
-  for (i = 0; i < l; i++) {
-    if (news[i] != L_ESC)
-      luaL_addchar(b, news[i]);
-    else {
-      i++;  /* skip ESC */
-      if (!isdigit(uchar(news[i])))
-        luaL_addchar(b, news[i]);
-      else if (news[i] == '0')
-          luaL_addlstring(b, s, e - s);
-      else {
-        push_onecapture(ms, news[i] - '1', s, e);
-        luaL_addvalue(b);  /* add capture to accumulated result */
-      }
-    }
-  }
-}
-
-
-static void add_value (MatchState *ms, luaL_Buffer *b, const char *s,
-                                                       const char *e) {
-  lua_State *L = ms->L;
-  switch (lua_type(L, 3)) {
-    case LUA_TNUMBER:
-    case LUA_TSTRING: {
-      add_s(ms, b, s, e);
-      return;
-    }
-    case LUA_TFUNCTION: {
-      int n;
-      lua_pushvalue(L, 3);
-      n = push_captures(ms, s, e);
-      lua_call(L, n, 1);
-      break;
-    }
-    case LUA_TTABLE: {
-      push_onecapture(ms, 0, s, e);
-      lua_gettable(L, 3);
-      break;
-    }
-  }
-  if (!lua_toboolean(L, -1)) {  /* nil or false? */
-    lua_pop(L, 1);
-    lua_pushlstring(L, s, e - s);  /* keep original text */
-  }
-  else if (!lua_isstring(L, -1))
-    luaL_error(L, "invalid replacement value (a %s)", luaL_typename(L, -1)); 
-  luaL_addvalue(b);  /* add result to accumulator */
-}
-
-
-static int str_gsub (lua_State *L) {
-  size_t srcl;
-  const char *src = luaL_checklstring(L, 1, &srcl);
-  const char *p = luaL_checkstring(L, 2);
-  int  tr = lua_type(L, 3);
-  int max_s = luaL_optint(L, 4, srcl+1);
-  int anchor = (*p == '^') ? (p++, 1) : 0;
-  int n = 0;
-  MatchState ms;
-  luaL_Buffer b;
-  luaL_argcheck(L, tr == LUA_TNUMBER || tr == LUA_TSTRING ||
-                   tr == LUA_TFUNCTION || tr == LUA_TTABLE, 3,
-                      "string/function/table expected");
-  luaL_buffinit(L, &b);
-  ms.L = L;
-  ms.src_init = src;
-  ms.src_end = src+srcl;
-  while (n < max_s) {
-    const char *e;
-    ms.level = 0;
-    e = match(&ms, src, p);
-    if (e) {
-      n++;
-      add_value(&ms, &b, src, e);
-    }
-    if (e && e>src) /* non empty match? */
-      src = e;  /* skip it */
-    else if (src < ms.src_end)
-      luaL_addchar(&b, *src++);
-    else break;
-    if (anchor) break;
-  }
-  luaL_addlstring(&b, src, ms.src_end-src);
-  luaL_pushresult(&b);
-  lua_pushinteger(L, n);  /* number of substitutions */
-  return 2;
-}
-
-/* }====================================================== */
-
-
-/* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */
-#define MAX_ITEM	512
-/* valid flags in a format specification */
-#define FLAGS	"-+ #0"
-/*
-** maximum size of each format specification (such as '%-099.99d')
-** (+10 accounts for %99.99x plus margin of error)
-*/
-#define MAX_FORMAT	(sizeof(FLAGS) + sizeof(LUA_INTFRMLEN) + 10)
-
-
-static void addquoted (lua_State *L, luaL_Buffer *b, int arg) {
-  size_t l;
-  const char *s = luaL_checklstring(L, arg, &l);
-  luaL_addchar(b, '"');
-  while (l--) {
-    switch (*s) {
-      case '"': case '\\': case '\n': {
-        luaL_addchar(b, '\\');
-        luaL_addchar(b, *s);
-        break;
-      }
-      case '\r': {
-        luaL_addlstring(b, "\\r", 2);
-        break;
-      }
-      case '\0': {
-        luaL_addlstring(b, "\\000", 4);
-        break;
-      }
-      default: {
-        luaL_addchar(b, *s);
-        break;
-      }
-    }
-    s++;
-  }
-  luaL_addchar(b, '"');
-}
-
-static const char *scanformat (lua_State *L, const char *strfrmt, char *form) {
-  const char *p = strfrmt;
-  while (*p != '\0' && strchr(FLAGS, *p) != NULL) p++;  /* skip flags */
-  if ((size_t)(p - strfrmt) >= sizeof(FLAGS))
-    luaL_error(L, "invalid format (repeated flags)");
-  if (isdigit(uchar(*p))) p++;  /* skip width */
-  if (isdigit(uchar(*p))) p++;  /* (2 digits at most) */
-  if (*p == '.') {
-    p++;
-    if (isdigit(uchar(*p))) p++;  /* skip precision */
-    if (isdigit(uchar(*p))) p++;  /* (2 digits at most) */
-  }
-  if (isdigit(uchar(*p)))
-    luaL_error(L, "invalid format (width or precision too long)");
-  *(form++) = '%';
-  strncpy(form, strfrmt, p - strfrmt + 1);
-  form += p - strfrmt + 1;
-  *form = '\0';
-  return p;
-}
-
-
-static void addintlen (char *form) {
-  size_t l = strlen(form);
-  char spec = form[l - 1];
-  strcpy(form + l - 1, LUA_INTFRMLEN);
-  form[l + sizeof(LUA_INTFRMLEN) - 2] = spec;
-  form[l + sizeof(LUA_INTFRMLEN) - 1] = '\0';
-}
-
-
-static int str_format (lua_State *L) {
-  int top = lua_gettop(L);
-  int arg = 1;
-  size_t sfl;
-  const char *strfrmt = luaL_checklstring(L, arg, &sfl);
-  const char *strfrmt_end = strfrmt+sfl;
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  while (strfrmt < strfrmt_end) {
-    if (*strfrmt != L_ESC)
-      luaL_addchar(&b, *strfrmt++);
-    else if (*++strfrmt == L_ESC)
-      luaL_addchar(&b, *strfrmt++);  /* %% */
-    else { /* format item */
-      char form[MAX_FORMAT];  /* to store the format (`%...') */
-      char buff[MAX_ITEM];  /* to store the formatted item */
-      if (++arg > top)
-        luaL_argerror(L, arg, "no value");
-      strfrmt = scanformat(L, strfrmt, form);
-      switch (*strfrmt++) {
-        case 'c': {
-          sprintf(buff, form, (int)luaL_checknumber(L, arg));
-          break;
-        }
-        case 'd':  case 'i': {
-          addintlen(form);
-          sprintf(buff, form, (LUA_INTFRM_T)luaL_checknumber(L, arg));
-          break;
-        }
-        case 'o':  case 'u':  case 'x':  case 'X': {
-          addintlen(form);
-          sprintf(buff, form, (unsigned LUA_INTFRM_T)luaL_checknumber(L, arg));
-          break;
-        }
-        case 'e':  case 'E': case 'f':
-        case 'g': case 'G': {
-          sprintf(buff, form, (double)luaL_checknumber(L, arg));
-          break;
-        }
-        case 'q': {
-          addquoted(L, &b, arg);
-          continue;  /* skip the 'addsize' at the end */
-        }
-        case 's': {
-          size_t l;
-          const char *s = luaL_checklstring(L, arg, &l);
-          if (!strchr(form, '.') && l >= 100) {
-            /* no precision and string is too long to be formatted;
-               keep original string */
-            lua_pushvalue(L, arg);
-            luaL_addvalue(&b);
-            continue;  /* skip the `addsize' at the end */
-          }
-          else {
-            sprintf(buff, form, s);
-            break;
-          }
-        }
-        default: {  /* also treat cases `pnLlh' */
-          return luaL_error(L, "invalid option " LUA_QL("%%%c") " to "
-                               LUA_QL("format"), *(strfrmt - 1));
-        }
-      }
-      luaL_addlstring(&b, buff, strlen(buff));
-    }
-  }
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-static const luaL_Reg strlib[] = {
-  {"byte", str_byte},
-  {"char", str_char},
-  {"dump", str_dump},
-  {"find", str_find},
-  {"format", str_format},
-  {"gfind", gfind_nodef},
-  {"gmatch", gmatch},
-  {"gsub", str_gsub},
-  {"len", str_len},
-  {"lower", str_lower},
-  {"match", str_match},
-  {"rep", str_rep},
-  {"reverse", str_reverse},
-  {"sub", str_sub},
-  {"upper", str_upper},
-  {NULL, NULL}
-};
-
-
-static void createmetatable (lua_State *L) {
-  lua_createtable(L, 0, 1);  /* create metatable for strings */
-  lua_pushliteral(L, "");  /* dummy string */
-  lua_pushvalue(L, -2);
-  lua_setmetatable(L, -2);  /* set string metatable */
-  lua_pop(L, 1);  /* pop dummy string */
-  lua_pushvalue(L, -2);  /* string library... */
-  lua_setfield(L, -2, "__index");  /* ...is the __index metamethod */
-  lua_pop(L, 1);  /* pop metatable */
-}
-
-
-/*
-** Open string library
-*/
-LUALIB_API int luaopen_string (lua_State *L) {
-  luaL_register(L, LUA_STRLIBNAME, strlib);
-#if defined(LUA_COMPAT_GFIND)
-  lua_getfield(L, -1, "gmatch");
-  lua_setfield(L, -2, "gfind");
-#endif
-  createmetatable(L);
-  return 1;
-}
-
diff --git a/extern/lua-5.1.5/src/ltable.c b/extern/lua-5.1.5/src/ltable.c
deleted file mode 100644
index ec84f4fa..00000000
--- a/extern/lua-5.1.5/src/ltable.c
+++ /dev/null
@@ -1,588 +0,0 @@
-/*
-** $Id: ltable.c,v 2.32.1.2 2007/12/28 15:32:23 roberto Exp $
-** Lua tables (hash)
-** See Copyright Notice in lua.h
-*/
-
-
-/*
-** Implementation of tables (aka arrays, objects, or hash tables).
-** Tables keep its elements in two parts: an array part and a hash part.
-** Non-negative integer keys are all candidates to be kept in the array
-** part. The actual size of the array is the largest `n' such that at
-** least half the slots between 0 and n are in use.
-** Hash uses a mix of chained scatter table with Brent's variation.
-** A main invariant of these tables is that, if an element is not
-** in its main position (i.e. the `original' position that its hash gives
-** to it), then the colliding element is in its own main position.
-** Hence even when the load factor reaches 100%, performance remains good.
-*/
-
-#include <math.h>
-#include <string.h>
-
-#define ltable_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "ltable.h"
-
-
-/*
-** max size of array part is 2^MAXBITS
-*/
-#if LUAI_BITSINT > 26
-#define MAXBITS		26
-#else
-#define MAXBITS		(LUAI_BITSINT-2)
-#endif
-
-#define MAXASIZE	(1 << MAXBITS)
-
-
-#define hashpow2(t,n)      (gnode(t, lmod((n), sizenode(t))))
-  
-#define hashstr(t,str)  hashpow2(t, (str)->tsv.hash)
-#define hashboolean(t,p)        hashpow2(t, p)
-
-
-/*
-** for some types, it is better to avoid modulus by power of 2, as
-** they tend to have many 2 factors.
-*/
-#define hashmod(t,n)	(gnode(t, ((n) % ((sizenode(t)-1)|1))))
-
-
-#define hashpointer(t,p)	hashmod(t, IntPoint(p))
-
-
-/*
-** number of ints inside a lua_Number
-*/
-#define numints		cast_int(sizeof(lua_Number)/sizeof(int))
-
-
-
-#define dummynode		(&dummynode_)
-
-static const Node dummynode_ = {
-  {{NULL}, LUA_TNIL},  /* value */
-  {{{NULL}, LUA_TNIL, NULL}}  /* key */
-};
-
-
-/*
-** hash for lua_Numbers
-*/
-static Node *hashnum (const Table *t, lua_Number n) {
-  unsigned int a[numints];
-  int i;
-  if (luai_numeq(n, 0))  /* avoid problems with -0 */
-    return gnode(t, 0);
-  memcpy(a, &n, sizeof(a));
-  for (i = 1; i < numints; i++) a[0] += a[i];
-  return hashmod(t, a[0]);
-}
-
-
-
-/*
-** returns the `main' position of an element in a table (that is, the index
-** of its hash value)
-*/
-static Node *mainposition (const Table *t, const TValue *key) {
-  switch (ttype(key)) {
-    case LUA_TNUMBER:
-      return hashnum(t, nvalue(key));
-    case LUA_TSTRING:
-      return hashstr(t, rawtsvalue(key));
-    case LUA_TBOOLEAN:
-      return hashboolean(t, bvalue(key));
-    case LUA_TLIGHTUSERDATA:
-      return hashpointer(t, pvalue(key));
-    default:
-      return hashpointer(t, gcvalue(key));
-  }
-}
-
-
-/*
-** returns the index for `key' if `key' is an appropriate key to live in
-** the array part of the table, -1 otherwise.
-*/
-static int arrayindex (const TValue *key) {
-  if (ttisnumber(key)) {
-    lua_Number n = nvalue(key);
-    int k;
-    lua_number2int(k, n);
-    if (luai_numeq(cast_num(k), n))
-      return k;
-  }
-  return -1;  /* `key' did not match some condition */
-}
-
-
-/*
-** returns the index of a `key' for table traversals. First goes all
-** elements in the array part, then elements in the hash part. The
-** beginning of a traversal is signalled by -1.
-*/
-static int findindex (lua_State *L, Table *t, StkId key) {
-  int i;
-  if (ttisnil(key)) return -1;  /* first iteration */
-  i = arrayindex(key);
-  if (0 < i && i <= t->sizearray)  /* is `key' inside array part? */
-    return i-1;  /* yes; that's the index (corrected to C) */
-  else {
-    Node *n = mainposition(t, key);
-    do {  /* check whether `key' is somewhere in the chain */
-      /* key may be dead already, but it is ok to use it in `next' */
-      if (luaO_rawequalObj(key2tval(n), key) ||
-            (ttype(gkey(n)) == LUA_TDEADKEY && iscollectable(key) &&
-             gcvalue(gkey(n)) == gcvalue(key))) {
-        i = cast_int(n - gnode(t, 0));  /* key index in hash table */
-        /* hash elements are numbered after array ones */
-        return i + t->sizearray;
-      }
-      else n = gnext(n);
-    } while (n);
-    luaG_runerror(L, "invalid key to " LUA_QL("next"));  /* key not found */
-    return 0;  /* to avoid warnings */
-  }
-}
-
-
-int luaH_next (lua_State *L, Table *t, StkId key) {
-  int i = findindex(L, t, key);  /* find original element */
-  for (i++; i < t->sizearray; i++) {  /* try first array part */
-    if (!ttisnil(&t->array[i])) {  /* a non-nil value? */
-      setnvalue(key, cast_num(i+1));
-      setobj2s(L, key+1, &t->array[i]);
-      return 1;
-    }
-  }
-  for (i -= t->sizearray; i < sizenode(t); i++) {  /* then hash part */
-    if (!ttisnil(gval(gnode(t, i)))) {  /* a non-nil value? */
-      setobj2s(L, key, key2tval(gnode(t, i)));
-      setobj2s(L, key+1, gval(gnode(t, i)));
-      return 1;
-    }
-  }
-  return 0;  /* no more elements */
-}
-
-
-/*
-** {=============================================================
-** Rehash
-** ==============================================================
-*/
-
-
-static int computesizes (int nums[], int *narray) {
-  int i;
-  int twotoi;  /* 2^i */
-  int a = 0;  /* number of elements smaller than 2^i */
-  int na = 0;  /* number of elements to go to array part */
-  int n = 0;  /* optimal size for array part */
-  for (i = 0, twotoi = 1; twotoi/2 < *narray; i++, twotoi *= 2) {
-    if (nums[i] > 0) {
-      a += nums[i];
-      if (a > twotoi/2) {  /* more than half elements present? */
-        n = twotoi;  /* optimal size (till now) */
-        na = a;  /* all elements smaller than n will go to array part */
-      }
-    }
-    if (a == *narray) break;  /* all elements already counted */
-  }
-  *narray = n;
-  lua_assert(*narray/2 <= na && na <= *narray);
-  return na;
-}
-
-
-static int countint (const TValue *key, int *nums) {
-  int k = arrayindex(key);
-  if (0 < k && k <= MAXASIZE) {  /* is `key' an appropriate array index? */
-    nums[ceillog2(k)]++;  /* count as such */
-    return 1;
-  }
-  else
-    return 0;
-}
-
-
-static int numusearray (const Table *t, int *nums) {
-  int lg;
-  int ttlg;  /* 2^lg */
-  int ause = 0;  /* summation of `nums' */
-  int i = 1;  /* count to traverse all array keys */
-  for (lg=0, ttlg=1; lg<=MAXBITS; lg++, ttlg*=2) {  /* for each slice */
-    int lc = 0;  /* counter */
-    int lim = ttlg;
-    if (lim > t->sizearray) {
-      lim = t->sizearray;  /* adjust upper limit */
-      if (i > lim)
-        break;  /* no more elements to count */
-    }
-    /* count elements in range (2^(lg-1), 2^lg] */
-    for (; i <= lim; i++) {
-      if (!ttisnil(&t->array[i-1]))
-        lc++;
-    }
-    nums[lg] += lc;
-    ause += lc;
-  }
-  return ause;
-}
-
-
-static int numusehash (const Table *t, int *nums, int *pnasize) {
-  int totaluse = 0;  /* total number of elements */
-  int ause = 0;  /* summation of `nums' */
-  int i = sizenode(t);
-  while (i--) {
-    Node *n = &t->node[i];
-    if (!ttisnil(gval(n))) {
-      ause += countint(key2tval(n), nums);
-      totaluse++;
-    }
-  }
-  *pnasize += ause;
-  return totaluse;
-}
-
-
-static void setarrayvector (lua_State *L, Table *t, int size) {
-  int i;
-  luaM_reallocvector(L, t->array, t->sizearray, size, TValue);
-  for (i=t->sizearray; i<size; i++)
-     setnilvalue(&t->array[i]);
-  t->sizearray = size;
-}
-
-
-static void setnodevector (lua_State *L, Table *t, int size) {
-  int lsize;
-  if (size == 0) {  /* no elements to hash part? */
-    t->node = cast(Node *, dummynode);  /* use common `dummynode' */
-    lsize = 0;
-  }
-  else {
-    int i;
-    lsize = ceillog2(size);
-    if (lsize > MAXBITS)
-      luaG_runerror(L, "table overflow");
-    size = twoto(lsize);
-    t->node = luaM_newvector(L, size, Node);
-    for (i=0; i<size; i++) {
-      Node *n = gnode(t, i);
-      gnext(n) = NULL;
-      setnilvalue(gkey(n));
-      setnilvalue(gval(n));
-    }
-  }
-  t->lsizenode = cast_byte(lsize);
-  t->lastfree = gnode(t, size);  /* all positions are free */
-}
-
-
-static void resize (lua_State *L, Table *t, int nasize, int nhsize) {
-  int i;
-  int oldasize = t->sizearray;
-  int oldhsize = t->lsizenode;
-  Node *nold = t->node;  /* save old hash ... */
-  if (nasize > oldasize)  /* array part must grow? */
-    setarrayvector(L, t, nasize);
-  /* create new hash part with appropriate size */
-  setnodevector(L, t, nhsize);  
-  if (nasize < oldasize) {  /* array part must shrink? */
-    t->sizearray = nasize;
-    /* re-insert elements from vanishing slice */
-    for (i=nasize; i<oldasize; i++) {
-      if (!ttisnil(&t->array[i]))
-        setobjt2t(L, luaH_setnum(L, t, i+1), &t->array[i]);
-    }
-    /* shrink array */
-    luaM_reallocvector(L, t->array, oldasize, nasize, TValue);
-  }
-  /* re-insert elements from hash part */
-  for (i = twoto(oldhsize) - 1; i >= 0; i--) {
-    Node *old = nold+i;
-    if (!ttisnil(gval(old)))
-      setobjt2t(L, luaH_set(L, t, key2tval(old)), gval(old));
-  }
-  if (nold != dummynode)
-    luaM_freearray(L, nold, twoto(oldhsize), Node);  /* free old array */
-}
-
-
-void luaH_resizearray (lua_State *L, Table *t, int nasize) {
-  int nsize = (t->node == dummynode) ? 0 : sizenode(t);
-  resize(L, t, nasize, nsize);
-}
-
-
-static void rehash (lua_State *L, Table *t, const TValue *ek) {
-  int nasize, na;
-  int nums[MAXBITS+1];  /* nums[i] = number of keys between 2^(i-1) and 2^i */
-  int i;
-  int totaluse;
-  for (i=0; i<=MAXBITS; i++) nums[i] = 0;  /* reset counts */
-  nasize = numusearray(t, nums);  /* count keys in array part */
-  totaluse = nasize;  /* all those keys are integer keys */
-  totaluse += numusehash(t, nums, &nasize);  /* count keys in hash part */
-  /* count extra key */
-  nasize += countint(ek, nums);
-  totaluse++;
-  /* compute new size for array part */
-  na = computesizes(nums, &nasize);
-  /* resize the table to new computed sizes */
-  resize(L, t, nasize, totaluse - na);
-}
-
-
-
-/*
-** }=============================================================
-*/
-
-
-Table *luaH_new (lua_State *L, int narray, int nhash) {
-  Table *t = luaM_new(L, Table);
-  luaC_link(L, obj2gco(t), LUA_TTABLE);
-  t->metatable = NULL;
-  t->flags = cast_byte(~0);
-  /* temporary values (kept only if some malloc fails) */
-  t->array = NULL;
-  t->sizearray = 0;
-  t->lsizenode = 0;
-  t->node = cast(Node *, dummynode);
-  setarrayvector(L, t, narray);
-  setnodevector(L, t, nhash);
-  return t;
-}
-
-
-void luaH_free (lua_State *L, Table *t) {
-  if (t->node != dummynode)
-    luaM_freearray(L, t->node, sizenode(t), Node);
-  luaM_freearray(L, t->array, t->sizearray, TValue);
-  luaM_free(L, t);
-}
-
-
-static Node *getfreepos (Table *t) {
-  while (t->lastfree-- > t->node) {
-    if (ttisnil(gkey(t->lastfree)))
-      return t->lastfree;
-  }
-  return NULL;  /* could not find a free place */
-}
-
-
-
-/*
-** inserts a new key into a hash table; first, check whether key's main 
-** position is free. If not, check whether colliding node is in its main 
-** position or not: if it is not, move colliding node to an empty place and 
-** put new key in its main position; otherwise (colliding node is in its main 
-** position), new key goes to an empty position. 
-*/
-static TValue *newkey (lua_State *L, Table *t, const TValue *key) {
-  Node *mp = mainposition(t, key);
-  if (!ttisnil(gval(mp)) || mp == dummynode) {
-    Node *othern;
-    Node *n = getfreepos(t);  /* get a free place */
-    if (n == NULL) {  /* cannot find a free place? */
-      rehash(L, t, key);  /* grow table */
-      return luaH_set(L, t, key);  /* re-insert key into grown table */
-    }
-    lua_assert(n != dummynode);
-    othern = mainposition(t, key2tval(mp));
-    if (othern != mp) {  /* is colliding node out of its main position? */
-      /* yes; move colliding node into free position */
-      while (gnext(othern) != mp) othern = gnext(othern);  /* find previous */
-      gnext(othern) = n;  /* redo the chain with `n' in place of `mp' */
-      *n = *mp;  /* copy colliding node into free pos. (mp->next also goes) */
-      gnext(mp) = NULL;  /* now `mp' is free */
-      setnilvalue(gval(mp));
-    }
-    else {  /* colliding node is in its own main position */
-      /* new node will go into free position */
-      gnext(n) = gnext(mp);  /* chain new position */
-      gnext(mp) = n;
-      mp = n;
-    }
-  }
-  gkey(mp)->value = key->value; gkey(mp)->tt = key->tt;
-  luaC_barriert(L, t, key);
-  lua_assert(ttisnil(gval(mp)));
-  return gval(mp);
-}
-
-
-/*
-** search function for integers
-*/
-const TValue *luaH_getnum (Table *t, int key) {
-  /* (1 <= key && key <= t->sizearray) */
-  if (cast(unsigned int, key-1) < cast(unsigned int, t->sizearray))
-    return &t->array[key-1];
-  else {
-    lua_Number nk = cast_num(key);
-    Node *n = hashnum(t, nk);
-    do {  /* check whether `key' is somewhere in the chain */
-      if (ttisnumber(gkey(n)) && luai_numeq(nvalue(gkey(n)), nk))
-        return gval(n);  /* that's it */
-      else n = gnext(n);
-    } while (n);
-    return luaO_nilobject;
-  }
-}
-
-
-/*
-** search function for strings
-*/
-const TValue *luaH_getstr (Table *t, TString *key) {
-  Node *n = hashstr(t, key);
-  do {  /* check whether `key' is somewhere in the chain */
-    if (ttisstring(gkey(n)) && rawtsvalue(gkey(n)) == key)
-      return gval(n);  /* that's it */
-    else n = gnext(n);
-  } while (n);
-  return luaO_nilobject;
-}
-
-
-/*
-** main search function
-*/
-const TValue *luaH_get (Table *t, const TValue *key) {
-  switch (ttype(key)) {
-    case LUA_TNIL: return luaO_nilobject;
-    case LUA_TSTRING: return luaH_getstr(t, rawtsvalue(key));
-    case LUA_TNUMBER: {
-      int k;
-      lua_Number n = nvalue(key);
-      lua_number2int(k, n);
-      if (luai_numeq(cast_num(k), nvalue(key))) /* index is int? */
-        return luaH_getnum(t, k);  /* use specialized version */
-      /* else go through */
-    }
-    default: {
-      Node *n = mainposition(t, key);
-      do {  /* check whether `key' is somewhere in the chain */
-        if (luaO_rawequalObj(key2tval(n), key))
-          return gval(n);  /* that's it */
-        else n = gnext(n);
-      } while (n);
-      return luaO_nilobject;
-    }
-  }
-}
-
-
-TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
-  const TValue *p = luaH_get(t, key);
-  t->flags = 0;
-  if (p != luaO_nilobject)
-    return cast(TValue *, p);
-  else {
-    if (ttisnil(key)) luaG_runerror(L, "table index is nil");
-    else if (ttisnumber(key) && luai_numisnan(nvalue(key)))
-      luaG_runerror(L, "table index is NaN");
-    return newkey(L, t, key);
-  }
-}
-
-
-TValue *luaH_setnum (lua_State *L, Table *t, int key) {
-  const TValue *p = luaH_getnum(t, key);
-  if (p != luaO_nilobject)
-    return cast(TValue *, p);
-  else {
-    TValue k;
-    setnvalue(&k, cast_num(key));
-    return newkey(L, t, &k);
-  }
-}
-
-
-TValue *luaH_setstr (lua_State *L, Table *t, TString *key) {
-  const TValue *p = luaH_getstr(t, key);
-  if (p != luaO_nilobject)
-    return cast(TValue *, p);
-  else {
-    TValue k;
-    setsvalue(L, &k, key);
-    return newkey(L, t, &k);
-  }
-}
-
-
-static int unbound_search (Table *t, unsigned int j) {
-  unsigned int i = j;  /* i is zero or a present index */
-  j++;
-  /* find `i' and `j' such that i is present and j is not */
-  while (!ttisnil(luaH_getnum(t, j))) {
-    i = j;
-    j *= 2;
-    if (j > cast(unsigned int, MAX_INT)) {  /* overflow? */
-      /* table was built with bad purposes: resort to linear search */
-      i = 1;
-      while (!ttisnil(luaH_getnum(t, i))) i++;
-      return i - 1;
-    }
-  }
-  /* now do a binary search between them */
-  while (j - i > 1) {
-    unsigned int m = (i+j)/2;
-    if (ttisnil(luaH_getnum(t, m))) j = m;
-    else i = m;
-  }
-  return i;
-}
-
-
-/*
-** Try to find a boundary in table `t'. A `boundary' is an integer index
-** such that t[i] is non-nil and t[i+1] is nil (and 0 if t[1] is nil).
-*/
-int luaH_getn (Table *t) {
-  unsigned int j = t->sizearray;
-  if (j > 0 && ttisnil(&t->array[j - 1])) {
-    /* there is a boundary in the array part: (binary) search for it */
-    unsigned int i = 0;
-    while (j - i > 1) {
-      unsigned int m = (i+j)/2;
-      if (ttisnil(&t->array[m - 1])) j = m;
-      else i = m;
-    }
-    return i;
-  }
-  /* else must find a boundary in hash part */
-  else if (t->node == dummynode)  /* hash part is empty? */
-    return j;  /* that is easy... */
-  else return unbound_search(t, j);
-}
-
-
-
-#if defined(LUA_DEBUG)
-
-Node *luaH_mainposition (const Table *t, const TValue *key) {
-  return mainposition(t, key);
-}
-
-int luaH_isdummy (Node *n) { return n == dummynode; }
-
-#endif
diff --git a/extern/lua-5.1.5/src/ltable.h b/extern/lua-5.1.5/src/ltable.h
deleted file mode 100644
index f5b9d5ea..00000000
--- a/extern/lua-5.1.5/src/ltable.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-** $Id: ltable.h,v 2.10.1.1 2007/12/27 13:02:25 roberto Exp $
-** Lua tables (hash)
-** See Copyright Notice in lua.h
-*/
-
-#ifndef ltable_h
-#define ltable_h
-
-#include "lobject.h"
-
-
-#define gnode(t,i)	(&(t)->node[i])
-#define gkey(n)		(&(n)->i_key.nk)
-#define gval(n)		(&(n)->i_val)
-#define gnext(n)	((n)->i_key.nk.next)
-
-#define key2tval(n)	(&(n)->i_key.tvk)
-
-
-LUAI_FUNC const TValue *luaH_getnum (Table *t, int key);
-LUAI_FUNC TValue *luaH_setnum (lua_State *L, Table *t, int key);
-LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key);
-LUAI_FUNC TValue *luaH_setstr (lua_State *L, Table *t, TString *key);
-LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key);
-LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key);
-LUAI_FUNC Table *luaH_new (lua_State *L, int narray, int lnhash);
-LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, int nasize);
-LUAI_FUNC void luaH_free (lua_State *L, Table *t);
-LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key);
-LUAI_FUNC int luaH_getn (Table *t);
-
-
-#if defined(LUA_DEBUG)
-LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key);
-LUAI_FUNC int luaH_isdummy (Node *n);
-#endif
-
-
-#endif
diff --git a/extern/lua-5.1.5/src/ltablib.c b/extern/lua-5.1.5/src/ltablib.c
deleted file mode 100644
index b6d9cb4a..00000000
--- a/extern/lua-5.1.5/src/ltablib.c
+++ /dev/null
@@ -1,287 +0,0 @@
-/*
-** $Id: ltablib.c,v 1.38.1.3 2008/02/14 16:46:58 roberto Exp $
-** Library for Table Manipulation
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stddef.h>
-
-#define ltablib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-#define aux_getn(L,n)	(luaL_checktype(L, n, LUA_TTABLE), luaL_getn(L, n))
-
-
-static int foreachi (lua_State *L) {
-  int i;
-  int n = aux_getn(L, 1);
-  luaL_checktype(L, 2, LUA_TFUNCTION);
-  for (i=1; i <= n; i++) {
-    lua_pushvalue(L, 2);  /* function */
-    lua_pushinteger(L, i);  /* 1st argument */
-    lua_rawgeti(L, 1, i);  /* 2nd argument */
-    lua_call(L, 2, 1);
-    if (!lua_isnil(L, -1))
-      return 1;
-    lua_pop(L, 1);  /* remove nil result */
-  }
-  return 0;
-}
-
-
-static int foreach (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  luaL_checktype(L, 2, LUA_TFUNCTION);
-  lua_pushnil(L);  /* first key */
-  while (lua_next(L, 1)) {
-    lua_pushvalue(L, 2);  /* function */
-    lua_pushvalue(L, -3);  /* key */
-    lua_pushvalue(L, -3);  /* value */
-    lua_call(L, 2, 1);
-    if (!lua_isnil(L, -1))
-      return 1;
-    lua_pop(L, 2);  /* remove value and result */
-  }
-  return 0;
-}
-
-
-static int maxn (lua_State *L) {
-  lua_Number max = 0;
-  luaL_checktype(L, 1, LUA_TTABLE);
-  lua_pushnil(L);  /* first key */
-  while (lua_next(L, 1)) {
-    lua_pop(L, 1);  /* remove value */
-    if (lua_type(L, -1) == LUA_TNUMBER) {
-      lua_Number v = lua_tonumber(L, -1);
-      if (v > max) max = v;
-    }
-  }
-  lua_pushnumber(L, max);
-  return 1;
-}
-
-
-static int getn (lua_State *L) {
-  lua_pushinteger(L, aux_getn(L, 1));
-  return 1;
-}
-
-
-static int setn (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-#ifndef luaL_setn
-  luaL_setn(L, 1, luaL_checkint(L, 2));
-#else
-  luaL_error(L, LUA_QL("setn") " is obsolete");
-#endif
-  lua_pushvalue(L, 1);
-  return 1;
-}
-
-
-static int tinsert (lua_State *L) {
-  int e = aux_getn(L, 1) + 1;  /* first empty element */
-  int pos;  /* where to insert new element */
-  switch (lua_gettop(L)) {
-    case 2: {  /* called with only 2 arguments */
-      pos = e;  /* insert new element at the end */
-      break;
-    }
-    case 3: {
-      int i;
-      pos = luaL_checkint(L, 2);  /* 2nd argument is the position */
-      if (pos > e) e = pos;  /* `grow' array if necessary */
-      for (i = e; i > pos; i--) {  /* move up elements */
-        lua_rawgeti(L, 1, i-1);
-        lua_rawseti(L, 1, i);  /* t[i] = t[i-1] */
-      }
-      break;
-    }
-    default: {
-      return luaL_error(L, "wrong number of arguments to " LUA_QL("insert"));
-    }
-  }
-  luaL_setn(L, 1, e);  /* new size */
-  lua_rawseti(L, 1, pos);  /* t[pos] = v */
-  return 0;
-}
-
-
-static int tremove (lua_State *L) {
-  int e = aux_getn(L, 1);
-  int pos = luaL_optint(L, 2, e);
-  if (!(1 <= pos && pos <= e))  /* position is outside bounds? */
-   return 0;  /* nothing to remove */
-  luaL_setn(L, 1, e - 1);  /* t.n = n-1 */
-  lua_rawgeti(L, 1, pos);  /* result = t[pos] */
-  for ( ;pos<e; pos++) {
-    lua_rawgeti(L, 1, pos+1);
-    lua_rawseti(L, 1, pos);  /* t[pos] = t[pos+1] */
-  }
-  lua_pushnil(L);
-  lua_rawseti(L, 1, e);  /* t[e] = nil */
-  return 1;
-}
-
-
-static void addfield (lua_State *L, luaL_Buffer *b, int i) {
-  lua_rawgeti(L, 1, i);
-  if (!lua_isstring(L, -1))
-    luaL_error(L, "invalid value (%s) at index %d in table for "
-                  LUA_QL("concat"), luaL_typename(L, -1), i);
-    luaL_addvalue(b);
-}
-
-
-static int tconcat (lua_State *L) {
-  luaL_Buffer b;
-  size_t lsep;
-  int i, last;
-  const char *sep = luaL_optlstring(L, 2, "", &lsep);
-  luaL_checktype(L, 1, LUA_TTABLE);
-  i = luaL_optint(L, 3, 1);
-  last = luaL_opt(L, luaL_checkint, 4, luaL_getn(L, 1));
-  luaL_buffinit(L, &b);
-  for (; i < last; i++) {
-    addfield(L, &b, i);
-    luaL_addlstring(&b, sep, lsep);
-  }
-  if (i == last)  /* add last value (if interval was not empty) */
-    addfield(L, &b, i);
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-
-/*
-** {======================================================
-** Quicksort
-** (based on `Algorithms in MODULA-3', Robert Sedgewick;
-**  Addison-Wesley, 1993.)
-*/
-
-
-static void set2 (lua_State *L, int i, int j) {
-  lua_rawseti(L, 1, i);
-  lua_rawseti(L, 1, j);
-}
-
-static int sort_comp (lua_State *L, int a, int b) {
-  if (!lua_isnil(L, 2)) {  /* function? */
-    int res;
-    lua_pushvalue(L, 2);
-    lua_pushvalue(L, a-1);  /* -1 to compensate function */
-    lua_pushvalue(L, b-2);  /* -2 to compensate function and `a' */
-    lua_call(L, 2, 1);
-    res = lua_toboolean(L, -1);
-    lua_pop(L, 1);
-    return res;
-  }
-  else  /* a < b? */
-    return lua_lessthan(L, a, b);
-}
-
-static void auxsort (lua_State *L, int l, int u) {
-  while (l < u) {  /* for tail recursion */
-    int i, j;
-    /* sort elements a[l], a[(l+u)/2] and a[u] */
-    lua_rawgeti(L, 1, l);
-    lua_rawgeti(L, 1, u);
-    if (sort_comp(L, -1, -2))  /* a[u] < a[l]? */
-      set2(L, l, u);  /* swap a[l] - a[u] */
-    else
-      lua_pop(L, 2);
-    if (u-l == 1) break;  /* only 2 elements */
-    i = (l+u)/2;
-    lua_rawgeti(L, 1, i);
-    lua_rawgeti(L, 1, l);
-    if (sort_comp(L, -2, -1))  /* a[i]<a[l]? */
-      set2(L, i, l);
-    else {
-      lua_pop(L, 1);  /* remove a[l] */
-      lua_rawgeti(L, 1, u);
-      if (sort_comp(L, -1, -2))  /* a[u]<a[i]? */
-        set2(L, i, u);
-      else
-        lua_pop(L, 2);
-    }
-    if (u-l == 2) break;  /* only 3 elements */
-    lua_rawgeti(L, 1, i);  /* Pivot */
-    lua_pushvalue(L, -1);
-    lua_rawgeti(L, 1, u-1);
-    set2(L, i, u-1);
-    /* a[l] <= P == a[u-1] <= a[u], only need to sort from l+1 to u-2 */
-    i = l; j = u-1;
-    for (;;) {  /* invariant: a[l..i] <= P <= a[j..u] */
-      /* repeat ++i until a[i] >= P */
-      while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) {
-        if (i>u) luaL_error(L, "invalid order function for sorting");
-        lua_pop(L, 1);  /* remove a[i] */
-      }
-      /* repeat --j until a[j] <= P */
-      while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) {
-        if (j<l) luaL_error(L, "invalid order function for sorting");
-        lua_pop(L, 1);  /* remove a[j] */
-      }
-      if (j<i) {
-        lua_pop(L, 3);  /* pop pivot, a[i], a[j] */
-        break;
-      }
-      set2(L, i, j);
-    }
-    lua_rawgeti(L, 1, u-1);
-    lua_rawgeti(L, 1, i);
-    set2(L, u-1, i);  /* swap pivot (a[u-1]) with a[i] */
-    /* a[l..i-1] <= a[i] == P <= a[i+1..u] */
-    /* adjust so that smaller half is in [j..i] and larger one in [l..u] */
-    if (i-l < u-i) {
-      j=l; i=i-1; l=i+2;
-    }
-    else {
-      j=i+1; i=u; u=j-2;
-    }
-    auxsort(L, j, i);  /* call recursively the smaller one */
-  }  /* repeat the routine for the larger one */
-}
-
-static int sort (lua_State *L) {
-  int n = aux_getn(L, 1);
-  luaL_checkstack(L, 40, "");  /* assume array is smaller than 2^40 */
-  if (!lua_isnoneornil(L, 2))  /* is there a 2nd argument? */
-    luaL_checktype(L, 2, LUA_TFUNCTION);
-  lua_settop(L, 2);  /* make sure there is two arguments */
-  auxsort(L, 1, n);
-  return 0;
-}
-
-/* }====================================================== */
-
-
-static const luaL_Reg tab_funcs[] = {
-  {"concat", tconcat},
-  {"foreach", foreach},
-  {"foreachi", foreachi},
-  {"getn", getn},
-  {"maxn", maxn},
-  {"insert", tinsert},
-  {"remove", tremove},
-  {"setn", setn},
-  {"sort", sort},
-  {NULL, NULL}
-};
-
-
-LUALIB_API int luaopen_table (lua_State *L) {
-  luaL_register(L, LUA_TABLIBNAME, tab_funcs);
-  return 1;
-}
-
diff --git a/extern/lua-5.1.5/src/ltm.c b/extern/lua-5.1.5/src/ltm.c
deleted file mode 100644
index c27f0f6f..00000000
--- a/extern/lua-5.1.5/src/ltm.c
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
-** $Id: ltm.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
-** Tag methods
-** See Copyright Notice in lua.h
-*/
-
-
-#include <string.h>
-
-#define ltm_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-
-
-
-const char *const luaT_typenames[] = {
-  "nil", "boolean", "userdata", "number",
-  "string", "table", "function", "userdata", "thread",
-  "proto", "upval"
-};
-
-
-void luaT_init (lua_State *L) {
-  static const char *const luaT_eventname[] = {  /* ORDER TM */
-    "__index", "__newindex",
-    "__gc", "__mode", "__eq",
-    "__add", "__sub", "__mul", "__div", "__mod",
-    "__pow", "__unm", "__len", "__lt", "__le",
-    "__concat", "__call"
-  };
-  int i;
-  for (i=0; i<TM_N; i++) {
-    G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
-    luaS_fix(G(L)->tmname[i]);  /* never collect these names */
-  }
-}
-
-
-/*
-** function to be used with macro "fasttm": optimized for absence of
-** tag methods
-*/
-const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
-  const TValue *tm = luaH_getstr(events, ename);
-  lua_assert(event <= TM_EQ);
-  if (ttisnil(tm)) {  /* no tag method? */
-    events->flags |= cast_byte(1u<<event);  /* cache this fact */
-    return NULL;
-  }
-  else return tm;
-}
-
-
-const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
-  Table *mt;
-  switch (ttype(o)) {
-    case LUA_TTABLE:
-      mt = hvalue(o)->metatable;
-      break;
-    case LUA_TUSERDATA:
-      mt = uvalue(o)->metatable;
-      break;
-    default:
-      mt = G(L)->mt[ttype(o)];
-  }
-  return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject);
-}
-
diff --git a/extern/lua-5.1.5/src/ltm.h b/extern/lua-5.1.5/src/ltm.h
deleted file mode 100644
index 64343b78..00000000
--- a/extern/lua-5.1.5/src/ltm.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-** $Id: ltm.h,v 2.6.1.1 2007/12/27 13:02:25 roberto Exp $
-** Tag methods
-** See Copyright Notice in lua.h
-*/
-
-#ifndef ltm_h
-#define ltm_h
-
-
-#include "lobject.h"
-
-
-/*
-* WARNING: if you change the order of this enumeration,
-* grep "ORDER TM"
-*/
-typedef enum {
-  TM_INDEX,
-  TM_NEWINDEX,
-  TM_GC,
-  TM_MODE,
-  TM_EQ,  /* last tag method with `fast' access */
-  TM_ADD,
-  TM_SUB,
-  TM_MUL,
-  TM_DIV,
-  TM_MOD,
-  TM_POW,
-  TM_UNM,
-  TM_LEN,
-  TM_LT,
-  TM_LE,
-  TM_CONCAT,
-  TM_CALL,
-  TM_N		/* number of elements in the enum */
-} TMS;
-
-
-
-#define gfasttm(g,et,e) ((et) == NULL ? NULL : \
-  ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))
-
-#define fasttm(l,et,e)	gfasttm(G(l), et, e)
-
-LUAI_DATA const char *const luaT_typenames[];
-
-
-LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename);
-LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o,
-                                                       TMS event);
-LUAI_FUNC void luaT_init (lua_State *L);
-
-#endif
diff --git a/extern/lua-5.1.5/src/lua.c b/extern/lua-5.1.5/src/lua.c
deleted file mode 100644
index 3a466093..00000000
--- a/extern/lua-5.1.5/src/lua.c
+++ /dev/null
@@ -1,392 +0,0 @@
-/*
-** $Id: lua.c,v 1.160.1.2 2007/12/28 15:32:23 roberto Exp $
-** Lua stand-alone interpreter
-** See Copyright Notice in lua.h
-*/
-
-
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define lua_c
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-
-static lua_State *globalL = NULL;
-
-static const char *progname = LUA_PROGNAME;
-
-
-
-static void lstop (lua_State *L, lua_Debug *ar) {
-  (void)ar;  /* unused arg. */
-  lua_sethook(L, NULL, 0, 0);
-  luaL_error(L, "interrupted!");
-}
-
-
-static void laction (int i) {
-  signal(i, SIG_DFL); /* if another SIGINT happens before lstop,
-                              terminate process (default action) */
-  lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);
-}
-
-
-static void print_usage (void) {
-  fprintf(stderr,
-  "usage: %s [options] [script [args]].\n"
-  "Available options are:\n"
-  "  -e stat  execute string " LUA_QL("stat") "\n"
-  "  -l name  require library " LUA_QL("name") "\n"
-  "  -i       enter interactive mode after executing " LUA_QL("script") "\n"
-  "  -v       show version information\n"
-  "  --       stop handling options\n"
-  "  -        execute stdin and stop handling options\n"
-  ,
-  progname);
-  fflush(stderr);
-}
-
-
-static void l_message (const char *pname, const char *msg) {
-  if (pname) fprintf(stderr, "%s: ", pname);
-  fprintf(stderr, "%s\n", msg);
-  fflush(stderr);
-}
-
-
-static int report (lua_State *L, int status) {
-  if (status && !lua_isnil(L, -1)) {
-    const char *msg = lua_tostring(L, -1);
-    if (msg == NULL) msg = "(error object is not a string)";
-    l_message(progname, msg);
-    lua_pop(L, 1);
-  }
-  return status;
-}
-
-
-static int traceback (lua_State *L) {
-  if (!lua_isstring(L, 1))  /* 'message' not a string? */
-    return 1;  /* keep it intact */
-  lua_getfield(L, LUA_GLOBALSINDEX, "debug");
-  if (!lua_istable(L, -1)) {
-    lua_pop(L, 1);
-    return 1;
-  }
-  lua_getfield(L, -1, "traceback");
-  if (!lua_isfunction(L, -1)) {
-    lua_pop(L, 2);
-    return 1;
-  }
-  lua_pushvalue(L, 1);  /* pass error message */
-  lua_pushinteger(L, 2);  /* skip this function and traceback */
-  lua_call(L, 2, 1);  /* call debug.traceback */
-  return 1;
-}
-
-
-static int docall (lua_State *L, int narg, int clear) {
-  int status;
-  int base = lua_gettop(L) - narg;  /* function index */
-  lua_pushcfunction(L, traceback);  /* push traceback function */
-  lua_insert(L, base);  /* put it under chunk and args */
-  signal(SIGINT, laction);
-  status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);
-  signal(SIGINT, SIG_DFL);
-  lua_remove(L, base);  /* remove traceback function */
-  /* force a complete garbage collection in case of errors */
-  if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0);
-  return status;
-}
-
-
-static void print_version (void) {
-  l_message(NULL, LUA_RELEASE "  " LUA_COPYRIGHT);
-}
-
-
-static int getargs (lua_State *L, char **argv, int n) {
-  int narg;
-  int i;
-  int argc = 0;
-  while (argv[argc]) argc++;  /* count total number of arguments */
-  narg = argc - (n + 1);  /* number of arguments to the script */
-  luaL_checkstack(L, narg + 3, "too many arguments to script");
-  for (i=n+1; i < argc; i++)
-    lua_pushstring(L, argv[i]);
-  lua_createtable(L, narg, n + 1);
-  for (i=0; i < argc; i++) {
-    lua_pushstring(L, argv[i]);
-    lua_rawseti(L, -2, i - n);
-  }
-  return narg;
-}
-
-
-static int dofile (lua_State *L, const char *name) {
-  int status = luaL_loadfile(L, name) || docall(L, 0, 1);
-  return report(L, status);
-}
-
-
-static int dostring (lua_State *L, const char *s, const char *name) {
-  int status = luaL_loadbuffer(L, s, strlen(s), name) || docall(L, 0, 1);
-  return report(L, status);
-}
-
-
-static int dolibrary (lua_State *L, const char *name) {
-  lua_getglobal(L, "require");
-  lua_pushstring(L, name);
-  return report(L, docall(L, 1, 1));
-}
-
-
-static const char *get_prompt (lua_State *L, int firstline) {
-  const char *p;
-  lua_getfield(L, LUA_GLOBALSINDEX, firstline ? "_PROMPT" : "_PROMPT2");
-  p = lua_tostring(L, -1);
-  if (p == NULL) p = (firstline ? LUA_PROMPT : LUA_PROMPT2);
-  lua_pop(L, 1);  /* remove global */
-  return p;
-}
-
-
-static int incomplete (lua_State *L, int status) {
-  if (status == LUA_ERRSYNTAX) {
-    size_t lmsg;
-    const char *msg = lua_tolstring(L, -1, &lmsg);
-    const char *tp = msg + lmsg - (sizeof(LUA_QL("<eof>")) - 1);
-    if (strstr(msg, LUA_QL("<eof>")) == tp) {
-      lua_pop(L, 1);
-      return 1;
-    }
-  }
-  return 0;  /* else... */
-}
-
-
-static int pushline (lua_State *L, int firstline) {
-  char buffer[LUA_MAXINPUT];
-  char *b = buffer;
-  size_t l;
-  const char *prmt = get_prompt(L, firstline);
-  if (lua_readline(L, b, prmt) == 0)
-    return 0;  /* no input */
-  l = strlen(b);
-  if (l > 0 && b[l-1] == '\n')  /* line ends with newline? */
-    b[l-1] = '\0';  /* remove it */
-  if (firstline && b[0] == '=')  /* first line starts with `=' ? */
-    lua_pushfstring(L, "return %s", b+1);  /* change it to `return' */
-  else
-    lua_pushstring(L, b);
-  lua_freeline(L, b);
-  return 1;
-}
-
-
-static int loadline (lua_State *L) {
-  int status;
-  lua_settop(L, 0);
-  if (!pushline(L, 1))
-    return -1;  /* no input */
-  for (;;) {  /* repeat until gets a complete line */
-    status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");
-    if (!incomplete(L, status)) break;  /* cannot try to add lines? */
-    if (!pushline(L, 0))  /* no more input? */
-      return -1;
-    lua_pushliteral(L, "\n");  /* add a new line... */
-    lua_insert(L, -2);  /* ...between the two lines */
-    lua_concat(L, 3);  /* join them */
-  }
-  lua_saveline(L, 1);
-  lua_remove(L, 1);  /* remove line */
-  return status;
-}
-
-
-static void dotty (lua_State *L) {
-  int status;
-  const char *oldprogname = progname;
-  progname = NULL;
-  while ((status = loadline(L)) != -1) {
-    if (status == 0) status = docall(L, 0, 0);
-    report(L, status);
-    if (status == 0 && lua_gettop(L) > 0) {  /* any result to print? */
-      lua_getglobal(L, "print");
-      lua_insert(L, 1);
-      if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0)
-        l_message(progname, lua_pushfstring(L,
-                               "error calling " LUA_QL("print") " (%s)",
-                               lua_tostring(L, -1)));
-    }
-  }
-  lua_settop(L, 0);  /* clear stack */
-  fputs("\n", stdout);
-  fflush(stdout);
-  progname = oldprogname;
-}
-
-
-static int handle_script (lua_State *L, char **argv, int n) {
-  int status;
-  const char *fname;
-  int narg = getargs(L, argv, n);  /* collect arguments */
-  lua_setglobal(L, "arg");
-  fname = argv[n];
-  if (strcmp(fname, "-") == 0 && strcmp(argv[n-1], "--") != 0) 
-    fname = NULL;  /* stdin */
-  status = luaL_loadfile(L, fname);
-  lua_insert(L, -(narg+1));
-  if (status == 0)
-    status = docall(L, narg, 0);
-  else
-    lua_pop(L, narg);      
-  return report(L, status);
-}
-
-
-/* check that argument has no extra characters at the end */
-#define notail(x)	{if ((x)[2] != '\0') return -1;}
-
-
-static int collectargs (char **argv, int *pi, int *pv, int *pe) {
-  int i;
-  for (i = 1; argv[i] != NULL; i++) {
-    if (argv[i][0] != '-')  /* not an option? */
-        return i;
-    switch (argv[i][1]) {  /* option */
-      case '-':
-        notail(argv[i]);
-        return (argv[i+1] != NULL ? i+1 : 0);
-      case '\0':
-        return i;
-      case 'i':
-        notail(argv[i]);
-        *pi = 1;  /* go through */
-      case 'v':
-        notail(argv[i]);
-        *pv = 1;
-        break;
-      case 'e':
-        *pe = 1;  /* go through */
-      case 'l':
-        if (argv[i][2] == '\0') {
-          i++;
-          if (argv[i] == NULL) return -1;
-        }
-        break;
-      default: return -1;  /* invalid option */
-    }
-  }
-  return 0;
-}
-
-
-static int runargs (lua_State *L, char **argv, int n) {
-  int i;
-  for (i = 1; i < n; i++) {
-    if (argv[i] == NULL) continue;
-    lua_assert(argv[i][0] == '-');
-    switch (argv[i][1]) {  /* option */
-      case 'e': {
-        const char *chunk = argv[i] + 2;
-        if (*chunk == '\0') chunk = argv[++i];
-        lua_assert(chunk != NULL);
-        if (dostring(L, chunk, "=(command line)") != 0)
-          return 1;
-        break;
-      }
-      case 'l': {
-        const char *filename = argv[i] + 2;
-        if (*filename == '\0') filename = argv[++i];
-        lua_assert(filename != NULL);
-        if (dolibrary(L, filename))
-          return 1;  /* stop if file fails */
-        break;
-      }
-      default: break;
-    }
-  }
-  return 0;
-}
-
-
-static int handle_luainit (lua_State *L) {
-  const char *init = getenv(LUA_INIT);
-  if (init == NULL) return 0;  /* status OK */
-  else if (init[0] == '@')
-    return dofile(L, init+1);
-  else
-    return dostring(L, init, "=" LUA_INIT);
-}
-
-
-struct Smain {
-  int argc;
-  char **argv;
-  int status;
-};
-
-
-static int pmain (lua_State *L) {
-  struct Smain *s = (struct Smain *)lua_touserdata(L, 1);
-  char **argv = s->argv;
-  int script;
-  int has_i = 0, has_v = 0, has_e = 0;
-  globalL = L;
-  if (argv[0] && argv[0][0]) progname = argv[0];
-  lua_gc(L, LUA_GCSTOP, 0);  /* stop collector during initialization */
-  luaL_openlibs(L);  /* open libraries */
-  lua_gc(L, LUA_GCRESTART, 0);
-  s->status = handle_luainit(L);
-  if (s->status != 0) return 0;
-  script = collectargs(argv, &has_i, &has_v, &has_e);
-  if (script < 0) {  /* invalid args? */
-    print_usage();
-    s->status = 1;
-    return 0;
-  }
-  if (has_v) print_version();
-  s->status = runargs(L, argv, (script > 0) ? script : s->argc);
-  if (s->status != 0) return 0;
-  if (script)
-    s->status = handle_script(L, argv, script);
-  if (s->status != 0) return 0;
-  if (has_i)
-    dotty(L);
-  else if (script == 0 && !has_e && !has_v) {
-    if (lua_stdin_is_tty()) {
-      print_version();
-      dotty(L);
-    }
-    else dofile(L, NULL);  /* executes stdin as a file */
-  }
-  return 0;
-}
-
-
-int main (int argc, char **argv) {
-  int status;
-  struct Smain s;
-  lua_State *L = lua_open();  /* create state */
-  if (L == NULL) {
-    l_message(argv[0], "cannot create state: not enough memory");
-    return EXIT_FAILURE;
-  }
-  s.argc = argc;
-  s.argv = argv;
-  status = lua_cpcall(L, &pmain, &s);
-  report(L, status);
-  lua_close(L);
-  return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS;
-}
-
diff --git a/extern/lua-5.1.5/src/lua.h b/extern/lua-5.1.5/src/lua.h
deleted file mode 100644
index a4b73e74..00000000
--- a/extern/lua-5.1.5/src/lua.h
+++ /dev/null
@@ -1,388 +0,0 @@
-/*
-** $Id: lua.h,v 1.218.1.7 2012/01/13 20:36:20 roberto Exp $
-** Lua - An Extensible Extension Language
-** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
-** See Copyright Notice at the end of this file
-*/
-
-
-#ifndef lua_h
-#define lua_h
-
-#include <stdarg.h>
-#include <stddef.h>
-
-
-#include "luaconf.h"
-
-
-#define LUA_VERSION	"Lua 5.1"
-#define LUA_RELEASE	"Lua 5.1.5"
-#define LUA_VERSION_NUM	501
-#define LUA_COPYRIGHT	"Copyright (C) 1994-2012 Lua.org, PUC-Rio"
-#define LUA_AUTHORS 	"R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
-
-
-/* mark for precompiled code (`<esc>Lua') */
-#define	LUA_SIGNATURE	"\033Lua"
-
-/* option for multiple returns in `lua_pcall' and `lua_call' */
-#define LUA_MULTRET	(-1)
-
-
-/*
-** pseudo-indices
-*/
-#define LUA_REGISTRYINDEX	(-10000)
-#define LUA_ENVIRONINDEX	(-10001)
-#define LUA_GLOBALSINDEX	(-10002)
-#define lua_upvalueindex(i)	(LUA_GLOBALSINDEX-(i))
-
-
-/* thread status; 0 is OK */
-#define LUA_YIELD	1
-#define LUA_ERRRUN	2
-#define LUA_ERRSYNTAX	3
-#define LUA_ERRMEM	4
-#define LUA_ERRERR	5
-
-
-typedef struct lua_State lua_State;
-
-typedef int (*lua_CFunction) (lua_State *L);
-
-
-/*
-** functions that read/write blocks when loading/dumping Lua chunks
-*/
-typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
-
-typedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud);
-
-
-/*
-** prototype for memory-allocation functions
-*/
-typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
-
-
-/*
-** basic types
-*/
-#define LUA_TNONE		(-1)
-
-#define LUA_TNIL		0
-#define LUA_TBOOLEAN		1
-#define LUA_TLIGHTUSERDATA	2
-#define LUA_TNUMBER		3
-#define LUA_TSTRING		4
-#define LUA_TTABLE		5
-#define LUA_TFUNCTION		6
-#define LUA_TUSERDATA		7
-#define LUA_TTHREAD		8
-
-
-
-/* minimum Lua stack available to a C function */
-#define LUA_MINSTACK	20
-
-
-/*
-** generic extra include file
-*/
-#if defined(LUA_USER_H)
-#include LUA_USER_H
-#endif
-
-
-/* type of numbers in Lua */
-typedef LUA_NUMBER lua_Number;
-
-
-/* type for integer functions */
-typedef LUA_INTEGER lua_Integer;
-
-
-
-/*
-** state manipulation
-*/
-LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
-LUA_API void       (lua_close) (lua_State *L);
-LUA_API lua_State *(lua_newthread) (lua_State *L);
-
-LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
-
-
-/*
-** basic stack manipulation
-*/
-LUA_API int   (lua_gettop) (lua_State *L);
-LUA_API void  (lua_settop) (lua_State *L, int idx);
-LUA_API void  (lua_pushvalue) (lua_State *L, int idx);
-LUA_API void  (lua_remove) (lua_State *L, int idx);
-LUA_API void  (lua_insert) (lua_State *L, int idx);
-LUA_API void  (lua_replace) (lua_State *L, int idx);
-LUA_API int   (lua_checkstack) (lua_State *L, int sz);
-
-LUA_API void  (lua_xmove) (lua_State *from, lua_State *to, int n);
-
-
-/*
-** access functions (stack -> C)
-*/
-
-LUA_API int             (lua_isnumber) (lua_State *L, int idx);
-LUA_API int             (lua_isstring) (lua_State *L, int idx);
-LUA_API int             (lua_iscfunction) (lua_State *L, int idx);
-LUA_API int             (lua_isuserdata) (lua_State *L, int idx);
-LUA_API int             (lua_type) (lua_State *L, int idx);
-LUA_API const char     *(lua_typename) (lua_State *L, int tp);
-
-LUA_API int            (lua_equal) (lua_State *L, int idx1, int idx2);
-LUA_API int            (lua_rawequal) (lua_State *L, int idx1, int idx2);
-LUA_API int            (lua_lessthan) (lua_State *L, int idx1, int idx2);
-
-LUA_API lua_Number      (lua_tonumber) (lua_State *L, int idx);
-LUA_API lua_Integer     (lua_tointeger) (lua_State *L, int idx);
-LUA_API int             (lua_toboolean) (lua_State *L, int idx);
-LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
-LUA_API size_t          (lua_objlen) (lua_State *L, int idx);
-LUA_API lua_CFunction   (lua_tocfunction) (lua_State *L, int idx);
-LUA_API void	       *(lua_touserdata) (lua_State *L, int idx);
-LUA_API lua_State      *(lua_tothread) (lua_State *L, int idx);
-LUA_API const void     *(lua_topointer) (lua_State *L, int idx);
-
-
-/*
-** push functions (C -> stack)
-*/
-LUA_API void  (lua_pushnil) (lua_State *L);
-LUA_API void  (lua_pushnumber) (lua_State *L, lua_Number n);
-LUA_API void  (lua_pushinteger) (lua_State *L, lua_Integer n);
-LUA_API void  (lua_pushlstring) (lua_State *L, const char *s, size_t l);
-LUA_API void  (lua_pushstring) (lua_State *L, const char *s);
-LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
-                                                      va_list argp);
-LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
-LUA_API void  (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
-LUA_API void  (lua_pushboolean) (lua_State *L, int b);
-LUA_API void  (lua_pushlightuserdata) (lua_State *L, void *p);
-LUA_API int   (lua_pushthread) (lua_State *L);
-
-
-/*
-** get functions (Lua -> stack)
-*/
-LUA_API void  (lua_gettable) (lua_State *L, int idx);
-LUA_API void  (lua_getfield) (lua_State *L, int idx, const char *k);
-LUA_API void  (lua_rawget) (lua_State *L, int idx);
-LUA_API void  (lua_rawgeti) (lua_State *L, int idx, int n);
-LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
-LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
-LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
-LUA_API void  (lua_getfenv) (lua_State *L, int idx);
-
-
-/*
-** set functions (stack -> Lua)
-*/
-LUA_API void  (lua_settable) (lua_State *L, int idx);
-LUA_API void  (lua_setfield) (lua_State *L, int idx, const char *k);
-LUA_API void  (lua_rawset) (lua_State *L, int idx);
-LUA_API void  (lua_rawseti) (lua_State *L, int idx, int n);
-LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
-LUA_API int   (lua_setfenv) (lua_State *L, int idx);
-
-
-/*
-** `load' and `call' functions (load and run Lua code)
-*/
-LUA_API void  (lua_call) (lua_State *L, int nargs, int nresults);
-LUA_API int   (lua_pcall) (lua_State *L, int nargs, int nresults, int errfunc);
-LUA_API int   (lua_cpcall) (lua_State *L, lua_CFunction func, void *ud);
-LUA_API int   (lua_load) (lua_State *L, lua_Reader reader, void *dt,
-                                        const char *chunkname);
-
-LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);
-
-
-/*
-** coroutine functions
-*/
-LUA_API int  (lua_yield) (lua_State *L, int nresults);
-LUA_API int  (lua_resume) (lua_State *L, int narg);
-LUA_API int  (lua_status) (lua_State *L);
-
-/*
-** garbage-collection function and options
-*/
-
-#define LUA_GCSTOP		0
-#define LUA_GCRESTART		1
-#define LUA_GCCOLLECT		2
-#define LUA_GCCOUNT		3
-#define LUA_GCCOUNTB		4
-#define LUA_GCSTEP		5
-#define LUA_GCSETPAUSE		6
-#define LUA_GCSETSTEPMUL	7
-
-LUA_API int (lua_gc) (lua_State *L, int what, int data);
-
-
-/*
-** miscellaneous functions
-*/
-
-LUA_API int   (lua_error) (lua_State *L);
-
-LUA_API int   (lua_next) (lua_State *L, int idx);
-
-LUA_API void  (lua_concat) (lua_State *L, int n);
-
-LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
-LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);
-
-
-
-/* 
-** ===============================================================
-** some useful macros
-** ===============================================================
-*/
-
-#define lua_pop(L,n)		lua_settop(L, -(n)-1)
-
-#define lua_newtable(L)		lua_createtable(L, 0, 0)
-
-#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
-
-#define lua_pushcfunction(L,f)	lua_pushcclosure(L, (f), 0)
-
-#define lua_strlen(L,i)		lua_objlen(L, (i))
-
-#define lua_isfunction(L,n)	(lua_type(L, (n)) == LUA_TFUNCTION)
-#define lua_istable(L,n)	(lua_type(L, (n)) == LUA_TTABLE)
-#define lua_islightuserdata(L,n)	(lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
-#define lua_isnil(L,n)		(lua_type(L, (n)) == LUA_TNIL)
-#define lua_isboolean(L,n)	(lua_type(L, (n)) == LUA_TBOOLEAN)
-#define lua_isthread(L,n)	(lua_type(L, (n)) == LUA_TTHREAD)
-#define lua_isnone(L,n)		(lua_type(L, (n)) == LUA_TNONE)
-#define lua_isnoneornil(L, n)	(lua_type(L, (n)) <= 0)
-
-#define lua_pushliteral(L, s)	\
-	lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
-
-#define lua_setglobal(L,s)	lua_setfield(L, LUA_GLOBALSINDEX, (s))
-#define lua_getglobal(L,s)	lua_getfield(L, LUA_GLOBALSINDEX, (s))
-
-#define lua_tostring(L,i)	lua_tolstring(L, (i), NULL)
-
-
-
-/*
-** compatibility macros and functions
-*/
-
-#define lua_open()	luaL_newstate()
-
-#define lua_getregistry(L)	lua_pushvalue(L, LUA_REGISTRYINDEX)
-
-#define lua_getgccount(L)	lua_gc(L, LUA_GCCOUNT, 0)
-
-#define lua_Chunkreader		lua_Reader
-#define lua_Chunkwriter		lua_Writer
-
-
-/* hack */
-LUA_API void lua_setlevel	(lua_State *from, lua_State *to);
-
-
-/*
-** {======================================================================
-** Debug API
-** =======================================================================
-*/
-
-
-/*
-** Event codes
-*/
-#define LUA_HOOKCALL	0
-#define LUA_HOOKRET	1
-#define LUA_HOOKLINE	2
-#define LUA_HOOKCOUNT	3
-#define LUA_HOOKTAILRET 4
-
-
-/*
-** Event masks
-*/
-#define LUA_MASKCALL	(1 << LUA_HOOKCALL)
-#define LUA_MASKRET	(1 << LUA_HOOKRET)
-#define LUA_MASKLINE	(1 << LUA_HOOKLINE)
-#define LUA_MASKCOUNT	(1 << LUA_HOOKCOUNT)
-
-typedef struct lua_Debug lua_Debug;  /* activation record */
-
-
-/* Functions to be called by the debuger in specific events */
-typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
-
-
-LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar);
-LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
-LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);
-LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);
-LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n);
-LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n);
-
-LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count);
-LUA_API lua_Hook lua_gethook (lua_State *L);
-LUA_API int lua_gethookmask (lua_State *L);
-LUA_API int lua_gethookcount (lua_State *L);
-
-
-struct lua_Debug {
-  int event;
-  const char *name;	/* (n) */
-  const char *namewhat;	/* (n) `global', `local', `field', `method' */
-  const char *what;	/* (S) `Lua', `C', `main', `tail' */
-  const char *source;	/* (S) */
-  int currentline;	/* (l) */
-  int nups;		/* (u) number of upvalues */
-  int linedefined;	/* (S) */
-  int lastlinedefined;	/* (S) */
-  char short_src[LUA_IDSIZE]; /* (S) */
-  /* private part */
-  int i_ci;  /* active function */
-};
-
-/* }====================================================================== */
-
-
-/******************************************************************************
-* Copyright (C) 1994-2012 Lua.org, PUC-Rio.  All rights reserved.
-*
-* Permission is hereby granted, free of charge, to any person obtaining
-* a copy of this software and associated documentation files (the
-* "Software"), to deal in the Software without restriction, including
-* without limitation the rights to use, copy, modify, merge, publish,
-* distribute, sublicense, and/or sell copies of the Software, and to
-* permit persons to whom the Software is furnished to do so, subject to
-* the following conditions:
-*
-* The above copyright notice and this permission notice shall be
-* included in all copies or substantial portions of the Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-******************************************************************************/
-
-
-#endif
diff --git a/extern/lua-5.1.5/src/luac.c b/extern/lua-5.1.5/src/luac.c
deleted file mode 100644
index d0701739..00000000
--- a/extern/lua-5.1.5/src/luac.c
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
-** $Id: luac.c,v 1.54 2006/06/02 17:37:11 lhf Exp $
-** Lua compiler (saves bytecodes to files; also list bytecodes)
-** See Copyright Notice in lua.h
-*/
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define luac_c
-#define LUA_CORE
-
-#include "lua.h"
-#include "lauxlib.h"
-
-#include "ldo.h"
-#include "lfunc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lstring.h"
-#include "lundump.h"
-
-#define PROGNAME	"luac"		/* default program name */
-#define	OUTPUT		PROGNAME ".out"	/* default output file */
-
-static int listing=0;			/* list bytecodes? */
-static int dumping=1;			/* dump bytecodes? */
-static int stripping=0;			/* strip debug information? */
-static char Output[]={ OUTPUT };	/* default output file name */
-static const char* output=Output;	/* actual output file name */
-static const char* progname=PROGNAME;	/* actual program name */
-
-static void fatal(const char* message)
-{
- fprintf(stderr,"%s: %s\n",progname,message);
- exit(EXIT_FAILURE);
-}
-
-static void cannot(const char* what)
-{
- fprintf(stderr,"%s: cannot %s %s: %s\n",progname,what,output,strerror(errno));
- exit(EXIT_FAILURE);
-}
-
-static void usage(const char* message)
-{
- if (*message=='-')
-  fprintf(stderr,"%s: unrecognized option " LUA_QS "\n",progname,message);
- else
-  fprintf(stderr,"%s: %s\n",progname,message);
- fprintf(stderr,
- "usage: %s [options] [filenames].\n"
- "Available options are:\n"
- "  -        process stdin\n"
- "  -l       list\n"
- "  -o name  output to file " LUA_QL("name") " (default is \"%s\")\n"
- "  -p       parse only\n"
- "  -s       strip debug information\n"
- "  -v       show version information\n"
- "  --       stop handling options\n",
- progname,Output);
- exit(EXIT_FAILURE);
-}
-
-#define	IS(s)	(strcmp(argv[i],s)==0)
-
-static int doargs(int argc, char* argv[])
-{
- int i;
- int version=0;
- if (argv[0]!=NULL && *argv[0]!=0) progname=argv[0];
- for (i=1; i<argc; i++)
- {
-  if (*argv[i]!='-')			/* end of options; keep it */
-   break;
-  else if (IS("--"))			/* end of options; skip it */
-  {
-   ++i;
-   if (version) ++version;
-   break;
-  }
-  else if (IS("-"))			/* end of options; use stdin */
-   break;
-  else if (IS("-l"))			/* list */
-   ++listing;
-  else if (IS("-o"))			/* output file */
-  {
-   output=argv[++i];
-   if (output==NULL || *output==0) usage(LUA_QL("-o") " needs argument");
-   if (IS("-")) output=NULL;
-  }
-  else if (IS("-p"))			/* parse only */
-   dumping=0;
-  else if (IS("-s"))			/* strip debug information */
-   stripping=1;
-  else if (IS("-v"))			/* show version */
-   ++version;
-  else					/* unknown option */
-   usage(argv[i]);
- }
- if (i==argc && (listing || !dumping))
- {
-  dumping=0;
-  argv[--i]=Output;
- }
- if (version)
- {
-  printf("%s  %s\n",LUA_RELEASE,LUA_COPYRIGHT);
-  if (version==argc-1) exit(EXIT_SUCCESS);
- }
- return i;
-}
-
-#define toproto(L,i) (clvalue(L->top+(i))->l.p)
-
-static const Proto* combine(lua_State* L, int n)
-{
- if (n==1)
-  return toproto(L,-1);
- else
- {
-  int i,pc;
-  Proto* f=luaF_newproto(L);
-  setptvalue2s(L,L->top,f); incr_top(L);
-  f->source=luaS_newliteral(L,"=(" PROGNAME ")");
-  f->maxstacksize=1;
-  pc=2*n+1;
-  f->code=luaM_newvector(L,pc,Instruction);
-  f->sizecode=pc;
-  f->p=luaM_newvector(L,n,Proto*);
-  f->sizep=n;
-  pc=0;
-  for (i=0; i<n; i++)
-  {
-   f->p[i]=toproto(L,i-n-1);
-   f->code[pc++]=CREATE_ABx(OP_CLOSURE,0,i);
-   f->code[pc++]=CREATE_ABC(OP_CALL,0,1,1);
-  }
-  f->code[pc++]=CREATE_ABC(OP_RETURN,0,1,0);
-  return f;
- }
-}
-
-static int writer(lua_State* L, const void* p, size_t size, void* u)
-{
- UNUSED(L);
- return (fwrite(p,size,1,(FILE*)u)!=1) && (size!=0);
-}
-
-struct Smain {
- int argc;
- char** argv;
-};
-
-static int pmain(lua_State* L)
-{
- struct Smain* s = (struct Smain*)lua_touserdata(L, 1);
- int argc=s->argc;
- char** argv=s->argv;
- const Proto* f;
- int i;
- if (!lua_checkstack(L,argc)) fatal("too many input files");
- for (i=0; i<argc; i++)
- {
-  const char* filename=IS("-") ? NULL : argv[i];
-  if (luaL_loadfile(L,filename)!=0) fatal(lua_tostring(L,-1));
- }
- f=combine(L,argc);
- if (listing) luaU_print(f,listing>1);
- if (dumping)
- {
-  FILE* D= (output==NULL) ? stdout : fopen(output,"wb");
-  if (D==NULL) cannot("open");
-  lua_lock(L);
-  luaU_dump(L,f,writer,D,stripping);
-  lua_unlock(L);
-  if (ferror(D)) cannot("write");
-  if (fclose(D)) cannot("close");
- }
- return 0;
-}
-
-int main(int argc, char* argv[])
-{
- lua_State* L;
- struct Smain s;
- int i=doargs(argc,argv);
- argc-=i; argv+=i;
- if (argc<=0) usage("no input files given");
- L=lua_open();
- if (L==NULL) fatal("not enough memory for state");
- s.argc=argc;
- s.argv=argv;
- if (lua_cpcall(L,pmain,&s)!=0) fatal(lua_tostring(L,-1));
- lua_close(L);
- return EXIT_SUCCESS;
-}
diff --git a/extern/lua-5.1.5/src/luaconf.h b/extern/lua-5.1.5/src/luaconf.h
deleted file mode 100644
index e2cb2616..00000000
--- a/extern/lua-5.1.5/src/luaconf.h
+++ /dev/null
@@ -1,763 +0,0 @@
-/*
-** $Id: luaconf.h,v 1.82.1.7 2008/02/11 16:25:08 roberto Exp $
-** Configuration file for Lua
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef lconfig_h
-#define lconfig_h
-
-#include <limits.h>
-#include <stddef.h>
-
-
-/*
-** ==================================================================
-** Search for "@@" to find all configurable definitions.
-** ===================================================================
-*/
-
-
-/*
-@@ LUA_ANSI controls the use of non-ansi features.
-** CHANGE it (define it) if you want Lua to avoid the use of any
-** non-ansi feature or library.
-*/
-#if defined(__STRICT_ANSI__)
-#define LUA_ANSI
-#endif
-
-
-#if !defined(LUA_ANSI) && defined(_WIN32)
-#define LUA_WIN
-#endif
-
-#if defined(LUA_USE_LINUX)
-#define LUA_USE_POSIX
-#define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
-#define LUA_USE_READLINE	/* needs some extra libraries */
-#endif
-
-#if defined(LUA_USE_MACOSX)
-#define LUA_USE_POSIX
-#define LUA_DL_DYLD		/* does not need extra library */
-#endif
-
-
-
-/*
-@@ LUA_USE_POSIX includes all functionallity listed as X/Open System
-@* Interfaces Extension (XSI).
-** CHANGE it (define it) if your system is XSI compatible.
-*/
-#if defined(LUA_USE_POSIX)
-#define LUA_USE_MKSTEMP
-#define LUA_USE_ISATTY
-#define LUA_USE_POPEN
-#define LUA_USE_ULONGJMP
-#endif
-
-
-/*
-@@ LUA_PATH and LUA_CPATH are the names of the environment variables that
-@* Lua check to set its paths.
-@@ LUA_INIT is the name of the environment variable that Lua
-@* checks for initialization code.
-** CHANGE them if you want different names.
-*/
-#define LUA_PATH        "LUA_PATH"
-#define LUA_CPATH       "LUA_CPATH"
-#define LUA_INIT	"LUA_INIT"
-
-
-/*
-@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
-@* Lua libraries.
-@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
-@* C libraries.
-** CHANGE them if your machine has a non-conventional directory
-** hierarchy or if you want to install your libraries in
-** non-conventional directories.
-*/
-#if defined(_WIN32)
-/*
-** In Windows, any exclamation mark ('!') in the path is replaced by the
-** path of the directory of the executable file of the current process.
-*/
-#define LUA_LDIR	"!\\lua\\"
-#define LUA_CDIR	"!\\"
-#define LUA_PATH_DEFAULT  \
-		".\\?.lua;"  LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \
-		             LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua"
-#define LUA_CPATH_DEFAULT \
-	".\\?.dll;"  LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll"
-
-#else
-#define LUA_ROOT	"/usr/local/"
-#define LUA_LDIR	LUA_ROOT "share/lua/5.1/"
-#define LUA_CDIR	LUA_ROOT "lib/lua/5.1/"
-#define LUA_PATH_DEFAULT  \
-		"./?.lua;"  LUA_LDIR"?.lua;"  LUA_LDIR"?/init.lua;" \
-		            LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua"
-#define LUA_CPATH_DEFAULT \
-	"./?.so;"  LUA_CDIR"?.so;" LUA_CDIR"loadall.so"
-#endif
-
-
-/*
-@@ LUA_DIRSEP is the directory separator (for submodules).
-** CHANGE it if your machine does not use "/" as the directory separator
-** and is not Windows. (On Windows Lua automatically uses "\".)
-*/
-#if defined(_WIN32)
-#define LUA_DIRSEP	"\\"
-#else
-#define LUA_DIRSEP	"/"
-#endif
-
-
-/*
-@@ LUA_PATHSEP is the character that separates templates in a path.
-@@ LUA_PATH_MARK is the string that marks the substitution points in a
-@* template.
-@@ LUA_EXECDIR in a Windows path is replaced by the executable's
-@* directory.
-@@ LUA_IGMARK is a mark to ignore all before it when bulding the
-@* luaopen_ function name.
-** CHANGE them if for some reason your system cannot use those
-** characters. (E.g., if one of those characters is a common character
-** in file/directory names.) Probably you do not need to change them.
-*/
-#define LUA_PATHSEP	";"
-#define LUA_PATH_MARK	"?"
-#define LUA_EXECDIR	"!"
-#define LUA_IGMARK	"-"
-
-
-/*
-@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger.
-** CHANGE that if ptrdiff_t is not adequate on your machine. (On most
-** machines, ptrdiff_t gives a good choice between int or long.)
-*/
-#define LUA_INTEGER	ptrdiff_t
-
-
-/*
-@@ LUA_API is a mark for all core API functions.
-@@ LUALIB_API is a mark for all standard library functions.
-** CHANGE them if you need to define those functions in some special way.
-** For instance, if you want to create one Windows DLL with the core and
-** the libraries, you may want to use the following definition (define
-** LUA_BUILD_AS_DLL to get it).
-*/
-#if defined(LUA_BUILD_AS_DLL)
-
-#if defined(LUA_CORE) || defined(LUA_LIB)
-#define LUA_API __declspec(dllexport)
-#else
-#define LUA_API __declspec(dllimport)
-#endif
-
-#else
-
-#define LUA_API		extern
-
-#endif
-
-/* more often than not the libs go together with the core */
-#define LUALIB_API	LUA_API
-
-
-/*
-@@ LUAI_FUNC is a mark for all extern functions that are not to be
-@* exported to outside modules.
-@@ LUAI_DATA is a mark for all extern (const) variables that are not to
-@* be exported to outside modules.
-** CHANGE them if you need to mark them in some special way. Elf/gcc
-** (versions 3.2 and later) mark them as "hidden" to optimize access
-** when Lua is compiled as a shared library.
-*/
-#if defined(luaall_c)
-#define LUAI_FUNC	static
-#define LUAI_DATA	/* empty */
-
-#elif defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
-      defined(__ELF__)
-#define LUAI_FUNC	__attribute__((visibility("hidden"))) extern
-#define LUAI_DATA	LUAI_FUNC
-
-#else
-#define LUAI_FUNC	extern
-#define LUAI_DATA	extern
-#endif
-
-
-
-/*
-@@ LUA_QL describes how error messages quote program elements.
-** CHANGE it if you want a different appearance.
-*/
-#define LUA_QL(x)	"'" x "'"
-#define LUA_QS		LUA_QL("%s")
-
-
-/*
-@@ LUA_IDSIZE gives the maximum size for the description of the source
-@* of a function in debug information.
-** CHANGE it if you want a different size.
-*/
-#define LUA_IDSIZE	60
-
-
-/*
-** {==================================================================
-** Stand-alone configuration
-** ===================================================================
-*/
-
-#if defined(lua_c) || defined(luaall_c)
-
-/*
-@@ lua_stdin_is_tty detects whether the standard input is a 'tty' (that
-@* is, whether we're running lua interactively).
-** CHANGE it if you have a better definition for non-POSIX/non-Windows
-** systems.
-*/
-#if defined(LUA_USE_ISATTY)
-#include <unistd.h>
-#define lua_stdin_is_tty()	isatty(0)
-#elif defined(LUA_WIN)
-#include <io.h>
-#include <stdio.h>
-#define lua_stdin_is_tty()	_isatty(_fileno(stdin))
-#else
-#define lua_stdin_is_tty()	1  /* assume stdin is a tty */
-#endif
-
-
-/*
-@@ LUA_PROMPT is the default prompt used by stand-alone Lua.
-@@ LUA_PROMPT2 is the default continuation prompt used by stand-alone Lua.
-** CHANGE them if you want different prompts. (You can also change the
-** prompts dynamically, assigning to globals _PROMPT/_PROMPT2.)
-*/
-#define LUA_PROMPT		"> "
-#define LUA_PROMPT2		">> "
-
-
-/*
-@@ LUA_PROGNAME is the default name for the stand-alone Lua program.
-** CHANGE it if your stand-alone interpreter has a different name and
-** your system is not able to detect that name automatically.
-*/
-#define LUA_PROGNAME		"lua"
-
-
-/*
-@@ LUA_MAXINPUT is the maximum length for an input line in the
-@* stand-alone interpreter.
-** CHANGE it if you need longer lines.
-*/
-#define LUA_MAXINPUT	512
-
-
-/*
-@@ lua_readline defines how to show a prompt and then read a line from
-@* the standard input.
-@@ lua_saveline defines how to "save" a read line in a "history".
-@@ lua_freeline defines how to free a line read by lua_readline.
-** CHANGE them if you want to improve this functionality (e.g., by using
-** GNU readline and history facilities).
-*/
-#if defined(LUA_USE_READLINE)
-#include <stdio.h>
-#include <readline/readline.h>
-#include <readline/history.h>
-#define lua_readline(L,b,p)	((void)L, ((b)=readline(p)) != NULL)
-#define lua_saveline(L,idx) \
-	if (lua_strlen(L,idx) > 0)  /* non-empty line? */ \
-	  add_history(lua_tostring(L, idx));  /* add it to history */
-#define lua_freeline(L,b)	((void)L, free(b))
-#else
-#define lua_readline(L,b,p)	\
-	((void)L, fputs(p, stdout), fflush(stdout),  /* show prompt */ \
-	fgets(b, LUA_MAXINPUT, stdin) != NULL)  /* get line */
-#define lua_saveline(L,idx)	{ (void)L; (void)idx; }
-#define lua_freeline(L,b)	{ (void)L; (void)b; }
-#endif
-
-#endif
-
-/* }================================================================== */
-
-
-/*
-@@ LUAI_GCPAUSE defines the default pause between garbage-collector cycles
-@* as a percentage.
-** CHANGE it if you want the GC to run faster or slower (higher values
-** mean larger pauses which mean slower collection.) You can also change
-** this value dynamically.
-*/
-#define LUAI_GCPAUSE	200  /* 200% (wait memory to double before next GC) */
-
-
-/*
-@@ LUAI_GCMUL defines the default speed of garbage collection relative to
-@* memory allocation as a percentage.
-** CHANGE it if you want to change the granularity of the garbage
-** collection. (Higher values mean coarser collections. 0 represents
-** infinity, where each step performs a full collection.) You can also
-** change this value dynamically.
-*/
-#define LUAI_GCMUL	200 /* GC runs 'twice the speed' of memory allocation */
-
-
-
-/*
-@@ LUA_COMPAT_GETN controls compatibility with old getn behavior.
-** CHANGE it (define it) if you want exact compatibility with the
-** behavior of setn/getn in Lua 5.0.
-*/
-#undef LUA_COMPAT_GETN
-
-/*
-@@ LUA_COMPAT_LOADLIB controls compatibility about global loadlib.
-** CHANGE it to undefined as soon as you do not need a global 'loadlib'
-** function (the function is still available as 'package.loadlib').
-*/
-#undef LUA_COMPAT_LOADLIB
-
-/*
-@@ LUA_COMPAT_VARARG controls compatibility with old vararg feature.
-** CHANGE it to undefined as soon as your programs use only '...' to
-** access vararg parameters (instead of the old 'arg' table).
-*/
-#define LUA_COMPAT_VARARG
-
-/*
-@@ LUA_COMPAT_MOD controls compatibility with old math.mod function.
-** CHANGE it to undefined as soon as your programs use 'math.fmod' or
-** the new '%' operator instead of 'math.mod'.
-*/
-#define LUA_COMPAT_MOD
-
-/*
-@@ LUA_COMPAT_LSTR controls compatibility with old long string nesting
-@* facility.
-** CHANGE it to 2 if you want the old behaviour, or undefine it to turn
-** off the advisory error when nesting [[...]].
-*/
-#define LUA_COMPAT_LSTR		1
-
-/*
-@@ LUA_COMPAT_GFIND controls compatibility with old 'string.gfind' name.
-** CHANGE it to undefined as soon as you rename 'string.gfind' to
-** 'string.gmatch'.
-*/
-#define LUA_COMPAT_GFIND
-
-/*
-@@ LUA_COMPAT_OPENLIB controls compatibility with old 'luaL_openlib'
-@* behavior.
-** CHANGE it to undefined as soon as you replace to 'luaL_register'
-** your uses of 'luaL_openlib'
-*/
-#define LUA_COMPAT_OPENLIB
-
-
-
-/*
-@@ luai_apicheck is the assert macro used by the Lua-C API.
-** CHANGE luai_apicheck if you want Lua to perform some checks in the
-** parameters it gets from API calls. This may slow down the interpreter
-** a bit, but may be quite useful when debugging C code that interfaces
-** with Lua. A useful redefinition is to use assert.h.
-*/
-#if defined(LUA_USE_APICHECK)
-#include <assert.h>
-#define luai_apicheck(L,o)	{ (void)L; assert(o); }
-#else
-#define luai_apicheck(L,o)	{ (void)L; }
-#endif
-
-
-/*
-@@ LUAI_BITSINT defines the number of bits in an int.
-** CHANGE here if Lua cannot automatically detect the number of bits of
-** your machine. Probably you do not need to change this.
-*/
-/* avoid overflows in comparison */
-#if INT_MAX-20 < 32760
-#define LUAI_BITSINT	16
-#elif INT_MAX > 2147483640L
-/* int has at least 32 bits */
-#define LUAI_BITSINT	32
-#else
-#error "you must define LUA_BITSINT with number of bits in an integer"
-#endif
-
-
-/*
-@@ LUAI_UINT32 is an unsigned integer with at least 32 bits.
-@@ LUAI_INT32 is an signed integer with at least 32 bits.
-@@ LUAI_UMEM is an unsigned integer big enough to count the total
-@* memory used by Lua.
-@@ LUAI_MEM is a signed integer big enough to count the total memory
-@* used by Lua.
-** CHANGE here if for some weird reason the default definitions are not
-** good enough for your machine. (The definitions in the 'else'
-** part always works, but may waste space on machines with 64-bit
-** longs.) Probably you do not need to change this.
-*/
-#if LUAI_BITSINT >= 32
-#define LUAI_UINT32	unsigned int
-#define LUAI_INT32	int
-#define LUAI_MAXINT32	INT_MAX
-#define LUAI_UMEM	size_t
-#define LUAI_MEM	ptrdiff_t
-#else
-/* 16-bit ints */
-#define LUAI_UINT32	unsigned long
-#define LUAI_INT32	long
-#define LUAI_MAXINT32	LONG_MAX
-#define LUAI_UMEM	unsigned long
-#define LUAI_MEM	long
-#endif
-
-
-/*
-@@ LUAI_MAXCALLS limits the number of nested calls.
-** CHANGE it if you need really deep recursive calls. This limit is
-** arbitrary; its only purpose is to stop infinite recursion before
-** exhausting memory.
-*/
-#define LUAI_MAXCALLS	20000
-
-
-/*
-@@ LUAI_MAXCSTACK limits the number of Lua stack slots that a C function
-@* can use.
-** CHANGE it if you need lots of (Lua) stack space for your C
-** functions. This limit is arbitrary; its only purpose is to stop C
-** functions to consume unlimited stack space. (must be smaller than
-** -LUA_REGISTRYINDEX)
-*/
-#define LUAI_MAXCSTACK	8000
-
-
-
-/*
-** {==================================================================
-** CHANGE (to smaller values) the following definitions if your system
-** has a small C stack. (Or you may want to change them to larger
-** values if your system has a large C stack and these limits are
-** too rigid for you.) Some of these constants control the size of
-** stack-allocated arrays used by the compiler or the interpreter, while
-** others limit the maximum number of recursive calls that the compiler
-** or the interpreter can perform. Values too large may cause a C stack
-** overflow for some forms of deep constructs.
-** ===================================================================
-*/
-
-
-/*
-@@ LUAI_MAXCCALLS is the maximum depth for nested C calls (short) and
-@* syntactical nested non-terminals in a program.
-*/
-#define LUAI_MAXCCALLS		200
-
-
-/*
-@@ LUAI_MAXVARS is the maximum number of local variables per function
-@* (must be smaller than 250).
-*/
-#define LUAI_MAXVARS		200
-
-
-/*
-@@ LUAI_MAXUPVALUES is the maximum number of upvalues per function
-@* (must be smaller than 250).
-*/
-#define LUAI_MAXUPVALUES	60
-
-
-/*
-@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
-*/
-#define LUAL_BUFFERSIZE		BUFSIZ
-
-/* }================================================================== */
-
-
-
-
-/*
-** {==================================================================
-@@ LUA_NUMBER is the type of numbers in Lua.
-** CHANGE the following definitions only if you want to build Lua
-** with a number type different from double. You may also need to
-** change lua_number2int & lua_number2integer.
-** ===================================================================
-*/
-
-#define LUA_NUMBER_DOUBLE
-#define LUA_NUMBER	double
-
-/*
-@@ LUAI_UACNUMBER is the result of an 'usual argument conversion'
-@* over a number.
-*/
-#define LUAI_UACNUMBER	double
-
-
-/*
-@@ LUA_NUMBER_SCAN is the format for reading numbers.
-@@ LUA_NUMBER_FMT is the format for writing numbers.
-@@ lua_number2str converts a number to a string.
-@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.
-@@ lua_str2number converts a string to a number.
-*/
-#define LUA_NUMBER_SCAN		"%lf"
-#define LUA_NUMBER_FMT		"%.14g"
-#define lua_number2str(s,n)	sprintf((s), LUA_NUMBER_FMT, (n))
-#define LUAI_MAXNUMBER2STR	32 /* 16 digits, sign, point, and \0 */
-#define lua_str2number(s,p)	strtod((s), (p))
-
-
-/*
-@@ The luai_num* macros define the primitive operations over numbers.
-*/
-#if defined(LUA_CORE)
-#include <math.h>
-#define luai_numadd(a,b)	((a)+(b))
-#define luai_numsub(a,b)	((a)-(b))
-#define luai_nummul(a,b)	((a)*(b))
-#define luai_numdiv(a,b)	((a)/(b))
-#define luai_nummod(a,b)	((a) - floor((a)/(b))*(b))
-#define luai_numpow(a,b)	(pow(a,b))
-#define luai_numunm(a)		(-(a))
-#define luai_numeq(a,b)		((a)==(b))
-#define luai_numlt(a,b)		((a)<(b))
-#define luai_numle(a,b)		((a)<=(b))
-#define luai_numisnan(a)	(!luai_numeq((a), (a)))
-#endif
-
-
-/*
-@@ lua_number2int is a macro to convert lua_Number to int.
-@@ lua_number2integer is a macro to convert lua_Number to lua_Integer.
-** CHANGE them if you know a faster way to convert a lua_Number to
-** int (with any rounding method and without throwing errors) in your
-** system. In Pentium machines, a naive typecast from double to int
-** in C is extremely slow, so any alternative is worth trying.
-*/
-
-/* On a Pentium, resort to a trick */
-#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) && !defined(__SSE2__) && \
-    (defined(__i386) || defined (_M_IX86) || defined(__i386__))
-
-/* On a Microsoft compiler, use assembler */
-#if defined(_MSC_VER)
-
-#define lua_number2int(i,d)   __asm fld d   __asm fistp i
-#define lua_number2integer(i,n)		lua_number2int(i, n)
-
-/* the next trick should work on any Pentium, but sometimes clashes
-   with a DirectX idiosyncrasy */
-#else
-
-union luai_Cast { double l_d; long l_l; };
-#define lua_number2int(i,d) \
-  { volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; }
-#define lua_number2integer(i,n)		lua_number2int(i, n)
-
-#endif
-
-
-/* this option always works, but may be slow */
-#else
-#define lua_number2int(i,d)	((i)=(int)(d))
-#define lua_number2integer(i,d)	((i)=(lua_Integer)(d))
-
-#endif
-
-/* }================================================================== */
-
-
-/*
-@@ LUAI_USER_ALIGNMENT_T is a type that requires maximum alignment.
-** CHANGE it if your system requires alignments larger than double. (For
-** instance, if your system supports long doubles and they must be
-** aligned in 16-byte boundaries, then you should add long double in the
-** union.) Probably you do not need to change this.
-*/
-#define LUAI_USER_ALIGNMENT_T	union { double u; void *s; long l; }
-
-
-/*
-@@ LUAI_THROW/LUAI_TRY define how Lua does exception handling.
-** CHANGE them if you prefer to use longjmp/setjmp even with C++
-** or if want/don't to use _longjmp/_setjmp instead of regular
-** longjmp/setjmp. By default, Lua handles errors with exceptions when
-** compiling as C++ code, with _longjmp/_setjmp when asked to use them,
-** and with longjmp/setjmp otherwise.
-*/
-#if defined(__cplusplus)
-/* C++ exceptions */
-#define LUAI_THROW(L,c)	throw(c)
-#define LUAI_TRY(L,c,a)	try { a } catch(...) \
-	{ if ((c)->status == 0) (c)->status = -1; }
-#define luai_jmpbuf	int  /* dummy variable */
-
-#elif defined(LUA_USE_ULONGJMP)
-/* in Unix, try _longjmp/_setjmp (more efficient) */
-#define LUAI_THROW(L,c)	_longjmp((c)->b, 1)
-#define LUAI_TRY(L,c,a)	if (_setjmp((c)->b) == 0) { a }
-#define luai_jmpbuf	jmp_buf
-
-#else
-/* default handling with long jumps */
-#define LUAI_THROW(L,c)	longjmp((c)->b, 1)
-#define LUAI_TRY(L,c,a)	if (setjmp((c)->b) == 0) { a }
-#define luai_jmpbuf	jmp_buf
-
-#endif
-
-
-/*
-@@ LUA_MAXCAPTURES is the maximum number of captures that a pattern
-@* can do during pattern-matching.
-** CHANGE it if you need more captures. This limit is arbitrary.
-*/
-#define LUA_MAXCAPTURES		32
-
-
-/*
-@@ lua_tmpnam is the function that the OS library uses to create a
-@* temporary name.
-@@ LUA_TMPNAMBUFSIZE is the maximum size of a name created by lua_tmpnam.
-** CHANGE them if you have an alternative to tmpnam (which is considered
-** insecure) or if you want the original tmpnam anyway.  By default, Lua
-** uses tmpnam except when POSIX is available, where it uses mkstemp.
-*/
-#if defined(loslib_c) || defined(luaall_c)
-
-#if defined(LUA_USE_MKSTEMP)
-#include <unistd.h>
-#define LUA_TMPNAMBUFSIZE	32
-#define lua_tmpnam(b,e)	{ \
-	strcpy(b, "/tmp/lua_XXXXXX"); \
-	e = mkstemp(b); \
-	if (e != -1) close(e); \
-	e = (e == -1); }
-
-#else
-#define LUA_TMPNAMBUFSIZE	L_tmpnam
-#define lua_tmpnam(b,e)		{ e = (tmpnam(b) == NULL); }
-#endif
-
-#endif
-
-
-/*
-@@ lua_popen spawns a new process connected to the current one through
-@* the file streams.
-** CHANGE it if you have a way to implement it in your system.
-*/
-#if defined(LUA_USE_POPEN)
-
-#define lua_popen(L,c,m)	((void)L, fflush(NULL), popen(c,m))
-#define lua_pclose(L,file)	((void)L, (pclose(file) != -1))
-
-#elif defined(LUA_WIN)
-
-#define lua_popen(L,c,m)	((void)L, _popen(c,m))
-#define lua_pclose(L,file)	((void)L, (_pclose(file) != -1))
-
-#else
-
-#define lua_popen(L,c,m)	((void)((void)c, m),  \
-		luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)
-#define lua_pclose(L,file)		((void)((void)L, file), 0)
-
-#endif
-
-/*
-@@ LUA_DL_* define which dynamic-library system Lua should use.
-** CHANGE here if Lua has problems choosing the appropriate
-** dynamic-library system for your platform (either Windows' DLL, Mac's
-** dyld, or Unix's dlopen). If your system is some kind of Unix, there
-** is a good chance that it has dlopen, so LUA_DL_DLOPEN will work for
-** it.  To use dlopen you also need to adapt the src/Makefile (probably
-** adding -ldl to the linker options), so Lua does not select it
-** automatically.  (When you change the makefile to add -ldl, you must
-** also add -DLUA_USE_DLOPEN.)
-** If you do not want any kind of dynamic library, undefine all these
-** options.
-** By default, _WIN32 gets LUA_DL_DLL and MAC OS X gets LUA_DL_DYLD.
-*/
-#if defined(LUA_USE_DLOPEN)
-#define LUA_DL_DLOPEN
-#endif
-
-#if defined(LUA_WIN)
-#define LUA_DL_DLL
-#endif
-
-
-/*
-@@ LUAI_EXTRASPACE allows you to add user-specific data in a lua_State
-@* (the data goes just *before* the lua_State pointer).
-** CHANGE (define) this if you really need that. This value must be
-** a multiple of the maximum alignment required for your machine.
-*/
-#define LUAI_EXTRASPACE		0
-
-
-/*
-@@ luai_userstate* allow user-specific actions on threads.
-** CHANGE them if you defined LUAI_EXTRASPACE and need to do something
-** extra when a thread is created/deleted/resumed/yielded.
-*/
-#define luai_userstateopen(L)		((void)L)
-#define luai_userstateclose(L)		((void)L)
-#define luai_userstatethread(L,L1)	((void)L)
-#define luai_userstatefree(L)		((void)L)
-#define luai_userstateresume(L,n)	((void)L)
-#define luai_userstateyield(L,n)	((void)L)
-
-
-/*
-@@ LUA_INTFRMLEN is the length modifier for integer conversions
-@* in 'string.format'.
-@@ LUA_INTFRM_T is the integer type correspoding to the previous length
-@* modifier.
-** CHANGE them if your system supports long long or does not support long.
-*/
-
-#if defined(LUA_USELONGLONG)
-
-#define LUA_INTFRMLEN		"ll"
-#define LUA_INTFRM_T		long long
-
-#else
-
-#define LUA_INTFRMLEN		"l"
-#define LUA_INTFRM_T		long
-
-#endif
-
-
-
-/* =================================================================== */
-
-/*
-** Local configuration. You can use this space to add your redefinitions
-** without modifying the main part of the file.
-*/
-
-
-
-#endif
-
diff --git a/extern/lua-5.1.5/src/lualib.h b/extern/lua-5.1.5/src/lualib.h
deleted file mode 100644
index 469417f6..00000000
--- a/extern/lua-5.1.5/src/lualib.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
-** $Id: lualib.h,v 1.36.1.1 2007/12/27 13:02:25 roberto Exp $
-** Lua standard libraries
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef lualib_h
-#define lualib_h
-
-#include "lua.h"
-
-
-/* Key to file-handle type */
-#define LUA_FILEHANDLE		"FILE*"
-
-
-#define LUA_COLIBNAME	"coroutine"
-LUALIB_API int (luaopen_base) (lua_State *L);
-
-#define LUA_TABLIBNAME	"table"
-LUALIB_API int (luaopen_table) (lua_State *L);
-
-#define LUA_IOLIBNAME	"io"
-LUALIB_API int (luaopen_io) (lua_State *L);
-
-#define LUA_OSLIBNAME	"os"
-LUALIB_API int (luaopen_os) (lua_State *L);
-
-#define LUA_STRLIBNAME	"string"
-LUALIB_API int (luaopen_string) (lua_State *L);
-
-#define LUA_MATHLIBNAME	"math"
-LUALIB_API int (luaopen_math) (lua_State *L);
-
-#define LUA_DBLIBNAME	"debug"
-LUALIB_API int (luaopen_debug) (lua_State *L);
-
-#define LUA_LOADLIBNAME	"package"
-LUALIB_API int (luaopen_package) (lua_State *L);
-
-
-/* open all previous libraries */
-LUALIB_API void (luaL_openlibs) (lua_State *L); 
-
-
-
-#ifndef lua_assert
-#define lua_assert(x)	((void)0)
-#endif
-
-
-#endif
diff --git a/extern/lua-5.1.5/src/lundump.c b/extern/lua-5.1.5/src/lundump.c
deleted file mode 100644
index 8010a457..00000000
--- a/extern/lua-5.1.5/src/lundump.c
+++ /dev/null
@@ -1,227 +0,0 @@
-/*
-** $Id: lundump.c,v 2.7.1.4 2008/04/04 19:51:41 roberto Exp $
-** load precompiled Lua chunks
-** See Copyright Notice in lua.h
-*/
-
-#include <string.h>
-
-#define lundump_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstring.h"
-#include "lundump.h"
-#include "lzio.h"
-
-typedef struct {
- lua_State* L;
- ZIO* Z;
- Mbuffer* b;
- const char* name;
-} LoadState;
-
-#ifdef LUAC_TRUST_BINARIES
-#define IF(c,s)
-#define error(S,s)
-#else
-#define IF(c,s)		if (c) error(S,s)
-
-static void error(LoadState* S, const char* why)
-{
- luaO_pushfstring(S->L,"%s: %s in precompiled chunk",S->name,why);
- luaD_throw(S->L,LUA_ERRSYNTAX);
-}
-#endif
-
-#define LoadMem(S,b,n,size)	LoadBlock(S,b,(n)*(size))
-#define	LoadByte(S)		(lu_byte)LoadChar(S)
-#define LoadVar(S,x)		LoadMem(S,&x,1,sizeof(x))
-#define LoadVector(S,b,n,size)	LoadMem(S,b,n,size)
-
-static void LoadBlock(LoadState* S, void* b, size_t size)
-{
- size_t r=luaZ_read(S->Z,b,size);
- IF (r!=0, "unexpected end");
-}
-
-static int LoadChar(LoadState* S)
-{
- char x;
- LoadVar(S,x);
- return x;
-}
-
-static int LoadInt(LoadState* S)
-{
- int x;
- LoadVar(S,x);
- IF (x<0, "bad integer");
- return x;
-}
-
-static lua_Number LoadNumber(LoadState* S)
-{
- lua_Number x;
- LoadVar(S,x);
- return x;
-}
-
-static TString* LoadString(LoadState* S)
-{
- size_t size;
- LoadVar(S,size);
- if (size==0)
-  return NULL;
- else
- {
-  char* s=luaZ_openspace(S->L,S->b,size);
-  LoadBlock(S,s,size);
-  return luaS_newlstr(S->L,s,size-1);		/* remove trailing '\0' */
- }
-}
-
-static void LoadCode(LoadState* S, Proto* f)
-{
- int n=LoadInt(S);
- f->code=luaM_newvector(S->L,n,Instruction);
- f->sizecode=n;
- LoadVector(S,f->code,n,sizeof(Instruction));
-}
-
-static Proto* LoadFunction(LoadState* S, TString* p);
-
-static void LoadConstants(LoadState* S, Proto* f)
-{
- int i,n;
- n=LoadInt(S);
- f->k=luaM_newvector(S->L,n,TValue);
- f->sizek=n;
- for (i=0; i<n; i++) setnilvalue(&f->k[i]);
- for (i=0; i<n; i++)
- {
-  TValue* o=&f->k[i];
-  int t=LoadChar(S);
-  switch (t)
-  {
-   case LUA_TNIL:
-   	setnilvalue(o);
-	break;
-   case LUA_TBOOLEAN:
-   	setbvalue(o,LoadChar(S)!=0);
-	break;
-   case LUA_TNUMBER:
-	setnvalue(o,LoadNumber(S));
-	break;
-   case LUA_TSTRING:
-	setsvalue2n(S->L,o,LoadString(S));
-	break;
-   default:
-	error(S,"bad constant");
-	break;
-  }
- }
- n=LoadInt(S);
- f->p=luaM_newvector(S->L,n,Proto*);
- f->sizep=n;
- for (i=0; i<n; i++) f->p[i]=NULL;
- for (i=0; i<n; i++) f->p[i]=LoadFunction(S,f->source);
-}
-
-static void LoadDebug(LoadState* S, Proto* f)
-{
- int i,n;
- n=LoadInt(S);
- f->lineinfo=luaM_newvector(S->L,n,int);
- f->sizelineinfo=n;
- LoadVector(S,f->lineinfo,n,sizeof(int));
- n=LoadInt(S);
- f->locvars=luaM_newvector(S->L,n,LocVar);
- f->sizelocvars=n;
- for (i=0; i<n; i++) f->locvars[i].varname=NULL;
- for (i=0; i<n; i++)
- {
-  f->locvars[i].varname=LoadString(S);
-  f->locvars[i].startpc=LoadInt(S);
-  f->locvars[i].endpc=LoadInt(S);
- }
- n=LoadInt(S);
- f->upvalues=luaM_newvector(S->L,n,TString*);
- f->sizeupvalues=n;
- for (i=0; i<n; i++) f->upvalues[i]=NULL;
- for (i=0; i<n; i++) f->upvalues[i]=LoadString(S);
-}
-
-static Proto* LoadFunction(LoadState* S, TString* p)
-{
- Proto* f;
- if (++S->L->nCcalls > LUAI_MAXCCALLS) error(S,"code too deep");
- f=luaF_newproto(S->L);
- setptvalue2s(S->L,S->L->top,f); incr_top(S->L);
- f->source=LoadString(S); if (f->source==NULL) f->source=p;
- f->linedefined=LoadInt(S);
- f->lastlinedefined=LoadInt(S);
- f->nups=LoadByte(S);
- f->numparams=LoadByte(S);
- f->is_vararg=LoadByte(S);
- f->maxstacksize=LoadByte(S);
- LoadCode(S,f);
- LoadConstants(S,f);
- LoadDebug(S,f);
- IF (!luaG_checkcode(f), "bad code");
- S->L->top--;
- S->L->nCcalls--;
- return f;
-}
-
-static void LoadHeader(LoadState* S)
-{
- char h[LUAC_HEADERSIZE];
- char s[LUAC_HEADERSIZE];
- luaU_header(h);
- LoadBlock(S,s,LUAC_HEADERSIZE);
- IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
-}
-
-/*
-** load precompiled chunk
-*/
-Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
-{
- LoadState S;
- if (*name=='@' || *name=='=')
-  S.name=name+1;
- else if (*name==LUA_SIGNATURE[0])
-  S.name="binary string";
- else
-  S.name=name;
- S.L=L;
- S.Z=Z;
- S.b=buff;
- LoadHeader(&S);
- return LoadFunction(&S,luaS_newliteral(L,"=?"));
-}
-
-/*
-* make header
-*/
-void luaU_header (char* h)
-{
- int x=1;
- memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-1);
- h+=sizeof(LUA_SIGNATURE)-1;
- *h++=(char)LUAC_VERSION;
- *h++=(char)LUAC_FORMAT;
- *h++=(char)*(char*)&x;				/* endianness */
- *h++=(char)sizeof(int);
- *h++=(char)sizeof(size_t);
- *h++=(char)sizeof(Instruction);
- *h++=(char)sizeof(lua_Number);
- *h++=(char)(((lua_Number)0.5)==0);		/* is lua_Number integral? */
-}
diff --git a/extern/lua-5.1.5/src/lundump.h b/extern/lua-5.1.5/src/lundump.h
deleted file mode 100644
index c80189db..00000000
--- a/extern/lua-5.1.5/src/lundump.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
-** $Id: lundump.h,v 1.37.1.1 2007/12/27 13:02:25 roberto Exp $
-** load precompiled Lua chunks
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lundump_h
-#define lundump_h
-
-#include "lobject.h"
-#include "lzio.h"
-
-/* load one chunk; from lundump.c */
-LUAI_FUNC Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name);
-
-/* make header; from lundump.c */
-LUAI_FUNC void luaU_header (char* h);
-
-/* dump one chunk; from ldump.c */
-LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip);
-
-#ifdef luac_c
-/* print one chunk; from print.c */
-LUAI_FUNC void luaU_print (const Proto* f, int full);
-#endif
-
-/* for header of binary files -- this is Lua 5.1 */
-#define LUAC_VERSION		0x51
-
-/* for header of binary files -- this is the official format */
-#define LUAC_FORMAT		0
-
-/* size of header of binary files */
-#define LUAC_HEADERSIZE		12
-
-#endif
diff --git a/extern/lua-5.1.5/src/lvm.c b/extern/lua-5.1.5/src/lvm.c
deleted file mode 100644
index e0a0cd85..00000000
--- a/extern/lua-5.1.5/src/lvm.c
+++ /dev/null
@@ -1,767 +0,0 @@
-/*
-** $Id: lvm.c,v 2.63.1.5 2011/08/17 20:43:11 roberto Exp $
-** Lua virtual machine
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define lvm_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-#include "lvm.h"
-
-
-
-/* limit for table tag-method chains (to avoid loops) */
-#define MAXTAGLOOP	100
-
-
-const TValue *luaV_tonumber (const TValue *obj, TValue *n) {
-  lua_Number num;
-  if (ttisnumber(obj)) return obj;
-  if (ttisstring(obj) && luaO_str2d(svalue(obj), &num)) {
-    setnvalue(n, num);
-    return n;
-  }
-  else
-    return NULL;
-}
-
-
-int luaV_tostring (lua_State *L, StkId obj) {
-  if (!ttisnumber(obj))
-    return 0;
-  else {
-    char s[LUAI_MAXNUMBER2STR];
-    lua_Number n = nvalue(obj);
-    lua_number2str(s, n);
-    setsvalue2s(L, obj, luaS_new(L, s));
-    return 1;
-  }
-}
-
-
-static void traceexec (lua_State *L, const Instruction *pc) {
-  lu_byte mask = L->hookmask;
-  const Instruction *oldpc = L->savedpc;
-  L->savedpc = pc;
-  if ((mask & LUA_MASKCOUNT) && L->hookcount == 0) {
-    resethookcount(L);
-    luaD_callhook(L, LUA_HOOKCOUNT, -1);
-  }
-  if (mask & LUA_MASKLINE) {
-    Proto *p = ci_func(L->ci)->l.p;
-    int npc = pcRel(pc, p);
-    int newline = getline(p, npc);
-    /* call linehook when enter a new function, when jump back (loop),
-       or when enter a new line */
-    if (npc == 0 || pc <= oldpc || newline != getline(p, pcRel(oldpc, p)))
-      luaD_callhook(L, LUA_HOOKLINE, newline);
-  }
-}
-
-
-static void callTMres (lua_State *L, StkId res, const TValue *f,
-                        const TValue *p1, const TValue *p2) {
-  ptrdiff_t result = savestack(L, res);
-  setobj2s(L, L->top, f);  /* push function */
-  setobj2s(L, L->top+1, p1);  /* 1st argument */
-  setobj2s(L, L->top+2, p2);  /* 2nd argument */
-  luaD_checkstack(L, 3);
-  L->top += 3;
-  luaD_call(L, L->top - 3, 1);
-  res = restorestack(L, result);
-  L->top--;
-  setobjs2s(L, res, L->top);
-}
-
-
-
-static void callTM (lua_State *L, const TValue *f, const TValue *p1,
-                    const TValue *p2, const TValue *p3) {
-  setobj2s(L, L->top, f);  /* push function */
-  setobj2s(L, L->top+1, p1);  /* 1st argument */
-  setobj2s(L, L->top+2, p2);  /* 2nd argument */
-  setobj2s(L, L->top+3, p3);  /* 3th argument */
-  luaD_checkstack(L, 4);
-  L->top += 4;
-  luaD_call(L, L->top - 4, 0);
-}
-
-
-void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {
-  int loop;
-  for (loop = 0; loop < MAXTAGLOOP; loop++) {
-    const TValue *tm;
-    if (ttistable(t)) {  /* `t' is a table? */
-      Table *h = hvalue(t);
-      const TValue *res = luaH_get(h, key); /* do a primitive get */
-      if (!ttisnil(res) ||  /* result is no nil? */
-          (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
-        setobj2s(L, val, res);
-        return;
-      }
-      /* else will try the tag method */
-    }
-    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))
-      luaG_typeerror(L, t, "index");
-    if (ttisfunction(tm)) {
-      callTMres(L, val, tm, t, key);
-      return;
-    }
-    t = tm;  /* else repeat with `tm' */ 
-  }
-  luaG_runerror(L, "loop in gettable");
-}
-
-
-void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) {
-  int loop;
-  TValue temp;
-  for (loop = 0; loop < MAXTAGLOOP; loop++) {
-    const TValue *tm;
-    if (ttistable(t)) {  /* `t' is a table? */
-      Table *h = hvalue(t);
-      TValue *oldval = luaH_set(L, h, key); /* do a primitive set */
-      if (!ttisnil(oldval) ||  /* result is no nil? */
-          (tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL) { /* or no TM? */
-        setobj2t(L, oldval, val);
-        h->flags = 0;
-        luaC_barriert(L, h, val);
-        return;
-      }
-      /* else will try the tag method */
-    }
-    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
-      luaG_typeerror(L, t, "index");
-    if (ttisfunction(tm)) {
-      callTM(L, tm, t, key, val);
-      return;
-    }
-    /* else repeat with `tm' */
-    setobj(L, &temp, tm);  /* avoid pointing inside table (may rehash) */
-    t = &temp;
-  }
-  luaG_runerror(L, "loop in settable");
-}
-
-
-static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2,
-                       StkId res, TMS event) {
-  const TValue *tm = luaT_gettmbyobj(L, p1, event);  /* try first operand */
-  if (ttisnil(tm))
-    tm = luaT_gettmbyobj(L, p2, event);  /* try second operand */
-  if (ttisnil(tm)) return 0;
-  callTMres(L, res, tm, p1, p2);
-  return 1;
-}
-
-
-static const TValue *get_compTM (lua_State *L, Table *mt1, Table *mt2,
-                                  TMS event) {
-  const TValue *tm1 = fasttm(L, mt1, event);
-  const TValue *tm2;
-  if (tm1 == NULL) return NULL;  /* no metamethod */
-  if (mt1 == mt2) return tm1;  /* same metatables => same metamethods */
-  tm2 = fasttm(L, mt2, event);
-  if (tm2 == NULL) return NULL;  /* no metamethod */
-  if (luaO_rawequalObj(tm1, tm2))  /* same metamethods? */
-    return tm1;
-  return NULL;
-}
-
-
-static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2,
-                         TMS event) {
-  const TValue *tm1 = luaT_gettmbyobj(L, p1, event);
-  const TValue *tm2;
-  if (ttisnil(tm1)) return -1;  /* no metamethod? */
-  tm2 = luaT_gettmbyobj(L, p2, event);
-  if (!luaO_rawequalObj(tm1, tm2))  /* different metamethods? */
-    return -1;
-  callTMres(L, L->top, tm1, p1, p2);
-  return !l_isfalse(L->top);
-}
-
-
-static int l_strcmp (const TString *ls, const TString *rs) {
-  const char *l = getstr(ls);
-  size_t ll = ls->tsv.len;
-  const char *r = getstr(rs);
-  size_t lr = rs->tsv.len;
-  for (;;) {
-    int temp = strcoll(l, r);
-    if (temp != 0) return temp;
-    else {  /* strings are equal up to a `\0' */
-      size_t len = strlen(l);  /* index of first `\0' in both strings */
-      if (len == lr)  /* r is finished? */
-        return (len == ll) ? 0 : 1;
-      else if (len == ll)  /* l is finished? */
-        return -1;  /* l is smaller than r (because r is not finished) */
-      /* both strings longer than `len'; go on comparing (after the `\0') */
-      len++;
-      l += len; ll -= len; r += len; lr -= len;
-    }
-  }
-}
-
-
-int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {
-  int res;
-  if (ttype(l) != ttype(r))
-    return luaG_ordererror(L, l, r);
-  else if (ttisnumber(l))
-    return luai_numlt(nvalue(l), nvalue(r));
-  else if (ttisstring(l))
-    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
-  else if ((res = call_orderTM(L, l, r, TM_LT)) != -1)
-    return res;
-  return luaG_ordererror(L, l, r);
-}
-
-
-static int lessequal (lua_State *L, const TValue *l, const TValue *r) {
-  int res;
-  if (ttype(l) != ttype(r))
-    return luaG_ordererror(L, l, r);
-  else if (ttisnumber(l))
-    return luai_numle(nvalue(l), nvalue(r));
-  else if (ttisstring(l))
-    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;
-  else if ((res = call_orderTM(L, l, r, TM_LE)) != -1)  /* first try `le' */
-    return res;
-  else if ((res = call_orderTM(L, r, l, TM_LT)) != -1)  /* else try `lt' */
-    return !res;
-  return luaG_ordererror(L, l, r);
-}
-
-
-int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2) {
-  const TValue *tm;
-  lua_assert(ttype(t1) == ttype(t2));
-  switch (ttype(t1)) {
-    case LUA_TNIL: return 1;
-    case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2));
-    case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2);  /* true must be 1 !! */
-    case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
-    case LUA_TUSERDATA: {
-      if (uvalue(t1) == uvalue(t2)) return 1;
-      tm = get_compTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable,
-                         TM_EQ);
-      break;  /* will try TM */
-    }
-    case LUA_TTABLE: {
-      if (hvalue(t1) == hvalue(t2)) return 1;
-      tm = get_compTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ);
-      break;  /* will try TM */
-    }
-    default: return gcvalue(t1) == gcvalue(t2);
-  }
-  if (tm == NULL) return 0;  /* no TM? */
-  callTMres(L, L->top, tm, t1, t2);  /* call TM */
-  return !l_isfalse(L->top);
-}
-
-
-void luaV_concat (lua_State *L, int total, int last) {
-  do {
-    StkId top = L->base + last + 1;
-    int n = 2;  /* number of elements handled in this pass (at least 2) */
-    if (!(ttisstring(top-2) || ttisnumber(top-2)) || !tostring(L, top-1)) {
-      if (!call_binTM(L, top-2, top-1, top-2, TM_CONCAT))
-        luaG_concaterror(L, top-2, top-1);
-    } else if (tsvalue(top-1)->len == 0)  /* second op is empty? */
-      (void)tostring(L, top - 2);  /* result is first op (as string) */
-    else {
-      /* at least two string values; get as many as possible */
-      size_t tl = tsvalue(top-1)->len;
-      char *buffer;
-      int i;
-      /* collect total length */
-      for (n = 1; n < total && tostring(L, top-n-1); n++) {
-        size_t l = tsvalue(top-n-1)->len;
-        if (l >= MAX_SIZET - tl) luaG_runerror(L, "string length overflow");
-        tl += l;
-      }
-      buffer = luaZ_openspace(L, &G(L)->buff, tl);
-      tl = 0;
-      for (i=n; i>0; i--) {  /* concat all strings */
-        size_t l = tsvalue(top-i)->len;
-        memcpy(buffer+tl, svalue(top-i), l);
-        tl += l;
-      }
-      setsvalue2s(L, top-n, luaS_newlstr(L, buffer, tl));
-    }
-    total -= n-1;  /* got `n' strings to create 1 new */
-    last -= n-1;
-  } while (total > 1);  /* repeat until only 1 result left */
-}
-
-
-static void Arith (lua_State *L, StkId ra, const TValue *rb,
-                   const TValue *rc, TMS op) {
-  TValue tempb, tempc;
-  const TValue *b, *c;
-  if ((b = luaV_tonumber(rb, &tempb)) != NULL &&
-      (c = luaV_tonumber(rc, &tempc)) != NULL) {
-    lua_Number nb = nvalue(b), nc = nvalue(c);
-    switch (op) {
-      case TM_ADD: setnvalue(ra, luai_numadd(nb, nc)); break;
-      case TM_SUB: setnvalue(ra, luai_numsub(nb, nc)); break;
-      case TM_MUL: setnvalue(ra, luai_nummul(nb, nc)); break;
-      case TM_DIV: setnvalue(ra, luai_numdiv(nb, nc)); break;
-      case TM_MOD: setnvalue(ra, luai_nummod(nb, nc)); break;
-      case TM_POW: setnvalue(ra, luai_numpow(nb, nc)); break;
-      case TM_UNM: setnvalue(ra, luai_numunm(nb)); break;
-      default: lua_assert(0); break;
-    }
-  }
-  else if (!call_binTM(L, rb, rc, ra, op))
-    luaG_aritherror(L, rb, rc);
-}
-
-
-
-/*
-** some macros for common tasks in `luaV_execute'
-*/
-
-#define runtime_check(L, c)	{ if (!(c)) break; }
-
-#define RA(i)	(base+GETARG_A(i))
-/* to be used after possible stack reallocation */
-#define RB(i)	check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i))
-#define RC(i)	check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i))
-#define RKB(i)	check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \
-	ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i))
-#define RKC(i)	check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \
-	ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i))
-#define KBx(i)	check_exp(getBMode(GET_OPCODE(i)) == OpArgK, k+GETARG_Bx(i))
-
-
-#define dojump(L,pc,i)	{(pc) += (i); luai_threadyield(L);}
-
-
-#define Protect(x)	{ L->savedpc = pc; {x;}; base = L->base; }
-
-
-#define arith_op(op,tm) { \
-        TValue *rb = RKB(i); \
-        TValue *rc = RKC(i); \
-        if (ttisnumber(rb) && ttisnumber(rc)) { \
-          lua_Number nb = nvalue(rb), nc = nvalue(rc); \
-          setnvalue(ra, op(nb, nc)); \
-        } \
-        else \
-          Protect(Arith(L, ra, rb, rc, tm)); \
-      }
-
-
-
-void luaV_execute (lua_State *L, int nexeccalls) {
-  LClosure *cl;
-  StkId base;
-  TValue *k;
-  const Instruction *pc;
- reentry:  /* entry point */
-  lua_assert(isLua(L->ci));
-  pc = L->savedpc;
-  cl = &clvalue(L->ci->func)->l;
-  base = L->base;
-  k = cl->p->k;
-  /* main loop of interpreter */
-  for (;;) {
-    const Instruction i = *pc++;
-    StkId ra;
-    if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
-        (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
-      traceexec(L, pc);
-      if (L->status == LUA_YIELD) {  /* did hook yield? */
-        L->savedpc = pc - 1;
-        return;
-      }
-      base = L->base;
-    }
-    /* warning!! several calls may realloc the stack and invalidate `ra' */
-    ra = RA(i);
-    lua_assert(base == L->base && L->base == L->ci->base);
-    lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
-    lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
-    switch (GET_OPCODE(i)) {
-      case OP_MOVE: {
-        setobjs2s(L, ra, RB(i));
-        continue;
-      }
-      case OP_LOADK: {
-        setobj2s(L, ra, KBx(i));
-        continue;
-      }
-      case OP_LOADBOOL: {
-        setbvalue(ra, GETARG_B(i));
-        if (GETARG_C(i)) pc++;  /* skip next instruction (if C) */
-        continue;
-      }
-      case OP_LOADNIL: {
-        TValue *rb = RB(i);
-        do {
-          setnilvalue(rb--);
-        } while (rb >= ra);
-        continue;
-      }
-      case OP_GETUPVAL: {
-        int b = GETARG_B(i);
-        setobj2s(L, ra, cl->upvals[b]->v);
-        continue;
-      }
-      case OP_GETGLOBAL: {
-        TValue g;
-        TValue *rb = KBx(i);
-        sethvalue(L, &g, cl->env);
-        lua_assert(ttisstring(rb));
-        Protect(luaV_gettable(L, &g, rb, ra));
-        continue;
-      }
-      case OP_GETTABLE: {
-        Protect(luaV_gettable(L, RB(i), RKC(i), ra));
-        continue;
-      }
-      case OP_SETGLOBAL: {
-        TValue g;
-        sethvalue(L, &g, cl->env);
-        lua_assert(ttisstring(KBx(i)));
-        Protect(luaV_settable(L, &g, KBx(i), ra));
-        continue;
-      }
-      case OP_SETUPVAL: {
-        UpVal *uv = cl->upvals[GETARG_B(i)];
-        setobj(L, uv->v, ra);
-        luaC_barrier(L, uv, ra);
-        continue;
-      }
-      case OP_SETTABLE: {
-        Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
-        continue;
-      }
-      case OP_NEWTABLE: {
-        int b = GETARG_B(i);
-        int c = GETARG_C(i);
-        sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));
-        Protect(luaC_checkGC(L));
-        continue;
-      }
-      case OP_SELF: {
-        StkId rb = RB(i);
-        setobjs2s(L, ra+1, rb);
-        Protect(luaV_gettable(L, rb, RKC(i), ra));
-        continue;
-      }
-      case OP_ADD: {
-        arith_op(luai_numadd, TM_ADD);
-        continue;
-      }
-      case OP_SUB: {
-        arith_op(luai_numsub, TM_SUB);
-        continue;
-      }
-      case OP_MUL: {
-        arith_op(luai_nummul, TM_MUL);
-        continue;
-      }
-      case OP_DIV: {
-        arith_op(luai_numdiv, TM_DIV);
-        continue;
-      }
-      case OP_MOD: {
-        arith_op(luai_nummod, TM_MOD);
-        continue;
-      }
-      case OP_POW: {
-        arith_op(luai_numpow, TM_POW);
-        continue;
-      }
-      case OP_UNM: {
-        TValue *rb = RB(i);
-        if (ttisnumber(rb)) {
-          lua_Number nb = nvalue(rb);
-          setnvalue(ra, luai_numunm(nb));
-        }
-        else {
-          Protect(Arith(L, ra, rb, rb, TM_UNM));
-        }
-        continue;
-      }
-      case OP_NOT: {
-        int res = l_isfalse(RB(i));  /* next assignment may change this value */
-        setbvalue(ra, res);
-        continue;
-      }
-      case OP_LEN: {
-        const TValue *rb = RB(i);
-        switch (ttype(rb)) {
-          case LUA_TTABLE: {
-            setnvalue(ra, cast_num(luaH_getn(hvalue(rb))));
-            break;
-          }
-          case LUA_TSTRING: {
-            setnvalue(ra, cast_num(tsvalue(rb)->len));
-            break;
-          }
-          default: {  /* try metamethod */
-            Protect(
-              if (!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN))
-                luaG_typeerror(L, rb, "get length of");
-            )
-          }
-        }
-        continue;
-      }
-      case OP_CONCAT: {
-        int b = GETARG_B(i);
-        int c = GETARG_C(i);
-        Protect(luaV_concat(L, c-b+1, c); luaC_checkGC(L));
-        setobjs2s(L, RA(i), base+b);
-        continue;
-      }
-      case OP_JMP: {
-        dojump(L, pc, GETARG_sBx(i));
-        continue;
-      }
-      case OP_EQ: {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        Protect(
-          if (equalobj(L, rb, rc) == GETARG_A(i))
-            dojump(L, pc, GETARG_sBx(*pc));
-        )
-        pc++;
-        continue;
-      }
-      case OP_LT: {
-        Protect(
-          if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i))
-            dojump(L, pc, GETARG_sBx(*pc));
-        )
-        pc++;
-        continue;
-      }
-      case OP_LE: {
-        Protect(
-          if (lessequal(L, RKB(i), RKC(i)) == GETARG_A(i))
-            dojump(L, pc, GETARG_sBx(*pc));
-        )
-        pc++;
-        continue;
-      }
-      case OP_TEST: {
-        if (l_isfalse(ra) != GETARG_C(i))
-          dojump(L, pc, GETARG_sBx(*pc));
-        pc++;
-        continue;
-      }
-      case OP_TESTSET: {
-        TValue *rb = RB(i);
-        if (l_isfalse(rb) != GETARG_C(i)) {
-          setobjs2s(L, ra, rb);
-          dojump(L, pc, GETARG_sBx(*pc));
-        }
-        pc++;
-        continue;
-      }
-      case OP_CALL: {
-        int b = GETARG_B(i);
-        int nresults = GETARG_C(i) - 1;
-        if (b != 0) L->top = ra+b;  /* else previous instruction set top */
-        L->savedpc = pc;
-        switch (luaD_precall(L, ra, nresults)) {
-          case PCRLUA: {
-            nexeccalls++;
-            goto reentry;  /* restart luaV_execute over new Lua function */
-          }
-          case PCRC: {
-            /* it was a C function (`precall' called it); adjust results */
-            if (nresults >= 0) L->top = L->ci->top;
-            base = L->base;
-            continue;
-          }
-          default: {
-            return;  /* yield */
-          }
-        }
-      }
-      case OP_TAILCALL: {
-        int b = GETARG_B(i);
-        if (b != 0) L->top = ra+b;  /* else previous instruction set top */
-        L->savedpc = pc;
-        lua_assert(GETARG_C(i) - 1 == LUA_MULTRET);
-        switch (luaD_precall(L, ra, LUA_MULTRET)) {
-          case PCRLUA: {
-            /* tail call: put new frame in place of previous one */
-            CallInfo *ci = L->ci - 1;  /* previous frame */
-            int aux;
-            StkId func = ci->func;
-            StkId pfunc = (ci+1)->func;  /* previous function index */
-            if (L->openupval) luaF_close(L, ci->base);
-            L->base = ci->base = ci->func + ((ci+1)->base - pfunc);
-            for (aux = 0; pfunc+aux < L->top; aux++)  /* move frame down */
-              setobjs2s(L, func+aux, pfunc+aux);
-            ci->top = L->top = func+aux;  /* correct top */
-            lua_assert(L->top == L->base + clvalue(func)->l.p->maxstacksize);
-            ci->savedpc = L->savedpc;
-            ci->tailcalls++;  /* one more call lost */
-            L->ci--;  /* remove new frame */
-            goto reentry;
-          }
-          case PCRC: {  /* it was a C function (`precall' called it) */
-            base = L->base;
-            continue;
-          }
-          default: {
-            return;  /* yield */
-          }
-        }
-      }
-      case OP_RETURN: {
-        int b = GETARG_B(i);
-        if (b != 0) L->top = ra+b-1;
-        if (L->openupval) luaF_close(L, base);
-        L->savedpc = pc;
-        b = luaD_poscall(L, ra);
-        if (--nexeccalls == 0)  /* was previous function running `here'? */
-          return;  /* no: return */
-        else {  /* yes: continue its execution */
-          if (b) L->top = L->ci->top;
-          lua_assert(isLua(L->ci));
-          lua_assert(GET_OPCODE(*((L->ci)->savedpc - 1)) == OP_CALL);
-          goto reentry;
-        }
-      }
-      case OP_FORLOOP: {
-        lua_Number step = nvalue(ra+2);
-        lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */
-        lua_Number limit = nvalue(ra+1);
-        if (luai_numlt(0, step) ? luai_numle(idx, limit)
-                                : luai_numle(limit, idx)) {
-          dojump(L, pc, GETARG_sBx(i));  /* jump back */
-          setnvalue(ra, idx);  /* update internal index... */
-          setnvalue(ra+3, idx);  /* ...and external index */
-        }
-        continue;
-      }
-      case OP_FORPREP: {
-        const TValue *init = ra;
-        const TValue *plimit = ra+1;
-        const TValue *pstep = ra+2;
-        L->savedpc = pc;  /* next steps may throw errors */
-        if (!tonumber(init, ra))
-          luaG_runerror(L, LUA_QL("for") " initial value must be a number");
-        else if (!tonumber(plimit, ra+1))
-          luaG_runerror(L, LUA_QL("for") " limit must be a number");
-        else if (!tonumber(pstep, ra+2))
-          luaG_runerror(L, LUA_QL("for") " step must be a number");
-        setnvalue(ra, luai_numsub(nvalue(ra), nvalue(pstep)));
-        dojump(L, pc, GETARG_sBx(i));
-        continue;
-      }
-      case OP_TFORLOOP: {
-        StkId cb = ra + 3;  /* call base */
-        setobjs2s(L, cb+2, ra+2);
-        setobjs2s(L, cb+1, ra+1);
-        setobjs2s(L, cb, ra);
-        L->top = cb+3;  /* func. + 2 args (state and index) */
-        Protect(luaD_call(L, cb, GETARG_C(i)));
-        L->top = L->ci->top;
-        cb = RA(i) + 3;  /* previous call may change the stack */
-        if (!ttisnil(cb)) {  /* continue loop? */
-          setobjs2s(L, cb-1, cb);  /* save control variable */
-          dojump(L, pc, GETARG_sBx(*pc));  /* jump back */
-        }
-        pc++;
-        continue;
-      }
-      case OP_SETLIST: {
-        int n = GETARG_B(i);
-        int c = GETARG_C(i);
-        int last;
-        Table *h;
-        if (n == 0) {
-          n = cast_int(L->top - ra) - 1;
-          L->top = L->ci->top;
-        }
-        if (c == 0) c = cast_int(*pc++);
-        runtime_check(L, ttistable(ra));
-        h = hvalue(ra);
-        last = ((c-1)*LFIELDS_PER_FLUSH) + n;
-        if (last > h->sizearray)  /* needs more space? */
-          luaH_resizearray(L, h, last);  /* pre-alloc it at once */
-        for (; n > 0; n--) {
-          TValue *val = ra+n;
-          setobj2t(L, luaH_setnum(L, h, last--), val);
-          luaC_barriert(L, h, val);
-        }
-        continue;
-      }
-      case OP_CLOSE: {
-        luaF_close(L, ra);
-        continue;
-      }
-      case OP_CLOSURE: {
-        Proto *p;
-        Closure *ncl;
-        int nup, j;
-        p = cl->p->p[GETARG_Bx(i)];
-        nup = p->nups;
-        ncl = luaF_newLclosure(L, nup, cl->env);
-        ncl->l.p = p;
-        for (j=0; j<nup; j++, pc++) {
-          if (GET_OPCODE(*pc) == OP_GETUPVAL)
-            ncl->l.upvals[j] = cl->upvals[GETARG_B(*pc)];
-          else {
-            lua_assert(GET_OPCODE(*pc) == OP_MOVE);
-            ncl->l.upvals[j] = luaF_findupval(L, base + GETARG_B(*pc));
-          }
-        }
-        setclvalue(L, ra, ncl);
-        Protect(luaC_checkGC(L));
-        continue;
-      }
-      case OP_VARARG: {
-        int b = GETARG_B(i) - 1;
-        int j;
-        CallInfo *ci = L->ci;
-        int n = cast_int(ci->base - ci->func) - cl->p->numparams - 1;
-        if (b == LUA_MULTRET) {
-          Protect(luaD_checkstack(L, n));
-          ra = RA(i);  /* previous call may change the stack */
-          b = n;
-          L->top = ra + n;
-        }
-        for (j = 0; j < b; j++) {
-          if (j < n) {
-            setobjs2s(L, ra + j, ci->base - n + j);
-          }
-          else {
-            setnilvalue(ra + j);
-          }
-        }
-        continue;
-      }
-    }
-  }
-}
-
diff --git a/extern/lua-5.1.5/src/lvm.h b/extern/lua-5.1.5/src/lvm.h
deleted file mode 100644
index bfe4f567..00000000
--- a/extern/lua-5.1.5/src/lvm.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
-** $Id: lvm.h,v 2.5.1.1 2007/12/27 13:02:25 roberto Exp $
-** Lua virtual machine
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lvm_h
-#define lvm_h
-
-
-#include "ldo.h"
-#include "lobject.h"
-#include "ltm.h"
-
-
-#define tostring(L,o) ((ttype(o) == LUA_TSTRING) || (luaV_tostring(L, o)))
-
-#define tonumber(o,n)	(ttype(o) == LUA_TNUMBER || \
-                         (((o) = luaV_tonumber(o,n)) != NULL))
-
-#define equalobj(L,o1,o2) \
-	(ttype(o1) == ttype(o2) && luaV_equalval(L, o1, o2))
-
-
-LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r);
-LUAI_FUNC int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2);
-LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n);
-LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj);
-LUAI_FUNC void luaV_gettable (lua_State *L, const TValue *t, TValue *key,
-                                            StkId val);
-LUAI_FUNC void luaV_settable (lua_State *L, const TValue *t, TValue *key,
-                                            StkId val);
-LUAI_FUNC void luaV_execute (lua_State *L, int nexeccalls);
-LUAI_FUNC void luaV_concat (lua_State *L, int total, int last);
-
-#endif
diff --git a/extern/lua-5.1.5/src/lzio.c b/extern/lua-5.1.5/src/lzio.c
deleted file mode 100644
index 293edd59..00000000
--- a/extern/lua-5.1.5/src/lzio.c
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
-** $Id: lzio.c,v 1.31.1.1 2007/12/27 13:02:25 roberto Exp $
-** a generic input stream interface
-** See Copyright Notice in lua.h
-*/
-
-
-#include <string.h>
-
-#define lzio_c
-#define LUA_CORE
-
-#include "lua.h"
-
-#include "llimits.h"
-#include "lmem.h"
-#include "lstate.h"
-#include "lzio.h"
-
-
-int luaZ_fill (ZIO *z) {
-  size_t size;
-  lua_State *L = z->L;
-  const char *buff;
-  lua_unlock(L);
-  buff = z->reader(L, z->data, &size);
-  lua_lock(L);
-  if (buff == NULL || size == 0) return EOZ;
-  z->n = size - 1;
-  z->p = buff;
-  return char2int(*(z->p++));
-}
-
-
-int luaZ_lookahead (ZIO *z) {
-  if (z->n == 0) {
-    if (luaZ_fill(z) == EOZ)
-      return EOZ;
-    else {
-      z->n++;  /* luaZ_fill removed first byte; put back it */
-      z->p--;
-    }
-  }
-  return char2int(*z->p);
-}
-
-
-void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) {
-  z->L = L;
-  z->reader = reader;
-  z->data = data;
-  z->n = 0;
-  z->p = NULL;
-}
-
-
-/* --------------------------------------------------------------- read --- */
-size_t luaZ_read (ZIO *z, void *b, size_t n) {
-  while (n) {
-    size_t m;
-    if (luaZ_lookahead(z) == EOZ)
-      return n;  /* return number of missing bytes */
-    m = (n <= z->n) ? n : z->n;  /* min. between n and z->n */
-    memcpy(b, z->p, m);
-    z->n -= m;
-    z->p += m;
-    b = (char *)b + m;
-    n -= m;
-  }
-  return 0;
-}
-
-/* ------------------------------------------------------------------------ */
-char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n) {
-  if (n > buff->buffsize) {
-    if (n < LUA_MINBUFFER) n = LUA_MINBUFFER;
-    luaZ_resizebuffer(L, buff, n);
-  }
-  return buff->buffer;
-}
-
-
diff --git a/extern/lua-5.1.5/src/lzio.h b/extern/lua-5.1.5/src/lzio.h
deleted file mode 100644
index 51d695d8..00000000
--- a/extern/lua-5.1.5/src/lzio.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
-** $Id: lzio.h,v 1.21.1.1 2007/12/27 13:02:25 roberto Exp $
-** Buffered streams
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef lzio_h
-#define lzio_h
-
-#include "lua.h"
-
-#include "lmem.h"
-
-
-#define EOZ	(-1)			/* end of stream */
-
-typedef struct Zio ZIO;
-
-#define char2int(c)	cast(int, cast(unsigned char, (c)))
-
-#define zgetc(z)  (((z)->n--)>0 ?  char2int(*(z)->p++) : luaZ_fill(z))
-
-typedef struct Mbuffer {
-  char *buffer;
-  size_t n;
-  size_t buffsize;
-} Mbuffer;
-
-#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)
-
-#define luaZ_buffer(buff)	((buff)->buffer)
-#define luaZ_sizebuffer(buff)	((buff)->buffsize)
-#define luaZ_bufflen(buff)	((buff)->n)
-
-#define luaZ_resetbuffer(buff) ((buff)->n = 0)
-
-
-#define luaZ_resizebuffer(L, buff, size) \
-	(luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \
-	(buff)->buffsize = size)
-
-#define luaZ_freebuffer(L, buff)	luaZ_resizebuffer(L, buff, 0)
-
-
-LUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n);
-LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,
-                                        void *data);
-LUAI_FUNC size_t luaZ_read (ZIO* z, void* b, size_t n);	/* read next n bytes */
-LUAI_FUNC int luaZ_lookahead (ZIO *z);
-
-
-
-/* --------- Private Part ------------------ */
-
-struct Zio {
-  size_t n;			/* bytes still unread */
-  const char *p;		/* current position in buffer */
-  lua_Reader reader;
-  void* data;			/* additional data */
-  lua_State *L;			/* Lua state (for reader) */
-};
-
-
-LUAI_FUNC int luaZ_fill (ZIO *z);
-
-#endif
diff --git a/extern/lua-5.1.5/src/print.c b/extern/lua-5.1.5/src/print.c
deleted file mode 100644
index e240cfc3..00000000
--- a/extern/lua-5.1.5/src/print.c
+++ /dev/null
@@ -1,227 +0,0 @@
-/*
-** $Id: print.c,v 1.55a 2006/05/31 13:30:05 lhf Exp $
-** print bytecodes
-** See Copyright Notice in lua.h
-*/
-
-#include <ctype.h>
-#include <stdio.h>
-
-#define luac_c
-#define LUA_CORE
-
-#include "ldebug.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lundump.h"
-
-#define PrintFunction	luaU_print
-
-#define Sizeof(x)	((int)sizeof(x))
-#define VOID(p)		((const void*)(p))
-
-static void PrintString(const TString* ts)
-{
- const char* s=getstr(ts);
- size_t i,n=ts->tsv.len;
- putchar('"');
- for (i=0; i<n; i++)
- {
-  int c=s[i];
-  switch (c)
-  {
-   case '"': printf("\\\""); break;
-   case '\\': printf("\\\\"); break;
-   case '\a': printf("\\a"); break;
-   case '\b': printf("\\b"); break;
-   case '\f': printf("\\f"); break;
-   case '\n': printf("\\n"); break;
-   case '\r': printf("\\r"); break;
-   case '\t': printf("\\t"); break;
-   case '\v': printf("\\v"); break;
-   default:	if (isprint((unsigned char)c))
-   			putchar(c);
-		else
-			printf("\\%03u",(unsigned char)c);
-  }
- }
- putchar('"');
-}
-
-static void PrintConstant(const Proto* f, int i)
-{
- const TValue* o=&f->k[i];
- switch (ttype(o))
- {
-  case LUA_TNIL:
-	printf("nil");
-	break;
-  case LUA_TBOOLEAN:
-	printf(bvalue(o) ? "true" : "false");
-	break;
-  case LUA_TNUMBER:
-	printf(LUA_NUMBER_FMT,nvalue(o));
-	break;
-  case LUA_TSTRING:
-	PrintString(rawtsvalue(o));
-	break;
-  default:				/* cannot happen */
-	printf("? type=%d",ttype(o));
-	break;
- }
-}
-
-static void PrintCode(const Proto* f)
-{
- const Instruction* code=f->code;
- int pc,n=f->sizecode;
- for (pc=0; pc<n; pc++)
- {
-  Instruction i=code[pc];
-  OpCode o=GET_OPCODE(i);
-  int a=GETARG_A(i);
-  int b=GETARG_B(i);
-  int c=GETARG_C(i);
-  int bx=GETARG_Bx(i);
-  int sbx=GETARG_sBx(i);
-  int line=getline(f,pc);
-  printf("\t%d\t",pc+1);
-  if (line>0) printf("[%d]\t",line); else printf("[-]\t");
-  printf("%-9s\t",luaP_opnames[o]);
-  switch (getOpMode(o))
-  {
-   case iABC:
-    printf("%d",a);
-    if (getBMode(o)!=OpArgN) printf(" %d",ISK(b) ? (-1-INDEXK(b)) : b);
-    if (getCMode(o)!=OpArgN) printf(" %d",ISK(c) ? (-1-INDEXK(c)) : c);
-    break;
-   case iABx:
-    if (getBMode(o)==OpArgK) printf("%d %d",a,-1-bx); else printf("%d %d",a,bx);
-    break;
-   case iAsBx:
-    if (o==OP_JMP) printf("%d",sbx); else printf("%d %d",a,sbx);
-    break;
-  }
-  switch (o)
-  {
-   case OP_LOADK:
-    printf("\t; "); PrintConstant(f,bx);
-    break;
-   case OP_GETUPVAL:
-   case OP_SETUPVAL:
-    printf("\t; %s", (f->sizeupvalues>0) ? getstr(f->upvalues[b]) : "-");
-    break;
-   case OP_GETGLOBAL:
-   case OP_SETGLOBAL:
-    printf("\t; %s",svalue(&f->k[bx]));
-    break;
-   case OP_GETTABLE:
-   case OP_SELF:
-    if (ISK(c)) { printf("\t; "); PrintConstant(f,INDEXK(c)); }
-    break;
-   case OP_SETTABLE:
-   case OP_ADD:
-   case OP_SUB:
-   case OP_MUL:
-   case OP_DIV:
-   case OP_POW:
-   case OP_EQ:
-   case OP_LT:
-   case OP_LE:
-    if (ISK(b) || ISK(c))
-    {
-     printf("\t; ");
-     if (ISK(b)) PrintConstant(f,INDEXK(b)); else printf("-");
-     printf(" ");
-     if (ISK(c)) PrintConstant(f,INDEXK(c)); else printf("-");
-    }
-    break;
-   case OP_JMP:
-   case OP_FORLOOP:
-   case OP_FORPREP:
-    printf("\t; to %d",sbx+pc+2);
-    break;
-   case OP_CLOSURE:
-    printf("\t; %p",VOID(f->p[bx]));
-    break;
-   case OP_SETLIST:
-    if (c==0) printf("\t; %d",(int)code[++pc]);
-    else printf("\t; %d",c);
-    break;
-   default:
-    break;
-  }
-  printf("\n");
- }
-}
-
-#define SS(x)	(x==1)?"":"s"
-#define S(x)	x,SS(x)
-
-static void PrintHeader(const Proto* f)
-{
- const char* s=getstr(f->source);
- if (*s=='@' || *s=='=')
-  s++;
- else if (*s==LUA_SIGNATURE[0])
-  s="(bstring)";
- else
-  s="(string)";
- printf("\n%s <%s:%d,%d> (%d instruction%s, %d bytes at %p)\n",
- 	(f->linedefined==0)?"main":"function",s,
-	f->linedefined,f->lastlinedefined,
-	S(f->sizecode),f->sizecode*Sizeof(Instruction),VOID(f));
- printf("%d%s param%s, %d slot%s, %d upvalue%s, ",
-	f->numparams,f->is_vararg?"+":"",SS(f->numparams),
-	S(f->maxstacksize),S(f->nups));
- printf("%d local%s, %d constant%s, %d function%s\n",
-	S(f->sizelocvars),S(f->sizek),S(f->sizep));
-}
-
-static void PrintConstants(const Proto* f)
-{
- int i,n=f->sizek;
- printf("constants (%d) for %p:\n",n,VOID(f));
- for (i=0; i<n; i++)
- {
-  printf("\t%d\t",i+1);
-  PrintConstant(f,i);
-  printf("\n");
- }
-}
-
-static void PrintLocals(const Proto* f)
-{
- int i,n=f->sizelocvars;
- printf("locals (%d) for %p:\n",n,VOID(f));
- for (i=0; i<n; i++)
- {
-  printf("\t%d\t%s\t%d\t%d\n",
-  i,getstr(f->locvars[i].varname),f->locvars[i].startpc+1,f->locvars[i].endpc+1);
- }
-}
-
-static void PrintUpvalues(const Proto* f)
-{
- int i,n=f->sizeupvalues;
- printf("upvalues (%d) for %p:\n",n,VOID(f));
- if (f->upvalues==NULL) return;
- for (i=0; i<n; i++)
- {
-  printf("\t%d\t%s\n",i,getstr(f->upvalues[i]));
- }
-}
-
-void PrintFunction(const Proto* f, int full)
-{
- int i,n=f->sizep;
- PrintHeader(f);
- PrintCode(f);
- if (full)
- {
-  PrintConstants(f);
-  PrintLocals(f);
-  PrintUpvalues(f);
- }
- for (i=0; i<n; i++) PrintFunction(f->p[i],full);
-}
diff --git a/extern/lua-5.1.5/test/README b/extern/lua-5.1.5/test/README
deleted file mode 100644
index 0c7f38bc..00000000
--- a/extern/lua-5.1.5/test/README
+++ /dev/null
@@ -1,26 +0,0 @@
-These are simple tests for Lua.  Some of them contain useful code.
-They are meant to be run to make sure Lua is built correctly and also
-to be read, to see how Lua programs look.
-
-Here is a one-line summary of each program:
-
-   bisect.lua		bisection method for solving non-linear equations
-   cf.lua		temperature conversion table (celsius to farenheit)
-   echo.lua             echo command line arguments
-   env.lua              environment variables as automatic global variables
-   factorial.lua	factorial without recursion
-   fib.lua		fibonacci function with cache
-   fibfor.lua		fibonacci numbers with coroutines and generators
-   globals.lua		report global variable usage
-   hello.lua		the first program in every language
-   life.lua		Conway's Game of Life
-   luac.lua	 	bare-bones luac
-   printf.lua		an implementation of printf
-   readonly.lua		make global variables readonly
-   sieve.lua		the sieve of of Eratosthenes programmed with coroutines
-   sort.lua		two implementations of a sort function
-   table.lua		make table, grouping all data for the same item
-   trace-calls.lua	trace calls
-   trace-globals.lua	trace assigments to global variables
-   xd.lua		hex dump
-
diff --git a/extern/lua-5.1.5/test/bisect.lua b/extern/lua-5.1.5/test/bisect.lua
deleted file mode 100644
index f91e69bf..00000000
--- a/extern/lua-5.1.5/test/bisect.lua
+++ /dev/null
@@ -1,27 +0,0 @@
--- bisection method for solving non-linear equations
-
-delta=1e-6	-- tolerance
-
-function bisect(f,a,b,fa,fb)
- local c=(a+b)/2
- io.write(n," c=",c," a=",a," b=",b,"\n")
- if c==a or c==b or math.abs(a-b)<delta then return c,b-a end
- n=n+1
- local fc=f(c)
- if fa*fc<0 then return bisect(f,a,c,fa,fc) else return bisect(f,c,b,fc,fb) end
-end
-
--- find root of f in the inverval [a,b]. needs f(a)*f(b)<0
-function solve(f,a,b)
- n=0
- local z,e=bisect(f,a,b,f(a),f(b))
- io.write(string.format("after %d steps, root is %.17g with error %.1e, f=%.1e\n",n,z,e,f(z)))
-end
-
--- our function
-function f(x)
- return x*x*x-x-1
-end
-
--- find zero in [1,2]
-solve(f,1,2)
diff --git a/extern/lua-5.1.5/test/cf.lua b/extern/lua-5.1.5/test/cf.lua
deleted file mode 100644
index 8cda54b9..00000000
--- a/extern/lua-5.1.5/test/cf.lua
+++ /dev/null
@@ -1,16 +0,0 @@
--- temperature conversion table (celsius to farenheit)
-
-for c0=-20,50-1,10 do
-	io.write("C ")
-	for c=c0,c0+10-1 do
-		io.write(string.format("%3.0f ",c))
-	end
-	io.write("\n")
-	
-	io.write("F ")
-	for c=c0,c0+10-1 do
-		f=(9/5)*c+32
-		io.write(string.format("%3.0f ",f))
-	end
-	io.write("\n\n")
-end
diff --git a/extern/lua-5.1.5/test/echo.lua b/extern/lua-5.1.5/test/echo.lua
deleted file mode 100644
index 4313439a..00000000
--- a/extern/lua-5.1.5/test/echo.lua
+++ /dev/null
@@ -1,5 +0,0 @@
--- echo command line arguments
-
-for i=0,table.getn(arg) do
- print(i,arg[i])
-end
diff --git a/extern/lua-5.1.5/test/env.lua b/extern/lua-5.1.5/test/env.lua
deleted file mode 100644
index 9e62a57f..00000000
--- a/extern/lua-5.1.5/test/env.lua
+++ /dev/null
@@ -1,7 +0,0 @@
--- read environment variables as if they were global variables
-
-local f=function (t,i) return os.getenv(i) end
-setmetatable(getfenv(),{__index=f})
-
--- an example
-print(a,USER,PATH)
diff --git a/extern/lua-5.1.5/test/factorial.lua b/extern/lua-5.1.5/test/factorial.lua
deleted file mode 100644
index 7c4cf0fa..00000000
--- a/extern/lua-5.1.5/test/factorial.lua
+++ /dev/null
@@ -1,32 +0,0 @@
--- function closures are powerful
-
--- traditional fixed-point operator from functional programming
-Y = function (g)
-      local a = function (f) return f(f) end
-      return a(function (f)
-                 return g(function (x)
-                             local c=f(f)
-                             return c(x)
-                           end)
-               end)
-end
-
-
--- factorial without recursion
-F = function (f)
-      return function (n)
-               if n == 0 then return 1
-               else return n*f(n-1) end
-             end
-    end
-
-factorial = Y(F)   -- factorial is the fixed point of F
-
--- now test it
-function test(x)
-	io.write(x,"! = ",factorial(x),"\n")
-end
-
-for n=0,16 do
-	test(n)
-end
diff --git a/extern/lua-5.1.5/test/fib.lua b/extern/lua-5.1.5/test/fib.lua
deleted file mode 100644
index 97a921b1..00000000
--- a/extern/lua-5.1.5/test/fib.lua
+++ /dev/null
@@ -1,40 +0,0 @@
--- fibonacci function with cache
-
--- very inefficient fibonacci function
-function fib(n)
-	N=N+1
-	if n<2 then
-		return n
-	else
-		return fib(n-1)+fib(n-2)
-	end
-end
-
--- a general-purpose value cache
-function cache(f)
-	local c={}
-	return function (x)
-		local y=c[x]
-		if not y then
-			y=f(x)
-			c[x]=y
-		end
-		return y
-	end
-end
-
--- run and time it
-function test(s,f)
-	N=0
-	local c=os.clock()
-	local v=f(n)
-	local t=os.clock()-c
-	print(s,n,v,t,N)
-end
-
-n=arg[1] or 24		-- for other values, do lua fib.lua XX
-n=tonumber(n)
-print("","n","value","time","evals")
-test("plain",fib)
-fib=cache(fib)
-test("cached",fib)
diff --git a/extern/lua-5.1.5/test/fibfor.lua b/extern/lua-5.1.5/test/fibfor.lua
deleted file mode 100644
index 8bbba39c..00000000
--- a/extern/lua-5.1.5/test/fibfor.lua
+++ /dev/null
@@ -1,13 +0,0 @@
--- example of for with generator functions
-
-function generatefib (n)
-  return coroutine.wrap(function ()
-    local a,b = 1, 1
-    while a <= n do
-      coroutine.yield(a)
-      a, b = b, a+b
-    end
-  end)
-end
-
-for i in generatefib(1000) do print(i) end
diff --git a/extern/lua-5.1.5/test/globals.lua b/extern/lua-5.1.5/test/globals.lua
deleted file mode 100644
index d4c20e15..00000000
--- a/extern/lua-5.1.5/test/globals.lua
+++ /dev/null
@@ -1,13 +0,0 @@
--- reads luac listings and reports global variable usage
--- lines where a global is written to are marked with "*"
--- typical usage: luac -p -l file.lua | lua globals.lua | sort | lua table.lua
-
-while 1 do
- local s=io.read()
- if s==nil then break end
- local ok,_,l,op,g=string.find(s,"%[%-?(%d*)%]%s*([GS])ETGLOBAL.-;%s+(.*)$")
- if ok then
-  if op=="S" then op="*" else op="" end
-  io.write(g,"\t",l,op,"\n")
- end
-end
diff --git a/extern/lua-5.1.5/test/hello.lua b/extern/lua-5.1.5/test/hello.lua
deleted file mode 100644
index 0925498f..00000000
--- a/extern/lua-5.1.5/test/hello.lua
+++ /dev/null
@@ -1,3 +0,0 @@
--- the first program in every language
-
-io.write("Hello world, from ",_VERSION,"!\n")
diff --git a/extern/lua-5.1.5/test/life.lua b/extern/lua-5.1.5/test/life.lua
deleted file mode 100644
index 911d9fe1..00000000
--- a/extern/lua-5.1.5/test/life.lua
+++ /dev/null
@@ -1,111 +0,0 @@
--- life.lua
--- original by Dave Bollinger <DBollinger@compuserve.com> posted to lua-l
--- modified to use ANSI terminal escape sequences
--- modified to use for instead of while
-
-local write=io.write
-
-ALIVE="�"	DEAD="�"
-ALIVE="O"	DEAD="-"
-
-function delay() -- NOTE: SYSTEM-DEPENDENT, adjust as necessary
-  for i=1,10000 do end
-  -- local i=os.clock()+1 while(os.clock()<i) do end
-end
-
-function ARRAY2D(w,h)
-  local t = {w=w,h=h}
-  for y=1,h do
-    t[y] = {}
-    for x=1,w do
-      t[y][x]=0
-    end
-  end
-  return t
-end
-
-_CELLS = {}
-
--- give birth to a "shape" within the cell array
-function _CELLS:spawn(shape,left,top)
-  for y=0,shape.h-1 do
-    for x=0,shape.w-1 do
-      self[top+y][left+x] = shape[y*shape.w+x+1]
-    end
-  end
-end
-
--- run the CA and produce the next generation
-function _CELLS:evolve(next)
-  local ym1,y,yp1,yi=self.h-1,self.h,1,self.h
-  while yi > 0 do
-    local xm1,x,xp1,xi=self.w-1,self.w,1,self.w
-    while xi > 0 do
-      local sum = self[ym1][xm1] + self[ym1][x] + self[ym1][xp1] +
-                  self[y][xm1] + self[y][xp1] +
-                  self[yp1][xm1] + self[yp1][x] + self[yp1][xp1]
-      next[y][x] = ((sum==2) and self[y][x]) or ((sum==3) and 1) or 0
-      xm1,x,xp1,xi = x,xp1,xp1+1,xi-1
-    end
-    ym1,y,yp1,yi = y,yp1,yp1+1,yi-1
-  end
-end
-
--- output the array to screen
-function _CELLS:draw()
-  local out="" -- accumulate to reduce flicker
-  for y=1,self.h do
-   for x=1,self.w do
-      out=out..(((self[y][x]>0) and ALIVE) or DEAD)
-    end
-    out=out.."\n"
-  end
-  write(out)
-end
-
--- constructor
-function CELLS(w,h)
-  local c = ARRAY2D(w,h)
-  c.spawn = _CELLS.spawn
-  c.evolve = _CELLS.evolve
-  c.draw = _CELLS.draw
-  return c
-end
-
---
--- shapes suitable for use with spawn() above
---
-HEART = { 1,0,1,1,0,1,1,1,1; w=3,h=3 }
-GLIDER = { 0,0,1,1,0,1,0,1,1; w=3,h=3 }
-EXPLODE = { 0,1,0,1,1,1,1,0,1,0,1,0; w=3,h=4 }
-FISH = { 0,1,1,1,1,1,0,0,0,1,0,0,0,0,1,1,0,0,1,0; w=5,h=4 }
-BUTTERFLY = { 1,0,0,0,1,0,1,1,1,0,1,0,0,0,1,1,0,1,0,1,1,0,0,0,1; w=5,h=5 }
-
--- the main routine
-function LIFE(w,h)
-  -- create two arrays
-  local thisgen = CELLS(w,h)
-  local nextgen = CELLS(w,h)
-
-  -- create some life
-  -- about 1000 generations of fun, then a glider steady-state
-  thisgen:spawn(GLIDER,5,4)
-  thisgen:spawn(EXPLODE,25,10)
-  thisgen:spawn(FISH,4,12)
-
-  -- run until break
-  local gen=1
-  write("\027[2J")	-- ANSI clear screen
-  while 1 do
-    thisgen:evolve(nextgen)
-    thisgen,nextgen = nextgen,thisgen
-    write("\027[H")	-- ANSI home cursor
-    thisgen:draw()
-    write("Life - generation ",gen,"\n")
-    gen=gen+1
-    if gen>2000 then break end
-    --delay()		-- no delay
-  end
-end
-
-LIFE(40,20)
diff --git a/extern/lua-5.1.5/test/luac.lua b/extern/lua-5.1.5/test/luac.lua
deleted file mode 100644
index 96a0a97c..00000000
--- a/extern/lua-5.1.5/test/luac.lua
+++ /dev/null
@@ -1,7 +0,0 @@
--- bare-bones luac in Lua
--- usage: lua luac.lua file.lua
-
-assert(arg[1]~=nil and arg[2]==nil,"usage: lua luac.lua file.lua")
-f=assert(io.open("luac.out","wb"))
-assert(f:write(string.dump(assert(loadfile(arg[1])))))
-assert(f:close())
diff --git a/extern/lua-5.1.5/test/printf.lua b/extern/lua-5.1.5/test/printf.lua
deleted file mode 100644
index 58c63ff5..00000000
--- a/extern/lua-5.1.5/test/printf.lua
+++ /dev/null
@@ -1,7 +0,0 @@
--- an implementation of printf
-
-function printf(...)
- io.write(string.format(...))
-end
-
-printf("Hello %s from %s on %s\n",os.getenv"USER" or "there",_VERSION,os.date())
diff --git a/extern/lua-5.1.5/test/readonly.lua b/extern/lua-5.1.5/test/readonly.lua
deleted file mode 100644
index 85c0b4e0..00000000
--- a/extern/lua-5.1.5/test/readonly.lua
+++ /dev/null
@@ -1,12 +0,0 @@
--- make global variables readonly
-
-local f=function (t,i) error("cannot redefine global variable `"..i.."'",2) end
-local g={}
-local G=getfenv()
-setmetatable(g,{__index=G,__newindex=f})
-setfenv(1,g)
-
--- an example
-rawset(g,"x",3)
-x=2
-y=1	-- cannot redefine `y'
diff --git a/extern/lua-5.1.5/test/sieve.lua b/extern/lua-5.1.5/test/sieve.lua
deleted file mode 100644
index 0871bb21..00000000
--- a/extern/lua-5.1.5/test/sieve.lua
+++ /dev/null
@@ -1,29 +0,0 @@
--- the sieve of of Eratosthenes programmed with coroutines
--- typical usage: lua -e N=1000 sieve.lua | column
-
--- generate all the numbers from 2 to n
-function gen (n)
-  return coroutine.wrap(function ()
-    for i=2,n do coroutine.yield(i) end
-  end)
-end
-
--- filter the numbers generated by `g', removing multiples of `p'
-function filter (p, g)
-  return coroutine.wrap(function ()
-    while 1 do
-      local n = g()
-      if n == nil then return end
-      if math.mod(n, p) ~= 0 then coroutine.yield(n) end
-    end
-  end)
-end
-
-N=N or 1000		-- from command line
-x = gen(N)		-- generate primes up to N
-while 1 do
-  local n = x()		-- pick a number until done
-  if n == nil then break end
-  print(n)		-- must be a prime number
-  x = filter(n, x)	-- now remove its multiples
-end
diff --git a/extern/lua-5.1.5/test/sort.lua b/extern/lua-5.1.5/test/sort.lua
deleted file mode 100644
index 0bcb15f8..00000000
--- a/extern/lua-5.1.5/test/sort.lua
+++ /dev/null
@@ -1,66 +0,0 @@
--- two implementations of a sort function
--- this is an example only. Lua has now a built-in function "sort"
-
--- extracted from Programming Pearls, page 110
-function qsort(x,l,u,f)
- if l<u then
-  local m=math.random(u-(l-1))+l-1	-- choose a random pivot in range l..u
-  x[l],x[m]=x[m],x[l]			-- swap pivot to first position
-  local t=x[l]				-- pivot value
-  m=l
-  local i=l+1
-  while i<=u do
-    -- invariant: x[l+1..m] < t <= x[m+1..i-1]
-    if f(x[i],t) then
-      m=m+1
-      x[m],x[i]=x[i],x[m]		-- swap x[i] and x[m]
-    end
-    i=i+1
-  end
-  x[l],x[m]=x[m],x[l]			-- swap pivot to a valid place
-  -- x[l+1..m-1] < x[m] <= x[m+1..u]
-  qsort(x,l,m-1,f)
-  qsort(x,m+1,u,f)
- end
-end
-
-function selectionsort(x,n,f)
- local i=1
- while i<=n do
-  local m,j=i,i+1
-  while j<=n do
-   if f(x[j],x[m]) then m=j end
-   j=j+1
-  end
- x[i],x[m]=x[m],x[i]			-- swap x[i] and x[m]
- i=i+1
- end
-end
-
-function show(m,x)
- io.write(m,"\n\t")
- local i=1
- while x[i] do
-  io.write(x[i])
-  i=i+1
-  if x[i] then io.write(",") end
- end
- io.write("\n")
-end
-
-function testsorts(x)
- local n=1
- while x[n] do n=n+1 end; n=n-1		-- count elements
- show("original",x)
- qsort(x,1,n,function (x,y) return x<y end)
- show("after quicksort",x)
- selectionsort(x,n,function (x,y) return x>y end)
- show("after reverse selection sort",x)
- qsort(x,1,n,function (x,y) return x<y end)
- show("after quicksort again",x)
-end
-
--- array to be sorted
-x={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"}
-
-testsorts(x)
diff --git a/extern/lua-5.1.5/test/table.lua b/extern/lua-5.1.5/test/table.lua
deleted file mode 100644
index 235089c0..00000000
--- a/extern/lua-5.1.5/test/table.lua
+++ /dev/null
@@ -1,12 +0,0 @@
--- make table, grouping all data for the same item
--- input is 2 columns (item, data)
-
-local A
-while 1 do
- local l=io.read()
- if l==nil then break end
- local _,_,a,b=string.find(l,'"?([_%w]+)"?%s*(.*)$')
- if a~=A then A=a io.write("\n",a,":") end
- io.write(" ",b)
-end
-io.write("\n")
diff --git a/extern/lua-5.1.5/test/trace-calls.lua b/extern/lua-5.1.5/test/trace-calls.lua
deleted file mode 100644
index 6d7a7b3b..00000000
--- a/extern/lua-5.1.5/test/trace-calls.lua
+++ /dev/null
@@ -1,32 +0,0 @@
--- trace calls
--- example: lua -ltrace-calls bisect.lua
-
-local level=0
-
-local function hook(event)
- local t=debug.getinfo(3)
- io.write(level," >>> ",string.rep(" ",level))
- if t~=nil and t.currentline>=0 then io.write(t.short_src,":",t.currentline," ") end
- t=debug.getinfo(2)
- if event=="call" then
-  level=level+1
- else
-  level=level-1 if level<0 then level=0 end
- end
- if t.what=="main" then
-  if event=="call" then
-   io.write("begin ",t.short_src)
-  else
-   io.write("end ",t.short_src)
-  end
- elseif t.what=="Lua" then
--- table.foreach(t,print)
-  io.write(event," ",t.name or "(Lua)"," <",t.linedefined,":",t.short_src,">")
- else
- io.write(event," ",t.name or "(C)"," [",t.what,"] ")
- end
- io.write("\n")
-end
-
-debug.sethook(hook,"cr")
-level=0
diff --git a/extern/lua-5.1.5/test/trace-globals.lua b/extern/lua-5.1.5/test/trace-globals.lua
deleted file mode 100644
index 295e670c..00000000
--- a/extern/lua-5.1.5/test/trace-globals.lua
+++ /dev/null
@@ -1,38 +0,0 @@
--- trace assigments to global variables
-
-do
- -- a tostring that quotes strings. note the use of the original tostring.
- local _tostring=tostring
- local tostring=function(a)
-  if type(a)=="string" then
-   return string.format("%q",a)
-  else
-   return _tostring(a)
-  end
- end
-
- local log=function (name,old,new)
-  local t=debug.getinfo(3,"Sl")
-  local line=t.currentline
-  io.write(t.short_src)
-  if line>=0 then io.write(":",line) end
-  io.write(": ",name," is now ",tostring(new)," (was ",tostring(old),")","\n")
- end
-
- local g={}
- local set=function (t,name,value)
-  log(name,g[name],value)
-  g[name]=value
- end
- setmetatable(getfenv(),{__index=g,__newindex=set})
-end
-
--- an example
-
-a=1
-b=2
-a=10
-b=20
-b=nil
-b=200
-print(a,b,c)
diff --git a/extern/lua-5.1.5/test/xd.lua b/extern/lua-5.1.5/test/xd.lua
deleted file mode 100644
index ebc3effc..00000000
--- a/extern/lua-5.1.5/test/xd.lua
+++ /dev/null
@@ -1,14 +0,0 @@
--- hex dump
--- usage: lua xd.lua < file
-
-local offset=0
-while true do
- local s=io.read(16)
- if s==nil then return end
- io.write(string.format("%08X  ",offset))
- string.gsub(s,"(.)",
-	function (c) io.write(string.format("%02X ",string.byte(c))) end)
- io.write(string.rep(" ",3*(16-string.len(s))))
- io.write(" ",string.gsub(s,"%c","."),"\n") 
- offset=offset+16
-end
diff --git a/include/addons/addon_manager.hpp b/include/addons/addon_manager.hpp
deleted file mode 100644
index 83e98928..00000000
--- a/include/addons/addon_manager.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-
-#include "addons/lua_engine.hpp"
-#include "addons/toc_parser.hpp"
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace wowee::addons {
-
-class AddonManager {
-public:
-    AddonManager();
-    ~AddonManager();
-
-    bool initialize(game::GameHandler* gameHandler, const LuaServices& services = {});
-    void scanAddons(const std::string& addonsPath);
-    void loadAllAddons();
-    bool runScript(const std::string& code);
-    void fireEvent(const std::string& event, const std::vector<std::string>& args = {});
-    void update(float deltaTime);
-    void shutdown();
-
-    const std::vector<TocFile>& getAddons() const { return addons_; }
-    LuaEngine* getLuaEngine() { return &luaEngine_; }
-    bool isInitialized() const { return luaEngine_.isInitialized(); }
-
-    void saveAllSavedVariables();
-    void setCharacterName(const std::string& name) { characterName_ = name; }
-
-    /// Re-initialize the Lua VM and reload all addons (used by /reload).
-    bool reload();
-
-private:
-    LuaEngine luaEngine_;
-    std::vector<TocFile> addons_;
-    game::GameHandler* gameHandler_ = nullptr;
-    LuaServices luaServices_;
-    std::string addonsPath_;
-
-    bool loadAddon(const TocFile& addon);
-    std::string getSavedVariablesPath(const TocFile& addon) const;
-    std::string getSavedVariablesPerCharacterPath(const TocFile& addon) const;
-    std::string characterName_;
-};
-
-} // namespace wowee::addons
diff --git a/include/addons/lua_api_helpers.hpp b/include/addons/lua_api_helpers.hpp
deleted file mode 100644
index 0c6642ec..00000000
--- a/include/addons/lua_api_helpers.hpp
+++ /dev/null
@@ -1,166 +0,0 @@
-// lua_api_helpers.hpp — Shared helpers, lookup tables, and utility functions
-// used by all lua_*_api.cpp domain files.
-// Extracted from lua_engine.cpp as part of §5.1 (Tame LuaEngine).
-#pragma once
-
-#include <string>
-#include <chrono>
-#include <cstring>
-#include <algorithm>
-
-#include "addons/lua_services.hpp"
-#include "game/game_handler.hpp"
-#include "game/entity.hpp"
-#include "game/update_field_table.hpp"
-#include "core/logger.hpp"
-
-extern "C" {
-#include <lua.h>
-#include <lauxlib.h>
-#include <lualib.h>
-}
-
-namespace wowee::addons {
-
-// ---- String helper ----
-inline void toLowerInPlace(std::string& s) {
-    for (char& c : s) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-}
-
-// ---- Lua return helpers — used 200+ times as guard/fallback returns ----
-inline int luaReturnNil(lua_State* L)  { lua_pushnil(L); return 1; }
-inline int luaReturnZero(lua_State* L) { lua_pushnumber(L, 0); return 1; }
-inline int luaReturnFalse(lua_State* L){ lua_pushboolean(L, 0); return 1; }
-
-// ---- Shared GetTime() epoch ----
-// All time-returning functions must use this same origin
-// so that addon calculations like (start + duration - GetTime()) are consistent.
-inline const auto& luaTimeEpoch() {
-    static const auto epoch = std::chrono::steady_clock::now();
-    return epoch;
-}
-
-inline double luaGetTimeNow() {
-    return std::chrono::duration<double>(std::chrono::steady_clock::now() - luaTimeEpoch()).count();
-}
-
-// ---- Shared WoW class/race/power name tables (indexed by ID, element 0 = unknown) ----
-inline constexpr const char* kLuaClasses[] = {
-    "","Warrior","Paladin","Hunter","Rogue","Priest",
-    "Death Knight","Shaman","Mage","Warlock","","Druid"
-};
-inline constexpr const char* kLuaRaces[] = {
-    "","Human","Orc","Dwarf","Night Elf","Undead",
-    "Tauren","Gnome","Troll","","Blood Elf","Draenei"
-};
-inline constexpr const char* kLuaPowerNames[] = {
-    "MANA","RAGE","FOCUS","ENERGY","HAPPINESS","","RUNIC_POWER"
-};
-
-// ---- Quality hex strings ----
-// No alpha prefix — for item links
-inline constexpr const char* kQualHexNoAlpha[] = {
-    "9d9d9d","ffffff","1eff00","0070dd","a335ee","ff8000","e6cc80","e6cc80"
-};
-// With ff alpha prefix — for Lua color returns
-inline constexpr const char* kQualHexAlpha[] = {
-    "ff9d9d9d","ffffffff","ff1eff00","ff0070dd","ffa335ee","ffff8000","ffe6cc80","ff00ccff"
-};
-
-// ---- Retrieve GameHandler pointer stored in Lua registry ----
-inline game::GameHandler* getGameHandler(lua_State* L) {
-    lua_getfield(L, LUA_REGISTRYINDEX, "wowee_game_handler");
-    auto* gh = static_cast<game::GameHandler*>(lua_touserdata(L, -1));
-    lua_pop(L, 1);
-    return gh;
-}
-
-// ---- Retrieve LuaServices pointer stored in Lua registry ----
-inline LuaServices* getLuaServices(lua_State* L) {
-    lua_getfield(L, LUA_REGISTRYINDEX, "wowee_lua_services");
-    auto* svc = static_cast<LuaServices*>(lua_touserdata(L, -1));
-    lua_pop(L, 1);
-    return svc;
-}
-
-// ---- Unit resolution helpers ----
-
-// Read UNIT_FIELD_TARGET_LO/HI from an entity's update fields to get what it's targeting
-inline uint64_t getEntityTargetGuid(game::GameHandler* gh, uint64_t guid) {
-    if (guid == 0) return 0;
-    // If asking for the player's target, use direct accessor
-    if (guid == gh->getPlayerGuid()) return gh->getTargetGuid();
-    auto entity = gh->getEntityManager().getEntity(guid);
-    if (!entity) return 0;
-    const auto& fields = entity->getFields();
-    auto loIt = fields.find(game::fieldIndex(game::UF::UNIT_FIELD_TARGET_LO));
-    if (loIt == fields.end()) return 0;
-    uint64_t targetGuid = loIt->second;
-    auto hiIt = fields.find(game::fieldIndex(game::UF::UNIT_FIELD_TARGET_HI));
-    if (hiIt != fields.end())
-        targetGuid |= (static_cast<uint64_t>(hiIt->second) << 32);
-    return targetGuid;
-}
-
-// Resolve WoW unit IDs to GUID
-inline uint64_t resolveUnitGuid(game::GameHandler* gh, const std::string& uid) {
-    if (uid == "player")      return gh->getPlayerGuid();
-    if (uid == "target")      return gh->getTargetGuid();
-    if (uid == "focus")       return gh->getFocusGuid();
-    if (uid == "mouseover")   return gh->getMouseoverGuid();
-    if (uid == "pet")         return gh->getPetGuid();
-    // Compound unit IDs: targettarget, focustarget, pettarget, mouseovertarget
-    if (uid == "targettarget")    return getEntityTargetGuid(gh, gh->getTargetGuid());
-    if (uid == "focustarget")     return getEntityTargetGuid(gh, gh->getFocusGuid());
-    if (uid == "pettarget")       return getEntityTargetGuid(gh, gh->getPetGuid());
-    if (uid == "mouseovertarget") return getEntityTargetGuid(gh, gh->getMouseoverGuid());
-    // party1-party4, raid1-raid40
-    if (uid.rfind("party", 0) == 0 && uid.size() > 5) {
-        int idx = 0;
-        try { idx = std::stoi(uid.substr(5)); } catch (...) { return 0; }
-        if (idx < 1 || idx > 4) return 0;
-        const auto& pd = gh->getPartyData();
-        // party members exclude self; index 1-based
-        int found = 0;
-        for (const auto& m : pd.members) {
-            if (m.guid == gh->getPlayerGuid()) continue;
-            if (++found == idx) return m.guid;
-        }
-        return 0;
-    }
-    if (uid.rfind("raid", 0) == 0 && uid.size() > 4 && uid[4] != 'p') {
-        int idx = 0;
-        try { idx = std::stoi(uid.substr(4)); } catch (...) { return 0; }
-        if (idx < 1 || idx > 40) return 0;
-        const auto& pd = gh->getPartyData();
-        if (idx <= static_cast<int>(pd.members.size()))
-            return pd.members[idx - 1].guid;
-        return 0;
-    }
-    return 0;
-}
-
-// Resolve unit IDs (player, target, focus, mouseover, pet, targettarget, etc.) to entity
-inline game::Unit* resolveUnit(lua_State* L, const char* unitId) {
-    auto* gh = getGameHandler(L);
-    if (!gh || !unitId) return nullptr;
-    std::string uid(unitId);
-    toLowerInPlace(uid);
-
-    uint64_t guid = resolveUnitGuid(gh, uid);
-    if (guid == 0) return nullptr;
-    auto entity = gh->getEntityManager().getEntity(guid);
-    if (!entity) return nullptr;
-    return dynamic_cast<game::Unit*>(entity.get());
-}
-
-// Find GroupMember data for a GUID (for party members out of entity range)
-inline const game::GroupMember* findPartyMember(game::GameHandler* gh, uint64_t guid) {
-    if (!gh || guid == 0) return nullptr;
-    for (const auto& m : gh->getPartyData().members) {
-        if (m.guid == guid && m.hasPartyStats) return &m;
-    }
-    return nullptr;
-}
-
-} // namespace wowee::addons
diff --git a/include/addons/lua_api_registrations.hpp b/include/addons/lua_api_registrations.hpp
deleted file mode 100644
index 2da1eb80..00000000
--- a/include/addons/lua_api_registrations.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-// lua_api_registrations.hpp — Forward declarations for per-domain Lua API
-// registration functions.  Called from LuaEngine::registerCoreAPI().
-// Extracted from lua_engine.cpp as part of §5.1 (Tame LuaEngine).
-#pragma once
-
-struct lua_State;
-
-namespace wowee::addons {
-
-void registerUnitLuaAPI(lua_State* L);
-void registerSpellLuaAPI(lua_State* L);
-void registerInventoryLuaAPI(lua_State* L);
-void registerQuestLuaAPI(lua_State* L);
-void registerSocialLuaAPI(lua_State* L);
-void registerSystemLuaAPI(lua_State* L);
-void registerActionLuaAPI(lua_State* L);
-
-} // namespace wowee::addons
diff --git a/include/addons/lua_engine.hpp b/include/addons/lua_engine.hpp
deleted file mode 100644
index d53c19f8..00000000
--- a/include/addons/lua_engine.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#pragma once
-
-#include "addons/lua_services.hpp"
-#include <functional>
-#include <string>
-#include <vector>
-
-struct lua_State;
-
-namespace wowee::game { class GameHandler; }
-
-namespace wowee::addons {
-
-struct TocFile;  // forward declaration
-
-class LuaEngine {
-public:
-    LuaEngine();
-    ~LuaEngine();
-
-    LuaEngine(const LuaEngine&) = delete;
-    LuaEngine& operator=(const LuaEngine&) = delete;
-
-    bool initialize();
-    void shutdown();
-
-    bool executeFile(const std::string& path);
-    bool executeString(const std::string& code);
-
-    void setGameHandler(game::GameHandler* handler);
-    void setLuaServices(const LuaServices& services);
-
-    // Fire a WoW event to all registered Lua handlers.
-    void fireEvent(const std::string& eventName,
-                   const std::vector<std::string>& args = {});
-
-    // Try to dispatch a slash command via SlashCmdList. Returns true if handled.
-    bool dispatchSlashCommand(const std::string& command, const std::string& args);
-
-    // Call OnUpdate scripts on all frames that have one.
-    void dispatchOnUpdate(float elapsed);
-
-    // SavedVariables: load globals from file, save globals to file
-    bool loadSavedVariables(const std::string& path);
-    bool saveSavedVariables(const std::string& path, const std::vector<std::string>& varNames);
-
-    // Store addon info in registry for GetAddOnInfo/GetNumAddOns
-    void setAddonList(const std::vector<TocFile>& addons);
-
-    lua_State* getState() { return L_; }
-    bool isInitialized() const { return L_ != nullptr; }
-
-    // Optional callback for Lua errors (displayed as UI errors to the player)
-    using LuaErrorCallback = std::function<void(const std::string&)>;
-    void setLuaErrorCallback(LuaErrorCallback cb) { luaErrorCallback_ = std::move(cb); }
-
-private:
-    lua_State* L_ = nullptr;
-    game::GameHandler* gameHandler_ = nullptr;
-    LuaServices luaServices_;
-    LuaErrorCallback luaErrorCallback_;
-
-    void registerCoreAPI();
-    void registerEventAPI();
-};
-
-} // namespace wowee::addons
diff --git a/include/addons/lua_services.hpp b/include/addons/lua_services.hpp
deleted file mode 100644
index adba58d7..00000000
--- a/include/addons/lua_services.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-// lua_services.hpp — Dependency-injected services for Lua bindings.
-// Replaces Application::getInstance() calls in domain API files (§5.2).
-#pragma once
-
-namespace wowee::core  { class Window; }
-namespace wowee::audio { class AudioCoordinator; }
-namespace wowee::game  { class ExpansionRegistry; }
-
-namespace wowee::addons {
-
-struct LuaServices {
-    core::Window*            window            = nullptr;
-    audio::AudioCoordinator* audioCoordinator  = nullptr;
-    game::ExpansionRegistry* expansionRegistry = nullptr;
-};
-
-} // namespace wowee::addons
diff --git a/include/addons/toc_parser.hpp b/include/addons/toc_parser.hpp
deleted file mode 100644
index b19b4a78..00000000
--- a/include/addons/toc_parser.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#pragma once
-
-#include <optional>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-namespace wowee::addons {
-
-struct TocFile {
-    std::string addonName;
-    std::string basePath;
-
-    std::unordered_map<std::string, std::string> directives;
-    std::vector<std::string> files;
-
-    std::string getTitle() const;
-    std::string getInterface() const;
-    bool isLoadOnDemand() const;
-    std::vector<std::string> getSavedVariables() const;
-    std::vector<std::string> getSavedVariablesPerCharacter() const;
-};
-
-std::optional<TocFile> parseTocFile(const std::string& tocPath);
-
-} // namespace wowee::addons
diff --git a/include/audio/audio_coordinator.hpp b/include/audio/audio_coordinator.hpp
deleted file mode 100644
index f181164f..00000000
--- a/include/audio/audio_coordinator.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#pragma once
-
-#include <memory>
-
-namespace wowee {
-namespace pipeline { class AssetManager; }
-namespace audio {
-
-class MusicManager;
-class FootstepManager;
-class ActivitySoundManager;
-class MountSoundManager;
-class NpcVoiceManager;
-class AmbientSoundManager;
-class UiSoundManager;
-class CombatSoundManager;
-class SpellSoundManager;
-class MovementSoundManager;
-
-/// Coordinates all audio subsystems.
-/// Extracted from Renderer to separate audio lifecycle from rendering.
-/// Owned by Application; Renderer and UI components access through Application.
-class AudioCoordinator {
-public:
-    AudioCoordinator();
-    ~AudioCoordinator();
-
-    /// Initialize the audio engine and all managers.
-    /// @return true if audio is available (engine initialized successfully)
-    bool initialize();
-
-    /// Initialize managers that need AssetManager (music lookups, sound banks).
-    void initializeWithAssets(pipeline::AssetManager* assetManager);
-
-    /// Shutdown all audio managers and engine.
-    void shutdown();
-
-    // Accessors for all audio managers (same interface as Renderer had)
-    MusicManager* getMusicManager() { return musicManager_.get(); }
-    FootstepManager* getFootstepManager() { return footstepManager_.get(); }
-    ActivitySoundManager* getActivitySoundManager() { return activitySoundManager_.get(); }
-    MountSoundManager* getMountSoundManager() { return mountSoundManager_.get(); }
-    NpcVoiceManager* getNpcVoiceManager() { return npcVoiceManager_.get(); }
-    AmbientSoundManager* getAmbientSoundManager() { return ambientSoundManager_.get(); }
-    UiSoundManager* getUiSoundManager() { return uiSoundManager_.get(); }
-    CombatSoundManager* getCombatSoundManager() { return combatSoundManager_.get(); }
-    SpellSoundManager* getSpellSoundManager() { return spellSoundManager_.get(); }
-    MovementSoundManager* getMovementSoundManager() { return movementSoundManager_.get(); }
-
-private:
-    std::unique_ptr<MusicManager> musicManager_;
-    std::unique_ptr<FootstepManager> footstepManager_;
-    std::unique_ptr<ActivitySoundManager> activitySoundManager_;
-    std::unique_ptr<MountSoundManager> mountSoundManager_;
-    std::unique_ptr<NpcVoiceManager> npcVoiceManager_;
-    std::unique_ptr<AmbientSoundManager> ambientSoundManager_;
-    std::unique_ptr<UiSoundManager> uiSoundManager_;
-    std::unique_ptr<CombatSoundManager> combatSoundManager_;
-    std::unique_ptr<SpellSoundManager> spellSoundManager_;
-    std::unique_ptr<MovementSoundManager> movementSoundManager_;
-
-    bool audioAvailable_ = false;
-};
-
-} // namespace audio
-} // namespace wowee
diff --git a/include/audio/audio_engine.hpp b/include/audio/audio_engine.hpp
index c6d5e723..20015330 100644
--- a/include/audio/audio_engine.hpp
+++ b/include/audio/audio_engine.hpp
@@ -45,11 +45,6 @@ public:
     bool playSound2D(const std::vector<uint8_t>& wavData, float volume = 1.0f, float pitch = 1.0f);
     bool playSound2D(const std::string& mpqPath, float volume = 1.0f, float pitch = 1.0f);
 
-    // Stoppable 2D sound — returns a non-zero handle, or 0 on failure
-    uint32_t playSound2DStoppable(const std::vector<uint8_t>& wavData, float volume = 1.0f);
-    // Stop a sound started with playSound2DStoppable (no-op if already finished)
-    void stopSound(uint32_t id);
-
     // 3D positional sound playback
     bool playSound3D(const std::vector<uint8_t>& wavData, const glm::vec3& position,
                      float volume = 1.0f, float pitch = 1.0f, float maxDistance = 100.0f);
@@ -75,10 +70,8 @@ private:
         ma_sound* sound;
         void* buffer;  // ma_audio_buffer* - Keep audio buffer alive
         std::shared_ptr<const std::vector<uint8_t>> pcmDataRef;  // Keep decoded PCM alive
-        uint32_t id = 0;  // 0 = anonymous (not stoppable)
     };
     std::vector<ActiveSound> activeSounds_;
-    uint32_t nextSoundId_ = 1;
 
     // Music track state
     ma_sound* musicSound_ = nullptr;
diff --git a/include/audio/npc_voice_manager.hpp b/include/audio/npc_voice_manager.hpp
index 1bf722fd..92ab8f32 100644
--- a/include/audio/npc_voice_manager.hpp
+++ b/include/audio/npc_voice_manager.hpp
@@ -38,10 +38,6 @@ enum class VoiceType {
     GNOME_FEMALE,
     GOBLIN_MALE,
     GOBLIN_FEMALE,
-    BLOODELF_MALE,
-    BLOODELF_FEMALE,
-    DRAENEI_MALE,
-    DRAENEI_FEMALE,
     GENERIC,  // Fallback
 };
 
diff --git a/include/audio/spell_sound_manager.hpp b/include/audio/spell_sound_manager.hpp
index d0273c82..1933a7aa 100644
--- a/include/audio/spell_sound_manager.hpp
+++ b/include/audio/spell_sound_manager.hpp
@@ -45,7 +45,6 @@ public:
 
     // Spell casting sounds
     void playPrecast(MagicSchool school, SpellPower power);  // Channeling/preparation
-    void stopPrecast();                                       // Stop precast sound early
     void playCast(MagicSchool school);                        // When spell fires
     void playImpact(MagicSchool school, SpellPower power);    // When spell hits target
 
@@ -97,7 +96,6 @@ private:
     // State tracking
     float volumeScale_ = 1.0f;
     bool initialized_ = false;
-    uint32_t activePrecastId_ = 0;  // Handle from AudioEngine::playSound2DStoppable()
 
     // Helper methods
     bool loadSound(const std::string& path, SpellSample& sample, pipeline::AssetManager* assets);
diff --git a/include/audio/ui_sound_manager.hpp b/include/audio/ui_sound_manager.hpp
index 7a9a66b8..241014ae 100644
--- a/include/audio/ui_sound_manager.hpp
+++ b/include/audio/ui_sound_manager.hpp
@@ -75,12 +75,6 @@ public:
     void playTargetSelect();
     void playTargetDeselect();
 
-    // Chat notifications
-    void playWhisperReceived();
-
-    // Minimap ping
-    void playMinimapPing();
-
 private:
     struct UISample {
         std::string path;
@@ -128,8 +122,6 @@ private:
     std::vector<UISample> errorSounds_;
     std::vector<UISample> selectTargetSounds_;
     std::vector<UISample> deselectTargetSounds_;
-    std::vector<UISample> whisperSounds_;
-    std::vector<UISample> minimapPingSounds_;
 
     // State tracking
     float volumeScale_ = 1.0f;
diff --git a/include/core/appearance_composer.hpp b/include/core/appearance_composer.hpp
deleted file mode 100644
index d38ab53c..00000000
--- a/include/core/appearance_composer.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#pragma once
-
-#include "game/character.hpp"
-#include <string>
-#include <vector>
-#include <unordered_set>
-#include <cstdint>
-
-namespace wowee {
-
-namespace rendering { class Renderer; }
-namespace pipeline { class AssetManager; class DBCLayout; struct M2Model; }
-namespace game { class GameHandler; }
-
-namespace core {
-
-class EntitySpawner;
-
-// Default (bare) geoset IDs per equipment group.
-// Each group's base is groupNumber * 100; variant 01 is typically bare/default.
-constexpr uint16_t kGeosetDefaultConnector = 101;   // Group  1: default hair connector
-constexpr uint16_t kGeosetBareForearms     = 401;   // Group  4: no gloves
-constexpr uint16_t kGeosetBareShins        = 503;   // Group  5: no boots
-constexpr uint16_t kGeosetDefaultEars      = 702;   // Group  7: ears
-constexpr uint16_t kGeosetBareSleeves      = 801;   // Group  8: no chest armor sleeves
-constexpr uint16_t kGeosetDefaultKneepads  = 902;   // Group  9: kneepads
-constexpr uint16_t kGeosetDefaultTabard    = 1201;  // Group 12: tabard base
-constexpr uint16_t kGeosetBarePants        = 1301;  // Group 13: no leggings
-constexpr uint16_t kGeosetNoCape           = 1501;  // Group 15: no cape
-constexpr uint16_t kGeosetWithCape         = 1502;  // Group 15: with cape
-constexpr uint16_t kGeosetBareFeet         = 2002;  // Group 20: bare feet
-
-/// Resolved texture paths from CharSections.dbc for player character compositing.
-struct PlayerTextureInfo {
-    std::string bodySkinPath;
-    std::string faceLowerPath;
-    std::string faceUpperPath;
-    std::string hairTexturePath;
-    std::vector<std::string> underwearPaths;
-};
-
-/// Handles player character visual appearance: skin compositing, geoset selection,
-/// texture path lookups, and equipment weapon rendering.
-class AppearanceComposer {
-public:
-    AppearanceComposer(rendering::Renderer* renderer,
-                       pipeline::AssetManager* assetManager,
-                       game::GameHandler* gameHandler,
-                       pipeline::DBCLayout* dbcLayout,
-                       EntitySpawner* entitySpawner);
-
-    // Player model path resolution
-    std::string getPlayerModelPath(game::Race race, game::Gender gender) const;
-
-    // Resolve texture paths from CharSections.dbc and fill model texture slots.
-    // Call BEFORE charRenderer->loadModel().
-    PlayerTextureInfo resolvePlayerTextures(pipeline::M2Model& model,
-                                           game::Race race, game::Gender gender,
-                                           uint32_t appearanceBytes);
-
-    // Apply composited textures to loaded model instance.
-    // Call AFTER charRenderer->loadModel(). Saves skin state for re-compositing.
-    void compositePlayerSkin(uint32_t modelSlotId, const PlayerTextureInfo& texInfo);
-
-    // Build default active geosets for player character
-    std::unordered_set<uint16_t> buildDefaultPlayerGeosets(uint8_t raceId, uint8_t sexId,
-                                                           uint8_t hairStyleId, uint8_t facialId);
-
-    // Equipment weapon loading (reads inventory, attaches weapon M2 models)
-    void loadEquippedWeapons();
-
-    // Weapon sheathe state
-    void setWeaponsSheathed(bool sheathed) { weaponsSheathed_ = sheathed; }
-    bool isWeaponsSheathed() const { return weaponsSheathed_; }
-    void toggleWeaponsSheathed() { weaponsSheathed_ = !weaponsSheathed_; }
-
-    // Saved skin state accessors (used by game_screen.cpp for equipment re-compositing)
-    const std::string& getBodySkinPath() const { return bodySkinPath_; }
-    const std::vector<std::string>& getUnderwearPaths() const { return underwearPaths_; }
-    uint32_t getSkinTextureSlotIndex() const { return skinTextureSlotIndex_; }
-    uint32_t getCloakTextureSlotIndex() const { return cloakTextureSlotIndex_; }
-
-private:
-    bool loadWeaponM2(const std::string& m2Path, pipeline::M2Model& outModel);
-
-    rendering::Renderer* renderer_;
-    pipeline::AssetManager* assetManager_;
-    game::GameHandler* gameHandler_;
-    pipeline::DBCLayout* dbcLayout_;
-    EntitySpawner* entitySpawner_;
-
-    // Saved at spawn for skin re-compositing on equipment changes
-    std::string bodySkinPath_;
-    std::vector<std::string> underwearPaths_;
-    uint32_t skinTextureSlotIndex_ = 0;
-    uint32_t cloakTextureSlotIndex_ = 0;
-
-    bool weaponsSheathed_ = false;
-};
-
-} // namespace core
-} // namespace wowee
diff --git a/include/core/application.hpp b/include/core/application.hpp
index 148131ac..4d10acc7 100644
--- a/include/core/application.hpp
+++ b/include/core/application.hpp
@@ -2,11 +2,7 @@
 
 #include "core/window.hpp"
 #include "core/input.hpp"
-#include "core/entity_spawner.hpp"
-#include "core/appearance_composer.hpp"
-#include "core/world_loader.hpp"
 #include "game/character.hpp"
-#include "game/game_services.hpp"
 #include "pipeline/blp_loader.hpp"
 #include <memory>
 #include <string>
@@ -29,8 +25,7 @@ namespace ui { class UIManager; }
 namespace auth { class AuthHandler; }
 namespace game { class GameHandler; class World; class ExpansionRegistry; }
 namespace pipeline { class AssetManager; class DBCLayout; struct M2Model; struct WMOModel; }
-namespace audio { enum class VoiceType; class AudioCoordinator; }
-namespace addons { class AddonManager; }
+namespace audio { enum class VoiceType; }
 
 namespace core {
 
@@ -44,8 +39,6 @@ enum class AppState {
 };
 
 class Application {
-    friend class WorldLoader;
-
 public:
     Application();
     ~Application();
@@ -69,7 +62,6 @@ public:
     game::GameHandler* getGameHandler() { return gameHandler.get(); }
     game::World* getWorld() { return world.get(); }
     pipeline::AssetManager* getAssetManager() { return assetManager.get(); }
-    addons::AddonManager* getAddonManager() { return addonManager_.get(); }
     game::ExpansionRegistry* getExpansionRegistry() { return expansionRegistry_.get(); }
     pipeline::DBCLayout* getDBCLayout() { return dbcLayout_.get(); }
     void reloadExpansionData(); // Reload DBC layouts, opcodes, etc. after expansion change
@@ -77,47 +69,58 @@ public:
     // Singleton access
     static Application& getInstance() { return *instance; }
 
-
+    // Weapon loading (called at spawn and on equipment change)
+    void loadEquippedWeapons();
 
     // Logout to login screen
     void logoutToLogin();
 
-    // Render bounds lookup (for click targeting / selection) — delegates to EntitySpawner
+    // Render bounds lookup (for click targeting / selection)
     bool getRenderBoundsForGuid(uint64_t guid, glm::vec3& outCenter, float& outRadius) const;
     bool getRenderFootZForGuid(uint64_t guid, float& outFootZ) const;
-    bool getRenderPositionForGuid(uint64_t guid, glm::vec3& outPos) const;
 
-    // Character skin composite state — delegated to AppearanceComposer
-    const std::string& getBodySkinPath() const { return appearanceComposer_ ? appearanceComposer_->getBodySkinPath() : emptyString_; }
-    const std::vector<std::string>& getUnderwearPaths() const { return appearanceComposer_ ? appearanceComposer_->getUnderwearPaths() : emptyStringVec_; }
-    uint32_t getSkinTextureSlotIndex() const { return appearanceComposer_ ? appearanceComposer_->getSkinTextureSlotIndex() : 0; }
-    uint32_t getCloakTextureSlotIndex() const { return appearanceComposer_ ? appearanceComposer_->getCloakTextureSlotIndex() : 0; }
-    uint32_t getGryphonDisplayId() const { return entitySpawner_ ? entitySpawner_->getGryphonDisplayId() : 0; }
-    uint32_t getWyvernDisplayId() const { return entitySpawner_ ? entitySpawner_->getWyvernDisplayId() : 0; }
-
-    // Entity spawner access
-    EntitySpawner* getEntitySpawner() { return entitySpawner_.get(); }
-
-    // Appearance composer access
-    AppearanceComposer* getAppearanceComposer() { return appearanceComposer_.get(); }
-
-    // World loader access
-    WorldLoader* getWorldLoader() { return worldLoader_.get(); }
-
-    // Audio coordinator access (Section 4.1: extracted audio subsystem)
-    audio::AudioCoordinator* getAudioCoordinator() { return audioCoordinator_.get(); }
+    // Character skin composite state (saved at spawn for re-compositing on equipment change)
+    const std::string& getBodySkinPath() const { return bodySkinPath_; }
+    const std::vector<std::string>& getUnderwearPaths() const { return underwearPaths_; }
+    uint32_t getSkinTextureSlotIndex() const { return skinTextureSlotIndex_; }
+    uint32_t getCloakTextureSlotIndex() const { return cloakTextureSlotIndex_; }
+    uint32_t getGryphonDisplayId() const { return gryphonDisplayId_; }
+    uint32_t getWyvernDisplayId() const { return wyvernDisplayId_; }
 
 private:
     void update(float deltaTime);
     void render();
     void setupUICallbacks();
     void spawnPlayerCharacter();
+    std::string getPlayerModelPath() const;
+    static const char* mapIdToName(uint32_t mapId);
+    void loadOnlineWorldTerrain(uint32_t mapId, float x, float y, float z);
     void buildFactionHostilityMap(uint8_t playerRace);
+    pipeline::M2Model loadCreatureM2Sync(const std::string& m2Path);
+    void spawnOnlineCreature(uint64_t guid, uint32_t displayId, float x, float y, float z, float orientation);
+    void despawnOnlineCreature(uint64_t guid);
+    bool tryAttachCreatureVirtualWeapons(uint64_t guid, uint32_t instanceId);
+    void spawnOnlinePlayer(uint64_t guid,
+                           uint8_t raceId,
+                           uint8_t genderId,
+                           uint32_t appearanceBytes,
+                           uint8_t facialFeatures,
+                           float x, float y, float z, float orientation);
+    void setOnlinePlayerEquipment(uint64_t guid,
+                                  const std::array<uint32_t, 19>& displayInfoIds,
+                                  const std::array<uint8_t, 19>& inventoryTypes);
+    void despawnOnlinePlayer(uint64_t guid);
+    void buildCreatureDisplayLookups();
+    std::string getModelPathForDisplayId(uint32_t displayId) const;
+    void spawnOnlineGameObject(uint64_t guid, uint32_t entry, uint32_t displayId, float x, float y, float z, float orientation);
+    void despawnOnlineGameObject(uint64_t guid);
+    void buildGameObjectDisplayLookups();
+    std::string getGameObjectModelPathForDisplayId(uint32_t displayId) const;
+    audio::VoiceType detectVoiceTypeFromDisplayId(uint32_t displayId) const;
     void setupTestTransport();  // Test transport boat for development
 
     static Application* instance;
 
-    game::GameServices gameServices_;
     std::unique_ptr<Window> window;
     std::unique_ptr<rendering::Renderer> renderer;
     std::unique_ptr<ui::UIManager> uiManager;
@@ -125,14 +128,8 @@ private:
     std::unique_ptr<game::GameHandler> gameHandler;
     std::unique_ptr<game::World> world;
     std::unique_ptr<pipeline::AssetManager> assetManager;
-    std::unique_ptr<addons::AddonManager> addonManager_;
-    bool addonsLoaded_ = false;
     std::unique_ptr<game::ExpansionRegistry> expansionRegistry_;
     std::unique_ptr<pipeline::DBCLayout> dbcLayout_;
-    std::unique_ptr<EntitySpawner> entitySpawner_;
-    std::unique_ptr<AppearanceComposer> appearanceComposer_;
-    std::unique_ptr<WorldLoader> worldLoader_;
-    std::unique_ptr<audio::AudioCoordinator> audioCoordinator_;
 
     AppState state = AppState::AUTHENTICATION;
     bool running = false;
@@ -150,11 +147,93 @@ private:
     uint32_t spawnedAppearanceBytes_ = 0;
     uint8_t spawnedFacialFeatures_ = 0;
 
-    // Static empty values for null-safe delegation
-    static inline const std::string emptyString_;
-    static inline const std::vector<std::string> emptyStringVec_;
+    // Weapon model ID counter (starting high to avoid collision with character model IDs)
+    uint32_t nextWeaponModelId_ = 1000;
 
+    // Saved at spawn for skin re-compositing
+    std::string bodySkinPath_;
+    std::vector<std::string> underwearPaths_;
+    uint32_t skinTextureSlotIndex_ = 0;
+    uint32_t cloakTextureSlotIndex_ = 0;
+
+    // Online creature model spawning
+    struct CreatureDisplayData {
+        uint32_t modelId = 0;
+        std::string skin1, skin2, skin3;  // Texture names from CreatureDisplayInfo.dbc
+        uint32_t extraDisplayId = 0;      // Link to CreatureDisplayInfoExtra.dbc
+    };
+    struct HumanoidDisplayExtra {
+        uint8_t raceId = 0;
+        uint8_t sexId = 0;
+        uint8_t skinId = 0;
+        uint8_t faceId = 0;
+        uint8_t hairStyleId = 0;
+        uint8_t hairColorId = 0;
+        uint8_t facialHairId = 0;
+        std::string bakeName;  // Pre-baked texture path if available
+        // Equipment display IDs (from columns 8-18)
+        // 0=helm, 1=shoulder, 2=shirt, 3=chest, 4=belt, 5=legs, 6=feet, 7=wrist, 8=hands, 9=tabard, 10=cape
+        uint32_t equipDisplayId[11] = {0};
+    };
+    std::unordered_map<uint32_t, CreatureDisplayData> displayDataMap_;  // displayId → display data
+    std::unordered_map<uint32_t, HumanoidDisplayExtra> humanoidExtraMap_;  // extraDisplayId → humanoid data
+    std::unordered_map<uint32_t, std::string> modelIdToPath_;   // modelId → M2 path (from CreatureModelData.dbc)
+    // CharHairGeosets.dbc: key = (raceId<<16)|(sexId<<8)|variationId → geosetId (skinSectionId)
+    std::unordered_map<uint32_t, uint16_t> hairGeosetMap_;
+    // CharFacialHairStyles.dbc: key = (raceId<<16)|(sexId<<8)|variationId → {geoset100, geoset300, geoset200}
+    struct FacialHairGeosets { uint16_t geoset100 = 0; uint16_t geoset300 = 0; uint16_t geoset200 = 0; };
+    std::unordered_map<uint32_t, FacialHairGeosets> facialHairGeosetMap_;
+    std::unordered_map<uint64_t, uint32_t> creatureInstances_;  // guid → render instanceId
+    std::unordered_map<uint64_t, uint32_t> creatureModelIds_;   // guid → loaded modelId
+    std::unordered_map<uint64_t, glm::vec3> creatureRenderPosCache_; // guid -> last synced render position
+    std::unordered_set<uint64_t> creatureWeaponsAttached_;       // guid set when NPC virtual weapons attached
+    std::unordered_map<uint64_t, uint8_t> creatureWeaponAttachAttempts_; // guid -> attach attempts
+    std::unordered_map<uint32_t, bool> modelIdIsWolfLike_;     // modelId → cached wolf/worg check
+    static constexpr int MAX_WEAPON_ATTACHES_PER_TICK = 2;     // limit weapon attach work per 1s tick
+
+    // CharSections.dbc lookup cache to avoid O(N) DBC scan per NPC spawn.
+    // Key: (race<<24)|(sex<<16)|(section<<12)|(variation<<8)|color → texture path
+    std::unordered_map<uint64_t, std::string> charSectionsCache_;
+    bool charSectionsCacheBuilt_ = false;
+    void buildCharSectionsCache();
+    std::string lookupCharSection(uint8_t race, uint8_t sex, uint8_t section,
+                                  uint8_t variation, uint8_t color, int texIndex = 0) const;
+
+    // Async creature model loading: file I/O + M2 parsing on background thread,
+    // GPU upload + instance creation on main thread.
+    struct PreparedCreatureModel {
+        uint64_t guid;
+        uint32_t displayId;
+        uint32_t modelId;
+        float x, y, z, orientation;
+        std::shared_ptr<pipeline::M2Model> model; // parsed on background thread
+        std::unordered_map<std::string, pipeline::BLPImage> predecodedTextures; // decoded on bg thread
+        bool valid = false;
+        bool permanent_failure = false;
+    };
+    struct AsyncCreatureLoad {
+        std::future<PreparedCreatureModel> future;
+    };
+    std::vector<AsyncCreatureLoad> asyncCreatureLoads_;
+    void processAsyncCreatureResults(bool unlimited = false);
+    static constexpr int MAX_ASYNC_CREATURE_LOADS = 4; // concurrent background loads
+    std::unordered_set<uint64_t> deadCreatureGuids_;            // GUIDs that should spawn in corpse/death pose
+    std::unordered_map<uint32_t, uint32_t> displayIdModelCache_; // displayId → modelId (model caching)
+    std::unordered_set<uint32_t> displayIdTexturesApplied_;    // displayIds with per-model textures applied
+    std::unordered_map<uint32_t, std::unordered_map<std::string, pipeline::BLPImage>> displayIdPredecodedTextures_; // displayId → pre-decoded skin textures
+    mutable std::unordered_set<uint32_t> warnedMissingDisplayDataIds_; // displayIds already warned
+    mutable std::unordered_set<uint32_t> warnedMissingModelPathIds_;   // modelIds/displayIds already warned
+    uint32_t nextCreatureModelId_ = 5000;  // Model IDs for online creatures
+    uint32_t gryphonDisplayId_ = 0;
+    uint32_t wyvernDisplayId_ = 0;
     bool lastTaxiFlight_ = false;
+    uint32_t loadedMapId_ = 0xFFFFFFFF;  // Map ID of currently loaded terrain (0xFFFFFFFF = none)
+    uint32_t worldLoadGeneration_ = 0;   // Incremented on each world entry to detect re-entrant loads
+    bool loadingWorld_ = false;          // True while loadOnlineWorldTerrain is running
+    struct PendingWorldEntry {
+        uint32_t mapId; float x, y, z;
+    };
+    std::optional<PendingWorldEntry> pendingWorldEntry_;  // Deferred world entry during loading
     float taxiLandingClampTimer_ = 0.0f;
     float worldEntryMovementGraceTimer_ = 0.0f;
 
@@ -175,11 +254,194 @@ private:
     glm::vec3 chargeEndPos_{0.0f};    // Render coordinates
     uint64_t chargeTargetGuid_ = 0;
 
+    // Online gameobject model spawning
+    struct GameObjectInstanceInfo {
+        uint32_t modelId = 0;
+        uint32_t instanceId = 0;
+        bool isWmo = false;
+    };
+    std::unordered_map<uint32_t, std::string> gameObjectDisplayIdToPath_;
+    std::unordered_map<uint32_t, uint32_t> gameObjectDisplayIdModelCache_; // displayId → M2 modelId
+    std::unordered_map<uint32_t, uint32_t> gameObjectDisplayIdWmoCache_;   // displayId → WMO modelId
+    std::unordered_map<uint64_t, GameObjectInstanceInfo> gameObjectInstances_; // guid → instance info
+    struct PendingTransportMove {
+        float x = 0.0f;
+        float y = 0.0f;
+        float z = 0.0f;
+        float orientation = 0.0f;
+    };
+    std::unordered_map<uint64_t, PendingTransportMove> pendingTransportMoves_; // guid -> latest pre-registration move
+    uint32_t nextGameObjectModelId_ = 20000;
+    uint32_t nextGameObjectWmoModelId_ = 40000;
+    bool testTransportSetup_ = false;
+    bool gameObjectLookupsBuilt_ = false;
+
+    // Mount model tracking
+    uint32_t mountInstanceId_ = 0;
+    uint32_t mountModelId_ = 0;
+    uint32_t pendingMountDisplayId_ = 0;  // Deferred mount load (0 = none pending)
+    bool weaponsSheathed_ = false;
     bool wasAutoAttacking_ = false;
+    void processPendingMount();
+    bool creatureLookupsBuilt_ = false;
+    bool mapNameCacheLoaded_ = false;
+    std::unordered_map<uint32_t, std::string> mapNameById_;
+
+    // Deferred creature spawn queue (throttles spawning to avoid hangs)
+    struct PendingCreatureSpawn {
+        uint64_t guid;
+        uint32_t displayId;
+        float x, y, z, orientation;
+    };
+    std::deque<PendingCreatureSpawn> pendingCreatureSpawns_;
+    static constexpr int MAX_SPAWNS_PER_FRAME = 3;
+    static constexpr int MAX_NEW_CREATURE_MODELS_PER_FRAME = 1;
+    static constexpr uint16_t MAX_CREATURE_SPAWN_RETRIES = 300;
+    std::unordered_set<uint64_t> pendingCreatureSpawnGuids_;
+    std::unordered_map<uint64_t, uint16_t> creatureSpawnRetryCounts_;
+    std::unordered_set<uint32_t> nonRenderableCreatureDisplayIds_;
+
+    // Online player instances (separate from creatures so we can apply per-player skin/hair textures).
+    std::unordered_map<uint64_t, uint32_t> playerInstances_;  // guid → render instanceId
+    struct OnlinePlayerAppearanceState {
+        uint32_t instanceId = 0;
+        uint32_t modelId = 0;
+        uint8_t raceId = 0;
+        uint8_t genderId = 0;
+        uint32_t appearanceBytes = 0;
+        uint8_t facialFeatures = 0;
+        std::string bodySkinPath;
+        std::vector<std::string> underwearPaths;
+    };
+    std::unordered_map<uint64_t, OnlinePlayerAppearanceState> onlinePlayerAppearance_;
+    std::unordered_map<uint64_t, std::pair<std::array<uint32_t, 19>, std::array<uint8_t, 19>>> pendingOnlinePlayerEquipment_;
+    // Deferred equipment compositing queue — processes max 1 per frame to avoid stutter
+    std::vector<std::pair<uint64_t, std::pair<std::array<uint32_t, 19>, std::array<uint8_t, 19>>>> deferredEquipmentQueue_;
+    void processDeferredEquipmentQueue();
+    // Async equipment texture pre-decode: BLP decode on background thread, composite on main thread
+    struct PreparedEquipmentUpdate {
+        uint64_t guid;
+        std::array<uint32_t, 19> displayInfoIds;
+        std::array<uint8_t, 19> inventoryTypes;
+        std::unordered_map<std::string, pipeline::BLPImage> predecodedTextures;
+    };
+    struct AsyncEquipmentLoad {
+        std::future<PreparedEquipmentUpdate> future;
+    };
+    std::vector<AsyncEquipmentLoad> asyncEquipmentLoads_;
+    void processAsyncEquipmentResults();
+    std::vector<std::string> resolveEquipmentTexturePaths(uint64_t guid,
+        const std::array<uint32_t, 19>& displayInfoIds,
+        const std::array<uint8_t, 19>& inventoryTypes) const;
+    // Deferred NPC texture setup — async DBC lookups + BLP pre-decode to avoid main-thread stalls
+    struct DeferredNpcComposite {
+        uint32_t modelId;
+        uint32_t displayId;
+        // Skin compositing (type-1 slots)
+        std::string basePath;                     // CharSections skin base texture
+        std::vector<std::string> overlayPaths;    // face + underwear overlays
+        std::vector<std::pair<int, std::string>> regionLayers;  // equipment region overlays
+        std::vector<uint32_t> skinTextureSlots;   // model texture slots needing skin composite
+        bool hasComposite = false;                // needs compositing (overlays or equipment regions)
+        bool hasSimpleSkin = false;               // just base skin, no compositing needed
+        // Baked skin (type-1 slots)
+        std::string bakedSkinPath;                // baked texture path (if available)
+        bool hasBakedSkin = false;                // baked skin resolved successfully
+        // Hair (type-6 slots)
+        std::vector<uint32_t> hairTextureSlots;   // model texture slots needing hair texture
+        std::string hairTexturePath;              // resolved hair texture path
+        bool useBakedForHair = false;             // bald NPC: use baked skin for type-6
+    };
+    struct PreparedNpcComposite {
+        DeferredNpcComposite info;
+        std::unordered_map<std::string, pipeline::BLPImage> predecodedTextures;
+    };
+    struct AsyncNpcCompositeLoad {
+        std::future<PreparedNpcComposite> future;
+    };
+    std::vector<AsyncNpcCompositeLoad> asyncNpcCompositeLoads_;
+    void processAsyncNpcCompositeResults();
+    // Cache base player model geometry by (raceId, genderId)
+    std::unordered_map<uint32_t, uint32_t> playerModelCache_; // key=(race<<8)|gender → modelId
+    struct PlayerTextureSlots { int skin = -1; int hair = -1; int underwear = -1; };
+    std::unordered_map<uint32_t, PlayerTextureSlots> playerTextureSlotsByModelId_;
+    uint32_t nextPlayerModelId_ = 60000;
+    struct PendingPlayerSpawn {
+        uint64_t guid;
+        uint8_t raceId;
+        uint8_t genderId;
+        uint32_t appearanceBytes;
+        uint8_t facialFeatures;
+        float x, y, z, orientation;
+    };
+    std::vector<PendingPlayerSpawn> pendingPlayerSpawns_;
+    std::unordered_set<uint64_t> pendingPlayerSpawnGuids_;
+    void processPlayerSpawnQueue();
+    std::unordered_set<uint64_t> creaturePermanentFailureGuids_;
+    void processCreatureSpawnQueue(bool unlimited = false);
+
+    struct PendingGameObjectSpawn {
+        uint64_t guid;
+        uint32_t entry;
+        uint32_t displayId;
+        float x, y, z, orientation;
+    };
+    std::vector<PendingGameObjectSpawn> pendingGameObjectSpawns_;
+    void processGameObjectSpawnQueue();
+
+    // Async WMO loading for game objects (file I/O + parse on background thread)
+    struct PreparedGameObjectWMO {
+        uint64_t guid;
+        uint32_t entry;
+        uint32_t displayId;
+        float x, y, z, orientation;
+        std::shared_ptr<pipeline::WMOModel> wmoModel;
+        std::unordered_map<std::string, pipeline::BLPImage> predecodedTextures; // decoded on bg thread
+        bool valid = false;
+        bool isWmo = false;
+        std::string modelPath;
+    };
+    struct AsyncGameObjectLoad {
+        std::future<PreparedGameObjectWMO> future;
+    };
+    std::vector<AsyncGameObjectLoad> asyncGameObjectLoads_;
+    void processAsyncGameObjectResults();
+    struct PendingTransportDoodadBatch {
+        uint64_t guid = 0;
+        uint32_t modelId = 0;
+        uint32_t instanceId = 0;
+        size_t nextIndex = 0;
+        size_t doodadBudget = 0;
+        size_t spawnedDoodads = 0;
+        float x = 0.0f;
+        float y = 0.0f;
+        float z = 0.0f;
+        float orientation = 0.0f;
+    };
+    std::vector<PendingTransportDoodadBatch> pendingTransportDoodadBatches_;
+    static constexpr size_t MAX_TRANSPORT_DOODADS_PER_FRAME = 4;
+    void processPendingTransportDoodads();
 
     // Quest marker billboard sprites (above NPCs)
     void loadQuestMarkerModels();  // Now loads BLP textures
     void updateQuestMarkers();     // Updates billboard positions
+
+    // Background world preloader — warms AssetManager file cache for the
+    // expected world before the user clicks Enter World.
+    struct WorldPreload {
+        uint32_t mapId = 0;
+        std::string mapName;
+        int centerTileX = 0;
+        int centerTileY = 0;
+        std::atomic<bool> cancel{false};
+        std::vector<std::thread> workers;
+    };
+    std::unique_ptr<WorldPreload> worldPreload_;
+    void startWorldPreload(uint32_t mapId, const std::string& mapName, float serverX, float serverY);
+    void cancelWorldPreload();
+    void saveLastWorldInfo(uint32_t mapId, const std::string& mapName, float serverX, float serverY);
+    struct LastWorldInfo { uint32_t mapId = 0; std::string mapName; float x = 0, y = 0; bool valid = false; };
+    LastWorldInfo loadLastWorldInfo() const;
 };
 
 } // namespace core
diff --git a/include/core/entity_spawner.hpp b/include/core/entity_spawner.hpp
deleted file mode 100644
index 301faf28..00000000
--- a/include/core/entity_spawner.hpp
+++ /dev/null
@@ -1,465 +0,0 @@
-#pragma once
-
-#include "game/character.hpp"
-#include "game/game_services.hpp"
-#include "pipeline/blp_loader.hpp"
-#include <memory>
-#include <string>
-#include <vector>
-#include <deque>
-#include <unordered_map>
-#include <unordered_set>
-#include <array>
-#include <optional>
-#include <future>
-#include <mutex>
-#include <glm/glm.hpp>
-
-namespace wowee {
-
-// Forward declarations
-namespace rendering { class Renderer; }
-namespace pipeline { class AssetManager; class DBCLayout; struct M2Model; struct WMOModel; }
-namespace audio { enum class VoiceType; }
-namespace game { class GameHandler; }
-
-namespace core {
-
-class Application;
-
-class EntitySpawner {
-public:
-    EntitySpawner(rendering::Renderer* renderer,
-                  pipeline::AssetManager* assetManager,
-                  game::GameHandler* gameHandler,
-                  pipeline::DBCLayout* dbcLayout,
-                  game::GameServices* gameServices);
-    ~EntitySpawner();
-
-    EntitySpawner(const EntitySpawner&) = delete;
-    EntitySpawner& operator=(const EntitySpawner&) = delete;
-
-    // Lifecycle
-    void initialize();   // Build DBC lookups
-    void update();       // Process all spawn/despawn queues (called from Application::update)
-    void shutdown();     // Clear all instances and queues
-
-    // Queue-based spawn API (called from GameHandler callbacks)
-    void queueCreatureSpawn(uint64_t guid, uint32_t displayId,
-                            float x, float y, float z, float orientation, float scale = 1.0f);
-    void queuePlayerSpawn(uint64_t guid, uint8_t raceId, uint8_t genderId,
-                          uint32_t appearanceBytes, uint8_t facialFeatures,
-                          float x, float y, float z, float orientation);
-    void queueGameObjectSpawn(uint64_t guid, uint32_t entry, uint32_t displayId,
-                              float x, float y, float z, float orientation, float scale = 1.0f);
-    void queuePlayerEquipment(uint64_t guid,
-                              const std::array<uint32_t, 19>& displayInfoIds,
-                              const std::array<uint8_t, 19>& inventoryTypes);
-
-    // Immediate despawn
-    void despawnCreature(uint64_t guid);
-    void despawnPlayer(uint64_t guid);
-    void despawnGameObject(uint64_t guid);
-
-    // Clear all queues and instances (logout, reconnect)
-    void clearAllQueues();
-    void despawnAllCreatures();
-    void despawnAllPlayers();
-    void despawnAllGameObjects();
-
-    // Full reset — despawns entities, waits for async loads, clears all state.
-    // Used by logoutToLogin() and loadOnlineWorldTerrain() for clean slate.
-    void resetAllState();
-
-    // Rebuild lookup tables (for reloadExpansionData after expansion change)
-    void rebuildLookups();
-
-    // Check if any spawn/async work is still pending
-    bool hasWorkPending() const;
-
-    // Status queries
-    bool isCreatureSpawned(uint64_t guid) const { return creatureInstances_.count(guid) > 0; }
-    bool isCreaturePending(uint64_t guid) const { return pendingCreatureSpawnGuids_.count(guid) > 0; }
-    bool isPlayerSpawned(uint64_t guid) const { return playerInstances_.count(guid) > 0; }
-    bool isPlayerPending(uint64_t guid) const { return pendingPlayerSpawnGuids_.count(guid) > 0; }
-    bool isGameObjectSpawned(uint64_t guid) const { return gameObjectInstances_.count(guid) > 0; }
-
-    // Quick instance ID lookups (returns 0 if not found)
-    uint32_t getCreatureInstanceId(uint64_t guid) const {
-        auto it = creatureInstances_.find(guid); return (it != creatureInstances_.end()) ? it->second : 0;
-    }
-    uint32_t getPlayerInstanceId(uint64_t guid) const {
-        auto it = playerInstances_.find(guid); return (it != playerInstances_.end()) ? it->second : 0;
-    }
-
-    // Render bounds/position queries (used by click targeting, etc.)
-    bool getRenderBoundsForGuid(uint64_t guid, glm::vec3& outCenter, float& outRadius) const;
-    bool getRenderFootZForGuid(uint64_t guid, float& outFootZ) const;
-    bool getRenderPositionForGuid(uint64_t guid, glm::vec3& outPos) const;
-
-    // Display data lookups
-    bool areCreatureLookupsBuilt() const { return creatureLookupsBuilt_; }
-    bool areGameObjectLookupsBuilt() const { return gameObjectLookupsBuilt_; }
-    std::string getModelPathForDisplayId(uint32_t displayId) const;
-    std::string getGameObjectModelPathForDisplayId(uint32_t displayId) const;
-    audio::VoiceType detectVoiceTypeFromDisplayId(uint32_t displayId) const;
-
-    // Weapon attachment for NPC virtual weapons
-    bool tryAttachCreatureVirtualWeapons(uint64_t guid, uint32_t instanceId);
-
-    // Mount
-    void setMountDisplayId(uint32_t displayId) { pendingMountDisplayId_ = displayId; }
-    uint32_t getMountInstanceId() const { return mountInstanceId_; }
-    uint32_t getMountModelId() const { return mountModelId_; }
-
-    // Local player GUID exclusion (EntitySpawner skips spawning the local player)
-    void setLocalPlayerGuid(uint64_t guid) { spawnedPlayerGuid_ = guid; }
-
-    // Weapon model IDs (shared counter for creature weapons + equipment helm/weapon models)
-    uint32_t allocateWeaponModelId() { return nextWeaponModelId_++; }
-
-    // Maximum weapon attachment operations per tick (used by Application update loop)
-    static constexpr int MAX_WEAPON_ATTACHES_PER_TICK = 2;
-
-    // Dead creature tracking (spawn in corpse/death pose)
-    void markCreatureDead(uint64_t guid) { deadCreatureGuids_.insert(guid); }
-    void unmarkCreatureDead(uint64_t guid) { deadCreatureGuids_.erase(guid); }
-    void clearDeadCreatureGuids() { deadCreatureGuids_.clear(); }
-
-    // Mount state management
-    void clearMountState();
-
-    // Transport registration API (used by setupUICallbacks transport spawn callback)
-    void queueTransportRegistration(uint64_t guid, uint32_t entry, uint32_t displayId,
-                                     float x, float y, float z, float orientation);
-    void setTransportPendingMove(uint64_t guid, float x, float y, float z, float orientation);
-    bool hasTransportRegistrationPending(uint64_t guid) const;
-    void updateTransportRegistration(uint64_t guid, uint32_t displayId,
-                                      float x, float y, float z, float orientation);
-
-    // Test transport setup flag
-    bool isTestTransportSetup() const { return testTransportSetup_; }
-    void setTestTransportSetup(bool v) { testTransportSetup_ = v; }
-
-    // Creature animation state accessors (for movement sync in Application::update)
-    std::unordered_map<uint64_t, uint32_t>& getCreatureInstances() { return creatureInstances_; }
-    const std::unordered_map<uint64_t, uint32_t>& getCreatureInstances() const { return creatureInstances_; }
-    std::unordered_map<uint64_t, uint32_t>& getCreatureModelIds() { return creatureModelIds_; }
-    std::unordered_map<uint64_t, glm::vec3>& getCreatureRenderPosCache() { return creatureRenderPosCache_; }
-    std::unordered_map<uint64_t, bool>& getCreatureWasMoving() { return creatureWasMoving_; }
-    std::unordered_map<uint64_t, bool>& getCreatureWasSwimming() { return creatureWasSwimming_; }
-    std::unordered_map<uint64_t, bool>& getCreatureWasFlying() { return creatureWasFlying_; }
-    std::unordered_map<uint64_t, bool>& getCreatureWasWalking() { return creatureWasWalking_; }
-    std::unordered_map<uint64_t, bool>& getCreatureSwimmingState() { return creatureSwimmingState_; }
-    std::unordered_map<uint64_t, bool>& getCreatureWalkingState() { return creatureWalkingState_; }
-    std::unordered_map<uint64_t, bool>& getCreatureFlyingState() { return creatureFlyingState_; }
-    std::unordered_set<uint64_t>& getCreatureWeaponsAttached() { return creatureWeaponsAttached_; }
-    std::unordered_map<uint64_t, uint8_t>& getCreatureWeaponAttachAttempts() { return creatureWeaponAttachAttempts_; }
-    std::unordered_map<uint32_t, bool>& getModelIdIsWolfLike() { return modelIdIsWolfLike_; }
-
-    // Player instance accessors (for movement sync in Application::update)
-    std::unordered_map<uint64_t, uint32_t>& getPlayerInstances() { return playerInstances_; }
-    const std::unordered_map<uint64_t, uint32_t>& getPlayerInstances() const { return playerInstances_; }
-
-    // GameObject instance accessors
-    auto& getGameObjectInstances() { return gameObjectInstances_; }
-    const auto& getGameObjectInstances() const { return gameObjectInstances_; }
-
-    // Display data accessors (needed by Application for gryphon/wyvern display IDs)
-    const auto& getDisplayDataMap() const { return displayDataMap_; }
-    uint32_t getGryphonDisplayId() const { return gryphonDisplayId_; }
-    uint32_t getWyvernDisplayId() const { return wyvernDisplayId_; }
-
-    // Character section lookups (needed for player character skin compositing)
-    std::string lookupCharSection(uint8_t race, uint8_t sex, uint8_t section,
-                                  uint8_t variation, uint8_t color, int texIndex = 0) const;
-    const std::unordered_map<uint32_t, uint16_t>& getHairGeosetMap() const { return hairGeosetMap_; }
-
-    struct FacialHairGeosets { uint16_t geoset100 = 0; uint16_t geoset300 = 0; uint16_t geoset200 = 0; };
-    const std::unordered_map<uint32_t, FacialHairGeosets>& getFacialHairGeosetMap() const { return facialHairGeosetMap_; }
-
-    // Creature M2 sync loader (used by spawnPlayerCharacter in Application)
-    pipeline::M2Model loadCreatureM2Sync(const std::string& m2Path);
-
-private:
-    // Dependencies (non-owning)
-    rendering::Renderer* renderer_;
-    pipeline::AssetManager* assetManager_;
-    game::GameHandler* gameHandler_;
-    pipeline::DBCLayout* dbcLayout_;
-    game::GameServices* gameServices_;
-
-    // --- Creature display data (from DBC files) ---
-    struct CreatureDisplayData {
-        uint32_t modelId = 0;
-        std::string skin1, skin2, skin3;  // Texture names from CreatureDisplayInfo.dbc
-        uint32_t extraDisplayId = 0;      // Link to CreatureDisplayInfoExtra.dbc
-    };
-    struct HumanoidDisplayExtra {
-        uint8_t raceId = 0;
-        uint8_t sexId = 0;
-        uint8_t skinId = 0;
-        uint8_t faceId = 0;
-        uint8_t hairStyleId = 0;
-        uint8_t hairColorId = 0;
-        uint8_t facialHairId = 0;
-        std::string bakeName;  // Pre-baked texture path if available
-        // Equipment display IDs (from columns 8-18)
-        // 0=helm, 1=shoulder, 2=shirt, 3=chest, 4=belt, 5=legs, 6=feet, 7=wrist, 8=hands, 9=tabard, 10=cape
-        uint32_t equipDisplayId[11] = {0};
-    };
-    std::unordered_map<uint32_t, CreatureDisplayData> displayDataMap_;  // displayId → display data
-    std::unordered_map<uint32_t, HumanoidDisplayExtra> humanoidExtraMap_;  // extraDisplayId → humanoid data
-    std::unordered_map<uint32_t, std::string> modelIdToPath_;   // modelId → M2 path (from CreatureModelData.dbc)
-    // CharHairGeosets.dbc: key = (raceId<<16)|(sexId<<8)|variationId → geosetId (skinSectionId)
-    std::unordered_map<uint32_t, uint16_t> hairGeosetMap_;
-    // CharFacialHairStyles.dbc: key = (raceId<<16)|(sexId<<8)|variationId → {geoset100, geoset300, geoset200}
-    std::unordered_map<uint32_t, FacialHairGeosets> facialHairGeosetMap_;
-    bool creatureLookupsBuilt_ = false;
-
-    // CharSections.dbc lookup cache
-    std::unordered_map<uint64_t, std::string> charSectionsCache_;
-    bool charSectionsCacheBuilt_ = false;
-    void buildCharSectionsCache();
-
-    // Creature display lookup building
-    void buildCreatureDisplayLookups();
-
-    // Weapon M2 loading helper
-    bool loadWeaponM2(const std::string& m2Path, pipeline::M2Model& outModel);
-
-    // GameObject display lookups
-    std::unordered_map<uint32_t, std::string> gameObjectDisplayIdToPath_;
-    bool gameObjectLookupsBuilt_ = false;
-    void buildGameObjectDisplayLookups();
-
-    // --- Creature instances and tracking ---
-    std::unordered_map<uint64_t, uint32_t> creatureInstances_;  // guid → render instanceId
-    std::unordered_map<uint64_t, uint32_t> creatureModelIds_;   // guid → loaded modelId
-    std::unordered_map<uint64_t, glm::vec3> creatureRenderPosCache_; // guid → last synced render position
-    std::unordered_map<uint64_t, bool> creatureWasMoving_;
-    std::unordered_map<uint64_t, bool> creatureWasSwimming_;
-    std::unordered_map<uint64_t, bool> creatureWasFlying_;
-    std::unordered_map<uint64_t, bool> creatureWasWalking_;
-    std::unordered_map<uint64_t, bool> creatureSwimmingState_;
-    std::unordered_map<uint64_t, bool> creatureWalkingState_;
-    std::unordered_map<uint64_t, bool> creatureFlyingState_;
-    std::unordered_set<uint64_t> creatureWeaponsAttached_;
-    std::unordered_map<uint64_t, uint8_t> creatureWeaponAttachAttempts_;
-    std::unordered_map<uint32_t, bool> modelIdIsWolfLike_;
-
-    // --- Creature async loads ---
-    struct PreparedCreatureModel {
-        uint64_t guid;
-        uint32_t displayId;
-        uint32_t modelId;
-        float x, y, z, orientation;
-        float scale = 1.0f;
-        std::shared_ptr<pipeline::M2Model> model;
-        std::unordered_map<std::string, pipeline::BLPImage> predecodedTextures;
-        bool valid = false;
-        bool permanent_failure = false;
-    };
-    struct AsyncCreatureLoad {
-        std::future<PreparedCreatureModel> future;
-    };
-    std::vector<AsyncCreatureLoad> asyncCreatureLoads_;
-    std::unordered_set<uint32_t> asyncCreatureDisplayLoads_;
-    void processAsyncCreatureResults(bool unlimited = false);
-    static constexpr int MAX_ASYNC_CREATURE_LOADS = 4;
-    std::unordered_set<uint64_t> deadCreatureGuids_;
-    std::unordered_map<uint32_t, uint32_t> displayIdModelCache_;
-    std::unordered_set<uint32_t> displayIdTexturesApplied_;
-    std::unordered_map<uint32_t, std::unordered_map<std::string, pipeline::BLPImage>> displayIdPredecodedTextures_;
-    mutable std::unordered_set<uint32_t> warnedMissingDisplayDataIds_;
-    mutable std::unordered_set<uint32_t> warnedMissingModelPathIds_;
-    uint32_t nextCreatureModelId_ = 5000;
-    uint32_t gryphonDisplayId_ = 0;
-    uint32_t wyvernDisplayId_ = 0;
-
-    // --- Creature spawn queue ---
-    struct PendingCreatureSpawn {
-        uint64_t guid;
-        uint32_t displayId;
-        float x, y, z, orientation;
-        float scale = 1.0f;
-    };
-    std::deque<PendingCreatureSpawn> pendingCreatureSpawns_;
-    static constexpr int MAX_SPAWNS_PER_FRAME = 3;
-    static constexpr int MAX_NEW_CREATURE_MODELS_PER_FRAME = 1;
-    static constexpr uint16_t MAX_CREATURE_SPAWN_RETRIES = 300;
-    std::unordered_set<uint64_t> pendingCreatureSpawnGuids_;
-    std::unordered_map<uint64_t, uint16_t> creatureSpawnRetryCounts_;
-    std::unordered_set<uint32_t> nonRenderableCreatureDisplayIds_;
-    std::unordered_set<uint64_t> creaturePermanentFailureGuids_;
-    void processCreatureSpawnQueue(bool unlimited = false);
-
-    // --- NPC composite loads ---
-    struct DeferredNpcComposite {
-        uint32_t modelId;
-        uint32_t displayId;
-        std::string basePath;
-        std::vector<std::string> overlayPaths;
-        std::vector<std::pair<int, std::string>> regionLayers;
-        std::vector<uint32_t> skinTextureSlots;
-        bool hasComposite = false;
-        bool hasSimpleSkin = false;
-        std::string bakedSkinPath;
-        bool hasBakedSkin = false;
-        std::vector<uint32_t> hairTextureSlots;
-        std::string hairTexturePath;
-        bool useBakedForHair = false;
-    };
-    struct PreparedNpcComposite {
-        DeferredNpcComposite info;
-        std::unordered_map<std::string, pipeline::BLPImage> predecodedTextures;
-    };
-    struct AsyncNpcCompositeLoad {
-        std::future<PreparedNpcComposite> future;
-    };
-    std::vector<AsyncNpcCompositeLoad> asyncNpcCompositeLoads_;
-    void processAsyncNpcCompositeResults(bool unlimited = false);
-
-    // --- Player instances ---
-    std::unordered_map<uint64_t, uint32_t> playerInstances_;  // guid → render instanceId
-    struct OnlinePlayerAppearanceState {
-        uint32_t instanceId = 0;
-        uint32_t modelId = 0;
-        uint8_t raceId = 0;
-        uint8_t genderId = 0;
-        uint32_t appearanceBytes = 0;
-        uint8_t facialFeatures = 0;
-        std::string bodySkinPath;
-        std::vector<std::string> underwearPaths;
-    };
-    std::unordered_map<uint64_t, OnlinePlayerAppearanceState> onlinePlayerAppearance_;
-    std::unordered_map<uint64_t, std::pair<std::array<uint32_t, 19>, std::array<uint8_t, 19>>> pendingOnlinePlayerEquipment_;
-    std::deque<std::pair<uint64_t, std::pair<std::array<uint32_t, 19>, std::array<uint8_t, 19>>>> deferredEquipmentQueue_;
-    void processDeferredEquipmentQueue();
-    struct PreparedEquipmentUpdate {
-        uint64_t guid;
-        std::array<uint32_t, 19> displayInfoIds;
-        std::array<uint8_t, 19> inventoryTypes;
-        std::unordered_map<std::string, pipeline::BLPImage> predecodedTextures;
-    };
-    struct AsyncEquipmentLoad {
-        std::future<PreparedEquipmentUpdate> future;
-    };
-    std::vector<AsyncEquipmentLoad> asyncEquipmentLoads_;
-    void processAsyncEquipmentResults();
-    std::vector<std::string> resolveEquipmentTexturePaths(uint64_t guid,
-        const std::array<uint32_t, 19>& displayInfoIds,
-        const std::array<uint8_t, 19>& inventoryTypes) const;
-    std::unordered_map<uint32_t, uint32_t> playerModelCache_;
-    struct PlayerTextureSlots { int skin = -1; int hair = -1; int underwear = -1; };
-    std::unordered_map<uint32_t, PlayerTextureSlots> playerTextureSlotsByModelId_;
-    uint32_t nextPlayerModelId_ = 60000;
-
-    // --- Player spawn queue ---
-    struct PendingPlayerSpawn {
-        uint64_t guid;
-        uint8_t raceId;
-        uint8_t genderId;
-        uint32_t appearanceBytes;
-        uint8_t facialFeatures;
-        float x, y, z, orientation;
-    };
-    std::deque<PendingPlayerSpawn> pendingPlayerSpawns_;
-    std::unordered_set<uint64_t> pendingPlayerSpawnGuids_;
-    void processPlayerSpawnQueue();
-
-    // --- GameObject instances ---
-    struct GameObjectInstanceInfo {
-        uint32_t modelId = 0;
-        uint32_t instanceId = 0;
-        bool isWmo = false;
-    };
-    std::unordered_map<uint32_t, uint32_t> gameObjectDisplayIdModelCache_;
-    std::unordered_set<uint32_t> gameObjectDisplayIdFailedCache_;
-    std::unordered_map<uint32_t, uint32_t> gameObjectDisplayIdWmoCache_;
-    std::unordered_map<uint64_t, GameObjectInstanceInfo> gameObjectInstances_;
-    struct PendingTransportMove {
-        float x = 0.0f, y = 0.0f, z = 0.0f, orientation = 0.0f;
-    };
-    struct PendingTransportRegistration {
-        uint64_t guid = 0;
-        uint32_t entry = 0;
-        uint32_t displayId = 0;
-        float x = 0.0f, y = 0.0f, z = 0.0f, orientation = 0.0f;
-    };
-    std::unordered_map<uint64_t, PendingTransportMove> pendingTransportMoves_;
-    std::deque<PendingTransportRegistration> pendingTransportRegistrations_;
-    uint32_t nextGameObjectModelId_ = 20000;
-    uint32_t nextGameObjectWmoModelId_ = 40000;
-    bool testTransportSetup_ = false;
-
-    // --- GameObject spawn queue ---
-    struct PendingGameObjectSpawn {
-        uint64_t guid;
-        uint32_t entry;
-        uint32_t displayId;
-        float x, y, z, orientation;
-        float scale = 1.0f;
-    };
-    std::deque<PendingGameObjectSpawn> pendingGameObjectSpawns_;
-    void processGameObjectSpawnQueue();
-
-    // --- Async WMO loading for game objects ---
-    struct PreparedGameObjectWMO {
-        uint64_t guid;
-        uint32_t entry;
-        uint32_t displayId;
-        float x, y, z, orientation;
-        float scale = 1.0f;
-        std::shared_ptr<pipeline::WMOModel> wmoModel;
-        std::unordered_map<std::string, pipeline::BLPImage> predecodedTextures;
-        bool valid = false;
-        bool isWmo = false;
-        std::string modelPath;
-    };
-    struct AsyncGameObjectLoad {
-        std::future<PreparedGameObjectWMO> future;
-    };
-    std::vector<AsyncGameObjectLoad> asyncGameObjectLoads_;
-    void processAsyncGameObjectResults();
-    struct PendingTransportDoodadBatch {
-        uint64_t guid = 0;
-        uint32_t modelId = 0;
-        uint32_t instanceId = 0;
-        size_t nextIndex = 0;
-        size_t doodadBudget = 0;
-        size_t spawnedDoodads = 0;
-        float x = 0.0f, y = 0.0f, z = 0.0f, orientation = 0.0f;
-    };
-    std::vector<PendingTransportDoodadBatch> pendingTransportDoodadBatches_;
-    static constexpr size_t MAX_TRANSPORT_DOODADS_PER_FRAME = 4;
-    void processPendingTransportRegistrations();
-    void processPendingTransportDoodads();
-
-    // --- Mount ---
-    uint32_t mountInstanceId_ = 0;
-    uint32_t mountModelId_ = 0;
-    uint32_t pendingMountDisplayId_ = 0;
-    void processPendingMount();
-
-    // --- Local player GUID exclusion ---
-    uint64_t spawnedPlayerGuid_ = 0;
-
-    // --- Weapon model ID counter ---
-    uint32_t nextWeaponModelId_ = 1000;
-
-    // --- Spawn internal methods ---
-    void spawnOnlineCreature(uint64_t guid, uint32_t displayId,
-                             float x, float y, float z, float orientation, float scale = 1.0f);
-    void spawnOnlinePlayer(uint64_t guid, uint8_t raceId, uint8_t genderId,
-                           uint32_t appearanceBytes, uint8_t facialFeatures,
-                           float x, float y, float z, float orientation);
-    void setOnlinePlayerEquipment(uint64_t guid,
-                                  const std::array<uint32_t, 19>& displayInfoIds,
-                                  const std::array<uint8_t, 19>& inventoryTypes);
-    void spawnOnlineGameObject(uint64_t guid, uint32_t entry, uint32_t displayId,
-                               float x, float y, float z, float orientation, float scale = 1.0f);
-};
-
-} // namespace core
-} // namespace wowee
diff --git a/include/core/logger.hpp b/include/core/logger.hpp
index f3065f71..fa8e8158 100644
--- a/include/core/logger.hpp
+++ b/include/core/logger.hpp
@@ -7,8 +7,6 @@
 #include <fstream>
 #include <chrono>
 #include <atomic>
-#include <cstdio>
-#include <cstdint>
 
 namespace wowee {
 namespace core {
@@ -146,17 +144,6 @@ private:
     } \
 } while (0)
 
-inline std::string toHexString(const uint8_t* data, size_t len, bool spaces = false) {
-    std::string s;
-    s.reserve(len * (spaces ? 3 : 2));
-    for (size_t i = 0; i < len; ++i) {
-        char buf[4];
-        std::snprintf(buf, sizeof(buf), spaces ? "%02x " : "%02x", data[i]);
-        s += buf;
-    }
-    return s;
-}
-
 } // namespace core
 } // namespace wowee
 
diff --git a/include/core/profiler.hpp b/include/core/profiler.hpp
deleted file mode 100644
index 7b1b4745..00000000
--- a/include/core/profiler.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-// Thin wrapper around Tracy profiler.
-// When TRACY_ENABLE is not defined, all macros expand to nothing (zero overhead).
-#pragma once
-
-#ifdef TRACY_ENABLE
-#include <tracy/Tracy.hpp>
-#else
-// No-op replacements when Tracy is disabled.
-#define ZoneScoped
-#define ZoneScopedN(x)
-#define ZoneScopedC(x)
-#define ZoneScopedNC(x, y)
-#define FrameMark
-#define FrameMarkNamed(x)
-#define FrameMarkStart(x)
-#define FrameMarkEnd(x)
-#define TracyPlot(x, y)
-#define TracyMessageL(x)
-#endif
diff --git a/include/core/world_loader.hpp b/include/core/world_loader.hpp
deleted file mode 100644
index 01ce5483..00000000
--- a/include/core/world_loader.hpp
+++ /dev/null
@@ -1,125 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-#include <unordered_map>
-#include <optional>
-#include <memory>
-#include <atomic>
-#include <thread>
-#include <cstdint>
-
-namespace wowee {
-
-namespace rendering { class Renderer; }
-namespace pipeline { class AssetManager; class DBCLayout; }
-namespace game { class GameHandler; class World; }
-namespace addons { class AddonManager; }
-
-namespace core {
-
-class Application;
-class EntitySpawner;
-class AppearanceComposer;
-class Window;
-
-/// Handles terrain streaming, map transitions, world preloading,
-/// and coordinate-aware tile management for online world entry.
-class WorldLoader {
-public:
-    WorldLoader(Application& app,
-                rendering::Renderer* renderer,
-                pipeline::AssetManager* assetManager,
-                game::GameHandler* gameHandler,
-                EntitySpawner* entitySpawner,
-                AppearanceComposer* appearanceComposer,
-                Window* window,
-                game::World* world,
-                addons::AddonManager* addonManager);
-    ~WorldLoader();
-
-    // Main terrain loading — drives loading screen, WMO/ADT detection, player spawn
-    void loadOnlineWorldTerrain(uint32_t mapId, float x, float y, float z);
-
-    // Process deferred world entry (called from Application::update each frame)
-    void processPendingEntry();
-
-    // Map name utilities
-    static const char* mapIdToName(uint32_t mapId);
-    static const char* mapDisplayName(uint32_t mapId);
-
-    // Background preloading — warms AssetManager file cache
-    void startWorldPreload(uint32_t mapId, const std::string& mapName,
-                           float serverX, float serverY);
-    void cancelWorldPreload();
-
-    // Persistent world info for session-to-session preloading
-    void saveLastWorldInfo(uint32_t mapId, const std::string& mapName,
-                           float serverX, float serverY);
-    struct LastWorldInfo {
-        uint32_t mapId = 0;
-        std::string mapName;
-        float x = 0, y = 0;
-        bool valid = false;
-    };
-    LastWorldInfo loadLastWorldInfo() const;
-
-    // State accessors
-    uint32_t getLoadedMapId() const { return loadedMapId_; }
-    bool isLoadingWorld() const { return loadingWorld_; }
-    bool hasPendingEntry() const { return pendingWorldEntry_.has_value(); }
-
-    // Get cached map name by ID (returns empty string if not found)
-    std::string getMapNameById(uint32_t mapId) const {
-        auto it = mapNameById_.find(mapId);
-        return (it != mapNameById_.end()) ? it->second : std::string{};
-    }
-
-    // Set pending world entry for deferred processing via processPendingEntry()
-    void setPendingEntry(uint32_t mapId, float x, float y, float z) {
-        pendingWorldEntry_ = PendingWorldEntry{mapId, x, y, z};
-    }
-
-    // Reset methods (for logout / character switch)
-    void resetLoadedMap() { loadedMapId_ = 0xFFFFFFFF; }
-    void resetMapNameCache() { mapNameCacheLoaded_ = false; mapNameById_.clear(); }
-
-private:
-    Application& app_;
-    rendering::Renderer* renderer_;
-    pipeline::AssetManager* assetManager_;
-    game::GameHandler* gameHandler_;
-    EntitySpawner* entitySpawner_;
-    AppearanceComposer* appearanceComposer_;
-    Window* window_;
-    game::World* world_;
-    addons::AddonManager* addonManager_;
-
-    uint32_t loadedMapId_ = 0xFFFFFFFF;  // Map ID of currently loaded terrain (0xFFFFFFFF = none)
-    uint32_t worldLoadGeneration_ = 0;   // Incremented on each world entry to detect re-entrant loads
-    bool loadingWorld_ = false;          // True while loadOnlineWorldTerrain is running
-
-    struct PendingWorldEntry {
-        uint32_t mapId; float x, y, z;
-    };
-    std::optional<PendingWorldEntry> pendingWorldEntry_;
-
-    // Map.dbc name cache (loaded once per session)
-    bool mapNameCacheLoaded_ = false;
-    std::unordered_map<uint32_t, std::string> mapNameById_;
-
-    // Background world preloader — warms AssetManager file cache for the
-    // expected world before the user clicks Enter World.
-    struct WorldPreload {
-        uint32_t mapId = 0;
-        std::string mapName;
-        int centerTileX = 0;
-        int centerTileY = 0;
-        std::atomic<bool> cancel{false};
-        std::vector<std::thread> workers;
-    };
-    std::unique_ptr<WorldPreload> worldPreload_;
-};
-
-} // namespace core
-} // namespace wowee
diff --git a/include/game/chat_handler.hpp b/include/game/chat_handler.hpp
deleted file mode 100644
index f4e55c16..00000000
--- a/include/game/chat_handler.hpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#pragma once
-
-#include "game/world_packets.hpp"
-#include "game/opcode_table.hpp"
-#include "game/handler_types.hpp"
-#include "network/packet.hpp"
-#include <deque>
-#include <functional>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-namespace wowee {
-namespace game {
-
-class GameHandler;
-
-class ChatHandler {
-public:
-    using PacketHandler = std::function<void(network::Packet&)>;
-    using DispatchTable = std::unordered_map<LogicalOpcode, PacketHandler>;
-
-    explicit ChatHandler(GameHandler& owner);
-
-    void registerOpcodes(DispatchTable& table);
-
-    // --- Public API (delegated from GameHandler) ---
-    void sendChatMessage(ChatType type, const std::string& message, const std::string& target = "");
-    void sendTextEmote(uint32_t textEmoteId, uint64_t targetGuid = 0);
-    void joinChannel(const std::string& channelName, const std::string& password = "");
-    void leaveChannel(const std::string& channelName);
-    std::string getChannelByIndex(int index) const;
-    int getChannelIndex(const std::string& channelName) const;
-    const std::vector<std::string>& getJoinedChannels() const { return joinedChannels_; }
-    void autoJoinDefaultChannels();
-    void addLocalChatMessage(const MessageChatData& msg);
-    void addSystemChatMessage(const std::string& message);
-    void toggleAfk(const std::string& message);
-    void toggleDnd(const std::string& message);
-    void replyToLastWhisper(const std::string& message);
-
-    // ---- Methods moved from GameHandler ----
-    void submitGmTicket(const std::string& text);
-    void handleMotd(network::Packet& packet);
-    void handleNotification(network::Packet& packet);
-
-    // --- State accessors ---
-    std::deque<MessageChatData>& getChatHistory() { return chatHistory_; }
-    const std::deque<MessageChatData>& getChatHistory() const { return chatHistory_; }
-    size_t getMaxChatHistory() const { return maxChatHistory_; }
-    void setMaxChatHistory(size_t n) { maxChatHistory_ = n; }
-
-    // Chat auto-join settings (aliased from handler_types.hpp)
-    using ChatAutoJoin = game::ChatAutoJoin;
-    ChatAutoJoin chatAutoJoin;
-
-private:
-    // --- Packet handlers ---
-    void handleMessageChat(network::Packet& packet);
-    void handleTextEmote(network::Packet& packet);
-    void handleChannelNotify(network::Packet& packet);
-    void handleChannelList(network::Packet& packet);
-
-    GameHandler& owner_;
-
-    // --- State ---
-    std::deque<MessageChatData> chatHistory_;
-    size_t maxChatHistory_ = 100;
-    std::vector<std::string> joinedChannels_;
-
-    // Track senders we've already auto-replied to (AFK/DND) this session
-    // to prevent infinite reply loops. Cleared when AFK/DND is toggled off.
-    std::unordered_set<std::string> afkAutoRepliedSenders_;
-};
-
-} // namespace game
-} // namespace wowee
diff --git a/include/game/combat_handler.hpp b/include/game/combat_handler.hpp
deleted file mode 100644
index 645be0cf..00000000
--- a/include/game/combat_handler.hpp
+++ /dev/null
@@ -1,190 +0,0 @@
-#pragma once
-
-#include "game/world_packets.hpp"
-#include "game/opcode_table.hpp"
-#include "game/spell_defines.hpp"
-#include "network/packet.hpp"
-#include <chrono>
-#include <deque>
-#include <functional>
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-namespace wowee {
-namespace game {
-
-class GameHandler;
-class Entity;
-
-class CombatHandler {
-public:
-    using PacketHandler = std::function<void(network::Packet&)>;
-    using DispatchTable = std::unordered_map<LogicalOpcode, PacketHandler>;
-
-    explicit CombatHandler(GameHandler& owner);
-
-    void registerOpcodes(DispatchTable& table);
-
-    // --- Public API (delegated from GameHandler) ---
-    void startAutoAttack(uint64_t targetGuid);
-    void stopAutoAttack();
-    bool isAutoAttacking() const { return autoAttacking_; }
-    bool hasAutoAttackIntent() const { return autoAttackRequested_; }
-    bool isInCombat() const { return autoAttacking_ || !hostileAttackers_.empty(); }
-    bool isInCombatWith(uint64_t guid) const {
-        return guid != 0 &&
-               ((autoAttacking_ && autoAttackTarget_ == guid) ||
-                (hostileAttackers_.count(guid) > 0));
-    }
-    uint64_t getAutoAttackTargetGuid() const { return autoAttackTarget_; }
-    bool isAggressiveTowardPlayer(uint64_t guid) const { return hostileAttackers_.count(guid) > 0; }
-    uint64_t getLastMeleeSwingMs() const { return lastMeleeSwingMs_; }
-
-    // Floating combat text
-    const std::vector<CombatTextEntry>& getCombatText() const { return combatText_; }
-    void updateCombatText(float deltaTime);
-
-    // Combat log (persistent rolling history)
-    const std::deque<CombatLogEntry>& getCombatLog() const { return combatLog_; }
-    void clearCombatLog() { combatLog_.clear(); }
-
-    // Threat
-    struct ThreatEntry {
-        uint64_t victimGuid = 0;
-        uint32_t threat     = 0;
-    };
-    const std::vector<ThreatEntry>* getThreatList(uint64_t unitGuid) const {
-        auto it = threatLists_.find(unitGuid);
-        return (it != threatLists_.end()) ? &it->second : nullptr;
-    }
-
-    // Hostile attacker tracking
-    bool isHostileAttacker(uint64_t guid) const { return hostileAttackers_.count(guid) > 0; }
-    void clearHostileAttackers() { hostileAttackers_.clear(); }
-
-    // Forced faction reactions
-    const std::unordered_map<uint32_t, uint8_t>& getForcedReactions() const { return forcedReactions_; }
-
-    // Auto-attack timing state (read by GameHandler::update for retry/resend logic)
-    bool& autoAttackOutOfRangeRef() { return autoAttackOutOfRange_; }
-    float& autoAttackOutOfRangeTimeRef() { return autoAttackOutOfRangeTime_; }
-    float& autoAttackRangeWarnCooldownRef() { return autoAttackRangeWarnCooldown_; }
-    float& autoAttackResendTimerRef() { return autoAttackResendTimer_; }
-    float& autoAttackFacingSyncTimerRef() { return autoAttackFacingSyncTimer_; }
-    bool& autoAttackRetryPendingRef() { return autoAttackRetryPending_; }
-
-    // Combat text creation (used by other handlers, e.g. spell handler for periodic damage)
-    void addCombatText(CombatTextEntry::Type type, int32_t amount, uint32_t spellId,
-                       bool isPlayerSource, uint8_t powerType = 0,
-                       uint64_t srcGuid = 0, uint64_t dstGuid = 0);
-
-    // Spellsteal dedup (used by aura update handler)
-    bool shouldLogSpellstealAura(uint64_t casterGuid, uint64_t victimGuid, uint32_t spellId);
-
-    // Called from GameHandler::update() each frame
-    void updateAutoAttack(float deltaTime);
-
-    // --- Targeting ---
-    void setTarget(uint64_t guid);
-    void clearTarget();
-    std::shared_ptr<Entity> getTarget() const;
-    void setFocus(uint64_t guid);
-    void clearFocus();
-    std::shared_ptr<Entity> getFocus() const;
-    void setMouseoverGuid(uint64_t guid);
-    void targetLastTarget();
-    void targetEnemy(bool reverse);
-    void targetFriend(bool reverse);
-    void tabTarget(float playerX, float playerY, float playerZ);
-    void assistTarget();
-
-    // --- PvP ---
-    void togglePvp();
-
-    // --- Death / Resurrection ---
-    void releaseSpirit();
-    bool canReclaimCorpse() const;
-    float getCorpseReclaimDelaySec() const;
-    void reclaimCorpse();
-    void useSelfRes();
-    void activateSpiritHealer(uint64_t npcGuid);
-    void acceptResurrect();
-    void declineResurrect();
-
-    // --- XP ---
-    static uint32_t killXp(uint32_t playerLevel, uint32_t victimLevel);
-    void handleXpGain(network::Packet& packet);
-
-    // State management (for resets, entity cleanup)
-    void resetAllCombatState();
-    void removeHostileAttacker(uint64_t guid);
-    void clearCombatText();
-    void removeCombatTextForGuid(uint64_t guid);
-
-private:
-    // --- Packet handlers ---
-    void handleAttackStart(network::Packet& packet);
-    void handleAttackStop(network::Packet& packet);
-    void handleAttackerStateUpdate(network::Packet& packet);
-    void handleSpellDamageLog(network::Packet& packet);
-    void handleSpellHealLog(network::Packet& packet);
-    void handleSetForcedReactions(network::Packet& packet);
-    void handleHealthUpdate(network::Packet& packet);
-    void handlePowerUpdate(network::Packet& packet);
-    void handleUpdateComboPoints(network::Packet& packet);
-    void handlePvpCredit(network::Packet& packet);
-    void handleProcResist(network::Packet& packet);
-    void handleSpellDamageShield(network::Packet& packet);
-    void handleSpellOrDamageImmune(network::Packet& packet);
-    void handleResistLog(network::Packet& packet);
-    void handlePetTameFailure(network::Packet& packet);
-    void handlePetActionFeedback(network::Packet& packet);
-    void handlePetCastFailed(network::Packet& packet);
-    void handlePetBroken(network::Packet& packet);
-    void handlePetLearnedSpell(network::Packet& packet);
-    void handlePetUnlearnedSpell(network::Packet& packet);
-    void handlePetMode(network::Packet& packet);
-    void handleResurrectFailed(network::Packet& packet);
-
-    void autoTargetAttacker(uint64_t attackerGuid);
-
-    GameHandler& owner_;
-
-    // --- Combat state ---
-    bool autoAttacking_ = false;
-    bool autoAttackRequested_ = false;
-    bool autoAttackRetryPending_ = false;
-    uint64_t autoAttackTarget_ = 0;
-    bool autoAttackOutOfRange_ = false;
-    float autoAttackOutOfRangeTime_ = 0.0f;
-    float autoAttackRangeWarnCooldown_ = 0.0f;
-    float autoAttackResendTimer_ = 0.0f;
-    float autoAttackFacingSyncTimer_ = 0.0f;
-    std::unordered_set<uint64_t> hostileAttackers_;
-    std::vector<CombatTextEntry> combatText_;
-    static constexpr size_t MAX_COMBAT_LOG = 500;
-    std::deque<CombatLogEntry> combatLog_;
-
-    struct RecentSpellstealLogEntry {
-        uint64_t casterGuid = 0;
-        uint64_t victimGuid = 0;
-        uint32_t spellId = 0;
-        std::chrono::steady_clock::time_point timestamp{};
-    };
-    static constexpr size_t MAX_RECENT_SPELLSTEAL_LOGS = 32;
-    std::deque<RecentSpellstealLogEntry> recentSpellstealLogs_;
-
-    uint64_t lastMeleeSwingMs_ = 0;
-
-    // unitGuid → sorted threat list (descending by threat value)
-    std::unordered_map<uint64_t, std::vector<ThreatEntry>> threatLists_;
-
-    // Forced faction reactions
-    std::unordered_map<uint32_t, uint8_t> forcedReactions_;
-};
-
-} // namespace game
-} // namespace wowee
diff --git a/include/game/entity.hpp b/include/game/entity.hpp
index bd5dfc5f..9f4dfde7 100644
--- a/include/game/entity.hpp
+++ b/include/game/entity.hpp
@@ -3,7 +3,6 @@
 #include <cstdint>
 #include <string>
 #include <map>
-#include <unordered_map>
 #include <memory>
 
 namespace wowee {
@@ -93,9 +92,7 @@ public:
         float impliedVX = (destX - fromX) / durationSec;
         float impliedVY = (destY - fromY) / durationSec;
         float impliedVZ = (destZ - fromZ) / durationSec;
-        // Exponential moving average on velocity — 65% new sample, 35% previous.
-        // Smooths out jitter from irregular server update intervals (~200-600ms)
-        // without introducing visible lag on direction changes.
+        // Exponentially smooth velocity so jittery packet timing doesn't snap speed.
         const float alpha = 0.65f;
         velX_ = alpha * impliedVX + (1.0f - alpha) * velX_;
         velY_ = alpha * impliedVY + (1.0f - alpha) * velY_;
@@ -138,13 +135,6 @@ public:
 
     bool isEntityMoving() const { return isMoving_; }
 
-    /// True only during the active interpolation phase (before reaching destination).
-    /// Unlike isEntityMoving(), this does NOT include the dead-reckoning overrun window,
-    /// so animations (Run/Walk) should use this to avoid "running in place" after arrival.
-    bool isActivelyMoving() const {
-        return isMoving_ && moveElapsed_ < moveDuration_;
-    }
-
     // Returns the latest server-authoritative position: destination if moving, current if not.
     // Unlike getX/Y/Z (which only update via updateMovement), this always reflects the
     // last known server position regardless of distance culling.
@@ -156,9 +146,6 @@ public:
     ObjectType getType() const { return type; }
     void setType(ObjectType t) { type = t; }
 
-    /// True if this entity is a Unit or Player (both derive from Unit).
-    bool isUnit() const { return type == ObjectType::UNIT || type == ObjectType::PLAYER; }
-
     // Fields (for update values)
     void setField(uint16_t index, uint32_t value) {
         fields[index] = value;
@@ -227,9 +214,6 @@ public:
     void setMaxPower(uint32_t p) { maxPowers[powerType < 7 ? powerType : 0] = p; }
     void setMaxPowerByType(uint8_t type, uint32_t p) { if (type < 7) maxPowers[type] = p; }
 
-    uint32_t getPowerByType(uint8_t type) const { return type < 7 ? powers[type] : 0; }
-    uint32_t getMaxPowerByType(uint8_t type) const { return type < 7 ? maxPowers[type] : 0; }
-
     uint8_t getPowerType() const { return powerType; }
     void setPowerType(uint8_t t) { powerType = t; }
 
@@ -261,10 +245,6 @@ public:
     uint32_t getNpcFlags() const { return npcFlags; }
     void setNpcFlags(uint32_t f) { npcFlags = f; }
 
-    // NPC emote state (UNIT_NPC_EMOTESTATE) — persistent looping animation for NPCs
-    uint32_t getNpcEmoteState() const { return npcEmoteState; }
-    void setNpcEmoteState(uint32_t e) { npcEmoteState = e; }
-
     // Returns true if NPC has interaction flags (gossip/vendor/quest/trainer)
     bool isInteractable() const { return npcFlags != 0; }
 
@@ -288,21 +268,24 @@ protected:
     uint32_t unitFlags = 0;
     uint32_t dynamicFlags = 0;
     uint32_t npcFlags = 0;
-    uint32_t npcEmoteState = 0;
     uint32_t factionTemplate = 0;
     bool hostile = false;
 };
 
 /**
  * Player entity
- * Name is inherited from Unit — do NOT redeclare it here or the
- * shadowed field will diverge from Unit::name, causing nameplates
- * and other Unit*-based lookups to read an empty string.
  */
 class Player : public Unit {
 public:
     Player() { type = ObjectType::PLAYER; }
     explicit Player(uint64_t guid) : Unit(guid) { type = ObjectType::PLAYER; }
+
+    // Name
+    const std::string& getName() const { return name; }
+    void setName(const std::string& n) { name = n; }
+
+protected:
+    std::string name;
 };
 
 /**
@@ -346,7 +329,7 @@ public:
     bool hasEntity(uint64_t guid) const;
 
     // Get all entities
-    const std::unordered_map<uint64_t, std::shared_ptr<Entity>>& getEntities() const {
+    const std::map<uint64_t, std::shared_ptr<Entity>>& getEntities() const {
         return entities;
     }
 
@@ -361,7 +344,7 @@ public:
     }
 
 private:
-    std::unordered_map<uint64_t, std::shared_ptr<Entity>> entities;
+    std::map<uint64_t, std::shared_ptr<Entity>> entities;
 };
 
 } // namespace game
diff --git a/include/game/entity_controller.hpp b/include/game/entity_controller.hpp
deleted file mode 100644
index f114b8ad..00000000
--- a/include/game/entity_controller.hpp
+++ /dev/null
@@ -1,274 +0,0 @@
-#pragma once
-
-#include "game/world_packets.hpp"
-#include "game/entity.hpp"
-#include "game/opcode_table.hpp"
-#include "network/packet.hpp"
-#include <chrono>
-#include <deque>
-#include <functional>
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <glm/vec3.hpp>
-
-namespace wowee {
-namespace game {
-
-class GameHandler;
-
-class EntityController {
-public:
-    using PacketHandler = std::function<void(network::Packet&)>;
-    using DispatchTable = std::unordered_map<LogicalOpcode, PacketHandler>;
-
-    explicit EntityController(GameHandler& owner);
-
-    void registerOpcodes(DispatchTable& table);
-
-    // --- Entity Manager access ---
-    EntityManager& getEntityManager() { return entityManager; }
-    const EntityManager& getEntityManager() const { return entityManager; }
-
-    // --- Name / info cache queries ---
-    void queryPlayerName(uint64_t guid);
-    void queryCreatureInfo(uint32_t entry, uint64_t guid);
-    void queryGameObjectInfo(uint32_t entry, uint64_t guid);
-    std::string getCachedPlayerName(uint64_t guid) const;
-    std::string getCachedCreatureName(uint32_t entry) const;
-    void invalidatePlayerName(uint64_t guid) { playerNameCache.erase(guid); }
-
-    // Read-only cache access for other handlers
-    const std::unordered_map<uint64_t, std::string>& getPlayerNameCache() const { return playerNameCache; }
-    const std::unordered_map<uint32_t, CreatureQueryResponseData>& getCreatureInfoCache() const { return creatureInfoCache; }
-    std::string getCachedCreatureSubName(uint32_t entry) const {
-        auto it = creatureInfoCache.find(entry);
-        return (it != creatureInfoCache.end()) ? it->second.subName : "";
-    }
-    int getCreatureRank(uint32_t entry) const {
-        auto it = creatureInfoCache.find(entry);
-        return (it != creatureInfoCache.end()) ? static_cast<int>(it->second.rank) : -1;
-    }
-    uint32_t getCreatureType(uint32_t entry) const {
-        auto it = creatureInfoCache.find(entry);
-        return (it != creatureInfoCache.end()) ? it->second.creatureType : 0;
-    }
-    uint32_t getCreatureFamily(uint32_t entry) const {
-        auto it = creatureInfoCache.find(entry);
-        return (it != creatureInfoCache.end()) ? it->second.family : 0;
-    }
-    const GameObjectQueryResponseData* getCachedGameObjectInfo(uint32_t entry) const {
-        auto it = gameObjectInfoCache_.find(entry);
-        return (it != gameObjectInfoCache_.end()) ? &it->second : nullptr;
-    }
-
-    // Name lookup (checks cache then entity manager)
-    const std::string& lookupName(uint64_t guid) const {
-        static const std::string kEmpty;
-        auto it = playerNameCache.find(guid);
-        if (it != playerNameCache.end()) return it->second;
-        auto entity = entityManager.getEntity(guid);
-        if (entity) {
-            if (auto* unit = dynamic_cast<const Unit*>(entity.get())) {
-                if (!unit->getName().empty()) return unit->getName();
-            }
-        }
-        return kEmpty;
-    }
-    uint8_t lookupPlayerClass(uint64_t guid) const {
-        auto it = playerClassRaceCache_.find(guid);
-        return it != playerClassRaceCache_.end() ? it->second.classId : 0;
-    }
-    uint8_t lookupPlayerRace(uint64_t guid) const {
-        auto it = playerClassRaceCache_.find(guid);
-        return it != playerClassRaceCache_.end() ? it->second.raceId : 0;
-    }
-
-    // --- Transport GUID tracking ---
-    bool isTransportGuid(uint64_t guid) const { return transportGuids_.count(guid) > 0; }
-    bool hasServerTransportUpdate(uint64_t guid) const { return serverUpdatedTransportGuids_.count(guid) > 0; }
-
-    // --- Update object work queue ---
-    void enqueueUpdateObjectWork(UpdateObjectData&& data);
-    void processPendingUpdateObjectWork(const std::chrono::steady_clock::time_point& start,
-                                        float budgetMs);
-    bool hasPendingUpdateObjectWork() const { return !pendingUpdateObjectWork_.empty(); }
-
-    // --- Reset all state (called on disconnect / character switch) ---
-    void clearAll();
-
-private:
-    GameHandler& owner_;
-
-    // --- Entity tracking ---
-    EntityManager entityManager;              // Manages all entities in view
-
-    // ---- Name caches ----
-    std::unordered_map<uint64_t, std::string> playerNameCache;
-    // Class/race cache from SMSG_NAME_QUERY_RESPONSE (guid → {classId, raceId})
-    struct PlayerClassRace { uint8_t classId = 0; uint8_t raceId = 0; };
-    std::unordered_map<uint64_t, PlayerClassRace> playerClassRaceCache_;
-    std::unordered_set<uint64_t> pendingNameQueries;
-    std::unordered_map<uint32_t, CreatureQueryResponseData> creatureInfoCache;
-    std::unordered_set<uint32_t> pendingCreatureQueries;
-    std::unordered_map<uint32_t, GameObjectQueryResponseData> gameObjectInfoCache_;
-    std::unordered_set<uint32_t> pendingGameObjectQueries_;
-
-    // --- Update Object work queue ---
-    struct PendingUpdateObjectWork {
-        UpdateObjectData data;
-        size_t nextBlockIndex = 0;
-        bool outOfRangeProcessed = false;
-        bool newItemCreated = false;
-    };
-    std::deque<PendingUpdateObjectWork> pendingUpdateObjectWork_;
-
-    // --- Transport GUID tracking ---
-    std::unordered_set<uint64_t> transportGuids_;  // GUIDs of known transport GameObjects
-    std::unordered_set<uint64_t> serverUpdatedTransportGuids_;
-
-    // --- Packet handlers ---
-    void handleUpdateObject(network::Packet& packet);
-    void handleCompressedUpdateObject(network::Packet& packet);
-    void handleDestroyObject(network::Packet& packet);
-    void handleNameQueryResponse(network::Packet& packet);
-    void handleCreatureQueryResponse(network::Packet& packet);
-    void handleGameObjectQueryResponse(network::Packet& packet);
-    void handleGameObjectPageText(network::Packet& packet);
-    void handlePageTextQueryResponse(network::Packet& packet);
-
-    // --- Entity lifecycle ---
-    void processOutOfRangeObjects(const std::vector<uint64_t>& guids);
-    void applyUpdateObjectBlock(const UpdateBlock& block, bool& newItemCreated);
-    void finalizeUpdateObjectBatch(bool newItemCreated);
-
-    bool extractPlayerAppearance(const std::map<uint16_t, uint32_t>& fields,
-                                 uint8_t& outRace, uint8_t& outGender,
-                                 uint32_t& outAppearanceBytes, uint8_t& outFacial) const;
-    void maybeDetectCoinageIndex(const std::map<uint16_t, uint32_t>& oldFields,
-                                 const std::map<uint16_t, uint32_t>& newFields);
-
-    void handleCreateObject(const UpdateBlock& block, bool& newItemCreated);
-    void handleValuesUpdate(const UpdateBlock& block);
-    void handleMovementUpdate(const UpdateBlock& block);
-
-    // Update transport-relative child attachment (non-player entities).
-    //     Consolidates identical logic from CREATE/VALUES/MOVEMENT handlers.
-    void updateNonPlayerTransportAttachment(const UpdateBlock& block,
-                                            const std::shared_ptr<Entity>& entity,
-                                            ObjectType entityType);
-    // Rebuild playerAuras_ from UNIT_FIELD_AURAS (Classic/vanilla only).
-    //     Consolidates identical logic from CREATE and VALUES handlers.
-    void syncClassicAurasFromFields(const std::shared_ptr<Entity>& entity);
-    // Detect mount/dismount from UNIT_FIELD_MOUNTDISPLAYID changes (self-player only).
-    //     Consolidates identical logic from CREATE and VALUES handlers.
-    void detectPlayerMountChange(uint32_t newMountDisplayId,
-                                 const std::map<uint16_t, uint32_t>& blockFields);
-
-    // Shared player-death handler: caches corpse position, sets death state.
-    void markPlayerDead(const char* source);
-
-    // Cached field indices resolved once per handler call to avoid repeated lookups.
-    struct UnitFieldIndices {
-        uint16_t health, maxHealth, powerBase, maxPowerBase;
-        uint16_t level, faction, flags, dynFlags;
-        uint16_t displayId, mountDisplayId, npcFlags, npcEmoteState;
-        uint16_t bytes0, bytes1;
-        static UnitFieldIndices resolve();
-    };
-    struct PlayerFieldIndices {
-        uint16_t xp, nextXp, restedXp, level;
-        uint16_t coinage, honor, arena;
-        uint16_t playerFlags, armor;
-        uint16_t pBytes, pBytes2, chosenTitle;
-        uint16_t stats[5];
-        uint16_t meleeAP, rangedAP;
-        uint16_t spDmg1, healBonus;
-        uint16_t blockPct, dodgePct, parryPct, critPct, rangedCritPct;
-        uint16_t sCrit1, rating1;
-        static PlayerFieldIndices resolve();
-    };
-    struct UnitFieldUpdateResult {
-        bool healthChanged = false;
-        bool powerChanged = false;
-        bool displayIdChanged = false;
-        bool npcDeathNotified = false;
-        bool npcRespawnNotified = false;
-        uint32_t oldDisplayId = 0;
-    };
-
-    // Entity factory — creates the correct Entity subclass for the given block.
-    std::shared_ptr<Entity> createEntityFromBlock(const UpdateBlock& block);
-    // Track player-on-transport state from movement blocks.
-    void applyPlayerTransportState(const UpdateBlock& block,
-                                    const std::shared_ptr<Entity>& entity,
-                                    const glm::vec3& canonicalPos, float oCanonical,
-                                    bool updateMovementInfoPos);
-    // Apply unit fields during CREATE — returns true if entity is initially dead.
-    bool applyUnitFieldsOnCreate(const UpdateBlock& block,
-                                  std::shared_ptr<Unit>& unit,
-                                  const UnitFieldIndices& ufi);
-    // Apply unit fields during VALUES — returns change tracking result.
-    UnitFieldUpdateResult applyUnitFieldsOnUpdate(const UpdateBlock& block,
-                                                    const std::shared_ptr<Entity>& entity,
-                                                    std::shared_ptr<Unit>& unit,
-                                                    const UnitFieldIndices& ufi);
-    // Apply player stat fields (XP, inventory, skills, etc.). isCreate=true for CREATE path.
-    bool applyPlayerStatFields(const std::map<uint16_t, uint32_t>& fields,
-                                const PlayerFieldIndices& pfi, bool isCreate);
-    // Dispatch spawn callbacks (creature/player) — deduplicates CREATE and VALUES paths.
-    void dispatchEntitySpawn(uint64_t guid, ObjectType objectType,
-                              const std::shared_ptr<Entity>& entity,
-                              const std::shared_ptr<Unit>& unit, bool isDead);
-    // Track item/container on CREATE.
-    void trackItemOnCreate(const UpdateBlock& block, bool& newItemCreated);
-    // Update item fields on VALUES update.
-    void updateItemOnValuesUpdate(const UpdateBlock& block,
-                                   const std::shared_ptr<Entity>& entity);
-
-    // Allows extending object-type handling without modifying handler dispatch.
-    struct IObjectTypeHandler {
-        virtual ~IObjectTypeHandler() = default;
-        virtual void onCreate(const UpdateBlock& /*block*/, std::shared_ptr<Entity>& /*entity*/,
-                              bool& /*newItemCreated*/) {}
-        virtual void onValuesUpdate(const UpdateBlock& /*block*/, std::shared_ptr<Entity>& /*entity*/) {}
-        virtual void onMovementUpdate(const UpdateBlock& /*block*/, std::shared_ptr<Entity>& /*entity*/) {}
-    };
-    struct UnitTypeHandler;
-    struct PlayerTypeHandler;
-    struct GameObjectTypeHandler;
-    struct ItemTypeHandler;
-    struct CorpseTypeHandler;
-    std::unordered_map<uint8_t, std::unique_ptr<IObjectTypeHandler>> typeHandlers_;
-    void initTypeHandlers();
-    IObjectTypeHandler* getTypeHandler(ObjectType type) const;
-
-    void onCreateUnit(const UpdateBlock& block, std::shared_ptr<Entity>& entity);
-    void onCreatePlayer(const UpdateBlock& block, std::shared_ptr<Entity>& entity);
-    void onCreateGameObject(const UpdateBlock& block, std::shared_ptr<Entity>& entity);
-    void onCreateItem(const UpdateBlock& block, bool& newItemCreated);
-    void onCreateCorpse(const UpdateBlock& block);
-    void handleDisplayIdChange(const UpdateBlock& block,
-                               const std::shared_ptr<Entity>& entity,
-                               const std::shared_ptr<Unit>& unit,
-                               const UnitFieldUpdateResult& result);
-    void onValuesUpdateUnit(const UpdateBlock& block, std::shared_ptr<Entity>& entity);
-    void onValuesUpdatePlayer(const UpdateBlock& block, std::shared_ptr<Entity>& entity);
-    void onValuesUpdateItem(const UpdateBlock& block, std::shared_ptr<Entity>& entity);
-    void onValuesUpdateGameObject(const UpdateBlock& block, std::shared_ptr<Entity>& entity);
-
-    // Collects addon events during block processing, flushes at the end.
-    struct PendingEvents {
-        std::vector<std::pair<std::string, std::vector<std::string>>> events;
-        void emit(const std::string& name, const std::vector<std::string>& args = {}) {
-            events.emplace_back(name, args);
-        }
-        void clear() { events.clear(); }
-    };
-    PendingEvents pendingEvents_;
-    void flushPendingEvents();
-};
-
-} // namespace game
-} // namespace wowee
diff --git a/include/game/game_handler.hpp b/include/game/game_handler.hpp
index 0d2883f6..53029471 100644
--- a/include/game/game_handler.hpp
+++ b/include/game/game_handler.hpp
@@ -7,14 +7,6 @@
 #include "game/inventory.hpp"
 #include "game/spell_defines.hpp"
 #include "game/group_defines.hpp"
-#include "game/handler_types.hpp"
-#include "game/combat_handler.hpp"
-#include "game/spell_handler.hpp"
-#include "game/quest_handler.hpp"
-#include "game/movement_handler.hpp"
-#include "game/entity_controller.hpp"
-#include "game/game_services.hpp"
-#include "network/packet.hpp"
 #include <glm/glm.hpp>
 #include <memory>
 #include <string>
@@ -29,7 +21,6 @@
 #include <optional>
 #include <algorithm>
 #include <chrono>
-#include <future>
 
 namespace wowee::game {
     class TransportManager;
@@ -38,11 +29,6 @@ namespace wowee::game {
     class WardenModule;
     class WardenModuleManager;
     class PacketParsers;
-    class ChatHandler;
-    class MovementHandler;
-    class InventoryHandler;
-    class SocialHandler;
-    class WardenHandler;
 }
 
 namespace wowee {
@@ -52,11 +38,8 @@ namespace game {
 
 struct PlayerSkill {
     uint32_t skillId = 0;
-    uint16_t value = 0;        // base + permanent item bonuses
+    uint16_t value = 0;
     uint16_t maxValue = 0;
-    uint16_t bonusTemp = 0;    // temporary buff bonus (food, potions, etc.)
-    uint16_t bonusPerm = 0;    // permanent spec/misc bonus (rarely non-zero)
-    uint16_t effectiveValue() const { return value + bonusTemp + bonusPerm; }
 };
 
 /**
@@ -72,24 +55,6 @@ enum class QuestGiverStatus : uint8_t {
     REWARD = 10        // ? (yellow)
 };
 
-/**
- * A single contact list entry (friend, ignore, or mute).
- */
-struct ContactEntry {
-    uint64_t    guid     = 0;
-    std::string name;
-    std::string note;
-    uint32_t    flags    = 0;   // 0x1=friend, 0x2=ignore, 0x4=mute
-    uint8_t     status   = 0;   // 0=offline, 1=online, 2=AFK, 3=DND
-    uint32_t    areaId   = 0;
-    uint32_t    level    = 0;
-    uint32_t    classId  = 0;
-
-    bool isFriend() const { return (flags & 0x1) != 0; }
-    bool isIgnored() const { return (flags & 0x2) != 0; }
-    bool isOnline()  const { return status != 0; }
-};
-
 /**
  * World connection state
  */
@@ -127,15 +92,29 @@ using WorldConnectFailureCallback = std::function<void(const std::string& reason
  */
 class GameHandler {
 public:
-    // Talent data structures (aliased from handler_types.hpp)
-    using TalentEntry = game::TalentEntry;
-    using TalentTabEntry = game::TalentTabEntry;
+    // Talent data structures (must be public for use in templates)
+    struct TalentEntry {
+        uint32_t talentId = 0;
+        uint32_t tabId = 0;           // Which talent tree
+        uint8_t row = 0;              // Tier (0-10)
+        uint8_t column = 0;           // Column (0-3)
+        uint32_t rankSpells[5] = {};  // Spell IDs for ranks 1-5
+        uint32_t prereqTalent[3] = {}; // Required talents
+        uint8_t prereqRank[3] = {};   // Required ranks
+        uint8_t maxRank = 0;          // Number of ranks (1-5)
+    };
 
-    explicit GameHandler(GameServices& services);
+    struct TalentTabEntry {
+        uint32_t tabId = 0;
+        std::string name;
+        uint32_t classMask = 0;       // Which classes can use this tab
+        uint8_t orderIndex = 0;       // Display order (0-2)
+        std::string backgroundFile;   // Texture path
+    };
+
+    GameHandler();
     ~GameHandler();
 
-    const GameServices& services() const { return services_; }
-
     /** Access the active opcode table (wire ↔ logical mapping). */
     const OpcodeTable& getOpcodeTable() const { return opcodeTable_; }
     OpcodeTable& getOpcodeTable() { return opcodeTable_; }
@@ -170,7 +149,6 @@ public:
      * Check if connected to world server
      */
     bool isConnected() const;
-    bool isInWorld() const { return state == WorldState::IN_WORLD && socket; }
 
     /**
      * Get current connection state
@@ -222,7 +200,6 @@ public:
         pos = homeBindPos_;
         return true;
     }
-    uint32_t getHomeBindZoneId() const { return homeBindZoneId_; }
 
     /**
      * Send a movement packet
@@ -247,8 +224,8 @@ public:
     /**
      * Get entity manager (for accessing entities in view)
      */
-    EntityManager& getEntityManager() { return entityController_->getEntityManager(); }
-    const EntityManager& getEntityManager() const { return entityController_->getEntityManager(); }
+    EntityManager& getEntityManager() { return entityManager; }
+    const EntityManager& getEntityManager() const { return entityManager; }
 
     /**
      * Send a chat message
@@ -260,57 +237,24 @@ public:
     void sendTextEmote(uint32_t textEmoteId, uint64_t targetGuid = 0);
     void joinChannel(const std::string& channelName, const std::string& password = "");
     void leaveChannel(const std::string& channelName);
-    const std::vector<std::string>& getJoinedChannels() const;
+    const std::vector<std::string>& getJoinedChannels() const { return joinedChannels_; }
     std::string getChannelByIndex(int index) const;
     int getChannelIndex(const std::string& channelName) const;
 
-    // Chat auto-join settings (aliased from handler_types.hpp)
-    using ChatAutoJoin = game::ChatAutoJoin;
+    // Chat auto-join settings (set by UI before autoJoinDefaultChannels)
+    struct ChatAutoJoin {
+        bool general = true;
+        bool trade = true;
+        bool localDefense = true;
+        bool lfg = true;
+        bool local = true;
+    };
     ChatAutoJoin chatAutoJoin;
-    void autoJoinDefaultChannels();
 
     // Chat bubble callback: (senderGuid, message, isYell)
     using ChatBubbleCallback = std::function<void(uint64_t, const std::string&, bool)>;
     void setChatBubbleCallback(ChatBubbleCallback cb) { chatBubbleCallback_ = std::move(cb); }
 
-    // Addon chat event callback: fires when any chat message is received (for Lua event dispatch)
-    using AddonChatCallback = std::function<void(const MessageChatData&)>;
-    void setAddonChatCallback(AddonChatCallback cb) { addonChatCallback_ = std::move(cb); }
-
-    // Generic addon event callback: fires named events with string args
-    using AddonEventCallback = std::function<void(const std::string&, const std::vector<std::string>&)>;
-    void setAddonEventCallback(AddonEventCallback cb) { addonEventCallback_ = std::move(cb); }
-
-    // Spell icon path resolver: spellId -> texture path string (e.g., "Interface\\Icons\\Spell_Fire_Fireball01")
-    using SpellIconPathResolver = std::function<std::string(uint32_t)>;
-    void setSpellIconPathResolver(SpellIconPathResolver r) { spellIconPathResolver_ = std::move(r); }
-    std::string getSpellIconPath(uint32_t spellId) const {
-        return spellIconPathResolver_ ? spellIconPathResolver_(spellId) : std::string{};
-    }
-
-    // Spell data resolver: spellId -> {castTimeMs, minRange, maxRange}
-    struct SpellDataInfo { uint32_t castTimeMs = 0; float minRange = 0; float maxRange = 0; uint32_t manaCost = 0; uint8_t powerType = 0; };
-    using SpellDataResolver = std::function<SpellDataInfo(uint32_t)>;
-    void setSpellDataResolver(SpellDataResolver r) { spellDataResolver_ = std::move(r); }
-    SpellDataInfo getSpellData(uint32_t spellId) const {
-        return spellDataResolver_ ? spellDataResolver_(spellId) : SpellDataInfo{};
-    }
-
-    // Item icon path resolver: displayInfoId -> texture path (e.g., "Interface\\Icons\\INV_Sword_04")
-    using ItemIconPathResolver = std::function<std::string(uint32_t)>;
-    void setItemIconPathResolver(ItemIconPathResolver r) { itemIconPathResolver_ = std::move(r); }
-    std::string getItemIconPath(uint32_t displayInfoId) const {
-        return itemIconPathResolver_ ? itemIconPathResolver_(displayInfoId) : std::string{};
-    }
-
-    // Random property/suffix name resolver: randomPropertyId -> suffix name (e.g., "of the Eagle")
-    // Positive IDs → ItemRandomProperties.dbc; negative IDs → ItemRandomSuffix.dbc (abs value)
-    using RandomPropertyNameResolver = std::function<std::string(int32_t)>;
-    void setRandomPropertyNameResolver(RandomPropertyNameResolver r) { randomPropertyNameResolver_ = std::move(r); }
-    std::string getRandomPropertyName(int32_t id) const {
-        return randomPropertyNameResolver_ ? randomPropertyNameResolver_(id) : std::string{};
-    }
-
     // Emote animation callback: (entityGuid, animationId)
     using EmoteAnimCallback = std::function<void(uint64_t, uint32_t)>;
     void setEmoteAnimCallback(EmoteAnimCallback cb) { emoteAnimCallback_ = std::move(cb); }
@@ -320,8 +264,7 @@ public:
      * @param maxMessages Maximum number of messages to return (0 = all)
      * @return Vector of chat messages
      */
-    const std::deque<MessageChatData>& getChatHistory() const;
-    void clearChatHistory();
+    const std::deque<MessageChatData>& getChatHistory() const { return chatHistory; }
 
     /**
      * Add a locally-generated chat message (e.g., emote feedback)
@@ -331,64 +274,9 @@ public:
     // Money (copper)
     uint64_t getMoneyCopper() const { return playerMoneyCopper_; }
 
-    // PvP currency (TBC/WotLK only)
-    uint32_t getHonorPoints() const { return playerHonorPoints_; }
-    uint32_t getArenaPoints() const { return playerArenaPoints_; }
-
     // Server-authoritative armor (UNIT_FIELD_RESISTANCES[0])
     int32_t getArmorRating() const { return playerArmorRating_; }
 
-    // Server-authoritative elemental resistances (UNIT_FIELD_RESISTANCES[1-6]).
-    // school: 1=Holy, 2=Fire, 3=Nature, 4=Frost, 5=Shadow, 6=Arcane. Returns 0 if not received.
-    int32_t getResistance(int school) const {
-        if (school < 1 || school > 6) return 0;
-        return playerResistances_[school - 1];
-    }
-
-    // Server-authoritative primary stats (UNIT_FIELD_STAT0-4: STR, AGI, STA, INT, SPI).
-    // Returns -1 if the server hasn't sent the value yet.
-    int32_t getPlayerStat(int idx) const {
-        if (idx < 0 || idx > 4) return -1;
-        return playerStats_[idx];
-    }
-
-    // Server-authoritative attack power (WotLK: UNIT_FIELD_ATTACK_POWER / RANGED).
-    // Returns -1 if not yet received.
-    int32_t getMeleeAttackPower()  const { return playerMeleeAP_; }
-    int32_t getRangedAttackPower() const { return playerRangedAP_; }
-
-    // Server-authoritative spell damage / healing bonus (WotLK: PLAYER_FIELD_MOD_*).
-    // getSpellPower returns the max damage bonus across magic schools 1-6 (Holy/Fire/Nature/Frost/Shadow/Arcane).
-    // Returns -1 if not yet received.
-    int32_t getSpellPower() const {
-        int32_t sp = -1;
-        for (int i = 1; i <= 6; ++i) {
-            if (playerSpellDmgBonus_[i] > sp) sp = playerSpellDmgBonus_[i];
-        }
-        return sp;
-    }
-    int32_t getHealingPower() const { return playerHealBonus_; }
-
-    // Server-authoritative combat chance percentages (WotLK: PLAYER_* float fields).
-    // Returns -1.0f if not yet received.
-    float getDodgePct()  const { return playerDodgePct_; }
-    float getParryPct()  const { return playerParryPct_; }
-    float getBlockPct()  const { return playerBlockPct_; }
-    float getCritPct()   const { return playerCritPct_; }
-    float getRangedCritPct() const { return playerRangedCritPct_; }
-    // Spell crit by school (0=Physical,1=Holy,2=Fire,3=Nature,4=Frost,5=Shadow,6=Arcane)
-    float getSpellCritPct(int school = 1) const {
-        if (school < 0 || school > 6) return -1.0f;
-        return playerSpellCritPct_[school];
-    }
-
-    // Server-authoritative combat ratings (WotLK: PLAYER_FIELD_COMBAT_RATING_1+idx).
-    // Returns -1 if not yet received. Indices match AzerothCore CombatRating enum.
-    int32_t getCombatRating(int cr) const {
-        if (cr < 0 || cr > 24) return -1;
-        return playerCombatRatings_[cr];
-    }
-
     // Inventory
     Inventory& getInventory() { return inventory; }
     const Inventory& getInventory() const { return inventory; }
@@ -411,10 +299,6 @@ public:
     std::shared_ptr<Entity> getFocus() const;
     bool hasFocus() const { return focusGuid != 0; }
 
-    // Mouseover targeting — set each frame by the nameplate renderer
-    void setMouseoverGuid(uint64_t guid);
-    uint64_t getMouseoverGuid() const { return mouseoverGuid_; }
-
     // Advanced targeting
     void targetLastTarget();
     void targetEnemy(bool reverse = false);
@@ -423,23 +307,10 @@ public:
     // Inspection
     void inspectTarget();
 
-    using InspectArenaTeam = game::InspectArenaTeam;
-    using InspectResult = game::InspectResult;
-    const InspectResult* getInspectResult() const {
-        return inspectResult_.guid ? &inspectResult_ : nullptr;
-    }
-
     // Server info commands
     void queryServerTime();
     void requestPlayedTime();
     void queryWho(const std::string& playerName = "");
-    uint32_t getTotalTimePlayed() const;
-    uint32_t getLevelTimePlayed() const;
-
-    using WhoEntry = game::WhoEntry;
-    const std::vector<WhoEntry>& getWhoResults() const;
-    uint32_t getWhoOnlineCount() const;
-    std::string getWhoAreaName(uint32_t zoneId) const { return getAreaName(zoneId); }
 
     // Social commands
     void addFriend(const std::string& playerName, const std::string& note = "");
@@ -447,47 +318,18 @@ public:
     void setFriendNote(const std::string& playerName, const std::string& note);
     void addIgnore(const std::string& playerName);
     void removeIgnore(const std::string& playerName);
-    const std::unordered_map<std::string, uint64_t>& getIgnoreCache() const { return ignoreCache; }
 
     // Random roll
     void randomRoll(uint32_t minRoll = 1, uint32_t maxRoll = 100);
 
-    // Battleground queue slot (aliased from handler_types.hpp)
-    using BgQueueSlot = game::BgQueueSlot;
-
-    // Available BG list (aliased from handler_types.hpp)
-    using AvailableBgInfo = game::AvailableBgInfo;
-
     // Battleground
     bool hasPendingBgInvite() const;
     void acceptBattlefield(uint32_t queueSlot = 0xFFFFFFFF);
-    void declineBattlefield(uint32_t queueSlot = 0xFFFFFFFF);
-    const std::array<BgQueueSlot, 3>& getBgQueues() const;
-    const std::vector<AvailableBgInfo>& getAvailableBgs() const;
-
-    // BG scoreboard (aliased from handler_types.hpp)
-    using BgPlayerScore = game::BgPlayerScore;
-    using ArenaTeamScore = game::ArenaTeamScore;
-    using BgScoreboardData = game::BgScoreboardData;
-    void requestPvpLog();
-    const BgScoreboardData* getBgScoreboard() const;
-
-    // BG flag carrier positions (aliased from handler_types.hpp)
-    using BgPlayerPosition = game::BgPlayerPosition;
-    const std::vector<BgPlayerPosition>& getBgPlayerPositions() const;
-
-    // Network latency (milliseconds, updated each PONG response)
-    uint32_t getLatencyMs() const { return lastLatency; }
 
     // Logout commands
     void requestLogout();
     void cancelLogout();
 
-    // Instance difficulty
-    void sendSetDifficulty(uint32_t difficulty);
-    bool  isLoggingOut() const;
-    float getLogoutCountdown() const;
-
     // Stand state
     void setStandState(uint8_t state);  // 0=stand, 1=sit, 2=sit_chair, 3=sleep, 4=sit_low_chair, 5=sit_medium_chair, 6=sit_high_chair, 7=dead, 8=kneel, 9=submerged
     uint8_t getStandState() const { return standState_; }
@@ -498,20 +340,14 @@ public:
     // Display toggles
     void toggleHelm();
     void toggleCloak();
-    bool isHelmVisible() const { return helmVisible_; }
-    bool isCloakVisible() const { return cloakVisible_; }
 
     // Follow/Assist
     void followTarget();
-    void cancelFollow();   // Stop following current target
     void assistTarget();
 
     // PvP
     void togglePvp();
 
-    // Minimap ping (Ctrl+click on minimap; wowX/wowY in canonical WoW coords)
-    void sendMinimapPing(float wowX, float wowY);
-
     // Guild commands
     void requestGuildInfo();
     void requestGuildRoster();
@@ -527,28 +363,6 @@ public:
     void setGuildOfficerNote(const std::string& name, const std::string& note);
     void acceptGuildInvite();
     void declineGuildInvite();
-
-    // GM Ticket
-    void submitGmTicket(const std::string& text);
-    void deleteGmTicket();
-    void requestGmTicket();          ///< Send CMSG_GMTICKET_GETTICKET to query open ticket
-
-    // GM ticket status accessors
-    bool hasActiveGmTicket() const { return gmTicketActive_; }
-    const std::string& getGmTicketText() const { return gmTicketText_; }
-    bool isGmSupportAvailable() const { return gmSupportAvailable_; }
-    float getGmTicketWaitHours() const { return gmTicketWaitHours_; }
-
-    // Battlefield Manager (Wintergrasp)
-    bool hasBfMgrInvite()  const { return bfMgrInvitePending_; }
-    bool isInBfMgrZone()   const { return bfMgrActive_; }
-    uint32_t getBfMgrZoneId() const { return bfMgrZoneId_; }
-    void acceptBfMgrInvite();
-    void declineBfMgrInvite();
-
-    // WotLK Calendar
-    uint32_t getCalendarPendingInvites() const { return calendarPendingInvites_; }
-    void requestCalendar(); ///< Send CMSG_CALENDAR_GET_CALENDAR to the server
     void queryGuildInfo(uint32_t guildId);
     void createGuild(const std::string& guildName);
     void addGuildRank(const std::string& rankName);
@@ -557,45 +371,32 @@ public:
     void buyPetition(uint64_t npcGuid, const std::string& guildName);
 
     // Guild state accessors
-    bool isInGuild() const;
-    const std::string& getGuildName() const;
-    const GuildRosterData& getGuildRoster() const;
-    bool hasGuildRoster() const;
-    const std::vector<std::string>& getGuildRankNames() const;
-    bool hasPendingGuildInvite() const;
-    const std::string& getPendingGuildInviterName() const;
-    const std::string& getPendingGuildInviteGuildName() const;
-    const GuildInfoData& getGuildInfoData() const;
-    const GuildQueryResponseData& getGuildQueryData() const;
-    bool hasGuildInfoData() const;
-    bool hasPetitionShowlist() const;
+    bool isInGuild() const {
+        if (!guildName_.empty()) return true;
+        const Character* ch = getActiveCharacter();
+        return ch && ch->hasGuild();
+    }
+    const std::string& getGuildName() const { return guildName_; }
+    const GuildRosterData& getGuildRoster() const { return guildRoster_; }
+    bool hasGuildRoster() const { return hasGuildRoster_; }
+    const std::vector<std::string>& getGuildRankNames() const { return guildRankNames_; }
+    bool hasPendingGuildInvite() const { return pendingGuildInvite_; }
+    const std::string& getPendingGuildInviterName() const { return pendingGuildInviterName_; }
+    const std::string& getPendingGuildInviteGuildName() const { return pendingGuildInviteGuildName_; }
+    const GuildInfoData& getGuildInfoData() const { return guildInfoData_; }
+    const GuildQueryResponseData& getGuildQueryData() const { return guildQueryData_; }
+    bool hasGuildInfoData() const { return guildInfoData_.isValid(); }
+    bool hasPetitionShowlist() const { return showPetitionDialog_; }
     void clearPetitionDialog() { showPetitionDialog_ = false; }
-    uint32_t getPetitionCost() const;
-    uint64_t getPetitionNpcGuid() const;
+    uint32_t getPetitionCost() const { return petitionCost_; }
+    uint64_t getPetitionNpcGuid() const { return petitionNpcGuid_; }
 
-    // Petition signatures (guild charter signing flow)
-    using PetitionSignature = game::PetitionSignature;
-    using PetitionInfo = game::PetitionInfo;
-    const PetitionInfo& getPetitionInfo() const;
-    bool hasPetitionSignaturesUI() const;
-    void clearPetitionSignaturesUI() { petitionInfo_.showUI = false; }
-    void signPetition(uint64_t petitionGuid);
-    void turnInPetition(uint64_t petitionGuid);
-
-    // Guild name lookup for other players' nameplates
-    // Returns the guild name for a given guildId, or empty if unknown.
-    // Automatically queries the server for unknown guild IDs.
-    const std::string& lookupGuildName(uint32_t guildId);
-    // Returns the guildId for a player entity (from PLAYER_GUILDID update field).
-    uint32_t getEntityGuildId(uint64_t guid) const;
-
-    using ReadyCheckResult = game::ReadyCheckResult;
+    // Ready check
     void initiateReadyCheck();
     void respondToReadyCheck(bool ready);
-    bool hasPendingReadyCheck() const;
+    bool hasPendingReadyCheck() const { return pendingReadyCheck_; }
     void dismissReadyCheck() { pendingReadyCheck_ = false; }
-    const std::string& getReadyCheckInitiator() const;
-    const std::vector<ReadyCheckResult>& getReadyCheckResults() const;
+    const std::string& getReadyCheckInitiator() const { return readyCheckInitiator_; }
 
     // Duel
     void forfeitDuel();
@@ -603,19 +404,8 @@ public:
     // AFK/DND status
     void toggleAfk(const std::string& message = "");
     void toggleDnd(const std::string& message = "");
-    bool isAfk() const { return afkStatus_; }
-    bool isDnd() const { return dndStatus_; }
     void replyToLastWhisper(const std::string& message);
-    std::string getLastWhisperSender() const {
-        if (!lastWhisperSender_.empty()) return lastWhisperSender_;
-        // Name may not have been cached when whisper arrived — resolve from GUID
-        if (lastWhisperSenderGuid_ != 0) {
-            const auto& cache = getPlayerNameCache();
-            auto it = cache.find(lastWhisperSenderGuid_);
-            if (it != cache.end()) return it->second;
-        }
-        return "";
-    }
+    std::string getLastWhisperSender() const { return lastWhisperSender_; }
     void setLastWhisperSender(const std::string& name) { lastWhisperSender_ = name; }
 
     // Party/Raid management
@@ -630,137 +420,43 @@ public:
     // Combat and Trade
     void proposeDuel(uint64_t targetGuid);
     void initiateTrade(uint64_t targetGuid);
-    void reportPlayer(uint64_t targetGuid, const std::string& reason);
     void stopCasting();
-    void resetCastState();       // force-clear all cast/craft/queue state without sending packets
-    void resetWardenState();     // clear all warden module/crypto state for connect/disconnect
-    void clearUnitCaches();      // clear per-unit cast states and aura caches
 
+    // ---- Phase 1: Name queries ----
     void queryPlayerName(uint64_t guid);
     void queryCreatureInfo(uint32_t entry, uint64_t guid);
     void queryGameObjectInfo(uint32_t entry, uint64_t guid);
     const GameObjectQueryResponseData* getCachedGameObjectInfo(uint32_t entry) const {
-        return entityController_->getCachedGameObjectInfo(entry);
+        auto it = gameObjectInfoCache_.find(entry);
+        return (it != gameObjectInfoCache_.end()) ? &it->second : nullptr;
     }
     std::string getCachedPlayerName(uint64_t guid) const;
     std::string getCachedCreatureName(uint32_t entry) const;
-    // Read-only cache access forwarded from EntityController
-    const std::unordered_map<uint64_t, std::string>& getPlayerNameCache() const {
-        return entityController_->getPlayerNameCache();
-    }
-    const std::unordered_map<uint32_t, CreatureQueryResponseData>& getCreatureInfoCache() const {
-        return entityController_->getCreatureInfoCache();
-    }
-    // Returns the creature subname/title (e.g. "<Warchief of the Horde>"), empty if not cached
-    std::string getCachedCreatureSubName(uint32_t entry) const {
-        return entityController_->getCachedCreatureSubName(entry);
-    }
-    // Returns the creature rank (0=Normal,1=Elite,2=RareElite,3=Boss,4=Rare)
-    // or -1 if not cached yet
-    int getCreatureRank(uint32_t entry) const {
-        return entityController_->getCreatureRank(entry);
-    }
-    // Returns creature type (1=Beast,2=Dragonkin,...,7=Humanoid,...) or 0 if not cached
-    uint32_t getCreatureType(uint32_t entry) const {
-        return entityController_->getCreatureType(entry);
-    }
-    // Returns creature family (e.g. pet family for beasts) or 0
-    uint32_t getCreatureFamily(uint32_t entry) const {
-        return entityController_->getCreatureFamily(entry);
-    }
 
+    // ---- Phase 2: Combat ----
     void startAutoAttack(uint64_t targetGuid);
     void stopAutoAttack();
-    bool isAutoAttacking() const;
-    bool hasAutoAttackIntent() const;
-    bool isInCombat() const;
-    bool isInCombatWith(uint64_t guid) const;
-    uint64_t getAutoAttackTargetGuid() const;
-    bool isAggressiveTowardPlayer(uint64_t guid) const;
-    // Timestamp (ms since epoch) of the most recent player melee auto-attack.
-    // Zero if no swing has occurred this session.
-    uint64_t getLastMeleeSwingMs() const;
-    const std::vector<CombatTextEntry>& getCombatText() const;
-    void clearCombatText();
-    void updateCombatText(float deltaTime);
-    void clearHostileAttackers();
-
-    // Combat log (persistent rolling history, max MAX_COMBAT_LOG entries)
-    const std::deque<CombatLogEntry>& getCombatLog() const;
-    void clearCombatLog();
-
-    // Area trigger messages (SMSG_AREA_TRIGGER_MESSAGE) — drained by UI each frame
-    bool hasAreaTriggerMsg() const { return !areaTriggerMsgs_.empty(); }
-    std::string popAreaTriggerMsg() {
-        if (areaTriggerMsgs_.empty()) return {};
-        std::string msg = areaTriggerMsgs_.front();
-        areaTriggerMsgs_.pop_front();
-        return msg;
+    bool isAutoAttacking() const { return autoAttacking; }
+    bool hasAutoAttackIntent() const { return autoAttackRequested_; }
+    bool isInCombat() const { return autoAttacking || !hostileAttackers_.empty(); }
+    bool isInCombatWith(uint64_t guid) const {
+        return guid != 0 &&
+               ((autoAttacking && autoAttackTarget == guid) ||
+                (hostileAttackers_.count(guid) > 0));
     }
+    uint64_t getAutoAttackTargetGuid() const { return autoAttackTarget; }
+    bool isAggressiveTowardPlayer(uint64_t guid) const { return hostileAttackers_.count(guid) > 0; }
+    const std::vector<CombatTextEntry>& getCombatText() const { return combatText; }
+    void updateCombatText(float deltaTime);
 
-    // Threat
-    using ThreatEntry = CombatHandler::ThreatEntry;
-    const std::vector<ThreatEntry>* getThreatList(uint64_t unitGuid) const;
-    const std::vector<ThreatEntry>* getTargetThreatList() const;
-
+    // ---- Phase 3: Spells ----
     void castSpell(uint32_t spellId, uint64_t targetGuid = 0);
     void cancelCast();
     void cancelAura(uint32_t spellId);
     void dismissPet();
-    void renamePet(const std::string& newName);
     bool hasPet() const { return petGuid_ != 0; }
-    // Returns true once after SMSG_PET_RENAMEABLE; consuming the flag clears it.
-    bool consumePetRenameablePending() { bool v = petRenameablePending_; petRenameablePending_ = false; return v; }
     uint64_t getPetGuid() const { return petGuid_; }
-
-    // ---- Pet state (populated by SMSG_PET_SPELLS / SMSG_PET_MODE) ----
-    // 10 action bar slots; each entry is a packed uint32:
-    //   bits 0-23  = spell ID (or 0 for empty)
-    //   bits 24-31 = action type (0x00=cast, 0xC0=autocast on, 0x40=autocast off)
-    static constexpr int PET_ACTION_BAR_SLOTS = 10;
-    uint32_t getPetActionSlot(int idx) const {
-        if (idx < 0 || idx >= PET_ACTION_BAR_SLOTS) return 0;
-        return petActionSlots_[idx];
-    }
-    // Pet command/react state from SMSG_PET_MODE or SMSG_PET_SPELLS
-    uint8_t getPetCommand() const { return petCommand_; }   // 0=stay,1=follow,2=attack,3=dismiss
-    uint8_t getPetReact()   const { return petReact_; }     // 0=passive,1=defensive,2=aggressive
-    // Spells the pet knows (from SMSG_PET_SPELLS spell list)
-    const std::vector<uint32_t>& getPetSpells() const { return petSpellList_; }
-    // Pet autocast set (spellIds that have autocast enabled)
-    bool isPetSpellAutocast(uint32_t spellId) const {
-        return petAutocastSpells_.count(spellId) != 0;
-    }
-    // Send CMSG_PET_ACTION to issue a pet command
-    void sendPetAction(uint32_t action, uint64_t targetGuid = 0);
-    // Toggle autocast for a pet spell via CMSG_PET_SPELL_AUTOCAST
-    void togglePetSpellAutocast(uint32_t spellId);
-    const std::unordered_set<uint32_t>& getKnownSpells() const {
-        static const std::unordered_set<uint32_t> empty;
-        return spellHandler_ ? spellHandler_->getKnownSpells() : empty;
-    }
-
-    // Spell book tabs — groups known spells by class skill line for Lua API
-    using SpellBookTab = SpellHandler::SpellBookTab;
-    const std::vector<SpellBookTab>& getSpellBookTabs();
-
-    // ---- Pet Stable ----
-    struct StabledPet {
-        uint32_t petNumber  = 0;   // server-side pet number (used for unstable/swap)
-        uint32_t entry      = 0;   // creature entry ID
-        uint32_t level      = 0;
-        std::string name;
-        uint32_t displayId  = 0;
-        bool     isActive   = false;  // true = currently summoned/active slot
-    };
-    bool isStableWindowOpen() const { return stableWindowOpen_; }
-    void closeStableWindow() { stableWindowOpen_ = false; }
-    uint64_t getStableMasterGuid() const { return stableMasterGuid_; }
-    uint8_t  getStableSlots() const { return stableNumSlots_; }
-    const std::vector<StabledPet>& getStabledPets() const { return stabledPets_; }
-    void requestStabledPetList();          // CMSG MSG_LIST_STABLED_PETS
-    void stablePet(uint8_t slot);          // CMSG_STABLE_PET (store active pet in slot)
-    void unstablePet(uint32_t petNumber);  // CMSG_UNSTABLE_PET (retrieve to active)
+    const std::unordered_set<uint32_t>& getKnownSpells() const { return knownSpells; }
 
     // Player proficiency bitmasks (from SMSG_SET_PROFICIENCY)
     // itemClass 2 = Weapon (subClassMask bits: 0=Axe1H,1=Axe2H,2=Bow,3=Gun,4=Mace1H,5=Mace2H,6=Polearm,7=Sword1H,8=Sword2H,10=Staff,13=Fist,14=Misc,15=Dagger,16=Thrown,17=Crossbow,18=Wand,19=Fishing)
@@ -770,87 +466,26 @@ public:
     bool canUseWeaponSubclass(uint32_t subClass) const { return (weaponProficiency_ >> subClass) & 1u; }
     bool canUseArmorSubclass(uint32_t subClass)  const { return (armorProficiency_  >> subClass) & 1u; }
 
-    // Minimap pings from party members
-    struct MinimapPing {
-        uint64_t senderGuid = 0;
-        float    wowX       = 0.0f;  // canonical WoW X (north)
-        float    wowY       = 0.0f;  // canonical WoW Y (west)
-        float    age        = 0.0f;  // seconds since received
-        static constexpr float LIFETIME = 5.0f;
-        bool isExpired() const { return age >= LIFETIME; }
-    };
-    const std::vector<MinimapPing>& getMinimapPings() const { return minimapPings_; }
-    void tickMinimapPings(float dt) {
-        for (auto& p : minimapPings_) p.age += dt;
-        minimapPings_.erase(
-            std::remove_if(minimapPings_.begin(), minimapPings_.end(),
-                           [](const MinimapPing& p){ return p.isExpired(); }),
-            minimapPings_.end());
-    }
-
-    bool isCasting() const { return spellHandler_ ? spellHandler_->isCasting() : false; }
-    bool isChanneling() const { return spellHandler_ ? spellHandler_->isChanneling() : false; }
+    bool isCasting() const { return casting; }
     bool isGameObjectInteractionCasting() const {
-        return spellHandler_ ? spellHandler_->isGameObjectInteractionCasting() : false;
+        return casting && currentCastSpellId == 0 && pendingGameObjectInteractGuid_ != 0;
     }
-    uint32_t getCurrentCastSpellId() const { return spellHandler_ ? spellHandler_->getCurrentCastSpellId() : 0; }
-    float getCastProgress() const { return spellHandler_ ? spellHandler_->getCastProgress() : 0.0f; }
-    float getCastTimeRemaining() const { return spellHandler_ ? spellHandler_->getCastTimeRemaining() : 0.0f; }
-    float getCastTimeTotal() const { return spellHandler_ ? spellHandler_->getCastTimeTotal() : 0.0f; }
+    uint32_t getCurrentCastSpellId() const { return currentCastSpellId; }
+    float getCastProgress() const { return castTimeTotal > 0 ? (castTimeTotal - castTimeRemaining) / castTimeTotal : 0.0f; }
+    float getCastTimeRemaining() const { return castTimeRemaining; }
 
-    // Repeat-craft queue
-    void startCraftQueue(uint32_t spellId, int count);
-    void cancelCraftQueue();
-    int getCraftQueueRemaining() const;
-    uint32_t getCraftQueueSpellId() const;
-
-    // 400ms spell-queue window: next spell to cast when current finishes
-    uint32_t getQueuedSpellId() const;
-    void cancelQueuedSpell() { if (spellHandler_) spellHandler_->cancelQueuedSpell(); }
-
-    // Unit cast state (aliased from handler_types.hpp)
-    using UnitCastState = game::UnitCastState;
-    // Returns cast state for any unit by GUID (delegates to SpellHandler)
-    const UnitCastState* getUnitCastState(uint64_t guid) const {
-        if (spellHandler_) return spellHandler_->getUnitCastState(guid);
-        return nullptr;
-    }
-    // Convenience helpers for the current target
-    bool isTargetCasting() const { return spellHandler_ ? spellHandler_->isTargetCasting() : false; }
-    uint32_t getTargetCastSpellId() const { return spellHandler_ ? spellHandler_->getTargetCastSpellId() : 0; }
-    float getTargetCastProgress() const { return spellHandler_ ? spellHandler_->getTargetCastProgress() : 0.0f; }
-    float getTargetCastTimeRemaining() const { return spellHandler_ ? spellHandler_->getTargetCastTimeRemaining() : 0.0f; }
-    bool isTargetCastInterruptible() const { return spellHandler_ ? spellHandler_->isTargetCastInterruptible() : true; }
-
-    // Talents — delegate to SpellHandler as canonical authority
-    uint8_t getActiveTalentSpec() const { return spellHandler_ ? spellHandler_->getActiveTalentSpec() : 0; }
-    uint8_t getUnspentTalentPoints() const { return spellHandler_ ? spellHandler_->getUnspentTalentPoints() : 0; }
-    uint8_t getUnspentTalentPoints(uint8_t spec) const { return spellHandler_ ? spellHandler_->getUnspentTalentPoints(spec) : 0; }
-    const std::unordered_map<uint32_t, uint8_t>& getLearnedTalents() const {
-        if (spellHandler_) return spellHandler_->getLearnedTalents();
-        static const std::unordered_map<uint32_t, uint8_t> empty;
-        return empty;
-    }
+    // Talents
+    uint8_t getActiveTalentSpec() const { return activeTalentSpec_; }
+    uint8_t getUnspentTalentPoints() const { return unspentTalentPoints_[activeTalentSpec_]; }
+    uint8_t getUnspentTalentPoints(uint8_t spec) const { return spec < 2 ? unspentTalentPoints_[spec] : 0; }
+    const std::unordered_map<uint32_t, uint8_t>& getLearnedTalents() const { return learnedTalents_[activeTalentSpec_]; }
     const std::unordered_map<uint32_t, uint8_t>& getLearnedTalents(uint8_t spec) const {
-        if (spellHandler_) return spellHandler_->getLearnedTalents(spec);
-        static const std::unordered_map<uint32_t, uint8_t> empty;
-        return empty;
-    }
-
-    // Glyphs (WotLK): up to 6 glyph slots per spec (3 major + 3 minor)
-    static constexpr uint8_t MAX_GLYPH_SLOTS = 6;
-    const std::array<uint16_t, MAX_GLYPH_SLOTS>& getGlyphs() const {
-        if (spellHandler_) return spellHandler_->getGlyphs();
-        static const std::array<uint16_t, MAX_GLYPH_SLOTS> empty{};
-        return empty;
-    }
-    const std::array<uint16_t, MAX_GLYPH_SLOTS>& getGlyphs(uint8_t spec) const {
-        if (spellHandler_) return spellHandler_->getGlyphs(spec);
-        static const std::array<uint16_t, MAX_GLYPH_SLOTS> empty{};
-        return empty;
+        static std::unordered_map<uint32_t, uint8_t> empty;
+        return spec < 2 ? learnedTalents_[spec] : empty;
     }
     uint8_t getTalentRank(uint32_t talentId) const {
-        return spellHandler_ ? spellHandler_->getTalentRank(talentId) : 0;
+        auto it = learnedTalents_[activeTalentSpec_].find(talentId);
+        return (it != learnedTalents_[activeTalentSpec_].end()) ? it->second : 0;
     }
     void learnTalent(uint32_t talentId, uint32_t requestedRank);
     void switchTalentSpec(uint8_t newSpec);
@@ -864,46 +499,23 @@ public:
         auto it = talentTabCache_.find(tabId);
         return (it != talentTabCache_.end()) ? &it->second : nullptr;
     }
-    const std::unordered_map<uint32_t, TalentEntry>& getAllTalents() const;
-    const std::unordered_map<uint32_t, TalentTabEntry>& getAllTalentTabs() const;
+    const std::unordered_map<uint32_t, TalentEntry>& getAllTalents() const { return talentCache_; }
+    const std::unordered_map<uint32_t, TalentTabEntry>& getAllTalentTabs() const { return talentTabCache_; }
     void loadTalentDbc();
 
-    // Action bar — 4 bars × 12 slots = 48 total
-    // Bar 0 (slots  0-11): main bottom bar (1-0, -, =)
-    // Bar 1 (slots 12-23): second bar above main (Shift+1 ... Shift+=)
-    // Bar 2 (slots 24-35): right side vertical bar
-    // Bar 3 (slots 36-47): left side vertical bar
-    static constexpr int SLOTS_PER_BAR    = 12;
-    static constexpr int ACTION_BARS      = 4;
-    static constexpr int ACTION_BAR_SLOTS = SLOTS_PER_BAR * ACTION_BARS;   // 48
+    // Action bar
+    static constexpr int ACTION_BAR_SLOTS = 12;
     std::array<ActionBarSlot, ACTION_BAR_SLOTS>& getActionBar() { return actionBar; }
     const std::array<ActionBarSlot, ACTION_BAR_SLOTS>& getActionBar() const { return actionBar; }
     void setActionBarSlot(int slot, ActionBarSlot::Type type, uint32_t id);
 
-    // Client-side macro text storage (server sends only macro index; text is stored locally)
-    const std::string& getMacroText(uint32_t macroId) const;
-    void setMacroText(uint32_t macroId, const std::string& text);
-
     void saveCharacterConfig();
     void loadCharacterConfig();
     static std::string getCharacterConfigDir();
 
-    // Auras — delegate to SpellHandler as canonical authority
-    const std::vector<AuraSlot>& getPlayerAuras() const {
-        if (spellHandler_) return spellHandler_->getPlayerAuras();
-        static const std::vector<AuraSlot> empty;
-        return empty;
-    }
-    const std::vector<AuraSlot>& getTargetAuras() const {
-        if (spellHandler_) return spellHandler_->getTargetAuras();
-        static const std::vector<AuraSlot> empty;
-        return empty;
-    }
-    // Per-unit aura cache (populated for party members and any unit we receive updates for)
-    const std::vector<AuraSlot>* getUnitAuras(uint64_t guid) const {
-        if (spellHandler_) return spellHandler_->getUnitAuras(guid);
-        return nullptr;
-    }
+    // Auras
+    const std::vector<AuraSlot>& getPlayerAuras() const { return playerAuras; }
+    const std::vector<AuraSlot>& getTargetAuras() const { return targetAuras; }
 
     // Completed quests (populated from SMSG_QUERY_QUESTS_COMPLETED_RESPONSE)
     bool isQuestCompleted(uint32_t questId) const { return completedQuests_.count(questId) > 0; }
@@ -920,65 +532,14 @@ public:
     using NpcRespawnCallback = std::function<void(uint64_t guid)>;
     void setNpcRespawnCallback(NpcRespawnCallback cb) { npcRespawnCallback_ = std::move(cb); }
 
-    // Stand state animation callback — fired when SMSG_STANDSTATE_UPDATE confirms a new state
-    // standState: 0=stand, 1-6=sit variants, 7=dead, 8=kneel
-    using StandStateCallback = std::function<void(uint8_t standState)>;
-    void setStandStateCallback(StandStateCallback cb) { standStateCallback_ = std::move(cb); }
-
-    // Appearance changed callback — fired when PLAYER_BYTES or facial features update (barber shop, etc.)
-    using AppearanceChangedCallback = std::function<void()>;
-    void setAppearanceChangedCallback(AppearanceChangedCallback cb) { appearanceChangedCallback_ = std::move(cb); }
-
-    // Ghost state callback — fired when player enters or leaves ghost (spirit) form
-    using GhostStateCallback = std::function<void(bool isGhost)>;
-    void setGhostStateCallback(GhostStateCallback cb) { ghostStateCallback_ = std::move(cb); }
-
     // Melee swing callback (for driving animation/SFX)
-    // spellId: 0 = regular auto-attack swing, non-zero = melee ability (special attack)
-    using MeleeSwingCallback = std::function<void(uint32_t spellId)>;
+    using MeleeSwingCallback = std::function<void()>;
     void setMeleeSwingCallback(MeleeSwingCallback cb) { meleeSwingCallback_ = std::move(cb); }
 
-    // Spell cast animation callbacks — true=start cast/channel, false=finish/cancel
-    // guid: caster (may be player or another unit), isChannel: channel vs regular cast
-    // castType: DIRECTED (unit target), OMNI (self/no target), AREA (ground AoE)
-    using SpellCastAnimCallback = std::function<void(uint64_t guid, bool start, bool isChannel,
-                                                      SpellCastType castType)>;
-    void setSpellCastAnimCallback(SpellCastAnimCallback cb) { spellCastAnimCallback_ = std::move(cb); }
-
-    // Fired when the player's own spell cast fails (spellId of the failed spell).
-    using SpellCastFailedCallback = std::function<void(uint32_t spellId)>;
-    void setSpellCastFailedCallback(SpellCastFailedCallback cb) { spellCastFailedCallback_ = std::move(cb); }
-
-    // Unit animation hint: signal jump (animId=38) for other players/NPCs
-    using UnitAnimHintCallback = std::function<void(uint64_t guid, uint32_t animId)>;
-    void setUnitAnimHintCallback(UnitAnimHintCallback cb) { unitAnimHintCallback_ = std::move(cb); }
-
-    // Unit move-flags callback: fired on every MSG_MOVE_* for other players with the raw flags field.
-    // Drives Walk(4) vs Run(5) selection and swim state initialization from heartbeat packets.
-    using UnitMoveFlagsCallback = std::function<void(uint64_t guid, uint32_t moveFlags)>;
-    void setUnitMoveFlagsCallback(UnitMoveFlagsCallback cb) { unitMoveFlagsCallback_ = std::move(cb); }
-
     // NPC swing callback (plays attack animation on NPC)
     using NpcSwingCallback = std::function<void(uint64_t guid)>;
     void setNpcSwingCallback(NpcSwingCallback cb) { npcSwingCallback_ = std::move(cb); }
 
-    // Hit reaction callback — triggers victim animation (dodge, block, wound, crit wound)
-    enum class HitReaction : uint8_t { WOUND, CRIT_WOUND, DODGE, PARRY, BLOCK, SHIELD_BLOCK };
-    using HitReactionCallback = std::function<void(uint64_t victimGuid, HitReaction reaction)>;
-    void setHitReactionCallback(HitReactionCallback cb) { hitReactionCallback_ = std::move(cb); }
-
-    // Stun state callback — fires when UNIT_FLAG_STUNNED changes on the local player
-    using StunStateCallback = std::function<void(bool stunned)>;
-    void setStunStateCallback(StunStateCallback cb) { stunStateCallback_ = std::move(cb); }
-
-    // Stealth state callback — fires when UNIT_FLAG_SNEAKING changes on the local player
-    using StealthStateCallback = std::function<void(bool stealthed)>;
-    void setStealthStateCallback(StealthStateCallback cb) { stealthStateCallback_ = std::move(cb); }
-
-    // Player health changed callback — fires when local player HP changes
-    using PlayerHealthCallback = std::function<void(uint32_t health, uint32_t maxHealth)>;
-    void setPlayerHealthCallback(PlayerHealthCallback cb) { playerHealthCallback_ = std::move(cb); }
-
     // NPC greeting callback (plays voice line when NPC is clicked)
     using NpcGreetingCallback = std::function<void(uint64_t guid, const glm::vec3& position)>;
     void setNpcGreetingCallback(NpcGreetingCallback cb) { npcGreetingCallback_ = std::move(cb); }
@@ -992,8 +553,6 @@ public:
     // XP tracking
     uint32_t getPlayerXp() const { return playerXp_; }
     uint32_t getPlayerNextLevelXp() const { return playerNextLevelXp_; }
-    uint32_t getPlayerRestedXp() const { return playerRestedXp_; }
-    bool isPlayerResting() const { return isResting_; }
     uint32_t getPlayerLevel() const { return serverPlayerLevel_; }
     const std::vector<uint32_t>& getPlayerExploredZoneMasks() const { return playerExploredZones_; }
     bool hasPlayerExploredZoneMasks() const { return hasPlayerExploredZones_; }
@@ -1003,17 +562,6 @@ public:
     float getGameTime() const { return gameTime_; }
     float getTimeSpeed() const { return timeSpeed_; }
 
-    // Global Cooldown (GCD) — set when the server sends a spellId=0 cooldown entry
-    float getGCDRemaining() const {
-        if (gcdTotal_ <= 0.0f) return 0.0f;
-        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now() - gcdStartedAt_).count() / 1000.0f;
-        float rem = gcdTotal_ - elapsed;
-        return rem > 0.0f ? rem : 0.0f;
-    }
-    float getGCDTotal() const;
-    bool isGCDActive() const { return getGCDRemaining() > 0.0f; }
-
     // Weather state (updated by SMSG_WEATHER)
     // weatherType: 0=clear, 1=rain, 2=snow, 3=storm/fog
     uint32_t getWeatherType() const { return weatherType_; }
@@ -1024,30 +572,15 @@ public:
     uint32_t getOverrideLightTransMs() const { return overrideLightTransMs_; }
 
     // Player skills
-    const std::unordered_map<uint32_t, PlayerSkill>& getPlayerSkills() const { return playerSkills_; }
+    const std::map<uint32_t, PlayerSkill>& getPlayerSkills() const { return playerSkills_; }
     const std::string& getSkillName(uint32_t skillId) const;
     uint32_t getSkillCategory(uint32_t skillId) const;
-    bool isProfessionSpell(uint32_t spellId) const;
 
     // World entry callback (online mode - triggered when entering world)
-    // Parameters: mapId, x, y, z (canonical WoW coords), isInitialEntry=true on first login or reconnect
-    using WorldEntryCallback = std::function<void(uint32_t mapId, float x, float y, float z, bool isInitialEntry)>;
+    // Parameters: mapId, x, y, z (canonical WoW coordinates)
+    using WorldEntryCallback = std::function<void(uint32_t mapId, float x, float y, float z)>;
     void setWorldEntryCallback(WorldEntryCallback cb) { worldEntryCallback_ = std::move(cb); }
 
-    // Knockback callback: called when server sends SMSG_MOVE_KNOCK_BACK for the player.
-    // Parameters: vcos, vsin (render-space direction), hspeed, vspeed (raw from packet).
-    using KnockBackCallback = std::function<void(float vcos, float vsin, float hspeed, float vspeed)>;
-    void setKnockBackCallback(KnockBackCallback cb) { knockBackCallback_ = std::move(cb); }
-
-    // Camera shake callback: called when server sends SMSG_CAMERA_SHAKE.
-    // Parameters: magnitude (world units), frequency (Hz), duration (seconds).
-    using CameraShakeCallback = std::function<void(float magnitude, float frequency, float duration)>;
-    void setCameraShakeCallback(CameraShakeCallback cb) { cameraShakeCallback_ = std::move(cb); }
-
-    // Auto-follow callback: pass render-space position pointer to start, nullptr to cancel.
-    using AutoFollowCallback = std::function<void(const glm::vec3* renderPos)>;
-    void setAutoFollowCallback(AutoFollowCallback cb) { autoFollowCallback_ = std::move(cb); }
-
     // Unstuck callback (resets player Z to floor height)
     using UnstuckCallback = std::function<void()>;
     void setUnstuckCallback(UnstuckCallback cb) { unstuckCallback_ = std::move(cb); }
@@ -1059,15 +592,9 @@ public:
     using BindPointCallback = std::function<void(uint32_t mapId, float x, float y, float z)>;
     void setBindPointCallback(BindPointCallback cb) { bindPointCallback_ = std::move(cb); }
 
-    // Called when the player starts casting Hearthstone so terrain at the bind
-    // point can be pre-loaded during the cast time.
-    // Parameters: mapId and canonical (x, y, z) of the bind location.
-    using HearthstonePreloadCallback = std::function<void(uint32_t mapId, float x, float y, float z)>;
-    void setHearthstonePreloadCallback(HearthstonePreloadCallback cb) { hearthstonePreloadCallback_ = std::move(cb); }
-
     // Creature spawn callback (online mode - triggered when creature enters view)
-    // Parameters: guid, displayId, x, y, z (canonical), orientation, scale (OBJECT_FIELD_SCALE_X)
-    using CreatureSpawnCallback = std::function<void(uint64_t guid, uint32_t displayId, float x, float y, float z, float orientation, float scale)>;
+    // Parameters: guid, displayId, x, y, z (canonical), orientation
+    using CreatureSpawnCallback = std::function<void(uint64_t guid, uint32_t displayId, float x, float y, float z, float orientation)>;
     void setCreatureSpawnCallback(CreatureSpawnCallback cb) { creatureSpawnCallback_ = std::move(cb); }
 
     // Creature despawn callback (online mode - triggered when creature leaves view)
@@ -1097,8 +624,8 @@ public:
     void setPlayerEquipmentCallback(PlayerEquipmentCallback cb) { playerEquipmentCallback_ = std::move(cb); }
 
     // GameObject spawn callback (online mode - triggered when gameobject enters view)
-    // Parameters: guid, entry, displayId, x, y, z (canonical), orientation, scale (OBJECT_FIELD_SCALE_X)
-    using GameObjectSpawnCallback = std::function<void(uint64_t guid, uint32_t entry, uint32_t displayId, float x, float y, float z, float orientation, float scale)>;
+    // Parameters: guid, entry, displayId, x, y, z (canonical), orientation
+    using GameObjectSpawnCallback = std::function<void(uint64_t guid, uint32_t entry, uint32_t displayId, float x, float y, float z, float orientation)>;
     void setGameObjectSpawnCallback(GameObjectSpawnCallback cb) { gameObjectSpawnCallback_ = std::move(cb); }
 
     // GameObject move callback (online mode - triggered when gameobject position updates)
@@ -1113,19 +640,6 @@ public:
     using GameObjectCustomAnimCallback = std::function<void(uint64_t guid, uint32_t animId)>;
     void setGameObjectCustomAnimCallback(GameObjectCustomAnimCallback cb) { gameObjectCustomAnimCallback_ = std::move(cb); }
 
-    // GameObject state change callback (triggered when GAMEOBJECT_BYTES_1 updates — state byte changes)
-    // goState: 0=READY(closed), 1=OPEN, 2=DESTROYED
-    using GameObjectStateCallback = std::function<void(uint64_t guid, uint8_t goState)>;
-    void setGameObjectStateCallback(GameObjectStateCallback cb) { gameObjectStateCallback_ = std::move(cb); }
-
-    // Sprint aura callback — fired when sprint-type aura active state changes on player
-    using SprintAuraCallback = std::function<void(bool active)>;
-    void setSprintAuraCallback(SprintAuraCallback cb) { sprintAuraCallback_ = std::move(cb); }
-
-    // Vehicle state callback — fired when player enters/exits a vehicle
-    using VehicleStateCallback = std::function<void(bool entered, uint32_t vehicleId)>;
-    void setVehicleStateCallback(VehicleStateCallback cb) { vehicleStateCallback_ = std::move(cb); }
-
     // Faction hostility map (populated from FactionTemplate.dbc by Application)
     void setFactionHostileMap(std::unordered_map<uint32_t, bool> map) { factionHostileMap_ = std::move(map); }
 
@@ -1157,16 +671,11 @@ public:
     glm::vec3 getPlayerTransportOffset() const { return playerTransportOffset_; }
 
     // Check if a GUID is a known transport
-    bool isTransportGuid(uint64_t guid) const { return entityController_->isTransportGuid(guid); }
-    bool hasServerTransportUpdate(uint64_t guid) const { return entityController_->hasServerTransportUpdate(guid); }
+    bool isTransportGuid(uint64_t guid) const { return transportGuids_.count(guid) > 0; }
+    bool hasServerTransportUpdate(uint64_t guid) const { return serverUpdatedTransportGuids_.count(guid) > 0; }
     glm::vec3 getComposedWorldPosition();  // Compose transport transform * local offset
     TransportManager* getTransportManager() { return transportManager_.get(); }
     void setPlayerOnTransport(uint64_t transportGuid, const glm::vec3& localOffset) {
-        // Validate transport is registered before attaching player
-        // (defer if transport not yet registered to prevent desyncs)
-        if (transportGuid != 0 && !isTransportGuid(transportGuid)) {
-            return;  // Transport not yet registered; skip attachment
-        }
         playerTransportGuid_ = transportGuid;
         playerTransportOffset_ = localOffset;
         playerTransportStickyGuid_ = transportGuid;
@@ -1188,36 +697,13 @@ public:
 
     // Cooldowns
     float getSpellCooldown(uint32_t spellId) const;
-    const std::unordered_map<uint32_t, float>& getSpellCooldowns() const {
-        static const std::unordered_map<uint32_t, float> empty;
-        return spellHandler_ ? spellHandler_->getSpellCooldowns() : empty;
-    }
 
     // Player GUID
     uint64_t getPlayerGuid() const { return playerGuid; }
-
-    // Look up class/race for a player GUID from name query cache. Returns 0 if unknown.
-    uint8_t lookupPlayerClass(uint64_t guid) const {
-        return entityController_->lookupPlayerClass(guid);
-    }
-    uint8_t lookupPlayerRace(uint64_t guid) const {
-        return entityController_->lookupPlayerRace(guid);
-    }
-
-    // Look up a display name for any guid: checks playerNameCache then entity manager.
-    // Returns empty string if unknown. Used by chat display to resolve names at render time.
-    const std::string& lookupName(uint64_t guid) const {
-        return entityController_->lookupName(guid);
-    }
-
     uint8_t getPlayerClass() const {
         const Character* ch = getActiveCharacter();
         return ch ? static_cast<uint8_t>(ch->characterClass) : 0;
     }
-    uint8_t getPlayerRace() const {
-        const Character* ch = getActiveCharacter();
-        return ch ? static_cast<uint8_t>(ch->race) : 0;
-    }
     void setPlayerGuid(uint64_t guid) { playerGuid = guid; }
 
     // Player death state
@@ -1225,83 +711,31 @@ public:
     bool isPlayerGhost() const { return releasedSpirit_; }
     bool showDeathDialog() const { return playerDead_ && !releasedSpirit_; }
     bool showResurrectDialog() const { return resurrectRequestPending_; }
-    /** True when SMSG_PRE_RESURRECT arrived — Reincarnation/Twisting Nether available. */
-    bool canSelfRes() const { return selfResAvailable_; }
-    /** Send CMSG_SELF_RES to use Reincarnation / Twisting Nether. */
-    void useSelfRes();
-    const std::string& getResurrectCasterName() const { return resurrectCasterName_; }
-    bool showTalentWipeConfirmDialog() const;
-    uint32_t getTalentWipeCost() const;
-    void confirmTalentWipe();
-    void cancelTalentWipe();
-    // Pet talent respec confirm
-    bool showPetUnlearnDialog() const;
-    uint32_t getPetUnlearnCost() const;
-    void confirmPetUnlearn();
-    void cancelPetUnlearn();
-
-    // Barber shop
-    bool isBarberShopOpen() const { return barberShopOpen_; }
-    void closeBarberShop() { barberShopOpen_ = false; fireAddonEvent("BARBER_SHOP_CLOSE", {}); }
-    void sendAlterAppearance(uint32_t hairStyle, uint32_t hairColor, uint32_t facialHair);
-
-    // Instance difficulty (0=5N, 1=5H, 2=25N, 3=25H for WotLK)
-    uint32_t getInstanceDifficulty() const;
-    bool isInstanceHeroic() const;
-    bool isInInstance() const;
-
-    /** True when ghost is within 40 yards of corpse position (same map). */
-    bool canReclaimCorpse() const;
-    /** Seconds remaining on the PvP corpse-reclaim delay, or 0 if the reclaim is available now. */
-    float getCorpseReclaimDelaySec() const;
-    /** Distance (yards) from ghost to corpse, or -1 if no corpse data. */
-    float getCorpseDistance() const {
-        if (corpseMapId_ == 0 || currentMapId_ != corpseMapId_) return -1.0f;
-        // movementInfo is canonical (x=north=server_y, y=west=server_x);
-        // corpse coords are raw server (x=west, y=north) — swap to compare.
-        float dx = movementInfo.x - corpseY_;
-        float dy = movementInfo.y - corpseX_;
-        float dz = movementInfo.z - corpseZ_;
-        return std::sqrt(dx*dx + dy*dy + dz*dz);
-    }
-    /** Corpse position in canonical WoW coords (X=north, Y=west).
-     *  Returns false if no corpse data or on a different map. */
-    bool getCorpseCanonicalPos(float& outX, float& outY) const {
-        if (corpseMapId_ == 0 || currentMapId_ != corpseMapId_) return false;
-        outX = corpseY_;  // server Y = canonical X (north)
-        outY = corpseX_;  // server X = canonical Y (west)
-        return true;
-    }
-    /** Send CMSG_RECLAIM_CORPSE; noop if not a ghost or not near corpse. */
-    void reclaimCorpse();
     void releaseSpirit();
     void acceptResurrect();
     void declineResurrect();
 
-    // ---- Group ----
+    // ---- Phase 4: Group ----
     void inviteToGroup(const std::string& playerName);
     void acceptGroupInvite();
     void declineGroupInvite();
     void leaveGroup();
-    void convertToRaid();
-    void sendSetLootMethod(uint32_t method, uint32_t threshold, uint64_t masterLooterGuid);
     bool isInGroup() const { return !partyData.isEmpty(); }
     const GroupListData& getPartyData() const { return partyData; }
-    const std::vector<ContactEntry>& getContacts() const { return contacts_; }
-    bool hasPendingGroupInvite() const;
-    const std::string& getPendingInviterName() const;
+    bool hasPendingGroupInvite() const { return pendingGroupInvite; }
+    const std::string& getPendingInviterName() const { return pendingInviterName; }
 
     // ---- Item text (books / readable items) ----
-    bool isItemTextOpen() const;
-    const std::string& getItemText() const;
-    void closeItemText();
+    bool isItemTextOpen() const { return itemTextOpen_; }
+    const std::string& getItemText() const { return itemText_; }
+    void closeItemText() { itemTextOpen_ = false; }
     void queryItemText(uint64_t itemGuid);
 
     // ---- Shared Quest ----
-    bool hasPendingSharedQuest() const;
-    uint32_t getSharedQuestId() const;
-    const std::string& getSharedQuestTitle() const;
-    const std::string& getSharedQuestSharerName() const;
+    bool hasPendingSharedQuest() const { return pendingSharedQuest_; }
+    uint32_t getSharedQuestId() const { return sharedQuestId_; }
+    const std::string& getSharedQuestTitle() const { return sharedQuestTitle_; }
+    const std::string& getSharedQuestSharerName() const { return sharedQuestSharerName_; }
     void acceptSharedQuest();
     void declineSharedQuest();
 
@@ -1324,49 +758,29 @@ public:
     enum class TradeStatus : uint8_t {
         None = 0, PendingIncoming, Open, Accepted, Complete
     };
-
-    static constexpr int TRADE_SLOT_COUNT = 6;  // WoW has 6 normal trade slots + slot 6 for non-trade item
-
-    struct TradeSlot {
-        uint32_t itemId      = 0;
-        uint32_t displayId   = 0;
-        uint32_t stackCount  = 0;
-        uint64_t itemGuid    = 0;
-        uint8_t  bag         = 0xFF;   // 0xFF = not set
-        uint8_t  bagSlot     = 0xFF;
-        bool     occupied    = false;
-    };
-
-    TradeStatus getTradeStatus() const;
-    bool hasPendingTradeRequest() const;
-    bool isTradeOpen() const;
-    const std::string& getTradePeerName() const;
-
-    // My trade slots (what I'm offering)
-    const std::array<TradeSlot, TRADE_SLOT_COUNT>& getMyTradeSlots() const;
-    const std::array<TradeSlot, TRADE_SLOT_COUNT>& getPeerTradeSlots() const;
-    uint64_t getMyTradeGold() const;
-    uint64_t getPeerTradeGold() const;
-
+    TradeStatus getTradeStatus() const { return tradeStatus_; }
+    bool hasPendingTradeRequest() const { return tradeStatus_ == TradeStatus::PendingIncoming; }
+    const std::string& getTradePeerName() const { return tradePeerName_; }
     void acceptTradeRequest();   // respond to incoming SMSG_TRADE_STATUS(1) with CMSG_BEGIN_TRADE
     void declineTradeRequest();  // respond with CMSG_CANCEL_TRADE
     void acceptTrade();          // lock in offer: CMSG_ACCEPT_TRADE
     void cancelTrade();          // CMSG_CANCEL_TRADE
-    void setTradeItem(uint8_t tradeSlot, uint8_t bag, uint8_t bagSlot);
-    void clearTradeItem(uint8_t tradeSlot);
-    void setTradeGold(uint64_t copper);
 
     // ---- Duel ----
-    bool hasPendingDuelRequest() const;
-    const std::string& getDuelChallengerName() const;
+    bool hasPendingDuelRequest() const { return pendingDuelRequest_; }
+    const std::string& getDuelChallengerName() const { return duelChallengerName_; }
     void acceptDuel();
     // forfeitDuel() already declared at line ~399
-    // Returns remaining duel countdown seconds, or 0 if no active countdown
-    float getDuelCountdownRemaining() const;
 
-    // Instance lockouts (aliased from handler_types.hpp)
-    using InstanceLockout = game::InstanceLockout;
-    const std::vector<InstanceLockout>& getInstanceLockouts() const;
+    // ---- Instance lockouts ----
+    struct InstanceLockout {
+        uint32_t mapId       = 0;
+        uint32_t difficulty  = 0;  // 0=normal,1=heroic/10man,2=25man,3=25man heroic
+        uint64_t resetTime   = 0;  // Unix timestamp of instance reset
+        bool     locked      = false;
+        bool     extended    = false;
+    };
+    const std::vector<InstanceLockout>& getInstanceLockouts() const { return instanceLockouts_; }
 
     // Boss encounter unit tracking (SMSG_UPDATE_INSTANCE_ENCOUNTER_UNIT)
     static constexpr uint32_t kMaxEncounterSlots = 5;
@@ -1375,101 +789,54 @@ public:
         return (slot < kMaxEncounterSlots) ? encounterUnitGuids_[slot] : 0;
     }
 
-    // Raid target markers (MSG_RAID_TARGET_UPDATE)
-    // Icon indices 0-7: Star, Circle, Diamond, Triangle, Moon, Square, Cross, Skull
-    static constexpr uint32_t kRaidMarkCount = 8;
-    // Returns the GUID marked with the given icon (0 = no mark)
-    uint64_t getRaidMarkGuid(uint32_t icon) const {
-        return (icon < kRaidMarkCount) ? raidTargetGuids_[icon] : 0;
-    }
-    // Returns the raid mark icon for a given guid (0xFF = no mark)
-    uint8_t getEntityRaidMark(uint64_t guid) const {
-        if (guid == 0) return 0xFF;
-        for (uint32_t i = 0; i < kRaidMarkCount; ++i)
-            if (raidTargetGuids_[i] == guid) return static_cast<uint8_t>(i);
-        return 0xFF;
-    }
-    // Set or clear a raid mark on a guid (icon 0-7, or 0xFF to clear)
-    void setRaidMark(uint64_t guid, uint8_t icon);
-
     // ---- LFG / Dungeon Finder ----
-    // LFG state (aliased from handler_types.hpp)
-    using LfgState = game::LfgState;
+    enum class LfgState : uint8_t {
+        None           = 0,
+        RoleCheck      = 1,
+        Queued         = 2,
+        Proposal       = 3,
+        Boot           = 4,
+        InDungeon      = 5,
+        FinishedDungeon= 6,
+        RaidBrowser    = 7,
+    };
 
     // roles bitmask: 0x02=tank, 0x04=healer, 0x08=dps; pass LFGDungeonEntry ID
     void lfgJoin(uint32_t dungeonId, uint8_t roles);
     void lfgLeave();
-    void lfgSetRoles(uint8_t roles);
     void lfgAcceptProposal(uint32_t proposalId, bool accept);
-    void lfgSetBootVote(bool vote);
     void lfgTeleport(bool toLfgDungeon = true);
-    LfgState getLfgState() const;
-    bool isLfgQueued() const;
-    bool isLfgInDungeon() const;
-    uint32_t getLfgDungeonId() const;
-    std::string getCurrentLfgDungeonName() const;
-    std::string getMapName(uint32_t mapId) const;
-    uint32_t getLfgProposalId() const;
-    int32_t  getLfgAvgWaitSec() const;
-    uint32_t getLfgTimeInQueueMs() const;
-    uint32_t getLfgBootVotes() const;
-    uint32_t getLfgBootTotal() const;
-    uint32_t getLfgBootTimeLeft() const;
-    uint32_t getLfgBootNeeded() const;
-    const std::string& getLfgBootTargetName() const;
-    const std::string& getLfgBootReason() const;
+    LfgState getLfgState() const { return lfgState_; }
+    bool isLfgQueued()    const { return lfgState_ == LfgState::Queued; }
+    bool isLfgInDungeon() const { return lfgState_ == LfgState::InDungeon; }
+    uint32_t getLfgDungeonId()   const { return lfgDungeonId_; }
+    uint32_t getLfgProposalId()  const { return lfgProposalId_; }
+    int32_t  getLfgAvgWaitSec()  const { return lfgAvgWaitSec_; }
+    uint32_t getLfgTimeInQueueMs() const { return lfgTimeInQueueMs_; }
 
-    // Arena team stats (aliased from handler_types.hpp)
-    using ArenaTeamStats = game::ArenaTeamStats;
-    const std::vector<ArenaTeamStats>& getArenaTeamStats() const;
-    void requestArenaTeamRoster(uint32_t teamId);
-
-    // Arena team roster (aliased from handler_types.hpp)
-    using ArenaTeamMember = game::ArenaTeamMember;
-    using ArenaTeamRoster = game::ArenaTeamRoster;
-    // Returns roster for the given teamId, or nullptr if not yet received
-    const ArenaTeamRoster* getArenaTeamRoster(uint32_t teamId) const {
-        for (const auto& r : arenaTeamRosters_) {
-            if (r.teamId == teamId) return &r;
-        }
-        return nullptr;
-    }
-
-    // ---- Loot ----
+    // ---- Phase 5: Loot ----
     void lootTarget(uint64_t guid);
     void lootItem(uint8_t slotIndex);
     void closeLoot();
     void activateSpiritHealer(uint64_t npcGuid);
-    bool isLootWindowOpen() const;
-    const LootResponseData& getCurrentLoot() const;
-    void setAutoLoot(bool enabled);
-    bool isAutoLoot() const;
-    void setAutoSellGrey(bool enabled);
-    bool isAutoSellGrey() const;
-    void setAutoRepair(bool enabled);
-    bool isAutoRepair() const;
+    bool isLootWindowOpen() const { return lootWindowOpen; }
+    const LootResponseData& getCurrentLoot() const { return currentLoot; }
+    void setAutoLoot(bool enabled) { autoLoot_ = enabled; }
+    bool isAutoLoot() const { return autoLoot_; }
 
-    // Master loot candidates (from SMSG_LOOT_MASTER_LIST)
-    const std::vector<uint64_t>& getMasterLootCandidates() const;
-    bool hasMasterLootCandidates() const;
-    void lootMasterGive(uint8_t lootSlot, uint64_t targetGuid);
-
-    // Group loot roll (aliased from handler_types.hpp)
-    using LootRollEntry = game::LootRollEntry;
-    bool hasPendingLootRoll() const;
-    const LootRollEntry& getPendingLootRoll() const;
+    // Group loot roll
+    struct LootRollEntry {
+        uint64_t objectGuid    = 0;
+        uint32_t slot          = 0;
+        uint32_t itemId        = 0;
+        std::string itemName;
+        uint8_t  itemQuality   = 0;
+    };
+    bool hasPendingLootRoll() const { return pendingLootRollActive_; }
+    const LootRollEntry& getPendingLootRoll() const { return pendingLootRoll_; }
     void sendLootRoll(uint64_t objectGuid, uint32_t slot, uint8_t rollType);
     // rollType: 0=need, 1=greed, 2=disenchant, 96=pass
 
-    // Equipment Sets (aliased from handler_types.hpp)
-    using EquipmentSetInfo = game::EquipmentSetInfo;
-    const std::vector<EquipmentSetInfo>& getEquipmentSets() const;
-    bool supportsEquipmentSets() const;
-    void useEquipmentSet(uint32_t setId);
-    void saveEquipmentSet(const std::string& name, const std::string& iconName = "INV_Misc_QuestionMark",
-                          uint64_t existingGuid = 0, uint32_t setIndex = 0xFFFFFFFF);
-    void deleteEquipmentSet(uint64_t setGuid);
-
     // NPC Gossip
     void interactWithNpc(uint64_t guid);
     void interactWithGameObject(uint64_t guid);
@@ -1478,45 +845,49 @@ public:
     void acceptQuest();
     void declineQuest();
     void closeGossip();
-    // Quest-starting items: right-click triggers quest offer dialog via questgiver protocol
-    void offerQuestFromItem(uint64_t itemGuid, uint32_t questId);
-    uint64_t getBagItemGuid(int bagIndex, int slotIndex) const;
-    bool isGossipWindowOpen() const;
-    const GossipMessageData& getCurrentGossip() const;
-    bool isQuestDetailsOpen();
-    const QuestDetailsData& getQuestDetails() const;
+    bool isGossipWindowOpen() const { return gossipWindowOpen; }
+    const GossipMessageData& getCurrentGossip() const { return currentGossip; }
+    bool isQuestDetailsOpen() const { return questDetailsOpen; }
+    const QuestDetailsData& getQuestDetails() const { return currentQuestDetails; }
 
-    // Gossip POI (aliased from handler_types.hpp)
-    using GossipPoi = game::GossipPoi;
-    const std::vector<GossipPoi>& getGossipPois() const;
+    // Gossip / quest map POI markers (SMSG_GOSSIP_POI)
+    struct GossipPoi {
+        float    x     = 0.0f;   // WoW canonical X (north)
+        float    y     = 0.0f;   // WoW canonical Y (west)
+        uint32_t icon  = 0;      // POI icon type
+        uint32_t data  = 0;
+        std::string name;
+    };
+    const std::vector<GossipPoi>& getGossipPois() const { return gossipPois_; }
     void clearGossipPois() { gossipPois_.clear(); }
 
     // Quest turn-in
-    bool isQuestRequestItemsOpen() const;
-    const QuestRequestItemsData& getQuestRequestItems() const;
+    bool isQuestRequestItemsOpen() const { return questRequestItemsOpen_; }
+    const QuestRequestItemsData& getQuestRequestItems() const { return currentQuestRequestItems_; }
     void completeQuest();       // Send CMSG_QUESTGIVER_COMPLETE_QUEST
     void closeQuestRequestItems();
 
-    bool isQuestOfferRewardOpen() const;
-    const QuestOfferRewardData& getQuestOfferReward() const;
+    bool isQuestOfferRewardOpen() const { return questOfferRewardOpen_; }
+    const QuestOfferRewardData& getQuestOfferReward() const { return currentQuestOfferReward_; }
     void chooseQuestReward(uint32_t rewardIndex);  // Send CMSG_QUESTGIVER_CHOOSE_REWARD
     void closeQuestOfferReward();
 
     // Quest log
-    using QuestLogEntry = QuestHandler::QuestLogEntry;
-    const std::vector<QuestLogEntry>& getQuestLog() const;
-    int getSelectedQuestLogIndex() const;
-    void setSelectedQuestLogIndex(int idx) { selectedQuestLogIndex_ = idx; }
+    struct QuestLogEntry {
+        uint32_t questId = 0;
+        std::string title;
+        std::string objectives;
+        bool complete = false;
+        // Objective kill counts: objectiveIndex -> (current, required)
+        std::unordered_map<uint32_t, std::pair<uint32_t, uint32_t>> killCounts;
+        // Quest item progress: itemId -> current count
+        std::unordered_map<uint32_t, uint32_t> itemCounts;
+        // Server-authoritative quest item requirements from REQUEST_ITEMS
+        std::unordered_map<uint32_t, uint32_t> requiredItemCounts;
+    };
+    const std::vector<QuestLogEntry>& getQuestLog() const { return questLog_; }
     void abandonQuest(uint32_t questId);
-    void shareQuestWithParty(uint32_t questId);  // CMSG_PUSHQUESTTOPARTY
     bool requestQuestQuery(uint32_t questId, bool force = false);
-    bool isQuestTracked(uint32_t questId) const { return trackedQuestIds_.count(questId) > 0; }
-    void setQuestTracked(uint32_t questId, bool tracked) {
-        if (tracked) trackedQuestIds_.insert(questId);
-        else trackedQuestIds_.erase(questId);
-        saveCharacterConfig();
-    }
-    const std::unordered_set<uint32_t>& getTrackedQuestIds() const;
     bool isQuestQueryPending(uint32_t questId) const {
         return pendingQuestQueryIds_.count(questId) > 0;
     }
@@ -1545,7 +916,6 @@ public:
 
     // Combo points
     uint8_t  getComboPoints() const { return comboPoints_; }
-    uint8_t  getShapeshiftFormId() const { return shapeshiftFormId_; }
     uint64_t getComboTarget() const { return comboTarget_; }
 
     // Death Knight rune state (6 runes: 0-1=Blood, 2-3=Unholy, 4-5=Frost; may become Death=3)
@@ -1557,148 +927,23 @@ public:
     };
     const std::array<RuneSlot, 6>& getPlayerRunes() const { return playerRunes_; }
 
-    // Talent-driven spell modifiers (SMSG_SET_FLAT_SPELL_MODIFIER / SMSG_SET_PCT_SPELL_MODIFIER)
-    // SpellModOp matches WotLK SpellModOp enum (server-side).
-    enum class SpellModOp : uint8_t {
-        Damage            =  0,
-        Duration          =  1,
-        Threat            =  2,
-        Effect1           =  3,
-        Charges           =  4,
-        Range             =  5,
-        Radius            =  6,
-        CritChance        =  7,
-        AllEffects        =  8,
-        NotLoseCastingTime =  9,
-        CastingTime       = 10,
-        Cooldown          = 11,
-        Effect2           = 12,
-        IgnoreArmor       = 13,
-        Cost              = 14,
-        CritDamageBonus   = 15,
-        ResistMissChance  = 16,
-        JumpTargets       = 17,
-        ChanceOfSuccess   = 18,
-        ActivationTime    = 19,
-        Efficiency        = 20,
-        MultipleValue     = 21,
-        ResistDispelChance = 22,
-        Effect3           = 23,
-        BonusMultiplier   = 24,
-        ProcPerMinute     = 25,
-        ValueMultiplier   = 26,
-        ResistPushback    = 27,
-        MechanicDuration  = 28,
-        StartCooldown     = 29,
-        PeriodicBonus     = 30,
-        AttackPower       = 31,
-    };
-    static constexpr int SPELL_MOD_OP_COUNT = 32;
-
-    // Key: (SpellModOp, groupIndex) — value: accumulated flat or pct modifier
-    // pct values are stored in integer percent (e.g. -20 means -20% reduction).
-    struct SpellModKey {
-        SpellModOp op;
-        uint8_t    group;
-        bool operator==(const SpellModKey& o) const {
-            return op == o.op && group == o.group;
-        }
-    };
-    struct SpellModKeyHash {
-        std::size_t operator()(const SpellModKey& k) const {
-            return std::hash<uint32_t>()(
-                (static_cast<uint32_t>(static_cast<uint8_t>(k.op)) << 8) | k.group);
-        }
-    };
-
-    // Returns the sum of all flat modifiers for a given op across all groups.
-    // (Callers that need per-group resolution can use getSpellFlatMods() directly.)
-    int32_t getSpellFlatMod(SpellModOp op) const {
-        int32_t total = 0;
-        for (const auto& [k, v] : spellFlatMods_)
-            if (k.op == op) total += v;
-        return total;
-    }
-    // Returns the sum of all pct modifiers for a given op across all groups (in %).
-    int32_t getSpellPctMod(SpellModOp op) const {
-        int32_t total = 0;
-        for (const auto& [k, v] : spellPctMods_)
-            if (k.op == op) total += v;
-        return total;
-    }
-
-    // Convenience: apply flat+pct modifier to a base value.
-    // result = (base + flatMod) * (1.0 + pctMod/100.0), clamped to >= 0.
-    static int32_t applySpellMod(int32_t base, int32_t flat, int32_t pct) {
-        int64_t v = static_cast<int64_t>(base) + flat;
-        if (pct != 0) v = v + (v * pct + 50) / 100;  // round half-up
-        return static_cast<int32_t>(v < 0 ? 0 : v);
-    }
-
     struct FactionStandingInit {
         uint8_t flags = 0;
         int32_t standing = 0;
     };
-    // Faction flag bitmask constants (from Faction.dbc ReputationFlags / SMSG_INITIALIZE_FACTIONS)
-    static constexpr uint8_t FACTION_FLAG_VISIBLE    = 0x01; // shown in reputation list
-    static constexpr uint8_t FACTION_FLAG_AT_WAR     = 0x02; // player is at war
-    static constexpr uint8_t FACTION_FLAG_HIDDEN      = 0x04; // never shown
-    static constexpr uint8_t FACTION_FLAG_INVISIBLE_FORCED = 0x08;
-    static constexpr uint8_t FACTION_FLAG_PEACE_FORCED     = 0x10;
-
     const std::vector<FactionStandingInit>& getInitialFactions() const { return initialFactions_; }
     const std::unordered_map<uint32_t, int32_t>& getFactionStandings() const { return factionStandings_; }
-
-    // Returns true if the player has "at war" toggled for the faction at repListId
-    bool isFactionAtWar(uint32_t repListId) const {
-        if (repListId >= initialFactions_.size()) return false;
-        return (initialFactions_[repListId].flags & FACTION_FLAG_AT_WAR) != 0;
-    }
-    // Returns true if the faction is visible in the reputation list
-    bool isFactionVisible(uint32_t repListId) const {
-        if (repListId >= initialFactions_.size()) return false;
-        const uint8_t f = initialFactions_[repListId].flags;
-        if (f & FACTION_FLAG_HIDDEN) return false;
-        if (f & FACTION_FLAG_INVISIBLE_FORCED) return false;
-        return (f & FACTION_FLAG_VISIBLE) != 0;
-    }
-    // Returns the faction ID for a given repListId (0 if unknown)
-    uint32_t getFactionIdByRepListId(uint32_t repListId) const;
-    // Returns the repListId for a given faction ID (0xFFFFFFFF if not found)
-    uint32_t getRepListIdByFactionId(uint32_t factionId) const;
-    // Shaman totems (4 slots: 0=Earth, 1=Fire, 2=Water, 3=Air)
-    struct TotemSlot {
-        uint32_t spellId     = 0;
-        uint32_t durationMs  = 0;
-        std::chrono::steady_clock::time_point placedAt{};
-        bool active() const { return spellId != 0 && remainingMs() > 0; }
-        float remainingMs() const {
-            if (spellId == 0 || durationMs == 0) return 0.0f;
-            auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
-                std::chrono::steady_clock::now() - placedAt).count();
-            float rem = static_cast<float>(durationMs) - static_cast<float>(elapsed);
-            return rem > 0.0f ? rem : 0.0f;
-        }
-    };
-    static constexpr int NUM_TOTEM_SLOTS = 4;
-    const TotemSlot& getTotemSlot(int slot) const {
-        static TotemSlot empty;
-        return (slot >= 0 && slot < NUM_TOTEM_SLOTS) ? activeTotemSlots_[slot] : empty;
-    }
-
     const std::string& getFactionNamePublic(uint32_t factionId) const;
-    uint32_t getWatchedFactionId() const { return watchedFactionId_; }
-    void setWatchedFactionId(uint32_t factionId);
     uint32_t getLastContactListMask() const { return lastContactListMask_; }
     uint32_t getLastContactListCount() const { return lastContactListCount_; }
-    bool isServerMovementAllowed() const;
+    bool isServerMovementAllowed() const { return serverMovementAllowed_; }
 
     // Quest giver status (! and ? markers)
     QuestGiverStatus getQuestGiverStatus(uint64_t guid) const {
         auto it = npcQuestStatus_.find(guid);
         return (it != npcQuestStatus_.end()) ? it->second : QuestGiverStatus::NONE;
     }
-    const std::unordered_map<uint64_t, QuestGiverStatus>& getNpcQuestStatuses() const;
+    const std::unordered_map<uint64_t, QuestGiverStatus>& getNpcQuestStatuses() const { return npcQuestStatus_; }
 
     // Charge callback — fires when player casts a charge spell toward target
     // Parameters: targetGuid, targetX, targetY, targetZ (canonical WoW coordinates)
@@ -1709,90 +954,13 @@ public:
     using LevelUpCallback = std::function<void(uint32_t newLevel)>;
     void setLevelUpCallback(LevelUpCallback cb) { levelUpCallback_ = std::move(cb); }
 
-    // Stat deltas from the last SMSG_LEVELUP_INFO (valid until next level-up)
-    struct LevelUpDeltas {
-        uint32_t hp   = 0;
-        uint32_t mana = 0;
-        uint32_t str = 0, agi = 0, sta = 0, intel = 0, spi = 0;
-    };
-    const LevelUpDeltas& getLastLevelUpDeltas() const { return lastLevelUpDeltas_; }
-
-    // Temporary weapon enchant timers (from SMSG_ITEM_ENCHANT_TIME_UPDATE)
-    // Slot: 0=main-hand, 1=off-hand, 2=ranged. Value: expire time (steady_clock ms).
-    struct TempEnchantTimer {
-        uint32_t slot     = 0;
-        uint64_t expireMs = 0;   // std::chrono::steady_clock ms timestamp when it expires
-    };
-    const std::vector<TempEnchantTimer>& getTempEnchantTimers() const { return tempEnchantTimers_; }
-    // Returns remaining ms for a given slot, or 0 if absent/expired.
-    uint32_t getTempEnchantRemainingMs(uint32_t slot) const;
-    static constexpr const char* kTempEnchantSlotNames[] = { "Main Hand", "Off Hand", "Ranged" };
-
-    // ---- Readable text (books / scrolls / notes) ----
-    // Populated by handlePageTextQueryResponse(); multi-page items chain via nextPageId.
-    struct BookPage { uint32_t pageId = 0; std::string text; };
-    const std::vector<BookPage>& getBookPages() const { return bookPages_; }
-    bool hasBookOpen() const { return !bookPages_.empty(); }
-    void clearBook() { bookPages_.clear(); }
-
     // Other player level-up callback — fires when another player gains a level
     using OtherPlayerLevelUpCallback = std::function<void(uint64_t guid, uint32_t newLevel)>;
     void setOtherPlayerLevelUpCallback(OtherPlayerLevelUpCallback cb) { otherPlayerLevelUpCallback_ = std::move(cb); }
 
     // Achievement earned callback — fires when SMSG_ACHIEVEMENT_EARNED is received
-    using AchievementEarnedCallback = std::function<void(uint32_t achievementId, const std::string& name)>;
+    using AchievementEarnedCallback = std::function<void(uint32_t achievementId)>;
     void setAchievementEarnedCallback(AchievementEarnedCallback cb) { achievementEarnedCallback_ = std::move(cb); }
-    const std::unordered_set<uint32_t>& getEarnedAchievements() const { return earnedAchievements_; }
-
-    // Title system — earned title bits and the currently displayed title
-    const std::unordered_set<uint32_t>& getKnownTitleBits() const { return knownTitleBits_; }
-    int32_t getChosenTitleBit() const { return chosenTitleBit_; }
-    /// Returns the formatted title string for a given bit (replaces %s with player name), or empty.
-    std::string getFormattedTitle(uint32_t bit) const;
-    /// Send CMSG_SET_TITLE to activate a title (bit >= 0) or clear it (bit = -1).
-    void sendSetTitle(int32_t bit);
-
-    // Area discovery callback — fires when SMSG_EXPLORATION_EXPERIENCE is received
-    using AreaDiscoveryCallback = std::function<void(const std::string& areaName, uint32_t xpGained)>;
-    void setAreaDiscoveryCallback(AreaDiscoveryCallback cb) { areaDiscoveryCallback_ = std::move(cb); }
-
-    // Quest objective progress callback — fires on SMSG_QUESTUPDATE_ADD_KILL / ADD_ITEM
-    // questTitle: name of the quest; objectiveName: creature/item name; current/required counts
-    using QuestProgressCallback = std::function<void(const std::string& questTitle,
-                                                     const std::string& objectiveName,
-                                                     uint32_t current, uint32_t required)>;
-    void setQuestProgressCallback(QuestProgressCallback cb) { questProgressCallback_ = std::move(cb); }
-    const std::unordered_map<uint32_t, uint64_t>& getCriteriaProgress() const { return criteriaProgress_; }
-    /// Returns the WoW PackedTime earn date for an achievement, or 0 if unknown.
-    uint32_t getAchievementDate(uint32_t id) const {
-        auto it = achievementDates_.find(id);
-        return (it != achievementDates_.end()) ? it->second : 0u;
-    }
-    /// Returns the name of an achievement by ID, or empty string if unknown.
-    const std::string& getAchievementName(uint32_t id) const {
-        auto it = achievementNameCache_.find(id);
-        if (it != achievementNameCache_.end()) return it->second;
-        static const std::string kEmpty;
-        return kEmpty;
-    }
-    /// Returns the description of an achievement by ID, or empty string if unknown.
-    const std::string& getAchievementDescription(uint32_t id) const {
-        auto it = achievementDescCache_.find(id);
-        if (it != achievementDescCache_.end()) return it->second;
-        static const std::string kEmpty;
-        return kEmpty;
-    }
-    /// Returns the point value of an achievement by ID, or 0 if unknown.
-    uint32_t getAchievementPoints(uint32_t id) const {
-        auto it = achievementPointsCache_.find(id);
-        return (it != achievementPointsCache_.end()) ? it->second : 0u;
-    }
-    /// Returns the set of achievement IDs earned by an inspected player (via SMSG_RESPOND_INSPECT_ACHIEVEMENTS).
-    /// Returns nullptr if no inspect data is available for the given GUID.
-    const std::unordered_set<uint32_t>* getInspectedPlayerAchievements(uint64_t guid) const {
-        auto it = inspectedPlayerAchievements_.find(guid);
-        return (it != inspectedPlayerAchievements_.end()) ? &it->second : nullptr;
-    }
 
     // Server-triggered music callback — fires when SMSG_PLAY_MUSIC is received.
     // The soundId corresponds to a SoundEntries.dbc record. The receiver is
@@ -1810,43 +978,6 @@ public:
     using PlayPositionalSoundCallback = std::function<void(uint32_t soundId, uint64_t sourceGuid)>;
     void setPlayPositionalSoundCallback(PlayPositionalSoundCallback cb) { playPositionalSoundCallback_ = std::move(cb); }
 
-    // UI error frame: prominent on-screen error messages (spell can't be cast, etc.)
-    using UIErrorCallback = std::function<void(const std::string& msg)>;
-    void setUIErrorCallback(UIErrorCallback cb) { uiErrorCallback_ = std::move(cb); }
-    void addUIError(const std::string& msg) {
-        if (uiErrorCallback_) uiErrorCallback_(msg);
-        fireAddonEvent("UI_ERROR_MESSAGE", {msg});
-    }
-    void addUIInfoMessage(const std::string& msg) {
-        fireAddonEvent("UI_INFO_MESSAGE", {msg});
-    }
-    void fireAddonEvent(const std::string& event, const std::vector<std::string>& args = {}) {
-        if (addonEventCallback_) addonEventCallback_(event, args);
-    }
-    // Convenience: invoke a callback with a sound manager obtained from the renderer.
-    template<typename ManagerGetter, typename Callback>
-    void withSoundManager(ManagerGetter getter, Callback cb);
-
-    // Reputation change toast: factionName, delta, new standing
-    using RepChangeCallback = std::function<void(const std::string& factionName, int32_t delta, int32_t standing)>;
-    void setRepChangeCallback(RepChangeCallback cb) { repChangeCallback_ = std::move(cb); }
-
-    // PvP honor credit callback (honorable kill or BG reward)
-    using PvpHonorCallback = std::function<void(uint32_t honorAmount, uint64_t victimGuid, uint32_t victimRank)>;
-    void setPvpHonorCallback(PvpHonorCallback cb) { pvpHonorCallback_ = std::move(cb); }
-
-    // Item looted / received callback (SMSG_ITEM_PUSH_RESULT when showInChat is set)
-    using ItemLootCallback = std::function<void(uint32_t itemId, uint32_t count, uint32_t quality, const std::string& name)>;
-    void setItemLootCallback(ItemLootCallback cb) { itemLootCallback_ = std::move(cb); }
-
-    // Loot window open/close callback (for loot kneel animation)
-    using LootWindowCallback = std::function<void(bool open)>;
-    void setLootWindowCallback(LootWindowCallback cb) { lootWindowCallback_ = std::move(cb); }
-
-    // Quest turn-in completion callback
-    using QuestCompleteCallback = std::function<void(uint32_t questId, const std::string& questTitle)>;
-    void setQuestCompleteCallback(QuestCompleteCallback cb) { questCompleteCallback_ = std::move(cb); }
-
     // Mount state
     using MountCallback = std::function<void(uint32_t mountDisplayId)>;  // 0 = dismount
     void setMountCallback(MountCallback cb) { mountCallback_ = std::move(cb); }
@@ -1863,81 +994,49 @@ public:
     using TaxiFlightStartCallback = std::function<void()>;
     void setTaxiFlightStartCallback(TaxiFlightStartCallback cb) { taxiFlightStartCallback_ = std::move(cb); }
 
-    // Callback fired when server sends SMSG_OPEN_LFG_DUNGEON_FINDER (open dungeon finder UI)
-    using OpenLfgCallback = std::function<void()>;
-    void setOpenLfgCallback(OpenLfgCallback cb) { openLfgCallback_ = std::move(cb); }
-
     bool isMounted() const { return currentMountDisplayId_ != 0; }
-    bool isHostileAttacker(uint64_t guid) const;
-    bool isHostileFactionPublic(uint32_t factionTemplateId) const { return isHostileFaction(factionTemplateId); }
-    float getServerRunSpeed() const;
-    float getServerWalkSpeed() const;
-    float getServerSwimSpeed() const;
-    float getServerSwimBackSpeed() const;
-    float getServerFlightSpeed() const;
-    float getServerFlightBackSpeed() const;
-    float getServerRunBackSpeed() const;
-    float getServerTurnRate() const;
-    bool isPlayerRooted() const {
-        return (movementInfo.flags & static_cast<uint32_t>(MovementFlags::ROOT)) != 0;
-    }
-    bool isGravityDisabled() const {
-        return (movementInfo.flags & static_cast<uint32_t>(MovementFlags::LEVITATING)) != 0;
-    }
-    bool isFeatherFalling() const {
-        return (movementInfo.flags & static_cast<uint32_t>(MovementFlags::FEATHER_FALL)) != 0;
-    }
-    bool isWaterWalking() const {
-        return (movementInfo.flags & static_cast<uint32_t>(MovementFlags::WATER_WALK)) != 0;
-    }
-    bool isPlayerFlying() const {
-        const uint32_t flyMask = static_cast<uint32_t>(MovementFlags::CAN_FLY) |
-                                 static_cast<uint32_t>(MovementFlags::FLYING);
-        return (movementInfo.flags & flyMask) == flyMask;
-    }
-    bool isHovering() const {
-        return (movementInfo.flags & static_cast<uint32_t>(MovementFlags::HOVER)) != 0;
-    }
-    bool isSwimming() const {
-        return (movementInfo.flags & static_cast<uint32_t>(MovementFlags::SWIMMING)) != 0;
-    }
-    // Set the character pitch angle (radians) for movement packets (flight / swimming).
-    // Positive = nose up, negative = nose down.
-    void setMovementPitch(float radians) { movementInfo.pitch = radians; }
+    bool isHostileAttacker(uint64_t guid) const { return hostileAttackers_.count(guid) > 0; }
+    float getServerRunSpeed() const { return serverRunSpeed_; }
     void dismount();
 
     // Taxi / Flight Paths
-    bool isTaxiWindowOpen() const;
+    bool isTaxiWindowOpen() const { return taxiWindowOpen_; }
     void closeTaxi();
     void activateTaxi(uint32_t destNodeId);
-    bool isOnTaxiFlight() const;
-    bool isTaxiMountActive() const;
-    bool isTaxiActivationPending() const;
+    bool isOnTaxiFlight() const { return onTaxiFlight_; }
+    bool isTaxiMountActive() const { return taxiMountActive_; }
+    bool isTaxiActivationPending() const { return taxiActivatePending_; }
     void forceClearTaxiAndMovementState();
-    const std::string& getTaxiDestName() const;
-    const ShowTaxiNodesData& getTaxiData() const;
-    uint32_t getTaxiCurrentNode() const;
+    const ShowTaxiNodesData& getTaxiData() const { return currentTaxiData_; }
+    uint32_t getTaxiCurrentNode() const { return currentTaxiData_.nearestNode; }
 
-    using TaxiNode = MovementHandler::TaxiNode;
-    using TaxiPathEdge = MovementHandler::TaxiPathEdge;
-    using TaxiPathNode = MovementHandler::TaxiPathNode;
-    const std::unordered_map<uint32_t, TaxiNode>& getTaxiNodes() const;
-    bool isKnownTaxiNode(uint32_t nodeId) const {
-        if (nodeId == 0 || nodeId > 384) return false;
-        uint32_t idx = nodeId - 1;
-        return (knownTaxiMask_[idx / 32] & (1u << (idx % 32))) != 0;
-    }
+    struct TaxiNode {
+        uint32_t id = 0;
+        uint32_t mapId = 0;
+        float x = 0, y = 0, z = 0;
+        std::string name;
+        uint32_t mountDisplayIdAlliance = 0;
+        uint32_t mountDisplayIdHorde = 0;
+    };
+    struct TaxiPathEdge {
+        uint32_t pathId = 0;
+        uint32_t fromNode = 0, toNode = 0;
+        uint32_t cost = 0;
+    };
+    struct TaxiPathNode {
+        uint32_t id = 0;
+        uint32_t pathId = 0;
+        uint32_t nodeIndex = 0;
+        uint32_t mapId = 0;
+        float x = 0, y = 0, z = 0;
+    };
+    const std::unordered_map<uint32_t, TaxiNode>& getTaxiNodes() const { return taxiNodes_; }
     uint32_t getTaxiCostTo(uint32_t destNodeId) const;
     bool taxiNpcHasRoutes(uint64_t guid) const {
         auto it = taxiNpcHasRoutes_.find(guid);
         return it != taxiNpcHasRoutes_.end() && it->second;
     }
 
-    // Vehicle (WotLK)
-    bool isInVehicle() const { return vehicleId_ != 0; }
-    uint32_t getVehicleId() const { return vehicleId_; }
-    void sendRequestVehicleExit();
-
     // Vendor
     void openVendor(uint64_t npcGuid);
     void closeVendor();
@@ -1951,40 +1050,30 @@ public:
         uint32_t count = 1;
     };
     void buyBackItem(uint32_t buybackSlot);
-    void repairItem(uint64_t vendorGuid, uint64_t itemGuid);
-    void repairAll(uint64_t vendorGuid, bool useGuildBank = false);
-    uint32_t estimateRepairAllCost() const;
-    const std::deque<BuybackItem>& getBuybackItems() const;
+    const std::deque<BuybackItem>& getBuybackItems() const { return buybackItems_; }
     void autoEquipItemBySlot(int backpackIndex);
     void autoEquipItemInBag(int bagIndex, int slotIndex);
     void useItemBySlot(int backpackIndex);
     void useItemInBag(int bagIndex, int slotIndex);
-    // CMSG_OPEN_ITEM — for locked containers (lockboxes); server checks keyring automatically
-    void openItemBySlot(int backpackIndex);
-    void openItemInBag(int bagIndex, int slotIndex);
     void destroyItem(uint8_t bag, uint8_t slot, uint8_t count = 1);
-    void splitItem(uint8_t srcBag, uint8_t srcSlot, uint8_t count);
     void swapContainerItems(uint8_t srcBag, uint8_t srcSlot, uint8_t dstBag, uint8_t dstSlot);
     void swapBagSlots(int srcBagIndex, int dstBagIndex);
     void useItemById(uint32_t itemId);
-    uint32_t getItemIdForSpell(uint32_t spellId) const;
-    bool isVendorWindowOpen() const;
-    const ListInventoryData& getVendorItems() const;
-    void setVendorCanRepair(bool v);
+    bool isVendorWindowOpen() const { return vendorWindowOpen; }
+    const ListInventoryData& getVendorItems() const { return currentVendorItems; }
 
     // Mail
-    bool isMailboxOpen() const;
-    const std::vector<MailMessage>& getMailInbox() const;
-    int getSelectedMailIndex() const;
-    void setSelectedMailIndex(int idx);
-    bool isMailComposeOpen() const;
-    void openMailCompose();
-    void closeMailCompose();
-    bool hasNewMail() const;
-    void openMailbox(uint64_t guid);
+    bool isMailboxOpen() const { return mailboxOpen_; }
+    const std::vector<MailMessage>& getMailInbox() const { return mailInbox_; }
+    int getSelectedMailIndex() const { return selectedMailIndex_; }
+    void setSelectedMailIndex(int idx) { selectedMailIndex_ = idx; }
+    bool isMailComposeOpen() const { return showMailCompose_; }
+    void openMailCompose() { showMailCompose_ = true; clearMailAttachments(); }
+    void closeMailCompose() { showMailCompose_ = false; clearMailAttachments(); }
+    bool hasNewMail() const { return hasNewMail_; }
     void closeMailbox();
     void sendMail(const std::string& recipient, const std::string& subject,
-                  const std::string& body, uint64_t money, uint64_t cod = 0);
+                  const std::string& body, uint32_t money, uint32_t cod = 0);
 
     // Mail attachments (max 12 per WotLK)
     static constexpr int MAIL_MAX_ATTACHMENTS = 12;
@@ -1999,10 +1088,10 @@ public:
     bool attachItemFromBag(int bagIndex, int slotIndex);
     bool detachMailAttachment(int attachIndex);
     void clearMailAttachments();
-    const std::array<MailAttachSlot, 12>& getMailAttachments() const;
+    const std::array<MailAttachSlot, 12>& getMailAttachments() const { return mailAttachments_; }
     int getMailAttachmentCount() const;
     void mailTakeMoney(uint32_t mailId);
-    void mailTakeItem(uint32_t mailId, uint32_t itemGuidLow);
+    void mailTakeItem(uint32_t mailId, uint32_t itemIndex);
     void mailDelete(uint32_t mailId);
     void mailMarkAsRead(uint32_t mailId);
     void refreshMailList();
@@ -2013,10 +1102,10 @@ public:
     void buyBankSlot();
     void depositItem(uint8_t srcBag, uint8_t srcSlot);
     void withdrawItem(uint8_t srcBag, uint8_t srcSlot);
-    bool isBankOpen() const;
-    uint64_t getBankerGuid() const;
-    int getEffectiveBankSlots() const;
-    int getEffectiveBankBagSlots() const;
+    bool isBankOpen() const { return bankOpen_; }
+    uint64_t getBankerGuid() const { return bankerGuid_; }
+    int getEffectiveBankSlots() const { return effectiveBankSlots_; }
+    int getEffectiveBankBagSlots() const { return effectiveBankBagSlots_; }
 
     // Guild Bank
     void openGuildBank(uint64_t guid);
@@ -2027,10 +1116,10 @@ public:
     void withdrawGuildBankMoney(uint32_t amount);
     void guildBankWithdrawItem(uint8_t tabId, uint8_t bankSlot, uint8_t destBag, uint8_t destSlot);
     void guildBankDepositItem(uint8_t tabId, uint8_t bankSlot, uint8_t srcBag, uint8_t srcSlot);
-    bool isGuildBankOpen() const;
-    const GuildBankData& getGuildBankData() const;
-    uint8_t getGuildBankActiveTab() const;
-    void setGuildBankActiveTab(uint8_t tab);
+    bool isGuildBankOpen() const { return guildBankOpen_; }
+    const GuildBankData& getGuildBankData() const { return guildBankData_; }
+    uint8_t getGuildBankActiveTab() const { return guildBankActiveTab_; }
+    void setGuildBankActiveTab(uint8_t tab) { guildBankActiveTab_ = tab; }
 
     // Auction House
     void openAuctionHouse(uint64_t guid);
@@ -2038,55 +1127,40 @@ public:
     void auctionSearch(const std::string& name, uint8_t levelMin, uint8_t levelMax,
                        uint32_t quality, uint32_t itemClass, uint32_t itemSubClass,
                        uint32_t invTypeMask, uint8_t usableOnly, uint32_t offset = 0);
-    void auctionSellItem(int backpackIndex, uint32_t bid,
+    void auctionSellItem(uint64_t itemGuid, uint32_t stackCount, uint32_t bid,
                          uint32_t buyout, uint32_t duration);
     void auctionPlaceBid(uint32_t auctionId, uint32_t amount);
     void auctionBuyout(uint32_t auctionId, uint32_t buyoutPrice);
     void auctionCancelItem(uint32_t auctionId);
     void auctionListOwnerItems(uint32_t offset = 0);
     void auctionListBidderItems(uint32_t offset = 0);
-    bool isAuctionHouseOpen() const;
-    uint64_t getAuctioneerGuid() const;
-    const AuctionListResult& getAuctionBrowseResults() const;
-    const AuctionListResult& getAuctionOwnerResults() const;
-    const AuctionListResult& getAuctionBidderResults() const;
-    int getAuctionActiveTab() const;
-    void setAuctionActiveTab(int tab);
-    float getAuctionSearchDelay() const;
+    bool isAuctionHouseOpen() const { return auctionOpen_; }
+    uint64_t getAuctioneerGuid() const { return auctioneerGuid_; }
+    const AuctionListResult& getAuctionBrowseResults() const { return auctionBrowseResults_; }
+    const AuctionListResult& getAuctionOwnerResults() const { return auctionOwnerResults_; }
+    const AuctionListResult& getAuctionBidderResults() const { return auctionBidderResults_; }
+    int getAuctionActiveTab() const { return auctionActiveTab_; }
+    void setAuctionActiveTab(int tab) { auctionActiveTab_ = tab; }
+    float getAuctionSearchDelay() const { return auctionSearchDelayTimer_; }
 
     // Trainer
-    bool isTrainerWindowOpen() const;
-    const TrainerListData& getTrainerSpells() const;
+    bool isTrainerWindowOpen() const { return trainerWindowOpen_; }
+    const TrainerListData& getTrainerSpells() const { return currentTrainerList_; }
     void trainSpell(uint32_t spellId);
     void closeTrainer();
     const std::string& getSpellName(uint32_t spellId) const;
     const std::string& getSpellRank(uint32_t spellId) const;
-    /// Returns the tooltip/description text from Spell.dbc (empty if unknown or has no text).
-    const std::string& getSpellDescription(uint32_t spellId) const;
-    const int32_t* getSpellEffectBasePoints(uint32_t spellId) const;
-    float getSpellDuration(uint32_t spellId) const;
-    std::string getEnchantName(uint32_t enchantId) const;
     const std::string& getSkillLineName(uint32_t spellId) const;
-    /// Returns the DispelType for a spell (0=none,1=magic,2=curse,3=disease,4=poison,5+=other)
-    uint8_t getSpellDispelType(uint32_t spellId) const;
-    /// Returns true if the spell can be interrupted by abilities like Kick/Counterspell.
-    /// False for spells with SPELL_ATTR_EX_NOT_INTERRUPTIBLE (attrEx bit 4 = 0x10).
-    bool isSpellInterruptible(uint32_t spellId) const;
-    /// Returns the school bitmask for the spell from Spell.dbc
-    /// (0x01=Physical, 0x02=Holy, 0x04=Fire, 0x08=Nature, 0x10=Frost, 0x20=Shadow, 0x40=Arcane).
-    /// Returns 0 if unknown.
-    uint32_t getSpellSchoolMask(uint32_t spellId) const;
 
     struct TrainerTab {
         std::string name;
         std::vector<const TrainerSpell*> spells;
     };
-    const std::vector<TrainerTab>& getTrainerTabs() const;
+    const std::vector<TrainerTab>& getTrainerTabs() const { return trainerTabs_; }
     const ItemQueryResponseData* getItemInfo(uint32_t itemId) const {
         auto it = itemInfoCache_.find(itemId);
         return (it != itemInfoCache_.end()) ? &it->second : nullptr;
     }
-    const std::unordered_map<uint32_t, ItemQueryResponseData>& getItemInfoCache() const { return itemInfoCache_; }
     // Request item info from server if not already cached/pending
     void ensureItemInfo(uint32_t entry) {
         if (entry == 0 || itemInfoCache_.count(entry) || pendingItemQueries_.count(entry)) return;
@@ -2096,23 +1170,7 @@ public:
         if (index < 0 || index >= static_cast<int>(backpackSlotGuids_.size())) return 0;
         return backpackSlotGuids_[index];
     }
-    uint64_t getEquipSlotGuid(int slot) const {
-        if (slot < 0 || slot >= static_cast<int>(equipSlotGuids_.size())) return 0;
-        return equipSlotGuids_[slot];
-    }
-    // Returns the permanent and temporary enchant IDs for an item by GUID (0 if unknown).
-    std::pair<uint32_t, uint32_t> getItemEnchantIds(uint64_t guid) const {
-        auto it = onlineItems_.find(guid);
-        if (it == onlineItems_.end()) return {0, 0};
-        return {it->second.permanentEnchantId, it->second.temporaryEnchantId};
-    }
-    // Returns the socket gem enchant IDs (3 slots; 0 = empty socket) for an item by GUID.
-    std::array<uint32_t, 3> getItemSocketEnchantIds(uint64_t guid) const {
-        auto it = onlineItems_.find(guid);
-        if (it == onlineItems_.end()) return {};
-        return it->second.socketEnchantIds;
-    }
-    uint64_t getVendorGuid() const;
+    uint64_t getVendorGuid() const { return currentVendorItems.vendorGuid; }
 
     /**
      * Set callbacks
@@ -2126,11 +1184,6 @@ public:
      * @param deltaTime Time since last update in seconds
      */
     void update(float deltaTime);
-    void updateNetworking(float deltaTime);
-    void updateTimers(float deltaTime);
-    void updateEntityInterpolation(float deltaTime);
-    void updateTaxiAndMountState(float deltaTime);
-    void updateAutoAttack(float deltaTime);
 
     /**
      * Reset DBC-backed caches so they reload from new expansion data.
@@ -2139,30 +1192,12 @@ public:
     void resetDbcCaches();
 
 private:
-    friend class ChatHandler;
-    friend class MovementHandler;
-    friend class CombatHandler;
-    friend class SpellHandler;
-    friend class InventoryHandler;
-    friend class SocialHandler;
-    friend class QuestHandler;
-    friend class WardenHandler;
-    friend class EntityController;
-
-    // Dead: autoTargetAttacker moved to CombatHandler
+    void autoTargetAttacker(uint64_t attackerGuid);
 
     /**
      * Handle incoming packet from world server
      */
     void handlePacket(network::Packet& packet);
-    void registerOpcodeHandlers();
-    void registerSkipHandler(LogicalOpcode op);
-    void registerErrorHandler(LogicalOpcode op, const char* msg);
-    void registerHandler(LogicalOpcode op, void (GameHandler::*handler)(network::Packet&));
-    void registerWorldHandler(LogicalOpcode op, void (GameHandler::*handler)(network::Packet&));
-    void enqueueIncomingPacket(const network::Packet& packet);
-    void enqueueIncomingPacketFront(network::Packet&& packet);
-    void processQueuedIncomingPackets();
 
     /**
      * Handle SMSG_AUTH_CHALLENGE from server
@@ -2203,6 +1238,7 @@ private:
      * Handle SMSG_WARDEN_DATA gate packet from server.
      * We do not implement anti-cheat exchange for third-party realms.
      */
+    void handleWardenData(network::Packet& packet);
 
     /**
      * Handle SMSG_ACCOUNT_DATA_TIMES from server
@@ -2222,7 +1258,37 @@ private:
      */
     void handlePong(network::Packet& packet);
 
+    /**
+     * Handle SMSG_UPDATE_OBJECT from server
+     */
+    void handleUpdateObject(network::Packet& packet);
+
+    /**
+     * Handle SMSG_COMPRESSED_UPDATE_OBJECT from server
+     */
+    void handleCompressedUpdateObject(network::Packet& packet);
+
+    /**
+     * Handle SMSG_DESTROY_OBJECT from server
+     */
+    void handleDestroyObject(network::Packet& packet);
+
+    /**
+     * Handle SMSG_MESSAGECHAT from server
+     */
+    void handleMessageChat(network::Packet& packet);
+    void handleTextEmote(network::Packet& packet);
+    void handleChannelNotify(network::Packet& packet);
+    void autoJoinDefaultChannels();
+
+    // ---- Phase 1 handlers ----
+    void handleNameQueryResponse(network::Packet& packet);
+    void handleCreatureQueryResponse(network::Packet& packet);
+    void handleGameObjectQueryResponse(network::Packet& packet);
+    void handleGameObjectPageText(network::Packet& packet);
+    void handlePageTextQueryResponse(network::Packet& packet);
     void handleItemQueryResponse(network::Packet& packet);
+    void handleInspectResults(network::Packet& packet);
     void queryItemInfo(uint32_t entry, uint64_t guid);
     void rebuildOnlineInventory();
     void maybeDetectVisibleItemLayout();
@@ -2234,15 +1300,53 @@ private:
     void extractContainerFields(uint64_t containerGuid, const std::map<uint16_t, uint32_t>& fields);
     uint64_t resolveOnlineItemGuid(uint32_t itemId) const;
 
-    // handleAttackStart, handleAttackStop, handleAttackerStateUpdate,
-    // handleSpellDamageLog, handleSpellHealLog removed
+    // ---- Phase 2 handlers ----
+    void handleAttackStart(network::Packet& packet);
+    void handleAttackStop(network::Packet& packet);
+    void handleAttackerStateUpdate(network::Packet& packet);
+    void handleSpellDamageLog(network::Packet& packet);
+    void handleSpellHealLog(network::Packet& packet);
 
     // ---- Equipment set handler ----
+    void handleEquipmentSetList(network::Packet& packet);
     void handleUpdateAuraDuration(uint8_t slot, uint32_t durationMs);
-    // handleSetForcedReactions — dispatched via CombatHandler
+    void handleSetForcedReactions(network::Packet& packet);
+
+    // ---- Phase 3 handlers ----
+    void handleInitialSpells(network::Packet& packet);
+    void handleCastFailed(network::Packet& packet);
+    void handleSpellStart(network::Packet& packet);
+    void handleSpellGo(network::Packet& packet);
+    void handleSpellCooldown(network::Packet& packet);
+    void handleCooldownEvent(network::Packet& packet);
+    void handleAchievementEarned(network::Packet& packet);
+    void handleAuraUpdate(network::Packet& packet, bool isAll);
+    void handleLearnedSpell(network::Packet& packet);
+    void handleSupercededSpell(network::Packet& packet);
+    void handleRemovedSpell(network::Packet& packet);
+    void handleUnlearnSpells(network::Packet& packet);
+
+    // ---- Talent handlers ----
+    void handleTalentsInfo(network::Packet& packet);
+
+    // ---- Phase 4 handlers ----
+    void handleGroupInvite(network::Packet& packet);
+    void handleGroupDecline(network::Packet& packet);
+    void handleGroupList(network::Packet& packet);
+    void handleGroupUninvite(network::Packet& packet);
+    void handlePartyCommandResult(network::Packet& packet);
+    void handlePartyMemberStats(network::Packet& packet, bool isFull);
 
     // ---- Guild handlers ----
+    void handleGuildInfo(network::Packet& packet);
+    void handleGuildRoster(network::Packet& packet);
+    void handleGuildQueryResponse(network::Packet& packet);
+    void handleGuildEvent(network::Packet& packet);
+    void handleGuildInvite(network::Packet& packet);
+    void handleGuildCommandResult(network::Packet& packet);
+    void handlePetitionShowlist(network::Packet& packet);
     void handlePetSpells(network::Packet& packet);
+    void handleTurnInPetitionResults(network::Packet& packet);
 
     // ---- Character creation handler ----
     void handleCharCreateResponse(network::Packet& packet);
@@ -2251,60 +1355,118 @@ private:
     void handleXpGain(network::Packet& packet);
 
     // ---- Creature movement handler ----
+    void handleMonsterMove(network::Packet& packet);
+    void handleCompressedMoves(network::Packet& packet);
+    void handleMonsterMoveTransport(network::Packet& packet);
 
     // ---- Other player movement (MSG_MOVE_* from server) ----
+    void handleOtherPlayerMovement(network::Packet& packet);
 
+    // ---- Phase 5 handlers ----
+    void handleLootResponse(network::Packet& packet);
+    void handleLootReleaseResponse(network::Packet& packet);
+    void handleLootRemoved(network::Packet& packet);
+    void handleGossipMessage(network::Packet& packet);
+    void handleQuestgiverQuestList(network::Packet& packet);
+    void handleGossipComplete(network::Packet& packet);
+    void handleQuestDetails(network::Packet& packet);
+    void handleQuestRequestItems(network::Packet& packet);
+    void handleQuestOfferReward(network::Packet& packet);
     void clearPendingQuestAccept(uint32_t questId);
     void triggerQuestAcceptResync(uint32_t questId, uint64_t npcGuid, const char* reason);
     bool hasQuestInLog(uint32_t questId) const;
-    std::string guidToUnitId(uint64_t guid) const;
-    Unit* getUnitByGuid(uint64_t guid);
-    std::string getQuestTitle(uint32_t questId) const;
-    const QuestLogEntry* findQuestLogEntry(uint32_t questId) const;
     int findQuestLogSlotIndexFromServer(uint32_t questId) const;
     void addQuestToLocalLogIfMissing(uint32_t questId, const std::string& title, const std::string& objectives);
     bool resyncQuestLogFromServerSlots(bool forceQueryMetadata);
+    void handleListInventory(network::Packet& packet);
     void addMoneyCopper(uint32_t amount);
 
     // ---- Teleport handler ----
+    void handleTeleportAck(network::Packet& packet);
+    void handleNewWorld(network::Packet& packet);
 
     // ---- Movement ACK handlers ----
+    void handleForceRunSpeedChange(network::Packet& packet);
+    void handleForceSpeedChange(network::Packet& packet, const char* name, Opcode ackOpcode, float* speedStorage);
+    void handleForceMoveRootState(network::Packet& packet, bool rooted);
+    void handleForceMoveFlagChange(network::Packet& packet, const char* name, Opcode ackOpcode, uint32_t flag, bool set);
+    void handleMoveKnockBack(network::Packet& packet);
 
     // ---- Area trigger detection ----
     void loadAreaTriggerDbc();
     void checkAreaTriggers();
 
     // ---- Instance lockout handler ----
+    void handleRaidInstanceInfo(network::Packet& packet);
+    void handleItemTextQueryResponse(network::Packet& packet);
+    void handleQuestConfirmAccept(network::Packet& packet);
     void handleSummonRequest(network::Packet& packet);
-    void resetTradeState();
+    void handleTradeStatus(network::Packet& packet);
     void handleDuelRequested(network::Packet& packet);
     void handleDuelComplete(network::Packet& packet);
     void handleDuelWinner(network::Packet& packet);
+    void handleLootRoll(network::Packet& packet);
+    void handleLootRollWon(network::Packet& packet);
 
     // ---- LFG / Dungeon Finder handlers ----
+    void handleLfgJoinResult(network::Packet& packet);
+    void handleLfgQueueStatus(network::Packet& packet);
+    void handleLfgProposalUpdate(network::Packet& packet);
+    void handleLfgRoleCheckUpdate(network::Packet& packet);
+    void handleLfgUpdatePlayer(network::Packet& packet);
+    void handleLfgPlayerReward(network::Packet& packet);
+    void handleLfgBootProposalUpdate(network::Packet& packet);
+    void handleLfgTeleportDenied(network::Packet& packet);
 
     // ---- Arena / Battleground handlers ----
+    void handleBattlefieldStatus(network::Packet& packet);
+    void handleInstanceDifficulty(network::Packet& packet);
+    void handleArenaTeamCommandResult(network::Packet& packet);
+    void handleArenaTeamQueryResponse(network::Packet& packet);
+    void handleArenaTeamInvite(network::Packet& packet);
+    void handleArenaTeamEvent(network::Packet& packet);
+    void handleArenaError(network::Packet& packet);
 
     // ---- Bank handlers ----
+    void handleShowBank(network::Packet& packet);
+    void handleBuyBankSlotResult(network::Packet& packet);
 
     // ---- Guild Bank handlers ----
+    void handleGuildBankList(network::Packet& packet);
 
     // ---- Auction House handlers ----
+    void handleAuctionHello(network::Packet& packet);
+    void handleAuctionListResult(network::Packet& packet);
+    void handleAuctionOwnerListResult(network::Packet& packet);
+    void handleAuctionBidderListResult(network::Packet& packet);
+    void handleAuctionCommandResult(network::Packet& packet);
 
     // ---- Mail handlers ----
+    void handleShowMailbox(network::Packet& packet);
+    void handleMailListResult(network::Packet& packet);
+    void handleSendMailResult(network::Packet& packet);
+    void handleReceivedMail(network::Packet& packet);
+    void handleQueryNextMailTime(network::Packet& packet);
 
     // ---- Taxi handlers ----
+    void handleShowTaxiNodes(network::Packet& packet);
+    void handleActivateTaxiReply(network::Packet& packet);
+    void loadTaxiDbc();
 
     // ---- Server info handlers ----
     void handleQueryTimeResponse(network::Packet& packet);
+    void handlePlayedTime(network::Packet& packet);
+    void handleWho(network::Packet& packet);
 
     // ---- Social handlers ----
+    void handleFriendStatus(network::Packet& packet);
+    void handleRandomRoll(network::Packet& packet);
 
     // ---- Logout handlers ----
+    void handleLogoutResponse(network::Packet& packet);
+    void handleLogoutComplete(network::Packet& packet);
 
-    void addCombatText(CombatTextEntry::Type type, int32_t amount, uint32_t spellId, bool isPlayerSource, uint8_t powerType = 0,
-                       uint64_t srcGuid = 0, uint64_t dstGuid = 0);
-    bool shouldLogSpellstealAura(uint64_t casterGuid, uint64_t victimGuid, uint32_t spellId);
+    void addCombatText(CombatTextEntry::Type type, int32_t amount, uint32_t spellId, bool isPlayerSource);
     void addSystemChatMessage(const std::string& message);
 
     /**
@@ -2337,23 +1499,6 @@ private:
                                 float localOrientation);
     void clearTransportAttachment(uint64_t childGuid);
 
-    // Explicit service dependencies (owned by Application)
-    GameServices& services_;
-
-    // Domain handlers — each manages a specific concern extracted from GameHandler
-    std::unique_ptr<ChatHandler>      chatHandler_;
-    std::unique_ptr<MovementHandler>  movementHandler_;
-    std::unique_ptr<CombatHandler>    combatHandler_;
-    std::unique_ptr<SpellHandler>     spellHandler_;
-    std::unique_ptr<InventoryHandler> inventoryHandler_;
-    std::unique_ptr<SocialHandler>    socialHandler_;
-    std::unique_ptr<QuestHandler>     questHandler_;
-    std::unique_ptr<WardenHandler>    wardenHandler_;
-
-    // Opcode dispatch table — built once in registerOpcodeHandlers(), called by handlePacket()
-    using PacketHandler = std::function<void(network::Packet&)>;
-    std::unordered_map<LogicalOpcode, PacketHandler> dispatchTable_;
-
     // Opcode translation table (expansion-specific wire ↔ logical mapping)
     OpcodeTable opcodeTable_;
 
@@ -2365,7 +1510,6 @@ private:
 
     // Network
     std::unique_ptr<network::WorldSocket> socket;
-    std::deque<network::Packet> pendingIncomingPackets_;
 
     // State
     WorldState state = WorldState::DISCONNECTED;
@@ -2387,36 +1531,24 @@ private:
     std::chrono::steady_clock::time_point movementClockStart_ = std::chrono::steady_clock::now();
     uint32_t lastMovementTimestampMs_ = 0;
     bool serverMovementAllowed_ = true;
-    uint32_t monsterMovePacketsThisTick_ = 0;
-    uint32_t monsterMovePacketsDroppedThisTick_ = 0;
-
-    // Fall/jump tracking for movement packet correctness.
-    // fallTime must be the elapsed ms since the FALLING flag was set; the server
-    // uses it for fall-damage calculations and anti-cheat validation.
-    bool isFalling_ = false;
-    uint32_t fallStartMs_ = 0;  // movementInfo.time value when FALLING started
 
     // Inventory
     Inventory inventory;
 
-    // Entity tracking (delegated to EntityController)
-    std::unique_ptr<EntityController> entityController_;
+    // Entity tracking
+    EntityManager entityManager;             // Manages all entities in view
 
-    // Chat (state lives in ChatHandler; callbacks remain here for cross-domain access)
+    // Chat
+    std::deque<MessageChatData> chatHistory;    // Recent chat messages
+    size_t maxChatHistory = 100;             // Maximum chat messages to keep
+    std::vector<std::string> joinedChannels_;   // Active channel memberships
     ChatBubbleCallback chatBubbleCallback_;
-    AddonChatCallback addonChatCallback_;
-    AddonEventCallback addonEventCallback_;
-    SpellIconPathResolver spellIconPathResolver_;
-    ItemIconPathResolver itemIconPathResolver_;
-    SpellDataResolver spellDataResolver_;
-    RandomPropertyNameResolver randomPropertyNameResolver_;
     EmoteAnimCallback emoteAnimCallback_;
 
     // Targeting
     uint64_t targetGuid = 0;
     uint64_t focusGuid = 0;              // Focus target
     uint64_t lastTargetGuid = 0;         // Previous target
-    uint64_t mouseoverGuid_ = 0;         // Set each frame by nameplate renderer
     std::vector<uint64_t> tabCycleList;
     int tabCycleIndex = -1;
     bool tabCycleStale = true;
@@ -2427,33 +1559,27 @@ private:
     float pingInterval = 30.0f;              // Ping interval (30 seconds)
     float timeSinceLastMoveHeartbeat_ = 0.0f; // Periodic movement heartbeat to keep server position synced
     float moveHeartbeatInterval_ = 0.5f;
-    uint32_t lastHeartbeatSendTimeMs_ = 0;
-    float lastHeartbeatX_ = 0.0f;
-    float lastHeartbeatY_ = 0.0f;
-    float lastHeartbeatZ_ = 0.0f;
-    uint32_t lastHeartbeatFlags_ = 0;
-    uint64_t lastHeartbeatTransportGuid_ = 0;
-    uint32_t lastNonHeartbeatMoveSendTimeMs_ = 0;
-    uint32_t lastFacingSendTimeMs_ = 0;
-    float lastFacingSentOrientation_ = 0.0f;
     uint32_t lastLatency = 0;                // Last measured latency (milliseconds)
-    std::chrono::steady_clock::time_point pingTimestamp_;  // Time CMSG_PING was sent
 
     // Player GUID and map
     uint64_t playerGuid = 0;
     uint32_t currentMapId_ = 0;
     bool hasHomeBind_ = false;
     uint32_t homeBindMapId_ = 0;
-    uint32_t homeBindZoneId_ = 0;
     glm::vec3 homeBindPos_{0.0f};
 
+    // ---- Phase 1: Name caches ----
+    std::unordered_map<uint64_t, std::string> playerNameCache;
+    std::unordered_set<uint64_t> pendingNameQueries;
+    std::unordered_map<uint32_t, CreatureQueryResponseData> creatureInfoCache;
+    std::unordered_set<uint32_t> pendingCreatureQueries;
+    std::unordered_map<uint32_t, GameObjectQueryResponseData> gameObjectInfoCache_;
+    std::unordered_set<uint32_t> pendingGameObjectQueries_;
 
-    // ---- Friend/contact list cache ----
+    // ---- Friend list cache ----
     std::unordered_map<std::string, uint64_t> friendsCache;  // name -> guid
-    std::unordered_set<uint64_t> friendGuids_;               // all known friend GUIDs (for name backfill)
     uint32_t lastContactListMask_ = 0;
     uint32_t lastContactListCount_ = 0;
-    std::vector<ContactEntry> contacts_;                     // structured contact list (friends + ignores)
 
     // ---- World state and faction initialization snapshots ----
     uint32_t worldStateMapId_ = 0;
@@ -2462,12 +1588,10 @@ private:
     std::vector<FactionStandingInit> initialFactions_;
 
     // ---- Ignore list cache ----
-    std::unordered_map<std::string, uint64_t> ignoreCache;  // name -> guid (UI display)
-    std::unordered_set<uint64_t> ignoreListGuids_;            // authoritative GUID set from server
+    std::unordered_map<std::string, uint64_t> ignoreCache;  // name -> guid
 
     // ---- Logout state ----
-    bool  loggingOut_        = false;
-    float logoutCountdown_   = 0.0f;   // seconds remaining before server logs us out (0 = instant/done)
+    bool loggingOut_ = false;
 
     // ---- Display state ----
     bool helmVisible_ = true;
@@ -2476,7 +1600,6 @@ private:
 
     // ---- Follow state ----
     uint64_t followTargetGuid_ = 0;
-    glm::vec3 followRenderPos_{0.0f};  // Render-space position of followed entity (updated each frame)
 
     // ---- AFK/DND status ----
     bool afkStatus_ = false;
@@ -2484,33 +1607,17 @@ private:
     std::string afkMessage_;
     std::string dndMessage_;
     std::string lastWhisperSender_;
-    uint64_t lastWhisperSenderGuid_ = 0;
 
     // ---- Online item tracking ----
     struct OnlineItemInfo {
         uint32_t entry = 0;
         uint32_t stackCount = 1;
-        uint32_t curDurability = 0;
-        uint32_t maxDurability = 0;
-        uint32_t permanentEnchantId = 0;  // ITEM_ENCHANTMENT_SLOT 0 (enchanting)
-        uint32_t temporaryEnchantId = 0;  // ITEM_ENCHANTMENT_SLOT 1 (sharpening stones, poisons)
-        std::array<uint32_t, 3> socketEnchantIds{};  // ITEM_ENCHANTMENT_SLOT 2-4 (gems)
     };
     std::unordered_map<uint64_t, OnlineItemInfo> onlineItems_;
     std::unordered_map<uint32_t, ItemQueryResponseData> itemInfoCache_;
     std::unordered_set<uint32_t> pendingItemQueries_;
-    float pendingItemQueryTimer_ = 0.0f;
-
-    // Deferred SMSG_ITEM_PUSH_RESULT notifications for items whose info wasn't
-    // cached at arrival time; emitted once the query response arrives.
-    struct PendingItemPushNotif {
-        uint32_t itemId = 0;
-        uint32_t count  = 1;
-    };
-    std::vector<PendingItemPushNotif> pendingItemPushNotifs_;
     std::array<uint64_t, 23> equipSlotGuids_{};
     std::array<uint64_t, 16> backpackSlotGuids_{};
-    std::array<uint64_t, 32> keyringSlotGuids_{};
     // Container (bag) contents: containerGuid -> array of item GUIDs per slot
     struct ContainerInfo {
         uint32_t numSlots = 0;
@@ -2525,14 +1632,9 @@ private:
 
     // Visible equipment for other players: detect the update-field layout (base + stride)
     // using the local player's own equipped items, then decode other players by index.
-    // WotLK 3.3.5a (AzerothCore/ChromieCraft): visible item entries appear at field
-    // WotLK 3.3.5a: PLAYER_VISIBLE_ITEM_1_ENTRYID = field 283, stride 2.
-    // Confirmed by RAW FIELDS dump: base=283 gives 17/19 valid item IDs,
-    // base=284 reads enchant values instead.
-    // Slots: HEAD=0, NECK=1, SHOULDERS=2, BODY=3, CHEST=4, WAIST=5, LEGS=6,
-    //        FEET=7, WRISTS=8, HANDS=9, FINGER1=10, FINGER2=11, TRINKET1=12,
-    //        TRINKET2=13, BACK=14, MAINHAND=15, OFFHAND=16, RANGED=17, TABARD=18
-    int visibleItemEntryBase_ = 283;
+    // Default to known WotLK 3.3.5a layout: UNIT_END(148) + 0x0088 = 284, stride 2.
+    // The heuristic in maybeDetectVisibleItemLayout() can still override if needed.
+    int visibleItemEntryBase_ = 284;
     int visibleItemStride_ = 2;
     bool visibleItemLayoutVerified_ = false;  // true once heuristic confirms/overrides default
     std::unordered_map<uint64_t, std::array<uint32_t, 19>> otherPlayerVisibleItemEntries_;
@@ -2542,23 +1644,27 @@ private:
 
     // Inspect fallback (when visible item fields are missing/unreliable)
     std::unordered_map<uint64_t, std::array<uint32_t, 19>> inspectedPlayerItemEntries_;
-    InspectResult inspectResult_; // most-recently received inspect response
     std::unordered_set<uint64_t> pendingAutoInspect_;
     float inspectRateLimit_ = 0.0f;
 
-    // ---- Combat ----
-    bool wasCombat_ = false;  // Previous frame combat state for PLAYER_REGEN edge detection
-    std::deque<std::string>    areaTriggerMsgs_;
+    // ---- Phase 2: Combat ----
+    bool autoAttacking = false;
+    bool autoAttackRequested_ = false;   // local intent (CMSG_ATTACKSWING sent)
+    uint64_t autoAttackTarget = 0;
+    bool autoAttackOutOfRange_ = false;
+    float autoAttackOutOfRangeTime_ = 0.0f;
+    float autoAttackRangeWarnCooldown_ = 0.0f;
+    float autoAttackResendTimer_ = 0.0f;  // Re-send CMSG_ATTACKSWING every ~1s while attacking
+    float autoAttackFacingSyncTimer_ = 0.0f; // Periodic facing sync while meleeing
+    std::unordered_set<uint64_t> hostileAttackers_;
+    std::vector<CombatTextEntry> combatText;
 
+    // ---- Phase 3: Spells ----
     WorldEntryCallback worldEntryCallback_;
-    KnockBackCallback knockBackCallback_;
-    CameraShakeCallback cameraShakeCallback_;
-    AutoFollowCallback autoFollowCallback_;
     UnstuckCallback unstuckCallback_;
     UnstuckCallback unstuckGyCallback_;
     UnstuckCallback unstuckHearthCallback_;
     BindPointCallback bindPointCallback_;
-    HearthstonePreloadCallback hearthstonePreloadCallback_;
     CreatureSpawnCallback creatureSpawnCallback_;
     CreatureDespawnCallback creatureDespawnCallback_;
     PlayerSpawnCallback playerSpawnCallback_;
@@ -2571,9 +1677,6 @@ private:
     GameObjectMoveCallback gameObjectMoveCallback_;
     GameObjectDespawnCallback gameObjectDespawnCallback_;
     GameObjectCustomAnimCallback gameObjectCustomAnimCallback_;
-    GameObjectStateCallback gameObjectStateCallback_;
-    SprintAuraCallback sprintAuraCallback_;
-    VehicleStateCallback vehicleStateCallback_;
 
     // Transport tracking
     struct TransportAttachment {
@@ -2584,26 +1687,30 @@ private:
         bool hasLocalOrientation = false;
     };
     std::unordered_map<uint64_t, TransportAttachment> transportAttachments_;
-    // Transport GUID tracking moved to EntityController
+    std::unordered_set<uint64_t> transportGuids_;  // GUIDs of known transport GameObjects
+    std::unordered_set<uint64_t> serverUpdatedTransportGuids_;
     uint64_t playerTransportGuid_ = 0;             // Transport the player is riding (0 = none)
     glm::vec3 playerTransportOffset_ = glm::vec3(0.0f); // Player offset on transport
     uint64_t playerTransportStickyGuid_ = 0;       // Last transport player was on (temporary retention)
     float playerTransportStickyTimer_ = 0.0f;      // Seconds to keep sticky transport alive after transient clears
     std::unique_ptr<TransportManager> transportManager_;  // Transport movement manager
+    std::unordered_set<uint32_t> knownSpells;
+    std::unordered_map<uint32_t, float> spellCooldowns;    // spellId -> remaining seconds
     uint32_t weaponProficiency_ = 0;  // bitmask from SMSG_SET_PROFICIENCY itemClass=2
     uint32_t armorProficiency_  = 0;  // bitmask from SMSG_SET_PROFICIENCY itemClass=4
-    std::vector<MinimapPing> minimapPings_;
+    uint8_t castCount = 0;
+    bool casting = false;
+    uint32_t currentCastSpellId = 0;
+    float castTimeRemaining = 0.0f;
     uint64_t pendingGameObjectInteractGuid_ = 0;
 
     // Talents (dual-spec support)
     uint8_t activeTalentSpec_ = 0;                              // Currently active spec (0 or 1)
     uint8_t unspentTalentPoints_[2] = {0, 0};                   // Unspent points per spec
     std::unordered_map<uint32_t, uint8_t> learnedTalents_[2];  // Learned talents per spec
-    std::array<std::array<uint16_t, MAX_GLYPH_SLOTS>, 2> learnedGlyphs_{};  // Glyphs per spec
     std::unordered_map<uint32_t, TalentEntry> talentCache_;      // talentId -> entry
     std::unordered_map<uint32_t, TalentTabEntry> talentTabCache_; // tabId -> entry
     bool talentDbcLoaded_ = false;
-    bool talentsInitialized_ = false;                           // Reset on world entry; guards first-spec selection
 
     // ---- Area trigger detection ----
     struct AreaTriggerEntry {
@@ -2620,45 +1727,28 @@ private:
     float areaTriggerCheckTimer_ = 0.0f;
     bool areaTriggerSuppressFirst_ = false;  // suppress first check after map transfer
 
-    std::array<ActionBarSlot, ACTION_BAR_SLOTS> actionBar{};
-    std::unordered_map<uint32_t, std::string> macros_;  // client-side macro text (persisted in char config)
+    float castTimeTotal = 0.0f;
+    std::array<ActionBarSlot, 12> actionBar{};
     std::vector<AuraSlot> playerAuras;
     std::vector<AuraSlot> targetAuras;
-    std::unordered_map<uint64_t, std::vector<AuraSlot>> unitAurasCache_; // per-unit aura cache
     uint64_t petGuid_ = 0;
-    uint32_t petActionSlots_[10] = {};   // SMSG_PET_SPELLS action bar (10 slots)
-    uint8_t  petCommand_ = 1;            // 0=stay,1=follow,2=attack,3=dismiss
-    uint8_t  petReact_   = 1;            // 0=passive,1=defensive,2=aggressive
-    bool     petRenameablePending_ = false;  // set by SMSG_PET_RENAMEABLE, consumed by UI
-    std::vector<uint32_t> petSpellList_; // known pet spells
-    std::unordered_set<uint32_t> petAutocastSpells_;  // spells with autocast on
-
-    // ---- Pet Stable ----
-    bool stableWindowOpen_    = false;
-    uint64_t stableMasterGuid_ = 0;
-    uint8_t  stableNumSlots_   = 0;
-    std::vector<StabledPet> stabledPets_;
-    void handleListStabledPets(network::Packet& packet);
 
     // ---- Battleground queue state ----
+    struct BgQueueSlot {
+        uint32_t queueSlot = 0;
+        uint32_t bgTypeId = 0;
+        uint8_t arenaType = 0;
+        uint32_t statusId = 0;  // 0=none, 1=wait_queue, 2=wait_join, 3=in_progress
+    };
     std::array<BgQueueSlot, 3> bgQueues_{};
 
-    // ---- Available battleground list (SMSG_BATTLEFIELD_LIST) ----
-    std::vector<AvailableBgInfo> availableBgs_;
-
     // Instance difficulty
     uint32_t instanceDifficulty_ = 0;
     bool instanceIsHeroic_ = false;
-    bool inInstance_ = false;
-
-    // Raid target markers (icon 0-7 -> guid; 0 = empty slot)
-    std::array<uint64_t, kRaidMarkCount> raidTargetGuids_ = {};
 
     // Mirror timers (0=fatigue, 1=breath, 2=feigndeath)
     MirrorTimer mirrorTimers_[3];
 
-    // Shapeshift form (from UNIT_FIELD_BYTES_1 byte 3)
-    uint8_t  shapeshiftFormId_ = 0;
     // Combo points (rogues/druids)
     uint8_t  comboPoints_ = 0;
     uint64_t comboTarget_ = 0;
@@ -2666,17 +1756,6 @@ private:
     // Instance / raid lockouts
     std::vector<InstanceLockout> instanceLockouts_;
 
-    // Arena team stats (indexed by team slot, updated by SMSG_ARENA_TEAM_STATS)
-    std::vector<ArenaTeamStats>  arenaTeamStats_;
-    // Arena team rosters (updated by SMSG_ARENA_TEAM_ROSTER)
-    std::vector<ArenaTeamRoster> arenaTeamRosters_;
-
-    // BG scoreboard (MSG_PVP_LOG_DATA)
-    BgScoreboardData bgScoreboard_;
-
-    // BG flag carrier / player positions (MSG_BATTLEGROUND_PLAYER_POSITIONS)
-    std::vector<BgPlayerPosition> bgPlayerPositions_;
-
     // Instance encounter boss units (slots 0-4 from SMSG_UPDATE_INSTANCE_ENCOUNTER_UNIT)
     std::array<uint64_t, kMaxEncounterSlots> encounterUnitGuids_ = {};  // 0 = empty slot
 
@@ -2686,33 +1765,20 @@ private:
     uint32_t lfgProposalId_   = 0;   // pending proposal id (0 = none)
     int32_t  lfgAvgWaitSec_   = -1;  // estimated wait, -1=unknown
     uint32_t lfgTimeInQueueMs_= 0;   // ms already in queue
-    uint32_t lfgBootVotes_    = 0;   // current boot-yes votes
-    uint32_t lfgBootTotal_    = 0;   // total votes cast
-    uint32_t lfgBootTimeLeft_ = 0;   // seconds remaining
-    uint32_t lfgBootNeeded_   = 0;   // votes needed to kick
-    std::string lfgBootTargetName_;  // name of player being voted on
-    std::string lfgBootReason_;      // reason given for kick
 
     // Ready check state
-    bool        pendingReadyCheck_       = false;
-    uint32_t    readyCheckReadyCount_    = 0;
-    uint32_t    readyCheckNotReadyCount_ = 0;
+    bool        pendingReadyCheck_     = false;
     std::string readyCheckInitiator_;
-    std::vector<ReadyCheckResult> readyCheckResults_; // per-player status live during check
 
     // Faction standings (factionId → absolute standing value)
     std::unordered_map<uint32_t, int32_t> factionStandings_;
     // Faction name cache (factionId → name), populated lazily from Faction.dbc
-    mutable std::unordered_map<uint32_t, std::string> factionNameCache_;
-    // repListId → factionId mapping (populated with factionNameCache)
-    mutable std::unordered_map<uint32_t, uint32_t> factionRepListToId_;
-    // factionId → repListId reverse mapping
-    mutable std::unordered_map<uint32_t, uint32_t> factionIdToRepList_;
-    mutable bool factionNameCacheLoaded_ = false;
-    void loadFactionNameCache() const;
+    std::unordered_map<uint32_t, std::string> factionNameCache_;
+    bool factionNameCacheLoaded_ = false;
+    void loadFactionNameCache();
     std::string getFactionName(uint32_t factionId) const;
 
-    // ---- Group ----
+    // ---- Phase 4: Group ----
     GroupListData partyData;
     bool pendingGroupInvite = false;
     std::string pendingInviterName;
@@ -2733,32 +1799,17 @@ private:
     uint64_t    summonerGuid_         = 0;
     std::string summonerName_;
     float       summonTimeoutSec_     = 0.0f;
-    uint32_t    totalTimePlayed_      = 0;
-    uint32_t    levelTimePlayed_      = 0;
-
-    // Who results (last SMSG_WHO response)
-    std::vector<WhoEntry> whoResults_;
-    uint32_t whoOnlineCount_ = 0;
 
     // Trade state
     TradeStatus tradeStatus_  = TradeStatus::None;
     uint64_t    tradePeerGuid_= 0;
     std::string tradePeerName_;
-    std::array<TradeSlot, TRADE_SLOT_COUNT> myTradeSlots_{};
-    std::array<TradeSlot, TRADE_SLOT_COUNT> peerTradeSlots_{};
-    uint64_t myTradeGold_   = 0;
-    uint64_t peerTradeGold_ = 0;
-
-    // Shaman totem state
-    TotemSlot activeTotemSlots_[NUM_TOTEM_SLOTS];
 
     // Duel state
     bool pendingDuelRequest_    = false;
     uint64_t duelChallengerGuid_= 0;
     uint64_t duelFlagGuid_      = 0;
     std::string duelChallengerName_;
-    uint32_t duelCountdownMs_   = 0;   // 0 = no active countdown
-    std::chrono::steady_clock::time_point duelCountdownStartedAt_{};
 
     // ---- Guild state ----
     std::string guildName_;
@@ -2767,29 +1818,20 @@ private:
     GuildInfoData guildInfoData_;
     GuildQueryResponseData guildQueryData_;
     bool hasGuildRoster_ = false;
-    std::unordered_map<uint32_t, std::string> guildNameCache_;  // guildId → guild name
-    std::unordered_set<uint32_t> pendingGuildNameQueries_;      // in-flight guild queries
     bool pendingGuildInvite_ = false;
     std::string pendingGuildInviterName_;
     std::string pendingGuildInviteGuildName_;
     bool showPetitionDialog_ = false;
     uint32_t petitionCost_ = 0;
     uint64_t petitionNpcGuid_ = 0;
-    PetitionInfo petitionInfo_;
 
     uint64_t activeCharacterGuid_ = 0;
     Race playerRace_ = Race::HUMAN;
 
-    // Barber shop
-    bool barberShopOpen_ = false;
-
-    // ---- Loot ----
+    // ---- Phase 5: Loot ----
     bool lootWindowOpen = false;
     bool autoLoot_ = false;
-    bool autoSellGrey_ = false;
-    bool autoRepair_ = false;
     LootResponseData currentLoot;
-    std::vector<uint64_t> masterLootCandidates_;  // from SMSG_LOOT_MASTER_LIST
 
     // Group loot roll state
     bool          pendingLootRollActive_ = false;
@@ -2797,7 +1839,6 @@ private:
     struct LocalLootState {
         LootResponseData data;
         bool moneyTaken = false;
-        bool itemAutoLootSent = false;
     };
     std::unordered_map<uint64_t, LocalLootState> localLootState_;
     struct PendingLootRetry {
@@ -2812,32 +1853,12 @@ private:
         float timer = 0.0f;
     };
     std::vector<PendingLootOpen> pendingGameObjectLootOpens_;
-    // Tracks the last GO we sent CMSG_GAMEOBJ_USE to; used in handleSpellGo
-    // to send CMSG_LOOT after a gather cast (mining/herbalism) completes.
-    uint64_t lastInteractedGoGuid_ = 0;
     uint64_t pendingLootMoneyGuid_ = 0;
     uint32_t pendingLootMoneyAmount_ = 0;
     float pendingLootMoneyNotifyTimer_ = 0.0f;
     std::unordered_map<uint64_t, float> recentLootMoneyAnnounceCooldowns_;
     uint64_t playerMoneyCopper_ = 0;
-    uint32_t playerHonorPoints_ = 0;
-    uint32_t playerArenaPoints_ = 0;
     int32_t playerArmorRating_ = 0;
-    int32_t playerResistances_[6] = {};  // [0]=Holy,[1]=Fire,[2]=Nature,[3]=Frost,[4]=Shadow,[5]=Arcane
-    // Server-authoritative primary stats: [0]=STR [1]=AGI [2]=STA [3]=INT [4]=SPI; -1 = not received yet
-    int32_t playerStats_[5] = {-1, -1, -1, -1, -1};
-    // WotLK secondary combat stats (-1 = not yet received)
-    int32_t playerMeleeAP_    = -1;
-    int32_t playerRangedAP_   = -1;
-    int32_t playerSpellDmgBonus_[7] = {-1,-1,-1,-1,-1,-1,-1}; // per school 0-6
-    int32_t playerHealBonus_  = -1;
-    float playerDodgePct_     = -1.0f;
-    float playerParryPct_     = -1.0f;
-    float playerBlockPct_     = -1.0f;
-    float playerCritPct_      = -1.0f;
-    float playerRangedCritPct_ = -1.0f;
-    float playerSpellCritPct_[7] = {-1.0f,-1.0f,-1.0f,-1.0f,-1.0f,-1.0f,-1.0f};
-    int32_t playerCombatRatings_[25] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
     // Some servers/custom clients shift update field indices. We can auto-detect coinage by correlating
     // money-notify deltas with update-field diffs and then overriding UF::PLAYER_FIELD_COINAGE at runtime.
     uint32_t pendingMoneyDelta_ = 0;
@@ -2852,7 +1873,6 @@ private:
 
     // Quest details
     bool questDetailsOpen = false;
-    std::chrono::steady_clock::time_point questDetailsOpenTime{};  // Delayed opening to allow item data to load
     QuestDetailsData currentQuestDetails;
 
     // Quest turn-in
@@ -2868,9 +1888,7 @@ private:
 
     // Quest log
     std::vector<QuestLogEntry> questLog_;
-    int selectedQuestLogIndex_ = 0;
     std::unordered_set<uint32_t> pendingQuestQueryIds_;
-    std::unordered_set<uint32_t> trackedQuestIds_;
     bool pendingLoginQuestResync_ = false;
     float pendingLoginQuestResyncTimeout_ = 0.0f;
 
@@ -2884,9 +1902,6 @@ private:
         return it != factionHostileMap_.end() ? it->second : true; // default hostile if unknown
     }
 
-    // Vehicle (WotLK): non-zero when player is seated in a vehicle
-    uint32_t vehicleId_ = 0;
-
     // Taxi / Flight Paths
     std::unordered_map<uint64_t, bool> taxiNpcHasRoutes_;  // guid -> has new/available routes
     std::unordered_map<uint32_t, TaxiNode> taxiNodes_;
@@ -2897,7 +1912,6 @@ private:
     ShowTaxiNodesData currentTaxiData_;
     uint64_t taxiNpcGuid_ = 0;
     bool onTaxiFlight_ = false;
-    std::string taxiDestName_;
     bool taxiMountActive_ = false;
     uint32_t taxiMountDisplayId_ = 0;
     bool taxiActivatePending_ = false;
@@ -2915,8 +1929,11 @@ private:
     uint32_t knownTaxiMask_[12] = {};  // Track previously known nodes for discovery alerts
     bool taxiMaskInitialized_ = false; // First SMSG_SHOWTAXINODES seeds mask without alerts
     std::unordered_map<uint32_t, uint32_t> taxiCostMap_; // destNodeId -> total cost in copper
+    void buildTaxiCostMap();
+    void applyTaxiMountForCurrentNode();
     uint32_t nextMovementTimestampMs();
     void sanitizeMovementForTaxi();
+    void startClientTaxiPath(const std::vector<uint32_t>& pathNodes);
     void updateClientTaxi(float deltaTime);
 
     // Mail
@@ -2980,62 +1997,17 @@ private:
     // Trainer
     bool trainerWindowOpen_ = false;
     TrainerListData currentTrainerList_;
-    struct SpellNameEntry {
-        std::string name; std::string rank; std::string description;
-        uint32_t schoolMask = 0; uint8_t dispelType = 0; uint32_t attrEx = 0;
-        int32_t effectBasePoints[3] = {0, 0, 0};
-        float durationSec = 0.0f; // resolved from DurationIndex → SpellDuration.dbc
-    };
-    mutable std::unordered_map<uint32_t, SpellNameEntry> spellNameCache_;
-    mutable bool spellNameCacheLoaded_ = false;
+    struct SpellNameEntry { std::string name; std::string rank; uint32_t schoolMask = 0; };
+    std::unordered_map<uint32_t, SpellNameEntry> spellNameCache_;
+    bool spellNameCacheLoaded_ = false;
 
-    // Title cache: maps titleBit → title string (lazy-loaded from CharTitles.dbc)
-    // The strings use "%s" as a player-name placeholder (e.g. "Commander %s", "%s the Explorer").
-    mutable std::unordered_map<uint32_t, std::string> titleNameCache_;
-    mutable bool titleNameCacheLoaded_ = false;
-    void loadTitleNameCache() const;
-    // Set of title bit-indices known to the player (from SMSG_TITLE_EARNED).
-    std::unordered_set<uint32_t> knownTitleBits_;
-    // Currently selected title bit, or -1 for no title. Updated from PLAYER_CHOSEN_TITLE.
-    int32_t chosenTitleBit_ = -1;
-
-    // Achievement caches (lazy-loaded from Achievement.dbc on first earned event)
+    // Achievement name cache (lazy-loaded from Achievement.dbc on first earned event)
     std::unordered_map<uint32_t, std::string> achievementNameCache_;
-    std::unordered_map<uint32_t, std::string> achievementDescCache_;
-    std::unordered_map<uint32_t, uint32_t>    achievementPointsCache_;
     bool achievementNameCacheLoaded_ = false;
     void loadAchievementNameCache();
-    // Set of achievement IDs earned by the player (populated from SMSG_ALL_ACHIEVEMENT_DATA)
-    std::unordered_set<uint32_t> earnedAchievements_;
-    // Earn dates: achievementId → WoW PackedTime (from SMSG_ACHIEVEMENT_EARNED / SMSG_ALL_ACHIEVEMENT_DATA)
-    std::unordered_map<uint32_t, uint32_t> achievementDates_;
-    // Criteria progress: criteriaId → current value (from SMSG_CRITERIA_UPDATE)
-    std::unordered_map<uint32_t, uint64_t> criteriaProgress_;
-    void handleAllAchievementData(network::Packet& packet);
-
-    // Per-player achievement data from SMSG_RESPOND_INSPECT_ACHIEVEMENTS
-    // Key: inspected player's GUID; value: set of earned achievement IDs
-    std::unordered_map<uint64_t, std::unordered_set<uint32_t>> inspectedPlayerAchievements_;
-
-    // Area name cache (lazy-loaded from WorldMapArea.dbc; maps AreaTable ID → display name)
-    mutable std::unordered_map<uint32_t, std::string> areaNameCache_;
-    mutable bool areaNameCacheLoaded_ = false;
-    void loadAreaNameCache() const;
-    std::string getAreaName(uint32_t areaId) const;
-
-    // Map name cache (lazy-loaded from Map.dbc; maps mapId → localized display name)
-    mutable std::unordered_map<uint32_t, std::string> mapNameCache_;
-    mutable bool mapNameCacheLoaded_ = false;
-    void loadMapNameCache() const;
-
-    // LFG dungeon name cache (lazy-loaded from LFGDungeons.dbc; WotLK only)
-    mutable std::unordered_map<uint32_t, std::string> lfgDungeonNameCache_;
-    mutable bool lfgDungeonNameCacheLoaded_ = false;
-    void loadLfgDungeonDbc() const;
-    std::string getLfgDungeonName(uint32_t dungeonId) const;
     std::vector<TrainerTab> trainerTabs_;
-    void loadSpellNameCache() const;
-    void preloadDBCCaches() const;
+    void handleTrainerList(network::Packet& packet);
+    void loadSpellNameCache();
     void categorizeTrainerSpells();
 
     // Callbacks
@@ -3083,21 +2055,11 @@ private:
     std::vector<WardenCREntry> wardenCREntries_;
     // Module-specific check type opcodes [9]: MEM, PAGE_A, PAGE_B, MPQ, LUA, DRIVER, TIMING, PROC, MODULE
     uint8_t wardenCheckOpcodes_[9] = {};
-
-    // Async Warden response: avoids 5-second main-loop stalls from PAGE_A/PAGE_B code pattern searches
-    std::future<std::vector<uint8_t>> wardenPendingEncrypted_;  // encrypted response bytes
-    bool wardenResponsePending_ = false;
-
-    // ---- RX silence detection ----
-    std::chrono::steady_clock::time_point lastRxTime_{};
-    bool rxSilenceLogged_ = false;
-    bool rxSilence15sLogged_ = false;
+    bool loadWardenCRFile(const std::string& moduleHashHex);
 
     // ---- XP tracking ----
     uint32_t playerXp_ = 0;
     uint32_t playerNextLevelXp_ = 0;
-    uint32_t playerRestedXp_ = 0;
-    bool isResting_ = false;
     uint32_t serverPlayerLevel_ = 1;
     static uint32_t xpForLevel(uint32_t level);
 
@@ -3106,10 +2068,6 @@ private:
     float timeSpeed_ = 0.0166f;   // Time scale (default: 1 game day = 1 real hour)
     void handleLoginSetTimeSpeed(network::Packet& packet);
 
-    // ---- Global Cooldown (GCD) ----
-    float gcdTotal_ = 0.0f;
-    std::chrono::steady_clock::time_point gcdStartedAt_{};
-
     // ---- Weather state (SMSG_WEATHER) ----
     uint32_t weatherType_ = 0;       // 0=clear, 1=rain, 2=snow, 3=storm
     float weatherIntensity_ = 0.0f;  // 0.0 to 1.0
@@ -3119,12 +2077,10 @@ private:
     uint32_t overrideLightTransMs_ = 0;
 
     // ---- Player skills ----
-    std::unordered_map<uint32_t, PlayerSkill> playerSkills_;
+    std::map<uint32_t, PlayerSkill> playerSkills_;
     std::unordered_map<uint32_t, std::string> skillLineNames_;
     std::unordered_map<uint32_t, uint32_t> skillLineCategories_;
     std::unordered_map<uint32_t, uint32_t> spellToSkillLine_;      // spellID -> skillLineID
-    std::vector<SpellBookTab> spellBookTabs_;
-    bool spellBookTabsDirty_ = true;
     bool skillLineDbcLoaded_ = false;
     bool skillLineAbilityLoaded_ = false;
     static constexpr size_t PLAYER_EXPLORED_ZONES_COUNT = 128;
@@ -3135,45 +2091,23 @@ private:
     void loadSkillLineAbilityDbc();
     void extractSkillFields(const std::map<uint16_t, uint32_t>& fields);
     void extractExploredZoneFields(const std::map<uint16_t, uint32_t>& fields);
-    void applyQuestStateFromFields(const std::map<uint16_t, uint32_t>& fields);
-    // Apply packed kill counts from player update fields to a quest entry that has
-    // already had its killObjectives populated from SMSG_QUEST_QUERY_RESPONSE.
-    void applyPackedKillCountsFromFields(QuestLogEntry& quest);
 
     NpcDeathCallback npcDeathCallback_;
     NpcAggroCallback npcAggroCallback_;
     NpcRespawnCallback npcRespawnCallback_;
-    StandStateCallback standStateCallback_;
-    AppearanceChangedCallback appearanceChangedCallback_;
-    GhostStateCallback ghostStateCallback_;
     MeleeSwingCallback meleeSwingCallback_;
-    // lastMeleeSwingMs_ moved to CombatHandler
-    SpellCastAnimCallback spellCastAnimCallback_;
-    SpellCastFailedCallback spellCastFailedCallback_;
-    UnitAnimHintCallback unitAnimHintCallback_;
-    UnitMoveFlagsCallback unitMoveFlagsCallback_;
     NpcSwingCallback npcSwingCallback_;
-    HitReactionCallback hitReactionCallback_;
-    StunStateCallback stunStateCallback_;
-    StealthStateCallback stealthStateCallback_;
-    PlayerHealthCallback playerHealthCallback_;
     NpcGreetingCallback npcGreetingCallback_;
     NpcFarewellCallback npcFarewellCallback_;
     NpcVendorCallback npcVendorCallback_;
     ChargeCallback chargeCallback_;
     LevelUpCallback levelUpCallback_;
-    LevelUpDeltas lastLevelUpDeltas_;
-    std::vector<TempEnchantTimer> tempEnchantTimers_;
-    std::vector<BookPage> bookPages_;            // pages collected for the current readable item
     OtherPlayerLevelUpCallback otherPlayerLevelUpCallback_;
     AchievementEarnedCallback achievementEarnedCallback_;
-    AreaDiscoveryCallback areaDiscoveryCallback_;
-    QuestProgressCallback questProgressCallback_;
     MountCallback mountCallback_;
     TaxiPrecacheCallback taxiPrecacheCallback_;
     TaxiOrientationCallback taxiOrientationCallback_;
     TaxiFlightStartCallback taxiFlightStartCallback_;
-    OpenLfgCallback openLfgCallback_;
     uint32_t currentMountDisplayId_ = 0;
     uint32_t mountAuraSpellId_ = 0;       // Spell ID of the aura that caused mounting (for CMSG_CANCEL_AURA fallback)
     float serverRunSpeed_ = 7.0f;
@@ -3187,12 +2121,6 @@ private:
     float serverPitchRate_ = 3.14159f;
     bool playerDead_ = false;
     bool releasedSpirit_ = false;
-    uint32_t corpseMapId_ = 0;
-    float corpseX_ = 0.0f, corpseY_ = 0.0f, corpseZ_ = 0.0f;
-    uint64_t corpseGuid_ = 0;
-    // Absolute time (ms since epoch) when PvP corpse-reclaim delay expires.
-    // 0 means no active delay (reclaim allowed immediately upon proximity).
-    uint64_t corpseReclaimAvailableMs_ = 0;
     // Death Knight runes (class 6): slots 0-1=Blood, 2-3=Unholy, 4-5=Frost initially
     std::array<RuneSlot, 6> playerRunes_ = [] {
         std::array<RuneSlot, 6> r{};
@@ -3204,18 +2132,7 @@ private:
     uint64_t pendingSpiritHealerGuid_ = 0;
     bool resurrectPending_ = false;
     bool resurrectRequestPending_ = false;
-    bool selfResAvailable_ = false;  // SMSG_PRE_RESURRECT received — Reincarnation/Twisting Nether
-    // ---- Talent wipe confirm dialog ----
-    bool talentWipePending_ = false;
-    uint64_t talentWipeNpcGuid_ = 0;
-    uint32_t talentWipeCost_ = 0;
-    // ---- Pet talent respec confirm dialog ----
-    bool petUnlearnPending_ = false;
-    uint64_t petUnlearnGuid_ = 0;
-    uint32_t petUnlearnCost_ = 0;
-    bool resurrectIsSpiritHealer_ = false;  // true = SMSG_SPIRIT_HEALER_CONFIRM, false = SMSG_RESURRECT_REQUEST
     uint64_t resurrectCasterGuid_ = 0;
-    std::string resurrectCasterName_;
     bool repopPending_ = false;
     uint64_t lastRepopRequestMs_ = 0;
 
@@ -3232,54 +2149,14 @@ private:
         std::array<uint64_t, 19> itemGuids{};
     };
     std::vector<EquipmentSet> equipmentSets_;
-    std::string pendingSaveSetName_;   // Saved between CMSG_EQUIPMENT_SET_SAVE and SMSG_EQUIPMENT_SET_SAVED
-    std::string pendingSaveSetIcon_;
-    std::vector<EquipmentSetInfo> equipmentSetInfo_;  // public-facing copy
 
-    // forcedReactions_ moved to CombatHandler
+    // ---- Forced faction reactions (SMSG_SET_FORCED_REACTIONS) ----
+    std::unordered_map<uint32_t, uint8_t> forcedReactions_;  // factionId -> reaction tier
 
     // ---- Server-triggered audio ----
     PlayMusicCallback playMusicCallback_;
     PlaySoundCallback playSoundCallback_;
     PlayPositionalSoundCallback playPositionalSoundCallback_;
-
-    // ---- UI error frame callback ----
-    UIErrorCallback uiErrorCallback_;
-
-    // ---- Reputation change callback ----
-    RepChangeCallback repChangeCallback_;
-    uint32_t watchedFactionId_ = 0; // auto-set to most recently changed faction
-
-    // ---- PvP honor credit callback ----
-    PvpHonorCallback pvpHonorCallback_;
-
-    // ---- Item loot callback ----
-    ItemLootCallback itemLootCallback_;
-
-    // ---- Loot window callback ----
-    LootWindowCallback lootWindowCallback_;
-
-    // ---- Quest completion callback ----
-    QuestCompleteCallback questCompleteCallback_;
-
-    // ---- GM Ticket state (SMSG_GMTICKET_GETTICKET / SMSG_GMTICKET_SYSTEMSTATUS) ----
-    bool        gmTicketActive_    = false;  ///< True when an open ticket exists on the server
-    std::string gmTicketText_;               ///< Text of the open ticket (from SMSG_GMTICKET_GETTICKET)
-    float       gmTicketWaitHours_ = 0.0f;  ///< Server-estimated wait time in hours
-    bool        gmSupportAvailable_ = true; ///< GM support system online (SMSG_GMTICKET_SYSTEMSTATUS)
-
-    // ---- Battlefield Manager state (WotLK Wintergrasp / outdoor battlefields) ----
-    bool        bfMgrInvitePending_ = false; ///< True when an entry/queue invite is pending acceptance
-    bool        bfMgrActive_        = false; ///< True while the player is inside an outdoor battlefield
-    uint32_t    bfMgrZoneId_        = 0;     ///< Zone ID of the pending/active battlefield
-
-    // ---- WotLK Calendar: pending invite counter ----
-    uint32_t    calendarPendingInvites_ = 0; ///< Unacknowledged calendar invites (SMSG_CALENDAR_SEND_NUM_PENDING)
-
-    // ---- Spell modifiers (SMSG_SET_FLAT_SPELL_MODIFIER / SMSG_SET_PCT_SPELL_MODIFIER) ----
-    // Keyed by (SpellModOp, groupIndex); cleared on logout/character change.
-    std::unordered_map<SpellModKey, int32_t, SpellModKeyHash> spellFlatMods_;
-    std::unordered_map<SpellModKey, int32_t, SpellModKeyHash> spellPctMods_;
 };
 
 } // namespace game
diff --git a/include/game/game_services.hpp b/include/game/game_services.hpp
deleted file mode 100644
index 21a14251..00000000
--- a/include/game/game_services.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-#include <cstdint>
-
-namespace wowee {
-namespace rendering { class Renderer; }
-namespace pipeline { class AssetManager; }
-namespace audio { class AudioCoordinator; }
-namespace game { class ExpansionRegistry; }
-
-namespace game {
-
-// Explicit service dependencies for game handlers.
-// Owned by Application, passed by reference to GameHandler at construction.
-// Replaces hidden Application::getInstance() singleton access.
-struct GameServices {
-    rendering::Renderer* renderer = nullptr;
-    audio::AudioCoordinator* audioCoordinator = nullptr;
-    pipeline::AssetManager* assetManager = nullptr;
-    ExpansionRegistry* expansionRegistry = nullptr;
-    uint32_t gryphonDisplayId = 0;
-    uint32_t wyvernDisplayId = 0;
-};
-
-} // namespace game
-} // namespace wowee
diff --git a/include/game/game_utils.hpp b/include/game/game_utils.hpp
deleted file mode 100644
index e0f0ac74..00000000
--- a/include/game/game_utils.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-
-#include "game/expansion_profile.hpp"
-#include "core/application.hpp"
-
-namespace wowee {
-namespace game {
-
-inline bool isActiveExpansion(const char* expansionId) {
-    auto& app = core::Application::getInstance();
-    auto* registry = app.getExpansionRegistry();
-    if (!registry) return false;
-    auto* profile = registry->getActive();
-    if (!profile) return false;
-    return profile->id == expansionId;
-}
-
-inline bool isClassicLikeExpansion() {
-    return isActiveExpansion("classic") || isActiveExpansion("turtle");
-}
-
-inline bool isPreWotlk() {
-    return isClassicLikeExpansion() || isActiveExpansion("tbc");
-}
-
-// Shared item link formatter used by inventory, quest, spell, and social handlers.
-// Centralised here so quality color table changes propagate everywhere.
-inline std::string buildItemLink(uint32_t itemId, uint32_t quality, const std::string& name) {
-    static const char* kQualHex[] = {
-        "9d9d9d",  // 0 Poor
-        "ffffff",  // 1 Common
-        "1eff00",  // 2 Uncommon
-        "0070dd",  // 3 Rare
-        "a335ee",  // 4 Epic
-        "ff8000",  // 5 Legendary
-        "e6cc80",  // 6 Artifact
-        "e6cc80",  // 7 Heirloom
-    };
-    uint32_t qi = quality < 8 ? quality : 1u;
-    char buf[512];
-    snprintf(buf, sizeof(buf), "|cff%s|Hitem:%u:0:0:0:0:0:0:0:0|h[%s]|h|r",
-             kQualHex[qi], itemId, name.c_str());
-    return buf;
-}
-
-} // namespace game
-} // namespace wowee
diff --git a/include/game/handler_types.hpp b/include/game/handler_types.hpp
deleted file mode 100644
index e76e20fe..00000000
--- a/include/game/handler_types.hpp
+++ /dev/null
@@ -1,282 +0,0 @@
-#pragma once
-/**
- * handler_types.hpp — Shared struct definitions used by GameHandler and domain handlers.
- *
- * These types were previously duplicated across GameHandler, SpellHandler, SocialHandler,
- * ChatHandler, QuestHandler, and InventoryHandler.  Now they live here at namespace scope,
- * and each class provides a `using` alias for backward compatibility
- * (e.g. GameHandler::TalentEntry  ==  game::TalentEntry).
- */
-
-#include <array>
-#include <chrono>
-#include <cstdint>
-#include <string>
-#include <vector>
-
-namespace wowee {
-namespace game {
-
-// ---- Talent DBC data ----
-
-struct TalentEntry {
-    uint32_t talentId = 0;
-    uint32_t tabId = 0;
-    uint8_t row = 0;
-    uint8_t column = 0;
-    uint32_t rankSpells[5] = {};
-    uint32_t prereqTalent[3] = {};
-    uint8_t prereqRank[3] = {};
-    uint8_t maxRank = 0;
-};
-
-struct TalentTabEntry {
-    uint32_t tabId = 0;
-    std::string name;
-    uint32_t classMask = 0;
-    uint8_t orderIndex = 0;
-    std::string backgroundFile;
-};
-
-// ---- Spell / cast state ----
-
-// Spell targeting classification for animation selection.
-// Derived from the spell packet's targetGuid field — NOT the player's UI target.
-//   DIRECTED — spell targets a specific unit (Frostbolt, Heal, Shadow Bolt)
-//   OMNI     — self-cast / no explicit target (Arcane Explosion, buffs)
-//   AREA     — ground-targeted AoE (Blizzard, Rain of Fire, Flamestrike)
-enum class SpellCastType : uint8_t {
-    DIRECTED = 0,  // Has a specific unit target
-    OMNI     = 1,  // Self / no target
-    AREA     = 2,  // Ground-targeted AoE
-};
-
-struct UnitCastState {
-    bool          casting         = false;
-    bool          isChannel       = false;
-    uint32_t      spellId         = 0;
-    float         timeRemaining   = 0.0f;
-    float         timeTotal       = 0.0f;
-    bool          interruptible   = true;
-    SpellCastType castType        = SpellCastType::OMNI;
-};
-
-// ---- Equipment sets (WotLK) ----
-
-struct EquipmentSetInfo {
-    uint64_t setGuid = 0;
-    uint32_t setId = 0;
-    std::string name;
-    std::string iconName;
-};
-
-// ---- Inspection ----
-
-struct InspectArenaTeam {
-    uint32_t    teamId         = 0;
-    uint8_t     type           = 0;
-    uint32_t    weekGames      = 0;
-    uint32_t    weekWins       = 0;
-    uint32_t    seasonGames    = 0;
-    uint32_t    seasonWins     = 0;
-    std::string name;
-    uint32_t    personalRating = 0;
-};
-
-struct InspectResult {
-    uint64_t    guid           = 0;
-    std::string playerName;
-    uint32_t    totalTalents   = 0;
-    uint32_t    unspentTalents = 0;
-    uint8_t     talentGroups   = 0;
-    uint8_t     activeTalentGroup = 0;
-    std::array<uint32_t, 19> itemEntries{};
-    std::array<uint16_t, 19> enchantIds{};
-    std::vector<InspectArenaTeam> arenaTeams;
-};
-
-// ---- Who ----
-
-struct WhoEntry {
-    std::string name;
-    std::string guildName;
-    uint32_t level    = 0;
-    uint32_t classId  = 0;
-    uint32_t raceId   = 0;
-    uint32_t zoneId   = 0;
-};
-
-// ---- Battleground ----
-
-struct BgQueueSlot {
-    uint32_t queueSlot = 0;
-    uint32_t bgTypeId = 0;
-    uint8_t arenaType = 0;
-    uint32_t statusId = 0;
-    uint32_t inviteTimeout = 80;
-    uint32_t avgWaitTimeSec = 0;
-    uint32_t timeInQueueSec = 0;
-    std::chrono::steady_clock::time_point inviteReceivedTime{};
-    std::string bgName;
-};
-
-struct AvailableBgInfo {
-    uint32_t bgTypeId         = 0;
-    bool     isRegistered     = false;
-    bool     isHoliday        = false;
-    uint32_t minLevel         = 0;
-    uint32_t maxLevel         = 0;
-    std::vector<uint32_t> instanceIds;
-};
-
-struct BgPlayerScore {
-    uint64_t    guid            = 0;
-    std::string name;
-    uint8_t     team            = 0;
-    uint32_t    killingBlows    = 0;
-    uint32_t    deaths          = 0;
-    uint32_t    honorableKills  = 0;
-    uint32_t    bonusHonor      = 0;
-    std::vector<std::pair<std::string, uint32_t>> bgStats;
-};
-
-struct ArenaTeamScore {
-    std::string teamName;
-    uint32_t    ratingChange = 0;
-    uint32_t    newRating    = 0;
-};
-
-struct BgScoreboardData {
-    std::vector<BgPlayerScore> players;
-    bool hasWinner = false;
-    uint8_t winner = 0;
-    bool isArena   = false;
-    ArenaTeamScore arenaTeams[2];
-};
-
-struct BgPlayerPosition {
-    uint64_t guid  = 0;
-    float    wowX  = 0.0f;
-    float    wowY  = 0.0f;
-    int      group = 0;
-};
-
-// ---- Guild petition ----
-
-struct PetitionSignature {
-    uint64_t playerGuid = 0;
-    std::string playerName;
-};
-
-struct PetitionInfo {
-    uint64_t petitionGuid = 0;
-    uint64_t ownerGuid = 0;
-    std::string guildName;
-    uint32_t signatureCount = 0;
-    uint32_t signaturesRequired = 9;
-    std::vector<PetitionSignature> signatures;
-    bool showUI = false;
-};
-
-// ---- Ready check ----
-
-struct ReadyCheckResult {
-    std::string name;
-    bool ready = false;
-};
-
-// ---- Chat ----
-
-struct ChatAutoJoin {
-    bool general = true;
-    bool trade = true;
-    bool localDefense = true;
-    bool lfg = true;
-    bool local = true;
-};
-
-// ---- Quest / gossip ----
-
-struct GossipPoi {
-    float    x     = 0.0f;
-    float    y     = 0.0f;
-    uint32_t icon  = 0;
-    uint32_t data  = 0;
-    std::string name;
-};
-
-// ---- Instance lockouts ----
-
-struct InstanceLockout {
-    uint32_t mapId       = 0;
-    uint32_t difficulty  = 0;
-    uint64_t resetTime   = 0;
-    bool     locked      = false;
-    bool     extended    = false;
-};
-
-// ---- LFG ----
-
-enum class LfgState : uint8_t {
-    None           = 0,
-    RoleCheck      = 1,
-    Queued         = 2,
-    Proposal       = 3,
-    Boot           = 4,
-    InDungeon      = 5,
-    FinishedDungeon= 6,
-    RaidBrowser    = 7,
-};
-
-// ---- Arena teams ----
-
-struct ArenaTeamStats {
-    uint32_t teamId       = 0;
-    uint32_t rating       = 0;
-    uint32_t weekGames    = 0;
-    uint32_t weekWins     = 0;
-    uint32_t seasonGames  = 0;
-    uint32_t seasonWins   = 0;
-    uint32_t rank         = 0;
-    std::string teamName;
-    uint32_t teamType     = 0;
-};
-
-struct ArenaTeamMember {
-    uint64_t    guid            = 0;
-    std::string name;
-    bool        online          = false;
-    uint32_t    weekGames       = 0;
-    uint32_t    weekWins        = 0;
-    uint32_t    seasonGames     = 0;
-    uint32_t    seasonWins      = 0;
-    uint32_t    personalRating  = 0;
-};
-
-struct ArenaTeamRoster {
-    uint32_t teamId = 0;
-    std::vector<ArenaTeamMember> members;
-};
-
-// ---- Group loot roll ----
-
-struct LootRollEntry {
-    uint64_t objectGuid    = 0;
-    uint32_t slot          = 0;
-    uint32_t itemId        = 0;
-    std::string itemName;
-    uint8_t  itemQuality   = 0;
-    uint32_t rollCountdownMs = 60000;
-    uint8_t  voteMask      = 0xFF;
-    std::chrono::steady_clock::time_point rollStartedAt{};
-
-    struct PlayerRollResult {
-        std::string playerName;
-        uint8_t rollNum  = 0;
-        uint8_t rollType = 0;
-    };
-    std::vector<PlayerRollResult> playerRolls;
-};
-
-} // namespace game
-} // namespace wowee
diff --git a/include/game/inventory.hpp b/include/game/inventory.hpp
index 4a7a9fa1..b25d5234 100644
--- a/include/game/inventory.hpp
+++ b/include/game/inventory.hpp
@@ -3,7 +3,6 @@
 #include <cstdint>
 #include <string>
 #include <array>
-#include <vector>
 
 namespace wowee {
 namespace game {
@@ -15,8 +14,6 @@ enum class ItemQuality : uint8_t {
     RARE = 3,       // Blue
     EPIC = 4,       // Purple
     LEGENDARY = 5,  // Orange
-    ARTIFACT = 6,   // Yellow (unused in 3.3.5a but valid quality value)
-    HEIRLOOM = 7,   // Yellow/gold (WotLK bind-on-account heirlooms)
 };
 
 enum class EquipSlot : uint8_t {
@@ -28,38 +25,6 @@ enum class EquipSlot : uint8_t {
     NUM_SLOTS  // = 23
 };
 
-// WoW InventoryType field values (from ItemDisplayInfo / Item.dbc / CMSG_ITEM_QUERY)
-// Used in ItemDef::inventoryType and equipment update packets.
-namespace InvType {
-    constexpr uint8_t NON_EQUIP     = 0;   // Not equippable / unarmed
-    constexpr uint8_t HEAD          = 1;
-    constexpr uint8_t NECK          = 2;
-    constexpr uint8_t SHOULDERS     = 3;
-    constexpr uint8_t SHIRT         = 4;
-    constexpr uint8_t CHEST         = 5;   // Chest armor
-    constexpr uint8_t WAIST         = 6;
-    constexpr uint8_t LEGS          = 7;
-    constexpr uint8_t FEET          = 8;
-    constexpr uint8_t WRISTS        = 9;
-    constexpr uint8_t HANDS         = 10;
-    constexpr uint8_t FINGER        = 11;  // Ring
-    constexpr uint8_t TRINKET       = 12;
-    constexpr uint8_t ONE_HAND      = 13;  // One-handed weapon (sword, mace, dagger, fist)
-    constexpr uint8_t SHIELD        = 14;
-    constexpr uint8_t RANGED_BOW    = 15;  // Bow
-    constexpr uint8_t BACK          = 16;  // Cloak
-    constexpr uint8_t TWO_HAND      = 17;  // Two-handed weapon (also polearm/staff by inventoryType alone)
-    constexpr uint8_t BAG           = 18;
-    constexpr uint8_t TABARD        = 19;
-    constexpr uint8_t ROBE          = 20;  // Chest (robe variant)
-    constexpr uint8_t MAIN_HAND     = 21;  // Main-hand only weapon
-    constexpr uint8_t OFF_HAND      = 22;  // Off-hand (held-in-off-hand items, not weapons)
-    constexpr uint8_t HOLDABLE      = 23;  // Off-hand holdable (books, orbs)
-    constexpr uint8_t AMMO          = 24;
-    constexpr uint8_t THROWN        = 25;
-    constexpr uint8_t RANGED_GUN    = 26;  // Gun / Crossbow / Wand
-} // namespace InvType
-
 struct ItemDef {
     uint32_t itemId = 0;
     std::string name;
@@ -81,16 +46,6 @@ struct ItemDef {
     int32_t spirit = 0;
     uint32_t displayInfoId = 0;
     uint32_t sellPrice = 0;
-    uint32_t curDurability = 0;
-    uint32_t maxDurability = 0;
-    uint32_t itemLevel = 0;
-    uint32_t requiredLevel = 0;
-    uint32_t bindType = 0;      // 0=none, 1=BoP, 2=BoE, 3=BoU, 4=BoQ
-    std::string description;    // Flavor/lore text shown in tooltip (italic yellow)
-    // Generic stat pairs for non-primary stats (hit, crit, haste, AP, SP, etc.)
-    struct ExtraStat { uint32_t statType = 0; int32_t statValue = 0; };
-    std::vector<ExtraStat> extraStats;
-    uint32_t startQuestId = 0;  // Non-zero: item begins a quest
 };
 
 struct ItemSlot {
@@ -101,13 +56,7 @@ struct ItemSlot {
 class Inventory {
 public:
     static constexpr int BACKPACK_SLOTS = 16;
-    static constexpr int KEYRING_SLOTS = 32;
-    // WoW slot layout: 0-22 are equipment (head, neck, ... tabard, mainhand, offhand, ranged, ammo).
-    // Backpack inventory starts at slot 23 in bag 0xFF, so packet slot = NUM_EQUIP_SLOTS + backpackIndex.
     static constexpr int NUM_EQUIP_SLOTS = 23;
-    // Bag containers occupy equipment slots 19-22 (bag1, bag2, bag3, bag4).
-    // Packet bag byte = FIRST_BAG_EQUIP_SLOT + bagIndex.
-    static constexpr int FIRST_BAG_EQUIP_SLOT = 19;
     static constexpr int NUM_BAG_SLOTS = 4;
     static constexpr int MAX_BAG_SIZE = 36;
     static constexpr int BANK_SLOTS = 28;
@@ -126,12 +75,6 @@ public:
     bool setEquipSlot(EquipSlot slot, const ItemDef& item);
     bool clearEquipSlot(EquipSlot slot);
 
-    // Keyring
-    const ItemSlot& getKeyringSlot(int index) const;
-    bool setKeyringSlot(int index, const ItemDef& item);
-    bool clearKeyringSlot(int index);
-    int getKeyringSize() const { return KEYRING_SLOTS; }
-
     // Extra bags
     int getBagSize(int bagIndex) const;
     void setBagSize(int bagIndex, int size);
@@ -162,28 +105,11 @@ public:
     int findFreeBackpackSlot() const;
     bool addItem(const ItemDef& item);
 
-    // Sort all bag slots (backpack + equip bags) by quality desc → itemId asc → stackCount desc.
-    // Purely client-side: reorders the local inventory struct without server interaction.
-    void sortBags();
-
-    // A single swap operation using WoW bag/slot addressing (for CMSG_SWAP_ITEM).
-    struct SwapOp {
-        uint8_t srcBag;
-        uint8_t srcSlot;
-        uint8_t dstBag;
-        uint8_t dstSlot;
-    };
-
-    // Compute the CMSG_SWAP_ITEM operations needed to reach sorted order.
-    // Does NOT modify the inventory — caller is responsible for sending packets.
-    std::vector<SwapOp> computeSortSwaps() const;
-
     // Test data
     void populateTestItems();
 
 private:
     std::array<ItemSlot, BACKPACK_SLOTS> backpack{};
-    std::array<ItemSlot, KEYRING_SLOTS> keyring_{};
     std::array<ItemSlot, NUM_EQUIP_SLOTS> equipment{};
 
     struct BagData {
diff --git a/include/game/inventory_handler.hpp b/include/game/inventory_handler.hpp
deleted file mode 100644
index ea64df0d..00000000
--- a/include/game/inventory_handler.hpp
+++ /dev/null
@@ -1,414 +0,0 @@
-#pragma once
-
-#include "game/world_packets.hpp"
-#include "game/opcode_table.hpp"
-#include "game/inventory.hpp"
-#include "game/handler_types.hpp"
-#include "network/packet.hpp"
-#include <array>
-#include <chrono>
-#include <deque>
-#include <functional>
-#include <map>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-namespace wowee {
-namespace game {
-
-class GameHandler;
-
-class InventoryHandler {
-public:
-    using PacketHandler = std::function<void(network::Packet&)>;
-    using DispatchTable = std::unordered_map<LogicalOpcode, PacketHandler>;
-
-    explicit InventoryHandler(GameHandler& owner);
-
-    void registerOpcodes(DispatchTable& table);
-
-    // ---- Item text (books / readable items) ----
-    bool isItemTextOpen() const { return itemTextOpen_; }
-    const std::string& getItemText() const { return itemText_; }
-    void closeItemText() { itemTextOpen_ = false; }
-    void queryItemText(uint64_t itemGuid);
-
-    // ---- Trade ----
-    enum class TradeStatus : uint8_t {
-        None = 0, PendingIncoming, Open, Accepted, Complete
-    };
-
-    static constexpr int TRADE_SLOT_COUNT = 6;
-
-    struct TradeSlot {
-        uint32_t itemId      = 0;
-        uint32_t displayId   = 0;
-        uint32_t stackCount  = 0;
-        uint64_t itemGuid    = 0;
-    };
-
-    TradeStatus getTradeStatus() const { return tradeStatus_; }
-    bool hasPendingTradeRequest() const { return tradeStatus_ == TradeStatus::PendingIncoming; }
-    bool isTradeOpen() const { return tradeStatus_ == TradeStatus::Open || tradeStatus_ == TradeStatus::Accepted; }
-    const std::string& getTradePeerName() const { return tradePeerName_; }
-    const std::array<TradeSlot, TRADE_SLOT_COUNT>& getMyTradeSlots() const { return myTradeSlots_; }
-    const std::array<TradeSlot, TRADE_SLOT_COUNT>& getPeerTradeSlots() const { return peerTradeSlots_; }
-    uint64_t getMyTradeGold() const { return myTradeGold_; }
-    uint64_t getPeerTradeGold() const { return peerTradeGold_; }
-    void acceptTradeRequest();
-    void declineTradeRequest();
-    void acceptTrade();
-    void cancelTrade();
-    void setTradeItem(uint8_t tradeSlot, uint8_t srcBag, uint8_t srcSlot);
-    void clearTradeItem(uint8_t tradeSlot);
-    void setTradeGold(uint64_t amount);
-
-    // ---- Loot ----
-    void lootTarget(uint64_t targetGuid);
-    void lootItem(uint8_t slotIndex);
-    void closeLoot();
-    bool isLootWindowOpen() const { return lootWindowOpen_; }
-    const LootResponseData& getCurrentLoot() const { return currentLoot_; }
-    void setAutoLoot(bool enabled) { autoLoot_ = enabled; }
-    bool isAutoLoot() const { return autoLoot_; }
-    void setAutoSellGrey(bool enabled) { autoSellGrey_ = enabled; }
-    bool isAutoSellGrey() const { return autoSellGrey_; }
-    void setAutoRepair(bool enabled) { autoRepair_ = enabled; }
-    bool isAutoRepair() const { return autoRepair_; }
-
-    // Master loot candidates (from SMSG_LOOT_MASTER_LIST)
-    const std::vector<uint64_t>& getMasterLootCandidates() const { return masterLootCandidates_; }
-    bool hasMasterLootCandidates() const { return !masterLootCandidates_.empty(); }
-    void lootMasterGive(uint8_t lootSlot, uint64_t targetGuid);
-
-    // Group loot roll (aliased from handler_types.hpp)
-    using LootRollEntry = game::LootRollEntry;
-    bool hasPendingLootRoll() const { return pendingLootRollActive_; }
-    const LootRollEntry& getPendingLootRoll() const { return pendingLootRoll_; }
-    void sendLootRoll(uint64_t objectGuid, uint32_t slot, uint8_t rollType);
-
-    // ---- Equipment Sets (aliased from handler_types.hpp) ----
-    using EquipmentSetInfo = game::EquipmentSetInfo;
-    const std::vector<EquipmentSetInfo>& getEquipmentSets() const { return equipmentSetInfo_; }
-    bool supportsEquipmentSets() const;
-    void useEquipmentSet(uint32_t setId);
-    void saveEquipmentSet(const std::string& name, const std::string& iconName = "INV_Misc_QuestionMark",
-                          uint64_t existingGuid = 0, uint32_t setIndex = 0xFFFFFFFF);
-    void deleteEquipmentSet(uint64_t setGuid);
-
-    // ---- Vendor ----
-    struct BuybackItem {
-        uint64_t itemGuid = 0;
-        ItemDef item;
-        uint32_t count = 1;
-    };
-    void openVendor(uint64_t npcGuid);
-    void closeVendor();
-    void buyItem(uint64_t vendorGuid, uint32_t itemId, uint32_t slot, uint32_t count);
-    void sellItem(uint64_t vendorGuid, uint64_t itemGuid, uint32_t count);
-    void sellItemBySlot(int backpackIndex);
-    void sellItemInBag(int bagIndex, int slotIndex);
-    void buyBackItem(uint32_t buybackSlot);
-    void repairItem(uint64_t vendorGuid, uint64_t itemGuid);
-    void repairAll(uint64_t vendorGuid, bool useGuildBank = false);
-    uint32_t estimateRepairAllCost() const;
-    const std::deque<BuybackItem>& getBuybackItems() const { return buybackItems_; }
-    void autoEquipItemBySlot(int backpackIndex);
-    void autoEquipItemInBag(int bagIndex, int slotIndex);
-    void useItemBySlot(int backpackIndex);
-    void useItemInBag(int bagIndex, int slotIndex);
-    void openItemBySlot(int backpackIndex);
-    void openItemInBag(int bagIndex, int slotIndex);
-    void destroyItem(uint8_t bag, uint8_t slot, uint8_t count = 1);
-    void splitItem(uint8_t srcBag, uint8_t srcSlot, uint8_t count);
-    void swapContainerItems(uint8_t srcBag, uint8_t srcSlot, uint8_t dstBag, uint8_t dstSlot);
-    void swapBagSlots(int srcBagIndex, int dstBagIndex);
-    void unequipToBackpack(EquipSlot equipSlot);
-    void useItemById(uint32_t itemId);
-    bool isVendorWindowOpen() const { return vendorWindowOpen_; }
-    const ListInventoryData& getVendorItems() const { return currentVendorItems_; }
-    void setVendorCanRepair(bool v) { currentVendorItems_.canRepair = v; }
-    uint64_t getVendorGuid() const { return currentVendorItems_.vendorGuid; }
-
-    // ---- Mail ----
-    static constexpr int MAIL_MAX_ATTACHMENTS = 12;
-    struct MailAttachSlot {
-        uint64_t itemGuid = 0;
-        game::ItemDef item;
-        uint8_t srcBag = 0xFF;
-        uint8_t srcSlot = 0;
-        bool occupied() const { return itemGuid != 0; }
-    };
-    bool isMailboxOpen() const { return mailboxOpen_; }
-    const std::vector<MailMessage>& getMailInbox() const { return mailInbox_; }
-    int getSelectedMailIndex() const { return selectedMailIndex_; }
-    void setSelectedMailIndex(int idx) { selectedMailIndex_ = idx; }
-    bool isMailComposeOpen() const { return showMailCompose_; }
-    void openMailCompose() { showMailCompose_ = true; clearMailAttachments(); }
-    void closeMailCompose() { showMailCompose_ = false; clearMailAttachments(); }
-    bool hasNewMail() const { return hasNewMail_; }
-    void openMailbox(uint64_t guid);
-    void closeMailbox();
-    void sendMail(const std::string& recipient, const std::string& subject,
-                  const std::string& body, uint64_t money, uint64_t cod = 0);
-    bool attachItemFromBackpack(int backpackIndex);
-    bool attachItemFromBag(int bagIndex, int slotIndex);
-    bool detachMailAttachment(int attachIndex);
-    void clearMailAttachments();
-    const std::array<MailAttachSlot, 12>& getMailAttachments() const { return mailAttachments_; }
-    int getMailAttachmentCount() const;
-    void mailTakeMoney(uint32_t mailId);
-    void mailTakeItem(uint32_t mailId, uint32_t itemGuidLow);
-    void mailDelete(uint32_t mailId);
-    void mailMarkAsRead(uint32_t mailId);
-    void refreshMailList();
-
-    // ---- Bank ----
-    void openBank(uint64_t guid);
-    void closeBank();
-    void buyBankSlot();
-    void depositItem(uint8_t srcBag, uint8_t srcSlot);
-    void withdrawItem(uint8_t srcBag, uint8_t srcSlot);
-    bool isBankOpen() const { return bankOpen_; }
-    uint64_t getBankerGuid() const { return bankerGuid_; }
-    int getEffectiveBankSlots() const { return effectiveBankSlots_; }
-    int getEffectiveBankBagSlots() const { return effectiveBankBagSlots_; }
-
-    // ---- Guild Bank ----
-    void openGuildBank(uint64_t guid);
-    void closeGuildBank();
-    void queryGuildBankTab(uint8_t tabId);
-    void buyGuildBankTab();
-    void depositGuildBankMoney(uint32_t amount);
-    void withdrawGuildBankMoney(uint32_t amount);
-    void guildBankWithdrawItem(uint8_t tabId, uint8_t bankSlot, uint8_t destBag, uint8_t destSlot);
-    void guildBankDepositItem(uint8_t tabId, uint8_t bankSlot, uint8_t srcBag, uint8_t srcSlot);
-    bool isGuildBankOpen() const { return guildBankOpen_; }
-    const GuildBankData& getGuildBankData() const { return guildBankData_; }
-    uint8_t getGuildBankActiveTab() const { return guildBankActiveTab_; }
-    void setGuildBankActiveTab(uint8_t tab) { guildBankActiveTab_ = tab; }
-
-    // ---- Auction House ----
-    void openAuctionHouse(uint64_t guid);
-    void closeAuctionHouse();
-    void auctionSearch(const std::string& name, uint8_t levelMin, uint8_t levelMax,
-                       uint32_t quality, uint32_t itemClass, uint32_t itemSubClass,
-                       uint32_t invTypeMask, uint8_t usableOnly, uint32_t offset = 0);
-    void auctionSellItem(int backpackIndex, uint32_t bid,
-                         uint32_t buyout, uint32_t duration);
-    void auctionPlaceBid(uint32_t auctionId, uint32_t amount);
-    void auctionBuyout(uint32_t auctionId, uint32_t buyoutPrice);
-    void auctionCancelItem(uint32_t auctionId);
-    void auctionListOwnerItems(uint32_t offset = 0);
-    void auctionListBidderItems(uint32_t offset = 0);
-    bool isAuctionHouseOpen() const { return auctionOpen_; }
-    uint64_t getAuctioneerGuid() const { return auctioneerGuid_; }
-    const AuctionListResult& getAuctionBrowseResults() const { return auctionBrowseResults_; }
-    const AuctionListResult& getAuctionOwnerResults() const { return auctionOwnerResults_; }
-    const AuctionListResult& getAuctionBidderResults() const { return auctionBidderResults_; }
-    int getAuctionActiveTab() const { return auctionActiveTab_; }
-    void setAuctionActiveTab(int tab) { auctionActiveTab_ = tab; }
-    float getAuctionSearchDelay() const { return auctionSearchDelayTimer_; }
-
-    // ---- Trainer ----
-    struct TrainerTab {
-        std::string name;
-        std::vector<const TrainerSpell*> spells;
-    };
-    bool isTrainerWindowOpen() const { return trainerWindowOpen_; }
-    const TrainerListData& getTrainerSpells() const { return currentTrainerList_; }
-    void trainSpell(uint32_t spellId);
-    void closeTrainer();
-    const std::vector<TrainerTab>& getTrainerTabs() const { return trainerTabs_; }
-    void resetTradeState();
-
-    // ---- Methods moved from GameHandler ----
-    void initiateTrade(uint64_t targetGuid);
-    uint32_t getTempEnchantRemainingMs(uint32_t slot) const;
-    void addMoneyCopper(uint32_t amount);
-
-    // ---- Inventory field / rebuild methods (moved from GameHandler) ----
-    void queryItemInfo(uint32_t entry, uint64_t guid);
-    uint64_t resolveOnlineItemGuid(uint32_t itemId) const;
-    void detectInventorySlotBases(const std::map<uint16_t, uint32_t>& fields);
-    bool applyInventoryFields(const std::map<uint16_t, uint32_t>& fields);
-    void extractContainerFields(uint64_t containerGuid, const std::map<uint16_t, uint32_t>& fields);
-    ItemDef buildItemDef(uint32_t entry, uint32_t stackCount, uint32_t curDur, uint32_t maxDur, uint64_t guid);
-    void rebuildOnlineInventory();
-    void maybeDetectVisibleItemLayout();
-    void updateOtherPlayerVisibleItems(uint64_t guid, const std::map<uint16_t, uint32_t>& fields);
-    void emitOtherPlayerEquipment(uint64_t guid);
-    void emitAllOtherPlayerEquipment();
-    void handleItemQueryResponse(network::Packet& packet);
-
-private:
-    // --- Packet handlers ---
-    void handleLootResponse(network::Packet& packet);
-    void handleLootReleaseResponse(network::Packet& packet);
-    void handleLootRemoved(network::Packet& packet);
-    void handleListInventory(network::Packet& packet);
-    void handleTrainerList(network::Packet& packet);
-    void handleItemTextQueryResponse(network::Packet& packet);
-    void handleTradeStatus(network::Packet& packet);
-    void handleTradeStatusExtended(network::Packet& packet);
-    void handleLootRoll(network::Packet& packet);
-    void handleLootRollWon(network::Packet& packet);
-    void handleShowBank(network::Packet& packet);
-    void handleBuyBankSlotResult(network::Packet& packet);
-    void handleGuildBankList(network::Packet& packet);
-    void handleAuctionHello(network::Packet& packet);
-    void handleAuctionListResult(network::Packet& packet);
-    void handleAuctionOwnerListResult(network::Packet& packet);
-    void handleAuctionBidderListResult(network::Packet& packet);
-    void handleAuctionCommandResult(network::Packet& packet);
-    void handleShowMailbox(network::Packet& packet);
-    void handleMailListResult(network::Packet& packet);
-    void handleSendMailResult(network::Packet& packet);
-    void handleReceivedMail(network::Packet& packet);
-    void handleQueryNextMailTime(network::Packet& packet);
-    void handleEquipmentSetList(network::Packet& packet);
-
-    void categorizeTrainerSpells();
-    void handleTrainerBuySucceeded(network::Packet& packet);
-    void handleTrainerBuyFailed(network::Packet& packet);
-
-    GameHandler& owner_;
-
-    // ---- Item text state ----
-    bool        itemTextOpen_   = false;
-    std::string itemText_;
-
-    // ---- Trade state ----
-    TradeStatus tradeStatus_  = TradeStatus::None;
-    uint64_t    tradePeerGuid_= 0;
-    std::string tradePeerName_;
-    std::array<TradeSlot, TRADE_SLOT_COUNT> myTradeSlots_{};
-    std::array<TradeSlot, TRADE_SLOT_COUNT> peerTradeSlots_{};
-    uint64_t myTradeGold_   = 0;
-    uint64_t peerTradeGold_ = 0;
-
-    // ---- Loot state ----
-    bool lootWindowOpen_ = false;
-    bool autoLoot_ = false;
-    bool autoSellGrey_ = false;
-    bool autoRepair_ = false;
-    LootResponseData currentLoot_;
-    std::vector<uint64_t> masterLootCandidates_;
-
-    // Group loot roll state
-    bool          pendingLootRollActive_ = false;
-    LootRollEntry pendingLootRoll_;
-    struct LocalLootState {
-        LootResponseData data;
-        bool moneyTaken = false;
-        bool itemAutoLootSent = false;
-    };
-    std::unordered_map<uint64_t, LocalLootState> localLootState_;
-    struct PendingLootRetry {
-        uint64_t guid = 0;
-        float timer = 0.0f;
-        uint8_t remainingRetries = 0;
-        bool sendLoot = false;
-    };
-    std::vector<PendingLootRetry> pendingGameObjectLootRetries_;
-    struct PendingLootOpen {
-        uint64_t guid = 0;
-        float timer = 0.0f;
-    };
-    std::vector<PendingLootOpen> pendingGameObjectLootOpens_;
-    uint64_t lastInteractedGoGuid_ = 0;
-    uint64_t pendingLootMoneyGuid_ = 0;
-    uint32_t pendingLootMoneyAmount_ = 0;
-    float pendingLootMoneyNotifyTimer_ = 0.0f;
-    std::unordered_map<uint64_t, float> recentLootMoneyAnnounceCooldowns_;
-
-    // ---- Vendor state ----
-    bool vendorWindowOpen_ = false;
-    ListInventoryData currentVendorItems_;
-    std::deque<BuybackItem> buybackItems_;
-    std::unordered_map<uint64_t, BuybackItem> pendingSellToBuyback_;
-    int pendingBuybackSlot_ = -1;
-    uint32_t pendingBuybackWireSlot_ = 0;
-    uint32_t pendingBuyItemId_ = 0;
-    uint32_t pendingBuyItemSlot_ = 0;
-
-    // ---- Mail state ----
-    bool mailboxOpen_ = false;
-    uint64_t mailboxGuid_ = 0;
-    std::vector<MailMessage> mailInbox_;
-    int selectedMailIndex_ = -1;
-    bool showMailCompose_ = false;
-    bool hasNewMail_ = false;
-    std::array<MailAttachSlot, MAIL_MAX_ATTACHMENTS> mailAttachments_{};
-
-    // ---- Bank state ----
-    bool bankOpen_ = false;
-    uint64_t bankerGuid_ = 0;
-    std::array<uint64_t, 28> bankSlotGuids_{};
-    std::array<uint64_t, 7> bankBagSlotGuids_{};
-    int effectiveBankSlots_ = 28;
-    int effectiveBankBagSlots_ = 7;
-
-    // ---- Guild Bank state ----
-    bool guildBankOpen_ = false;
-    uint64_t guildBankerGuid_ = 0;
-    GuildBankData guildBankData_;
-    uint8_t guildBankActiveTab_ = 0;
-
-    // ---- Auction House state ----
-    bool auctionOpen_ = false;
-    uint64_t auctioneerGuid_ = 0;
-    uint32_t auctionHouseId_ = 0;
-    AuctionListResult auctionBrowseResults_;
-    AuctionListResult auctionOwnerResults_;
-    AuctionListResult auctionBidderResults_;
-    int auctionActiveTab_ = 0;
-    float auctionSearchDelayTimer_ = 0.0f;
-    struct AuctionSearchParams {
-        std::string name;
-        uint8_t levelMin = 0, levelMax = 0;
-        uint32_t quality = 0xFFFFFFFF;
-        uint32_t itemClass = 0xFFFFFFFF;
-        uint32_t itemSubClass = 0xFFFFFFFF;
-        uint32_t invTypeMask = 0;
-        uint8_t usableOnly = 0;
-        uint32_t offset = 0;
-    };
-    AuctionSearchParams lastAuctionSearch_;
-    bool hasAuctionSearch_ = false;  // true after any search (including empty-name browse-all)
-    enum class AuctionResultTarget { BROWSE, OWNER, BIDDER };
-    AuctionResultTarget pendingAuctionTarget_ = AuctionResultTarget::BROWSE;
-
-    // ---- Trainer state ----
-    bool trainerWindowOpen_ = false;
-    TrainerListData currentTrainerList_;
-    std::vector<TrainerTab> trainerTabs_;
-
-    // ---- Equipment set state ----
-    struct EquipmentSet {
-        uint64_t setGuid = 0;
-        uint32_t setId = 0;
-        std::string name;
-        std::string iconName;
-        uint32_t ignoreSlotMask = 0;
-        std::array<uint64_t, 19> itemGuids{};
-    };
-    std::vector<EquipmentSet> equipmentSets_;
-    std::string pendingSaveSetName_;
-    std::string pendingSaveSetIcon_;
-    std::vector<EquipmentSetInfo> equipmentSetInfo_;
-
-    // ---- Repair cost DBC cache ----
-    mutable bool repairDbcLoaded_ = false;
-    // DurabilityCosts.dbc: [itemLevel] -> multiplier[29] (weapon subclass 0-20, armor subclass+21)
-    mutable std::unordered_map<uint32_t, std::array<uint32_t, 29>> durabilityCosts_;
-    // DurabilityQuality.dbc: [id] -> quality_mod float
-    mutable std::unordered_map<uint32_t, float> durabilityQuality_;
-    void loadRepairDbc() const;
-    uint32_t estimateItemRepairCost(uint64_t itemGuid) const;
-};
-
-} // namespace game
-} // namespace wowee
diff --git a/include/game/movement_handler.hpp b/include/game/movement_handler.hpp
deleted file mode 100644
index 3a4649c2..00000000
--- a/include/game/movement_handler.hpp
+++ /dev/null
@@ -1,277 +0,0 @@
-#pragma once
-
-#include "game/world_packets.hpp"
-#include "game/opcode_table.hpp"
-#include "network/packet.hpp"
-#include <glm/glm.hpp>
-#include <chrono>
-#include <deque>
-#include <functional>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-namespace wowee {
-namespace game {
-
-class GameHandler;
-
-class MovementHandler {
-public:
-    using PacketHandler = std::function<void(network::Packet&)>;
-    using DispatchTable = std::unordered_map<LogicalOpcode, PacketHandler>;
-
-    explicit MovementHandler(GameHandler& owner);
-
-    void registerOpcodes(DispatchTable& table);
-
-    // --- Public API (delegated from GameHandler) ---
-
-    void sendMovement(Opcode opcode);
-    void setPosition(float x, float y, float z);
-    void setOrientation(float orientation);
-    void setMovementPitch(float radians) { movementInfo.pitch = radians; }
-    void dismount();
-
-    // Follow target (moved from GameHandler)
-    void followTarget();
-    void cancelFollow();
-
-    // Area trigger detection
-    void loadAreaTriggerDbc();
-    void checkAreaTriggers();
-
-    // Transport attachment
-    void setTransportAttachment(uint64_t childGuid, ObjectType type, uint64_t transportGuid,
-                                const glm::vec3& localOffset, bool hasLocalOrientation,
-                                float localOrientation);
-    void clearTransportAttachment(uint64_t childGuid);
-    void updateAttachedTransportChildren(float deltaTime);
-
-    // Movement info accessors
-    const MovementInfo& getMovementInfo() const { return movementInfo; }
-    MovementInfo& getMovementInfoMut() { return movementInfo; }
-
-    // Speed accessors
-    float getServerRunSpeed() const { return serverRunSpeed_; }
-    float getServerWalkSpeed() const { return serverWalkSpeed_; }
-    float getServerSwimSpeed() const { return serverSwimSpeed_; }
-    float getServerSwimBackSpeed() const { return serverSwimBackSpeed_; }
-    float getServerFlightSpeed() const { return serverFlightSpeed_; }
-    float getServerFlightBackSpeed() const { return serverFlightBackSpeed_; }
-    float getServerRunBackSpeed() const { return serverRunBackSpeed_; }
-    float getServerTurnRate() const { return serverTurnRate_; }
-
-    // Movement flag queries
-    bool isPlayerRooted() const {
-        return (movementInfo.flags & static_cast<uint32_t>(MovementFlags::ROOT)) != 0;
-    }
-    bool isGravityDisabled() const {
-        return (movementInfo.flags & static_cast<uint32_t>(MovementFlags::LEVITATING)) != 0;
-    }
-    bool isFeatherFalling() const {
-        return (movementInfo.flags & static_cast<uint32_t>(MovementFlags::FEATHER_FALL)) != 0;
-    }
-    bool isWaterWalking() const {
-        return (movementInfo.flags & static_cast<uint32_t>(MovementFlags::WATER_WALK)) != 0;
-    }
-    bool isPlayerFlying() const {
-        const uint32_t flyMask = static_cast<uint32_t>(MovementFlags::CAN_FLY) |
-                                 static_cast<uint32_t>(MovementFlags::FLYING);
-        return (movementInfo.flags & flyMask) == flyMask;
-    }
-    bool isHovering() const {
-        return (movementInfo.flags & static_cast<uint32_t>(MovementFlags::HOVER)) != 0;
-    }
-    bool isSwimming() const {
-        return (movementInfo.flags & static_cast<uint32_t>(MovementFlags::SWIMMING)) != 0;
-    }
-
-    // Taxi / Flight Paths
-    bool isTaxiWindowOpen() const { return taxiWindowOpen_; }
-    void closeTaxi();
-    void activateTaxi(uint32_t destNodeId);
-    bool isOnTaxiFlight() const { return onTaxiFlight_; }
-    bool isTaxiMountActive() const { return taxiMountActive_; }
-    bool isTaxiActivationPending() const { return taxiActivatePending_; }
-    void forceClearTaxiAndMovementState();
-    const std::string& getTaxiDestName() const { return taxiDestName_; }
-    const ShowTaxiNodesData& getTaxiData() const { return currentTaxiData_; }
-    uint32_t getTaxiCurrentNode() const { return currentTaxiData_.nearestNode; }
-
-    struct TaxiNode {
-        uint32_t id = 0;
-        uint32_t mapId = 0;
-        float x = 0, y = 0, z = 0;
-        std::string name;
-        uint32_t mountDisplayIdAlliance = 0;
-        uint32_t mountDisplayIdHorde = 0;
-    };
-    struct TaxiPathEdge {
-        uint32_t pathId = 0;
-        uint32_t fromNode = 0, toNode = 0;
-        uint32_t cost = 0;
-    };
-    struct TaxiPathNode {
-        uint32_t id = 0;
-        uint32_t pathId = 0;
-        uint32_t nodeIndex = 0;
-        uint32_t mapId = 0;
-        float x = 0, y = 0, z = 0;
-    };
-
-    const std::unordered_map<uint32_t, TaxiNode>& getTaxiNodes() const { return taxiNodes_; }
-    // WotLK 3.3.5a TaxiNodes.dbc has 384 entries; the known-taxi bitmask
-    // is 12 × uint32 = 384 bits. Node IDs outside this range are invalid.
-    static constexpr uint32_t kMaxTaxiNodeId = 384;
-    bool isKnownTaxiNode(uint32_t nodeId) const {
-        if (nodeId == 0 || nodeId > kMaxTaxiNodeId) return false;
-        uint32_t idx = nodeId - 1;
-        return (knownTaxiMask_[idx / 32] & (1u << (idx % 32))) != 0;
-    }
-    uint32_t getTaxiCostTo(uint32_t destNodeId) const;
-    bool taxiNpcHasRoutes(uint64_t guid) const {
-        auto it = taxiNpcHasRoutes_.find(guid);
-        return it != taxiNpcHasRoutes_.end() && it->second;
-    }
-
-    void updateClientTaxi(float deltaTime);
-    uint32_t nextMovementTimestampMs();
-    void sanitizeMovementForTaxi();
-
-    // Heartbeat / movement timing (for GameHandler::update())
-    float& timeSinceLastMoveHeartbeatRef() { return timeSinceLastMoveHeartbeat_; }
-    float getMoveHeartbeatInterval() const { return moveHeartbeatInterval_; }
-    bool isServerMovementAllowed() const { return serverMovementAllowed_; }
-    void setServerMovementAllowed(bool v) { serverMovementAllowed_ = v; }
-    uint32_t& monsterMovePacketsThisTickRef() { return monsterMovePacketsThisTick_; }
-    uint32_t& monsterMovePacketsDroppedThisTickRef() { return monsterMovePacketsDroppedThisTick_; }
-
-    // Taxi state references for GameHandler update/processing
-    bool& onTaxiFlightRef() { return onTaxiFlight_; }
-    bool& taxiMountActiveRef() { return taxiMountActive_; }
-    uint32_t& taxiMountDisplayIdRef() { return taxiMountDisplayId_; }
-    bool& taxiActivatePendingRef() { return taxiActivatePending_; }
-    float& taxiActivateTimerRef() { return taxiActivateTimer_; }
-    bool& taxiClientActiveRef() { return taxiClientActive_; }
-    float& taxiLandingCooldownRef() { return taxiLandingCooldown_; }
-    float& taxiStartGraceRef() { return taxiStartGrace_; }
-    bool& taxiRecoverPendingRef() { return taxiRecoverPending_; }
-    uint32_t& taxiRecoverMapIdRef() { return taxiRecoverMapId_; }
-    glm::vec3& taxiRecoverPosRef() { return taxiRecoverPos_; }
-    std::unordered_map<uint64_t, bool>& taxiNpcHasRoutesRef() { return taxiNpcHasRoutes_; }
-    uint32_t* knownTaxiMaskPtr() { return knownTaxiMask_; }
-    bool& taxiMaskInitializedRef() { return taxiMaskInitialized_; }
-    uint64_t& taxiNpcGuidRef() { return taxiNpcGuid_; }
-
-    // Other-player movement timing (for cleanup on despawn etc.)
-    std::unordered_map<uint64_t, uint32_t>& otherPlayerMoveTimeMsRef() { return otherPlayerMoveTimeMs_; }
-    std::unordered_map<uint64_t, float>& otherPlayerSmoothedIntervalMsRef() { return otherPlayerSmoothedIntervalMs_; }
-
-    // Methods also called from GameHandler's registerOpcodeHandlers
-    void handleCompressedMoves(network::Packet& packet);
-    void handleForceMoveFlagChange(network::Packet& packet, const char* name, Opcode ackOpcode, uint32_t flag, bool set);
-    void handleMoveSetCollisionHeight(network::Packet& packet);
-    void applyTaxiMountForCurrentNode();
-
-private:
-    // --- Packet handlers ---
-    void handleMonsterMove(network::Packet& packet);
-    void handleMonsterMoveTransport(network::Packet& packet);
-    void handleOtherPlayerMovement(network::Packet& packet);
-    void handleMoveSetSpeed(network::Packet& packet);
-    void handleForceRunSpeedChange(network::Packet& packet);
-    network::Packet buildForceAck(Opcode ackOpcode, uint32_t counter);
-    void handleForceSpeedChange(network::Packet& packet, const char* name, Opcode ackOpcode, float* speedStorage);
-    void handleForceMoveRootState(network::Packet& packet, bool rooted);
-    void handleMoveKnockBack(network::Packet& packet);
-    void handleTeleportAck(network::Packet& packet);
-    void handleNewWorld(network::Packet& packet);
-    void handleShowTaxiNodes(network::Packet& packet);
-    void handleClientControlUpdate(network::Packet& packet);
-    void handleActivateTaxiReply(network::Packet& packet);
-    void loadTaxiDbc();
-
-    // --- Private helpers ---
-    void buildTaxiCostMap();
-    void startClientTaxiPath(const std::vector<uint32_t>& pathNodes);
-
-    friend class GameHandler;
-
-    GameHandler& owner_;
-
-    // --- Movement state ---
-    // Reference to GameHandler's movementInfo to avoid desync
-    MovementInfo& movementInfo;
-    std::chrono::steady_clock::time_point movementClockStart_ = std::chrono::steady_clock::now();
-    uint32_t lastMovementTimestampMs_ = 0;
-    bool serverMovementAllowed_ = true;
-    uint32_t monsterMovePacketsThisTick_ = 0;
-    uint32_t monsterMovePacketsDroppedThisTick_ = 0;
-
-    // Fall/jump tracking
-    bool isFalling_ = false;
-    uint32_t fallStartMs_ = 0;
-
-    // Heartbeat timing
-    int heartbeatLogCount_ = 0;  // periodic position audit counter
-    float timeSinceLastMoveHeartbeat_ = 0.0f;
-    float moveHeartbeatInterval_ = 0.5f;
-    uint32_t lastHeartbeatSendTimeMs_ = 0;
-    float lastHeartbeatX_ = 0.0f;
-    float lastHeartbeatY_ = 0.0f;
-    float lastHeartbeatZ_ = 0.0f;
-    uint32_t lastHeartbeatFlags_ = 0;
-    uint64_t lastHeartbeatTransportGuid_ = 0;
-    uint32_t lastNonHeartbeatMoveSendTimeMs_ = 0;
-    uint32_t lastFacingSendTimeMs_ = 0;
-    float lastFacingSentOrientation_ = 0.0f;
-
-    // Speed state
-    float serverRunSpeed_ = 7.0f;
-    float serverWalkSpeed_ = 2.5f;
-    float serverRunBackSpeed_ = 4.5f;
-    float serverSwimSpeed_ = 4.722f;
-    float serverSwimBackSpeed_ = 2.5f;
-    float serverFlightSpeed_ = 7.0f;
-    float serverFlightBackSpeed_ = 4.5f;
-    float serverTurnRate_ = 3.14159f;
-    float serverPitchRate_ = 3.14159f;
-
-    // Other-player movement smoothing
-    std::unordered_map<uint64_t, uint32_t> otherPlayerMoveTimeMs_;
-    std::unordered_map<uint64_t, float>    otherPlayerSmoothedIntervalMs_;
-
-    // --- Taxi / Flight Path state ---
-    std::unordered_map<uint64_t, bool> taxiNpcHasRoutes_;
-    std::unordered_map<uint32_t, TaxiNode> taxiNodes_;
-    std::vector<TaxiPathEdge> taxiPathEdges_;
-    std::unordered_map<uint32_t, std::vector<TaxiPathNode>> taxiPathNodes_;
-    bool taxiDbcLoaded_ = false;
-    bool taxiWindowOpen_ = false;
-    ShowTaxiNodesData currentTaxiData_;
-    uint64_t taxiNpcGuid_ = 0;
-    bool onTaxiFlight_ = false;
-    std::string taxiDestName_;
-    bool taxiMountActive_ = false;
-    uint32_t taxiMountDisplayId_ = 0;
-    bool taxiActivatePending_ = false;
-    float taxiActivateTimer_ = 0.0f;
-    bool taxiClientActive_ = false;
-    float taxiLandingCooldown_ = 0.0f;
-    float taxiStartGrace_ = 0.0f;
-    size_t taxiClientIndex_ = 0;
-    std::vector<glm::vec3> taxiClientPath_;
-    float taxiClientSpeed_ = 32.0f;
-    float taxiClientSegmentProgress_ = 0.0f;
-    bool taxiRecoverPending_ = false;
-    uint32_t taxiRecoverMapId_ = 0;
-    glm::vec3 taxiRecoverPos_{0.0f};
-    uint32_t knownTaxiMask_[12] = {};
-    bool taxiMaskInitialized_ = false;
-    std::unordered_map<uint32_t, uint32_t> taxiCostMap_;
-};
-
-} // namespace game
-} // namespace wowee
diff --git a/include/game/opcode_aliases_generated.inc b/include/game/opcode_aliases_generated.inc
index ed20d098..ad488110 100644
--- a/include/game/opcode_aliases_generated.inc
+++ b/include/game/opcode_aliases_generated.inc
@@ -41,4 +41,5 @@
     {"SMSG_SPLINE_MOVE_SET_RUN_BACK_SPEED", "SMSG_SPLINE_SET_RUN_BACK_SPEED"},
     {"SMSG_SPLINE_MOVE_SET_RUN_SPEED", "SMSG_SPLINE_SET_RUN_SPEED"},
     {"SMSG_SPLINE_MOVE_SET_SWIM_SPEED", "SMSG_SPLINE_SET_SWIM_SPEED"},
+    {"SMSG_UPDATE_AURA_DURATION", "SMSG_EQUIPMENT_SET_SAVED"},
     {"SMSG_VICTIMSTATEUPDATE_OBSOLETE", "SMSG_BATTLEFIELD_PORT_DENIED"},
diff --git a/include/game/opcode_table.hpp b/include/game/opcode_table.hpp
index 966542b9..91242206 100644
--- a/include/game/opcode_table.hpp
+++ b/include/game/opcode_table.hpp
@@ -33,10 +33,7 @@ class OpcodeTable {
 public:
     /**
      * Load opcode mappings from a JSON file.
-     * Format:
-     * { "CMSG_PING": "0x1DC", "SMSG_AUTH_CHALLENGE": "0x1EC", ... }
-     * or a delta file with:
-     * { "_extends": "../classic/opcodes.json", "_remove": ["MSG_FOO"], ...overrides }
+     * Format: { "CMSG_PING": "0x1DC", "SMSG_AUTH_CHALLENGE": "0x1EC", ... }
      */
     bool loadFromJson(const std::string& path);
 
@@ -52,14 +49,12 @@ public:
     /** Number of mapped opcodes. */
     size_t size() const { return logicalToWire_.size(); }
 
-    /** Get canonical enum name for a logical opcode. */
-    static const char* logicalToName(LogicalOpcode op);
-
 private:
     std::unordered_map<uint16_t, uint16_t> logicalToWire_;   // LogicalOpcode → wire
     std::unordered_map<uint16_t, uint16_t> wireToLogical_;   // wire → LogicalOpcode
 
     static std::optional<LogicalOpcode> nameToLogical(const std::string& name);
+    static const char* logicalToName(LogicalOpcode op);
 };
 
 /**
diff --git a/include/game/packet_parsers.hpp b/include/game/packet_parsers.hpp
index 8ee0b255..f1466a1d 100644
--- a/include/game/packet_parsers.hpp
+++ b/include/game/packet_parsers.hpp
@@ -26,10 +26,6 @@ public:
     // Classic: none, TBC: u8, WotLK: u16.
     virtual uint8_t movementFlags2Size() const { return 2; }
 
-    // Wire-format movement flag that gates transport data in MSG_MOVE_* payloads.
-    // WotLK/TBC: 0x200, Classic/Turtle: 0x02000000.
-    virtual uint32_t wireOnTransportFlag() const { return 0x00000200; }
-
     // --- Movement ---
 
     /** Parse movement block from SMSG_UPDATE_OBJECT */
@@ -97,11 +93,6 @@ public:
         return SpellDamageLogParser::parse(packet, data);
     }
 
-    /** Parse SMSG_SPELLHEALLOG */
-    virtual bool parseSpellHealLog(network::Packet& packet, SpellHealLogData& data) {
-        return SpellHealLogParser::parse(packet, data);
-    }
-
     // --- Spells ---
 
     /** Parse SMSG_INITIAL_SPELLS */
@@ -109,34 +100,11 @@ public:
         return InitialSpellsParser::parse(packet, data);
     }
 
-    /** Parse SMSG_SPELL_START */
-    virtual bool parseSpellStart(network::Packet& packet, SpellStartData& data) {
-        return SpellStartParser::parse(packet, data);
-    }
-
-    /** Parse SMSG_SPELL_GO */
-    virtual bool parseSpellGo(network::Packet& packet, SpellGoData& data) {
-        return SpellGoParser::parse(packet, data);
-    }
-
     /** Parse SMSG_CAST_FAILED */
     virtual bool parseCastFailed(network::Packet& packet, CastFailedData& data) {
         return CastFailedParser::parse(packet, data);
     }
 
-    /** Parse SMSG_CAST_RESULT header (spellId + result), expansion-aware.
-     *  WotLK: castCount(u8) + spellId(u32) + result(u8)
-     *  TBC/Classic: spellId(u32) + result(u8)  (no castCount prefix)
-     */
-    virtual bool parseCastResult(network::Packet& packet, uint32_t& spellId, uint8_t& result) {
-        // WotLK default: skip castCount, read spellId + result
-        if (packet.getSize() - packet.getReadPos() < 6) return false;
-        packet.readUInt8();  // castCount
-        spellId = packet.readUInt32();
-        result  = packet.readUInt8();
-        return true;
-    }
-
     /** Parse SMSG_AURA_UPDATE / SMSG_AURA_UPDATE_ALL */
     virtual bool parseAuraUpdate(network::Packet& packet, AuraUpdateData& data, bool isAll = false) {
         return AuraUpdateParser::parse(packet, data, isAll);
@@ -154,13 +122,6 @@ public:
         return NameQueryResponseParser::parse(packet, data);
     }
 
-    // --- Creature Query ---
-
-    /** Parse SMSG_CREATURE_QUERY_RESPONSE */
-    virtual bool parseCreatureQueryResponse(network::Packet& packet, CreatureQueryResponseData& data) {
-        return CreatureQueryResponseParser::parse(packet, data);
-    }
-
     // --- Item Query ---
 
     /** Build CMSG_ITEM_QUERY_SINGLE */
@@ -211,11 +172,6 @@ public:
      *  WotLK: 5 fields per slot, Classic/Vanilla: 3. */
     virtual uint8_t questLogStride() const { return 5; }
 
-    /** Number of PLAYER_EXPLORED_ZONES uint32 fields in update-object blocks.
-     *  Classic/Vanilla/Turtle: 64 (bit-packs up to zone ID 2047).
-     *  TBC/WotLK: 128 (covers Outland/Northrend zone IDs up to 4095). */
-    virtual uint8_t exploredZonesCount() const { return 128; }
-
     // --- Quest Giver Status ---
 
     /** Read quest giver status from packet.
@@ -261,7 +217,7 @@ public:
     /** Build CMSG_SEND_MAIL */
     virtual network::Packet buildSendMail(uint64_t mailboxGuid, const std::string& recipient,
                                            const std::string& subject, const std::string& body,
-                                           uint64_t money, uint64_t cod,
+                                           uint32_t money, uint32_t cod,
                                            const std::vector<uint64_t>& itemGuids = {}) {
         return SendMailPacket::build(mailboxGuid, recipient, subject, body, money, cod, itemGuids);
     }
@@ -270,8 +226,8 @@ public:
     virtual bool parseMailList(network::Packet& packet, std::vector<MailMessage>& inbox);
 
     /** Build CMSG_MAIL_TAKE_ITEM */
-    virtual network::Packet buildMailTakeItem(uint64_t mailboxGuid, uint32_t mailId, uint32_t itemGuidLow) {
-        return MailTakeItemPacket::build(mailboxGuid, mailId, itemGuidLow);
+    virtual network::Packet buildMailTakeItem(uint64_t mailboxGuid, uint32_t mailId, uint32_t itemSlot) {
+        return MailTakeItemPacket::build(mailboxGuid, mailId, itemSlot);
     }
 
     /** Build CMSG_MAIL_DELETE */
@@ -283,12 +239,12 @@ public:
 
     /** Read a packed GUID from the packet */
     virtual uint64_t readPackedGuid(network::Packet& packet) {
-        return packet.readPackedGuid();
+        return UpdateObjectParser::readPackedGuid(packet);
     }
 
     /** Write a packed GUID to the packet */
     virtual void writePackedGuid(network::Packet& packet, uint64_t guid) {
-        packet.writePackedGuid(guid);
+        MovementPacket::writePackedGuid(packet, guid);
     }
 };
 
@@ -331,54 +287,6 @@ public:
     bool parseNameQueryResponse(network::Packet& packet, NameQueryResponseData& data) override;
     bool parseItemQueryResponse(network::Packet& packet, ItemQueryResponseData& data) override;
     network::Packet buildAcceptQuestPacket(uint64_t npcGuid, uint32_t questId) override;
-    // TBC 2.4.3 CMSG_CAST_SPELL has no castFlags byte (WotLK added it)
-    network::Packet buildCastSpell(uint32_t spellId, uint64_t targetGuid, uint8_t castCount) override;
-    // TBC 2.4.3 CMSG_USE_ITEM has no glyphIndex field (WotLK added it)
-    network::Packet buildUseItem(uint8_t bagIndex, uint8_t slotIndex, uint64_t itemGuid, uint32_t spellId = 0) override;
-    // TBC 2.4.3 SMSG_MONSTER_MOVE has no unk byte after packed GUID (WotLK added it)
-    bool parseMonsterMove(network::Packet& packet, MonsterMoveData& data) override;
-    // TBC 2.4.3 SMSG_GOSSIP_MESSAGE quests lack questFlags(u32)+isRepeatable(u8) (WotLK added them)
-    bool parseGossipMessage(network::Packet& packet, GossipMessageData& data) override;
-    // TBC 2.4.3 SMSG_CAST_RESULT: spellId(u32) + result(u8) — WotLK added castCount(u8) prefix
-    bool parseCastResult(network::Packet& packet, uint32_t& spellId, uint8_t& result) override;
-    // TBC 2.4.3 SMSG_CAST_FAILED: spellId(u32) + result(u8) — WotLK added castCount(u8) prefix
-    bool parseCastFailed(network::Packet& packet, CastFailedData& data) override;
-    // TBC 2.4.3 SMSG_SPELL_START: full uint64 GUIDs (WotLK uses packed GUIDs)
-    bool parseSpellStart(network::Packet& packet, SpellStartData& data) override;
-    // TBC 2.4.3 SMSG_SPELL_GO: full uint64 GUIDs, no timestamp field (WotLK added one)
-    bool parseSpellGo(network::Packet& packet, SpellGoData& data) override;
-    // TBC 2.4.3 SMSG_MAIL_LIST_RESULT: uint8 count (not uint32+uint8), no body field,
-    // attachment uses uint64 itemGuid (not uint32), enchants are 7×u32 id-only (not 7×{id+dur+charges})
-    bool parseMailList(network::Packet& packet, std::vector<MailMessage>& inbox) override;
-    // TBC 2.4.3 SMSG_ATTACKERSTATEUPDATE uses full uint64 GUIDs (WotLK uses packed GUIDs)
-    bool parseAttackerStateUpdate(network::Packet& packet, AttackerStateUpdateData& data) override;
-    // TBC 2.4.3 SMSG_SPELLNONMELEEDAMAGELOG uses full uint64 GUIDs (WotLK uses packed GUIDs)
-    bool parseSpellDamageLog(network::Packet& packet, SpellDamageLogData& data) override;
-    // TBC 2.4.3 SMSG_SPELLHEALLOG uses full uint64 GUIDs (WotLK uses packed GUIDs)
-    bool parseSpellHealLog(network::Packet& packet, SpellHealLogData& data) override;
-    // TBC 2.4.3 quest log has 4 update fields per slot (questId, state, counts, timer)
-    // WotLK expands this to 5 (splits counts into two fields).
-    uint8_t questLogStride() const override { return 4; }
-    // TBC 2.4.3 CMSG_QUESTGIVER_QUERY_QUEST: guid(8) + questId(4) — no trailing
-    // isDialogContinued byte that WotLK added
-    network::Packet buildQueryQuestPacket(uint64_t npcGuid, uint32_t questId) override;
-    // TBC/Classic SMSG_QUESTGIVER_QUEST_DETAILS lacks informUnit(u64), flags(u32),
-    // isFinished(u8) that WotLK added; uses variable item counts + emote section.
-    bool parseQuestDetails(network::Packet& packet, QuestDetailsData& data) override;
-    // TBC 2.4.3 SMSG_GUILD_ROSTER: same rank structure as WotLK (variable rankCount +
-    // goldLimit + bank tabs), but NO gender byte per member (WotLK added it)
-    bool parseGuildRoster(network::Packet& packet, GuildRosterData& data) override;
-    // TBC 2.4.3 SMSG_QUESTGIVER_STATUS: uint32 status (WotLK uses uint8)
-    uint8_t readQuestGiverStatus(network::Packet& packet) override;
-    // TBC 2.4.3 SMSG_MESSAGECHAT: no senderGuid/unknown prefix before type-specific data
-    bool parseMessageChat(network::Packet& packet, MessageChatData& data) override;
-    // TBC 2.4.3 SMSG_GAMEOBJECT_QUERY_RESPONSE: 2 extra strings after names
-    // (iconName + castBarCaption); WotLK has 3 (adds unk1)
-    bool parseGameObjectQueryResponse(network::Packet& packet, GameObjectQueryResponseData& data) override;
-    // TBC 2.4.3 CMSG_JOIN_CHANNEL: name+password only (WotLK prepends channelId+hasVoice+joinedByZone)
-    network::Packet buildJoinChannel(const std::string& channelName, const std::string& password) override;
-    // TBC 2.4.3 CMSG_LEAVE_CHANNEL: name only (WotLK prepends channelId)
-    network::Packet buildLeaveChannel(const std::string& channelName) override;
 };
 
 /**
@@ -398,7 +306,6 @@ public:
 class ClassicPacketParsers : public TbcPacketParsers {
 public:
     uint8_t movementFlags2Size() const override { return 0; }
-    uint32_t wireOnTransportFlag() const override { return 0x02000000; }
     bool parseCharEnum(network::Packet& packet, CharEnumResponse& response) override;
     bool parseMovementBlock(network::Packet& packet, UpdateBlock& block) override;
     void writeMovementPayload(network::Packet& packet, const MovementInfo& info) override;
@@ -408,11 +315,8 @@ public:
     network::Packet buildCastSpell(uint32_t spellId, uint64_t targetGuid, uint8_t castCount) override;
     network::Packet buildUseItem(uint8_t bagIndex, uint8_t slotIndex, uint64_t itemGuid, uint32_t spellId = 0) override;
     bool parseCastFailed(network::Packet& packet, CastFailedData& data) override;
-    bool parseCastResult(network::Packet& packet, uint32_t& spellId, uint8_t& result) override;
     bool parseMessageChat(network::Packet& packet, MessageChatData& data) override;
     bool parseGameObjectQueryResponse(network::Packet& packet, GameObjectQueryResponseData& data) override;
-    // Classic 1.12 SMSG_CREATURE_QUERY_RESPONSE lacks the iconName string that TBC/WotLK include
-    bool parseCreatureQueryResponse(network::Packet& packet, CreatureQueryResponseData& data) override;
     bool parseGossipMessage(network::Packet& packet, GossipMessageData& data) override;
     bool parseGuildRoster(network::Packet& packet, GuildRosterData& data) override;
     bool parseGuildQueryResponse(network::Packet& packet, GuildQueryResponseData& data) override;
@@ -420,59 +324,36 @@ public:
     network::Packet buildLeaveChannel(const std::string& channelName) override;
     network::Packet buildSendMail(uint64_t mailboxGuid, const std::string& recipient,
                                    const std::string& subject, const std::string& body,
-                                   uint64_t money, uint64_t cod,
+                                   uint32_t money, uint32_t cod,
                                    const std::vector<uint64_t>& itemGuids = {}) override;
     bool parseMailList(network::Packet& packet, std::vector<MailMessage>& inbox) override;
-    network::Packet buildMailTakeItem(uint64_t mailboxGuid, uint32_t mailId, uint32_t itemGuidLow) override;
+    network::Packet buildMailTakeItem(uint64_t mailboxGuid, uint32_t mailId, uint32_t itemSlot) override;
     network::Packet buildMailDelete(uint64_t mailboxGuid, uint32_t mailId, uint32_t mailTemplateId) override;
     network::Packet buildItemQuery(uint32_t entry, uint64_t guid) override;
     bool parseItemQueryResponse(network::Packet& packet, ItemQueryResponseData& data) override;
     uint8_t readQuestGiverStatus(network::Packet& packet) override;
     network::Packet buildQueryQuestPacket(uint64_t npcGuid, uint32_t questId) override;
     network::Packet buildAcceptQuestPacket(uint64_t npcGuid, uint32_t questId) override;
-    // parseQuestDetails inherited from TbcPacketParsers (same format as TBC 2.4.3)
+    bool parseQuestDetails(network::Packet& packet, QuestDetailsData& data) override;
     uint8_t questLogStride() const override { return 3; }
-    // Classic 1.12 has 64 explored-zone uint32 fields (zone IDs fit in 2048 bits).
-    // TBC/WotLK use 128 (needed for Outland/Northrend zone IDs up to 4095).
-    uint8_t exploredZonesCount() const override { return 64; }
     bool parseMonsterMove(network::Packet& packet, MonsterMoveData& data) override {
         return MonsterMoveParser::parseVanilla(packet, data);
     }
-    // Classic 1.12 SMSG_INITIAL_SPELLS: uint16 spellId + uint16 slot per entry (not uint32 + uint16)
-    bool parseInitialSpells(network::Packet& packet, InitialSpellsData& data) override {
-        return InitialSpellsParser::parse(packet, data, /*vanillaFormat=*/true);
-    }
-    // Classic 1.12 uses PackedGuid (not full uint64) and uint16 castFlags (not uint32)
-    bool parseSpellStart(network::Packet& packet, SpellStartData& data) override;
-    bool parseSpellGo(network::Packet& packet, SpellGoData& data) override;
-    // Classic 1.12 melee/spell log packets use PackedGuid (not full uint64)
-    bool parseAttackerStateUpdate(network::Packet& packet, AttackerStateUpdateData& data) override;
-    bool parseSpellDamageLog(network::Packet& packet, SpellDamageLogData& data) override;
-    bool parseSpellHealLog(network::Packet& packet, SpellHealLogData& data) override;
-    // Classic 1.12 has SMSG_AURA_UPDATE (unlike TBC which doesn't);
-    // format differs from WotLK: no caster GUID, DURATION flag is 0x10 not 0x20
-    bool parseAuraUpdate(network::Packet& packet, AuraUpdateData& data, bool isAll = false) override;
-    // Classic 1.12 SMSG_NAME_QUERY_RESPONSE: full uint64 guid + name + realmName CString +
-    // uint32 race + uint32 gender + uint32 class (TBC Variant A skips the realmName CString)
-    bool parseNameQueryResponse(network::Packet& packet, NameQueryResponseData& data) override;
 };
 
 /**
- * Turtle WoW packet parsers.
+ * Turtle WoW (build 7234) packet parsers.
  *
- * Turtle is Classic-based but not wire-identical to vanilla MaNGOS. It keeps
- * most Classic packet formats, while overriding the movement-bearing paths that
- * have proven to vary in live traffic:
- * - update-object movement blocks use a Turtle-specific hybrid layout
- * - update-object parsing falls back through Classic/TBC/WotLK movement layouts
- * - monster-move parsing falls back through Vanilla, TBC, and guarded WotLK layouts
+ * Turtle WoW is a heavily modified vanilla server that sends TBC-style
+ * movement blocks (moveFlags2, transport timestamps, 8 speeds including flight)
+ * while keeping all other Classic packet formats.
  *
- * Everything else inherits the Classic parser behavior.
+ * Inherits all Classic overrides (charEnum, chat, gossip, mail, items, etc.)
+ * but delegates movement block parsing to TBC format.
  */
 class TurtlePacketParsers : public ClassicPacketParsers {
 public:
     uint8_t movementFlags2Size() const override { return 0; }
-    bool parseUpdateObject(network::Packet& packet, UpdateObjectData& data) override;
     bool parseMovementBlock(network::Packet& packet, UpdateBlock& block) override;
     bool parseMonsterMove(network::Packet& packet, MonsterMoveData& data) override;
 };
diff --git a/include/game/quest_handler.hpp b/include/game/quest_handler.hpp
deleted file mode 100644
index 63e0b2d0..00000000
--- a/include/game/quest_handler.hpp
+++ /dev/null
@@ -1,200 +0,0 @@
-#pragma once
-
-#include "game/world_packets.hpp"
-#include "game/opcode_table.hpp"
-#include "game/handler_types.hpp"
-#include "network/packet.hpp"
-#include <array>
-#include <chrono>
-#include <functional>
-#include <map>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-namespace wowee {
-namespace game {
-
-class GameHandler;
-enum class QuestGiverStatus : uint8_t;
-
-class QuestHandler {
-public:
-    using PacketHandler = std::function<void(network::Packet&)>;
-    using DispatchTable = std::unordered_map<LogicalOpcode, PacketHandler>;
-
-    explicit QuestHandler(GameHandler& owner);
-
-    void registerOpcodes(DispatchTable& table);
-
-    // --- Public API (delegated from GameHandler) ---
-
-    // NPC Gossip
-    void selectGossipOption(uint32_t optionId);
-    void selectGossipQuest(uint32_t questId);
-    void acceptQuest();
-    void declineQuest();
-    void closeGossip();
-    void offerQuestFromItem(uint64_t itemGuid, uint32_t questId);
-
-    bool isGossipWindowOpen() const { return gossipWindowOpen_; }
-    const GossipMessageData& getCurrentGossip() const { return currentGossip_; }
-
-    // Quest details
-    bool isQuestDetailsOpen() {
-        if (questDetailsOpen_) return true;
-        if (questDetailsOpenTime_ != std::chrono::steady_clock::time_point{}) {
-            if (std::chrono::steady_clock::now() >= questDetailsOpenTime_) {
-                questDetailsOpen_ = true;
-                questDetailsOpenTime_ = std::chrono::steady_clock::time_point{};
-                return true;
-            }
-        }
-        return false;
-    }
-    const QuestDetailsData& getQuestDetails() const { return currentQuestDetails_; }
-
-    // Gossip / quest map POI markers (aliased from handler_types.hpp)
-    using GossipPoi = game::GossipPoi;
-    const std::vector<GossipPoi>& getGossipPois() const { return gossipPois_; }
-    void clearGossipPois() { gossipPois_.clear(); }
-
-    // Quest turn-in
-    bool isQuestRequestItemsOpen() const { return questRequestItemsOpen_; }
-    const QuestRequestItemsData& getQuestRequestItems() const { return currentQuestRequestItems_; }
-    void completeQuest();
-    void closeQuestRequestItems();
-
-    bool isQuestOfferRewardOpen() const { return questOfferRewardOpen_; }
-    const QuestOfferRewardData& getQuestOfferReward() const { return currentQuestOfferReward_; }
-    void chooseQuestReward(uint32_t rewardIndex);
-    void closeQuestOfferReward();
-
-    // Quest log
-    struct QuestLogEntry {
-        uint32_t questId = 0;
-        std::string title;
-        std::string objectives;
-        bool complete = false;
-        std::unordered_map<uint32_t, std::pair<uint32_t, uint32_t>> killCounts;
-        std::unordered_map<uint32_t, uint32_t> itemCounts;
-        std::unordered_map<uint32_t, uint32_t> requiredItemCounts;
-        struct KillObjective {
-            int32_t npcOrGoId = 0;
-            uint32_t required = 0;
-        };
-        std::array<KillObjective, 4> killObjectives{};
-        struct ItemObjective {
-            uint32_t itemId = 0;
-            uint32_t required = 0;
-        };
-        std::array<ItemObjective, 6> itemObjectives{};
-        int32_t  rewardMoney = 0;
-        std::array<QuestRewardItem, 4> rewardItems{};
-        std::array<QuestRewardItem, 6> rewardChoiceItems{};
-    };
-    const std::vector<QuestLogEntry>& getQuestLog() const { return questLog_; }
-    int getSelectedQuestLogIndex() const { return selectedQuestLogIndex_; }
-    void setSelectedQuestLogIndex(int idx) { selectedQuestLogIndex_ = idx; }
-    void abandonQuest(uint32_t questId);
-    void shareQuestWithParty(uint32_t questId);
-    bool requestQuestQuery(uint32_t questId, bool force = false);
-    bool isQuestTracked(uint32_t questId) const { return trackedQuestIds_.count(questId) > 0; }
-    void setQuestTracked(uint32_t questId, bool tracked);
-    const std::unordered_set<uint32_t>& getTrackedQuestIds() const { return trackedQuestIds_; }
-    bool isQuestQueryPending(uint32_t questId) const {
-        return pendingQuestQueryIds_.count(questId) > 0;
-    }
-    void clearQuestQueryPending(uint32_t questId) { pendingQuestQueryIds_.erase(questId); }
-
-    // Quest giver status (! and ? markers)
-    QuestGiverStatus getQuestGiverStatus(uint64_t guid) const;
-    const std::unordered_map<uint64_t, QuestGiverStatus>& getNpcQuestStatuses() const { return npcQuestStatus_; }
-
-    // Shared quest
-    bool hasPendingSharedQuest() const { return pendingSharedQuest_; }
-    uint32_t getSharedQuestId() const { return sharedQuestId_; }
-    const std::string& getSharedQuestTitle() const { return sharedQuestTitle_; }
-    const std::string& getSharedQuestSharerName() const { return sharedQuestSharerName_; }
-    void acceptSharedQuest();
-    void declineSharedQuest();
-
-    // --- Internal helpers called from GameHandler ---
-    bool hasQuestInLog(uint32_t questId) const;
-    int findQuestLogSlotIndexFromServer(uint32_t questId) const;
-    void addQuestToLocalLogIfMissing(uint32_t questId, const std::string& title, const std::string& objectives);
-    bool resyncQuestLogFromServerSlots(bool forceQueryMetadata);
-    void applyQuestStateFromFields(const std::map<uint16_t, uint32_t>& fields);
-    void applyPackedKillCountsFromFields(QuestLogEntry& quest);
-    void clearPendingQuestAccept(uint32_t questId);
-    void triggerQuestAcceptResync(uint32_t questId, uint64_t npcGuid, const char* reason);
-
-    // Pending quest accept timeout state (used by GameHandler::update)
-    std::unordered_map<uint32_t, float>& pendingQuestAcceptTimeoutsRef() { return pendingQuestAcceptTimeouts_; }
-    std::unordered_map<uint32_t, uint64_t>& pendingQuestAcceptNpcGuidsRef() { return pendingQuestAcceptNpcGuids_; }
-    bool& pendingLoginQuestResyncRef() { return pendingLoginQuestResync_; }
-    float& pendingLoginQuestResyncTimeoutRef() { return pendingLoginQuestResyncTimeout_; }
-
-    // Direct state access for vendor/gossip interaction in GameHandler
-    bool& gossipWindowOpenRef() { return gossipWindowOpen_; }
-    GossipMessageData& currentGossipRef() { return currentGossip_; }
-    std::unordered_map<uint64_t, QuestGiverStatus>& npcQuestStatusRef() { return npcQuestStatus_; }
-
-private:
-    // --- Packet handlers ---
-    void handleGossipMessage(network::Packet& packet);
-    void handleQuestgiverQuestList(network::Packet& packet);
-    void classifyGossipQuests(bool updateQuestLog);
-    void handleGossipComplete(network::Packet& packet);
-    void handleQuestPoiQueryResponse(network::Packet& packet);
-    void handleQuestDetails(network::Packet& packet);
-    void handleQuestRequestItems(network::Packet& packet);
-    void handleQuestOfferReward(network::Packet& packet);
-    void handleQuestConfirmAccept(network::Packet& packet);
-
-    GameHandler& owner_;
-
-    // --- State ---
-    // Gossip
-    bool gossipWindowOpen_ = false;
-    GossipMessageData currentGossip_;
-    std::vector<GossipPoi> gossipPois_;
-
-    // Quest details
-    bool questDetailsOpen_ = false;
-    std::chrono::steady_clock::time_point questDetailsOpenTime_{};
-    QuestDetailsData currentQuestDetails_;
-
-    // Quest turn-in
-    bool questRequestItemsOpen_ = false;
-    QuestRequestItemsData currentQuestRequestItems_;
-    uint32_t pendingTurnInQuestId_ = 0;
-    uint64_t pendingTurnInNpcGuid_ = 0;
-    bool pendingTurnInRewardRequest_ = false;
-    std::unordered_map<uint32_t, float> pendingQuestAcceptTimeouts_;
-    std::unordered_map<uint32_t, uint64_t> pendingQuestAcceptNpcGuids_;
-    bool questOfferRewardOpen_ = false;
-    QuestOfferRewardData currentQuestOfferReward_;
-
-    // Quest log
-    std::vector<QuestLogEntry> questLog_;
-    int selectedQuestLogIndex_ = 0;
-    std::unordered_set<uint32_t> pendingQuestQueryIds_;
-    std::unordered_set<uint32_t> trackedQuestIds_;
-    bool pendingLoginQuestResync_ = false;
-    float pendingLoginQuestResyncTimeout_ = 0.0f;
-
-    // Quest giver status per NPC
-    std::unordered_map<uint64_t, QuestGiverStatus> npcQuestStatus_;
-
-    // Shared quest state
-    bool        pendingSharedQuest_       = false;
-    uint32_t    sharedQuestId_            = 0;
-    std::string sharedQuestTitle_;
-    std::string sharedQuestSharerName_;
-    uint64_t    sharedQuestSharerGuid_    = 0;
-};
-
-} // namespace game
-} // namespace wowee
diff --git a/include/game/social_handler.hpp b/include/game/social_handler.hpp
deleted file mode 100644
index 53ffdf0f..00000000
--- a/include/game/social_handler.hpp
+++ /dev/null
@@ -1,450 +0,0 @@
-#pragma once
-
-#include "game/world_packets.hpp"
-#include "game/opcode_table.hpp"
-#include "game/group_defines.hpp"
-#include "game/handler_types.hpp"
-#include "network/packet.hpp"
-#include <array>
-#include <chrono>
-#include <functional>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-namespace wowee {
-namespace game {
-
-class GameHandler;
-
-class SocialHandler {
-public:
-    using PacketHandler = std::function<void(network::Packet&)>;
-    using DispatchTable = std::unordered_map<LogicalOpcode, PacketHandler>;
-
-    explicit SocialHandler(GameHandler& owner);
-
-    void registerOpcodes(DispatchTable& table);
-
-    // ---- Structs (aliased from handler_types.hpp) ----
-
-    using InspectArenaTeam = game::InspectArenaTeam;
-
-    using InspectResult = game::InspectResult;
-
-    using WhoEntry = game::WhoEntry;
-
-    using BgQueueSlot = game::BgQueueSlot;
-
-    using AvailableBgInfo = game::AvailableBgInfo;
-
-    using BgPlayerScore = game::BgPlayerScore;
-
-    using ArenaTeamScore = game::ArenaTeamScore;
-
-    using BgScoreboardData = game::BgScoreboardData;
-
-    using BgPlayerPosition = game::BgPlayerPosition;
-
-    using PetitionSignature = game::PetitionSignature;
-
-    using PetitionInfo = game::PetitionInfo;
-
-    using ReadyCheckResult = game::ReadyCheckResult;
-
-    using InstanceLockout = game::InstanceLockout;
-
-    using LfgState = game::LfgState;
-
-    using ArenaTeamStats = game::ArenaTeamStats;
-
-    using ArenaTeamMember = game::ArenaTeamMember;
-
-    using ArenaTeamRoster = game::ArenaTeamRoster;
-
-    // ---- Public API ----
-
-    // Inspection
-    void inspectTarget();
-    const InspectResult* getInspectResult() const {
-        return inspectResult_.guid ? &inspectResult_ : nullptr;
-    }
-
-    // Server info / who
-    void queryServerTime();
-    void requestPlayedTime();
-    void queryWho(const std::string& playerName = "");
-    uint32_t getTotalTimePlayed() const { return totalTimePlayed_; }
-    uint32_t getLevelTimePlayed() const { return levelTimePlayed_; }
-    const std::vector<WhoEntry>& getWhoResults() const { return whoResults_; }
-    uint32_t getWhoOnlineCount() const { return whoOnlineCount_; }
-    std::string getWhoAreaName(uint32_t zoneId) const;
-
-    // Social commands
-    void addFriend(const std::string& playerName, const std::string& note = "");
-    void removeFriend(const std::string& playerName);
-    void setFriendNote(const std::string& playerName, const std::string& note);
-    void addIgnore(const std::string& playerName);
-    void removeIgnore(const std::string& playerName);
-
-    // Random roll
-    void randomRoll(uint32_t minRoll = 1, uint32_t maxRoll = 100);
-
-    // Battleground
-    bool hasPendingBgInvite() const;
-    void acceptBattlefield(uint32_t queueSlot = 0xFFFFFFFF);
-    void declineBattlefield(uint32_t queueSlot = 0xFFFFFFFF);
-    const std::array<BgQueueSlot, 3>& getBgQueues() const { return bgQueues_; }
-    const std::vector<AvailableBgInfo>& getAvailableBgs() const { return availableBgs_; }
-    void requestPvpLog();
-    const BgScoreboardData* getBgScoreboard() const {
-        return bgScoreboard_.players.empty() ? nullptr : &bgScoreboard_;
-    }
-    const std::vector<BgPlayerPosition>& getBgPlayerPositions() const { return bgPlayerPositions_; }
-
-    // Logout
-    void requestLogout();
-    void cancelLogout();
-    bool  isLoggingOut()        const { return loggingOut_; }
-    float getLogoutCountdown()  const { return logoutCountdown_; }
-
-    // Guild
-    void requestGuildInfo();
-    void requestGuildRoster();
-    void setGuildMotd(const std::string& motd);
-    void promoteGuildMember(const std::string& playerName);
-    void demoteGuildMember(const std::string& playerName);
-    void leaveGuild();
-    void inviteToGuild(const std::string& playerName);
-    void kickGuildMember(const std::string& playerName);
-    void disbandGuild();
-    void setGuildLeader(const std::string& name);
-    void setGuildPublicNote(const std::string& name, const std::string& note);
-    void setGuildOfficerNote(const std::string& name, const std::string& note);
-    void acceptGuildInvite();
-    void declineGuildInvite();
-    void queryGuildInfo(uint32_t guildId);
-    void createGuild(const std::string& guildName);
-    void addGuildRank(const std::string& rankName);
-    void deleteGuildRank();
-    void requestPetitionShowlist(uint64_t npcGuid);
-    void buyPetition(uint64_t npcGuid, const std::string& guildName);
-
-    // Guild state accessors
-    bool isInGuild() const;
-    const std::string& getGuildName() const { return guildName_; }
-    const GuildRosterData& getGuildRoster() const { return guildRoster_; }
-    bool hasGuildRoster() const { return hasGuildRoster_; }
-    const std::vector<std::string>& getGuildRankNames() const { return guildRankNames_; }
-    bool hasPendingGuildInvite() const { return pendingGuildInvite_; }
-    const std::string& getPendingGuildInviterName() const { return pendingGuildInviterName_; }
-    const std::string& getPendingGuildInviteGuildName() const { return pendingGuildInviteGuildName_; }
-    const GuildInfoData& getGuildInfoData() const { return guildInfoData_; }
-    const GuildQueryResponseData& getGuildQueryData() const { return guildQueryData_; }
-    bool hasGuildInfoData() const { return guildInfoData_.isValid(); }
-
-    // Petition
-    bool hasPetitionShowlist() const { return showPetitionDialog_; }
-    void clearPetitionDialog() { showPetitionDialog_ = false; }
-    uint32_t getPetitionCost() const { return petitionCost_; }
-    uint64_t getPetitionNpcGuid() const { return petitionNpcGuid_; }
-    const PetitionInfo& getPetitionInfo() const { return petitionInfo_; }
-    bool hasPetitionSignaturesUI() const { return petitionInfo_.showUI; }
-    void clearPetitionSignaturesUI() { petitionInfo_.showUI = false; }
-    void signPetition(uint64_t petitionGuid);
-    void turnInPetition(uint64_t petitionGuid);
-
-    // Guild name lookup
-    const std::string& lookupGuildName(uint32_t guildId);
-    uint32_t getEntityGuildId(uint64_t guid) const;
-
-    // Ready check
-    void initiateReadyCheck();
-    void respondToReadyCheck(bool ready);
-    bool hasPendingReadyCheck() const { return pendingReadyCheck_; }
-    void dismissReadyCheck() { pendingReadyCheck_ = false; }
-    const std::string& getReadyCheckInitiator() const { return readyCheckInitiator_; }
-    const std::vector<ReadyCheckResult>& getReadyCheckResults() const { return readyCheckResults_; }
-
-    // Duel
-    void acceptDuel();
-    void forfeitDuel();
-    void proposeDuel(uint64_t targetGuid);
-    void reportPlayer(uint64_t targetGuid, const std::string& reason);
-    bool hasPendingDuelRequest() const { return pendingDuelRequest_; }
-    const std::string& getDuelChallengerName() const { return duelChallengerName_; }
-    float getDuelCountdownRemaining() const {
-        if (duelCountdownMs_ == 0) return 0.0f;
-        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now() - duelCountdownStartedAt_).count();
-        float rem = (static_cast<float>(duelCountdownMs_) - static_cast<float>(elapsed)) / 1000.0f;
-        return rem > 0.0f ? rem : 0.0f;
-    }
-
-    // Party/Raid
-    void inviteToGroup(const std::string& playerName);
-    void acceptGroupInvite();
-    void declineGroupInvite();
-    void leaveGroup();
-    void convertToRaid();
-    void sendSetLootMethod(uint32_t method, uint32_t threshold, uint64_t masterLooterGuid);
-    bool isInGroup() const { return !partyData.isEmpty(); }
-    const GroupListData& getPartyData() const { return partyData; }
-    bool hasPendingGroupInvite() const { return pendingGroupInvite; }
-    const std::string& getPendingInviterName() const { return pendingInviterName; }
-    void uninvitePlayer(const std::string& playerName);
-    void leaveParty();
-    void setMainTank(uint64_t targetGuid);
-    void setMainAssist(uint64_t targetGuid);
-    void clearMainTank();
-    void clearMainAssist();
-    void setRaidMark(uint64_t guid, uint8_t icon);
-    void requestRaidInfo();
-
-    // Instance lockouts
-    const std::vector<InstanceLockout>& getInstanceLockouts() const { return instanceLockouts_; }
-
-    // Instance difficulty
-    uint32_t getInstanceDifficulty() const { return instanceDifficulty_; }
-    bool isInstanceHeroic() const { return instanceIsHeroic_; }
-    bool isInInstance() const { return inInstance_; }
-
-    // Minimap ping
-    void sendMinimapPing(float wowX, float wowY);
-
-    // Summon request
-    void handleSummonRequest(network::Packet& packet);
-    void acceptSummon();
-    void declineSummon();
-
-    // Battlefield Manager
-    void acceptBfMgrInvite();
-    void declineBfMgrInvite();
-
-    // Calendar
-    void requestCalendar();
-
-    // ---- Methods moved from GameHandler ----
-    void sendSetDifficulty(uint32_t difficulty);
-    void toggleHelm();
-    void toggleCloak();
-    void setStandState(uint8_t standState);
-    void sendAlterAppearance(uint32_t hairStyle, uint32_t hairColor, uint32_t facialHair);
-    void deleteGmTicket();
-    void requestGmTicket();
-
-    // Utility methods for delegation from GameHandler
-    void updateLogoutCountdown(float deltaTime);
-    void resetTransferState();
-    GroupListData& mutablePartyData() { return partyData; }
-    InspectResult& mutableInspectResult() { return inspectResult_; }
-    void setRaidTargetGuid(uint8_t icon, uint64_t guid) {
-        if (icon < kRaidMarkCount) raidTargetGuids_[icon] = guid;
-    }
-    void setEncounterUnitGuid(uint32_t slot, uint64_t guid) {
-        if (slot < kMaxEncounterSlots) encounterUnitGuids_[slot] = guid;
-    }
-
-    // Encounter unit tracking
-    static constexpr uint32_t kMaxEncounterSlots = 5;
-    uint64_t getEncounterUnitGuid(uint32_t slot) const {
-        return (slot < kMaxEncounterSlots) ? encounterUnitGuids_[slot] : 0;
-    }
-
-    // Raid target markers (0-7: Star, Circle, Diamond, Triangle, Moon, Square, Cross, Skull)
-    static constexpr uint32_t kRaidMarkCount = 8;
-    uint64_t getRaidMarkGuid(uint32_t icon) const {
-        return (icon < kRaidMarkCount) ? raidTargetGuids_[icon] : 0;
-    }
-    uint8_t getEntityRaidMark(uint64_t guid) const {
-        if (guid == 0) return 0xFF;
-        for (uint32_t i = 0; i < kRaidMarkCount; ++i)
-            if (raidTargetGuids_[i] == guid) return static_cast<uint8_t>(i);
-        return 0xFF;
-    }
-
-    // LFG / Dungeon Finder
-    void lfgJoin(uint32_t dungeonId, uint8_t roles);
-    void lfgLeave();
-    void lfgSetRoles(uint8_t roles);
-    void lfgAcceptProposal(uint32_t proposalId, bool accept);
-    void lfgSetBootVote(bool vote);
-    void lfgTeleport(bool toLfgDungeon = true);
-    LfgState getLfgState()           const { return lfgState_; }
-    bool isLfgQueued()               const { return lfgState_ == LfgState::Queued; }
-    bool isLfgInDungeon()            const { return lfgState_ == LfgState::InDungeon; }
-    uint32_t getLfgDungeonId()       const { return lfgDungeonId_; }
-    std::string getCurrentLfgDungeonName() const;
-    uint32_t getLfgProposalId()      const { return lfgProposalId_; }
-    int32_t  getLfgAvgWaitSec()      const { return lfgAvgWaitSec_; }
-    uint32_t getLfgTimeInQueueMs()   const { return lfgTimeInQueueMs_; }
-    uint32_t getLfgBootVotes()       const { return lfgBootVotes_; }
-    uint32_t getLfgBootTotal()       const { return lfgBootTotal_; }
-    uint32_t getLfgBootTimeLeft()    const { return lfgBootTimeLeft_; }
-    uint32_t getLfgBootNeeded()      const { return lfgBootNeeded_; }
-    const std::string& getLfgBootTargetName() const { return lfgBootTargetName_; }
-    const std::string& getLfgBootReason()     const { return lfgBootReason_; }
-
-    // Arena
-    const std::vector<ArenaTeamStats>& getArenaTeamStats() const { return arenaTeamStats_; }
-    void requestArenaTeamRoster(uint32_t teamId);
-    const ArenaTeamRoster* getArenaTeamRoster(uint32_t teamId) const {
-        for (const auto& r : arenaTeamRosters_)
-            if (r.teamId == teamId) return &r;
-        return nullptr;
-    }
-
-private:
-    // ---- Packet handlers ----
-    void handleInspectResults(network::Packet& packet);
-    void handleQueryTimeResponse(network::Packet& packet);
-    void handlePlayedTime(network::Packet& packet);
-    void handleWho(network::Packet& packet);
-    void handleFriendList(network::Packet& packet);
-    void handleContactList(network::Packet& packet);
-    void handleFriendStatus(network::Packet& packet);
-    void handleRandomRoll(network::Packet& packet);
-    void handleLogoutResponse(network::Packet& packet);
-    void handleLogoutComplete(network::Packet& packet);
-    void handleGroupInvite(network::Packet& packet);
-    void handleGroupDecline(network::Packet& packet);
-    void handleGroupList(network::Packet& packet);
-    void handleGroupUninvite(network::Packet& packet);
-    void handlePartyCommandResult(network::Packet& packet);
-    void handlePartyMemberStats(network::Packet& packet, bool isFull);
-    void handleGuildInfo(network::Packet& packet);
-    void handleGuildRoster(network::Packet& packet);
-    void handleGuildQueryResponse(network::Packet& packet);
-    void handleGuildEvent(network::Packet& packet);
-    void handleGuildInvite(network::Packet& packet);
-    void handleGuildCommandResult(network::Packet& packet);
-    void handlePetitionShowlist(network::Packet& packet);
-    void handlePetitionQueryResponse(network::Packet& packet);
-    void handlePetitionShowSignatures(network::Packet& packet);
-    void handlePetitionSignResults(network::Packet& packet);
-    void handleTurnInPetitionResults(network::Packet& packet);
-    void handleBattlefieldStatus(network::Packet& packet);
-    void handleBattlefieldList(network::Packet& packet);
-    void handleRaidInstanceInfo(network::Packet& packet);
-    void handleInstanceDifficulty(network::Packet& packet);
-    void handleDuelRequested(network::Packet& packet);
-    void handleDuelComplete(network::Packet& packet);
-    void handleDuelWinner(network::Packet& packet);
-    void handleLfgJoinResult(network::Packet& packet);
-    void handleLfgQueueStatus(network::Packet& packet);
-    void handleLfgProposalUpdate(network::Packet& packet);
-    void handleLfgRoleCheckUpdate(network::Packet& packet);
-    void handleLfgUpdatePlayer(network::Packet& packet);
-    void handleLfgPlayerReward(network::Packet& packet);
-    void handleLfgBootProposalUpdate(network::Packet& packet);
-    void handleLfgTeleportDenied(network::Packet& packet);
-    void handleArenaTeamCommandResult(network::Packet& packet);
-    void handleArenaTeamQueryResponse(network::Packet& packet);
-    void handleArenaTeamRoster(network::Packet& packet);
-    void handleArenaTeamInvite(network::Packet& packet);
-    void handleArenaTeamEvent(network::Packet& packet);
-    void handleArenaTeamStats(network::Packet& packet);
-    void handleArenaError(network::Packet& packet);
-    void handlePvpLogData(network::Packet& packet);
-    void handleInitializeFactions(network::Packet& packet);
-    void handleSetFactionStanding(network::Packet& packet);
-    void handleSetFactionAtWar(network::Packet& packet);
-    void handleSetFactionVisible(network::Packet& packet);
-    void handleGroupSetLeader(network::Packet& packet);
-    void handleTalentsInfo(network::Packet& packet);
-
-    GameHandler& owner_;
-
-    // ---- State ----
-
-    // Inspect
-    InspectResult inspectResult_;
-
-    // Logout
-    bool  loggingOut_        = false;
-    float logoutCountdown_   = 0.0f;
-
-    // Time played
-    uint32_t totalTimePlayed_ = 0;
-    uint32_t levelTimePlayed_ = 0;
-
-    // Who results
-    std::vector<WhoEntry> whoResults_;
-    uint32_t whoOnlineCount_ = 0;
-
-    // Duel
-    bool pendingDuelRequest_    = false;
-    uint64_t duelChallengerGuid_= 0;
-    uint64_t duelFlagGuid_      = 0;
-    std::string duelChallengerName_;
-    uint32_t duelCountdownMs_   = 0;
-    std::chrono::steady_clock::time_point duelCountdownStartedAt_{};
-
-    // Guild
-    std::string guildName_;
-    std::vector<std::string> guildRankNames_;
-    GuildRosterData guildRoster_;
-    GuildInfoData guildInfoData_;
-    GuildQueryResponseData guildQueryData_;
-    bool hasGuildRoster_ = false;
-    std::unordered_map<uint32_t, std::string> guildNameCache_;
-    std::unordered_set<uint32_t> pendingGuildNameQueries_;
-    bool pendingGuildInvite_ = false;
-    std::string pendingGuildInviterName_;
-    std::string pendingGuildInviteGuildName_;
-    bool showPetitionDialog_ = false;
-    uint32_t petitionCost_ = 0;
-    uint64_t petitionNpcGuid_ = 0;
-    PetitionInfo petitionInfo_;
-
-    // Group
-    GroupListData partyData;
-    bool pendingGroupInvite = false;
-    std::string pendingInviterName;
-
-    // Ready check
-    bool        pendingReadyCheck_       = false;
-    uint32_t    readyCheckReadyCount_    = 0;
-    uint32_t    readyCheckNotReadyCount_ = 0;
-    std::string readyCheckInitiator_;
-    std::vector<ReadyCheckResult> readyCheckResults_;
-
-    // Instance
-    std::vector<InstanceLockout> instanceLockouts_;
-    uint32_t instanceDifficulty_ = 0;
-    bool instanceIsHeroic_ = false;
-    bool inInstance_ = false;
-
-    // Raid marks
-    std::array<uint64_t, kRaidMarkCount> raidTargetGuids_ = {};
-
-    // Encounter units
-    std::array<uint64_t, kMaxEncounterSlots> encounterUnitGuids_ = {};
-
-    // Arena
-    std::vector<ArenaTeamStats>  arenaTeamStats_;
-    std::vector<ArenaTeamRoster> arenaTeamRosters_;
-
-    // Battleground
-    std::array<BgQueueSlot, 3> bgQueues_{};
-    std::vector<AvailableBgInfo> availableBgs_;
-    BgScoreboardData bgScoreboard_;
-    std::vector<BgPlayerPosition> bgPlayerPositions_;
-
-    // LFG / Dungeon Finder
-    LfgState lfgState_        = LfgState::None;
-    uint32_t lfgDungeonId_    = 0;
-    uint32_t lfgProposalId_   = 0;
-    int32_t  lfgAvgWaitSec_   = -1;
-    uint32_t lfgTimeInQueueMs_= 0;
-    uint32_t lfgBootVotes_    = 0;
-    uint32_t lfgBootTotal_    = 0;
-    uint32_t lfgBootTimeLeft_ = 0;
-    uint32_t lfgBootNeeded_   = 0;
-    std::string lfgBootTargetName_;
-    std::string lfgBootReason_;
-};
-
-} // namespace game
-} // namespace wowee
diff --git a/include/game/spell_defines.hpp b/include/game/spell_defines.hpp
index 8b431532..041b44f6 100644
--- a/include/game/spell_defines.hpp
+++ b/include/game/spell_defines.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
 #include <cstdint>
-#include <ctime>
 #include <string>
 #include <vector>
 
@@ -51,38 +50,19 @@ struct ActionBarSlot {
 struct CombatTextEntry {
     enum Type : uint8_t {
         MELEE_DAMAGE, SPELL_DAMAGE, HEAL, MISS, DODGE, PARRY, BLOCK,
-        EVADE, CRIT_DAMAGE, CRIT_HEAL, PERIODIC_DAMAGE, PERIODIC_HEAL, ENVIRONMENTAL,
-        ENERGIZE, POWER_DRAIN, XP_GAIN, IMMUNE, ABSORB, RESIST, DEFLECT, REFLECT, PROC_TRIGGER,
-        DISPEL, STEAL, INTERRUPT, INSTAKILL, HONOR_GAIN, GLANCING, CRUSHING
+        CRIT_DAMAGE, CRIT_HEAL, PERIODIC_DAMAGE, PERIODIC_HEAL, ENVIRONMENTAL,
+        ENERGIZE, XP_GAIN, IMMUNE
     };
     Type type;
     int32_t amount = 0;
     uint32_t spellId = 0;
     float age = 0.0f;           // Seconds since creation (for fadeout)
     bool isPlayerSource = false; // True if player dealt this
-    uint8_t powerType = 0;      // For ENERGIZE/POWER_DRAIN: 0=mana,1=rage,2=focus,3=energy,6=runicpower
-    uint64_t srcGuid = 0;       // Source entity (attacker/caster)
-    uint64_t dstGuid = 0;       // Destination entity (victim/target) — used for world-space positioning
-    float xSeed = 0.0f;         // Random horizontal offset seed (-1..1) to stagger overlapping text
 
     static constexpr float LIFETIME = 2.5f;
     bool isExpired() const { return age >= LIFETIME; }
 };
 
-/**
- * Persistent combat log entry (stored in a rolling deque, survives beyond floating-text lifetime)
- */
-struct CombatLogEntry {
-    CombatTextEntry::Type type = CombatTextEntry::MELEE_DAMAGE;
-    int32_t  amount       = 0;
-    uint32_t spellId      = 0;
-    bool     isPlayerSource = false;
-    uint8_t  powerType    = 0;   // For ENERGIZE/DRAIN: power type; for ENVIRONMENTAL: env damage type
-    time_t   timestamp    = 0;   // Wall-clock time (std::time(nullptr))
-    std::string sourceName;      // Resolved display name of attacker/caster
-    std::string targetName;      // Resolved display name of victim/target
-};
-
 /**
  * Spell cooldown entry received from server
  */
@@ -300,76 +280,5 @@ inline const char* getSpellCastResultString(uint8_t result, int powerType = -1)
     }
 }
 
-// ── SpellEffect — SMSG_SPELLLOGEXECUTE effectType field (3.3.5a) ──────────
-// Full WoW enum has 164 entries; only values used in the codebase or commonly
-// relevant are defined here. Values match SharedDefines.h SpellEffects enum.
-namespace SpellEffect {
-    constexpr uint8_t NONE                      = 0;
-    constexpr uint8_t INSTAKILL                 = 1;
-    constexpr uint8_t SCHOOL_DAMAGE             = 2;
-    constexpr uint8_t DUMMY                     = 3;
-    constexpr uint8_t TELEPORT_UNITS            = 5;
-    constexpr uint8_t APPLY_AURA                = 6;
-    constexpr uint8_t ENVIRONMENTAL_DAMAGE      = 7;
-    constexpr uint8_t POWER_DRAIN               = 10;
-    constexpr uint8_t HEALTH_LEECH              = 11;
-    constexpr uint8_t HEAL                      = 12;
-    constexpr uint8_t WEAPON_DAMAGE_NOSCHOOL    = 16;
-    constexpr uint8_t RESURRECT                 = 18;
-    constexpr uint8_t EXTRA_ATTACKS             = 19;
-    constexpr uint8_t CREATE_ITEM               = 24;
-    constexpr uint8_t WEAPON_DAMAGE             = 25;
-    constexpr uint8_t INTERRUPT_CAST            = 26;
-    constexpr uint8_t OPEN_LOCK                 = 27;
-    constexpr uint8_t APPLY_AREA_AURA_PARTY     = 35;
-    constexpr uint8_t LEARN_SPELL               = 36;
-    constexpr uint8_t DISPEL                    = 38;
-    constexpr uint8_t SUMMON                    = 40;
-    constexpr uint8_t ENERGIZE                  = 43;
-    constexpr uint8_t WEAPON_PERCENT_DAMAGE     = 44;
-    constexpr uint8_t TRIGGER_SPELL             = 45;
-    constexpr uint8_t FEED_PET                  = 49;
-    constexpr uint8_t DISMISS_PET               = 50;
-    constexpr uint8_t ENCHANT_ITEM_PERM         = 53;
-    constexpr uint8_t ENCHANT_ITEM_TEMP         = 54;
-    constexpr uint8_t SUMMON_PET                = 56;
-    constexpr uint8_t LEARN_PET_SPELL           = 57;
-    constexpr uint8_t WEAPON_DAMAGE_PLUS        = 58;
-    constexpr uint8_t CREATE_HOUSE              = 60;
-    constexpr uint8_t DUEL                      = 62;
-    constexpr uint8_t QUEST_COMPLETE            = 63;
-    constexpr uint8_t NORMALIZED_WEAPON_DMG     = 75;
-    constexpr uint8_t OPEN_LOCK_ITEM            = 79;
-    constexpr uint8_t APPLY_AREA_AURA_RAID      = 81;
-    constexpr uint8_t ACTIVATE_RUNE             = 92;
-    constexpr uint8_t KNOCK_BACK                = 99;
-    constexpr uint8_t PULL                      = 100;
-    constexpr uint8_t DISPEL_MECHANIC           = 108;
-    constexpr uint8_t RESURRECT_NEW             = 113;
-    constexpr uint8_t CREATE_ITEM2              = 114;
-    constexpr uint8_t MILLING                   = 115;
-    constexpr uint8_t PROSPECTING               = 118;
-    constexpr uint8_t CHARGE                    = 126;
-    constexpr uint8_t TITAN_GRIP                = 155;
-    constexpr uint8_t TOTAL_SPELL_EFFECTS       = 164;
-} // namespace SpellEffect
-
-// ── SpellMissInfo — SMSG_SPELLLOGMISS / SMSG_SPELL_GO miss type (3.3.5a) ─
-namespace SpellMissInfo {
-    constexpr uint8_t NONE      = 0;   // Miss
-    constexpr uint8_t MISS      = 0;
-    constexpr uint8_t DODGE     = 1;
-    constexpr uint8_t PARRY     = 2;
-    constexpr uint8_t BLOCK     = 3;
-    constexpr uint8_t EVADE     = 4;
-    constexpr uint8_t IMMUNE    = 5;
-    constexpr uint8_t DEFLECT   = 6;
-    constexpr uint8_t ABSORB    = 7;
-    constexpr uint8_t RESIST    = 8;
-    constexpr uint8_t IMMUNE2   = 9;   // Second immunity flag
-    constexpr uint8_t IMMUNE3   = 10;  // Third immunity flag
-    constexpr uint8_t REFLECT   = 11;
-} // namespace SpellMissInfo
-
 } // namespace game
 } // namespace wowee
diff --git a/include/game/spell_handler.hpp b/include/game/spell_handler.hpp
deleted file mode 100644
index e93f6281..00000000
--- a/include/game/spell_handler.hpp
+++ /dev/null
@@ -1,328 +0,0 @@
-#pragma once
-
-#include "game/world_packets.hpp"
-#include "game/opcode_table.hpp"
-#include "game/spell_defines.hpp"
-#include "game/handler_types.hpp"
-#include "network/packet.hpp"
-#include <array>
-#include <chrono>
-#include <functional>
-#include <map>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-namespace wowee {
-namespace game {
-
-class GameHandler;
-
-class SpellHandler {
-public:
-    using PacketHandler = std::function<void(network::Packet&)>;
-    using DispatchTable = std::unordered_map<LogicalOpcode, PacketHandler>;
-
-    explicit SpellHandler(GameHandler& owner);
-
-    void registerOpcodes(DispatchTable& table);
-
-    // Talent data structures (aliased from handler_types.hpp)
-    using TalentEntry = game::TalentEntry;
-    using TalentTabEntry = game::TalentTabEntry;
-
-    // --- Spell book tabs ---
-    struct SpellBookTab {
-        std::string name;
-        std::string texture; // icon path
-        std::vector<uint32_t> spellIds; // spells in this tab
-    };
-
-    // Unit cast state (aliased from handler_types.hpp)
-    using UnitCastState = game::UnitCastState;
-
-    // Equipment set info (aliased from handler_types.hpp)
-    using EquipmentSetInfo = game::EquipmentSetInfo;
-
-    // --- Public API (delegated from GameHandler) ---
-    void castSpell(uint32_t spellId, uint64_t targetGuid = 0);
-    void cancelCast();
-    void cancelAura(uint32_t spellId);
-
-    // Known spells
-    const std::unordered_set<uint32_t>& getKnownSpells() const { return knownSpells_; }
-    const std::unordered_map<uint32_t, float>& getSpellCooldowns() const { return spellCooldowns_; }
-    float getSpellCooldown(uint32_t spellId) const;
-
-    // Cast state
-    bool isCasting() const { return casting_; }
-    bool isChanneling() const { return casting_ && castIsChannel_; }
-    bool isGameObjectInteractionCasting() const;
-    uint32_t getCurrentCastSpellId() const { return currentCastSpellId_; }
-    float getCastProgress() const { return castTimeTotal_ > 0 ? (castTimeTotal_ - castTimeRemaining_) / castTimeTotal_ : 0.0f; }
-    float getCastTimeRemaining() const { return castTimeRemaining_; }
-    float getCastTimeTotal() const { return castTimeTotal_; }
-
-    // Repeat-craft queue
-    void startCraftQueue(uint32_t spellId, int count);
-    void cancelCraftQueue();
-    int getCraftQueueRemaining() const { return craftQueueRemaining_; }
-    uint32_t getCraftQueueSpellId() const { return craftQueueSpellId_; }
-
-    // Spell queue (400ms window)
-    uint32_t getQueuedSpellId() const { return queuedSpellId_; }
-    void cancelQueuedSpell() { queuedSpellId_ = 0; queuedSpellTarget_ = 0; }
-
-    // Unit cast state (tracked per GUID for target frame + boss frames)
-    const UnitCastState* getUnitCastState(uint64_t guid) const {
-        auto it = unitCastStates_.find(guid);
-        return (it != unitCastStates_.end() && it->second.casting) ? &it->second : nullptr;
-    }
-    void clearUnitCastStates() { unitCastStates_.clear(); }
-
-    // Target cast helpers
-    bool isTargetCasting() const;
-    uint32_t getTargetCastSpellId() const;
-    float getTargetCastProgress() const;
-    float getTargetCastTimeRemaining() const;
-    bool isTargetCastInterruptible() const;
-
-    // Talents
-    uint8_t getActiveTalentSpec() const { return activeTalentSpec_; }
-    uint8_t getUnspentTalentPoints() const { return unspentTalentPoints_[activeTalentSpec_]; }
-    uint8_t getUnspentTalentPoints(uint8_t spec) const { return spec < 2 ? unspentTalentPoints_[spec] : 0; }
-    const std::unordered_map<uint32_t, uint8_t>& getLearnedTalents() const { return learnedTalents_[activeTalentSpec_]; }
-    const std::unordered_map<uint32_t, uint8_t>& getLearnedTalents(uint8_t spec) const {
-        static std::unordered_map<uint32_t, uint8_t> empty;
-        return spec < 2 ? learnedTalents_[spec] : empty;
-    }
-
-    static constexpr uint8_t MAX_GLYPH_SLOTS = 6;
-    const std::array<uint16_t, MAX_GLYPH_SLOTS>& getGlyphs() const { return learnedGlyphs_[activeTalentSpec_]; }
-    const std::array<uint16_t, MAX_GLYPH_SLOTS>& getGlyphs(uint8_t spec) const {
-        static std::array<uint16_t, MAX_GLYPH_SLOTS> empty{};
-        return spec < 2 ? learnedGlyphs_[spec] : empty;
-    }
-    uint8_t getTalentRank(uint32_t talentId) const {
-        auto it = learnedTalents_[activeTalentSpec_].find(talentId);
-        return (it != learnedTalents_[activeTalentSpec_].end()) ? it->second : 0;
-    }
-    void learnTalent(uint32_t talentId, uint32_t requestedRank);
-    void switchTalentSpec(uint8_t newSpec);
-
-    // Talent DBC access
-    const TalentEntry* getTalentEntry(uint32_t talentId) const {
-        auto it = talentCache_.find(talentId);
-        return (it != talentCache_.end()) ? &it->second : nullptr;
-    }
-    const TalentTabEntry* getTalentTabEntry(uint32_t tabId) const {
-        auto it = talentTabCache_.find(tabId);
-        return (it != talentTabCache_.end()) ? &it->second : nullptr;
-    }
-    const std::unordered_map<uint32_t, TalentEntry>& getAllTalents() const { return talentCache_; }
-    const std::unordered_map<uint32_t, TalentTabEntry>& getAllTalentTabs() const { return talentTabCache_; }
-    void loadTalentDbc();
-
-    // Auras
-    const std::vector<AuraSlot>& getPlayerAuras() const { return playerAuras_; }
-    const std::vector<AuraSlot>& getTargetAuras() const { return targetAuras_; }
-    const std::vector<AuraSlot>* getUnitAuras(uint64_t guid) const {
-        auto it = unitAurasCache_.find(guid);
-        return (it != unitAurasCache_.end()) ? &it->second : nullptr;
-    }
-
-    // Global Cooldown (GCD)
-    float getGCDRemaining() const {
-        if (gcdTotal_ <= 0.0f) return 0.0f;
-        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now() - gcdStartedAt_).count() / 1000.0f;
-        float rem = gcdTotal_ - elapsed;
-        return rem > 0.0f ? rem : 0.0f;
-    }
-    float getGCDTotal() const { return gcdTotal_; }
-    bool isGCDActive() const { return getGCDRemaining() > 0.0f; }
-
-    // Spell book tabs
-    const std::vector<SpellBookTab>& getSpellBookTabs();
-
-    // Talent wipe confirm dialog
-    bool showTalentWipeConfirmDialog() const { return talentWipePending_; }
-    uint32_t getTalentWipeCost() const { return talentWipeCost_; }
-    void confirmTalentWipe();
-    void cancelTalentWipe() { talentWipePending_ = false; }
-
-    // Pet talent respec confirm
-    bool showPetUnlearnDialog() const { return petUnlearnPending_; }
-    uint32_t getPetUnlearnCost() const { return petUnlearnCost_; }
-    void confirmPetUnlearn();
-    void cancelPetUnlearn() { petUnlearnPending_ = false; }
-
-    // Item use
-    void useItemBySlot(int backpackIndex);
-    void useItemInBag(int bagIndex, int slotIndex);
-    void useItemById(uint32_t itemId);
-
-    // Equipment sets — canonical data owned by InventoryHandler;
-    // GameHandler::getEquipmentSets() delegates to inventoryHandler_.
-
-    // Pet spells
-    void sendPetAction(uint32_t action, uint64_t targetGuid = 0);
-    void dismissPet();
-    void togglePetSpellAutocast(uint32_t spellId);
-    void renamePet(const std::string& newName);
-
-    // Spell DBC accessors
-    const int32_t* getSpellEffectBasePoints(uint32_t spellId) const;
-    float getSpellDuration(uint32_t spellId) const;
-    const std::string& getSpellName(uint32_t spellId) const;
-    const std::string& getSpellRank(uint32_t spellId) const;
-    const std::string& getSpellDescription(uint32_t spellId) const;
-    std::string getEnchantName(uint32_t enchantId) const;
-    uint8_t getSpellDispelType(uint32_t spellId) const;
-    bool isSpellInterruptible(uint32_t spellId) const;
-    uint32_t getSpellSchoolMask(uint32_t spellId) const;
-    const std::string& getSkillLineName(uint32_t spellId) const;
-
-    // Cast state
-    void stopCasting();
-    void resetCastState();
-    void resetTalentState();
-    // Full per-character reset (spells, cooldowns, auras, cast state, talents).
-    // Called from GameHandler::selectCharacter so spell state doesn't bleed between characters.
-    void resetAllState();
-    void clearUnitCaches();
-
-    // Aura duration
-    void handleUpdateAuraDuration(uint8_t slot, uint32_t durationMs);
-
-    // Skill DBC
-    void loadSkillLineDbc();
-    void extractSkillFields(const std::map<uint16_t, uint32_t>& fields);
-    void extractExploredZoneFields(const std::map<uint16_t, uint32_t>& fields);
-
-    // Update per-frame timers (call from GameHandler::update)
-    void updateTimers(float dt);
-
-private:
-    // --- Packet handlers ---
-    void handleInitialSpells(network::Packet& packet);
-    void handleCastFailed(network::Packet& packet);
-    void handleSpellStart(network::Packet& packet);
-    void handleSpellGo(network::Packet& packet);
-    void handleSpellCooldown(network::Packet& packet);
-    void handleCooldownEvent(network::Packet& packet);
-    void handleAuraUpdate(network::Packet& packet, bool isAll);
-    void handleLearnedSpell(network::Packet& packet);
-    void handlePetSpells(network::Packet& packet);
-    void handleListStabledPets(network::Packet& packet);
-
-    // Pet stable
-    void requestStabledPetList();
-    void stablePet(uint8_t slot);
-    void unstablePet(uint32_t petNumber);
-
-    void handleCastResult(network::Packet& packet);
-    void handleSpellFailedOther(network::Packet& packet);
-    void handleClearCooldown(network::Packet& packet);
-    void handleModifyCooldown(network::Packet& packet);
-    void handlePlaySpellVisual(network::Packet& packet);
-    void handleSpellModifier(network::Packet& packet, bool isFlat);
-    void handleSpellDelayed(network::Packet& packet);
-    void handleSpellLogMiss(network::Packet& packet);
-    void handleSpellFailure(network::Packet& packet);
-    void handleItemCooldown(network::Packet& packet);
-    void handleDispelFailed(network::Packet& packet);
-    void handleTotemCreated(network::Packet& packet);
-    void handlePeriodicAuraLog(network::Packet& packet);
-    void handleSpellEnergizeLog(network::Packet& packet);
-    void handleExtraAuraInfo(network::Packet& packet, bool isInit);
-    void handleSpellDispelLog(network::Packet& packet);
-    void handleSpellStealLog(network::Packet& packet);
-    void handleSpellChanceProcLog(network::Packet& packet);
-    void handleSpellInstaKillLog(network::Packet& packet);
-    void handleSpellLogExecute(network::Packet& packet);
-    void handleClearExtraAuraInfo(network::Packet& packet);
-    void handleItemEnchantTimeUpdate(network::Packet& packet);
-    void handleResumeCastBar(network::Packet& packet);
-    void handleChannelStart(network::Packet& packet);
-    void handleChannelUpdate(network::Packet& packet);
-
-    // --- Internal helpers ---
-    // Find the on-use spell for an item (trigger=0 Use or trigger=5 NoDelay).
-    // CMSG_USE_ITEM requires a valid spellId or the server silently ignores it.
-    uint32_t findOnUseSpellId(uint32_t itemId) const;
-    void loadSpellNameCache() const;
-    void loadSkillLineAbilityDbc();
-    void categorizeTrainerSpells();
-    void handleSupercededSpell(network::Packet& packet);
-    void handleRemovedSpell(network::Packet& packet);
-    void handleUnlearnSpells(network::Packet& packet);
-    void handleTalentsInfo(network::Packet& packet);
-    void handleAchievementEarned(network::Packet& packet);
-
-    friend class GameHandler;
-    friend class InventoryHandler;
-    friend class CombatHandler;
-    friend class EntityController;
-
-    GameHandler& owner_;
-
-    // --- Spell state ---
-    std::unordered_set<uint32_t> knownSpells_;
-    std::unordered_map<uint32_t, float> spellCooldowns_;    // spellId -> remaining seconds
-    uint8_t castCount_ = 0;
-    bool casting_ = false;
-    bool castIsChannel_ = false;
-    uint32_t currentCastSpellId_ = 0;
-    float castTimeRemaining_ = 0.0f;
-    float castTimeTotal_ = 0.0f;
-
-    // Repeat-craft queue
-    uint32_t craftQueueSpellId_ = 0;
-    int craftQueueRemaining_ = 0;
-
-    // Spell queue (400ms window)
-    uint32_t queuedSpellId_ = 0;
-    uint64_t queuedSpellTarget_ = 0;
-
-    // Per-unit cast state
-    std::unordered_map<uint64_t, UnitCastState> unitCastStates_;
-
-    // Talents (dual-spec support)
-    uint8_t activeTalentSpec_ = 0;
-    uint8_t unspentTalentPoints_[2] = {0, 0};
-    std::unordered_map<uint32_t, uint8_t> learnedTalents_[2];
-    std::array<std::array<uint16_t, MAX_GLYPH_SLOTS>, 2> learnedGlyphs_{};
-    std::unordered_map<uint32_t, TalentEntry> talentCache_;
-    std::unordered_map<uint32_t, TalentTabEntry> talentTabCache_;
-    bool talentDbcLoaded_ = false;
-    bool talentsInitialized_ = false;
-
-    // Auras
-    std::vector<AuraSlot> playerAuras_;
-    std::vector<AuraSlot> targetAuras_;
-    std::unordered_map<uint64_t, std::vector<AuraSlot>> unitAurasCache_;
-
-    // Global Cooldown
-    float gcdTotal_ = 0.0f;
-    std::chrono::steady_clock::time_point gcdStartedAt_{};
-
-    // Spell book tabs
-    std::vector<SpellBookTab> spellBookTabs_;
-    size_t lastSpellCount_ = 0;
-    bool spellBookTabsDirty_ = true;
-
-    // Talent wipe confirm dialog
-    bool talentWipePending_ = false;
-    uint64_t talentWipeNpcGuid_ = 0;
-    uint32_t talentWipeCost_ = 0;
-
-    // Pet talent respec confirm dialog
-    bool petUnlearnPending_ = false;
-    uint64_t petUnlearnGuid_ = 0;
-    uint32_t petUnlearnCost_ = 0;
-};
-
-} // namespace game
-} // namespace wowee
diff --git a/include/game/transport_manager.hpp b/include/game/transport_manager.hpp
index 57eaa6bc..496380c4 100644
--- a/include/game/transport_manager.hpp
+++ b/include/game/transport_manager.hpp
@@ -64,7 +64,7 @@ struct ActiveTransport {
     bool serverYawFlipped180;       // Auto-correction when server yaw is consistently opposite movement
     int serverYawAlignmentScore;    // Hysteresis score for yaw flip detection
 
-    double lastServerUpdate;         // Time of last server movement update
+    float lastServerUpdate;         // Time of last server movement update
     int serverUpdateCount;          // Number of server updates received
 
     // Dead-reckoning from latest authoritative updates (used only when updates are sparse).
@@ -147,9 +147,7 @@ private:
     rendering::WMORenderer* wmoRenderer_ = nullptr;
     rendering::M2Renderer* m2Renderer_ = nullptr;
     bool clientSideAnimation_ = false;  // DISABLED - use server positions instead of client prediction
-    // double: float loses millisecond precision after ~4.5 hours (2^23 / 1000),
-    // causing transport path interpolation to visibly jerk in long play sessions.
-    double elapsedTime_ = 0.0;
+    float elapsedTime_ = 0.0f;  // Total elapsed time (seconds)
 };
 
 } // namespace wowee::game
diff --git a/include/game/update_field_table.hpp b/include/game/update_field_table.hpp
index c9d63e99..b841925e 100644
--- a/include/game/update_field_table.hpp
+++ b/include/game/update_field_table.hpp
@@ -14,13 +14,11 @@ namespace game {
 enum class UF : uint16_t {
     // Object fields
     OBJECT_FIELD_ENTRY,
-    OBJECT_FIELD_SCALE_X,
 
     // Unit fields
     UNIT_FIELD_TARGET_LO,
     UNIT_FIELD_TARGET_HI,
     UNIT_FIELD_BYTES_0,
-    UNIT_FIELD_BYTES_1,  // byte3 = shapeshift form ID
     UNIT_FIELD_HEALTH,
     UNIT_FIELD_POWER1,
     UNIT_FIELD_MAXHEALTH,
@@ -32,65 +30,31 @@ enum class UF : uint16_t {
     UNIT_FIELD_DISPLAYID,
     UNIT_FIELD_MOUNTDISPLAYID,
     UNIT_FIELD_AURAS,           // Start of aura spell ID array (48 consecutive uint32 slots, classic/vanilla only)
-    UNIT_FIELD_AURAFLAGS,       // Aura flags packed 4-per-uint32 (12 uint32 slots); 0x01=cancelable,0x02=harmful,0x04=helpful
     UNIT_NPC_FLAGS,
-    UNIT_NPC_EMOTESTATE,       // Persistent NPC emote animation ID (uint32)
     UNIT_DYNAMIC_FLAGS,
     UNIT_FIELD_RESISTANCES,   // Physical armor (index 0 of the resistance array)
-    UNIT_FIELD_STAT0,         // Strength (effective base, includes items)
-    UNIT_FIELD_STAT1,         // Agility
-    UNIT_FIELD_STAT2,         // Stamina
-    UNIT_FIELD_STAT3,         // Intellect
-    UNIT_FIELD_STAT4,         // Spirit
     UNIT_END,
 
-    // Unit combat fields (WotLK: PRIVATE+OWNER — only visible for the player character)
-    UNIT_FIELD_ATTACK_POWER,         // Melee attack power (int32)
-    UNIT_FIELD_RANGED_ATTACK_POWER,  // Ranged attack power (int32)
-
     // Player fields
     PLAYER_FLAGS,
     PLAYER_BYTES,
     PLAYER_BYTES_2,
     PLAYER_XP,
     PLAYER_NEXT_LEVEL_XP,
-    PLAYER_REST_STATE_EXPERIENCE,
     PLAYER_FIELD_COINAGE,
     PLAYER_QUEST_LOG_START,
     PLAYER_FIELD_INV_SLOT_HEAD,
     PLAYER_FIELD_PACK_SLOT_1,
-    PLAYER_FIELD_KEYRING_SLOT_1,
     PLAYER_FIELD_BANK_SLOT_1,
     PLAYER_FIELD_BANKBAG_SLOT_1,
     PLAYER_SKILL_INFO_START,
     PLAYER_EXPLORED_ZONES_START,
-    PLAYER_CHOSEN_TITLE,         // Active title index (-1 = no title)
-
-    // Player spell power / healing bonus (WotLK: PRIVATE — int32 per school)
-    PLAYER_FIELD_MOD_DAMAGE_DONE_POS,  // Spell damage bonus (first of 7 schools)
-    PLAYER_FIELD_MOD_HEALING_DONE_POS, // Healing bonus
-
-    // Player combat stats (WotLK: PRIVATE — float values)
-    PLAYER_BLOCK_PERCENTAGE,         // Block chance %
-    PLAYER_DODGE_PERCENTAGE,         // Dodge chance %
-    PLAYER_PARRY_PERCENTAGE,         // Parry chance %
-    PLAYER_CRIT_PERCENTAGE,          // Melee crit chance %
-    PLAYER_RANGED_CRIT_PERCENTAGE,   // Ranged crit chance %
-    PLAYER_SPELL_CRIT_PERCENTAGE1,   // Spell crit chance % (first school; 7 consecutive float fields)
-    PLAYER_FIELD_COMBAT_RATING_1,    // First of 25 int32 combat rating slots (CR_* indices)
-
-    // Player PvP currency (TBC/WotLK only — Classic uses the old weekly honor system)
-    PLAYER_FIELD_HONOR_CURRENCY,     // Accumulated honor points (uint32)
-    PLAYER_FIELD_ARENA_CURRENCY,     // Accumulated arena points (uint32)
 
     // GameObject fields
     GAMEOBJECT_DISPLAYID,
-    GAMEOBJECT_BYTES_1,
 
     // Item fields
     ITEM_FIELD_STACK_COUNT,
-    ITEM_FIELD_DURABILITY,
-    ITEM_FIELD_MAXDURABILITY,
 
     // Container fields
     CONTAINER_FIELD_NUM_SLOTS,
diff --git a/include/game/warden_emulator.hpp b/include/game/warden_emulator.hpp
index 9271c978..320afd0d 100644
--- a/include/game/warden_emulator.hpp
+++ b/include/game/warden_emulator.hpp
@@ -5,7 +5,6 @@
 #include <string>
 #include <memory>
 #include <map>
-#include <unordered_map>
 #include <functional>
 
 // Forward declare unicorn types (will include in .cpp)
@@ -138,10 +137,6 @@ public:
      */
     std::vector<uint8_t> readData(uint32_t address, size_t size);
 
-    // Look up an already-registered API stub address by DLL and function name.
-    // Returns 0 if not found. Used by WardenModule::bindAPIs() for IAT patching.
-    uint32_t getAPIAddress(const std::string& dllName, const std::string& funcName) const;
-
 private:
     uc_engine* uc_;                  // Unicorn engine instance
     uint32_t moduleBase_;            // Module base address
@@ -152,21 +147,11 @@ private:
     uint32_t heapSize_;              // Heap size
     uint32_t apiStubBase_;           // API stub base address
 
-    // API hooks: DLL name -> Function name -> stub address
-    std::unordered_map<std::string, std::unordered_map<std::string, uint32_t>> apiAddresses_;
-
-    // API stub dispatch: stub address -> {argCount, handler}
-    struct ApiHookEntry {
-        int argCount;
-        std::function<uint32_t(WardenEmulator&, const std::vector<uint32_t>&)> handler;
-    };
-    std::unordered_map<uint32_t, ApiHookEntry> apiHandlers_;
-    uint32_t nextApiStubAddr_;   // tracks next free stub slot (replaces static local)
-    bool apiCodeHookRegistered_; // true once UC_HOOK_CODE for stub range is added
+    // API hooks: DLL name -> Function name -> Handler
+    std::map<std::string, std::map<std::string, uint32_t>> apiAddresses_;
 
     // Memory allocation tracking
-    std::unordered_map<uint32_t, size_t> allocations_;
-    std::map<uint32_t, size_t> freeBlocks_;  // free-list keyed by base address
+    std::map<uint32_t, size_t> allocations_;
     uint32_t nextHeapAddr_;
 
     // Hook handles for cleanup
diff --git a/include/game/warden_handler.hpp b/include/game/warden_handler.hpp
deleted file mode 100644
index 2cb0e818..00000000
--- a/include/game/warden_handler.hpp
+++ /dev/null
@@ -1,103 +0,0 @@
-#pragma once
-
-#include "game/opcode_table.hpp"
-#include "network/packet.hpp"
-#include <cstdint>
-#include <functional>
-#include <future>
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-namespace wowee {
-namespace game {
-
-class GameHandler;
-class WardenCrypto;
-class WardenMemory;
-class WardenModule;
-class WardenModuleManager;
-
-class WardenHandler {
-public:
-    using PacketHandler = std::function<void(network::Packet&)>;
-    using DispatchTable = std::unordered_map<LogicalOpcode, PacketHandler>;
-
-    explicit WardenHandler(GameHandler& owner);
-
-    void registerOpcodes(DispatchTable& table);
-
-    // --- Public API ---
-
-    /** Reset all warden state (called on connect / disconnect). */
-    void reset();
-
-    /** Initialize warden module manager (called once from GameHandler ctor). */
-    void initModuleManager();
-
-    /** Whether the server requires Warden (gates char enum / create). */
-    bool requiresWarden() const { return requiresWarden_; }
-    void setRequiresWarden(bool v) { requiresWarden_ = v; }
-
-    bool wardenGateSeen() const { return wardenGateSeen_; }
-
-    /** Increment packet-after-gate counter (called from handlePacket). */
-    void notifyPacketAfterGate() { ++wardenPacketsAfterGate_; }
-
-    bool wardenCharEnumBlockedLogged() const { return wardenCharEnumBlockedLogged_; }
-    void setWardenCharEnumBlockedLogged(bool v) { wardenCharEnumBlockedLogged_ = v; }
-
-    /** Called from GameHandler::update() to drain async warden response + log gate timing. */
-    void update(float deltaTime);
-
-private:
-    void handleWardenData(network::Packet& packet);
-    bool loadWardenCRFile(const std::string& moduleHashHex);
-
-    GameHandler& owner_;
-
-    // --- Warden state ---
-    bool requiresWarden_ = false;
-    bool wardenGateSeen_ = false;
-    float wardenGateElapsed_ = 0.0f;
-    float wardenGateNextStatusLog_ = 2.0f;
-    uint32_t wardenPacketsAfterGate_ = 0;
-    bool wardenCharEnumBlockedLogged_ = false;
-    std::unique_ptr<WardenCrypto> wardenCrypto_;
-    std::unique_ptr<WardenMemory> wardenMemory_;
-    std::unique_ptr<WardenModuleManager> wardenModuleManager_;
-
-    // Warden module download state
-    enum class WardenState {
-        WAIT_MODULE_USE,     // Waiting for first SMSG (MODULE_USE)
-        WAIT_MODULE_CACHE,   // Sent MODULE_MISSING, receiving module chunks
-        WAIT_HASH_REQUEST,   // Module received, waiting for HASH_REQUEST
-        WAIT_CHECKS,         // Hash sent, waiting for check requests
-    };
-    WardenState wardenState_ = WardenState::WAIT_MODULE_USE;
-    std::vector<uint8_t> wardenModuleHash_;    // 16 bytes MD5
-    std::vector<uint8_t> wardenModuleKey_;     // 16 bytes RC4
-    uint32_t wardenModuleSize_ = 0;
-    std::vector<uint8_t> wardenModuleData_;    // Downloaded module chunks
-    std::vector<uint8_t> wardenLoadedModuleImage_; // Parsed module image for key derivation
-    std::shared_ptr<WardenModule> wardenLoadedModule_; // Loaded Warden module
-
-    // Pre-computed challenge/response entries from .cr file
-    struct WardenCREntry {
-        uint8_t seed[16];
-        uint8_t reply[20];
-        uint8_t clientKey[16];  // Encrypt key (client→server)
-        uint8_t serverKey[16]; // Decrypt key (server→client)
-    };
-    std::vector<WardenCREntry> wardenCREntries_;
-    // Module-specific check type opcodes [9]: MEM, PAGE_A, PAGE_B, MPQ, LUA, DRIVER, TIMING, PROC, MODULE
-    uint8_t wardenCheckOpcodes_[9] = {};
-
-    // Async Warden response: avoids 5-second main-loop stalls from PAGE_A/PAGE_B code pattern searches
-    std::future<std::vector<uint8_t>> wardenPendingEncrypted_;  // encrypted response bytes
-    bool wardenResponsePending_ = false;
-};
-
-} // namespace game
-} // namespace wowee
diff --git a/include/game/warden_memory.hpp b/include/game/warden_memory.hpp
index 39a2abf2..335ad7a9 100644
--- a/include/game/warden_memory.hpp
+++ b/include/game/warden_memory.hpp
@@ -3,7 +3,6 @@
 #include <vector>
 #include <cstdint>
 #include <string>
-#include <unordered_map>
 
 namespace wowee {
 namespace game {
@@ -19,9 +18,8 @@ public:
     ~WardenMemory();
 
     /** Search standard candidate dirs for WoW.exe and load it.
-     *  @param build Client build number (e.g. 5875 for Classic 1.12.1) to select the right exe.
-     *  @param isTurtle If true, prefer the Turtle WoW custom exe (different code bytes). */
-    bool load(uint16_t build = 0, bool isTurtle = false);
+     *  @param build Client build number (e.g. 5875 for Classic 1.12.1) to select the right exe. */
+    bool load(uint16_t build = 0);
 
     /** Load PE image from a specific file path. */
     bool loadFromFile(const std::string& exePath);
@@ -34,23 +32,6 @@ public:
 
     bool isLoaded() const { return loaded_; }
 
-    /**
-     * Search PE image for a byte pattern matching HMAC-SHA1(seed, pattern).
-     * Used for FIND_MEM_IMAGE_CODE_BY_HASH and FIND_CODE_BY_HASH scans.
-     * @param seed 4-byte HMAC key
-     * @param expectedHash 20-byte expected HMAC-SHA1 digest
-     * @param patternLen Length of the pattern to search for
-     * @param imageOnly If true, search only executable sections (.text)
-     * @param hintOffset RVA hint from PAGE_A request — check this position first
-     * @return true if a matching pattern was found in the PE image
-     */
-    bool searchCodePattern(const uint8_t seed[4], const uint8_t expectedHash[20],
-                           uint8_t patternLen, bool imageOnly,
-                           uint32_t hintOffset = 0, bool hintOnly = false) const;
-
-    /** Write a little-endian uint32 at the given virtual address in the PE image. */
-    void writeLE32(uint32_t va, uint32_t value);
-
 private:
     bool loaded_ = false;
     uint32_t imageBase_ = 0;
@@ -65,15 +46,9 @@ private:
     bool parsePE(const std::vector<uint8_t>& fileData);
     void initKuserSharedData();
     void patchRuntimeGlobals();
-    void patchTurtleWowBinary();
-    void verifyWardenScanEntries();
-    bool isTurtle_ = false;
+    void writeLE32(uint32_t va, uint32_t value);
     std::string findWowExe(uint16_t build) const;
-    static uint32_t expectedImageSizeForBuild(uint16_t build, bool isTurtle);
-
-    // Cache for searchCodePattern results to avoid repeated 5-second brute-force searches.
-    // Key: hex string of seed(4)+hash(20)+patLen(1)+imageOnly(1) = 26 bytes.
-    mutable std::unordered_map<std::string, bool> codePatternCache_;
+    static uint32_t expectedImageSizeForBuild(uint16_t build);
 };
 
 } // namespace game
diff --git a/include/game/warden_module.hpp b/include/game/warden_module.hpp
index 7f3f21f9..bcea989f 100644
--- a/include/game/warden_module.hpp
+++ b/include/game/warden_module.hpp
@@ -13,7 +13,6 @@ namespace game {
 
 // Forward declarations
 class WardenEmulator;
-class WardenCrypto;
 
 /**
  * Represents Warden callback functions exported by loaded module
@@ -37,19 +36,18 @@ struct WardenFuncList {
  * Warden module loader and executor
  *
  * IMPLEMENTATION STATUS:
- * ✅ Module metadata parsing and validation
- * ✅ RC4 decryption (WardenCrypto)
- * ✅ RSA-2048 signature verification (OpenSSL EVP — real Blizzard modulus)
- * ✅ zlib decompression
- * ✅ Custom executable format parsing (3 pair-format variants)
- * ✅ Address relocation (delta-encoded fixups)
- * ✅ x86 emulation via Unicorn Engine (cross-platform)
- * ✅ Client callbacks (sendPacket, validateModule, generateRC4)
- * ✅ API binding / IAT patching (parses import table, auto-stubs unknown APIs)
- * ✅ RSA modulus verified (Blizzard key, same across 1.12.1/2.4.3/3.3.5a)
+ * ✅ Module metadata parsing
+ * ✅ Basic validation framework
+ * ⏳ RC4 decryption (uses existing WardenCrypto)
+ * ❌ RSA signature verification (TODO - requires OpenSSL RSA)
+ * ❌ zlib decompression (TODO - requires zlib library)
+ * ❌ Custom executable format parsing (TODO - major reverse engineering)
+ * ❌ Address relocation (TODO - x86 address fixups)
+ * ❌ API binding (TODO - kernel32/user32 function resolution)
+ * ❌ Native code execution (TODO - execute loaded x86 code)
  *
- * Non-fatal verification: RSA mismatch logs warning but continues loading,
- * so private-server modules signed with custom keys still work.
+ * For strict servers like Warmane, ALL TODOs must be implemented.
+ * For permissive servers, fake responses in GameHandler work.
  */
 class WardenModule {
 public:
@@ -128,12 +126,6 @@ public:
     size_t getModuleSize() const { return moduleSize_; }
     const std::vector<uint8_t>& getDecompressedData() const { return decompressedData_; }
 
-    // Inject dependencies for module callbacks (sendPacket, generateRC4).
-    // Must be called before initializeModule() so callbacks can reach the
-    // network layer and crypto state.
-    using SendPacketFunc = std::function<void(const uint8_t*, size_t)>;
-    void setCallbackDependencies(WardenCrypto* crypto, SendPacketFunc sendFunc);
-
 private:
     bool loaded_;                          // Module successfully loaded
     std::vector<uint8_t> md5Hash_;         // Module identifier
@@ -148,12 +140,6 @@ private:
     size_t relocDataOffset_ = 0;           // Offset into decompressedData_ where relocation data starts
     WardenFuncList funcList_;              // Callback functions
     std::unique_ptr<WardenEmulator> emulator_; // Cross-platform x86 emulator
-    uint32_t emulatedPacketHandlerAddr_ = 0;   // Raw emulated VA for 4-arg PacketHandler call
-
-    // Dependencies injected via setCallbackDependencies() for module callbacks.
-    // These are NOT owned — the handler owns the crypto and socket lifetime.
-    WardenCrypto* callbackCrypto_ = nullptr;
-    SendPacketFunc callbackSendPacket_;
 
     // Validation and loading steps
     bool verifyMD5(const std::vector<uint8_t>& data,
diff --git a/include/game/world_packets.hpp b/include/game/world_packets.hpp
index 19cbf3ba..42f64bc9 100644
--- a/include/game/world_packets.hpp
+++ b/include/game/world_packets.hpp
@@ -395,14 +395,11 @@ enum class MovementFlags : uint32_t {
     ROOT                = 0x00000800,
     FALLING             = 0x00001000,
     FALLINGFAR          = 0x00002000,
-    FEATHER_FALL        = 0x00004000,  // Slow fall / Parachute
-    WATER_WALK          = 0x00008000,  // Walk on water surface
     SWIMMING            = 0x00200000,
     ASCENDING           = 0x00400000,
-    DESCENDING          = 0x00800000,
-    CAN_FLY             = 0x01000000,
-    FLYING              = 0x02000000,
-    HOVER               = 0x40000000,
+    CAN_FLY             = 0x00800000,
+    FLYING              = 0x01000000,
+    HOVER               = 0x02000000,
 };
 
 /**
@@ -449,6 +446,7 @@ struct MovementInfo {
  */
 class MovementPacket {
 public:
+    static void writePackedGuid(network::Packet& packet, uint64_t guid);
     static void writeMovementPayload(network::Packet& packet, const MovementInfo& info);
 
     /**
@@ -483,10 +481,6 @@ struct UpdateBlock {
     // Update flags from movement block (for detecting transports, etc.)
     uint16_t updateFlags = 0;
 
-    // Raw movement flags from LIVING block (SWIMMING=0x200000, WALKING=0x100, CAN_FLY=0x800000, FLYING=0x1000000)
-    // Used to initialise swim/walk/fly state on entity spawn (cold-join).
-    uint32_t moveFlags = 0;
-
     // Transport data from LIVING movement block (MOVEMENTFLAG_ONTRANSPORT)
     bool onTransport = false;
     uint64_t transportGuid = 0;
@@ -525,6 +519,14 @@ public:
      */
     static bool parse(network::Packet& packet, UpdateObjectData& data);
 
+    /**
+     * Read packed GUID from packet
+     *
+     * @param packet Packet to read from
+     * @return GUID value
+     */
+    static uint64_t readPackedGuid(network::Packet& packet);
+
     /**
      * Parse a single update block
      *
@@ -607,11 +609,7 @@ enum class ChatType : uint8_t {
     MONSTER_WHISPER = 42,
     RAID_BOSS_WHISPER = 43,
     RAID_BOSS_EMOTE = 44,
-    MONSTER_PARTY = 50,
-    // BG/Arena system messages (WoW 3.3.5a — no sender, treated as SYSTEM in display)
-    BG_SYSTEM_NEUTRAL  = 82,
-    BG_SYSTEM_ALLIANCE = 83,
-    BG_SYSTEM_HORDE    = 84
+    MONSTER_PARTY = 50
 };
 
 /**
@@ -689,7 +687,6 @@ public:
  * Get human-readable string for chat type
  */
 const char* getChatTypeString(ChatType type);
-const char* getItemSubclassName(uint32_t itemClass, uint32_t subClass);
 
 // ============================================================
 // Text Emotes
@@ -720,9 +717,7 @@ struct TextEmoteData {
  */
 class TextEmoteParser {
 public:
-    // legacyFormat: Classic 1.12 and TBC 2.4.3 send textEmoteId+emoteNum first, then senderGuid.
-    //               WotLK 3.3.5a reverses this: senderGuid first, then textEmoteId+emoteNum.
-    static bool parse(network::Packet& packet, TextEmoteData& data, bool legacyFormat = false);
+    static bool parse(network::Packet& packet, TextEmoteData& data);
 };
 
 // ============================================================
@@ -749,40 +744,38 @@ public:
  * Channel notification types
  */
 enum class ChannelNotifyType : uint8_t {
-    PLAYER_JOINED = 0x00,
-    PLAYER_LEFT = 0x01,
-    YOU_JOINED = 0x02,
-    YOU_LEFT = 0x03,
-    WRONG_PASSWORD = 0x04,
-    NOT_MEMBER = 0x05,
-    NOT_MODERATOR = 0x06,
-    PASSWORD_CHANGED = 0x07,
-    OWNER_CHANGED = 0x08,
-    PLAYER_NOT_FOUND = 0x09,
-    NOT_OWNER = 0x0A,
-    CHANNEL_OWNER = 0x0B,
-    MODE_CHANGE = 0x0C,
-    ANNOUNCEMENTS_ON = 0x0D,
-    ANNOUNCEMENTS_OFF = 0x0E,
-    MODERATION_ON = 0x0F,
-    MODERATION_OFF = 0x10,
-    MUTED = 0x11,
-    PLAYER_KICKED = 0x12,
-    BANNED = 0x13,
-    PLAYER_BANNED = 0x14,
-    PLAYER_UNBANNED = 0x15,
-    PLAYER_NOT_BANNED = 0x16,
-    PLAYER_ALREADY_MEMBER = 0x17,
-    INVITE = 0x18,
-    INVITE_WRONG_FACTION = 0x19,
-    WRONG_FACTION = 0x1A,
-    INVALID_NAME = 0x1B,
-    NOT_MODERATED = 0x1C,
-    PLAYER_INVITED = 0x1D,
-    PLAYER_INVITE_BANNED = 0x1E,
-    THROTTLED = 0x1F,
-    NOT_IN_AREA = 0x20,
-    NOT_IN_LFG = 0x21,
+    YOU_JOINED = 0x00,
+    YOU_LEFT = 0x01,
+    WRONG_PASSWORD = 0x02,
+    NOT_MEMBER = 0x03,
+    NOT_MODERATOR = 0x04,
+    PASSWORD_CHANGED = 0x05,
+    OWNER_CHANGED = 0x06,
+    PLAYER_NOT_FOUND = 0x07,
+    NOT_OWNER = 0x08,
+    CHANNEL_OWNER = 0x09,
+    MODE_CHANGE = 0x0A,
+    ANNOUNCEMENTS_ON = 0x0B,
+    ANNOUNCEMENTS_OFF = 0x0C,
+    MODERATION_ON = 0x0D,
+    MODERATION_OFF = 0x0E,
+    MUTED = 0x0F,
+    PLAYER_KICKED = 0x10,
+    BANNED = 0x11,
+    PLAYER_BANNED = 0x12,
+    PLAYER_UNBANNED = 0x13,
+    PLAYER_NOT_BANNED = 0x14,
+    PLAYER_ALREADY_MEMBER = 0x15,
+    INVITE = 0x16,
+    INVITE_WRONG_FACTION = 0x17,
+    WRONG_FACTION = 0x18,
+    INVALID_NAME = 0x19,
+    NOT_MODERATED = 0x1A,
+    PLAYER_INVITED = 0x1B,
+    PLAYER_INVITE_BANNED = 0x1C,
+    THROTTLED = 0x1D,
+    NOT_IN_AREA = 0x1E,
+    NOT_IN_LFG = 0x1F,
 };
 
 /**
@@ -904,12 +897,6 @@ public:
     static network::Packet build(uint64_t ignoreGuid);
 };
 
-/** CMSG_COMPLAIN packet builder (player report) */
-class ComplainPacket {
-public:
-    static network::Packet build(uint64_t targetGuid, const std::string& reason);
-};
-
 // ============================================================
 // Logout Commands
 // ============================================================
@@ -948,21 +935,6 @@ public:
     static network::Packet build(uint8_t state);
 };
 
-// ============================================================
-// Action Bar
-// ============================================================
-
-/** CMSG_SET_ACTION_BUTTON packet builder */
-class SetActionButtonPacket {
-public:
-    // button:   0-based slot index
-    // type:     ActionBarSlot::Type (SPELL=0, ITEM=1, MACRO=2, EMPTY=0)
-    // id:       spellId, itemId, or macroId (0 to clear)
-    // isClassic: true for Vanilla/Turtle format (5-byte payload),
-    //            false for TBC/WotLK (5-byte packed uint32)
-    static network::Packet build(uint8_t button, uint8_t type, uint32_t id, bool isClassic);
-};
-
 // ============================================================
 // Display Toggles
 // ============================================================
@@ -1321,23 +1293,6 @@ public:
     static network::Packet build();
 };
 
-/** CMSG_GROUP_RAID_CONVERT packet builder */
-class GroupRaidConvertPacket {
-public:
-    static network::Packet build();
-};
-
-/** CMSG_LOOT_METHOD packet builder */
-class SetLootMethodPacket {
-public:
-    /**
-     * @param method 0=FFA, 1=RoundRobin, 2=MasterLoot, 3=GroupLoot, 4=NeedBeforeGreed
-     * @param threshold item quality threshold (0-6)
-     * @param masterLooterGuid GUID of master looter (only relevant for method=2)
-     */
-    static network::Packet build(uint32_t method, uint32_t threshold, uint64_t masterLooterGuid);
-};
-
 /** MSG_RAID_TARGET_UPDATE packet builder */
 class RaidTargetUpdatePacket {
 public:
@@ -1389,33 +1344,6 @@ public:
     static network::Packet build();
 };
 
-/** CMSG_SET_TRADE_ITEM packet builder (tradeSlot, bag, bagSlot) */
-class SetTradeItemPacket {
-public:
-    // tradeSlot: 0-5 (normal) or 6 (backpack money-only slot)
-    // bag: 255 = main backpack, 19-22 = bag slots
-    // bagSlot: slot within bag
-    static network::Packet build(uint8_t tradeSlot, uint8_t bag, uint8_t bagSlot);
-};
-
-/** CMSG_CLEAR_TRADE_ITEM packet builder (remove item from trade slot) */
-class ClearTradeItemPacket {
-public:
-    static network::Packet build(uint8_t tradeSlot);
-};
-
-/** CMSG_SET_TRADE_GOLD packet builder (gold offered, in copper) */
-class SetTradeGoldPacket {
-public:
-    static network::Packet build(uint64_t copper);
-};
-
-/** CMSG_UNACCEPT_TRADE packet builder (unaccept without cancelling) */
-class UnacceptTradePacket {
-public:
-    static network::Packet build();
-};
-
 /** CMSG_ATTACKSWING packet builder */
 class AttackSwingPacket {
 public:
@@ -1460,7 +1388,7 @@ public:
 };
 
 // ============================================================
-// Foundation — Targeting, Name Queries
+// Phase 1: Foundation — Targeting, Name Queries
 // ============================================================
 
 /** CMSG_SET_SELECTION packet builder */
@@ -1481,12 +1409,6 @@ public:
     static network::Packet build(uint64_t targetGuid);
 };
 
-/** CMSG_QUERY_INSPECT_ACHIEVEMENTS packet builder (WotLK 3.3.5a) */
-class QueryInspectAchievementsPacket {
-public:
-    static network::Packet build(uint64_t targetGuid);
-};
-
 /** CMSG_NAME_QUERY packet builder */
 class NameQueryPacket {
 public:
@@ -1525,10 +1447,9 @@ struct CreatureQueryResponseData {
     std::string subName;
     std::string iconName;
     uint32_t typeFlags = 0;
-    uint32_t creatureType = 0;  // 1=Beast, 2=Dragonkin, 3=Demon, 4=Elemental, 5=Giant, 6=Undead, 7=Humanoid, ...
+    uint32_t creatureType = 0;
     uint32_t family = 0;
     uint32_t rank = 0;         // 0=Normal, 1=Elite, 2=Rare Elite, 3=Boss, 4=Rare
-    uint32_t displayId[4] = {};  // Up to 4 random display models (0 = unused)
 
     bool isValid() const { return entry != 0 && !name.empty(); }
 };
@@ -1606,29 +1527,19 @@ struct ItemQueryResponseData {
     uint32_t subClass = 0;
     uint32_t displayInfoId = 0;
     uint32_t quality = 0;
-    uint32_t itemFlags = 0;     // Item flag bitmask (Heroic=0x8, Unique-Equipped=0x1000000)
     uint32_t inventoryType = 0;
-    int32_t maxCount = 0;       // Max that can be carried (1 = Unique, 0 = unlimited)
     int32_t maxStack = 1;
     uint32_t containerSlots = 0;
     float damageMin = 0.0f;
     float damageMax = 0.0f;
     uint32_t delayMs = 0;
     int32_t armor = 0;
-    int32_t holyRes = 0;
-    int32_t fireRes = 0;
-    int32_t natureRes = 0;
-    int32_t frostRes = 0;
-    int32_t shadowRes = 0;
-    int32_t arcaneRes = 0;
     int32_t stamina = 0;
     int32_t strength = 0;
     int32_t agility = 0;
     int32_t intellect = 0;
     int32_t spirit = 0;
     uint32_t sellPrice = 0;
-    uint32_t itemLevel = 0;
-    uint32_t requiredLevel = 0;
     std::string subclassName;
     // Item spells (up to 5)
     struct ItemSpell {
@@ -1636,23 +1547,6 @@ struct ItemQueryResponseData {
         uint32_t spellTrigger = 0; // 0=Use, 1=Equip, 2=ChanceOnHit, 5=Learn
     };
     std::array<ItemSpell, 5> spells{};
-    uint32_t bindType = 0;      // 0=none, 1=BoP, 2=BoE, 3=BoU, 4=BoQ
-    std::string description;    // Flavor/lore text
-    // Generic stat pairs for non-primary stats (hit, crit, haste, AP, SP, etc.)
-    struct ExtraStat { uint32_t statType = 0; int32_t statValue = 0; };
-    std::vector<ExtraStat> extraStats;
-    uint32_t startQuestId = 0;  // Non-zero: item begins a quest
-    // Gem socket slots (WotLK/TBC): 0=no socket; color mask: 1=Meta,2=Red,4=Yellow,8=Blue
-    std::array<uint32_t, 3> socketColor{};
-    uint32_t socketBonus = 0;   // enchantmentId of socket bonus; 0=none
-    uint32_t itemSetId   = 0;   // ItemSet.dbc entry; 0=not part of a set
-    // Requirement fields
-    uint32_t requiredSkill = 0;       // SkillLine.dbc ID (0 = no skill required)
-    uint32_t requiredSkillRank = 0;   // Minimum skill value
-    uint32_t allowableClass = 0;      // Class bitmask (0 = all classes)
-    uint32_t allowableRace  = 0;      // Race bitmask (0 = all races)
-    uint32_t requiredReputationFaction = 0;  // Faction.dbc ID (0 = none)
-    uint32_t requiredReputationRank    = 0;  // 0=Hated..8=Exalted
     bool valid = false;
 };
 
@@ -1663,7 +1557,7 @@ public:
 };
 
 // ============================================================
-// Combat Core
+// Phase 2: Combat Core
 // ============================================================
 
 /** SMSG_MONSTER_MOVE data */
@@ -1736,10 +1630,8 @@ struct AttackerStateUpdateData {
     uint32_t blocked = 0;
 
     bool isValid() const { return attackerGuid != 0; }
-    bool isCrit() const     { return (hitInfo & 0x0200) != 0; }
-    bool isMiss() const     { return (hitInfo & 0x0010) != 0; }
-    bool isGlancing() const { return (hitInfo & 0x0800) != 0; }
-    bool isCrushing() const { return (hitInfo & 0x1000) != 0; }
+    bool isCrit() const { return (hitInfo & 0x200) != 0; }
+    bool isMiss() const { return (hitInfo & 0x10) != 0; }
 };
 
 class AttackerStateUpdateParser {
@@ -1805,7 +1697,7 @@ public:
 };
 
 // ============================================================
-// Spells, Action Bar, Auras
+// Phase 3: Spells, Action Bar, Auras
 // ============================================================
 
 /** SMSG_INITIAL_SPELLS data */
@@ -1819,10 +1711,7 @@ struct InitialSpellsData {
 
 class InitialSpellsParser {
 public:
-    // vanillaFormat=true: Classic 1.12 uint16 spellId + uint16 slot (4 bytes/spell)
-    // vanillaFormat=false: TBC/WotLK uint32 spellId + uint16 unk (6 bytes/spell)
-    static bool parse(network::Packet& packet, InitialSpellsData& data,
-                      bool vanillaFormat = false);
+    static bool parse(network::Packet& packet, InitialSpellsData& data);
 };
 
 /** CMSG_CAST_SPELL packet builder */
@@ -1840,8 +1729,7 @@ public:
 /** CMSG_PET_ACTION packet builder */
 class PetActionPacket {
 public:
-    /** CMSG_PET_ACTION: petGuid + action + targetGuid (0 = no target) */
-    static network::Packet build(uint64_t petGuid, uint32_t action, uint64_t targetGuid = 0);
+    static network::Packet build(uint64_t petGuid, uint32_t action);
 };
 
 /** SMSG_CAST_FAILED data */
@@ -1877,11 +1765,6 @@ public:
 };
 
 /** SMSG_SPELL_GO data (simplified) */
-struct SpellGoMissEntry {
-    uint64_t targetGuid = 0;
-    uint8_t  missType   = 0;  // 0=MISS 1=DODGE 2=PARRY 3=BLOCK 4=EVADE 5=IMMUNE 6=DEFLECT 7=ABSORB 8=RESIST 11=REFLECT
-};
-
 struct SpellGoData {
     uint64_t casterGuid = 0;
     uint64_t casterUnit = 0;
@@ -1889,10 +1772,8 @@ struct SpellGoData {
     uint32_t spellId = 0;
     uint32_t castFlags = 0;
     uint8_t hitCount = 0;
-    std::vector<uint64_t>       hitTargets;
+    std::vector<uint64_t> hitTargets;
     uint8_t missCount = 0;
-    std::vector<SpellGoMissEntry> missTargets;
-    uint64_t targetGuid = 0;  ///< Primary target GUID from SpellCastTargets (0 = none/AoE)
 
     bool isValid() const { return spellId != 0; }
 };
@@ -1930,7 +1811,7 @@ public:
 };
 
 // ============================================================
-// Group/Party System
+// Phase 4: Group/Party System
 // ============================================================
 
 /** CMSG_GROUP_INVITE packet builder */
@@ -1967,9 +1848,7 @@ public:
 /** SMSG_GROUP_LIST parser */
 class GroupListParser {
 public:
-    // hasRoles: WotLK 3.3.5a added a roles byte at group level and per-member for LFD.
-    //           Classic 1.12 and TBC 2.4.3 do not send this byte.
-    static bool parse(network::Packet& packet, GroupListData& data, bool hasRoles = true);
+    static bool parse(network::Packet& packet, GroupListData& data);
 };
 
 /** SMSG_PARTY_COMMAND_RESULT data */
@@ -1998,7 +1877,7 @@ public:
 };
 
 // ============================================================
-// Loot System
+// Phase 5: Loot System
 // ============================================================
 
 /** Loot item entry */
@@ -2044,12 +1923,6 @@ public:
     static network::Packet build(uint8_t bagIndex, uint8_t slotIndex, uint64_t itemGuid, uint32_t spellId = 0);
 };
 
-/** CMSG_OPEN_ITEM packet builder (for locked containers / lockboxes) */
-class OpenItemPacket {
-public:
-    static network::Packet build(uint8_t bagIndex, uint8_t slotIndex);
-};
-
 /** CMSG_AUTOEQUIP_ITEM packet builder */
 class AutoEquipItemPacket {
 public:
@@ -2063,13 +1936,6 @@ public:
     static network::Packet build(uint8_t dstBag, uint8_t dstSlot, uint8_t srcBag, uint8_t srcSlot);
 };
 
-/** CMSG_SPLIT_ITEM packet builder */
-class SplitItemPacket {
-public:
-    static network::Packet build(uint8_t srcBag, uint8_t srcSlot,
-                                 uint8_t dstBag, uint8_t dstSlot, uint8_t count);
-};
-
 /** CMSG_SWAP_INV_ITEM packet builder */
 class SwapInvItemPacket {
 public:
@@ -2093,14 +1959,11 @@ public:
 /** SMSG_LOOT_RESPONSE parser */
 class LootResponseParser {
 public:
-    // isWotlkFormat: true for WotLK (has trailing quest item section),
-    //                false for Classic/TBC (no quest item section).
-    //                Per-item size is 22 bytes across all expansions.
-    static bool parse(network::Packet& packet, LootResponseData& data, bool isWotlkFormat = true);
+    static bool parse(network::Packet& packet, LootResponseData& data);
 };
 
 // ============================================================
-// NPC Gossip
+// Phase 5: NPC Gossip
 // ============================================================
 
 /** Gossip menu option */
@@ -2194,14 +2057,6 @@ public:
     static network::Packet build(uint64_t npcGuid, uint32_t questId);
 };
 
-/** Reward item entry (shared by quest detail/offer windows) */
-struct QuestRewardItem {
-    uint32_t itemId = 0;
-    uint32_t count = 0;
-    uint32_t displayInfoId = 0;
-    uint32_t choiceSlot = 0;  // Original reward slot index from server payload
-};
-
 /** SMSG_QUESTGIVER_QUEST_DETAILS data (simplified) */
 struct QuestDetailsData {
     uint64_t npcGuid = 0;
@@ -2212,8 +2067,6 @@ struct QuestDetailsData {
     uint32_t suggestedPlayers = 0;
     uint32_t rewardMoney = 0;
     uint32_t rewardXp = 0;
-    std::vector<QuestRewardItem> rewardChoiceItems;  // Player picks one of these
-    std::vector<QuestRewardItem> rewardItems;         // These are always given
 };
 
 /** SMSG_QUESTGIVER_QUEST_DETAILS parser */
@@ -2222,6 +2075,14 @@ public:
     static bool parse(network::Packet& packet, QuestDetailsData& data);
 };
 
+/** Reward item entry (shared by quest detail/offer windows) */
+struct QuestRewardItem {
+    uint32_t itemId = 0;
+    uint32_t count = 0;
+    uint32_t displayInfoId = 0;
+    uint32_t choiceSlot = 0;  // Original reward slot index from server payload
+};
+
 /** SMSG_QUESTGIVER_REQUEST_ITEMS data (turn-in progress check) */
 struct QuestRequestItemsData {
     uint64_t npcGuid = 0;
@@ -2278,7 +2139,7 @@ public:
 };
 
 // ============================================================
-// Vendor
+// Phase 5: Vendor
 // ============================================================
 
 /** Vendor item entry */
@@ -2297,7 +2158,6 @@ struct VendorItem {
 struct ListInventoryData {
     uint64_t vendorGuid = 0;
     std::vector<VendorItem> items;
-    bool canRepair = false;  // Set when vendor was opened via GOSSIP_OPTION_ARMORER
 
     bool isValid() const { return true; }
 };
@@ -2360,9 +2220,7 @@ struct TrainerListData {
 
 class TrainerListParser {
 public:
-    // isClassic: Classic 1.12 per-spell layout has no profDialog/profButton fields
-    // (reqLevel immediately follows cost), plus a trailing unk uint32 per entry.
-    static bool parse(network::Packet& packet, TrainerListData& data, bool isClassic = false);
+    static bool parse(network::Packet& packet, TrainerListData& data);
 };
 
 class TrainerBuySpellPacket {
@@ -2408,13 +2266,6 @@ public:
     static network::Packet build(bool accept);
 };
 
-/** CMSG_SET_ACTIVE_TALENT_GROUP_OBSOLETE (0x4C3) — switch dual-spec talent group */
-class ActivateTalentGroupPacket {
-public:
-    /** @param group  0 = primary spec, 1 = secondary spec */
-    static network::Packet build(uint32_t group);
-};
-
 // ============================================================
 // Taxi / Flight Paths
 // ============================================================
@@ -2477,12 +2328,6 @@ public:
     static network::Packet build();
 };
 
-/** CMSG_RECLAIM_CORPSE packet builder */
-class ReclaimCorpsePacket {
-public:
-    static network::Packet build(uint64_t guid);
-};
-
 /** CMSG_SPIRIT_HEALER_ACTIVATE packet builder */
 class SpiritHealerActivatePacket {
 public:
@@ -2520,8 +2365,8 @@ struct MailMessage {
     std::string subject;
     std::string body;
     uint32_t stationeryId = 0;
-    uint64_t money = 0;
-    uint64_t cod = 0;           // Cash on delivery
+    uint32_t money = 0;
+    uint32_t cod = 0;           // Cash on delivery
     uint32_t flags = 0;
     float expirationTime = 0.0f;
     uint32_t mailTemplateId = 0;
@@ -2540,7 +2385,7 @@ class SendMailPacket {
 public:
     static network::Packet build(uint64_t mailboxGuid, const std::string& recipient,
                                  const std::string& subject, const std::string& body,
-                                 uint64_t money, uint64_t cod,
+                                 uint32_t money, uint32_t cod,
                                  const std::vector<uint64_t>& itemGuids = {});
 };
 
@@ -2553,7 +2398,7 @@ public:
 /** CMSG_MAIL_TAKE_ITEM packet builder */
 class MailTakeItemPacket {
 public:
-    static network::Packet build(uint64_t mailboxGuid, uint32_t mailId, uint32_t itemGuidLow);
+    static network::Packet build(uint64_t mailboxGuid, uint32_t mailId, uint32_t itemIndex);
 };
 
 /** CMSG_MAIL_DELETE packet builder */
@@ -2736,8 +2581,7 @@ class AuctionSellItemPacket {
 public:
     static network::Packet build(uint64_t auctioneerGuid, uint64_t itemGuid,
                                   uint32_t stackCount, uint32_t bid,
-                                  uint32_t buyout, uint32_t duration,
-                                  bool preWotlk = false);
+                                  uint32_t buyout, uint32_t duration);
 };
 
 /** CMSG_AUCTION_PLACE_BID packet builder */
@@ -2768,8 +2612,7 @@ public:
 /** SMSG_AUCTION_LIST_RESULT parser (shared for browse/owner/bidder) */
 class AuctionListResultParser {
 public:
-    // numEnchantSlots: Classic 1.12 = 1, TBC/WotLK = 3 (extra enchant slots per entry)
-    static bool parse(network::Packet& packet, AuctionListResult& data, int numEnchantSlots = 3);
+    static bool parse(network::Packet& packet, AuctionListResult& data);
 };
 
 /** SMSG_AUCTION_COMMAND_RESULT parser */
@@ -2778,48 +2621,5 @@ public:
     static bool parse(network::Packet& packet, AuctionCommandResult& data);
 };
 
-/** Pet Stable packet builders */
-class ListStabledPetsPacket {
-public:
-    /** MSG_LIST_STABLED_PETS (CMSG): request list from stable master */
-    static network::Packet build(uint64_t stableMasterGuid);
-};
-
-class StablePetPacket {
-public:
-    /** CMSG_STABLE_PET: store active pet in the given stable slot (1-based) */
-    static network::Packet build(uint64_t stableMasterGuid, uint8_t slot);
-};
-
-class UnstablePetPacket {
-public:
-    /** CMSG_UNSTABLE_PET: retrieve a stabled pet by its server-side petNumber */
-    static network::Packet build(uint64_t stableMasterGuid, uint32_t petNumber);
-};
-
-class PetRenamePacket {
-public:
-    /** CMSG_PET_RENAME: rename the player's active pet.
-     *  petGuid: the pet's object GUID (from GameHandler::getPetGuid())
-     *  name: new name (max 12 chars; server validates and may reject)
-     *  isDeclined: 0 for non-Cyrillic locales (no declined name forms) */
-    static network::Packet build(uint64_t petGuid, const std::string& name, uint8_t isDeclined = 0);
-};
-
-/** CMSG_SET_TITLE packet builder.
- *  titleBit >= 0: activate the title with that bit index.
- *  titleBit == -1: clear the current title (show no title). */
-class SetTitlePacket {
-public:
-    static network::Packet build(int32_t titleBit);
-};
-
-/** CMSG_ALTER_APPEARANCE – barber shop: change hair style, color, facial hair.
- *  Payload: uint32 hairStyle, uint32 hairColor, uint32 facialHair. */
-class AlterAppearancePacket {
-public:
-    static network::Packet build(uint32_t hairStyle, uint32_t hairColor, uint32_t facialHair);
-};
-
 } // namespace game
 } // namespace wowee
diff --git a/include/network/net_platform.hpp b/include/network/net_platform.hpp
index 329dd375..0cc38e1a 100644
--- a/include/network/net_platform.hpp
+++ b/include/network/net_platform.hpp
@@ -22,7 +22,6 @@
   #include <netinet/in.h>
   #include <arpa/inet.h>
   #include <netdb.h>
-  #include <netinet/tcp.h>
   #include <unistd.h>
   #include <fcntl.h>
   #include <cerrno>
diff --git a/include/network/packet.hpp b/include/network/packet.hpp
index 744b6eae..fbfb85bf 100644
--- a/include/network/packet.hpp
+++ b/include/network/packet.hpp
@@ -27,29 +27,13 @@ public:
     uint32_t readUInt32();
     uint64_t readUInt64();
     float readFloat();
-    uint64_t readPackedGuid();
-    void writePackedGuid(uint64_t guid);
     std::string readString();
 
     uint16_t getOpcode() const { return opcode; }
     const std::vector<uint8_t>& getData() const { return data; }
     size_t getReadPos() const { return readPos; }
     size_t getSize() const { return data.size(); }
-    // Clamp to 0 instead of wrapping to ~(size_t)0 when readPos overshoots
-    // (can happen via setReadPos with an unchecked offset).
-    size_t getRemainingSize() const { return (readPos <= data.size()) ? (data.size() - readPos) : 0; }
-    bool hasRemaining(size_t need) const { return readPos <= data.size() && need <= (data.size() - readPos); }
-    bool hasFullPackedGuid() const {
-        if (readPos >= data.size()) return false;
-        uint8_t mask = data[readPos];
-        size_t guidBytes = 1;
-        for (int bit = 0; bit < 8; ++bit)
-            if (mask & (1u << bit)) ++guidBytes;
-        return getRemainingSize() >= guidBytes;
-    }
     void setReadPos(size_t pos) { readPos = pos; }
-    bool hasData() const { return readPos < data.size(); }
-    void skipAll() { readPos = data.size(); }
 
 private:
     uint16_t opcode = 0;
diff --git a/include/network/world_socket.hpp b/include/network/world_socket.hpp
index 543e570f..1d8f1d00 100644
--- a/include/network/world_socket.hpp
+++ b/include/network/world_socket.hpp
@@ -7,14 +7,7 @@
 #include "auth/vanilla_crypt.hpp"
 #include <functional>
 #include <vector>
-#include <deque>
 #include <cstdint>
-#include <chrono>
-#include <thread>
-#include <mutex>
-#include <atomic>
-#include <string>
-#include <array>
 
 namespace wowee {
 namespace network {
@@ -73,8 +66,6 @@ public:
      */
     void initEncryption(const std::vector<uint8_t>& sessionKey, uint32_t build = 12340);
 
-    void tracePacketsFor(std::chrono::milliseconds duration, const std::string& reason);
-
     /**
      * Check if header encryption is enabled
      */
@@ -85,25 +76,11 @@ private:
      * Try to parse complete packets from receive buffer
      */
     void tryParsePackets();
-    void pumpNetworkIO();
-    void dispatchQueuedPackets();
-    void asyncPumpLoop();
-    void startAsyncPump();
-    void stopAsyncPump();
-    void closeSocketNoJoin();
-    void recordRecentPacket(bool outbound, uint16_t opcode, uint16_t payloadLen);
-    void dumpRecentPacketHistoryLocked(const char* reason, size_t bufferedBytes);
 
     socket_t sockfd = INVALID_SOCK;
     bool connected = false;
     bool encryptionEnabled = false;
     bool useVanillaCrypt = false;  // true = XOR cipher, false = RC4
-    bool useAsyncPump_ = true;
-    std::thread asyncPumpThread_;
-    std::atomic<bool> asyncPumpStop_{false};
-    std::atomic<bool> asyncPumpRunning_{false};
-    mutable std::mutex ioMutex_;
-    mutable std::mutex callbackMutex_;
 
     // WotLK RC4 ciphers for header encryption/decryption
     auth::RC4 encryptCipher;
@@ -117,8 +94,6 @@ private:
     size_t receiveReadOffset_ = 0;
     // Optional reused packet queue (feature-gated) to reduce per-update allocations.
     std::vector<Packet> parsedPacketsScratch_;
-    // Parsed packets waiting for callback dispatch; drained with a strict per-update budget.
-    std::deque<Packet> pendingPacketCallbacks_;
 
     // Runtime-gated network optimization toggles (default off).
     bool useFastRecvAppend_ = false;
@@ -130,17 +105,6 @@ private:
 
     // Debug-only tracing window for post-auth packet framing verification.
     int headerTracePacketsLeft = 0;
-    std::chrono::steady_clock::time_point packetTraceStart_{};
-    std::chrono::steady_clock::time_point packetTraceUntil_{};
-    std::string packetTraceReason_;
-
-    struct RecentPacketTrace {
-        std::chrono::steady_clock::time_point when{};
-        bool outbound = false;
-        uint16_t opcode = 0;
-        uint16_t payloadLen = 0;
-    };
-    std::deque<RecentPacketTrace> recentPacketHistory_;
 
     // Packet callback
     std::function<void(const Packet&)> packetCallback;
diff --git a/include/pipeline/asset_manager.hpp b/include/pipeline/asset_manager.hpp
index ca6a44c1..a32895d6 100644
--- a/include/pipeline/asset_manager.hpp
+++ b/include/pipeline/asset_manager.hpp
@@ -8,9 +8,7 @@
 #include <string>
 #include <vector>
 #include <map>
-#include <unordered_map>
 #include <mutex>
-#include <shared_mutex>
 
 namespace wowee {
 namespace pipeline {
@@ -61,15 +59,6 @@ public:
      */
     void setExpansionDataPath(const std::string& path);
 
-    /**
-     * Set a base data path to fall back to when the primary manifest
-     * does not contain a requested file.  Call this when the primary
-     * dataPath is an expansion-specific subset (e.g. Data/expansions/vanilla/)
-     * that only holds DBC overrides, not the full world asset set.
-     * @param basePath  Path to the base extraction (Data/) that has a manifest.json
-     */
-    void setBaseFallbackPath(const std::string& basePath);
-
     /**
      * Load a DBC file
      * @param name DBC file name (e.g., "Map.dbc")
@@ -77,14 +66,6 @@ public:
      */
     std::shared_ptr<DBCFile> loadDBC(const std::string& name);
 
-    /**
-     * Load a DBC file that is optional (not all expansions ship it).
-     * Returns nullptr quietly (debug-level log only) when the file is absent.
-     * @param name DBC file name (e.g., "Item.dbc")
-     * @return Loaded DBC file, or nullptr if not available
-     */
-    std::shared_ptr<DBCFile> loadDBCOptional(const std::string& name);
-
     /**
      * Get a cached DBC file
      * @param name DBC file name
@@ -155,26 +136,21 @@ private:
     AssetManifest manifest_;
     LooseFileReader looseReader_;
 
-    // Optional base-path fallback: used when manifest_ doesn't contain a file.
-    // Populated by setBaseFallbackPath(); ignored if baseFallbackDataPath_ is empty.
-    std::string    baseFallbackDataPath_;
-    AssetManifest  baseFallbackManifest_;
-
     /**
      * Resolve filesystem path: check override dir first, then base manifest.
      * Returns empty string if not found.
      */
     std::string resolveFile(const std::string& normalizedPath) const;
 
-    mutable std::shared_mutex cacheMutex;
-    std::unordered_map<std::string, std::shared_ptr<DBCFile>> dbcCache;
+    mutable std::mutex cacheMutex;
+    std::map<std::string, std::shared_ptr<DBCFile>> dbcCache;
 
     // File cache (LRU, dynamic budget based on system RAM)
     struct CachedFile {
         std::vector<uint8_t> data;
         uint64_t lastAccessTime;
     };
-    mutable std::unordered_map<std::string, CachedFile> fileCache;
+    mutable std::map<std::string, CachedFile> fileCache;
     mutable size_t fileCacheTotalBytes = 0;
     mutable uint64_t fileCacheAccessCounter = 0;
     mutable size_t fileCacheHits = 0;
diff --git a/include/pipeline/asset_manifest.hpp b/include/pipeline/asset_manifest.hpp
index bb5267d8..4f658646 100644
--- a/include/pipeline/asset_manifest.hpp
+++ b/include/pipeline/asset_manifest.hpp
@@ -29,7 +29,7 @@ public:
      * @param manifestPath Full path to manifest.json
      * @return true if loaded successfully
      */
-    [[nodiscard]] bool load(const std::string& manifestPath);
+    bool load(const std::string& manifestPath);
 
     /**
      * Lookup an entry by normalized WoW path (lowercase, backslash)
diff --git a/include/pipeline/dbc_layout.hpp b/include/pipeline/dbc_layout.hpp
index 0bbb2b29..154aef08 100644
--- a/include/pipeline/dbc_layout.hpp
+++ b/include/pipeline/dbc_layout.hpp
@@ -57,40 +57,5 @@ inline uint32_t dbcField(const std::string& dbcName, const std::string& fieldNam
     return fm ? fm->field(fieldName) : 0xFFFFFFFF;
 }
 
-// Forward declaration
-class DBCFile;
-
-/**
- * Resolved CharSections.dbc field indices.
- *
- * Stock WotLK 3.3.5a uses: Texture1=4, Texture2=5, Texture3=6, Flags=7,
- *   VariationIndex=8, ColorIndex=9  (textures first).
- * Classic/TBC/Turtle and HD-texture WotLK use: VariationIndex=4, ColorIndex=5,
- *   Texture1=6, Texture2=7, Texture3=8, Flags=9  (variation first).
- *
- * detectCharSectionsFields() auto-detects which layout the actual DBC uses
- * by sampling field-4 values: small integers (0-15) => variation-first,
- * large values (string offsets) => texture-first.
- */
-struct CharSectionsFields {
-    uint32_t raceId         = 1;
-    uint32_t sexId          = 2;
-    uint32_t baseSection    = 3;
-    uint32_t variationIndex = 4;
-    uint32_t colorIndex     = 5;
-    uint32_t texture1       = 6;
-    uint32_t texture2       = 7;
-    uint32_t texture3       = 8;
-    uint32_t flags          = 9;
-};
-
-/**
- * Detect the actual CharSections.dbc field layout by probing record data.
- * @param dbc  Loaded CharSections.dbc file (must not be null).
- * @param csL  JSON-derived field map (may be null — defaults used).
- * @return Resolved field indices for this particular DBC binary.
- */
-CharSectionsFields detectCharSectionsFields(const DBCFile* dbc, const DBCFieldMap* csL);
-
 } // namespace pipeline
 } // namespace wowee
diff --git a/include/pipeline/dbc_loader.hpp b/include/pipeline/dbc_loader.hpp
index 49f9df63..1651e5d2 100644
--- a/include/pipeline/dbc_loader.hpp
+++ b/include/pipeline/dbc_loader.hpp
@@ -1,14 +1,11 @@
 #pragma once
 
 #include <vector>
-#include <unordered_map>
+#include <map>
 #include <string>
-#include <string_view>
 #include <cstdint>
 #include <memory>
 
-#include "pipeline/dbc_layout.hpp"
-
 namespace wowee {
 namespace pipeline {
 
@@ -29,7 +26,7 @@ public:
      * @param dbcData Raw DBC file data
      * @return true if loaded successfully
      */
-    [[nodiscard]] bool load(const std::vector<uint8_t>& dbcData);
+    bool load(const std::vector<uint8_t>& dbcData);
 
     /**
      * Check if DBC is loaded
@@ -95,11 +92,6 @@ public:
      */
     std::string getString(uint32_t recordIndex, uint32_t fieldIndex) const;
 
-    /**
-     * Get a string field as a view (no allocation; valid while this DBCFile lives)
-     */
-    std::string_view getStringView(uint32_t recordIndex, uint32_t fieldIndex) const;
-
     /**
      * Get string by offset in string block
      * @param offset Offset into string block
@@ -107,11 +99,6 @@ public:
      */
     std::string getStringByOffset(uint32_t offset) const;
 
-    /**
-     * Get string by offset as a view (no allocation; valid while this DBCFile lives)
-     */
-    std::string_view getStringViewByOffset(uint32_t offset) const;
-
     /**
      * Find a record by ID (assumes first field is ID)
      * @param id Record ID to find
@@ -139,7 +126,7 @@ private:
     std::vector<uint8_t> stringBlock;   // String block
 
     // Cache for record ID -> index lookup
-    mutable std::unordered_map<uint32_t, uint32_t> idToIndexCache;
+    mutable std::map<uint32_t, uint32_t> idToIndexCache;
     mutable bool idCacheBuilt = false;
 
     void buildIdCache() const;
@@ -151,28 +138,5 @@ private:
     bool loadCSV(const std::vector<uint8_t>& csvData);
 };
 
-/**
- * Build the 8-element texture region field index array for ItemDisplayInfo.dbc.
- * Classic/Turtle 23-field DBCs have textures at 14-21;
- * TBC/WotLK 25-field DBCs have textures at 15-22.
- * Detects automatically from the loaded DBC's field count.
- */
-inline void getItemDisplayInfoTextureFields(const DBCFile& dbc,
-    const DBCFieldMap* layout,
-    uint32_t (&out)[8])
-{
-    // 25-field DBCs (TBC/WotLK) shift textures +1 vs 23-field (Classic/Turtle)
-    uint32_t base = (dbc.getFieldCount() >= 25) ? 15u : 14u;
-    if (layout) {
-        uint32_t idx = layout->field("TextureArmUpper");
-        if (idx != 0xFFFFFFFF) {
-            base = idx;
-            // Correct JSON layouts written for 23-field when DBC is actually 25-field
-            if (base == 14 && dbc.getFieldCount() >= 25) base = 15;
-        }
-    }
-    for (int i = 0; i < 8; i++) out[i] = base + static_cast<uint32_t>(i);
-}
-
 } // namespace pipeline
 } // namespace wowee
diff --git a/include/pipeline/m2_loader.hpp b/include/pipeline/m2_loader.hpp
index 185ca653..d3949f88 100644
--- a/include/pipeline/m2_loader.hpp
+++ b/include/pipeline/m2_loader.hpp
@@ -165,29 +165,6 @@ struct M2ParticleEmitter {
     bool enabled = true;
 };
 
-// Ribbon emitter definition parsed from M2 (WotLK format)
-struct M2RibbonEmitter {
-    int32_t  ribbonId   = 0;
-    uint32_t bone       = 0;        // Bone that drives the ribbon spine
-    glm::vec3 position{0.0f};       // Offset from bone pivot
-
-    uint16_t textureIndex  = 0;     // First texture lookup index
-    uint16_t materialIndex = 0;     // First material lookup index (blend mode)
-
-    // Animated tracks
-    M2AnimationTrack colorTrack;       // RGB 0..1
-    M2AnimationTrack alphaTrack;       // float 0..1 (stored as fixed16 on disk)
-    M2AnimationTrack heightAboveTrack; // Half-width above bone
-    M2AnimationTrack heightBelowTrack; // Half-width below bone
-    M2AnimationTrack visibilityTrack;  // 0=hidden, 1=visible
-
-    float edgesPerSecond = 15.0f;   // How many edge points are generated per second
-    float edgeLifetime   = 0.5f;    // Seconds before edges expire
-    float gravity        = 0.0f;    // Downward pull on edges per s²
-    uint16_t textureRows = 1;
-    uint16_t textureCols = 1;
-};
-
 // Complete M2 model structure
 struct M2Model {
     // Model metadata
@@ -236,9 +213,6 @@ struct M2Model {
     // Particle emitters
     std::vector<M2ParticleEmitter> particleEmitters;
 
-    // Ribbon emitters
-    std::vector<M2RibbonEmitter> ribbonEmitters;
-
     // Collision mesh (simplified geometry for physics)
     std::vector<glm::vec3> collisionVertices;
     std::vector<uint16_t> collisionIndices;      // 3 per triangle
diff --git a/include/pipeline/mpq_manager.hpp b/include/pipeline/mpq_manager.hpp
new file mode 100644
index 00000000..7de542ff
--- /dev/null
+++ b/include/pipeline/mpq_manager.hpp
@@ -0,0 +1,128 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <cstdint>
+#include <memory>
+#include <map>
+#include <unordered_map>
+#include <unordered_set>
+#include <mutex>
+
+// Forward declare StormLib handle
+typedef void* HANDLE;
+
+namespace wowee {
+namespace pipeline {
+
+/**
+ * MPQManager - Manages MPQ archive loading and file reading
+ *
+ * WoW 3.3.5a stores all game assets in MPQ archives.
+ * This manager loads multiple archives and provides unified file access.
+ */
+class MPQManager {
+public:
+    MPQManager();
+    ~MPQManager();
+
+    /**
+     * Initialize the MPQ system
+     * @param dataPath Path to WoW Data directory
+     * @return true if initialization succeeded
+     */
+    bool initialize(const std::string& dataPath);
+
+    /**
+     * Shutdown and close all archives
+     */
+    void shutdown();
+
+    /**
+     * Load a single MPQ archive
+     * @param path Full path to MPQ file
+     * @param priority Priority for file resolution (higher = checked first)
+     * @return true if archive loaded successfully
+     */
+    bool loadArchive(const std::string& path, int priority = 0);
+
+    /**
+     * Check if a file exists in any loaded archive
+     * @param filename Virtual file path (e.g., "World\\Maps\\Azeroth\\Azeroth.wdt")
+     * @return true if file exists
+     */
+    bool fileExists(const std::string& filename) const;
+
+    /**
+     * Read a file from MPQ archives
+     * @param filename Virtual file path
+     * @return File contents as byte vector (empty if not found)
+     */
+    std::vector<uint8_t> readFile(const std::string& filename) const;
+
+    /**
+     * Get file size without reading it
+     * @param filename Virtual file path
+     * @return File size in bytes (0 if not found)
+     */
+    uint32_t getFileSize(const std::string& filename) const;
+
+    /**
+     * Check if MPQ system is initialized
+     */
+    bool isInitialized() const { return initialized; }
+
+    /**
+     * Get list of loaded archives
+     */
+    const std::vector<std::string>& getLoadedArchives() const { return archiveNames; }
+
+private:
+    struct ArchiveEntry {
+        HANDLE handle;
+        std::string path;
+        int priority;
+    };
+
+    bool initialized = false;
+    std::string dataPath;
+    std::vector<ArchiveEntry> archives;
+    std::vector<std::string> archiveNames;
+
+    /**
+     * Find archive containing a file
+     * @param filename File to search for
+     * @return Archive handle or nullptr if not found
+     */
+    HANDLE findFileArchive(const std::string& filename) const;
+
+    /**
+     * Load patch archives (e.g., patch.MPQ, patch-2.MPQ, etc.)
+     */
+    bool loadPatchArchives();
+
+    /**
+     * Load locale-specific archives
+     * @param locale Locale string (e.g., "enUS")
+     */
+    bool loadLocaleArchives(const std::string& locale);
+
+    void logMissingFileOnce(const std::string& filename) const;
+
+    // Cache for mapping "virtual filename" -> archive handle (or INVALID_HANDLE_VALUE for not found).
+    // This avoids scanning every archive for repeated lookups, which can otherwise appear as a hang
+    // on screens that trigger many asset probes (character select, character preview, etc.).
+    //
+    // Important: caching misses can blow up memory if the game probes many unique non-existent filenames.
+    // Miss caching is disabled by default and must be explicitly enabled.
+    mutable std::mutex fileArchiveCacheMutex_;
+    mutable std::unordered_map<std::string, HANDLE> fileArchiveCache_;
+    size_t fileArchiveCacheMaxEntries_ = 500000;
+    bool fileArchiveCacheMisses_ = false;
+
+    mutable std::mutex missingFileMutex_;
+    mutable std::unordered_set<std::string> missingFileWarnings_;
+};
+
+} // namespace pipeline
+} // namespace wowee
diff --git a/include/pipeline/wmo_loader.hpp b/include/pipeline/wmo_loader.hpp
index 4b952b5b..ed2cf149 100644
--- a/include/pipeline/wmo_loader.hpp
+++ b/include/pipeline/wmo_loader.hpp
@@ -185,7 +185,6 @@ struct WMOModel {
     uint32_t nDoodadDefs;
     uint32_t nDoodadSets;
 
-    glm::vec3 ambientColor;     // MOHD ambient color (used for interior group lighting)
     glm::vec3 boundingBoxMin;
     glm::vec3 boundingBoxMax;
 
diff --git a/include/rendering/animation/activity_fsm.hpp b/include/rendering/animation/activity_fsm.hpp
deleted file mode 100644
index f5a3a33a..00000000
--- a/include/rendering/animation/activity_fsm.hpp
+++ /dev/null
@@ -1,110 +0,0 @@
-#pragma once
-
-#include "rendering/animation/anim_capability_set.hpp"
-#include "rendering/animation/anim_event.hpp"
-#include <cstdint>
-#include <string>
-
-namespace wowee {
-namespace rendering {
-
-// ============================================================================
-// ActivityFSM
-//
-// Pure logic state machine for non-combat activities: emote, loot, sit/sleep/kneel.
-// Sit chain (down → loop → up) auto-advances on one-shot completion.
-// All activities cancel on movement.
-// ============================================================================
-class ActivityFSM {
-public:
-    enum class State : uint8_t {
-        NONE,
-        EMOTE,
-        LOOTING,        // One-shot LOOT anim
-        LOOT_KNEELING,  // KNEEL_LOOP until loot window closes
-        LOOT_END,       // One-shot KNEEL_END exit anim
-        SIT_DOWN,
-        SITTING,
-        SIT_UP,
-    };
-
-    struct Input {
-        bool moving = false;
-        bool sprinting = false;
-        bool jumping = false;
-        bool grounded = true;
-        bool swimming = false;
-        bool sitting = false;    // Camera controller sitting state
-        bool stunned = false;
-        // Animation state query for one-shot completion detection
-        uint32_t currentAnimId = 0;
-        float currentAnimTime = 0.0f;
-        float currentAnimDuration = 0.0f;
-        bool haveAnimState = false;
-    };
-
-    void onEvent(AnimEvent event);
-
-    /// Evaluate current state against input and capabilities.
-    AnimOutput resolve(const Input& in, const AnimCapabilitySet& caps);
-
-    State getState() const { return state_; }
-    void setState(State s) { state_ = s; }
-    bool isActive() const { return state_ != State::NONE; }
-    void reset();
-
-    // ── Emote management ────────────────────────────────────────────────
-    void startEmote(uint32_t animId, bool loop);
-    void cancelEmote();
-    bool isEmoteActive() const { return emoteActive_; }
-    uint32_t getEmoteAnimId() const { return emoteAnimId_; }
-
-    // ── Sit/sleep/kneel management ──────────────────────────────────────
-    // WoW UnitStandStateType constants
-    static constexpr uint8_t STAND_STATE_STAND    = 0;
-    static constexpr uint8_t STAND_STATE_SIT      = 1;
-    static constexpr uint8_t STAND_STATE_SIT_CHAIR = 2;
-    static constexpr uint8_t STAND_STATE_SLEEP    = 3;
-    static constexpr uint8_t STAND_STATE_SIT_LOW  = 4;
-    static constexpr uint8_t STAND_STATE_SIT_MED  = 5;
-    static constexpr uint8_t STAND_STATE_SIT_HIGH = 6;
-    static constexpr uint8_t STAND_STATE_DEAD     = 7;
-    static constexpr uint8_t STAND_STATE_KNEEL    = 8;
-
-    void setStandState(uint8_t standState);
-    uint8_t getStandState() const { return standState_; }
-
-    // ── Loot management ─────────────────────────────────────────────────
-    void startLooting();
-    void stopLooting();
-
-    static constexpr uint8_t PRIORITY = 30;
-
-private:
-    State state_ = State::NONE;
-
-    // Emote state
-    bool emoteActive_ = false;
-    uint32_t emoteAnimId_ = 0;
-    bool emoteLoop_ = false;
-
-    // Sit/sleep/kneel transition animations
-    uint8_t standState_ = 0;
-    uint32_t sitDownAnim_ = 0;
-    uint32_t sitLoopAnim_ = 0;
-    uint32_t sitUpAnim_ = 0;
-    bool sitDownAnimSeen_ = false;  // Track whether one-shot has started playing
-    bool sitUpAnimSeen_ = false;
-    uint8_t sitDownFrames_ = 0;    // Frames spent in SIT_DOWN (for safety timeout)
-    uint8_t sitUpFrames_ = 0;      // Frames spent in SIT_UP
-    bool lootAnimSeen_ = false;
-    uint8_t lootFrames_ = 0;
-    bool lootEndAnimSeen_ = false;
-    uint8_t lootEndFrames_ = 0;
-
-    void updateTransitions(const Input& in);
-    bool oneShotComplete(const Input& in, uint32_t expectedAnimId) const;
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/anim_capability_probe.hpp b/include/rendering/animation/anim_capability_probe.hpp
deleted file mode 100644
index b0e41574..00000000
--- a/include/rendering/animation/anim_capability_probe.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <vector>
-#include "rendering/animation/anim_capability_set.hpp"
-
-namespace wowee {
-namespace rendering {
-
-class Renderer;
-
-// ============================================================================
-// AnimCapabilityProbe
-//
-// Scans a model's animation sequences once and caches the results in an
-// AnimCapabilitySet. All animation selection then uses the probed set
-// instead of per-frame hasAnimation() calls.
-// ============================================================================
-class AnimCapabilityProbe {
-public:
-    AnimCapabilityProbe() = default;
-
-    /// Probe all animation capabilities for the given character instance.
-    /// Returns a fully-populated AnimCapabilitySet.
-    static AnimCapabilitySet probe(Renderer* renderer, uint32_t instanceId);
-
-    /// Probe mount animation capabilities (separate model).
-    static AnimCapabilitySet probeMountModel(Renderer* renderer, uint32_t mountInstanceId);
-
-private:
-    /// Pick the first available animation from candidates for the given instance.
-    /// Returns 0 if none available.
-    static uint32_t pickFirst(Renderer* renderer, uint32_t instanceId,
-                              const uint32_t* candidates, size_t count);
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/anim_capability_set.hpp b/include/rendering/animation/anim_capability_set.hpp
deleted file mode 100644
index dd7d770f..00000000
--- a/include/rendering/animation/anim_capability_set.hpp
+++ /dev/null
@@ -1,147 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace wowee {
-namespace rendering {
-
-// ============================================================================
-// AnimFallbackPolicy
-//
-// Controls what happens when a requested animation is unavailable.
-// ============================================================================
-enum class AnimFallbackPolicy : uint8_t {
-    STAY_IN_STATE,     // Keep current animation (default for player)
-    FIRST_AVAILABLE,   // Try candidates list, stay if all fail
-    NONE,              // Do nothing (default for expired queue)
-};
-
-// ============================================================================
-// AnimOutput
-//
-// Unified animation selection result. When valid=false, callers should
-// keep the currently playing animation (STAY_IN_STATE policy).
-// ============================================================================
-struct AnimOutput {
-    uint32_t animId = 0;
-    bool loop = false;
-    bool valid = false;
-
-    /// Construct a valid output.
-    static AnimOutput ok(uint32_t id, bool looping) {
-        return {id, looping, true};
-    }
-    /// Construct an invalid output (STAY policy).
-    static AnimOutput stay() {
-        return {0, false, false};
-    }
-};
-
-// ============================================================================
-// AnimCapabilitySet
-//
-// Probed once per model load. Caches which animations a model supports
-// and the resolved IDs (after fallback chains). This eliminates per-frame
-// hasAnimation() calls.
-// ============================================================================
-struct AnimCapabilitySet {
-    // ── Locomotion resolved IDs ─────────────────────────────────────────
-    uint32_t resolvedStand = 0;
-    uint32_t resolvedWalk = 0;
-    uint32_t resolvedRun = 0;
-    uint32_t resolvedSprint = 0;
-    uint32_t resolvedWalkBackwards = 0;
-    uint32_t resolvedStrafeLeft = 0;
-    uint32_t resolvedStrafeRight = 0;
-    uint32_t resolvedRunLeft = 0;
-    uint32_t resolvedRunRight = 0;
-    uint32_t resolvedJumpStart = 0;
-    uint32_t resolvedJump = 0;       // Mid-air loop
-    uint32_t resolvedJumpEnd = 0;
-    uint32_t resolvedSwimIdle = 0;
-    uint32_t resolvedSwim = 0;
-    uint32_t resolvedSwimBackwards = 0;
-    uint32_t resolvedSwimLeft = 0;
-    uint32_t resolvedSwimRight = 0;
-
-    // ── Combat resolved IDs ─────────────────────────────────────────────
-    uint32_t resolvedCombatIdle = 0;
-    uint32_t resolvedMelee1H = 0;
-    uint32_t resolvedMelee2H = 0;
-    uint32_t resolvedMelee2HLoose = 0;
-    uint32_t resolvedMeleeUnarmed = 0;
-    uint32_t resolvedMeleeFist = 0;
-    uint32_t resolvedMeleePierce = 0;   // Dagger
-    uint32_t resolvedMeleeOffHand = 0;
-    uint32_t resolvedMeleeOffHandFist = 0;
-    uint32_t resolvedMeleeOffHandPierce = 0;
-    uint32_t resolvedMeleeOffHandUnarmed = 0;
-
-    // ── Ready stances ───────────────────────────────────────────────────
-    uint32_t resolvedReady1H = 0;
-    uint32_t resolvedReady2H = 0;
-    uint32_t resolvedReady2HLoose = 0;
-    uint32_t resolvedReadyUnarmed = 0;
-    uint32_t resolvedReadyFist = 0;
-    uint32_t resolvedReadyBow = 0;
-    uint32_t resolvedReadyRifle = 0;
-    uint32_t resolvedReadyCrossbow = 0;
-    uint32_t resolvedReadyThrown = 0;
-
-    // ── Ranged attack resolved IDs ──────────────────────────────────────
-    uint32_t resolvedFireBow = 0;
-    uint32_t resolvedAttackRifle = 0;
-    uint32_t resolvedAttackCrossbow = 0;
-    uint32_t resolvedAttackThrown = 0;
-    uint32_t resolvedLoadBow = 0;
-    uint32_t resolvedLoadRifle = 0;
-
-    // ── Special attacks ─────────────────────────────────────────────────
-    uint32_t resolvedSpecial1H = 0;
-    uint32_t resolvedSpecial2H = 0;
-    uint32_t resolvedSpecialUnarmed = 0;
-    uint32_t resolvedShieldBash = 0;
-
-    // ── Activity resolved IDs ───────────────────────────────────────────
-    uint32_t resolvedStandWound = 0;
-    uint32_t resolvedSitDown = 0;
-    uint32_t resolvedSitLoop = 0;
-    uint32_t resolvedSitUp = 0;
-    uint32_t resolvedKneel = 0;
-    uint32_t resolvedDeath = 0;
-
-    // ── Stealth ─────────────────────────────────────────────────────────
-    uint32_t resolvedStealthIdle = 0;
-    uint32_t resolvedStealthWalk = 0;
-    uint32_t resolvedStealthRun = 0;
-
-    // ── Misc ────────────────────────────────────────────────────────────
-    uint32_t resolvedMount = 0;
-    uint32_t resolvedUnsheathe = 0;
-    uint32_t resolvedSheathe = 0;
-    uint32_t resolvedStun = 0;
-    uint32_t resolvedCombatWound = 0;
-    uint32_t resolvedLoot = 0;
-
-    // ── Capability flags (bitfield) ─────────────────────────────────────
-    bool hasStand : 1;
-    bool hasWalk : 1;
-    bool hasRun : 1;
-    bool hasSprint : 1;
-    bool hasWalkBackwards : 1;
-    bool hasJump : 1;
-    bool hasSwim : 1;
-    bool hasMelee : 1;
-    bool hasStealth : 1;
-    bool hasDeath : 1;
-    bool hasMount : 1;
-
-    // Default-initialize all flags to false
-    AnimCapabilitySet()
-        : hasStand(false), hasWalk(false), hasRun(false), hasSprint(false),
-          hasWalkBackwards(false), hasJump(false), hasSwim(false),
-          hasMelee(false), hasStealth(false), hasDeath(false), hasMount(false) {}
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/anim_event.hpp b/include/rendering/animation/anim_event.hpp
deleted file mode 100644
index dfa8b332..00000000
--- a/include/rendering/animation/anim_event.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace wowee {
-namespace rendering {
-
-// ============================================================================
-// AnimEvent
-//
-// Event-driven animation state transitions. Sub-FSMs react to these events
-// instead of polling conditions every frame.
-// ============================================================================
-enum class AnimEvent : uint8_t {
-    MOVE_START, MOVE_STOP,
-    SPRINT_START, SPRINT_STOP,
-    JUMP, LANDED,
-    SWIM_ENTER, SWIM_EXIT,
-    COMBAT_ENTER, COMBAT_EXIT,
-    STUN_ENTER, STUN_EXIT,
-    SPELL_START, SPELL_STOP,
-    HIT_REACT, CHARGE_START, CHARGE_END,
-    EMOTE_START, EMOTE_STOP,
-    LOOT_START, LOOT_STOP,
-    SIT, STAND_UP,
-    MOUNT, DISMOUNT,
-    STEALTH_ENTER, STEALTH_EXIT,
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/animation_ids.hpp b/include/rendering/animation/animation_ids.hpp
deleted file mode 100644
index 03836afc..00000000
--- a/include/rendering/animation/animation_ids.hpp
+++ /dev/null
@@ -1,514 +0,0 @@
-#pragma once
-// ============================================================================
-// M2 Animation IDs — AnimationData.dbc
-//
-// Complete list from https://wowdev.wiki/M2/AnimationList
-// Community names in comments describe what each animation looks like in-game.
-// Organized by World of Warcraft expansion for easier management.
-// ============================================================================
-
-#include <cstdint>
-#include <memory>
-
-namespace wowee {
-namespace pipeline { class DBCFile; }
-namespace rendering {
-namespace anim {
-
-// ============================================================================
-// Classic (Vanilla WoW 1.x) — Core character & creature animations
-// IDs 0–145
-// ============================================================================
-
-constexpr uint32_t STAND                      = 0;   // Idle standing pose
-constexpr uint32_t DEATH                      = 1;   // Death animation
-constexpr uint32_t SPELL                      = 2;   // Generic spell cast
-constexpr uint32_t STOP                       = 3;   // Transition to stop
-constexpr uint32_t WALK                       = 4;   // Walking forward
-constexpr uint32_t RUN                        = 5;   // Running forward
-constexpr uint32_t DEAD                       = 6;   // Corpse on the ground
-constexpr uint32_t RISE                       = 7;   // Rising from death (resurrection)
-constexpr uint32_t STAND_WOUND               = 8;   // Wounded idle stance
-constexpr uint32_t COMBAT_WOUND              = 9;   // Wounded combat idle
-constexpr uint32_t COMBAT_CRITICAL           = 10;  // Critical hit reaction
-constexpr uint32_t SHUFFLE_LEFT              = 11;  // Strafe walk left
-constexpr uint32_t SHUFFLE_RIGHT             = 12;  // Strafe walk right
-constexpr uint32_t WALK_BACKWARDS            = 13;  // Walking backwards / backpedal
-constexpr uint32_t STUN                      = 14;  // Stunned
-constexpr uint32_t HANDS_CLOSED              = 15;  // Hands closed (weapon grip idle)
-constexpr uint32_t ATTACK_UNARMED            = 16;  // Unarmed melee attack
-constexpr uint32_t ATTACK_1H                 = 17;  // One-handed melee attack
-constexpr uint32_t ATTACK_2H                 = 18;  // Two-handed melee attack
-constexpr uint32_t ATTACK_2H_LOOSE           = 19;  // Polearm/staff two-hand attack
-constexpr uint32_t PARRY_UNARMED             = 20;  // Unarmed parry
-constexpr uint32_t PARRY_1H                  = 21;  // One-handed weapon parry
-constexpr uint32_t PARRY_2H                  = 22;  // Two-handed weapon parry
-constexpr uint32_t PARRY_2H_LOOSE            = 23;  // Polearm/staff parry
-constexpr uint32_t SHIELD_BLOCK              = 24;  // Shield block
-constexpr uint32_t READY_UNARMED             = 25;  // Unarmed combat ready stance
-constexpr uint32_t READY_1H                  = 26;  // One-handed weapon ready stance
-constexpr uint32_t READY_2H                  = 27;  // Two-handed weapon ready stance
-constexpr uint32_t READY_2H_LOOSE            = 28;  // Polearm/staff ready stance
-constexpr uint32_t READY_BOW                 = 29;  // Bow ready stance
-constexpr uint32_t DODGE                     = 30;  // Dodge
-constexpr uint32_t SPELL_PRECAST             = 31;  // Spell precast wind-up
-constexpr uint32_t SPELL_CAST                = 32;  // Spell cast
-constexpr uint32_t SPELL_CAST_AREA           = 33;  // Area-of-effect spell cast
-constexpr uint32_t NPC_WELCOME               = 34;  // NPC greeting animation
-constexpr uint32_t NPC_GOODBYE               = 35;  // NPC farewell animation
-constexpr uint32_t BLOCK                     = 36;  // Block
-constexpr uint32_t JUMP_START                = 37;  // Jump takeoff
-constexpr uint32_t JUMP                      = 38;  // Mid-air jump loop
-constexpr uint32_t JUMP_END                  = 39;  // Jump landing
-constexpr uint32_t FALL                      = 40;  // Falling
-constexpr uint32_t SWIM_IDLE                 = 41;  // Treading water
-constexpr uint32_t SWIM                      = 42;  // Swimming forward
-constexpr uint32_t SWIM_LEFT                 = 43;  // Swim strafe left
-constexpr uint32_t SWIM_RIGHT                = 44;  // Swim strafe right
-constexpr uint32_t SWIM_BACKWARDS            = 45;  // Swim backwards
-constexpr uint32_t ATTACK_BOW                = 46;  // Bow attack
-constexpr uint32_t FIRE_BOW                  = 47;  // Fire bow shot
-constexpr uint32_t READY_RIFLE               = 48;  // Rifle/gun ready stance
-constexpr uint32_t ATTACK_RIFLE              = 49;  // Rifle/gun attack
-constexpr uint32_t LOOT                      = 50;  // Looting / bending down to pick up
-constexpr uint32_t READY_SPELL_DIRECTED      = 51;  // Directed spell ready
-constexpr uint32_t READY_SPELL_OMNI          = 52;  // Omni spell ready
-constexpr uint32_t SPELL_CAST_DIRECTED       = 53;  // Directed spell cast
-constexpr uint32_t SPELL_CAST_OMNI           = 54;  // Omni spell cast
-constexpr uint32_t BATTLE_ROAR               = 55;  // Battle shout / roar
-constexpr uint32_t READY_ABILITY             = 56;  // Ability ready stance
-constexpr uint32_t SPECIAL_1H                = 57;  // Special one-handed attack
-constexpr uint32_t SPECIAL_2H                = 58;  // Special two-handed attack
-constexpr uint32_t SHIELD_BASH               = 59;  // Shield bash
-constexpr uint32_t EMOTE_TALK                = 60;  // /talk
-constexpr uint32_t EMOTE_EAT                 = 61;  // /eat
-constexpr uint32_t EMOTE_WORK                = 62;  // /work
-constexpr uint32_t EMOTE_USE_STANDING        = 63;  // Standing use animation
-constexpr uint32_t EMOTE_EXCLAMATION         = 64;  // NPC exclamation (!)
-constexpr uint32_t EMOTE_QUESTION            = 65;  // NPC question (?)
-constexpr uint32_t EMOTE_BOW                 = 66;  // /bow
-constexpr uint32_t EMOTE_WAVE                = 67;  // /wave
-constexpr uint32_t EMOTE_CHEER               = 68;  // /cheer
-constexpr uint32_t EMOTE_DANCE               = 69;  // /dance
-constexpr uint32_t EMOTE_LAUGH               = 70;  // /laugh
-constexpr uint32_t EMOTE_SLEEP               = 71;  // /sleep
-constexpr uint32_t EMOTE_SIT_GROUND          = 72;  // /sit on ground
-constexpr uint32_t EMOTE_RUDE                = 73;  // /rude
-constexpr uint32_t EMOTE_ROAR                = 74;  // /roar
-constexpr uint32_t EMOTE_KNEEL               = 75;  // /kneel
-constexpr uint32_t EMOTE_KISS                = 76;  // /kiss
-constexpr uint32_t EMOTE_CRY                 = 77;  // /cry
-constexpr uint32_t EMOTE_CHICKEN             = 78;  // /chicken — flap arms and strut
-constexpr uint32_t EMOTE_BEG                 = 79;  // /beg
-constexpr uint32_t EMOTE_APPLAUD             = 80;  // /applaud
-constexpr uint32_t EMOTE_SHOUT               = 81;  // /shout
-constexpr uint32_t EMOTE_FLEX                = 82;  // /flex — show off muscles
-constexpr uint32_t EMOTE_SHY                 = 83;  // /shy
-constexpr uint32_t EMOTE_POINT               = 84;  // /point
-constexpr uint32_t ATTACK_1H_PIERCE          = 85;  // One-handed pierce (dagger stab)
-constexpr uint32_t ATTACK_2H_LOOSE_PIERCE    = 86;  // Polearm/staff pierce
-constexpr uint32_t ATTACK_OFF                = 87;  // Off-hand attack
-constexpr uint32_t ATTACK_OFF_PIERCE         = 88;  // Off-hand pierce attack
-constexpr uint32_t SHEATHE                   = 89;  // Sheathe weapons
-constexpr uint32_t HIP_SHEATHE               = 90;  // Hip sheathe
-constexpr uint32_t MOUNT                     = 91;  // Mounted idle
-constexpr uint32_t RUN_RIGHT                 = 92;  // Strafe run right
-constexpr uint32_t RUN_LEFT                  = 93;  // Strafe run left
-constexpr uint32_t MOUNT_SPECIAL             = 94;  // Mount rearing / special move
-constexpr uint32_t KICK                      = 95;  // Kick
-constexpr uint32_t SIT_GROUND_DOWN           = 96;  // Transition: standing → sitting
-constexpr uint32_t SITTING                   = 97;  // Sitting on ground loop
-constexpr uint32_t SIT_GROUND_UP             = 98;  // Transition: sitting → standing
-constexpr uint32_t SLEEP_DOWN                = 99;  // Transition: standing → sleeping
-constexpr uint32_t SLEEP                     = 100; // Sleeping loop
-constexpr uint32_t SLEEP_UP                  = 101; // Transition: sleeping → standing
-constexpr uint32_t SIT_CHAIR_LOW             = 102; // Sit in low chair
-constexpr uint32_t SIT_CHAIR_MED             = 103; // Sit in medium chair
-constexpr uint32_t SIT_CHAIR_HIGH            = 104; // Sit in high chair
-constexpr uint32_t LOAD_BOW                  = 105; // Nock/load bow
-constexpr uint32_t LOAD_RIFLE               = 106; // Load rifle/gun
-constexpr uint32_t ATTACK_THROWN             = 107; // Thrown weapon attack
-constexpr uint32_t READY_THROWN              = 108; // Thrown weapon ready
-constexpr uint32_t HOLD_BOW                  = 109; // Hold bow idle
-constexpr uint32_t HOLD_RIFLE               = 110; // Hold rifle/gun idle
-constexpr uint32_t HOLD_THROWN              = 111; // Hold thrown weapon idle
-constexpr uint32_t LOAD_THROWN              = 112; // Load thrown weapon
-constexpr uint32_t EMOTE_SALUTE              = 113; // /salute
-constexpr uint32_t KNEEL_START               = 114; // Transition: standing → kneeling
-constexpr uint32_t KNEEL_LOOP                = 115; // Kneeling loop
-constexpr uint32_t KNEEL_END                 = 116; // Transition: kneeling → standing
-constexpr uint32_t ATTACK_UNARMED_OFF        = 117; // Off-hand unarmed attack
-constexpr uint32_t SPECIAL_UNARMED           = 118; // Special unarmed attack
-constexpr uint32_t STEALTH_WALK              = 119; // Stealth walking (rogue sneak)
-constexpr uint32_t STEALTH_STAND             = 120; // Stealth standing idle
-constexpr uint32_t KNOCKDOWN                 = 121; // Knocked down
-constexpr uint32_t EATING_LOOP               = 122; // Eating loop (food/drink)
-constexpr uint32_t USE_STANDING_LOOP         = 123; // Use standing loop
-constexpr uint32_t CHANNEL_CAST_DIRECTED     = 124; // Channeled directed cast
-constexpr uint32_t CHANNEL_CAST_OMNI         = 125; // Channeled omni cast
-constexpr uint32_t WHIRLWIND                 = 126; // Whirlwind attack (warrior)
-constexpr uint32_t BIRTH                     = 127; // Creature birth/spawn
-constexpr uint32_t USE_STANDING_START        = 128; // Use standing start
-constexpr uint32_t USE_STANDING_END          = 129; // Use standing end
-constexpr uint32_t CREATURE_SPECIAL          = 130; // Creature special ability
-constexpr uint32_t DROWN                     = 131; // Drowning
-constexpr uint32_t DROWNED                   = 132; // Drowned corpse underwater
-constexpr uint32_t FISHING_CAST              = 133; // Fishing cast
-constexpr uint32_t FISHING_LOOP              = 134; // Fishing idle loop
-constexpr uint32_t FLY                       = 135; // Flying generic
-constexpr uint32_t EMOTE_WORK_NO_SHEATHE     = 136; // Work emote (no weapon sheathe)
-constexpr uint32_t EMOTE_STUN_NO_SHEATHE     = 137; // Stun emote (no weapon sheathe)
-constexpr uint32_t EMOTE_USE_STANDING_NO_SHEATHE = 138; // Use standing (no weapon sheathe)
-constexpr uint32_t SPELL_SLEEP_DOWN          = 139; // Spell-induced sleep down
-constexpr uint32_t SPELL_KNEEL_START         = 140; // Spell-induced kneel start
-constexpr uint32_t SPELL_KNEEL_LOOP          = 141; // Spell-induced kneel loop
-constexpr uint32_t SPELL_KNEEL_END           = 142; // Spell-induced kneel end
-constexpr uint32_t SPRINT                    = 143; // Sprint / Custom Spell 01
-constexpr uint32_t IN_FLIGHT                 = 144; // In-flight (flight path travel)
-constexpr uint32_t SPAWN                     = 145; // Object/creature spawn animation
-
-// ============================================================================
-// The Burning Crusade (TBC 2.x) — Flying mounts, game objects, stealth run
-// IDs 146–199
-// ============================================================================
-
-constexpr uint32_t CLOSE                     = 146; // Game object close
-constexpr uint32_t CLOSED                    = 147; // Game object closed loop
-constexpr uint32_t OPEN                      = 148; // Game object open
-constexpr uint32_t DESTROY                   = 149; // Game object destroy
-constexpr uint32_t DESTROYED                 = 150; // Game object destroyed state
-constexpr uint32_t UNSHEATHE                 = 151; // Unsheathe weapons
-constexpr uint32_t SHEATHE_ALT               = 152; // Sheathe weapons (alternate)
-constexpr uint32_t ATTACK_UNARMED_NO_SHEATHE = 153; // Unarmed attack (no sheathe)
-constexpr uint32_t STEALTH_RUN               = 154; // Stealth running (rogue sprint)
-constexpr uint32_t READY_CROSSBOW            = 155; // Crossbow ready stance
-constexpr uint32_t ATTACK_CROSSBOW           = 156; // Crossbow attack
-constexpr uint32_t EMOTE_TALK_EXCLAMATION    = 157; // /talk with exclamation
-constexpr uint32_t FLY_IDLE                  = 158; // Flying mount idle / hovering
-constexpr uint32_t FLY_FORWARD               = 159; // Flying mount forward
-constexpr uint32_t FLY_BACKWARDS             = 160; // Flying mount backwards
-constexpr uint32_t FLY_LEFT                  = 161; // Flying mount strafe left
-constexpr uint32_t FLY_RIGHT                 = 162; // Flying mount strafe right
-constexpr uint32_t FLY_UP                    = 163; // Flying mount ascending
-constexpr uint32_t FLY_DOWN                  = 164; // Flying mount descending
-constexpr uint32_t FLY_LAND_START            = 165; // Flying mount land start
-constexpr uint32_t FLY_LAND_RUN              = 166; // Flying mount land run
-constexpr uint32_t FLY_LAND_END              = 167; // Flying mount land end
-constexpr uint32_t EMOTE_TALK_QUESTION       = 168; // /talk with question
-constexpr uint32_t EMOTE_READ                = 169; // /read (reading animation)
-constexpr uint32_t EMOTE_SHIELDBLOCK         = 170; // Shield block emote
-constexpr uint32_t EMOTE_CHOP                = 171; // Chopping emote (lumber)
-constexpr uint32_t EMOTE_HOLDRIFLE           = 172; // Hold rifle emote
-constexpr uint32_t EMOTE_HOLDBOW             = 173; // Hold bow emote
-constexpr uint32_t EMOTE_HOLDTHROWN          = 174; // Hold thrown weapon emote
-constexpr uint32_t CUSTOM_SPELL_02           = 175; // Custom spell animation 02
-constexpr uint32_t CUSTOM_SPELL_03           = 176; // Custom spell animation 03
-constexpr uint32_t CUSTOM_SPELL_04           = 177; // Custom spell animation 04
-constexpr uint32_t CUSTOM_SPELL_05           = 178; // Custom spell animation 05
-constexpr uint32_t CUSTOM_SPELL_06           = 179; // Custom spell animation 06
-constexpr uint32_t CUSTOM_SPELL_07           = 180; // Custom spell animation 07
-constexpr uint32_t CUSTOM_SPELL_08           = 181; // Custom spell animation 08
-constexpr uint32_t CUSTOM_SPELL_09           = 182; // Custom spell animation 09
-constexpr uint32_t CUSTOM_SPELL_10           = 183; // Custom spell animation 10
-constexpr uint32_t EMOTE_STATE_DANCE         = 184; // /dance state (looping dance)
-
-// ============================================================================
-// Wrath of the Lich King (WotLK 3.x) — Vehicles, reclined, crafting, etc.
-// IDs 185+
-// ============================================================================
-
-constexpr uint32_t FLY_STAND                 = 185; // Flying stand (hover in place)
-constexpr uint32_t EMOTE_STATE_LAUGH         = 186; // /laugh state loop
-constexpr uint32_t EMOTE_STATE_POINT         = 187; // /point state loop
-constexpr uint32_t EMOTE_STATE_EAT           = 188; // /eat state loop
-constexpr uint32_t EMOTE_STATE_WORK          = 189; // /work state loop (crafting NPC)
-constexpr uint32_t EMOTE_STATE_SIT_GROUND    = 190; // /sit ground state loop
-constexpr uint32_t EMOTE_STATE_HOLD_BOW      = 191; // Hold bow state loop
-constexpr uint32_t EMOTE_STATE_HOLD_RIFLE    = 192; // Hold rifle state loop
-constexpr uint32_t EMOTE_STATE_HOLD_THROWN   = 193; // Hold thrown state loop
-constexpr uint32_t FLY_COMBAT_WOUND          = 194; // Flying wounded
-constexpr uint32_t FLY_COMBAT_CRITICAL       = 195; // Flying critical hit reaction
-constexpr uint32_t RECLINED                  = 196; // Reclined / laid back pose
-constexpr uint32_t EMOTE_STATE_ROAR          = 197; // /roar state loop
-constexpr uint32_t EMOTE_USE_STANDING_LOOP_2 = 198; // Use standing loop variant
-constexpr uint32_t EMOTE_STATE_APPLAUD       = 199; // /applaud state loop
-constexpr uint32_t READY_FIST                = 200; // Fist weapon ready stance
-constexpr uint32_t SPELL_CHANNEL_DIRECTED_OMNI = 201; // Channel directed omni
-constexpr uint32_t SPECIAL_ATTACK_1H_OFF     = 202; // Special off-hand one-handed attack
-constexpr uint32_t ATTACK_FIST_1H            = 203; // Fist weapon one-hand attack
-constexpr uint32_t ATTACK_FIST_1H_OFF        = 204; // Fist weapon off-hand attack
-constexpr uint32_t PARRY_FIST_1H             = 205; // Fist weapon parry
-
-constexpr uint32_t READY_FIST_1H             = 206; // Fist weapon one-hand ready
-constexpr uint32_t EMOTE_STATE_READ_AND_TALK = 207; // Read and talk NPC loop
-constexpr uint32_t EMOTE_STATE_WORK_NO_SHEATHE = 208; // Work no sheathe state loop
-constexpr uint32_t FLY_RUN                   = 209; // Flying run (fast forward flight)
-constexpr uint32_t EMOTE_STATE_KNEEL_2       = 210; // Kneel state variant
-constexpr uint32_t EMOTE_STATE_SPELL_KNEEL   = 211; // Spell kneel state loop
-constexpr uint32_t EMOTE_STATE_USE_STANDING  = 212; // Use standing state
-constexpr uint32_t EMOTE_STATE_STUN          = 213; // Stun state loop
-constexpr uint32_t EMOTE_STATE_STUN_NO_SHEATHE = 214; // Stun no sheathe state
-constexpr uint32_t EMOTE_TRAIN               = 215; // /train — choo choo!
-constexpr uint32_t EMOTE_DEAD                = 216; // /dead — play dead
-constexpr uint32_t EMOTE_STATE_DANCE_ONCE    = 217; // Single dance animation
-constexpr uint32_t FLY_DEATH                 = 218; // Flying death
-constexpr uint32_t FLY_STAND_WOUND          = 219; // Flying wounded stand
-constexpr uint32_t FLY_SHUFFLE_LEFT          = 220; // Flying strafe left
-constexpr uint32_t FLY_SHUFFLE_RIGHT         = 221; // Flying strafe right
-constexpr uint32_t FLY_WALK_BACKWARDS        = 222; // Flying walk backwards
-constexpr uint32_t FLY_STUN                  = 223; // Flying stunned
-constexpr uint32_t FLY_HANDS_CLOSED          = 224; // Flying hands closed
-constexpr uint32_t FLY_ATTACK_UNARMED        = 225; // Flying unarmed attack
-constexpr uint32_t FLY_ATTACK_1H             = 226; // Flying one-hand attack
-constexpr uint32_t FLY_ATTACK_2H             = 227; // Flying two-hand attack
-constexpr uint32_t FLY_ATTACK_2H_LOOSE       = 228; // Flying polearm attack
-constexpr uint32_t FLY_SPELL                 = 229; // Flying spell — generic spell while flying
-constexpr uint32_t FLY_STOP                  = 230; // Flying stop
-constexpr uint32_t FLY_WALK                  = 231; // Flying walk
-constexpr uint32_t FLY_DEAD                  = 232; // Flying dead (corpse mid-air)
-constexpr uint32_t FLY_RISE                  = 233; // Flying rise — resurrection mid-air
-constexpr uint32_t FLY_RUN_2                 = 234; // Flying run variant
-constexpr uint32_t FLY_FALL                  = 235; // Flying fall
-constexpr uint32_t FLY_SWIM_IDLE             = 236; // Flying swim idle
-constexpr uint32_t FLY_SWIM                  = 237; // Flying swim
-constexpr uint32_t FLY_SWIM_LEFT             = 238; // Flying swim left
-constexpr uint32_t FLY_SWIM_RIGHT            = 239; // Flying swim right
-constexpr uint32_t FLY_SWIM_BACKWARDS        = 240; // Flying swim backwards
-constexpr uint32_t FLY_ATTACK_BOW            = 241; // Flying bow attack
-constexpr uint32_t FLY_FIRE_BOW              = 242; // Flying fire bow
-constexpr uint32_t FLY_READY_RIFLE           = 243; // Flying rifle ready
-constexpr uint32_t FLY_ATTACK_RIFLE          = 244; // Flying rifle attack
-
-// ── WotLK Vehicle & extended movement animations ──────────────────────────
-
-constexpr uint32_t TOTEM_SMALL               = 245; // Small totem idle (shaman)
-constexpr uint32_t TOTEM_MEDIUM              = 246; // Medium totem idle
-constexpr uint32_t TOTEM_LARGE               = 247; // Large totem idle
-constexpr uint32_t FLY_LOOT                  = 248; // Flying loot
-constexpr uint32_t FLY_READY_SPELL_DIRECTED  = 249; // Flying directed spell ready
-constexpr uint32_t FLY_READY_SPELL_OMNI      = 250; // Flying omni spell ready
-constexpr uint32_t FLY_SPELL_CAST_DIRECTED   = 251; // Flying directed spell cast
-constexpr uint32_t FLY_SPELL_CAST_OMNI       = 252; // Flying omni spell cast
-constexpr uint32_t FLY_BATTLE_ROAR           = 253; // Flying battle shout
-constexpr uint32_t FLY_READY_ABILITY         = 254; // Flying ability ready
-constexpr uint32_t FLY_SPECIAL_1H            = 255; // Flying special one-hand
-constexpr uint32_t FLY_SPECIAL_2H            = 256; // Flying special two-hand
-constexpr uint32_t FLY_SHIELD_BASH           = 257; // Flying shield bash
-constexpr uint32_t FLY_EMOTE_TALK            = 258; // Flying emote talk
-constexpr uint32_t FLY_EMOTE_EAT             = 259; // Flying emote eat
-constexpr uint32_t FLY_EMOTE_WORK            = 260; // Flying emote work
-constexpr uint32_t FLY_EMOTE_USE_STANDING    = 261; // Flying emote use standing
-constexpr uint32_t FLY_EMOTE_BOW             = 262; // Flying emote bow
-constexpr uint32_t FLY_EMOTE_WAVE            = 263; // Flying emote wave
-constexpr uint32_t FLY_EMOTE_CHEER           = 264; // Flying emote cheer
-constexpr uint32_t FLY_EMOTE_DANCE           = 265; // Flying emote dance
-constexpr uint32_t FLY_EMOTE_LAUGH           = 266; // Flying emote laugh
-constexpr uint32_t FLY_EMOTE_SLEEP           = 267; // Flying emote sleep
-constexpr uint32_t FLY_EMOTE_SIT_GROUND      = 268; // Flying emote sit ground
-constexpr uint32_t FLY_EMOTE_RUDE            = 269; // Flying emote rude
-constexpr uint32_t FLY_EMOTE_ROAR            = 270; // Flying emote roar
-constexpr uint32_t FLY_EMOTE_KNEEL           = 271; // Flying emote kneel
-constexpr uint32_t FLY_EMOTE_KISS            = 272; // Flying emote kiss
-constexpr uint32_t FLY_EMOTE_CRY             = 273; // Flying emote cry
-constexpr uint32_t FLY_EMOTE_CHICKEN         = 274; // Flying emote chicken
-constexpr uint32_t FLY_EMOTE_BEG             = 275; // Flying emote beg
-constexpr uint32_t FLY_EMOTE_APPLAUD         = 276; // Flying emote applaud
-constexpr uint32_t FLY_EMOTE_SHOUT           = 277; // Flying emote shout
-constexpr uint32_t FLY_EMOTE_FLEX            = 278; // Flying emote flex
-constexpr uint32_t FLY_EMOTE_SHY             = 279; // Flying emote shy
-constexpr uint32_t FLY_EMOTE_POINT           = 280; // Flying emote point
-constexpr uint32_t FLY_ATTACK_1H_PIERCE      = 281; // Flying one-hand pierce
-constexpr uint32_t FLY_ATTACK_2H_LOOSE_PIERCE = 282; // Flying polearm pierce
-constexpr uint32_t FLY_ATTACK_OFF            = 283; // Flying off-hand attack
-constexpr uint32_t FLY_ATTACK_OFF_PIERCE     = 284; // Flying off-hand pierce
-constexpr uint32_t FLY_SHEATHE               = 285; // Flying sheathe
-constexpr uint32_t FLY_HIP_SHEATHE           = 286; // Flying hip sheathe
-constexpr uint32_t FLY_MOUNT                 = 287; // Flying mounted
-constexpr uint32_t FLY_RUN_RIGHT             = 288; // Flying strafe run right
-constexpr uint32_t FLY_RUN_LEFT              = 289; // Flying strafe run left
-constexpr uint32_t FLY_MOUNT_SPECIAL         = 290; // Flying mount special
-constexpr uint32_t FLY_KICK                  = 291; // Flying kick
-constexpr uint32_t FLY_SIT_GROUND_DOWN       = 292; // Flying sit ground down
-constexpr uint32_t FLY_SITTING               = 293; // Flying sitting
-constexpr uint32_t FLY_SIT_GROUND_UP         = 294; // Flying sit ground up
-constexpr uint32_t FLY_SLEEP_DOWN            = 295; // Flying sleep down
-constexpr uint32_t FLY_SLEEP                 = 296; // Flying sleeping
-constexpr uint32_t FLY_SLEEP_UP              = 297; // Flying sleep up
-constexpr uint32_t FLY_SIT_CHAIR_LOW         = 298; // Flying sit chair low
-constexpr uint32_t FLY_SIT_CHAIR_MED         = 299; // Flying sit chair med
-constexpr uint32_t FLY_SIT_CHAIR_HIGH        = 300; // Flying sit chair high
-constexpr uint32_t FLY_LOAD_BOW              = 301; // Flying load bow
-constexpr uint32_t FLY_LOAD_RIFLE            = 302; // Flying load rifle
-constexpr uint32_t FLY_ATTACK_THROWN          = 303; // Flying thrown attack
-constexpr uint32_t FLY_READY_THROWN           = 304; // Flying thrown ready
-constexpr uint32_t FLY_HOLD_BOW              = 305; // Flying hold bow
-constexpr uint32_t FLY_HOLD_RIFLE            = 306; // Flying hold rifle
-constexpr uint32_t FLY_HOLD_THROWN           = 307; // Flying hold thrown
-constexpr uint32_t FLY_LOAD_THROWN           = 308; // Flying load thrown
-constexpr uint32_t FLY_EMOTE_SALUTE          = 309; // Flying emote salute
-constexpr uint32_t FLY_KNEEL_START           = 310; // Flying kneel start
-constexpr uint32_t FLY_KNEEL_LOOP            = 311; // Flying kneel loop
-constexpr uint32_t FLY_KNEEL_END             = 312; // Flying kneel end
-constexpr uint32_t FLY_ATTACK_UNARMED_OFF    = 313; // Flying off-hand unarmed
-constexpr uint32_t FLY_SPECIAL_UNARMED       = 314; // Flying special unarmed
-constexpr uint32_t FLY_STEALTH_WALK          = 315; // Flying stealth walk
-constexpr uint32_t FLY_STEALTH_STAND         = 316; // Flying stealth stand
-constexpr uint32_t FLY_KNOCKDOWN             = 317; // Flying knockdown
-constexpr uint32_t FLY_EATING_LOOP           = 318; // Flying eating loop
-constexpr uint32_t FLY_USE_STANDING_LOOP     = 319; // Flying use standing loop
-constexpr uint32_t FLY_CHANNEL_CAST_DIRECTED = 320; // Flying directed channel
-constexpr uint32_t FLY_CHANNEL_CAST_OMNI     = 321; // Flying omni channel
-constexpr uint32_t FLY_WHIRLWIND             = 322; // Flying whirlwind
-constexpr uint32_t FLY_BIRTH                 = 323; // Flying birth/spawn
-constexpr uint32_t FLY_USE_STANDING_START    = 324; // Flying use standing start
-constexpr uint32_t FLY_USE_STANDING_END      = 325; // Flying use standing end
-constexpr uint32_t FLY_CREATURE_SPECIAL      = 326; // Flying creature special
-constexpr uint32_t FLY_DROWN                 = 327; // Flying drown
-constexpr uint32_t FLY_DROWNED               = 328; // Flying drowned
-constexpr uint32_t FLY_FISHING_CAST          = 329; // Flying fishing cast
-constexpr uint32_t FLY_FISHING_LOOP          = 330; // Flying fishing loop
-constexpr uint32_t FLY_FLY                   = 331; // Flying fly
-constexpr uint32_t FLY_EMOTE_WORK_NO_SHEATHE = 332; // Flying work no sheathe
-constexpr uint32_t FLY_EMOTE_STUN_NO_SHEATHE = 333; // Flying stun no sheathe
-constexpr uint32_t FLY_EMOTE_USE_STANDING_NO_SHEATHE = 334; // Flying use standing no sheathe
-constexpr uint32_t FLY_SPELL_SLEEP_DOWN      = 335; // Flying spell sleep down
-constexpr uint32_t FLY_SPELL_KNEEL_START     = 336; // Flying spell kneel start
-constexpr uint32_t FLY_SPELL_KNEEL_LOOP      = 337; // Flying spell kneel loop
-constexpr uint32_t FLY_SPELL_KNEEL_END       = 338; // Flying spell kneel end
-constexpr uint32_t FLY_SPRINT                = 339; // Flying sprint
-constexpr uint32_t FLY_IN_FLIGHT             = 340; // Flying in-flight
-constexpr uint32_t FLY_SPAWN                 = 341; // Flying spawn
-constexpr uint32_t FLY_CLOSE                 = 342; // Flying close
-constexpr uint32_t FLY_CLOSED                = 343; // Flying closed
-constexpr uint32_t FLY_OPEN                  = 344; // Flying open
-constexpr uint32_t FLY_DESTROY               = 345; // Flying destroy
-constexpr uint32_t FLY_DESTROYED             = 346; // Flying destroyed
-constexpr uint32_t FLY_UNSHEATHE             = 347; // Flying unsheathe
-constexpr uint32_t FLY_SHEATHE_ALT           = 348; // Flying sheathe alt
-constexpr uint32_t FLY_ATTACK_UNARMED_NO_SHEATHE = 349; // Flying unarmed no sheathe
-constexpr uint32_t FLY_STEALTH_RUN           = 350; // Flying stealth run
-constexpr uint32_t FLY_READY_CROSSBOW        = 351; // Flying crossbow ready
-constexpr uint32_t FLY_ATTACK_CROSSBOW       = 352; // Flying crossbow attack
-constexpr uint32_t FLY_EMOTE_TALK_EXCLAMATION = 353; // Flying talk exclamation
-constexpr uint32_t FLY_EMOTE_TALK_QUESTION   = 354; // Flying talk question
-constexpr uint32_t FLY_EMOTE_READ            = 355; // Flying emote read
-
-// ── WotLK extended creature animations ────────────────────────────────────
-
-constexpr uint32_t EMOTE_HOLD_CROSSBOW       = 356; // Hold crossbow emote
-constexpr uint32_t FLY_EMOTE_HOLD_BOW        = 357; // Flying hold bow emote
-constexpr uint32_t FLY_EMOTE_HOLD_RIFLE      = 358; // Flying hold rifle emote
-constexpr uint32_t FLY_EMOTE_HOLD_THROWN     = 359; // Flying hold thrown emote
-constexpr uint32_t FLY_EMOTE_HOLD_CROSSBOW   = 360; // Flying hold crossbow emote
-constexpr uint32_t FLY_CUSTOM_SPELL_02       = 361; // Flying custom spell 02
-constexpr uint32_t FLY_CUSTOM_SPELL_03       = 362; // Flying custom spell 03
-constexpr uint32_t FLY_CUSTOM_SPELL_04       = 363; // Flying custom spell 04
-constexpr uint32_t FLY_CUSTOM_SPELL_05       = 364; // Flying custom spell 05
-constexpr uint32_t FLY_CUSTOM_SPELL_06       = 365; // Flying custom spell 06
-constexpr uint32_t FLY_CUSTOM_SPELL_07       = 366; // Flying custom spell 07
-constexpr uint32_t FLY_CUSTOM_SPELL_08       = 367; // Flying custom spell 08
-constexpr uint32_t FLY_CUSTOM_SPELL_09       = 368; // Flying custom spell 09
-constexpr uint32_t FLY_CUSTOM_SPELL_10       = 369; // Flying custom spell 10
-constexpr uint32_t FLY_EMOTE_STATE_DANCE     = 370; // Flying dance state
-constexpr uint32_t EMOTE_EAT_NO_SHEATHE      = 371; // Eat emote (no weapon sheathe)
-constexpr uint32_t MOUNT_RUN_RIGHT           = 372; // Mounted strafe run right
-constexpr uint32_t MOUNT_RUN_LEFT            = 373; // Mounted strafe run left
-constexpr uint32_t MOUNT_WALK_BACKWARDS      = 374; // Mounted walk backwards
-constexpr uint32_t MOUNT_SWIM_IDLE           = 375; // Mounted swimming idle
-constexpr uint32_t MOUNT_SWIM                = 376; // Mounted swimming forward
-constexpr uint32_t MOUNT_SWIM_LEFT           = 377; // Mounted swimming left
-constexpr uint32_t MOUNT_SWIM_RIGHT          = 378; // Mounted swimming right
-constexpr uint32_t MOUNT_SWIM_BACKWARDS      = 379; // Mounted swimming backwards
-constexpr uint32_t MOUNT_FLIGHT_IDLE         = 380; // Mounted flight idle (hovering)
-constexpr uint32_t MOUNT_FLIGHT_FORWARD      = 381; // Mounted flight forward
-constexpr uint32_t MOUNT_FLIGHT_BACKWARDS    = 382; // Mounted flight backwards
-constexpr uint32_t MOUNT_FLIGHT_LEFT         = 383; // Mounted flight left
-constexpr uint32_t MOUNT_FLIGHT_RIGHT        = 384; // Mounted flight right
-constexpr uint32_t MOUNT_FLIGHT_UP           = 385; // Mounted flight ascending
-constexpr uint32_t MOUNT_FLIGHT_DOWN         = 386; // Mounted flight descending
-constexpr uint32_t MOUNT_FLIGHT_LAND_START   = 387; // Mounted flight land start
-constexpr uint32_t MOUNT_FLIGHT_LAND_RUN     = 388; // Mounted flight land run
-constexpr uint32_t MOUNT_FLIGHT_LAND_END     = 389; // Mounted flight land end
-constexpr uint32_t FLY_EMOTE_STATE_LAUGH     = 390; // Flying laugh state
-constexpr uint32_t FLY_EMOTE_STATE_POINT     = 391; // Flying point state
-constexpr uint32_t FLY_EMOTE_STATE_EAT       = 392; // Flying eat state
-constexpr uint32_t FLY_EMOTE_STATE_WORK      = 393; // Flying work state
-constexpr uint32_t FLY_EMOTE_STATE_SIT_GROUND = 394; // Flying sit ground state
-constexpr uint32_t FLY_EMOTE_STATE_HOLD_BOW  = 395; // Flying hold bow state
-constexpr uint32_t FLY_EMOTE_STATE_HOLD_RIFLE = 396; // Flying hold rifle state
-constexpr uint32_t FLY_EMOTE_STATE_HOLD_THROWN = 397; // Flying hold thrown state
-constexpr uint32_t FLY_EMOTE_STATE_ROAR      = 398; // Flying roar state
-constexpr uint32_t FLY_RECLINED              = 399; // Flying reclined
-constexpr uint32_t EMOTE_TRAIN_2             = 400; // /train variant — choo choo!
-constexpr uint32_t EMOTE_DEAD_2              = 401; // /dead variant (play dead)
-constexpr uint32_t FLY_EMOTE_USE_STANDING_LOOP_2 = 402; // Flying use standing loop
-constexpr uint32_t FLY_EMOTE_STATE_APPLAUD   = 403; // Flying applaud state
-constexpr uint32_t FLY_READY_FIST            = 404; // Flying fist ready
-constexpr uint32_t FLY_SPELL_CHANNEL_DIRECTED_OMNI = 405; // Flying channel directed omni
-constexpr uint32_t FLY_SPECIAL_ATTACK_1H_OFF = 406; // Flying special off-hand
-constexpr uint32_t FLY_ATTACK_FIST_1H        = 407; // Flying fist attack
-constexpr uint32_t FLY_ATTACK_FIST_1H_OFF    = 408; // Flying fist off-hand
-constexpr uint32_t FLY_PARRY_FIST_1H         = 409; // Flying fist parry
-constexpr uint32_t FLY_READY_FIST_1H         = 410; // Flying fist one-hand ready
-constexpr uint32_t FLY_EMOTE_STATE_READ_AND_TALK = 411; // Flying read and talk state
-constexpr uint32_t FLY_EMOTE_STATE_WORK_NO_SHEATHE = 412; // Flying work no sheathe state
-constexpr uint32_t FLY_EMOTE_STATE_KNEEL_2   = 413; // Flying kneel state variant
-constexpr uint32_t FLY_EMOTE_STATE_SPELL_KNEEL = 414; // Flying spell kneel state
-constexpr uint32_t FLY_EMOTE_STATE_USE_STANDING = 415; // Flying use standing state
-constexpr uint32_t FLY_EMOTE_STATE_STUN      = 416; // Flying stun state
-constexpr uint32_t FLY_EMOTE_STATE_STUN_NO_SHEATHE = 417; // Flying stun no sheathe state
-constexpr uint32_t FLY_EMOTE_TRAIN           = 418; // Flying train emote
-constexpr uint32_t FLY_EMOTE_DEAD            = 419; // Flying dead emote
-constexpr uint32_t FLY_EMOTE_STATE_DANCE_ONCE = 420; // Flying single dance
-constexpr uint32_t FLY_EMOTE_EAT_NO_SHEATHE  = 421; // Flying eat no sheathe
-constexpr uint32_t FLY_MOUNT_RUN_RIGHT       = 422; // Flying mount run right
-constexpr uint32_t FLY_MOUNT_RUN_LEFT        = 423; // Flying mount run left
-constexpr uint32_t FLY_MOUNT_WALK_BACKWARDS  = 424; // Flying mount walk backwards
-constexpr uint32_t FLY_MOUNT_SWIM_IDLE       = 425; // Flying mount swim idle
-constexpr uint32_t FLY_MOUNT_SWIM            = 426; // Flying mount swim
-constexpr uint32_t FLY_MOUNT_SWIM_LEFT       = 427; // Flying mount swim left
-constexpr uint32_t FLY_MOUNT_SWIM_RIGHT      = 428; // Flying mount swim right
-constexpr uint32_t FLY_MOUNT_SWIM_BACKWARDS  = 429; // Flying mount swim backwards
-constexpr uint32_t FLY_MOUNT_FLIGHT_IDLE     = 430; // Flying mount flight idle
-constexpr uint32_t FLY_MOUNT_FLIGHT_FORWARD  = 431; // Flying mount flight forward
-constexpr uint32_t FLY_MOUNT_FLIGHT_BACKWARDS = 432; // Flying mount flight backwards
-constexpr uint32_t FLY_MOUNT_FLIGHT_LEFT     = 433; // Flying mount flight left
-constexpr uint32_t FLY_MOUNT_FLIGHT_RIGHT    = 434; // Flying mount flight right
-constexpr uint32_t FLY_MOUNT_FLIGHT_UP       = 435; // Flying mount flight up
-constexpr uint32_t FLY_MOUNT_FLIGHT_DOWN     = 436; // Flying mount flight down
-constexpr uint32_t FLY_MOUNT_FLIGHT_LAND_START = 437; // Flying mount flight land start
-constexpr uint32_t FLY_MOUNT_FLIGHT_LAND_RUN = 438; // Flying mount flight land run
-constexpr uint32_t FLY_MOUNT_FLIGHT_LAND_END = 439; // Flying mount flight land end
-constexpr uint32_t FLY_TOTEM_SMALL           = 440; // Flying small totem
-constexpr uint32_t FLY_TOTEM_MEDIUM          = 441; // Flying medium totem
-constexpr uint32_t FLY_TOTEM_LARGE           = 442; // Flying large totem
-constexpr uint32_t FLY_EMOTE_HOLD_CROSSBOW_2 = 443; // Flying hold crossbow (variant)
-
-// ── WotLK vehicle-specific & late additions ───────────────────────────────
-
-constexpr uint32_t VEHICLE_GRAB               = 444; // Vehicle: grab object
-constexpr uint32_t VEHICLE_THROW              = 445; // Vehicle: throw object
-constexpr uint32_t FLY_VEHICLE_GRAB           = 446; // Flying vehicle grab
-constexpr uint32_t FLY_VEHICLE_THROW          = 447; // Flying vehicle throw
-constexpr uint32_t GUILD_CHAMPION_1           = 448; // Guild champion pose 1
-constexpr uint32_t GUILD_CHAMPION_2           = 449; // Guild champion pose 2
-constexpr uint32_t FLY_GUILD_CHAMPION_1       = 450; // Flying guild champion 1
-constexpr uint32_t FLY_GUILD_CHAMPION_2       = 451; // Flying guild champion 2
-
-// Total number of animation IDs (0–451 inclusive)
-constexpr uint32_t ANIM_COUNT                 = 452;
-
-/// Return the symbolic name for an animation ID (e.g. 0 → "STAND").
-/// Returns "UNKNOWN" for IDs outside the known range.
-const char* nameFromId(uint32_t id);
-
-/// Return the FLY_* variant of a ground animation ID, or 0 if none exists.
-uint32_t flyVariant(uint32_t groundId);
-
-/// Validate animation_ids.hpp constants against AnimationData.dbc.
-/// Logs warnings for IDs present in DBC but missing from constants, and vice versa.
-void validateAgainstDBC(const std::shared_ptr<wowee::pipeline::DBCFile>& dbc);
-
-} // namespace anim
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/animation_manager.hpp b/include/rendering/animation/animation_manager.hpp
deleted file mode 100644
index 7a759e09..00000000
--- a/include/rendering/animation/animation_manager.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#pragma once
-
-// Renamed from PlayerAnimator/NpcAnimator dual-map → unified CharacterAnimator registry.
-// NpcAnimator removed — all characters use the same generic CharacterAnimator.
-#include "rendering/animation/character_animator.hpp"
-#include "rendering/animation/anim_capability_set.hpp"
-#include <cstdint>
-#include <unordered_map>
-#include <memory>
-
-namespace wowee {
-namespace rendering {
-
-// ============================================================================
-// AnimationManager
-//
-// Central registry for all character animators. Owned by Renderer, replaces
-// scattered AnimationController* passing.
-//
-// Single animator type:
-//   CharacterAnimator — generic animator for any character (player, NPC,
-//                        companion). Full FSM composition with priority
-//                        resolver.
-//
-// AnimationController becomes a thin shim delegating to this manager
-// until all callsites are migrated.
-// ============================================================================
-class AnimationManager {
-public:
-    AnimationManager() = default;
-
-    // ── Character animators ─────────────────────────────────────────────
-
-    /// Get or create a CharacterAnimator for the given instance ID.
-    CharacterAnimator& getOrCreate(uint32_t instanceId);
-
-    /// Get existing CharacterAnimator (nullptr if not found).
-    CharacterAnimator* get(uint32_t instanceId);
-
-    /// Remove a character animator.
-    void remove(uint32_t instanceId);
-
-    // ── Per-frame ───────────────────────────────────────────────────────
-
-    /// Update all registered animators.
-    void updateAll(float dt);
-
-    // ── Counts ──────────────────────────────────────────────────────────
-    size_t count() const { return animators_.size(); }
-
-private:
-    std::unordered_map<uint32_t, std::unique_ptr<CharacterAnimator>> animators_;
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/character_animator.hpp b/include/rendering/animation/character_animator.hpp
deleted file mode 100644
index 56ca09ad..00000000
--- a/include/rendering/animation/character_animator.hpp
+++ /dev/null
@@ -1,145 +0,0 @@
-#pragma once
-
-#include "rendering/animation/i_character_animator.hpp"
-#include "rendering/animation/anim_capability_set.hpp"
-#include "rendering/animation/locomotion_fsm.hpp"
-#include "rendering/animation/combat_fsm.hpp"
-#include "rendering/animation/activity_fsm.hpp"
-#include "rendering/animation/mount_fsm.hpp"
-#include <cstdint>
-
-namespace wowee {
-namespace rendering {
-
-// ============================================================================
-// CharacterAnimator
-//
-// Generic animator for any character (player, NPC, companion).
-// Composes LocomotionFSM, CombatFSM, ActivityFSM, and MountFSM with
-// a priority resolver. Implements ICharacterAnimator.
-//
-// Priority order: Stun > HitReaction > Spell > Charge > Combat > Activity > Locomotion
-//
-// No idle fallback: if all FSMs return {valid=false}, last animation continues.
-//
-// Overlay layer (stealth, sprint) substitutes the resolved anim without
-// changing sub-FSM state.
-// ============================================================================
-class CharacterAnimator final : public ICharacterAnimator {
-public:
-    CharacterAnimator();
-
-    // ── IAnimator ───────────────────────────────────────────────────────
-    void onEvent(AnimEvent event) override;
-    void update(float dt) override;
-
-    // ── ICharacterAnimator ──────────────────────────────────────────────
-    void startSpellCast(uint32_t precast, uint32_t cast, bool loop, uint32_t finalize) override;
-    void stopSpellCast() override;
-    void triggerMeleeSwing() override;
-    void triggerRangedShot() override;
-    void triggerHitReaction(uint32_t animId) override;
-    void triggerSpecialAttack(uint32_t spellId) override;
-    void setEquippedWeaponType(const WeaponLoadout& loadout) override;
-    void setEquippedRangedType(RangedWeaponType type) override;
-    void playEmote(uint32_t animId, bool loop) override;
-    void cancelEmote() override;
-    void startLooting() override;
-    void stopLooting() override;
-    void setStunned(bool stunned) override;
-    void setCharging(bool charging) override;
-    void setStandState(uint8_t state) override;
-    void setStealthed(bool stealth) override;
-    void setInCombat(bool combat) override;
-    void setLowHealth(bool low) override;
-    void setSprintAuraActive(bool active) override;
-
-    // ── Configuration ───────────────────────────────────────────────────
-    void setCapabilities(const AnimCapabilitySet& caps) { caps_ = caps; }
-    const AnimCapabilitySet& getCapabilities() const { return caps_; }
-    void setWeaponLoadout(const WeaponLoadout& loadout) { loadout_ = loadout; }
-    const WeaponLoadout& getWeaponLoadout() const { return loadout_; }
-
-    // ── Mount ───────────────────────────────────────────────────────────
-    void configureMountFSM(const MountFSM::MountAnimSet& anims, bool taxiFlight);
-    void clearMountFSM();
-    bool isMountActive() const { return mount_.isActive(); }
-    MountFSM& getMountFSM() { return mount_; }
-
-    // ── Sub-FSM access (for transition queries) ─────────────────────────
-    LocomotionFSM& getLocomotion() { return locomotion_; }
-    const LocomotionFSM& getLocomotion() const { return locomotion_; }
-    CombatFSM& getCombat() { return combat_; }
-    const CombatFSM& getCombat() const { return combat_; }
-    ActivityFSM& getActivity() { return activity_; }
-    const ActivityFSM& getActivity() const { return activity_; }
-
-    // ── Last resolved output ────────────────────────────────────────────
-    AnimOutput getLastOutput() const { return lastOutput_; }
-
-    // ── Input injection (set per-frame from AnimationController) ────────
-    struct FrameInput {
-        // From camera controller
-        bool moving = false;
-        bool sprinting = false;
-        bool movingForward = false;
-        bool movingBackward = false;
-        bool autoRunning = false;
-        bool strafeLeft = false;
-        bool strafeRight = false;
-        bool grounded = true;
-        bool jumping = false;
-        bool swimming = false;
-        bool sitting = false;
-        bool flyingActive = false;
-        bool ascending = false;
-        bool descending = false;
-        bool jumpKeyPressed = false;
-        float characterYaw = 0.0f;
-        // Melee/ranged timers
-        float meleeSwingTimer = 0.0f;
-        float rangedShootTimer = 0.0f;
-        uint32_t specialAttackAnimId = 0;
-        uint32_t rangedAnimId = 0;
-        // Animation state query
-        uint32_t currentAnimId = 0;
-        float currentAnimTime = 0.0f;
-        float currentAnimDuration = 0.0f;
-        bool haveAnimState = false;
-        // Mount state query
-        uint32_t curMountAnim = 0;
-        float curMountTime = 0.0f;
-        float curMountDuration = 0.0f;
-        bool haveMountState = false;
-    };
-
-    void setFrameInput(const FrameInput& input) { frameInput_ = input; }
-
-private:
-    AnimCapabilitySet caps_;
-    WeaponLoadout loadout_;
-
-    LocomotionFSM locomotion_;
-    CombatFSM     combat_;
-    ActivityFSM   activity_;
-    MountFSM      mount_;
-
-    // Overlay flags
-    bool stealthed_ = false;
-    bool sprintAura_ = false;
-    bool lowHealth_ = false;
-    bool inCombat_ = false;
-
-    float lastDt_ = 0.0f;
-    FrameInput frameInput_;
-    AnimOutput lastOutput_;
-
-    /// Priority resolver: highest-priority active FSM wins.
-    AnimOutput resolveAnimation();
-
-    /// Apply stealth/sprint overlays to the resolved animation.
-    AnimOutput applyOverlays(AnimOutput base) const;
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/combat_fsm.hpp b/include/rendering/animation/combat_fsm.hpp
deleted file mode 100644
index 8c189b67..00000000
--- a/include/rendering/animation/combat_fsm.hpp
+++ /dev/null
@@ -1,120 +0,0 @@
-#pragma once
-
-#include "rendering/animation/anim_capability_set.hpp"
-#include "rendering/animation/anim_event.hpp"
-#include "rendering/animation/weapon_type.hpp"
-#include <cstdint>
-
-namespace wowee {
-namespace rendering {
-
-// ============================================================================
-// CombatFSM
-//
-// Pure logic state machine for combat animation. No renderer dependency.
-// States: INACTIVE · COMBAT_IDLE · MELEE_SWING · RANGED_SHOOT · RANGED_LOAD ·
-//         SPELL_PRECAST · SPELL_CASTING · SPELL_FINALIZE · HIT_REACTION ·
-//         STUNNED · CHARGE · UNSHEATHE · SHEATHE
-//
-// Stun overrides all combat states. Spell state cleared on interrupts.
-// offHandTurn_ alternation managed internally.
-// ============================================================================
-class CombatFSM {
-public:
-    enum class State : uint8_t {
-        INACTIVE,
-        COMBAT_IDLE,
-        MELEE_SWING,
-        RANGED_SHOOT,
-        RANGED_LOAD,
-        SPELL_PRECAST,
-        SPELL_CASTING,
-        SPELL_FINALIZE,
-        HIT_REACTION,
-        STUNNED,
-        CHARGE,
-        UNSHEATHE,
-        SHEATHE,
-    };
-
-    struct Input {
-        bool inCombat = false;
-        bool grounded = true;
-        bool jumping = false;
-        bool swimming = false;
-        bool moving = false;
-        bool sprinting = false;
-        bool lowHealth = false;
-        float meleeSwingTimer = 0.0f;   // >0 = melee active
-        float rangedShootTimer = 0.0f;  // >0 = ranged active
-        uint32_t specialAttackAnimId = 0;
-        uint32_t rangedAnimId = 0;
-        // Animation state query for one-shot completion detection
-        uint32_t currentAnimId = 0;
-        float currentAnimTime = 0.0f;
-        float currentAnimDuration = 0.0f;
-        bool haveAnimState = false;
-        // Whether model has specific one-shot animations
-        bool hasUnsheathe = false;
-        bool hasSheathe = false;
-    };
-
-    void onEvent(AnimEvent event);
-
-    /// Evaluate current state against input and capabilities.
-    AnimOutput resolve(const Input& in, const AnimCapabilitySet& caps,
-                       const WeaponLoadout& loadout);
-
-    State getState() const { return state_; }
-    void setState(State s) { state_ = s; }
-
-    bool isStunned() const { return state_ == State::STUNNED; }
-    bool isActive() const { return state_ != State::INACTIVE; }
-    void reset();
-
-    // ── Spell cast management ───────────────────────────────────────────
-    void startSpellCast(uint32_t precast, uint32_t cast, bool castLoop, uint32_t finalize);
-    void stopSpellCast();
-    void clearSpellState();
-
-    // ── Hit/stun management ─────────────────────────────────────────────
-    void triggerHitReaction(uint32_t animId);
-    void setStunned(bool stunned);
-    void setCharging(bool charging);
-
-    static constexpr uint8_t PRIORITY = 50;
-
-private:
-    State state_ = State::INACTIVE;
-
-    // Spell cast sequence
-    uint32_t spellPrecastAnimId_ = 0;
-    uint32_t spellCastAnimId_ = 0;
-    uint32_t spellFinalizeAnimId_ = 0;
-    bool spellCastLoop_ = false;
-    bool spellPrecastAnimSeen_ = false;
-    uint8_t spellPrecastFrames_ = 0;
-    bool spellFinalizeAnimSeen_ = false;
-    uint8_t spellFinalizeFrames_ = 0;
-
-    // Hit reaction
-    uint32_t hitReactionAnimId_ = 0;
-
-    // Stun
-    bool stunned_ = false;
-
-    // Charge
-    bool charging_ = false;
-
-    // Off-hand alternation for dual wielding
-    bool offHandTurn_ = false;
-
-    /// Internal: update state transitions based on input.
-    void updateTransitions(const Input& in);
-
-    /// Detect if a one-shot animation has completed.
-    bool oneShotComplete(const Input& in, uint32_t expectedAnimId) const;
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/emote_registry.hpp b/include/rendering/animation/emote_registry.hpp
deleted file mode 100644
index 2794fb25..00000000
--- a/include/rendering/animation/emote_registry.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <string>
-#include <optional>
-#include <unordered_map>
-#include <vector>
-
-namespace wowee {
-namespace rendering {
-
-// ============================================================================
-// EmoteRegistry — extracted from AnimationController
-//
-// Owns all static emote data, DBC loading, emote text lookup, and
-// animation ID resolution.  Singleton — loaded once on first use.
-// ============================================================================
-
-struct EmoteInfo {
-    uint32_t animId = 0;
-    uint32_t dbcId = 0;
-    bool loop = false;
-    std::string textNoTarget;
-    std::string textTarget;
-    std::string othersNoTarget;
-    std::string othersTarget;
-    std::string command;
-};
-
-class EmoteRegistry {
-public:
-    static EmoteRegistry& instance();
-
-    /// Load emotes from DBC files (called once on first use).
-    void loadFromDbc();
-
-    struct EmoteResult { uint32_t animId; bool loop; };
-
-    /// Look up an emote by chat command (e.g. "dance", "wave").
-    std::optional<EmoteResult> findEmote(const std::string& command) const;
-
-    /// Get the animation ID for a DBC emote ID.
-    uint32_t animByDbcId(uint32_t dbcId) const;
-
-    /// Get the emote state variant (looping) for a one-shot emote animation.
-    uint32_t getStateVariant(uint32_t oneShotAnimId) const;
-
-    /// Get first-person emote text for a command.
-    std::string textFor(const std::string& emoteName,
-                        const std::string* targetName = nullptr) const;
-
-    /// Get DBC ID for an emote command.
-    uint32_t dbcIdFor(const std::string& emoteName) const;
-
-    /// Get third-person emote text by DBC ID.
-    std::string textByDbcId(uint32_t dbcId,
-                            const std::string& senderName,
-                            const std::string* targetName = nullptr) const;
-
-    /// Get the full EmoteInfo for a command (nullptr if not found).
-    const EmoteInfo* findInfo(const std::string& command) const;
-
-private:
-    EmoteRegistry() = default;
-    EmoteRegistry(const EmoteRegistry&) = delete;
-    EmoteRegistry& operator=(const EmoteRegistry&) = delete;
-
-    void loadFallbackEmotes();
-    void buildDbcIdIndex();
-
-    bool loaded_ = false;
-    std::unordered_map<std::string, EmoteInfo> emoteTable_;
-    std::unordered_map<uint32_t, const EmoteInfo*> emoteByDbcId_;
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/footstep_driver.hpp b/include/rendering/animation/footstep_driver.hpp
deleted file mode 100644
index 6dd3005f..00000000
--- a/include/rendering/animation/footstep_driver.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <glm/glm.hpp>
-
-namespace wowee {
-
-namespace audio { enum class FootstepSurface : uint8_t; }
-
-namespace rendering {
-
-class Renderer;
-
-// ============================================================================
-// FootstepDriver — extracted from AnimationController
-//
-// Owns animation-driven footstep event detection, surface resolution,
-// and player/mount footstep tracking state.
-// ============================================================================
-class FootstepDriver {
-public:
-    FootstepDriver() = default;
-
-    /// Process footstep events for this frame (called from Renderer::update).
-    void update(float deltaTime, Renderer* renderer,
-                bool mounted, uint32_t mountInstanceId, bool taxiFlight,
-                bool isFootstepState);
-
-    /// Detect if a footstep event should trigger based on animation phase crossing.
-    bool shouldTriggerFootstepEvent(uint32_t animationId, float animationTimeMs,
-                                    float animationDurationMs);
-
-    /// Resolve the surface type under the character for footstep sound selection.
-    audio::FootstepSurface resolveFootstepSurface(Renderer* renderer) const;
-
-private:
-    // Player footstep event tracking (animation-driven)
-    uint32_t footstepLastAnimationId_ = 0;
-    float footstepLastNormTime_ = 0.0f;
-    bool footstepNormInitialized_ = false;
-
-    // Footstep surface cache (avoid expensive queries every step)
-    mutable audio::FootstepSurface cachedFootstepSurface_{};
-    mutable glm::vec3 cachedFootstepPosition_{0.0f, 0.0f, 0.0f};
-    mutable float cachedFootstepUpdateTimer_{999.0f};
-
-    // Mount footstep tracking (separate from player's)
-    uint32_t mountFootstepLastAnimId_ = 0;
-    float mountFootstepLastNormTime_ = 0.0f;
-    bool mountFootstepNormInitialized_ = false;
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/i_anim_renderer.hpp b/include/rendering/animation/i_anim_renderer.hpp
deleted file mode 100644
index 7eec655e..00000000
--- a/include/rendering/animation/i_anim_renderer.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-
-#include "rendering/animation/anim_capability_set.hpp"
-#include "rendering/animation/anim_event.hpp"
-#include <cstdint>
-#include <vector>
-
-namespace wowee {
-namespace pipeline { struct M2Sequence; }
-
-namespace rendering {
-
-// ============================================================================
-// IAnimRenderer
-//
-// Abstraction for renderer animation operations. Sub-FSMs and animators
-// talk to this interface, not to CharacterRenderer directly.
-// ============================================================================
-class IAnimRenderer {
-public:
-    virtual void playAnimation(uint32_t instanceId, uint32_t animId, bool loop) = 0;
-    virtual bool hasAnimation(uint32_t instanceId, uint32_t animId) const = 0;
-    virtual bool getAnimationState(uint32_t instanceId, uint32_t& outAnimId,
-                                   float& outTimeMs, float& outDurMs) const = 0;
-    virtual bool getAnimationSequences(uint32_t instanceId,
-                                       std::vector<pipeline::M2Sequence>& out) const = 0;
-    virtual ~IAnimRenderer() = default;
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/i_animator.hpp b/include/rendering/animation/i_animator.hpp
deleted file mode 100644
index b52055cb..00000000
--- a/include/rendering/animation/i_animator.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#include "rendering/animation/anim_event.hpp"
-
-namespace wowee {
-namespace rendering {
-
-// ============================================================================
-// IAnimator
-//
-// Base interface for all entity animators. Common to player + NPC.
-// ============================================================================
-class IAnimator {
-public:
-    virtual void onEvent(AnimEvent event) = 0;
-    virtual void update(float dt) = 0;
-    virtual ~IAnimator() = default;
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/i_character_animator.hpp b/include/rendering/animation/i_character_animator.hpp
deleted file mode 100644
index 75c67a3d..00000000
--- a/include/rendering/animation/i_character_animator.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-
-#include "rendering/animation/i_animator.hpp"
-#include "rendering/animation/weapon_type.hpp"
-#include <cstdint>
-#include <string>
-
-namespace wowee {
-namespace rendering {
-
-// ============================================================================
-// ICharacterAnimator
-//
-// Player-specific animation interface. Extends IAnimator with combat,
-// spell, emote, and mount operations.
-// ============================================================================
-class ICharacterAnimator : public IAnimator {
-public:
-    virtual void startSpellCast(uint32_t precast, uint32_t cast, bool loop, uint32_t finalize) = 0;
-    virtual void stopSpellCast() = 0;
-    virtual void triggerMeleeSwing() = 0;
-    virtual void triggerRangedShot() = 0;
-    virtual void triggerHitReaction(uint32_t animId) = 0;
-    virtual void triggerSpecialAttack(uint32_t spellId) = 0;
-    virtual void setEquippedWeaponType(const WeaponLoadout& loadout) = 0;
-    virtual void setEquippedRangedType(RangedWeaponType type) = 0;
-    virtual void playEmote(uint32_t animId, bool loop) = 0;
-    virtual void cancelEmote() = 0;
-    virtual void startLooting() = 0;
-    virtual void stopLooting() = 0;
-    virtual void setStunned(bool stunned) = 0;
-    virtual void setCharging(bool charging) = 0;
-    virtual void setStandState(uint8_t state) = 0;
-    virtual void setStealthed(bool stealth) = 0;
-    virtual void setInCombat(bool combat) = 0;
-    virtual void setLowHealth(bool low) = 0;
-    virtual void setSprintAuraActive(bool active) = 0;
-    virtual ~ICharacterAnimator() = default;
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/locomotion_fsm.hpp b/include/rendering/animation/locomotion_fsm.hpp
deleted file mode 100644
index 2c99ecd4..00000000
--- a/include/rendering/animation/locomotion_fsm.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#pragma once
-
-#include "rendering/animation/anim_capability_set.hpp"
-#include "rendering/animation/anim_event.hpp"
-#include <cstdint>
-
-namespace wowee {
-namespace rendering {
-
-// ============================================================================
-// LocomotionFSM
-//
-// Pure logic state machine for movement animation. No renderer dependency.
-// States: IDLE · WALK · RUN · JUMP_START · JUMP_MID · JUMP_END · SWIM_IDLE · SWIM
-//
-// Grace timer is internal — no external locomotionStopGraceTimer_ needed.
-// ============================================================================
-class LocomotionFSM {
-public:
-    enum class State : uint8_t {
-        IDLE, WALK, RUN,
-        JUMP_START, JUMP_MID, JUMP_END,
-        SWIM_IDLE, SWIM,
-    };
-
-    struct Input {
-        bool moving = false;
-        bool movingForward = false;
-        bool sprinting = false;
-        bool movingBackward = false;
-        bool strafeLeft = false;
-        bool strafeRight = false;
-        bool grounded = true;
-        bool jumping = false;
-        bool swimming = false;
-        bool sitting = false;
-        bool sprintAura = false;      // Sprint/Dash aura — use SPRINT anim
-        float deltaTime = 0.0f;
-        // Animation state for one-shot completion detection (jump start/end)
-        uint32_t currentAnimId = 0;
-        float currentAnimTime = 0.0f;
-        float currentAnimDuration = 0.0f;
-        bool haveAnimState = false;
-    };
-
-    /// Process event and update internal state.
-    void onEvent(AnimEvent event);
-
-    /// Evaluate current state against input and capabilities.
-    /// Returns AnimOutput with valid=false if no change needed (STAY policy).
-    AnimOutput resolve(const Input& in, const AnimCapabilitySet& caps);
-
-    State getState() const { return state_; }
-    void setState(State s) { state_ = s; }
-    void reset();
-
-    static constexpr uint8_t PRIORITY = 10;
-
-private:
-    State state_ = State::IDLE;
-
-    // Grace timer: short delay before switching from WALK/RUN to IDLE
-    // to avoid flickering on network jitter
-    float graceTimer_ = 0.0f;
-    bool wasSprinting_ = false;
-
-    // One-shot tracking for jump start/end animations
-    bool jumpStartSeen_ = false;
-    bool jumpEndSeen_ = false;
-
-    static constexpr float kGraceSec = 0.12f;
-
-    /// Internal: update state transitions based on input.
-    void updateTransitions(const Input& in, const AnimCapabilitySet& caps);
-    bool oneShotComplete(const Input& in, uint32_t expectedAnimId) const;
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/mount_fsm.hpp b/include/rendering/animation/mount_fsm.hpp
deleted file mode 100644
index de9ca158..00000000
--- a/include/rendering/animation/mount_fsm.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-#pragma once
-
-#include "rendering/animation/anim_capability_set.hpp"
-#include "rendering/animation/anim_event.hpp"
-#include <cstdint>
-#include <vector>
-#include <random>
-#include <glm/glm.hpp>
-
-namespace wowee {
-namespace rendering {
-
-// ============================================================================
-// MountFSM
-//
-// Self-contained mount animation state machine. Replaces the ~400-line
-// mounted branch of updateCharacterAnimation() and eliminates the `goto`.
-//
-// Owns: fidget timer, RNG, idle sound timer, mount action state.
-// All static RNG replaced with per-instance members.
-// ============================================================================
-class MountFSM {
-public:
-    // Animation set discovered at mount time (property-based, not hardcoded)
-    struct MountAnimSet {
-        uint32_t jumpStart = 0;
-        uint32_t jumpLoop = 0;
-        uint32_t jumpEnd = 0;
-        uint32_t rearUp = 0;
-        uint32_t run = 0;
-        uint32_t stand = 0;
-        // Flight animations
-        uint32_t flyIdle = 0;
-        uint32_t flyForward = 0;
-        uint32_t flyBackwards = 0;
-        uint32_t flyLeft = 0;
-        uint32_t flyRight = 0;
-        uint32_t flyUp = 0;
-        uint32_t flyDown = 0;
-        std::vector<uint32_t> fidgets;
-    };
-
-    enum class MountState : uint8_t {
-        IDLE, RUN, JUMP_START, JUMP_LOOP, JUMP_LAND, REAR_UP, FLY,
-    };
-
-    enum class MountAction : uint8_t { None, Jump, RearUp };
-
-    struct Input {
-        bool moving = false;
-        bool movingBackward = false;
-        bool strafeLeft = false;
-        bool strafeRight = false;
-        bool grounded = true;
-        bool jumpKeyPressed = false;
-        bool flying = false;
-        bool swimming = false;
-        bool ascending = false;
-        bool descending = false;
-        bool taxiFlight = false;
-        float deltaTime = 0.0f;
-        float characterYaw = 0.0f;
-        // Mount anim state query
-        uint32_t curMountAnim = 0;
-        float curMountTime = 0.0f;
-        float curMountDuration = 0.0f;
-        bool haveMountState = false;
-    };
-
-    /// Output from evaluate(): what to play on rider + mount, and positioning data.
-    struct Output {
-        // Mount animation
-        uint32_t mountAnimId = 0;
-        bool mountAnimLoop = true;
-        bool mountAnimChanged = false;  // true = should call playAnimation
-
-        // Rider animation
-        uint32_t riderAnimId = 0;
-        bool riderAnimLoop = true;
-        bool riderAnimChanged = false;
-
-        // Mount procedural motion
-        float mountBob = 0.0f;         // Vertical bob offset
-        float mountPitch = 0.0f;       // Pitch (forward lean)
-        float mountRoll = 0.0f;        // Roll (banking)
-
-        // Signals
-        bool playJumpSound = false;
-        bool playLandSound = false;
-        bool playRearUpSound = false;
-        bool playIdleSound = false;
-        bool triggerMountJump = false;  // Tell camera controller to jump
-        bool fidgetStarted = false;
-    };
-
-    void configure(const MountAnimSet& anims, bool taxiFlight);
-    void clear();
-    void onEvent(AnimEvent event);
-
-    /// Main evaluation: produces Output describing what to play.
-    Output evaluate(const Input& in);
-
-    bool isActive() const { return active_; }
-    MountState getState() const { return state_; }
-    MountAction getAction() const { return action_; }
-    const MountAnimSet& getAnims() const { return anims_; }
-
-private:
-    bool active_ = false;
-    MountState state_ = MountState::IDLE;
-    MountAction action_ = MountAction::None;
-    uint32_t actionPhase_ = 0;
-
-    MountAnimSet anims_;
-    bool taxiFlight_ = false;
-
-    // Fidget system — per-instance, not static
-    float fidgetTimer_ = 0.0f;
-    float nextFidgetTime_ = 8.0f;
-    uint32_t activeFidget_ = 0;
-    std::mt19937 rng_;
-
-    // Idle ambient sound timer
-    float idleSoundTimer_ = 0.0f;
-    float nextIdleSoundTime_ = 60.0f;
-
-    // Procedural lean
-    float prevYaw_ = 0.0f;
-    float roll_ = 0.0f;
-
-    // Last mount animation for change detection
-    uint32_t lastMountAnim_ = 0;
-
-    /// Resolve the mount animation for the given input (non-taxi).
-    uint32_t resolveGroundOrFlyAnim(const Input& in) const;
-
-    /// Check if an action animation has completed.
-    bool actionAnimComplete(const Input& in) const;
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/sfx_state_driver.hpp b/include/rendering/animation/sfx_state_driver.hpp
deleted file mode 100644
index 28b4c266..00000000
--- a/include/rendering/animation/sfx_state_driver.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace wowee {
-namespace rendering {
-
-class Renderer;
-class FootstepDriver;
-
-// ============================================================================
-// SfxStateDriver — extracted from AnimationController
-//
-// Tracks state transitions for activity SFX (jump, landing, swim) and
-// mount ambient sounds.
-// ============================================================================
-class SfxStateDriver {
-public:
-    SfxStateDriver() = default;
-
-    /// Track state transitions and trigger appropriate SFX.
-    void update(float deltaTime, Renderer* renderer,
-                bool mounted, bool taxiFlight,
-                FootstepDriver& footstepDriver);
-
-private:
-    bool initialized_ = false;
-    bool prevGrounded_ = true;
-    bool prevJumping_ = false;
-    bool prevFalling_ = false;
-    bool prevSwimming_ = false;
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation/weapon_type.hpp b/include/rendering/animation/weapon_type.hpp
deleted file mode 100644
index 23c662e7..00000000
--- a/include/rendering/animation/weapon_type.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace wowee {
-namespace rendering {
-
-/// Ranged weapon type for animation selection (bow/gun/crossbow/thrown)
-enum class RangedWeaponType : uint8_t { NONE = 0, BOW, GUN, CROSSBOW, THROWN };
-
-// ============================================================================
-// WeaponLoadout — extracted from AnimationController
-//
-// Consolidates the 6 weapon boolean fields + inventory type + ranged type
-// into a single value type.
-// ============================================================================
-struct WeaponLoadout {
-    uint32_t inventoryType = 0;
-    bool is2HLoose  = false;  // Polearm or staff
-    bool isFist     = false;  // Fist weapon
-    bool isDagger   = false;  // Dagger (uses pierce variants)
-    bool hasOffHand = false;  // Has off-hand weapon (dual wield)
-    bool hasShield  = false;  // Has shield equipped (for SHIELD_BASH)
-    RangedWeaponType rangedType = RangedWeaponType::NONE;
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/animation_controller.hpp b/include/rendering/animation_controller.hpp
deleted file mode 100644
index 0efcc715..00000000
--- a/include/rendering/animation_controller.hpp
+++ /dev/null
@@ -1,224 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <string>
-#include <vector>
-#include <glm/glm.hpp>
-#include "rendering/animation/footstep_driver.hpp"
-#include "rendering/animation/sfx_state_driver.hpp"
-#include "rendering/animation/weapon_type.hpp"
-#include "rendering/animation/anim_capability_set.hpp"
-#include "rendering/animation/character_animator.hpp"
-
-namespace wowee {
-namespace rendering {
-
-class Renderer;
-
-// ============================================================================
-// AnimationController — thin adapter wrapping CharacterAnimator
-//
-// Bridges the Renderer world (camera state, CharacterRenderer, audio)
-// and the pure-logic CharacterAnimator + sub-FSMs. Public API unchanged.
-//
-// Responsibilities:
-//   · Collect inputs from renderer/camera → CharacterAnimator::FrameInput
-//   · Forward state-changing calls → CharacterAnimator
-//   · Read AnimOutput from CharacterAnimator → apply via CharacterRenderer
-//   · Mount discovery (needs renderer for sequence queries)
-//   · Mount positioning (needs renderer for attachment queries)
-//   · Melee/ranged resolution (needs renderer for sequence queries)
-//   · Footstep and SFX drivers (already extracted)
-// ============================================================================
-class AnimationController {
-public:
-    AnimationController();
-    ~AnimationController();
-
-    void initialize(Renderer* renderer);
-
-    /// Probe (or re-probe) animation capabilities for the current character model.
-    /// Called once during initialize() / onCharacterFollow() and after model changes.
-    void probeCapabilities();
-    const AnimCapabilitySet& getCapabilities() const { return characterAnimator_.getCapabilities(); }
-
-    // ── Per-frame update hooks (called from Renderer::update) ──────────────
-    // Runs the character animation state machine (mounted + unmounted).
-    void updateCharacterAnimation();
-    // Processes animation-driven footstep events (player + mount).
-    void updateFootsteps(float deltaTime);
-    // Tracks state transitions for activity SFX (jump, landing, swim) and
-    // mount ambient sounds.
-    void updateSfxState(float deltaTime);
-    // Decrements melee swing timer / cooldown.
-    void updateMeleeTimers(float deltaTime);
-    // Store per-frame delta time (used inside animation state machine).
-    void setDeltaTime(float dt) { lastDeltaTime_ = dt; }
-
-    // ── Character follow ───────────────────────────────────────────────────
-    void onCharacterFollow(uint32_t instanceId);
-
-    // ── Emote support ──────────────────────────────────────────────────────
-    void playEmote(const std::string& emoteName);
-    void cancelEmote();
-    bool isEmoteActive() const { return characterAnimator_.getActivity().isEmoteActive(); }
-    static std::string getEmoteText(const std::string& emoteName,
-                                    const std::string* targetName = nullptr);
-    static uint32_t getEmoteDbcId(const std::string& emoteName);
-    static std::string getEmoteTextByDbcId(uint32_t dbcId,
-                                           const std::string& senderName,
-                                           const std::string* targetName = nullptr);
-    static uint32_t getEmoteAnimByDbcId(uint32_t dbcId);
-
-    // ── Targeting / combat ─────────────────────────────────────────────────
-    void setTargetPosition(const glm::vec3* pos);
-    void setInCombat(bool combat);
-    bool isInCombat() const { return inCombat_; }
-    const glm::vec3* getTargetPosition() const { return targetPosition_; }
-    void resetCombatVisualState();
-    bool isMoving() const;
-
-    // ── Melee combat ───────────────────────────────────────────────────────
-    void triggerMeleeSwing();
-    /// inventoryType: WoW inventory type (0=unarmed, 13=1H, 17=2H, 21=main-hand, …)
-    /// is2HLoose: true for polearms/staves (use ATTACK_2H_LOOSE instead of ATTACK_2H)
-    void setEquippedWeaponType(uint32_t inventoryType, bool is2HLoose = false,
-                               bool isFist = false, bool isDagger = false,
-                               bool hasOffHand = false, bool hasShield = false);
-    /// Play a special attack animation for a melee ability (spellId → SPECIAL_1H/2H/SHIELD_BASH/WHIRLWIND)
-    void triggerSpecialAttack(uint32_t spellId);
-
-    // ── Sprint aura animation ────────────────────────────────────────────
-    void setSprintAuraActive(bool active);
-
-    // ── Ranged combat ──────────────────────────────────────────────────────
-    void setEquippedRangedType(RangedWeaponType type);
-    /// Trigger a ranged shot animation (Auto Shot, Shoot, Throw)
-    void triggerRangedShot();
-    RangedWeaponType getEquippedRangedType() const { return weaponLoadout_.rangedType; }
-    void setCharging(bool charging);
-    bool isCharging() const { return charging_; }
-
-    // ── Spell casting ──────────────────────────────────────────────────────
-    /// Enter spell cast animation sequence:
-    ///   precastAnimId (one-shot wind-up) → castAnimId (looping hold) → finalizeAnimId (one-shot release)
-    /// Any phase can be 0 to skip it.
-    void startSpellCast(uint32_t precastAnimId, uint32_t castAnimId, bool castLoop,
-                        uint32_t finalizeAnimId = 0);
-    /// Leave spell cast animation state → plays finalization anim then idle.
-    void stopSpellCast();
-
-    // ── Loot animation ─────────────────────────────────────────────────────
-    void startLooting();
-    void stopLooting();
-
-    // ── Hit reactions ──────────────────────────────────────────────────────
-    /// Play a one-shot hit reaction animation (wound, dodge, block, etc.)
-    /// on the player character.  The state machine returns to the previous
-    /// state once the reaction animation finishes.
-    void triggerHitReaction(uint32_t animId);
-
-    // ── Crowd control ──────────────────────────────────────────────────────
-    /// Enter/exit stunned state (loops STUN animation until cleared).
-    void setStunned(bool stunned);
-    bool isStunned() const { return stunned_; }
-
-    // ── Health-based idle ──────────────────────────────────────────────────
-    /// When true, idle/combat-idle will prefer STAND_WOUND if the model has it.
-    void setLowHealth(bool low);
-
-    // ── Stand state (sit/sleep/kneel transitions) ──────────────────────────
-    // WoW UnitStandStateType constants
-    static constexpr uint8_t STAND_STATE_STAND      = 0;
-    static constexpr uint8_t STAND_STATE_SIT         = 1;
-    static constexpr uint8_t STAND_STATE_SIT_CHAIR   = 2;
-    static constexpr uint8_t STAND_STATE_SLEEP       = 3;
-    static constexpr uint8_t STAND_STATE_SIT_LOW     = 4;
-    static constexpr uint8_t STAND_STATE_SIT_MED     = 5;
-    static constexpr uint8_t STAND_STATE_SIT_HIGH    = 6;
-    static constexpr uint8_t STAND_STATE_DEAD        = 7;
-    static constexpr uint8_t STAND_STATE_KNEEL       = 8;
-    static constexpr uint8_t STAND_STATE_SUBMERGED   = 9;
-    void setStandState(uint8_t state);
-
-    // ── Stealth ────────────────────────────────────────────────────────────
-    /// When true, idle/walk/run use stealth animation variants.
-    void setStealthed(bool stealth);
-
-    // ── Effect triggers ────────────────────────────────────────────────────
-    void triggerLevelUpEffect(const glm::vec3& position);
-    void startChargeEffect(const glm::vec3& position, const glm::vec3& direction);
-    void emitChargeEffect(const glm::vec3& position, const glm::vec3& direction);
-    void stopChargeEffect();
-
-    // ── Mount ──────────────────────────────────────────────────────────────
-    void setMounted(uint32_t mountInstId, uint32_t mountDisplayId,
-                    float heightOffset, const std::string& modelPath = "");
-    void setTaxiFlight(bool onTaxi) { taxiFlight_ = onTaxi; }
-    void setMountPitchRoll(float pitch, float roll) { mountPitch_ = pitch; mountRoll_ = roll; }
-    void clearMount();
-    bool isMounted() const { return mountInstanceId_ != 0; }
-    uint32_t getMountInstanceId() const { return mountInstanceId_; }
-
-    // ── Query helpers (used by Renderer) ───────────────────────────────────
-    bool isFootstepAnimationState() const;
-    float getMeleeSwingTimer() const { return meleeSwingTimer_; }
-    float getMountHeightOffset() const { return mountHeightOffset_; }
-    bool isTaxiFlight() const { return taxiFlight_; }
-
-private:
-    Renderer* renderer_ = nullptr;
-
-    // ── CharacterAnimator: owns the complete character animation FSM ─────
-    CharacterAnimator characterAnimator_;
-    bool capabilitiesProbed_ = false;
-
-    // ── Animation change detection ───────────────────────────────────────
-    uint32_t lastPlayerAnimRequest_ = UINT32_MAX;
-    bool lastPlayerAnimLoopRequest_ = true;
-    float lastDeltaTime_ = 0.0f;
-
-    // ── Externally-queried state (mirrored to CharacterAnimator) ────────────
-    const glm::vec3* targetPosition_ = nullptr;
-    bool inCombat_ = false;
-    bool stunned_ = false;
-    bool charging_ = false;
-
-    // ── Footstep event tracking (delegated to FootstepDriver) ────────────
-    FootstepDriver footstepDriver_;
-
-    // ── SFX transition state (delegated to SfxStateDriver) ───────────────
-    SfxStateDriver sfxStateDriver_;
-
-    // ── Melee combat (needs renderer for sequence queries) ───────────────
-    float meleeSwingTimer_ = 0.0f;
-    float meleeSwingCooldown_ = 0.0f;
-    float meleeAnimDurationMs_ = 0.0f;
-    uint32_t meleeAnimId_ = 0;
-    uint32_t specialAttackAnimId_ = 0;
-    WeaponLoadout weaponLoadout_;
-    bool meleeOffHandTurn_ = false;
-
-    // ── Ranged weapon state ──────────────────────────────────────────────
-    float rangedShootTimer_ = 0.0f;
-    uint32_t rangedAnimId_ = 0;
-
-    // ── Mount state (discovery + positioning need renderer) ──────────────
-    uint32_t mountInstanceId_ = 0;
-    float mountHeightOffset_ = 0.0f;
-    float mountPitch_ = 0.0f;
-    float mountRoll_ = 0.0f;       // External roll for taxi flights (lean roll computed by MountFSM)
-    int mountSeatAttachmentId_ = -1;
-    glm::vec3 smoothedMountSeatPos_ = glm::vec3(0.0f);
-    bool mountSeatSmoothingInit_ = false;
-    bool taxiFlight_ = false;
-    bool sprintAuraActive_ = false;
-
-    // ── Private helpers ──────────────────────────────────────────────────
-    uint32_t resolveMeleeAnimId();
-    void updateMountedAnimation(float deltaTime);
-    void applyMountPositioning(float mountBob, float mountRoll, float characterYaw);
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/camera.hpp b/include/rendering/camera.hpp
index ed4732f2..ee58c8f2 100644
--- a/include/rendering/camera.hpp
+++ b/include/rendering/camera.hpp
@@ -51,7 +51,7 @@ private:
     float pitch = 0.0f;
     float fov = 45.0f;
     float aspectRatio = 16.0f / 9.0f;
-    float nearPlane = 0.5f;
+    float nearPlane = 0.05f;
     float farPlane = 30000.0f;   // Improves depth precision vs extremely large far clip
 
     glm::mat4 viewMatrix = glm::mat4(1.0f);
diff --git a/include/rendering/camera_controller.hpp b/include/rendering/camera_controller.hpp
index a5593b06..34600b47 100644
--- a/include/rendering/camera_controller.hpp
+++ b/include/rendering/camera_controller.hpp
@@ -3,7 +3,6 @@
 #include "rendering/camera.hpp"
 #include "core/input.hpp"
 #include <SDL2/SDL.h>
-#include <algorithm>
 #include <functional>
 #include <optional>
 
@@ -45,7 +44,6 @@ public:
     }
 
     void reset();
-    void resetAngles();
     void teleportTo(const glm::vec3& pos);
     void setOnlineMode(bool online) { onlineMode = online; }
 
@@ -84,7 +82,6 @@ public:
     bool isSwimming() const { return swimming; }
     bool isInsideWMO() const { return cachedInsideWMO; }
     void setGrounded(bool g) { grounded = g; }
-    void setSitting(bool s) { sitting = s; }
     bool isOnTaxi() const { return externalFollow_; }
     const glm::vec3* getFollowTarget() const { return followTarget; }
     glm::vec3* getFollowTargetMutable() { return followTarget; }
@@ -92,40 +89,8 @@ public:
     // Movement callback for sending opcodes to server
     using MovementCallback = std::function<void(uint32_t opcode)>;
     void setMovementCallback(MovementCallback cb) { movementCallback = std::move(cb); }
-
-    // Callback invoked when the player stands up via local input (space/X/movement key
-    // while server-sitting), so the caller can send CMSG_STAND_STATE_CHANGE(0).
-    using StandUpCallback = std::function<void()>;
-    void setStandUpCallback(StandUpCallback cb) { standUpCallback_ = std::move(cb); }
-
-    // Callback invoked when the player sits down via local input (X key).
-    using SitDownCallback = std::function<void()>;
-    void setSitDownCallback(SitDownCallback cb) { sitDownCallback_ = std::move(cb); }
-
-    // Callback invoked when auto-follow is cancelled by user movement input.
-    using AutoFollowCancelCallback = std::function<void()>;
-    void setAutoFollowCancelCallback(AutoFollowCancelCallback cb) { autoFollowCancelCallback_ = std::move(cb); }
-
     void setUseWoWSpeed(bool use) { useWoWSpeed = use; }
     void setRunSpeedOverride(float speed) { runSpeedOverride_ = speed; }
-    void setWalkSpeedOverride(float speed) { walkSpeedOverride_ = speed; }
-    void setSwimSpeedOverride(float speed) { swimSpeedOverride_ = speed; }
-    void setSwimBackSpeedOverride(float speed) { swimBackSpeedOverride_ = speed; }
-    void setFlightSpeedOverride(float speed) { flightSpeedOverride_ = speed; }
-    void setFlightBackSpeedOverride(float speed) { flightBackSpeedOverride_ = speed; }
-    void setRunBackSpeedOverride(float speed) { runBackSpeedOverride_ = speed; }
-    // Server turn rate in rad/s (SMSG_FORCE_TURN_RATE_CHANGE); 0 = use WOW_TURN_SPEED default
-    void setTurnRateOverride(float rateRadS) { turnRateOverride_ = rateRadS; }
-    void setMovementRooted(bool rooted) { movementRooted_ = rooted; }
-    bool isMovementRooted() const { return movementRooted_; }
-    void setGravityDisabled(bool disabled) { gravityDisabled_ = disabled; }
-    void setFeatherFallActive(bool active) { featherFallActive_ = active; }
-    void setWaterWalkActive(bool active) { waterWalkActive_ = active; }
-    void setFlyingActive(bool active) { flyingActive_ = active; }
-    bool isFlyingActive() const { return flyingActive_; }
-    bool isAscending() const { return wasAscending_; }
-    bool isDescending() const { return wasDescending_; }
-    void setHoverActive(bool active) { hoverActive_ = active; }
     void setMounted(bool m) { mounted_ = m; }
     void setMountHeightOffset(float offset) { mountHeightOffset_ = offset; }
     void setExternalFollow(bool enabled) { externalFollow_ = enabled; }
@@ -133,30 +98,10 @@ public:
     void setFacingYaw(float yaw) { facingYaw = yaw; }  // For taxi/scripted movement
     void clearMovementInputs();
     void suppressMovementFor(float seconds) { movementSuppressTimer_ = seconds; }
-    void suspendGravityFor(float seconds) { gravitySuspendTimer_ = seconds; }
-
-    // Auto-follow: walk toward a target position each frame (WoW /follow).
-    // The caller updates *targetPos every frame with the followed entity's render position.
-    // Stops within FOLLOW_STOP_DIST; cancels on manual WASD input.
-    void setAutoFollow(const glm::vec3* targetPos) { autoFollowTarget_ = targetPos; }
-    void cancelAutoFollow() { autoFollowTarget_ = nullptr; }
-    bool isAutoFollowing() const { return autoFollowTarget_ != nullptr; }
 
     // Trigger mount jump (applies vertical velocity for physics hop)
     void triggerMountJump();
 
-    // Apply server-driven knockback impulse.
-    // dir: render-space 2D direction unit vector (from vcos/vsin in packet)
-    // hspeed: horizontal speed magnitude (units/s)
-    // vspeed: raw packet vspeed field (server sends negative for upward launch)
-    void applyKnockBack(float vcos, float vsin, float hspeed, float vspeed);
-
-    // Trigger a camera shake effect (e.g. from SMSG_CAMERA_SHAKE).
-    // magnitude: peak positional offset in world units
-    // frequency: oscillation frequency in Hz
-    // duration: shake duration in seconds
-    void triggerShake(float magnitude, float frequency, float duration);
-
     // For first-person player hiding
     void setCharacterRenderer(class CharacterRenderer* cr, uint32_t playerId) {
         characterRenderer = cr;
@@ -184,7 +129,7 @@ private:
 
     // Mouse settings
     float mouseSensitivity = 0.2f;
-    bool invertMouse = true;
+    bool invertMouse = false;
     bool mouseButtonDown = false;
     bool leftMouseDown = false;
     bool rightMouseDown = false;
@@ -201,25 +146,16 @@ private:
     static constexpr float MAX_DISTANCE_INTERIOR = 12.0f;  // Max zoom inside WMOs
     bool extendedZoom_ = false;
     static constexpr float ZOOM_SMOOTH_SPEED = 15.0f;  // How fast zoom eases
-    static constexpr float CAM_SMOOTH_SPEED_DEFAULT = 30.0f;
-    float camSmoothSpeed_ = CAM_SMOOTH_SPEED_DEFAULT;  // User-configurable camera smoothing (higher = tighter)
-public:
-    void setCameraSmoothSpeed(float speed) { camSmoothSpeed_ = std::clamp(speed, 5.0f, 100.0f); }
-    float getCameraSmoothSpeed() const { return camSmoothSpeed_; }
-    void setPivotHeight(float h) { pivotHeight_ = std::clamp(h, 0.0f, 3.0f); }
-    float getPivotHeight() const { return pivotHeight_; }
-private:
-    static constexpr float PIVOT_HEIGHT_DEFAULT = 1.6f;
-    float pivotHeight_ = PIVOT_HEIGHT_DEFAULT;  // User-configurable pivot height
+    static constexpr float CAM_SMOOTH_SPEED = 20.0f;   // How fast camera position smooths
+    static constexpr float PIVOT_HEIGHT = 1.8f;     // Pivot at head height
     static constexpr float CAM_SPHERE_RADIUS = 0.32f;  // Keep camera farther from geometry to avoid clipping-through surfaces
     static constexpr float CAM_EPSILON = 0.22f;        // Extra wall offset to avoid near-plane clipping artifacts
     static constexpr float COLLISION_FOCUS_RADIUS_THIRD_PERSON = 20.0f;  // Reduced for performance
     static constexpr float COLLISION_FOCUS_RADIUS_FREE_FLY = 20.0f;
     static constexpr float MIN_PITCH = -88.0f;      // Look almost straight down
-    static constexpr float MAX_PITCH = 88.0f;       // Look almost straight up (WoW standard)
+    static constexpr float MAX_PITCH = 35.0f;       // Limited upward look
     glm::vec3* followTarget = nullptr;
     glm::vec3 smoothedCamPos = glm::vec3(0.0f);     // For smooth camera movement
-    float smoothedCollisionDist_ = -1.0f;           // Asymmetrically-smoothed WMO collision limit (-1 = uninitialised)
 
     // Gravity / grounding
     float verticalVelocity = 0.0f;
@@ -278,8 +214,6 @@ private:
 
     // Movement input suppression (after teleport/portal, ignore held keys)
     float movementSuppressTimer_ = 0.0f;
-    // Gravity suspension (after world entry, hold Z until ground detected)
-    float gravitySuspendTimer_ = 0.0f;
 
     // State
     bool enabled = true;
@@ -290,11 +224,6 @@ private:
     bool autoRunning = false;
     bool tildeWasDown = false;
 
-    // Auto-follow target position (WoW /follow). Non-null when following.
-    const glm::vec3* autoFollowTarget_ = nullptr;
-    static constexpr float FOLLOW_STOP_DIST = 3.0f;   // Stop within 3 units of target
-    static constexpr float FOLLOW_MAX_DIST  = 40.0f;  // Cancel if > 40 units away
-
     // Movement state tracking (for sending opcodes on state change)
     bool wasMovingForward = false;
     bool wasMovingBackward = false;
@@ -304,8 +233,6 @@ private:
     bool wasTurningRight = false;
     bool wasJumping = false;
     bool wasFalling = false;
-    bool wasAscending_ = false;   // Space held while flyingActive_
-    bool wasDescending_ = false;  // X held while flyingActive_
     bool moveForwardActive = false;
     bool moveBackwardActive = false;
     bool strafeLeftActive = false;
@@ -313,9 +240,6 @@ private:
 
     // Movement callback
     MovementCallback movementCallback;
-    StandUpCallback standUpCallback_;
-    SitDownCallback sitDownCallback_;
-    AutoFollowCancelCallback autoFollowCancelCallback_;
 
     // Movement speeds
     bool useWoWSpeed = false;
@@ -334,27 +258,8 @@ private:
         return std::sqrt(2.0f * std::abs(MOUNT_GRAVITY) * MOUNT_JUMP_HEIGHT);
     }
 
-    // Server-driven speed overrides (0 = use hardcoded default)
+    // Server-driven run speed override (0 = use default WOW_RUN_SPEED)
     float runSpeedOverride_ = 0.0f;
-    float walkSpeedOverride_ = 0.0f;
-    float swimSpeedOverride_ = 0.0f;
-    float swimBackSpeedOverride_ = 0.0f;
-    float flightSpeedOverride_ = 0.0f;
-    float flightBackSpeedOverride_ = 0.0f;
-    float runBackSpeedOverride_ = 0.0f;
-    float turnRateOverride_ = 0.0f;  // rad/s; 0 = WOW_TURN_SPEED default (π rad/s)
-    // Server-driven root state: when true, block all horizontal movement input.
-    bool movementRooted_ = false;
-    // Server-driven gravity disable (levitate/hover): skip gravity accumulation.
-    bool gravityDisabled_ = false;
-    // Server-driven feather fall: cap downward velocity to slow-fall terminal.
-    bool featherFallActive_ = false;
-    // Server-driven water walk: treat water surface as ground (don't swim).
-    bool waterWalkActive_ = false;
-    // Player-controlled flight (CAN_FLY + FLYING): 3D movement, no gravity.
-    bool flyingActive_ = false;
-    // Server-driven hover (HOVER flag): float at fixed height above ground.
-    bool hoverActive_ = false;
     bool mounted_ = false;
     float mountHeightOffset_ = 0.0f;
     bool externalMoving_ = false;
@@ -406,20 +311,6 @@ private:
     float cachedFloorHeight_ = 0.0f;
     bool hasCachedFloor_ = false;
     static constexpr float COLLISION_CACHE_DISTANCE = 0.15f;  // Re-check every 15cm
-
-    // Server-driven knockback state.
-    // When the server sends SMSG_MOVE_KNOCK_BACK, we apply horizontal + vertical
-    // impulse here and let the normal physics loop (gravity, collision) resolve it.
-    bool knockbackActive_ = false;
-    glm::vec2 knockbackHorizVel_ = glm::vec2(0.0f); // render-space horizontal velocity (units/s)
-    // Horizontal velocity decays via WoW-like drag so the player doesn't slide forever.
-    static constexpr float KNOCKBACK_HORIZ_DRAG = 4.5f; // exponential decay rate (1/s)
-
-    // Camera shake state (SMSG_CAMERA_SHAKE)
-    float shakeElapsed_   = 0.0f;
-    float shakeDuration_  = 0.0f;
-    float shakeMagnitude_ = 0.0f;
-    float shakeFrequency_ = 0.0f;
 };
 
 } // namespace rendering
diff --git a/include/rendering/character_preview.hpp b/include/rendering/character_preview.hpp
index edacc289..7ff5352c 100644
--- a/include/rendering/character_preview.hpp
+++ b/include/rendering/character_preview.hpp
@@ -75,17 +75,12 @@ private:
     void* previewUBOMapped_[MAX_FRAMES] = {};
     VkDescriptorSet previewPerFrameSet_[MAX_FRAMES] = {};
 
-    // Dummy 1x1 depth texture for shadow map placeholder (sampler2DShadow compatible)
-    VkImage dummyShadowImage_ = VK_NULL_HANDLE;
-    VkImageView dummyShadowView_ = VK_NULL_HANDLE;
-    VmaAllocation dummyShadowAlloc_ = VK_NULL_HANDLE;
-    VkSampler dummyShadowSampler_ = VK_NULL_HANDLE; // owned by VkContext sampler cache
+    // Dummy 1x1 white texture for shadow map placeholder
+    std::unique_ptr<VkTexture> dummyWhiteTex_;
 
     // ImGui texture handle for displaying the preview (VkDescriptorSet in Vulkan backend)
     VkDescriptorSet imguiTextureId_ = VK_NULL_HANDLE;
 
-    // 4:5 portrait aspect ratio — taller than wide to show full character body
-    // from head to feet in the character creation/selection screen
     static constexpr int fboWidth_ = 400;
     static constexpr int fboHeight_ = 500;
 
diff --git a/include/rendering/character_renderer.hpp b/include/rendering/character_renderer.hpp
index 025f9924..7a01c0d7 100644
--- a/include/rendering/character_renderer.hpp
+++ b/include/rendering/character_renderer.hpp
@@ -13,7 +13,6 @@
 #include <utility>
 #include <future>
 #include <deque>
-#include <condition_variable>
 #include <mutex>
 #include <atomic>
 
@@ -79,7 +78,6 @@ public:
     void setInstanceRotation(uint32_t instanceId, const glm::vec3& rotation);
     void moveInstanceTo(uint32_t instanceId, const glm::vec3& destination, float durationSeconds);
     void startFadeIn(uint32_t instanceId, float durationSeconds);
-    void setInstanceOpacity(uint32_t instanceId, float opacity);
     const pipeline::M2Model* getModelData(uint32_t modelId) const;
     void setActiveGeosets(uint32_t instanceId, const std::unordered_set<uint16_t>& geosets);
     void setGroupTextureOverride(uint32_t instanceId, uint16_t geosetGroup, VkTexture* texture);
@@ -93,7 +91,6 @@ public:
     bool getInstanceModelName(uint32_t instanceId, std::string& modelName) const;
     bool getInstanceBounds(uint32_t instanceId, glm::vec3& outCenter, float& outRadius) const;
     bool getInstanceFootZ(uint32_t instanceId, float& outFootZ) const;
-    bool getInstancePosition(uint32_t instanceId, glm::vec3& outPos) const;
 
     /** Debug: Log all available animations for an instance */
     void dumpAnimations(uint32_t instanceId) const;
@@ -158,7 +155,6 @@ private:
         uint32_t currentAnimationId = 0;
         int currentSequenceIndex = -1;  // Index into M2Model::sequences
         float animationTime = 0.0f;
-        float globalSequenceTime = 0.0f; // Separate timer for global sequences (accumulates without wrapping at sequence duration)
         bool animationLoop = true;
         bool isDead = false;  // Prevents movement while in death state
         std::vector<glm::mat4> boneMatrices;  // Current bone transforms
@@ -207,11 +203,10 @@ private:
     void calculateBindPose(M2ModelGPU& gpuModel);
     void updateAnimation(CharacterInstance& instance, float deltaTime);
     void calculateBoneMatrices(CharacterInstance& instance);
-    glm::mat4 getBoneTransform(const pipeline::M2Bone& bone, float animTime, float globalSeqTime,
-                               int sequenceIndex, const std::vector<uint32_t>& globalSeqDurations);
+    glm::mat4 getBoneTransform(const pipeline::M2Bone& bone, float time, int sequenceIndex);
     glm::mat4 getModelMatrix(const CharacterInstance& instance) const;
-    void destroyModelGPU(M2ModelGPU& gpuModel, bool defer = false);
-    void destroyInstanceBones(CharacterInstance& inst, bool defer = false);
+    void destroyModelGPU(M2ModelGPU& gpuModel);
+    void destroyInstanceBones(CharacterInstance& inst);
 
     // Keyframe interpolation helpers
     static int findKeyframeIndex(const std::vector<uint32_t>& timestamps, float time);
@@ -220,10 +215,6 @@ private:
     static glm::quat interpolateQuat(const pipeline::M2AnimationTrack& track,
                                       int seqIdx, float time);
 
-    // Attachment point lookup helper — shared by attachWeapon() and getAttachmentTransform()
-    bool findAttachmentBone(uint32_t modelId, uint32_t attachmentId,
-                           uint16_t& outBoneIndex, glm::vec3& outOffset) const;
-
 public:
     /**
      * Build a composited character skin texture by alpha-blending overlay
@@ -253,10 +244,6 @@ public:
 
 
 private:
-    // Create 1×1 fallback textures used when real textures are missing or still loading.
-    // Called during both init and clear to ensure valid descriptor bindings at all times.
-    void createFallbackTextures(VkDevice device);
-
     VkContext* vkCtx_ = nullptr;
     VkRenderPass renderPassOverride_ = VK_NULL_HANDLE;
     VkSampleCountFlagBits msaaSamplesOverride_ = VK_SAMPLE_COUNT_1_BIT;
@@ -299,16 +286,11 @@ private:
         bool normalMapPending = false;  // deferred normal map generation
     };
     std::unordered_map<std::string, TextureCacheEntry> textureCache;
-    struct TextureProperties {
-        bool hasAlpha = false;
-        bool colorKeyBlack = false;
-    };
-    std::unordered_map<VkTexture*, TextureProperties> texturePropsByPtr_;
+    std::unordered_map<VkTexture*, bool> textureHasAlphaByPtr_;
+    std::unordered_map<VkTexture*, bool> textureColorKeyBlackByPtr_;
     std::unordered_map<std::string, VkTexture*> compositeCache_;  // key → texture for reuse
     std::unordered_set<std::string> failedTextureCache_;  // negative cache for budget exhaustion
-    std::unordered_map<std::string, uint64_t> failedTextureRetryAt_;
     std::unordered_set<std::string> loggedTextureLoadFails_;  // dedup warning logs
-    uint64_t textureLookupSerial_ = 0;
     size_t textureCacheBytes_ = 0;
     uint64_t textureCacheCounter_ = 0;
     size_t textureCacheBudgetBytes_ = 1024ull * 1024 * 1024;
@@ -335,7 +317,6 @@ private:
     };
     // Completed results ready for GPU upload (populated by background threads)
     std::mutex normalMapResultsMutex_;
-    std::condition_variable normalMapDoneCV_;  // signaled when pendingNormalMapCount_ reaches 0
     std::deque<NormalMapResult> completedNormalMaps_;
     std::atomic<int> pendingNormalMapCount_{0};  // in-flight background tasks
 
diff --git a/include/rendering/loading_screen.hpp b/include/rendering/loading_screen.hpp
index a0ed13a5..afd134b9 100644
--- a/include/rendering/loading_screen.hpp
+++ b/include/rendering/loading_screen.hpp
@@ -30,7 +30,6 @@ public:
 
     void setProgress(float progress) { loadProgress = progress; }
     void setStatus(const std::string& status) { statusText = status; }
-    void setZoneName(const std::string& name) { zoneName = name; }
 
     // Must be set before initialize() for Vulkan texture upload
     void setVkContext(VkContext* ctx) { vkCtx = ctx; }
@@ -54,7 +53,6 @@ private:
 
     float loadProgress = 0.0f;
     std::string statusText = "Loading...";
-    std::string zoneName;
 
     int imageWidth = 0;
     int imageHeight = 0;
diff --git a/include/rendering/m2_model_classifier.hpp b/include/rendering/m2_model_classifier.hpp
deleted file mode 100644
index 8ef09aab..00000000
--- a/include/rendering/m2_model_classifier.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#pragma once
-
-#include <glm/glm.hpp>
-#include <string>
-#include <cstddef>
-
-namespace wowee {
-namespace rendering {
-
-/**
- * Output of classifyM2Model(): all name/geometry-based flags for an M2 model.
- * Pure data — no Vulkan, GPU, or asset-manager dependencies.
- */
-struct M2ClassificationResult {
-    // --- Collision shape selectors ---
-    bool collisionNoBlock            = false; ///< Foliage/soft-trees/rugs: no blocking
-    bool collisionBridge             = false; ///< Walk-on-top bridge/plank/walkway
-    bool collisionPlanter            = false; ///< Low stepped planter/curb
-    bool collisionSteppedFountain    = false; ///< Stepped fountain base
-    bool collisionSteppedLowPlatform = false; ///< Low stepped platform (curb/planter/bridge)
-    bool collisionStatue             = false; ///< Statue/monument/sculpture
-    bool collisionSmallSolidProp     = false; ///< Blockable solid prop (crate/chest/barrel)
-    bool collisionNarrowVerticalProp = false; ///< Narrow tall prop (lamp/post/pole)
-    bool collisionTreeTrunk          = false; ///< Tree trunk cylinder
-
-    // --- Rendering / effect classification ---
-    bool isFoliageLike      = false; ///< Foliage or tree (wind sway, disabled animation)
-    bool isSpellEffect      = false; ///< Spell effect / particle-dominated visual
-    bool isLavaModel        = false; ///< Lava surface (UV scroll animation)
-    bool isInstancePortal   = false; ///< Instance portal (additive, spin, no collision)
-    bool isWaterVegetation  = false; ///< Aquatic vegetation (cattails, kelp, reeds, etc.)
-    bool isFireflyEffect    = false; ///< Ambient creature (exempt from particle dampeners)
-    bool isElvenLike        = false; ///< Night elf / Blood elf themed model
-    bool isLanternLike      = false; ///< Lantern/lamp/light model
-    bool isKoboldFlame      = false; ///< Kobold candle/torch model
-    bool isGroundDetail     = false; ///< Ground-clutter detail doodad (always non-blocking)
-    bool isInvisibleTrap    = false; ///< Event-object invisible trap (no render, no collision)
-    bool isSmoke            = false; ///< Smoke model (UV scroll animation)
-
-    // --- Animation flags ---
-    bool disableAnimation   = false; ///< Keep visually stable (foliage, chest lids, etc.)
-    bool shadowWindFoliage  = false; ///< Apply wind sway in shadow pass for foliage/trees
-};
-
-/**
- * Classify an M2 model by name and geometry.
- *
- * Pure function — no Vulkan, VkContext, or AssetManager dependencies.
- * All results are derived solely from the model name string and tight vertex bounds.
- *
- * @param name         Full model path/name from the M2 header (any case)
- * @param boundsMin    Per-vertex tight bounding-box minimum
- * @param boundsMax    Per-vertex tight bounding-box maximum
- * @param vertexCount  Number of mesh vertices
- * @param emitterCount Number of particle emitters
- */
-M2ClassificationResult classifyM2Model(
-    const std::string& name,
-    const glm::vec3&   boundsMin,
-    const glm::vec3&   boundsMax,
-    std::size_t        vertexCount,
-    std::size_t        emitterCount);
-
-// ---------------------------------------------------------------------------
-// Batch texture classification
-// ---------------------------------------------------------------------------
-
-/**
- * Per-batch texture key classification — glow / tint token flags.
- * Input must be a lowercased, backslash-normalised texture path (as stored in
- * M2Renderer's textureKeysLower vector).  Pure data — no Vulkan dependencies.
- */
-struct M2BatchTexClassification {
-    bool exactLanternGlowTex = false; ///< One of the known exact lantern-glow texture paths
-    bool hasGlowToken        = false; ///< glow / flare / halo / light
-    bool hasFlameToken       = false; ///< flame / fire / flamelick / ember
-    bool hasGlowCardToken    = false; ///< glow / flamelick / lensflare / t_vfx / lightbeam / glowball / genericglow
-    bool likelyFlame         = false; ///< fire / flame / torch
-    bool lanternFamily       = false; ///< lantern / lamp / elf / silvermoon / quel / thalas
-    int  glowTint            = 0;     ///< 0 = neutral, 1 = cool (blue/arcane), 2 = warm (red/scarlet)
-};
-
-/**
- * Classify a batch texture by its lowercased path for glow/tint hinting.
- *
- * Pure function — no Vulkan, VkContext, or AssetManager dependencies.
- *
- * @param lowerTexKey Lowercased, backslash-normalised texture path (may be empty)
- */
-M2BatchTexClassification classifyBatchTexture(const std::string& lowerTexKey);
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/m2_renderer.hpp b/include/rendering/m2_renderer.hpp
index 85c62df9..a37c4a2d 100644
--- a/include/rendering/m2_renderer.hpp
+++ b/include/rendering/m2_renderer.hpp
@@ -5,16 +5,13 @@
 #include <vulkan/vulkan.h>
 #include <vk_mem_alloc.h>
 #include <glm/glm.hpp>
-#include <atomic>
 #include <memory>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
-#include <deque>
 #include <string>
 #include <optional>
 #include <random>
-#include <chrono>
 #include <future>
 
 namespace wowee {
@@ -125,18 +122,11 @@ struct M2ModelGPU {
     bool isKoboldFlame = false;     // Model name matches kobold+(candle/torch/mine) (precomputed)
     bool isLavaModel = false;       // Model name contains lava/molten/magma (UV scroll fallback)
     bool hasTextureAnimation = false; // True if any batch has UV animation
-    bool hasTransparentBatches = false; // True if any batch uses alpha-blend or additive (blendMode >= 2)
     uint8_t availableLODs = 0;  // Bitmask: bit N set if any batch has submeshLevel==N
 
     // Particle emitter data (kept from M2Model)
     std::vector<pipeline::M2ParticleEmitter> particleEmitters;
-    std::vector<VkTexture*> particleTextures;    // Resolved Vulkan textures per emitter
-    std::vector<VkDescriptorSet> particleTexSets; // Pre-allocated descriptor sets per emitter (stable, avoids per-frame alloc)
-
-    // Ribbon emitter data (kept from M2Model)
-    std::vector<pipeline::M2RibbonEmitter> ribbonEmitters;
-    std::vector<VkTexture*> ribbonTextures;       // Resolved texture per ribbon emitter
-    std::vector<VkDescriptorSet> ribbonTexSets;   // Descriptor sets per ribbon emitter
+    std::vector<VkTexture*> particleTextures;  // Resolved Vulkan textures per emitter
 
     // Texture transform data for UV animation
     std::vector<pipeline::M2TextureTransform> textureTransforms;
@@ -188,19 +178,6 @@ struct M2Instance {
     std::vector<float> emitterAccumulators;  // fractional particle counter per emitter
     std::vector<M2Particle> particles;
 
-    // Ribbon emitter state
-    struct RibbonEdge {
-        glm::vec3 worldPos;   // Spine world position when this edge was born
-        glm::vec3 color;      // Interpolated color at birth
-        float     alpha;      // Interpolated alpha at birth
-        float     heightAbove;// Half-width above spine
-        float     heightBelow;// Half-width below spine
-        float     age;        // Seconds since spawned
-    };
-    // One deque of edges per ribbon emitter on this instance
-    std::vector<std::deque<RibbonEdge>> ribbonEdges;
-    std::vector<float> ribbonEdgeAccumulators; // fractional edge counter per emitter
-
     // Cached model flags (set at creation to avoid per-frame hash lookups)
     bool cachedHasAnimation = false;
     bool cachedDisableAnimation = false;
@@ -219,15 +196,12 @@ struct M2Instance {
     uint8_t frameSkipCounter = 0;
     bool bonesDirty[2] = {false, false};  // Per-frame-index: set when bones recomputed, cleared after upload
 
-    // Per-instance bone SSBO (double-buffered) — legacy; see mega bone SSBO in M2Renderer
+    // Per-instance bone SSBO (double-buffered)
     ::VkBuffer boneBuffer[2] = {};
     VmaAllocation boneAlloc[2] = {};
     void* boneMapped[2] = {};
     VkDescriptorSet boneSet[2] = {};
 
-    // Mega bone SSBO offset — base bone index for this instance (set per-frame in prepareRender)
-    uint32_t megaBoneOffset = 0;
-
     void updateModelMatrix();
 };
 
@@ -295,8 +269,6 @@ public:
      */
     /** Pre-allocate GPU resources (bone SSBOs, descriptors) on main thread before parallel render. */
     void prepareRender(uint32_t frameIndex, const Camera& camera);
-    /** Dispatch GPU frustum culling compute shader on primary cmd before render pass. */
-    void dispatchCullCompute(VkCommandBuffer cmd, uint32_t frameIndex, const Camera& camera);
     void render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const Camera& camera);
 
     /**
@@ -321,20 +293,9 @@ public:
      */
     void renderSmokeParticles(VkCommandBuffer cmd, VkDescriptorSet perFrameSet);
 
-    /**
-     * Render M2 ribbon emitters (spell trails / wing effects)
-     */
-    void renderM2Ribbons(VkCommandBuffer cmd, VkDescriptorSet perFrameSet);
-
     void setInstancePosition(uint32_t instanceId, const glm::vec3& position);
     void setInstanceTransform(uint32_t instanceId, const glm::mat4& transform);
     void setInstanceAnimationFrozen(uint32_t instanceId, bool frozen);
-    /// Set the animation sequence by animation ID (e.g. anim::OPEN, anim::CLOSE).
-    /// Finds the first sequence with matching ID. Unfreezes the instance and resets time.
-    void setInstanceAnimation(uint32_t instanceId, uint32_t animationId, bool loop = true);
-    /// Check if a model instance has a specific animation ID in its sequence table.
-    bool hasAnimation(uint32_t instanceId, uint32_t animationId) const;
-    float getInstanceAnimDuration(uint32_t instanceId) const;
     void removeInstance(uint32_t instanceId);
     void removeInstances(const std::vector<uint32_t>& instanceIds);
     void setSkipCollision(uint32_t instanceId, bool skip);
@@ -401,9 +362,8 @@ private:
     VkDescriptorSet shadowParamsSet_ = VK_NULL_HANDLE;
     ::VkBuffer shadowParamsUBO_ = VK_NULL_HANDLE;
     VmaAllocation shadowParamsAlloc_ = VK_NULL_HANDLE;
-    // Per-frame pools for foliage shadow texture descriptor sets (one per frame-in-flight)
-    static constexpr uint32_t kShadowTexPoolFrames = 2;
-    VkDescriptorPool shadowTexPool_[kShadowTexPoolFrames] = {};
+    // Per-frame pool for foliage shadow texture descriptor sets
+    VkDescriptorPool shadowTexPool_ = VK_NULL_HANDLE;
 
     // Particle pipelines
     VkPipeline particlePipeline_ = VK_NULL_HANDLE;       // M2 emitter particles
@@ -412,11 +372,6 @@ private:
     VkPipeline smokePipeline_ = VK_NULL_HANDLE;           // Smoke particles
     VkPipelineLayout smokePipelineLayout_ = VK_NULL_HANDLE;
 
-    // Ribbon pipelines (additive + alpha-blend)
-    VkPipeline ribbonPipeline_ = VK_NULL_HANDLE;          // Alpha-blend ribbons
-    VkPipeline ribbonAdditivePipeline_ = VK_NULL_HANDLE;  // Additive ribbons
-    VkPipelineLayout ribbonPipelineLayout_ = VK_NULL_HANDLE;
-
     // Descriptor set layouts
     VkDescriptorSetLayout materialSetLayout_ = VK_NULL_HANDLE;  // set 1
     VkDescriptorSetLayout boneSetLayout_ = VK_NULL_HANDLE;      // set 2
@@ -425,80 +380,8 @@ private:
     // Descriptor pools
     VkDescriptorPool materialDescPool_ = VK_NULL_HANDLE;
     VkDescriptorPool boneDescPool_ = VK_NULL_HANDLE;
-    static constexpr uint32_t MAX_MATERIAL_SETS = 16384;
-    static constexpr uint32_t MAX_BONE_SETS = 16384;
-
-    // Dummy identity bone buffer + descriptor set for non-animated models.
-    // The pipeline layout declares set 2 (bones) and some drivers (Intel ANV)
-    // require all declared sets to be bound even when the shader doesn't access them.
-    ::VkBuffer dummyBoneBuffer_ = VK_NULL_HANDLE;
-    VmaAllocation dummyBoneAlloc_ = VK_NULL_HANDLE;
-    VkDescriptorSet dummyBoneSet_ = VK_NULL_HANDLE;
-
-    // Mega bone SSBO — consolidates all per-instance bone matrices into a single buffer per frame.
-    // Replaces per-instance bone SSBOs for fewer descriptor binds and enables GPU instancing.
-    static constexpr uint32_t MEGA_BONE_MAX_INSTANCES = 2048;
-    static constexpr uint32_t MAX_BONES_PER_INSTANCE = 128;
-    ::VkBuffer megaBoneBuffer_[2] = {};
-    VmaAllocation megaBoneAlloc_[2] = {};
-    void* megaBoneMapped_[2] = {};
-    VkDescriptorSet megaBoneSet_[2] = {};
-
-    // GPU instance data SSBO — per-instance transforms, fade, bones for instanced draws.
-    // Shader reads instanceData[push.instanceDataOffset + gl_InstanceIndex].
-    struct M2InstanceGPU {
-        glm::mat4 model;           // 64 bytes @ offset 0
-        glm::vec2 uvOffset;        //  8 bytes @ offset 64
-        float fadeAlpha;           //  4 bytes @ offset 72
-        int32_t useBones;          //  4 bytes @ offset 76
-        int32_t boneBase;          //  4 bytes @ offset 80
-        int32_t _pad[3] = {};      // 12 bytes @ offset 84 — align to 96 (std430)
-    };
-    static constexpr uint32_t MAX_INSTANCE_DATA = 16384;
-    VkDescriptorSetLayout instanceSetLayout_ = VK_NULL_HANDLE;
-    VkDescriptorPool instanceDescPool_ = VK_NULL_HANDLE;
-    ::VkBuffer instanceBuffer_[2] = {};
-    VmaAllocation instanceAlloc_[2] = {};
-    void* instanceMapped_[2] = {};
-    VkDescriptorSet instanceSet_[2] = {};
-    uint32_t instanceDataCount_ = 0; // reset each frame in render()
-
-    // GPU Frustum Culling via Compute Shader
-    // Compute shader tests each M2 instance against frustum planes + distance, writes visibility[].
-    // CPU reads back visibility to build sortedVisible_ without per-instance frustum/distance tests.
-    struct CullInstanceGPU {        // matches CullInstance in m2_cull.comp.glsl (32 bytes, std430)
-        glm::vec4 sphere;           // xyz = world position, w = padded radius
-        float effectiveMaxDistSq;   // adaptive distance cull threshold
-        uint32_t flags;             // bit 0 = valid, bit 1 = smoke, bit 2 = invisibleTrap
-        float _pad[2] = {};
-    };
-    struct CullUniformsGPU {        // matches CullUniforms in m2_cull.comp.glsl (128 bytes, std140)
-        glm::vec4 frustumPlanes[6]; // xyz = normal, w = distance
-        glm::vec4 cameraPos;        // xyz = camera position, w = maxPossibleDistSq
-        uint32_t instanceCount;
-        uint32_t _pad[3] = {};
-    };
-    static constexpr uint32_t MAX_CULL_INSTANCES = 24576;
-    VkPipeline cullPipeline_ = VK_NULL_HANDLE;
-    VkPipelineLayout cullPipelineLayout_ = VK_NULL_HANDLE;
-    VkDescriptorSetLayout cullSetLayout_ = VK_NULL_HANDLE;
-    VkDescriptorPool cullDescPool_ = VK_NULL_HANDLE;
-    VkDescriptorSet cullSet_[2] = {};               // double-buffered
-    ::VkBuffer cullUniformBuffer_[2] = {};           // frustum planes + camera (UBO)
-    VmaAllocation cullUniformAlloc_[2] = {};
-    void* cullUniformMapped_[2] = {};
-    ::VkBuffer cullInputBuffer_[2] = {};             // per-instance bounding sphere + flags (SSBO)
-    VmaAllocation cullInputAlloc_[2] = {};
-    void* cullInputMapped_[2] = {};
-    ::VkBuffer cullOutputBuffer_[2] = {};            // uint visibility[] (SSBO, host-readable)
-    VmaAllocation cullOutputAlloc_[2] = {};
-    void* cullOutputMapped_[2] = {};
-
-    // Dynamic ribbon vertex buffer (CPU-written triangle strip)
-    static constexpr size_t MAX_RIBBON_VERTS = 2048;  // 9 floats each
-    ::VkBuffer ribbonVB_ = VK_NULL_HANDLE;
-    VmaAllocation ribbonVBAlloc_ = VK_NULL_HANDLE;
-    void* ribbonVBMapped_ = nullptr;
+    static constexpr uint32_t MAX_MATERIAL_SETS = 8192;
+    static constexpr uint32_t MAX_BONE_SETS = 8192;
 
     // Dynamic particle buffers
     ::VkBuffer smokeVB_ = VK_NULL_HANDLE;
@@ -514,9 +397,6 @@ private:
     void* glowVBMapped_ = nullptr;
 
     std::unordered_map<uint32_t, M2ModelGPU> models;
-    // Grace period for model cleanup: track when a model first became instanceless.
-    // Models are only evicted after 60 seconds with no instances.
-    std::unordered_map<uint32_t, std::chrono::steady_clock::time_point> modelUnusedSince_;
     std::vector<M2Instance> instances;
 
     // O(1) dedup: key = (modelId, quantized x, quantized y, quantized z) → instanceId
@@ -554,18 +434,13 @@ private:
         bool colorKeyBlack = false;
     };
     std::unordered_map<std::string, TextureCacheEntry> textureCache;
-    struct TextureProperties {
-        bool hasAlpha = false;
-        bool colorKeyBlack = false;
-    };
-    std::unordered_map<VkTexture*, TextureProperties> texturePropsByPtr_;
+    std::unordered_map<VkTexture*, bool> textureHasAlphaByPtr_;
+    std::unordered_map<VkTexture*, bool> textureColorKeyBlackByPtr_;
     size_t textureCacheBytes_ = 0;
     uint64_t textureCacheCounter_ = 0;
     size_t textureCacheBudgetBytes_ = 2048ull * 1024 * 1024;
     std::unordered_set<std::string> failedTextureCache_;
-    std::unordered_map<std::string, uint64_t> failedTextureRetryAt_;
     std::unordered_set<std::string> loggedTextureLoadFails_;
-    uint64_t textureLookupSerial_ = 0;
     uint32_t textureBudgetRejectWarnings_ = 0;
     std::unique_ptr<VkTexture> whiteTexture_;
     std::unique_ptr<VkTexture> glowTexture_;
@@ -602,10 +477,9 @@ private:
     std::unordered_map<uint32_t, size_t> instanceIndexById;
     // Collision scratch buffers are thread_local (see m2_renderer.cpp) for thread-safety.
 
-    // Collision query profiling — atomic because getFloorHeight is dispatched
-    // on async threads from camera_controller while the main thread reads these.
-    mutable std::atomic<double> queryTimeMs{0.0};
-    mutable std::atomic<uint32_t> queryCallCount{0};
+    // Collision query profiling (per frame).
+    mutable double queryTimeMs = 0.0;
+    mutable uint32_t queryCallCount = 0;
 
     // Persistent render buffers (avoid per-frame allocation/deallocation)
     struct VisibleEntry {
@@ -622,49 +496,6 @@ private:
     };
     std::vector<GlowSprite> glowSprites_;  // Reused each frame
 
-    // Shadow-pass texture descriptor cache (reused each frame, cleared via pool reset)
-    std::unordered_map<VkImageView, VkDescriptorSet> shadowTexSetCache_;
-
-    // Ribbon draw-call list (reused each frame)
-    struct RibbonDrawCall {
-        VkDescriptorSet texSet;
-        VkPipeline      pipeline;
-        uint32_t        firstVertex;
-        uint32_t        vertexCount;
-    };
-    std::vector<RibbonDrawCall> ribbonDraws_;
-
-    // Particle group structures (reused each frame)
-    struct ParticleGroupKey {
-        VkTexture* texture;
-        uint8_t blendType;
-        uint16_t tilesX;
-        uint16_t tilesY;
-        bool operator==(const ParticleGroupKey& other) const {
-            return texture == other.texture &&
-                   blendType == other.blendType &&
-                   tilesX == other.tilesX &&
-                   tilesY == other.tilesY;
-        }
-    };
-    struct ParticleGroupKeyHash {
-        size_t operator()(const ParticleGroupKey& key) const {
-            size_t h1 = std::hash<uintptr_t>{}(reinterpret_cast<uintptr_t>(key.texture));
-            size_t h2 = std::hash<uint32_t>{}((static_cast<uint32_t>(key.tilesX) << 16) | key.tilesY);
-            size_t h3 = std::hash<uint8_t>{}(key.blendType);
-            return h1 ^ (h2 * 0x9e3779b9u) ^ (h3 * 0x85ebca6bu);
-        }
-    };
-    struct ParticleGroup {
-        VkTexture* texture;
-        uint8_t blendType;
-        uint16_t tilesX;
-        uint16_t tilesY;
-        VkDescriptorSet preAllocSet = VK_NULL_HANDLE;
-        std::vector<float> vertexData;
-    };
-    std::unordered_map<ParticleGroupKey, ParticleGroup, ParticleGroupKeyHash> particleGroups_;
-
     // Animation update buffers (avoid per-frame allocation)
     std::vector<size_t> boneWorkIndices_;        // Reused each frame
     std::vector<std::future<void>> animFutures_; // Reused each frame
@@ -702,7 +533,6 @@ private:
     glm::vec3 interpFBlockVec3(const pipeline::M2FBlock& fb, float lifeRatio);
     void emitParticles(M2Instance& inst, const M2ModelGPU& gpu, float dt);
     void updateParticles(M2Instance& inst, float dt);
-    void updateRibbons(M2Instance& inst, const M2ModelGPU& gpu, float dt);
 
     // Helper to allocate descriptor sets
     VkDescriptorSet allocateMaterialSet();
@@ -710,10 +540,8 @@ private:
 
     // Helper to destroy model GPU resources
     void destroyModelGPU(M2ModelGPU& model);
-    // Helper to destroy instance bone buffers.
-    // When defer=true, destruction is scheduled via deferAfterFrameFence so
-    // in-flight command buffers are not invalidated (use for streaming unload).
-    void destroyInstanceBones(M2Instance& inst, bool defer = false);
+    // Helper to destroy instance bone buffers
+    void destroyInstanceBones(M2Instance& inst);
 };
 
 } // namespace rendering
diff --git a/include/rendering/mesh.hpp b/include/rendering/mesh.hpp
new file mode 100644
index 00000000..670b5397
--- /dev/null
+++ b/include/rendering/mesh.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <vector>
+#include <GL/glew.h>
+#include <glm/glm.hpp>
+
+namespace wowee {
+namespace rendering {
+
+struct Vertex {
+    glm::vec3 position;
+    glm::vec3 normal;
+    glm::vec2 texCoord;
+};
+
+class Mesh {
+public:
+    Mesh() = default;
+    ~Mesh();
+
+    void create(const std::vector<Vertex>& vertices, const std::vector<uint32_t>& indices);
+    void destroy();
+    void draw() const;
+
+private:
+    GLuint VAO = 0;
+    GLuint VBO = 0;
+    GLuint EBO = 0;
+    size_t indexCount = 0;
+};
+
+} // namespace rendering
+} // namespace wowee
diff --git a/include/rendering/minimap.hpp b/include/rendering/minimap.hpp
index 906f4666..ca7c5345 100644
--- a/include/rendering/minimap.hpp
+++ b/include/rendering/minimap.hpp
@@ -7,7 +7,6 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
-#include <deque>
 #include <algorithm>
 
 namespace wowee {
@@ -74,10 +73,7 @@ private:
     bool trsParsed = false;
 
     // Tile texture cache: hash → VkTexture
-    // Evicted (FIFO) when the count of successfully-loaded tiles exceeds MAX_TILE_CACHE.
-    static constexpr size_t MAX_TILE_CACHE = 128;
     std::unordered_map<std::string, std::unique_ptr<VkTexture>> tileTextureCache;
-    std::deque<std::string> tileInsertionOrder;  // hashes of successfully loaded tiles, oldest first
     std::unique_ptr<VkTexture> noDataTexture;
 
     // Composite render target (3x3 tiles = 768x768)
diff --git a/include/rendering/post_process_pipeline.hpp b/include/rendering/post_process_pipeline.hpp
deleted file mode 100644
index 74c4c9b7..00000000
--- a/include/rendering/post_process_pipeline.hpp
+++ /dev/null
@@ -1,284 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <cstdint>
-#include <glm/glm.hpp>
-#include <vulkan/vulkan.h>
-#include <vk_mem_alloc.h>
-#include "rendering/vk_utils.hpp"
-#if WOWEE_HAS_AMD_FSR2
-#include "ffx_fsr2.h"
-#include "ffx_fsr2_vk.h"
-#endif
-
-namespace wowee {
-namespace rendering {
-
-class VkContext;
-class Camera;
-class AmdFsr3Runtime;
-
-/// Returned by setFSREnabled/setFSR2Enabled when they need the Renderer
-/// to schedule an MSAA sample-count change (§4.3).
-struct MsaaChangeRequest {
-    bool requested = false;
-    VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
-};
-
-/// PostProcessPipeline owns all FSR 1.0, FXAA, and FSR 2.2/3 state and
-/// orchestrates post-processing passes between the scene render pass and
-/// the final swapchain presentation (§4.3 extraction from Renderer).
-class PostProcessPipeline {
-public:
-    PostProcessPipeline();
-    ~PostProcessPipeline();
-
-    void initialize(VkContext* ctx);
-    void shutdown();
-
-    // --- Frame-loop integration (called from Renderer::beginFrame) ---
-
-    /// Lazy-create / lazy-destroy FSR/FXAA/FSR2 resources between frames.
-    void manageResources();
-
-    /// Recreate post-process resources after swapchain resize.
-    void handleSwapchainResize();
-
-    /// Apply FSR2 temporal jitter to the camera projection.
-    void applyJitter(Camera* camera);
-
-    /// Returns the framebuffer the scene should render into.
-    /// If no post-processing is active, returns VK_NULL_HANDLE (use swapchain).
-    VkFramebuffer getSceneFramebuffer() const;
-
-    /// Returns the render extent for the active post-process pipeline.
-    /// Falls back to swapchain extent if nothing is active.
-    VkExtent2D getSceneRenderExtent() const;
-
-    /// True if any post-process pipeline is active (FSR/FXAA/FSR2).
-    bool hasActivePostProcess() const;
-
-    /// True when FXAA alone (no FSR2) needs its own off-screen pass.
-    bool useFXAAPostPass() const { return fxaa_.enabled; }
-
-    // --- Frame-loop integration (called from Renderer::endFrame) ---
-
-    /// Execute all post-processing passes.  Returns true if an INLINE
-    /// render pass was started (affects ImGui recording mode).
-    bool executePostProcessing(VkCommandBuffer cmd, uint32_t imageIndex,
-                               Camera* camera, float deltaTime);
-
-    // --- MSAA interop (called from Renderer::applyMsaaChange) ---
-
-    /// Destroy FSR/FSR2/FXAA resources (they will be lazily recreated).
-    void destroyAllResources();
-
-    /// True when FSR2 is active and MSAA changes should be blocked.
-    bool isFsr2BlockingMsaa() const { return fsr2_.enabled; }
-
-    // --- Public API (delegated from Renderer) ---
-
-    // FXAA
-    void setFXAAEnabled(bool enabled);
-    bool isFXAAEnabled() const { return fxaa_.enabled; }
-
-    // FSR 1.0
-    MsaaChangeRequest setFSREnabled(bool enabled);
-    bool isFSREnabled() const { return fsr_.enabled; }
-    void setFSRQuality(float scaleFactor);
-    void setFSRSharpness(float sharpness);
-    float getFSRScaleFactor() const { return fsr_.scaleFactor; }
-    float getFSRSharpness() const { return fsr_.sharpness; }
-
-    // FSR 2.2
-    MsaaChangeRequest setFSR2Enabled(bool enabled, Camera* camera);
-    bool isFSR2Enabled() const { return fsr2_.enabled; }
-    void setFSR2DebugTuning(float jitterSign, float motionVecScaleX, float motionVecScaleY);
-
-    // FSR3 Framegen
-    void setAmdFsr3FramegenEnabled(bool enabled);
-    bool isAmdFsr3FramegenEnabled() const { return fsr2_.amdFsr3FramegenEnabled; }
-    float getFSR2JitterSign() const { return fsr2_.jitterSign; }
-    float getFSR2MotionVecScaleX() const { return fsr2_.motionVecScaleX; }
-    float getFSR2MotionVecScaleY() const { return fsr2_.motionVecScaleY; }
-#if WOWEE_HAS_AMD_FSR2
-    bool isAmdFsr2SdkAvailable() const { return true; }
-#else
-    bool isAmdFsr2SdkAvailable() const { return false; }
-#endif
-#if WOWEE_HAS_AMD_FSR3_FRAMEGEN
-    bool isAmdFsr3FramegenSdkAvailable() const { return true; }
-#else
-    bool isAmdFsr3FramegenSdkAvailable() const { return false; }
-#endif
-    bool isAmdFsr3FramegenRuntimeActive() const { return fsr2_.amdFsr3FramegenRuntimeActive; }
-    bool isAmdFsr3FramegenRuntimeReady() const { return fsr2_.amdFsr3FramegenRuntimeReady; }
-    const char* getAmdFsr3FramegenRuntimePath() const;
-    const std::string& getAmdFsr3FramegenRuntimeError() const { return fsr2_.amdFsr3RuntimeLastError; }
-    size_t getAmdFsr3UpscaleDispatchCount() const { return fsr2_.amdFsr3UpscaleDispatchCount; }
-    size_t getAmdFsr3FramegenDispatchCount() const { return fsr2_.amdFsr3FramegenDispatchCount; }
-    size_t getAmdFsr3FallbackCount() const { return fsr2_.amdFsr3FallbackCount; }
-
-    // Brightness (1.0 = default, <1 darkens, >1 brightens)
-    void setBrightness(float b) { brightness_ = b; }
-    float getBrightness() const { return brightness_; }
-
-private:
-    VkContext* vkCtx_ = nullptr;
-
-    // Per-frame state set during executePostProcessing
-    VkCommandBuffer currentCmd_ = VK_NULL_HANDLE;
-    Camera* camera_ = nullptr;
-    float lastDeltaTime_ = 0.0f;
-
-    // Brightness
-    float brightness_ = 1.0f;
-
-    // FSR 1.0 upscaling state
-    struct FSRState {
-        bool enabled = false;
-        bool needsRecreate = false;
-        float scaleFactor = 1.00f;  // Native default
-        float sharpness = 1.6f;
-        uint32_t internalWidth = 0;
-        uint32_t internalHeight = 0;
-
-        // Off-screen scene target (reduced resolution)
-        AllocatedImage sceneColor{};        // 1x color (non-MSAA render target / MSAA resolve target)
-        AllocatedImage sceneDepth{};        // Depth (matches current MSAA sample count)
-        AllocatedImage sceneMsaaColor{};    // MSAA color target (only when MSAA > 1x)
-        AllocatedImage sceneDepthResolve{}; // Depth resolve (only when MSAA + depth resolve)
-        VkFramebuffer sceneFramebuffer = VK_NULL_HANDLE;
-        VkSampler sceneSampler = VK_NULL_HANDLE;
-
-        // Upscale pipeline
-        VkPipeline pipeline = VK_NULL_HANDLE;
-        VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
-        VkDescriptorSetLayout descSetLayout = VK_NULL_HANDLE;
-        VkDescriptorPool descPool = VK_NULL_HANDLE;
-        VkDescriptorSet descSet = VK_NULL_HANDLE;
-    };
-    FSRState fsr_;
-    bool initFSRResources();
-    void destroyFSRResources();
-    void renderFSRUpscale();
-
-    // FXAA post-process state
-    struct FXAAState {
-        bool enabled       = false;
-        bool needsRecreate = false;
-
-        // Off-screen scene target (same resolution as swapchain — no scaling)
-        AllocatedImage sceneColor{};        // 1x resolved color target
-        AllocatedImage sceneDepth{};        // Depth (matches MSAA sample count)
-        AllocatedImage sceneMsaaColor{};    // MSAA color target (when MSAA > 1x)
-        AllocatedImage sceneDepthResolve{}; // Depth resolve (MSAA + depth resolve)
-        VkFramebuffer sceneFramebuffer = VK_NULL_HANDLE;
-        VkSampler sceneSampler         = VK_NULL_HANDLE;
-
-        // FXAA fullscreen pipeline
-        VkPipeline           pipeline          = VK_NULL_HANDLE;
-        VkPipelineLayout     pipelineLayout    = VK_NULL_HANDLE;
-        VkDescriptorSetLayout descSetLayout    = VK_NULL_HANDLE;
-        VkDescriptorPool     descPool          = VK_NULL_HANDLE;
-        // Per-frame descriptor sets to avoid race with in-flight command buffers
-        static constexpr uint32_t DESC_SET_COUNT = 2; // matches MAX_FRAMES_IN_FLIGHT
-        VkDescriptorSet      descSet[DESC_SET_COUNT] = {};
-    };
-    FXAAState fxaa_;
-    bool initFXAAResources();
-    void destroyFXAAResources();
-    void renderFXAAPass();
-
-    // FSR 2.2 temporal upscaling state
-    struct FSR2State {
-        bool enabled = false;
-        bool needsRecreate = false;
-        float scaleFactor = 0.77f;
-        float sharpness = 3.0f;  // Very strong RCAS to counteract upscale softness
-        uint32_t internalWidth = 0;
-        uint32_t internalHeight = 0;
-
-        // Off-screen scene targets (internal resolution, no MSAA — FSR2 replaces AA)
-        AllocatedImage sceneColor{};
-        AllocatedImage sceneDepth{};
-        VkFramebuffer sceneFramebuffer = VK_NULL_HANDLE;
-
-        // Samplers
-        VkSampler linearSampler = VK_NULL_HANDLE;   // For color
-        VkSampler nearestSampler = VK_NULL_HANDLE;  // For depth / motion vectors
-
-        // Motion vector buffer (internal resolution)
-        AllocatedImage motionVectors{};
-
-        // History buffers (display resolution, ping-pong)
-        AllocatedImage history[2]{};
-        AllocatedImage framegenOutput{};
-        bool framegenOutputValid = false;
-        uint32_t currentHistory = 0;  // Output index (0 or 1)
-
-        // Compute pipelines
-        VkPipeline motionVecPipeline = VK_NULL_HANDLE;
-        VkPipelineLayout motionVecPipelineLayout = VK_NULL_HANDLE;
-        VkDescriptorSetLayout motionVecDescSetLayout = VK_NULL_HANDLE;
-        VkDescriptorPool motionVecDescPool = VK_NULL_HANDLE;
-        VkDescriptorSet motionVecDescSet = VK_NULL_HANDLE;
-
-        VkPipeline accumulatePipeline = VK_NULL_HANDLE;
-        VkPipelineLayout accumulatePipelineLayout = VK_NULL_HANDLE;
-        VkDescriptorSetLayout accumulateDescSetLayout = VK_NULL_HANDLE;
-        VkDescriptorPool accumulateDescPool = VK_NULL_HANDLE;
-        VkDescriptorSet accumulateDescSets[2] = {};  // Per ping-pong
-
-        // RCAS sharpening pass (display resolution)
-        VkPipeline sharpenPipeline = VK_NULL_HANDLE;
-        VkPipelineLayout sharpenPipelineLayout = VK_NULL_HANDLE;
-        VkDescriptorSetLayout sharpenDescSetLayout = VK_NULL_HANDLE;
-        VkDescriptorPool sharpenDescPool = VK_NULL_HANDLE;
-        VkDescriptorSet sharpenDescSets[2] = {};
-
-        // Previous frame state for motion vector reprojection
-        glm::mat4 prevViewProjection = glm::mat4(1.0f);
-        glm::vec2 prevJitter = glm::vec2(0.0f);
-        uint32_t frameIndex = 0;
-        bool needsHistoryReset = true;
-        bool useAmdBackend = false;
-        bool amdFsr3FramegenEnabled = false;
-        bool amdFsr3FramegenRuntimeActive = false;
-        bool amdFsr3FramegenRuntimeReady = false;
-        std::string amdFsr3RuntimePath = "Path C";
-        std::string amdFsr3RuntimeLastError{};
-        size_t amdFsr3UpscaleDispatchCount = 0;
-        size_t amdFsr3FramegenDispatchCount = 0;
-        size_t amdFsr3FallbackCount = 0;
-        uint64_t amdFsr3InteropSyncValue = 1;
-        float jitterSign = 0.38f;
-        float motionVecScaleX = 1.0f;
-        float motionVecScaleY = 1.0f;
-#if WOWEE_HAS_AMD_FSR2
-        FfxFsr2Context amdContext{};
-        FfxFsr2Interface amdInterface{};
-        void* amdScratchBuffer = nullptr;
-        size_t amdScratchBufferSize = 0;
-#endif
-        std::unique_ptr<AmdFsr3Runtime> amdFsr3Runtime;
-
-        // Convergent accumulation: jitter for N frames then freeze
-        int convergenceFrame = 0;
-        static constexpr int convergenceMaxFrames = 8;
-        glm::mat4 lastStableVP = glm::mat4(1.0f);
-    };
-    FSR2State fsr2_;
-    bool initFSR2Resources();
-    void destroyFSR2Resources();
-    void dispatchMotionVectors();
-    void dispatchTemporalAccumulate();
-    void dispatchAmdFsr2();
-    void dispatchAmdFsr3Framegen();
-    void renderFSR2Sharpen();
-    static float halton(uint32_t index, uint32_t base);
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/quest_marker_renderer.hpp b/include/rendering/quest_marker_renderer.hpp
index a0d18776..2d6a73d3 100644
--- a/include/rendering/quest_marker_renderer.hpp
+++ b/include/rendering/quest_marker_renderer.hpp
@@ -35,10 +35,8 @@ public:
      * @param position World position (NPC base position)
      * @param markerType 0=available(!), 1=turnin(?), 2=incomplete(?)
      * @param boundingHeight NPC bounding height (optional, default 2.0f)
-     * @param grayscale 0 = full colour, 1 = desaturated grey (trivial/low-level quests)
      */
-    void setMarker(uint64_t guid, const glm::vec3& position, int markerType,
-                   float boundingHeight = 2.0f, float grayscale = 0.0f);
+    void setMarker(uint64_t guid, const glm::vec3& position, int markerType, float boundingHeight = 2.0f);
 
     /**
      * Remove a quest marker
@@ -63,7 +61,6 @@ private:
         glm::vec3 position;
         int type; // 0=available, 1=turnin, 2=incomplete
         float boundingHeight = 2.0f;
-        float grayscale = 0.0f; // 0 = colour, 1 = desaturated (trivial quests)
     };
 
     std::unordered_map<uint64_t, Marker> markers_;
diff --git a/include/rendering/render_graph.hpp b/include/rendering/render_graph.hpp
deleted file mode 100644
index 6b17f5b1..00000000
--- a/include/rendering/render_graph.hpp
+++ /dev/null
@@ -1,117 +0,0 @@
-#pragma once
-
-#include <vulkan/vulkan.h>
-#include <string>
-#include <vector>
-#include <functional>
-#include <cstdint>
-
-namespace wowee {
-namespace rendering {
-
-// Lightweight Render Graph / Frame Graph
-// Converts hardcoded pass sequence (shadow → reflection → compute cull →
-// main → post-process → ImGui → present) into declarative graph nodes.
-// Graph auto-inserts VkImageMemoryBarrier between passes.
-
-// Resource handle — identifies a virtual resource (image or buffer) within the graph.
-struct RGResource {
-    uint32_t id = UINT32_MAX;
-    bool valid() const { return id != UINT32_MAX; }
-};
-
-// Image barrier descriptor for automatic synchronization between passes.
-struct RGImageBarrier {
-    VkImage image;
-    VkImageLayout oldLayout;
-    VkImageLayout newLayout;
-    VkAccessFlags srcAccess;
-    VkAccessFlags dstAccess;
-    VkPipelineStageFlags srcStage;
-    VkPipelineStageFlags dstStage;
-    VkImageAspectFlags aspectMask;
-};
-
-// Buffer barrier descriptor for automatic synchronization between passes.
-struct RGBufferBarrier {
-    VkBuffer buffer;
-    VkDeviceSize offset;
-    VkDeviceSize size;
-    VkAccessFlags srcAccess;
-    VkAccessFlags dstAccess;
-    VkPipelineStageFlags srcStage;
-    VkPipelineStageFlags dstStage;
-};
-
-// Render pass node — wraps an execution callback with declared inputs/outputs.
-struct RGPass {
-    std::string name;
-    std::vector<RGResource> inputs;
-    std::vector<RGResource> outputs;
-    std::function<void(VkCommandBuffer cmd)> execute;
-    bool enabled = true; // Can be dynamically disabled per-frame
-
-    // Barriers to insert before this pass executes
-    std::vector<RGImageBarrier> imageBarriers;
-    std::vector<RGBufferBarrier> bufferBarriers;
-};
-
-class RenderGraph {
-public:
-    RenderGraph() = default;
-    ~RenderGraph() = default;
-
-    // Reset graph for a new frame (clears passes, keeps resource registry).
-    void reset();
-
-    // Register a virtual resource (returns handle for input/output declarations).
-    RGResource registerResource(const std::string& name);
-
-    // Look up a previously registered resource by name.
-    RGResource findResource(const std::string& name) const;
-
-    // Add a render pass node.
-    // inputs: resources this pass reads from
-    // outputs: resources this pass writes to
-    // execute: callback invoked with the frame's command buffer
-    void addPass(const std::string& name,
-                 const std::vector<RGResource>& inputs,
-                 const std::vector<RGResource>& outputs,
-                 std::function<void(VkCommandBuffer cmd)> execute);
-
-    // Enable/disable a pass by name (for dynamic toggling, e.g. shadows off).
-    void setPassEnabled(const std::string& name, bool enabled);
-
-    // Compile: topological sort by dependency order, insert barriers.
-    // Must be called after all addPass() calls and before execute().
-    void compile();
-
-    // Execute all enabled passes in compiled order on the given command buffer.
-    void execute(VkCommandBuffer cmd);
-
-    // Query: get the compiled execution order (pass names, for debug HUD).
-    const std::vector<uint32_t>& getExecutionOrder() const { return executionOrder_; }
-    const std::vector<RGPass>& getPasses() const { return passes_; }
-
-private:
-    // Topological sort helper (Kahn's algorithm).
-    void topologicalSort();
-
-    // Resource registry: name → id
-    struct ResourceEntry {
-        std::string name;
-        uint32_t id;
-    };
-    std::vector<ResourceEntry> resources_;
-    uint32_t nextResourceId_ = 0;
-
-    // Pass storage
-    std::vector<RGPass> passes_;
-
-    // Compiled execution order (indices into passes_)
-    std::vector<uint32_t> executionOrder_;
-    bool compiled_ = false;
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/renderer.hpp b/include/rendering/renderer.hpp
index a8c3520d..90432595 100644
--- a/include/rendering/renderer.hpp
+++ b/include/rendering/renderer.hpp
@@ -6,26 +6,29 @@
 #include <vector>
 #include <future>
 #include <cstddef>
-#include <unordered_map>
-#include <unordered_set>
 #include <glm/glm.hpp>
 #include <vulkan/vulkan.h>
 #include <vk_mem_alloc.h>
 #include "rendering/vk_frame_data.hpp"
 #include "rendering/vk_utils.hpp"
 #include "rendering/sky_system.hpp"
+#if WOWEE_HAS_AMD_FSR2
+#include "ffx_fsr2.h"
+#include "ffx_fsr2_vk.h"
+#endif
 
 namespace wowee {
 namespace core { class Window; }
 namespace rendering { class VkContext; }
 namespace game { class World; class ZoneManager; class GameHandler; }
-namespace audio { class AudioCoordinator; }
+namespace audio { class MusicManager; class FootstepManager; class ActivitySoundManager; class MountSoundManager; class NpcVoiceManager; class AmbientSoundManager; class UiSoundManager; class CombatSoundManager; class SpellSoundManager; class MovementSoundManager; enum class FootstepSurface : uint8_t; enum class VoiceType; }
 namespace pipeline { class AssetManager; }
 
 namespace rendering {
 
 class Camera;
 class CameraController;
+class Scene;
 class TerrainRenderer;
 class TerrainManager;
 class PerformanceHUD;
@@ -36,7 +39,6 @@ class StarField;
 class Clouds;
 class LensFlare;
 class Weather;
-class Lightning;
 class LightingManager;
 class SwimEffects;
 class MountDust;
@@ -49,15 +51,8 @@ class Minimap;
 class WorldMap;
 class QuestMarkerRenderer;
 class CharacterPreview;
+class Shader;
 class AmdFsr3Runtime;
-class SpellVisualSystem;
-class PostProcessPipeline;
-class AnimationController;
-enum class RangedWeaponType : uint8_t;
-class LevelUpEffect;
-class ChargeEffect;
-class SwimEffects;
-class RenderGraph;
 
 class Renderer {
 public:
@@ -121,6 +116,7 @@ public:
 
     Camera* getCamera() { return camera.get(); }
     CameraController* getCameraController() { return cameraController.get(); }
+    Scene* getScene() { return scene.get(); }
     TerrainRenderer* getTerrainRenderer() const { return terrainRenderer.get(); }
     TerrainManager* getTerrainManager() const { return terrainManager.get(); }
     PerformanceHUD* getPerformanceHUD() { return performanceHUD.get(); }
@@ -131,7 +127,6 @@ public:
     Clouds* getClouds() const { return skySystem ? skySystem->getClouds() : nullptr; }
     LensFlare* getLensFlare() const { return skySystem ? skySystem->getLensFlare() : nullptr; }
     Weather* getWeather() const { return weather.get(); }
-    Lightning* getLightning() const { return lightning.get(); }
     CharacterRenderer* getCharacterRenderer() const { return characterRenderer.get(); }
     WMORenderer* getWMORenderer() const { return wmoRenderer.get(); }
     M2Renderer* getM2Renderer() const { return m2Renderer.get(); }
@@ -140,7 +135,6 @@ public:
     QuestMarkerRenderer* getQuestMarkerRenderer() const { return questMarkerRenderer.get(); }
     SkySystem* getSkySystem() const { return skySystem.get(); }
     const std::string& getCurrentZoneName() const { return currentZoneName; }
-    bool isPlayerIndoors() const { return playerIndoors_; }
     VkContext* getVkContext() const { return vkCtx; }
     VkDescriptorSetLayout getPerFrameSetLayout() const { return perFrameSetLayout; }
     VkRenderPass getShadowRenderPass() const { return shadowRenderPass; }
@@ -152,56 +146,34 @@ public:
     float getCharacterYaw() const { return characterYaw; }
     void setCharacterYaw(float yawDeg) { characterYaw = yawDeg; }
 
-    // Emote support — delegates to AnimationController (§4.2)
+    // Emote support
     void playEmote(const std::string& emoteName);
     void triggerLevelUpEffect(const glm::vec3& position);
     void cancelEmote();
-
-    // Screenshot capture — copies swapchain image to PNG file
-    bool captureScreenshot(const std::string& outputPath);
-
-    // Spell visual effects (SMSG_PLAY_SPELL_VISUAL / SMSG_PLAY_SPELL_IMPACT)
-    // Delegates to SpellVisualSystem (owned by Renderer)
-    void playSpellVisual(uint32_t visualId, const glm::vec3& worldPosition,
-                         bool useImpactKit = false);
-    SpellVisualSystem* getSpellVisualSystem() const { return spellVisualSystem_.get(); }
-    bool isEmoteActive() const;
+    bool isEmoteActive() const { return emoteActive; }
     static std::string getEmoteText(const std::string& emoteName, const std::string* targetName = nullptr);
     static uint32_t getEmoteDbcId(const std::string& emoteName);
     static std::string getEmoteTextByDbcId(uint32_t dbcId, const std::string& senderName, const std::string* targetName = nullptr);
     static uint32_t getEmoteAnimByDbcId(uint32_t dbcId);
 
-    // Targeting support — delegates to AnimationController (§4.2)
+    // Targeting support
     void setTargetPosition(const glm::vec3* pos);
-    void setInCombat(bool combat);
-    void resetCombatVisualState();
+    void setInCombat(bool combat) { inCombat_ = combat; }
     bool isMoving() const;
     void triggerMeleeSwing();
-    void setEquippedWeaponType(uint32_t inventoryType, bool is2HLoose = false,
-                               bool isFist = false, bool isDagger = false,
-                               bool hasOffHand = false, bool hasShield = false);
-    void triggerSpecialAttack(uint32_t spellId);
-    void setEquippedRangedType(RangedWeaponType type);
-    void triggerRangedShot();
-    RangedWeaponType getEquippedRangedType() const;
-    void setCharging(bool charging);
-    bool isCharging() const;
+    void setEquippedWeaponType(uint32_t inventoryType) { equippedWeaponInvType_ = inventoryType; meleeAnimId = 0; }
+    void setCharging(bool charging) { charging_ = charging; }
+    bool isCharging() const { return charging_; }
     void startChargeEffect(const glm::vec3& position, const glm::vec3& direction);
     void emitChargeEffect(const glm::vec3& position, const glm::vec3& direction);
     void stopChargeEffect();
 
-    // Mount rendering — delegates to AnimationController (§4.2)
+    // Mount rendering
     void setMounted(uint32_t mountInstId, uint32_t mountDisplayId, float heightOffset, const std::string& modelPath = "");
-    void setTaxiFlight(bool onTaxi);
-    void setMountPitchRoll(float pitch, float roll);
+    void setTaxiFlight(bool onTaxi) { taxiFlight_ = onTaxi; }
+    void setMountPitchRoll(float pitch, float roll) { mountPitch_ = pitch; mountRoll_ = roll; }
     void clearMount();
-    bool isMounted() const;
-
-    // AnimationController access (§4.2)
-    AnimationController* getAnimationController() const { return animationController_.get(); }
-    LevelUpEffect* getLevelUpEffect() const { return levelUpEffect.get(); }
-    ChargeEffect* getChargeEffect() const { return chargeEffect.get(); }
-    SwimEffects* getSwimEffects() const { return swimEffects.get(); }
+    bool isMounted() const { return mountInstanceId_ != 0; }
 
     // Selection circle for targeted entity
     void setSelectionCircle(const glm::vec3& pos, float radius, const glm::vec3& color);
@@ -214,10 +186,17 @@ public:
     double getLastTerrainRenderMs() const { return lastTerrainRenderMs; }
     double getLastWMORenderMs() const { return lastWMORenderMs; }
     double getLastM2RenderMs() const { return lastM2RenderMs; }
-    // Audio coordinator — owned by Application, set via setAudioCoordinator().
-    void setAudioCoordinator(audio::AudioCoordinator* ac) { audioCoordinator_ = ac; }
-    audio::AudioCoordinator* getAudioCoordinator() { return audioCoordinator_; }
+    audio::MusicManager* getMusicManager() { return musicManager.get(); }
     game::ZoneManager* getZoneManager() { return zoneManager.get(); }
+    audio::FootstepManager* getFootstepManager() { return footstepManager.get(); }
+    audio::ActivitySoundManager* getActivitySoundManager() { return activitySoundManager.get(); }
+    audio::MountSoundManager* getMountSoundManager() { return mountSoundManager.get(); }
+    audio::NpcVoiceManager* getNpcVoiceManager() { return npcVoiceManager.get(); }
+    audio::AmbientSoundManager* getAmbientSoundManager() { return ambientSoundManager.get(); }
+    audio::UiSoundManager* getUiSoundManager() { return uiSoundManager.get(); }
+    audio::CombatSoundManager* getCombatSoundManager() { return combatSoundManager.get(); }
+    audio::SpellSoundManager* getSpellSoundManager() { return spellSoundManager.get(); }
+    audio::MovementSoundManager* getMovementSoundManager() { return movementSoundManager.get(); }
     LightingManager* getLightingManager() { return lightingManager.get(); }
 
 private:
@@ -226,6 +205,7 @@ private:
     core::Window* window = nullptr;
     std::unique_ptr<Camera> camera;
     std::unique_ptr<CameraController> cameraController;
+    std::unique_ptr<Scene> scene;
     std::unique_ptr<TerrainRenderer> terrainRenderer;
     std::unique_ptr<TerrainManager> terrainManager;
     std::unique_ptr<PerformanceHUD> performanceHUD;
@@ -236,7 +216,6 @@ private:
     std::unique_ptr<Clouds> clouds;
     std::unique_ptr<LensFlare> lensFlare;
     std::unique_ptr<Weather> weather;
-    std::unique_ptr<Lightning> lightning;
     std::unique_ptr<LightingManager> lightingManager;
     std::unique_ptr<SkySystem> skySystem;  // Coordinator for sky rendering
     std::unique_ptr<SwimEffects> swimEffects;
@@ -249,22 +228,26 @@ private:
     std::unique_ptr<Minimap> minimap;
     std::unique_ptr<WorldMap> worldMap;
     std::unique_ptr<QuestMarkerRenderer> questMarkerRenderer;
-    audio::AudioCoordinator* audioCoordinator_ = nullptr;  // Owned by Application
-    std::unique_ptr<AnimationController> animationController_;  // §4.2
+    std::unique_ptr<audio::MusicManager> musicManager;
+    std::unique_ptr<audio::FootstepManager> footstepManager;
+    std::unique_ptr<audio::ActivitySoundManager> activitySoundManager;
+    std::unique_ptr<audio::MountSoundManager> mountSoundManager;
+    std::unique_ptr<audio::NpcVoiceManager> npcVoiceManager;
+    std::unique_ptr<audio::AmbientSoundManager> ambientSoundManager;
+    std::unique_ptr<audio::UiSoundManager> uiSoundManager;
+    std::unique_ptr<audio::CombatSoundManager> combatSoundManager;
+    std::unique_ptr<audio::SpellSoundManager> spellSoundManager;
+    std::unique_ptr<audio::MovementSoundManager> movementSoundManager;
     std::unique_ptr<game::ZoneManager> zoneManager;
     // Shadow mapping (Vulkan)
     static constexpr uint32_t SHADOW_MAP_SIZE = 4096;
-    // Per-frame shadow resources: each in-flight frame has its own depth image and
-    // framebuffer so that frame N's shadow read and frame N+1's shadow write don't
-    // race on the same image across concurrent GPU submissions.
-    // Array size must match MAX_FRAMES (= 2, defined in the private section below).
-    VkImage shadowDepthImage[2] = {};
-    VmaAllocation shadowDepthAlloc[2] = {};
-    VkImageView shadowDepthView[2] = {};
+    VkImage shadowDepthImage = VK_NULL_HANDLE;
+    VmaAllocation shadowDepthAlloc = VK_NULL_HANDLE;
+    VkImageView shadowDepthView = VK_NULL_HANDLE;
     VkSampler shadowSampler = VK_NULL_HANDLE;
     VkRenderPass shadowRenderPass = VK_NULL_HANDLE;
-    VkFramebuffer shadowFramebuffer[2] = {};
-    VkImageLayout shadowDepthLayout_[2] = {};
+    VkFramebuffer shadowFramebuffer = VK_NULL_HANDLE;
+    VkImageLayout shadowDepthLayout_ = VK_IMAGE_LAYOUT_UNDEFINED;
     glm::mat4 lightSpaceMatrix = glm::mat4(1.0f);
     glm::vec3 shadowCenter = glm::vec3(0.0f);
     bool shadowCenterInitialized = false;
@@ -284,35 +267,38 @@ public:
     float getShadowDistance() const { return shadowDistance_; }
     void setMsaaSamples(VkSampleCountFlagBits samples);
 
-    // Post-process pipeline API — delegates to PostProcessPipeline (§4.3)
-    PostProcessPipeline* getPostProcessPipeline() const;
-    void setFXAAEnabled(bool enabled);
-    bool isFXAAEnabled() const;
+    // FSR (FidelityFX Super Resolution) upscaling
     void setFSREnabled(bool enabled);
-    bool isFSREnabled() const;
-    void setFSRQuality(float scaleFactor);
-    void setFSRSharpness(float sharpness);
-    float getFSRScaleFactor() const;
-    float getFSRSharpness() const;
+    bool isFSREnabled() const { return fsr_.enabled; }
+    void setFSRQuality(float scaleFactor);  // 0.59=Balanced, 0.67=Quality, 0.77=UltraQuality, 1.00=Native
+    void setFSRSharpness(float sharpness);  // 0.0 - 2.0
+    float getFSRScaleFactor() const { return fsr_.scaleFactor; }
+    float getFSRSharpness() const { return fsr_.sharpness; }
     void setFSR2Enabled(bool enabled);
-    bool isFSR2Enabled() const;
+    bool isFSR2Enabled() const { return fsr2_.enabled; }
     void setFSR2DebugTuning(float jitterSign, float motionVecScaleX, float motionVecScaleY);
     void setAmdFsr3FramegenEnabled(bool enabled);
-    bool isAmdFsr3FramegenEnabled() const;
-    float getFSR2JitterSign() const;
-    float getFSR2MotionVecScaleX() const;
-    float getFSR2MotionVecScaleY() const;
-    bool isAmdFsr2SdkAvailable() const;
-    bool isAmdFsr3FramegenSdkAvailable() const;
-    bool isAmdFsr3FramegenRuntimeActive() const;
-    bool isAmdFsr3FramegenRuntimeReady() const;
+    bool isAmdFsr3FramegenEnabled() const { return fsr2_.amdFsr3FramegenEnabled; }
+    float getFSR2JitterSign() const { return fsr2_.jitterSign; }
+    float getFSR2MotionVecScaleX() const { return fsr2_.motionVecScaleX; }
+    float getFSR2MotionVecScaleY() const { return fsr2_.motionVecScaleY; }
+#if WOWEE_HAS_AMD_FSR2
+    bool isAmdFsr2SdkAvailable() const { return true; }
+#else
+    bool isAmdFsr2SdkAvailable() const { return false; }
+#endif
+#if WOWEE_HAS_AMD_FSR3_FRAMEGEN
+    bool isAmdFsr3FramegenSdkAvailable() const { return true; }
+#else
+    bool isAmdFsr3FramegenSdkAvailable() const { return false; }
+#endif
+    bool isAmdFsr3FramegenRuntimeActive() const { return fsr2_.amdFsr3FramegenRuntimeActive; }
+    bool isAmdFsr3FramegenRuntimeReady() const { return fsr2_.amdFsr3FramegenRuntimeReady; }
     const char* getAmdFsr3FramegenRuntimePath() const;
-    const std::string& getAmdFsr3FramegenRuntimeError() const;
-    size_t getAmdFsr3UpscaleDispatchCount() const;
-    size_t getAmdFsr3FramegenDispatchCount() const;
-    size_t getAmdFsr3FallbackCount() const;
-    void setBrightness(float b);
-    float getBrightness() const;
+    const std::string& getAmdFsr3FramegenRuntimeError() const { return fsr2_.amdFsr3RuntimeLastError; }
+    size_t getAmdFsr3UpscaleDispatchCount() const { return fsr2_.amdFsr3UpscaleDispatchCount; }
+    size_t getAmdFsr3FramegenDispatchCount() const { return fsr2_.amdFsr3FramegenDispatchCount; }
+    size_t getAmdFsr3FallbackCount() const { return fsr2_.amdFsr3FallbackCount; }
 
     void setWaterRefractionEnabled(bool enabled);
     bool isWaterRefractionEnabled() const;
@@ -325,18 +311,10 @@ private:
     glm::mat4 computeLightSpaceMatrix();
 
     pipeline::AssetManager* cachedAssetManager = nullptr;
-
-    // Spell visual effects — owned SpellVisualSystem (extracted from Renderer §4.4)
-    std::unique_ptr<SpellVisualSystem> spellVisualSystem_;
-
-    // Post-process pipeline — owns all FSR/FXAA/FSR2 state (extracted §4.3)
-    std::unique_ptr<PostProcessPipeline> postProcessPipeline_;
-
     uint32_t currentZoneId = 0;
     std::string currentZoneName;
     bool inTavern_ = false;
     bool inBlacksmith_ = false;
-    bool playerIndoors_ = false;  // Cached WMO inside state for macro conditionals
     float musicSwitchCooldown_ = 0.0f;
     bool deferredWorldInitEnabled_ = true;
     bool deferredWorldInitPending_ = false;
@@ -348,7 +326,23 @@ private:
     uint32_t characterInstanceId = 0;
     float characterYaw = 0.0f;
 
+    // Character animation state
+    enum class CharAnimState { IDLE, WALK, RUN, JUMP_START, JUMP_MID, JUMP_END, SIT_DOWN, SITTING, EMOTE, SWIM_IDLE, SWIM, MELEE_SWING, MOUNT, CHARGE, COMBAT_IDLE };
+    CharAnimState charAnimState = CharAnimState::IDLE;
+    void updateCharacterAnimation();
+    bool isFootstepAnimationState() const;
+    bool shouldTriggerFootstepEvent(uint32_t animationId, float animationTimeMs, float animationDurationMs);
+    audio::FootstepSurface resolveFootstepSurface() const;
+    uint32_t resolveMeleeAnimId();
 
+    // Emote state
+    bool emoteActive = false;
+    uint32_t emoteAnimId = 0;
+    bool emoteLoop = false;
+
+    // Target facing
+    const glm::vec3* targetPosition = nullptr;
+    bool inCombat_ = false;
 
     // Selection circle rendering (Vulkan)
     VkPipeline selCirclePipeline = VK_NULL_HANDLE;
@@ -371,7 +365,181 @@ private:
     void initOverlayPipeline();
     void renderOverlay(const glm::vec4& color, VkCommandBuffer overrideCmd = VK_NULL_HANDLE);
 
+    // FSR 1.0 upscaling state
+    struct FSRState {
+        bool enabled = false;
+        bool needsRecreate = false;
+        float scaleFactor = 1.00f;  // Native default
+        float sharpness = 1.6f;
+        uint32_t internalWidth = 0;
+        uint32_t internalHeight = 0;
 
+        // Off-screen scene target (reduced resolution)
+        AllocatedImage sceneColor{};        // 1x color (non-MSAA render target / MSAA resolve target)
+        AllocatedImage sceneDepth{};        // Depth (matches current MSAA sample count)
+        AllocatedImage sceneMsaaColor{};    // MSAA color target (only when MSAA > 1x)
+        AllocatedImage sceneDepthResolve{}; // Depth resolve (only when MSAA + depth resolve)
+        VkFramebuffer sceneFramebuffer = VK_NULL_HANDLE;
+        VkSampler sceneSampler = VK_NULL_HANDLE;
+
+        // Upscale pipeline
+        VkPipeline pipeline = VK_NULL_HANDLE;
+        VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
+        VkDescriptorSetLayout descSetLayout = VK_NULL_HANDLE;
+        VkDescriptorPool descPool = VK_NULL_HANDLE;
+        VkDescriptorSet descSet = VK_NULL_HANDLE;
+    };
+    FSRState fsr_;
+    bool initFSRResources();
+    void destroyFSRResources();
+    void renderFSRUpscale();
+
+    // FSR 2.2 temporal upscaling state
+    struct FSR2State {
+        bool enabled = false;
+        bool needsRecreate = false;
+        float scaleFactor = 0.77f;
+        float sharpness = 3.0f;  // Very strong RCAS to counteract upscale softness
+        uint32_t internalWidth = 0;
+        uint32_t internalHeight = 0;
+
+        // Off-screen scene targets (internal resolution, no MSAA — FSR2 replaces AA)
+        AllocatedImage sceneColor{};
+        AllocatedImage sceneDepth{};
+        VkFramebuffer sceneFramebuffer = VK_NULL_HANDLE;
+
+        // Samplers
+        VkSampler linearSampler = VK_NULL_HANDLE;   // For color
+        VkSampler nearestSampler = VK_NULL_HANDLE;  // For depth / motion vectors
+
+        // Motion vector buffer (internal resolution)
+        AllocatedImage motionVectors{};
+
+        // History buffers (display resolution, ping-pong)
+        AllocatedImage history[2]{};
+        AllocatedImage framegenOutput{};
+        bool framegenOutputValid = false;
+        uint32_t currentHistory = 0;  // Output index (0 or 1)
+
+        // Compute pipelines
+        VkPipeline motionVecPipeline = VK_NULL_HANDLE;
+        VkPipelineLayout motionVecPipelineLayout = VK_NULL_HANDLE;
+        VkDescriptorSetLayout motionVecDescSetLayout = VK_NULL_HANDLE;
+        VkDescriptorPool motionVecDescPool = VK_NULL_HANDLE;
+        VkDescriptorSet motionVecDescSet = VK_NULL_HANDLE;
+
+        VkPipeline accumulatePipeline = VK_NULL_HANDLE;
+        VkPipelineLayout accumulatePipelineLayout = VK_NULL_HANDLE;
+        VkDescriptorSetLayout accumulateDescSetLayout = VK_NULL_HANDLE;
+        VkDescriptorPool accumulateDescPool = VK_NULL_HANDLE;
+        VkDescriptorSet accumulateDescSets[2] = {};  // Per ping-pong
+
+        // RCAS sharpening pass (display resolution)
+        VkPipeline sharpenPipeline = VK_NULL_HANDLE;
+        VkPipelineLayout sharpenPipelineLayout = VK_NULL_HANDLE;
+        VkDescriptorSetLayout sharpenDescSetLayout = VK_NULL_HANDLE;
+        VkDescriptorPool sharpenDescPool = VK_NULL_HANDLE;
+        VkDescriptorSet sharpenDescSets[2] = {};
+
+        // Previous frame state for motion vector reprojection
+        glm::mat4 prevViewProjection = glm::mat4(1.0f);
+        glm::vec2 prevJitter = glm::vec2(0.0f);
+        uint32_t frameIndex = 0;
+        bool needsHistoryReset = true;
+        bool useAmdBackend = false;
+        bool amdFsr3FramegenEnabled = false;
+        bool amdFsr3FramegenRuntimeActive = false;
+        bool amdFsr3FramegenRuntimeReady = false;
+        std::string amdFsr3RuntimePath = "Path C";
+        std::string amdFsr3RuntimeLastError{};
+        size_t amdFsr3UpscaleDispatchCount = 0;
+        size_t amdFsr3FramegenDispatchCount = 0;
+        size_t amdFsr3FallbackCount = 0;
+        uint64_t amdFsr3InteropSyncValue = 1;
+        float jitterSign = 0.38f;
+        float motionVecScaleX = 1.0f;
+        float motionVecScaleY = 1.0f;
+#if WOWEE_HAS_AMD_FSR2
+        FfxFsr2Context amdContext{};
+        FfxFsr2Interface amdInterface{};
+        void* amdScratchBuffer = nullptr;
+        size_t amdScratchBufferSize = 0;
+#endif
+        std::unique_ptr<AmdFsr3Runtime> amdFsr3Runtime;
+
+        // Convergent accumulation: jitter for N frames then freeze
+        int convergenceFrame = 0;
+        static constexpr int convergenceMaxFrames = 8;
+        glm::mat4 lastStableVP = glm::mat4(1.0f);
+    };
+    FSR2State fsr2_;
+    bool initFSR2Resources();
+    void destroyFSR2Resources();
+    void dispatchMotionVectors();
+    void dispatchTemporalAccumulate();
+    void dispatchAmdFsr2();
+    void dispatchAmdFsr3Framegen();
+    void renderFSR2Sharpen();
+    static float halton(uint32_t index, uint32_t base);
+
+    // Footstep event tracking (animation-driven)
+    uint32_t footstepLastAnimationId = 0;
+    float footstepLastNormTime = 0.0f;
+    bool footstepNormInitialized = false;
+
+    // Footstep surface cache (avoid expensive queries every step)
+    mutable audio::FootstepSurface cachedFootstepSurface{};
+    mutable glm::vec3 cachedFootstepPosition{0.0f, 0.0f, 0.0f};
+    mutable float cachedFootstepUpdateTimer{999.0f};  // Force initial query
+
+    // Mount footstep tracking (separate from player's)
+    uint32_t mountFootstepLastAnimId = 0;
+    float mountFootstepLastNormTime = 0.0f;
+    bool mountFootstepNormInitialized = false;
+    bool sfxStateInitialized = false;
+    bool sfxPrevGrounded = true;
+    bool sfxPrevJumping = false;
+    bool sfxPrevFalling = false;
+    bool sfxPrevSwimming = false;
+
+    bool charging_ = false;
+    float meleeSwingTimer = 0.0f;
+    float meleeSwingCooldown = 0.0f;
+    float meleeAnimDurationMs = 0.0f;
+    uint32_t meleeAnimId = 0;
+    uint32_t equippedWeaponInvType_ = 0;
+
+    // Mount state
+    // Mount animation capabilities (discovered at mount time, varies per model)
+    struct MountAnimSet {
+        uint32_t jumpStart = 0;  // Jump start animation
+        uint32_t jumpLoop = 0;   // Jump airborne loop
+        uint32_t jumpEnd = 0;    // Jump landing
+        uint32_t rearUp = 0;     // Rear-up / special flourish
+        uint32_t run = 0;        // Run animation (discovered, don't assume)
+        uint32_t stand = 0;      // Stand animation (discovered)
+        std::vector<uint32_t> fidgets;  // Idle fidget animations (head turn, tail swish, etc.)
+    };
+
+    enum class MountAction { None, Jump, RearUp };
+
+    uint32_t mountInstanceId_ = 0;
+    float mountHeightOffset_ = 0.0f;
+    float mountPitch_ = 0.0f;  // Up/down tilt (radians)
+    float mountRoll_ = 0.0f;   // Left/right banking (radians)
+    int mountSeatAttachmentId_ = -1;  // -1 unknown, -2 unavailable
+    glm::vec3 smoothedMountSeatPos_ = glm::vec3(0.0f);
+    bool mountSeatSmoothingInit_ = false;
+    float prevMountYaw_ = 0.0f; // Previous yaw for turn rate calculation (procedural lean)
+    float lastDeltaTime_ = 0.0f; // Cached for use in updateCharacterAnimation()
+    MountAction mountAction_ = MountAction::None;  // Current mount action (jump/rear-up)
+    uint32_t mountActionPhase_ = 0;  // 0=start, 1=loop, 2=end (for jump chaining)
+    MountAnimSet mountAnims_;  // Cached animation IDs for current mount
+    float mountIdleFidgetTimer_ = 0.0f;  // Timer for random idle fidgets
+    float mountIdleSoundTimer_ = 0.0f;   // Timer for ambient idle sounds
+    uint32_t mountActiveFidget_ = 0;     // Currently playing fidget animation ID (0 = none)
+    bool taxiFlight_ = false;
+    bool taxiAnimsLogged_ = false;
 
     // Vulkan frame state
     VkContext* vkCtx = nullptr;
@@ -393,7 +561,7 @@ private:
     VkBuffer reflPerFrameUBO = VK_NULL_HANDLE;
     VmaAllocation reflPerFrameUBOAlloc = VK_NULL_HANDLE;
     void* reflPerFrameUBOMapped = nullptr;
-    VkDescriptorSet reflPerFrameDescSet[MAX_FRAMES] = {};
+    VkDescriptorSet reflPerFrameDescSet = VK_NULL_HANDLE;
 
     bool createPerFrameResources();
     void destroyPerFrameResources();
@@ -421,8 +589,6 @@ private:
     VkCommandBuffer secondaryCmds_[NUM_SECONDARIES][MAX_FRAMES] = {};
 
     bool parallelRecordingEnabled_ = false;  // set true after pools/buffers created
-    bool endFrameInlineMode_ = false;       // true when endFrame switched to INLINE render pass
-    float lastDeltaTime_ = 0.0f;           // cached for post-process pipeline
     bool createSecondaryCommandResources();
     void destroySecondaryCommandResources();
     VkCommandBuffer beginSecondary(uint32_t secondaryIndex);
@@ -439,12 +605,6 @@ private:
     bool terrainEnabled = true;
     bool terrainLoaded = false;
 
-    bool ghostMode_ = false;  // set each frame from gameHandler->isPlayerGhost()
-
-    // Render Graph — declarative pass ordering with automatic barriers
-    std::unique_ptr<RenderGraph> renderGraph_;
-    void buildFrameGraph(game::GameHandler* gameHandler);
-
     // CPU timing stats (last frame/update).
     double lastUpdateMs = 0.0;
     double lastRenderMs = 0.0;
diff --git a/include/rendering/scene.hpp b/include/rendering/scene.hpp
new file mode 100644
index 00000000..9f640b06
--- /dev/null
+++ b/include/rendering/scene.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <vector>
+#include <memory>
+
+namespace wowee {
+namespace rendering {
+
+class Mesh;
+
+class Scene {
+public:
+    Scene() = default;
+    ~Scene() = default;
+
+    void addMesh(std::shared_ptr<Mesh> mesh);
+    void removeMesh(const std::shared_ptr<Mesh>& mesh);
+    void clear();
+
+    const std::vector<std::shared_ptr<Mesh>>& getMeshes() const { return meshes; }
+
+private:
+    std::vector<std::shared_ptr<Mesh>> meshes;
+};
+
+} // namespace rendering
+} // namespace wowee
diff --git a/include/rendering/shader.hpp b/include/rendering/shader.hpp
new file mode 100644
index 00000000..29f0dc38
--- /dev/null
+++ b/include/rendering/shader.hpp
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <string>
+#include <unordered_map>
+#include <GL/glew.h>
+#include <glm/glm.hpp>
+
+namespace wowee {
+namespace rendering {
+
+class Shader {
+public:
+    Shader() = default;
+    ~Shader();
+
+    bool loadFromFile(const std::string& vertexPath, const std::string& fragmentPath);
+    bool loadFromSource(const std::string& vertexSource, const std::string& fragmentSource);
+
+    void use() const;
+    void unuse() const;
+
+    void setUniform(const std::string& name, int value);
+    void setUniform(const std::string& name, float value);
+    void setUniform(const std::string& name, const glm::vec2& value);
+    void setUniform(const std::string& name, const glm::vec3& value);
+    void setUniform(const std::string& name, const glm::vec4& value);
+    void setUniform(const std::string& name, const glm::mat3& value);
+    void setUniform(const std::string& name, const glm::mat4& value);
+    void setUniformMatrixArray(const std::string& name, const glm::mat4* matrices, int count);
+
+    GLuint getProgram() const { return program; }
+
+    // Adopt an externally-created program (no ownership of individual shaders)
+    void setProgram(GLuint prog) { program = prog; }
+    // Release ownership without deleting (caller retains the GL program)
+    void releaseProgram() { program = 0; vertexShader = 0; fragmentShader = 0; }
+
+private:
+    bool compile(const std::string& vertexSource, const std::string& fragmentSource);
+    GLint getUniformLocation(const std::string& name) const;
+
+    GLuint program = 0;
+    GLuint vertexShader = 0;
+    GLuint fragmentShader = 0;
+
+    // Cache uniform locations to avoid expensive glGetUniformLocation calls
+    mutable std::unordered_map<std::string, GLint> uniformLocationCache;
+};
+
+} // namespace rendering
+} // namespace wowee
diff --git a/include/rendering/spell_visual_system.hpp b/include/rendering/spell_visual_system.hpp
deleted file mode 100644
index 38d75c0d..00000000
--- a/include/rendering/spell_visual_system.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <string>
-#include <vector>
-#include <unordered_map>
-#include <unordered_set>
-#include <glm/glm.hpp>
-
-namespace wowee {
-namespace pipeline { class AssetManager; }
-namespace rendering {
-
-class M2Renderer;
-
-class SpellVisualSystem {
-public:
-    SpellVisualSystem() = default;
-    ~SpellVisualSystem() = default;
-
-    // Initialize with references to the M2 renderer (for model loading/instance spawning)
-    void initialize(M2Renderer* m2Renderer);
-    void shutdown();
-
-    // Spawn a spell visual at a world position.
-    // useImpactKit=false → CastKit path; useImpactKit=true → ImpactKit path
-    void playSpellVisual(uint32_t visualId, const glm::vec3& worldPosition,
-                         bool useImpactKit = false);
-
-    // Advance lifetime timers and remove expired instances.
-    void update(float deltaTime);
-
-    // Remove all active spell visual instances and reset caches.
-    // Called on map change / combat reset.
-    void reset();
-
-private:
-    // Spell visual effects — transient M2 instances spawned by SMSG_PLAY_SPELL_VISUAL/IMPACT
-    struct SpellVisualInstance {
-        uint32_t instanceId;
-        float elapsed;
-        float duration;  // per-instance lifetime in seconds (from M2 anim or default)
-    };
-
-    void loadSpellVisualDbc();
-
-    M2Renderer* m2Renderer_ = nullptr;
-    pipeline::AssetManager* cachedAssetManager_ = nullptr;
-
-    std::vector<SpellVisualInstance> activeSpellVisuals_;
-    std::unordered_map<uint32_t, std::string> spellVisualCastPath_;   // visualId → cast M2 path
-    std::unordered_map<uint32_t, std::string> spellVisualImpactPath_; // visualId → impact M2 path
-    std::unordered_map<std::string, uint32_t> spellVisualModelIds_;   // M2 path → M2Renderer modelId
-    std::unordered_set<uint32_t> spellVisualFailedModels_;           // modelIds that failed to load (negative cache)
-    uint32_t nextSpellVisualModelId_ = 999000; // Reserved range 999000-999799
-    bool spellVisualDbcLoaded_ = false;
-    static constexpr float SPELL_VISUAL_MAX_DURATION = 5.0f;
-    static constexpr float SPELL_VISUAL_DEFAULT_DURATION = 2.0f;
-};
-
-} // namespace rendering
-} // namespace wowee
diff --git a/include/rendering/terrain_manager.hpp b/include/rendering/terrain_manager.hpp
index 59c9c4e2..2a746d3e 100644
--- a/include/rendering/terrain_manager.hpp
+++ b/include/rendering/terrain_manager.hpp
@@ -152,12 +152,9 @@ struct FinalizingTile {
     FinalizationPhase phase = FinalizationPhase::TERRAIN;
 
     // Progress indices within current phase
-    size_t m2ModelIndex     = 0;   // Next M2 model to upload
-    size_t m2InstanceIndex  = 0;   // Next M2 placement to instantiate
-    size_t wmoModelIndex    = 0;   // Next WMO model to upload
-    size_t wmoInstanceIndex = 0;   // Next WMO placement to instantiate
-    size_t wmoDoodadIndex   = 0;   // Next WMO doodad to upload
-    size_t wmoLiquidGroupIndex = 0; // Next liquid group within current WMO instance
+    size_t m2ModelIndex = 0;       // Next M2 model to upload
+    size_t wmoModelIndex = 0;      // Next WMO model to upload
+    size_t wmoDoodadIndex = 0;     // Next WMO doodad to upload
 
     // Incremental terrain upload state (splits TERRAIN phase across frames)
     bool terrainPreloaded = false;  // True after preloaded textures uploaded
@@ -280,9 +277,6 @@ public:
     /** Process one ready tile (for loading screens with per-tile progress updates) */
     void processOneReadyTile();
 
-    /** Process a bounded batch of ready tiles with async GPU upload (no sync wait) */
-    void processReadyTiles();
-
 private:
     /**
      * Get tile coordinates from GL world position
@@ -321,6 +315,10 @@ private:
      */
     void workerLoop();
 
+    /**
+     * Main thread: poll for completed tiles and upload to GPU
+     */
+    void processReadyTiles();
     void ensureGroundEffectTablesLoaded();
     void generateGroundClutterPlacements(std::shared_ptr<PendingTile>& pending,
                                          std::unordered_set<uint32_t>& preparedModelIds);
@@ -346,8 +344,8 @@ private:
 
     // Streaming parameters
     bool streamingEnabled = true;
-    int loadRadius = 6;      // Load tiles within this radius (13x13 grid = 169 tiles)
-    int unloadRadius = 9;    // Unload tiles beyond this radius
+    int loadRadius = 4;      // Load tiles within this radius (9x9 grid = 81 tiles)
+    int unloadRadius = 7;    // Unload tiles beyond this radius
     float updateInterval = 0.033f;  // Check streaming every 33ms (~30 fps)
     float timeSinceLastUpdate = 0.0f;
     float proactiveStreamTimer_ = 0.0f;
@@ -395,11 +393,6 @@ private:
     std::unordered_set<uint32_t> uploadedM2Ids_;
     std::mutex uploadedM2IdsMutex_;
 
-    // Cross-tile dedup for WMO doodad preparation on background workers
-    // (prevents re-parsing thousands of doodads when same WMO spans multiple tiles)
-    std::unordered_set<uint32_t> preparedWmoUniqueIds_;
-    std::mutex preparedWmoUniqueIdsMutex_;
-
     // Dedup set for doodad placements across tile boundaries
     std::unordered_set<uint32_t> placedDoodadIds;
 
diff --git a/include/rendering/terrain_renderer.hpp b/include/rendering/terrain_renderer.hpp
index 56d235db..f4994792 100644
--- a/include/rendering/terrain_renderer.hpp
+++ b/include/rendering/terrain_renderer.hpp
@@ -60,11 +60,6 @@ struct TerrainChunkGPU {
     float boundingSphereRadius = 0.0f;
     glm::vec3 boundingSphereCenter = glm::vec3(0.0f);
 
-    // Offsets into mega buffers for indirect drawing (-1 = not in mega buffer)
-    int32_t megaBaseVertex = -1;
-    uint32_t megaFirstIndex = 0;
-    uint32_t vertexCount = 0;
-
     bool isValid() const { return vertexBuffer != VK_NULL_HANDLE && indexBuffer != VK_NULL_HANDLE; }
 };
 
@@ -176,7 +171,7 @@ private:
 
     // Descriptor pool for material sets
     VkDescriptorPool materialDescPool = VK_NULL_HANDLE;
-    static constexpr uint32_t MAX_MATERIAL_SETS = 65536;
+    static constexpr uint32_t MAX_MATERIAL_SETS = 16384;
 
     // Loaded terrain chunks
     std::vector<TerrainChunkGPU> chunks;
@@ -205,25 +200,6 @@ private:
     bool fogEnabled = true;
     int renderedChunks = 0;
     int culledChunks = 0;
-
-    // Mega vertex/index buffers for indirect drawing
-    // All terrain chunks share a single VB + IB, eliminating per-chunk rebinds.
-    // Indirect draw commands are built CPU-side each frame for visible chunks.
-    VkBuffer megaVB_ = VK_NULL_HANDLE;
-    VmaAllocation megaVBAlloc_ = VK_NULL_HANDLE;
-    void* megaVBMapped_ = nullptr;
-    VkBuffer megaIB_ = VK_NULL_HANDLE;
-    VmaAllocation megaIBAlloc_ = VK_NULL_HANDLE;
-    void* megaIBMapped_ = nullptr;
-    uint32_t megaVBUsed_ = 0;  // vertices used
-    uint32_t megaIBUsed_ = 0;  // indices used
-    static constexpr uint32_t MEGA_VB_MAX_VERTS   = 1536 * 1024; // ~1.5M verts × 44B ≈ 64MB
-    static constexpr uint32_t MEGA_IB_MAX_INDICES  = 6 * 1024 * 1024; // 6M indices × 4B = 24MB
-
-    VkBuffer indirectBuffer_ = VK_NULL_HANDLE;
-    VmaAllocation indirectAlloc_ = VK_NULL_HANDLE;
-    void* indirectMapped_ = nullptr;
-    static constexpr uint32_t MAX_INDIRECT_DRAWS = 8192;
 };
 
 } // namespace rendering
diff --git a/include/rendering/video_player.hpp b/include/rendering/video_player.hpp
new file mode 100644
index 00000000..3d093715
--- /dev/null
+++ b/include/rendering/video_player.hpp
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <string>
+#include <cstdint>
+#include <vector>
+
+typedef unsigned int GLuint;
+
+namespace wowee {
+namespace rendering {
+
+class VideoPlayer {
+public:
+    VideoPlayer();
+    ~VideoPlayer();
+
+    bool open(const std::string& path);
+    void update(float deltaTime);
+    void close();
+
+    bool isReady() const { return textureReady; }
+    GLuint getTextureId() const { return textureId; }
+    int getWidth() const { return width; }
+    int getHeight() const { return height; }
+
+private:
+    bool decodeNextFrame();
+    void uploadFrame();
+
+    void* formatCtx = nullptr;
+    void* codecCtx = nullptr;
+    void* frame = nullptr;
+    void* rgbFrame = nullptr;
+    void* packet = nullptr;
+    void* swsCtx = nullptr;
+
+    int videoStreamIndex = -1;
+    int width = 0;
+    int height = 0;
+    double frameTime = 1.0 / 30.0;
+    double accumulator = 0.0;
+    bool eof = false;
+
+    GLuint textureId = 0;
+    bool textureReady = false;
+    std::string sourcePath;
+    std::vector<uint8_t> rgbBuffer;
+};
+
+} // namespace rendering
+} // namespace wowee
diff --git a/include/rendering/vk_buffer.hpp b/include/rendering/vk_buffer.hpp
index f97acb99..6cb0ba54 100644
--- a/include/rendering/vk_buffer.hpp
+++ b/include/rendering/vk_buffer.hpp
@@ -24,11 +24,11 @@ public:
     VkBuffer& operator=(VkBuffer&& other) noexcept;
 
     // Create a GPU-local buffer and upload data via staging
-    [[nodiscard]] bool uploadToGPU(VkContext& ctx, const void* data, VkDeviceSize size,
+    bool uploadToGPU(VkContext& ctx, const void* data, VkDeviceSize size,
         VkBufferUsageFlags usage);
 
     // Create a host-visible buffer (for uniform/dynamic data updated each frame)
-    [[nodiscard]] bool createMapped(VmaAllocator allocator, VkDeviceSize size,
+    bool createMapped(VmaAllocator allocator, VkDeviceSize size,
         VkBufferUsageFlags usage);
 
     // Update mapped buffer contents (only valid for mapped buffers)
diff --git a/include/rendering/vk_context.hpp b/include/rendering/vk_context.hpp
index 3f487d39..154a4f98 100644
--- a/include/rendering/vk_context.hpp
+++ b/include/rendering/vk_context.hpp
@@ -8,8 +8,6 @@
 #include <vector>
 #include <functional>
 #include <cstdint>
-#include <unordered_map>
-#include <mutex>
 
 namespace wowee {
 namespace rendering {
@@ -19,6 +17,8 @@ static constexpr uint32_t MAX_FRAMES_IN_FLIGHT = 2;
 struct FrameData {
     VkCommandPool commandPool = VK_NULL_HANDLE;
     VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
+    VkSemaphore imageAvailableSemaphore = VK_NULL_HANDLE;
+    VkSemaphore renderFinishedSemaphore = VK_NULL_HANDLE;
     VkFence inFlightFence = VK_NULL_HANDLE;
 };
 
@@ -30,11 +30,11 @@ public:
     VkContext(const VkContext&) = delete;
     VkContext& operator=(const VkContext&) = delete;
 
-    [[nodiscard]] bool initialize(SDL_Window* window);
+    bool initialize(SDL_Window* window);
     void shutdown();
 
     // Swapchain management
-    [[nodiscard]] bool recreateSwapchain(int width, int height);
+    bool recreateSwapchain(int width, int height);
 
     // Frame operations
     VkCommandBuffer beginFrame(uint32_t& imageIndex);
@@ -57,33 +57,14 @@ public:
     void pollUploadBatches();    // Check completed async uploads, free staging buffers
     void waitAllUploads();       // Block until all in-flight uploads complete
 
-    // Defer resource destruction until it is safe with multiple frames in flight.
-    //
-    // This queues work to run after the fence for the *current frame slot* has
-    // signaled the next time we enter beginFrame() for that slot (i.e. after
-    // MAX_FRAMES_IN_FLIGHT submissions). Use this for resources that may still
-    // be referenced by command buffers submitted in the previous frame(s),
-    // such as descriptor sets and buffers freed during streaming/unload.
-    void deferAfterFrameFence(std::function<void()>&& fn);
-    // Like deferAfterFrameFence, but waits until ALL in-flight frame slots have
-    // been fenced — safe for shared resources bound by multiple frames' command
-    // buffers (material descriptor sets, vertex/index buffers, etc.).
-    void deferAfterAllFrameFences(std::function<void()>&& fn);
-
     // Accessors
     VkInstance getInstance() const { return instance; }
     VkPhysicalDevice getPhysicalDevice() const { return physicalDevice; }
     VkDevice getDevice() const { return device; }
-    uint32_t getGpuVendorId() const { return gpuVendorId_; }
-    const char* getGpuName() const { return gpuName_; }
-    bool isAmdGpu() const { return gpuVendorId_ == 0x1002; }
-    bool isNvidiaGpu() const { return gpuVendorId_ == 0x10DE; }
     VkQueue getGraphicsQueue() const { return graphicsQueue; }
     uint32_t getGraphicsQueueFamily() const { return graphicsQueueFamily; }
-    bool hasDedicatedTransferQueue() const { return hasDedicatedTransfer_; }
     VmaAllocator getAllocator() const { return allocator; }
     VkSurfaceKHR getSurface() const { return surface; }
-    VkPipelineCache getPipelineCache() const { return pipelineCache_; }
 
     VkSwapchainKHR getSwapchain() const { return swapchain; }
     VkFormat getSwapchainFormat() const { return swapchainFormat; }
@@ -124,18 +105,6 @@ public:
     VkImageView getDepthResolveImageView() const { return depthResolveImageView; }
     VkImageView getDepthImageView() const { return depthImageView; }
 
-    // Sampler cache: returns a shared VkSampler matching the given create info.
-    // Callers must NOT destroy the returned sampler — it is owned by VkContext.
-    // Automatically clamps anisotropy if the device doesn't support it.
-    VkSampler getOrCreateSampler(const VkSamplerCreateInfo& info);
-
-    // Whether the physical device supports sampler anisotropy.
-    bool isSamplerAnisotropySupported() const { return samplerAnisotropySupported_; }
-
-    // Global sampler cache accessor (set during VkContext::initialize, cleared on shutdown).
-    // Used by VkTexture and other code that only has a VkDevice handle.
-    static VkContext* globalInstance() { return sInstance_; }
-
     // UI texture upload: creates a Vulkan texture from RGBA data and returns
     // a VkDescriptorSet suitable for use as ImTextureID.
     // The caller does NOT need to free the result — resources are tracked and
@@ -152,8 +121,6 @@ private:
     void destroySwapchain();
     bool createCommandPools();
     bool createSyncObjects();
-    bool createPipelineCache();
-    void savePipelineCache();
     bool createImGuiResources();
     void destroyImGuiResources();
 
@@ -168,22 +135,11 @@ private:
     VkDevice device = VK_NULL_HANDLE;
     VmaAllocator allocator = VK_NULL_HANDLE;
 
-    // Pipeline cache (persisted to disk for faster startup)
-    VkPipelineCache pipelineCache_ = VK_NULL_HANDLE;
-    uint32_t gpuVendorId_ = 0;
-    char gpuName_[256] = {};
-
     VkQueue graphicsQueue = VK_NULL_HANDLE;
     VkQueue presentQueue = VK_NULL_HANDLE;
     uint32_t graphicsQueueFamily = 0;
     uint32_t presentQueueFamily = 0;
 
-    // Dedicated transfer queue (second queue from same graphics family)
-    VkQueue transferQueue_ = VK_NULL_HANDLE;
-    VkCommandPool transferCommandPool_ = VK_NULL_HANDLE;
-    bool hasDedicatedTransfer_ = false;
-    uint32_t graphicsQueueFamilyQueueCount_ = 1; // queried in selectPhysicalDevice
-
     // Swapchain
     VkSwapchainKHR swapchain = VK_NULL_HANDLE;
     VkFormat swapchainFormat = VK_FORMAT_UNDEFINED;
@@ -199,12 +155,6 @@ private:
     FrameData frames[MAX_FRAMES_IN_FLIGHT];
     uint32_t currentFrame = 0;
 
-    // Per-swapchain-image semaphores (avoids reuse while presentation engine holds them)
-    std::vector<VkSemaphore> imageAcquiredSemaphores_;   // [swapchainImageCount], per-image
-    std::vector<VkSemaphore> renderFinishedSemaphores_;  // [swapchainImageCount], per-image
-    VkSemaphore nextAcquireSemaphore_ = VK_NULL_HANDLE;  // free semaphore for next acquire
-    VkSemaphore currentAcquireSemaphore_ = VK_NULL_HANDLE; // the one used for the current frame
-
     // Immediate submit resources
     VkCommandPool immCommandPool = VK_NULL_HANDLE;
     VkFence immFence = VK_NULL_HANDLE;
@@ -223,9 +173,6 @@ private:
     };
     std::vector<InFlightBatch> inFlightBatches_;
 
-    void runDeferredCleanup(uint32_t frameIndex);
-    std::vector<std::function<void()>> deferredCleanup_[MAX_FRAMES_IN_FLIGHT];
-
     // Depth buffer (shared across all framebuffers)
     VkImage depthImage = VK_NULL_HANDLE;
     VkImageView depthImageView = VK_NULL_HANDLE;
@@ -246,9 +193,6 @@ private:
     bool createDepthResolveImage();
     void destroyDepthResolveImage();
 
-    // Actual Vulkan API version the instance was created with (gates core 1.2 calls)
-    uint32_t instanceApiVersion_ = VK_API_VERSION_1_1;
-
     // MSAA depth resolve support (for sampling/copying resolved depth)
     bool depthResolveSupported_ = false;
     VkResolveModeFlagBits depthResolveMode_ = VK_RESOLVE_MODE_NONE;
@@ -271,13 +215,6 @@ private:
     };
     std::vector<UiTexture> uiTextures_;
 
-    // Sampler cache — deduplicates VkSamplers by configuration hash.
-    std::mutex samplerCacheMutex_;
-    std::unordered_map<uint64_t, VkSampler> samplerCache_;
-    bool samplerAnisotropySupported_ = false;
-
-    static VkContext* sInstance_;
-
 #ifndef NDEBUG
     bool enableValidation = true;
 #else
diff --git a/include/rendering/vk_frame_data.hpp b/include/rendering/vk_frame_data.hpp
index bc06af10..595b76ac 100644
--- a/include/rendering/vk_frame_data.hpp
+++ b/include/rendering/vk_frame_data.hpp
@@ -2,8 +2,6 @@
 
 #include <vulkan/vulkan.h>
 #include <glm/glm.hpp>
-#include <atomic>
-#include <chrono>
 
 namespace wowee {
 namespace rendering {
@@ -27,44 +25,5 @@ struct GPUPushConstants {
     glm::mat4 model;
 };
 
-// Push constants for shadow rendering passes
-struct ShadowPush {
-    glm::mat4 lightSpaceMatrix;
-    glm::mat4 model;
-};
-
-// Uniform buffer for shadow rendering parameters (matches shader std140 layout)
-struct ShadowParamsUBO {
-    int32_t useBones;
-    int32_t useTexture;
-    int32_t alphaTest;
-    int32_t foliageSway;
-    float windTime;
-    float foliageMotionDamp;
-};
-
-// Timer utility for performance profiling queries.
-// Uses atomics because floor-height queries are dispatched on async threads
-// from CameraController while the main thread may read the counters.
-struct QueryTimer {
-    std::atomic<double>* totalMs = nullptr;
-    std::atomic<uint32_t>* callCount = nullptr;
-    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
-    QueryTimer(std::atomic<double>* total, std::atomic<uint32_t>* calls)
-        : totalMs(total), callCount(calls) {}
-    ~QueryTimer() {
-        if (callCount) {
-            callCount->fetch_add(1, std::memory_order_relaxed);
-        }
-        if (totalMs) {
-            auto end = std::chrono::steady_clock::now();
-            double ms = std::chrono::duration<double, std::milli>(end - start).count();
-            // Relaxed is fine for diagnostics — exact ordering doesn't matter.
-            double old = totalMs->load(std::memory_order_relaxed);
-            while (!totalMs->compare_exchange_weak(old, old + ms, std::memory_order_relaxed)) {}
-        }
-    }
-};
-
 } // namespace rendering
 } // namespace wowee
diff --git a/include/rendering/vk_pipeline.hpp b/include/rendering/vk_pipeline.hpp
index e53229e3..ea0a3e10 100644
--- a/include/rendering/vk_pipeline.hpp
+++ b/include/rendering/vk_pipeline.hpp
@@ -75,12 +75,8 @@ public:
     // Dynamic state
     PipelineBuilder& setDynamicStates(const std::vector<VkDynamicState>& states);
 
-    // Pipeline derivatives — hint driver to share compiled state between similar pipelines
-    PipelineBuilder& setFlags(VkPipelineCreateFlags flags);
-    PipelineBuilder& setBasePipeline(VkPipeline basePipeline);
-
-    // Build the pipeline (pass a VkPipelineCache for faster creation)
-    VkPipeline build(VkDevice device, VkPipelineCache cache = VK_NULL_HANDLE) const;
+    // Build the pipeline
+    VkPipeline build(VkDevice device) const;
 
     // Common blend states
     static VkPipelineColorBlendAttachmentState blendDisabled();
@@ -110,8 +106,6 @@ private:
     VkRenderPass renderPass_ = VK_NULL_HANDLE;
     uint32_t subpass_ = 0;
     std::vector<VkDynamicState> dynamicStates_;
-    VkPipelineCreateFlags flags_ = 0;
-    VkPipeline basePipelineHandle_ = VK_NULL_HANDLE;
 };
 
 // Helper to create a pipeline layout from descriptor set layouts and push constant ranges
diff --git a/include/rendering/vk_render_target.hpp b/include/rendering/vk_render_target.hpp
index a954bc5b..ffa1cd4f 100644
--- a/include/rendering/vk_render_target.hpp
+++ b/include/rendering/vk_render_target.hpp
@@ -73,7 +73,6 @@ private:
     bool hasDepth_ = false;
     VkSampleCountFlagBits msaaSamples_ = VK_SAMPLE_COUNT_1_BIT;
     VkSampler sampler_ = VK_NULL_HANDLE;
-    bool ownsSampler_ = true;
     VkRenderPass renderPass_ = VK_NULL_HANDLE;
     VkFramebuffer framebuffer_ = VK_NULL_HANDLE;
 };
diff --git a/include/rendering/vk_shader.hpp b/include/rendering/vk_shader.hpp
index 8ed2c241..cd8fc839 100644
--- a/include/rendering/vk_shader.hpp
+++ b/include/rendering/vk_shader.hpp
@@ -18,7 +18,7 @@ public:
     VkShaderModule& operator=(VkShaderModule&& other) noexcept;
 
     // Load a SPIR-V file from disk
-    [[nodiscard]] bool loadFromFile(VkDevice device, const std::string& path);
+    bool loadFromFile(VkDevice device, const std::string& path);
 
     // Load from raw SPIR-V bytes
     bool loadFromMemory(VkDevice device, const uint32_t* code, size_t sizeBytes);
diff --git a/include/rendering/vk_texture.hpp b/include/rendering/vk_texture.hpp
index 985f699d..83167d9d 100644
--- a/include/rendering/vk_texture.hpp
+++ b/include/rendering/vk_texture.hpp
@@ -60,7 +60,7 @@ public:
     uint32_t getHeight() const { return image_.extent.height; }
     VkFormat getFormat() const { return image_.format; }
     uint32_t getMipLevels() const { return mipLevels_; }
-    bool isValid() const { return image_.image != VK_NULL_HANDLE && sampler_ != VK_NULL_HANDLE; }
+    bool isValid() const { return image_.image != VK_NULL_HANDLE; }
 
     // Write descriptor info for binding
     VkDescriptorImageInfo descriptorInfo(VkImageLayout layout =
@@ -68,13 +68,10 @@ public:
 
 private:
     void generateMipmaps(VkContext& ctx, VkFormat format, uint32_t width, uint32_t height);
-    // Shared sampler finalization: prefer the global cache, fall back to direct creation
-    bool finalizeSampler(VkDevice device, const VkSamplerCreateInfo& samplerInfo);
 
     AllocatedImage image_{};
     VkSampler sampler_ = VK_NULL_HANDLE;
     uint32_t mipLevels_ = 1;
-    bool ownsSampler_ = true; // false when sampler comes from VkContext cache
 };
 
 } // namespace rendering
diff --git a/include/rendering/vk_utils.hpp b/include/rendering/vk_utils.hpp
index 22631cc0..40847ad1 100644
--- a/include/rendering/vk_utils.hpp
+++ b/include/rendering/vk_utils.hpp
@@ -3,8 +3,6 @@
 #include <vulkan/vulkan.h>
 #include <vk_mem_alloc.h>
 #include <cstdint>
-#include <limits>
-#include <cstdlib>
 
 namespace wowee {
 namespace rendering {
@@ -58,25 +56,5 @@ inline bool vkCheck(VkResult result, [[maybe_unused]] const char* msg) {
     return true;
 }
 
-// Environment variable utility functions
-inline size_t envSizeMBOrDefault(const char* name, size_t defMb) {
-    const char* v = std::getenv(name);
-    if (!v || !*v) return defMb;
-    char* end = nullptr;
-    unsigned long long mb = std::strtoull(v, &end, 10);
-    if (end == v || mb == 0) return defMb;
-    if (mb > (std::numeric_limits<size_t>::max() / (1024ull * 1024ull))) return defMb;
-    return static_cast<size_t>(mb);
-}
-
-inline size_t envSizeOrDefault(const char* name, size_t defValue) {
-    const char* v = std::getenv(name);
-    if (!v || !*v) return defValue;
-    char* end = nullptr;
-    unsigned long long n = std::strtoull(v, &end, 10);
-    if (end == v || n == 0) return defValue;
-    return static_cast<size_t>(n);
-}
-
 } // namespace rendering
 } // namespace wowee
diff --git a/include/rendering/weather.hpp b/include/rendering/weather.hpp
index 3349526f..b92c963d 100644
--- a/include/rendering/weather.hpp
+++ b/include/rendering/weather.hpp
@@ -28,8 +28,7 @@ public:
     enum class Type {
         NONE,
         RAIN,
-        SNOW,
-        STORM
+        SNOW
     };
 
     Weather();
diff --git a/include/rendering/wmo_renderer.hpp b/include/rendering/wmo_renderer.hpp
index 33eae7da..4546d41c 100644
--- a/include/rendering/wmo_renderer.hpp
+++ b/include/rendering/wmo_renderer.hpp
@@ -4,7 +4,6 @@
 #include <vulkan/vulkan.h>
 #include <vk_mem_alloc.h>
 #include <glm/glm.hpp>
-#include <atomic>
 #include <memory>
 #include <unordered_map>
 #include <unordered_set>
@@ -70,12 +69,6 @@ public:
      */
     bool loadModel(const pipeline::WMOModel& model, uint32_t id);
 
-    /**
-     * Check if a WMO model is currently resident in the renderer
-     * @param id WMO model identifier
-     */
-    bool isModelLoaded(uint32_t id) const;
-
     /**
      * Unload WMO model and free GPU resources
      * @param id WMO model identifier
@@ -157,8 +150,7 @@ public:
      */
     /** Pre-update mutable state (frame ID, material UBOs) on main thread before parallel render. */
     void prepareRender();
-    void render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const Camera& camera,
-                const glm::vec3* viewerPos = nullptr);
+    void render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const Camera& camera);
 
     /**
      * Initialize shadow pipeline (Phase 7)
@@ -361,9 +353,7 @@ private:
         float heightMapVariance;   // 40 (low variance = skip POM)
         float normalMapStrength;   // 44 (0=flat, 1=full, 2=exaggerated)
         int32_t isLava;            // 48 (1=lava/magma UV scroll)
-        float wmoAmbientR;         // 52 (interior ambient color R)
-        float wmoAmbientG;         // 56 (interior ambient color G)
-        float wmoAmbientB;         // 60 (interior ambient color B)
+        float pad[3];              // 52-60 padding to 64 bytes
     };  // 64 bytes total
 
     /**
@@ -482,7 +472,6 @@ private:
         std::vector<GroupResources> groups;
         glm::vec3 boundingBoxMin;
         glm::vec3 boundingBoxMax;
-        glm::vec3 wmoAmbientColor{0.5f, 0.5f, 0.5f};  // From MOHD, used for interior lighting
         bool isLowPlatform = false;
 
         // Doodad templates (M2 models placed in WMO, stored for instancing)
@@ -599,11 +588,9 @@ private:
     VkDescriptorSet allocateMaterialSet();
 
     /**
-     * Destroy GPU resources for a single group.
-     * When defer=true, destruction is scheduled via deferAfterFrameFence
-     * so in-flight command buffers are not invalidated.
+     * Destroy GPU resources for a single group
      */
-    void destroyGroupGPU(GroupResources& group, bool defer = false);
+    void destroyGroupGPU(GroupResources& group);
 
     struct GridCell {
         int x;
@@ -659,7 +646,7 @@ private:
 
     // Descriptor pool for material sets
     VkDescriptorPool materialDescPool_ = VK_NULL_HANDLE;
-    static constexpr uint32_t MAX_MATERIAL_SETS = 32768;
+    static constexpr uint32_t MAX_MATERIAL_SETS = 8192;
 
     // Texture cache (path -> VkTexture)
     struct TextureCacheEntry {
@@ -674,9 +661,7 @@ private:
     uint64_t textureCacheCounter_ = 0;
     size_t textureCacheBudgetBytes_ = 8192ull * 1024 * 1024;  // 8 GB default, overridden at init
     std::unordered_set<std::string> failedTextureCache_;
-    std::unordered_map<std::string, uint64_t> failedTextureRetryAt_;
     std::unordered_set<std::string> loggedTextureLoadFails_;
-    uint64_t textureLookupSerial_ = 0;
     uint32_t textureBudgetRejectWarnings_ = 0;
 
     // Default white texture
@@ -708,7 +693,7 @@ private:
     // Rendering state
     bool wireframeMode = false;
     bool frustumCulling = true;
-    bool portalCulling = true;   // AABB transform bug fixed; conservative frustum test (no plane-side check) is visually safe
+    bool portalCulling = false;  // Disabled by default - needs debugging
     bool distanceCulling = false;  // Disabled - causes ground to disappear
     float maxGroupDistance = 500.0f;
     float maxGroupDistanceSq = 250000.0f;  // maxGroupDistance^2
@@ -740,13 +725,10 @@ private:
     std::vector<std::future<void>> cullFutures_;
     std::vector<size_t> visibleInstances_;      // reused per frame
     std::vector<InstanceDrawList> drawLists_;    // reused per frame
-    std::vector<uint32_t> portalVisibleGroups_; // reused per frame (portal culling scratch)
-    std::unordered_set<uint32_t> portalVisibleGroupSet_; // reused per frame (portal culling scratch)
 
-    // Collision query profiling — atomic because getFloorHeight is dispatched
-    // on async threads from camera_controller while the main thread reads these.
-    mutable std::atomic<double> queryTimeMs{0.0};
-    mutable std::atomic<uint32_t> queryCallCount{0};
+    // Collision query profiling (per frame).
+    mutable double queryTimeMs = 0.0;
+    mutable uint32_t queryCallCount = 0;
 
     // Floor height cache - persistent precomputed grid
     static constexpr float FLOOR_GRID_CELL_SIZE = 2.0f;  // 2 unit grid cells
diff --git a/include/rendering/world_map.hpp b/include/rendering/world_map.hpp
index fee98b6d..89568209 100644
--- a/include/rendering/world_map.hpp
+++ b/include/rendering/world_map.hpp
@@ -3,7 +3,6 @@
 #include <vulkan/vulkan.h>
 #include <vk_mem_alloc.h>
 #include <glm/glm.hpp>
-#include <cstdint>
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -18,22 +17,6 @@ class VkContext;
 class VkTexture;
 class VkRenderTarget;
 
-/// Party member dot passed in from the UI layer for world map overlay.
-struct WorldMapPartyDot {
-    glm::vec3 renderPos;   ///< Position in render-space coordinates
-    uint32_t  color;       ///< RGBA packed color (IM_COL32 format)
-    std::string name;      ///< Member name (shown as tooltip on hover)
-};
-
-/// Taxi (flight master) node passed from the UI layer for world map overlay.
-struct WorldMapTaxiNode {
-    uint32_t  id = 0;      ///< TaxiNodes.dbc ID
-    uint32_t  mapId = 0;   ///< WoW internal map ID (0=EK,1=Kal,530=Outland,571=Northrend)
-    float     wowX = 0, wowY = 0, wowZ = 0;  ///< Canonical WoW coordinates
-    std::string name;      ///< Node name (shown as tooltip)
-    bool      known = false; ///< Player has discovered this node
-};
-
 struct WorldMapZone {
     uint32_t wmaID = 0;
     uint32_t areaID = 0;       // 0 = continent level
@@ -60,27 +43,10 @@ public:
     void compositePass(VkCommandBuffer cmd);
 
     /// ImGui overlay — call INSIDE the main render pass (during ImGui frame).
-    void render(const glm::vec3& playerRenderPos, int screenWidth, int screenHeight,
-                float playerYawDeg = 0.0f);
+    void render(const glm::vec3& playerRenderPos, int screenWidth, int screenHeight);
 
     void setMapName(const std::string& name);
     void setServerExplorationMask(const std::vector<uint32_t>& masks, bool hasData);
-    void setPartyDots(std::vector<WorldMapPartyDot> dots) { partyDots_ = std::move(dots); }
-    void setTaxiNodes(std::vector<WorldMapTaxiNode> nodes) { taxiNodes_ = std::move(nodes); }
-
-    /// Quest POI marker for world map overlay (from SMSG_QUEST_POI_QUERY_RESPONSE).
-    struct QuestPoi {
-        float wowX = 0, wowY = 0;  ///< Canonical WoW coordinates (centroid of POI area)
-        std::string name;           ///< Quest title
-    };
-    void setQuestPois(std::vector<QuestPoi> pois) { questPois_ = std::move(pois); }
-    /// Set the player's corpse position for overlay rendering.
-    /// @param hasCorpse  True when the player is a ghost with an unclaimed corpse on this map.
-    /// @param renderPos  Corpse position in render-space coordinates.
-    void setCorpsePos(bool hasCorpse, glm::vec3 renderPos) {
-        hasCorpse_ = hasCorpse;
-        corpseRenderPos_ = renderPos;
-    }
     bool isOpen() const { return open; }
     void close() { open = false; }
 
@@ -96,8 +62,7 @@ private:
                                       float& top, float& bottom) const;
     void loadZoneTextures(int zoneIdx);
     void requestComposite(int zoneIdx);
-    void renderImGuiOverlay(const glm::vec3& playerRenderPos, int screenWidth, int screenHeight,
-                            float playerYawDeg);
+    void renderImGuiOverlay(const glm::vec3& playerRenderPos, int screenWidth, int screenHeight);
     void updateExploration(const glm::vec3& playerRenderPos);
     void zoomIn(const glm::vec3& playerRenderPos);
     void zoomOut();
@@ -148,26 +113,10 @@ private:
     // Texture storage (owns all VkTexture objects for zone tiles)
     std::vector<std::unique_ptr<VkTexture>> zoneTextures;
 
-    // Party member dots (set each frame from the UI layer)
-    std::vector<WorldMapPartyDot> partyDots_;
-
-    // Taxi node markers (set each frame from the UI layer)
-    std::vector<WorldMapTaxiNode> taxiNodes_;
-    int currentMapId_ = -1;  ///< WoW map ID currently loaded (set in loadZonesFromDBC)
-
-    // Quest POI markers (set each frame from the UI layer)
-    std::vector<QuestPoi> questPois_;
-
-    // Corpse marker (ghost state — set each frame from the UI layer)
-    bool      hasCorpse_        = false;
-    glm::vec3 corpseRenderPos_  = {};
-
     // Exploration / fog of war
     std::vector<uint32_t> serverExplorationMask;
     bool hasServerExplorationMask = false;
     std::unordered_set<int> exploredZones;
-    // Locally accumulated exploration (used as fallback when server mask is unavailable)
-    std::unordered_set<int> locallyExploredZones_;
 };
 
 } // namespace rendering
diff --git a/include/ui/action_bar_panel.hpp b/include/ui/action_bar_panel.hpp
deleted file mode 100644
index 4a62e642..00000000
--- a/include/ui/action_bar_panel.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-// ============================================================
-// ActionBarPanel — extracted from GameScreen
-// Owns all action bar rendering: main bar, stance bar, bag bar,
-// XP bar, reputation bar, macro resolution.
-// ============================================================
-#pragma once
-#include "ui/ui_services.hpp"
-#include <cstdint>
-#include <unordered_map>
-#include <functional>
-#include <vulkan/vulkan.h>
-
-namespace wowee {
-namespace game { class GameHandler; }
-namespace pipeline { class AssetManager; }
-namespace ui {
-
-class ChatPanel;
-class SettingsPanel;
-class InventoryScreen;
-class SpellbookScreen;
-class QuestLogScreen;
-
-class ActionBarPanel {
-public:
-    // Callback type for resolving spell icons (spellId, assetMgr) → VkDescriptorSet
-    using SpellIconFn = std::function<VkDescriptorSet(uint32_t, pipeline::AssetManager*)>;
-
-    // ---- Action bar render methods ----
-    void renderActionBar(game::GameHandler& gameHandler,
-                         SettingsPanel& settingsPanel,
-                         ChatPanel& chatPanel,
-                         InventoryScreen& inventoryScreen,
-                         SpellbookScreen& spellbookScreen,
-                         QuestLogScreen& questLogScreen,
-                         SpellIconFn getSpellIcon);
-    void renderStanceBar(game::GameHandler& gameHandler,
-                         SettingsPanel& settingsPanel,
-                         SpellbookScreen& spellbookScreen,
-                         SpellIconFn getSpellIcon);
-    void renderBagBar(game::GameHandler& gameHandler,
-                      SettingsPanel& settingsPanel,
-                      InventoryScreen& inventoryScreen);
-    void renderXpBar(game::GameHandler& gameHandler,
-                     SettingsPanel& settingsPanel);
-    void renderRepBar(game::GameHandler& gameHandler,
-                      SettingsPanel& settingsPanel);
-
-    // ---- State owned by this panel ----
-
-    // Action bar error-flash: spellId → wall-clock time (seconds) when the flash ends
-    std::unordered_map<uint32_t, float> actionFlashEndTimes_;
-    static constexpr float kActionFlashDuration = 0.5f;
-
-    // Action bar drag state (-1 = not dragging)
-    int actionBarDragSlot_ = -1;
-    VkDescriptorSet actionBarDragIcon_ = VK_NULL_HANDLE;
-
-    // Bag bar state
-    VkDescriptorSet backpackIconTexture_ = VK_NULL_HANDLE;
-    VkDescriptorSet emptyBagSlotTexture_ = VK_NULL_HANDLE;
-    int bagBarPickedSlot_ = -1;
-    int bagBarDragSource_ = -1;
-
-    // Macro editor popup state
-    uint32_t macroEditorId_   = 0;
-    bool     macroEditorOpen_ = false;
-    char     macroEditorBuf_[256] = {};
-
-    // Macro cooldown cache: maps macro ID → resolved primary spell ID
-    std::unordered_map<uint32_t, uint32_t> macroPrimarySpellCache_;
-    size_t macroCacheSpellCount_ = 0;
-
-    // Section 3.5: UIServices injection (Phase B singleton breaking)
-    void setServices(const UIServices& services) { services_ = services; }
-
-private:
-    UIServices services_;
-    uint32_t resolveMacroPrimarySpellId(uint32_t macroId, game::GameHandler& gameHandler);
-};
-
-} // namespace ui
-} // namespace wowee
diff --git a/include/ui/auth_screen.hpp b/include/ui/auth_screen.hpp
index e02fefe2..e1dbdde7 100644
--- a/include/ui/auth_screen.hpp
+++ b/include/ui/auth_screen.hpp
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "ui/ui_services.hpp"
 #include "auth/auth_handler.hpp"
 #include <vulkan/vulkan.h>
 #include <string>
@@ -31,9 +30,6 @@ public:
      */
     void setOnSuccess(std::function<void()> callback) { onSuccess = callback; }
 
-    /// Set services (dependency injection)
-    void setServices(const UIServices& services) { services_ = services; }
-
 
     /**
      * Check if authentication is in progress
@@ -48,8 +44,6 @@ public:
     const std::string& getStatusMessage() const { return statusMessage; }
 
 private:
-    UIServices services_;  // Injected service references
-
     struct ServerProfile {
         std::string hostname;
         int port = 3724;
@@ -131,35 +125,6 @@ private:
     std::vector<std::string> introTracks_;
     bool loginMusicVolumeAdjusted_ = false;
     int savedMusicVolume_ = 30;
-
-    // ----- Login-screen graphics settings popup -----
-    bool showLoginSettings_ = false;
-
-    // Local copies of the settings keys we expose in the login popup.
-    // Loaded on first open; saved on Apply.
-    struct LoginGraphicsState {
-        int  preset          = 2;   // 0=Custom 1=Low 2=Medium 3=High 4=Ultra
-        bool shadows         = true;
-        float shadowDistance = 300.0f;
-        int  antiAliasing    = 0;   // 0=Off 1=2x 2=4x 3=8x
-        bool fxaa            = false;
-        bool normalMapping   = true;
-        bool pom             = true;
-        int  pomQuality      = 1;   // 0=Low 1=Medium 2=High
-        int  upscalingMode   = 0;   // 0=Off 1=FSR1 2=FSR3
-        bool waterRefraction = true;
-        int  groundClutter   = 100; // 0-150
-        int  brightness      = 50;  // 0-100
-        bool vsync           = false;
-        bool fullscreen      = false;
-    };
-    LoginGraphicsState loginGfx_;
-    bool loginGfxLoaded_ = false;
-
-    void renderLoginSettingsWindow();
-    void loadLoginGraphicsState();
-    void saveLoginGraphicsState();
-    static void applyPresetToState(LoginGraphicsState& s, int preset);
 };
 
 }} // namespace wowee::ui
diff --git a/include/ui/character_screen.hpp b/include/ui/character_screen.hpp
index c4312bc8..aae4d6a0 100644
--- a/include/ui/character_screen.hpp
+++ b/include/ui/character_screen.hpp
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "ui/ui_services.hpp"
 #include "game/game_handler.hpp"
 #include <imgui.h>
 #include <string>
@@ -49,9 +48,6 @@ public:
     void setOnBack(std::function<void()> cb) { onBack = std::move(cb); }
     void setOnDeleteCharacter(std::function<void(uint64_t)> cb) { onDeleteCharacter = std::move(cb); }
 
-    /// Set services (dependency injection)
-    void setServices(const UIServices& services) { services_ = services; }
-
     /**
      * Reset selection state (e.g., when switching servers)
      */
@@ -93,8 +89,6 @@ public:
     void selectCharacterByName(const std::string& name);
 
 private:
-    UIServices services_;  // Injected service references
-
     // UI state
     int selectedCharacterIndex = -1;
     bool characterSelected = false;
diff --git a/include/ui/chat_panel.hpp b/include/ui/chat_panel.hpp
deleted file mode 100644
index b6528545..00000000
--- a/include/ui/chat_panel.hpp
+++ /dev/null
@@ -1,201 +0,0 @@
-#pragma once
-
-#include "game/game_handler.hpp"
-#include "ui/ui_services.hpp"
-#include <vulkan/vulkan.h>
-#include <imgui.h>
-#include <string>
-#include <vector>
-#include <functional>
-
-namespace wowee {
-namespace pipeline { class AssetManager; }
-namespace rendering { class Renderer; }
-namespace ui {
-
-class InventoryScreen;
-class SpellbookScreen;
-class QuestLogScreen;
-
-/**
- * Self-contained chat UI panel extracted from GameScreen.
- *
- * Owns all chat state: input buffer, sent-history, tab filtering,
- * slash-command parsing, chat bubbles, and chat-related settings.
- */
-class ChatPanel {
-public:
-    ChatPanel();
-
-    // ---- Main entry points (called by GameScreen) ----
-
-    /**
-     * Render the chat window (tabs, history, input, etc.)
-     */
-    void render(game::GameHandler& gameHandler,
-               InventoryScreen& inventoryScreen,
-               SpellbookScreen& spellbookScreen,
-               QuestLogScreen& questLogScreen);
-
-    /**
-     * Render 3D-projected chat bubbles above entities.
-     */
-    void renderBubbles(game::GameHandler& gameHandler);
-
-    /**
-     * Register one-shot callbacks on GameHandler (call once per session).
-     * Sets up the chat-bubble callback.
-     */
-    void setupCallbacks(game::GameHandler& gameHandler);
-
-    // ---- Input helpers (called by GameScreen keybind handling) ----
-
-    bool isChatInputActive() const { return chatInputActive_; }
-
-    /** Insert a spell / item link into the chat input buffer (shift-click). */
-    void insertChatLink(const std::string& link);
-
-    /** Activate the input field with a leading '/' (slash key). */
-    void activateSlashInput();
-
-    /** Activate (focus) the input field (Enter key). */
-    void activateInput();
-
-    /** Request that the chat input be focused next frame. */
-    void requestRefocus() { refocusChatInput_ = true; }
-
-    /** Set up a whisper to the given player name and focus input. */
-    void setWhisperTarget(const std::string& name);
-
-    /** Execute a macro body (one line per 'click'). */
-    void executeMacroText(game::GameHandler& gameHandler,
-                          InventoryScreen& inventoryScreen,
-                          SpellbookScreen& spellbookScreen,
-                          QuestLogScreen& questLogScreen,
-                          const std::string& macroText);
-
-    // ---- Slash-command side-effects ----
-    // GameScreen reads these each frame, then clears them.
-
-    struct SlashCommands {
-        bool showInspect   = false;
-        bool toggleThreat  = false;
-        bool showBgScore   = false;
-        bool showGmTicket  = false;
-        bool showWho       = false;
-        bool toggleCombatLog = false;
-        bool takeScreenshot = false;
-    };
-
-    /** Return accumulated slash-command flags and reset them. */
-    SlashCommands consumeSlashCommands();
-
-    // ---- Chat settings (read/written by GameScreen save/load & settings tab) ----
-
-    bool  chatShowTimestamps  = false;
-    int   chatFontSize        = 1;   // 0=small, 1=medium, 2=large
-    bool  chatAutoJoinGeneral = true;
-    bool  chatAutoJoinTrade   = true;
-    bool  chatAutoJoinLocalDefense = true;
-    bool  chatAutoJoinLFG     = true;
-    bool  chatAutoJoinLocal   = true;
-    int   activeChatTab       = 0;
-
-    /** Spell icon lookup callback — set by GameScreen each frame before render(). */
-    std::function<VkDescriptorSet(uint32_t, pipeline::AssetManager*)> getSpellIcon;
-
-    /** Render the "Chat" tab inside the Settings window. */
-    void renderSettingsTab(std::function<void()> saveSettingsFn);
-
-    /** Reset all chat settings to defaults. */
-    void restoreDefaults();
-
-    // Section 3.5: UIServices injection (Phase B singleton breaking)
-    void setServices(const UIServices& services) { services_ = services; }
-
-    /** Replace $g/$G and $n/$N gender/name placeholders in quest/chat text. */
-    std::string replaceGenderPlaceholders(const std::string& text, game::GameHandler& gameHandler);
-
-private:
-    // Section 3.5: Injected UI services (Phase B singleton breaking)
-    UIServices services_;
-
-    // ---- Chat input state ----
-    char chatInputBuffer_[512] = "";
-    char whisperTargetBuffer_[256] = "";
-    bool chatInputActive_ = false;
-    int  selectedChatType_ = 0;  // 0=SAY .. 10=CHANNEL
-    int  lastChatType_     = 0;
-    int  selectedChannelIdx_ = 0;
-    bool chatInputMoveCursorToEnd_ = false;
-    bool refocusChatInput_ = false;
-
-    // Sent-message history (Up/Down arrow recall)
-    std::vector<std::string> chatSentHistory_;
-    int chatHistoryIdx_ = -1;
-
-    // Macro stop flag
-    bool macroStopped_ = false;
-
-    // Tab-completion state
-    std::string chatTabPrefix_;
-    std::vector<std::string> chatTabMatches_;
-    int chatTabMatchIdx_ = -1;
-
-    // Mention notification
-    size_t chatMentionSeenCount_ = 0;
-
-    // ---- Chat tabs ----
-    struct ChatTab {
-        std::string name;
-        uint64_t typeMask;
-    };
-    std::vector<ChatTab> chatTabs_;
-    std::vector<int> chatTabUnread_;
-    size_t chatTabSeenCount_ = 0;
-
-    void initChatTabs();
-    bool shouldShowMessage(const game::MessageChatData& msg, int tabIndex) const;
-
-    // ---- Chat window visual state ----
-    bool  chatScrolledUp_          = false;
-    bool  chatForceScrollToBottom_ = false;
-    bool  chatWindowLocked_        = true;
-    ImVec2 chatWindowPos_          = ImVec2(0.0f, 0.0f);
-    bool  chatWindowPosInit_       = false;
-
-    // ---- Chat bubbles ----
-    struct ChatBubble {
-        uint64_t senderGuid   = 0;
-        std::string message;
-        float timeRemaining   = 0.0f;
-        float totalDuration   = 0.0f;
-        bool isYell           = false;
-    };
-    std::vector<ChatBubble> chatBubbles_;
-    bool chatBubbleCallbackSet_ = false;
-
-    // ---- Whisper toast state (populated in render, rendered by GameScreen/ToastManager) ----
-    // Whisper scanning lives here because it's tightly coupled to chat history iteration.
-    size_t whisperSeenCount_ = 0;
-
-    // ---- Helpers ----
-    void sendChatMessage(game::GameHandler& gameHandler,
-                         InventoryScreen& inventoryScreen,
-                         SpellbookScreen& spellbookScreen,
-                         QuestLogScreen& questLogScreen);
-    const char* getChatTypeName(game::ChatType type) const;
-    ImVec4 getChatTypeColor(game::ChatType type) const;
-
-    // Cached game handler for input callback (set each frame in render)
-    game::GameHandler* cachedGameHandler_ = nullptr;
-
-    // Join channel input buffer
-    char joinChannelBuffer_[128] = "";
-
-    // Slash command flags (accumulated, consumed by GameScreen)
-    SlashCommands slashCmds_;
-};
-
-} // namespace ui
-} // namespace wowee
diff --git a/include/ui/combat_ui.hpp b/include/ui/combat_ui.hpp
deleted file mode 100644
index b09d2fc4..00000000
--- a/include/ui/combat_ui.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#pragma once
-
-#include "ui/ui_services.hpp"
-#include <imgui.h>
-#include <vulkan/vulkan.h>
-#include <string>
-#include <vector>
-#include <cstdint>
-#include <functional>
-
-namespace wowee {
-namespace game { class GameHandler; }
-namespace pipeline { class AssetManager; }
-namespace ui {
-
-class SettingsPanel;
-class SpellbookScreen;
-
-/**
- * Combat UI overlay manager (extracted from GameScreen)
- *
- * Owns all combat-related rendering:
- *   cast bar, cooldown tracker, raid warning overlay, floating combat text,
- *   DPS/HPS meter, buff bar, battleground score HUD, combat log,
- *   threat window, BG scoreboard.
- */
-class CombatUI {
-public:
-    CombatUI() = default;
-
-    // ---- Callback type for spell icon lookup (stays in GameScreen) ----
-    using SpellIconFn = std::function<VkDescriptorSet(uint32_t spellId, pipeline::AssetManager*)>;
-
-    // ---- Toggle booleans (written by slash commands / escape handler / settings) ----
-    bool showCombatLog_ = false;
-    bool showThreatWindow_ = false;
-    bool showBgScoreboard_ = false;
-
-    // ---- Raid Warning / Boss Emote big-text overlay ----
-    struct RaidWarnEntry {
-        std::string text;
-        float age = 0.0f;
-        bool isBossEmote = false;
-        static constexpr float LIFETIME = 5.0f;
-    };
-    std::vector<RaidWarnEntry> raidWarnEntries_;
-    bool raidWarnCallbackSet_ = false;
-    size_t raidWarnChatSeenCount_ = 0;
-
-    // ---- DPS meter state ----
-    float dpsCombatAge_ = 0.0f;
-    bool dpsWasInCombat_ = false;
-    float dpsEncounterDamage_ = 0.0f;
-    float dpsEncounterHeal_   = 0.0f;
-    size_t dpsLogSeenCount_   = 0;
-
-    // ---- Public render methods ----
-    void renderCastBar(game::GameHandler& gameHandler, SpellIconFn getSpellIcon);
-    void renderCooldownTracker(game::GameHandler& gameHandler,
-                               const SettingsPanel& settings,
-                               SpellIconFn getSpellIcon);
-    void renderRaidWarningOverlay(game::GameHandler& gameHandler);
-    void renderCombatText(game::GameHandler& gameHandler);
-    void renderDPSMeter(game::GameHandler& gameHandler,
-                        const SettingsPanel& settings);
-    void renderBuffBar(game::GameHandler& gameHandler,
-                       SpellbookScreen& spellbookScreen,
-                       SpellIconFn getSpellIcon);
-    void renderBattlegroundScore(game::GameHandler& gameHandler);
-    void renderCombatLog(game::GameHandler& gameHandler,
-                         SpellbookScreen& spellbookScreen);
-    void renderThreatWindow(game::GameHandler& gameHandler);
-    void renderBgScoreboard(game::GameHandler& gameHandler);
-
-    // Section 3.5: UIServices injection (Phase B singleton breaking)
-    void setServices(const UIServices& services) { services_ = services; }
-
-private:
-    UIServices services_;
-};
-
-} // namespace ui
-} // namespace wowee
diff --git a/include/ui/dialog_manager.hpp b/include/ui/dialog_manager.hpp
deleted file mode 100644
index 9bd075ee..00000000
--- a/include/ui/dialog_manager.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#pragma once
-
-#include "ui/ui_services.hpp"
-#include <imgui.h>
-#include <string>
-#include <cstdint>
-
-namespace wowee {
-namespace game { class GameHandler; }
-namespace ui {
-
-class ChatPanel;
-class InventoryScreen;
-
-/**
- * Dialog / popup overlay manager
- *
- * Owns all yes/no popup rendering:
- *   group invite, duel request, duel countdown, loot roll, trade request,
- *   trade window, summon request, shared quest, item text, guild invite,
- *   ready check, BG invite, BF manager invite, LFG proposal, LFG role check,
- *   resurrect, talent wipe confirm, pet unlearn confirm.
- */
-class DialogManager {
-public:
-    DialogManager() = default;
-
-    /// Render "early" dialogs (group invite through LFG role check)
-    /// called in render() before guild roster / social frame
-    void renderDialogs(game::GameHandler& gameHandler,
-                       InventoryScreen& inventoryScreen,
-                       ChatPanel& chatPanel);
-
-    /// Render "late" dialogs (resurrect, talent wipe, pet unlearn)
-    /// called in render() after reclaim corpse button
-    void renderLateDialogs(game::GameHandler& gameHandler);
-
-    // Section 3.5: UIServices injection (Phase B singleton breaking)
-    void setServices(const UIServices& services) { services_ = services; }
-
-private:
-    // Section 3.5: Injected UI services
-    UIServices services_;
-    // Common ImGui window flags for popup dialogs
-    static constexpr ImGuiWindowFlags kDialogFlags =
-        ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize;
-
-    // ---- LFG role state ----
-    uint8_t lfgRoles_ = 0x08;  // default: DPS (0x02=tank, 0x04=healer, 0x08=dps)
-
-    // ---- Individual dialog renderers ----
-    void renderGroupInvitePopup(game::GameHandler& gameHandler);
-    void renderDuelRequestPopup(game::GameHandler& gameHandler);
-    void renderDuelCountdown(game::GameHandler& gameHandler);
-    void renderItemTextWindow(game::GameHandler& gameHandler);
-    void renderSharedQuestPopup(game::GameHandler& gameHandler);
-    void renderSummonRequestPopup(game::GameHandler& gameHandler);
-    void renderTradeRequestPopup(game::GameHandler& gameHandler);
-    void renderTradeWindow(game::GameHandler& gameHandler,
-                           InventoryScreen& inventoryScreen,
-                           ChatPanel& chatPanel);
-    void renderLootRollPopup(game::GameHandler& gameHandler,
-                             InventoryScreen& inventoryScreen,
-                             ChatPanel& chatPanel);
-    void renderGuildInvitePopup(game::GameHandler& gameHandler);
-    void renderReadyCheckPopup(game::GameHandler& gameHandler);
-    void renderBgInvitePopup(game::GameHandler& gameHandler);
-    void renderBfMgrInvitePopup(game::GameHandler& gameHandler);
-    void renderLfgProposalPopup(game::GameHandler& gameHandler);
-    void renderLfgRoleCheckPopup(game::GameHandler& gameHandler);
-    void renderResurrectDialog(game::GameHandler& gameHandler);
-    void renderTalentWipeConfirmDialog(game::GameHandler& gameHandler);
-    void renderPetUnlearnConfirmDialog(game::GameHandler& gameHandler);
-};
-
-} // namespace ui
-} // namespace wowee
diff --git a/include/ui/game_screen.hpp b/include/ui/game_screen.hpp
index f35bd679..49d429b6 100644
--- a/include/ui/game_screen.hpp
+++ b/include/ui/game_screen.hpp
@@ -8,25 +8,13 @@
 #include "ui/quest_log_screen.hpp"
 #include "ui/spellbook_screen.hpp"
 #include "ui/talent_screen.hpp"
-#include "ui/keybinding_manager.hpp"
-#include "ui/chat_panel.hpp"
-#include "ui/toast_manager.hpp"
-#include "ui/dialog_manager.hpp"
-#include "ui/settings_panel.hpp"
-#include "ui/combat_ui.hpp"
-#include "ui/social_panel.hpp"
-#include "ui/action_bar_panel.hpp"
-#include "ui/window_manager.hpp"
-#include "ui/ui_services.hpp"
 #include <vulkan/vulkan.h>
 #include <imgui.h>
 #include <string>
 #include <unordered_map>
 
 namespace wowee {
-namespace core { class AppearanceComposer; }
 namespace pipeline { class AssetManager; }
-namespace rendering { class Renderer; }
 namespace ui {
 
 /**
@@ -47,72 +35,112 @@ public:
     /**
      * Check if chat input is active
      */
-    bool isChatInputActive() const { return chatPanel_.isChatInputActive(); }
+    bool isChatInputActive() const { return chatInputActive; }
 
     void saveSettings();
     void loadSettings();
 
-    // Dependency injection for extracted classes (Phase A singleton breaking)
-    void setAppearanceComposer(core::AppearanceComposer* ac) { appearanceComposer_ = ac; }
-
-    // Section 3.5: UIServices injection (Phase B singleton breaking)
-    void setServices(const UIServices& services);
-
 private:
-    // Injected UI services (Section 3.5 Phase B - replaces getInstance() calls)
-    UIServices services_;
-    // Legacy pointer for Phase A compatibility (will be removed when all callsites migrate)
-    core::AppearanceComposer* appearanceComposer_ = nullptr;
-    // Chat panel (extracted from GameScreen — owns all chat state and rendering)
-    ChatPanel chatPanel_;
+    // Chat state
+    char chatInputBuffer[512] = "";
+    char whisperTargetBuffer[256] = "";
+    bool chatInputActive = false;
+    int selectedChatType = 0;  // 0=SAY, 1=YELL, 2=PARTY, 3=GUILD, 4=WHISPER
+    int lastChatType = 0;  // Track chat type changes
+    bool chatInputMoveCursorToEnd = false;
 
-    // Toast manager (extracted from GameScreen — owns all toast/notification state and rendering)
-    ToastManager toastManager_;
-
-    // Dialog manager (extracted from GameScreen — owns all popup/dialog rendering)
-    DialogManager dialogManager_;
-
-    // Settings panel (extracted from GameScreen — owns all settings UI and config state)
-    SettingsPanel settingsPanel_;
-
-    // Combat UI (extracted from GameScreen — owns all combat overlay rendering)
-    CombatUI combatUI_;
-
-    // Social panel (extracted from GameScreen — owns all social/group UI rendering)
-    SocialPanel socialPanel_;
-
-    // Action bar panel (extracted from GameScreen — owns action/stance/bag/xp/rep bars)
-    ActionBarPanel actionBarPanel_;
-
-    // Window manager (extracted from GameScreen — owns NPC windows, popups, overlays)
-    WindowManager windowManager_;
+    // Chat tabs
+    int activeChatTab_ = 0;
+    struct ChatTab {
+        std::string name;
+        uint32_t typeMask;  // bitmask of ChatType values to show
+    };
+    std::vector<ChatTab> chatTabs_;
+    void initChatTabs();
+    bool shouldShowMessage(const game::MessageChatData& msg, int tabIndex) const;
 
     // UI state
     bool showEntityWindow = false;
     bool showChatWindow = true;
-    bool showMinimap_ = true;  // M key toggles minimap
-    bool showNameplates_ = true;  // V key toggles enemy/NPC nameplates
-    uint64_t nameplateCtxGuid_ = 0; // GUID of nameplate right-clicked (0 = none)
-    ImVec2 nameplateCtxPos_{};      // Screen position of nameplate right-click
-    uint32_t lastPlayerHp_ = 0;   // Previous frame HP for damage flash detection
-    float damageFlashAlpha_ = 0.0f; // Screen edge flash intensity (fades to 0)
-
-
-    // UIErrorsFrame: WoW-style center-bottom error messages (spell fails, out of range, etc.)
-    struct UIErrorEntry { std::string text; float age = 0.0f; };
-    std::vector<UIErrorEntry> uiErrors_;
-    bool uiErrorCallbackSet_ = false;
-    static constexpr float kUIErrorLifetime = 2.5f;
-    bool castFailedCallbackSet_ = false;
-
+    bool showNameplates_ = true;  // V key toggles nameplates
     bool showPlayerInfo = false;
-    bool showWorldMap_ = false;  // W key toggles world map
-    ImVec2 questTrackerPos_ = ImVec2(-1.0f, -1.0f);  // <0 = use default
-    ImVec2 questTrackerSize_ = ImVec2(220.0f, 200.0f); // saved size
-    float questTrackerRightOffset_ = -1.0f;            // pixels from right edge; <0 = use default
-    bool questTrackerPosInit_ = false;
+    bool showGuildRoster_ = false;
+    std::string selectedGuildMember_;
+    bool showGuildNoteEdit_ = false;
+    bool editingOfficerNote_ = false;
+    char guildNoteEditBuffer_[256] = {0};
+    int guildRosterTab_ = 0;  // 0=Roster, 1=Guild Info
+    char guildMotdEditBuffer_[256] = {0};
+    bool showMotdEdit_ = false;
+    char petitionNameBuffer_[64] = {0};
+    char addRankNameBuffer_[64] = {0};
+    bool showAddRankModal_ = false;
+    bool refocusChatInput = false;
+    bool vendorBagsOpened_ = false;  // Track if bags were auto-opened for current vendor session
+    bool chatWindowLocked = true;
+    ImVec2 chatWindowPos_ = ImVec2(0.0f, 0.0f);
+    bool chatWindowPosInit_ = false;
+    bool showEscapeMenu = false;
+    bool showEscapeSettingsNotice = false;
+    bool showSettingsWindow = false;
+    bool settingsInit = false;
+    bool pendingFullscreen = false;
+    bool pendingVsync = false;
+    int pendingResIndex = 0;
+    bool pendingShadows = true;
+    float pendingShadowDistance = 300.0f;
+    bool pendingWaterRefraction = false;
+    int pendingMasterVolume = 100;
+    int pendingMusicVolume = 30;
+    int pendingAmbientVolume = 100;
+    int pendingUiVolume = 100;
+    int pendingCombatVolume = 100;
+    int pendingSpellVolume = 100;
+    int pendingMovementVolume = 100;
+    int pendingFootstepVolume = 100;
+    int pendingNpcVoiceVolume = 100;
+    int pendingMountVolume = 100;
+    int pendingActivityVolume = 100;
+    float pendingMouseSensitivity = 0.2f;
+    bool pendingInvertMouse = false;
+    bool pendingExtendedZoom = false;
+    int pendingUiOpacity = 65;
+    bool pendingMinimapRotate = false;
+    bool pendingMinimapSquare = false;
+    bool pendingMinimapNpcDots = false;
+    bool pendingSeparateBags = true;
+    bool pendingAutoLoot = false;
+    bool pendingUseOriginalSoundtrack = true;
+    int pendingGroundClutterDensity = 100;
+    int pendingAntiAliasing = 0;  // 0=Off, 1=2x, 2=4x, 3=8x
+    bool pendingNormalMapping = true;   // on by default
+    float pendingNormalMapStrength = 0.8f;  // 0.0-2.0
+    bool pendingPOM = true;             // on by default
+    int pendingPOMQuality = 1;          // 0=Low(16), 1=Medium(32), 2=High(64)
+    bool pendingFSR = false;
+    int pendingUpscalingMode = 0;       // 0=Off, 1=FSR1, 2=FSR3
+    int pendingFSRQuality = 3;          // 0=UltraQuality, 1=Quality, 2=Balanced, 3=Native(100%)
+    float pendingFSRSharpness = 1.6f;
+    float pendingFSR2JitterSign = 0.38f;
+    float pendingFSR2MotionVecScaleX = 1.0f;
+    float pendingFSR2MotionVecScaleY = 1.0f;
+    bool pendingAMDFramegen = false;
+    bool fsrSettingsApplied_ = false;
 
+    // UI element transparency (0.0 = fully transparent, 1.0 = fully opaque)
+    float uiOpacity_ = 0.65f;
+    bool minimapRotate_ = false;
+    bool minimapSquare_ = false;
+    bool minimapNpcDots_ = false;
+    bool minimapSettingsApplied_ = false;
+    bool volumeSettingsApplied_ = false;  // True once saved volume settings applied to audio managers
+    bool msaaSettingsApplied_ = false;   // True once saved MSAA setting applied to renderer
+    bool waterRefractionApplied_ = false;
+    bool normalMapSettingsApplied_ = false;  // True once saved normal map/POM settings applied
 
+    // Mute state: mute bypasses master volume without touching slider values
+    bool soundMuted_ = false;
+    float preMuteVolume_ = 1.0f;  // AudioEngine master volume before muting
 
     /**
      * Render player info window
@@ -124,6 +152,26 @@ private:
      */
     void renderEntityList(game::GameHandler& gameHandler);
 
+    /**
+     * Render chat window
+     */
+    void renderChatWindow(game::GameHandler& gameHandler);
+
+    /**
+     * Send chat message
+     */
+    void sendChatMessage(game::GameHandler& gameHandler);
+
+    /**
+     * Get chat type name
+     */
+    const char* getChatTypeName(game::ChatType type) const;
+
+    /**
+     * Get chat type color
+     */
+    ImVec4 getChatTypeColor(game::ChatType type) const;
+
     /**
      * Render player unit frame (top-left)
      */
@@ -133,13 +181,11 @@ private:
      * Render target frame
      */
     void renderTargetFrame(game::GameHandler& gameHandler);
-    void renderFocusFrame(game::GameHandler& gameHandler);
 
     /**
      * Render pet frame (below player frame when player has an active pet)
      */
     void renderPetFrame(game::GameHandler& gameHandler);
-    void renderTotemFrame(game::GameHandler& gameHandler);
 
     /**
      * Process targeting input (Tab, Escape, click)
@@ -156,15 +202,50 @@ private:
      */
     void updateCharacterTextures(game::Inventory& inventory);
 
-
+    // ---- New UI renders ----
+    void renderActionBar(game::GameHandler& gameHandler);
+    void renderBagBar(game::GameHandler& gameHandler);
+    void renderXpBar(game::GameHandler& gameHandler);
+    void renderCastBar(game::GameHandler& gameHandler);
     void renderMirrorTimers(game::GameHandler& gameHandler);
-    void renderUIErrors(game::GameHandler& gameHandler, float deltaTime);
+    void renderCombatText(game::GameHandler& gameHandler);
+    void renderPartyFrames(game::GameHandler& gameHandler);
+    void renderBossFrames(game::GameHandler& gameHandler);
+    void renderGroupInvitePopup(game::GameHandler& gameHandler);
+    void renderDuelRequestPopup(game::GameHandler& gameHandler);
+    void renderLootRollPopup(game::GameHandler& gameHandler);
+    void renderTradeRequestPopup(game::GameHandler& gameHandler);
+    void renderSummonRequestPopup(game::GameHandler& gameHandler);
+    void renderSharedQuestPopup(game::GameHandler& gameHandler);
+    void renderItemTextWindow(game::GameHandler& gameHandler);
+    void renderBuffBar(game::GameHandler& gameHandler);
+    void renderLootWindow(game::GameHandler& gameHandler);
+    void renderGossipWindow(game::GameHandler& gameHandler);
+    void renderQuestDetailsWindow(game::GameHandler& gameHandler);
+    void renderQuestRequestItemsWindow(game::GameHandler& gameHandler);
+    void renderQuestOfferRewardWindow(game::GameHandler& gameHandler);
+    void renderVendorWindow(game::GameHandler& gameHandler);
+    void renderTrainerWindow(game::GameHandler& gameHandler);
+    void renderTaxiWindow(game::GameHandler& gameHandler);
+    void renderDeathScreen(game::GameHandler& gameHandler);
+    void renderResurrectDialog(game::GameHandler& gameHandler);
+    void renderEscapeMenu();
+    void renderSettingsWindow();
     void renderQuestMarkers(game::GameHandler& gameHandler);
     void renderMinimapMarkers(game::GameHandler& gameHandler);
     void renderQuestObjectiveTracker(game::GameHandler& gameHandler);
+    void renderGuildRoster(game::GameHandler& gameHandler);
+    void renderGuildInvitePopup(game::GameHandler& gameHandler);
+    void renderReadyCheckPopup(game::GameHandler& gameHandler);
+    void renderChatBubbles(game::GameHandler& gameHandler);
+    void renderMailWindow(game::GameHandler& gameHandler);
+    void renderMailComposeWindow(game::GameHandler& gameHandler);
+    void renderBankWindow(game::GameHandler& gameHandler);
+    void renderGuildBankWindow(game::GameHandler& gameHandler);
+    void renderAuctionHouseWindow(game::GameHandler& gameHandler);
+    void renderDungeonFinderWindow(game::GameHandler& gameHandler);
+    void renderInstanceLockouts(game::GameHandler& gameHandler);
     void renderNameplates(game::GameHandler& gameHandler);
-    void renderDurabilityWarning(game::GameHandler& gameHandler);
-    void takeScreenshot(game::GameHandler& gameHandler);
 
     /**
      * Inventory screen
@@ -190,26 +271,101 @@ private:
     // Death Knight rune bar: client-predicted fill (0.0=depleted, 1.0=ready) for smooth animation
     float runeClientFill_[6] = {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f};
 
-    // Pet rename modal (triggered from pet frame context menu)
-    bool petRenameOpen_ = false;
-    char petRenameBuf_[16] = {};
+    // Action bar drag state (-1 = not dragging)
+    int actionBarDragSlot_ = -1;
+    VkDescriptorSet actionBarDragIcon_ = VK_NULL_HANDLE;
+
+    // Bag bar state
+    VkDescriptorSet backpackIconTexture_ = VK_NULL_HANDLE;
+    VkDescriptorSet emptyBagSlotTexture_ = VK_NULL_HANDLE;
+    int bagBarPickedSlot_ = -1;   // Visual drag in progress (-1 = none)
+    int bagBarDragSource_ = -1;   // Mouse pressed on this slot, waiting for drag or click (-1 = none)
+
+    // Instance Lockouts window
+    bool  showInstanceLockouts_ = false;
+
+    // Dungeon Finder state
+    bool  showDungeonFinder_ = false;
+    uint8_t lfgRoles_ = 0x08;  // default: DPS (0x02=tank, 0x04=healer, 0x08=dps)
+    uint32_t lfgSelectedDungeon_ = 861;  // default: random dungeon (entry 861 = Random Dungeon WotLK)
+
+    // Chat settings
+    bool chatShowTimestamps_ = false;
+    int chatFontSize_ = 1;  // 0=small, 1=medium, 2=large
+    bool chatAutoJoinGeneral_ = true;
+    bool chatAutoJoinTrade_ = true;
+    bool chatAutoJoinLocalDefense_ = true;
+    bool chatAutoJoinLFG_ = true;
+    bool chatAutoJoinLocal_ = true;
+
+    // Join channel input buffer
+    char joinChannelBuffer_[128] = "";
+
+    static std::string getSettingsPath();
+
+    // Gender placeholder replacement
+    std::string replaceGenderPlaceholders(const std::string& text, game::GameHandler& gameHandler);
+
+    // Chat bubbles
+    struct ChatBubble {
+        uint64_t senderGuid = 0;
+        std::string message;
+        float timeRemaining = 0.0f;
+        float totalDuration = 0.0f;
+        bool isYell = false;
+    };
+    std::vector<ChatBubble> chatBubbles_;
+    bool chatBubbleCallbackSet_ = false;
+
+    // Mail compose state
+    char mailRecipientBuffer_[256] = "";
+    char mailSubjectBuffer_[256] = "";
+    char mailBodyBuffer_[2048] = "";
+    int mailComposeMoney_[3] = {0, 0, 0};  // gold, silver, copper
+
+    // Auction house UI state
+    char auctionSearchName_[256] = "";
+    int auctionLevelMin_ = 0;
+    int auctionLevelMax_ = 0;
+    int auctionQuality_ = 0;
+    int auctionSellDuration_ = 2;  // 0=12h, 1=24h, 2=48h
+    int auctionSellBid_[3] = {0, 0, 0};     // gold, silver, copper
+    int auctionSellBuyout_[3] = {0, 0, 0};  // gold, silver, copper
+    int auctionSelectedItem_ = -1;
+    int auctionSellSlotIndex_ = -1;          // Selected backpack slot for selling
+    uint32_t auctionBrowseOffset_ = 0;       // Pagination offset for browse results
+    int auctionItemClass_ = -1;              // Item class filter (-1 = All)
+    int auctionItemSubClass_ = -1;           // Item subclass filter (-1 = All)
+
+    // Guild bank money input
+    int guildBankMoneyInput_[3] = {0, 0, 0};  // gold, silver, copper
 
     // Left-click targeting: distinguish click from camera drag
     glm::vec2 leftClickPressPos_ = glm::vec2(0.0f);
     bool leftClickWasPress_ = false;
 
+    // Level-up ding animation
+    static constexpr float DING_DURATION = 3.0f;
+    float dingTimer_ = 0.0f;
+    uint32_t dingLevel_ = 0;
+    void renderDingEffect();
 
-    bool appearanceCallbackSet_ = false;
-    bool ghostOpacityStateKnown_ = false;
-    bool ghostOpacityLastState_ = false;
-    uint32_t ghostOpacityLastInstanceId_ = 0;
+    // Achievement toast banner
+    static constexpr float ACHIEVEMENT_TOAST_DURATION = 5.0f;
+    float achievementToastTimer_ = 0.0f;
+    uint32_t achievementToastId_ = 0;
+    void renderAchievementToast();
 
-
-    void renderWeatherOverlay(game::GameHandler& gameHandler);
+    // Zone discovery text ("Entering: <ZoneName>")
+    static constexpr float ZONE_TEXT_DURATION = 5.0f;
+    float zoneTextTimer_ = 0.0f;
+    std::string zoneTextName_;
+    std::string lastKnownZoneName_;
+    void renderZoneText();
 
 public:
-    void openDungeonFinder() { socialPanel_.showDungeonFinder_ = true; }
-    ToastManager& toastManager() { return toastManager_; }
+    void triggerDing(uint32_t newLevel);
+    void triggerAchievementToast(uint32_t achievementId);
 };
 
 } // namespace ui
diff --git a/include/ui/inventory_screen.hpp b/include/ui/inventory_screen.hpp
index 3e81f1cb..a0a19386 100644
--- a/include/ui/inventory_screen.hpp
+++ b/include/ui/inventory_screen.hpp
@@ -6,7 +6,6 @@
 #include <vulkan/vulkan.h>
 #include <imgui.h>
 #include <array>
-#include <deque>
 #include <functional>
 #include <memory>
 #include <unordered_map>
@@ -40,8 +39,6 @@ public:
     bool isSeparateBags() const { return separateBags_; }
     void toggleCompactBags() { compactBags_ = !compactBags_; }
     bool isCompactBags() const { return compactBags_; }
-    void setShowKeyring(bool show) { showKeyring_ = show; }
-    bool isShowKeyring() const { return showKeyring_; }
     bool isBackpackOpen() const { return backpackOpen_; }
     bool isBagOpen(int idx) const { return idx >= 0 && idx < 4 ? bagOpen_[idx] : false; }
 
@@ -82,7 +79,6 @@ private:
     bool bKeyWasDown = false;
     bool separateBags_ = true;
     bool compactBags_ = false;
-    bool showKeyring_ = true;
     bool backpackOpen_ = false;
     std::array<bool, 4> bagOpen_{};
     bool cKeyWasDown = false;
@@ -100,7 +96,6 @@ private:
     std::unordered_map<uint32_t, VkDescriptorSet> iconCache_;
 public:
     VkDescriptorSet getItemIcon(uint32_t displayInfoId);
-    void renderItemTooltip(const game::ItemQueryResponseData& info, const game::Inventory* inventory = nullptr, uint64_t itemGuid = 0);
 private:
 
     // Character model preview
@@ -152,9 +147,7 @@ private:
                          int bagIndex, float defaultX, float defaultY, uint64_t moneyCopper);
     void renderEquipmentPanel(game::Inventory& inventory);
     void renderBackpackPanel(game::Inventory& inventory, bool collapseEmptySections = false);
-    void renderStatsPanel(game::Inventory& inventory, uint32_t playerLevel, int32_t serverArmor = 0,
-                          const int32_t* serverStats = nullptr, const int32_t* serverResists = nullptr,
-                          const game::GameHandler* gh = nullptr);
+    void renderStatsPanel(game::Inventory& inventory, uint32_t playerLevel, int32_t serverArmor = 0);
     void renderReputationPanel(game::GameHandler& gameHandler);
 
     void renderItemSlot(game::Inventory& inventory, const game::ItemSlot& slot,
@@ -162,8 +155,7 @@ private:
                         SlotKind kind, int backpackIndex,
                         game::EquipSlot equipSlot,
                         int bagIndex = -1, int bagSlotIndex = -1);
-    void renderItemTooltip(const game::ItemDef& item, const game::Inventory* inventory = nullptr, uint64_t itemGuid = 0);
-    const std::unordered_map<uint32_t, std::string>& getEnchantmentNames();
+    void renderItemTooltip(const game::ItemDef& item, const game::Inventory* inventory = nullptr);
 
     // Held item helpers
     void pickupFromBackpack(game::Inventory& inv, int index);
@@ -177,32 +169,11 @@ private:
     void renderHeldItem();
     bool bagHasAnyItems(const game::Inventory& inventory, int bagIndex) const;
 
-    // Drop confirmation (drag-outside-window destroy)
+    // Drop confirmation
     bool dropConfirmOpen_ = false;
     int dropBackpackIndex_ = -1;
     std::string dropItemName_;
 
-    // Destroy confirmation (Shift+right-click destroy)
-    bool destroyConfirmOpen_ = false;
-    uint8_t destroyBag_ = 0xFF;
-    uint8_t destroySlot_ = 0;
-    uint8_t destroyCount_ = 1;
-    std::string destroyItemName_;
-
-    // Stack split popup state
-    bool splitConfirmOpen_ = false;
-    uint8_t splitBag_ = 0xFF;
-    uint8_t splitSlot_ = 0;
-    int splitMax_ = 1;
-    int splitCount_ = 1;
-    std::string splitItemName_;
-
-    // Server-side bag sort swap queue (one swap per frame)
-    std::deque<game::Inventory::SwapOp> sortSwapQueue_;
-
-    // Pending chat item link from shift-click
-    std::string pendingChatItemLink_;
-
 public:
     static ImVec4 getQualityColor(game::ItemQuality quality);
 
@@ -217,13 +188,6 @@ public:
     /// Drop the currently held item into a specific equipment slot.
     /// Returns true if the drop was accepted and consumed.
     bool dropHeldItemToEquipSlot(game::Inventory& inv, game::EquipSlot slot);
-    /// Returns a WoW item link string if the user shift-clicked a bag item, then clears it.
-    std::string getAndClearPendingChatLink() {
-        std::string out = std::move(pendingChatItemLink_);
-        pendingChatItemLink_.clear();
-        return out;
-    }
-
     /// Drop the currently held item into a bank slot via CMSG_SWAP_ITEM.
     void dropIntoBankSlot(game::GameHandler& gh, uint8_t dstBag, uint8_t dstSlot);
     /// Pick up an item from main bank slot (click-and-hold from bank window).
diff --git a/include/ui/keybinding_manager.hpp b/include/ui/keybinding_manager.hpp
deleted file mode 100644
index 9a1320a9..00000000
--- a/include/ui/keybinding_manager.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#pragma once
-
-#include <imgui.h>
-#include <string>
-#include <unordered_map>
-#include <memory>
-
-namespace wowee::ui {
-
-/**
- * Manages keybinding configuration for in-game actions.
- * Supports loading/saving from config files and runtime rebinding.
- */
-class KeybindingManager {
-public:
-    enum class Action {
-        TOGGLE_CHARACTER_SCREEN,
-        TOGGLE_INVENTORY,
-        TOGGLE_BAGS,
-        TOGGLE_SPELLBOOK,
-        TOGGLE_TALENTS,
-        TOGGLE_QUESTS,
-        TOGGLE_MINIMAP,
-        TOGGLE_SETTINGS,
-        TOGGLE_CHAT,
-        TOGGLE_GUILD_ROSTER,
-        TOGGLE_DUNGEON_FINDER,
-        TOGGLE_WORLD_MAP,
-        TOGGLE_NAMEPLATES,
-        TOGGLE_RAID_FRAMES,
-        TOGGLE_ACHIEVEMENTS,
-        TOGGLE_SKILLS,
-        ACTION_COUNT
-    };
-
-    static KeybindingManager& getInstance();
-
-    /**
-     * Check if an action's keybinding was just pressed.
-     * Uses ImGui::IsKeyPressed() internally with the bound key.
-     */
-    bool isActionPressed(Action action, bool repeat = false);
-
-    /**
-     * Get the currently bound key for an action.
-     */
-    ImGuiKey getKeyForAction(Action action) const;
-
-    /**
-     * Rebind an action to a different key.
-     */
-    void setKeyForAction(Action action, ImGuiKey key);
-
-    /**
-     * Reset all keybindings to defaults.
-     */
-    void resetToDefaults();
-
-    /**
-     * Load keybindings from config file.
-     */
-    void loadFromConfigFile(const std::string& filePath);
-
-    /**
-     * Save keybindings to config file.
-     */
-    void saveToConfigFile(const std::string& filePath) const;
-
-    /**
-     * Get human-readable name for an action.
-     */
-    static const char* getActionName(Action action);
-
-    /**
-     * Get all actions for iteration.
-     */
-    static constexpr int getActionCount() { return static_cast<int>(Action::ACTION_COUNT); }
-
-private:
-    KeybindingManager();
-
-    std::unordered_map<int, ImGuiKey> bindings_;  // action -> key
-
-    void initializeDefaults();
-};
-
-}  // namespace wowee::ui
diff --git a/include/ui/quest_log_screen.hpp b/include/ui/quest_log_screen.hpp
index 0bb791e0..7e289e92 100644
--- a/include/ui/quest_log_screen.hpp
+++ b/include/ui/quest_log_screen.hpp
@@ -7,34 +7,20 @@
 
 namespace wowee { namespace ui {
 
-class InventoryScreen;
-
 class QuestLogScreen {
 public:
-    void render(game::GameHandler& gameHandler, InventoryScreen& invScreen);
+    void render(game::GameHandler& gameHandler);
     bool isOpen() const { return open; }
     void toggle() { open = !open; }
     void setOpen(bool o) { open = o; }
-    // Open the log and scroll to the given quest (by questId)
-    void openAndSelectQuest(uint32_t questId) {
-        open = true;
-        pendingSelectQuestId_ = questId;
-        scrollToSelected_ = true;
-    }
 
 private:
     bool open = false;
     bool lKeyWasDown = false;
     int selectedIndex = -1;
-    uint32_t pendingSelectQuestId_ = 0;  // non-zero: select this quest on next render
-    bool scrollToSelected_ = false;       // true: call SetScrollHereY once after selection
     uint32_t lastDetailRequestQuestId_ = 0;
     double lastDetailRequestAt_ = 0.0;
     std::unordered_set<uint32_t> questDetailQueryNoResponse_;
-    // Search / filter
-    char questSearchFilter_[64] = {};
-    // 0=all, 1=active only, 2=complete only
-    int questFilterMode_ = 0;
 };
 
 }} // namespace wowee::ui
diff --git a/include/ui/settings_panel.hpp b/include/ui/settings_panel.hpp
deleted file mode 100644
index a024ffad..00000000
--- a/include/ui/settings_panel.hpp
+++ /dev/null
@@ -1,176 +0,0 @@
-#pragma once
-
-#include "ui/ui_services.hpp"
-#include <vulkan/vulkan.h>
-#include <string>
-#include <functional>
-#include <cstdint>
-
-namespace wowee {
-namespace rendering { class Renderer; }
-namespace audio { class AudioCoordinator; }
-namespace ui {
-
-class InventoryScreen;
-class ChatPanel;
-
-/**
- * Settings panel (extracted from GameScreen)
- *
- * Owns all settings UI rendering, settings state variables, and
- * graphics preset logic.  Save/load remains in GameScreen since
- * it serialises cross-cutting state (chat, quest tracker, etc.).
- */
-class SettingsPanel {
-public:
-    // ---- Settings UI visibility flags (written by EscapeMenu / Escape key) ----
-    bool showEscapeSettingsNotice = false;
-    bool showSettingsWindow = false;
-    bool settingsInit = false;
-
-    // ---- Pending video / graphics settings ----
-    bool pendingFullscreen = false;
-    bool pendingVsync = false;
-    int pendingResIndex = 0;
-    bool pendingShadows = true;
-    float pendingShadowDistance = 300.0f;
-    bool pendingWaterRefraction = true;
-    int pendingBrightness = 50; // 0-100, maps to 0.0-2.0 (50 = 1.0 default)
-
-    // ---- Pending audio settings ----
-    int pendingMasterVolume = 100;
-    int pendingMusicVolume = 30;
-    int pendingAmbientVolume = 100;
-    int pendingUiVolume = 100;
-    int pendingCombatVolume = 100;
-    int pendingSpellVolume = 100;
-    int pendingMovementVolume = 100;
-    int pendingFootstepVolume = 100;
-    int pendingNpcVoiceVolume = 100;
-    int pendingMountVolume = 100;
-    int pendingActivityVolume = 100;
-
-    // ---- Pending camera / controls ----
-    float pendingMouseSensitivity = 0.2f;
-    bool pendingInvertMouse = false;
-    bool pendingExtendedZoom = false;
-    float pendingCameraStiffness = 30.0f;  // Camera smooth speed (higher = tighter, less sway)
-    float pendingPivotHeight = 1.6f;       // Camera pivot height above feet (lower = less detached feel)
-    float pendingFov = 70.0f;  // degrees, default matches WoW's ~70° horizontal FOV
-
-    // ---- Pending UI / interface ----
-    int pendingUiOpacity = 65;
-    bool pendingMinimapRotate = false;
-    bool pendingMinimapSquare = false;
-    bool pendingMinimapNpcDots = false;
-    bool pendingShowLatencyMeter = true;
-    bool pendingSeparateBags = true;
-    bool pendingShowKeyring = true;
-
-    // ---- Pending gameplay ----
-    bool pendingAutoLoot = false;
-    bool pendingAutoSellGrey = false;
-    bool pendingAutoRepair = false;
-
-    // ---- Pending soundtrack ----
-    bool pendingUseOriginalSoundtrack = true;
-
-    // ---- Pending action bar layout ----
-    bool pendingShowActionBar2 = true;   // Show second action bar above main bar
-    float pendingActionBarScale = 1.0f;  // Multiplier for action bar slot size (0.5–1.5)
-    float pendingActionBar2OffsetX = 0.0f;  // Horizontal offset from default center position
-    float pendingActionBar2OffsetY = 0.0f;  // Vertical offset from default (above bar 1)
-    bool pendingShowRightBar = false;   // Right-edge vertical action bar (bar 3, slots 24-35)
-    bool pendingShowLeftBar  = false;   // Left-edge vertical action bar (bar 4, slots 36-47)
-    float pendingRightBarOffsetY = 0.0f;  // Vertical offset from screen center
-    float pendingLeftBarOffsetY  = 0.0f;  // Vertical offset from screen center
-
-    // ---- Pending graphics quality ----
-    int pendingGroundClutterDensity = 100;
-    int pendingAntiAliasing = 0;  // 0=Off, 1=2x, 2=4x, 3=8x
-    bool pendingFXAA = false;     // FXAA post-process (combinable with MSAA)
-    bool pendingNormalMapping = true;   // on by default
-    float pendingNormalMapStrength = 0.8f;  // 0.0-2.0
-    bool pendingPOM = true;             // on by default
-    int pendingPOMQuality = 1;          // 0=Low(16), 1=Medium(32), 2=High(64)
-    bool pendingFSR = false;
-    int pendingUpscalingMode = 0;       // 0=Off, 1=FSR1, 2=FSR3
-    int pendingFSRQuality = 3;          // 0=UltraQuality, 1=Quality, 2=Balanced, 3=Native(100%)
-    float pendingFSRSharpness = 1.6f;
-    float pendingFSR2JitterSign = 0.38f;
-    float pendingFSR2MotionVecScaleX = 1.0f;
-    float pendingFSR2MotionVecScaleY = 1.0f;
-    bool pendingAMDFramegen = false;
-
-    // ---- Graphics quality presets ----
-    enum class GraphicsPreset : int {
-        CUSTOM = 0,
-        LOW = 1,
-        MEDIUM = 2,
-        HIGH = 3,
-        ULTRA = 4
-    };
-    GraphicsPreset currentGraphicsPreset = GraphicsPreset::CUSTOM;
-    GraphicsPreset pendingGraphicsPreset = GraphicsPreset::CUSTOM;
-
-    // ---- Applied-once flags (used by GameScreen::render() one-time-apply blocks) ----
-    bool fsrSettingsApplied_ = false;
-    float uiOpacity_ = 0.65f;  // UI element transparency (0.0 = fully transparent, 1.0 = fully opaque)
-    bool minimapRotate_ = false;
-    bool minimapSquare_ = false;
-    bool minimapNpcDots_ = false;
-    bool showLatencyMeter_ = true;           // Show server latency indicator
-    bool minimapSettingsApplied_ = false;
-    bool volumeSettingsApplied_ = false;  // True once saved volume settings applied to audio managers
-    bool msaaSettingsApplied_ = false;   // True once saved MSAA setting applied to renderer
-    bool fxaaSettingsApplied_ = false;   // True once saved FXAA setting applied to renderer
-    bool waterRefractionApplied_ = false;
-    bool normalMapSettingsApplied_ = false;  // True once saved normal map/POM settings applied
-
-    // ---- Mute state: mute bypasses master volume without touching slider values ----
-    bool soundMuted_ = false;
-    float preMuteVolume_ = 1.0f;  // AudioEngine master volume before muting
-
-    // ---- Config toggles (read by GameScreen rendering, edited by Interface tab) ----
-    float nameplateScale_ = 1.0f; // Scale multiplier for nameplate bar dimensions
-    bool showFriendlyNameplates_ = true;  // Shift+V toggles friendly player nameplates
-    bool showDPSMeter_ = false;
-    bool showCooldownTracker_ = false;
-    bool damageFlashEnabled_ = true;
-    bool lowHealthVignetteEnabled_ = true; // Persistent pulsing red vignette below 20% HP
-
-    // ---- Public methods ----
-
-    /// Render the settings window (call from GameScreen::render)
-    void renderSettingsWindow(InventoryScreen& inventoryScreen, ChatPanel& chatPanel,
-                              std::function<void()> saveCallback);
-
-    /// Apply audio volume levels to all audio coordinator sound managers
-    void applyAudioVolumes(audio::AudioCoordinator* ac);
-
-    /// Return the platform-specific settings file path
-    static std::string getSettingsPath();
-
-    /// Set services (dependency injection)
-    void setServices(const UIServices& services) { services_ = services; }
-
-private:
-    UIServices services_;  // Injected service references
-
-    // Keybinding customization (private — only used in Controls tab)
-    int pendingRebindAction_ = -1;  // -1 = not rebinding, otherwise action index
-    bool awaitingKeyPress_ = false;
-
-    // Settings tab rendering
-    void renderSettingsInterfaceTab(std::function<void()> saveCallback);
-    void renderSettingsGameplayTab(InventoryScreen& inventoryScreen,
-                                   std::function<void()> saveCallback);
-    void renderSettingsControlsTab(std::function<void()> saveCallback);
-    void renderSettingsAudioTab(std::function<void()> saveCallback);
-    void renderSettingsAboutTab();
-    void applyGraphicsPreset(GraphicsPreset preset);
-    void updateGraphicsPresetFromCurrentSettings();
-};
-
-} // namespace ui
-} // namespace wowee
diff --git a/include/ui/social_panel.hpp b/include/ui/social_panel.hpp
deleted file mode 100644
index 1eed9a93..00000000
--- a/include/ui/social_panel.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-#pragma once
-
-#include "ui/ui_services.hpp"
-#include <imgui.h>
-#include <vulkan/vulkan.h>
-#include <string>
-#include <vector>
-#include <cstdint>
-#include <functional>
-
-namespace wowee {
-namespace game { class GameHandler; }
-namespace pipeline { class AssetManager; }
-namespace ui {
-
-class ChatPanel;
-class SpellbookScreen;
-class InventoryScreen;
-
-/**
- * Social panel manager (extracted from GameScreen)
- *
- * Owns all social/group-related rendering:
- *   party frames, boss frames, guild roster, social/friends frame,
- *   dungeon finder, who window, inspect window.
- */
-class SocialPanel {
-public:
-    SocialPanel() = default;
-
-    // ---- Callback type for spell icon lookup (stays in GameScreen) ----
-    using SpellIconFn = std::function<VkDescriptorSet(uint32_t spellId, pipeline::AssetManager*)>;
-
-    // ---- Toggle booleans (written by slash commands / escape handler / keybinds / UI buttons) ----
-    bool showSocialFrame_ = false;   // O key toggles social/friends list
-    bool showGuildRoster_ = false;
-    bool showRaidFrames_ = true;     // F key toggles raid/party frames
-    bool showWhoWindow_ = false;
-    bool showDungeonFinder_ = false;
-    bool showInspectWindow_ = false;
-
-    // ---- Guild roster state ----
-    std::string selectedGuildMember_;
-    bool showGuildNoteEdit_ = false;
-    bool editingOfficerNote_ = false;
-    char guildNoteEditBuffer_[256] = {0};
-    int guildRosterTab_ = 0;         // 0=Roster, 1=Guild Info
-    char guildMotdEditBuffer_[256] = {0};
-    bool showMotdEdit_ = false;
-    char petitionNameBuffer_[64] = {0};
-    char addRankNameBuffer_[64] = {0};
-    bool showAddRankModal_ = false;
-
-    // ---- LFG state ----
-    uint8_t lfgRoles_ = 0x08;           // default: DPS (0x02=tank, 0x04=healer, 0x08=dps)
-    uint32_t lfgSelectedDungeon_ = 861;  // default: random dungeon (entry 861)
-
-    // ---- Public render methods ----
-    void renderPartyFrames(game::GameHandler& gameHandler,
-                           ChatPanel& chatPanel,
-                           SpellIconFn getSpellIcon);
-    void renderBossFrames(game::GameHandler& gameHandler,
-                          SpellbookScreen& spellbookScreen,
-                          SpellIconFn getSpellIcon);
-    void renderGuildRoster(game::GameHandler& gameHandler,
-                           ChatPanel& chatPanel);
-    void renderSocialFrame(game::GameHandler& gameHandler,
-                           ChatPanel& chatPanel);
-    void renderDungeonFinderWindow(game::GameHandler& gameHandler,
-                                   ChatPanel& chatPanel);
-    void renderWhoWindow(game::GameHandler& gameHandler,
-                         ChatPanel& chatPanel);
-    void renderInspectWindow(game::GameHandler& gameHandler,
-                             InventoryScreen& inventoryScreen);
-
-    // Section 3.5: UIServices injection (Phase B singleton breaking)
-    void setServices(const UIServices& services) { services_ = services; }
-
-private:
-    UIServices services_;
-};
-
-} // namespace ui
-} // namespace wowee
diff --git a/include/ui/spellbook_screen.hpp b/include/ui/spellbook_screen.hpp
index 2bc0f866..a6944972 100644
--- a/include/ui/spellbook_screen.hpp
+++ b/include/ui/spellbook_screen.hpp
@@ -25,7 +25,6 @@ struct SpellInfo {
     uint32_t manaCost = 0;       // Mana cost
     uint32_t powerType = 0;      // 0=mana, 1=rage, 2=focus, 3=energy
     uint32_t rangeIndex = 0;     // Range index from SpellRange.dbc
-    uint32_t schoolMask = 0;     // School bitmask (1=phys,2=holy,4=fire,8=nature,16=frost,32=shadow,64=arcane)
     bool isPassive() const { return (attributes & 0x40) != 0; }
 };
 
@@ -44,33 +43,11 @@ public:
     // Spell name lookup — triggers DBC load if needed, used by action bar tooltips
     std::string lookupSpellName(uint32_t spellId, pipeline::AssetManager* assetManager);
 
-    // Rich tooltip — renders a full spell tooltip (inside an already-open BeginTooltip block).
-    // Triggers DBC load if needed. Returns true if spell data was found.
-    bool renderSpellInfoTooltip(uint32_t spellId, game::GameHandler& gameHandler,
-                                pipeline::AssetManager* assetManager);
-
     // Drag-and-drop state for action bar assignment
     bool isDraggingSpell() const { return draggingSpell_; }
     uint32_t getDragSpellId() const { return dragSpellId_; }
     void consumeDragSpell() { draggingSpell_ = false; dragSpellId_ = 0; dragSpellIconTex_ = VK_NULL_HANDLE; }
 
-    /// Returns the max range in yards for a spell (0 if self-cast, unknown, or melee).
-    /// Triggers DBC load if needed. Used by the action bar for out-of-range tinting.
-    uint32_t getSpellMaxRange(uint32_t spellId, pipeline::AssetManager* assetManager);
-
-    /// Returns the power cost and type for a spell (cost=0 if unknown/free).
-    /// powerType: 0=mana, 1=rage, 2=focus, 3=energy, 6=runic power.
-    /// Triggers DBC load if needed. Used by the action bar for insufficient-power tinting.
-    void getSpellPowerInfo(uint32_t spellId, pipeline::AssetManager* assetManager,
-                           uint32_t& outCost, uint32_t& outPowerType);
-
-    /// Returns a WoW spell link string if the user shift-clicked a spell, then clears it.
-    std::string getAndClearPendingChatLink() {
-        std::string out = std::move(pendingChatSpellLink_);
-        pendingChatSpellLink_.clear();
-        return out;
-    }
-
 private:
     bool open = false;
     bool pKeyWasDown = false;
@@ -104,9 +81,6 @@ private:
     uint32_t dragSpellId_ = 0;
     VkDescriptorSet dragSpellIconTex_ = VK_NULL_HANDLE;
 
-    // Pending chat spell link from shift-click
-    std::string pendingChatSpellLink_;
-
     void loadSpellDBC(pipeline::AssetManager* assetManager);
     void loadSpellIconDBC(pipeline::AssetManager* assetManager);
     void loadSkillLineDBCs(pipeline::AssetManager* assetManager);
@@ -114,8 +88,8 @@ private:
     VkDescriptorSet getSpellIcon(uint32_t iconId, pipeline::AssetManager* assetManager);
     const SpellInfo* getSpellInfo(uint32_t spellId) const;
 
-    // Tooltip rendering helper (showUsageHints=false when called from action bar)
-    void renderSpellTooltip(const SpellInfo* info, game::GameHandler& gameHandler, bool showUsageHints = true);
+    // Tooltip rendering helper
+    void renderSpellTooltip(const SpellInfo* info, game::GameHandler& gameHandler);
 };
 
 } // namespace ui
diff --git a/include/ui/talent_screen.hpp b/include/ui/talent_screen.hpp
index 82a674e4..18bbe152 100644
--- a/include/ui/talent_screen.hpp
+++ b/include/ui/talent_screen.hpp
@@ -28,8 +28,6 @@ private:
 
     void loadSpellDBC(pipeline::AssetManager* assetManager);
     void loadSpellIconDBC(pipeline::AssetManager* assetManager);
-    void loadGlyphPropertiesDBC(pipeline::AssetManager* assetManager);
-    void renderGlyphs(game::GameHandler& gameHandler);
     VkDescriptorSet getSpellIcon(uint32_t iconId, pipeline::AssetManager* assetManager);
 
     bool open = false;
@@ -38,22 +36,11 @@ private:
     // DBC caches
     bool spellDbcLoaded = false;
     bool iconDbcLoaded = false;
-    bool glyphDbcLoaded = false;
     std::unordered_map<uint32_t, uint32_t> spellIconIds;       // spellId -> iconId
     std::unordered_map<uint32_t, std::string> spellIconPaths;  // iconId -> path
     std::unordered_map<uint32_t, VkDescriptorSet> spellIconCache;  // iconId -> texture
     std::unordered_map<uint32_t, std::string> spellTooltips;   // spellId -> description
     std::unordered_map<uint32_t, VkDescriptorSet> bgTextureCache_;  // tabId -> bg texture
-
-    // Talent learn confirmation
-    bool talentConfirmOpen_ = false;
-    uint32_t pendingTalentId_ = 0;
-    uint32_t pendingTalentRank_ = 0;
-    std::string pendingTalentName_;
-
-    // GlyphProperties.dbc cache: glyphId -> { spellId, isMajor }
-    struct GlyphInfo { uint32_t spellId = 0; bool isMajor = false; };
-    std::unordered_map<uint32_t, GlyphInfo> glyphProperties_;  // glyphId -> info
 };
 
 } // namespace ui
diff --git a/include/ui/toast_manager.hpp b/include/ui/toast_manager.hpp
deleted file mode 100644
index 34cafa4d..00000000
--- a/include/ui/toast_manager.hpp
+++ /dev/null
@@ -1,197 +0,0 @@
-#pragma once
-
-#include "ui/ui_services.hpp"
-#include <vulkan/vulkan.h>
-#include <imgui.h>
-#include <string>
-#include <vector>
-#include <cstdint>
-
-namespace wowee {
-namespace game { class GameHandler; }
-namespace ui {
-
-/**
- * Toast / notification overlay manager
- *
- * Owns all toast state, callbacks, and rendering:
- *   level-up ding, achievement, area discovery, whisper, quest progress,
- *   player level-up, PvP honor, item loot, reputation, quest complete,
- *   zone entry, area trigger, resurrect flash, and zone text.
- */
-class ToastManager {
-public:
-    ToastManager() = default;
-
-    /// Register toast-related callbacks on GameHandler (idempotent — safe every frame)
-    void setupCallbacks(game::GameHandler& gameHandler);
-
-    /// Render "early" toasts (rep, quest-complete, zone, area-trigger) — called before action bars
-    void renderEarlyToasts(float deltaTime, game::GameHandler& gameHandler);
-
-    /// Render "late" toasts (ding, achievement, discovery, whisper, quest progress,
-    /// player level-up, PvP honor, item loot, resurrect flash, zone text) — called after escape menu
-    void renderLateToasts(game::GameHandler& gameHandler);
-
-    /// Fire level-up ding animation + sound
-    void triggerDing(uint32_t newLevel, uint32_t hpDelta = 0, uint32_t manaDelta = 0,
-                     uint32_t str = 0, uint32_t agi = 0, uint32_t sta = 0,
-                     uint32_t intel = 0, uint32_t spi = 0);
-
-    /// Fire achievement earned toast + sound
-    void triggerAchievementToast(uint32_t achievementId, std::string name = {});
-
-    // Section 3.5: UIServices injection (Phase B singleton breaking)
-    void setServices(const UIServices& services) { services_ = services; }
-
-    // --- public state consumed by GameScreen for the golden burst overlay ---
-    float levelUpFlashAlpha = 0.0f;
-    uint32_t levelUpDisplayLevel = 0;
-
-private:
-    // Section 3.5: Injected UI services
-    UIServices services_;
-
-    // ---- Ding effect (own level-up) ----
-    static constexpr float DING_DURATION = 4.0f;
-    float dingTimer_ = 0.0f;
-    uint32_t dingLevel_ = 0;
-    uint32_t dingHpDelta_   = 0;
-    uint32_t dingManaDelta_ = 0;
-    uint32_t dingStats_[5]  = {};
-    void renderDingEffect();
-
-    // ---- Achievement toast ----
-    static constexpr float ACHIEVEMENT_TOAST_DURATION = 5.0f;
-    float achievementToastTimer_ = 0.0f;
-    uint32_t achievementToastId_ = 0;
-    std::string achievementToastName_;
-    bool achievementCallbackSet_ = false;
-    void renderAchievementToast();
-
-    // ---- Area discovery toast ----
-    static constexpr float DISCOVERY_TOAST_DURATION = 4.0f;
-    float discoveryToastTimer_ = 0.0f;
-    std::string discoveryToastName_;
-    uint32_t discoveryToastXP_ = 0;
-    bool areaDiscoveryCallbackSet_ = false;
-    void renderDiscoveryToast();
-
-    // ---- Whisper toast ----
-    struct WhisperToastEntry {
-        std::string sender;
-        std::string preview;
-        float age = 0.0f;
-    };
-    static constexpr float WHISPER_TOAST_DURATION = 5.0f;
-    std::vector<WhisperToastEntry> whisperToasts_;
-    size_t whisperSeenCount_ = 0;
-    void renderWhisperToasts();
-
-    // ---- Quest objective progress toast ----
-    struct QuestProgressToastEntry {
-        std::string questTitle;
-        std::string objectiveName;
-        uint32_t current = 0;
-        uint32_t required = 0;
-        float age = 0.0f;
-    };
-    static constexpr float QUEST_TOAST_DURATION = 4.0f;
-    std::vector<QuestProgressToastEntry> questToasts_;
-    bool questProgressCallbackSet_ = false;
-    void renderQuestProgressToasts();
-
-    // ---- Nearby player level-up toast ----
-    struct PlayerLevelUpToastEntry {
-        uint64_t guid = 0;
-        std::string playerName;
-        uint32_t newLevel = 0;
-        float age = 0.0f;
-    };
-    static constexpr float PLAYER_LEVELUP_TOAST_DURATION = 4.0f;
-    std::vector<PlayerLevelUpToastEntry> playerLevelUpToasts_;
-    bool otherPlayerLevelUpCallbackSet_ = false;
-    void renderPlayerLevelUpToasts(game::GameHandler& gameHandler);
-
-    // ---- PvP honor toast ----
-    struct PvpHonorToastEntry {
-        uint32_t honor = 0;
-        uint32_t victimRank = 0;
-        float age = 0.0f;
-    };
-    static constexpr float PVP_HONOR_TOAST_DURATION = 3.5f;
-    std::vector<PvpHonorToastEntry> pvpHonorToasts_;
-    bool pvpHonorCallbackSet_ = false;
-    void renderPvpHonorToasts();
-
-    // ---- Item loot toast ----
-    struct ItemLootToastEntry {
-        uint32_t itemId = 0;
-        uint32_t count = 0;
-        uint32_t quality = 1;
-        std::string name;
-        float age = 0.0f;
-    };
-    static constexpr float ITEM_LOOT_TOAST_DURATION = 3.0f;
-    std::vector<ItemLootToastEntry> itemLootToasts_;
-    bool itemLootCallbackSet_ = false;
-    void renderItemLootToasts();
-
-    // ---- Reputation change toast ----
-    struct RepToastEntry {
-        std::string factionName;
-        int32_t delta = 0;
-        int32_t standing = 0;
-        float age = 0.0f;
-    };
-    std::vector<RepToastEntry> repToasts_;
-    bool repChangeCallbackSet_ = false;
-    static constexpr float kRepToastLifetime = 3.5f;
-    void renderRepToasts(float deltaTime);
-
-    // ---- Quest completion toast ----
-    struct QuestCompleteToastEntry {
-        uint32_t questId = 0;
-        std::string title;
-        float age = 0.0f;
-    };
-    std::vector<QuestCompleteToastEntry> questCompleteToasts_;
-    bool questCompleteCallbackSet_ = false;
-    static constexpr float kQuestCompleteToastLifetime = 4.0f;
-    void renderQuestCompleteToasts(float deltaTime);
-
-    // ---- Zone entry toast ----
-    struct ZoneToastEntry {
-        std::string zoneName;
-        float age = 0.0f;
-    };
-    std::vector<ZoneToastEntry> zoneToasts_;
-    std::string lastKnownZone_;
-    static constexpr float kZoneToastLifetime = 3.0f;
-    void renderZoneToasts(float deltaTime);
-
-    // ---- Area trigger message toast ----
-    struct AreaTriggerToast {
-        std::string text;
-        float age = 0.0f;
-    };
-    std::vector<AreaTriggerToast> areaTriggerToasts_;
-    void renderAreaTriggerToasts(float deltaTime, game::GameHandler& gameHandler);
-
-    // ---- Resurrection flash ----
-    float resurrectFlashTimer_ = 0.0f;
-    static constexpr float kResurrectFlashDuration = 3.0f;
-    bool ghostStateCallbackSet_ = false;
-    void renderResurrectFlash();
-
-    // ---- Zone discovery text ("Entering: <ZoneName>") ----
-    static constexpr float ZONE_TEXT_DURATION = 5.0f;
-    float zoneTextTimer_ = 0.0f;
-    std::string zoneTextName_;
-    std::string lastKnownZoneName_;
-    uint32_t lastKnownWorldStateZoneId_ = 0;
-    void renderZoneText(game::GameHandler& gameHandler);
-};
-
-} // namespace ui
-} // namespace wowee
diff --git a/include/ui/ui_colors.hpp b/include/ui/ui_colors.hpp
deleted file mode 100644
index abbda64f..00000000
--- a/include/ui/ui_colors.hpp
+++ /dev/null
@@ -1,216 +0,0 @@
-#pragma once
-
-#include <imgui.h>
-#include "game/inventory.hpp"
-
-namespace wowee::ui {
-
-// ---- Common UI colors ----
-namespace colors {
-    constexpr ImVec4 kRed         = {1.0f, 0.3f, 0.3f, 1.0f};
-    constexpr ImVec4 kGreen       = {0.4f, 1.0f, 0.4f, 1.0f};
-    constexpr ImVec4 kBrightGreen = {0.3f, 1.0f, 0.3f, 1.0f};
-    constexpr ImVec4 kYellow      = {1.0f, 1.0f, 0.3f, 1.0f};
-    constexpr ImVec4 kGray        = {0.6f, 0.6f, 0.6f, 1.0f};
-    constexpr ImVec4 kDarkGray    = {0.5f, 0.5f, 0.5f, 1.0f};
-    constexpr ImVec4 kLightGray   = {0.7f, 0.7f, 0.7f, 1.0f};
-    constexpr ImVec4 kWhite       = {1.0f, 1.0f, 1.0f, 1.0f};
-    constexpr ImVec4 kTooltipGold = {1.0f, 0.82f, 0.0f, 1.0f};
-    constexpr ImVec4 kBrightGold  = {1.0f, 0.85f, 0.0f, 1.0f};
-    constexpr ImVec4 kPaleRed     = {1.0f, 0.5f, 0.5f, 1.0f};
-    constexpr ImVec4 kBrightRed   = {1.0f, 0.2f, 0.2f, 1.0f};
-    constexpr ImVec4 kLightBlue   = {0.4f, 0.6f, 1.0f, 1.0f};
-    constexpr ImVec4 kManaBlue    = {0.2f, 0.2f, 0.9f, 1.0f};
-    constexpr ImVec4 kCyan        = {0.0f, 0.8f, 1.0f, 1.0f};
-    constexpr ImVec4 kDarkRed     = {0.9f, 0.2f, 0.2f, 1.0f};
-    constexpr ImVec4 kSoftRed     = {1.0f, 0.4f, 0.4f, 1.0f};
-    constexpr ImVec4 kHostileRed  = {1.0f, 0.35f, 0.35f, 1.0f};
-    constexpr ImVec4 kMediumGray  = {0.65f, 0.65f, 0.65f, 1.0f};
-    constexpr ImVec4 kWarmGold    = {1.0f, 0.84f, 0.0f, 1.0f};
-    constexpr ImVec4 kOrange      = {0.9f, 0.6f, 0.1f, 1.0f};
-    constexpr ImVec4 kFriendlyGreen = {0.2f, 0.7f, 0.2f, 1.0f};
-    constexpr ImVec4 kHealthGreen   = {0.2f, 0.8f, 0.2f, 1.0f};
-    constexpr ImVec4 kLightGreen    = {0.6f, 1.0f, 0.6f, 1.0f};
-    constexpr ImVec4 kActiveGreen   = {0.5f, 1.0f, 0.5f, 1.0f};
-    constexpr ImVec4 kSocketGreen   = {0.5f, 0.8f, 0.5f, 1.0f};
-
-    // UI element colors
-    constexpr ImVec4 kInactiveGray   = {0.55f, 0.55f, 0.55f, 1.0f};
-    constexpr ImVec4 kVeryLightGray  = {0.85f, 0.85f, 0.85f, 1.0f};
-    constexpr ImVec4 kSymbolGold     = {1.0f, 0.85f, 0.1f, 1.0f};
-    constexpr ImVec4 kDarkYellow     = {0.8f, 0.8f, 0.0f, 1.0f};
-    constexpr ImVec4 kLowHealthRed   = {0.8f, 0.2f, 0.2f, 1.0f};
-    constexpr ImVec4 kDangerRed      = {0.7f, 0.2f, 0.2f, 1.0f};
-
-    // Cast bar / status colors
-    constexpr ImVec4 kCastGreen      = {0.2f, 0.75f, 0.2f, 1.0f};
-    constexpr ImVec4 kQueueGreen     = {0.3f, 0.9f, 0.3f, 1.0f};
-
-    // Button styling colors (accept/decline patterns)
-    constexpr ImVec4 kBtnGreen       = {0.15f, 0.5f, 0.15f, 1.0f};
-    constexpr ImVec4 kBtnGreenHover  = {0.2f, 0.7f, 0.2f, 1.0f};  // == kFriendlyGreen
-    constexpr ImVec4 kBtnRed         = {0.5f, 0.15f, 0.15f, 1.0f};
-    constexpr ImVec4 kBtnRedHover    = {0.7f, 0.3f, 0.3f, 1.0f};
-    constexpr ImVec4 kBtnDkGreen     = {0.2f, 0.5f, 0.2f, 1.0f};
-    constexpr ImVec4 kBtnDkGreenHover= {0.3f, 0.7f, 0.3f, 1.0f};
-    constexpr ImVec4 kBtnDkRed       = {0.5f, 0.2f, 0.2f, 1.0f};
-    constexpr ImVec4 kBtnDkRedHover  = {0.7f, 0.3f, 0.3f, 1.0f};
-    constexpr ImVec4 kMidHealthYellow= {0.8f, 0.8f, 0.2f, 1.0f};
-
-    // Power-type colors (unit resource bars)
-    constexpr ImVec4 kEnergyYellow    = {0.9f, 0.9f, 0.2f, 1.0f};
-    constexpr ImVec4 kHappinessGreen  = {0.5f, 0.9f, 0.3f, 1.0f};
-    constexpr ImVec4 kRunicRed        = {0.8f, 0.1f, 0.2f, 1.0f};
-    constexpr ImVec4 kSoulShardPurple = {0.4f, 0.1f, 0.6f, 1.0f};
-
-    // Coin colors
-    constexpr ImVec4 kGold   = {1.00f, 0.82f, 0.00f, 1.0f};
-    constexpr ImVec4 kSilver = {0.80f, 0.80f, 0.80f, 1.0f};
-    constexpr ImVec4 kCopper = {0.72f, 0.45f, 0.20f, 1.0f};
-} // namespace colors
-
-// ---- Item quality colors ----
-inline ImVec4 getQualityColor(game::ItemQuality quality) {
-    switch (quality) {
-        case game::ItemQuality::POOR:      return {0.62f, 0.62f, 0.62f, 1.0f};
-        case game::ItemQuality::COMMON:    return {1.0f, 1.0f, 1.0f, 1.0f};
-        case game::ItemQuality::UNCOMMON:  return {0.12f, 1.0f, 0.0f, 1.0f};
-        case game::ItemQuality::RARE:      return {0.0f, 0.44f, 0.87f, 1.0f};
-        case game::ItemQuality::EPIC:      return {0.64f, 0.21f, 0.93f, 1.0f};
-        case game::ItemQuality::LEGENDARY: return {1.0f, 0.50f, 0.0f, 1.0f};
-        case game::ItemQuality::ARTIFACT:  return {0.90f, 0.80f, 0.50f, 1.0f};
-        case game::ItemQuality::HEIRLOOM:  return {0.90f, 0.80f, 0.50f, 1.0f};
-        default:                           return {1.0f, 1.0f, 1.0f, 1.0f};
-    }
-}
-
-// ---- Coin display (gold/silver/copper) ----
-inline void renderCoinsText(uint32_t g, uint32_t s, uint32_t c) {
-    bool any = false;
-    if (g > 0) {
-        ImGui::TextColored(colors::kGold, "%ug", g);
-        any = true;
-    }
-    if (s > 0 || g > 0) {
-        if (any) ImGui::SameLine(0, 3);
-        ImGui::TextColored(colors::kSilver, "%us", s);
-        any = true;
-    }
-    if (any) ImGui::SameLine(0, 3);
-    ImGui::TextColored(colors::kCopper, "%uc", c);
-}
-
-// Convenience overload: decompose copper amount and render as gold/silver/copper
-inline void renderCoinsFromCopper(uint64_t copper) {
-    renderCoinsText(static_cast<uint32_t>(copper / 10000),
-                    static_cast<uint32_t>((copper / 100) % 100),
-                    static_cast<uint32_t>(copper % 100));
-}
-
-// ---- Inventory slot name from WoW inventory type ----
-inline const char* getInventorySlotName(uint32_t inventoryType) {
-    switch (inventoryType) {
-        case 1:  return "Head";
-        case 2:  return "Neck";
-        case 3:  return "Shoulder";
-        case 4:  return "Shirt";
-        case 5:  return "Chest";
-        case 6:  return "Waist";
-        case 7:  return "Legs";
-        case 8:  return "Feet";
-        case 9:  return "Wrist";
-        case 10: return "Hands";
-        case 11: return "Finger";
-        case 12: return "Trinket";
-        case 13: return "One-Hand";
-        case 14: return "Shield";
-        case 15: return "Ranged";
-        case 16: return "Back";
-        case 17: return "Two-Hand";
-        case 18: return "Bag";
-        case 19: return "Tabard";
-        case 20: return "Robe";
-        case 21: return "Main Hand";
-        case 22: return "Off Hand";
-        case 23: return "Held In Off-hand";
-        case 25: return "Thrown";
-        case 26: return "Ranged";
-        case 28: return "Relic";
-        default: return "";
-    }
-}
-
-// ---- Binding type display ----
-inline void renderBindingType(uint32_t bindType) {
-    const auto& kBindColor = colors::kTooltipGold;
-    switch (bindType) {
-        case 1: ImGui::TextColored(kBindColor, "Binds when picked up"); break;
-        case 2: ImGui::TextColored(kBindColor, "Binds when equipped"); break;
-        case 3: ImGui::TextColored(kBindColor, "Binds when used"); break;
-        case 4: ImGui::TextColored(kBindColor, "Quest Item"); break;
-        default: break;
-    }
-}
-
-// ---- DBC item-set spell field keys ----
-inline constexpr const char* kItemSetItemKeys[10] = {
-    "Item0","Item1","Item2","Item3","Item4",
-    "Item5","Item6","Item7","Item8","Item9"
-};
-inline constexpr const char* kItemSetSpellKeys[10] = {
-    "Spell0","Spell1","Spell2","Spell3","Spell4",
-    "Spell5","Spell6","Spell7","Spell8","Spell9"
-};
-inline constexpr const char* kItemSetThresholdKeys[10] = {
-    "Threshold0","Threshold1","Threshold2","Threshold3","Threshold4",
-    "Threshold5","Threshold6","Threshold7","Threshold8","Threshold9"
-};
-
-// ---- Socket type display (gem sockets) ----
-struct SocketTypeDef { uint32_t mask; const char* label; ImVec4 col; };
-inline constexpr SocketTypeDef kSocketTypes[] = {
-    { 1, "Meta Socket",   { 0.7f, 0.7f, 0.9f, 1.0f } },
-    { 2, "Red Socket",    { 1.0f, 0.3f, 0.3f, 1.0f } },
-    { 4, "Yellow Socket", { 1.0f, 0.9f, 0.3f, 1.0f } },
-    { 8, "Blue Socket",   { 0.3f, 0.6f, 1.0f, 1.0f } },
-};
-
-// ---- Class/race bitmask lookup (for allowableClass/allowableRace display) ----
-struct ClassMaskEntry { uint32_t mask; const char* name; };
-inline constexpr ClassMaskEntry kClassMasks[] = {
-    {1,"Warrior"}, {2,"Paladin"}, {4,"Hunter"}, {8,"Rogue"},
-    {16,"Priest"}, {32,"Death Knight"}, {64,"Shaman"},
-    {128,"Mage"}, {256,"Warlock"}, {1024,"Druid"},
-};
-
-struct RaceMaskEntry { uint32_t mask; const char* name; };
-inline constexpr RaceMaskEntry kRaceMasks[] = {
-    {1,"Human"}, {2,"Orc"}, {4,"Dwarf"}, {8,"Night Elf"},
-    {16,"Undead"}, {32,"Tauren"}, {64,"Gnome"}, {128,"Troll"},
-    {512,"Blood Elf"}, {1024,"Draenei"},
-};
-
-// ---- WoW class colors (Blizzard canonical) ----
-inline ImVec4 getClassColor(uint8_t classId) {
-    switch (classId) {
-        case 1:  return {0.78f, 0.61f, 0.43f, 1.0f}; // Warrior  #C79C6E
-        case 2:  return {0.96f, 0.55f, 0.73f, 1.0f}; // Paladin  #F58CBA
-        case 3:  return {0.67f, 0.83f, 0.45f, 1.0f}; // Hunter   #ABD473
-        case 4:  return {1.00f, 0.96f, 0.41f, 1.0f}; // Rogue    #FFF569
-        case 5:  return {1.00f, 1.00f, 1.00f, 1.0f}; // Priest   #FFFFFF
-        case 6:  return {0.77f, 0.12f, 0.23f, 1.0f}; // DK       #C41F3B
-        case 7:  return {0.00f, 0.44f, 0.87f, 1.0f}; // Shaman   #0070DE
-        case 8:  return {0.41f, 0.80f, 0.94f, 1.0f}; // Mage     #69CCF0
-        case 9:  return {0.58f, 0.51f, 0.79f, 1.0f}; // Warlock  #9482C9
-        case 11: return {1.00f, 0.49f, 0.04f, 1.0f}; // Druid    #FF7D0A
-        default: return colors::kVeryLightGray;
-    }
-}
-
-inline ImU32 getClassColorU32(uint8_t classId, int alpha = 255) {
-    ImVec4 c = getClassColor(classId);
-    return IM_COL32(static_cast<int>(c.x * 255), static_cast<int>(c.y * 255),
-                    static_cast<int>(c.z * 255), alpha);
-}
-
-} // namespace wowee::ui
diff --git a/include/ui/ui_helpers.hpp b/include/ui/ui_helpers.hpp
deleted file mode 100644
index f3f6d08a..00000000
--- a/include/ui/ui_helpers.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#pragma once
-
-#include <imgui.h>
-#include <cstdint>
-#include <cstdio>
-#include "ui/ui_colors.hpp"
-#include "game/entity.hpp"
-#include "game/update_field_table.hpp"
-#include "game/character.hpp"
-
-namespace wowee::ui::helpers {
-
-// ---- Duration / aura formatting ----
-
-// Format a duration in seconds as compact text: "2h", "3:05", "42"
-inline void fmtDurationCompact(char* buf, size_t sz, int secs) {
-    if (secs >= 3600) snprintf(buf, sz, "%dh", secs / 3600);
-    else if (secs >= 60) snprintf(buf, sz, "%d:%02d", secs / 60, secs % 60);
-    else snprintf(buf, sz, "%d", secs);
-}
-
-// Render "Remaining: Xs" or "Remaining: Xm Ys" in a tooltip (light gray)
-inline void renderAuraRemaining(int remainMs) {
-    if (remainMs <= 0) return;
-    int s = remainMs / 1000;
-    char buf[32];
-    if (s < 60) snprintf(buf, sizeof(buf), "Remaining: %ds", s);
-    else snprintf(buf, sizeof(buf), "Remaining: %dm %ds", s / 60, s % 60);
-    ImGui::TextColored(colors::kLightGray, "%s", buf);
-}
-
-// ---- Class color / name helpers ----
-
-inline ImVec4 classColorVec4(uint8_t classId) { return getClassColor(classId); }
-inline ImU32 classColorU32(uint8_t classId, int alpha = 255) { return getClassColorU32(classId, alpha); }
-
-inline const char* classNameStr(uint8_t classId) {
-    return game::getClassName(static_cast<game::Class>(classId));
-}
-
-// Extract class id from a unit's UNIT_FIELD_BYTES_0 update field.
-// Returns 0 if the entity pointer is null or field is unset.
-inline uint8_t entityClassId(const game::Entity* entity) {
-    if (!entity) return 0;
-    using UF = game::UF;
-    uint32_t bytes0 = entity->getField(game::fieldIndex(UF::UNIT_FIELD_BYTES_0));
-    return static_cast<uint8_t>((bytes0 >> 8) & 0xFF);
-}
-
-// ---- Shared UI data tables ----
-
-// Aura dispel-type names (indexed by dispelType 0-4)
-inline constexpr const char* kDispelNames[] = { "", "Magic", "Curse", "Disease", "Poison" };
-
-// Raid mark names with symbol prefixes (indexed 0-7: Star..Skull)
-inline constexpr const char* kRaidMarkNames[] = {
-    "{*} Star", "{O} Circle", "{<>} Diamond", "{^} Triangle",
-    "{)} Moon", "{ } Square", "{x} Cross", "{8} Skull"
-};
-
-} // namespace wowee::ui::helpers
diff --git a/include/ui/ui_manager.hpp b/include/ui/ui_manager.hpp
index bdc217d9..ba1e4c09 100644
--- a/include/ui/ui_manager.hpp
+++ b/include/ui/ui_manager.hpp
@@ -5,7 +5,6 @@
 #include "ui/character_create_screen.hpp"
 #include "ui/character_screen.hpp"
 #include "ui/game_screen.hpp"
-#include "ui/ui_services.hpp"
 #include <memory>
 
 // Forward declare SDL_Event
@@ -14,7 +13,7 @@ union SDL_Event;
 namespace wowee {
 
 // Forward declarations
-namespace core { class Window; class AppearanceComposer; enum class AppState; }
+namespace core { class Window; enum class AppState; }
 namespace auth { class AuthHandler; }
 namespace game { class GameHandler; }
 
@@ -70,23 +69,8 @@ public:
     CharacterScreen& getCharacterScreen() { return *characterScreen; }
     GameScreen& getGameScreen() { return *gameScreen; }
 
-    // Dependency injection forwarding (Phase A singleton breaking)
-    void setAppearanceComposer(core::AppearanceComposer* ac) {
-        if (gameScreen) gameScreen->setAppearanceComposer(ac);
-    }
-
-    // Section 3.5: UIServices injection (Phase B singleton breaking)
-    void setServices(const UIServices& services) {
-        services_ = services;
-        if (gameScreen) gameScreen->setServices(services);
-        if (authScreen) authScreen->setServices(services);
-        if (characterScreen) characterScreen->setServices(services);
-    }
-    const UIServices& getServices() const { return services_; }
-
 private:
     core::Window* window = nullptr;
-    UIServices services_;  // Section 3.5: Injected services
 
     // UI Screens
     std::unique_ptr<AuthScreen> authScreen;
diff --git a/include/ui/ui_services.hpp b/include/ui/ui_services.hpp
deleted file mode 100644
index fdcd4b2b..00000000
--- a/include/ui/ui_services.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#pragma once
-
-namespace wowee {
-
-// Forward declarations
-namespace core { 
-    class Window;
-    class EntitySpawner;
-    class AppearanceComposer;
-    class WorldLoader;
-}
-namespace rendering { class Renderer; }
-namespace pipeline { class AssetManager; }
-namespace game { 
-    class GameHandler;
-    class ExpansionRegistry;
-}
-namespace addons { class AddonManager; }
-namespace audio { class AudioCoordinator; }
-
-namespace ui {
-
-/**
- * UI Services - Dependency injection container for UI components.
- * 
- * Section 3.5: Break the singleton Phase B
- * 
- * Replaces Application::getInstance() calls throughout UI code.
- * Application creates this struct and injects it into UIManager,
- * which propagates it to GameScreen and all child UI components.
- * 
- * Owned by Application, shared as const pointers (non-owning).
- */
-struct UIServices {
-    core::Window* window = nullptr;
-    rendering::Renderer* renderer = nullptr;
-    pipeline::AssetManager* assetManager = nullptr;
-    game::GameHandler* gameHandler = nullptr;
-    game::ExpansionRegistry* expansionRegistry = nullptr;
-    addons::AddonManager* addonManager = nullptr;
-    audio::AudioCoordinator* audioCoordinator = nullptr;
-    
-    // Extracted classes (also available individually for Phase A compatibility)
-    core::EntitySpawner* entitySpawner = nullptr;
-    core::AppearanceComposer* appearanceComposer = nullptr;
-    core::WorldLoader* worldLoader = nullptr;
-    
-    // Helper to check if core services are wired
-    bool isValid() const {
-        return window && renderer && assetManager && gameHandler;
-    }
-};
-
-} // namespace ui
-} // namespace wowee
diff --git a/include/ui/window_manager.hpp b/include/ui/window_manager.hpp
deleted file mode 100644
index a5f3564c..00000000
--- a/include/ui/window_manager.hpp
+++ /dev/null
@@ -1,187 +0,0 @@
-// ============================================================
-// WindowManager — extracted from GameScreen
-// Owns all NPC interaction windows, popup dialogs, and misc
-// overlay UI: loot, gossip, quest, vendor, trainer, mail, bank,
-// auction house, barber, stable, taxi, escape menu, death screen,
-// instance lockouts, achievements, GM ticket, books, titles,
-// equipment sets, skills.
-// ============================================================
-#pragma once
-#include "ui/ui_services.hpp"
-#include <cstdint>
-#include <string>
-#include <unordered_map>
-#include <functional>
-#include <vulkan/vulkan.h>
-
-namespace wowee {
-namespace game { class GameHandler; }
-namespace pipeline { class AssetManager; }
-namespace ui {
-
-class ChatPanel;
-class SettingsPanel;
-class InventoryScreen;
-class SpellbookScreen;
-
-class WindowManager {
-public:
-    // Callback type for resolving spell icons (spellId, assetMgr) → VkDescriptorSet
-    using SpellIconFn = std::function<VkDescriptorSet(uint32_t, pipeline::AssetManager*)>;
-
-    // ---- NPC interaction windows ----
-    void renderLootWindow(game::GameHandler& gameHandler,
-                          InventoryScreen& inventoryScreen,
-                          ChatPanel& chatPanel);
-    void renderGossipWindow(game::GameHandler& gameHandler,
-                            ChatPanel& chatPanel);
-    void renderQuestDetailsWindow(game::GameHandler& gameHandler,
-                                  ChatPanel& chatPanel,
-                                  InventoryScreen& inventoryScreen);
-    void renderQuestRequestItemsWindow(game::GameHandler& gameHandler,
-                                       ChatPanel& chatPanel,
-                                       InventoryScreen& inventoryScreen);
-    void renderQuestOfferRewardWindow(game::GameHandler& gameHandler,
-                                      ChatPanel& chatPanel,
-                                      InventoryScreen& inventoryScreen);
-    void renderVendorWindow(game::GameHandler& gameHandler,
-                            InventoryScreen& inventoryScreen,
-                            ChatPanel& chatPanel);
-    void renderTrainerWindow(game::GameHandler& gameHandler,
-                             SpellIconFn getSpellIcon);
-    void renderBarberShopWindow(game::GameHandler& gameHandler);
-    void renderStableWindow(game::GameHandler& gameHandler);
-    void renderTaxiWindow(game::GameHandler& gameHandler);
-
-    // ---- Mail and banking ----
-    void renderMailWindow(game::GameHandler& gameHandler,
-                          InventoryScreen& inventoryScreen,
-                          ChatPanel& chatPanel);
-    void renderMailComposeWindow(game::GameHandler& gameHandler,
-                                 InventoryScreen& inventoryScreen);
-    void renderBankWindow(game::GameHandler& gameHandler,
-                          InventoryScreen& inventoryScreen,
-                          ChatPanel& chatPanel);
-    void renderGuildBankWindow(game::GameHandler& gameHandler,
-                               InventoryScreen& inventoryScreen,
-                               ChatPanel& chatPanel);
-    void renderAuctionHouseWindow(game::GameHandler& gameHandler,
-                                  InventoryScreen& inventoryScreen,
-                                  ChatPanel& chatPanel);
-
-    // ---- Popup / overlay windows ----
-    void renderEscapeMenu(SettingsPanel& settingsPanel);
-    void renderLogoutCountdown(game::GameHandler& gameHandler);
-    void renderDeathScreen(game::GameHandler& gameHandler);
-    void renderReclaimCorpseButton(game::GameHandler& gameHandler);
-    void renderInstanceLockouts(game::GameHandler& gameHandler);
-    void renderAchievementWindow(game::GameHandler& gameHandler);
-    void renderGmTicketWindow(game::GameHandler& gameHandler);
-    void renderBookWindow(game::GameHandler& gameHandler);
-    void renderTitlesWindow(game::GameHandler& gameHandler);
-    void renderEquipSetWindow(game::GameHandler& gameHandler);
-    void renderSkillsWindow(game::GameHandler& gameHandler);
-
-    // ---- State owned by this manager ----
-
-    // Instance lockouts
-    bool showInstanceLockouts_ = false;
-
-    // Achievements
-    bool showAchievementWindow_ = false;
-    char achievementSearchBuf_[128] = {};
-
-    // Skills / Professions
-    bool showSkillsWindow_ = false;
-
-    // Titles
-    bool showTitlesWindow_ = false;
-
-    // Equipment Sets
-    bool showEquipSetWindow_ = false;
-
-    // GM Ticket
-    bool showGmTicketWindow_     = false;
-    bool gmTicketWindowWasOpen_  = false;
-    char gmTicketBuf_[2048] = {};
-
-    // Book / scroll reader
-    bool showBookWindow_ = false;
-    int  bookCurrentPage_ = 0;
-
-    // Death screen
-    float deathElapsed_ = 0.0f;
-    bool deathTimerRunning_ = false;
-    static constexpr float kForcedReleaseSec = 360.0f;
-
-    // Escape menu
-    bool showEscapeMenu = false;
-
-    // Mail compose
-    char mailRecipientBuffer_[256] = "";
-    char mailSubjectBuffer_[256] = "";
-    char mailBodyBuffer_[2048] = "";
-    int mailComposeMoney_[3] = {0, 0, 0};
-
-    // Vendor
-    char vendorSearchFilter_[128] = "";
-    bool vendorConfirmOpen_ = false;
-    uint64_t vendorConfirmGuid_ = 0;
-    uint32_t vendorConfirmItemId_ = 0;
-    uint32_t vendorConfirmSlot_ = 0;
-    uint32_t vendorConfirmQty_ = 1;
-    uint32_t vendorConfirmPrice_ = 0;
-    std::string vendorConfirmItemName_;
-    bool vendorBagsOpened_ = false;
-
-    // Barber shop
-    int barberHairStyle_ = 0;
-    int barberHairColor_ = 0;
-    int barberFacialHair_ = 0;
-    int barberOrigHairStyle_ = 0;
-    int barberOrigHairColor_ = 0;
-    int barberOrigFacialHair_ = 0;
-    bool barberInitialized_ = false;
-
-    // Trainer
-    char trainerSearchFilter_[128] = "";
-
-    // Auction house
-    char auctionSearchName_[256] = "";
-    int auctionLevelMin_ = 0;
-    int auctionLevelMax_ = 0;
-    int auctionQuality_ = 0;
-    int auctionSellDuration_ = 2;
-    int auctionSellBid_[3] = {0, 0, 0};
-    int auctionSellBuyout_[3] = {0, 0, 0};
-    int auctionSelectedItem_ = -1;
-    int auctionSellSlotIndex_ = -1;
-    uint32_t auctionBrowseOffset_ = 0;
-    int auctionItemClass_ = -1;
-    int auctionItemSubClass_ = -1;
-    bool auctionUsableOnly_ = false;
-
-    // Guild bank money input
-    int guildBankMoneyInput_[3] = {0, 0, 0};
-
-    // ItemExtendedCost.dbc cache
-    struct ExtendedCostEntry {
-        uint32_t honorPoints = 0;
-        uint32_t arenaPoints = 0;
-        uint32_t itemId[5] = {};
-        uint32_t itemCount[5] = {};
-    };
-    std::unordered_map<uint32_t, ExtendedCostEntry> extendedCostCache_;
-    bool extendedCostDbLoaded_ = false;
-
-    // Section 3.5: UIServices injection (Phase B singleton breaking)
-    void setServices(const UIServices& services) { services_ = services; }
-
-private:
-    UIServices services_;
-    void loadExtendedCostDBC();
-    std::string formatExtendedCost(uint32_t extendedCostId, game::GameHandler& gameHandler);
-};
-
-} // namespace ui
-} // namespace wowee
diff --git a/resources/wowee.rc b/resources/wowee.rc
index 45939fce..a39b5c55 100644
--- a/resources/wowee.rc
+++ b/resources/wowee.rc
@@ -1 +1 @@
-IDI_APP_ICON ICON "assets/wowee.ico"
+IDI_APP_ICON ICON "assets\\wowee.ico"
diff --git a/restart-worldserver.sh b/restart-worldserver.sh
old mode 100755
new mode 100644
diff --git a/src/addons/addon_manager.cpp b/src/addons/addon_manager.cpp
deleted file mode 100644
index e8167f94..00000000
--- a/src/addons/addon_manager.cpp
+++ /dev/null
@@ -1,176 +0,0 @@
-#include "addons/addon_manager.hpp"
-#include "core/logger.hpp"
-#include <algorithm>
-#include <filesystem>
-
-namespace fs = std::filesystem;
-
-namespace wowee::addons {
-
-AddonManager::AddonManager() = default;
-AddonManager::~AddonManager() { shutdown(); }
-
-bool AddonManager::initialize(game::GameHandler* gameHandler, const LuaServices& services) {
-    gameHandler_ = gameHandler;
-    luaServices_ = services;
-    if (!luaEngine_.initialize()) return false;
-    luaEngine_.setGameHandler(gameHandler);
-    luaEngine_.setLuaServices(luaServices_);
-    return true;
-}
-
-void AddonManager::scanAddons(const std::string& addonsPath) {
-    addonsPath_ = addonsPath;
-    addons_.clear();
-
-    std::error_code ec;
-    if (!fs::is_directory(addonsPath, ec)) {
-        LOG_INFO("AddonManager: no AddOns directory at ", addonsPath);
-        return;
-    }
-
-    std::vector<fs::path> dirs;
-    for (const auto& entry : fs::directory_iterator(addonsPath, ec)) {
-        if (entry.is_directory()) dirs.push_back(entry.path());
-    }
-    // Sort alphabetically for deterministic load order
-    std::sort(dirs.begin(), dirs.end());
-
-    for (const auto& dir : dirs) {
-        std::string dirName = dir.filename().string();
-        std::string tocPath = (dir / (dirName + ".toc")).string();
-        auto toc = parseTocFile(tocPath);
-        if (!toc) continue;
-
-        if (toc->isLoadOnDemand()) {
-            LOG_DEBUG("AddonManager: skipping LoadOnDemand addon: ", dirName);
-            continue;
-        }
-
-        LOG_INFO("AddonManager: registered addon '", toc->getTitle(),
-                 "' (", toc->files.size(), " files)");
-        addons_.push_back(std::move(*toc));
-    }
-
-    LOG_INFO("AddonManager: scanned ", addons_.size(), " addons");
-}
-
-void AddonManager::loadAllAddons() {
-    luaEngine_.setAddonList(addons_);
-    int loaded = 0, failed = 0;
-    for (const auto& addon : addons_) {
-        if (loadAddon(addon)) loaded++;
-        else failed++;
-    }
-    LOG_INFO("AddonManager: loaded ", loaded, " addons",
-             (failed > 0 ? (", " + std::to_string(failed) + " failed") : ""));
-}
-
-std::string AddonManager::getSavedVariablesPath(const TocFile& addon) const {
-    return addon.basePath + "/" + addon.addonName + ".lua.saved";
-}
-
-std::string AddonManager::getSavedVariablesPerCharacterPath(const TocFile& addon) const {
-    if (characterName_.empty()) return "";
-    return addon.basePath + "/" + addon.addonName + "." + characterName_ + ".lua.saved";
-}
-
-bool AddonManager::loadAddon(const TocFile& addon) {
-    // Load SavedVariables before addon code (so globals are available at load time)
-    auto savedVars = addon.getSavedVariables();
-    if (!savedVars.empty()) {
-        std::string svPath = getSavedVariablesPath(addon);
-        luaEngine_.loadSavedVariables(svPath);
-        LOG_DEBUG("AddonManager: loaded saved variables for '", addon.addonName, "'");
-    }
-    // Load per-character SavedVariables
-    auto savedVarsPC = addon.getSavedVariablesPerCharacter();
-    if (!savedVarsPC.empty()) {
-        std::string svpcPath = getSavedVariablesPerCharacterPath(addon);
-        if (!svpcPath.empty()) {
-            luaEngine_.loadSavedVariables(svpcPath);
-            LOG_DEBUG("AddonManager: loaded per-character saved variables for '", addon.addonName, "'");
-        }
-    }
-
-    bool success = true;
-    for (const auto& filename : addon.files) {
-        std::string lower = filename;
-        for (char& c : lower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-
-        if (lower.size() >= 4 && lower.substr(lower.size() - 4) == ".lua") {
-            std::string fullPath = addon.basePath + "/" + filename;
-            if (!luaEngine_.executeFile(fullPath)) {
-                success = false;
-            }
-        } else if (lower.size() >= 4 && lower.substr(lower.size() - 4) == ".xml") {
-            LOG_DEBUG("AddonManager: skipping XML file '", filename,
-                      "' in addon '", addon.addonName, "' (XML frames not yet implemented)");
-        }
-    }
-
-    // Fire ADDON_LOADED event after all addon files are executed
-    // This is the standard WoW pattern for addon initialization
-    if (success) {
-        luaEngine_.fireEvent("ADDON_LOADED", {addon.addonName});
-    }
-    return success;
-}
-
-bool AddonManager::runScript(const std::string& code) {
-    return luaEngine_.executeString(code);
-}
-
-void AddonManager::fireEvent(const std::string& event, const std::vector<std::string>& args) {
-    luaEngine_.fireEvent(event, args);
-}
-
-void AddonManager::update(float deltaTime) {
-    luaEngine_.dispatchOnUpdate(deltaTime);
-}
-
-void AddonManager::saveAllSavedVariables() {
-    for (const auto& addon : addons_) {
-        auto savedVars = addon.getSavedVariables();
-        if (!savedVars.empty()) {
-            std::string svPath = getSavedVariablesPath(addon);
-            luaEngine_.saveSavedVariables(svPath, savedVars);
-        }
-        auto savedVarsPC = addon.getSavedVariablesPerCharacter();
-        if (!savedVarsPC.empty()) {
-            std::string svpcPath = getSavedVariablesPerCharacterPath(addon);
-            if (!svpcPath.empty()) {
-                luaEngine_.saveSavedVariables(svpcPath, savedVarsPC);
-            }
-        }
-    }
-}
-
-bool AddonManager::reload() {
-    LOG_INFO("AddonManager: reloading all addons...");
-    saveAllSavedVariables();
-    addons_.clear();
-    luaEngine_.shutdown();
-
-    if (!luaEngine_.initialize()) {
-        LOG_ERROR("AddonManager: failed to reinitialize Lua VM during reload");
-        return false;
-    }
-    luaEngine_.setGameHandler(gameHandler_);
-    luaEngine_.setLuaServices(luaServices_);
-
-    if (!addonsPath_.empty()) {
-        scanAddons(addonsPath_);
-        loadAllAddons();
-    }
-    LOG_INFO("AddonManager: reload complete");
-    return true;
-}
-
-void AddonManager::shutdown() {
-    saveAllSavedVariables();
-    addons_.clear();
-    luaEngine_.shutdown();
-}
-
-} // namespace wowee::addons
diff --git a/src/addons/lua_action_api.cpp b/src/addons/lua_action_api.cpp
deleted file mode 100644
index a54716ad..00000000
--- a/src/addons/lua_action_api.cpp
+++ /dev/null
@@ -1,734 +0,0 @@
-// lua_action_api.cpp — Action bar, cursor/pickup, keyboard input, key bindings, and pet actions Lua API bindings.
-// Extracted from lua_engine.cpp as part of §5.1 (Tame LuaEngine).
-#include "addons/lua_api_helpers.hpp"
-#include "imgui.h"
-
-namespace wowee::addons {
-
-enum class CursorType { NONE, SPELL, ITEM, ACTION };
-static CursorType s_cursorType = CursorType::NONE;
-static uint32_t   s_cursorId   = 0;    // spellId, itemId, or action slot
-static int        s_cursorSlot = 0;    // source slot for placement
-static int        s_cursorBag  = -1;   // source bag for container items
-
-static int lua_HasAction(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    int slot = static_cast<int>(luaL_checknumber(L, 1)) - 1; // WoW uses 1-indexed slots
-    const auto& bar = gh->getActionBar();
-    if (slot < 0 || slot >= static_cast<int>(bar.size())) {
-        lua_pushboolean(L, 0);
-        return 1;
-    }
-    lua_pushboolean(L, !bar[slot].isEmpty());
-    return 1;
-}
-
-// GetActionTexture(slot) → texturePath or nil
-static int lua_GetActionTexture(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-    int slot = static_cast<int>(luaL_checknumber(L, 1)) - 1;
-    const auto& bar = gh->getActionBar();
-    if (slot < 0 || slot >= static_cast<int>(bar.size()) || bar[slot].isEmpty()) {
-        lua_pushnil(L);
-        return 1;
-    }
-    const auto& action = bar[slot];
-    if (action.type == game::ActionBarSlot::SPELL) {
-        std::string icon = gh->getSpellIconPath(action.id);
-        if (!icon.empty()) {
-            lua_pushstring(L, icon.c_str());
-            return 1;
-        }
-    } else if (action.type == game::ActionBarSlot::ITEM && action.id != 0) {
-        const auto* info = gh->getItemInfo(action.id);
-        if (info && info->displayInfoId != 0) {
-            std::string icon = gh->getItemIconPath(info->displayInfoId);
-            if (!icon.empty()) {
-                lua_pushstring(L, icon.c_str());
-                return 1;
-            }
-        }
-    }
-    lua_pushnil(L);
-    return 1;
-}
-
-// IsCurrentAction(slot) → boolean
-static int lua_IsCurrentAction(lua_State* L) {
-    // Currently no "active action" tracking; return false
-    (void)L;
-    lua_pushboolean(L, 0);
-    return 1;
-}
-
-// IsUsableAction(slot) → usable, notEnoughMana
-static int lua_IsUsableAction(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushboolean(L, 0); lua_pushboolean(L, 0); return 2; }
-    int slot = static_cast<int>(luaL_checknumber(L, 1)) - 1;
-    const auto& bar = gh->getActionBar();
-    if (slot < 0 || slot >= static_cast<int>(bar.size()) || bar[slot].isEmpty()) {
-        lua_pushboolean(L, 0);
-        lua_pushboolean(L, 0);
-        return 2;
-    }
-    const auto& action = bar[slot];
-    bool usable = action.isReady();
-    bool noMana = false;
-    if (action.type == game::ActionBarSlot::SPELL) {
-        usable = usable && gh->getKnownSpells().count(action.id);
-        // Check power cost
-        if (usable && action.id != 0) {
-            auto spellData = gh->getSpellData(action.id);
-            if (spellData.manaCost > 0) {
-                auto pe = gh->getEntityManager().getEntity(gh->getPlayerGuid());
-                if (pe) {
-                    auto* unit = dynamic_cast<game::Unit*>(pe.get());
-                    if (unit && unit->getPower() < spellData.manaCost) {
-                        noMana = true;
-                        usable = false;
-                    }
-                }
-            }
-        }
-    }
-    lua_pushboolean(L, usable ? 1 : 0);
-    lua_pushboolean(L, noMana ? 1 : 0);
-    return 2;
-}
-
-// IsActionInRange(slot) → 1 if in range, 0 if out, nil if no range check applicable
-static int lua_IsActionInRange(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-    int slot = static_cast<int>(luaL_checknumber(L, 1)) - 1;
-    const auto& bar = gh->getActionBar();
-    if (slot < 0 || slot >= static_cast<int>(bar.size()) || bar[slot].isEmpty()) {
-        lua_pushnil(L);
-        return 1;
-    }
-    const auto& action = bar[slot];
-    uint32_t spellId = 0;
-    if (action.type == game::ActionBarSlot::SPELL) {
-        spellId = action.id;
-    } else {
-        // Items/macros: no range check for now
-        lua_pushnil(L);
-        return 1;
-    }
-    if (spellId == 0) { return luaReturnNil(L); }
-
-    auto data = gh->getSpellData(spellId);
-    if (data.maxRange <= 0.0f) {
-        // Melee or self-cast spells: no range indicator
-        lua_pushnil(L);
-        return 1;
-    }
-
-    // Need a target to check range against
-    uint64_t targetGuid = gh->getTargetGuid();
-    if (targetGuid == 0) { return luaReturnNil(L); }
-    auto targetEnt = gh->getEntityManager().getEntity(targetGuid);
-    auto playerEnt = gh->getEntityManager().getEntity(gh->getPlayerGuid());
-    if (!targetEnt || !playerEnt) { return luaReturnNil(L); }
-
-    float dx = playerEnt->getX() - targetEnt->getX();
-    float dy = playerEnt->getY() - targetEnt->getY();
-    float dz = playerEnt->getZ() - targetEnt->getZ();
-    float dist = std::sqrt(dx*dx + dy*dy + dz*dz);
-    lua_pushnumber(L, dist <= data.maxRange ? 1 : 0);
-    return 1;
-}
-
-// GetActionInfo(slot) → actionType, id, subType
-static int lua_GetActionInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return 0; }
-    int slot = static_cast<int>(luaL_checknumber(L, 1)) - 1;
-    const auto& bar = gh->getActionBar();
-    if (slot < 0 || slot >= static_cast<int>(bar.size()) || bar[slot].isEmpty()) {
-        return 0;
-    }
-    const auto& action = bar[slot];
-    switch (action.type) {
-        case game::ActionBarSlot::SPELL:
-            lua_pushstring(L, "spell");
-            lua_pushnumber(L, action.id);
-            lua_pushstring(L, "spell");
-            return 3;
-        case game::ActionBarSlot::ITEM:
-            lua_pushstring(L, "item");
-            lua_pushnumber(L, action.id);
-            lua_pushstring(L, "item");
-            return 3;
-        case game::ActionBarSlot::MACRO:
-            lua_pushstring(L, "macro");
-            lua_pushnumber(L, action.id);
-            lua_pushstring(L, "macro");
-            return 3;
-        default:
-            return 0;
-    }
-}
-
-// GetActionCount(slot) → count (item stack count or 0)
-static int lua_GetActionCount(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnZero(L); }
-    int slot = static_cast<int>(luaL_checknumber(L, 1)) - 1;
-    const auto& bar = gh->getActionBar();
-    if (slot < 0 || slot >= static_cast<int>(bar.size()) || bar[slot].isEmpty()) {
-        lua_pushnumber(L, 0);
-        return 1;
-    }
-    const auto& action = bar[slot];
-    if (action.type == game::ActionBarSlot::ITEM && action.id != 0) {
-        // Count items across backpack + bags
-        uint32_t count = 0;
-        const auto& inv = gh->getInventory();
-        for (int i = 0; i < inv.getBackpackSize(); ++i) {
-            const auto& s = inv.getBackpackSlot(i);
-            if (!s.empty() && s.item.itemId == action.id)
-                count += (s.item.stackCount > 0 ? s.item.stackCount : 1);
-        }
-        for (int b = 0; b < game::Inventory::NUM_BAG_SLOTS; ++b) {
-            int bagSize = inv.getBagSize(b);
-            for (int i = 0; i < bagSize; ++i) {
-                const auto& s = inv.getBagSlot(b, i);
-                if (!s.empty() && s.item.itemId == action.id)
-                    count += (s.item.stackCount > 0 ? s.item.stackCount : 1);
-            }
-        }
-        lua_pushnumber(L, count);
-    } else {
-        lua_pushnumber(L, 0);
-    }
-    return 1;
-}
-
-// GetActionCooldown(slot) → start, duration, enable
-static int lua_GetActionCooldown(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushnumber(L, 0); lua_pushnumber(L, 0); lua_pushnumber(L, 1); return 3; }
-    int slot = static_cast<int>(luaL_checknumber(L, 1)) - 1;
-    const auto& bar = gh->getActionBar();
-    if (slot < 0 || slot >= static_cast<int>(bar.size()) || bar[slot].isEmpty()) {
-        lua_pushnumber(L, 0);
-        lua_pushnumber(L, 0);
-        lua_pushnumber(L, 1);
-        return 3;
-    }
-    const auto& action = bar[slot];
-    if (action.cooldownRemaining > 0.0f) {
-        // WoW returns GetTime()-based start time; approximate
-        double now = 0;
-        lua_getglobal(L, "GetTime");
-        if (lua_isfunction(L, -1)) {
-            lua_call(L, 0, 1);
-            now = lua_tonumber(L, -1);
-            lua_pop(L, 1);
-        } else {
-            lua_pop(L, 1);
-        }
-        double start = now - (action.cooldownTotal - action.cooldownRemaining);
-        lua_pushnumber(L, start);
-        lua_pushnumber(L, action.cooldownTotal);
-        lua_pushnumber(L, 1);
-    } else if (action.type == game::ActionBarSlot::SPELL && gh->isGCDActive()) {
-        // No individual cooldown but GCD is active — show GCD sweep
-        float gcdRem = gh->getGCDRemaining();
-        float gcdTotal = gh->getGCDTotal();
-        double now = 0;
-        lua_getglobal(L, "GetTime");
-        if (lua_isfunction(L, -1)) { lua_call(L, 0, 1); now = lua_tonumber(L, -1); lua_pop(L, 1); }
-        else lua_pop(L, 1);
-        double elapsed = gcdTotal - gcdRem;
-        lua_pushnumber(L, now - elapsed);
-        lua_pushnumber(L, gcdTotal);
-        lua_pushnumber(L, 1);
-    } else {
-        lua_pushnumber(L, 0);
-        lua_pushnumber(L, 0);
-        lua_pushnumber(L, 1);
-    }
-    return 3;
-}
-
-// UseAction(slot, checkCursor, onSelf) — activate action bar slot (1-indexed)
-static int lua_UseAction(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    int slot = static_cast<int>(luaL_checknumber(L, 1)) - 1;
-    const auto& bar = gh->getActionBar();
-    if (slot < 0 || slot >= static_cast<int>(bar.size()) || bar[slot].isEmpty()) return 0;
-    const auto& action = bar[slot];
-    if (action.type == game::ActionBarSlot::SPELL && action.isReady()) {
-        uint64_t target = gh->hasTarget() ? gh->getTargetGuid() : 0;
-        gh->castSpell(action.id, target);
-    } else if (action.type == game::ActionBarSlot::ITEM && action.id != 0) {
-        gh->useItemById(action.id);
-    }
-    // Macro execution requires GameScreen context; not available from pure Lua API
-    return 0;
-}
-
-// --- Cursor / Drag-Drop System ---
-// Tracks what the player is "holding" on the cursor (spell, item, action).
-
-
-static int lua_ClearCursor(lua_State* L) {
-    (void)L;
-    s_cursorType = CursorType::NONE;
-    s_cursorId = 0;
-    s_cursorSlot = 0;
-    s_cursorBag = -1;
-    return 0;
-}
-
-static int lua_GetCursorInfo(lua_State* L) {
-    switch (s_cursorType) {
-        case CursorType::SPELL:
-            lua_pushstring(L, "spell");
-            lua_pushnumber(L, 0);          // bookSlotIndex
-            lua_pushstring(L, "spell");    // bookType
-            lua_pushnumber(L, s_cursorId); // spellId
-            return 4;
-        case CursorType::ITEM:
-            lua_pushstring(L, "item");
-            lua_pushnumber(L, s_cursorId);
-            return 2;
-        case CursorType::ACTION:
-            lua_pushstring(L, "action");
-            lua_pushnumber(L, s_cursorSlot);
-            return 2;
-        default:
-            return 0;
-    }
-}
-
-static int lua_CursorHasItem(lua_State* L) {
-    lua_pushboolean(L, s_cursorType == CursorType::ITEM ? 1 : 0);
-    return 1;
-}
-
-static int lua_CursorHasSpell(lua_State* L) {
-    lua_pushboolean(L, s_cursorType == CursorType::SPELL ? 1 : 0);
-    return 1;
-}
-
-// PickupAction(slot) — picks up an action from the action bar
-static int lua_PickupAction(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    int slot = static_cast<int>(luaL_checknumber(L, 1));
-    const auto& bar = gh->getActionBar();
-    if (slot < 1 || slot > static_cast<int>(bar.size())) return 0;
-    const auto& action = bar[slot - 1];
-    if (action.isEmpty()) {
-        // Empty slot — if cursor has something, place it
-        if (s_cursorType == CursorType::SPELL && s_cursorId != 0) {
-            gh->setActionBarSlot(slot - 1, game::ActionBarSlot::SPELL, s_cursorId);
-            s_cursorType = CursorType::NONE;
-            s_cursorId = 0;
-        }
-    } else {
-        // Pick up existing action
-        s_cursorType = (action.type == game::ActionBarSlot::SPELL) ? CursorType::SPELL :
-                       (action.type == game::ActionBarSlot::ITEM)  ? CursorType::ITEM :
-                       CursorType::ACTION;
-        s_cursorId = action.id;
-        s_cursorSlot = slot;
-    }
-    return 0;
-}
-
-// PlaceAction(slot) — places cursor content into an action bar slot
-static int lua_PlaceAction(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    int slot = static_cast<int>(luaL_checknumber(L, 1));
-    if (slot < 1 || slot > static_cast<int>(gh->getActionBar().size())) return 0;
-    if (s_cursorType == CursorType::SPELL && s_cursorId != 0) {
-        gh->setActionBarSlot(slot - 1, game::ActionBarSlot::SPELL, s_cursorId);
-    } else if (s_cursorType == CursorType::ITEM && s_cursorId != 0) {
-        gh->setActionBarSlot(slot - 1, game::ActionBarSlot::ITEM, s_cursorId);
-    }
-    s_cursorType = CursorType::NONE;
-    s_cursorId = 0;
-    return 0;
-}
-
-// PickupSpell(bookSlot, bookType) — picks up a spell from the spellbook
-static int lua_PickupSpell(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    int slot = static_cast<int>(luaL_checknumber(L, 1));
-    const auto& tabs = gh->getSpellBookTabs();
-    int idx = slot;
-    for (const auto& tab : tabs) {
-        if (idx <= static_cast<int>(tab.spellIds.size())) {
-            s_cursorType = CursorType::SPELL;
-            s_cursorId = tab.spellIds[idx - 1];
-            return 0;
-        }
-        idx -= static_cast<int>(tab.spellIds.size());
-    }
-    return 0;
-}
-
-// PickupSpellBookItem(bookSlot, bookType) — alias for PickupSpell
-static int lua_PickupSpellBookItem(lua_State* L) {
-    return lua_PickupSpell(L);
-}
-
-// PickupContainerItem(bag, slot) — picks up an item from a bag
-static int lua_PickupContainerItem(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    int bag = static_cast<int>(luaL_checknumber(L, 1));
-    int slot = static_cast<int>(luaL_checknumber(L, 2));
-    const auto& inv = gh->getInventory();
-    const game::ItemSlot* itemSlot = nullptr;
-    if (bag == 0 && slot >= 1 && slot <= inv.getBackpackSize()) {
-        itemSlot = &inv.getBackpackSlot(slot - 1);
-    } else if (bag >= 1 && bag <= 4) {
-        int bagSize = inv.getBagSize(bag - 1);
-        if (slot >= 1 && slot <= bagSize) {
-            itemSlot = &inv.getBagSlot(bag - 1, slot - 1);
-        }
-    }
-    if (itemSlot && !itemSlot->empty()) {
-        s_cursorType = CursorType::ITEM;
-        s_cursorId = itemSlot->item.itemId;
-        s_cursorBag = bag;
-        s_cursorSlot = slot;
-    }
-    return 0;
-}
-
-// PickupInventoryItem(slot) — picks up an equipped item
-static int lua_PickupInventoryItem(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    int slot = static_cast<int>(luaL_checknumber(L, 1));
-    if (slot < 1 || slot > 19) return 0;
-    const auto& inv = gh->getInventory();
-    const auto& eq = inv.getEquipSlot(static_cast<game::EquipSlot>(slot - 1));
-    if (!eq.empty()) {
-        s_cursorType = CursorType::ITEM;
-        s_cursorId = eq.item.itemId;
-        s_cursorSlot = slot;
-        s_cursorBag = -1;
-    }
-    return 0;
-}
-
-// DeleteCursorItem() — destroys the item on cursor
-static int lua_DeleteCursorItem(lua_State* L) {
-    (void)L;
-    s_cursorType = CursorType::NONE;
-    s_cursorId = 0;
-    return 0;
-}
-
-// AutoEquipCursorItem() — equip item from cursor
-static int lua_AutoEquipCursorItem(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (gh && s_cursorType == CursorType::ITEM && s_cursorId != 0) {
-        gh->useItemById(s_cursorId);
-    }
-    s_cursorType = CursorType::NONE;
-    s_cursorId = 0;
-    return 0;
-}
-
-// --- Frame System ---
-// Minimal WoW-compatible frame objects with RegisterEvent/SetScript/GetScript.
-// Frames are Lua tables with a metatable that provides methods.
-
-// Frame method: frame:RegisterEvent("EVENT")
-
-static int lua_IsShiftKeyDown(lua_State* L) {
-    lua_pushboolean(L, ImGui::GetIO().KeyShift ? 1 : 0);
-    return 1;
-}
-static int lua_IsControlKeyDown(lua_State* L) {
-    lua_pushboolean(L, ImGui::GetIO().KeyCtrl ? 1 : 0);
-    return 1;
-}
-static int lua_IsAltKeyDown(lua_State* L) {
-    lua_pushboolean(L, ImGui::GetIO().KeyAlt ? 1 : 0);
-    return 1;
-}
-
-// IsModifiedClick(action) → boolean
-// Checks if a modifier key combo matches a named click action.
-// Common actions: "CHATLINK" (shift-click), "DRESSUP" (ctrl-click),
-//                 "SPLITSTACK" (shift-click), "SELFCAST" (alt-click)
-static int lua_IsModifiedClick(lua_State* L) {
-    const char* action = luaL_optstring(L, 1, "");
-    std::string act(action);
-    for (char& c : act) c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
-    const auto& io = ImGui::GetIO();
-    bool result = false;
-    if (act == "CHATLINK" || act == "SPLITSTACK")
-        result = io.KeyShift;
-    else if (act == "DRESSUP" || act == "COMPAREITEMS")
-        result = io.KeyCtrl;
-    else if (act == "SELFCAST" || act == "FOCUSCAST")
-        result = io.KeyAlt;
-    else if (act == "STICKYCAMERA")
-        result = io.KeyCtrl;
-    else
-        result = io.KeyShift; // Default: shift for unknown actions
-    lua_pushboolean(L, result ? 1 : 0);
-    return 1;
-}
-
-// GetModifiedClick(action) → key name ("SHIFT", "CTRL", "ALT", "NONE")
-static int lua_GetModifiedClick(lua_State* L) {
-    const char* action = luaL_optstring(L, 1, "");
-    std::string act(action);
-    for (char& c : act) c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
-    if (act == "CHATLINK" || act == "SPLITSTACK")
-        lua_pushstring(L, "SHIFT");
-    else if (act == "DRESSUP" || act == "COMPAREITEMS")
-        lua_pushstring(L, "CTRL");
-    else if (act == "SELFCAST" || act == "FOCUSCAST")
-        lua_pushstring(L, "ALT");
-    else
-        lua_pushstring(L, "SHIFT");
-    return 1;
-}
-static int lua_SetModifiedClick(lua_State* L) { (void)L; return 0; }
-
-// --- Keybinding API ---
-// Maps WoW binding names like "ACTIONBUTTON1" to key display strings like "1"
-
-// GetBindingKey(command) → key1, key2 (or nil)
-static int lua_GetBindingKey(lua_State* L) {
-    const char* cmd = luaL_checkstring(L, 1);
-    std::string command(cmd);
-    // Return intuitive default bindings for action buttons
-    if (command.find("ACTIONBUTTON") == 0) {
-        std::string num = command.substr(12);
-        int n = 0;
-        try { n = std::stoi(num); } catch(...) {}
-        if (n >= 1 && n <= 9) {
-            lua_pushstring(L, num.c_str());
-            return 1;
-        } else if (n == 10) {
-            lua_pushstring(L, "0");
-            return 1;
-        } else if (n == 11) {
-            lua_pushstring(L, "-");
-            return 1;
-        } else if (n == 12) {
-            lua_pushstring(L, "=");
-            return 1;
-        }
-    }
-    lua_pushnil(L);
-    return 1;
-}
-
-// GetBindingAction(key) → command (or nil)
-static int lua_GetBindingAction(lua_State* L) {
-    const char* key = luaL_checkstring(L, 1);
-    std::string k(key);
-    // Simple reverse mapping for number keys
-    if (k.size() == 1 && k[0] >= '1' && k[0] <= '9') {
-        lua_pushstring(L, ("ACTIONBUTTON" + k).c_str());
-        return 1;
-    } else if (k == "0") {
-        lua_pushstring(L, "ACTIONBUTTON10");
-        return 1;
-    }
-    lua_pushnil(L);
-    return 1;
-}
-
-static int lua_GetNumBindings(lua_State* L) { return luaReturnZero(L); }
-static int lua_GetBinding(lua_State* L) { (void)L; lua_pushnil(L); return 1; }
-static int lua_SetBinding(lua_State* L) { (void)L; return 0; }
-static int lua_SaveBindings(lua_State* L) { (void)L; return 0; }
-static int lua_SetOverrideBindingClick(lua_State* L) { (void)L; return 0; }
-static int lua_ClearOverrideBindings(lua_State* L) { (void)L; return 0; }
-
-// Frame methods: SetPoint, SetSize, SetWidth, SetHeight, GetWidth, GetHeight, GetCenter, SetAlpha, GetAlpha
-
-void registerActionLuaAPI(lua_State* L) {
-    static const struct { const char* name; lua_CFunction func; } api[] = {
-                {"HasAction",           lua_HasAction},
-                {"GetActionTexture",    lua_GetActionTexture},
-                {"IsCurrentAction",     lua_IsCurrentAction},
-                {"IsUsableAction",      lua_IsUsableAction},
-                {"IsActionInRange",     lua_IsActionInRange},
-                {"GetActionInfo",       lua_GetActionInfo},
-                {"GetActionCount",      lua_GetActionCount},
-                {"GetActionCooldown",   lua_GetActionCooldown},
-                {"UseAction",           lua_UseAction},
-                {"PickupAction",        lua_PickupAction},
-                {"PlaceAction",         lua_PlaceAction},
-                {"PickupSpell",         lua_PickupSpell},
-                {"PickupSpellBookItem", lua_PickupSpellBookItem},
-                {"PickupContainerItem", lua_PickupContainerItem},
-                {"PickupInventoryItem", lua_PickupInventoryItem},
-                {"ClearCursor",         lua_ClearCursor},
-                {"GetCursorInfo",       lua_GetCursorInfo},
-                {"CursorHasItem",       lua_CursorHasItem},
-                {"CursorHasSpell",      lua_CursorHasSpell},
-                {"DeleteCursorItem",    lua_DeleteCursorItem},
-                {"AutoEquipCursorItem", lua_AutoEquipCursorItem},
-                {"IsShiftKeyDown",      lua_IsShiftKeyDown},
-                {"IsControlKeyDown",    lua_IsControlKeyDown},
-                {"IsAltKeyDown",        lua_IsAltKeyDown},
-                {"IsModifiedClick",     lua_IsModifiedClick},
-                {"GetModifiedClick",    lua_GetModifiedClick},
-                {"SetModifiedClick",    lua_SetModifiedClick},
-                {"GetBindingKey",       lua_GetBindingKey},
-                {"GetBindingAction",    lua_GetBindingAction},
-                {"GetNumBindings",      lua_GetNumBindings},
-                {"GetBinding",          lua_GetBinding},
-                {"SetBinding",          lua_SetBinding},
-                {"SaveBindings",        lua_SaveBindings},
-                {"SetOverrideBindingClick", lua_SetOverrideBindingClick},
-                {"ClearOverrideBindings", lua_ClearOverrideBindings},
-                {"GetActionBarPage", [](lua_State* L) -> int {
-            // Return current action bar page (1-6)
-            lua_getglobal(L, "__WoweeActionBarPage");
-            if (lua_isnil(L, -1)) { lua_pop(L, 1); lua_pushnumber(L, 1); }
-            return 1;
-        }},
-                {"ChangeActionBarPage", [](lua_State* L) -> int {
-            int page = static_cast<int>(luaL_checknumber(L, 1));
-            if (page < 1) page = 1;
-            if (page > 6) page = 6;
-            lua_pushnumber(L, page);
-            lua_setglobal(L, "__WoweeActionBarPage");
-            // Fire ACTIONBAR_PAGE_CHANGED via the frame event system
-            lua_getglobal(L, "__WoweeEvents");
-            if (!lua_isnil(L, -1)) {
-                lua_getfield(L, -1, "ACTIONBAR_PAGE_CHANGED");
-                if (!lua_isnil(L, -1)) {
-                    int n = static_cast<int>(lua_objlen(L, -1));
-                    for (int i = 1; i <= n; i++) {
-                        lua_rawgeti(L, -1, i);
-                        if (lua_isfunction(L, -1)) {
-                            lua_pushstring(L, "ACTIONBAR_PAGE_CHANGED");
-                            if (lua_pcall(L, 1, 0, 0) != 0) {
-                                LOG_ERROR("LuaEngine: ACTIONBAR_PAGE_CHANGED handler error: ",
-                                          lua_tostring(L, -1) ? lua_tostring(L, -1) : "(unknown)");
-                                lua_pop(L, 1);
-                            }
-                        } else lua_pop(L, 1);
-                    }
-                }
-                lua_pop(L, 1);
-            }
-            lua_pop(L, 1);
-            return 0;
-        }},
-                {"HasPetUI", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            lua_pushboolean(L, gh && gh->hasPet() ? 1 : 0);
-            return 1;
-        }},
-                {"GetPetActionInfo", [](lua_State* L) -> int {
-            // GetPetActionInfo(index) → name, subtext, texture, isToken, isActive, autoCastAllowed, autoCastEnabled
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            if (!gh || index < 1 || index > game::GameHandler::PET_ACTION_BAR_SLOTS) {
-                return luaReturnNil(L);
-            }
-            uint32_t packed = gh->getPetActionSlot(index - 1);
-            uint32_t spellId = packed & 0x00FFFFFF;
-            uint8_t actionType = static_cast<uint8_t>((packed >> 24) & 0xFF);
-            if (spellId == 0) { return luaReturnNil(L); }
-            const std::string& name = gh->getSpellName(spellId);
-            std::string iconPath = gh->getSpellIconPath(spellId);
-            lua_pushstring(L, name.empty() ? "Unknown" : name.c_str()); // name
-            lua_pushstring(L, "");                                       // subtext
-            lua_pushstring(L, iconPath.empty() ? "Interface\\Icons\\INV_Misc_QuestionMark" : iconPath.c_str()); // texture
-            lua_pushboolean(L, 0);                                       // isToken
-            lua_pushboolean(L, (actionType & 0xC0) != 0 ? 1 : 0);      // isActive
-            lua_pushboolean(L, 1);                                       // autoCastAllowed
-            lua_pushboolean(L, gh->isPetSpellAutocast(spellId) ? 1 : 0); // autoCastEnabled
-            return 7;
-        }},
-                {"GetPetActionCooldown", [](lua_State* L) -> int {
-            lua_pushnumber(L, 0); lua_pushnumber(L, 0); lua_pushnumber(L, 1);
-            return 3;
-        }},
-                {"PetAttack", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh && gh->hasPet() && gh->hasTarget())
-                gh->sendPetAction(0x00000007 | (2u << 24), gh->getTargetGuid()); // CMD_ATTACK
-            return 0;
-        }},
-                {"PetFollow", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh && gh->hasPet())
-                gh->sendPetAction(0x00000007 | (1u << 24), 0); // CMD_FOLLOW
-            return 0;
-        }},
-                {"PetWait", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh && gh->hasPet())
-                gh->sendPetAction(0x00000007 | (0u << 24), 0); // CMD_STAY
-            return 0;
-        }},
-                {"PetPassiveMode", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh && gh->hasPet())
-                gh->sendPetAction(0x00000007 | (0u << 16), 0); // REACT_PASSIVE
-            return 0;
-        }},
-                {"CastPetAction", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            if (!gh || !gh->hasPet() || index < 1 || index > game::GameHandler::PET_ACTION_BAR_SLOTS) return 0;
-            uint32_t packed = gh->getPetActionSlot(index - 1);
-            uint32_t spellId = packed & 0x00FFFFFF;
-            if (spellId != 0) {
-                uint64_t target = gh->hasTarget() ? gh->getTargetGuid() : gh->getPetGuid();
-                gh->sendPetAction(packed, target);
-            }
-            return 0;
-        }},
-                {"TogglePetAutocast", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            if (!gh || !gh->hasPet() || index < 1 || index > game::GameHandler::PET_ACTION_BAR_SLOTS) return 0;
-            uint32_t packed = gh->getPetActionSlot(index - 1);
-            uint32_t spellId = packed & 0x00FFFFFF;
-            if (spellId != 0) gh->togglePetSpellAutocast(spellId);
-            return 0;
-        }},
-                {"PetDismiss", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh && gh->hasPet())
-                gh->sendPetAction(0x00000007 | (3u << 24), 0); // CMD_DISMISS
-            return 0;
-        }},
-                {"IsPetAttackActive", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            lua_pushboolean(L, gh && gh->getPetCommand() == 2 ? 1 : 0); // 2=attack
-            return 1;
-        }},
-                {"PetDefensiveMode", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh && gh->hasPet())
-                gh->sendPetAction(0x00000007 | (1u << 16), 0); // REACT_DEFENSIVE
-            return 0;
-        }},
-    };
-    for (const auto& [name, func] : api) {
-        lua_pushcfunction(L, func);
-        lua_setglobal(L, name);
-    }
-}
-
-} // namespace wowee::addons
diff --git a/src/addons/lua_engine.cpp b/src/addons/lua_engine.cpp
deleted file mode 100644
index b8afa3e0..00000000
--- a/src/addons/lua_engine.cpp
+++ /dev/null
@@ -1,1742 +0,0 @@
-#include "addons/lua_engine.hpp"
-#include "addons/lua_api_helpers.hpp"
-#include "addons/lua_api_registrations.hpp"
-#include "addons/toc_parser.hpp"
-#include "core/window.hpp"
-#include <imgui.h>
-#include <fstream>
-#include <filesystem>
-
-extern "C" {
-#include <lua.h>
-#include <lauxlib.h>
-#include <lualib.h>
-}
-
-namespace wowee::addons {
-
-static int lua_wow_print(lua_State* L) {
-    int nargs = lua_gettop(L);
-    std::string result;
-    for (int i = 1; i <= nargs; i++) {
-        if (i > 1) result += '\t';
-        // Lua 5.1: use lua_tostring (luaL_tolstring is 5.3+)
-        if (lua_isstring(L, i) || lua_isnumber(L, i)) {
-            const char* s = lua_tostring(L, i);
-            if (s) result += s;
-        } else if (lua_isboolean(L, i)) {
-            result += lua_toboolean(L, i) ? "true" : "false";
-        } else if (lua_isnil(L, i)) {
-            result += "nil";
-        } else {
-            result += lua_typename(L, lua_type(L, i));
-        }
-    }
-
-    auto* gh = getGameHandler(L);
-    if (gh) {
-        game::MessageChatData msg;
-        msg.type = game::ChatType::SYSTEM;
-        msg.language = game::ChatLanguage::UNIVERSAL;
-        msg.message = result;
-        gh->addLocalChatMessage(msg);
-    }
-    LOG_INFO("[Lua] ", result);
-    return 0;
-}
-
-// WoW-compatible message() — same as print for now
-static int lua_wow_message(lua_State* L) {
-    return lua_wow_print(L);
-}
-
-// Helper: resolve WoW unit IDs to GUID
-// Read UNIT_FIELD_TARGET_LO/HI from an entity's update fields to get what it's targeting
-
-// --- Frame system functions ---
-
-static int lua_Frame_RegisterEvent(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);  // self
-    const char* eventName = luaL_checkstring(L, 2);
-
-    // Get frame's registered events table (create if needed)
-    lua_getfield(L, 1, "__events");
-    if (lua_isnil(L, -1)) {
-        lua_pop(L, 1);
-        lua_newtable(L);
-        lua_pushvalue(L, -1);
-        lua_setfield(L, 1, "__events");
-    }
-    lua_pushboolean(L, 1);
-    lua_setfield(L, -2, eventName);
-    lua_pop(L, 1);
-
-    // Also register in global __WoweeFrameEvents for dispatch
-    lua_getglobal(L, "__WoweeFrameEvents");
-    if (lua_isnil(L, -1)) {
-        lua_pop(L, 1);
-        lua_newtable(L);
-        lua_pushvalue(L, -1);
-        lua_setglobal(L, "__WoweeFrameEvents");
-    }
-    lua_getfield(L, -1, eventName);
-    if (lua_isnil(L, -1)) {
-        lua_pop(L, 1);
-        lua_newtable(L);
-        lua_pushvalue(L, -1);
-        lua_setfield(L, -3, eventName);
-    }
-    // Append frame reference
-    int len = static_cast<int>(lua_objlen(L, -1));
-    lua_pushvalue(L, 1);  // push frame
-    lua_rawseti(L, -2, len + 1);
-    lua_pop(L, 2);  // pop list + __WoweeFrameEvents
-    return 0;
-}
-
-// Frame method: frame:UnregisterEvent("EVENT")
-static int lua_Frame_UnregisterEvent(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    const char* eventName = luaL_checkstring(L, 2);
-
-    // Remove from frame's own events
-    lua_getfield(L, 1, "__events");
-    if (lua_istable(L, -1)) {
-        lua_pushnil(L);
-        lua_setfield(L, -2, eventName);
-    }
-    lua_pop(L, 1);
-    return 0;
-}
-
-// Frame method: frame:SetScript("handler", func)
-static int lua_Frame_SetScript(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    const char* scriptType = luaL_checkstring(L, 2);
-    // arg 3 can be function or nil
-    lua_getfield(L, 1, "__scripts");
-    if (lua_isnil(L, -1)) {
-        lua_pop(L, 1);
-        lua_newtable(L);
-        lua_pushvalue(L, -1);
-        lua_setfield(L, 1, "__scripts");
-    }
-    lua_pushvalue(L, 3);
-    lua_setfield(L, -2, scriptType);
-    lua_pop(L, 1);
-
-    // Track frames with OnUpdate in __WoweeOnUpdateFrames
-    if (strcmp(scriptType, "OnUpdate") == 0) {
-        lua_getglobal(L, "__WoweeOnUpdateFrames");
-        if (!lua_istable(L, -1)) { lua_pop(L, 1); return 0; }
-        if (lua_isfunction(L, 3)) {
-            // Add frame to the list
-            int len = static_cast<int>(lua_objlen(L, -1));
-            lua_pushvalue(L, 1);
-            lua_rawseti(L, -2, len + 1);
-        }
-        lua_pop(L, 1);
-    }
-    return 0;
-}
-
-// Frame method: frame:GetScript("handler")
-static int lua_Frame_GetScript(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    const char* scriptType = luaL_checkstring(L, 2);
-    lua_getfield(L, 1, "__scripts");
-    if (lua_istable(L, -1)) {
-        lua_getfield(L, -1, scriptType);
-    } else {
-        lua_pushnil(L);
-    }
-    return 1;
-}
-
-// Frame method: frame:GetName()
-static int lua_Frame_GetName(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    lua_getfield(L, 1, "__name");
-    return 1;
-}
-
-// Frame method: frame:Show() / frame:Hide() / frame:IsShown() / frame:IsVisible()
-static int lua_Frame_Show(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    lua_pushboolean(L, 1);
-    lua_setfield(L, 1, "__visible");
-    return 0;
-}
-static int lua_Frame_Hide(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    lua_pushboolean(L, 0);
-    lua_setfield(L, 1, "__visible");
-    return 0;
-}
-static int lua_Frame_IsShown(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    lua_getfield(L, 1, "__visible");
-    lua_pushboolean(L, lua_toboolean(L, -1));
-    return 1;
-}
-
-// Frame method: frame:CreateTexture(name, layer) → texture stub
-static int lua_Frame_CreateTexture(lua_State* L) {
-    lua_newtable(L);
-    // Add noop methods for common texture operations
-    luaL_dostring(L,
-        "return function(t) "
-        "function t:SetTexture() end "
-        "function t:SetTexCoord() end "
-        "function t:SetVertexColor() end "
-        "function t:SetAllPoints() end "
-        "function t:SetPoint() end "
-        "function t:SetSize() end "
-        "function t:SetWidth() end "
-        "function t:SetHeight() end "
-        "function t:Show() end "
-        "function t:Hide() end "
-        "function t:SetAlpha() end "
-        "function t:GetTexture() return '' end "
-        "function t:SetDesaturated() end "
-        "function t:SetBlendMode() end "
-        "function t:SetDrawLayer() end "
-        "end");
-    lua_pushvalue(L, -2); // push the table
-    lua_call(L, 1, 0);    // call the function with the table
-    return 1;
-}
-
-// Frame method: frame:CreateFontString(name, layer, template) → fontstring stub
-static int lua_Frame_CreateFontString(lua_State* L) {
-    lua_newtable(L);
-    luaL_dostring(L,
-        "return function(fs) "
-        "fs._text = '' "
-        "function fs:SetText(t) self._text = t or '' end "
-        "function fs:GetText() return self._text end "
-        "function fs:SetFont() end "
-        "function fs:SetFontObject() end "
-        "function fs:SetTextColor() end "
-        "function fs:SetJustifyH() end "
-        "function fs:SetJustifyV() end "
-        "function fs:SetPoint() end "
-        "function fs:SetAllPoints() end "
-        "function fs:Show() end "
-        "function fs:Hide() end "
-        "function fs:SetAlpha() end "
-        "function fs:GetStringWidth() return 0 end "
-        "function fs:GetStringHeight() return 0 end "
-        "function fs:SetWordWrap() end "
-        "function fs:SetNonSpaceWrap() end "
-        "function fs:SetMaxLines() end "
-        "function fs:SetShadowOffset() end "
-        "function fs:SetShadowColor() end "
-        "function fs:SetWidth() end "
-        "function fs:SetHeight() end "
-        "end");
-    lua_pushvalue(L, -2);
-    lua_call(L, 1, 0);
-    return 1;
-}
-
-// GetFramerate() → fps
-static int lua_GetFramerate(lua_State* L) {
-    lua_pushnumber(L, static_cast<double>(ImGui::GetIO().Framerate));
-    return 1;
-}
-
-// GetCursorPosition() → x, y (screen coordinates, origin top-left)
-static int lua_GetCursorPosition(lua_State* L) {
-    const auto& io = ImGui::GetIO();
-    lua_pushnumber(L, io.MousePos.x);
-    lua_pushnumber(L, io.MousePos.y);
-    return 2;
-}
-
-// GetScreenWidth() → width
-static int lua_GetScreenWidth(lua_State* L) {
-    auto* svc = getLuaServices(L);
-    auto* window = svc ? svc->window : nullptr;
-    lua_pushnumber(L, window ? window->getWidth() : 1920);
-    return 1;
-}
-
-// GetScreenHeight() → height
-static int lua_GetScreenHeight(lua_State* L) {
-    auto* svc = getLuaServices(L);
-    auto* window = svc ? svc->window : nullptr;
-    lua_pushnumber(L, window ? window->getHeight() : 1080);
-    return 1;
-}
-
-// Modifier key state queries using ImGui IO
-
-static int lua_Frame_SetPoint(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    const char* point = luaL_optstring(L, 2, "CENTER");
-    // Store point info in frame table
-    lua_pushstring(L, point);
-    lua_setfield(L, 1, "__point");
-    // Optional x/y offsets (args 4,5 if relativeTo is given, or 3,4 if not)
-    double xOfs = 0, yOfs = 0;
-    if (lua_isnumber(L, 4)) { xOfs = lua_tonumber(L, 4); yOfs = lua_tonumber(L, 5); }
-    else if (lua_isnumber(L, 3)) { xOfs = lua_tonumber(L, 3); yOfs = lua_tonumber(L, 4); }
-    lua_pushnumber(L, xOfs);
-    lua_setfield(L, 1, "__xOfs");
-    lua_pushnumber(L, yOfs);
-    lua_setfield(L, 1, "__yOfs");
-    return 0;
-}
-
-static int lua_Frame_SetSize(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    double w = luaL_optnumber(L, 2, 0);
-    double h = luaL_optnumber(L, 3, 0);
-    lua_pushnumber(L, w);
-    lua_setfield(L, 1, "__width");
-    lua_pushnumber(L, h);
-    lua_setfield(L, 1, "__height");
-    return 0;
-}
-
-static int lua_Frame_SetWidth(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    lua_pushnumber(L, luaL_checknumber(L, 2));
-    lua_setfield(L, 1, "__width");
-    return 0;
-}
-
-static int lua_Frame_SetHeight(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    lua_pushnumber(L, luaL_checknumber(L, 2));
-    lua_setfield(L, 1, "__height");
-    return 0;
-}
-
-static int lua_Frame_GetWidth(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    lua_getfield(L, 1, "__width");
-    if (lua_isnil(L, -1)) { lua_pop(L, 1); lua_pushnumber(L, 0); }
-    return 1;
-}
-
-static int lua_Frame_GetHeight(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    lua_getfield(L, 1, "__height");
-    if (lua_isnil(L, -1)) { lua_pop(L, 1); lua_pushnumber(L, 0); }
-    return 1;
-}
-
-static int lua_Frame_GetCenter(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    lua_getfield(L, 1, "__xOfs");
-    double x = lua_isnumber(L, -1) ? lua_tonumber(L, -1) : 0;
-    lua_pop(L, 1);
-    lua_getfield(L, 1, "__yOfs");
-    double y = lua_isnumber(L, -1) ? lua_tonumber(L, -1) : 0;
-    lua_pop(L, 1);
-    lua_pushnumber(L, x);
-    lua_pushnumber(L, y);
-    return 2;
-}
-
-static int lua_Frame_SetAlpha(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    lua_pushnumber(L, luaL_checknumber(L, 2));
-    lua_setfield(L, 1, "__alpha");
-    return 0;
-}
-
-static int lua_Frame_GetAlpha(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    lua_getfield(L, 1, "__alpha");
-    if (lua_isnil(L, -1)) { lua_pop(L, 1); lua_pushnumber(L, 1.0); }
-    return 1;
-}
-
-static int lua_Frame_SetParent(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    if (lua_istable(L, 2) || lua_isnil(L, 2)) {
-        lua_pushvalue(L, 2);
-        lua_setfield(L, 1, "__parent");
-    }
-    return 0;
-}
-
-static int lua_Frame_GetParent(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    lua_getfield(L, 1, "__parent");
-    return 1;
-}
-
-// CreateFrame(frameType, name, parent, template)
-static int lua_CreateFrame(lua_State* L) {
-    const char* frameType = luaL_optstring(L, 1, "Frame");
-    const char* name = luaL_optstring(L, 2, nullptr);
-    (void)frameType; // All frame types use the same table structure for now
-
-    // Create the frame table
-    lua_newtable(L);
-
-    // Set frame name
-    if (name && *name) {
-        lua_pushstring(L, name);
-        lua_setfield(L, -2, "__name");
-        // Also set as a global so other addons can find it by name
-        lua_pushvalue(L, -1);
-        lua_setglobal(L, name);
-    }
-
-    // Set initial visibility
-    lua_pushboolean(L, 1);
-    lua_setfield(L, -2, "__visible");
-
-    // Apply frame metatable with methods
-    lua_getglobal(L, "__WoweeFrameMT");
-    lua_setmetatable(L, -2);
-
-    return 1;
-}
-
-// --- WoW Utility Functions ---
-
-// strsplit(delimiter, str) — WoW's string split
-
-LuaEngine::LuaEngine() = default;
-
-LuaEngine::~LuaEngine() {
-    shutdown();
-}
-
-bool LuaEngine::initialize() {
-    if (L_) return true;
-
-    L_ = luaL_newstate();
-    if (!L_) {
-        LOG_ERROR("LuaEngine: failed to create Lua state");
-        return false;
-    }
-
-    // Open safe standard libraries (no io, os, debug, package)
-    luaopen_base(L_);
-    luaopen_table(L_);
-    luaopen_string(L_);
-    luaopen_math(L_);
-
-    // Remove unsafe globals from base library
-    const char* unsafeGlobals[] = {
-        "dofile", "loadfile", "load", "collectgarbage", "newproxy", nullptr
-    };
-    for (const char** g = unsafeGlobals; *g; ++g) {
-        lua_pushnil(L_);
-        lua_setglobal(L_, *g);
-    }
-
-    registerCoreAPI();
-    registerEventAPI();
-
-    LOG_INFO("LuaEngine: initialized (Lua 5.1)");
-    return true;
-}
-
-void LuaEngine::shutdown() {
-    if (L_) {
-        lua_close(L_);
-        L_ = nullptr;
-        LOG_INFO("LuaEngine: shut down");
-    }
-}
-
-void LuaEngine::setGameHandler(game::GameHandler* handler) {
-    gameHandler_ = handler;
-    if (L_) {
-        lua_pushlightuserdata(L_, handler);
-        lua_setfield(L_, LUA_REGISTRYINDEX, "wowee_game_handler");
-    }
-}
-
-void LuaEngine::setLuaServices(const LuaServices& services) {
-    luaServices_ = services;
-    if (L_) {
-        lua_pushlightuserdata(L_, &luaServices_);
-        lua_setfield(L_, LUA_REGISTRYINDEX, "wowee_lua_services");
-    }
-}
-
-
-void LuaEngine::registerCoreAPI() {
-    // Override print() to go to chat
-    lua_pushcfunction(L_, lua_wow_print);
-    lua_setglobal(L_, "print");
-
-    // WoW API stubs
-    lua_pushcfunction(L_, lua_wow_message);
-    lua_setglobal(L_, "message");
-
-    // --- Per-domain Lua API registration ---
-    registerUnitLuaAPI(L_);
-    registerSpellLuaAPI(L_);
-    registerInventoryLuaAPI(L_);
-    registerQuestLuaAPI(L_);
-    registerSocialLuaAPI(L_);
-    registerSystemLuaAPI(L_);
-    registerActionLuaAPI(L_);
-
-    // WoW aliases
-    lua_getglobal(L_, "string");
-    lua_getfield(L_, -1, "format");
-    lua_setglobal(L_, "format");
-    lua_pop(L_, 1);  // pop string table
-
-    // tinsert/tremove aliases
-    lua_getglobal(L_, "table");
-    lua_getfield(L_, -1, "insert");
-    lua_setglobal(L_, "tinsert");
-    lua_getfield(L_, -1, "remove");
-    lua_setglobal(L_, "tremove");
-    lua_pop(L_, 1);  // pop table
-
-    // SlashCmdList table — addons register slash commands here
-    lua_newtable(L_);
-    lua_setglobal(L_, "SlashCmdList");
-
-    // Frame metatable with methods
-    lua_newtable(L_);  // metatable
-    lua_pushvalue(L_, -1);
-    lua_setfield(L_, -2, "__index"); // metatable.__index = metatable
-
-    static const struct luaL_Reg frameMethods[] = {
-        {"RegisterEvent",   lua_Frame_RegisterEvent},
-        {"UnregisterEvent", lua_Frame_UnregisterEvent},
-        {"SetScript",       lua_Frame_SetScript},
-        {"GetScript",       lua_Frame_GetScript},
-        {"GetName",         lua_Frame_GetName},
-        {"Show",            lua_Frame_Show},
-        {"Hide",            lua_Frame_Hide},
-        {"IsShown",         lua_Frame_IsShown},
-        {"IsVisible",       lua_Frame_IsShown}, // alias
-        {"SetPoint",        lua_Frame_SetPoint},
-        {"SetSize",         lua_Frame_SetSize},
-        {"SetWidth",        lua_Frame_SetWidth},
-        {"SetHeight",       lua_Frame_SetHeight},
-        {"GetWidth",        lua_Frame_GetWidth},
-        {"GetHeight",       lua_Frame_GetHeight},
-        {"GetCenter",       lua_Frame_GetCenter},
-        {"SetAlpha",        lua_Frame_SetAlpha},
-        {"GetAlpha",        lua_Frame_GetAlpha},
-        {"SetParent",       lua_Frame_SetParent},
-        {"GetParent",       lua_Frame_GetParent},
-        {"CreateTexture",   lua_Frame_CreateTexture},
-        {"CreateFontString", lua_Frame_CreateFontString},
-        {nullptr, nullptr}
-    };
-    for (const luaL_Reg* r = frameMethods; r->name; r++) {
-        lua_pushcfunction(L_, r->func);
-        lua_setfield(L_, -2, r->name);
-    }
-    lua_setglobal(L_, "__WoweeFrameMT");
-
-    // Add commonly called no-op frame methods to prevent addon errors
-    luaL_dostring(L_,
-        "local mt = __WoweeFrameMT\n"
-        "function mt:SetFrameLevel(level) self.__frameLevel = level end\n"
-        "function mt:GetFrameLevel() return self.__frameLevel or 1 end\n"
-        "function mt:SetFrameStrata(strata) self.__strata = strata end\n"
-        "function mt:GetFrameStrata() return self.__strata or 'MEDIUM' end\n"
-        "function mt:EnableMouse(enable) end\n"
-        "function mt:EnableMouseWheel(enable) end\n"
-        "function mt:SetMovable(movable) end\n"
-        "function mt:SetResizable(resizable) end\n"
-        "function mt:RegisterForDrag(...) end\n"
-        "function mt:SetClampedToScreen(clamped) end\n"
-        "function mt:SetBackdrop(backdrop) end\n"
-        "function mt:SetBackdropColor(...) end\n"
-        "function mt:SetBackdropBorderColor(...) end\n"
-        "function mt:ClearAllPoints() end\n"
-        "function mt:SetID(id) self.__id = id end\n"
-        "function mt:GetID() return self.__id or 0 end\n"
-        "function mt:SetScale(scale) self.__scale = scale end\n"
-        "function mt:GetScale() return self.__scale or 1.0 end\n"
-        "function mt:GetEffectiveScale() return self.__scale or 1.0 end\n"
-        "function mt:SetToplevel(top) end\n"
-        "function mt:Raise() end\n"
-        "function mt:Lower() end\n"
-        "function mt:GetLeft() return 0 end\n"
-        "function mt:GetRight() return 0 end\n"
-        "function mt:GetTop() return 0 end\n"
-        "function mt:GetBottom() return 0 end\n"
-        "function mt:GetNumPoints() return 0 end\n"
-        "function mt:GetPoint(n) return 'CENTER', nil, 'CENTER', 0, 0 end\n"
-        "function mt:SetHitRectInsets(...) end\n"
-        "function mt:RegisterForClicks(...) end\n"
-        "function mt:SetAttribute(name, value) self['attr_'..name] = value end\n"
-        "function mt:GetAttribute(name) return self['attr_'..name] end\n"
-        "function mt:HookScript(scriptType, fn)\n"
-        "    local orig = self.__scripts and self.__scripts[scriptType]\n"
-        "    if orig then\n"
-        "        self:SetScript(scriptType, function(...) orig(...); fn(...) end)\n"
-        "    else\n"
-        "        self:SetScript(scriptType, fn)\n"
-        "    end\n"
-        "end\n"
-        "function mt:SetMinResize(...) end\n"
-        "function mt:SetMaxResize(...) end\n"
-        "function mt:StartMoving() end\n"
-        "function mt:StopMovingOrSizing() end\n"
-        "function mt:IsMouseOver() return false end\n"
-        "function mt:GetObjectType() return 'Frame' end\n"
-    );
-
-    // CreateFrame function
-    lua_pushcfunction(L_, lua_CreateFrame);
-    lua_setglobal(L_, "CreateFrame");
-
-    // Cursor/screen/FPS functions
-    lua_pushcfunction(L_, lua_GetCursorPosition);
-    lua_setglobal(L_, "GetCursorPosition");
-    lua_pushcfunction(L_, lua_GetScreenWidth);
-    lua_setglobal(L_, "GetScreenWidth");
-    lua_pushcfunction(L_, lua_GetScreenHeight);
-    lua_setglobal(L_, "GetScreenHeight");
-    lua_pushcfunction(L_, lua_GetFramerate);
-    lua_setglobal(L_, "GetFramerate");
-
-    // Frame event dispatch table
-    lua_newtable(L_);
-    lua_setglobal(L_, "__WoweeFrameEvents");
-
-    // OnUpdate frame tracking table
-    lua_newtable(L_);
-    lua_setglobal(L_, "__WoweeOnUpdateFrames");
-
-    // C_Timer implementation via Lua (uses OnUpdate internally)
-    luaL_dostring(L_,
-        "C_Timer = {}\n"
-        "local timers = {}\n"
-        "local timerFrame = CreateFrame('Frame', '__WoweeTimerFrame')\n"
-        "timerFrame:SetScript('OnUpdate', function(self, elapsed)\n"
-        "    local i = 1\n"
-        "    while i <= #timers do\n"
-        "        timers[i].remaining = timers[i].remaining - elapsed\n"
-        "        if timers[i].remaining <= 0 then\n"
-        "            local cb = timers[i].callback\n"
-        "            table.remove(timers, i)\n"
-        "            cb()\n"
-        "        else\n"
-        "            i = i + 1\n"
-        "        end\n"
-        "    end\n"
-        "    if #timers == 0 then self:Hide() end\n"
-        "end)\n"
-        "timerFrame:Hide()\n"
-        "function C_Timer.After(seconds, callback)\n"
-        "    tinsert(timers, {remaining = seconds, callback = callback})\n"
-        "    timerFrame:Show()\n"
-        "end\n"
-        "function C_Timer.NewTicker(seconds, callback, iterations)\n"
-        "    local count = 0\n"
-        "    local maxIter = iterations or -1\n"
-        "    local ticker = {cancelled = false}\n"
-        "    local function tick()\n"
-        "        if ticker.cancelled then return end\n"
-        "        count = count + 1\n"
-        "        callback(ticker)\n"
-        "        if maxIter > 0 and count >= maxIter then return end\n"
-        "        C_Timer.After(seconds, tick)\n"
-        "    end\n"
-        "    C_Timer.After(seconds, tick)\n"
-        "    function ticker:Cancel() self.cancelled = true end\n"
-        "    return ticker\n"
-        "end\n"
-    );
-
-    // DEFAULT_CHAT_FRAME with AddMessage method (used by many addons)
-    luaL_dostring(L_,
-        "DEFAULT_CHAT_FRAME = {}\n"
-        "function DEFAULT_CHAT_FRAME:AddMessage(text, r, g, b)\n"
-        "    if r and g and b then\n"
-        "        local hex = format('|cff%02x%02x%02x', "
-        "            math.floor(r*255), math.floor(g*255), math.floor(b*255))\n"
-        "        print(hex .. tostring(text) .. '|r')\n"
-        "    else\n"
-        "        print(tostring(text))\n"
-        "    end\n"
-        "end\n"
-        "ChatFrame1 = DEFAULT_CHAT_FRAME\n"
-    );
-
-    // hooksecurefunc — hook a function to run additional code after it
-    luaL_dostring(L_,
-        "function hooksecurefunc(tblOrName, nameOrFunc, funcOrNil)\n"
-        "    local tbl, name, hook\n"
-        "    if type(tblOrName) == 'table' then\n"
-        "        tbl, name, hook = tblOrName, nameOrFunc, funcOrNil\n"
-        "    else\n"
-        "        tbl, name, hook = _G, tblOrName, nameOrFunc\n"
-        "    end\n"
-        "    local orig = tbl[name]\n"
-        "    if type(orig) ~= 'function' then return end\n"
-        "    tbl[name] = function(...)\n"
-        "        local r = {orig(...)}\n"
-        "        hook(...)\n"
-        "        return unpack(r)\n"
-        "    end\n"
-        "end\n"
-    );
-
-    // LibStub — universal library version management used by Ace3 and virtually all addon libs.
-    // This is the standard WoW LibStub implementation that addons embed/expect globally.
-    luaL_dostring(L_,
-        "local LibStub = LibStub or {}\n"
-        "LibStub.libs = LibStub.libs or {}\n"
-        "LibStub.minors = LibStub.minors or {}\n"
-        "function LibStub:NewLibrary(major, minor)\n"
-        "    assert(type(major) == 'string', 'LibStub:NewLibrary: bad argument #1 (string expected)')\n"
-        "    minor = assert(tonumber(minor or (type(minor) == 'string' and minor:match('(%d+)'))), 'LibStub:NewLibrary: bad argument #2 (number expected)')\n"
-        "    local oldMinor = self.minors[major]\n"
-        "    if oldMinor and oldMinor >= minor then return nil end\n"
-        "    local lib = self.libs[major] or {}\n"
-        "    self.libs[major] = lib\n"
-        "    self.minors[major] = minor\n"
-        "    return lib, oldMinor\n"
-        "end\n"
-        "function LibStub:GetLibrary(major, silent)\n"
-        "    if not self.libs[major] and not silent then\n"
-        "        error('Cannot find a library instance of \"' .. tostring(major) .. '\".')\n"
-        "    end\n"
-        "    return self.libs[major], self.minors[major]\n"
-        "end\n"
-        "function LibStub:IterateLibraries() return pairs(self.libs) end\n"
-        "setmetatable(LibStub, { __call = LibStub.GetLibrary })\n"
-        "_G['LibStub'] = LibStub\n"
-    );
-
-    // CallbackHandler-1.0 — minimal implementation for Ace3-based addons
-    luaL_dostring(L_,
-        "if LibStub then\n"
-        "  local CBH = LibStub:NewLibrary('CallbackHandler-1.0', 7)\n"
-        "  if CBH then\n"
-        "    CBH.mixins = { 'RegisterCallback', 'UnregisterCallback', 'UnregisterAllCallbacks', 'Fire' }\n"
-        "    function CBH:New(target, regName, unregName, unregAllName, onUsed)\n"
-        "      local registry = setmetatable({}, { __index = CBH })\n"
-        "      registry.callbacks = {}\n"
-        "      target = target or {}\n"
-        "      target[regName or 'RegisterCallback'] = function(self, event, method, ...)\n"
-        "        if not registry.callbacks[event] then registry.callbacks[event] = {} end\n"
-        "        local handler = type(method) == 'function' and method or self[method]\n"
-        "        registry.callbacks[event][self] = handler\n"
-        "      end\n"
-        "      target[unregName or 'UnregisterCallback'] = function(self, event)\n"
-        "        if registry.callbacks[event] then registry.callbacks[event][self] = nil end\n"
-        "      end\n"
-        "      target[unregAllName or 'UnregisterAllCallbacks'] = function(self)\n"
-        "        for event, handlers in pairs(registry.callbacks) do handlers[self] = nil end\n"
-        "      end\n"
-        "      registry.Fire = function(self, event, ...)\n"
-        "        if not self.callbacks[event] then return end\n"
-        "        for obj, handler in pairs(self.callbacks[event]) do\n"
-        "          handler(obj, event, ...)\n"
-        "        end\n"
-        "      end\n"
-        "      return registry\n"
-        "    end\n"
-        "  end\n"
-        "end\n"
-    );
-
-    // Noop stubs for commonly called functions that don't need implementation
-    luaL_dostring(L_,
-        "function SetDesaturation() end\n"
-        "function SetPortraitTexture() end\n"
-        "function StopSound() end\n"
-        "function UIParent_OnEvent() end\n"
-        "UIParent = CreateFrame('Frame', 'UIParent')\n"
-        "UIPanelWindows = {}\n"
-        "WorldFrame = CreateFrame('Frame', 'WorldFrame')\n"
-        // GameTooltip: global tooltip frame used by virtually all addons
-        "GameTooltip = CreateFrame('Frame', 'GameTooltip')\n"
-        "GameTooltip.__lines = {}\n"
-        "function GameTooltip:SetOwner(owner, anchor) self.__owner = owner; self.__anchor = anchor end\n"
-        "function GameTooltip:ClearLines() self.__lines = {} end\n"
-        "function GameTooltip:AddLine(text, r, g, b, wrap) table.insert(self.__lines, {text=text or '',r=r,g=g,b=b}) end\n"
-        "function GameTooltip:AddDoubleLine(l, r, lr, lg, lb, rr, rg, rb) table.insert(self.__lines, {text=(l or '')..'  '..(r or '')}) end\n"
-        "function GameTooltip:SetText(text, r, g, b) self.__lines = {{text=text or '',r=r,g=g,b=b}} end\n"
-        "function GameTooltip:GetItem()\n"
-        "    if self.__itemId and self.__itemId > 0 then\n"
-        "        local name = GetItemInfo(self.__itemId)\n"
-        "        local _, itemLink = GetItemInfo(self.__itemId)\n"
-        "        return name, itemLink or ('|cffffffff|Hitem:'..self.__itemId..':0|h['..tostring(name)..']|h|r')\n"
-        "    end\n"
-        "    return nil\n"
-        "end\n"
-        "function GameTooltip:GetSpell()\n"
-        "    if self.__spellId and self.__spellId > 0 then\n"
-        "        local name = GetSpellInfo(self.__spellId)\n"
-        "        return name, nil, self.__spellId\n"
-        "    end\n"
-        "    return nil\n"
-        "end\n"
-        "function GameTooltip:GetUnit() return nil end\n"
-        "function GameTooltip:NumLines() return #self.__lines end\n"
-        "function GameTooltip:GetText() return self.__lines[1] and self.__lines[1].text or '' end\n"
-        "function GameTooltip:SetUnitBuff(unit, index, filter)\n"
-        "    self:ClearLines()\n"
-        "    local name, rank, icon, count, debuffType, duration, expTime, caster, steal, consolidate, spellId = UnitBuff(unit, index, filter)\n"
-        "    if name then\n"
-        "        self:SetText(name, 1, 1, 1)\n"
-        "        if duration and duration > 0 then\n"
-        "            self:AddLine(string.format('%.0f sec remaining', expTime - GetTime()), 1, 1, 1)\n"
-        "        end\n"
-        "        self.__spellId = spellId\n"
-        "    end\n"
-        "end\n"
-        "function GameTooltip:SetUnitDebuff(unit, index, filter)\n"
-        "    self:ClearLines()\n"
-        "    local name, rank, icon, count, debuffType, duration, expTime, caster, steal, consolidate, spellId = UnitDebuff(unit, index, filter)\n"
-        "    if name then\n"
-        "        self:SetText(name, 1, 0, 0)\n"
-        "        if debuffType then self:AddLine(debuffType, 0.5, 0.5, 0.5) end\n"
-        "        self.__spellId = spellId\n"
-        "    end\n"
-        "end\n"
-        "function GameTooltip:SetHyperlink(link)\n"
-        "    self:ClearLines()\n"
-        "    if not link then return end\n"
-        "    local id = link:match('item:(%d+)')\n"
-        "    if id then\n"
-        "        _WoweePopulateItemTooltip(self, tonumber(id))\n"
-        "        return\n"
-        "    end\n"
-        "    id = link:match('spell:(%d+)')\n"
-        "    if id then\n"
-        "        self:SetSpellByID(tonumber(id))\n"
-        "        return\n"
-        "    end\n"
-        "end\n"
-        // Shared item tooltip builder using GetItemInfo return values
-        "function _WoweePopulateItemTooltip(self, itemId)\n"
-        "    local name, itemLink, quality, iLevel, reqLevel, class, subclass, maxStack, equipSlot, texture, sellPrice = GetItemInfo(itemId)\n"
-        "    if not name then return false end\n"
-        "    local qColors = {[0]={0.62,0.62,0.62},[1]={1,1,1},[2]={0.12,1,0},[3]={0,0.44,0.87},[4]={0.64,0.21,0.93},[5]={1,0.5,0},[6]={0.9,0.8,0.5},[7]={0,0.8,1}}\n"
-        "    local c = qColors[quality or 1] or {1,1,1}\n"
-        "    self:SetText(name, c[1], c[2], c[3])\n"
-        "    -- Item level for equipment\n"
-        "    if equipSlot and equipSlot ~= '' and iLevel and iLevel > 0 then\n"
-        "        self:AddLine('Item Level '..iLevel, 1, 0.82, 0)\n"
-        "    end\n"
-        "    -- Equip slot and subclass on same line\n"
-        "    if equipSlot and equipSlot ~= '' then\n"
-        "        local slotNames = {INVTYPE_HEAD='Head',INVTYPE_NECK='Neck',INVTYPE_SHOULDER='Shoulder',\n"
-        "            INVTYPE_CHEST='Chest',INVTYPE_WAIST='Waist',INVTYPE_LEGS='Legs',INVTYPE_FEET='Feet',\n"
-        "            INVTYPE_WRIST='Wrist',INVTYPE_HAND='Hands',INVTYPE_FINGER='Finger',\n"
-        "            INVTYPE_TRINKET='Trinket',INVTYPE_CLOAK='Back',INVTYPE_WEAPON='One-Hand',\n"
-        "            INVTYPE_SHIELD='Off Hand',INVTYPE_2HWEAPON='Two-Hand',INVTYPE_RANGED='Ranged',\n"
-        "            INVTYPE_WEAPONMAINHAND='Main Hand',INVTYPE_WEAPONOFFHAND='Off Hand',\n"
-        "            INVTYPE_HOLDABLE='Held In Off-Hand',INVTYPE_TABARD='Tabard',INVTYPE_ROBE='Chest'}\n"
-        "        local slotText = slotNames[equipSlot] or ''\n"
-        "        local subText = (subclass and subclass ~= '') and subclass or ''\n"
-        "        if slotText ~= '' or subText ~= '' then\n"
-        "            self:AddDoubleLine(slotText, subText, 1,1,1, 1,1,1)\n"
-        "        end\n"
-        "    elseif class and class ~= '' then\n"
-        "        self:AddLine(class, 1, 1, 1)\n"
-        "    end\n"
-        "    -- Fetch detailed stats from C side\n"
-        "    local data = _GetItemTooltipData(itemId)\n"
-        "    if data then\n"
-        "        -- Bind type\n"
-        "        if data.isHeroic then self:AddLine('Heroic', 0, 1, 0) end\n"
-        "        if data.isUnique then self:AddLine('Unique', 1, 1, 1)\n"
-        "        elseif data.isUniqueEquipped then self:AddLine('Unique-Equipped', 1, 1, 1) end\n"
-        "        if data.bindType == 1 then self:AddLine('Binds when picked up', 1, 1, 1)\n"
-        "        elseif data.bindType == 2 then self:AddLine('Binds when equipped', 1, 1, 1)\n"
-        "        elseif data.bindType == 3 then self:AddLine('Binds when used', 1, 1, 1) end\n"
-        "        -- Armor\n"
-        "        if data.armor and data.armor > 0 then\n"
-        "            self:AddLine(data.armor..' Armor', 1, 1, 1)\n"
-        "        end\n"
-        "        -- Weapon damage and speed\n"
-        "        if data.damageMin and data.damageMax and data.damageMin > 0 then\n"
-        "            local speed = (data.speed or 0) / 1000\n"
-        "            if speed > 0 then\n"
-        "                self:AddDoubleLine(string.format('%.0f - %.0f Damage', data.damageMin, data.damageMax), string.format('Speed %.2f', speed), 1,1,1, 1,1,1)\n"
-        "                local dps = (data.damageMin + data.damageMax) / 2 / speed\n"
-        "                self:AddLine(string.format('(%.1f damage per second)', dps), 1, 1, 1)\n"
-        "            end\n"
-        "        end\n"
-        "        -- Stats\n"
-        "        if data.stamina then self:AddLine('+'..data.stamina..' Stamina', 0, 1, 0) end\n"
-        "        if data.strength then self:AddLine('+'..data.strength..' Strength', 0, 1, 0) end\n"
-        "        if data.agility then self:AddLine('+'..data.agility..' Agility', 0, 1, 0) end\n"
-        "        if data.intellect then self:AddLine('+'..data.intellect..' Intellect', 0, 1, 0) end\n"
-        "        if data.spirit then self:AddLine('+'..data.spirit..' Spirit', 0, 1, 0) end\n"
-        "        -- Extra stats (hit, crit, haste, AP, SP, etc.)\n"
-        "        if data.extraStats then\n"
-        "            local statNames = {[3]='Agility',[4]='Strength',[5]='Intellect',[6]='Spirit',[7]='Stamina',\n"
-        "                [12]='Defense Rating',[13]='Dodge Rating',[14]='Parry Rating',[15]='Block Rating',\n"
-        "                [16]='Melee Hit Rating',[17]='Ranged Hit Rating',[18]='Spell Hit Rating',\n"
-        "                [19]='Melee Crit Rating',[20]='Ranged Crit Rating',[21]='Spell Crit Rating',\n"
-        "                [28]='Melee Haste Rating',[29]='Ranged Haste Rating',[30]='Spell Haste Rating',\n"
-        "                [31]='Hit Rating',[32]='Crit Rating',[36]='Haste Rating',\n"
-        "                [33]='Resilience Rating',[34]='Attack Power',[35]='Spell Power',\n"
-        "                [37]='Expertise Rating',[38]='Attack Power',[39]='Ranged Attack Power',\n"
-        "                [43]='Mana per 5 sec.',[44]='Armor Penetration Rating',\n"
-        "                [45]='Spell Power',[46]='Health per 5 sec.',[47]='Spell Penetration'}\n"
-        "            for _, stat in ipairs(data.extraStats) do\n"
-        "                local name = statNames[stat.type]\n"
-        "                if name and stat.value ~= 0 then\n"
-        "                    local prefix = stat.value > 0 and '+' or ''\n"
-        "                    self:AddLine(prefix..stat.value..' '..name, 0, 1, 0)\n"
-        "                end\n"
-        "            end\n"
-        "        end\n"
-        "        -- Resistances\n"
-        "        if data.fireRes and data.fireRes ~= 0 then self:AddLine('+'..data.fireRes..' Fire Resistance', 0, 1, 0) end\n"
-        "        if data.natureRes and data.natureRes ~= 0 then self:AddLine('+'..data.natureRes..' Nature Resistance', 0, 1, 0) end\n"
-        "        if data.frostRes and data.frostRes ~= 0 then self:AddLine('+'..data.frostRes..' Frost Resistance', 0, 1, 0) end\n"
-        "        if data.shadowRes and data.shadowRes ~= 0 then self:AddLine('+'..data.shadowRes..' Shadow Resistance', 0, 1, 0) end\n"
-        "        if data.arcaneRes and data.arcaneRes ~= 0 then self:AddLine('+'..data.arcaneRes..' Arcane Resistance', 0, 1, 0) end\n"
-        "        -- Item spell effects (Use: / Equip: / Chance on Hit:)\n"
-        "        if data.itemSpells then\n"
-        "            local triggerLabels = {[0]='Use: ',[1]='Equip: ',[2]='Chance on hit: ',[5]=''}\n"
-        "            for _, sp in ipairs(data.itemSpells) do\n"
-        "                local label = triggerLabels[sp.trigger] or ''\n"
-        "                local text = sp.description or sp.name or ''\n"
-        "                if text ~= '' then\n"
-        "                    self:AddLine(label .. text, 0, 1, 0)\n"
-        "                end\n"
-        "            end\n"
-        "        end\n"
-        "        -- Gem sockets\n"
-        "        if data.sockets then\n"
-        "            local socketNames = {[1]='Meta',[2]='Red',[4]='Yellow',[8]='Blue'}\n"
-        "            for _, sock in ipairs(data.sockets) do\n"
-        "                local colorName = socketNames[sock.color] or 'Prismatic'\n"
-        "                self:AddLine('[' .. colorName .. ' Socket]', 0.5, 0.5, 0.5)\n"
-        "            end\n"
-        "        end\n"
-        "        -- Required level\n"
-        "        if data.requiredLevel and data.requiredLevel > 1 then\n"
-        "            self:AddLine('Requires Level '..data.requiredLevel, 1, 1, 1)\n"
-        "        end\n"
-        "        -- Flavor text\n"
-        "        if data.description then self:AddLine('\"'..data.description..'\"', 1, 0.82, 0) end\n"
-        "        if data.startsQuest then self:AddLine('This Item Begins a Quest', 1, 0.82, 0) end\n"
-        "    end\n"
-        "    -- Sell price from GetItemInfo\n"
-        "    if sellPrice and sellPrice > 0 then\n"
-        "        local gold = math.floor(sellPrice / 10000)\n"
-        "        local silver = math.floor((sellPrice % 10000) / 100)\n"
-        "        local copper = sellPrice % 100\n"
-        "        local parts = {}\n"
-        "        if gold > 0 then table.insert(parts, gold..'g') end\n"
-        "        if silver > 0 then table.insert(parts, silver..'s') end\n"
-        "        if copper > 0 then table.insert(parts, copper..'c') end\n"
-        "        if #parts > 0 then self:AddLine('Sell Price: '..table.concat(parts, ' '), 1, 1, 1) end\n"
-        "    end\n"
-        "    self.__itemId = itemId\n"
-        "    return true\n"
-        "end\n"
-        "function GameTooltip:SetInventoryItem(unit, slot)\n"
-        "    self:ClearLines()\n"
-        "    if unit ~= 'player' then return false, false, 0 end\n"
-        "    local link = GetInventoryItemLink(unit, slot)\n"
-        "    if not link then return false, false, 0 end\n"
-        "    local id = link:match('item:(%d+)')\n"
-        "    if not id then return false, false, 0 end\n"
-        "    local ok = _WoweePopulateItemTooltip(self, tonumber(id))\n"
-        "    return ok or false, false, 0\n"
-        "end\n"
-        "function GameTooltip:SetBagItem(bag, slot)\n"
-        "    self:ClearLines()\n"
-        "    local tex, count, locked, quality, readable, lootable, link = GetContainerItemInfo(bag, slot)\n"
-        "    if not link then return end\n"
-        "    local id = link:match('item:(%d+)')\n"
-        "    if not id then return end\n"
-        "    _WoweePopulateItemTooltip(self, tonumber(id))\n"
-        "    if count and count > 1 then self:AddLine('Count: '..count, 0.5, 0.5, 0.5) end\n"
-        "end\n"
-        "function GameTooltip:SetSpellByID(spellId)\n"
-        "    self:ClearLines()\n"
-        "    if not spellId or spellId == 0 then return end\n"
-        "    local name, rank, icon, castTime, minRange, maxRange = GetSpellInfo(spellId)\n"
-        "    if name then\n"
-        "        self:SetText(name, 1, 1, 1)\n"
-        "        if rank and rank ~= '' then self:AddLine(rank, 0.5, 0.5, 0.5) end\n"
-        "        -- Mana cost\n"
-        "        local cost, costType = GetSpellPowerCost(spellId)\n"
-        "        if cost and cost > 0 then\n"
-        "            local powerNames = {[0]='Mana',[1]='Rage',[2]='Focus',[3]='Energy',[6]='Runic Power'}\n"
-        "            self:AddLine(cost..' '..(powerNames[costType] or 'Mana'), 1, 1, 1)\n"
-        "        end\n"
-        "        -- Range\n"
-        "        if maxRange and maxRange > 0 then\n"
-        "            self:AddDoubleLine(string.format('%.0f yd range', maxRange), '', 1,1,1, 1,1,1)\n"
-        "        end\n"
-        "        -- Cast time\n"
-        "        if castTime and castTime > 0 then\n"
-        "            self:AddDoubleLine(string.format('%.1f sec cast', castTime / 1000), '', 1,1,1, 1,1,1)\n"
-        "        else\n"
-        "            self:AddDoubleLine('Instant', '', 1,1,1, 1,1,1)\n"
-        "        end\n"
-        "        -- Description\n"
-        "        local desc = GetSpellDescription(spellId)\n"
-        "        if desc and desc ~= '' then\n"
-        "            self:AddLine(desc, 1, 0.82, 0)\n"
-        "        end\n"
-        "        -- Cooldown\n"
-        "        local start, dur = GetSpellCooldown(spellId)\n"
-        "        if dur and dur > 0 then\n"
-        "            local rem = start + dur - GetTime()\n"
-        "            if rem > 0.1 then self:AddLine(string.format('%.0f sec cooldown', rem), 1, 0, 0) end\n"
-        "        end\n"
-        "        self.__spellId = spellId\n"
-        "    end\n"
-        "end\n"
-        "function GameTooltip:SetAction(slot)\n"
-        "    self:ClearLines()\n"
-        "    if not slot then return end\n"
-        "    local actionType, id = GetActionInfo(slot)\n"
-        "    if actionType == 'spell' and id and id > 0 then\n"
-        "        self:SetSpellByID(id)\n"
-        "    elseif actionType == 'item' and id and id > 0 then\n"
-        "        _WoweePopulateItemTooltip(self, id)\n"
-        "    end\n"
-        "end\n"
-        "function GameTooltip:FadeOut() end\n"
-        "function GameTooltip:SetFrameStrata(...) end\n"
-        "function GameTooltip:SetClampedToScreen(...) end\n"
-        "function GameTooltip:IsOwned(f) return self.__owner == f end\n"
-        // ShoppingTooltip: used by comparison tooltips
-        "ShoppingTooltip1 = CreateFrame('Frame', 'ShoppingTooltip1')\n"
-        "ShoppingTooltip2 = CreateFrame('Frame', 'ShoppingTooltip2')\n"
-        // Error handling stubs (used by many addons)
-        "local _errorHandler = function(err) return err end\n"
-        "function geterrorhandler() return _errorHandler end\n"
-        "function seterrorhandler(fn) if type(fn)=='function' then _errorHandler=fn end end\n"
-        "function debugstack(start, count1, count2) return '' end\n"
-        "function securecall(fn, ...) if type(fn)=='function' then return fn(...) end end\n"
-        "function issecurevariable(...) return false end\n"
-        "function issecure() return false end\n"
-        // GetCVarBool wraps C-side GetCVar (registered in table) for boolean queries
-        "function GetCVarBool(name) return GetCVar(name) == '1' end\n"
-        // Misc compatibility stubs
-        // GetScreenWidth, GetScreenHeight, GetNumLootItems are now C functions
-        // GetFramerate is now a C function
-        "function GetNetStats() return 0, 0, 0, 0 end\n"
-        "function IsLoggedIn() return true end\n"
-        "function StaticPopup_Show() end\n"
-        "function StaticPopup_Hide() end\n"
-        // UI Panel management — Show/Hide standard WoW panels
-        "UIPanelWindows = {}\n"
-        "function ShowUIPanel(frame, force)\n"
-        "    if frame and frame.Show then frame:Show() end\n"
-        "end\n"
-        "function HideUIPanel(frame)\n"
-        "    if frame and frame.Hide then frame:Hide() end\n"
-        "end\n"
-        "function ToggleFrame(frame)\n"
-        "    if frame then\n"
-        "        if frame:IsShown() then frame:Hide() else frame:Show() end\n"
-        "    end\n"
-        "end\n"
-        "function GetUIPanel(which) return nil end\n"
-        "function CloseWindows(ignoreCenter) return false end\n"
-        // TEXT localization stub — returns input string unchanged
-        "function TEXT(text) return text end\n"
-        // Faux scroll frame helpers (used by many list UIs)
-        "function FauxScrollFrame_GetOffset(frame)\n"
-        "    return frame and frame.offset or 0\n"
-        "end\n"
-        "function FauxScrollFrame_Update(frame, numItems, numVisible, valueStep, button, smallWidth, bigWidth, highlightFrame, smallHighlightWidth, bigHighlightWidth)\n"
-        "    if not frame then return false end\n"
-        "    frame.offset = frame.offset or 0\n"
-        "    local showScrollBar = numItems > numVisible\n"
-        "    return showScrollBar\n"
-        "end\n"
-        "function FauxScrollFrame_SetOffset(frame, offset)\n"
-        "    if frame then frame.offset = offset or 0 end\n"
-        "end\n"
-        "function FauxScrollFrame_OnVerticalScroll(frame, value, itemHeight, updateFunction)\n"
-        "    if not frame then return end\n"
-        "    frame.offset = math.floor(value / (itemHeight or 1) + 0.5)\n"
-        "    if updateFunction then updateFunction() end\n"
-        "end\n"
-        // SecureCmdOptionParse — parses conditional macros like [target=focus]
-        "function SecureCmdOptionParse(options)\n"
-        "    if not options then return nil end\n"
-        "    -- Simple: return the unconditional fallback (text after last semicolon or the whole string)\n"
-        "    local result = options:match(';%s*(.-)$') or options:match('^%[.*%]%s*(.-)$') or options\n"
-        "    return result\n"
-        "end\n"
-        // ChatFrame message group stubs
-        "function ChatFrame_AddMessageGroup(frame, group) end\n"
-        "function ChatFrame_RemoveMessageGroup(frame, group) end\n"
-        "function ChatFrame_AddChannel(frame, channel) end\n"
-        "function ChatFrame_RemoveChannel(frame, channel) end\n"
-        // CreateTexture/CreateFontString are now C frame methods in the metatable
-        "do\n"
-        "  local function cc(r,g,b)\n"
-        "    local t = {r=r, g=g, b=b}\n"
-        "    t.colorStr = string.format('%02x%02x%02x', math.floor(r*255), math.floor(g*255), math.floor(b*255))\n"
-        "    function t:GenerateHexColor() return '|cff' .. self.colorStr end\n"
-        "    function t:GenerateHexColorMarkup() return '|cff' .. self.colorStr end\n"
-        "    return t\n"
-        "  end\n"
-        "  RAID_CLASS_COLORS = {\n"
-        "    WARRIOR=cc(0.78,0.61,0.43), PALADIN=cc(0.96,0.55,0.73),\n"
-        "    HUNTER=cc(0.67,0.83,0.45), ROGUE=cc(1.0,0.96,0.41),\n"
-        "    PRIEST=cc(1.0,1.0,1.0), DEATHKNIGHT=cc(0.77,0.12,0.23),\n"
-        "    SHAMAN=cc(0.0,0.44,0.87), MAGE=cc(0.41,0.80,0.94),\n"
-        "    WARLOCK=cc(0.58,0.51,0.79), DRUID=cc(1.0,0.49,0.04),\n"
-        "  }\n"
-        "end\n"
-        // GetClassColor(className) — returns r, g, b, colorString
-        "function GetClassColor(className)\n"
-        "    local c = RAID_CLASS_COLORS[className]\n"
-        "    if c then return c.r, c.g, c.b, c.colorStr end\n"
-        "    return 1, 1, 1, 'ffffffff'\n"
-        "end\n"
-        // QuestDifficultyColors table for quest level coloring
-        "QuestDifficultyColors = {\n"
-        "    impossible = {r=1.0,g=0.1,b=0.1,font='QuestDifficulty_Impossible'},\n"
-        "    verydifficult = {r=1.0,g=0.5,b=0.25,font='QuestDifficulty_VeryDifficult'},\n"
-        "    difficult = {r=1.0,g=1.0,b=0.0,font='QuestDifficulty_Difficult'},\n"
-        "    standard = {r=0.25,g=0.75,b=0.25,font='QuestDifficulty_Standard'},\n"
-        "    trivial = {r=0.5,g=0.5,b=0.5,font='QuestDifficulty_Trivial'},\n"
-        "    header = {r=1.0,g=0.82,b=0.0,font='QuestDifficulty_Header'},\n"
-        "}\n"
-        // Money formatting utility
-        "function GetCoinTextureString(copper)\n"
-        "    if not copper or copper == 0 then return '0c' end\n"
-        "    copper = math.floor(copper)\n"
-        "    local g = math.floor(copper / 10000)\n"
-        "    local s = math.floor(math.fmod(copper, 10000) / 100)\n"
-        "    local c = math.fmod(copper, 100)\n"
-        "    local r = ''\n"
-        "    if g > 0 then r = r .. g .. 'g ' end\n"
-        "    if s > 0 then r = r .. s .. 's ' end\n"
-        "    if c > 0 or r == '' then r = r .. c .. 'c' end\n"
-        "    return r\n"
-        "end\n"
-        "GetCoinText = GetCoinTextureString\n"
-    );
-
-    // UIDropDownMenu framework — minimal compat for addons using dropdown menus
-    luaL_dostring(L_,
-        "UIDROPDOWNMENU_MENU_LEVEL = 1\n"
-        "UIDROPDOWNMENU_MENU_VALUE = nil\n"
-        "UIDROPDOWNMENU_OPEN_MENU = nil\n"
-        "local _ddMenuList = {}\n"
-        "function UIDropDownMenu_Initialize(frame, initFunc, displayMode, level, menuList)\n"
-        "    if frame then frame.__initFunc = initFunc end\n"
-        "end\n"
-        "function UIDropDownMenu_CreateInfo() return {} end\n"
-        "function UIDropDownMenu_AddButton(info, level) table.insert(_ddMenuList, info) end\n"
-        "function UIDropDownMenu_SetWidth(frame, width) end\n"
-        "function UIDropDownMenu_SetButtonWidth(frame, width) end\n"
-        "function UIDropDownMenu_SetText(frame, text)\n"
-        "    if frame then frame.__text = text end\n"
-        "end\n"
-        "function UIDropDownMenu_GetText(frame)\n"
-        "    return frame and frame.__text or ''\n"
-        "end\n"
-        "function UIDropDownMenu_SetSelectedID(frame, id) end\n"
-        "function UIDropDownMenu_SetSelectedValue(frame, value) end\n"
-        "function UIDropDownMenu_GetSelectedID(frame) return 1 end\n"
-        "function UIDropDownMenu_GetSelectedValue(frame) return nil end\n"
-        "function UIDropDownMenu_JustifyText(frame, justify) end\n"
-        "function UIDropDownMenu_EnableDropDown(frame) end\n"
-        "function UIDropDownMenu_DisableDropDown(frame) end\n"
-        "function CloseDropDownMenus() end\n"
-        "function ToggleDropDownMenu(level, value, frame, anchor, xOfs, yOfs) end\n"
-    );
-
-    // UISpecialFrames: frames in this list close on Escape key
-    luaL_dostring(L_,
-        "UISpecialFrames = {}\n"
-        // Font object stubs — addons reference these for CreateFontString templates
-        "GameFontNormal = {}\n"
-        "GameFontNormalSmall = {}\n"
-        "GameFontNormalLarge = {}\n"
-        "GameFontHighlight = {}\n"
-        "GameFontHighlightSmall = {}\n"
-        "GameFontHighlightLarge = {}\n"
-        "GameFontDisable = {}\n"
-        "GameFontDisableSmall = {}\n"
-        "GameFontWhite = {}\n"
-        "GameFontRed = {}\n"
-        "GameFontGreen = {}\n"
-        "NumberFontNormal = {}\n"
-        "ChatFontNormal = {}\n"
-        "SystemFont = {}\n"
-        // InterfaceOptionsFrame: addons register settings panels here
-        "InterfaceOptionsFrame = CreateFrame('Frame', 'InterfaceOptionsFrame')\n"
-        "InterfaceOptionsFramePanelContainer = CreateFrame('Frame', 'InterfaceOptionsFramePanelContainer')\n"
-        "function InterfaceOptions_AddCategory(panel) end\n"
-        "function InterfaceOptionsFrame_OpenToCategory(panel) end\n"
-        // Commonly expected global tables
-        "SLASH_RELOAD1 = '/reload'\n"
-        "SLASH_RELOADUI1 = '/reloadui'\n"
-        "GRAY_FONT_COLOR = {r=0.5,g=0.5,b=0.5}\n"
-        "NORMAL_FONT_COLOR = {r=1.0,g=0.82,b=0.0}\n"
-        "HIGHLIGHT_FONT_COLOR = {r=1.0,g=1.0,b=1.0}\n"
-        "GREEN_FONT_COLOR = {r=0.1,g=1.0,b=0.1}\n"
-        "RED_FONT_COLOR = {r=1.0,g=0.1,b=0.1}\n"
-        // C_ChatInfo — addon message prefix API used by some addons
-        "C_ChatInfo = C_ChatInfo or {}\n"
-        "C_ChatInfo.RegisterAddonMessagePrefix = RegisterAddonMessagePrefix\n"
-        "C_ChatInfo.IsAddonMessagePrefixRegistered = IsAddonMessagePrefixRegistered\n"
-        "C_ChatInfo.SendAddonMessage = SendAddonMessage\n"
-    );
-
-    // Action bar constants and functions used by action bar addons
-    luaL_dostring(L_,
-        "NUM_ACTIONBAR_BUTTONS = 12\n"
-        "NUM_ACTIONBAR_PAGES = 6\n"
-        "ACTION_BUTTON_SHOW_GRID_REASON_CVAR = 1\n"
-        "ACTION_BUTTON_SHOW_GRID_REASON_EVENT = 2\n"
-        // Action bar page tracking
-        "local _actionBarPage = 1\n"
-        "function GetActionBarPage() return _actionBarPage end\n"
-        "function ChangeActionBarPage(page) _actionBarPage = page end\n"
-        "function GetBonusBarOffset() return 0 end\n"
-        // Action type query
-        "function GetActionText(slot) return nil end\n"
-        "function GetActionCount(slot) return 0 end\n"
-        // Binding functions
-        "function GetBindingKey(action) return nil end\n"
-        "function GetBindingAction(key) return nil end\n"
-        "function SetBinding(key, action) end\n"
-        "function SaveBindings(which) end\n"
-        "function GetCurrentBindingSet() return 1 end\n"
-        // Macro functions
-        "function GetNumMacros() return 0, 0 end\n"
-        "function GetMacroInfo(id) return nil end\n"
-        "function GetMacroBody(id) return nil end\n"
-        "function GetMacroIndexByName(name) return 0 end\n"
-        // Stance bar
-        "function GetNumShapeshiftForms() return 0 end\n"
-        "function GetShapeshiftFormInfo(index) return nil, nil, nil, nil end\n"
-        // Pet action bar
-        "NUM_PET_ACTION_SLOTS = 10\n"
-        // Common WoW constants used by many addons
-        "MAX_TALENT_TABS = 3\n"
-        "MAX_NUM_TALENTS = 100\n"
-        "BOOKTYPE_SPELL = 0\n"
-        "BOOKTYPE_PET = 1\n"
-        "MAX_PARTY_MEMBERS = 4\n"
-        "MAX_RAID_MEMBERS = 40\n"
-        "MAX_ARENA_TEAMS = 3\n"
-        "INVSLOT_FIRST_EQUIPPED = 1\n"
-        "INVSLOT_LAST_EQUIPPED = 19\n"
-        "NUM_BAG_SLOTS = 4\n"
-        "NUM_BANKBAGSLOTS = 7\n"
-        "CONTAINER_BAG_OFFSET = 0\n"
-        "MAX_SKILLLINE_TABS = 8\n"
-        "TRADE_ENCHANT_SLOT = 7\n"
-        "function GetPetActionInfo(slot) return nil end\n"
-        "function GetPetActionsUsable() return false end\n"
-    );
-
-    // WoW table/string utility functions used by many addons
-    luaL_dostring(L_,
-        // Table utilities
-        "function tContains(tbl, item)\n"
-        "    for _, v in pairs(tbl) do if v == item then return true end end\n"
-        "    return false\n"
-        "end\n"
-        "function tInvert(tbl)\n"
-        "    local inv = {}\n"
-        "    for k, v in pairs(tbl) do inv[v] = k end\n"
-        "    return inv\n"
-        "end\n"
-        "function CopyTable(src)\n"
-        "    if type(src) ~= 'table' then return src end\n"
-        "    local copy = {}\n"
-        "    for k, v in pairs(src) do copy[k] = CopyTable(v) end\n"
-        "    return setmetatable(copy, getmetatable(src))\n"
-        "end\n"
-        "function tDeleteItem(tbl, item)\n"
-        "    for i = #tbl, 1, -1 do if tbl[i] == item then table.remove(tbl, i) end end\n"
-        "end\n"
-        // Mixin pattern — used by modern addons for OOP-style object creation
-        "function Mixin(obj, ...)\n"
-        "    for i = 1, select('#', ...) do\n"
-        "        local mixin = select(i, ...)\n"
-        "        for k, v in pairs(mixin) do obj[k] = v end\n"
-        "    end\n"
-        "    return obj\n"
-        "end\n"
-        "function CreateFromMixins(...)\n"
-        "    return Mixin({}, ...)\n"
-        "end\n"
-        "function CreateAndInitFromMixin(mixin, ...)\n"
-        "    local obj = CreateFromMixins(mixin)\n"
-        "    if obj.Init then obj:Init(...) end\n"
-        "    return obj\n"
-        "end\n"
-        "function MergeTable(dest, src)\n"
-        "    for k, v in pairs(src) do dest[k] = v end\n"
-        "    return dest\n"
-        "end\n"
-        // String utilities (WoW globals that alias Lua string functions)
-        "strupper = string.upper\n"
-        "strlower = string.lower\n"
-        "strfind = string.find\n"
-        "strsub = string.sub\n"
-        "strlen = string.len\n"
-        "strrep = string.rep\n"
-        "strbyte = string.byte\n"
-        "strchar = string.char\n"
-        "strgfind = string.gmatch\n"
-        "function tostringall(...)\n"
-        "    local n = select('#', ...)\n"
-        "    if n == 0 then return end\n"
-        "    local r = {}\n"
-        "    for i = 1, n do r[i] = tostring(select(i, ...)) end\n"
-        "    return unpack(r, 1, n)\n"
-        "end\n"
-        "strrev = string.reverse\n"
-        "gsub = string.gsub\n"
-        "gmatch = string.gmatch\n"
-        "strjoin = function(delim, ...)\n"
-        "    return table.concat({...}, delim)\n"
-        "end\n"
-        // Math utilities
-        "function Clamp(val, lo, hi) return math.min(math.max(val, lo), hi) end\n"
-        "function Round(val) return math.floor(val + 0.5) end\n"
-        // Bit operations (WoW provides these; Lua 5.1 doesn't have native bit ops)
-        "bit = bit or {}\n"
-        "bit.band = bit.band or function(a, b) local r,m=0,1 for i=0,31 do if a%2==1 and b%2==1 then r=r+m end a=math.floor(a/2) b=math.floor(b/2) m=m*2 end return r end\n"
-        "bit.bor = bit.bor or function(a, b) local r,m=0,1 for i=0,31 do if a%2==1 or b%2==1 then r=r+m end a=math.floor(a/2) b=math.floor(b/2) m=m*2 end return r end\n"
-        "bit.bxor = bit.bxor or function(a, b) local r,m=0,1 for i=0,31 do if (a%2==1)~=(b%2==1) then r=r+m end a=math.floor(a/2) b=math.floor(b/2) m=m*2 end return r end\n"
-        "bit.bnot = bit.bnot or function(a) return 4294967295 - a end\n"
-        "bit.lshift = bit.lshift or function(a, n) return a * (2^n) end\n"
-        "bit.rshift = bit.rshift or function(a, n) return math.floor(a / (2^n)) end\n"
-    );
-}
-
-// ---- Event System ----
-// Lua-side: WoweeEvents table holds { ["EVENT_NAME"] = { handler1, handler2, ... } }
-// RegisterEvent("EVENT", handler) adds a handler function
-// UnregisterEvent("EVENT", handler) removes it
-
-
-static int lua_RegisterEvent(lua_State* L) {
-    const char* eventName = luaL_checkstring(L, 1);
-    luaL_checktype(L, 2, LUA_TFUNCTION);
-
-    // Get or create the WoweeEvents table
-    lua_getglobal(L, "__WoweeEvents");
-    if (lua_isnil(L, -1)) {
-        lua_pop(L, 1);
-        lua_newtable(L);
-        lua_pushvalue(L, -1);
-        lua_setglobal(L, "__WoweeEvents");
-    }
-
-    // Get or create the handler list for this event
-    lua_getfield(L, -1, eventName);
-    if (lua_isnil(L, -1)) {
-        lua_pop(L, 1);
-        lua_newtable(L);
-        lua_pushvalue(L, -1);
-        lua_setfield(L, -3, eventName);
-    }
-
-    // Append the handler function to the list
-    int len = static_cast<int>(lua_objlen(L, -1));
-    lua_pushvalue(L, 2);  // push the handler function
-    lua_rawseti(L, -2, len + 1);
-
-    lua_pop(L, 2);  // pop handler list + WoweeEvents
-    return 0;
-}
-
-static int lua_UnregisterEvent(lua_State* L) {
-    const char* eventName = luaL_checkstring(L, 1);
-    luaL_checktype(L, 2, LUA_TFUNCTION);
-
-    lua_getglobal(L, "__WoweeEvents");
-    if (lua_isnil(L, -1)) { lua_pop(L, 1); return 0; }
-
-    lua_getfield(L, -1, eventName);
-    if (lua_isnil(L, -1)) { lua_pop(L, 2); return 0; }
-
-    // Remove matching handler from the list
-    int len = static_cast<int>(lua_objlen(L, -1));
-    for (int i = 1; i <= len; i++) {
-        lua_rawgeti(L, -1, i);
-        if (lua_rawequal(L, -1, 2)) {
-            lua_pop(L, 1);
-            // Shift remaining elements down
-            for (int j = i; j < len; j++) {
-                lua_rawgeti(L, -1, j + 1);
-                lua_rawseti(L, -2, j);
-            }
-            lua_pushnil(L);
-            lua_rawseti(L, -2, len);
-            break;
-        }
-        lua_pop(L, 1);
-    }
-    lua_pop(L, 2);
-    return 0;
-}
-
-void LuaEngine::registerEventAPI() {
-    lua_pushcfunction(L_, lua_RegisterEvent);
-    lua_setglobal(L_, "RegisterEvent");
-
-    lua_pushcfunction(L_, lua_UnregisterEvent);
-    lua_setglobal(L_, "UnregisterEvent");
-
-    // Create the events table
-    lua_newtable(L_);
-    lua_setglobal(L_, "__WoweeEvents");
-}
-
-void LuaEngine::fireEvent(const std::string& eventName,
-                           const std::vector<std::string>& args) {
-    if (!L_) return;
-
-    lua_getglobal(L_, "__WoweeEvents");
-    if (lua_isnil(L_, -1)) { lua_pop(L_, 1); return; }
-
-    lua_getfield(L_, -1, eventName.c_str());
-    if (lua_isnil(L_, -1)) { lua_pop(L_, 2); return; }
-
-    int handlerCount = static_cast<int>(lua_objlen(L_, -1));
-    for (int i = 1; i <= handlerCount; i++) {
-        lua_rawgeti(L_, -1, i);
-        if (!lua_isfunction(L_, -1)) { lua_pop(L_, 1); continue; }
-
-        // Push arguments: event name first, then extra args
-        lua_pushstring(L_, eventName.c_str());
-        for (const auto& arg : args) {
-            lua_pushstring(L_, arg.c_str());
-        }
-
-        int nargs = 1 + static_cast<int>(args.size());
-        if (lua_pcall(L_, nargs, 0, 0) != 0) {
-            const char* err = lua_tostring(L_, -1);
-            std::string errStr = err ? err : "(unknown)";
-            LOG_ERROR("LuaEngine: event '", eventName, "' handler error: ", errStr);
-            if (luaErrorCallback_) luaErrorCallback_(errStr);
-            lua_pop(L_, 1);
-        }
-    }
-    lua_pop(L_, 2);  // pop handler list + WoweeEvents
-
-    // Also dispatch to frames that registered for this event via frame:RegisterEvent()
-    lua_getglobal(L_, "__WoweeFrameEvents");
-    if (lua_istable(L_, -1)) {
-        lua_getfield(L_, -1, eventName.c_str());
-        if (lua_istable(L_, -1)) {
-            int frameCount = static_cast<int>(lua_objlen(L_, -1));
-            for (int i = 1; i <= frameCount; i++) {
-                lua_rawgeti(L_, -1, i);
-                if (!lua_istable(L_, -1)) { lua_pop(L_, 1); continue; }
-
-                // Get the frame's OnEvent script
-                lua_getfield(L_, -1, "__scripts");
-                if (lua_istable(L_, -1)) {
-                    lua_getfield(L_, -1, "OnEvent");
-                    if (lua_isfunction(L_, -1)) {
-                        lua_pushvalue(L_, -3);  // self (frame)
-                        lua_pushstring(L_, eventName.c_str());
-                        for (const auto& arg : args) lua_pushstring(L_, arg.c_str());
-                        int nargs = 2 + static_cast<int>(args.size());
-                        if (lua_pcall(L_, nargs, 0, 0) != 0) {
-                            const char* ferr = lua_tostring(L_, -1);
-                            std::string ferrStr = ferr ? ferr : "(unknown)";
-                            LOG_ERROR("LuaEngine: frame OnEvent error: ", ferrStr);
-                            if (luaErrorCallback_) luaErrorCallback_(ferrStr);
-                            lua_pop(L_, 1);
-                        }
-                    } else {
-                        lua_pop(L_, 1); // pop non-function
-                    }
-                }
-                lua_pop(L_, 2); // pop __scripts + frame
-            }
-        }
-        lua_pop(L_, 1); // pop event frame list
-    }
-    lua_pop(L_, 1); // pop __WoweeFrameEvents
-}
-
-void LuaEngine::dispatchOnUpdate(float elapsed) {
-    if (!L_) return;
-
-    lua_getglobal(L_, "__WoweeOnUpdateFrames");
-    if (!lua_istable(L_, -1)) { lua_pop(L_, 1); return; }
-
-    int count = static_cast<int>(lua_objlen(L_, -1));
-    for (int i = 1; i <= count; i++) {
-        lua_rawgeti(L_, -1, i);
-        if (!lua_istable(L_, -1)) { lua_pop(L_, 1); continue; }
-
-        // Check if frame is visible
-        lua_getfield(L_, -1, "__visible");
-        bool visible = lua_toboolean(L_, -1);
-        lua_pop(L_, 1);
-        if (!visible) { lua_pop(L_, 1); continue; }
-
-        // Get OnUpdate script
-        lua_getfield(L_, -1, "__scripts");
-        if (lua_istable(L_, -1)) {
-            lua_getfield(L_, -1, "OnUpdate");
-            if (lua_isfunction(L_, -1)) {
-                lua_pushvalue(L_, -3);  // self (frame)
-                lua_pushnumber(L_, static_cast<double>(elapsed));
-                if (lua_pcall(L_, 2, 0, 0) != 0) {
-                    const char* uerr = lua_tostring(L_, -1);
-                    std::string uerrStr = uerr ? uerr : "(unknown)";
-                    LOG_ERROR("LuaEngine: OnUpdate error: ", uerrStr);
-                    if (luaErrorCallback_) luaErrorCallback_(uerrStr);
-                    lua_pop(L_, 1);
-                }
-            } else {
-                lua_pop(L_, 1);
-            }
-        }
-        lua_pop(L_, 2); // pop __scripts + frame
-    }
-    lua_pop(L_, 1); // pop __WoweeOnUpdateFrames
-}
-
-bool LuaEngine::dispatchSlashCommand(const std::string& command, const std::string& args) {
-    if (!L_) return false;
-
-    // Check each SlashCmdList entry: for key NAME, check SLASH_NAME1, SLASH_NAME2, etc.
-    lua_getglobal(L_, "SlashCmdList");
-    if (!lua_istable(L_, -1)) { lua_pop(L_, 1); return false; }
-
-    std::string cmdLower = command;
-    toLowerInPlace(cmdLower);
-
-    lua_pushnil(L_);
-    while (lua_next(L_, -2) != 0) {
-        // Stack: SlashCmdList, key, handler
-        if (!lua_isfunction(L_, -1) || !lua_isstring(L_, -2)) {
-            lua_pop(L_, 1);
-            continue;
-        }
-        const char* name = lua_tostring(L_, -2);
-
-        // Check SLASH_<NAME>1 through SLASH_<NAME>9
-        for (int i = 1; i <= 9; i++) {
-            std::string globalName = "SLASH_" + std::string(name) + std::to_string(i);
-            lua_getglobal(L_, globalName.c_str());
-            if (lua_isstring(L_, -1)) {
-                std::string slashStr = lua_tostring(L_, -1);
-                toLowerInPlace(slashStr);
-                if (slashStr == cmdLower) {
-                    lua_pop(L_, 1); // pop global
-                    // Call the handler with args
-                    lua_pushvalue(L_, -1); // copy handler
-                    lua_pushstring(L_, args.c_str());
-                    if (lua_pcall(L_, 1, 0, 0) != 0) {
-                        LOG_ERROR("LuaEngine: SlashCmdList['", name, "'] error: ",
-                                  lua_tostring(L_, -1));
-                        lua_pop(L_, 1);
-                    }
-                    lua_pop(L_, 3); // pop handler, key, SlashCmdList
-                    return true;
-                }
-            }
-            lua_pop(L_, 1); // pop global
-        }
-        lua_pop(L_, 1); // pop handler, keep key for next iteration
-    }
-    lua_pop(L_, 1); // pop SlashCmdList
-    return false;
-}
-
-// ---- SavedVariables serialization ----
-
-static void serializeLuaValue(lua_State* L, int idx, std::string& out, int indent);
-
-static void serializeLuaTable(lua_State* L, int idx, std::string& out, int indent) {
-    out += "{\n";
-    std::string pad(indent + 2, ' ');
-    lua_pushnil(L);
-    while (lua_next(L, idx) != 0) {
-        out += pad;
-        // Key
-        if (lua_type(L, -2) == LUA_TSTRING) {
-            const char* k = lua_tostring(L, -2);
-            out += "[\"";
-            for (const char* p = k; *p; ++p) {
-                if (*p == '"' || *p == '\\') out += '\\';
-                out += *p;
-            }
-            out += "\"] = ";
-        } else if (lua_type(L, -2) == LUA_TNUMBER) {
-            out += "[" + std::to_string(static_cast<long long>(lua_tonumber(L, -2))) + "] = ";
-        } else {
-            lua_pop(L, 1);
-            continue;
-        }
-        // Value
-        serializeLuaValue(L, lua_gettop(L), out, indent + 2);
-        out += ",\n";
-        lua_pop(L, 1);
-    }
-    out += std::string(indent, ' ') + "}";
-}
-
-static void serializeLuaValue(lua_State* L, int idx, std::string& out, int indent) {
-    switch (lua_type(L, idx)) {
-        case LUA_TNIL:     out += "nil"; break;
-        case LUA_TBOOLEAN: out += lua_toboolean(L, idx) ? "true" : "false"; break;
-        case LUA_TNUMBER: {
-            double v = lua_tonumber(L, idx);
-            char buf[64];
-            snprintf(buf, sizeof(buf), "%.17g", v);
-            out += buf;
-            break;
-        }
-        case LUA_TSTRING: {
-            const char* s = lua_tostring(L, idx);
-            out += "\"";
-            for (const char* p = s; *p; ++p) {
-                if (*p == '"' || *p == '\\') out += '\\';
-                else if (*p == '\n') { out += "\\n"; continue; }
-                else if (*p == '\r') continue;
-                out += *p;
-            }
-            out += "\"";
-            break;
-        }
-        case LUA_TTABLE:
-            serializeLuaTable(L, idx, out, indent);
-            break;
-        default:
-            out += "nil"; // Functions, userdata, etc. can't be serialized
-            break;
-    }
-}
-
-void LuaEngine::setAddonList(const std::vector<TocFile>& addons) {
-    if (!L_) return;
-    lua_pushnumber(L_, static_cast<double>(addons.size()));
-    lua_setfield(L_, LUA_REGISTRYINDEX, "wowee_addon_count");
-
-    lua_newtable(L_);
-    for (size_t i = 0; i < addons.size(); i++) {
-        lua_newtable(L_);
-        lua_pushstring(L_, addons[i].addonName.c_str());
-        lua_setfield(L_, -2, "name");
-        lua_pushstring(L_, addons[i].getTitle().c_str());
-        lua_setfield(L_, -2, "title");
-        auto notesIt = addons[i].directives.find("Notes");
-        lua_pushstring(L_, notesIt != addons[i].directives.end() ? notesIt->second.c_str() : "");
-        lua_setfield(L_, -2, "notes");
-        // Store all TOC directives for GetAddOnMetadata
-        lua_newtable(L_);
-        for (const auto& [key, val] : addons[i].directives) {
-            lua_pushstring(L_, val.c_str());
-            lua_setfield(L_, -2, key.c_str());
-        }
-        lua_setfield(L_, -2, "metadata");
-        lua_rawseti(L_, -2, static_cast<int>(i + 1));
-    }
-    lua_setfield(L_, LUA_REGISTRYINDEX, "wowee_addon_info");
-}
-
-bool LuaEngine::loadSavedVariables(const std::string& path) {
-    if (!L_) return false;
-    std::ifstream f(path);
-    if (!f.is_open()) return false; // No saved data yet — not an error
-    std::string content((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
-    if (content.empty()) return true;
-    int err = luaL_dostring(L_, content.c_str());
-    if (err != 0) {
-        LOG_WARNING("LuaEngine: error loading saved variables from '", path, "': ",
-                    lua_tostring(L_, -1));
-        lua_pop(L_, 1);
-        return false;
-    }
-    return true;
-}
-
-bool LuaEngine::saveSavedVariables(const std::string& path, const std::vector<std::string>& varNames) {
-    if (!L_ || varNames.empty()) return false;
-    std::string output;
-    for (const auto& name : varNames) {
-        lua_getglobal(L_, name.c_str());
-        if (!lua_isnil(L_, -1)) {
-            output += name + " = ";
-            serializeLuaValue(L_, lua_gettop(L_), output, 0);
-            output += "\n";
-        }
-        lua_pop(L_, 1);
-    }
-    if (output.empty()) return true;
-
-    // Ensure directory exists
-    size_t lastSlash = path.find_last_of("/\\");
-    if (lastSlash != std::string::npos) {
-        std::error_code ec;
-        std::filesystem::create_directories(path.substr(0, lastSlash), ec);
-    }
-
-    std::ofstream f(path);
-    if (!f.is_open()) {
-        LOG_WARNING("LuaEngine: cannot write saved variables to '", path, "'");
-        return false;
-    }
-    f << output;
-    LOG_INFO("LuaEngine: saved variables to '", path, "' (", output.size(), " bytes)");
-    return true;
-}
-
-bool LuaEngine::executeFile(const std::string& path) {
-    if (!L_) return false;
-
-    int err = luaL_dofile(L_, path.c_str());
-    if (err != 0) {
-        const char* errMsg = lua_tostring(L_, -1);
-        std::string msg = errMsg ? errMsg : "(unknown error)";
-        LOG_ERROR("LuaEngine: error loading '", path, "': ", msg);
-        if (luaErrorCallback_) luaErrorCallback_(msg);
-        if (gameHandler_) {
-            game::MessageChatData errChat;
-            errChat.type = game::ChatType::SYSTEM;
-            errChat.language = game::ChatLanguage::UNIVERSAL;
-            errChat.message = "|cffff4040[Lua Error] " + msg + "|r";
-            gameHandler_->addLocalChatMessage(errChat);
-        }
-        lua_pop(L_, 1);
-        return false;
-    }
-    return true;
-}
-
-bool LuaEngine::executeString(const std::string& code) {
-    if (!L_) return false;
-
-    int err = luaL_dostring(L_, code.c_str());
-    if (err != 0) {
-        const char* errMsg = lua_tostring(L_, -1);
-        std::string msg = errMsg ? errMsg : "(unknown error)";
-        LOG_ERROR("LuaEngine: script error: ", msg);
-        if (luaErrorCallback_) luaErrorCallback_(msg);
-        if (gameHandler_) {
-            game::MessageChatData errChat;
-            errChat.type = game::ChatType::SYSTEM;
-            errChat.language = game::ChatLanguage::UNIVERSAL;
-            errChat.message = "|cffff4040[Lua Error] " + msg + "|r";
-            gameHandler_->addLocalChatMessage(errChat);
-        }
-        lua_pop(L_, 1);
-        return false;
-    }
-    return true;
-}
-
-} // namespace wowee::addons
diff --git a/src/addons/lua_inventory_api.cpp b/src/addons/lua_inventory_api.cpp
deleted file mode 100644
index c7a93090..00000000
--- a/src/addons/lua_inventory_api.cpp
+++ /dev/null
@@ -1,892 +0,0 @@
-// lua_inventory_api.cpp — Items, containers, merchant, loot, equipment, trading, auction, and mail Lua API bindings.
-// Extracted from lua_engine.cpp as part of §5.1 (Tame LuaEngine).
-#include "addons/lua_api_helpers.hpp"
-
-namespace wowee::addons {
-
-static int lua_GetMoney(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushnumber(L, gh ? static_cast<double>(gh->getMoneyCopper()) : 0.0);
-    return 1;
-}
-
-// --- Merchant/Vendor API ---
-
-static int lua_GetMerchantNumItems(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnZero(L); }
-    lua_pushnumber(L, gh->getVendorItems().items.size());
-    return 1;
-}
-
-// GetMerchantItemInfo(index) → name, texture, price, stackCount, numAvailable, isUsable
-static int lua_GetMerchantItemInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int index = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || index < 1) { return luaReturnNil(L); }
-    const auto& items = gh->getVendorItems().items;
-    if (index > static_cast<int>(items.size())) { return luaReturnNil(L); }
-    const auto& vi = items[index - 1];
-    const auto* info = gh->getItemInfo(vi.itemId);
-    std::string name = info ? info->name : ("Item #" + std::to_string(vi.itemId));
-    lua_pushstring(L, name.c_str());                    // name
-    // texture
-    std::string iconPath;
-    if (info && info->displayInfoId != 0)
-        iconPath = gh->getItemIconPath(info->displayInfoId);
-    if (!iconPath.empty()) lua_pushstring(L, iconPath.c_str());
-    else lua_pushnil(L);
-    lua_pushnumber(L, vi.buyPrice);                     // price (copper)
-    lua_pushnumber(L, vi.stackCount > 0 ? vi.stackCount : 1); // stackCount
-    lua_pushnumber(L, vi.maxCount == -1 ? -1 : vi.maxCount);  // numAvailable (-1=unlimited)
-    lua_pushboolean(L, 1);                              // isUsable
-    return 6;
-}
-
-// GetMerchantItemLink(index) → item link
-static int lua_GetMerchantItemLink(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int index = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || index < 1) { return luaReturnNil(L); }
-    const auto& items = gh->getVendorItems().items;
-    if (index > static_cast<int>(items.size())) { return luaReturnNil(L); }
-    const auto& vi = items[index - 1];
-    const auto* info = gh->getItemInfo(vi.itemId);
-    if (!info) { return luaReturnNil(L); }
-
-    const char* ch = (info->quality < 8) ? kQualHexAlpha[info->quality] : "ffffffff";
-    char link[256];
-    snprintf(link, sizeof(link), "|c%s|Hitem:%u:0:0:0:0:0:0:0|h[%s]|h|r", ch, vi.itemId, info->name.c_str());
-    lua_pushstring(L, link);
-    return 1;
-}
-
-static int lua_CanMerchantRepair(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushboolean(L, gh && gh->getVendorItems().canRepair ? 1 : 0);
-    return 1;
-}
-
-// UnitStat(unit, statIndex) → base, effective, posBuff, negBuff
-
-static int lua_GetItemInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-
-    uint32_t itemId = 0;
-    if (lua_isnumber(L, 1)) {
-        itemId = static_cast<uint32_t>(lua_tonumber(L, 1));
-    } else if (lua_isstring(L, 1)) {
-        // Try to parse "item:12345" link format
-        const char* s = lua_tostring(L, 1);
-        std::string str(s ? s : "");
-        auto pos = str.find("item:");
-        if (pos != std::string::npos) {
-            try { itemId = static_cast<uint32_t>(std::stoul(str.substr(pos + 5))); } catch (...) {}
-        }
-    }
-    if (itemId == 0) { return luaReturnNil(L); }
-
-    const auto* info = gh->getItemInfo(itemId);
-    if (!info) { return luaReturnNil(L); }
-
-    lua_pushstring(L, info->name.c_str());          // 1: name
-    // Build item link with quality-colored text
-    const char* colorHex = (info->quality < 8) ? kQualHexAlpha[info->quality] : "ffffffff";
-    char link[256];
-    snprintf(link, sizeof(link), "|c%s|Hitem:%u:0:0:0:0:0:0:0|h[%s]|h|r",
-             colorHex, itemId, info->name.c_str());
-    lua_pushstring(L, link);                         // 2: link
-    lua_pushnumber(L, info->quality);                // 3: quality
-    lua_pushnumber(L, info->itemLevel);              // 4: iLevel
-    lua_pushnumber(L, info->requiredLevel);          // 5: requiredLevel
-    // 6: class (type string) — map itemClass to display name
-    {
-        static constexpr const char* kItemClasses[] = {
-            "Consumable", "Bag", "Weapon", "Gem", "Armor", "Reagent", "Projectile",
-            "Trade Goods", "Generic", "Recipe", "Money", "Quiver", "Quest", "Key",
-            "Permanent", "Miscellaneous", "Glyph"
-        };
-        if (info->itemClass < 17)
-            lua_pushstring(L, kItemClasses[info->itemClass]);
-        else
-            lua_pushstring(L, "Miscellaneous");
-    }
-    // 7: subclass — use subclassName from ItemDef if available, else generic
-    lua_pushstring(L, info->subclassName.empty() ? "" : info->subclassName.c_str());
-    lua_pushnumber(L, info->maxStack > 0 ? info->maxStack : 1); // 8: maxStack
-    // 9: equipSlot — WoW inventoryType to INVTYPE string
-    {
-        static constexpr const char* kInvTypes[] = {
-            "", "INVTYPE_HEAD", "INVTYPE_NECK", "INVTYPE_SHOULDER",
-            "INVTYPE_BODY", "INVTYPE_CHEST", "INVTYPE_WAIST", "INVTYPE_LEGS",
-            "INVTYPE_FEET", "INVTYPE_WRIST", "INVTYPE_HAND", "INVTYPE_FINGER",
-            "INVTYPE_TRINKET", "INVTYPE_WEAPON", "INVTYPE_SHIELD",
-            "INVTYPE_RANGED", "INVTYPE_CLOAK", "INVTYPE_2HWEAPON",
-            "INVTYPE_BAG", "INVTYPE_TABARD", "INVTYPE_ROBE",
-            "INVTYPE_WEAPONMAINHAND", "INVTYPE_WEAPONOFFHAND", "INVTYPE_HOLDABLE",
-            "INVTYPE_AMMO", "INVTYPE_THROWN", "INVTYPE_RANGEDRIGHT",
-            "INVTYPE_QUIVER", "INVTYPE_RELIC"
-        };
-        uint32_t invType = info->inventoryType;
-        lua_pushstring(L, invType < 29 ? kInvTypes[invType] : "");
-    }
-    // 10: texture (icon path from ItemDisplayInfo.dbc)
-    if (info->displayInfoId != 0) {
-        std::string iconPath = gh->getItemIconPath(info->displayInfoId);
-        if (!iconPath.empty()) lua_pushstring(L, iconPath.c_str());
-        else lua_pushnil(L);
-    } else {
-        lua_pushnil(L);
-    }
-    lua_pushnumber(L, info->sellPrice);              // 11: vendorPrice
-    return 11;
-}
-
-// GetItemQualityColor(quality) → r, g, b, hex
-// Quality: 0=Poor(gray), 1=Common(white), 2=Uncommon(green), 3=Rare(blue),
-//          4=Epic(purple), 5=Legendary(orange), 6=Artifact(gold), 7=Heirloom(gold)
-static int lua_GetItemQualityColor(lua_State* L) {
-    int q = static_cast<int>(luaL_checknumber(L, 1));
-    struct QC { float r, g, b; const char* hex; };
-    static const QC colors[] = {
-        {0.62f, 0.62f, 0.62f, "ff9d9d9d"}, // 0 Poor
-        {1.00f, 1.00f, 1.00f, "ffffffff"}, // 1 Common
-        {0.12f, 1.00f, 0.00f, "ff1eff00"}, // 2 Uncommon
-        {0.00f, 0.44f, 0.87f, "ff0070dd"}, // 3 Rare
-        {0.64f, 0.21f, 0.93f, "ffa335ee"}, // 4 Epic
-        {1.00f, 0.50f, 0.00f, "ffff8000"}, // 5 Legendary
-        {0.90f, 0.80f, 0.50f, "ffe6cc80"}, // 6 Artifact
-        {0.00f, 0.80f, 1.00f, "ff00ccff"}, // 7 Heirloom
-    };
-    if (q < 0 || q > 7) q = 1;
-    lua_pushnumber(L, colors[q].r);
-    lua_pushnumber(L, colors[q].g);
-    lua_pushnumber(L, colors[q].b);
-    lua_pushstring(L, colors[q].hex);
-    return 4;
-}
-
-// GetItemCount(itemId [, includeBank]) → count
-static int lua_GetItemCount(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnZero(L); }
-    uint32_t itemId = static_cast<uint32_t>(luaL_checknumber(L, 1));
-    const auto& inv = gh->getInventory();
-    uint32_t count = 0;
-    // Backpack
-    for (int i = 0; i < inv.getBackpackSize(); ++i) {
-        const auto& s = inv.getBackpackSlot(i);
-        if (!s.empty() && s.item.itemId == itemId)
-            count += (s.item.stackCount > 0 ? s.item.stackCount : 1);
-    }
-    // Bags 1-4
-    for (int b = 0; b < game::Inventory::NUM_BAG_SLOTS; ++b) {
-        int sz = inv.getBagSize(b);
-        for (int i = 0; i < sz; ++i) {
-            const auto& s = inv.getBagSlot(b, i);
-            if (!s.empty() && s.item.itemId == itemId)
-                count += (s.item.stackCount > 0 ? s.item.stackCount : 1);
-        }
-    }
-    lua_pushnumber(L, count);
-    return 1;
-}
-
-// UseContainerItem(bag, slot) — use/equip an item from a bag
-static int lua_UseContainerItem(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    int bag = static_cast<int>(luaL_checknumber(L, 1));
-    int slot = static_cast<int>(luaL_checknumber(L, 2));
-    const auto& inv = gh->getInventory();
-    const game::ItemSlot* itemSlot = nullptr;
-    if (bag == 0 && slot >= 1 && slot <= inv.getBackpackSize())
-        itemSlot = &inv.getBackpackSlot(slot - 1);
-    else if (bag >= 1 && bag <= 4) {
-        int sz = inv.getBagSize(bag - 1);
-        if (slot >= 1 && slot <= sz)
-            itemSlot = &inv.getBagSlot(bag - 1, slot - 1);
-    }
-    if (itemSlot && !itemSlot->empty())
-        gh->useItemById(itemSlot->item.itemId);
-    return 0;
-}
-
-// _GetItemTooltipData(itemId) → table with armor, bind, stats, damage, description
-// Returns a Lua table with detailed item info for tooltip building
-static int lua_GetItemTooltipData(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    uint32_t itemId = static_cast<uint32_t>(luaL_checknumber(L, 1));
-    if (!gh || itemId == 0) { return luaReturnNil(L); }
-    const auto* info = gh->getItemInfo(itemId);
-    if (!info) { return luaReturnNil(L); }
-
-    lua_newtable(L);
-    // Unique / Heroic flags
-    if (info->maxCount == 1) { lua_pushboolean(L, 1); lua_setfield(L, -2, "isUnique"); }
-    if (info->itemFlags & 0x8) { lua_pushboolean(L, 1); lua_setfield(L, -2, "isHeroic"); }
-    if (info->itemFlags & 0x1000000) { lua_pushboolean(L, 1); lua_setfield(L, -2, "isUniqueEquipped"); }
-    // Bind type
-    lua_pushnumber(L, info->bindType);
-    lua_setfield(L, -2, "bindType");
-    // Armor
-    lua_pushnumber(L, info->armor);
-    lua_setfield(L, -2, "armor");
-    // Damage
-    lua_pushnumber(L, info->damageMin);
-    lua_setfield(L, -2, "damageMin");
-    lua_pushnumber(L, info->damageMax);
-    lua_setfield(L, -2, "damageMax");
-    lua_pushnumber(L, info->delayMs);
-    lua_setfield(L, -2, "speed");
-    // Primary stats
-    if (info->stamina != 0) { lua_pushnumber(L, info->stamina); lua_setfield(L, -2, "stamina"); }
-    if (info->strength != 0) { lua_pushnumber(L, info->strength); lua_setfield(L, -2, "strength"); }
-    if (info->agility != 0) { lua_pushnumber(L, info->agility); lua_setfield(L, -2, "agility"); }
-    if (info->intellect != 0) { lua_pushnumber(L, info->intellect); lua_setfield(L, -2, "intellect"); }
-    if (info->spirit != 0) { lua_pushnumber(L, info->spirit); lua_setfield(L, -2, "spirit"); }
-    // Description
-    if (!info->description.empty()) {
-        lua_pushstring(L, info->description.c_str());
-        lua_setfield(L, -2, "description");
-    }
-    // Required level
-    lua_pushnumber(L, info->requiredLevel);
-    lua_setfield(L, -2, "requiredLevel");
-    // Extra stats (hit, crit, haste, AP, SP, etc.) as array of {type, value} pairs
-    if (!info->extraStats.empty()) {
-        lua_newtable(L);
-        for (size_t i = 0; i < info->extraStats.size(); ++i) {
-            lua_newtable(L);
-            lua_pushnumber(L, info->extraStats[i].statType);
-            lua_setfield(L, -2, "type");
-            lua_pushnumber(L, info->extraStats[i].statValue);
-            lua_setfield(L, -2, "value");
-            lua_rawseti(L, -2, static_cast<int>(i) + 1);
-        }
-        lua_setfield(L, -2, "extraStats");
-    }
-    // Resistances
-    if (info->fireRes != 0) { lua_pushnumber(L, info->fireRes); lua_setfield(L, -2, "fireRes"); }
-    if (info->natureRes != 0) { lua_pushnumber(L, info->natureRes); lua_setfield(L, -2, "natureRes"); }
-    if (info->frostRes != 0) { lua_pushnumber(L, info->frostRes); lua_setfield(L, -2, "frostRes"); }
-    if (info->shadowRes != 0) { lua_pushnumber(L, info->shadowRes); lua_setfield(L, -2, "shadowRes"); }
-    if (info->arcaneRes != 0) { lua_pushnumber(L, info->arcaneRes); lua_setfield(L, -2, "arcaneRes"); }
-    // Item spell effects (Use: / Equip: / Chance on Hit:)
-    {
-        lua_newtable(L);
-        int spellCount = 0;
-        for (int i = 0; i < 5; ++i) {
-            if (info->spells[i].spellId == 0) continue;
-            ++spellCount;
-            lua_newtable(L);
-            lua_pushnumber(L, info->spells[i].spellId);
-            lua_setfield(L, -2, "spellId");
-            lua_pushnumber(L, info->spells[i].spellTrigger);
-            lua_setfield(L, -2, "trigger");
-            // Get spell name for display
-            const std::string& sName = gh->getSpellName(info->spells[i].spellId);
-            if (!sName.empty()) { lua_pushstring(L, sName.c_str()); lua_setfield(L, -2, "name"); }
-            // Get description
-            const std::string& sDesc = gh->getSpellDescription(info->spells[i].spellId);
-            if (!sDesc.empty()) { lua_pushstring(L, sDesc.c_str()); lua_setfield(L, -2, "description"); }
-            lua_rawseti(L, -2, spellCount);
-        }
-        if (spellCount > 0) lua_setfield(L, -2, "itemSpells");
-        else lua_pop(L, 1);
-    }
-    // Gem sockets (WotLK/TBC)
-    int numSockets = 0;
-    for (int i = 0; i < 3; ++i) {
-        if (info->socketColor[i] != 0) ++numSockets;
-    }
-    if (numSockets > 0) {
-        lua_newtable(L);
-        for (int i = 0; i < 3; ++i) {
-            if (info->socketColor[i] != 0) {
-                lua_newtable(L);
-                lua_pushnumber(L, info->socketColor[i]);
-                lua_setfield(L, -2, "color");
-                lua_rawseti(L, -2, i + 1);
-            }
-        }
-        lua_setfield(L, -2, "sockets");
-    }
-    // Item set
-    if (info->itemSetId != 0) {
-        lua_pushnumber(L, info->itemSetId);
-        lua_setfield(L, -2, "itemSetId");
-    }
-    // Quest-starting item
-    if (info->startQuestId != 0) {
-        lua_pushboolean(L, 1);
-        lua_setfield(L, -2, "startsQuest");
-    }
-    return 1;
-}
-
-// --- Locale/Build/Realm info ---
-
-
-static int lua_GetContainerNumSlots(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int container = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh) { return luaReturnZero(L); }
-    const auto& inv = gh->getInventory();
-    if (container == 0) {
-        lua_pushnumber(L, inv.getBackpackSize());
-    } else if (container >= 1 && container <= 4) {
-        lua_pushnumber(L, inv.getBagSize(container - 1));
-    } else {
-        lua_pushnumber(L, 0);
-    }
-    return 1;
-}
-
-// GetContainerItemInfo(container, slot) → texture, count, locked, quality, readable, lootable, link
-static int lua_GetContainerItemInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int container = static_cast<int>(luaL_checknumber(L, 1));
-    int slot = static_cast<int>(luaL_checknumber(L, 2));
-    if (!gh) { return luaReturnNil(L); }
-
-    const auto& inv = gh->getInventory();
-    const game::ItemSlot* itemSlot = nullptr;
-
-    if (container == 0 && slot >= 1 && slot <= inv.getBackpackSize()) {
-        itemSlot = &inv.getBackpackSlot(slot - 1);  // WoW uses 1-based
-    } else if (container >= 1 && container <= 4) {
-        int bagIdx = container - 1;
-        int bagSize = inv.getBagSize(bagIdx);
-        if (slot >= 1 && slot <= bagSize)
-            itemSlot = &inv.getBagSlot(bagIdx, slot - 1);
-    }
-
-    if (!itemSlot || itemSlot->empty()) { return luaReturnNil(L); }
-
-    // Get item info for quality/icon
-    const auto* info = gh->getItemInfo(itemSlot->item.itemId);
-
-    lua_pushnil(L);  // texture (icon path — would need ItemDisplayInfo icon resolver)
-    lua_pushnumber(L, itemSlot->item.stackCount);  // count
-    lua_pushboolean(L, 0);  // locked
-    lua_pushnumber(L, info ? info->quality : 0);  // quality
-    lua_pushboolean(L, 0);  // readable
-    lua_pushboolean(L, 0);  // lootable
-    // Build item link with quality color
-    std::string name = info ? info->name : ("Item #" + std::to_string(itemSlot->item.itemId));
-    uint32_t q = info ? info->quality : 0;
-
-    uint32_t qi = q < 8 ? q : 1u;
-    char link[256];
-    snprintf(link, sizeof(link), "|cff%s|Hitem:%u:0:0:0:0:0:0:0|h[%s]|h|r",
-             kQualHexNoAlpha[qi], itemSlot->item.itemId, name.c_str());
-    lua_pushstring(L, link);  // link
-    return 7;
-}
-
-// GetContainerItemLink(container, slot) → item link string
-static int lua_GetContainerItemLink(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int container = static_cast<int>(luaL_checknumber(L, 1));
-    int slot = static_cast<int>(luaL_checknumber(L, 2));
-    if (!gh) { return luaReturnNil(L); }
-
-    const auto& inv = gh->getInventory();
-    const game::ItemSlot* itemSlot = nullptr;
-
-    if (container == 0 && slot >= 1 && slot <= inv.getBackpackSize()) {
-        itemSlot = &inv.getBackpackSlot(slot - 1);
-    } else if (container >= 1 && container <= 4) {
-        int bagIdx = container - 1;
-        int bagSize = inv.getBagSize(bagIdx);
-        if (slot >= 1 && slot <= bagSize)
-            itemSlot = &inv.getBagSlot(bagIdx, slot - 1);
-    }
-
-    if (!itemSlot || itemSlot->empty()) { return luaReturnNil(L); }
-    const auto* info = gh->getItemInfo(itemSlot->item.itemId);
-    std::string name = info ? info->name : ("Item #" + std::to_string(itemSlot->item.itemId));
-    uint32_t q = info ? info->quality : 0;
-    char link[256];
-
-    uint32_t qi = q < 8 ? q : 1u;
-    snprintf(link, sizeof(link), "|cff%s|Hitem:%u:0:0:0:0:0:0:0|h[%s]|h|r",
-             kQualHexNoAlpha[qi], itemSlot->item.itemId, name.c_str());
-    lua_pushstring(L, link);
-    return 1;
-}
-
-// GetContainerNumFreeSlots(container) → numFreeSlots, bagType
-static int lua_GetContainerNumFreeSlots(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int container = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh) { lua_pushnumber(L, 0); lua_pushnumber(L, 0); return 2; }
-
-    const auto& inv = gh->getInventory();
-    int freeSlots = 0;
-    int totalSlots = 0;
-
-    if (container == 0) {
-        totalSlots = inv.getBackpackSize();
-        for (int i = 0; i < totalSlots; ++i)
-            if (inv.getBackpackSlot(i).empty()) ++freeSlots;
-    } else if (container >= 1 && container <= 4) {
-        totalSlots = inv.getBagSize(container - 1);
-        for (int i = 0; i < totalSlots; ++i)
-            if (inv.getBagSlot(container - 1, i).empty()) ++freeSlots;
-    }
-
-    lua_pushnumber(L, freeSlots);
-    lua_pushnumber(L, 0);  // bagType (0 = normal)
-    return 2;
-}
-
-// --- Equipment Slot API ---
-// WoW inventory slot IDs: 1=Head,2=Neck,3=Shoulders,4=Shirt,5=Chest,
-// 6=Waist,7=Legs,8=Feet,9=Wrists,10=Hands,11=Ring1,12=Ring2,
-// 13=Trinket1,14=Trinket2,15=Back,16=MainHand,17=OffHand,18=Ranged,19=Tabard
-
-// GetInventorySlotInfo("slotName") → slotId, textureName, checkRelic
-// Maps WoW slot names (e.g. "HeadSlot", "HEADSLOT") to inventory slot IDs
-static int lua_GetInventorySlotInfo(lua_State* L) {
-    const char* name = luaL_checkstring(L, 1);
-    std::string slot(name);
-    // Normalize: uppercase, strip trailing "SLOT" if present
-    for (char& c : slot) c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
-    if (slot.size() > 4 && slot.substr(slot.size() - 4) == "SLOT")
-        slot = slot.substr(0, slot.size() - 4);
-
-    // WoW inventory slots are 1-indexed
-    struct SlotMap { const char* name; int id; const char* texture; };
-    static const SlotMap mapping[] = {
-        {"HEAD",          1,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Head"},
-        {"NECK",          2,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Neck"},
-        {"SHOULDER",      3,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Shoulder"},
-        {"SHIRT",         4,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Shirt"},
-        {"CHEST",         5,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Chest"},
-        {"WAIST",         6,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Waist"},
-        {"LEGS",          7,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Legs"},
-        {"FEET",          8,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Feet"},
-        {"WRIST",         9,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Wrists"},
-        {"HANDS",        10,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Hands"},
-        {"FINGER0",      11,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Finger"},
-        {"FINGER1",      12,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Finger"},
-        {"TRINKET0",     13,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Trinket"},
-        {"TRINKET1",     14,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Trinket"},
-        {"BACK",         15,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Chest"},
-        {"MAINHAND",     16,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-MainHand"},
-        {"SECONDARYHAND",17,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-SecondaryHand"},
-        {"RANGED",       18,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Ranged"},
-        {"TABARD",       19,  "Interface\\PaperDoll\\UI-PaperDoll-Slot-Tabard"},
-    };
-    for (const auto& m : mapping) {
-        if (slot == m.name) {
-            lua_pushnumber(L, m.id);
-            lua_pushstring(L, m.texture);
-            lua_pushboolean(L, m.id == 18 ? 1 : 0); // checkRelic: only ranged slot
-            return 3;
-        }
-    }
-    luaL_error(L, "Unknown inventory slot: %s", name);
-    return 0;
-}
-
-static int lua_GetInventoryItemLink(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    const char* uid = luaL_optstring(L, 1, "player");
-    int slotId = static_cast<int>(luaL_checknumber(L, 2));
-    if (!gh || slotId < 1 || slotId > 19) { return luaReturnNil(L); }
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    if (uidStr != "player") { return luaReturnNil(L); }
-
-    const auto& inv = gh->getInventory();
-    const auto& slot = inv.getEquipSlot(static_cast<game::EquipSlot>(slotId - 1));
-    if (slot.empty()) { return luaReturnNil(L); }
-
-    const auto* info = gh->getItemInfo(slot.item.itemId);
-    std::string name = info ? info->name : slot.item.name;
-    uint32_t q = info ? info->quality : static_cast<uint32_t>(slot.item.quality);
-
-    uint32_t qi = q < 8 ? q : 1u;
-    char link[256];
-    snprintf(link, sizeof(link), "|cff%s|Hitem:%u:0:0:0:0:0:0:0|h[%s]|h|r",
-             kQualHexNoAlpha[qi], slot.item.itemId, name.c_str());
-    lua_pushstring(L, link);
-    return 1;
-}
-
-static int lua_GetInventoryItemID(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    const char* uid = luaL_optstring(L, 1, "player");
-    int slotId = static_cast<int>(luaL_checknumber(L, 2));
-    if (!gh || slotId < 1 || slotId > 19) { return luaReturnNil(L); }
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    if (uidStr != "player") { return luaReturnNil(L); }
-
-    const auto& inv = gh->getInventory();
-    const auto& slot = inv.getEquipSlot(static_cast<game::EquipSlot>(slotId - 1));
-    if (slot.empty()) { return luaReturnNil(L); }
-    lua_pushnumber(L, slot.item.itemId);
-    return 1;
-}
-
-static int lua_GetInventoryItemTexture(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    const char* uid = luaL_optstring(L, 1, "player");
-    int slotId = static_cast<int>(luaL_checknumber(L, 2));
-    if (!gh || slotId < 1 || slotId > 19) { return luaReturnNil(L); }
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    if (uidStr != "player") { return luaReturnNil(L); }
-
-    const auto& inv = gh->getInventory();
-    const auto& slot = inv.getEquipSlot(static_cast<game::EquipSlot>(slotId - 1));
-    if (slot.empty()) { return luaReturnNil(L); }
-    lua_pushnil(L);
-    return 1;
-}
-
-static int lua_GetNumLootItems(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh || !gh->isLootWindowOpen()) { return luaReturnZero(L); }
-    lua_pushnumber(L, gh->getCurrentLoot().items.size());
-    return 1;
-}
-
-// GetLootSlotInfo(slot) → texture, name, quantity, quality, locked
-static int lua_GetLootSlotInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int slot = static_cast<int>(luaL_checknumber(L, 1)); // 1-indexed
-    if (!gh || !gh->isLootWindowOpen()) {
-        return luaReturnNil(L);
-    }
-    const auto& loot = gh->getCurrentLoot();
-    if (slot < 1 || slot > static_cast<int>(loot.items.size())) {
-        return luaReturnNil(L);
-    }
-    const auto& item = loot.items[slot - 1];
-    const auto* info = gh->getItemInfo(item.itemId);
-
-    // texture (icon path from ItemDisplayInfo.dbc)
-    std::string icon;
-    if (info && info->displayInfoId != 0) {
-        icon = gh->getItemIconPath(info->displayInfoId);
-    }
-    if (!icon.empty()) lua_pushstring(L, icon.c_str());
-    else lua_pushnil(L);
-
-    // name
-    if (info && !info->name.empty()) lua_pushstring(L, info->name.c_str());
-    else lua_pushstring(L, ("Item #" + std::to_string(item.itemId)).c_str());
-
-    lua_pushnumber(L, item.count);                           // quantity
-    lua_pushnumber(L, info ? info->quality : 1);             // quality
-    lua_pushboolean(L, 0);                                   // locked (not tracked)
-    return 5;
-}
-
-// GetLootSlotLink(slot) → itemLink
-static int lua_GetLootSlotLink(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int slot = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || !gh->isLootWindowOpen()) { return luaReturnNil(L); }
-    const auto& loot = gh->getCurrentLoot();
-    if (slot < 1 || slot > static_cast<int>(loot.items.size())) {
-        return luaReturnNil(L);
-    }
-    const auto& item = loot.items[slot - 1];
-    const auto* info = gh->getItemInfo(item.itemId);
-    if (!info || info->name.empty()) { return luaReturnNil(L); }
-
-    uint32_t qi = info->quality < 8 ? info->quality : 1u;
-    char link[256];
-    snprintf(link, sizeof(link), "|cff%s|Hitem:%u:0:0:0:0:0:0:0|h[%s]|h|r",
-             kQualHexNoAlpha[qi], item.itemId, info->name.c_str());
-    lua_pushstring(L, link);
-    return 1;
-}
-
-// LootSlot(slot) — take item from loot
-static int lua_LootSlot(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int slot = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || !gh->isLootWindowOpen()) return 0;
-    const auto& loot = gh->getCurrentLoot();
-    if (slot < 1 || slot > static_cast<int>(loot.items.size())) return 0;
-    gh->lootItem(loot.items[slot - 1].slotIndex);
-    return 0;
-}
-
-// CloseLoot() — close loot window
-static int lua_CloseLoot(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (gh) gh->closeLoot();
-    return 0;
-}
-
-// GetLootMethod() → "freeforall"|"roundrobin"|"master"|"group"|"needbeforegreed", partyLoot, raidLoot
-static int lua_GetLootMethod(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushstring(L, "freeforall"); lua_pushnumber(L, 0); lua_pushnumber(L, 0); return 3; }
-    const auto& pd = gh->getPartyData();
-    const char* method = "freeforall";
-    switch (pd.lootMethod) {
-        case 0: method = "freeforall"; break;
-        case 1: method = "roundrobin"; break;
-        case 2: method = "master"; break;
-        case 3: method = "group"; break;
-        case 4: method = "needbeforegreed"; break;
-    }
-    lua_pushstring(L, method);
-    lua_pushnumber(L, 0); // partyLootMaster (index)
-    lua_pushnumber(L, 0); // raidLootMaster (index)
-    return 3;
-}
-
-// --- Additional WoW API ---
-
-static int lua_GetItemLink(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-    uint32_t itemId = static_cast<uint32_t>(luaL_checknumber(L, 1));
-    if (itemId == 0) { return luaReturnNil(L); }
-    const auto* info = gh->getItemInfo(itemId);
-    if (!info || info->name.empty()) { return luaReturnNil(L); }
-
-    uint32_t qi = info->quality < 8 ? info->quality : 1u;
-    char link[256];
-    snprintf(link, sizeof(link), "|cff%s|Hitem:%u:0:0:0:0:0:0:0|h[%s]|h|r",
-             kQualHexNoAlpha[qi], itemId, info->name.c_str());
-    lua_pushstring(L, link);
-    return 1;
-}
-
-// GetSpellLink(spellIdOrName) → "|cFFxxxxxx|Hspell:ID|h[Name]|h|r"
-
-void registerInventoryLuaAPI(lua_State* L) {
-    static const struct { const char* name; lua_CFunction func; } api[] = {
-                {"GetMoney",      lua_GetMoney},
-                {"GetMerchantNumItems",  lua_GetMerchantNumItems},
-                {"GetMerchantItemInfo",  lua_GetMerchantItemInfo},
-                {"GetMerchantItemLink",  lua_GetMerchantItemLink},
-                {"CanMerchantRepair",    lua_CanMerchantRepair},
-                {"GetItemInfo",       lua_GetItemInfo},
-                {"GetItemQualityColor", lua_GetItemQualityColor},
-                {"_GetItemTooltipData", lua_GetItemTooltipData},
-                {"GetItemCount",      lua_GetItemCount},
-                {"UseContainerItem",  lua_UseContainerItem},
-                {"GetContainerNumSlots",    lua_GetContainerNumSlots},
-                {"GetContainerItemInfo",    lua_GetContainerItemInfo},
-                {"GetContainerItemLink",    lua_GetContainerItemLink},
-                {"GetContainerNumFreeSlots", lua_GetContainerNumFreeSlots},
-                {"GetInventorySlotInfo",    lua_GetInventorySlotInfo},
-                {"GetInventoryItemLink",    lua_GetInventoryItemLink},
-                {"GetInventoryItemID",      lua_GetInventoryItemID},
-                {"GetInventoryItemTexture", lua_GetInventoryItemTexture},
-                {"GetItemLink",          lua_GetItemLink},
-                {"GetNumLootItems",     lua_GetNumLootItems},
-                {"GetLootSlotInfo",     lua_GetLootSlotInfo},
-                {"GetLootSlotLink",     lua_GetLootSlotLink},
-                {"LootSlot",            lua_LootSlot},
-                {"CloseLoot",           lua_CloseLoot},
-                {"GetLootMethod",       lua_GetLootMethod},
-                {"BuyMerchantItem", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            int count = static_cast<int>(luaL_optnumber(L, 2, 1));
-            if (!gh || index < 1) return 0;
-            const auto& items = gh->getVendorItems().items;
-            if (index > static_cast<int>(items.size())) return 0;
-            const auto& vi = items[index - 1];
-            gh->buyItem(gh->getVendorGuid(), vi.itemId, vi.slot, count);
-            return 0;
-        }},
-                {"SellContainerItem", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int bag = static_cast<int>(luaL_checknumber(L, 1));
-            int slot = static_cast<int>(luaL_checknumber(L, 2));
-            if (!gh) return 0;
-            if (bag == 0) gh->sellItemBySlot(slot - 1);
-            else if (bag >= 1 && bag <= 4) gh->sellItemInBag(bag - 1, slot - 1);
-            return 0;
-        }},
-                {"RepairAllItems", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh && gh->getVendorItems().canRepair) {
-                bool useGuildBank = lua_toboolean(L, 1) != 0;
-                gh->repairAll(gh->getVendorGuid(), useGuildBank);
-            }
-            return 0;
-        }},
-                {"UnequipItemSlot", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int slot = static_cast<int>(luaL_checknumber(L, 1));
-            if (gh && slot >= 1 && slot <= 19)
-                gh->unequipToBackpack(static_cast<game::EquipSlot>(slot - 1));
-            return 0;
-        }},
-                {"AcceptTrade", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->acceptTrade();
-            return 0;
-        }},
-                {"CancelTrade", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh && gh->isTradeOpen()) gh->cancelTrade();
-            return 0;
-        }},
-                {"InitiateTrade", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const char* uid = luaL_checkstring(L, 1);
-            if (gh) {
-                uint64_t guid = resolveUnitGuid(gh, std::string(uid));
-                if (guid != 0) gh->initiateTrade(guid);
-            }
-            return 0;
-        }},
-                {"GetNumAuctionItems", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const char* listType = luaL_optstring(L, 1, "list");
-            if (!gh) { lua_pushnumber(L, 0); lua_pushnumber(L, 0); return 2; }
-            std::string t(listType);
-            const game::AuctionListResult* r = nullptr;
-            if (t == "list" || t == "browse") r = &gh->getAuctionBrowseResults();
-            else if (t == "owner") r = &gh->getAuctionOwnerResults();
-            else if (t == "bidder") r = &gh->getAuctionBidderResults();
-            lua_pushnumber(L, r ? r->auctions.size() : 0);
-            lua_pushnumber(L, r ? r->totalCount : 0);
-            return 2;
-        }},
-                {"GetAuctionItemInfo", [](lua_State* L) -> int {
-            // GetAuctionItemInfo(type, index) → name, texture, count, quality, canUse, level, levelColHeader, minBid, minIncrement, buyoutPrice, bidAmount, highBidder, bidderFullName, owner, ownerFullName, saleStatus, itemId
-            auto* gh = getGameHandler(L);
-            const char* listType = luaL_checkstring(L, 1);
-            int index = static_cast<int>(luaL_checknumber(L, 2));
-            if (!gh || index < 1) { return luaReturnNil(L); }
-            std::string t(listType);
-            const game::AuctionListResult* r = nullptr;
-            if (t == "list") r = &gh->getAuctionBrowseResults();
-            else if (t == "owner") r = &gh->getAuctionOwnerResults();
-            else if (t == "bidder") r = &gh->getAuctionBidderResults();
-            if (!r || index > static_cast<int>(r->auctions.size())) { return luaReturnNil(L); }
-            const auto& a = r->auctions[index - 1];
-            const auto* info = gh->getItemInfo(a.itemEntry);
-            std::string name = info ? info->name : "Item #" + std::to_string(a.itemEntry);
-            std::string icon = (info && info->displayInfoId != 0) ? gh->getItemIconPath(info->displayInfoId) : "";
-            uint32_t quality = info ? info->quality : 1;
-            lua_pushstring(L, name.c_str());        // name
-            lua_pushstring(L, icon.empty() ? "Interface\\Icons\\INV_Misc_QuestionMark" : icon.c_str()); // texture
-            lua_pushnumber(L, a.stackCount);        // count
-            lua_pushnumber(L, quality);             // quality
-            lua_pushboolean(L, 1);                  // canUse
-            lua_pushnumber(L, info ? info->requiredLevel : 0); // level
-            lua_pushstring(L, "");                  // levelColHeader
-            lua_pushnumber(L, a.startBid);          // minBid
-            lua_pushnumber(L, a.minBidIncrement);   // minIncrement
-            lua_pushnumber(L, a.buyoutPrice);       // buyoutPrice
-            lua_pushnumber(L, a.currentBid);        // bidAmount
-            lua_pushboolean(L, a.bidderGuid != 0 ? 1 : 0); // highBidder
-            lua_pushstring(L, "");                  // bidderFullName
-            lua_pushstring(L, "");                  // owner
-            lua_pushstring(L, "");                  // ownerFullName
-            lua_pushnumber(L, 0);                   // saleStatus
-            lua_pushnumber(L, a.itemEntry);         // itemId
-            return 17;
-        }},
-                {"GetAuctionItemTimeLeft", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const char* listType = luaL_checkstring(L, 1);
-            int index = static_cast<int>(luaL_checknumber(L, 2));
-            if (!gh || index < 1) { lua_pushnumber(L, 4); return 1; }
-            std::string t(listType);
-            const game::AuctionListResult* r = nullptr;
-            if (t == "list") r = &gh->getAuctionBrowseResults();
-            else if (t == "owner") r = &gh->getAuctionOwnerResults();
-            else if (t == "bidder") r = &gh->getAuctionBidderResults();
-            if (!r || index > static_cast<int>(r->auctions.size())) { lua_pushnumber(L, 4); return 1; }
-            // Return 1=short(<30m), 2=medium(<2h), 3=long(<12h), 4=very long(>12h)
-            uint32_t ms = r->auctions[index - 1].timeLeftMs;
-            int cat = (ms < 1800000) ? 1 : (ms < 7200000) ? 2 : (ms < 43200000) ? 3 : 4;
-            lua_pushnumber(L, cat);
-            return 1;
-        }},
-                {"GetAuctionItemLink", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const char* listType = luaL_checkstring(L, 1);
-            int index = static_cast<int>(luaL_checknumber(L, 2));
-            if (!gh || index < 1) { return luaReturnNil(L); }
-            std::string t(listType);
-            const game::AuctionListResult* r = nullptr;
-            if (t == "list") r = &gh->getAuctionBrowseResults();
-            else if (t == "owner") r = &gh->getAuctionOwnerResults();
-            else if (t == "bidder") r = &gh->getAuctionBidderResults();
-            if (!r || index > static_cast<int>(r->auctions.size())) { return luaReturnNil(L); }
-            uint32_t itemId = r->auctions[index - 1].itemEntry;
-            const auto* info = gh->getItemInfo(itemId);
-            if (!info) { return luaReturnNil(L); }
-        
-            const char* ch = (info->quality < 8) ? kQualHexAlpha[info->quality] : "ffffffff";
-            char link[256];
-            snprintf(link, sizeof(link), "|c%s|Hitem:%u:0:0:0:0:0:0:0|h[%s]|h|r", ch, itemId, info->name.c_str());
-            lua_pushstring(L, link);
-            return 1;
-        }},
-                {"GetInboxNumItems", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            lua_pushnumber(L, gh ? gh->getMailInbox().size() : 0);
-            return 1;
-        }},
-                {"GetInboxHeaderInfo", [](lua_State* L) -> int {
-            // GetInboxHeaderInfo(index) → packageIcon, stationeryIcon, sender, subject, money, COD, daysLeft, hasItem, wasRead, wasReturned, textCreated, canReply, isGM
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            if (!gh || index < 1) { return luaReturnNil(L); }
-            const auto& inbox = gh->getMailInbox();
-            if (index > static_cast<int>(inbox.size())) { return luaReturnNil(L); }
-            const auto& mail = inbox[index - 1];
-            lua_pushstring(L, "Interface\\Icons\\INV_Letter_15"); // packageIcon
-            lua_pushstring(L, "Interface\\Icons\\INV_Letter_15"); // stationeryIcon
-            lua_pushstring(L, mail.senderName.c_str());           // sender
-            lua_pushstring(L, mail.subject.c_str());              // subject
-            lua_pushnumber(L, mail.money);                        // money (copper)
-            lua_pushnumber(L, mail.cod);                          // COD
-            lua_pushnumber(L, mail.expirationTime / 86400.0f);   // daysLeft
-            lua_pushboolean(L, mail.attachments.empty() ? 0 : 1); // hasItem
-            lua_pushboolean(L, mail.read ? 1 : 0);               // wasRead
-            lua_pushboolean(L, 0);                                // wasReturned
-            lua_pushboolean(L, !mail.body.empty() ? 1 : 0);      // textCreated
-            lua_pushboolean(L, mail.messageType == 0 ? 1 : 0);   // canReply (player mail only)
-            lua_pushboolean(L, 0);                                // isGM
-            return 13;
-        }},
-                {"GetInboxText", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            if (!gh || index < 1) { return luaReturnNil(L); }
-            const auto& inbox = gh->getMailInbox();
-            if (index > static_cast<int>(inbox.size())) { return luaReturnNil(L); }
-            lua_pushstring(L, inbox[index - 1].body.c_str());
-            return 1;
-        }},
-                {"HasNewMail", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (!gh) { return luaReturnFalse(L); }
-            bool hasNew = false;
-            for (const auto& m : gh->getMailInbox()) {
-                if (!m.read) { hasNew = true; break; }
-            }
-            lua_pushboolean(L, hasNew ? 1 : 0);
-            return 1;
-        }},
-    };
-    for (const auto& [name, func] : api) {
-        lua_pushcfunction(L, func);
-        lua_setglobal(L, name);
-    }
-}
-
-} // namespace wowee::addons
diff --git a/src/addons/lua_quest_api.cpp b/src/addons/lua_quest_api.cpp
deleted file mode 100644
index 1e74806e..00000000
--- a/src/addons/lua_quest_api.cpp
+++ /dev/null
@@ -1,564 +0,0 @@
-// lua_quest_api.cpp — Quest log, skills, talents, glyphs, and achievements Lua API bindings.
-// Extracted from lua_engine.cpp as part of §5.1 (Tame LuaEngine).
-#include "addons/lua_api_helpers.hpp"
-
-namespace wowee::addons {
-
-static int lua_GetNumQuestLogEntries(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushnumber(L, 0); lua_pushnumber(L, 0); return 2; }
-    const auto& ql = gh->getQuestLog();
-    lua_pushnumber(L, ql.size());  // numEntries
-    lua_pushnumber(L, 0);          // numQuests (headers not tracked)
-    return 2;
-}
-
-// GetQuestLogTitle(index) → title, level, suggestedGroup, isHeader, isCollapsed, isComplete, frequency, questID
-static int lua_GetQuestLogTitle(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int index = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || index < 1) { return luaReturnNil(L); }
-    const auto& ql = gh->getQuestLog();
-    if (index > static_cast<int>(ql.size())) { return luaReturnNil(L); }
-    const auto& q = ql[index - 1];  // 1-based
-    lua_pushstring(L, q.title.c_str());  // title
-    lua_pushnumber(L, 0);                // level (not tracked)
-    lua_pushnumber(L, 0);                // suggestedGroup
-    lua_pushboolean(L, 0);               // isHeader
-    lua_pushboolean(L, 0);               // isCollapsed
-    lua_pushboolean(L, q.complete);      // isComplete
-    lua_pushnumber(L, 0);                // frequency
-    lua_pushnumber(L, q.questId);        // questID
-    return 8;
-}
-
-// GetQuestLogQuestText(index) → description, objectives
-static int lua_GetQuestLogQuestText(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int index = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || index < 1) { return luaReturnNil(L); }
-    const auto& ql = gh->getQuestLog();
-    if (index > static_cast<int>(ql.size())) { return luaReturnNil(L); }
-    const auto& q = ql[index - 1];
-    lua_pushstring(L, "");                    // description (not stored)
-    lua_pushstring(L, q.objectives.c_str());  // objectives
-    return 2;
-}
-
-// IsQuestComplete(questID) → boolean
-static int lua_IsQuestComplete(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    uint32_t questId = static_cast<uint32_t>(luaL_checknumber(L, 1));
-    if (!gh) { return luaReturnFalse(L); }
-    for (const auto& q : gh->getQuestLog()) {
-        if (q.questId == questId) {
-            lua_pushboolean(L, q.complete);
-            return 1;
-        }
-    }
-    lua_pushboolean(L, 0);
-    return 1;
-}
-
-// SelectQuestLogEntry(index) — select a quest in the quest log
-static int lua_SelectQuestLogEntry(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int index = static_cast<int>(luaL_checknumber(L, 1));
-    if (gh) gh->setSelectedQuestLogIndex(index);
-    return 0;
-}
-
-// GetQuestLogSelection() → index
-static int lua_GetQuestLogSelection(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushnumber(L, gh ? gh->getSelectedQuestLogIndex() : 0);
-    return 1;
-}
-
-// GetNumQuestWatches() → count
-static int lua_GetNumQuestWatches(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushnumber(L, gh ? gh->getTrackedQuestIds().size() : 0);
-    return 1;
-}
-
-// GetQuestIndexForWatch(watchIndex) → questLogIndex
-// Maps the Nth watched quest to its quest log index (1-based)
-static int lua_GetQuestIndexForWatch(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int watchIdx = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || watchIdx < 1) { return luaReturnNil(L); }
-    const auto& ql = gh->getQuestLog();
-    const auto& tracked = gh->getTrackedQuestIds();
-    int found = 0;
-    for (size_t i = 0; i < ql.size(); ++i) {
-        if (tracked.count(ql[i].questId)) {
-            found++;
-            if (found == watchIdx) {
-                lua_pushnumber(L, static_cast<int>(i) + 1); // 1-based
-                return 1;
-            }
-        }
-    }
-    lua_pushnil(L);
-    return 1;
-}
-
-// AddQuestWatch(questLogIndex) — add a quest to the watch list
-static int lua_AddQuestWatch(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int index = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || index < 1) return 0;
-    const auto& ql = gh->getQuestLog();
-    if (index <= static_cast<int>(ql.size())) {
-        gh->setQuestTracked(ql[index - 1].questId, true);
-    }
-    return 0;
-}
-
-// RemoveQuestWatch(questLogIndex) — remove a quest from the watch list
-static int lua_RemoveQuestWatch(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int index = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || index < 1) return 0;
-    const auto& ql = gh->getQuestLog();
-    if (index <= static_cast<int>(ql.size())) {
-        gh->setQuestTracked(ql[index - 1].questId, false);
-    }
-    return 0;
-}
-
-// IsQuestWatched(questLogIndex) → boolean
-static int lua_IsQuestWatched(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int index = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || index < 1) { return luaReturnFalse(L); }
-    const auto& ql = gh->getQuestLog();
-    if (index <= static_cast<int>(ql.size())) {
-        lua_pushboolean(L, gh->isQuestTracked(ql[index - 1].questId) ? 1 : 0);
-    } else {
-        lua_pushboolean(L, 0);
-    }
-    return 1;
-}
-
-// GetQuestLink(questLogIndex) → "|cff...|Hquest:id:level|h[title]|h|r"
-static int lua_GetQuestLink(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int index = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || index < 1) { return luaReturnNil(L); }
-    const auto& ql = gh->getQuestLog();
-    if (index > static_cast<int>(ql.size())) { return luaReturnNil(L); }
-    const auto& q = ql[index - 1];
-    // Yellow quest link format matching WoW
-    std::string link = "|cff808000|Hquest:" + std::to_string(q.questId) +
-                       ":0|h[" + q.title + "]|h|r";
-    lua_pushstring(L, link.c_str());
-    return 1;
-}
-
-// GetNumQuestLeaderBoards(questLogIndex) → count of objectives
-static int lua_GetNumQuestLeaderBoards(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int index = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || index < 1) { return luaReturnZero(L); }
-    const auto& ql = gh->getQuestLog();
-    if (index > static_cast<int>(ql.size())) { return luaReturnZero(L); }
-    const auto& q = ql[index - 1];
-    int count = 0;
-    for (const auto& ko : q.killObjectives) {
-        if (ko.npcOrGoId != 0 || ko.required > 0) ++count;
-    }
-    for (const auto& io : q.itemObjectives) {
-        if (io.itemId != 0 || io.required > 0) ++count;
-    }
-    lua_pushnumber(L, count);
-    return 1;
-}
-
-// GetQuestLogLeaderBoard(objIndex, questLogIndex) → text, type, finished
-// objIndex is 1-based within the quest's objectives
-static int lua_GetQuestLogLeaderBoard(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int objIdx = static_cast<int>(luaL_checknumber(L, 1));
-    int questIdx = static_cast<int>(luaL_optnumber(L, 2,
-        gh ? gh->getSelectedQuestLogIndex() : 0));
-    if (!gh || questIdx < 1 || objIdx < 1) { return luaReturnNil(L); }
-    const auto& ql = gh->getQuestLog();
-    if (questIdx > static_cast<int>(ql.size())) { return luaReturnNil(L); }
-    const auto& q = ql[questIdx - 1];
-
-    // Build ordered list: kill objectives first, then item objectives
-    int cur = 0;
-    for (int i = 0; i < 4; ++i) {
-        if (q.killObjectives[i].npcOrGoId == 0 && q.killObjectives[i].required == 0) continue;
-        ++cur;
-        if (cur == objIdx) {
-            // Get current count from killCounts map (keyed by abs(npcOrGoId))
-            uint32_t key = static_cast<uint32_t>(std::abs(q.killObjectives[i].npcOrGoId));
-            uint32_t current = 0;
-            auto it = q.killCounts.find(key);
-            if (it != q.killCounts.end()) current = it->second.first;
-            uint32_t required = q.killObjectives[i].required;
-            bool finished = (current >= required);
-            // Build display text like "Kobold Vermin slain: 3/8"
-            std::string text = (q.killObjectives[i].npcOrGoId < 0 ? "Object" : "Creature")
-                + std::string(" slain: ") + std::to_string(current) + "/" + std::to_string(required);
-            lua_pushstring(L, text.c_str());
-            lua_pushstring(L, q.killObjectives[i].npcOrGoId < 0 ? "object" : "monster");
-            lua_pushboolean(L, finished ? 1 : 0);
-            return 3;
-        }
-    }
-    for (int i = 0; i < 6; ++i) {
-        if (q.itemObjectives[i].itemId == 0 && q.itemObjectives[i].required == 0) continue;
-        ++cur;
-        if (cur == objIdx) {
-            uint32_t current = 0;
-            auto it = q.itemCounts.find(q.itemObjectives[i].itemId);
-            if (it != q.itemCounts.end()) current = it->second;
-            uint32_t required = q.itemObjectives[i].required;
-            bool finished = (current >= required);
-            // Get item name if available
-            std::string itemName;
-            const auto* info = gh->getItemInfo(q.itemObjectives[i].itemId);
-            if (info && !info->name.empty()) itemName = info->name;
-            else itemName = "Item #" + std::to_string(q.itemObjectives[i].itemId);
-            std::string text = itemName + ": " + std::to_string(current) + "/" + std::to_string(required);
-            lua_pushstring(L, text.c_str());
-            lua_pushstring(L, "item");
-            lua_pushboolean(L, finished ? 1 : 0);
-            return 3;
-        }
-    }
-    lua_pushnil(L);
-    return 1;
-}
-
-// ExpandQuestHeader / CollapseQuestHeader — no-ops (flat quest list, no headers)
-static int lua_ExpandQuestHeader(lua_State* L) { (void)L; return 0; }
-static int lua_CollapseQuestHeader(lua_State* L) { (void)L; return 0; }
-
-// GetQuestLogSpecialItemInfo(questLogIndex) — returns nil (no special items)
-static int lua_GetQuestLogSpecialItemInfo(lua_State* L) { (void)L; lua_pushnil(L); return 1; }
-
-static int lua_GetNumSkillLines(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnZero(L); }
-    lua_pushnumber(L, gh->getPlayerSkills().size());
-    return 1;
-}
-
-// GetSkillLineInfo(index) → skillName, isHeader, isExpanded, skillRank, numTempPoints, skillModifier, skillMaxRank, isAbandonable, stepCost, rankCost, minLevel, skillCostType
-static int lua_GetSkillLineInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int index = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || index < 1) {
-        lua_pushnil(L);
-        return 1;
-    }
-    const auto& skills = gh->getPlayerSkills();
-    if (index > static_cast<int>(skills.size())) {
-        lua_pushnil(L);
-        return 1;
-    }
-    // Skills are in a map — iterate to the Nth entry
-    auto it = skills.begin();
-    std::advance(it, index - 1);
-    const auto& skill = it->second;
-    std::string name = gh->getSkillName(skill.skillId);
-    if (name.empty()) name = "Skill " + std::to_string(skill.skillId);
-
-    lua_pushstring(L, name.c_str());                    // 1: skillName
-    lua_pushboolean(L, 0);                              // 2: isHeader (false — flat list)
-    lua_pushboolean(L, 1);                              // 3: isExpanded
-    lua_pushnumber(L, skill.effectiveValue());           // 4: skillRank
-    lua_pushnumber(L, skill.bonusTemp);                  // 5: numTempPoints
-    lua_pushnumber(L, skill.bonusPerm);                  // 6: skillModifier
-    lua_pushnumber(L, skill.maxValue);                   // 7: skillMaxRank
-    lua_pushboolean(L, 0);                              // 8: isAbandonable
-    lua_pushnumber(L, 0);                               // 9: stepCost
-    lua_pushnumber(L, 0);                               // 10: rankCost
-    lua_pushnumber(L, 0);                               // 11: minLevel
-    lua_pushnumber(L, 0);                               // 12: skillCostType
-    return 12;
-}
-
-// --- Friends/Ignore API ---
-
-
-static int lua_GetNumTalentTabs(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnZero(L); }
-    // Count tabs matching the player's class
-    uint8_t classId = gh->getPlayerClass();
-    uint32_t classMask = (classId > 0) ? (1u << (classId - 1)) : 0;
-    int count = 0;
-    for (const auto& [tabId, tab] : gh->getAllTalentTabs()) {
-        if (tab.classMask & classMask) count++;
-    }
-    lua_pushnumber(L, count);
-    return 1;
-}
-
-// GetTalentTabInfo(tabIndex) → name, iconTexture, pointsSpent, background
-static int lua_GetTalentTabInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int tabIndex = static_cast<int>(luaL_checknumber(L, 1)); // 1-indexed
-    if (!gh || tabIndex < 1) {
-        return luaReturnNil(L);
-    }
-    uint8_t classId = gh->getPlayerClass();
-    uint32_t classMask = (classId > 0) ? (1u << (classId - 1)) : 0;
-    // Find the Nth tab for this class (sorted by orderIndex)
-    std::vector<const game::GameHandler::TalentTabEntry*> classTabs;
-    for (const auto& [tabId, tab] : gh->getAllTalentTabs()) {
-        if (tab.classMask & classMask) classTabs.push_back(&tab);
-    }
-    std::sort(classTabs.begin(), classTabs.end(),
-        [](const auto* a, const auto* b) { return a->orderIndex < b->orderIndex; });
-    if (tabIndex > static_cast<int>(classTabs.size())) {
-        return luaReturnNil(L);
-    }
-    const auto* tab = classTabs[tabIndex - 1];
-    // Count points spent in this tab
-    int pointsSpent = 0;
-    const auto& learned = gh->getLearnedTalents();
-    for (const auto& [talentId, rank] : learned) {
-        const auto* entry = gh->getTalentEntry(talentId);
-        if (entry && entry->tabId == tab->tabId) pointsSpent += rank;
-    }
-    lua_pushstring(L, tab->name.c_str());              // 1: name
-    lua_pushnil(L);                                     // 2: iconTexture (not resolved)
-    lua_pushnumber(L, pointsSpent);                     // 3: pointsSpent
-    lua_pushstring(L, tab->backgroundFile.c_str());     // 4: background
-    return 4;
-}
-
-// GetNumTalents(tabIndex) → count
-static int lua_GetNumTalents(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int tabIndex = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || tabIndex < 1) { return luaReturnZero(L); }
-    uint8_t classId = gh->getPlayerClass();
-    uint32_t classMask = (classId > 0) ? (1u << (classId - 1)) : 0;
-    std::vector<const game::GameHandler::TalentTabEntry*> classTabs;
-    for (const auto& [tabId, tab] : gh->getAllTalentTabs()) {
-        if (tab.classMask & classMask) classTabs.push_back(&tab);
-    }
-    std::sort(classTabs.begin(), classTabs.end(),
-        [](const auto* a, const auto* b) { return a->orderIndex < b->orderIndex; });
-    if (tabIndex > static_cast<int>(classTabs.size())) {
-        return luaReturnZero(L);
-    }
-    uint32_t targetTabId = classTabs[tabIndex - 1]->tabId;
-    int count = 0;
-    for (const auto& [talentId, entry] : gh->getAllTalents()) {
-        if (entry.tabId == targetTabId) count++;
-    }
-    lua_pushnumber(L, count);
-    return 1;
-}
-
-// GetTalentInfo(tabIndex, talentIndex) → name, iconTexture, tier, column, rank, maxRank, isExceptional, available
-static int lua_GetTalentInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int tabIndex = static_cast<int>(luaL_checknumber(L, 1));
-    int talentIndex = static_cast<int>(luaL_checknumber(L, 2));
-    if (!gh || tabIndex < 1 || talentIndex < 1) {
-        for (int i = 0; i < 8; i++) lua_pushnil(L);
-        return 8;
-    }
-    uint8_t classId = gh->getPlayerClass();
-    uint32_t classMask = (classId > 0) ? (1u << (classId - 1)) : 0;
-    std::vector<const game::GameHandler::TalentTabEntry*> classTabs;
-    for (const auto& [tabId, tab] : gh->getAllTalentTabs()) {
-        if (tab.classMask & classMask) classTabs.push_back(&tab);
-    }
-    std::sort(classTabs.begin(), classTabs.end(),
-        [](const auto* a, const auto* b) { return a->orderIndex < b->orderIndex; });
-    if (tabIndex > static_cast<int>(classTabs.size())) {
-        for (int i = 0; i < 8; i++) lua_pushnil(L);
-        return 8;
-    }
-    uint32_t targetTabId = classTabs[tabIndex - 1]->tabId;
-    // Collect talents for this tab, sorted by row then column
-    std::vector<const game::GameHandler::TalentEntry*> tabTalents;
-    for (const auto& [talentId, entry] : gh->getAllTalents()) {
-        if (entry.tabId == targetTabId) tabTalents.push_back(&entry);
-    }
-    std::sort(tabTalents.begin(), tabTalents.end(),
-        [](const auto* a, const auto* b) {
-            return (a->row != b->row) ? a->row < b->row : a->column < b->column;
-        });
-    if (talentIndex > static_cast<int>(tabTalents.size())) {
-        for (int i = 0; i < 8; i++) lua_pushnil(L);
-        return 8;
-    }
-    const auto* talent = tabTalents[talentIndex - 1];
-    uint8_t rank = gh->getTalentRank(talent->talentId);
-    // Get spell name for rank 1 spell
-    std::string name = gh->getSpellName(talent->rankSpells[0]);
-    if (name.empty()) name = "Talent " + std::to_string(talent->talentId);
-
-    lua_pushstring(L, name.c_str());          // 1: name
-    lua_pushnil(L);                            // 2: iconTexture
-    lua_pushnumber(L, talent->row + 1);        // 3: tier (1-indexed)
-    lua_pushnumber(L, talent->column + 1);     // 4: column (1-indexed)
-    lua_pushnumber(L, rank);                   // 5: rank
-    lua_pushnumber(L, talent->maxRank);        // 6: maxRank
-    lua_pushboolean(L, 0);                     // 7: isExceptional
-    lua_pushboolean(L, 1);                     // 8: available
-    return 8;
-}
-
-static int lua_GetActiveTalentGroup(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushnumber(L, gh ? (gh->getActiveTalentSpec() + 1) : 1);
-    return 1;
-}
-
-void registerQuestLuaAPI(lua_State* L) {
-    static const struct { const char* name; lua_CFunction func; } api[] = {
-                {"GetNumQuestLogEntries",   lua_GetNumQuestLogEntries},
-                {"GetQuestLogTitle",        lua_GetQuestLogTitle},
-                {"GetQuestLogQuestText",    lua_GetQuestLogQuestText},
-                {"IsQuestComplete",         lua_IsQuestComplete},
-                {"SelectQuestLogEntry",     lua_SelectQuestLogEntry},
-                {"GetQuestLogSelection",    lua_GetQuestLogSelection},
-                {"GetNumQuestWatches",      lua_GetNumQuestWatches},
-                {"GetQuestIndexForWatch",   lua_GetQuestIndexForWatch},
-                {"AddQuestWatch",           lua_AddQuestWatch},
-                {"RemoveQuestWatch",        lua_RemoveQuestWatch},
-                {"IsQuestWatched",          lua_IsQuestWatched},
-                {"GetQuestLink",            lua_GetQuestLink},
-                {"GetNumQuestLeaderBoards", lua_GetNumQuestLeaderBoards},
-                {"GetQuestLogLeaderBoard",  lua_GetQuestLogLeaderBoard},
-                {"ExpandQuestHeader",       lua_ExpandQuestHeader},
-                {"CollapseQuestHeader",     lua_CollapseQuestHeader},
-                {"GetQuestLogSpecialItemInfo", lua_GetQuestLogSpecialItemInfo},
-                {"GetNumSkillLines",        lua_GetNumSkillLines},
-                {"GetSkillLineInfo",        lua_GetSkillLineInfo},
-                {"GetNumTalentTabs",        lua_GetNumTalentTabs},
-                {"GetTalentTabInfo",        lua_GetTalentTabInfo},
-                {"GetNumTalents",           lua_GetNumTalents},
-                {"GetTalentInfo",           lua_GetTalentInfo},
-                {"GetActiveTalentGroup",    lua_GetActiveTalentGroup},
-                {"AcceptQuest", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->acceptQuest();
-            return 0;
-        }},
-                {"DeclineQuest", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->declineQuest();
-            return 0;
-        }},
-                {"CompleteQuest", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->completeQuest();
-            return 0;
-        }},
-                {"AbandonQuest", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            uint32_t questId = static_cast<uint32_t>(luaL_checknumber(L, 1));
-            if (gh) gh->abandonQuest(questId);
-            return 0;
-        }},
-                {"GetNumQuestRewards", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (!gh) { return luaReturnZero(L); }
-            int idx = gh->getSelectedQuestLogIndex();
-            if (idx < 1) { return luaReturnZero(L); }
-            const auto& ql = gh->getQuestLog();
-            if (idx > static_cast<int>(ql.size())) { return luaReturnZero(L); }
-            int count = 0;
-            for (const auto& r : ql[idx-1].rewardItems)
-                if (r.itemId != 0) ++count;
-            lua_pushnumber(L, count);
-            return 1;
-        }},
-                {"GetNumQuestChoices", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (!gh) { return luaReturnZero(L); }
-            int idx = gh->getSelectedQuestLogIndex();
-            if (idx < 1) { return luaReturnZero(L); }
-            const auto& ql = gh->getQuestLog();
-            if (idx > static_cast<int>(ql.size())) { return luaReturnZero(L); }
-            int count = 0;
-            for (const auto& r : ql[idx-1].rewardChoiceItems)
-                if (r.itemId != 0) ++count;
-            lua_pushnumber(L, count);
-            return 1;
-        }},
-                {"GetNumGlyphSockets", [](lua_State* L) -> int {
-            lua_pushnumber(L, game::GameHandler::MAX_GLYPH_SLOTS);
-            return 1;
-        }},
-                {"GetGlyphSocketInfo", [](lua_State* L) -> int {
-            // GetGlyphSocketInfo(index [, talentGroup]) → enabled, glyphType, glyphSpellID, icon
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            int spec = static_cast<int>(luaL_optnumber(L, 2, 0));
-            if (!gh || index < 1 || index > game::GameHandler::MAX_GLYPH_SLOTS) {
-                lua_pushboolean(L, 0); lua_pushnumber(L, 0); lua_pushnil(L); lua_pushnil(L);
-                return 4;
-            }
-            const auto& glyphs = (spec >= 1 && spec <= 2)
-                ? gh->getGlyphs(static_cast<uint8_t>(spec - 1)) : gh->getGlyphs();
-            uint16_t glyphId = glyphs[index - 1];
-            // Glyph type: slots 1,2,3 = major (1), slots 4,5,6 = minor (2)
-            int glyphType = (index <= 3) ? 1 : 2;
-            lua_pushboolean(L, 1);              // enabled
-            lua_pushnumber(L, glyphType);       // glyphType (1=major, 2=minor)
-            if (glyphId != 0) {
-                lua_pushnumber(L, glyphId);     // glyphSpellID
-                lua_pushstring(L, "Interface\\Icons\\INV_Glyph_MajorWarrior"); // placeholder icon
-            } else {
-                lua_pushnil(L);
-                lua_pushnil(L);
-            }
-            return 4;
-        }},
-                {"GetNumCompletedAchievements", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            lua_pushnumber(L, gh ? gh->getEarnedAchievements().size() : 0);
-            return 1;
-        }},
-                {"GetAchievementInfo", [](lua_State* L) -> int {
-            // GetAchievementInfo(id) → id, name, points, completed, month, day, year, description, flags, icon, rewardText, isGuildAch
-            auto* gh = getGameHandler(L);
-            uint32_t id = static_cast<uint32_t>(luaL_checknumber(L, 1));
-            if (!gh) { return luaReturnNil(L); }
-            const std::string& name = gh->getAchievementName(id);
-            if (name.empty()) { return luaReturnNil(L); }
-            bool completed = gh->getEarnedAchievements().count(id) > 0;
-            uint32_t date = gh->getAchievementDate(id);
-            uint32_t points = gh->getAchievementPoints(id);
-            const std::string& desc = gh->getAchievementDescription(id);
-            // Parse date: packed as (month << 24 | day << 16 | year)
-            int month = completed ? static_cast<int>((date >> 24) & 0xFF) : 0;
-            int day = completed ? static_cast<int>((date >> 16) & 0xFF) : 0;
-            int year = completed ? static_cast<int>(date & 0xFFFF) : 0;
-            lua_pushnumber(L, id);                 // 1: id
-            lua_pushstring(L, name.c_str());       // 2: name
-            lua_pushnumber(L, points);             // 3: points
-            lua_pushboolean(L, completed ? 1 : 0); // 4: completed
-            lua_pushnumber(L, month);              // 5: month
-            lua_pushnumber(L, day);                // 6: day
-            lua_pushnumber(L, year);               // 7: year
-            lua_pushstring(L, desc.c_str());       // 8: description
-            lua_pushnumber(L, 0);                  // 9: flags
-            lua_pushstring(L, "Interface\\Icons\\Achievement_General"); // 10: icon
-            lua_pushstring(L, "");                 // 11: rewardText
-            lua_pushboolean(L, 0);                 // 12: isGuildAchievement
-            return 12;
-        }},
-    };
-    for (const auto& [name, func] : api) {
-        lua_pushcfunction(L, func);
-        lua_setglobal(L, name);
-    }
-}
-
-} // namespace wowee::addons
diff --git a/src/addons/lua_social_api.cpp b/src/addons/lua_social_api.cpp
deleted file mode 100644
index d29f3acc..00000000
--- a/src/addons/lua_social_api.cpp
+++ /dev/null
@@ -1,502 +0,0 @@
-// lua_social_api.cpp — Chat, guild, friends, ignore, gossip, party management, and emotes Lua API bindings.
-// Extracted from lua_engine.cpp as part of §5.1 (Tame LuaEngine).
-#include "addons/lua_api_helpers.hpp"
-
-namespace wowee::addons {
-
-static int lua_SendChatMessage(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    const char* msg = luaL_checkstring(L, 1);
-    const char* chatType = luaL_optstring(L, 2, "SAY");
-    // language arg (3) ignored — server determines language
-    const char* target = luaL_optstring(L, 4, "");
-
-    std::string typeStr(chatType);
-    for (char& c : typeStr) c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
-
-    game::ChatType ct = game::ChatType::SAY;
-    if (typeStr == "SAY")            ct = game::ChatType::SAY;
-    else if (typeStr == "YELL")      ct = game::ChatType::YELL;
-    else if (typeStr == "PARTY")     ct = game::ChatType::PARTY;
-    else if (typeStr == "GUILD")     ct = game::ChatType::GUILD;
-    else if (typeStr == "OFFICER")   ct = game::ChatType::OFFICER;
-    else if (typeStr == "RAID")      ct = game::ChatType::RAID;
-    else if (typeStr == "WHISPER")   ct = game::ChatType::WHISPER;
-    else if (typeStr == "BATTLEGROUND") ct = game::ChatType::BATTLEGROUND;
-
-    std::string targetStr(target && *target ? target : "");
-    gh->sendChatMessage(ct, msg, targetStr);
-    return 0;
-}
-
-// SendAddonMessage(prefix, text, chatType, target) — send addon message
-static int lua_SendAddonMessage(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    const char* prefix = luaL_checkstring(L, 1);
-    const char* text = luaL_checkstring(L, 2);
-    const char* chatType = luaL_optstring(L, 3, "PARTY");
-    const char* target = luaL_optstring(L, 4, "");
-
-    // Build addon message: prefix + TAB + text, send via the appropriate channel
-    std::string typeStr(chatType);
-    for (char& c : typeStr) c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
-
-    game::ChatType ct = game::ChatType::PARTY;
-    if (typeStr == "PARTY")           ct = game::ChatType::PARTY;
-    else if (typeStr == "RAID")       ct = game::ChatType::RAID;
-    else if (typeStr == "GUILD")      ct = game::ChatType::GUILD;
-    else if (typeStr == "OFFICER")    ct = game::ChatType::OFFICER;
-    else if (typeStr == "BATTLEGROUND") ct = game::ChatType::BATTLEGROUND;
-    else if (typeStr == "WHISPER")    ct = game::ChatType::WHISPER;
-
-    // Encode as prefix\ttext (WoW addon message format)
-    std::string encoded = std::string(prefix) + "\t" + text;
-    std::string targetStr(target && *target ? target : "");
-    gh->sendChatMessage(ct, encoded, targetStr);
-    return 0;
-}
-
-// RegisterAddonMessagePrefix(prefix) — register prefix for receiving addon messages
-static int lua_RegisterAddonMessagePrefix(lua_State* L) {
-    const char* prefix = luaL_checkstring(L, 1);
-    // Store in a global Lua table for filtering
-    lua_getglobal(L, "__WoweeAddonPrefixes");
-    if (lua_isnil(L, -1)) {
-        lua_pop(L, 1);
-        lua_newtable(L);
-        lua_pushvalue(L, -1);
-        lua_setglobal(L, "__WoweeAddonPrefixes");
-    }
-    lua_pushboolean(L, 1);
-    lua_setfield(L, -2, prefix);
-    lua_pop(L, 1);
-    lua_pushboolean(L, 1); // success
-    return 1;
-}
-
-// IsAddonMessagePrefixRegistered(prefix) → boolean
-static int lua_IsAddonMessagePrefixRegistered(lua_State* L) {
-    const char* prefix = luaL_checkstring(L, 1);
-    lua_getglobal(L, "__WoweeAddonPrefixes");
-    if (lua_istable(L, -1)) {
-        lua_getfield(L, -1, prefix);
-        lua_pushboolean(L, lua_toboolean(L, -1));
-        return 1;
-    }
-    lua_pushboolean(L, 0);
-    return 1;
-}
-
-static int lua_GetNumFriends(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnZero(L); }
-    int count = 0;
-    for (const auto& c : gh->getContacts())
-        if (c.isFriend()) count++;
-    lua_pushnumber(L, count);
-    return 1;
-}
-
-// GetFriendInfo(index) → name, level, class, area, connected, status, note
-static int lua_GetFriendInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int index = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || index < 1) {
-        return luaReturnNil(L);
-    }
-    int found = 0;
-    for (const auto& c : gh->getContacts()) {
-        if (!c.isFriend()) continue;
-        if (++found == index) {
-            lua_pushstring(L, c.name.c_str());      // 1: name
-            lua_pushnumber(L, c.level);              // 2: level
-
-            lua_pushstring(L, c.classId < 12 ? kLuaClasses[c.classId] : "Unknown"); // 3: class
-            std::string area;
-            if (c.areaId != 0) area = gh->getWhoAreaName(c.areaId);
-            lua_pushstring(L, area.c_str());         // 4: area
-            lua_pushboolean(L, c.isOnline());        // 5: connected
-            lua_pushstring(L, c.status == 2 ? "<AFK>" : (c.status == 3 ? "<DND>" : "")); // 6: status
-            lua_pushstring(L, c.note.c_str());       // 7: note
-            return 7;
-        }
-    }
-    lua_pushnil(L);
-    return 1;
-}
-
-// --- Guild API ---
-
-// IsInGuild() → boolean
-static int lua_IsInGuild(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushboolean(L, gh && gh->isInGuild());
-    return 1;
-}
-
-// GetGuildInfo("player") → guildName, guildRankName, guildRankIndex
-static int lua_GetGuildInfoFunc(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh || !gh->isInGuild()) { return luaReturnNil(L); }
-    lua_pushstring(L, gh->getGuildName().c_str());
-    // Get rank name for the player
-    const auto& roster = gh->getGuildRoster();
-    std::string rankName;
-    uint32_t rankIndex = 0;
-    for (const auto& m : roster.members) {
-        if (m.guid == gh->getPlayerGuid()) {
-            rankIndex = m.rankIndex;
-            const auto& rankNames = gh->getGuildRankNames();
-            if (rankIndex < rankNames.size()) rankName = rankNames[rankIndex];
-            break;
-        }
-    }
-    lua_pushstring(L, rankName.c_str());
-    lua_pushnumber(L, rankIndex);
-    return 3;
-}
-
-// GetNumGuildMembers() → totalMembers, onlineMembers
-static int lua_GetNumGuildMembers(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushnumber(L, 0); lua_pushnumber(L, 0); return 2; }
-    const auto& roster = gh->getGuildRoster();
-    int online = 0;
-    for (const auto& m : roster.members)
-        if (m.online) online++;
-    lua_pushnumber(L, roster.members.size());
-    lua_pushnumber(L, online);
-    return 2;
-}
-
-// GetGuildRosterInfo(index) → name, rank, rankIndex, level, class, zone, note, officerNote, online, status, classId
-static int lua_GetGuildRosterInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int index = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || index < 1) { return luaReturnNil(L); }
-    const auto& roster = gh->getGuildRoster();
-    if (index > static_cast<int>(roster.members.size())) { return luaReturnNil(L); }
-    const auto& m = roster.members[index - 1];
-
-    lua_pushstring(L, m.name.c_str());                      // 1: name
-    const auto& rankNames = gh->getGuildRankNames();
-    lua_pushstring(L, m.rankIndex < rankNames.size()
-        ? rankNames[m.rankIndex].c_str() : "");              // 2: rank name
-    lua_pushnumber(L, m.rankIndex);                          // 3: rankIndex
-    lua_pushnumber(L, m.level);                              // 4: level
-    lua_pushstring(L, m.classId < 12 ? kLuaClasses[m.classId] : "Unknown"); // 5: class
-    std::string zone;
-    if (m.zoneId != 0 && m.online) zone = gh->getWhoAreaName(m.zoneId);
-    lua_pushstring(L, zone.c_str());                         // 6: zone
-    lua_pushstring(L, m.publicNote.c_str());                 // 7: note
-    lua_pushstring(L, m.officerNote.c_str());                // 8: officerNote
-    lua_pushboolean(L, m.online);                            // 9: online
-    lua_pushnumber(L, 0);                                    // 10: status (0=online, 1=AFK, 2=DND)
-    lua_pushnumber(L, m.classId);                            // 11: classId (numeric)
-    return 11;
-}
-
-// GetGuildRosterMOTD() → motd
-static int lua_GetGuildRosterMOTD(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushstring(L, ""); return 1; }
-    lua_pushstring(L, gh->getGuildRoster().motd.c_str());
-    return 1;
-}
-
-// GetNumIgnores() → count
-static int lua_GetNumIgnores(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnZero(L); }
-    int count = 0;
-    for (const auto& c : gh->getContacts())
-        if (c.isIgnored()) count++;
-    lua_pushnumber(L, count);
-    return 1;
-}
-
-// GetIgnoreName(index) → name
-static int lua_GetIgnoreName(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int index = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || index < 1) { return luaReturnNil(L); }
-    int found = 0;
-    for (const auto& c : gh->getContacts()) {
-        if (!c.isIgnored()) continue;
-        if (++found == index) {
-            lua_pushstring(L, c.name.c_str());
-            return 1;
-        }
-    }
-    lua_pushnil(L);
-    return 1;
-}
-
-// --- Talent API ---
-
-// GetNumTalentTabs() → count (usually 3)
-
-void registerSocialLuaAPI(lua_State* L) {
-    static const struct { const char* name; lua_CFunction func; } api[] = {
-                {"SendChatMessage",   lua_SendChatMessage},
-                {"SendAddonMessage",  lua_SendAddonMessage},
-                {"RegisterAddonMessagePrefix", lua_RegisterAddonMessagePrefix},
-                {"IsAddonMessagePrefixRegistered", lua_IsAddonMessagePrefixRegistered},
-                {"IsInGuild",               lua_IsInGuild},
-                {"GetGuildInfo",            lua_GetGuildInfoFunc},
-                {"GetNumGuildMembers",      lua_GetNumGuildMembers},
-                {"GuildRoster", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->requestGuildRoster();
-            return 0;
-        }},
-                {"SortGuildRoster", [](lua_State* L) -> int {
-            (void)L; // Sorting is client-side display only
-            return 0;
-        }},
-                {"GetGuildRosterInfo",      lua_GetGuildRosterInfo},
-                {"GetGuildRosterMOTD",      lua_GetGuildRosterMOTD},
-                {"GetNumFriends",           lua_GetNumFriends},
-                {"GetFriendInfo",           lua_GetFriendInfo},
-                {"GetNumIgnores",           lua_GetNumIgnores},
-                {"GetIgnoreName",           lua_GetIgnoreName},
-                {"GuildInvite", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->inviteToGuild(luaL_checkstring(L, 1));
-            return 0;
-        }},
-                {"GuildUninvite", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->kickGuildMember(luaL_checkstring(L, 1));
-            return 0;
-        }},
-                {"GuildPromote", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->promoteGuildMember(luaL_checkstring(L, 1));
-            return 0;
-        }},
-                {"GuildDemote", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->demoteGuildMember(luaL_checkstring(L, 1));
-            return 0;
-        }},
-                {"GuildLeave", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->leaveGuild();
-            return 0;
-        }},
-                {"GuildSetPublicNote", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->setGuildPublicNote(luaL_checkstring(L, 1), luaL_checkstring(L, 2));
-            return 0;
-        }},
-                {"DoEmote", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const char* token = luaL_checkstring(L, 1);
-            if (!gh) return 0;
-            std::string t(token);
-            for (char& c : t) c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
-            // Map common emote tokens to DBC TextEmote IDs
-            static const std::unordered_map<std::string, uint32_t> emoteMap = {
-                {"WAVE", 67}, {"BOW", 2}, {"DANCE", 10}, {"CHEER", 5},
-                {"CHICKEN", 6}, {"CRY", 8}, {"EAT", 14}, {"DRINK", 13},
-                {"FLEX", 16}, {"KISS", 22}, {"LAUGH", 23}, {"POINT", 30},
-                {"ROAR", 34}, {"RUDE", 36}, {"SALUTE", 37}, {"SHY", 40},
-                {"SILLY", 41}, {"SIT", 42}, {"SLEEP", 43}, {"SPIT", 44},
-                {"THANK", 52}, {"CLAP", 7}, {"KNEEL", 21}, {"LAY", 24},
-                {"NO", 28}, {"YES", 70}, {"BEG", 1}, {"ANGRY", 64},
-                {"FAREWELL", 15}, {"HELLO", 18}, {"WELCOME", 68},
-            };
-            auto it = emoteMap.find(t);
-            uint64_t target = gh->hasTarget() ? gh->getTargetGuid() : 0;
-            if (it != emoteMap.end()) {
-                gh->sendTextEmote(it->second, target);
-            }
-            return 0;
-        }},
-                {"AddFriend", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const char* name = luaL_checkstring(L, 1);
-            const char* note = luaL_optstring(L, 2, "");
-            if (gh) gh->addFriend(name, note);
-            return 0;
-        }},
-                {"RemoveFriend", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const char* name = luaL_checkstring(L, 1);
-            if (gh) gh->removeFriend(name);
-            return 0;
-        }},
-                {"AddIgnore", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const char* name = luaL_checkstring(L, 1);
-            if (gh) gh->addIgnore(name);
-            return 0;
-        }},
-                {"DelIgnore", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const char* name = luaL_checkstring(L, 1);
-            if (gh) gh->removeIgnore(name);
-            return 0;
-        }},
-                {"ShowFriends", [](lua_State* L) -> int {
-            (void)L; // Friends panel is shown via ImGui, not Lua
-            return 0;
-        }},
-                {"GetNumWhoResults", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (!gh) { lua_pushnumber(L, 0); lua_pushnumber(L, 0); return 2; }
-            lua_pushnumber(L, gh->getWhoResults().size());
-            lua_pushnumber(L, gh->getWhoOnlineCount());
-            return 2;
-        }},
-                {"GetWhoInfo", [](lua_State* L) -> int {
-            // GetWhoInfo(index) → name, guild, level, race, class, zone, classFileName
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            if (!gh || index < 1) { return luaReturnNil(L); }
-            const auto& results = gh->getWhoResults();
-            if (index > static_cast<int>(results.size())) { return luaReturnNil(L); }
-            const auto& w = results[index - 1];
-
-
-            const char* raceName = (w.raceId < 12) ? kLuaRaces[w.raceId] : "Unknown";
-            const char* className = (w.classId < 12) ? kLuaClasses[w.classId] : "Unknown";
-            static constexpr const char* kClassFiles[] = {"","WARRIOR","PALADIN","HUNTER","ROGUE","PRIEST","DEATHKNIGHT","SHAMAN","MAGE","WARLOCK","","DRUID"};
-            const char* classFile = (w.classId < 12) ? kClassFiles[w.classId] : "WARRIOR";
-            lua_pushstring(L, w.name.c_str());
-            lua_pushstring(L, w.guildName.c_str());
-            lua_pushnumber(L, w.level);
-            lua_pushstring(L, raceName);
-            lua_pushstring(L, className);
-            lua_pushstring(L, ""); // zone name (would need area lookup)
-            lua_pushstring(L, classFile);
-            return 7;
-        }},
-                {"SendWho", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const char* query = luaL_optstring(L, 1, "");
-            if (gh) gh->queryWho(query);
-            return 0;
-        }},
-                {"SetWhoToUI", [](lua_State* L) -> int {
-            (void)L; return 0; // Stub
-        }},
-                {"GetNumGossipOptions", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            lua_pushnumber(L, gh ? gh->getCurrentGossip().options.size() : 0);
-            return 1;
-        }},
-                {"GetGossipOptions", [](lua_State* L) -> int {
-            // Returns pairs of (text, type) for each option
-            auto* gh = getGameHandler(L);
-            if (!gh) return 0;
-            const auto& opts = gh->getCurrentGossip().options;
-            int n = 0;
-            static constexpr const char* kIcons[] = {"gossip","vendor","taxi","trainer","spiritguide","innkeeper","banker","petition","tabard","battlemaster","auctioneer"};
-            for (const auto& o : opts) {
-                lua_pushstring(L, o.text.c_str());
-                lua_pushstring(L, o.icon < 11 ? kIcons[o.icon] : "gossip");
-                n += 2;
-            }
-            return n;
-        }},
-                {"SelectGossipOption", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            if (!gh || index < 1) return 0;
-            const auto& opts = gh->getCurrentGossip().options;
-            if (index <= static_cast<int>(opts.size()))
-                gh->selectGossipOption(opts[index - 1].id);
-            return 0;
-        }},
-                {"GetNumGossipAvailableQuests", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (!gh) { return luaReturnZero(L); }
-            int count = 0;
-            for (const auto& q : gh->getCurrentGossip().quests)
-                if (q.questIcon != 4) ++count; // 4 = active/in-progress
-            lua_pushnumber(L, count);
-            return 1;
-        }},
-                {"GetNumGossipActiveQuests", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (!gh) { return luaReturnZero(L); }
-            int count = 0;
-            for (const auto& q : gh->getCurrentGossip().quests)
-                if (q.questIcon == 4) ++count;
-            lua_pushnumber(L, count);
-            return 1;
-        }},
-                {"CloseGossip", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->closeGossip();
-            return 0;
-        }},
-                {"InviteUnit", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->inviteToGroup(luaL_checkstring(L, 1));
-            return 0;
-        }},
-                {"UninviteUnit", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->uninvitePlayer(luaL_checkstring(L, 1));
-            return 0;
-        }},
-                {"LeaveParty", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->leaveGroup();
-            return 0;
-        }},
-                {"FollowUnit", [](lua_State* L) -> int {
-            (void)L; // Follow requires movement system integration
-            return 0;
-        }},
-                {"RandomRoll", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int mn = static_cast<int>(luaL_optnumber(L, 1, 1));
-            int mx = static_cast<int>(luaL_optnumber(L, 2, 100));
-            if (gh) gh->randomRoll(mn, mx);
-            return 0;
-        }},
-                {"JoinChannelByName", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const char* name = luaL_checkstring(L, 1);
-            const char* pw = luaL_optstring(L, 2, "");
-            if (gh) gh->joinChannel(name, pw);
-            return 0;
-        }},
-                {"LeaveChannelByName", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const char* name = luaL_checkstring(L, 1);
-            if (gh) gh->leaveChannel(name);
-            return 0;
-        }},
-                {"GetChannelName", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            if (!gh || index < 1) { return luaReturnNil(L); }
-            std::string name = gh->getChannelByIndex(index - 1);
-            if (!name.empty()) {
-                lua_pushstring(L, name.c_str());
-                lua_pushstring(L, ""); // header
-                lua_pushboolean(L, 0); // collapsed
-                lua_pushnumber(L, index); // channelNumber
-                lua_pushnumber(L, 0); // count
-                lua_pushboolean(L, 1); // active
-                lua_pushstring(L, "CHANNEL_CATEGORY_CUSTOM"); // category
-                return 7;
-            }
-            lua_pushnil(L);
-            return 1;
-        }},
-    };
-    for (const auto& [name, func] : api) {
-        lua_pushcfunction(L, func);
-        lua_setglobal(L, name);
-    }
-}
-
-} // namespace wowee::addons
diff --git a/src/addons/lua_spell_api.cpp b/src/addons/lua_spell_api.cpp
deleted file mode 100644
index cfe73fd0..00000000
--- a/src/addons/lua_spell_api.cpp
+++ /dev/null
@@ -1,968 +0,0 @@
-// lua_spell_api.cpp — Spell info, casting, auras, and targeting Lua API bindings.
-// Extracted from lua_engine.cpp as part of §5.1 (Tame LuaEngine).
-#include "addons/lua_api_helpers.hpp"
-
-namespace wowee::addons {
-
-static int lua_IsSpellInRange(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-    const char* spellNameOrId = luaL_checkstring(L, 1);
-    const char* uid = luaL_optstring(L, 2, "target");
-
-    // Resolve spell ID
-    uint32_t spellId = 0;
-    if (spellNameOrId[0] >= '0' && spellNameOrId[0] <= '9') {
-        spellId = static_cast<uint32_t>(strtoul(spellNameOrId, nullptr, 10));
-    } else {
-        std::string nameLow(spellNameOrId);
-        toLowerInPlace(nameLow);
-        for (uint32_t sid : gh->getKnownSpells()) {
-            std::string sn = gh->getSpellName(sid);
-            toLowerInPlace(sn);
-            if (sn == nameLow) { spellId = sid; break; }
-        }
-    }
-    if (spellId == 0) { return luaReturnNil(L); }
-
-    // Get spell max range from DBC
-    auto data = gh->getSpellData(spellId);
-    if (data.maxRange <= 0.0f) { return luaReturnNil(L); }
-
-    // Resolve target position
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid == 0) { return luaReturnNil(L); }
-    auto targetEnt = gh->getEntityManager().getEntity(guid);
-    auto playerEnt = gh->getEntityManager().getEntity(gh->getPlayerGuid());
-    if (!targetEnt || !playerEnt) { return luaReturnNil(L); }
-
-    float dx = playerEnt->getX() - targetEnt->getX();
-    float dy = playerEnt->getY() - targetEnt->getY();
-    float dz = playerEnt->getZ() - targetEnt->getZ();
-    float dist = std::sqrt(dx*dx + dy*dy + dz*dz);
-    lua_pushnumber(L, dist <= data.maxRange ? 1 : 0);
-    return 1;
-}
-
-// UnitIsVisible(unit) → boolean (entity exists in the client's entity manager)
-
-static int lua_UnitAura(lua_State* L, bool wantBuff) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-    const char* uid = luaL_optstring(L, 1, "player");
-    int index = static_cast<int>(luaL_optnumber(L, 2, 1));
-    if (index < 1) { return luaReturnNil(L); }
-
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-
-    const std::vector<game::AuraSlot>* auras = nullptr;
-    if (uidStr == "player")      auras = &gh->getPlayerAuras();
-    else if (uidStr == "target") auras = &gh->getTargetAuras();
-    else {
-        // Try party/raid/focus via GUID lookup in unitAurasCache
-        uint64_t guid = resolveUnitGuid(gh, uidStr);
-        if (guid != 0) auras = gh->getUnitAuras(guid);
-    }
-    if (!auras) { return luaReturnNil(L); }
-
-    // Filter to buffs or debuffs and find the Nth one
-    int found = 0;
-    for (const auto& aura : *auras) {
-        if (aura.isEmpty() || aura.spellId == 0) continue;
-        bool isDebuff = (aura.flags & 0x80) != 0;
-        if (wantBuff ? isDebuff : !isDebuff) continue;
-        found++;
-        if (found == index) {
-            // Return: name, rank, icon, count, debuffType, duration, expirationTime, ...spellId
-            std::string name = gh->getSpellName(aura.spellId);
-            lua_pushstring(L, name.empty() ? "Unknown" : name.c_str()); // name
-            lua_pushstring(L, "");           // rank
-            std::string iconPath = gh->getSpellIconPath(aura.spellId);
-            if (!iconPath.empty()) lua_pushstring(L, iconPath.c_str());
-            else lua_pushnil(L);             // icon texture path
-            lua_pushnumber(L, aura.charges); // count
-            // debuffType: resolve from Spell.dbc dispel type
-            {
-                uint8_t dt = gh->getSpellDispelType(aura.spellId);
-                switch (dt) {
-                    case 1:  lua_pushstring(L, "Magic");  break;
-                    case 2:  lua_pushstring(L, "Curse");  break;
-                    case 3:  lua_pushstring(L, "Disease"); break;
-                    case 4:  lua_pushstring(L, "Poison"); break;
-                    default: lua_pushnil(L);              break;
-                }
-            }
-            lua_pushnumber(L, aura.maxDurationMs > 0 ? aura.maxDurationMs / 1000.0 : 0); // duration
-            // expirationTime: GetTime() + remaining seconds (so addons can compute countdown)
-            if (aura.durationMs > 0) {
-                uint64_t auraNowMs = static_cast<uint64_t>(
-                    std::chrono::duration_cast<std::chrono::milliseconds>(
-                        std::chrono::steady_clock::now().time_since_epoch()).count());
-                int32_t remMs = aura.getRemainingMs(auraNowMs);
-                lua_pushnumber(L, luaGetTimeNow() + remMs / 1000.0);
-            } else {
-                lua_pushnumber(L, 0);  // permanent aura
-            }
-            // caster: return unit ID string if caster is known
-            if (aura.casterGuid != 0) {
-                if (aura.casterGuid == gh->getPlayerGuid())
-                    lua_pushstring(L, "player");
-                else if (aura.casterGuid == gh->getTargetGuid())
-                    lua_pushstring(L, "target");
-                else if (aura.casterGuid == gh->getFocusGuid())
-                    lua_pushstring(L, "focus");
-                else if (aura.casterGuid == gh->getPetGuid())
-                    lua_pushstring(L, "pet");
-                else {
-                    char cBuf[32];
-                    snprintf(cBuf, sizeof(cBuf), "0x%016llX", (unsigned long long)aura.casterGuid);
-                    lua_pushstring(L, cBuf);
-                }
-            } else {
-                lua_pushnil(L);
-            }
-            lua_pushboolean(L, 0);           // isStealable
-            lua_pushboolean(L, 0);           // shouldConsolidate
-            lua_pushnumber(L, aura.spellId); // spellId
-            return 11;
-        }
-    }
-    lua_pushnil(L);
-    return 1;
-}
-
-static int lua_UnitBuff(lua_State* L) { return lua_UnitAura(L, true); }
-static int lua_UnitDebuff(lua_State* L) { return lua_UnitAura(L, false); }
-
-// UnitAura(unit, index, filter) — generic aura query with filter string
-// filter: "HELPFUL" = buffs, "HARMFUL" = debuffs, "PLAYER" = cast by player,
-//         "HELPFUL|PLAYER" = buffs cast by player, etc.
-static int lua_UnitAuraGeneric(lua_State* L) {
-    const char* filter = luaL_optstring(L, 3, "HELPFUL");
-    std::string f(filter ? filter : "HELPFUL");
-    for (char& c : f) c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
-    bool wantBuff = (f.find("HARMFUL") == std::string::npos);
-    return lua_UnitAura(L, wantBuff);
-}
-
-// ---------- UnitCastingInfo / UnitChannelInfo ----------
-// Internal helper: pushes cast/channel info for a unit.
-// Returns number of Lua return values (0 if not casting/channeling the requested type).
-static int lua_UnitCastInfo(lua_State* L, bool wantChannel) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-
-    const char* uid = luaL_optstring(L, 1, "player");
-    std::string uidStr(uid ? uid : "player");
-
-    // Use shared GetTime() epoch for consistent timestamps
-    double nowSec = luaGetTimeNow();
-
-    // Resolve cast state for the unit
-    bool isCasting = false;
-    bool isChannel = false;
-    uint32_t spellId = 0;
-    float timeTotal = 0.0f;
-    float timeRemaining = 0.0f;
-    bool interruptible = true;
-
-    if (uidStr == "player") {
-        isCasting = gh->isCasting();
-        isChannel = gh->isChanneling();
-        spellId = gh->getCurrentCastSpellId();
-        timeTotal = gh->getCastTimeTotal();
-        timeRemaining = gh->getCastTimeRemaining();
-        // Player interruptibility: always true for own casts (server controls actual interrupt)
-        interruptible = true;
-    } else {
-        uint64_t guid = resolveUnitGuid(gh, uidStr);
-        if (guid == 0) { return luaReturnNil(L); }
-        const auto* state = gh->getUnitCastState(guid);
-        if (!state) { return luaReturnNil(L); }
-        isCasting = state->casting;
-        isChannel = state->isChannel;
-        spellId = state->spellId;
-        timeTotal = state->timeTotal;
-        timeRemaining = state->timeRemaining;
-        interruptible = state->interruptible;
-    }
-
-    if (!isCasting) { return luaReturnNil(L); }
-
-    // UnitCastingInfo: only returns for non-channel casts
-    // UnitChannelInfo: only returns for channels
-    if (wantChannel != isChannel) { return luaReturnNil(L); }
-
-    // Spell name + icon
-    const std::string& name = gh->getSpellName(spellId);
-    std::string iconPath = gh->getSpellIconPath(spellId);
-
-    // Time values in milliseconds (WoW API convention)
-    double startTimeMs = (nowSec - (timeTotal - timeRemaining)) * 1000.0;
-    double endTimeMs   = (nowSec + timeRemaining) * 1000.0;
-
-    // Return values match WoW API:
-    // UnitCastingInfo: name, text, texture, startTime, endTime, isTradeSkill, castID, notInterruptible
-    // UnitChannelInfo: name, text, texture, startTime, endTime, isTradeSkill, notInterruptible
-    lua_pushstring(L, name.empty() ? "Unknown" : name.c_str()); // name
-    lua_pushstring(L, "");                                       // text (sub-text, usually empty)
-    if (!iconPath.empty()) lua_pushstring(L, iconPath.c_str());
-    else lua_pushstring(L, "Interface\\Icons\\INV_Misc_QuestionMark");  // texture
-    lua_pushnumber(L, startTimeMs);                              // startTime (ms)
-    lua_pushnumber(L, endTimeMs);                                // endTime (ms)
-    lua_pushboolean(L, gh->isProfessionSpell(spellId) ? 1 : 0); // isTradeSkill
-    if (!wantChannel) {
-        lua_pushnumber(L, spellId);                              // castID (UnitCastingInfo only)
-    }
-    lua_pushboolean(L, interruptible ? 0 : 1);                  // notInterruptible
-    return wantChannel ? 7 : 8;
-}
-
-static int lua_UnitCastingInfo(lua_State* L) { return lua_UnitCastInfo(L, false); }
-static int lua_UnitChannelInfo(lua_State* L) { return lua_UnitCastInfo(L, true); }
-
-static int lua_CastSpellByName(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    const char* name = luaL_checkstring(L, 1);
-    if (!name || !*name) return 0;
-
-    // Find highest rank of spell by name (same logic as /cast)
-    std::string nameLow(name);
-    toLowerInPlace(nameLow);
-
-    uint32_t bestId = 0;
-    int bestRank = -1;
-    for (uint32_t sid : gh->getKnownSpells()) {
-        std::string sn = gh->getSpellName(sid);
-        toLowerInPlace(sn);
-        if (sn != nameLow) continue;
-        int rank = 0;
-        const std::string& rk = gh->getSpellRank(sid);
-        if (!rk.empty()) {
-            std::string rkl = rk;
-            toLowerInPlace(rkl);
-            if (rkl.rfind("rank ", 0) == 0) {
-                try { rank = std::stoi(rkl.substr(5)); } catch (...) {}
-            }
-        }
-        if (rank > bestRank) { bestRank = rank; bestId = sid; }
-    }
-    if (bestId != 0) {
-        uint64_t target = gh->hasTarget() ? gh->getTargetGuid() : 0;
-        gh->castSpell(bestId, target);
-    }
-    return 0;
-}
-
-static int lua_IsSpellKnown(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    uint32_t spellId = static_cast<uint32_t>(luaL_checknumber(L, 1));
-    lua_pushboolean(L, gh && gh->getKnownSpells().count(spellId));
-    return 1;
-}
-
-// --- Spell Book Tab API ---
-
-// GetNumSpellTabs() → count
-static int lua_GetNumSpellTabs(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnZero(L); }
-    lua_pushnumber(L, gh->getSpellBookTabs().size());
-    return 1;
-}
-
-// GetSpellTabInfo(tabIndex) → name, texture, offset, numSpells
-// tabIndex is 1-based; offset is 1-based global spell book slot
-static int lua_GetSpellTabInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int tabIdx = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || tabIdx < 1) {
-        return luaReturnNil(L);
-    }
-    const auto& tabs = gh->getSpellBookTabs();
-    if (tabIdx > static_cast<int>(tabs.size())) {
-        return luaReturnNil(L);
-    }
-    // Compute offset: sum of spells in all preceding tabs (1-based)
-    int offset = 0;
-    for (int i = 0; i < tabIdx - 1; ++i)
-        offset += static_cast<int>(tabs[i].spellIds.size());
-    const auto& tab = tabs[tabIdx - 1];
-    lua_pushstring(L, tab.name.c_str());           // name
-    lua_pushstring(L, tab.texture.c_str());        // texture
-    lua_pushnumber(L, offset);                     // offset (0-based for WoW compat)
-    lua_pushnumber(L, tab.spellIds.size());        // numSpells
-    return 4;
-}
-
-// GetSpellBookItemInfo(slot, bookType) → "SPELL", spellId
-// slot is 1-based global spell book index
-static int lua_GetSpellBookItemInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int slot = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || slot < 1) {
-        lua_pushstring(L, "SPELL");
-        lua_pushnumber(L, 0);
-        return 2;
-    }
-    const auto& tabs = gh->getSpellBookTabs();
-    int idx = slot; // 1-based
-    for (const auto& tab : tabs) {
-        if (idx <= static_cast<int>(tab.spellIds.size())) {
-            lua_pushstring(L, "SPELL");
-            lua_pushnumber(L, tab.spellIds[idx - 1]);
-            return 2;
-        }
-        idx -= static_cast<int>(tab.spellIds.size());
-    }
-    lua_pushstring(L, "SPELL");
-    lua_pushnumber(L, 0);
-    return 2;
-}
-
-// GetSpellBookItemName(slot, bookType) → name, subName
-static int lua_GetSpellBookItemName(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int slot = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || slot < 1) { return luaReturnNil(L); }
-    const auto& tabs = gh->getSpellBookTabs();
-    int idx = slot;
-    for (const auto& tab : tabs) {
-        if (idx <= static_cast<int>(tab.spellIds.size())) {
-            uint32_t spellId = tab.spellIds[idx - 1];
-            const std::string& name = gh->getSpellName(spellId);
-            lua_pushstring(L, name.empty() ? "Unknown" : name.c_str());
-            lua_pushstring(L, ""); // subName/rank
-            return 2;
-        }
-        idx -= static_cast<int>(tab.spellIds.size());
-    }
-    lua_pushnil(L);
-    return 1;
-}
-
-// GetSpellDescription(spellId) → description string
-// Clean spell description template variables for display
-static std::string cleanSpellDescription(const std::string& raw, const int32_t effectBase[3] = nullptr, float durationSec = 0.0f) {
-    if (raw.empty() || raw.find('$') == std::string::npos) return raw;
-    std::string result;
-    result.reserve(raw.size());
-    for (size_t i = 0; i < raw.size(); ++i) {
-        if (raw[i] == '$' && i + 1 < raw.size()) {
-            char next = raw[i + 1];
-            if (next == 's' || next == 'S') {
-                // $s1, $s2, $s3 — substitute with effect base points + 1
-                i += 1; // skip 's'
-                int idx = 0;
-                if (i + 1 < raw.size() && raw[i + 1] >= '1' && raw[i + 1] <= '3') {
-                    idx = raw[i + 1] - '1';
-                    ++i;
-                }
-                if (effectBase && effectBase[idx] != 0) {
-                    int32_t val = std::abs(effectBase[idx]) + 1;
-                    result += std::to_string(val);
-                } else {
-                    result += 'X';
-                }
-                while (i + 1 < raw.size() && raw[i + 1] >= '0' && raw[i + 1] <= '9') ++i;
-            } else if (next == 'o' || next == 'O') {
-                // $o1 = periodic total (base * ticks). Ticks = duration / 3sec for most spells
-                i += 1;
-                int idx = 0;
-                if (i + 1 < raw.size() && raw[i + 1] >= '1' && raw[i + 1] <= '3') {
-                    idx = raw[i + 1] - '1';
-                    ++i;
-                }
-                if (effectBase && effectBase[idx] != 0 && durationSec > 0.0f) {
-                    int32_t perTick = std::abs(effectBase[idx]) + 1;
-                    int ticks = static_cast<int>(durationSec / 3.0f);
-                    if (ticks < 1) ticks = 1;
-                    result += std::to_string(perTick * ticks);
-                } else {
-                    result += 'X';
-                }
-                while (i + 1 < raw.size() && raw[i + 1] >= '0' && raw[i + 1] <= '9') ++i;
-            } else if (next == 'e' || next == 'E' || next == 't' || next == 'T' ||
-                next == 'h' || next == 'H' || next == 'u' || next == 'U') {
-                // Other variables — insert "X" placeholder
-                result += 'X';
-                i += 1;
-                while (i + 1 < raw.size() && raw[i + 1] >= '0' && raw[i + 1] <= '9') ++i;
-            } else if (next == 'd' || next == 'D') {
-                // $d = duration
-                if (durationSec > 0.0f) {
-                    if (durationSec >= 60.0f)
-                        result += std::to_string(static_cast<int>(durationSec / 60.0f)) + " min";
-                    else
-                        result += std::to_string(static_cast<int>(durationSec)) + " sec";
-                } else {
-                    result += "X sec";
-                }
-                ++i;
-                while (i + 1 < raw.size() && raw[i + 1] >= '0' && raw[i + 1] <= '9') ++i;
-            } else if (next == 'a' || next == 'A') {
-                // $a1 = radius
-                result += "X";
-                ++i;
-                while (i + 1 < raw.size() && raw[i + 1] >= '0' && raw[i + 1] <= '9') ++i;
-            } else if (next == 'b' || next == 'B' || next == 'n' || next == 'N' ||
-                       next == 'i' || next == 'I' || next == 'x' || next == 'X') {
-                // misc variables
-                result += "X";
-                ++i;
-                while (i + 1 < raw.size() && raw[i + 1] >= '0' && raw[i + 1] <= '9') ++i;
-            } else if (next == '$') {
-                // $$ = literal $
-                result += '$';
-                ++i;
-            } else if (next == '{' || next == '<') {
-                // ${...} or $<...> — skip entire block
-                char close = (next == '{') ? '}' : '>';
-                size_t end = raw.find(close, i + 2);
-                if (end != std::string::npos) i = end;
-                else result += raw[i]; // no closing — keep $
-            } else {
-                result += raw[i]; // unknown $ pattern — keep
-            }
-        } else {
-            result += raw[i];
-        }
-    }
-    return result;
-}
-
-static int lua_GetSpellDescription(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushstring(L, ""); return 1; }
-    uint32_t spellId = static_cast<uint32_t>(luaL_checknumber(L, 1));
-    const std::string& desc = gh->getSpellDescription(spellId);
-    const int32_t* ebp = gh->getSpellEffectBasePoints(spellId);
-    float dur = gh->getSpellDuration(spellId);
-    std::string cleaned = cleanSpellDescription(desc, ebp, dur);
-    lua_pushstring(L, cleaned.c_str());
-    return 1;
-}
-
-
-static int lua_GetEnchantInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-    uint32_t enchantId = static_cast<uint32_t>(luaL_checknumber(L, 1));
-    std::string name = gh->getEnchantName(enchantId);
-    if (name.empty()) { return luaReturnNil(L); }
-    lua_pushstring(L, name.c_str());
-    return 1;
-}
-
-static int lua_GetSpellCooldown(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushnumber(L, 0); lua_pushnumber(L, 0); return 2; }
-    // Accept spell name or ID
-    uint32_t spellId = 0;
-    if (lua_isnumber(L, 1)) {
-        spellId = static_cast<uint32_t>(lua_tonumber(L, 1));
-    } else {
-        const char* name = luaL_checkstring(L, 1);
-        std::string nameLow(name);
-        toLowerInPlace(nameLow);
-        for (uint32_t sid : gh->getKnownSpells()) {
-            std::string sn = gh->getSpellName(sid);
-            toLowerInPlace(sn);
-            if (sn == nameLow) { spellId = sid; break; }
-        }
-    }
-    float cd = gh->getSpellCooldown(spellId);
-    // Also check GCD — if spell has no individual cooldown but GCD is active,
-    // return the GCD timing (this is how WoW handles it)
-    float gcdRem = gh->getGCDRemaining();
-    float gcdTotal = gh->getGCDTotal();
-
-    // WoW returns (start, duration, enabled) where remaining = start + duration - GetTime()
-    double nowSec = luaGetTimeNow();
-
-    if (cd > 0.01f) {
-        // Spell-specific cooldown (longer than GCD)
-        double start = nowSec - 0.01; // approximate start as "just now" minus epsilon
-        lua_pushnumber(L, start);
-        lua_pushnumber(L, cd);
-    } else if (gcdRem > 0.01f) {
-        // GCD is active — return GCD timing
-        double elapsed = gcdTotal - gcdRem;
-        double start = nowSec - elapsed;
-        lua_pushnumber(L, start);
-        lua_pushnumber(L, gcdTotal);
-    } else {
-        lua_pushnumber(L, 0);       // not on cooldown
-        lua_pushnumber(L, 0);
-    }
-    lua_pushnumber(L, 1);           // enabled
-    return 3;
-}
-
-static int lua_HasTarget(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushboolean(L, gh && gh->hasTarget());
-    return 1;
-}
-
-// TargetUnit(unitId) — set current target
-static int lua_TargetUnit(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    const char* uid = luaL_checkstring(L, 1);
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid != 0) gh->setTarget(guid);
-    return 0;
-}
-
-// ClearTarget() — clear current target
-static int lua_ClearTarget(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (gh) gh->clearTarget();
-    return 0;
-}
-
-// FocusUnit(unitId) — set focus target
-static int lua_FocusUnit(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    const char* uid = luaL_optstring(L, 1, nullptr);
-    if (!uid || !*uid) return 0;
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid != 0) gh->setFocus(guid);
-    return 0;
-}
-
-// ClearFocus() — clear focus target
-static int lua_ClearFocus(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (gh) gh->clearFocus();
-    return 0;
-}
-
-// AssistUnit(unitId) — target whatever the given unit is targeting
-static int lua_AssistUnit(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    const char* uid = luaL_optstring(L, 1, "target");
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid == 0) return 0;
-    uint64_t theirTarget = getEntityTargetGuid(gh, guid);
-    if (theirTarget != 0) gh->setTarget(theirTarget);
-    return 0;
-}
-
-// TargetLastTarget() — re-target previous target
-static int lua_TargetLastTarget(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (gh) gh->targetLastTarget();
-    return 0;
-}
-
-// TargetNearestEnemy() — tab-target nearest enemy
-static int lua_TargetNearestEnemy(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (gh) gh->targetEnemy(false);
-    return 0;
-}
-
-// TargetNearestFriend() — target nearest friendly unit
-static int lua_TargetNearestFriend(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (gh) gh->targetFriend(false);
-    return 0;
-}
-
-// GetRaidTargetIndex(unit) → icon index (1-8) or nil
-static int lua_GetRaidTargetIndex(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-    const char* uid = luaL_optstring(L, 1, "target");
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid == 0) { return luaReturnNil(L); }
-    uint8_t mark = gh->getEntityRaidMark(guid);
-    if (mark == 0xFF) { return luaReturnNil(L); }
-    lua_pushnumber(L, mark + 1); // WoW uses 1-indexed (1=Star, 2=Circle, ... 8=Skull)
-    return 1;
-}
-
-// SetRaidTarget(unit, index) — set raid marker (1-8, or 0 to clear)
-static int lua_SetRaidTarget(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    const char* uid = luaL_optstring(L, 1, "target");
-    int index = static_cast<int>(luaL_checknumber(L, 2));
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid == 0) return 0;
-    if (index >= 1 && index <= 8)
-        gh->setRaidMark(guid, static_cast<uint8_t>(index - 1));
-    else if (index == 0)
-        gh->setRaidMark(guid, 0xFF); // clear
-    return 0;
-}
-
-// GetSpellPowerCost(spellId) → {{ type=powerType, cost=manaCost, name=powerName }}
-
-static int lua_GetSpellPowerCost(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_newtable(L); return 1; }
-    uint32_t spellId = static_cast<uint32_t>(luaL_checknumber(L, 1));
-    auto data = gh->getSpellData(spellId);
-    lua_newtable(L); // outer table (array of cost entries)
-    if (data.manaCost > 0) {
-        lua_newtable(L); // cost entry
-        lua_pushnumber(L, data.powerType);
-        lua_setfield(L, -2, "type");
-        lua_pushnumber(L, data.manaCost);
-        lua_setfield(L, -2, "cost");
-    
-        lua_pushstring(L, data.powerType < 7 ? kLuaPowerNames[data.powerType] : "MANA");
-        lua_setfield(L, -2, "name");
-        lua_rawseti(L, -2, 1); // outer[1] = entry
-    }
-    return 1;
-}
-
-// --- GetSpellInfo / GetSpellTexture ---
-// GetSpellInfo(spellIdOrName) -> name, rank, icon, castTime, minRange, maxRange, spellId
-static int lua_GetSpellInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-
-    uint32_t spellId = 0;
-    if (lua_isnumber(L, 1)) {
-        spellId = static_cast<uint32_t>(lua_tonumber(L, 1));
-    } else if (lua_isstring(L, 1)) {
-        const char* name = lua_tostring(L, 1);
-        if (!name || !*name) { return luaReturnNil(L); }
-        std::string nameLow(name);
-        toLowerInPlace(nameLow);
-        int bestRank = -1;
-        for (uint32_t sid : gh->getKnownSpells()) {
-            std::string sn = gh->getSpellName(sid);
-            toLowerInPlace(sn);
-            if (sn != nameLow) continue;
-            int rank = 0;
-            const std::string& rk = gh->getSpellRank(sid);
-            if (!rk.empty()) {
-                std::string rkl = rk;
-                toLowerInPlace(rkl);
-                if (rkl.rfind("rank ", 0) == 0) {
-                    try { rank = std::stoi(rkl.substr(5)); } catch (...) {}
-                }
-            }
-            if (rank > bestRank) { bestRank = rank; spellId = sid; }
-        }
-    }
-
-    if (spellId == 0) { return luaReturnNil(L); }
-    std::string name = gh->getSpellName(spellId);
-    if (name.empty()) { return luaReturnNil(L); }
-
-    lua_pushstring(L, name.c_str());                        // 1: name
-    const std::string& rank = gh->getSpellRank(spellId);
-    lua_pushstring(L, rank.c_str());                        // 2: rank
-    std::string iconPath = gh->getSpellIconPath(spellId);
-    if (!iconPath.empty()) lua_pushstring(L, iconPath.c_str());
-    else lua_pushnil(L);                                     // 3: icon texture path
-    // Resolve cast time and range from Spell.dbc → SpellCastTimes.dbc / SpellRange.dbc
-    auto spellData = gh->getSpellData(spellId);
-    lua_pushnumber(L, spellData.castTimeMs);                 // 4: castTime (ms)
-    lua_pushnumber(L, spellData.minRange);                   // 5: minRange (yards)
-    lua_pushnumber(L, spellData.maxRange);                   // 6: maxRange (yards)
-    lua_pushnumber(L, spellId);                              // 7: spellId
-    return 7;
-}
-
-// GetSpellTexture(spellIdOrName) -> icon texture path string
-static int lua_GetSpellTexture(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-
-    uint32_t spellId = 0;
-    if (lua_isnumber(L, 1)) {
-        spellId = static_cast<uint32_t>(lua_tonumber(L, 1));
-    } else if (lua_isstring(L, 1)) {
-        const char* name = lua_tostring(L, 1);
-        if (!name || !*name) { return luaReturnNil(L); }
-        std::string nameLow(name);
-        toLowerInPlace(nameLow);
-        for (uint32_t sid : gh->getKnownSpells()) {
-            std::string sn = gh->getSpellName(sid);
-            toLowerInPlace(sn);
-            if (sn == nameLow) { spellId = sid; break; }
-        }
-    }
-    if (spellId == 0) { return luaReturnNil(L); }
-    std::string iconPath = gh->getSpellIconPath(spellId);
-    if (!iconPath.empty()) lua_pushstring(L, iconPath.c_str());
-    else lua_pushnil(L);
-    return 1;
-}
-
-// GetItemInfo(itemId) -> name, link, quality, iLevel, reqLevel, class, subclass, maxStack, equipSlot, texture, vendorPrice
-
-static int lua_GetSpellLink(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-
-    uint32_t spellId = 0;
-    if (lua_isnumber(L, 1)) {
-        spellId = static_cast<uint32_t>(lua_tonumber(L, 1));
-    } else if (lua_isstring(L, 1)) {
-        const char* name = lua_tostring(L, 1);
-        if (!name || !*name) { return luaReturnNil(L); }
-        std::string nameLow(name);
-        toLowerInPlace(nameLow);
-        for (uint32_t sid : gh->getKnownSpells()) {
-            std::string sn = gh->getSpellName(sid);
-            toLowerInPlace(sn);
-            if (sn == nameLow) { spellId = sid; break; }
-        }
-    }
-    if (spellId == 0) { return luaReturnNil(L); }
-    std::string name = gh->getSpellName(spellId);
-    if (name.empty()) { return luaReturnNil(L); }
-    char link[256];
-    snprintf(link, sizeof(link), "|cff71d5ff|Hspell:%u|h[%s]|h|r", spellId, name.c_str());
-    lua_pushstring(L, link);
-    return 1;
-}
-
-static int lua_CancelUnitBuff(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    const char* uid = luaL_optstring(L, 1, "player");
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    if (uidStr != "player") return 0; // Can only cancel own buffs
-    int index = static_cast<int>(luaL_checknumber(L, 2));
-    const auto& auras = gh->getPlayerAuras();
-    // Find the Nth buff (non-debuff)
-    int buffCount = 0;
-    for (const auto& a : auras) {
-        if (a.isEmpty()) continue;
-        if ((a.flags & 0x80) != 0) continue; // skip debuffs
-        if (++buffCount == index) {
-            gh->cancelAura(a.spellId);
-            break;
-        }
-    }
-    return 0;
-}
-
-// CastSpellByID(spellId) — cast spell by numeric ID
-static int lua_CastSpellByID(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) return 0;
-    uint32_t spellId = static_cast<uint32_t>(luaL_checknumber(L, 1));
-    if (spellId == 0) return 0;
-    uint64_t target = gh->hasTarget() ? gh->getTargetGuid() : 0;
-    gh->castSpell(spellId, target);
-    return 0;
-}
-
-static int lua_IsUsableSpell(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushboolean(L, 0); lua_pushboolean(L, 0); return 2; }
-
-    uint32_t spellId = 0;
-    if (lua_isnumber(L, 1)) {
-        spellId = static_cast<uint32_t>(lua_tonumber(L, 1));
-    } else if (lua_isstring(L, 1)) {
-        const char* name = lua_tostring(L, 1);
-        if (!name || !*name) { lua_pushboolean(L, 0); lua_pushboolean(L, 0); return 2; }
-        std::string nameLow(name);
-        toLowerInPlace(nameLow);
-        for (uint32_t sid : gh->getKnownSpells()) {
-            std::string sn = gh->getSpellName(sid);
-            toLowerInPlace(sn);
-            if (sn == nameLow) { spellId = sid; break; }
-        }
-    }
-
-    if (spellId == 0 || !gh->getKnownSpells().count(spellId)) {
-        lua_pushboolean(L, 0);
-        lua_pushboolean(L, 0);
-        return 2;
-    }
-
-    float cd = gh->getSpellCooldown(spellId);
-    bool onCooldown = (cd > 0.1f);
-    bool noMana = false;
-    if (!onCooldown) {
-        auto spellData = gh->getSpellData(spellId);
-        if (spellData.manaCost > 0) {
-            auto playerEntity = gh->getEntityManager().getEntity(gh->getPlayerGuid());
-            if (playerEntity) {
-                auto* unit = dynamic_cast<game::Unit*>(playerEntity.get());
-                if (unit && unit->getPower() < spellData.manaCost) {
-                    noMana = true;
-                }
-            }
-        }
-    }
-    lua_pushboolean(L, (onCooldown || noMana) ? 0 : 1);
-    lua_pushboolean(L, noMana ? 1 : 0);
-    return 2;
-}
-
-
-void registerSpellLuaAPI(lua_State* L) {
-    static const struct { const char* name; lua_CFunction func; } api[] = {
-                {"SpellStopCasting", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->cancelCast();
-            return 0;
-        }},
-                {"SpellStopTargeting", [](lua_State* L) -> int {
-            (void)L; return 0; // No targeting reticle in this client
-        }},
-                {"SpellIsTargeting", [](lua_State* L) -> int {
-            lua_pushboolean(L, 0); // No AoE targeting reticle
-            return 1;
-        }},
-                {"IsSpellInRange",    lua_IsSpellInRange},
-                {"UnitBuff",          lua_UnitBuff},
-                {"UnitDebuff",        lua_UnitDebuff},
-                {"UnitAura",          lua_UnitAuraGeneric},
-                {"UnitCastingInfo",   lua_UnitCastingInfo},
-                {"UnitChannelInfo",   lua_UnitChannelInfo},
-                {"CastSpellByName",   lua_CastSpellByName},
-                {"CastSpellByID",       lua_CastSpellByID},
-                {"IsSpellKnown",      lua_IsSpellKnown},
-                {"GetNumSpellTabs",   lua_GetNumSpellTabs},
-                {"GetSpellTabInfo",   lua_GetSpellTabInfo},
-                {"GetSpellBookItemInfo", lua_GetSpellBookItemInfo},
-                {"GetSpellBookItemName", lua_GetSpellBookItemName},
-                {"GetSpellCooldown",  lua_GetSpellCooldown},
-                {"GetSpellPowerCost", lua_GetSpellPowerCost},
-                {"GetSpellDescription", lua_GetSpellDescription},
-                {"GetEnchantInfo",     lua_GetEnchantInfo},
-                {"GetSpellInfo",      lua_GetSpellInfo},
-                {"GetSpellTexture",   lua_GetSpellTexture},
-                {"GetSpellLink",         lua_GetSpellLink},
-                {"IsUsableSpell",        lua_IsUsableSpell},
-                {"CancelUnitBuff",      lua_CancelUnitBuff},
-                {"HasTarget",         lua_HasTarget},
-                {"TargetUnit",        lua_TargetUnit},
-                {"ClearTarget",       lua_ClearTarget},
-                {"FocusUnit",         lua_FocusUnit},
-                {"ClearFocus",        lua_ClearFocus},
-                {"AssistUnit",        lua_AssistUnit},
-                {"TargetLastTarget",  lua_TargetLastTarget},
-                {"TargetNearestEnemy",  lua_TargetNearestEnemy},
-                {"TargetNearestFriend", lua_TargetNearestFriend},
-                {"GetRaidTargetIndex",  lua_GetRaidTargetIndex},
-                {"SetRaidTarget",       lua_SetRaidTarget},
-                {"IsPlayerSpell", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            uint32_t spellId = static_cast<uint32_t>(luaL_checknumber(L, 1));
-            lua_pushboolean(L, gh && gh->getKnownSpells().count(spellId) ? 1 : 0);
-            return 1;
-        }},
-                {"IsSpellOverlayed", [](lua_State* L) -> int {
-            (void)L; lua_pushboolean(L, 0); return 1; // No proc overlay tracking
-        }},
-                {"IsCurrentSpell", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            uint32_t spellId = static_cast<uint32_t>(luaL_checknumber(L, 1));
-            lua_pushboolean(L, gh && gh->getCurrentCastSpellId() == spellId ? 1 : 0);
-            return 1;
-        }},
-                {"IsAutoRepeatSpell", [](lua_State* L) -> int {
-            (void)L; lua_pushboolean(L, 0); return 1; // Stub
-        }},
-                {"CastShapeshiftForm", [](lua_State* L) -> int {
-            // CastShapeshiftForm(index) — cast the spell for the given form slot
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            if (!gh || index < 1) return 0;
-            uint8_t classId = gh->getPlayerClass();
-            // Map class + index to spell IDs
-            // Warrior stances
-            static const uint32_t warriorSpells[] = {2457, 71, 2458}; // Battle, Defensive, Berserker
-            // Druid forms
-            static const uint32_t druidSpells[] = {5487, 783, 768, 40120, 24858, 33891}; // Bear, Travel, Cat, Swift Flight, Moonkin, Tree
-            // DK presences
-            static const uint32_t dkSpells[] = {48266, 48263, 48265}; // Blood, Frost, Unholy
-            // Rogue
-            static const uint32_t rogueSpells[] = {1784}; // Stealth
-
-            const uint32_t* spells = nullptr;
-            int numSpells = 0;
-            switch (classId) {
-                case 1: spells = warriorSpells; numSpells = 3; break;
-                case 6: spells = dkSpells; numSpells = 3; break;
-                case 4: spells = rogueSpells; numSpells = 1; break;
-                case 11: spells = druidSpells; numSpells = 6; break;
-                default: return 0;
-            }
-            if (index <= numSpells) {
-                gh->castSpell(spells[index - 1], 0);
-            }
-            return 0;
-        }},
-                {"CancelShapeshiftForm", [](lua_State* L) -> int {
-            // Cancel current form — cast spell 0 or cancel aura
-            auto* gh = getGameHandler(L);
-            if (gh && gh->getShapeshiftFormId() != 0) {
-                // Cancelling a form is done by re-casting the same form spell
-                // For simplicity, just note that the server will handle it
-            }
-            return 0;
-        }},
-                {"GetShapeshiftFormCooldown", [](lua_State* L) -> int {
-            // No per-form cooldown tracking — return no cooldown
-            lua_pushnumber(L, 0); lua_pushnumber(L, 0); lua_pushnumber(L, 1);
-            return 3;
-        }},
-                {"GetShapeshiftForm", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            lua_pushnumber(L, gh ? gh->getShapeshiftFormId() : 0);
-            return 1;
-        }},
-                {"GetNumShapeshiftForms", [](lua_State* L) -> int {
-            // Return count based on player class
-            auto* gh = getGameHandler(L);
-            if (!gh) { return luaReturnZero(L); }
-            uint8_t classId = gh->getPlayerClass();
-            // Druid: Bear(1), Aquatic(2), Cat(3), Travel(4), Moonkin/Tree(5/6)
-            // Warrior: Battle(1), Defensive(2), Berserker(3)
-            // Rogue: Stealth(1)
-            // Priest: Shadowform(1)
-            // Paladin: varies by level/talents
-            // DK: Blood Presence, Frost, Unholy (3)
-            switch (classId) {
-                case 1: lua_pushnumber(L, 3); break;  // Warrior
-                case 2: lua_pushnumber(L, 3); break;  // Paladin (auras)
-                case 4: lua_pushnumber(L, 1); break;  // Rogue
-                case 5: lua_pushnumber(L, 1); break;  // Priest
-                case 6: lua_pushnumber(L, 3); break;  // Death Knight
-                case 11: lua_pushnumber(L, 6); break; // Druid
-                default: lua_pushnumber(L, 0); break;
-            }
-            return 1;
-        }},
-    };
-    for (const auto& [name, func] : api) {
-        lua_pushcfunction(L, func);
-        lua_setglobal(L, name);
-    }
-}
-
-} // namespace wowee::addons
diff --git a/src/addons/lua_system_api.cpp b/src/addons/lua_system_api.cpp
deleted file mode 100644
index bfd992ac..00000000
--- a/src/addons/lua_system_api.cpp
+++ /dev/null
@@ -1,761 +0,0 @@
-// lua_system_api.cpp — System, time, sound, locale, map, addons, instances, and utilities Lua API bindings.
-// Extracted from lua_engine.cpp as part of §5.1 (Tame LuaEngine).
-#include "addons/lua_api_helpers.hpp"
-#include "audio/audio_coordinator.hpp"
-#include "audio/ui_sound_manager.hpp"
-#include "core/window.hpp"
-#include "game/expansion_profile.hpp"
-
-namespace wowee::addons {
-
-static int lua_PlaySound(lua_State* L) {
-    auto* svc = getLuaServices(L);
-    auto* ac = svc ? svc->audioCoordinator : nullptr;
-    if (!ac) return 0;
-    auto* sfx = ac->getUiSoundManager();
-    if (!sfx) return 0;
-
-    // Accept numeric sound ID or string name
-    std::string sound;
-    if (lua_isnumber(L, 1)) {
-        uint32_t id = static_cast<uint32_t>(lua_tonumber(L, 1));
-        // Map common WoW sound IDs to named sounds
-        switch (id) {
-            case 856: case 1115: sfx->playButtonClick(); return 0; // igMainMenuOption
-            case 840: sfx->playQuestActivate(); return 0;          // igQuestListOpen
-            case 841: sfx->playQuestComplete(); return 0;           // igQuestListComplete
-            case 862: sfx->playBagOpen(); return 0;                // igBackPackOpen
-            case 863: sfx->playBagClose(); return 0;               // igBackPackClose
-            case 867: sfx->playError(); return 0;                  // igPlayerInvite
-            case 888: sfx->playLevelUp(); return 0;                // LEVELUPSOUND
-            default: return 0;
-        }
-    } else {
-        const char* name = luaL_optstring(L, 1, "");
-        sound = name;
-        for (char& c : sound) c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
-        if (sound == "IGMAINMENUOPTION" || sound == "IGMAINMENUOPTIONCHECKBOXON")
-            sfx->playButtonClick();
-        else if (sound == "IGQUESTLISTOPEN") sfx->playQuestActivate();
-        else if (sound == "IGQUESTLISTCOMPLETE") sfx->playQuestComplete();
-        else if (sound == "IGBACKPACKOPEN") sfx->playBagOpen();
-        else if (sound == "IGBACKPACKCLOSE") sfx->playBagClose();
-        else if (sound == "LEVELUPSOUND") sfx->playLevelUp();
-        else if (sound == "IGPLAYERINVITEACCEPTED") sfx->playButtonClick();
-        else if (sound == "TALENTSCREENOPEN") sfx->playCharacterSheetOpen();
-        else if (sound == "TALENTSCREENCLOSE") sfx->playCharacterSheetClose();
-    }
-    return 0;
-}
-
-// PlaySoundFile(path) — stub (file-based sounds not loaded from Lua)
-static int lua_PlaySoundFile(lua_State* L) { (void)L; return 0; }
-
-static int lua_GetPlayerMapPosition(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (gh) {
-        const auto& mi = gh->getMovementInfo();
-        lua_pushnumber(L, mi.x);
-        lua_pushnumber(L, mi.y);
-        return 2;
-    }
-    lua_pushnumber(L, 0);
-    lua_pushnumber(L, 0);
-    return 2;
-}
-
-// GetPlayerFacing() → radians (0 = north, increasing counter-clockwise)
-static int lua_GetPlayerFacing(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (gh) {
-        float facing = gh->getMovementInfo().orientation;
-        // Normalize to [0, 2π)
-        while (facing < 0) facing += 6.2831853f;
-        while (facing >= 6.2831853f) facing -= 6.2831853f;
-        lua_pushnumber(L, facing);
-    } else {
-        lua_pushnumber(L, 0);
-    }
-    return 1;
-}
-
-// GetCVar(name) → value string (stub for most, real for a few)
-static int lua_GetCVar(lua_State* L) {
-    const char* name = luaL_checkstring(L, 1);
-    std::string n(name);
-    // Return sensible defaults for commonly queried CVars
-    if (n == "uiScale") lua_pushstring(L, "1");
-    else if (n == "useUIScale") lua_pushstring(L, "1");
-    else if (n == "screenWidth" || n == "gxResolution") {
-        auto* svc = getLuaServices(L);
-        auto* win = svc ? svc->window : nullptr;
-        lua_pushstring(L, std::to_string(win ? win->getWidth() : 1920).c_str());
-    } else if (n == "screenHeight" || n == "gxFullscreenResolution") {
-        auto* svc = getLuaServices(L);
-        auto* win = svc ? svc->window : nullptr;
-        lua_pushstring(L, std::to_string(win ? win->getHeight() : 1080).c_str());
-    } else if (n == "nameplateShowFriends") lua_pushstring(L, "1");
-    else if (n == "nameplateShowEnemies") lua_pushstring(L, "1");
-    else if (n == "Sound_EnableSFX") lua_pushstring(L, "1");
-    else if (n == "Sound_EnableMusic") lua_pushstring(L, "1");
-    else if (n == "chatBubbles") lua_pushstring(L, "1");
-    else if (n == "autoLootDefault") lua_pushstring(L, "1");
-    else lua_pushstring(L, "0");
-    return 1;
-}
-
-// SetCVar(name, value) — no-op stub
-static int lua_SetCVar(lua_State* L) {
-    (void)L;
-    return 0;
-}
-
-
-static int lua_GetNumAddOns(lua_State* L) {
-    lua_getfield(L, LUA_REGISTRYINDEX, "wowee_addon_count");
-    return 1;
-}
-
-static int lua_GetAddOnInfo(lua_State* L) {
-    // Accept index (1-based) or addon name
-    lua_getfield(L, LUA_REGISTRYINDEX, "wowee_addon_info");
-    if (!lua_istable(L, -1)) {
-        lua_pop(L, 1);
-        return luaReturnNil(L);
-    }
-
-    int idx = 0;
-    if (lua_isnumber(L, 1)) {
-        idx = static_cast<int>(lua_tonumber(L, 1));
-    } else if (lua_isstring(L, 1)) {
-        // Search by name
-        const char* name = lua_tostring(L, 1);
-        int count = static_cast<int>(lua_objlen(L, -1));
-        for (int i = 1; i <= count; i++) {
-            lua_rawgeti(L, -1, i);
-            lua_getfield(L, -1, "name");
-            const char* aName = lua_tostring(L, -1);
-            lua_pop(L, 1);
-            if (aName && strcmp(aName, name) == 0) { idx = i; lua_pop(L, 1); break; }
-            lua_pop(L, 1);
-        }
-    }
-
-    if (idx < 1) { lua_pop(L, 1); lua_pushnil(L); return 1; }
-
-    lua_rawgeti(L, -1, idx);
-    if (!lua_istable(L, -1)) { lua_pop(L, 2); lua_pushnil(L); return 1; }
-
-    lua_getfield(L, -1, "name");
-    lua_getfield(L, -2, "title");
-    lua_getfield(L, -3, "notes");
-    lua_pushboolean(L, 1); // loadable (always true for now)
-    lua_pushstring(L, "INSECURE"); // security
-    lua_pop(L, 1); // pop addon info entry (keep others)
-    // Return: name, title, notes, loadable, reason, security
-    return 5;
-}
-
-// GetAddOnMetadata(addonNameOrIndex, key) → value
-static int lua_GetAddOnMetadata(lua_State* L) {
-    lua_getfield(L, LUA_REGISTRYINDEX, "wowee_addon_info");
-    if (!lua_istable(L, -1)) { lua_pop(L, 1); lua_pushnil(L); return 1; }
-
-    int idx = 0;
-    if (lua_isnumber(L, 1)) {
-        idx = static_cast<int>(lua_tonumber(L, 1));
-    } else if (lua_isstring(L, 1)) {
-        const char* name = lua_tostring(L, 1);
-        int count = static_cast<int>(lua_objlen(L, -1));
-        for (int i = 1; i <= count; i++) {
-            lua_rawgeti(L, -1, i);
-            lua_getfield(L, -1, "name");
-            const char* aName = lua_tostring(L, -1);
-            lua_pop(L, 1);
-            if (aName && strcmp(aName, name) == 0) { idx = i; lua_pop(L, 1); break; }
-            lua_pop(L, 1);
-        }
-    }
-    if (idx < 1) { lua_pop(L, 1); lua_pushnil(L); return 1; }
-
-    const char* key = luaL_checkstring(L, 2);
-    lua_rawgeti(L, -1, idx);
-    if (!lua_istable(L, -1)) { lua_pop(L, 2); lua_pushnil(L); return 1; }
-    lua_getfield(L, -1, "metadata");
-    if (!lua_istable(L, -1)) { lua_pop(L, 3); lua_pushnil(L); return 1; }
-    lua_getfield(L, -1, key);
-    return 1;
-}
-
-// UnitBuff(unitId, index) / UnitDebuff(unitId, index)
-// Returns: name, rank, icon, count, debuffType, duration, expirationTime, caster, isStealable, shouldConsolidate, spellId
-
-static int lua_GetLocale(lua_State* L) {
-    lua_pushstring(L, "enUS");
-    return 1;
-}
-
-static int lua_GetBuildInfo(lua_State* L) {
-    // Return WotLK defaults; expansion-specific version detection would need
-    // access to the expansion registry which isn't available here.
-    lua_pushstring(L, "3.3.5a");    // 1: version
-    lua_pushnumber(L, 12340);       // 2: buildNumber
-    lua_pushstring(L, "Jan 1 2025");// 3: date
-    lua_pushnumber(L, 30300);       // 4: tocVersion
-    return 4;
-}
-
-static int lua_GetCurrentMapAreaID(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushnumber(L, gh ? gh->getCurrentMapId() : 0);
-    return 1;
-}
-
-// GetZoneText() / GetRealZoneText() → current zone name
-static int lua_GetZoneText(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushstring(L, ""); return 1; }
-    uint32_t zoneId = gh->getWorldStateZoneId();
-    if (zoneId != 0) {
-        std::string name = gh->getWhoAreaName(zoneId);
-        if (!name.empty()) { lua_pushstring(L, name.c_str()); return 1; }
-    }
-    lua_pushstring(L, "");
-    return 1;
-}
-
-// GetSubZoneText() → subzone name (same as zone for now — server doesn't always send subzone)
-static int lua_GetSubZoneText(lua_State* L) {
-    return lua_GetZoneText(L);  // Best-effort: zone and subzone often overlap
-}
-
-// GetMinimapZoneText() → zone name displayed near minimap
-static int lua_GetMinimapZoneText(lua_State* L) {
-    return lua_GetZoneText(L);
-}
-
-// --- World Map Navigation API ---
-
-// Map ID → continent mapping
-static int mapIdToContinent(uint32_t mapId) {
-    switch (mapId) {
-        case 0:   return 2; // Eastern Kingdoms
-        case 1:   return 1; // Kalimdor
-        case 530: return 3; // Outland
-        case 571: return 4; // Northrend
-        default:  return 0; // Instance or unknown
-    }
-}
-
-// Internal tracked map state (which continent/zone the map UI is viewing)
-static int s_mapContinent = 0;
-static int s_mapZone = 0;
-
-// SetMapToCurrentZone() — sets map view to the player's current zone
-static int lua_SetMapToCurrentZone(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (gh) {
-        s_mapContinent = mapIdToContinent(gh->getCurrentMapId());
-        s_mapZone = static_cast<int>(gh->getWorldStateZoneId());
-    }
-    return 0;
-}
-
-// GetCurrentMapContinent() → continentId (1=Kalimdor, 2=EK, 3=Outland, 4=Northrend)
-static int lua_GetCurrentMapContinent(lua_State* L) {
-    if (s_mapContinent == 0) {
-        auto* gh = getGameHandler(L);
-        if (gh) s_mapContinent = mapIdToContinent(gh->getCurrentMapId());
-    }
-    lua_pushnumber(L, s_mapContinent);
-    return 1;
-}
-
-// GetCurrentMapZone() → zoneId
-static int lua_GetCurrentMapZone(lua_State* L) {
-    if (s_mapZone == 0) {
-        auto* gh = getGameHandler(L);
-        if (gh) s_mapZone = static_cast<int>(gh->getWorldStateZoneId());
-    }
-    lua_pushnumber(L, s_mapZone);
-    return 1;
-}
-
-// SetMapZoom(continent [, zone]) — sets map view to continent/zone
-static int lua_SetMapZoom(lua_State* L) {
-    s_mapContinent = static_cast<int>(luaL_checknumber(L, 1));
-    s_mapZone = static_cast<int>(luaL_optnumber(L, 2, 0));
-    return 0;
-}
-
-// GetMapContinents() → "Kalimdor", "Eastern Kingdoms", ...
-static int lua_GetMapContinents(lua_State* L) {
-    lua_pushstring(L, "Kalimdor");
-    lua_pushstring(L, "Eastern Kingdoms");
-    lua_pushstring(L, "Outland");
-    lua_pushstring(L, "Northrend");
-    return 4;
-}
-
-// GetMapZones(continent) → zone names for that continent
-// Returns a basic list; addons mainly need this to not error
-static int lua_GetMapZones(lua_State* L) {
-    int cont = static_cast<int>(luaL_checknumber(L, 1));
-    // Return a minimal representative set per continent
-    switch (cont) {
-        case 1: // Kalimdor
-            lua_pushstring(L, "Durotar"); lua_pushstring(L, "Mulgore");
-            lua_pushstring(L, "The Barrens"); lua_pushstring(L, "Teldrassil");
-            return 4;
-        case 2: // Eastern Kingdoms
-            lua_pushstring(L, "Elwynn Forest"); lua_pushstring(L, "Westfall");
-            lua_pushstring(L, "Dun Morogh"); lua_pushstring(L, "Tirisfal Glades");
-            return 4;
-        case 3: // Outland
-            lua_pushstring(L, "Hellfire Peninsula"); lua_pushstring(L, "Zangarmarsh");
-            return 2;
-        case 4: // Northrend
-            lua_pushstring(L, "Borean Tundra"); lua_pushstring(L, "Howling Fjord");
-            return 2;
-        default:
-            return 0;
-    }
-}
-
-// GetNumMapLandmarks() → 0 (no landmark data exposed yet)
-static int lua_GetNumMapLandmarks(lua_State* L) {
-    lua_pushnumber(L, 0);
-    return 1;
-}
-
-
-static int lua_GetGameTime(lua_State* L) {
-    // Returns server game time as hours, minutes
-    auto* gh = getGameHandler(L);
-    if (gh) {
-        float gt = gh->getGameTime();
-        int hours = static_cast<int>(gt) % 24;
-        int mins = static_cast<int>((gt - static_cast<int>(gt)) * 60.0f);
-        lua_pushnumber(L, hours);
-        lua_pushnumber(L, mins);
-    } else {
-        lua_pushnumber(L, 12);
-        lua_pushnumber(L, 0);
-    }
-    return 2;
-}
-
-static int lua_GetServerTime(lua_State* L) {
-    lua_pushnumber(L, static_cast<double>(std::time(nullptr)));
-    return 1;
-}
-
-
-static int lua_IsInInstance(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushboolean(L, 0); lua_pushstring(L, "none"); return 2; }
-    bool inInstance = gh->isInInstance();
-    lua_pushboolean(L, inInstance);
-    lua_pushstring(L, inInstance ? "party" : "none");  // simplified: "none", "party", "raid", "pvp", "arena"
-    return 2;
-}
-
-// GetInstanceInfo() → name, type, difficultyIndex, difficultyName, maxPlayers, ...
-static int lua_GetInstanceInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) {
-        lua_pushstring(L, ""); lua_pushstring(L, "none"); lua_pushnumber(L, 0);
-        lua_pushstring(L, "Normal"); lua_pushnumber(L, 0);
-        return 5;
-    }
-    std::string mapName = gh->getMapName(gh->getCurrentMapId());
-    lua_pushstring(L, mapName.c_str());                    // 1: name
-    lua_pushstring(L, gh->isInInstance() ? "party" : "none"); // 2: instanceType
-    lua_pushnumber(L, gh->getInstanceDifficulty());        // 3: difficultyIndex
-    static constexpr const char* kDiff[] = {"Normal", "Heroic", "25 Normal", "25 Heroic"};
-    uint32_t diff = gh->getInstanceDifficulty();
-    lua_pushstring(L, (diff < 4) ? kDiff[diff] : "Normal"); // 4: difficultyName
-    lua_pushnumber(L, 5);                                   // 5: maxPlayers (default 5-man)
-    return 5;
-}
-
-static int lua_GetInstanceDifficulty(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushnumber(L, gh ? (gh->getInstanceDifficulty() + 1) : 1);
-    return 1;
-}
-
-static int lua_strsplit(lua_State* L) {
-    const char* delim = luaL_checkstring(L, 1);
-    const char* str = luaL_checkstring(L, 2);
-    if (!delim[0]) { lua_pushstring(L, str); return 1; }
-    int count = 0;
-    std::string s(str);
-    size_t pos = 0;
-    while (pos <= s.size()) {
-        size_t found = s.find(delim[0], pos);
-        if (found == std::string::npos) {
-            lua_pushstring(L, s.substr(pos).c_str());
-            count++;
-            break;
-        }
-        lua_pushstring(L, s.substr(pos, found - pos).c_str());
-        count++;
-        pos = found + 1;
-    }
-    return count;
-}
-
-// strtrim(str) — remove leading/trailing whitespace
-static int lua_strtrim(lua_State* L) {
-    const char* str = luaL_checkstring(L, 1);
-    std::string s(str);
-    size_t start = s.find_first_not_of(" \t\r\n");
-    size_t end = s.find_last_not_of(" \t\r\n");
-    lua_pushstring(L, (start == std::string::npos) ? "" : s.substr(start, end - start + 1).c_str());
-    return 1;
-}
-
-// wipe(table) — clear all entries from a table
-static int lua_wipe(lua_State* L) {
-    luaL_checktype(L, 1, LUA_TTABLE);
-    // Remove all integer keys
-    int len = static_cast<int>(lua_objlen(L, 1));
-    for (int i = len; i >= 1; i--) {
-        lua_pushnil(L);
-        lua_rawseti(L, 1, i);
-    }
-    // Remove all string keys
-    lua_pushnil(L);
-    while (lua_next(L, 1) != 0) {
-        lua_pop(L, 1);       // pop value
-        lua_pushvalue(L, -1); // copy key
-        lua_pushnil(L);
-        lua_rawset(L, 1);    // table[key] = nil
-    }
-    lua_pushvalue(L, 1);
-    return 1;
-}
-
-// date(format) — safe date function (os.date was removed)
-static int lua_wow_date(lua_State* L) {
-    const char* fmt = luaL_optstring(L, 1, "%c");
-    time_t now = time(nullptr);
-    struct tm* tm = localtime(&now);
-    char buf[256];
-    strftime(buf, sizeof(buf), fmt, tm);
-    lua_pushstring(L, buf);
-    return 1;
-}
-
-// time() — current unix timestamp
-static int lua_wow_time(lua_State* L) {
-    lua_pushnumber(L, static_cast<double>(time(nullptr)));
-    return 1;
-}
-
-// GetTime() — returns elapsed seconds since engine start (shared epoch)
-static int lua_wow_gettime(lua_State* L) {
-    lua_pushnumber(L, luaGetTimeNow());
-    return 1;
-}
-
-void registerSystemLuaAPI(lua_State* L) {
-    static const struct { const char* name; lua_CFunction func; } api[] = {
-                {"PlaySound",           lua_PlaySound},
-                {"PlaySoundFile",       lua_PlaySoundFile},
-                {"GetPlayerMapPosition", lua_GetPlayerMapPosition},
-                {"GetPlayerFacing",     lua_GetPlayerFacing},
-                {"GetCVar",             lua_GetCVar},
-                {"SetCVar",             lua_SetCVar},
-                {"GetLocale",         lua_GetLocale},
-                {"GetBuildInfo",      lua_GetBuildInfo},
-                {"GetCurrentMapAreaID", lua_GetCurrentMapAreaID},
-                {"SetMapToCurrentZone", lua_SetMapToCurrentZone},
-                {"GetCurrentMapContinent", lua_GetCurrentMapContinent},
-                {"GetCurrentMapZone",   lua_GetCurrentMapZone},
-                {"SetMapZoom",          lua_SetMapZoom},
-                {"GetMapContinents",    lua_GetMapContinents},
-                {"GetMapZones",         lua_GetMapZones},
-                {"GetNumMapLandmarks",  lua_GetNumMapLandmarks},
-                {"GetZoneText",          lua_GetZoneText},
-                {"GetRealZoneText",      lua_GetZoneText},
-                {"GetSubZoneText",       lua_GetSubZoneText},
-                {"GetMinimapZoneText",   lua_GetMinimapZoneText},
-                {"GetGameTime",             lua_GetGameTime},
-                {"GetServerTime",           lua_GetServerTime},
-                {"GetNumAddOns",      lua_GetNumAddOns},
-                {"GetAddOnInfo",      lua_GetAddOnInfo},
-                {"GetAddOnMetadata",  lua_GetAddOnMetadata},
-                {"IsInInstance",         lua_IsInInstance},
-                {"GetInstanceInfo",      lua_GetInstanceInfo},
-                {"GetInstanceDifficulty", lua_GetInstanceDifficulty},
-                {"strsplit",          lua_strsplit},
-                {"strtrim",           lua_strtrim},
-                {"wipe",              lua_wipe},
-                {"date",              lua_wow_date},
-                {"time",              lua_wow_time},
-                {"GetTime",           lua_wow_gettime},
-                {"IsConnectedToServer", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            lua_pushboolean(L, gh && gh->isConnected() ? 1 : 0);
-            return 1;
-        }},
-                {"GetRealmName", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) {
-                const auto* ac = gh->getActiveCharacter();
-                lua_pushstring(L, ac ? "WoWee" : "Unknown");
-            } else lua_pushstring(L, "Unknown");
-            return 1;
-        }},
-                {"GetNormalizedRealmName", [](lua_State* L) -> int {
-            lua_pushstring(L, "WoWee");
-            return 1;
-        }},
-                {"ShowHelm", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->toggleHelm(); // Toggles helm visibility
-            return 0;
-        }},
-                {"ShowCloak", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->toggleCloak();
-            return 0;
-        }},
-                {"TogglePVP", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->togglePvp();
-            return 0;
-        }},
-                {"Minimap_Ping", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            float x = static_cast<float>(luaL_optnumber(L, 1, 0));
-            float y = static_cast<float>(luaL_optnumber(L, 2, 0));
-            if (gh) gh->sendMinimapPing(x, y);
-            return 0;
-        }},
-                {"RequestTimePlayed", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->requestPlayedTime();
-            return 0;
-        }},
-                {"Logout", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->requestLogout();
-            return 0;
-        }},
-                {"CancelLogout", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->cancelLogout();
-            return 0;
-        }},
-                {"NumTaxiNodes", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            lua_pushnumber(L, gh ? gh->getTaxiNodes().size() : 0);
-            return 1;
-        }},
-                {"TaxiNodeName", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            if (!gh) { lua_pushstring(L, ""); return 1; }
-            int i = 0;
-            for (const auto& [id, node] : gh->getTaxiNodes()) {
-                if (++i == index) {
-                    lua_pushstring(L, node.name.c_str());
-                    return 1;
-                }
-            }
-            lua_pushstring(L, "");
-            return 1;
-        }},
-                {"TaxiNodeGetType", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            if (!gh) { return luaReturnZero(L); }
-            int i = 0;
-            for (const auto& [id, node] : gh->getTaxiNodes()) {
-                if (++i == index) {
-                    bool known = gh->isKnownTaxiNode(id);
-                    lua_pushnumber(L, known ? 1 : 0); // 0=none, 1=reachable, 2=current
-                    return 1;
-                }
-            }
-            lua_pushnumber(L, 0);
-            return 1;
-        }},
-                {"TakeTaxiNode", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            if (!gh) return 0;
-            int i = 0;
-            for (const auto& [id, node] : gh->getTaxiNodes()) {
-                if (++i == index) {
-                    gh->activateTaxi(id);
-                    break;
-                }
-            }
-            return 0;
-        }},
-                {"GetNetStats", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            uint32_t ms = gh ? gh->getLatencyMs() : 0;
-            lua_pushnumber(L, 0);   // bandwidthIn
-            lua_pushnumber(L, 0);   // bandwidthOut
-            lua_pushnumber(L, ms);  // latencyHome
-            lua_pushnumber(L, ms);  // latencyWorld
-            return 4;
-        }},
-                {"GetCurrentTitle", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            lua_pushnumber(L, gh ? gh->getChosenTitleBit() : -1);
-            return 1;
-        }},
-                {"GetTitleName", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int bit = static_cast<int>(luaL_checknumber(L, 1));
-            if (!gh || bit < 0) { return luaReturnNil(L); }
-            std::string title = gh->getFormattedTitle(static_cast<uint32_t>(bit));
-            if (title.empty()) { return luaReturnNil(L); }
-            lua_pushstring(L, title.c_str());
-            return 1;
-        }},
-                {"SetCurrentTitle", [](lua_State* L) -> int {
-            (void)L; // Title changes require CMSG_SET_TITLE which we don't expose yet
-            return 0;
-        }},
-                {"GetInspectSpecialization", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const auto* ir = gh ? gh->getInspectResult() : nullptr;
-            lua_pushnumber(L, ir ? ir->activeTalentGroup : 0);
-            return 1;
-        }},
-                {"NotifyInspect", [](lua_State* L) -> int {
-            (void)L; // Inspect is auto-triggered by the C++ side when targeting a player
-            return 0;
-        }},
-                {"ClearInspectPlayer", [](lua_State* L) -> int {
-            (void)L;
-            return 0;
-        }},
-                {"GetHonorCurrency", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            lua_pushnumber(L, gh ? gh->getHonorPoints() : 0);
-            return 1;
-        }},
-                {"GetArenaCurrency", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            lua_pushnumber(L, gh ? gh->getArenaPoints() : 0);
-            return 1;
-        }},
-                {"GetTimePlayed", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (!gh) { lua_pushnumber(L, 0); lua_pushnumber(L, 0); return 2; }
-            lua_pushnumber(L, gh->getTotalTimePlayed());
-            lua_pushnumber(L, gh->getLevelTimePlayed());
-            return 2;
-        }},
-                {"GetBindLocation", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (!gh) { lua_pushstring(L, "Unknown"); return 1; }
-            lua_pushstring(L, gh->getWhoAreaName(gh->getHomeBindZoneId()).c_str());
-            return 1;
-        }},
-                {"GetNumSavedInstances", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            lua_pushnumber(L, gh ? gh->getInstanceLockouts().size() : 0);
-            return 1;
-        }},
-                {"GetSavedInstanceInfo", [](lua_State* L) -> int {
-            // GetSavedInstanceInfo(index) → name, id, reset, difficulty, locked, extended, instanceIDMostSig, isRaid, maxPlayers
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            if (!gh || index < 1) { return luaReturnNil(L); }
-            const auto& lockouts = gh->getInstanceLockouts();
-            if (index > static_cast<int>(lockouts.size())) { return luaReturnNil(L); }
-            const auto& l = lockouts[index - 1];
-            lua_pushstring(L, ("Instance " + std::to_string(l.mapId)).c_str()); // name (would need MapDBC for real names)
-            lua_pushnumber(L, l.mapId);             // id
-            lua_pushnumber(L, static_cast<double>(l.resetTime - static_cast<uint64_t>(time(nullptr)))); // reset (seconds until)
-            lua_pushnumber(L, l.difficulty);        // difficulty
-            lua_pushboolean(L, l.locked ? 1 : 0);  // locked
-            lua_pushboolean(L, l.extended ? 1 : 0); // extended
-            lua_pushnumber(L, 0);                   // instanceIDMostSig
-            lua_pushboolean(L, l.difficulty >= 2 ? 1 : 0); // isRaid (25-man = raid)
-            lua_pushnumber(L, l.difficulty >= 2 ? 25 : (l.difficulty >= 1 ? 10 : 5)); // maxPlayers
-            return 9;
-        }},
-                {"CalendarGetDate", [](lua_State* L) -> int {
-            // CalendarGetDate() → weekday, month, day, year
-            time_t now = time(nullptr);
-            struct tm* t = localtime(&now);
-            lua_pushnumber(L, t->tm_wday + 1); // weekday (1=Sun)
-            lua_pushnumber(L, t->tm_mon + 1);  // month (1-12)
-            lua_pushnumber(L, t->tm_mday);     // day
-            lua_pushnumber(L, t->tm_year + 1900); // year
-            return 4;
-        }},
-                {"CalendarGetNumPendingInvites", [](lua_State* L) -> int {
-            return luaReturnZero(L);
-        }},
-                {"CalendarGetNumDayEvents", [](lua_State* L) -> int {
-            return luaReturnZero(L);
-        }},
-                {"GetDifficultyInfo", [](lua_State* L) -> int {
-            // GetDifficultyInfo(id) → name, groupType, isHeroic, maxPlayers
-            int diff = static_cast<int>(luaL_checknumber(L, 1));
-            struct DiffInfo { const char* name; const char* group; int heroic; int maxPlayers; };
-            static const DiffInfo infos[] = {
-                {"5 Player", "party", 0, 5},          // 0: Normal 5-man
-                {"5 Player (Heroic)", "party", 1, 5},  // 1: Heroic 5-man
-                {"10 Player", "raid", 0, 10},          // 2: 10-man Normal
-                {"25 Player", "raid", 0, 25},          // 3: 25-man Normal
-                {"10 Player (Heroic)", "raid", 1, 10}, // 4: 10-man Heroic
-                {"25 Player (Heroic)", "raid", 1, 25}, // 5: 25-man Heroic
-            };
-            if (diff >= 0 && diff < 6) {
-                lua_pushstring(L, infos[diff].name);
-                lua_pushstring(L, infos[diff].group);
-                lua_pushboolean(L, infos[diff].heroic);
-                lua_pushnumber(L, infos[diff].maxPlayers);
-            } else {
-                lua_pushstring(L, "Unknown");
-                lua_pushstring(L, "party");
-                lua_pushboolean(L, 0);
-                lua_pushnumber(L, 5);
-            }
-            return 4;
-        }},
-                {"GetWeatherInfo", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (!gh) { lua_pushnumber(L, 0); lua_pushnumber(L, 0); return 2; }
-            lua_pushnumber(L, gh->getWeatherType());
-            lua_pushnumber(L, gh->getWeatherIntensity());
-            return 2;
-        }},
-                {"GetMaxPlayerLevel", [](lua_State* L) -> int {
-            auto* svc = getLuaServices(L);
-            auto* reg = svc ? svc->expansionRegistry : nullptr;
-            auto* prof = reg ? reg->getActive() : nullptr;
-            if (prof && prof->id == "wotlk") lua_pushnumber(L, 80);
-            else if (prof && prof->id == "tbc") lua_pushnumber(L, 70);
-            else lua_pushnumber(L, 60);
-            return 1;
-        }},
-                {"GetAccountExpansionLevel", [](lua_State* L) -> int {
-            auto* svc = getLuaServices(L);
-            auto* reg = svc ? svc->expansionRegistry : nullptr;
-            auto* prof = reg ? reg->getActive() : nullptr;
-            if (prof && prof->id == "wotlk") lua_pushnumber(L, 3);
-            else if (prof && prof->id == "tbc") lua_pushnumber(L, 2);
-            else lua_pushnumber(L, 1);
-            return 1;
-        }},
-    };
-    for (const auto& [name, func] : api) {
-        lua_pushcfunction(L, func);
-        lua_setglobal(L, name);
-    }
-}
-
-} // namespace wowee::addons
diff --git a/src/addons/lua_unit_api.cpp b/src/addons/lua_unit_api.cpp
deleted file mode 100644
index b469069c..00000000
--- a/src/addons/lua_unit_api.cpp
+++ /dev/null
@@ -1,1514 +0,0 @@
-// lua_unit_api.cpp — Unit query, stats, party/raid, and player state Lua API bindings.
-// Extracted from lua_engine.cpp as part of §5.1 (Tame LuaEngine).
-#include "addons/lua_api_helpers.hpp"
-
-namespace wowee::addons {
-
-static int lua_UnitName(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* unit = resolveUnit(L, uid);
-    if (unit && !unit->getName().empty()) {
-        lua_pushstring(L, unit->getName().c_str());
-    } else {
-        // Fallback: party member name for out-of-range members
-        auto* gh = getGameHandler(L);
-        std::string uidStr(uid);
-        toLowerInPlace(uidStr);
-        uint64_t guid = gh ? resolveUnitGuid(gh, uidStr) : 0;
-        const auto* pm = findPartyMember(gh, guid);
-        if (pm && !pm->name.empty()) {
-            lua_pushstring(L, pm->name.c_str());
-        } else if (gh && guid != 0) {
-            // Try player name cache
-            const std::string& cached = gh->lookupName(guid);
-            lua_pushstring(L, cached.empty() ? "Unknown" : cached.c_str());
-        } else {
-            lua_pushstring(L, "Unknown");
-        }
-    }
-    return 1;
-}
-
-
-static int lua_UnitHealth(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* unit = resolveUnit(L, uid);
-    if (unit) {
-        lua_pushnumber(L, unit->getHealth());
-    } else {
-        // Fallback: party member stats for out-of-range members
-        auto* gh = getGameHandler(L);
-        std::string uidStr(uid);
-        toLowerInPlace(uidStr);
-        uint64_t guid = gh ? resolveUnitGuid(gh, uidStr) : 0;
-        const auto* pm = findPartyMember(gh, guid);
-        lua_pushnumber(L, pm ? pm->curHealth : 0);
-    }
-    return 1;
-}
-
-static int lua_UnitHealthMax(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* unit = resolveUnit(L, uid);
-    if (unit) {
-        lua_pushnumber(L, unit->getMaxHealth());
-    } else {
-        auto* gh = getGameHandler(L);
-        std::string uidStr(uid);
-        toLowerInPlace(uidStr);
-        uint64_t guid = gh ? resolveUnitGuid(gh, uidStr) : 0;
-        const auto* pm = findPartyMember(gh, guid);
-        lua_pushnumber(L, pm ? pm->maxHealth : 0);
-    }
-    return 1;
-}
-
-static int lua_UnitPower(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* unit = resolveUnit(L, uid);
-    if (unit) {
-        lua_pushnumber(L, unit->getPower());
-    } else {
-        auto* gh = getGameHandler(L);
-        std::string uidStr(uid);
-        toLowerInPlace(uidStr);
-        uint64_t guid = gh ? resolveUnitGuid(gh, uidStr) : 0;
-        const auto* pm = findPartyMember(gh, guid);
-        lua_pushnumber(L, pm ? pm->curPower : 0);
-    }
-    return 1;
-}
-
-static int lua_UnitPowerMax(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* unit = resolveUnit(L, uid);
-    if (unit) {
-        lua_pushnumber(L, unit->getMaxPower());
-    } else {
-        auto* gh = getGameHandler(L);
-        std::string uidStr(uid);
-        toLowerInPlace(uidStr);
-        uint64_t guid = gh ? resolveUnitGuid(gh, uidStr) : 0;
-        const auto* pm = findPartyMember(gh, guid);
-        lua_pushnumber(L, pm ? pm->maxPower : 0);
-    }
-    return 1;
-}
-
-static int lua_UnitLevel(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* unit = resolveUnit(L, uid);
-    if (unit) {
-        lua_pushnumber(L, unit->getLevel());
-    } else {
-        auto* gh = getGameHandler(L);
-        std::string uidStr(uid);
-        toLowerInPlace(uidStr);
-        uint64_t guid = gh ? resolveUnitGuid(gh, uidStr) : 0;
-        const auto* pm = findPartyMember(gh, guid);
-        lua_pushnumber(L, pm ? pm->level : 0);
-    }
-    return 1;
-}
-
-static int lua_UnitExists(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* unit = resolveUnit(L, uid);
-    if (unit) {
-        lua_pushboolean(L, 1);
-    } else {
-        // Party members in other zones don't have entities but still "exist"
-        auto* gh = getGameHandler(L);
-        std::string uidStr(uid);
-        toLowerInPlace(uidStr);
-        uint64_t guid = gh ? resolveUnitGuid(gh, uidStr) : 0;
-        lua_pushboolean(L, guid != 0 && findPartyMember(gh, guid) != nullptr);
-    }
-    return 1;
-}
-
-static int lua_UnitIsDead(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* unit = resolveUnit(L, uid);
-    if (unit) {
-        lua_pushboolean(L, unit->getHealth() == 0);
-    } else {
-        // Fallback: party member stats for out-of-range members
-        auto* gh = getGameHandler(L);
-        std::string uidStr(uid);
-        toLowerInPlace(uidStr);
-        uint64_t guid = gh ? resolveUnitGuid(gh, uidStr) : 0;
-        const auto* pm = findPartyMember(gh, guid);
-        lua_pushboolean(L, pm ? (pm->curHealth == 0 && pm->maxHealth > 0) : 0);
-    }
-    return 1;
-}
-
-static int lua_UnitClass(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* gh = getGameHandler(L);
-    auto* unit = resolveUnit(L, uid);
-    if (unit && gh) {
-
-        uint8_t classId = 0;
-        std::string uidStr(uid);
-        toLowerInPlace(uidStr);
-        if (uidStr == "player") {
-            classId = gh->getPlayerClass();
-        } else {
-            // Read class from UNIT_FIELD_BYTES_0 (class is byte 1)
-            uint64_t guid = resolveUnitGuid(gh, uidStr);
-            if (guid != 0) {
-                auto entity = gh->getEntityManager().getEntity(guid);
-                if (entity) {
-                    uint32_t bytes0 = entity->getField(
-                        game::fieldIndex(game::UF::UNIT_FIELD_BYTES_0));
-                    classId = static_cast<uint8_t>((bytes0 >> 8) & 0xFF);
-                }
-            }
-            // Fallback: check name query class/race cache
-            if (classId == 0 && guid != 0) {
-                classId = gh->lookupPlayerClass(guid);
-            }
-        }
-        const char* name = (classId > 0 && classId < 12) ? kLuaClasses[classId] : "Unknown";
-        lua_pushstring(L, name);
-        lua_pushstring(L, name);  // WoW returns localized + English
-        lua_pushnumber(L, classId);
-        return 3;
-    }
-    lua_pushstring(L, "Unknown");
-    lua_pushstring(L, "Unknown");
-    lua_pushnumber(L, 0);
-    return 3;
-}
-
-// UnitIsGhost(unit) — true if unit is in ghost form
-static int lua_UnitIsGhost(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    if (uidStr == "player") {
-        lua_pushboolean(L, gh->isPlayerGhost());
-    } else {
-        // Check UNIT_FIELD_FLAGS for UNIT_FLAG_GHOST (0x00000100) — best approximation
-        uint64_t guid = resolveUnitGuid(gh, uidStr);
-        bool ghost = false;
-        if (guid != 0) {
-            auto entity = gh->getEntityManager().getEntity(guid);
-            if (entity) {
-                // Ghost is PLAYER_FLAGS bit 0x10, NOT UNIT_FIELD_FLAGS bit 0x100
-                // (which is UNIT_FLAG_IMMUNE_TO_PC — would flag immune NPCs as ghosts).
-                uint32_t pf = entity->getField(game::fieldIndex(game::UF::PLAYER_FLAGS));
-                ghost = (pf & 0x00000010) != 0;
-            }
-        }
-        lua_pushboolean(L, ghost);
-    }
-    return 1;
-}
-
-// UnitIsDeadOrGhost(unit)
-static int lua_UnitIsDeadOrGhost(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* unit = resolveUnit(L, uid);
-    auto* gh = getGameHandler(L);
-    bool dead = (unit && unit->getHealth() == 0);
-    if (!dead && gh) {
-        std::string uidStr(uid);
-        toLowerInPlace(uidStr);
-        if (uidStr == "player") dead = gh->isPlayerGhost() || gh->isPlayerDead();
-    }
-    lua_pushboolean(L, dead);
-    return 1;
-}
-
-// UnitIsAFK(unit), UnitIsDND(unit)
-static int lua_UnitIsAFK(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid != 0) {
-        auto entity = gh->getEntityManager().getEntity(guid);
-        if (entity) {
-            // AFK is PLAYER_FLAGS bit 0x01, NOT UNIT_FIELD_FLAGS (where 0x01
-            // is UNIT_FLAG_SERVER_CONTROLLED — completely unrelated).
-            uint32_t playerFlags = entity->getField(game::fieldIndex(game::UF::PLAYER_FLAGS));
-            lua_pushboolean(L, (playerFlags & 0x01) != 0);
-            return 1;
-        }
-    }
-    lua_pushboolean(L, 0);
-    return 1;
-}
-
-static int lua_UnitIsDND(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid != 0) {
-        auto entity = gh->getEntityManager().getEntity(guid);
-        if (entity) {
-            // DND is PLAYER_FLAGS bit 0x02, NOT UNIT_FIELD_FLAGS.
-            uint32_t playerFlags = entity->getField(game::fieldIndex(game::UF::PLAYER_FLAGS));
-            lua_pushboolean(L, (playerFlags & 0x02) != 0);
-            return 1;
-        }
-    }
-    lua_pushboolean(L, 0);
-    return 1;
-}
-
-// UnitPlayerControlled(unit) — true for players and player-controlled pets
-static int lua_UnitPlayerControlled(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid == 0) { return luaReturnFalse(L); }
-    auto entity = gh->getEntityManager().getEntity(guid);
-    if (!entity) { return luaReturnFalse(L); }
-    // Players are always player-controlled; pets check UNIT_FLAG_PLAYER_CONTROLLED (0x01000000)
-    if (entity->getType() == game::ObjectType::PLAYER) {
-        lua_pushboolean(L, 1);
-    } else {
-        uint32_t flags = entity->getField(game::fieldIndex(game::UF::UNIT_FIELD_FLAGS));
-        lua_pushboolean(L, (flags & 0x01000000) != 0);
-    }
-    return 1;
-}
-
-// UnitIsTapped(unit) — true if mob is tapped (tagged by any player)
-static int lua_UnitIsTapped(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "target");
-    auto* unit = resolveUnit(L, uid);
-    if (!unit) { return luaReturnFalse(L); }
-    lua_pushboolean(L, (unit->getDynamicFlags() & 0x0004) != 0); // UNIT_DYNFLAG_TAPPED_BY_PLAYER
-    return 1;
-}
-
-// UnitIsTappedByPlayer(unit) — true if tapped by the local player (can loot)
-static int lua_UnitIsTappedByPlayer(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "target");
-    auto* unit = resolveUnit(L, uid);
-    if (!unit) { return luaReturnFalse(L); }
-    uint32_t df = unit->getDynamicFlags();
-    // Tapped by player: has TAPPED flag but also LOOTABLE or TAPPED_BY_ALL
-    bool tapped = (df & 0x0004) != 0;
-    bool lootable = (df & 0x0001) != 0;
-    bool sharedTag = (df & 0x0008) != 0;
-    lua_pushboolean(L, tapped && (lootable || sharedTag));
-    return 1;
-}
-
-// UnitIsTappedByAllThreatList(unit) — true if shared-tag mob
-static int lua_UnitIsTappedByAllThreatList(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "target");
-    auto* unit = resolveUnit(L, uid);
-    if (!unit) { return luaReturnFalse(L); }
-    lua_pushboolean(L, (unit->getDynamicFlags() & 0x0008) != 0);
-    return 1;
-}
-
-// UnitThreatSituation(unit, mobUnit) → 0=not tanking, 1=not tanking but threat, 2=insecurely tanking, 3=securely tanking
-static int lua_UnitThreatSituation(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnZero(L); }
-    const char* uid = luaL_optstring(L, 1, "player");
-    const char* mobUid = luaL_optstring(L, 2, nullptr);
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t playerUnitGuid = resolveUnitGuid(gh, uidStr);
-    if (playerUnitGuid == 0) { return luaReturnZero(L); }
-    // If no mob specified, check general combat threat against current target
-    uint64_t mobGuid = 0;
-    if (mobUid && *mobUid) {
-        std::string mStr(mobUid);
-        toLowerInPlace(mStr);
-        mobGuid = resolveUnitGuid(gh, mStr);
-    }
-    // Approximate threat: check if the mob is targeting this unit
-    if (mobGuid != 0) {
-        auto mobEntity = gh->getEntityManager().getEntity(mobGuid);
-        if (mobEntity) {
-            const auto& fields = mobEntity->getFields();
-            auto loIt = fields.find(game::fieldIndex(game::UF::UNIT_FIELD_TARGET_LO));
-            if (loIt != fields.end()) {
-                uint64_t mobTarget = loIt->second;
-                auto hiIt = fields.find(game::fieldIndex(game::UF::UNIT_FIELD_TARGET_HI));
-                if (hiIt != fields.end())
-                    mobTarget |= (static_cast<uint64_t>(hiIt->second) << 32);
-                if (mobTarget == playerUnitGuid) {
-                    lua_pushnumber(L, 3); // securely tanking
-                    return 1;
-                }
-            }
-        }
-    }
-    // Check if player is in combat (basic threat indicator)
-    if (playerUnitGuid == gh->getPlayerGuid() && gh->isInCombat()) {
-        lua_pushnumber(L, 1); // in combat but not tanking
-        return 1;
-    }
-    lua_pushnumber(L, 0);
-    return 1;
-}
-
-// UnitDetailedThreatSituation(unit, mobUnit) → isTanking, status, threatPct, rawThreatPct, threatValue
-static int lua_UnitDetailedThreatSituation(lua_State* L) {
-    // Use UnitThreatSituation logic for the basics
-    auto* gh = getGameHandler(L);
-    if (!gh) {
-        lua_pushboolean(L, 0); lua_pushnumber(L, 0); lua_pushnumber(L, 0); lua_pushnumber(L, 0); lua_pushnumber(L, 0);
-        return 5;
-    }
-    const char* uid = luaL_optstring(L, 1, "player");
-    const char* mobUid = luaL_optstring(L, 2, nullptr);
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t unitGuid = resolveUnitGuid(gh, uidStr);
-    bool isTanking = false;
-    int status = 0;
-    if (unitGuid != 0 && mobUid && *mobUid) {
-        std::string mStr(mobUid);
-        toLowerInPlace(mStr);
-        uint64_t mobGuid = resolveUnitGuid(gh, mStr);
-        if (mobGuid != 0) {
-            auto mobEnt = gh->getEntityManager().getEntity(mobGuid);
-            if (mobEnt) {
-                const auto& f = mobEnt->getFields();
-                auto lo = f.find(game::fieldIndex(game::UF::UNIT_FIELD_TARGET_LO));
-                if (lo != f.end()) {
-                    uint64_t mt = lo->second;
-                    auto hi = f.find(game::fieldIndex(game::UF::UNIT_FIELD_TARGET_HI));
-                    if (hi != f.end()) mt |= (static_cast<uint64_t>(hi->second) << 32);
-                    if (mt == unitGuid) { isTanking = true; status = 3; }
-                }
-            }
-        }
-    }
-    lua_pushboolean(L, isTanking);
-    lua_pushnumber(L, status);
-    lua_pushnumber(L, isTanking ? 100.0 : 0.0); // threatPct
-    lua_pushnumber(L, isTanking ? 100.0 : 0.0); // rawThreatPct
-    lua_pushnumber(L, 0); // threatValue (not available without server threat data)
-    return 5;
-}
-
-// UnitDistanceSquared(unit) → distSq, canCalculate
-static int lua_UnitDistanceSquared(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushnumber(L, 0); lua_pushboolean(L, 0); return 2; }
-    const char* uid = luaL_checkstring(L, 1);
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid == 0 || guid == gh->getPlayerGuid()) { lua_pushnumber(L, 0); lua_pushboolean(L, 0); return 2; }
-    auto targetEnt = gh->getEntityManager().getEntity(guid);
-    auto playerEnt = gh->getEntityManager().getEntity(gh->getPlayerGuid());
-    if (!targetEnt || !playerEnt) { lua_pushnumber(L, 0); lua_pushboolean(L, 0); return 2; }
-    float dx = playerEnt->getX() - targetEnt->getX();
-    float dy = playerEnt->getY() - targetEnt->getY();
-    float dz = playerEnt->getZ() - targetEnt->getZ();
-    lua_pushnumber(L, dx*dx + dy*dy + dz*dz);
-    lua_pushboolean(L, 1);
-    return 2;
-}
-
-// CheckInteractDistance(unit, distIndex) → boolean
-// distIndex: 1=inspect(28yd), 2=trade(11yd), 3=duel(10yd), 4=follow(28yd)
-static int lua_CheckInteractDistance(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    const char* uid = luaL_checkstring(L, 1);
-    int distIdx = static_cast<int>(luaL_optnumber(L, 2, 4));
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid == 0) { return luaReturnFalse(L); }
-    auto targetEnt = gh->getEntityManager().getEntity(guid);
-    auto playerEnt = gh->getEntityManager().getEntity(gh->getPlayerGuid());
-    if (!targetEnt || !playerEnt) { return luaReturnFalse(L); }
-    float dx = playerEnt->getX() - targetEnt->getX();
-    float dy = playerEnt->getY() - targetEnt->getY();
-    float dz = playerEnt->getZ() - targetEnt->getZ();
-    float dist = std::sqrt(dx*dx + dy*dy + dz*dz);
-    float maxDist = 28.0f; // default: follow/inspect range
-    switch (distIdx) {
-        case 1: maxDist = 28.0f; break; // inspect
-        case 2: maxDist = 11.11f; break; // trade
-        case 3: maxDist = 9.9f; break; // duel
-        case 4: maxDist = 28.0f; break; // follow
-    }
-    lua_pushboolean(L, dist <= maxDist);
-    return 1;
-}
-
-// UnitIsVisible(unit) → boolean (entity exists in the client's entity manager)
-static int lua_UnitIsVisible(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "target");
-    auto* unit = resolveUnit(L, uid);
-    lua_pushboolean(L, unit != nullptr);
-    return 1;
-}
-
-// UnitGroupRolesAssigned(unit) → "TANK", "HEALER", "DAMAGER", or "NONE"
-static int lua_UnitGroupRolesAssigned(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushstring(L, "NONE"); return 1; }
-    const char* uid = luaL_optstring(L, 1, "player");
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid == 0) { lua_pushstring(L, "NONE"); return 1; }
-    const auto& pd = gh->getPartyData();
-    for (const auto& m : pd.members) {
-        if (m.guid == guid) {
-            // WotLK LFG roles bitmask (from SMSG_GROUP_LIST / SMSG_LFG_ROLE_CHECK_UPDATE).
-            // Bit 0x01 = Leader (not a combat role), 0x02 = Tank, 0x04 = Healer, 0x08 = DPS.
-            constexpr uint8_t kRoleTank    = 0x02;
-            constexpr uint8_t kRoleHealer  = 0x04;
-            constexpr uint8_t kRoleDamager = 0x08;
-            if (m.roles & kRoleTank)    { lua_pushstring(L, "TANK"); return 1; }
-            if (m.roles & kRoleHealer)  { lua_pushstring(L, "HEALER"); return 1; }
-            if (m.roles & kRoleDamager) { lua_pushstring(L, "DAMAGER"); return 1; }
-            break;
-        }
-    }
-    lua_pushstring(L, "NONE");
-    return 1;
-}
-
-// UnitCanAttack(unit, otherUnit) → boolean
-static int lua_UnitCanAttack(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    const char* uid1 = luaL_checkstring(L, 1);
-    const char* uid2 = luaL_checkstring(L, 2);
-    std::string u1(uid1), u2(uid2);
-    toLowerInPlace(u1);
-    toLowerInPlace(u2);
-    uint64_t g1 = resolveUnitGuid(gh, u1);
-    uint64_t g2 = resolveUnitGuid(gh, u2);
-    if (g1 == 0 || g2 == 0 || g1 == g2) { return luaReturnFalse(L); }
-    // Check if unit2 is hostile to unit1
-    auto* unit2 = resolveUnit(L, uid2);
-    if (unit2 && unit2->isHostile()) {
-        lua_pushboolean(L, 1);
-    } else {
-        lua_pushboolean(L, 0);
-    }
-    return 1;
-}
-
-// UnitCanCooperate(unit, otherUnit) → boolean
-static int lua_UnitCanCooperate(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    (void)luaL_checkstring(L, 1); // unit1 (unused — cooperation is based on unit2's hostility)
-    const char* uid2 = luaL_checkstring(L, 2);
-    auto* unit2 = resolveUnit(L, uid2);
-    if (!unit2) { return luaReturnFalse(L); }
-    lua_pushboolean(L, !unit2->isHostile());
-    return 1;
-}
-
-// UnitCreatureFamily(unit) → familyName or nil
-static int lua_UnitCreatureFamily(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-    const char* uid = luaL_optstring(L, 1, "target");
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid == 0) { return luaReturnNil(L); }
-    auto entity = gh->getEntityManager().getEntity(guid);
-    if (!entity || entity->getType() == game::ObjectType::PLAYER) { return luaReturnNil(L); }
-    auto unit = std::dynamic_pointer_cast<game::Unit>(entity);
-    if (!unit) { return luaReturnNil(L); }
-    uint32_t family = gh->getCreatureFamily(unit->getEntry());
-    if (family == 0) { return luaReturnNil(L); }
-    static constexpr const char* kFamilies[] = {
-        "", "Wolf", "Cat", "Spider", "Bear", "Boar", "Crocolisk", "Carrion Bird",
-        "Crab", "Gorilla", "Raptor", "", "Tallstrider", "", "", "Felhunter",
-        "Voidwalker", "Succubus", "", "Doomguard", "Scorpid", "Turtle", "",
-        "Imp", "Bat", "Hyena", "Bird of Prey", "Wind Serpent", "", "Dragonhawk",
-        "Ravager", "Warp Stalker", "Sporebat", "Nether Ray", "Serpent", "Moth",
-        "Chimaera", "Devilsaur", "Ghoul", "Silithid", "Worm", "Rhino", "Wasp",
-        "Core Hound", "Spirit Beast"
-    };
-    lua_pushstring(L, (family < sizeof(kFamilies)/sizeof(kFamilies[0]) && kFamilies[family][0])
-        ? kFamilies[family] : "Beast");
-    return 1;
-}
-
-// UnitOnTaxi(unit) → boolean (true if on a flight path)
-static int lua_UnitOnTaxi(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    if (uidStr == "player") {
-        lua_pushboolean(L, gh->isOnTaxiFlight());
-    } else {
-        lua_pushboolean(L, 0); // Can't determine for other units
-    }
-    return 1;
-}
-
-// UnitSex(unit) → 1=unknown, 2=male, 3=female
-static int lua_UnitSex(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushnumber(L, 1); return 1; }
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid != 0) {
-        auto entity = gh->getEntityManager().getEntity(guid);
-        if (entity) {
-            // Gender is byte 2 of UNIT_FIELD_BYTES_0 (0=male, 1=female)
-            uint32_t bytes0 = entity->getField(game::fieldIndex(game::UF::UNIT_FIELD_BYTES_0));
-            uint8_t gender = static_cast<uint8_t>((bytes0 >> 16) & 0xFF);
-            lua_pushnumber(L, gender == 0 ? 2 : (gender == 1 ? 3 : 1)); // WoW: 2=male, 3=female
-            return 1;
-        }
-    }
-    lua_pushnumber(L, 1); // unknown
-    return 1;
-}
-
-// --- Player/Game API ---
-
-static int lua_UnitStat(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushnumber(L, 0); lua_pushnumber(L, 0); lua_pushnumber(L, 0); lua_pushnumber(L, 0); return 4; }
-    int statIdx = static_cast<int>(luaL_checknumber(L, 2)) - 1; // WoW API is 1-indexed
-    int32_t val = gh->getPlayerStat(statIdx);
-    if (val < 0) val = 0;
-    // We only have the effective value from the server; report base=effective, no buffs
-    lua_pushnumber(L, val); // base (approximate — server only sends effective)
-    lua_pushnumber(L, val); // effective
-    lua_pushnumber(L, 0);   // positive buff
-    lua_pushnumber(L, 0);   // negative buff
-    return 4;
-}
-
-// GetDodgeChance() → percent
-static int lua_GetDodgeChance(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    float v = gh ? gh->getDodgePct() : 0.0f;
-    lua_pushnumber(L, v >= 0 ? v : 0.0);
-    return 1;
-}
-
-// GetParryChance() → percent
-static int lua_GetParryChance(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    float v = gh ? gh->getParryPct() : 0.0f;
-    lua_pushnumber(L, v >= 0 ? v : 0.0);
-    return 1;
-}
-
-// GetBlockChance() → percent
-static int lua_GetBlockChance(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    float v = gh ? gh->getBlockPct() : 0.0f;
-    lua_pushnumber(L, v >= 0 ? v : 0.0);
-    return 1;
-}
-
-// GetCritChance() → percent (melee crit)
-static int lua_GetCritChance(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    float v = gh ? gh->getCritPct() : 0.0f;
-    lua_pushnumber(L, v >= 0 ? v : 0.0);
-    return 1;
-}
-
-// GetRangedCritChance() → percent
-static int lua_GetRangedCritChance(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    float v = gh ? gh->getRangedCritPct() : 0.0f;
-    lua_pushnumber(L, v >= 0 ? v : 0.0);
-    return 1;
-}
-
-// GetSpellCritChance(school) → percent  (1=Holy,2=Fire,3=Nature,4=Frost,5=Shadow,6=Arcane)
-static int lua_GetSpellCritChance(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int school = static_cast<int>(luaL_checknumber(L, 1));
-    float v = gh ? gh->getSpellCritPct(school) : 0.0f;
-    lua_pushnumber(L, v >= 0 ? v : 0.0);
-    return 1;
-}
-
-// GetCombatRating(ratingIndex) → value
-static int lua_GetCombatRating(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int cr = static_cast<int>(luaL_checknumber(L, 1));
-    int32_t v = gh ? gh->getCombatRating(cr) : 0;
-    lua_pushnumber(L, v >= 0 ? v : 0);
-    return 1;
-}
-
-// GetSpellBonusDamage(school) → value  (1-6 magic schools)
-static int lua_GetSpellBonusDamage(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnZero(L); }
-    int32_t sp = gh->getSpellPower();
-    lua_pushnumber(L, sp >= 0 ? sp : 0);
-    return 1;
-}
-
-// GetSpellBonusHealing() → value
-static int lua_GetSpellBonusHealing(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnZero(L); }
-    int32_t v = gh->getHealingPower();
-    lua_pushnumber(L, v >= 0 ? v : 0);
-    return 1;
-}
-
-// GetMeleeHaste / GetAttackPowerForStat stubs for addon compat
-static int lua_GetAttackPower(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int32_t ap = gh ? gh->getMeleeAttackPower() : 0;
-    if (ap < 0) ap = 0;
-    lua_pushnumber(L, ap);  // base
-    lua_pushnumber(L, 0);   // posBuff
-    lua_pushnumber(L, 0);   // negBuff
-    return 3;
-}
-
-static int lua_GetRangedAttackPower(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int32_t ap = gh ? gh->getRangedAttackPower() : 0;
-    if (ap < 0) ap = 0;
-    lua_pushnumber(L, ap);
-    lua_pushnumber(L, 0);
-    lua_pushnumber(L, 0);
-    return 3;
-}
-
-
-static int lua_IsInGroup(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushboolean(L, gh && gh->isInGroup());
-    return 1;
-}
-
-static int lua_IsInRaid(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushboolean(L, gh && gh->isInGroup() && gh->getPartyData().groupType == 1);
-    return 1;
-}
-
-// PlaySound(soundId) — play a WoW UI sound by ID or name
-
-static int lua_UnitRace(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushstring(L, "Unknown"); lua_pushstring(L, "Unknown"); lua_pushnumber(L, 0); return 3; }
-    std::string uid(luaL_optstring(L, 1, "player"));
-    toLowerInPlace(uid);
-
-    uint8_t raceId = 0;
-    if (uid == "player") {
-        raceId = gh->getPlayerRace();
-    } else {
-        // Read race from UNIT_FIELD_BYTES_0 (race is byte 0)
-        uint64_t guid = resolveUnitGuid(gh, uid);
-        if (guid != 0) {
-            auto entity = gh->getEntityManager().getEntity(guid);
-            if (entity) {
-                uint32_t bytes0 = entity->getField(
-                    game::fieldIndex(game::UF::UNIT_FIELD_BYTES_0));
-                raceId = static_cast<uint8_t>(bytes0 & 0xFF);
-            }
-            // Fallback: name query class/race cache
-            if (raceId == 0) raceId = gh->lookupPlayerRace(guid);
-        }
-    }
-    const char* name = (raceId > 0 && raceId < 12) ? kLuaRaces[raceId] : "Unknown";
-    lua_pushstring(L, name);      // 1: localized race
-    lua_pushstring(L, name);      // 2: English race
-    lua_pushnumber(L, raceId);    // 3: raceId (WoW returns 3 values)
-    return 3;
-}
-
-static int lua_UnitPowerType(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* unit = resolveUnit(L, uid);
-
-    if (unit) {
-        uint8_t pt = unit->getPowerType();
-        lua_pushnumber(L, pt);
-        lua_pushstring(L, (pt < 7) ? kLuaPowerNames[pt] : "MANA");
-        return 2;
-    }
-    // Fallback: party member stats for out-of-range members
-    auto* gh = getGameHandler(L);
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = gh ? resolveUnitGuid(gh, uidStr) : 0;
-    const auto* pm = findPartyMember(gh, guid);
-    if (pm) {
-        uint8_t pt = pm->powerType;
-        lua_pushnumber(L, pt);
-        lua_pushstring(L, (pt < 7) ? kLuaPowerNames[pt] : "MANA");
-        return 2;
-    }
-    lua_pushnumber(L, 0);
-    lua_pushstring(L, "MANA");
-    return 2;
-}
-
-static int lua_GetNumGroupMembers(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushnumber(L, gh ? gh->getPartyData().memberCount : 0);
-    return 1;
-}
-
-static int lua_UnitGUID(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid == 0) { return luaReturnNil(L); }
-    char buf[32];
-    snprintf(buf, sizeof(buf), "0x%016llX", (unsigned long long)guid);
-    lua_pushstring(L, buf);
-    return 1;
-}
-
-static int lua_UnitIsPlayer(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    auto entity = guid ? gh->getEntityManager().getEntity(guid) : nullptr;
-    lua_pushboolean(L, entity && entity->getType() == game::ObjectType::PLAYER);
-    return 1;
-}
-
-static int lua_InCombatLockdown(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushboolean(L, gh && gh->isInCombat());
-    return 1;
-}
-
-static int lua_IsMounted(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushboolean(L, gh && gh->isMounted());
-    return 1;
-}
-
-static int lua_IsFlying(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushboolean(L, gh && gh->isPlayerFlying());
-    return 1;
-}
-
-static int lua_IsSwimming(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushboolean(L, gh && gh->isSwimming());
-    return 1;
-}
-
-static int lua_IsResting(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushboolean(L, gh && gh->isPlayerResting());
-    return 1;
-}
-
-static int lua_IsFalling(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    // Check FALLING movement flag
-    if (!gh) { return luaReturnFalse(L); }
-    const auto& mi = gh->getMovementInfo();
-    lua_pushboolean(L, (mi.flags & 0x2000) != 0); // MOVEFLAG_FALLING = 0x2000
-    return 1;
-}
-
-static int lua_IsStealthed(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    // Check for stealth auras (aura flags bit 0x40 = is harmful, stealth is a buff)
-    // WoW detects stealth via unit flags: UNIT_FLAG_IMMUNE (0x02) or specific aura IDs
-    // Simplified: check player auras for known stealth spell IDs
-    bool stealthed = false;
-    for (const auto& a : gh->getPlayerAuras()) {
-        if (a.isEmpty() || a.spellId == 0) continue;
-        // Common stealth IDs: 1784 (Stealth), 5215 (Prowl), 66 (Invisibility)
-        if (a.spellId == 1784 || a.spellId == 5215 || a.spellId == 66 ||
-            a.spellId == 1785 || a.spellId == 1786 || a.spellId == 1787 ||
-            a.spellId == 11305 || a.spellId == 11306) {
-            stealthed = true;
-            break;
-        }
-    }
-    lua_pushboolean(L, stealthed);
-    return 1;
-}
-
-static int lua_GetUnitSpeed(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    const char* uid = luaL_optstring(L, 1, "player");
-    if (!gh || std::string(uid) != "player") {
-        lua_pushnumber(L, 0);
-        return 1;
-    }
-    lua_pushnumber(L, gh->getServerRunSpeed());
-    return 1;
-}
-
-// --- Container/Bag API ---
-// WoW bags: container 0 = backpack (16 slots), containers 1-4 = equipped bags
-
-
-static int lua_UnitXP(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnZero(L); }
-    std::string u(uid);
-    toLowerInPlace(u);
-    if (u == "player") lua_pushnumber(L, gh->getPlayerXp());
-    else lua_pushnumber(L, 0);
-    return 1;
-}
-
-static int lua_UnitXPMax(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushnumber(L, 1); return 1; }
-    std::string u(uid);
-    toLowerInPlace(u);
-    if (u == "player") {
-        uint32_t nlxp = gh->getPlayerNextLevelXp();
-        lua_pushnumber(L, nlxp > 0 ? nlxp : 1);
-    } else {
-        lua_pushnumber(L, 1);
-    }
-    return 1;
-}
-
-// GetXPExhaustion() → rested XP pool remaining (nil if none)
-static int lua_GetXPExhaustion(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-    uint32_t rested = gh->getPlayerRestedXp();
-    if (rested > 0) lua_pushnumber(L, rested);
-    else lua_pushnil(L);
-    return 1;
-}
-
-// GetRestState() → 1 = normal, 2 = rested
-static int lua_GetRestState(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushnumber(L, (gh && gh->isPlayerResting()) ? 2 : 1);
-    return 1;
-}
-
-// --- Quest Log API ---
-
-static int lua_UnitAffectingCombat(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    if (uidStr == "player") {
-        lua_pushboolean(L, gh->isInCombat());
-    } else {
-        // Check UNIT_FLAG_IN_COMBAT (0x00080000) in UNIT_FIELD_FLAGS
-        uint64_t guid = resolveUnitGuid(gh, uidStr);
-        bool inCombat = false;
-        if (guid != 0) {
-            auto entity = gh->getEntityManager().getEntity(guid);
-            if (entity) {
-                uint32_t flags = entity->getField(
-                    game::fieldIndex(game::UF::UNIT_FIELD_FLAGS));
-                inCombat = (flags & 0x00080000) != 0; // UNIT_FLAG_IN_COMBAT
-            }
-        }
-        lua_pushboolean(L, inCombat);
-    }
-    return 1;
-}
-
-static int lua_GetNumRaidMembers(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh || !gh->isInGroup()) { return luaReturnZero(L); }
-    const auto& pd = gh->getPartyData();
-    lua_pushnumber(L, (pd.groupType == 1) ? pd.memberCount : 0);
-    return 1;
-}
-
-static int lua_GetNumPartyMembers(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh || !gh->isInGroup()) { return luaReturnZero(L); }
-    const auto& pd = gh->getPartyData();
-    // In party (not raid), count excludes self
-    int count = (pd.groupType == 0) ? static_cast<int>(pd.memberCount) : 0;
-    // memberCount includes self on some servers, subtract 1 if needed
-    if (count > 0) count = std::max(0, count - 1);
-    lua_pushnumber(L, count);
-    return 1;
-}
-
-static int lua_UnitInParty(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    if (uidStr == "player") {
-        lua_pushboolean(L, gh->isInGroup());
-    } else {
-        uint64_t guid = resolveUnitGuid(gh, uidStr);
-        if (guid == 0) { return luaReturnFalse(L); }
-        const auto& pd = gh->getPartyData();
-        bool found = false;
-        for (const auto& m : pd.members) {
-            if (m.guid == guid) { found = true; break; }
-        }
-        lua_pushboolean(L, found);
-    }
-    return 1;
-}
-
-static int lua_UnitInRaid(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    const auto& pd = gh->getPartyData();
-    if (pd.groupType != 1) { return luaReturnFalse(L); }
-    if (uidStr == "player") {
-        lua_pushboolean(L, 1);
-        return 1;
-    }
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    bool found = false;
-    for (const auto& m : pd.members) {
-        if (m.guid == guid) { found = true; break; }
-    }
-    lua_pushboolean(L, found);
-    return 1;
-}
-
-// GetRaidRosterInfo(index) → name, rank, subgroup, level, class, fileName, zone, online, isDead, role, isML
-static int lua_GetRaidRosterInfo(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    int index = static_cast<int>(luaL_checknumber(L, 1));
-    if (!gh || index < 1) { return luaReturnNil(L); }
-    const auto& pd = gh->getPartyData();
-    if (index > static_cast<int>(pd.members.size())) { return luaReturnNil(L); }
-    const auto& m = pd.members[index - 1];
-    lua_pushstring(L, m.name.c_str());       // name
-    lua_pushnumber(L, m.guid == pd.leaderGuid ? 2 : (m.flags & 0x01 ? 1 : 0)); // rank (0=member, 1=assist, 2=leader)
-    lua_pushnumber(L, m.subGroup + 1);       // subgroup (1-indexed)
-    lua_pushnumber(L, m.level);              // level
-    // Class: resolve from entity if available
-    std::string className = "Unknown";
-    auto entity = gh->getEntityManager().getEntity(m.guid);
-    if (entity) {
-        uint32_t bytes0 = entity->getField(game::fieldIndex(game::UF::UNIT_FIELD_BYTES_0));
-        uint8_t classId = static_cast<uint8_t>((bytes0 >> 8) & 0xFF);
-        if (classId > 0 && classId < 12) className = kLuaClasses[classId];
-    }
-    lua_pushstring(L, className.c_str());    // class (localized)
-    lua_pushstring(L, className.c_str());    // fileName
-    lua_pushstring(L, "");                   // zone
-    lua_pushboolean(L, m.isOnline);          // online
-    lua_pushboolean(L, m.curHealth == 0);    // isDead
-    lua_pushstring(L, "NONE");               // role
-    lua_pushboolean(L, pd.looterGuid == m.guid ? 1 : 0); // isML
-    return 11;
-}
-
-// GetThreatStatusColor(statusIndex) → r, g, b
-static int lua_GetThreatStatusColor(lua_State* L) {
-    int status = static_cast<int>(luaL_optnumber(L, 1, 0));
-    switch (status) {
-        case 0: lua_pushnumber(L, 0.69f); lua_pushnumber(L, 0.69f); lua_pushnumber(L, 0.69f); break; // gray (no threat)
-        case 1: lua_pushnumber(L, 1.0f);  lua_pushnumber(L, 1.0f);  lua_pushnumber(L, 0.47f); break; // yellow (threat)
-        case 2: lua_pushnumber(L, 1.0f);  lua_pushnumber(L, 0.6f);  lua_pushnumber(L, 0.0f);  break; // orange (high threat)
-        case 3: lua_pushnumber(L, 1.0f);  lua_pushnumber(L, 0.0f);  lua_pushnumber(L, 0.0f);  break; // red (tanking)
-        default: lua_pushnumber(L, 1.0f); lua_pushnumber(L, 1.0f);  lua_pushnumber(L, 1.0f);  break;
-    }
-    return 3;
-}
-
-// GetReadyCheckStatus(unit) → status string
-static int lua_GetReadyCheckStatus(lua_State* L) {
-    (void)L;
-    lua_pushnil(L); // No ready check in progress
-    return 1;
-}
-
-// RegisterUnitWatch / UnregisterUnitWatch — secure unit frame stubs
-static int lua_RegisterUnitWatch(lua_State* L) { (void)L; return 0; }
-static int lua_UnregisterUnitWatch(lua_State* L) { (void)L; return 0; }
-
-static int lua_UnitIsUnit(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    const char* uid1 = luaL_checkstring(L, 1);
-    const char* uid2 = luaL_checkstring(L, 2);
-    std::string u1(uid1), u2(uid2);
-    toLowerInPlace(u1);
-    toLowerInPlace(u2);
-    uint64_t g1 = resolveUnitGuid(gh, u1);
-    uint64_t g2 = resolveUnitGuid(gh, u2);
-    lua_pushboolean(L, g1 != 0 && g1 == g2);
-    return 1;
-}
-
-static int lua_UnitIsFriend(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* unit = resolveUnit(L, uid);
-    lua_pushboolean(L, unit && !unit->isHostile());
-    return 1;
-}
-
-static int lua_UnitIsEnemy(lua_State* L) {
-    const char* uid = luaL_optstring(L, 1, "player");
-    auto* unit = resolveUnit(L, uid);
-    lua_pushboolean(L, unit && unit->isHostile());
-    return 1;
-}
-
-static int lua_UnitCreatureType(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushstring(L, "Unknown"); return 1; }
-    const char* uid = luaL_optstring(L, 1, "target");
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid == 0) { lua_pushstring(L, "Unknown"); return 1; }
-    auto entity = gh->getEntityManager().getEntity(guid);
-    if (!entity) { lua_pushstring(L, "Unknown"); return 1; }
-    // Player units are always "Humanoid"
-    if (entity->getType() == game::ObjectType::PLAYER) {
-        lua_pushstring(L, "Humanoid");
-        return 1;
-    }
-    auto unit = std::dynamic_pointer_cast<game::Unit>(entity);
-    if (!unit) { lua_pushstring(L, "Unknown"); return 1; }
-    uint32_t ct = gh->getCreatureType(unit->getEntry());
-    static constexpr const char* kTypes[] = {
-        "Unknown", "Beast", "Dragonkin", "Demon", "Elemental",
-        "Giant", "Undead", "Humanoid", "Critter", "Mechanical",
-        "Not specified", "Totem", "Non-combat Pet", "Gas Cloud"
-    };
-    lua_pushstring(L, (ct < 14) ? kTypes[ct] : "Unknown");
-    return 1;
-}
-
-// GetPlayerInfoByGUID(guid) → localizedClass, englishClass, localizedRace, englishRace, sex, name, realm
-static int lua_GetPlayerInfoByGUID(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    const char* guidStr = luaL_checkstring(L, 1);
-    if (!gh || !guidStr) {
-        for (int i = 0; i < 7; i++) lua_pushnil(L);
-        return 7;
-    }
-    // Parse hex GUID string "0x0000000000000001"
-    uint64_t guid = 0;
-    if (guidStr[0] == '0' && (guidStr[1] == 'x' || guidStr[1] == 'X'))
-        guid = strtoull(guidStr + 2, nullptr, 16);
-    else
-        guid = strtoull(guidStr, nullptr, 16);
-
-    if (guid == 0) { for (int i = 0; i < 7; i++) lua_pushnil(L); return 7; }
-
-    // Look up entity name
-    std::string name = gh->lookupName(guid);
-    if (name.empty() && guid == gh->getPlayerGuid()) {
-        const auto& chars = gh->getCharacters();
-        for (const auto& c : chars)
-            if (c.guid == guid) { name = c.name; break; }
-    }
-
-    // For player GUID, return class/race if it's the local player
-    const char* className = "Unknown";
-    const char* raceName = "Unknown";
-    if (guid == gh->getPlayerGuid()) {
-        uint8_t cid = gh->getPlayerClass();
-        uint8_t rid = gh->getPlayerRace();
-        if (cid < 12) className = kLuaClasses[cid];
-        if (rid < 12) raceName = kLuaRaces[rid];
-    }
-
-    lua_pushstring(L, className);  // 1: localizedClass
-    lua_pushstring(L, className);  // 2: englishClass
-    lua_pushstring(L, raceName);   // 3: localizedRace
-    lua_pushstring(L, raceName);   // 4: englishRace
-    lua_pushnumber(L, 0);          // 5: sex (0=unknown)
-    lua_pushstring(L, name.c_str()); // 6: name
-    lua_pushstring(L, "");         // 7: realm
-    return 7;
-}
-
-
-static int lua_UnitClassification(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { lua_pushstring(L, "normal"); return 1; }
-    const char* uid = luaL_optstring(L, 1, "target");
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid == 0) { lua_pushstring(L, "normal"); return 1; }
-    auto entity = gh->getEntityManager().getEntity(guid);
-    if (!entity || entity->getType() == game::ObjectType::PLAYER) {
-        lua_pushstring(L, "normal");
-        return 1;
-    }
-    auto unit = std::dynamic_pointer_cast<game::Unit>(entity);
-    if (!unit) { lua_pushstring(L, "normal"); return 1; }
-    int rank = gh->getCreatureRank(unit->getEntry());
-    switch (rank) {
-        case 1:  lua_pushstring(L, "elite"); break;
-        case 2:  lua_pushstring(L, "rareelite"); break;
-        case 3:  lua_pushstring(L, "worldboss"); break;
-        case 4:  lua_pushstring(L, "rare"); break;
-        default: lua_pushstring(L, "normal"); break;
-    }
-    return 1;
-}
-
-// GetComboPoints("player"|"vehicle", "target") → number
-static int lua_GetComboPoints(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    lua_pushnumber(L, gh ? gh->getComboPoints() : 0);
-    return 1;
-}
-
-// UnitReaction(unit, otherUnit) → 1-8 (hostile to exalted)
-// Simplified: hostile=2, neutral=4, friendly=5
-static int lua_UnitReaction(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnNil(L); }
-    const char* uid1 = luaL_checkstring(L, 1);
-    const char* uid2 = luaL_checkstring(L, 2);
-    auto* unit2 = resolveUnit(L, uid2);
-    if (!unit2) { return luaReturnNil(L); }
-    // If unit2 is the player, always friendly to self
-    std::string u1(uid1);
-    toLowerInPlace(u1);
-    std::string u2(uid2);
-    toLowerInPlace(u2);
-    uint64_t g1 = resolveUnitGuid(gh, u1);
-    uint64_t g2 = resolveUnitGuid(gh, u2);
-    if (g1 == g2) { lua_pushnumber(L, 5); return 1; } // same unit = friendly
-    if (unit2->isHostile()) {
-        lua_pushnumber(L, 2); // hostile
-    } else {
-        lua_pushnumber(L, 5); // friendly
-    }
-    return 1;
-}
-
-// UnitIsConnected(unit) → boolean
-static int lua_UnitIsConnected(lua_State* L) {
-    auto* gh = getGameHandler(L);
-    if (!gh) { return luaReturnFalse(L); }
-    const char* uid = luaL_optstring(L, 1, "player");
-    std::string uidStr(uid);
-    toLowerInPlace(uidStr);
-    uint64_t guid = resolveUnitGuid(gh, uidStr);
-    if (guid == 0) { return luaReturnFalse(L); }
-    // Player is always connected
-    if (guid == gh->getPlayerGuid()) { lua_pushboolean(L, 1); return 1; }
-    // Check party/raid member online status
-    const auto& pd = gh->getPartyData();
-    for (const auto& m : pd.members) {
-        if (m.guid == guid) {
-            lua_pushboolean(L, m.isOnline ? 1 : 0);
-            return 1;
-        }
-    }
-    // Non-party entities that exist are considered connected
-    auto entity = gh->getEntityManager().getEntity(guid);
-    lua_pushboolean(L, entity ? 1 : 0);
-    return 1;
-}
-
-// HasAction(slot) → boolean (1-indexed slot)
-
-void registerUnitLuaAPI(lua_State* L) {
-    static const struct { const char* name; lua_CFunction func; } api[] = {
-                {"UnitName",      lua_UnitName},
-                {"UnitFullName",  lua_UnitName},
-                {"GetUnitName",   lua_UnitName},
-                {"UnitHealth",    lua_UnitHealth},
-                {"UnitHealthMax", lua_UnitHealthMax},
-                {"UnitPower",     lua_UnitPower},
-                {"UnitPowerMax",  lua_UnitPowerMax},
-                {"UnitMana",      lua_UnitPower},
-                {"UnitManaMax",   lua_UnitPowerMax},
-                {"UnitRage",      lua_UnitPower},
-                {"UnitEnergy",    lua_UnitPower},
-                {"UnitFocus",     lua_UnitPower},
-                {"UnitRunicPower", lua_UnitPower},
-                {"UnitLevel",     lua_UnitLevel},
-                {"UnitExists",    lua_UnitExists},
-                {"UnitIsDead",    lua_UnitIsDead},
-                {"UnitIsGhost",   lua_UnitIsGhost},
-                {"UnitIsDeadOrGhost", lua_UnitIsDeadOrGhost},
-                {"UnitIsAFK",     lua_UnitIsAFK},
-                {"UnitIsDND",     lua_UnitIsDND},
-                {"UnitPlayerControlled", lua_UnitPlayerControlled},
-                {"UnitIsTapped",        lua_UnitIsTapped},
-                {"UnitIsTappedByPlayer", lua_UnitIsTappedByPlayer},
-                {"UnitIsTappedByAllThreatList", lua_UnitIsTappedByAllThreatList},
-                {"UnitIsVisible",       lua_UnitIsVisible},
-                {"UnitGroupRolesAssigned", lua_UnitGroupRolesAssigned},
-                {"UnitCanAttack",       lua_UnitCanAttack},
-                {"UnitCanCooperate",    lua_UnitCanCooperate},
-                {"UnitCreatureFamily",  lua_UnitCreatureFamily},
-                {"UnitOnTaxi",          lua_UnitOnTaxi},
-                {"UnitThreatSituation", lua_UnitThreatSituation},
-                {"UnitDetailedThreatSituation", lua_UnitDetailedThreatSituation},
-                {"UnitSex",       lua_UnitSex},
-                {"UnitClass",     lua_UnitClass},
-                {"UnitArmor",     [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int32_t armor = gh ? gh->getArmorRating() : 0;
-            if (armor < 0) armor = 0;
-            lua_pushnumber(L, armor); // base
-            lua_pushnumber(L, armor); // effective
-            lua_pushnumber(L, armor); // armor (again for compat)
-            lua_pushnumber(L, 0);     // posBuff
-            lua_pushnumber(L, 0);     // negBuff
-            return 5;
-        }},
-                {"UnitResistance", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int school = static_cast<int>(luaL_optnumber(L, 2, 0));
-            int32_t val = 0;
-            if (gh) {
-                if (school == 0) val = gh->getArmorRating(); // physical = armor
-                else if (school >= 1 && school <= 6) val = gh->getResistance(school);
-            }
-            if (val < 0) val = 0;
-            lua_pushnumber(L, val); // base
-            lua_pushnumber(L, val); // effective
-            lua_pushnumber(L, 0);   // posBuff
-            lua_pushnumber(L, 0);   // negBuff
-            return 4;
-        }},
-                {"UnitStat",      lua_UnitStat},
-                {"GetDodgeChance",    lua_GetDodgeChance},
-                {"GetParryChance",    lua_GetParryChance},
-                {"GetBlockChance",    lua_GetBlockChance},
-                {"GetCritChance",     lua_GetCritChance},
-                {"GetRangedCritChance", lua_GetRangedCritChance},
-                {"GetSpellCritChance",  lua_GetSpellCritChance},
-                {"GetCombatRating",     lua_GetCombatRating},
-                {"GetSpellBonusDamage", lua_GetSpellBonusDamage},
-                {"GetSpellBonusHealing", lua_GetSpellBonusHealing},
-                {"GetAttackPowerForStat", lua_GetAttackPower},
-                {"GetRangedAttackPower",  lua_GetRangedAttackPower},
-                {"IsInGroup",     lua_IsInGroup},
-                {"IsInRaid",      lua_IsInRaid},
-                {"GetShapeshiftFormInfo", [](lua_State* L) -> int {
-            // GetShapeshiftFormInfo(index) → icon, name, isActive, isCastable
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            if (!gh || index < 1) { return luaReturnNil(L); }
-            uint8_t classId = gh->getPlayerClass();
-            uint8_t currentForm = gh->getShapeshiftFormId();
-
-            // Form tables per class: {formId, spellId, name, icon}
-            struct FormInfo { uint8_t formId; const char* name; const char* icon; };
-            static const FormInfo warriorForms[] = {
-                {17, "Battle Stance", "Interface\\Icons\\Ability_Warrior_OffensiveStance"},
-                {18, "Defensive Stance", "Interface\\Icons\\Ability_Warrior_DefensiveStance"},
-                {19, "Berserker Stance", "Interface\\Icons\\Ability_Racial_Avatar"},
-            };
-            static const FormInfo druidForms[] = {
-                {1,  "Bear Form", "Interface\\Icons\\Ability_Racial_BearForm"},
-                {4,  "Travel Form", "Interface\\Icons\\Ability_Druid_TravelForm"},
-                {3,  "Cat Form", "Interface\\Icons\\Ability_Druid_CatForm"},
-                {27, "Swift Flight Form", "Interface\\Icons\\Ability_Druid_FlightForm"},
-                {31, "Moonkin Form", "Interface\\Icons\\Spell_Nature_ForceOfNature"},
-                {36, "Tree of Life", "Interface\\Icons\\Ability_Druid_TreeofLife"},
-            };
-            static const FormInfo dkForms[] = {
-                {32, "Blood Presence", "Interface\\Icons\\Spell_Deathknight_BloodPresence"},
-                {33, "Frost Presence", "Interface\\Icons\\Spell_Deathknight_FrostPresence"},
-                {34, "Unholy Presence", "Interface\\Icons\\Spell_Deathknight_UnholyPresence"},
-            };
-            static const FormInfo rogueForms[] = {
-                {30, "Stealth", "Interface\\Icons\\Ability_Stealth"},
-            };
-
-            const FormInfo* forms = nullptr;
-            int numForms = 0;
-            switch (classId) {
-                case 1: forms = warriorForms; numForms = 3; break;
-                case 6: forms = dkForms; numForms = 3; break;
-                case 4: forms = rogueForms; numForms = 1; break;
-                case 11: forms = druidForms; numForms = 6; break;
-                default: lua_pushnil(L); return 1;
-            }
-            if (index > numForms) { return luaReturnNil(L); }
-            const auto& fi = forms[index - 1];
-            lua_pushstring(L, fi.icon);                          // icon
-            lua_pushstring(L, fi.name);                          // name
-            lua_pushboolean(L, currentForm == fi.formId ? 1 : 0); // isActive
-            lua_pushboolean(L, 1);                               // isCastable
-            return 4;
-        }},
-                {"UnitIsPVP", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const char* uid = luaL_optstring(L, 1, "player");
-            if (!gh) { return luaReturnFalse(L); }
-            uint64_t guid = resolveUnitGuid(gh, std::string(uid));
-            if (guid == 0) { return luaReturnFalse(L); }
-            auto entity = gh->getEntityManager().getEntity(guid);
-            if (!entity) { return luaReturnFalse(L); }
-            // UNIT_FLAG_PVP = 0x00001000
-            uint32_t flags = entity->getField(game::fieldIndex(game::UF::UNIT_FIELD_FLAGS));
-            lua_pushboolean(L, (flags & 0x00001000) ? 1 : 0);
-            return 1;
-        }},
-                {"UnitIsPVPFreeForAll", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const char* uid = luaL_optstring(L, 1, "player");
-            if (!gh) { return luaReturnFalse(L); }
-            uint64_t guid = resolveUnitGuid(gh, std::string(uid));
-            if (guid == 0) { return luaReturnFalse(L); }
-            auto entity = gh->getEntityManager().getEntity(guid);
-            if (!entity) { return luaReturnFalse(L); }
-            // FFA PvP is PLAYER_FLAGS bit 0x80, NOT UNIT_FIELD_FLAGS bit 0x00080000
-            // (which is UNIT_FLAG_PACIFIED — would flag pacified mobs as FFA-PVP).
-            uint32_t pf = entity->getField(game::fieldIndex(game::UF::PLAYER_FLAGS));
-            lua_pushboolean(L, (pf & 0x00000080) ? 1 : 0);
-            return 1;
-        }},
-                {"GetBattlefieldStatus", [](lua_State* L) -> int {
-            lua_pushstring(L, "none");
-            lua_pushnumber(L, 0);
-            lua_pushnumber(L, 0);
-            return 3;
-        }},
-                {"GetNumBattlefieldScores", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const auto* sb = gh ? gh->getBgScoreboard() : nullptr;
-            lua_pushnumber(L, sb ? sb->players.size() : 0);
-            return 1;
-        }},
-                {"GetBattlefieldScore", [](lua_State* L) -> int {
-            // GetBattlefieldScore(index) → name, killingBlows, honorableKills, deaths, honorGained, faction, rank, race, class, classToken, damageDone, healingDone
-            auto* gh = getGameHandler(L);
-            int index = static_cast<int>(luaL_checknumber(L, 1));
-            const auto* sb = gh ? gh->getBgScoreboard() : nullptr;
-            if (!sb || index < 1 || index > static_cast<int>(sb->players.size())) {
-                return luaReturnNil(L);
-            }
-            const auto& p = sb->players[index - 1];
-            lua_pushstring(L, p.name.c_str());     // name
-            lua_pushnumber(L, p.killingBlows);      // killingBlows
-            lua_pushnumber(L, p.honorableKills);    // honorableKills
-            lua_pushnumber(L, p.deaths);            // deaths
-            lua_pushnumber(L, p.bonusHonor);        // honorGained
-            lua_pushnumber(L, p.team);              // faction (0=Horde,1=Alliance)
-            lua_pushnumber(L, 0);                   // rank
-            lua_pushstring(L, "");                  // race
-            lua_pushstring(L, "");                  // class
-            lua_pushstring(L, "WARRIOR");           // classToken
-            lua_pushnumber(L, 0);                   // damageDone
-            lua_pushnumber(L, 0);                   // healingDone
-            return 12;
-        }},
-                {"GetBattlefieldWinner", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            const auto* sb = gh ? gh->getBgScoreboard() : nullptr;
-            if (sb && sb->hasWinner) lua_pushnumber(L, sb->winner);
-            else lua_pushnil(L);
-            return 1;
-        }},
-                {"RequestBattlefieldScoreData", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            if (gh) gh->requestPvpLog();
-            return 0;
-        }},
-                {"AcceptBattlefieldPort", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            int accept = lua_toboolean(L, 2);
-            if (gh) {
-                if (accept) gh->acceptBattlefield();
-                else gh->declineBattlefield();
-            }
-            return 0;
-        }},
-                {"UnitRace",          lua_UnitRace},
-                {"UnitPowerType",     lua_UnitPowerType},
-                {"GetNumGroupMembers", lua_GetNumGroupMembers},
-                {"UnitGUID",          lua_UnitGUID},
-                {"UnitIsPlayer",      lua_UnitIsPlayer},
-                {"InCombatLockdown",  lua_InCombatLockdown},
-                {"UnitDistanceSquared", lua_UnitDistanceSquared},
-                {"CheckInteractDistance", lua_CheckInteractDistance},
-                {"IsMounted",         lua_IsMounted},
-                {"IsFlying",          lua_IsFlying},
-                {"IsSwimming",        lua_IsSwimming},
-                {"IsResting",         lua_IsResting},
-                {"IsFalling",         lua_IsFalling},
-                {"IsStealthed",       lua_IsStealthed},
-                {"GetUnitSpeed",      lua_GetUnitSpeed},
-                {"UnitAffectingCombat", lua_UnitAffectingCombat},
-                {"GetNumRaidMembers",   lua_GetNumRaidMembers},
-                {"GetNumPartyMembers",  lua_GetNumPartyMembers},
-                {"UnitInParty",         lua_UnitInParty},
-                {"UnitInRaid",          lua_UnitInRaid},
-                {"GetRaidRosterInfo",   lua_GetRaidRosterInfo},
-                {"GetThreatStatusColor", lua_GetThreatStatusColor},
-                {"GetReadyCheckStatus", lua_GetReadyCheckStatus},
-                {"RegisterUnitWatch",   lua_RegisterUnitWatch},
-                {"UnregisterUnitWatch", lua_UnregisterUnitWatch},
-                {"UnitIsUnit",          lua_UnitIsUnit},
-                {"UnitIsFriend",        lua_UnitIsFriend},
-                {"UnitIsEnemy",         lua_UnitIsEnemy},
-                {"UnitCreatureType",    lua_UnitCreatureType},
-                {"UnitClassification",  lua_UnitClassification},
-                {"UnitReaction",        lua_UnitReaction},
-                {"UnitIsConnected",     lua_UnitIsConnected},
-                {"GetComboPoints",      lua_GetComboPoints},
-                {"GetPlayerInfoByGUID",  lua_GetPlayerInfoByGUID},
-                {"UnitXP",                  lua_UnitXP},
-                {"UnitXPMax",               lua_UnitXPMax},
-                {"GetXPExhaustion",         lua_GetXPExhaustion},
-                {"GetRestState",            lua_GetRestState},
-                {"HasFocus", [](lua_State* L) -> int {
-            auto* gh = getGameHandler(L);
-            lua_pushboolean(L, gh && gh->hasFocus() ? 1 : 0);
-            return 1;
-        }},
-    };
-    for (const auto& [name, func] : api) {
-        lua_pushcfunction(L, func);
-        lua_setglobal(L, name);
-    }
-}
-
-} // namespace wowee::addons
diff --git a/src/addons/toc_parser.cpp b/src/addons/toc_parser.cpp
deleted file mode 100644
index 523a164a..00000000
--- a/src/addons/toc_parser.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-#include "addons/toc_parser.hpp"
-#include <fstream>
-#include <algorithm>
-
-namespace wowee::addons {
-
-std::string TocFile::getTitle() const {
-    auto it = directives.find("Title");
-    return (it != directives.end()) ? it->second : addonName;
-}
-
-std::string TocFile::getInterface() const {
-    auto it = directives.find("Interface");
-    return (it != directives.end()) ? it->second : "";
-}
-
-bool TocFile::isLoadOnDemand() const {
-    auto it = directives.find("LoadOnDemand");
-    return (it != directives.end()) && it->second == "1";
-}
-
-static std::vector<std::string> parseVarList(const std::string& val) {
-    std::vector<std::string> result;
-    size_t pos = 0;
-    while (pos <= val.size()) {
-        size_t comma = val.find(',', pos);
-        std::string name = (comma != std::string::npos) ? val.substr(pos, comma - pos) : val.substr(pos);
-        size_t start = name.find_first_not_of(" \t");
-        size_t end = name.find_last_not_of(" \t");
-        if (start != std::string::npos)
-            result.push_back(name.substr(start, end - start + 1));
-        if (comma == std::string::npos) break;
-        pos = comma + 1;
-    }
-    return result;
-}
-
-std::vector<std::string> TocFile::getSavedVariables() const {
-    auto it = directives.find("SavedVariables");
-    return (it != directives.end()) ? parseVarList(it->second) : std::vector<std::string>{};
-}
-
-std::vector<std::string> TocFile::getSavedVariablesPerCharacter() const {
-    auto it = directives.find("SavedVariablesPerCharacter");
-    return (it != directives.end()) ? parseVarList(it->second) : std::vector<std::string>{};
-}
-
-std::optional<TocFile> parseTocFile(const std::string& tocPath) {
-    std::ifstream f(tocPath);
-    if (!f.is_open()) return std::nullopt;
-
-    TocFile toc;
-    toc.basePath = tocPath;
-    // Strip filename to get directory
-    size_t lastSlash = tocPath.find_last_of("/\\");
-    if (lastSlash != std::string::npos) {
-        toc.basePath = tocPath.substr(0, lastSlash);
-        toc.addonName = tocPath.substr(lastSlash + 1);
-    }
-    // Strip .toc extension from addon name
-    size_t dotPos = toc.addonName.rfind(".toc");
-    if (dotPos != std::string::npos) toc.addonName.resize(dotPos);
-
-    std::string line;
-    while (std::getline(f, line)) {
-        // Strip trailing CR (Windows line endings)
-        if (!line.empty() && line.back() == '\r') line.pop_back();
-
-        // Skip empty lines
-        if (line.empty()) continue;
-
-        // ## directives
-        if (line.size() >= 3 && line[0] == '#' && line[1] == '#') {
-            std::string directive = line.substr(2);
-            size_t colon = directive.find(':');
-            if (colon != std::string::npos) {
-                std::string key = directive.substr(0, colon);
-                std::string val = directive.substr(colon + 1);
-                // Trim whitespace
-                auto trim = [](std::string& s) {
-                    size_t start = s.find_first_not_of(" \t");
-                    size_t end = s.find_last_not_of(" \t");
-                    s = (start == std::string::npos) ? "" : s.substr(start, end - start + 1);
-                };
-                trim(key);
-                trim(val);
-                if (!key.empty()) toc.directives[key] = val;
-            }
-            continue;
-        }
-
-        // Single # comment
-        if (line[0] == '#') continue;
-
-        // Whitespace-only line
-        size_t firstNonSpace = line.find_first_not_of(" \t");
-        if (firstNonSpace == std::string::npos) continue;
-
-        // File entry — normalize backslashes to forward slashes
-        std::string filename = line.substr(firstNonSpace);
-        size_t lastNonSpace = filename.find_last_not_of(" \t");
-        if (lastNonSpace != std::string::npos) filename.resize(lastNonSpace + 1);
-        std::replace(filename.begin(), filename.end(), '\\', '/');
-        toc.files.push_back(std::move(filename));
-    }
-
-    return toc;
-}
-
-} // namespace wowee::addons
diff --git a/src/audio/activity_sound_manager.cpp b/src/audio/activity_sound_manager.cpp
index 9ba6bf50..4f02b35e 100644
--- a/src/audio/activity_sound_manager.cpp
+++ b/src/audio/activity_sound_manager.cpp
@@ -52,14 +52,18 @@ bool ActivitySoundManager::initialize(pipeline::AssetManager* assets) {
     preloadLandingSet(FootstepSurface::SNOW, "Snow");
 
     preloadCandidates(meleeSwingClips, {
-        "Sound\\Item\\Weapons\\WeaponSwings\\mWooshMedium1.wav",
-        "Sound\\Item\\Weapons\\WeaponSwings\\mWooshMedium2.wav",
-        "Sound\\Item\\Weapons\\WeaponSwings\\mWooshMedium3.wav",
-        "Sound\\Item\\Weapons\\WeaponSwings\\mWooshLarge1.wav",
-        "Sound\\Item\\Weapons\\WeaponSwings\\mWooshLarge2.wav",
-        "Sound\\Item\\Weapons\\WeaponSwings\\mWooshLarge3.wav",
-        "Sound\\Item\\Weapons\\MissSwings\\MissWhoosh1Handed.wav",
-        "Sound\\Item\\Weapons\\MissSwings\\MissWhoosh2Handed.wav"
+        "Sound\\Item\\Weapons\\Sword\\SwordSwing1.wav",
+        "Sound\\Item\\Weapons\\Sword\\SwordSwing2.wav",
+        "Sound\\Item\\Weapons\\Sword\\SwordSwing3.wav",
+        "Sound\\Item\\Weapons\\Sword\\SwordHit1.wav",
+        "Sound\\Item\\Weapons\\Sword\\SwordHit2.wav",
+        "Sound\\Item\\Weapons\\Sword\\SwordHit3.wav",
+        "Sound\\Item\\Weapons\\OneHanded\\Sword\\SwordSwing1.wav",
+        "Sound\\Item\\Weapons\\OneHanded\\Sword\\SwordSwing2.wav",
+        "Sound\\Item\\Weapons\\OneHanded\\Sword\\SwordSwing3.wav",
+        "Sound\\Item\\Weapons\\Melee\\MeleeSwing1.wav",
+        "Sound\\Item\\Weapons\\Melee\\MeleeSwing2.wav",
+        "Sound\\Item\\Weapons\\Melee\\MeleeSwing3.wav"
     });
 
     initialized = true;
@@ -355,7 +359,7 @@ void ActivitySoundManager::setCharacterVoiceProfile(const std::string& modelName
     std::string base = "Human";
 
     struct RaceMap { const char* token; const char* folder; const char* base; };
-    static constexpr RaceMap races[] = {
+    static const RaceMap races[] = {
         {"human", "Human", "Human"},
         {"orc", "Orc", "Orc"},
         {"dwarf", "Dwarf", "Dwarf"},
diff --git a/src/audio/ambient_sound_manager.cpp b/src/audio/ambient_sound_manager.cpp
index a2719c32..22791fe8 100644
--- a/src/audio/ambient_sound_manager.cpp
+++ b/src/audio/ambient_sound_manager.cpp
@@ -85,7 +85,7 @@ bool AmbientSoundManager::initialize(pipeline::AssetManager* assets) {
 
     // Load bird chirp sounds (daytime periodic) — up to 6 variants
     {
-        static constexpr const char* birdPaths[] = {
+        static const char* birdPaths[] = {
             "Sound\\Ambience\\BirdAmbience\\BirdChirp01.wav",
             "Sound\\Ambience\\BirdAmbience\\BirdChirp02.wav",
             "Sound\\Ambience\\BirdAmbience\\BirdChirp03.wav",
@@ -101,7 +101,7 @@ bool AmbientSoundManager::initialize(pipeline::AssetManager* assets) {
 
     // Load cricket/insect sounds (nighttime periodic)
     {
-        static constexpr const char* cricketPaths[] = {
+        static const char* cricketPaths[] = {
             "Sound\\Ambience\\Insect\\InsectMorning.wav",
             "Sound\\Ambience\\Insect\\InsectNight.wav",
         };
@@ -921,8 +921,7 @@ void AmbientSoundManager::updateBellTolls(float deltaTime) {
                  static_cast<int>(currentCity_));
     }
 
-    // Play remaining tolls with 1.5s spacing — matches retail WoW bell cadence
-    // (long enough for each toll to ring out before the next begins)
+    // Play remaining tolls with 1.5 second delay between each
     if (remainingTolls_ > 0) {
         bellTollDelay_ += deltaTime;
 
diff --git a/src/audio/audio_coordinator.cpp b/src/audio/audio_coordinator.cpp
deleted file mode 100644
index deeb0861..00000000
--- a/src/audio/audio_coordinator.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-#include "audio/audio_coordinator.hpp"
-#include "audio/audio_engine.hpp"
-#include "audio/music_manager.hpp"
-#include "audio/footstep_manager.hpp"
-#include "audio/activity_sound_manager.hpp"
-#include "audio/mount_sound_manager.hpp"
-#include "audio/npc_voice_manager.hpp"
-#include "audio/ambient_sound_manager.hpp"
-#include "audio/ui_sound_manager.hpp"
-#include "audio/combat_sound_manager.hpp"
-#include "audio/spell_sound_manager.hpp"
-#include "audio/movement_sound_manager.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "core/logger.hpp"
-
-namespace wowee {
-namespace audio {
-
-AudioCoordinator::AudioCoordinator() = default;
-
-AudioCoordinator::~AudioCoordinator() {
-    shutdown();
-}
-
-bool AudioCoordinator::initialize() {
-    // Initialize AudioEngine (singleton)
-    if (!AudioEngine::instance().initialize()) {
-        LOG_WARNING("Failed to initialize AudioEngine - audio will be disabled");
-        audioAvailable_ = false;
-        return false;
-    }
-    audioAvailable_ = true;
-
-    // Create all audio managers (initialized later with asset manager)
-    musicManager_ = std::make_unique<MusicManager>();
-    footstepManager_ = std::make_unique<FootstepManager>();
-    activitySoundManager_ = std::make_unique<ActivitySoundManager>();
-    mountSoundManager_ = std::make_unique<MountSoundManager>();
-    npcVoiceManager_ = std::make_unique<NpcVoiceManager>();
-    ambientSoundManager_ = std::make_unique<AmbientSoundManager>();
-    uiSoundManager_ = std::make_unique<UiSoundManager>();
-    combatSoundManager_ = std::make_unique<CombatSoundManager>();
-    spellSoundManager_ = std::make_unique<SpellSoundManager>();
-    movementSoundManager_ = std::make_unique<MovementSoundManager>();
-
-    LOG_INFO("AudioCoordinator initialized with ", 10, " audio managers");
-    return true;
-}
-
-void AudioCoordinator::initializeWithAssets(pipeline::AssetManager* assetManager) {
-    if (!audioAvailable_ || !assetManager) return;
-
-    if (musicManager_) musicManager_->initialize(assetManager);
-    if (footstepManager_) footstepManager_->initialize(assetManager);
-    if (activitySoundManager_) activitySoundManager_->initialize(assetManager);
-    if (mountSoundManager_) mountSoundManager_->initialize(assetManager);
-    if (npcVoiceManager_) npcVoiceManager_->initialize(assetManager);
-    if (ambientSoundManager_) ambientSoundManager_->initialize(assetManager);
-    if (uiSoundManager_) uiSoundManager_->initialize(assetManager);
-    if (combatSoundManager_) combatSoundManager_->initialize(assetManager);
-    if (spellSoundManager_) spellSoundManager_->initialize(assetManager);
-    if (movementSoundManager_) movementSoundManager_->initialize(assetManager);
-
-    LOG_INFO("AudioCoordinator initialized with asset manager");
-}
-
-void AudioCoordinator::shutdown() {
-    // Reset all managers first (they may reference AudioEngine)
-    movementSoundManager_.reset();
-    spellSoundManager_.reset();
-    combatSoundManager_.reset();
-    uiSoundManager_.reset();
-    ambientSoundManager_.reset();
-    npcVoiceManager_.reset();
-    mountSoundManager_.reset();
-    activitySoundManager_.reset();
-    footstepManager_.reset();
-    musicManager_.reset();
-
-    // Shutdown audio engine last
-    if (audioAvailable_) {
-        AudioEngine::instance().shutdown();
-        audioAvailable_ = false;
-    }
-
-    LOG_INFO("AudioCoordinator shutdown complete");
-}
-
-} // namespace audio
-} // namespace wowee
diff --git a/src/audio/audio_engine.cpp b/src/audio/audio_engine.cpp
index c6b060e8..7fdcb952 100644
--- a/src/audio/audio_engine.cpp
+++ b/src/audio/audio_engine.cpp
@@ -8,7 +8,6 @@
 
 #include <cstring>
 #include <cstdlib>
-#include <iterator>
 #include <memory>
 #include <unordered_map>
 
@@ -99,13 +98,10 @@ static bool decodeWavCached(const std::vector<uint8_t>& wavData, DecodedWavCache
     entry.sampleRate = sampleRate;
     entry.frames = framesRead;
     entry.pcmData = pcmData;
-    // Evict oldest half when cache grows too large. 256 entries ≈ 50-100 MB of decoded
-    // PCM data depending on file lengths; halving keeps memory bounded while retaining
-    // recently-heard sounds (footsteps, UI clicks, combat hits) for instant replay.
-    constexpr size_t kMaxCachedSounds = 256;
-    if (gDecodedWavCache.size() >= kMaxCachedSounds) {
+    // Evict oldest half when cache grows too large (keeps ~128 most-recent sounds)
+    if (gDecodedWavCache.size() >= 256) {
         auto it = gDecodedWavCache.begin();
-        std::advance(it, gDecodedWavCache.size() / 2);
+        for (size_t n = gDecodedWavCache.size() / 2; n > 0; --n, ++it) {}
         gDecodedWavCache.erase(gDecodedWavCache.begin(), it);
     }
     gDecodedWavCache.emplace(key, entry);
@@ -243,9 +239,7 @@ bool AudioEngine::playSound2D(const std::vector<uint8_t>& wavData, float volume,
         decoded.pcmData->data(),
         nullptr  // No custom allocator
     );
-    // Must set explicitly — miniaudio defaults to device sample rate, which causes
-    // pitch distortion if it differs from the file's native rate (e.g. 22050 vs 44100 Hz).
-    bufferConfig.sampleRate = decoded.sampleRate;
+    bufferConfig.sampleRate = decoded.sampleRate;  // Critical: preserve original sample rate!
 
     ma_audio_buffer* audioBuffer = static_cast<ma_audio_buffer*>(std::malloc(sizeof(ma_audio_buffer)));
     if (!audioBuffer) return false;
@@ -294,77 +288,11 @@ bool AudioEngine::playSound2D(const std::vector<uint8_t>& wavData, float volume,
     }
 
     // Track this sound for cleanup (decoded PCM shared across plays)
-    activeSounds_.push_back({sound, audioBuffer, decoded.pcmData, 0u});
+    activeSounds_.push_back({sound, audioBuffer, decoded.pcmData});
 
     return true;
 }
 
-uint32_t AudioEngine::playSound2DStoppable(const std::vector<uint8_t>& wavData, float volume) {
-    if (!initialized_ || !engine_ || wavData.empty()) return 0;
-    if (masterVolume_ <= 0.0f) return 0;
-
-    DecodedWavCacheEntry decoded;
-    if (!decodeWavCached(wavData, decoded) || !decoded.pcmData || decoded.frames == 0) return 0;
-
-    ma_audio_buffer_config bufferConfig = ma_audio_buffer_config_init(
-        decoded.format, decoded.channels, decoded.frames, decoded.pcmData->data(), nullptr);
-    bufferConfig.sampleRate = decoded.sampleRate;
-
-    ma_audio_buffer* audioBuffer = static_cast<ma_audio_buffer*>(std::malloc(sizeof(ma_audio_buffer)));
-    if (!audioBuffer) return 0;
-    if (ma_audio_buffer_init(&bufferConfig, audioBuffer) != MA_SUCCESS) {
-        std::free(audioBuffer);
-        return 0;
-    }
-
-    ma_sound* sound = static_cast<ma_sound*>(std::malloc(sizeof(ma_sound)));
-    if (!sound) {
-        ma_audio_buffer_uninit(audioBuffer);
-        std::free(audioBuffer);
-        return 0;
-    }
-    ma_result result = ma_sound_init_from_data_source(
-        engine_, audioBuffer,
-        MA_SOUND_FLAG_DECODE | MA_SOUND_FLAG_ASYNC | MA_SOUND_FLAG_NO_PITCH | MA_SOUND_FLAG_NO_SPATIALIZATION,
-        nullptr, sound);
-    if (result != MA_SUCCESS) {
-        ma_audio_buffer_uninit(audioBuffer);
-        std::free(audioBuffer);
-        std::free(sound);
-        return 0;
-    }
-
-    ma_sound_set_volume(sound, volume);
-    if (ma_sound_start(sound) != MA_SUCCESS) {
-        ma_sound_uninit(sound);
-        ma_audio_buffer_uninit(audioBuffer);
-        std::free(audioBuffer);
-        std::free(sound);
-        return 0;
-    }
-
-    uint32_t id = nextSoundId_++;
-    if (nextSoundId_ == 0) nextSoundId_ = 1;  // Skip 0 (sentinel)
-    activeSounds_.push_back({sound, audioBuffer, decoded.pcmData, id});
-    return id;
-}
-
-void AudioEngine::stopSound(uint32_t id) {
-    if (id == 0) return;
-    for (auto it = activeSounds_.begin(); it != activeSounds_.end(); ++it) {
-        if (it->id == id) {
-            ma_sound_stop(it->sound);
-            ma_sound_uninit(it->sound);
-            std::free(it->sound);
-            ma_audio_buffer* buffer = static_cast<ma_audio_buffer*>(it->buffer);
-            ma_audio_buffer_uninit(buffer);
-            std::free(buffer);
-            activeSounds_.erase(it);
-            return;
-        }
-    }
-}
-
 bool AudioEngine::playSound2D(const std::string& mpqPath, float volume, float pitch) {
     if (!assetManager_) {
         LOG_WARNING("AudioEngine::playSound2D(path): no AssetManager set");
@@ -400,9 +328,7 @@ bool AudioEngine::playSound3D(const std::vector<uint8_t>& wavData, const glm::ve
         decoded.pcmData->data(),
         nullptr
     );
-    // Must set explicitly — miniaudio defaults to device sample rate, which causes
-    // pitch distortion if it differs from the file's native rate (e.g. 22050 vs 44100 Hz).
-    bufferConfig.sampleRate = decoded.sampleRate;
+    bufferConfig.sampleRate = decoded.sampleRate;  // Critical: preserve original sample rate!
 
     ma_audio_buffer* audioBuffer = static_cast<ma_audio_buffer*>(std::malloc(sizeof(ma_audio_buffer)));
     if (!audioBuffer) return false;
diff --git a/src/audio/mount_sound_manager.cpp b/src/audio/mount_sound_manager.cpp
index 92452161..0762ea26 100644
--- a/src/audio/mount_sound_manager.cpp
+++ b/src/audio/mount_sound_manager.cpp
@@ -495,7 +495,7 @@ MountType MountSoundManager::detectMountType(uint32_t creatureDisplayId) const {
 MountFamily MountSoundManager::detectMountFamilyFromPath(const std::string& modelPath) const {
     // Convert path to lowercase for matching
     std::string lower = modelPath;
-    for (char& c : lower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+    for (char& c : lower) c = std::tolower(c);
 
     // Check creature model path for family keywords
     if (lower.find("tallstrider") != std::string::npos ||
diff --git a/src/audio/npc_voice_manager.cpp b/src/audio/npc_voice_manager.cpp
index 6f6c3b67..1027d165 100644
--- a/src/audio/npc_voice_manager.cpp
+++ b/src/audio/npc_voice_manager.cpp
@@ -178,30 +178,6 @@ void NpcVoiceManager::loadVoiceSounds() {
     loadCategory(vendorLibrary_, VoiceType::UNDEAD_FEMALE, "UndeadFemaleStandardNPC", "Vendor", 2);
     loadCategory(pissedLibrary_, VoiceType::UNDEAD_FEMALE, "UndeadFemaleStandardNPC", "Pissed", 6);
 
-    // Blood Elf Male (TBC+ NPCBloodElfMaleStandard, sparse numbering up to 12)
-    loadCategory(greetingLibrary_, VoiceType::BLOODELF_MALE, "NPCBloodElfMaleStandard", "Greeting", 12);
-    loadCategory(farewellLibrary_, VoiceType::BLOODELF_MALE, "NPCBloodElfMaleStandard", "Farewell", 12);
-    loadCategory(vendorLibrary_, VoiceType::BLOODELF_MALE, "NPCBloodElfMaleStandard", "Vendor", 6);
-    loadCategory(pissedLibrary_, VoiceType::BLOODELF_MALE, "NPCBloodElfMaleStandard", "Pissed", 10);
-
-    // Blood Elf Female
-    loadCategory(greetingLibrary_, VoiceType::BLOODELF_FEMALE, "NPCBloodElfFemaleStandard", "Greeting", 12);
-    loadCategory(farewellLibrary_, VoiceType::BLOODELF_FEMALE, "NPCBloodElfFemaleStandard", "Farewell", 12);
-    loadCategory(vendorLibrary_, VoiceType::BLOODELF_FEMALE, "NPCBloodElfFemaleStandard", "Vendor", 6);
-    loadCategory(pissedLibrary_, VoiceType::BLOODELF_FEMALE, "NPCBloodElfFemaleStandard", "Pissed", 10);
-
-    // Draenei Male
-    loadCategory(greetingLibrary_, VoiceType::DRAENEI_MALE, "NPCDraeneiMaleStandard", "Greeting", 12);
-    loadCategory(farewellLibrary_, VoiceType::DRAENEI_MALE, "NPCDraeneiMaleStandard", "Farewell", 12);
-    loadCategory(vendorLibrary_, VoiceType::DRAENEI_MALE, "NPCDraeneiMaleStandard", "Vendor", 6);
-    loadCategory(pissedLibrary_, VoiceType::DRAENEI_MALE, "NPCDraeneiMaleStandard", "Pissed", 10);
-
-    // Draenei Female
-    loadCategory(greetingLibrary_, VoiceType::DRAENEI_FEMALE, "NPCDraeneiFemaleStandard", "Greeting", 12);
-    loadCategory(farewellLibrary_, VoiceType::DRAENEI_FEMALE, "NPCDraeneiFemaleStandard", "Farewell", 12);
-    loadCategory(vendorLibrary_, VoiceType::DRAENEI_FEMALE, "NPCDraeneiFemaleStandard", "Vendor", 6);
-    loadCategory(pissedLibrary_, VoiceType::DRAENEI_FEMALE, "NPCDraeneiFemaleStandard", "Pissed", 10);
-
     // Load combat sounds from Character vocal files
     // These use a different path structure: Sound\Character\{Race}\{Race}Vocal{Gender}\{Race}{Gender}{Sound}.wav
     auto loadCombatCategory = [this](
@@ -275,38 +251,6 @@ void NpcVoiceManager::loadVoiceSounds() {
 
     loadCombatCategory(aggroLibrary_, VoiceType::TROLL_FEMALE, "Troll", "TrollFemale", "AttackMyTarget", 3);
     loadCombatCategory(fleeLibrary_, VoiceType::TROLL_FEMALE, "Troll", "TrollFemale", "Flee", 2);
-
-    // Blood Elf and Draenei combat sounds (flat folder structure, no VocalMale/Female subfolder)
-    auto loadCombatFlat = [this](
-        std::unordered_map<VoiceType, std::vector<VoiceSample>>& library,
-        VoiceType type,
-        const std::string& raceFolder,
-        const std::string& raceGender,
-        const std::string& soundType,
-        int count) {
-
-        auto& samples = library[type];
-        for (int i = 1; i <= count; ++i) {
-            std::string num = (i < 10) ? ("0" + std::to_string(i)) : std::to_string(i);
-            std::string path = "Sound\\Character\\" + raceFolder + "\\" + raceGender + soundType + num + ".wav";
-            VoiceSample sample;
-            if (loadSound(path, sample)) samples.push_back(std::move(sample));
-        }
-    };
-
-    // Blood Elf combat sounds
-    loadCombatFlat(aggroLibrary_, VoiceType::BLOODELF_MALE, "BloodElf", "BloodElfMale", "AttackMyTarget", 3);
-    loadCombatFlat(fleeLibrary_, VoiceType::BLOODELF_MALE, "BloodElf", "BloodElfMale", "Flee", 3);
-
-    loadCombatFlat(aggroLibrary_, VoiceType::BLOODELF_FEMALE, "BloodElf", "BloodElfFemale", "AttackMyTarget", 3);
-    loadCombatFlat(fleeLibrary_, VoiceType::BLOODELF_FEMALE, "BloodElf", "BloodElfFemale", "Flee", 3);
-
-    // Draenei combat sounds
-    loadCombatFlat(aggroLibrary_, VoiceType::DRAENEI_MALE, "Draenei", "DraeneiMale", "AttackMyTarget", 3);
-    loadCombatFlat(fleeLibrary_, VoiceType::DRAENEI_MALE, "Draenei", "DraeneiMale", "Flee", 3);
-
-    loadCombatFlat(aggroLibrary_, VoiceType::DRAENEI_FEMALE, "Draenei", "DraeneiFemale", "AttackMyTarget", 3);
-    loadCombatFlat(fleeLibrary_, VoiceType::DRAENEI_FEMALE, "Draenei", "DraeneiFemale", "Flee", 3);
 }
 
 bool NpcVoiceManager::loadSound(const std::string& path, VoiceSample& sample) {
diff --git a/src/audio/spell_sound_manager.cpp b/src/audio/spell_sound_manager.cpp
index c72f6d7c..4c024b88 100644
--- a/src/audio/spell_sound_manager.cpp
+++ b/src/audio/spell_sound_manager.cpp
@@ -220,22 +220,12 @@ void SpellSoundManager::playPrecast(MagicSchool school, SpellPower power) {
             return;
     }
 
-    if (library && !library->empty() && (*library)[0].loaded) {
-        stopPrecast();  // Stop any previous precast still playing
-        float volume = 0.75f * volumeScale_;
-        activePrecastId_ = AudioEngine::instance().playSound2DStoppable((*library)[0].data, volume);
-    }
-}
-
-void SpellSoundManager::stopPrecast() {
-    if (activePrecastId_ != 0) {
-        AudioEngine::instance().stopSound(activePrecastId_);
-        activePrecastId_ = 0;
+    if (library) {
+        playSound(*library);
     }
 }
 
 void SpellSoundManager::playCast(MagicSchool school) {
-    stopPrecast();  // Ensure precast doesn't overlap the cast sound
     switch (school) {
         case MagicSchool::FIRE:
             playSound(castFireSounds_);
diff --git a/src/audio/ui_sound_manager.cpp b/src/audio/ui_sound_manager.cpp
index 6518259e..f32f0d9b 100644
--- a/src/audio/ui_sound_manager.cpp
+++ b/src/audio/ui_sound_manager.cpp
@@ -122,20 +122,6 @@ bool UiSoundManager::initialize(pipeline::AssetManager* assets) {
     deselectTargetSounds_.resize(1);
     loadSound("Sound\\Interface\\iDeselectTarget.wav", deselectTargetSounds_[0], assets);
 
-    // Whisper notification (falls back to iSelectTarget if the dedicated file is absent)
-    whisperSounds_.resize(1);
-    if (!loadSound("Sound\\Interface\\Whisper_TellMale.wav", whisperSounds_[0], assets)) {
-        if (!loadSound("Sound\\Interface\\Whisper_TellFemale.wav", whisperSounds_[0], assets)) {
-            whisperSounds_ = selectTargetSounds_;
-        }
-    }
-
-    // Minimap ping sound
-    minimapPingSounds_.resize(1);
-    if (!loadSound("Sound\\Interface\\MapPing.wav", minimapPingSounds_[0], assets)) {
-        minimapPingSounds_ = selectTargetSounds_;  // fallback to target select sound
-    }
-
     LOG_INFO("UISoundManager: Window sounds - Bag: ", (bagOpenLoaded && bagCloseLoaded) ? "YES" : "NO",
              ", QuestLog: ", (questLogOpenLoaded && questLogCloseLoaded) ? "YES" : "NO",
              ", CharSheet: ", (charSheetOpenLoaded && charSheetCloseLoaded) ? "YES" : "NO");
@@ -239,11 +225,5 @@ void UiSoundManager::playError() { playSound(errorSounds_); }
 void UiSoundManager::playTargetSelect() { playSound(selectTargetSounds_); }
 void UiSoundManager::playTargetDeselect() { playSound(deselectTargetSounds_); }
 
-// Chat notifications
-void UiSoundManager::playWhisperReceived() { playSound(whisperSounds_); }
-
-// Minimap ping
-void UiSoundManager::playMinimapPing() { playSound(minimapPingSounds_); }
-
 } // namespace audio
 } // namespace wowee
diff --git a/src/auth/auth_handler.cpp b/src/auth/auth_handler.cpp
index 2cb2bb48..a6ad394a 100644
--- a/src/auth/auth_handler.cpp
+++ b/src/auth/auth_handler.cpp
@@ -13,12 +13,6 @@
 namespace wowee {
 namespace auth {
 
-// WoW login security flags (CMD_AUTH_LOGON_CHALLENGE response, securityFlags byte).
-// Multiple flags can be set simultaneously; the client must satisfy all of them.
-constexpr uint8_t kSecurityFlagPin           = 0x01;  // PIN grid challenge
-constexpr uint8_t kSecurityFlagMatrixCard    = 0x02;  // Matrix card (unused by most servers)
-constexpr uint8_t kSecurityFlagAuthenticator = 0x04;  // TOTP authenticator token
-
 AuthHandler::AuthHandler() {
     LOG_DEBUG("AuthHandler created");
 }
@@ -88,7 +82,7 @@ void AuthHandler::requestRealmList() {
         return;
     }
     if (state != AuthState::AUTHENTICATED && state != AuthState::REALM_LIST_RECEIVED) {
-        LOG_ERROR("Cannot request realm list: not authenticated (state: ", static_cast<int>(state), ")");
+        LOG_ERROR("Cannot request realm list: not authenticated (state: ", (int)state, ")");
         return;
     }
 
@@ -188,11 +182,11 @@ void AuthHandler::handleLogonChallengeResponse(network::Packet& packet) {
         if (response.result == AuthResult::BUILD_INVALID || response.result == AuthResult::BUILD_UPDATE) {
             std::ostringstream ss;
             ss << "LOGON_CHALLENGE failed: version mismatch (client v"
-               << static_cast<int>(clientInfo.majorVersion) << "."
-               << static_cast<int>(clientInfo.minorVersion) << "."
-               << static_cast<int>(clientInfo.patchVersion)
+               << (int)clientInfo.majorVersion << "."
+               << (int)clientInfo.minorVersion << "."
+               << (int)clientInfo.patchVersion
                << " build " << clientInfo.build
-               << ", auth protocol " << static_cast<int>(clientInfo.protocolVersion) << ")";
+               << ", auth protocol " << (int)clientInfo.protocolVersion << ")";
             fail(ss.str());
         } else {
             fail(std::string("LOGON_CHALLENGE failed: ") + getAuthResultString(response.result));
@@ -201,21 +195,21 @@ void AuthHandler::handleLogonChallengeResponse(network::Packet& packet) {
     }
 
     if (response.securityFlags != 0) {
-        LOG_WARNING("Server sent security flags: 0x", std::hex, static_cast<int>(response.securityFlags), std::dec);
-        if (response.securityFlags & kSecurityFlagPin) LOG_WARNING("  PIN required");
-        if (response.securityFlags & kSecurityFlagMatrixCard) LOG_WARNING("  Matrix card required (not supported)");
-        if (response.securityFlags & kSecurityFlagAuthenticator) LOG_WARNING("  Authenticator required (not supported)");
+        LOG_WARNING("Server sent security flags: 0x", std::hex, (int)response.securityFlags, std::dec);
+        if (response.securityFlags & 0x01) LOG_WARNING("  PIN required");
+        if (response.securityFlags & 0x02) LOG_WARNING("  Matrix card required (not supported)");
+        if (response.securityFlags & 0x04) LOG_WARNING("  Authenticator required (not supported)");
     }
 
     LOG_INFO("Challenge: N=", response.N.size(), "B g=", response.g.size(), "B salt=",
-             response.salt.size(), "B secFlags=0x", std::hex, static_cast<int>(response.securityFlags), std::dec);
+             response.salt.size(), "B secFlags=0x", std::hex, (int)response.securityFlags, std::dec);
 
     // Feed SRP with server challenge data
     srp->feed(response.B, response.g, response.N, response.salt);
 
     securityFlags_ = response.securityFlags;
     checksumSalt_ = response.checksumSalt;
-    if (securityFlags_ & kSecurityFlagPin) {
+    if (securityFlags_ & 0x01) {
         pinGridSeed_ = response.pinGridSeed;
         pinServerSalt_ = response.pinSalt;
     }
@@ -223,8 +217,8 @@ void AuthHandler::handleLogonChallengeResponse(network::Packet& packet) {
     setState(AuthState::CHALLENGE_RECEIVED);
 
     // If a security code is required, wait for user input.
-    if (((securityFlags_ & kSecurityFlagAuthenticator) || (securityFlags_ & kSecurityFlagPin)) && pendingSecurityCode_.empty()) {
-        setState((securityFlags_ & kSecurityFlagAuthenticator) ? AuthState::AUTHENTICATOR_REQUIRED : AuthState::PIN_REQUIRED);
+    if (((securityFlags_ & 0x04) || (securityFlags_ & 0x01)) && pendingSecurityCode_.empty()) {
+        setState((securityFlags_ & 0x04) ? AuthState::AUTHENTICATOR_REQUIRED : AuthState::PIN_REQUIRED);
         return;
     }
 
@@ -244,7 +238,7 @@ void AuthHandler::sendLogonProof() {
     std::array<uint8_t, 20> crcHash{};
     const std::array<uint8_t, 20>* crcHashPtr = nullptr;
 
-    if (securityFlags_ & kSecurityFlagPin) {
+    if (securityFlags_ & 0x01) {
         try {
             PinProof proof = computePinProof(pendingSecurityCode_, pinGridSeed_, pinServerSalt_);
             pinClientSalt = proof.clientSalt;
@@ -305,7 +299,7 @@ void AuthHandler::sendLogonProof() {
         auto packet = LogonProofPacket::build(A, M1, securityFlags_, crcHashPtr, pinClientSaltPtr, pinHashPtr);
         socket->send(packet);
 
-        if (securityFlags_ & kSecurityFlagAuthenticator) {
+        if (securityFlags_ & 0x04) {
             // TrinityCore-style Google Authenticator token: send immediately after proof.
             const std::string token = pendingSecurityCode_;
             auto tokPkt = AuthenticatorTokenPacket::build(token);
@@ -395,12 +389,12 @@ void AuthHandler::handleRealmListResponse(network::Packet& packet) {
         const auto& realm = realms[i];
         LOG_INFO("Realm ", (i + 1), ": ", realm.name);
         LOG_INFO("  Address: ", realm.address);
-        LOG_INFO("  ID: ", static_cast<int>(realm.id));
+        LOG_INFO("  ID: ", (int)realm.id);
         LOG_INFO("  Population: ", realm.population);
-        LOG_INFO("  Characters: ", static_cast<int>(realm.characters));
+        LOG_INFO("  Characters: ", (int)realm.characters);
         if (realm.hasVersionInfo()) {
-            LOG_INFO("  Version: ", static_cast<int>(realm.majorVersion), ".",
-                     static_cast<int>(realm.minorVersion), ".", static_cast<int>(realm.patchVersion),
+            LOG_INFO("  Version: ", (int)realm.majorVersion, ".",
+                     (int)realm.minorVersion, ".", (int)realm.patchVersion,
                      " (build ", realm.build, ")");
         }
     }
@@ -427,9 +421,9 @@ void AuthHandler::handlePacket(network::Packet& packet) {
         const auto& raw = packet.getData();
         std::ostringstream hs;
         for (size_t i = 0; i < std::min<size_t>(raw.size(), 40); ++i)
-            hs << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>(raw[i]);
+            hs << std::hex << std::setfill('0') << std::setw(2) << (int)raw[i];
         if (raw.size() > 40) hs << "...";
-        LOG_INFO("Auth pkt 0x", std::hex, static_cast<int>(opcodeValue), std::dec,
+        LOG_INFO("Auth pkt 0x", std::hex, (int)opcodeValue, std::dec,
                  " (", raw.size(), "B): ", hs.str());
     }
 
@@ -448,11 +442,11 @@ void AuthHandler::handlePacket(network::Packet& packet) {
                     }
                     if (response.result == AuthResult::BUILD_INVALID || response.result == AuthResult::BUILD_UPDATE) {
                         ss << ": version mismatch (client v"
-                           << static_cast<int>(clientInfo.majorVersion) << "."
-                           << static_cast<int>(clientInfo.minorVersion) << "."
-                           << static_cast<int>(clientInfo.patchVersion)
+                           << (int)clientInfo.majorVersion << "."
+                           << (int)clientInfo.minorVersion << "."
+                           << (int)clientInfo.patchVersion
                            << " build " << clientInfo.build
-                           << ", auth protocol " << static_cast<int>(clientInfo.protocolVersion) << ")";
+                           << ", auth protocol " << (int)clientInfo.protocolVersion << ")";
                     } else {
                         ss << ": " << getAuthResultString(response.result)
                            << " (code 0x" << std::hex << std::setw(2) << std::setfill('0')
@@ -460,7 +454,7 @@ void AuthHandler::handlePacket(network::Packet& packet) {
                     }
                     fail(ss.str());
                 } else {
-                    LOG_WARNING("Unexpected LOGON_CHALLENGE response in state: ", static_cast<int>(state));
+                    LOG_WARNING("Unexpected LOGON_CHALLENGE response in state: ", (int)state);
                 }
             }
             break;
@@ -469,7 +463,7 @@ void AuthHandler::handlePacket(network::Packet& packet) {
             if (state == AuthState::PROOF_SENT) {
                 handleLogonProofResponse(packet);
             } else {
-                LOG_WARNING("Unexpected LOGON_PROOF response in state: ", static_cast<int>(state));
+                LOG_WARNING("Unexpected LOGON_PROOF response in state: ", (int)state);
             }
             break;
 
@@ -477,12 +471,12 @@ void AuthHandler::handlePacket(network::Packet& packet) {
             if (state == AuthState::REALM_LIST_REQUESTED) {
                 handleRealmListResponse(packet);
             } else {
-                LOG_WARNING("Unexpected REALM_LIST response in state: ", static_cast<int>(state));
+                LOG_WARNING("Unexpected REALM_LIST response in state: ", (int)state);
             }
             break;
 
         default:
-            LOG_WARNING("Unhandled auth opcode: 0x", std::hex, static_cast<int>(opcodeValue), std::dec);
+            LOG_WARNING("Unhandled auth opcode: 0x", std::hex, (int)opcodeValue, std::dec);
             break;
     }
 }
@@ -509,7 +503,7 @@ void AuthHandler::update(float /*deltaTime*/) {
 
 void AuthHandler::setState(AuthState newState) {
     if (state != newState) {
-        LOG_DEBUG("Auth state: ", static_cast<int>(state), " -> ", static_cast<int>(newState));
+        LOG_DEBUG("Auth state: ", (int)state, " -> ", (int)newState);
         state = newState;
     }
 }
diff --git a/src/auth/auth_packets.cpp b/src/auth/auth_packets.cpp
index 7ffef253..f95a5344 100644
--- a/src/auth/auth_packets.cpp
+++ b/src/auth/auth_packets.cpp
@@ -57,8 +57,7 @@ bool detectOutboundIPv4(std::array<uint8_t, 4>& outIp) {
 network::Packet LogonChallengePacket::build(const std::string& account, const ClientInfo& info) {
     // Convert account to uppercase
     std::string upperAccount = account;
-    std::transform(upperAccount.begin(), upperAccount.end(), upperAccount.begin(),
-                   [](unsigned char c) { return static_cast<char>(std::toupper(c)); });
+    std::transform(upperAccount.begin(), upperAccount.end(), upperAccount.begin(), ::toupper);
 
     // Calculate payload size (everything after cmd + error + size)
     // game(4) + version(3) + build(2) + platform(4) + os(4) + locale(4) +
@@ -208,7 +207,7 @@ bool LogonChallengeResponseParser::parse(network::Packet& packet, LogonChallenge
     LOG_DEBUG("  g size: ", response.g.size(), " bytes");
     LOG_DEBUG("  N size: ", response.N.size(), " bytes");
     LOG_DEBUG("  salt size: ", response.salt.size(), " bytes");
-    LOG_DEBUG("  Security flags: ", static_cast<int>(response.securityFlags));
+    LOG_DEBUG("  Security flags: ", (int)response.securityFlags);
     if (response.securityFlags & 0x01) {
         LOG_DEBUG("  PIN grid seed: ", response.pinGridSeed);
     }
@@ -318,10 +317,10 @@ bool LogonProofResponseParser::parse(network::Packet& packet, LogonProofResponse
     // Status
     response.status = packet.readUInt8();
 
-    LOG_INFO("LOGON_PROOF response status: ", static_cast<int>(response.status));
+    LOG_INFO("LOGON_PROOF response status: ", (int)response.status);
 
     if (response.status != 0) {
-        LOG_ERROR("LOGON_PROOF failed with status: ", static_cast<int>(response.status));
+        LOG_ERROR("LOGON_PROOF failed with status: ", (int)response.status);
         return true;  // Valid packet, but proof failed
     }
 
@@ -419,23 +418,23 @@ bool RealmListResponseParser::parse(network::Packet& packet, RealmListResponse&
             realm.patchVersion = packet.readUInt8();
             realm.build = packet.readUInt16();
 
-            LOG_DEBUG("  Realm ", static_cast<int>(i), " (", realm.name, ") version: ",
-                      static_cast<int>(realm.majorVersion), ".", static_cast<int>(realm.minorVersion), ".",
-                      static_cast<int>(realm.patchVersion), " (", realm.build, ")");
+            LOG_DEBUG("  Realm ", (int)i, " (", realm.name, ") version: ",
+                      (int)realm.majorVersion, ".", (int)realm.minorVersion, ".",
+                      (int)realm.patchVersion, " (", realm.build, ")");
         } else {
-            LOG_DEBUG("  Realm ", static_cast<int>(i), " (", realm.name, ") - no version info");
+            LOG_DEBUG("  Realm ", (int)i, " (", realm.name, ") - no version info");
         }
 
-        LOG_DEBUG("  Realm ", static_cast<int>(i), " details:");
+        LOG_DEBUG("  Realm ", (int)i, " details:");
         LOG_DEBUG("    Name: ", realm.name);
         LOG_DEBUG("    Address: ", realm.address);
-        LOG_DEBUG("    ID: ", static_cast<int>(realm.id));
-        LOG_DEBUG("    Icon: ", static_cast<int>(realm.icon));
-        LOG_DEBUG("    Lock: ", static_cast<int>(realm.lock));
-        LOG_DEBUG("    Flags: ", static_cast<int>(realm.flags));
+        LOG_DEBUG("    ID: ", (int)realm.id);
+        LOG_DEBUG("    Icon: ", (int)realm.icon);
+        LOG_DEBUG("    Lock: ", (int)realm.lock);
+        LOG_DEBUG("    Flags: ", (int)realm.flags);
         LOG_DEBUG("    Population: ", realm.population);
-        LOG_DEBUG("    Characters: ", static_cast<int>(realm.characters));
-        LOG_DEBUG("    Timezone: ", static_cast<int>(realm.timezone));
+        LOG_DEBUG("    Characters: ", (int)realm.characters);
+        LOG_DEBUG("    Timezone: ", (int)realm.timezone);
 
         response.realms.push_back(realm);
     }
diff --git a/src/auth/big_num.cpp b/src/auth/big_num.cpp
index 7e76475b..1ccaf27d 100644
--- a/src/auth/big_num.cpp
+++ b/src/auth/big_num.cpp
@@ -136,8 +136,6 @@ std::vector<uint8_t> BigNum::toArray(bool littleEndian, int minSize) const {
 
 std::string BigNum::toHex() const {
     char* hex = BN_bn2hex(bn);
-    // BN_bn2hex returns nullptr on allocation failure
-    if (!hex) return "(null)";
     std::string result(hex);
     OPENSSL_free(hex);
     return result;
@@ -145,7 +143,6 @@ std::string BigNum::toHex() const {
 
 std::string BigNum::toDecimal() const {
     char* dec = BN_bn2dec(bn);
-    if (!dec) return "(null)";
     std::string result(dec);
     OPENSSL_free(dec);
     return result;
diff --git a/src/auth/pin_auth.cpp b/src/auth/pin_auth.cpp
index 0ec47857..00293b6c 100644
--- a/src/auth/pin_auth.cpp
+++ b/src/auth/pin_auth.cpp
@@ -63,9 +63,7 @@ static std::vector<uint8_t> randomizePinDigits(const std::string& pinDigits,
         if (idx == 0xFF) {
             throw std::runtime_error("PIN digit not found in remapped grid");
         }
-        // PIN grid encodes each digit as its ASCII character ('0'..'9') for the
-        // server-side HMAC computation — this matches Blizzard's auth protocol.
-        out.push_back(static_cast<uint8_t>(idx + '0'));
+        out.push_back(static_cast<uint8_t>(idx + 0x30)); // ASCII '0'+idx
     }
 
     return out;
diff --git a/src/auth/srp.cpp b/src/auth/srp.cpp
index 99498164..48438ce3 100644
--- a/src/auth/srp.cpp
+++ b/src/auth/srp.cpp
@@ -100,7 +100,7 @@ void SRP::feed(const std::vector<uint8_t>& B_bytes,
     auto hexStr = [](const std::vector<uint8_t>& v, size_t maxBytes = 8) -> std::string {
         std::ostringstream ss;
         for (size_t i = 0; i < std::min(v.size(), maxBytes); ++i)
-            ss << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>(v[i]);
+            ss << std::hex << std::setfill('0') << std::setw(2) << (int)v[i];
         if (v.size() > maxBytes) ss << "...";
         return ss.str();
     };
@@ -117,9 +117,8 @@ std::vector<uint8_t> SRP::computeAuthHash(const std::string& username,
     // Convert to uppercase (WoW requirement)
     std::string upperUser = username;
     std::string upperPass = password;
-    auto toUpper = [](unsigned char c) { return static_cast<char>(std::toupper(c)); };
-    std::transform(upperUser.begin(), upperUser.end(), upperUser.begin(), toUpper);
-    std::transform(upperPass.begin(), upperPass.end(), upperPass.begin(), toUpper);
+    std::transform(upperUser.begin(), upperUser.end(), upperUser.begin(), ::toupper);
+    std::transform(upperPass.begin(), upperPass.end(), upperPass.begin(), ::toupper);
 
     // H(I:P)
     std::string combined = upperUser + ":" + upperPass;
@@ -129,15 +128,11 @@ std::vector<uint8_t> SRP::computeAuthHash(const std::string& username,
 void SRP::computeClientEphemeral() {
     LOG_DEBUG("Computing client ephemeral");
 
-    // Generate random private ephemeral a (19 bytes = 152 bits).
-    // WoW SRP-6a requires A != 0 mod N; in practice this almost never fails
-    // (probability ≈ 2^-152), but we retry to be safe. 100 attempts is far more
-    // than needed — if it fails, the RNG is broken.
-    static constexpr int kMaxEphemeralAttempts = 100;
-    static constexpr int kEphemeralBytes = 19; // 152 bits — matches Blizzard client
+    // Generate random private ephemeral a (19 bytes = 152 bits)
+    // Keep trying until we get a valid A
     int attempts = 0;
-    while (attempts < kMaxEphemeralAttempts) {
-        a = BigNum::fromRandom(kEphemeralBytes);
+    while (attempts < 100) {
+        a = BigNum::fromRandom(19);
 
         // A = g^a mod N
         A = g.modPow(a, N);
@@ -150,8 +145,8 @@ void SRP::computeClientEphemeral() {
         attempts++;
     }
 
-    if (attempts >= kMaxEphemeralAttempts) {
-        LOG_ERROR("Failed to generate valid client ephemeral after ", kMaxEphemeralAttempts, " attempts!");
+    if (attempts >= 100) {
+        LOG_ERROR("Failed to generate valid client ephemeral after 100 attempts!");
     }
 }
 
diff --git a/src/core/appearance_composer.cpp b/src/core/appearance_composer.cpp
deleted file mode 100644
index 9f14bd32..00000000
--- a/src/core/appearance_composer.cpp
+++ /dev/null
@@ -1,429 +0,0 @@
-#include "core/appearance_composer.hpp"
-#include "core/entity_spawner.hpp"
-#include "core/logger.hpp"
-#include "rendering/renderer.hpp"
-#include "rendering/character_renderer.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "pipeline/m2_loader.hpp"
-#include "pipeline/dbc_loader.hpp"
-#include "pipeline/dbc_layout.hpp"
-#include "game/game_handler.hpp"
-
-namespace wowee {
-namespace core {
-
-AppearanceComposer::AppearanceComposer(rendering::Renderer* renderer,
-                                       pipeline::AssetManager* assetManager,
-                                       game::GameHandler* gameHandler,
-                                       pipeline::DBCLayout* dbcLayout,
-                                       EntitySpawner* entitySpawner)
-    : renderer_(renderer)
-    , assetManager_(assetManager)
-    , gameHandler_(gameHandler)
-    , dbcLayout_(dbcLayout)
-    , entitySpawner_(entitySpawner)
-{
-}
-
-std::string AppearanceComposer::getPlayerModelPath(game::Race race, game::Gender gender) const {
-    return game::getPlayerModelPath(race, gender);
-}
-
-PlayerTextureInfo AppearanceComposer::resolvePlayerTextures(pipeline::M2Model& model,
-                                                            game::Race race, game::Gender gender,
-                                                            uint32_t appearanceBytes) {
-    PlayerTextureInfo result;
-
-    uint32_t targetRaceId = static_cast<uint32_t>(race);
-    uint32_t targetSexId = (gender == game::Gender::FEMALE) ? 1u : 0u;
-
-    // Race name for fallback texture paths
-    const char* raceFolderName = "Human";
-    switch (race) {
-        case game::Race::HUMAN:    raceFolderName = "Human"; break;
-        case game::Race::ORC:      raceFolderName = "Orc"; break;
-        case game::Race::DWARF:    raceFolderName = "Dwarf"; break;
-        case game::Race::NIGHT_ELF: raceFolderName = "NightElf"; break;
-        case game::Race::UNDEAD:    raceFolderName = "Scourge"; break;
-        case game::Race::TAUREN:    raceFolderName = "Tauren"; break;
-        case game::Race::GNOME:     raceFolderName = "Gnome"; break;
-        case game::Race::TROLL:     raceFolderName = "Troll"; break;
-        case game::Race::BLOOD_ELF: raceFolderName = "BloodElf"; break;
-        case game::Race::DRAENEI:   raceFolderName = "Draenei"; break;
-        default: break;
-    }
-    const char* genderFolder = (gender == game::Gender::FEMALE) ? "Female" : "Male";
-    std::string raceGender = std::string(raceFolderName) + genderFolder;
-    result.bodySkinPath = std::string("Character\\") + raceFolderName + "\\" + genderFolder + "\\" + raceGender + "Skin00_00.blp";
-    std::string pelvisPath = std::string("Character\\") + raceFolderName + "\\" + genderFolder + "\\" + raceGender + "NakedPelvisSkin00_00.blp";
-
-    // Extract appearance bytes for texture lookups
-    uint8_t charSkinId = appearanceBytes & 0xFF;
-    uint8_t charFaceId = (appearanceBytes >> 8) & 0xFF;
-    uint8_t charHairStyleId = (appearanceBytes >> 16) & 0xFF;
-    uint8_t charHairColorId = (appearanceBytes >> 24) & 0xFF;
-    LOG_INFO("Appearance: skin=", static_cast<int>(charSkinId), " face=", static_cast<int>(charFaceId),
-             " hairStyle=", static_cast<int>(charHairStyleId), " hairColor=", static_cast<int>(charHairColorId));
-
-    // Parse CharSections.dbc for skin/face/hair/underwear texture paths
-    auto charSectionsDbc = assetManager_->loadDBC("CharSections.dbc");
-    if (charSectionsDbc) {
-        LOG_INFO("CharSections.dbc loaded: ", charSectionsDbc->getRecordCount(), " records");
-        const auto* csL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CharSections") : nullptr;
-        auto csF = pipeline::detectCharSectionsFields(charSectionsDbc.get(), csL);
-        bool foundSkin = false;
-        bool foundUnderwear = false;
-        bool foundFaceLower = false;
-        bool foundHair = false;
-        for (uint32_t r = 0; r < charSectionsDbc->getRecordCount(); r++) {
-            uint32_t raceId = charSectionsDbc->getUInt32(r, csF.raceId);
-            uint32_t sexId = charSectionsDbc->getUInt32(r, csF.sexId);
-            uint32_t baseSection = charSectionsDbc->getUInt32(r, csF.baseSection);
-            uint32_t variationIndex = charSectionsDbc->getUInt32(r, csF.variationIndex);
-            uint32_t colorIndex = charSectionsDbc->getUInt32(r, csF.colorIndex);
-
-            if (raceId != targetRaceId || sexId != targetSexId) continue;
-
-            // Section 0 = skin: match by colorIndex = skin byte
-            if (baseSection == 0 && !foundSkin && colorIndex == charSkinId) {
-                std::string tex1 = charSectionsDbc->getString(r, csF.texture1);
-                if (!tex1.empty()) {
-                    result.bodySkinPath = tex1;
-                    foundSkin = true;
-                    LOG_INFO("  DBC body skin: ", result.bodySkinPath, " (skin=", static_cast<int>(charSkinId), ")");
-                }
-            }
-            // Section 3 = hair: match variation=hairStyle, color=hairColor
-            else if (baseSection == 3 && !foundHair &&
-                     variationIndex == charHairStyleId && colorIndex == charHairColorId) {
-                result.hairTexturePath = charSectionsDbc->getString(r, csF.texture1);
-                if (!result.hairTexturePath.empty()) {
-                    foundHair = true;
-                    LOG_INFO("  DBC hair texture: ", result.hairTexturePath,
-                             " (style=", static_cast<int>(charHairStyleId), " color=", static_cast<int>(charHairColorId), ")");
-                }
-            }
-            // Section 1 = face: match variation=faceId, colorIndex=skinId
-            // Texture1 = face lower, Texture2 = face upper
-            else if (baseSection == 1 && !foundFaceLower &&
-                     variationIndex == charFaceId && colorIndex == charSkinId) {
-                std::string tex1 = charSectionsDbc->getString(r, csF.texture1);
-                std::string tex2 = charSectionsDbc->getString(r, csF.texture2);
-                if (!tex1.empty()) {
-                    result.faceLowerPath = tex1;
-                    LOG_INFO("  DBC face lower: ", result.faceLowerPath);
-                }
-                if (!tex2.empty()) {
-                    result.faceUpperPath = tex2;
-                    LOG_INFO("  DBC face upper: ", result.faceUpperPath);
-                }
-                foundFaceLower = true;
-            }
-            // Section 4 = underwear
-            else if (baseSection == 4 && !foundUnderwear && colorIndex == charSkinId) {
-                for (uint32_t f = csF.texture1; f <= csF.texture1 + 2; f++) {
-                    std::string tex = charSectionsDbc->getString(r, f);
-                    if (!tex.empty()) {
-                        result.underwearPaths.push_back(tex);
-                        LOG_INFO("  DBC underwear texture: ", tex);
-                    }
-                }
-                foundUnderwear = true;
-            }
-
-            if (foundSkin && foundHair && foundFaceLower && foundUnderwear) break;
-        }
-
-        if (!foundHair) {
-            LOG_WARNING("No DBC hair match for style=", static_cast<int>(charHairStyleId),
-                        " color=", static_cast<int>(charHairColorId),
-                        " race=", targetRaceId, " sex=", targetSexId);
-        }
-    } else {
-        LOG_WARNING("Failed to load CharSections.dbc, using hardcoded textures");
-    }
-
-    // Fill model texture slots with resolved paths
-    for (auto& tex : model.textures) {
-        if (tex.type == 1 && tex.filename.empty()) {
-            tex.filename = result.bodySkinPath;
-        } else if (tex.type == 6) {
-            if (!result.hairTexturePath.empty()) {
-                tex.filename = result.hairTexturePath;
-            } else if (tex.filename.empty()) {
-                tex.filename = std::string("Character\\") + raceFolderName + "\\Hair00_00.blp";
-            }
-        } else if (tex.type == 8 && tex.filename.empty()) {
-            if (!result.underwearPaths.empty()) {
-                tex.filename = result.underwearPaths[0];
-            } else {
-                tex.filename = pelvisPath;
-            }
-        }
-    }
-
-    return result;
-}
-
-void AppearanceComposer::compositePlayerSkin(uint32_t modelSlotId, const PlayerTextureInfo& texInfo) {
-    if (!renderer_) return;
-    auto* charRenderer = renderer_->getCharacterRenderer();
-    if (!charRenderer) return;
-
-    // Save skin composite state for re-compositing on equipment changes
-    // Include face textures so compositeWithRegions can rebuild the full base
-    bodySkinPath_ = texInfo.bodySkinPath;
-    underwearPaths_.clear();
-    if (!texInfo.faceLowerPath.empty()) underwearPaths_.push_back(texInfo.faceLowerPath);
-    if (!texInfo.faceUpperPath.empty()) underwearPaths_.push_back(texInfo.faceUpperPath);
-    for (const auto& up : texInfo.underwearPaths) underwearPaths_.push_back(up);
-
-    // Composite body skin + face + underwear overlays
-    {
-        std::vector<std::string> layers;
-        layers.push_back(texInfo.bodySkinPath);
-        if (!texInfo.faceLowerPath.empty()) layers.push_back(texInfo.faceLowerPath);
-        if (!texInfo.faceUpperPath.empty()) layers.push_back(texInfo.faceUpperPath);
-        for (const auto& up : texInfo.underwearPaths) {
-            layers.push_back(up);
-        }
-        if (layers.size() > 1) {
-            rendering::VkTexture* compositeTex = charRenderer->compositeTextures(layers);
-            if (compositeTex != 0) {
-                // Find type-1 (skin) texture slot and replace with composite
-                // We need model texture info — walk slots via charRenderer
-                // Use the model slot ID to find the right texture index
-                auto* modelData = charRenderer->getModelData(modelSlotId);
-                if (modelData) {
-                    for (size_t ti = 0; ti < modelData->textures.size(); ti++) {
-                        if (modelData->textures[ti].type == 1) {
-                            charRenderer->setModelTexture(modelSlotId, static_cast<uint32_t>(ti), compositeTex);
-                            skinTextureSlotIndex_ = static_cast<uint32_t>(ti);
-                            LOG_INFO("Replaced type-1 texture slot ", ti, " with composited body+face+underwear");
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    // Override hair texture on GPU (type-6 slot) after model load
-    if (!texInfo.hairTexturePath.empty()) {
-        rendering::VkTexture* hairTex = charRenderer->loadTexture(texInfo.hairTexturePath);
-        if (hairTex) {
-            auto* modelData = charRenderer->getModelData(modelSlotId);
-            if (modelData) {
-                for (size_t ti = 0; ti < modelData->textures.size(); ti++) {
-                    if (modelData->textures[ti].type == 6) {
-                        charRenderer->setModelTexture(modelSlotId, static_cast<uint32_t>(ti), hairTex);
-                        LOG_INFO("Applied DBC hair texture to slot ", ti, ": ", texInfo.hairTexturePath);
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    // Find cloak (type-2, Object Skin) texture slot index
-    {
-        auto* modelData = charRenderer->getModelData(modelSlotId);
-        if (modelData) {
-            for (size_t ti = 0; ti < modelData->textures.size(); ti++) {
-                if (modelData->textures[ti].type == 2) {
-                    cloakTextureSlotIndex_ = static_cast<uint32_t>(ti);
-                    LOG_INFO("Cloak texture slot: ", ti);
-                    break;
-                }
-            }
-        }
-    }
-}
-
-std::unordered_set<uint16_t> AppearanceComposer::buildDefaultPlayerGeosets(uint8_t raceId, uint8_t sexId,
-                                                                           uint8_t hairStyleId, uint8_t facialId) {
-    std::unordered_set<uint16_t> activeGeosets;
-
-    // Look up the correct hair scalp geoset from CharHairGeosets.dbc
-    uint16_t selectedHairScalp = 1; // default
-    std::unordered_set<uint16_t> allHairScalpGeosets;
-    if (entitySpawner_) {
-        const auto& hairMap = entitySpawner_->getHairGeosetMap();
-        uint32_t hairKey = (static_cast<uint32_t>(raceId) << 16) |
-                           (static_cast<uint32_t>(sexId) << 8) |
-                           static_cast<uint32_t>(hairStyleId);
-        auto it = hairMap.find(hairKey);
-        if (it != hairMap.end() && it->second > 0)
-            selectedHairScalp = it->second;
-
-        // Collect all hair scalp geosets for this race/sex to exclude the others
-        for (const auto& [k, v] : hairMap) {
-            if (static_cast<uint8_t>((k >> 16) & 0xFF) == raceId &&
-                static_cast<uint8_t>((k >> 8) & 0xFF) == sexId &&
-                v > 0 && v < 100)
-                allHairScalpGeosets.insert(v);
-        }
-    }
-
-    // Group 0: add body base submeshes (0) but exclude other hair scalp variants
-    activeGeosets.insert(0);  // body base
-    activeGeosets.insert(selectedHairScalp);
-    // Some models have additional non-hair body submeshes (e.g. earrings, jaw);
-    // these are typically < 100 and NOT in the hair geoset set
-    for (uint16_t i = 1; i < 100; i++) {
-        if (allHairScalpGeosets.count(i) == 0)
-            activeGeosets.insert(i);  // not a hair geoset, safe to include
-    }
-
-    // Hair connector: group 1 = 100 + geoset
-    activeGeosets.insert(static_cast<uint16_t>(100 + std::max<uint16_t>(selectedHairScalp, 1)));
-
-    // Facial hair geosets from CharacterFacialHairStyles.dbc
-    if (entitySpawner_) {
-        const auto& facialMap = entitySpawner_->getFacialHairGeosetMap();
-        uint32_t facialKey = (static_cast<uint32_t>(raceId) << 16) |
-                             (static_cast<uint32_t>(sexId) << 8) |
-                             static_cast<uint32_t>(facialId);
-        auto it = facialMap.find(facialKey);
-        if (it != facialMap.end()) {
-            activeGeosets.insert(static_cast<uint16_t>(200 + std::max<uint16_t>(it->second.geoset200, 1)));
-            activeGeosets.insert(static_cast<uint16_t>(300 + std::max<uint16_t>(it->second.geoset300, 1)));
-        } else {
-            activeGeosets.insert(201);
-            activeGeosets.insert(301);
-        }
-    } else {
-        activeGeosets.insert(201);
-        activeGeosets.insert(301);
-    }
-
-    activeGeosets.insert(kGeosetBareForearms);
-    activeGeosets.insert(kGeosetBareShins);
-    activeGeosets.insert(kGeosetDefaultEars);
-    activeGeosets.insert(kGeosetBareSleeves);
-    activeGeosets.insert(kGeosetDefaultKneepads);
-    activeGeosets.insert(kGeosetBarePants);
-    activeGeosets.insert(kGeosetWithCape);
-    activeGeosets.insert(kGeosetBareFeet);
-    return activeGeosets;
-}
-
-bool AppearanceComposer::loadWeaponM2(const std::string& m2Path, pipeline::M2Model& outModel) {
-    auto m2Data = assetManager_->readFile(m2Path);
-    if (m2Data.empty()) return false;
-    outModel = pipeline::M2Loader::load(m2Data);
-    // Load skin (WotLK+ M2 format): strip .m2, append 00.skin
-    std::string skinPath = m2Path;
-    size_t dotPos = skinPath.rfind('.');
-    if (dotPos != std::string::npos) skinPath = skinPath.substr(0, dotPos);
-    skinPath += "00.skin";
-    auto skinData = assetManager_->readFile(skinPath);
-    if (!skinData.empty() && outModel.version >= 264)
-        pipeline::M2Loader::loadSkin(skinData, outModel);
-    return outModel.isValid();
-}
-
-void AppearanceComposer::loadEquippedWeapons() {
-    if (!renderer_ || !renderer_->getCharacterRenderer() || !assetManager_ || !assetManager_->isInitialized())
-        return;
-    if (!gameHandler_) return;
-
-    auto* charRenderer = renderer_->getCharacterRenderer();
-    uint32_t charInstanceId = renderer_->getCharacterInstanceId();
-    if (charInstanceId == 0) return;
-
-    auto& inventory = gameHandler_->getInventory();
-
-    // Load ItemDisplayInfo.dbc
-    auto displayInfoDbc = assetManager_->loadDBC("ItemDisplayInfo.dbc");
-    if (!displayInfoDbc) {
-        LOG_WARNING("loadEquippedWeapons: failed to load ItemDisplayInfo.dbc");
-        return;
-    }
-    // Mapping: EquipSlot → attachment ID (1=RightHand, 2=LeftHand)
-    struct WeaponSlot {
-        game::EquipSlot slot;
-        uint32_t attachmentId;
-    };
-    WeaponSlot weaponSlots[] = {
-        { game::EquipSlot::MAIN_HAND, 1 },
-        { game::EquipSlot::OFF_HAND,  2 },
-    };
-
-    if (weaponsSheathed_) {
-        for (const auto& ws : weaponSlots) {
-            charRenderer->detachWeapon(charInstanceId, ws.attachmentId);
-        }
-        return;
-    }
-
-    for (const auto& ws : weaponSlots) {
-        const auto& equipSlot = inventory.getEquipSlot(ws.slot);
-
-        // If slot is empty or has no displayInfoId, detach any existing weapon
-        if (equipSlot.empty() || equipSlot.item.displayInfoId == 0) {
-            charRenderer->detachWeapon(charInstanceId, ws.attachmentId);
-            continue;
-        }
-
-        uint32_t displayInfoId = equipSlot.item.displayInfoId;
-        int32_t recIdx = displayInfoDbc->findRecordById(displayInfoId);
-        if (recIdx < 0) {
-            LOG_WARNING("loadEquippedWeapons: displayInfoId ", displayInfoId, " not found in DBC");
-            charRenderer->detachWeapon(charInstanceId, ws.attachmentId);
-            continue;
-        }
-
-        const auto* idiL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
-        std::string modelName = displayInfoDbc->getString(static_cast<uint32_t>(recIdx), idiL ? (*idiL)["LeftModel"] : 1);
-        std::string textureName = displayInfoDbc->getString(static_cast<uint32_t>(recIdx), idiL ? (*idiL)["LeftModelTexture"] : 3);
-
-        if (modelName.empty()) {
-            LOG_WARNING("loadEquippedWeapons: empty model name for displayInfoId ", displayInfoId);
-            charRenderer->detachWeapon(charInstanceId, ws.attachmentId);
-            continue;
-        }
-
-        // Convert .mdx → .m2
-        std::string modelFile = modelName;
-        {
-            size_t dotPos = modelFile.rfind('.');
-            if (dotPos != std::string::npos) {
-                modelFile = modelFile.substr(0, dotPos) + ".m2";
-            } else {
-                modelFile += ".m2";
-            }
-        }
-
-        // Try Weapon directory first, then Shield
-        std::string m2Path = "Item\\ObjectComponents\\Weapon\\" + modelFile;
-        pipeline::M2Model weaponModel;
-        if (!loadWeaponM2(m2Path, weaponModel)) {
-            m2Path = "Item\\ObjectComponents\\Shield\\" + modelFile;
-            if (!loadWeaponM2(m2Path, weaponModel)) {
-                LOG_WARNING("loadEquippedWeapons: failed to load ", modelFile);
-                charRenderer->detachWeapon(charInstanceId, ws.attachmentId);
-                continue;
-            }
-        }
-
-        // Build texture path
-        std::string texturePath;
-        if (!textureName.empty()) {
-            texturePath = "Item\\ObjectComponents\\Weapon\\" + textureName + ".blp";
-            if (!assetManager_->fileExists(texturePath)) {
-                texturePath = "Item\\ObjectComponents\\Shield\\" + textureName + ".blp";
-            }
-        }
-
-        uint32_t weaponModelId = entitySpawner_->allocateWeaponModelId();
-        bool ok = charRenderer->attachWeapon(charInstanceId, ws.attachmentId,
-                                              weaponModel, weaponModelId, texturePath);
-        if (ok) {
-            LOG_INFO("Equipped weapon: ", m2Path, " at attachment ", ws.attachmentId);
-        }
-    }
-}
-
-} // namespace core
-} // namespace wowee
diff --git a/src/core/application.cpp b/src/core/application.cpp
index e9f26e41..be239cfc 100644
--- a/src/core/application.cpp
+++ b/src/core/application.cpp
@@ -1,8 +1,5 @@
 #include "core/application.hpp"
 #include "core/coordinates.hpp"
-#include "core/profiler.hpp"
-#include "rendering/animation/animation_ids.hpp"
-#include "rendering/animation_controller.hpp"
 #include <unordered_set>
 #include <cmath>
 #include <chrono>
@@ -34,15 +31,12 @@
 #include "audio/footstep_manager.hpp"
 #include "audio/activity_sound_manager.hpp"
 #include "audio/audio_engine.hpp"
-#include "audio/audio_coordinator.hpp"
-#include "addons/addon_manager.hpp"
 #include <imgui.h>
 #include "pipeline/m2_loader.hpp"
 #include "pipeline/wmo_loader.hpp"
 #include "pipeline/wdt_loader.hpp"
 #include "pipeline/dbc_loader.hpp"
 #include "ui/ui_manager.hpp"
-#include "ui/ui_services.hpp"
 #include "auth/auth_handler.hpp"
 #include "game/game_handler.hpp"
 #include "game/transport_manager.hpp"
@@ -53,6 +47,7 @@
 #include "pipeline/dbc_layout.hpp"
 
 #include <SDL2/SDL.h>
+// GL/glew.h removed — Vulkan migration Phase 1
 #include <cstdlib>
 #include <climits>
 #include <algorithm>
@@ -88,9 +83,107 @@ bool envFlagEnabled(const char* key, bool defaultValue = false) {
     return !(raw[0] == '0' || raw[0] == 'f' || raw[0] == 'F' ||
              raw[0] == 'n' || raw[0] == 'N');
 }
-
 } // namespace
 
+
+const char* Application::mapIdToName(uint32_t mapId) {
+    // Fallback when Map.dbc is unavailable. Names must match WDT directory names
+    // (case-insensitive — AssetManager lowercases all paths).
+    switch (mapId) {
+        // Continents
+        case 0: return "Azeroth";
+        case 1: return "Kalimdor";
+        case 530: return "Expansion01";
+        case 571: return "Northrend";
+        // Classic dungeons/raids
+        case 30: return "PVPZone01";
+        case 33: return "Shadowfang";
+        case 34: return "StormwindJail";
+        case 36: return "DeadminesInstance";
+        case 43: return "WailingCaverns";
+        case 47: return "RazserfenKraulInstance";
+        case 48: return "Blackfathom";
+        case 70: return "Uldaman";
+        case 90: return "GnomeragonInstance";
+        case 109: return "SunkenTemple";
+        case 129: return "RazorfenDowns";
+        case 189: return "MonasteryInstances";
+        case 209: return "TanarisInstance";
+        case 229: return "BlackRockSpire";
+        case 230: return "BlackrockDepths";
+        case 249: return "OnyxiaLairInstance";
+        case 289: return "ScholomanceInstance";
+        case 309: return "Zul'Gurub";
+        case 329: return "Stratholme";
+        case 349: return "Mauradon";
+        case 369: return "DeeprunTram";
+        case 389: return "OrgrimmarInstance";
+        case 409: return "MoltenCore";
+        case 429: return "DireMaul";
+        case 469: return "BlackwingLair";
+        case 489: return "PVPZone03";
+        case 509: return "AhnQiraj";
+        case 529: return "PVPZone04";
+        case 531: return "AhnQirajTemple";
+        case 533: return "Stratholme Raid";
+        // TBC
+        case 532: return "Karazahn";
+        case 534: return "HyjalPast";
+        case 540: return "HellfireMilitary";
+        case 542: return "HellfireDemon";
+        case 543: return "HellfireRampart";
+        case 544: return "HellfireRaid";
+        case 545: return "CoilfangPumping";
+        case 546: return "CoilfangMarsh";
+        case 547: return "CoilfangDraenei";
+        case 548: return "CoilfangRaid";
+        case 550: return "TempestKeepRaid";
+        case 552: return "TempestKeepArcane";
+        case 553: return "TempestKeepAtrium";
+        case 554: return "TempestKeepFactory";
+        case 555: return "AuchindounShadow";
+        case 556: return "AuchindounDraenei";
+        case 557: return "AuchindounEthereal";
+        case 558: return "AuchindounDemon";
+        case 560: return "HillsbradPast";
+        case 564: return "BlackTemple";
+        case 565: return "GruulsLair";
+        case 566: return "PVPZone05";
+        case 568: return "ZulAman";
+        case 580: return "SunwellPlateau";
+        case 585: return "Sunwell5ManFix";
+        // WotLK
+        case 574: return "Valgarde70";
+        case 575: return "UtgardePinnacle";
+        case 576: return "Nexus70";
+        case 578: return "Nexus80";
+        case 595: return "StratholmeCOT";
+        case 599: return "Ulduar70";
+        case 600: return "Ulduar80";
+        case 601: return "DrakTheronKeep";
+        case 602: return "GunDrak";
+        case 603: return "UlduarRaid";
+        case 608: return "DalaranPrison";
+        case 615: return "ChamberOfAspectsBlack";
+        case 617: return "DeathKnightStart";
+        case 619: return "Azjol_Uppercity";
+        case 624: return "WintergraspRaid";
+        case 631: return "IcecrownCitadel";
+        case 632: return "IcecrownCitadel5Man";
+        case 649: return "ArgentTournamentRaid";
+        case 650: return "ArgentTournamentDungeon";
+        case 658: return "QuarryOfTears";
+        case 668: return "HallsOfReflection";
+        case 724: return "ChamberOfAspectsRed";
+        default: return "";
+    }
+}
+
+std::string Application::getPlayerModelPath() const {
+    return game::getPlayerModelPath(playerRace_, playerGender_);
+}
+
+
 Application* Application::instance = nullptr;
 
 Application::Application() {
@@ -128,11 +221,6 @@ bool Application::initialize() {
         return false;
     }
 
-    // Create and initialize audio coordinator (owns all audio managers)
-    audioCoordinator_ = std::make_unique<audio::AudioCoordinator>();
-    audioCoordinator_->initialize();
-    renderer->setAudioCoordinator(audioCoordinator_.get());
-
     // Create UI manager
     uiManager = std::make_unique<ui::UIManager>();
     if (!uiManager->initialize(window.get())) {
@@ -142,6 +230,7 @@ bool Application::initialize() {
 
     // Create subsystems
     authHandler = std::make_unique<auth::AuthHandler>();
+    gameHandler = std::make_unique<game::GameHandler>();
     world = std::make_unique<game::World>();
 
     // Create and initialize expansion registry
@@ -153,15 +242,6 @@ bool Application::initialize() {
     // Create asset manager
     assetManager = std::make_unique<pipeline::AssetManager>();
 
-    // Populate game services — all subsystems now available
-    gameServices_.renderer = renderer.get();
-    gameServices_.audioCoordinator = audioCoordinator_.get();
-    gameServices_.assetManager = assetManager.get();
-    gameServices_.expansionRegistry = expansionRegistry_.get();
-
-    // Create game handler with explicit service dependencies
-    gameHandler = std::make_unique<game::GameHandler>(gameServices_);
-
     // Try to get WoW data path from environment variable
     const char* dataPathEnv = std::getenv("WOW_DATA_PATH");
     std::string dataPath = dataPathEnv ? dataPathEnv : "./Data";
@@ -212,11 +292,6 @@ bool Application::initialize() {
             if (std::filesystem::exists(expansionManifest)) {
                 assetPath = profile->dataPath;
                 LOG_INFO("Using expansion-specific asset path: ", assetPath);
-                // Register base Data/ as fallback so world terrain files are found
-                // even when the expansion path only contains DBC overrides.
-                if (assetPath != dataPath) {
-                    assetManager->setBaseFallbackPath(dataPath);
-                }
             }
         }
     }
@@ -225,33 +300,7 @@ bool Application::initialize() {
     if (assetManager->initialize(assetPath)) {
         LOG_INFO("Asset manager initialized successfully");
         // Eagerly load creature display DBC lookups so first spawn doesn't stall
-        entitySpawner_ = std::make_unique<EntitySpawner>(
-            renderer.get(), assetManager.get(), gameHandler.get(),
-            dbcLayout_.get(), &gameServices_);
-        entitySpawner_->initialize();
-
-        appearanceComposer_ = std::make_unique<AppearanceComposer>(
-            renderer.get(), assetManager.get(), gameHandler.get(),
-            dbcLayout_.get(), entitySpawner_.get());
-
-        // Wire AppearanceComposer to UI components (Phase A singleton breaking)
-        if (uiManager) {
-            uiManager->setAppearanceComposer(appearanceComposer_.get());
-            
-            // Wire all services to UI components (Phase B singleton breaking)
-            ui::UIServices uiServices;
-            uiServices.window = window.get();
-            uiServices.renderer = renderer.get();
-            uiServices.assetManager = assetManager.get();
-            uiServices.gameHandler = gameHandler.get();
-            uiServices.expansionRegistry = expansionRegistry_.get();
-            uiServices.addonManager = addonManager_.get();  // May be nullptr here, re-wire later
-            uiServices.audioCoordinator = audioCoordinator_.get();
-            uiServices.entitySpawner = entitySpawner_.get();
-            uiServices.appearanceComposer = appearanceComposer_.get();
-            uiServices.worldLoader = worldLoader_.get();
-            uiManager->setServices(uiServices);
-        }
+        buildCreatureDisplayLookups();
 
         // Ensure the main in-world CharacterRenderer can load textures immediately.
         // Previously this was only wired during terrain initialization, which meant early spawns
@@ -266,295 +315,12 @@ bool Application::initialize() {
             gameHandler->getTransportManager()->loadTaxiPathNodeDBC(assetManager.get());
         }
 
-        // Initialize addon system
-        addonManager_ = std::make_unique<addons::AddonManager>();
-        addons::LuaServices luaSvc;
-        luaSvc.window            = window.get();
-        luaSvc.audioCoordinator  = audioCoordinator_.get();
-        luaSvc.expansionRegistry = expansionRegistry_.get();
-        if (addonManager_->initialize(gameHandler.get(), luaSvc)) {
-            std::string addonsDir = assetPath + "/interface/AddOns";
-            addonManager_->scanAddons(addonsDir);
-            // Wire Lua errors to UI error display
-            addonManager_->getLuaEngine()->setLuaErrorCallback([gh = gameHandler.get()](const std::string& err) {
-                if (gh) gh->addUIError(err);
-            });
-            // Wire chat messages to addon event dispatch
-            gameHandler->setAddonChatCallback([this](const game::MessageChatData& msg) {
-                if (!addonManager_ || !addonsLoaded_) return;
-                // Map ChatType to WoW event name
-                const char* eventName = nullptr;
-                switch (msg.type) {
-                    case game::ChatType::SAY:          eventName = "CHAT_MSG_SAY"; break;
-                    case game::ChatType::YELL:         eventName = "CHAT_MSG_YELL"; break;
-                    case game::ChatType::WHISPER:       eventName = "CHAT_MSG_WHISPER"; break;
-                    case game::ChatType::PARTY:         eventName = "CHAT_MSG_PARTY"; break;
-                    case game::ChatType::GUILD:         eventName = "CHAT_MSG_GUILD"; break;
-                    case game::ChatType::OFFICER:       eventName = "CHAT_MSG_OFFICER"; break;
-                    case game::ChatType::RAID:          eventName = "CHAT_MSG_RAID"; break;
-                    case game::ChatType::RAID_WARNING:  eventName = "CHAT_MSG_RAID_WARNING"; break;
-                    case game::ChatType::BATTLEGROUND:  eventName = "CHAT_MSG_BATTLEGROUND"; break;
-                    case game::ChatType::SYSTEM:        eventName = "CHAT_MSG_SYSTEM"; break;
-                    case game::ChatType::CHANNEL:       eventName = "CHAT_MSG_CHANNEL"; break;
-                    case game::ChatType::EMOTE:
-                    case game::ChatType::TEXT_EMOTE:    eventName = "CHAT_MSG_EMOTE"; break;
-                    case game::ChatType::ACHIEVEMENT:   eventName = "CHAT_MSG_ACHIEVEMENT"; break;
-                    case game::ChatType::GUILD_ACHIEVEMENT: eventName = "CHAT_MSG_GUILD_ACHIEVEMENT"; break;
-                    case game::ChatType::WHISPER_INFORM: eventName = "CHAT_MSG_WHISPER_INFORM"; break;
-                    case game::ChatType::RAID_LEADER:   eventName = "CHAT_MSG_RAID_LEADER"; break;
-                    case game::ChatType::BATTLEGROUND_LEADER: eventName = "CHAT_MSG_BATTLEGROUND_LEADER"; break;
-                    case game::ChatType::MONSTER_SAY:    eventName = "CHAT_MSG_MONSTER_SAY"; break;
-                    case game::ChatType::MONSTER_YELL:   eventName = "CHAT_MSG_MONSTER_YELL"; break;
-                    case game::ChatType::MONSTER_EMOTE:  eventName = "CHAT_MSG_MONSTER_EMOTE"; break;
-                    case game::ChatType::MONSTER_WHISPER: eventName = "CHAT_MSG_MONSTER_WHISPER"; break;
-                    case game::ChatType::RAID_BOSS_EMOTE: eventName = "CHAT_MSG_RAID_BOSS_EMOTE"; break;
-                    case game::ChatType::RAID_BOSS_WHISPER: eventName = "CHAT_MSG_RAID_BOSS_WHISPER"; break;
-                    case game::ChatType::BG_SYSTEM_NEUTRAL:  eventName = "CHAT_MSG_BG_SYSTEM_NEUTRAL"; break;
-                    case game::ChatType::BG_SYSTEM_ALLIANCE: eventName = "CHAT_MSG_BG_SYSTEM_ALLIANCE"; break;
-                    case game::ChatType::BG_SYSTEM_HORDE:    eventName = "CHAT_MSG_BG_SYSTEM_HORDE"; break;
-                    case game::ChatType::MONSTER_PARTY:  eventName = "CHAT_MSG_MONSTER_PARTY"; break;
-                    case game::ChatType::AFK:            eventName = "CHAT_MSG_AFK"; break;
-                    case game::ChatType::DND:            eventName = "CHAT_MSG_DND"; break;
-                    case game::ChatType::LOOT:           eventName = "CHAT_MSG_LOOT"; break;
-                    case game::ChatType::SKILL:          eventName = "CHAT_MSG_SKILL"; break;
-                    default: break;
-                }
-                if (eventName) {
-                    addonManager_->fireEvent(eventName, {msg.message, msg.senderName});
-                }
-            });
-            // Wire generic game events to addon dispatch
-            gameHandler->setAddonEventCallback([this](const std::string& event, const std::vector<std::string>& args) {
-                if (addonManager_ && addonsLoaded_) {
-                    addonManager_->fireEvent(event, args);
-                }
-            });
-            // Wire spell icon path resolver for Lua API (GetSpellInfo, UnitBuff icon, etc.)
-            {
-                auto spellIconPaths  = std::make_shared<std::unordered_map<uint32_t, std::string>>();
-                auto spellIconIds    = std::make_shared<std::unordered_map<uint32_t, uint32_t>>();
-                auto loaded          = std::make_shared<bool>(false);
-                auto* am = assetManager.get();
-                gameHandler->setSpellIconPathResolver([spellIconPaths, spellIconIds, loaded, am](uint32_t spellId) -> std::string {
-                    if (!am) return {};
-                    // Lazy-load SpellIcon.dbc + Spell.dbc icon IDs on first call
-                    if (!*loaded) {
-                        *loaded = true;
-                        auto iconDbc = am->loadDBC("SpellIcon.dbc");
-                        const auto* iconL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("SpellIcon") : nullptr;
-                        if (iconDbc && iconDbc->isLoaded()) {
-                            for (uint32_t i = 0; i < iconDbc->getRecordCount(); i++) {
-                                uint32_t id = iconDbc->getUInt32(i, iconL ? (*iconL)["ID"] : 0);
-                                std::string path = iconDbc->getString(i, iconL ? (*iconL)["Path"] : 1);
-                                if (!path.empty() && id > 0) (*spellIconPaths)[id] = path;
-                            }
-                        }
-                        auto spellDbc = am->loadDBC("Spell.dbc");
-                        const auto* spellL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("Spell") : nullptr;
-                        if (spellDbc && spellDbc->isLoaded()) {
-                            uint32_t fieldCount = spellDbc->getFieldCount();
-                            uint32_t iconField = 133; // WotLK default
-                            uint32_t idField = 0;
-                            if (spellL) {
-                                uint32_t layoutIcon = (*spellL)["IconID"];
-                                if (layoutIcon < fieldCount && fieldCount <= layoutIcon + 20) {
-                                    iconField = layoutIcon;
-                                    idField = (*spellL)["ID"];
-                                }
-                            }
-                            for (uint32_t i = 0; i < spellDbc->getRecordCount(); i++) {
-                                uint32_t id = spellDbc->getUInt32(i, idField);
-                                uint32_t iconId = spellDbc->getUInt32(i, iconField);
-                                if (id > 0 && iconId > 0) (*spellIconIds)[id] = iconId;
-                            }
-                        }
-                    }
-                    auto iit = spellIconIds->find(spellId);
-                    if (iit == spellIconIds->end()) return {};
-                    auto pit = spellIconPaths->find(iit->second);
-                    if (pit == spellIconPaths->end()) return {};
-                    return pit->second;
-                });
-            }
-            // Wire item icon path resolver: displayInfoId -> "Interface\\Icons\\INV_..."
-            {
-                auto iconNames = std::make_shared<std::unordered_map<uint32_t, std::string>>();
-                auto loaded    = std::make_shared<bool>(false);
-                auto* am = assetManager.get();
-                gameHandler->setItemIconPathResolver([iconNames, loaded, am](uint32_t displayInfoId) -> std::string {
-                    if (!am || displayInfoId == 0) return {};
-                    if (!*loaded) {
-                        *loaded = true;
-                        auto dbc = am->loadDBC("ItemDisplayInfo.dbc");
-                        const auto* dispL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
-                        if (dbc && dbc->isLoaded()) {
-                            uint32_t iconField = dispL ? (*dispL)["InventoryIcon"] : 5;
-                            for (uint32_t i = 0; i < dbc->getRecordCount(); i++) {
-                                uint32_t id = dbc->getUInt32(i, 0); // field 0 = ID
-                                std::string name = dbc->getString(i, iconField);
-                                if (id > 0 && !name.empty()) (*iconNames)[id] = name;
-                            }
-                            LOG_INFO("Loaded ", iconNames->size(), " item icon names from ItemDisplayInfo.dbc");
-                        }
-                    }
-                    auto it = iconNames->find(displayInfoId);
-                    if (it == iconNames->end()) return {};
-                    return "Interface\\Icons\\" + it->second;
-                });
-            }
-            // Wire spell data resolver: spellId -> {castTimeMs, minRange, maxRange}
-            {
-                auto castTimeMap = std::make_shared<std::unordered_map<uint32_t, uint32_t>>();
-                auto rangeMap    = std::make_shared<std::unordered_map<uint32_t, std::pair<float,float>>>();
-                auto spellCastIdx = std::make_shared<std::unordered_map<uint32_t, uint32_t>>(); // spellId→castTimeIdx
-                auto spellRangeIdx = std::make_shared<std::unordered_map<uint32_t, uint32_t>>(); // spellId→rangeIdx
-                struct SpellCostEntry { uint32_t manaCost = 0; uint8_t powerType = 0; };
-                auto spellCostMap = std::make_shared<std::unordered_map<uint32_t, SpellCostEntry>>();
-                auto loaded = std::make_shared<bool>(false);
-                auto* am = assetManager.get();
-                gameHandler->setSpellDataResolver([castTimeMap, rangeMap, spellCastIdx, spellRangeIdx, spellCostMap, loaded, am](uint32_t spellId) -> game::GameHandler::SpellDataInfo {
-                    if (!am) return {};
-                    if (!*loaded) {
-                        *loaded = true;
-                        // Load SpellCastTimes.dbc
-                        auto ctDbc = am->loadDBC("SpellCastTimes.dbc");
-                        if (ctDbc && ctDbc->isLoaded()) {
-                            for (uint32_t i = 0; i < ctDbc->getRecordCount(); ++i) {
-                                uint32_t id = ctDbc->getUInt32(i, 0);
-                                int32_t base = static_cast<int32_t>(ctDbc->getUInt32(i, 1));
-                                if (id > 0 && base > 0) (*castTimeMap)[id] = static_cast<uint32_t>(base);
-                            }
-                        }
-                        // Load SpellRange.dbc
-                        const auto* srL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("SpellRange") : nullptr;
-                        uint32_t minRField = srL ? (*srL)["MinRange"] : 1;
-                        uint32_t maxRField = srL ? (*srL)["MaxRange"] : 4;
-                        auto rDbc = am->loadDBC("SpellRange.dbc");
-                        if (rDbc && rDbc->isLoaded()) {
-                            for (uint32_t i = 0; i < rDbc->getRecordCount(); ++i) {
-                                uint32_t id = rDbc->getUInt32(i, 0);
-                                float minR = rDbc->getFloat(i, minRField);
-                                float maxR = rDbc->getFloat(i, maxRField);
-                                if (id > 0) (*rangeMap)[id] = {minR, maxR};
-                            }
-                        }
-                        // Load Spell.dbc: extract castTimeIndex and rangeIndex per spell
-                        auto sDbc = am->loadDBC("Spell.dbc");
-                        const auto* spL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("Spell") : nullptr;
-                        if (sDbc && sDbc->isLoaded()) {
-                            uint32_t idF = spL ? (*spL)["ID"] : 0;
-                            uint32_t ctF = spL ? (*spL)["CastingTimeIndex"] : 134; // WotLK default
-                            uint32_t rF  = spL ? (*spL)["RangeIndex"] : 132;
-                            uint32_t ptF = UINT32_MAX, mcF = UINT32_MAX;
-                            if (spL) {
-                                try { ptF = (*spL)["PowerType"]; } catch (...) {}
-                                try { mcF = (*spL)["ManaCost"]; } catch (...) {}
-                            }
-                            uint32_t fc = sDbc->getFieldCount();
-                            for (uint32_t i = 0; i < sDbc->getRecordCount(); ++i) {
-                                uint32_t id = sDbc->getUInt32(i, idF);
-                                if (id == 0) continue;
-                                uint32_t ct = sDbc->getUInt32(i, ctF);
-                                uint32_t ri = sDbc->getUInt32(i, rF);
-                                if (ct > 0) (*spellCastIdx)[id] = ct;
-                                if (ri > 0) (*spellRangeIdx)[id] = ri;
-                                // Extract power cost
-                                uint32_t mc = (mcF < fc) ? sDbc->getUInt32(i, mcF) : 0;
-                                uint8_t  pt = (ptF < fc) ? static_cast<uint8_t>(sDbc->getUInt32(i, ptF)) : 0;
-                                if (mc > 0) (*spellCostMap)[id] = {mc, pt};
-                            }
-                        }
-                        LOG_INFO("SpellDataResolver: loaded ", spellCastIdx->size(), " cast indices, ",
-                                 spellRangeIdx->size(), " range indices");
-                    }
-                    game::GameHandler::SpellDataInfo info;
-                    auto ciIt = spellCastIdx->find(spellId);
-                    if (ciIt != spellCastIdx->end()) {
-                        auto ctIt = castTimeMap->find(ciIt->second);
-                        if (ctIt != castTimeMap->end()) info.castTimeMs = ctIt->second;
-                    }
-                    auto riIt = spellRangeIdx->find(spellId);
-                    if (riIt != spellRangeIdx->end()) {
-                        auto rIt = rangeMap->find(riIt->second);
-                        if (rIt != rangeMap->end()) {
-                            info.minRange = rIt->second.first;
-                            info.maxRange = rIt->second.second;
-                        }
-                    }
-                    auto mcIt = spellCostMap->find(spellId);
-                    if (mcIt != spellCostMap->end()) {
-                        info.manaCost = mcIt->second.manaCost;
-                        info.powerType = mcIt->second.powerType;
-                    }
-                    return info;
-                });
-            }
-            // Wire random property/suffix name resolver for item display
-            {
-                auto propNames   = std::make_shared<std::unordered_map<int32_t, std::string>>();
-                auto propLoaded  = std::make_shared<bool>(false);
-                auto* amPtr = assetManager.get();
-                gameHandler->setRandomPropertyNameResolver([propNames, propLoaded, amPtr](int32_t id) -> std::string {
-                    if (!amPtr || id == 0) return {};
-                    if (!*propLoaded) {
-                        *propLoaded = true;
-                        // ItemRandomProperties.dbc: ID=0, Name=4 (string)
-                        if (auto dbc = amPtr->loadDBC("ItemRandomProperties.dbc"); dbc && dbc->isLoaded()) {
-                            uint32_t nameField = (dbc->getFieldCount() > 4) ? 4 : 1;
-                            for (uint32_t r = 0; r < dbc->getRecordCount(); ++r) {
-                                int32_t rid = static_cast<int32_t>(dbc->getUInt32(r, 0));
-                                std::string name = dbc->getString(r, nameField);
-                                if (!name.empty() && rid > 0) (*propNames)[rid] = name;
-                            }
-                        }
-                        // ItemRandomSuffix.dbc: ID=0, Name=4 (string) — stored as negative IDs
-                        if (auto dbc = amPtr->loadDBC("ItemRandomSuffix.dbc"); dbc && dbc->isLoaded()) {
-                            uint32_t nameField = (dbc->getFieldCount() > 4) ? 4 : 1;
-                            for (uint32_t r = 0; r < dbc->getRecordCount(); ++r) {
-                                int32_t rid = static_cast<int32_t>(dbc->getUInt32(r, 0));
-                                std::string name = dbc->getString(r, nameField);
-                                if (!name.empty() && rid > 0) (*propNames)[-rid] = name;
-                            }
-                        }
-                    }
-                    auto it = propNames->find(id);
-                    return (it != propNames->end()) ? it->second : std::string{};
-                });
-            }
-            LOG_INFO("Addon system initialized, found ", addonManager_->getAddons().size(), " addon(s)");
-        } else {
-            LOG_WARNING("Failed to initialize addon system");
-            addonManager_.reset();
-        }
-
-        // Initialize world loader (handles terrain streaming, world preload, map transitions)
-        worldLoader_ = std::make_unique<WorldLoader>(
-            *this, renderer.get(), assetManager.get(), gameHandler.get(),
-            entitySpawner_.get(), appearanceComposer_.get(), window.get(),
-            world.get(), addonManager_.get());
-
-        // Re-wire UIServices now that all services (addonManager_, worldLoader_) are available
-        if (uiManager) {
-            ui::UIServices uiServices;
-            uiServices.window = window.get();
-            uiServices.renderer = renderer.get();
-            uiServices.assetManager = assetManager.get();
-            uiServices.gameHandler = gameHandler.get();
-            uiServices.expansionRegistry = expansionRegistry_.get();
-            uiServices.addonManager = addonManager_.get();
-            uiServices.audioCoordinator = audioCoordinator_.get();
-            uiServices.entitySpawner = entitySpawner_.get();
-            uiServices.appearanceComposer = appearanceComposer_.get();
-            uiServices.worldLoader = worldLoader_.get();
-            uiManager->setServices(uiServices);
-        }
-
         // Start background preload for last-played character's world.
         // Warms the file cache so terrain tile loading is faster at Enter World.
         {
-            auto lastWorld = worldLoader_->loadLastWorldInfo();
+            auto lastWorld = loadLastWorldInfo();
             if (lastWorld.valid) {
-                worldLoader_->startWorldPreload(lastWorld.mapId, lastWorld.mapName, lastWorld.x, lastWorld.y);
+                startWorldPreload(lastWorld.mapId, lastWorld.mapName, lastWorld.x, lastWorld.y);
             }
         }
 
@@ -572,7 +338,6 @@ bool Application::initialize() {
 }
 
 void Application::run() {
-    ZoneScopedN("Application::run");
     LOG_INFO("Starting main loop");
 
     // Pin main thread to a dedicated CPU core to reduce scheduling jitter
@@ -621,206 +386,143 @@ void Application::run() {
     }
 
     auto lastTime = std::chrono::high_resolution_clock::now();
-    std::atomic<bool> watchdogRunning{true};
-    std::atomic<int64_t> watchdogHeartbeatMs{
-        std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now().time_since_epoch()).count()
-    };
-    // Signal flag: watchdog sets this when a stall is detected, main loop
-    // handles the actual SDL calls. SDL2 video functions must only be called
-    // from the main thread (the one that called SDL_Init); calling them from
-    // a background thread is UB on macOS (Cocoa) and unsafe on other platforms.
-    std::atomic<bool> watchdogRequestRelease{false};
-    std::thread watchdogThread([&watchdogRunning, &watchdogHeartbeatMs, &watchdogRequestRelease]() {
-        bool signalledForCurrentStall = false;
-        while (watchdogRunning.load(std::memory_order_acquire)) {
-            std::this_thread::sleep_for(std::chrono::milliseconds(250));
-            const int64_t nowMs = std::chrono::duration_cast<std::chrono::milliseconds>(
-                std::chrono::steady_clock::now().time_since_epoch()).count();
-            const int64_t lastBeatMs = watchdogHeartbeatMs.load(std::memory_order_acquire);
-            const int64_t stallMs = nowMs - lastBeatMs;
 
-            if (stallMs > 1500) {
-                if (!signalledForCurrentStall) {
-                    watchdogRequestRelease.store(true, std::memory_order_release);
-                    LOG_WARNING("Main-loop stall detected (", stallMs,
-                                "ms) — requesting mouse capture release");
-                    signalledForCurrentStall = true;
-                }
-            } else {
-                signalledForCurrentStall = false;
-            }
+    while (running && !window->shouldClose()) {
+        // Calculate delta time
+        auto currentTime = std::chrono::high_resolution_clock::now();
+        std::chrono::duration<float> deltaTimeDuration = currentTime - lastTime;
+        float deltaTime = deltaTimeDuration.count();
+        lastTime = currentTime;
+
+        // Cap delta time to prevent large jumps
+        if (deltaTime > 0.1f) {
+            deltaTime = 0.1f;
         }
-    });
 
-    try {
-        while (running && !window->shouldClose()) {
-            watchdogHeartbeatMs.store(
-                std::chrono::duration_cast<std::chrono::milliseconds>(
-                    std::chrono::steady_clock::now().time_since_epoch()).count(),
-                std::memory_order_release);
-
-            // Handle watchdog mouse-release request on the main thread where
-            // SDL video calls are safe (required by SDL2 threading model).
-            if (watchdogRequestRelease.exchange(false, std::memory_order_acq_rel)) {
-                SDL_SetRelativeMouseMode(SDL_FALSE);
-                SDL_ShowCursor(SDL_ENABLE);
-                if (window && window->getSDLWindow()) {
-                    SDL_SetWindowGrab(window->getSDLWindow(), SDL_FALSE);
-                }
-                LOG_WARNING("Watchdog: force-released mouse capture on main thread");
+        // Poll events
+        SDL_Event event;
+        while (SDL_PollEvent(&event)) {
+            // Pass event to UI manager first
+            if (uiManager) {
+                uiManager->processEvent(event);
             }
 
-            // Calculate delta time
-            auto currentTime = std::chrono::high_resolution_clock::now();
-            std::chrono::duration<float> deltaTimeDuration = currentTime - lastTime;
-            float deltaTime = deltaTimeDuration.count();
-            lastTime = currentTime;
-
-            // Cap delta time to prevent large jumps
-            if (deltaTime > 0.1f) {
-                deltaTime = 0.1f;
-            }
-
-            // Poll events
-            SDL_Event event;
-            while (SDL_PollEvent(&event)) {
-                // Pass event to UI manager first
-                if (uiManager) {
-                    uiManager->processEvent(event);
+            // Pass mouse events to camera controller (skip when UI has mouse focus)
+            if (renderer && renderer->getCameraController() && !ImGui::GetIO().WantCaptureMouse) {
+                if (event.type == SDL_MOUSEMOTION) {
+                    renderer->getCameraController()->processMouseMotion(event.motion);
                 }
-
-                // Pass mouse events to camera controller (skip when UI has mouse focus)
-                if (renderer && renderer->getCameraController() && !ImGui::GetIO().WantCaptureMouse) {
-                    if (event.type == SDL_MOUSEMOTION) {
-                        renderer->getCameraController()->processMouseMotion(event.motion);
-                    }
-                    else if (event.type == SDL_MOUSEBUTTONDOWN || event.type == SDL_MOUSEBUTTONUP) {
-                        renderer->getCameraController()->processMouseButton(event.button);
-                    }
-                    else if (event.type == SDL_MOUSEWHEEL) {
-                        renderer->getCameraController()->processMouseWheel(static_cast<float>(event.wheel.y));
-                    }
+                else if (event.type == SDL_MOUSEBUTTONDOWN || event.type == SDL_MOUSEBUTTONUP) {
+                    renderer->getCameraController()->processMouseButton(event.button);
                 }
-
-                // Handle window events
-                if (event.type == SDL_QUIT) {
-                    window->setShouldClose(true);
-                }
-                else if (event.type == SDL_WINDOWEVENT) {
-                    if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
-                        int newWidth = event.window.data1;
-                        int newHeight = event.window.data2;
-                        window->setSize(newWidth, newHeight);
-                        // Vulkan viewport set in command buffer, not globally
-                        if (renderer && renderer->getCamera()) {
-                            renderer->getCamera()->setAspectRatio(static_cast<float>(newWidth) / newHeight);
-                        }
-                        // Notify addons so UI layouts can adapt to the new size
-                        if (addonManager_)
-                            addonManager_->fireEvent("DISPLAY_SIZE_CHANGED");
-                    }
-                }
-                // Debug controls
-                else if (event.type == SDL_KEYDOWN) {
-                    // Skip non-function-key input when UI (chat) has keyboard focus
-                    bool uiHasKeyboard = ImGui::GetIO().WantCaptureKeyboard;
-                    auto sc = event.key.keysym.scancode;
-                    bool isFKey = (sc >= SDL_SCANCODE_F1 && sc <= SDL_SCANCODE_F12);
-                    if (uiHasKeyboard && !isFKey) {
-                        continue;  // Let ImGui handle the keystroke
-                    }
-
-                    // F1: Toggle performance HUD
-                    if (event.key.keysym.scancode == SDL_SCANCODE_F1) {
-                        if (renderer && renderer->getPerformanceHUD()) {
-                            renderer->getPerformanceHUD()->toggle();
-                            bool enabled = renderer->getPerformanceHUD()->isEnabled();
-                            LOG_INFO("Performance HUD: ", enabled ? "ON" : "OFF");
-                        }
-                    }
-                    // F4: Toggle shadows
-                    else if (event.key.keysym.scancode == SDL_SCANCODE_F4) {
-                        if (renderer) {
-                            bool enabled = !renderer->areShadowsEnabled();
-                            renderer->setShadowsEnabled(enabled);
-                            LOG_INFO("Shadows: ", enabled ? "ON" : "OFF");
-                        }
-                    }
-                    // F8: Debug WMO floor at current position
-                    else if (event.key.keysym.scancode == SDL_SCANCODE_F8 && event.key.repeat == 0) {
-                        if (renderer && renderer->getWMORenderer()) {
-                            glm::vec3 pos = renderer->getCharacterPosition();
-                            LOG_WARNING("F8: WMO floor debug at render pos (", pos.x, ", ", pos.y, ", ", pos.z, ")");
-                            renderer->getWMORenderer()->debugDumpGroupsAtPosition(pos.x, pos.y, pos.z);
-                        }
-                    }
+                else if (event.type == SDL_MOUSEWHEEL) {
+                    renderer->getCameraController()->processMouseWheel(static_cast<float>(event.wheel.y));
                 }
             }
 
-            // Update input
-            Input::getInstance().update();
-
-            // Update application state
-            try {
-                FrameMark;
-                update(deltaTime);
-            } catch (const std::bad_alloc& e) {
-                LOG_ERROR("OOM during Application::update (state=", static_cast<int>(state),
-                          ", dt=", deltaTime, "): ", e.what());
-                throw;
-            } catch (const std::exception& e) {
-                LOG_ERROR("Exception during Application::update (state=", static_cast<int>(state),
-                          ", dt=", deltaTime, "): ", e.what());
-                throw;
-            }
-            // Render
-            try {
-                render();
-            } catch (const std::bad_alloc& e) {
-                LOG_ERROR("OOM during Application::render (state=", static_cast<int>(state), "): ", e.what());
-                throw;
-            } catch (const std::exception& e) {
-                LOG_ERROR("Exception during Application::render (state=", static_cast<int>(state), "): ", e.what());
-                throw;
-            }
-            // Swap buffers
-            try {
-                window->swapBuffers();
-            } catch (const std::bad_alloc& e) {
-                LOG_ERROR("OOM during swapBuffers: ", e.what());
-                throw;
-            } catch (const std::exception& e) {
-                LOG_ERROR("Exception during swapBuffers: ", e.what());
-                throw;
-            }
-
-            // Exit gracefully on GPU device lost (unrecoverable)
-            if (renderer && renderer->getVkContext() && renderer->getVkContext()->isDeviceLost()) {
-                LOG_ERROR("GPU device lost — exiting application");
+            // Handle window events
+            if (event.type == SDL_QUIT) {
                 window->setShouldClose(true);
             }
+            else if (event.type == SDL_WINDOWEVENT) {
+                if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
+                    int newWidth = event.window.data1;
+                    int newHeight = event.window.data2;
+                    window->setSize(newWidth, newHeight);
+                    // Vulkan viewport set in command buffer, not globally
+                    if (renderer && renderer->getCamera()) {
+                        renderer->getCamera()->setAspectRatio(static_cast<float>(newWidth) / newHeight);
+                    }
+                }
+            }
+            // Debug controls
+            else if (event.type == SDL_KEYDOWN) {
+                // Skip non-function-key input when UI (chat) has keyboard focus
+                bool uiHasKeyboard = ImGui::GetIO().WantCaptureKeyboard;
+                auto sc = event.key.keysym.scancode;
+                bool isFKey = (sc >= SDL_SCANCODE_F1 && sc <= SDL_SCANCODE_F12);
+                if (uiHasKeyboard && !isFKey) {
+                    continue;  // Let ImGui handle the keystroke
+                }
 
-            // Soft frame rate cap when vsync is off to prevent 100% CPU usage.
-            // Target ~240 FPS max (~4.2ms per frame); vsync handles its own pacing.
-            if (!window->isVsyncEnabled() && deltaTime < 0.004f) {
-                float sleepMs = (0.004f - deltaTime) * 1000.0f;
-                if (sleepMs > 0.5f)
-                    std::this_thread::sleep_for(std::chrono::microseconds(
-                        static_cast<int64_t>(sleepMs * 900.0f)));  // 90% of target to account for sleep overshoot
+                // F1: Toggle performance HUD
+                if (event.key.keysym.scancode == SDL_SCANCODE_F1) {
+                    if (renderer && renderer->getPerformanceHUD()) {
+                        renderer->getPerformanceHUD()->toggle();
+                        bool enabled = renderer->getPerformanceHUD()->isEnabled();
+                        LOG_INFO("Performance HUD: ", enabled ? "ON" : "OFF");
+                    }
+                }
+                // F4: Toggle shadows
+                else if (event.key.keysym.scancode == SDL_SCANCODE_F4) {
+                    if (renderer) {
+                        bool enabled = !renderer->areShadowsEnabled();
+                        renderer->setShadowsEnabled(enabled);
+                        LOG_INFO("Shadows: ", enabled ? "ON" : "OFF");
+                    }
+                }
+                // F7: Test level-up effect (ignore key repeat)
+                else if (event.key.keysym.scancode == SDL_SCANCODE_F7 && event.key.repeat == 0) {
+                    if (renderer) {
+                        renderer->triggerLevelUpEffect(renderer->getCharacterPosition());
+                        LOG_INFO("Triggered test level-up effect");
+                    }
+                    if (uiManager) {
+                        uiManager->getGameScreen().triggerDing(99);
+                    }
+                }
+                // F8: Debug WMO floor at current position
+                else if (event.key.keysym.scancode == SDL_SCANCODE_F8 && event.key.repeat == 0) {
+                    if (renderer && renderer->getWMORenderer()) {
+                        glm::vec3 pos = renderer->getCharacterPosition();
+                        LOG_WARNING("F8: WMO floor debug at render pos (", pos.x, ", ", pos.y, ", ", pos.z, ")");
+                        renderer->getWMORenderer()->debugDumpGroupsAtPosition(pos.x, pos.y, pos.z);
+                    }
+                }
             }
         }
-    } catch (...) {
-        watchdogRunning.store(false, std::memory_order_release);
-        if (watchdogThread.joinable()) {
-            watchdogThread.join();
-        }
-        throw;
-    }
 
-    watchdogRunning.store(false, std::memory_order_release);
-    if (watchdogThread.joinable()) {
-        watchdogThread.join();
+        // Update input
+        Input::getInstance().update();
+
+        // Update application state
+        try {
+            update(deltaTime);
+        } catch (const std::bad_alloc& e) {
+            LOG_ERROR("OOM during Application::update (state=", static_cast<int>(state),
+                      ", dt=", deltaTime, "): ", e.what());
+            throw;
+        } catch (const std::exception& e) {
+            LOG_ERROR("Exception during Application::update (state=", static_cast<int>(state),
+                      ", dt=", deltaTime, "): ", e.what());
+            throw;
+        }
+        // Render
+        try {
+            render();
+        } catch (const std::bad_alloc& e) {
+            LOG_ERROR("OOM during Application::render (state=", static_cast<int>(state), "): ", e.what());
+            throw;
+        } catch (const std::exception& e) {
+            LOG_ERROR("Exception during Application::render (state=", static_cast<int>(state), "): ", e.what());
+            throw;
+        }
+        // Swap buffers
+        try {
+            window->swapBuffers();
+        } catch (const std::bad_alloc& e) {
+            LOG_ERROR("OOM during swapBuffers: ", e.what());
+            throw;
+        } catch (const std::exception& e) {
+            LOG_ERROR("Exception during swapBuffers: ", e.what());
+            throw;
+        }
+
+        // Exit gracefully on GPU device lost (unrecoverable)
+        if (renderer && renderer->getVkContext() && renderer->getVkContext()->isDeviceLost()) {
+            LOG_ERROR("GPU device lost — exiting application");
+            window->setShouldClose(true);
+        }
     }
 
     LOG_INFO("Main loop ended");
@@ -829,16 +531,8 @@ void Application::run() {
 void Application::shutdown() {
     LOG_WARNING("Shutting down application...");
 
-    // Hide the window immediately so the OS doesn't think the app is frozen
-    // during the (potentially slow) resource cleanup below.
-    if (window && window->getSDLWindow()) {
-        SDL_HideWindow(window->getSDLWindow());
-    }
-
     // Stop background world preloader before destroying AssetManager
-    if (worldLoader_) {
-        worldLoader_->cancelWorldPreload();
-    };
+    cancelWorldPreload();
 
     // Save floor cache before renderer is destroyed
     if (renderer && renderer->getWMORenderer()) {
@@ -860,17 +554,10 @@ void Application::shutdown() {
     LOG_WARNING("Renderer shutdown complete, resetting...");
     renderer.reset();
 
-    // Shutdown audio coordinator after renderer (renderer may reference audio during shutdown)
-    if (audioCoordinator_) {
-        audioCoordinator_->shutdown();
-    }
-    audioCoordinator_.reset();
-
     LOG_WARNING("Resetting world...");
     world.reset();
     LOG_WARNING("Resetting gameHandler...");
     gameHandler.reset();
-    gameServices_ = {};
     LOG_WARNING("Resetting authHandler...");
     authHandler.reset();
     LOG_WARNING("Resetting assetManager...");
@@ -910,16 +597,11 @@ void Application::setState(AppState newState) {
             }
             // Ensure no stale in-world player model leaks into the next login attempt.
             // If we reuse a previously spawned instance without forcing a respawn, appearance (notably hair) can desync.
-            if (addonManager_ && addonsLoaded_) {
-                addonManager_->fireEvent("PLAYER_LEAVING_WORLD");
-                addonManager_->saveAllSavedVariables();
-            }
             npcsSpawned = false;
             playerCharacterSpawned = false;
-            addonsLoaded_ = false;
-            if (appearanceComposer_) appearanceComposer_->setWeaponsSheathed(false);
+            weaponsSheathed_ = false;
             wasAutoAttacking_ = false;
-            if (worldLoader_) worldLoader_->resetLoadedMap();
+            loadedMapId_ = 0xFFFFFFFF;
             spawnedPlayerGuid_ = 0;
             spawnedAppearanceBytes_ = 0;
             spawnedFacialFeatures_ = 0;
@@ -941,58 +623,12 @@ void Application::setState(AppState newState) {
                         gameHandler->sendMovement(static_cast<game::Opcode>(opcode));
                     }
                 });
-                cc->setStandUpCallback([this]() {
-                    if (gameHandler) {
-                        gameHandler->setStandState(rendering::AnimationController::STAND_STATE_STAND);
-                    }
-                });
-                cc->setSitDownCallback([this]() {
-                    if (gameHandler) {
-                        gameHandler->setStandState(rendering::AnimationController::STAND_STATE_SIT);
-                    }
-                    if (renderer) {
-                        if (auto* ac = renderer->getAnimationController()) {
-                            ac->setStandState(rendering::AnimationController::STAND_STATE_SIT);
-                        }
-                    }
-                });
-                cc->setAutoFollowCancelCallback([this]() {
-                    if (gameHandler) {
-                        gameHandler->cancelFollow();
-                    }
-                });
                 cc->setUseWoWSpeed(true);
             }
             if (gameHandler) {
-                gameHandler->setMeleeSwingCallback([this](uint32_t spellId) {
+                gameHandler->setMeleeSwingCallback([this]() {
                     if (renderer) {
-                        // Ranged auto-attack spells: Auto Shot (75), Shoot (5019), Throw (2764)
-                        if (spellId == 75 || spellId == 5019 || spellId == 2764) {
-                            renderer->triggerRangedShot();
-                        } else if (spellId != 0) {
-                            renderer->triggerSpecialAttack(spellId);
-                        } else {
-                            renderer->triggerMeleeSwing();
-                        }
-                    }
-                });
-                gameHandler->setKnockBackCallback([this](float vcos, float vsin, float hspeed, float vspeed) {
-                    if (renderer && renderer->getCameraController()) {
-                        renderer->getCameraController()->applyKnockBack(vcos, vsin, hspeed, vspeed);
-                    }
-                });
-                gameHandler->setCameraShakeCallback([this](float magnitude, float frequency, float duration) {
-                    if (renderer && renderer->getCameraController()) {
-                        renderer->getCameraController()->triggerShake(magnitude, frequency, duration);
-                    }
-                });
-                gameHandler->setAutoFollowCallback([this](const glm::vec3* renderPos) {
-                    if (renderer && renderer->getCameraController()) {
-                        if (renderPos) {
-                            renderer->getCameraController()->setAutoFollow(renderPos);
-                        } else {
-                            renderer->getCameraController()->cancelAutoFollow();
-                        }
+                        renderer->triggerMeleeSwing();
                     }
                 });
             }
@@ -1042,7 +678,8 @@ void Application::reloadExpansionData() {
     }
 
     // Reset map name cache so it reloads from new expansion's Map.dbc
-    if (worldLoader_) worldLoader_->resetMapNameCache();
+    mapNameCacheLoaded_ = false;
+    mapNameById_.clear();
 
     // Reset game handler DBC caches so they reload from new expansion data
     if (gameHandler) {
@@ -1050,7 +687,13 @@ void Application::reloadExpansionData() {
     }
 
     // Rebuild creature display lookups with the new expansion's DBC layout
-    if (entitySpawner_) entitySpawner_->rebuildLookups();
+    creatureLookupsBuilt_ = false;
+    displayDataMap_.clear();
+    humanoidExtraMap_.clear();
+    creatureModelIds_.clear();
+    creatureRenderPosCache_.clear();
+    nonRenderableCreatureDisplayIds_.clear();
+    buildCreatureDisplayLookups();
 }
 
 void Application::logoutToLogin() {
@@ -1068,9 +711,9 @@ void Application::logoutToLogin() {
     // --- Per-session flags ---
     npcsSpawned = false;
     playerCharacterSpawned = false;
-    if (appearanceComposer_) appearanceComposer_->setWeaponsSheathed(false);
+    weaponsSheathed_ = false;
     wasAutoAttacking_ = false;
-    if (worldLoader_) worldLoader_->resetLoadedMap();
+    loadedMapId_ = 0xFFFFFFFF;
     lastTaxiFlight_ = false;
     taxiLandingClampTimer_ = 0.0f;
     worldEntryMovementGraceTimer_ = 0.0f;
@@ -1090,13 +733,53 @@ void Application::logoutToLogin() {
     spawnedAppearanceBytes_ = 0;
     spawnedFacialFeatures_ = 0;
 
-    // --- Reset all EntitySpawner state (mount, creatures, players, GOs, queues, caches) ---
-    if (entitySpawner_) entitySpawner_->resetAllState();
+    // --- Mount state ---
+    mountInstanceId_ = 0;
+    mountModelId_ = 0;
+    pendingMountDisplayId_ = 0;
+
+    // --- Creature instance tracking ---
+    creatureInstances_.clear();
+    creatureModelIds_.clear();
+    creatureRenderPosCache_.clear();
+    creatureWeaponsAttached_.clear();
+    creatureWeaponAttachAttempts_.clear();
+    deadCreatureGuids_.clear();
+    nonRenderableCreatureDisplayIds_.clear();
+    creaturePermanentFailureGuids_.clear();
+    modelIdIsWolfLike_.clear();
+    displayIdTexturesApplied_.clear();
+    charSectionsCache_.clear();
+    charSectionsCacheBuilt_ = false;
+
+    // Wait for any in-flight async creature loads before clearing state
+    for (auto& load : asyncCreatureLoads_) {
+        if (load.future.valid()) load.future.wait();
+    }
+    asyncCreatureLoads_.clear();
+
+    // --- Creature spawn queues ---
+    pendingCreatureSpawns_.clear();
+    pendingCreatureSpawnGuids_.clear();
+    creatureSpawnRetryCounts_.clear();
+
+    // --- Player instance tracking ---
+    playerInstances_.clear();
+    onlinePlayerAppearance_.clear();
+    pendingOnlinePlayerEquipment_.clear();
+    deferredEquipmentQueue_.clear();
+    pendingPlayerSpawns_.clear();
+    pendingPlayerSpawnGuids_.clear();
+
+    // --- GameObject instance tracking ---
+    gameObjectInstances_.clear();
+    pendingGameObjectSpawns_.clear();
+    pendingTransportMoves_.clear();
+    pendingTransportDoodadBatches_.clear();
 
     world.reset();
 
     if (renderer) {
-        renderer->resetCombatVisualState();
         // Remove old player model so it doesn't persist into next session
         if (auto* charRenderer = renderer->getCharacterRenderer()) {
             charRenderer->removeInstance(1);
@@ -1118,7 +801,7 @@ void Application::logoutToLogin() {
         }
         renderer->clearMount();
         renderer->setCharacterFollow(0);
-        if (auto* music = audioCoordinator_ ? audioCoordinator_->getMusicManager() : nullptr) {
+        if (auto* music = renderer->getMusicManager()) {
             music->stopMusic(0.0f);
         }
     }
@@ -1132,7 +815,6 @@ void Application::logoutToLogin() {
 }
 
 void Application::update(float deltaTime) {
-    ZoneScopedN("Application::update");
     const char* updateCheckpoint = "enter";
     try {
     // Update based on current state
@@ -1197,17 +879,14 @@ void Application::update(float deltaTime) {
                     gameHandler->update(deltaTime);
                 }
             });
-            if (addonManager_ && addonsLoaded_) {
-                addonManager_->update(deltaTime);
-            }
             // Always unsheath on combat engage.
             inGameStep = "auto-unsheathe";
             updateCheckpoint = "in_game: auto-unsheathe";
             if (gameHandler) {
                 const bool autoAttacking = gameHandler->isAutoAttacking();
-                if (autoAttacking && !wasAutoAttacking_ && appearanceComposer_ && appearanceComposer_->isWeaponsSheathed()) {
-                    appearanceComposer_->setWeaponsSheathed(false);
-                    appearanceComposer_->loadEquippedWeapons();
+                if (autoAttacking && !wasAutoAttacking_ && weaponsSheathed_) {
+                    weaponsSheathed_ = false;
+                    loadEquippedWeapons();
                 }
                 wasAutoAttacking_ = autoAttacking;
             }
@@ -1218,9 +897,9 @@ void Application::update(float deltaTime) {
             {
                 const bool uiWantsKeyboard = ImGui::GetIO().WantCaptureKeyboard;
                 auto& input = Input::getInstance();
-                if (!uiWantsKeyboard && input.isKeyJustPressed(SDL_SCANCODE_Z) && appearanceComposer_) {
-                    appearanceComposer_->toggleWeaponsSheathed();
-                    appearanceComposer_->loadEquippedWeapons();
+                if (!uiWantsKeyboard && input.isKeyJustPressed(SDL_SCANCODE_Z)) {
+                    weaponsSheathed_ = !weaponsSheathed_;
+                    loadEquippedWeapons();
                 }
             }
 
@@ -1234,7 +913,10 @@ void Application::update(float deltaTime) {
             inGameStep = "spawn/equipment queues";
             updateCheckpoint = "in_game: spawn/equipment queues";
             runInGameStage("spawn/equipment queues", [&] {
-                if (entitySpawner_) entitySpawner_->update();
+                processPlayerSpawnQueue();
+                processCreatureSpawnQueue();
+                processAsyncNpcCompositeResults();
+                processDeferredEquipmentQueue();
                 if (auto* cr = renderer ? renderer->getCharacterRenderer() : nullptr) {
                     cr->processPendingNormalMaps(4);
                 }
@@ -1265,7 +947,7 @@ void Application::update(float deltaTime) {
                         if (entity->getType() != game::ObjectType::UNIT) continue;
                         auto unit = std::dynamic_pointer_cast<game::Unit>(entity);
                         if (!unit || unit->getDisplayId() == 0) continue;
-                        if (entitySpawner_->isCreatureSpawned(guid) || entitySpawner_->isCreaturePending(guid)) continue;
+                        if (creatureInstances_.count(guid) || pendingCreatureSpawnGuids_.count(guid)) continue;
 
                         if (havePlayerPos) {
                             glm::vec3 pos(unit->getX(), unit->getY(), unit->getZ());
@@ -1274,22 +956,15 @@ void Application::update(float deltaTime) {
                             if (distSq > kResyncRadiusSq) continue;
                         }
 
-                        float retryScale = 1.0f;
-                        {
-                            using game::fieldIndex; using game::UF;
-                            uint16_t si = fieldIndex(UF::OBJECT_FIELD_SCALE_X);
-                            if (si != 0xFFFF) {
-                                uint32_t raw = unit->getField(si);
-                                if (raw != 0) {
-                                    float s2 = 1.0f;
-                                    std::memcpy(&s2, &raw, sizeof(float));
-                                    if (s2 > 0.01f && s2 < 100.0f) retryScale = s2;
-                                }
-                            }
-                        }
-                        entitySpawner_->queueCreatureSpawn(guid, unit->getDisplayId(),
-                            unit->getX(), unit->getY(), unit->getZ(),
-                            unit->getOrientation(), retryScale);
+                        PendingCreatureSpawn retrySpawn{};
+                        retrySpawn.guid = guid;
+                        retrySpawn.displayId = unit->getDisplayId();
+                        retrySpawn.x = unit->getX();
+                        retrySpawn.y = unit->getY();
+                        retrySpawn.z = unit->getZ();
+                        retrySpawn.orientation = unit->getOrientation();
+                        pendingCreatureSpawns_.push_back(retrySpawn);
+                        pendingCreatureSpawnGuids_.insert(guid);
                     }
                 }
             }
@@ -1297,12 +972,13 @@ void Application::update(float deltaTime) {
             inGameStep = "gameobject/transport queues";
             updateCheckpoint = "in_game: gameobject/transport queues";
             runInGameStage("gameobject/transport queues", [&] {
-                // GO/transport queues handled by entitySpawner_->update() above
+                processGameObjectSpawnQueue();
+                processPendingTransportDoodads();
             });
             inGameStep = "pending mount";
             updateCheckpoint = "in_game: pending mount";
             runInGameStage("processPendingMount", [&] {
-                // Mount processing handled by entitySpawner_->update() above
+                processPendingMount();
             });
             // Update 3D quest markers above NPCs
             inGameStep = "quest markers";
@@ -1316,42 +992,6 @@ void Application::update(float deltaTime) {
             runInGameStage("post-update sync", [&] {
                 if (renderer && gameHandler && renderer->getCameraController()) {
                     renderer->getCameraController()->setRunSpeedOverride(gameHandler->getServerRunSpeed());
-                    renderer->getCameraController()->setWalkSpeedOverride(gameHandler->getServerWalkSpeed());
-                    renderer->getCameraController()->setSwimSpeedOverride(gameHandler->getServerSwimSpeed());
-                    renderer->getCameraController()->setSwimBackSpeedOverride(gameHandler->getServerSwimBackSpeed());
-                    renderer->getCameraController()->setFlightSpeedOverride(gameHandler->getServerFlightSpeed());
-                    renderer->getCameraController()->setFlightBackSpeedOverride(gameHandler->getServerFlightBackSpeed());
-                    renderer->getCameraController()->setRunBackSpeedOverride(gameHandler->getServerRunBackSpeed());
-                    renderer->getCameraController()->setTurnRateOverride(gameHandler->getServerTurnRate());
-                    renderer->getCameraController()->setMovementRooted(gameHandler->isPlayerRooted());
-                    renderer->getCameraController()->setGravityDisabled(gameHandler->isGravityDisabled());
-                    renderer->getCameraController()->setFeatherFallActive(gameHandler->isFeatherFalling());
-                    renderer->getCameraController()->setWaterWalkActive(gameHandler->isWaterWalking());
-                    renderer->getCameraController()->setFlyingActive(gameHandler->isPlayerFlying());
-                    renderer->getCameraController()->setHoverActive(gameHandler->isHovering());
-
-                    // Sync camera forward pitch to movement packets during flight / swimming.
-                    // The server writes the pitch field when FLYING or SWIMMING flags are set;
-                    // without this sync it would always be 0 (horizontal), causing other
-                    // players to see the character flying flat even when pitching up/down.
-                    if (gameHandler->isPlayerFlying() || gameHandler->isSwimming()) {
-                        if (auto* cam = renderer->getCamera()) {
-                            glm::vec3 fwd = cam->getForward();
-                            float len = glm::length(fwd);
-                            if (len > 1e-4f) {
-                                float pitchRad = std::asin(std::clamp(fwd.z / len, -1.0f, 1.0f));
-                                gameHandler->setMovementPitch(pitchRad);
-                                // Tilt the mount/character model to match flight direction
-                                // (taxi flight uses setTaxiOrientationCallback for this instead)
-                                if (gameHandler->isPlayerFlying() && gameHandler->isMounted()) {
-                                    renderer->setMountPitchRoll(pitchRad, 0.0f);
-                                }
-                            }
-                        }
-                    } else if (gameHandler->isMounted()) {
-                        // Reset mount pitch when not flying
-                        renderer->setMountPitchRoll(0.0f, 0.0f);
-                    }
                 }
 
                 bool onTaxi = gameHandler &&
@@ -1359,15 +999,6 @@ void Application::update(float deltaTime) {
                                gameHandler->isTaxiMountActive() ||
                                gameHandler->isTaxiActivationPending());
                 bool onTransportNow = gameHandler && gameHandler->isOnTransport();
-                // Clear stale client-side transport state when the tracked transport no longer exists.
-                if (onTransportNow && gameHandler->getTransportManager()) {
-                    auto* currentTracked = gameHandler->getTransportManager()->getTransport(
-                        gameHandler->getPlayerTransportGuid());
-                    if (!currentTracked) {
-                        gameHandler->clearPlayerTransport();
-                        onTransportNow = false;
-                    }
-                }
                 // M2 transports (trams) use position-delta approach: player keeps normal
                 // movement and the transport's frame-to-frame delta is applied on top.
                 // Only WMO transports (ships) use full external-driven mode.
@@ -1477,8 +1108,8 @@ void Application::update(float deltaTime) {
                 // Taxi flights move fast (32 u/s) — load further ahead so terrain is ready
                 // before the camera arrives.  Keep updates frequent to spot new tiles early.
                 renderer->getTerrainManager()->setUpdateInterval(onTaxi ? 0.033f : 0.033f);
-                renderer->getTerrainManager()->setLoadRadius(onTaxi ? 8 : 4);
-                renderer->getTerrainManager()->setUnloadRadius(onTaxi ? 12 : 7);
+                renderer->getTerrainManager()->setLoadRadius(onTaxi ? 6 : 4);
+                renderer->getTerrainManager()->setUnloadRadius(onTaxi ? 9 : 7);
                 renderer->getTerrainManager()->setTaxiStreamingMode(onTaxi);
                 }
                 lastTaxiFlight_ = onTaxi;
@@ -1546,9 +1177,8 @@ void Application::update(float deltaTime) {
 
                     // Keep facing toward target and emit charge effect
                     glm::vec3 dir = chargeEndPos_ - chargeStartPos_;
-                    float dirLenSq = glm::dot(dir, dir);
-                    if (dirLenSq > 1e-4f) {
-                        dir *= glm::inversesqrt(dirLenSq);
+                    if (glm::length(dir) > 0.01f) {
+                        dir = glm::normalize(dir);
                         float yawDeg = glm::degrees(std::atan2(dir.x, dir.y));
                         renderer->setCharacterYaw(yawDeg);
                         renderer->emitChargeEffect(renderPos, dir);
@@ -1581,10 +1211,10 @@ void Application::update(float deltaTime) {
                                 glm::vec3 targetCanonical(targetEntity->getX(), targetEntity->getY(), targetEntity->getZ());
                                 glm::vec3 targetRender = core::coords::canonicalToRender(targetCanonical);
                                 glm::vec3 toTarget = targetRender - renderPos;
-                                float dSq = glm::dot(toTarget, toTarget);
-                                if (dSq > 2.25f) {
+                                float d = glm::length(toTarget);
+                                if (d > 1.5f) {
                                     // Place us 1.5 units from target (well within 8-unit melee range)
-                                    glm::vec3 snapPos = targetRender - toTarget * (1.5f * glm::inversesqrt(dSq));
+                                    glm::vec3 snapPos = targetRender - glm::normalize(toTarget) * 1.5f;
                                     renderer->getCharacterPosition() = snapPos;
                                     glm::vec3 snapCanonical = core::coords::renderToCanonical(snapPos);
                                     gameHandler->setPosition(snapCanonical.x, snapCanonical.y, snapCanonical.z);
@@ -1604,29 +1234,23 @@ void Application::update(float deltaTime) {
                 } else {
                     glm::vec3 renderPos = renderer->getCharacterPosition();
 
-                    // M2 transport riding: resolve in canonical space and lock once per frame.
-                    // This avoids visible jitter from mixed render/canonical delta application.
+                    // M2 transport riding: apply transport's frame-to-frame position delta
+                    // so the player moves with the tram while retaining normal movement input.
                     if (isM2Transport && gameHandler->getTransportManager()) {
                         auto* tr = gameHandler->getTransportManager()->getTransport(
                             gameHandler->getPlayerTransportGuid());
                         if (tr) {
-                            // Keep passenger locked to elevator vertical motion while grounded.
-                            // Without this, floor clamping can hold world-Z static unless the
-                            // player is jumping, which makes lifts appear to not move vertically.
-                            glm::vec3 tentativeCanonical = core::coords::renderToCanonical(renderPos);
-                            glm::vec3 localOffset = gameHandler->getPlayerTransportOffset();
-                            localOffset.x = tentativeCanonical.x - tr->position.x;
-                            localOffset.y = tentativeCanonical.y - tr->position.y;
-                            if (renderer->getCameraController() &&
-                                !renderer->getCameraController()->isGrounded()) {
-                                // While airborne (jump/fall), allow local Z offset to change.
-                                localOffset.z = tentativeCanonical.z - tr->position.z;
+                            static glm::vec3 lastTransportCanonical(0);
+                            static uint64_t lastTransportGuid = 0;
+                            if (lastTransportGuid == gameHandler->getPlayerTransportGuid()) {
+                                glm::vec3 deltaCanonical = tr->position - lastTransportCanonical;
+                                glm::vec3 deltaRender = core::coords::canonicalToRender(deltaCanonical)
+                                                      - core::coords::canonicalToRender(glm::vec3(0));
+                                renderPos += deltaRender;
+                                renderer->getCharacterPosition() = renderPos;
                             }
-                            gameHandler->setPlayerTransportOffset(localOffset);
-
-                            glm::vec3 lockedCanonical = tr->position + localOffset;
-                            renderPos = core::coords::canonicalToRender(lockedCanonical);
-                            renderer->getCharacterPosition() = renderPos;
+                            lastTransportCanonical = tr->position;
+                            lastTransportGuid = gameHandler->getPlayerTransportGuid();
                         }
                     }
 
@@ -1663,45 +1287,21 @@ void Application::update(float deltaTime) {
                     }
 
                     // Client-side transport boarding detection (for M2 transports like trams
-                    // and lifts where the server doesn't send transport attachment data).
-                    // Thunder Bluff elevators use model origins that can be far from the deck
-                    // the player stands on, so they need wider attachment bounds.
+                    // where the server doesn't send transport attachment data).
+                    // Use a generous AABB around each transport's current position.
                     if (gameHandler->getTransportManager() && !gameHandler->isOnTransport()) {
                         auto* tm = gameHandler->getTransportManager();
                         glm::vec3 playerCanonical = core::coords::renderToCanonical(renderPos);
-                        constexpr float kM2BoardHorizDistSq = 12.0f * 12.0f;
-                        constexpr float kM2BoardVertDist = 15.0f;
-                        constexpr float kTbLiftBoardHorizDistSq = 22.0f * 22.0f;
-                        constexpr float kTbLiftBoardVertDist = 14.0f;
 
-                        uint64_t bestGuid = 0;
-                        float bestScore = 1e30f;
                         for (auto& [guid, transport] : tm->getTransports()) {
                             if (!transport.isM2) continue;
-                            const bool isThunderBluffLift =
-                                (transport.entry >= 20649u && transport.entry <= 20657u);
-                            const float maxHorizDistSq = isThunderBluffLift
-                                ? kTbLiftBoardHorizDistSq
-                                : kM2BoardHorizDistSq;
-                            const float maxVertDist = isThunderBluffLift
-                                ? kTbLiftBoardVertDist
-                                : kM2BoardVertDist;
                             glm::vec3 diff = playerCanonical - transport.position;
                             float horizDistSq = diff.x * diff.x + diff.y * diff.y;
                             float vertDist = std::abs(diff.z);
-                            if (horizDistSq < maxHorizDistSq && vertDist < maxVertDist) {
-                                float score = horizDistSq + vertDist * vertDist;
-                                if (score < bestScore) {
-                                    bestScore = score;
-                                    bestGuid = guid;
-                                }
-                            }
-                        }
-                        if (bestGuid != 0) {
-                            auto* tr = tm->getTransport(bestGuid);
-                            if (tr) {
-                                gameHandler->setPlayerOnTransport(bestGuid, playerCanonical - tr->position);
-                                LOG_DEBUG("M2 transport boarding: guid=0x", std::hex, bestGuid, std::dec);
+                            if (horizDistSq < 144.0f && vertDist < 15.0f) {
+                                gameHandler->setPlayerOnTransport(guid, playerCanonical - transport.position);
+                                LOG_DEBUG("M2 transport boarding: guid=0x", std::hex, guid, std::dec);
+                                break;
                             }
                         }
                     }
@@ -1714,19 +1314,7 @@ void Application::update(float deltaTime) {
                             glm::vec3 playerCanonical = core::coords::renderToCanonical(renderPos);
                             glm::vec3 diff = playerCanonical - tr->position;
                             float horizDistSq = diff.x * diff.x + diff.y * diff.y;
-                            const bool isThunderBluffLift =
-                                (tr->entry >= 20649u && tr->entry <= 20657u);
-                            constexpr float kM2DisembarkHorizDistSq = 15.0f * 15.0f;
-                            constexpr float kTbLiftDisembarkHorizDistSq = 28.0f * 28.0f;
-                            constexpr float kM2DisembarkVertDist = 18.0f;
-                            constexpr float kTbLiftDisembarkVertDist = 16.0f;
-                            const float disembarkHorizDistSq = isThunderBluffLift
-                                ? kTbLiftDisembarkHorizDistSq
-                                : kM2DisembarkHorizDistSq;
-                            const float disembarkVertDist = isThunderBluffLift
-                                ? kTbLiftDisembarkVertDist
-                                : kM2DisembarkVertDist;
-                            if (horizDistSq > disembarkHorizDistSq || std::abs(diff.z) > disembarkVertDist) {
+                            if (horizDistSq > 225.0f) {
                                 gameHandler->clearPlayerTransport();
                                 LOG_DEBUG("M2 transport disembark");
                             }
@@ -1764,54 +1352,35 @@ void Application::update(float deltaTime) {
                     }
                 }
                 const float syncRadiusSq = 320.0f * 320.0f;
-                auto& _creatureInstances = entitySpawner_->getCreatureInstances();
-                auto& _creatureWeaponsAttached = entitySpawner_->getCreatureWeaponsAttached();
-                auto& _creatureWeaponAttachAttempts = entitySpawner_->getCreatureWeaponAttachAttempts();
-                auto& _creatureModelIds = entitySpawner_->getCreatureModelIds();
-                auto& _modelIdIsWolfLike = entitySpawner_->getModelIdIsWolfLike();
-                auto& _creatureRenderPosCache = entitySpawner_->getCreatureRenderPosCache();
-                auto& _creatureSwimmingState = entitySpawner_->getCreatureSwimmingState();
-                auto& _creatureWalkingState = entitySpawner_->getCreatureWalkingState();
-                auto& _creatureFlyingState = entitySpawner_->getCreatureFlyingState();
-                auto& _creatureWasMoving = entitySpawner_->getCreatureWasMoving();
-                auto& _creatureWasSwimming = entitySpawner_->getCreatureWasSwimming();
-                auto& _creatureWasFlying = entitySpawner_->getCreatureWasFlying();
-                auto& _creatureWasWalking = entitySpawner_->getCreatureWasWalking();
-                for (const auto& [guid, instanceId] : _creatureInstances) {
+                for (const auto& [guid, instanceId] : creatureInstances_) {
                     auto entity = gameHandler->getEntityManager().getEntity(guid);
                     if (!entity || entity->getType() != game::ObjectType::UNIT) continue;
 
                     if (npcWeaponRetryTick &&
-                        weaponAttachesThisTick < EntitySpawner::MAX_WEAPON_ATTACHES_PER_TICK &&
-                        !_creatureWeaponsAttached.count(guid)) {
+                        weaponAttachesThisTick < MAX_WEAPON_ATTACHES_PER_TICK &&
+                        !creatureWeaponsAttached_.count(guid)) {
                         uint8_t attempts = 0;
-                        auto itAttempts = _creatureWeaponAttachAttempts.find(guid);
-                        if (itAttempts != _creatureWeaponAttachAttempts.end()) attempts = itAttempts->second;
+                        auto itAttempts = creatureWeaponAttachAttempts_.find(guid);
+                        if (itAttempts != creatureWeaponAttachAttempts_.end()) attempts = itAttempts->second;
                         if (attempts < 30) {
                             weaponAttachesThisTick++;
-                            if (entitySpawner_->tryAttachCreatureVirtualWeapons(guid, instanceId)) {
-                                _creatureWeaponsAttached.insert(guid);
-                                _creatureWeaponAttachAttempts.erase(guid);
+                            if (tryAttachCreatureVirtualWeapons(guid, instanceId)) {
+                                creatureWeaponsAttached_.insert(guid);
+                                creatureWeaponAttachAttempts_.erase(guid);
                             } else {
-                                _creatureWeaponAttachAttempts[guid] = static_cast<uint8_t>(attempts + 1);
+                                creatureWeaponAttachAttempts_[guid] = static_cast<uint8_t>(attempts + 1);
                             }
                         }
                     }
 
-                    // Distance check uses getLatestX/Y/Z (server-authoritative destination) to
-                    // avoid false-culling entities that moved while getX/Y/Z was stale.
-                    // Position sync still uses getX/Y/Z to preserve smooth interpolation for
-                    // nearby entities; distant entities (> 150u) have planarDist≈0 anyway
-                    // so the renderer remains driven correctly by creatureMoveCallback_.
-                    glm::vec3 latestCanonical(entity->getLatestX(), entity->getLatestY(), entity->getLatestZ());
+                    glm::vec3 canonical(entity->getX(), entity->getY(), entity->getZ());
                     float canonDistSq = 0.0f;
                     if (havePlayerPos) {
-                        glm::vec3 d = latestCanonical - playerPos;
+                        glm::vec3 d = canonical - playerPos;
                         canonDistSq = glm::dot(d, d);
                         if (canonDistSq > syncRadiusSq) continue;
                     }
 
-                    glm::vec3 canonical(entity->getX(), entity->getY(), entity->getZ());
                     glm::vec3 renderPos = core::coords::canonicalToRender(canonical);
 
                     // Visual collision guard: keep hostile melee units from rendering inside the
@@ -1846,11 +1415,11 @@ void Application::update(float deltaTime) {
 
                         // Species/model-specific spacing for wolf-like creatures (their lunge anims
                         // often put head/torso inside the player capsule).
-                        auto mit = _creatureModelIds.find(guid);
-                        if (mit != _creatureModelIds.end()) {
+                        auto mit = creatureModelIds_.find(guid);
+                        if (mit != creatureModelIds_.end()) {
                             uint32_t mid = mit->second;
-                            auto wolfIt = _modelIdIsWolfLike.find(mid);
-                            if (wolfIt == _modelIdIsWolfLike.end()) {
+                            auto wolfIt = modelIdIsWolfLike_.find(mid);
+                            if (wolfIt == modelIdIsWolfLike_.end()) {
                                 bool isWolf = false;
                                 if (const auto* md = charRenderer->getModelData(mid)) {
                                     std::string modelName = md->name;
@@ -1859,7 +1428,7 @@ void Application::update(float deltaTime) {
                                     isWolf = (modelName.find("wolf") != std::string::npos ||
                                               modelName.find("worg") != std::string::npos);
                                 }
-                                wolfIt = _modelIdIsWolfLike.emplace(mid, isWolf).first;
+                                wolfIt = modelIdIsWolfLike_.emplace(mid, isWolf).first;
                             }
                             if (wolfIt->second) {
                                 minSep = std::max(minSep, 2.45f);
@@ -1879,85 +1448,27 @@ void Application::update(float deltaTime) {
                         }
                     }
 
-                    auto posIt = _creatureRenderPosCache.find(guid);
-                    if (posIt == _creatureRenderPosCache.end()) {
+                    auto posIt = creatureRenderPosCache_.find(guid);
+                    if (posIt == creatureRenderPosCache_.end()) {
                         charRenderer->setInstancePosition(instanceId, renderPos);
-                        _creatureRenderPosCache[guid] = renderPos;
+                        creatureRenderPosCache_[guid] = renderPos;
                     } else {
                         const glm::vec3 prevPos = posIt->second;
-                        float ddx2 = renderPos.x - prevPos.x;
-                        float ddy2 = renderPos.y - prevPos.y;
-                        float planarDistSq = ddx2 * ddx2 + ddy2 * ddy2;
+                        const glm::vec2 delta2(renderPos.x - prevPos.x, renderPos.y - prevPos.y);
+                        float planarDist = glm::length(delta2);
                         float dz = std::abs(renderPos.z - prevPos.z);
 
                         auto unitPtr = std::static_pointer_cast<game::Unit>(entity);
                         const bool deadOrCorpse = unitPtr->getHealth() == 0;
-                        const bool largeCorrection = (planarDistSq > 36.0f) || (dz > 3.0f);
-                        // isEntityMoving() reflects server-authoritative move state set by
-                        // startMoveTo() in handleMonsterMove, regardless of distance-cull.
-                        // This correctly detects movement for distant creatures (> 150u)
-                        // where updateMovement() is not called and getX/Y/Z() stays stale.
-                        // Use isActivelyMoving() (not isEntityMoving()) so the
-                        // Run/Walk animation stops when the creature reaches its
-                        // destination, rather than persisting through the dead-
-                        // reckoning overrun window.
-                        const bool entityIsMoving = entity->isActivelyMoving();
-                        constexpr float kMoveThreshSq = 0.03f * 0.03f;
-                        const bool isMovingNow = !deadOrCorpse && (entityIsMoving || planarDistSq > kMoveThreshSq || dz > 0.08f);
+                        const bool largeCorrection = (planarDist > 6.0f) || (dz > 3.0f);
                         if (deadOrCorpse || largeCorrection) {
                             charRenderer->setInstancePosition(instanceId, renderPos);
-                        } else if (planarDistSq > kMoveThreshSq || dz > 0.08f) {
-                            // Position changed in entity coords → drive renderer toward it.
-                            float planarDist = std::sqrt(planarDistSq);
+                        } else if (planarDist > 0.03f || dz > 0.08f) {
+                            // Use movement interpolation so step/run animation can play.
                             float duration = std::clamp(planarDist / 5.5f, 0.05f, 0.22f);
                             charRenderer->moveInstanceTo(instanceId, renderPos, duration);
                         }
-                        // When entity is moving but getX/Y/Z is stale (distance-culled),
-                        // don't call moveInstanceTo — creatureMoveCallback_ already drove
-                        // the renderer to the correct destination via the spline packet.
                         posIt->second = renderPos;
-
-                        // Drive movement animation: Walk/Run/Swim (4/5/42) when moving,
-                        // Stand/SwimIdle (0/41) when idle. Walk(4) selected when WALKING flag is set.
-                        // WoW M2 animation IDs: 4=Walk, 5=Run, 41=SwimIdle, 42=Swim.
-                        // Only switch on transitions to avoid resetting animation time.
-                        // Don't override Death (1) animation.
-                        const bool isSwimmingNow = _creatureSwimmingState.count(guid) > 0;
-                        const bool isWalkingNow  = _creatureWalkingState.count(guid) > 0;
-                        const bool isFlyingNow   = _creatureFlyingState.count(guid) > 0;
-                        bool prevMoving   = _creatureWasMoving[guid];
-                        bool prevSwimming = _creatureWasSwimming[guid];
-                        bool prevFlying   = _creatureWasFlying[guid];
-                        bool prevWalking  = _creatureWasWalking[guid];
-                        // Trigger animation update on any locomotion-state transition, not just
-                        // moving/idle — e.g. creature lands while still moving → FlyForward→Run,
-                        // or server changes WALKING flag while creature is already running → Walk.
-                        const bool stateChanged = (isMovingNow  != prevMoving)   ||
-                                                  (isSwimmingNow != prevSwimming) ||
-                                                  (isFlyingNow   != prevFlying)   ||
-                                                  (isWalkingNow  != prevWalking && isMovingNow);
-                        if (stateChanged) {
-                            _creatureWasMoving[guid]   = isMovingNow;
-                            _creatureWasSwimming[guid] = isSwimmingNow;
-                            _creatureWasFlying[guid]   = isFlyingNow;
-                            _creatureWasWalking[guid]  = isWalkingNow;
-                            uint32_t curAnimId = 0; float curT = 0.0f, curDur = 0.0f;
-                            bool gotState = charRenderer->getAnimationState(instanceId, curAnimId, curT, curDur);
-                            if (!gotState || curAnimId != rendering::anim::DEATH) {
-                                uint32_t targetAnim;
-                                if (isMovingNow) {
-                                    if (isFlyingNow)        targetAnim = rendering::anim::FLY_FORWARD;
-                                    else if (isSwimmingNow) targetAnim = rendering::anim::SWIM;
-                                    else if (isWalkingNow)  targetAnim = rendering::anim::WALK;
-                                    else                    targetAnim = rendering::anim::RUN;
-                                } else {
-                                    if (isFlyingNow)        targetAnim = rendering::anim::FLY_IDLE;
-                                    else if (isSwimmingNow) targetAnim = rendering::anim::SWIM_IDLE;
-                                    else                    targetAnim = rendering::anim::STAND;
-                                }
-                                charRenderer->playAnimation(instanceId, targetAnim, /*loop=*/true);
-                            }
-                        }
                     }
                     float renderYaw = entity->getOrientation() + glm::radians(90.0f);
                     charRenderer->setInstanceRotation(instanceId, glm::vec3(0.0f, 0.0f, renderYaw));
@@ -1968,123 +1479,7 @@ void Application::update(float deltaTime) {
                     std::chrono::steady_clock::now() - creatureSyncStart).count();
                 if (csMs > 5.0f) {
                     LOG_WARNING("SLOW update stage 'creature render sync': ", csMs, "ms (",
-                                entitySpawner_->getCreatureInstances().size(), " creatures)");
-                }
-            }
-
-            // --- Online player render sync (position, orientation, animation) ---
-            // Mirrors the creature sync loop above but without collision guard or
-            // weapon-attach logic.  Without this, online players never transition
-            // back to Stand after movement stops ("run in place" bug).
-            auto playerSyncStart = std::chrono::steady_clock::now();
-            if (renderer && gameHandler && renderer->getCharacterRenderer()) {
-                auto* charRenderer = renderer->getCharacterRenderer();
-                glm::vec3 pPos(0.0f);
-                bool havePPos = false;
-                if (auto pe = gameHandler->getEntityManager().getEntity(gameHandler->getPlayerGuid())) {
-                    pPos = glm::vec3(pe->getX(), pe->getY(), pe->getZ());
-                    havePPos = true;
-                }
-                const float pSyncRadiusSq = 320.0f * 320.0f;
-
-                auto& _playerInstances = entitySpawner_->getPlayerInstances();
-                auto& _pCreatureWasMoving = entitySpawner_->getCreatureWasMoving();
-                auto& _pCreatureWasSwimming = entitySpawner_->getCreatureWasSwimming();
-                auto& _pCreatureWasFlying = entitySpawner_->getCreatureWasFlying();
-                auto& _pCreatureWasWalking = entitySpawner_->getCreatureWasWalking();
-                auto& _pCreatureSwimmingState = entitySpawner_->getCreatureSwimmingState();
-                auto& _pCreatureWalkingState = entitySpawner_->getCreatureWalkingState();
-                auto& _pCreatureFlyingState = entitySpawner_->getCreatureFlyingState();
-                auto& _pCreatureRenderPosCache = entitySpawner_->getCreatureRenderPosCache();
-                for (const auto& [guid, instanceId] : _playerInstances) {
-                    auto entity = gameHandler->getEntityManager().getEntity(guid);
-                    if (!entity || entity->getType() != game::ObjectType::PLAYER) continue;
-
-                    // Distance cull
-                    if (havePPos) {
-                        glm::vec3 latestCanonical(entity->getLatestX(), entity->getLatestY(), entity->getLatestZ());
-                        glm::vec3 d = latestCanonical - pPos;
-                        if (glm::dot(d, d) > pSyncRadiusSq) continue;
-                    }
-
-                    // Position sync
-                    glm::vec3 canonical(entity->getX(), entity->getY(), entity->getZ());
-                    glm::vec3 renderPos = core::coords::canonicalToRender(canonical);
-
-                    auto posIt = _pCreatureRenderPosCache.find(guid);
-                    if (posIt == _pCreatureRenderPosCache.end()) {
-                        charRenderer->setInstancePosition(instanceId, renderPos);
-                        _pCreatureRenderPosCache[guid] = renderPos;
-                    } else {
-                        const glm::vec3 prevPos = posIt->second;
-                        float ddx2 = renderPos.x - prevPos.x;
-                        float ddy2 = renderPos.y - prevPos.y;
-                        float planarDistSq = ddx2 * ddx2 + ddy2 * ddy2;
-                        float dz = std::abs(renderPos.z - prevPos.z);
-
-                        auto unitPtr = std::static_pointer_cast<game::Unit>(entity);
-                        const bool deadOrCorpse = unitPtr->getHealth() == 0;
-                        const bool largeCorrection = (planarDistSq > 36.0f) || (dz > 3.0f);
-                        const bool entityIsMoving = entity->isActivelyMoving();
-                        constexpr float kMoveThreshSq2 = 0.03f * 0.03f;
-                        const bool isMovingNow = !deadOrCorpse && (entityIsMoving || planarDistSq > kMoveThreshSq2 || dz > 0.08f);
-
-                        if (deadOrCorpse || largeCorrection) {
-                            charRenderer->setInstancePosition(instanceId, renderPos);
-                        } else if (planarDistSq > kMoveThreshSq2 || dz > 0.08f) {
-                            float planarDist = std::sqrt(planarDistSq);
-                            float duration = std::clamp(planarDist / 5.5f, 0.05f, 0.22f);
-                            charRenderer->moveInstanceTo(instanceId, renderPos, duration);
-                        }
-                        posIt->second = renderPos;
-
-                        // Drive movement animation (same logic as creatures)
-                        const bool isSwimmingNow = _pCreatureSwimmingState.count(guid) > 0;
-                        const bool isWalkingNow  = _pCreatureWalkingState.count(guid) > 0;
-                        const bool isFlyingNow   = _pCreatureFlyingState.count(guid) > 0;
-                        bool prevMoving   = _pCreatureWasMoving[guid];
-                        bool prevSwimming = _pCreatureWasSwimming[guid];
-                        bool prevFlying   = _pCreatureWasFlying[guid];
-                        bool prevWalking  = _pCreatureWasWalking[guid];
-                        const bool stateChanged = (isMovingNow  != prevMoving)   ||
-                                                  (isSwimmingNow != prevSwimming) ||
-                                                  (isFlyingNow   != prevFlying)   ||
-                                                  (isWalkingNow  != prevWalking && isMovingNow);
-                        if (stateChanged) {
-                            _pCreatureWasMoving[guid]   = isMovingNow;
-                            _pCreatureWasSwimming[guid] = isSwimmingNow;
-                            _pCreatureWasFlying[guid]   = isFlyingNow;
-                            _pCreatureWasWalking[guid]  = isWalkingNow;
-                            uint32_t curAnimId = 0; float curT = 0.0f, curDur = 0.0f;
-                            bool gotState = charRenderer->getAnimationState(instanceId, curAnimId, curT, curDur);
-                            if (!gotState || curAnimId != rendering::anim::DEATH) {
-                                uint32_t targetAnim;
-                                if (isMovingNow) {
-                                    if (isFlyingNow)        targetAnim = rendering::anim::FLY_FORWARD;
-                                    else if (isSwimmingNow) targetAnim = rendering::anim::SWIM;
-                                    else if (isWalkingNow)  targetAnim = rendering::anim::WALK;
-                                    else                    targetAnim = rendering::anim::RUN;
-                                } else {
-                                    if (isFlyingNow)        targetAnim = rendering::anim::FLY_IDLE;
-                                    else if (isSwimmingNow) targetAnim = rendering::anim::SWIM_IDLE;
-                                    else                    targetAnim = rendering::anim::STAND;
-                                }
-                                charRenderer->playAnimation(instanceId, targetAnim, /*loop=*/true);
-                            }
-                        }
-                    }
-
-                    // Orientation sync
-                    float renderYaw = entity->getOrientation() + glm::radians(90.0f);
-                    charRenderer->setInstanceRotation(instanceId, glm::vec3(0.0f, 0.0f, renderYaw));
-                }
-            }
-            {
-                float psMs = std::chrono::duration<float, std::milli>(
-                    std::chrono::steady_clock::now() - playerSyncStart).count();
-                if (psMs > 5.0f) {
-                    LOG_WARNING("SLOW update stage 'player render sync': ", psMs, "ms (",
-                                entitySpawner_->getPlayerInstances().size(), " players)");
+                                creatureInstances_.size(), " creatures)");
                 }
             }
 
@@ -2106,11 +1501,6 @@ void Application::update(float deltaTime) {
             break;
     }
 
-    // Process any pending world entry request via WorldLoader
-    if (worldLoader_ && state != AppState::DISCONNECTED) {
-        worldLoader_->processPendingEntry();
-    }
-
     // Update renderer (camera, etc.) only when in-game
     updateCheckpoint = "renderer update";
     if (renderer && state == AppState::IN_GAME) {
@@ -2199,8 +1589,7 @@ void Application::setupUICallbacks() {
         size_t colonPos = realmAddress.find(':');
         if (colonPos != std::string::npos) {
             host = realmAddress.substr(0, colonPos);
-            try { port = static_cast<uint16_t>(std::stoi(realmAddress.substr(colonPos + 1))); }
-            catch (...) { LOG_WARNING("Invalid port in realm address: ", realmAddress); }
+            port = static_cast<uint16_t>(std::stoi(realmAddress.substr(colonPos + 1)));
         }
 
         // Connect to world server
@@ -2298,83 +1687,16 @@ void Application::setupUICallbacks() {
     });
 
     // World entry callback (online mode) - load terrain when entering world
-    gameHandler->setWorldEntryCallback([this](uint32_t mapId, float x, float y, float z, bool isInitialEntry) {
-        LOG_INFO("Online world entry: mapId=", mapId, " pos=(", x, ", ", y, ", ", z, ")"
-                 " initial=", isInitialEntry);
-        if (renderer) {
-            renderer->resetCombatVisualState();
-        }
+    gameHandler->setWorldEntryCallback([this](uint32_t mapId, float x, float y, float z) {
+        LOG_INFO("Online world entry: mapId=", mapId, " pos=(", x, ", ", y, ", ", z, ")");
 
-        // Reconnect to the same map: terrain stays loaded but all online entities are stale.
-        // Despawn them properly so the server's fresh CREATE_OBJECTs will re-populate the world.
-        uint32_t currentLoadedMap = worldLoader_ ? worldLoader_->getLoadedMapId() : 0xFFFFFFFF;
-        if (entitySpawner_ && mapId == currentLoadedMap && renderer && renderer->getTerrainManager() && isInitialEntry) {
-            LOG_INFO("Reconnect to same map ", mapId, ": clearing stale online entities (terrain preserved)");
-
-            // Pending spawn queues and failure caches — clear so previously-failed GUIDs can retry.
-            // Dead creature guids will be re-populated from fresh server state.
-            entitySpawner_->clearAllQueues();
-
-            // Properly despawn all tracked instances from the renderer
-            entitySpawner_->despawnAllCreatures();
-            entitySpawner_->despawnAllPlayers();
-            entitySpawner_->despawnAllGameObjects();
-
-            // Update player position and re-queue nearby tiles (same logic as teleport)
-            glm::vec3 canonical = core::coords::serverToCanonical(glm::vec3(x, y, z));
-            glm::vec3 renderPos = core::coords::canonicalToRender(canonical);
-            renderer->getCharacterPosition() = renderPos;
-            if (renderer->getCameraController()) {
-                auto* ft = renderer->getCameraController()->getFollowTargetMutable();
-                if (ft) *ft = renderPos;
-                renderer->getCameraController()->clearMovementInputs();
-                renderer->getCameraController()->suppressMovementFor(1.0f);
-                renderer->getCameraController()->suspendGravityFor(10.0f);
-            }
-            worldEntryMovementGraceTimer_ = 2.0f;
-            taxiLandingClampTimer_ = 0.0f;
-            lastTaxiFlight_ = false;
-            renderer->getTerrainManager()->processReadyTiles();
-            {
-                auto [tileX, tileY] = core::coords::worldToTile(renderPos.x, renderPos.y);
-                std::vector<std::pair<int,int>> nearbyTiles;
-                nearbyTiles.reserve(289);
-                for (int dy = -8; dy <= 8; dy++)
-                    for (int dx = -8; dx <= 8; dx++)
-                        nearbyTiles.push_back({tileX + dx, tileY + dy});
-                renderer->getTerrainManager()->precacheTiles(nearbyTiles);
-            }
-            return;
-        }
-
-        // Same-map teleport (taxi landing, GM teleport, hearthstone on same continent):
-        if (mapId == currentLoadedMap && renderer && renderer->getTerrainManager()) {
-            // Check if teleport is far enough to need terrain loading (>500 render units)
-            glm::vec3 oldPos = renderer->getCharacterPosition();
-            glm::vec3 canonical = core::coords::serverToCanonical(glm::vec3(x, y, z));
-            glm::vec3 renderPos = core::coords::canonicalToRender(canonical);
-            float teleportDistSq = glm::dot(renderPos - oldPos, renderPos - oldPos);
-            bool farTeleport = (teleportDistSq > 500.0f * 500.0f);
-
-            if (farTeleport) {
-                // Far same-map teleport (hearthstone, etc.): defer full world reload
-                // to next frame to avoid blocking the packet handler for 20+ seconds.
-                LOG_WARNING("Far same-map teleport (dist=", std::sqrt(teleportDistSq),
-                            "), deferring world reload to next frame");
-                // Update position immediately so the player doesn't keep moving at old location
-                renderer->getCharacterPosition() = renderPos;
-                if (renderer->getCameraController()) {
-                    auto* ft = renderer->getCameraController()->getFollowTargetMutable();
-                    if (ft) *ft = renderPos;
-                    renderer->getCameraController()->clearMovementInputs();
-                    renderer->getCameraController()->suppressMovementFor(1.0f);
-                renderer->getCameraController()->suspendGravityFor(10.0f);
-                }
-                if (worldLoader_) worldLoader_->setPendingEntry(mapId, x, y, z);
-                return;
-            }
+        // Same-map teleport (taxi landing, GM teleport on same continent):
+        // just update position, let terrain streamer handle tile loading incrementally.
+        // A full reload is only needed on first entry or map change.
+        if (mapId == loadedMapId_ && renderer && renderer->getTerrainManager()) {
             LOG_INFO("Same-map teleport (map ", mapId, "), skipping full world reload");
-            // canonical and renderPos already computed above for distance check
+            glm::vec3 canonical = core::coords::serverToCanonical(glm::vec3(x, y, z));
+            glm::vec3 renderPos = core::coords::canonicalToRender(canonical);
             renderer->getCharacterPosition() = renderPos;
             if (renderer->getCameraController()) {
                 auto* ft = renderer->getCameraController()->getFollowTargetMutable();
@@ -2388,45 +1710,29 @@ void Application::setupUICallbacks() {
                 renderer->getCameraController()->clearMovementInputs();
                 renderer->getCameraController()->suppressMovementFor(0.5f);
             }
-            // Kick off async upload for any tiles that finished background
-            // parsing.  Use the bounded processReadyTiles() instead of
-            // processAllReadyTiles() to avoid multi-second main-thread stalls
-            // when many tiles are ready (the rest will finalize over subsequent
-            // frames via the normal terrain update loop).
-            renderer->getTerrainManager()->processReadyTiles();
-
-            // Queue all remaining tiles within the load radius (8 tiles = 17x17)
-            // at the new position. precacheTiles skips already-loaded/pending tiles,
-            // so this only enqueues tiles that aren't yet in the pipeline.
-            // This ensures background workers immediately start loading everything
-            // visible from the new position (hearthstone may land far from old location).
-            {
-                auto [tileX, tileY] = core::coords::worldToTile(renderPos.x, renderPos.y);
-                std::vector<std::pair<int,int>> nearbyTiles;
-                nearbyTiles.reserve(289);
-                for (int dy = -8; dy <= 8; dy++)
-                    for (int dx = -8; dx <= 8; dx++)
-                        nearbyTiles.push_back({tileX + dx, tileY + dy});
-                renderer->getTerrainManager()->precacheTiles(nearbyTiles);
-            }
             return;
         }
 
         // If a world load is already in progress (re-entrant call from
         // gameHandler->update() processing SMSG_NEW_WORLD during warmup),
-        // defer this entry. The current load will pick it up when it finishes.
-        if (worldLoader_ && worldLoader_->isLoadingWorld()) {
+        // defer this entry.  The current load will pick it up when it finishes.
+        if (loadingWorld_) {
             LOG_WARNING("World entry deferred: map ", mapId, " while loading (will process after current load)");
-            worldLoader_->setPendingEntry(mapId, x, y, z);
+            pendingWorldEntry_ = {mapId, x, y, z};
             return;
         }
 
-        // Full world loads are expensive and `loadOnlineWorldTerrain()` itself
-        // drives `gameHandler->update()` during warmup. Queue the load here so
-        // it runs after the current packet handler returns instead of recursing
-        // from `SMSG_LOGIN_VERIFY_WORLD` / `SMSG_NEW_WORLD`.
-        LOG_WARNING("Queued world entry: map ", mapId, " pos=(", x, ", ", y, ", ", z, ")");
-        if (worldLoader_) worldLoader_->setPendingEntry(mapId, x, y, z);
+        worldEntryMovementGraceTimer_ = 2.0f;
+        taxiLandingClampTimer_ = 0.0f;
+        lastTaxiFlight_ = false;
+        // Stop any movement that was active before the teleport
+        if (renderer && renderer->getCameraController()) {
+            renderer->getCameraController()->clearMovementInputs();
+            renderer->getCameraController()->suppressMovementFor(1.0f);
+        }
+        loadOnlineWorldTerrain(mapId, x, y, z);
+        // loadedMapId_ is set inside loadOnlineWorldTerrain (including
+        // any deferred entries it processes), so we must NOT override it here.
     });
 
     auto sampleBestFloorAt = [this](float x, float y, float probeZ) -> std::optional<float> {
@@ -2644,67 +1950,16 @@ void Application::setupUICallbacks() {
         LOG_INFO("Bindpoint set: mapId=", mapId, " pos=(", x, ", ", y, ", ", z, ")");
     });
 
-    // Hearthstone preload callback: begin loading terrain at the bind point as soon as
-    // the player starts casting Hearthstone.  The ~10 s cast gives enough time for
-    // the background streaming workers to bring tiles into the cache so the player
-    // lands on solid ground instead of falling through un-loaded terrain.
-    gameHandler->setHearthstonePreloadCallback([this](uint32_t mapId, float x, float y, float z) {
-        if (!renderer || !assetManager) return;
-
-        auto* terrainMgr = renderer->getTerrainManager();
-        if (!terrainMgr) return;
-
-        // Resolve map name from the cached Map.dbc table
-        std::string mapName;
-        if (worldLoader_) {
-            mapName = worldLoader_->getMapNameById(mapId);
-        }
-        if (mapName.empty()) {
-            mapName = WorldLoader::mapIdToName(mapId);
-        }
-        if (mapName.empty()) mapName = "Azeroth";
-
-        uint32_t currentLoadedMap = worldLoader_ ? worldLoader_->getLoadedMapId() : 0xFFFFFFFF;
-        if (mapId == currentLoadedMap) {
-            // Same map: pre-enqueue tiles around the bind point so workers start
-            // loading them now. Uses render-space coords (canonicalToRender).
-            // Use radius 4 (9x9=81 tiles) — hearthstone cast is ~10s, enough time
-            // for workers to parse most of these before the player arrives.
-            glm::vec3 renderPos = core::coords::canonicalToRender(glm::vec3(x, y, z));
-            auto [tileX, tileY] = core::coords::worldToTile(renderPos.x, renderPos.y);
-
-            std::vector<std::pair<int,int>> tiles;
-            tiles.reserve(81);
-            for (int dy = -4; dy <= 4; dy++)
-                for (int dx = -4; dx <= 4; dx++)
-                    tiles.push_back({tileX + dx, tileY + dy});
-
-            terrainMgr->precacheTiles(tiles);
-            LOG_INFO("Hearthstone preload: enqueued ", tiles.size(),
-                     " tiles around bind point (same map) tile=[", tileX, ",", tileY, "]");
-        } else {
-            // Different map: warm the file cache so ADT parsing is fast when
-            // loadOnlineWorldTerrain runs its blocking load loop.
-            // homeBindPos_ is canonical; startWorldPreload expects server coords.
-            glm::vec3 server = core::coords::canonicalToServer(glm::vec3(x, y, z));
-            if (worldLoader_) {
-                worldLoader_->startWorldPreload(mapId, mapName, server.x, server.y);
-            }
-            LOG_INFO("Hearthstone preload: started file cache warm for map '", mapName,
-                     "' (id=", mapId, ")");
-        }
-    });
-
     // Faction hostility map is built in buildFactionHostilityMap() when character enters world
 
     // Creature spawn callback (online mode) - spawn creature models
-    gameHandler->setCreatureSpawnCallback([this](uint64_t guid, uint32_t displayId, float x, float y, float z, float orientation, float scale) {
-        if (!entitySpawner_) return;
+    gameHandler->setCreatureSpawnCallback([this](uint64_t guid, uint32_t displayId, float x, float y, float z, float orientation) {
         // Queue spawns to avoid hanging when many creatures appear at once.
         // Deduplicate so repeated updates don't flood pending queue.
-        if (entitySpawner_->isCreatureSpawned(guid)) return;
-        if (entitySpawner_->isCreaturePending(guid)) return;
-        entitySpawner_->queueCreatureSpawn(guid, displayId, x, y, z, orientation, scale);
+        if (creatureInstances_.count(guid)) return;
+        if (pendingCreatureSpawnGuids_.count(guid)) return;
+        pendingCreatureSpawns_.push_back({guid, displayId, x, y, z, orientation});
+        pendingCreatureSpawnGuids_.insert(guid);
     });
 
     // Player spawn callback (online mode) - spawn player models with correct textures
@@ -2715,10 +1970,6 @@ void Application::setupUICallbacks() {
                                               uint32_t appearanceBytes,
                                               uint8_t facialFeatures,
                                               float x, float y, float z, float orientation) {
-        if (!entitySpawner_) return;
-        LOG_WARNING("playerSpawnCallback: guid=0x", std::hex, guid, std::dec,
-                    " race=", static_cast<int>(raceId), " gender=", static_cast<int>(genderId),
-                    " pos=(", x, ",", y, ",", z, ")");
         // Skip local player — already spawned as the main character
         uint64_t localGuid = gameHandler ? gameHandler->getPlayerGuid() : 0;
         uint64_t activeGuid = gameHandler ? gameHandler->getActiveCharacterGuid() : 0;
@@ -2727,110 +1978,53 @@ void Application::setupUICallbacks() {
             (spawnedPlayerGuid_ != 0 && guid == spawnedPlayerGuid_)) {
             return;
         }
-        if (entitySpawner_->isPlayerSpawned(guid)) return;
-        if (entitySpawner_->isPlayerPending(guid)) return;
-        entitySpawner_->queuePlayerSpawn(guid, raceId, genderId, appearanceBytes, facialFeatures, x, y, z, orientation);
+        if (playerInstances_.count(guid)) return;
+        if (pendingPlayerSpawnGuids_.count(guid)) return;
+        pendingPlayerSpawns_.push_back({guid, raceId, genderId, appearanceBytes, facialFeatures, x, y, z, orientation});
+        pendingPlayerSpawnGuids_.insert(guid);
     });
 
     // Online player equipment callback - apply armor geosets/skin overlays per player instance.
     gameHandler->setPlayerEquipmentCallback([this](uint64_t guid,
                                                   const std::array<uint32_t, 19>& displayInfoIds,
                                                   const std::array<uint8_t, 19>& inventoryTypes) {
-        if (!entitySpawner_) return;
         // Queue equipment compositing instead of doing it immediately —
         // compositeWithRegions is expensive (file I/O + CPU blit + GPU upload)
         // and causes frame stutters if multiple players update at once.
-        entitySpawner_->queuePlayerEquipment(guid, displayInfoIds, inventoryTypes);
+        deferredEquipmentQueue_.push_back({guid, {displayInfoIds, inventoryTypes}});
     });
 
     // Creature despawn callback (online mode) - remove creature models
     gameHandler->setCreatureDespawnCallback([this](uint64_t guid) {
-        if (!entitySpawner_) return;
-        entitySpawner_->despawnCreature(guid);
+        despawnOnlineCreature(guid);
     });
 
     gameHandler->setPlayerDespawnCallback([this](uint64_t guid) {
-        if (!entitySpawner_) return;
-        entitySpawner_->despawnPlayer(guid);
+        despawnOnlinePlayer(guid);
     });
 
     // GameObject spawn callback (online mode) - spawn static models (mailboxes, etc.)
-    gameHandler->setGameObjectSpawnCallback([this](uint64_t guid, uint32_t entry, uint32_t displayId, float x, float y, float z, float orientation, float scale) {
-        if (!entitySpawner_) return;
-        entitySpawner_->queueGameObjectSpawn(guid, entry, displayId, x, y, z, orientation, scale);
+    gameHandler->setGameObjectSpawnCallback([this](uint64_t guid, uint32_t entry, uint32_t displayId, float x, float y, float z, float orientation) {
+        pendingGameObjectSpawns_.push_back({guid, entry, displayId, x, y, z, orientation});
     });
 
     // GameObject despawn callback (online mode) - remove static models
     gameHandler->setGameObjectDespawnCallback([this](uint64_t guid) {
-        if (!entitySpawner_) return;
-        entitySpawner_->despawnGameObject(guid);
+        despawnOnlineGameObject(guid);
     });
 
     // GameObject custom animation callback (e.g. chest opening)
-    gameHandler->setGameObjectCustomAnimCallback([this](uint64_t guid, uint32_t animId) {
-        if (!entitySpawner_ || !renderer) return;
-        auto& goInstances = entitySpawner_->getGameObjectInstances();
-        auto it = goInstances.find(guid);
-        if (it == goInstances.end()) return;
+    gameHandler->setGameObjectCustomAnimCallback([this](uint64_t guid, uint32_t /*animId*/) {
+        auto it = gameObjectInstances_.find(guid);
+        if (it == gameObjectInstances_.end() || !renderer) return;
         auto& info = it->second;
         if (!info.isWmo) {
             if (auto* m2r = renderer->getM2Renderer()) {
-                // Play the custom animation as a one-shot if model supports it
-                if (m2r->hasAnimation(info.instanceId, animId))
-                    m2r->setInstanceAnimation(info.instanceId, animId, false);
-                else
-                    m2r->setInstanceAnimationFrozen(info.instanceId, false);
+                m2r->setInstanceAnimationFrozen(info.instanceId, false);
             }
         }
     });
 
-    // GameObject state change callback — animate doors/chests opening/closing/destroying
-    gameHandler->setGameObjectStateCallback([this](uint64_t guid, uint8_t goState) {
-        if (!entitySpawner_ || !renderer) return;
-        auto& goInstances = entitySpawner_->getGameObjectInstances();
-        auto it = goInstances.find(guid);
-        if (it == goInstances.end()) return;
-        auto& info = it->second;
-        if (info.isWmo) return; // WMOs don't have M2 animation sequences
-        auto* m2r = renderer->getM2Renderer();
-        if (!m2r) return;
-        uint32_t instId = info.instanceId;
-        // GO states: 0=READY(closed), 1=OPEN, 2=DESTROYED/ACTIVE
-        if (goState == 1) {
-            // Opening: play OPEN(148) one-shot, fall back to unfreezing
-            if (m2r->hasAnimation(instId, 148))
-                m2r->setInstanceAnimation(instId, 148, false);
-            else
-                m2r->setInstanceAnimationFrozen(instId, false);
-        } else if (goState == 2) {
-            // Destroyed: play DESTROY(149) one-shot
-            if (m2r->hasAnimation(instId, 149))
-                m2r->setInstanceAnimation(instId, 149, false);
-        } else {
-            // Closed: play CLOSE(146) one-shot, else freeze
-            if (m2r->hasAnimation(instId, 146))
-                m2r->setInstanceAnimation(instId, 146, false);
-            else
-                m2r->setInstanceAnimationFrozen(instId, true);
-        }
-    });
-
-    // Sprint aura callback — use SPRINT(143) animation when sprint-type buff is active
-    gameHandler->setSprintAuraCallback([this](bool active) {
-        if (!renderer) return;
-        auto* ac = renderer->getAnimationController();
-        if (ac) ac->setSprintAuraActive(active);
-    });
-
-    // Vehicle state callback — hide player character when inside a vehicle
-    gameHandler->setVehicleStateCallback([this](bool entered, uint32_t /*vehicleId*/) {
-        if (!renderer) return;
-        auto* cr = renderer->getCharacterRenderer();
-        uint32_t instId = renderer->getCharacterInstanceId();
-        if (!cr || instId == 0) return;
-        cr->setInstanceVisible(instId, !entered);
-    });
-
     // Charge callback — warrior rushes toward target
     gameHandler->setChargeCallback([this](uint64_t targetGuid, float tx, float ty, float tz) {
         if (!renderer || !renderer->getCameraController() || !gameHandler) return;
@@ -2842,10 +2036,9 @@ void Application::setupUICallbacks() {
 
         // Compute direction and stop 2.0 units short (melee reach)
         glm::vec3 dir = targetRender - startRender;
-        float distSq = glm::dot(dir, dir);
-        if (distSq < 9.0f) return; // Too close, nothing to do
-        float invDist = glm::inversesqrt(distSq);
-        glm::vec3 dirNorm = dir * invDist;
+        float dist = glm::length(dir);
+        if (dist < 3.0f) return; // Too close, nothing to do
+        glm::vec3 dirNorm = dir / dist;
         glm::vec3 endRender = targetRender - dirNorm * 2.0f;
 
         // Face toward target BEFORE starting charge
@@ -2860,7 +2053,7 @@ void Application::setupUICallbacks() {
         // Set charge state
         chargeActive_ = true;
         chargeTimer_ = 0.0f;
-        chargeDuration_ = std::max(std::sqrt(distSq) / 25.0f, 0.3f); // ~25 units/sec
+        chargeDuration_ = std::max(dist / 25.0f, 0.3f); // ~25 units/sec
         chargeStartPos_ = startRender;
         chargeEndPos_ = endRender;
         chargeTargetGuid_ = targetGuid;
@@ -2889,7 +2082,7 @@ void Application::setupUICallbacks() {
     // Level-up callback — play sound, cheer emote, and trigger UI ding overlay + 3D effect
     gameHandler->setLevelUpCallback([this](uint32_t newLevel) {
         if (uiManager) {
-            uiManager->getGameScreen().toastManager().triggerDing(newLevel);
+            uiManager->getGameScreen().triggerDing(newLevel);
         }
         if (renderer) {
             renderer->triggerLevelUpEffect(renderer->getCharacterPosition());
@@ -2897,9 +2090,9 @@ void Application::setupUICallbacks() {
     });
 
     // Achievement earned callback — show toast banner
-    gameHandler->setAchievementEarnedCallback([this](uint32_t achievementId, const std::string& name) {
+    gameHandler->setAchievementEarnedCallback([this](uint32_t achievementId) {
         if (uiManager) {
-            uiManager->getGameScreen().toastManager().triggerAchievementToast(achievementId, name);
+            uiManager->getGameScreen().triggerAchievementToast(achievementId);
         }
     });
 
@@ -2907,7 +2100,7 @@ void Application::setupUICallbacks() {
     // Resolves soundId → SoundEntries.dbc → MPQ path → MusicManager.
     gameHandler->setPlayMusicCallback([this](uint32_t soundId) {
         if (!assetManager || !renderer) return;
-        auto* music = audioCoordinator_ ? audioCoordinator_->getMusicManager() : nullptr;
+        auto* music = renderer->getMusicManager();
         if (!music) return;
 
         auto dbc = assetManager->loadDBC("SoundEntries.dbc");
@@ -2966,12 +2159,10 @@ void Application::setupUICallbacks() {
             if (name.empty()) continue;
             std::string path = dir.empty() ? name : dir + "\\" + name;
 
-            // Play as 3D sound if source entity position is available.
-            // Entity stores canonical coords; listener uses render coords (camera).
+            // Play as 3D sound if source entity position is available
             auto entity = gameHandler->getEntityManager().getEntity(sourceGuid);
             if (entity) {
-                glm::vec3 canonical{entity->getLatestX(), entity->getLatestY(), entity->getLatestZ()};
-                glm::vec3 pos = core::coords::canonicalToRender(canonical);
+                glm::vec3 pos{entity->getLatestX(), entity->getLatestY(), entity->getLatestZ()};
                 audio::AudioEngine::instance().playSound3D(path, pos);
             } else {
                 audio::AudioEngine::instance().playSound2D(path);
@@ -3008,17 +2199,18 @@ void Application::setupUICallbacks() {
     gameHandler->setMountCallback([this](uint32_t mountDisplayId) {
         if (mountDisplayId == 0) {
             // Dismount is instant (no loading needed)
-            if (renderer && renderer->getCharacterRenderer() && entitySpawner_->getMountInstanceId() != 0) {
-                renderer->getCharacterRenderer()->removeInstance(entitySpawner_->getMountInstanceId());
-                entitySpawner_->clearMountState();
+            if (renderer && renderer->getCharacterRenderer() && mountInstanceId_ != 0) {
+                renderer->getCharacterRenderer()->removeInstance(mountInstanceId_);
+                mountInstanceId_ = 0;
             }
-            entitySpawner_->setMountDisplayId(0);
+            mountModelId_ = 0;
+            pendingMountDisplayId_ = 0;
             if (renderer) renderer->clearMount();
             LOG_INFO("Dismounted");
             return;
         }
         // Queue the mount for processing in the next update() frame
-        entitySpawner_->setMountDisplayId(mountDisplayId);
+        pendingMountDisplayId_ = mountDisplayId;
     });
 
     // Taxi precache callback - preload terrain tiles along flight path
@@ -3096,53 +2288,26 @@ void Application::setupUICallbacks() {
         }
     });
 
-    // Open dungeon finder callback — server sends SMSG_OPEN_LFG_DUNGEON_FINDER
-    gameHandler->setOpenLfgCallback([this]() {
-        if (uiManager) uiManager->getGameScreen().openDungeonFinder();
-    });
-
     // Creature move callback (online mode) - update creature positions
     gameHandler->setCreatureMoveCallback([this](uint64_t guid, float x, float y, float z, uint32_t durationMs) {
-        if (!entitySpawner_) return;
         if (!renderer || !renderer->getCharacterRenderer()) return;
         uint32_t instanceId = 0;
-        bool isPlayer = false;
-        instanceId = entitySpawner_->getPlayerInstanceId(guid);
-        if (instanceId != 0) { isPlayer = true; }
+        auto pit = playerInstances_.find(guid);
+        if (pit != playerInstances_.end()) instanceId = pit->second;
         else {
-            instanceId = entitySpawner_->getCreatureInstanceId(guid);
+            auto it = creatureInstances_.find(guid);
+            if (it != creatureInstances_.end()) instanceId = it->second;
         }
         if (instanceId != 0) {
             glm::vec3 renderPos = core::coords::canonicalToRender(glm::vec3(x, y, z));
             float durationSec = static_cast<float>(durationMs) / 1000.0f;
             renderer->getCharacterRenderer()->moveInstanceTo(instanceId, renderPos, durationSec);
-            // Play Run animation (anim 5) for the duration of the spline move.
-            // WoW M2 animation IDs: 4=Walk, 5=Run.
-            // Don't override Death animation (1). The per-frame sync loop will return to
-            // Stand when movement stops.
-            if (durationMs > 0) {
-                // Player animation is managed by the local renderer state machine —
-                // don't reset it here or every server movement packet restarts the
-                // run cycle from frame 0, causing visible stutter.
-                if (!isPlayer) {
-                    uint32_t curAnimId = 0; float curT = 0.0f, curDur = 0.0f;
-                    auto* cr = renderer->getCharacterRenderer();
-                    bool gotState = cr->getAnimationState(instanceId, curAnimId, curT, curDur);
-                    // Only start Run if not already running and not in Death animation.
-                    if (!gotState || (curAnimId != rendering::anim::DEATH && curAnimId != rendering::anim::RUN)) {
-                        cr->playAnimation(instanceId, rendering::anim::RUN, /*loop=*/true);
-                    }
-                    entitySpawner_->getCreatureWasMoving()[guid] = true;
-                }
-            }
         }
     });
 
     gameHandler->setGameObjectMoveCallback([this](uint64_t guid, float x, float y, float z, float orientation) {
-        if (!entitySpawner_) return;
-        auto& goInstMap = entitySpawner_->getGameObjectInstances();
-        auto it = goInstMap.find(guid);
-        if (it == goInstMap.end() || !renderer) {
+        auto it = gameObjectInstances_.find(guid);
+        if (it == gameObjectInstances_.end() || !renderer) {
             return;
         }
         glm::vec3 renderPos = core::coords::canonicalToRender(glm::vec3(x, y, z));
@@ -3165,28 +2330,138 @@ void Application::setupUICallbacks() {
 
     // Transport spawn callback (online mode) - register transports with TransportManager
     gameHandler->setTransportSpawnCallback([this](uint64_t guid, uint32_t entry, uint32_t displayId, float x, float y, float z, float orientation) {
-        if (!entitySpawner_) return;
-        if (!renderer) return;
+        auto* transportManager = gameHandler->getTransportManager();
+        if (!transportManager || !renderer) return;
 
-        // Get the GameObject instance now so late queue processing can rely on stable IDs.
-        auto& goInstances2 = entitySpawner_->getGameObjectInstances();
-        auto it = goInstances2.find(guid);
-        if (it == goInstances2.end()) {
+        // Get the WMO instance ID from the GameObject spawn
+        auto it = gameObjectInstances_.find(guid);
+        if (it == gameObjectInstances_.end()) {
             LOG_WARNING("Transport spawn callback: GameObject instance not found for GUID 0x", std::hex, guid, std::dec);
             return;
         }
 
-        auto pendingIt = entitySpawner_->hasTransportRegistrationPending(guid);
-        if (pendingIt) {
-            entitySpawner_->updateTransportRegistration(guid, displayId, x, y, z, orientation);
+        uint32_t wmoInstanceId = it->second.instanceId;
+        LOG_WARNING("Registering server transport: GUID=0x", std::hex, guid, std::dec,
+                 " entry=", entry, " displayId=", displayId, " wmoInstance=", wmoInstanceId,
+                 " pos=(", x, ", ", y, ", ", z, ")");
+
+        // TransportAnimation.dbc is indexed by GameObject entry
+        uint32_t pathId = entry;
+        const bool preferServerData = gameHandler && gameHandler->hasServerTransportUpdate(guid);
+
+        bool clientAnim = transportManager->isClientSideAnimation();
+        LOG_DEBUG("Transport spawn callback: clientAnimation=", clientAnim,
+                 " guid=0x", std::hex, guid, std::dec, " entry=", entry, " pathId=", pathId,
+                 " preferServer=", preferServerData);
+
+        // Coordinates are already canonical (converted in game_handler.cpp when entity was created)
+        glm::vec3 canonicalSpawnPos(x, y, z);
+
+        // Check if we have a real path from TransportAnimation.dbc (indexed by entry).
+        // AzerothCore transport entries are not always 1:1 with DBC path ids.
+        const bool shipOrZeppelinDisplay =
+            (displayId == 3015 || displayId == 3031 || displayId == 7546 ||
+             displayId == 7446 || displayId == 1587 || displayId == 2454 ||
+             displayId == 807 || displayId == 808);
+        bool hasUsablePath = transportManager->hasPathForEntry(entry);
+        if (shipOrZeppelinDisplay) {
+            // For true transports, reject tiny XY tracks that effectively look stationary.
+            hasUsablePath = transportManager->hasUsableMovingPathForEntry(entry, 25.0f);
+        }
+
+        LOG_WARNING("Transport path check: entry=", entry, " hasUsablePath=", hasUsablePath,
+                 " preferServerData=", preferServerData, " shipOrZepDisplay=", shipOrZeppelinDisplay);
+
+        if (preferServerData) {
+            // Strict server-authoritative mode: do not infer/remap fallback routes.
+            if (!hasUsablePath) {
+                std::vector<glm::vec3> path = { canonicalSpawnPos };
+                transportManager->loadPathFromNodes(pathId, path, false, 0.0f);
+                LOG_WARNING("Server-first strict registration: stationary fallback for GUID 0x",
+                         std::hex, guid, std::dec, " entry=", entry);
+            } else {
+                LOG_WARNING("Server-first transport registration: using entry DBC path for entry ", entry);
+            }
+        } else if (!hasUsablePath) {
+            // Remap/infer path by spawn position when entry doesn't map 1:1 to DBC ids.
+            // For elevators (TB lift platforms), we must allow z-only paths here.
+            bool allowZOnly = (displayId == 455 || displayId == 462);
+            uint32_t inferredPath = transportManager->inferDbcPathForSpawn(
+                canonicalSpawnPos, 1200.0f, allowZOnly);
+            if (inferredPath != 0) {
+                pathId = inferredPath;
+                LOG_WARNING("Using inferred transport path ", pathId, " for entry ", entry);
+            } else {
+                uint32_t remappedPath = transportManager->pickFallbackMovingPath(entry, displayId);
+                if (remappedPath != 0) {
+                    pathId = remappedPath;
+                    LOG_WARNING("Using remapped fallback transport path ", pathId,
+                             " for entry ", entry, " displayId=", displayId,
+                             " (usableEntryPath=", transportManager->hasPathForEntry(entry), ")");
+                } else {
+                    LOG_WARNING("No TransportAnimation.dbc path for entry ", entry,
+                                " - transport will be stationary");
+
+                    // Fallback: Stationary at spawn point (wait for server to send real position)
+                    std::vector<glm::vec3> path = { canonicalSpawnPos };
+                    transportManager->loadPathFromNodes(pathId, path, false, 0.0f);
+                }
+            }
         } else {
-            entitySpawner_->queueTransportRegistration(guid, entry, displayId, x, y, z, orientation);
+            LOG_WARNING("Using real transport path from TransportAnimation.dbc for entry ", entry);
+        }
+
+        // Register the transport with spawn position (prevents rendering at origin until server update)
+        transportManager->registerTransport(guid, wmoInstanceId, pathId, canonicalSpawnPos, entry);
+
+        // Mark M2 transports (e.g. Deeprun Tram cars) so TransportManager uses M2Renderer
+        if (!it->second.isWmo) {
+            if (auto* tr = transportManager->getTransport(guid)) {
+                tr->isM2 = true;
+            }
+        }
+
+        // Server-authoritative movement - set initial position from spawn data
+        glm::vec3 canonicalPos(x, y, z);
+        transportManager->updateServerTransport(guid, canonicalPos, orientation);
+
+        // If a move packet arrived before registration completed, replay latest now.
+        auto pendingIt = pendingTransportMoves_.find(guid);
+        if (pendingIt != pendingTransportMoves_.end()) {
+            const PendingTransportMove pending = pendingIt->second;
+            transportManager->updateServerTransport(guid, glm::vec3(pending.x, pending.y, pending.z), pending.orientation);
+            LOG_DEBUG("Replayed queued transport move for GUID=0x", std::hex, guid, std::dec,
+                     " pos=(", pending.x, ", ", pending.y, ", ", pending.z, ") orientation=", pending.orientation);
+            pendingTransportMoves_.erase(pendingIt);
+        }
+
+        // For MO_TRANSPORT at (0,0,0): check if GO data is already cached with a taxiPathId
+        if (glm::length(canonicalSpawnPos) < 1.0f && gameHandler) {
+            auto goData = gameHandler->getCachedGameObjectInfo(entry);
+            if (goData && goData->type == 15 && goData->hasData && goData->data[0] != 0) {
+                uint32_t taxiPathId = goData->data[0];
+                if (transportManager->hasTaxiPath(taxiPathId)) {
+                    transportManager->assignTaxiPathToTransport(entry, taxiPathId);
+                    LOG_DEBUG("Assigned cached TaxiPathNode path for MO_TRANSPORT entry=", entry,
+                             " taxiPathId=", taxiPathId);
+                }
+            }
+        }
+
+        if (auto* tr = transportManager->getTransport(guid); tr) {
+            LOG_WARNING("Transport registered: guid=0x", std::hex, guid, std::dec,
+                     " entry=", entry, " displayId=", displayId,
+                     " pathId=", tr->pathId,
+                     " mode=", (tr->useClientAnimation ? "client" : "server"),
+                     " serverUpdates=", tr->serverUpdateCount);
+        } else {
+            LOG_DEBUG("Transport registered: guid=0x", std::hex, guid, std::dec,
+                     " entry=", entry, " displayId=", displayId, " (TransportManager instance missing)");
         }
     });
 
     // Transport move callback (online mode) - update transport gameobject positions
     gameHandler->setTransportMoveCallback([this](uint64_t guid, float x, float y, float z, float orientation) {
-        if (!entitySpawner_) return;
         LOG_DEBUG("Transport move callback: GUID=0x", std::hex, guid, std::dec,
                  " pos=(", x, ", ", y, ", ", z, ") orientation=", orientation);
 
@@ -3196,12 +2471,6 @@ void Application::setupUICallbacks() {
             return;
         }
 
-        if (entitySpawner_->hasTransportRegistrationPending(guid)) {
-            entitySpawner_->setTransportPendingMove(guid, x, y, z, orientation);
-            LOG_DEBUG("Queued transport move for pending registration GUID=0x", std::hex, guid, std::dec);
-            return;
-        }
-
         // Check if transport exists - if not, treat this as a late spawn (reconnection/server restart)
         if (!transportManager->getTransport(guid)) {
             LOG_DEBUG("Received position update for unregistered transport 0x", std::hex, guid, std::dec,
@@ -3215,9 +2484,8 @@ void Application::setupUICallbacks() {
                 uint32_t displayId = go->getDisplayId();
 
                 // Find the WMO instance for this transport (should exist from earlier GameObject spawn)
-                auto& goInstances3 = entitySpawner_->getGameObjectInstances();
-                auto it = goInstances3.find(guid);
-                if (it != goInstances3.end()) {
+                auto it = gameObjectInstances_.find(guid);
+                if (it != gameObjectInstances_.end()) {
                     uint32_t wmoInstanceId = it->second.instanceId;
 
                     // TransportAnimation.dbc is indexed by GameObject entry
@@ -3277,20 +2545,14 @@ void Application::setupUICallbacks() {
                     }
 
                     transportManager->registerTransport(guid, wmoInstanceId, pathId, canonicalSpawnPos, entry);
-                    // Keep type in sync with the spawned instance; needed for M2 lift boarding/motion.
-                    if (!it->second.isWmo) {
-                        if (auto* tr = transportManager->getTransport(guid)) {
-                            tr->isM2 = true;
-                        }
-                    }
                 } else {
-                    entitySpawner_->setTransportPendingMove(guid, x, y, z, orientation);
+                    pendingTransportMoves_[guid] = PendingTransportMove{x, y, z, orientation};
                     LOG_DEBUG("Cannot auto-spawn transport 0x", std::hex, guid, std::dec,
                               " - WMO instance not found yet (queued move for replay)");
                     return;
                 }
             } else {
-                entitySpawner_->setTransportPendingMove(guid, x, y, z, orientation);
+                pendingTransportMoves_[guid] = PendingTransportMove{x, y, z, orientation};
                 LOG_DEBUG("Cannot auto-spawn transport 0x", std::hex, guid, std::dec,
                           " - entity not found in EntityManager (queued move for replay)");
                 return;
@@ -3318,404 +2580,35 @@ void Application::setupUICallbacks() {
         }
     });
 
-    // NPC/player death callback (online mode) - play death animation
+    // NPC death callback (online mode) - play death animation
     gameHandler->setNpcDeathCallback([this](uint64_t guid) {
-        if (!entitySpawner_) return;
-        entitySpawner_->markCreatureDead(guid);
-        if (!renderer || !renderer->getCharacterRenderer()) return;
-        uint32_t instanceId = entitySpawner_->getCreatureInstanceId(guid);
-        if (instanceId == 0) instanceId = entitySpawner_->getPlayerInstanceId(guid);
-        if (instanceId != 0) {
-            renderer->getCharacterRenderer()->playAnimation(instanceId, rendering::anim::DEATH, false);
+        deadCreatureGuids_.insert(guid);
+        auto it = creatureInstances_.find(guid);
+        if (it != creatureInstances_.end() && renderer && renderer->getCharacterRenderer()) {
+            renderer->getCharacterRenderer()->playAnimation(it->second, 1, false); // Death
         }
     });
 
-    // NPC/player respawn callback (online mode) - play rise animation then idle
+    // NPC respawn callback (online mode) - reset to idle animation
     gameHandler->setNpcRespawnCallback([this](uint64_t guid) {
-        if (!entitySpawner_) return;
-        entitySpawner_->unmarkCreatureDead(guid);
-        if (!renderer || !renderer->getCharacterRenderer()) return;
-        uint32_t instanceId = entitySpawner_->getCreatureInstanceId(guid);
-        if (instanceId == 0) instanceId = entitySpawner_->getPlayerInstanceId(guid);
-        if (instanceId != 0) {
-            auto* cr = renderer->getCharacterRenderer();
-            // Play RISE one-shot (auto-returns to STAND when finished), fall back to STAND
-            if (cr->hasAnimation(instanceId, rendering::anim::RISE))
-                cr->playAnimation(instanceId, rendering::anim::RISE, false);
-            else
-                cr->playAnimation(instanceId, rendering::anim::STAND, true);
+        deadCreatureGuids_.erase(guid);
+        auto it = creatureInstances_.find(guid);
+        if (it != creatureInstances_.end() && renderer && renderer->getCharacterRenderer()) {
+            renderer->getCharacterRenderer()->playAnimation(it->second, 0, true); // Idle
         }
     });
 
-    // NPC/player swing callback (online mode) - play attack animation
-    // Probes the model for the best available attack animation:
-    //   ATTACK_1H(17) → ATTACK_2H(18) → ATTACK_2H_LOOSE(19) → ATTACK_UNARMED(16)
+    // NPC swing callback (online mode) - play attack animation
     gameHandler->setNpcSwingCallback([this](uint64_t guid) {
-        if (!entitySpawner_) return;
-        if (!renderer || !renderer->getCharacterRenderer()) return;
-        uint32_t instanceId = entitySpawner_->getCreatureInstanceId(guid);
-        if (instanceId == 0) instanceId = entitySpawner_->getPlayerInstanceId(guid);
-        if (instanceId != 0) {
-            auto* cr = renderer->getCharacterRenderer();
-            static const uint32_t attackAnims[] = {
-                rendering::anim::ATTACK_1H,
-                rendering::anim::ATTACK_2H,
-                rendering::anim::ATTACK_2H_LOOSE,
-                rendering::anim::ATTACK_UNARMED
-            };
-            bool played = false;
-            for (uint32_t anim : attackAnims) {
-                if (cr->hasAnimation(instanceId, anim)) {
-                    cr->playAnimation(instanceId, anim, false);
-                    played = true;
-                    break;
-                }
-            }
-            if (!played) cr->playAnimation(instanceId, rendering::anim::ATTACK_UNARMED, false);
+        auto it = creatureInstances_.find(guid);
+        if (it != creatureInstances_.end() && renderer && renderer->getCharacterRenderer()) {
+            renderer->getCharacterRenderer()->playAnimation(it->second, 16, false); // Attack
         }
     });
 
-    // Hit reaction callback — plays one-shot dodge/block/wound animation on the victim
-    gameHandler->setHitReactionCallback([this](uint64_t victimGuid, game::GameHandler::HitReaction reaction) {
-        if (!renderer) return;
-        auto* cr = renderer->getCharacterRenderer();
-        if (!cr) return;
-
-        // Determine animation based on reaction type
-        uint32_t animId = rendering::anim::COMBAT_WOUND;
-        switch (reaction) {
-            case game::GameHandler::HitReaction::DODGE:      animId = rendering::anim::DODGE; break;
-            case game::GameHandler::HitReaction::PARRY:      break; // Parry already handled by existing system
-            case game::GameHandler::HitReaction::BLOCK:      animId = rendering::anim::BLOCK; break;
-            case game::GameHandler::HitReaction::SHIELD_BLOCK: animId = rendering::anim::SHIELD_BLOCK; break;
-            case game::GameHandler::HitReaction::CRIT_WOUND: animId = rendering::anim::COMBAT_CRITICAL; break;
-            case game::GameHandler::HitReaction::WOUND:      animId = rendering::anim::COMBAT_WOUND; break;
-        }
-
-        // For local player: use AnimationController state
-        bool isLocalPlayer = (victimGuid == gameHandler->getPlayerGuid());
-        if (isLocalPlayer) {
-            auto* ac = renderer->getAnimationController();
-            if (ac) {
-                uint32_t charInstId = renderer->getCharacterInstanceId();
-                if (charInstId && cr->hasAnimation(charInstId, animId))
-                    ac->triggerHitReaction(animId);
-            }
-            return;
-        }
-
-        // For NPCs/other players: direct playAnimation
-        if (!entitySpawner_) return;
-        uint32_t instanceId = entitySpawner_->getCreatureInstanceId(victimGuid);
-        if (instanceId == 0) instanceId = entitySpawner_->getPlayerInstanceId(victimGuid);
-        if (instanceId != 0 && cr->hasAnimation(instanceId, animId))
-            cr->playAnimation(instanceId, animId, false);
-    });
-
-    // Stun state callback — enters/exits STUNNED animation on local player
-    gameHandler->setStunStateCallback([this](bool stunned) {
-        if (!renderer) return;
-        auto* ac = renderer->getAnimationController();
-        if (ac) ac->setStunned(stunned);
-    });
-
-    // Stealth state callback — switches to stealth animation variants
-    gameHandler->setStealthStateCallback([this](bool stealthed) {
-        if (!renderer) return;
-        auto* ac = renderer->getAnimationController();
-        if (ac) ac->setStealthed(stealthed);
-    });
-
-    // Player health callback — switches to wounded idle when HP < 20%
-    gameHandler->setPlayerHealthCallback([this](uint32_t health, uint32_t maxHealth) {
-        if (!renderer) return;
-        auto* ac = renderer->getAnimationController();
-        if (!ac) return;
-        bool lowHp = (maxHealth > 0) && (health > 0) && (health * 5 <= maxHealth);
-        ac->setLowHealth(lowHp);
-    });
-
-    // Unit animation hint callback — plays jump (38=JumpMid) animation on other players/NPCs.
-    // Swim/walking state is now authoritative from the move-flags callback below.
-    // animId=38 (JumpMid): airborne jump animation; land detection is via per-frame sync.
-    gameHandler->setUnitAnimHintCallback([this](uint64_t guid, uint32_t animId) {
-        if (!entitySpawner_) return;
-        if (!renderer) return;
-        auto* cr = renderer->getCharacterRenderer();
-        if (!cr) return;
-        uint32_t instanceId = entitySpawner_->getPlayerInstanceId(guid);
-        if (instanceId == 0) instanceId = entitySpawner_->getCreatureInstanceId(guid);
-        if (instanceId == 0) return;
-        // Don't override Death animation
-        uint32_t curAnim = 0; float curT = 0.0f, curDur = 0.0f;
-        if (cr->getAnimationState(instanceId, curAnim, curT, curDur) && curAnim == rendering::anim::DEATH) return;
-        cr->playAnimation(instanceId, animId, /*loop=*/true);
-    });
-
-    // Unit move-flags callback — updates swimming and walking state from every MSG_MOVE_* packet.
-    // This is more reliable than opcode-based hints for cold joins and heartbeats:
-    // a player already swimming when we join will have SWIMMING set on the first heartbeat.
-    // Walking(4) vs Running(5) is also driven here from the WALKING flag.
-    gameHandler->setUnitMoveFlagsCallback([this](uint64_t guid, uint32_t moveFlags) {
-        if (!entitySpawner_) return;
-        const bool isSwimming = (moveFlags & static_cast<uint32_t>(game::MovementFlags::SWIMMING)) != 0;
-        const bool isWalking  = (moveFlags & static_cast<uint32_t>(game::MovementFlags::WALKING))  != 0;
-        const bool isFlying   = (moveFlags & static_cast<uint32_t>(game::MovementFlags::FLYING))   != 0;
-        auto& swimState = entitySpawner_->getCreatureSwimmingState();
-        auto& walkState = entitySpawner_->getCreatureWalkingState();
-        auto& flyState  = entitySpawner_->getCreatureFlyingState();
-        if (isSwimming) swimState[guid] = true;
-        else            swimState.erase(guid);
-        if (isWalking)  walkState[guid] = true;
-        else            walkState.erase(guid);
-        if (isFlying)   flyState[guid] = true;
-        else            flyState.erase(guid);
-    });
-
-    // Emote animation callback — play server-driven emote animations on NPCs and other players.
-    // When emoteAnim is 0, the NPC's emote state was cleared → revert to STAND.
-    // Non-zero values from UNIT_NPC_EMOTESTATE updates are persistent (played looping).
-    gameHandler->setEmoteAnimCallback([this](uint64_t guid, uint32_t emoteAnim) {
-        if (!entitySpawner_) return;
-        if (!renderer) return;
-        auto* cr = renderer->getCharacterRenderer();
-        if (!cr) return;
-        // Look up creature instance first, then online players
-        uint32_t emoteInstanceId = entitySpawner_->getCreatureInstanceId(guid);
-        if (emoteInstanceId != 0) {
-            if (emoteAnim == 0) {
-                // Emote state cleared → return to idle
-                cr->playAnimation(emoteInstanceId, rendering::anim::STAND, true);
-            } else {
-                cr->playAnimation(emoteInstanceId, emoteAnim, false);
-            }
-            return;
-        }
-        emoteInstanceId = entitySpawner_->getPlayerInstanceId(guid);
-        if (emoteInstanceId != 0) {
-            cr->playAnimation(emoteInstanceId, emoteAnim, false);
-        }
-    });
-
-    // Spell cast animation callback — play cast animation on caster (player or NPC/other player)
-    // WoW-accurate 3-phase spell animation sequence:
-    //   Phase 1: SPELL_PRECAST (31)              — one-shot wind-up
-    //   Phase 2: READY_SPELL_DIRECTED/OMNI (51/52) — looping hold while cast bar fills
-    //   Phase 3: SPELL_CAST_DIRECTED/OMNI/AREA (53/54/33) — one-shot release at completion
-    // Channels use CHANNEL_CAST_DIRECTED/OMNI (124/125) or SPELL_CHANNEL_DIRECTED_OMNI (201).
-    // castType comes from the spell packet's targetGuid:
-    //   DIRECTED — spell targets a specific unit  (Frostbolt, Heal)
-    //   OMNI     — self-cast / no explicit target (Arcane Explosion, buffs)
-    //   AREA     — ground-targeted AoE           (Blizzard, Rain of Fire)
-    gameHandler->setSpellCastAnimCallback([this](uint64_t guid, bool start, bool isChannel,
-                                                  game::SpellCastType castType) {
-        if (!entitySpawner_) return;
-        if (!renderer) return;
-        auto* cr = renderer->getCharacterRenderer();
-        if (!cr) return;
-
-        // Determine if this is the local player
-        bool isLocalPlayer = false;
-        uint32_t instanceId = 0;
-        {
-            uint32_t charInstId = renderer->getCharacterInstanceId();
-            if (charInstId != 0 && guid == gameHandler->getPlayerGuid()) {
-                instanceId = charInstId;
-                isLocalPlayer = true;
-            }
-        }
-        if (instanceId == 0) instanceId = entitySpawner_->getCreatureInstanceId(guid);
-        if (instanceId == 0) instanceId = entitySpawner_->getPlayerInstanceId(guid);
-        if (instanceId == 0) return;
-
-        const bool isDirected = (castType == game::SpellCastType::DIRECTED);
-        const bool isArea     = (castType == game::SpellCastType::AREA);
-
-        if (start) {
-            // Detect fishing spells (channeled) — use FISHING_LOOP instead of generic cast
-            auto isFishingSpell = [](uint32_t spellId) {
-                return spellId == 7620 || spellId == 7731 || spellId == 7732 ||
-                       spellId == 18248 || spellId == 33095 || spellId == 51294;
-            };
-            uint32_t currentSpell = isLocalPlayer ? gameHandler->getCurrentCastSpellId() : 0;
-            bool isFishing = isChannel && isFishingSpell(currentSpell);
-
-            if (isFishing && cr->hasAnimation(instanceId, rendering::anim::FISHING_LOOP)) {
-                // Fishing: use FISHING_LOOP (looping idle) for the channel duration
-                if (isLocalPlayer) {
-                    auto* ac = renderer->getAnimationController();
-                    if (ac) ac->startSpellCast(0, rendering::anim::FISHING_LOOP, true, 0);
-                } else {
-                    cr->playAnimation(instanceId, rendering::anim::FISHING_LOOP, true);
-                }
-            } else {
-            // Helper: pick first animation the model supports from a list
-            auto pickFirst = [&](std::initializer_list<uint32_t> ids) -> uint32_t {
-                for (uint32_t id : ids)
-                    if (cr->hasAnimation(instanceId, id)) return id;
-                return 0;
-            };
-
-            // Phase 1: Precast wind-up (one-shot, non-channels only)
-            uint32_t precastAnim = 0;
-            if (!isChannel) {
-                precastAnim = pickFirst({rendering::anim::SPELL_PRECAST});
-            }
-
-            // Phase 2: Cast hold (looping while cast bar fills / channel active)
-            uint32_t castAnim = 0;
-            if (isChannel) {
-                // Channel hold: prefer DIRECTED/OMNI based on spell target classification
-                if (isDirected) {
-                    castAnim = pickFirst({
-                        rendering::anim::CHANNEL_CAST_DIRECTED,
-                        rendering::anim::CHANNEL_CAST_OMNI,
-                        rendering::anim::SPELL_CHANNEL_DIRECTED_OMNI,
-                        rendering::anim::READY_SPELL_DIRECTED,
-                        rendering::anim::SPELL
-                    });
-                } else {
-                    // OMNI or AREA channels (Blizzard channel, Tranquility, etc.)
-                    castAnim = pickFirst({
-                        rendering::anim::CHANNEL_CAST_OMNI,
-                        rendering::anim::CHANNEL_CAST_DIRECTED,
-                        rendering::anim::SPELL_CHANNEL_DIRECTED_OMNI,
-                        rendering::anim::READY_SPELL_OMNI,
-                        rendering::anim::SPELL
-                    });
-                }
-            } else {
-                // Regular cast hold: READY_SPELL_DIRECTED/OMNI while cast bar fills
-                if (isDirected) {
-                    castAnim = pickFirst({
-                        rendering::anim::READY_SPELL_DIRECTED,
-                        rendering::anim::READY_SPELL_OMNI,
-                        rendering::anim::SPELL_CAST_DIRECTED,
-                        rendering::anim::SPELL_CAST,
-                        rendering::anim::SPELL
-                    });
-                } else {
-                    // OMNI (self-buff) or AREA (AoE targeting)
-                    castAnim = pickFirst({
-                        rendering::anim::READY_SPELL_OMNI,
-                        rendering::anim::READY_SPELL_DIRECTED,
-                        rendering::anim::SPELL_CAST_OMNI,
-                        rendering::anim::SPELL_CAST,
-                        rendering::anim::SPELL
-                    });
-                }
-            }
-            if (castAnim == 0) castAnim = rendering::anim::SPELL;
-
-            // Phase 3: Finalization release (one-shot after cast completes)
-            // Animation chosen by spell target type: AREA → SPELL_CAST_AREA,
-            // DIRECTED → SPELL_CAST_DIRECTED, OMNI → SPELL_CAST_OMNI
-            uint32_t finalizeAnim = 0;
-            if (isLocalPlayer && !isChannel) {
-                if (isArea) {
-                    // Ground-targeted AoE: SPELL_CAST_AREA → SPELL_CAST_OMNI
-                    finalizeAnim = pickFirst({
-                        rendering::anim::SPELL_CAST_AREA,
-                        rendering::anim::SPELL_CAST_OMNI,
-                        rendering::anim::SPELL_CAST,
-                        rendering::anim::SPELL
-                    });
-                } else if (isDirected) {
-                    // Single-target: SPELL_CAST_DIRECTED → SPELL_CAST_OMNI
-                    finalizeAnim = pickFirst({
-                        rendering::anim::SPELL_CAST_DIRECTED,
-                        rendering::anim::SPELL_CAST_OMNI,
-                        rendering::anim::SPELL_CAST,
-                        rendering::anim::SPELL
-                    });
-                } else {
-                    // OMNI (self-buff, Arcane Explosion): SPELL_CAST_OMNI → SPELL_CAST_AREA
-                    finalizeAnim = pickFirst({
-                        rendering::anim::SPELL_CAST_OMNI,
-                        rendering::anim::SPELL_CAST_AREA,
-                        rendering::anim::SPELL_CAST,
-                        rendering::anim::SPELL
-                    });
-                }
-            }
-
-            if (isLocalPlayer) {
-                auto* ac = renderer->getAnimationController();
-                if (ac) ac->startSpellCast(precastAnim, castAnim, true, finalizeAnim);
-            } else {
-                cr->playAnimation(instanceId, castAnim, true);
-            }
-            } // end !isFishing
-        } else {
-            // Cast/channel ended — plays finalization anim completely then returns to idle
-            if (isLocalPlayer) {
-                auto* ac = renderer->getAnimationController();
-                if (ac) ac->stopSpellCast();
-            } else if (isChannel) {
-                cr->playAnimation(instanceId, rendering::anim::STAND, true);
-            }
-        }
-    });
-
-    // Ghost state callback — make player semi-transparent when in spirit form
-    gameHandler->setGhostStateCallback([this](bool isGhost) {
-        if (!renderer) return;
-        auto* cr = renderer->getCharacterRenderer();
-        if (!cr) return;
-        uint32_t charInstId = renderer->getCharacterInstanceId();
-        if (charInstId == 0) return;
-        cr->setInstanceOpacity(charInstId, isGhost ? 0.5f : 1.0f);
-    });
-
-    // Stand state animation callback — route through AnimationController state machine
-    // for proper sit/sleep/kneel transition animations (down → loop → up)
-    gameHandler->setStandStateCallback([this](uint8_t standState) {
-        if (!renderer) return;
-        using AC = rendering::AnimationController;
-
-        // Sync camera controller sitting flag: block movement while sitting/kneeling
-        if (auto* cc = renderer->getCameraController()) {
-            cc->setSitting(standState >= AC::STAND_STATE_SIT &&
-                           standState <= AC::STAND_STATE_KNEEL &&
-                           standState != AC::STAND_STATE_DEAD);
-        }
-
-        auto* ac = renderer->getAnimationController();
-        if (!ac) return;
-
-        // Death is special — play directly, not through sit state machine
-        if (standState == AC::STAND_STATE_DEAD) {
-            auto* cr = renderer->getCharacterRenderer();
-            if (!cr) return;
-            uint32_t charInstId = renderer->getCharacterInstanceId();
-            if (charInstId == 0) return;
-            cr->playAnimation(charInstId, rendering::anim::DEATH, false);
-            return;
-        }
-
-        ac->setStandState(standState);
-    });
-
-    // Loot window callback — play kneel/loot animation while looting
-    gameHandler->setLootWindowCallback([this](bool open) {
-        if (!renderer) return;
-        auto* ac = renderer->getAnimationController();
-        if (!ac) return;
-        if (open) ac->startLooting();
-        else      ac->stopLooting();
-    });
-
     // NPC greeting callback - play voice line
     gameHandler->setNpcGreetingCallback([this](uint64_t guid, const glm::vec3& position) {
-        // Play NPC_WELCOME animation on the NPC
-        if (entitySpawner_ && renderer) {
-            auto* cr = renderer->getCharacterRenderer();
-            if (cr) {
-                uint32_t instanceId = entitySpawner_->getCreatureInstanceId(guid);
-                if (instanceId != 0) cr->playAnimation(instanceId, rendering::anim::NPC_WELCOME, false);
-            }
-        }
-        if (audioCoordinator_ && audioCoordinator_->getNpcVoiceManager()) {
+        if (renderer && renderer->getNpcVoiceManager()) {
             // Convert canonical to render coords for 3D audio
             glm::vec3 renderPos = core::coords::canonicalToRender(position);
 
@@ -3725,16 +2618,16 @@ void Application::setupUICallbacks() {
             if (entity && entity->getType() == game::ObjectType::UNIT) {
                 auto unit = std::static_pointer_cast<game::Unit>(entity);
                 uint32_t displayId = unit->getDisplayId();
-                voiceType = entitySpawner_->detectVoiceTypeFromDisplayId(displayId);
+                voiceType = detectVoiceTypeFromDisplayId(displayId);
             }
 
-            audioCoordinator_->getNpcVoiceManager()->playGreeting(guid, voiceType, renderPos);
+            renderer->getNpcVoiceManager()->playGreeting(guid, voiceType, renderPos);
         }
     });
 
     // NPC farewell callback - play farewell voice line
     gameHandler->setNpcFarewellCallback([this](uint64_t guid, const glm::vec3& position) {
-        if (audioCoordinator_ && audioCoordinator_->getNpcVoiceManager()) {
+        if (renderer && renderer->getNpcVoiceManager()) {
             glm::vec3 renderPos = core::coords::canonicalToRender(position);
 
             audio::VoiceType voiceType = audio::VoiceType::GENERIC;
@@ -3742,16 +2635,16 @@ void Application::setupUICallbacks() {
             if (entity && entity->getType() == game::ObjectType::UNIT) {
                 auto unit = std::static_pointer_cast<game::Unit>(entity);
                 uint32_t displayId = unit->getDisplayId();
-                voiceType = entitySpawner_->detectVoiceTypeFromDisplayId(displayId);
+                voiceType = detectVoiceTypeFromDisplayId(displayId);
             }
 
-            audioCoordinator_->getNpcVoiceManager()->playFarewell(guid, voiceType, renderPos);
+            renderer->getNpcVoiceManager()->playFarewell(guid, voiceType, renderPos);
         }
     });
 
     // NPC vendor callback - play vendor voice line
     gameHandler->setNpcVendorCallback([this](uint64_t guid, const glm::vec3& position) {
-        if (audioCoordinator_ && audioCoordinator_->getNpcVoiceManager()) {
+        if (renderer && renderer->getNpcVoiceManager()) {
             glm::vec3 renderPos = core::coords::canonicalToRender(position);
 
             audio::VoiceType voiceType = audio::VoiceType::GENERIC;
@@ -3759,16 +2652,16 @@ void Application::setupUICallbacks() {
             if (entity && entity->getType() == game::ObjectType::UNIT) {
                 auto unit = std::static_pointer_cast<game::Unit>(entity);
                 uint32_t displayId = unit->getDisplayId();
-                voiceType = entitySpawner_->detectVoiceTypeFromDisplayId(displayId);
+                voiceType = detectVoiceTypeFromDisplayId(displayId);
             }
 
-            audioCoordinator_->getNpcVoiceManager()->playVendor(guid, voiceType, renderPos);
+            renderer->getNpcVoiceManager()->playVendor(guid, voiceType, renderPos);
         }
     });
 
     // NPC aggro callback - play combat start voice line
     gameHandler->setNpcAggroCallback([this](uint64_t guid, const glm::vec3& position) {
-        if (audioCoordinator_ && audioCoordinator_->getNpcVoiceManager()) {
+        if (renderer && renderer->getNpcVoiceManager()) {
             glm::vec3 renderPos = core::coords::canonicalToRender(position);
 
             audio::VoiceType voiceType = audio::VoiceType::GENERIC;
@@ -3776,10 +2669,10 @@ void Application::setupUICallbacks() {
             if (entity && entity->getType() == game::ObjectType::UNIT) {
                 auto unit = std::static_pointer_cast<game::Unit>(entity);
                 uint32_t displayId = unit->getDisplayId();
-                voiceType = entitySpawner_->detectVoiceTypeFromDisplayId(displayId);
+                voiceType = detectVoiceTypeFromDisplayId(displayId);
             }
 
-            audioCoordinator_->getNpcVoiceManager()->playAggro(guid, voiceType, renderPos);
+            renderer->getNpcVoiceManager()->playAggro(guid, voiceType, renderPos);
         }
     });
 
@@ -3835,7 +2728,7 @@ void Application::spawnPlayerCharacter() {
     auto* charRenderer = renderer->getCharacterRenderer();
     auto* camera = renderer->getCamera();
     bool loaded = false;
-    std::string m2Path = appearanceComposer_->getPlayerModelPath(playerRace_, playerGender_);
+    std::string m2Path = getPlayerModelPath();
     std::string modelDir;
     std::string baseName;
     {
@@ -3872,18 +2765,144 @@ void Application::spawnPlayerCharacter() {
                     LOG_INFO("  Texture ", ti, ": type=", tex.type, " name='", tex.filename, "'");
                 }
 
-                // Resolve textures from CharSections.dbc via AppearanceComposer
-                PlayerTextureInfo texInfo;
+                // Look up textures from CharSections.dbc for all races
                 bool useCharSections = true;
-                if (appearanceComposer_) {
-                    uint32_t appearanceBytes = 0;
-                    if (gameHandler) {
-                        const game::Character* activeChar = gameHandler->getActiveCharacter();
-                        if (activeChar) {
-                            appearanceBytes = activeChar->appearanceBytes;
+                uint32_t targetRaceId = static_cast<uint32_t>(playerRace_);
+                uint32_t targetSexId = (playerGender_ == game::Gender::FEMALE) ? 1u : 0u;
+
+                // Race name for fallback texture paths
+                const char* raceFolderName = "Human";
+                switch (playerRace_) {
+                    case game::Race::HUMAN:    raceFolderName = "Human"; break;
+                    case game::Race::ORC:      raceFolderName = "Orc"; break;
+                    case game::Race::DWARF:    raceFolderName = "Dwarf"; break;
+                    case game::Race::NIGHT_ELF: raceFolderName = "NightElf"; break;
+                    case game::Race::UNDEAD:    raceFolderName = "Scourge"; break;
+                    case game::Race::TAUREN:    raceFolderName = "Tauren"; break;
+                    case game::Race::GNOME:     raceFolderName = "Gnome"; break;
+                    case game::Race::TROLL:     raceFolderName = "Troll"; break;
+                    case game::Race::BLOOD_ELF: raceFolderName = "BloodElf"; break;
+                    case game::Race::DRAENEI:   raceFolderName = "Draenei"; break;
+                    default: break;
+                }
+                const char* genderFolder = (playerGender_ == game::Gender::FEMALE) ? "Female" : "Male";
+                std::string raceGender = std::string(raceFolderName) + genderFolder;
+                std::string bodySkinPath = std::string("Character\\") + raceFolderName + "\\" + genderFolder + "\\" + raceGender + "Skin00_00.blp";
+                std::string pelvisPath = std::string("Character\\") + raceFolderName + "\\" + genderFolder + "\\" + raceGender + "NakedPelvisSkin00_00.blp";
+                std::string faceLowerTexturePath;
+                std::string faceUpperTexturePath;
+                std::vector<std::string> underwearPaths;
+
+                // Extract appearance bytes for texture lookups
+                uint8_t charSkinId = 0, charFaceId = 0, charHairStyleId = 0, charHairColorId = 0;
+                if (gameHandler) {
+                    const game::Character* activeChar = gameHandler->getActiveCharacter();
+                    if (activeChar) {
+                        charSkinId = activeChar->appearanceBytes & 0xFF;
+                        charFaceId = (activeChar->appearanceBytes >> 8) & 0xFF;
+                        charHairStyleId = (activeChar->appearanceBytes >> 16) & 0xFF;
+                        charHairColorId = (activeChar->appearanceBytes >> 24) & 0xFF;
+                        LOG_INFO("Appearance: skin=", (int)charSkinId, " face=", (int)charFaceId,
+                                 " hairStyle=", (int)charHairStyleId, " hairColor=", (int)charHairColorId);
+                    }
+                }
+
+                std::string hairTexturePath;
+                if (useCharSections) {
+                    auto charSectionsDbc = assetManager->loadDBC("CharSections.dbc");
+                    if (charSectionsDbc) {
+                        LOG_INFO("CharSections.dbc loaded: ", charSectionsDbc->getRecordCount(), " records");
+                        const auto* csL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CharSections") : nullptr;
+                        bool foundSkin = false;
+                        bool foundUnderwear = false;
+                        bool foundFaceLower = false;
+                        bool foundHair = false;
+                        for (uint32_t r = 0; r < charSectionsDbc->getRecordCount(); r++) {
+                            uint32_t raceId = charSectionsDbc->getUInt32(r, csL ? (*csL)["RaceID"] : 1);
+                            uint32_t sexId = charSectionsDbc->getUInt32(r, csL ? (*csL)["SexID"] : 2);
+                            uint32_t baseSection = charSectionsDbc->getUInt32(r, csL ? (*csL)["BaseSection"] : 3);
+                            uint32_t variationIndex = charSectionsDbc->getUInt32(r, csL ? (*csL)["VariationIndex"] : 4);
+                            uint32_t colorIndex = charSectionsDbc->getUInt32(r, csL ? (*csL)["ColorIndex"] : 5);
+
+                            if (raceId != targetRaceId || sexId != targetSexId) continue;
+
+                            // Section 0 = skin: match by colorIndex = skin byte
+                            const uint32_t csTex1 = csL ? (*csL)["Texture1"] : 6;
+                            if (baseSection == 0 && !foundSkin && colorIndex == charSkinId) {
+                                std::string tex1 = charSectionsDbc->getString(r, csTex1);
+                                if (!tex1.empty()) {
+                                    bodySkinPath = tex1;
+                                    foundSkin = true;
+                                    LOG_INFO("  DBC body skin: ", bodySkinPath, " (skin=", (int)charSkinId, ")");
+                                }
+                            }
+                            // Section 3 = hair: match variation=hairStyle, color=hairColor
+                            else if (baseSection == 3 && !foundHair &&
+                                     variationIndex == charHairStyleId && colorIndex == charHairColorId) {
+                                hairTexturePath = charSectionsDbc->getString(r, csTex1);
+                                if (!hairTexturePath.empty()) {
+                                    foundHair = true;
+                                    LOG_INFO("  DBC hair texture: ", hairTexturePath,
+                                             " (style=", (int)charHairStyleId, " color=", (int)charHairColorId, ")");
+                                }
+                            }
+                            // Section 1 = face: match variation=faceId, colorIndex=skinId
+                            // Texture1 = face lower, Texture2 = face upper
+                            else if (baseSection == 1 && !foundFaceLower &&
+                                     variationIndex == charFaceId && colorIndex == charSkinId) {
+                                std::string tex1 = charSectionsDbc->getString(r, csTex1);
+                                std::string tex2 = charSectionsDbc->getString(r, csTex1 + 1);
+                                if (!tex1.empty()) {
+                                    faceLowerTexturePath = tex1;
+                                    LOG_INFO("  DBC face lower: ", faceLowerTexturePath);
+                                }
+                                if (!tex2.empty()) {
+                                    faceUpperTexturePath = tex2;
+                                    LOG_INFO("  DBC face upper: ", faceUpperTexturePath);
+                                }
+                                foundFaceLower = true;
+                            }
+                            // Section 4 = underwear
+                            else if (baseSection == 4 && !foundUnderwear && colorIndex == charSkinId) {
+                                for (uint32_t f = csTex1; f <= csTex1 + 2; f++) {
+                                    std::string tex = charSectionsDbc->getString(r, f);
+                                    if (!tex.empty()) {
+                                        underwearPaths.push_back(tex);
+                                        LOG_INFO("  DBC underwear texture: ", tex);
+                                    }
+                                }
+                                foundUnderwear = true;
+                            }
+
+                            if (foundSkin && foundHair && foundFaceLower && foundUnderwear) break;
+                        }
+
+                        if (!foundHair) {
+                            LOG_WARNING("No DBC hair match for style=", (int)charHairStyleId,
+                                        " color=", (int)charHairColorId,
+                                        " race=", targetRaceId, " sex=", targetSexId);
+                        }
+                    } else {
+                        LOG_WARNING("Failed to load CharSections.dbc, using hardcoded textures");
+                    }
+
+                    for (auto& tex : model.textures) {
+                        if (tex.type == 1 && tex.filename.empty()) {
+                            tex.filename = bodySkinPath;
+                        } else if (tex.type == 6) {
+                            if (!hairTexturePath.empty()) {
+                                tex.filename = hairTexturePath;
+                            } else if (tex.filename.empty()) {
+                                tex.filename = std::string("Character\\") + raceFolderName + "\\Hair00_00.blp";
+                            }
+                        } else if (tex.type == 8 && tex.filename.empty()) {
+                            if (!underwearPaths.empty()) {
+                                tex.filename = underwearPaths[0];
+                            } else {
+                                tex.filename = pelvisPath;
+                            }
                         }
                     }
-                    texInfo = appearanceComposer_->resolvePlayerTextures(model, playerRace_, playerGender_, appearanceBytes);
                 }
 
                 // Load external .anim files for sequences with external data.
@@ -3909,9 +2928,62 @@ void Application::spawnPlayerCharacter() {
 
                 charRenderer->loadModel(model, 1);
 
-                // Apply composited textures via AppearanceComposer (saves skin state for re-compositing)
-                if (useCharSections && appearanceComposer_) {
-                    appearanceComposer_->compositePlayerSkin(1, texInfo);
+                if (useCharSections) {
+                    // Save skin composite state for re-compositing on equipment changes
+                    // Include face textures so compositeWithRegions can rebuild the full base
+                    bodySkinPath_ = bodySkinPath;
+                    underwearPaths_.clear();
+                    if (!faceLowerTexturePath.empty()) underwearPaths_.push_back(faceLowerTexturePath);
+                    if (!faceUpperTexturePath.empty()) underwearPaths_.push_back(faceUpperTexturePath);
+                    for (const auto& up : underwearPaths) underwearPaths_.push_back(up);
+
+                    // Composite body skin + face + underwear overlays
+                    {
+                        std::vector<std::string> layers;
+                        layers.push_back(bodySkinPath);
+                        if (!faceLowerTexturePath.empty()) layers.push_back(faceLowerTexturePath);
+                        if (!faceUpperTexturePath.empty()) layers.push_back(faceUpperTexturePath);
+                        for (const auto& up : underwearPaths) {
+                            layers.push_back(up);
+                        }
+                        if (layers.size() > 1) {
+                            rendering::VkTexture* compositeTex = charRenderer->compositeTextures(layers);
+                            if (compositeTex != 0) {
+                                for (size_t ti = 0; ti < model.textures.size(); ti++) {
+                                    if (model.textures[ti].type == 1) {
+                                        charRenderer->setModelTexture(1, static_cast<uint32_t>(ti), compositeTex);
+                                        skinTextureSlotIndex_ = static_cast<uint32_t>(ti);
+                                        LOG_INFO("Replaced type-1 texture slot ", ti, " with composited body+face+underwear");
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // Override hair texture on GPU (type-6 slot) after model load
+                    if (!hairTexturePath.empty()) {
+                        rendering::VkTexture* hairTex = charRenderer->loadTexture(hairTexturePath);
+                        if (hairTex) {
+                            for (size_t ti = 0; ti < model.textures.size(); ti++) {
+                                if (model.textures[ti].type == 6) {
+                                    charRenderer->setModelTexture(1, static_cast<uint32_t>(ti), hairTex);
+                                    LOG_INFO("Applied DBC hair texture to slot ", ti, ": ", hairTexturePath);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    bodySkinPath_.clear();
+                    underwearPaths_.clear();
+                }
+                // Find cloak (type-2, Object Skin) texture slot index
+                for (size_t ti = 0; ti < model.textures.size(); ti++) {
+                    if (model.textures[ti].type == 2) {
+                        cloakTextureSlotIndex_ = static_cast<uint32_t>(ti);
+                        LOG_INFO("Cloak texture slot: ", ti);
+                        break;
+                    }
                 }
 
                 loaded = true;
@@ -3992,26 +3064,38 @@ void Application::spawnPlayerCharacter() {
 	        renderer->getCharacterPosition() = spawnPos;
 	        renderer->setCharacterFollow(instanceId);
 
-	        // Build default geosets for the active character via AppearanceComposer
+	        // Default geosets for the active character (match CharacterPreview logic).
+	        // Previous hardcoded values (notably always inserting 101) caused wrong hair meshes in-world.
+	        std::unordered_set<uint16_t> activeGeosets;
+	        // Body parts (group 0: IDs 0-99, some models use up to 27)
+	        for (uint16_t i = 0; i <= 99; i++) activeGeosets.insert(i);
+
 	        uint8_t hairStyleId = 0;
 	        uint8_t facialId = 0;
-	        uint8_t raceId = 0;
-	        uint8_t sexId = 0;
 	        if (gameHandler) {
 	            if (const game::Character* ch = gameHandler->getActiveCharacter()) {
 	                hairStyleId = static_cast<uint8_t>((ch->appearanceBytes >> 16) & 0xFF);
 	                facialId = ch->facialFeatures;
-	                raceId = static_cast<uint8_t>(ch->race);
-	                sexId = static_cast<uint8_t>(ch->gender);
 	            }
 	        }
-	        auto activeGeosets = appearanceComposer_
-	            ? appearanceComposer_->buildDefaultPlayerGeosets(raceId, sexId, hairStyleId, facialId)
-	            : std::unordered_set<uint16_t>{};
+	        // Hair style geoset: group 1 = 100 + variation + 1
+	        activeGeosets.insert(static_cast<uint16_t>(100 + hairStyleId + 1));
+	        // Facial hair geoset: group 2 = 200 + variation + 1
+	        activeGeosets.insert(static_cast<uint16_t>(200 + facialId + 1));
+	        activeGeosets.insert(401);   // Bare forearms (no gloves) — group 4
+	        activeGeosets.insert(502);   // Bare shins (no boots) — group 5
+	        activeGeosets.insert(702);   // Ears: default
+	        activeGeosets.insert(801);   // Bare wrists (no chest armor sleeves) — group 8
+	        activeGeosets.insert(902);   // Kneepads: default — group 9
+	        activeGeosets.insert(1301);  // Bare legs (no pants) — group 13
+	        activeGeosets.insert(1502);  // No cloak — group 15
+	        activeGeosets.insert(2002);  // Bare feet — group 20
+	        // 1703 = DK eye glow mesh — skip for normal characters
+	        // Normal eyes are part of the face texture on the body mesh
 	        charRenderer->setActiveGeosets(instanceId, activeGeosets);
 
-        // Play idle animation
-        charRenderer->playAnimation(instanceId, rendering::anim::STAND, true);
+        // Play idle animation (Stand = animation ID 0)
+        charRenderer->playAnimation(instanceId, 0, true);
         LOG_INFO("Spawned player character at (",
                 static_cast<int>(spawnPos.x), ", ",
                 static_cast<int>(spawnPos.y), ", ",
@@ -4019,7 +3103,7 @@ void Application::spawnPlayerCharacter() {
         playerCharacterSpawned = true;
 
         // Set voice profile to match character race/gender
-        if (auto* asm_ = audioCoordinator_ ? audioCoordinator_->getActivitySoundManager() : nullptr) {
+        if (auto* asm_ = renderer->getActivitySoundManager()) {
             const char* raceFolder = "Human";
             const char* raceBase = "Human";
             switch (playerRace_) {
@@ -4062,10 +3146,289 @@ void Application::spawnPlayerCharacter() {
         }
 
         // Load equipped weapons (sword + shield)
-        if (appearanceComposer_) appearanceComposer_->loadEquippedWeapons();
+        loadEquippedWeapons();
     }
 }
 
+void Application::loadEquippedWeapons() {
+    if (!renderer || !renderer->getCharacterRenderer() || !assetManager || !assetManager->isInitialized())
+        return;
+    if (!gameHandler) return;
+
+    auto* charRenderer = renderer->getCharacterRenderer();
+    uint32_t charInstanceId = renderer->getCharacterInstanceId();
+    if (charInstanceId == 0) return;
+
+    auto& inventory = gameHandler->getInventory();
+
+    // Load ItemDisplayInfo.dbc
+    auto displayInfoDbc = assetManager->loadDBC("ItemDisplayInfo.dbc");
+    if (!displayInfoDbc) {
+        LOG_WARNING("loadEquippedWeapons: failed to load ItemDisplayInfo.dbc");
+        return;
+    }
+    // Mapping: EquipSlot → attachment ID (1=RightHand, 2=LeftHand)
+    struct WeaponSlot {
+        game::EquipSlot slot;
+        uint32_t attachmentId;
+    };
+    WeaponSlot weaponSlots[] = {
+        { game::EquipSlot::MAIN_HAND, 1 },
+        { game::EquipSlot::OFF_HAND,  2 },
+    };
+
+    if (weaponsSheathed_) {
+        for (const auto& ws : weaponSlots) {
+            charRenderer->detachWeapon(charInstanceId, ws.attachmentId);
+        }
+        return;
+    }
+
+    for (const auto& ws : weaponSlots) {
+        const auto& equipSlot = inventory.getEquipSlot(ws.slot);
+
+        // If slot is empty or has no displayInfoId, detach any existing weapon
+        if (equipSlot.empty() || equipSlot.item.displayInfoId == 0) {
+            charRenderer->detachWeapon(charInstanceId, ws.attachmentId);
+            continue;
+        }
+
+        uint32_t displayInfoId = equipSlot.item.displayInfoId;
+        int32_t recIdx = displayInfoDbc->findRecordById(displayInfoId);
+        if (recIdx < 0) {
+            LOG_WARNING("loadEquippedWeapons: displayInfoId ", displayInfoId, " not found in DBC");
+            charRenderer->detachWeapon(charInstanceId, ws.attachmentId);
+            continue;
+        }
+
+        const auto* idiL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
+        std::string modelName = displayInfoDbc->getString(static_cast<uint32_t>(recIdx), idiL ? (*idiL)["LeftModel"] : 1);
+        std::string textureName = displayInfoDbc->getString(static_cast<uint32_t>(recIdx), idiL ? (*idiL)["LeftModelTexture"] : 3);
+
+        if (modelName.empty()) {
+            LOG_WARNING("loadEquippedWeapons: empty model name for displayInfoId ", displayInfoId);
+            charRenderer->detachWeapon(charInstanceId, ws.attachmentId);
+            continue;
+        }
+
+        // Convert .mdx → .m2
+        std::string modelFile = modelName;
+        {
+            size_t dotPos = modelFile.rfind('.');
+            if (dotPos != std::string::npos) {
+                modelFile = modelFile.substr(0, dotPos) + ".m2";
+            } else {
+                modelFile += ".m2";
+            }
+        }
+
+        // Try Weapon directory first, then Shield
+        std::string m2Path = "Item\\ObjectComponents\\Weapon\\" + modelFile;
+        auto m2Data = assetManager->readFile(m2Path);
+        if (m2Data.empty()) {
+            m2Path = "Item\\ObjectComponents\\Shield\\" + modelFile;
+            m2Data = assetManager->readFile(m2Path);
+        }
+        if (m2Data.empty()) {
+            LOG_WARNING("loadEquippedWeapons: failed to read ", modelFile);
+            charRenderer->detachWeapon(charInstanceId, ws.attachmentId);
+            continue;
+        }
+
+        auto weaponModel = pipeline::M2Loader::load(m2Data);
+
+        // Load skin file
+        std::string skinFile = modelFile;
+        {
+            size_t dotPos = skinFile.rfind('.');
+            if (dotPos != std::string::npos) {
+                skinFile = skinFile.substr(0, dotPos) + "00.skin";
+            }
+        }
+        // Try same directory as m2
+        std::string skinDir = m2Path.substr(0, m2Path.rfind('\\') + 1);
+        auto skinData = assetManager->readFile(skinDir + skinFile);
+        if (!skinData.empty() && weaponModel.version >= 264) {
+            pipeline::M2Loader::loadSkin(skinData, weaponModel);
+        }
+
+        if (!weaponModel.isValid()) {
+            LOG_WARNING("loadEquippedWeapons: invalid weapon model from ", m2Path);
+            charRenderer->detachWeapon(charInstanceId, ws.attachmentId);
+            continue;
+        }
+
+        // Build texture path
+        std::string texturePath;
+        if (!textureName.empty()) {
+            texturePath = "Item\\ObjectComponents\\Weapon\\" + textureName + ".blp";
+            if (!assetManager->fileExists(texturePath)) {
+                texturePath = "Item\\ObjectComponents\\Shield\\" + textureName + ".blp";
+            }
+        }
+
+        uint32_t weaponModelId = nextWeaponModelId_++;
+        bool ok = charRenderer->attachWeapon(charInstanceId, ws.attachmentId,
+                                              weaponModel, weaponModelId, texturePath);
+        if (ok) {
+            LOG_INFO("Equipped weapon: ", m2Path, " at attachment ", ws.attachmentId);
+        }
+    }
+}
+
+bool Application::tryAttachCreatureVirtualWeapons(uint64_t guid, uint32_t instanceId) {
+    if (!renderer || !renderer->getCharacterRenderer() || !assetManager || !gameHandler) return false;
+    auto* charRenderer = renderer->getCharacterRenderer();
+    if (!charRenderer) return false;
+
+    auto entity = gameHandler->getEntityManager().getEntity(guid);
+    if (!entity || entity->getType() != game::ObjectType::UNIT) return false;
+    auto unit = std::static_pointer_cast<game::Unit>(entity);
+    if (!unit) return false;
+
+    // Virtual weapons are only appropriate for humanoid-style displays.
+    // Non-humanoids (wolves/boars/etc.) can expose non-zero virtual item fields
+    // and otherwise end up with comedic floating weapons.
+    uint32_t displayId = unit->getDisplayId();
+    auto dIt = displayDataMap_.find(displayId);
+    if (dIt == displayDataMap_.end()) return false;
+    uint32_t extraDisplayId = dIt->second.extraDisplayId;
+    if (extraDisplayId == 0 || humanoidExtraMap_.find(extraDisplayId) == humanoidExtraMap_.end()) {
+        return false;
+    }
+
+    auto itemDisplayDbc = assetManager->loadDBC("ItemDisplayInfo.dbc");
+    if (!itemDisplayDbc) return false;
+    auto itemDbc = assetManager->loadDBC("Item.dbc");
+    const auto* idiL = pipeline::getActiveDBCLayout()
+        ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
+    const auto* itemL = pipeline::getActiveDBCLayout()
+        ? pipeline::getActiveDBCLayout()->getLayout("Item") : nullptr;
+
+    auto resolveDisplayInfoId = [&](uint32_t rawId) -> uint32_t {
+        if (rawId == 0) return 0;
+        // AzerothCore uses item entries in UNIT_VIRTUAL_ITEM_SLOT_ID.
+        // Resolve strictly through Item.dbc entry -> DisplayID to avoid
+        // accidental ItemDisplayInfo ID collisions (staff/hilt mismatches).
+        if (itemDbc) {
+            int32_t itemRec = itemDbc->findRecordById(rawId); // treat as item entry
+            if (itemRec >= 0) {
+                const uint32_t dispFieldPrimary = itemL ? (*itemL)["DisplayID"] : 5u;
+                uint32_t displayIdA = itemDbc->getUInt32(static_cast<uint32_t>(itemRec), dispFieldPrimary);
+                if (displayIdA != 0 && itemDisplayDbc->findRecordById(displayIdA) >= 0) {
+                    return displayIdA;
+                }
+            }
+        }
+        return 0;
+    };
+
+    auto attachNpcWeaponDisplay = [&](uint32_t itemDisplayId, uint32_t attachmentId) -> bool {
+        uint32_t resolvedDisplayId = resolveDisplayInfoId(itemDisplayId);
+        if (resolvedDisplayId == 0) return false;
+        int32_t recIdx = itemDisplayDbc->findRecordById(resolvedDisplayId);
+        if (recIdx < 0) return false;
+
+        const uint32_t modelFieldL = idiL ? (*idiL)["LeftModel"] : 1u;
+        const uint32_t modelFieldR = idiL ? (*idiL)["RightModel"] : 2u;
+        const uint32_t texFieldL = idiL ? (*idiL)["LeftModelTexture"] : 3u;
+        const uint32_t texFieldR = idiL ? (*idiL)["RightModelTexture"] : 4u;
+        // Prefer LeftModel (stock player equipment path uses LeftModel and avoids
+        // the "hilt-only" variants seen when forcing RightModel).
+        std::string modelName = itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), modelFieldL);
+        std::string textureName = itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), texFieldL);
+        if (modelName.empty()) {
+            modelName = itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), modelFieldR);
+            textureName = itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), texFieldR);
+        }
+        if (modelName.empty()) return false;
+
+        std::string modelFile = modelName;
+        size_t dotPos = modelFile.rfind('.');
+        if (dotPos != std::string::npos) modelFile = modelFile.substr(0, dotPos);
+        modelFile += ".m2";
+
+        // Main-hand NPC weapon path: only use actual weapon models.
+        // This avoids shields/placeholder hilts being attached incorrectly.
+        std::string m2Path = "Item\\ObjectComponents\\Weapon\\" + modelFile;
+        auto m2Data = assetManager->readFile(m2Path);
+        if (m2Data.empty()) return false;
+
+        auto weaponModel = pipeline::M2Loader::load(m2Data);
+        std::string skinFile = modelFile;
+        size_t skinDot = skinFile.rfind('.');
+        if (skinDot != std::string::npos) skinFile = skinFile.substr(0, skinDot);
+        skinFile += "00.skin";
+        std::string skinDir = m2Path.substr(0, m2Path.rfind('\\') + 1);
+        auto skinData = assetManager->readFile(skinDir + skinFile);
+        if (!skinData.empty() && weaponModel.version >= 264) {
+            pipeline::M2Loader::loadSkin(skinData, weaponModel);
+        }
+        if (!weaponModel.isValid()) return false;
+
+        std::string texturePath;
+        if (!textureName.empty()) {
+            texturePath = "Item\\ObjectComponents\\Weapon\\" + textureName + ".blp";
+            if (!assetManager->fileExists(texturePath)) texturePath.clear();
+        }
+
+        uint32_t weaponModelId = nextWeaponModelId_++;
+        return charRenderer->attachWeapon(instanceId, attachmentId, weaponModel, weaponModelId, texturePath);
+    };
+
+    auto hasResolvableWeaponModel = [&](uint32_t itemDisplayId) -> bool {
+        uint32_t resolvedDisplayId = resolveDisplayInfoId(itemDisplayId);
+        if (resolvedDisplayId == 0) return false;
+        int32_t recIdx = itemDisplayDbc->findRecordById(resolvedDisplayId);
+        if (recIdx < 0) return false;
+        const uint32_t modelFieldL = idiL ? (*idiL)["LeftModel"] : 1u;
+        const uint32_t modelFieldR = idiL ? (*idiL)["RightModel"] : 2u;
+        std::string modelName = itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), modelFieldL);
+        if (modelName.empty()) {
+            modelName = itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), modelFieldR);
+        }
+        if (modelName.empty()) return false;
+        std::string modelFile = modelName;
+        size_t dotPos = modelFile.rfind('.');
+        if (dotPos != std::string::npos) modelFile = modelFile.substr(0, dotPos);
+        modelFile += ".m2";
+        return assetManager->fileExists("Item\\ObjectComponents\\Weapon\\" + modelFile);
+    };
+
+    bool attachedMain = false;
+    bool hadWeaponCandidate = false;
+
+    const uint16_t candidateBases[] = {56, 57, 58, 70, 148, 149, 150, 151, 152};
+    for (uint16_t base : candidateBases) {
+        uint32_t v0 = entity->getField(static_cast<uint16_t>(base + 0));
+        if (v0 != 0) hadWeaponCandidate = true;
+        if (!attachedMain && v0 != 0) attachedMain = attachNpcWeaponDisplay(v0, 1);
+        if (attachedMain) break;
+    }
+
+    uint16_t unitEnd = game::fieldIndex(game::UF::UNIT_END);
+    uint16_t scanLo = 60;
+    uint16_t scanHi = (unitEnd != 0xFFFF) ? static_cast<uint16_t>(unitEnd + 96) : 320;
+    std::map<uint16_t, uint32_t> candidateByIndex;
+    for (const auto& [idx, val] : entity->getFields()) {
+        if (idx < scanLo || idx > scanHi) continue;
+        if (val == 0) continue;
+        if (hasResolvableWeaponModel(val)) {
+            candidateByIndex[idx] = val;
+            hadWeaponCandidate = true;
+        }
+    }
+    for (const auto& [idx, val] : candidateByIndex) {
+        if (!attachedMain) attachedMain = attachNpcWeaponDisplay(val, 1);
+        if (attachedMain) break;
+    }
+
+    // Force off-hand clear in NPC path to avoid incorrect shields/placeholder hilts.
+    charRenderer->detachWeapon(instanceId, 2);
+    // Success if main-hand attached when there was at least one candidate.
+    return hadWeaponCandidate && attachedMain;
+}
+
 void Application::buildFactionHostilityMap(uint8_t playerRace) {
     if (!assetManager || !assetManager->isInitialized() || !gameHandler) return;
 
@@ -4121,7 +3484,7 @@ void Application::buildFactionHostilityMap(uint8_t playerRace) {
                 }
             }
         }
-        LOG_INFO("Faction.dbc: ", hostileParentFactions.size(), " factions hostile to race ", static_cast<int>(playerRace));
+        LOG_INFO("Faction.dbc: ", hostileParentFactions.size(), " factions hostile to race ", (int)playerRace);
     }
 
     // Get player faction template data
@@ -4189,25 +3552,4676 @@ void Application::buildFactionHostilityMap(uint8_t playerRace) {
     uint32_t hostileCount = 0;
     for (const auto& [fid, h] : factionMap) { if (h) hostileCount++; }
     gameHandler->setFactionHostileMap(std::move(factionMap));
-    LOG_INFO("Faction hostility for race ", static_cast<int>(playerRace), " (FT ", playerFtId, "): ",
+    LOG_INFO("Faction hostility for race ", (int)playerRace, " (FT ", playerFtId, "): ",
         hostileCount, "/", ftDbc->getRecordCount(),
         " hostile (friendGroup=0x", std::hex, playerFriendGroup, ", enemyGroup=0x", playerEnemyGroup, std::dec, ")");
 }
 
-// Render bounds/position queries — delegates to EntitySpawner
+void Application::loadOnlineWorldTerrain(uint32_t mapId, float x, float y, float z) {
+    if (!renderer || !assetManager || !assetManager->isInitialized()) {
+        LOG_WARNING("Cannot load online terrain: renderer or assets not ready");
+        return;
+    }
+
+    // Guard against re-entrant calls.  The worldEntryCallback defers new
+    // entries while this flag is set; we process them at the end.
+    loadingWorld_ = true;
+    pendingWorldEntry_.reset();
+
+    // --- Loading screen for online mode ---
+    rendering::LoadingScreen loadingScreen;
+    loadingScreen.setVkContext(window->getVkContext());
+    loadingScreen.setSDLWindow(window->getSDLWindow());
+    bool loadingScreenOk = loadingScreen.initialize();
+
+    auto showProgress = [&](const char* msg, float progress) {
+        SDL_Event event;
+        while (SDL_PollEvent(&event)) {
+            if (event.type == SDL_QUIT) {
+                window->setShouldClose(true);
+                loadingScreen.shutdown();
+                return;
+            }
+            if (event.type == SDL_WINDOWEVENT &&
+                event.window.event == SDL_WINDOWEVENT_RESIZED) {
+                int w = event.window.data1;
+                int h = event.window.data2;
+                window->setSize(w, h);
+                // Vulkan viewport set in command buffer
+                if (renderer && renderer->getCamera()) {
+                    renderer->getCamera()->setAspectRatio(static_cast<float>(w) / h);
+                }
+            }
+        }
+        if (!loadingScreenOk) return;
+        loadingScreen.setStatus(msg);
+        loadingScreen.setProgress(progress);
+        loadingScreen.render();
+        window->swapBuffers();
+    };
+
+    showProgress("Entering world...", 0.0f);
+
+    // --- Clean up previous map's state on map change ---
+    // (Same cleanup as logout, but preserves player identity and renderer objects.)
+    LOG_WARNING("loadOnlineWorldTerrain: mapId=", mapId, " loadedMapId_=", loadedMapId_);
+    bool hasRendererData = renderer && (renderer->getWMORenderer() || renderer->getM2Renderer());
+    if (loadedMapId_ != 0xFFFFFFFF || hasRendererData) {
+        LOG_WARNING("Map change: cleaning up old map ", loadedMapId_, " before loading map ", mapId);
+
+        // Clear pending queues first (these don't touch GPU resources)
+        pendingCreatureSpawns_.clear();
+        pendingCreatureSpawnGuids_.clear();
+        creatureSpawnRetryCounts_.clear();
+        pendingPlayerSpawns_.clear();
+        pendingPlayerSpawnGuids_.clear();
+        pendingOnlinePlayerEquipment_.clear();
+        deferredEquipmentQueue_.clear();
+        pendingGameObjectSpawns_.clear();
+        pendingTransportMoves_.clear();
+        pendingTransportDoodadBatches_.clear();
+
+        if (renderer) {
+            // Clear all world geometry from old map (including textures/models).
+            // WMO clearAll and M2 clear both call vkDeviceWaitIdle internally,
+            // ensuring no GPU command buffers reference old resources.
+            if (auto* wmo = renderer->getWMORenderer()) {
+                wmo->clearAll();
+            }
+            if (auto* m2 = renderer->getM2Renderer()) {
+                m2->clear();
+            }
+
+            // Full clear of character renderer: removes all instances, models,
+            // textures, and resets descriptor pools.  This prevents stale GPU
+            // resources from accumulating across map changes (old creature
+            // models, bone buffers, texture descriptor sets) which can cause
+            // VK_ERROR_DEVICE_LOST on some drivers.
+            if (auto* cr = renderer->getCharacterRenderer()) {
+                cr->clear();
+                renderer->setCharacterFollow(0);
+            }
+            // Reset equipment dirty tracking so composited textures are rebuilt
+            // after spawnPlayerCharacter() recreates the character instance.
+            if (gameHandler) {
+                gameHandler->resetEquipmentDirtyTracking();
+            }
+
+            if (auto* terrain = renderer->getTerrainManager()) {
+                terrain->softReset();
+                terrain->setStreamingEnabled(true);  // Re-enable in case previous map disabled it
+            }
+            if (auto* questMarkers = renderer->getQuestMarkerRenderer()) {
+                questMarkers->clear();
+            }
+            renderer->clearMount();
+        }
+
+        // Clear application-level instance tracking (after renderer cleanup)
+        creatureInstances_.clear();
+        creatureModelIds_.clear();
+        creatureRenderPosCache_.clear();
+        creatureWeaponsAttached_.clear();
+        creatureWeaponAttachAttempts_.clear();
+        deadCreatureGuids_.clear();
+        nonRenderableCreatureDisplayIds_.clear();
+        creaturePermanentFailureGuids_.clear();
+        modelIdIsWolfLike_.clear();
+        displayIdTexturesApplied_.clear();
+        charSectionsCache_.clear();
+        charSectionsCacheBuilt_ = false;
+        for (auto& load : asyncCreatureLoads_) {
+            if (load.future.valid()) load.future.wait();
+        }
+        asyncCreatureLoads_.clear();
+
+        playerInstances_.clear();
+        onlinePlayerAppearance_.clear();
+
+        gameObjectInstances_.clear();
+        gameObjectDisplayIdModelCache_.clear();
+
+        // Force player character re-spawn on new map
+        playerCharacterSpawned = false;
+    }
+
+    // Resolve map folder name from Map.dbc (authoritative for world/instance maps).
+    // This is required for instances like DeeprunTram (map 369) that are not Azeroth/Kalimdor.
+    if (!mapNameCacheLoaded_ && assetManager) {
+        mapNameCacheLoaded_ = true;
+        if (auto mapDbc = assetManager->loadDBC("Map.dbc"); mapDbc && mapDbc->isLoaded()) {
+            mapNameById_.reserve(mapDbc->getRecordCount());
+            const auto* mapL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("Map") : nullptr;
+            for (uint32_t i = 0; i < mapDbc->getRecordCount(); i++) {
+                uint32_t id = mapDbc->getUInt32(i, mapL ? (*mapL)["ID"] : 0);
+                std::string internalName = mapDbc->getString(i, mapL ? (*mapL)["InternalName"] : 1);
+                if (!internalName.empty() && mapNameById_.find(id) == mapNameById_.end()) {
+                    mapNameById_[id] = std::move(internalName);
+                }
+            }
+            LOG_INFO("Loaded Map.dbc map-name cache: ", mapNameById_.size(), " entries");
+        } else {
+            LOG_WARNING("Map.dbc not available; using fallback map-id mapping");
+        }
+    }
+
+    std::string mapName;
+    if (auto it = mapNameById_.find(mapId); it != mapNameById_.end()) {
+        mapName = it->second;
+    } else {
+        mapName = mapIdToName(mapId);
+    }
+    if (mapName.empty()) {
+        LOG_WARNING("Unknown mapId ", mapId, " (no Map.dbc entry); falling back to Azeroth");
+        mapName = "Azeroth";
+    }
+    LOG_INFO("Loading online world terrain for map '", mapName, "' (ID ", mapId, ")");
+
+    // Cancel any stale preload (if it was for a different map, the file cache
+    // still retains whatever was loaded — it doesn't hurt).
+    if (worldPreload_) {
+        if (worldPreload_->mapId == mapId) {
+            LOG_INFO("World preload: cache-warm hit for map '", mapName, "'");
+        } else {
+            LOG_INFO("World preload: map mismatch (preloaded ", worldPreload_->mapName,
+                     ", entering ", mapName, ")");
+        }
+    }
+    cancelWorldPreload();
+
+    // Save this world info for next session's early preload
+    saveLastWorldInfo(mapId, mapName, x, y);
+
+    // Convert server coordinates to canonical WoW coordinates
+    // Server sends: X=West (canonical.Y), Y=North (canonical.X), Z=Up
+    glm::vec3 spawnCanonical = core::coords::serverToCanonical(glm::vec3(x, y, z));
+    glm::vec3 spawnRender = core::coords::canonicalToRender(spawnCanonical);
+
+    // Set camera position and facing from server orientation
+    if (renderer->getCameraController()) {
+        float yawDeg = 0.0f;
+        if (gameHandler) {
+            float canonicalYaw = gameHandler->getMovementInfo().orientation;
+            yawDeg = 180.0f - glm::degrees(canonicalYaw);
+        }
+        renderer->getCameraController()->setOnlineMode(true);
+        renderer->getCameraController()->setDefaultSpawn(spawnRender, yawDeg, -15.0f);
+        renderer->getCameraController()->reset();
+    }
+
+    // Set map name for WMO renderer and reset instance mode
+    if (renderer->getWMORenderer()) {
+        renderer->getWMORenderer()->setMapName(mapName);
+        renderer->getWMORenderer()->setWMOOnlyMap(false);
+    }
+
+    // Set map name for terrain manager
+    if (renderer->getTerrainManager()) {
+        renderer->getTerrainManager()->setMapName(mapName);
+    }
+
+    // NOTE: TransportManager renderer connection moved to after initializeRenderers (later in this function)
+
+    // Connect WMORenderer to M2Renderer (for hierarchical transforms: doodads following WMO parents)
+    if (renderer->getWMORenderer() && renderer->getM2Renderer()) {
+        renderer->getWMORenderer()->setM2Renderer(renderer->getM2Renderer());
+        LOG_INFO("WMORenderer connected to M2Renderer for hierarchical doodad transforms");
+    }
+
+    showProgress("Loading character model...", 0.05f);
+
+    // Build faction hostility map for this character's race
+    if (gameHandler) {
+        const game::Character* activeChar = gameHandler->getActiveCharacter();
+        if (activeChar) {
+            buildFactionHostilityMap(static_cast<uint8_t>(activeChar->race));
+        }
+    }
+
+    // Spawn player model for online mode (skip if already spawned, e.g. teleport)
+    if (gameHandler) {
+        const game::Character* activeChar = gameHandler->getActiveCharacter();
+        if (activeChar) {
+            const uint64_t activeGuid = gameHandler->getActiveCharacterGuid();
+            const bool appearanceChanged =
+                (activeGuid != spawnedPlayerGuid_) ||
+                (activeChar->appearanceBytes != spawnedAppearanceBytes_) ||
+                (activeChar->facialFeatures != spawnedFacialFeatures_) ||
+                (activeChar->race != playerRace_) ||
+                (activeChar->gender != playerGender_) ||
+                (activeChar->characterClass != playerClass_);
+
+            if (!playerCharacterSpawned || appearanceChanged) {
+                if (appearanceChanged) {
+                    LOG_INFO("Respawning player model for new/changed character: guid=0x",
+                             std::hex, activeGuid, std::dec);
+                }
+                // Remove old instance so we don't keep stale visuals.
+                if (renderer && renderer->getCharacterRenderer()) {
+                    uint32_t oldInst = renderer->getCharacterInstanceId();
+                    if (oldInst > 0) {
+                        renderer->setCharacterFollow(0);
+                        renderer->clearMount();
+                        renderer->getCharacterRenderer()->removeInstance(oldInst);
+                    }
+                }
+                playerCharacterSpawned = false;
+                spawnedPlayerGuid_ = 0;
+                spawnedAppearanceBytes_ = 0;
+                spawnedFacialFeatures_ = 0;
+
+                playerRace_ = activeChar->race;
+                playerGender_ = activeChar->gender;
+                playerClass_ = activeChar->characterClass;
+                spawnSnapToGround = false;
+                weaponsSheathed_ = false;
+                loadEquippedWeapons(); // will no-op until instance exists
+                spawnPlayerCharacter();
+            }
+            renderer->getCharacterPosition() = spawnRender;
+            LOG_INFO("Online player at render pos (", spawnRender.x, ", ", spawnRender.y, ", ", spawnRender.z, ")");
+        } else {
+            LOG_WARNING("No active character found for player model spawning");
+        }
+    }
+
+    showProgress("Loading terrain...", 0.20f);
+
+    // Check WDT to detect WMO-only maps (dungeons, raids, BGs)
+    bool isWMOOnlyMap = false;
+    pipeline::WDTInfo wdtInfo;
+    {
+        std::string wdtPath = "World\\Maps\\" + mapName + "\\" + mapName + ".wdt";
+        LOG_WARNING("Reading WDT: ", wdtPath);
+        std::vector<uint8_t> wdtData = assetManager->readFile(wdtPath);
+        if (!wdtData.empty()) {
+            wdtInfo = pipeline::parseWDT(wdtData);
+            isWMOOnlyMap = wdtInfo.isWMOOnly() && !wdtInfo.rootWMOPath.empty();
+            LOG_WARNING("WDT result: isWMOOnly=", isWMOOnlyMap, " rootWMO='", wdtInfo.rootWMOPath, "'");
+        } else {
+            LOG_WARNING("No WDT file found at ", wdtPath);
+        }
+    }
+
+    bool terrainOk = false;
+
+    if (isWMOOnlyMap) {
+        // ---- WMO-only map (dungeon/raid/BG): load root WMO directly ----
+        LOG_WARNING("WMO-only map detected — loading root WMO: ", wdtInfo.rootWMOPath);
+        showProgress("Loading instance geometry...", 0.25f);
+
+        // Initialize renderers if they don't exist yet (first login to a WMO-only map).
+        // On map change, renderers already exist from the previous map.
+        if (!renderer->getWMORenderer() || !renderer->getTerrainManager()) {
+            renderer->initializeRenderers(assetManager.get(), mapName);
+        }
+
+        // Set map name on WMO renderer and disable terrain streaming (no ADT tiles for instances)
+        if (renderer->getWMORenderer()) {
+            renderer->getWMORenderer()->setMapName(mapName);
+            renderer->getWMORenderer()->setWMOOnlyMap(true);
+        }
+        if (renderer->getTerrainManager()) {
+            renderer->getTerrainManager()->setStreamingEnabled(false);
+        }
+
+        // Spawn player character now that renderers are initialized
+        if (!playerCharacterSpawned) {
+            spawnPlayerCharacter();
+            loadEquippedWeapons();
+        }
+
+        // Load the root WMO
+        auto* wmoRenderer = renderer->getWMORenderer();
+        LOG_WARNING("WMO-only: wmoRenderer=", (wmoRenderer ? "valid" : "NULL"));
+        if (wmoRenderer) {
+            LOG_WARNING("WMO-only: reading root WMO file: ", wdtInfo.rootWMOPath);
+            std::vector<uint8_t> wmoData = assetManager->readFile(wdtInfo.rootWMOPath);
+            LOG_WARNING("WMO-only: root WMO data size=", wmoData.size());
+            if (!wmoData.empty()) {
+                pipeline::WMOModel wmoModel = pipeline::WMOLoader::load(wmoData);
+                LOG_WARNING("WMO-only: parsed WMO model, nGroups=", wmoModel.nGroups);
+
+                if (wmoModel.nGroups > 0) {
+                    showProgress("Loading instance groups...", 0.35f);
+                    std::string basePath = wdtInfo.rootWMOPath;
+                    std::string extension;
+                    if (basePath.size() > 4) {
+                        extension = basePath.substr(basePath.size() - 4);
+                        std::string extLower = extension;
+                        for (char& c : extLower) c = std::tolower(c);
+                        if (extLower == ".wmo") {
+                            basePath = basePath.substr(0, basePath.size() - 4);
+                        }
+                    }
+
+                    uint32_t loadedGroups = 0;
+                    for (uint32_t gi = 0; gi < wmoModel.nGroups; gi++) {
+                        char groupSuffix[16];
+                        snprintf(groupSuffix, sizeof(groupSuffix), "_%03u%s", gi, extension.c_str());
+                        std::string groupPath = basePath + groupSuffix;
+                        std::vector<uint8_t> groupData = assetManager->readFile(groupPath);
+                        if (groupData.empty()) {
+                            snprintf(groupSuffix, sizeof(groupSuffix), "_%03u.wmo", gi);
+                            groupData = assetManager->readFile(basePath + groupSuffix);
+                        }
+                        if (groupData.empty()) {
+                            snprintf(groupSuffix, sizeof(groupSuffix), "_%03u.WMO", gi);
+                            groupData = assetManager->readFile(basePath + groupSuffix);
+                        }
+                        if (!groupData.empty()) {
+                            pipeline::WMOLoader::loadGroup(groupData, wmoModel, gi);
+                            loadedGroups++;
+                        }
+
+                        // Update loading progress
+                        if (wmoModel.nGroups > 1) {
+                            float groupProgress = 0.35f + 0.30f * static_cast<float>(gi + 1) / wmoModel.nGroups;
+                            char buf[128];
+                            snprintf(buf, sizeof(buf), "Loading instance groups... %u / %u", gi + 1, wmoModel.nGroups);
+                            showProgress(buf, groupProgress);
+                        }
+                    }
+
+                    LOG_INFO("Loaded ", loadedGroups, " / ", wmoModel.nGroups, " WMO groups for instance");
+                }
+
+                // WMO-only maps: MODF uses same format as ADT MODF.
+                // Apply the same rotation conversion that outdoor WMOs get
+                // (including the implicit +180° Z yaw), but skip the ZEROPOINT
+                // position offset for zero-position instances (server sends
+                // coordinates relative to the WMO, not relative to map corner).
+                glm::vec3 wmoPos(0.0f);
+                glm::vec3 wmoRot(
+                    -wdtInfo.rotation[2] * 3.14159f / 180.0f,
+                    -wdtInfo.rotation[0] * 3.14159f / 180.0f,
+                    (wdtInfo.rotation[1] + 180.0f) * 3.14159f / 180.0f
+                );
+                if (wdtInfo.position[0] != 0.0f || wdtInfo.position[1] != 0.0f || wdtInfo.position[2] != 0.0f) {
+                    wmoPos = core::coords::adtToWorld(
+                        wdtInfo.position[0], wdtInfo.position[1], wdtInfo.position[2]);
+                }
+
+                showProgress("Uploading instance geometry...", 0.70f);
+                uint32_t wmoModelId = 900000 + mapId;  // Unique ID range for instance WMOs
+                if (wmoRenderer->loadModel(wmoModel, wmoModelId)) {
+                    uint32_t instanceId = wmoRenderer->createInstance(wmoModelId, wmoPos, wmoRot, 1.0f);
+                    if (instanceId > 0) {
+                        LOG_WARNING("Instance WMO loaded: modelId=", wmoModelId,
+                                " instanceId=", instanceId);
+                        LOG_WARNING("  MOHD bbox local: (",
+                                   wmoModel.boundingBoxMin.x, ", ", wmoModel.boundingBoxMin.y, ", ", wmoModel.boundingBoxMin.z,
+                                   ") to (", wmoModel.boundingBoxMax.x, ", ", wmoModel.boundingBoxMax.y, ", ", wmoModel.boundingBoxMax.z, ")");
+                        LOG_WARNING("  WMO pos: (", wmoPos.x, ", ", wmoPos.y, ", ", wmoPos.z,
+                                   ") rot: (", wmoRot.x, ", ", wmoRot.y, ", ", wmoRot.z, ")");
+                        LOG_WARNING("  Player render pos: (", spawnRender.x, ", ", spawnRender.y, ", ", spawnRender.z, ")");
+                        LOG_WARNING("  Player canonical: (", spawnCanonical.x, ", ", spawnCanonical.y, ", ", spawnCanonical.z, ")");
+                        // Show player position in WMO local space
+                        {
+                            glm::mat4 instMat(1.0f);
+                            instMat = glm::translate(instMat, wmoPos);
+                            instMat = glm::rotate(instMat, wmoRot.z, glm::vec3(0,0,1));
+                            instMat = glm::rotate(instMat, wmoRot.y, glm::vec3(0,1,0));
+                            instMat = glm::rotate(instMat, wmoRot.x, glm::vec3(1,0,0));
+                            glm::mat4 invMat = glm::inverse(instMat);
+                            glm::vec3 localPlayer = glm::vec3(invMat * glm::vec4(spawnRender, 1.0f));
+                            LOG_WARNING("  Player in WMO local: (", localPlayer.x, ", ", localPlayer.y, ", ", localPlayer.z, ")");
+                            bool inside = localPlayer.x >= wmoModel.boundingBoxMin.x && localPlayer.x <= wmoModel.boundingBoxMax.x &&
+                                          localPlayer.y >= wmoModel.boundingBoxMin.y && localPlayer.y <= wmoModel.boundingBoxMax.y &&
+                                          localPlayer.z >= wmoModel.boundingBoxMin.z && localPlayer.z <= wmoModel.boundingBoxMax.z;
+                            LOG_WARNING("  Player inside MOHD bbox: ", inside ? "YES" : "NO");
+                        }
+
+                        // Load doodads from the specified doodad set
+                        auto* m2Renderer = renderer->getM2Renderer();
+                        if (m2Renderer && !wmoModel.doodadSets.empty() && !wmoModel.doodads.empty()) {
+                            uint32_t setIdx = std::min(static_cast<uint32_t>(wdtInfo.doodadSet),
+                                                       static_cast<uint32_t>(wmoModel.doodadSets.size() - 1));
+                            const auto& doodadSet = wmoModel.doodadSets[setIdx];
+
+                            showProgress("Loading instance doodads...", 0.75f);
+                            glm::mat4 wmoMatrix(1.0f);
+                            wmoMatrix = glm::translate(wmoMatrix, wmoPos);
+                            wmoMatrix = glm::rotate(wmoMatrix, wmoRot.z, glm::vec3(0, 0, 1));
+                            wmoMatrix = glm::rotate(wmoMatrix, wmoRot.y, glm::vec3(0, 1, 0));
+                            wmoMatrix = glm::rotate(wmoMatrix, wmoRot.x, glm::vec3(1, 0, 0));
+
+                            uint32_t loadedDoodads = 0;
+                            for (uint32_t di = 0; di < doodadSet.count; di++) {
+                                uint32_t doodadIdx = doodadSet.startIndex + di;
+                                if (doodadIdx >= wmoModel.doodads.size()) break;
+
+                                const auto& doodad = wmoModel.doodads[doodadIdx];
+                                auto nameIt = wmoModel.doodadNames.find(doodad.nameIndex);
+                                if (nameIt == wmoModel.doodadNames.end()) continue;
+
+                                std::string m2Path = nameIt->second;
+                                if (m2Path.empty()) continue;
+
+                                if (m2Path.size() > 4) {
+                                    std::string ext = m2Path.substr(m2Path.size() - 4);
+                                    for (char& c : ext) c = std::tolower(c);
+                                    if (ext == ".mdx" || ext == ".mdl") {
+                                        m2Path = m2Path.substr(0, m2Path.size() - 4) + ".m2";
+                                    }
+                                }
+
+                                std::vector<uint8_t> m2Data = assetManager->readFile(m2Path);
+                                if (m2Data.empty()) continue;
+
+                                pipeline::M2Model m2Model = pipeline::M2Loader::load(m2Data);
+                                if (m2Model.name.empty()) m2Model.name = m2Path;
+
+                                std::string skinPath = m2Path.substr(0, m2Path.size() - 3) + "00.skin";
+                                std::vector<uint8_t> skinData = assetManager->readFile(skinPath);
+                                if (!skinData.empty() && m2Model.version >= 264) {
+                                    pipeline::M2Loader::loadSkin(skinData, m2Model);
+                                }
+                                if (!m2Model.isValid()) continue;
+
+                                glm::quat fixedRotation(doodad.rotation.w, doodad.rotation.x,
+                                                        doodad.rotation.y, doodad.rotation.z);
+                                glm::mat4 doodadLocal(1.0f);
+                                doodadLocal = glm::translate(doodadLocal, doodad.position);
+                                doodadLocal *= glm::mat4_cast(fixedRotation);
+                                doodadLocal = glm::scale(doodadLocal, glm::vec3(doodad.scale));
+
+                                glm::mat4 worldMatrix = wmoMatrix * doodadLocal;
+                                glm::vec3 worldPos = glm::vec3(worldMatrix[3]);
+
+                                uint32_t doodadModelId = static_cast<uint32_t>(std::hash<std::string>{}(m2Path));
+                                m2Renderer->loadModel(m2Model, doodadModelId);
+                                uint32_t doodadInstId = m2Renderer->createInstanceWithMatrix(doodadModelId, worldMatrix, worldPos);
+                                if (doodadInstId) m2Renderer->setSkipCollision(doodadInstId, true);
+                                loadedDoodads++;
+                            }
+                            LOG_INFO("Loaded ", loadedDoodads, " instance WMO doodads");
+                        }
+                    } else {
+                        LOG_WARNING("Failed to create instance WMO instance");
+                    }
+                } else {
+                    LOG_WARNING("Failed to load instance WMO model");
+                }
+            } else {
+                LOG_WARNING("Failed to read root WMO file: ", wdtInfo.rootWMOPath);
+            }
+
+            // Build collision cache for the instance WMO
+            showProgress("Building collision cache...", 0.88f);
+            if (loadingScreenOk) { loadingScreen.render(); window->swapBuffers(); }
+            wmoRenderer->loadFloorCache();
+            if (wmoRenderer->getFloorCacheSize() == 0) {
+                showProgress("Computing walkable surfaces...", 0.90f);
+                if (loadingScreenOk) { loadingScreen.render(); window->swapBuffers(); }
+                wmoRenderer->precomputeFloorCache();
+            }
+        }
+
+        // Snap player to WMO floor so they don't fall through on first frame
+        if (wmoRenderer && renderer) {
+            glm::vec3 playerPos = renderer->getCharacterPosition();
+            // Query floor with generous height margin above spawn point
+            auto floor = wmoRenderer->getFloorHeight(playerPos.x, playerPos.y, playerPos.z + 50.0f);
+            if (floor) {
+                playerPos.z = *floor + 0.1f;  // Small offset above floor
+                renderer->getCharacterPosition() = playerPos;
+                if (gameHandler) {
+                    glm::vec3 canonical = core::coords::renderToCanonical(playerPos);
+                    gameHandler->setPosition(canonical.x, canonical.y, canonical.z);
+                }
+                LOG_INFO("Snapped player to instance WMO floor: z=", *floor);
+            } else {
+                LOG_WARNING("Could not find WMO floor at player spawn (",
+                           playerPos.x, ", ", playerPos.y, ", ", playerPos.z, ")");
+            }
+        }
+
+        // Diagnostic: verify WMO renderer state after instance loading
+        LOG_WARNING("=== INSTANCE WMO LOAD COMPLETE ===");
+        LOG_WARNING("  wmoRenderer models loaded: ", wmoRenderer->getLoadedModelCount());
+        LOG_WARNING("  wmoRenderer instances: ", wmoRenderer->getInstanceCount());
+        LOG_WARNING("  wmoRenderer floor cache: ", wmoRenderer->getFloorCacheSize());
+
+        terrainOk = true;  // Mark as OK so post-load setup runs
+    } else {
+        // ---- Normal ADT-based map ----
+        // Compute ADT tile from canonical coordinates
+        auto [tileX, tileY] = core::coords::canonicalToTile(spawnCanonical.x, spawnCanonical.y);
+        std::string adtPath = "World\\Maps\\" + mapName + "\\" + mapName + "_" +
+                              std::to_string(tileX) + "_" + std::to_string(tileY) + ".adt";
+        LOG_INFO("Loading ADT tile [", tileX, ",", tileY, "] from canonical (",
+                 spawnCanonical.x, ", ", spawnCanonical.y, ", ", spawnCanonical.z, ")");
+
+        // Load the initial terrain tile
+        terrainOk = renderer->loadTestTerrain(assetManager.get(), adtPath);
+        if (!terrainOk) {
+            LOG_WARNING("Could not load terrain for online world - atmospheric rendering only");
+        } else {
+            LOG_INFO("Online world terrain loading initiated");
+        }
+
+        // Set map name on WMO renderer (initializeRenderers handles terrain/minimap/worldMap)
+        if (renderer->getWMORenderer()) {
+            renderer->getWMORenderer()->setMapName(mapName);
+        }
+
+        // Character renderer is created inside loadTestTerrain(), so spawn the
+        // player model now that the renderer actually exists.
+        if (!playerCharacterSpawned) {
+            spawnPlayerCharacter();
+            loadEquippedWeapons();
+        }
+
+        showProgress("Streaming terrain tiles...", 0.35f);
+
+        // Wait for surrounding terrain tiles to stream in
+        if (terrainOk && renderer->getTerrainManager() && renderer->getCamera()) {
+            auto* terrainMgr = renderer->getTerrainManager();
+            auto* camera = renderer->getCamera();
+
+            // Use a small radius for the initial load (just immediate tiles),
+            // then restore the full radius after entering the game.
+            // This matches WoW's behavior: load quickly, stream the rest in-game.
+            const int savedLoadRadius = 4;
+            terrainMgr->setLoadRadius(3);   // 7x7=49 tiles — prevents hitches on spawn
+            terrainMgr->setUnloadRadius(7);
+
+            // Trigger tile streaming for surrounding area
+            terrainMgr->update(*camera, 1.0f);
+
+            auto startTime = std::chrono::high_resolution_clock::now();
+            auto lastProgressTime = startTime;
+            const float maxWaitSeconds = 60.0f;
+            const float stallSeconds = 10.0f;
+            int initialRemaining = terrainMgr->getRemainingTileCount();
+            if (initialRemaining < 1) initialRemaining = 1;
+            int lastRemaining = initialRemaining;
+
+            // Wait until all pending + ready-queue tiles are finalized
+            while (terrainMgr->getRemainingTileCount() > 0) {
+                SDL_Event event;
+                while (SDL_PollEvent(&event)) {
+                    if (event.type == SDL_QUIT) {
+                        window->setShouldClose(true);
+                        loadingScreen.shutdown();
+                        return;
+                    }
+                    if (event.type == SDL_WINDOWEVENT &&
+                        event.window.event == SDL_WINDOWEVENT_RESIZED) {
+                        int w = event.window.data1;
+                        int h = event.window.data2;
+                        window->setSize(w, h);
+                        // Vulkan viewport set in command buffer
+                        if (renderer->getCamera()) {
+                            renderer->getCamera()->setAspectRatio(static_cast<float>(w) / h);
+                        }
+                    }
+                }
+
+                // Trigger new streaming — enqueue tiles for background workers
+                terrainMgr->update(*camera, 0.016f);
+
+                // Process ONE tile per iteration so the progress bar updates
+                // smoothly between tiles instead of stalling on large batches.
+                terrainMgr->processOneReadyTile();
+
+                int remaining = terrainMgr->getRemainingTileCount();
+                int loaded = terrainMgr->getLoadedTileCount();
+                int total = loaded + remaining;
+                if (total < 1) total = 1;
+                float tileProgress = static_cast<float>(loaded) / static_cast<float>(total);
+                float progress = 0.35f + tileProgress * 0.50f;
+
+                auto now = std::chrono::high_resolution_clock::now();
+                float elapsedSec = std::chrono::duration<float>(now - startTime).count();
+
+                char buf[192];
+                if (loaded > 0 && remaining > 0) {
+                    float tilesPerSec = static_cast<float>(loaded) / std::max(elapsedSec, 0.1f);
+                    float etaSec = static_cast<float>(remaining) / std::max(tilesPerSec, 0.1f);
+                    snprintf(buf, sizeof(buf), "Loading terrain... %d / %d tiles (%.0f tiles/s, ~%.0fs remaining)",
+                             loaded, total, tilesPerSec, etaSec);
+                } else {
+                    snprintf(buf, sizeof(buf), "Loading terrain... %d / %d tiles",
+                             loaded, total);
+                }
+
+                if (loadingScreenOk) {
+                    loadingScreen.setStatus(buf);
+                    loadingScreen.setProgress(progress);
+                    loadingScreen.render();
+                    window->swapBuffers();
+                }
+
+                if (remaining != lastRemaining) {
+                    lastRemaining = remaining;
+                    lastProgressTime = now;
+                }
+
+                auto elapsed = std::chrono::high_resolution_clock::now() - startTime;
+                if (std::chrono::duration<float>(elapsed).count() > maxWaitSeconds) {
+                    LOG_WARNING("Online terrain streaming timeout after ", maxWaitSeconds, "s");
+                    break;
+                }
+                auto stalledFor = std::chrono::high_resolution_clock::now() - lastProgressTime;
+                if (std::chrono::duration<float>(stalledFor).count() > stallSeconds) {
+                    LOG_WARNING("Online terrain streaming stalled for ", stallSeconds,
+                                "s (remaining=", lastRemaining, "), continuing without full preload");
+                    break;
+                }
+
+                // Don't sleep if there are more tiles to finalize — keep processing
+                if (remaining > 0 && terrainMgr->getReadyQueueCount() == 0) {
+                    SDL_Delay(16);
+                }
+            }
+
+            LOG_INFO("Online terrain streaming complete: ", terrainMgr->getLoadedTileCount(), " tiles loaded");
+
+            // Restore full load radius — remaining tiles stream in-game
+            terrainMgr->setLoadRadius(savedLoadRadius);
+
+            // Load/precompute collision cache
+            if (renderer->getWMORenderer()) {
+                showProgress("Building collision cache...", 0.88f);
+                if (loadingScreenOk) { loadingScreen.render(); window->swapBuffers(); }
+                renderer->getWMORenderer()->loadFloorCache();
+                if (renderer->getWMORenderer()->getFloorCacheSize() == 0) {
+                    showProgress("Computing walkable surfaces...", 0.90f);
+                    if (loadingScreenOk) { loadingScreen.render(); window->swapBuffers(); }
+                    renderer->getWMORenderer()->precomputeFloorCache();
+                }
+            }
+        }
+    }
+
+    // Snap player to loaded terrain so they don't spawn underground
+    if (renderer->getCameraController()) {
+        renderer->getCameraController()->reset();
+    }
+
+    // Test transport disabled — real transports come from server via UPDATEFLAG_TRANSPORT
+    showProgress("Finalizing world...", 0.94f);
+    // setupTestTransport();
+
+    // Connect TransportManager to renderers (must happen AFTER initializeRenderers)
+    if (gameHandler && gameHandler->getTransportManager()) {
+        auto* tm = gameHandler->getTransportManager();
+        if (renderer->getWMORenderer()) tm->setWMORenderer(renderer->getWMORenderer());
+        if (renderer->getM2Renderer()) tm->setM2Renderer(renderer->getM2Renderer());
+        LOG_WARNING("TransportManager connected: wmoR=", (renderer->getWMORenderer() ? "yes" : "NULL"),
+                   " m2R=", (renderer->getM2Renderer() ? "yes" : "NULL"));
+    }
+
+    // Set up NPC animation callbacks (for online creatures)
+    showProgress("Preparing creatures...", 0.97f);
+    if (gameHandler && renderer && renderer->getCharacterRenderer()) {
+        auto* cr = renderer->getCharacterRenderer();
+        auto* app = this;
+
+        gameHandler->setNpcDeathCallback([cr, app](uint64_t guid) {
+            app->deadCreatureGuids_.insert(guid);
+            auto it = app->creatureInstances_.find(guid);
+            if (it != app->creatureInstances_.end() && cr) {
+                cr->playAnimation(it->second, 1, false); // animation ID 1 = Death
+            }
+        });
+
+        gameHandler->setNpcRespawnCallback([cr, app](uint64_t guid) {
+            app->deadCreatureGuids_.erase(guid);
+            auto it = app->creatureInstances_.find(guid);
+            if (it != app->creatureInstances_.end() && cr) {
+                cr->playAnimation(it->second, 0, true); // animation ID 0 = Idle
+            }
+        });
+
+        gameHandler->setNpcSwingCallback([cr, app](uint64_t guid) {
+            auto it = app->creatureInstances_.find(guid);
+            if (it != app->creatureInstances_.end() && cr) {
+                cr->playAnimation(it->second, 16, false); // animation ID 16 = Attack1
+            }
+        });
+    }
+
+    // Keep the loading screen visible until all spawn/equipment/gameobject queues
+    // are fully drained. This ensures the player sees a fully populated world
+    // (character clothed, NPCs placed, game objects loaded) when the screen drops.
+    {
+        const float kMinWarmupSeconds = 2.0f;   // minimum time to drain network packets
+        const float kMaxWarmupSeconds = 15.0f;  // hard cap to avoid infinite stall
+        const auto warmupStart = std::chrono::high_resolution_clock::now();
+        // Track consecutive idle iterations (all queues empty) to detect convergence
+        int idleIterations = 0;
+        const int kIdleThreshold = 5;  // require 5 consecutive empty loops (~80ms)
+
+        while (true) {
+            SDL_Event event;
+            while (SDL_PollEvent(&event)) {
+                if (event.type == SDL_QUIT) {
+                    window->setShouldClose(true);
+                    if (loadingScreenOk) loadingScreen.shutdown();
+                    return;
+                }
+                if (event.type == SDL_WINDOWEVENT &&
+                    event.window.event == SDL_WINDOWEVENT_RESIZED) {
+                    int w = event.window.data1;
+                    int h = event.window.data2;
+                    window->setSize(w, h);
+                    if (renderer && renderer->getCamera()) {
+                        renderer->getCamera()->setAspectRatio(static_cast<float>(w) / h);
+                    }
+                }
+            }
+
+            // Drain network and process deferred spawn/composite queues while hidden.
+            if (gameHandler) gameHandler->update(1.0f / 60.0f);
+
+            // If a new world entry was deferred during packet processing,
+            // stop warming up this map — we'll load the new one after cleanup.
+            if (pendingWorldEntry_) {
+                LOG_WARNING("loadOnlineWorldTerrain(map ", mapId,
+                            ") — deferred world entry pending, stopping warmup");
+                break;
+            }
+
+            if (world) world->update(1.0f / 60.0f);
+            processPlayerSpawnQueue();
+
+            // During load screen warmup: lift per-frame budgets so GPU uploads
+            // and spawns happen in bulk while the loading screen is still visible.
+            processCreatureSpawnQueue(true);
+            processAsyncNpcCompositeResults();
+            // Process equipment queue more aggressively during warmup (multiple per iteration)
+            for (int i = 0; i < 8 && (!deferredEquipmentQueue_.empty() || !asyncEquipmentLoads_.empty()); i++) {
+                processDeferredEquipmentQueue();
+            }
+            if (auto* cr = renderer ? renderer->getCharacterRenderer() : nullptr) {
+                cr->processPendingNormalMaps(INT_MAX);
+            }
+
+            // Process ALL pending game object spawns.
+            while (!pendingGameObjectSpawns_.empty()) {
+                auto& s = pendingGameObjectSpawns_.front();
+                spawnOnlineGameObject(s.guid, s.entry, s.displayId, s.x, s.y, s.z, s.orientation);
+                pendingGameObjectSpawns_.erase(pendingGameObjectSpawns_.begin());
+            }
+
+            processPendingTransportDoodads();
+            processPendingMount();
+            updateQuestMarkers();
+
+            // Update renderer (terrain streaming, animations)
+            if (renderer) {
+                renderer->update(1.0f / 60.0f);
+            }
+
+            const auto now = std::chrono::high_resolution_clock::now();
+            const float elapsed = std::chrono::duration<float>(now - warmupStart).count();
+
+            // Check if all queues are drained
+            bool queuesEmpty =
+                pendingCreatureSpawns_.empty() &&
+                asyncCreatureLoads_.empty() &&
+                asyncNpcCompositeLoads_.empty() &&
+                deferredEquipmentQueue_.empty() &&
+                asyncEquipmentLoads_.empty() &&
+                pendingGameObjectSpawns_.empty() &&
+                asyncGameObjectLoads_.empty() &&
+                pendingPlayerSpawns_.empty();
+
+            if (queuesEmpty) {
+                idleIterations++;
+            } else {
+                idleIterations = 0;
+            }
+
+            // Exit when: (min time passed AND queues drained for several iterations) OR hard cap
+            bool readyToExit = (elapsed >= kMinWarmupSeconds && idleIterations >= kIdleThreshold);
+            if (readyToExit || elapsed >= kMaxWarmupSeconds) {
+                if (elapsed >= kMaxWarmupSeconds) {
+                    LOG_WARNING("Warmup hit hard cap (", kMaxWarmupSeconds, "s), entering world with pending work");
+                }
+                break;
+            }
+
+            const float t = std::clamp(elapsed / kMaxWarmupSeconds, 0.0f, 1.0f);
+            showProgress("Finalizing world sync...", 0.97f + t * 0.025f);
+            SDL_Delay(16);
+        }
+    }
+
+    // Start intro pan right before entering gameplay so it's visible after loading.
+    if (renderer->getCameraController()) {
+        renderer->getCameraController()->startIntroPan(2.8f, 140.0f);
+    }
+
+    showProgress("Entering world...", 1.0f);
+
+    if (loadingScreenOk) {
+        loadingScreen.shutdown();
+    }
+
+    // Track which map we actually loaded (used by same-map teleport check).
+    loadedMapId_ = mapId;
+
+    // Clear loading flag and process any deferred world entry.
+    // A deferred entry occurs when SMSG_NEW_WORLD arrived during our warmup
+    // (e.g., an area trigger in a dungeon immediately teleporting the player out).
+    loadingWorld_ = false;
+    if (pendingWorldEntry_) {
+        auto entry = *pendingWorldEntry_;
+        pendingWorldEntry_.reset();
+        LOG_WARNING("Processing deferred world entry: map ", entry.mapId);
+        worldEntryMovementGraceTimer_ = 2.0f;
+        taxiLandingClampTimer_ = 0.0f;
+        lastTaxiFlight_ = false;
+        // Recursive call — sets loadedMapId_ and IN_GAME state for the final map.
+        loadOnlineWorldTerrain(entry.mapId, entry.x, entry.y, entry.z);
+        return;  // The recursive call handles setState(IN_GAME).
+    }
+
+    // Only enter IN_GAME when this is the final map (no deferred entry pending).
+    setState(AppState::IN_GAME);
+}
+
+void Application::buildCharSectionsCache() {
+    if (charSectionsCacheBuilt_ || !assetManager || !assetManager->isInitialized()) return;
+    auto dbc = assetManager->loadDBC("CharSections.dbc");
+    if (!dbc) return;
+    const auto* csL = pipeline::getActiveDBCLayout()
+        ? pipeline::getActiveDBCLayout()->getLayout("CharSections") : nullptr;
+    uint32_t raceF = csL ? (*csL)["RaceID"] : 1;
+    uint32_t sexF = csL ? (*csL)["SexID"] : 2;
+    uint32_t secF = csL ? (*csL)["BaseSection"] : 3;
+    uint32_t varF = csL ? (*csL)["VariationIndex"] : 4;
+    uint32_t colF = csL ? (*csL)["ColorIndex"] : 5;
+    uint32_t tex1F = csL ? (*csL)["Texture1"] : 6;
+    for (uint32_t r = 0; r < dbc->getRecordCount(); r++) {
+        uint32_t race = dbc->getUInt32(r, raceF);
+        uint32_t sex = dbc->getUInt32(r, sexF);
+        uint32_t section = dbc->getUInt32(r, secF);
+        uint32_t variation = dbc->getUInt32(r, varF);
+        uint32_t color = dbc->getUInt32(r, colF);
+        // We only cache sections 0 (skin), 1 (face), 3 (hair), 4 (underwear)
+        if (section != 0 && section != 1 && section != 3 && section != 4) continue;
+        for (int ti = 0; ti < 3; ti++) {
+            std::string tex = dbc->getString(r, tex1F + ti);
+            if (tex.empty()) continue;
+            // Key: race(8)|sex(4)|section(4)|variation(8)|color(8)|texIndex(2) packed into 64 bits
+            uint64_t key = (static_cast<uint64_t>(race) << 26) |
+                           (static_cast<uint64_t>(sex & 0xF) << 22) |
+                           (static_cast<uint64_t>(section & 0xF) << 18) |
+                           (static_cast<uint64_t>(variation & 0xFF) << 10) |
+                           (static_cast<uint64_t>(color & 0xFF) << 2) |
+                           static_cast<uint64_t>(ti);
+            charSectionsCache_.emplace(key, tex);
+        }
+    }
+    charSectionsCacheBuilt_ = true;
+    LOG_INFO("CharSections cache built: ", charSectionsCache_.size(), " entries");
+}
+
+std::string Application::lookupCharSection(uint8_t race, uint8_t sex, uint8_t section,
+                                           uint8_t variation, uint8_t color, int texIndex) const {
+    uint64_t key = (static_cast<uint64_t>(race) << 26) |
+                   (static_cast<uint64_t>(sex & 0xF) << 22) |
+                   (static_cast<uint64_t>(section & 0xF) << 18) |
+                   (static_cast<uint64_t>(variation & 0xFF) << 10) |
+                   (static_cast<uint64_t>(color & 0xFF) << 2) |
+                   static_cast<uint64_t>(texIndex);
+    auto it = charSectionsCache_.find(key);
+    return (it != charSectionsCache_.end()) ? it->second : std::string();
+}
+
+void Application::buildCreatureDisplayLookups() {
+    if (creatureLookupsBuilt_ || !assetManager || !assetManager->isInitialized()) return;
+
+    LOG_INFO("Building creature display lookups from DBC files");
+
+    // CreatureDisplayInfo.dbc structure (3.3.5a):
+    // Col 0: displayId
+    // Col 1: modelId
+    // Col 3: extendedDisplayInfoID (link to CreatureDisplayInfoExtra.dbc)
+    // Col 6: Skin1 (texture name)
+    // Col 7: Skin2
+    // Col 8: Skin3
+    if (auto cdi = assetManager->loadDBC("CreatureDisplayInfo.dbc"); cdi && cdi->isLoaded()) {
+        const auto* cdiL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CreatureDisplayInfo") : nullptr;
+        for (uint32_t i = 0; i < cdi->getRecordCount(); i++) {
+            CreatureDisplayData data;
+            data.modelId = cdi->getUInt32(i, cdiL ? (*cdiL)["ModelID"] : 1);
+            data.extraDisplayId = cdi->getUInt32(i, cdiL ? (*cdiL)["ExtraDisplayId"] : 3);
+            data.skin1 = cdi->getString(i, cdiL ? (*cdiL)["Skin1"] : 6);
+            data.skin2 = cdi->getString(i, cdiL ? (*cdiL)["Skin2"] : 7);
+            data.skin3 = cdi->getString(i, cdiL ? (*cdiL)["Skin3"] : 8);
+            displayDataMap_[cdi->getUInt32(i, cdiL ? (*cdiL)["ID"] : 0)] = data;
+        }
+        LOG_INFO("Loaded ", displayDataMap_.size(), " display→model mappings");
+    }
+
+    // CreatureDisplayInfoExtra.dbc structure (3.3.5a):
+    // Col 0: ID
+    // Col 1: DisplayRaceID
+    // Col 2: DisplaySexID
+    // Col 3: SkinID
+    // Col 4: FaceID
+    // Col 5: HairStyleID
+    // Col 6: HairColorID
+    // Col 7: FacialHairID
+    // CreatureDisplayInfoExtra.dbc field layout depends on actual field count:
+    //   19 fields: 10 equip slots (8-17), BakeName=18 (no Flags field)
+    //   21 fields: 11 equip slots (8-18), Flags=19, BakeName=20
+    if (auto cdie = assetManager->loadDBC("CreatureDisplayInfoExtra.dbc"); cdie && cdie->isLoaded()) {
+        const auto* cdieL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CreatureDisplayInfoExtra") : nullptr;
+        const uint32_t cdieEquip0 = cdieL ? (*cdieL)["EquipDisplay0"] : 8;
+        // Detect actual field count to determine equip slot count and BakeName position
+        const uint32_t dbcFieldCount = cdie->getFieldCount();
+        int numEquipSlots;
+        uint32_t bakeField;
+        if (dbcFieldCount <= 19) {
+            // 19 fields: 10 equip slots (8-17), BakeName at 18
+            numEquipSlots = 10;
+            bakeField = 18;
+        } else {
+            // 21 fields: 11 equip slots (8-18), Flags=19, BakeName=20
+            numEquipSlots = 11;
+            bakeField = cdieL ? (*cdieL)["BakeName"] : 20;
+        }
+        uint32_t withBakeName = 0;
+        for (uint32_t i = 0; i < cdie->getRecordCount(); i++) {
+            HumanoidDisplayExtra extra;
+            extra.raceId = static_cast<uint8_t>(cdie->getUInt32(i, cdieL ? (*cdieL)["RaceID"] : 1));
+            extra.sexId = static_cast<uint8_t>(cdie->getUInt32(i, cdieL ? (*cdieL)["SexID"] : 2));
+            extra.skinId = static_cast<uint8_t>(cdie->getUInt32(i, cdieL ? (*cdieL)["SkinID"] : 3));
+            extra.faceId = static_cast<uint8_t>(cdie->getUInt32(i, cdieL ? (*cdieL)["FaceID"] : 4));
+            extra.hairStyleId = static_cast<uint8_t>(cdie->getUInt32(i, cdieL ? (*cdieL)["HairStyleID"] : 5));
+            extra.hairColorId = static_cast<uint8_t>(cdie->getUInt32(i, cdieL ? (*cdieL)["HairColorID"] : 6));
+            extra.facialHairId = static_cast<uint8_t>(cdie->getUInt32(i, cdieL ? (*cdieL)["FacialHairID"] : 7));
+            for (int eq = 0; eq < numEquipSlots; eq++) {
+                extra.equipDisplayId[eq] = cdie->getUInt32(i, cdieEquip0 + eq);
+            }
+            extra.bakeName = cdie->getString(i, bakeField);
+            if (!extra.bakeName.empty()) withBakeName++;
+            humanoidExtraMap_[cdie->getUInt32(i, cdieL ? (*cdieL)["ID"] : 0)] = extra;
+        }
+        LOG_WARNING("Loaded ", humanoidExtraMap_.size(), " humanoid display extra entries (",
+                 withBakeName, " with baked textures, ", numEquipSlots, " equip slots, ",
+                 dbcFieldCount, " DBC fields, bakeField=", bakeField, ")");
+    }
+
+    // CreatureModelData.dbc: modelId (col 0) → modelPath (col 2, .mdx → .m2)
+    if (auto cmd = assetManager->loadDBC("CreatureModelData.dbc"); cmd && cmd->isLoaded()) {
+        const auto* cmdL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CreatureModelData") : nullptr;
+        for (uint32_t i = 0; i < cmd->getRecordCount(); i++) {
+            std::string mdx = cmd->getString(i, cmdL ? (*cmdL)["ModelPath"] : 2);
+            if (mdx.empty()) continue;
+            if (mdx.size() >= 4) {
+                mdx = mdx.substr(0, mdx.size() - 4) + ".m2";
+            }
+            modelIdToPath_[cmd->getUInt32(i, cmdL ? (*cmdL)["ID"] : 0)] = mdx;
+        }
+        LOG_INFO("Loaded ", modelIdToPath_.size(), " model→path mappings");
+    }
+
+    // Resolve gryphon/wyvern display IDs by exact model path so taxi mounts have textures.
+    auto toLower = [](std::string s) {
+        for (char& c : s) c = static_cast<char>(::tolower(c));
+        return s;
+    };
+    auto normalizePath = [&](const std::string& p) {
+        std::string s = p;
+        for (char& c : s) if (c == '/') c = '\\';
+        return toLower(s);
+    };
+    auto resolveDisplayIdForExactPath = [&](const std::string& exactPath) -> uint32_t {
+        const std::string target = normalizePath(exactPath);
+        // Collect ALL model IDs that map to this path (multiple model IDs can
+        // share the same .m2 file, e.g. modelId 147 and 792 both → Gryphon.m2)
+        std::vector<uint32_t> modelIds;
+        for (const auto& [mid, path] : modelIdToPath_) {
+            if (normalizePath(path) == target) {
+                modelIds.push_back(mid);
+            }
+        }
+        if (modelIds.empty()) return 0;
+        uint32_t bestDisplayId = 0;
+        int bestScore = -1;
+        for (const auto& [dispId, data] : displayDataMap_) {
+            bool matches = false;
+            for (uint32_t mid : modelIds) {
+                if (data.modelId == mid) { matches = true; break; }
+            }
+            if (!matches) continue;
+            int score = 0;
+            if (!data.skin1.empty()) score += 3;
+            if (!data.skin2.empty()) score += 2;
+            if (!data.skin3.empty()) score += 1;
+            if (score > bestScore) {
+                bestScore = score;
+                bestDisplayId = dispId;
+            }
+        }
+        return bestDisplayId;
+    };
+
+    gryphonDisplayId_ = resolveDisplayIdForExactPath("Creature\\Gryphon\\Gryphon.m2");
+    wyvernDisplayId_  = resolveDisplayIdForExactPath("Creature\\Wyvern\\Wyvern.m2");
+    LOG_INFO("Taxi mount displayIds: gryphon=", gryphonDisplayId_, " wyvern=", wyvernDisplayId_);
+
+    // CharHairGeosets.dbc: maps (race, sex, hairStyleId) → skinSectionId for hair mesh
+    // Col 0: ID, Col 1: RaceID, Col 2: SexID, Col 3: VariationID, Col 4: GeosetID, Col 5: Showscalp
+    if (auto chg = assetManager->loadDBC("CharHairGeosets.dbc"); chg && chg->isLoaded()) {
+        const auto* chgL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CharHairGeosets") : nullptr;
+        for (uint32_t i = 0; i < chg->getRecordCount(); i++) {
+            uint32_t raceId = chg->getUInt32(i, chgL ? (*chgL)["RaceID"] : 1);
+            uint32_t sexId = chg->getUInt32(i, chgL ? (*chgL)["SexID"] : 2);
+            uint32_t variation = chg->getUInt32(i, chgL ? (*chgL)["Variation"] : 3);
+            uint32_t geosetId = chg->getUInt32(i, chgL ? (*chgL)["GeosetID"] : 4);
+            uint32_t key = (raceId << 16) | (sexId << 8) | variation;
+            hairGeosetMap_[key] = static_cast<uint16_t>(geosetId);
+        }
+        LOG_INFO("Loaded ", hairGeosetMap_.size(), " hair geoset mappings from CharHairGeosets.dbc");
+        // Debug: dump Human Male (race=1, sex=0) hair geoset mappings
+        for (uint32_t v = 0; v < 20; v++) {
+            uint32_t k = (1u << 16) | (0u << 8) | v;
+            auto it = hairGeosetMap_.find(k);
+            if (it != hairGeosetMap_.end()) {
+            }
+        }
+    }
+
+    // CharacterFacialHairStyles.dbc: maps (race, sex, facialHairId) → geoset IDs
+    // No ID column: Col 0: RaceID, Col 1: SexID, Col 2: VariationID
+    // Col 3: Geoset100, Col 4: Geoset300, Col 5: Geoset200
+    if (auto cfh = assetManager->loadDBC("CharacterFacialHairStyles.dbc"); cfh && cfh->isLoaded()) {
+        const auto* cfhL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CharacterFacialHairStyles") : nullptr;
+        for (uint32_t i = 0; i < cfh->getRecordCount(); i++) {
+            uint32_t raceId = cfh->getUInt32(i, cfhL ? (*cfhL)["RaceID"] : 0);
+            uint32_t sexId = cfh->getUInt32(i, cfhL ? (*cfhL)["SexID"] : 1);
+            uint32_t variation = cfh->getUInt32(i, cfhL ? (*cfhL)["Variation"] : 2);
+            uint32_t key = (raceId << 16) | (sexId << 8) | variation;
+            FacialHairGeosets fhg;
+            fhg.geoset100 = static_cast<uint16_t>(cfh->getUInt32(i, cfhL ? (*cfhL)["Geoset100"] : 3));
+            fhg.geoset300 = static_cast<uint16_t>(cfh->getUInt32(i, cfhL ? (*cfhL)["Geoset300"] : 4));
+            fhg.geoset200 = static_cast<uint16_t>(cfh->getUInt32(i, cfhL ? (*cfhL)["Geoset200"] : 5));
+            facialHairGeosetMap_[key] = fhg;
+        }
+        LOG_INFO("Loaded ", facialHairGeosetMap_.size(), " facial hair geoset mappings from CharacterFacialHairStyles.dbc");
+    }
+
+    creatureLookupsBuilt_ = true;
+}
+
+std::string Application::getModelPathForDisplayId(uint32_t displayId) const {
+    if (displayId == 30412) return "Creature\\Gryphon\\Gryphon.m2";
+    if (displayId == 30413) return "Creature\\Wyvern\\Wyvern.m2";
+
+    // WotLK servers can send display IDs that do not exist in older/local
+    // CreatureDisplayInfo datasets. Keep those creatures visible by falling
+    // back to a close base model instead of dropping spawn entirely.
+    switch (displayId) {
+        case 31048: // Diseased Young Wolf variants (AzerothCore WotLK)
+        case 31049: // Diseased Wolf variants (AzerothCore WotLK)
+            return "Creature\\Wolf\\Wolf.m2";
+        default:
+            break;
+    }
+
+    auto itData = displayDataMap_.find(displayId);
+    if (itData == displayDataMap_.end()) {
+        // Some sources (e.g., taxi nodes) may provide a modelId directly.
+        auto itPath = modelIdToPath_.find(displayId);
+        if (itPath != modelIdToPath_.end()) {
+            return itPath->second;
+        }
+        if (displayId == 30412) return "Creature\\Gryphon\\Gryphon.m2";
+        if (displayId == 30413) return "Creature\\Wyvern\\Wyvern.m2";
+        if (warnedMissingDisplayDataIds_.insert(displayId).second) {
+            LOG_WARNING("No display data for displayId ", displayId,
+                        " (displayDataMap_ has ", displayDataMap_.size(), " entries)");
+        }
+        return "";
+    }
+
+    auto itPath = modelIdToPath_.find(itData->second.modelId);
+    if (itPath == modelIdToPath_.end()) {
+        if (warnedMissingModelPathIds_.insert(displayId).second) {
+            LOG_WARNING("No model path for modelId ", itData->second.modelId,
+                        " from displayId ", displayId,
+                        " (modelIdToPath_ has ", modelIdToPath_.size(), " entries)");
+        }
+        return "";
+    }
+
+    return itPath->second;
+}
+
+audio::VoiceType Application::detectVoiceTypeFromDisplayId(uint32_t displayId) const {
+    // Look up display data
+    auto itDisplay = displayDataMap_.find(displayId);
+    if (itDisplay == displayDataMap_.end() || itDisplay->second.extraDisplayId == 0) {
+        LOG_INFO("Voice detection: displayId ", displayId, " -> GENERIC (no display data)");
+        return audio::VoiceType::GENERIC;  // Not a humanoid or no extra data
+    }
+
+    // Look up humanoid extra data (race/sex info)
+    auto itExtra = humanoidExtraMap_.find(itDisplay->second.extraDisplayId);
+    if (itExtra == humanoidExtraMap_.end()) {
+        LOG_INFO("Voice detection: displayId ", displayId, " -> GENERIC (no humanoid extra data)");
+        return audio::VoiceType::GENERIC;
+    }
+
+    uint8_t raceId = itExtra->second.raceId;
+    uint8_t sexId = itExtra->second.sexId;
+
+    const char* raceName = "Unknown";
+    const char* sexName = (sexId == 0) ? "Male" : "Female";
+
+    // Map (raceId, sexId) to VoiceType
+    // Race IDs: 1=Human, 2=Orc, 3=Dwarf, 4=NightElf, 5=Undead, 6=Tauren, 7=Gnome, 8=Troll
+    // Sex IDs: 0=Male, 1=Female
+    audio::VoiceType result;
+    switch (raceId) {
+        case 1: raceName = "Human"; result = (sexId == 0) ? audio::VoiceType::HUMAN_MALE : audio::VoiceType::HUMAN_FEMALE; break;
+        case 2: raceName = "Orc"; result = (sexId == 0) ? audio::VoiceType::ORC_MALE : audio::VoiceType::ORC_FEMALE; break;
+        case 3: raceName = "Dwarf"; result = (sexId == 0) ? audio::VoiceType::DWARF_MALE : audio::VoiceType::DWARF_FEMALE; break;
+        case 4: raceName = "NightElf"; result = (sexId == 0) ? audio::VoiceType::NIGHTELF_MALE : audio::VoiceType::NIGHTELF_FEMALE; break;
+        case 5: raceName = "Undead"; result = (sexId == 0) ? audio::VoiceType::UNDEAD_MALE : audio::VoiceType::UNDEAD_FEMALE; break;
+        case 6: raceName = "Tauren"; result = (sexId == 0) ? audio::VoiceType::TAUREN_MALE : audio::VoiceType::TAUREN_FEMALE; break;
+        case 7: raceName = "Gnome"; result = (sexId == 0) ? audio::VoiceType::GNOME_MALE : audio::VoiceType::GNOME_FEMALE; break;
+        case 8: raceName = "Troll"; result = (sexId == 0) ? audio::VoiceType::TROLL_MALE : audio::VoiceType::TROLL_FEMALE; break;
+        default: result = audio::VoiceType::GENERIC; break;
+    }
+
+    LOG_INFO("Voice detection: displayId ", displayId, " -> ", raceName, " ", sexName, " (race=", (int)raceId, ", sex=", (int)sexId, ")");
+    return result;
+}
+
+void Application::buildGameObjectDisplayLookups() {
+    if (gameObjectLookupsBuilt_ || !assetManager || !assetManager->isInitialized()) return;
+
+    LOG_INFO("Building gameobject display lookups from DBC files");
+
+    // GameObjectDisplayInfo.dbc structure (3.3.5a):
+    // Col 0: ID (displayId)
+    // Col 1: ModelName
+    if (auto godi = assetManager->loadDBC("GameObjectDisplayInfo.dbc"); godi && godi->isLoaded()) {
+        const auto* godiL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("GameObjectDisplayInfo") : nullptr;
+        for (uint32_t i = 0; i < godi->getRecordCount(); i++) {
+            uint32_t displayId = godi->getUInt32(i, godiL ? (*godiL)["ID"] : 0);
+            std::string modelName = godi->getString(i, godiL ? (*godiL)["ModelName"] : 1);
+            if (modelName.empty()) continue;
+            if (modelName.size() >= 4) {
+                std::string ext = modelName.substr(modelName.size() - 4);
+                for (char& c : ext) c = static_cast<char>(std::tolower(c));
+                if (ext == ".mdx") {
+                    modelName = modelName.substr(0, modelName.size() - 4) + ".m2";
+                }
+            }
+            gameObjectDisplayIdToPath_[displayId] = modelName;
+        }
+        LOG_INFO("Loaded ", gameObjectDisplayIdToPath_.size(), " gameobject display mappings");
+    }
+
+    gameObjectLookupsBuilt_ = true;
+}
+
+std::string Application::getGameObjectModelPathForDisplayId(uint32_t displayId) const {
+    auto it = gameObjectDisplayIdToPath_.find(displayId);
+    if (it == gameObjectDisplayIdToPath_.end()) return "";
+    return it->second;
+}
+
 bool Application::getRenderBoundsForGuid(uint64_t guid, glm::vec3& outCenter, float& outRadius) const {
-    if (entitySpawner_) return entitySpawner_->getRenderBoundsForGuid(guid, outCenter, outRadius);
-    return false;
+    if (!renderer || !renderer->getCharacterRenderer()) return false;
+    uint32_t instanceId = 0;
+
+    if (gameHandler && guid == gameHandler->getPlayerGuid()) {
+        instanceId = renderer->getCharacterInstanceId();
+    }
+    if (instanceId == 0) {
+        auto pit = playerInstances_.find(guid);
+        if (pit != playerInstances_.end()) instanceId = pit->second;
+    }
+    if (instanceId == 0) {
+        auto it = creatureInstances_.find(guid);
+        if (it != creatureInstances_.end()) instanceId = it->second;
+    }
+    if (instanceId == 0) return false;
+
+    return renderer->getCharacterRenderer()->getInstanceBounds(instanceId, outCenter, outRadius);
 }
 
 bool Application::getRenderFootZForGuid(uint64_t guid, float& outFootZ) const {
-    if (entitySpawner_) return entitySpawner_->getRenderFootZForGuid(guid, outFootZ);
-    return false;
+    if (!renderer || !renderer->getCharacterRenderer()) return false;
+    uint32_t instanceId = 0;
+
+    if (gameHandler && guid == gameHandler->getPlayerGuid()) {
+        instanceId = renderer->getCharacterInstanceId();
+    }
+    if (instanceId == 0) {
+        auto pit = playerInstances_.find(guid);
+        if (pit != playerInstances_.end()) instanceId = pit->second;
+    }
+    if (instanceId == 0) {
+        auto it = creatureInstances_.find(guid);
+        if (it != creatureInstances_.end()) instanceId = it->second;
+    }
+    if (instanceId == 0) return false;
+
+    return renderer->getCharacterRenderer()->getInstanceFootZ(instanceId, outFootZ);
 }
 
-bool Application::getRenderPositionForGuid(uint64_t guid, glm::vec3& outPos) const {
-    if (entitySpawner_) return entitySpawner_->getRenderPositionForGuid(guid, outPos);
-    return false;
+pipeline::M2Model Application::loadCreatureM2Sync(const std::string& m2Path) {
+    auto m2Data = assetManager->readFile(m2Path);
+    if (m2Data.empty()) {
+        LOG_WARNING("Failed to read creature M2: ", m2Path);
+        return {};
+    }
+
+    pipeline::M2Model model = pipeline::M2Loader::load(m2Data);
+    if (model.vertices.empty()) {
+        LOG_WARNING("Failed to parse creature M2: ", m2Path);
+        return {};
+    }
+
+    // Load skin file (only for WotLK M2s - vanilla has embedded skin)
+    if (model.version >= 264) {
+        std::string skinPath = m2Path.substr(0, m2Path.size() - 3) + "00.skin";
+        auto skinData = assetManager->readFile(skinPath);
+        if (!skinData.empty()) {
+            pipeline::M2Loader::loadSkin(skinData, model);
+        } else {
+            LOG_WARNING("Missing skin file for WotLK creature M2: ", skinPath);
+        }
+    }
+
+    // Load external .anim files for sequences without flag 0x20
+    std::string basePath = m2Path.substr(0, m2Path.size() - 3);
+    for (uint32_t si = 0; si < model.sequences.size(); si++) {
+        if (!(model.sequences[si].flags & 0x20)) {
+            char animFileName[256];
+            snprintf(animFileName, sizeof(animFileName), "%s%04u-%02u.anim",
+                basePath.c_str(), model.sequences[si].id, model.sequences[si].variationIndex);
+            auto animData = assetManager->readFileOptional(animFileName);
+            if (!animData.empty()) {
+                pipeline::M2Loader::loadAnimFile(m2Data, animData, si, model);
+            }
+        }
+    }
+
+    return model;
+}
+
+void Application::spawnOnlineCreature(uint64_t guid, uint32_t displayId, float x, float y, float z, float orientation) {
+    if (!renderer || !renderer->getCharacterRenderer() || !assetManager) return;
+
+    // Skip if lookups not yet built (asset manager not ready)
+    if (!creatureLookupsBuilt_) return;
+
+    // Skip if already spawned
+    if (creatureInstances_.count(guid)) return;
+    if (nonRenderableCreatureDisplayIds_.count(displayId)) {
+        creaturePermanentFailureGuids_.insert(guid);
+        return;
+    }
+
+    // Get model path from displayId
+    std::string m2Path = getModelPathForDisplayId(displayId);
+    if (m2Path.empty()) {
+        nonRenderableCreatureDisplayIds_.insert(displayId);
+        creaturePermanentFailureGuids_.insert(guid);
+        return;
+    }
+    {
+        // Intentionally invisible helper creatures should not consume retry budget.
+        std::string lowerPath = m2Path;
+        std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(),
+                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+        if (lowerPath.find("invisiblestalker") != std::string::npos ||
+            lowerPath.find("invisible_stalker") != std::string::npos) {
+            nonRenderableCreatureDisplayIds_.insert(displayId);
+            creaturePermanentFailureGuids_.insert(guid);
+            return;
+        }
+    }
+
+    auto* charRenderer = renderer->getCharacterRenderer();
+
+    // Check model cache - reuse if same displayId was already loaded
+    uint32_t modelId = 0;
+    auto cacheIt = displayIdModelCache_.find(displayId);
+    if (cacheIt != displayIdModelCache_.end()) {
+        modelId = cacheIt->second;
+    } else {
+        // Load model from disk (only once per displayId)
+        modelId = nextCreatureModelId_++;
+
+        pipeline::M2Model model = loadCreatureM2Sync(m2Path);
+        if (!model.isValid()) {
+            nonRenderableCreatureDisplayIds_.insert(displayId);
+            creaturePermanentFailureGuids_.insert(guid);
+            return;
+        }
+
+        if (!charRenderer->loadModel(model, modelId)) {
+            LOG_WARNING("Failed to load creature model: ", m2Path);
+            nonRenderableCreatureDisplayIds_.insert(displayId);
+            creaturePermanentFailureGuids_.insert(guid);
+            return;
+        }
+
+        displayIdModelCache_[displayId] = modelId;
+    }
+
+    // Apply skin textures from CreatureDisplayInfo.dbc (only once per displayId model).
+    // Track separately from model cache because async loading may upload the model
+    // before textures are applied.
+    auto itDisplayData = displayDataMap_.find(displayId);
+    bool needsTextures = (displayIdTexturesApplied_.find(displayId) == displayIdTexturesApplied_.end());
+    if (needsTextures && itDisplayData != displayDataMap_.end()) {
+        auto texStart = std::chrono::steady_clock::now();
+        displayIdTexturesApplied_.insert(displayId);
+        const auto& dispData = itDisplayData->second;
+
+        // Use pre-decoded textures from async creature load (if available)
+        auto itPreDec = displayIdPredecodedTextures_.find(displayId);
+        bool hasPreDec = (itPreDec != displayIdPredecodedTextures_.end());
+        if (hasPreDec) {
+            charRenderer->setPredecodedBLPCache(&itPreDec->second);
+        }
+
+        // Get model directory for texture path construction
+        std::string modelDir;
+        size_t lastSlash = m2Path.find_last_of("\\/");
+        if (lastSlash != std::string::npos) {
+            modelDir = m2Path.substr(0, lastSlash + 1);
+        }
+
+        LOG_DEBUG("DisplayId ", displayId, " skins: '", dispData.skin1, "', '", dispData.skin2, "', '", dispData.skin3,
+                  "' extraDisplayId=", dispData.extraDisplayId);
+
+        // Get model data from CharacterRenderer for texture iteration
+        const auto* modelData = charRenderer->getModelData(modelId);
+        if (!modelData) {
+            LOG_WARNING("Model data not found for modelId ", modelId);
+        }
+
+        // Log texture types in the model
+        if (modelData) {
+        for (size_t ti = 0; ti < modelData->textures.size(); ti++) {
+            LOG_DEBUG("  Model texture ", ti, ": type=", modelData->textures[ti].type, " filename='", modelData->textures[ti].filename, "'");
+        }
+        }
+
+        // Check if this is a humanoid NPC with extra display info
+        bool hasHumanoidTexture = false;
+        if (dispData.extraDisplayId != 0) {
+            auto itExtra = humanoidExtraMap_.find(dispData.extraDisplayId);
+            if (itExtra != humanoidExtraMap_.end()) {
+                const auto& extra = itExtra->second;
+                LOG_DEBUG("  Found humanoid extra: raceId=", (int)extra.raceId, " sexId=", (int)extra.sexId,
+                          " hairStyle=", (int)extra.hairStyleId, " hairColor=", (int)extra.hairColorId,
+                          " bakeName='", extra.bakeName, "'");
+
+                // Collect model texture slot info (type 1 = skin, type 6 = hair)
+                std::vector<uint32_t> skinSlots, hairSlots;
+                if (modelData) {
+                    for (size_t ti = 0; ti < modelData->textures.size(); ti++) {
+                        uint32_t texType = modelData->textures[ti].type;
+                        if (texType == 1 || texType == 11 || texType == 12 || texType == 13)
+                            skinSlots.push_back(static_cast<uint32_t>(ti));
+                        if (texType == 6)
+                            hairSlots.push_back(static_cast<uint32_t>(ti));
+                    }
+                }
+
+                // Copy extra data for the async task (avoid dangling reference)
+                HumanoidDisplayExtra extraCopy = extra;
+
+                // Launch async task: ALL DBC lookups, path resolution, and BLP pre-decode
+                // happen on a background thread. Only GPU texture upload runs on main thread
+                // (in processAsyncNpcCompositeResults).
+                auto* am = assetManager.get();
+                AsyncNpcCompositeLoad load;
+                load.future = std::async(std::launch::async,
+                    [am, extraCopy, skinSlots = std::move(skinSlots),
+                     hairSlots = std::move(hairSlots), modelId, displayId]() mutable -> PreparedNpcComposite {
+                        PreparedNpcComposite result;
+                        DeferredNpcComposite& def = result.info;
+                        def.modelId = modelId;
+                        def.displayId = displayId;
+                        def.skinTextureSlots = std::move(skinSlots);
+                        def.hairTextureSlots = std::move(hairSlots);
+
+                        std::vector<std::string> allPaths;  // paths to pre-decode
+
+                        // --- Baked skin texture ---
+                        if (!extraCopy.bakeName.empty()) {
+                            def.bakedSkinPath = "Textures\\BakedNpcTextures\\" + extraCopy.bakeName;
+                            def.hasBakedSkin = true;
+                            allPaths.push_back(def.bakedSkinPath);
+                        }
+
+                        // --- CharSections fallback (skin/face/underwear) ---
+                        if (!def.hasBakedSkin) {
+                            auto csDbc = am->loadDBC("CharSections.dbc");
+                            if (csDbc) {
+                                const auto* csL = pipeline::getActiveDBCLayout()
+                                    ? pipeline::getActiveDBCLayout()->getLayout("CharSections") : nullptr;
+                                uint32_t npcRace = static_cast<uint32_t>(extraCopy.raceId);
+                                uint32_t npcSex = static_cast<uint32_t>(extraCopy.sexId);
+                                uint32_t npcSkin = static_cast<uint32_t>(extraCopy.skinId);
+                                uint32_t npcFace = static_cast<uint32_t>(extraCopy.faceId);
+                                std::string npcFaceLower, npcFaceUpper;
+                                std::vector<std::string> npcUnderwear;
+
+                                for (uint32_t r = 0; r < csDbc->getRecordCount(); r++) {
+                                    uint32_t rId = csDbc->getUInt32(r, csL ? (*csL)["RaceID"] : 1);
+                                    uint32_t sId = csDbc->getUInt32(r, csL ? (*csL)["SexID"] : 2);
+                                    if (rId != npcRace || sId != npcSex) continue;
+
+                                    uint32_t section = csDbc->getUInt32(r, csL ? (*csL)["BaseSection"] : 3);
+                                    uint32_t variation = csDbc->getUInt32(r, csL ? (*csL)["VariationIndex"] : 4);
+                                    uint32_t color = csDbc->getUInt32(r, csL ? (*csL)["ColorIndex"] : 5);
+                                    uint32_t tex1F = csL ? (*csL)["Texture1"] : 6;
+
+                                    if (section == 0 && def.basePath.empty() && color == npcSkin) {
+                                        def.basePath = csDbc->getString(r, tex1F);
+                                    } else if (section == 1 && npcFaceLower.empty() &&
+                                               variation == npcFace && color == npcSkin) {
+                                        npcFaceLower = csDbc->getString(r, tex1F);
+                                        npcFaceUpper = csDbc->getString(r, tex1F + 1);
+                                    } else if (section == 4 && npcUnderwear.empty() && color == npcSkin) {
+                                        for (uint32_t f = tex1F; f <= tex1F + 2; f++) {
+                                            std::string tex = csDbc->getString(r, f);
+                                            if (!tex.empty()) npcUnderwear.push_back(tex);
+                                        }
+                                    }
+                                }
+
+                                if (!def.basePath.empty()) {
+                                    allPaths.push_back(def.basePath);
+                                    if (!npcFaceLower.empty()) { def.overlayPaths.push_back(npcFaceLower); allPaths.push_back(npcFaceLower); }
+                                    if (!npcFaceUpper.empty()) { def.overlayPaths.push_back(npcFaceUpper); allPaths.push_back(npcFaceUpper); }
+                                    for (const auto& uw : npcUnderwear) { def.overlayPaths.push_back(uw); allPaths.push_back(uw); }
+                                }
+                            }
+                        }
+
+                        // --- Equipment region layers (ItemDisplayInfo DBC) ---
+                        auto idiDbc = am->loadDBC("ItemDisplayInfo.dbc");
+                        if (idiDbc) {
+                            static const char* componentDirs[] = {
+                                "ArmUpperTexture", "ArmLowerTexture", "HandTexture",
+                                "TorsoUpperTexture", "TorsoLowerTexture",
+                                "LegUpperTexture", "LegLowerTexture", "FootTexture",
+                            };
+                            const auto* idiL = pipeline::getActiveDBCLayout()
+                                ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
+                            const uint32_t texRegionFields[8] = {
+                                idiL ? (*idiL)["TextureArmUpper"]  : 14u,
+                                idiL ? (*idiL)["TextureArmLower"]  : 15u,
+                                idiL ? (*idiL)["TextureHand"]      : 16u,
+                                idiL ? (*idiL)["TextureTorsoUpper"]: 17u,
+                                idiL ? (*idiL)["TextureTorsoLower"]: 18u,
+                                idiL ? (*idiL)["TextureLegUpper"]  : 19u,
+                                idiL ? (*idiL)["TextureLegLower"]  : 20u,
+                                idiL ? (*idiL)["TextureFoot"]      : 21u,
+                            };
+                            const bool npcIsFemale = (extraCopy.sexId == 1);
+                            const bool npcHasArmArmor = (extraCopy.equipDisplayId[7] != 0 || extraCopy.equipDisplayId[8] != 0);
+
+                            auto regionAllowedForNpcSlot = [](int eqSlot, int region) -> bool {
+                                switch (eqSlot) {
+                                    case 2: case 3: return region <= 4;
+                                    case 4: return false;
+                                    case 5: return region == 5 || region == 6;
+                                    case 6: return region == 7;
+                                    case 7: return false;
+                                    case 8: return region == 2;
+                                    case 9: return region == 3 || region == 4;
+                                    default: return false;
+                                }
+                            };
+
+                            for (int eqSlot = 0; eqSlot < 11; eqSlot++) {
+                                uint32_t did = extraCopy.equipDisplayId[eqSlot];
+                                if (did == 0) continue;
+                                int32_t recIdx = idiDbc->findRecordById(did);
+                                if (recIdx < 0) continue;
+
+                                for (int region = 0; region < 8; region++) {
+                                    if (!regionAllowedForNpcSlot(eqSlot, region)) continue;
+                                    if (eqSlot == 2 && !npcHasArmArmor && !(region == 3 || region == 4)) continue;
+                                    std::string texName = idiDbc->getString(
+                                        static_cast<uint32_t>(recIdx), texRegionFields[region]);
+                                    if (texName.empty()) continue;
+
+                                    std::string base = "Item\\TextureComponents\\" +
+                                        std::string(componentDirs[region]) + "\\" + texName;
+                                    std::string genderPath = base + (npcIsFemale ? "_F.blp" : "_M.blp");
+                                    std::string unisexPath = base + "_U.blp";
+                                    std::string basePath = base + ".blp";
+                                    std::string fullPath;
+                                    if (am->fileExists(genderPath)) fullPath = genderPath;
+                                    else if (am->fileExists(unisexPath)) fullPath = unisexPath;
+                                    else if (am->fileExists(basePath)) fullPath = basePath;
+                                    else continue;
+
+                                    def.regionLayers.emplace_back(region, fullPath);
+                                    allPaths.push_back(fullPath);
+                                }
+                            }
+                        }
+
+                        // Determine compositing mode
+                        if (!def.basePath.empty()) {
+                            bool needsComposite = !def.overlayPaths.empty() || !def.regionLayers.empty();
+                            if (needsComposite && !def.skinTextureSlots.empty()) {
+                                def.hasComposite = true;
+                            } else if (!def.skinTextureSlots.empty()) {
+                                def.hasSimpleSkin = true;
+                            }
+                        }
+
+                        // --- Hair texture from CharSections (section 3) ---
+                        {
+                            auto csDbc = am->loadDBC("CharSections.dbc");
+                            if (csDbc) {
+                                const auto* csL = pipeline::getActiveDBCLayout()
+                                    ? pipeline::getActiveDBCLayout()->getLayout("CharSections") : nullptr;
+                                uint32_t targetRace = static_cast<uint32_t>(extraCopy.raceId);
+                                uint32_t targetSex = static_cast<uint32_t>(extraCopy.sexId);
+
+                                for (uint32_t r = 0; r < csDbc->getRecordCount(); r++) {
+                                    uint32_t raceId = csDbc->getUInt32(r, csL ? (*csL)["RaceID"] : 1);
+                                    uint32_t sexId = csDbc->getUInt32(r, csL ? (*csL)["SexID"] : 2);
+                                    if (raceId != targetRace || sexId != targetSex) continue;
+                                    uint32_t section = csDbc->getUInt32(r, csL ? (*csL)["BaseSection"] : 3);
+                                    if (section != 3) continue;
+                                    uint32_t variation = csDbc->getUInt32(r, csL ? (*csL)["VariationIndex"] : 4);
+                                    uint32_t colorIdx = csDbc->getUInt32(r, csL ? (*csL)["ColorIndex"] : 5);
+                                    if (variation != static_cast<uint32_t>(extraCopy.hairStyleId)) continue;
+                                    if (colorIdx != static_cast<uint32_t>(extraCopy.hairColorId)) continue;
+                                    def.hairTexturePath = csDbc->getString(r, csL ? (*csL)["Texture1"] : 6);
+                                    break;
+                                }
+
+                                if (!def.hairTexturePath.empty()) {
+                                    allPaths.push_back(def.hairTexturePath);
+                                } else if (def.hasBakedSkin && !def.hairTextureSlots.empty()) {
+                                    def.useBakedForHair = true;
+                                    // bakedSkinPath already in allPaths
+                                }
+                            }
+                        }
+
+                        // --- Pre-decode all BLP textures on this background thread ---
+                        for (const auto& path : allPaths) {
+                            std::string key = path;
+                            std::replace(key.begin(), key.end(), '/', '\\');
+                            std::transform(key.begin(), key.end(), key.begin(),
+                                           [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+                            if (result.predecodedTextures.count(key)) continue;
+                            auto blp = am->loadTexture(key);
+                            if (blp.isValid()) {
+                                result.predecodedTextures[key] = std::move(blp);
+                            }
+                        }
+
+                        return result;
+                    });
+                asyncNpcCompositeLoads_.push_back(std::move(load));
+                hasHumanoidTexture = true;  // skip non-humanoid skin block
+            } else {
+                LOG_WARNING("  extraDisplayId ", dispData.extraDisplayId, " not found in humanoidExtraMap");
+            }
+        }
+
+        // Apply creature skin textures (for non-humanoid creatures)
+        if (!hasHumanoidTexture && modelData) {
+            auto resolveCreatureSkinPath = [&](const std::string& skinField) -> std::string {
+                if (skinField.empty()) return "";
+
+                std::string raw = skinField;
+                std::replace(raw.begin(), raw.end(), '/', '\\');
+                auto isSpace = [](unsigned char c) { return std::isspace(c) != 0; };
+                raw.erase(raw.begin(), std::find_if(raw.begin(), raw.end(), [&](unsigned char c) { return !isSpace(c); }));
+                raw.erase(std::find_if(raw.rbegin(), raw.rend(), [&](unsigned char c) { return !isSpace(c); }).base(), raw.end());
+                if (raw.empty()) return "";
+
+                auto hasBlpExt = [](const std::string& p) {
+                    if (p.size() < 4) return false;
+                    std::string ext = p.substr(p.size() - 4);
+                    std::transform(ext.begin(), ext.end(), ext.begin(),
+                                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+                    return ext == ".blp";
+                };
+                auto addCandidate = [](std::vector<std::string>& out, const std::string& p) {
+                    if (p.empty()) return;
+                    if (std::find(out.begin(), out.end(), p) == out.end()) out.push_back(p);
+                };
+
+                std::vector<std::string> candidates;
+                const bool hasDir = (raw.find('\\') != std::string::npos || raw.find('/') != std::string::npos);
+                const bool hasExt = hasBlpExt(raw);
+
+                if (hasDir) {
+                    addCandidate(candidates, raw);
+                    if (!hasExt) addCandidate(candidates, raw + ".blp");
+                } else {
+                    addCandidate(candidates, modelDir + raw);
+                    if (!hasExt) addCandidate(candidates, modelDir + raw + ".blp");
+                    addCandidate(candidates, raw);
+                    if (!hasExt) addCandidate(candidates, raw + ".blp");
+                }
+
+                for (const auto& c : candidates) {
+                    if (assetManager->fileExists(c)) return c;
+                }
+                return "";
+            };
+
+            for (size_t ti = 0; ti < modelData->textures.size(); ti++) {
+                const auto& tex = modelData->textures[ti];
+                std::string skinPath;
+
+                // Creature skin types: 11 = skin1, 12 = skin2, 13 = skin3
+                if (tex.type == 11 && !dispData.skin1.empty()) {
+                    skinPath = resolveCreatureSkinPath(dispData.skin1);
+                } else if (tex.type == 12 && !dispData.skin2.empty()) {
+                    skinPath = resolveCreatureSkinPath(dispData.skin2);
+                } else if (tex.type == 13 && !dispData.skin3.empty()) {
+                    skinPath = resolveCreatureSkinPath(dispData.skin3);
+                }
+
+                if (!skinPath.empty()) {
+                    rendering::VkTexture* skinTex = charRenderer->loadTexture(skinPath);
+                    if (skinTex) {
+                        charRenderer->setModelTexture(modelId, static_cast<uint32_t>(ti), skinTex);
+                        LOG_DEBUG("Applied creature skin texture: ", skinPath, " to slot ", ti);
+                    }
+                } else if ((tex.type == 11 && !dispData.skin1.empty()) ||
+                           (tex.type == 12 && !dispData.skin2.empty()) ||
+                           (tex.type == 13 && !dispData.skin3.empty())) {
+                    LOG_WARNING("Creature skin texture not found for displayId ", displayId,
+                                " slot ", ti, " type ", tex.type,
+                                " (skin fields: '", dispData.skin1, "', '",
+                                dispData.skin2, "', '", dispData.skin3, "')");
+                }
+            }
+        }
+
+        // Clear pre-decoded cache after applying all display textures
+        charRenderer->setPredecodedBLPCache(nullptr);
+        displayIdPredecodedTextures_.erase(displayId);
+        {
+            auto texEnd = std::chrono::steady_clock::now();
+            float texMs = std::chrono::duration<float, std::milli>(texEnd - texStart).count();
+            if (texMs > 50.0f) {
+                LOG_WARNING("spawnCreature texture setup took ", texMs, "ms displayId=", displayId,
+                            " hasPreDec=", hasPreDec, " extra=", dispData.extraDisplayId);
+            }
+        }
+    }
+
+    // Use the entity's latest server-authoritative position rather than the stale spawn
+    // position. Movement packets (SMSG_MONSTER_MOVE) can arrive while a creature is still
+    // queued in pendingCreatureSpawns_ and get silently dropped. getLatestX/Y/Z returns
+    // the movement destination if the entity is mid-move, which is always up-to-date
+    // regardless of distance culling (unlike getX/Y/Z which requires updateMovement).
+    if (gameHandler) {
+        if (auto entity = gameHandler->getEntityManager().getEntity(guid)) {
+            x = entity->getLatestX();
+            y = entity->getLatestY();
+            z = entity->getLatestZ();
+            orientation = entity->getOrientation();
+        }
+    }
+
+    // Convert canonical → render coordinates
+    glm::vec3 renderPos = core::coords::canonicalToRender(glm::vec3(x, y, z));
+
+    // Keep authoritative server Z for online creature spawns.
+    // Terrain-based lifting can incorrectly move elevated NPCs (e.g. flight masters on
+    // Stormwind ramparts) to bad heights relative to WMO geometry.
+
+    // Convert canonical WoW orientation (0=north) -> render yaw (0=west)
+    float renderYaw = orientation + glm::radians(90.0f);
+
+    // Create instance
+    uint32_t instanceId = charRenderer->createInstance(modelId, renderPos,
+        glm::vec3(0.0f, 0.0f, renderYaw), 1.0f);
+
+    if (instanceId == 0) {
+        LOG_WARNING("Failed to create creature instance for guid 0x", std::hex, guid, std::dec);
+        return;
+    }
+
+    // Per-instance hair/skin texture overrides — runs for ALL NPCs (including cached models)
+    // so that each NPC gets its own hair/skin color regardless of model sharing.
+    // Uses pre-built CharSections cache (O(1) lookup instead of O(N) DBC scan).
+    {
+        if (!charSectionsCacheBuilt_) buildCharSectionsCache();
+        auto itDD = displayDataMap_.find(displayId);
+        if (itDD != displayDataMap_.end() && itDD->second.extraDisplayId != 0) {
+            auto itExtra2 = humanoidExtraMap_.find(itDD->second.extraDisplayId);
+            if (itExtra2 != humanoidExtraMap_.end()) {
+                const auto& extra = itExtra2->second;
+                const auto* md = charRenderer->getModelData(modelId);
+                if (md) {
+                        // Look up hair texture (section 3) via cache
+                        rendering::VkTexture* whiteTex = charRenderer->loadTexture("");
+                        std::string hairPath = lookupCharSection(
+                            extra.raceId, extra.sexId, 3, extra.hairStyleId, extra.hairColorId, 0);
+                        if (!hairPath.empty()) {
+                            rendering::VkTexture* hairTex = charRenderer->loadTexture(hairPath);
+                            if (hairTex && hairTex != whiteTex) {
+                                for (size_t ti = 0; ti < md->textures.size(); ti++) {
+                                    if (md->textures[ti].type == 6) {
+                                        charRenderer->setTextureSlotOverride(instanceId, static_cast<uint16_t>(ti), hairTex);
+                                    }
+                                }
+                            }
+                        }
+
+                        // Look up skin texture (section 0) for per-instance skin color.
+                        // Skip when the NPC has a baked texture or composited equipment —
+                        // those already encode armor over skin and must not be replaced.
+                        bool hasEquipOrBake = !extra.bakeName.empty();
+                        if (!hasEquipOrBake) {
+                            for (int s = 0; s < 11 && !hasEquipOrBake; s++)
+                                if (extra.equipDisplayId[s] != 0) hasEquipOrBake = true;
+                        }
+                        if (!hasEquipOrBake) {
+                            std::string skinPath = lookupCharSection(
+                                extra.raceId, extra.sexId, 0, 0, extra.skinId, 0);
+                            if (!skinPath.empty()) {
+                                rendering::VkTexture* skinTex = charRenderer->loadTexture(skinPath);
+                                if (skinTex) {
+                                    for (size_t ti = 0; ti < md->textures.size(); ti++) {
+                                        uint32_t tt = md->textures[ti].type;
+                                        if (tt == 1 || tt == 11) {
+                                            charRenderer->setTextureSlotOverride(instanceId, static_cast<uint16_t>(ti), skinTex);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                }
+            }
+        }
+    }
+
+    // Optional humanoid NPC geoset mask. Disabled by default because forcing geosets
+    // causes long-standing visual artifacts on some models (missing waist, phantom
+    // bracers, flickering apron overlays). Prefer model defaults.
+    static constexpr bool kEnableNpcSafeGeosetMask = false;
+    if (kEnableNpcSafeGeosetMask &&
+        itDisplayData != displayDataMap_.end() &&
+        itDisplayData->second.extraDisplayId != 0) {
+        auto itExtra = humanoidExtraMap_.find(itDisplayData->second.extraDisplayId);
+        if (itExtra != humanoidExtraMap_.end()) {
+            const auto& extra = itExtra->second;
+            std::unordered_set<uint16_t> safeGeosets;
+            std::unordered_set<uint16_t> modelGeosets;
+            std::unordered_map<uint16_t, uint16_t> firstGeosetByGroup;
+            if (const auto* md = charRenderer->getModelData(modelId)) {
+                for (const auto& b : md->batches) {
+                    const uint16_t sid = b.submeshId;
+                    modelGeosets.insert(sid);
+                    const uint16_t group = static_cast<uint16_t>(sid / 100);
+                    auto it = firstGeosetByGroup.find(group);
+                    if (it == firstGeosetByGroup.end() || sid < it->second) {
+                        firstGeosetByGroup[group] = sid;
+                    }
+                }
+            }
+            auto addSafeGeoset = [&](uint16_t preferredId) {
+                if (preferredId < 100 || modelGeosets.empty()) {
+                    safeGeosets.insert(preferredId);
+                    return;
+                }
+                if (modelGeosets.count(preferredId) > 0) {
+                    safeGeosets.insert(preferredId);
+                    return;
+                }
+                const uint16_t group = static_cast<uint16_t>(preferredId / 100);
+                auto it = firstGeosetByGroup.find(group);
+                if (it != firstGeosetByGroup.end()) {
+                    safeGeosets.insert(it->second);
+                }
+            };
+            uint16_t hairGeoset = 1;
+            uint32_t hairKey = (static_cast<uint32_t>(extra.raceId) << 16) |
+                               (static_cast<uint32_t>(extra.sexId) << 8) |
+                               static_cast<uint32_t>(extra.hairStyleId);
+            auto itHairGeo = hairGeosetMap_.find(hairKey);
+            if (itHairGeo != hairGeosetMap_.end() && itHairGeo->second > 0) {
+                hairGeoset = itHairGeo->second;
+            }
+            const uint16_t selectedHairScalp = (hairGeoset > 0 ? hairGeoset : 1);
+            std::unordered_set<uint16_t> hairScalpGeosetsForRaceSex;
+            for (const auto& [k, v] : hairGeosetMap_) {
+                uint8_t race = static_cast<uint8_t>((k >> 16) & 0xFF);
+                uint8_t sex = static_cast<uint8_t>((k >> 8) & 0xFF);
+                if (race == extra.raceId && sex == extra.sexId && v > 0 && v < 100) {
+                    hairScalpGeosetsForRaceSex.insert(v);
+                }
+            }
+            // Group 0 contains both base body parts and race/sex hair scalp variants.
+            // Keep all non-hair body submeshes, but only the selected hair scalp.
+            for (uint16_t sid : modelGeosets) {
+                if (sid >= 100) continue;
+                if (hairScalpGeosetsForRaceSex.count(sid) > 0 && sid != selectedHairScalp) continue;
+                safeGeosets.insert(sid);
+            }
+            safeGeosets.insert(selectedHairScalp);
+            addSafeGeoset(static_cast<uint16_t>(100 + std::max<uint16_t>(hairGeoset, 1)));
+
+            uint32_t facialKey = (static_cast<uint32_t>(extra.raceId) << 16) |
+                                 (static_cast<uint32_t>(extra.sexId) << 8) |
+                                 static_cast<uint32_t>(extra.facialHairId);
+            auto itFacial = facialHairGeosetMap_.find(facialKey);
+            if (itFacial != facialHairGeosetMap_.end()) {
+                const auto& fhg = itFacial->second;
+                addSafeGeoset(static_cast<uint16_t>(200 + std::max<uint16_t>(fhg.geoset200, 1)));
+                addSafeGeoset(static_cast<uint16_t>(300 + std::max<uint16_t>(fhg.geoset300, 1)));
+            } else {
+                addSafeGeoset(201);
+                addSafeGeoset(301);
+            }
+
+            // Force pants (1301) and avoid robe skirt variants unless we re-enable full slot-accurate geosets.
+            addSafeGeoset(301);
+            addSafeGeoset(401);
+            addSafeGeoset(402);
+            addSafeGeoset(501);
+            addSafeGeoset(701);
+            addSafeGeoset(801);
+            addSafeGeoset(901);
+            addSafeGeoset(1201);
+            addSafeGeoset(1301);
+            addSafeGeoset(2002);
+
+            charRenderer->setActiveGeosets(instanceId, safeGeosets);
+        }
+    }
+
+    // NOTE: Custom humanoid NPC geoset/equipment overrides are currently too
+    // aggressive and can make NPCs invisible (targetable but not rendered).
+    // Keep default model geosets for online creatures until this path is made
+    // data-accurate per display model.
+    static constexpr bool kEnableNpcHumanoidOverrides = false;
+
+    // Set geosets for humanoid NPCs based on CreatureDisplayInfoExtra
+    if (kEnableNpcHumanoidOverrides &&
+        itDisplayData != displayDataMap_.end() &&
+        itDisplayData->second.extraDisplayId != 0) {
+        auto itExtra = humanoidExtraMap_.find(itDisplayData->second.extraDisplayId);
+        if (itExtra != humanoidExtraMap_.end()) {
+            const auto& extra = itExtra->second;
+            std::unordered_set<uint16_t> activeGeosets;
+
+            // Group 0: body base (id=0 always) + hair scalp mesh from CharHairGeosets.dbc
+            activeGeosets.insert(0);  // Body base mesh
+
+            // Hair: CharHairGeosets.dbc maps (race, sex, hairStyleId) → group 0 scalp submeshId
+            uint32_t hairKey = (static_cast<uint32_t>(extra.raceId) << 16) |
+                               (static_cast<uint32_t>(extra.sexId) << 8) |
+                               static_cast<uint32_t>(extra.hairStyleId);
+            auto itHairGeo = hairGeosetMap_.find(hairKey);
+            uint16_t hairScalpId = (itHairGeo != hairGeosetMap_.end()) ? itHairGeo->second : 0;
+            if (hairScalpId > 0) {
+                activeGeosets.insert(hairScalpId);                        // Group 0 scalp/hair mesh
+                activeGeosets.insert(static_cast<uint16_t>(100 + hairScalpId)); // Group 1 connector (if exists)
+            } else {
+                // Bald (geosetId=0): body base has a hole at the crown, so include
+                // submeshId=1 (bald scalp cap with body skin texture) to cover it.
+                activeGeosets.insert(1);    // Group 0 bald scalp mesh
+                activeGeosets.insert(101);  // Group 1 connector
+            }
+            uint16_t hairGeoset = (hairScalpId > 0) ? hairScalpId : 1;
+
+            // Facial hair geosets from CharFacialHairStyles.dbc lookup
+            uint32_t facialKey = (static_cast<uint32_t>(extra.raceId) << 16) |
+                                 (static_cast<uint32_t>(extra.sexId) << 8) |
+                                 static_cast<uint32_t>(extra.facialHairId);
+            auto itFacial = facialHairGeosetMap_.find(facialKey);
+            if (itFacial != facialHairGeosetMap_.end()) {
+                const auto& fhg = itFacial->second;
+                // DBC values are variation indices within each group; add group base
+                activeGeosets.insert(static_cast<uint16_t>(100 + std::max(fhg.geoset100, (uint16_t)1)));
+                activeGeosets.insert(static_cast<uint16_t>(300 + std::max(fhg.geoset300, (uint16_t)1)));
+                activeGeosets.insert(static_cast<uint16_t>(200 + std::max(fhg.geoset200, (uint16_t)1)));
+            } else {
+                activeGeosets.insert(101); // Default group 1: no extra
+                activeGeosets.insert(201); // Default group 2: no facial hair
+                activeGeosets.insert(301); // Default group 3: no facial hair
+            }
+
+            // Default equipment geosets (bare/no armor)
+            // CharGeosets: group 4=gloves(forearm), 5=boots(shin), 8=sleeves, 9=kneepads, 13=pants
+            std::unordered_set<uint16_t> modelGeosets;
+            std::unordered_map<uint16_t, uint16_t> firstByGroup;
+            if (const auto* md = charRenderer->getModelData(modelId)) {
+                for (const auto& b : md->batches) {
+                    const uint16_t sid = b.submeshId;
+                    modelGeosets.insert(sid);
+                    const uint16_t group = static_cast<uint16_t>(sid / 100);
+                    auto it = firstByGroup.find(group);
+                    if (it == firstByGroup.end() || sid < it->second) {
+                        firstByGroup[group] = sid;
+                    }
+                }
+            }
+            auto pickGeoset = [&](uint16_t preferred, uint16_t group) -> uint16_t {
+                if (preferred != 0 && modelGeosets.count(preferred) > 0) return preferred;
+                auto it = firstByGroup.find(group);
+                if (it != firstByGroup.end()) return it->second;
+                return preferred;
+            };
+
+            uint16_t geosetGloves = pickGeoset(301, 3);   // Bare gloves/forearms (group 3)
+            uint16_t geosetBoots = pickGeoset(401, 4);    // Bare boots/shins (group 4)
+            uint16_t geosetTorso = pickGeoset(501, 5);    // Base torso/waist (group 5)
+            uint16_t geosetSleeves = pickGeoset(801, 8);  // Bare wrists (group 8, controlled by chest)
+            uint16_t geosetPants = pickGeoset(1301, 13);  // Bare legs (group 13)
+            uint16_t geosetCape = 0;       // Group 15 disabled unless cape is equipped
+            uint16_t geosetTabard = 0;     // TODO: NPC tabard geosets currently flicker/apron; keep hidden for now
+            rendering::VkTexture* npcCapeTextureId = nullptr;
+
+            // Load equipment geosets from ItemDisplayInfo.dbc
+            // DBC columns: 7=GeosetGroup[0], 8=GeosetGroup[1], 9=GeosetGroup[2]
+            auto itemDisplayDbc = assetManager->loadDBC("ItemDisplayInfo.dbc");
+            const auto* idiL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
+            if (itemDisplayDbc) {
+                // Equipment slots: 0=helm, 1=shoulder, 2=shirt, 3=chest, 4=belt, 5=legs, 6=feet, 7=wrist, 8=hands, 9=tabard, 10=cape
+                const uint32_t fGG1 = idiL ? (*idiL)["GeosetGroup1"] : 7;
+
+                auto readGeosetGroup = [&](int slot, const char* slotName) -> uint32_t {
+                    uint32_t did = extra.equipDisplayId[slot];
+                    if (did == 0) return 0;
+                    int32_t idx = itemDisplayDbc->findRecordById(did);
+                    if (idx < 0) {
+                        LOG_INFO("NPC equip slot ", slotName, " displayId=", did, " NOT FOUND in ItemDisplayInfo.dbc");
+                        return 0;
+                    }
+                    uint32_t gg = itemDisplayDbc->getUInt32(static_cast<uint32_t>(idx), fGG1);
+                    LOG_INFO("NPC equip slot ", slotName, " displayId=", did, " GeosetGroup1=", gg, " (field=", fGG1, ")");
+                    return gg;
+                };
+
+                // Chest (slot 3) → group 5 (torso) + group 8 (sleeves/wristbands)
+                {
+                    uint32_t gg = readGeosetGroup(3, "chest");
+                    if (gg > 0) geosetTorso = pickGeoset(static_cast<uint16_t>(501 + gg), 5);
+                    if (gg > 0) geosetSleeves = pickGeoset(static_cast<uint16_t>(801 + gg), 8);
+                }
+
+                // Legs (slot 5) → group 13 (trousers)
+                {
+                    uint32_t gg = readGeosetGroup(5, "legs");
+                    if (gg > 0) geosetPants = pickGeoset(static_cast<uint16_t>(1301 + gg), 13);
+                }
+
+                // Feet (slot 6) → group 4 (boots/shins)
+                {
+                    uint32_t gg = readGeosetGroup(6, "feet");
+                    if (gg > 0) geosetBoots = pickGeoset(static_cast<uint16_t>(401 + gg), 4);
+                }
+
+                // Hands (slot 8) → group 3 (gloves/forearms)
+                {
+                    uint32_t gg = readGeosetGroup(8, "hands");
+                    if (gg > 0) geosetGloves = pickGeoset(static_cast<uint16_t>(301 + gg), 3);
+                }
+
+                // Tabard (slot 9) intentionally disabled for now (see geosetTabard TODO above).
+
+                // Cape (slot 10) → group 15
+                if (extra.equipDisplayId[10] != 0) {
+                    int32_t idx = itemDisplayDbc->findRecordById(extra.equipDisplayId[10]);
+                    if (idx >= 0) {
+                        geosetCape = 1502;
+                        const bool npcIsFemale = (extra.sexId == 1);
+                        const uint32_t leftTexField = idiL ? (*idiL)["LeftModelTexture"] : 3u;
+                        std::vector<std::string> capeNames;
+                        auto addName = [&](const std::string& n) {
+                            if (!n.empty() && std::find(capeNames.begin(), capeNames.end(), n) == capeNames.end()) {
+                                capeNames.push_back(n);
+                            }
+                        };
+                        std::string leftName = itemDisplayDbc->getString(static_cast<uint32_t>(idx), leftTexField);
+                        addName(leftName);
+
+                        auto hasBlpExt = [](const std::string& p) {
+                            if (p.size() < 4) return false;
+                            std::string ext = p.substr(p.size() - 4);
+                            std::transform(ext.begin(), ext.end(), ext.begin(),
+                                           [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+                            return ext == ".blp";
+                        };
+                        std::vector<std::string> capeCandidates;
+                        auto addCapeCandidate = [&](const std::string& p) {
+                            if (p.empty()) return;
+                            if (std::find(capeCandidates.begin(), capeCandidates.end(), p) == capeCandidates.end()) {
+                                capeCandidates.push_back(p);
+                            }
+                        };
+                        for (const auto& nameRaw : capeNames) {
+                            std::string name = nameRaw;
+                            std::replace(name.begin(), name.end(), '/', '\\');
+                            const bool hasDir = (name.find('\\') != std::string::npos);
+                            const bool hasExt = hasBlpExt(name);
+                            if (hasDir) {
+                                addCapeCandidate(name);
+                                if (!hasExt) addCapeCandidate(name + ".blp");
+                            } else {
+                                std::string baseObj = "Item\\ObjectComponents\\Cape\\" + name;
+                                std::string baseTex = "Item\\TextureComponents\\Cape\\" + name;
+                                addCapeCandidate(baseObj);
+                                addCapeCandidate(baseTex);
+                                if (!hasExt) {
+                                    addCapeCandidate(baseObj + ".blp");
+                                    addCapeCandidate(baseTex + ".blp");
+                                }
+                                addCapeCandidate(baseObj + (npcIsFemale ? "_F.blp" : "_M.blp"));
+                                addCapeCandidate(baseObj + "_U.blp");
+                                addCapeCandidate(baseTex + (npcIsFemale ? "_F.blp" : "_M.blp"));
+                                addCapeCandidate(baseTex + "_U.blp");
+                            }
+                        }
+                        const rendering::VkTexture* whiteTex = charRenderer->loadTexture("");
+                        for (const auto& candidate : capeCandidates) {
+                            rendering::VkTexture* tex = charRenderer->loadTexture(candidate);
+                            if (tex && tex != whiteTex) {
+                                npcCapeTextureId = tex;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Apply equipment geosets
+            activeGeosets.insert(geosetGloves);
+            activeGeosets.insert(geosetBoots);
+            activeGeosets.insert(geosetTorso);
+            activeGeosets.insert(geosetSleeves);
+            activeGeosets.insert(geosetPants);
+            if (geosetCape != 0) {
+                activeGeosets.insert(geosetCape);
+            }
+            if (geosetTabard != 0) {
+                activeGeosets.insert(geosetTabard);
+            }
+            activeGeosets.insert(pickGeoset(702, 7));   // Ears: default
+            activeGeosets.insert(pickGeoset(902, 9));   // Kneepads: default
+            activeGeosets.insert(pickGeoset(2002, 20)); // Bare feet mesh
+            // Keep all model-present torso variants active to avoid missing male
+            // abdomen/waist sections when a single 5xx pick is wrong.
+            for (uint16_t sid : modelGeosets) {
+                if ((sid / 100) == 5) activeGeosets.insert(sid);
+            }
+            // Keep all model-present pelvis variants active to avoid missing waist/belt
+            // sections on some humanoid males when a single 9xx variant is wrong.
+            for (uint16_t sid : modelGeosets) {
+                if ((sid / 100) == 9) activeGeosets.insert(sid);
+            }
+
+            // Hide hair under helmets: replace style-specific scalp with bald scalp
+            if (extra.equipDisplayId[0] != 0 && hairGeoset > 1) {
+                activeGeosets.erase(hairGeoset);                              // Remove style scalp
+                activeGeosets.erase(static_cast<uint16_t>(100 + hairGeoset)); // Remove style group 1
+                activeGeosets.insert(1);    // Bald scalp cap (group 0)
+                activeGeosets.insert(101);  // Default group 1 connector
+            }
+
+            // Log model's actual submesh IDs for debugging geoset mismatches
+            if (auto* md = charRenderer->getModelData(modelId)) {
+                std::string batchIds;
+                for (const auto& b : md->batches) {
+                    if (!batchIds.empty()) batchIds += ",";
+                    batchIds += std::to_string(b.submeshId);
+                }
+                LOG_INFO("Model batches submeshIds: [", batchIds, "]");
+            }
+
+            // Log what geosets we're setting for debugging
+            std::string geosetList;
+            for (uint16_t g : activeGeosets) {
+                if (!geosetList.empty()) geosetList += ",";
+                geosetList += std::to_string(g);
+            }
+            LOG_INFO("NPC geosets for instance ", instanceId, ": [", geosetList, "]");
+            charRenderer->setActiveGeosets(instanceId, activeGeosets);
+            if (geosetCape != 0 && npcCapeTextureId) {
+                charRenderer->setGroupTextureOverride(instanceId, 15, npcCapeTextureId);
+                if (const auto* md = charRenderer->getModelData(modelId)) {
+                    for (size_t ti = 0; ti < md->textures.size(); ti++) {
+                        if (md->textures[ti].type == 2) {
+                            charRenderer->setTextureSlotOverride(instanceId, static_cast<uint16_t>(ti), npcCapeTextureId);
+                        }
+                    }
+                }
+            }
+            LOG_DEBUG("Set humanoid geosets: hair=", (int)hairGeoset,
+                      " sleeves=", geosetSleeves, " pants=", geosetPants,
+                      " boots=", geosetBoots, " gloves=", geosetGloves);
+
+            // TODO(#helmet-attach): NPC helmet attachment anchors are currently unreliable
+            // on some humanoid models (floating/incorrect bone bind). Keep hidden for now.
+            static constexpr bool kEnableNpcHelmetAttachmentsMainPath = false;
+            // Load and attach helmet model if equipped
+            if (kEnableNpcHelmetAttachmentsMainPath && extra.equipDisplayId[0] != 0 && itemDisplayDbc) {
+                int32_t helmIdx = itemDisplayDbc->findRecordById(extra.equipDisplayId[0]);
+                if (helmIdx >= 0) {
+                    // Get helmet model name from ItemDisplayInfo.dbc (LeftModel)
+                    std::string helmModelName = itemDisplayDbc->getString(static_cast<uint32_t>(helmIdx), idiL ? (*idiL)["LeftModel"] : 1);
+                    if (!helmModelName.empty()) {
+                        // Convert .mdx to .m2
+                        size_t dotPos = helmModelName.rfind('.');
+                        if (dotPos != std::string::npos) {
+                            helmModelName = helmModelName.substr(0, dotPos);
+                        }
+
+                        // WoW helmet M2 files have per-race/gender variants with a suffix
+                        // e.g. Helm_Plate_B_01Stormwind_HuM.M2 for Human Male
+                        // ChrRaces.dbc ClientPrefix values (raceId → prefix):
+                        static const std::unordered_map<uint8_t, std::string> racePrefix = {
+                            {1, "Hu"}, {2, "Or"}, {3, "Dw"}, {4, "Ni"}, {5, "Sc"},
+                            {6, "Ta"}, {7, "Gn"}, {8, "Tr"}, {10, "Be"}, {11, "Dr"}
+                        };
+                        std::string genderSuffix = (extra.sexId == 0) ? "M" : "F";
+                        std::string raceSuffix;
+                        auto itRace = racePrefix.find(extra.raceId);
+                        if (itRace != racePrefix.end()) {
+                            raceSuffix = "_" + itRace->second + genderSuffix;
+                        }
+
+                        // Try race/gender-specific variant first, then base name
+                        std::string helmPath;
+                        std::vector<uint8_t> helmData;
+                        if (!raceSuffix.empty()) {
+                            helmPath = "Item\\ObjectComponents\\Head\\" + helmModelName + raceSuffix + ".m2";
+                            helmData = assetManager->readFile(helmPath);
+                        }
+                        if (helmData.empty()) {
+                            helmPath = "Item\\ObjectComponents\\Head\\" + helmModelName + ".m2";
+                            helmData = assetManager->readFile(helmPath);
+                        }
+
+                        if (!helmData.empty()) {
+                            auto helmModel = pipeline::M2Loader::load(helmData);
+                            // Load skin (only for WotLK M2s)
+                            std::string skinPath = helmPath.substr(0, helmPath.size() - 3) + "00.skin";
+                            auto skinData = assetManager->readFile(skinPath);
+                            if (!skinData.empty() && helmModel.version >= 264) {
+                                pipeline::M2Loader::loadSkin(skinData, helmModel);
+                            }
+
+                            if (helmModel.isValid()) {
+                                // Attachment point 11 = Head
+                                uint32_t helmModelId = nextCreatureModelId_++;
+                                // Get texture from ItemDisplayInfo (LeftModelTexture)
+                                std::string helmTexName = itemDisplayDbc->getString(static_cast<uint32_t>(helmIdx), idiL ? (*idiL)["LeftModelTexture"] : 3);
+                                std::string helmTexPath;
+                                if (!helmTexName.empty()) {
+                                    // Try race/gender suffixed texture first
+                                    if (!raceSuffix.empty()) {
+                                        std::string suffixedTex = "Item\\ObjectComponents\\Head\\" + helmTexName + raceSuffix + ".blp";
+                                        if (assetManager->fileExists(suffixedTex)) {
+                                            helmTexPath = suffixedTex;
+                                        }
+                                    }
+                                    if (helmTexPath.empty()) {
+                                        helmTexPath = "Item\\ObjectComponents\\Head\\" + helmTexName + ".blp";
+                                    }
+                                }
+                                bool attached = charRenderer->attachWeapon(instanceId, 0, helmModel, helmModelId, helmTexPath);
+                                if (!attached) {
+                                    attached = charRenderer->attachWeapon(instanceId, 11, helmModel, helmModelId, helmTexPath);
+                                }
+                                if (attached) {
+                                    LOG_DEBUG("Attached helmet model: ", helmPath, " tex: ", helmTexPath);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // With full humanoid overrides disabled, some character-style NPC models still render
+    // conflicting clothing geosets at once (global capes, robe skirts over trousers).
+    // Normalize only clothing groups while leaving all other model batches untouched.
+    if (const auto* md = charRenderer->getModelData(modelId)) {
+        std::unordered_set<uint16_t> allGeosets;
+        std::unordered_map<uint16_t, uint16_t> firstByGroup;
+        bool hasGroup3 = false;  // glove/forearm variants
+        bool hasGroup4 = false;  // glove/forearm variants (some models)
+        bool hasGroup8 = false;  // sleeve/wrist variants
+        bool hasGroup12 = false; // tabard variants
+        bool hasGroup13 = false; // trousers/robe skirt variants
+        bool hasGroup15 = false; // cloak variants
+        for (const auto& b : md->batches) {
+            const uint16_t sid = b.submeshId;
+            const uint16_t group = static_cast<uint16_t>(sid / 100);
+            allGeosets.insert(sid);
+            auto itFirst = firstByGroup.find(group);
+            if (itFirst == firstByGroup.end() || sid < itFirst->second) {
+                firstByGroup[group] = sid;
+            }
+            if (group == 3) hasGroup3 = true;
+            if (group == 4) hasGroup4 = true;
+            if (group == 8) hasGroup8 = true;
+            if (group == 12) hasGroup12 = true;
+            if (group == 13) hasGroup13 = true;
+            if (group == 15) hasGroup15 = true;
+        }
+
+        // Only apply to humanoid-like clothing models.
+        if (hasGroup3 || hasGroup4 || hasGroup8 || hasGroup12 || hasGroup13 || hasGroup15) {
+            bool hasRenderableCape = false;
+            bool hasEquippedTabard = false;
+            bool hasHumanoidExtra = false;
+            uint8_t extraRaceId = 0;
+            uint8_t extraSexId = 0;
+            uint16_t selectedHairScalp = 1;
+            uint16_t selectedFacial200 = 200;
+            uint16_t selectedFacial300 = 300;
+            uint16_t selectedFacial300Alt = 300;
+            bool wantsFacialHair = false;
+            uint32_t equipChestGG = 0, equipLegsGG = 0, equipFeetGG = 0;
+            std::unordered_set<uint16_t> hairScalpGeosetsForRaceSex;
+            if (itDisplayData != displayDataMap_.end() &&
+                itDisplayData->second.extraDisplayId != 0) {
+                auto itExtra = humanoidExtraMap_.find(itDisplayData->second.extraDisplayId);
+                if (itExtra != humanoidExtraMap_.end()) {
+                    hasHumanoidExtra = true;
+                    extraRaceId = itExtra->second.raceId;
+                    extraSexId = itExtra->second.sexId;
+                    hasEquippedTabard = (itExtra->second.equipDisplayId[9] != 0);
+                    uint32_t hairKey = (static_cast<uint32_t>(extraRaceId) << 16) |
+                                       (static_cast<uint32_t>(extraSexId) << 8) |
+                                       static_cast<uint32_t>(itExtra->second.hairStyleId);
+                    auto itHairGeo = hairGeosetMap_.find(hairKey);
+                    if (itHairGeo != hairGeosetMap_.end() && itHairGeo->second > 0) {
+                        selectedHairScalp = itHairGeo->second;
+                    }
+                    uint32_t facialKey = (static_cast<uint32_t>(extraRaceId) << 16) |
+                                         (static_cast<uint32_t>(extraSexId) << 8) |
+                                         static_cast<uint32_t>(itExtra->second.facialHairId);
+                    wantsFacialHair = (itExtra->second.facialHairId != 0);
+                    auto itFacial = facialHairGeosetMap_.find(facialKey);
+                    if (itFacial != facialHairGeosetMap_.end()) {
+                        selectedFacial200 = static_cast<uint16_t>(200 + itFacial->second.geoset200);
+                        selectedFacial300 = static_cast<uint16_t>(300 + itFacial->second.geoset300);
+                        selectedFacial300Alt = static_cast<uint16_t>(300 + itFacial->second.geoset200);
+                    }
+                    for (const auto& [k, v] : hairGeosetMap_) {
+                        uint8_t race = static_cast<uint8_t>((k >> 16) & 0xFF);
+                        uint8_t sex = static_cast<uint8_t>((k >> 8) & 0xFF);
+                        if (race == extraRaceId && sex == extraSexId && v > 0 && v < 100) {
+                            hairScalpGeosetsForRaceSex.insert(v);
+                        }
+                    }
+                    auto itemDisplayDbc = assetManager->loadDBC("ItemDisplayInfo.dbc");
+                    const auto* idiL = pipeline::getActiveDBCLayout()
+                        ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
+
+                    uint32_t capeDisplayId = itExtra->second.equipDisplayId[10];
+                    if (capeDisplayId != 0 && itemDisplayDbc) {
+                            int32_t recIdx = itemDisplayDbc->findRecordById(capeDisplayId);
+                            if (recIdx >= 0) {
+                                const uint32_t leftTexField = idiL ? (*idiL)["LeftModelTexture"] : 3u;
+                                const uint32_t rightTexField = idiL ? (*idiL)["RightModelTexture"] : 4u;
+                                std::vector<std::string> capeNames;
+                                auto addName = [&](const std::string& n) {
+                                    if (!n.empty() &&
+                                        std::find(capeNames.begin(), capeNames.end(), n) == capeNames.end()) {
+                                        capeNames.push_back(n);
+                                    }
+                                };
+                                addName(itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), leftTexField));
+                                addName(itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), rightTexField));
+
+                                auto hasBlpExt = [](const std::string& p) {
+                                    if (p.size() < 4) return false;
+                                    std::string ext = p.substr(p.size() - 4);
+                                    std::transform(ext.begin(), ext.end(), ext.begin(),
+                                                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+                                    return ext == ".blp";
+                                };
+
+                                const bool npcIsFemale = (itExtra->second.sexId == 1);
+                                std::vector<std::string> candidates;
+                                auto addCandidate = [&](const std::string& p) {
+                                    if (p.empty()) return;
+                                    if (std::find(candidates.begin(), candidates.end(), p) == candidates.end()) {
+                                        candidates.push_back(p);
+                                    }
+                                };
+
+                                for (const auto& raw : capeNames) {
+                                    std::string name = raw;
+                                    std::replace(name.begin(), name.end(), '/', '\\');
+                                    const bool hasDir = (name.find('\\') != std::string::npos);
+                                    const bool hasExt = hasBlpExt(name);
+                                    if (hasDir) {
+                                        addCandidate(name);
+                                        if (!hasExt) addCandidate(name + ".blp");
+                                    } else {
+                                        std::string baseObj = "Item\\ObjectComponents\\Cape\\" + name;
+                                        std::string baseTex = "Item\\TextureComponents\\Cape\\" + name;
+                                        addCandidate(baseObj);
+                                        addCandidate(baseTex);
+                                        if (!hasExt) {
+                                            addCandidate(baseObj + ".blp");
+                                            addCandidate(baseTex + ".blp");
+                                        }
+                                        addCandidate(baseObj + (npcIsFemale ? "_F.blp" : "_M.blp"));
+                                        addCandidate(baseObj + "_U.blp");
+                                        addCandidate(baseTex + (npcIsFemale ? "_F.blp" : "_M.blp"));
+                                        addCandidate(baseTex + "_U.blp");
+                                    }
+                                }
+
+                                for (const auto& p : candidates) {
+                                    if (assetManager->fileExists(p)) {
+                                        hasRenderableCape = true;
+                                        break;
+                                    }
+                                }
+                            }
+                    }
+
+                    // Read GeosetGroup1 from equipment to drive clothed mesh selection
+                    if (itemDisplayDbc) {
+                        const uint32_t fGG1 = idiL ? (*idiL)["GeosetGroup1"] : 7;
+                        auto readGG = [&](uint32_t did) -> uint32_t {
+                            if (did == 0) return 0;
+                            int32_t idx = itemDisplayDbc->findRecordById(did);
+                            return (idx >= 0) ? itemDisplayDbc->getUInt32(static_cast<uint32_t>(idx), fGG1) : 0;
+                        };
+                        equipChestGG = readGG(itExtra->second.equipDisplayId[3]);
+                        if (equipChestGG == 0) equipChestGG = readGG(itExtra->second.equipDisplayId[2]); // shirt fallback
+                        equipLegsGG = readGG(itExtra->second.equipDisplayId[5]);
+                        equipFeetGG = readGG(itExtra->second.equipDisplayId[6]);
+                    }
+                }
+            }
+
+            std::unordered_set<uint16_t> normalizedGeosets;
+            for (uint16_t sid : allGeosets) {
+                const uint16_t group = static_cast<uint16_t>(sid / 100);
+                if (group == 3 || group == 4 || group == 8 || group == 12 || group == 13 || group == 15) continue;
+                // Some humanoid models carry cloak cloth in group 16. Strip this too
+                // when no cape is equipped to avoid "everyone has a cape".
+                if (!hasRenderableCape && group == 16) continue;
+                // Group 0 can contain multiple scalp/hair meshes. Keep only the selected
+                // race/sex/style scalp to avoid overlapping broken hair.
+                if (hasHumanoidExtra && sid < 100 && hairScalpGeosetsForRaceSex.count(sid) > 0 && sid != selectedHairScalp) {
+                    continue;
+                }
+                // Group 1 contains connector variants that mirror scalp style.
+                if (hasHumanoidExtra && group == 1) {
+                    const uint16_t selectedConnector = static_cast<uint16_t>(100 + std::max<uint16_t>(selectedHairScalp, 1));
+                    if (sid != selectedConnector) {
+                        // Keep fallback connector only when selected one does not exist on this model.
+                        if (sid != 101 || allGeosets.count(selectedConnector) > 0) {
+                            continue;
+                        }
+                    }
+                }
+                // Group 2 facial variants: keep selected variant; fallback only if missing.
+                if (hasHumanoidExtra && group == 2) {
+                    if (!wantsFacialHair) {
+                        continue;
+                    }
+                    if (sid != selectedFacial200) {
+                        if (sid != 200 && sid != 201) {
+                            continue;
+                        }
+                        if (allGeosets.count(selectedFacial200) > 0) {
+                            continue;
+                        }
+                    }
+                }
+                normalizedGeosets.insert(sid);
+            }
+
+            auto pickFromGroup = [&](uint16_t preferredSid, uint16_t group) -> uint16_t {
+                if (allGeosets.count(preferredSid) > 0) return preferredSid;
+                auto it = firstByGroup.find(group);
+                if (it != firstByGroup.end()) return it->second;
+                return 0;
+            };
+
+            // Intentionally do not add group 3 (glove/forearm accessory meshes).
+            // Even "bare" variants can produce unwanted looped arm geometry on NPCs.
+
+            if (hasGroup4) {
+                uint16_t wantBoots = (equipFeetGG > 0) ? static_cast<uint16_t>(400 + equipFeetGG) : 401;
+                uint16_t bootsSid = pickFromGroup(wantBoots, 4);
+                if (bootsSid != 0) normalizedGeosets.insert(bootsSid);
+            }
+
+            // Add sleeve/wrist meshes when chest armor calls for them.
+            if (hasGroup8 && equipChestGG > 0) {
+                uint16_t wantSleeves = static_cast<uint16_t>(800 + equipChestGG);
+                uint16_t sleeveSid = pickFromGroup(wantSleeves, 8);
+                if (sleeveSid != 0) normalizedGeosets.insert(sleeveSid);
+            }
+
+            // Show tabard mesh only when CreatureDisplayInfoExtra equips one.
+            if (hasGroup12 && hasEquippedTabard) {
+                uint16_t tabardSid = pickFromGroup(1201, 12);
+                if (tabardSid != 0) normalizedGeosets.insert(tabardSid);
+            }
+
+            // Some mustache/goatee variants are authored in facial group 3xx.
+            // Re-add selected facial 3xx plus low-index facial fallbacks.
+            if (hasHumanoidExtra && wantsFacialHair) {
+                // Prefer alt channel first (often chin-beard), then primary.
+                uint16_t facial300Sid = pickFromGroup(selectedFacial300Alt, 3);
+                if (facial300Sid == 0) facial300Sid = pickFromGroup(selectedFacial300, 3);
+                if (facial300Sid != 0) normalizedGeosets.insert(facial300Sid);
+                if (facial300Sid == 0) {
+                    if (allGeosets.count(300) > 0) normalizedGeosets.insert(300);
+                    else if (allGeosets.count(301) > 0) normalizedGeosets.insert(301);
+                }
+            }
+
+            // Prefer trousers geoset; use covered variant when legs armor exists.
+            if (hasGroup13) {
+                uint16_t wantPants = (equipLegsGG > 0) ? static_cast<uint16_t>(1300 + equipLegsGG) : 1301;
+                uint16_t pantsSid = pickFromGroup(wantPants, 13);
+                if (pantsSid != 0) normalizedGeosets.insert(pantsSid);
+            }
+
+            // Prefer explicit cloak variant only when a cape is equipped.
+            if (hasGroup15 && hasRenderableCape) {
+                uint16_t capeSid = pickFromGroup(1502, 15);
+                if (capeSid != 0) normalizedGeosets.insert(capeSid);
+            }
+
+            if (!normalizedGeosets.empty()) {
+                charRenderer->setActiveGeosets(instanceId, normalizedGeosets);
+            }
+        }
+    }
+
+    // Optional NPC helmet attachments (kept disabled for stability: this path
+    // can increase spawn-time pressure and regress NPC visibility in crowded areas).
+    static constexpr bool kEnableNpcHelmetAttachments = false;
+    if (kEnableNpcHelmetAttachments &&
+        itDisplayData != displayDataMap_.end() &&
+        itDisplayData->second.extraDisplayId != 0) {
+        auto itExtra = humanoidExtraMap_.find(itDisplayData->second.extraDisplayId);
+        if (itExtra != humanoidExtraMap_.end()) {
+            const auto& extra = itExtra->second;
+            if (extra.equipDisplayId[0] != 0) { // Helm slot
+                auto itemDisplayDbc = assetManager->loadDBC("ItemDisplayInfo.dbc");
+                const auto* idiL2 = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
+                if (itemDisplayDbc) {
+                    int32_t helmIdx = itemDisplayDbc->findRecordById(extra.equipDisplayId[0]);
+                    if (helmIdx >= 0) {
+                        std::string helmModelName = itemDisplayDbc->getString(static_cast<uint32_t>(helmIdx), idiL2 ? (*idiL2)["LeftModel"] : 1);
+                        if (!helmModelName.empty()) {
+                            size_t dotPos = helmModelName.rfind('.');
+                            if (dotPos != std::string::npos) {
+                                helmModelName = helmModelName.substr(0, dotPos);
+                            }
+
+                            static const std::unordered_map<uint8_t, std::string> racePrefix = {
+                                {1, "Hu"}, {2, "Or"}, {3, "Dw"}, {4, "Ni"}, {5, "Sc"},
+                                {6, "Ta"}, {7, "Gn"}, {8, "Tr"}, {10, "Be"}, {11, "Dr"}
+                            };
+                            std::string genderSuffix = (extra.sexId == 0) ? "M" : "F";
+                            std::string raceSuffix;
+                            auto itRace = racePrefix.find(extra.raceId);
+                            if (itRace != racePrefix.end()) {
+                                raceSuffix = "_" + itRace->second + genderSuffix;
+                            }
+
+                            std::string helmPath;
+                            std::vector<uint8_t> helmData;
+                            if (!raceSuffix.empty()) {
+                                helmPath = "Item\\ObjectComponents\\Head\\" + helmModelName + raceSuffix + ".m2";
+                                helmData = assetManager->readFile(helmPath);
+                            }
+                            if (helmData.empty()) {
+                                helmPath = "Item\\ObjectComponents\\Head\\" + helmModelName + ".m2";
+                                helmData = assetManager->readFile(helmPath);
+                            }
+
+                            if (!helmData.empty()) {
+                                auto helmModel = pipeline::M2Loader::load(helmData);
+                                std::string skinPath = helmPath.substr(0, helmPath.size() - 3) + "00.skin";
+                                auto skinData = assetManager->readFile(skinPath);
+                                if (!skinData.empty() && helmModel.version >= 264) {
+                                    pipeline::M2Loader::loadSkin(skinData, helmModel);
+                                }
+
+                                if (helmModel.isValid()) {
+                                    uint32_t helmModelId = nextCreatureModelId_++;
+                                    std::string helmTexName = itemDisplayDbc->getString(static_cast<uint32_t>(helmIdx), idiL2 ? (*idiL2)["LeftModelTexture"] : 3);
+                                    std::string helmTexPath;
+                                    if (!helmTexName.empty()) {
+                                        if (!raceSuffix.empty()) {
+                                            std::string suffixedTex = "Item\\ObjectComponents\\Head\\" + helmTexName + raceSuffix + ".blp";
+                                            if (assetManager->fileExists(suffixedTex)) {
+                                                helmTexPath = suffixedTex;
+                                            }
+                                        }
+                                        if (helmTexPath.empty()) {
+                                            helmTexPath = "Item\\ObjectComponents\\Head\\" + helmTexName + ".blp";
+                                        }
+                                    }
+                                    // Attachment point 11 = Head
+                                    charRenderer->attachWeapon(instanceId, 11, helmModel, helmModelId, helmTexPath);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Try attaching NPC held weapons; if update fields are not ready yet,
+    // IN_GAME retry loop will attempt again shortly.
+    bool weaponsAttachedNow = tryAttachCreatureVirtualWeapons(guid, instanceId);
+
+    // Spawn in the correct pose. If the server marked this creature dead before
+    // the queued spawn was processed, start directly in death animation.
+    if (deadCreatureGuids_.count(guid)) {
+        charRenderer->playAnimation(instanceId, 1, false); // Death
+    } else {
+        charRenderer->playAnimation(instanceId, 0, true); // Idle
+    }
+    charRenderer->startFadeIn(instanceId, 0.5f);
+
+    // Track instance
+    creatureInstances_[guid] = instanceId;
+    creatureModelIds_[guid] = modelId;
+    creatureRenderPosCache_[guid] = renderPos;
+    if (weaponsAttachedNow) {
+        creatureWeaponsAttached_.insert(guid);
+        creatureWeaponAttachAttempts_.erase(guid);
+    } else {
+        creatureWeaponsAttached_.erase(guid);
+        creatureWeaponAttachAttempts_[guid] = 1;
+    }
+    LOG_DEBUG("Spawned creature: guid=0x", std::hex, guid, std::dec,
+             " displayId=", displayId, " at (", x, ", ", y, ", ", z, ")");
+}
+
+void Application::spawnOnlinePlayer(uint64_t guid,
+                                    uint8_t raceId,
+                                    uint8_t genderId,
+                                    uint32_t appearanceBytes,
+                                    uint8_t facialFeatures,
+                                    float x, float y, float z, float orientation) {
+    if (!renderer || !renderer->getCharacterRenderer() || !assetManager || !assetManager->isInitialized()) return;
+    if (playerInstances_.count(guid)) return;
+
+    // Skip local player — already spawned as the main character
+    if (gameHandler) {
+        uint64_t localGuid = gameHandler->getPlayerGuid();
+        uint64_t activeGuid = gameHandler->getActiveCharacterGuid();
+        if ((localGuid != 0 && guid == localGuid) ||
+            (activeGuid != 0 && guid == activeGuid) ||
+            (spawnedPlayerGuid_ != 0 && guid == spawnedPlayerGuid_)) {
+            return;
+        }
+    }
+    auto* charRenderer = renderer->getCharacterRenderer();
+
+    // Base geometry model: cache by (race, gender)
+    uint32_t cacheKey = (static_cast<uint32_t>(raceId) << 8) | static_cast<uint32_t>(genderId & 0xFF);
+    uint32_t modelId = 0;
+    auto itCache = playerModelCache_.find(cacheKey);
+    if (itCache != playerModelCache_.end()) {
+        modelId = itCache->second;
+    } else {
+        game::Race race = static_cast<game::Race>(raceId);
+        game::Gender gender = (genderId == 1) ? game::Gender::FEMALE : game::Gender::MALE;
+        std::string m2Path = game::getPlayerModelPath(race, gender);
+        if (m2Path.empty()) {
+            LOG_WARNING("spawnOnlinePlayer: unknown race/gender for guid 0x", std::hex, guid, std::dec,
+                        " race=", (int)raceId, " gender=", (int)genderId);
+            return;
+        }
+
+        // Parse modelDir/baseName for skin/anim loading
+        std::string modelDir;
+        std::string baseName;
+        {
+            size_t slash = m2Path.rfind('\\');
+            if (slash != std::string::npos) {
+                modelDir = m2Path.substr(0, slash + 1);
+                baseName = m2Path.substr(slash + 1);
+            } else {
+                baseName = m2Path;
+            }
+            size_t dot = baseName.rfind('.');
+            if (dot != std::string::npos) baseName = baseName.substr(0, dot);
+        }
+
+        auto m2Data = assetManager->readFile(m2Path);
+        if (m2Data.empty()) {
+            LOG_WARNING("spawnOnlinePlayer: failed to read M2: ", m2Path);
+            return;
+        }
+
+        pipeline::M2Model model = pipeline::M2Loader::load(m2Data);
+        if (!model.isValid() || model.vertices.empty()) {
+            LOG_WARNING("spawnOnlinePlayer: failed to parse M2: ", m2Path);
+            return;
+        }
+
+        // Skin file (only for WotLK M2s - vanilla has embedded skin)
+        std::string skinPath = modelDir + baseName + "00.skin";
+        auto skinData = assetManager->readFile(skinPath);
+        if (!skinData.empty() && model.version >= 264) {
+            pipeline::M2Loader::loadSkin(skinData, model);
+        }
+
+        // Load only core external animations (stand/walk/run) to avoid stalls
+        for (uint32_t si = 0; si < model.sequences.size(); si++) {
+            if (!(model.sequences[si].flags & 0x20)) {
+                uint32_t animId = model.sequences[si].id;
+                if (animId != 0 && animId != 4 && animId != 5) continue;
+                char animFileName[256];
+                snprintf(animFileName, sizeof(animFileName),
+                         "%s%s%04u-%02u.anim",
+                         modelDir.c_str(),
+                         baseName.c_str(),
+                         animId,
+                         model.sequences[si].variationIndex);
+                auto animData = assetManager->readFileOptional(animFileName);
+                if (!animData.empty()) {
+                    pipeline::M2Loader::loadAnimFile(m2Data, animData, si, model);
+                }
+            }
+        }
+
+        modelId = nextPlayerModelId_++;
+        if (!charRenderer->loadModel(model, modelId)) {
+            LOG_WARNING("spawnOnlinePlayer: failed to load model to GPU: ", m2Path);
+            return;
+        }
+
+        playerModelCache_[cacheKey] = modelId;
+    }
+
+    // Determine texture slots once per model
+    if (!playerTextureSlotsByModelId_.count(modelId)) {
+        PlayerTextureSlots slots;
+        if (const auto* md = charRenderer->getModelData(modelId)) {
+            for (size_t ti = 0; ti < md->textures.size(); ti++) {
+                uint32_t t = md->textures[ti].type;
+                if (t == 1 && slots.skin < 0) slots.skin = (int)ti;
+                else if (t == 6 && slots.hair < 0) slots.hair = (int)ti;
+                else if (t == 8 && slots.underwear < 0) slots.underwear = (int)ti;
+            }
+        }
+        playerTextureSlotsByModelId_[modelId] = slots;
+    }
+
+    // Create instance at server position
+    glm::vec3 renderPos = core::coords::canonicalToRender(glm::vec3(x, y, z));
+    float renderYaw = orientation + glm::radians(90.0f);
+    uint32_t instanceId = charRenderer->createInstance(modelId, renderPos, glm::vec3(0.0f, 0.0f, renderYaw), 1.0f);
+    if (instanceId == 0) return;
+
+    // Resolve skin/hair texture paths via CharSections, then apply as per-instance overrides
+    const char* raceFolderName = "Human";
+    switch (static_cast<game::Race>(raceId)) {
+        case game::Race::HUMAN: raceFolderName = "Human"; break;
+        case game::Race::ORC: raceFolderName = "Orc"; break;
+        case game::Race::DWARF: raceFolderName = "Dwarf"; break;
+        case game::Race::NIGHT_ELF: raceFolderName = "NightElf"; break;
+        case game::Race::UNDEAD: raceFolderName = "Scourge"; break;
+        case game::Race::TAUREN: raceFolderName = "Tauren"; break;
+        case game::Race::GNOME: raceFolderName = "Gnome"; break;
+        case game::Race::TROLL: raceFolderName = "Troll"; break;
+        case game::Race::BLOOD_ELF: raceFolderName = "BloodElf"; break;
+        case game::Race::DRAENEI: raceFolderName = "Draenei"; break;
+        default: break;
+    }
+    const char* genderFolder = (genderId == 1) ? "Female" : "Male";
+    std::string raceGender = std::string(raceFolderName) + genderFolder;
+    std::string bodySkinPath = std::string("Character\\") + raceFolderName + "\\" + genderFolder + "\\" + raceGender + "Skin00_00.blp";
+    std::string pelvisPath = std::string("Character\\") + raceFolderName + "\\" + genderFolder + "\\" + raceGender + "NakedPelvisSkin00_00.blp";
+    std::vector<std::string> underwearPaths;
+    std::string hairTexturePath;
+    std::string faceLowerPath;
+    std::string faceUpperPath;
+
+    uint8_t skinId = appearanceBytes & 0xFF;
+    uint8_t faceId = (appearanceBytes >> 8) & 0xFF;
+    uint8_t hairStyleId = (appearanceBytes >> 16) & 0xFF;
+    uint8_t hairColorId = (appearanceBytes >> 24) & 0xFF;
+
+    if (auto charSectionsDbc = assetManager->loadDBC("CharSections.dbc"); charSectionsDbc && charSectionsDbc->isLoaded()) {
+        const auto* csL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CharSections") : nullptr;
+        uint32_t targetRaceId = raceId;
+        uint32_t targetSexId = genderId;
+        const uint32_t csTex1 = csL ? (*csL)["Texture1"] : 6;
+
+        bool foundSkin = false;
+        bool foundUnderwear = false;
+        bool foundHair = false;
+        bool foundFaceLower = false;
+
+        for (uint32_t r = 0; r < charSectionsDbc->getRecordCount(); r++) {
+            uint32_t rRace = charSectionsDbc->getUInt32(r, csL ? (*csL)["RaceID"] : 1);
+            uint32_t rSex = charSectionsDbc->getUInt32(r, csL ? (*csL)["SexID"] : 2);
+            uint32_t baseSection = charSectionsDbc->getUInt32(r, csL ? (*csL)["BaseSection"] : 3);
+            uint32_t variationIndex = charSectionsDbc->getUInt32(r, csL ? (*csL)["VariationIndex"] : 4);
+            uint32_t colorIndex = charSectionsDbc->getUInt32(r, csL ? (*csL)["ColorIndex"] : 5);
+
+            if (rRace != targetRaceId || rSex != targetSexId) continue;
+
+            if (baseSection == 0 && !foundSkin && colorIndex == skinId) {
+                std::string tex1 = charSectionsDbc->getString(r, csTex1);
+                if (!tex1.empty()) { bodySkinPath = tex1; foundSkin = true; }
+            } else if (baseSection == 3 && !foundHair &&
+                       variationIndex == hairStyleId && colorIndex == hairColorId) {
+                hairTexturePath = charSectionsDbc->getString(r, csTex1);
+                if (!hairTexturePath.empty()) foundHair = true;
+            } else if (baseSection == 4 && !foundUnderwear && colorIndex == skinId) {
+                for (uint32_t f = csTex1; f <= csTex1 + 2; f++) {
+                    std::string tex = charSectionsDbc->getString(r, f);
+                    if (!tex.empty()) underwearPaths.push_back(tex);
+                }
+                foundUnderwear = true;
+            } else if (baseSection == 1 && !foundFaceLower &&
+                       variationIndex == faceId && colorIndex == skinId) {
+                std::string tex1 = charSectionsDbc->getString(r, csTex1);
+                std::string tex2 = charSectionsDbc->getString(r, csTex1 + 1);
+                if (!tex1.empty()) faceLowerPath = tex1;
+                if (!tex2.empty()) faceUpperPath = tex2;
+                foundFaceLower = true;
+            }
+
+            if (foundSkin && foundUnderwear && foundHair && foundFaceLower) break;
+        }
+    }
+
+    // Composite base skin + face + underwear overlays
+    rendering::VkTexture* compositeTex = nullptr;
+    {
+        std::vector<std::string> layers;
+        layers.push_back(bodySkinPath);
+        if (!faceLowerPath.empty()) layers.push_back(faceLowerPath);
+        if (!faceUpperPath.empty()) layers.push_back(faceUpperPath);
+        for (const auto& up : underwearPaths) layers.push_back(up);
+        if (layers.size() > 1) {
+            compositeTex = charRenderer->compositeTextures(layers);
+        } else {
+            compositeTex = charRenderer->loadTexture(bodySkinPath);
+        }
+    }
+
+    rendering::VkTexture* hairTex = nullptr;
+    if (!hairTexturePath.empty()) {
+        hairTex = charRenderer->loadTexture(hairTexturePath);
+    }
+    rendering::VkTexture* underwearTex = nullptr;
+    if (!underwearPaths.empty()) underwearTex = charRenderer->loadTexture(underwearPaths[0]);
+    else underwearTex = charRenderer->loadTexture(pelvisPath);
+
+    const PlayerTextureSlots& slots = playerTextureSlotsByModelId_[modelId];
+    if (slots.skin >= 0 && compositeTex) {
+        charRenderer->setTextureSlotOverride(instanceId, static_cast<uint16_t>(slots.skin), compositeTex);
+    }
+    if (slots.hair >= 0 && hairTex) {
+        charRenderer->setTextureSlotOverride(instanceId, static_cast<uint16_t>(slots.hair), hairTex);
+    }
+    if (slots.underwear >= 0 && underwearTex) {
+        charRenderer->setTextureSlotOverride(instanceId, static_cast<uint16_t>(slots.underwear), underwearTex);
+    }
+
+    // Geosets: body + hair/facial hair selections
+    std::unordered_set<uint16_t> activeGeosets;
+    // Body parts (group 0: IDs 0-99, some models use up to 27)
+    for (uint16_t i = 0; i <= 99; i++) activeGeosets.insert(i);
+    activeGeosets.insert(static_cast<uint16_t>(100 + hairStyleId + 1));
+    activeGeosets.insert(static_cast<uint16_t>(200 + facialFeatures + 1));
+    activeGeosets.insert(401);   // Bare forearms (no gloves) — group 4
+    activeGeosets.insert(502);   // Bare shins (no boots) — group 5
+    activeGeosets.insert(702);   // Ears
+    activeGeosets.insert(801);   // Bare wrists (no sleeves) — group 8
+    activeGeosets.insert(902);   // Kneepads — group 9
+    activeGeosets.insert(1301);  // Bare legs — group 13
+    activeGeosets.insert(1502);  // No cloak — group 15
+    activeGeosets.insert(2002);  // Bare feet — group 20
+    charRenderer->setActiveGeosets(instanceId, activeGeosets);
+
+    charRenderer->playAnimation(instanceId, 0, true);
+    playerInstances_[guid] = instanceId;
+
+    OnlinePlayerAppearanceState st;
+    st.instanceId = instanceId;
+    st.modelId = modelId;
+    st.raceId = raceId;
+    st.genderId = genderId;
+    st.appearanceBytes = appearanceBytes;
+    st.facialFeatures = facialFeatures;
+    st.bodySkinPath = bodySkinPath;
+    // Include face textures so compositeWithRegions can rebuild the full base
+    if (!faceLowerPath.empty()) st.underwearPaths.push_back(faceLowerPath);
+    if (!faceUpperPath.empty()) st.underwearPaths.push_back(faceUpperPath);
+    for (const auto& up : underwearPaths) st.underwearPaths.push_back(up);
+    onlinePlayerAppearance_[guid] = std::move(st);
+}
+
+void Application::setOnlinePlayerEquipment(uint64_t guid,
+                                          const std::array<uint32_t, 19>& displayInfoIds,
+                                          const std::array<uint8_t, 19>& inventoryTypes) {
+    if (!renderer || !renderer->getCharacterRenderer() || !assetManager || !assetManager->isInitialized()) return;
+
+    // Skip local player — equipment handled by GameScreen::updateCharacterGeosets/Textures
+    // via consumeOnlineEquipmentDirty(), which fires on the same server update.
+    if (gameHandler) {
+        uint64_t localGuid = gameHandler->getPlayerGuid();
+        if (localGuid != 0 && guid == localGuid) return;
+    }
+
+    // If the player isn't spawned yet, store equipment until spawn.
+    if (!playerInstances_.count(guid) || !onlinePlayerAppearance_.count(guid)) {
+        pendingOnlinePlayerEquipment_[guid] = {displayInfoIds, inventoryTypes};
+        return;
+    }
+
+    auto it = onlinePlayerAppearance_.find(guid);
+    if (it == onlinePlayerAppearance_.end()) return;
+    const OnlinePlayerAppearanceState& st = it->second;
+
+    auto* charRenderer = renderer->getCharacterRenderer();
+    if (!charRenderer) return;
+    if (st.instanceId == 0 || st.modelId == 0) return;
+
+    if (st.bodySkinPath.empty()) return;
+
+    auto displayInfoDbc = assetManager->loadDBC("ItemDisplayInfo.dbc");
+    if (!displayInfoDbc) return;
+    const auto* idiL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
+
+    auto getGeosetGroup = [&](uint32_t displayInfoId, uint32_t fieldIdx) -> uint32_t {
+        if (displayInfoId == 0) return 0;
+        int32_t recIdx = displayInfoDbc->findRecordById(displayInfoId);
+        if (recIdx < 0) return 0;
+        return displayInfoDbc->getUInt32(static_cast<uint32_t>(recIdx), fieldIdx);
+    };
+
+    auto findDisplayIdByInvType = [&](std::initializer_list<uint8_t> types) -> uint32_t {
+        for (int s = 0; s < 19; s++) {
+            uint8_t inv = inventoryTypes[s];
+            if (inv == 0 || displayInfoIds[s] == 0) continue;
+            for (uint8_t t : types) {
+                if (inv == t) return displayInfoIds[s];
+            }
+        }
+        return 0;
+    };
+
+    auto hasInvType = [&](std::initializer_list<uint8_t> types) -> bool {
+        for (int s = 0; s < 19; s++) {
+            uint8_t inv = inventoryTypes[s];
+            if (inv == 0) continue;
+            for (uint8_t t : types) {
+                if (inv == t) return true;
+            }
+        }
+        return false;
+    };
+
+    // --- Geosets ---
+    std::unordered_set<uint16_t> geosets;
+    // Body parts (group 0: IDs 0-99, some models use up to 27)
+    for (uint16_t i = 0; i <= 99; i++) geosets.insert(i);
+
+    uint8_t hairStyleId = static_cast<uint8_t>((st.appearanceBytes >> 16) & 0xFF);
+    geosets.insert(static_cast<uint16_t>(100 + hairStyleId + 1));
+    geosets.insert(static_cast<uint16_t>(200 + st.facialFeatures + 1));
+    geosets.insert(401);   // Body joint patches (knees)
+    geosets.insert(402);   // Body joint patches (elbows)
+    geosets.insert(701);   // Ears
+    geosets.insert(902);   // Kneepads
+    geosets.insert(2002);  // Bare feet mesh
+
+    const uint32_t geosetGroup1Field = idiL ? (*idiL)["GeosetGroup1"] : 7;
+    const uint32_t geosetGroup3Field = idiL ? (*idiL)["GeosetGroup3"] : 9;
+
+    // Chest/Shirt/Robe (invType 4,5,20)
+    {
+        uint32_t did = findDisplayIdByInvType({4, 5, 20});
+        uint32_t gg1 = getGeosetGroup(did, geosetGroup1Field);
+        geosets.insert(static_cast<uint16_t>(gg1 > 0 ? 501 + gg1 : 501));
+
+        uint32_t gg3 = getGeosetGroup(did, geosetGroup3Field);
+        if (gg3 > 0) geosets.insert(static_cast<uint16_t>(1301 + gg3));
+    }
+
+    // Legs (invType 7)
+    {
+        uint32_t did = findDisplayIdByInvType({7});
+        uint32_t gg1 = getGeosetGroup(did, geosetGroup1Field);
+        if (geosets.count(1302) == 0 && geosets.count(1303) == 0) {
+            geosets.insert(static_cast<uint16_t>(gg1 > 0 ? 1301 + gg1 : 1301));
+        }
+    }
+
+    // Feet (invType 8): 401/402 are body patches (always on), 403+ are boot meshes
+    {
+        uint32_t did = findDisplayIdByInvType({8});
+        uint32_t gg1 = getGeosetGroup(did, geosetGroup1Field);
+        if (gg1 > 0) geosets.insert(static_cast<uint16_t>(402 + gg1));
+    }
+
+    // Hands (invType 10)
+    {
+        uint32_t did = findDisplayIdByInvType({10});
+        uint32_t gg1 = getGeosetGroup(did, geosetGroup1Field);
+        geosets.insert(static_cast<uint16_t>(gg1 > 0 ? 301 + gg1 : 301));
+    }
+
+    // Back/Cloak (invType 16)
+    geosets.insert(hasInvType({16}) ? 1502 : 1501);
+    // Tabard (invType 19)
+    if (hasInvType({19})) geosets.insert(1201);
+
+    charRenderer->setActiveGeosets(st.instanceId, geosets);
+
+    // --- Textures (skin atlas compositing) ---
+    static const char* componentDirs[] = {
+        "ArmUpperTexture",
+        "ArmLowerTexture",
+        "HandTexture",
+        "TorsoUpperTexture",
+        "TorsoLowerTexture",
+        "LegUpperTexture",
+        "LegLowerTexture",
+        "FootTexture",
+    };
+
+    // Texture component region fields from DBC layout
+    // Binary DBC (23 fields) has textures at 14+
+    const uint32_t texRegionFields[8] = {
+        idiL ? (*idiL)["TextureArmUpper"]  : 14u,
+        idiL ? (*idiL)["TextureArmLower"]  : 15u,
+        idiL ? (*idiL)["TextureHand"]      : 16u,
+        idiL ? (*idiL)["TextureTorsoUpper"]: 17u,
+        idiL ? (*idiL)["TextureTorsoLower"]: 18u,
+        idiL ? (*idiL)["TextureLegUpper"]  : 19u,
+        idiL ? (*idiL)["TextureLegLower"]  : 20u,
+        idiL ? (*idiL)["TextureFoot"]      : 21u,
+    };
+
+    std::vector<std::pair<int, std::string>> regionLayers;
+    const bool isFemale = (st.genderId == 1);
+
+    for (int s = 0; s < 19; s++) {
+        uint32_t did = displayInfoIds[s];
+        if (did == 0) continue;
+        int32_t recIdx = displayInfoDbc->findRecordById(did);
+        if (recIdx < 0) continue;
+
+        for (int region = 0; region < 8; region++) {
+            std::string texName = displayInfoDbc->getString(
+                static_cast<uint32_t>(recIdx), texRegionFields[region]);
+            if (texName.empty()) continue;
+
+            std::string base = "Item\\TextureComponents\\" + std::string(componentDirs[region]) + "\\" + texName;
+            std::string genderPath = base + (isFemale ? "_F.blp" : "_M.blp");
+            std::string unisexPath = base + "_U.blp";
+            std::string fullPath;
+            if (assetManager->fileExists(genderPath)) fullPath = genderPath;
+            else if (assetManager->fileExists(unisexPath)) fullPath = unisexPath;
+            else fullPath = base + ".blp";
+
+            regionLayers.emplace_back(region, fullPath);
+        }
+    }
+
+    const auto slotsIt = playerTextureSlotsByModelId_.find(st.modelId);
+    if (slotsIt == playerTextureSlotsByModelId_.end()) return;
+    const PlayerTextureSlots& slots = slotsIt->second;
+    if (slots.skin < 0) return;
+
+    rendering::VkTexture* newTex = charRenderer->compositeWithRegions(st.bodySkinPath, st.underwearPaths, regionLayers);
+    if (newTex) {
+        charRenderer->setTextureSlotOverride(st.instanceId, static_cast<uint16_t>(slots.skin), newTex);
+    }
+}
+
+void Application::despawnOnlinePlayer(uint64_t guid) {
+    if (!renderer || !renderer->getCharacterRenderer()) return;
+    auto it = playerInstances_.find(guid);
+    if (it == playerInstances_.end()) return;
+    renderer->getCharacterRenderer()->removeInstance(it->second);
+    playerInstances_.erase(it);
+    onlinePlayerAppearance_.erase(guid);
+    pendingOnlinePlayerEquipment_.erase(guid);
+}
+
+void Application::spawnOnlineGameObject(uint64_t guid, uint32_t entry, uint32_t displayId, float x, float y, float z, float orientation) {
+    if (!renderer || !assetManager) return;
+
+    if (!gameObjectLookupsBuilt_) {
+        buildGameObjectDisplayLookups();
+    }
+    if (!gameObjectLookupsBuilt_) return;
+
+    if (gameObjectInstances_.count(guid)) {
+        // Already have a render instance — update its position (e.g. transport re-creation)
+        auto& info = gameObjectInstances_[guid];
+        glm::vec3 renderPos = core::coords::canonicalToRender(glm::vec3(x, y, z));
+        LOG_DEBUG("GameObject position update: displayId=", displayId, " guid=0x", std::hex, guid, std::dec,
+                 " pos=(", x, ", ", y, ", ", z, ")");
+        if (renderer) {
+            if (info.isWmo) {
+                if (auto* wr = renderer->getWMORenderer()) {
+                    glm::mat4 transform(1.0f);
+                    transform = glm::translate(transform, renderPos);
+                    transform = glm::rotate(transform, orientation, glm::vec3(0, 0, 1));
+                    wr->setInstanceTransform(info.instanceId, transform);
+                }
+            } else {
+                if (auto* mr = renderer->getM2Renderer()) {
+                    glm::mat4 transform(1.0f);
+                    transform = glm::translate(transform, renderPos);
+                    mr->setInstanceTransform(info.instanceId, transform);
+                }
+            }
+        }
+        return;
+    }
+
+    std::string modelPath;
+
+        // Override model path for transports with wrong displayIds (preloaded transports)
+        // Check if this GUID is a known transport
+        bool isTransport = gameHandler && gameHandler->isTransportGuid(guid);
+        if (isTransport) {
+            // Map common transport displayIds to correct WMO paths
+            // NOTE: displayIds 455/462 are elevators in Thunder Bluff and should NOT be forced to ships.
+            // Keep ship/zeppelin overrides entry-driven where possible.
+            // DisplayIds 807, 808 = Zeppelins
+            // DisplayIds 2454, 1587 = Special ships/icebreakers
+            if (entry == 20808 || entry == 176231 || entry == 176310) {
+                modelPath = "World\\wmo\\transports\\transport_ship\\transportship.wmo";
+                LOG_INFO("Overriding transport entry/display ", entry, "/", displayId, " → transportship.wmo");
+            } else if (displayId == 807 || displayId == 808 || displayId == 175080 || displayId == 176495 || displayId == 164871) {
+                modelPath = "World\\wmo\\transports\\transport_zeppelin\\transport_zeppelin.wmo";
+                LOG_INFO("Overriding transport displayId ", displayId, " → transport_zeppelin.wmo");
+            } else if (displayId == 1587) {
+                modelPath = "World\\wmo\\transports\\transport_horde_zeppelin\\Transport_Horde_Zeppelin.wmo";
+                LOG_INFO("Overriding transport displayId ", displayId, " → Transport_Horde_Zeppelin.wmo");
+            } else if (displayId == 2454 || displayId == 181688 || displayId == 190536) {
+                modelPath = "World\\wmo\\transports\\icebreaker\\Transport_Icebreaker_ship.wmo";
+                LOG_INFO("Overriding transport displayId ", displayId, " → Transport_Icebreaker_ship.wmo");
+            } else if (displayId == 3831) {
+                // Deeprun Tram car
+                modelPath = "World\\Generic\\Gnome\\Passive Doodads\\Subway\\SubwayCar.m2";
+                LOG_WARNING("Overriding transport displayId ", displayId, " → SubwayCar.m2");
+            }
+        }
+
+    // Fallback to normal displayId lookup if not a transport or no override matched
+    if (modelPath.empty()) {
+        modelPath = getGameObjectModelPathForDisplayId(displayId);
+    }
+
+    if (modelPath.empty()) {
+        LOG_WARNING("No model path for gameobject displayId ", displayId, " (guid 0x", std::hex, guid, std::dec, ")");
+        return;
+    }
+
+    // Log spawns to help debug duplicate objects (e.g., cathedral issue)
+    LOG_DEBUG("GameObject spawn: displayId=", displayId, " guid=0x", std::hex, guid, std::dec,
+             " model=", modelPath, " pos=(", x, ", ", y, ", ", z, ")");
+
+    std::string lowerPath = modelPath;
+    std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(),
+                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+    bool isWmo = lowerPath.size() >= 4 && lowerPath.substr(lowerPath.size() - 4) == ".wmo";
+
+    glm::vec3 renderPos = core::coords::canonicalToRender(glm::vec3(x, y, z));
+    const float renderYawWmo = orientation;
+    // M2 game objects: model default faces +renderX. renderYaw = canonical + 90° = server_yaw
+    // (same offset as creature/character renderer so all M2 models face consistently)
+    const float renderYawM2go = orientation + glm::radians(90.0f);
+
+    bool loadedAsWmo = false;
+    if (isWmo) {
+        auto* wmoRenderer = renderer->getWMORenderer();
+        if (!wmoRenderer) return;
+
+        uint32_t modelId = 0;
+        auto itCache = gameObjectDisplayIdWmoCache_.find(displayId);
+        if (itCache != gameObjectDisplayIdWmoCache_.end()) {
+            modelId = itCache->second;
+            loadedAsWmo = true;
+        } else {
+            auto wmoData = assetManager->readFile(modelPath);
+            if (!wmoData.empty()) {
+                pipeline::WMOModel wmoModel = pipeline::WMOLoader::load(wmoData);
+                LOG_DEBUG("Gameobject WMO root loaded: ", modelPath, " nGroups=", wmoModel.nGroups);
+                int loadedGroups = 0;
+                if (wmoModel.nGroups > 0) {
+                    std::string basePath = modelPath;
+                    std::string extension;
+                    if (basePath.size() > 4) {
+                        extension = basePath.substr(basePath.size() - 4);
+                        std::string extLower = extension;
+                        for (char& c : extLower) c = static_cast<char>(std::tolower(c));
+                        if (extLower == ".wmo") {
+                            basePath = basePath.substr(0, basePath.size() - 4);
+                        }
+                    }
+
+                    for (uint32_t gi = 0; gi < wmoModel.nGroups; gi++) {
+                        char groupSuffix[16];
+                        snprintf(groupSuffix, sizeof(groupSuffix), "_%03u%s", gi, extension.c_str());
+                        std::string groupPath = basePath + groupSuffix;
+                        std::vector<uint8_t> groupData = assetManager->readFile(groupPath);
+                        if (groupData.empty()) {
+                            snprintf(groupSuffix, sizeof(groupSuffix), "_%03u.wmo", gi);
+                            groupData = assetManager->readFile(basePath + groupSuffix);
+                        }
+                        if (groupData.empty()) {
+                            snprintf(groupSuffix, sizeof(groupSuffix), "_%03u.WMO", gi);
+                            groupData = assetManager->readFile(basePath + groupSuffix);
+                        }
+                        if (!groupData.empty()) {
+                            pipeline::WMOLoader::loadGroup(groupData, wmoModel, gi);
+                            loadedGroups++;
+                        } else {
+                            LOG_WARNING("  Failed to load WMO group ", gi, " for: ", basePath);
+                        }
+                    }
+                }
+
+                if (loadedGroups > 0 || wmoModel.nGroups == 0) {
+                    modelId = nextGameObjectWmoModelId_++;
+                    if (wmoRenderer->loadModel(wmoModel, modelId)) {
+                        gameObjectDisplayIdWmoCache_[displayId] = modelId;
+                        loadedAsWmo = true;
+                    } else {
+                        LOG_WARNING("Failed to load gameobject WMO model: ", modelPath);
+                    }
+                } else {
+                    LOG_WARNING("No WMO groups loaded for gameobject: ", modelPath,
+                                " — falling back to M2");
+                }
+            } else {
+                LOG_WARNING("Failed to read gameobject WMO: ", modelPath, " — falling back to M2");
+            }
+        }
+
+        if (loadedAsWmo) {
+            uint32_t instanceId = wmoRenderer->createInstance(modelId, renderPos,
+                glm::vec3(0.0f, 0.0f, renderYawWmo), 1.0f);
+            if (instanceId == 0) {
+                LOG_WARNING("Failed to create gameobject WMO instance for guid 0x", std::hex, guid, std::dec);
+                return;
+            }
+
+            gameObjectInstances_[guid] = {modelId, instanceId, true};
+            LOG_DEBUG("Spawned gameobject WMO: guid=0x", std::hex, guid, std::dec,
+                     " displayId=", displayId, " at (", x, ", ", y, ", ", z, ")");
+
+            // Spawn transport WMO doodads (chairs, furniture, etc.) as child M2 instances
+            bool isTransport = false;
+            if (gameHandler) {
+                std::string lowerModelPath = modelPath;
+                std::transform(lowerModelPath.begin(), lowerModelPath.end(), lowerModelPath.begin(),
+                               [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+                isTransport = (lowerModelPath.find("transport") != std::string::npos);
+            }
+
+            auto* m2Renderer = renderer->getM2Renderer();
+            if (m2Renderer && isTransport) {
+                const auto* doodadTemplates = wmoRenderer->getDoodadTemplates(modelId);
+                if (doodadTemplates && !doodadTemplates->empty()) {
+                    constexpr size_t kMaxTransportDoodads = 192;
+                    const size_t doodadBudget = std::min(doodadTemplates->size(), kMaxTransportDoodads);
+                    LOG_DEBUG("Queueing ", doodadBudget, "/", doodadTemplates->size(),
+                             " transport doodads for WMO instance ", instanceId);
+                    pendingTransportDoodadBatches_.push_back(PendingTransportDoodadBatch{
+                        guid,
+                        modelId,
+                        instanceId,
+                        0,
+                        doodadBudget,
+                        0,
+                        x, y, z,
+                        orientation
+                    });
+                } else {
+                LOG_DEBUG("Transport WMO has no doodads or templates not available");
+            }
+            }
+
+            // Transport GameObjects are not always named "transport" in their WMO path
+            // (e.g. elevators/lifts). If the server marks it as a transport, always
+            // notify so TransportManager can animate/carry passengers.
+            bool isTG = gameHandler && gameHandler->isTransportGuid(guid);
+            LOG_WARNING("WMO GO spawned: guid=0x", std::hex, guid, std::dec,
+                       " entry=", entry, " displayId=", displayId,
+                       " isTransport=", isTG,
+                       " pos=(", x, ", ", y, ", ", z, ")");
+            if (isTG) {
+                gameHandler->notifyTransportSpawned(guid, entry, displayId, x, y, z, orientation);
+            }
+
+            return;
+        }
+
+        // WMO failed — fall through to try as M2
+        // Convert .wmo path to .m2 for fallback
+        modelPath = modelPath.substr(0, modelPath.size() - 4) + ".m2";
+    }
+
+    {
+        auto* m2Renderer = renderer->getM2Renderer();
+        if (!m2Renderer) return;
+
+        uint32_t modelId = 0;
+        auto itCache = gameObjectDisplayIdModelCache_.find(displayId);
+        if (itCache != gameObjectDisplayIdModelCache_.end()) {
+            modelId = itCache->second;
+            if (!m2Renderer->hasModel(modelId)) {
+                LOG_WARNING("GO M2 cache hit but model gone: displayId=", displayId,
+                            " modelId=", modelId, " path=", modelPath,
+                            " — reloading");
+                gameObjectDisplayIdModelCache_.erase(itCache);
+                itCache = gameObjectDisplayIdModelCache_.end();
+            }
+        }
+        if (itCache == gameObjectDisplayIdModelCache_.end()) {
+            modelId = nextGameObjectModelId_++;
+
+            auto m2Data = assetManager->readFile(modelPath);
+            if (m2Data.empty()) {
+                LOG_WARNING("Failed to read gameobject M2: ", modelPath);
+                return;
+            }
+
+            pipeline::M2Model model = pipeline::M2Loader::load(m2Data);
+            if (model.vertices.empty()) {
+                LOG_WARNING("Failed to parse gameobject M2: ", modelPath);
+                return;
+            }
+
+            std::string skinPath = modelPath.substr(0, modelPath.size() - 3) + "00.skin";
+            auto skinData = assetManager->readFile(skinPath);
+            if (!skinData.empty() && model.version >= 264) {
+                pipeline::M2Loader::loadSkin(skinData, model);
+            }
+
+            if (!m2Renderer->loadModel(model, modelId)) {
+                LOG_WARNING("Failed to load gameobject model: ", modelPath);
+                return;
+            }
+
+            gameObjectDisplayIdModelCache_[displayId] = modelId;
+        }
+
+        uint32_t instanceId = m2Renderer->createInstance(modelId, renderPos,
+            glm::vec3(0.0f, 0.0f, renderYawM2go), 1.0f);
+        if (instanceId == 0) {
+            LOG_WARNING("Failed to create gameobject instance for guid 0x", std::hex, guid, std::dec);
+            return;
+        }
+
+        // Freeze animation for static gameobjects, but let portals/effects/transports animate
+        bool isTransportGO = gameHandler && gameHandler->isTransportGuid(guid);
+        std::string lowerPath = modelPath;
+        std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(), ::tolower);
+        bool isAnimatedEffect = (lowerPath.find("instanceportal") != std::string::npos ||
+                                  lowerPath.find("instancenewportal") != std::string::npos ||
+                                  lowerPath.find("portalfx") != std::string::npos ||
+                                  lowerPath.find("spellportal") != std::string::npos);
+        if (!isAnimatedEffect && !isTransportGO) {
+            m2Renderer->setInstanceAnimationFrozen(instanceId, true);
+        }
+
+        gameObjectInstances_[guid] = {modelId, instanceId, false};
+
+        // Notify transport system for M2 transports (e.g. Deeprun Tram cars)
+        if (gameHandler && gameHandler->isTransportGuid(guid)) {
+            LOG_WARNING("M2 transport spawned: guid=0x", std::hex, guid, std::dec,
+                       " entry=", entry, " displayId=", displayId,
+                       " instanceId=", instanceId);
+            gameHandler->notifyTransportSpawned(guid, entry, displayId, x, y, z, orientation);
+        }
+    }
+
+    LOG_DEBUG("Spawned gameobject: guid=0x", std::hex, guid, std::dec,
+             " displayId=", displayId, " at (", x, ", ", y, ", ", z, ")");
+}
+
+void Application::processAsyncCreatureResults(bool unlimited) {
+    // Check completed async model loads and finalize on main thread (GPU upload + instance creation).
+    // Limit GPU model uploads per frame to avoid spikes, but always drain cheap bookkeeping.
+    // In unlimited mode (load screen), process all pending uploads without cap.
+    static constexpr int kMaxModelUploadsPerFrame = 1;
+    int modelUploads = 0;
+
+    for (auto it = asyncCreatureLoads_.begin(); it != asyncCreatureLoads_.end(); ) {
+        if (!it->future.valid() ||
+            it->future.wait_for(std::chrono::milliseconds(0)) != std::future_status::ready) {
+            ++it;
+            continue;
+        }
+
+        // Peek: if this result needs a NEW model upload (not cached) and we've hit
+        // the upload budget, defer to next frame without consuming the future.
+        if (!unlimited && modelUploads >= kMaxModelUploadsPerFrame) {
+            break;
+        }
+
+        auto result = it->future.get();
+        it = asyncCreatureLoads_.erase(it);
+
+        if (result.permanent_failure) {
+            nonRenderableCreatureDisplayIds_.insert(result.displayId);
+            creaturePermanentFailureGuids_.insert(result.guid);
+            pendingCreatureSpawnGuids_.erase(result.guid);
+            creatureSpawnRetryCounts_.erase(result.guid);
+            continue;
+        }
+        if (!result.valid || !result.model) {
+            pendingCreatureSpawnGuids_.erase(result.guid);
+            creatureSpawnRetryCounts_.erase(result.guid);
+            continue;
+        }
+
+        // Model parsed on background thread — upload to GPU on main thread.
+        auto* charRenderer = renderer ? renderer->getCharacterRenderer() : nullptr;
+        if (!charRenderer) {
+            pendingCreatureSpawnGuids_.erase(result.guid);
+            continue;
+        }
+
+        // Upload model to GPU (must happen on main thread)
+        // Use pre-decoded BLP cache to skip main-thread texture decode
+        auto uploadStart = std::chrono::steady_clock::now();
+        charRenderer->setPredecodedBLPCache(&result.predecodedTextures);
+        if (!charRenderer->loadModel(*result.model, result.modelId)) {
+            charRenderer->setPredecodedBLPCache(nullptr);
+            nonRenderableCreatureDisplayIds_.insert(result.displayId);
+            creaturePermanentFailureGuids_.insert(result.guid);
+            pendingCreatureSpawnGuids_.erase(result.guid);
+            creatureSpawnRetryCounts_.erase(result.guid);
+            continue;
+        }
+        charRenderer->setPredecodedBLPCache(nullptr);
+        {
+            auto uploadEnd = std::chrono::steady_clock::now();
+            float uploadMs = std::chrono::duration<float, std::milli>(uploadEnd - uploadStart).count();
+            if (uploadMs > 100.0f) {
+                LOG_WARNING("charRenderer->loadModel took ", uploadMs, "ms displayId=", result.displayId,
+                            " preDecoded=", result.predecodedTextures.size());
+            }
+        }
+        // Save remaining pre-decoded textures (display skins) for spawnOnlineCreature
+        if (!result.predecodedTextures.empty()) {
+            displayIdPredecodedTextures_[result.displayId] = std::move(result.predecodedTextures);
+        }
+        displayIdModelCache_[result.displayId] = result.modelId;
+        modelUploads++;
+
+        pendingCreatureSpawnGuids_.erase(result.guid);
+        creatureSpawnRetryCounts_.erase(result.guid);
+
+        // Re-queue as a normal pending spawn — model is now cached, so sync spawn is fast
+        // (only creates instance + applies textures, no file I/O).
+        if (!creatureInstances_.count(result.guid) &&
+            !creaturePermanentFailureGuids_.count(result.guid)) {
+            PendingCreatureSpawn s{};
+            s.guid = result.guid;
+            s.displayId = result.displayId;
+            s.x = result.x;
+            s.y = result.y;
+            s.z = result.z;
+            s.orientation = result.orientation;
+            pendingCreatureSpawns_.push_back(s);
+            pendingCreatureSpawnGuids_.insert(result.guid);
+        }
+    }
+}
+
+void Application::processAsyncNpcCompositeResults() {
+    auto* charRenderer = renderer ? renderer->getCharacterRenderer() : nullptr;
+    if (!charRenderer) return;
+
+    for (auto it = asyncNpcCompositeLoads_.begin(); it != asyncNpcCompositeLoads_.end(); ) {
+        if (!it->future.valid() ||
+            it->future.wait_for(std::chrono::milliseconds(0)) != std::future_status::ready) {
+            ++it;
+            continue;
+        }
+        auto result = it->future.get();
+        it = asyncNpcCompositeLoads_.erase(it);
+
+        const auto& info = result.info;
+
+        // Set pre-decoded cache so texture loads skip synchronous BLP decode
+        charRenderer->setPredecodedBLPCache(&result.predecodedTextures);
+
+        // --- Apply skin to type-1 slots ---
+        rendering::VkTexture* skinTex = nullptr;
+
+        if (info.hasBakedSkin) {
+            // Baked skin: load from pre-decoded cache
+            skinTex = charRenderer->loadTexture(info.bakedSkinPath);
+        }
+
+        if (info.hasComposite) {
+            // Composite with face/underwear/equipment regions on top of base skin
+            rendering::VkTexture* compositeTex = nullptr;
+            if (!info.regionLayers.empty()) {
+                compositeTex = charRenderer->compositeWithRegions(info.basePath,
+                    info.overlayPaths, info.regionLayers);
+            } else if (!info.overlayPaths.empty()) {
+                std::vector<std::string> skinLayers;
+                skinLayers.push_back(info.basePath);
+                for (const auto& op : info.overlayPaths) skinLayers.push_back(op);
+                compositeTex = charRenderer->compositeTextures(skinLayers);
+            }
+            if (compositeTex) skinTex = compositeTex;
+        } else if (info.hasSimpleSkin) {
+            // Simple skin: just base texture, no compositing
+            auto* baseTex = charRenderer->loadTexture(info.basePath);
+            if (baseTex) skinTex = baseTex;
+        }
+
+        if (skinTex) {
+            for (uint32_t slot : info.skinTextureSlots) {
+                charRenderer->setModelTexture(info.modelId, slot, skinTex);
+            }
+        }
+
+        // --- Apply hair texture to type-6 slots ---
+        if (!info.hairTexturePath.empty()) {
+            rendering::VkTexture* hairTex = charRenderer->loadTexture(info.hairTexturePath);
+            rendering::VkTexture* whTex = charRenderer->loadTexture("");
+            if (hairTex && hairTex != whTex) {
+                for (uint32_t slot : info.hairTextureSlots) {
+                    charRenderer->setModelTexture(info.modelId, slot, hairTex);
+                }
+            }
+        } else if (info.useBakedForHair && skinTex) {
+            // Bald NPC: use skin/baked texture for scalp cap
+            for (uint32_t slot : info.hairTextureSlots) {
+                charRenderer->setModelTexture(info.modelId, slot, skinTex);
+            }
+        }
+
+        charRenderer->setPredecodedBLPCache(nullptr);
+    }
+}
+
+void Application::processCreatureSpawnQueue(bool unlimited) {
+    auto startTime = std::chrono::steady_clock::now();
+    // Budget: max 2ms per frame for creature spawning to prevent stutter.
+    // In unlimited mode (load screen), process everything without budget cap.
+    static constexpr float kSpawnBudgetMs = 2.0f;
+
+    // First, finalize any async model loads that completed on background threads.
+    processAsyncCreatureResults(unlimited);
+    {
+        auto now = std::chrono::steady_clock::now();
+        float asyncMs = std::chrono::duration<float, std::milli>(now - startTime).count();
+        if (asyncMs > 100.0f) {
+            LOG_WARNING("processAsyncCreatureResults took ", asyncMs, "ms");
+        }
+    }
+
+    if (pendingCreatureSpawns_.empty()) return;
+    if (!creatureLookupsBuilt_) {
+        buildCreatureDisplayLookups();
+        if (!creatureLookupsBuilt_) return;
+    }
+
+    int processed = 0;
+    int asyncLaunched = 0;
+    size_t rotationsLeft = pendingCreatureSpawns_.size();
+    while (!pendingCreatureSpawns_.empty() &&
+           (unlimited || processed < MAX_SPAWNS_PER_FRAME) &&
+           rotationsLeft > 0) {
+        // Check time budget every iteration (including first — async results may
+        // have already consumed the budget via GPU model uploads).
+        if (!unlimited) {
+            auto now = std::chrono::steady_clock::now();
+            float elapsedMs = std::chrono::duration<float, std::milli>(now - startTime).count();
+            if (elapsedMs >= kSpawnBudgetMs) break;
+        }
+
+        PendingCreatureSpawn s = pendingCreatureSpawns_.front();
+        pendingCreatureSpawns_.pop_front();
+
+        if (nonRenderableCreatureDisplayIds_.count(s.displayId)) {
+            pendingCreatureSpawnGuids_.erase(s.guid);
+            creatureSpawnRetryCounts_.erase(s.guid);
+            processed++;
+            rotationsLeft = pendingCreatureSpawns_.size();
+            continue;
+        }
+
+        const bool needsNewModel = (displayIdModelCache_.find(s.displayId) == displayIdModelCache_.end());
+
+        // For new models: launch async load on background thread instead of blocking.
+        if (needsNewModel) {
+            const int maxAsync = unlimited ? (MAX_ASYNC_CREATURE_LOADS * 4) : MAX_ASYNC_CREATURE_LOADS;
+            if (static_cast<int>(asyncCreatureLoads_.size()) + asyncLaunched >= maxAsync) {
+                // Too many in-flight — defer to next frame
+                pendingCreatureSpawns_.push_back(s);
+                rotationsLeft--;
+                continue;
+            }
+
+            std::string m2Path = getModelPathForDisplayId(s.displayId);
+            if (m2Path.empty()) {
+                nonRenderableCreatureDisplayIds_.insert(s.displayId);
+                creaturePermanentFailureGuids_.insert(s.guid);
+                pendingCreatureSpawnGuids_.erase(s.guid);
+                creatureSpawnRetryCounts_.erase(s.guid);
+                processed++;
+                rotationsLeft = pendingCreatureSpawns_.size();
+                continue;
+            }
+
+            // Check for invisible stalkers
+            {
+                std::string lowerPath = m2Path;
+                std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(),
+                               [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+                if (lowerPath.find("invisiblestalker") != std::string::npos ||
+                    lowerPath.find("invisible_stalker") != std::string::npos) {
+                    nonRenderableCreatureDisplayIds_.insert(s.displayId);
+                    creaturePermanentFailureGuids_.insert(s.guid);
+                    pendingCreatureSpawnGuids_.erase(s.guid);
+                    processed++;
+                    rotationsLeft = pendingCreatureSpawns_.size();
+                    continue;
+                }
+            }
+
+            // Launch async M2 load — file I/O and parsing happen off the main thread.
+            uint32_t modelId = nextCreatureModelId_++;
+            auto* am = assetManager.get();
+
+            // Collect display skin texture paths for background pre-decode
+            std::vector<std::string> displaySkinPaths;
+            {
+                auto itDD = displayDataMap_.find(s.displayId);
+                if (itDD != displayDataMap_.end()) {
+                    std::string modelDir;
+                    size_t lastSlash = m2Path.find_last_of("\\/");
+                    if (lastSlash != std::string::npos) modelDir = m2Path.substr(0, lastSlash + 1);
+
+                    auto resolveForAsync = [&](const std::string& skinField) {
+                        if (skinField.empty()) return;
+                        std::string raw = skinField;
+                        std::replace(raw.begin(), raw.end(), '/', '\\');
+                        while (!raw.empty() && std::isspace(static_cast<unsigned char>(raw.front()))) raw.erase(raw.begin());
+                        while (!raw.empty() && std::isspace(static_cast<unsigned char>(raw.back()))) raw.pop_back();
+                        if (raw.empty()) return;
+                        bool hasExt = raw.size() >= 4 && raw.substr(raw.size()-4) == ".blp";
+                        bool hasDir = raw.find('\\') != std::string::npos;
+                        std::vector<std::string> candidates;
+                        if (hasDir) {
+                            candidates.push_back(raw);
+                            if (!hasExt) candidates.push_back(raw + ".blp");
+                        } else {
+                            candidates.push_back(modelDir + raw);
+                            if (!hasExt) candidates.push_back(modelDir + raw + ".blp");
+                            candidates.push_back(raw);
+                            if (!hasExt) candidates.push_back(raw + ".blp");
+                        }
+                        for (const auto& c : candidates) {
+                            if (am->fileExists(c)) { displaySkinPaths.push_back(c); return; }
+                        }
+                    };
+                    resolveForAsync(itDD->second.skin1);
+                    resolveForAsync(itDD->second.skin2);
+                    resolveForAsync(itDD->second.skin3);
+
+                    // Pre-decode humanoid NPC textures (bake, skin, face, underwear, hair, equipment)
+                    if (itDD->second.extraDisplayId != 0) {
+                        auto itHE = humanoidExtraMap_.find(itDD->second.extraDisplayId);
+                        if (itHE != humanoidExtraMap_.end()) {
+                            const auto& he = itHE->second;
+                            // Baked texture
+                            if (!he.bakeName.empty()) {
+                                displaySkinPaths.push_back("Textures\\BakedNpcTextures\\" + he.bakeName);
+                            }
+                            // CharSections: skin, face, underwear
+                            auto csDbc = am->loadDBC("CharSections.dbc");
+                            if (csDbc) {
+                                const auto* csL = pipeline::getActiveDBCLayout()
+                                    ? pipeline::getActiveDBCLayout()->getLayout("CharSections") : nullptr;
+                                uint32_t nRace = static_cast<uint32_t>(he.raceId);
+                                uint32_t nSex = static_cast<uint32_t>(he.sexId);
+                                uint32_t nSkin = static_cast<uint32_t>(he.skinId);
+                                uint32_t nFace = static_cast<uint32_t>(he.faceId);
+                                for (uint32_t r = 0; r < csDbc->getRecordCount(); r++) {
+                                    uint32_t rId = csDbc->getUInt32(r, csL ? (*csL)["RaceID"] : 1);
+                                    uint32_t sId = csDbc->getUInt32(r, csL ? (*csL)["SexID"] : 2);
+                                    if (rId != nRace || sId != nSex) continue;
+                                    uint32_t section = csDbc->getUInt32(r, csL ? (*csL)["BaseSection"] : 3);
+                                    uint32_t variation = csDbc->getUInt32(r, csL ? (*csL)["VariationIndex"] : 4);
+                                    uint32_t color = csDbc->getUInt32(r, csL ? (*csL)["ColorIndex"] : 5);
+                                    uint32_t tex1F = csL ? (*csL)["Texture1"] : 6;
+                                    if (section == 0 && color == nSkin) {
+                                        std::string t = csDbc->getString(r, tex1F);
+                                        if (!t.empty()) displaySkinPaths.push_back(t);
+                                    } else if (section == 1 && variation == nFace && color == nSkin) {
+                                        std::string t1 = csDbc->getString(r, tex1F);
+                                        std::string t2 = csDbc->getString(r, tex1F + 1);
+                                        if (!t1.empty()) displaySkinPaths.push_back(t1);
+                                        if (!t2.empty()) displaySkinPaths.push_back(t2);
+                                    } else if (section == 3 && variation == static_cast<uint32_t>(he.hairStyleId)
+                                               && color == static_cast<uint32_t>(he.hairColorId)) {
+                                        std::string t = csDbc->getString(r, tex1F);
+                                        if (!t.empty()) displaySkinPaths.push_back(t);
+                                    } else if (section == 4 && color == nSkin) {
+                                        for (uint32_t f = tex1F; f <= tex1F + 2; f++) {
+                                            std::string t = csDbc->getString(r, f);
+                                            if (!t.empty()) displaySkinPaths.push_back(t);
+                                        }
+                                    }
+                                }
+                            }
+                            // Equipment region textures
+                            auto idiDbc = am->loadDBC("ItemDisplayInfo.dbc");
+                            if (idiDbc) {
+                                static const char* compDirs[] = {
+                                    "ArmUpperTexture", "ArmLowerTexture", "HandTexture",
+                                    "TorsoUpperTexture", "TorsoLowerTexture",
+                                    "LegUpperTexture", "LegLowerTexture", "FootTexture",
+                                };
+                                const auto* idiL = pipeline::getActiveDBCLayout()
+                                    ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
+                                const uint32_t trf[8] = {
+                                    idiL ? (*idiL)["TextureArmUpper"]  : 14u,
+                                    idiL ? (*idiL)["TextureArmLower"]  : 15u,
+                                    idiL ? (*idiL)["TextureHand"]      : 16u,
+                                    idiL ? (*idiL)["TextureTorsoUpper"]: 17u,
+                                    idiL ? (*idiL)["TextureTorsoLower"]: 18u,
+                                    idiL ? (*idiL)["TextureLegUpper"]  : 19u,
+                                    idiL ? (*idiL)["TextureLegLower"]  : 20u,
+                                    idiL ? (*idiL)["TextureFoot"]      : 21u,
+                                };
+                                const bool isFem = (he.sexId == 1);
+                                for (int eq = 0; eq < 11; eq++) {
+                                    uint32_t did = he.equipDisplayId[eq];
+                                    if (did == 0) continue;
+                                    int32_t recIdx = idiDbc->findRecordById(did);
+                                    if (recIdx < 0) continue;
+                                    for (int region = 0; region < 8; region++) {
+                                        std::string texName = idiDbc->getString(static_cast<uint32_t>(recIdx), trf[region]);
+                                        if (texName.empty()) continue;
+                                        std::string base = "Item\\TextureComponents\\" +
+                                            std::string(compDirs[region]) + "\\" + texName;
+                                        std::string gp = base + (isFem ? "_F.blp" : "_M.blp");
+                                        std::string up = base + "_U.blp";
+                                        if (am->fileExists(gp)) displaySkinPaths.push_back(gp);
+                                        else if (am->fileExists(up)) displaySkinPaths.push_back(up);
+                                        else displaySkinPaths.push_back(base + ".blp");
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            AsyncCreatureLoad load;
+            load.future = std::async(std::launch::async,
+                [am, m2Path, modelId, s, skinPaths = std::move(displaySkinPaths)]() -> PreparedCreatureModel {
+                    PreparedCreatureModel result;
+                    result.guid = s.guid;
+                    result.displayId = s.displayId;
+                    result.modelId = modelId;
+                    result.x = s.x;
+                    result.y = s.y;
+                    result.z = s.z;
+                    result.orientation = s.orientation;
+
+                    auto m2Data = am->readFile(m2Path);
+                    if (m2Data.empty()) {
+                        result.permanent_failure = true;
+                        return result;
+                    }
+
+                    auto model = std::make_shared<pipeline::M2Model>(pipeline::M2Loader::load(m2Data));
+                    if (model->vertices.empty()) {
+                        result.permanent_failure = true;
+                        return result;
+                    }
+
+                    // Load skin file
+                    if (model->version >= 264) {
+                        std::string skinPath = m2Path.substr(0, m2Path.size() - 3) + "00.skin";
+                        auto skinData = am->readFile(skinPath);
+                        if (!skinData.empty()) {
+                            pipeline::M2Loader::loadSkin(skinData, *model);
+                        }
+                    }
+
+                    // Load external .anim files
+                    std::string basePath = m2Path.substr(0, m2Path.size() - 3);
+                    for (uint32_t si = 0; si < model->sequences.size(); si++) {
+                        if (!(model->sequences[si].flags & 0x20)) {
+                            char animFileName[256];
+                            snprintf(animFileName, sizeof(animFileName), "%s%04u-%02u.anim",
+                                basePath.c_str(), model->sequences[si].id, model->sequences[si].variationIndex);
+                            auto animData = am->readFileOptional(animFileName);
+                            if (!animData.empty()) {
+                                pipeline::M2Loader::loadAnimFile(m2Data, animData, si, *model);
+                            }
+                        }
+                    }
+
+                    // Pre-decode model textures on background thread
+                    for (const auto& tex : model->textures) {
+                        if (tex.filename.empty()) continue;
+                        std::string texKey = tex.filename;
+                        std::replace(texKey.begin(), texKey.end(), '/', '\\');
+                        std::transform(texKey.begin(), texKey.end(), texKey.begin(),
+                                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+                        if (result.predecodedTextures.find(texKey) != result.predecodedTextures.end()) continue;
+                        auto blp = am->loadTexture(texKey);
+                        if (blp.isValid()) {
+                            result.predecodedTextures[texKey] = std::move(blp);
+                        }
+                    }
+
+                    // Pre-decode display skin textures (skin1/skin2/skin3 from CreatureDisplayInfo)
+                    for (const auto& sp : skinPaths) {
+                        std::string key = sp;
+                        std::replace(key.begin(), key.end(), '/', '\\');
+                        std::transform(key.begin(), key.end(), key.begin(),
+                                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+                        if (result.predecodedTextures.count(key)) continue;
+                        auto blp = am->loadTexture(key);
+                        if (blp.isValid()) {
+                            result.predecodedTextures[key] = std::move(blp);
+                        }
+                    }
+
+                    result.model = std::move(model);
+                    result.valid = true;
+                    return result;
+                });
+            asyncCreatureLoads_.push_back(std::move(load));
+            asyncLaunched++;
+            // Don't erase from pendingCreatureSpawnGuids_ — the async result handler will do it
+            rotationsLeft = pendingCreatureSpawns_.size();
+            processed++;
+            continue;
+        }
+
+        // Cached model — spawn is fast (no file I/O, just instance creation + texture setup)
+        {
+            auto spawnStart = std::chrono::steady_clock::now();
+            spawnOnlineCreature(s.guid, s.displayId, s.x, s.y, s.z, s.orientation);
+            auto spawnEnd = std::chrono::steady_clock::now();
+            float spawnMs = std::chrono::duration<float, std::milli>(spawnEnd - spawnStart).count();
+            if (spawnMs > 100.0f) {
+                LOG_WARNING("spawnOnlineCreature took ", spawnMs, "ms displayId=", s.displayId);
+            }
+        }
+        pendingCreatureSpawnGuids_.erase(s.guid);
+
+        // If spawn still failed, retry for a limited number of frames.
+        if (!creatureInstances_.count(s.guid)) {
+            if (creaturePermanentFailureGuids_.erase(s.guid) > 0) {
+                creatureSpawnRetryCounts_.erase(s.guid);
+                processed++;
+                continue;
+            }
+            uint16_t retries = 0;
+            auto it = creatureSpawnRetryCounts_.find(s.guid);
+            if (it != creatureSpawnRetryCounts_.end()) {
+                retries = it->second;
+            }
+            if (retries < MAX_CREATURE_SPAWN_RETRIES) {
+                creatureSpawnRetryCounts_[s.guid] = static_cast<uint16_t>(retries + 1);
+                pendingCreatureSpawns_.push_back(s);
+                pendingCreatureSpawnGuids_.insert(s.guid);
+            } else {
+                creatureSpawnRetryCounts_.erase(s.guid);
+                LOG_WARNING("Dropping creature spawn after retries: guid=0x", std::hex, s.guid, std::dec,
+                            " displayId=", s.displayId);
+            }
+        } else {
+            creatureSpawnRetryCounts_.erase(s.guid);
+        }
+        rotationsLeft = pendingCreatureSpawns_.size();
+        processed++;
+    }
+}
+
+void Application::processPlayerSpawnQueue() {
+    if (pendingPlayerSpawns_.empty()) return;
+    if (!assetManager || !assetManager->isInitialized()) return;
+
+    int processed = 0;
+    while (!pendingPlayerSpawns_.empty() && processed < MAX_SPAWNS_PER_FRAME) {
+        PendingPlayerSpawn s = pendingPlayerSpawns_.front();
+        pendingPlayerSpawns_.erase(pendingPlayerSpawns_.begin());
+        pendingPlayerSpawnGuids_.erase(s.guid);
+
+        // Skip if already spawned (could have been spawned by a previous update this frame)
+        if (playerInstances_.count(s.guid)) {
+            processed++;
+            continue;
+        }
+
+        spawnOnlinePlayer(s.guid, s.raceId, s.genderId, s.appearanceBytes, s.facialFeatures, s.x, s.y, s.z, s.orientation);
+        // Apply any equipment updates that arrived before the player was spawned.
+        auto pit = pendingOnlinePlayerEquipment_.find(s.guid);
+        if (pit != pendingOnlinePlayerEquipment_.end()) {
+            deferredEquipmentQueue_.push_back({s.guid, pit->second});
+            pendingOnlinePlayerEquipment_.erase(pit);
+        }
+        processed++;
+    }
+}
+
+std::vector<std::string> Application::resolveEquipmentTexturePaths(uint64_t guid,
+    const std::array<uint32_t, 19>& displayInfoIds,
+    const std::array<uint8_t, 19>& /*inventoryTypes*/) const {
+    std::vector<std::string> paths;
+
+    auto it = onlinePlayerAppearance_.find(guid);
+    if (it == onlinePlayerAppearance_.end()) return paths;
+    const OnlinePlayerAppearanceState& st = it->second;
+
+    // Add base skin + underwear paths
+    if (!st.bodySkinPath.empty()) paths.push_back(st.bodySkinPath);
+    for (const auto& up : st.underwearPaths) {
+        if (!up.empty()) paths.push_back(up);
+    }
+
+    // Resolve equipment region texture paths (same logic as setOnlinePlayerEquipment)
+    auto displayInfoDbc = assetManager->loadDBC("ItemDisplayInfo.dbc");
+    if (!displayInfoDbc) return paths;
+    const auto* idiL = pipeline::getActiveDBCLayout()
+        ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
+
+    static const char* componentDirs[] = {
+        "ArmUpperTexture", "ArmLowerTexture", "HandTexture",
+        "TorsoUpperTexture", "TorsoLowerTexture",
+        "LegUpperTexture", "LegLowerTexture", "FootTexture",
+    };
+    const uint32_t texRegionFields[8] = {
+        idiL ? (*idiL)["TextureArmUpper"]  : 14u,
+        idiL ? (*idiL)["TextureArmLower"]  : 15u,
+        idiL ? (*idiL)["TextureHand"]      : 16u,
+        idiL ? (*idiL)["TextureTorsoUpper"]: 17u,
+        idiL ? (*idiL)["TextureTorsoLower"]: 18u,
+        idiL ? (*idiL)["TextureLegUpper"]  : 19u,
+        idiL ? (*idiL)["TextureLegLower"]  : 20u,
+        idiL ? (*idiL)["TextureFoot"]      : 21u,
+    };
+    const bool isFemale = (st.genderId == 1);
+
+    for (int s = 0; s < 19; s++) {
+        uint32_t did = displayInfoIds[s];
+        if (did == 0) continue;
+        int32_t recIdx = displayInfoDbc->findRecordById(did);
+        if (recIdx < 0) continue;
+        for (int region = 0; region < 8; region++) {
+            std::string texName = displayInfoDbc->getString(
+                static_cast<uint32_t>(recIdx), texRegionFields[region]);
+            if (texName.empty()) continue;
+            std::string base = "Item\\TextureComponents\\" +
+                std::string(componentDirs[region]) + "\\" + texName;
+            std::string genderPath = base + (isFemale ? "_F.blp" : "_M.blp");
+            std::string unisexPath = base + "_U.blp";
+            if (assetManager->fileExists(genderPath)) paths.push_back(genderPath);
+            else if (assetManager->fileExists(unisexPath)) paths.push_back(unisexPath);
+            else paths.push_back(base + ".blp");
+        }
+    }
+    return paths;
+}
+
+void Application::processAsyncEquipmentResults() {
+    for (auto it = asyncEquipmentLoads_.begin(); it != asyncEquipmentLoads_.end(); ) {
+        if (!it->future.valid() ||
+            it->future.wait_for(std::chrono::milliseconds(0)) != std::future_status::ready) {
+            ++it;
+            continue;
+        }
+        auto result = it->future.get();
+        it = asyncEquipmentLoads_.erase(it);
+
+        auto* charRenderer = renderer ? renderer->getCharacterRenderer() : nullptr;
+        if (!charRenderer) continue;
+
+        // Set pre-decoded cache so compositeWithRegions skips synchronous BLP decode
+        charRenderer->setPredecodedBLPCache(&result.predecodedTextures);
+        setOnlinePlayerEquipment(result.guid, result.displayInfoIds, result.inventoryTypes);
+        charRenderer->setPredecodedBLPCache(nullptr);
+    }
+}
+
+void Application::processDeferredEquipmentQueue() {
+    // First, finalize any completed async pre-decodes
+    processAsyncEquipmentResults();
+
+    if (deferredEquipmentQueue_.empty()) return;
+    // Limit in-flight async equipment loads
+    if (asyncEquipmentLoads_.size() >= 2) return;
+
+    auto [guid, equipData] = deferredEquipmentQueue_.front();
+    deferredEquipmentQueue_.erase(deferredEquipmentQueue_.begin());
+
+    // Resolve all texture paths that compositeWithRegions will need
+    auto texturePaths = resolveEquipmentTexturePaths(guid, equipData.first, equipData.second);
+
+    if (texturePaths.empty()) {
+        // No textures to pre-decode — just apply directly (fast path)
+        setOnlinePlayerEquipment(guid, equipData.first, equipData.second);
+        return;
+    }
+
+    // Launch background BLP pre-decode
+    auto* am = assetManager.get();
+    auto displayInfoIds = equipData.first;
+    auto inventoryTypes = equipData.second;
+    AsyncEquipmentLoad load;
+    load.future = std::async(std::launch::async,
+        [am, guid, displayInfoIds, inventoryTypes, paths = std::move(texturePaths)]() -> PreparedEquipmentUpdate {
+            PreparedEquipmentUpdate result;
+            result.guid = guid;
+            result.displayInfoIds = displayInfoIds;
+            result.inventoryTypes = inventoryTypes;
+            for (const auto& path : paths) {
+                std::string key = path;
+                std::replace(key.begin(), key.end(), '/', '\\');
+                std::transform(key.begin(), key.end(), key.begin(),
+                               [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+                if (result.predecodedTextures.count(key)) continue;
+                auto blp = am->loadTexture(key);
+                if (blp.isValid()) {
+                    result.predecodedTextures[key] = std::move(blp);
+                }
+            }
+            return result;
+        });
+    asyncEquipmentLoads_.push_back(std::move(load));
+}
+
+void Application::processAsyncGameObjectResults() {
+    for (auto it = asyncGameObjectLoads_.begin(); it != asyncGameObjectLoads_.end(); ) {
+        if (!it->future.valid() ||
+            it->future.wait_for(std::chrono::milliseconds(0)) != std::future_status::ready) {
+            ++it;
+            continue;
+        }
+
+        auto result = it->future.get();
+        it = asyncGameObjectLoads_.erase(it);
+
+        if (!result.valid || !result.isWmo || !result.wmoModel) {
+            // Fallback: spawn via sync path (likely an M2 or failed WMO)
+            spawnOnlineGameObject(result.guid, result.entry, result.displayId,
+                                 result.x, result.y, result.z, result.orientation);
+            continue;
+        }
+
+        // WMO parsed on background thread — do GPU upload + instance creation on main thread
+        auto* wmoRenderer = renderer ? renderer->getWMORenderer() : nullptr;
+        if (!wmoRenderer) continue;
+
+        uint32_t modelId = 0;
+        auto itCache = gameObjectDisplayIdWmoCache_.find(result.displayId);
+        if (itCache != gameObjectDisplayIdWmoCache_.end()) {
+            modelId = itCache->second;
+        } else {
+            modelId = nextGameObjectWmoModelId_++;
+            wmoRenderer->setPredecodedBLPCache(&result.predecodedTextures);
+            if (!wmoRenderer->loadModel(*result.wmoModel, modelId)) {
+                wmoRenderer->setPredecodedBLPCache(nullptr);
+                LOG_WARNING("Failed to load async gameobject WMO: ", result.modelPath);
+                continue;
+            }
+            wmoRenderer->setPredecodedBLPCache(nullptr);
+            gameObjectDisplayIdWmoCache_[result.displayId] = modelId;
+        }
+
+        glm::vec3 renderPos = core::coords::canonicalToRender(
+            glm::vec3(result.x, result.y, result.z));
+        uint32_t instanceId = wmoRenderer->createInstance(
+            modelId, renderPos, glm::vec3(0.0f, 0.0f, result.orientation), 1.0f);
+        if (instanceId == 0) continue;
+
+        gameObjectInstances_[result.guid] = {modelId, instanceId, true};
+
+        // Queue transport doodad loading if applicable
+        std::string lowerPath = result.modelPath;
+        std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(),
+                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+        if (lowerPath.find("transport") != std::string::npos) {
+            const auto* doodadTemplates = wmoRenderer->getDoodadTemplates(modelId);
+            if (doodadTemplates && !doodadTemplates->empty()) {
+                PendingTransportDoodadBatch batch;
+                batch.guid = result.guid;
+                batch.modelId = modelId;
+                batch.instanceId = instanceId;
+                batch.x = result.x;
+                batch.y = result.y;
+                batch.z = result.z;
+                batch.orientation = result.orientation;
+                batch.doodadBudget = doodadTemplates->size();
+                pendingTransportDoodadBatches_.push_back(batch);
+            }
+        }
+    }
+}
+
+void Application::processGameObjectSpawnQueue() {
+    // Finalize any completed async WMO loads first
+    processAsyncGameObjectResults();
+
+    if (pendingGameObjectSpawns_.empty()) return;
+
+    // Process spawns: cached WMOs and M2s go sync (cheap), uncached WMOs go async
+    auto startTime = std::chrono::steady_clock::now();
+    static constexpr float kBudgetMs = 2.0f;
+    static constexpr int kMaxAsyncLoads = 2;
+
+    while (!pendingGameObjectSpawns_.empty()) {
+        float elapsedMs = std::chrono::duration<float, std::milli>(
+            std::chrono::steady_clock::now() - startTime).count();
+        if (elapsedMs >= kBudgetMs) break;
+
+        auto& s = pendingGameObjectSpawns_.front();
+
+        // Check if this is an uncached WMO that needs async loading
+        std::string modelPath;
+        if (gameObjectLookupsBuilt_) {
+            // Check transport overrides first
+            bool isTransport = gameHandler && gameHandler->isTransportGuid(s.guid);
+            if (isTransport) {
+                if (s.entry == 20808 || s.entry == 176231 || s.entry == 176310)
+                    modelPath = "World\\wmo\\transports\\transport_ship\\transportship.wmo";
+                else if (s.displayId == 807 || s.displayId == 808 || s.displayId == 175080 || s.displayId == 176495 || s.displayId == 164871)
+                    modelPath = "World\\wmo\\transports\\transport_zeppelin\\transport_zeppelin.wmo";
+                else if (s.displayId == 1587)
+                    modelPath = "World\\wmo\\transports\\transport_horde_zeppelin\\Transport_Horde_Zeppelin.wmo";
+                else if (s.displayId == 2454 || s.displayId == 181688 || s.displayId == 190536)
+                    modelPath = "World\\wmo\\transports\\icebreaker\\Transport_Icebreaker_ship.wmo";
+            }
+            if (modelPath.empty())
+                modelPath = getGameObjectModelPathForDisplayId(s.displayId);
+        }
+
+        std::string lowerPath = modelPath;
+        std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(),
+                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+        bool isWmo = lowerPath.size() >= 4 && lowerPath.substr(lowerPath.size() - 4) == ".wmo";
+        bool isCached = isWmo && gameObjectDisplayIdWmoCache_.count(s.displayId);
+
+        if (isWmo && !isCached && !modelPath.empty() &&
+            static_cast<int>(asyncGameObjectLoads_.size()) < kMaxAsyncLoads) {
+            // Launch async WMO load — file I/O + parse on background thread
+            auto* am = assetManager.get();
+            PendingGameObjectSpawn capture = s;
+            std::string capturePath = modelPath;
+            AsyncGameObjectLoad load;
+            load.future = std::async(std::launch::async,
+                [am, capture, capturePath]() -> PreparedGameObjectWMO {
+                    PreparedGameObjectWMO result;
+                    result.guid = capture.guid;
+                    result.entry = capture.entry;
+                    result.displayId = capture.displayId;
+                    result.x = capture.x;
+                    result.y = capture.y;
+                    result.z = capture.z;
+                    result.orientation = capture.orientation;
+                    result.modelPath = capturePath;
+                    result.isWmo = true;
+
+                    auto wmoData = am->readFile(capturePath);
+                    if (wmoData.empty()) return result;
+
+                    auto wmo = std::make_shared<pipeline::WMOModel>(
+                        pipeline::WMOLoader::load(wmoData));
+
+                    // Load groups
+                    if (wmo->nGroups > 0) {
+                        std::string basePath = capturePath;
+                        std::string ext;
+                        if (basePath.size() > 4) {
+                            ext = basePath.substr(basePath.size() - 4);
+                            basePath = basePath.substr(0, basePath.size() - 4);
+                        }
+                        for (uint32_t gi = 0; gi < wmo->nGroups; gi++) {
+                            char suffix[16];
+                            snprintf(suffix, sizeof(suffix), "_%03u%s", gi, ext.c_str());
+                            auto groupData = am->readFile(basePath + suffix);
+                            if (groupData.empty()) {
+                                snprintf(suffix, sizeof(suffix), "_%03u.wmo", gi);
+                                groupData = am->readFile(basePath + suffix);
+                            }
+                            if (!groupData.empty()) {
+                                pipeline::WMOLoader::loadGroup(groupData, *wmo, gi);
+                            }
+                        }
+                    }
+
+                    // Pre-decode WMO textures on background thread
+                    for (const auto& texPath : wmo->textures) {
+                        if (texPath.empty()) continue;
+                        std::string texKey = texPath;
+                        size_t nul = texKey.find('\0');
+                        if (nul != std::string::npos) texKey.resize(nul);
+                        std::replace(texKey.begin(), texKey.end(), '/', '\\');
+                        std::transform(texKey.begin(), texKey.end(), texKey.begin(),
+                                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+                        if (texKey.empty()) continue;
+                        // Convert to .blp extension
+                        if (texKey.size() >= 4) {
+                            std::string ext = texKey.substr(texKey.size() - 4);
+                            if (ext == ".tga" || ext == ".dds") {
+                                texKey = texKey.substr(0, texKey.size() - 4) + ".blp";
+                            }
+                        }
+                        if (result.predecodedTextures.find(texKey) != result.predecodedTextures.end()) continue;
+                        auto blp = am->loadTexture(texKey);
+                        if (blp.isValid()) {
+                            result.predecodedTextures[texKey] = std::move(blp);
+                        }
+                    }
+
+                    result.wmoModel = wmo;
+                    result.valid = true;
+                    return result;
+                });
+            asyncGameObjectLoads_.push_back(std::move(load));
+            pendingGameObjectSpawns_.erase(pendingGameObjectSpawns_.begin());
+            continue;
+        }
+
+        // Cached WMO or M2 — spawn synchronously (cheap)
+        spawnOnlineGameObject(s.guid, s.entry, s.displayId, s.x, s.y, s.z, s.orientation);
+        pendingGameObjectSpawns_.erase(pendingGameObjectSpawns_.begin());
+    }
+}
+
+void Application::processPendingTransportDoodads() {
+    if (pendingTransportDoodadBatches_.empty()) return;
+    if (!renderer || !assetManager) return;
+
+    auto* wmoRenderer = renderer->getWMORenderer();
+    auto* m2Renderer = renderer->getM2Renderer();
+    if (!wmoRenderer || !m2Renderer) return;
+
+    auto startTime = std::chrono::steady_clock::now();
+    static constexpr float kDoodadBudgetMs = 4.0f;
+
+    size_t budgetLeft = MAX_TRANSPORT_DOODADS_PER_FRAME;
+    for (auto it = pendingTransportDoodadBatches_.begin();
+         it != pendingTransportDoodadBatches_.end() && budgetLeft > 0;) {
+        // Time budget check
+        float elapsedMs = std::chrono::duration<float, std::milli>(
+            std::chrono::steady_clock::now() - startTime).count();
+        if (elapsedMs >= kDoodadBudgetMs) break;
+        auto goIt = gameObjectInstances_.find(it->guid);
+        if (goIt == gameObjectInstances_.end() || !goIt->second.isWmo ||
+            goIt->second.instanceId != it->instanceId || goIt->second.modelId != it->modelId) {
+            it = pendingTransportDoodadBatches_.erase(it);
+            continue;
+        }
+
+        const auto* doodadTemplates = wmoRenderer->getDoodadTemplates(it->modelId);
+        if (!doodadTemplates || doodadTemplates->empty()) {
+            it = pendingTransportDoodadBatches_.erase(it);
+            continue;
+        }
+
+        const size_t maxIndex = std::min(it->doodadBudget, doodadTemplates->size());
+        while (it->nextIndex < maxIndex && budgetLeft > 0) {
+            // Per-doodad time budget (each does synchronous file I/O + parse + GPU upload)
+            float innerMs = std::chrono::duration<float, std::milli>(
+                std::chrono::steady_clock::now() - startTime).count();
+            if (innerMs >= kDoodadBudgetMs) { budgetLeft = 0; break; }
+
+            const auto& doodadTemplate = (*doodadTemplates)[it->nextIndex];
+            it->nextIndex++;
+            budgetLeft--;
+
+            uint32_t doodadModelId = static_cast<uint32_t>(std::hash<std::string>{}(doodadTemplate.m2Path));
+            auto m2Data = assetManager->readFile(doodadTemplate.m2Path);
+            if (m2Data.empty()) continue;
+
+            pipeline::M2Model m2Model = pipeline::M2Loader::load(m2Data);
+            std::string skinPath = doodadTemplate.m2Path.substr(0, doodadTemplate.m2Path.size() - 3) + "00.skin";
+            std::vector<uint8_t> skinData = assetManager->readFile(skinPath);
+            if (!skinData.empty() && m2Model.version >= 264) {
+                pipeline::M2Loader::loadSkin(skinData, m2Model);
+            }
+            if (!m2Model.isValid()) continue;
+
+            m2Renderer->loadModel(m2Model, doodadModelId);
+            uint32_t m2InstanceId = m2Renderer->createInstance(doodadModelId, glm::vec3(0.0f), glm::vec3(0.0f), 1.0f);
+            if (m2InstanceId == 0) continue;
+            m2Renderer->setSkipCollision(m2InstanceId, true);
+
+            wmoRenderer->addDoodadToInstance(it->instanceId, m2InstanceId, doodadTemplate.localTransform);
+            it->spawnedDoodads++;
+        }
+
+        if (it->nextIndex >= maxIndex) {
+            if (it->spawnedDoodads > 0) {
+                LOG_DEBUG("Spawned ", it->spawnedDoodads,
+                         " transport doodads for WMO instance ", it->instanceId);
+                glm::vec3 renderPos = core::coords::canonicalToRender(glm::vec3(it->x, it->y, it->z));
+                glm::mat4 wmoTransform(1.0f);
+                wmoTransform = glm::translate(wmoTransform, renderPos);
+                wmoTransform = glm::rotate(wmoTransform, it->orientation, glm::vec3(0, 0, 1));
+                wmoRenderer->setInstanceTransform(it->instanceId, wmoTransform);
+            }
+            it = pendingTransportDoodadBatches_.erase(it);
+        } else {
+            ++it;
+        }
+    }
+}
+
+void Application::processPendingMount() {
+    if (pendingMountDisplayId_ == 0) return;
+    uint32_t mountDisplayId = pendingMountDisplayId_;
+    pendingMountDisplayId_ = 0;
+    LOG_INFO("processPendingMount: loading displayId ", mountDisplayId);
+
+    if (!renderer || !renderer->getCharacterRenderer() || !assetManager) return;
+    auto* charRenderer = renderer->getCharacterRenderer();
+
+    std::string m2Path = getModelPathForDisplayId(mountDisplayId);
+    if (m2Path.empty()) {
+        LOG_WARNING("No model path for mount displayId ", mountDisplayId);
+        return;
+    }
+
+    // Check model cache
+    uint32_t modelId = 0;
+    auto cacheIt = displayIdModelCache_.find(mountDisplayId);
+    if (cacheIt != displayIdModelCache_.end()) {
+        modelId = cacheIt->second;
+    } else {
+        modelId = nextCreatureModelId_++;
+
+        auto m2Data = assetManager->readFile(m2Path);
+        if (m2Data.empty()) {
+            LOG_WARNING("Failed to read mount M2: ", m2Path);
+            return;
+        }
+
+        pipeline::M2Model model = pipeline::M2Loader::load(m2Data);
+        if (model.vertices.empty()) {
+            LOG_WARNING("Failed to parse mount M2: ", m2Path);
+            return;
+        }
+
+        // Load skin file (only for WotLK M2s - vanilla has embedded skin)
+        if (model.version >= 264) {
+            std::string skinPath = m2Path.substr(0, m2Path.size() - 3) + "00.skin";
+            auto skinData = assetManager->readFile(skinPath);
+            if (!skinData.empty()) {
+                pipeline::M2Loader::loadSkin(skinData, model);
+            } else {
+                LOG_WARNING("Missing skin file for WotLK mount M2: ", skinPath);
+            }
+        }
+
+        // Load external .anim files (only idle + run needed for mounts)
+        std::string basePath = m2Path.substr(0, m2Path.size() - 3);
+        for (uint32_t si = 0; si < model.sequences.size(); si++) {
+            if (!(model.sequences[si].flags & 0x20)) {
+                uint32_t animId = model.sequences[si].id;
+                // Only load stand(0), walk(4), run(5) anims to avoid hang
+                if (animId != 0 && animId != 4 && animId != 5) continue;
+                char animFileName[256];
+                snprintf(animFileName, sizeof(animFileName), "%s%04u-%02u.anim",
+                    basePath.c_str(), animId, model.sequences[si].variationIndex);
+                auto animData = assetManager->readFileOptional(animFileName);
+                if (!animData.empty()) {
+                    pipeline::M2Loader::loadAnimFile(m2Data, animData, si, model);
+                }
+            }
+        }
+
+        if (!charRenderer->loadModel(model, modelId)) {
+            LOG_WARNING("Failed to load mount model: ", m2Path);
+            return;
+        }
+
+        displayIdModelCache_[mountDisplayId] = modelId;
+    }
+
+    // Apply creature skin textures from CreatureDisplayInfo.dbc.
+    // Re-apply even for cached models so transient failures can self-heal.
+    std::string modelDir;
+    size_t lastSlash = m2Path.find_last_of("\\/");
+    if (lastSlash != std::string::npos) {
+        modelDir = m2Path.substr(0, lastSlash + 1);
+    }
+
+    auto itDisplayData = displayDataMap_.find(mountDisplayId);
+    bool haveDisplayData = false;
+    CreatureDisplayData dispData{};
+    if (itDisplayData != displayDataMap_.end()) {
+        dispData = itDisplayData->second;
+        haveDisplayData = true;
+    } else {
+        // Some taxi mount display IDs are sparse; recover skins by matching model path.
+        std::string lowerMountPath = m2Path;
+        std::transform(lowerMountPath.begin(), lowerMountPath.end(), lowerMountPath.begin(),
+                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+        int bestScore = -1;
+        for (const auto& [dispId, data] : displayDataMap_) {
+            auto pit = modelIdToPath_.find(data.modelId);
+            if (pit == modelIdToPath_.end()) continue;
+            std::string p = pit->second;
+            std::transform(p.begin(), p.end(), p.begin(),
+                           [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+            if (p != lowerMountPath) continue;
+            int score = 0;
+            if (!data.skin1.empty()) {
+                std::string p1 = modelDir + data.skin1 + ".blp";
+                score += assetManager->fileExists(p1) ? 30 : 3;
+            }
+            if (!data.skin2.empty()) {
+                std::string p2 = modelDir + data.skin2 + ".blp";
+                score += assetManager->fileExists(p2) ? 20 : 2;
+            }
+            if (!data.skin3.empty()) {
+                std::string p3 = modelDir + data.skin3 + ".blp";
+                score += assetManager->fileExists(p3) ? 10 : 1;
+            }
+            if (score > bestScore) {
+                bestScore = score;
+                dispData = data;
+                haveDisplayData = true;
+            }
+        }
+        if (haveDisplayData) {
+            LOG_INFO("Recovered mount display data by model path for displayId=", mountDisplayId,
+                     " skin1='", dispData.skin1, "' skin2='", dispData.skin2,
+                     "' skin3='", dispData.skin3, "'");
+        }
+    }
+    if (haveDisplayData) {
+        // If this displayId has no skins, try to find another displayId for the same model with skins.
+        if (dispData.skin1.empty() && dispData.skin2.empty() && dispData.skin3.empty()) {
+            uint32_t sourceModelId = dispData.modelId;
+            int bestScore = -1;
+            for (const auto& [dispId, data] : displayDataMap_) {
+                if (data.modelId != sourceModelId) continue;
+                int score = 0;
+                if (!data.skin1.empty()) {
+                    std::string p = modelDir + data.skin1 + ".blp";
+                    score += assetManager->fileExists(p) ? 30 : 3;
+                }
+                if (!data.skin2.empty()) {
+                    std::string p = modelDir + data.skin2 + ".blp";
+                    score += assetManager->fileExists(p) ? 20 : 2;
+                }
+                if (!data.skin3.empty()) {
+                    std::string p = modelDir + data.skin3 + ".blp";
+                    score += assetManager->fileExists(p) ? 10 : 1;
+                }
+                if (score > bestScore) {
+                    bestScore = score;
+                    dispData = data;
+                }
+            }
+            LOG_INFO("Mount skin fallback for displayId=", mountDisplayId,
+                     " modelId=", sourceModelId, " skin1='", dispData.skin1,
+                     "' skin2='", dispData.skin2, "' skin3='", dispData.skin3, "'");
+        }
+        const auto* md = charRenderer->getModelData(modelId);
+        if (md) {
+            LOG_INFO("Mount model textures: ", md->textures.size(), " slots, skin1='", dispData.skin1,
+                     "' skin2='", dispData.skin2, "' skin3='", dispData.skin3, "'");
+            for (size_t ti = 0; ti < md->textures.size(); ti++) {
+                LOG_INFO("  tex[", ti, "] type=", md->textures[ti].type,
+                         " filename='", md->textures[ti].filename, "'");
+            }
+
+            int replaced = 0;
+            for (size_t ti = 0; ti < md->textures.size(); ti++) {
+                const auto& tex = md->textures[ti];
+                std::string texPath;
+                if (tex.type == 11 && !dispData.skin1.empty()) {
+                    texPath = modelDir + dispData.skin1 + ".blp";
+                } else if (tex.type == 12 && !dispData.skin2.empty()) {
+                    texPath = modelDir + dispData.skin2 + ".blp";
+                } else if (tex.type == 13 && !dispData.skin3.empty()) {
+                    texPath = modelDir + dispData.skin3 + ".blp";
+                }
+                if (!texPath.empty()) {
+                    rendering::VkTexture* skinTex = charRenderer->loadTexture(texPath);
+                    if (skinTex) {
+                        charRenderer->setModelTexture(modelId, static_cast<uint32_t>(ti), skinTex);
+                        LOG_INFO("  Applied skin texture slot ", ti, ": ", texPath);
+                        replaced++;
+                    } else {
+                        LOG_WARNING("  Failed to load skin texture slot ", ti, ": ", texPath);
+                    }
+                }
+            }
+
+            // Force skin textures onto type-0 (hardcoded) slots that have no filename
+            if (replaced == 0) {
+                for (size_t ti = 0; ti < md->textures.size(); ti++) {
+                    const auto& tex = md->textures[ti];
+                    if (tex.type == 0 && tex.filename.empty()) {
+                        // Empty hardcoded slot — try skin1 then skin2
+                        std::string texPath;
+                        if (!dispData.skin1.empty() && replaced == 0) {
+                            texPath = modelDir + dispData.skin1 + ".blp";
+                        } else if (!dispData.skin2.empty()) {
+                            texPath = modelDir + dispData.skin2 + ".blp";
+                        }
+                        if (!texPath.empty()) {
+                            rendering::VkTexture* skinTex = charRenderer->loadTexture(texPath);
+                            if (skinTex) {
+                                charRenderer->setModelTexture(modelId, static_cast<uint32_t>(ti), skinTex);
+                                LOG_INFO("  Forced skin on empty hardcoded slot ", ti, ": ", texPath);
+                                replaced++;
+                            }
+                        }
+                    }
+                }
+            }
+
+            // If still no textures, try hardcoded model texture filenames
+            if (replaced == 0) {
+                for (size_t ti = 0; ti < md->textures.size(); ti++) {
+                    if (!md->textures[ti].filename.empty()) {
+                        rendering::VkTexture* texId = charRenderer->loadTexture(md->textures[ti].filename);
+                        if (texId) {
+                            charRenderer->setModelTexture(modelId, static_cast<uint32_t>(ti), texId);
+                            LOG_INFO("  Used model embedded texture slot ", ti, ": ", md->textures[ti].filename);
+                            replaced++;
+                        }
+                    }
+                }
+            }
+
+            // Final fallback for gryphon/wyvern: try well-known skin texture names
+            if (replaced == 0 && !md->textures.empty()) {
+                std::string lowerMountPath = m2Path;
+                std::transform(lowerMountPath.begin(), lowerMountPath.end(), lowerMountPath.begin(),
+                               [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+                if (lowerMountPath.find("gryphon") != std::string::npos) {
+                    const char* gryphonSkins[] = {
+                        "Creature\\Gryphon\\Gryphon_Skin.blp",
+                        "Creature\\Gryphon\\Gryphon_Skin01.blp",
+                        "Creature\\Gryphon\\GRYPHON_SKIN01.BLP",
+                        nullptr
+                    };
+                    for (const char** p = gryphonSkins; *p; ++p) {
+                        rendering::VkTexture* texId = charRenderer->loadTexture(*p);
+                        if (texId) {
+                            charRenderer->setModelTexture(modelId, 0, texId);
+                            LOG_INFO("  Forced gryphon skin fallback: ", *p);
+                            replaced++;
+                            break;
+                        }
+                    }
+                } else if (lowerMountPath.find("wyvern") != std::string::npos) {
+                    const char* wyvernSkins[] = {
+                        "Creature\\Wyvern\\Wyvern_Skin.blp",
+                        "Creature\\Wyvern\\Wyvern_Skin01.blp",
+                        nullptr
+                    };
+                    for (const char** p = wyvernSkins; *p; ++p) {
+                        rendering::VkTexture* texId = charRenderer->loadTexture(*p);
+                        if (texId) {
+                            charRenderer->setModelTexture(modelId, 0, texId);
+                            LOG_INFO("  Forced wyvern skin fallback: ", *p);
+                            replaced++;
+                            break;
+                        }
+                    }
+                }
+            }
+            LOG_INFO("Mount texture setup: ", replaced, " textures applied");
+        }
+    }
+
+    mountModelId_ = modelId;
+
+    // Create mount instance at player position
+    glm::vec3 mountPos = renderer->getCharacterPosition();
+    float yawRad = glm::radians(renderer->getCharacterYaw());
+    uint32_t instanceId = charRenderer->createInstance(modelId, mountPos,
+        glm::vec3(0.0f, 0.0f, yawRad), 1.0f);
+
+    if (instanceId == 0) {
+        LOG_WARNING("Failed to create mount instance");
+        return;
+    }
+
+    mountInstanceId_ = instanceId;
+
+    // Compute height offset — place player above mount's back
+    // Use tight bounds from actual vertices (M2 header bounds can be inaccurate)
+    const auto* modelData = charRenderer->getModelData(modelId);
+    float heightOffset = 1.8f;
+    if (modelData && !modelData->vertices.empty()) {
+        float minZ =  std::numeric_limits<float>::max();
+        float maxZ = -std::numeric_limits<float>::max();
+        for (const auto& v : modelData->vertices) {
+            if (v.position.z < minZ) minZ = v.position.z;
+            if (v.position.z > maxZ) maxZ = v.position.z;
+        }
+        float extentZ = maxZ - minZ;
+        LOG_INFO("Mount tight bounds: minZ=", minZ, " maxZ=", maxZ, " extentZ=", extentZ);
+        if (extentZ > 0.5f) {
+            // Saddle point is roughly 75% up the model, measured from model origin
+            heightOffset = maxZ * 0.8f;
+            if (heightOffset < 1.0f) heightOffset = extentZ * 0.75f;
+            if (heightOffset < 1.0f) heightOffset = 1.8f;
+        }
+    }
+
+    renderer->setMounted(instanceId, mountDisplayId, heightOffset, m2Path);
+
+    // For taxi mounts, start with flying animation; for ground mounts, start with stand
+    bool isTaxi = gameHandler && gameHandler->isOnTaxiFlight();
+    uint32_t startAnim = 0; // ANIM_STAND
+    if (isTaxi) {
+        // Try WotLK fly anims first, then Vanilla-friendly fallbacks
+        uint32_t taxiCandidates[] = {159, 158, 234, 229, 233, 141, 369, 6, 5}; // FlyForward, FlyIdle, FlyRun(234), FlyStand(229), FlyWalk(233), FlyMounted, FlyRun, Fly, Run
+        for (uint32_t anim : taxiCandidates) {
+            if (charRenderer->hasAnimation(instanceId, anim)) {
+                startAnim = anim;
+                break;
+            }
+        }
+        // If none found, startAnim stays 0 (Stand/hover) which is fine for flying creatures
+    }
+    charRenderer->playAnimation(instanceId, startAnim, true);
+
+    LOG_INFO("processPendingMount: DONE displayId=", mountDisplayId, " model=", m2Path, " heightOffset=", heightOffset);
+}
+
+void Application::despawnOnlineCreature(uint64_t guid) {
+    // If this guid is a PLAYER, it will be tracked in playerInstances_.
+    // Route to the correct despawn path so we don't leak instances.
+    if (playerInstances_.count(guid)) {
+        despawnOnlinePlayer(guid);
+        return;
+    }
+
+    pendingCreatureSpawnGuids_.erase(guid);
+    creatureSpawnRetryCounts_.erase(guid);
+    creaturePermanentFailureGuids_.erase(guid);
+    deadCreatureGuids_.erase(guid);
+
+    auto it = creatureInstances_.find(guid);
+    if (it == creatureInstances_.end()) return;
+
+    if (renderer && renderer->getCharacterRenderer()) {
+        renderer->getCharacterRenderer()->removeInstance(it->second);
+    }
+
+    creatureInstances_.erase(it);
+    creatureModelIds_.erase(guid);
+    creatureRenderPosCache_.erase(guid);
+    creatureWeaponsAttached_.erase(guid);
+    creatureWeaponAttachAttempts_.erase(guid);
+
+    LOG_DEBUG("Despawned creature: guid=0x", std::hex, guid, std::dec);
+}
+
+void Application::despawnOnlineGameObject(uint64_t guid) {
+    pendingTransportDoodadBatches_.erase(
+        std::remove_if(pendingTransportDoodadBatches_.begin(), pendingTransportDoodadBatches_.end(),
+                       [guid](const PendingTransportDoodadBatch& b) { return b.guid == guid; }),
+        pendingTransportDoodadBatches_.end());
+
+    auto it = gameObjectInstances_.find(guid);
+    if (it == gameObjectInstances_.end()) return;
+
+    if (renderer) {
+        if (it->second.isWmo) {
+            if (auto* wmoRenderer = renderer->getWMORenderer()) {
+                wmoRenderer->removeInstance(it->second.instanceId);
+            }
+        } else {
+            if (auto* m2Renderer = renderer->getM2Renderer()) {
+                m2Renderer->removeInstance(it->second.instanceId);
+            }
+        }
+    }
+
+    gameObjectInstances_.erase(it);
+
+    LOG_DEBUG("Despawned gameobject: guid=0x", std::hex, guid, std::dec);
 }
 
 void Application::loadQuestMarkerModels() {
@@ -4255,21 +8269,17 @@ void Application::updateQuestMarkers() {
         int markerType = -1;  // -1 = no marker
 
         using game::QuestGiverStatus;
-        float markerGrayscale = 0.0f;  // 0 = colour, 1 = grey (trivial quests)
         switch (status) {
             case QuestGiverStatus::AVAILABLE:
-                markerType = 0;  // Yellow !
-                break;
             case QuestGiverStatus::AVAILABLE_LOW:
-                markerType = 0;  // Grey ! (same texture, desaturated in shader)
-                markerGrayscale = 1.0f;
+                markerType = 0;  // Available (yellow !)
                 break;
             case QuestGiverStatus::REWARD:
             case QuestGiverStatus::REWARD_REP:
-                markerType = 1;  // Yellow ?
+                markerType = 1;  // Turn-in (yellow ?)
                 break;
             case QuestGiverStatus::INCOMPLETE:
-                markerType = 2;  // Grey ?
+                markerType = 2;  // Incomplete (grey ?)
                 break;
             default:
                 break;
@@ -4303,7 +8313,7 @@ void Application::updateQuestMarkers() {
         }
 
         // Set the marker (renderer will handle positioning, bob, glow, etc.)
-        questMarkerRenderer->setMarker(guid, renderPos, markerType, boundingHeight, markerGrayscale);
+        questMarkerRenderer->setMarker(guid, renderPos, markerType, boundingHeight);
         markersAdded++;
     }
 
@@ -4314,8 +8324,7 @@ void Application::updateQuestMarkers() {
 }
 
 void Application::setupTestTransport() {
-    if (!entitySpawner_) return;
-    if (entitySpawner_->isTestTransportSetup()) return;
+    if (testTransportSetup_) return;
     if (!gameHandler || !renderer || !assetManager) return;
 
     auto* transportManager = gameHandler->getTransportManager();
@@ -4442,7 +8451,7 @@ void Application::setupTestTransport() {
                                     glm::vec3(-15.0f, -30.0f, 0.0f),
                                     glm::vec3(15.0f, 30.0f, 10.0f));
 
-    entitySpawner_->setTestTransportSetup(true);
+    testTransportSetup_ = true;
     LOG_INFO("========================================");
     LOG_INFO("Test transport registered:");
     LOG_INFO("  GUID: 0x", std::hex, transportGuid, std::dec);
@@ -4458,5 +8467,121 @@ void Application::setupTestTransport() {
     LOG_INFO("========================================");
 }
 
+// ─── World Preloader ─────────────────────────────────────────────────────────
+// Pre-warms AssetManager file cache with ADT files (and their _obj0 variants)
+// for tiles around the expected spawn position.  Runs in background so that
+// when loadOnlineWorldTerrain eventually asks TerrainManager workers to parse
+// the same files, every readFile() is an instant cache hit instead of disk I/O.
+
+void Application::startWorldPreload(uint32_t mapId, const std::string& mapName,
+                                     float serverX, float serverY) {
+    cancelWorldPreload();
+    if (!assetManager || !assetManager->isInitialized() || mapName.empty()) return;
+
+    glm::vec3 canonical = core::coords::serverToCanonical(glm::vec3(serverX, serverY, 0.0f));
+    auto [tileX, tileY] = core::coords::canonicalToTile(canonical.x, canonical.y);
+
+    worldPreload_ = std::make_unique<WorldPreload>();
+    worldPreload_->mapId = mapId;
+    worldPreload_->mapName = mapName;
+    worldPreload_->centerTileX = tileX;
+    worldPreload_->centerTileY = tileY;
+
+    LOG_INFO("World preload: starting for map '", mapName, "' tile [", tileX, ",", tileY, "]");
+
+    // Build list of tiles to preload (radius 1 = 3x3 = 9 tiles, matching load screen)
+    struct TileJob { int x, y; };
+    auto jobs = std::make_shared<std::vector<TileJob>>();
+    // Center tile first (most important)
+    jobs->push_back({tileX, tileY});
+    for (int dx = -1; dx <= 1; dx++) {
+        for (int dy = -1; dy <= 1; dy++) {
+            if (dx == 0 && dy == 0) continue;
+            int tx = tileX + dx, ty = tileY + dy;
+            if (tx < 0 || tx > 63 || ty < 0 || ty > 63) continue;
+            jobs->push_back({tx, ty});
+        }
+    }
+
+    // Spawn worker threads (one per tile for maximum parallelism)
+    auto cancelFlag = &worldPreload_->cancel;
+    auto* am = assetManager.get();
+    std::string mn = mapName;
+
+    int numWorkers = std::min(static_cast<int>(jobs->size()), 4);
+    auto nextJob = std::make_shared<std::atomic<int>>(0);
+
+    for (int w = 0; w < numWorkers; w++) {
+        worldPreload_->workers.emplace_back([am, mn, jobs, nextJob, cancelFlag]() {
+            while (!cancelFlag->load(std::memory_order_relaxed)) {
+                int idx = nextJob->fetch_add(1, std::memory_order_relaxed);
+                if (idx >= static_cast<int>(jobs->size())) break;
+
+                int tx = (*jobs)[idx].x;
+                int ty = (*jobs)[idx].y;
+
+                // Read ADT file (warms file cache)
+                std::string adtPath = "World\\Maps\\" + mn + "\\" + mn + "_" +
+                                      std::to_string(tx) + "_" + std::to_string(ty) + ".adt";
+                am->readFile(adtPath);
+                if (cancelFlag->load(std::memory_order_relaxed)) break;
+
+                // Read obj0 variant
+                std::string objPath = "World\\Maps\\" + mn + "\\" + mn + "_" +
+                                      std::to_string(tx) + "_" + std::to_string(ty) + "_obj0.adt";
+                am->readFile(objPath);
+            }
+            LOG_DEBUG("World preload worker finished");
+        });
+    }
+}
+
+void Application::cancelWorldPreload() {
+    if (!worldPreload_) return;
+    worldPreload_->cancel.store(true, std::memory_order_relaxed);
+    for (auto& t : worldPreload_->workers) {
+        if (t.joinable()) t.join();
+    }
+    LOG_INFO("World preload: cancelled (map=", worldPreload_->mapName,
+             " tile=[", worldPreload_->centerTileX, ",", worldPreload_->centerTileY, "])");
+    worldPreload_.reset();
+}
+
+void Application::saveLastWorldInfo(uint32_t mapId, const std::string& mapName,
+                                     float serverX, float serverY) {
+#ifdef _WIN32
+    const char* base = std::getenv("APPDATA");
+    std::string dir = base ? std::string(base) + "\\wowee" : ".";
+#else
+    const char* home = std::getenv("HOME");
+    std::string dir = home ? std::string(home) + "/.wowee" : ".";
+#endif
+    std::filesystem::create_directories(dir);
+    std::ofstream f(dir + "/last_world.cfg");
+    if (f) {
+        f << mapId << "\n" << mapName << "\n" << serverX << "\n" << serverY << "\n";
+    }
+}
+
+Application::LastWorldInfo Application::loadLastWorldInfo() const {
+#ifdef _WIN32
+    const char* base = std::getenv("APPDATA");
+    std::string dir = base ? std::string(base) + "\\wowee" : ".";
+#else
+    const char* home = std::getenv("HOME");
+    std::string dir = home ? std::string(home) + "/.wowee" : ".";
+#endif
+    LastWorldInfo info;
+    std::ifstream f(dir + "/last_world.cfg");
+    if (!f) return info;
+    std::string line;
+    if (std::getline(f, line)) info.mapId = static_cast<uint32_t>(std::stoul(line));
+    if (std::getline(f, line)) info.mapName = line;
+    if (std::getline(f, line)) info.x = std::stof(line);
+    if (std::getline(f, line)) info.y = std::stof(line);
+    info.valid = !info.mapName.empty();
+    return info;
+}
+
 } // namespace core
 } // namespace wowee
diff --git a/src/core/entity_spawner.cpp b/src/core/entity_spawner.cpp
deleted file mode 100644
index b745bb85..00000000
--- a/src/core/entity_spawner.cpp
+++ /dev/null
@@ -1,5012 +0,0 @@
-#include "core/entity_spawner.hpp"
-#include "core/coordinates.hpp"
-#include "core/logger.hpp"
-#include "rendering/renderer.hpp"
-#include "rendering/vk_context.hpp"
-#include "rendering/character_renderer.hpp"
-#include "rendering/wmo_renderer.hpp"
-#include "rendering/m2_renderer.hpp"
-#include "audio/npc_voice_manager.hpp"
-#include "pipeline/m2_loader.hpp"
-#include "pipeline/wmo_loader.hpp"
-#include "rendering/animation/animation_ids.hpp"
-#include "pipeline/dbc_loader.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "pipeline/dbc_layout.hpp"
-#include "game/game_handler.hpp"
-#include "game/game_services.hpp"
-#include "game/transport_manager.hpp"
-
-#include <cmath>
-#include <algorithm>
-#include <cctype>
-#include <sstream>
-#include <cstring>
-
-namespace wowee {
-namespace core {
-
-namespace {
-// Default (bare) geoset IDs per equipment group.
-// Each group's base is groupNumber * 100; variant 01 is typically bare/default.
-constexpr uint16_t kGeosetDefaultConnector = 101;   // Group  1: default hair connector
-constexpr uint16_t kGeosetBareForearms     = 401;   // Group  4: no gloves
-constexpr uint16_t kGeosetBareShins        = 503;   // Group  5: no boots
-constexpr uint16_t kGeosetDefaultEars      = 702;   // Group  7: ears
-constexpr uint16_t kGeosetBareSleeves      = 801;   // Group  8: no chest armor sleeves
-constexpr uint16_t kGeosetDefaultKneepads  = 902;   // Group  9: kneepads
-constexpr uint16_t kGeosetDefaultTabard    = 1201;  // Group 12: tabard base
-constexpr uint16_t kGeosetBarePants        = 1301;  // Group 13: no leggings
-constexpr uint16_t kGeosetNoCape           = 1501;  // Group 15: no cape
-constexpr uint16_t kGeosetWithCape         = 1502;  // Group 15: with cape
-constexpr uint16_t kGeosetBareFeet         = 2002;  // Group 20: bare feet
-} // namespace
-
-// --- Constructor / Destructor ---
-
-EntitySpawner::EntitySpawner(rendering::Renderer* renderer,
-                             pipeline::AssetManager* assetManager,
-                             game::GameHandler* gameHandler,
-                             pipeline::DBCLayout* dbcLayout,
-                             game::GameServices* gameServices)
-    : renderer_(renderer)
-    , assetManager_(assetManager)
-    , gameHandler_(gameHandler)
-    , dbcLayout_(dbcLayout)
-    , gameServices_(gameServices)
-{
-}
-
-EntitySpawner::~EntitySpawner() = default;
-
-// --- Lifecycle ---
-
-void EntitySpawner::initialize() {
-    buildCharSectionsCache();
-    buildCreatureDisplayLookups();
-    buildGameObjectDisplayLookups();
-}
-
-void EntitySpawner::update() {
-    processPlayerSpawnQueue();
-    processCreatureSpawnQueue();
-    processAsyncNpcCompositeResults();
-    processDeferredEquipmentQueue();
-    processGameObjectSpawnQueue();
-    processPendingTransportRegistrations();
-    processPendingTransportDoodads();
-    processPendingMount();
-}
-
-void EntitySpawner::shutdown() {
-    clearAllQueues();
-    // Clear all instances
-    creatureInstances_.clear();
-    creatureModelIds_.clear();
-    creatureRenderPosCache_.clear();
-    creatureWasMoving_.clear();
-    creatureWasSwimming_.clear();
-    creatureWasFlying_.clear();
-    creatureWasWalking_.clear();
-    creatureSwimmingState_.clear();
-    creatureWalkingState_.clear();
-    creatureFlyingState_.clear();
-    creatureWeaponsAttached_.clear();
-    creatureWeaponAttachAttempts_.clear();
-    playerInstances_.clear();
-    onlinePlayerAppearance_.clear();
-    gameObjectInstances_.clear();
-}
-
-void EntitySpawner::resetAllState() {
-    // Wait for in-flight async loads before clearing state
-    for (auto& load : asyncCreatureLoads_) {
-        if (load.future.valid()) load.future.wait();
-    }
-
-    // Despawn all entities (renderer cleanup)
-    despawnAllCreatures();
-    despawnAllPlayers();
-    despawnAllGameObjects();
-    clearMountState();
-
-    // Clear all queues and async loads
-    clearAllQueues();
-
-    // Clear all instance tracking
-    creatureInstances_.clear();
-    creatureModelIds_.clear();
-    creatureRenderPosCache_.clear();
-    playerInstances_.clear();
-    onlinePlayerAppearance_.clear();
-    gameObjectInstances_.clear();
-
-    // Clear animation state maps
-    creatureWasMoving_.clear();
-    creatureWasSwimming_.clear();
-    creatureWasFlying_.clear();
-    creatureWasWalking_.clear();
-    creatureSwimmingState_.clear();
-    creatureWalkingState_.clear();
-    creatureFlyingState_.clear();
-    creatureWeaponsAttached_.clear();
-    creatureWeaponAttachAttempts_.clear();
-    modelIdIsWolfLike_.clear();
-
-    // Clear display/spawn caches
-    nonRenderableCreatureDisplayIds_.clear();
-    displayIdTexturesApplied_.clear();
-    charSectionsCache_.clear();
-    charSectionsCacheBuilt_ = false;
-
-    // Clear GO display caches
-    gameObjectDisplayIdModelCache_.clear();
-    gameObjectDisplayIdWmoCache_.clear();
-    gameObjectDisplayIdFailedCache_.clear();
-}
-
-void EntitySpawner::rebuildLookups() {
-    creatureLookupsBuilt_ = false;
-    displayDataMap_.clear();
-    humanoidExtraMap_.clear();
-    creatureModelIds_.clear();
-    creatureRenderPosCache_.clear();
-    nonRenderableCreatureDisplayIds_.clear();
-    initialize();
-}
-
-bool EntitySpawner::hasWorkPending() const {
-    return !pendingCreatureSpawns_.empty() || !asyncCreatureLoads_.empty() ||
-           !asyncNpcCompositeLoads_.empty() || !pendingPlayerSpawns_.empty() ||
-           !asyncEquipmentLoads_.empty() || !deferredEquipmentQueue_.empty() ||
-           !pendingGameObjectSpawns_.empty() || !asyncGameObjectLoads_.empty();
-}
-
-void EntitySpawner::clearMountState() {
-    if (mountInstanceId_ != 0 && renderer_) {
-        if (auto* charRenderer = renderer_->getCharacterRenderer()) {
-            charRenderer->removeInstance(mountInstanceId_);
-        }
-    }
-    mountInstanceId_ = 0;
-    mountModelId_ = 0;
-    pendingMountDisplayId_ = 0;
-}
-
-void EntitySpawner::queueTransportRegistration(uint64_t guid, uint32_t entry, uint32_t displayId,
-                                                float x, float y, float z, float orientation) {
-    pendingTransportRegistrations_.push_back({guid, entry, displayId, x, y, z, orientation});
-}
-
-void EntitySpawner::setTransportPendingMove(uint64_t guid, float x, float y, float z, float orientation) {
-    pendingTransportMoves_[guid] = {x, y, z, orientation};
-}
-
-bool EntitySpawner::hasTransportRegistrationPending(uint64_t guid) const {
-    return std::any_of(pendingTransportRegistrations_.begin(), pendingTransportRegistrations_.end(),
-                       [guid](const PendingTransportRegistration& reg) { return reg.guid == guid; });
-}
-
-void EntitySpawner::updateTransportRegistration(uint64_t guid, uint32_t displayId,
-                                                 float x, float y, float z, float orientation) {
-    for (auto& reg : pendingTransportRegistrations_) {
-        if (reg.guid == guid) {
-            reg.displayId = displayId;
-            reg.x = x; reg.y = y; reg.z = z; reg.orientation = orientation;
-            return;
-        }
-    }
-}
-
-// --- Queue API ---
-
-void EntitySpawner::queueCreatureSpawn(uint64_t guid, uint32_t displayId,
-                                        float x, float y, float z, float orientation, float scale) {
-    if (creatureInstances_.count(guid)) return;
-    if (pendingCreatureSpawnGuids_.count(guid)) return;
-    pendingCreatureSpawns_.push_back({guid, displayId, x, y, z, orientation, scale});
-    pendingCreatureSpawnGuids_.insert(guid);
-}
-
-void EntitySpawner::queuePlayerSpawn(uint64_t guid, uint8_t raceId, uint8_t genderId,
-                                      uint32_t appearanceBytes, uint8_t facialFeatures,
-                                      float x, float y, float z, float orientation) {
-    if (playerInstances_.count(guid)) return;
-    if (pendingPlayerSpawnGuids_.count(guid)) return;
-    pendingPlayerSpawns_.push_back({guid, raceId, genderId, appearanceBytes, facialFeatures, x, y, z, orientation});
-    pendingPlayerSpawnGuids_.insert(guid);
-}
-
-void EntitySpawner::queueGameObjectSpawn(uint64_t guid, uint32_t entry, uint32_t displayId,
-                                          float x, float y, float z, float orientation, float scale) {
-    pendingGameObjectSpawns_.push_back({guid, entry, displayId, x, y, z, orientation, scale});
-}
-
-void EntitySpawner::queuePlayerEquipment(uint64_t guid,
-                                          const std::array<uint32_t, 19>& displayInfoIds,
-                                          const std::array<uint8_t, 19>& inventoryTypes) {
-    deferredEquipmentQueue_.push_back({guid, {displayInfoIds, inventoryTypes}});
-}
-
-// --- Immediate despawn wrappers ---
-
-void EntitySpawner::clearAllQueues() {
-    pendingCreatureSpawns_.clear();
-    pendingCreatureSpawnGuids_.clear();
-    creatureSpawnRetryCounts_.clear();
-    creaturePermanentFailureGuids_.clear();
-    deadCreatureGuids_.clear();
-    pendingPlayerSpawns_.clear();
-    pendingPlayerSpawnGuids_.clear();
-    pendingOnlinePlayerEquipment_.clear();
-    deferredEquipmentQueue_.clear();
-    pendingGameObjectSpawns_.clear();
-    pendingTransportRegistrations_.clear();
-    pendingTransportMoves_.clear();
-    pendingTransportDoodadBatches_.clear();
-    asyncCreatureLoads_.clear();
-    asyncCreatureDisplayLoads_.clear();
-    asyncEquipmentLoads_.clear();
-    asyncNpcCompositeLoads_.clear();
-    asyncGameObjectLoads_.clear();
-}
-
-void EntitySpawner::despawnAllCreatures() {
-    std::vector<uint64_t> guids;
-    guids.reserve(creatureInstances_.size());
-    for (const auto& [g, _] : creatureInstances_) guids.push_back(g);
-    for (auto g : guids) despawnCreature(g);
-}
-
-void EntitySpawner::despawnAllPlayers() {
-    std::vector<uint64_t> guids;
-    guids.reserve(playerInstances_.size());
-    for (const auto& [g, _] : playerInstances_) guids.push_back(g);
-    for (auto g : guids) despawnPlayer(g);
-}
-
-void EntitySpawner::despawnAllGameObjects() {
-    std::vector<uint64_t> guids;
-    guids.reserve(gameObjectInstances_.size());
-    for (const auto& [g, _] : gameObjectInstances_) guids.push_back(g);
-    for (auto g : guids) despawnGameObject(g);
-}
-
-// --- Methods extracted from Application (with comments preserved) ---
-
-bool EntitySpawner::tryAttachCreatureVirtualWeapons(uint64_t guid, uint32_t instanceId) {
-    if (!renderer_ || !renderer_->getCharacterRenderer() || !assetManager_ || !gameHandler_) return false;
-    auto* charRenderer = renderer_->getCharacterRenderer();
-    if (!charRenderer) return false;
-
-    auto entity = gameHandler_->getEntityManager().getEntity(guid);
-    if (!entity || entity->getType() != game::ObjectType::UNIT) return false;
-    auto unit = std::static_pointer_cast<game::Unit>(entity);
-    if (!unit) return false;
-
-    // Virtual weapons are only appropriate for humanoid-style displays.
-    // Non-humanoids (wolves/boars/etc.) can expose non-zero virtual item fields
-    // and otherwise end up with comedic floating weapons.
-    uint32_t displayId = unit->getDisplayId();
-    auto dIt = displayDataMap_.find(displayId);
-    if (dIt == displayDataMap_.end()) return false;
-    uint32_t extraDisplayId = dIt->second.extraDisplayId;
-    if (extraDisplayId == 0 || humanoidExtraMap_.find(extraDisplayId) == humanoidExtraMap_.end()) {
-        return false;
-    }
-
-    auto itemDisplayDbc = assetManager_->loadDBC("ItemDisplayInfo.dbc");
-    if (!itemDisplayDbc) return false;
-    // Item.dbc is not distributed to clients in Vanilla 1.12; on those expansions
-    // item display IDs are resolved via the server-sent item cache instead.
-    auto itemDbc = assetManager_->loadDBCOptional("Item.dbc");
-    const auto* idiL = pipeline::getActiveDBCLayout()
-        ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
-    const auto* itemL = pipeline::getActiveDBCLayout()
-        ? pipeline::getActiveDBCLayout()->getLayout("Item") : nullptr;
-
-    auto resolveDisplayInfoId = [&](uint32_t rawId) -> uint32_t {
-        if (rawId == 0) return 0;
-        // Primary path: AzerothCore uses item entries in UNIT_VIRTUAL_ITEM_SLOT_ID.
-        // Resolve strictly through Item.dbc entry -> DisplayID to avoid
-        // accidental ItemDisplayInfo ID collisions (staff/hilt mismatches).
-        if (itemDbc) {
-            int32_t itemRec = itemDbc->findRecordById(rawId); // treat as item entry
-            if (itemRec >= 0) {
-                const uint32_t dispFieldPrimary = itemL ? (*itemL)["DisplayID"] : 5u;
-                uint32_t displayIdA = itemDbc->getUInt32(static_cast<uint32_t>(itemRec), dispFieldPrimary);
-                if (displayIdA != 0 && itemDisplayDbc->findRecordById(displayIdA) >= 0) {
-                    return displayIdA;
-                }
-            }
-        }
-        // Fallback: Vanilla 1.12 does not distribute Item.dbc to clients.
-        // Items arrive via SMSG_ITEM_QUERY_SINGLE_RESPONSE and are cached in
-        // itemInfoCache_. Use the server-sent displayInfoId when available.
-        if (!itemDbc && gameHandler_) {
-            if (const auto* info = gameHandler_->getItemInfo(rawId)) {
-                uint32_t displayIdB = info->displayInfoId;
-                if (displayIdB != 0 && itemDisplayDbc->findRecordById(displayIdB) >= 0) {
-                    return displayIdB;
-                }
-            }
-        }
-        return 0;
-    };
-
-    auto attachNpcWeaponDisplay = [&](uint32_t itemDisplayId, uint32_t attachmentId) -> bool {
-        uint32_t resolvedDisplayId = resolveDisplayInfoId(itemDisplayId);
-        if (resolvedDisplayId == 0) return false;
-        int32_t recIdx = itemDisplayDbc->findRecordById(resolvedDisplayId);
-        if (recIdx < 0) return false;
-
-        const uint32_t modelFieldL = idiL ? (*idiL)["LeftModel"] : 1u;
-        const uint32_t modelFieldR = idiL ? (*idiL)["RightModel"] : 2u;
-        const uint32_t texFieldL = idiL ? (*idiL)["LeftModelTexture"] : 3u;
-        const uint32_t texFieldR = idiL ? (*idiL)["RightModelTexture"] : 4u;
-        // Prefer LeftModel (stock player equipment path uses LeftModel and avoids
-        // the "hilt-only" variants seen when forcing RightModel).
-        std::string modelName = itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), modelFieldL);
-        std::string textureName = itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), texFieldL);
-        if (modelName.empty()) {
-            modelName = itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), modelFieldR);
-            textureName = itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), texFieldR);
-        }
-        if (modelName.empty()) return false;
-
-        std::string modelFile = modelName;
-        size_t dotPos = modelFile.rfind('.');
-        if (dotPos != std::string::npos) modelFile = modelFile.substr(0, dotPos);
-        modelFile += ".m2";
-
-        // Main-hand NPC weapon path: only use actual weapon models.
-        std::string m2Path = "Item\\ObjectComponents\\Weapon\\" + modelFile;
-        pipeline::M2Model weaponModel;
-        if (!loadWeaponM2(m2Path, weaponModel)) return false;
-
-        std::string texturePath;
-        if (!textureName.empty()) {
-            texturePath = "Item\\ObjectComponents\\Weapon\\" + textureName + ".blp";
-            if (!assetManager_->fileExists(texturePath)) texturePath.clear();
-        }
-
-        uint32_t weaponModelId = nextWeaponModelId_++;
-        return charRenderer->attachWeapon(instanceId, attachmentId, weaponModel, weaponModelId, texturePath);
-    };
-
-    auto hasResolvableWeaponModel = [&](uint32_t itemDisplayId) -> bool {
-        uint32_t resolvedDisplayId = resolveDisplayInfoId(itemDisplayId);
-        if (resolvedDisplayId == 0) return false;
-        int32_t recIdx = itemDisplayDbc->findRecordById(resolvedDisplayId);
-        if (recIdx < 0) return false;
-        const uint32_t modelFieldL = idiL ? (*idiL)["LeftModel"] : 1u;
-        const uint32_t modelFieldR = idiL ? (*idiL)["RightModel"] : 2u;
-        std::string modelName = itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), modelFieldL);
-        if (modelName.empty()) {
-            modelName = itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), modelFieldR);
-        }
-        if (modelName.empty()) return false;
-        std::string modelFile = modelName;
-        size_t dotPos = modelFile.rfind('.');
-        if (dotPos != std::string::npos) modelFile = modelFile.substr(0, dotPos);
-        modelFile += ".m2";
-        return assetManager_->fileExists("Item\\ObjectComponents\\Weapon\\" + modelFile);
-    };
-
-    bool attachedMain = false;
-    bool hadWeaponCandidate = false;
-
-    const uint16_t candidateBases[] = {56, 57, 58, 70, 148, 149, 150, 151, 152};
-    for (uint16_t base : candidateBases) {
-        uint32_t v0 = entity->getField(static_cast<uint16_t>(base + 0));
-        if (v0 != 0) hadWeaponCandidate = true;
-        if (!attachedMain && v0 != 0) attachedMain = attachNpcWeaponDisplay(v0, 1);
-        if (attachedMain) break;
-    }
-
-    uint16_t unitEnd = game::fieldIndex(game::UF::UNIT_END);
-    uint16_t scanLo = 60;
-    uint16_t scanHi = (unitEnd != 0xFFFF) ? static_cast<uint16_t>(unitEnd + 96) : 320;
-    std::map<uint16_t, uint32_t> candidateByIndex;
-    for (const auto& [idx, val] : entity->getFields()) {
-        if (idx < scanLo || idx > scanHi) continue;
-        if (val == 0) continue;
-        if (hasResolvableWeaponModel(val)) {
-            candidateByIndex[idx] = val;
-            hadWeaponCandidate = true;
-        }
-    }
-    for (const auto& [idx, val] : candidateByIndex) {
-        if (!attachedMain) attachedMain = attachNpcWeaponDisplay(val, 1);
-        if (attachedMain) break;
-    }
-
-    // Force off-hand clear in NPC path to avoid incorrect shields/placeholder hilts.
-    charRenderer->detachWeapon(instanceId, 2);
-    // Success if main-hand attached when there was at least one candidate.
-    return hadWeaponCandidate && attachedMain;
-}
-
-
-void EntitySpawner::buildCharSectionsCache() {
-    if (charSectionsCacheBuilt_ || !assetManager_ || !assetManager_->isInitialized()) return;
-    auto dbc = assetManager_->loadDBC("CharSections.dbc");
-    if (!dbc) return;
-    const auto* csL = pipeline::getActiveDBCLayout()
-        ? pipeline::getActiveDBCLayout()->getLayout("CharSections") : nullptr;
-    auto csF = pipeline::detectCharSectionsFields(dbc.get(), csL);
-    for (uint32_t r = 0; r < dbc->getRecordCount(); r++) {
-        uint32_t race = dbc->getUInt32(r, csF.raceId);
-        uint32_t sex = dbc->getUInt32(r, csF.sexId);
-        uint32_t section = dbc->getUInt32(r, csF.baseSection);
-        uint32_t variation = dbc->getUInt32(r, csF.variationIndex);
-        uint32_t color = dbc->getUInt32(r, csF.colorIndex);
-        // We only cache sections 0 (skin), 1 (face), 3 (hair), 4 (underwear)
-        if (section != 0 && section != 1 && section != 3 && section != 4) continue;
-        for (int ti = 0; ti < 3; ti++) {
-            std::string tex = dbc->getString(r, csF.texture1 + ti);
-            if (tex.empty()) continue;
-            // Key: race(8)|sex(4)|section(4)|variation(8)|color(8)|texIndex(2) packed into 64 bits
-            uint64_t key = (static_cast<uint64_t>(race) << 26) |
-                           (static_cast<uint64_t>(sex & 0xF) << 22) |
-                           (static_cast<uint64_t>(section & 0xF) << 18) |
-                           (static_cast<uint64_t>(variation & 0xFF) << 10) |
-                           (static_cast<uint64_t>(color & 0xFF) << 2) |
-                           static_cast<uint64_t>(ti);
-            charSectionsCache_.emplace(key, tex);
-        }
-    }
-    charSectionsCacheBuilt_ = true;
-    LOG_INFO("CharSections cache built: ", charSectionsCache_.size(), " entries");
-}
-
-std::string EntitySpawner::lookupCharSection(uint8_t race, uint8_t sex, uint8_t section,
-                                           uint8_t variation, uint8_t color, int texIndex) const {
-    uint64_t key = (static_cast<uint64_t>(race) << 26) |
-                   (static_cast<uint64_t>(sex & 0xF) << 22) |
-                   (static_cast<uint64_t>(section & 0xF) << 18) |
-                   (static_cast<uint64_t>(variation & 0xFF) << 10) |
-                   (static_cast<uint64_t>(color & 0xFF) << 2) |
-                   static_cast<uint64_t>(texIndex);
-    auto it = charSectionsCache_.find(key);
-    return (it != charSectionsCache_.end()) ? it->second : std::string();
-}
-
-void EntitySpawner::buildCreatureDisplayLookups() {
-    if (creatureLookupsBuilt_ || !assetManager_ || !assetManager_->isInitialized()) return;
-
-    LOG_INFO("Building creature display lookups from DBC files");
-
-    // CreatureDisplayInfo.dbc structure (3.3.5a):
-    // Col 0: displayId
-    // Col 1: modelId
-    // Col 3: extendedDisplayInfoID (link to CreatureDisplayInfoExtra.dbc)
-    // Col 6: Skin1 (texture name)
-    // Col 7: Skin2
-    // Col 8: Skin3
-    if (auto cdi = assetManager_->loadDBC("CreatureDisplayInfo.dbc"); cdi && cdi->isLoaded()) {
-        const auto* cdiL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CreatureDisplayInfo") : nullptr;
-        for (uint32_t i = 0; i < cdi->getRecordCount(); i++) {
-            CreatureDisplayData data;
-            data.modelId = cdi->getUInt32(i, cdiL ? (*cdiL)["ModelID"] : 1);
-            data.extraDisplayId = cdi->getUInt32(i, cdiL ? (*cdiL)["ExtraDisplayId"] : 3);
-            data.skin1 = cdi->getString(i, cdiL ? (*cdiL)["Skin1"] : 6);
-            data.skin2 = cdi->getString(i, cdiL ? (*cdiL)["Skin2"] : 7);
-            data.skin3 = cdi->getString(i, cdiL ? (*cdiL)["Skin3"] : 8);
-            displayDataMap_[cdi->getUInt32(i, cdiL ? (*cdiL)["ID"] : 0)] = data;
-        }
-        LOG_INFO("Loaded ", displayDataMap_.size(), " display→model mappings");
-    }
-
-    // CreatureDisplayInfoExtra.dbc structure (3.3.5a):
-    // Col 0: ID
-    // Col 1: DisplayRaceID
-    // Col 2: DisplaySexID
-    // Col 3: SkinID
-    // Col 4: FaceID
-    // Col 5: HairStyleID
-    // Col 6: HairColorID
-    // Col 7: FacialHairID
-    // CreatureDisplayInfoExtra.dbc field layout depends on actual field count:
-    //   19 fields: 10 equip slots (8-17), BakeName=18 (no Flags field)
-    //   21 fields: 11 equip slots (8-18), Flags=19, BakeName=20
-    if (auto cdie = assetManager_->loadDBC("CreatureDisplayInfoExtra.dbc"); cdie && cdie->isLoaded()) {
-        const auto* cdieL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CreatureDisplayInfoExtra") : nullptr;
-        const uint32_t cdieEquip0 = cdieL ? (*cdieL)["EquipDisplay0"] : 8;
-        // Detect actual field count to determine equip slot count and BakeName position
-        const uint32_t dbcFieldCount = cdie->getFieldCount();
-        int numEquipSlots;
-        uint32_t bakeField;
-        if (dbcFieldCount <= 19) {
-            // 19 fields: 10 equip slots (8-17), BakeName at 18
-            numEquipSlots = 10;
-            bakeField = 18;
-        } else {
-            // 21 fields: 11 equip slots (8-18), Flags=19, BakeName=20
-            numEquipSlots = 11;
-            bakeField = cdieL ? (*cdieL)["BakeName"] : 20;
-        }
-        uint32_t withBakeName = 0;
-        for (uint32_t i = 0; i < cdie->getRecordCount(); i++) {
-            HumanoidDisplayExtra extra;
-            extra.raceId = static_cast<uint8_t>(cdie->getUInt32(i, cdieL ? (*cdieL)["RaceID"] : 1));
-            extra.sexId = static_cast<uint8_t>(cdie->getUInt32(i, cdieL ? (*cdieL)["SexID"] : 2));
-            extra.skinId = static_cast<uint8_t>(cdie->getUInt32(i, cdieL ? (*cdieL)["SkinID"] : 3));
-            extra.faceId = static_cast<uint8_t>(cdie->getUInt32(i, cdieL ? (*cdieL)["FaceID"] : 4));
-            extra.hairStyleId = static_cast<uint8_t>(cdie->getUInt32(i, cdieL ? (*cdieL)["HairStyleID"] : 5));
-            extra.hairColorId = static_cast<uint8_t>(cdie->getUInt32(i, cdieL ? (*cdieL)["HairColorID"] : 6));
-            extra.facialHairId = static_cast<uint8_t>(cdie->getUInt32(i, cdieL ? (*cdieL)["FacialHairID"] : 7));
-            for (int eq = 0; eq < numEquipSlots; eq++) {
-                extra.equipDisplayId[eq] = cdie->getUInt32(i, cdieEquip0 + eq);
-            }
-            extra.bakeName = cdie->getString(i, bakeField);
-            if (!extra.bakeName.empty()) withBakeName++;
-            humanoidExtraMap_[cdie->getUInt32(i, cdieL ? (*cdieL)["ID"] : 0)] = extra;
-        }
-        LOG_WARNING("Loaded ", humanoidExtraMap_.size(), " humanoid display extra entries (",
-                 withBakeName, " with baked textures, ", numEquipSlots, " equip slots, ",
-                 dbcFieldCount, " DBC fields, bakeField=", bakeField, ")");
-    }
-
-    // CreatureModelData.dbc: modelId (col 0) → modelPath (col 2, .mdx → .m2)
-    if (auto cmd = assetManager_->loadDBC("CreatureModelData.dbc"); cmd && cmd->isLoaded()) {
-        const auto* cmdL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CreatureModelData") : nullptr;
-        for (uint32_t i = 0; i < cmd->getRecordCount(); i++) {
-            std::string mdx = cmd->getString(i, cmdL ? (*cmdL)["ModelPath"] : 2);
-            if (mdx.empty()) continue;
-            if (mdx.size() >= 4) {
-                mdx = mdx.substr(0, mdx.size() - 4) + ".m2";
-            }
-            modelIdToPath_[cmd->getUInt32(i, cmdL ? (*cmdL)["ID"] : 0)] = mdx;
-        }
-        LOG_INFO("Loaded ", modelIdToPath_.size(), " model→path mappings");
-    }
-
-    // Resolve gryphon/wyvern display IDs by exact model path so taxi mounts have textures.
-    auto toLower = [](std::string s) {
-        for (char& c : s) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-        return s;
-    };
-    auto normalizePath = [&](const std::string& p) {
-        std::string s = p;
-        for (char& c : s) if (c == '/') c = '\\';
-        return toLower(s);
-    };
-    auto resolveDisplayIdForExactPath = [&](const std::string& exactPath) -> uint32_t {
-        const std::string target = normalizePath(exactPath);
-        // Collect ALL model IDs that map to this path (multiple model IDs can
-        // share the same .m2 file, e.g. modelId 147 and 792 both → Gryphon.m2)
-        std::vector<uint32_t> modelIds;
-        for (const auto& [mid, path] : modelIdToPath_) {
-            if (normalizePath(path) == target) {
-                modelIds.push_back(mid);
-            }
-        }
-        if (modelIds.empty()) return 0;
-        uint32_t bestDisplayId = 0;
-        int bestScore = -1;
-        for (const auto& [dispId, data] : displayDataMap_) {
-            bool matches = false;
-            for (uint32_t mid : modelIds) {
-                if (data.modelId == mid) { matches = true; break; }
-            }
-            if (!matches) continue;
-            int score = 0;
-            if (!data.skin1.empty()) score += 3;
-            if (!data.skin2.empty()) score += 2;
-            if (!data.skin3.empty()) score += 1;
-            if (score > bestScore) {
-                bestScore = score;
-                bestDisplayId = dispId;
-            }
-        }
-        return bestDisplayId;
-    };
-
-    gryphonDisplayId_ = resolveDisplayIdForExactPath("Creature\\Gryphon\\Gryphon.m2");
-    wyvernDisplayId_  = resolveDisplayIdForExactPath("Creature\\Wyvern\\Wyvern.m2");
-    gameServices_->gryphonDisplayId = gryphonDisplayId_;
-    gameServices_->wyvernDisplayId  = wyvernDisplayId_;
-    LOG_INFO("Taxi mount displayIds: gryphon=", gryphonDisplayId_, " wyvern=", wyvernDisplayId_);
-
-    // CharHairGeosets.dbc: maps (race, sex, hairStyleId) → skinSectionId for hair mesh
-    // Col 0: ID, Col 1: RaceID, Col 2: SexID, Col 3: VariationID, Col 4: GeosetID, Col 5: Showscalp
-    if (auto chg = assetManager_->loadDBC("CharHairGeosets.dbc"); chg && chg->isLoaded()) {
-        const auto* chgL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CharHairGeosets") : nullptr;
-        for (uint32_t i = 0; i < chg->getRecordCount(); i++) {
-            uint32_t raceId = chg->getUInt32(i, chgL ? (*chgL)["RaceID"] : 1);
-            uint32_t sexId = chg->getUInt32(i, chgL ? (*chgL)["SexID"] : 2);
-            uint32_t variation = chg->getUInt32(i, chgL ? (*chgL)["Variation"] : 3);
-            uint32_t geosetId = chg->getUInt32(i, chgL ? (*chgL)["GeosetID"] : 4);
-            uint32_t key = (raceId << 16) | (sexId << 8) | variation;
-            hairGeosetMap_[key] = static_cast<uint16_t>(geosetId);
-        }
-        LOG_INFO("Loaded ", hairGeosetMap_.size(), " hair geoset mappings from CharHairGeosets.dbc");
-    }
-
-    // CharacterFacialHairStyles.dbc: maps (race, sex, facialHairId) → geoset IDs
-    // No ID column: Col 0: RaceID, Col 1: SexID, Col 2: VariationID
-    // Col 3: Geoset100, Col 4: Geoset300, Col 5: Geoset200
-    if (auto cfh = assetManager_->loadDBC("CharacterFacialHairStyles.dbc"); cfh && cfh->isLoaded()) {
-        const auto* cfhL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CharacterFacialHairStyles") : nullptr;
-        for (uint32_t i = 0; i < cfh->getRecordCount(); i++) {
-            uint32_t raceId = cfh->getUInt32(i, cfhL ? (*cfhL)["RaceID"] : 0);
-            uint32_t sexId = cfh->getUInt32(i, cfhL ? (*cfhL)["SexID"] : 1);
-            uint32_t variation = cfh->getUInt32(i, cfhL ? (*cfhL)["Variation"] : 2);
-            uint32_t key = (raceId << 16) | (sexId << 8) | variation;
-            FacialHairGeosets fhg;
-            fhg.geoset100 = static_cast<uint16_t>(cfh->getUInt32(i, cfhL ? (*cfhL)["Geoset100"] : 3));
-            fhg.geoset300 = static_cast<uint16_t>(cfh->getUInt32(i, cfhL ? (*cfhL)["Geoset300"] : 4));
-            fhg.geoset200 = static_cast<uint16_t>(cfh->getUInt32(i, cfhL ? (*cfhL)["Geoset200"] : 5));
-            facialHairGeosetMap_[key] = fhg;
-        }
-        LOG_INFO("Loaded ", facialHairGeosetMap_.size(), " facial hair geoset mappings from CharacterFacialHairStyles.dbc");
-    }
-
-    creatureLookupsBuilt_ = true;
-}
-
-std::string EntitySpawner::getModelPathForDisplayId(uint32_t displayId) const {
-    if (displayId == 30412) return "Creature\\Gryphon\\Gryphon.m2";
-    if (displayId == 30413) return "Creature\\Wyvern\\Wyvern.m2";
-
-    // WotLK servers can send display IDs that do not exist in older/local
-    // CreatureDisplayInfo datasets. Keep those creatures visible by falling
-    // back to a close base model instead of dropping spawn entirely.
-    switch (displayId) {
-        case 31048: // Diseased Young Wolf variants (AzerothCore WotLK)
-        case 31049: // Diseased Wolf variants (AzerothCore WotLK)
-            return "Creature\\Wolf\\Wolf.m2";
-        default:
-            break;
-    }
-
-    auto itData = displayDataMap_.find(displayId);
-    if (itData == displayDataMap_.end()) {
-        // Some sources (e.g., taxi nodes) may provide a modelId directly.
-        auto itPath = modelIdToPath_.find(displayId);
-        if (itPath != modelIdToPath_.end()) {
-            return itPath->second;
-        }
-        if (displayId == 30412) return "Creature\\Gryphon\\Gryphon.m2";
-        if (displayId == 30413) return "Creature\\Wyvern\\Wyvern.m2";
-        if (warnedMissingDisplayDataIds_.insert(displayId).second) {
-            LOG_WARNING("No display data for displayId ", displayId,
-                        " (displayDataMap_ has ", displayDataMap_.size(), " entries)");
-        }
-        return "";
-    }
-
-    auto itPath = modelIdToPath_.find(itData->second.modelId);
-    if (itPath == modelIdToPath_.end()) {
-        if (warnedMissingModelPathIds_.insert(displayId).second) {
-            LOG_WARNING("No model path for modelId ", itData->second.modelId,
-                        " from displayId ", displayId,
-                        " (modelIdToPath_ has ", modelIdToPath_.size(), " entries)");
-        }
-        return "";
-    }
-
-    return itPath->second;
-}
-
-audio::VoiceType EntitySpawner::detectVoiceTypeFromDisplayId(uint32_t displayId) const {
-    // Look up display data
-    auto itDisplay = displayDataMap_.find(displayId);
-    if (itDisplay == displayDataMap_.end() || itDisplay->second.extraDisplayId == 0) {
-        LOG_INFO("Voice detection: displayId ", displayId, " -> GENERIC (no display data)");
-        return audio::VoiceType::GENERIC;  // Not a humanoid or no extra data
-    }
-
-    // Look up humanoid extra data (race/sex info)
-    auto itExtra = humanoidExtraMap_.find(itDisplay->second.extraDisplayId);
-    if (itExtra == humanoidExtraMap_.end()) {
-        LOG_INFO("Voice detection: displayId ", displayId, " -> GENERIC (no humanoid extra data)");
-        return audio::VoiceType::GENERIC;
-    }
-
-    uint8_t raceId = itExtra->second.raceId;
-    uint8_t sexId = itExtra->second.sexId;
-
-    const char* raceName = "Unknown";
-    const char* sexName = (sexId == 0) ? "Male" : "Female";
-
-    // Map (raceId, sexId) to VoiceType
-    // Race IDs: 1=Human, 2=Orc, 3=Dwarf, 4=NightElf, 5=Undead, 6=Tauren, 7=Gnome, 8=Troll
-    // Sex IDs: 0=Male, 1=Female
-    audio::VoiceType result;
-    switch (raceId) {
-        case 1: raceName = "Human"; result = (sexId == 0) ? audio::VoiceType::HUMAN_MALE : audio::VoiceType::HUMAN_FEMALE; break;
-        case 2: raceName = "Orc"; result = (sexId == 0) ? audio::VoiceType::ORC_MALE : audio::VoiceType::ORC_FEMALE; break;
-        case 3: raceName = "Dwarf"; result = (sexId == 0) ? audio::VoiceType::DWARF_MALE : audio::VoiceType::DWARF_FEMALE; break;
-        case 4: raceName = "NightElf"; result = (sexId == 0) ? audio::VoiceType::NIGHTELF_MALE : audio::VoiceType::NIGHTELF_FEMALE; break;
-        case 5: raceName = "Undead"; result = (sexId == 0) ? audio::VoiceType::UNDEAD_MALE : audio::VoiceType::UNDEAD_FEMALE; break;
-        case 6: raceName = "Tauren"; result = (sexId == 0) ? audio::VoiceType::TAUREN_MALE : audio::VoiceType::TAUREN_FEMALE; break;
-        case 7: raceName = "Gnome"; result = (sexId == 0) ? audio::VoiceType::GNOME_MALE : audio::VoiceType::GNOME_FEMALE; break;
-        case 8: raceName = "Troll"; result = (sexId == 0) ? audio::VoiceType::TROLL_MALE : audio::VoiceType::TROLL_FEMALE; break;
-        case 10: raceName = "BloodElf"; result = (sexId == 0) ? audio::VoiceType::BLOODELF_MALE : audio::VoiceType::BLOODELF_FEMALE; break;
-        case 11: raceName = "Draenei"; result = (sexId == 0) ? audio::VoiceType::DRAENEI_MALE : audio::VoiceType::DRAENEI_FEMALE; break;
-        default: result = audio::VoiceType::GENERIC; break;
-    }
-
-    LOG_INFO("Voice detection: displayId ", displayId, " -> ", raceName, " ", sexName, " (race=", static_cast<int>(raceId), ", sex=", static_cast<int>(sexId), ")");
-    return result;
-}
-
-void EntitySpawner::buildGameObjectDisplayLookups() {
-    if (gameObjectLookupsBuilt_ || !assetManager_ || !assetManager_->isInitialized()) return;
-
-    LOG_INFO("Building gameobject display lookups from DBC files");
-
-    // GameObjectDisplayInfo.dbc structure (3.3.5a):
-    // Col 0: ID (displayId)
-    // Col 1: ModelName
-    if (auto godi = assetManager_->loadDBC("GameObjectDisplayInfo.dbc"); godi && godi->isLoaded()) {
-        const auto* godiL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("GameObjectDisplayInfo") : nullptr;
-        for (uint32_t i = 0; i < godi->getRecordCount(); i++) {
-            uint32_t displayId = godi->getUInt32(i, godiL ? (*godiL)["ID"] : 0);
-            std::string modelName = godi->getString(i, godiL ? (*godiL)["ModelName"] : 1);
-            if (modelName.empty()) continue;
-            if (modelName.size() >= 4) {
-                std::string ext = modelName.substr(modelName.size() - 4);
-                for (char& c : ext) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                if (ext == ".mdx") {
-                    modelName = modelName.substr(0, modelName.size() - 4) + ".m2";
-                }
-            }
-            gameObjectDisplayIdToPath_[displayId] = modelName;
-        }
-        LOG_INFO("Loaded ", gameObjectDisplayIdToPath_.size(), " gameobject display mappings");
-    } else {
-        LOG_WARNING("GameObjectDisplayInfo.dbc failed to load — no GO display mappings available");
-    }
-
-    if (gameObjectDisplayIdToPath_.empty()) {
-        LOG_WARNING("GO display mapping table is EMPTY — game objects will not render");
-    }
-
-    gameObjectLookupsBuilt_ = true;
-}
-
-std::string EntitySpawner::getGameObjectModelPathForDisplayId(uint32_t displayId) const {
-    auto it = gameObjectDisplayIdToPath_.find(displayId);
-    if (it == gameObjectDisplayIdToPath_.end()) return "";
-    return it->second;
-}
-
-
-bool EntitySpawner::getRenderBoundsForGuid(uint64_t guid, glm::vec3& outCenter, float& outRadius) const {
-    if (!renderer_ || !renderer_->getCharacterRenderer()) return false;
-    uint32_t instanceId = 0;
-
-    if (gameHandler_ && guid == gameHandler_->getPlayerGuid()) {
-        instanceId = renderer_->getCharacterInstanceId();
-    }
-    if (instanceId == 0) {
-        auto pit = playerInstances_.find(guid);
-        if (pit != playerInstances_.end()) instanceId = pit->second;
-    }
-    if (instanceId == 0) {
-        auto it = creatureInstances_.find(guid);
-        if (it != creatureInstances_.end()) instanceId = it->second;
-    }
-    if (instanceId == 0) return false;
-
-    return renderer_->getCharacterRenderer()->getInstanceBounds(instanceId, outCenter, outRadius);
-}
-
-bool EntitySpawner::getRenderFootZForGuid(uint64_t guid, float& outFootZ) const {
-    if (!renderer_ || !renderer_->getCharacterRenderer()) return false;
-    uint32_t instanceId = 0;
-
-    if (gameHandler_ && guid == gameHandler_->getPlayerGuid()) {
-        instanceId = renderer_->getCharacterInstanceId();
-    }
-    if (instanceId == 0) {
-        auto pit = playerInstances_.find(guid);
-        if (pit != playerInstances_.end()) instanceId = pit->second;
-    }
-    if (instanceId == 0) {
-        auto it = creatureInstances_.find(guid);
-        if (it != creatureInstances_.end()) instanceId = it->second;
-    }
-    if (instanceId == 0) return false;
-
-    return renderer_->getCharacterRenderer()->getInstanceFootZ(instanceId, outFootZ);
-}
-
-bool EntitySpawner::getRenderPositionForGuid(uint64_t guid, glm::vec3& outPos) const {
-    if (!renderer_ || !renderer_->getCharacterRenderer()) return false;
-    uint32_t instanceId = 0;
-
-    if (gameHandler_ && guid == gameHandler_->getPlayerGuid()) {
-        instanceId = renderer_->getCharacterInstanceId();
-    }
-    if (instanceId == 0) {
-        auto pit = playerInstances_.find(guid);
-        if (pit != playerInstances_.end()) instanceId = pit->second;
-    }
-    if (instanceId == 0) {
-        auto it = creatureInstances_.find(guid);
-        if (it != creatureInstances_.end()) instanceId = it->second;
-    }
-    if (instanceId == 0) return false;
-
-    return renderer_->getCharacterRenderer()->getInstancePosition(instanceId, outPos);
-}
-
-
-pipeline::M2Model EntitySpawner::loadCreatureM2Sync(const std::string& m2Path) {
-    auto m2Data = assetManager_->readFile(m2Path);
-    if (m2Data.empty()) {
-        LOG_WARNING("Failed to read creature M2: ", m2Path);
-        return {};
-    }
-
-    pipeline::M2Model model = pipeline::M2Loader::load(m2Data);
-    if (model.vertices.empty()) {
-        LOG_WARNING("Failed to parse creature M2: ", m2Path);
-        return {};
-    }
-
-    // Load skin file (only for WotLK M2s - vanilla has embedded skin)
-    if (model.version >= 264) {
-        std::string skinPath = m2Path.substr(0, m2Path.size() - 3) + "00.skin";
-        auto skinData = assetManager_->readFile(skinPath);
-        if (!skinData.empty()) {
-            pipeline::M2Loader::loadSkin(skinData, model);
-        } else {
-            LOG_WARNING("Missing skin file for WotLK creature M2: ", skinPath);
-        }
-    }
-
-    // Load external .anim files for sequences without flag 0x20
-    std::string basePath = m2Path.substr(0, m2Path.size() - 3);
-    for (uint32_t si = 0; si < model.sequences.size(); si++) {
-        if (!(model.sequences[si].flags & 0x20)) {
-            char animFileName[256];
-            snprintf(animFileName, sizeof(animFileName), "%s%04u-%02u.anim",
-                basePath.c_str(), model.sequences[si].id, model.sequences[si].variationIndex);
-            auto animData = assetManager_->readFileOptional(animFileName);
-            if (!animData.empty()) {
-                pipeline::M2Loader::loadAnimFile(m2Data, animData, si, model);
-            }
-        }
-    }
-
-    return model;
-}
-
-void EntitySpawner::spawnOnlineCreature(uint64_t guid, uint32_t displayId, float x, float y, float z, float orientation, float scale) {
-    if (!renderer_ || !renderer_->getCharacterRenderer() || !assetManager_) return;
-
-    // Skip if lookups not yet built (asset manager not ready)
-    if (!creatureLookupsBuilt_) return;
-
-    // Skip if already spawned
-    if (creatureInstances_.count(guid)) return;
-    if (nonRenderableCreatureDisplayIds_.count(displayId)) {
-        creaturePermanentFailureGuids_.insert(guid);
-        return;
-    }
-
-    // Get model path from displayId
-    std::string m2Path = getModelPathForDisplayId(displayId);
-    if (m2Path.empty()) {
-        nonRenderableCreatureDisplayIds_.insert(displayId);
-        creaturePermanentFailureGuids_.insert(guid);
-        return;
-    }
-    {
-        // Intentionally invisible helper creatures should not consume retry budget.
-        std::string lowerPath = m2Path;
-        std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(),
-                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-        if (lowerPath.find("invisiblestalker") != std::string::npos ||
-            lowerPath.find("invisible_stalker") != std::string::npos) {
-            nonRenderableCreatureDisplayIds_.insert(displayId);
-            creaturePermanentFailureGuids_.insert(guid);
-            return;
-        }
-    }
-
-    auto* charRenderer = renderer_->getCharacterRenderer();
-
-    // Check model cache - reuse if same displayId was already loaded
-    uint32_t modelId = 0;
-    auto cacheIt = displayIdModelCache_.find(displayId);
-    if (cacheIt != displayIdModelCache_.end()) {
-        modelId = cacheIt->second;
-    } else {
-        // Load model from disk (only once per displayId)
-        modelId = nextCreatureModelId_++;
-
-        pipeline::M2Model model = loadCreatureM2Sync(m2Path);
-        if (!model.isValid()) {
-            nonRenderableCreatureDisplayIds_.insert(displayId);
-            creaturePermanentFailureGuids_.insert(guid);
-            return;
-        }
-
-        if (!charRenderer->loadModel(model, modelId)) {
-            LOG_WARNING("Failed to load creature model: ", m2Path);
-            nonRenderableCreatureDisplayIds_.insert(displayId);
-            creaturePermanentFailureGuids_.insert(guid);
-            return;
-        }
-
-        displayIdModelCache_[displayId] = modelId;
-    }
-
-    // Apply skin textures from CreatureDisplayInfo.dbc (only once per displayId model).
-    // Track separately from model cache because async loading may upload the model
-    // before textures are applied.
-    auto itDisplayData = displayDataMap_.find(displayId);
-    bool needsTextures = (displayIdTexturesApplied_.find(displayId) == displayIdTexturesApplied_.end());
-    if (needsTextures && itDisplayData != displayDataMap_.end()) {
-        auto texStart = std::chrono::steady_clock::now();
-        displayIdTexturesApplied_.insert(displayId);
-        const auto& dispData = itDisplayData->second;
-
-        // Use pre-decoded textures from async creature load (if available)
-        auto itPreDec = displayIdPredecodedTextures_.find(displayId);
-        bool hasPreDec = (itPreDec != displayIdPredecodedTextures_.end());
-        if (hasPreDec) {
-            charRenderer->setPredecodedBLPCache(&itPreDec->second);
-        }
-
-        // Get model directory for texture path construction
-        std::string modelDir;
-        size_t lastSlash = m2Path.find_last_of("\\/");
-        if (lastSlash != std::string::npos) {
-            modelDir = m2Path.substr(0, lastSlash + 1);
-        }
-
-        LOG_DEBUG("DisplayId ", displayId, " skins: '", dispData.skin1, "', '", dispData.skin2, "', '", dispData.skin3,
-                  "' extraDisplayId=", dispData.extraDisplayId);
-
-        // Get model data from CharacterRenderer for texture iteration
-        const auto* modelData = charRenderer->getModelData(modelId);
-        if (!modelData) {
-            LOG_WARNING("Model data not found for modelId ", modelId);
-        }
-
-        // Log texture types in the model
-        if (modelData) {
-        for (size_t ti = 0; ti < modelData->textures.size(); ti++) {
-            LOG_DEBUG("  Model texture ", ti, ": type=", modelData->textures[ti].type, " filename='", modelData->textures[ti].filename, "'");
-        }
-        }
-
-        // Check if this is a humanoid NPC with extra display info
-        bool hasHumanoidTexture = false;
-        if (dispData.extraDisplayId != 0) {
-            auto itExtra = humanoidExtraMap_.find(dispData.extraDisplayId);
-            if (itExtra != humanoidExtraMap_.end()) {
-                const auto& extra = itExtra->second;
-                LOG_DEBUG("  Found humanoid extra: raceId=", static_cast<int>(extra.raceId), " sexId=", static_cast<int>(extra.sexId),
-                          " hairStyle=", static_cast<int>(extra.hairStyleId), " hairColor=", static_cast<int>(extra.hairColorId),
-                          " bakeName='", extra.bakeName, "'");
-
-                // Collect model texture slot info (type 1 = skin, type 6 = hair)
-                std::vector<uint32_t> skinSlots, hairSlots;
-                if (modelData) {
-                    for (size_t ti = 0; ti < modelData->textures.size(); ti++) {
-                        uint32_t texType = modelData->textures[ti].type;
-                        if (texType == 1 || texType == 11 || texType == 12 || texType == 13)
-                            skinSlots.push_back(static_cast<uint32_t>(ti));
-                        if (texType == 6)
-                            hairSlots.push_back(static_cast<uint32_t>(ti));
-                    }
-                }
-
-                // Copy extra data for the async task (avoid dangling reference)
-                HumanoidDisplayExtra extraCopy = extra;
-
-                // Launch async task: ALL DBC lookups, path resolution, and BLP pre-decode
-                // happen on a background thread. Only GPU texture upload runs on main thread
-                // (in processAsyncNpcCompositeResults).
-                auto* am = assetManager_;
-                AsyncNpcCompositeLoad load;
-                load.future = std::async(std::launch::async,
-                    [am, extraCopy, skinSlots = std::move(skinSlots),
-                     hairSlots = std::move(hairSlots), modelId, displayId]() mutable -> PreparedNpcComposite {
-                        PreparedNpcComposite result;
-                        DeferredNpcComposite& def = result.info;
-                        def.modelId = modelId;
-                        def.displayId = displayId;
-                        def.skinTextureSlots = std::move(skinSlots);
-                        def.hairTextureSlots = std::move(hairSlots);
-
-                        std::vector<std::string> allPaths;  // paths to pre-decode
-
-                        // --- Baked skin texture ---
-                        if (!extraCopy.bakeName.empty()) {
-                            def.bakedSkinPath = "Textures\\BakedNpcTextures\\" + extraCopy.bakeName;
-                            def.hasBakedSkin = true;
-                            allPaths.push_back(def.bakedSkinPath);
-                        }
-
-                        // --- CharSections fallback (skin/face/underwear) ---
-                        if (!def.hasBakedSkin) {
-                            auto csDbc = am->loadDBC("CharSections.dbc");
-                            if (csDbc) {
-                                const auto* csL = pipeline::getActiveDBCLayout()
-                                    ? pipeline::getActiveDBCLayout()->getLayout("CharSections") : nullptr;
-                                auto csF = pipeline::detectCharSectionsFields(csDbc.get(), csL);
-                                uint32_t npcRace = static_cast<uint32_t>(extraCopy.raceId);
-                                uint32_t npcSex = static_cast<uint32_t>(extraCopy.sexId);
-                                uint32_t npcSkin = static_cast<uint32_t>(extraCopy.skinId);
-                                uint32_t npcFace = static_cast<uint32_t>(extraCopy.faceId);
-                                std::string npcFaceLower, npcFaceUpper;
-                                std::vector<std::string> npcUnderwear;
-
-                                for (uint32_t r = 0; r < csDbc->getRecordCount(); r++) {
-                                    uint32_t rId = csDbc->getUInt32(r, csF.raceId);
-                                    uint32_t sId = csDbc->getUInt32(r, csF.sexId);
-                                    if (rId != npcRace || sId != npcSex) continue;
-
-                                    uint32_t section = csDbc->getUInt32(r, csF.baseSection);
-                                    uint32_t variation = csDbc->getUInt32(r, csF.variationIndex);
-                                    uint32_t color = csDbc->getUInt32(r, csF.colorIndex);
-
-                                    if (section == 0 && def.basePath.empty() && color == npcSkin) {
-                                        def.basePath = csDbc->getString(r, csF.texture1);
-                                    } else if (section == 1 && npcFaceLower.empty() &&
-                                               variation == npcFace && color == npcSkin) {
-                                        npcFaceLower = csDbc->getString(r, csF.texture1);
-                                        npcFaceUpper = csDbc->getString(r, csF.texture2);
-                                    } else if (section == 4 && npcUnderwear.empty() && color == npcSkin) {
-                                        for (uint32_t f = csF.texture1; f <= csF.texture1 + 2; f++) {
-                                            std::string tex = csDbc->getString(r, f);
-                                            if (!tex.empty()) npcUnderwear.push_back(tex);
-                                        }
-                                    }
-                                }
-
-                                if (!def.basePath.empty()) {
-                                    allPaths.push_back(def.basePath);
-                                    if (!npcFaceLower.empty()) { def.overlayPaths.push_back(npcFaceLower); allPaths.push_back(npcFaceLower); }
-                                    if (!npcFaceUpper.empty()) { def.overlayPaths.push_back(npcFaceUpper); allPaths.push_back(npcFaceUpper); }
-                                    for (const auto& uw : npcUnderwear) { def.overlayPaths.push_back(uw); allPaths.push_back(uw); }
-                                }
-                            }
-                        }
-
-                        // --- Equipment region layers (ItemDisplayInfo DBC) ---
-                        auto idiDbc = am->loadDBC("ItemDisplayInfo.dbc");
-                        if (idiDbc) {
-                            static constexpr const char* componentDirs[] = {
-                                "ArmUpperTexture", "ArmLowerTexture", "HandTexture",
-                                "TorsoUpperTexture", "TorsoLowerTexture",
-                                "LegUpperTexture", "LegLowerTexture", "FootTexture",
-                            };
-                            const auto* idiL = pipeline::getActiveDBCLayout()
-                                ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
-                            uint32_t texRegionFields[8];
-                            pipeline::getItemDisplayInfoTextureFields(*idiDbc, idiL, texRegionFields);
-                            const bool npcIsFemale = (extraCopy.sexId == 1);
-                            const bool npcHasArmArmor = (extraCopy.equipDisplayId[7] != 0 || extraCopy.equipDisplayId[8] != 0);
-
-                            auto regionAllowedForNpcSlot = [](int eqSlot, int region) -> bool {
-                                switch (eqSlot) {
-                                    case 2: case 3: return region <= 4;
-                                    case 4: return false;
-                                    case 5: return region == 5 || region == 6;
-                                    case 6: return region == 7;
-                                    case 7: return false;
-                                    case 8: return region == 2;
-                                    case 9: return region == 3 || region == 4;
-                                    default: return false;
-                                }
-                            };
-
-                            for (int eqSlot = 0; eqSlot < 11; eqSlot++) {
-                                uint32_t did = extraCopy.equipDisplayId[eqSlot];
-                                if (did == 0) continue;
-                                int32_t recIdx = idiDbc->findRecordById(did);
-                                if (recIdx < 0) continue;
-
-                                for (int region = 0; region < 8; region++) {
-                                    if (!regionAllowedForNpcSlot(eqSlot, region)) continue;
-                                    if (eqSlot == 2 && !npcHasArmArmor && !(region == 3 || region == 4)) continue;
-                                    std::string texName = idiDbc->getString(
-                                        static_cast<uint32_t>(recIdx), texRegionFields[region]);
-                                    if (texName.empty()) continue;
-
-                                    std::string base = "Item\\TextureComponents\\" +
-                                        std::string(componentDirs[region]) + "\\" + texName;
-                                    std::string genderPath = base + (npcIsFemale ? "_F.blp" : "_M.blp");
-                                    std::string unisexPath = base + "_U.blp";
-                                    std::string basePath = base + ".blp";
-                                    std::string fullPath;
-                                    if (am->fileExists(genderPath)) fullPath = genderPath;
-                                    else if (am->fileExists(unisexPath)) fullPath = unisexPath;
-                                    else if (am->fileExists(basePath)) fullPath = basePath;
-                                    else continue;
-
-                                    def.regionLayers.emplace_back(region, fullPath);
-                                    allPaths.push_back(fullPath);
-                                }
-                            }
-                        }
-
-                        // Determine compositing mode
-                        if (!def.basePath.empty()) {
-                            bool needsComposite = !def.overlayPaths.empty() || !def.regionLayers.empty();
-                            if (needsComposite && !def.skinTextureSlots.empty()) {
-                                def.hasComposite = true;
-                            } else if (!def.skinTextureSlots.empty()) {
-                                def.hasSimpleSkin = true;
-                            }
-                        }
-
-                        // --- Hair texture from CharSections (section 3) ---
-                        {
-                            auto csDbc = am->loadDBC("CharSections.dbc");
-                            if (csDbc) {
-                                const auto* csL = pipeline::getActiveDBCLayout()
-                                    ? pipeline::getActiveDBCLayout()->getLayout("CharSections") : nullptr;
-                                auto csF = pipeline::detectCharSectionsFields(csDbc.get(), csL);
-                                uint32_t targetRace = static_cast<uint32_t>(extraCopy.raceId);
-                                uint32_t targetSex = static_cast<uint32_t>(extraCopy.sexId);
-
-                                for (uint32_t r = 0; r < csDbc->getRecordCount(); r++) {
-                                    uint32_t raceId = csDbc->getUInt32(r, csF.raceId);
-                                    uint32_t sexId = csDbc->getUInt32(r, csF.sexId);
-                                    if (raceId != targetRace || sexId != targetSex) continue;
-                                    uint32_t section = csDbc->getUInt32(r, csF.baseSection);
-                                    if (section != 3) continue;
-                                    uint32_t variation = csDbc->getUInt32(r, csF.variationIndex);
-                                    uint32_t colorIdx = csDbc->getUInt32(r, csF.colorIndex);
-                                    if (variation != static_cast<uint32_t>(extraCopy.hairStyleId)) continue;
-                                    if (colorIdx != static_cast<uint32_t>(extraCopy.hairColorId)) continue;
-                                    def.hairTexturePath = csDbc->getString(r, csF.texture1);
-                                    break;
-                                }
-
-                                if (!def.hairTexturePath.empty()) {
-                                    allPaths.push_back(def.hairTexturePath);
-                                } else if (def.hasBakedSkin && !def.hairTextureSlots.empty()) {
-                                    def.useBakedForHair = true;
-                                    // bakedSkinPath already in allPaths
-                                }
-                            }
-                        }
-
-                        // --- Pre-decode all BLP textures on this background thread ---
-                        for (const auto& path : allPaths) {
-                            std::string key = path;
-                            std::replace(key.begin(), key.end(), '/', '\\');
-                            std::transform(key.begin(), key.end(), key.begin(),
-                                           [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-                            if (result.predecodedTextures.count(key)) continue;
-                            auto blp = am->loadTexture(key);
-                            if (blp.isValid()) {
-                                result.predecodedTextures[key] = std::move(blp);
-                            }
-                        }
-
-                        return result;
-                    });
-                asyncNpcCompositeLoads_.push_back(std::move(load));
-                hasHumanoidTexture = true;  // skip non-humanoid skin block
-            } else {
-                LOG_WARNING("  extraDisplayId ", dispData.extraDisplayId, " not found in humanoidExtraMap");
-            }
-        }
-
-        // Apply creature skin textures (for non-humanoid creatures)
-        if (!hasHumanoidTexture && modelData) {
-            auto resolveCreatureSkinPath = [&](const std::string& skinField) -> std::string {
-                if (skinField.empty()) return "";
-
-                std::string raw = skinField;
-                std::replace(raw.begin(), raw.end(), '/', '\\');
-                auto isSpace = [](unsigned char c) { return std::isspace(c) != 0; };
-                raw.erase(raw.begin(), std::find_if(raw.begin(), raw.end(), [&](unsigned char c) { return !isSpace(c); }));
-                raw.erase(std::find_if(raw.rbegin(), raw.rend(), [&](unsigned char c) { return !isSpace(c); }).base(), raw.end());
-                if (raw.empty()) return "";
-
-                auto hasBlpExt = [](const std::string& p) {
-                    if (p.size() < 4) return false;
-                    std::string ext = p.substr(p.size() - 4);
-                    std::transform(ext.begin(), ext.end(), ext.begin(),
-                                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-                    return ext == ".blp";
-                };
-                auto addCandidate = [](std::vector<std::string>& out, const std::string& p) {
-                    if (p.empty()) return;
-                    if (std::find(out.begin(), out.end(), p) == out.end()) out.push_back(p);
-                };
-
-                std::vector<std::string> candidates;
-                const bool hasDir = (raw.find('\\') != std::string::npos || raw.find('/') != std::string::npos);
-                const bool hasExt = hasBlpExt(raw);
-
-                if (hasDir) {
-                    addCandidate(candidates, raw);
-                    if (!hasExt) addCandidate(candidates, raw + ".blp");
-                } else {
-                    addCandidate(candidates, modelDir + raw);
-                    if (!hasExt) addCandidate(candidates, modelDir + raw + ".blp");
-                    addCandidate(candidates, raw);
-                    if (!hasExt) addCandidate(candidates, raw + ".blp");
-                }
-
-                for (const auto& c : candidates) {
-                    if (assetManager_->fileExists(c)) return c;
-                }
-                return "";
-            };
-
-            for (size_t ti = 0; ti < modelData->textures.size(); ti++) {
-                const auto& tex = modelData->textures[ti];
-                std::string skinPath;
-
-                // Creature skin types: 11 = skin1, 12 = skin2, 13 = skin3
-                if (tex.type == 11 && !dispData.skin1.empty()) {
-                    skinPath = resolveCreatureSkinPath(dispData.skin1);
-                } else if (tex.type == 12 && !dispData.skin2.empty()) {
-                    skinPath = resolveCreatureSkinPath(dispData.skin2);
-                } else if (tex.type == 13 && !dispData.skin3.empty()) {
-                    skinPath = resolveCreatureSkinPath(dispData.skin3);
-                }
-
-                if (!skinPath.empty()) {
-                    rendering::VkTexture* skinTex = charRenderer->loadTexture(skinPath);
-                    if (skinTex) {
-                        charRenderer->setModelTexture(modelId, static_cast<uint32_t>(ti), skinTex);
-                        LOG_DEBUG("Applied creature skin texture: ", skinPath, " to slot ", ti);
-                    }
-                } else if ((tex.type == 11 && !dispData.skin1.empty()) ||
-                           (tex.type == 12 && !dispData.skin2.empty()) ||
-                           (tex.type == 13 && !dispData.skin3.empty())) {
-                    LOG_WARNING("Creature skin texture not found for displayId ", displayId,
-                                " slot ", ti, " type ", tex.type,
-                                " (skin fields: '", dispData.skin1, "', '",
-                                dispData.skin2, "', '", dispData.skin3, "')");
-                }
-            }
-        }
-
-        // Clear pre-decoded cache after applying all display textures
-        charRenderer->setPredecodedBLPCache(nullptr);
-        displayIdPredecodedTextures_.erase(displayId);
-        {
-            auto texEnd = std::chrono::steady_clock::now();
-            float texMs = std::chrono::duration<float, std::milli>(texEnd - texStart).count();
-            if (texMs > 50.0f) {
-                LOG_WARNING("spawnCreature texture setup took ", texMs, "ms displayId=", displayId,
-                            " hasPreDec=", hasPreDec, " extra=", dispData.extraDisplayId);
-            }
-        }
-    }
-
-    // Use the entity's latest server-authoritative position rather than the stale spawn
-    // position. Movement packets (SMSG_MONSTER_MOVE) can arrive while a creature is still
-    // queued in pendingCreatureSpawns_ and get silently dropped. getLatestX/Y/Z returns
-    // the movement destination if the entity is mid-move, which is always up-to-date
-    // regardless of distance culling (unlike getX/Y/Z which requires updateMovement).
-    if (gameHandler_) {
-        if (auto entity = gameHandler_->getEntityManager().getEntity(guid)) {
-            x = entity->getLatestX();
-            y = entity->getLatestY();
-            z = entity->getLatestZ();
-            orientation = entity->getOrientation();
-        }
-    }
-
-    // Convert canonical → render coordinates
-    glm::vec3 renderPos = core::coords::canonicalToRender(glm::vec3(x, y, z));
-
-    // Keep authoritative server Z for online creature spawns.
-    // Terrain-based lifting can incorrectly move elevated NPCs (e.g. flight masters on
-    // Stormwind ramparts) to bad heights relative to WMO geometry.
-
-    // Convert canonical WoW orientation (0=north) -> render yaw (0=west)
-    float renderYaw = orientation + glm::radians(90.0f);
-
-    // Create instance (apply server-provided scale from OBJECT_FIELD_SCALE_X)
-    uint32_t instanceId = charRenderer->createInstance(modelId, renderPos,
-        glm::vec3(0.0f, 0.0f, renderYaw), scale);
-
-    if (instanceId == 0) {
-        LOG_WARNING("Failed to create creature instance for guid 0x", std::hex, guid, std::dec);
-        return;
-    }
-
-    // Per-instance hair/skin texture overrides — runs for ALL NPCs (including cached models)
-    // so that each NPC gets its own hair/skin color regardless of model sharing.
-    // Uses pre-built CharSections cache (O(1) lookup instead of O(N) DBC scan).
-    {
-        if (!charSectionsCacheBuilt_) buildCharSectionsCache();
-        auto itDD = displayDataMap_.find(displayId);
-        if (itDD != displayDataMap_.end() && itDD->second.extraDisplayId != 0) {
-            auto itExtra2 = humanoidExtraMap_.find(itDD->second.extraDisplayId);
-            if (itExtra2 != humanoidExtraMap_.end()) {
-                const auto& extra = itExtra2->second;
-                const auto* md = charRenderer->getModelData(modelId);
-                if (md) {
-                        // Look up hair texture (section 3) via cache
-                        rendering::VkTexture* whiteTex = charRenderer->loadTexture("");
-                        std::string hairPath = lookupCharSection(
-                            extra.raceId, extra.sexId, 3, extra.hairStyleId, extra.hairColorId, 0);
-                        if (!hairPath.empty()) {
-                            rendering::VkTexture* hairTex = charRenderer->loadTexture(hairPath);
-                            if (hairTex && hairTex != whiteTex) {
-                                for (size_t ti = 0; ti < md->textures.size(); ti++) {
-                                    if (md->textures[ti].type == 6) {
-                                        charRenderer->setTextureSlotOverride(instanceId, static_cast<uint16_t>(ti), hairTex);
-                                    }
-                                }
-                            }
-                        }
-
-                        // Look up skin texture (section 0) for per-instance skin color.
-                        // Skip when the NPC has a baked texture or composited equipment —
-                        // those already encode armor over skin and must not be replaced.
-                        bool hasEquipOrBake = !extra.bakeName.empty();
-                        if (!hasEquipOrBake) {
-                            for (int s = 0; s < 11 && !hasEquipOrBake; s++)
-                                if (extra.equipDisplayId[s] != 0) hasEquipOrBake = true;
-                        }
-                        if (!hasEquipOrBake) {
-                            std::string skinPath = lookupCharSection(
-                                extra.raceId, extra.sexId, 0, 0, extra.skinId, 0);
-                            if (!skinPath.empty()) {
-                                rendering::VkTexture* skinTex = charRenderer->loadTexture(skinPath);
-                                if (skinTex) {
-                                    for (size_t ti = 0; ti < md->textures.size(); ti++) {
-                                        uint32_t tt = md->textures[ti].type;
-                                        if (tt == 1 || tt == 11) {
-                                            charRenderer->setTextureSlotOverride(instanceId, static_cast<uint16_t>(ti), skinTex);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                }
-            }
-        }
-    }
-
-    // Optional humanoid NPC geoset mask. Disabled by default because forcing geosets
-    // causes long-standing visual artifacts on some models (missing waist, phantom
-    // bracers, flickering apron overlays). Prefer model defaults.
-    static constexpr bool kEnableNpcSafeGeosetMask = false;
-    if (kEnableNpcSafeGeosetMask &&
-        itDisplayData != displayDataMap_.end() &&
-        itDisplayData->second.extraDisplayId != 0) {
-        auto itExtra = humanoidExtraMap_.find(itDisplayData->second.extraDisplayId);
-        if (itExtra != humanoidExtraMap_.end()) {
-            const auto& extra = itExtra->second;
-            std::unordered_set<uint16_t> safeGeosets;
-            std::unordered_set<uint16_t> modelGeosets;
-            std::unordered_map<uint16_t, uint16_t> firstGeosetByGroup;
-            if (const auto* md = charRenderer->getModelData(modelId)) {
-                for (const auto& b : md->batches) {
-                    const uint16_t sid = b.submeshId;
-                    modelGeosets.insert(sid);
-                    const uint16_t group = static_cast<uint16_t>(sid / 100);
-                    auto it = firstGeosetByGroup.find(group);
-                    if (it == firstGeosetByGroup.end() || sid < it->second) {
-                        firstGeosetByGroup[group] = sid;
-                    }
-                }
-            }
-            auto addSafeGeoset = [&](uint16_t preferredId) {
-                if (preferredId < 100 || modelGeosets.empty()) {
-                    safeGeosets.insert(preferredId);
-                    return;
-                }
-                if (modelGeosets.count(preferredId) > 0) {
-                    safeGeosets.insert(preferredId);
-                    return;
-                }
-                const uint16_t group = static_cast<uint16_t>(preferredId / 100);
-                auto it = firstGeosetByGroup.find(group);
-                if (it != firstGeosetByGroup.end()) {
-                    safeGeosets.insert(it->second);
-                }
-            };
-            uint16_t hairGeoset = 1;
-            uint32_t hairKey = (static_cast<uint32_t>(extra.raceId) << 16) |
-                               (static_cast<uint32_t>(extra.sexId) << 8) |
-                               static_cast<uint32_t>(extra.hairStyleId);
-            auto itHairGeo = hairGeosetMap_.find(hairKey);
-            if (itHairGeo != hairGeosetMap_.end() && itHairGeo->second > 0) {
-                hairGeoset = itHairGeo->second;
-            }
-            const uint16_t selectedHairScalp = (hairGeoset > 0 ? hairGeoset : 1);
-            std::unordered_set<uint16_t> hairScalpGeosetsForRaceSex;
-            for (const auto& [k, v] : hairGeosetMap_) {
-                uint8_t race = static_cast<uint8_t>((k >> 16) & 0xFF);
-                uint8_t sex = static_cast<uint8_t>((k >> 8) & 0xFF);
-                if (race == extra.raceId && sex == extra.sexId && v > 0 && v < 100) {
-                    hairScalpGeosetsForRaceSex.insert(v);
-                }
-            }
-            // Group 0 contains both base body parts and race/sex hair scalp variants.
-            // Keep all non-hair body submeshes, but only the selected hair scalp.
-            for (uint16_t sid : modelGeosets) {
-                if (sid >= 100) continue;
-                if (hairScalpGeosetsForRaceSex.count(sid) > 0 && sid != selectedHairScalp) continue;
-                safeGeosets.insert(sid);
-            }
-            safeGeosets.insert(selectedHairScalp);
-            addSafeGeoset(static_cast<uint16_t>(100 + std::max<uint16_t>(hairGeoset, 1)));
-
-            uint32_t facialKey = (static_cast<uint32_t>(extra.raceId) << 16) |
-                                 (static_cast<uint32_t>(extra.sexId) << 8) |
-                                 static_cast<uint32_t>(extra.facialHairId);
-            auto itFacial = facialHairGeosetMap_.find(facialKey);
-            if (itFacial != facialHairGeosetMap_.end()) {
-                const auto& fhg = itFacial->second;
-                addSafeGeoset(static_cast<uint16_t>(200 + std::max<uint16_t>(fhg.geoset200, 1)));
-                addSafeGeoset(static_cast<uint16_t>(300 + std::max<uint16_t>(fhg.geoset300, 1)));
-            } else {
-                addSafeGeoset(201);
-                addSafeGeoset(301);
-            }
-
-            // Force pants (1301) and avoid robe skirt variants unless we re-enable full slot-accurate geosets.
-            addSafeGeoset(301);
-            addSafeGeoset(kGeosetBareForearms);
-            addSafeGeoset(402);
-            addSafeGeoset(501);
-            addSafeGeoset(701);
-            addSafeGeoset(kGeosetBareSleeves);
-            addSafeGeoset(901);
-            addSafeGeoset(kGeosetDefaultTabard);
-            addSafeGeoset(kGeosetBarePants);
-            addSafeGeoset(kGeosetBareFeet);
-
-            charRenderer->setActiveGeosets(instanceId, safeGeosets);
-        }
-    }
-
-    // NOTE: Custom humanoid NPC geoset/equipment overrides are currently too
-    // aggressive and can make NPCs invisible (targetable but not rendered).
-    // Keep default model geosets for online creatures until this path is made
-    // data-accurate per display model.
-    static constexpr bool kEnableNpcHumanoidOverrides = false;
-
-    // Set geosets for humanoid NPCs based on CreatureDisplayInfoExtra
-    if (kEnableNpcHumanoidOverrides &&
-        itDisplayData != displayDataMap_.end() &&
-        itDisplayData->second.extraDisplayId != 0) {
-        auto itExtra = humanoidExtraMap_.find(itDisplayData->second.extraDisplayId);
-        if (itExtra != humanoidExtraMap_.end()) {
-            const auto& extra = itExtra->second;
-            std::unordered_set<uint16_t> activeGeosets;
-
-            // Group 0: body base (id=0 always) + hair scalp mesh from CharHairGeosets.dbc
-            activeGeosets.insert(0);  // Body base mesh
-
-            // Hair: CharHairGeosets.dbc maps (race, sex, hairStyleId) → group 0 scalp submeshId
-            uint32_t hairKey = (static_cast<uint32_t>(extra.raceId) << 16) |
-                               (static_cast<uint32_t>(extra.sexId) << 8) |
-                               static_cast<uint32_t>(extra.hairStyleId);
-            auto itHairGeo = hairGeosetMap_.find(hairKey);
-            uint16_t hairScalpId = (itHairGeo != hairGeosetMap_.end()) ? itHairGeo->second : 0;
-            if (hairScalpId > 0) {
-                activeGeosets.insert(hairScalpId);                        // Group 0 scalp/hair mesh
-                activeGeosets.insert(static_cast<uint16_t>(100 + hairScalpId)); // Group 1 connector (if exists)
-            } else {
-                // Bald (geosetId=0): body base has a hole at the crown, so include
-                // submeshId=1 (bald scalp cap with body skin texture) to cover it.
-                activeGeosets.insert(1);    // Group 0 bald scalp mesh
-                activeGeosets.insert(kGeosetDefaultConnector);  // Group 1 connector
-            }
-            uint16_t hairGeoset = (hairScalpId > 0) ? hairScalpId : 1;
-
-            // Facial hair geosets from CharFacialHairStyles.dbc lookup
-            uint32_t facialKey = (static_cast<uint32_t>(extra.raceId) << 16) |
-                                 (static_cast<uint32_t>(extra.sexId) << 8) |
-                                 static_cast<uint32_t>(extra.facialHairId);
-            auto itFacial = facialHairGeosetMap_.find(facialKey);
-            if (itFacial != facialHairGeosetMap_.end()) {
-                const auto& fhg = itFacial->second;
-                // DBC values are variation indices within each group; add group base
-                activeGeosets.insert(static_cast<uint16_t>(100 + std::max(fhg.geoset100, static_cast<uint16_t>(1))));
-                activeGeosets.insert(static_cast<uint16_t>(300 + std::max(fhg.geoset300, static_cast<uint16_t>(1))));
-                activeGeosets.insert(static_cast<uint16_t>(200 + std::max(fhg.geoset200, static_cast<uint16_t>(1))));
-            } else {
-                activeGeosets.insert(kGeosetDefaultConnector); // Default group 1: no extra
-                activeGeosets.insert(201); // Default group 2: no facial hair
-                activeGeosets.insert(301); // Default group 3: no facial hair
-            }
-
-            // Default equipment geosets (bare/no armor)
-            // CharGeosets: group 4=gloves(forearm), 5=boots(shin), 8=sleeves, 12=tabard, 13=pants
-            std::unordered_set<uint16_t> modelGeosets;
-            std::unordered_map<uint16_t, uint16_t> firstByGroup;
-            if (const auto* md = charRenderer->getModelData(modelId)) {
-                for (const auto& b : md->batches) {
-                    const uint16_t sid = b.submeshId;
-                    modelGeosets.insert(sid);
-                    const uint16_t group = static_cast<uint16_t>(sid / 100);
-                    auto it = firstByGroup.find(group);
-                    if (it == firstByGroup.end() || sid < it->second) {
-                        firstByGroup[group] = sid;
-                    }
-                }
-            }
-            auto pickGeoset = [&](uint16_t preferred, uint16_t group) -> uint16_t {
-                if (preferred != 0 && modelGeosets.count(preferred) > 0) return preferred;
-                auto it = firstByGroup.find(group);
-                if (it != firstByGroup.end()) return it->second;
-                return preferred;
-            };
-
-            uint16_t geosetGloves = pickGeoset(kGeosetBareForearms, 4);
-            uint16_t geosetBoots = pickGeoset(kGeosetBareShins, 5);
-            uint16_t geosetSleeves = pickGeoset(kGeosetBareSleeves, 8);
-            uint16_t geosetPants = pickGeoset(kGeosetBarePants, 13);
-            uint16_t geosetCape = 0;       // Group 15 disabled unless cape is equipped
-            uint16_t geosetTabard = pickGeoset(kGeosetDefaultTabard, 12);
-            uint16_t geosetBelt = 0;       // Group 18 disabled unless belt is equipped
-            rendering::VkTexture* npcCapeTextureId = nullptr;
-
-            // Load equipment geosets from ItemDisplayInfo.dbc
-            // DBC columns: 7=GeosetGroup[0], 8=GeosetGroup[1], 9=GeosetGroup[2]
-            auto itemDisplayDbc = assetManager_->loadDBC("ItemDisplayInfo.dbc");
-            const auto* idiL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
-            if (itemDisplayDbc) {
-                // Equipment slots: 0=helm, 1=shoulder, 2=shirt, 3=chest, 4=belt, 5=legs, 6=feet, 7=wrist, 8=hands, 9=tabard, 10=cape
-                const uint32_t fGG1 = idiL ? (*idiL)["GeosetGroup1"] : 7;
-
-                auto readGeosetGroup = [&](int slot, const char* slotName) -> uint32_t {
-                    uint32_t did = extra.equipDisplayId[slot];
-                    if (did == 0) return 0;
-                    int32_t idx = itemDisplayDbc->findRecordById(did);
-                    if (idx < 0) {
-                        LOG_DEBUG("NPC equip slot ", slotName, " displayId=", did, " NOT FOUND in ItemDisplayInfo.dbc");
-                        return 0;
-                    }
-                    uint32_t gg = itemDisplayDbc->getUInt32(static_cast<uint32_t>(idx), fGG1);
-                    LOG_DEBUG("NPC equip slot ", slotName, " displayId=", did, " GeosetGroup1=", gg);
-                    return gg;
-                };
-
-                // Chest (slot 3) → group 8 (sleeves/wristbands)
-                {
-                    uint32_t gg = readGeosetGroup(3, "chest");
-                    if (gg > 0) geosetSleeves = pickGeoset(static_cast<uint16_t>(kGeosetBareSleeves + gg), 8);
-                }
-
-                // Legs (slot 5) → group 13 (trousers)
-                {
-                    uint32_t gg = readGeosetGroup(5, "legs");
-                    if (gg > 0) geosetPants = pickGeoset(static_cast<uint16_t>(kGeosetBarePants + gg), 13);
-                }
-
-                // Feet (slot 6) → group 5 (boots/shins)
-                {
-                    uint32_t gg = readGeosetGroup(6, "feet");
-                    if (gg > 0) geosetBoots = pickGeoset(static_cast<uint16_t>(501 + gg), 5);
-                }
-
-                // Hands (slot 8) → group 4 (gloves/forearms)
-                {
-                    uint32_t gg = readGeosetGroup(8, "hands");
-                    if (gg > 0) geosetGloves = pickGeoset(static_cast<uint16_t>(kGeosetBareForearms + gg), 4);
-                }
-
-                // Wrists (slot 7) → group 8 (sleeves, only if chest didn't set it)
-                {
-                    uint32_t gg = readGeosetGroup(7, "wrist");
-                    if (gg > 0 && geosetSleeves == pickGeoset(kGeosetBareSleeves, 8))
-                        geosetSleeves = pickGeoset(static_cast<uint16_t>(kGeosetBareSleeves + gg), 8);
-                }
-
-                // Belt (slot 4) → group 18 (buckle)
-                {
-                    uint32_t gg = readGeosetGroup(4, "belt");
-                    if (gg > 0) geosetBelt = static_cast<uint16_t>(1801 + gg);
-                }
-
-                // Tabard (slot 9) → group 12 (tabard/robe mesh)
-                {
-                    uint32_t gg = readGeosetGroup(9, "tabard");
-                    if (gg > 0) geosetTabard = pickGeoset(static_cast<uint16_t>(1200 + gg), 12);
-                }
-
-                // Cape (slot 10) → group 15
-                if (extra.equipDisplayId[10] != 0) {
-                    int32_t idx = itemDisplayDbc->findRecordById(extra.equipDisplayId[10]);
-                    if (idx >= 0) {
-                        geosetCape = kGeosetWithCape;
-                        const bool npcIsFemale = (extra.sexId == 1);
-                        const uint32_t leftTexField = idiL ? (*idiL)["LeftModelTexture"] : 3u;
-                        std::vector<std::string> capeNames;
-                        auto addName = [&](const std::string& n) {
-                            if (!n.empty() && std::find(capeNames.begin(), capeNames.end(), n) == capeNames.end()) {
-                                capeNames.push_back(n);
-                            }
-                        };
-                        std::string leftName = itemDisplayDbc->getString(static_cast<uint32_t>(idx), leftTexField);
-                        addName(leftName);
-
-                        auto hasBlpExt = [](const std::string& p) {
-                            if (p.size() < 4) return false;
-                            std::string ext = p.substr(p.size() - 4);
-                            std::transform(ext.begin(), ext.end(), ext.begin(),
-                                           [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-                            return ext == ".blp";
-                        };
-                        std::vector<std::string> capeCandidates;
-                        auto addCapeCandidate = [&](const std::string& p) {
-                            if (p.empty()) return;
-                            if (std::find(capeCandidates.begin(), capeCandidates.end(), p) == capeCandidates.end()) {
-                                capeCandidates.push_back(p);
-                            }
-                        };
-                        for (const auto& nameRaw : capeNames) {
-                            std::string name = nameRaw;
-                            std::replace(name.begin(), name.end(), '/', '\\');
-                            const bool hasDir = (name.find('\\') != std::string::npos);
-                            const bool hasExt = hasBlpExt(name);
-                            if (hasDir) {
-                                addCapeCandidate(name);
-                                if (!hasExt) addCapeCandidate(name + ".blp");
-                            } else {
-                                std::string baseObj = "Item\\ObjectComponents\\Cape\\" + name;
-                                std::string baseTex = "Item\\TextureComponents\\Cape\\" + name;
-                                addCapeCandidate(baseObj);
-                                addCapeCandidate(baseTex);
-                                if (!hasExt) {
-                                    addCapeCandidate(baseObj + ".blp");
-                                    addCapeCandidate(baseTex + ".blp");
-                                }
-                                addCapeCandidate(baseObj + (npcIsFemale ? "_F.blp" : "_M.blp"));
-                                addCapeCandidate(baseObj + "_U.blp");
-                                addCapeCandidate(baseTex + (npcIsFemale ? "_F.blp" : "_M.blp"));
-                                addCapeCandidate(baseTex + "_U.blp");
-                            }
-                        }
-                        const rendering::VkTexture* whiteTex = charRenderer->loadTexture("");
-                        for (const auto& candidate : capeCandidates) {
-                            rendering::VkTexture* tex = charRenderer->loadTexture(candidate);
-                            if (tex && tex != whiteTex) {
-                                npcCapeTextureId = tex;
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-
-            // Apply equipment geosets
-            activeGeosets.insert(geosetGloves);
-            activeGeosets.insert(geosetBoots);
-            activeGeosets.insert(geosetSleeves);
-            activeGeosets.insert(geosetPants);
-            if (geosetCape != 0) {
-                activeGeosets.insert(geosetCape);
-            }
-            if (geosetTabard != 0) {
-                activeGeosets.insert(geosetTabard);
-            }
-            if (geosetBelt != 0) {
-                activeGeosets.insert(geosetBelt);
-            }
-            activeGeosets.insert(pickGeoset(kGeosetDefaultEars, 7));
-            activeGeosets.insert(pickGeoset(kGeosetDefaultKneepads, 9));
-            activeGeosets.insert(pickGeoset(kGeosetBareFeet, 20));
-            // Keep all model-present torso variants active to avoid missing male
-            // abdomen/waist sections when a single 5xx pick is wrong.
-            for (uint16_t sid : modelGeosets) {
-                if ((sid / 100) == 5) activeGeosets.insert(sid);
-            }
-            // Keep all model-present pelvis variants active to avoid missing waist/belt
-            // sections on some humanoid males when a single 9xx variant is wrong.
-            for (uint16_t sid : modelGeosets) {
-                if ((sid / 100) == 9) activeGeosets.insert(sid);
-            }
-
-            // Hide hair under helmets: replace style-specific scalp with bald scalp
-            if (extra.equipDisplayId[0] != 0 && hairGeoset > 1) {
-                activeGeosets.erase(hairGeoset);                              // Remove style scalp
-                activeGeosets.erase(static_cast<uint16_t>(100 + hairGeoset)); // Remove style group 1
-                activeGeosets.insert(1);    // Bald scalp cap (group 0)
-                activeGeosets.insert(kGeosetDefaultConnector);  // Default group 1 connector
-            }
-
-            charRenderer->setActiveGeosets(instanceId, activeGeosets);
-            if (geosetCape != 0 && npcCapeTextureId) {
-                charRenderer->setGroupTextureOverride(instanceId, 15, npcCapeTextureId);
-                if (const auto* md = charRenderer->getModelData(modelId)) {
-                    for (size_t ti = 0; ti < md->textures.size(); ti++) {
-                        if (md->textures[ti].type == 2) {
-                            charRenderer->setTextureSlotOverride(instanceId, static_cast<uint16_t>(ti), npcCapeTextureId);
-                        }
-                    }
-                }
-            }
-            LOG_DEBUG("Set humanoid geosets: hair=", static_cast<int>(hairGeoset),
-                      " sleeves=", geosetSleeves, " pants=", geosetPants,
-                      " boots=", geosetBoots, " gloves=", geosetGloves);
-
-            // NOTE: NPC helmet attachment with fallback logic to use bone 0 if attachment
-            // point 11 is missing. This improves compatibility with models that don't have
-            // attachment 11 explicitly defined.
-            static constexpr bool kEnableNpcHelmetAttachmentsMainPath = true;
-            // Load and attach helmet model if equipped
-            if (kEnableNpcHelmetAttachmentsMainPath && extra.equipDisplayId[0] != 0 && itemDisplayDbc) {
-                int32_t helmIdx = itemDisplayDbc->findRecordById(extra.equipDisplayId[0]);
-                if (helmIdx >= 0) {
-                    // Get helmet model name from ItemDisplayInfo.dbc (LeftModel)
-                    std::string helmModelName = itemDisplayDbc->getString(static_cast<uint32_t>(helmIdx), idiL ? (*idiL)["LeftModel"] : 1);
-                    if (!helmModelName.empty()) {
-                        // Convert .mdx to .m2
-                        size_t dotPos = helmModelName.rfind('.');
-                        if (dotPos != std::string::npos) {
-                            helmModelName = helmModelName.substr(0, dotPos);
-                        }
-
-                        // WoW helmet M2 files have per-race/gender variants with a suffix
-                        // e.g. Helm_Plate_B_01Stormwind_HuM.M2 for Human Male
-                        // ChrRaces.dbc ClientPrefix values (raceId → prefix):
-                        static const std::unordered_map<uint8_t, std::string> racePrefix = {
-                            {1, "Hu"}, {2, "Or"}, {3, "Dw"}, {4, "Ni"}, {5, "Sc"},
-                            {6, "Ta"}, {7, "Gn"}, {8, "Tr"}, {10, "Be"}, {11, "Dr"}
-                        };
-                        std::string genderSuffix = (extra.sexId == 0) ? "M" : "F";
-                        std::string raceSuffix;
-                        auto itRace = racePrefix.find(extra.raceId);
-                        if (itRace != racePrefix.end()) {
-                            raceSuffix = "_" + itRace->second + genderSuffix;
-                        }
-
-                        // Try race/gender-specific variant first, then base name
-                        std::string helmPath;
-                        std::vector<uint8_t> helmData;
-                        if (!raceSuffix.empty()) {
-                            helmPath = "Item\\ObjectComponents\\Head\\" + helmModelName + raceSuffix + ".m2";
-                            helmData = assetManager_->readFile(helmPath);
-                        }
-                        if (helmData.empty()) {
-                            helmPath = "Item\\ObjectComponents\\Head\\" + helmModelName + ".m2";
-                            helmData = assetManager_->readFile(helmPath);
-                        }
-
-                        if (!helmData.empty()) {
-                            auto helmModel = pipeline::M2Loader::load(helmData);
-                            // Load skin (only for WotLK M2s)
-                            std::string skinPath = helmPath.substr(0, helmPath.size() - 3) + "00.skin";
-                            auto skinData = assetManager_->readFile(skinPath);
-                            if (!skinData.empty() && helmModel.version >= 264) {
-                                pipeline::M2Loader::loadSkin(skinData, helmModel);
-                            }
-
-                            if (helmModel.isValid()) {
-                                // Attachment point 11 = Head
-                                uint32_t helmModelId = nextCreatureModelId_++;
-                                // Get texture from ItemDisplayInfo (LeftModelTexture)
-                                std::string helmTexName = itemDisplayDbc->getString(static_cast<uint32_t>(helmIdx), idiL ? (*idiL)["LeftModelTexture"] : 3);
-                                std::string helmTexPath;
-                                if (!helmTexName.empty()) {
-                                    // Try race/gender suffixed texture first
-                                    if (!raceSuffix.empty()) {
-                                        std::string suffixedTex = "Item\\ObjectComponents\\Head\\" + helmTexName + raceSuffix + ".blp";
-                                        if (assetManager_->fileExists(suffixedTex)) {
-                                            helmTexPath = suffixedTex;
-                                        }
-                                    }
-                                    if (helmTexPath.empty()) {
-                                        helmTexPath = "Item\\ObjectComponents\\Head\\" + helmTexName + ".blp";
-                                    }
-                                }
-                                bool attached = charRenderer->attachWeapon(instanceId, 0, helmModel, helmModelId, helmTexPath);
-                                if (!attached) {
-                                    attached = charRenderer->attachWeapon(instanceId, 11, helmModel, helmModelId, helmTexPath);
-                                }
-                                if (attached) {
-                                    LOG_DEBUG("Attached helmet model: ", helmPath, " tex: ", helmTexPath);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-            // NPC shoulder attachment: slot 1 = shoulder in the NPC equipment array.
-            // Shoulders have TWO M2 models (left + right) at attachment points 5 and 6.
-            if (extra.equipDisplayId[1] != 0) {
-                int32_t shoulderIdx = itemDisplayDbc->findRecordById(extra.equipDisplayId[1]);
-                if (shoulderIdx >= 0) {
-                    const uint32_t leftModelField = idiL ? (*idiL)["LeftModel"] : 1u;
-                    const uint32_t rightModelField = idiL ? (*idiL)["RightModel"] : 2u;
-                    const uint32_t leftTexFieldS = idiL ? (*idiL)["LeftModelTexture"] : 3u;
-                    const uint32_t rightTexFieldS = idiL ? (*idiL)["RightModelTexture"] : 4u;
-
-                    static const std::unordered_map<uint8_t, std::string> shoulderRacePrefix = {
-                        {1, "Hu"}, {2, "Or"}, {3, "Dw"}, {4, "Ni"}, {5, "Sc"},
-                        {6, "Ta"}, {7, "Gn"}, {8, "Tr"}, {10, "Be"}, {11, "Dr"}
-                    };
-                    std::string genderSuffix = (extra.sexId == 0) ? "M" : "F";
-                    std::string raceSuffix;
-                    {
-                        auto itRace = shoulderRacePrefix.find(extra.raceId);
-                        if (itRace != shoulderRacePrefix.end()) {
-                            raceSuffix = "_" + itRace->second + genderSuffix;
-                        }
-                    }
-
-                    // Left shoulder (attachment point 5) using LeftModel
-                    std::string leftModelName = itemDisplayDbc->getString(static_cast<uint32_t>(shoulderIdx), leftModelField);
-                    if (!leftModelName.empty()) {
-                        size_t dotPos = leftModelName.rfind('.');
-                        if (dotPos != std::string::npos) leftModelName = leftModelName.substr(0, dotPos);
-
-                        std::string leftPath;
-                        std::vector<uint8_t> leftData;
-                        if (!raceSuffix.empty()) {
-                            leftPath = "Item\\ObjectComponents\\Shoulder\\" + leftModelName + raceSuffix + ".m2";
-                            leftData = assetManager_->readFile(leftPath);
-                        }
-                        if (leftData.empty()) {
-                            leftPath = "Item\\ObjectComponents\\Shoulder\\" + leftModelName + ".m2";
-                            leftData = assetManager_->readFile(leftPath);
-                        }
-                        if (!leftData.empty()) {
-                            auto leftModel = pipeline::M2Loader::load(leftData);
-                            std::string skinPath = leftPath.substr(0, leftPath.size() - 3) + "00.skin";
-                            auto skinData = assetManager_->readFile(skinPath);
-                            if (!skinData.empty() && leftModel.version >= 264) {
-                                pipeline::M2Loader::loadSkin(skinData, leftModel);
-                            }
-                            if (leftModel.isValid()) {
-                                uint32_t leftModelId = nextCreatureModelId_++;
-                                std::string leftTexName = itemDisplayDbc->getString(static_cast<uint32_t>(shoulderIdx), leftTexFieldS);
-                                std::string leftTexPath;
-                                if (!leftTexName.empty()) {
-                                    if (!raceSuffix.empty()) {
-                                        std::string suffixedTex = "Item\\ObjectComponents\\Shoulder\\" + leftTexName + raceSuffix + ".blp";
-                                        if (assetManager_->fileExists(suffixedTex)) leftTexPath = suffixedTex;
-                                    }
-                                    if (leftTexPath.empty()) {
-                                        leftTexPath = "Item\\ObjectComponents\\Shoulder\\" + leftTexName + ".blp";
-                                    }
-                                }
-                                bool attached = charRenderer->attachWeapon(instanceId, 5, leftModel, leftModelId, leftTexPath);
-                                if (attached) {
-                                    LOG_DEBUG("NPC attached left shoulder: ", leftPath, " tex: ", leftTexPath);
-                                }
-                            }
-                        }
-                    }
-
-                    // Right shoulder (attachment point 6) using RightModel
-                    std::string rightModelName = itemDisplayDbc->getString(static_cast<uint32_t>(shoulderIdx), rightModelField);
-                    if (!rightModelName.empty()) {
-                        size_t dotPos = rightModelName.rfind('.');
-                        if (dotPos != std::string::npos) rightModelName = rightModelName.substr(0, dotPos);
-
-                        std::string rightPath;
-                        std::vector<uint8_t> rightData;
-                        if (!raceSuffix.empty()) {
-                            rightPath = "Item\\ObjectComponents\\Shoulder\\" + rightModelName + raceSuffix + ".m2";
-                            rightData = assetManager_->readFile(rightPath);
-                        }
-                        if (rightData.empty()) {
-                            rightPath = "Item\\ObjectComponents\\Shoulder\\" + rightModelName + ".m2";
-                            rightData = assetManager_->readFile(rightPath);
-                        }
-                        if (!rightData.empty()) {
-                            auto rightModel = pipeline::M2Loader::load(rightData);
-                            std::string skinPath = rightPath.substr(0, rightPath.size() - 3) + "00.skin";
-                            auto skinData = assetManager_->readFile(skinPath);
-                            if (!skinData.empty() && rightModel.version >= 264) {
-                                pipeline::M2Loader::loadSkin(skinData, rightModel);
-                            }
-                            if (rightModel.isValid()) {
-                                uint32_t rightModelId = nextCreatureModelId_++;
-                                std::string rightTexName = itemDisplayDbc->getString(static_cast<uint32_t>(shoulderIdx), rightTexFieldS);
-                                std::string rightTexPath;
-                                if (!rightTexName.empty()) {
-                                    if (!raceSuffix.empty()) {
-                                        std::string suffixedTex = "Item\\ObjectComponents\\Shoulder\\" + rightTexName + raceSuffix + ".blp";
-                                        if (assetManager_->fileExists(suffixedTex)) rightTexPath = suffixedTex;
-                                    }
-                                    if (rightTexPath.empty()) {
-                                        rightTexPath = "Item\\ObjectComponents\\Shoulder\\" + rightTexName + ".blp";
-                                    }
-                                }
-                                bool attached = charRenderer->attachWeapon(instanceId, 6, rightModel, rightModelId, rightTexPath);
-                                if (attached) {
-                                    LOG_DEBUG("NPC attached right shoulder: ", rightPath, " tex: ", rightTexPath);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    // With full humanoid overrides disabled, some character-style NPC models still render
-    // conflicting clothing geosets at once (global capes, robe skirts over trousers).
-    // Normalize only clothing groups while leaving all other model batches untouched.
-    if (const auto* md = charRenderer->getModelData(modelId)) {
-        std::unordered_set<uint16_t> allGeosets;
-        std::unordered_map<uint16_t, uint16_t> firstByGroup;
-        bool hasGroup3 = false;  // glove/forearm variants
-        bool hasGroup4 = false;  // glove/forearm variants (some models)
-        bool hasGroup8 = false;  // sleeve/wrist variants
-        bool hasGroup12 = false; // tabard variants
-        bool hasGroup13 = false; // trousers/robe skirt variants
-        bool hasGroup15 = false; // cloak variants
-        for (const auto& b : md->batches) {
-            const uint16_t sid = b.submeshId;
-            const uint16_t group = static_cast<uint16_t>(sid / 100);
-            allGeosets.insert(sid);
-            auto itFirst = firstByGroup.find(group);
-            if (itFirst == firstByGroup.end() || sid < itFirst->second) {
-                firstByGroup[group] = sid;
-            }
-            if (group == 3) hasGroup3 = true;
-            if (group == 4) hasGroup4 = true;
-            if (group == 8) hasGroup8 = true;
-            if (group == 12) hasGroup12 = true;
-            if (group == 13) hasGroup13 = true;
-            if (group == 15) hasGroup15 = true;
-        }
-
-        // Only apply to humanoid-like clothing models.
-        if (hasGroup3 || hasGroup4 || hasGroup8 || hasGroup12 || hasGroup13 || hasGroup15) {
-            bool hasRenderableCape = false;
-            bool hasEquippedTabard = false;
-            bool hasHumanoidExtra = false;
-            uint8_t extraRaceId = 0;
-            uint8_t extraSexId = 0;
-            uint16_t selectedHairScalp = 1;
-            uint16_t selectedFacial200 = 200;
-            uint16_t selectedFacial300 = 300;
-            uint16_t selectedFacial300Alt = 300;
-            bool wantsFacialHair = false;
-            uint32_t equipChestGG = 0, equipLegsGG = 0, equipFeetGG = 0;
-            std::unordered_set<uint16_t> hairScalpGeosetsForRaceSex;
-            if (itDisplayData != displayDataMap_.end() &&
-                itDisplayData->second.extraDisplayId != 0) {
-                auto itExtra = humanoidExtraMap_.find(itDisplayData->second.extraDisplayId);
-                if (itExtra != humanoidExtraMap_.end()) {
-                    hasHumanoidExtra = true;
-                    extraRaceId = itExtra->second.raceId;
-                    extraSexId = itExtra->second.sexId;
-                    hasEquippedTabard = (itExtra->second.equipDisplayId[9] != 0);
-                    uint32_t hairKey = (static_cast<uint32_t>(extraRaceId) << 16) |
-                                       (static_cast<uint32_t>(extraSexId) << 8) |
-                                       static_cast<uint32_t>(itExtra->second.hairStyleId);
-                    auto itHairGeo = hairGeosetMap_.find(hairKey);
-                    if (itHairGeo != hairGeosetMap_.end() && itHairGeo->second > 0) {
-                        selectedHairScalp = itHairGeo->second;
-                    }
-                    uint32_t facialKey = (static_cast<uint32_t>(extraRaceId) << 16) |
-                                         (static_cast<uint32_t>(extraSexId) << 8) |
-                                         static_cast<uint32_t>(itExtra->second.facialHairId);
-                    wantsFacialHair = (itExtra->second.facialHairId != 0);
-                    auto itFacial = facialHairGeosetMap_.find(facialKey);
-                    if (itFacial != facialHairGeosetMap_.end()) {
-                        selectedFacial200 = static_cast<uint16_t>(200 + itFacial->second.geoset200);
-                        selectedFacial300 = static_cast<uint16_t>(300 + itFacial->second.geoset300);
-                        selectedFacial300Alt = static_cast<uint16_t>(300 + itFacial->second.geoset200);
-                    }
-                    for (const auto& [k, v] : hairGeosetMap_) {
-                        uint8_t race = static_cast<uint8_t>((k >> 16) & 0xFF);
-                        uint8_t sex = static_cast<uint8_t>((k >> 8) & 0xFF);
-                        if (race == extraRaceId && sex == extraSexId && v > 0 && v < 100) {
-                            hairScalpGeosetsForRaceSex.insert(v);
-                        }
-                    }
-                    auto itemDisplayDbc = assetManager_->loadDBC("ItemDisplayInfo.dbc");
-                    const auto* idiL = pipeline::getActiveDBCLayout()
-                        ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
-
-                    uint32_t capeDisplayId = itExtra->second.equipDisplayId[10];
-                    if (capeDisplayId != 0 && itemDisplayDbc) {
-                            int32_t recIdx = itemDisplayDbc->findRecordById(capeDisplayId);
-                            if (recIdx >= 0) {
-                                const uint32_t leftTexField = idiL ? (*idiL)["LeftModelTexture"] : 3u;
-                                const uint32_t rightTexField = idiL ? (*idiL)["RightModelTexture"] : 4u;
-                                std::vector<std::string> capeNames;
-                                auto addName = [&](const std::string& n) {
-                                    if (!n.empty() &&
-                                        std::find(capeNames.begin(), capeNames.end(), n) == capeNames.end()) {
-                                        capeNames.push_back(n);
-                                    }
-                                };
-                                addName(itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), leftTexField));
-                                addName(itemDisplayDbc->getString(static_cast<uint32_t>(recIdx), rightTexField));
-
-                                auto hasBlpExt = [](const std::string& p) {
-                                    if (p.size() < 4) return false;
-                                    std::string ext = p.substr(p.size() - 4);
-                                    std::transform(ext.begin(), ext.end(), ext.begin(),
-                                                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-                                    return ext == ".blp";
-                                };
-
-                                const bool npcIsFemale = (itExtra->second.sexId == 1);
-                                std::vector<std::string> candidates;
-                                auto addCandidate = [&](const std::string& p) {
-                                    if (p.empty()) return;
-                                    if (std::find(candidates.begin(), candidates.end(), p) == candidates.end()) {
-                                        candidates.push_back(p);
-                                    }
-                                };
-
-                                for (const auto& raw : capeNames) {
-                                    std::string name = raw;
-                                    std::replace(name.begin(), name.end(), '/', '\\');
-                                    const bool hasDir = (name.find('\\') != std::string::npos);
-                                    const bool hasExt = hasBlpExt(name);
-                                    if (hasDir) {
-                                        addCandidate(name);
-                                        if (!hasExt) addCandidate(name + ".blp");
-                                    } else {
-                                        std::string baseObj = "Item\\ObjectComponents\\Cape\\" + name;
-                                        std::string baseTex = "Item\\TextureComponents\\Cape\\" + name;
-                                        addCandidate(baseObj);
-                                        addCandidate(baseTex);
-                                        if (!hasExt) {
-                                            addCandidate(baseObj + ".blp");
-                                            addCandidate(baseTex + ".blp");
-                                        }
-                                        addCandidate(baseObj + (npcIsFemale ? "_F.blp" : "_M.blp"));
-                                        addCandidate(baseObj + "_U.blp");
-                                        addCandidate(baseTex + (npcIsFemale ? "_F.blp" : "_M.blp"));
-                                        addCandidate(baseTex + "_U.blp");
-                                    }
-                                }
-
-                                for (const auto& p : candidates) {
-                                    if (assetManager_->fileExists(p)) {
-                                        hasRenderableCape = true;
-                                        break;
-                                    }
-                                }
-                            }
-                    }
-
-                    // Read GeosetGroup1 from equipment to drive clothed mesh selection
-                    if (itemDisplayDbc) {
-                        const uint32_t fGG1 = idiL ? (*idiL)["GeosetGroup1"] : 7;
-                        auto readGG = [&](uint32_t did) -> uint32_t {
-                            if (did == 0) return 0;
-                            int32_t idx = itemDisplayDbc->findRecordById(did);
-                            return (idx >= 0) ? itemDisplayDbc->getUInt32(static_cast<uint32_t>(idx), fGG1) : 0;
-                        };
-                        equipChestGG = readGG(itExtra->second.equipDisplayId[3]);
-                        if (equipChestGG == 0) equipChestGG = readGG(itExtra->second.equipDisplayId[2]); // shirt fallback
-                        equipLegsGG = readGG(itExtra->second.equipDisplayId[5]);
-                        equipFeetGG = readGG(itExtra->second.equipDisplayId[6]);
-                    }
-                }
-            }
-
-            std::unordered_set<uint16_t> normalizedGeosets;
-            for (uint16_t sid : allGeosets) {
-                const uint16_t group = static_cast<uint16_t>(sid / 100);
-                if (group == 3 || group == 4 || group == 8 || group == 12 || group == 13 || group == 15) continue;
-                // Some humanoid models carry cloak cloth in group 16. Strip this too
-                // when no cape is equipped to avoid "everyone has a cape".
-                if (!hasRenderableCape && group == 16) continue;
-                // Group 0 can contain multiple scalp/hair meshes. Keep only the selected
-                // race/sex/style scalp to avoid overlapping broken hair.
-                if (hasHumanoidExtra && sid < 100 && hairScalpGeosetsForRaceSex.count(sid) > 0 && sid != selectedHairScalp) {
-                    continue;
-                }
-                // Group 1 contains connector variants that mirror scalp style.
-                if (hasHumanoidExtra && group == 1) {
-                    const uint16_t selectedConnector = static_cast<uint16_t>(100 + std::max<uint16_t>(selectedHairScalp, 1));
-                    if (sid != selectedConnector) {
-                        // Keep fallback connector only when selected one does not exist on this model.
-                        if (sid != 101 || allGeosets.count(selectedConnector) > 0) {
-                            continue;
-                        }
-                    }
-                }
-                // Group 2 facial variants: keep selected variant; fallback only if missing.
-                if (hasHumanoidExtra && group == 2) {
-                    if (!wantsFacialHair) {
-                        continue;
-                    }
-                    if (sid != selectedFacial200) {
-                        if (sid != 200 && sid != 201) {
-                            continue;
-                        }
-                        if (allGeosets.count(selectedFacial200) > 0) {
-                            continue;
-                        }
-                    }
-                }
-                normalizedGeosets.insert(sid);
-            }
-
-            auto pickFromGroup = [&](uint16_t preferredSid, uint16_t group) -> uint16_t {
-                if (allGeosets.count(preferredSid) > 0) return preferredSid;
-                auto it = firstByGroup.find(group);
-                if (it != firstByGroup.end()) return it->second;
-                return 0;
-            };
-
-            // Intentionally do not add group 3 (glove/forearm accessory meshes).
-            // Even "bare" variants can produce unwanted looped arm geometry on NPCs.
-
-            if (hasGroup4) {
-                uint16_t wantBoots = (equipFeetGG > 0) ? static_cast<uint16_t>(400 + equipFeetGG) : kGeosetBareForearms;
-                uint16_t bootsSid = pickFromGroup(wantBoots, 4);
-                if (bootsSid != 0) normalizedGeosets.insert(bootsSid);
-            }
-
-            // Add sleeve/wrist meshes when chest armor calls for them.
-            if (hasGroup8 && equipChestGG > 0) {
-                uint16_t wantSleeves = static_cast<uint16_t>(800 + equipChestGG);
-                uint16_t sleeveSid = pickFromGroup(wantSleeves, 8);
-                if (sleeveSid != 0) normalizedGeosets.insert(sleeveSid);
-            }
-
-            // Show tabard mesh only when CreatureDisplayInfoExtra equips one.
-            if (hasGroup12 && hasEquippedTabard) {
-                uint16_t wantTabard = kGeosetDefaultTabard;  // Default fallback
-
-                // Try to read tabard geoset variant from ItemDisplayInfo.dbc (slot 9)
-                if (hasHumanoidExtra && itDisplayData != displayDataMap_.end() &&
-                    itDisplayData->second.extraDisplayId != 0) {
-                    auto itExtra = humanoidExtraMap_.find(itDisplayData->second.extraDisplayId);
-                    if (itExtra != humanoidExtraMap_.end()) {
-                        uint32_t tabardDisplayId = itExtra->second.equipDisplayId[9];
-                        if (tabardDisplayId != 0) {
-                            auto itemDisplayDbc = assetManager_->loadDBC("ItemDisplayInfo.dbc");
-                            const auto* idiL = pipeline::getActiveDBCLayout()
-                                ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
-                            if (itemDisplayDbc && idiL) {
-                                int32_t tabardIdx = itemDisplayDbc->findRecordById(tabardDisplayId);
-                                if (tabardIdx >= 0) {
-                                    // Get geoset variant from ItemDisplayInfo GeosetGroup1 field
-                                    const uint32_t ggField = (*idiL)["GeosetGroup1"];
-                                    uint32_t tabardGG = itemDisplayDbc->getUInt32(static_cast<uint32_t>(tabardIdx), ggField);
-                                    if (tabardGG > 0) {
-                                        wantTabard = static_cast<uint16_t>(1200 + tabardGG);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-
-                uint16_t tabardSid = pickFromGroup(wantTabard, 12);
-                if (tabardSid != 0) normalizedGeosets.insert(tabardSid);
-            }
-
-            // Some mustache/goatee variants are authored in facial group 3xx.
-            // Re-add selected facial 3xx plus low-index facial fallbacks.
-            if (hasHumanoidExtra && wantsFacialHair) {
-                // Prefer alt channel first (often chin-beard), then primary.
-                uint16_t facial300Sid = pickFromGroup(selectedFacial300Alt, 3);
-                if (facial300Sid == 0) facial300Sid = pickFromGroup(selectedFacial300, 3);
-                if (facial300Sid != 0) normalizedGeosets.insert(facial300Sid);
-                if (facial300Sid == 0) {
-                    if (allGeosets.count(300) > 0) normalizedGeosets.insert(300);
-                    else if (allGeosets.count(301) > 0) normalizedGeosets.insert(301);
-                }
-            }
-
-            // Prefer trousers geoset; use covered variant when legs armor exists.
-            if (hasGroup13) {
-                uint16_t wantPants = (equipLegsGG > 0) ? static_cast<uint16_t>(1300 + equipLegsGG) : kGeosetBarePants;
-                uint16_t pantsSid = pickFromGroup(wantPants, 13);
-                if (pantsSid != 0) normalizedGeosets.insert(pantsSid);
-            }
-
-            // Prefer explicit cloak variant only when a cape is equipped.
-            if (hasGroup15 && hasRenderableCape) {
-                uint16_t capeSid = pickFromGroup(kGeosetWithCape, 15);
-                if (capeSid != 0) normalizedGeosets.insert(capeSid);
-            }
-
-            if (!normalizedGeosets.empty()) {
-                charRenderer->setActiveGeosets(instanceId, normalizedGeosets);
-            }
-        }
-    }
-
-    // Try attaching NPC held weapons; if update fields are not ready yet,
-    // IN_GAME retry loop will attempt again shortly.
-    bool weaponsAttachedNow = tryAttachCreatureVirtualWeapons(guid, instanceId);
-
-    // Spawn in the correct pose. If the server marked this creature dead before
-    // the queued spawn was processed, start directly in death animation.
-    if (deadCreatureGuids_.count(guid)) {
-        charRenderer->playAnimation(instanceId, rendering::anim::DEATH, false);
-    } else {
-        // Check if this NPC has a persistent emote state (e.g. working, eating, dancing)
-        uint32_t npcEmote = 0;
-        if (gameHandler_) {
-            auto entity = gameHandler_->getEntityManager().getEntity(guid);
-            if (entity && entity->getType() == game::ObjectType::UNIT) {
-                npcEmote = std::static_pointer_cast<game::Unit>(entity)->getNpcEmoteState();
-            }
-        }
-        if (npcEmote != 0 && charRenderer->hasAnimation(instanceId, npcEmote)) {
-            charRenderer->playAnimation(instanceId, npcEmote, true);
-        } else if (charRenderer->hasAnimation(instanceId, rendering::anim::BIRTH)) {
-            // Play birth animation (one-shot) — will return to STAND after
-            charRenderer->playAnimation(instanceId, rendering::anim::BIRTH, false);
-        } else if (charRenderer->hasAnimation(instanceId, rendering::anim::SPAWN)) {
-            charRenderer->playAnimation(instanceId, rendering::anim::SPAWN, false);
-        } else {
-            charRenderer->playAnimation(instanceId, rendering::anim::STAND, true);
-        }
-    }
-    charRenderer->startFadeIn(instanceId, 0.5f);
-
-    // Track instance
-    creatureInstances_[guid] = instanceId;
-    creatureModelIds_[guid] = modelId;
-    creatureRenderPosCache_[guid] = renderPos;
-    if (weaponsAttachedNow) {
-        creatureWeaponsAttached_.insert(guid);
-        creatureWeaponAttachAttempts_.erase(guid);
-    } else {
-        creatureWeaponsAttached_.erase(guid);
-        creatureWeaponAttachAttempts_[guid] = 1;
-    }
-    LOG_DEBUG("Spawned creature: guid=0x", std::hex, guid, std::dec,
-             " displayId=", displayId, " at (", x, ", ", y, ", ", z, ")");
-}
-
-void EntitySpawner::spawnOnlinePlayer(uint64_t guid,
-                                    uint8_t raceId,
-                                    uint8_t genderId,
-                                    uint32_t appearanceBytes,
-                                    uint8_t facialFeatures,
-                                    float x, float y, float z, float orientation) {
-    if (!renderer_ || !renderer_->getCharacterRenderer() || !assetManager_ || !assetManager_->isInitialized()) return;
-    if (playerInstances_.count(guid)) return;
-
-    // Skip local player — already spawned as the main character
-    if (gameHandler_) {
-        uint64_t localGuid = gameHandler_->getPlayerGuid();
-        uint64_t activeGuid = gameHandler_->getActiveCharacterGuid();
-        if ((localGuid != 0 && guid == localGuid) ||
-            (activeGuid != 0 && guid == activeGuid) ||
-            (spawnedPlayerGuid_ != 0 && guid == spawnedPlayerGuid_)) {
-            return;
-        }
-    }
-    auto* charRenderer = renderer_->getCharacterRenderer();
-
-    // Base geometry model: cache by (race, gender)
-    uint32_t cacheKey = (static_cast<uint32_t>(raceId) << 8) | static_cast<uint32_t>(genderId & 0xFF);
-    uint32_t modelId = 0;
-    auto itCache = playerModelCache_.find(cacheKey);
-    if (itCache != playerModelCache_.end()) {
-        modelId = itCache->second;
-    } else {
-        game::Race race = static_cast<game::Race>(raceId);
-        game::Gender gender = (genderId == 1) ? game::Gender::FEMALE : game::Gender::MALE;
-        std::string m2Path = game::getPlayerModelPath(race, gender);
-        if (m2Path.empty()) {
-            LOG_WARNING("spawnOnlinePlayer: unknown race/gender for guid 0x", std::hex, guid, std::dec,
-                        " race=", static_cast<int>(raceId), " gender=", static_cast<int>(genderId));
-            return;
-        }
-
-        // Parse modelDir/baseName for skin/anim loading
-        std::string modelDir;
-        std::string baseName;
-        {
-            size_t slash = m2Path.rfind('\\');
-            if (slash != std::string::npos) {
-                modelDir = m2Path.substr(0, slash + 1);
-                baseName = m2Path.substr(slash + 1);
-            } else {
-                baseName = m2Path;
-            }
-            size_t dot = baseName.rfind('.');
-            if (dot != std::string::npos) baseName = baseName.substr(0, dot);
-        }
-
-        auto m2Data = assetManager_->readFile(m2Path);
-        if (m2Data.empty()) {
-            LOG_WARNING("spawnOnlinePlayer: failed to read M2: ", m2Path);
-            return;
-        }
-
-        pipeline::M2Model model = pipeline::M2Loader::load(m2Data);
-        if (model.vertices.empty()) {
-            LOG_WARNING("spawnOnlinePlayer: failed to parse M2: ", m2Path);
-            return;
-        }
-
-        // Skin file (only for WotLK M2s - vanilla has embedded skin)
-        std::string skinPath = modelDir + baseName + "00.skin";
-        auto skinData = assetManager_->readFile(skinPath);
-        if (!skinData.empty() && model.version >= 264) {
-            pipeline::M2Loader::loadSkin(skinData, model);
-        }
-
-        // After skin loading, full model must be valid (vertices + indices)
-        if (!model.isValid()) {
-            LOG_WARNING("spawnOnlinePlayer: failed to load skin for M2: ", m2Path);
-            return;
-        }
-
-        // Load only core external animations (stand/walk/run) to avoid stalls
-        for (uint32_t si = 0; si < model.sequences.size(); si++) {
-            if (!(model.sequences[si].flags & 0x20)) {
-                uint32_t animId = model.sequences[si].id;
-                if (animId != rendering::anim::STAND && animId != rendering::anim::WALK && animId != rendering::anim::RUN) continue;
-                char animFileName[256];
-                snprintf(animFileName, sizeof(animFileName),
-                         "%s%s%04u-%02u.anim",
-                         modelDir.c_str(),
-                         baseName.c_str(),
-                         animId,
-                         model.sequences[si].variationIndex);
-                auto animData = assetManager_->readFileOptional(animFileName);
-                if (!animData.empty()) {
-                    pipeline::M2Loader::loadAnimFile(m2Data, animData, si, model);
-                }
-            }
-        }
-
-        modelId = nextPlayerModelId_++;
-        if (!charRenderer->loadModel(model, modelId)) {
-            LOG_WARNING("spawnOnlinePlayer: failed to load model to GPU: ", m2Path);
-            return;
-        }
-
-        playerModelCache_[cacheKey] = modelId;
-    }
-
-    // Determine texture slots once per model
-    {
-        auto [slotIt, inserted] = playerTextureSlotsByModelId_.try_emplace(modelId);
-        if (inserted) {
-            PlayerTextureSlots slots;
-            if (const auto* md = charRenderer->getModelData(modelId)) {
-                for (size_t ti = 0; ti < md->textures.size(); ti++) {
-                    uint32_t t = md->textures[ti].type;
-                    if (t == 1 && slots.skin < 0) slots.skin = static_cast<int>(ti);
-                    else if (t == 6 && slots.hair < 0) slots.hair = static_cast<int>(ti);
-                    else if (t == 8 && slots.underwear < 0) slots.underwear = static_cast<int>(ti);
-                }
-            }
-            slotIt->second = slots;
-        }
-    }
-
-    // Create instance at server position
-    glm::vec3 renderPos = core::coords::canonicalToRender(glm::vec3(x, y, z));
-    float renderYaw = orientation + glm::radians(90.0f);
-    uint32_t instanceId = charRenderer->createInstance(modelId, renderPos, glm::vec3(0.0f, 0.0f, renderYaw), 1.0f);
-    if (instanceId == 0) return;
-
-    // Resolve skin/hair texture paths via CharSections, then apply as per-instance overrides
-    const char* raceFolderName = "Human";
-    switch (static_cast<game::Race>(raceId)) {
-        case game::Race::HUMAN: raceFolderName = "Human"; break;
-        case game::Race::ORC: raceFolderName = "Orc"; break;
-        case game::Race::DWARF: raceFolderName = "Dwarf"; break;
-        case game::Race::NIGHT_ELF: raceFolderName = "NightElf"; break;
-        case game::Race::UNDEAD: raceFolderName = "Scourge"; break;
-        case game::Race::TAUREN: raceFolderName = "Tauren"; break;
-        case game::Race::GNOME: raceFolderName = "Gnome"; break;
-        case game::Race::TROLL: raceFolderName = "Troll"; break;
-        case game::Race::BLOOD_ELF: raceFolderName = "BloodElf"; break;
-        case game::Race::DRAENEI: raceFolderName = "Draenei"; break;
-        default: break;
-    }
-    const char* genderFolder = (genderId == 1) ? "Female" : "Male";
-    std::string raceGender = std::string(raceFolderName) + genderFolder;
-    std::string bodySkinPath = std::string("Character\\") + raceFolderName + "\\" + genderFolder + "\\" + raceGender + "Skin00_00.blp";
-    std::string pelvisPath = std::string("Character\\") + raceFolderName + "\\" + genderFolder + "\\" + raceGender + "NakedPelvisSkin00_00.blp";
-    std::vector<std::string> underwearPaths;
-    std::string hairTexturePath;
-    std::string faceLowerPath;
-    std::string faceUpperPath;
-
-    uint8_t skinId = appearanceBytes & 0xFF;
-    uint8_t faceId = (appearanceBytes >> 8) & 0xFF;
-    uint8_t hairStyleId = (appearanceBytes >> 16) & 0xFF;
-    uint8_t hairColorId = (appearanceBytes >> 24) & 0xFF;
-
-    if (auto charSectionsDbc = assetManager_->loadDBC("CharSections.dbc"); charSectionsDbc && charSectionsDbc->isLoaded()) {
-        const auto* csL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CharSections") : nullptr;
-        auto csF = pipeline::detectCharSectionsFields(charSectionsDbc.get(), csL);
-        uint32_t targetRaceId = raceId;
-        uint32_t targetSexId = genderId;
-
-        bool foundSkin = false;
-        bool foundUnderwear = false;
-        bool foundHair = false;
-        bool foundFaceLower = false;
-
-        for (uint32_t r = 0; r < charSectionsDbc->getRecordCount(); r++) {
-            uint32_t rRace = charSectionsDbc->getUInt32(r, csF.raceId);
-            uint32_t rSex = charSectionsDbc->getUInt32(r, csF.sexId);
-            uint32_t baseSection = charSectionsDbc->getUInt32(r, csF.baseSection);
-            uint32_t variationIndex = charSectionsDbc->getUInt32(r, csF.variationIndex);
-            uint32_t colorIndex = charSectionsDbc->getUInt32(r, csF.colorIndex);
-
-            if (rRace != targetRaceId || rSex != targetSexId) continue;
-
-            if (baseSection == 0 && !foundSkin && colorIndex == skinId) {
-                std::string tex1 = charSectionsDbc->getString(r, csF.texture1);
-                if (!tex1.empty()) { bodySkinPath = tex1; foundSkin = true; }
-            } else if (baseSection == 3 && !foundHair &&
-                       variationIndex == hairStyleId && colorIndex == hairColorId) {
-                hairTexturePath = charSectionsDbc->getString(r, csF.texture1);
-                if (!hairTexturePath.empty()) foundHair = true;
-            } else if (baseSection == 4 && !foundUnderwear && colorIndex == skinId) {
-                for (uint32_t f = csF.texture1; f <= csF.texture1 + 2; f++) {
-                    std::string tex = charSectionsDbc->getString(r, f);
-                    if (!tex.empty()) underwearPaths.push_back(tex);
-                }
-                foundUnderwear = true;
-            } else if (baseSection == 1 && !foundFaceLower &&
-                       variationIndex == faceId && colorIndex == skinId) {
-                std::string tex1 = charSectionsDbc->getString(r, csF.texture1);
-                std::string tex2 = charSectionsDbc->getString(r, csF.texture2);
-                if (!tex1.empty()) faceLowerPath = tex1;
-                if (!tex2.empty()) faceUpperPath = tex2;
-                foundFaceLower = true;
-            }
-
-            if (foundSkin && foundUnderwear && foundHair && foundFaceLower) break;
-        }
-    }
-
-    // Composite base skin + face + underwear overlays
-    rendering::VkTexture* compositeTex = nullptr;
-    {
-        std::vector<std::string> layers;
-        layers.push_back(bodySkinPath);
-        if (!faceLowerPath.empty()) layers.push_back(faceLowerPath);
-        if (!faceUpperPath.empty()) layers.push_back(faceUpperPath);
-        for (const auto& up : underwearPaths) layers.push_back(up);
-        if (layers.size() > 1) {
-            compositeTex = charRenderer->compositeTextures(layers);
-        } else {
-            compositeTex = charRenderer->loadTexture(bodySkinPath);
-        }
-    }
-
-    rendering::VkTexture* hairTex = nullptr;
-    if (!hairTexturePath.empty()) {
-        hairTex = charRenderer->loadTexture(hairTexturePath);
-    }
-    rendering::VkTexture* underwearTex = nullptr;
-    if (!underwearPaths.empty()) underwearTex = charRenderer->loadTexture(underwearPaths[0]);
-    else underwearTex = charRenderer->loadTexture(pelvisPath);
-
-    const PlayerTextureSlots& slots = playerTextureSlotsByModelId_[modelId];
-    if (slots.skin >= 0 && compositeTex) {
-        charRenderer->setTextureSlotOverride(instanceId, static_cast<uint16_t>(slots.skin), compositeTex);
-    }
-    if (slots.hair >= 0 && hairTex) {
-        charRenderer->setTextureSlotOverride(instanceId, static_cast<uint16_t>(slots.hair), hairTex);
-    }
-    if (slots.underwear >= 0 && underwearTex) {
-        charRenderer->setTextureSlotOverride(instanceId, static_cast<uint16_t>(slots.underwear), underwearTex);
-    }
-
-    // Geosets: body + hair/facial hair selections
-    std::unordered_set<uint16_t> activeGeosets;
-    // Body parts (group 0: IDs 0-99, some models use up to 27)
-    for (uint16_t i = 0; i <= 99; i++) activeGeosets.insert(i);
-    activeGeosets.insert(static_cast<uint16_t>(100 + hairStyleId + 1));
-    activeGeosets.insert(static_cast<uint16_t>(200 + facialFeatures + 1));
-    activeGeosets.insert(kGeosetBareForearms);
-    activeGeosets.insert(kGeosetBareShins);
-    activeGeosets.insert(kGeosetDefaultEars);
-    activeGeosets.insert(kGeosetBareSleeves);
-    activeGeosets.insert(kGeosetDefaultKneepads);
-    activeGeosets.insert(kGeosetBarePants);
-    activeGeosets.insert(kGeosetWithCape);
-    activeGeosets.insert(kGeosetBareFeet);
-    charRenderer->setActiveGeosets(instanceId, activeGeosets);
-
-    charRenderer->playAnimation(instanceId, rendering::anim::STAND, true);
-    playerInstances_[guid] = instanceId;
-
-    OnlinePlayerAppearanceState st;
-    st.instanceId = instanceId;
-    st.modelId = modelId;
-    st.raceId = raceId;
-    st.genderId = genderId;
-    st.appearanceBytes = appearanceBytes;
-    st.facialFeatures = facialFeatures;
-    st.bodySkinPath = bodySkinPath;
-    // Include face textures so compositeWithRegions can rebuild the full base
-    if (!faceLowerPath.empty()) st.underwearPaths.push_back(faceLowerPath);
-    if (!faceUpperPath.empty()) st.underwearPaths.push_back(faceUpperPath);
-    for (const auto& up : underwearPaths) st.underwearPaths.push_back(up);
-    onlinePlayerAppearance_[guid] = std::move(st);
-}
-
-void EntitySpawner::setOnlinePlayerEquipment(uint64_t guid,
-                                          const std::array<uint32_t, 19>& displayInfoIds,
-                                          const std::array<uint8_t, 19>& inventoryTypes) {
-    if (!renderer_ || !renderer_->getCharacterRenderer() || !assetManager_ || !assetManager_->isInitialized()) return;
-
-    // Skip local player — equipment handled by GameScreen::updateCharacterGeosets/Textures
-    // via consumeOnlineEquipmentDirty(), which fires on the same server update.
-    if (gameHandler_) {
-        uint64_t localGuid = gameHandler_->getPlayerGuid();
-        if (localGuid != 0 && guid == localGuid) return;
-    }
-
-    // If the player isn't spawned yet, store equipment until spawn.
-    auto appIt = onlinePlayerAppearance_.find(guid);
-    if (!playerInstances_.count(guid) || appIt == onlinePlayerAppearance_.end()) {
-        pendingOnlinePlayerEquipment_[guid] = {displayInfoIds, inventoryTypes};
-        return;
-    }
-
-    const OnlinePlayerAppearanceState& st = appIt->second;
-
-    auto* charRenderer = renderer_->getCharacterRenderer();
-    if (!charRenderer) return;
-    if (st.instanceId == 0 || st.modelId == 0) return;
-
-    if (st.bodySkinPath.empty()) {
-        LOG_WARNING("setOnlinePlayerEquipment: bodySkinPath empty for guid=0x", std::hex, guid, std::dec,
-                    " instanceId=", st.instanceId, " — skipping equipment");
-        return;
-    }
-
-    int nonZeroDisplay = 0;
-    for (uint32_t d : displayInfoIds) if (d != 0) nonZeroDisplay++;
-    LOG_WARNING("setOnlinePlayerEquipment: guid=0x", std::hex, guid, std::dec,
-                " instanceId=", st.instanceId, " nonZeroDisplayIds=", nonZeroDisplay,
-                " head=", displayInfoIds[0], " chest=", displayInfoIds[4],
-                " legs=", displayInfoIds[6], " mainhand=", displayInfoIds[15]);
-
-    auto displayInfoDbc = assetManager_->loadDBC("ItemDisplayInfo.dbc");
-    if (!displayInfoDbc) return;
-    const auto* idiL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
-
-    auto getGeosetGroup = [&](uint32_t displayInfoId, uint32_t fieldIdx) -> uint32_t {
-        if (displayInfoId == 0) return 0;
-        int32_t recIdx = displayInfoDbc->findRecordById(displayInfoId);
-        if (recIdx < 0) return 0;
-        return displayInfoDbc->getUInt32(static_cast<uint32_t>(recIdx), fieldIdx);
-    };
-
-    auto findDisplayIdByInvType = [&](std::initializer_list<uint8_t> types) -> uint32_t {
-        for (int s = 0; s < 19; s++) {
-            uint8_t inv = inventoryTypes[s];
-            if (inv == 0 || displayInfoIds[s] == 0) continue;
-            for (uint8_t t : types) {
-                if (inv == t) return displayInfoIds[s];
-            }
-        }
-        return 0;
-    };
-
-    auto hasInvType = [&](std::initializer_list<uint8_t> types) -> bool {
-        for (int s = 0; s < 19; s++) {
-            uint8_t inv = inventoryTypes[s];
-            if (inv == 0) continue;
-            for (uint8_t t : types) {
-                if (inv == t) return true;
-            }
-        }
-        return false;
-    };
-
-    // --- Geosets ---
-    // Mirror the same group-range logic as CharacterPreview::applyEquipment to
-    // keep other-player rendering consistent with the local character preview.
-    // Group 4 (4xx) = forearms/gloves, 5 (5xx) = shins/boots, 8 (8xx) = wrists/sleeves,
-    // 13 (13xx) = legs/trousers.  Missing defaults caused the shin-mesh gap (status.md).
-    std::unordered_set<uint16_t> geosets;
-    // Body parts (group 0: IDs 0-99, some models use up to 27)
-    for (uint16_t i = 0; i <= 99; i++) geosets.insert(i);
-
-    uint8_t hairStyleId = static_cast<uint8_t>((st.appearanceBytes >> 16) & 0xFF);
-    geosets.insert(static_cast<uint16_t>(100 + hairStyleId + 1));
-    geosets.insert(static_cast<uint16_t>(200 + st.facialFeatures + 1));
-    geosets.insert(701);                  // Ears
-    geosets.insert(kGeosetDefaultKneepads); // Kneepads
-    geosets.insert(kGeosetBareFeet);        // Bare feet mesh
-
-    const uint32_t geosetGroup1Field = idiL ? (*idiL)["GeosetGroup1"] : 7;
-    const uint32_t geosetGroup3Field = idiL ? (*idiL)["GeosetGroup3"] : 9;
-
-    // Per-group defaults — overridden below when equipment provides a geoset value.
-    uint16_t geosetGloves  = kGeosetBareForearms;
-    uint16_t geosetBoots   = kGeosetBareShins;
-    uint16_t geosetSleeves = kGeosetBareSleeves;
-    uint16_t geosetPants   = kGeosetBarePants;
-
-    // Chest/Shirt/Robe (invType 4,5,20) → wrist/sleeve group 8
-    {
-        uint32_t did = findDisplayIdByInvType({4, 5, 20});
-        uint32_t gg1 = getGeosetGroup(did, geosetGroup1Field);
-        if (gg1 > 0) geosetSleeves = static_cast<uint16_t>(kGeosetBareSleeves + gg1);
-        // Robe kilt → leg group 13
-        uint32_t gg3 = getGeosetGroup(did, geosetGroup3Field);
-        if (gg3 > 0) geosetPants = static_cast<uint16_t>(kGeosetBarePants + gg3);
-    }
-
-    // Legs (invType 7) → leg group 13
-    {
-        uint32_t did = findDisplayIdByInvType({7});
-        uint32_t gg1 = getGeosetGroup(did, geosetGroup1Field);
-        if (gg1 > 0) geosetPants = static_cast<uint16_t>(kGeosetBarePants + gg1);
-    }
-
-    // Feet/Boots (invType 8) → shin group 5
-    {
-        uint32_t did = findDisplayIdByInvType({8});
-        uint32_t gg1 = getGeosetGroup(did, geosetGroup1Field);
-        if (gg1 > 0) geosetBoots = static_cast<uint16_t>(501 + gg1);
-    }
-
-    // Hands/Gloves (invType 10) → forearm group 4
-    {
-        uint32_t did = findDisplayIdByInvType({10});
-        uint32_t gg1 = getGeosetGroup(did, geosetGroup1Field);
-        if (gg1 > 0) geosetGloves = static_cast<uint16_t>(kGeosetBareForearms + gg1);
-    }
-
-    // Wrists/Bracers (invType 9) → sleeve group 8 (only if chest/shirt didn't set it)
-    {
-        uint32_t did = findDisplayIdByInvType({9});
-        if (did != 0 && geosetSleeves == kGeosetBareSleeves) {
-            uint32_t gg1 = getGeosetGroup(did, geosetGroup1Field);
-            if (gg1 > 0) geosetSleeves = static_cast<uint16_t>(kGeosetBareSleeves + gg1);
-        }
-    }
-
-    // Waist/Belt (invType 6) → buckle group 18
-    uint16_t geosetBelt = 0;
-    {
-        uint32_t did = findDisplayIdByInvType({6});
-        uint32_t gg1 = getGeosetGroup(did, geosetGroup1Field);
-        if (gg1 > 0) geosetBelt = static_cast<uint16_t>(1801 + gg1);
-    }
-
-    geosets.insert(geosetGloves);
-    geosets.insert(geosetBoots);
-    geosets.insert(geosetSleeves);
-    geosets.insert(geosetPants);
-    if (geosetBelt != 0) geosets.insert(geosetBelt);
-    // Back/Cloak (invType 16)
-    geosets.insert(hasInvType({16}) ? kGeosetWithCape : kGeosetNoCape);
-    // Tabard (invType 19)
-    if (hasInvType({19})) geosets.insert(kGeosetDefaultTabard);
-
-    // Hide hair under helmets: replace style-specific scalp with bald scalp
-    // HEAD slot is index 0 in the 19-element equipment array
-    if (displayInfoIds[0] != 0 && hairStyleId > 0) {
-        uint16_t hairGeoset = static_cast<uint16_t>(hairStyleId + 1);
-        geosets.erase(static_cast<uint16_t>(100 + hairGeoset)); // Remove style group 1
-        geosets.insert(kGeosetDefaultConnector);  // Default group 1 connector
-    }
-
-    charRenderer->setActiveGeosets(st.instanceId, geosets);
-
-    // --- Helmet model attachment ---
-    // HEAD slot is index 0 in the 19-element equipment array.
-    // Helmet M2s are race/gender-specific (e.g. Helm_Plate_B_01_HuM.m2 for Human Male).
-    if (displayInfoIds[0] != 0) {
-        // Detach any previously attached helmet before attaching a new one
-        charRenderer->detachWeapon(st.instanceId, 0);
-        charRenderer->detachWeapon(st.instanceId, 11);
-
-        int32_t helmIdx = displayInfoDbc->findRecordById(displayInfoIds[0]);
-        if (helmIdx >= 0) {
-            const uint32_t leftModelField = idiL ? (*idiL)["LeftModel"] : 1u;
-            std::string helmModelName = displayInfoDbc->getString(static_cast<uint32_t>(helmIdx), leftModelField);
-            if (!helmModelName.empty()) {
-                // Strip .mdx/.m2 extension
-                size_t dotPos = helmModelName.rfind('.');
-                if (dotPos != std::string::npos) helmModelName = helmModelName.substr(0, dotPos);
-
-                // Race/gender suffix for helmet variants
-                static const std::unordered_map<uint8_t, std::string> racePrefix = {
-                    {1, "Hu"}, {2, "Or"}, {3, "Dw"}, {4, "Ni"}, {5, "Sc"},
-                    {6, "Ta"}, {7, "Gn"}, {8, "Tr"}, {10, "Be"}, {11, "Dr"}
-                };
-                std::string genderSuffix = (st.genderId == 0) ? "M" : "F";
-                std::string raceSuffix;
-                auto itRace = racePrefix.find(st.raceId);
-                if (itRace != racePrefix.end()) {
-                    raceSuffix = "_" + itRace->second + genderSuffix;
-                }
-
-                // Try race/gender-specific variant first, then base name
-                std::string helmPath;
-                pipeline::M2Model helmModel;
-                if (!raceSuffix.empty()) {
-                    helmPath = "Item\\ObjectComponents\\Head\\" + helmModelName + raceSuffix + ".m2";
-                    if (!loadWeaponM2(helmPath, helmModel)) helmModel = {};
-                }
-                if (!helmModel.isValid()) {
-                    helmPath = "Item\\ObjectComponents\\Head\\" + helmModelName + ".m2";
-                    loadWeaponM2(helmPath, helmModel);
-                }
-
-                if (helmModel.isValid()) {
-                    uint32_t helmModelId = nextWeaponModelId_++;
-                    // Get texture from ItemDisplayInfo (LeftModelTexture)
-                    const uint32_t leftTexField = idiL ? (*idiL)["LeftModelTexture"] : 3u;
-                    std::string helmTexName = displayInfoDbc->getString(static_cast<uint32_t>(helmIdx), leftTexField);
-                    std::string helmTexPath;
-                    if (!helmTexName.empty()) {
-                        if (!raceSuffix.empty()) {
-                            std::string suffixedTex = "Item\\ObjectComponents\\Head\\" + helmTexName + raceSuffix + ".blp";
-                            if (assetManager_->fileExists(suffixedTex)) helmTexPath = suffixedTex;
-                        }
-                        if (helmTexPath.empty()) {
-                            helmTexPath = "Item\\ObjectComponents\\Head\\" + helmTexName + ".blp";
-                        }
-                    }
-                    // Attachment point 0 (head bone), fallback to 11 (explicit head attachment)
-                    bool attached = charRenderer->attachWeapon(st.instanceId, 0, helmModel, helmModelId, helmTexPath);
-                    if (!attached) {
-                        attached = charRenderer->attachWeapon(st.instanceId, 11, helmModel, helmModelId, helmTexPath);
-                    }
-                    if (attached) {
-                        LOG_DEBUG("Attached player helmet: ", helmPath, " tex: ", helmTexPath);
-                    }
-                }
-            }
-        }
-    } else {
-        // No helmet equipped — detach any existing helmet model
-        charRenderer->detachWeapon(st.instanceId, 0);
-        charRenderer->detachWeapon(st.instanceId, 11);
-    }
-
-    // --- Shoulder model attachment ---
-    // SHOULDERS slot is index 2 in the 19-element equipment array.
-    // Shoulders have TWO M2 models (left + right) attached at points 5 and 6.
-    // ItemDisplayInfo.dbc: LeftModel → left shoulder, RightModel → right shoulder.
-    if (displayInfoIds[2] != 0) {
-        // Detach any previously attached shoulder models
-        charRenderer->detachWeapon(st.instanceId, 5);
-        charRenderer->detachWeapon(st.instanceId, 6);
-
-        int32_t shoulderIdx = displayInfoDbc->findRecordById(displayInfoIds[2]);
-        if (shoulderIdx >= 0) {
-            const uint32_t leftModelField = idiL ? (*idiL)["LeftModel"] : 1u;
-            const uint32_t rightModelField = idiL ? (*idiL)["RightModel"] : 2u;
-            const uint32_t leftTexField = idiL ? (*idiL)["LeftModelTexture"] : 3u;
-            const uint32_t rightTexField = idiL ? (*idiL)["RightModelTexture"] : 4u;
-
-            // Race/gender suffix for shoulder variants (same as helmets)
-            static const std::unordered_map<uint8_t, std::string> shoulderRacePrefix = {
-                {1, "Hu"}, {2, "Or"}, {3, "Dw"}, {4, "Ni"}, {5, "Sc"},
-                {6, "Ta"}, {7, "Gn"}, {8, "Tr"}, {10, "Be"}, {11, "Dr"}
-            };
-            std::string genderSuffix = (st.genderId == 0) ? "M" : "F";
-            std::string raceSuffix;
-            auto itRace = shoulderRacePrefix.find(st.raceId);
-            if (itRace != shoulderRacePrefix.end()) {
-                raceSuffix = "_" + itRace->second + genderSuffix;
-            }
-
-            // Attach left shoulder (attachment point 5) using LeftModel
-            std::string leftModelName = displayInfoDbc->getString(static_cast<uint32_t>(shoulderIdx), leftModelField);
-            if (!leftModelName.empty()) {
-                size_t dotPos = leftModelName.rfind('.');
-                if (dotPos != std::string::npos) leftModelName = leftModelName.substr(0, dotPos);
-
-                std::string leftPath;
-                pipeline::M2Model leftModel;
-                if (!raceSuffix.empty()) {
-                    leftPath = "Item\\ObjectComponents\\Shoulder\\" + leftModelName + raceSuffix + ".m2";
-                    if (!loadWeaponM2(leftPath, leftModel)) leftModel = {};
-                }
-                if (!leftModel.isValid()) {
-                    leftPath = "Item\\ObjectComponents\\Shoulder\\" + leftModelName + ".m2";
-                    loadWeaponM2(leftPath, leftModel);
-                }
-
-                if (leftModel.isValid()) {
-                    uint32_t leftModelId = nextWeaponModelId_++;
-                    std::string leftTexName = displayInfoDbc->getString(static_cast<uint32_t>(shoulderIdx), leftTexField);
-                    std::string leftTexPath;
-                    if (!leftTexName.empty()) {
-                        if (!raceSuffix.empty()) {
-                            std::string suffixedTex = "Item\\ObjectComponents\\Shoulder\\" + leftTexName + raceSuffix + ".blp";
-                            if (assetManager_->fileExists(suffixedTex)) leftTexPath = suffixedTex;
-                        }
-                        if (leftTexPath.empty()) {
-                            leftTexPath = "Item\\ObjectComponents\\Shoulder\\" + leftTexName + ".blp";
-                        }
-                    }
-                    bool attached = charRenderer->attachWeapon(st.instanceId, 5, leftModel, leftModelId, leftTexPath);
-                    if (attached) {
-                        LOG_DEBUG("Attached left shoulder: ", leftPath, " tex: ", leftTexPath);
-                    }
-                }
-            }
-
-            // Attach right shoulder (attachment point 6) using RightModel
-            std::string rightModelName = displayInfoDbc->getString(static_cast<uint32_t>(shoulderIdx), rightModelField);
-            if (!rightModelName.empty()) {
-                size_t dotPos = rightModelName.rfind('.');
-                if (dotPos != std::string::npos) rightModelName = rightModelName.substr(0, dotPos);
-
-                std::string rightPath;
-                pipeline::M2Model rightModel;
-                if (!raceSuffix.empty()) {
-                    rightPath = "Item\\ObjectComponents\\Shoulder\\" + rightModelName + raceSuffix + ".m2";
-                    if (!loadWeaponM2(rightPath, rightModel)) rightModel = {};
-                }
-                if (!rightModel.isValid()) {
-                    rightPath = "Item\\ObjectComponents\\Shoulder\\" + rightModelName + ".m2";
-                    loadWeaponM2(rightPath, rightModel);
-                }
-
-                if (rightModel.isValid()) {
-                    uint32_t rightModelId = nextWeaponModelId_++;
-                    std::string rightTexName = displayInfoDbc->getString(static_cast<uint32_t>(shoulderIdx), rightTexField);
-                    std::string rightTexPath;
-                    if (!rightTexName.empty()) {
-                        if (!raceSuffix.empty()) {
-                            std::string suffixedTex = "Item\\ObjectComponents\\Shoulder\\" + rightTexName + raceSuffix + ".blp";
-                            if (assetManager_->fileExists(suffixedTex)) rightTexPath = suffixedTex;
-                        }
-                        if (rightTexPath.empty()) {
-                            rightTexPath = "Item\\ObjectComponents\\Shoulder\\" + rightTexName + ".blp";
-                        }
-                    }
-                    bool attached = charRenderer->attachWeapon(st.instanceId, 6, rightModel, rightModelId, rightTexPath);
-                    if (attached) {
-                        LOG_DEBUG("Attached right shoulder: ", rightPath, " tex: ", rightTexPath);
-                    }
-                }
-            }
-        }
-    } else {
-        // No shoulders equipped — detach any existing shoulder models
-        charRenderer->detachWeapon(st.instanceId, 5);
-        charRenderer->detachWeapon(st.instanceId, 6);
-    }
-
-    // --- Cape texture (group 15 / texture type 2) ---
-    // The geoset above enables the cape mesh, but without a texture it renders blank.
-    if (hasInvType({16})) {
-        // Back/cloak is WoW equipment slot 14 (BACK) in the 19-element array.
-        uint32_t capeDid = displayInfoIds[14];
-        if (capeDid != 0) {
-            int32_t capeRecIdx = displayInfoDbc->findRecordById(capeDid);
-            if (capeRecIdx >= 0) {
-                const uint32_t leftTexField = idiL ? (*idiL)["LeftModelTexture"] : 3u;
-                std::string capeName = displayInfoDbc->getString(
-                    static_cast<uint32_t>(capeRecIdx), leftTexField);
-
-                if (!capeName.empty()) {
-                    std::replace(capeName.begin(), capeName.end(), '/', '\\');
-
-                    auto hasBlpExt = [](const std::string& p) {
-                        if (p.size() < 4) return false;
-                        std::string ext = p.substr(p.size() - 4);
-                        std::transform(ext.begin(), ext.end(), ext.begin(),
-                                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-                        return ext == ".blp";
-                    };
-
-                    const bool hasDir = (capeName.find('\\') != std::string::npos);
-                    const bool hasExt = hasBlpExt(capeName);
-
-                    std::vector<std::string> capeCandidates;
-                    auto addCapeCandidate = [&](const std::string& p) {
-                        if (p.empty()) return;
-                        if (std::find(capeCandidates.begin(), capeCandidates.end(), p) == capeCandidates.end()) {
-                            capeCandidates.push_back(p);
-                        }
-                    };
-
-                    if (hasDir) {
-                        addCapeCandidate(capeName);
-                        if (!hasExt) addCapeCandidate(capeName + ".blp");
-                    } else {
-                        std::string baseObj = "Item\\ObjectComponents\\Cape\\" + capeName;
-                        std::string baseTex = "Item\\TextureComponents\\Cape\\" + capeName;
-                        addCapeCandidate(baseObj);
-                        addCapeCandidate(baseTex);
-                        if (!hasExt) {
-                            addCapeCandidate(baseObj + ".blp");
-                            addCapeCandidate(baseTex + ".blp");
-                        }
-                        addCapeCandidate(baseObj + (st.genderId == 1 ? "_F.blp" : "_M.blp"));
-                        addCapeCandidate(baseObj + "_U.blp");
-                        addCapeCandidate(baseTex + (st.genderId == 1 ? "_F.blp" : "_M.blp"));
-                        addCapeCandidate(baseTex + "_U.blp");
-                    }
-
-                    const rendering::VkTexture* whiteTex = charRenderer->loadTexture("");
-                    rendering::VkTexture* capeTexture = nullptr;
-                    for (const auto& candidate : capeCandidates) {
-                        rendering::VkTexture* tex = charRenderer->loadTexture(candidate);
-                        if (tex && tex != whiteTex) {
-                            capeTexture = tex;
-                            break;
-                        }
-                    }
-
-                    if (capeTexture) {
-                        charRenderer->setGroupTextureOverride(st.instanceId, 15, capeTexture);
-                        if (const auto* md = charRenderer->getModelData(st.modelId)) {
-                            for (size_t ti = 0; ti < md->textures.size(); ti++) {
-                                if (md->textures[ti].type == 2) {
-                                    charRenderer->setTextureSlotOverride(
-                                        st.instanceId, static_cast<uint16_t>(ti), capeTexture);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    // --- Textures (skin atlas compositing) ---
-    static constexpr const char* componentDirs[] = {
-        "ArmUpperTexture",
-        "ArmLowerTexture",
-        "HandTexture",
-        "TorsoUpperTexture",
-        "TorsoLowerTexture",
-        "LegUpperTexture",
-        "LegLowerTexture",
-        "FootTexture",
-    };
-
-    uint32_t texRegionFields[8];
-    pipeline::getItemDisplayInfoTextureFields(*displayInfoDbc, idiL, texRegionFields);
-
-    std::vector<std::pair<int, std::string>> regionLayers;
-    const bool isFemale = (st.genderId == 1);
-
-    for (int s = 0; s < 19; s++) {
-        uint32_t did = displayInfoIds[s];
-        if (did == 0) continue;
-        int32_t recIdx = displayInfoDbc->findRecordById(did);
-        if (recIdx < 0) continue;
-
-        for (int region = 0; region < 8; region++) {
-            std::string texName = displayInfoDbc->getString(
-                static_cast<uint32_t>(recIdx), texRegionFields[region]);
-            if (texName.empty()) continue;
-
-            std::string base = "Item\\TextureComponents\\" + std::string(componentDirs[region]) + "\\" + texName;
-            std::string genderPath = base + (isFemale ? "_F.blp" : "_M.blp");
-            std::string unisexPath = base + "_U.blp";
-            std::string fullPath;
-            if (assetManager_->fileExists(genderPath)) fullPath = genderPath;
-            else if (assetManager_->fileExists(unisexPath)) fullPath = unisexPath;
-            else fullPath = base + ".blp";
-
-            regionLayers.emplace_back(region, fullPath);
-        }
-    }
-
-    const auto slotsIt = playerTextureSlotsByModelId_.find(st.modelId);
-    if (slotsIt == playerTextureSlotsByModelId_.end()) return;
-    const PlayerTextureSlots& slots = slotsIt->second;
-    if (slots.skin < 0) return;
-
-    rendering::VkTexture* newTex = charRenderer->compositeWithRegions(st.bodySkinPath, st.underwearPaths, regionLayers);
-    if (newTex) {
-        charRenderer->setTextureSlotOverride(st.instanceId, static_cast<uint16_t>(slots.skin), newTex);
-    }
-
-    // --- Weapon model attachment ---
-    // Slot indices in the 19-element EquipSlot array:
-    //   15 = MAIN_HAND → attachment 1 (right hand)
-    //   16 = OFF_HAND  → attachment 2 (left hand)
-    struct OnlineWeaponSlot {
-        int slotIndex;
-        uint32_t attachmentId;
-    };
-    static constexpr OnlineWeaponSlot weaponSlots[] = {
-        { 15, 1 },  // MAIN_HAND → right hand
-        { 16, 2 },  // OFF_HAND  → left hand
-    };
-
-    const uint32_t modelFieldL = idiL ? (*idiL)["LeftModel"] : 1u;
-    const uint32_t modelFieldR = idiL ? (*idiL)["RightModel"] : 2u;
-    const uint32_t texFieldL   = idiL ? (*idiL)["LeftModelTexture"] : 3u;
-    const uint32_t texFieldR   = idiL ? (*idiL)["RightModelTexture"] : 4u;
-
-    for (const auto& ws : weaponSlots) {
-        uint32_t weapDisplayId = displayInfoIds[ws.slotIndex];
-        if (weapDisplayId == 0) {
-            charRenderer->detachWeapon(st.instanceId, ws.attachmentId);
-            continue;
-        }
-
-        int32_t recIdx = displayInfoDbc->findRecordById(weapDisplayId);
-        if (recIdx < 0) {
-            charRenderer->detachWeapon(st.instanceId, ws.attachmentId);
-            continue;
-        }
-
-        // Prefer LeftModel (full weapon), fall back to RightModel (hilt variants)
-        std::string modelName = displayInfoDbc->getString(static_cast<uint32_t>(recIdx), modelFieldL);
-        std::string textureName = displayInfoDbc->getString(static_cast<uint32_t>(recIdx), texFieldL);
-        if (modelName.empty()) {
-            modelName = displayInfoDbc->getString(static_cast<uint32_t>(recIdx), modelFieldR);
-            textureName = displayInfoDbc->getString(static_cast<uint32_t>(recIdx), texFieldR);
-        }
-        if (modelName.empty()) {
-            charRenderer->detachWeapon(st.instanceId, ws.attachmentId);
-            continue;
-        }
-
-        // Convert .mdx → .m2
-        std::string modelFile = modelName;
-        {
-            size_t dotPos = modelFile.rfind('.');
-            if (dotPos != std::string::npos) modelFile = modelFile.substr(0, dotPos);
-            modelFile += ".m2";
-        }
-
-        // Try Weapon directory first, then Shield
-        std::string m2Path = "Item\\ObjectComponents\\Weapon\\" + modelFile;
-        pipeline::M2Model weaponModel;
-        if (!loadWeaponM2(m2Path, weaponModel)) {
-            m2Path = "Item\\ObjectComponents\\Shield\\" + modelFile;
-            if (!loadWeaponM2(m2Path, weaponModel)) {
-                charRenderer->detachWeapon(st.instanceId, ws.attachmentId);
-                continue;
-            }
-        }
-
-        // Build texture path
-        std::string texturePath;
-        if (!textureName.empty()) {
-            texturePath = "Item\\ObjectComponents\\Weapon\\" + textureName + ".blp";
-            if (!assetManager_->fileExists(texturePath)) {
-                texturePath = "Item\\ObjectComponents\\Shield\\" + textureName + ".blp";
-                if (!assetManager_->fileExists(texturePath)) texturePath.clear();
-            }
-        }
-
-        uint32_t weaponModelId = nextWeaponModelId_++;
-        charRenderer->attachWeapon(st.instanceId, ws.attachmentId,
-                                   weaponModel, weaponModelId, texturePath);
-    }
-}
-
-void EntitySpawner::despawnPlayer(uint64_t guid) {
-    if (!renderer_ || !renderer_->getCharacterRenderer()) return;
-    auto it = playerInstances_.find(guid);
-    if (it == playerInstances_.end()) return;
-    renderer_->getCharacterRenderer()->removeInstance(it->second);
-    playerInstances_.erase(it);
-    onlinePlayerAppearance_.erase(guid);
-    pendingOnlinePlayerEquipment_.erase(guid);
-    creatureRenderPosCache_.erase(guid);
-    creatureSwimmingState_.erase(guid);
-    creatureWalkingState_.erase(guid);
-    creatureFlyingState_.erase(guid);
-    creatureWasMoving_.erase(guid);
-    creatureWasSwimming_.erase(guid);
-    creatureWasFlying_.erase(guid);
-    creatureWasWalking_.erase(guid);
-}
-
-void EntitySpawner::spawnOnlineGameObject(uint64_t guid, uint32_t entry, uint32_t displayId, float x, float y, float z, float orientation, float scale) {
-    if (!renderer_ || !assetManager_) return;
-
-    if (!gameObjectLookupsBuilt_) {
-        buildGameObjectDisplayLookups();
-    }
-    if (!gameObjectLookupsBuilt_) return;
-
-    LOG_DEBUG("GO spawn attempt: guid=0x", std::hex, guid, std::dec,
-             " displayId=", displayId, " entry=", entry,
-             " pos=(", x, ", ", y, ", ", z, ")");
-
-    auto goIt = gameObjectInstances_.find(guid);
-    if (goIt != gameObjectInstances_.end()) {
-        // Already have a render instance — update its position (e.g. transport re-creation)
-        auto& info = goIt->second;
-        glm::vec3 renderPos = core::coords::canonicalToRender(glm::vec3(x, y, z));
-        LOG_DEBUG("GameObject position update: displayId=", displayId, " guid=0x", std::hex, guid, std::dec,
-                 " pos=(", x, ", ", y, ", ", z, ")");
-        if (renderer_) {
-            if (info.isWmo) {
-                if (auto* wr = renderer_->getWMORenderer()) {
-                    glm::mat4 transform(1.0f);
-                    transform = glm::translate(transform, renderPos);
-                    transform = glm::rotate(transform, orientation, glm::vec3(0, 0, 1));
-                    wr->setInstanceTransform(info.instanceId, transform);
-                }
-            } else {
-                if (auto* mr = renderer_->getM2Renderer()) {
-                    glm::mat4 transform(1.0f);
-                    transform = glm::translate(transform, renderPos);
-                    mr->setInstanceTransform(info.instanceId, transform);
-                }
-            }
-        }
-        return;
-    }
-
-    std::string modelPath;
-
-        // Override model path for transports with wrong displayIds (preloaded transports)
-        // Check if this GUID is a known transport
-        bool isTransport = gameHandler_ && gameHandler_->isTransportGuid(guid);
-        if (isTransport) {
-            // Map common transport displayIds to correct WMO paths
-            // NOTE: displayIds 455/462 are elevators in Thunder Bluff and should NOT be forced to ships.
-            // Keep ship/zeppelin overrides entry-driven where possible.
-            // DisplayIds 807, 808 = Zeppelins
-            // DisplayIds 2454, 1587 = Special ships/icebreakers
-            if (entry == 20808 || entry == 176231 || entry == 176310) {
-                modelPath = "World\\wmo\\transports\\transport_ship\\transportship.wmo";
-                LOG_INFO("Overriding transport entry/display ", entry, "/", displayId, " → transportship.wmo");
-            } else if (displayId == 807 || displayId == 808 || displayId == 175080 || displayId == 176495 || displayId == 164871) {
-                modelPath = "World\\wmo\\transports\\transport_zeppelin\\transport_zeppelin.wmo";
-                LOG_INFO("Overriding transport displayId ", displayId, " → transport_zeppelin.wmo");
-            } else if (displayId == 1587) {
-                modelPath = "World\\wmo\\transports\\transport_horde_zeppelin\\Transport_Horde_Zeppelin.wmo";
-                LOG_INFO("Overriding transport displayId ", displayId, " → Transport_Horde_Zeppelin.wmo");
-            } else if (displayId == 2454 || displayId == 181688 || displayId == 190536) {
-                modelPath = "World\\wmo\\transports\\icebreaker\\Transport_Icebreaker_ship.wmo";
-                LOG_INFO("Overriding transport displayId ", displayId, " → Transport_Icebreaker_ship.wmo");
-            } else if (displayId == 3831) {
-                // Deeprun Tram car
-                modelPath = "World\\Generic\\Gnome\\Passive Doodads\\Subway\\SubwayCar.m2";
-                LOG_WARNING("Overriding transport displayId ", displayId, " → SubwayCar.m2");
-            }
-        }
-
-    // Fallback to normal displayId lookup if not a transport or no override matched
-    if (modelPath.empty()) {
-        modelPath = getGameObjectModelPathForDisplayId(displayId);
-    }
-
-    if (modelPath.empty()) {
-        LOG_WARNING("No model path for gameobject displayId ", displayId, " (guid 0x", std::hex, guid, std::dec, ")");
-        return;
-    }
-
-    // Log spawns to help debug duplicate objects (e.g., cathedral issue)
-    LOG_DEBUG("GameObject spawn: displayId=", displayId, " guid=0x", std::hex, guid, std::dec,
-             " model=", modelPath, " pos=(", x, ", ", y, ", ", z, ")");
-
-    std::string lowerPath = modelPath;
-    std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(),
-                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-    bool isWmo = lowerPath.size() >= 4 && lowerPath.substr(lowerPath.size() - 4) == ".wmo";
-
-    glm::vec3 renderPos = core::coords::canonicalToRender(glm::vec3(x, y, z));
-    const float renderYawWmo = orientation;
-    // M2 game objects: model default faces +renderX. renderYaw = canonical + 90° = server_yaw
-    // (same offset as creature/character renderer_ so all M2 models face consistently)
-    const float renderYawM2go = orientation + glm::radians(90.0f);
-
-    bool loadedAsWmo = false;
-    if (isWmo) {
-        auto* wmoRenderer = renderer_->getWMORenderer();
-        if (!wmoRenderer) return;
-
-        uint32_t modelId = 0;
-        auto itCache = gameObjectDisplayIdWmoCache_.find(displayId);
-        if (itCache != gameObjectDisplayIdWmoCache_.end()) {
-            modelId = itCache->second;
-            // Only use cached entry if the model is still resident in the renderer_
-            if (wmoRenderer->isModelLoaded(modelId)) {
-                loadedAsWmo = true;
-            } else {
-                gameObjectDisplayIdWmoCache_.erase(itCache);
-                modelId = 0;
-            }
-        }
-        if (!loadedAsWmo && modelId == 0) {
-            auto wmoData = assetManager_->readFile(modelPath);
-            if (!wmoData.empty()) {
-                pipeline::WMOModel wmoModel = pipeline::WMOLoader::load(wmoData);
-                LOG_DEBUG("Gameobject WMO root loaded: ", modelPath, " nGroups=", wmoModel.nGroups);
-                int loadedGroups = 0;
-                if (wmoModel.nGroups > 0) {
-                    std::string basePath = modelPath;
-                    std::string extension;
-                    if (basePath.size() > 4) {
-                        extension = basePath.substr(basePath.size() - 4);
-                        std::string extLower = extension;
-                        for (char& c : extLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        if (extLower == ".wmo") {
-                            basePath = basePath.substr(0, basePath.size() - 4);
-                        }
-                    }
-
-                    for (uint32_t gi = 0; gi < wmoModel.nGroups; gi++) {
-                        char groupSuffix[16];
-                        snprintf(groupSuffix, sizeof(groupSuffix), "_%03u%s", gi, extension.c_str());
-                        std::string groupPath = basePath + groupSuffix;
-                        std::vector<uint8_t> groupData = assetManager_->readFile(groupPath);
-                        if (groupData.empty()) {
-                            snprintf(groupSuffix, sizeof(groupSuffix), "_%03u.wmo", gi);
-                            groupData = assetManager_->readFile(basePath + groupSuffix);
-                        }
-                        if (groupData.empty()) {
-                            snprintf(groupSuffix, sizeof(groupSuffix), "_%03u.WMO", gi);
-                            groupData = assetManager_->readFile(basePath + groupSuffix);
-                        }
-                        if (!groupData.empty()) {
-                            pipeline::WMOLoader::loadGroup(groupData, wmoModel, gi);
-                            loadedGroups++;
-                        } else {
-                            LOG_WARNING("  Failed to load WMO group ", gi, " for: ", basePath);
-                        }
-                    }
-                }
-
-                if (loadedGroups > 0 || wmoModel.nGroups == 0) {
-                    modelId = nextGameObjectWmoModelId_++;
-                    if (wmoRenderer->loadModel(wmoModel, modelId)) {
-                        gameObjectDisplayIdWmoCache_[displayId] = modelId;
-                        loadedAsWmo = true;
-                    } else {
-                        LOG_WARNING("Failed to load gameobject WMO model: ", modelPath);
-                    }
-                } else {
-                    LOG_WARNING("No WMO groups loaded for gameobject: ", modelPath,
-                                " — falling back to M2");
-                }
-            } else {
-                LOG_WARNING("Failed to read gameobject WMO: ", modelPath, " — falling back to M2");
-            }
-        }
-
-        if (loadedAsWmo) {
-            uint32_t instanceId = wmoRenderer->createInstance(modelId, renderPos,
-                glm::vec3(0.0f, 0.0f, renderYawWmo), scale);
-            if (instanceId == 0) {
-                LOG_WARNING("Failed to create gameobject WMO instance for guid 0x", std::hex, guid, std::dec);
-                return;
-            }
-
-            gameObjectInstances_[guid] = {modelId, instanceId, true};
-            LOG_DEBUG("Spawned gameobject WMO: guid=0x", std::hex, guid, std::dec,
-                     " displayId=", displayId, " at (", x, ", ", y, ", ", z, ")");
-
-            // Spawn transport WMO doodads (chairs, furniture, etc.) as child M2 instances
-            bool isTransport = false;
-            if (gameHandler_) {
-                std::string lowerModelPath = modelPath;
-                std::transform(lowerModelPath.begin(), lowerModelPath.end(), lowerModelPath.begin(),
-                               [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-                isTransport = (lowerModelPath.find("transport") != std::string::npos);
-            }
-
-            auto* m2Renderer = renderer_->getM2Renderer();
-            if (m2Renderer && isTransport) {
-                const auto* doodadTemplates = wmoRenderer->getDoodadTemplates(modelId);
-                if (doodadTemplates && !doodadTemplates->empty()) {
-                    constexpr size_t kMaxTransportDoodads = 192;
-                    const size_t doodadBudget = std::min(doodadTemplates->size(), kMaxTransportDoodads);
-                    LOG_DEBUG("Queueing ", doodadBudget, "/", doodadTemplates->size(),
-                             " transport doodads for WMO instance ", instanceId);
-                    pendingTransportDoodadBatches_.push_back(PendingTransportDoodadBatch{
-                        guid,
-                        modelId,
-                        instanceId,
-                        0,
-                        doodadBudget,
-                        0,
-                        x, y, z,
-                        orientation
-                    });
-                } else {
-                LOG_DEBUG("Transport WMO has no doodads or templates not available");
-            }
-            }
-
-            // Transport GameObjects are not always named "transport" in their WMO path
-            // (e.g. elevators/lifts). If the server marks it as a transport, always
-            // notify so TransportManager can animate/carry passengers.
-            bool isTG = gameHandler_ && gameHandler_->isTransportGuid(guid);
-            LOG_WARNING("WMO GO spawned: guid=0x", std::hex, guid, std::dec,
-                       " entry=", entry, " displayId=", displayId,
-                       " isTransport=", isTG,
-                       " pos=(", x, ", ", y, ", ", z, ")");
-            if (isTG) {
-                gameHandler_->notifyTransportSpawned(guid, entry, displayId, x, y, z, orientation);
-            }
-
-            return;
-        }
-
-        // WMO failed — fall through to try as M2
-        // Convert .wmo path to .m2 for fallback
-        modelPath = modelPath.substr(0, modelPath.size() - 4) + ".m2";
-    }
-
-    {
-        auto* m2Renderer = renderer_->getM2Renderer();
-        if (!m2Renderer) return;
-
-        // Skip displayIds that permanently failed to load (e.g. empty/unsupported M2s).
-        // Without this guard the same empty model is re-parsed every frame, causing
-        // sustained log spam and wasted CPU.
-        if (gameObjectDisplayIdFailedCache_.count(displayId)) return;
-
-        uint32_t modelId = 0;
-        auto itCache = gameObjectDisplayIdModelCache_.find(displayId);
-        if (itCache != gameObjectDisplayIdModelCache_.end()) {
-            modelId = itCache->second;
-            if (!m2Renderer->hasModel(modelId)) {
-                LOG_WARNING("GO M2 cache hit but model gone: displayId=", displayId,
-                            " modelId=", modelId, " path=", modelPath,
-                            " — reloading");
-                gameObjectDisplayIdModelCache_.erase(itCache);
-                itCache = gameObjectDisplayIdModelCache_.end();
-            }
-        }
-        if (itCache == gameObjectDisplayIdModelCache_.end()) {
-            modelId = nextGameObjectModelId_++;
-
-            auto m2Data = assetManager_->readFile(modelPath);
-            if (m2Data.empty()) {
-                LOG_WARNING("Failed to read gameobject M2: ", modelPath);
-                gameObjectDisplayIdFailedCache_.insert(displayId);
-                return;
-            }
-
-            pipeline::M2Model model = pipeline::M2Loader::load(m2Data);
-            if (model.vertices.empty()) {
-                LOG_WARNING("Failed to parse gameobject M2: ", modelPath);
-                gameObjectDisplayIdFailedCache_.insert(displayId);
-                return;
-            }
-
-            std::string skinPath = modelPath.substr(0, modelPath.size() - 3) + "00.skin";
-            auto skinData = assetManager_->readFile(skinPath);
-            if (!skinData.empty() && model.version >= 264) {
-                pipeline::M2Loader::loadSkin(skinData, model);
-            } else if (skinData.empty() && model.version >= 264) {
-                LOG_WARNING("GO skin file MISSING for WotLK M2 (no indices/batches): ", skinPath);
-            }
-
-            LOG_DEBUG("GO model: ", modelPath, " v=", model.version,
-                     " verts=", model.vertices.size(),
-                     " idx=", model.indices.size(),
-                     " batches=", model.batches.size(),
-                     " bones=", model.bones.size(),
-                     " skin=", (skinData.empty() ? "MISSING" : "ok"));
-
-            if (!m2Renderer->loadModel(model, modelId)) {
-                LOG_WARNING("Failed to load gameobject model: ", modelPath);
-                gameObjectDisplayIdFailedCache_.insert(displayId);
-                return;
-            }
-
-            gameObjectDisplayIdModelCache_[displayId] = modelId;
-        }
-
-        uint32_t instanceId = m2Renderer->createInstance(modelId, renderPos,
-            glm::vec3(0.0f, 0.0f, renderYawM2go), scale);
-        if (instanceId == 0) {
-            LOG_WARNING("Failed to create gameobject instance for guid 0x", std::hex, guid, std::dec);
-            return;
-        }
-
-        // Freeze animation for static gameobjects, but let portals/effects/transports animate
-        bool isTransportGO = gameHandler_ && gameHandler_->isTransportGuid(guid);
-        std::string lowerPath = modelPath;
-        std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(),
-                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-        bool isAnimatedEffect = (lowerPath.find("instanceportal") != std::string::npos ||
-                                  lowerPath.find("instancenewportal") != std::string::npos ||
-                                  lowerPath.find("portalfx") != std::string::npos ||
-                                  lowerPath.find("spellportal") != std::string::npos);
-        if (!isAnimatedEffect && !isTransportGO) {
-            // Check for totem idle animations — totems should animate, not freeze
-            bool isTotem = false;
-            if (m2Renderer->hasAnimation(instanceId, 245)) {         // TOTEM_SMALL
-                m2Renderer->setInstanceAnimation(instanceId, 245, true);
-                isTotem = true;
-            } else if (m2Renderer->hasAnimation(instanceId, 246)) {  // TOTEM_MEDIUM
-                m2Renderer->setInstanceAnimation(instanceId, 246, true);
-                isTotem = true;
-            } else if (m2Renderer->hasAnimation(instanceId, 247)) {  // TOTEM_LARGE
-                m2Renderer->setInstanceAnimation(instanceId, 247, true);
-                isTotem = true;
-            }
-            if (!isTotem) {
-                m2Renderer->setInstanceAnimationFrozen(instanceId, true);
-            }
-        }
-
-        gameObjectInstances_[guid] = {modelId, instanceId, false};
-
-        // Notify transport system for M2 transports (e.g. Deeprun Tram cars)
-        if (gameHandler_ && gameHandler_->isTransportGuid(guid)) {
-            LOG_WARNING("M2 transport spawned: guid=0x", std::hex, guid, std::dec,
-                       " entry=", entry, " displayId=", displayId,
-                       " instanceId=", instanceId);
-            gameHandler_->notifyTransportSpawned(guid, entry, displayId, x, y, z, orientation);
-        }
-    }
-
-    LOG_DEBUG("Spawned gameobject: guid=0x", std::hex, guid, std::dec,
-             " displayId=", displayId, " at (", x, ", ", y, ", ", z, ")");
-}
-
-void EntitySpawner::processAsyncCreatureResults(bool unlimited) {
-    // Check completed async model loads and finalize on main thread (GPU upload + instance creation).
-    // Limit GPU model uploads per tick to avoid long main-thread stalls that can starve socket updates.
-    // Even in unlimited mode (load screen), keep a small cap and budget to prevent multi-second stalls.
-    static constexpr int kMaxModelUploadsPerTick = 1;
-    static constexpr int kMaxModelUploadsPerTickWarmup = 1;
-    static constexpr float kFinalizeBudgetMs = 2.0f;
-    static constexpr float kFinalizeBudgetWarmupMs = 2.0f;
-    const int maxUploadsThisTick = unlimited ? kMaxModelUploadsPerTickWarmup : kMaxModelUploadsPerTick;
-    const float budgetMs = unlimited ? kFinalizeBudgetWarmupMs : kFinalizeBudgetMs;
-    const auto tickStart = std::chrono::steady_clock::now();
-    int modelUploads = 0;
-
-    for (auto it = asyncCreatureLoads_.begin(); it != asyncCreatureLoads_.end(); ) {
-        if (std::chrono::duration<float, std::milli>(
-                std::chrono::steady_clock::now() - tickStart).count() >= budgetMs) {
-            break;
-        }
-
-        if (!it->future.valid() ||
-            it->future.wait_for(std::chrono::milliseconds(0)) != std::future_status::ready) {
-            ++it;
-            continue;
-        }
-
-        auto result = it->future.get();
-        it = asyncCreatureLoads_.erase(it);
-        asyncCreatureDisplayLoads_.erase(result.displayId);
-
-        // Failures and cache hits need no GPU work — process them even when the
-        // upload budget is exhausted. Previously the budget check was above this
-        // point, blocking ALL ready futures (including zero-cost ones) after a
-        // single upload, which throttled creature spawn throughput during world load.
-        if (result.permanent_failure) {
-            nonRenderableCreatureDisplayIds_.insert(result.displayId);
-            creaturePermanentFailureGuids_.insert(result.guid);
-            pendingCreatureSpawnGuids_.erase(result.guid);
-            creatureSpawnRetryCounts_.erase(result.guid);
-            continue;
-        }
-        if (!result.valid || !result.model) {
-            pendingCreatureSpawnGuids_.erase(result.guid);
-            creatureSpawnRetryCounts_.erase(result.guid);
-            continue;
-        }
-
-        // Another async result may have already uploaded this displayId while this
-        // task was still running; in that case, skip duplicate GPU upload.
-        if (displayIdModelCache_.find(result.displayId) != displayIdModelCache_.end()) {
-            pendingCreatureSpawnGuids_.erase(result.guid);
-            creatureSpawnRetryCounts_.erase(result.guid);
-            if (!creatureInstances_.count(result.guid) &&
-                !creaturePermanentFailureGuids_.count(result.guid)) {
-                PendingCreatureSpawn s{};
-                s.guid = result.guid;
-                s.displayId = result.displayId;
-                s.x = result.x;
-                s.y = result.y;
-                s.z = result.z;
-                s.orientation = result.orientation;
-                s.scale = result.scale;
-                pendingCreatureSpawns_.push_back(s);
-                pendingCreatureSpawnGuids_.insert(result.guid);
-            }
-            continue;
-        }
-
-        // Only actual GPU uploads count toward the per-tick budget.
-        if (modelUploads >= maxUploadsThisTick) {
-            // Re-queue this result — it needs a GPU upload but we're at budget.
-            // Push a new pending spawn so it's retried next frame.
-            pendingCreatureSpawnGuids_.erase(result.guid);
-            creatureSpawnRetryCounts_.erase(result.guid);
-            PendingCreatureSpawn s{};
-            s.guid = result.guid;
-            s.displayId = result.displayId;
-            s.x = result.x; s.y = result.y; s.z = result.z;
-            s.orientation = result.orientation;
-            s.scale = result.scale;
-            pendingCreatureSpawns_.push_back(s);
-            pendingCreatureSpawnGuids_.insert(result.guid);
-            continue;
-        }
-
-        // Model parsed on background thread — upload to GPU on main thread.
-        auto* charRenderer = renderer_ ? renderer_->getCharacterRenderer() : nullptr;
-        if (!charRenderer) {
-            pendingCreatureSpawnGuids_.erase(result.guid);
-            continue;
-        }
-
-        // Count upload attempts toward the frame budget even if upload fails.
-        // Otherwise repeated failures can consume an unbounded amount of frame time.
-        modelUploads++;
-
-        // Upload model to GPU (must happen on main thread)
-        // Use pre-decoded BLP cache to skip main-thread texture decode
-        auto uploadStart = std::chrono::steady_clock::now();
-        charRenderer->setPredecodedBLPCache(&result.predecodedTextures);
-        if (!charRenderer->loadModel(*result.model, result.modelId)) {
-            charRenderer->setPredecodedBLPCache(nullptr);
-            nonRenderableCreatureDisplayIds_.insert(result.displayId);
-            creaturePermanentFailureGuids_.insert(result.guid);
-            pendingCreatureSpawnGuids_.erase(result.guid);
-            creatureSpawnRetryCounts_.erase(result.guid);
-            continue;
-        }
-        charRenderer->setPredecodedBLPCache(nullptr);
-        {
-            auto uploadEnd = std::chrono::steady_clock::now();
-            float uploadMs = std::chrono::duration<float, std::milli>(uploadEnd - uploadStart).count();
-            if (uploadMs > 100.0f) {
-                LOG_WARNING("charRenderer->loadModel took ", uploadMs, "ms displayId=", result.displayId,
-                            " preDecoded=", result.predecodedTextures.size());
-            }
-        }
-        // Save remaining pre-decoded textures (display skins) for spawnOnlineCreature
-        if (!result.predecodedTextures.empty()) {
-            displayIdPredecodedTextures_[result.displayId] = std::move(result.predecodedTextures);
-        }
-        displayIdModelCache_[result.displayId] = result.modelId;
-        pendingCreatureSpawnGuids_.erase(result.guid);
-        creatureSpawnRetryCounts_.erase(result.guid);
-
-        // Re-queue as a normal pending spawn — model is now cached, so sync spawn is fast
-        // (only creates instance + applies textures, no file I/O).
-        if (!creatureInstances_.count(result.guid) &&
-            !creaturePermanentFailureGuids_.count(result.guid)) {
-            PendingCreatureSpawn s{};
-            s.guid = result.guid;
-            s.displayId = result.displayId;
-            s.x = result.x;
-            s.y = result.y;
-            s.z = result.z;
-            s.orientation = result.orientation;
-            s.scale = result.scale;
-            pendingCreatureSpawns_.push_back(s);
-            pendingCreatureSpawnGuids_.insert(result.guid);
-        }
-    }
-}
-
-void EntitySpawner::processAsyncNpcCompositeResults(bool unlimited) {
-    auto* charRenderer = renderer_ ? renderer_->getCharacterRenderer() : nullptr;
-    if (!charRenderer) return;
-
-    // Budget: 2ms per frame to avoid stalling when many NPCs complete skin compositing
-    // simultaneously. In unlimited mode (load screen), process everything without cap.
-    static constexpr float kCompositeBudgetMs = 2.0f;
-    auto startTime = std::chrono::steady_clock::now();
-
-    for (auto it = asyncNpcCompositeLoads_.begin(); it != asyncNpcCompositeLoads_.end(); ) {
-        if (!unlimited) {
-            float elapsed = std::chrono::duration<float, std::milli>(
-                std::chrono::steady_clock::now() - startTime).count();
-            if (elapsed >= kCompositeBudgetMs) break;
-        }
-        if (!it->future.valid() ||
-            it->future.wait_for(std::chrono::milliseconds(0)) != std::future_status::ready) {
-            ++it;
-            continue;
-        }
-        auto result = it->future.get();
-        it = asyncNpcCompositeLoads_.erase(it);
-
-        const auto& info = result.info;
-
-        // Set pre-decoded cache so texture loads skip synchronous BLP decode
-        charRenderer->setPredecodedBLPCache(&result.predecodedTextures);
-
-        // --- Apply skin to type-1 slots ---
-        rendering::VkTexture* skinTex = nullptr;
-
-        if (info.hasBakedSkin) {
-            // Baked skin: load from pre-decoded cache
-            skinTex = charRenderer->loadTexture(info.bakedSkinPath);
-        }
-
-        if (info.hasComposite) {
-            // Composite with face/underwear/equipment regions on top of base skin
-            rendering::VkTexture* compositeTex = nullptr;
-            if (!info.regionLayers.empty()) {
-                compositeTex = charRenderer->compositeWithRegions(info.basePath,
-                    info.overlayPaths, info.regionLayers);
-            } else if (!info.overlayPaths.empty()) {
-                std::vector<std::string> skinLayers;
-                skinLayers.push_back(info.basePath);
-                for (const auto& op : info.overlayPaths) skinLayers.push_back(op);
-                compositeTex = charRenderer->compositeTextures(skinLayers);
-            }
-            if (compositeTex) skinTex = compositeTex;
-        } else if (info.hasSimpleSkin) {
-            // Simple skin: just base texture, no compositing
-            auto* baseTex = charRenderer->loadTexture(info.basePath);
-            if (baseTex) skinTex = baseTex;
-        }
-
-        if (skinTex) {
-            for (uint32_t slot : info.skinTextureSlots) {
-                charRenderer->setModelTexture(info.modelId, slot, skinTex);
-            }
-        }
-
-        // --- Apply hair texture to type-6 slots ---
-        if (!info.hairTexturePath.empty()) {
-            rendering::VkTexture* hairTex = charRenderer->loadTexture(info.hairTexturePath);
-            rendering::VkTexture* whTex = charRenderer->loadTexture("");
-            if (hairTex && hairTex != whTex) {
-                for (uint32_t slot : info.hairTextureSlots) {
-                    charRenderer->setModelTexture(info.modelId, slot, hairTex);
-                }
-            }
-        } else if (info.useBakedForHair && skinTex) {
-            // Bald NPC: use skin/baked texture for scalp cap
-            for (uint32_t slot : info.hairTextureSlots) {
-                charRenderer->setModelTexture(info.modelId, slot, skinTex);
-            }
-        }
-
-        charRenderer->setPredecodedBLPCache(nullptr);
-    }
-}
-
-void EntitySpawner::processCreatureSpawnQueue(bool unlimited) {
-    auto startTime = std::chrono::steady_clock::now();
-    // Budget: max 2ms per frame for creature spawning to prevent stutter.
-    // In unlimited mode (load screen), process everything without budget cap.
-    static constexpr float kSpawnBudgetMs = 2.0f;
-
-    // First, finalize any async model loads that completed on background threads.
-    processAsyncCreatureResults(unlimited);
-    {
-        auto now = std::chrono::steady_clock::now();
-        float asyncMs = std::chrono::duration<float, std::milli>(now - startTime).count();
-        if (asyncMs > 100.0f) {
-            LOG_WARNING("processAsyncCreatureResults took ", asyncMs, "ms");
-        }
-    }
-
-    if (pendingCreatureSpawns_.empty()) return;
-    if (!creatureLookupsBuilt_) {
-        buildCreatureDisplayLookups();
-        if (!creatureLookupsBuilt_) return;
-    }
-
-    int processed = 0;
-    int asyncLaunched = 0;
-    size_t rotationsLeft = pendingCreatureSpawns_.size();
-    while (!pendingCreatureSpawns_.empty() &&
-           (unlimited || processed < MAX_SPAWNS_PER_FRAME) &&
-           rotationsLeft > 0) {
-        // Check time budget every iteration (including first — async results may
-        // have already consumed the budget via GPU model uploads).
-        if (!unlimited) {
-            auto now = std::chrono::steady_clock::now();
-            float elapsedMs = std::chrono::duration<float, std::milli>(now - startTime).count();
-            if (elapsedMs >= kSpawnBudgetMs) break;
-        }
-
-        PendingCreatureSpawn s = pendingCreatureSpawns_.front();
-        pendingCreatureSpawns_.pop_front();
-
-        if (nonRenderableCreatureDisplayIds_.count(s.displayId)) {
-            pendingCreatureSpawnGuids_.erase(s.guid);
-            creatureSpawnRetryCounts_.erase(s.guid);
-            processed++;
-            rotationsLeft = pendingCreatureSpawns_.size();
-            continue;
-        }
-
-        const bool needsNewModel = (displayIdModelCache_.find(s.displayId) == displayIdModelCache_.end());
-
-        // For new models: launch async load on background thread instead of blocking.
-        if (needsNewModel) {
-            // Keep exactly one background load per displayId. Additional spawns for
-            // the same displayId stay queued and will spawn once cache is populated.
-            if (asyncCreatureDisplayLoads_.count(s.displayId)) {
-                pendingCreatureSpawns_.push_back(s);
-                rotationsLeft--;
-                continue;
-            }
-
-            const int maxAsync = unlimited ? (MAX_ASYNC_CREATURE_LOADS * 4) : MAX_ASYNC_CREATURE_LOADS;
-            if (static_cast<int>(asyncCreatureLoads_.size()) + asyncLaunched >= maxAsync) {
-                // Too many in-flight — defer to next frame
-                pendingCreatureSpawns_.push_back(s);
-                rotationsLeft--;
-                continue;
-            }
-
-            std::string m2Path = getModelPathForDisplayId(s.displayId);
-            if (m2Path.empty()) {
-                nonRenderableCreatureDisplayIds_.insert(s.displayId);
-                creaturePermanentFailureGuids_.insert(s.guid);
-                pendingCreatureSpawnGuids_.erase(s.guid);
-                creatureSpawnRetryCounts_.erase(s.guid);
-                processed++;
-                rotationsLeft = pendingCreatureSpawns_.size();
-                continue;
-            }
-
-            // Check for invisible stalkers
-            {
-                std::string lowerPath = m2Path;
-                std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(),
-                               [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-                if (lowerPath.find("invisiblestalker") != std::string::npos ||
-                    lowerPath.find("invisible_stalker") != std::string::npos) {
-                    nonRenderableCreatureDisplayIds_.insert(s.displayId);
-                    creaturePermanentFailureGuids_.insert(s.guid);
-                    pendingCreatureSpawnGuids_.erase(s.guid);
-                    processed++;
-                    rotationsLeft = pendingCreatureSpawns_.size();
-                    continue;
-                }
-            }
-
-            // Launch async M2 load — file I/O and parsing happen off the main thread.
-            uint32_t modelId = nextCreatureModelId_++;
-            auto* am = assetManager_;
-
-            // Collect display skin texture paths for background pre-decode
-            std::vector<std::string> displaySkinPaths;
-            {
-                auto itDD = displayDataMap_.find(s.displayId);
-                if (itDD != displayDataMap_.end()) {
-                    std::string modelDir;
-                    size_t lastSlash = m2Path.find_last_of("\\/");
-                    if (lastSlash != std::string::npos) modelDir = m2Path.substr(0, lastSlash + 1);
-
-                    auto resolveForAsync = [&](const std::string& skinField) {
-                        if (skinField.empty()) return;
-                        std::string raw = skinField;
-                        std::replace(raw.begin(), raw.end(), '/', '\\');
-                        while (!raw.empty() && std::isspace(static_cast<unsigned char>(raw.front()))) raw.erase(raw.begin());
-                        while (!raw.empty() && std::isspace(static_cast<unsigned char>(raw.back()))) raw.pop_back();
-                        if (raw.empty()) return;
-                        bool hasExt = raw.size() >= 4 && raw.substr(raw.size()-4) == ".blp";
-                        bool hasDir = raw.find('\\') != std::string::npos;
-                        std::vector<std::string> candidates;
-                        if (hasDir) {
-                            candidates.push_back(raw);
-                            if (!hasExt) candidates.push_back(raw + ".blp");
-                        } else {
-                            candidates.push_back(modelDir + raw);
-                            if (!hasExt) candidates.push_back(modelDir + raw + ".blp");
-                            candidates.push_back(raw);
-                            if (!hasExt) candidates.push_back(raw + ".blp");
-                        }
-                        for (const auto& c : candidates) {
-                            if (am->fileExists(c)) { displaySkinPaths.push_back(c); return; }
-                        }
-                    };
-                    resolveForAsync(itDD->second.skin1);
-                    resolveForAsync(itDD->second.skin2);
-                    resolveForAsync(itDD->second.skin3);
-
-                    // Pre-decode humanoid NPC textures (bake, skin, face, underwear, hair, equipment)
-                    if (itDD->second.extraDisplayId != 0) {
-                        auto itHE = humanoidExtraMap_.find(itDD->second.extraDisplayId);
-                        if (itHE != humanoidExtraMap_.end()) {
-                            const auto& he = itHE->second;
-                            // Baked texture
-                            if (!he.bakeName.empty()) {
-                                displaySkinPaths.push_back("Textures\\BakedNpcTextures\\" + he.bakeName);
-                            }
-                            // CharSections: skin, face, underwear
-                            auto csDbc = am->loadDBC("CharSections.dbc");
-                            if (csDbc) {
-                                const auto* csL = pipeline::getActiveDBCLayout()
-                                    ? pipeline::getActiveDBCLayout()->getLayout("CharSections") : nullptr;
-                                auto csF = pipeline::detectCharSectionsFields(csDbc.get(), csL);
-                                uint32_t nRace = static_cast<uint32_t>(he.raceId);
-                                uint32_t nSex = static_cast<uint32_t>(he.sexId);
-                                uint32_t nSkin = static_cast<uint32_t>(he.skinId);
-                                uint32_t nFace = static_cast<uint32_t>(he.faceId);
-                                for (uint32_t r = 0; r < csDbc->getRecordCount(); r++) {
-                                    uint32_t rId = csDbc->getUInt32(r, csF.raceId);
-                                    uint32_t sId = csDbc->getUInt32(r, csF.sexId);
-                                    if (rId != nRace || sId != nSex) continue;
-                                    uint32_t section = csDbc->getUInt32(r, csF.baseSection);
-                                    uint32_t variation = csDbc->getUInt32(r, csF.variationIndex);
-                                    uint32_t color = csDbc->getUInt32(r, csF.colorIndex);
-                                    if (section == 0 && color == nSkin) {
-                                        std::string t = csDbc->getString(r, csF.texture1);
-                                        if (!t.empty()) displaySkinPaths.push_back(t);
-                                    } else if (section == 1 && variation == nFace && color == nSkin) {
-                                        std::string t1 = csDbc->getString(r, csF.texture1);
-                                        std::string t2 = csDbc->getString(r, csF.texture2);
-                                        if (!t1.empty()) displaySkinPaths.push_back(t1);
-                                        if (!t2.empty()) displaySkinPaths.push_back(t2);
-                                    } else if (section == 3 && variation == static_cast<uint32_t>(he.hairStyleId)
-                                               && color == static_cast<uint32_t>(he.hairColorId)) {
-                                        std::string t = csDbc->getString(r, csF.texture1);
-                                        if (!t.empty()) displaySkinPaths.push_back(t);
-                                    } else if (section == 4 && color == nSkin) {
-                                        for (uint32_t f = csF.texture1; f <= csF.texture1 + 2; f++) {
-                                            std::string t = csDbc->getString(r, f);
-                                            if (!t.empty()) displaySkinPaths.push_back(t);
-                                        }
-                                    }
-                                }
-                            }
-                            // Equipment region textures
-                            auto idiDbc = am->loadDBC("ItemDisplayInfo.dbc");
-                            if (idiDbc) {
-                                static constexpr const char* compDirs[] = {
-                                    "ArmUpperTexture", "ArmLowerTexture", "HandTexture",
-                                    "TorsoUpperTexture", "TorsoLowerTexture",
-                                    "LegUpperTexture", "LegLowerTexture", "FootTexture",
-                                };
-                                const auto* idiL = pipeline::getActiveDBCLayout()
-                                    ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
-                                const uint32_t trf[8] = {
-                                    idiL ? (*idiL)["TextureArmUpper"]  : 14u,
-                                    idiL ? (*idiL)["TextureArmLower"]  : 15u,
-                                    idiL ? (*idiL)["TextureHand"]      : 16u,
-                                    idiL ? (*idiL)["TextureTorsoUpper"]: 17u,
-                                    idiL ? (*idiL)["TextureTorsoLower"]: 18u,
-                                    idiL ? (*idiL)["TextureLegUpper"]  : 19u,
-                                    idiL ? (*idiL)["TextureLegLower"]  : 20u,
-                                    idiL ? (*idiL)["TextureFoot"]      : 21u,
-                                };
-                                const bool isFem = (he.sexId == 1);
-                                for (int eq = 0; eq < 11; eq++) {
-                                    uint32_t did = he.equipDisplayId[eq];
-                                    if (did == 0) continue;
-                                    int32_t recIdx = idiDbc->findRecordById(did);
-                                    if (recIdx < 0) continue;
-                                    for (int region = 0; region < 8; region++) {
-                                        std::string texName = idiDbc->getString(static_cast<uint32_t>(recIdx), trf[region]);
-                                        if (texName.empty()) continue;
-                                        std::string base = "Item\\TextureComponents\\" +
-                                            std::string(compDirs[region]) + "\\" + texName;
-                                        std::string gp = base + (isFem ? "_F.blp" : "_M.blp");
-                                        std::string up = base + "_U.blp";
-                                        if (am->fileExists(gp)) displaySkinPaths.push_back(gp);
-                                        else if (am->fileExists(up)) displaySkinPaths.push_back(up);
-                                        else displaySkinPaths.push_back(base + ".blp");
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-            AsyncCreatureLoad load;
-            load.future = std::async(std::launch::async,
-                [am, m2Path, modelId, s, skinPaths = std::move(displaySkinPaths)]() -> PreparedCreatureModel {
-                    PreparedCreatureModel result;
-                    result.guid = s.guid;
-                    result.displayId = s.displayId;
-                    result.modelId = modelId;
-                    result.x = s.x;
-                    result.y = s.y;
-                    result.z = s.z;
-                    result.orientation = s.orientation;
-                    result.scale = s.scale;
-
-                    auto m2Data = am->readFile(m2Path);
-                    if (m2Data.empty()) {
-                        result.permanent_failure = true;
-                        return result;
-                    }
-
-                    auto model = std::make_shared<pipeline::M2Model>(pipeline::M2Loader::load(m2Data));
-                    if (model->vertices.empty()) {
-                        result.permanent_failure = true;
-                        return result;
-                    }
-
-                    // Load skin file
-                    if (model->version >= 264) {
-                        std::string skinPath = m2Path.substr(0, m2Path.size() - 3) + "00.skin";
-                        auto skinData = am->readFile(skinPath);
-                        if (!skinData.empty()) {
-                            pipeline::M2Loader::loadSkin(skinData, *model);
-                        }
-                    }
-
-                    // Load external .anim files
-                    std::string basePath = m2Path.substr(0, m2Path.size() - 3);
-                    for (uint32_t si = 0; si < model->sequences.size(); si++) {
-                        if (!(model->sequences[si].flags & 0x20)) {
-                            char animFileName[256];
-                            snprintf(animFileName, sizeof(animFileName), "%s%04u-%02u.anim",
-                                basePath.c_str(), model->sequences[si].id, model->sequences[si].variationIndex);
-                            auto animData = am->readFileOptional(animFileName);
-                            if (!animData.empty()) {
-                                pipeline::M2Loader::loadAnimFile(m2Data, animData, si, *model);
-                            }
-                        }
-                    }
-
-                    // Pre-decode model textures on background thread
-                    for (const auto& tex : model->textures) {
-                        if (tex.filename.empty()) continue;
-                        std::string texKey = tex.filename;
-                        std::replace(texKey.begin(), texKey.end(), '/', '\\');
-                        std::transform(texKey.begin(), texKey.end(), texKey.begin(),
-                                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-                        if (result.predecodedTextures.find(texKey) != result.predecodedTextures.end()) continue;
-                        auto blp = am->loadTexture(texKey);
-                        if (blp.isValid()) {
-                            result.predecodedTextures[texKey] = std::move(blp);
-                        }
-                    }
-
-                    // Pre-decode display skin textures (skin1/skin2/skin3 from CreatureDisplayInfo)
-                    for (const auto& sp : skinPaths) {
-                        std::string key = sp;
-                        std::replace(key.begin(), key.end(), '/', '\\');
-                        std::transform(key.begin(), key.end(), key.begin(),
-                                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-                        if (result.predecodedTextures.count(key)) continue;
-                        auto blp = am->loadTexture(key);
-                        if (blp.isValid()) {
-                            result.predecodedTextures[key] = std::move(blp);
-                        }
-                    }
-
-                    result.model = std::move(model);
-                    result.valid = true;
-                    return result;
-                });
-            asyncCreatureLoads_.push_back(std::move(load));
-            asyncCreatureDisplayLoads_.insert(s.displayId);
-            asyncLaunched++;
-            // Don't erase from pendingCreatureSpawnGuids_ — the async result handler will do it
-            rotationsLeft = pendingCreatureSpawns_.size();
-            processed++;
-            continue;
-        }
-
-        // Cached model — spawn is fast (no file I/O, just instance creation + texture setup)
-        {
-            auto spawnStart = std::chrono::steady_clock::now();
-            spawnOnlineCreature(s.guid, s.displayId, s.x, s.y, s.z, s.orientation, s.scale);
-            auto spawnEnd = std::chrono::steady_clock::now();
-            float spawnMs = std::chrono::duration<float, std::milli>(spawnEnd - spawnStart).count();
-            if (spawnMs > 100.0f) {
-                LOG_WARNING("spawnOnlineCreature took ", spawnMs, "ms displayId=", s.displayId);
-            }
-        }
-        pendingCreatureSpawnGuids_.erase(s.guid);
-
-        // If spawn still failed, retry for a limited number of frames.
-        if (!creatureInstances_.count(s.guid)) {
-            if (creaturePermanentFailureGuids_.erase(s.guid) > 0) {
-                creatureSpawnRetryCounts_.erase(s.guid);
-                processed++;
-                continue;
-            }
-            uint16_t retries = 0;
-            auto it = creatureSpawnRetryCounts_.find(s.guid);
-            if (it != creatureSpawnRetryCounts_.end()) {
-                retries = it->second;
-            }
-            if (retries < MAX_CREATURE_SPAWN_RETRIES) {
-                creatureSpawnRetryCounts_[s.guid] = static_cast<uint16_t>(retries + 1);
-                pendingCreatureSpawns_.push_back(s);
-                pendingCreatureSpawnGuids_.insert(s.guid);
-            } else {
-                creatureSpawnRetryCounts_.erase(s.guid);
-                LOG_WARNING("Dropping creature spawn after retries: guid=0x", std::hex, s.guid, std::dec,
-                            " displayId=", s.displayId);
-            }
-        } else {
-            creatureSpawnRetryCounts_.erase(s.guid);
-        }
-        rotationsLeft = pendingCreatureSpawns_.size();
-        processed++;
-    }
-}
-
-void EntitySpawner::processPlayerSpawnQueue() {
-    if (pendingPlayerSpawns_.empty()) return;
-    if (!assetManager_ || !assetManager_->isInitialized()) return;
-
-    int processed = 0;
-    while (!pendingPlayerSpawns_.empty() && processed < MAX_SPAWNS_PER_FRAME) {
-        PendingPlayerSpawn s = pendingPlayerSpawns_.front();
-        pendingPlayerSpawns_.erase(pendingPlayerSpawns_.begin());
-        pendingPlayerSpawnGuids_.erase(s.guid);
-
-        // Skip if already spawned (could have been spawned by a previous update this frame)
-        if (playerInstances_.count(s.guid)) {
-            processed++;
-            continue;
-        }
-
-        spawnOnlinePlayer(s.guid, s.raceId, s.genderId, s.appearanceBytes, s.facialFeatures, s.x, s.y, s.z, s.orientation);
-        // Apply any equipment updates that arrived before the player was spawned.
-        auto pit = pendingOnlinePlayerEquipment_.find(s.guid);
-        if (pit != pendingOnlinePlayerEquipment_.end()) {
-            deferredEquipmentQueue_.push_back({s.guid, pit->second});
-            pendingOnlinePlayerEquipment_.erase(pit);
-        }
-        processed++;
-    }
-}
-
-std::vector<std::string> EntitySpawner::resolveEquipmentTexturePaths(uint64_t guid,
-    const std::array<uint32_t, 19>& displayInfoIds,
-    const std::array<uint8_t, 19>& /*inventoryTypes*/) const {
-    std::vector<std::string> paths;
-
-    auto it = onlinePlayerAppearance_.find(guid);
-    if (it == onlinePlayerAppearance_.end()) return paths;
-    const OnlinePlayerAppearanceState& st = it->second;
-
-    // Add base skin + underwear paths
-    if (!st.bodySkinPath.empty()) paths.push_back(st.bodySkinPath);
-    for (const auto& up : st.underwearPaths) {
-        if (!up.empty()) paths.push_back(up);
-    }
-
-    // Resolve equipment region texture paths (same logic as setOnlinePlayerEquipment)
-    auto displayInfoDbc = assetManager_->loadDBC("ItemDisplayInfo.dbc");
-    if (!displayInfoDbc) return paths;
-    const auto* idiL = pipeline::getActiveDBCLayout()
-        ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
-
-    static constexpr const char* componentDirs[] = {
-        "ArmUpperTexture", "ArmLowerTexture", "HandTexture",
-        "TorsoUpperTexture", "TorsoLowerTexture",
-        "LegUpperTexture", "LegLowerTexture", "FootTexture",
-    };
-    uint32_t texRegionFields[8];
-    pipeline::getItemDisplayInfoTextureFields(*displayInfoDbc, idiL, texRegionFields);
-    const bool isFemale = (st.genderId == 1);
-
-    for (int s = 0; s < 19; s++) {
-        uint32_t did = displayInfoIds[s];
-        if (did == 0) continue;
-        int32_t recIdx = displayInfoDbc->findRecordById(did);
-        if (recIdx < 0) continue;
-        for (int region = 0; region < 8; region++) {
-            std::string texName = displayInfoDbc->getString(
-                static_cast<uint32_t>(recIdx), texRegionFields[region]);
-            if (texName.empty()) continue;
-            std::string base = "Item\\TextureComponents\\" +
-                std::string(componentDirs[region]) + "\\" + texName;
-            std::string genderPath = base + (isFemale ? "_F.blp" : "_M.blp");
-            std::string unisexPath = base + "_U.blp";
-            if (assetManager_->fileExists(genderPath)) paths.push_back(genderPath);
-            else if (assetManager_->fileExists(unisexPath)) paths.push_back(unisexPath);
-            else paths.push_back(base + ".blp");
-        }
-    }
-    return paths;
-}
-
-void EntitySpawner::processAsyncEquipmentResults() {
-    for (auto it = asyncEquipmentLoads_.begin(); it != asyncEquipmentLoads_.end(); ) {
-        if (!it->future.valid() ||
-            it->future.wait_for(std::chrono::milliseconds(0)) != std::future_status::ready) {
-            ++it;
-            continue;
-        }
-        auto result = it->future.get();
-        it = asyncEquipmentLoads_.erase(it);
-
-        auto* charRenderer = renderer_ ? renderer_->getCharacterRenderer() : nullptr;
-        if (!charRenderer) continue;
-
-        // Set pre-decoded cache so compositeWithRegions skips synchronous BLP decode
-        charRenderer->setPredecodedBLPCache(&result.predecodedTextures);
-        setOnlinePlayerEquipment(result.guid, result.displayInfoIds, result.inventoryTypes);
-        charRenderer->setPredecodedBLPCache(nullptr);
-    }
-}
-
-void EntitySpawner::processDeferredEquipmentQueue() {
-    // First, finalize any completed async pre-decodes
-    processAsyncEquipmentResults();
-
-    if (deferredEquipmentQueue_.empty()) return;
-    // Limit in-flight async equipment loads
-    if (asyncEquipmentLoads_.size() >= 2) return;
-
-    auto [guid, equipData] = deferredEquipmentQueue_.front();
-    deferredEquipmentQueue_.erase(deferredEquipmentQueue_.begin());
-
-    // Resolve all texture paths that compositeWithRegions will need
-    auto texturePaths = resolveEquipmentTexturePaths(guid, equipData.first, equipData.second);
-
-    if (texturePaths.empty()) {
-        // No textures to pre-decode — just apply directly (fast path)
-        LOG_WARNING("Equipment fast path for guid=0x", std::hex, guid, std::dec,
-                    " (no textures to pre-decode)");
-        setOnlinePlayerEquipment(guid, equipData.first, equipData.second);
-        return;
-    }
-    LOG_WARNING("Equipment async pre-decode for guid=0x", std::hex, guid, std::dec,
-                " textures=", texturePaths.size());
-
-    // Launch background BLP pre-decode
-    auto* am = assetManager_;
-    auto displayInfoIds = equipData.first;
-    auto inventoryTypes = equipData.second;
-    AsyncEquipmentLoad load;
-    load.future = std::async(std::launch::async,
-        [am, guid, displayInfoIds, inventoryTypes, paths = std::move(texturePaths)]() -> PreparedEquipmentUpdate {
-            PreparedEquipmentUpdate result;
-            result.guid = guid;
-            result.displayInfoIds = displayInfoIds;
-            result.inventoryTypes = inventoryTypes;
-            for (const auto& path : paths) {
-                std::string key = path;
-                std::replace(key.begin(), key.end(), '/', '\\');
-                std::transform(key.begin(), key.end(), key.begin(),
-                               [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-                if (result.predecodedTextures.count(key)) continue;
-                auto blp = am->loadTexture(key);
-                if (blp.isValid()) {
-                    result.predecodedTextures[key] = std::move(blp);
-                }
-            }
-            return result;
-        });
-    asyncEquipmentLoads_.push_back(std::move(load));
-}
-
-void EntitySpawner::processAsyncGameObjectResults() {
-    for (auto it = asyncGameObjectLoads_.begin(); it != asyncGameObjectLoads_.end(); ) {
-        if (!it->future.valid() ||
-            it->future.wait_for(std::chrono::milliseconds(0)) != std::future_status::ready) {
-            ++it;
-            continue;
-        }
-
-        auto result = it->future.get();
-        it = asyncGameObjectLoads_.erase(it);
-
-        if (!result.valid || !result.isWmo || !result.wmoModel) {
-            // Fallback: spawn via sync path (likely an M2 or failed WMO)
-            spawnOnlineGameObject(result.guid, result.entry, result.displayId,
-                                 result.x, result.y, result.z, result.orientation, result.scale);
-            continue;
-        }
-
-        // WMO parsed on background thread — do GPU upload + instance creation on main thread
-        auto* wmoRenderer = renderer_ ? renderer_->getWMORenderer() : nullptr;
-        if (!wmoRenderer) continue;
-
-        uint32_t modelId = 0;
-        auto itCache = gameObjectDisplayIdWmoCache_.find(result.displayId);
-        if (itCache != gameObjectDisplayIdWmoCache_.end()) {
-            modelId = itCache->second;
-        } else {
-            modelId = nextGameObjectWmoModelId_++;
-            wmoRenderer->setPredecodedBLPCache(&result.predecodedTextures);
-            if (!wmoRenderer->loadModel(*result.wmoModel, modelId)) {
-                wmoRenderer->setPredecodedBLPCache(nullptr);
-                LOG_WARNING("Failed to load async gameobject WMO: ", result.modelPath);
-                continue;
-            }
-            wmoRenderer->setPredecodedBLPCache(nullptr);
-            gameObjectDisplayIdWmoCache_[result.displayId] = modelId;
-        }
-
-        glm::vec3 renderPos = core::coords::canonicalToRender(
-            glm::vec3(result.x, result.y, result.z));
-        uint32_t instanceId = wmoRenderer->createInstance(
-            modelId, renderPos, glm::vec3(0.0f, 0.0f, result.orientation), result.scale);
-        if (instanceId == 0) continue;
-
-        gameObjectInstances_[result.guid] = {modelId, instanceId, true};
-
-        // Queue transport doodad loading if applicable
-        std::string lowerPath = result.modelPath;
-        std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(),
-                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-        if (lowerPath.find("transport") != std::string::npos) {
-            const auto* doodadTemplates = wmoRenderer->getDoodadTemplates(modelId);
-            if (doodadTemplates && !doodadTemplates->empty()) {
-                PendingTransportDoodadBatch batch;
-                batch.guid = result.guid;
-                batch.modelId = modelId;
-                batch.instanceId = instanceId;
-                batch.x = result.x;
-                batch.y = result.y;
-                batch.z = result.z;
-                batch.orientation = result.orientation;
-                batch.doodadBudget = doodadTemplates->size();
-                pendingTransportDoodadBatches_.push_back(batch);
-            }
-        }
-    }
-}
-
-void EntitySpawner::processGameObjectSpawnQueue() {
-    // Finalize any completed async WMO loads first
-    processAsyncGameObjectResults();
-
-    if (pendingGameObjectSpawns_.empty()) return;
-
-    static int goQueueLogCounter = 0;
-    if (++goQueueLogCounter % 60 == 1) {
-        LOG_DEBUG("GO queue: ", pendingGameObjectSpawns_.size(), " pending, ",
-                 gameObjectInstances_.size(), " spawned, ",
-                 gameObjectDisplayIdFailedCache_.size(), " failed");
-    }
-
-    // Process spawns: cached WMOs and M2s go sync (cheap), uncached WMOs go async
-    auto startTime = std::chrono::steady_clock::now();
-    static constexpr float kBudgetMs = 2.0f;
-    static constexpr int kMaxAsyncLoads = 2;
-
-    while (!pendingGameObjectSpawns_.empty()) {
-        float elapsedMs = std::chrono::duration<float, std::milli>(
-            std::chrono::steady_clock::now() - startTime).count();
-        if (elapsedMs >= kBudgetMs) break;
-
-        auto& s = pendingGameObjectSpawns_.front();
-
-        // Check if this is an uncached WMO that needs async loading
-        std::string modelPath;
-        if (gameObjectLookupsBuilt_) {
-            // Check transport overrides first
-            bool isTransport = gameHandler_ && gameHandler_->isTransportGuid(s.guid);
-            if (isTransport) {
-                if (s.entry == 20808 || s.entry == 176231 || s.entry == 176310)
-                    modelPath = "World\\wmo\\transports\\transport_ship\\transportship.wmo";
-                else if (s.displayId == 807 || s.displayId == 808 || s.displayId == 175080 || s.displayId == 176495 || s.displayId == 164871)
-                    modelPath = "World\\wmo\\transports\\transport_zeppelin\\transport_zeppelin.wmo";
-                else if (s.displayId == 1587)
-                    modelPath = "World\\wmo\\transports\\transport_horde_zeppelin\\Transport_Horde_Zeppelin.wmo";
-                else if (s.displayId == 2454 || s.displayId == 181688 || s.displayId == 190536)
-                    modelPath = "World\\wmo\\transports\\icebreaker\\Transport_Icebreaker_ship.wmo";
-            }
-            if (modelPath.empty())
-                modelPath = getGameObjectModelPathForDisplayId(s.displayId);
-        }
-
-        std::string lowerPath = modelPath;
-        std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(),
-                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-        bool isWmo = lowerPath.size() >= 4 && lowerPath.substr(lowerPath.size() - 4) == ".wmo";
-        bool isCached = isWmo && gameObjectDisplayIdWmoCache_.count(s.displayId);
-
-        if (isWmo && !isCached && !modelPath.empty() &&
-            static_cast<int>(asyncGameObjectLoads_.size()) < kMaxAsyncLoads) {
-            // Launch async WMO load — file I/O + parse on background thread
-            auto* am = assetManager_;
-            PendingGameObjectSpawn capture = s;
-            std::string capturePath = modelPath;
-            AsyncGameObjectLoad load;
-            load.future = std::async(std::launch::async,
-                [am, capture, capturePath]() -> PreparedGameObjectWMO {
-                    PreparedGameObjectWMO result;
-                    result.guid = capture.guid;
-                    result.entry = capture.entry;
-                    result.displayId = capture.displayId;
-                    result.x = capture.x;
-                    result.y = capture.y;
-                    result.z = capture.z;
-                    result.orientation = capture.orientation;
-                    result.scale = capture.scale;
-                    result.modelPath = capturePath;
-                    result.isWmo = true;
-
-                    auto wmoData = am->readFile(capturePath);
-                    if (wmoData.empty()) return result;
-
-                    auto wmo = std::make_shared<pipeline::WMOModel>(
-                        pipeline::WMOLoader::load(wmoData));
-
-                    // Load groups
-                    if (wmo->nGroups > 0) {
-                        std::string basePath = capturePath;
-                        std::string ext;
-                        if (basePath.size() > 4) {
-                            ext = basePath.substr(basePath.size() - 4);
-                            basePath = basePath.substr(0, basePath.size() - 4);
-                        }
-                        for (uint32_t gi = 0; gi < wmo->nGroups; gi++) {
-                            char suffix[16];
-                            snprintf(suffix, sizeof(suffix), "_%03u%s", gi, ext.c_str());
-                            auto groupData = am->readFile(basePath + suffix);
-                            if (groupData.empty()) {
-                                snprintf(suffix, sizeof(suffix), "_%03u.wmo", gi);
-                                groupData = am->readFile(basePath + suffix);
-                            }
-                            if (!groupData.empty()) {
-                                pipeline::WMOLoader::loadGroup(groupData, *wmo, gi);
-                            }
-                        }
-                    }
-
-                    // Pre-decode WMO textures on background thread
-                    for (const auto& texPath : wmo->textures) {
-                        if (texPath.empty()) continue;
-                        std::string texKey = texPath;
-                        size_t nul = texKey.find('\0');
-                        if (nul != std::string::npos) texKey.resize(nul);
-                        std::replace(texKey.begin(), texKey.end(), '/', '\\');
-                        std::transform(texKey.begin(), texKey.end(), texKey.begin(),
-                                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-                        if (texKey.empty()) continue;
-                        // Convert to .blp extension
-                        if (texKey.size() >= 4) {
-                            std::string ext = texKey.substr(texKey.size() - 4);
-                            if (ext == ".tga" || ext == ".dds") {
-                                texKey = texKey.substr(0, texKey.size() - 4) + ".blp";
-                            }
-                        }
-                        if (result.predecodedTextures.find(texKey) != result.predecodedTextures.end()) continue;
-                        auto blp = am->loadTexture(texKey);
-                        if (blp.isValid()) {
-                            result.predecodedTextures[texKey] = std::move(blp);
-                        }
-                    }
-
-                    result.wmoModel = wmo;
-                    result.valid = true;
-                    return result;
-                });
-            asyncGameObjectLoads_.push_back(std::move(load));
-            pendingGameObjectSpawns_.erase(pendingGameObjectSpawns_.begin());
-            continue;
-        }
-
-        // Cached WMO or M2 — spawn synchronously (cheap)
-        spawnOnlineGameObject(s.guid, s.entry, s.displayId, s.x, s.y, s.z, s.orientation, s.scale);
-        pendingGameObjectSpawns_.erase(pendingGameObjectSpawns_.begin());
-    }
-}
-
-void EntitySpawner::processPendingTransportRegistrations() {
-    if (pendingTransportRegistrations_.empty()) return;
-    if (!gameHandler_ || !renderer_) return;
-
-    auto* transportManager = gameHandler_->getTransportManager();
-    if (!transportManager) return;
-
-    auto startTime = std::chrono::steady_clock::now();
-    static constexpr int kMaxRegistrationsPerFrame = 2;
-    static constexpr float kRegistrationBudgetMs = 2.0f;
-    int processed = 0;
-
-    for (auto it = pendingTransportRegistrations_.begin();
-         it != pendingTransportRegistrations_.end() && processed < kMaxRegistrationsPerFrame;) {
-        float elapsedMs = std::chrono::duration<float, std::milli>(
-            std::chrono::steady_clock::now() - startTime).count();
-        if (elapsedMs >= kRegistrationBudgetMs) break;
-
-        const PendingTransportRegistration pending = *it;
-        auto goIt = gameObjectInstances_.find(pending.guid);
-        if (goIt == gameObjectInstances_.end()) {
-            it = pendingTransportRegistrations_.erase(it);
-            continue;
-        }
-
-        if (transportManager->getTransport(pending.guid)) {
-            transportManager->updateServerTransport(
-                pending.guid, glm::vec3(pending.x, pending.y, pending.z), pending.orientation);
-            it = pendingTransportRegistrations_.erase(it);
-            continue;
-        }
-
-        const uint32_t wmoInstanceId = goIt->second.instanceId;
-        LOG_WARNING("Registering server transport: GUID=0x", std::hex, pending.guid, std::dec,
-                 " entry=", pending.entry, " displayId=", pending.displayId, " wmoInstance=", wmoInstanceId,
-                 " pos=(", pending.x, ", ", pending.y, ", ", pending.z, ")");
-
-        // TransportAnimation.dbc is indexed by GameObject entry.
-        uint32_t pathId = pending.entry;
-        const bool preferServerData = gameHandler_->hasServerTransportUpdate(pending.guid);
-
-        bool clientAnim = transportManager->isClientSideAnimation();
-        LOG_DEBUG("Transport spawn callback: clientAnimation=", clientAnim,
-                 " guid=0x", std::hex, pending.guid, std::dec,
-                 " entry=", pending.entry, " pathId=", pathId,
-                 " preferServer=", preferServerData);
-
-        glm::vec3 canonicalSpawnPos(pending.x, pending.y, pending.z);
-        const bool shipOrZeppelinDisplay =
-            (pending.displayId == 3015 || pending.displayId == 3031 || pending.displayId == 7546 ||
-             pending.displayId == 7446 || pending.displayId == 1587 || pending.displayId == 2454 ||
-             pending.displayId == 807 || pending.displayId == 808);
-        bool hasUsablePath = transportManager->hasPathForEntry(pending.entry);
-        if (shipOrZeppelinDisplay) {
-            hasUsablePath = transportManager->hasUsableMovingPathForEntry(pending.entry, 25.0f);
-        }
-
-        LOG_WARNING("Transport path check: entry=", pending.entry, " hasUsablePath=", hasUsablePath,
-                 " preferServerData=", preferServerData, " shipOrZepDisplay=", shipOrZeppelinDisplay);
-
-        if (preferServerData) {
-            if (!hasUsablePath) {
-                std::vector<glm::vec3> path = { canonicalSpawnPos };
-                transportManager->loadPathFromNodes(pathId, path, false, 0.0f);
-                LOG_WARNING("Server-first strict registration: stationary fallback for GUID 0x",
-                         std::hex, pending.guid, std::dec, " entry=", pending.entry);
-            } else {
-                LOG_WARNING("Server-first transport registration: using entry DBC path for entry ", pending.entry);
-            }
-        } else if (!hasUsablePath) {
-            bool allowZOnly = (pending.displayId == 455 || pending.displayId == 462);
-            uint32_t inferredPath = transportManager->inferDbcPathForSpawn(
-                canonicalSpawnPos, 1200.0f, allowZOnly);
-            if (inferredPath != 0) {
-                pathId = inferredPath;
-                LOG_WARNING("Using inferred transport path ", pathId, " for entry ", pending.entry);
-            } else {
-                uint32_t remappedPath = transportManager->pickFallbackMovingPath(pending.entry, pending.displayId);
-                if (remappedPath != 0) {
-                    pathId = remappedPath;
-                    LOG_WARNING("Using remapped fallback transport path ", pathId,
-                             " for entry ", pending.entry, " displayId=", pending.displayId,
-                             " (usableEntryPath=", transportManager->hasPathForEntry(pending.entry), ")");
-                } else {
-                    LOG_WARNING("No TransportAnimation.dbc path for entry ", pending.entry,
-                                " - transport will be stationary");
-                    std::vector<glm::vec3> path = { canonicalSpawnPos };
-                    transportManager->loadPathFromNodes(pathId, path, false, 0.0f);
-                }
-            }
-        } else {
-            LOG_WARNING("Using real transport path from TransportAnimation.dbc for entry ", pending.entry);
-        }
-
-        transportManager->registerTransport(pending.guid, wmoInstanceId, pathId, canonicalSpawnPos, pending.entry);
-
-        if (!goIt->second.isWmo) {
-            if (auto* tr = transportManager->getTransport(pending.guid)) {
-                tr->isM2 = true;
-            }
-        }
-
-        transportManager->updateServerTransport(
-            pending.guid, glm::vec3(pending.x, pending.y, pending.z), pending.orientation);
-
-        auto moveIt = pendingTransportMoves_.find(pending.guid);
-        if (moveIt != pendingTransportMoves_.end()) {
-            const PendingTransportMove latestMove = moveIt->second;
-            transportManager->updateServerTransport(
-                pending.guid, glm::vec3(latestMove.x, latestMove.y, latestMove.z), latestMove.orientation);
-            LOG_DEBUG("Replayed queued transport move for GUID=0x", std::hex, pending.guid, std::dec,
-                     " pos=(", latestMove.x, ", ", latestMove.y, ", ", latestMove.z,
-                     ") orientation=", latestMove.orientation);
-            pendingTransportMoves_.erase(moveIt);
-        }
-
-        if (glm::dot(canonicalSpawnPos, canonicalSpawnPos) < 1.0f) {
-            auto goData = gameHandler_->getCachedGameObjectInfo(pending.entry);
-            if (goData && goData->type == 15 && goData->hasData && goData->data[0] != 0) {
-                uint32_t taxiPathId = goData->data[0];
-                if (transportManager->hasTaxiPath(taxiPathId)) {
-                    transportManager->assignTaxiPathToTransport(pending.entry, taxiPathId);
-                    LOG_DEBUG("Assigned cached TaxiPathNode path for MO_TRANSPORT entry=", pending.entry,
-                             " taxiPathId=", taxiPathId);
-                }
-            }
-        }
-
-        if (auto* tr = transportManager->getTransport(pending.guid); tr) {
-            LOG_WARNING("Transport registered: guid=0x", std::hex, pending.guid, std::dec,
-                     " entry=", pending.entry, " displayId=", pending.displayId,
-                     " pathId=", tr->pathId,
-                     " mode=", (tr->useClientAnimation ? "client" : "server"),
-                     " serverUpdates=", tr->serverUpdateCount);
-        } else {
-            LOG_DEBUG("Transport registered: guid=0x", std::hex, pending.guid, std::dec,
-                     " entry=", pending.entry, " displayId=", pending.displayId,
-                     " (TransportManager instance missing)");
-        }
-
-        ++processed;
-        it = pendingTransportRegistrations_.erase(it);
-    }
-}
-
-void EntitySpawner::processPendingTransportDoodads() {
-    if (pendingTransportDoodadBatches_.empty()) return;
-    if (!renderer_ || !assetManager_) return;
-
-    auto* wmoRenderer = renderer_->getWMORenderer();
-    auto* m2Renderer = renderer_->getM2Renderer();
-    if (!wmoRenderer || !m2Renderer) return;
-
-    auto startTime = std::chrono::steady_clock::now();
-    static constexpr float kDoodadBudgetMs = 4.0f;
-
-    // Batch all GPU uploads into a single async command buffer submission so that
-    // N doodads with multiple textures each don't each block on vkQueueSubmit +
-    // vkWaitForFences. Without batching, 30+ doodads × several textures = hundreds
-    // of sync GPU submits → the 490ms stall that preceded the VK_ERROR_DEVICE_LOST.
-    auto* vkCtx = renderer_->getVkContext();
-    if (vkCtx) vkCtx->beginUploadBatch();
-
-    size_t budgetLeft = MAX_TRANSPORT_DOODADS_PER_FRAME;
-    for (auto it = pendingTransportDoodadBatches_.begin();
-         it != pendingTransportDoodadBatches_.end() && budgetLeft > 0;) {
-        // Time budget check
-        float elapsedMs = std::chrono::duration<float, std::milli>(
-            std::chrono::steady_clock::now() - startTime).count();
-        if (elapsedMs >= kDoodadBudgetMs) break;
-        auto goIt = gameObjectInstances_.find(it->guid);
-        if (goIt == gameObjectInstances_.end() || !goIt->second.isWmo ||
-            goIt->second.instanceId != it->instanceId || goIt->second.modelId != it->modelId) {
-            it = pendingTransportDoodadBatches_.erase(it);
-            continue;
-        }
-
-        const auto* doodadTemplates = wmoRenderer->getDoodadTemplates(it->modelId);
-        if (!doodadTemplates || doodadTemplates->empty()) {
-            it = pendingTransportDoodadBatches_.erase(it);
-            continue;
-        }
-
-        const size_t maxIndex = std::min(it->doodadBudget, doodadTemplates->size());
-        while (it->nextIndex < maxIndex && budgetLeft > 0) {
-            // Per-doodad time budget (each does synchronous file I/O + parse + GPU upload)
-            float innerMs = std::chrono::duration<float, std::milli>(
-                std::chrono::steady_clock::now() - startTime).count();
-            if (innerMs >= kDoodadBudgetMs) { budgetLeft = 0; break; }
-
-            const auto& doodadTemplate = (*doodadTemplates)[it->nextIndex];
-            it->nextIndex++;
-            budgetLeft--;
-
-            uint32_t doodadModelId = static_cast<uint32_t>(std::hash<std::string>{}(doodadTemplate.m2Path));
-            auto m2Data = assetManager_->readFile(doodadTemplate.m2Path);
-            if (m2Data.empty()) continue;
-
-            pipeline::M2Model m2Model = pipeline::M2Loader::load(m2Data);
-            std::string skinPath = doodadTemplate.m2Path.substr(0, doodadTemplate.m2Path.size() - 3) + "00.skin";
-            std::vector<uint8_t> skinData = assetManager_->readFile(skinPath);
-            if (!skinData.empty() && m2Model.version >= 264) {
-                pipeline::M2Loader::loadSkin(skinData, m2Model);
-            }
-            if (!m2Model.isValid()) continue;
-
-            if (!m2Renderer->loadModel(m2Model, doodadModelId)) continue;
-            uint32_t m2InstanceId = m2Renderer->createInstance(doodadModelId, glm::vec3(0.0f), glm::vec3(0.0f), 1.0f);
-            if (m2InstanceId == 0) continue;
-            m2Renderer->setSkipCollision(m2InstanceId, true);
-
-            wmoRenderer->addDoodadToInstance(it->instanceId, m2InstanceId, doodadTemplate.localTransform);
-            it->spawnedDoodads++;
-        }
-
-        if (it->nextIndex >= maxIndex) {
-            if (it->spawnedDoodads > 0) {
-                LOG_DEBUG("Spawned ", it->spawnedDoodads,
-                         " transport doodads for WMO instance ", it->instanceId);
-                glm::vec3 renderPos = core::coords::canonicalToRender(glm::vec3(it->x, it->y, it->z));
-                glm::mat4 wmoTransform(1.0f);
-                wmoTransform = glm::translate(wmoTransform, renderPos);
-                wmoTransform = glm::rotate(wmoTransform, it->orientation, glm::vec3(0, 0, 1));
-                wmoRenderer->setInstanceTransform(it->instanceId, wmoTransform);
-            }
-            it = pendingTransportDoodadBatches_.erase(it);
-        } else {
-            ++it;
-        }
-    }
-
-    // Finalize the upload batch — submit all GPU copies in one shot (async, no wait).
-    if (vkCtx) vkCtx->endUploadBatch();
-}
-
-void EntitySpawner::processPendingMount() {
-    if (pendingMountDisplayId_ == 0) return;
-    uint32_t mountDisplayId = pendingMountDisplayId_;
-    pendingMountDisplayId_ = 0;
-    LOG_INFO("processPendingMount: loading displayId ", mountDisplayId);
-
-    if (!renderer_ || !renderer_->getCharacterRenderer() || !assetManager_) return;
-    auto* charRenderer = renderer_->getCharacterRenderer();
-
-    std::string m2Path = getModelPathForDisplayId(mountDisplayId);
-    if (m2Path.empty()) {
-        LOG_WARNING("No model path for mount displayId ", mountDisplayId);
-        return;
-    }
-
-    // Check model cache
-    uint32_t modelId = 0;
-    auto cacheIt = displayIdModelCache_.find(mountDisplayId);
-    if (cacheIt != displayIdModelCache_.end()) {
-        modelId = cacheIt->second;
-    } else {
-        modelId = nextCreatureModelId_++;
-
-        auto m2Data = assetManager_->readFile(m2Path);
-        if (m2Data.empty()) {
-            LOG_WARNING("Failed to read mount M2: ", m2Path);
-            return;
-        }
-
-        pipeline::M2Model model = pipeline::M2Loader::load(m2Data);
-        if (model.vertices.empty()) {
-            LOG_WARNING("Failed to parse mount M2: ", m2Path);
-            return;
-        }
-
-        // Load skin file (only for WotLK M2s - vanilla has embedded skin)
-        if (model.version >= 264) {
-            std::string skinPath = m2Path.substr(0, m2Path.size() - 3) + "00.skin";
-            auto skinData = assetManager_->readFile(skinPath);
-            if (!skinData.empty()) {
-                pipeline::M2Loader::loadSkin(skinData, model);
-            } else {
-                LOG_WARNING("Missing skin file for WotLK mount M2: ", skinPath);
-            }
-        }
-
-        // Load external .anim files (only idle + run needed for mounts)
-        std::string basePath = m2Path.substr(0, m2Path.size() - 3);
-        for (uint32_t si = 0; si < model.sequences.size(); si++) {
-            if (!(model.sequences[si].flags & 0x20)) {
-                uint32_t animId = model.sequences[si].id;
-                // Only load stand, walk, run anims to avoid hang
-                if (animId != rendering::anim::STAND && animId != rendering::anim::WALK && animId != rendering::anim::RUN) continue;
-                char animFileName[256];
-                snprintf(animFileName, sizeof(animFileName), "%s%04u-%02u.anim",
-                    basePath.c_str(), animId, model.sequences[si].variationIndex);
-                auto animData = assetManager_->readFileOptional(animFileName);
-                if (!animData.empty()) {
-                    pipeline::M2Loader::loadAnimFile(m2Data, animData, si, model);
-                }
-            }
-        }
-
-        if (!charRenderer->loadModel(model, modelId)) {
-            LOG_WARNING("Failed to load mount model: ", m2Path);
-            return;
-        }
-
-        displayIdModelCache_[mountDisplayId] = modelId;
-    }
-
-    // Apply creature skin textures from CreatureDisplayInfo.dbc.
-    // Re-apply even for cached models so transient failures can self-heal.
-    std::string modelDir;
-    size_t lastSlash = m2Path.find_last_of("\\/");
-    if (lastSlash != std::string::npos) {
-        modelDir = m2Path.substr(0, lastSlash + 1);
-    }
-
-    auto itDisplayData = displayDataMap_.find(mountDisplayId);
-    bool haveDisplayData = false;
-    CreatureDisplayData dispData{};
-    if (itDisplayData != displayDataMap_.end()) {
-        dispData = itDisplayData->second;
-        haveDisplayData = true;
-    } else {
-        // Some taxi mount display IDs are sparse; recover skins by matching model path.
-        std::string lowerMountPath = m2Path;
-        std::transform(lowerMountPath.begin(), lowerMountPath.end(), lowerMountPath.begin(),
-                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-        int bestScore = -1;
-        for (const auto& [dispId, data] : displayDataMap_) {
-            auto pit = modelIdToPath_.find(data.modelId);
-            if (pit == modelIdToPath_.end()) continue;
-            std::string p = pit->second;
-            std::transform(p.begin(), p.end(), p.begin(),
-                           [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-            if (p != lowerMountPath) continue;
-            int score = 0;
-            if (!data.skin1.empty()) {
-                std::string p1 = modelDir + data.skin1 + ".blp";
-                score += assetManager_->fileExists(p1) ? 30 : 3;
-            }
-            if (!data.skin2.empty()) {
-                std::string p2 = modelDir + data.skin2 + ".blp";
-                score += assetManager_->fileExists(p2) ? 20 : 2;
-            }
-            if (!data.skin3.empty()) {
-                std::string p3 = modelDir + data.skin3 + ".blp";
-                score += assetManager_->fileExists(p3) ? 10 : 1;
-            }
-            if (score > bestScore) {
-                bestScore = score;
-                dispData = data;
-                haveDisplayData = true;
-            }
-        }
-        if (haveDisplayData) {
-            LOG_INFO("Recovered mount display data by model path for displayId=", mountDisplayId,
-                     " skin1='", dispData.skin1, "' skin2='", dispData.skin2,
-                     "' skin3='", dispData.skin3, "'");
-        }
-    }
-    if (haveDisplayData) {
-        // If this displayId has no skins, try to find another displayId for the same model with skins.
-        if (dispData.skin1.empty() && dispData.skin2.empty() && dispData.skin3.empty()) {
-            uint32_t sourceModelId = dispData.modelId;
-            int bestScore = -1;
-            for (const auto& [dispId, data] : displayDataMap_) {
-                if (data.modelId != sourceModelId) continue;
-                int score = 0;
-                if (!data.skin1.empty()) {
-                    std::string p = modelDir + data.skin1 + ".blp";
-                    score += assetManager_->fileExists(p) ? 30 : 3;
-                }
-                if (!data.skin2.empty()) {
-                    std::string p = modelDir + data.skin2 + ".blp";
-                    score += assetManager_->fileExists(p) ? 20 : 2;
-                }
-                if (!data.skin3.empty()) {
-                    std::string p = modelDir + data.skin3 + ".blp";
-                    score += assetManager_->fileExists(p) ? 10 : 1;
-                }
-                if (score > bestScore) {
-                    bestScore = score;
-                    dispData = data;
-                }
-            }
-            LOG_INFO("Mount skin fallback for displayId=", mountDisplayId,
-                     " modelId=", sourceModelId, " skin1='", dispData.skin1,
-                     "' skin2='", dispData.skin2, "' skin3='", dispData.skin3, "'");
-        }
-        const auto* md = charRenderer->getModelData(modelId);
-        if (md) {
-            LOG_INFO("Mount model textures: ", md->textures.size(), " slots, skin1='", dispData.skin1,
-                     "' skin2='", dispData.skin2, "' skin3='", dispData.skin3, "'");
-            for (size_t ti = 0; ti < md->textures.size(); ti++) {
-                LOG_INFO("  tex[", ti, "] type=", md->textures[ti].type,
-                         " filename='", md->textures[ti].filename, "'");
-            }
-
-            int replaced = 0;
-            for (size_t ti = 0; ti < md->textures.size(); ti++) {
-                const auto& tex = md->textures[ti];
-                std::string texPath;
-                if (tex.type == 11 && !dispData.skin1.empty()) {
-                    texPath = modelDir + dispData.skin1 + ".blp";
-                } else if (tex.type == 12 && !dispData.skin2.empty()) {
-                    texPath = modelDir + dispData.skin2 + ".blp";
-                } else if (tex.type == 13 && !dispData.skin3.empty()) {
-                    texPath = modelDir + dispData.skin3 + ".blp";
-                }
-                if (!texPath.empty()) {
-                    rendering::VkTexture* skinTex = charRenderer->loadTexture(texPath);
-                    if (skinTex) {
-                        charRenderer->setModelTexture(modelId, static_cast<uint32_t>(ti), skinTex);
-                        LOG_INFO("  Applied skin texture slot ", ti, ": ", texPath);
-                        replaced++;
-                    } else {
-                        LOG_WARNING("  Failed to load skin texture slot ", ti, ": ", texPath);
-                    }
-                }
-            }
-
-            // Force skin textures onto type-0 (hardcoded) slots that have no filename
-            if (replaced == 0) {
-                for (size_t ti = 0; ti < md->textures.size(); ti++) {
-                    const auto& tex = md->textures[ti];
-                    if (tex.type == 0 && tex.filename.empty()) {
-                        // Empty hardcoded slot — try skin1 then skin2
-                        std::string texPath;
-                        if (!dispData.skin1.empty() && replaced == 0) {
-                            texPath = modelDir + dispData.skin1 + ".blp";
-                        } else if (!dispData.skin2.empty()) {
-                            texPath = modelDir + dispData.skin2 + ".blp";
-                        }
-                        if (!texPath.empty()) {
-                            rendering::VkTexture* skinTex = charRenderer->loadTexture(texPath);
-                            if (skinTex) {
-                                charRenderer->setModelTexture(modelId, static_cast<uint32_t>(ti), skinTex);
-                                LOG_INFO("  Forced skin on empty hardcoded slot ", ti, ": ", texPath);
-                                replaced++;
-                            }
-                        }
-                    }
-                }
-            }
-
-            // If still no textures, try hardcoded model texture filenames
-            if (replaced == 0) {
-                for (size_t ti = 0; ti < md->textures.size(); ti++) {
-                    if (!md->textures[ti].filename.empty()) {
-                        rendering::VkTexture* texId = charRenderer->loadTexture(md->textures[ti].filename);
-                        if (texId) {
-                            charRenderer->setModelTexture(modelId, static_cast<uint32_t>(ti), texId);
-                            LOG_INFO("  Used model embedded texture slot ", ti, ": ", md->textures[ti].filename);
-                            replaced++;
-                        }
-                    }
-                }
-            }
-
-            // Final fallback for gryphon/wyvern: try well-known skin texture names
-            if (replaced == 0 && !md->textures.empty()) {
-                std::string lowerMountPath = m2Path;
-                std::transform(lowerMountPath.begin(), lowerMountPath.end(), lowerMountPath.begin(),
-                               [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-                if (lowerMountPath.find("gryphon") != std::string::npos) {
-                    const char* gryphonSkins[] = {
-                        "Creature\\Gryphon\\Gryphon_Skin.blp",
-                        "Creature\\Gryphon\\Gryphon_Skin01.blp",
-                        "Creature\\Gryphon\\GRYPHON_SKIN01.BLP",
-                        nullptr
-                    };
-                    for (const char** p = gryphonSkins; *p; ++p) {
-                        rendering::VkTexture* texId = charRenderer->loadTexture(*p);
-                        if (texId) {
-                            charRenderer->setModelTexture(modelId, 0, texId);
-                            LOG_INFO("  Forced gryphon skin fallback: ", *p);
-                            replaced++;
-                            break;
-                        }
-                    }
-                } else if (lowerMountPath.find("wyvern") != std::string::npos) {
-                    const char* wyvernSkins[] = {
-                        "Creature\\Wyvern\\Wyvern_Skin.blp",
-                        "Creature\\Wyvern\\Wyvern_Skin01.blp",
-                        nullptr
-                    };
-                    for (const char** p = wyvernSkins; *p; ++p) {
-                        rendering::VkTexture* texId = charRenderer->loadTexture(*p);
-                        if (texId) {
-                            charRenderer->setModelTexture(modelId, 0, texId);
-                            LOG_INFO("  Forced wyvern skin fallback: ", *p);
-                            replaced++;
-                            break;
-                        }
-                    }
-                }
-            }
-            LOG_INFO("Mount texture setup: ", replaced, " textures applied");
-        }
-    }
-
-    mountModelId_ = modelId;
-
-    // Create mount instance at player position
-    glm::vec3 mountPos = renderer_->getCharacterPosition();
-    float yawRad = glm::radians(renderer_->getCharacterYaw());
-    uint32_t instanceId = charRenderer->createInstance(modelId, mountPos,
-        glm::vec3(0.0f, 0.0f, yawRad), 1.0f);
-
-    if (instanceId == 0) {
-        LOG_WARNING("Failed to create mount instance");
-        return;
-    }
-
-    mountInstanceId_ = instanceId;
-
-    // Compute height offset — place player above mount's back
-    // Use tight bounds from actual vertices (M2 header bounds can be inaccurate)
-    const auto* modelData = charRenderer->getModelData(modelId);
-    float heightOffset = 1.8f;
-    if (modelData && !modelData->vertices.empty()) {
-        float minZ =  std::numeric_limits<float>::max();
-        float maxZ = -std::numeric_limits<float>::max();
-        for (const auto& v : modelData->vertices) {
-            if (v.position.z < minZ) minZ = v.position.z;
-            if (v.position.z > maxZ) maxZ = v.position.z;
-        }
-        float extentZ = maxZ - minZ;
-        LOG_INFO("Mount tight bounds: minZ=", minZ, " maxZ=", maxZ, " extentZ=", extentZ);
-        if (extentZ > 0.5f) {
-            // Saddle point is roughly 75% up the model, measured from model origin
-            heightOffset = maxZ * 0.8f;
-            if (heightOffset < 1.0f) heightOffset = extentZ * 0.75f;
-            if (heightOffset < 1.0f) heightOffset = 1.8f;
-        }
-    }
-
-    renderer_->setMounted(instanceId, mountDisplayId, heightOffset, m2Path);
-
-    // For taxi mounts, start with flying animation; for ground mounts, start with stand
-    bool isTaxi = gameHandler_ && gameHandler_->isOnTaxiFlight();
-    uint32_t startAnim = rendering::anim::STAND;
-    if (isTaxi) {
-        // Try WotLK fly anims first, then Vanilla-friendly fallbacks
-        using namespace rendering::anim;
-        uint32_t taxiCandidates[] = {FLY_FORWARD, FLY_IDLE, FLY_RUN_2, FLY_SPELL, FLY_RISE, SPELL_KNEEL_LOOP, FLY_CUSTOM_SPELL_10, DEAD, RUN};
-        for (uint32_t anim : taxiCandidates) {
-            if (charRenderer->hasAnimation(instanceId, anim)) {
-                startAnim = anim;
-                break;
-            }
-        }
-        // If none found, startAnim stays 0 (Stand/hover) which is fine for flying creatures
-    }
-    charRenderer->playAnimation(instanceId, startAnim, true);
-
-    LOG_INFO("processPendingMount: DONE displayId=", mountDisplayId, " model=", m2Path, " heightOffset=", heightOffset);
-}
-
-void EntitySpawner::despawnCreature(uint64_t guid) {
-    // If this guid is a PLAYER, it will be tracked in playerInstances_.
-    // Route to the correct despawn path so we don't leak instances.
-    if (playerInstances_.count(guid)) {
-        despawnPlayer(guid);
-        return;
-    }
-
-    pendingCreatureSpawnGuids_.erase(guid);
-    creatureSpawnRetryCounts_.erase(guid);
-    creaturePermanentFailureGuids_.erase(guid);
-    deadCreatureGuids_.erase(guid);
-
-    auto it = creatureInstances_.find(guid);
-    if (it == creatureInstances_.end()) return;
-
-    if (renderer_ && renderer_->getCharacterRenderer()) {
-        renderer_->getCharacterRenderer()->removeInstance(it->second);
-    }
-
-    creatureInstances_.erase(it);
-    creatureModelIds_.erase(guid);
-    creatureRenderPosCache_.erase(guid);
-    creatureWeaponsAttached_.erase(guid);
-    creatureWeaponAttachAttempts_.erase(guid);
-    creatureWasMoving_.erase(guid);
-    creatureWasSwimming_.erase(guid);
-    creatureWasFlying_.erase(guid);
-    creatureWasWalking_.erase(guid);
-    creatureSwimmingState_.erase(guid);
-    creatureWalkingState_.erase(guid);
-    creatureFlyingState_.erase(guid);
-
-    LOG_DEBUG("Despawned creature: guid=0x", std::hex, guid, std::dec);
-}
-
-void EntitySpawner::despawnGameObject(uint64_t guid) {
-    pendingTransportDoodadBatches_.erase(
-        std::remove_if(pendingTransportDoodadBatches_.begin(), pendingTransportDoodadBatches_.end(),
-                       [guid](const PendingTransportDoodadBatch& b) { return b.guid == guid; }),
-        pendingTransportDoodadBatches_.end());
-
-    auto it = gameObjectInstances_.find(guid);
-    if (it == gameObjectInstances_.end()) return;
-
-    if (renderer_) {
-        if (it->second.isWmo) {
-            if (auto* wmoRenderer = renderer_->getWMORenderer()) {
-                wmoRenderer->removeInstance(it->second.instanceId);
-            }
-        } else {
-            if (auto* m2Renderer = renderer_->getM2Renderer()) {
-                m2Renderer->removeInstance(it->second.instanceId);
-            }
-        }
-    }
-
-    gameObjectInstances_.erase(it);
-
-    LOG_DEBUG("Despawned gameobject: guid=0x", std::hex, guid, std::dec);
-}
-
-bool EntitySpawner::loadWeaponM2(const std::string& m2Path, pipeline::M2Model& outModel) {
-    auto m2Data = assetManager_->readFile(m2Path);
-    if (m2Data.empty()) return false;
-    outModel = pipeline::M2Loader::load(m2Data);
-    // Load skin (WotLK+ M2 format): strip .m2, append 00.skin
-    std::string skinPath = m2Path;
-    size_t dotPos = skinPath.rfind('.');
-    if (dotPos != std::string::npos) skinPath = skinPath.substr(0, dotPos);
-    skinPath += "00.skin";
-    auto skinData = assetManager_->readFile(skinPath);
-    if (!skinData.empty() && outModel.version >= 264)
-        pipeline::M2Loader::loadSkin(skinData, outModel);
-    return outModel.isValid();
-}
-
-
-} // namespace core
-} // namespace wowee
diff --git a/src/core/input.cpp b/src/core/input.cpp
index 4c909824..b7c0e060 100644
--- a/src/core/input.cpp
+++ b/src/core/input.cpp
@@ -25,10 +25,7 @@ void Input::update() {
     Uint32 mouseState = SDL_GetMouseState(&mouseX, &mouseY);
     mousePosition = glm::vec2(static_cast<float>(mouseX), static_cast<float>(mouseY));
 
-    // SDL_BUTTON(x) is defined as (1 << (x-1)), so button indices are 1-based.
-    // SDL_BUTTON(0) is undefined behavior (negative shift). Start at 1.
-    currentMouseState[0] = false;
-    for (int i = 1; i < NUM_MOUSE_BUTTONS; ++i) {
+    for (int i = 0; i < NUM_MOUSE_BUTTONS; ++i) {
         currentMouseState[i] = (mouseState & SDL_BUTTON(i)) != 0;
     }
 
diff --git a/src/core/logger.cpp b/src/core/logger.cpp
index 27162dfd..0a85d6df 100644
--- a/src/core/logger.cpp
+++ b/src/core/logger.cpp
@@ -124,11 +124,10 @@ void Logger::log(LogLevel level, const std::string& message) {
         return;
     }
 
-    // Capture timestamp before acquiring lock to minimize critical section
-    auto nowSteady = std::chrono::steady_clock::now();
-
     std::lock_guard<std::mutex> lock(mutex);
     ensureFile();
+
+    auto nowSteady = std::chrono::steady_clock::now();
     if (dedupeEnabled_ && !lastMessage_.empty() &&
         level == lastLevel_ && message == lastMessage_) {
         auto elapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(nowSteady - lastMessageTime_).count();
diff --git a/src/core/memory_monitor.cpp b/src/core/memory_monitor.cpp
index 75ee47e3..913240fd 100644
--- a/src/core/memory_monitor.cpp
+++ b/src/core/memory_monitor.cpp
@@ -23,10 +23,9 @@ size_t readMemAvailableBytesFromProc() {
 
     std::string line;
     while (std::getline(meminfo, line)) {
-        // /proc/meminfo format: "MemAvailable:  123456789 kB"
-        static constexpr size_t kFieldPrefixLen = 13; // strlen("MemAvailable:")
+        // Format: "MemAvailable:  123456789 kB"
         if (line.rfind("MemAvailable:", 0) != 0) continue;
-        std::istringstream iss(line.substr(kFieldPrefixLen));
+        std::istringstream iss(line.substr(13));
         size_t kb = 0;
         iss >> kb;
         if (kb > 0) return kb * 1024ull;
@@ -43,18 +42,13 @@ MemoryMonitor& MemoryMonitor::getInstance() {
 }
 
 void MemoryMonitor::initialize() {
-    constexpr size_t kOneGB = 1024ull * 1024 * 1024;
-    // Fallback if OS API unavailable — 16 GB is a safe conservative estimate
-    // that prevents over-aggressive asset caching on unknown hardware.
-    constexpr size_t kFallbackRAM = 16 * kOneGB;
-
 #ifdef _WIN32
     ULONGLONG totalKB = 0;
     if (GetPhysicallyInstalledSystemMemory(&totalKB)) {
         totalRAM_ = static_cast<size_t>(totalKB) * 1024ull;
-        LOG_INFO("System RAM detected: ", totalRAM_ / kOneGB, " GB");
+        LOG_INFO("System RAM detected: ", totalRAM_ / (1024 * 1024 * 1024), " GB");
     } else {
-        totalRAM_ = kFallbackRAM;
+        totalRAM_ = 16ull * 1024 * 1024 * 1024;
         LOG_WARNING("Could not detect system RAM, assuming 16GB");
     }
 #elif defined(__APPLE__)
@@ -62,18 +56,19 @@ void MemoryMonitor::initialize() {
     size_t len = sizeof(physmem);
     if (sysctlbyname("hw.memsize", &physmem, &len, nullptr, 0) == 0) {
         totalRAM_ = static_cast<size_t>(physmem);
-        LOG_INFO("System RAM detected: ", totalRAM_ / kOneGB, " GB");
+        LOG_INFO("System RAM detected: ", totalRAM_ / (1024 * 1024 * 1024), " GB");
     } else {
-        totalRAM_ = kFallbackRAM;
+        totalRAM_ = 16ull * 1024 * 1024 * 1024;
         LOG_WARNING("Could not detect system RAM, assuming 16GB");
     }
 #else
     struct sysinfo info;
     if (sysinfo(&info) == 0) {
         totalRAM_ = static_cast<size_t>(info.totalram) * info.mem_unit;
-        LOG_INFO("System RAM detected: ", totalRAM_ / kOneGB, " GB");
+        LOG_INFO("System RAM detected: ", totalRAM_ / (1024 * 1024 * 1024), " GB");
     } else {
-        totalRAM_ = kFallbackRAM;
+        // Fallback: assume 16GB
+        totalRAM_ = 16ull * 1024 * 1024 * 1024;
         LOG_WARNING("Could not detect system RAM, assuming 16GB");
     }
 #endif
@@ -114,16 +109,16 @@ size_t MemoryMonitor::getAvailableRAM() const {
 
 size_t MemoryMonitor::getRecommendedCacheBudget() const {
     size_t available = getAvailableRAM();
-    // Use 50% of available RAM for caches, hard-capped at 16 GB.
-    static constexpr size_t kHardCapBytes = 16ull * 1024 * 1024 * 1024;  // 16 GB
-    size_t budget = available * 50 / 100;
-    return budget < kHardCapBytes ? budget : kHardCapBytes;
+    // Use 80% of available RAM for caches (very aggressive), but cap at 90% of total
+    size_t budget = available * 80 / 100;
+    size_t maxBudget = totalRAM_ * 90 / 100;
+    return budget < maxBudget ? budget : maxBudget;
 }
 
 bool MemoryMonitor::isMemoryPressure() const {
     size_t available = getAvailableRAM();
-    // Memory pressure if < 10% RAM available
-    return available < (totalRAM_ * 10 / 100);
+    // Memory pressure if < 20% RAM available
+    return available < (totalRAM_ * 20 / 100);
 }
 
 } // namespace core
diff --git a/src/core/window.cpp b/src/core/window.cpp
index f48f2a51..9f74a81c 100644
--- a/src/core/window.cpp
+++ b/src/core/window.cpp
@@ -38,15 +38,6 @@ bool Window::initialize() {
     // clear error and avoids the misleading "not configured in SDL" message.
     // SDL 2.28+ uses LoadLibraryExW(LOAD_LIBRARY_SEARCH_DEFAULT_DIRS) which does
     // not search System32, so fall back to the explicit path on Windows if needed.
-    //
-    // On macOS, MoltenVK is a Vulkan "portability" driver.  The Vulkan loader
-    // hides portability drivers (and their extensions like VK_KHR_surface) from
-    // pre-instance enumeration unless told otherwise.  Setting this env var
-    // makes the loader include portability ICDs so SDL's VK_KHR_surface check
-    // succeeds.
-#ifdef __APPLE__
-    setenv("VK_LOADER_ENABLE_PORTABILITY_DRIVERS", "1", 0 /*don't overwrite*/);
-#endif
     bool vulkanLoaded = (SDL_Vulkan_LoadLibrary(nullptr) == 0);
 #ifdef _WIN32
     if (!vulkanLoaded) {
@@ -103,8 +94,6 @@ bool Window::initialize() {
     return true;
 }
 
-// Shutdown progress uses LOG_WARNING so these messages are always visible even at
-// default log levels — useful for diagnosing hangs or crashes during teardown.
 void Window::shutdown() {
     LOG_WARNING("Window::shutdown - vkContext...");
     if (vkContext) {
diff --git a/src/core/world_loader.cpp b/src/core/world_loader.cpp
deleted file mode 100644
index 6811c26a..00000000
--- a/src/core/world_loader.cpp
+++ /dev/null
@@ -1,1233 +0,0 @@
-// WorldLoader — terrain streaming, map transitions, world preloading
-// Extracted from Application as part of god-class decomposition (Section 3.3)
-
-#include "core/world_loader.hpp"
-#include "core/application.hpp"
-#include "rendering/animation/animation_ids.hpp"
-#include "core/entity_spawner.hpp"
-#include "core/appearance_composer.hpp"
-#include "core/window.hpp"
-#include "core/coordinates.hpp"
-#include "core/logger.hpp"
-#include "rendering/renderer.hpp"
-#include "rendering/vk_context.hpp"
-#include "rendering/camera.hpp"
-#include "rendering/camera_controller.hpp"
-#include "rendering/terrain_manager.hpp"
-#include "rendering/character_renderer.hpp"
-#include "rendering/wmo_renderer.hpp"
-#include "rendering/m2_renderer.hpp"
-#include "rendering/quest_marker_renderer.hpp"
-#include "rendering/loading_screen.hpp"
-#include "addons/addon_manager.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "pipeline/dbc_layout.hpp"
-#include "pipeline/m2_loader.hpp"
-#include "pipeline/wmo_loader.hpp"
-#include "pipeline/wdt_loader.hpp"
-#include "game/game_handler.hpp"
-#include "game/transport_manager.hpp"
-#include "game/world.hpp"
-
-#include <SDL2/SDL.h>
-#include <chrono>
-#include <filesystem>
-#include <fstream>
-#include <algorithm>
-#include <cctype>
-#include <glm/gtc/quaternion.hpp>
-
-namespace wowee {
-namespace core {
-
-WorldLoader::WorldLoader(Application& app,
-                         rendering::Renderer* renderer,
-                         pipeline::AssetManager* assetManager,
-                         game::GameHandler* gameHandler,
-                         EntitySpawner* entitySpawner,
-                         AppearanceComposer* appearanceComposer,
-                         Window* window,
-                         game::World* world,
-                         addons::AddonManager* addonManager)
-    : app_(app)
-    , renderer_(renderer)
-    , assetManager_(assetManager)
-    , gameHandler_(gameHandler)
-    , entitySpawner_(entitySpawner)
-    , appearanceComposer_(appearanceComposer)
-    , window_(window)
-    , world_(world)
-    , addonManager_(addonManager)
-{}
-
-WorldLoader::~WorldLoader() {
-    cancelWorldPreload();
-}
-
-const char* WorldLoader::mapDisplayName(uint32_t mapId) {
-    // Friendly display names for the loading screen
-    switch (mapId) {
-        case 0: return "Eastern Kingdoms";
-        case 1: return "Kalimdor";
-        case 530: return "Outland";
-        case 571: return "Northrend";
-        default: return nullptr;
-    }
-}
-
-const char* WorldLoader::mapIdToName(uint32_t mapId) {
-    // Fallback when Map.dbc is unavailable. Names must match WDT directory names
-    // (case-insensitive — AssetManager lowercases all paths).
-    switch (mapId) {
-        // Continents
-        case 0: return "Azeroth";
-        case 1: return "Kalimdor";
-        case 530: return "Expansion01";
-        case 571: return "Northrend";
-        // Classic dungeons/raids
-        case 30: return "PVPZone01";
-        case 33: return "Shadowfang";
-        case 34: return "StormwindJail";
-        case 36: return "DeadminesInstance";
-        case 43: return "WailingCaverns";
-        case 47: return "RazserfenKraulInstance";
-        case 48: return "Blackfathom";
-        case 70: return "Uldaman";
-        case 90: return "GnomeragonInstance";
-        case 109: return "SunkenTemple";
-        case 129: return "RazorfenDowns";
-        case 189: return "MonasteryInstances";
-        case 209: return "TanarisInstance";
-        case 229: return "BlackRockSpire";
-        case 230: return "BlackrockDepths";
-        case 249: return "OnyxiaLairInstance";
-        case 289: return "ScholomanceInstance";
-        case 309: return "Zul'Gurub";
-        case 329: return "Stratholme";
-        case 349: return "Mauradon";
-        case 369: return "DeeprunTram";
-        case 389: return "OrgrimmarInstance";
-        case 409: return "MoltenCore";
-        case 429: return "DireMaul";
-        case 469: return "BlackwingLair";
-        case 489: return "PVPZone03";
-        case 509: return "AhnQiraj";
-        case 529: return "PVPZone04";
-        case 531: return "AhnQirajTemple";
-        case 533: return "Stratholme Raid";
-        // TBC
-        case 532: return "Karazahn";
-        case 534: return "HyjalPast";
-        case 540: return "HellfireMilitary";
-        case 542: return "HellfireDemon";
-        case 543: return "HellfireRampart";
-        case 544: return "HellfireRaid";
-        case 545: return "CoilfangPumping";
-        case 546: return "CoilfangMarsh";
-        case 547: return "CoilfangDraenei";
-        case 548: return "CoilfangRaid";
-        case 550: return "TempestKeepRaid";
-        case 552: return "TempestKeepArcane";
-        case 553: return "TempestKeepAtrium";
-        case 554: return "TempestKeepFactory";
-        case 555: return "AuchindounShadow";
-        case 556: return "AuchindounDraenei";
-        case 557: return "AuchindounEthereal";
-        case 558: return "AuchindounDemon";
-        case 560: return "HillsbradPast";
-        case 564: return "BlackTemple";
-        case 565: return "GruulsLair";
-        case 566: return "PVPZone05";
-        case 568: return "ZulAman";
-        case 580: return "SunwellPlateau";
-        case 585: return "Sunwell5ManFix";
-        // WotLK
-        case 574: return "Valgarde70";
-        case 575: return "UtgardePinnacle";
-        case 576: return "Nexus70";
-        case 578: return "Nexus80";
-        case 595: return "StratholmeCOT";
-        case 599: return "Ulduar70";
-        case 600: return "Ulduar80";
-        case 601: return "DrakTheronKeep";
-        case 602: return "GunDrak";
-        case 603: return "UlduarRaid";
-        case 608: return "DalaranPrison";
-        case 615: return "ChamberOfAspectsBlack";
-        case 617: return "DeathKnightStart";
-        case 619: return "Azjol_Uppercity";
-        case 624: return "WintergraspRaid";
-        case 631: return "IcecrownCitadel";
-        case 632: return "IcecrownCitadel5Man";
-        case 649: return "ArgentTournamentRaid";
-        case 650: return "ArgentTournamentDungeon";
-        case 658: return "QuarryOfTears";
-        case 668: return "HallsOfReflection";
-        case 724: return "ChamberOfAspectsRed";
-        default: return "";
-    }
-}
-
-void WorldLoader::processPendingEntry() {
-    if (!pendingWorldEntry_ || loadingWorld_) return;
-    auto entry = *pendingWorldEntry_;
-    pendingWorldEntry_.reset();
-    LOG_WARNING("Processing deferred world entry: map ", entry.mapId);
-    app_.worldEntryMovementGraceTimer_ = 2.0f;
-    app_.taxiLandingClampTimer_ = 0.0f;
-    app_.lastTaxiFlight_ = false;
-    // Clear camera movement inputs before loading terrain
-    if (renderer_ && renderer_->getCameraController()) {
-        renderer_->getCameraController()->clearMovementInputs();
-        renderer_->getCameraController()->suppressMovementFor(1.0f);
-        renderer_->getCameraController()->suspendGravityFor(10.0f);
-    }
-    loadOnlineWorldTerrain(entry.mapId, entry.x, entry.y, entry.z);
-}
-
-void WorldLoader::loadOnlineWorldTerrain(uint32_t mapId, float x, float y, float z) {
-    if (!renderer_ || !assetManager_ || !assetManager_->isInitialized()) {
-        LOG_WARNING("Cannot load online terrain: renderer or assets not ready");
-        return;
-    }
-
-    // Guard against re-entrant calls. The worldEntryCallback defers new
-    // entries while this flag is set; we process them at the end.
-    loadingWorld_ = true;
-    pendingWorldEntry_.reset();
-
-    // --- Loading screen for online mode ---
-    rendering::LoadingScreen loadingScreen;
-    loadingScreen.setVkContext(window_->getVkContext());
-    loadingScreen.setSDLWindow(window_->getSDLWindow());
-    bool loadingScreenOk = loadingScreen.initialize();
-
-    auto showProgress = [&](const char* msg, float progress) {
-        SDL_Event event;
-        while (SDL_PollEvent(&event)) {
-            if (event.type == SDL_QUIT) {
-                window_->setShouldClose(true);
-                loadingScreen.shutdown();
-                return;
-            }
-            if (event.type == SDL_WINDOWEVENT &&
-                event.window.event == SDL_WINDOWEVENT_RESIZED) {
-                int w = event.window.data1;
-                int h = event.window.data2;
-                window_->setSize(w, h);
-                // Vulkan viewport set in command buffer
-                if (renderer_ && renderer_->getCamera()) {
-                    renderer_->getCamera()->setAspectRatio(static_cast<float>(w) / h);
-                }
-            }
-        }
-        if (!loadingScreenOk) return;
-        loadingScreen.setStatus(msg);
-        loadingScreen.setProgress(progress);
-        loadingScreen.render();
-        window_->swapBuffers();
-    };
-
-    // Set zone name on loading screen — prefer friendly display name, then DBC
-    {
-        const char* friendly = mapDisplayName(mapId);
-        if (friendly) {
-            loadingScreen.setZoneName(friendly);
-        } else if (gameHandler_) {
-            std::string dbcName = gameHandler_->getMapName(mapId);
-            if (!dbcName.empty())
-                loadingScreen.setZoneName(dbcName);
-            else
-                loadingScreen.setZoneName("Loading...");
-        }
-    }
-
-    showProgress("Entering world...", 0.0f);
-
-    // --- Clean up previous map's state on map change ---
-    // (Same cleanup as logout, but preserves player identity and renderer objects.)
-    LOG_WARNING("loadOnlineWorldTerrain: mapId=", mapId, " loadedMapId_=", loadedMapId_);
-    bool hasRendererData = renderer_ && (renderer_->getWMORenderer() || renderer_->getM2Renderer());
-    if (loadedMapId_ != 0xFFFFFFFF || hasRendererData) {
-        LOG_WARNING("Map change: cleaning up old map ", loadedMapId_, " before loading map ", mapId);
-
-        // Clear pending queues first (these don't touch GPU resources)
-        entitySpawner_->clearAllQueues();
-
-        if (renderer_) {
-            // Clear all world geometry from old map (including textures/models).
-            // WMO clearAll and M2 clear both call vkDeviceWaitIdle internally,
-            // ensuring no GPU command buffers reference old resources.
-            if (auto* wmo = renderer_->getWMORenderer()) {
-                wmo->clearAll();
-            }
-            if (auto* m2 = renderer_->getM2Renderer()) {
-                m2->clear();
-            }
-
-            // Full clear of character renderer: removes all instances, models,
-            // textures, and resets descriptor pools. This prevents stale GPU
-            // resources from accumulating across map changes (old creature
-            // models, bone buffers, texture descriptor sets) which can cause
-            // VK_ERROR_DEVICE_LOST on some drivers.
-            if (auto* cr = renderer_->getCharacterRenderer()) {
-                cr->clear();
-                renderer_->setCharacterFollow(0);
-            }
-            // Reset equipment dirty tracking so composited textures are rebuilt
-            // after spawnPlayerCharacter() recreates the character instance.
-            if (gameHandler_) {
-                gameHandler_->resetEquipmentDirtyTracking();
-            }
-
-            if (auto* terrain = renderer_->getTerrainManager()) {
-                terrain->softReset();
-                terrain->setStreamingEnabled(true);  // Re-enable in case previous map disabled it
-            }
-            if (auto* questMarkers = renderer_->getQuestMarkerRenderer()) {
-                questMarkers->clear();
-            }
-            renderer_->clearMount();
-        }
-
-        // Clear application-level instance tracking (after renderer cleanup)
-        entitySpawner_->resetAllState();
-
-        // Force player character re-spawn on new map
-        app_.playerCharacterSpawned = false;
-    }
-
-    // Resolve map folder name from Map.dbc (authoritative for world/instance maps).
-    // This is required for instances like DeeprunTram (map 369) that are not Azeroth/Kalimdor.
-    if (!mapNameCacheLoaded_ && assetManager_) {
-        mapNameCacheLoaded_ = true;
-        if (auto mapDbc = assetManager_->loadDBC("Map.dbc"); mapDbc && mapDbc->isLoaded()) {
-            mapNameById_.reserve(mapDbc->getRecordCount());
-            const auto* mapL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("Map") : nullptr;
-            for (uint32_t i = 0; i < mapDbc->getRecordCount(); i++) {
-                uint32_t id = mapDbc->getUInt32(i, mapL ? (*mapL)["ID"] : 0);
-                std::string internalName = mapDbc->getString(i, mapL ? (*mapL)["InternalName"] : 1);
-                if (!internalName.empty() && mapNameById_.find(id) == mapNameById_.end()) {
-                    mapNameById_[id] = std::move(internalName);
-                }
-            }
-            LOG_INFO("Loaded Map.dbc map-name cache: ", mapNameById_.size(), " entries");
-        } else {
-            LOG_WARNING("Map.dbc not available; using fallback map-id mapping");
-        }
-    }
-
-    std::string mapName;
-    if (auto it = mapNameById_.find(mapId); it != mapNameById_.end()) {
-        mapName = it->second;
-    } else {
-        mapName = mapIdToName(mapId);
-    }
-    if (mapName.empty()) {
-        LOG_WARNING("Unknown mapId ", mapId, " (no Map.dbc entry); falling back to Azeroth");
-        mapName = "Azeroth";
-    }
-    LOG_INFO("Loading online world terrain for map '", mapName, "' (ID ", mapId, ")");
-
-    // Cancel any stale preload (if it was for a different map, the file cache
-    // still retains whatever was loaded — it doesn't hurt).
-    if (worldPreload_) {
-        if (worldPreload_->mapId == mapId) {
-            LOG_INFO("World preload: cache-warm hit for map '", mapName, "'");
-        } else {
-            LOG_INFO("World preload: map mismatch (preloaded ", worldPreload_->mapName,
-                     ", entering ", mapName, ")");
-        }
-    }
-    cancelWorldPreload();
-
-    // Save this world info for next session's early preload
-    saveLastWorldInfo(mapId, mapName, x, y);
-
-    // Convert server coordinates to canonical WoW coordinates
-    // Server sends: X=West (canonical.Y), Y=North (canonical.X), Z=Up
-    glm::vec3 spawnCanonical = core::coords::serverToCanonical(glm::vec3(x, y, z));
-    glm::vec3 spawnRender = core::coords::canonicalToRender(spawnCanonical);
-
-    // Set camera position and facing from server orientation
-    if (renderer_->getCameraController()) {
-        float yawDeg = 0.0f;
-        if (gameHandler_) {
-            float canonicalYaw = gameHandler_->getMovementInfo().orientation;
-            yawDeg = 180.0f - glm::degrees(canonicalYaw);
-        }
-        renderer_->getCameraController()->setOnlineMode(true);
-        renderer_->getCameraController()->setDefaultSpawn(spawnRender, yawDeg, -15.0f);
-        renderer_->getCameraController()->reset();
-    }
-
-    // Set map name for WMO renderer and reset instance mode
-    if (renderer_->getWMORenderer()) {
-        renderer_->getWMORenderer()->setMapName(mapName);
-        renderer_->getWMORenderer()->setWMOOnlyMap(false);
-    }
-
-    // Set map name for terrain manager
-    if (renderer_->getTerrainManager()) {
-        renderer_->getTerrainManager()->setMapName(mapName);
-    }
-
-    // NOTE: TransportManager renderer connection moved to after initializeRenderers (later in this function)
-
-    // Connect WMORenderer to M2Renderer (for hierarchical transforms: doodads following WMO parents)
-    if (renderer_->getWMORenderer() && renderer_->getM2Renderer()) {
-        renderer_->getWMORenderer()->setM2Renderer(renderer_->getM2Renderer());
-        LOG_INFO("WMORenderer connected to M2Renderer for hierarchical doodad transforms");
-    }
-
-    showProgress("Loading character model...", 0.05f);
-
-    // Build faction hostility map for this character's race
-    if (gameHandler_) {
-        const game::Character* activeChar = gameHandler_->getActiveCharacter();
-        if (activeChar) {
-            app_.buildFactionHostilityMap(static_cast<uint8_t>(activeChar->race));
-        }
-    }
-
-    // Spawn player model for online mode (skip if already spawned, e.g. teleport)
-    if (gameHandler_) {
-        const game::Character* activeChar = gameHandler_->getActiveCharacter();
-        if (activeChar) {
-            const uint64_t activeGuid = gameHandler_->getActiveCharacterGuid();
-            const bool appearanceChanged =
-                (activeGuid != app_.spawnedPlayerGuid_) ||
-                (activeChar->appearanceBytes != app_.spawnedAppearanceBytes_) ||
-                (activeChar->facialFeatures != app_.spawnedFacialFeatures_) ||
-                (activeChar->race != app_.playerRace_) ||
-                (activeChar->gender != app_.playerGender_) ||
-                (activeChar->characterClass != app_.playerClass_);
-
-            if (!app_.playerCharacterSpawned || appearanceChanged) {
-                if (appearanceChanged) {
-                    LOG_INFO("Respawning player model for new/changed character: guid=0x",
-                             std::hex, activeGuid, std::dec);
-                }
-                // Remove old instance so we don't keep stale visuals.
-                if (renderer_ && renderer_->getCharacterRenderer()) {
-                    uint32_t oldInst = renderer_->getCharacterInstanceId();
-                    if (oldInst > 0) {
-                        renderer_->setCharacterFollow(0);
-                        renderer_->clearMount();
-                        renderer_->getCharacterRenderer()->removeInstance(oldInst);
-                    }
-                }
-                app_.playerCharacterSpawned = false;
-                app_.spawnedPlayerGuid_ = 0;
-                app_.spawnedAppearanceBytes_ = 0;
-                app_.spawnedFacialFeatures_ = 0;
-
-                app_.playerRace_ = activeChar->race;
-                app_.playerGender_ = activeChar->gender;
-                app_.playerClass_ = activeChar->characterClass;
-                app_.spawnSnapToGround = false;
-                if (appearanceComposer_) appearanceComposer_->setWeaponsSheathed(false);
-                if (appearanceComposer_) appearanceComposer_->loadEquippedWeapons(); // will no-op until instance exists
-                app_.spawnPlayerCharacter();
-            }
-            renderer_->getCharacterPosition() = spawnRender;
-            LOG_INFO("Online player at render pos (", spawnRender.x, ", ", spawnRender.y, ", ", spawnRender.z, ")");
-        } else {
-            LOG_WARNING("No active character found for player model spawning");
-        }
-    }
-
-    showProgress("Loading terrain...", 0.20f);
-
-    // Check WDT to detect WMO-only maps (dungeons, raids, BGs)
-    bool isWMOOnlyMap = false;
-    pipeline::WDTInfo wdtInfo;
-    {
-        std::string wdtPath = "World\\Maps\\" + mapName + "\\" + mapName + ".wdt";
-        LOG_WARNING("Reading WDT: ", wdtPath);
-        std::vector<uint8_t> wdtData = assetManager_->readFile(wdtPath);
-        if (!wdtData.empty()) {
-            wdtInfo = pipeline::parseWDT(wdtData);
-            isWMOOnlyMap = wdtInfo.isWMOOnly() && !wdtInfo.rootWMOPath.empty();
-            LOG_WARNING("WDT result: isWMOOnly=", isWMOOnlyMap, " rootWMO='", wdtInfo.rootWMOPath, "'");
-        } else {
-            LOG_WARNING("No WDT file found at ", wdtPath);
-        }
-    }
-
-    bool terrainOk = false;
-
-    if (isWMOOnlyMap) {
-        // ---- WMO-only map (dungeon/raid/BG): load root WMO directly ----
-        LOG_WARNING("WMO-only map detected — loading root WMO: ", wdtInfo.rootWMOPath);
-        showProgress("Loading instance geometry...", 0.25f);
-
-        // Initialize renderers if they don't exist yet (first login to a WMO-only map).
-        // On map change, renderers already exist from the previous map.
-        if (!renderer_->getWMORenderer() || !renderer_->getTerrainManager()) {
-            renderer_->initializeRenderers(assetManager_, mapName);
-        }
-
-        // Set map name on WMO renderer and disable terrain streaming (no ADT tiles for instances)
-        if (renderer_->getWMORenderer()) {
-            renderer_->getWMORenderer()->setMapName(mapName);
-            renderer_->getWMORenderer()->setWMOOnlyMap(true);
-        }
-        if (renderer_->getTerrainManager()) {
-            renderer_->getTerrainManager()->setStreamingEnabled(false);
-        }
-
-        // Spawn player character now that renderers are initialized
-        if (!app_.playerCharacterSpawned) {
-            app_.spawnPlayerCharacter();
-            if (appearanceComposer_) appearanceComposer_->loadEquippedWeapons();
-        }
-
-        // Load the root WMO
-        auto* wmoRenderer = renderer_->getWMORenderer();
-        LOG_WARNING("WMO-only: wmoRenderer=", (wmoRenderer ? "valid" : "NULL"));
-        if (wmoRenderer) {
-            LOG_WARNING("WMO-only: reading root WMO file: ", wdtInfo.rootWMOPath);
-            std::vector<uint8_t> wmoData = assetManager_->readFile(wdtInfo.rootWMOPath);
-            LOG_WARNING("WMO-only: root WMO data size=", wmoData.size());
-            if (!wmoData.empty()) {
-                pipeline::WMOModel wmoModel = pipeline::WMOLoader::load(wmoData);
-                LOG_WARNING("WMO-only: parsed WMO model, nGroups=", wmoModel.nGroups);
-
-                if (wmoModel.nGroups > 0) {
-                    showProgress("Loading instance groups...", 0.35f);
-                    std::string basePath = wdtInfo.rootWMOPath;
-                    std::string extension;
-                    if (basePath.size() > 4) {
-                        extension = basePath.substr(basePath.size() - 4);
-                        std::string extLower = extension;
-                        for (char& c : extLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        if (extLower == ".wmo") {
-                            basePath = basePath.substr(0, basePath.size() - 4);
-                        }
-                    }
-
-                    uint32_t loadedGroups = 0;
-                    for (uint32_t gi = 0; gi < wmoModel.nGroups; gi++) {
-                        char groupSuffix[16];
-                        snprintf(groupSuffix, sizeof(groupSuffix), "_%03u%s", gi, extension.c_str());
-                        std::string groupPath = basePath + groupSuffix;
-                        std::vector<uint8_t> groupData = assetManager_->readFile(groupPath);
-                        if (groupData.empty()) {
-                            snprintf(groupSuffix, sizeof(groupSuffix), "_%03u.wmo", gi);
-                            groupData = assetManager_->readFile(basePath + groupSuffix);
-                        }
-                        if (groupData.empty()) {
-                            snprintf(groupSuffix, sizeof(groupSuffix), "_%03u.WMO", gi);
-                            groupData = assetManager_->readFile(basePath + groupSuffix);
-                        }
-                        if (!groupData.empty()) {
-                            pipeline::WMOLoader::loadGroup(groupData, wmoModel, gi);
-                            loadedGroups++;
-                        }
-
-                        // Update loading progress
-                        if (wmoModel.nGroups > 1) {
-                            float groupProgress = 0.35f + 0.30f * static_cast<float>(gi + 1) / wmoModel.nGroups;
-                            char buf[128];
-                            snprintf(buf, sizeof(buf), "Loading instance groups... %u / %u", gi + 1, wmoModel.nGroups);
-                            showProgress(buf, groupProgress);
-                        }
-                    }
-
-                    LOG_INFO("Loaded ", loadedGroups, " / ", wmoModel.nGroups, " WMO groups for instance");
-                }
-
-                // WMO-only maps: MODF uses same format as ADT MODF.
-                // Apply the same rotation conversion that outdoor WMOs get
-                // (including the implicit +180° Z yaw), but skip the ZEROPOINT
-                // position offset for zero-position instances (server sends
-                // coordinates relative to the WMO, not relative to map corner).
-                glm::vec3 wmoPos(0.0f);
-                glm::vec3 wmoRot(
-                    -wdtInfo.rotation[2] * 3.14159f / 180.0f,
-                    -wdtInfo.rotation[0] * 3.14159f / 180.0f,
-                    (wdtInfo.rotation[1] + 180.0f) * 3.14159f / 180.0f
-                );
-                if (wdtInfo.position[0] != 0.0f || wdtInfo.position[1] != 0.0f || wdtInfo.position[2] != 0.0f) {
-                    wmoPos = core::coords::adtToWorld(
-                        wdtInfo.position[0], wdtInfo.position[1], wdtInfo.position[2]);
-                }
-
-                showProgress("Uploading instance geometry...", 0.70f);
-                uint32_t wmoModelId = 900000 + mapId;  // Unique ID range for instance WMOs
-                if (wmoRenderer->loadModel(wmoModel, wmoModelId)) {
-                    uint32_t instanceId = wmoRenderer->createInstance(wmoModelId, wmoPos, wmoRot, 1.0f);
-                    if (instanceId > 0) {
-                        LOG_WARNING("Instance WMO loaded: modelId=", wmoModelId,
-                                " instanceId=", instanceId);
-                        LOG_WARNING("  MOHD bbox local: (",
-                                   wmoModel.boundingBoxMin.x, ", ", wmoModel.boundingBoxMin.y, ", ", wmoModel.boundingBoxMin.z,
-                                   ") to (", wmoModel.boundingBoxMax.x, ", ", wmoModel.boundingBoxMax.y, ", ", wmoModel.boundingBoxMax.z, ")");
-                        LOG_WARNING("  WMO pos: (", wmoPos.x, ", ", wmoPos.y, ", ", wmoPos.z,
-                                   ") rot: (", wmoRot.x, ", ", wmoRot.y, ", ", wmoRot.z, ")");
-                        LOG_WARNING("  Player render pos: (", spawnRender.x, ", ", spawnRender.y, ", ", spawnRender.z, ")");
-                        LOG_WARNING("  Player canonical: (", spawnCanonical.x, ", ", spawnCanonical.y, ", ", spawnCanonical.z, ")");
-                        // Show player position in WMO local space
-                        {
-                            glm::mat4 instMat(1.0f);
-                            instMat = glm::translate(instMat, wmoPos);
-                            instMat = glm::rotate(instMat, wmoRot.z, glm::vec3(0,0,1));
-                            instMat = glm::rotate(instMat, wmoRot.y, glm::vec3(0,1,0));
-                            instMat = glm::rotate(instMat, wmoRot.x, glm::vec3(1,0,0));
-                            glm::mat4 invMat = glm::inverse(instMat);
-                            glm::vec3 localPlayer = glm::vec3(invMat * glm::vec4(spawnRender, 1.0f));
-                            LOG_WARNING("  Player in WMO local: (", localPlayer.x, ", ", localPlayer.y, ", ", localPlayer.z, ")");
-                            bool inside = localPlayer.x >= wmoModel.boundingBoxMin.x && localPlayer.x <= wmoModel.boundingBoxMax.x &&
-                                          localPlayer.y >= wmoModel.boundingBoxMin.y && localPlayer.y <= wmoModel.boundingBoxMax.y &&
-                                          localPlayer.z >= wmoModel.boundingBoxMin.z && localPlayer.z <= wmoModel.boundingBoxMax.z;
-                            LOG_WARNING("  Player inside MOHD bbox: ", inside ? "YES" : "NO");
-                        }
-
-                        // Load doodads from the specified doodad set
-                        auto* m2Renderer = renderer_->getM2Renderer();
-                        if (m2Renderer && !wmoModel.doodadSets.empty() && !wmoModel.doodads.empty()) {
-                            uint32_t setIdx = std::min(static_cast<uint32_t>(wdtInfo.doodadSet),
-                                                       static_cast<uint32_t>(wmoModel.doodadSets.size() - 1));
-                            const auto& doodadSet = wmoModel.doodadSets[setIdx];
-
-                            showProgress("Loading instance doodads...", 0.75f);
-                            glm::mat4 wmoMatrix(1.0f);
-                            wmoMatrix = glm::translate(wmoMatrix, wmoPos);
-                            wmoMatrix = glm::rotate(wmoMatrix, wmoRot.z, glm::vec3(0, 0, 1));
-                            wmoMatrix = glm::rotate(wmoMatrix, wmoRot.y, glm::vec3(0, 1, 0));
-                            wmoMatrix = glm::rotate(wmoMatrix, wmoRot.x, glm::vec3(1, 0, 0));
-
-                            uint32_t loadedDoodads = 0;
-                            for (uint32_t di = 0; di < doodadSet.count; di++) {
-                                uint32_t doodadIdx = doodadSet.startIndex + di;
-                                if (doodadIdx >= wmoModel.doodads.size()) break;
-
-                                const auto& doodad = wmoModel.doodads[doodadIdx];
-                                auto nameIt = wmoModel.doodadNames.find(doodad.nameIndex);
-                                if (nameIt == wmoModel.doodadNames.end()) continue;
-
-                                std::string m2Path = nameIt->second;
-                                if (m2Path.empty()) continue;
-
-                                if (m2Path.size() > 4) {
-                                    std::string ext = m2Path.substr(m2Path.size() - 4);
-                                    for (char& c : ext) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                                    if (ext == ".mdx" || ext == ".mdl") {
-                                        m2Path = m2Path.substr(0, m2Path.size() - 4) + ".m2";
-                                    }
-                                }
-
-                                std::vector<uint8_t> m2Data = assetManager_->readFile(m2Path);
-                                if (m2Data.empty()) continue;
-
-                                pipeline::M2Model m2Model = pipeline::M2Loader::load(m2Data);
-                                if (m2Model.name.empty()) m2Model.name = m2Path;
-
-                                std::string skinPath = m2Path.substr(0, m2Path.size() - 3) + "00.skin";
-                                std::vector<uint8_t> skinData = assetManager_->readFile(skinPath);
-                                if (!skinData.empty() && m2Model.version >= 264) {
-                                    pipeline::M2Loader::loadSkin(skinData, m2Model);
-                                }
-                                if (!m2Model.isValid()) continue;
-
-                                glm::quat fixedRotation(doodad.rotation.w, doodad.rotation.x,
-                                                        doodad.rotation.y, doodad.rotation.z);
-                                glm::mat4 doodadLocal(1.0f);
-                                doodadLocal = glm::translate(doodadLocal, doodad.position);
-                                doodadLocal *= glm::mat4_cast(fixedRotation);
-                                doodadLocal = glm::scale(doodadLocal, glm::vec3(doodad.scale));
-
-                                glm::mat4 worldMatrix = wmoMatrix * doodadLocal;
-                                glm::vec3 worldPos = glm::vec3(worldMatrix[3]);
-
-                                uint32_t doodadModelId = static_cast<uint32_t>(std::hash<std::string>{}(m2Path));
-                                if (!m2Renderer->loadModel(m2Model, doodadModelId)) continue;
-                                uint32_t doodadInstId = m2Renderer->createInstanceWithMatrix(doodadModelId, worldMatrix, worldPos);
-                                if (doodadInstId) m2Renderer->setSkipCollision(doodadInstId, true);
-                                loadedDoodads++;
-                            }
-                            LOG_INFO("Loaded ", loadedDoodads, " instance WMO doodads");
-                        }
-                    } else {
-                        LOG_WARNING("Failed to create instance WMO instance");
-                    }
-                } else {
-                    LOG_WARNING("Failed to load instance WMO model");
-                }
-            } else {
-                LOG_WARNING("Failed to read root WMO file: ", wdtInfo.rootWMOPath);
-            }
-
-            // Build collision cache for the instance WMO
-            showProgress("Building collision cache...", 0.88f);
-            if (loadingScreenOk) { loadingScreen.render(); window_->swapBuffers(); }
-            wmoRenderer->loadFloorCache();
-            if (wmoRenderer->getFloorCacheSize() == 0) {
-                showProgress("Computing walkable surfaces...", 0.90f);
-                if (loadingScreenOk) { loadingScreen.render(); window_->swapBuffers(); }
-                wmoRenderer->precomputeFloorCache();
-            }
-        }
-
-        // Snap player to WMO floor so they don't fall through on first frame
-        if (wmoRenderer && renderer_) {
-            glm::vec3 playerPos = renderer_->getCharacterPosition();
-            // Query floor with generous height margin above spawn point
-            auto floor = wmoRenderer->getFloorHeight(playerPos.x, playerPos.y, playerPos.z + 50.0f);
-            if (floor) {
-                playerPos.z = *floor + 0.1f;  // Small offset above floor
-                renderer_->getCharacterPosition() = playerPos;
-                if (gameHandler_) {
-                    glm::vec3 canonical = core::coords::renderToCanonical(playerPos);
-                    gameHandler_->setPosition(canonical.x, canonical.y, canonical.z);
-                }
-                LOG_INFO("Snapped player to instance WMO floor: z=", *floor);
-            } else {
-                LOG_WARNING("Could not find WMO floor at player spawn (",
-                           playerPos.x, ", ", playerPos.y, ", ", playerPos.z, ")");
-            }
-        }
-
-        // Diagnostic: verify WMO renderer state after instance loading
-        LOG_WARNING("=== INSTANCE WMO LOAD COMPLETE ===");
-        LOG_WARNING("  wmoRenderer models loaded: ", wmoRenderer->getLoadedModelCount());
-        LOG_WARNING("  wmoRenderer instances: ", wmoRenderer->getInstanceCount());
-        LOG_WARNING("  wmoRenderer floor cache: ", wmoRenderer->getFloorCacheSize());
-
-        terrainOk = true;  // Mark as OK so post-load setup runs
-    } else {
-        // ---- Normal ADT-based map ----
-        // Compute ADT tile from canonical coordinates
-        auto [tileX, tileY] = core::coords::canonicalToTile(spawnCanonical.x, spawnCanonical.y);
-        std::string adtPath = "World\\Maps\\" + mapName + "\\" + mapName + "_" +
-                              std::to_string(tileX) + "_" + std::to_string(tileY) + ".adt";
-        LOG_INFO("Loading ADT tile [", tileX, ",", tileY, "] from canonical (",
-                 spawnCanonical.x, ", ", spawnCanonical.y, ", ", spawnCanonical.z, ")");
-
-        // Load the initial terrain tile
-        terrainOk = renderer_->loadTestTerrain(assetManager_, adtPath);
-        if (!terrainOk) {
-            LOG_WARNING("Could not load terrain for online world - atmospheric rendering only");
-        } else {
-            LOG_INFO("Online world terrain loading initiated");
-        }
-
-        // Set map name on WMO renderer (initializeRenderers handles terrain/minimap/worldMap)
-        if (renderer_->getWMORenderer()) {
-            renderer_->getWMORenderer()->setMapName(mapName);
-        }
-
-        // Character renderer is created inside loadTestTerrain(), so spawn the
-        // player model now that the renderer actually exists.
-        if (!app_.playerCharacterSpawned) {
-            app_.spawnPlayerCharacter();
-            if (appearanceComposer_) appearanceComposer_->loadEquippedWeapons();
-        }
-
-        showProgress("Streaming terrain tiles...", 0.35f);
-
-        // Wait for surrounding terrain tiles to stream in
-        if (terrainOk && renderer_->getTerrainManager() && renderer_->getCamera()) {
-            auto* terrainMgr = renderer_->getTerrainManager();
-            auto* camera = renderer_->getCamera();
-
-            // Use a small radius for the initial load (just immediate tiles),
-            // then restore the full radius after entering the game.
-            // This matches WoW's behavior: load quickly, stream the rest in-game.
-            const int savedLoadRadius = 6;
-            terrainMgr->setLoadRadius(4);   // 9x9=81 tiles — prevents hitches on spawn
-            terrainMgr->setUnloadRadius(9);
-
-            // Trigger tile streaming for surrounding area
-            terrainMgr->update(*camera, 1.0f);
-
-            auto startTime = std::chrono::high_resolution_clock::now();
-            auto lastProgressTime = startTime;
-            const float maxWaitSeconds = 60.0f;
-            const float stallSeconds = 10.0f;
-            int initialRemaining = terrainMgr->getRemainingTileCount();
-            if (initialRemaining < 1) initialRemaining = 1;
-            int lastRemaining = initialRemaining;
-
-            // Wait until all pending + ready-queue tiles are finalized
-            while (terrainMgr->getRemainingTileCount() > 0) {
-                SDL_Event event;
-                while (SDL_PollEvent(&event)) {
-                    if (event.type == SDL_QUIT) {
-                        window_->setShouldClose(true);
-                        loadingScreen.shutdown();
-                        return;
-                    }
-                    if (event.type == SDL_WINDOWEVENT &&
-                        event.window.event == SDL_WINDOWEVENT_RESIZED) {
-                        int w = event.window.data1;
-                        int h = event.window.data2;
-                        window_->setSize(w, h);
-                        // Vulkan viewport set in command buffer
-                        if (renderer_->getCamera()) {
-                            renderer_->getCamera()->setAspectRatio(static_cast<float>(w) / h);
-                        }
-                    }
-                }
-
-                // Trigger new streaming — enqueue tiles for background workers
-                terrainMgr->update(*camera, 0.016f);
-
-                // Process ONE tile per iteration so the progress bar updates
-                // smoothly between tiles instead of stalling on large batches.
-                terrainMgr->processOneReadyTile();
-
-                int remaining = terrainMgr->getRemainingTileCount();
-                int loaded = terrainMgr->getLoadedTileCount();
-                int total = loaded + remaining;
-                if (total < 1) total = 1;
-                float tileProgress = static_cast<float>(loaded) / static_cast<float>(total);
-                float progress = 0.35f + tileProgress * 0.50f;
-
-                auto now = std::chrono::high_resolution_clock::now();
-                float elapsedSec = std::chrono::duration<float>(now - startTime).count();
-
-                char buf[192];
-                if (loaded > 0 && remaining > 0) {
-                    float tilesPerSec = static_cast<float>(loaded) / std::max(elapsedSec, 0.1f);
-                    float etaSec = static_cast<float>(remaining) / std::max(tilesPerSec, 0.1f);
-                    snprintf(buf, sizeof(buf), "Loading terrain... %d / %d tiles (%.0f tiles/s, ~%.0fs remaining)",
-                             loaded, total, tilesPerSec, etaSec);
-                } else {
-                    snprintf(buf, sizeof(buf), "Loading terrain... %d / %d tiles",
-                             loaded, total);
-                }
-
-                if (loadingScreenOk) {
-                    loadingScreen.setStatus(buf);
-                    loadingScreen.setProgress(progress);
-                    loadingScreen.render();
-                    window_->swapBuffers();
-                }
-
-                if (remaining != lastRemaining) {
-                    lastRemaining = remaining;
-                    lastProgressTime = now;
-                }
-
-                auto elapsed = std::chrono::high_resolution_clock::now() - startTime;
-                if (std::chrono::duration<float>(elapsed).count() > maxWaitSeconds) {
-                    LOG_WARNING("Online terrain streaming timeout after ", maxWaitSeconds, "s");
-                    break;
-                }
-                auto stalledFor = std::chrono::high_resolution_clock::now() - lastProgressTime;
-                if (std::chrono::duration<float>(stalledFor).count() > stallSeconds) {
-                    LOG_WARNING("Online terrain streaming stalled for ", stallSeconds,
-                                "s (remaining=", lastRemaining, "), continuing without full preload");
-                    break;
-                }
-
-                // Don't sleep if there are more tiles to finalize — keep processing
-                if (remaining > 0 && terrainMgr->getReadyQueueCount() == 0) {
-                    SDL_Delay(16);
-                }
-            }
-
-            LOG_INFO("Online terrain streaming complete: ", terrainMgr->getLoadedTileCount(), " tiles loaded");
-
-            // Restore full load radius — remaining tiles stream in-game
-            terrainMgr->setLoadRadius(savedLoadRadius);
-
-            // Load/precompute collision cache
-            if (renderer_->getWMORenderer()) {
-                showProgress("Building collision cache...", 0.88f);
-                if (loadingScreenOk) { loadingScreen.render(); window_->swapBuffers(); }
-                renderer_->getWMORenderer()->loadFloorCache();
-                if (renderer_->getWMORenderer()->getFloorCacheSize() == 0) {
-                    showProgress("Computing walkable surfaces...", 0.90f);
-                    if (loadingScreenOk) { loadingScreen.render(); window_->swapBuffers(); }
-                    renderer_->getWMORenderer()->precomputeFloorCache();
-                }
-            }
-        }
-    }
-
-    // Snap player to loaded terrain so they don't spawn underground
-    if (renderer_->getCameraController()) {
-        renderer_->getCameraController()->reset();
-    }
-
-    // Test transport disabled — real transports come from server via UPDATEFLAG_TRANSPORT
-    showProgress("Finalizing world...", 0.94f);
-    // setupTestTransport();
-
-    // Connect TransportManager to renderers (must happen AFTER initializeRenderers)
-    if (gameHandler_ && gameHandler_->getTransportManager()) {
-        auto* tm = gameHandler_->getTransportManager();
-        if (renderer_->getWMORenderer()) tm->setWMORenderer(renderer_->getWMORenderer());
-        if (renderer_->getM2Renderer()) tm->setM2Renderer(renderer_->getM2Renderer());
-        LOG_WARNING("TransportManager connected: wmoR=", (renderer_->getWMORenderer() ? "yes" : "NULL"),
-                   " m2R=", (renderer_->getM2Renderer() ? "yes" : "NULL"));
-    }
-
-    // Set up NPC animation callbacks (for online creatures)
-    showProgress("Preparing creatures...", 0.97f);
-    if (gameHandler_ && renderer_ && renderer_->getCharacterRenderer()) {
-        auto* cr = renderer_->getCharacterRenderer();
-        auto* spawner = entitySpawner_;
-
-        gameHandler_->setNpcDeathCallback([cr, spawner](uint64_t guid) {
-            spawner->markCreatureDead(guid);
-            uint32_t instanceId = spawner->getCreatureInstanceId(guid);
-            if (instanceId == 0) instanceId = spawner->getPlayerInstanceId(guid);
-            if (instanceId != 0 && cr) {
-                cr->playAnimation(instanceId, rendering::anim::DEATH, false);
-            }
-        });
-
-        gameHandler_->setNpcRespawnCallback([cr, spawner](uint64_t guid) {
-            spawner->unmarkCreatureDead(guid);
-            uint32_t instanceId = spawner->getCreatureInstanceId(guid);
-            if (instanceId == 0) instanceId = spawner->getPlayerInstanceId(guid);
-            if (instanceId != 0 && cr) {
-                cr->playAnimation(instanceId, rendering::anim::STAND, true);
-            }
-        });
-
-        // Probe the creature model for the best available attack animation
-        gameHandler_->setNpcSwingCallback([cr, spawner](uint64_t guid) {
-            uint32_t instanceId = spawner->getCreatureInstanceId(guid);
-            if (instanceId == 0) instanceId = spawner->getPlayerInstanceId(guid);
-            if (instanceId != 0 && cr) {
-                static const uint32_t attackAnims[] = {
-                    rendering::anim::ATTACK_1H,
-                    rendering::anim::ATTACK_2H,
-                    rendering::anim::ATTACK_2H_LOOSE,
-                    rendering::anim::ATTACK_UNARMED
-                };
-                bool played = false;
-                for (uint32_t anim : attackAnims) {
-                    if (cr->hasAnimation(instanceId, anim)) {
-                        cr->playAnimation(instanceId, anim, false);
-                        played = true;
-                        break;
-                    }
-                }
-                if (!played) cr->playAnimation(instanceId, rendering::anim::ATTACK_UNARMED, false);
-            }
-        });
-    }
-
-    // Keep the loading screen visible until all spawn/equipment/gameobject queues
-    // are fully drained. This ensures the player sees a fully populated world
-    // (character clothed, NPCs placed, game objects loaded) when the screen drops.
-    {
-        const float kMinWarmupSeconds = 2.0f;   // minimum time to drain network packets
-        const float kMaxWarmupSeconds = 25.0f;  // hard cap to avoid infinite stall
-        const auto warmupStart = std::chrono::high_resolution_clock::now();
-        // Track consecutive idle iterations (all queues empty) to detect convergence
-        int idleIterations = 0;
-        const int kIdleThreshold = 5;  // require 5 consecutive empty loops (~80ms)
-
-        while (true) {
-            SDL_Event event;
-            while (SDL_PollEvent(&event)) {
-                if (event.type == SDL_QUIT) {
-                    window_->setShouldClose(true);
-                    if (loadingScreenOk) loadingScreen.shutdown();
-                    return;
-                }
-                if (event.type == SDL_WINDOWEVENT &&
-                    event.window.event == SDL_WINDOWEVENT_RESIZED) {
-                    int w = event.window.data1;
-                    int h = event.window.data2;
-                    window_->setSize(w, h);
-                    if (renderer_ && renderer_->getCamera()) {
-                        renderer_->getCamera()->setAspectRatio(static_cast<float>(w) / h);
-                    }
-                }
-            }
-
-            // Drain network and process deferred spawn/composite queues while hidden.
-            if (gameHandler_) gameHandler_->update(1.0f / 60.0f);
-
-            // If a new world entry was deferred during packet processing,
-            // stop warming up this map — we'll load the new one after cleanup.
-            if (pendingWorldEntry_) {
-                LOG_WARNING("loadOnlineWorldTerrain(map ", mapId,
-                            ") — deferred world entry pending, stopping warmup");
-                break;
-            }
-
-            if (world_) world_->update(1.0f / 60.0f);
-
-            // Process all spawn/equipment/transport queues during warmup
-            entitySpawner_->update();
-            if (auto* cr = renderer_ ? renderer_->getCharacterRenderer() : nullptr) {
-                cr->processPendingNormalMaps(4);
-            }
-            app_.updateQuestMarkers();
-
-            // Update renderer (terrain streaming, animations)
-            if (renderer_) {
-                renderer_->update(1.0f / 60.0f);
-            }
-
-            const auto now = std::chrono::high_resolution_clock::now();
-            const float elapsed = std::chrono::duration<float>(now - warmupStart).count();
-
-            // Check if all queues are drained
-            bool queuesEmpty = !entitySpawner_->hasWorkPending();
-
-            if (queuesEmpty) {
-                idleIterations++;
-            } else {
-                idleIterations = 0;
-            }
-
-            // Don't exit warmup until the ground under the player exists.
-            // In cities like Stormwind, players stand on WMO floors, not terrain.
-            // Check BOTH terrain AND WMO floor — require at least one to be valid.
-            bool groundReady = false;
-            if (renderer_) {
-                glm::vec3 renderSpawn = core::coords::canonicalToRender(
-                    glm::vec3(x, y, z));
-                float rx = renderSpawn.x, ry = renderSpawn.y, rz = renderSpawn.z;
-
-                // Check WMO floor FIRST (cities like Stormwind stand on WMO floors).
-                // Terrain exists below WMOs but at the wrong height.
-                if (auto* wmo = renderer_->getWMORenderer()) {
-                    auto wmoH = wmo->getFloorHeight(rx, ry, rz + 5.0f);
-                    if (wmoH.has_value() && std::abs(*wmoH - rz) < 15.0f) {
-                        groundReady = true;
-                    }
-                }
-                // Check terrain — but only if it's close to spawn Z (within 15 units).
-                // Terrain far below a WMO city doesn't count as ground.
-                if (!groundReady) {
-                    if (auto* tm = renderer_->getTerrainManager()) {
-                        auto tH = tm->getHeightAt(rx, ry);
-                        if (tH.has_value() && std::abs(*tH - rz) < 15.0f) {
-                            groundReady = true;
-                        }
-                    }
-                }
-                // After 5s with enough tiles loaded, accept terrain as ready even if
-                // the height sample doesn't match spawn Z exactly. This handles cases
-                // where getHeightAt returns a slightly different value than the server's
-                // spawn Z (e.g. terrain LOD, MCNK chunk boundaries, or spawn inside a
-                // building where floor height differs from terrain below).
-                if (!groundReady && elapsed >= 5.0f) {
-                    if (auto* tm = renderer_->getTerrainManager()) {
-                        if (tm->getLoadedTileCount() >= 4) {
-                            groundReady = true;
-                            LOG_WARNING("Warmup: using tile-count fallback (", tm->getLoadedTileCount(), " tiles) after ", elapsed, "s");
-                        }
-                    }
-                }
-
-                if (!groundReady && elapsed > 5.0f && static_cast<int>(elapsed * 2) % 3 == 0) {
-                    LOG_WARNING("Warmup: ground not ready at spawn (", rx, ",", ry, ",", rz,
-                                ") after ", elapsed, "s");
-                }
-            }
-
-            // Exit when: (min time passed AND queues drained AND ground ready) OR hard cap
-            bool readyToExit = (elapsed >= kMinWarmupSeconds && idleIterations >= kIdleThreshold && groundReady);
-            if (readyToExit || elapsed >= kMaxWarmupSeconds) {
-                if (elapsed >= kMaxWarmupSeconds && !groundReady) {
-                    LOG_WARNING("Warmup hit hard cap (", kMaxWarmupSeconds, "s), ground NOT ready — may fall through world");
-                } else if (elapsed >= kMaxWarmupSeconds) {
-                    LOG_WARNING("Warmup hit hard cap (", kMaxWarmupSeconds, "s), entering world with pending work");
-                }
-                break;
-            }
-
-            const float t = std::clamp(elapsed / kMaxWarmupSeconds, 0.0f, 1.0f);
-            showProgress("Finalizing world sync...", 0.97f + t * 0.025f);
-            SDL_Delay(16);
-        }
-    }
-
-    // Start intro pan right before entering gameplay so it's visible after loading.
-    if (renderer_->getCameraController()) {
-        renderer_->getCameraController()->startIntroPan(2.8f, 140.0f);
-    }
-
-    showProgress("Entering world...", 1.0f);
-
-    // Ensure all GPU resources (textures, buffers, pipelines) created during
-    // world load are fully flushed before the first render frame. Without this,
-    // vkCmdBeginRenderPass can crash on NVIDIA 590.x when resources from async
-    // uploads haven't completed their queue operations.
-    if (renderer_ && renderer_->getVkContext()) {
-        vkDeviceWaitIdle(renderer_->getVkContext()->getDevice());
-    }
-
-    if (loadingScreenOk) {
-        loadingScreen.shutdown();
-    }
-
-    // Track which map we actually loaded (used by same-map teleport check).
-    loadedMapId_ = mapId;
-
-    // Clear loading flag and process any deferred world entry.
-    // A deferred entry occurs when SMSG_NEW_WORLD arrived during our warmup
-    // (e.g., an area trigger in a dungeon immediately teleporting the player out).
-    loadingWorld_ = false;
-    if (pendingWorldEntry_) {
-        auto entry = *pendingWorldEntry_;
-        pendingWorldEntry_.reset();
-        LOG_WARNING("Processing deferred world entry: map ", entry.mapId);
-        app_.worldEntryMovementGraceTimer_ = 2.0f;
-        app_.taxiLandingClampTimer_ = 0.0f;
-        app_.lastTaxiFlight_ = false;
-        // Recursive call — sets loadedMapId_ and IN_GAME state for the final map.
-        loadOnlineWorldTerrain(entry.mapId, entry.x, entry.y, entry.z);
-        return;  // The recursive call handles setState(IN_GAME).
-    }
-
-    // Only enter IN_GAME when this is the final map (no deferred entry pending).
-    app_.setState(AppState::IN_GAME);
-
-    // Load addons once per session on first world entry
-    if (addonManager_ && !app_.addonsLoaded_) {
-        // Set character name for per-character SavedVariables
-        if (gameHandler_) {
-            const std::string& charName = gameHandler_->lookupName(gameHandler_->getPlayerGuid());
-            if (!charName.empty()) {
-                addonManager_->setCharacterName(charName);
-            } else {
-                // Fallback: find name from character list
-                for (const auto& c : gameHandler_->getCharacters()) {
-                    if (c.guid == gameHandler_->getPlayerGuid()) {
-                        addonManager_->setCharacterName(c.name);
-                        break;
-                    }
-                }
-            }
-        }
-        addonManager_->loadAllAddons();
-        app_.addonsLoaded_ = true;
-        addonManager_->fireEvent("VARIABLES_LOADED");
-        addonManager_->fireEvent("PLAYER_LOGIN");
-        addonManager_->fireEvent("PLAYER_ENTERING_WORLD");
-    } else if (addonManager_ && app_.addonsLoaded_) {
-        // Subsequent world entries (e.g. teleport, instance entry)
-        addonManager_->fireEvent("PLAYER_ENTERING_WORLD");
-    }
-}
-
-void WorldLoader::startWorldPreload(uint32_t mapId, const std::string& mapName,
-                                     float serverX, float serverY) {
-    cancelWorldPreload();
-    if (!assetManager_ || !assetManager_->isInitialized() || mapName.empty()) return;
-
-    glm::vec3 canonical = core::coords::serverToCanonical(glm::vec3(serverX, serverY, 0.0f));
-    auto [tileX, tileY] = core::coords::canonicalToTile(canonical.x, canonical.y);
-
-    worldPreload_ = std::make_unique<WorldPreload>();
-    worldPreload_->mapId = mapId;
-    worldPreload_->mapName = mapName;
-    worldPreload_->centerTileX = tileX;
-    worldPreload_->centerTileY = tileY;
-
-    LOG_INFO("World preload: starting for map '", mapName, "' tile [", tileX, ",", tileY, "]");
-
-    // Build list of tiles to preload (radius 1 = 3x3 = 9 tiles, matching load screen)
-    struct TileJob { int x, y; };
-    auto jobs = std::make_shared<std::vector<TileJob>>();
-    // Center tile first (most important)
-    jobs->push_back({tileX, tileY});
-    for (int dx = -1; dx <= 1; dx++) {
-        for (int dy = -1; dy <= 1; dy++) {
-            if (dx == 0 && dy == 0) continue;
-            int tx = tileX + dx, ty = tileY + dy;
-            if (tx < 0 || tx > 63 || ty < 0 || ty > 63) continue;
-            jobs->push_back({tx, ty});
-        }
-    }
-
-    // Spawn worker threads (one per tile for maximum parallelism)
-    auto cancelFlag = &worldPreload_->cancel;
-    auto* am = assetManager_;
-    std::string mn = mapName;
-
-    int numWorkers = std::min(static_cast<int>(jobs->size()), 4);
-    auto nextJob = std::make_shared<std::atomic<int>>(0);
-
-    for (int w = 0; w < numWorkers; w++) {
-        worldPreload_->workers.emplace_back([am, mn, jobs, nextJob, cancelFlag]() {
-            while (!cancelFlag->load(std::memory_order_relaxed)) {
-                int idx = nextJob->fetch_add(1, std::memory_order_relaxed);
-                if (idx >= static_cast<int>(jobs->size())) break;
-
-                int tx = (*jobs)[idx].x;
-                int ty = (*jobs)[idx].y;
-
-                // Read ADT file (warms file cache)
-                std::string adtPath = "World\\Maps\\" + mn + "\\" + mn + "_" +
-                                      std::to_string(tx) + "_" + std::to_string(ty) + ".adt";
-                am->readFile(adtPath);
-                if (cancelFlag->load(std::memory_order_relaxed)) break;
-
-                // Read obj0 variant
-                std::string objPath = "World\\Maps\\" + mn + "\\" + mn + "_" +
-                                      std::to_string(tx) + "_" + std::to_string(ty) + "_obj0.adt";
-                am->readFile(objPath);
-            }
-            LOG_DEBUG("World preload worker finished");
-        });
-    }
-}
-
-void WorldLoader::cancelWorldPreload() {
-    if (!worldPreload_) return;
-    worldPreload_->cancel.store(true, std::memory_order_relaxed);
-    for (auto& t : worldPreload_->workers) {
-        if (t.joinable()) t.join();
-    }
-    LOG_INFO("World preload: cancelled (map=", worldPreload_->mapName,
-             " tile=[", worldPreload_->centerTileX, ",", worldPreload_->centerTileY, "])");
-    worldPreload_.reset();
-}
-
-void WorldLoader::saveLastWorldInfo(uint32_t mapId, const std::string& mapName,
-                                     float serverX, float serverY) {
-#ifdef _WIN32
-    const char* base = std::getenv("APPDATA");
-    std::string dir = base ? std::string(base) + "\\wowee" : ".";
-#else
-    const char* home = std::getenv("HOME");
-    std::string dir = home ? std::string(home) + "/.wowee" : ".";
-#endif
-    std::filesystem::create_directories(dir);
-    std::ofstream f(dir + "/last_world.cfg");
-    if (f) {
-        f << mapId << "\n" << mapName << "\n" << serverX << "\n" << serverY << "\n";
-    }
-}
-
-WorldLoader::LastWorldInfo WorldLoader::loadLastWorldInfo() const {
-#ifdef _WIN32
-    const char* base = std::getenv("APPDATA");
-    std::string dir = base ? std::string(base) + "\\wowee" : ".";
-#else
-    const char* home = std::getenv("HOME");
-    std::string dir = home ? std::string(home) + "/.wowee" : ".";
-#endif
-    LastWorldInfo info;
-    std::ifstream f(dir + "/last_world.cfg");
-    if (!f) return info;
-    std::string line;
-    try {
-        if (std::getline(f, line)) info.mapId = static_cast<uint32_t>(std::stoul(line));
-        if (std::getline(f, line)) info.mapName = line;
-        if (std::getline(f, line)) info.x = std::stof(line);
-        if (std::getline(f, line)) info.y = std::stof(line);
-    } catch (...) {
-        LOG_WARNING("Malformed last_world.cfg, ignoring saved position");
-        return info;
-    }
-    info.valid = !info.mapName.empty();
-    return info;
-}
-
-} // namespace core
-} // namespace wowee
diff --git a/src/game/chat_handler.cpp b/src/game/chat_handler.cpp
deleted file mode 100644
index 5dfc2fd5..00000000
--- a/src/game/chat_handler.cpp
+++ /dev/null
@@ -1,794 +0,0 @@
-#include "game/chat_handler.hpp"
-#include "game/game_handler.hpp"
-#include "game/game_utils.hpp"
-#include "game/packet_parsers.hpp"
-#include "game/entity.hpp"
-#include "game/opcode_table.hpp"
-#include "network/world_socket.hpp"
-#include "rendering/renderer.hpp"
-#include "core/logger.hpp"
-#include <algorithm>
-
-namespace wowee {
-namespace game {
-
-ChatHandler::ChatHandler(GameHandler& owner)
-    : owner_(owner) {}
-
-void ChatHandler::registerOpcodes(DispatchTable& table) {
-    table[Opcode::SMSG_MESSAGECHAT] = [this](network::Packet& packet) {
-        if (owner_.getState() == WorldState::IN_WORLD) handleMessageChat(packet);
-    };
-    table[Opcode::SMSG_GM_MESSAGECHAT] = [this](network::Packet& packet) {
-        if (owner_.getState() != WorldState::IN_WORLD) return;
-        // SMSG_GM_MESSAGECHAT has the same header as SMSG_MESSAGECHAT
-        // (type[1]+lang[4]+senderGuid[8]+unk[4] = 17 bytes) followed by an
-        // extra gmNameLen[4]+gmName[N] before the type-specific body.
-        // Strip the GM name field to produce standard SMSG_MESSAGECHAT format.
-        if (!packet.hasRemaining(21)) return; // 17 header + 4 gmNameLen min
-        uint8_t  type       = packet.readUInt8();
-        uint32_t lang       = packet.readUInt32();
-        uint64_t senderGuid = packet.readUInt64();
-        uint32_t unk        = packet.readUInt32();
-        uint32_t gmNameLen  = packet.readUInt32();
-        if (!packet.hasRemaining(gmNameLen)) return;
-        packet.setReadPos(packet.getReadPos() + gmNameLen); // skip gmName
-
-        // Rebuild as regular SMSG_MESSAGECHAT (header + remaining body)
-        network::Packet regular(0);
-        regular.writeUInt8(type);
-        regular.writeUInt32(lang);
-        regular.writeUInt64(senderGuid);
-        regular.writeUInt32(unk);
-        const auto& raw = packet.getData();
-        size_t pos = packet.getReadPos();
-        if (pos < raw.size())
-            regular.writeBytes(raw.data() + pos, raw.size() - pos);
-        handleMessageChat(regular);
-    };
-    table[Opcode::SMSG_TEXT_EMOTE] = [this](network::Packet& packet) {
-        if (owner_.getState() == WorldState::IN_WORLD) handleTextEmote(packet);
-    };
-    table[Opcode::SMSG_EMOTE] = [this](network::Packet& packet) {
-        if (owner_.getState() != WorldState::IN_WORLD) return;
-        if (!packet.hasRemaining(12)) return;
-        uint32_t emoteAnim  = packet.readUInt32();
-        uint64_t sourceGuid = packet.readUInt64();
-        if (owner_.emoteAnimCallback_ && sourceGuid != 0)
-            owner_.emoteAnimCallback_(sourceGuid, emoteAnim);
-    };
-    table[Opcode::SMSG_CHANNEL_NOTIFY] = [this](network::Packet& packet) {
-        if (owner_.getState() == WorldState::IN_WORLD ||
-            owner_.getState() == WorldState::ENTERING_WORLD)
-            handleChannelNotify(packet);
-    };
-    table[Opcode::SMSG_CHAT_PLAYER_NOT_FOUND] = [this](network::Packet& packet) {
-        std::string name = packet.readString();
-        if (!name.empty()) addSystemChatMessage("No player named '" + name + "' is currently playing.");
-    };
-    table[Opcode::SMSG_CHAT_PLAYER_AMBIGUOUS] = [this](network::Packet& packet) {
-        std::string name = packet.readString();
-        if (!name.empty()) addSystemChatMessage("Player name '" + name + "' is ambiguous.");
-    };
-    table[Opcode::SMSG_CHAT_WRONG_FACTION] = [this](network::Packet& /*packet*/) {
-        owner_.addUIError("You cannot send messages to members of that faction.");
-        addSystemChatMessage("You cannot send messages to members of that faction.");
-    };
-    table[Opcode::SMSG_CHAT_NOT_IN_PARTY] = [this](network::Packet& /*packet*/) {
-        owner_.addUIError("You are not in a party.");
-        addSystemChatMessage("You are not in a party.");
-    };
-    table[Opcode::SMSG_CHAT_RESTRICTED] = [this](network::Packet& /*packet*/) {
-        owner_.addUIError("You cannot send chat messages in this area.");
-        addSystemChatMessage("You cannot send chat messages in this area.");
-    };
-
-    // ---- Channel list ----
-
-    // ---- Server / defense / area-trigger messages (moved from GameHandler) ----
-    table[Opcode::SMSG_DEFENSE_MESSAGE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(5)) {
-            /*uint32_t zoneId =*/ packet.readUInt32();
-            std::string defMsg = packet.readString();
-            if (!defMsg.empty()) addSystemChatMessage("[Defense] " + defMsg);
-        }
-    };
-    // Server messages
-    table[Opcode::SMSG_SERVER_MESSAGE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t msgType = packet.readUInt32();
-            std::string msg = packet.readString();
-            if (!msg.empty()) {
-                std::string prefix;
-                switch (msgType) {
-                    case 1: prefix = "[Shutdown] ";   owner_.addUIError("Server shutdown: " + msg);  break;
-                    case 2: prefix = "[Restart] ";    owner_.addUIError("Server restart: " + msg);   break;
-                    case 4: prefix = "[Shutdown cancelled] "; break;
-                    case 5: prefix = "[Restart cancelled] ";  break;
-                    default: prefix = "[Server] "; break;
-                }
-                addSystemChatMessage(prefix + msg);
-            }
-        }
-    };
-    table[Opcode::SMSG_CHAT_SERVER_MESSAGE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            /*uint32_t msgType =*/ packet.readUInt32();
-            std::string msg = packet.readString();
-            if (!msg.empty()) addSystemChatMessage("[Announcement] " + msg);
-        }
-    };
-    table[Opcode::SMSG_AREA_TRIGGER_MESSAGE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            /*uint32_t len =*/ packet.readUInt32();
-            std::string msg = packet.readString();
-            if (!msg.empty()) {
-                owner_.addUIError(msg);
-                addSystemChatMessage(msg);
-                owner_.areaTriggerMsgs_.push_back(msg);
-            }
-        }
-    };
-
-    table[Opcode::SMSG_CHANNEL_LIST] = [this](network::Packet& p) { handleChannelList(p); };
-}
-
-void ChatHandler::sendChatMessage(ChatType type, const std::string& message, const std::string& target) {
-    if (owner_.getState() != WorldState::IN_WORLD) {
-        LOG_WARNING("Cannot send chat in state: ", static_cast<int>(owner_.getState()));
-        return;
-    }
-
-    if (message.empty()) {
-        LOG_WARNING("Cannot send empty chat message");
-        return;
-    }
-
-    LOG_INFO("OUTGOING CHAT: type=", static_cast<int>(type),
-             " (", getChatTypeString(type), ") target='", target, "' msg='", message.substr(0, 60), "'");
-
-    // Use the player's faction language. AzerothCore rejects wrong language.
-    // Alliance races: Human(1), Dwarf(3), NightElf(4), Gnome(7), Draenei(11) → COMMON (7)
-    // Horde races: Orc(2), Undead(5), Tauren(6), Troll(8), BloodElf(10) → ORCISH (1)
-    uint8_t race = owner_.getPlayerRace();
-    bool isHorde = (race == 2 || race == 5 || race == 6 || race == 8 || race == 10);
-    ChatLanguage language = isHorde ? ChatLanguage::ORCISH : ChatLanguage::COMMON;
-
-    auto packet = MessageChatPacket::build(type, language, message, target);
-    owner_.socket->send(packet);
-
-    // Add local echo so the player sees their own message immediately
-    MessageChatData echo;
-    echo.senderGuid = owner_.playerGuid;
-    echo.language = language;
-    echo.message = message;
-
-    auto nameIt = owner_.getPlayerNameCache().find(owner_.playerGuid);
-    if (nameIt != owner_.getPlayerNameCache().end()) {
-        echo.senderName = nameIt->second;
-    }
-
-    if (type == ChatType::WHISPER) {
-        echo.type = ChatType::WHISPER_INFORM;
-        echo.senderName = target;
-    } else {
-        echo.type = type;
-    }
-
-    if (type == ChatType::CHANNEL) {
-        echo.channelName = target;
-    }
-
-    addLocalChatMessage(echo);
-}
-
-void ChatHandler::handleMessageChat(network::Packet& packet) {
-    LOG_DEBUG("Handling SMSG_MESSAGECHAT");
-
-    MessageChatData data;
-    if (!owner_.packetParsers_->parseMessageChat(packet, data)) {
-        LOG_WARNING("Failed to parse SMSG_MESSAGECHAT, size=", packet.getSize());
-        return;
-    }
-    LOG_INFO("INCOMING CHAT: type=", static_cast<int>(data.type),
-             " (", getChatTypeString(data.type), ") sender=0x", std::hex, data.senderGuid, std::dec,
-             " '", data.senderName, "' msg='", data.message.substr(0, 60), "'");
-
-    // Skip server echo of our own messages (we already added a local echo)
-    if (data.senderGuid == owner_.playerGuid && data.senderGuid != 0) {
-        if (data.type == ChatType::WHISPER && !data.senderName.empty()) {
-            owner_.lastWhisperSender_ = data.senderName;
-        }
-        return;
-    }
-
-    // Resolve sender name from entity/cache if not already set by parser
-    if (data.senderName.empty() && data.senderGuid != 0) {
-        auto nameIt = owner_.getPlayerNameCache().find(data.senderGuid);
-        if (nameIt != owner_.getPlayerNameCache().end()) {
-            data.senderName = nameIt->second;
-        } else {
-            auto entity = owner_.getEntityManager().getEntity(data.senderGuid);
-            if (entity) {
-                if (entity->getType() == ObjectType::PLAYER) {
-                    auto player = std::dynamic_pointer_cast<Player>(entity);
-                    if (player && !player->getName().empty()) {
-                        data.senderName = player->getName();
-                    }
-                } else if (entity->getType() == ObjectType::UNIT) {
-                    auto unit = std::dynamic_pointer_cast<Unit>(entity);
-                    if (unit && !unit->getName().empty()) {
-                        data.senderName = unit->getName();
-                    }
-                }
-            }
-        }
-
-        if (data.senderName.empty()) {
-            owner_.queryPlayerName(data.senderGuid);
-        }
-    }
-
-    // Filter BG queue announcer spam (server-side module on ChromieCraft/AzerothCore).
-    // Arrives as SAY (type=0) with color codes: |cffff0000[BG Queue Announcer]:|r ...
-    {
-        const auto& msg = data.message;
-        if (msg.find("BG Queue Announcer") != std::string::npos ||
-            msg.find("Queue status") != std::string::npos) {
-            return;
-        }
-    }
-
-    // Filter officer chat if player doesn't have officer chat permission.
-    // Some servers send officer chat to all guild members regardless of rank.
-    // WoW guild right bit 0x40 = GR_RIGHT_OFFCHATSPEAK, 0x80 = GR_RIGHT_OFFCHATLISTEN
-    if (data.type == ChatType::OFFICER) {
-        const auto& roster = owner_.getGuildRoster();
-        uint64_t myGuid = owner_.getPlayerGuid();
-        uint32_t myRankIdx = 0;
-        for (const auto& m : roster.members) {
-            if (m.guid == myGuid) { myRankIdx = m.rankIndex; break; }
-        }
-        if (myRankIdx < roster.ranks.size()) {
-            uint32_t rights = roster.ranks[myRankIdx].rights;
-            if (!(rights & 0x80)) { // GR_RIGHT_OFFCHATLISTEN = 0x80
-                return; // Don't show officer chat to non-officers
-            }
-        }
-    }
-
-    // Filter addon-to-addon whispers (GearScore, DBM, oRA, etc.) from player chat.
-    // These are invisible in the real WoW client.
-    if (data.type == ChatType::WHISPER || data.type == ChatType::WHISPER_INFORM) {
-        const auto& msg = data.message;
-        if (msg.size() >= 3 && (
-            msg.rfind("GS_", 0) == 0 ||          // GearScore
-            msg.rfind("DVNE", 0) == 0 ||          // DBM (DeadlyBossMods)
-            msg.rfind("oRA", 0) == 0 ||            // oRA raid addon
-            msg.rfind("BWVQ", 0) == 0 ||           // BigWigs
-            msg.rfind("AVR", 0) == 0 ||            // AVR (Augmented Virtual Reality)
-            msg.rfind("\t", 0) == 0 ||             // Tab-prefixed addon messages
-            (msg.size() > 4 && static_cast<unsigned char>(msg[0]) > 127))) {  // Binary data
-            return; // Silently discard addon whisper
-        }
-    }
-
-    // Add to chat history
-    chatHistory_.push_back(data);
-    if (chatHistory_.size() > maxChatHistory_) {
-        chatHistory_.erase(chatHistory_.begin());
-    }
-
-    // Track whisper sender for /r command
-    if (data.type == ChatType::WHISPER) {
-        // Always store GUID so getLastWhisperSender() can resolve the name
-        // from the player name cache even if name wasn't available yet
-        if (data.senderGuid != 0)
-            owner_.lastWhisperSenderGuid_ = data.senderGuid;
-        if (!data.senderName.empty())
-            owner_.lastWhisperSender_ = data.senderName;
-
-        if (!data.senderName.empty()) {
-            // Only auto-reply once per sender per AFK/DND session to prevent loops
-            if (owner_.afkStatus_ && afkAutoRepliedSenders_.insert(data.senderName).second) {
-                std::string reply = owner_.afkMessage_.empty() ? "Away from Keyboard" : owner_.afkMessage_;
-                sendChatMessage(ChatType::WHISPER, "<AFK> " + reply, data.senderName);
-            } else if (owner_.dndStatus_ && afkAutoRepliedSenders_.insert(data.senderName).second) {
-                std::string reply = owner_.dndMessage_.empty() ? "Do Not Disturb" : owner_.dndMessage_;
-                sendChatMessage(ChatType::WHISPER, "<DND> " + reply, data.senderName);
-            }
-        }
-    }
-
-    // Trigger chat bubble for SAY/YELL messages from others
-    if (owner_.chatBubbleCallback_ && data.senderGuid != 0) {
-        if (data.type == ChatType::SAY || data.type == ChatType::YELL ||
-            data.type == ChatType::MONSTER_SAY || data.type == ChatType::MONSTER_YELL ||
-            data.type == ChatType::MONSTER_PARTY) {
-            bool isYell = (data.type == ChatType::YELL || data.type == ChatType::MONSTER_YELL);
-            owner_.chatBubbleCallback_(data.senderGuid, data.message, isYell);
-        }
-    }
-
-    // Log the message
-    std::string senderInfo;
-    if (!data.senderName.empty()) {
-        senderInfo = data.senderName;
-    } else if (data.senderGuid != 0) {
-        senderInfo = "Unknown-" + std::to_string(data.senderGuid);
-    } else {
-        senderInfo = "System";
-    }
-
-    std::string channelInfo;
-    if (!data.channelName.empty()) {
-        channelInfo = "[" + data.channelName + "] ";
-    }
-
-    LOG_DEBUG("[", getChatTypeString(data.type), "] ", channelInfo, senderInfo, ": ", data.message);
-
-    // Detect addon messages
-    if (owner_.addonEventCallback_ &&
-        data.type != ChatType::SAY && data.type != ChatType::YELL &&
-        data.type != ChatType::EMOTE && data.type != ChatType::TEXT_EMOTE &&
-        data.type != ChatType::MONSTER_SAY && data.type != ChatType::MONSTER_YELL) {
-        auto tabPos = data.message.find('\t');
-        if (tabPos != std::string::npos && tabPos > 0 && tabPos <= 16 &&
-            tabPos < data.message.size() - 1) {
-            std::string prefix = data.message.substr(0, tabPos);
-            if (prefix.find(' ') == std::string::npos) {
-                std::string body = data.message.substr(tabPos + 1);
-                std::string channel = getChatTypeString(data.type);
-                owner_.addonEventCallback_("CHAT_MSG_ADDON", {prefix, body, channel, data.senderName});
-                return;
-            }
-        }
-    }
-
-    // Fire CHAT_MSG_* addon events
-    if (owner_.addonChatCallback_) owner_.addonChatCallback_(data);
-    if (owner_.addonEventCallback_) {
-        std::string eventName = "CHAT_MSG_";
-        eventName += getChatTypeString(data.type);
-        std::string lang = std::to_string(static_cast<int>(data.language));
-        char guidBuf[32];
-        snprintf(guidBuf, sizeof(guidBuf), "0x%016llX", (unsigned long long)data.senderGuid);
-        owner_.addonEventCallback_(eventName, {
-            data.message,
-            data.senderName,
-            lang,
-            data.channelName,
-            senderInfo,
-            "",
-            "0",
-            "0",
-            "",
-            "0",
-            "0",
-            guidBuf
-        });
-    }
-}
-
-void ChatHandler::sendTextEmote(uint32_t textEmoteId, uint64_t targetGuid) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = TextEmotePacket::build(textEmoteId, targetGuid);
-    owner_.socket->send(packet);
-}
-
-void ChatHandler::handleTextEmote(network::Packet& packet) {
-    const bool legacyFormat = isClassicLikeExpansion() || isActiveExpansion("tbc");
-    TextEmoteData data;
-    if (!TextEmoteParser::parse(packet, data, legacyFormat)) {
-        LOG_WARNING("Failed to parse SMSG_TEXT_EMOTE");
-        return;
-    }
-
-    if (data.senderGuid == owner_.playerGuid && data.senderGuid != 0) {
-        return;
-    }
-
-    std::string senderName;
-    auto nameIt = owner_.getPlayerNameCache().find(data.senderGuid);
-    if (nameIt != owner_.getPlayerNameCache().end()) {
-        senderName = nameIt->second;
-    } else {
-        auto entity = owner_.getEntityManager().getEntity(data.senderGuid);
-        if (entity) {
-            auto unit = std::dynamic_pointer_cast<Unit>(entity);
-            if (unit) senderName = unit->getName();
-        }
-    }
-    if (senderName.empty()) {
-        senderName = "Unknown";
-        owner_.queryPlayerName(data.senderGuid);
-    }
-
-    const std::string* targetPtr = data.targetName.empty() ? nullptr : &data.targetName;
-    std::string emoteText = rendering::Renderer::getEmoteTextByDbcId(data.textEmoteId, senderName, targetPtr);
-    if (emoteText.empty()) {
-        emoteText = data.targetName.empty()
-            ? senderName + " performs an emote."
-            : senderName + " performs an emote at " + data.targetName + ".";
-    }
-
-    MessageChatData chatMsg;
-    chatMsg.type = ChatType::TEXT_EMOTE;
-    chatMsg.language = ChatLanguage::COMMON;
-    chatMsg.senderGuid = data.senderGuid;
-    chatMsg.senderName = senderName;
-    chatMsg.message = emoteText;
-
-    addLocalChatMessage(chatMsg);
-
-    uint32_t animId = rendering::Renderer::getEmoteAnimByDbcId(data.textEmoteId);
-    if (animId != 0 && owner_.emoteAnimCallback_) {
-        owner_.emoteAnimCallback_(data.senderGuid, animId);
-    }
-
-    LOG_INFO("TEXT_EMOTE from ", senderName, " (emoteId=", data.textEmoteId, ", anim=", animId, ")");
-}
-
-void ChatHandler::joinChannel(const std::string& channelName, const std::string& password) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = owner_.packetParsers_
-        ? owner_.packetParsers_->buildJoinChannel(channelName, password)
-        : JoinChannelPacket::build(channelName, password);
-    owner_.socket->send(packet);
-    LOG_INFO("Requesting to join channel: ", channelName);
-}
-
-void ChatHandler::leaveChannel(const std::string& channelName) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = owner_.packetParsers_
-        ? owner_.packetParsers_->buildLeaveChannel(channelName)
-        : LeaveChannelPacket::build(channelName);
-    owner_.socket->send(packet);
-    LOG_INFO("Requesting to leave channel: ", channelName);
-}
-
-std::string ChatHandler::getChannelByIndex(int index) const {
-    if (index < 1 || index > static_cast<int>(joinedChannels_.size())) return "";
-    return joinedChannels_[index - 1];
-}
-
-int ChatHandler::getChannelIndex(const std::string& channelName) const {
-    for (int i = 0; i < static_cast<int>(joinedChannels_.size()); ++i) {
-        if (joinedChannels_[i] == channelName) return i + 1;
-    }
-    return 0;
-}
-
-void ChatHandler::handleChannelNotify(network::Packet& packet) {
-    ChannelNotifyData data;
-    if (!ChannelNotifyParser::parse(packet, data)) {
-        LOG_WARNING("Failed to parse SMSG_CHANNEL_NOTIFY");
-        return;
-    }
-
-    switch (data.notifyType) {
-        case ChannelNotifyType::YOU_JOINED: {
-            if (std::find(joinedChannels_.begin(), joinedChannels_.end(), data.channelName) == joinedChannels_.end()) {
-                joinedChannels_.push_back(data.channelName);
-            }
-            MessageChatData msg;
-            msg.type = ChatType::SYSTEM;
-            msg.message = "Joined channel: " + data.channelName;
-            addLocalChatMessage(msg);
-            LOG_INFO("Joined channel: ", data.channelName);
-            break;
-        }
-        case ChannelNotifyType::YOU_LEFT: {
-            joinedChannels_.erase(
-                std::remove(joinedChannels_.begin(), joinedChannels_.end(), data.channelName),
-                joinedChannels_.end());
-            MessageChatData msg;
-            msg.type = ChatType::SYSTEM;
-            msg.message = "Left channel: " + data.channelName;
-            addLocalChatMessage(msg);
-            LOG_INFO("Left channel: ", data.channelName);
-            break;
-        }
-        case ChannelNotifyType::PLAYER_ALREADY_MEMBER: {
-            // Server confirms we're in this channel but our local list doesn't have it yet —
-            // can happen after reconnect or if the join notification was missed.
-            if (std::find(joinedChannels_.begin(), joinedChannels_.end(), data.channelName) == joinedChannels_.end()) {
-                joinedChannels_.push_back(data.channelName);
-                LOG_INFO("Already in channel: ", data.channelName);
-            }
-            break;
-        }
-        case ChannelNotifyType::NOT_IN_AREA:
-            addSystemChatMessage("You must be in the area to join '" + data.channelName + "'.");
-            LOG_DEBUG("Cannot join channel ", data.channelName, " (not in area)");
-            break;
-        case ChannelNotifyType::WRONG_PASSWORD:
-            addSystemChatMessage("Wrong password for channel '" + data.channelName + "'.");
-            break;
-        case ChannelNotifyType::NOT_MEMBER:
-            addSystemChatMessage("You are not in channel '" + data.channelName + "'.");
-            break;
-        case ChannelNotifyType::NOT_MODERATOR:
-            addSystemChatMessage("You are not a moderator of '" + data.channelName + "'.");
-            break;
-        case ChannelNotifyType::MUTED:
-            addSystemChatMessage("You are muted in channel '" + data.channelName + "'.");
-            break;
-        case ChannelNotifyType::BANNED:
-            addSystemChatMessage("You are banned from channel '" + data.channelName + "'.");
-            break;
-        case ChannelNotifyType::THROTTLED:
-            addSystemChatMessage("Channel '" + data.channelName + "' is throttled. Please wait.");
-            break;
-        case ChannelNotifyType::NOT_IN_LFG:
-            addSystemChatMessage("You must be in a LFG queue to join '" + data.channelName + "'.");
-            break;
-        case ChannelNotifyType::PLAYER_KICKED:
-            addSystemChatMessage("A player was kicked from '" + data.channelName + "'.");
-            break;
-        case ChannelNotifyType::PASSWORD_CHANGED:
-            addSystemChatMessage("Password for '" + data.channelName + "' changed.");
-            break;
-        case ChannelNotifyType::OWNER_CHANGED:
-            addSystemChatMessage("Owner of '" + data.channelName + "' changed.");
-            break;
-        case ChannelNotifyType::NOT_OWNER:
-            addSystemChatMessage("You are not the owner of '" + data.channelName + "'.");
-            break;
-        case ChannelNotifyType::INVALID_NAME:
-            addSystemChatMessage("Invalid channel name '" + data.channelName + "'.");
-            break;
-        case ChannelNotifyType::PLAYER_NOT_FOUND:
-            addSystemChatMessage("Player not found.");
-            break;
-        case ChannelNotifyType::ANNOUNCEMENTS_ON:
-            addSystemChatMessage("Channel '" + data.channelName + "': announcements enabled.");
-            break;
-        case ChannelNotifyType::ANNOUNCEMENTS_OFF:
-            addSystemChatMessage("Channel '" + data.channelName + "': announcements disabled.");
-            break;
-        case ChannelNotifyType::MODERATION_ON:
-            addSystemChatMessage("Channel '" + data.channelName + "' is now moderated.");
-            break;
-        case ChannelNotifyType::MODERATION_OFF:
-            addSystemChatMessage("Channel '" + data.channelName + "' is no longer moderated.");
-            break;
-        case ChannelNotifyType::PLAYER_BANNED:
-            addSystemChatMessage("A player was banned from '" + data.channelName + "'.");
-            break;
-        case ChannelNotifyType::PLAYER_UNBANNED:
-            addSystemChatMessage("A player was unbanned from '" + data.channelName + "'.");
-            break;
-        case ChannelNotifyType::PLAYER_NOT_BANNED:
-            addSystemChatMessage("That player is not banned from '" + data.channelName + "'.");
-            break;
-        case ChannelNotifyType::INVITE:
-            addSystemChatMessage("You have been invited to join channel '" + data.channelName + "'.");
-            break;
-        case ChannelNotifyType::INVITE_WRONG_FACTION:
-        case ChannelNotifyType::WRONG_FACTION:
-            addSystemChatMessage("Wrong faction for channel '" + data.channelName + "'.");
-            break;
-        case ChannelNotifyType::NOT_MODERATED:
-            addSystemChatMessage("Channel '" + data.channelName + "' is not moderated.");
-            break;
-        case ChannelNotifyType::PLAYER_INVITED:
-            addSystemChatMessage("Player invited to channel '" + data.channelName + "'.");
-            break;
-        case ChannelNotifyType::PLAYER_INVITE_BANNED:
-            addSystemChatMessage("That player is banned from '" + data.channelName + "'.");
-            break;
-        default:
-            LOG_DEBUG("Channel notify type ", static_cast<int>(data.notifyType),
-                     " for channel ", data.channelName);
-            break;
-    }
-}
-
-void ChatHandler::autoJoinDefaultChannels() {
-    LOG_INFO("autoJoinDefaultChannels: general=", chatAutoJoin.general,
-             " trade=", chatAutoJoin.trade, " localDefense=", chatAutoJoin.localDefense,
-             " lfg=", chatAutoJoin.lfg, " local=", chatAutoJoin.local);
-    if (chatAutoJoin.general) joinChannel("General");
-    if (chatAutoJoin.trade) joinChannel("Trade");
-    if (chatAutoJoin.localDefense) joinChannel("LocalDefense");
-    if (chatAutoJoin.lfg) joinChannel("LookingForGroup");
-    if (chatAutoJoin.local) joinChannel("Local");
-}
-
-void ChatHandler::addLocalChatMessage(const MessageChatData& msg) {
-    chatHistory_.push_back(msg);
-    if (chatHistory_.size() > maxChatHistory_) {
-        chatHistory_.pop_front();
-    }
-    if (owner_.addonChatCallback_) owner_.addonChatCallback_(msg);
-
-    if (owner_.addonEventCallback_) {
-        std::string eventName = "CHAT_MSG_";
-        eventName += getChatTypeString(msg.type);
-        const Character* ac = owner_.getActiveCharacter();
-        std::string senderName = msg.senderName.empty()
-            ? (ac ? ac->name : std::string{}) : msg.senderName;
-        char guidBuf[32];
-        snprintf(guidBuf, sizeof(guidBuf), "0x%016llX",
-                 (unsigned long long)(msg.senderGuid != 0 ? msg.senderGuid : owner_.playerGuid));
-        owner_.addonEventCallback_(eventName, {
-            msg.message, senderName,
-            std::to_string(static_cast<int>(msg.language)),
-            msg.channelName, senderName, "", "0", "0", "", "0", "0", guidBuf
-        });
-    }
-}
-
-void ChatHandler::addSystemChatMessage(const std::string& message) {
-    if (message.empty()) return;
-    MessageChatData msg;
-    msg.type = ChatType::SYSTEM;
-    msg.language = ChatLanguage::UNIVERSAL;
-    msg.message = message;
-    addLocalChatMessage(msg);
-}
-
-void ChatHandler::toggleAfk(const std::string& message) {
-    owner_.afkStatus_ = !owner_.afkStatus_;
-    owner_.afkMessage_ = message;
-
-    if (owner_.afkStatus_) {
-        if (message.empty()) {
-            addSystemChatMessage("You are now AFK.");
-        } else {
-            addSystemChatMessage("You are now AFK: " + message);
-        }
-        // If DND was active, turn it off
-        if (owner_.dndStatus_) {
-            owner_.dndStatus_ = false;
-            owner_.dndMessage_.clear();
-        }
-    } else {
-        addSystemChatMessage("You are no longer AFK.");
-        owner_.afkMessage_.clear();
-        afkAutoRepliedSenders_.clear();
-    }
-
-    LOG_INFO("AFK status: ", owner_.afkStatus_, ", message: ", message);
-}
-
-void ChatHandler::toggleDnd(const std::string& message) {
-    owner_.dndStatus_ = !owner_.dndStatus_;
-    owner_.dndMessage_ = message;
-
-    if (owner_.dndStatus_) {
-        if (message.empty()) {
-            addSystemChatMessage("You are now DND (Do Not Disturb).");
-        } else {
-            addSystemChatMessage("You are now DND: " + message);
-        }
-        // If AFK was active, turn it off
-        if (owner_.afkStatus_) {
-            owner_.afkStatus_ = false;
-            owner_.afkMessage_.clear();
-        }
-    } else {
-        addSystemChatMessage("You are no longer DND.");
-        owner_.dndMessage_.clear();
-        afkAutoRepliedSenders_.clear();
-    }
-
-    LOG_INFO("DND status: ", owner_.dndStatus_, ", message: ", message);
-}
-
-void ChatHandler::replyToLastWhisper(const std::string& message) {
-    if (!owner_.isInWorld()) {
-        LOG_WARNING("Cannot send whisper: not in world or not connected");
-        return;
-    }
-
-    if (owner_.lastWhisperSender_.empty()) {
-        addSystemChatMessage("No one has whispered you yet.");
-        return;
-    }
-
-    if (message.empty()) {
-        addSystemChatMessage("You must specify a message to send.");
-        return;
-    }
-
-    // Send whisper using the standard message chat function
-    sendChatMessage(ChatType::WHISPER, message, owner_.lastWhisperSender_);
-    LOG_INFO("Replied to ", owner_.lastWhisperSender_, ": ", message);
-}
-
-// ============================================================
-// Moved opcode handlers (from GameHandler::registerOpcodeHandlers)
-// ============================================================
-
-void ChatHandler::handleChannelList(network::Packet& packet) {
-    std::string chanName = packet.readString();
-    if (!packet.hasRemaining(5)) return;
-    /*uint8_t chanFlags =*/ packet.readUInt8();
-    uint32_t memberCount = packet.readUInt32();
-    memberCount = std::min(memberCount, 200u);
-    addSystemChatMessage(chanName + " has " + std::to_string(memberCount) + " member(s):");
-    for (uint32_t i = 0; i < memberCount; ++i) {
-        if (!packet.hasRemaining(9)) break;
-        uint64_t memberGuid = packet.readUInt64();
-        uint8_t memberFlags = packet.readUInt8();
-        std::string name;
-        auto entity = owner_.getEntityManager().getEntity(memberGuid);
-        if (entity) {
-            auto player = std::dynamic_pointer_cast<Player>(entity);
-            if (player && !player->getName().empty()) name = player->getName();
-        }
-        if (name.empty()) name = owner_.lookupName(memberGuid);
-        if (name.empty()) name = "(unknown)";
-        std::string entry = "  " + name;
-        if (memberFlags & 0x01) entry += " [Moderator]";
-        if (memberFlags & 0x02) entry += " [Muted]";
-        addSystemChatMessage(entry);
-    }
-}
-
-// ============================================================
-// Methods moved from GameHandler
-// ============================================================
-
-void ChatHandler::submitGmTicket(const std::string& text) {
-    if (!owner_.isInWorld()) return;
-
-    // CMSG_GMTICKET_CREATE (WotLK 3.3.5a):
-    // string   ticket_text
-    // float[3] position (server coords)
-    // float    facing
-    // uint32   mapId
-    // uint8    need_response (1 = yes)
-    network::Packet pkt(wireOpcode(Opcode::CMSG_GMTICKET_CREATE));
-    pkt.writeString(text);
-    pkt.writeFloat(owner_.movementInfo.x);
-    pkt.writeFloat(owner_.movementInfo.y);
-    pkt.writeFloat(owner_.movementInfo.z);
-    pkt.writeFloat(owner_.movementInfo.orientation);
-    pkt.writeUInt32(owner_.currentMapId_);
-    pkt.writeUInt8(1);  // need_response = yes
-    owner_.socket->send(pkt);
-    LOG_INFO("Submitted GM ticket: '", text, "'");
-}
-
-void ChatHandler::handleMotd(network::Packet& packet) {
-    LOG_INFO("Handling SMSG_MOTD");
-
-    MotdData data;
-    if (!MotdParser::parse(packet, data)) {
-        LOG_WARNING("Failed to parse SMSG_MOTD");
-        return;
-    }
-
-    if (!data.isEmpty()) {
-        LOG_INFO("========================================");
-        LOG_INFO("   MESSAGE OF THE DAY");
-        LOG_INFO("========================================");
-        for (const auto& line : data.lines) {
-            LOG_INFO(line);
-            addSystemChatMessage(std::string("MOTD: ") + line);
-        }
-        // Add a visual separator after MOTD block so subsequent messages don't
-        // appear glued to the last MOTD line.
-        MessageChatData spacer;
-        spacer.type = ChatType::SYSTEM;
-        spacer.language = ChatLanguage::UNIVERSAL;
-        spacer.message = "";
-        addLocalChatMessage(spacer);
-        LOG_INFO("========================================");
-    }
-}
-
-void ChatHandler::handleNotification(network::Packet& packet) {
-    // SMSG_NOTIFICATION: single null-terminated string
-    std::string message = packet.readString();
-    if (!message.empty()) {
-        LOG_INFO("Server notification: ", message);
-        addSystemChatMessage(message);
-    }
-}
-
-} // namespace game
-} // namespace wowee
diff --git a/src/game/combat_handler.cpp b/src/game/combat_handler.cpp
deleted file mode 100644
index 48f0b2fd..00000000
--- a/src/game/combat_handler.cpp
+++ /dev/null
@@ -1,1534 +0,0 @@
-#include "game/combat_handler.hpp"
-#include "game/game_handler.hpp"
-#include "game/game_utils.hpp"
-#include "game/packet_parsers.hpp"
-#include "game/entity.hpp"
-#include "game/update_field_table.hpp"
-#include "game/opcode_table.hpp"
-#include "rendering/renderer.hpp"
-#include "audio/audio_coordinator.hpp"
-#include "audio/combat_sound_manager.hpp"
-#include "audio/activity_sound_manager.hpp"
-#include "core/application.hpp"
-#include "core/logger.hpp"
-#include "network/world_socket.hpp"
-#include <algorithm>
-#include <cmath>
-#include <ctime>
-#include <random>
-
-namespace wowee {
-namespace game {
-
-CombatHandler::CombatHandler(GameHandler& owner)
-    : owner_(owner) {}
-
-void CombatHandler::registerOpcodes(DispatchTable& table) {
-    // ---- Combat clearing ----
-    table[Opcode::SMSG_ATTACKSWING_DEADTARGET] = [this](network::Packet& /*packet*/) {
-        autoAttacking_ = false;
-        autoAttackTarget_ = 0;
-    };
-    table[Opcode::SMSG_THREAT_CLEAR] = [this](network::Packet& /*packet*/) {
-        threatLists_.clear();
-        if (owner_.addonEventCallback_) owner_.addonEventCallback_("UNIT_THREAT_LIST_UPDATE", {});
-    };
-    table[Opcode::SMSG_THREAT_REMOVE] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(1)) return;
-        uint64_t unitGuid   = packet.readPackedGuid();
-        if (!packet.hasRemaining(1)) return;
-        uint64_t victimGuid = packet.readPackedGuid();
-        auto it = threatLists_.find(unitGuid);
-        if (it != threatLists_.end()) {
-            auto& list = it->second;
-            list.erase(std::remove_if(list.begin(), list.end(),
-                [victimGuid](const ThreatEntry& e){ return e.victimGuid == victimGuid; }),
-                list.end());
-            if (list.empty()) threatLists_.erase(it);
-        }
-    };
-    table[Opcode::SMSG_CANCEL_COMBAT] = [this](network::Packet& /*packet*/) {
-        autoAttacking_ = false;
-        autoAttackTarget_ = 0;
-        autoAttackRequested_ = false;
-    };
-
-    // ---- Attack/combat delegates ----
-    table[Opcode::SMSG_ATTACKSTART] = [this](network::Packet& packet) { handleAttackStart(packet); };
-    table[Opcode::SMSG_ATTACKSTOP] = [this](network::Packet& packet) { handleAttackStop(packet); };
-    table[Opcode::SMSG_ATTACKSWING_NOTINRANGE] = [this](network::Packet& /*packet*/) {
-        autoAttackOutOfRange_ = true;
-        if (autoAttackRangeWarnCooldown_ <= 0.0f) {
-            owner_.addSystemChatMessage("Target is too far away.");
-            autoAttackRangeWarnCooldown_ = 1.25f;
-        }
-    };
-    table[Opcode::SMSG_ATTACKSWING_BADFACING] = [this](network::Packet& /*packet*/) {
-        if (autoAttackRequested_ && autoAttackTarget_ != 0) {
-            auto targetEntity = owner_.getEntityManager().getEntity(autoAttackTarget_);
-            if (targetEntity) {
-                float toTargetX = targetEntity->getX() - owner_.movementInfo.x;
-                float toTargetY = targetEntity->getY() - owner_.movementInfo.y;
-                if (std::abs(toTargetX) > 0.01f || std::abs(toTargetY) > 0.01f) {
-                    owner_.movementInfo.orientation = std::atan2(-toTargetY, toTargetX);
-                    owner_.sendMovement(Opcode::MSG_MOVE_SET_FACING);
-                }
-            }
-        }
-    };
-    table[Opcode::SMSG_ATTACKSWING_NOTSTANDING] = [this](network::Packet& /*packet*/) {
-        autoAttackOutOfRange_ = false;
-        autoAttackOutOfRangeTime_ = 0.0f;
-        if (autoAttackRangeWarnCooldown_ <= 0.0f) {
-            owner_.addSystemChatMessage("You need to stand up to fight.");
-            autoAttackRangeWarnCooldown_ = 1.25f;
-        }
-    };
-    table[Opcode::SMSG_ATTACKSWING_CANT_ATTACK] = [this](network::Packet& /*packet*/) {
-        stopAutoAttack();
-        if (autoAttackRangeWarnCooldown_ <= 0.0f) {
-            owner_.addSystemChatMessage("You can't attack that.");
-            autoAttackRangeWarnCooldown_ = 1.25f;
-        }
-    };
-    table[Opcode::SMSG_ATTACKERSTATEUPDATE] = [this](network::Packet& packet) { handleAttackerStateUpdate(packet); };
-    table[Opcode::SMSG_AI_REACTION] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(12)) return;
-        uint64_t guid = packet.readUInt64();
-        uint32_t reaction = packet.readUInt32();
-        if (reaction == 2 && owner_.npcAggroCallback_) {
-            auto entity = owner_.getEntityManager().getEntity(guid);
-            if (entity)
-                owner_.npcAggroCallback_(guid, glm::vec3(entity->getX(), entity->getY(), entity->getZ()));
-        }
-    };
-    table[Opcode::SMSG_SPELLNONMELEEDAMAGELOG] = [this](network::Packet& packet) { handleSpellDamageLog(packet); };
-    table[Opcode::SMSG_SPELLHEALLOG] = [this](network::Packet& packet) { handleSpellHealLog(packet); };
-
-    // ---- Environmental damage ----
-    table[Opcode::SMSG_ENVIRONMENTAL_DAMAGE_LOG] = [this](network::Packet& packet) {
-        // uint64 victimGuid + uint8 envDmgType + uint32 damage + uint32 absorbed + uint32 resisted
-        // envDmgType: 0=Exhausted(fatigue), 1=Drowning, 2=Fall, 3=Lava, 4=Slime, 5=Fire
-        if (!packet.hasRemaining(21)) { packet.skipAll(); return; }
-        uint64_t victimGuid  = packet.readUInt64();
-        uint8_t envType      = packet.readUInt8();
-        uint32_t dmg         = packet.readUInt32();
-        uint32_t envAbs      = packet.readUInt32();
-        uint32_t envRes      = packet.readUInt32();
-        if (victimGuid == owner_.playerGuid) {
-            // Environmental damage: pass envType via powerType field for display differentiation
-            if (dmg > 0)
-                addCombatText(CombatTextEntry::ENVIRONMENTAL, static_cast<int32_t>(dmg), 0, false, envType, 0, victimGuid);
-            if (envAbs > 0)
-                addCombatText(CombatTextEntry::ABSORB, static_cast<int32_t>(envAbs), 0, false, 0, 0, victimGuid);
-            if (envRes > 0)
-                addCombatText(CombatTextEntry::RESIST, static_cast<int32_t>(envRes), 0, false, 0, 0, victimGuid);
-            // Drowning damage → play DROWN one-shot on player
-            if (envType == 1 && dmg > 0 && owner_.emoteAnimCallback_)
-                owner_.emoteAnimCallback_(victimGuid, 131); // anim::DROWN
-        }
-        packet.skipAll();
-    };
-
-    // ---- Threat updates ----
-    for (auto op : {Opcode::SMSG_HIGHEST_THREAT_UPDATE,
-                    Opcode::SMSG_THREAT_UPDATE}) {
-        table[op] = [this](network::Packet& packet) {
-            // Both packets share the same format:
-            // packed_guid (unit) + packed_guid (highest-threat target or target, unused here)
-            // + uint32 count + count × (packed_guid victim + uint32 threat)
-            if (!packet.hasRemaining(1)) return;
-            uint64_t unitGuid = packet.readPackedGuid();
-            if (!packet.hasRemaining(1)) return;
-            (void)packet.readPackedGuid(); // highest-threat / current target
-            if (!packet.hasRemaining(4)) return;
-            uint32_t cnt = packet.readUInt32();
-            if (cnt > 100) { packet.skipAll(); return; } // sanity
-            std::vector<ThreatEntry> list;
-            list.reserve(cnt);
-            for (uint32_t i = 0; i < cnt; ++i) {
-                if (!packet.hasRemaining(1)) return;
-                ThreatEntry entry;
-                entry.victimGuid = packet.readPackedGuid();
-                if (!packet.hasRemaining(4)) return;
-                entry.threat = packet.readUInt32();
-                list.push_back(entry);
-            }
-            // Sort descending by threat so highest is first
-            std::sort(list.begin(), list.end(),
-                [](const ThreatEntry& a, const ThreatEntry& b){ return a.threat > b.threat; });
-            threatLists_[unitGuid] = std::move(list);
-            if (owner_.addonEventCallback_)
-                owner_.addonEventCallback_("UNIT_THREAT_LIST_UPDATE", {});
-        };
-    }
-
-    // ---- Forced faction reactions ----
-    table[Opcode::SMSG_SET_FORCED_REACTIONS] = [this](network::Packet& packet) { handleSetForcedReactions(packet); };
-
-    // ---- Entity delta updates: health / power / combo / PvP / proc ----
-    table[Opcode::SMSG_HEALTH_UPDATE] = [this](network::Packet& p) { handleHealthUpdate(p); };
-    table[Opcode::SMSG_POWER_UPDATE] = [this](network::Packet& p) { handlePowerUpdate(p); };
-    table[Opcode::SMSG_UPDATE_COMBO_POINTS] = [this](network::Packet& p) { handleUpdateComboPoints(p); };
-    table[Opcode::SMSG_PVP_CREDIT] = [this](network::Packet& p) { handlePvpCredit(p); };
-    table[Opcode::SMSG_PROCRESIST] = [this](network::Packet& p) { handleProcResist(p); };
-
-    // SMSG_ENVIRONMENTALDAMAGELOG is an alias for SMSG_ENVIRONMENTAL_DAMAGE_LOG
-    // (registered above at line 108 with envType forwarding). No separate handler needed.
-    table[Opcode::SMSG_SPELLDAMAGESHIELD] = [this](network::Packet& p) { handleSpellDamageShield(p); };
-    table[Opcode::SMSG_SPELLORDAMAGE_IMMUNE] = [this](network::Packet& p) { handleSpellOrDamageImmune(p); };
-    table[Opcode::SMSG_RESISTLOG] = [this](network::Packet& p) { handleResistLog(p); };
-
-    // ---- Pet feedback ----
-    table[Opcode::SMSG_PET_TAME_FAILURE] = [this](network::Packet& p) { handlePetTameFailure(p); };
-    table[Opcode::SMSG_PET_ACTION_FEEDBACK] = [this](network::Packet& p) { handlePetActionFeedback(p); };
-    table[Opcode::SMSG_PET_CAST_FAILED] = [this](network::Packet& p) { handlePetCastFailed(p); };
-    table[Opcode::SMSG_PET_BROKEN] = [this](network::Packet& p) { handlePetBroken(p); };
-    table[Opcode::SMSG_PET_LEARNED_SPELL] = [this](network::Packet& p) { handlePetLearnedSpell(p); };
-    table[Opcode::SMSG_PET_UNLEARNED_SPELL] = [this](network::Packet& p) { handlePetUnlearnedSpell(p); };
-    table[Opcode::SMSG_PET_MODE] = [this](network::Packet& p) { handlePetMode(p); };
-
-    // ---- Resurrect ----
-    table[Opcode::SMSG_RESURRECT_FAILED] = [this](network::Packet& p) { handleResurrectFailed(p); };
-}
-
-// ============================================================
-// Auto-attack
-// ============================================================
-
-void CombatHandler::startAutoAttack(uint64_t targetGuid) {
-    // Can't attack yourself
-    if (targetGuid == owner_.playerGuid) return;
-    if (targetGuid == 0) return;
-
-    // Dismount when entering combat
-    if (owner_.isMounted()) {
-        owner_.dismount();
-    }
-
-    // Client-side melee range gate to avoid starting "swing forever" loops when
-    // target is already clearly out of range.
-    if (auto target = owner_.getEntityManager().getEntity(targetGuid)) {
-        float dx = owner_.movementInfo.x - target->getLatestX();
-        float dy = owner_.movementInfo.y - target->getLatestY();
-        float dz = owner_.movementInfo.z - target->getLatestZ();
-        float dist3d = std::sqrt(dx * dx + dy * dy + dz * dz);
-        if (dist3d > 8.0f) {
-            if (autoAttackRangeWarnCooldown_ <= 0.0f) {
-                owner_.addSystemChatMessage("Target is too far away.");
-                autoAttackRangeWarnCooldown_ = 1.25f;
-            }
-            return;
-        }
-    }
-
-    autoAttackRequested_ = true;
-    autoAttackRetryPending_ = true;
-    // Keep combat animation/state server-authoritative. We only flip autoAttacking
-    // on SMSG_ATTACKSTART where attackerGuid == playerGuid.
-    autoAttacking_ = false;
-    autoAttackTarget_ = targetGuid;
-    autoAttackOutOfRange_ = false;
-    autoAttackOutOfRangeTime_ = 0.0f;
-    autoAttackResendTimer_ = 0.0f;
-    autoAttackFacingSyncTimer_ = 0.0f;
-    if (owner_.state == WorldState::IN_WORLD && owner_.socket) {
-        auto packet = AttackSwingPacket::build(targetGuid);
-        owner_.socket->send(packet);
-    }
-    LOG_INFO("Starting auto-attack on 0x", std::hex, targetGuid, std::dec);
-}
-
-void CombatHandler::stopAutoAttack() {
-    if (!autoAttacking_ && !autoAttackRequested_) return;
-    autoAttackRequested_ = false;
-    autoAttacking_ = false;
-    autoAttackRetryPending_ = false;
-    autoAttackTarget_ = 0;
-    autoAttackOutOfRange_ = false;
-    autoAttackOutOfRangeTime_ = 0.0f;
-    autoAttackResendTimer_ = 0.0f;
-    autoAttackFacingSyncTimer_ = 0.0f;
-    if (owner_.state == WorldState::IN_WORLD && owner_.socket) {
-        auto packet = AttackStopPacket::build();
-        owner_.socket->send(packet);
-    }
-    LOG_INFO("Stopping auto-attack");
-    if (owner_.addonEventCallback_)
-        owner_.addonEventCallback_("PLAYER_LEAVE_COMBAT", {});
-}
-
-// ============================================================
-// Combat text
-// ============================================================
-
-void CombatHandler::addCombatText(CombatTextEntry::Type type, int32_t amount, uint32_t spellId, bool isPlayerSource, uint8_t powerType,
-                                  uint64_t srcGuid, uint64_t dstGuid) {
-    CombatTextEntry entry;
-    entry.type = type;
-    entry.amount = amount;
-    entry.spellId = spellId;
-    entry.age = 0.0f;
-    entry.isPlayerSource = isPlayerSource;
-    entry.powerType = powerType;
-    entry.srcGuid = srcGuid;
-    entry.dstGuid = dstGuid;
-    // Random horizontal stagger so simultaneous hits don't stack vertically
-    static std::mt19937 rng(std::random_device{}());
-    std::uniform_real_distribution<float> dist(-1.0f, 1.0f);
-    entry.xSeed = dist(rng);
-    combatText_.push_back(entry);
-
-    // Persistent combat log — use explicit GUIDs if provided, else fall back to
-    // player/current-target (the old behaviour for events without specific participants).
-    CombatLogEntry log;
-    log.type     = type;
-    log.amount   = amount;
-    log.spellId  = spellId;
-    log.isPlayerSource = isPlayerSource;
-    log.powerType = powerType;
-    log.timestamp = std::time(nullptr);
-    // If the caller provided an explicit destination GUID but left source GUID as 0,
-    // preserve "unknown/no source" (e.g. environmental damage) instead of
-    // backfilling from current target.
-    uint64_t effectiveSrc = (srcGuid != 0) ? srcGuid
-                          : ((dstGuid != 0) ? 0 : (isPlayerSource ? owner_.playerGuid : owner_.targetGuid));
-    uint64_t effectiveDst = (dstGuid != 0) ? dstGuid
-                          : (isPlayerSource ? owner_.targetGuid : owner_.playerGuid);
-    log.sourceName = owner_.lookupName(effectiveSrc);
-    log.targetName = (effectiveDst != 0) ? owner_.lookupName(effectiveDst) : std::string{};
-    if (combatLog_.size() >= MAX_COMBAT_LOG)
-        combatLog_.pop_front();
-    combatLog_.push_back(std::move(log));
-
-    // Fire COMBAT_LOG_EVENT_UNFILTERED for Lua addons
-    // Args: subevent, sourceGUID, sourceName, 0 (sourceFlags), destGUID, destName, 0 (destFlags), spellId, spellName, amount
-    if (owner_.addonEventCallback_) {
-        static const char* kSubevents[] = {
-            "SWING_DAMAGE", "SPELL_DAMAGE", "SPELL_HEAL", "SWING_MISSED", "SWING_MISSED",
-            "SWING_MISSED", "SWING_MISSED", "SWING_MISSED", "SPELL_DAMAGE", "SPELL_HEAL",
-            "SPELL_PERIODIC_DAMAGE", "SPELL_PERIODIC_HEAL", "ENVIRONMENTAL_DAMAGE",
-            "SPELL_ENERGIZE", "SPELL_DRAIN", "PARTY_KILL", "SPELL_MISSED", "SPELL_ABSORBED",
-            "SPELL_MISSED", "SPELL_MISSED", "SPELL_MISSED", "SPELL_AURA_APPLIED",
-            "SPELL_DISPEL", "SPELL_STOLEN", "SPELL_INTERRUPT", "SPELL_INSTAKILL",
-            "PARTY_KILL", "SWING_DAMAGE", "SWING_DAMAGE"
-        };
-        const char* subevent = (type < sizeof(kSubevents)/sizeof(kSubevents[0]))
-            ? kSubevents[type] : "UNKNOWN";
-        char srcBuf[32], dstBuf[32];
-        snprintf(srcBuf, sizeof(srcBuf), "0x%016llX", (unsigned long long)effectiveSrc);
-        snprintf(dstBuf, sizeof(dstBuf), "0x%016llX", (unsigned long long)effectiveDst);
-        std::string spellName = (spellId != 0) ? owner_.getSpellName(spellId) : std::string{};
-        std::string timestamp = std::to_string(static_cast<double>(std::time(nullptr)));
-        owner_.addonEventCallback_("COMBAT_LOG_EVENT_UNFILTERED", {
-            timestamp, subevent,
-            srcBuf, log.sourceName, "0",
-            dstBuf, log.targetName, "0",
-            std::to_string(spellId), spellName,
-            std::to_string(amount)
-        });
-    }
-}
-
-bool CombatHandler::shouldLogSpellstealAura(uint64_t casterGuid, uint64_t victimGuid, uint32_t spellId) {
-    if (spellId == 0) return false;
-
-    const auto now = std::chrono::steady_clock::now();
-    constexpr auto kRecentWindow = std::chrono::seconds(1);
-    while (!recentSpellstealLogs_.empty() &&
-           now - recentSpellstealLogs_.front().timestamp > kRecentWindow) {
-        recentSpellstealLogs_.pop_front();
-    }
-
-    for (auto it = recentSpellstealLogs_.begin(); it != recentSpellstealLogs_.end(); ++it) {
-        if (it->casterGuid == casterGuid &&
-            it->victimGuid == victimGuid &&
-            it->spellId == spellId) {
-            recentSpellstealLogs_.erase(it);
-            return false;
-        }
-    }
-
-    if (recentSpellstealLogs_.size() >= MAX_RECENT_SPELLSTEAL_LOGS)
-        recentSpellstealLogs_.pop_front();
-    recentSpellstealLogs_.push_back({casterGuid, victimGuid, spellId, now});
-    return true;
-}
-
-void CombatHandler::updateCombatText(float deltaTime) {
-    for (auto& entry : combatText_) {
-        entry.age += deltaTime;
-    }
-    combatText_.erase(
-        std::remove_if(combatText_.begin(), combatText_.end(),
-                       [](const CombatTextEntry& e) { return e.isExpired(); }),
-        combatText_.end());
-}
-
-// ============================================================
-// Packet handlers
-// ============================================================
-
-void CombatHandler::autoTargetAttacker(uint64_t attackerGuid) {
-    if (attackerGuid == 0 || attackerGuid == owner_.playerGuid) return;
-    if (owner_.targetGuid != 0) return;
-    if (!owner_.getEntityManager().hasEntity(attackerGuid)) return;
-    owner_.setTarget(attackerGuid);
-}
-
-void CombatHandler::handleAttackStart(network::Packet& packet) {
-    AttackStartData data;
-    if (!AttackStartParser::parse(packet, data)) return;
-
-    if (data.attackerGuid == owner_.playerGuid) {
-        autoAttackRequested_ = true;
-        autoAttacking_ = true;
-        autoAttackRetryPending_ = false;
-        autoAttackTarget_ = data.victimGuid;
-        if (owner_.addonEventCallback_)
-            owner_.addonEventCallback_("PLAYER_ENTER_COMBAT", {});
-    } else if (data.victimGuid == owner_.playerGuid && data.attackerGuid != 0) {
-        hostileAttackers_.insert(data.attackerGuid);
-        autoTargetAttacker(data.attackerGuid);
-
-        // Play aggro sound when NPC attacks player
-        if (owner_.npcAggroCallback_) {
-            auto entity = owner_.getEntityManager().getEntity(data.attackerGuid);
-            if (entity && entity->getType() == ObjectType::UNIT) {
-                glm::vec3 pos(entity->getX(), entity->getY(), entity->getZ());
-                owner_.npcAggroCallback_(data.attackerGuid, pos);
-            }
-        }
-    }
-
-    // Force both participants to face each other at combat start.
-    // Uses atan2(-dy, dx): canonical orientation convention where the West/Y
-    // component is negated (renderYaw = orientation + 90°, model-forward = render+X).
-    auto attackerEnt = owner_.getEntityManager().getEntity(data.attackerGuid);
-    auto victimEnt   = owner_.getEntityManager().getEntity(data.victimGuid);
-    if (attackerEnt && victimEnt) {
-        float dx = victimEnt->getX() - attackerEnt->getX();
-        float dy = victimEnt->getY() - attackerEnt->getY();
-        if (std::abs(dx) > 0.01f || std::abs(dy) > 0.01f) {
-            attackerEnt->setOrientation(std::atan2(-dy,  dx));   // attacker → victim
-            victimEnt->setOrientation  (std::atan2( dy, -dx));   // victim   → attacker
-        }
-    }
-}
-
-void CombatHandler::handleAttackStop(network::Packet& packet) {
-    AttackStopData data;
-    if (!AttackStopParser::parse(packet, data)) return;
-
-    // Keep intent, but clear server-confirmed active state until ATTACKSTART resumes.
-    if (data.attackerGuid == owner_.playerGuid) {
-        autoAttacking_ = false;
-        autoAttackRetryPending_ = autoAttackRequested_;
-        autoAttackResendTimer_ = 0.0f;
-        LOG_DEBUG("SMSG_ATTACKSTOP received (keeping auto-attack intent)");
-    } else if (data.victimGuid == owner_.playerGuid) {
-        hostileAttackers_.erase(data.attackerGuid);
-    }
-}
-
-void CombatHandler::handleAttackerStateUpdate(network::Packet& packet) {
-    AttackerStateUpdateData data;
-    if (!owner_.packetParsers_->parseAttackerStateUpdate(packet, data)) return;
-
-    bool isPlayerAttacker = (data.attackerGuid == owner_.playerGuid);
-    bool isPlayerTarget = (data.targetGuid == owner_.playerGuid);
-    if (!isPlayerAttacker && !isPlayerTarget) return;  // Not our combat
-
-    if (isPlayerAttacker) {
-        lastMeleeSwingMs_ = static_cast<uint64_t>(
-            std::chrono::duration_cast<std::chrono::milliseconds>(
-                std::chrono::system_clock::now().time_since_epoch()).count());
-        if (owner_.meleeSwingCallback_) owner_.meleeSwingCallback_(0);
-    }
-    if (!isPlayerAttacker && owner_.npcSwingCallback_) {
-        owner_.npcSwingCallback_(data.attackerGuid);
-    }
-
-    if (isPlayerTarget && data.attackerGuid != 0) {
-        hostileAttackers_.insert(data.attackerGuid);
-        autoTargetAttacker(data.attackerGuid);
-    }
-
-    // Play combat sounds via CombatSoundManager + character vocalizations
-    if (auto* ac = owner_.services().audioCoordinator) {
-        if (auto* csm = ac->getCombatSoundManager()) {
-            auto weaponSize = audio::CombatSoundManager::WeaponSize::MEDIUM;
-            if (data.isMiss()) {
-                csm->playWeaponMiss(false);
-            } else if (data.victimState == 1 || data.victimState == 2) {
-                // Dodge/parry — swing whoosh but no impact
-                csm->playWeaponSwing(weaponSize, false);
-            } else {
-                // Hit — swing + flesh impact
-                csm->playWeaponSwing(weaponSize, data.isCrit());
-                csm->playImpact(weaponSize, audio::CombatSoundManager::ImpactType::FLESH, data.isCrit());
-            }
-        }
-        // Character vocalizations
-        if (auto* asm_ = ac->getActivitySoundManager()) {
-            if (isPlayerAttacker && !data.isMiss() && data.victimState != 1 && data.victimState != 2) {
-                asm_->playAttackGrunt();
-            }
-            if (isPlayerTarget && !data.isMiss() && data.victimState != 1 && data.victimState != 2) {
-                asm_->playWound(data.isCrit());
-            }
-        }
-    }
-
-    if (data.isMiss()) {
-        addCombatText(CombatTextEntry::MISS, 0, 0, isPlayerAttacker, 0, data.attackerGuid, data.targetGuid);
-    } else if (data.victimState == 1) {
-        addCombatText(CombatTextEntry::DODGE, 0, 0, isPlayerAttacker, 0, data.attackerGuid, data.targetGuid);
-    } else if (data.victimState == 2) {
-        addCombatText(CombatTextEntry::PARRY, 0, 0, isPlayerAttacker, 0, data.attackerGuid, data.targetGuid);
-    } else if (data.victimState == 4) {
-        // VICTIMSTATE_BLOCKS: show reduced damage and the blocked amount
-        if (data.totalDamage > 0)
-            addCombatText(CombatTextEntry::MELEE_DAMAGE, data.totalDamage, 0, isPlayerAttacker, 0, data.attackerGuid, data.targetGuid);
-        addCombatText(CombatTextEntry::BLOCK, static_cast<int32_t>(data.blocked), 0, isPlayerAttacker, 0, data.attackerGuid, data.targetGuid);
-    } else if (data.victimState == 5) {
-        // VICTIMSTATE_EVADE: NPC evaded (out of combat zone).
-        addCombatText(CombatTextEntry::EVADE, 0, 0, isPlayerAttacker, 0, data.attackerGuid, data.targetGuid);
-    } else if (data.victimState == 6) {
-        // VICTIMSTATE_IS_IMMUNE: Target is immune to this attack.
-        addCombatText(CombatTextEntry::IMMUNE, 0, 0, isPlayerAttacker, 0, data.attackerGuid, data.targetGuid);
-    } else if (data.victimState == 7) {
-        // VICTIMSTATE_DEFLECT: Attack was deflected (e.g. shield slam reflect).
-        addCombatText(CombatTextEntry::DEFLECT, 0, 0, isPlayerAttacker, 0, data.attackerGuid, data.targetGuid);
-    } else {
-        CombatTextEntry::Type type;
-        if (data.isCrit())
-            type = CombatTextEntry::CRIT_DAMAGE;
-        else if (data.isCrushing())
-            type = CombatTextEntry::CRUSHING;
-        else if (data.isGlancing())
-            type = CombatTextEntry::GLANCING;
-        else
-            type = CombatTextEntry::MELEE_DAMAGE;
-        addCombatText(type, data.totalDamage, 0, isPlayerAttacker, 0, data.attackerGuid, data.targetGuid);
-        // Show partial absorb/resist from sub-damage entries
-        uint32_t totalAbsorbed = 0, totalResisted = 0;
-        for (const auto& sub : data.subDamages) {
-            totalAbsorbed += sub.absorbed;
-            totalResisted += sub.resisted;
-        }
-        if (totalAbsorbed > 0)
-            addCombatText(CombatTextEntry::ABSORB, static_cast<int32_t>(totalAbsorbed), 0, isPlayerAttacker, 0, data.attackerGuid, data.targetGuid);
-        if (totalResisted > 0)
-            addCombatText(CombatTextEntry::RESIST, static_cast<int32_t>(totalResisted), 0, isPlayerAttacker, 0, data.attackerGuid, data.targetGuid);
-    }
-
-    // Fire hit reaction animation on the victim
-    if (owner_.hitReactionCallback_ && !data.isMiss()) {
-        using HR = GameHandler::HitReaction;
-        HR reaction = HR::WOUND;
-        if (data.victimState == 1) reaction = HR::DODGE;
-        else if (data.victimState == 2) reaction = HR::PARRY;
-        else if (data.victimState == 4) reaction = HR::BLOCK;
-        else if (data.isCrit()) reaction = HR::CRIT_WOUND;
-        owner_.hitReactionCallback_(data.targetGuid, reaction);
-    }
-
-}
-
-void CombatHandler::handleSpellDamageLog(network::Packet& packet) {
-    SpellDamageLogData data;
-    if (!owner_.packetParsers_->parseSpellDamageLog(packet, data)) return;
-
-    bool isPlayerSource = (data.attackerGuid == owner_.playerGuid);
-    bool isPlayerTarget = (data.targetGuid == owner_.playerGuid);
-    if (!isPlayerSource && !isPlayerTarget) return;  // Not our combat
-
-    if (isPlayerTarget && data.attackerGuid != 0) {
-        hostileAttackers_.insert(data.attackerGuid);
-        autoTargetAttacker(data.attackerGuid);
-    }
-
-    auto type = data.isCrit ? CombatTextEntry::CRIT_DAMAGE : CombatTextEntry::SPELL_DAMAGE;
-    if (data.damage > 0)
-        addCombatText(type, static_cast<int32_t>(data.damage), data.spellId, isPlayerSource, 0, data.attackerGuid, data.targetGuid);
-    if (data.absorbed > 0)
-        addCombatText(CombatTextEntry::ABSORB, static_cast<int32_t>(data.absorbed), data.spellId, isPlayerSource, 0, data.attackerGuid, data.targetGuid);
-    if (data.resisted > 0)
-        addCombatText(CombatTextEntry::RESIST, static_cast<int32_t>(data.resisted), data.spellId, isPlayerSource, 0, data.attackerGuid, data.targetGuid);
-}
-
-void CombatHandler::handleSpellHealLog(network::Packet& packet) {
-    SpellHealLogData data;
-    if (!owner_.packetParsers_->parseSpellHealLog(packet, data)) return;
-
-    bool isPlayerSource = (data.casterGuid == owner_.playerGuid);
-    bool isPlayerTarget = (data.targetGuid == owner_.playerGuid);
-    if (!isPlayerSource && !isPlayerTarget) return;  // Not our combat
-
-    auto type = data.isCrit ? CombatTextEntry::CRIT_HEAL : CombatTextEntry::HEAL;
-    addCombatText(type, static_cast<int32_t>(data.heal), data.spellId, isPlayerSource, 0, data.casterGuid, data.targetGuid);
-    if (data.absorbed > 0)
-        addCombatText(CombatTextEntry::ABSORB, static_cast<int32_t>(data.absorbed), data.spellId, isPlayerSource, 0, data.casterGuid, data.targetGuid);
-}
-
-void CombatHandler::handleSetForcedReactions(network::Packet& packet) {
-    if (!packet.hasRemaining(4)) return;
-    uint32_t count = packet.readUInt32();
-    if (count > 64) {
-        LOG_WARNING("SMSG_SET_FORCED_REACTIONS: suspicious count ", count, ", ignoring");
-        packet.skipAll();
-        return;
-    }
-    forcedReactions_.clear();
-    for (uint32_t i = 0; i < count; ++i) {
-        if (!packet.hasRemaining(8)) break;
-        uint32_t factionId = packet.readUInt32();
-        uint32_t reaction  = packet.readUInt32();
-        forcedReactions_[factionId] = static_cast<uint8_t>(reaction);
-    }
-    LOG_INFO("SMSG_SET_FORCED_REACTIONS: ", forcedReactions_.size(), " faction overrides");
-}
-
-// ============================================================
-// Per-frame update
-// ============================================================
-
-void CombatHandler::updateAutoAttack(float deltaTime) {
-    // Decrement range warn cooldown
-    if (autoAttackRangeWarnCooldown_ > 0.0f) {
-        autoAttackRangeWarnCooldown_ = std::max(0.0f, autoAttackRangeWarnCooldown_ - deltaTime);
-    }
-
-    // Leave combat if auto-attack target is too far away (leash range)
-    // and keep melee intent tightly synced while stationary.
-    if (autoAttackRequested_ && autoAttackTarget_ != 0) {
-        auto targetEntity = owner_.getEntityManager().getEntity(autoAttackTarget_);
-        if (targetEntity) {
-            const float targetX = targetEntity->getLatestX();
-            const float targetY = targetEntity->getLatestY();
-            const float targetZ = targetEntity->getLatestZ();
-            float dx = owner_.movementInfo.x - targetX;
-            float dy = owner_.movementInfo.y - targetY;
-            float dz = owner_.movementInfo.z - targetZ;
-            float dist = std::sqrt(dx * dx + dy * dy);
-            float dist3d = std::sqrt(dx * dx + dy * dy + dz * dz);
-            const bool classicLike = isPreWotlk();
-            if (dist > 40.0f) {
-                stopAutoAttack();
-                LOG_INFO("Left combat: target too far (", dist, " yards)");
-            } else if (owner_.isInWorld()) {
-                bool allowResync = true;
-                const float meleeRange = classicLike ? 5.25f : 5.75f;
-                if (dist3d > meleeRange) {
-                    autoAttackOutOfRange_ = true;
-                    autoAttackOutOfRangeTime_ += deltaTime;
-                    if (autoAttackRangeWarnCooldown_ <= 0.0f) {
-                        owner_.addSystemChatMessage("Target is too far away.");
-                        owner_.addUIError("Target is too far away.");
-                        autoAttackRangeWarnCooldown_ = 1.25f;
-                    }
-                    // Stop chasing stale swings when the target remains out of range.
-                    if (autoAttackOutOfRangeTime_ > 2.0f && dist3d > 9.0f) {
-                        stopAutoAttack();
-                        owner_.addSystemChatMessage("Auto-attack stopped: target out of range.");
-                        allowResync = false;
-                    }
-                } else {
-                    autoAttackOutOfRange_ = false;
-                    autoAttackOutOfRangeTime_ = 0.0f;
-                }
-
-                if (allowResync) {
-                    autoAttackResendTimer_ += deltaTime;
-                    autoAttackFacingSyncTimer_ += deltaTime;
-
-                    // Classic/Turtle servers do not tolerate steady attack-start
-                    // reissues well. Only retry once after local start or an
-                    // explicit server-side attack stop while intent is still set.
-                    const float resendInterval = classicLike ? 1.0f : 0.50f;
-                    if (!autoAttacking_ && !autoAttackOutOfRange_ && autoAttackRetryPending_ &&
-                        autoAttackResendTimer_ >= resendInterval) {
-                        autoAttackResendTimer_ = 0.0f;
-                        autoAttackRetryPending_ = false;
-                        auto pkt = AttackSwingPacket::build(autoAttackTarget_);
-                        owner_.socket->send(pkt);
-                    }
-
-                    // Keep server-facing aligned while trying to acquire melee.
-                    const float facingSyncInterval = classicLike ? 0.25f : 0.20f;
-                    const bool allowPeriodicFacingSync = !classicLike || !autoAttacking_;
-                    if (allowPeriodicFacingSync &&
-                        autoAttackFacingSyncTimer_ >= facingSyncInterval) {
-                        autoAttackFacingSyncTimer_ = 0.0f;
-                        float toTargetX = targetX - owner_.movementInfo.x;
-                        float toTargetY = targetY - owner_.movementInfo.y;
-                        if (std::abs(toTargetX) > 0.01f || std::abs(toTargetY) > 0.01f) {
-                            float desired = std::atan2(-toTargetY, toTargetX);
-                            float diff = desired - owner_.movementInfo.orientation;
-                            while (diff > static_cast<float>(M_PI)) diff -= 2.0f * static_cast<float>(M_PI);
-                            while (diff < -static_cast<float>(M_PI)) diff += 2.0f * static_cast<float>(M_PI);
-                            const float facingThreshold = classicLike ? 0.035f : 0.12f;
-                            if (std::abs(diff) > facingThreshold) {
-                                owner_.movementInfo.orientation = desired;
-                                owner_.sendMovement(Opcode::MSG_MOVE_SET_FACING);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    // Keep active melee attackers visually facing the player as positions change.
-    if (!hostileAttackers_.empty()) {
-        for (uint64_t attackerGuid : hostileAttackers_) {
-            auto attacker = owner_.getEntityManager().getEntity(attackerGuid);
-            if (!attacker) continue;
-            float dx = owner_.movementInfo.x - attacker->getX();
-            float dy = owner_.movementInfo.y - attacker->getY();
-            if (std::abs(dx) < 0.01f && std::abs(dy) < 0.01f) continue;
-            attacker->setOrientation(std::atan2(-dy, dx));
-        }
-    }
-}
-
-// ============================================================
-// State management
-// ============================================================
-
-void CombatHandler::resetAllCombatState() {
-    hostileAttackers_.clear();
-    combatText_.clear();
-    autoAttacking_ = false;
-    autoAttackRequested_ = false;
-    autoAttackRetryPending_ = false;
-    autoAttackTarget_ = 0;
-    autoAttackOutOfRange_ = false;
-    autoAttackOutOfRangeTime_ = 0.0f;
-    autoAttackRangeWarnCooldown_ = 0.0f;
-    autoAttackResendTimer_ = 0.0f;
-    autoAttackFacingSyncTimer_ = 0.0f;
-    lastMeleeSwingMs_ = 0;
-}
-
-void CombatHandler::removeHostileAttacker(uint64_t guid) {
-    hostileAttackers_.erase(guid);
-}
-
-void CombatHandler::clearCombatText() {
-    combatText_.clear();
-}
-
-void CombatHandler::removeCombatTextForGuid(uint64_t guid) {
-    combatText_.erase(
-        std::remove_if(combatText_.begin(), combatText_.end(),
-            [guid](const CombatTextEntry& e) {
-                return e.dstGuid == guid;
-            }),
-        combatText_.end());
-}
-
-// ============================================================
-// Moved opcode handlers (from GameHandler::registerOpcodeHandlers)
-// ============================================================
-
-void CombatHandler::handleHealthUpdate(network::Packet& packet) {
-    const bool huTbc = isActiveExpansion("tbc");
-    if (!packet.hasRemaining(huTbc ? 8u : 2u) ) return;
-    uint64_t guid = huTbc ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(4)) return;
-    uint32_t hp = packet.readUInt32();
-    if (auto* unit = owner_.getUnitByGuid(guid)) unit->setHealth(hp);
-    if (guid != 0) {
-        auto unitId = owner_.guidToUnitId(guid);
-        if (!unitId.empty()) owner_.fireAddonEvent("UNIT_HEALTH", {unitId});
-    }
-}
-
-void CombatHandler::handlePowerUpdate(network::Packet& packet) {
-    const bool puTbc = isActiveExpansion("tbc");
-    if (!packet.hasRemaining(puTbc ? 8u : 2u) ) return;
-    uint64_t guid = puTbc ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(5)) return;
-    uint8_t  powerType = packet.readUInt8();
-    uint32_t value     = packet.readUInt32();
-    if (auto* unit = owner_.getUnitByGuid(guid)) unit->setPowerByType(powerType, value);
-    if (guid != 0) {
-        auto unitId = owner_.guidToUnitId(guid);
-        if (!unitId.empty()) {
-            owner_.fireAddonEvent("UNIT_POWER", {unitId});
-            if (guid == owner_.playerGuid) {
-                owner_.fireAddonEvent("ACTIONBAR_UPDATE_USABLE", {});
-                owner_.fireAddonEvent("SPELL_UPDATE_USABLE", {});
-            }
-        }
-    }
-}
-
-void CombatHandler::handleUpdateComboPoints(network::Packet& packet) {
-    const bool cpTbc = isActiveExpansion("tbc");
-    if (!packet.hasRemaining(cpTbc ? 8u : 2u) ) return;
-    uint64_t target = cpTbc ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(1)) return;
-    owner_.comboPoints_ = packet.readUInt8();
-    owner_.comboTarget_ = target;
-    LOG_DEBUG("SMSG_UPDATE_COMBO_POINTS: target=0x", std::hex, target,
-              std::dec, " points=", static_cast<int>(owner_.comboPoints_));
-    owner_.fireAddonEvent("PLAYER_COMBO_POINTS", {});
-}
-
-void CombatHandler::handlePvpCredit(network::Packet& packet) {
-    if (packet.hasRemaining(16)) {
-        uint32_t honor      = packet.readUInt32();
-        uint64_t victimGuid = packet.readUInt64();
-        uint32_t rank       = packet.readUInt32();
-        LOG_INFO("SMSG_PVP_CREDIT: honor=", honor, " victim=0x", std::hex, victimGuid, std::dec, " rank=", rank);
-        std::string msg = "You gain " + std::to_string(honor) + " honor points.";
-        owner_.addSystemChatMessage(msg);
-        if (honor > 0) addCombatText(CombatTextEntry::HONOR_GAIN, static_cast<int32_t>(honor), 0, true);
-        if (owner_.pvpHonorCallback_) owner_.pvpHonorCallback_(honor, victimGuid, rank);
-        owner_.fireAddonEvent("CHAT_MSG_COMBAT_HONOR_GAIN", {msg});
-    }
-}
-
-void CombatHandler::handleProcResist(network::Packet& packet) {
-    const bool prUsesFullGuid = isActiveExpansion("tbc");
-    auto readPrGuid = [&]() -> uint64_t {
-        if (prUsesFullGuid)
-            return (packet.hasRemaining(8)) ? packet.readUInt64() : 0;
-        return packet.readPackedGuid();
-    };
-    if (!packet.hasRemaining(prUsesFullGuid ? 8u : 1u)             || (!prUsesFullGuid && !packet.hasFullPackedGuid())) { packet.skipAll(); return; }
-    uint64_t caster = readPrGuid();
-    if (!packet.hasRemaining(prUsesFullGuid ? 8u : 1u)             || (!prUsesFullGuid && !packet.hasFullPackedGuid())) { packet.skipAll(); return; }
-    uint64_t victim = readPrGuid();
-    if (!packet.hasRemaining(4)) return;
-    uint32_t spellId = packet.readUInt32();
-    if (victim == owner_.playerGuid)       addCombatText(CombatTextEntry::RESIST, 0, spellId, false, 0, caster, victim);
-    else if (caster == owner_.playerGuid)  addCombatText(CombatTextEntry::RESIST, 0, spellId, true,  0, caster, victim);
-    packet.skipAll();
-}
-
-// ============================================================
-// Environmental / reflect / immune / resist
-// ============================================================
-
-
-void CombatHandler::handleSpellDamageShield(network::Packet& packet) {
-    // Classic: packed_guid victim + packed_guid caster + spellId(4) + damage(4) + schoolMask(4)
-    // TBC:     uint64 victim + uint64 caster + spellId(4) + damage(4) + schoolMask(4)
-    // WotLK:   packed_guid victim + packed_guid caster + spellId(4) + damage(4) + absorbed(4) + schoolMask(4)
-    const bool shieldTbc = isActiveExpansion("tbc");
-    const bool shieldWotlkLike = !isClassicLikeExpansion() && !shieldTbc;
-    const auto shieldRem = [&]() { return packet.getRemainingSize(); };
-    const size_t shieldMinSz = shieldTbc ? 24u : 2u;
-    if (!packet.hasRemaining(shieldMinSz)) {
-        packet.skipAll(); return;
-    }
-    if (!shieldTbc && (!packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t victimGuid = shieldTbc
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(shieldTbc ? 8u : 1u)             || (!shieldTbc && !packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t casterGuid = shieldTbc
-        ? packet.readUInt64() : packet.readPackedGuid();
-    const size_t shieldTailSize = shieldWotlkLike ? 16u : 12u;
-    if (shieldRem() < shieldTailSize) {
-        packet.skipAll(); return;
-    }
-    uint32_t shieldSpellId = packet.readUInt32();
-    uint32_t damage        = packet.readUInt32();
-    if (shieldWotlkLike)
-        /*uint32_t absorbed =*/ packet.readUInt32();
-    /*uint32_t school =*/  packet.readUInt32();
-    // Show combat text: damage shield reflect
-    if (casterGuid == owner_.playerGuid) {
-        // We have a damage shield that reflected damage
-        addCombatText(CombatTextEntry::SPELL_DAMAGE, static_cast<int32_t>(damage), shieldSpellId, true, 0, casterGuid, victimGuid);
-    } else if (victimGuid == owner_.playerGuid) {
-        // A damage shield hit us (e.g. target's Thorns)
-        addCombatText(CombatTextEntry::SPELL_DAMAGE, static_cast<int32_t>(damage), shieldSpellId, false, 0, casterGuid, victimGuid);
-    }
-}
-
-void CombatHandler::handleSpellOrDamageImmune(network::Packet& packet) {
-    // WotLK/Classic/Turtle: packed casterGuid + packed victimGuid + uint32 spellId + uint8 saveType
-    // TBC:                  full uint64 casterGuid + full uint64 victimGuid + uint32 + uint8
-    const bool immuneUsesFullGuid = isActiveExpansion("tbc");
-    const size_t minSz = immuneUsesFullGuid ? 21u : 2u;
-    if (!packet.hasRemaining(minSz)) {
-        packet.skipAll(); return;
-    }
-    if (!immuneUsesFullGuid && !packet.hasFullPackedGuid()) {
-        packet.skipAll(); return;
-    }
-    uint64_t casterGuid = immuneUsesFullGuid
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(immuneUsesFullGuid ? 8u : 2u)             || (!immuneUsesFullGuid && !packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t victimGuid = immuneUsesFullGuid
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(5)) return;
-    uint32_t immuneSpellId = packet.readUInt32();
-    /*uint8_t saveType =*/ packet.readUInt8();
-    // Show IMMUNE text when the player is the caster (we hit an immune target)
-    // or the victim (we are immune)
-    if (casterGuid == owner_.playerGuid || victimGuid == owner_.playerGuid) {
-        addCombatText(CombatTextEntry::IMMUNE, 0, immuneSpellId,
-                      casterGuid == owner_.playerGuid, 0, casterGuid, victimGuid);
-    }
-}
-
-void CombatHandler::handleResistLog(network::Packet& packet) {
-    // WotLK/Classic/Turtle: uint32 hitInfo + packed_guid attacker + packed_guid victim + uint32 spellId
-    //                      + float resistFactor + uint32 targetRes + uint32 resistedValue + ...
-    // TBC:                 same layout but full uint64 GUIDs
-    // Show RESIST combat text when player resists an incoming spell.
-    const bool rlUsesFullGuid = isActiveExpansion("tbc");
-    auto rl_rem = [&]() { return packet.getRemainingSize(); };
-    if (rl_rem() < 4) { packet.skipAll(); return; }
-    /*uint32_t hitInfo =*/ packet.readUInt32();
-    if (rl_rem() < (rlUsesFullGuid ? 8u : 1u)
-        || (!rlUsesFullGuid && !packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t attackerGuid = rlUsesFullGuid
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (rl_rem() < (rlUsesFullGuid ? 8u : 1u)
-        || (!rlUsesFullGuid && !packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t victimGuid = rlUsesFullGuid
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (rl_rem() < 4) { packet.skipAll(); return; }
-    uint32_t spellId = packet.readUInt32();
-    // Resist payload includes:
-    // float resistFactor + uint32 targetResistance + uint32 resistedValue.
-    // Require the full payload so truncated packets cannot synthesize
-    // zero-value resist events.
-    if (rl_rem() < 12) { packet.skipAll(); return; }
-    /*float resistFactor =*/ packet.readFloat();
-    /*uint32_t targetRes =*/ packet.readUInt32();
-    int32_t resistedAmount = static_cast<int32_t>(packet.readUInt32());
-    // Show RESIST when the player is involved on either side.
-    if (resistedAmount > 0 && victimGuid == owner_.playerGuid) {
-        addCombatText(CombatTextEntry::RESIST, resistedAmount, spellId, false, 0, attackerGuid, victimGuid);
-    } else if (resistedAmount > 0 && attackerGuid == owner_.playerGuid) {
-        addCombatText(CombatTextEntry::RESIST, resistedAmount, spellId, true, 0, attackerGuid, victimGuid);
-    }
-    packet.skipAll();
-}
-
-// ============================================================
-// Pet feedback
-// ============================================================
-
-void CombatHandler::handlePetTameFailure(network::Packet& packet) {
-    static const char* reasons[] = {
-        "Invalid creature", "Too many pets", "Already tamed",
-        "Wrong faction", "Level too low", "Creature not tameable",
-        "Can't control", "Can't command"
-    };
-    if (packet.hasRemaining(1)) {
-        uint8_t reason = packet.readUInt8();
-        const char* msg = (reason < 8) ? reasons[reason] : "Unknown reason";
-        std::string s = std::string("Failed to tame: ") + msg;
-        owner_.addUIError(s);
-        owner_.addSystemChatMessage(s);
-    }
-}
-
-void CombatHandler::handlePetActionFeedback(network::Packet& packet) {
-    static const char* kPetFeedback[] = {
-        nullptr,
-        "Your pet is dead.", "Your pet has nothing to attack.",
-        "Your pet cannot attack that target.", "That target is too far away.",
-        "Your pet cannot find a path to the target.",
-        "Your pet cannot attack an immune target.",
-    };
-    if (!packet.hasRemaining(1)) return;
-    uint8_t msg = packet.readUInt8();
-    if (msg > 0 && msg < 7 && kPetFeedback[msg]) owner_.addSystemChatMessage(kPetFeedback[msg]);
-    packet.skipAll();
-}
-
-void CombatHandler::handlePetCastFailed(network::Packet& packet) {
-    // WotLK: castCount(1) + spellId(4) + reason(1)
-    // Classic/TBC: spellId(4) + reason(1) (no castCount)
-    const bool hasCount = isActiveExpansion("wotlk");
-    const size_t minSize = hasCount ? 6u : 5u;
-    if (packet.hasRemaining(minSize)) {
-        if (hasCount) /*uint8_t castCount =*/ packet.readUInt8();
-        uint32_t spellId   = packet.readUInt32();
-        uint8_t  reason    = (packet.hasRemaining(1))
-                                 ? packet.readUInt8() : 0;
-        LOG_DEBUG("SMSG_PET_CAST_FAILED: spell=", spellId,
-                  " reason=", static_cast<int>(reason));
-        if (reason != 0) {
-            const char* reasonStr = getSpellCastResultString(reason);
-            const std::string& sName = owner_.getSpellName(spellId);
-            std::string errMsg;
-            if (reasonStr && *reasonStr)
-                errMsg = sName.empty() ? reasonStr : (sName + ": " + reasonStr);
-            else
-                errMsg = sName.empty() ? "Pet spell failed." : (sName + ": Pet spell failed.");
-            owner_.addSystemChatMessage(errMsg);
-        }
-    }
-    packet.skipAll();
-}
-
-void CombatHandler::handlePetBroken(network::Packet& packet) {
-    // Pet bond broken (died or forcibly dismissed) — clear pet state
-    owner_.petGuid_ = 0;
-    owner_.petSpellList_.clear();
-    owner_.petAutocastSpells_.clear();
-    memset(owner_.petActionSlots_, 0, sizeof(owner_.petActionSlots_));
-    owner_.addSystemChatMessage("Your pet has died.");
-    LOG_INFO("SMSG_PET_BROKEN: pet bond broken");
-    packet.skipAll();
-}
-
-void CombatHandler::handlePetLearnedSpell(network::Packet& packet) {
-    if (packet.hasRemaining(4)) {
-        uint32_t spellId = packet.readUInt32();
-        owner_.petSpellList_.push_back(spellId);
-        const std::string& sname = owner_.getSpellName(spellId);
-        owner_.addSystemChatMessage("Your pet has learned " + (sname.empty() ? "a new ability." : sname + "."));
-        LOG_DEBUG("SMSG_PET_LEARNED_SPELL: spellId=", spellId);
-        owner_.fireAddonEvent("PET_BAR_UPDATE", {});
-    }
-    packet.skipAll();
-}
-
-void CombatHandler::handlePetUnlearnedSpell(network::Packet& packet) {
-    if (packet.hasRemaining(4)) {
-        uint32_t spellId = packet.readUInt32();
-        owner_.petSpellList_.erase(
-            std::remove(owner_.petSpellList_.begin(), owner_.petSpellList_.end(), spellId),
-            owner_.petSpellList_.end());
-        owner_.petAutocastSpells_.erase(spellId);
-        LOG_DEBUG("SMSG_PET_UNLEARNED_SPELL: spellId=", spellId);
-    }
-    packet.skipAll();
-}
-
-void CombatHandler::handlePetMode(network::Packet& packet) {
-    // uint64 petGuid, uint32 mode
-    // mode bits: low byte = command state, next byte = react state
-    if (packet.hasRemaining(12)) {
-        uint64_t modeGuid = packet.readUInt64();
-        uint32_t mode     = packet.readUInt32();
-        if (modeGuid == owner_.petGuid_) {
-            owner_.petCommand_ = static_cast<uint8_t>(mode & 0xFF);
-            owner_.petReact_   = static_cast<uint8_t>((mode >> 8) & 0xFF);
-            LOG_DEBUG("SMSG_PET_MODE: command=", static_cast<int>(owner_.petCommand_),
-                      " react=", static_cast<int>(owner_.petReact_));
-        }
-    }
-    packet.skipAll();
-}
-
-// ============================================================
-// Resurrect
-// ============================================================
-
-void CombatHandler::handleResurrectFailed(network::Packet& packet) {
-    if (packet.hasRemaining(4)) {
-        uint32_t reason = packet.readUInt32();
-        const char* msg = (reason == 1) ? "The target cannot be resurrected right now."
-                        : (reason == 2) ? "Cannot resurrect in this area."
-                        : "Resurrection failed.";
-        owner_.addUIError(msg);
-        owner_.addSystemChatMessage(msg);
-    }
-}
-
-// ============================================================
-// Targeting
-// ============================================================
-
-void CombatHandler::setTarget(uint64_t guid) {
-    if (guid == owner_.targetGuid) return;
-
-    // Save previous target
-    if (owner_.targetGuid != 0) {
-        owner_.lastTargetGuid = owner_.targetGuid;
-    }
-
-    owner_.targetGuid = guid;
-
-    // Clear stale aura data from the previous target so the buff bar shows
-    // an empty state until the server sends SMSG_AURA_UPDATE_ALL for the new target.
-    if (owner_.spellHandler_) for (auto& slot : owner_.spellHandler_->targetAuras_) slot = AuraSlot{};
-
-    // Clear previous target's cast bar on target change
-    // (the new target's cast state is naturally fetched from spellHandler_->unitCastStates_ by GUID)
-
-    // Inform server of target selection
-    if (owner_.isInWorld()) {
-        auto packet = SetSelectionPacket::build(guid);
-        owner_.socket->send(packet);
-    }
-
-    if (guid != 0) {
-        LOG_INFO("Target set: 0x", std::hex, guid, std::dec);
-    }
-    owner_.fireAddonEvent("PLAYER_TARGET_CHANGED", {});
-}
-
-void CombatHandler::clearTarget() {
-    if (owner_.targetGuid != 0) {
-        LOG_INFO("Target cleared");
-        // Zero the GUID before firing the event so callbacks/addons that query
-        // the current target see null (consistent with setTarget which updates
-        // targetGuid before the event).
-        owner_.targetGuid = 0;
-        owner_.fireAddonEvent("PLAYER_TARGET_CHANGED", {});
-    } else {
-        owner_.targetGuid = 0;
-    }
-    owner_.tabCycleIndex = -1;
-    owner_.tabCycleStale = true;
-}
-
-std::shared_ptr<Entity> CombatHandler::getTarget() const {
-    if (owner_.targetGuid == 0) return nullptr;
-    return owner_.getEntityManager().getEntity(owner_.targetGuid);
-}
-
-void CombatHandler::setFocus(uint64_t guid) {
-    owner_.focusGuid = guid;
-    owner_.fireAddonEvent("PLAYER_FOCUS_CHANGED", {});
-    if (guid != 0) {
-        auto entity = owner_.getEntityManager().getEntity(guid);
-        if (entity) {
-            std::string name;
-            auto unit = std::dynamic_pointer_cast<Unit>(entity);
-            if (unit && !unit->getName().empty()) {
-                name = unit->getName();
-            }
-            if (name.empty()) name = owner_.lookupName(guid);
-            if (name.empty()) name = "Unknown";
-            owner_.addSystemChatMessage("Focus set: " + name);
-            LOG_INFO("Focus set: 0x", std::hex, guid, std::dec);
-        }
-    }
-}
-
-void CombatHandler::clearFocus() {
-    if (owner_.focusGuid != 0) {
-        owner_.addSystemChatMessage("Focus cleared.");
-        LOG_INFO("Focus cleared");
-    }
-    owner_.focusGuid = 0;
-    owner_.fireAddonEvent("PLAYER_FOCUS_CHANGED", {});
-}
-
-std::shared_ptr<Entity> CombatHandler::getFocus() const {
-    if (owner_.focusGuid == 0) return nullptr;
-    return owner_.getEntityManager().getEntity(owner_.focusGuid);
-}
-
-void CombatHandler::setMouseoverGuid(uint64_t guid) {
-    if (owner_.mouseoverGuid_ != guid) {
-        owner_.mouseoverGuid_ = guid;
-        owner_.fireAddonEvent("UPDATE_MOUSEOVER_UNIT", {});
-    }
-}
-
-void CombatHandler::targetLastTarget() {
-    if (owner_.lastTargetGuid == 0) {
-        owner_.addSystemChatMessage("No previous target.");
-        return;
-    }
-
-    // Swap current and last target
-    uint64_t temp = owner_.targetGuid;
-    setTarget(owner_.lastTargetGuid);
-    owner_.lastTargetGuid = temp;
-}
-
-void CombatHandler::targetEnemy(bool reverse) {
-    // Get list of hostile entities
-    std::vector<uint64_t> hostiles;
-    auto& entities = owner_.getEntityManager().getEntities();
-
-    for (const auto& [guid, entity] : entities) {
-        if (entity->getType() == ObjectType::UNIT) {
-            auto unit = std::dynamic_pointer_cast<Unit>(entity);
-            if (unit && guid != owner_.playerGuid && unit->isHostile()) {
-                hostiles.push_back(guid);
-            }
-        }
-    }
-
-    if (hostiles.empty()) {
-        owner_.addSystemChatMessage("No enemies in range.");
-        return;
-    }
-
-    // Find current target in list
-    auto it = std::find(hostiles.begin(), hostiles.end(), owner_.targetGuid);
-
-    if (it == hostiles.end()) {
-        // Not currently targeting a hostile, target first one
-        setTarget(reverse ? hostiles.back() : hostiles.front());
-    } else {
-        // Cycle to next/previous
-        if (reverse) {
-            if (it == hostiles.begin()) {
-                setTarget(hostiles.back());
-            } else {
-                setTarget(*(--it));
-            }
-        } else {
-            ++it;
-            if (it == hostiles.end()) {
-                setTarget(hostiles.front());
-            } else {
-                setTarget(*it);
-            }
-        }
-    }
-}
-
-void CombatHandler::targetFriend(bool reverse) {
-    // Get list of friendly entities (players)
-    std::vector<uint64_t> friendlies;
-    auto& entities = owner_.getEntityManager().getEntities();
-
-    for (const auto& [guid, entity] : entities) {
-        if (entity->getType() == ObjectType::PLAYER && guid != owner_.playerGuid) {
-            friendlies.push_back(guid);
-        }
-    }
-
-    if (friendlies.empty()) {
-        owner_.addSystemChatMessage("No friendly targets in range.");
-        return;
-    }
-
-    // Find current target in list
-    auto it = std::find(friendlies.begin(), friendlies.end(), owner_.targetGuid);
-
-    if (it == friendlies.end()) {
-        // Not currently targeting a friend, target first one
-        setTarget(reverse ? friendlies.back() : friendlies.front());
-    } else {
-        // Cycle to next/previous
-        if (reverse) {
-            if (it == friendlies.begin()) {
-                setTarget(friendlies.back());
-            } else {
-                setTarget(*(--it));
-            }
-        } else {
-            ++it;
-            if (it == friendlies.end()) {
-                setTarget(friendlies.front());
-            } else {
-                setTarget(*it);
-            }
-        }
-    }
-}
-
-void CombatHandler::tabTarget(float playerX, float playerY, float playerZ) {
-    // Helper: returns true if the entity is a living hostile that can be tab-targeted.
-    auto isValidTabTarget = [&](const std::shared_ptr<Entity>& e) -> bool {
-        if (!e) return false;
-        const uint64_t guid = e->getGuid();
-        auto* unit = dynamic_cast<Unit*>(e.get());
-        if (!unit) return false;
-        if (unit->getHealth() == 0) {
-            auto lootIt = owner_.localLootState_.find(guid);
-            if (lootIt == owner_.localLootState_.end() || lootIt->second.data.items.empty()) {
-                return false;
-            }
-            return true;
-        }
-        const bool hostileByFaction = unit->isHostile();
-        const bool hostileByCombat = isAggressiveTowardPlayer(guid);
-        if (!hostileByFaction && !hostileByCombat) return false;
-        return true;
-    };
-
-    // Rebuild cycle list if stale (entity added/removed since last tab press).
-    if (owner_.tabCycleStale) {
-        owner_.tabCycleList.clear();
-        owner_.tabCycleIndex = -1;
-
-        struct EntityDist { uint64_t guid; float distance; };
-        std::vector<EntityDist> sortable;
-
-        for (const auto& [guid, entity] : owner_.getEntityManager().getEntities()) {
-            auto t = entity->getType();
-            if (t != ObjectType::UNIT && t != ObjectType::PLAYER) continue;
-            if (guid == owner_.playerGuid) continue;
-            if (!isValidTabTarget(entity)) continue;
-            float dx = entity->getX() - playerX;
-            float dy = entity->getY() - playerY;
-            float dz = entity->getZ() - playerZ;
-            sortable.push_back({guid, std::sqrt(dx*dx + dy*dy + dz*dz)});
-        }
-
-        std::sort(sortable.begin(), sortable.end(),
-                  [](const EntityDist& a, const EntityDist& b) { return a.distance < b.distance; });
-
-        for (const auto& ed : sortable) {
-            owner_.tabCycleList.push_back(ed.guid);
-        }
-        owner_.tabCycleStale = false;
-    }
-
-    if (owner_.tabCycleList.empty()) {
-        clearTarget();
-        return;
-    }
-
-    // Advance through the cycle, skipping any entry that has since died or
-    // turned friendly (e.g. NPC killed between two tab presses).
-    int tries = static_cast<int>(owner_.tabCycleList.size());
-    while (tries-- > 0) {
-        owner_.tabCycleIndex = (owner_.tabCycleIndex + 1) % static_cast<int>(owner_.tabCycleList.size());
-        uint64_t guid = owner_.tabCycleList[owner_.tabCycleIndex];
-        auto entity = owner_.getEntityManager().getEntity(guid);
-        if (isValidTabTarget(entity)) {
-            setTarget(guid);
-            return;
-        }
-    }
-
-    // All cached entries are stale — clear target and force a fresh rebuild next time.
-    owner_.tabCycleStale = true;
-    clearTarget();
-}
-
-void CombatHandler::assistTarget() {
-    if (owner_.state != WorldState::IN_WORLD) {
-        LOG_WARNING("Cannot assist: not in world");
-        return;
-    }
-
-    if (owner_.targetGuid == 0) {
-        owner_.addSystemChatMessage("You must target someone to assist.");
-        return;
-    }
-
-    auto target = getTarget();
-    if (!target) {
-        owner_.addSystemChatMessage("Invalid target.");
-        return;
-    }
-
-    // Get target name
-    std::string targetName = "Target";
-    if (target->getType() == ObjectType::PLAYER) {
-        auto player = std::static_pointer_cast<Player>(target);
-        if (!player->getName().empty()) {
-            targetName = player->getName();
-        }
-    } else if (target->getType() == ObjectType::UNIT) {
-        auto unit = std::static_pointer_cast<Unit>(target);
-        targetName = unit->getName();
-    }
-
-    // Try to read target GUID from update fields (UNIT_FIELD_TARGET)
-    uint64_t assistTargetGuid = 0;
-    const auto& fields = target->getFields();
-    auto it = fields.find(fieldIndex(UF::UNIT_FIELD_TARGET_LO));
-    if (it != fields.end()) {
-        assistTargetGuid = it->second;
-        auto it2 = fields.find(fieldIndex(UF::UNIT_FIELD_TARGET_HI));
-        if (it2 != fields.end()) {
-            assistTargetGuid |= (static_cast<uint64_t>(it2->second) << 32);
-        }
-    }
-
-    if (assistTargetGuid == 0) {
-        owner_.addSystemChatMessage(targetName + " has no target.");
-        LOG_INFO("Assist: ", targetName, " has no target");
-        return;
-    }
-
-    // Set our target to their target
-    setTarget(assistTargetGuid);
-    LOG_INFO("Assisting ", targetName, ", now targeting GUID: 0x", std::hex, assistTargetGuid, std::dec);
-}
-
-// ============================================================
-// PvP
-// ============================================================
-
-void CombatHandler::togglePvp() {
-    if (!owner_.isInWorld()) {
-        LOG_WARNING("Cannot toggle PvP: not in world or not connected");
-        return;
-    }
-
-    auto packet = TogglePvpPacket::build();
-    owner_.socket->send(packet);
-    auto entity = owner_.getEntityManager().getEntity(owner_.playerGuid);
-    bool currentlyPvp = false;
-    if (entity) {
-        // UNIT_FIELD_FLAGS (index 59), bit 0x1000 = UNIT_FLAG_PVP
-        currentlyPvp = (entity->getField(59) & 0x00001000) != 0;
-    }
-    if (currentlyPvp) {
-        owner_.addSystemChatMessage("PvP flag disabled.");
-    } else {
-        owner_.addSystemChatMessage("PvP flag enabled.");
-    }
-    LOG_INFO("Toggled PvP flag");
-}
-
-// ============================================================
-// Death / Resurrection
-// ============================================================
-
-void CombatHandler::releaseSpirit() {
-    if (owner_.socket && owner_.state == WorldState::IN_WORLD) {
-        auto now = std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now().time_since_epoch()).count();
-        if (owner_.repopPending_ && now - static_cast<int64_t>(owner_.lastRepopRequestMs_) < 1000) {
-            return;
-        }
-        auto packet = RepopRequestPacket::build();
-        owner_.socket->send(packet);
-        owner_.selfResAvailable_ = false;
-        owner_.repopPending_ = true;
-        owner_.lastRepopRequestMs_ = static_cast<uint64_t>(now);
-        LOG_INFO("Sent CMSG_REPOP_REQUEST (Release Spirit)");
-        network::Packet cq(wireOpcode(Opcode::MSG_CORPSE_QUERY));
-        owner_.socket->send(cq);
-    }
-}
-
-bool CombatHandler::canReclaimCorpse() const {
-    if (!owner_.releasedSpirit_ || owner_.corpseGuid_ == 0 || owner_.corpseMapId_ == 0) return false;
-    if (owner_.currentMapId_ != owner_.corpseMapId_) return false;
-    float dx = owner_.movementInfo.x - owner_.corpseY_;
-    float dy = owner_.movementInfo.y - owner_.corpseX_;
-    float dz = owner_.movementInfo.z - owner_.corpseZ_;
-    return (dx*dx + dy*dy + dz*dz) <= (40.0f * 40.0f);
-}
-
-float CombatHandler::getCorpseReclaimDelaySec() const {
-    if (owner_.corpseReclaimAvailableMs_ == 0) return 0.0f;
-    auto nowMs = static_cast<uint64_t>(
-        std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now().time_since_epoch()).count());
-    if (nowMs >= owner_.corpseReclaimAvailableMs_) return 0.0f;
-    return static_cast<float>(owner_.corpseReclaimAvailableMs_ - nowMs) / 1000.0f;
-}
-
-void CombatHandler::reclaimCorpse() {
-    if (!canReclaimCorpse() || !owner_.socket) return;
-    if (owner_.corpseGuid_ == 0) {
-        LOG_WARNING("reclaimCorpse: corpse GUID not yet known (corpse object not received); cannot reclaim");
-        return;
-    }
-    auto packet = ReclaimCorpsePacket::build(owner_.corpseGuid_);
-    owner_.socket->send(packet);
-    LOG_INFO("Sent CMSG_RECLAIM_CORPSE for corpse guid=0x", std::hex, owner_.corpseGuid_, std::dec);
-}
-
-void CombatHandler::useSelfRes() {
-    if (!owner_.selfResAvailable_ || !owner_.socket) return;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_SELF_RES));
-    owner_.socket->send(pkt);
-    owner_.selfResAvailable_ = false;
-    LOG_INFO("Sent CMSG_SELF_RES (Reincarnation / Twisting Nether)");
-}
-
-void CombatHandler::activateSpiritHealer(uint64_t npcGuid) {
-    if (!owner_.isInWorld()) return;
-    owner_.pendingSpiritHealerGuid_ = npcGuid;
-    auto packet = SpiritHealerActivatePacket::build(npcGuid);
-    owner_.socket->send(packet);
-    owner_.resurrectPending_ = true;
-    LOG_INFO("Sent CMSG_SPIRIT_HEALER_ACTIVATE for 0x", std::hex, npcGuid, std::dec);
-}
-
-void CombatHandler::acceptResurrect() {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || !owner_.resurrectRequestPending_) return;
-    if (owner_.resurrectIsSpiritHealer_) {
-        auto activate = SpiritHealerActivatePacket::build(owner_.resurrectCasterGuid_);
-        owner_.socket->send(activate);
-        LOG_INFO("Sent CMSG_SPIRIT_HEALER_ACTIVATE for 0x",
-                 std::hex, owner_.resurrectCasterGuid_, std::dec);
-    } else {
-        auto resp = ResurrectResponsePacket::build(owner_.resurrectCasterGuid_, true);
-        owner_.socket->send(resp);
-        LOG_INFO("Sent CMSG_RESURRECT_RESPONSE (accept) for 0x",
-                 std::hex, owner_.resurrectCasterGuid_, std::dec);
-    }
-    owner_.resurrectRequestPending_ = false;
-    owner_.resurrectPending_ = true;
-}
-
-void CombatHandler::declineResurrect() {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || !owner_.resurrectRequestPending_) return;
-    auto resp = ResurrectResponsePacket::build(owner_.resurrectCasterGuid_, false);
-    owner_.socket->send(resp);
-    LOG_INFO("Sent CMSG_RESURRECT_RESPONSE (decline) for 0x",
-             std::hex, owner_.resurrectCasterGuid_, std::dec);
-    owner_.resurrectRequestPending_ = false;
-}
-
-// ============================================================
-// XP
-// ============================================================
-
-uint32_t CombatHandler::killXp(uint32_t playerLevel, uint32_t victimLevel) {
-    if (playerLevel == 0 || victimLevel == 0) return 0;
-
-    int32_t grayLevel;
-    if (playerLevel <= 5)        grayLevel = 0;
-    else if (playerLevel <= 39)  grayLevel = static_cast<int32_t>(playerLevel) - 5 - static_cast<int32_t>(playerLevel) / 10;
-    else if (playerLevel <= 59)  grayLevel = static_cast<int32_t>(playerLevel) - 1 - static_cast<int32_t>(playerLevel) / 5;
-    else                         grayLevel = static_cast<int32_t>(playerLevel) - 9;
-
-    if (static_cast<int32_t>(victimLevel) <= grayLevel) return 0;
-
-    uint32_t baseXp = 45 + 5 * victimLevel;
-
-    int32_t diff = static_cast<int32_t>(victimLevel) - static_cast<int32_t>(playerLevel);
-    float multiplier = 1.0f + diff * 0.05f;
-    if (multiplier < 0.1f) multiplier = 0.1f;
-    if (multiplier > 2.0f) multiplier = 2.0f;
-
-    return static_cast<uint32_t>(baseXp * multiplier);
-}
-
-void CombatHandler::handleXpGain(network::Packet& packet) {
-    XpGainData data;
-    if (!XpGainParser::parse(packet, data)) return;
-
-    addCombatText(CombatTextEntry::XP_GAIN, static_cast<int32_t>(data.totalXp), 0, true);
-
-    std::string msg;
-    if (data.victimGuid != 0 && data.type == 0) {
-        std::string victimName = owner_.lookupName(data.victimGuid);
-        if (!victimName.empty())
-            msg = victimName + " dies, you gain " + std::to_string(data.totalXp) + " experience.";
-        else
-            msg = "You gain " + std::to_string(data.totalXp) + " experience.";
-    } else {
-        msg = "You gain " + std::to_string(data.totalXp) + " experience.";
-    }
-    if (data.groupBonus > 0) {
-        msg += " (+" + std::to_string(data.groupBonus) + " group bonus)";
-    }
-    owner_.addSystemChatMessage(msg);
-    owner_.fireAddonEvent("CHAT_MSG_COMBAT_XP_GAIN", {msg, std::to_string(data.totalXp)});
-}
-
-} // namespace game
-} // namespace wowee
diff --git a/src/game/entity_controller.cpp b/src/game/entity_controller.cpp
deleted file mode 100644
index 6eb3a307..00000000
--- a/src/game/entity_controller.cpp
+++ /dev/null
@@ -1,2215 +0,0 @@
-#include "game/entity_controller.hpp"
-#include "game/game_handler.hpp"
-#include "game/game_utils.hpp"
-#include "game/packet_parsers.hpp"
-#include "game/entity.hpp"
-#include "game/update_field_table.hpp"
-#include "game/opcode_table.hpp"
-#include "game/chat_handler.hpp"
-#include "game/transport_manager.hpp"
-#include "core/logger.hpp"
-#include "core/coordinates.hpp"
-#include "network/world_socket.hpp"
-#include <algorithm>
-#include <cstring>
-#include <zlib.h>
-
-namespace wowee {
-namespace game {
-
-namespace {
-
-const char* worldStateName(WorldState state) {
-    switch (state) {
-        case WorldState::DISCONNECTED: return "DISCONNECTED";
-        case WorldState::CONNECTING: return "CONNECTING";
-        case WorldState::CONNECTED: return "CONNECTED";
-        case WorldState::CHALLENGE_RECEIVED: return "CHALLENGE_RECEIVED";
-        case WorldState::AUTH_SENT: return "AUTH_SENT";
-        case WorldState::AUTHENTICATED: return "AUTHENTICATED";
-        case WorldState::READY: return "READY";
-        case WorldState::CHAR_LIST_REQUESTED: return "CHAR_LIST_REQUESTED";
-        case WorldState::CHAR_LIST_RECEIVED: return "CHAR_LIST_RECEIVED";
-        case WorldState::ENTERING_WORLD: return "ENTERING_WORLD";
-        case WorldState::IN_WORLD: return "IN_WORLD";
-        case WorldState::FAILED: return "FAILED";
-    }
-    return "UNKNOWN";
-}
-
-bool envFlagEnabled(const char* key, bool defaultValue = false) {
-    const char* raw = std::getenv(key);
-    if (!raw || !*raw) return defaultValue;
-    return !(raw[0] == '0' || raw[0] == 'f' || raw[0] == 'F' ||
-             raw[0] == 'n' || raw[0] == 'N');
-}
-
-int parseEnvIntClamped(const char* key, int defaultValue, int minValue, int maxValue) {
-    const char* raw = std::getenv(key);
-    if (!raw || !*raw) return defaultValue;
-    char* end = nullptr;
-    long parsed = std::strtol(raw, &end, 10);
-    if (end == raw) return defaultValue;
-    return static_cast<int>(std::clamp<long>(parsed, minValue, maxValue));
-}
-
-int updateObjectBlocksBudgetPerUpdate(WorldState state) {
-    static const int inWorldBudget =
-        parseEnvIntClamped("WOWEE_NET_MAX_UPDATE_OBJECT_BLOCKS", 24, 1, 2048);
-    static const int loginBudget =
-        parseEnvIntClamped("WOWEE_NET_MAX_UPDATE_OBJECT_BLOCKS_LOGIN", 128, 1, 4096);
-    return state == WorldState::IN_WORLD ? inWorldBudget : loginBudget;
-}
-
-float slowUpdateObjectBlockLogThresholdMs() {
-    static const int thresholdMs =
-        parseEnvIntClamped("WOWEE_NET_SLOW_UPDATE_BLOCK_LOG_MS", 10, 1, 60000);
-    return static_cast<float>(thresholdMs);
-}
-
-} // anonymous namespace
-
-EntityController::EntityController(GameHandler& owner)
-    : owner_(owner) { initTypeHandlers(); }
-
-void EntityController::registerOpcodes(DispatchTable& table) {
-    // World object updates
-    table[Opcode::SMSG_UPDATE_OBJECT] = [this](network::Packet& packet) {
-        LOG_DEBUG("Received SMSG_UPDATE_OBJECT, state=", static_cast<int>(owner_.state), " size=", packet.getSize());
-        if (owner_.state == WorldState::IN_WORLD) handleUpdateObject(packet);
-    };
-    table[Opcode::SMSG_COMPRESSED_UPDATE_OBJECT] = [this](network::Packet& packet) {
-        LOG_DEBUG("Received SMSG_COMPRESSED_UPDATE_OBJECT, state=", static_cast<int>(owner_.state), " size=", packet.getSize());
-        if (owner_.state == WorldState::IN_WORLD) handleCompressedUpdateObject(packet);
-    };
-    table[Opcode::SMSG_DESTROY_OBJECT] = [this](network::Packet& packet) {
-        if (owner_.state == WorldState::IN_WORLD) handleDestroyObject(packet);
-    };
-
-    // Entity queries
-    table[Opcode::SMSG_NAME_QUERY_RESPONSE] = [this](network::Packet& packet) {
-        handleNameQueryResponse(packet);
-    };
-    table[Opcode::SMSG_CREATURE_QUERY_RESPONSE] = [this](network::Packet& packet) {
-        handleCreatureQueryResponse(packet);
-    };
-    table[Opcode::SMSG_GAMEOBJECT_QUERY_RESPONSE] = [this](network::Packet& packet) {
-        handleGameObjectQueryResponse(packet);
-    };
-    table[Opcode::SMSG_GAMEOBJECT_PAGETEXT] = [this](network::Packet& packet) {
-        handleGameObjectPageText(packet);
-    };
-    table[Opcode::SMSG_PAGE_TEXT_QUERY_RESPONSE] = [this](network::Packet& packet) {
-        handlePageTextQueryResponse(packet);
-    };
-}
-
-void EntityController::clearAll() {
-    pendingUpdateObjectWork_.clear();
-    playerNameCache.clear();
-    playerClassRaceCache_.clear();
-    pendingNameQueries.clear();
-    creatureInfoCache.clear();
-    pendingCreatureQueries.clear();
-    gameObjectInfoCache_.clear();
-    pendingGameObjectQueries_.clear();
-    transportGuids_.clear();
-    serverUpdatedTransportGuids_.clear();
-    entityManager.clear();
-}
-
-// ============================================================
-// Update Object Pipeline
-// ============================================================
-
-void EntityController::enqueueUpdateObjectWork(UpdateObjectData&& data) {
-    pendingUpdateObjectWork_.push_back(PendingUpdateObjectWork{std::move(data)});
-}
-void EntityController::processPendingUpdateObjectWork(const std::chrono::steady_clock::time_point& start,
-                                                 float budgetMs) {
-    if (pendingUpdateObjectWork_.empty()) {
-        return;
-    }
-
-    const int maxBlocksThisUpdate = updateObjectBlocksBudgetPerUpdate(owner_.state);
-    int processedBlocks = 0;
-
-    while (!pendingUpdateObjectWork_.empty() && processedBlocks < maxBlocksThisUpdate) {
-        float elapsedMs = std::chrono::duration<float, std::milli>(
-            std::chrono::steady_clock::now() - start).count();
-        if (elapsedMs >= budgetMs) {
-            break;
-        }
-
-        auto& work = pendingUpdateObjectWork_.front();
-        if (!work.outOfRangeProcessed) {
-            auto outOfRangeStart = std::chrono::steady_clock::now();
-            processOutOfRangeObjects(work.data.outOfRangeGuids);
-            float outOfRangeMs = std::chrono::duration<float, std::milli>(
-                std::chrono::steady_clock::now() - outOfRangeStart).count();
-            if (outOfRangeMs > slowUpdateObjectBlockLogThresholdMs()) {
-                LOG_WARNING("SLOW update-object out-of-range handling: ", outOfRangeMs,
-                            "ms guidCount=", work.data.outOfRangeGuids.size());
-            }
-            work.outOfRangeProcessed = true;
-        }
-
-        while (work.nextBlockIndex < work.data.blocks.size() && processedBlocks < maxBlocksThisUpdate) {
-            elapsedMs = std::chrono::duration<float, std::milli>(
-                std::chrono::steady_clock::now() - start).count();
-            if (elapsedMs >= budgetMs) {
-                break;
-            }
-
-            const UpdateBlock& block = work.data.blocks[work.nextBlockIndex];
-            auto blockStart = std::chrono::steady_clock::now();
-            applyUpdateObjectBlock(block, work.newItemCreated);
-            float blockMs = std::chrono::duration<float, std::milli>(
-                std::chrono::steady_clock::now() - blockStart).count();
-            if (blockMs > slowUpdateObjectBlockLogThresholdMs()) {
-                LOG_WARNING("SLOW update-object block apply: ", blockMs,
-                            "ms index=", work.nextBlockIndex,
-                            " type=", static_cast<int>(block.updateType),
-                            " guid=0x", std::hex, block.guid, std::dec,
-                            " objectType=", static_cast<int>(block.objectType),
-                            " fieldCount=", block.fields.size(),
-                            " hasMovement=", block.hasMovement ? 1 : 0);
-            }
-            ++work.nextBlockIndex;
-            ++processedBlocks;
-        }
-
-        if (work.nextBlockIndex >= work.data.blocks.size()) {
-            finalizeUpdateObjectBatch(work.newItemCreated);
-            pendingUpdateObjectWork_.pop_front();
-            continue;
-        }
-        break;
-    }
-
-    if (!pendingUpdateObjectWork_.empty()) {
-        const auto& work = pendingUpdateObjectWork_.front();
-        LOG_DEBUG("GameHandler update-object budget reached (remainingBatches=",
-                  pendingUpdateObjectWork_.size(), ", nextBlockIndex=", work.nextBlockIndex,
-                  "/", work.data.blocks.size(), ", owner_.state=", worldStateName(owner_.state), ")");
-    }
-}
-void EntityController::handleUpdateObject(network::Packet& packet) {
-    UpdateObjectData data;
-    if (!owner_.packetParsers_->parseUpdateObject(packet, data)) {
-        static int updateObjErrors = 0;
-        if (++updateObjErrors <= 5)
-            LOG_WARNING("Failed to parse SMSG_UPDATE_OBJECT");
-        if (data.blocks.empty()) return;
-        // Fall through: process any blocks that were successfully parsed before the failure.
-    }
-
-    enqueueUpdateObjectWork(std::move(data));
-}
-
-void EntityController::processOutOfRangeObjects(const std::vector<uint64_t>& guids) {
-    // Process out-of-range objects first
-    for (uint64_t guid : guids) {
-        auto entity = entityManager.getEntity(guid);
-        if (!entity) continue;
-
-        const bool isKnownTransport = transportGuids_.count(guid) > 0;
-        if (isKnownTransport) {
-            // Keep transports alive across out-of-range flapping.
-            // Boats/zeppelins are global movers and removing them here can make
-            // them disappear until a later movement snapshot happens to recreate them.
-            const bool playerAboardNow = (owner_.playerTransportGuid_ == guid);
-            const bool stickyAboard = (owner_.playerTransportStickyGuid_ == guid && owner_.playerTransportStickyTimer_ > 0.0f);
-            const bool movementSaysAboard = (owner_.movementInfo.transportGuid == guid);
-            LOG_INFO("Preserving transport on out-of-range: 0x",
-                     std::hex, guid, std::dec,
-                     " now=", playerAboardNow,
-                     " sticky=", stickyAboard,
-                     " movement=", movementSaysAboard);
-            continue;
-        }
-
-        LOG_DEBUG("Entity went out of range: 0x", std::hex, guid, std::dec);
-        // Trigger despawn callbacks before removing entity
-        if (entity->getType() == ObjectType::UNIT && owner_.creatureDespawnCallback_) {
-            owner_.creatureDespawnCallback_(guid);
-        } else if (entity->getType() == ObjectType::PLAYER && owner_.playerDespawnCallback_) {
-            owner_.playerDespawnCallback_(guid);
-            owner_.otherPlayerVisibleItemEntries_.erase(guid);
-            owner_.otherPlayerVisibleDirty_.erase(guid);
-            owner_.otherPlayerMoveTimeMs_.erase(guid);
-            owner_.inspectedPlayerItemEntries_.erase(guid);
-            owner_.pendingAutoInspect_.erase(guid);
-            // Clear pending name query so the query is re-sent when this player
-            // comes back into range (entity is recreated as a new object).
-            pendingNameQueries.erase(guid);
-        } else if (entity->getType() == ObjectType::GAMEOBJECT && owner_.gameObjectDespawnCallback_) {
-            owner_.gameObjectDespawnCallback_(guid);
-        }
-        transportGuids_.erase(guid);
-        serverUpdatedTransportGuids_.erase(guid);
-        owner_.clearTransportAttachment(guid);
-        if (owner_.playerTransportGuid_ == guid) {
-            owner_.clearPlayerTransport();
-        }
-        entityManager.removeEntity(guid);
-    }
-
-}
-
-// ============================================================
-// Extracted helper methods
-// ============================================================
-
-bool EntityController::extractPlayerAppearance(const std::map<uint16_t, uint32_t>& fields,
-                                               uint8_t& outRace,
-                                               uint8_t& outGender,
-                                               uint32_t& outAppearanceBytes,
-                                               uint8_t& outFacial) const {
-    outRace = 0;
-    outGender = 0;
-    outAppearanceBytes = 0;
-    outFacial = 0;
-
-    auto readField = [&](uint16_t idx, uint32_t& out) -> bool {
-        if (idx == 0xFFFF) return false;
-        auto it = fields.find(idx);
-        if (it == fields.end()) return false;
-        out = it->second;
-        return true;
-    };
-
-    uint32_t bytes0 = 0;
-    uint32_t pbytes = 0;
-    uint32_t pbytes2 = 0;
-
-    const uint16_t ufBytes0 = fieldIndex(UF::UNIT_FIELD_BYTES_0);
-    const uint16_t ufPbytes = fieldIndex(UF::PLAYER_BYTES);
-    const uint16_t ufPbytes2 = fieldIndex(UF::PLAYER_BYTES_2);
-
-    bool haveBytes0 = readField(ufBytes0, bytes0);
-    bool havePbytes = readField(ufPbytes, pbytes);
-    bool havePbytes2 = readField(ufPbytes2, pbytes2);
-
-    // Heuristic fallback: Turtle can run with unusual build numbers; if the JSON table is missing,
-    // try to locate plausible packed fields by scanning.
-    if (!haveBytes0) {
-        for (const auto& [idx, v] : fields) {
-            uint8_t race = static_cast<uint8_t>(v & 0xFF);
-            uint8_t cls = static_cast<uint8_t>((v >> 8) & 0xFF);
-            uint8_t gender = static_cast<uint8_t>((v >> 16) & 0xFF);
-            uint8_t power = static_cast<uint8_t>((v >> 24) & 0xFF);
-            if (race >= 1 && race <= 20 &&
-                cls >= 1 && cls <= 20 &&
-                gender <= 1 &&
-                power <= 10) {
-                bytes0 = v;
-                haveBytes0 = true;
-                break;
-            }
-        }
-    }
-    if (!havePbytes) {
-        for (const auto& [idx, v] : fields) {
-            uint8_t skin = static_cast<uint8_t>(v & 0xFF);
-            uint8_t face = static_cast<uint8_t>((v >> 8) & 0xFF);
-            uint8_t hair = static_cast<uint8_t>((v >> 16) & 0xFF);
-            uint8_t color = static_cast<uint8_t>((v >> 24) & 0xFF);
-            if (skin <= 50 && face <= 50 && hair <= 100 && color <= 50) {
-                pbytes = v;
-                havePbytes = true;
-                break;
-            }
-        }
-    }
-    if (!havePbytes2) {
-        for (const auto& [idx, v] : fields) {
-            uint8_t facial = static_cast<uint8_t>(v & 0xFF);
-            if (facial <= 100) {
-                pbytes2 = v;
-                havePbytes2 = true;
-                break;
-            }
-        }
-    }
-
-    if (!haveBytes0 || !havePbytes) return false;
-
-    outRace = static_cast<uint8_t>(bytes0 & 0xFF);
-    outGender = static_cast<uint8_t>((bytes0 >> 16) & 0xFF);
-    outAppearanceBytes = pbytes;
-    outFacial = havePbytes2 ? static_cast<uint8_t>(pbytes2 & 0xFF) : 0;
-    return true;
-}
-
-void EntityController::maybeDetectCoinageIndex(const std::map<uint16_t, uint32_t>& oldFields,
-                                               const std::map<uint16_t, uint32_t>& newFields) {
-    if (owner_.pendingMoneyDelta_ == 0 || owner_.pendingMoneyDeltaTimer_ <= 0.0f) return;
-    if (oldFields.empty() || newFields.empty()) return;
-
-    constexpr uint32_t kMaxPlausibleCoinage = 2147483647u;
-    std::vector<uint16_t> candidates;
-    candidates.reserve(8);
-
-    for (const auto& [idx, newVal] : newFields) {
-        auto itOld = oldFields.find(idx);
-        if (itOld == oldFields.end()) continue;
-        uint32_t oldVal = itOld->second;
-        if (newVal < oldVal) continue;
-        uint32_t delta = newVal - oldVal;
-        if (delta != owner_.pendingMoneyDelta_) continue;
-        if (newVal > kMaxPlausibleCoinage) continue;
-        candidates.push_back(idx);
-    }
-
-    if (candidates.empty()) return;
-
-    uint16_t current = fieldIndex(UF::PLAYER_FIELD_COINAGE);
-    uint16_t chosen = candidates[0];
-    if (std::find(candidates.begin(), candidates.end(), current) != candidates.end()) {
-        chosen = current;
-    } else {
-        std::sort(candidates.begin(), candidates.end());
-        chosen = candidates[0];
-    }
-
-    if (chosen != current && current != 0xFFFF) {
-        owner_.updateFieldTable_.setIndex(UF::PLAYER_FIELD_COINAGE, chosen);
-        LOG_WARNING("Auto-detected PLAYER_FIELD_COINAGE index: ", chosen, " (was ", current, ")");
-    }
-
-    owner_.pendingMoneyDelta_ = 0;
-    owner_.pendingMoneyDeltaTimer_ = 0.0f;
-}
-
-// ============================================================
-// Update type dispatch
-// ============================================================
-
-void EntityController::applyUpdateObjectBlock(const UpdateBlock& block, bool& newItemCreated) {
-    switch (block.updateType) {
-        case UpdateType::CREATE_OBJECT:
-        case UpdateType::CREATE_OBJECT2:
-            handleCreateObject(block, newItemCreated);
-            break;
-        case UpdateType::VALUES:
-            handleValuesUpdate(block);
-            break;
-        case UpdateType::MOVEMENT:
-            handleMovementUpdate(block);
-            break;
-        default:
-            break;
-    }
-}
-
-// ============================================================
-// Concern-specific helpers
-// ============================================================
-
-// Non-player transport child attachment — identical in CREATE/VALUES/MOVEMENT
-void EntityController::updateNonPlayerTransportAttachment(const UpdateBlock& block,
-                                                           const std::shared_ptr<Entity>& entity,
-                                                           ObjectType entityType) {
-    if (block.guid == owner_.playerGuid) return;
-    if (entityType != ObjectType::UNIT && entityType != ObjectType::GAMEOBJECT) return;
-
-    if (block.onTransport && block.transportGuid != 0) {
-        glm::vec3 localOffset = core::coords::serverToCanonical(
-            glm::vec3(block.transportX, block.transportY, block.transportZ));
-        const bool hasLocalOrientation = (block.updateFlags & 0x0020) != 0; // UPDATEFLAG_LIVING
-        float localOriCanonical = core::coords::normalizeAngleRad(-block.transportO);
-        owner_.setTransportAttachment(block.guid, entityType, block.transportGuid,
-                               localOffset, hasLocalOrientation, localOriCanonical);
-        if (owner_.transportManager_ && owner_.transportManager_->getTransport(block.transportGuid)) {
-            glm::vec3 composed = owner_.transportManager_->getPlayerWorldPosition(block.transportGuid, localOffset);
-            entity->setPosition(composed.x, composed.y, composed.z, entity->getOrientation());
-        }
-    } else {
-        owner_.clearTransportAttachment(block.guid);
-    }
-}
-
-//     Rebuild playerAuras from UNIT_FIELD_AURAS (Classic/vanilla only).
-//     blockFields is used to check if any aura field was updated in this packet.
-//     entity->getFields() is used for reading the full accumulated state.
-//     Normalises Classic harmful bit (0x02) to WotLK debuff bit (0x80) so
-//     downstream code checking for 0x80 works consistently across expansions.
-void EntityController::syncClassicAurasFromFields(const std::shared_ptr<Entity>& entity) {
-    if (!isClassicLikeExpansion() || !owner_.spellHandler_) return;
-
-    const uint16_t ufAuras     = fieldIndex(UF::UNIT_FIELD_AURAS);
-    const uint16_t ufAuraFlags = fieldIndex(UF::UNIT_FIELD_AURAFLAGS);
-    if (ufAuras == 0xFFFF) return;
-
-    const auto& allFields = entity->getFields();
-    bool hasAuraField = false;
-    for (const auto& [fk, fv] : allFields) {
-        if (fk >= ufAuras && fk < ufAuras + 48) { hasAuraField = true; break; }
-    }
-    if (!hasAuraField) return;
-
-    owner_.spellHandler_->playerAuras_.clear();
-    owner_.spellHandler_->playerAuras_.resize(48);
-    uint64_t nowMs = static_cast<uint64_t>(
-        std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now().time_since_epoch()).count());
-    for (int slot = 0; slot < 48; ++slot) {
-        auto it = allFields.find(static_cast<uint16_t>(ufAuras + slot));
-        if (it != allFields.end() && it->second != 0) {
-            AuraSlot& a = owner_.spellHandler_->playerAuras_[slot];
-            a.spellId = it->second;
-            // Read aura flag byte: packed 4-per-uint32 at ufAuraFlags
-            uint8_t aFlag = 0;
-            if (ufAuraFlags != 0xFFFF) {
-                auto fit = allFields.find(static_cast<uint16_t>(ufAuraFlags + slot / 4));
-                if (fit != allFields.end())
-                    aFlag = static_cast<uint8_t>((fit->second >> ((slot % 4) * 8)) & 0xFF);
-            }
-            // Normalize Classic harmful bit (0x02) to WotLK debuff bit (0x80)
-            // so downstream code checking for 0x80 works consistently.
-            if (aFlag & 0x02)
-                aFlag = (aFlag & ~0x02) | 0x80;
-            a.flags = aFlag;
-            a.durationMs = -1;
-            a.maxDurationMs = -1;
-            a.casterGuid = owner_.playerGuid;
-            a.receivedAtMs = nowMs;
-        }
-    }
-    LOG_DEBUG("[Classic] Rebuilt playerAuras from UNIT_FIELD_AURAS");
-    pendingEvents_.emit("UNIT_AURA", {"player"});
-}
-
-// Detect player mount/dismount from UNIT_FIELD_MOUNTDISPLAYID changes
-void EntityController::detectPlayerMountChange(uint32_t newMountDisplayId,
-                                                const std::map<uint16_t, uint32_t>& blockFields) {
-    uint32_t old = owner_.currentMountDisplayId_;
-    owner_.currentMountDisplayId_ = newMountDisplayId;
-    if (newMountDisplayId != old && owner_.mountCallback_) owner_.mountCallback_(newMountDisplayId);
-    if (newMountDisplayId != old)
-        pendingEvents_.emit("UNIT_MODEL_CHANGED", {"player"});
-    if (old == 0 && newMountDisplayId != 0) {
-        // Just mounted — find the mount aura (indefinite duration, self-cast)
-        owner_.mountAuraSpellId_ = 0;
-        if (owner_.spellHandler_) for (const auto& a : owner_.spellHandler_->playerAuras_) {
-            if (!a.isEmpty() && a.maxDurationMs < 0 && a.casterGuid == owner_.playerGuid) {
-                owner_.mountAuraSpellId_ = a.spellId;
-            }
-        }
-        // Classic/vanilla fallback: scan UNIT_FIELD_AURAS from same update block
-        if (owner_.mountAuraSpellId_ == 0) {
-            const uint16_t ufAuras = fieldIndex(UF::UNIT_FIELD_AURAS);
-            if (ufAuras != 0xFFFF) {
-                for (const auto& [fk, fv] : blockFields) {
-                    if (fk >= ufAuras && fk < ufAuras + 48 && fv != 0) {
-                        owner_.mountAuraSpellId_ = fv;
-                        break;
-                    }
-                }
-            }
-        }
-        LOG_INFO("Mount detected: displayId=", newMountDisplayId, " auraSpellId=", owner_.mountAuraSpellId_);
-    }
-    if (old != 0 && newMountDisplayId == 0) {
-        // Only clear the specific mount aura, not all indefinite auras.
-        // Previously this cleared every aura with maxDurationMs < 0, which
-        // would strip racial passives, tracking, and zone buffs on dismount.
-        uint32_t mountSpell = owner_.mountAuraSpellId_;
-        owner_.mountAuraSpellId_ = 0;
-        if (mountSpell != 0 && owner_.spellHandler_) {
-            for (auto& a : owner_.spellHandler_->playerAuras_) {
-                if (!a.isEmpty() && a.spellId == mountSpell) {
-                    a = AuraSlot{};
-                    break;
-                }
-            }
-        }
-    }
-}
-
-// Resolve cached field indices once per handler call.
-EntityController::UnitFieldIndices EntityController::UnitFieldIndices::resolve() {
-    return UnitFieldIndices{
-        fieldIndex(UF::UNIT_FIELD_HEALTH),
-        fieldIndex(UF::UNIT_FIELD_MAXHEALTH),
-        fieldIndex(UF::UNIT_FIELD_POWER1),
-        fieldIndex(UF::UNIT_FIELD_MAXPOWER1),
-        fieldIndex(UF::UNIT_FIELD_LEVEL),
-        fieldIndex(UF::UNIT_FIELD_FACTIONTEMPLATE),
-        fieldIndex(UF::UNIT_FIELD_FLAGS),
-        fieldIndex(UF::UNIT_DYNAMIC_FLAGS),
-        fieldIndex(UF::UNIT_FIELD_DISPLAYID),
-        fieldIndex(UF::UNIT_FIELD_MOUNTDISPLAYID),
-        fieldIndex(UF::UNIT_NPC_FLAGS),
-        fieldIndex(UF::UNIT_NPC_EMOTESTATE),
-        fieldIndex(UF::UNIT_FIELD_BYTES_0),
-        fieldIndex(UF::UNIT_FIELD_BYTES_1)
-    };
-}
-
-EntityController::PlayerFieldIndices EntityController::PlayerFieldIndices::resolve() {
-    return PlayerFieldIndices{
-        fieldIndex(UF::PLAYER_XP),
-        fieldIndex(UF::PLAYER_NEXT_LEVEL_XP),
-        fieldIndex(UF::PLAYER_REST_STATE_EXPERIENCE),
-        fieldIndex(UF::UNIT_FIELD_LEVEL),
-        fieldIndex(UF::PLAYER_FIELD_COINAGE),
-        fieldIndex(UF::PLAYER_FIELD_HONOR_CURRENCY),
-        fieldIndex(UF::PLAYER_FIELD_ARENA_CURRENCY),
-        fieldIndex(UF::PLAYER_FLAGS),
-        fieldIndex(UF::UNIT_FIELD_RESISTANCES),
-        fieldIndex(UF::PLAYER_BYTES),
-        fieldIndex(UF::PLAYER_BYTES_2),
-        fieldIndex(UF::PLAYER_CHOSEN_TITLE),
-        {fieldIndex(UF::UNIT_FIELD_STAT0), fieldIndex(UF::UNIT_FIELD_STAT1),
-         fieldIndex(UF::UNIT_FIELD_STAT2), fieldIndex(UF::UNIT_FIELD_STAT3),
-         fieldIndex(UF::UNIT_FIELD_STAT4)},
-        fieldIndex(UF::UNIT_FIELD_ATTACK_POWER),
-        fieldIndex(UF::UNIT_FIELD_RANGED_ATTACK_POWER),
-        fieldIndex(UF::PLAYER_FIELD_MOD_DAMAGE_DONE_POS),
-        fieldIndex(UF::PLAYER_FIELD_MOD_HEALING_DONE_POS),
-        fieldIndex(UF::PLAYER_BLOCK_PERCENTAGE),
-        fieldIndex(UF::PLAYER_DODGE_PERCENTAGE),
-        fieldIndex(UF::PLAYER_PARRY_PERCENTAGE),
-        fieldIndex(UF::PLAYER_CRIT_PERCENTAGE),
-        fieldIndex(UF::PLAYER_RANGED_CRIT_PERCENTAGE),
-        fieldIndex(UF::PLAYER_SPELL_CRIT_PERCENTAGE1),
-        fieldIndex(UF::PLAYER_FIELD_COMBAT_RATING_1)
-    };
-}
-
-// Create the appropriate Entity subclass from the block's object type.
-std::shared_ptr<Entity> EntityController::createEntityFromBlock(const UpdateBlock& block) {
-    switch (block.objectType) {
-        case ObjectType::PLAYER:
-            return std::make_shared<Player>(block.guid);
-        case ObjectType::UNIT:
-            return std::make_shared<Unit>(block.guid);
-        case ObjectType::GAMEOBJECT:
-            return std::make_shared<GameObject>(block.guid);
-        default: {
-            auto entity = std::make_shared<Entity>(block.guid);
-            entity->setType(block.objectType);
-            return entity;
-        }
-    }
-}
-
-//     Track player-on-transport state from movement blocks.
-//     Consolidates near-identical logic from CREATE and MOVEMENT handlers.
-//     When updateMovementInfoPos is true (MOVEMENT), movementInfo.x/y/z are set
-//     to the raw canonical position when not on a resolved transport.
-//     When false (CREATE), movementInfo is only set for resolved transport positions.
-void EntityController::applyPlayerTransportState(const UpdateBlock& block,
-                                                   const std::shared_ptr<Entity>& entity,
-                                                   const glm::vec3& canonicalPos, float oCanonical,
-                                                   bool updateMovementInfoPos) {
-    if (block.onTransport) {
-        // Convert transport offset from server → canonical coordinates
-        glm::vec3 serverOffset(block.transportX, block.transportY, block.transportZ);
-        glm::vec3 canonicalOffset = core::coords::serverToCanonical(serverOffset);
-        owner_.setPlayerOnTransport(block.transportGuid, canonicalOffset);
-        if (owner_.transportManager_ && owner_.transportManager_->getTransport(owner_.playerTransportGuid_)) {
-            glm::vec3 composed = owner_.transportManager_->getPlayerWorldPosition(owner_.playerTransportGuid_, owner_.playerTransportOffset_);
-            entity->setPosition(composed.x, composed.y, composed.z, oCanonical);
-            owner_.movementInfo.x = composed.x;
-            owner_.movementInfo.y = composed.y;
-            owner_.movementInfo.z = composed.z;
-        } else if (updateMovementInfoPos) {
-            owner_.movementInfo.x = canonicalPos.x;
-            owner_.movementInfo.y = canonicalPos.y;
-            owner_.movementInfo.z = canonicalPos.z;
-        }
-        LOG_INFO("Player on transport: 0x", std::hex, owner_.playerTransportGuid_, std::dec,
-                " offset=(", owner_.playerTransportOffset_.x, ", ", owner_.playerTransportOffset_.y,
-                ", ", owner_.playerTransportOffset_.z, ")");
-    } else {
-        if (updateMovementInfoPos) {
-            owner_.movementInfo.x = canonicalPos.x;
-            owner_.movementInfo.y = canonicalPos.y;
-            owner_.movementInfo.z = canonicalPos.z;
-        }
-        // Don't clear client-side M2 transport boarding (trams) —
-        // the server doesn't know about client-detected transport attachment.
-        bool isClientM2Transport = false;
-        if (owner_.playerTransportGuid_ != 0 && owner_.transportManager_) {
-            auto* tr = owner_.transportManager_->getTransport(owner_.playerTransportGuid_);
-            isClientM2Transport = (tr && tr->isM2);
-        }
-        if (owner_.playerTransportGuid_ != 0 && !isClientM2Transport) {
-            LOG_INFO("Player left transport");
-            owner_.clearPlayerTransport();
-        }
-    }
-}
-
-//     Apply unit fields during CREATE — sets health/power/level/flags/displayId/etc.
-//     Returns true if the entity is initially dead (health=0 or DYNFLAG_DEAD).
-bool EntityController::applyUnitFieldsOnCreate(const UpdateBlock& block,
-                                                 std::shared_ptr<Unit>& unit,
-                                                 const UnitFieldIndices& ufi) {
-    bool unitInitiallyDead = false;
-    constexpr uint32_t UNIT_DYNFLAG_DEAD = 0x0008;
-    constexpr uint32_t UNIT_DYNFLAG_LOOTABLE = 0x0001;
-
-    for (const auto& [key, val] : block.fields) {
-        // Check all specific fields BEFORE power/maxpower range checks.
-        // In Classic, power indices (23-27) are adjacent to maxHealth (28),
-        // and maxPower indices (29-33) are adjacent to level (34) and faction (35).
-        // A range check like "key >= powerBase && key < powerBase+7" would
-        // incorrectly capture maxHealth/level/faction in Classic's tight layout.
-        if (key == ufi.health) {
-            unit->setHealth(val);
-            if (block.objectType == ObjectType::UNIT && val == 0) {
-                unitInitiallyDead = true;
-            }
-            if (block.guid == owner_.playerGuid && val == 0) {
-                owner_.playerDead_ = true;
-                LOG_INFO("Player logged in dead");
-            }
-        } else if (key == ufi.maxHealth) { unit->setMaxHealth(val); }
-        else if (key == ufi.level) {
-            unit->setLevel(val);
-        } else if (key == ufi.faction) {
-            unit->setFactionTemplate(val);
-            if (owner_.addonEventCallback_) {
-                auto uid = owner_.guidToUnitId(block.guid);
-                if (!uid.empty())
-                    pendingEvents_.emit("UNIT_FACTION", {uid});
-            }
-        }
-        else if (key == ufi.flags) {
-            unit->setUnitFlags(val);
-            if (owner_.addonEventCallback_) {
-                auto uid = owner_.guidToUnitId(block.guid);
-                if (!uid.empty())
-                    pendingEvents_.emit("UNIT_FLAGS", {uid});
-            }
-        }
-        else if (key == ufi.bytes0) {
-            unit->setPowerType(static_cast<uint8_t>((val >> 24) & 0xFF));
-        } else if (key == ufi.displayId) {
-            unit->setDisplayId(val);
-            if (owner_.addonEventCallback_) {
-                auto uid = owner_.guidToUnitId(block.guid);
-                if (!uid.empty())
-                    pendingEvents_.emit("UNIT_MODEL_CHANGED", {uid});
-            }
-        }
-        else if (key == ufi.npcFlags) { unit->setNpcFlags(val); }
-        else if (key == ufi.npcEmoteState) { unit->setNpcEmoteState(val); }
-        else if (key == ufi.dynFlags) {
-            unit->setDynamicFlags(val);
-            if (block.objectType == ObjectType::UNIT &&
-                ((val & UNIT_DYNFLAG_DEAD) != 0 || (val & UNIT_DYNFLAG_LOOTABLE) != 0)) {
-                unitInitiallyDead = true;
-            }
-        }
-        // Power/maxpower range checks AFTER all specific fields
-        else if (key >= ufi.powerBase && key < ufi.powerBase + 7) {
-            unit->setPowerByType(static_cast<uint8_t>(key - ufi.powerBase), val);
-        } else if (key >= ufi.maxPowerBase && key < ufi.maxPowerBase + 7) {
-            unit->setMaxPowerByType(static_cast<uint8_t>(key - ufi.maxPowerBase), val);
-        }
-        else if (key == ufi.mountDisplayId) {
-            if (block.guid == owner_.playerGuid) {
-                detectPlayerMountChange(val, block.fields);
-            }
-            unit->setMountDisplayId(val);
-        }
-    }
-    return unitInitiallyDead;
-}
-
-// Consolidates player-death state into one place so both the health==0 and
-// dynFlags UNIT_DYNFLAG_DEAD paths share the same corpse-caching logic.
-// Classic WoW does not send SMSG_DEATH_RELEASE_LOC, so this cached position
-// is the primary source for canReclaimCorpse().
-void EntityController::markPlayerDead(const char* source) {
-    owner_.playerDead_ = true;
-    owner_.releasedSpirit_ = false;
-    // owner_.movementInfo is canonical (x=north, y=west); corpseX_/Y_ are
-    // raw server coords (x=west, y=north) — swap axes.
-    owner_.corpseX_     = owner_.movementInfo.y;
-    owner_.corpseY_     = owner_.movementInfo.x;
-    owner_.corpseZ_     = owner_.movementInfo.z;
-    owner_.corpseMapId_ = owner_.currentMapId_;
-    LOG_INFO("Player died (", source, "). Corpse cached at server=(",
-             owner_.corpseX_, ",", owner_.corpseY_, ",", owner_.corpseZ_,
-             ") map=", owner_.corpseMapId_);
-}
-
-// 3c: Apply unit fields during VALUES update — tracks health/power/display changes
-//     and fires events for transitions (death, resurrect, level up, etc.).
-EntityController::UnitFieldUpdateResult EntityController::applyUnitFieldsOnUpdate(
-        const UpdateBlock& block, const std::shared_ptr<Entity>& entity,
-        std::shared_ptr<Unit>& unit, const UnitFieldIndices& ufi) {
-    UnitFieldUpdateResult result;
-    result.oldDisplayId = unit->getDisplayId();
-    uint32_t oldHealth = unit->getHealth();
-    constexpr uint32_t UNIT_DYNFLAG_DEAD = 0x0008;
-
-    for (const auto& [key, val] : block.fields) {
-        if (key == ufi.health) {
-            unit->setHealth(val);
-            result.healthChanged = true;
-            if (val == 0) {
-                if (owner_.combatHandler_ && block.guid == owner_.combatHandler_->getAutoAttackTargetGuid()) {
-                    owner_.stopAutoAttack();
-                }
-                if (owner_.combatHandler_) owner_.combatHandler_->removeHostileAttacker(block.guid);
-                if (block.guid == owner_.playerGuid) {
-                    markPlayerDead("health=0");
-                    owner_.stopAutoAttack();
-                    pendingEvents_.emit("PLAYER_DEAD", {});
-                }
-                if ((entity->getType() == ObjectType::UNIT || entity->getType() == ObjectType::PLAYER) && owner_.npcDeathCallback_) {
-                    owner_.npcDeathCallback_(block.guid);
-                    result.npcDeathNotified = true;
-                }
-            } else if (oldHealth == 0 && val > 0) {
-                if (block.guid == owner_.playerGuid) {
-                    bool wasGhost = owner_.releasedSpirit_;
-                    owner_.playerDead_ = false;
-                    if (!wasGhost) {
-                        LOG_INFO("Player resurrected!");
-                        pendingEvents_.emit("PLAYER_ALIVE", {});
-                    } else {
-                        LOG_INFO("Player entered ghost form");
-                        owner_.releasedSpirit_ = false;
-                        pendingEvents_.emit("PLAYER_UNGHOST", {});
-                    }
-                }
-                if ((entity->getType() == ObjectType::UNIT || entity->getType() == ObjectType::PLAYER) && owner_.npcRespawnCallback_) {
-                    owner_.npcRespawnCallback_(block.guid);
-                    result.npcRespawnNotified = true;
-                }
-            }
-        // Specific fields checked BEFORE power/maxpower range checks
-        // (Classic packs maxHealth/level/faction adjacent to power indices)
-        } else if (key == ufi.maxHealth) { unit->setMaxHealth(val); result.healthChanged = true; }
-        else if (key == ufi.bytes0) {
-            uint8_t oldPT = unit->getPowerType();
-            unit->setPowerType(static_cast<uint8_t>((val >> 24) & 0xFF));
-            if (unit->getPowerType() != oldPT) {
-                auto uid = owner_.guidToUnitId(block.guid);
-                if (!uid.empty())
-                    pendingEvents_.emit("UNIT_DISPLAYPOWER", {uid});
-            }
-        } else if (key == ufi.flags) {
-            uint32_t oldFlags = unit->getUnitFlags();
-            unit->setUnitFlags(val);
-            // Detect stun state change on local player
-            constexpr uint32_t UNIT_FLAG_STUNNED = 0x00040000;
-            if (block.guid == owner_.playerGuid && owner_.stunStateCallback_) {
-                bool wasStunned = (oldFlags & UNIT_FLAG_STUNNED) != 0;
-                bool nowStunned = (val & UNIT_FLAG_STUNNED) != 0;
-                if (wasStunned != nowStunned) {
-                    owner_.stunStateCallback_(nowStunned);
-                }
-            }
-            // Detect stealth state change on local player
-            constexpr uint32_t UNIT_FLAG_SNEAKING = 0x02000000;
-            if (block.guid == owner_.playerGuid && owner_.stealthStateCallback_) {
-                bool wasStealth = (oldFlags & UNIT_FLAG_SNEAKING) != 0;
-                bool nowStealth = (val & UNIT_FLAG_SNEAKING) != 0;
-                if (wasStealth != nowStealth) {
-                    owner_.stealthStateCallback_(nowStealth);
-                }
-            }
-        }
-        else if (ufi.bytes1 != 0xFFFF && key == ufi.bytes1 && block.guid == owner_.playerGuid) {
-            uint8_t newForm = static_cast<uint8_t>((val >> 24) & 0xFF);
-            if (newForm != owner_.shapeshiftFormId_) {
-                owner_.shapeshiftFormId_ = newForm;
-                LOG_INFO("Shapeshift form changed: ", static_cast<int>(newForm));
-                    pendingEvents_.emit("UPDATE_SHAPESHIFT_FORM", {});
-                    pendingEvents_.emit("UPDATE_SHAPESHIFT_FORMS", {});
-            }
-        }
-        else if (key == ufi.dynFlags) {
-            uint32_t oldDyn = unit->getDynamicFlags();
-            unit->setDynamicFlags(val);
-            if (block.guid == owner_.playerGuid) {
-                bool wasDead = (oldDyn & UNIT_DYNFLAG_DEAD) != 0;
-                bool nowDead = (val & UNIT_DYNFLAG_DEAD) != 0;
-                if (!wasDead && nowDead) {
-                    markPlayerDead("dynFlags");
-                } else if (wasDead && !nowDead) {
-                    owner_.playerDead_ = false;
-                    owner_.releasedSpirit_ = false;
-                    owner_.selfResAvailable_ = false;
-                    LOG_INFO("Player resurrected (dynamic flags)");
-                }
-            } else if (entity->getType() == ObjectType::UNIT || entity->getType() == ObjectType::PLAYER) {
-                bool wasDead = (oldDyn & UNIT_DYNFLAG_DEAD) != 0;
-                bool nowDead = (val & UNIT_DYNFLAG_DEAD) != 0;
-                if (!wasDead && nowDead) {
-                    if (!result.npcDeathNotified && owner_.npcDeathCallback_) {
-                        owner_.npcDeathCallback_(block.guid);
-                        result.npcDeathNotified = true;
-                    }
-                } else if (wasDead && !nowDead) {
-                    if (!result.npcRespawnNotified && owner_.npcRespawnCallback_) {
-                        owner_.npcRespawnCallback_(block.guid);
-                        result.npcRespawnNotified = true;
-                    }
-                }
-            }
-        } else if (key == ufi.level) {
-            uint32_t oldLvl = unit->getLevel();
-            unit->setLevel(val);
-            if (val != oldLvl) {
-                auto uid = owner_.guidToUnitId(block.guid);
-                if (!uid.empty())
-                    pendingEvents_.emit("UNIT_LEVEL", {uid});
-            }
-            if (block.guid != owner_.playerGuid &&
-                entity->getType() == ObjectType::PLAYER &&
-                val > oldLvl && oldLvl > 0 &&
-                owner_.otherPlayerLevelUpCallback_) {
-                owner_.otherPlayerLevelUpCallback_(block.guid, val);
-            }
-        }
-        else if (key == ufi.faction) {
-            unit->setFactionTemplate(val);
-            unit->setHostile(owner_.isHostileFaction(val));
-        } else if (key == ufi.displayId) {
-            if (val != unit->getDisplayId()) {
-                unit->setDisplayId(val);
-                result.displayIdChanged = true;
-            }
-        } else if (key == ufi.mountDisplayId) {
-            if (block.guid == owner_.playerGuid) {
-                detectPlayerMountChange(val, block.fields);
-            }
-            unit->setMountDisplayId(val);
-        } else if (key == ufi.npcFlags) { unit->setNpcFlags(val); }
-        else if (key == ufi.npcEmoteState) {
-            uint32_t oldEmote = unit->getNpcEmoteState();
-            unit->setNpcEmoteState(val);
-            // Fire emote animation callback so entity_spawner can update the NPC's idle anim
-            if (val != oldEmote && owner_.emoteAnimCallback_) {
-                owner_.emoteAnimCallback_(block.guid, val);
-            }
-        }
-        // Power/maxpower range checks AFTER all specific fields
-        else if (key >= ufi.powerBase && key < ufi.powerBase + 7) {
-            unit->setPowerByType(static_cast<uint8_t>(key - ufi.powerBase), val);
-            result.powerChanged = true;
-        } else if (key >= ufi.maxPowerBase && key < ufi.maxPowerBase + 7) {
-            unit->setMaxPowerByType(static_cast<uint8_t>(key - ufi.maxPowerBase), val);
-            result.powerChanged = true;
-        }
-    }
-
-    // Fire UNIT_HEALTH / UNIT_POWER events for Lua addons
-    if ((result.healthChanged || result.powerChanged)) {
-        auto unitId = owner_.guidToUnitId(block.guid);
-        if (!unitId.empty()) {
-            if (result.healthChanged) pendingEvents_.emit("UNIT_HEALTH", {unitId});
-            if (result.powerChanged) {
-                pendingEvents_.emit("UNIT_POWER", {unitId});
-                // When player power changes, action bar usability may change
-                if (block.guid == owner_.playerGuid) {
-                    pendingEvents_.emit("ACTIONBAR_UPDATE_USABLE", {});
-                    pendingEvents_.emit("SPELL_UPDATE_USABLE", {});
-                }
-            }
-        }
-    }
-
-    // Fire player health callback for wounded-idle animation
-    if (result.healthChanged && block.guid == owner_.playerGuid && owner_.playerHealthCallback_) {
-        owner_.playerHealthCallback_(unit->getHealth(), unit->getMaxHealth());
-    }
-
-    return result;
-}
-
-//     Apply player stat fields (XP, coinage, combat stats, etc.).
-//     Shared between CREATE and VALUES — isCreate controls event firing differences.
-bool EntityController::applyPlayerStatFields(const std::map<uint16_t, uint32_t>& fields,
-                                               const PlayerFieldIndices& pfi,
-                                               bool isCreate) {
-    bool slotsChanged = false;
-    for (const auto& [key, val] : fields) {
-        if (key == pfi.xp) {
-            owner_.playerXp_ = val;
-            if (!isCreate) {
-                LOG_DEBUG("XP updated: ", val);
-                pendingEvents_.emit("PLAYER_XP_UPDATE", {std::to_string(val)});
-            }
-        }
-        else if (key == pfi.nextXp) {
-            owner_.playerNextLevelXp_ = val;
-            if (!isCreate) LOG_DEBUG("Next level XP updated: ", val);
-        }
-        else if (pfi.restedXp != 0xFFFF && key == pfi.restedXp) {
-            owner_.playerRestedXp_ = val;
-            if (!isCreate) pendingEvents_.emit("UPDATE_EXHAUSTION", {});
-        }
-        else if (key == pfi.level) {
-            owner_.serverPlayerLevel_ = val;
-            if (!isCreate) LOG_DEBUG("Level updated: ", val);
-            for (auto& ch : owner_.characters) {
-                if (ch.guid == owner_.playerGuid) { ch.level = val; break; }
-            }
-        }
-        else if (key == pfi.coinage) {
-            uint64_t oldMoney = owner_.playerMoneyCopper_;
-            owner_.playerMoneyCopper_ = val;
-            LOG_DEBUG("Money ", isCreate ? "set from update fields: " : "updated via VALUES: ", val, " copper");
-            if (val != oldMoney)
-                pendingEvents_.emit("PLAYER_MONEY", {});
-        }
-        else if (pfi.honor != 0xFFFF && key == pfi.honor) {
-            owner_.playerHonorPoints_ = val;
-            LOG_DEBUG("Honor points ", isCreate ? "from update fields: " : "updated: ", val);
-        }
-        else if (pfi.arena != 0xFFFF && key == pfi.arena) {
-            owner_.playerArenaPoints_ = val;
-            LOG_DEBUG("Arena points ", isCreate ? "from update fields: " : "updated: ", val);
-        }
-        else if (pfi.armor != 0xFFFF && key == pfi.armor) {
-            owner_.playerArmorRating_ = static_cast<int32_t>(val);
-            if (isCreate) LOG_DEBUG("Armor rating from update fields: ", owner_.playerArmorRating_);
-        }
-        else if (pfi.armor != 0xFFFF && key > pfi.armor && key <= pfi.armor + 6) {
-            owner_.playerResistances_[key - pfi.armor - 1] = static_cast<int32_t>(val);
-        }
-        else if (pfi.pBytes2 != 0xFFFF && key == pfi.pBytes2) {
-            uint8_t bankBagSlots = static_cast<uint8_t>((val >> 16) & 0xFF);
-            owner_.inventory.setPurchasedBankBagSlots(bankBagSlots);
-            // Byte 3 (bits 24-31): REST_STATE
-            // 0 = not resting, 1 = REST_TYPE_IN_TAVERN, 2 = REST_TYPE_IN_CITY
-            uint8_t restStateByte = static_cast<uint8_t>((val >> 24) & 0xFF);
-            if (isCreate) {
-                LOG_WARNING("PLAYER_BYTES_2 (CREATE): raw=0x", std::hex, val, std::dec,
-                           " bankBagSlots=", static_cast<int>(bankBagSlots));
-                bool wasResting = owner_.isResting_;
-                owner_.isResting_ = (restStateByte != 0);
-                if (owner_.isResting_ != wasResting) {
-                    pendingEvents_.emit("UPDATE_EXHAUSTION", {});
-                    pendingEvents_.emit("PLAYER_UPDATE_RESTING", {});
-                }
-            } else {
-                // Byte 0 (bits 0-7): facial hair / piercings
-                uint8_t facialHair = static_cast<uint8_t>(val & 0xFF);
-                for (auto& ch : owner_.characters) {
-                    if (ch.guid == owner_.playerGuid) { ch.facialFeatures = facialHair; break; }
-                }
-                LOG_DEBUG("PLAYER_BYTES_2 (VALUES): raw=0x", std::hex, val, std::dec,
-                           " bankBagSlots=", static_cast<int>(bankBagSlots),
-                           " facial=", static_cast<int>(facialHair));
-                owner_.isResting_ = (restStateByte != 0);
-                if (owner_.appearanceChangedCallback_)
-                    owner_.appearanceChangedCallback_();
-            }
-        }
-        else if (pfi.chosenTitle != 0xFFFF && key == pfi.chosenTitle) {
-            owner_.chosenTitleBit_ = static_cast<int32_t>(val);
-            LOG_DEBUG("PLAYER_CHOSEN_TITLE ", isCreate ? "from update fields: " : "updated: ",
-                      owner_.chosenTitleBit_);
-        }
-        // VALUES-only fields: PLAYER_BYTES (appearance) and PLAYER_FLAGS (ghost state)
-        else if (!isCreate && pfi.pBytes != 0xFFFF && key == pfi.pBytes) {
-            // PLAYER_BYTES changed (barber shop, polymorph, etc.)
-            for (auto& ch : owner_.characters) {
-                if (ch.guid == owner_.playerGuid) { ch.appearanceBytes = val; break; }
-            }
-            if (owner_.appearanceChangedCallback_)
-                owner_.appearanceChangedCallback_();
-        }
-        else if (!isCreate && key == pfi.playerFlags) {
-            constexpr uint32_t PLAYER_FLAGS_GHOST = 0x00000010;
-            bool wasGhost = owner_.releasedSpirit_;
-            bool nowGhost = (val & PLAYER_FLAGS_GHOST) != 0;
-            if (!wasGhost && nowGhost) {
-                owner_.releasedSpirit_ = true;
-                LOG_INFO("Player entered ghost form (PLAYER_FLAGS)");
-                if (owner_.ghostStateCallback_) owner_.ghostStateCallback_(true);
-            } else if (wasGhost && !nowGhost) {
-                owner_.releasedSpirit_ = false;
-                owner_.playerDead_ = false;
-                owner_.repopPending_ = false;
-                owner_.resurrectPending_ = false;
-                owner_.selfResAvailable_ = false;
-                owner_.corpseMapId_ = 0;  // corpse reclaimed
-                owner_.corpseGuid_ = 0;
-                owner_.corpseReclaimAvailableMs_ = 0;
-                LOG_INFO("Player resurrected (PLAYER_FLAGS ghost cleared)");
-                pendingEvents_.emit("PLAYER_ALIVE", {});
-                if (owner_.ghostStateCallback_) owner_.ghostStateCallback_(false);
-            }
-            pendingEvents_.emit("PLAYER_FLAGS_CHANGED", {});
-        }
-        else if (pfi.meleeAP  != 0xFFFF && key == pfi.meleeAP)  { owner_.playerMeleeAP_  = static_cast<int32_t>(val); }
-        else if (pfi.rangedAP != 0xFFFF && key == pfi.rangedAP) { owner_.playerRangedAP_ = static_cast<int32_t>(val); }
-        else if (pfi.spDmg1   != 0xFFFF && key >= pfi.spDmg1 && key < pfi.spDmg1 + 7) {
-            owner_.playerSpellDmgBonus_[key - pfi.spDmg1] = static_cast<int32_t>(val);
-        }
-        else if (pfi.healBonus != 0xFFFF && key == pfi.healBonus) { owner_.playerHealBonus_ = static_cast<int32_t>(val); }
-        // Percentage stats are stored as IEEE 754 floats packed into uint32 update fields.
-        // memcpy reinterprets the bits; clamp to [0..100] to guard against NaN/Inf from
-        // corrupted packets reaching the UI (display-only, no gameplay logic depends on these).
-        else if (pfi.blockPct != 0xFFFF && key == pfi.blockPct) { std::memcpy(&owner_.playerBlockPct_, &val, 4); owner_.playerBlockPct_ = std::clamp(owner_.playerBlockPct_, 0.0f, 100.0f); }
-        else if (pfi.dodgePct != 0xFFFF && key == pfi.dodgePct) { std::memcpy(&owner_.playerDodgePct_, &val, 4); owner_.playerDodgePct_ = std::clamp(owner_.playerDodgePct_, 0.0f, 100.0f); }
-        else if (pfi.parryPct != 0xFFFF && key == pfi.parryPct) { std::memcpy(&owner_.playerParryPct_, &val, 4); owner_.playerParryPct_ = std::clamp(owner_.playerParryPct_, 0.0f, 100.0f); }
-        else if (pfi.critPct  != 0xFFFF && key == pfi.critPct)  { std::memcpy(&owner_.playerCritPct_,  &val, 4); owner_.playerCritPct_  = std::clamp(owner_.playerCritPct_,  0.0f, 100.0f); }
-        else if (pfi.rangedCritPct != 0xFFFF && key == pfi.rangedCritPct) { std::memcpy(&owner_.playerRangedCritPct_, &val, 4); owner_.playerRangedCritPct_ = std::clamp(owner_.playerRangedCritPct_, 0.0f, 100.0f); }
-        else if (pfi.sCrit1   != 0xFFFF && key >= pfi.sCrit1 && key < pfi.sCrit1 + 7) {
-            std::memcpy(&owner_.playerSpellCritPct_[key - pfi.sCrit1], &val, 4);
-        }
-        else if (pfi.rating1  != 0xFFFF && key >= pfi.rating1 && key < pfi.rating1 + 25) {
-            owner_.playerCombatRatings_[key - pfi.rating1] = static_cast<int32_t>(val);
-        }
-        else {
-            for (int si = 0; si < 5; ++si) {
-                if (pfi.stats[si] != 0xFFFF && key == pfi.stats[si]) {
-                    owner_.playerStats_[si] = static_cast<int32_t>(val);
-                    break;
-                }
-            }
-        }
-        // Do not synthesize quest-log entries from raw update-field slots.
-        // Slot layouts differ on some classic-family realms and can produce
-        // phantom "already accepted" quests that block quest acceptance.
-    }
-    if (owner_.applyInventoryFields(fields)) slotsChanged = true;
-    return slotsChanged;
-}
-
-//     Dispatch entity spawn callbacks for units/players.
-//     Consolidates player/creature spawn callback invocation from CREATE and VALUES handlers.
-//     isDead = unitInitiallyDead (CREATE) or computed isDeadNow && !npcDeathNotified (VALUES).
-void EntityController::dispatchEntitySpawn(uint64_t guid, ObjectType objectType,
-                                            const std::shared_ptr<Entity>& entity,
-                                            const std::shared_ptr<Unit>& unit,
-                                            bool isDead) {
-    if (objectType == ObjectType::PLAYER && guid == owner_.playerGuid) {
-        return;  // Skip local player — spawned separately via spawnPlayerCharacter()
-    }
-    if (objectType == ObjectType::PLAYER) {
-        if (owner_.playerSpawnCallback_) {
-            uint8_t race = 0, gender = 0, facial = 0;
-            uint32_t appearanceBytes = 0;
-            if (extractPlayerAppearance(entity->getFields(), race, gender, appearanceBytes, facial)) {
-                owner_.playerSpawnCallback_(guid, unit->getDisplayId(), race, gender,
-                                    appearanceBytes, facial,
-                                    unit->getX(), unit->getY(), unit->getZ(), unit->getOrientation());
-            } else {
-                LOG_WARNING("[Spawn] PLAYER guid=0x", std::hex, guid, std::dec,
-                          " displayId=", unit->getDisplayId(), " appearance extraction failed — model will not render");
-            }
-        }
-    } else if (owner_.creatureSpawnCallback_) {
-        LOG_DEBUG("[Spawn] UNIT guid=0x", std::hex, guid, std::dec,
-                  " displayId=", unit->getDisplayId(), " at (",
-                  unit->getX(), ",", unit->getY(), ",", unit->getZ(), ")");
-        float unitScale = 1.0f;
-        uint16_t scaleIdx = fieldIndex(UF::OBJECT_FIELD_SCALE_X);
-        if (scaleIdx != 0xFFFF) {
-            // raw == 0 means the field was never populated (IEEE 754 0.0f is all-zero bits).
-            // Keep the default 1.0f rather than setting scale to 0 and making the entity invisible.
-            uint32_t raw = entity->getField(scaleIdx);
-            if (raw != 0) {
-                std::memcpy(&unitScale, &raw, sizeof(float));
-                if (unitScale <= 0.01f || unitScale > 100.0f) unitScale = 1.0f;
-            }
-        }
-        owner_.creatureSpawnCallback_(guid, unit->getDisplayId(),
-            unit->getX(), unit->getY(), unit->getZ(), unit->getOrientation(), unitScale);
-    }
-    if (isDead && owner_.npcDeathCallback_) {
-        owner_.npcDeathCallback_(guid);
-    }
-    // Query quest giver status for NPCs with questgiver flag (0x02)
-    if (objectType == ObjectType::UNIT && (unit->getNpcFlags() & 0x02) && owner_.socket) {
-        network::Packet qsPkt(wireOpcode(Opcode::CMSG_QUESTGIVER_STATUS_QUERY));
-        qsPkt.writeUInt64(guid);
-        owner_.socket->send(qsPkt);
-    }
-}
-
-// Track online item/container objects during CREATE.
-void EntityController::trackItemOnCreate(const UpdateBlock& block, bool& newItemCreated) {
-    auto entryIt = block.fields.find(fieldIndex(UF::OBJECT_FIELD_ENTRY));
-    auto stackIt = block.fields.find(fieldIndex(UF::ITEM_FIELD_STACK_COUNT));
-    auto durIt   = block.fields.find(fieldIndex(UF::ITEM_FIELD_DURABILITY));
-    auto maxDurIt= block.fields.find(fieldIndex(UF::ITEM_FIELD_MAXDURABILITY));
-    const uint16_t enchBase = (fieldIndex(UF::ITEM_FIELD_STACK_COUNT) != 0xFFFF)
-        ? static_cast<uint16_t>(fieldIndex(UF::ITEM_FIELD_STACK_COUNT) + 8u) : 0xFFFFu;
-    auto permEnchIt  = (enchBase != 0xFFFF) ? block.fields.find(enchBase)       : block.fields.end();
-    auto tempEnchIt  = (enchBase != 0xFFFF) ? block.fields.find(enchBase + 3u)  : block.fields.end();
-    auto sock1EnchIt = (enchBase != 0xFFFF) ? block.fields.find(enchBase + 6u)  : block.fields.end();
-    auto sock2EnchIt = (enchBase != 0xFFFF) ? block.fields.find(enchBase + 9u)  : block.fields.end();
-    auto sock3EnchIt = (enchBase != 0xFFFF) ? block.fields.find(enchBase + 12u) : block.fields.end();
-    if (entryIt != block.fields.end() && entryIt->second != 0) {
-        // Preserve existing info when doing partial updates
-        GameHandler::OnlineItemInfo info = owner_.onlineItems_.count(block.guid)
-            ? owner_.onlineItems_[block.guid] : GameHandler::OnlineItemInfo{};
-        info.entry = entryIt->second;
-        if (stackIt    != block.fields.end()) info.stackCount            = stackIt->second;
-        if (durIt      != block.fields.end()) info.curDurability         = durIt->second;
-        if (maxDurIt   != block.fields.end()) info.maxDurability         = maxDurIt->second;
-        if (permEnchIt != block.fields.end()) info.permanentEnchantId    = permEnchIt->second;
-        if (tempEnchIt != block.fields.end()) info.temporaryEnchantId    = tempEnchIt->second;
-        if (sock1EnchIt != block.fields.end()) info.socketEnchantIds[0]  = sock1EnchIt->second;
-        if (sock2EnchIt != block.fields.end()) info.socketEnchantIds[1]  = sock2EnchIt->second;
-        if (sock3EnchIt != block.fields.end()) info.socketEnchantIds[2]  = sock3EnchIt->second;
-        auto [itemIt, isNew] = owner_.onlineItems_.insert_or_assign(block.guid, info);
-        if (isNew) newItemCreated = true;
-        owner_.queryItemInfo(info.entry, block.guid);
-    }
-    // Extract container slot GUIDs for bags
-    if (block.objectType == ObjectType::CONTAINER) {
-        owner_.extractContainerFields(block.guid, block.fields);
-    }
-}
-
-// Update item stack count / durability / enchants for existing items during VALUES.
-void EntityController::updateItemOnValuesUpdate(const UpdateBlock& block,
-                                                  const std::shared_ptr<Entity>& entity) {
-    bool inventoryChanged = false;
-    const uint16_t itemStackField   = fieldIndex(UF::ITEM_FIELD_STACK_COUNT);
-    const uint16_t itemDurField     = fieldIndex(UF::ITEM_FIELD_DURABILITY);
-    const uint16_t itemMaxDurField  = fieldIndex(UF::ITEM_FIELD_MAXDURABILITY);
-    const uint16_t containerNumSlotsField = fieldIndex(UF::CONTAINER_FIELD_NUM_SLOTS);
-    const uint16_t containerSlot1Field = fieldIndex(UF::CONTAINER_FIELD_SLOT_1);
-    // ITEM_FIELD_ENCHANTMENT starts 8 fields after ITEM_FIELD_STACK_COUNT (fixed offset
-    // across all expansions: +DURATION, +5×SPELL_CHARGES, +FLAGS = +8).
-    // Slot 0 = permanent (field +0), slot 1 = temp (+3), slots 2-4 = sockets (+6,+9,+12).
-    const uint16_t itemEnchBase      = (itemStackField != 0xFFFF) ? (itemStackField + 8u)  : 0xFFFF;
-    const uint16_t itemPermEnchField = itemEnchBase;
-    const uint16_t itemTempEnchField = (itemEnchBase != 0xFFFF) ? (itemEnchBase + 3u)  : 0xFFFF;
-    const uint16_t itemSock1EnchField= (itemEnchBase != 0xFFFF) ? (itemEnchBase + 6u)  : 0xFFFF;
-    const uint16_t itemSock2EnchField= (itemEnchBase != 0xFFFF) ? (itemEnchBase + 9u)  : 0xFFFF;
-    const uint16_t itemSock3EnchField= (itemEnchBase != 0xFFFF) ? (itemEnchBase + 12u) : 0xFFFF;
-
-    auto it = owner_.onlineItems_.find(block.guid);
-    bool isItemInInventory = (it != owner_.onlineItems_.end());
-
-    for (const auto& [key, val] : block.fields) {
-        if (key == itemStackField && isItemInInventory) {
-            if (it->second.stackCount != val) {
-                it->second.stackCount = val;
-                inventoryChanged = true;
-            }
-        } else if (key == itemDurField && isItemInInventory) {
-            if (it->second.curDurability != val) {
-                const uint32_t prevDur = it->second.curDurability;
-                it->second.curDurability = val;
-                inventoryChanged = true;
-                LOG_DEBUG("Item durability update: guid=0x", std::hex, block.guid,
-                          std::dec, " dur ", prevDur, "->", val, "/", it->second.maxDurability);
-                // Warn once when durability drops below 20% for an equipped item.
-                const uint32_t maxDur = it->second.maxDurability;
-                if (maxDur > 0 && val < maxDur / 5u && prevDur >= maxDur / 5u) {
-                    // Check if this item is in an equip slot (not bag inventory).
-                    bool isEquipped = false;
-                    for (uint64_t slotGuid : owner_.equipSlotGuids_) {
-                        if (slotGuid == block.guid) { isEquipped = true; break; }
-                    }
-                    if (isEquipped) {
-                        std::string itemName;
-                        const auto* info = owner_.getItemInfo(it->second.entry);
-                        if (info) itemName = info->name;
-                        char buf[128];
-                        if (!itemName.empty())
-                            std::snprintf(buf, sizeof(buf), "%s is about to break!", itemName.c_str());
-                        else
-                            std::snprintf(buf, sizeof(buf), "An equipped item is about to break!");
-                        owner_.addUIError(buf);
-                        owner_.addSystemChatMessage(buf);
-                    }
-                }
-            }
-        } else if (key == itemMaxDurField && isItemInInventory) {
-            if (it->second.maxDurability != val) {
-                it->second.maxDurability = val;
-                inventoryChanged = true;
-            }
-        } else if (isItemInInventory && itemPermEnchField != 0xFFFF && key == itemPermEnchField) {
-            if (it->second.permanentEnchantId != val) {
-                it->second.permanentEnchantId = val;
-                inventoryChanged = true;
-            }
-        } else if (isItemInInventory && itemTempEnchField != 0xFFFF && key == itemTempEnchField) {
-            if (it->second.temporaryEnchantId != val) {
-                it->second.temporaryEnchantId = val;
-                inventoryChanged = true;
-            }
-        } else if (isItemInInventory && itemSock1EnchField != 0xFFFF && key == itemSock1EnchField) {
-            if (it->second.socketEnchantIds[0] != val) {
-                it->second.socketEnchantIds[0] = val;
-                inventoryChanged = true;
-            }
-        } else if (isItemInInventory && itemSock2EnchField != 0xFFFF && key == itemSock2EnchField) {
-            if (it->second.socketEnchantIds[1] != val) {
-                it->second.socketEnchantIds[1] = val;
-                inventoryChanged = true;
-            }
-        } else if (isItemInInventory && itemSock3EnchField != 0xFFFF && key == itemSock3EnchField) {
-            if (it->second.socketEnchantIds[2] != val) {
-                it->second.socketEnchantIds[2] = val;
-                inventoryChanged = true;
-            }
-        }
-    }
-    // Update container slot GUIDs on bag content changes
-    if (entity && entity->getType() == ObjectType::CONTAINER) {
-        for (const auto& [key, _] : block.fields) {
-            if ((containerNumSlotsField != 0xFFFF && key == containerNumSlotsField) ||
-                (containerSlot1Field != 0xFFFF && key >= containerSlot1Field && key < containerSlot1Field + 72)) {
-                inventoryChanged = true;
-                break;
-            }
-        }
-        owner_.extractContainerFields(block.guid, block.fields);
-    }
-    if (inventoryChanged) {
-        owner_.rebuildOnlineInventory();
-        pendingEvents_.emit("BAG_UPDATE", {});
-        pendingEvents_.emit("UNIT_INVENTORY_CHANGED", {"player"});
-    }
-}
-
-// ============================================================
-// Object-type handler struct definitions
-// ============================================================
-
-struct EntityController::UnitTypeHandler : EntityController::IObjectTypeHandler {
-    EntityController& ctl_;
-    explicit UnitTypeHandler(EntityController& c) : ctl_(c) {}
-    void onCreate(const UpdateBlock& block, std::shared_ptr<Entity>& entity, bool&) override { ctl_.onCreateUnit(block, entity); }
-    void onValuesUpdate(const UpdateBlock& block, std::shared_ptr<Entity>& entity) override { ctl_.onValuesUpdateUnit(block, entity); }
-};
-
-struct EntityController::PlayerTypeHandler : EntityController::IObjectTypeHandler {
-    EntityController& ctl_;
-    explicit PlayerTypeHandler(EntityController& c) : ctl_(c) {}
-    void onCreate(const UpdateBlock& block, std::shared_ptr<Entity>& entity, bool&) override { ctl_.onCreatePlayer(block, entity); }
-    void onValuesUpdate(const UpdateBlock& block, std::shared_ptr<Entity>& entity) override { ctl_.onValuesUpdatePlayer(block, entity); }
-};
-
-struct EntityController::GameObjectTypeHandler : EntityController::IObjectTypeHandler {
-    EntityController& ctl_;
-    explicit GameObjectTypeHandler(EntityController& c) : ctl_(c) {}
-    void onCreate(const UpdateBlock& block, std::shared_ptr<Entity>& entity, bool&) override { ctl_.onCreateGameObject(block, entity); }
-    void onValuesUpdate(const UpdateBlock& block, std::shared_ptr<Entity>& entity) override { ctl_.onValuesUpdateGameObject(block, entity); }
-};
-
-struct EntityController::ItemTypeHandler : EntityController::IObjectTypeHandler {
-    EntityController& ctl_;
-    explicit ItemTypeHandler(EntityController& c) : ctl_(c) {}
-    void onCreate(const UpdateBlock& block, std::shared_ptr<Entity>& /*entity*/, bool& newItemCreated) override { ctl_.onCreateItem(block, newItemCreated); }
-    void onValuesUpdate(const UpdateBlock& block, std::shared_ptr<Entity>& entity) override { ctl_.onValuesUpdateItem(block, entity); }
-};
-
-struct EntityController::CorpseTypeHandler : EntityController::IObjectTypeHandler {
-    EntityController& ctl_;
-    explicit CorpseTypeHandler(EntityController& c) : ctl_(c) {}
-    void onCreate(const UpdateBlock& block, std::shared_ptr<Entity>& /*entity*/, bool&) override { ctl_.onCreateCorpse(block); }
-};
-
-// ============================================================
-// Handler registry infrastructure
-// ============================================================
-
-void EntityController::initTypeHandlers() {
-    typeHandlers_[static_cast<uint8_t>(ObjectType::UNIT)] = std::make_unique<UnitTypeHandler>(*this);
-    typeHandlers_[static_cast<uint8_t>(ObjectType::PLAYER)] = std::make_unique<PlayerTypeHandler>(*this);
-    typeHandlers_[static_cast<uint8_t>(ObjectType::GAMEOBJECT)] = std::make_unique<GameObjectTypeHandler>(*this);
-    typeHandlers_[static_cast<uint8_t>(ObjectType::ITEM)] = std::make_unique<ItemTypeHandler>(*this);
-    typeHandlers_[static_cast<uint8_t>(ObjectType::CONTAINER)] = std::make_unique<ItemTypeHandler>(*this);
-    typeHandlers_[static_cast<uint8_t>(ObjectType::CORPSE)] = std::make_unique<CorpseTypeHandler>(*this);
-}
-
-EntityController::IObjectTypeHandler* EntityController::getTypeHandler(ObjectType type) const {
-    auto it = typeHandlers_.find(static_cast<uint8_t>(type));
-    return it != typeHandlers_.end() ? it->second.get() : nullptr;
-}
-
-// ============================================================
-// Deferred event bus flush
-// ============================================================
-
-void EntityController::flushPendingEvents() {
-    for (const auto& [name, args] : pendingEvents_.events) {
-        owner_.fireAddonEvent(name, args);
-    }
-    pendingEvents_.clear();
-}
-
-// ============================================================
-// Type-specific CREATE handlers
-// ============================================================
-
-void EntityController::onCreateUnit(const UpdateBlock& block, std::shared_ptr<Entity>& entity) {
-    // Name query for creatures
-    auto it = block.fields.find(fieldIndex(UF::OBJECT_FIELD_ENTRY));
-    if (it != block.fields.end() && it->second != 0) {
-        auto unit = std::static_pointer_cast<Unit>(entity);
-        unit->setEntry(it->second);
-        std::string cached = getCachedCreatureName(it->second);
-        if (!cached.empty()) {
-            unit->setName(cached);
-        }
-        queryCreatureInfo(it->second, block.guid);
-    }
-
-    // Unit fields
-    auto unit = std::static_pointer_cast<Unit>(entity);
-    UnitFieldIndices ufi = UnitFieldIndices::resolve();
-    bool unitInitiallyDead = applyUnitFieldsOnCreate(block, unit, ufi);
-
-    // Hostility
-    unit->setHostile(owner_.isHostileFaction(unit->getFactionTemplate()));
-
-    // Spawn dispatch
-    if (unit->getDisplayId() == 0) {
-        LOG_WARNING("[Spawn] UNIT guid=0x", std::hex, block.guid, std::dec,
-                  " has displayId=0 — no spawn (entry=", unit->getEntry(),
-                  " at ", unit->getX(), ",", unit->getY(), ",", unit->getZ(), ")");
-    }
-    if (unit->getDisplayId() != 0) {
-        dispatchEntitySpawn(block.guid, block.objectType, entity, unit, unitInitiallyDead);
-        if (block.hasMovement && block.moveFlags != 0 && owner_.unitMoveFlagsCallback_ &&
-            block.guid != owner_.playerGuid) {
-            owner_.unitMoveFlagsCallback_(block.guid, block.moveFlags);
-        }
-    }
-}
-
-void EntityController::onCreatePlayer(const UpdateBlock& block, std::shared_ptr<Entity>& entity) {
-    static const bool kVerboseUpdateObject = envFlagEnabled("WOWEE_LOG_UPDATE_OBJECT_VERBOSE", false);
-
-    // For the local player, capture the full initial field state
-    if (block.guid == owner_.playerGuid) {
-        owner_.lastPlayerFields_ = entity->getFields();
-        owner_.maybeDetectVisibleItemLayout();
-    }
-
-    // Name query + visible items
-    queryPlayerName(block.guid);
-    if (block.guid != owner_.playerGuid) {
-        owner_.updateOtherPlayerVisibleItems(block.guid, entity->getFields());
-    }
-
-    // Unit fields (PLAYER is a unit)
-    auto unit = std::static_pointer_cast<Unit>(entity);
-    UnitFieldIndices ufi = UnitFieldIndices::resolve();
-    bool unitInitiallyDead = applyUnitFieldsOnCreate(block, unit, ufi);
-
-    // Self-player post-unit-field handling
-    if (block.guid == owner_.playerGuid) {
-        constexpr uint32_t UNIT_FLAG_TAXI_FLIGHT = 0x00000100;
-        if ((unit->getUnitFlags() & UNIT_FLAG_TAXI_FLIGHT) != 0 && !owner_.onTaxiFlight_ && owner_.taxiLandingCooldown_ <= 0.0f) {
-            owner_.onTaxiFlight_ = true;
-            owner_.taxiStartGrace_ = std::max(owner_.taxiStartGrace_, 2.0f);
-            owner_.sanitizeMovementForTaxi();
-            if (owner_.movementHandler_) owner_.movementHandler_->applyTaxiMountForCurrentNode();
-        }
-    }
-    if (block.guid == owner_.playerGuid &&
-        (unit->getDynamicFlags() & 0x0008 /*UNIT_DYNFLAG_DEAD*/) != 0) {
-        owner_.playerDead_ = true;
-        LOG_INFO("Player logged in dead (dynamic flags)");
-    }
-    // Detect ghost state on login via PLAYER_FLAGS
-    if (block.guid == owner_.playerGuid) {
-        constexpr uint32_t PLAYER_FLAGS_GHOST = 0x00000010;
-        auto pfIt = block.fields.find(fieldIndex(UF::PLAYER_FLAGS));
-        if (pfIt != block.fields.end() && (pfIt->second & PLAYER_FLAGS_GHOST) != 0) {
-            owner_.releasedSpirit_ = true;
-            owner_.playerDead_ = true;
-            LOG_INFO("Player logged in as ghost (PLAYER_FLAGS)");
-            if (owner_.ghostStateCallback_) owner_.ghostStateCallback_(true);
-            // Query corpse position so minimap marker is accurate on reconnect
-            if (owner_.socket) {
-                network::Packet cq(wireOpcode(Opcode::MSG_CORPSE_QUERY));
-                owner_.socket->send(cq);
-            }
-        }
-    }
-    // Classic aura sync on initial object create
-    if (block.guid == owner_.playerGuid) {
-        syncClassicAurasFromFields(entity);
-    }
-
-    // Hostility
-    unit->setHostile(owner_.isHostileFaction(unit->getFactionTemplate()));
-
-    // Spawn dispatch
-    if (unit->getDisplayId() != 0) {
-        dispatchEntitySpawn(block.guid, block.objectType, entity, unit, unitInitiallyDead);
-        if (block.hasMovement && block.moveFlags != 0 && owner_.unitMoveFlagsCallback_ &&
-            block.guid != owner_.playerGuid) {
-            owner_.unitMoveFlagsCallback_(block.guid, block.moveFlags);
-        }
-    }
-
-    // Player stat fields (self only)
-    if (block.guid == owner_.playerGuid) {
-        // Auto-detect coinage index using the previous snapshot vs this full snapshot.
-        maybeDetectCoinageIndex(owner_.lastPlayerFields_, block.fields);
-
-        owner_.lastPlayerFields_ = block.fields;
-        owner_.detectInventorySlotBases(block.fields);
-
-        if (kVerboseUpdateObject) {
-            uint16_t maxField = 0;
-            for (const auto& [key, _val] : block.fields) {
-                if (key > maxField) maxField = key;
-            }
-            LOG_INFO("Player update with ", block.fields.size(),
-                     " fields (max index=", maxField, ")");
-        }
-
-        PlayerFieldIndices pfi = PlayerFieldIndices::resolve();
-        bool slotsChanged = applyPlayerStatFields(block.fields, pfi, true);
-        if (slotsChanged) owner_.rebuildOnlineInventory();
-        owner_.maybeDetectVisibleItemLayout();
-        owner_.extractSkillFields(owner_.lastPlayerFields_);
-        owner_.extractExploredZoneFields(owner_.lastPlayerFields_);
-        owner_.applyQuestStateFromFields(owner_.lastPlayerFields_);
-    }
-}
-
-void EntityController::onCreateGameObject(const UpdateBlock& block, std::shared_ptr<Entity>& entity) {
-    auto go = std::static_pointer_cast<GameObject>(entity);
-    auto itDisp = block.fields.find(fieldIndex(UF::GAMEOBJECT_DISPLAYID));
-    if (itDisp != block.fields.end()) {
-        go->setDisplayId(itDisp->second);
-    }
-    auto itEntry = block.fields.find(fieldIndex(UF::OBJECT_FIELD_ENTRY));
-    if (itEntry != block.fields.end() && itEntry->second != 0) {
-        go->setEntry(itEntry->second);
-        auto cacheIt = gameObjectInfoCache_.find(itEntry->second);
-        if (cacheIt != gameObjectInfoCache_.end()) {
-            go->setName(cacheIt->second.name);
-        }
-        queryGameObjectInfo(itEntry->second, block.guid);
-    }
-    // Detect transport GameObjects via UPDATEFLAG_TRANSPORT (0x0002)
-    LOG_DEBUG("GameObject CREATE: guid=0x", std::hex, block.guid, std::dec,
-             " entry=", go->getEntry(), " displayId=", go->getDisplayId(),
-             " updateFlags=0x", std::hex, block.updateFlags, std::dec,
-             " pos=(", go->getX(), ", ", go->getY(), ", ", go->getZ(), ")");
-    if (block.updateFlags & 0x0002) {
-        transportGuids_.insert(block.guid);
-        LOG_INFO("Detected transport GameObject: 0x", std::hex, block.guid, std::dec,
-                 " entry=", go->getEntry(),
-                 " displayId=", go->getDisplayId(),
-                 " pos=(", go->getX(), ", ", go->getY(), ", ", go->getZ(), ")");
-        // Note: TransportSpawnCallback will be invoked from Application after WMO instance is created
-    }
-    if (go->getDisplayId() != 0 && owner_.gameObjectSpawnCallback_) {
-        float goScale = 1.0f;
-        {
-            uint16_t scaleIdx = fieldIndex(UF::OBJECT_FIELD_SCALE_X);
-            if (scaleIdx != 0xFFFF) {
-                uint32_t raw = entity->getField(scaleIdx);
-                if (raw != 0) {
-                    std::memcpy(&goScale, &raw, sizeof(float));
-                    if (goScale <= 0.01f || goScale > 100.0f) goScale = 1.0f;
-                }
-            }
-        }
-        owner_.gameObjectSpawnCallback_(block.guid, go->getEntry(), go->getDisplayId(),
-            go->getX(), go->getY(), go->getZ(), go->getOrientation(), goScale);
-    }
-    // Fire transport move callback for transports (position update on re-creation)
-    if (transportGuids_.count(block.guid) && owner_.transportMoveCallback_) {
-        serverUpdatedTransportGuids_.insert(block.guid);
-        owner_.transportMoveCallback_(block.guid,
-            go->getX(), go->getY(), go->getZ(), go->getOrientation());
-    }
-}
-
-void EntityController::onCreateItem(const UpdateBlock& block, bool& newItemCreated) {
-    trackItemOnCreate(block, newItemCreated);
-}
-
-void EntityController::onCreateCorpse(const UpdateBlock& block) {
-    // Detect player's own corpse object so we have the position even when
-    // SMSG_DEATH_RELEASE_LOC hasn't been received (e.g. login as ghost).
-    if (block.hasMovement) {
-        // CORPSE_FIELD_OWNER is at index 6 (uint64, low word at 6, high at 7)
-        uint16_t ownerLowIdx = 6;
-        auto ownerLowIt = block.fields.find(ownerLowIdx);
-        uint32_t ownerLow = (ownerLowIt != block.fields.end()) ? ownerLowIt->second : 0;
-        auto ownerHighIt = block.fields.find(ownerLowIdx + 1);
-        uint32_t ownerHigh = (ownerHighIt != block.fields.end()) ? ownerHighIt->second : 0;
-        uint64_t ownerGuid = (static_cast<uint64_t>(ownerHigh) << 32) | ownerLow;
-        if (ownerGuid == owner_.playerGuid || ownerLow == static_cast<uint32_t>(owner_.playerGuid)) {
-            // Server coords from movement block
-            owner_.corpseGuid_  = block.guid;
-            owner_.corpseX_     = block.x;
-            owner_.corpseY_     = block.y;
-            owner_.corpseZ_     = block.z;
-            owner_.corpseMapId_ = owner_.currentMapId_;
-            LOG_INFO("Corpse object detected: guid=0x", std::hex, owner_.corpseGuid_, std::dec,
-                     " server=(", block.x, ", ", block.y, ", ", block.z,
-                     ") map=", owner_.corpseMapId_);
-        }
-    }
-}
-
-// ============================================================
-// Type-specific VALUES UPDATE handlers
-// ============================================================
-
-void EntityController::handleDisplayIdChange(const UpdateBlock& block,
-                                              const std::shared_ptr<Entity>& entity,
-                                              const std::shared_ptr<Unit>& unit,
-                                              const UnitFieldUpdateResult& result) {
-    if (!result.displayIdChanged || unit->getDisplayId() == 0 ||
-        unit->getDisplayId() == result.oldDisplayId)
-        return;
-
-    constexpr uint32_t UNIT_DYNFLAG_DEAD = 0x0008;
-    constexpr uint32_t UNIT_DYNFLAG_LOOTABLE = 0x0001;
-    bool isDeadNow = (unit->getHealth() == 0) ||
-        ((unit->getDynamicFlags() & (UNIT_DYNFLAG_DEAD | UNIT_DYNFLAG_LOOTABLE)) != 0);
-    dispatchEntitySpawn(block.guid, entity->getType(), entity, unit,
-                        isDeadNow && !result.npcDeathNotified);
-    if (owner_.addonEventCallback_) {
-        std::string uid;
-        if (block.guid == owner_.targetGuid) uid = "target";
-        else if (block.guid == owner_.focusGuid) uid = "focus";
-        else if (block.guid == owner_.petGuid_) uid = "pet";
-        if (!uid.empty())
-            pendingEvents_.emit("UNIT_MODEL_CHANGED", {uid});
-    }
-}
-
-void EntityController::onValuesUpdateUnit(const UpdateBlock& block, std::shared_ptr<Entity>& entity) {
-    auto unit = std::static_pointer_cast<Unit>(entity);
-    UnitFieldIndices ufi = UnitFieldIndices::resolve();
-    UnitFieldUpdateResult result = applyUnitFieldsOnUpdate(block, entity, unit, ufi);
-    handleDisplayIdChange(block, entity, unit, result);
-}
-
-void EntityController::onValuesUpdatePlayer(const UpdateBlock& block, std::shared_ptr<Entity>& entity) {
-    // Other player visible items
-    if (block.guid != owner_.playerGuid) {
-        owner_.updateOtherPlayerVisibleItems(block.guid, entity->getFields());
-    }
-
-    // Unit field update (player IS a unit)
-    auto unit = std::static_pointer_cast<Unit>(entity);
-    UnitFieldIndices ufi = UnitFieldIndices::resolve();
-    UnitFieldUpdateResult result = applyUnitFieldsOnUpdate(block, entity, unit, ufi);
-
-    // Classic aura sync from UNIT_FIELD_AURAS when those fields are updated
-    if (block.guid == owner_.playerGuid) {
-        syncClassicAurasFromFields(entity);
-    }
-
-    // Display ID changed — re-spawn/model-change
-    handleDisplayIdChange(block, entity, unit, result);
-
-    // Self-player stat/inventory/quest field updates
-    if (block.guid == owner_.playerGuid) {
-        const bool needCoinageDetectSnapshot =
-            (owner_.pendingMoneyDelta_ != 0 && owner_.pendingMoneyDeltaTimer_ > 0.0f);
-        std::map<uint16_t, uint32_t> oldFieldsSnapshot;
-        if (needCoinageDetectSnapshot) {
-            oldFieldsSnapshot = owner_.lastPlayerFields_;
-        }
-        if (block.hasMovement && block.runSpeed > 0.1f && block.runSpeed < 100.0f) {
-            owner_.serverRunSpeed_ = block.runSpeed;
-            // Some server dismount paths update run speed without updating mount display field.
-            if (!owner_.onTaxiFlight_ && !owner_.taxiMountActive_ &&
-                owner_.currentMountDisplayId_ != 0 && block.runSpeed <= 8.5f) {
-                LOG_INFO("Auto-clearing mount from movement speed update: speed=", block.runSpeed,
-                         " displayId=", owner_.currentMountDisplayId_);
-                owner_.currentMountDisplayId_ = 0;
-                if (owner_.mountCallback_) {
-                    owner_.mountCallback_(0);
-                }
-            }
-        }
-        auto mergeHint = owner_.lastPlayerFields_.end();
-        for (const auto& [key, val] : block.fields) {
-            mergeHint = owner_.lastPlayerFields_.insert_or_assign(mergeHint, key, val);
-        }
-        if (needCoinageDetectSnapshot) {
-            maybeDetectCoinageIndex(oldFieldsSnapshot, owner_.lastPlayerFields_);
-        }
-        owner_.maybeDetectVisibleItemLayout();
-        owner_.detectInventorySlotBases(block.fields);
-
-        PlayerFieldIndices pfi = PlayerFieldIndices::resolve();
-        bool slotsChanged = applyPlayerStatFields(block.fields, pfi, false);
-        if (slotsChanged) {
-            owner_.rebuildOnlineInventory();
-            pendingEvents_.emit("PLAYER_EQUIPMENT_CHANGED", {});
-        }
-        owner_.extractSkillFields(owner_.lastPlayerFields_);
-        owner_.extractExploredZoneFields(owner_.lastPlayerFields_);
-        owner_.applyQuestStateFromFields(owner_.lastPlayerFields_);
-    }
-}
-
-void EntityController::onValuesUpdateItem(const UpdateBlock& block, std::shared_ptr<Entity>& entity) {
-    updateItemOnValuesUpdate(block, entity);
-}
-
-void EntityController::onValuesUpdateGameObject(const UpdateBlock& block, std::shared_ptr<Entity>& entity) {
-    if (block.hasMovement) {
-        if (transportGuids_.count(block.guid) && owner_.transportMoveCallback_) {
-            serverUpdatedTransportGuids_.insert(block.guid);
-            owner_.transportMoveCallback_(block.guid, entity->getX(), entity->getY(),
-                                   entity->getZ(), entity->getOrientation());
-        } else if (owner_.gameObjectMoveCallback_) {
-            owner_.gameObjectMoveCallback_(block.guid, entity->getX(), entity->getY(),
-                                    entity->getZ(), entity->getOrientation());
-        }
-    }
-
-    // Detect GO state changes from GAMEOBJECT_BYTES_1 (packed: byte0=state, byte1=type, byte2=artKit, byte3=animProgress)
-    const uint16_t ufGoBytes1 = fieldIndex(UF::GAMEOBJECT_BYTES_1);
-    if (ufGoBytes1 != 0xFFFF) {
-        auto itB = block.fields.find(ufGoBytes1);
-        if (itB != block.fields.end()) {
-            uint8_t goState = static_cast<uint8_t>(itB->second & 0xFF);
-            if (owner_.gameObjectStateCallback_)
-                owner_.gameObjectStateCallback_(block.guid, goState);
-        }
-    }
-}
-
-// ============================================================
-// Update type handlers
-// ============================================================
-
-void EntityController::handleCreateObject(const UpdateBlock& block, bool& newItemCreated) {
-    pendingEvents_.clear();
-
-    // 3a: Create entity from block type
-    std::shared_ptr<Entity> entity = createEntityFromBlock(block);
-
-    // Set position from movement block (server → canonical)
-    if (block.hasMovement) {
-        glm::vec3 pos = core::coords::serverToCanonical(glm::vec3(block.x, block.y, block.z));
-        float oCanonical = core::coords::serverToCanonicalYaw(block.orientation);
-        entity->setPosition(pos.x, pos.y, pos.z, oCanonical);
-        LOG_DEBUG("  Position: (", pos.x, ", ", pos.y, ", ", pos.z, ")");
-        if (block.guid == owner_.playerGuid && block.runSpeed > 0.1f && block.runSpeed < 100.0f) {
-            owner_.serverRunSpeed_ = block.runSpeed;
-        }
-        // 3b: Track player-on-transport state
-        if (block.guid == owner_.playerGuid) {
-            applyPlayerTransportState(block, entity, pos, oCanonical, false);
-        }
-        // 3i: Track transport-relative children so they follow parent transport motion.
-        updateNonPlayerTransportAttachment(block, entity, block.objectType);
-    }
-
-    // Set fields
-    for (const auto& field : block.fields) {
-        entity->setField(field.first, field.second);
-    }
-
-    // Add to manager
-    entityManager.addEntity(block.guid, entity);
-
-    // Dispatch to type-specific handler
-    auto* handler = getTypeHandler(block.objectType);
-    if (handler) handler->onCreate(block, entity, newItemCreated);
-
-    flushPendingEvents();
-}
-
-void EntityController::handleValuesUpdate(const UpdateBlock& block) {
-    auto entity = entityManager.getEntity(block.guid);
-    if (!entity) {
-        // Item/container entities may be absent from entityManager (e.g. server
-        // only sent a partial update) but we still track them in onlineItems_.
-        // Process field updates so durability/stack changes from repair aren't lost.
-        if (owner_.onlineItems_.count(block.guid)) {
-            pendingEvents_.clear();
-            updateItemOnValuesUpdate(block, entity);
-            flushPendingEvents();
-            LOG_DEBUG("Updated orphan item fields: 0x", std::hex, block.guid, std::dec);
-        }
-        return;
-    }
-    pendingEvents_.clear();
-
-    // Position update (common)
-    if (block.hasMovement) {
-        glm::vec3 pos = core::coords::serverToCanonical(glm::vec3(block.x, block.y, block.z));
-        float oCanonical = core::coords::serverToCanonicalYaw(block.orientation);
-        entity->setPosition(pos.x, pos.y, pos.z, oCanonical);
-        updateNonPlayerTransportAttachment(block, entity, entity->getType());
-    }
-
-    // Set fields (common)
-    for (const auto& field : block.fields) {
-        entity->setField(field.first, field.second);
-    }
-
-    // Dispatch to type-specific handler
-    auto* handler = getTypeHandler(entity->getType());
-    if (handler) handler->onValuesUpdate(block, entity);
-
-    flushPendingEvents();
-    LOG_DEBUG("Updated entity fields: 0x", std::hex, block.guid, std::dec);
-}
-
-void EntityController::handleMovementUpdate(const UpdateBlock& block) {
-            // Diagnostic: Log if we receive MOVEMENT blocks for transports
-            if (transportGuids_.count(block.guid)) {
-                LOG_INFO("MOVEMENT update for transport 0x", std::hex, block.guid, std::dec,
-                         " pos=(", block.x, ", ", block.y, ", ", block.z, ")");
-            }
-
-            // Update entity position (server → canonical)
-            auto entity = entityManager.getEntity(block.guid);
-            if (entity) {
-                glm::vec3 pos = core::coords::serverToCanonical(glm::vec3(block.x, block.y, block.z));
-                float oCanonical = core::coords::serverToCanonicalYaw(block.orientation);
-                entity->setPosition(pos.x, pos.y, pos.z, oCanonical);
-                LOG_DEBUG("Updated entity position: 0x", std::hex, block.guid, std::dec);
-
-                updateNonPlayerTransportAttachment(block, entity, entity->getType());
-
-                // 3b: Track player-on-transport state from MOVEMENT updates
-                if (block.guid == owner_.playerGuid) {
-                    owner_.movementInfo.orientation = oCanonical;
-                    applyPlayerTransportState(block, entity, pos, oCanonical, true);
-                }
-
-                // Fire transport move callback if this is a known transport
-                if (transportGuids_.count(block.guid) && owner_.transportMoveCallback_) {
-                    serverUpdatedTransportGuids_.insert(block.guid);
-                    owner_.transportMoveCallback_(block.guid, pos.x, pos.y, pos.z, oCanonical);
-                }
-                // Fire move callback for non-transport gameobjects.
-                if (entity->getType() == ObjectType::GAMEOBJECT &&
-                    transportGuids_.count(block.guid) == 0 &&
-                    owner_.gameObjectMoveCallback_) {
-                    owner_.gameObjectMoveCallback_(block.guid, entity->getX(), entity->getY(),
-                                            entity->getZ(), entity->getOrientation());
-                }
-                // Fire move callback for non-player units (creatures).
-                // SMSG_MONSTER_MOVE handles smooth interpolated movement, but many
-                // servers (especially vanilla/Turtle WoW) communicate NPC positions
-                // via MOVEMENT blocks instead. Use duration=0 for an instant snap.
-                if (block.guid != owner_.playerGuid &&
-                    entity->getType() == ObjectType::UNIT &&
-                    transportGuids_.count(block.guid) == 0 &&
-                    owner_.creatureMoveCallback_) {
-                    owner_.creatureMoveCallback_(block.guid, pos.x, pos.y, pos.z, 0);
-                }
-            } else {
-                LOG_WARNING("MOVEMENT update for unknown entity: 0x", std::hex, block.guid, std::dec);
-            }
-}
-
-void EntityController::finalizeUpdateObjectBatch(bool newItemCreated) {
-    owner_.tabCycleStale = true;
-    // Entity count logging disabled
-
-    // Deferred rebuild: if new item objects were created in this packet, rebuild
-    // owner_.inventory so that slot GUIDs updated earlier in the same packet can resolve.
-    if (newItemCreated) {
-        owner_.rebuildOnlineInventory();
-    }
-
-    // Late owner_.inventory base detection once items are known
-    if (owner_.playerGuid != 0 && owner_.invSlotBase_ < 0 && !owner_.lastPlayerFields_.empty() && !owner_.onlineItems_.empty()) {
-        owner_.detectInventorySlotBases(owner_.lastPlayerFields_);
-        if (owner_.invSlotBase_ >= 0) {
-            if (owner_.applyInventoryFields(owner_.lastPlayerFields_)) {
-                owner_.rebuildOnlineInventory();
-            }
-        }
-    }
-}
-
-void EntityController::handleCompressedUpdateObject(network::Packet& packet) {
-    LOG_DEBUG("Handling SMSG_COMPRESSED_UPDATE_OBJECT, packet size: ", packet.getSize());
-
-    // First 4 bytes = decompressed size
-    if (packet.getSize() < 4) {
-        LOG_WARNING("SMSG_COMPRESSED_UPDATE_OBJECT too small");
-        return;
-    }
-
-    uint32_t decompressedSize = packet.readUInt32();
-    LOG_DEBUG("  Decompressed size: ", decompressedSize);
-
-    // Capital cities and large raids can produce very large update packets.
-    // The real WoW client handles up to ~10MB; 5MB covers all practical cases.
-    if (decompressedSize == 0 || decompressedSize > 5 * 1024 * 1024) {
-        LOG_WARNING("Invalid decompressed size: ", decompressedSize);
-        return;
-    }
-
-    // Remaining data is zlib compressed
-    size_t compressedSize = packet.getRemainingSize();
-    const uint8_t* compressedData = packet.getData().data() + packet.getReadPos();
-
-    // Decompress
-    std::vector<uint8_t> decompressed(decompressedSize);
-    uLongf destLen = decompressedSize;
-    int ret = uncompress(decompressed.data(), &destLen, compressedData, compressedSize);
-
-    if (ret != Z_OK) {
-        LOG_WARNING("Failed to decompress UPDATE_OBJECT: zlib error ", ret);
-        return;
-    }
-
-    // Create packet from decompressed data and parse it
-    network::Packet decompressedPacket(wireOpcode(Opcode::SMSG_UPDATE_OBJECT), decompressed);
-    handleUpdateObject(decompressedPacket);
-}
-void EntityController::handleDestroyObject(network::Packet& packet) {
-    LOG_DEBUG("Handling SMSG_DESTROY_OBJECT");
-
-    DestroyObjectData data;
-    if (!DestroyObjectParser::parse(packet, data)) {
-        LOG_WARNING("Failed to parse SMSG_DESTROY_OBJECT");
-        return;
-    }
-
-    // Remove entity
-    if (entityManager.hasEntity(data.guid)) {
-        if (transportGuids_.count(data.guid) > 0) {
-            const bool playerAboardNow = (owner_.playerTransportGuid_ == data.guid);
-            const bool stickyAboard = (owner_.playerTransportStickyGuid_ == data.guid && owner_.playerTransportStickyTimer_ > 0.0f);
-            const bool movementSaysAboard = (owner_.movementInfo.transportGuid == data.guid);
-            if (playerAboardNow || stickyAboard || movementSaysAboard) {
-                serverUpdatedTransportGuids_.erase(data.guid);
-                LOG_INFO("Preserving in-use transport on destroy: 0x", std::hex, data.guid, std::dec,
-                         " now=", playerAboardNow,
-                         " sticky=", stickyAboard,
-                         " movement=", movementSaysAboard);
-                return;
-            }
-        }
-        // Mirror out-of-range handling: invoke render-layer despawn callbacks before entity removal.
-        auto entity = entityManager.getEntity(data.guid);
-        if (entity) {
-            if (entity->getType() == ObjectType::UNIT && owner_.creatureDespawnCallback_) {
-                owner_.creatureDespawnCallback_(data.guid);
-            } else if (entity->getType() == ObjectType::PLAYER && owner_.playerDespawnCallback_) {
-                // Player entities also need renderer cleanup on DESTROY_OBJECT, not just out-of-range.
-                owner_.playerDespawnCallback_(data.guid);
-                owner_.otherPlayerVisibleItemEntries_.erase(data.guid);
-                owner_.otherPlayerVisibleDirty_.erase(data.guid);
-                owner_.otherPlayerMoveTimeMs_.erase(data.guid);
-                owner_.inspectedPlayerItemEntries_.erase(data.guid);
-                owner_.pendingAutoInspect_.erase(data.guid);
-                pendingNameQueries.erase(data.guid);
-            } else if (entity->getType() == ObjectType::GAMEOBJECT && owner_.gameObjectDespawnCallback_) {
-                owner_.gameObjectDespawnCallback_(data.guid);
-            }
-        }
-        if (transportGuids_.count(data.guid) > 0) {
-            transportGuids_.erase(data.guid);
-            serverUpdatedTransportGuids_.erase(data.guid);
-            if (owner_.playerTransportGuid_ == data.guid) {
-                owner_.clearPlayerTransport();
-            }
-        }
-        owner_.clearTransportAttachment(data.guid);
-        entityManager.removeEntity(data.guid);
-        LOG_INFO("Destroyed entity: 0x", std::hex, data.guid, std::dec,
-                 " (", (data.isDeath ? "death" : "despawn"), ")");
-    } else {
-        LOG_DEBUG("Destroy object for unknown entity: 0x", std::hex, data.guid, std::dec);
-    }
-
-    // Clean up auto-attack and target if destroyed entity was our target
-    if (owner_.combatHandler_ && data.guid == owner_.combatHandler_->getAutoAttackTargetGuid()) {
-        owner_.stopAutoAttack();
-    }
-    if (data.guid == owner_.targetGuid) {
-        owner_.targetGuid = 0;
-    }
-    if (owner_.combatHandler_) owner_.combatHandler_->removeHostileAttacker(data.guid);
-
-    // Remove online item/container tracking
-    owner_.containerContents_.erase(data.guid);
-    if (owner_.onlineItems_.erase(data.guid)) {
-        owner_.rebuildOnlineInventory();
-    }
-
-    // Clean up quest giver status
-    owner_.npcQuestStatus_.erase(data.guid);
-
-    // Remove combat text entries referencing the destroyed entity so floating
-    // damage numbers don't linger after the source/target despawns.
-    if (owner_.combatHandler_) owner_.combatHandler_->removeCombatTextForGuid(data.guid);
-
-    // Clean up unit cast owner_.state (cast bar) for the destroyed unit
-    if (owner_.spellHandler_) owner_.spellHandler_->unitCastStates_.erase(data.guid);
-    // Clean up cached auras
-    if (owner_.spellHandler_) owner_.spellHandler_->unitAurasCache_.erase(data.guid);
-
-    owner_.tabCycleStale = true;
-}
-
-// Name Queries
-// ============================================================
-
-void EntityController::queryPlayerName(uint64_t guid) {
-    // If already cached, apply the name to the entity (handles entity recreation after
-    // moving out/in range — the entity object is new but the cached name is valid).
-    auto cacheIt = playerNameCache.find(guid);
-    if (cacheIt != playerNameCache.end()) {
-        auto entity = entityManager.getEntity(guid);
-        if (entity && entity->getType() == ObjectType::PLAYER) {
-            auto player = std::static_pointer_cast<Player>(entity);
-            if (player->getName().empty()) {
-                player->setName(cacheIt->second);
-            }
-        }
-        return;
-    }
-    if (pendingNameQueries.count(guid)) return;
-    if (!owner_.isInWorld()) {
-        LOG_INFO("queryPlayerName: skipped guid=0x", std::hex, guid, std::dec,
-                 " owner_.state=", worldStateName(owner_.state), " owner_.socket=", (owner_.socket ? "yes" : "no"));
-        return;
-    }
-
-    LOG_INFO("queryPlayerName: sending CMSG_NAME_QUERY for guid=0x", std::hex, guid, std::dec);
-    pendingNameQueries.insert(guid);
-    auto packet = NameQueryPacket::build(guid);
-    owner_.socket->send(packet);
-}
-
-void EntityController::queryCreatureInfo(uint32_t entry, uint64_t guid) {
-    if (creatureInfoCache.count(entry) || pendingCreatureQueries.count(entry)) return;
-    if (!owner_.isInWorld()) return;
-
-    pendingCreatureQueries.insert(entry);
-    auto packet = CreatureQueryPacket::build(entry, guid);
-    owner_.socket->send(packet);
-}
-
-void EntityController::queryGameObjectInfo(uint32_t entry, uint64_t guid) {
-    if (gameObjectInfoCache_.count(entry) || pendingGameObjectQueries_.count(entry)) return;
-    if (!owner_.isInWorld()) return;
-
-    pendingGameObjectQueries_.insert(entry);
-    auto packet = GameObjectQueryPacket::build(entry, guid);
-    owner_.socket->send(packet);
-}
-
-std::string EntityController::getCachedPlayerName(uint64_t guid) const {
-    return std::string(lookupName(guid));
-}
-
-std::string EntityController::getCachedCreatureName(uint32_t entry) const {
-    auto it = creatureInfoCache.find(entry);
-    return (it != creatureInfoCache.end()) ? it->second.name : "";
-}
-void EntityController::handleNameQueryResponse(network::Packet& packet) {
-    NameQueryResponseData data;
-    if (!owner_.packetParsers_ || !owner_.packetParsers_->parseNameQueryResponse(packet, data)) {
-        LOG_WARNING("Failed to parse SMSG_NAME_QUERY_RESPONSE (size=", packet.getSize(), ")");
-        return;
-    }
-
-    pendingNameQueries.erase(data.guid);
-
-    LOG_INFO("Name query response: guid=0x", std::hex, data.guid, std::dec,
-             " found=", static_cast<int>(data.found), " name='", data.name, "'",
-             " race=", static_cast<int>(data.race), " class=", static_cast<int>(data.classId));
-
-    if (data.isValid()) {
-        playerNameCache[data.guid] = data.name;
-        // Cache class/race from name query for UnitClass/UnitRace fallback
-        if (data.classId != 0 || data.race != 0) {
-            playerClassRaceCache_[data.guid] = {data.classId, data.race};
-        }
-        // Update entity name
-        auto entity = entityManager.getEntity(data.guid);
-        if (entity && entity->getType() == ObjectType::PLAYER) {
-            auto player = std::static_pointer_cast<Player>(entity);
-            player->setName(data.name);
-        }
-
-        // Backfill chat history entries that arrived before we knew the name.
-        if (owner_.chatHandler_) {
-            for (auto& msg : owner_.chatHandler_->getChatHistory()) {
-                if (msg.senderGuid == data.guid && msg.senderName.empty()) {
-                    msg.senderName = data.name;
-                }
-            }
-        }
-
-        // Backfill whisper reply target if the name arrived after the whisper.
-        if (owner_.lastWhisperSenderGuid_ == data.guid && owner_.lastWhisperSender_.empty()) {
-            owner_.lastWhisperSender_ = data.name;
-        }
-
-        // Backfill mail inbox sender names
-        for (auto& mail : owner_.mailInbox_) {
-            if (mail.messageType == 0 && mail.senderGuid == data.guid) {
-                mail.senderName = data.name;
-            }
-        }
-
-        // Backfill friend list: if this GUID came from a friend list packet,
-        // register the name in owner_.friendsCache now that we know it.
-        if (owner_.friendGuids_.count(data.guid)) {
-            owner_.friendsCache[data.name] = data.guid;
-        }
-
-        // Backfill ignore list: SMSG_IGNORE_LIST only contains GUIDs, so
-        // ignoreCache (name→guid for UI) is populated here once names resolve.
-        if (owner_.ignoreListGuids_.count(data.guid)) {
-            owner_.ignoreCache[data.name] = data.guid;
-        }
-
-        // Fire UNIT_NAME_UPDATE so nameplate/unit frame addons know the name is available
-        if (owner_.addonEventCallback_) {
-            std::string unitId;
-            if (data.guid == owner_.targetGuid) unitId = "target";
-            else if (data.guid == owner_.focusGuid) unitId = "focus";
-            else if (data.guid == owner_.playerGuid) unitId = "player";
-            if (!unitId.empty())
-                owner_.fireAddonEvent("UNIT_NAME_UPDATE", {unitId});
-        }
-    }
-}
-
-void EntityController::handleCreatureQueryResponse(network::Packet& packet) {
-    CreatureQueryResponseData data;
-    if (!owner_.packetParsers_->parseCreatureQueryResponse(packet, data)) return;
-
-    pendingCreatureQueries.erase(data.entry);
-
-    if (data.isValid()) {
-        creatureInfoCache[data.entry] = data;
-        // Update all unit entities with this entry
-        for (auto& [guid, entity] : entityManager.getEntities()) {
-            if (entity->getType() == ObjectType::UNIT) {
-                auto unit = std::static_pointer_cast<Unit>(entity);
-                if (unit->getEntry() == data.entry) {
-                    unit->setName(data.name);
-                }
-            }
-        }
-    }
-}
-
-// ============================================================
-// GameObject Query
-// ============================================================
-
-void EntityController::handleGameObjectQueryResponse(network::Packet& packet) {
-    GameObjectQueryResponseData data;
-    bool ok = owner_.packetParsers_ ? owner_.packetParsers_->parseGameObjectQueryResponse(packet, data)
-                             : GameObjectQueryResponseParser::parse(packet, data);
-    if (!ok) return;
-
-    pendingGameObjectQueries_.erase(data.entry);
-
-    if (data.isValid()) {
-        gameObjectInfoCache_[data.entry] = data;
-        // Update all gameobject entities with this entry
-        for (auto& [guid, entity] : entityManager.getEntities()) {
-            if (entity->getType() == ObjectType::GAMEOBJECT) {
-                auto go = std::static_pointer_cast<GameObject>(entity);
-                if (go->getEntry() == data.entry) {
-                    go->setName(data.name);
-                }
-            }
-        }
-
-        // MO_TRANSPORT (type 15): assign TaxiPathNode path if available
-        if (data.type == 15 && data.hasData && data.data[0] != 0 && owner_.transportManager_) {
-            uint32_t taxiPathId = data.data[0];
-            if (owner_.transportManager_->hasTaxiPath(taxiPathId)) {
-                if (owner_.transportManager_->assignTaxiPathToTransport(data.entry, taxiPathId)) {
-                    LOG_DEBUG("MO_TRANSPORT entry=", data.entry, " assigned TaxiPathNode path ", taxiPathId);
-                }
-            } else {
-                LOG_DEBUG("MO_TRANSPORT entry=", data.entry, " taxiPathId=", taxiPathId,
-                         " not found in TaxiPathNode.dbc");
-            }
-        }
-    }
-}
-
-void EntityController::handleGameObjectPageText(network::Packet& packet) {
-    if (!packet.hasRemaining(8)) return;
-    uint64_t guid = packet.readUInt64();
-    auto entity = entityManager.getEntity(guid);
-    if (!entity || entity->getType() != ObjectType::GAMEOBJECT) return;
-
-    auto go = std::static_pointer_cast<GameObject>(entity);
-    uint32_t entry = go->getEntry();
-    if (entry == 0) return;
-
-    auto cacheIt = gameObjectInfoCache_.find(entry);
-    if (cacheIt == gameObjectInfoCache_.end()) {
-        queryGameObjectInfo(entry, guid);
-        return;
-    }
-
-    const GameObjectQueryResponseData& info = cacheIt->second;
-    uint32_t pageId = 0;
-    // AzerothCore layout:
-    // type 9 (TEXT): data[0]=pageID
-    // type 10 (GOOBER): data[7]=pageId
-    if (info.type == 9) pageId = info.data[0];
-    else if (info.type == 10) pageId = info.data[7];
-
-    if (pageId != 0 && owner_.socket && owner_.state == WorldState::IN_WORLD) {
-        owner_.bookPages_.clear();  // start a fresh book for this interaction
-        auto req = PageTextQueryPacket::build(pageId, guid);
-        owner_.socket->send(req);
-        return;
-    }
-
-    if (!info.name.empty()) {
-        owner_.addSystemChatMessage(info.name);
-    }
-}
-
-void EntityController::handlePageTextQueryResponse(network::Packet& packet) {
-    PageTextQueryResponseData data;
-    if (!PageTextQueryResponseParser::parse(packet, data)) return;
-
-    if (!data.isValid()) return;
-
-    // Append page if not already collected
-    bool alreadyHave = false;
-    for (const auto& bp : owner_.bookPages_) {
-        if (bp.pageId == data.pageId) { alreadyHave = true; break; }
-    }
-    if (!alreadyHave) {
-        owner_.bookPages_.push_back({data.pageId, data.text});
-    }
-
-    // Follow the chain: if there's a next page we haven't fetched yet, request it
-    if (data.nextPageId != 0) {
-        bool nextHave = false;
-        for (const auto& bp : owner_.bookPages_) {
-            if (bp.pageId == data.nextPageId) { nextHave = true; break; }
-        }
-        if (!nextHave && owner_.socket && owner_.state == WorldState::IN_WORLD) {
-            auto req = PageTextQueryPacket::build(data.nextPageId, owner_.playerGuid);
-            owner_.socket->send(req);
-        }
-    }
-    LOG_DEBUG("handlePageTextQueryResponse: pageId=", data.pageId,
-              " nextPage=", data.nextPageId,
-              " totalPages=", owner_.bookPages_.size());
-}
-
-
-} // namespace game
-} // namespace wowee
diff --git a/src/game/expansion_profile.cpp b/src/game/expansion_profile.cpp
index 5dd38d36..9b14e0b7 100644
--- a/src/game/expansion_profile.cpp
+++ b/src/game/expansion_profile.cpp
@@ -58,14 +58,7 @@ std::string jsonValue(const std::string& json, const std::string& key) {
 int jsonInt(const std::string& json, const std::string& key, int def = 0) {
     std::string v = jsonValue(json, key);
     if (v.empty()) return def;
-    try {
-        return std::stoi(v);
-    } catch (...) {
-        // Non-numeric value for an integer field — fall back to default rather than
-        // crashing, but log it so malformed expansion.json files are diagnosable.
-        wowee::core::Logger::getInstance().warning("jsonInt: failed to parse '", key, "' value '", v, "', using default ", def);
-        return def;
-    }
+    try { return std::stoi(v); } catch (...) { return def; }
 }
 
 std::vector<uint32_t> jsonUintArray(const std::string& json, const std::string& key) {
@@ -92,7 +85,7 @@ namespace game {
 
 std::string ExpansionProfile::versionString() const {
     std::ostringstream ss;
-    ss << static_cast<int>(majorVersion) << "." << static_cast<int>(minorVersion) << "." << static_cast<int>(patchVersion);
+    ss << (int)majorVersion << "." << (int)minorVersion << "." << (int)patchVersion;
     // Append letter suffix for known builds
     if (majorVersion == 3 && minorVersion == 3 && patchVersion == 5) ss << "a";
     else if (majorVersion == 2 && minorVersion == 4 && patchVersion == 3) ss << "";
diff --git a/src/game/game_handler.cpp b/src/game/game_handler.cpp
index 0c47c46f..0dec7072 100644
--- a/src/game/game_handler.cpp
+++ b/src/game/game_handler.cpp
@@ -1,13 +1,4 @@
 #include "game/game_handler.hpp"
-#include "game/game_utils.hpp"
-#include "game/chat_handler.hpp"
-#include "game/movement_handler.hpp"
-#include "game/combat_handler.hpp"
-#include "game/spell_handler.hpp"
-#include "game/inventory_handler.hpp"
-#include "game/social_handler.hpp"
-#include "game/quest_handler.hpp"
-#include "game/warden_handler.hpp"
 #include "game/packet_parsers.hpp"
 #include "game/transport_manager.hpp"
 #include "game/warden_crypto.hpp"
@@ -17,7 +8,6 @@
 #include "game/update_field_table.hpp"
 #include "game/expansion_profile.hpp"
 #include "rendering/renderer.hpp"
-#include "audio/audio_coordinator.hpp"
 #include "audio/activity_sound_manager.hpp"
 #include "audio/combat_sound_manager.hpp"
 #include "audio/spell_sound_manager.hpp"
@@ -31,7 +21,6 @@
 #include "pipeline/asset_manager.hpp"
 #include "pipeline/dbc_loader.hpp"
 #include "core/logger.hpp"
-#include "rendering/animation/animation_ids.hpp"
 #include <glm/gtx/quaternion.hpp>
 #include <algorithm>
 #include <cmath>
@@ -91,45 +80,26 @@ bool isAuthCharPipelineOpcode(LogicalOpcode op) {
     }
 }
 
-} // end anonymous namespace
+bool isActiveExpansion(const char* expansionId) {
+    auto& app = core::Application::getInstance();
+    auto* registry = app.getExpansionRegistry();
+    if (!registry) return false;
+    auto* profile = registry->getActive();
+    if (!profile) return false;
+    return profile->id == expansionId;
+}
 
-namespace {
+bool isClassicLikeExpansion() {
+    return isActiveExpansion("classic") || isActiveExpansion("turtle");
+}
 
-int parseEnvIntClamped(const char* key, int defaultValue, int minValue, int maxValue) {
+bool envFlagEnabled(const char* key, bool defaultValue = false) {
     const char* raw = std::getenv(key);
     if (!raw || !*raw) return defaultValue;
-    char* end = nullptr;
-    long parsed = std::strtol(raw, &end, 10);
-    if (end == raw) return defaultValue;
-    return static_cast<int>(std::clamp<long>(parsed, minValue, maxValue));
+    return !(raw[0] == '0' || raw[0] == 'f' || raw[0] == 'F' ||
+             raw[0] == 'n' || raw[0] == 'N');
 }
 
-int incomingPacketsBudgetPerUpdate(WorldState state) {
-    static const int inWorldBudget =
-        parseEnvIntClamped("WOWEE_NET_MAX_GAMEHANDLER_PACKETS", 24, 1, 512);
-    static const int loginBudget =
-        parseEnvIntClamped("WOWEE_NET_MAX_GAMEHANDLER_PACKETS_LOGIN", 96, 1, 512);
-    return state == WorldState::IN_WORLD ? inWorldBudget : loginBudget;
-}
-
-float incomingPacketBudgetMs(WorldState state) {
-    static const int inWorldBudgetMs =
-        parseEnvIntClamped("WOWEE_NET_MAX_GAMEHANDLER_PACKET_MS", 2, 1, 50);
-    static const int loginBudgetMs =
-        parseEnvIntClamped("WOWEE_NET_MAX_GAMEHANDLER_PACKET_MS_LOGIN", 8, 1, 50);
-    return static_cast<float>(state == WorldState::IN_WORLD ? inWorldBudgetMs : loginBudgetMs);
-}
-
-float slowPacketLogThresholdMs() {
-    static const int thresholdMs =
-        parseEnvIntClamped("WOWEE_NET_SLOW_PACKET_LOG_MS", 10, 1, 60000);
-    return static_cast<float>(thresholdMs);
-}
-
-constexpr size_t kMaxQueuedInboundPackets = 4096;
-
-} // end anonymous namespace
-
 std::string formatCopperAmount(uint32_t amount) {
     uint32_t gold = amount / 10000;
     uint32_t silver = (amount / 100) % 100;
@@ -153,34 +123,244 @@ std::string formatCopperAmount(uint32_t amount) {
     return oss.str();
 }
 
-template<typename ManagerGetter, typename Callback>
-void GameHandler::withSoundManager(ManagerGetter getter, Callback cb) {
-    if (auto* ac = services_.audioCoordinator) {
-        if (auto* mgr = (ac->*getter)()) cb(mgr);
+bool readCStringAt(const std::vector<uint8_t>& data, size_t start, std::string& out, size_t& nextPos) {
+    out.clear();
+    if (start >= data.size()) return false;
+    size_t i = start;
+    while (i < data.size()) {
+        uint8_t b = data[i++];
+        if (b == 0) {
+            nextPos = i;
+            return true;
+        }
+        out.push_back(static_cast<char>(b));
     }
+    return false;
 }
 
-// Registration helpers for common dispatch table patterns
-void GameHandler::registerSkipHandler(LogicalOpcode op) {
-    dispatchTable_[op] = [](network::Packet& packet) { packet.skipAll(); };
-}
-void GameHandler::registerErrorHandler(LogicalOpcode op, const char* msg) {
-    dispatchTable_[op] = [this, msg](network::Packet&) {
-        addUIError(msg);
-        addSystemChatMessage(msg);
-    };
-}
-void GameHandler::registerHandler(LogicalOpcode op, void (GameHandler::*handler)(network::Packet&)) {
-    dispatchTable_[op] = [this, handler](network::Packet& packet) { (this->*handler)(packet); };
-}
-void GameHandler::registerWorldHandler(LogicalOpcode op, void (GameHandler::*handler)(network::Packet&)) {
-    dispatchTable_[op] = [this, handler](network::Packet& packet) {
-        if (state == WorldState::IN_WORLD) (this->*handler)(packet);
-    };
+std::string asciiLower(std::string s) {
+    std::transform(s.begin(), s.end(), s.begin(),
+                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+    return s;
 }
 
-GameHandler::GameHandler(GameServices& services)
-    : services_(services) {
+std::vector<std::string> splitWowPath(const std::string& wowPath) {
+    std::vector<std::string> out;
+    std::string cur;
+    for (char c : wowPath) {
+        if (c == '\\' || c == '/') {
+            if (!cur.empty()) {
+                out.push_back(cur);
+                cur.clear();
+            }
+            continue;
+        }
+        cur.push_back(c);
+    }
+    if (!cur.empty()) out.push_back(cur);
+    return out;
+}
+
+int pathCaseScore(const std::string& name) {
+    int score = 0;
+    for (unsigned char c : name) {
+        if (std::islower(c)) score += 2;
+        else if (std::isupper(c)) score -= 1;
+    }
+    return score;
+}
+
+std::string resolveCaseInsensitiveDataPath(const std::string& dataRoot, const std::string& wowPath) {
+    if (dataRoot.empty() || wowPath.empty()) return std::string();
+    std::filesystem::path cur(dataRoot);
+    std::error_code ec;
+    if (!std::filesystem::exists(cur, ec) || !std::filesystem::is_directory(cur, ec)) {
+        return std::string();
+    }
+
+    for (const std::string& segment : splitWowPath(wowPath)) {
+        std::string wanted = asciiLower(segment);
+        std::filesystem::path bestPath;
+        int bestScore = std::numeric_limits<int>::min();
+        bool found = false;
+
+        for (const auto& entry : std::filesystem::directory_iterator(cur, ec)) {
+            if (ec) break;
+            std::string name = entry.path().filename().string();
+            if (asciiLower(name) != wanted) continue;
+            int score = pathCaseScore(name);
+            if (!found || score > bestScore) {
+                found = true;
+                bestScore = score;
+                bestPath = entry.path();
+            }
+        }
+        if (!found) return std::string();
+        cur = bestPath;
+    }
+
+    if (!std::filesystem::exists(cur, ec) || std::filesystem::is_directory(cur, ec)) {
+        return std::string();
+    }
+    return cur.string();
+}
+
+std::vector<uint8_t> readFileBinary(const std::string& fsPath) {
+    std::ifstream in(fsPath, std::ios::binary);
+    if (!in) return {};
+    in.seekg(0, std::ios::end);
+    std::streamoff size = in.tellg();
+    if (size <= 0) return {};
+    in.seekg(0, std::ios::beg);
+    std::vector<uint8_t> data(static_cast<size_t>(size));
+    in.read(reinterpret_cast<char*>(data.data()), size);
+    if (!in) return {};
+    return data;
+}
+
+bool hmacSha1Matches(const uint8_t seedBytes[4], const std::string& text, const uint8_t expected[20]) {
+    uint8_t out[SHA_DIGEST_LENGTH];
+    unsigned int outLen = 0;
+    HMAC(EVP_sha1(),
+         seedBytes, 4,
+         reinterpret_cast<const uint8_t*>(text.data()),
+         static_cast<int>(text.size()),
+         out, &outLen);
+    return outLen == SHA_DIGEST_LENGTH && std::memcmp(out, expected, SHA_DIGEST_LENGTH) == 0;
+}
+
+const std::unordered_map<std::string, std::array<uint8_t, 20>>& knownDoorHashes() {
+    static const std::unordered_map<std::string, std::array<uint8_t, 20>> k = {
+        {"world\\lordaeron\\stratholme\\activedoodads\\doors\\nox_door_plague.m2",
+         {0xB4,0x45,0x2B,0x6D,0x95,0xC9,0x8B,0x18,0x6A,0x70,0xB0,0x08,0xFA,0x07,0xBB,0xAE,0xF3,0x0D,0xF7,0xA2}},
+        {"world\\kalimdor\\onyxiaslair\\doors\\onyxiasgate01.m2",
+         {0x75,0x19,0x5E,0x4A,0xED,0xA0,0xBC,0xAF,0x04,0x8C,0xA0,0xE3,0x4D,0x95,0xA7,0x0D,0x4F,0x53,0xC7,0x46}},
+        {"world\\generic\\human\\activedoodads\\doors\\deadminedoor02.m2",
+         {0x3D,0xFF,0x01,0x1B,0x9A,0xB1,0x34,0xF3,0x7F,0x88,0x50,0x97,0xE6,0x95,0x35,0x1B,0x91,0x95,0x35,0x64}},
+        {"world\\kalimdor\\silithus\\activedoodads\\ahnqirajdoor\\ahnqirajdoor02.m2",
+         {0xDB,0xD4,0xF4,0x07,0xC4,0x68,0xCC,0x36,0x13,0x4E,0x62,0x1D,0x16,0x01,0x78,0xFD,0xA4,0xD0,0xD2,0x49}},
+        {"world\\kalimdor\\diremaul\\activedoodads\\doors\\diremaulsmallinstancedoor.m2",
+         {0x0D,0xC8,0xDB,0x46,0xC8,0x55,0x49,0xC0,0xFF,0x1A,0x60,0x0F,0x6C,0x23,0x63,0x57,0xC3,0x05,0x78,0x1A}},
+    };
+    return k;
+}
+
+bool isReadableQuestText(const std::string& s, size_t minLen, size_t maxLen) {
+    if (s.size() < minLen || s.size() > maxLen) return false;
+    bool hasAlpha = false;
+    for (unsigned char c : s) {
+        if (c < 0x20 || c > 0x7E) return false;
+        if (std::isalpha(c)) hasAlpha = true;
+    }
+    return hasAlpha;
+}
+
+bool isPlaceholderQuestTitle(const std::string& s) {
+    return s.rfind("Quest #", 0) == 0;
+}
+
+bool looksLikeQuestDescriptionText(const std::string& s) {
+    int spaces = 0;
+    int commas = 0;
+    for (unsigned char c : s) {
+        if (c == ' ') spaces++;
+        if (c == ',') commas++;
+    }
+    const int words = spaces + 1;
+    if (words > 8) return true;
+    if (commas > 0 && words > 5) return true;
+    if (s.find(". ") != std::string::npos) return true;
+    if (s.find(':') != std::string::npos && words > 5) return true;
+    return false;
+}
+
+bool isStrongQuestTitle(const std::string& s) {
+    if (!isReadableQuestText(s, 6, 72)) return false;
+    if (looksLikeQuestDescriptionText(s)) return false;
+    unsigned char first = static_cast<unsigned char>(s.front());
+    return std::isupper(first) != 0;
+}
+
+int scoreQuestTitle(const std::string& s) {
+    if (!isReadableQuestText(s, 4, 72)) return -1000;
+    if (looksLikeQuestDescriptionText(s)) return -1000;
+    int score = 0;
+    score += static_cast<int>(std::min<size_t>(s.size(), 32));
+    unsigned char first = static_cast<unsigned char>(s.front());
+    if (std::isupper(first)) score += 20;
+    if (std::islower(first)) score -= 20;
+    if (s.find(' ') != std::string::npos) score += 8;
+    if (s.find('.') != std::string::npos) score -= 18;
+    if (s.find('!') != std::string::npos || s.find('?') != std::string::npos) score -= 6;
+    return score;
+}
+
+struct QuestQueryTextCandidate {
+    std::string title;
+    std::string objectives;
+    int score = -1000;
+};
+
+QuestQueryTextCandidate pickBestQuestQueryTexts(const std::vector<uint8_t>& data, bool classicHint) {
+    QuestQueryTextCandidate best;
+    if (data.size() <= 9) return best;
+
+    std::vector<size_t> seedOffsets;
+    const size_t base = 8;
+    const size_t classicOffset = base + 40u * 4u;
+    const size_t wotlkOffset = base + 55u * 4u;
+    if (classicHint) {
+        seedOffsets.push_back(classicOffset);
+        seedOffsets.push_back(wotlkOffset);
+    } else {
+        seedOffsets.push_back(wotlkOffset);
+        seedOffsets.push_back(classicOffset);
+    }
+    for (size_t off : seedOffsets) {
+        if (off < data.size()) {
+            std::string title;
+            size_t next = off;
+            if (readCStringAt(data, off, title, next)) {
+                QuestQueryTextCandidate c;
+                c.title = title;
+                c.score = scoreQuestTitle(title) + 20; // Prefer expected struct offsets
+
+                std::string s2;
+                size_t n2 = next;
+                if (readCStringAt(data, next, s2, n2) && isReadableQuestText(s2, 8, 600)) {
+                    c.objectives = s2;
+                }
+                if (c.score > best.score) best = c;
+            }
+        }
+    }
+
+    // Fallback: scan packet for best printable C-string title candidate.
+    for (size_t start = 8; start < data.size(); ++start) {
+        std::string title;
+        size_t next = start;
+        if (!readCStringAt(data, start, title, next)) continue;
+
+        QuestQueryTextCandidate c;
+        c.title = title;
+        c.score = scoreQuestTitle(title);
+        if (c.score < 0) continue;
+
+        std::string s2, s3;
+        size_t n2 = next, n3 = next;
+        if (readCStringAt(data, next, s2, n2)) {
+            if (isReadableQuestText(s2, 8, 600)) c.objectives = s2;
+            else if (readCStringAt(data, n2, s3, n3) && isReadableQuestText(s3, 8, 600)) c.objectives = s3;
+        }
+        if (c.score > best.score) best = c;
+    }
+
+    return best;
+}
+} // namespace
+
+
+GameHandler::GameHandler() {
     LOG_DEBUG("GameHandler created");
 
     setActiveOpcodeTable(&opcodeTable_);
@@ -195,26 +375,15 @@ GameHandler::GameHandler(GameServices& services)
     // Initialize Warden module manager
     wardenModuleManager_ = std::make_unique<WardenModuleManager>();
 
-    // Initialize domain handlers
-    entityController_ = std::make_unique<EntityController>(*this);
-    chatHandler_      = std::make_unique<ChatHandler>(*this);
-    movementHandler_  = std::make_unique<MovementHandler>(*this);
-    combatHandler_    = std::make_unique<CombatHandler>(*this);
-    spellHandler_     = std::make_unique<SpellHandler>(*this);
-    inventoryHandler_ = std::make_unique<InventoryHandler>(*this);
-    socialHandler_    = std::make_unique<SocialHandler>(*this);
-    questHandler_     = std::make_unique<QuestHandler>(*this);
-    wardenHandler_    = std::make_unique<WardenHandler>(*this);
-    wardenHandler_->initModuleManager();
+    // Default spells always available
+    knownSpells.insert(6603);  // Attack
+    knownSpells.insert(8690);  // Hearthstone
 
     // Default action bar layout
     actionBar[0].type = ActionBarSlot::SPELL;
     actionBar[0].id = 6603;   // Attack in slot 1
     actionBar[11].type = ActionBarSlot::SPELL;
     actionBar[11].id = 8690;  // Hearthstone in slot 12
-
-    // Build the opcode dispatch table (replaces switch(*logicalOp) in handlePacket)
-    registerOpcodeHandlers();
 }
 
 GameHandler::~GameHandler() {
@@ -253,9 +422,24 @@ bool GameHandler::connect(const std::string& host,
     this->realmId_ = realmId;
 
     // Diagnostic: dump session key for AUTH_REJECT debugging
-    LOG_INFO("GameHandler session key (", sessionKey.size(), "): ",
-             core::toHexString(sessionKey.data(), sessionKey.size()));
-    resetWardenState();
+    {
+        std::string hex;
+        for (uint8_t b : sessionKey) { char buf[4]; snprintf(buf, sizeof(buf), "%02x", b); hex += buf; }
+        LOG_INFO("GameHandler session key (", sessionKey.size(), "): ", hex);
+    }
+    requiresWarden_ = false;
+    wardenGateSeen_ = false;
+    wardenGateElapsed_ = 0.0f;
+    wardenGateNextStatusLog_ = 2.0f;
+    wardenPacketsAfterGate_ = 0;
+    wardenCharEnumBlockedLogged_ = false;
+    wardenCrypto_.reset();
+    wardenState_ = WardenState::WAIT_MODULE_USE;
+    wardenModuleHash_.clear();
+    wardenModuleKey_.clear();
+    wardenModuleSize_ = 0;
+    wardenModuleData_.clear();
+    wardenLoadedModule_.reset();
 
     // Generate random client seed
     this->clientSeed = generateClientSeed();
@@ -266,7 +450,8 @@ bool GameHandler::connect(const std::string& host,
 
     // Set up packet callback
     socket->setPacketCallback([this](const network::Packet& packet) {
-        enqueueIncomingPacket(packet);
+        network::Packet mutablePacket = packet;
+        handlePacket(mutablePacket);
     });
 
     // Connect to world server
@@ -284,7 +469,21 @@ bool GameHandler::connect(const std::string& host,
     return true;
 }
 
-void GameHandler::resetWardenState() {
+void GameHandler::disconnect() {
+    if (onTaxiFlight_) {
+        taxiRecoverPending_ = true;
+    } else {
+        taxiRecoverPending_ = false;
+    }
+    if (socket) {
+        socket->disconnect();
+        socket.reset();
+    }
+    activeCharacterGuid_ = 0;
+    playerNameCache.clear();
+    pendingNameQueries.clear();
+    transportAttachments_.clear();
+    serverUpdatedTransportGuids_.clear();
     requiresWarden_ = false;
     wardenGateSeen_ = false;
     wardenGateElapsed_ = 0.0f;
@@ -298,43 +497,6 @@ void GameHandler::resetWardenState() {
     wardenModuleSize_ = 0;
     wardenModuleData_.clear();
     wardenLoadedModule_.reset();
-}
-
-void GameHandler::disconnect() {
-    if (onTaxiFlight_) {
-        taxiRecoverPending_ = true;
-    } else {
-        taxiRecoverPending_ = false;
-    }
-    if (socket) {
-        socket->disconnect();
-        socket.reset();
-    }
-    activeCharacterGuid_ = 0;
-    guildNameCache_.clear();
-    pendingGuildNameQueries_.clear();
-    friendGuids_.clear();
-    contacts_.clear();
-    transportAttachments_.clear();
-    resetWardenState();
-    pendingIncomingPackets_.clear();
-    // Fire despawn callbacks so the renderer releases M2/character model resources.
-    for (const auto& [guid, entity] : entityController_->getEntityManager().getEntities()) {
-        if (guid == playerGuid) continue;
-        if (entity->getType() == ObjectType::UNIT && creatureDespawnCallback_)
-            creatureDespawnCallback_(guid);
-        else if (entity->getType() == ObjectType::PLAYER && playerDespawnCallback_)
-            playerDespawnCallback_(guid);
-        else if (entity->getType() == ObjectType::GAMEOBJECT && gameObjectDespawnCallback_)
-            gameObjectDespawnCallback_(guid);
-    }
-    otherPlayerVisibleItemEntries_.clear();
-    otherPlayerVisibleDirty_.clear();
-    otherPlayerMoveTimeMs_.clear();
-    if (spellHandler_) spellHandler_->unitCastStates_.clear();
-    if (spellHandler_) spellHandler_->unitAurasCache_.clear();
-    if (combatHandler_) combatHandler_->clearCombatText();
-    entityController_->clearAll();
     setState(WorldState::DISCONNECTED);
     LOG_INFO("Disconnected from world server");
 }
@@ -357,13 +519,6 @@ void GameHandler::resetDbcCaches() {
     talentDbcLoaded_ = false;
     talentCache_.clear();
     talentTabCache_.clear();
-    // Clear the AssetManager DBC file cache so that expansion-specific DBCs
-    // (CharSections, ItemDisplayInfo, etc.) are reloaded from the new expansion's
-    // MPQ files instead of returning stale data from a previous session/expansion.
-    auto* am = services_.assetManager;
-    if (am) {
-        am->clearDBCCache();
-    }
     LOG_INFO("GameHandler: DBC caches cleared for expansion switch");
 }
 
@@ -371,11 +526,17 @@ bool GameHandler::isConnected() const {
     return socket && socket->isConnected();
 }
 
-void GameHandler::updateNetworking(float deltaTime) {
-    // Reset per-tick monster-move budget tracking (Classic/Turtle flood protection).
-    if (movementHandler_) {
-        movementHandler_->monsterMovePacketsThisTick_ = 0;
-        movementHandler_->monsterMovePacketsDroppedThisTick_ = 0;
+void GameHandler::update(float deltaTime) {
+    // Fire deferred char-create callback (outside ImGui render)
+    if (pendingCharCreateResult_) {
+        pendingCharCreateResult_ = false;
+        if (charCreateCallback_) {
+            charCreateCallback_(pendingCharCreateSuccess_, pendingCharCreateMsg_);
+        }
+    }
+
+    if (!socket) {
+        return;
     }
 
     // Update socket (processes incoming data and triggers callbacks)
@@ -389,60 +550,11 @@ void GameHandler::updateNetworking(float deltaTime) {
         }
     }
 
-    {
-        auto packetStart = std::chrono::steady_clock::now();
-        processQueuedIncomingPackets();
-        float packetMs = std::chrono::duration<float, std::milli>(
-            std::chrono::steady_clock::now() - packetStart).count();
-        if (packetMs > 3.0f) {
-            LOG_WARNING("SLOW queued packet handling: ", packetMs, "ms");
-        }
-    }
-
-    // Drain pending async Warden response (built on background thread to avoid 5s stalls)
-    if (wardenResponsePending_) {
-        auto status = wardenPendingEncrypted_.wait_for(std::chrono::milliseconds(0));
-        if (status == std::future_status::ready) {
-            auto plaintext = wardenPendingEncrypted_.get();
-            wardenResponsePending_ = false;
-            if (!plaintext.empty() && wardenCrypto_) {
-                std::vector<uint8_t> encrypted = wardenCrypto_->encrypt(plaintext);
-                network::Packet response(wireOpcode(Opcode::CMSG_WARDEN_DATA));
-                for (uint8_t byte : encrypted) {
-                    response.writeUInt8(byte);
-                }
-                if (socket && socket->isConnected()) {
-                    socket->send(response);
-                    LOG_WARNING("Warden: Sent async CHEAT_CHECKS_RESULT (", plaintext.size(), " bytes plaintext)");
-                }
-            }
-        }
-    }
-
-    // Detect RX silence (server stopped sending packets but TCP still open)
-    if (isInWorld() && socket->isConnected() &&
-        lastRxTime_.time_since_epoch().count() > 0) {
-        auto silenceMs = std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now() - lastRxTime_).count();
-        if (silenceMs > 10000 && !rxSilenceLogged_) {
-            rxSilenceLogged_ = true;
-            LOG_WARNING("RX SILENCE: No packets from server for ", silenceMs, "ms — possible soft disconnect");
-        }
-        if (silenceMs > 15000 && !rxSilence15sLogged_) {
-            rxSilence15sLogged_ = true;
-            LOG_WARNING("RX SILENCE: 15s — server appears to have stopped sending");
-        }
-    }
-
     // Detect server-side disconnect (socket closed during update)
     if (socket && !socket->isConnected() && state != WorldState::DISCONNECTED) {
-        if (pendingIncomingPackets_.empty() && !entityController_->hasPendingUpdateObjectWork()) {
-            LOG_WARNING("Server closed connection in state: ", worldStateName(state));
-            disconnect();
-            return;
-        }
-        LOG_DEBUG("World socket closed with ", pendingIncomingPackets_.size(),
-                  " queued packet(s) and update-object batch(es) pending dispatch");
+        LOG_WARNING("Server closed connection in state: ", worldStateName(state));
+        disconnect();
+        return;
     }
 
     // Post-gate visibility: determine whether server goes silent or closes after Warden requirement.
@@ -455,188 +567,10 @@ void GameHandler::updateNetworking(float deltaTime) {
             wardenGateNextStatusLog_ += 30.0f;
         }
     }
-}
 
-void GameHandler::updateTaxiAndMountState(float deltaTime) {
-// Update taxi landing cooldown
-if (taxiLandingCooldown_ > 0.0f) {
-    taxiLandingCooldown_ -= deltaTime;
-}
-if (taxiStartGrace_ > 0.0f) {
-    taxiStartGrace_ -= deltaTime;
-}
-if (playerTransportStickyTimer_ > 0.0f) {
-    playerTransportStickyTimer_ -= deltaTime;
-    if (playerTransportStickyTimer_ <= 0.0f) {
-        playerTransportStickyTimer_ = 0.0f;
-        playerTransportStickyGuid_ = 0;
-    }
-}
-
-// Detect taxi flight landing: UNIT_FLAG_TAXI_FLIGHT (0x00000100) cleared
-if (onTaxiFlight_) {
-    updateClientTaxi(deltaTime);
-    auto playerEntity = entityController_->getEntityManager().getEntity(playerGuid);
-    auto unit = std::dynamic_pointer_cast<Unit>(playerEntity);
-    if (unit &&
-        (unit->getUnitFlags() & 0x00000100) == 0 &&
-        !taxiClientActive_ &&
-        !taxiActivatePending_ &&
-        taxiStartGrace_ <= 0.0f) {
-        onTaxiFlight_ = false;
-        taxiLandingCooldown_ = 2.0f;  // 2 second cooldown to prevent re-entering
-        if (taxiMountActive_ && mountCallback_) {
-            mountCallback_(0);
-        }
-        taxiMountActive_ = false;
-        taxiMountDisplayId_ = 0;
-        currentMountDisplayId_ = 0;
-        taxiClientActive_ = false;
-        taxiClientPath_.clear();
-        taxiRecoverPending_ = false;
-        movementInfo.flags = 0;
-        movementInfo.flags2 = 0;
-        if (socket) {
-            sendMovement(Opcode::MSG_MOVE_STOP);
-            sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
-        }
-        LOG_INFO("Taxi flight landed");
-    }
-}
-
-// Safety: if taxi flight ended but mount is still active, force dismount.
-// Guard against transient taxi-state flicker.
-if (!onTaxiFlight_ && taxiMountActive_) {
-    bool serverStillTaxi = false;
-    auto playerEntity = entityController_->getEntityManager().getEntity(playerGuid);
-    auto playerUnit = std::dynamic_pointer_cast<Unit>(playerEntity);
-    if (playerUnit) {
-        serverStillTaxi = (playerUnit->getUnitFlags() & 0x00000100) != 0;
-    }
-
-    if (taxiStartGrace_ > 0.0f || serverStillTaxi || taxiClientActive_ || taxiActivatePending_) {
-        onTaxiFlight_ = true;
-    } else {
-        if (mountCallback_) mountCallback_(0);
-        taxiMountActive_ = false;
-        taxiMountDisplayId_ = 0;
-        currentMountDisplayId_ = 0;
-        movementInfo.flags = 0;
-        movementInfo.flags2 = 0;
-        if (socket) {
-            sendMovement(Opcode::MSG_MOVE_STOP);
-            sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
-        }
-        LOG_INFO("Taxi dismount cleanup");
-    }
-}
-
-// Keep non-taxi mount state server-authoritative.
-// Some server paths don't emit explicit mount field updates in lockstep
-// with local visual state changes, so reconcile continuously.
-if (!onTaxiFlight_ && !taxiMountActive_) {
-    auto playerEntity = entityController_->getEntityManager().getEntity(playerGuid);
-    auto playerUnit = std::dynamic_pointer_cast<Unit>(playerEntity);
-    if (playerUnit) {
-        uint32_t serverMountDisplayId = playerUnit->getMountDisplayId();
-        if (serverMountDisplayId != currentMountDisplayId_) {
-            LOG_INFO("Mount reconcile: server=", serverMountDisplayId,
-                     " local=", currentMountDisplayId_);
-            currentMountDisplayId_ = serverMountDisplayId;
-            if (mountCallback_) {
-                mountCallback_(serverMountDisplayId);
-            }
-        }
-    }
-}
-
-if (taxiRecoverPending_ && state == WorldState::IN_WORLD) {
-    auto playerEntity = entityController_->getEntityManager().getEntity(playerGuid);
-    if (playerEntity) {
-        playerEntity->setPosition(taxiRecoverPos_.x, taxiRecoverPos_.y,
-                                  taxiRecoverPos_.z, movementInfo.orientation);
-        movementInfo.x = taxiRecoverPos_.x;
-        movementInfo.y = taxiRecoverPos_.y;
-        movementInfo.z = taxiRecoverPos_.z;
-        if (socket) {
-            sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
-        }
-        taxiRecoverPending_ = false;
-        LOG_INFO("Taxi recovery applied");
-    }
-}
-
-if (taxiActivatePending_) {
-    taxiActivateTimer_ += deltaTime;
-    if (taxiActivateTimer_ > 5.0f) {
-        // If client taxi simulation is already active, server reply may be missing/late.
-        // Do not cancel the flight in that case; clear pending state and continue.
-        if (onTaxiFlight_ || taxiClientActive_ || taxiMountActive_) {
-            taxiActivatePending_ = false;
-            taxiActivateTimer_ = 0.0f;
-        } else {
-        taxiActivatePending_ = false;
-        taxiActivateTimer_ = 0.0f;
-        if (taxiMountActive_ && mountCallback_) {
-            mountCallback_(0);
-        }
-        taxiMountActive_ = false;
-        taxiMountDisplayId_ = 0;
-        taxiClientActive_ = false;
-        taxiClientPath_.clear();
-        onTaxiFlight_ = false;
-        LOG_WARNING("Taxi activation timed out");
-        }
-    }
-}
-}
-
-void GameHandler::updateAutoAttack(float deltaTime) {
-    if (combatHandler_) combatHandler_->updateAutoAttack(deltaTime);
-
-// Close NPC windows if player walks too far (15 units)
-}
-
-void GameHandler::updateEntityInterpolation(float deltaTime) {
-// Update entity movement interpolation (keeps targeting in sync with visuals)
-// Only update entities within reasonable distance for performance
-const float updateRadiusSq = 150.0f * 150.0f;  // 150 unit radius
-auto playerEntity = entityController_->getEntityManager().getEntity(playerGuid);
-glm::vec3 playerPos = playerEntity ? glm::vec3(playerEntity->getX(), playerEntity->getY(), playerEntity->getZ()) : glm::vec3(0.0f);
-
-for (auto& [guid, entity] : entityController_->getEntityManager().getEntities()) {
-    // Always update player
-    if (guid == playerGuid) {
-        entity->updateMovement(deltaTime);
-        continue;
-    }
-    // Keep selected/engaged target interpolation exact for UI targeting circle.
-    if (guid == targetGuid || (combatHandler_ && guid == combatHandler_->getAutoAttackTargetGuid())) {
-        entity->updateMovement(deltaTime);
-        continue;
-    }
-
-    // Distance cull other entities (use latest position to avoid culling by stale origin)
-    glm::vec3 entityPos(entity->getLatestX(), entity->getLatestY(), entity->getLatestZ());
-    float distSq = glm::dot(entityPos - playerPos, entityPos - playerPos);
-    if (distSq < updateRadiusSq) {
-        entity->updateMovement(deltaTime);
-    }
-}
-}
-
-void GameHandler::updateTimers(float deltaTime) {
-    if (spellHandler_) spellHandler_->updateTimers(deltaTime);
-
-    // Periodically clear stale pending item queries so they can be retried.
-    // Without this, a lost/malformed response leaves the entry stuck forever.
-    pendingItemQueryTimer_ += deltaTime;
-    if (pendingItemQueryTimer_ >= 5.0f) {
-        pendingItemQueryTimer_ = 0.0f;
-        if (!pendingItemQueries_.empty()) {
-            LOG_DEBUG("Clearing ", pendingItemQueries_.size(), " stale pending item queries");
-            pendingItemQueries_.clear();
-        }
+    // Validate target still exists
+    if (targetGuid != 0 && !entityManager.hasEntity(targetGuid)) {
+        clearTarget();
     }
 
     if (auctionSearchDelayTimer_ > 0.0f) {
@@ -665,7 +599,9 @@ void GameHandler::updateTimers(float deltaTime) {
             pendingMoneyDelta_ = 0;
         }
     }
-    // autoAttackRangeWarnCooldown_ decrement moved into CombatHandler::updateAutoAttack()
+    if (autoAttackRangeWarnCooldown_ > 0.0f) {
+        autoAttackRangeWarnCooldown_ = std::max(0.0f, autoAttackRangeWarnCooldown_ - deltaTime);
+    }
 
     if (pendingLoginQuestResync_) {
         pendingLoginQuestResyncTimeout_ -= deltaTime;
@@ -682,7 +618,7 @@ void GameHandler::updateTimers(float deltaTime) {
     for (auto it = pendingGameObjectLootRetries_.begin(); it != pendingGameObjectLootRetries_.end();) {
         it->timer -= deltaTime;
         if (it->timer <= 0.0f) {
-            if (it->remainingRetries > 0 && isInWorld()) {
+            if (it->remainingRetries > 0 && state == WorldState::IN_WORLD && socket) {
                 // Keep server-side position/facing fresh before retrying GO use.
                 sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
                 auto usePacket = GameObjectUsePacket::build(it->guid);
@@ -705,14 +641,7 @@ void GameHandler::updateTimers(float deltaTime) {
     for (auto it = pendingGameObjectLootOpens_.begin(); it != pendingGameObjectLootOpens_.end();) {
         it->timer -= deltaTime;
         if (it->timer <= 0.0f) {
-            if (isInWorld()) {
-                // Avoid sending CMSG_LOOT while a timed cast is active (e.g. gathering).
-                // handleSpellGo will trigger loot after the cast completes.
-                if (spellHandler_ && spellHandler_->casting_ && spellHandler_->currentCastSpellId_ != 0) {
-                    it->timer = 0.20f;
-                    ++it;
-                    continue;
-                }
+            if (state == WorldState::IN_WORLD && socket) {
                 lootTarget(it->guid);
             }
             it = pendingGameObjectLootOpens_.erase(it);
@@ -721,25 +650,6 @@ void GameHandler::updateTimers(float deltaTime) {
         }
     }
 
-    // Periodically re-query names for players whose initial CMSG_NAME_QUERY was
-    // lost (server didn't respond) or whose entity was recreated while the query
-    // was still pending. Runs every 5 seconds to keep overhead minimal.
-    if (isInWorld()) {
-        static float nameResyncTimer = 0.0f;
-        nameResyncTimer += deltaTime;
-        if (nameResyncTimer >= 5.0f) {
-            nameResyncTimer = 0.0f;
-            for (const auto& [guid, entity] : entityController_->getEntityManager().getEntities()) {
-                if (!entity || entity->getType() != ObjectType::PLAYER) continue;
-                if (guid == playerGuid) continue;
-                auto player = std::static_pointer_cast<Player>(entity);
-                if (!player->getName().empty()) continue;
-                // Player entity exists with empty name and no pending query — resend.
-                entityController_->queryPlayerName(guid);
-            }
-        }
-    }
-
     if (pendingLootMoneyNotifyTimer_ > 0.0f) {
         pendingLootMoneyNotifyTimer_ -= deltaTime;
         if (pendingLootMoneyNotifyTimer_ <= 0.0f) {
@@ -754,9 +664,9 @@ void GameHandler::updateTimers(float deltaTime) {
             }
             if (!alreadyAnnounced && pendingLootMoneyAmount_ > 0) {
                 addSystemChatMessage("Looted: " + formatCopperAmount(pendingLootMoneyAmount_));
-                auto* ac = services_.audioCoordinator;
-                if (ac) {
-                    if (auto* sfx = ac->getUiSoundManager()) {
+                auto* renderer = core::Application::getInstance().getRenderer();
+                if (renderer) {
+                    if (auto* sfx = renderer->getUiSoundManager()) {
                         if (pendingLootMoneyAmount_ >= 10000) {
                             sfx->playLootCoinLarge();
                         } else {
@@ -786,69 +696,23 @@ void GameHandler::updateTimers(float deltaTime) {
     if (inspectRateLimit_ > 0.0f) {
         inspectRateLimit_ = std::max(0.0f, inspectRateLimit_ - deltaTime);
     }
-    if (isInWorld() && inspectRateLimit_ <= 0.0f && !pendingAutoInspect_.empty()) {
+    if (state == WorldState::IN_WORLD && socket && inspectRateLimit_ <= 0.0f && !pendingAutoInspect_.empty()) {
         uint64_t guid = *pendingAutoInspect_.begin();
         pendingAutoInspect_.erase(pendingAutoInspect_.begin());
-        if (guid != 0 && guid != playerGuid && entityController_->getEntityManager().hasEntity(guid)) {
+        if (guid != 0 && guid != playerGuid && entityManager.hasEntity(guid)) {
             auto pkt = InspectPacket::build(guid);
             socket->send(pkt);
             inspectRateLimit_ = 2.0f; // throttle to avoid compositing stutter
             LOG_DEBUG("Sent CMSG_INSPECT for player 0x", std::hex, guid, std::dec);
         }
     }
-}
-
-void GameHandler::update(float deltaTime) {
-    // Fire deferred char-create callback (outside ImGui render)
-    if (pendingCharCreateResult_) {
-        pendingCharCreateResult_ = false;
-        if (charCreateCallback_) {
-            charCreateCallback_(pendingCharCreateSuccess_, pendingCharCreateMsg_);
-        }
-    }
-
-    if (!socket) {
-        return;
-    }
-
-    updateNetworking(deltaTime);
-    if (!socket) return;  // disconnect() may have been called
-
-    // Validate target still exists
-    if (targetGuid != 0 && !entityController_->getEntityManager().hasEntity(targetGuid)) {
-        clearTarget();
-    }
-
-    // Update auto-follow: refresh render position or cancel if entity disappeared
-    if (followTargetGuid_ != 0) {
-        auto followEnt = entityController_->getEntityManager().getEntity(followTargetGuid_);
-        if (followEnt) {
-            followRenderPos_ = core::coords::canonicalToRender(
-                glm::vec3(followEnt->getX(), followEnt->getY(), followEnt->getZ()));
-        } else {
-            cancelFollow();
-        }
-    }
-
-    // Detect combat state transitions → fire PLAYER_REGEN_DISABLED / PLAYER_REGEN_ENABLED
-    {
-        bool combatNow = isInCombat();
-        if (combatNow != wasCombat_) {
-            wasCombat_ = combatNow;
-                fireAddonEvent(combatNow ? "PLAYER_REGEN_DISABLED" : "PLAYER_REGEN_ENABLED", {});
-        }
-    }
-
-    updateTimers(deltaTime);
 
     // Send periodic heartbeat if in world
     if (state == WorldState::IN_WORLD) {
         timeSinceLastPing += deltaTime;
-        if (movementHandler_) movementHandler_->timeSinceLastMoveHeartbeat_ += deltaTime;
+        timeSinceLastMoveHeartbeat_ += deltaTime;
 
-        const float currentPingInterval =
-            (isPreWotlk()) ? 10.0f : pingInterval;
-        if (timeSinceLastPing >= currentPingInterval) {
+        if (timeSinceLastPing >= pingInterval) {
             if (socket) {
                 sendPing();
             }
@@ -856,35 +720,13 @@ void GameHandler::update(float deltaTime) {
         }
 
         const bool classicLikeCombatSync =
-            (combatHandler_ && combatHandler_->hasAutoAttackIntent()) && (isPreWotlk());
-        // Must match the locomotion bitmask in movement_handler.cpp so both
-        // sites agree on what constitutes "moving" for heartbeat throttling.
-        const uint32_t locomotionFlags =
-            static_cast<uint32_t>(MovementFlags::FORWARD) |
-            static_cast<uint32_t>(MovementFlags::BACKWARD) |
-            static_cast<uint32_t>(MovementFlags::STRAFE_LEFT) |
-            static_cast<uint32_t>(MovementFlags::STRAFE_RIGHT) |
-            static_cast<uint32_t>(MovementFlags::TURN_LEFT) |
-            static_cast<uint32_t>(MovementFlags::TURN_RIGHT) |
-            static_cast<uint32_t>(MovementFlags::ASCENDING) |
-            static_cast<uint32_t>(MovementFlags::DESCENDING) |
-            static_cast<uint32_t>(MovementFlags::SWIMMING) |
-            static_cast<uint32_t>(MovementFlags::FALLING) |
-            static_cast<uint32_t>(MovementFlags::FALLINGFAR);
-        const bool classicLikeStationaryCombatSync =
-            classicLikeCombatSync &&
-            !onTaxiFlight_ &&
-            !taxiActivatePending_ &&
-            !taxiClientActive_ &&
-            (movementInfo.flags & locomotionFlags) == 0;
+            autoAttackRequested_ && (isClassicLikeExpansion() || isActiveExpansion("tbc"));
         float heartbeatInterval = (onTaxiFlight_ || taxiActivatePending_ || taxiClientActive_)
                                       ? 0.25f
-                                      : (classicLikeStationaryCombatSync ? 0.75f
-                                                                         : (classicLikeCombatSync ? 0.20f
-                                                                                                  : moveHeartbeatInterval_));
-        if (movementHandler_ && movementHandler_->timeSinceLastMoveHeartbeat_ >= heartbeatInterval) {
+                                      : (classicLikeCombatSync ? 0.05f : moveHeartbeatInterval_);
+        if (timeSinceLastMoveHeartbeat_ >= heartbeatInterval) {
             sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
-            movementHandler_->timeSinceLastMoveHeartbeat_ = 0.0f;
+            timeSinceLastMoveHeartbeat_ = 0.0f;
         }
 
         // Check area triggers (instance portals, tavern rests, etc.)
@@ -894,34 +736,38 @@ void GameHandler::update(float deltaTime) {
             checkAreaTriggers();
         }
 
-        // Cancel GO interaction cast if player enters combat (auto-attack).
+        // Update cast timer (Phase 3)
         if (pendingGameObjectInteractGuid_ != 0 &&
-            combatHandler_ && (combatHandler_->isAutoAttacking() || combatHandler_->hasAutoAttackIntent())) {
+            (autoAttacking || autoAttackRequested_)) {
             pendingGameObjectInteractGuid_ = 0;
-            if (spellHandler_) spellHandler_->resetCastState();
-            addUIError("Interrupted.");
+            casting = false;
+            currentCastSpellId = 0;
+            castTimeRemaining = 0.0f;
             addSystemChatMessage("Interrupted.");
         }
-        // Check if client-side cast timer expired (tick-down is in SpellHandler::updateTimers).
-        // Two paths depending on whether this is a GO interaction cast:
-        if (spellHandler_ && spellHandler_->casting_ && spellHandler_->castTimeRemaining_ <= 0.0f) {
-            if (pendingGameObjectInteractGuid_ != 0) {
-                // GO interaction cast: do NOT call resetCastState() here. The server
-                // sends SMSG_SPELL_GO when the cast completes server-side (~50-200ms
-                // after the client timer expires due to float precision/frame timing).
-                // handleSpellGo checks `wasInTimedCast = casting_ && spellId == currentCastSpellId_`
-                // — if we clear those fields now, wasInTimedCast is false and the loot
-                // path (CMSG_LOOT via lastInteractedGoGuid_) never fires.
-                // Let the cast bar sit at 100% until SMSG_SPELL_GO arrives to clean up.
-                pendingGameObjectInteractGuid_ = 0;
-            } else {
-                // Regular cast with no GO pending: clean up immediately.
-                spellHandler_->resetCastState();
+        if (casting && castTimeRemaining > 0.0f) {
+            castTimeRemaining -= deltaTime;
+            if (castTimeRemaining <= 0.0f) {
+                if (pendingGameObjectInteractGuid_ != 0) {
+                    uint64_t interactGuid = pendingGameObjectInteractGuid_;
+                    pendingGameObjectInteractGuid_ = 0;
+                    performGameObjectInteractionNow(interactGuid);
+                }
+                casting = false;
+                currentCastSpellId = 0;
+                castTimeRemaining = 0.0f;
             }
         }
 
-        // Unit cast states and spell cooldowns are ticked by SpellHandler::updateTimers()
-        // (called from GameHandler::updateTimers above). No duplicate tick-down here.
+        // Update spell cooldowns (Phase 3)
+        for (auto it = spellCooldowns.begin(); it != spellCooldowns.end(); ) {
+            it->second -= deltaTime;
+            if (it->second <= 0.0f) {
+                it = spellCooldowns.erase(it);
+            } else {
+                ++it;
+            }
+        }
 
         // Update action bar cooldowns
         for (auto& slot : actionBar) {
@@ -933,12 +779,138 @@ void GameHandler::update(float deltaTime) {
 
         // Update combat text (Phase 2)
         updateCombatText(deltaTime);
-        tickMinimapPings(deltaTime);
 
-        // Tick logout countdown
-        if (socialHandler_) socialHandler_->updateLogoutCountdown(deltaTime);
+        // Update taxi landing cooldown
+        if (taxiLandingCooldown_ > 0.0f) {
+            taxiLandingCooldown_ -= deltaTime;
+        }
+        if (taxiStartGrace_ > 0.0f) {
+            taxiStartGrace_ -= deltaTime;
+        }
+        if (playerTransportStickyTimer_ > 0.0f) {
+            playerTransportStickyTimer_ -= deltaTime;
+            if (playerTransportStickyTimer_ <= 0.0f) {
+                playerTransportStickyTimer_ = 0.0f;
+                playerTransportStickyGuid_ = 0;
+            }
+        }
 
-        updateTaxiAndMountState(deltaTime);
+        // Detect taxi flight landing: UNIT_FLAG_TAXI_FLIGHT (0x00000100) cleared
+        if (onTaxiFlight_) {
+            updateClientTaxi(deltaTime);
+            auto playerEntity = entityManager.getEntity(playerGuid);
+            auto unit = std::dynamic_pointer_cast<Unit>(playerEntity);
+            if (unit &&
+                (unit->getUnitFlags() & 0x00000100) == 0 &&
+                !taxiClientActive_ &&
+                !taxiActivatePending_ &&
+                taxiStartGrace_ <= 0.0f) {
+                onTaxiFlight_ = false;
+                taxiLandingCooldown_ = 2.0f;  // 2 second cooldown to prevent re-entering
+                if (taxiMountActive_ && mountCallback_) {
+                    mountCallback_(0);
+                }
+                taxiMountActive_ = false;
+                taxiMountDisplayId_ = 0;
+                currentMountDisplayId_ = 0;
+                taxiClientActive_ = false;
+                taxiClientPath_.clear();
+                taxiRecoverPending_ = false;
+                movementInfo.flags = 0;
+                movementInfo.flags2 = 0;
+                if (socket) {
+                    sendMovement(Opcode::MSG_MOVE_STOP);
+                    sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
+                }
+                LOG_INFO("Taxi flight landed");
+            }
+        }
+
+        // Safety: if taxi flight ended but mount is still active, force dismount.
+        // Guard against transient taxi-state flicker.
+        if (!onTaxiFlight_ && taxiMountActive_) {
+            bool serverStillTaxi = false;
+            auto playerEntity = entityManager.getEntity(playerGuid);
+            auto playerUnit = std::dynamic_pointer_cast<Unit>(playerEntity);
+            if (playerUnit) {
+                serverStillTaxi = (playerUnit->getUnitFlags() & 0x00000100) != 0;
+            }
+
+            if (taxiStartGrace_ > 0.0f || serverStillTaxi || taxiClientActive_ || taxiActivatePending_) {
+                onTaxiFlight_ = true;
+            } else {
+                if (mountCallback_) mountCallback_(0);
+                taxiMountActive_ = false;
+                taxiMountDisplayId_ = 0;
+                currentMountDisplayId_ = 0;
+                movementInfo.flags = 0;
+                movementInfo.flags2 = 0;
+                if (socket) {
+                    sendMovement(Opcode::MSG_MOVE_STOP);
+                    sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
+                }
+                LOG_INFO("Taxi dismount cleanup");
+            }
+        }
+
+        // Keep non-taxi mount state server-authoritative.
+        // Some server paths don't emit explicit mount field updates in lockstep
+        // with local visual state changes, so reconcile continuously.
+        if (!onTaxiFlight_ && !taxiMountActive_) {
+            auto playerEntity = entityManager.getEntity(playerGuid);
+            auto playerUnit = std::dynamic_pointer_cast<Unit>(playerEntity);
+            if (playerUnit) {
+                uint32_t serverMountDisplayId = playerUnit->getMountDisplayId();
+                if (serverMountDisplayId != currentMountDisplayId_) {
+                    LOG_INFO("Mount reconcile: server=", serverMountDisplayId,
+                             " local=", currentMountDisplayId_);
+                    currentMountDisplayId_ = serverMountDisplayId;
+                    if (mountCallback_) {
+                        mountCallback_(serverMountDisplayId);
+                    }
+                }
+            }
+        }
+
+        if (taxiRecoverPending_ && state == WorldState::IN_WORLD) {
+            auto playerEntity = entityManager.getEntity(playerGuid);
+            if (playerEntity) {
+                playerEntity->setPosition(taxiRecoverPos_.x, taxiRecoverPos_.y,
+                                          taxiRecoverPos_.z, movementInfo.orientation);
+                movementInfo.x = taxiRecoverPos_.x;
+                movementInfo.y = taxiRecoverPos_.y;
+                movementInfo.z = taxiRecoverPos_.z;
+                if (socket) {
+                    sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
+                }
+                taxiRecoverPending_ = false;
+                LOG_INFO("Taxi recovery applied");
+            }
+        }
+
+        if (taxiActivatePending_) {
+            taxiActivateTimer_ += deltaTime;
+            if (taxiActivateTimer_ > 5.0f) {
+                // If client taxi simulation is already active, server reply may be missing/late.
+                // Do not cancel the flight in that case; clear pending state and continue.
+                if (onTaxiFlight_ || taxiClientActive_ || taxiMountActive_) {
+                    taxiActivatePending_ = false;
+                    taxiActivateTimer_ = 0.0f;
+                } else {
+                taxiActivatePending_ = false;
+                taxiActivateTimer_ = 0.0f;
+                if (taxiMountActive_ && mountCallback_) {
+                    mountCallback_(0);
+                }
+                taxiMountActive_ = false;
+                taxiMountDisplayId_ = 0;
+                taxiClientActive_ = false;
+                taxiClientPath_.clear();
+                onTaxiFlight_ = false;
+                LOG_WARNING("Taxi activation timed out");
+                }
+            }
+        }
 
         // Update transport manager
         if (transportManager_) {
@@ -946,2522 +918,190 @@ void GameHandler::update(float deltaTime) {
             updateAttachedTransportChildren(deltaTime);
         }
 
-        updateAutoAttack(deltaTime);
-        auto closeIfTooFar = [&](bool windowOpen, uint64_t npcGuid, auto closeFn, const char* label) {
-            if (!windowOpen || npcGuid == 0) return;
-            auto npc = entityController_->getEntityManager().getEntity(npcGuid);
-            if (!npc) return;
-            float dx = movementInfo.x - npc->getX();
-            float dy = movementInfo.y - npc->getY();
-            if (std::sqrt(dx * dx + dy * dy) > 15.0f) {
-                closeFn();
-                LOG_INFO(label, " closed: walked too far from NPC");
-            }
-        };
-        closeIfTooFar(isVendorWindowOpen(), getVendorItems().vendorGuid, [this]{ closeVendor(); }, "Vendor");
-        closeIfTooFar(isGossipWindowOpen(), getCurrentGossip().npcGuid, [this]{ closeGossip(); }, "Gossip");
-        closeIfTooFar(isTaxiWindowOpen(), taxiNpcGuid_, [this]{ closeTaxi(); }, "Taxi window");
-        closeIfTooFar(isTrainerWindowOpen(), getTrainerSpells().trainerGuid, [this]{ closeTrainer(); }, "Trainer");
-
-        updateEntityInterpolation(deltaTime);
-
-    }
-}
-
-void GameHandler::registerOpcodeHandlers() {
-    // -----------------------------------------------------------------------
-    // Auth / session / pre-world handshake
-    // -----------------------------------------------------------------------
-    dispatchTable_[Opcode::SMSG_AUTH_CHALLENGE] = [this](network::Packet& packet) {
-        if (state == WorldState::CONNECTED)
-            handleAuthChallenge(packet);
-        else
-            LOG_WARNING("Unexpected SMSG_AUTH_CHALLENGE in state: ", worldStateName(state));
-    };
-    dispatchTable_[Opcode::SMSG_AUTH_RESPONSE] = [this](network::Packet& packet) {
-        if (state == WorldState::AUTH_SENT)
-            handleAuthResponse(packet);
-        else
-            LOG_WARNING("Unexpected SMSG_AUTH_RESPONSE in state: ", worldStateName(state));
-    };
-    dispatchTable_[Opcode::SMSG_CHAR_CREATE] = [this](network::Packet& packet) {
-        handleCharCreateResponse(packet);
-    };
-    dispatchTable_[Opcode::SMSG_CHAR_DELETE] = [this](network::Packet& packet) {
-        uint8_t result = packet.readUInt8();
-        lastCharDeleteResult_ = result;
-        bool success = (result == 0x00 || result == 0x47);
-        LOG_INFO("SMSG_CHAR_DELETE result: ", static_cast<int>(result), success ? " (success)" : " (failed)");
-        requestCharacterList();
-        if (charDeleteCallback_) charDeleteCallback_(success);
-    };
-    dispatchTable_[Opcode::SMSG_CHAR_ENUM] = [this](network::Packet& packet) {
-        if (state == WorldState::CHAR_LIST_REQUESTED)
-            handleCharEnum(packet);
-        else
-            LOG_WARNING("Unexpected SMSG_CHAR_ENUM in state: ", worldStateName(state));
-    };
-    registerHandler(Opcode::SMSG_CHARACTER_LOGIN_FAILED, &GameHandler::handleCharLoginFailed);
-    dispatchTable_[Opcode::SMSG_LOGIN_VERIFY_WORLD] = [this](network::Packet& packet) {
-        if (state == WorldState::ENTERING_WORLD || state == WorldState::IN_WORLD)
-            handleLoginVerifyWorld(packet);
-        else
-            LOG_WARNING("Unexpected SMSG_LOGIN_VERIFY_WORLD in state: ", worldStateName(state));
-    };
-    registerHandler(Opcode::SMSG_LOGIN_SETTIMESPEED, &GameHandler::handleLoginSetTimeSpeed);
-    registerHandler(Opcode::SMSG_CLIENTCACHE_VERSION, &GameHandler::handleClientCacheVersion);
-    registerHandler(Opcode::SMSG_TUTORIAL_FLAGS, &GameHandler::handleTutorialFlags);
-    registerHandler(Opcode::SMSG_ACCOUNT_DATA_TIMES, &GameHandler::handleAccountDataTimes);
-    registerHandler(Opcode::SMSG_MOTD, &GameHandler::handleMotd);
-    registerHandler(Opcode::SMSG_NOTIFICATION, &GameHandler::handleNotification);
-    registerHandler(Opcode::SMSG_PONG, &GameHandler::handlePong);
-
-    // -----------------------------------------------------------------------
-    // World object updates + entity queries (delegated to EntityController)
-    // -----------------------------------------------------------------------
-    entityController_->registerOpcodes(dispatchTable_);
-
-    // -----------------------------------------------------------------------
-    // Item push / logout
-    // -----------------------------------------------------------------------
-    registerSkipHandler(Opcode::SMSG_ADDON_INFO);
-    registerSkipHandler(Opcode::SMSG_EXPECTED_SPAM_RECORDS);
-
-    // -----------------------------------------------------------------------
-    // XP / exploration
-    // -----------------------------------------------------------------------
-    registerHandler(Opcode::SMSG_LOG_XPGAIN, &GameHandler::handleXpGain);
-    dispatchTable_[Opcode::SMSG_EXPLORATION_EXPERIENCE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(8)) {
-            uint32_t areaId   = packet.readUInt32();
-            uint32_t xpGained = packet.readUInt32();
-            if (xpGained > 0) {
-                std::string areaName = getAreaName(areaId);
-                std::string msg;
-                if (!areaName.empty()) {
-                    msg = "Discovered " + areaName + "! Gained " + std::to_string(xpGained) + " experience.";
-                } else {
-                    char buf[128];
-                    std::snprintf(buf, sizeof(buf), "Discovered new area! Gained %u experience.", xpGained);
-                    msg = buf;
-                }
-                addSystemChatMessage(msg);
-                addCombatText(CombatTextEntry::XP_GAIN, static_cast<int32_t>(xpGained), 0, true);
-                if (areaDiscoveryCallback_) areaDiscoveryCallback_(areaName, xpGained);
-                                    fireAddonEvent("CHAT_MSG_COMBAT_XP_GAIN", {msg, std::to_string(xpGained)});
-            }
-        }
-    };
-
-    registerSkipHandler(Opcode::SMSG_PET_NAME_QUERY_RESPONSE);
-
-    // -----------------------------------------------------------------------
-    // Entity delta updates: health / power / world state / combo / timers / PvP
-    // (SMSG_HEALTH_UPDATE, SMSG_POWER_UPDATE, SMSG_UPDATE_COMBO_POINTS,
-    //  SMSG_PVP_CREDIT, SMSG_PROCRESIST → moved to CombatHandler)
-    // -----------------------------------------------------------------------
-    dispatchTable_[Opcode::SMSG_UPDATE_WORLD_STATE] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(8)) return;
-        uint32_t field = packet.readUInt32();
-        uint32_t value = packet.readUInt32();
-        worldStates_[field] = value;
-        LOG_DEBUG("SMSG_UPDATE_WORLD_STATE: field=", field, " value=", value);
-        fireAddonEvent("UPDATE_WORLD_STATES", {});
-    };
-    dispatchTable_[Opcode::SMSG_WORLD_STATE_UI_TIMER_UPDATE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t serverTime = packet.readUInt32();
-            LOG_DEBUG("SMSG_WORLD_STATE_UI_TIMER_UPDATE: serverTime=", serverTime);
-        }
-    };
-    dispatchTable_[Opcode::SMSG_START_MIRROR_TIMER] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(21)) return;
-        uint32_t type  = packet.readUInt32();
-        int32_t  value = static_cast<int32_t>(packet.readUInt32());
-        int32_t  maxV  = static_cast<int32_t>(packet.readUInt32());
-        int32_t  scale = static_cast<int32_t>(packet.readUInt32());
-        /*uint32_t tracker =*/ packet.readUInt32();
-        uint8_t  paused = packet.readUInt8();
-        if (type < 3) {
-            mirrorTimers_[type].value    = value;
-            mirrorTimers_[type].maxValue = maxV;
-            mirrorTimers_[type].scale    = scale;
-            mirrorTimers_[type].paused   = (paused != 0);
-            mirrorTimers_[type].active   = true;
-                            fireAddonEvent("MIRROR_TIMER_START", {
-                    std::to_string(type), std::to_string(value),
-                    std::to_string(maxV), std::to_string(scale),
-                    paused ? "1" : "0"});
-        }
-    };
-    dispatchTable_[Opcode::SMSG_STOP_MIRROR_TIMER] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(4)) return;
-        uint32_t type = packet.readUInt32();
-        if (type < 3) {
-            mirrorTimers_[type].active = false;
-            mirrorTimers_[type].value  = 0;
-            fireAddonEvent("MIRROR_TIMER_STOP", {std::to_string(type)});
-        }
-    };
-    dispatchTable_[Opcode::SMSG_PAUSE_MIRROR_TIMER] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(5)) return;
-        uint32_t type   = packet.readUInt32();
-        uint8_t  paused = packet.readUInt8();
-        if (type < 3) {
-            mirrorTimers_[type].paused = (paused != 0);
-            fireAddonEvent("MIRROR_TIMER_PAUSE", {paused ? "1" : "0"});
-        }
-    };
-
-    // -----------------------------------------------------------------------
-    // Cast result / spell proc
-    // (SMSG_CAST_RESULT, SMSG_SPELL_FAILED_OTHER → moved to SpellHandler)
-    // (SMSG_PROCRESIST → moved to CombatHandler)
-    // -----------------------------------------------------------------------
-
-    // -----------------------------------------------------------------------
-    // Pet stable
-    // -----------------------------------------------------------------------
-    dispatchTable_[Opcode::MSG_LIST_STABLED_PETS] = [this](network::Packet& packet) {
-        if (state == WorldState::IN_WORLD) handleListStabledPets(packet);
-    };
-    dispatchTable_[Opcode::SMSG_STABLE_RESULT] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(1)) return;
-        uint8_t result = packet.readUInt8();
-        const char* msg = nullptr;
-        switch (result) {
-            case 0x01: msg = "Pet stored in stable."; break;
-            case 0x06: msg = "Pet retrieved from stable."; break;
-            case 0x07: msg = "Stable slot purchased."; break;
-            case 0x08: msg = "Stable list updated."; break;
-            case 0x09: msg = "Stable failed: not enough money or other error."; addUIError(msg); break;
-            default: break;
-        }
-        if (msg) addSystemChatMessage(msg);
-        LOG_INFO("SMSG_STABLE_RESULT: result=", static_cast<int>(result));
-        if (stableWindowOpen_ && stableMasterGuid_ != 0 && socket && result <= 0x08) {
-            auto refreshPkt = ListStabledPetsPacket::build(stableMasterGuid_);
-            socket->send(refreshPkt);
-        }
-    };
-
-    // -----------------------------------------------------------------------
-    // Titles / achievements / character services
-    // -----------------------------------------------------------------------
-    dispatchTable_[Opcode::SMSG_TITLE_EARNED] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(8)) return;
-        uint32_t titleBit = packet.readUInt32();
-        uint32_t isLost   = packet.readUInt32();
-        loadTitleNameCache();
-        std::string titleStr;
-        auto tit = titleNameCache_.find(titleBit);
-        if (tit != titleNameCache_.end() && !tit->second.empty()) {
-            const auto& ln = lookupName(playerGuid);
-            const std::string& pName = ln.empty() ? std::string("you") : ln;
-            const std::string& fmt = tit->second;
-            size_t pos = fmt.find("%s");
-            if (pos != std::string::npos)
-                titleStr = fmt.substr(0, pos) + pName + fmt.substr(pos + 2);
-            else
-                titleStr = fmt;
-        }
-        std::string msg;
-        if (!titleStr.empty()) {
-            msg = isLost ? ("Title removed: " + titleStr + ".") : ("Title earned: " + titleStr + "!");
-        } else {
-            char buf[64];
-            std::snprintf(buf, sizeof(buf), isLost ? "Title removed (bit %u)." : "Title earned (bit %u)!", titleBit);
-            msg = buf;
-        }
-        if (isLost) knownTitleBits_.erase(titleBit);
-        else        knownTitleBits_.insert(titleBit);
-        addSystemChatMessage(msg);
-        LOG_INFO("SMSG_TITLE_EARNED: bit=", titleBit, " lost=", isLost, " title='", titleStr, "'");
-    };
-    dispatchTable_[Opcode::SMSG_LEARNED_DANCE_MOVES] = [this](network::Packet& packet) {
-        LOG_DEBUG("SMSG_LEARNED_DANCE_MOVES: ignored (size=", packet.getSize(), ")");
-    };
-    dispatchTable_[Opcode::SMSG_CHAR_RENAME] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(13)) {
-            uint32_t result = packet.readUInt32();
-            /*uint64_t guid =*/ packet.readUInt64();
-            std::string newName = packet.readString();
-            if (result == 0) {
-                addSystemChatMessage("Character name changed to: " + newName);
-            } else {
-                static const char* kRenameErrors[] = {
-                    nullptr, "Name already in use.", "Name too short.", "Name too long.",
-                    "Name contains invalid characters.", "Name contains a profanity.",
-                    "Name is reserved.", "Character name does not meet requirements.",
-                };
-                const char* errMsg = (result < 8) ? kRenameErrors[result] : nullptr;
-                std::string renameErr = errMsg ? std::string("Rename failed: ") + errMsg : "Character rename failed.";
-                addUIError(renameErr); addSystemChatMessage(renameErr);
-            }
-            LOG_INFO("SMSG_CHAR_RENAME: result=", result, " newName=", newName);
-        }
-    };
-
-    // -----------------------------------------------------------------------
-    // Bind / heartstone / phase / barber / corpse
-    // -----------------------------------------------------------------------
-    dispatchTable_[Opcode::SMSG_PLAYERBOUND] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(16)) return;
-        /*uint64_t binderGuid =*/ packet.readUInt64();
-        uint32_t mapId  = packet.readUInt32();
-        uint32_t zoneId = packet.readUInt32();
-        homeBindMapId_  = mapId;
-        homeBindZoneId_ = zoneId;
-        std::string pbMsg = "Your home location has been set";
-        std::string zoneName = getAreaName(zoneId);
-        if (!zoneName.empty()) pbMsg += " to " + zoneName;
-        pbMsg += '.';
-        addSystemChatMessage(pbMsg);
-    };
-    registerSkipHandler(Opcode::SMSG_BINDER_CONFIRM);
-    registerSkipHandler(Opcode::SMSG_SET_PHASE_SHIFT);
-    dispatchTable_[Opcode::SMSG_TOGGLE_XP_GAIN] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(1)) return;
-        uint8_t enabled = packet.readUInt8();
-        addSystemChatMessage(enabled ? "XP gain enabled." : "XP gain disabled.");
-    };
-    dispatchTable_[Opcode::SMSG_BINDZONEREPLY] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t result = packet.readUInt32();
-            if (result == 0) addSystemChatMessage("Your home is now set to this location.");
-            else { addUIError("You are too far from the innkeeper."); addSystemChatMessage("You are too far from the innkeeper."); }
-        }
-    };
-    dispatchTable_[Opcode::SMSG_CHANGEPLAYER_DIFFICULTY_RESULT] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t result = packet.readUInt32();
-            if (result == 0) {
-                addSystemChatMessage("Difficulty changed.");
-            } else {
-                static const char* reasons[] = {
-                    "", "Error", "Too many members", "Already in dungeon",
-                    "You are in a battleground", "Raid not allowed in heroic",
-                    "You must be in a raid group", "Player not in group"
-                };
-                const char* msg = (result < 8) ? reasons[result] : "Difficulty change failed.";
-                addUIError(std::string("Cannot change difficulty: ") + msg);
-                addSystemChatMessage(std::string("Cannot change difficulty: ") + msg);
-            }
-        }
-    };
-    dispatchTable_[Opcode::SMSG_CORPSE_NOT_IN_INSTANCE] = [this](network::Packet& /*packet*/) {
-        addUIError("Your corpse is outside this instance.");
-        addSystemChatMessage("Your corpse is outside this instance. Release spirit to retrieve it.");
-    };
-    dispatchTable_[Opcode::SMSG_CROSSED_INEBRIATION_THRESHOLD] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(12)) {
-            uint64_t guid      = packet.readUInt64();
-            uint32_t threshold = packet.readUInt32();
-            if (guid == playerGuid && threshold > 0) addSystemChatMessage("You feel rather drunk.");
-            LOG_DEBUG("SMSG_CROSSED_INEBRIATION_THRESHOLD: guid=0x", std::hex, guid, std::dec, " threshold=", threshold);
-        }
-    };
-    dispatchTable_[Opcode::SMSG_CLEAR_FAR_SIGHT_IMMEDIATE] = [this](network::Packet& /*packet*/) {
-        LOG_DEBUG("SMSG_CLEAR_FAR_SIGHT_IMMEDIATE");
-    };
-    registerSkipHandler(Opcode::SMSG_COMBAT_EVENT_FAILED);
-    dispatchTable_[Opcode::SMSG_FORCE_ANIM] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(1)) {
-            uint64_t animGuid = packet.readPackedGuid();
-            if (packet.hasRemaining(4)) {
-                uint32_t animId = packet.readUInt32();
-                if (emoteAnimCallback_) emoteAnimCallback_(animGuid, animId);
-            }
-        }
-    };
-    // Consume silently — opcodes we receive but don't need to act on
-    for (auto op : {
-        Opcode::SMSG_FLIGHT_SPLINE_SYNC, Opcode::SMSG_FORCE_DISPLAY_UPDATE,
-        Opcode::SMSG_FORCE_SEND_QUEUED_PACKETS, Opcode::SMSG_FORCE_SET_VEHICLE_REC_ID,
-        Opcode::SMSG_CORPSE_MAP_POSITION_QUERY_RESPONSE, Opcode::SMSG_DAMAGE_CALC_LOG,
-        Opcode::SMSG_DYNAMIC_DROP_ROLL_RESULT, Opcode::SMSG_DESTRUCTIBLE_BUILDING_DAMAGE,
-    }) { registerSkipHandler(op); }
-
-    // Game object despawn animation — reset state to closed before actual despawn
-    dispatchTable_[Opcode::SMSG_GAMEOBJECT_DESPAWN_ANIM] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(8)) return;
-        uint64_t guid = packet.readUInt64();
-        // Trigger a CLOSE animation / freeze before the object is removed
-        if (gameObjectStateCallback_) gameObjectStateCallback_(guid, 0);
-    };
-    // Game object reset state — return to READY(closed) state
-    dispatchTable_[Opcode::SMSG_GAMEOBJECT_RESET_STATE] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(8)) return;
-        uint64_t guid = packet.readUInt64();
-        if (gameObjectStateCallback_) gameObjectStateCallback_(guid, 0);
-    };
-    dispatchTable_[Opcode::SMSG_FORCED_DEATH_UPDATE] = [this](network::Packet& packet) {
-        playerDead_ = true;
-        if (ghostStateCallback_) ghostStateCallback_(false);
-        fireAddonEvent("PLAYER_DEAD", {});
-        addSystemChatMessage("You have been killed.");
-        LOG_INFO("SMSG_FORCED_DEATH_UPDATE: player force-killed");
-        packet.skipAll();
-    };
-    // SMSG_DEFENSE_MESSAGE — moved to ChatHandler::registerOpcodes
-    dispatchTable_[Opcode::SMSG_CORPSE_RECLAIM_DELAY] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t delayMs = packet.readUInt32();
-            auto nowMs = static_cast<uint64_t>(
-                std::chrono::duration_cast<std::chrono::milliseconds>(
-                    std::chrono::steady_clock::now().time_since_epoch()).count());
-            corpseReclaimAvailableMs_ = nowMs + delayMs;
-            LOG_INFO("SMSG_CORPSE_RECLAIM_DELAY: ", delayMs, "ms");
-        }
-    };
-    dispatchTable_[Opcode::SMSG_DEATH_RELEASE_LOC] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(16)) {
-            uint32_t relMapId = packet.readUInt32();
-            float relX = packet.readFloat(), relY = packet.readFloat(), relZ = packet.readFloat();
-            LOG_INFO("SMSG_DEATH_RELEASE_LOC (graveyard spawn): map=", relMapId, " x=", relX, " y=", relY, " z=", relZ);
-        }
-    };
-    dispatchTable_[Opcode::SMSG_ENABLE_BARBER_SHOP] = [this](network::Packet& /*packet*/) {
-        LOG_INFO("SMSG_ENABLE_BARBER_SHOP: barber shop available");
-        barberShopOpen_ = true;
-        fireAddonEvent("BARBER_SHOP_OPEN", {});
-    };
-
-    // ---- Batch 3: Corpse/gametime, combat clearing, mount, loot notify,
-    //                movement/speed/flags, attack, spells, group ----
-
-    dispatchTable_[Opcode::MSG_CORPSE_QUERY] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(1)) return;
-        uint8_t found = packet.readUInt8();
-        if (found && packet.hasRemaining(20)) {
-            /*uint32_t mapId =*/ packet.readUInt32();
-            float cx = packet.readFloat();
-            float cy = packet.readFloat();
-            float cz = packet.readFloat();
-            uint32_t corpseMapId = packet.readUInt32();
-            corpseX_ = cx;
-            corpseY_ = cy;
-            corpseZ_ = cz;
-            corpseMapId_ = corpseMapId;
-            LOG_INFO("MSG_CORPSE_QUERY: corpse at (", cx, ",", cy, ",", cz, ") map=", corpseMapId);
-        }
-    };
-    dispatchTable_[Opcode::SMSG_FEIGN_DEATH_RESISTED] = [this](network::Packet& /*packet*/) {
-        addUIError("Your Feign Death was resisted.");
-        addSystemChatMessage("Your Feign Death attempt was resisted.");
-    };
-    dispatchTable_[Opcode::SMSG_CHANNEL_MEMBER_COUNT] = [this](network::Packet& packet) {
-        std::string chanName = packet.readString();
-        if (packet.hasRemaining(5)) {
-            /*uint8_t flags =*/ packet.readUInt8();
-            uint32_t count = packet.readUInt32();
-            LOG_DEBUG("SMSG_CHANNEL_MEMBER_COUNT: channel=", chanName, " members=", count);
-        }
-    };
-    for (auto op : { Opcode::SMSG_GAMETIME_SET, Opcode::SMSG_GAMETIME_UPDATE }) {
-        dispatchTable_[op] = [this](network::Packet& packet) {
-            if (packet.hasRemaining(4)) {
-                uint32_t gameTimePacked = packet.readUInt32();
-                gameTime_ = static_cast<float>(gameTimePacked);
-            }
-            packet.skipAll();
-        };
-    }
-    dispatchTable_[Opcode::SMSG_GAMESPEED_SET] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(8)) {
-            uint32_t gameTimePacked = packet.readUInt32();
-            float timeSpeed = packet.readFloat();
-            gameTime_ = static_cast<float>(gameTimePacked);
-            timeSpeed_ = timeSpeed;
-        }
-        packet.skipAll();
-    };
-    dispatchTable_[Opcode::SMSG_GAMETIMEBIAS_SET] = [this](network::Packet& packet) {
-        packet.skipAll();
-    };
-    dispatchTable_[Opcode::SMSG_ACHIEVEMENT_DELETED] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t achId = packet.readUInt32();
-            earnedAchievements_.erase(achId);
-            achievementDates_.erase(achId);
-        }
-        packet.skipAll();
-    };
-    dispatchTable_[Opcode::SMSG_CRITERIA_DELETED] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t critId = packet.readUInt32();
-            criteriaProgress_.erase(critId);
-        }
-        packet.skipAll();
-    };
-
-    // Combat clearing
-    dispatchTable_[Opcode::SMSG_BREAK_TARGET] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(8)) {
-            uint64_t bGuid = packet.readUInt64();
-            if (bGuid == targetGuid) targetGuid = 0;
-        }
-    };
-    dispatchTable_[Opcode::SMSG_CLEAR_TARGET] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(8)) {
-            uint64_t cGuid = packet.readUInt64();
-            if (cGuid == 0 || cGuid == targetGuid) targetGuid = 0;
-        }
-    };
-
-    // Mount/dismount
-    dispatchTable_[Opcode::SMSG_DISMOUNT] = [this](network::Packet& /*packet*/) {
-        currentMountDisplayId_ = 0;
-        if (mountCallback_) mountCallback_(0);
-    };
-    dispatchTable_[Opcode::SMSG_MOUNTRESULT] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(4)) return;
-        uint32_t result = packet.readUInt32();
-        if (result != 4) {
-            const char* msgs[] = { "Cannot mount here.", "Invalid mount spell.",
-                                   "Too far away to mount.", "Already mounted." };
-            std::string mountErr = result < 4 ? msgs[result] : "Cannot mount.";
-            addUIError(mountErr);
-            addSystemChatMessage(mountErr);
-        }
-    };
-    dispatchTable_[Opcode::SMSG_DISMOUNTRESULT] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(4)) return;
-        uint32_t result = packet.readUInt32();
-        if (result != 0) {
-            addUIError("Cannot dismount here.");
-            addSystemChatMessage("Cannot dismount here.");
-        }
-    };
-
-    // Camera shake
-    dispatchTable_[Opcode::SMSG_CAMERA_SHAKE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(8)) {
-            uint32_t shakeId   = packet.readUInt32();
-            uint32_t shakeType = packet.readUInt32();
-            (void)shakeType;
-            float magnitude = (shakeId < 50) ? 0.04f : 0.08f;
-            if (cameraShakeCallback_)
-                cameraShakeCallback_(magnitude, 18.0f, 0.5f);
-        }
-    };
-
-    // (SMSG_PLAY_SPELL_VISUAL, SMSG_CLEAR_COOLDOWN, SMSG_MODIFY_COOLDOWN → moved to SpellHandler)
-
-    // ---- Batch 4: Ready check, duels, guild, loot/gossip/vendor, factions, spell mods ----
-
-    // Guild
-    registerHandler(Opcode::SMSG_PET_SPELLS, &GameHandler::handlePetSpells);
-
-    // Loot/gossip/vendor delegates
-    registerHandler(Opcode::SMSG_SUMMON_REQUEST, &GameHandler::handleSummonRequest);
-    dispatchTable_[Opcode::SMSG_SUMMON_CANCEL] = [this](network::Packet& /*packet*/) {
-        pendingSummonRequest_ = false;
-        addSystemChatMessage("Summon cancelled.");
-    };
-
-    // Bind point
-    dispatchTable_[Opcode::SMSG_BINDPOINTUPDATE] = [this](network::Packet& packet) {
-        BindPointUpdateData data;
-        if (BindPointUpdateParser::parse(packet, data)) {
-            glm::vec3 canonical = core::coords::serverToCanonical(
-                glm::vec3(data.x, data.y, data.z));
-            bool wasSet = hasHomeBind_;
-            hasHomeBind_ = true;
-            homeBindMapId_ = data.mapId;
-            homeBindZoneId_ = data.zoneId;
-            homeBindPos_ = canonical;
-            if (bindPointCallback_)
-                bindPointCallback_(data.mapId, canonical.x, canonical.y, canonical.z);
-            if (wasSet) {
-                std::string bindMsg = "Your home has been set";
-                std::string zoneName = getAreaName(data.zoneId);
-                if (!zoneName.empty()) bindMsg += " to " + zoneName;
-                bindMsg += '.';
-                addSystemChatMessage(bindMsg);
-            }
-        }
-    };
-
-    // Spirit healer / resurrect
-    dispatchTable_[Opcode::SMSG_SPIRIT_HEALER_CONFIRM] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(8)) return;
-        uint64_t npcGuid = packet.readUInt64();
-        if (npcGuid) {
-            resurrectCasterGuid_ = npcGuid;
-            resurrectCasterName_ = "";
-            resurrectIsSpiritHealer_ = true;
-            resurrectRequestPending_ = true;
-        }
-    };
-    dispatchTable_[Opcode::SMSG_RESURRECT_REQUEST] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(8)) return;
-        uint64_t casterGuid = packet.readUInt64();
-        std::string casterName;
-        if (packet.hasData())
-            casterName = packet.readString();
-        if (casterGuid) {
-            resurrectCasterGuid_ = casterGuid;
-            resurrectIsSpiritHealer_ = false;
-            if (!casterName.empty()) {
-                resurrectCasterName_ = casterName;
-            } else {
-                resurrectCasterName_ = lookupName(casterGuid);
-            }
-            resurrectRequestPending_ = true;
-                            fireAddonEvent("RESURRECT_REQUEST", {resurrectCasterName_});
-        }
-    };
-
-    // Time sync
-    dispatchTable_[Opcode::SMSG_TIME_SYNC_REQ] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(4)) return;
-        uint32_t counter = packet.readUInt32();
-        if (socket) {
-            network::Packet resp(wireOpcode(Opcode::CMSG_TIME_SYNC_RESP));
-            resp.writeUInt32(counter);
-            resp.writeUInt32(nextMovementTimestampMs());
-            socket->send(resp);
-        }
-    };
-
-    // (SMSG_TRAINER_BUY_SUCCEEDED, SMSG_TRAINER_BUY_FAILED → moved to InventoryHandler)
-
-    // Minimap ping
-    dispatchTable_[Opcode::MSG_MINIMAP_PING] = [this](network::Packet& packet) {
-        const bool mmTbcLike = isPreWotlk();
-        if (!packet.hasRemaining(mmTbcLike ? 8u : 1u) ) return;
-        uint64_t senderGuid = mmTbcLike
-            ? packet.readUInt64() : packet.readPackedGuid();
-        if (!packet.hasRemaining(8)) return;
-        float pingX = packet.readFloat();
-        float pingY = packet.readFloat();
-        MinimapPing ping;
-        ping.senderGuid = senderGuid;
-        ping.wowX = pingY;
-        ping.wowY = pingX;
-        ping.age  = 0.0f;
-        minimapPings_.push_back(ping);
-        if (senderGuid != playerGuid) {
-                            withSoundManager(&audio::AudioCoordinator::getUiSoundManager, [](auto* sfx) { sfx->playMinimapPing(); });
-        }
-    };
-    dispatchTable_[Opcode::SMSG_ZONE_UNDER_ATTACK] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t areaId = packet.readUInt32();
-            std::string areaName = getAreaName(areaId);
-            std::string msg = areaName.empty()
-                ? std::string("A zone is under attack!")
-                : (areaName + " is under attack!");
-            addUIError(msg);
-            addSystemChatMessage(msg);
-        }
-    };
-
-    // Spirit healer time / durability
-    dispatchTable_[Opcode::SMSG_AREA_SPIRIT_HEALER_TIME] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(12)) {
-            /*uint64_t guid =*/ packet.readUInt64();
-            uint32_t timeMs = packet.readUInt32();
-            uint32_t secs = timeMs / 1000;
-            char buf[128];
-            std::snprintf(buf, sizeof(buf), "You will be able to resurrect in %u seconds.", secs);
-            addSystemChatMessage(buf);
-        }
-    };
-    dispatchTable_[Opcode::SMSG_DURABILITY_DAMAGE_DEATH] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t pct = packet.readUInt32();
-            char buf[80];
-            std::snprintf(buf, sizeof(buf),
-                "You have lost %u%% of your gear's durability due to death.", pct);
-            addUIError(buf);
-            addSystemChatMessage(buf);
-        }
-    };
-
-    // (SMSG_INITIALIZE_FACTIONS, SMSG_SET_FACTION_STANDING,
-    //  SMSG_SET_FACTION_ATWAR, SMSG_SET_FACTION_VISIBLE → moved to SocialHandler)
-    dispatchTable_[Opcode::SMSG_FEATURE_SYSTEM_STATUS] = [this](network::Packet& packet) {
-        packet.skipAll();
-    };
-
-    // (SMSG_SET_FLAT_SPELL_MODIFIER, SMSG_SET_PCT_SPELL_MODIFIER, SMSG_SPELL_DELAYED → moved to SpellHandler)
-
-    // Proficiency
-    dispatchTable_[Opcode::SMSG_SET_PROFICIENCY] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(5)) return;
-        uint8_t  itemClass = packet.readUInt8();
-        uint32_t mask      = packet.readUInt32();
-        if (itemClass == 2) weaponProficiency_ = mask;
-        else if (itemClass == 4) armorProficiency_ = mask;
-    };
-
-    // Loot money / misc consume
-    for (auto op : { Opcode::SMSG_LOOT_CLEAR_MONEY, Opcode::SMSG_NPC_TEXT_UPDATE }) {
-        dispatchTable_[op] = [](network::Packet& /*packet*/) {};
-    }
-
-    // Play sound
-    dispatchTable_[Opcode::SMSG_PLAY_SOUND] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t soundId = packet.readUInt32();
-            if (playSoundCallback_) playSoundCallback_(soundId);
-        }
-    };
-
-    // SMSG_SERVER_MESSAGE — moved to ChatHandler::registerOpcodes
-    // SMSG_CHAT_SERVER_MESSAGE — moved to ChatHandler::registerOpcodes
-    // SMSG_AREA_TRIGGER_MESSAGE — moved to ChatHandler::registerOpcodes
-    dispatchTable_[Opcode::SMSG_TRIGGER_CINEMATIC] = [this](network::Packet& packet) {
-        packet.skipAll();
-        network::Packet ack(wireOpcode(Opcode::CMSG_NEXT_CINEMATIC_CAMERA));
-        socket->send(ack);
-    };
-
-    // ---- Batch 5: Teleport, taxi, BG, LFG, arena, movement relay, mail, bank, auction, quests ----
-
-    // Teleport
-    dispatchTable_[Opcode::SMSG_TRANSFER_PENDING] = [this](network::Packet& packet) {
-        uint32_t pendingMapId = packet.readUInt32();
-        if (packet.hasRemaining(8)) {
-            packet.readUInt32(); // transportEntry
-            packet.readUInt32(); // transportMapId
-        }
-        (void)pendingMapId;
-    };
-    dispatchTable_[Opcode::SMSG_TRANSFER_ABORTED] = [this](network::Packet& packet) {
-        uint32_t mapId = packet.readUInt32();
-        uint8_t reason = (packet.hasData()) ? packet.readUInt8() : 0;
-        (void)mapId;
-        const char* abortMsg = nullptr;
-        switch (reason) {
-            case 0x01: abortMsg = "Transfer aborted: difficulty unavailable."; break;
-            case 0x02: abortMsg = "Transfer aborted: expansion required."; break;
-            case 0x03: abortMsg = "Transfer aborted: instance not found."; break;
-            case 0x04: abortMsg = "Transfer aborted: too many instances. Please wait before entering a new instance."; break;
-            case 0x06: abortMsg = "Transfer aborted: instance is full."; break;
-            case 0x07: abortMsg = "Transfer aborted: zone is in combat."; break;
-            case 0x08: abortMsg = "Transfer aborted: you are already in this instance."; break;
-            case 0x09: abortMsg = "Transfer aborted: not enough players."; break;
-            default:   abortMsg = "Transfer aborted."; break;
-        }
-        addUIError(abortMsg);
-        addSystemChatMessage(abortMsg);
-    };
-
-    // Taxi
-    dispatchTable_[Opcode::SMSG_STANDSTATE_UPDATE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(1)) {
-            standState_ = packet.readUInt8();
-            if (standStateCallback_) standStateCallback_(standState_);
-        }
-    };
-    dispatchTable_[Opcode::SMSG_NEW_TAXI_PATH] = [this](network::Packet& /*packet*/) {
-        addSystemChatMessage("New flight path discovered!");
-    };
-
-    // Arena
-    dispatchTable_[Opcode::MSG_TALENT_WIPE_CONFIRM] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(12)) { packet.skipAll(); return; }
-        talentWipeNpcGuid_ = packet.readUInt64();
-        talentWipeCost_    = packet.readUInt32();
-        talentWipePending_ = true;
-                    fireAddonEvent("CONFIRM_TALENT_WIPE", {std::to_string(talentWipeCost_)});
-    };
-
-    // (SMSG_CHANNEL_LIST → moved to ChatHandler)
-    // (SMSG_GROUP_SET_LEADER → moved to SocialHandler)
-
-    // Gameobject / page text (entity queries moved to EntityController::registerOpcodes)
-    dispatchTable_[Opcode::SMSG_GAMEOBJECT_CUSTOM_ANIM] = [this](network::Packet& packet) {
-        if (packet.getSize() < 12) return;
-        uint64_t guid = packet.readUInt64();
-        uint32_t animId = packet.readUInt32();
-        if (gameObjectCustomAnimCallback_)
-            gameObjectCustomAnimCallback_(guid, animId);
-        if (animId == 0) {
-            auto goEnt = entityController_->getEntityManager().getEntity(guid);
-            if (goEnt && goEnt->getType() == ObjectType::GAMEOBJECT) {
-                auto go = std::static_pointer_cast<GameObject>(goEnt);
-                // Only show fishing message if the bobber belongs to us
-                // OBJECT_FIELD_CREATED_BY is a uint64 at field indices 6-7
-                uint64_t createdBy = static_cast<uint64_t>(go->getField(6))
-                                   | (static_cast<uint64_t>(go->getField(7)) << 32);
-                if (createdBy == playerGuid) {
-                    auto* info = getCachedGameObjectInfo(go->getEntry());
-                    if (info && info->type == 17) {
-                        addUIError("A fish is on your line!");
-                        addSystemChatMessage("A fish is on your line!");
-                        withSoundManager(&audio::AudioCoordinator::getUiSoundManager, [](auto* sfx) { sfx->playQuestUpdate(); });
+        // Leave combat if auto-attack target is too far away (leash range)
+        // and keep melee intent tightly synced while stationary.
+        if (autoAttackRequested_ && autoAttackTarget != 0) {
+            auto targetEntity = entityManager.getEntity(autoAttackTarget);
+            if (targetEntity) {
+                // Use latest server-authoritative target position to avoid stale
+                // interpolation snapshots masking out-of-range states.
+                const float targetX = targetEntity->getLatestX();
+                const float targetY = targetEntity->getLatestY();
+                const float targetZ = targetEntity->getLatestZ();
+                float dx = movementInfo.x - targetX;
+                float dy = movementInfo.y - targetY;
+                float dz = movementInfo.z - targetZ;
+                float dist = std::sqrt(dx * dx + dy * dy);
+                float dist3d = std::sqrt(dx * dx + dy * dy + dz * dz);
+                const bool classicLike = isClassicLikeExpansion() || isActiveExpansion("tbc");
+                if (dist > 40.0f) {
+                    stopAutoAttack();
+                    LOG_INFO("Left combat: target too far (", dist, " yards)");
+                } else if (state == WorldState::IN_WORLD && socket) {
+                    bool allowResync = true;
+                    const float meleeRange = classicLike ? 5.25f : 5.75f;
+                    if (dist3d > meleeRange) {
+                        autoAttackOutOfRange_ = true;
+                        autoAttackOutOfRangeTime_ += deltaTime;
+                        if (autoAttackRangeWarnCooldown_ <= 0.0f) {
+                            addSystemChatMessage("Target is too far away.");
+                            autoAttackRangeWarnCooldown_ = 1.25f;
+                        }
+                        // Stop chasing stale swings when the target remains out of range.
+                        if (autoAttackOutOfRangeTime_ > 2.0f && dist3d > 9.0f) {
+                            stopAutoAttack();
+                            addSystemChatMessage("Auto-attack stopped: target out of range.");
+                            allowResync = false;
+                        }
+                    } else {
+                        autoAttackOutOfRange_ = false;
+                        autoAttackOutOfRangeTime_ = 0.0f;
                     }
-                }
-            }
-        }
-    };
 
-    // Item refund / socket gems / item time
-    dispatchTable_[Opcode::SMSG_ITEM_REFUND_RESULT] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(12)) {
-            packet.readUInt64(); // itemGuid
-            uint32_t result = packet.readUInt32();
-            addSystemChatMessage(result == 0 ? "Item returned. Refund processed."
-                                             : "Could not return item for refund.");
-        }
-    };
-    dispatchTable_[Opcode::SMSG_SOCKET_GEMS_RESULT] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t result = packet.readUInt32();
-            if (result == 0) addSystemChatMessage("Gems socketed successfully.");
-            else addSystemChatMessage("Failed to socket gems.");
-        }
-    };
-    dispatchTable_[Opcode::SMSG_ITEM_TIME_UPDATE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(12)) {
-            packet.readUInt64(); // itemGuid
-            packet.readUInt32(); // durationMs
-        }
-    };
+                    if (allowResync) {
+                        autoAttackResendTimer_ += deltaTime;
+                        autoAttackFacingSyncTimer_ += deltaTime;
 
-    // ---- Batch 6: Spell miss / env damage / control / spell failure ----
+                        // Re-request swing more aggressively until server confirms active loop.
+                        float resendInterval = 1.0f;
+                        if (!autoAttacking || autoAttackOutOfRange_) {
+                            resendInterval = classicLike ? 0.25f : 0.50f;
+                        }
+                        if (autoAttackResendTimer_ >= resendInterval) {
+                            autoAttackResendTimer_ = 0.0f;
+                            auto pkt = AttackSwingPacket::build(autoAttackTarget);
+                            socket->send(pkt);
+                        }
 
+                        // Keep server-facing aligned with our current melee target.
+                        // Some vanilla-family realms become strict about front-arc checks unless
+                        // the client sends explicit facing updates while stationary.
+                        const float facingSyncInterval = classicLike ? 0.10f : 0.20f;
+                        if (autoAttackFacingSyncTimer_ >= facingSyncInterval) {
+                            autoAttackFacingSyncTimer_ = 0.0f;
+                            float toTargetX = targetX - movementInfo.x;
+                            float toTargetY = targetY - movementInfo.y;
+                            bool sentMovement = false;
+                            if (std::abs(toTargetX) > 0.01f || std::abs(toTargetY) > 0.01f) {
+                                float desired = std::atan2(-toTargetY, toTargetX);
+                                float diff = desired - movementInfo.orientation;
+                                while (diff > static_cast<float>(M_PI)) diff -= 2.0f * static_cast<float>(M_PI);
+                                while (diff < -static_cast<float>(M_PI)) diff += 2.0f * static_cast<float>(M_PI);
+                                const float facingThreshold = classicLike ? 0.035f : 0.12f; // ~2deg / ~7deg
+                                if (std::abs(diff) > facingThreshold) {
+                                    movementInfo.orientation = desired;
+                                    sendMovement(Opcode::MSG_MOVE_SET_FACING);
+                                    // Follow facing update with a heartbeat to tighten server range/facing checks.
+                                    sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
+                                    sentMovement = true;
+                                }
+                            } else if (classicLike) {
+                                // Keep stationary melee position/facing fresh for strict vanilla-family checks.
+                                sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
+                                sentMovement = true;
+                            }
 
-    // ---- Achievement / fishing delegates ----
-    dispatchTable_[Opcode::SMSG_ALL_ACHIEVEMENT_DATA] = [this](network::Packet& packet) {
-        handleAllAchievementData(packet);
-    };
-    dispatchTable_[Opcode::SMSG_FISH_NOT_HOOKED] = [this](network::Packet& /*packet*/) {
-        addSystemChatMessage("Your fish got away.");
-    };
-    dispatchTable_[Opcode::SMSG_FISH_ESCAPED] = [this](network::Packet& /*packet*/) {
-        addSystemChatMessage("Your fish escaped!");
-    };
-
-    // ---- Auto-repeat / auras / dispel / totem ----
-    dispatchTable_[Opcode::SMSG_CANCEL_AUTO_REPEAT] = [this](network::Packet& /*packet*/) {
-        // Server signals to stop a repeating spell (wand/shoot); no client action needed
-    };
-
-
-    // ---- Batch 7: World states, action buttons, level-up, vendor, inventory ----
-
-    // ---- SMSG_INIT_WORLD_STATES ----
-    dispatchTable_[Opcode::SMSG_INIT_WORLD_STATES] = [this](network::Packet& packet) {
-        // WotLK format: uint32 mapId, uint32 zoneId, uint32 areaId, uint16 count, N*(uint32 key, uint32 val)
-        // Classic/TBC format: uint32 mapId, uint32 zoneId, uint16 count, N*(uint32 key, uint32 val)
-        if (!packet.hasRemaining(10)) {
-            LOG_WARNING("SMSG_INIT_WORLD_STATES too short: ", packet.getSize(), " bytes");
-            return;
-        }
-        worldStateMapId_ = packet.readUInt32();
-        {
-            uint32_t newZoneId = packet.readUInt32();
-            if (newZoneId != worldStateZoneId_ && newZoneId != 0) {
-                worldStateZoneId_ = newZoneId;
-                    fireAddonEvent("ZONE_CHANGED_NEW_AREA", {});
-                    fireAddonEvent("ZONE_CHANGED", {});
-            } else {
-                worldStateZoneId_ = newZoneId;
-            }
-        }
-        // WotLK adds areaId (uint32) before count; Classic/TBC/Turtle use the shorter format
-        size_t remaining = packet.getRemainingSize();
-        bool isWotLKFormat = isActiveExpansion("wotlk");
-        if (isWotLKFormat && remaining >= 6) {
-            packet.readUInt32(); // areaId (WotLK only)
-        }
-        uint16_t count = packet.readUInt16();
-        size_t needed = static_cast<size_t>(count) * 8;
-        size_t available = packet.getRemainingSize();
-        if (available < needed) {
-            // Be tolerant across expansion/private-core variants: if packet shape
-            // still looks like N*(key,val) dwords, parse what is present.
-            if ((available % 8) == 0) {
-                uint16_t adjustedCount = static_cast<uint16_t>(available / 8);
-                LOG_WARNING("SMSG_INIT_WORLD_STATES count mismatch: header=", count,
-                            " adjusted=", adjustedCount, " (available=", available, ")");
-                count = adjustedCount;
-                needed = available;
-            } else {
-                LOG_WARNING("SMSG_INIT_WORLD_STATES truncated: expected ", needed,
-                            " bytes of state pairs, got ", available);
-                packet.skipAll();
-                return;
-            }
-        }
-        worldStates_.clear();
-        worldStates_.reserve(count);
-        for (uint16_t i = 0; i < count; ++i) {
-            uint32_t key = packet.readUInt32();
-            uint32_t val = packet.readUInt32();
-            worldStates_[key] = val;
-        }
-    };
-
-    // ---- SMSG_ACTION_BUTTONS ----
-    dispatchTable_[Opcode::SMSG_ACTION_BUTTONS] = [this](network::Packet& packet) {
-        // Slot encoding differs by expansion:
-        //   Classic/Turtle: uint16 actionId + uint8 type + uint8 misc
-        //     type: 0=spell, 1=item, 64=macro
-        //   TBC/WotLK: uint32 packed = actionId | (type << 24)
-        //     type: 0x00=spell, 0x80=item, 0x40=macro
-        // Format differences:
-        //   Classic 1.12: no mode byte, 120 slots (480 bytes)
-        //   TBC 2.4.3:    no mode byte, 132 slots (528 bytes)
-        //   WotLK 3.3.5a: uint8 mode + 144 slots (577 bytes)
-        size_t rem = packet.getRemainingSize();
-        const bool hasModeByteExp = isActiveExpansion("wotlk");
-        int serverBarSlots;
-        if (isClassicLikeExpansion()) {
-            serverBarSlots = 120;
-        } else if (isActiveExpansion("tbc")) {
-            serverBarSlots = 132;
-        } else {
-            serverBarSlots = 144;
-        }
-        if (hasModeByteExp) {
-            if (rem < 1) return;
-            /*uint8_t mode =*/ packet.readUInt8();
-            rem--;
-        }
-        for (int i = 0; i < serverBarSlots; ++i) {
-            if (rem < 4) return;
-            uint32_t packed = packet.readUInt32();
-            rem -= 4;
-            if (i >= ACTION_BAR_SLOTS) continue;  // only load bars 1 and 2
-            if (packed == 0) {
-                // Empty slot — only clear if not already set to Attack/Hearthstone defaults
-                // so we don't wipe hardcoded fallbacks when the server sends zeros.
-                continue;
-            }
-            uint8_t type = 0;
-            uint32_t id = 0;
-            if (isClassicLikeExpansion()) {
-                id = packed & 0x0000FFFFu;
-                type = static_cast<uint8_t>((packed >> 16) & 0xFF);
-            } else {
-                type = static_cast<uint8_t>((packed >> 24) & 0xFF);
-                id = packed & 0x00FFFFFFu;
-            }
-            if (id == 0) continue;
-            ActionBarSlot slot;
-            switch (type) {
-                case 0x00: slot.type = ActionBarSlot::SPELL; slot.id = id; break;
-                case 0x01: slot.type = ActionBarSlot::ITEM;  slot.id = id; break;  // Classic item
-                case 0x80: slot.type = ActionBarSlot::ITEM;  slot.id = id; break;  // TBC/WotLK item
-                case 0x40: slot.type = ActionBarSlot::MACRO; slot.id = id; break;  // macro (all expansions)
-                default:   continue;  // unknown — leave as-is
-            }
-            actionBar[i] = slot;
-        }
-        // Apply any pending cooldowns from spellHandler's cooldowns to newly populated slots.
-        // SMSG_SPELL_COOLDOWN often arrives before SMSG_ACTION_BUTTONS during login,
-        // so the per-slot cooldownRemaining would be 0 without this sync.
-        if (spellHandler_) {
-            for (auto& slot : actionBar) {
-                if (slot.type == ActionBarSlot::SPELL && slot.id != 0) {
-                    auto cdIt = spellHandler_->spellCooldowns_.find(slot.id);
-                    if (cdIt != spellHandler_->spellCooldowns_.end() && cdIt->second > 0.0f) {
-                        slot.cooldownRemaining = cdIt->second;
-                        slot.cooldownTotal     = cdIt->second;
-                    }
-                } else if (slot.type == ActionBarSlot::ITEM && slot.id != 0) {
-                    // Items (potions, trinkets): look up the item's on-use spell
-                    // and check if that spell has a pending cooldown.
-                    const auto* qi = getItemInfo(slot.id);
-                    if (qi && qi->valid) {
-                        for (const auto& sp : qi->spells) {
-                            if (sp.spellId == 0) continue;
-                            auto cdIt = spellHandler_->spellCooldowns_.find(sp.spellId);
-                            if (cdIt != spellHandler_->spellCooldowns_.end() && cdIt->second > 0.0f) {
-                                slot.cooldownRemaining = cdIt->second;
-                                slot.cooldownTotal     = cdIt->second;
-                                break;
+                            // Even when facing is already correct, keep position fresh while
+                            // trying to connect melee hits so servers don't require a step.
+                            if (!sentMovement && (!autoAttacking || autoAttackOutOfRange_)) {
+                                sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
                             }
                         }
                     }
                 }
             }
         }
-        LOG_INFO("SMSG_ACTION_BUTTONS: populated action bar from server");
-        fireAddonEvent("ACTIONBAR_SLOT_CHANGED", {});
-        packet.skipAll();
-    };
 
-    // ---- SMSG_LEVELUP_INFO / SMSG_LEVELUP_INFO_ALT (shared body) ----
-    for (auto op : {Opcode::SMSG_LEVELUP_INFO, Opcode::SMSG_LEVELUP_INFO_ALT}) {
-        dispatchTable_[op] = [this](network::Packet& packet) {
-            // Server-authoritative level-up event.
-            // WotLK layout: uint32 newLevel + uint32 hpDelta + uint32 manaDelta + 5x uint32 statDeltas
-            if (packet.hasRemaining(4)) {
-                uint32_t newLevel = packet.readUInt32();
-                if (newLevel > 0) {
-                    // Parse stat deltas (WotLK layout has 7 more uint32s)
-                    lastLevelUpDeltas_ = {};
-                    if (packet.hasRemaining(28)) {
-                        lastLevelUpDeltas_.hp    = packet.readUInt32();
-                        lastLevelUpDeltas_.mana  = packet.readUInt32();
-                        lastLevelUpDeltas_.str   = packet.readUInt32();
-                        lastLevelUpDeltas_.agi   = packet.readUInt32();
-                        lastLevelUpDeltas_.sta   = packet.readUInt32();
-                        lastLevelUpDeltas_.intel = packet.readUInt32();
-                        lastLevelUpDeltas_.spi   = packet.readUInt32();
-                    }
-                    uint32_t oldLevel = serverPlayerLevel_;
-                    serverPlayerLevel_ = std::max(serverPlayerLevel_, newLevel);
-                    // Update the character-list entry so the selection screen
-                    // shows the correct level if the player logs out and back.
-                    for (auto& ch : characters) {
-                        if (ch.guid == playerGuid) {
-                            ch.level = serverPlayerLevel_;
-                            break;  // was 'return' — must NOT exit here or level-up notification is skipped
-                        }
-                    }
-                    if (newLevel > oldLevel) {
-                        addSystemChatMessage("You have reached level " + std::to_string(newLevel) + "!");
-                        withSoundManager(&audio::AudioCoordinator::getUiSoundManager, [](auto* sfx) { sfx->playLevelUp(); });
-                        if (levelUpCallback_) levelUpCallback_(newLevel);
-                        fireAddonEvent("PLAYER_LEVEL_UP", {std::to_string(newLevel)});
-                    }
+        // Keep active melee attackers visually facing the player as positions change.
+        // Some servers don't stream frequent orientation updates during combat.
+        if (!hostileAttackers_.empty()) {
+            for (uint64_t attackerGuid : hostileAttackers_) {
+                auto attacker = entityManager.getEntity(attackerGuid);
+                if (!attacker) continue;
+                float dx = movementInfo.x - attacker->getX();
+                float dy = movementInfo.y - attacker->getY();
+                if (std::abs(dx) < 0.01f && std::abs(dy) < 0.01f) continue;
+                attacker->setOrientation(std::atan2(-dy, dx));
+            }
+        }
+
+        // Close vendor/gossip/taxi window if player walks too far from NPC
+        if (vendorWindowOpen && currentVendorItems.vendorGuid != 0) {
+            auto npc = entityManager.getEntity(currentVendorItems.vendorGuid);
+            if (npc) {
+                float dx = movementInfo.x - npc->getX();
+                float dy = movementInfo.y - npc->getY();
+                float dist = std::sqrt(dx * dx + dy * dy);
+                if (dist > 15.0f) {
+                    closeVendor();
+                    LOG_INFO("Vendor closed: walked too far from NPC");
                 }
             }
-            packet.skipAll();
-        };
+        }
+        if (gossipWindowOpen && currentGossip.npcGuid != 0) {
+            auto npc = entityManager.getEntity(currentGossip.npcGuid);
+            if (npc) {
+                float dx = movementInfo.x - npc->getX();
+                float dy = movementInfo.y - npc->getY();
+                float dist = std::sqrt(dx * dx + dy * dy);
+                if (dist > 15.0f) {
+                    closeGossip();
+                    LOG_INFO("Gossip closed: walked too far from NPC");
+                }
+            }
+        }
+        if (taxiWindowOpen_ && taxiNpcGuid_ != 0) {
+            auto npc = entityManager.getEntity(taxiNpcGuid_);
+            if (npc) {
+                float dx = movementInfo.x - npc->getX();
+                float dy = movementInfo.y - npc->getY();
+                float dist = std::sqrt(dx * dx + dy * dy);
+                if (dist > 15.0f) {
+                    closeTaxi();
+                    LOG_INFO("Taxi window closed: walked too far from NPC");
+                }
+            }
+        }
+        if (trainerWindowOpen_ && currentTrainerList_.trainerGuid != 0) {
+            auto npc = entityManager.getEntity(currentTrainerList_.trainerGuid);
+            if (npc) {
+                float dx = movementInfo.x - npc->getX();
+                float dy = movementInfo.y - npc->getY();
+                float dist = std::sqrt(dx * dx + dy * dy);
+                if (dist > 15.0f) {
+                    closeTrainer();
+                    LOG_INFO("Trainer closed: walked too far from NPC");
+                }
+            }
+        }
+
+        // Update entity movement interpolation (keeps targeting in sync with visuals)
+        // Only update entities within reasonable distance for performance
+        const float updateRadiusSq = 150.0f * 150.0f;  // 150 unit radius
+        auto playerEntity = entityManager.getEntity(playerGuid);
+        glm::vec3 playerPos = playerEntity ? glm::vec3(playerEntity->getX(), playerEntity->getY(), playerEntity->getZ()) : glm::vec3(0.0f);
+
+        for (auto& [guid, entity] : entityManager.getEntities()) {
+            // Always update player
+            if (guid == playerGuid) {
+                entity->updateMovement(deltaTime);
+                continue;
+            }
+            // Keep selected/engaged target interpolation exact for UI targeting circle.
+            if (guid == targetGuid || guid == autoAttackTarget) {
+                entity->updateMovement(deltaTime);
+                continue;
+            }
+
+            // Distance cull other entities (use latest position to avoid culling by stale origin)
+            glm::vec3 entityPos(entity->getLatestX(), entity->getLatestY(), entity->getLatestZ());
+            float distSq = glm::dot(entityPos - playerPos, entityPos - playerPos);
+            if (distSq < updateRadiusSq) {
+                entity->updateMovement(deltaTime);
+            }
+        }
+
     }
-
-    // ---- MSG_RAID_TARGET_UPDATE ----
-    dispatchTable_[Opcode::MSG_RAID_TARGET_UPDATE] = [this](network::Packet& packet) {
-        // uint8 type: 0 = full update (8 × (uint8 icon + uint64 guid)),
-        //             1 = single update (uint8 icon + uint64 guid)
-        size_t remRTU = packet.getRemainingSize();
-        if (remRTU < 1) return;
-        uint8_t rtuType = packet.readUInt8();
-        if (rtuType == 0) {
-            // Full update: always 8 entries
-            for (uint32_t i = 0; i < kRaidMarkCount; ++i) {
-                if (!packet.hasRemaining(9)) return;
-                uint8_t  icon = packet.readUInt8();
-                uint64_t guid = packet.readUInt64();
-                if (socialHandler_)
-                    socialHandler_->setRaidTargetGuid(icon, guid);
-            }
-        } else {
-            // Single update
-            if (packet.hasRemaining(9)) {
-                uint8_t  icon = packet.readUInt8();
-                uint64_t guid = packet.readUInt64();
-                if (socialHandler_)
-                    socialHandler_->setRaidTargetGuid(icon, guid);
-            }
-        }
-        LOG_DEBUG("MSG_RAID_TARGET_UPDATE: type=", static_cast<int>(rtuType));
-                    fireAddonEvent("RAID_TARGET_UPDATE", {});
-    };
-
-    // ---- SMSG_CRITERIA_UPDATE ----
-    dispatchTable_[Opcode::SMSG_CRITERIA_UPDATE] = [this](network::Packet& packet) {
-        // uint32 criteriaId + uint64 progress + uint32 elapsedTime + uint32 creationTime
-        if (packet.hasRemaining(20)) {
-            uint32_t criteriaId    = packet.readUInt32();
-            uint64_t progress      = packet.readUInt64();
-            packet.readUInt32(); // elapsedTime
-            packet.readUInt32(); // creationTime
-            uint64_t oldProgress = 0;
-            auto cpit = criteriaProgress_.find(criteriaId);
-            if (cpit != criteriaProgress_.end()) oldProgress = cpit->second;
-            criteriaProgress_[criteriaId] = progress;
-            LOG_DEBUG("SMSG_CRITERIA_UPDATE: id=", criteriaId, " progress=", progress);
-            // Fire addon event for achievement tracking addons
-            if (progress != oldProgress)
-                fireAddonEvent("CRITERIA_UPDATE", {std::to_string(criteriaId), std::to_string(progress)});
-        }
-    };
-
-    // ---- SMSG_BARBER_SHOP_RESULT ----
-    dispatchTable_[Opcode::SMSG_BARBER_SHOP_RESULT] = [this](network::Packet& packet) {
-        // uint32 result (0 = success, 1 = no money, 2 = not barber, 3 = sitting)
-        if (packet.hasRemaining(4)) {
-            uint32_t result = packet.readUInt32();
-            if (result == 0) {
-                addSystemChatMessage("Hairstyle changed.");
-                barberShopOpen_ = false;
-                fireAddonEvent("BARBER_SHOP_CLOSE", {});
-            } else {
-                const char* msg = (result == 1) ? "Not enough money for new hairstyle."
-                                : (result == 2) ? "You are not at a barber shop."
-                                : (result == 3) ? "You must stand up to use the barber shop."
-                                : "Barber shop unavailable.";
-                addUIError(msg);
-                addSystemChatMessage(msg);
-            }
-            LOG_DEBUG("SMSG_BARBER_SHOP_RESULT: result=", result);
-        }
-    };
-
-    // -----------------------------------------------------------------------
-    // Batch 8-12: Remaining opcodes (inspects, quests, auctions, spells,
-    //             calendars, battlefields, voice, misc consume-only)
-    // -----------------------------------------------------------------------
-    // uint32 currentZoneLightId + uint32 overrideLightId + uint32 transitionMs
-    dispatchTable_[Opcode::SMSG_OVERRIDE_LIGHT] = [this](network::Packet& packet) {
-        // uint32 currentZoneLightId + uint32 overrideLightId + uint32 transitionMs
-        if (packet.hasRemaining(12)) {
-            uint32_t zoneLightId     = packet.readUInt32();
-            uint32_t overrideLightId = packet.readUInt32();
-            uint32_t transitionMs    = packet.readUInt32();
-            overrideLightId_      = overrideLightId;
-            overrideLightTransMs_ = transitionMs;
-            LOG_DEBUG("SMSG_OVERRIDE_LIGHT: zone=", zoneLightId,
-                      " override=", overrideLightId, " transition=", transitionMs, "ms");
-        }
-    };
-    // Classic 1.12: uint32 weatherType + float intensity (8 bytes, no isAbrupt)
-    // TBC 2.4.3 / WotLK 3.3.5a: uint32 weatherType + float intensity + uint8 isAbrupt (9 bytes)
-    dispatchTable_[Opcode::SMSG_WEATHER] = [this](network::Packet& packet) {
-        // Classic 1.12: uint32 weatherType + float intensity (8 bytes, no isAbrupt)
-        // TBC 2.4.3 / WotLK 3.3.5a: uint32 weatherType + float intensity + uint8 isAbrupt (9 bytes)
-        if (packet.hasRemaining(8)) {
-            uint32_t wType = packet.readUInt32();
-            float wIntensity = packet.readFloat();
-            if (packet.hasRemaining(1))
-                /*uint8_t isAbrupt =*/ packet.readUInt8();
-            uint32_t prevWeatherType = weatherType_;
-            weatherType_ = wType;
-            weatherIntensity_ = wIntensity;
-            const char* typeName = (wType == 1) ? "Rain" : (wType == 2) ? "Snow" : (wType == 3) ? "Storm" : "Clear";
-            LOG_INFO("Weather changed: type=", wType, " (", typeName, "), intensity=", wIntensity);
-            // Announce weather changes (including initial zone weather)
-            if (wType != prevWeatherType) {
-                const char* weatherMsg = nullptr;
-                if (wIntensity < 0.05f || wType == 0) {
-                    if (prevWeatherType != 0)
-                        weatherMsg = "The weather clears.";
-                } else if (wType == 1) {
-                    weatherMsg = "It begins to rain.";
-                } else if (wType == 2) {
-                    weatherMsg = "It begins to snow.";
-                } else if (wType == 3) {
-                    weatherMsg = "A storm rolls in.";
-                }
-                if (weatherMsg) addSystemChatMessage(weatherMsg);
-            }
-            // Notify addons of weather change
-                            fireAddonEvent("WEATHER_CHANGED", {std::to_string(wType), std::to_string(wIntensity)});
-            // Storm transition: trigger a low-frequency thunder rumble shake
-            if (wType == 3 && wIntensity > 0.3f && cameraShakeCallback_) {
-                float mag = 0.03f + wIntensity * 0.04f; // 0.03–0.07 units
-                cameraShakeCallback_(mag, 6.0f, 0.6f);
-            }
-        }
-    };
-    // Server-script text message — display in system chat
-    dispatchTable_[Opcode::SMSG_SCRIPT_MESSAGE] = [this](network::Packet& packet) {
-        // Server-script text message — display in system chat
-        std::string msg = packet.readString();
-        if (!msg.empty()) {
-            addSystemChatMessage(msg);
-            LOG_INFO("SMSG_SCRIPT_MESSAGE: ", msg);
-        }
-    };
-    // uint64 targetGuid + uint64 casterGuid + uint32 spellId + uint32 displayId + uint32 animType
-    dispatchTable_[Opcode::SMSG_ENCHANTMENTLOG] = [this](network::Packet& packet) {
-        // uint64 targetGuid + uint64 casterGuid + uint32 spellId + uint32 displayId + uint32 animType
-        if (packet.hasRemaining(28)) {
-            uint64_t enchTargetGuid = packet.readUInt64();
-            uint64_t enchCasterGuid = packet.readUInt64();
-            uint32_t enchSpellId = packet.readUInt32();
-            /*uint32_t displayId =*/ packet.readUInt32();
-            /*uint32_t animType =*/ packet.readUInt32();
-            LOG_DEBUG("SMSG_ENCHANTMENTLOG: spellId=", enchSpellId);
-            // Show enchant message if the player is involved
-            if (enchTargetGuid == playerGuid || enchCasterGuid == playerGuid) {
-                const std::string& enchName = getSpellName(enchSpellId);
-                std::string casterName = lookupName(enchCasterGuid);
-                if (!enchName.empty()) {
-                    std::string msg;
-                    if (enchCasterGuid == playerGuid)
-                        msg = "You enchant with " + enchName + ".";
-                    else if (!casterName.empty())
-                        msg = casterName + " enchants your item with " + enchName + ".";
-                    else
-                        msg = "Your item has been enchanted with " + enchName + ".";
-                    addSystemChatMessage(msg);
-                }
-            }
-        }
-    };
-    // WotLK: uint64 playerGuid + uint8 teamCount + per-team fields
-    dispatchTable_[Opcode::MSG_INSPECT_ARENA_TEAMS] = [this](network::Packet& packet) {
-        // WotLK: uint64 playerGuid + uint8 teamCount + per-team fields
-        if (!packet.hasRemaining(9)) {
-            packet.skipAll();
-            return;
-        }
-        uint64_t inspGuid  = packet.readUInt64();
-        uint8_t  teamCount = packet.readUInt8();
-        if (teamCount > 3) teamCount = 3; // 2v2, 3v3, 5v5
-        if (socialHandler_) {
-            auto& ir = socialHandler_->mutableInspectResult();
-            if (inspGuid == ir.guid || ir.guid == 0) {
-                ir.guid = inspGuid;
-                ir.arenaTeams.clear();
-                for (uint8_t t = 0; t < teamCount; ++t) {
-                    if (!packet.hasRemaining(21)) break;
-                    SocialHandler::InspectArenaTeam team;
-                    team.teamId         = packet.readUInt32();
-                    team.type           = packet.readUInt8();
-                    team.weekGames      = packet.readUInt32();
-                    team.weekWins       = packet.readUInt32();
-                    team.seasonGames    = packet.readUInt32();
-                    team.seasonWins     = packet.readUInt32();
-                    team.name           = packet.readString();
-                    if (!packet.hasRemaining(4)) break;
-                    team.personalRating = packet.readUInt32();
-                    ir.arenaTeams.push_back(std::move(team));
-                }
-            }
-        }
-        LOG_DEBUG("MSG_INSPECT_ARENA_TEAMS: guid=0x", std::hex, inspGuid, std::dec,
-                  " teams=", static_cast<int>(teamCount));
-    };
-    // auctionId(u32) + action(u32) + error(u32) + itemEntry(u32) + randomPropertyId(u32) + ...
-    // action: 0=sold/won, 1=expired, 2=bid placed on your auction
-    // auctionHouseId(u32) + auctionId(u32) + bidderGuid(u64) + bidAmount(u32) + outbidAmount(u32) + itemEntry(u32) + randomPropertyId(u32)
-    // uint32 auctionId + uint32 itemEntry + uint32 itemRandom — auction expired/cancelled
-    // uint64 containerGuid — tells client to open this container
-    // The actual items come via update packets; we just log this.
-    // PackedGuid (player guid) + uint32 vehicleId
-    // vehicleId == 0 means the player left the vehicle
-    dispatchTable_[Opcode::SMSG_PLAYER_VEHICLE_DATA] = [this](network::Packet& packet) {
-        // PackedGuid (player guid) + uint32 vehicleId
-        // vehicleId == 0 means the player left the vehicle
-        if (packet.hasRemaining(1)) {
-            (void)packet.readPackedGuid(); // player guid (unused)
-        }
-        uint32_t newVehicleId = 0;
-        if (packet.hasRemaining(4)) {
-            newVehicleId = packet.readUInt32();
-        }
-        bool wasInVehicle = vehicleId_ != 0;
-        bool nowInVehicle = newVehicleId != 0;
-        vehicleId_ = newVehicleId;
-        if (wasInVehicle != nowInVehicle && vehicleStateCallback_) {
-            vehicleStateCallback_(nowInVehicle, newVehicleId);
-        }
-    };
-    // guid(8) + status(1): status 1 = NPC has available/new routes for this player
-    dispatchTable_[Opcode::SMSG_TAXINODE_STATUS] = [this](network::Packet& packet) {
-        // guid(8) + status(1): status 1 = NPC has available/new routes for this player
-        if (packet.hasRemaining(9)) {
-            uint64_t npcGuid = packet.readUInt64();
-            uint8_t  status  = packet.readUInt8();
-            taxiNpcHasRoutes_[npcGuid] = (status != 0);
-        }
-    };
-    // SMSG_GUILD_DECLINE — moved to SocialHandler::registerOpcodes
-    // Clear cached talent data so the talent screen reflects the reset.
-    dispatchTable_[Opcode::SMSG_TALENTS_INVOLUNTARILY_RESET] = [this](network::Packet& packet) {
-        // Clear cached talent data so the talent screen reflects the reset.
-        if (spellHandler_) spellHandler_->resetTalentState();
-        addUIError("Your talents have been reset by the server.");
-        addSystemChatMessage("Your talents have been reset by the server.");
-        packet.skipAll();
-    };
-    dispatchTable_[Opcode::SMSG_SET_REST_START] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t restTrigger = packet.readUInt32();
-            isResting_ = (restTrigger > 0);
-            addSystemChatMessage(isResting_ ? "You are now resting."
-                                            : "You are no longer resting.");
-                            fireAddonEvent("PLAYER_UPDATE_RESTING", {});
-        }
-    };
-    dispatchTable_[Opcode::SMSG_UPDATE_AURA_DURATION] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(5)) {
-            uint8_t slot       = packet.readUInt8();
-            uint32_t durationMs = packet.readUInt32();
-            handleUpdateAuraDuration(slot, durationMs);
-        }
-    };
-    dispatchTable_[Opcode::SMSG_ITEM_NAME_QUERY_RESPONSE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t itemId = packet.readUInt32();
-            std::string name = packet.readString();
-            if (!itemInfoCache_.count(itemId) && !name.empty()) {
-                ItemQueryResponseData stub;
-                stub.entry = itemId;
-                stub.name  = std::move(name);
-                stub.valid = true;
-                itemInfoCache_[itemId] = std::move(stub);
-            }
-        }
-        packet.skipAll();
-    };
-    dispatchTable_[Opcode::SMSG_MOUNTSPECIAL_ANIM] = [this](network::Packet& packet) { (void)packet.readPackedGuid(); };
-    dispatchTable_[Opcode::SMSG_CHAR_CUSTOMIZE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(1)) {
-            uint8_t result = packet.readUInt8();
-            addSystemChatMessage(result == 0 ? "Character customization complete."
-                                             : "Character customization failed.");
-        }
-        packet.skipAll();
-    };
-    dispatchTable_[Opcode::SMSG_CHAR_FACTION_CHANGE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(1)) {
-            uint8_t result = packet.readUInt8();
-            addSystemChatMessage(result == 0 ? "Faction change complete."
-                                             : "Faction change failed.");
-        }
-        packet.skipAll();
-    };
-    dispatchTable_[Opcode::SMSG_INVALIDATE_PLAYER] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(8)) {
-            uint64_t guid = packet.readUInt64();
-            entityController_->invalidatePlayerName(guid);
-        }
-    };
-    // uint32 movieId — we don't play movies; acknowledge immediately.
-    dispatchTable_[Opcode::SMSG_TRIGGER_MOVIE] = [this](network::Packet& packet) {
-        // uint32 movieId — we don't play movies; acknowledge immediately.
-        packet.skipAll();
-        // WotLK servers expect CMSG_COMPLETE_MOVIE after the movie finishes;
-        // without it, the server may hang or disconnect the client.
-        uint16_t wire = wireOpcode(Opcode::CMSG_COMPLETE_MOVIE);
-        if (wire != 0xFFFF) {
-            network::Packet ack(wire);
-            socket->send(ack);
-            LOG_DEBUG("SMSG_TRIGGER_MOVIE: skipped, sent CMSG_COMPLETE_MOVIE");
-        }
-    };
-    // Server-side LFG invite timed out (no response within time limit)
-    dispatchTable_[Opcode::SMSG_LFG_TIMEDOUT] = [this](network::Packet& packet) {
-        // Server-side LFG invite timed out (no response within time limit)
-        addSystemChatMessage("Dungeon Finder: Invite timed out.");
-        if (openLfgCallback_) openLfgCallback_();
-        packet.skipAll();
-    };
-    // Another party member failed to respond to a LFG role-check in time
-    dispatchTable_[Opcode::SMSG_LFG_OTHER_TIMEDOUT] = [this](network::Packet& packet) {
-        // Another party member failed to respond to a LFG role-check in time
-        addSystemChatMessage("Dungeon Finder: Another player's invite timed out.");
-        if (openLfgCallback_) openLfgCallback_();
-        packet.skipAll();
-    };
-    // uint32 result — LFG auto-join attempt failed (player selected auto-join at queue time)
-    dispatchTable_[Opcode::SMSG_LFG_AUTOJOIN_FAILED] = [this](network::Packet& packet) {
-        // uint32 result — LFG auto-join attempt failed (player selected auto-join at queue time)
-        if (packet.hasRemaining(4)) {
-            uint32_t result = packet.readUInt32();
-            (void)result;
-        }
-        addUIError("Dungeon Finder: Auto-join failed.");
-        addSystemChatMessage("Dungeon Finder: Auto-join failed.");
-        packet.skipAll();
-    };
-    // No eligible players found for auto-join
-    dispatchTable_[Opcode::SMSG_LFG_AUTOJOIN_FAILED_NO_PLAYER] = [this](network::Packet& packet) {
-        // No eligible players found for auto-join
-        addUIError("Dungeon Finder: No players available for auto-join.");
-        addSystemChatMessage("Dungeon Finder: No players available for auto-join.");
-        packet.skipAll();
-    };
-    // Party leader is currently set to Looking for More (LFM) mode
-    dispatchTable_[Opcode::SMSG_LFG_LEADER_IS_LFM] = [this](network::Packet& packet) {
-        // Party leader is currently set to Looking for More (LFM) mode
-        addSystemChatMessage("Your party leader is currently Looking for More.");
-        packet.skipAll();
-    };
-    // uint32 zoneId + uint8 level_min + uint8 level_max — player queued for meeting stone
-    dispatchTable_[Opcode::SMSG_MEETINGSTONE_SETQUEUE] = [this](network::Packet& packet) {
-        // uint32 zoneId + uint8 level_min + uint8 level_max — player queued for meeting stone
-        if (packet.hasRemaining(6)) {
-            uint32_t zoneId   = packet.readUInt32();
-            uint8_t  levelMin = packet.readUInt8();
-            uint8_t  levelMax = packet.readUInt8();
-            char buf[128];
-            std::string zoneName = getAreaName(zoneId);
-            if (!zoneName.empty())
-                std::snprintf(buf, sizeof(buf),
-                    "You are now in the Meeting Stone queue for %s (levels %u-%u).",
-                    zoneName.c_str(), levelMin, levelMax);
-            else
-                std::snprintf(buf, sizeof(buf),
-                    "You are now in the Meeting Stone queue for zone %u (levels %u-%u).",
-                    zoneId, levelMin, levelMax);
-            addSystemChatMessage(buf);
-            LOG_INFO("SMSG_MEETINGSTONE_SETQUEUE: zone=", zoneId,
-                     " levels=", static_cast<int>(levelMin), "-", static_cast<int>(levelMax));
-        }
-        packet.skipAll();
-    };
-    // Server confirms group found and teleport summon is ready
-    dispatchTable_[Opcode::SMSG_MEETINGSTONE_COMPLETE] = [this](network::Packet& packet) {
-        // Server confirms group found and teleport summon is ready
-        addSystemChatMessage("Meeting Stone: Your group is ready! Use the Meeting Stone to summon.");
-        LOG_INFO("SMSG_MEETINGSTONE_COMPLETE");
-        packet.skipAll();
-    };
-    // Meeting stone search is still ongoing
-    dispatchTable_[Opcode::SMSG_MEETINGSTONE_IN_PROGRESS] = [this](network::Packet& packet) {
-        // Meeting stone search is still ongoing
-        addSystemChatMessage("Meeting Stone: Searching for group members...");
-        LOG_DEBUG("SMSG_MEETINGSTONE_IN_PROGRESS");
-        packet.skipAll();
-    };
-    // uint64 memberGuid — a player was added to your group via meeting stone
-    dispatchTable_[Opcode::SMSG_MEETINGSTONE_MEMBER_ADDED] = [this](network::Packet& packet) {
-        // uint64 memberGuid — a player was added to your group via meeting stone
-        if (packet.hasRemaining(8)) {
-            uint64_t memberGuid = packet.readUInt64();
-            const auto& memberName = lookupName(memberGuid);
-            if (!memberName.empty()) {
-                addSystemChatMessage("Meeting Stone: " + memberName +
-                                     " has been added to your group.");
-            } else {
-                addSystemChatMessage("Meeting Stone: A new player has been added to your group.");
-            }
-            LOG_INFO("SMSG_MEETINGSTONE_MEMBER_ADDED: guid=0x", std::hex, memberGuid, std::dec);
-        }
-    };
-    // uint8 reason — failed to join group via meeting stone
-    // 0=target_not_in_lfg, 1=target_in_party, 2=target_invalid_map, 3=target_not_available
-    dispatchTable_[Opcode::SMSG_MEETINGSTONE_JOINFAILED] = [this](network::Packet& packet) {
-        // uint8 reason — failed to join group via meeting stone
-        // 0=target_not_in_lfg, 1=target_in_party, 2=target_invalid_map, 3=target_not_available
-        static const char* kMeetingstoneErrors[] = {
-            "Target player is not using the Meeting Stone.",
-            "Target player is already in a group.",
-            "You are not in a valid zone for that Meeting Stone.",
-            "Target player is not available.",
-        };
-        if (packet.hasRemaining(1)) {
-            uint8_t reason = packet.readUInt8();
-            const char* msg = (reason < 4) ? kMeetingstoneErrors[reason]
-                                           : "Meeting Stone: Could not join group.";
-            addSystemChatMessage(msg);
-            LOG_INFO("SMSG_MEETINGSTONE_JOINFAILED: reason=", static_cast<int>(reason));
-        }
-    };
-    // Player was removed from the meeting stone queue (left, or group disbanded)
-    dispatchTable_[Opcode::SMSG_MEETINGSTONE_LEAVE] = [this](network::Packet& packet) {
-        // Player was removed from the meeting stone queue (left, or group disbanded)
-        addSystemChatMessage("You have left the Meeting Stone queue.");
-        LOG_DEBUG("SMSG_MEETINGSTONE_LEAVE");
-        packet.skipAll();
-    };
-    dispatchTable_[Opcode::SMSG_GMTICKET_CREATE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(1)) {
-            uint8_t res = packet.readUInt8();
-            addSystemChatMessage(res == 1 ? "GM ticket submitted."
-                                          : "Failed to submit GM ticket.");
-        }
-    };
-    dispatchTable_[Opcode::SMSG_GMTICKET_UPDATETEXT] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(1)) {
-            uint8_t res = packet.readUInt8();
-            addSystemChatMessage(res == 1 ? "GM ticket updated."
-                                          : "Failed to update GM ticket.");
-        }
-    };
-    dispatchTable_[Opcode::SMSG_GMTICKET_DELETETICKET] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(1)) {
-            uint8_t res = packet.readUInt8();
-            addSystemChatMessage(res == 9 ? "GM ticket deleted."
-                                          : "No ticket to delete.");
-        }
-    };
-    // WotLK 3.3.5a format:
-    //   uint8  status  — 1=no ticket, 6=has open ticket, 3=closed, 10=suspended
-    // If status == 6 (GMTICKET_STATUS_HASTEXT):
-    //   cstring ticketText
-    //   uint32  ticketAge       (seconds old)
-    //   uint32  daysUntilOld    (days remaining before escalation)
-    //   float   waitTimeHours   (estimated GM wait time)
-    dispatchTable_[Opcode::SMSG_GMTICKET_GETTICKET] = [this](network::Packet& packet) {
-        // WotLK 3.3.5a format:
-        //   uint8  status  — 1=no ticket, 6=has open ticket, 3=closed, 10=suspended
-        // If status == 6 (GMTICKET_STATUS_HASTEXT):
-        //   cstring ticketText
-        //   uint32  ticketAge       (seconds old)
-        //   uint32  daysUntilOld    (days remaining before escalation)
-        //   float   waitTimeHours   (estimated GM wait time)
-        if (!packet.hasRemaining(1)) { packet.skipAll(); return; }
-        uint8_t gmStatus = packet.readUInt8();
-        // Status 6 = GMTICKET_STATUS_HASTEXT — open ticket with text
-        if (gmStatus == 6 && packet.hasRemaining(1)) {
-            gmTicketText_    = packet.readString();
-            uint32_t ageSec  = (packet.hasRemaining(4)) ? packet.readUInt32() : 0;
-            /*uint32_t daysLeft =*/ (packet.hasRemaining(4)) ? packet.readUInt32() : 0;
-            gmTicketWaitHours_ = (packet.hasRemaining(4))
-                ? packet.readFloat() : 0.0f;
-            gmTicketActive_ = true;
-            char buf[256];
-            if (ageSec < 60) {
-                std::snprintf(buf, sizeof(buf),
-                    "You have an open GM ticket (submitted %us ago). Estimated wait: %.1f hours.",
-                    ageSec, gmTicketWaitHours_);
-            } else {
-                uint32_t ageMin = ageSec / 60;
-                std::snprintf(buf, sizeof(buf),
-                    "You have an open GM ticket (submitted %um ago). Estimated wait: %.1f hours.",
-                    ageMin, gmTicketWaitHours_);
-            }
-            addSystemChatMessage(buf);
-            LOG_INFO("SMSG_GMTICKET_GETTICKET: open ticket age=", ageSec,
-                     "s wait=", gmTicketWaitHours_, "h");
-        } else if (gmStatus == 3) {
-            gmTicketActive_ = false;
-            gmTicketText_.clear();
-            addSystemChatMessage("Your GM ticket has been closed.");
-            LOG_INFO("SMSG_GMTICKET_GETTICKET: ticket closed");
-        } else if (gmStatus == 10) {
-            gmTicketActive_ = false;
-            gmTicketText_.clear();
-            addSystemChatMessage("Your GM ticket has been suspended.");
-            LOG_INFO("SMSG_GMTICKET_GETTICKET: ticket suspended");
-        } else {
-            // Status 1 = no open ticket (default/no ticket)
-            gmTicketActive_ = false;
-            gmTicketText_.clear();
-            LOG_DEBUG("SMSG_GMTICKET_GETTICKET: no open ticket (status=", static_cast<int>(gmStatus), ")");
-        }
-        packet.skipAll();
-    };
-    // uint32 status: 1 = GM support available, 0 = offline/unavailable
-    dispatchTable_[Opcode::SMSG_GMTICKET_SYSTEMSTATUS] = [this](network::Packet& packet) {
-        // uint32 status: 1 = GM support available, 0 = offline/unavailable
-        if (packet.hasRemaining(4)) {
-            uint32_t sysStatus = packet.readUInt32();
-            gmSupportAvailable_ = (sysStatus != 0);
-            addSystemChatMessage(gmSupportAvailable_
-                ? "GM support is currently available."
-                : "GM support is currently unavailable.");
-            LOG_INFO("SMSG_GMTICKET_SYSTEMSTATUS: available=", gmSupportAvailable_);
-        }
-        packet.skipAll();
-    };
-    // uint8 runeIndex + uint8 newRuneType (0=Blood,1=Unholy,2=Frost,3=Death)
-    dispatchTable_[Opcode::SMSG_CONVERT_RUNE] = [this](network::Packet& packet) {
-        // uint8 runeIndex + uint8 newRuneType (0=Blood,1=Unholy,2=Frost,3=Death)
-        if (!packet.hasRemaining(2)) {
-            packet.skipAll();
-            return;
-        }
-        uint8_t idx  = packet.readUInt8();
-        uint8_t type = packet.readUInt8();
-        if (idx < 6) playerRunes_[idx].type = static_cast<RuneType>(type & 0x3);
-    };
-    // uint8 runeReadyMask (bit i=1 → rune i is ready)
-    // uint8[6] cooldowns (0=ready, 255=just used → readyFraction = 1 - val/255)
-    dispatchTable_[Opcode::SMSG_RESYNC_RUNES] = [this](network::Packet& packet) {
-        // uint8 runeReadyMask (bit i=1 → rune i is ready)
-        // uint8[6] cooldowns (0=ready, 255=just used → readyFraction = 1 - val/255)
-        if (!packet.hasRemaining(7)) {
-            packet.skipAll();
-            return;
-        }
-        uint8_t readyMask = packet.readUInt8();
-        for (int i = 0; i < 6; i++) {
-            uint8_t cd = packet.readUInt8();
-            playerRunes_[i].ready = (readyMask & (1u << i)) != 0;
-            playerRunes_[i].readyFraction = 1.0f - cd / 255.0f;
-            if (playerRunes_[i].ready) playerRunes_[i].readyFraction = 1.0f;
-        }
-    };
-    // uint32 runeMask (bit i=1 → rune i just became ready)
-    dispatchTable_[Opcode::SMSG_ADD_RUNE_POWER] = [this](network::Packet& packet) {
-        // uint32 runeMask (bit i=1 → rune i just became ready)
-        if (!packet.hasRemaining(4)) {
-            packet.skipAll();
-            return;
-        }
-        uint32_t runeMask = packet.readUInt32();
-        for (int i = 0; i < 6; i++) {
-            if (runeMask & (1u << i)) {
-                playerRunes_[i].ready = true;
-                playerRunes_[i].readyFraction = 1.0f;
-            }
-        }
-    };
-
-    // uint8 result: 0=success, 1=failed, 2=disabled
-    dispatchTable_[Opcode::SMSG_COMPLAIN_RESULT] = [this](network::Packet& packet) {
-        // uint8 result: 0=success, 1=failed, 2=disabled
-        if (packet.hasRemaining(1)) {
-            uint8_t result = packet.readUInt8();
-            if (result == 0)
-                addSystemChatMessage("Your complaint has been submitted.");
-            else if (result == 2)
-                addUIError("Report a Player is currently disabled.");
-        }
-        packet.skipAll();
-    };
-    // uint32 slot + packed_guid unit (0 packed = clear slot)
-    dispatchTable_[Opcode::SMSG_UPDATE_INSTANCE_ENCOUNTER_UNIT] = [this](network::Packet& packet) {
-        // uint32 slot + packed_guid unit (0 packed = clear slot)
-        if (!packet.hasRemaining(5)) {
-            packet.skipAll();
-            return;
-        }
-        uint32_t slot = packet.readUInt32();
-        uint64_t unit = packet.readPackedGuid();
-        if (socialHandler_) {
-            socialHandler_->setEncounterUnitGuid(slot, unit);
-            LOG_DEBUG("SMSG_UPDATE_INSTANCE_ENCOUNTER_UNIT: slot=", slot,
-                      " guid=0x", std::hex, unit, std::dec);
-        }
-    };
-    // charName (cstring) + guid (uint64) + achievementId (uint32) + ...
-    dispatchTable_[Opcode::SMSG_SERVER_FIRST_ACHIEVEMENT] = [this](network::Packet& packet) {
-        // charName (cstring) + guid (uint64) + achievementId (uint32) + ...
-        if (packet.hasData()) {
-            std::string charName = packet.readString();
-            if (packet.hasRemaining(12)) {
-                /*uint64_t guid =*/ packet.readUInt64();
-                uint32_t achievementId = packet.readUInt32();
-                loadAchievementNameCache();
-                auto nit = achievementNameCache_.find(achievementId);
-                char buf[256];
-                if (nit != achievementNameCache_.end() && !nit->second.empty()) {
-                    std::snprintf(buf, sizeof(buf),
-                        "%s is the first on the realm to earn: %s!",
-                        charName.c_str(), nit->second.c_str());
-                } else {
-                    std::snprintf(buf, sizeof(buf),
-                        "%s is the first on the realm to earn achievement #%u!",
-                        charName.c_str(), achievementId);
-                }
-                addSystemChatMessage(buf);
-            }
-        }
-        packet.skipAll();
-    };
-    dispatchTable_[Opcode::SMSG_SUSPEND_COMMS] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t seqIdx = packet.readUInt32();
-            if (socket) {
-                network::Packet ack(wireOpcode(Opcode::CMSG_SUSPEND_COMMS_ACK));
-                ack.writeUInt32(seqIdx);
-                socket->send(ack);
-            }
-        }
-    };
-    // SMSG_PRE_RESURRECT: packed GUID of the player who can self-resurrect.
-    // Sent when the dead player has Reincarnation (Shaman), Twisting Nether (Warlock),
-    // or Deathpact (Death Knight passive). The client must send CMSG_SELF_RES to accept.
-    dispatchTable_[Opcode::SMSG_PRE_RESURRECT] = [this](network::Packet& packet) {
-        // SMSG_PRE_RESURRECT: packed GUID of the player who can self-resurrect.
-        // Sent when the dead player has Reincarnation (Shaman), Twisting Nether (Warlock),
-        // or Deathpact (Death Knight passive). The client must send CMSG_SELF_RES to accept.
-        uint64_t targetGuid = packet.readPackedGuid();
-        if (targetGuid == playerGuid || targetGuid == 0) {
-            selfResAvailable_ = true;
-            LOG_INFO("SMSG_PRE_RESURRECT: self-resurrection available (guid=0x",
-                     std::hex, targetGuid, std::dec, ")");
-        }
-    };
-    dispatchTable_[Opcode::SMSG_PLAYERBINDERROR] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t error = packet.readUInt32();
-            if (error == 0) {
-                addUIError("Your hearthstone is not bound.");
-                addSystemChatMessage("Your hearthstone is not bound.");
-            } else {
-                addUIError("Hearthstone bind failed.");
-                addSystemChatMessage("Hearthstone bind failed.");
-            }
-        }
-    };
-    dispatchTable_[Opcode::SMSG_RAID_GROUP_ONLY] = [this](network::Packet& packet) {
-        addUIError("You must be in a raid group to enter this instance.");
-        addSystemChatMessage("You must be in a raid group to enter this instance.");
-        packet.skipAll();
-    };
-    dispatchTable_[Opcode::SMSG_RAID_READY_CHECK_ERROR] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(1)) {
-            uint8_t err = packet.readUInt8();
-            if (err == 0) { addUIError("Ready check failed: not in a group."); addSystemChatMessage("Ready check failed: not in a group."); }
-            else if (err == 1) { addUIError("Ready check failed: in instance."); addSystemChatMessage("Ready check failed: in instance."); }
-            else { addUIError("Ready check failed."); addSystemChatMessage("Ready check failed."); }
-        }
-    };
-    dispatchTable_[Opcode::SMSG_RESET_FAILED_NOTIFY] = [this](network::Packet& packet) {
-        addUIError("Cannot reset instance: another player is still inside.");
-        addSystemChatMessage("Cannot reset instance: another player is still inside.");
-        packet.skipAll();
-    };
-    // uint32 splitType + uint32 deferTime + string realmName
-    // Client must respond with CMSG_REALM_SPLIT to avoid session timeout on some servers.
-    dispatchTable_[Opcode::SMSG_REALM_SPLIT] = [this](network::Packet& packet) {
-        // uint32 splitType + uint32 deferTime + string realmName
-        // Client must respond with CMSG_REALM_SPLIT to avoid session timeout on some servers.
-        uint32_t splitType = 0;
-        if (packet.hasRemaining(4))
-            splitType = packet.readUInt32();
-        packet.skipAll();
-        if (socket) {
-            network::Packet resp(wireOpcode(Opcode::CMSG_REALM_SPLIT));
-            resp.writeUInt32(splitType);
-            resp.writeString("3.3.5");
-            socket->send(resp);
-            LOG_DEBUG("SMSG_REALM_SPLIT splitType=", splitType, " — sent CMSG_REALM_SPLIT ack");
-        }
-    };
-    dispatchTable_[Opcode::SMSG_REAL_GROUP_UPDATE] = [this](network::Packet& packet) {
-        auto rem = [&]() { return packet.getRemainingSize(); };
-        if (rem() < 1) return;
-        uint8_t newGroupType = packet.readUInt8();
-        if (rem() < 4) return;
-        uint32_t newMemberFlags = packet.readUInt32();
-        if (rem() < 8) return;
-        uint64_t newLeaderGuid = packet.readUInt64();
-
-        if (socialHandler_) {
-            auto& pd = socialHandler_->mutablePartyData();
-            pd.groupType = newGroupType;
-            pd.leaderGuid = newLeaderGuid;
-
-            // Update local player's flags in the member list
-            uint64_t localGuid = playerGuid;
-            for (auto& m : pd.members) {
-                if (m.guid == localGuid) {
-                    m.flags = static_cast<uint8_t>(newMemberFlags & 0xFF);
-                    break;
-                }
-            }
-        }
-        LOG_DEBUG("SMSG_REAL_GROUP_UPDATE groupType=", static_cast<int>(newGroupType),
-                  " memberFlags=0x", std::hex, newMemberFlags, std::dec,
-                  " leaderGuid=", newLeaderGuid);
-        fireAddonEvent("PARTY_LEADER_CHANGED", {});
-        fireAddonEvent("GROUP_ROSTER_UPDATE", {});
-    };
-    dispatchTable_[Opcode::SMSG_PLAY_MUSIC] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t soundId = packet.readUInt32();
-            if (playMusicCallback_) playMusicCallback_(soundId);
-        }
-    };
-    dispatchTable_[Opcode::SMSG_PLAY_OBJECT_SOUND] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(12)) {
-            // uint32 soundId + uint64 sourceGuid
-            uint32_t soundId = packet.readUInt32();
-            uint64_t srcGuid = packet.readUInt64();
-            LOG_DEBUG("SMSG_PLAY_OBJECT_SOUND: id=", soundId, " src=0x", std::hex, srcGuid, std::dec);
-            if (playPositionalSoundCallback_) playPositionalSoundCallback_(soundId, srcGuid);
-            else if (playSoundCallback_) playSoundCallback_(soundId);
-        } else if (packet.hasRemaining(4)) {
-            uint32_t soundId = packet.readUInt32();
-            if (playSoundCallback_) playSoundCallback_(soundId);
-        }
-    };
-    // uint64 targetGuid + uint32 visualId (same structure as SMSG_PLAY_SPELL_VISUAL)
-    dispatchTable_[Opcode::SMSG_PLAY_SPELL_IMPACT] = [this](network::Packet& packet) {
-        // uint64 targetGuid + uint32 visualId (same structure as SMSG_PLAY_SPELL_VISUAL)
-        if (!packet.hasRemaining(12)) {
-            packet.skipAll(); return;
-        }
-        uint64_t impTargetGuid = packet.readUInt64();
-        uint32_t impVisualId   = packet.readUInt32();
-        if (impVisualId == 0) return;
-        auto* renderer = services_.renderer;
-        if (!renderer) return;
-        glm::vec3 spawnPos;
-        if (impTargetGuid == playerGuid) {
-            spawnPos = renderer->getCharacterPosition();
-        } else {
-            auto entity = entityController_->getEntityManager().getEntity(impTargetGuid);
-            if (!entity) return;
-            glm::vec3 canonical(entity->getLatestX(), entity->getLatestY(), entity->getLatestZ());
-            spawnPos = core::coords::canonicalToRender(canonical);
-        }
-        renderer->playSpellVisual(impVisualId, spawnPos, /*useImpactKit=*/true);
-    };
-    // SMSG_READ_ITEM_OK — moved to InventoryHandler::registerOpcodes
-    // SMSG_READ_ITEM_FAILED — moved to InventoryHandler::registerOpcodes
-    // SMSG_QUERY_QUESTS_COMPLETED_RESPONSE — moved to QuestHandler::registerOpcodes
-    dispatchTable_[Opcode::SMSG_NPC_WONT_TALK] = [this](network::Packet& packet) {
-        addUIError("That creature can't talk to you right now.");
-        addSystemChatMessage("That creature can't talk to you right now.");
-        packet.skipAll();
-    };
-
-    // SMSG_PET_UNLEARN_CONFIRM: uint64 petGuid + uint32 cost (copper).
-    // The other pet opcodes have different formats and must NOT set unlearn state.
-    dispatchTable_[Opcode::SMSG_PET_UNLEARN_CONFIRM] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(12)) {
-            petUnlearnGuid_ = packet.readUInt64();
-            petUnlearnCost_ = packet.readUInt32();
-            petUnlearnPending_ = true;
-        }
-        packet.skipAll();
-    };
-    // These pet opcodes have incompatible formats — just consume the packet.
-    // Previously they shared the unlearn handler, which misinterpreted sound IDs
-    // or GUID lists as unlearn costs and could trigger a bogus unlearn dialog.
-    for (auto op : { Opcode::SMSG_PET_GUIDS, Opcode::SMSG_PET_DISMISS_SOUND,
-                     Opcode::SMSG_PET_ACTION_SOUND }) {
-        dispatchTable_[op] = [](network::Packet& packet) { packet.skipAll(); };
-    }
-    // Server signals that the pet can now be named (first tame)
-    dispatchTable_[Opcode::SMSG_PET_RENAMEABLE] = [this](network::Packet& packet) {
-        // Server signals that the pet can now be named (first tame)
-        petRenameablePending_ = true;
-        packet.skipAll();
-    };
-    dispatchTable_[Opcode::SMSG_PET_NAME_INVALID] = [this](network::Packet& packet) {
-        addUIError("That pet name is invalid. Please choose a different name.");
-        addSystemChatMessage("That pet name is invalid. Please choose a different name.");
-        packet.skipAll();
-    };
-    // Classic 1.12: PackedGUID + 19×uint32 itemEntries (EQUIPMENT_SLOT_END=19)
-    // This opcode is only reachable on Classic servers; TBC/WotLK wire 0x115 maps to
-    // SMSG_INSPECT_RESULTS_UPDATE which is handled separately.
-    dispatchTable_[Opcode::SMSG_INSPECT] = [this](network::Packet& packet) {
-        // Classic 1.12: PackedGUID + 19×uint32 itemEntries (EQUIPMENT_SLOT_END=19)
-        // This opcode is only reachable on Classic servers; TBC/WotLK wire 0x115 maps to
-        // SMSG_INSPECT_RESULTS_UPDATE which is handled separately.
-        if (!packet.hasRemaining(2)) {
-            packet.skipAll(); return;
-        }
-        uint64_t guid = packet.readPackedGuid();
-        if (guid == 0) { packet.skipAll(); return; }
-
-        constexpr int kGearSlots = 19;
-        size_t needed = kGearSlots * sizeof(uint32_t);
-        if (!packet.hasRemaining(needed)) {
-            packet.skipAll(); return;
-        }
-
-        std::array<uint32_t, 19> items{};
-        for (int s = 0; s < kGearSlots; ++s)
-            items[s] = packet.readUInt32();
-
-        // Resolve player name
-        auto ent = entityController_->getEntityManager().getEntity(guid);
-        std::string playerName = "Target";
-        if (ent) {
-            auto pl = std::dynamic_pointer_cast<Player>(ent);
-            if (pl && !pl->getName().empty()) playerName = pl->getName();
-        }
-
-        // Populate inspect result immediately (no talent data in Classic SMSG_INSPECT)
-        if (socialHandler_) {
-            auto& ir = socialHandler_->mutableInspectResult();
-            ir.guid           = guid;
-            ir.playerName     = playerName;
-            ir.totalTalents   = 0;
-            ir.unspentTalents = 0;
-            ir.talentGroups   = 0;
-            ir.activeTalentGroup = 0;
-            ir.itemEntries    = items;
-            ir.enchantIds     = {};
-        }
-
-        // Also cache for future talent-inspect cross-reference
-        inspectedPlayerItemEntries_[guid] = items;
-
-        // Trigger item queries for non-empty slots
-        for (int s = 0; s < kGearSlots; ++s) {
-            if (items[s] != 0) queryItemInfo(items[s], 0);
-        }
-
-        LOG_INFO("SMSG_INSPECT (Classic): ", playerName, " has gear in ",
-                 std::count_if(items.begin(), items.end(),
-                               [](uint32_t e) { return e != 0; }), "/19 slots");
-        if (addonEventCallback_) {
-            char guidBuf[32];
-            snprintf(guidBuf, sizeof(guidBuf), "0x%016llX", (unsigned long long)guid);
-            fireAddonEvent("INSPECT_READY", {guidBuf});
-        }
-    };
-    // Same wire format as SMSG_COMPRESSED_MOVES: uint8 size + uint16 opcode + payload[]
-    dispatchTable_[Opcode::SMSG_MULTIPLE_MOVES] = [this](network::Packet& packet) {
-        // Same wire format as SMSG_COMPRESSED_MOVES: uint8 size + uint16 opcode + payload[]
-        if (movementHandler_) movementHandler_->handleCompressedMoves(packet);
-    };
-    // Each sub-packet uses the standard WotLK server wire format:
-    //   uint16_be subSize  (includes the 2-byte opcode; payload = subSize - 2)
-    //   uint16_le subOpcode
-    //   payload  (subSize - 2 bytes)
-    dispatchTable_[Opcode::SMSG_MULTIPLE_PACKETS] = [this](network::Packet& packet) {
-        // Each sub-packet uses the standard WotLK server wire format:
-        //   uint16_be subSize  (includes the 2-byte opcode; payload = subSize - 2)
-        //   uint16_le subOpcode
-        //   payload  (subSize - 2 bytes)
-        const auto& pdata = packet.getData();
-        size_t dataLen = pdata.size();
-        size_t pos = packet.getReadPos();
-        static uint32_t multiPktWarnCount = 0;
-        std::vector<network::Packet> subPackets;
-        while (pos + 4 <= dataLen) {
-            uint16_t subSize = static_cast<uint16_t>(
-                (static_cast<uint16_t>(pdata[pos]) << 8) | pdata[pos + 1]);
-            if (subSize < 2) break;
-            size_t payloadLen = subSize - 2;
-            if (pos + 4 + payloadLen > dataLen) {
-                if (++multiPktWarnCount <= 10) {
-                    LOG_WARNING("SMSG_MULTIPLE_PACKETS: sub-packet overruns buffer at pos=",
-                                pos, " subSize=", subSize, " dataLen=", dataLen);
-                }
-                break;
-            }
-            uint16_t subOpcode = static_cast<uint16_t>(pdata[pos + 2]) |
-                                 (static_cast<uint16_t>(pdata[pos + 3]) << 8);
-            std::vector<uint8_t> subPayload(pdata.begin() + pos + 4,
-                                            pdata.begin() + pos + 4 + payloadLen);
-            subPackets.emplace_back(subOpcode, std::move(subPayload));
-            pos += 4 + payloadLen;
-        }
-        for (auto it = subPackets.rbegin(); it != subPackets.rend(); ++it) {
-            enqueueIncomingPacketFront(std::move(*it));
-        }
-        packet.skipAll();
-    };
-    // Recruit-A-Friend: a mentor is offering to grant you a level
-    dispatchTable_[Opcode::SMSG_PROPOSE_LEVEL_GRANT] = [this](network::Packet& packet) {
-        // Recruit-A-Friend: a mentor is offering to grant you a level
-        if (packet.hasRemaining(8)) {
-            uint64_t mentorGuid = packet.readUInt64();
-            std::string mentorName;
-            auto ent = entityController_->getEntityManager().getEntity(mentorGuid);
-            if (auto* unit = dynamic_cast<Unit*>(ent.get())) mentorName = unit->getName();
-            if (mentorName.empty()) mentorName = lookupName(mentorGuid);
-            addSystemChatMessage(mentorName.empty()
-                ? "A player is offering to grant you a level."
-                : (mentorName + " is offering to grant you a level."));
-        }
-        packet.skipAll();
-    };
-    // SMSG_REFER_A_FRIEND_EXPIRED — moved to SocialHandler::registerOpcodes
-    // SMSG_REFER_A_FRIEND_FAILURE — moved to SocialHandler::registerOpcodes
-    // SMSG_REPORT_PVP_AFK_RESULT — moved to SocialHandler::registerOpcodes
-    dispatchTable_[Opcode::SMSG_RESPOND_INSPECT_ACHIEVEMENTS] = [this](network::Packet& packet) {
-        loadAchievementNameCache();
-        if (!packet.hasRemaining(1)) return;
-        uint64_t inspectedGuid = packet.readPackedGuid();
-        if (inspectedGuid == 0) { packet.skipAll(); return; }
-        std::unordered_set<uint32_t> achievements;
-        while (packet.hasRemaining(4)) {
-            uint32_t id = packet.readUInt32();
-            if (id == 0xFFFFFFFF) break;
-            if (!packet.hasRemaining(4)) break;
-            /*date*/ packet.readUInt32();
-            achievements.insert(id);
-        }
-        while (packet.hasRemaining(4)) {
-            uint32_t id = packet.readUInt32();
-            if (id == 0xFFFFFFFF) break;
-            if (!packet.hasRemaining(16)) break;
-            packet.readUInt64(); packet.readUInt32(); packet.readUInt32();
-        }
-        inspectedPlayerAchievements_[inspectedGuid] = std::move(achievements);
-        LOG_INFO("SMSG_RESPOND_INSPECT_ACHIEVEMENTS: guid=0x", std::hex, inspectedGuid, std::dec,
-                 " achievements=", inspectedPlayerAchievements_[inspectedGuid].size());
-    };
-    dispatchTable_[Opcode::SMSG_ON_CANCEL_EXPECTED_RIDE_VEHICLE_AURA] = [this](network::Packet& packet) {
-        vehicleId_ = 0;  // Vehicle ride cancelled; clear UI
-        if (vehicleStateCallback_) {
-            vehicleStateCallback_(false, 0);
-        }
-        packet.skipAll();
-    };
-    // uint32 type (0=normal, 1=heavy, 2=tired/restricted) + uint32 minutes played
-    dispatchTable_[Opcode::SMSG_PLAY_TIME_WARNING] = [this](network::Packet& packet) {
-        // uint32 type (0=normal, 1=heavy, 2=tired/restricted) + uint32 minutes played
-        if (packet.hasRemaining(4)) {
-            uint32_t warnType = packet.readUInt32();
-            uint32_t minutesPlayed = (packet.hasRemaining(4))
-                ? packet.readUInt32() : 0;
-            const char* severity = (warnType >= 2) ? "[Tired] " : "[Play Time] ";
-            char buf[128];
-            if (minutesPlayed > 0) {
-                uint32_t h = minutesPlayed / 60;
-                uint32_t m = minutesPlayed % 60;
-                if (h > 0)
-                    std::snprintf(buf, sizeof(buf), "%sYou have been playing for %uh %um.", severity, h, m);
-                else
-                    std::snprintf(buf, sizeof(buf), "%sYou have been playing for %um.", severity, m);
-            } else {
-                std::snprintf(buf, sizeof(buf), "%sYou have been playing for a long time.", severity);
-            }
-            addSystemChatMessage(buf);
-            addUIError(buf);
-        }
-    };
-    // WotLK 3.3.5a format:
-    //   uint64 mirrorGuid — GUID of the mirror image unit
-    //   uint32 displayId  — display ID to render the image with
-    //   uint8  raceId     — race of caster
-    //   uint8  genderFlag — gender of caster
-    //   uint8  classId    — class of caster
-    //   uint64 casterGuid — GUID of the player who cast the spell
-    //   Followed by equipped item display IDs (11 × uint32) if casterGuid != 0
-    // Purpose: tells client how to render the image (same appearance as caster).
-    // We parse the GUIDs so units render correctly via their existing display IDs.
-    dispatchTable_[Opcode::SMSG_MIRRORIMAGE_DATA] = [this](network::Packet& packet) {
-        // WotLK 3.3.5a format:
-        //   uint64 mirrorGuid — GUID of the mirror image unit
-        //   uint32 displayId  — display ID to render the image with
-        //   uint8  raceId     — race of caster
-        //   uint8  genderFlag — gender of caster
-        //   uint8  classId    — class of caster
-        //   uint64 casterGuid — GUID of the player who cast the spell
-        //   Followed by equipped item display IDs (11 × uint32) if casterGuid != 0
-        // Purpose: tells client how to render the image (same appearance as caster).
-        // We parse the GUIDs so units render correctly via their existing display IDs.
-        if (!packet.hasRemaining(8)) return;
-        uint64_t mirrorGuid = packet.readUInt64();
-        if (!packet.hasRemaining(4)) return;
-        uint32_t displayId  = packet.readUInt32();
-        if (!packet.hasRemaining(3)) return;
-        /*uint8_t raceId   =*/ packet.readUInt8();
-        /*uint8_t gender   =*/ packet.readUInt8();
-        /*uint8_t classId  =*/ packet.readUInt8();
-        // Apply display ID to the mirror image unit so it renders correctly
-        if (mirrorGuid != 0 && displayId != 0) {
-            auto entity = entityController_->getEntityManager().getEntity(mirrorGuid);
-            if (entity) {
-                auto unit = std::dynamic_pointer_cast<game::Unit>(entity);
-                if (unit && unit->getDisplayId() == 0)
-                    unit->setDisplayId(displayId);
-            }
-        }
-        LOG_DEBUG("SMSG_MIRRORIMAGE_DATA: mirrorGuid=0x", std::hex, mirrorGuid,
-                  " displayId=", std::dec, displayId);
-        packet.skipAll();
-    };
-    // uint64 battlefieldGuid + uint32 zoneId + uint64 expireUnixTime (seconds)
-    dispatchTable_[Opcode::SMSG_BATTLEFIELD_MGR_ENTRY_INVITE] = [this](network::Packet& packet) {
-        // uint64 battlefieldGuid + uint32 zoneId + uint64 expireUnixTime (seconds)
-        if (!packet.hasRemaining(20)) {
-            packet.skipAll(); return;
-        }
-        uint64_t bfGuid    = packet.readUInt64();
-        uint32_t bfZoneId  = packet.readUInt32();
-        uint64_t expireTime = packet.readUInt64();
-        (void)bfGuid; (void)expireTime;
-        // Store the invitation so the UI can show a prompt
-        bfMgrInvitePending_ = true;
-        bfMgrZoneId_        = bfZoneId;
-        char buf[128];
-        std::string bfZoneName = getAreaName(bfZoneId);
-        if (!bfZoneName.empty())
-            std::snprintf(buf, sizeof(buf),
-                "You are invited to the outdoor battlefield in %s. Click to enter.",
-                bfZoneName.c_str());
-        else
-            std::snprintf(buf, sizeof(buf),
-                "You are invited to the outdoor battlefield in zone %u. Click to enter.",
-                bfZoneId);
-        addSystemChatMessage(buf);
-        LOG_INFO("SMSG_BATTLEFIELD_MGR_ENTRY_INVITE: zoneId=", bfZoneId);
-    };
-    // uint64 battlefieldGuid + uint8 isSafe (1=pvp zones enabled) + uint8 onQueue
-    dispatchTable_[Opcode::SMSG_BATTLEFIELD_MGR_ENTERED] = [this](network::Packet& packet) {
-        // uint64 battlefieldGuid + uint8 isSafe (1=pvp zones enabled) + uint8 onQueue
-        if (packet.hasRemaining(8)) {
-            uint64_t bfGuid2 = packet.readUInt64();
-            (void)bfGuid2;
-            uint8_t isSafe  = (packet.hasRemaining(1)) ? packet.readUInt8() : 0;
-            uint8_t onQueue = (packet.hasRemaining(1)) ? packet.readUInt8() : 0;
-            bfMgrInvitePending_ = false;
-            bfMgrActive_        = true;
-            addSystemChatMessage(isSafe ? "You are in the battlefield zone (safe area)."
-                                        : "You have entered the battlefield!");
-            if (onQueue) addSystemChatMessage("You are in the battlefield queue.");
-            LOG_INFO("SMSG_BATTLEFIELD_MGR_ENTERED: isSafe=", static_cast<int>(isSafe), " onQueue=", static_cast<int>(onQueue));
-        }
-        packet.skipAll();
-    };
-    // uint64 battlefieldGuid + uint32 battlefieldId + uint64 expireTime
-    dispatchTable_[Opcode::SMSG_BATTLEFIELD_MGR_QUEUE_INVITE] = [this](network::Packet& packet) {
-        // uint64 battlefieldGuid + uint32 battlefieldId + uint64 expireTime
-        if (!packet.hasRemaining(20)) {
-            packet.skipAll(); return;
-        }
-        uint64_t bfGuid3   = packet.readUInt64();
-        uint32_t bfId      = packet.readUInt32();
-        uint64_t expTime   = packet.readUInt64();
-        (void)bfGuid3; (void)expTime;
-        bfMgrInvitePending_ = true;
-        bfMgrZoneId_        = bfId;
-        char buf[128];
-        std::snprintf(buf, sizeof(buf),
-            "A spot has opened in the battlefield queue (battlefield %u).", bfId);
-        addSystemChatMessage(buf);
-        LOG_INFO("SMSG_BATTLEFIELD_MGR_QUEUE_INVITE: bfId=", bfId);
-    };
-    // uint32 battlefieldId + uint32 teamId + uint8 accepted + uint8 loggingEnabled + uint8 result
-    // result: 0=queued, 1=not_in_group, 2=too_high_level, 3=too_low_level,
-    //         4=in_cooldown, 5=queued_other_bf, 6=bf_full
-    dispatchTable_[Opcode::SMSG_BATTLEFIELD_MGR_QUEUE_REQUEST_RESPONSE] = [this](network::Packet& packet) {
-        // uint32 battlefieldId + uint32 teamId + uint8 accepted + uint8 loggingEnabled + uint8 result
-        // result: 0=queued, 1=not_in_group, 2=too_high_level, 3=too_low_level,
-        //         4=in_cooldown, 5=queued_other_bf, 6=bf_full
-        if (!packet.hasRemaining(11)) {
-            packet.skipAll(); return;
-        }
-        uint32_t bfId2    = packet.readUInt32();
-        /*uint32_t teamId =*/ packet.readUInt32();
-        uint8_t accepted  = packet.readUInt8();
-        /*uint8_t logging =*/ packet.readUInt8();
-        uint8_t result    = packet.readUInt8();
-        (void)bfId2;
-        if (accepted) {
-            addSystemChatMessage("You have joined the battlefield queue.");
-        } else {
-            static const char* kBfQueueErrors[] = {
-                "Queued for battlefield.", "Not in a group.", "Level too high.",
-                "Level too low.", "Battlefield in cooldown.", "Already queued for another battlefield.",
-                "Battlefield is full."
-            };
-            const char* msg = (result < 7) ? kBfQueueErrors[result]
-                                           : "Battlefield queue request failed.";
-            addSystemChatMessage(std::string("Battlefield: ") + msg);
-        }
-        LOG_INFO("SMSG_BATTLEFIELD_MGR_QUEUE_REQUEST_RESPONSE: accepted=", static_cast<int>(accepted),
-                 " result=", static_cast<int>(result));
-        packet.skipAll();
-    };
-    // uint64 battlefieldGuid + uint8 remove
-    dispatchTable_[Opcode::SMSG_BATTLEFIELD_MGR_EJECT_PENDING] = [this](network::Packet& packet) {
-        // uint64 battlefieldGuid + uint8 remove
-        if (packet.hasRemaining(9)) {
-            uint64_t bfGuid4 = packet.readUInt64();
-            uint8_t  remove  = packet.readUInt8();
-            (void)bfGuid4;
-            if (remove) {
-                addSystemChatMessage("You will be removed from the battlefield shortly.");
-            }
-            LOG_INFO("SMSG_BATTLEFIELD_MGR_EJECT_PENDING: remove=", static_cast<int>(remove));
-        }
-        packet.skipAll();
-    };
-    // uint64 battlefieldGuid + uint32 reason + uint32 battleStatus + uint8 relocated
-    dispatchTable_[Opcode::SMSG_BATTLEFIELD_MGR_EJECTED] = [this](network::Packet& packet) {
-        // uint64 battlefieldGuid + uint32 reason + uint32 battleStatus + uint8 relocated
-        if (packet.hasRemaining(17)) {
-            uint64_t bfGuid5    = packet.readUInt64();
-            uint32_t reason     = packet.readUInt32();
-            /*uint32_t status  =*/ packet.readUInt32();
-            uint8_t relocated   = packet.readUInt8();
-            (void)bfGuid5;
-            static const char* kEjectReasons[] = {
-                "Removed from battlefield.", "Transported from battlefield.",
-                "Left battlefield voluntarily.", "Offline.",
-            };
-            const char* msg = (reason < 4) ? kEjectReasons[reason]
-                                           : "You have been ejected from the battlefield.";
-            addSystemChatMessage(msg);
-            if (relocated) addSystemChatMessage("You have been relocated outside the battlefield.");
-            LOG_INFO("SMSG_BATTLEFIELD_MGR_EJECTED: reason=", reason, " relocated=", static_cast<int>(relocated));
-        }
-        bfMgrActive_        = false;
-        bfMgrInvitePending_ = false;
-        packet.skipAll();
-    };
-    // uint32 oldState + uint32 newState
-    // States: 0=Waiting, 1=Starting, 2=InProgress, 3=Ending, 4=Cooldown
-    dispatchTable_[Opcode::SMSG_BATTLEFIELD_MGR_STATE_CHANGE] = [this](network::Packet& packet) {
-        // uint32 oldState + uint32 newState
-        // States: 0=Waiting, 1=Starting, 2=InProgress, 3=Ending, 4=Cooldown
-        if (packet.hasRemaining(8)) {
-            /*uint32_t oldState =*/ packet.readUInt32();
-            uint32_t newState   = packet.readUInt32();
-            static const char* kBfStates[] = {
-                "waiting", "starting", "in progress", "ending", "in cooldown"
-            };
-            const char* stateStr = (newState < 5) ? kBfStates[newState] : "unknown state";
-            char buf[128];
-            std::snprintf(buf, sizeof(buf), "Battlefield is now %s.", stateStr);
-            addSystemChatMessage(buf);
-            LOG_INFO("SMSG_BATTLEFIELD_MGR_STATE_CHANGE: newState=", newState);
-        }
-        packet.skipAll();
-    };
-    // uint32 numPending — number of unacknowledged calendar invites
-    dispatchTable_[Opcode::SMSG_CALENDAR_SEND_NUM_PENDING] = [this](network::Packet& packet) {
-        // uint32 numPending — number of unacknowledged calendar invites
-        if (packet.hasRemaining(4)) {
-            uint32_t numPending = packet.readUInt32();
-            calendarPendingInvites_ = numPending;
-            if (numPending > 0) {
-                char buf[64];
-                std::snprintf(buf, sizeof(buf),
-                    "You have %u pending calendar invite%s.",
-                    numPending, numPending == 1 ? "" : "s");
-                addSystemChatMessage(buf);
-            }
-            LOG_DEBUG("SMSG_CALENDAR_SEND_NUM_PENDING: ", numPending, " pending invites");
-        }
-    };
-    // uint32 command + uint8 result + cstring info
-    // result 0 = success; non-zero = error code
-    // command values: 0=add,1=get,2=guild_filter,3=arena_team,4=update,5=remove,
-    //                 6=copy,7=invite,8=rsvp,9=remove_invite,10=status,11=moderator_status
-    dispatchTable_[Opcode::SMSG_CALENDAR_COMMAND_RESULT] = [this](network::Packet& packet) {
-        // uint32 command + uint8 result + cstring info
-        // result 0 = success; non-zero = error code
-        // command values: 0=add,1=get,2=guild_filter,3=arena_team,4=update,5=remove,
-        //                 6=copy,7=invite,8=rsvp,9=remove_invite,10=status,11=moderator_status
-        if (!packet.hasRemaining(5)) {
-            packet.skipAll(); return;
-        }
-        /*uint32_t command =*/ packet.readUInt32();
-        uint8_t result    = packet.readUInt8();
-        std::string info  = (packet.hasData()) ? packet.readString() : "";
-        if (result != 0) {
-            // Map common calendar error codes to friendly strings
-            static const char* kCalendarErrors[] = {
-                "",
-                "Calendar: Internal error.",           // 1 = CALENDAR_ERROR_INTERNAL
-                "Calendar: Guild event limit reached.",// 2
-                "Calendar: Event limit reached.",      // 3
-                "Calendar: You cannot invite that player.", // 4
-                "Calendar: No invites remaining.",     // 5
-                "Calendar: Invalid date.",             // 6
-                "Calendar: Cannot invite yourself.",   // 7
-                "Calendar: Cannot modify this event.", // 8
-                "Calendar: Not invited.",              // 9
-                "Calendar: Already invited.",          // 10
-                "Calendar: Player not found.",         // 11
-                "Calendar: Not enough focus.",         // 12
-                "Calendar: Event locked.",             // 13
-                "Calendar: Event deleted.",            // 14
-                "Calendar: Not a moderator.",          // 15
-            };
-            const char* errMsg = (result < 16) ? kCalendarErrors[result]
-                                               : "Calendar: Command failed.";
-            if (errMsg && errMsg[0] != '\0') addSystemChatMessage(errMsg);
-            else if (!info.empty()) addSystemChatMessage("Calendar: " + info);
-        }
-        packet.skipAll();
-    };
-    // Rich notification: eventId(8) + title(cstring) + eventTime(8) + flags(4) +
-    //                   eventType(1) + dungeonId(4) + inviteId(8) + status(1) + rank(1) +
-    //                   isGuildEvent(1) + inviterGuid(8)
-    dispatchTable_[Opcode::SMSG_CALENDAR_EVENT_INVITE_ALERT] = [this](network::Packet& packet) {
-        // Rich notification: eventId(8) + title(cstring) + eventTime(8) + flags(4) +
-        //                   eventType(1) + dungeonId(4) + inviteId(8) + status(1) + rank(1) +
-        //                   isGuildEvent(1) + inviterGuid(8)
-        if (!packet.hasRemaining(9)) {
-            packet.skipAll(); return;
-        }
-        /*uint64_t eventId =*/ packet.readUInt64();
-        std::string title = (packet.hasData()) ? packet.readString() : "";
-        packet.skipAll(); // consume remaining fields
-        if (!title.empty()) {
-            addSystemChatMessage("Calendar invite: " + title);
-        } else {
-            addSystemChatMessage("You have a new calendar invite.");
-        }
-        if (calendarPendingInvites_ < 255) ++calendarPendingInvites_;
-        LOG_INFO("SMSG_CALENDAR_EVENT_INVITE_ALERT: title='", title, "'");
-    };
-    // Sent when an event invite's RSVP status changes for the local player
-    // Format: inviteId(8) + eventId(8) + eventType(1) + flags(4) +
-    //         inviteTime(8) + status(1) + rank(1) + isGuildEvent(1) + title(cstring)
-    dispatchTable_[Opcode::SMSG_CALENDAR_EVENT_STATUS] = [this](network::Packet& packet) {
-        // Sent when an event invite's RSVP status changes for the local player
-        // Format: inviteId(8) + eventId(8) + eventType(1) + flags(4) +
-        //         inviteTime(8) + status(1) + rank(1) + isGuildEvent(1) + title(cstring)
-        if (!packet.hasRemaining(31)) {
-            packet.skipAll(); return;
-        }
-        /*uint64_t inviteId =*/ packet.readUInt64();
-        /*uint64_t eventId  =*/ packet.readUInt64();
-        /*uint8_t  evType   =*/ packet.readUInt8();
-        /*uint32_t flags    =*/ packet.readUInt32();
-        /*uint64_t invTime  =*/ packet.readUInt64();
-        uint8_t status     = packet.readUInt8();
-        /*uint8_t rank      =*/ packet.readUInt8();
-        /*uint8_t isGuild   =*/ packet.readUInt8();
-        std::string evTitle = (packet.hasData()) ? packet.readString() : "";
-        // status: 0=Invited,1=Accepted,2=Declined,3=Confirmed,4=Out,5=Standby,6=SignedUp,7=Not Signed Up,8=Tentative
-        static const char* kRsvpStatus[] = {
-            "invited", "accepted", "declined", "confirmed",
-            "out", "on standby", "signed up", "not signed up", "tentative"
-        };
-        const char* statusStr = (status < 9) ? kRsvpStatus[status] : "unknown";
-        if (!evTitle.empty()) {
-            char buf[256];
-            std::snprintf(buf, sizeof(buf), "Calendar event '%s': your RSVP is %s.",
-                          evTitle.c_str(), statusStr);
-            addSystemChatMessage(buf);
-        }
-        packet.skipAll();
-    };
-    // uint64 inviteId + uint64 eventId + uint32 mapId + uint32 difficulty + uint64 resetTime
-    dispatchTable_[Opcode::SMSG_CALENDAR_RAID_LOCKOUT_ADDED] = [this](network::Packet& packet) {
-        // uint64 inviteId + uint64 eventId + uint32 mapId + uint32 difficulty + uint64 resetTime
-        if (packet.hasRemaining(28)) {
-            /*uint64_t inviteId =*/ packet.readUInt64();
-            /*uint64_t eventId  =*/ packet.readUInt64();
-            uint32_t mapId     = packet.readUInt32();
-            uint32_t difficulty = packet.readUInt32();
-            /*uint64_t resetTime =*/ packet.readUInt64();
-            std::string mapLabel = getMapName(mapId);
-            if (mapLabel.empty()) mapLabel = "map #" + std::to_string(mapId);
-            static const char* kDiff[] = {"Normal","Heroic","25-Man","25-Man Heroic"};
-            const char* diffStr = (difficulty < 4) ? kDiff[difficulty] : nullptr;
-            std::string msg = "Calendar: Raid lockout added for " + mapLabel;
-            if (diffStr) msg += std::string(" (") + diffStr + ")";
-            msg += '.';
-            addSystemChatMessage(msg);
-            LOG_DEBUG("SMSG_CALENDAR_RAID_LOCKOUT_ADDED: mapId=", mapId, " difficulty=", difficulty);
-        }
-        packet.skipAll();
-    };
-    // uint64 inviteId + uint64 eventId + uint32 mapId + uint32 difficulty
-    dispatchTable_[Opcode::SMSG_CALENDAR_RAID_LOCKOUT_REMOVED] = [this](network::Packet& packet) {
-        // uint64 inviteId + uint64 eventId + uint32 mapId + uint32 difficulty
-        if (packet.hasRemaining(20)) {
-            /*uint64_t inviteId =*/ packet.readUInt64();
-            /*uint64_t eventId  =*/ packet.readUInt64();
-            uint32_t mapId     = packet.readUInt32();
-            uint32_t difficulty = packet.readUInt32();
-            std::string mapLabel = getMapName(mapId);
-            if (mapLabel.empty()) mapLabel = "map #" + std::to_string(mapId);
-            static const char* kDiff[] = {"Normal","Heroic","25-Man","25-Man Heroic"};
-            const char* diffStr = (difficulty < 4) ? kDiff[difficulty] : nullptr;
-            std::string msg = "Calendar: Raid lockout removed for " + mapLabel;
-            if (diffStr) msg += std::string(" (") + diffStr + ")";
-            msg += '.';
-            addSystemChatMessage(msg);
-            LOG_DEBUG("SMSG_CALENDAR_RAID_LOCKOUT_REMOVED: mapId=", mapId,
-                      " difficulty=", difficulty);
-        }
-        packet.skipAll();
-    };
-    // uint32 unixTime — server's current unix timestamp; use to sync gameTime_
-    dispatchTable_[Opcode::SMSG_SERVERTIME] = [this](network::Packet& packet) {
-        // uint32 unixTime — server's current unix timestamp; use to sync gameTime_
-        if (packet.hasRemaining(4)) {
-            uint32_t srvTime = packet.readUInt32();
-            if (srvTime > 0) {
-                gameTime_ = static_cast<float>(srvTime);
-                LOG_DEBUG("SMSG_SERVERTIME: serverTime=", srvTime);
-            }
-        }
-    };
-    // uint64 kickerGuid + uint32 kickReasonType + null-terminated reason string
-    // kickReasonType: 0=other, 1=afk, 2=vote kick
-    dispatchTable_[Opcode::SMSG_KICK_REASON] = [this](network::Packet& packet) {
-        // uint64 kickerGuid + uint32 kickReasonType + null-terminated reason string
-        // kickReasonType: 0=other, 1=afk, 2=vote kick
-        if (!packet.hasRemaining(12)) {
-            packet.skipAll();
-            return;
-        }
-        uint64_t kickerGuid   = packet.readUInt64();
-        uint32_t reasonType   = packet.readUInt32();
-        std::string reason;
-        if (packet.hasData())
-            reason = packet.readString();
-        (void)kickerGuid;  // not displayed; reasonType IS used below
-        std::string msg = "You have been removed from the group.";
-        if (!reason.empty())
-            msg = "You have been removed from the group: " + reason;
-        else if (reasonType == 1)
-            msg = "You have been removed from the group for being AFK.";
-        else if (reasonType == 2)
-            msg = "You have been removed from the group by vote.";
-        addSystemChatMessage(msg);
-        addUIError(msg);
-        LOG_INFO("SMSG_KICK_REASON: reasonType=", reasonType,
-                 " reason='", reason, "'");
-    };
-    // uint32 throttleMs — rate-limited group action; notify the player
-    dispatchTable_[Opcode::SMSG_GROUPACTION_THROTTLED] = [this](network::Packet& packet) {
-        // uint32 throttleMs — rate-limited group action; notify the player
-        if (packet.hasRemaining(4)) {
-            uint32_t throttleMs = packet.readUInt32();
-            char buf[128];
-            if (throttleMs > 0) {
-                std::snprintf(buf, sizeof(buf),
-                              "Group action throttled. Please wait %.1f seconds.",
-                              throttleMs / 1000.0f);
-            } else {
-                std::snprintf(buf, sizeof(buf), "Group action throttled.");
-            }
-            addSystemChatMessage(buf);
-            LOG_DEBUG("SMSG_GROUPACTION_THROTTLED: throttleMs=", throttleMs);
-        }
-    };
-    // WotLK 3.3.5a: uint32 ticketId + string subject + string body + uint32 count
-    //   per count: string responseText
-    dispatchTable_[Opcode::SMSG_GMRESPONSE_RECEIVED] = [this](network::Packet& packet) {
-        // WotLK 3.3.5a: uint32 ticketId + string subject + string body + uint32 count
-        //   per count: string responseText
-        if (!packet.hasRemaining(4)) {
-            packet.skipAll();
-            return;
-        }
-        uint32_t ticketId = packet.readUInt32();
-        std::string subject;
-        std::string body;
-        if (packet.hasData()) subject = packet.readString();
-        if (packet.hasData()) body    = packet.readString();
-        uint32_t responseCount = 0;
-        if (packet.hasRemaining(4))
-            responseCount = packet.readUInt32();
-        std::string responseText;
-        for (uint32_t i = 0; i < responseCount && i < 10; ++i) {
-            if (packet.hasData()) {
-                std::string t = packet.readString();
-                if (i == 0) responseText = t;
-            }
-        }
-        (void)ticketId;
-        std::string msg;
-        if (!responseText.empty())
-            msg = "[GM Response] " + responseText;
-        else if (!body.empty())
-            msg = "[GM Response] " + body;
-        else if (!subject.empty())
-            msg = "[GM Response] " + subject;
-        else
-            msg = "[GM Response] Your ticket has been answered.";
-        addSystemChatMessage(msg);
-        addUIError(msg);
-        LOG_INFO("SMSG_GMRESPONSE_RECEIVED: ticketId=", ticketId,
-                 " subject='", subject, "'");
-    };
-    // uint32 ticketId + uint8 status (1=open, 2=surveyed, 3=need_more_help)
-    dispatchTable_[Opcode::SMSG_GMRESPONSE_STATUS_UPDATE] = [this](network::Packet& packet) {
-        // uint32 ticketId + uint8 status (1=open, 2=surveyed, 3=need_more_help)
-        if (packet.hasRemaining(5)) {
-            uint32_t ticketId = packet.readUInt32();
-            uint8_t  status   = packet.readUInt8();
-            const char* statusStr = (status == 1) ? "open"
-                                  : (status == 2) ? "answered"
-                                  : (status == 3) ? "needs more info"
-                                  : "updated";
-            char buf[128];
-            std::snprintf(buf, sizeof(buf),
-                          "[GM Ticket #%u] Status: %s.", ticketId, statusStr);
-            addSystemChatMessage(buf);
-            LOG_DEBUG("SMSG_GMRESPONSE_STATUS_UPDATE: ticketId=", ticketId,
-                      " status=", static_cast<int>(status));
-        }
-    };
-    // GM ticket status (new/updated); no ticket UI yet
-    registerSkipHandler(Opcode::SMSG_GM_TICKET_STATUS_UPDATE);
-    // Client uses this outbound; treat inbound variant as no-op for robustness.
-    registerSkipHandler(Opcode::MSG_MOVE_WORLDPORT_ACK);
-    // Observed custom server packet (8 bytes). Safe-consume for now.
-    registerSkipHandler(Opcode::MSG_MOVE_TIME_SKIPPED);
-    // loggingOut_ already cleared by cancelLogout(); this is server's confirmation
-    registerSkipHandler(Opcode::SMSG_LOGOUT_CANCEL_ACK);
-    // These packets are not damage-shield events. Consume them without
-    // synthesizing reflected damage entries or misattributing GUIDs.
-    registerSkipHandler(Opcode::SMSG_AURACASTLOG);
-    // These packets are not damage-shield events. Consume them without
-    // synthesizing reflected damage entries or misattributing GUIDs.
-    registerSkipHandler(Opcode::SMSG_SPELLBREAKLOG);
-    // Consume silently — informational, no UI action needed
-    registerSkipHandler(Opcode::SMSG_ITEM_REFUND_INFO_RESPONSE);
-    // Consume silently — informational, no UI action needed
-    registerSkipHandler(Opcode::SMSG_LOOT_LIST);
-    // Same format as LOCKOUT_ADDED; consume
-    registerSkipHandler(Opcode::SMSG_CALENDAR_RAID_LOCKOUT_UPDATED);
-    // Consume — remaining server notifications not yet parsed
-    for (auto op : {
-        Opcode::SMSG_AFK_MONITOR_INFO_RESPONSE,
-        Opcode::SMSG_AUCTION_LIST_PENDING_SALES,
-        Opcode::SMSG_AVAILABLE_VOICE_CHANNEL,
-        Opcode::SMSG_CALENDAR_ARENA_TEAM,
-        Opcode::SMSG_CALENDAR_CLEAR_PENDING_ACTION,
-        Opcode::SMSG_CALENDAR_EVENT_INVITE,
-        Opcode::SMSG_CALENDAR_EVENT_INVITE_NOTES,
-        Opcode::SMSG_CALENDAR_EVENT_INVITE_NOTES_ALERT,
-        Opcode::SMSG_CALENDAR_EVENT_INVITE_REMOVED,
-        Opcode::SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT,
-        Opcode::SMSG_CALENDAR_EVENT_INVITE_STATUS_ALERT,
-        Opcode::SMSG_CALENDAR_EVENT_MODERATOR_STATUS_ALERT,
-        Opcode::SMSG_CALENDAR_EVENT_REMOVED_ALERT,
-        Opcode::SMSG_CALENDAR_EVENT_UPDATED_ALERT,
-        Opcode::SMSG_CALENDAR_FILTER_GUILD,
-        Opcode::SMSG_CALENDAR_SEND_CALENDAR,
-        Opcode::SMSG_CALENDAR_SEND_EVENT,
-        Opcode::SMSG_CHEAT_DUMP_ITEMS_DEBUG_ONLY_RESPONSE,
-        Opcode::SMSG_CHEAT_DUMP_ITEMS_DEBUG_ONLY_RESPONSE_WRITE_FILE,
-        Opcode::SMSG_CHEAT_PLAYER_LOOKUP,
-        Opcode::SMSG_CHECK_FOR_BOTS,
-        Opcode::SMSG_COMMENTATOR_GET_PLAYER_INFO,
-        Opcode::SMSG_COMMENTATOR_MAP_INFO,
-        Opcode::SMSG_COMMENTATOR_PLAYER_INFO,
-        Opcode::SMSG_COMMENTATOR_SKIRMISH_QUEUE_RESULT1,
-        Opcode::SMSG_COMMENTATOR_SKIRMISH_QUEUE_RESULT2,
-        Opcode::SMSG_COMMENTATOR_STATE_CHANGED,
-        Opcode::SMSG_COOLDOWN_CHEAT,
-        Opcode::SMSG_DANCE_QUERY_RESPONSE,
-        Opcode::SMSG_DBLOOKUP,
-        Opcode::SMSG_DEBUGAURAPROC,
-        Opcode::SMSG_DEBUG_AISTATE,
-        Opcode::SMSG_DEBUG_LIST_TARGETS,
-        Opcode::SMSG_DEBUG_SERVER_GEO,
-        Opcode::SMSG_DUMP_OBJECTS_DATA,
-        Opcode::SMSG_FORCEACTIONSHOW,
-        Opcode::SMSG_GM_PLAYER_INFO,
-        Opcode::SMSG_GODMODE,
-        Opcode::SMSG_IGNORE_DIMINISHING_RETURNS_CHEAT,
-        Opcode::SMSG_IGNORE_REQUIREMENTS_CHEAT,
-        Opcode::SMSG_INVALIDATE_DANCE,
-        Opcode::SMSG_LFG_PENDING_INVITE,
-        Opcode::SMSG_LFG_PENDING_MATCH,
-        Opcode::SMSG_LFG_PENDING_MATCH_DONE,
-        Opcode::SMSG_LFG_UPDATE,
-        Opcode::SMSG_LFG_UPDATE_LFG,
-        Opcode::SMSG_LFG_UPDATE_LFM,
-        Opcode::SMSG_LFG_UPDATE_QUEUED,
-        Opcode::SMSG_MOVE_CHARACTER_CHEAT,
-        Opcode::SMSG_NOTIFY_DANCE,
-        Opcode::SMSG_NOTIFY_DEST_LOC_SPELL_CAST,
-        Opcode::SMSG_PETGODMODE,
-        Opcode::SMSG_PET_UPDATE_COMBO_POINTS,
-        Opcode::SMSG_PLAYER_SKINNED,
-        Opcode::SMSG_PLAY_DANCE,
-        Opcode::SMSG_PROFILEDATA_RESPONSE,
-        Opcode::SMSG_PVP_QUEUE_STATS,
-        Opcode::SMSG_QUERY_OBJECT_POSITION,
-        Opcode::SMSG_QUERY_OBJECT_ROTATION,
-        Opcode::SMSG_REDIRECT_CLIENT,
-        Opcode::SMSG_RESET_RANGED_COMBAT_TIMER,
-        Opcode::SMSG_SEND_ALL_COMBAT_LOG,
-        Opcode::SMSG_SET_EXTRA_AURA_INFO_NEED_UPDATE,
-        Opcode::SMSG_SET_PLAYER_DECLINED_NAMES_RESULT,
-        Opcode::SMSG_SET_PROJECTILE_POSITION,
-        Opcode::SMSG_SPELL_CHANCE_RESIST_PUSHBACK,
-        Opcode::SMSG_SPELL_UPDATE_CHAIN_TARGETS,
-        Opcode::SMSG_STOP_DANCE,
-        Opcode::SMSG_TEST_DROP_RATE_RESULT,
-        Opcode::SMSG_UPDATE_ACCOUNT_DATA,
-        Opcode::SMSG_UPDATE_ACCOUNT_DATA_COMPLETE,
-        Opcode::SMSG_UPDATE_INSTANCE_OWNERSHIP,
-        Opcode::SMSG_UPDATE_LAST_INSTANCE,
-        Opcode::SMSG_VOICESESSION_FULL,
-        Opcode::SMSG_VOICE_CHAT_STATUS,
-        Opcode::SMSG_VOICE_PARENTAL_CONTROLS,
-        Opcode::SMSG_VOICE_SESSION_ADJUST_PRIORITY,
-        Opcode::SMSG_VOICE_SESSION_ENABLE,
-        Opcode::SMSG_VOICE_SESSION_LEAVE,
-        Opcode::SMSG_VOICE_SESSION_ROSTER_UPDATE,
-        Opcode::SMSG_VOICE_SET_TALKER_MUTED
-    }) { registerSkipHandler(op); }
-
-    // -----------------------------------------------------------------------
-    // Domain handler registrations (override duplicate entries above)
-    // -----------------------------------------------------------------------
-    chatHandler_->registerOpcodes(dispatchTable_);
-    movementHandler_->registerOpcodes(dispatchTable_);
-    combatHandler_->registerOpcodes(dispatchTable_);
-    spellHandler_->registerOpcodes(dispatchTable_);
-    inventoryHandler_->registerOpcodes(dispatchTable_);
-    socialHandler_->registerOpcodes(dispatchTable_);
-    questHandler_->registerOpcodes(dispatchTable_);
-    wardenHandler_->registerOpcodes(dispatchTable_);
 }
 
 void GameHandler::handlePacket(network::Packet& packet) {
@@ -3471,10 +1111,9 @@ void GameHandler::handlePacket(network::Packet& packet) {
     }
 
     uint16_t opcode = packet.getOpcode();
-
     try {
 
-    const bool allowVanillaAliases = isPreWotlk();
+    const bool allowVanillaAliases = isClassicLikeExpansion() || isActiveExpansion("tbc");
 
     // Vanilla compatibility aliases:
     // - 0x006B: can be SMSG_COMPRESSED_MOVES on some vanilla-family servers
@@ -3499,14 +1138,14 @@ void GameHandler::handlePacket(network::Packet& packet) {
                     (monsterMoveTransportWire != 0xFFFF && subOpcode == monsterMoveTransportWire)) {
                     LOG_INFO("Opcode 0x006B interpreted as SMSG_COMPRESSED_MOVES (subOpcode=0x",
                              std::hex, subOpcode, std::dec, ")");
-                    if (movementHandler_) movementHandler_->handleCompressedMoves(packet);
+                    handleCompressedMoves(packet);
                     return;
                 }
             }
         }
 
         // Expected weather payload: uint32 weatherType, float intensity, uint8 abrupt
-        if (packet.hasRemaining(9)) {
+        if (packet.getSize() - packet.getReadPos() >= 9) {
             uint32_t wType = packet.readUInt32();
             float wIntensity = packet.readFloat();
             uint8_t abrupt = packet.readUInt8();
@@ -3532,7 +1171,7 @@ void GameHandler::handlePacket(network::Packet& packet) {
         }
     } else if (allowVanillaAliases && opcode == 0x0103) {
         // Expected play-music payload: uint32 sound/music id
-        if (packet.getRemainingSize() == 4) {
+        if (packet.getSize() - packet.getReadPos() == 4) {
             uint32_t soundId = packet.readUInt32();
             LOG_INFO("SMSG_PLAY_MUSIC (0x0103 alias): soundId=", soundId);
             if (playMusicCallback_) playMusicCallback_(soundId);
@@ -3541,7 +1180,7 @@ void GameHandler::handlePacket(network::Packet& packet) {
     } else if (opcode == 0x0480) {
         // Observed on this WotLK profile immediately after CMSG_BUYBACK_ITEM.
         // Treat as vendor/buyback transaction result (7-byte payload on this core).
-        if (packet.hasRemaining(7)) {
+        if (packet.getSize() - packet.getReadPos() >= 7) {
             uint8_t opType = packet.readUInt8();
             uint8_t resultCode = packet.readUInt8();
             uint8_t slotOrCount = packet.readUInt8();
@@ -3577,8 +1216,8 @@ void GameHandler::handlePacket(network::Packet& packet) {
                 pendingBuybackWireSlot_ = 0;
 
                 // Refresh vendor list so UI state stays in sync after buyback result.
-                if (getVendorItems().vendorGuid != 0 && socket && state == WorldState::IN_WORLD) {
-                    auto pkt = ListInventoryPacket::build(getVendorItems().vendorGuid);
+                if (currentVendorItems.vendorGuid != 0 && socket && state == WorldState::IN_WORLD) {
+                    auto pkt = ListInventoryPacket::build(currentVendorItems.vendorGuid);
                     socket->send(pkt);
                 }
             } else if (pendingBuyItemId_ != 0) {
@@ -3602,7 +1241,7 @@ void GameHandler::handlePacket(network::Packet& packet) {
     } else if (opcode == 0x046A) {
         // Server-specific vendor/buyback state packet (observed 25-byte records).
         // Consume to keep stream aligned; currently not used for gameplay logic.
-        if (packet.hasRemaining(25)) {
+        if (packet.getSize() - packet.getReadPos() >= 25) {
             packet.setReadPos(packet.getReadPos() + 25);
             return;
         }
@@ -3613,8 +1252,7 @@ void GameHandler::handlePacket(network::Packet& packet) {
         ++wardenPacketsAfterGate_;
     }
     if (preLogicalOp && isAuthCharPipelineOpcode(*preLogicalOp)) {
-        LOG_WARNING("AUTH/CHAR RX opcode=0x", std::hex, opcode, std::dec,
-                 " logical=", static_cast<uint32_t>(*preLogicalOp),
+        LOG_DEBUG("AUTH/CHAR RX opcode=0x", std::hex, opcode, std::dec,
                  " state=", worldStateName(state),
                  " size=", packet.getSize());
     }
@@ -3635,38 +1273,3857 @@ void GameHandler::handlePacket(network::Packet& packet) {
         return;
     }
 
-    // Dispatch via the opcode handler table
-    auto it = dispatchTable_.find(*logicalOp);
-    if (it != dispatchTable_.end()) {
-        it->second(packet);
-    } else {
-        // In pre-world states we need full visibility (char create/login handshakes).
-        // In-world we keep de-duplication to avoid heavy log I/O in busy areas.
-        if (state != WorldState::IN_WORLD) {
-            static std::unordered_set<uint32_t> loggedUnhandledByState;
-            const uint32_t key = (static_cast<uint32_t>(static_cast<uint8_t>(state)) << 16) |
-                                 static_cast<uint32_t>(opcode);
-            if (loggedUnhandledByState.insert(key).second) {
-                LOG_WARNING("Unhandled world opcode: 0x", std::hex, opcode, std::dec,
-                            " state=", static_cast<int>(state),
-                            " size=", packet.getSize());
-                const auto& data = packet.getData();
-                std::string hex;
-                size_t limit = std::min<size_t>(data.size(), 48);
-                hex.reserve(limit * 3);
-                for (size_t i = 0; i < limit; ++i) {
-                    char b[4];
-                    snprintf(b, sizeof(b), "%02x ", data[i]);
-                    hex += b;
-                }
-                LOG_INFO("Unhandled opcode payload hex (first ", limit, " bytes): ", hex);
+    switch (*logicalOp) {
+        case Opcode::SMSG_AUTH_CHALLENGE:
+            if (state == WorldState::CONNECTED) {
+                handleAuthChallenge(packet);
+            } else {
+                LOG_WARNING("Unexpected SMSG_AUTH_CHALLENGE in state: ", worldStateName(state));
             }
-        } else {
-            static std::unordered_set<uint16_t> loggedUnhandledOpcodes;
-            if (loggedUnhandledOpcodes.insert(static_cast<uint16_t>(opcode)).second) {
-                LOG_WARNING("Unhandled world opcode: 0x", std::hex, opcode, std::dec);
+            break;
+
+        case Opcode::SMSG_AUTH_RESPONSE:
+            if (state == WorldState::AUTH_SENT) {
+                handleAuthResponse(packet);
+            } else {
+                LOG_WARNING("Unexpected SMSG_AUTH_RESPONSE in state: ", worldStateName(state));
             }
+            break;
+
+        case Opcode::SMSG_CHAR_CREATE:
+            handleCharCreateResponse(packet);
+            break;
+
+        case Opcode::SMSG_CHAR_DELETE: {
+            uint8_t result = packet.readUInt8();
+            lastCharDeleteResult_ = result;
+            bool success = (result == 0x00 || result == 0x47); // Common success codes
+            LOG_INFO("SMSG_CHAR_DELETE result: ", (int)result, success ? " (success)" : " (failed)");
+            requestCharacterList();
+            if (charDeleteCallback_) charDeleteCallback_(success);
+            break;
         }
+
+        case Opcode::SMSG_CHAR_ENUM:
+            if (state == WorldState::CHAR_LIST_REQUESTED) {
+                handleCharEnum(packet);
+            } else {
+                LOG_WARNING("Unexpected SMSG_CHAR_ENUM in state: ", worldStateName(state));
+            }
+            break;
+
+        case Opcode::SMSG_CHARACTER_LOGIN_FAILED:
+            handleCharLoginFailed(packet);
+            break;
+
+        case Opcode::SMSG_LOGIN_VERIFY_WORLD:
+            if (state == WorldState::ENTERING_WORLD || state == WorldState::IN_WORLD) {
+                handleLoginVerifyWorld(packet);
+            } else {
+                LOG_WARNING("Unexpected SMSG_LOGIN_VERIFY_WORLD in state: ", worldStateName(state));
+            }
+            break;
+
+        case Opcode::SMSG_LOGIN_SETTIMESPEED:
+            // Can be received during login or at any time after
+            handleLoginSetTimeSpeed(packet);
+            break;
+
+        case Opcode::SMSG_CLIENTCACHE_VERSION:
+            // Early pre-world packet in some realms (e.g. Warmane profile)
+            handleClientCacheVersion(packet);
+            break;
+
+        case Opcode::SMSG_TUTORIAL_FLAGS:
+            // Often sent during char-list stage (8x uint32 tutorial flags)
+            handleTutorialFlags(packet);
+            break;
+
+        case Opcode::SMSG_WARDEN_DATA:
+            handleWardenData(packet);
+            break;
+
+        case Opcode::SMSG_ACCOUNT_DATA_TIMES:
+            // Can be received at any time after authentication
+            handleAccountDataTimes(packet);
+            break;
+
+        case Opcode::SMSG_MOTD:
+            // Can be received at any time after entering world
+            handleMotd(packet);
+            break;
+
+        case Opcode::SMSG_NOTIFICATION:
+            // Vanilla/Classic server notification (single string)
+            handleNotification(packet);
+            break;
+
+        case Opcode::SMSG_PONG:
+            // Can be received at any time after entering world
+            handlePong(packet);
+            break;
+
+        case Opcode::SMSG_UPDATE_OBJECT:
+            LOG_DEBUG("Received SMSG_UPDATE_OBJECT, state=", static_cast<int>(state), " size=", packet.getSize());
+            // Can be received after entering world
+            if (state == WorldState::IN_WORLD) {
+                handleUpdateObject(packet);
+            }
+            break;
+
+        case Opcode::SMSG_COMPRESSED_UPDATE_OBJECT:
+            LOG_DEBUG("Received SMSG_COMPRESSED_UPDATE_OBJECT, state=", static_cast<int>(state), " size=", packet.getSize());
+            // Compressed version of UPDATE_OBJECT
+            if (state == WorldState::IN_WORLD) {
+                handleCompressedUpdateObject(packet);
+            }
+            break;
+        case Opcode::SMSG_DESTROY_OBJECT:
+            // Can be received after entering world
+            if (state == WorldState::IN_WORLD) {
+                handleDestroyObject(packet);
+            }
+            break;
+
+        case Opcode::SMSG_MESSAGECHAT:
+            // Can be received after entering world
+            if (state == WorldState::IN_WORLD) {
+                handleMessageChat(packet);
+            }
+            break;
+        case Opcode::SMSG_GM_MESSAGECHAT:
+            // GM → player message: same wire format as SMSG_MESSAGECHAT
+            if (state == WorldState::IN_WORLD) {
+                handleMessageChat(packet);
+            }
+            break;
+
+        case Opcode::SMSG_TEXT_EMOTE:
+            if (state == WorldState::IN_WORLD) {
+                handleTextEmote(packet);
+            }
+            break;
+        case Opcode::SMSG_EMOTE: {
+            if (state != WorldState::IN_WORLD) break;
+            // SMSG_EMOTE: uint32 emoteAnim, uint64 sourceGuid
+            if (packet.getSize() - packet.getReadPos() < 12) break;
+            uint32_t emoteAnim = packet.readUInt32();
+            uint64_t sourceGuid = packet.readUInt64();
+            if (emoteAnimCallback_ && sourceGuid != 0) {
+                emoteAnimCallback_(sourceGuid, emoteAnim);
+            }
+            break;
+        }
+
+        case Opcode::SMSG_CHANNEL_NOTIFY:
+            // Accept during ENTERING_WORLD too — server auto-joins channels before VERIFY_WORLD
+            if (state == WorldState::IN_WORLD || state == WorldState::ENTERING_WORLD) {
+                handleChannelNotify(packet);
+            }
+            break;
+        case Opcode::SMSG_CHAT_PLAYER_NOT_FOUND: {
+            // string: name of the player not found (for failed whispers)
+            std::string name = packet.readString();
+            if (!name.empty()) {
+                addSystemChatMessage("No player named '" + name + "' is currently playing.");
+            }
+            break;
+        }
+        case Opcode::SMSG_CHAT_PLAYER_AMBIGUOUS: {
+            // string: ambiguous player name (multiple matches)
+            std::string name = packet.readString();
+            if (!name.empty()) {
+                addSystemChatMessage("Player name '" + name + "' is ambiguous.");
+            }
+            break;
+        }
+        case Opcode::SMSG_CHAT_WRONG_FACTION:
+            addSystemChatMessage("You cannot send messages to members of that faction.");
+            break;
+        case Opcode::SMSG_CHAT_NOT_IN_PARTY:
+            addSystemChatMessage("You are not in a party.");
+            break;
+        case Opcode::SMSG_CHAT_RESTRICTED:
+            addSystemChatMessage("You cannot send chat messages in this area.");
+            break;
+
+        case Opcode::SMSG_QUERY_TIME_RESPONSE:
+            if (state == WorldState::IN_WORLD) {
+                handleQueryTimeResponse(packet);
+            }
+            break;
+
+        case Opcode::SMSG_PLAYED_TIME:
+            if (state == WorldState::IN_WORLD) {
+                handlePlayedTime(packet);
+            }
+            break;
+
+        case Opcode::SMSG_WHO:
+            if (state == WorldState::IN_WORLD) {
+                handleWho(packet);
+            }
+            break;
+
+        case Opcode::SMSG_FRIEND_STATUS:
+            if (state == WorldState::IN_WORLD) {
+                handleFriendStatus(packet);
+            }
+            break;
+        case Opcode::SMSG_CONTACT_LIST: {
+            // Known variants:
+            // - Full form: uint32 listMask, uint32 count, then variable-size entries.
+            // - Minimal/legacy keepalive-ish form observed on some servers: 1 byte.
+            size_t remaining = packet.getSize() - packet.getReadPos();
+            if (remaining >= 8) {
+                lastContactListMask_ = packet.readUInt32();
+                lastContactListCount_ = packet.readUInt32();
+            } else if (remaining == 1) {
+                /*uint8_t marker =*/ packet.readUInt8();
+                lastContactListMask_ = 0;
+                lastContactListCount_ = 0;
+            } else if (remaining > 0) {
+                // Unknown short variant: consume to keep stream aligned, no warning spam.
+                packet.setReadPos(packet.getSize());
+            }
+            break;
+        }
+        case Opcode::SMSG_FRIEND_LIST:
+        case Opcode::SMSG_IGNORE_LIST:
+            // Legacy social list variants; CONTACT_LIST is primary in modern flow.
+            packet.setReadPos(packet.getSize());
+            break;
+
+        case Opcode::MSG_RANDOM_ROLL:
+            if (state == WorldState::IN_WORLD) {
+                handleRandomRoll(packet);
+            }
+            break;
+        case Opcode::SMSG_ITEM_PUSH_RESULT: {
+            // Item received notification (loot, quest reward, trade, etc.)
+            // guid(8) + received(1) + created(1) + showInChat(1) + bagSlot(1) + itemSlot(4)
+            // + itemId(4) + itemSuffixFactor(4) + randomPropertyId(4) + count(4) + totalCount(4)
+            constexpr size_t kMinSize = 8 + 1 + 1 + 1 + 1 + 4 + 4 + 4 + 4 + 4 + 4;
+            if (packet.getSize() - packet.getReadPos() >= kMinSize) {
+                /*uint64_t recipientGuid =*/ packet.readUInt64();
+                /*uint8_t received =*/ packet.readUInt8();   // 0=looted/generated, 1=received from trade
+                /*uint8_t created =*/ packet.readUInt8();    // 0=stack added, 1=new item slot
+                uint8_t showInChat = packet.readUInt8();
+                /*uint8_t bagSlot =*/ packet.readUInt8();
+                /*uint32_t itemSlot =*/ packet.readUInt32();
+                uint32_t itemId = packet.readUInt32();
+                /*uint32_t suffixFactor =*/ packet.readUInt32();
+                /*int32_t randomProp =*/ static_cast<int32_t>(packet.readUInt32());
+                uint32_t count = packet.readUInt32();
+                /*uint32_t totalCount =*/ packet.readUInt32();
+
+                queryItemInfo(itemId, 0);
+                if (showInChat) {
+                    std::string itemName = "item #" + std::to_string(itemId);
+                    if (const ItemQueryResponseData* info = getItemInfo(itemId)) {
+                        if (!info->name.empty()) itemName = info->name;
+                    }
+                    std::string msg = "Received: " + itemName;
+                    if (count > 1) msg += " x" + std::to_string(count);
+                    addSystemChatMessage(msg);
+                }
+                LOG_INFO("Item push: itemId=", itemId, " count=", count,
+                         " showInChat=", static_cast<int>(showInChat));
+            }
+            break;
+        }
+
+        case Opcode::SMSG_LOGOUT_RESPONSE:
+            handleLogoutResponse(packet);
+            break;
+
+        case Opcode::SMSG_LOGOUT_COMPLETE:
+            handleLogoutComplete(packet);
+            break;
+
+        // ---- Phase 1: Foundation ----
+        case Opcode::SMSG_NAME_QUERY_RESPONSE:
+            handleNameQueryResponse(packet);
+            break;
+
+        case Opcode::SMSG_CREATURE_QUERY_RESPONSE:
+            handleCreatureQueryResponse(packet);
+            break;
+
+        case Opcode::SMSG_ITEM_QUERY_SINGLE_RESPONSE:
+            handleItemQueryResponse(packet);
+            break;
+
+        case Opcode::SMSG_INSPECT_TALENT:
+            handleInspectResults(packet);
+            break;
+        case Opcode::SMSG_ADDON_INFO:
+        case Opcode::SMSG_EXPECTED_SPAM_RECORDS:
+            // Optional system payloads that are safe to consume.
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- XP ----
+        case Opcode::SMSG_LOG_XPGAIN:
+            handleXpGain(packet);
+            break;
+        case Opcode::SMSG_EXPLORATION_EXPERIENCE: {
+            // uint32 areaId + uint32 xpGained
+            if (packet.getSize() - packet.getReadPos() >= 8) {
+                /*uint32_t areaId =*/ packet.readUInt32();
+                uint32_t xpGained = packet.readUInt32();
+                if (xpGained > 0) {
+                    char buf[128];
+                    std::snprintf(buf, sizeof(buf),
+                                  "Discovered new area! Gained %u experience.", xpGained);
+                    addSystemChatMessage(buf);
+                    // XP is updated via PLAYER_XP update fields from the server.
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_PET_TAME_FAILURE: {
+            // uint8 reason: 0=invalid_creature, 1=too_many_pets, 2=already_tamed, etc.
+            const char* reasons[] = {
+                "Invalid creature", "Too many pets", "Already tamed",
+                "Wrong faction", "Level too low", "Creature not tameable",
+                "Can't control", "Can't command"
+            };
+            if (packet.getSize() - packet.getReadPos() >= 1) {
+                uint8_t reason = packet.readUInt8();
+                const char* msg = (reason < 8) ? reasons[reason] : "Unknown reason";
+                std::string s = std::string("Failed to tame: ") + msg;
+                addSystemChatMessage(s);
+            }
+            break;
+        }
+        case Opcode::SMSG_PET_ACTION_FEEDBACK: {
+            // uint8 action + uint8 flags
+            packet.setReadPos(packet.getSize());  // Consume; no UI for pet feedback yet.
+            break;
+        }
+        case Opcode::SMSG_PET_NAME_QUERY_RESPONSE: {
+            // uint32 petNumber + string name + uint32 timestamp + bool declined
+            packet.setReadPos(packet.getSize());  // Consume; pet names shown via unit objects.
+            break;
+        }
+        case Opcode::SMSG_QUESTUPDATE_FAILED: {
+            // uint32 questId
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t questId = packet.readUInt32();
+                char buf[128];
+                std::snprintf(buf, sizeof(buf), "Quest %u failed!", questId);
+                addSystemChatMessage(buf);
+            }
+            break;
+        }
+        case Opcode::SMSG_QUESTUPDATE_FAILEDTIMER: {
+            // uint32 questId
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t questId = packet.readUInt32();
+                char buf[128];
+                std::snprintf(buf, sizeof(buf), "Quest %u timed out!", questId);
+                addSystemChatMessage(buf);
+            }
+            break;
+        }
+
+        // ---- Entity health/power delta updates ----
+        case Opcode::SMSG_HEALTH_UPDATE: {
+            // packed_guid + uint32 health
+            if (packet.getSize() - packet.getReadPos() < 2) break;
+            uint64_t guid = UpdateObjectParser::readPackedGuid(packet);
+            if (packet.getSize() - packet.getReadPos() < 4) break;
+            uint32_t hp = packet.readUInt32();
+            auto entity = entityManager.getEntity(guid);
+            if (auto* unit = dynamic_cast<Unit*>(entity.get())) {
+                unit->setHealth(hp);
+            }
+            break;
+        }
+        case Opcode::SMSG_POWER_UPDATE: {
+            // packed_guid + uint8 powerType + uint32 value
+            if (packet.getSize() - packet.getReadPos() < 2) break;
+            uint64_t guid = UpdateObjectParser::readPackedGuid(packet);
+            if (packet.getSize() - packet.getReadPos() < 5) break;
+            uint8_t  powerType = packet.readUInt8();
+            uint32_t value     = packet.readUInt32();
+            auto entity = entityManager.getEntity(guid);
+            if (auto* unit = dynamic_cast<Unit*>(entity.get())) {
+                unit->setPowerByType(powerType, value);
+            }
+            break;
+        }
+
+        // ---- World state single update ----
+        case Opcode::SMSG_UPDATE_WORLD_STATE: {
+            // uint32 field + uint32 value
+            if (packet.getSize() - packet.getReadPos() < 8) break;
+            uint32_t field = packet.readUInt32();
+            uint32_t value = packet.readUInt32();
+            worldStates_[field] = value;
+            LOG_DEBUG("SMSG_UPDATE_WORLD_STATE: field=", field, " value=", value);
+            break;
+        }
+        case Opcode::SMSG_WORLD_STATE_UI_TIMER_UPDATE: {
+            // uint32 time (server unix timestamp) — used to sync UI timers (arena, BG)
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t serverTime = packet.readUInt32();
+                LOG_DEBUG("SMSG_WORLD_STATE_UI_TIMER_UPDATE: serverTime=", serverTime);
+            }
+            break;
+        }
+        case Opcode::SMSG_PVP_CREDIT: {
+            // uint32 honorPoints + uint64 victimGuid + uint32 victimRank
+            if (packet.getSize() - packet.getReadPos() >= 16) {
+                uint32_t honor      = packet.readUInt32();
+                uint64_t victimGuid = packet.readUInt64();
+                uint32_t rank       = packet.readUInt32();
+                LOG_INFO("SMSG_PVP_CREDIT: honor=", honor, " victim=0x", std::hex, victimGuid,
+                         std::dec, " rank=", rank);
+                std::string msg = "You gain " + std::to_string(honor) + " honor points.";
+                addSystemChatMessage(msg);
+            }
+            break;
+        }
+
+        // ---- Combo points ----
+        case Opcode::SMSG_UPDATE_COMBO_POINTS: {
+            // packed_guid (target) + uint8 points
+            if (packet.getSize() - packet.getReadPos() < 2) break;
+            uint64_t target = UpdateObjectParser::readPackedGuid(packet);
+            if (packet.getSize() - packet.getReadPos() < 1) break;
+            comboPoints_ = packet.readUInt8();
+            comboTarget_ = target;
+            LOG_DEBUG("SMSG_UPDATE_COMBO_POINTS: target=0x", std::hex, target,
+                      std::dec, " points=", static_cast<int>(comboPoints_));
+            break;
+        }
+
+        // ---- Mirror timers (breath/fatigue/feign death) ----
+        case Opcode::SMSG_START_MIRROR_TIMER: {
+            // uint32 type + int32 value + int32 maxValue + int32 scale + uint32 tracker + uint8 paused
+            if (packet.getSize() - packet.getReadPos() < 21) break;
+            uint32_t type  = packet.readUInt32();
+            int32_t  value = static_cast<int32_t>(packet.readUInt32());
+            int32_t  maxV  = static_cast<int32_t>(packet.readUInt32());
+            int32_t  scale = static_cast<int32_t>(packet.readUInt32());
+            /*uint32_t tracker =*/ packet.readUInt32();
+            uint8_t  paused = packet.readUInt8();
+            if (type < 3) {
+                mirrorTimers_[type].value    = value;
+                mirrorTimers_[type].maxValue = maxV;
+                mirrorTimers_[type].scale    = scale;
+                mirrorTimers_[type].paused   = (paused != 0);
+                mirrorTimers_[type].active   = true;
+            }
+            break;
+        }
+        case Opcode::SMSG_STOP_MIRROR_TIMER: {
+            // uint32 type
+            if (packet.getSize() - packet.getReadPos() < 4) break;
+            uint32_t type = packet.readUInt32();
+            if (type < 3) {
+                mirrorTimers_[type].active = false;
+                mirrorTimers_[type].value  = 0;
+            }
+            break;
+        }
+        case Opcode::SMSG_PAUSE_MIRROR_TIMER: {
+            // uint32 type + uint8 paused
+            if (packet.getSize() - packet.getReadPos() < 5) break;
+            uint32_t type   = packet.readUInt32();
+            uint8_t  paused = packet.readUInt8();
+            if (type < 3) {
+                mirrorTimers_[type].paused = (paused != 0);
+            }
+            break;
+        }
+
+        // ---- Cast result (WotLK extended cast failed) ----
+        case Opcode::SMSG_CAST_RESULT:
+            // WotLK: uint8 castCount + uint32 spellId + uint8 result [+ optional extra]
+            // If result == 0, the spell successfully began; otherwise treat like SMSG_CAST_FAILED.
+            if (packet.getSize() - packet.getReadPos() >= 6) {
+                /*uint8_t castCount =*/ packet.readUInt8();
+                /*uint32_t spellId  =*/ packet.readUInt32();
+                uint8_t  result    = packet.readUInt8();
+                if (result != 0) {
+                    // Failure — clear cast bar and show message
+                    casting = false;
+                    currentCastSpellId = 0;
+                    castTimeRemaining  = 0.0f;
+                    const char* reason = getSpellCastResultString(result, -1);
+                    MessageChatData msg;
+                    msg.type     = ChatType::SYSTEM;
+                    msg.language = ChatLanguage::UNIVERSAL;
+                    msg.message  = reason ? reason
+                                          : ("Spell cast failed (error " + std::to_string(result) + ")");
+                    addLocalChatMessage(msg);
+                }
+            }
+            break;
+
+        // ---- Spell failed on another unit ----
+        case Opcode::SMSG_SPELL_FAILED_OTHER:
+            // packed_guid + uint8 castCount + uint32 spellId + uint8 reason — just consume
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Spell proc resist log ----
+        case Opcode::SMSG_PROCRESIST: {
+            // casterGuid(8) + victimGuid(8) + uint32 spellId + uint8 logSchoolMask
+            if (packet.getSize() - packet.getReadPos() >= 17) {
+                /*uint64_t caster =*/ packet.readUInt64();
+                uint64_t victim = packet.readUInt64();
+                uint32_t spellId = packet.readUInt32();
+                if (victim == playerGuid)
+                    addCombatText(CombatTextEntry::MISS, 0, spellId, false);
+            }
+            break;
+        }
+
+        // ---- Loot start roll (Need/Greed popup trigger) ----
+        case Opcode::SMSG_LOOT_START_ROLL: {
+            // uint64 objectGuid + uint32 mapId + uint32 lootSlot + uint32 itemId
+            // + uint32 randomSuffix + uint32 randomPropId + uint32 countdown + uint8 voteMask
+            if (packet.getSize() - packet.getReadPos() < 33) break;
+            uint64_t objectGuid = packet.readUInt64();
+            /*uint32_t mapId =*/ packet.readUInt32();
+            uint32_t slot   = packet.readUInt32();
+            uint32_t itemId = packet.readUInt32();
+            /*uint32_t randSuffix =*/ packet.readUInt32();
+            /*uint32_t randProp   =*/ packet.readUInt32();
+            /*uint32_t countdown  =*/ packet.readUInt32();
+            /*uint8_t  voteMask   =*/ packet.readUInt8();
+            // Trigger the roll popup for local player
+            pendingLootRollActive_      = true;
+            pendingLootRoll_.objectGuid = objectGuid;
+            pendingLootRoll_.slot       = slot;
+            pendingLootRoll_.itemId     = itemId;
+            auto* info = getItemInfo(itemId);
+            pendingLootRoll_.itemName    = info ? info->name : std::to_string(itemId);
+            pendingLootRoll_.itemQuality = info ? static_cast<uint8_t>(info->quality) : 0;
+            LOG_INFO("SMSG_LOOT_START_ROLL: item=", itemId, " (", pendingLootRoll_.itemName,
+                     ") slot=", slot);
+            break;
+        }
+
+        // ---- Pet stable result ----
+        case Opcode::SMSG_STABLE_RESULT: {
+            // uint8 result
+            if (packet.getSize() - packet.getReadPos() < 1) break;
+            uint8_t result = packet.readUInt8();
+            const char* msg = nullptr;
+            switch (result) {
+                case 0x01: msg = "Pet stored in stable."; break;
+                case 0x06: msg = "Pet retrieved from stable."; break;
+                case 0x07: msg = "Stable slot purchased."; break;
+                case 0x08: msg = "Stable list updated."; break;
+                case 0x09: msg = "Stable failed: not enough money or other error."; break;
+                default:   break;
+            }
+            if (msg) addSystemChatMessage(msg);
+            LOG_INFO("SMSG_STABLE_RESULT: result=", static_cast<int>(result));
+            break;
+        }
+
+        // ---- Title earned ----
+        case Opcode::SMSG_TITLE_EARNED: {
+            // uint32 titleBitIndex + uint32 isLost
+            if (packet.getSize() - packet.getReadPos() < 8) break;
+            uint32_t titleBit = packet.readUInt32();
+            uint32_t isLost   = packet.readUInt32();
+            char buf[128];
+            std::snprintf(buf, sizeof(buf),
+                          isLost ? "Title removed (ID %u)." : "Title earned (ID %u)!",
+                          titleBit);
+            addSystemChatMessage(buf);
+            LOG_INFO("SMSG_TITLE_EARNED: id=", titleBit, " lost=", isLost);
+            break;
+        }
+
+        // ---- Hearthstone binding ----
+        case Opcode::SMSG_PLAYERBOUND: {
+            // uint64 binderGuid + uint32 mapId + uint32 zoneId
+            if (packet.getSize() - packet.getReadPos() < 16) break;
+            /*uint64_t binderGuid =*/ packet.readUInt64();
+            uint32_t mapId  = packet.readUInt32();
+            uint32_t zoneId = packet.readUInt32();
+            char buf[128];
+            std::snprintf(buf, sizeof(buf),
+                          "Your home location has been set (map %u, zone %u).", mapId, zoneId);
+            addSystemChatMessage(buf);
+            break;
+        }
+        case Opcode::SMSG_BINDER_CONFIRM: {
+            // uint64 npcGuid — server confirming bind point has been set
+            addSystemChatMessage("This innkeeper is now your home location.");
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+
+        // ---- Phase shift (WotLK phasing) ----
+        case Opcode::SMSG_SET_PHASE_SHIFT: {
+            // uint32 phaseFlags [+ packed guid + uint16 count + repeated uint16 phaseIds]
+            // Just consume; phasing doesn't require action from client in WotLK
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+
+        // ---- XP gain toggle ----
+        case Opcode::SMSG_TOGGLE_XP_GAIN: {
+            // uint8 enabled
+            if (packet.getSize() - packet.getReadPos() < 1) break;
+            uint8_t enabled = packet.readUInt8();
+            addSystemChatMessage(enabled ? "XP gain enabled." : "XP gain disabled.");
+            break;
+        }
+
+        // ---- Gossip POI (quest map markers) ----
+        case Opcode::SMSG_GOSSIP_POI: {
+            // uint32 flags + float x + float y + uint32 icon + uint32 data + string name
+            if (packet.getSize() - packet.getReadPos() < 20) break;
+            /*uint32_t flags =*/ packet.readUInt32();
+            float poiX = packet.readFloat();  // WoW canonical coords
+            float poiY = packet.readFloat();
+            uint32_t icon = packet.readUInt32();
+            uint32_t data = packet.readUInt32();
+            std::string name = packet.readString();
+            GossipPoi poi;
+            poi.x    = poiX;
+            poi.y    = poiY;
+            poi.icon = icon;
+            poi.data = data;
+            poi.name = std::move(name);
+            gossipPois_.push_back(std::move(poi));
+            LOG_DEBUG("SMSG_GOSSIP_POI: x=", poiX, " y=", poiY, " icon=", icon);
+            break;
+        }
+
+        // ---- Character service results ----
+        case Opcode::SMSG_CHAR_RENAME: {
+            // uint32 result (0=success) + uint64 guid + string newName
+            if (packet.getSize() - packet.getReadPos() >= 13) {
+                uint32_t result = packet.readUInt32();
+                /*uint64_t guid =*/ packet.readUInt64();
+                std::string newName = packet.readString();
+                if (result == 0) {
+                    addSystemChatMessage("Character name changed to: " + newName);
+                } else {
+                    addSystemChatMessage("Character rename failed (error " + std::to_string(result) + ").");
+                }
+                LOG_INFO("SMSG_CHAR_RENAME: result=", result, " newName=", newName);
+            }
+            break;
+        }
+        case Opcode::SMSG_BINDZONEREPLY: {
+            // uint32 result (0=success, 1=too far)
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t result = packet.readUInt32();
+                if (result == 0) {
+                    addSystemChatMessage("Your home is now set to this location.");
+                } else {
+                    addSystemChatMessage("You are too far from the innkeeper.");
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_CHANGEPLAYER_DIFFICULTY_RESULT: {
+            // uint32 result
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t result = packet.readUInt32();
+                if (result == 0) {
+                    addSystemChatMessage("Difficulty changed.");
+                } else {
+                    static const char* reasons[] = {
+                        "", "Error", "Too many members", "Already in dungeon",
+                        "You are in a battleground", "Raid not allowed in heroic",
+                        "You must be in a raid group", "Player not in group"
+                    };
+                    const char* msg = (result < 8) ? reasons[result] : "Difficulty change failed.";
+                    addSystemChatMessage(std::string("Cannot change difficulty: ") + msg);
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_CORPSE_NOT_IN_INSTANCE:
+            addSystemChatMessage("Your corpse is outside this instance. Release spirit to retrieve it.");
+            break;
+        case Opcode::SMSG_CROSSED_INEBRIATION_THRESHOLD: {
+            // uint64 playerGuid + uint32 threshold
+            if (packet.getSize() - packet.getReadPos() >= 12) {
+                uint64_t guid = packet.readUInt64();
+                uint32_t threshold = packet.readUInt32();
+                if (guid == playerGuid && threshold > 0) {
+                    addSystemChatMessage("You feel rather drunk.");
+                }
+                LOG_DEBUG("SMSG_CROSSED_INEBRIATION_THRESHOLD: guid=0x", std::hex, guid,
+                          std::dec, " threshold=", threshold);
+            }
+            break;
+        }
+        case Opcode::SMSG_CLEAR_FAR_SIGHT_IMMEDIATE:
+            // Far sight cancelled; viewport returns to player camera
+            LOG_DEBUG("SMSG_CLEAR_FAR_SIGHT_IMMEDIATE");
+            break;
+        case Opcode::SMSG_COMBAT_EVENT_FAILED:
+            // Combat event could not be executed (e.g. invalid target for special ability)
+            packet.setReadPos(packet.getSize());
+            break;
+        case Opcode::SMSG_FORCE_ANIM: {
+            // packed_guid + uint32 animId — force entity to play animation
+            if (packet.getSize() - packet.getReadPos() >= 1) {
+                (void)UpdateObjectParser::readPackedGuid(packet);
+                if (packet.getSize() - packet.getReadPos() >= 4) {
+                    /*uint32_t animId =*/ packet.readUInt32();
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_GAMEOBJECT_DESPAWN_ANIM:
+        case Opcode::SMSG_GAMEOBJECT_RESET_STATE:
+        case Opcode::SMSG_FLIGHT_SPLINE_SYNC:
+        case Opcode::SMSG_FORCE_DISPLAY_UPDATE:
+        case Opcode::SMSG_FORCE_SEND_QUEUED_PACKETS:
+        case Opcode::SMSG_FORCE_SET_VEHICLE_REC_ID:
+        case Opcode::SMSG_CORPSE_MAP_POSITION_QUERY_RESPONSE:
+        case Opcode::SMSG_DAMAGE_CALC_LOG:
+        case Opcode::SMSG_DYNAMIC_DROP_ROLL_RESULT:
+        case Opcode::SMSG_DESTRUCTIBLE_BUILDING_DAMAGE:
+        case Opcode::SMSG_FORCED_DEATH_UPDATE:
+            // Consume — handled by broader object update or not yet implemented
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Zone defense messages ----
+        case Opcode::SMSG_DEFENSE_MESSAGE: {
+            // uint32 zoneId + string message — used for PvP zone attack alerts
+            if (packet.getSize() - packet.getReadPos() >= 5) {
+                /*uint32_t zoneId =*/ packet.readUInt32();
+                std::string defMsg = packet.readString();
+                if (!defMsg.empty()) {
+                    addSystemChatMessage("[Defense] " + defMsg);
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_CORPSE_RECLAIM_DELAY: {
+            // uint32 delayMs before player can reclaim corpse
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t delayMs = packet.readUInt32();
+                uint32_t delaySec = (delayMs + 999) / 1000;
+                addSystemChatMessage("You can reclaim your corpse in " +
+                                     std::to_string(delaySec) + " seconds.");
+                LOG_DEBUG("SMSG_CORPSE_RECLAIM_DELAY: ", delayMs, "ms");
+            }
+            break;
+        }
+        case Opcode::SMSG_DEATH_RELEASE_LOC: {
+            // uint32 mapId + float x + float y + float z — spirit healer position
+            if (packet.getSize() - packet.getReadPos() >= 16) {
+                uint32_t mapId = packet.readUInt32();
+                float x = packet.readFloat();
+                float y = packet.readFloat();
+                float z = packet.readFloat();
+                LOG_INFO("SMSG_DEATH_RELEASE_LOC: map=", mapId, " x=", x, " y=", y, " z=", z);
+            }
+            break;
+        }
+        case Opcode::SMSG_ENABLE_BARBER_SHOP:
+            // Sent by server when player sits in barber chair — triggers barber shop UI
+            // No payload; we don't have barber shop UI yet, so just log
+            LOG_INFO("SMSG_ENABLE_BARBER_SHOP: barber shop available");
+            break;
+        case Opcode::SMSG_FEIGN_DEATH_RESISTED:
+            addSystemChatMessage("Your Feign Death attempt was resisted.");
+            LOG_DEBUG("SMSG_FEIGN_DEATH_RESISTED");
+            break;
+        case Opcode::SMSG_CHANNEL_MEMBER_COUNT: {
+            // string channelName + uint8 flags + uint32 memberCount
+            std::string chanName = packet.readString();
+            if (packet.getSize() - packet.getReadPos() >= 5) {
+                /*uint8_t flags =*/ packet.readUInt8();
+                uint32_t count = packet.readUInt32();
+                LOG_DEBUG("SMSG_CHANNEL_MEMBER_COUNT: channel=", chanName, " members=", count);
+            }
+            break;
+        }
+        case Opcode::SMSG_GAMETIME_SET:
+        case Opcode::SMSG_GAMETIME_UPDATE:
+            // Server time correction: uint32 gameTimePacked (seconds since epoch)
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t gameTimePacked = packet.readUInt32();
+                gameTime_ = static_cast<float>(gameTimePacked);
+                LOG_DEBUG("Server game time update: ", gameTime_, "s");
+            }
+            packet.setReadPos(packet.getSize());
+            break;
+        case Opcode::SMSG_GAMESPEED_SET:
+            // Server speed correction: uint32 gameTimePacked + float timeSpeed
+            if (packet.getSize() - packet.getReadPos() >= 8) {
+                uint32_t gameTimePacked = packet.readUInt32();
+                float timeSpeed = packet.readFloat();
+                gameTime_ = static_cast<float>(gameTimePacked);
+                timeSpeed_ = timeSpeed;
+                LOG_DEBUG("Server game speed update: time=", gameTime_, " speed=", timeSpeed_);
+            }
+            packet.setReadPos(packet.getSize());
+            break;
+        case Opcode::SMSG_GAMETIMEBIAS_SET:
+            // Time bias — consume without processing
+            packet.setReadPos(packet.getSize());
+            break;
+        case Opcode::SMSG_ACHIEVEMENT_DELETED:
+        case Opcode::SMSG_CRITERIA_DELETED:
+            // Consume achievement/criteria removal notifications
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Combat clearing ----
+        case Opcode::SMSG_ATTACKSWING_DEADTARGET:
+            // Target died mid-swing: clear auto-attack
+            autoAttacking = false;
+            autoAttackTarget = 0;
+            break;
+        case Opcode::SMSG_THREAT_CLEAR:
+            // All threat dropped on the local player (e.g. Vanish, Feign Death)
+            // No local state to clear — informational
+            LOG_DEBUG("SMSG_THREAT_CLEAR: threat wiped");
+            break;
+        case Opcode::SMSG_THREAT_REMOVE: {
+            // packed_guid (unit) + packed_guid (victim whose threat was removed)
+            if (packet.getSize() - packet.getReadPos() >= 1) {
+                (void)UpdateObjectParser::readPackedGuid(packet);
+                if (packet.getSize() - packet.getReadPos() >= 1) {
+                    (void)UpdateObjectParser::readPackedGuid(packet);
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_HIGHEST_THREAT_UPDATE: {
+            // packed_guid (tank) + packed_guid (new highest threat unit) + uint32 count
+            // + count × (packed_guid victim + uint32 threat)
+            // Informational — no threat UI yet; consume to suppress warnings
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+
+        case Opcode::SMSG_CANCEL_COMBAT:
+            // Server-side combat state reset
+            autoAttacking = false;
+            autoAttackTarget = 0;
+            autoAttackRequested_ = false;
+            break;
+
+        case Opcode::SMSG_BREAK_TARGET:
+            // Server breaking our targeting (PvP flag, etc.)
+            // uint64 guid — consume; target cleared if it matches
+            if (packet.getSize() - packet.getReadPos() >= 8) {
+                uint64_t bGuid = packet.readUInt64();
+                if (bGuid == targetGuid) targetGuid = 0;
+            }
+            break;
+
+        case Opcode::SMSG_CLEAR_TARGET:
+            // uint64 guid — server cleared targeting on a unit (or 0 = clear all)
+            if (packet.getSize() - packet.getReadPos() >= 8) {
+                uint64_t cGuid = packet.readUInt64();
+                if (cGuid == 0 || cGuid == targetGuid) targetGuid = 0;
+            }
+            break;
+
+        // ---- Server-forced dismount ----
+        case Opcode::SMSG_DISMOUNT:
+            // No payload — server forcing dismount
+            currentMountDisplayId_ = 0;
+            if (mountCallback_) mountCallback_(0);
+            break;
+
+        case Opcode::SMSG_MOUNTRESULT: {
+            // uint32 result: 0=error, 1=invalid, 2=not in range, 3=already mounted, 4=ok
+            if (packet.getSize() - packet.getReadPos() < 4) break;
+            uint32_t result = packet.readUInt32();
+            if (result != 4) {
+                const char* msgs[] = { "Cannot mount here.", "Invalid mount spell.", "Too far away to mount.", "Already mounted." };
+                addSystemChatMessage(result < 4 ? msgs[result] : "Cannot mount.");
+            }
+            break;
+        }
+        case Opcode::SMSG_DISMOUNTRESULT: {
+            // uint32 result: 0=ok, others=error
+            if (packet.getSize() - packet.getReadPos() < 4) break;
+            uint32_t result = packet.readUInt32();
+            if (result != 0) addSystemChatMessage("Cannot dismount here.");
+            break;
+        }
+
+        // ---- Loot notifications ----
+        case Opcode::SMSG_LOOT_ALL_PASSED: {
+            // uint64 objectGuid + uint32 slot + uint32 itemId + uint32 randSuffix + uint32 randPropId
+            if (packet.getSize() - packet.getReadPos() < 24) break;
+            /*uint64_t objGuid =*/ packet.readUInt64();
+            /*uint32_t slot    =*/ packet.readUInt32();
+            uint32_t itemId  = packet.readUInt32();
+            auto* info = getItemInfo(itemId);
+            char buf[256];
+            std::snprintf(buf, sizeof(buf), "Everyone passed on [%s].",
+                          info ? info->name.c_str() : std::to_string(itemId).c_str());
+            addSystemChatMessage(buf);
+            pendingLootRollActive_ = false;
+            break;
+        }
+        case Opcode::SMSG_LOOT_ITEM_NOTIFY: {
+            // uint64 looterGuid + uint64 lootGuid + uint32 itemId + uint32 count
+            if (packet.getSize() - packet.getReadPos() < 24) {
+                packet.setReadPos(packet.getSize()); break;
+            }
+            uint64_t looterGuid = packet.readUInt64();
+            /*uint64_t lootGuid =*/ packet.readUInt64();
+            uint32_t itemId  = packet.readUInt32();
+            uint32_t count   = packet.readUInt32();
+            // Show loot message for party members (not the player — SMSG_ITEM_PUSH_RESULT covers that)
+            if (isInGroup() && looterGuid != playerGuid) {
+                auto nit = playerNameCache.find(looterGuid);
+                std::string looterName = (nit != playerNameCache.end()) ? nit->second : "";
+                if (!looterName.empty()) {
+                    queryItemInfo(itemId, 0);
+                    std::string itemName = "item #" + std::to_string(itemId);
+                    if (const ItemQueryResponseData* info = getItemInfo(itemId)) {
+                        if (!info->name.empty()) itemName = info->name;
+                    }
+                    char buf[256];
+                    if (count > 1)
+                        std::snprintf(buf, sizeof(buf), "%s loots %s x%u.", looterName.c_str(), itemName.c_str(), count);
+                    else
+                        std::snprintf(buf, sizeof(buf), "%s loots %s.", looterName.c_str(), itemName.c_str());
+                    addSystemChatMessage(buf);
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_LOOT_SLOT_CHANGED:
+            // uint64 objectGuid + uint32 slot + ... — consume
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Spell log miss ----
+        case Opcode::SMSG_SPELLLOGMISS: {
+            // packed_guid caster + packed_guid target + uint8 isCrit + uint32 count
+            // + count × (uint64 victimGuid + uint8 missInfo)
+            if (packet.getSize() - packet.getReadPos() < 2) break;
+            uint64_t casterGuid = UpdateObjectParser::readPackedGuid(packet);
+            if (packet.getSize() - packet.getReadPos() < 2) break;
+            /*uint64_t targetGuidLog =*/ UpdateObjectParser::readPackedGuid(packet);
+            if (packet.getSize() - packet.getReadPos() < 5) break;
+            /*uint8_t isCrit =*/ packet.readUInt8();
+            uint32_t count = packet.readUInt32();
+            count = std::min(count, 32u);
+            for (uint32_t i = 0; i < count && packet.getSize() - packet.getReadPos() >= 9; ++i) {
+                /*uint64_t victimGuid =*/ packet.readUInt64();
+                uint8_t missInfo = packet.readUInt8();
+                // Show combat text only for local player's spell misses
+                if (casterGuid == playerGuid) {
+                    static const CombatTextEntry::Type missTypes[] = {
+                        CombatTextEntry::MISS,    // 0=MISS
+                        CombatTextEntry::DODGE,   // 1=DODGE
+                        CombatTextEntry::PARRY,   // 2=PARRY
+                        CombatTextEntry::BLOCK,   // 3=BLOCK
+                        CombatTextEntry::MISS,    // 4=EVADE  → show as MISS
+                        CombatTextEntry::MISS,    // 5=IMMUNE → show as MISS
+                        CombatTextEntry::MISS,    // 6=DEFLECT
+                        CombatTextEntry::MISS,    // 7=ABSORB
+                        CombatTextEntry::MISS,    // 8=RESIST
+                    };
+                    CombatTextEntry::Type ct = (missInfo < 9) ? missTypes[missInfo] : CombatTextEntry::MISS;
+                    addCombatText(ct, 0, 0, true);
+                }
+            }
+            break;
+        }
+
+        // ---- Environmental damage log ----
+        case Opcode::SMSG_ENVIRONMENTALDAMAGELOG: {
+            // uint64 victimGuid + uint8 envDamageType + uint32 damage + uint32 absorb + uint32 resist
+            if (packet.getSize() - packet.getReadPos() < 21) break;
+            uint64_t victimGuid = packet.readUInt64();
+            /*uint8_t  envType =*/ packet.readUInt8();
+            uint32_t damage   = packet.readUInt32();
+            /*uint32_t absorb =*/ packet.readUInt32();
+            /*uint32_t resist =*/ packet.readUInt32();
+            if (victimGuid == playerGuid && damage > 0) {
+                addCombatText(CombatTextEntry::ENVIRONMENTAL, static_cast<int32_t>(damage), 0, false);
+            }
+            break;
+        }
+
+        // ---- Creature Movement ----
+        case Opcode::SMSG_MONSTER_MOVE:
+            handleMonsterMove(packet);
+            break;
+
+        case Opcode::SMSG_COMPRESSED_MOVES:
+            handleCompressedMoves(packet);
+            break;
+
+        case Opcode::SMSG_MONSTER_MOVE_TRANSPORT:
+            handleMonsterMoveTransport(packet);
+            break;
+        case Opcode::SMSG_SPLINE_MOVE_SET_WALK_MODE:
+        case Opcode::SMSG_SPLINE_MOVE_SET_RUN_MODE:
+        case Opcode::SMSG_SPLINE_MOVE_FEATHER_FALL:
+        case Opcode::SMSG_SPLINE_MOVE_GRAVITY_DISABLE:
+        case Opcode::SMSG_SPLINE_MOVE_GRAVITY_ENABLE:
+        case Opcode::SMSG_SPLINE_MOVE_LAND_WALK:
+        case Opcode::SMSG_SPLINE_MOVE_NORMAL_FALL:
+        case Opcode::SMSG_SPLINE_MOVE_ROOT:
+        case Opcode::SMSG_SPLINE_MOVE_SET_FLYING:
+        case Opcode::SMSG_SPLINE_MOVE_SET_HOVER:
+        case Opcode::SMSG_SPLINE_MOVE_START_SWIM:
+        case Opcode::SMSG_SPLINE_MOVE_STOP_SWIM: {
+            // Minimal parse: PackedGuid only — entity state flag change.
+            if (packet.getSize() - packet.getReadPos() >= 1) {
+                (void)UpdateObjectParser::readPackedGuid(packet);
+            }
+            break;
+        }
+        case Opcode::SMSG_SPLINE_SET_RUN_SPEED:
+        case Opcode::SMSG_SPLINE_SET_RUN_BACK_SPEED:
+        case Opcode::SMSG_SPLINE_SET_SWIM_SPEED: {
+            // Minimal parse: PackedGuid + float speed
+            if (packet.getSize() - packet.getReadPos() < 5) break;
+            uint64_t guid = UpdateObjectParser::readPackedGuid(packet);
+            if (packet.getSize() - packet.getReadPos() < 4) break;
+            float speed = packet.readFloat();
+            if (guid == playerGuid && std::isfinite(speed) && speed > 0.1f && speed < 100.0f &&
+                *logicalOp == Opcode::SMSG_SPLINE_SET_RUN_SPEED) {
+                serverRunSpeed_ = speed;
+            }
+            break;
+        }
+
+        // ---- Speed Changes ----
+        case Opcode::SMSG_FORCE_RUN_SPEED_CHANGE:
+            handleForceRunSpeedChange(packet);
+            break;
+        case Opcode::SMSG_FORCE_MOVE_ROOT:
+            handleForceMoveRootState(packet, true);
+            break;
+        case Opcode::SMSG_FORCE_MOVE_UNROOT:
+            handleForceMoveRootState(packet, false);
+            break;
+
+        // ---- Other force speed changes ----
+        case Opcode::SMSG_FORCE_WALK_SPEED_CHANGE:
+            handleForceSpeedChange(packet, "WALK_SPEED", Opcode::CMSG_FORCE_WALK_SPEED_CHANGE_ACK, &serverWalkSpeed_);
+            break;
+        case Opcode::SMSG_FORCE_RUN_BACK_SPEED_CHANGE:
+            handleForceSpeedChange(packet, "RUN_BACK_SPEED", Opcode::CMSG_FORCE_RUN_BACK_SPEED_CHANGE_ACK, &serverRunBackSpeed_);
+            break;
+        case Opcode::SMSG_FORCE_SWIM_SPEED_CHANGE:
+            handleForceSpeedChange(packet, "SWIM_SPEED", Opcode::CMSG_FORCE_SWIM_SPEED_CHANGE_ACK, &serverSwimSpeed_);
+            break;
+        case Opcode::SMSG_FORCE_SWIM_BACK_SPEED_CHANGE:
+            handleForceSpeedChange(packet, "SWIM_BACK_SPEED", Opcode::CMSG_FORCE_SWIM_BACK_SPEED_CHANGE_ACK, &serverSwimBackSpeed_);
+            break;
+        case Opcode::SMSG_FORCE_FLIGHT_SPEED_CHANGE:
+            handleForceSpeedChange(packet, "FLIGHT_SPEED", Opcode::CMSG_FORCE_FLIGHT_SPEED_CHANGE_ACK, &serverFlightSpeed_);
+            break;
+        case Opcode::SMSG_FORCE_FLIGHT_BACK_SPEED_CHANGE:
+            handleForceSpeedChange(packet, "FLIGHT_BACK_SPEED", Opcode::CMSG_FORCE_FLIGHT_BACK_SPEED_CHANGE_ACK, &serverFlightBackSpeed_);
+            break;
+        case Opcode::SMSG_FORCE_TURN_RATE_CHANGE:
+            handleForceSpeedChange(packet, "TURN_RATE", Opcode::CMSG_FORCE_TURN_RATE_CHANGE_ACK, &serverTurnRate_);
+            break;
+        case Opcode::SMSG_FORCE_PITCH_RATE_CHANGE:
+            handleForceSpeedChange(packet, "PITCH_RATE", Opcode::CMSG_FORCE_PITCH_RATE_CHANGE_ACK, &serverPitchRate_);
+            break;
+
+        // ---- Movement flag toggle ACKs ----
+        case Opcode::SMSG_MOVE_SET_CAN_FLY:
+            handleForceMoveFlagChange(packet, "SET_CAN_FLY", Opcode::CMSG_MOVE_SET_CAN_FLY_ACK,
+                static_cast<uint32_t>(MovementFlags::CAN_FLY), true);
+            break;
+        case Opcode::SMSG_MOVE_UNSET_CAN_FLY:
+            handleForceMoveFlagChange(packet, "UNSET_CAN_FLY", Opcode::CMSG_MOVE_SET_CAN_FLY_ACK,
+                static_cast<uint32_t>(MovementFlags::CAN_FLY), false);
+            break;
+        case Opcode::SMSG_MOVE_FEATHER_FALL:
+            handleForceMoveFlagChange(packet, "FEATHER_FALL", Opcode::CMSG_MOVE_FEATHER_FALL_ACK, 0, true);
+            break;
+        case Opcode::SMSG_MOVE_WATER_WALK:
+            handleForceMoveFlagChange(packet, "WATER_WALK", Opcode::CMSG_MOVE_WATER_WALK_ACK, 0, true);
+            break;
+        case Opcode::SMSG_MOVE_SET_HOVER:
+            handleForceMoveFlagChange(packet, "SET_HOVER", Opcode::CMSG_MOVE_HOVER_ACK,
+                static_cast<uint32_t>(MovementFlags::HOVER), true);
+            break;
+        case Opcode::SMSG_MOVE_UNSET_HOVER:
+            handleForceMoveFlagChange(packet, "UNSET_HOVER", Opcode::CMSG_MOVE_HOVER_ACK,
+                static_cast<uint32_t>(MovementFlags::HOVER), false);
+            break;
+
+        // ---- Knockback ----
+        case Opcode::SMSG_MOVE_KNOCK_BACK:
+            handleMoveKnockBack(packet);
+            break;
+
+        case Opcode::SMSG_CLIENT_CONTROL_UPDATE: {
+            // Minimal parse: PackedGuid + uint8 allowMovement.
+            if (packet.getSize() - packet.getReadPos() < 2) {
+                LOG_WARNING("SMSG_CLIENT_CONTROL_UPDATE too short: ", packet.getSize(), " bytes");
+                break;
+            }
+            uint8_t guidMask = packet.readUInt8();
+            size_t guidBytes = 0;
+            uint64_t controlGuid = 0;
+            for (int i = 0; i < 8; ++i) {
+                if (guidMask & (1u << i)) ++guidBytes;
+            }
+            if (packet.getSize() - packet.getReadPos() < guidBytes + 1) {
+                LOG_WARNING("SMSG_CLIENT_CONTROL_UPDATE malformed (truncated packed guid)");
+                packet.setReadPos(packet.getSize());
+                break;
+            }
+            for (int i = 0; i < 8; ++i) {
+                if (guidMask & (1u << i)) {
+                    uint8_t b = packet.readUInt8();
+                    controlGuid |= (static_cast<uint64_t>(b) << (i * 8));
+                }
+            }
+            bool allowMovement = (packet.readUInt8() != 0);
+            if (controlGuid == 0 || controlGuid == playerGuid) {
+                bool changed = (serverMovementAllowed_ != allowMovement);
+                serverMovementAllowed_ = allowMovement;
+                if (changed && !allowMovement) {
+                    // Force-stop local movement immediately when server revokes control.
+                    movementInfo.flags &= ~(static_cast<uint32_t>(MovementFlags::FORWARD) |
+                                            static_cast<uint32_t>(MovementFlags::BACKWARD) |
+                                            static_cast<uint32_t>(MovementFlags::STRAFE_LEFT) |
+                                            static_cast<uint32_t>(MovementFlags::STRAFE_RIGHT) |
+                                            static_cast<uint32_t>(MovementFlags::TURN_LEFT) |
+                                            static_cast<uint32_t>(MovementFlags::TURN_RIGHT));
+                    sendMovement(Opcode::MSG_MOVE_STOP);
+                    sendMovement(Opcode::MSG_MOVE_STOP_STRAFE);
+                    sendMovement(Opcode::MSG_MOVE_STOP_TURN);
+                    sendMovement(Opcode::MSG_MOVE_STOP_SWIM);
+                    addSystemChatMessage("Movement disabled by server.");
+                } else if (changed && allowMovement) {
+                    addSystemChatMessage("Movement re-enabled.");
+                }
+            }
+            break;
+        }
+
+        // ---- Phase 2: Combat ----
+        case Opcode::SMSG_ATTACKSTART:
+            handleAttackStart(packet);
+            break;
+        case Opcode::SMSG_ATTACKSTOP:
+            handleAttackStop(packet);
+            break;
+        case Opcode::SMSG_ATTACKSWING_NOTINRANGE:
+            autoAttackOutOfRange_ = true;
+            if (autoAttackRangeWarnCooldown_ <= 0.0f) {
+                addSystemChatMessage("Target is too far away.");
+                autoAttackRangeWarnCooldown_ = 1.25f;
+            }
+            if (autoAttackRequested_ && autoAttackTarget != 0 && socket) {
+                // Avoid blind immediate resend loops when target is clearly out of melee range.
+                bool likelyInRange = true;
+                if (auto target = entityManager.getEntity(autoAttackTarget)) {
+                    float dx = movementInfo.x - target->getLatestX();
+                    float dy = movementInfo.y - target->getLatestY();
+                    float dz = movementInfo.z - target->getLatestZ();
+                    float dist3d = std::sqrt(dx * dx + dy * dy + dz * dz);
+                    likelyInRange = (dist3d <= 7.5f);
+                }
+                if (likelyInRange) {
+                    auto pkt = AttackSwingPacket::build(autoAttackTarget);
+                    socket->send(pkt);
+                }
+            }
+            break;
+        case Opcode::SMSG_ATTACKSWING_BADFACING:
+            if (autoAttackRequested_ && autoAttackTarget != 0) {
+                auto targetEntity = entityManager.getEntity(autoAttackTarget);
+                if (targetEntity) {
+                    float toTargetX = targetEntity->getX() - movementInfo.x;
+                    float toTargetY = targetEntity->getY() - movementInfo.y;
+                    if (std::abs(toTargetX) > 0.01f || std::abs(toTargetY) > 0.01f) {
+                        movementInfo.orientation = std::atan2(-toTargetY, toTargetX);
+                        sendMovement(Opcode::MSG_MOVE_SET_FACING);
+                        sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
+                    }
+                }
+                if (socket) {
+                    auto pkt = AttackSwingPacket::build(autoAttackTarget);
+                    socket->send(pkt);
+                }
+            }
+            break;
+        case Opcode::SMSG_ATTACKSWING_NOTSTANDING:
+        case Opcode::SMSG_ATTACKSWING_CANT_ATTACK:
+            autoAttackOutOfRange_ = false;
+            autoAttackOutOfRangeTime_ = 0.0f;
+            break;
+        case Opcode::SMSG_ATTACKERSTATEUPDATE:
+            handleAttackerStateUpdate(packet);
+            break;
+        case Opcode::SMSG_AI_REACTION: {
+            // SMSG_AI_REACTION: uint64 guid, uint32 reaction
+            if (packet.getSize() - packet.getReadPos() < 12) break;
+            uint64_t guid = packet.readUInt64();
+            uint32_t reaction = packet.readUInt32();
+            // Reaction 2 commonly indicates aggro.
+            if (reaction == 2 && npcAggroCallback_) {
+                auto entity = entityManager.getEntity(guid);
+                if (entity) {
+                    npcAggroCallback_(guid, glm::vec3(entity->getX(), entity->getY(), entity->getZ()));
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_SPELLNONMELEEDAMAGELOG:
+            handleSpellDamageLog(packet);
+            break;
+        case Opcode::SMSG_PLAY_SPELL_VISUAL: {
+            // Minimal parse: uint64 casterGuid, uint32 visualId
+            if (packet.getSize() - packet.getReadPos() < 12) break;
+            packet.readUInt64();
+            packet.readUInt32();
+            break;
+        }
+        case Opcode::SMSG_SPELLHEALLOG:
+            handleSpellHealLog(packet);
+            break;
+
+        // ---- Phase 3: Spells ----
+        case Opcode::SMSG_INITIAL_SPELLS:
+            handleInitialSpells(packet);
+            break;
+        case Opcode::SMSG_CAST_FAILED:
+            handleCastFailed(packet);
+            break;
+        case Opcode::SMSG_SPELL_START:
+            handleSpellStart(packet);
+            break;
+        case Opcode::SMSG_SPELL_GO:
+            handleSpellGo(packet);
+            break;
+        case Opcode::SMSG_SPELL_FAILURE:
+            // Spell failed mid-cast
+            casting = false;
+            currentCastSpellId = 0;
+            break;
+        case Opcode::SMSG_SPELL_COOLDOWN:
+            handleSpellCooldown(packet);
+            break;
+        case Opcode::SMSG_COOLDOWN_EVENT:
+            handleCooldownEvent(packet);
+            break;
+        case Opcode::SMSG_CLEAR_COOLDOWN: {
+            // spellId(u32) + guid(u64): clear cooldown for the given spell/guid
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t spellId = packet.readUInt32();
+                // guid is present but we only track per-spell for the local player
+                spellCooldowns.erase(spellId);
+                for (auto& slot : actionBar) {
+                    if (slot.type == ActionBarSlot::SPELL && slot.id == spellId) {
+                        slot.cooldownRemaining = 0.0f;
+                    }
+                }
+                LOG_DEBUG("SMSG_CLEAR_COOLDOWN: spellId=", spellId);
+            }
+            break;
+        }
+        case Opcode::SMSG_MODIFY_COOLDOWN: {
+            // spellId(u32) + diffMs(i32): adjust cooldown remaining by diffMs
+            if (packet.getSize() - packet.getReadPos() >= 8) {
+                uint32_t spellId = packet.readUInt32();
+                int32_t  diffMs  = static_cast<int32_t>(packet.readUInt32());
+                float diffSec = diffMs / 1000.0f;
+                auto it = spellCooldowns.find(spellId);
+                if (it != spellCooldowns.end()) {
+                    it->second = std::max(0.0f, it->second + diffSec);
+                    for (auto& slot : actionBar) {
+                        if (slot.type == ActionBarSlot::SPELL && slot.id == spellId) {
+                            slot.cooldownRemaining = std::max(0.0f, slot.cooldownRemaining + diffSec);
+                        }
+                    }
+                }
+                LOG_DEBUG("SMSG_MODIFY_COOLDOWN: spellId=", spellId, " diff=", diffMs, "ms");
+            }
+            break;
+        }
+        case Opcode::SMSG_ACHIEVEMENT_EARNED:
+            handleAchievementEarned(packet);
+            break;
+        case Opcode::SMSG_ALL_ACHIEVEMENT_DATA:
+            // Initial data burst on login — ignored for now (no achievement tracker UI).
+            break;
+        case Opcode::SMSG_ITEM_COOLDOWN: {
+            // uint64 itemGuid + uint32 spellId + uint32 cooldownMs
+            size_t rem = packet.getSize() - packet.getReadPos();
+            if (rem >= 16) {
+                /*uint64_t itemGuid =*/ packet.readUInt64();
+                uint32_t spellId    = packet.readUInt32();
+                uint32_t cdMs       = packet.readUInt32();
+                float cdSec = cdMs / 1000.0f;
+                if (spellId != 0 && cdSec > 0.0f) {
+                    spellCooldowns[spellId] = cdSec;
+                    for (auto& slot : actionBar) {
+                        if (slot.type == ActionBarSlot::SPELL && slot.id == spellId) {
+                            slot.cooldownRemaining = cdSec;
+                        }
+                    }
+                    LOG_DEBUG("SMSG_ITEM_COOLDOWN: spellId=", spellId, " cd=", cdSec, "s");
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_FISH_NOT_HOOKED:
+            addSystemChatMessage("Your fish got away.");
+            break;
+        case Opcode::SMSG_FISH_ESCAPED:
+            addSystemChatMessage("Your fish escaped!");
+            break;
+        case Opcode::MSG_MINIMAP_PING:
+            // Minimap ping from a party member — consume; no visual support yet.
+            packet.setReadPos(packet.getSize());
+            break;
+        case Opcode::SMSG_ZONE_UNDER_ATTACK: {
+            // uint32 areaId
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t areaId = packet.readUInt32();
+                char buf[128];
+                std::snprintf(buf, sizeof(buf),
+                              "A zone is under attack! (area %u)", areaId);
+                addSystemChatMessage(buf);
+            }
+            break;
+        }
+        case Opcode::SMSG_CANCEL_AUTO_REPEAT:
+            break; // Server signals to stop a repeating spell (wand/shoot); no client action needed
+        case Opcode::SMSG_AURA_UPDATE:
+            handleAuraUpdate(packet, false);
+            break;
+        case Opcode::SMSG_AURA_UPDATE_ALL:
+            handleAuraUpdate(packet, true);
+            break;
+        case Opcode::SMSG_DISPEL_FAILED: {
+            // casterGuid(8) + victimGuid(8) + spellId(4) [+ failing spellId(4)...]
+            if (packet.getSize() - packet.getReadPos() >= 20) {
+                /*uint64_t casterGuid =*/ packet.readUInt64();
+                /*uint64_t victimGuid =*/ packet.readUInt64();
+                uint32_t spellId = packet.readUInt32();
+                char buf[128];
+                std::snprintf(buf, sizeof(buf), "Dispel failed! (spell %u)", spellId);
+                addSystemChatMessage(buf);
+            }
+            break;
+        }
+        case Opcode::SMSG_TOTEM_CREATED: {
+            // uint8 slot + uint64 guid + uint32 duration + uint32 spellId
+            if (packet.getSize() - packet.getReadPos() >= 17) {
+                uint8_t  slot     = packet.readUInt8();
+                /*uint64_t guid =*/ packet.readUInt64();
+                uint32_t duration = packet.readUInt32();
+                uint32_t spellId  = packet.readUInt32();
+                LOG_DEBUG("SMSG_TOTEM_CREATED: slot=", (int)slot,
+                          " spellId=", spellId, " duration=", duration, "ms");
+            }
+            break;
+        }
+        case Opcode::SMSG_AREA_SPIRIT_HEALER_TIME: {
+            // uint64 guid + uint32 timeLeftMs
+            if (packet.getSize() - packet.getReadPos() >= 12) {
+                /*uint64_t guid =*/ packet.readUInt64();
+                uint32_t timeMs = packet.readUInt32();
+                uint32_t secs   = timeMs / 1000;
+                char buf[128];
+                std::snprintf(buf, sizeof(buf),
+                              "You will be able to resurrect in %u seconds.", secs);
+                addSystemChatMessage(buf);
+            }
+            break;
+        }
+        case Opcode::SMSG_DURABILITY_DAMAGE_DEATH: {
+            // uint32 percent (how much durability was lost due to death)
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                /*uint32_t pct =*/ packet.readUInt32();
+                addSystemChatMessage("You have lost 10% of your gear's durability due to death.");
+            }
+            break;
+        }
+        case Opcode::SMSG_LEARNED_SPELL:
+            handleLearnedSpell(packet);
+            break;
+        case Opcode::SMSG_SUPERCEDED_SPELL:
+            handleSupercededSpell(packet);
+            break;
+        case Opcode::SMSG_REMOVED_SPELL:
+            handleRemovedSpell(packet);
+            break;
+        case Opcode::SMSG_SEND_UNLEARN_SPELLS:
+            handleUnlearnSpells(packet);
+            break;
+
+        // ---- Talents ----
+        case Opcode::SMSG_TALENTS_INFO:
+            handleTalentsInfo(packet);
+            break;
+
+        // ---- Phase 4: Group ----
+        case Opcode::SMSG_GROUP_INVITE:
+            handleGroupInvite(packet);
+            break;
+        case Opcode::SMSG_GROUP_DECLINE:
+            handleGroupDecline(packet);
+            break;
+        case Opcode::SMSG_GROUP_LIST:
+            handleGroupList(packet);
+            break;
+        case Opcode::SMSG_GROUP_DESTROYED:
+            // The group was disbanded; clear all party state.
+            partyData.members.clear();
+            partyData.memberCount = 0;
+            partyData.leaderGuid = 0;
+            addSystemChatMessage("Your party has been disbanded.");
+            LOG_INFO("SMSG_GROUP_DESTROYED: party cleared");
+            break;
+        case Opcode::SMSG_GROUP_CANCEL:
+            // Group invite was cancelled before being accepted.
+            addSystemChatMessage("Group invite cancelled.");
+            LOG_DEBUG("SMSG_GROUP_CANCEL");
+            break;
+        case Opcode::SMSG_GROUP_UNINVITE:
+            handleGroupUninvite(packet);
+            break;
+        case Opcode::SMSG_PARTY_COMMAND_RESULT:
+            handlePartyCommandResult(packet);
+            break;
+        case Opcode::SMSG_PARTY_MEMBER_STATS:
+            handlePartyMemberStats(packet, false);
+            break;
+        case Opcode::SMSG_PARTY_MEMBER_STATS_FULL:
+            handlePartyMemberStats(packet, true);
+            break;
+        case Opcode::MSG_RAID_READY_CHECK: {
+            // Server is broadcasting a ready check (someone in the raid initiated it).
+            // Payload: empty body, or optional uint64 initiator GUID in some builds.
+            pendingReadyCheck_ = true;
+            readyCheckInitiator_.clear();
+            if (packet.getSize() - packet.getReadPos() >= 8) {
+                uint64_t initiatorGuid = packet.readUInt64();
+                auto entity = entityManager.getEntity(initiatorGuid);
+                if (auto* unit = dynamic_cast<Unit*>(entity.get())) {
+                    readyCheckInitiator_ = unit->getName();
+                }
+            }
+            if (readyCheckInitiator_.empty() && partyData.leaderGuid != 0) {
+                // Identify initiator from party leader
+                for (const auto& member : partyData.members) {
+                    if (member.guid == partyData.leaderGuid) { readyCheckInitiator_ = member.name; break; }
+                }
+            }
+            addSystemChatMessage(readyCheckInitiator_.empty()
+                ? "Ready check initiated!"
+                : readyCheckInitiator_ + " initiated a ready check!");
+            LOG_INFO("MSG_RAID_READY_CHECK: initiator=", readyCheckInitiator_);
+            break;
+        }
+        case Opcode::MSG_RAID_READY_CHECK_CONFIRM:
+            // Another member responded to the ready check — consume.
+            packet.setReadPos(packet.getSize());
+            break;
+        case Opcode::SMSG_RAID_INSTANCE_INFO:
+            handleRaidInstanceInfo(packet);
+            break;
+        case Opcode::SMSG_DUEL_REQUESTED:
+            handleDuelRequested(packet);
+            break;
+        case Opcode::SMSG_DUEL_COMPLETE:
+            handleDuelComplete(packet);
+            break;
+        case Opcode::SMSG_DUEL_WINNER:
+            handleDuelWinner(packet);
+            break;
+        case Opcode::SMSG_DUEL_OUTOFBOUNDS:
+            addSystemChatMessage("You are out of the duel area!");
+            break;
+        case Opcode::SMSG_DUEL_INBOUNDS:
+            // Re-entered the duel area; no special action needed.
+            break;
+        case Opcode::SMSG_DUEL_COUNTDOWN:
+            // Countdown timer — no action needed; server also sends UNIT_FIELD_FLAGS update.
+            break;
+        case Opcode::SMSG_PARTYKILLLOG: {
+            // uint64 killerGuid + uint64 victimGuid
+            if (packet.getSize() - packet.getReadPos() < 16) break;
+            uint64_t killerGuid = packet.readUInt64();
+            uint64_t victimGuid = packet.readUInt64();
+            // Show kill message in party chat style
+            auto nameForGuid = [&](uint64_t g) -> std::string {
+                // Check player name cache first
+                auto nit = playerNameCache.find(g);
+                if (nit != playerNameCache.end()) return nit->second;
+                // Fall back to entity name (NPCs)
+                auto ent = entityManager.getEntity(g);
+                if (ent && (ent->getType() == game::ObjectType::UNIT ||
+                            ent->getType() == game::ObjectType::PLAYER)) {
+                    auto unit = std::static_pointer_cast<game::Unit>(ent);
+                    return unit->getName();
+                }
+                return {};
+            };
+            std::string killerName = nameForGuid(killerGuid);
+            std::string victimName = nameForGuid(victimGuid);
+            if (!killerName.empty() && !victimName.empty()) {
+                char buf[256];
+                std::snprintf(buf, sizeof(buf), "%s killed %s.",
+                              killerName.c_str(), victimName.c_str());
+                addSystemChatMessage(buf);
+            }
+            break;
+        }
+
+        // ---- Guild ----
+        case Opcode::SMSG_GUILD_INFO:
+            handleGuildInfo(packet);
+            break;
+        case Opcode::SMSG_GUILD_ROSTER:
+            handleGuildRoster(packet);
+            break;
+        case Opcode::SMSG_GUILD_QUERY_RESPONSE:
+            handleGuildQueryResponse(packet);
+            break;
+        case Opcode::SMSG_GUILD_EVENT:
+            handleGuildEvent(packet);
+            break;
+        case Opcode::SMSG_GUILD_INVITE:
+            handleGuildInvite(packet);
+            break;
+        case Opcode::SMSG_GUILD_COMMAND_RESULT:
+            handleGuildCommandResult(packet);
+            break;
+        case Opcode::SMSG_PET_SPELLS:
+            handlePetSpells(packet);
+            break;
+        case Opcode::SMSG_PETITION_SHOWLIST:
+            handlePetitionShowlist(packet);
+            break;
+        case Opcode::SMSG_TURN_IN_PETITION_RESULTS:
+            handleTurnInPetitionResults(packet);
+            break;
+
+        // ---- Phase 5: Loot/Gossip/Vendor ----
+        case Opcode::SMSG_LOOT_RESPONSE:
+            handleLootResponse(packet);
+            break;
+        case Opcode::SMSG_LOOT_RELEASE_RESPONSE:
+            handleLootReleaseResponse(packet);
+            break;
+        case Opcode::SMSG_LOOT_REMOVED:
+            handleLootRemoved(packet);
+            break;
+        case Opcode::SMSG_QUEST_CONFIRM_ACCEPT:
+            handleQuestConfirmAccept(packet);
+            break;
+        case Opcode::SMSG_ITEM_TEXT_QUERY_RESPONSE:
+            handleItemTextQueryResponse(packet);
+            break;
+        case Opcode::SMSG_SUMMON_REQUEST:
+            handleSummonRequest(packet);
+            break;
+        case Opcode::SMSG_SUMMON_CANCEL:
+            pendingSummonRequest_ = false;
+            addSystemChatMessage("Summon cancelled.");
+            break;
+        case Opcode::SMSG_TRADE_STATUS:
+        case Opcode::SMSG_TRADE_STATUS_EXTENDED:
+            handleTradeStatus(packet);
+            break;
+        case Opcode::SMSG_LOOT_ROLL:
+            handleLootRoll(packet);
+            break;
+        case Opcode::SMSG_LOOT_ROLL_WON:
+            handleLootRollWon(packet);
+            break;
+        case Opcode::SMSG_LOOT_MASTER_LIST:
+            // Master looter list — no UI yet; consume to avoid unhandled warning.
+            packet.setReadPos(packet.getSize());
+            break;
+        case Opcode::SMSG_GOSSIP_MESSAGE:
+            handleGossipMessage(packet);
+            break;
+        case Opcode::SMSG_QUESTGIVER_QUEST_LIST:
+            handleQuestgiverQuestList(packet);
+            break;
+        case Opcode::SMSG_BINDPOINTUPDATE: {
+            BindPointUpdateData data;
+            if (BindPointUpdateParser::parse(packet, data)) {
+                LOG_INFO("Bindpoint updated: mapId=", data.mapId,
+                         " pos=(", data.x, ", ", data.y, ", ", data.z, ")");
+                glm::vec3 canonical = core::coords::serverToCanonical(
+                    glm::vec3(data.x, data.y, data.z));
+                // Only show message if bind point was already set (not initial login sync)
+                bool wasSet = hasHomeBind_;
+                hasHomeBind_ = true;
+                homeBindMapId_ = data.mapId;
+                homeBindPos_ = canonical;
+                if (bindPointCallback_) {
+                    bindPointCallback_(data.mapId, canonical.x, canonical.y, canonical.z);
+                }
+                if (wasSet) {
+                    addSystemChatMessage("Your home has been set.");
+                }
+            } else {
+                LOG_WARNING("Failed to parse SMSG_BINDPOINTUPDATE");
+            }
+            break;
+        }
+        case Opcode::SMSG_GOSSIP_COMPLETE:
+            handleGossipComplete(packet);
+            break;
+        case Opcode::SMSG_SPIRIT_HEALER_CONFIRM: {
+            if (packet.getSize() - packet.getReadPos() < 8) {
+                LOG_WARNING("SMSG_SPIRIT_HEALER_CONFIRM too short");
+                break;
+            }
+            uint64_t npcGuid = packet.readUInt64();
+            LOG_INFO("Spirit healer confirm from 0x", std::hex, npcGuid, std::dec);
+            if (npcGuid) {
+                resurrectCasterGuid_ = npcGuid;
+                resurrectRequestPending_ = true;
+            }
+            break;
+        }
+        case Opcode::SMSG_RESURRECT_REQUEST: {
+            if (packet.getSize() - packet.getReadPos() < 8) {
+                LOG_WARNING("SMSG_RESURRECT_REQUEST too short");
+                break;
+            }
+            uint64_t casterGuid = packet.readUInt64();
+            LOG_INFO("Resurrect request from 0x", std::hex, casterGuid, std::dec);
+            if (casterGuid) {
+                resurrectCasterGuid_ = casterGuid;
+                resurrectRequestPending_ = true;
+            }
+            break;
+        }
+        case Opcode::SMSG_TIME_SYNC_REQ: {
+            if (packet.getSize() - packet.getReadPos() < 4) {
+                LOG_WARNING("SMSG_TIME_SYNC_REQ too short");
+                break;
+            }
+            uint32_t counter = packet.readUInt32();
+            LOG_DEBUG("Time sync request counter: ", counter);
+            if (socket) {
+                network::Packet resp(wireOpcode(Opcode::CMSG_TIME_SYNC_RESP));
+                resp.writeUInt32(counter);
+                resp.writeUInt32(nextMovementTimestampMs());
+                socket->send(resp);
+            }
+            break;
+        }
+        case Opcode::SMSG_LIST_INVENTORY:
+            handleListInventory(packet);
+            break;
+        case Opcode::SMSG_TRAINER_LIST:
+            handleTrainerList(packet);
+            break;
+        case Opcode::SMSG_TRAINER_BUY_SUCCEEDED: {
+            uint64_t guid = packet.readUInt64();
+            uint32_t spellId = packet.readUInt32();
+            (void)guid;
+
+            // Add to known spells immediately for prerequisite re-evaluation
+            // (SMSG_LEARNED_SPELL may come separately, but we need immediate update)
+            if (!knownSpells.count(spellId)) {
+                knownSpells.insert(spellId);
+                LOG_INFO("Added spell ", spellId, " to known spells (trainer purchase)");
+            }
+
+            const std::string& name = getSpellName(spellId);
+            if (!name.empty())
+                addSystemChatMessage("You have learned " + name + ".");
+            else
+                addSystemChatMessage("Spell learned.");
+            break;
+        }
+        case Opcode::SMSG_TRAINER_BUY_FAILED: {
+            // Server rejected the spell purchase
+            // Packet format: uint64 trainerGuid, uint32 spellId, uint32 errorCode
+            uint64_t trainerGuid = packet.readUInt64();
+            uint32_t spellId = packet.readUInt32();
+            uint32_t errorCode = 0;
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                errorCode = packet.readUInt32();
+            }
+            LOG_WARNING("Trainer buy spell failed: guid=", trainerGuid,
+                       " spellId=", spellId, " error=", errorCode);
+
+            const std::string& spellName = getSpellName(spellId);
+            std::string msg = "Cannot learn ";
+            if (!spellName.empty()) msg += spellName;
+            else msg += "spell #" + std::to_string(spellId);
+
+            // Common error reasons
+            if (errorCode == 0) msg += " (not enough money)";
+            else if (errorCode == 1) msg += " (not enough skill)";
+            else if (errorCode == 2) msg += " (already known)";
+            else if (errorCode != 0) msg += " (error " + std::to_string(errorCode) + ")";
+
+            addSystemChatMessage(msg);
+            break;
+        }
+
+        // Silently ignore common packets we don't handle yet
+        case Opcode::SMSG_INIT_WORLD_STATES: {
+            // Minimal parse: uint32 mapId, uint32 zoneId, uint16 count, repeated (uint32 key, uint32 val)
+            if (packet.getSize() - packet.getReadPos() < 10) {
+                LOG_WARNING("SMSG_INIT_WORLD_STATES too short: ", packet.getSize(), " bytes");
+                break;
+            }
+            worldStateMapId_ = packet.readUInt32();
+            worldStateZoneId_ = packet.readUInt32();
+            uint16_t count = packet.readUInt16();
+            size_t needed = static_cast<size_t>(count) * 8;
+            size_t available = packet.getSize() - packet.getReadPos();
+            if (available < needed) {
+                // Be tolerant across expansion/private-core variants: if packet shape
+                // still looks like N*(key,val) dwords, parse what is present.
+                if ((available % 8) == 0) {
+                    uint16_t adjustedCount = static_cast<uint16_t>(available / 8);
+                    LOG_WARNING("SMSG_INIT_WORLD_STATES count mismatch: header=", count,
+                                " adjusted=", adjustedCount, " (available=", available, ")");
+                    count = adjustedCount;
+                    needed = available;
+                } else {
+                    LOG_WARNING("SMSG_INIT_WORLD_STATES truncated: expected ", needed,
+                                " bytes of state pairs, got ", available);
+                    packet.setReadPos(packet.getSize());
+                    break;
+                }
+            }
+            worldStates_.clear();
+            worldStates_.reserve(count);
+            for (uint16_t i = 0; i < count; ++i) {
+                uint32_t key = packet.readUInt32();
+                uint32_t val = packet.readUInt32();
+                worldStates_[key] = val;
+            }
+            break;
+        }
+        case Opcode::SMSG_INITIALIZE_FACTIONS: {
+            // Minimal parse: uint32 count, repeated (uint8 flags, int32 standing)
+            if (packet.getSize() - packet.getReadPos() < 4) {
+                LOG_WARNING("SMSG_INITIALIZE_FACTIONS too short: ", packet.getSize(), " bytes");
+                break;
+            }
+            uint32_t count = packet.readUInt32();
+            size_t needed = static_cast<size_t>(count) * 5;
+            if (packet.getSize() - packet.getReadPos() < needed) {
+                LOG_WARNING("SMSG_INITIALIZE_FACTIONS truncated: expected ", needed,
+                            " bytes of faction data, got ", packet.getSize() - packet.getReadPos());
+                packet.setReadPos(packet.getSize());
+                break;
+            }
+            initialFactions_.clear();
+            initialFactions_.reserve(count);
+            for (uint32_t i = 0; i < count; ++i) {
+                FactionStandingInit fs{};
+                fs.flags = packet.readUInt8();
+                fs.standing = static_cast<int32_t>(packet.readUInt32());
+                initialFactions_.push_back(fs);
+            }
+            break;
+        }
+        case Opcode::SMSG_SET_FACTION_STANDING: {
+            // uint8 showVisualEffect + uint32 count + count × (uint32 factionId + int32 standing)
+            if (packet.getSize() - packet.getReadPos() < 5) break;
+            /*uint8_t showVisual =*/ packet.readUInt8();
+            uint32_t count = packet.readUInt32();
+            count = std::min(count, 128u);
+            loadFactionNameCache();
+            for (uint32_t i = 0; i < count && packet.getSize() - packet.getReadPos() >= 8; ++i) {
+                uint32_t factionId = packet.readUInt32();
+                int32_t  standing  = static_cast<int32_t>(packet.readUInt32());
+                int32_t  oldStanding = 0;
+                auto it = factionStandings_.find(factionId);
+                if (it != factionStandings_.end()) oldStanding = it->second;
+                factionStandings_[factionId] = standing;
+                int32_t delta = standing - oldStanding;
+                if (delta != 0) {
+                    std::string name = getFactionName(factionId);
+                    char buf[256];
+                    std::snprintf(buf, sizeof(buf), "Reputation with %s %s by %d.",
+                                  name.c_str(),
+                                  delta > 0 ? "increased" : "decreased",
+                                  std::abs(delta));
+                    addSystemChatMessage(buf);
+                }
+                LOG_DEBUG("SMSG_SET_FACTION_STANDING: faction=", factionId, " standing=", standing);
+            }
+            break;
+        }
+        case Opcode::SMSG_SET_FACTION_ATWAR:
+        case Opcode::SMSG_SET_FACTION_VISIBLE:
+            // uint32 factionId [+ uint8 flags for ATWAR] — consume; hostility is tracked via update fields
+            packet.setReadPos(packet.getSize());
+            break;
+
+        case Opcode::SMSG_FEATURE_SYSTEM_STATUS:
+        case Opcode::SMSG_SET_FLAT_SPELL_MODIFIER:
+        case Opcode::SMSG_SET_PCT_SPELL_MODIFIER:
+        case Opcode::SMSG_SPELL_DELAYED: {
+            // packed_guid (caster) + uint32 delayMs — spell cast was pushed back
+            // Adjust cast bar if it's the player's spell
+            if (casting && packet.getSize() - packet.getReadPos() >= 1) {
+                uint64_t caster = UpdateObjectParser::readPackedGuid(packet);
+                if (caster == playerGuid && packet.getSize() - packet.getReadPos() >= 4) {
+                    uint32_t delayMs = packet.readUInt32();
+                    castTimeRemaining += delayMs / 1000.0f;  // Extend cast bar by delay
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_EQUIPMENT_SET_SAVED:
+            // uint32 setIndex + uint64 guid — equipment set was successfully saved
+            LOG_DEBUG("Equipment set saved");
+            break;
+        case Opcode::SMSG_PERIODICAURALOG: {
+            // packed_guid victim, packed_guid caster, uint32 spellId, uint32 count, then per-effect
+            if (packet.getSize() - packet.getReadPos() < 2) break;
+            uint64_t victimGuid = UpdateObjectParser::readPackedGuid(packet);
+            if (packet.getSize() - packet.getReadPos() < 2) break;
+            uint64_t casterGuid = UpdateObjectParser::readPackedGuid(packet);
+            if (packet.getSize() - packet.getReadPos() < 8) break;
+            uint32_t spellId = packet.readUInt32();
+            uint32_t count   = packet.readUInt32();
+            bool isPlayerVictim = (victimGuid == playerGuid);
+            bool isPlayerCaster = (casterGuid == playerGuid);
+            if (!isPlayerVictim && !isPlayerCaster) {
+                packet.setReadPos(packet.getSize());
+                break;
+            }
+            for (uint32_t i = 0; i < count && packet.getSize() - packet.getReadPos() >= 1; ++i) {
+                uint8_t auraType = packet.readUInt8();
+                if (auraType == 3 || auraType == 89) {
+                    // PERIODIC_DAMAGE / PERIODIC_DAMAGE_PERCENT: damage+school+absorbed+resisted
+                    if (packet.getSize() - packet.getReadPos() < 16) break;
+                    uint32_t dmg      = packet.readUInt32();
+                    /*uint32_t school=*/ packet.readUInt32();
+                    /*uint32_t abs=*/    packet.readUInt32();
+                    /*uint32_t res=*/    packet.readUInt32();
+                    addCombatText(CombatTextEntry::PERIODIC_DAMAGE, static_cast<int32_t>(dmg),
+                                  spellId, isPlayerCaster);
+                } else if (auraType == 8 || auraType == 124 || auraType == 45) {
+                    // PERIODIC_HEAL / PERIODIC_HEAL_PCT / OBS_MOD_HEALTH: heal+maxHeal+overHeal
+                    if (packet.getSize() - packet.getReadPos() < 12) break;
+                    uint32_t heal    = packet.readUInt32();
+                    /*uint32_t max=*/  packet.readUInt32();
+                    /*uint32_t over=*/ packet.readUInt32();
+                    addCombatText(CombatTextEntry::PERIODIC_HEAL, static_cast<int32_t>(heal),
+                                  spellId, isPlayerCaster);
+                } else {
+                    // Unknown/untracked aura type — stop parsing this event safely
+                    packet.setReadPos(packet.getSize());
+                    break;
+                }
+            }
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+        case Opcode::SMSG_SPELLENERGIZELOG: {
+            // packed victim GUID, packed caster GUID, uint32 spellId, uint8 powerType, int32 amount
+            size_t rem = packet.getSize() - packet.getReadPos();
+            if (rem < 4) { packet.setReadPos(packet.getSize()); break; }
+            uint64_t victimGuid = UpdateObjectParser::readPackedGuid(packet);
+            uint64_t casterGuid = UpdateObjectParser::readPackedGuid(packet);
+            rem = packet.getSize() - packet.getReadPos();
+            if (rem < 6) { packet.setReadPos(packet.getSize()); break; }
+            uint32_t spellId   = packet.readUInt32();
+            /*uint8_t powerType =*/ packet.readUInt8();
+            int32_t  amount    = static_cast<int32_t>(packet.readUInt32());
+            bool isPlayerVictim = (victimGuid == playerGuid);
+            bool isPlayerCaster = (casterGuid == playerGuid);
+            if ((isPlayerVictim || isPlayerCaster) && amount > 0)
+                addCombatText(CombatTextEntry::ENERGIZE, amount, spellId, isPlayerCaster);
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+        case Opcode::SMSG_ENVIRONMENTAL_DAMAGE_LOG: {
+            // uint64 victimGuid + uint8 envDmgType + uint32 damage + uint32 absorbed + uint32 resisted
+            // envDmgType: 1=Exhausted(fatigue), 2=Drowning, 3=Fall, 4=Lava, 5=Slime, 6=Fire
+            if (packet.getSize() - packet.getReadPos() < 21) { packet.setReadPos(packet.getSize()); break; }
+            uint64_t victimGuid  = packet.readUInt64();
+            /*uint8_t envType =*/ packet.readUInt8();
+            uint32_t dmg         = packet.readUInt32();
+            /*uint32_t abs =*/    packet.readUInt32();
+            if (victimGuid == playerGuid && dmg > 0)
+                addCombatText(CombatTextEntry::ENVIRONMENTAL, static_cast<int32_t>(dmg), 0, false);
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+        case Opcode::SMSG_SET_PROFICIENCY: {
+            // uint8 itemClass + uint32 itemSubClassMask
+            if (packet.getSize() - packet.getReadPos() < 5) break;
+            uint8_t  itemClass = packet.readUInt8();
+            uint32_t mask      = packet.readUInt32();
+            if (itemClass == 2) {      // Weapon
+                weaponProficiency_ = mask;
+                LOG_DEBUG("SMSG_SET_PROFICIENCY: weapon mask=0x", std::hex, mask, std::dec);
+            } else if (itemClass == 4) { // Armor
+                armorProficiency_ = mask;
+                LOG_DEBUG("SMSG_SET_PROFICIENCY: armor mask=0x", std::hex, mask, std::dec);
+            }
+            break;
+        }
+
+        case Opcode::SMSG_ACTION_BUTTONS: {
+            // uint8 mode (0=initial, 1=update) + 144 × uint32 packed buttons
+            // packed: bits 0-23 = actionId, bits 24-31 = type
+            //   0x00 = spell (when id != 0), 0x80 = item, 0x40 = macro (skip)
+            size_t rem = packet.getSize() - packet.getReadPos();
+            if (rem < 1) break;
+            /*uint8_t mode =*/ packet.readUInt8();
+            rem--;
+            constexpr int SERVER_BAR_SLOTS = 144;
+            constexpr int OUR_BAR_SLOTS    = 12;   // our actionBar array size
+            for (int i = 0; i < SERVER_BAR_SLOTS; ++i) {
+                if (rem < 4) break;
+                uint32_t packed = packet.readUInt32();
+                rem -= 4;
+                if (i >= OUR_BAR_SLOTS) continue;  // only load first bar
+                if (packed == 0) {
+                    // Empty slot — only clear if not already set to Attack/Hearthstone defaults
+                    // so we don't wipe hardcoded fallbacks when the server sends zeros.
+                    continue;
+                }
+                uint8_t  type   = static_cast<uint8_t>((packed >> 24) & 0xFF);
+                uint32_t id     = packed & 0x00FFFFFFu;
+                if (id == 0) continue;
+                ActionBarSlot slot;
+                switch (type) {
+                    case 0x00: slot.type = ActionBarSlot::SPELL; slot.id = id; break;
+                    case 0x80: slot.type = ActionBarSlot::ITEM;  slot.id = id; break;
+                    default:   continue;  // macro or unknown — leave as-is
+                }
+                actionBar[i] = slot;
+            }
+            LOG_INFO("SMSG_ACTION_BUTTONS: populated action bar from server");
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+
+        case Opcode::SMSG_LEVELUP_INFO:
+        case Opcode::SMSG_LEVELUP_INFO_ALT: {
+            // Server-authoritative level-up event.
+            // First field is always the new level in Classic/TBC/WotLK-era layouts.
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t newLevel = packet.readUInt32();
+                if (newLevel > 0) {
+                    uint32_t oldLevel = serverPlayerLevel_;
+                    serverPlayerLevel_ = std::max(serverPlayerLevel_, newLevel);
+                    for (auto& ch : characters) {
+                        if (ch.guid == playerGuid) {
+                            ch.level = serverPlayerLevel_;
+                            break;
+                        }
+                    }
+                    if (newLevel > oldLevel && levelUpCallback_) {
+                        levelUpCallback_(newLevel);
+                    }
+                }
+            }
+            // Remaining payload (hp/mana/stat deltas) is optional for our client.
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+
+        case Opcode::SMSG_PLAY_SOUND:
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t soundId = packet.readUInt32();
+                LOG_DEBUG("SMSG_PLAY_SOUND id=", soundId);
+                if (playSoundCallback_) playSoundCallback_(soundId);
+            }
+            break;
+
+        case Opcode::SMSG_SERVER_MESSAGE: {
+            // uint32 type, string message
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                /*uint32_t msgType =*/ packet.readUInt32();
+                std::string msg = packet.readString();
+                if (!msg.empty()) addSystemChatMessage("[Server] " + msg);
+            }
+            break;
+        }
+        case Opcode::SMSG_CHAT_SERVER_MESSAGE: {
+            // uint32 type + string text
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                /*uint32_t msgType =*/ packet.readUInt32();
+                std::string msg = packet.readString();
+                if (!msg.empty()) addSystemChatMessage("[Announcement] " + msg);
+            }
+            break;
+        }
+        case Opcode::SMSG_AREA_TRIGGER_MESSAGE: {
+            // uint32 size, then string
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                /*uint32_t len =*/ packet.readUInt32();
+                std::string msg = packet.readString();
+                if (!msg.empty()) addSystemChatMessage(msg);
+            }
+            break;
+        }
+        case Opcode::SMSG_TRIGGER_CINEMATIC:
+            // uint32 cinematicId — we don't play cinematics; consume and skip.
+            packet.setReadPos(packet.getSize());
+            LOG_DEBUG("SMSG_TRIGGER_CINEMATIC: skipped");
+            break;
+
+        case Opcode::SMSG_LOOT_MONEY_NOTIFY: {
+            // Format: uint32 money + uint8 soleLooter
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t amount = packet.readUInt32();
+                if (packet.getSize() - packet.getReadPos() >= 1) {
+                    /*uint8_t soleLooter =*/ packet.readUInt8();
+                }
+                playerMoneyCopper_ += amount;
+                pendingMoneyDelta_ = amount;
+                pendingMoneyDeltaTimer_ = 2.0f;
+                LOG_INFO("Looted ", amount, " copper (total: ", playerMoneyCopper_, ")");
+                uint64_t notifyGuid = pendingLootMoneyGuid_ != 0 ? pendingLootMoneyGuid_ : currentLoot.lootGuid;
+                pendingLootMoneyGuid_ = 0;
+                pendingLootMoneyAmount_ = 0;
+                pendingLootMoneyNotifyTimer_ = 0.0f;
+                bool alreadyAnnounced = false;
+                auto it = localLootState_.find(notifyGuid);
+                if (it != localLootState_.end()) {
+                    alreadyAnnounced = it->second.moneyTaken;
+                    it->second.moneyTaken = true;
+                }
+                if (!alreadyAnnounced) {
+                    addSystemChatMessage("Looted: " + formatCopperAmount(amount));
+                    auto* renderer = core::Application::getInstance().getRenderer();
+                    if (renderer) {
+                        if (auto* sfx = renderer->getUiSoundManager()) {
+                            if (amount >= 10000) {
+                                sfx->playLootCoinLarge();
+                            } else {
+                                sfx->playLootCoinSmall();
+                            }
+                        }
+                    }
+                    if (notifyGuid != 0) {
+                        recentLootMoneyAnnounceCooldowns_[notifyGuid] = 1.5f;
+                    }
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_LOOT_CLEAR_MONEY:
+        case Opcode::SMSG_NPC_TEXT_UPDATE:
+            break;
+        case Opcode::SMSG_SELL_ITEM: {
+            // uint64 vendorGuid, uint64 itemGuid, uint8 result
+            if ((packet.getSize() - packet.getReadPos()) >= 17) {
+                uint64_t vendorGuid = packet.readUInt64();
+                uint64_t itemGuid = packet.readUInt64(); // itemGuid
+                uint8_t result = packet.readUInt8();
+                LOG_INFO("SMSG_SELL_ITEM: vendorGuid=0x", std::hex, vendorGuid,
+                         " itemGuid=0x", itemGuid, std::dec,
+                         " result=", static_cast<int>(result));
+                if (result == 0) {
+                    pendingSellToBuyback_.erase(itemGuid);
+                } else {
+                    bool removedPending = false;
+                    auto it = pendingSellToBuyback_.find(itemGuid);
+                    if (it != pendingSellToBuyback_.end()) {
+                        for (auto bit = buybackItems_.begin(); bit != buybackItems_.end(); ++bit) {
+                            if (bit->itemGuid == itemGuid) {
+                                buybackItems_.erase(bit);
+                                break;
+                            }
+                        }
+                        pendingSellToBuyback_.erase(it);
+                        removedPending = true;
+                    }
+                    if (!removedPending) {
+                        // Some cores return a non-item GUID on sell failure; drop the newest
+                        // optimistic entry if it is still pending so stale rows don't block buyback.
+                        if (!buybackItems_.empty()) {
+                            uint64_t frontGuid = buybackItems_.front().itemGuid;
+                            if (pendingSellToBuyback_.erase(frontGuid) > 0) {
+                                buybackItems_.pop_front();
+                                removedPending = true;
+                            }
+                        }
+                    }
+                    if (!removedPending && !pendingSellToBuyback_.empty()) {
+                        // Last-resort desync recovery.
+                        pendingSellToBuyback_.clear();
+                        buybackItems_.clear();
+                    }
+                    static const char* sellErrors[] = {
+                        "OK", "Can't find item", "Can't sell item",
+                        "Can't find vendor", "You don't own that item",
+                        "Unknown error", "Only empty bag"
+                    };
+                    const char* msg = (result < 7) ? sellErrors[result] : "Unknown sell error";
+                    addSystemChatMessage(std::string("Sell failed: ") + msg);
+                    LOG_WARNING("SMSG_SELL_ITEM error: ", (int)result, " (", msg, ")");
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_INVENTORY_CHANGE_FAILURE: {
+            if ((packet.getSize() - packet.getReadPos()) >= 1) {
+                uint8_t error = packet.readUInt8();
+                if (error != 0) {
+                    LOG_WARNING("SMSG_INVENTORY_CHANGE_FAILURE: error=", (int)error);
+                    // InventoryResult enum (AzerothCore 3.3.5a)
+                    const char* errMsg = nullptr;
+                    switch (error) {
+                        case 1:  errMsg = "You must reach level %d to use that item."; break;
+                        case 2:  errMsg = "You don't have the required skill."; break;
+                        case 3:  errMsg = "That item doesn't go in that slot."; break;
+                        case 4:  errMsg = "That bag is full."; break;
+                        case 5:  errMsg = "Can't put bags in bags."; break;
+                        case 6:  errMsg = "Can't trade equipped bags."; break;
+                        case 7:  errMsg = "That slot only holds ammo."; break;
+                        case 8:  errMsg = "You can't use that item."; break;
+                        case 9:  errMsg = "No equipment slot available."; break;
+                        case 10: errMsg = "You can never use that item."; break;
+                        case 11: errMsg = "You can never use that item."; break;
+                        case 12: errMsg = "No equipment slot available."; break;
+                        case 13: errMsg = "Can't equip with a two-handed weapon."; break;
+                        case 14: errMsg = "Can't dual-wield."; break;
+                        case 15: errMsg = "That item doesn't go in that bag."; break;
+                        case 16: errMsg = "That item doesn't go in that bag."; break;
+                        case 17: errMsg = "You can't carry any more of those."; break;
+                        case 18: errMsg = "No equipment slot available."; break;
+                        case 19: errMsg = "Can't stack those items."; break;
+                        case 20: errMsg = "That item can't be equipped."; break;
+                        case 21: errMsg = "Can't swap items."; break;
+                        case 22: errMsg = "That slot is empty."; break;
+                        case 23: errMsg = "Item not found."; break;
+                        case 24: errMsg = "Can't drop soulbound items."; break;
+                        case 25: errMsg = "Out of range."; break;
+                        case 26: errMsg = "Need to split more than 1."; break;
+                        case 27: errMsg = "Split failed."; break;
+                        case 28: errMsg = "Not enough reagents."; break;
+                        case 29: errMsg = "Not enough money."; break;
+                        case 30: errMsg = "Not a bag."; break;
+                        case 31: errMsg = "Can't destroy non-empty bag."; break;
+                        case 32: errMsg = "You don't own that item."; break;
+                        case 33: errMsg = "You can only have one quiver."; break;
+                        case 34: errMsg = "No free bank slots."; break;
+                        case 35: errMsg = "No bank here."; break;
+                        case 36: errMsg = "Item is locked."; break;
+                        case 37: errMsg = "You are stunned."; break;
+                        case 38: errMsg = "You are dead."; break;
+                        case 39: errMsg = "Can't do that right now."; break;
+                        case 40: errMsg = "Internal bag error."; break;
+                        case 49: errMsg = "Loot is gone."; break;
+                        case 50: errMsg = "Inventory is full."; break;
+                        case 51: errMsg = "Bank is full."; break;
+                        case 52: errMsg = "That item is sold out."; break;
+                        case 58: errMsg = "That object is busy."; break;
+                        case 60: errMsg = "Can't do that in combat."; break;
+                        case 61: errMsg = "Can't do that while disarmed."; break;
+                        case 63: errMsg = "Requires a higher rank."; break;
+                        case 64: errMsg = "Requires higher reputation."; break;
+                        case 67: errMsg = "That item is unique-equipped."; break;
+                        case 69: errMsg = "Not enough honor points."; break;
+                        case 70: errMsg = "Not enough arena points."; break;
+                        case 77: errMsg = "Too much gold."; break;
+                        case 78: errMsg = "Can't do that during arena match."; break;
+                        case 80: errMsg = "Requires a personal arena rating."; break;
+                        case 87: errMsg = "Requires a higher level."; break;
+                        case 88: errMsg = "Requires the right talent."; break;
+                        default: break;
+                    }
+                    std::string msg = errMsg ? errMsg : "Inventory error (" + std::to_string(error) + ").";
+                    addSystemChatMessage(msg);
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_BUY_FAILED: {
+            // vendorGuid(8) + itemId(4) + errorCode(1)
+            if (packet.getSize() - packet.getReadPos() >= 13) {
+                uint64_t vendorGuid = packet.readUInt64();
+                uint32_t itemIdOrSlot = packet.readUInt32();
+                uint8_t errCode = packet.readUInt8();
+                LOG_INFO("SMSG_BUY_FAILED: vendorGuid=0x", std::hex, vendorGuid, std::dec,
+                         " item/slot=", itemIdOrSlot,
+                         " err=", static_cast<int>(errCode),
+                         " pendingBuybackSlot=", pendingBuybackSlot_,
+                         " pendingBuybackWireSlot=", pendingBuybackWireSlot_,
+                         " pendingBuyItemId=", pendingBuyItemId_,
+                         " pendingBuyItemSlot=", pendingBuyItemSlot_);
+                if (pendingBuybackSlot_ >= 0) {
+                    // Some cores require probing absolute buyback slots until a live entry is found.
+                    if (errCode == 0) {
+                        constexpr uint16_t kWotlkCmsgBuybackItemOpcode = 0x290;
+                        constexpr uint32_t kBuybackSlotEnd = 85;
+                        if (pendingBuybackWireSlot_ >= 74 && pendingBuybackWireSlot_ < kBuybackSlotEnd &&
+                            socket && state == WorldState::IN_WORLD && currentVendorItems.vendorGuid != 0) {
+                            ++pendingBuybackWireSlot_;
+                            LOG_INFO("Buyback retry: vendorGuid=0x", std::hex, currentVendorItems.vendorGuid,
+                                     std::dec, " uiSlot=", pendingBuybackSlot_,
+                                     " wireSlot=", pendingBuybackWireSlot_);
+                            network::Packet retry(kWotlkCmsgBuybackItemOpcode);
+                            retry.writeUInt64(currentVendorItems.vendorGuid);
+                            retry.writeUInt32(pendingBuybackWireSlot_);
+                            socket->send(retry);
+                            break;
+                        }
+                        // Exhausted slot probe: drop stale local row and advance.
+                        if (pendingBuybackSlot_ < static_cast<int>(buybackItems_.size())) {
+                            buybackItems_.erase(buybackItems_.begin() + pendingBuybackSlot_);
+                        }
+                        pendingBuybackSlot_ = -1;
+                        pendingBuybackWireSlot_ = 0;
+                        if (currentVendorItems.vendorGuid != 0 && socket && state == WorldState::IN_WORLD) {
+                            auto pkt = ListInventoryPacket::build(currentVendorItems.vendorGuid);
+                            socket->send(pkt);
+                        }
+                        break;
+                    }
+                    pendingBuybackSlot_ = -1;
+                    pendingBuybackWireSlot_ = 0;
+                }
+
+                const char* msg = "Purchase failed.";
+                switch (errCode) {
+                    case 0: msg = "Purchase failed: item not found."; break;
+                    case 2: msg = "You don't have enough money."; break;
+                    case 4: msg = "Seller is too far away."; break;
+                    case 5: msg = "That item is sold out."; break;
+                    case 6: msg = "You can't carry any more items."; break;
+                    default: break;
+                }
+                addSystemChatMessage(msg);
+            }
+            break;
+        }
+        case Opcode::MSG_RAID_TARGET_UPDATE:
+            break;
+        case Opcode::SMSG_BUY_ITEM: {
+            // uint64 vendorGuid + uint32 vendorSlot + int32 newCount + uint32 itemCount
+            // Confirms a successful CMSG_BUY_ITEM. The inventory update arrives via SMSG_UPDATE_OBJECT.
+            if (packet.getSize() - packet.getReadPos() >= 20) {
+                uint64_t vendorGuid = packet.readUInt64();
+                uint32_t vendorSlot = packet.readUInt32();
+                int32_t  newCount   = static_cast<int32_t>(packet.readUInt32());
+                uint32_t itemCount  = packet.readUInt32();
+                LOG_DEBUG("SMSG_BUY_ITEM: vendorGuid=0x", std::hex, vendorGuid, std::dec,
+                          " slot=", vendorSlot, " newCount=", newCount, " bought=", itemCount);
+                pendingBuyItemId_   = 0;
+                pendingBuyItemSlot_ = 0;
+            }
+            break;
+        }
+        case Opcode::SMSG_CRITERIA_UPDATE: {
+            // uint32 criteriaId + uint64 progress + uint32 elapsedTime + uint32 creationTime
+            // Achievement criteria progress (informational — no criteria UI yet).
+            if (packet.getSize() - packet.getReadPos() >= 20) {
+                uint32_t criteriaId    = packet.readUInt32();
+                uint64_t progress      = packet.readUInt64();
+                /*uint32_t elapsedTime =*/ packet.readUInt32();
+                /*uint32_t createTime  =*/ packet.readUInt32();
+                LOG_DEBUG("SMSG_CRITERIA_UPDATE: id=", criteriaId, " progress=", progress);
+            }
+            break;
+        }
+        case Opcode::SMSG_BARBER_SHOP_RESULT: {
+            // uint32 result (0 = success, 1 = no money, 2 = not barber, 3 = sitting)
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t result = packet.readUInt32();
+                if (result == 0) {
+                    addSystemChatMessage("Hairstyle changed.");
+                } else {
+                    const char* msg = (result == 1) ? "Not enough money for new hairstyle."
+                                    : (result == 2) ? "You are not at a barber shop."
+                                    : (result == 3) ? "You must stand up to use the barber shop."
+                                    : "Barber shop unavailable.";
+                    addSystemChatMessage(msg);
+                }
+                LOG_DEBUG("SMSG_BARBER_SHOP_RESULT: result=", result);
+            }
+            break;
+        }
+        case Opcode::SMSG_OVERRIDE_LIGHT: {
+            // uint32 currentZoneLightId + uint32 overrideLightId + uint32 transitionMs
+            if (packet.getSize() - packet.getReadPos() >= 12) {
+                uint32_t zoneLightId     = packet.readUInt32();
+                uint32_t overrideLightId = packet.readUInt32();
+                uint32_t transitionMs    = packet.readUInt32();
+                overrideLightId_      = overrideLightId;
+                overrideLightTransMs_ = transitionMs;
+                LOG_DEBUG("SMSG_OVERRIDE_LIGHT: zone=", zoneLightId,
+                          " override=", overrideLightId, " transition=", transitionMs, "ms");
+            }
+            break;
+        }
+        case Opcode::SMSG_WEATHER: {
+            // Format: uint32 weatherType, float intensity, uint8 isAbrupt
+            if (packet.getSize() - packet.getReadPos() >= 9) {
+                uint32_t wType = packet.readUInt32();
+                float wIntensity = packet.readFloat();
+                /*uint8_t isAbrupt =*/ packet.readUInt8();
+                weatherType_ = wType;
+                weatherIntensity_ = wIntensity;
+                const char* typeName = (wType == 1) ? "Rain" : (wType == 2) ? "Snow" : (wType == 3) ? "Storm" : "Clear";
+                LOG_INFO("Weather changed: type=", wType, " (", typeName, "), intensity=", wIntensity);
+            }
+            break;
+        }
+        case Opcode::SMSG_SCRIPT_MESSAGE: {
+            // Server-script text message — display in system chat
+            std::string msg = packet.readString();
+            if (!msg.empty()) {
+                addSystemChatMessage(msg);
+                LOG_INFO("SMSG_SCRIPT_MESSAGE: ", msg);
+            }
+            break;
+        }
+        case Opcode::SMSG_ENCHANTMENTLOG: {
+            // uint64 targetGuid + uint64 casterGuid + uint32 spellId + uint32 displayId + uint32 animType
+            if (packet.getSize() - packet.getReadPos() >= 28) {
+                /*uint64_t targetGuid =*/ packet.readUInt64();
+                /*uint64_t casterGuid =*/ packet.readUInt64();
+                uint32_t spellId = packet.readUInt32();
+                /*uint32_t displayId =*/ packet.readUInt32();
+                /*uint32_t animType =*/ packet.readUInt32();
+                LOG_DEBUG("SMSG_ENCHANTMENTLOG: spellId=", spellId);
+            }
+            break;
+        }
+        case Opcode::SMSG_SOCKET_GEMS_RESULT: {
+            // uint64 itemGuid + uint32 result (0 = success)
+            if (packet.getSize() - packet.getReadPos() >= 12) {
+                /*uint64_t itemGuid =*/ packet.readUInt64();
+                uint32_t result = packet.readUInt32();
+                if (result == 0) {
+                    addSystemChatMessage("Gems socketed successfully.");
+                } else {
+                    addSystemChatMessage("Failed to socket gems.");
+                }
+                LOG_DEBUG("SMSG_SOCKET_GEMS_RESULT: result=", result);
+            }
+            break;
+        }
+        case Opcode::SMSG_ITEM_REFUND_RESULT: {
+            // uint64 itemGuid + uint32 result (0=success)
+            if (packet.getSize() - packet.getReadPos() >= 12) {
+                /*uint64_t itemGuid =*/ packet.readUInt64();
+                uint32_t result = packet.readUInt32();
+                if (result == 0) {
+                    addSystemChatMessage("Item returned. Refund processed.");
+                } else {
+                    addSystemChatMessage("Could not return item for refund.");
+                }
+                LOG_DEBUG("SMSG_ITEM_REFUND_RESULT: result=", result);
+            }
+            break;
+        }
+        case Opcode::SMSG_ITEM_TIME_UPDATE: {
+            // uint64 itemGuid + uint32 durationMs — item duration ticking down
+            if (packet.getSize() - packet.getReadPos() >= 12) {
+                /*uint64_t itemGuid =*/ packet.readUInt64();
+                uint32_t durationMs = packet.readUInt32();
+                LOG_DEBUG("SMSG_ITEM_TIME_UPDATE: remainingMs=", durationMs);
+            }
+            break;
+        }
+        case Opcode::SMSG_RESURRECT_FAILED: {
+            // uint32 reason — various resurrection failures
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t reason = packet.readUInt32();
+                const char* msg = (reason == 1) ? "The target cannot be resurrected right now."
+                                : (reason == 2) ? "Cannot resurrect in this area."
+                                : "Resurrection failed.";
+                addSystemChatMessage(msg);
+                LOG_DEBUG("SMSG_RESURRECT_FAILED: reason=", reason);
+            }
+            break;
+        }
+        case Opcode::SMSG_GAMEOBJECT_QUERY_RESPONSE:
+            handleGameObjectQueryResponse(packet);
+            break;
+        case Opcode::SMSG_GAMEOBJECT_PAGETEXT:
+            handleGameObjectPageText(packet);
+            break;
+        case Opcode::SMSG_GAMEOBJECT_CUSTOM_ANIM: {
+            if (packet.getSize() >= 12) {
+                uint64_t guid = packet.readUInt64();
+                uint32_t animId = packet.readUInt32();
+                if (gameObjectCustomAnimCallback_) {
+                    gameObjectCustomAnimCallback_(guid, animId);
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_PAGE_TEXT_QUERY_RESPONSE:
+            handlePageTextQueryResponse(packet);
+            break;
+        case Opcode::SMSG_QUESTGIVER_STATUS: {
+            if (packet.getSize() - packet.getReadPos() >= 9) {
+                uint64_t npcGuid = packet.readUInt64();
+                uint8_t status = packetParsers_->readQuestGiverStatus(packet);
+                npcQuestStatus_[npcGuid] = static_cast<QuestGiverStatus>(status);
+                LOG_DEBUG("SMSG_QUESTGIVER_STATUS: guid=0x", std::hex, npcGuid, std::dec, " status=", (int)status);
+            }
+            break;
+        }
+        case Opcode::SMSG_QUESTGIVER_STATUS_MULTIPLE: {
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t count = packet.readUInt32();
+                for (uint32_t i = 0; i < count; ++i) {
+                    if (packet.getSize() - packet.getReadPos() < 9) break;
+                    uint64_t npcGuid = packet.readUInt64();
+                    uint8_t status = packetParsers_->readQuestGiverStatus(packet);
+                    npcQuestStatus_[npcGuid] = static_cast<QuestGiverStatus>(status);
+                }
+                LOG_DEBUG("SMSG_QUESTGIVER_STATUS_MULTIPLE: ", count, " entries");
+            }
+            break;
+        }
+        case Opcode::SMSG_QUESTGIVER_QUEST_DETAILS:
+            handleQuestDetails(packet);
+            break;
+        case Opcode::SMSG_QUESTGIVER_QUEST_INVALID: {
+            // Quest query failed - parse failure reason
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t failReason = packet.readUInt32();
+                pendingTurnInRewardRequest_ = false;
+                const char* reasonStr = "Unknown";
+                switch (failReason) {
+                    case 0: reasonStr = "Don't have quest"; break;
+                    case 1: reasonStr = "Quest level too low"; break;
+                    case 4: reasonStr = "Insufficient money"; break;
+                    case 5: reasonStr = "Inventory full"; break;
+                    case 13: reasonStr = "Already on that quest"; break;
+                    case 18: reasonStr = "Already completed quest"; break;
+                    case 19: reasonStr = "Can't take any more quests"; break;
+                }
+                LOG_WARNING("Quest invalid: reason=", failReason, " (", reasonStr, ")");
+                if (!pendingQuestAcceptTimeouts_.empty()) {
+                    std::vector<uint32_t> pendingQuestIds;
+                    pendingQuestIds.reserve(pendingQuestAcceptTimeouts_.size());
+                    for (const auto& pending : pendingQuestAcceptTimeouts_) {
+                        pendingQuestIds.push_back(pending.first);
+                    }
+                    for (uint32_t questId : pendingQuestIds) {
+                        const uint64_t npcGuid = pendingQuestAcceptNpcGuids_.count(questId) != 0
+                            ? pendingQuestAcceptNpcGuids_[questId] : 0;
+                        if (failReason == 13) {
+                            std::string fallbackTitle = "Quest #" + std::to_string(questId);
+                            std::string fallbackObjectives;
+                            if (currentQuestDetails.questId == questId) {
+                                if (!currentQuestDetails.title.empty()) fallbackTitle = currentQuestDetails.title;
+                                fallbackObjectives = currentQuestDetails.objectives;
+                            }
+                            addQuestToLocalLogIfMissing(questId, fallbackTitle, fallbackObjectives);
+                            triggerQuestAcceptResync(questId, npcGuid, "already-on-quest");
+                        } else if (failReason == 18) {
+                            triggerQuestAcceptResync(questId, npcGuid, "already-completed");
+                        }
+                        clearPendingQuestAccept(questId);
+                    }
+                }
+                // Only show error to user for real errors (not informational messages)
+                if (failReason != 13 && failReason != 18) {  // Don't spam "already on/completed"
+                    addSystemChatMessage(std::string("Quest unavailable: ") + reasonStr);
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_QUESTGIVER_QUEST_COMPLETE: {
+            // Mark quest as complete in local log
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t questId = packet.readUInt32();
+                LOG_INFO("Quest completed: questId=", questId);
+                if (pendingTurnInQuestId_ == questId) {
+                    pendingTurnInQuestId_ = 0;
+                    pendingTurnInNpcGuid_ = 0;
+                    pendingTurnInRewardRequest_ = false;
+                }
+                for (auto it = questLog_.begin(); it != questLog_.end(); ++it) {
+                    if (it->questId == questId) {
+                        questLog_.erase(it);
+                        LOG_INFO("  Removed quest ", questId, " from quest log");
+                        break;
+                    }
+                }
+            }
+            // Re-query all nearby quest giver NPCs so markers refresh
+            if (socket) {
+                for (const auto& [guid, entity] : entityManager.getEntities()) {
+                    if (entity->getType() != ObjectType::UNIT) continue;
+                    auto unit = std::static_pointer_cast<Unit>(entity);
+                    if (unit->getNpcFlags() & 0x02) {
+                        network::Packet qsPkt(wireOpcode(Opcode::CMSG_QUESTGIVER_STATUS_QUERY));
+                        qsPkt.writeUInt64(guid);
+                        socket->send(qsPkt);
+                    }
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_QUESTUPDATE_ADD_KILL: {
+            // Quest kill count update
+            // Compatibility: some classic-family opcode tables swap ADD_KILL and COMPLETE.
+            size_t rem = packet.getSize() - packet.getReadPos();
+            if (rem >= 12) {
+                uint32_t questId = packet.readUInt32();
+                clearPendingQuestAccept(questId);
+                uint32_t entry = packet.readUInt32();   // Creature entry
+                uint32_t count = packet.readUInt32();   // Current kills
+                uint32_t reqCount = 0;
+                if (packet.getSize() - packet.getReadPos() >= 4) {
+                    reqCount = packet.readUInt32();     // Required kills (if present)
+                }
+
+                LOG_INFO("Quest kill update: questId=", questId, " entry=", entry,
+                         " count=", count, "/", reqCount);
+
+                // Update quest log with kill count
+                for (auto& quest : questLog_) {
+                    if (quest.questId == questId) {
+                        // Preserve prior required count if this packet variant omits it.
+                        if (reqCount == 0) {
+                            auto it = quest.killCounts.find(entry);
+                            if (it != quest.killCounts.end()) reqCount = it->second.second;
+                            if (reqCount == 0) reqCount = count;
+                        }
+                        quest.killCounts[entry] = {count, reqCount};
+
+                        std::string progressMsg = quest.title + ": " +
+                                                std::to_string(count) + "/" +
+                                                std::to_string(reqCount);
+                        addSystemChatMessage(progressMsg);
+
+                        LOG_INFO("Updated kill count for quest ", questId, ": ",
+                                 count, "/", reqCount);
+                        break;
+                    }
+                }
+            } else if (rem >= 4) {
+                // Swapped mapping fallback: treat as QUESTUPDATE_COMPLETE packet.
+                uint32_t questId = packet.readUInt32();
+                clearPendingQuestAccept(questId);
+                LOG_INFO("Quest objectives completed (compat via ADD_KILL): questId=", questId);
+                for (auto& quest : questLog_) {
+                    if (quest.questId == questId) {
+                        quest.complete = true;
+                        addSystemChatMessage("Quest Complete: " + quest.title);
+                        break;
+                    }
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_QUESTUPDATE_ADD_ITEM: {
+            // Quest item count update: itemId + count
+            if (packet.getSize() - packet.getReadPos() >= 8) {
+                uint32_t itemId = packet.readUInt32();
+                uint32_t count = packet.readUInt32();
+                queryItemInfo(itemId, 0);
+
+                std::string itemLabel = "item #" + std::to_string(itemId);
+                if (const ItemQueryResponseData* info = getItemInfo(itemId)) {
+                    if (!info->name.empty()) itemLabel = info->name;
+                }
+
+                bool updatedAny = false;
+                for (auto& quest : questLog_) {
+                    if (quest.complete) continue;
+                    const bool tracksItem =
+                        quest.requiredItemCounts.count(itemId) > 0 ||
+                        quest.itemCounts.count(itemId) > 0;
+                    if (!tracksItem) continue;
+                    quest.itemCounts[itemId] = count;
+                    updatedAny = true;
+                }
+                addSystemChatMessage("Quest item: " + itemLabel + " (" + std::to_string(count) + ")");
+                LOG_INFO("Quest item update: itemId=", itemId, " count=", count,
+                         " trackedQuestsUpdated=", updatedAny);
+            }
+            break;
+        }
+        case Opcode::SMSG_QUESTUPDATE_COMPLETE: {
+            // Quest objectives completed - mark as ready to turn in.
+            // Compatibility: some classic-family opcode tables swap COMPLETE and ADD_KILL.
+            size_t rem = packet.getSize() - packet.getReadPos();
+            if (rem >= 12) {
+                uint32_t questId = packet.readUInt32();
+                clearPendingQuestAccept(questId);
+                uint32_t entry = packet.readUInt32();
+                uint32_t count = packet.readUInt32();
+                uint32_t reqCount = 0;
+                if (packet.getSize() - packet.getReadPos() >= 4) reqCount = packet.readUInt32();
+                if (reqCount == 0) reqCount = count;
+                LOG_INFO("Quest kill update (compat via COMPLETE): questId=", questId,
+                         " entry=", entry, " count=", count, "/", reqCount);
+                for (auto& quest : questLog_) {
+                    if (quest.questId == questId) {
+                        quest.killCounts[entry] = {count, reqCount};
+                        addSystemChatMessage(quest.title + ": " + std::to_string(count) +
+                                             "/" + std::to_string(reqCount));
+                        break;
+                    }
+                }
+            } else if (rem >= 4) {
+                uint32_t questId = packet.readUInt32();
+                clearPendingQuestAccept(questId);
+                LOG_INFO("Quest objectives completed: questId=", questId);
+
+                for (auto& quest : questLog_) {
+                    if (quest.questId == questId) {
+                        quest.complete = true;
+                        addSystemChatMessage("Quest Complete: " + quest.title);
+                        LOG_INFO("Marked quest ", questId, " as complete");
+                        break;
+                    }
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_QUEST_FORCE_REMOVE: {
+            // Minimal parse: uint32 questId
+            if (packet.getSize() - packet.getReadPos() < 4) {
+                LOG_WARNING("SMSG_QUEST_FORCE_REMOVE too short");
+                break;
+            }
+            uint32_t questId = packet.readUInt32();
+            clearPendingQuestAccept(questId);
+            pendingQuestQueryIds_.erase(questId);
+            if (questId == 0) {
+                // Some servers emit a zero-id variant during world bootstrap.
+                // Treat as no-op to avoid false "Quest removed" spam.
+                break;
+            }
+
+            bool removed = false;
+            std::string removedTitle;
+            for (auto it = questLog_.begin(); it != questLog_.end(); ++it) {
+                if (it->questId == questId) {
+                    removedTitle = it->title;
+                    questLog_.erase(it);
+                    removed = true;
+                    break;
+                }
+            }
+            if (currentQuestDetails.questId == questId) {
+                questDetailsOpen = false;
+                currentQuestDetails = QuestDetailsData{};
+                removed = true;
+            }
+            if (currentQuestRequestItems_.questId == questId) {
+                questRequestItemsOpen_ = false;
+                currentQuestRequestItems_ = QuestRequestItemsData{};
+                removed = true;
+            }
+            if (currentQuestOfferReward_.questId == questId) {
+                questOfferRewardOpen_ = false;
+                currentQuestOfferReward_ = QuestOfferRewardData{};
+                removed = true;
+            }
+            if (removed) {
+                if (!removedTitle.empty()) {
+                    addSystemChatMessage("Quest removed: " + removedTitle);
+                } else {
+                    addSystemChatMessage("Quest removed (ID " + std::to_string(questId) + ").");
+                }
+            }
+            break;
+        }
+        case Opcode::SMSG_QUEST_QUERY_RESPONSE: {
+            if (packet.getSize() < 8) {
+                LOG_WARNING("SMSG_QUEST_QUERY_RESPONSE: packet too small (", packet.getSize(), " bytes)");
+                break;
+            }
+
+            uint32_t questId = packet.readUInt32();
+            packet.readUInt32(); // questMethod
+
+            const bool isClassicLayout = packetParsers_ && packetParsers_->questLogStride() == 3;
+            const QuestQueryTextCandidate parsed = pickBestQuestQueryTexts(packet.getData(), isClassicLayout);
+
+            for (auto& q : questLog_) {
+                if (q.questId != questId) continue;
+
+                const int existingScore = scoreQuestTitle(q.title);
+                const bool parsedStrong = isStrongQuestTitle(parsed.title);
+                const bool parsedLongEnough = parsed.title.size() >= 6;
+                const bool notShorterThanExisting =
+                    isPlaceholderQuestTitle(q.title) || q.title.empty() || parsed.title.size() + 2 >= q.title.size();
+                const bool shouldReplaceTitle =
+                    parsed.score > -1000 &&
+                    parsedStrong &&
+                    parsedLongEnough &&
+                    notShorterThanExisting &&
+                    (isPlaceholderQuestTitle(q.title) || q.title.empty() || parsed.score >= existingScore + 12);
+
+                if (shouldReplaceTitle && !parsed.title.empty()) {
+                    q.title = parsed.title;
+                }
+                if (!parsed.objectives.empty() &&
+                    (q.objectives.empty() || q.objectives.size() < 16)) {
+                    q.objectives = parsed.objectives;
+                }
+                break;
+            }
+
+            pendingQuestQueryIds_.erase(questId);
+            break;
+        }
+        case Opcode::SMSG_QUESTLOG_FULL:
+            // Zero-payload notification: the player's quest log is full (25 quests).
+            addSystemChatMessage("Your quest log is full.");
+            LOG_INFO("SMSG_QUESTLOG_FULL: quest log is at capacity");
+            break;
+        case Opcode::SMSG_QUESTGIVER_REQUEST_ITEMS:
+            handleQuestRequestItems(packet);
+            break;
+        case Opcode::SMSG_QUESTGIVER_OFFER_REWARD:
+            handleQuestOfferReward(packet);
+            break;
+        case Opcode::SMSG_GROUP_SET_LEADER:
+            LOG_DEBUG("Ignoring known opcode: 0x", std::hex, opcode, std::dec);
+            break;
+
+        // ---- Teleport / Transfer ----
+        case Opcode::MSG_MOVE_TELEPORT_ACK:
+            handleTeleportAck(packet);
+            break;
+        case Opcode::SMSG_TRANSFER_PENDING: {
+            // SMSG_TRANSFER_PENDING: uint32 mapId, then optional transport data
+            uint32_t pendingMapId = packet.readUInt32();
+            LOG_WARNING("SMSG_TRANSFER_PENDING: mapId=", pendingMapId);
+            // Optional: if remaining data, there's a transport entry + mapId
+            if (packet.getReadPos() + 8 <= packet.getSize()) {
+                uint32_t transportEntry = packet.readUInt32();
+                uint32_t transportMapId = packet.readUInt32();
+                LOG_INFO("  Transport entry=", transportEntry, " transportMapId=", transportMapId);
+            }
+            break;
+        }
+        case Opcode::SMSG_NEW_WORLD:
+            handleNewWorld(packet);
+            break;
+        case Opcode::SMSG_TRANSFER_ABORTED: {
+            uint32_t mapId = packet.readUInt32();
+            uint8_t reason = (packet.getReadPos() < packet.getSize()) ? packet.readUInt8() : 0;
+            LOG_WARNING("SMSG_TRANSFER_ABORTED: mapId=", mapId, " reason=", (int)reason);
+            addSystemChatMessage("Transfer aborted.");
+            break;
+        }
+
+        // ---- Taxi / Flight Paths ----
+        case Opcode::SMSG_SHOWTAXINODES:
+            handleShowTaxiNodes(packet);
+            break;
+        case Opcode::SMSG_ACTIVATETAXIREPLY:
+            handleActivateTaxiReply(packet);
+            break;
+        case Opcode::SMSG_STANDSTATE_UPDATE:
+            // Server confirms stand state change (sit/stand/sleep/kneel)
+            if (packet.getSize() - packet.getReadPos() >= 1) {
+                standState_ = packet.readUInt8();
+                LOG_INFO("Stand state updated: ", static_cast<int>(standState_),
+                         " (", standState_ == 0 ? "stand" : standState_ == 1 ? "sit"
+                            : standState_ == 7 ? "dead" : standState_ == 8 ? "kneel" : "other", ")");
+            }
+            break;
+        case Opcode::SMSG_NEW_TAXI_PATH:
+            // Empty packet - server signals a new flight path was learned
+            // The actual node details come in the next SMSG_SHOWTAXINODES
+            addSystemChatMessage("New flight path discovered!");
+            break;
+
+        // ---- Arena / Battleground ----
+        case Opcode::SMSG_BATTLEFIELD_STATUS:
+            handleBattlefieldStatus(packet);
+            break;
+        case Opcode::SMSG_BATTLEFIELD_LIST:
+            LOG_INFO("Received SMSG_BATTLEFIELD_LIST");
+            break;
+        case Opcode::SMSG_BATTLEFIELD_PORT_DENIED:
+            addSystemChatMessage("Battlefield port denied.");
+            break;
+        case Opcode::MSG_BATTLEGROUND_PLAYER_POSITIONS:
+            // Optional map position updates for BG objectives/players.
+            packet.setReadPos(packet.getSize());
+            break;
+        case Opcode::SMSG_REMOVED_FROM_PVP_QUEUE:
+            addSystemChatMessage("You have been removed from the PvP queue.");
+            break;
+        case Opcode::SMSG_GROUP_JOINED_BATTLEGROUND:
+            addSystemChatMessage("Your group has joined the battleground.");
+            break;
+        case Opcode::SMSG_JOINED_BATTLEGROUND_QUEUE:
+            addSystemChatMessage("You have joined the battleground queue.");
+            break;
+        case Opcode::SMSG_BATTLEGROUND_PLAYER_JOINED:
+            LOG_INFO("Battleground player joined");
+            break;
+        case Opcode::SMSG_BATTLEGROUND_PLAYER_LEFT:
+            LOG_INFO("Battleground player left");
+            break;
+        case Opcode::SMSG_INSTANCE_DIFFICULTY:
+            handleInstanceDifficulty(packet);
+            break;
+        case Opcode::SMSG_INSTANCE_SAVE_CREATED:
+            // Zero-payload: your instance save was just created on the server.
+            addSystemChatMessage("You are now saved to this instance.");
+            LOG_INFO("SMSG_INSTANCE_SAVE_CREATED");
+            break;
+        case Opcode::SMSG_RAID_INSTANCE_MESSAGE: {
+            if (packet.getSize() - packet.getReadPos() >= 12) {
+                uint32_t msgType   = packet.readUInt32();
+                uint32_t mapId     = packet.readUInt32();
+                /*uint32_t diff =*/  packet.readUInt32();
+                // type: 1=warning(time left), 2=saved, 3=welcome
+                if (msgType == 1 && packet.getSize() - packet.getReadPos() >= 4) {
+                    uint32_t timeLeft = packet.readUInt32();
+                    uint32_t minutes  = timeLeft / 60;
+                    std::string msg = "Instance " + std::to_string(mapId) +
+                        " will reset in " + std::to_string(minutes) + " minute(s).";
+                    addSystemChatMessage(msg);
+                } else if (msgType == 2) {
+                    addSystemChatMessage("You have been saved to instance " + std::to_string(mapId) + ".");
+                } else if (msgType == 3) {
+                    addSystemChatMessage("Welcome to instance " + std::to_string(mapId) + ".");
+                }
+                LOG_INFO("SMSG_RAID_INSTANCE_MESSAGE: type=", msgType, " map=", mapId);
+            }
+            break;
+        }
+        case Opcode::SMSG_INSTANCE_RESET: {
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t mapId = packet.readUInt32();
+                // Remove matching lockout from local cache
+                auto it = std::remove_if(instanceLockouts_.begin(), instanceLockouts_.end(),
+                    [mapId](const InstanceLockout& lo){ return lo.mapId == mapId; });
+                instanceLockouts_.erase(it, instanceLockouts_.end());
+                addSystemChatMessage("Instance " + std::to_string(mapId) + " has been reset.");
+                LOG_INFO("SMSG_INSTANCE_RESET: mapId=", mapId);
+            }
+            break;
+        }
+        case Opcode::SMSG_INSTANCE_RESET_FAILED: {
+            if (packet.getSize() - packet.getReadPos() >= 8) {
+                uint32_t mapId  = packet.readUInt32();
+                uint32_t reason = packet.readUInt32();
+                static const char* resetFailReasons[] = {
+                    "Not max level.", "Offline party members.", "Party members inside.",
+                    "Party members changing zone.", "Heroic difficulty only."
+                };
+                const char* msg = (reason < 5) ? resetFailReasons[reason] : "Unknown reason.";
+                addSystemChatMessage("Cannot reset instance " + std::to_string(mapId) + ": " + msg);
+                LOG_INFO("SMSG_INSTANCE_RESET_FAILED: mapId=", mapId, " reason=", reason);
+            }
+            break;
+        }
+        case Opcode::SMSG_INSTANCE_LOCK_WARNING_QUERY: {
+            // Server asks player to confirm entering a saved instance.
+            // We auto-confirm with CMSG_INSTANCE_LOCK_RESPONSE.
+            if (socket && packet.getSize() - packet.getReadPos() >= 17) {
+                /*uint32_t mapId =*/ packet.readUInt32();
+                /*uint32_t diff  =*/ packet.readUInt32();
+                /*uint32_t timeLeft =*/ packet.readUInt32();
+                packet.readUInt32(); // unk
+                /*uint8_t  locked =*/ packet.readUInt8();
+                // Send acceptance
+                network::Packet resp(wireOpcode(Opcode::CMSG_INSTANCE_LOCK_RESPONSE));
+                resp.writeUInt8(1); // 1=accept
+                socket->send(resp);
+                LOG_INFO("SMSG_INSTANCE_LOCK_WARNING_QUERY: auto-accepted");
+            }
+            break;
+        }
+
+        // ---- LFG / Dungeon Finder ----
+        case Opcode::SMSG_LFG_JOIN_RESULT:
+            handleLfgJoinResult(packet);
+            break;
+        case Opcode::SMSG_LFG_QUEUE_STATUS:
+            handleLfgQueueStatus(packet);
+            break;
+        case Opcode::SMSG_LFG_PROPOSAL_UPDATE:
+            handleLfgProposalUpdate(packet);
+            break;
+        case Opcode::SMSG_LFG_ROLE_CHECK_UPDATE:
+            handleLfgRoleCheckUpdate(packet);
+            break;
+        case Opcode::SMSG_LFG_UPDATE_PLAYER:
+        case Opcode::SMSG_LFG_UPDATE_PARTY:
+            handleLfgUpdatePlayer(packet);
+            break;
+        case Opcode::SMSG_LFG_PLAYER_REWARD:
+            handleLfgPlayerReward(packet);
+            break;
+        case Opcode::SMSG_LFG_BOOT_PROPOSAL_UPDATE:
+            handleLfgBootProposalUpdate(packet);
+            break;
+        case Opcode::SMSG_LFG_TELEPORT_DENIED:
+            handleLfgTeleportDenied(packet);
+            break;
+        case Opcode::SMSG_LFG_DISABLED:
+            addSystemChatMessage("The Dungeon Finder is currently disabled.");
+            LOG_INFO("SMSG_LFG_DISABLED received");
+            break;
+        case Opcode::SMSG_LFG_OFFER_CONTINUE:
+            addSystemChatMessage("Dungeon Finder: You may continue your dungeon.");
+            break;
+        case Opcode::SMSG_LFG_ROLE_CHOSEN:
+        case Opcode::SMSG_LFG_UPDATE_SEARCH:
+        case Opcode::SMSG_UPDATE_LFG_LIST:
+        case Opcode::SMSG_LFG_PLAYER_INFO:
+        case Opcode::SMSG_LFG_PARTY_INFO:
+        case Opcode::SMSG_OPEN_LFG_DUNGEON_FINDER:
+            // Informational LFG packets not yet surfaced in UI — consume silently.
+            packet.setReadPos(packet.getSize());
+            break;
+
+        case Opcode::SMSG_ARENA_TEAM_COMMAND_RESULT:
+            handleArenaTeamCommandResult(packet);
+            break;
+        case Opcode::SMSG_ARENA_TEAM_QUERY_RESPONSE:
+            handleArenaTeamQueryResponse(packet);
+            break;
+        case Opcode::SMSG_ARENA_TEAM_ROSTER:
+            LOG_INFO("Received SMSG_ARENA_TEAM_ROSTER");
+            break;
+        case Opcode::SMSG_ARENA_TEAM_INVITE:
+            handleArenaTeamInvite(packet);
+            break;
+        case Opcode::SMSG_ARENA_TEAM_EVENT:
+            handleArenaTeamEvent(packet);
+            break;
+        case Opcode::SMSG_ARENA_TEAM_STATS:
+            LOG_INFO("Received SMSG_ARENA_TEAM_STATS");
+            break;
+        case Opcode::SMSG_ARENA_ERROR:
+            handleArenaError(packet);
+            break;
+        case Opcode::MSG_PVP_LOG_DATA:
+            LOG_INFO("Received MSG_PVP_LOG_DATA");
+            break;
+        case Opcode::MSG_INSPECT_ARENA_TEAMS:
+            LOG_INFO("Received MSG_INSPECT_ARENA_TEAMS");
+            break;
+        case Opcode::MSG_TALENT_WIPE_CONFIRM:
+            // Talent reset confirmation payload is not needed client-side right now.
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- MSG_MOVE_* opcodes (server relays other players' movement) ----
+        case Opcode::MSG_MOVE_START_FORWARD:
+        case Opcode::MSG_MOVE_START_BACKWARD:
+        case Opcode::MSG_MOVE_STOP:
+        case Opcode::MSG_MOVE_START_STRAFE_LEFT:
+        case Opcode::MSG_MOVE_START_STRAFE_RIGHT:
+        case Opcode::MSG_MOVE_STOP_STRAFE:
+        case Opcode::MSG_MOVE_JUMP:
+        case Opcode::MSG_MOVE_START_TURN_LEFT:
+        case Opcode::MSG_MOVE_START_TURN_RIGHT:
+        case Opcode::MSG_MOVE_STOP_TURN:
+        case Opcode::MSG_MOVE_SET_FACING:
+        case Opcode::MSG_MOVE_FALL_LAND:
+        case Opcode::MSG_MOVE_HEARTBEAT:
+        case Opcode::MSG_MOVE_START_SWIM:
+        case Opcode::MSG_MOVE_STOP_SWIM:
+            if (state == WorldState::IN_WORLD) {
+                handleOtherPlayerMovement(packet);
+            }
+            break;
+
+        // ---- Mail ----
+        case Opcode::SMSG_SHOW_MAILBOX:
+            handleShowMailbox(packet);
+            break;
+        case Opcode::SMSG_MAIL_LIST_RESULT:
+            handleMailListResult(packet);
+            break;
+        case Opcode::SMSG_SEND_MAIL_RESULT:
+            handleSendMailResult(packet);
+            break;
+        case Opcode::SMSG_RECEIVED_MAIL:
+            handleReceivedMail(packet);
+            break;
+        case Opcode::MSG_QUERY_NEXT_MAIL_TIME:
+            handleQueryNextMailTime(packet);
+            break;
+        case Opcode::SMSG_CHANNEL_LIST:
+            // Channel member listing currently not rendered in UI.
+            packet.setReadPos(packet.getSize());
+            break;
+        case Opcode::SMSG_INSPECT_RESULTS_UPDATE:
+            handleInspectResults(packet);
+            break;
+
+        // ---- Bank ----
+        case Opcode::SMSG_SHOW_BANK:
+            handleShowBank(packet);
+            break;
+        case Opcode::SMSG_BUY_BANK_SLOT_RESULT:
+            handleBuyBankSlotResult(packet);
+            break;
+
+        // ---- Guild Bank ----
+        case Opcode::SMSG_GUILD_BANK_LIST:
+            handleGuildBankList(packet);
+            break;
+
+        // ---- Auction House ----
+        case Opcode::MSG_AUCTION_HELLO:
+            handleAuctionHello(packet);
+            break;
+        case Opcode::SMSG_AUCTION_LIST_RESULT:
+            handleAuctionListResult(packet);
+            break;
+        case Opcode::SMSG_AUCTION_OWNER_LIST_RESULT:
+            handleAuctionOwnerListResult(packet);
+            break;
+        case Opcode::SMSG_AUCTION_BIDDER_LIST_RESULT:
+            handleAuctionBidderListResult(packet);
+            break;
+        case Opcode::SMSG_AUCTION_COMMAND_RESULT:
+            handleAuctionCommandResult(packet);
+            break;
+        case Opcode::SMSG_AUCTION_OWNER_NOTIFICATION: {
+            // auctionId(u32) + action(u32) + error(u32) + itemEntry(u32) + ...
+            if (packet.getSize() - packet.getReadPos() >= 16) {
+                uint32_t auctionId = packet.readUInt32();
+                uint32_t action = packet.readUInt32();
+                uint32_t error = packet.readUInt32();
+                uint32_t itemEntry = packet.readUInt32();
+                (void)auctionId; (void)action; (void)error;
+                ensureItemInfo(itemEntry);
+                auto* info = getItemInfo(itemEntry);
+                std::string itemName = info ? info->name : ("Item #" + std::to_string(itemEntry));
+                addSystemChatMessage("Your auction of " + itemName + " has sold!");
+            }
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+        case Opcode::SMSG_AUCTION_BIDDER_NOTIFICATION: {
+            // auctionId(u32) + itemEntry(u32) + ...
+            if (packet.getSize() - packet.getReadPos() >= 8) {
+                uint32_t auctionId = packet.readUInt32();
+                uint32_t itemEntry = packet.readUInt32();
+                (void)auctionId;
+                ensureItemInfo(itemEntry);
+                auto* info = getItemInfo(itemEntry);
+                std::string itemName = info ? info->name : ("Item #" + std::to_string(itemEntry));
+                addSystemChatMessage("You have been outbid on " + itemName + ".");
+            }
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+        case Opcode::SMSG_AUCTION_REMOVED_NOTIFICATION: {
+            // uint32 auctionId + uint32 itemEntry + uint32 itemRandom — auction expired/cancelled
+            if (packet.getSize() - packet.getReadPos() >= 12) {
+                /*uint32_t auctionId =*/ packet.readUInt32();
+                uint32_t itemEntry = packet.readUInt32();
+                /*uint32_t itemRandom =*/ packet.readUInt32();
+                ensureItemInfo(itemEntry);
+                auto* info = getItemInfo(itemEntry);
+                std::string itemName = info ? info->name : ("Item #" + std::to_string(itemEntry));
+                addSystemChatMessage("Your auction of " + itemName + " has expired.");
+            }
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+        case Opcode::SMSG_OPEN_CONTAINER: {
+            // uint64 containerGuid — tells client to open this container
+            // The actual items come via update packets; we just log this.
+            if (packet.getSize() - packet.getReadPos() >= 8) {
+                uint64_t containerGuid = packet.readUInt64();
+                LOG_DEBUG("SMSG_OPEN_CONTAINER: guid=0x", std::hex, containerGuid, std::dec);
+            }
+            break;
+        }
+        case Opcode::SMSG_GM_TICKET_STATUS_UPDATE:
+            // GM ticket status (new/updated); no ticket UI yet
+            packet.setReadPos(packet.getSize());
+            break;
+        case Opcode::SMSG_PLAYER_VEHICLE_DATA:
+            // Vehicle data update for player in vehicle; no vehicle UI yet
+            packet.setReadPos(packet.getSize());
+            break;
+        case Opcode::SMSG_SET_EXTRA_AURA_INFO_NEED_UPDATE:
+            packet.setReadPos(packet.getSize());
+            break;
+        case Opcode::SMSG_TAXINODE_STATUS: {
+            // guid(8) + status(1): status 1 = NPC has available/new routes for this player
+            if (packet.getSize() - packet.getReadPos() >= 9) {
+                uint64_t npcGuid = packet.readUInt64();
+                uint8_t  status  = packet.readUInt8();
+                taxiNpcHasRoutes_[npcGuid] = (status != 0);
+            }
+            break;
+        }
+        case Opcode::SMSG_INIT_EXTRA_AURA_INFO_OBSOLETE:
+        case Opcode::SMSG_SET_EXTRA_AURA_INFO_OBSOLETE:
+            // Extra aura metadata (icons/durations) not yet consumed by aura UI.
+            packet.setReadPos(packet.getSize());
+            break;
+        case Opcode::MSG_MOVE_WORLDPORT_ACK:
+            // Client uses this outbound; treat inbound variant as no-op for robustness.
+            packet.setReadPos(packet.getSize());
+            break;
+        case Opcode::MSG_MOVE_TIME_SKIPPED:
+            // Observed custom server packet (8 bytes). Safe-consume for now.
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Logout cancel ACK ----
+        case Opcode::SMSG_LOGOUT_CANCEL_ACK:
+            // loggingOut_ already cleared by cancelLogout(); this is server's confirmation
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Guild decline ----
+        case Opcode::SMSG_GUILD_DECLINE: {
+            if (packet.getReadPos() < packet.getSize()) {
+                std::string name = packet.readString();
+                addSystemChatMessage(name + " declined your guild invitation.");
+            }
+            break;
+        }
+
+        // ---- Talents involuntarily reset ----
+        case Opcode::SMSG_TALENTS_INVOLUNTARILY_RESET:
+            addSystemChatMessage("Your talents have been reset by the server.");
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Account data sync ----
+        case Opcode::SMSG_UPDATE_ACCOUNT_DATA:
+        case Opcode::SMSG_UPDATE_ACCOUNT_DATA_COMPLETE:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Rest state ----
+        case Opcode::SMSG_SET_REST_START: {
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t restTrigger = packet.readUInt32();
+                addSystemChatMessage(restTrigger > 0 ? "You are now resting."
+                                                     : "You are no longer resting.");
+            }
+            break;
+        }
+
+        // ---- Aura duration update ----
+        case Opcode::SMSG_UPDATE_AURA_DURATION: {
+            if (packet.getSize() - packet.getReadPos() >= 5) {
+                uint8_t slot       = packet.readUInt8();
+                uint32_t durationMs = packet.readUInt32();
+                handleUpdateAuraDuration(slot, durationMs);
+            }
+            break;
+        }
+
+        // ---- Item name query response ----
+        case Opcode::SMSG_ITEM_NAME_QUERY_RESPONSE: {
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t itemId = packet.readUInt32();
+                std::string name = packet.readString();
+                if (!itemInfoCache_.count(itemId) && !name.empty()) {
+                    ItemQueryResponseData stub;
+                    stub.entry = itemId;
+                    stub.name  = std::move(name);
+                    stub.valid = true;
+                    itemInfoCache_[itemId] = std::move(stub);
+                }
+            }
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+
+        // ---- Mount special animation ----
+        case Opcode::SMSG_MOUNTSPECIAL_ANIM:
+            (void)UpdateObjectParser::readPackedGuid(packet);
+            break;
+
+        // ---- Character customisation / faction change results ----
+        case Opcode::SMSG_CHAR_CUSTOMIZE: {
+            if (packet.getSize() - packet.getReadPos() >= 1) {
+                uint8_t result = packet.readUInt8();
+                addSystemChatMessage(result == 0 ? "Character customization complete."
+                                                 : "Character customization failed.");
+            }
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+        case Opcode::SMSG_CHAR_FACTION_CHANGE: {
+            if (packet.getSize() - packet.getReadPos() >= 1) {
+                uint8_t result = packet.readUInt8();
+                addSystemChatMessage(result == 0 ? "Faction change complete."
+                                                 : "Faction change failed.");
+            }
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+
+        // ---- Invalidate cached player data ----
+        case Opcode::SMSG_INVALIDATE_PLAYER: {
+            if (packet.getSize() - packet.getReadPos() >= 8) {
+                uint64_t guid = packet.readUInt64();
+                playerNameCache.erase(guid);
+            }
+            break;
+        }
+
+        // ---- Movie trigger ----
+        case Opcode::SMSG_TRIGGER_MOVIE:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Equipment sets ----
+        case Opcode::SMSG_EQUIPMENT_SET_LIST:
+            handleEquipmentSetList(packet);
+            break;
+        case Opcode::SMSG_EQUIPMENT_SET_USE_RESULT: {
+            if (packet.getSize() - packet.getReadPos() >= 1) {
+                uint8_t result = packet.readUInt8();
+                if (result != 0) addSystemChatMessage("Failed to equip item set.");
+            }
+            break;
+        }
+
+        // ---- LFG informational (not yet surfaced in UI) ----
+        case Opcode::SMSG_LFG_UPDATE:
+        case Opcode::SMSG_LFG_UPDATE_LFG:
+        case Opcode::SMSG_LFG_UPDATE_LFM:
+        case Opcode::SMSG_LFG_UPDATE_QUEUED:
+        case Opcode::SMSG_LFG_PENDING_INVITE:
+        case Opcode::SMSG_LFG_PENDING_MATCH:
+        case Opcode::SMSG_LFG_PENDING_MATCH_DONE:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- GM Ticket responses ----
+        case Opcode::SMSG_GMTICKET_CREATE: {
+            if (packet.getSize() - packet.getReadPos() >= 1) {
+                uint8_t res = packet.readUInt8();
+                addSystemChatMessage(res == 1 ? "GM ticket submitted."
+                                              : "Failed to submit GM ticket.");
+            }
+            break;
+        }
+        case Opcode::SMSG_GMTICKET_UPDATETEXT: {
+            if (packet.getSize() - packet.getReadPos() >= 1) {
+                uint8_t res = packet.readUInt8();
+                addSystemChatMessage(res == 1 ? "GM ticket updated."
+                                              : "Failed to update GM ticket.");
+            }
+            break;
+        }
+        case Opcode::SMSG_GMTICKET_DELETETICKET: {
+            if (packet.getSize() - packet.getReadPos() >= 1) {
+                uint8_t res = packet.readUInt8();
+                addSystemChatMessage(res == 9 ? "GM ticket deleted."
+                                              : "No ticket to delete.");
+            }
+            break;
+        }
+        case Opcode::SMSG_GMTICKET_GETTICKET:
+        case Opcode::SMSG_GMTICKET_SYSTEMSTATUS:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- DK rune tracking ----
+        case Opcode::SMSG_CONVERT_RUNE: {
+            // uint8 runeIndex + uint8 newRuneType (0=Blood,1=Unholy,2=Frost,3=Death)
+            if (packet.getSize() - packet.getReadPos() < 2) {
+                packet.setReadPos(packet.getSize());
+                break;
+            }
+            uint8_t idx  = packet.readUInt8();
+            uint8_t type = packet.readUInt8();
+            if (idx < 6) playerRunes_[idx].type = static_cast<RuneType>(type & 0x3);
+            break;
+        }
+        case Opcode::SMSG_RESYNC_RUNES: {
+            // uint8 runeReadyMask (bit i=1 → rune i is ready)
+            // uint8[6] cooldowns (0=ready, 255=just used → readyFraction = 1 - val/255)
+            if (packet.getSize() - packet.getReadPos() < 7) {
+                packet.setReadPos(packet.getSize());
+                break;
+            }
+            uint8_t readyMask = packet.readUInt8();
+            for (int i = 0; i < 6; i++) {
+                uint8_t cd = packet.readUInt8();
+                playerRunes_[i].ready = (readyMask & (1u << i)) != 0;
+                playerRunes_[i].readyFraction = 1.0f - cd / 255.0f;
+                if (playerRunes_[i].ready) playerRunes_[i].readyFraction = 1.0f;
+            }
+            break;
+        }
+        case Opcode::SMSG_ADD_RUNE_POWER: {
+            // uint32 runeMask (bit i=1 → rune i just became ready)
+            if (packet.getSize() - packet.getReadPos() < 4) {
+                packet.setReadPos(packet.getSize());
+                break;
+            }
+            uint32_t runeMask = packet.readUInt32();
+            for (int i = 0; i < 6; i++) {
+                if (runeMask & (1u << i)) {
+                    playerRunes_[i].ready = true;
+                    playerRunes_[i].readyFraction = 1.0f;
+                }
+            }
+            break;
+        }
+
+        // ---- Spell combat logs (consume) ----
+        case Opcode::SMSG_AURACASTLOG:
+        case Opcode::SMSG_SPELLBREAKLOG:
+        case Opcode::SMSG_SPELLDAMAGESHIELD: {
+            // victimGuid(8) + casterGuid(8) + spellId(4) + damage(4) + schoolMask(4)
+            if (packet.getSize() - packet.getReadPos() < 24) {
+                packet.setReadPos(packet.getSize()); break;
+            }
+            uint64_t victimGuid  = packet.readUInt64();
+            uint64_t casterGuid  = packet.readUInt64();
+            /*uint32_t spellId =*/ packet.readUInt32();
+            uint32_t damage      = packet.readUInt32();
+            /*uint32_t school =*/  packet.readUInt32();
+            // Show combat text: damage shield reflect
+            if (casterGuid == playerGuid) {
+                // We have a damage shield that reflected damage
+                addCombatText(CombatTextEntry::SPELL_DAMAGE, static_cast<int32_t>(damage), 0, true);
+            } else if (victimGuid == playerGuid) {
+                // A damage shield hit us (e.g. target's Thorns)
+                addCombatText(CombatTextEntry::SPELL_DAMAGE, static_cast<int32_t>(damage), 0, false);
+            }
+            break;
+        }
+        case Opcode::SMSG_SPELLORDAMAGE_IMMUNE: {
+            // casterGuid(packed) + victimGuid(packed) + uint32 spellId + uint8 saveType
+            if (packet.getSize() - packet.getReadPos() < 2) {
+                packet.setReadPos(packet.getSize()); break;
+            }
+            uint64_t casterGuid = UpdateObjectParser::readPackedGuid(packet);
+            if (packet.getSize() - packet.getReadPos() < 2) break;
+            uint64_t victimGuid = UpdateObjectParser::readPackedGuid(packet);
+            if (packet.getSize() - packet.getReadPos() < 5) break;
+            /*uint32_t spellId =*/ packet.readUInt32();
+            /*uint8_t saveType =*/ packet.readUInt8();
+            // Show IMMUNE text when the player is the caster (we hit an immune target)
+            // or the victim (we are immune)
+            if (casterGuid == playerGuid || victimGuid == playerGuid) {
+                addCombatText(CombatTextEntry::IMMUNE, 0, 0,
+                              casterGuid == playerGuid);
+            }
+            break;
+        }
+        case Opcode::SMSG_SPELLDISPELLOG: {
+            // packed casterGuid + packed victimGuid + uint32 dispelSpell + uint8 isStolen
+            // + uint32 count + count × (uint32 dispelled_spellId + uint32 unk)
+            if (packet.getSize() - packet.getReadPos() < 2) {
+                packet.setReadPos(packet.getSize()); break;
+            }
+            uint64_t casterGuid = UpdateObjectParser::readPackedGuid(packet);
+            if (packet.getSize() - packet.getReadPos() < 2) break;
+            uint64_t victimGuid = UpdateObjectParser::readPackedGuid(packet);
+            if (packet.getSize() - packet.getReadPos() < 9) break;
+            /*uint32_t dispelSpell =*/ packet.readUInt32();
+            uint8_t isStolen = packet.readUInt8();
+            uint32_t count   = packet.readUInt32();
+            // Show system message if player was victim or caster
+            if (victimGuid == playerGuid || casterGuid == playerGuid) {
+                const char* verb = isStolen ? "stolen" : "dispelled";
+                // Collect first dispelled spell name for the message
+                std::string firstSpellName;
+                for (uint32_t i = 0; i < count && packet.getSize() - packet.getReadPos() >= 8; ++i) {
+                    uint32_t dispelledId = packet.readUInt32();
+                    /*uint32_t unk =*/ packet.readUInt32();
+                    if (i == 0) {
+                        const std::string& nm = getSpellName(dispelledId);
+                        firstSpellName = nm.empty() ? ("spell " + std::to_string(dispelledId)) : nm;
+                    }
+                }
+                if (!firstSpellName.empty()) {
+                    char buf[256];
+                    if (victimGuid == playerGuid && casterGuid != playerGuid)
+                        std::snprintf(buf, sizeof(buf), "%s was %s.", firstSpellName.c_str(), verb);
+                    else if (casterGuid == playerGuid)
+                        std::snprintf(buf, sizeof(buf), "You %s %s.", verb, firstSpellName.c_str());
+                    else
+                        std::snprintf(buf, sizeof(buf), "%s %s.", firstSpellName.c_str(), verb);
+                    addSystemChatMessage(buf);
+                }
+            }
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+        case Opcode::SMSG_SPELLSTEALLOG: {
+            // Similar to SPELLDISPELLOG but always isStolen=true; same wire format
+            // Just consume — SPELLDISPELLOG handles the player-facing case above
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+        case Opcode::SMSG_SPELLINSTAKILLLOG:
+        case Opcode::SMSG_SPELLLOGEXECUTE:
+        case Opcode::SMSG_SPELL_CHANCE_PROC_LOG:
+        case Opcode::SMSG_SPELL_CHANCE_RESIST_PUSHBACK:
+        case Opcode::SMSG_SPELL_UPDATE_CHAIN_TARGETS:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Misc consume ----
+        case Opcode::SMSG_CLEAR_EXTRA_AURA_INFO:
+        case Opcode::SMSG_COMPLAIN_RESULT:
+        case Opcode::SMSG_ITEM_REFUND_INFO_RESPONSE:
+        case Opcode::SMSG_ITEM_ENCHANT_TIME_UPDATE:
+        case Opcode::SMSG_LOOT_LIST:
+        case Opcode::SMSG_RESUME_CAST_BAR: {
+            // packed_guid caster + packed_guid target + uint32 spellId
+            // + uint32 remainingMs + uint32 totalMs + uint8 schoolMask
+            auto remaining = [&]() { return packet.getSize() - packet.getReadPos(); };
+            if (remaining() < 1) break;
+            uint64_t caster = UpdateObjectParser::readPackedGuid(packet);
+            if (remaining() < 1) break;
+            (void)UpdateObjectParser::readPackedGuid(packet); // target
+            if (remaining() < 12) break;
+            uint32_t spellId   = packet.readUInt32();
+            uint32_t remainMs  = packet.readUInt32();
+            uint32_t totalMs   = packet.readUInt32();
+            if (caster == playerGuid && totalMs > 0) {
+                casting              = true;
+                currentCastSpellId   = spellId;
+                castTimeTotal        = totalMs   / 1000.0f;
+                castTimeRemaining    = remainMs  / 1000.0f;
+                LOG_DEBUG("SMSG_RESUME_CAST_BAR: spell=", spellId,
+                          " remaining=", remainMs, "ms total=", totalMs, "ms");
+            }
+            break;
+        }
+        case Opcode::SMSG_THREAT_UPDATE: {
+            // packed_guid (unit) + packed_guid (target) + uint32 count
+            // + count × (packed_guid victim + uint32 threat) — consume to suppress warnings
+            if (packet.getSize() - packet.getReadPos() < 1) break;
+            (void)UpdateObjectParser::readPackedGuid(packet);
+            if (packet.getSize() - packet.getReadPos() < 1) break;
+            (void)UpdateObjectParser::readPackedGuid(packet);
+            if (packet.getSize() - packet.getReadPos() < 4) break;
+            uint32_t cnt = packet.readUInt32();
+            for (uint32_t i = 0; i < cnt && packet.getSize() - packet.getReadPos() >= 1; ++i) {
+                (void)UpdateObjectParser::readPackedGuid(packet);
+                if (packet.getSize() - packet.getReadPos() >= 4)
+                    packet.readUInt32();
+            }
+            break;
+        }
+        case Opcode::SMSG_UPDATE_INSTANCE_ENCOUNTER_UNIT: {
+            // uint32 slot + packed_guid unit (0 packed = clear slot)
+            if (packet.getSize() - packet.getReadPos() < 5) {
+                packet.setReadPos(packet.getSize());
+                break;
+            }
+            uint32_t slot = packet.readUInt32();
+            uint64_t unit = UpdateObjectParser::readPackedGuid(packet);
+            if (slot < kMaxEncounterSlots) {
+                encounterUnitGuids_[slot] = unit;
+                LOG_DEBUG("SMSG_UPDATE_INSTANCE_ENCOUNTER_UNIT: slot=", slot,
+                          " guid=0x", std::hex, unit, std::dec);
+            }
+            break;
+        }
+        case Opcode::SMSG_UPDATE_INSTANCE_OWNERSHIP:
+        case Opcode::SMSG_UPDATE_LAST_INSTANCE:
+        case Opcode::SMSG_SEND_ALL_COMBAT_LOG:
+        case Opcode::SMSG_SET_PROJECTILE_POSITION:
+        case Opcode::SMSG_AUCTION_LIST_PENDING_SALES:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Server-first achievement broadcast ----
+        case Opcode::SMSG_SERVER_FIRST_ACHIEVEMENT: {
+            // charName (cstring) + guid (uint64) + achievementId (uint32) + ...
+            if (packet.getReadPos() < packet.getSize()) {
+                std::string charName = packet.readString();
+                if (packet.getSize() - packet.getReadPos() >= 12) {
+                    /*uint64_t guid =*/ packet.readUInt64();
+                    uint32_t achievementId = packet.readUInt32();
+                    loadAchievementNameCache();
+                    auto nit = achievementNameCache_.find(achievementId);
+                    char buf[256];
+                    if (nit != achievementNameCache_.end() && !nit->second.empty()) {
+                        std::snprintf(buf, sizeof(buf),
+                            "%s is the first on the realm to earn: %s!",
+                            charName.c_str(), nit->second.c_str());
+                    } else {
+                        std::snprintf(buf, sizeof(buf),
+                            "%s is the first on the realm to earn achievement #%u!",
+                            charName.c_str(), achievementId);
+                    }
+                    addSystemChatMessage(buf);
+                }
+            }
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+
+        // ---- Forced faction reactions ----
+        case Opcode::SMSG_SET_FORCED_REACTIONS:
+            handleSetForcedReactions(packet);
+            break;
+
+        // ---- Spline speed changes for other units ----
+        case Opcode::SMSG_SPLINE_SET_FLIGHT_SPEED:
+        case Opcode::SMSG_SPLINE_SET_FLIGHT_BACK_SPEED:
+        case Opcode::SMSG_SPLINE_SET_SWIM_BACK_SPEED:
+        case Opcode::SMSG_SPLINE_SET_WALK_SPEED:
+        case Opcode::SMSG_SPLINE_SET_TURN_RATE:
+        case Opcode::SMSG_SPLINE_SET_PITCH_RATE:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Spline move flag changes for other units ----
+        case Opcode::SMSG_SPLINE_MOVE_UNROOT:
+        case Opcode::SMSG_SPLINE_MOVE_UNSET_FLYING:
+        case Opcode::SMSG_SPLINE_MOVE_UNSET_HOVER:
+        case Opcode::SMSG_SPLINE_MOVE_WATER_WALK:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Quest failure notification ----
+        case Opcode::SMSG_QUESTGIVER_QUEST_FAILED: {
+            // uint32 questId + uint32 reason
+            if (packet.getSize() - packet.getReadPos() >= 8) {
+                /*uint32_t questId =*/ packet.readUInt32();
+                uint32_t reason = packet.readUInt32();
+                const char* reasonStr = "Unknown reason";
+                switch (reason) {
+                    case 1: reasonStr = "Quest failed: failed conditions"; break;
+                    case 2: reasonStr = "Quest failed: inventory full"; break;
+                    case 3: reasonStr = "Quest failed: too far away"; break;
+                    case 4: reasonStr = "Quest failed: another quest is blocking"; break;
+                    case 5: reasonStr = "Quest failed: wrong time of day"; break;
+                    case 6: reasonStr = "Quest failed: wrong race"; break;
+                    case 7: reasonStr = "Quest failed: wrong class"; break;
+                }
+                addSystemChatMessage(reasonStr);
+            }
+            break;
+        }
+
+        // ---- Suspend comms (requires ACK) ----
+        case Opcode::SMSG_SUSPEND_COMMS: {
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t seqIdx = packet.readUInt32();
+                if (socket) {
+                    network::Packet ack(wireOpcode(Opcode::CMSG_SUSPEND_COMMS_ACK));
+                    ack.writeUInt32(seqIdx);
+                    socket->send(ack);
+                }
+            }
+            break;
+        }
+
+        // ---- Pre-resurrect state ----
+        case Opcode::SMSG_PRE_RESURRECT: {
+            // packed GUID of the player to enter pre-resurrect
+            (void)UpdateObjectParser::readPackedGuid(packet);
+            break;
+        }
+
+        // ---- Hearthstone bind error ----
+        case Opcode::SMSG_PLAYERBINDERROR: {
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t error = packet.readUInt32();
+                if (error == 0)
+                    addSystemChatMessage("Your hearthstone is not bound.");
+                else
+                    addSystemChatMessage("Hearthstone bind failed.");
+            }
+            break;
+        }
+
+        // ---- Instance/raid errors ----
+        case Opcode::SMSG_RAID_GROUP_ONLY: {
+            addSystemChatMessage("You must be in a raid group to enter this instance.");
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+        case Opcode::SMSG_RAID_READY_CHECK_ERROR: {
+            if (packet.getSize() - packet.getReadPos() >= 1) {
+                uint8_t err = packet.readUInt8();
+                if (err == 0) addSystemChatMessage("Ready check failed: not in a group.");
+                else if (err == 1) addSystemChatMessage("Ready check failed: in instance.");
+                else addSystemChatMessage("Ready check failed.");
+            }
+            break;
+        }
+        case Opcode::SMSG_RESET_FAILED_NOTIFY: {
+            addSystemChatMessage("Cannot reset instance: another player is still inside.");
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+
+        // ---- Realm split ----
+        case Opcode::SMSG_REALM_SPLIT: {
+            // uint32 splitType + uint32 deferTime + string realmName
+            // Client must respond with CMSG_REALM_SPLIT to avoid session timeout on some servers.
+            uint32_t splitType = 0;
+            if (packet.getSize() - packet.getReadPos() >= 4)
+                splitType = packet.readUInt32();
+            packet.setReadPos(packet.getSize());
+            if (socket) {
+                network::Packet resp(wireOpcode(Opcode::CMSG_REALM_SPLIT));
+                resp.writeUInt32(splitType);
+                resp.writeString("3.3.5");
+                socket->send(resp);
+                LOG_DEBUG("SMSG_REALM_SPLIT splitType=", splitType, " — sent CMSG_REALM_SPLIT ack");
+            }
+            break;
+        }
+
+        // ---- Real group update (status flags) ----
+        case Opcode::SMSG_REAL_GROUP_UPDATE:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Play music (WotLK standard opcode) ----
+        case Opcode::SMSG_PLAY_MUSIC: {
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t soundId = packet.readUInt32();
+                if (playMusicCallback_) playMusicCallback_(soundId);
+            }
+            break;
+        }
+
+        // ---- Play object/spell sounds ----
+        case Opcode::SMSG_PLAY_OBJECT_SOUND:
+        case Opcode::SMSG_PLAY_SPELL_IMPACT:
+            if (packet.getSize() - packet.getReadPos() >= 12) {
+                // uint32 soundId + uint64 sourceGuid
+                uint32_t soundId   = packet.readUInt32();
+                uint64_t srcGuid   = packet.readUInt64();
+                LOG_DEBUG("SMSG_PLAY_OBJECT_SOUND/SPELL_IMPACT id=", soundId, " src=0x", std::hex, srcGuid, std::dec);
+                if (playPositionalSoundCallback_) playPositionalSoundCallback_(soundId, srcGuid);
+                else if (playSoundCallback_) playSoundCallback_(soundId);
+            } else if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t soundId = packet.readUInt32();
+                if (playSoundCallback_) playSoundCallback_(soundId);
+            }
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Resistance/combat log ----
+        case Opcode::SMSG_RESISTLOG:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Read item results ----
+        case Opcode::SMSG_READ_ITEM_OK:
+            addSystemChatMessage("You read the item.");
+            packet.setReadPos(packet.getSize());
+            break;
+        case Opcode::SMSG_READ_ITEM_FAILED:
+            addSystemChatMessage("You cannot read this item.");
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Completed quests query ----
+        case Opcode::SMSG_QUERY_QUESTS_COMPLETED_RESPONSE: {
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t count = packet.readUInt32();
+                if (count <= 4096) {
+                    for (uint32_t i = 0; i < count; ++i) {
+                        if (packet.getSize() - packet.getReadPos() < 4) break;
+                        uint32_t questId = packet.readUInt32();
+                        completedQuests_.insert(questId);
+                    }
+                    LOG_DEBUG("SMSG_QUERY_QUESTS_COMPLETED_RESPONSE: ", count, " completed quests");
+                }
+            }
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+
+        // ---- PVP quest kill update ----
+        case Opcode::SMSG_QUESTUPDATE_ADD_PVP_KILL: {
+            // uint64 guid + uint32 questId + uint32 killCount
+            if (packet.getSize() - packet.getReadPos() >= 16) {
+                /*uint64_t guid =*/ packet.readUInt64();
+                uint32_t questId = packet.readUInt32();
+                uint32_t count   = packet.readUInt32();
+                char buf[64];
+                std::snprintf(buf, sizeof(buf), "PVP kill counted for quest #%u (%u).",
+                              questId, count);
+                addSystemChatMessage(buf);
+            }
+            break;
+        }
+
+        // ---- NPC not responding ----
+        case Opcode::SMSG_NPC_WONT_TALK:
+            addSystemChatMessage("That creature can't talk to you right now.");
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Petition ----
+        case Opcode::SMSG_OFFER_PETITION_ERROR: {
+            if (packet.getSize() - packet.getReadPos() >= 4) {
+                uint32_t err = packet.readUInt32();
+                if (err == 1) addSystemChatMessage("Player is already in a guild.");
+                else if (err == 2) addSystemChatMessage("Player already has a petition.");
+                else addSystemChatMessage("Cannot offer petition to that player.");
+            }
+            break;
+        }
+        case Opcode::SMSG_PETITION_QUERY_RESPONSE:
+        case Opcode::SMSG_PETITION_SHOW_SIGNATURES:
+        case Opcode::SMSG_PETITION_SIGN_RESULTS:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Pet system (not yet implemented) ----
+        case Opcode::SMSG_PET_GUIDS:
+        case Opcode::SMSG_PET_MODE:
+        case Opcode::SMSG_PET_BROKEN:
+        case Opcode::SMSG_PET_CAST_FAILED:
+        case Opcode::SMSG_PET_DISMISS_SOUND:
+        case Opcode::SMSG_PET_ACTION_SOUND:
+        case Opcode::SMSG_PET_LEARNED_SPELL:
+        case Opcode::SMSG_PET_UNLEARNED_SPELL:
+        case Opcode::SMSG_PET_UNLEARN_CONFIRM:
+        case Opcode::SMSG_PET_NAME_INVALID:
+        case Opcode::SMSG_PET_RENAMEABLE:
+        case Opcode::SMSG_PET_UPDATE_COMBO_POINTS:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Inspect (full character inspection) ----
+        case Opcode::SMSG_INSPECT:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Multiple aggregated packets/moves ----
+        case Opcode::SMSG_MULTIPLE_MOVES:
+            // Same wire format as SMSG_COMPRESSED_MOVES: uint8 size + uint16 opcode + payload[]
+            handleCompressedMoves(packet);
+            break;
+
+        case Opcode::SMSG_MULTIPLE_PACKETS: {
+            // Each sub-packet uses the standard WotLK server wire format:
+            //   uint16_be subSize  (includes the 2-byte opcode; payload = subSize - 2)
+            //   uint16_le subOpcode
+            //   payload  (subSize - 2 bytes)
+            const auto& pdata = packet.getData();
+            size_t dataLen = pdata.size();
+            size_t pos = packet.getReadPos();
+            static uint32_t multiPktWarnCount = 0;
+            while (pos + 4 <= dataLen) {
+                uint16_t subSize = static_cast<uint16_t>(
+                    (static_cast<uint16_t>(pdata[pos]) << 8) | pdata[pos + 1]);
+                if (subSize < 2) break;
+                size_t payloadLen = subSize - 2;
+                if (pos + 4 + payloadLen > dataLen) {
+                    if (++multiPktWarnCount <= 10) {
+                        LOG_WARNING("SMSG_MULTIPLE_PACKETS: sub-packet overruns buffer at pos=",
+                                    pos, " subSize=", subSize, " dataLen=", dataLen);
+                    }
+                    break;
+                }
+                uint16_t subOpcode = static_cast<uint16_t>(pdata[pos + 2]) |
+                                     (static_cast<uint16_t>(pdata[pos + 3]) << 8);
+                std::vector<uint8_t> subPayload(pdata.begin() + pos + 4,
+                                                pdata.begin() + pos + 4 + payloadLen);
+                network::Packet subPacket(subOpcode, std::move(subPayload));
+                handlePacket(subPacket);
+                pos += 4 + payloadLen;
+            }
+            packet.setReadPos(packet.getSize());
+            break;
+        }
+
+        // ---- Misc consume ----
+        case Opcode::SMSG_SET_PLAYER_DECLINED_NAMES_RESULT:
+        case Opcode::SMSG_PROPOSE_LEVEL_GRANT:
+        case Opcode::SMSG_REFER_A_FRIEND_EXPIRED:
+        case Opcode::SMSG_REFER_A_FRIEND_FAILURE:
+        case Opcode::SMSG_REPORT_PVP_AFK_RESULT:
+        case Opcode::SMSG_REDIRECT_CLIENT:
+        case Opcode::SMSG_PVP_QUEUE_STATS:
+        case Opcode::SMSG_NOTIFY_DEST_LOC_SPELL_CAST:
+        case Opcode::SMSG_RESPOND_INSPECT_ACHIEVEMENTS:
+        case Opcode::SMSG_PLAYER_SKINNED:
+        case Opcode::SMSG_QUEST_POI_QUERY_RESPONSE:
+        case Opcode::SMSG_ON_CANCEL_EXPECTED_RIDE_VEHICLE_AURA:
+        case Opcode::SMSG_RESET_RANGED_COMBAT_TIMER:
+        case Opcode::SMSG_PROFILEDATA_RESPONSE:
+        case Opcode::SMSG_PLAY_TIME_WARNING:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Item query multiple (same format as single, re-use handler) ----
+        case Opcode::SMSG_ITEM_QUERY_MULTIPLE_RESPONSE:
+            handleItemQueryResponse(packet);
+            break;
+
+        // ---- Object position/rotation queries ----
+        case Opcode::SMSG_QUERY_OBJECT_POSITION:
+        case Opcode::SMSG_QUERY_OBJECT_ROTATION:
+        case Opcode::SMSG_VOICESESSION_FULL:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        // ---- Player movement flag changes (server-pushed) ----
+        case Opcode::SMSG_MOVE_GRAVITY_DISABLE:
+        case Opcode::SMSG_MOVE_GRAVITY_ENABLE:
+        case Opcode::SMSG_MOVE_LAND_WALK:
+        case Opcode::SMSG_MOVE_NORMAL_FALL:
+        case Opcode::SMSG_MOVE_SET_CAN_TRANSITION_BETWEEN_SWIM_AND_FLY:
+        case Opcode::SMSG_MOVE_UNSET_CAN_TRANSITION_BETWEEN_SWIM_AND_FLY:
+        case Opcode::SMSG_MOVE_SET_COLLISION_HGT:
+        case Opcode::SMSG_MOVE_SET_FLIGHT:
+        case Opcode::SMSG_MOVE_UNSET_FLIGHT:
+            packet.setReadPos(packet.getSize());
+            break;
+
+        default:
+            // In pre-world states we need full visibility (char create/login handshakes).
+            // In-world we keep de-duplication to avoid heavy log I/O in busy areas.
+            if (state != WorldState::IN_WORLD) {
+                static std::unordered_set<uint32_t> loggedUnhandledByState;
+                const uint32_t key = (static_cast<uint32_t>(static_cast<uint8_t>(state)) << 16) |
+                                     static_cast<uint32_t>(opcode);
+                if (loggedUnhandledByState.insert(key).second) {
+                    LOG_WARNING("Unhandled world opcode: 0x", std::hex, opcode, std::dec,
+                                " state=", static_cast<int>(state),
+                                " size=", packet.getSize());
+                    const auto& data = packet.getData();
+                    std::string hex;
+                    size_t limit = std::min<size_t>(data.size(), 48);
+                    hex.reserve(limit * 3);
+                    for (size_t i = 0; i < limit; ++i) {
+                        char b[4];
+                        snprintf(b, sizeof(b), "%02x ", data[i]);
+                        hex += b;
+                    }
+                    LOG_INFO("Unhandled opcode payload hex (first ", limit, " bytes): ", hex);
+                }
+            } else {
+                static std::unordered_set<uint16_t> loggedUnhandledOpcodes;
+                if (loggedUnhandledOpcodes.insert(static_cast<uint16_t>(opcode)).second) {
+                    LOG_WARNING("Unhandled world opcode: 0x", std::hex, opcode, std::dec);
+                }
+            }
+            break;
     }
     } catch (const std::bad_alloc& e) {
         LOG_ERROR("OOM while handling world opcode=0x", std::hex, opcode, std::dec,
@@ -3687,90 +5144,6 @@ void GameHandler::handlePacket(network::Packet& packet) {
     }
 }
 
-void GameHandler::enqueueIncomingPacket(const network::Packet& packet) {
-    if (pendingIncomingPackets_.size() >= kMaxQueuedInboundPackets) {
-        LOG_ERROR("Inbound packet queue overflow (", pendingIncomingPackets_.size(),
-                  " packets); dropping oldest packet to preserve responsiveness");
-        pendingIncomingPackets_.pop_front();
-    }
-    pendingIncomingPackets_.push_back(packet);
-    lastRxTime_ = std::chrono::steady_clock::now();
-    rxSilenceLogged_ = false;
-    rxSilence15sLogged_ = false;
-}
-
-void GameHandler::enqueueIncomingPacketFront(network::Packet&& packet) {
-    if (pendingIncomingPackets_.size() >= kMaxQueuedInboundPackets) {
-        LOG_ERROR("Inbound packet queue overflow while prepending (", pendingIncomingPackets_.size(),
-                  " packets); dropping newest queued packet to preserve ordering");
-        pendingIncomingPackets_.pop_back();
-    }
-    pendingIncomingPackets_.emplace_front(std::move(packet));
-}
-
-// enqueueUpdateObjectWork and processPendingUpdateObjectWork moved to EntityController
-
-void GameHandler::processQueuedIncomingPackets() {
-    if (pendingIncomingPackets_.empty() && !entityController_->hasPendingUpdateObjectWork()) {
-        return;
-    }
-
-    const int maxPacketsThisUpdate = incomingPacketsBudgetPerUpdate(state);
-    const float budgetMs = incomingPacketBudgetMs(state);
-    const auto start = std::chrono::steady_clock::now();
-    int processed = 0;
-
-    while (processed < maxPacketsThisUpdate) {
-        float elapsedMs = std::chrono::duration<float, std::milli>(
-            std::chrono::steady_clock::now() - start).count();
-        if (elapsedMs >= budgetMs) {
-            break;
-        }
-
-        if (entityController_->hasPendingUpdateObjectWork()) {
-            entityController_->processPendingUpdateObjectWork(start, budgetMs);
-            if (entityController_->hasPendingUpdateObjectWork()) {
-                break;
-            }
-            continue;
-        }
-
-        if (pendingIncomingPackets_.empty()) {
-            break;
-        }
-
-        network::Packet packet = std::move(pendingIncomingPackets_.front());
-        pendingIncomingPackets_.pop_front();
-        const uint16_t wireOp = packet.getOpcode();
-        const auto logicalOp = opcodeTable_.fromWire(wireOp);
-        auto packetHandleStart = std::chrono::steady_clock::now();
-        handlePacket(packet);
-        float packetMs = std::chrono::duration<float, std::milli>(
-            std::chrono::steady_clock::now() - packetHandleStart).count();
-        if (packetMs > slowPacketLogThresholdMs()) {
-            const char* logicalName = logicalOp
-                ? OpcodeTable::logicalToName(*logicalOp)
-                : "UNKNOWN";
-            LOG_WARNING("SLOW packet handler: ", packetMs,
-                        "ms wire=0x", std::hex, wireOp, std::dec,
-                        " logical=", logicalName,
-                        " size=", packet.getSize(),
-                        " state=", worldStateName(state));
-        }
-        ++processed;
-    }
-
-    if (entityController_->hasPendingUpdateObjectWork()) {
-        return;
-    }
-
-    if (!pendingIncomingPackets_.empty()) {
-        LOG_DEBUG("GameHandler packet budget reached (processed=", processed,
-                  ", remaining=", pendingIncomingPackets_.size(),
-                  ", state=", worldStateName(state), ")");
-    }
-}
-
 void GameHandler::handleAuthChallenge(network::Packet& packet) {
     LOG_INFO("Handling SMSG_AUTH_CHALLENGE");
 
@@ -3824,7 +5197,7 @@ void GameHandler::sendAuthSession() {
 }
 
 void GameHandler::handleAuthResponse(network::Packet& packet) {
-    LOG_WARNING("Handling SMSG_AUTH_RESPONSE, size=", packet.getSize());
+    LOG_INFO("Handling SMSG_AUTH_RESPONSE");
 
     AuthResponseData response;
     if (!AuthResponseParser::parse(packet, response)) {
@@ -3927,7 +5300,7 @@ void GameHandler::handleCharEnum(network::Packet& packet) {
             LOG_INFO("      GUID: 0x", std::hex, character.guid, std::dec);
             LOG_INFO("      ", getRaceName(character.race), " ",
                      getClassName(character.characterClass));
-            LOG_INFO("      Level ", static_cast<int>(character.level));
+            LOG_INFO("      Level ", (int)character.level);
         }
     }
 
@@ -4056,6 +5429,19 @@ const Character* GameHandler::getFirstCharacter() const {
     return &characters.front();
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
 void GameHandler::handleCharLoginFailed(network::Packet& packet) {
     uint8_t reason = packet.readUInt8();
 
@@ -4072,7 +5458,7 @@ void GameHandler::handleCharLoginFailed(network::Packet& packet) {
     };
     const char* msg = (reason < 9) ? reasonNames[reason] : "Unknown reason";
 
-    LOG_ERROR("SMSG_CHARACTER_LOGIN_FAILED: reason=", static_cast<int>(reason), " (", msg, ")");
+    LOG_ERROR("SMSG_CHARACTER_LOGIN_FAILED: reason=", (int)reason, " (", msg, ")");
 
     // Allow the player to re-select a character
     setState(WorldState::CHAR_LIST_RECEIVED);
@@ -4084,7 +5470,7 @@ void GameHandler::handleCharLoginFailed(network::Packet& packet) {
 
 void GameHandler::selectCharacter(uint64_t characterGuid) {
     if (state != WorldState::CHAR_LIST_RECEIVED) {
-        LOG_WARNING("Cannot select character in state: ", static_cast<int>(state));
+        LOG_WARNING("Cannot select character in state: ", (int)state);
         return;
     }
 
@@ -4101,7 +5487,7 @@ void GameHandler::selectCharacter(uint64_t characterGuid) {
     for (const auto& character : characters) {
         if (character.guid == characterGuid) {
             LOG_INFO("Character: ", character.name);
-            LOG_INFO("Level ", static_cast<int>(character.level), " ",
+            LOG_INFO("Level ", (int)character.level, " ",
                      getRaceName(character.race), " ",
                      getClassName(character.characterClass));
             playerRace_ = character.race;
@@ -4119,35 +5505,18 @@ void GameHandler::selectCharacter(uint64_t characterGuid) {
     pendingItemQueries_.clear();
     equipSlotGuids_ = {};
     backpackSlotGuids_ = {};
-    keyringSlotGuids_ = {};
     invSlotBase_ = -1;
     packSlotBase_ = -1;
     lastPlayerFields_.clear();
     onlineEquipDirty_ = false;
     playerMoneyCopper_ = 0;
     playerArmorRating_ = 0;
-    std::fill(std::begin(playerResistances_), std::end(playerResistances_), 0);
-    std::fill(std::begin(playerStats_), std::end(playerStats_), -1);
-    playerMeleeAP_ = -1;
-    playerRangedAP_ = -1;
-    std::fill(std::begin(playerSpellDmgBonus_), std::end(playerSpellDmgBonus_), -1);
-    playerHealBonus_ = -1;
-    playerDodgePct_ = -1.0f;
-    playerParryPct_ = -1.0f;
-    playerBlockPct_ = -1.0f;
-    playerCritPct_  = -1.0f;
-    playerRangedCritPct_ = -1.0f;
-    std::fill(std::begin(playerSpellCritPct_), std::end(playerSpellCritPct_), -1.0f);
-    std::fill(std::begin(playerCombatRatings_), std::end(playerCombatRatings_), -1);
-    if (spellHandler_) spellHandler_->resetAllState();
-    spellFlatMods_.clear();
-    spellPctMods_.clear();
+    knownSpells.clear();
+    spellCooldowns.clear();
     actionBar = {};
+    playerAuras.clear();
+    targetAuras.clear();
     petGuid_ = 0;
-    stableWindowOpen_  = false;
-    stableMasterGuid_  = 0;
-    stableNumSlots_    = 0;
-    stabledPets_.clear();
     playerXp_ = 0;
     playerNextLevelXp_ = 0;
     serverPlayerLevel_ = 1;
@@ -4161,19 +5530,22 @@ void GameHandler::selectCharacter(uint64_t characterGuid) {
     pendingQuestAcceptTimeouts_.clear();
     pendingQuestAcceptNpcGuids_.clear();
     npcQuestStatus_.clear();
-    if (combatHandler_) combatHandler_->resetAllCombatState();
-    // resetCastState() already called inside resetAllState() above
+    hostileAttackers_.clear();
+    combatText.clear();
+    autoAttacking = false;
+    autoAttackTarget = 0;
+    casting = false;
+    currentCastSpellId = 0;
     pendingGameObjectInteractGuid_ = 0;
-    lastInteractedGoGuid_ = 0;
+    castTimeRemaining = 0.0f;
+    castTimeTotal = 0.0f;
     playerDead_ = false;
     releasedSpirit_ = false;
-    corpseGuid_ = 0;
-    corpseReclaimAvailableMs_ = 0;
     targetGuid = 0;
     focusGuid = 0;
     lastTargetGuid = 0;
     tabCycleStale = true;
-    entityController_->clearAll();
+    entityManager = EntityManager();
 
     // Build CMSG_PLAYER_LOGIN packet
     auto packet = PlayerLoginPacket::build(characterGuid);
@@ -4222,29 +5594,9 @@ void GameHandler::handleLoginVerifyWorld(network::Packet& packet) {
         return;
     }
 
-    glm::vec3 canonical = core::coords::serverToCanonical(glm::vec3(data.x, data.y, data.z));
-    const bool alreadyInWorld = (state == WorldState::IN_WORLD);
-    const bool sameMap = alreadyInWorld && (currentMapId_ == data.mapId);
-    const float dxCurrent = movementInfo.x - canonical.x;
-    const float dyCurrent = movementInfo.y - canonical.y;
-    const float dzCurrent = movementInfo.z - canonical.z;
-    const float distSqCurrent = dxCurrent * dxCurrent + dyCurrent * dyCurrent + dzCurrent * dzCurrent;
-
-    // Some realms emit a late duplicate LOGIN_VERIFY_WORLD after the client is already
-    // in-world. Re-running full world-entry handling here can trigger an expensive
-    // same-map reload/reset path and starve networking for tens of seconds.
-    if (!initialWorldEntry && sameMap && distSqCurrent <= (5.0f * 5.0f)) {
-        LOG_INFO("Ignoring duplicate SMSG_LOGIN_VERIFY_WORLD while already in world: mapId=",
-                 data.mapId, " dist=", std::sqrt(distSqCurrent));
-        return;
-    }
-
     // Successfully entered the world (or teleported)
     currentMapId_ = data.mapId;
     setState(WorldState::IN_WORLD);
-    if (socket) {
-        socket->tracePacketsFor(std::chrono::seconds(12), "login_verify_world");
-    }
 
     LOG_INFO("========================================");
     LOG_INFO("   SUCCESSFULLY ENTERED WORLD!");
@@ -4255,7 +5607,8 @@ void GameHandler::handleLoginVerifyWorld(network::Packet& packet) {
     LOG_INFO("Player is now in the game world");
 
     // Initialize movement info with world entry position (server → canonical)
-    LOG_DEBUG("LOGIN_VERIFY_WORLD: server=(", data.x, ", ", data.y, ", ", data.z,
+    glm::vec3 canonical = core::coords::serverToCanonical(glm::vec3(data.x, data.y, data.z));
+    LOG_WARNING("LOGIN_VERIFY_WORLD: server=(", data.x, ", ", data.y, ", ", data.z,
              ") canonical=(", canonical.x, ", ", canonical.y, ", ", canonical.z, ") mapId=", data.mapId);
     movementInfo.x = canonical.x;
     movementInfo.y = canonical.y;
@@ -4263,40 +5616,26 @@ void GameHandler::handleLoginVerifyWorld(network::Packet& packet) {
     movementInfo.orientation = core::coords::serverToCanonicalYaw(data.orientation);
     movementInfo.flags = 0;
     movementInfo.flags2 = 0;
-    if (movementHandler_) {
-        movementHandler_->movementClockStart_ = std::chrono::steady_clock::now();
-        movementHandler_->lastMovementTimestampMs_ = 0;
-    }
+    movementClockStart_ = std::chrono::steady_clock::now();
+    lastMovementTimestampMs_ = 0;
     movementInfo.time = nextMovementTimestampMs();
-    if (movementHandler_) {
-        movementHandler_->isFalling_ = false;
-        movementHandler_->fallStartMs_ = 0;
-    }
-    movementInfo.fallTime = 0;
-    movementInfo.jumpVelocity = 0.0f;
-    movementInfo.jumpSinAngle = 0.0f;
-    movementInfo.jumpCosAngle = 0.0f;
-    movementInfo.jumpXYSpeed = 0.0f;
     resurrectPending_ = false;
     resurrectRequestPending_ = false;
-    selfResAvailable_ = false;
     onTaxiFlight_ = false;
     taxiMountActive_ = false;
     taxiActivatePending_ = false;
     taxiClientActive_ = false;
     taxiClientPath_.clear();
-    // taxiRecoverPending_ is NOT cleared here — it must survive the general
-    // state reset so the recovery check below can detect a mid-flight reconnect.
+    taxiRecoverPending_ = false;
     taxiStartGrace_ = 0.0f;
     currentMountDisplayId_ = 0;
     taxiMountDisplayId_ = 0;
-    vehicleId_ = 0;
     if (mountCallback_) {
         mountCallback_(0);
     }
 
-    // Clear boss encounter unit slots and raid marks on world transfer
-    if (socialHandler_) socialHandler_->resetTransferState();
+    // Clear boss encounter unit slots on world transfer
+    encounterUnitGuids_.fill(0);
 
     // Suppress area triggers on initial login — prevents exit portals from
     // immediately firing when spawning inside a dungeon/instance.
@@ -4304,24 +5643,29 @@ void GameHandler::handleLoginVerifyWorld(network::Packet& packet) {
     areaTriggerCheckTimer_ = -5.0f;
     areaTriggerSuppressFirst_ = true;
 
-    // Notify application to load terrain for this map/position (online mode)
-    if (worldEntryCallback_) {
-        worldEntryCallback_(data.mapId, data.x, data.y, data.z, initialWorldEntry);
-    }
-
-    // Send CMSG_SET_ACTIVE_MOVER on initial world entry and world transfers.
+    // Send CMSG_SET_ACTIVE_MOVER (required by some servers)
     if (playerGuid != 0 && socket) {
         auto activeMoverPacket = SetActiveMoverPacket::build(playerGuid);
         socket->send(activeMoverPacket);
         LOG_INFO("Sent CMSG_SET_ACTIVE_MOVER for player 0x", std::hex, playerGuid, std::dec);
     }
 
-    // Kick the first keepalive immediately on world entry. Classic-like realms
-    // can close the session before our default 30s ping cadence fires.
-    timeSinceLastPing = 0.0f;
-    if (socket) {
-        LOG_DEBUG("World entry keepalive: sending immediate ping after LOGIN_VERIFY_WORLD");
-        sendPing();
+    // Notify application to load terrain for this map/position (online mode)
+    if (worldEntryCallback_) {
+        worldEntryCallback_(data.mapId, data.x, data.y, data.z);
+    }
+
+    // Auto-join default chat channels
+    autoJoinDefaultChannels();
+
+    // Auto-query guild info on login
+    const Character* activeChar = getActiveCharacter();
+    if (activeChar && activeChar->hasGuild() && socket) {
+        auto gqPacket = GuildQueryPacket::build(activeChar->guildId);
+        socket->send(gqPacket);
+        auto grPacket = GuildRosterPacket::build();
+        socket->send(grPacket);
+        LOG_INFO("Auto-queried guild info (guildId=", activeChar->guildId, ")");
     }
 
     // If we disconnected mid-taxi, attempt to recover to destination after login.
@@ -4339,26 +5683,6 @@ void GameHandler::handleLoginVerifyWorld(network::Packet& packet) {
     }
 
     if (initialWorldEntry) {
-        // Clear inspect caches on world entry to avoid showing stale data.
-        inspectedPlayerAchievements_.clear();
-
-        // Reset talent initialization so the first SMSG_TALENTS_INFO after login
-        // correctly sets the active spec (static locals don't reset across logins).
-        if (spellHandler_) spellHandler_->resetTalentState();
-
-        // Auto-join default chat channels only on first world entry.
-        autoJoinDefaultChannels();
-
-        // Auto-query guild info on login.
-        const Character* activeChar = getActiveCharacter();
-        if (activeChar && activeChar->hasGuild() && socket) {
-            auto gqPacket = GuildQueryPacket::build(activeChar->guildId);
-            socket->send(gqPacket);
-            auto grPacket = GuildRosterPacket::build();
-            socket->send(grPacket);
-            LOG_INFO("Auto-queried guild info (guildId=", activeChar->guildId, ")");
-        }
-
         pendingQuestAcceptTimeouts_.clear();
         pendingQuestAcceptNpcGuids_.clear();
         pendingQuestQueryIds_.clear();
@@ -4367,46 +5691,11 @@ void GameHandler::handleLoginVerifyWorld(network::Packet& packet) {
         completedQuests_.clear();
         LOG_INFO("Queued quest log resync for login (from server quest slots)");
 
-        // Request completed quest IDs when the expansion supports it. Classic-like
-        // opcode tables do not define this packet, and sending 0xFFFF during world
-        // entry can desync the early session handshake.
+        // Request completed quest IDs from server (populates completedQuests_ when response arrives)
         if (socket) {
-            const uint16_t queryCompletedWire = wireOpcode(Opcode::CMSG_QUERY_QUESTS_COMPLETED);
-            if (queryCompletedWire != 0xFFFF) {
-                network::Packet cqcPkt(queryCompletedWire);
-                socket->send(cqcPkt);
-                LOG_INFO("Sent CMSG_QUERY_QUESTS_COMPLETED");
-            } else {
-                LOG_INFO("Skipping CMSG_QUERY_QUESTS_COMPLETED: opcode not mapped for current expansion");
-            }
-        }
-
-        // Auto-request played time on login so the character Stats tab is
-        // populated immediately without requiring /played.
-        if (socket) {
-            auto ptPkt = RequestPlayedTimePacket::build(false);  // false = don't show in chat
-            socket->send(ptPkt);
-            LOG_INFO("Auto-requested played time on login");
-        }
-    }
-
-    // Pre-load DBC name caches during world entry so the first packet that
-    // needs spell/title/achievement data doesn't stall mid-gameplay (the
-    // Spell.dbc cache alone is ~170ms on a cold load).
-    if (initialWorldEntry) {
-        preloadDBCCaches();
-    }
-
-    // Fire PLAYER_ENTERING_WORLD — THE most important event for addon initialization.
-    // Fires on initial login, teleports, instance transitions, and zone changes.
-    if (addonEventCallback_) {
-        fireAddonEvent("PLAYER_ENTERING_WORLD", {initialWorldEntry ? "1" : "0"});
-        // Also fire ZONE_CHANGED_NEW_AREA and UPDATE_WORLD_STATES so map/BG addons refresh
-        fireAddonEvent("ZONE_CHANGED_NEW_AREA", {});
-        fireAddonEvent("UPDATE_WORLD_STATES", {});
-        // PLAYER_LOGIN fires only on initial login (not teleports)
-        if (initialWorldEntry) {
-            fireAddonEvent("PLAYER_LOGIN", {});
+            network::Packet cqcPkt(wireOpcode(Opcode::CMSG_QUERY_QUESTS_COMPLETED));
+            socket->send(cqcPkt);
+            LOG_INFO("Sent CMSG_QUERY_QUESTS_COMPLETED");
         }
     }
 }
@@ -4437,6 +5726,855 @@ void GameHandler::handleTutorialFlags(network::Packet& packet) {
              flags[4], ", ", flags[5], ", ", flags[6], ", ", flags[7], "]");
 }
 
+bool GameHandler::loadWardenCRFile(const std::string& moduleHashHex) {
+    wardenCREntries_.clear();
+
+    // Look for .cr file in warden cache
+    std::string cacheBase;
+#ifdef _WIN32
+    if (const char* h = std::getenv("APPDATA")) cacheBase = std::string(h) + "\\wowee\\warden_cache";
+    else cacheBase = ".\\warden_cache";
+#else
+    if (const char* h = std::getenv("HOME")) cacheBase = std::string(h) + "/.local/share/wowee/warden_cache";
+    else cacheBase = "./warden_cache";
+#endif
+    std::string crPath = cacheBase + "/" + moduleHashHex + ".cr";
+
+    std::ifstream crFile(crPath, std::ios::binary);
+    if (!crFile) {
+        LOG_WARNING("Warden: No .cr file found at ", crPath);
+        return false;
+    }
+
+    // Get file size
+    crFile.seekg(0, std::ios::end);
+    auto fileSize = crFile.tellg();
+    crFile.seekg(0, std::ios::beg);
+
+    // Header: [4 memoryRead][4 pageScanCheck][9 opcodes] = 17 bytes
+    constexpr size_t CR_HEADER_SIZE = 17;
+    constexpr size_t CR_ENTRY_SIZE = 68; // seed[16]+reply[20]+clientKey[16]+serverKey[16]
+
+    if (static_cast<size_t>(fileSize) < CR_HEADER_SIZE) {
+        LOG_ERROR("Warden: .cr file too small (", fileSize, " bytes)");
+        return false;
+    }
+
+    // Read header: [4 memoryRead][4 pageScanCheck][9 opcodes]
+    crFile.seekg(8); // skip memoryRead + pageScanCheck
+    crFile.read(reinterpret_cast<char*>(wardenCheckOpcodes_), 9);
+    {
+        std::string opcHex;
+        // CMaNGOS WindowsScanType order:
+        // 0 READ_MEMORY, 1 FIND_MODULE_BY_NAME, 2 FIND_MEM_IMAGE_CODE_BY_HASH,
+        // 3 FIND_CODE_BY_HASH, 4 HASH_CLIENT_FILE, 5 GET_LUA_VARIABLE,
+        // 6 API_CHECK, 7 FIND_DRIVER_BY_NAME, 8 CHECK_TIMING_VALUES
+        const char* names[] = {"MEM","MODULE","PAGE_A","PAGE_B","MPQ","LUA","PROC","DRIVER","TIMING"};
+        for (int i = 0; i < 9; i++) {
+            char s[16]; snprintf(s, sizeof(s), "%s=0x%02X ", names[i], wardenCheckOpcodes_[i]); opcHex += s;
+        }
+        LOG_DEBUG("Warden: Check opcodes: ", opcHex);
+    }
+
+    size_t entryCount = (static_cast<size_t>(fileSize) - CR_HEADER_SIZE) / CR_ENTRY_SIZE;
+    if (entryCount == 0) {
+        LOG_ERROR("Warden: .cr file has no entries");
+        return false;
+    }
+
+    wardenCREntries_.resize(entryCount);
+    for (size_t i = 0; i < entryCount; i++) {
+        auto& e = wardenCREntries_[i];
+        crFile.read(reinterpret_cast<char*>(e.seed), 16);
+        crFile.read(reinterpret_cast<char*>(e.reply), 20);
+        crFile.read(reinterpret_cast<char*>(e.clientKey), 16);
+        crFile.read(reinterpret_cast<char*>(e.serverKey), 16);
+    }
+
+    LOG_INFO("Warden: Loaded ", entryCount, " CR entries from ", crPath);
+    return true;
+}
+
+void GameHandler::handleWardenData(network::Packet& packet) {
+    const auto& data = packet.getData();
+    if (!wardenGateSeen_) {
+        wardenGateSeen_ = true;
+        wardenGateElapsed_ = 0.0f;
+        wardenGateNextStatusLog_ = 2.0f;
+        wardenPacketsAfterGate_ = 0;
+    }
+
+    // Initialize Warden crypto from session key on first packet
+    if (!wardenCrypto_) {
+        wardenCrypto_ = std::make_unique<WardenCrypto>();
+        if (sessionKey.size() != 40) {
+            LOG_ERROR("Warden: No valid session key (size=", sessionKey.size(), "), cannot init crypto");
+            wardenCrypto_.reset();
+            return;
+        }
+        if (!wardenCrypto_->initFromSessionKey(sessionKey)) {
+            LOG_ERROR("Warden: Failed to initialize crypto from session key");
+            wardenCrypto_.reset();
+            return;
+        }
+        wardenState_ = WardenState::WAIT_MODULE_USE;
+    }
+
+    // Decrypt the payload
+    std::vector<uint8_t> decrypted = wardenCrypto_->decrypt(data);
+
+    // Avoid expensive hex formatting when DEBUG logs are disabled.
+    if (core::Logger::getInstance().shouldLog(core::LogLevel::DEBUG)) {
+        std::string hex;
+        size_t logSize = std::min(decrypted.size(), size_t(256));
+        hex.reserve(logSize * 3);
+        for (size_t i = 0; i < logSize; ++i) {
+            char b[4];
+            snprintf(b, sizeof(b), "%02x ", decrypted[i]);
+            hex += b;
+        }
+        if (decrypted.size() > 64) {
+            hex += "... (" + std::to_string(decrypted.size() - 64) + " more)";
+        }
+        LOG_DEBUG("Warden: Decrypted (", decrypted.size(), " bytes): ", hex);
+    }
+
+    if (decrypted.empty()) {
+        LOG_WARNING("Warden: Empty decrypted payload");
+        return;
+    }
+
+    uint8_t wardenOpcode = decrypted[0];
+
+    // Helper to send an encrypted Warden response
+    auto sendWardenResponse = [&](const std::vector<uint8_t>& plaintext) {
+        std::vector<uint8_t> encrypted = wardenCrypto_->encrypt(plaintext);
+        network::Packet response(wireOpcode(Opcode::CMSG_WARDEN_DATA));
+        for (uint8_t byte : encrypted) {
+            response.writeUInt8(byte);
+        }
+        if (socket && socket->isConnected()) {
+            socket->send(response);
+            LOG_DEBUG("Warden: Sent response (", plaintext.size(), " bytes plaintext)");
+        }
+    };
+
+    switch (wardenOpcode) {
+        case 0x00: { // WARDEN_SMSG_MODULE_USE
+            // Format: [1 opcode][16 moduleHash][16 moduleKey][4 moduleSize]
+            if (decrypted.size() < 37) {
+                LOG_ERROR("Warden: MODULE_USE too short (", decrypted.size(), " bytes, need 37)");
+                return;
+            }
+
+            wardenModuleHash_.assign(decrypted.begin() + 1, decrypted.begin() + 17);
+            wardenModuleKey_.assign(decrypted.begin() + 17, decrypted.begin() + 33);
+            wardenModuleSize_ = static_cast<uint32_t>(decrypted[33])
+                              | (static_cast<uint32_t>(decrypted[34]) << 8)
+                              | (static_cast<uint32_t>(decrypted[35]) << 16)
+                              | (static_cast<uint32_t>(decrypted[36]) << 24);
+            wardenModuleData_.clear();
+
+            {
+                std::string hashHex;
+                for (auto b : wardenModuleHash_) { char s[4]; snprintf(s, 4, "%02x", b); hashHex += s; }
+                LOG_DEBUG("Warden: MODULE_USE hash=", hashHex, " size=", wardenModuleSize_);
+
+                // Try to load pre-computed challenge/response entries
+                loadWardenCRFile(hashHex);
+            }
+
+            // Respond with MODULE_MISSING (opcode 0x00) to request the module data
+            std::vector<uint8_t> resp = { 0x00 }; // WARDEN_CMSG_MODULE_MISSING
+            sendWardenResponse(resp);
+            wardenState_ = WardenState::WAIT_MODULE_CACHE;
+            LOG_DEBUG("Warden: Sent MODULE_MISSING, waiting for module data chunks");
+            break;
+        }
+
+        case 0x01: { // WARDEN_SMSG_MODULE_CACHE (module data chunk)
+            // Format: [1 opcode][2 chunkSize LE][chunkSize bytes data]
+            if (decrypted.size() < 3) {
+                LOG_ERROR("Warden: MODULE_CACHE too short");
+                return;
+            }
+
+            uint16_t chunkSize = static_cast<uint16_t>(decrypted[1])
+                               | (static_cast<uint16_t>(decrypted[2]) << 8);
+
+            if (decrypted.size() < 3u + chunkSize) {
+                LOG_ERROR("Warden: MODULE_CACHE chunk truncated (claimed ", chunkSize,
+                          ", have ", decrypted.size() - 3, ")");
+                return;
+            }
+
+            wardenModuleData_.insert(wardenModuleData_.end(),
+                                     decrypted.begin() + 3,
+                                     decrypted.begin() + 3 + chunkSize);
+
+            LOG_DEBUG("Warden: MODULE_CACHE chunk ", chunkSize, " bytes, total ",
+                     wardenModuleData_.size(), "/", wardenModuleSize_);
+
+            // Check if module download is complete
+            if (wardenModuleData_.size() >= wardenModuleSize_) {
+                LOG_INFO("Warden: Module download complete (",
+                         wardenModuleData_.size(), " bytes)");
+                wardenState_ = WardenState::WAIT_HASH_REQUEST;
+
+                // Cache raw module to disk
+                {
+#ifdef _WIN32
+                    std::string cacheDir;
+                    if (const char* h = std::getenv("APPDATA")) cacheDir = std::string(h) + "\\wowee\\warden_cache";
+                    else cacheDir = ".\\warden_cache";
+#else
+                    std::string cacheDir;
+                    if (const char* h = std::getenv("HOME")) cacheDir = std::string(h) + "/.local/share/wowee/warden_cache";
+                    else cacheDir = "./warden_cache";
+#endif
+                    std::filesystem::create_directories(cacheDir);
+
+                    std::string hashHex;
+                    for (auto b : wardenModuleHash_) { char s[4]; snprintf(s, 4, "%02x", b); hashHex += s; }
+                    std::string cachePath = cacheDir + "/" + hashHex + ".wdn";
+
+                    std::ofstream wf(cachePath, std::ios::binary);
+                    if (wf) {
+                        wf.write(reinterpret_cast<const char*>(wardenModuleData_.data()), wardenModuleData_.size());
+                        LOG_DEBUG("Warden: Cached module to ", cachePath);
+                    }
+                }
+
+                // Load the module (decrypt, decompress, parse, relocate)
+                wardenLoadedModule_ = std::make_shared<WardenModule>();
+                if (wardenLoadedModule_->load(wardenModuleData_, wardenModuleHash_, wardenModuleKey_)) { // codeql[cpp/weak-cryptographic-algorithm]
+                    LOG_INFO("Warden: Module loaded successfully (image size=",
+                             wardenLoadedModule_->getModuleSize(), " bytes)");
+                } else {
+                    LOG_ERROR("Warden: Module loading FAILED");
+                    wardenLoadedModule_.reset();
+                }
+
+                // Send MODULE_OK (opcode 0x01)
+                std::vector<uint8_t> resp = { 0x01 }; // WARDEN_CMSG_MODULE_OK
+                sendWardenResponse(resp);
+                LOG_DEBUG("Warden: Sent MODULE_OK");
+            }
+            // No response for intermediate chunks
+            break;
+        }
+
+        case 0x05: { // WARDEN_SMSG_HASH_REQUEST
+            // Format: [1 opcode][16 seed]
+            if (decrypted.size() < 17) {
+                LOG_ERROR("Warden: HASH_REQUEST too short (", decrypted.size(), " bytes, need 17)");
+                return;
+            }
+
+            std::vector<uint8_t> seed(decrypted.begin() + 1, decrypted.begin() + 17);
+
+            // --- Try CR lookup (pre-computed challenge/response entries) ---
+            if (!wardenCREntries_.empty()) {
+                const WardenCREntry* match = nullptr;
+                for (const auto& entry : wardenCREntries_) {
+                    if (std::memcmp(entry.seed, seed.data(), 16) == 0) {
+                        match = &entry;
+                        break;
+                    }
+                }
+
+                if (match) {
+                    LOG_DEBUG("Warden: Found matching CR entry for seed");
+
+                    // Log the reply we're sending
+                    {
+                        std::string replyHex;
+                        for (int i = 0; i < 20; i++) {
+                            char s[4]; snprintf(s, 4, "%02x", match->reply[i]); replyHex += s;
+                        }
+                        LOG_DEBUG("Warden: Sending pre-computed reply=", replyHex);
+                    }
+
+                    // Send HASH_RESULT (opcode 0x04 + 20-byte reply)
+                    std::vector<uint8_t> resp;
+                    resp.push_back(0x04);
+                    resp.insert(resp.end(), match->reply, match->reply + 20);
+                    sendWardenResponse(resp);
+
+                    // Switch to new RC4 keys from the CR entry
+                    // clientKey = encrypt (client→server), serverKey = decrypt (server→client)
+                    std::vector<uint8_t> newEncryptKey(match->clientKey, match->clientKey + 16);
+                    std::vector<uint8_t> newDecryptKey(match->serverKey, match->serverKey + 16);
+                    wardenCrypto_->replaceKeys(newEncryptKey, newDecryptKey);
+
+                    LOG_DEBUG("Warden: Switched to CR key set");
+
+                    wardenState_ = WardenState::WAIT_CHECKS;
+                    break;
+                } else {
+                    LOG_WARNING("Warden: Seed not found in ", wardenCREntries_.size(), " CR entries");
+                }
+            }
+
+            // --- Fallback: compute hash from loaded module ---
+            LOG_WARNING("Warden: No CR match, computing hash from loaded module");
+
+            if (!wardenLoadedModule_ || !wardenLoadedModule_->isLoaded()) {
+                LOG_ERROR("Warden: No loaded module and no CR match — cannot compute hash");
+                wardenState_ = WardenState::WAIT_CHECKS;
+                break;
+            }
+
+            {
+                const uint8_t* moduleImage = static_cast<const uint8_t*>(wardenLoadedModule_->getModuleMemory());
+                size_t moduleImageSize = wardenLoadedModule_->getModuleSize();
+                const auto& decompressedData = wardenLoadedModule_->getDecompressedData();
+
+                // --- Empirical test: try multiple SHA1 computations and check against first CR entry ---
+                if (!wardenCREntries_.empty()) {
+                    const auto& firstCR = wardenCREntries_[0];
+                    std::string expectedHex;
+                    for (int i = 0; i < 20; i++) { char s[4]; snprintf(s, 4, "%02x", firstCR.reply[i]); expectedHex += s; }
+                    LOG_DEBUG("Warden: Empirical test — expected reply from CR[0]=", expectedHex);
+
+                    // Test 1: SHA1(moduleImage)
+                    {
+                        std::vector<uint8_t> data(moduleImage, moduleImage + moduleImageSize);
+                        auto h = auth::Crypto::sha1(data);
+                        bool match = (std::memcmp(h.data(), firstCR.reply, 20) == 0);
+                        std::string hex; for (auto b : h) { char s[4]; snprintf(s, 4, "%02x", b); hex += s; }
+                        LOG_DEBUG("Warden:   SHA1(moduleImage)=", hex, match ? " MATCH!" : "");
+                    }
+                    // Test 2: SHA1(seed || moduleImage)
+                    {
+                        std::vector<uint8_t> data;
+                        data.insert(data.end(), seed.begin(), seed.end());
+                        data.insert(data.end(), moduleImage, moduleImage + moduleImageSize);
+                        auto h = auth::Crypto::sha1(data);
+                        bool match = (std::memcmp(h.data(), firstCR.reply, 20) == 0);
+                        std::string hex; for (auto b : h) { char s[4]; snprintf(s, 4, "%02x", b); hex += s; }
+                        LOG_DEBUG("Warden:   SHA1(seed||image)=", hex, match ? " MATCH!" : "");
+                    }
+                    // Test 3: SHA1(moduleImage || seed)
+                    {
+                        std::vector<uint8_t> data(moduleImage, moduleImage + moduleImageSize);
+                        data.insert(data.end(), seed.begin(), seed.end());
+                        auto h = auth::Crypto::sha1(data);
+                        bool match = (std::memcmp(h.data(), firstCR.reply, 20) == 0);
+                        std::string hex; for (auto b : h) { char s[4]; snprintf(s, 4, "%02x", b); hex += s; }
+                        LOG_DEBUG("Warden:   SHA1(image||seed)=", hex, match ? " MATCH!" : "");
+                    }
+                    // Test 4: SHA1(decompressedData)
+                    {
+                        auto h = auth::Crypto::sha1(decompressedData);
+                        bool match = (std::memcmp(h.data(), firstCR.reply, 20) == 0);
+                        std::string hex; for (auto b : h) { char s[4]; snprintf(s, 4, "%02x", b); hex += s; }
+                        LOG_DEBUG("Warden:   SHA1(decompressed)=", hex, match ? " MATCH!" : "");
+                    }
+                    // Test 5: SHA1(rawModuleData)
+                    {
+                        auto h = auth::Crypto::sha1(wardenModuleData_);
+                        bool match = (std::memcmp(h.data(), firstCR.reply, 20) == 0);
+                        std::string hex; for (auto b : h) { char s[4]; snprintf(s, 4, "%02x", b); hex += s; }
+                        LOG_DEBUG("Warden:   SHA1(rawModule)=", hex, match ? " MATCH!" : "");
+                    }
+                    // Test 6: Check if all CR replies are the same (constant hash)
+                    {
+                        bool allSame = true;
+                        for (size_t i = 1; i < wardenCREntries_.size(); i++) {
+                            if (std::memcmp(wardenCREntries_[i].reply, firstCR.reply, 20) != 0) {
+                                allSame = false;
+                                break;
+                            }
+                        }
+                        LOG_DEBUG("Warden:   All ", wardenCREntries_.size(), " CR replies identical? ", allSame ? "YES" : "NO");
+                    }
+                }
+
+                // --- Compute the hash: SHA1(moduleImage) is the most likely candidate ---
+                // The module's hash response is typically SHA1 of the loaded module image.
+                // This is a constant per module (seed is not used in the hash, only for key derivation).
+                std::vector<uint8_t> imageData(moduleImage, moduleImage + moduleImageSize);
+                auto reply = auth::Crypto::sha1(imageData);
+
+                {
+                    std::string hex;
+                    for (auto b : reply) { char s[4]; snprintf(s, 4, "%02x", b); hex += s; }
+                    LOG_DEBUG("Warden: Sending SHA1(moduleImage)=", hex);
+                }
+
+                // Send HASH_RESULT (opcode 0x04 + 20-byte hash)
+                std::vector<uint8_t> resp;
+                resp.push_back(0x04);
+                resp.insert(resp.end(), reply.begin(), reply.end());
+                sendWardenResponse(resp);
+
+                // Derive new RC4 keys from the seed using SHA1Randx
+                std::vector<uint8_t> seedVec(seed.begin(), seed.end());
+                // Pad seed to at least 2 bytes for SHA1Randx split
+                // SHA1Randx splits input in half: first_half and second_half
+                uint8_t newEncryptKey[16], newDecryptKey[16];
+                WardenCrypto::sha1RandxGenerate(seedVec, newEncryptKey, newDecryptKey);
+
+                std::vector<uint8_t> ek(newEncryptKey, newEncryptKey + 16);
+                std::vector<uint8_t> dk(newDecryptKey, newDecryptKey + 16);
+                wardenCrypto_->replaceKeys(ek, dk);
+                for (auto& b : newEncryptKey) b = 0;
+                for (auto& b : newDecryptKey) b = 0;
+                LOG_DEBUG("Warden: Derived and applied key update from seed");
+            }
+
+            wardenState_ = WardenState::WAIT_CHECKS;
+            break;
+        }
+
+        case 0x02: { // WARDEN_SMSG_CHEAT_CHECKS_REQUEST
+            LOG_DEBUG("Warden: CHEAT_CHECKS_REQUEST (", decrypted.size(), " bytes)");
+
+            if (decrypted.size() < 3) {
+                LOG_ERROR("Warden: CHEAT_CHECKS_REQUEST too short");
+                break;
+            }
+
+            // --- Parse string table ---
+            // Format: [1 opcode][string table: (len+data)*][0x00 end][check data][xorByte]
+            size_t pos = 1;
+            std::vector<std::string> strings;
+            while (pos < decrypted.size()) {
+                uint8_t slen = decrypted[pos++];
+                if (slen == 0) break; // end of string table
+                if (pos + slen > decrypted.size()) break;
+                strings.emplace_back(reinterpret_cast<const char*>(decrypted.data() + pos), slen);
+                pos += slen;
+            }
+            LOG_DEBUG("Warden: String table: ", strings.size(), " entries");
+            for (size_t i = 0; i < strings.size(); i++) {
+                LOG_DEBUG("Warden:   [", i, "] = \"", strings[i], "\"");
+            }
+
+            // XOR byte is the last byte of the packet
+            uint8_t xorByte = decrypted.back();
+            LOG_DEBUG("Warden: XOR byte = 0x", [&]{ char s[4]; snprintf(s,4,"%02x",xorByte); return std::string(s); }());
+
+            // Check type enum indices
+            enum CheckType { CT_MEM=0, CT_PAGE_A=1, CT_PAGE_B=2, CT_MPQ=3, CT_LUA=4,
+                             CT_DRIVER=5, CT_TIMING=6, CT_PROC=7, CT_MODULE=8, CT_UNKNOWN=9 };
+            const char* checkTypeNames[] = {"MEM","PAGE_A","PAGE_B","MPQ","LUA","DRIVER","TIMING","PROC","MODULE","UNKNOWN"};
+            size_t checkEnd = decrypted.size() - 1; // exclude xorByte
+
+            auto decodeCheckType = [&](uint8_t raw) -> CheckType {
+                uint8_t decoded = raw ^ xorByte;
+                if (decoded == wardenCheckOpcodes_[0]) return CT_MEM;    // READ_MEMORY
+                if (decoded == wardenCheckOpcodes_[1]) return CT_MODULE; // FIND_MODULE_BY_NAME
+                if (decoded == wardenCheckOpcodes_[2]) return CT_PAGE_A; // FIND_MEM_IMAGE_CODE_BY_HASH
+                if (decoded == wardenCheckOpcodes_[3]) return CT_PAGE_B; // FIND_CODE_BY_HASH
+                if (decoded == wardenCheckOpcodes_[4]) return CT_MPQ;    // HASH_CLIENT_FILE
+                if (decoded == wardenCheckOpcodes_[5]) return CT_LUA;    // GET_LUA_VARIABLE
+                if (decoded == wardenCheckOpcodes_[6]) return CT_PROC;   // API_CHECK
+                if (decoded == wardenCheckOpcodes_[7]) return CT_DRIVER; // FIND_DRIVER_BY_NAME
+                if (decoded == wardenCheckOpcodes_[8]) return CT_TIMING; // CHECK_TIMING_VALUES
+                return CT_UNKNOWN;
+            };
+            auto isKnownWantedCodeScan = [&](const uint8_t seedBytes[4], const uint8_t reqHash[20],
+                                            uint32_t offset, uint8_t length) -> bool {
+                auto hashPattern = [&](const uint8_t* pattern, size_t patternLen) {
+                    uint8_t out[SHA_DIGEST_LENGTH];
+                    unsigned int outLen = 0;
+                    HMAC(EVP_sha1(),
+                         seedBytes, 4,
+                         pattern, patternLen,
+                         out, &outLen);
+                    return outLen == SHA_DIGEST_LENGTH && std::memcmp(out, reqHash, SHA_DIGEST_LENGTH) == 0;
+                };
+
+                // DB sanity check: "Warden packet process code search sanity check" (id=85)
+                static const uint8_t kPacketProcessSanityPattern[] = {
+                    0x33, 0xD2, 0x33, 0xC9, 0xE8, 0x87, 0x07, 0x1B, 0x00, 0xE8
+                };
+                if (offset == 13856 && length == sizeof(kPacketProcessSanityPattern) &&
+                    hashPattern(kPacketProcessSanityPattern, sizeof(kPacketProcessSanityPattern))) {
+                    return true;
+                }
+
+                // Scripted sanity check: "Warden Memory Read check" in wardenwin.cpp
+                static const uint8_t kWardenMemoryReadPattern[] = {
+                    0x56, 0x57, 0xFC, 0x8B, 0x54, 0x24, 0x14, 0x8B,
+                    0x74, 0x24, 0x10, 0x8B, 0x44, 0x24, 0x0C, 0x8B,
+                    0xCA, 0x8B, 0xF8, 0xC1, 0xE9, 0x02, 0x74, 0x02,
+                    0xF3, 0xA5, 0xB1, 0x03, 0x23, 0xCA, 0x74, 0x02,
+                    0xF3, 0xA4, 0x5F, 0x5E, 0xC3
+                };
+                if (length == sizeof(kWardenMemoryReadPattern) &&
+                    hashPattern(kWardenMemoryReadPattern, sizeof(kWardenMemoryReadPattern))) {
+                    return true;
+                }
+
+                return false;
+            };
+            auto resolveWardenString = [&](uint8_t oneBasedIndex) -> std::string {
+                if (oneBasedIndex == 0) return std::string();
+                size_t idx = static_cast<size_t>(oneBasedIndex - 1);
+                if (idx >= strings.size()) return std::string();
+                return strings[idx];
+            };
+            auto requestSizes = [&](CheckType ct) {
+                switch (ct) {
+                    case CT_TIMING: return std::vector<size_t>{0};
+                    case CT_MEM:    return std::vector<size_t>{6};
+                    case CT_PAGE_A: return std::vector<size_t>{24, 29};
+                    case CT_PAGE_B: return std::vector<size_t>{24, 29};
+                    case CT_MPQ:    return std::vector<size_t>{1};
+                    case CT_LUA:    return std::vector<size_t>{1};
+                    case CT_DRIVER: return std::vector<size_t>{25};
+                    case CT_PROC:   return std::vector<size_t>{30};
+                    case CT_MODULE: return std::vector<size_t>{24};
+                    default:        return std::vector<size_t>{};
+                }
+            };
+            std::unordered_map<size_t, bool> parseMemo;
+            std::function<bool(size_t)> canParseFrom = [&](size_t checkPos) -> bool {
+                if (checkPos == checkEnd) return true;
+                if (checkPos > checkEnd) return false;
+                auto it = parseMemo.find(checkPos);
+                if (it != parseMemo.end()) return it->second;
+
+                CheckType ct = decodeCheckType(decrypted[checkPos]);
+                if (ct == CT_UNKNOWN) {
+                    parseMemo[checkPos] = false;
+                    return false;
+                }
+
+                size_t payloadPos = checkPos + 1;
+                for (size_t reqSize : requestSizes(ct)) {
+                    if (payloadPos + reqSize > checkEnd) continue;
+                    if (canParseFrom(payloadPos + reqSize)) {
+                        parseMemo[checkPos] = true;
+                        return true;
+                    }
+                }
+
+                parseMemo[checkPos] = false;
+                return false;
+            };
+            auto isBoundaryAfter = [&](size_t start, size_t consume) -> bool {
+                size_t next = start + consume;
+                if (next == checkEnd) return true;
+                if (next > checkEnd) return false;
+                return decodeCheckType(decrypted[next]) != CT_UNKNOWN;
+            };
+
+            // --- Parse check entries and build response ---
+            std::vector<uint8_t> resultData;
+            int checkCount = 0;
+
+            while (pos < checkEnd) {
+                CheckType ct = decodeCheckType(decrypted[pos]);
+                pos++;
+                checkCount++;
+
+                LOG_DEBUG("Warden: Check #", checkCount, " type=", checkTypeNames[ct],
+                         " at offset ", pos - 1);
+
+                switch (ct) {
+                    case CT_TIMING: {
+                        // No additional request data
+                        // Response: [uint8 result=1][uint32 ticks]
+                        resultData.push_back(0x01);
+                        uint32_t ticks = static_cast<uint32_t>(
+                            std::chrono::duration_cast<std::chrono::milliseconds>(
+                                std::chrono::steady_clock::now().time_since_epoch()).count());
+                        resultData.push_back(ticks & 0xFF);
+                        resultData.push_back((ticks >> 8) & 0xFF);
+                        resultData.push_back((ticks >> 16) & 0xFF);
+                        resultData.push_back((ticks >> 24) & 0xFF);
+                        break;
+                    }
+                    case CT_MEM: {
+                        // Request: [1 stringIdx][4 offset][1 length]
+                        if (pos + 6 > checkEnd) { pos = checkEnd; break; }
+                        uint8_t strIdx = decrypted[pos++];
+                        std::string moduleName = resolveWardenString(strIdx);
+                        uint32_t offset = decrypted[pos] | (uint32_t(decrypted[pos+1])<<8)
+                                        | (uint32_t(decrypted[pos+2])<<16) | (uint32_t(decrypted[pos+3])<<24);
+                        pos += 4;
+                        uint8_t readLen = decrypted[pos++];
+                        LOG_DEBUG("Warden:   MEM offset=0x", [&]{char s[12];snprintf(s,12,"%08x",offset);return std::string(s);}(),
+                                 " len=", (int)readLen);
+                        if (!moduleName.empty()) {
+                            LOG_DEBUG("Warden:   MEM module=\"", moduleName, "\"");
+                        }
+
+                        // Lazy-load WoW.exe PE image on first MEM_CHECK
+                        if (!wardenMemory_) {
+                            wardenMemory_ = std::make_unique<WardenMemory>();
+                            if (!wardenMemory_->load(static_cast<uint16_t>(build))) {
+                                LOG_WARNING("Warden: Could not load WoW.exe for MEM_CHECK");
+                            }
+                        }
+
+                        // Read bytes from PE image (includes patched runtime globals)
+                        std::vector<uint8_t> memBuf(readLen, 0);
+                        if (wardenMemory_->isLoaded() && wardenMemory_->readMemory(offset, readLen, memBuf.data())) {
+                            LOG_DEBUG("Warden:   MEM_CHECK served from PE image");
+                        } else {
+                            LOG_WARNING("Warden:   MEM_CHECK fallback to zeros for 0x",
+                                        [&]{char s[12];snprintf(s,12,"%08x",offset);return std::string(s);}());
+                        }
+                        resultData.push_back(0x00);
+                        resultData.insert(resultData.end(), memBuf.begin(), memBuf.end());
+                        break;
+                    }
+                    case CT_PAGE_A: {
+                        // Classic has seen two PAGE_A layouts in the wild:
+                        // short: [4 seed][20 sha1] = 24 bytes
+                        // long:  [4 seed][20 sha1][4 addr][1 len] = 29 bytes
+                        // Prefer the variant that allows the full remaining stream to parse.
+                        constexpr size_t kPageAShort = 24;
+                        constexpr size_t kPageALong = 29;
+                        size_t consume = 0;
+
+                        if (pos + kPageAShort <= checkEnd && canParseFrom(pos + kPageAShort)) {
+                            consume = kPageAShort;
+                        }
+                        if (pos + kPageALong <= checkEnd && canParseFrom(pos + kPageALong) && consume == 0) {
+                            consume = kPageALong;
+                        }
+                        if (consume == 0 && isBoundaryAfter(pos, kPageAShort)) consume = kPageAShort;
+                        if (consume == 0 && isBoundaryAfter(pos, kPageALong)) consume = kPageALong;
+
+                        if (consume == 0) {
+                            size_t remaining = checkEnd - pos;
+                            if (remaining >= kPageAShort && remaining < kPageALong) consume = kPageAShort;
+                            else if (remaining >= kPageALong) consume = kPageALong;
+                            else {
+                                LOG_WARNING("Warden:   PAGE_A check truncated (remaining=", remaining,
+                                            "), consuming remainder");
+                                pos = checkEnd;
+                                resultData.push_back(0x00);
+                                break;
+                            }
+                        }
+
+                        uint8_t pageResult = 0x00;
+                        if (consume >= 29) {
+                            const uint8_t* p = decrypted.data() + pos;
+                            uint8_t seedBytes[4] = { p[0], p[1], p[2], p[3] };
+                            uint8_t reqHash[20];
+                            std::memcpy(reqHash, p + 4, 20);
+                            uint32_t off = uint32_t(p[24]) | (uint32_t(p[25]) << 8) |
+                                           (uint32_t(p[26]) << 16) | (uint32_t(p[27]) << 24);
+                            uint8_t len = p[28];
+                            if (isKnownWantedCodeScan(seedBytes, reqHash, off, len)) {
+                                pageResult = 0x4A; // PatternFound
+                            }
+                        }
+                        LOG_DEBUG("Warden:   PAGE_A request bytes=", consume,
+                                 " result=0x", [&]{char s[4];snprintf(s,4,"%02x",pageResult);return std::string(s);}());
+                        pos += consume;
+                        resultData.push_back(pageResult);
+                        break;
+                    }
+                    case CT_PAGE_B: {
+                        constexpr size_t kPageBShort = 24;
+                        constexpr size_t kPageBLong = 29;
+                        size_t consume = 0;
+
+                        if (pos + kPageBShort <= checkEnd && canParseFrom(pos + kPageBShort)) {
+                            consume = kPageBShort;
+                        }
+                        if (pos + kPageBLong <= checkEnd && canParseFrom(pos + kPageBLong) && consume == 0) {
+                            consume = kPageBLong;
+                        }
+                        if (consume == 0 && isBoundaryAfter(pos, kPageBShort)) consume = kPageBShort;
+                        if (consume == 0 && isBoundaryAfter(pos, kPageBLong)) consume = kPageBLong;
+
+                        if (consume == 0) {
+                            size_t remaining = checkEnd - pos;
+                            if (remaining >= kPageBShort && remaining < kPageBLong) consume = kPageBShort;
+                            else if (remaining >= kPageBLong) consume = kPageBLong;
+                            else { pos = checkEnd; break; }
+                        }
+                        uint8_t pageResult = 0x00;
+                        if (consume >= 29) {
+                            const uint8_t* p = decrypted.data() + pos;
+                            uint8_t seedBytes[4] = { p[0], p[1], p[2], p[3] };
+                            uint8_t reqHash[20];
+                            std::memcpy(reqHash, p + 4, 20);
+                            uint32_t off = uint32_t(p[24]) | (uint32_t(p[25]) << 8) |
+                                           (uint32_t(p[26]) << 16) | (uint32_t(p[27]) << 24);
+                            uint8_t len = p[28];
+                            if (isKnownWantedCodeScan(seedBytes, reqHash, off, len)) {
+                                pageResult = 0x4A; // PatternFound
+                            }
+                        }
+                        LOG_DEBUG("Warden:   PAGE_B request bytes=", consume,
+                                 " result=0x", [&]{char s[4];snprintf(s,4,"%02x",pageResult);return std::string(s);}());
+                        pos += consume;
+                        resultData.push_back(pageResult);
+                        break;
+                    }
+                    case CT_MPQ: {
+                        // HASH_CLIENT_FILE request: [1 stringIdx]
+                        if (pos + 1 > checkEnd) { pos = checkEnd; break; }
+                        uint8_t strIdx = decrypted[pos++];
+                        std::string filePath = resolveWardenString(strIdx);
+                        LOG_DEBUG("Warden:   MPQ file=\"", (filePath.empty() ? "?" : filePath), "\"");
+
+                        bool found = false;
+                        std::vector<uint8_t> hash(20, 0);
+                        if (!filePath.empty()) {
+                            std::string normalizedPath = asciiLower(filePath);
+                            std::replace(normalizedPath.begin(), normalizedPath.end(), '/', '\\');
+                            auto knownIt = knownDoorHashes().find(normalizedPath);
+                            if (knownIt != knownDoorHashes().end()) {
+                                found = true;
+                                hash.assign(knownIt->second.begin(), knownIt->second.end());
+                            }
+
+                            auto* am = core::Application::getInstance().getAssetManager();
+                            if (am && am->isInitialized() && !found) {
+                                // Use a case-insensitive direct filesystem resolution first.
+                                // Manifest entries may point at uppercase duplicate trees with
+                                // different content/hashes than canonical client files.
+                                std::vector<uint8_t> fileData;
+                                std::string resolvedFsPath =
+                                    resolveCaseInsensitiveDataPath(am->getDataPath(), filePath);
+                                if (!resolvedFsPath.empty()) {
+                                    fileData = readFileBinary(resolvedFsPath);
+                                }
+                                if (fileData.empty()) {
+                                    fileData = am->readFile(filePath);
+                                }
+
+                                if (!fileData.empty()) {
+                                    found = true;
+                                    hash = auth::Crypto::sha1(fileData);
+                                }
+                            }
+                        }
+
+                        // Response: [uint8 result][20 sha1]
+                        // result=0 => found/success, result=1 => not found/failure
+                        resultData.push_back(found ? 0x00 : 0x01);
+                        resultData.insert(resultData.end(), hash.begin(), hash.end());
+                        break;
+                    }
+                    case CT_LUA: {
+                        // Request: [1 stringIdx]
+                        if (pos + 1 > checkEnd) { pos = checkEnd; break; }
+                        uint8_t strIdx = decrypted[pos++];
+                        std::string luaVar = resolveWardenString(strIdx);
+                        LOG_DEBUG("Warden:   LUA str=\"", (luaVar.empty() ? "?" : luaVar), "\"");
+                        // Response: [uint8 result=0][uint16 len=0]
+                        // Lua string doesn't exist
+                        resultData.push_back(0x01); // not found
+                        break;
+                    }
+                    case CT_DRIVER: {
+                        // Request: [4 seed][20 sha1][1 stringIdx]
+                        if (pos + 25 > checkEnd) { pos = checkEnd; break; }
+                        pos += 24; // skip seed + sha1
+                        uint8_t strIdx = decrypted[pos++];
+                        std::string driverName = resolveWardenString(strIdx);
+                        LOG_DEBUG("Warden:   DRIVER=\"", (driverName.empty() ? "?" : driverName), "\"");
+                        // Response: [uint8 result=1] (driver NOT found = clean)
+                        resultData.push_back(0x01);
+                        break;
+                    }
+                    case CT_MODULE: {
+                        // FIND_MODULE_BY_NAME request: [4 seed][20 sha1] = 24 bytes
+                        int moduleSize = 24;
+                        if (pos + moduleSize > checkEnd) {
+                            size_t remaining = checkEnd - pos;
+                            LOG_WARNING("Warden:   MODULE check truncated (remaining=", remaining,
+                                        ", expected=", moduleSize, "), consuming remainder");
+                            pos = checkEnd;
+                        } else {
+                            const uint8_t* p = decrypted.data() + pos;
+                            uint8_t seedBytes[4] = { p[0], p[1], p[2], p[3] };
+                            uint8_t reqHash[20];
+                            std::memcpy(reqHash, p + 4, 20);
+                            pos += moduleSize;
+
+                            // CMaNGOS uppercases module names before hashing.
+                            // DB module scans:
+                            //   KERNEL32.DLL (wanted=true)
+                            //   WPESPY.DLL / SPEEDHACK-I386.DLL / TAMIA.DLL (wanted=false)
+                            bool shouldReportFound = false;
+                            if (hmacSha1Matches(seedBytes, "KERNEL32.DLL", reqHash)) {
+                                shouldReportFound = true;
+                            } else if (hmacSha1Matches(seedBytes, "WPESPY.DLL", reqHash) ||
+                                       hmacSha1Matches(seedBytes, "SPEEDHACK-I386.DLL", reqHash) ||
+                                       hmacSha1Matches(seedBytes, "TAMIA.DLL", reqHash)) {
+                                shouldReportFound = false;
+                            }
+                            resultData.push_back(shouldReportFound ? 0x4A : 0x01);
+                            break;
+                        }
+                        // Truncated module request fallback: module NOT loaded = clean
+                        resultData.push_back(0x01);
+                        break;
+                    }
+                    case CT_PROC: {
+                        // API_CHECK request:
+                        // [4 seed][20 sha1][1 stringIdx][1 stringIdx2][4 offset] = 30 bytes
+                        int procSize = 30;
+                        if (pos + procSize > checkEnd) { pos = checkEnd; break; }
+                        pos += procSize;
+                        // Response: [uint8 result=1] (proc NOT found = clean)
+                        resultData.push_back(0x01);
+                        break;
+                    }
+                    default: {
+                        LOG_WARNING("Warden: Unknown check type, cannot parse remaining");
+                        pos = checkEnd; // stop parsing
+                        break;
+                    }
+                }
+            }
+
+            LOG_DEBUG("Warden: Parsed ", checkCount, " checks, result data size=", resultData.size());
+
+            // --- Compute checksum: XOR of 5 uint32s from SHA1(resultData) ---
+            auto resultHash = auth::Crypto::sha1(resultData);
+            uint32_t checksum = 0;
+            for (int i = 0; i < 5; i++) {
+                uint32_t word = resultHash[i*4]
+                              | (uint32_t(resultHash[i*4+1]) << 8)
+                              | (uint32_t(resultHash[i*4+2]) << 16)
+                              | (uint32_t(resultHash[i*4+3]) << 24);
+                checksum ^= word;
+            }
+
+            // --- Build response: [0x02][uint16 length][uint32 checksum][resultData] ---
+            uint16_t resultLen = static_cast<uint16_t>(resultData.size());
+            std::vector<uint8_t> resp;
+            resp.push_back(0x02);
+            resp.push_back(resultLen & 0xFF);
+            resp.push_back((resultLen >> 8) & 0xFF);
+            resp.push_back(checksum & 0xFF);
+            resp.push_back((checksum >> 8) & 0xFF);
+            resp.push_back((checksum >> 16) & 0xFF);
+            resp.push_back((checksum >> 24) & 0xFF);
+            resp.insert(resp.end(), resultData.begin(), resultData.end());
+            sendWardenResponse(resp);
+            LOG_DEBUG("Warden: Sent CHEAT_CHECKS_RESULT (", resp.size(), " bytes, ",
+                     checkCount, " checks, checksum=0x",
+                     [&]{char s[12];snprintf(s,12,"%08x",checksum);return std::string(s);}(), ")");
+            break;
+        }
+
+        case 0x03: // WARDEN_SMSG_MODULE_INITIALIZE
+            LOG_DEBUG("Warden: MODULE_INITIALIZE (", decrypted.size(), " bytes, no response needed)");
+            break;
+
+        default:
+            LOG_DEBUG("Warden: Unknown opcode 0x", std::hex, (int)wardenOpcode, std::dec,
+                     " (state=", (int)wardenState_, ", size=", decrypted.size(), ")");
+            break;
+    }
+}
+
 void GameHandler::handleAccountDataTimes(network::Packet& packet) {
     LOG_DEBUG("Handling SMSG_ACCOUNT_DATA_TIMES");
 
@@ -4450,7 +6588,31 @@ void GameHandler::handleAccountDataTimes(network::Packet& packet) {
 }
 
 void GameHandler::handleMotd(network::Packet& packet) {
-    if (chatHandler_) chatHandler_->handleMotd(packet);
+    LOG_INFO("Handling SMSG_MOTD");
+
+    MotdData data;
+    if (!MotdParser::parse(packet, data)) {
+        LOG_WARNING("Failed to parse SMSG_MOTD");
+        return;
+    }
+
+    if (!data.isEmpty()) {
+        LOG_INFO("========================================");
+        LOG_INFO("   MESSAGE OF THE DAY");
+        LOG_INFO("========================================");
+        for (const auto& line : data.lines) {
+            LOG_INFO(line);
+            addSystemChatMessage(std::string("MOTD: ") + line);
+        }
+        // Add a visual separator after MOTD block so subsequent messages don't
+        // appear glued to the last MOTD line.
+        MessageChatData spacer;
+        spacer.type = ChatType::SYSTEM;
+        spacer.language = ChatLanguage::UNIVERSAL;
+        spacer.message = "";
+        addLocalChatMessage(spacer);
+        LOG_INFO("========================================");
+    }
 }
 
 void GameHandler::handleNotification(network::Packet& packet) {
@@ -4470,299 +6632,14 @@ void GameHandler::sendPing() {
     // Increment sequence number
     pingSequence++;
 
-    LOG_DEBUG("Sending CMSG_PING: sequence=", pingSequence,
-              " latencyHintMs=", lastLatency);
-
-    // Record send time for RTT measurement
-    pingTimestamp_ = std::chrono::steady_clock::now();
+    LOG_DEBUG("Sending CMSG_PING (heartbeat)");
+    LOG_DEBUG("  Sequence: ", pingSequence);
 
     // Build and send ping packet
     auto packet = PingPacket::build(pingSequence, lastLatency);
     socket->send(packet);
 }
 
-void GameHandler::sendRequestVehicleExit() {
-    if (state != WorldState::IN_WORLD || vehicleId_ == 0) return;
-    // CMSG_REQUEST_VEHICLE_EXIT has no payload — opcode only
-    network::Packet pkt(wireOpcode(Opcode::CMSG_REQUEST_VEHICLE_EXIT));
-    socket->send(pkt);
-    vehicleId_ = 0;  // Optimistically clear; server will confirm via SMSG_PLAYER_VEHICLE_DATA(0)
-}
-
-const std::vector<GameHandler::EquipmentSetInfo>& GameHandler::getEquipmentSets() const {
-    if (inventoryHandler_) return inventoryHandler_->getEquipmentSets();
-    static const std::vector<EquipmentSetInfo> empty;
-    return empty;
-}
-
-// Trade state delegation to InventoryHandler (which owns the canonical trade state)
-GameHandler::TradeStatus GameHandler::getTradeStatus() const {
-    if (inventoryHandler_) return static_cast<TradeStatus>(inventoryHandler_->getTradeStatus());
-    return tradeStatus_;
-}
-bool GameHandler::hasPendingTradeRequest() const {
-    return inventoryHandler_ ? inventoryHandler_->hasPendingTradeRequest() : false;
-}
-bool GameHandler::isTradeOpen() const {
-    return inventoryHandler_ ? inventoryHandler_->isTradeOpen() : false;
-}
-const std::string& GameHandler::getTradePeerName() const {
-    if (inventoryHandler_) return inventoryHandler_->getTradePeerName();
-    return tradePeerName_;
-}
-const std::array<GameHandler::TradeSlot, GameHandler::TRADE_SLOT_COUNT>& GameHandler::getMyTradeSlots() const {
-    if (inventoryHandler_) {
-        // Convert InventoryHandler::TradeSlot → GameHandler::TradeSlot (different struct layouts)
-        static std::array<TradeSlot, TRADE_SLOT_COUNT> converted{};
-        const auto& src = inventoryHandler_->getMyTradeSlots();
-        for (size_t i = 0; i < TRADE_SLOT_COUNT; i++) {
-            converted[i].itemId = src[i].itemId;
-            converted[i].displayId = src[i].displayId;
-            converted[i].stackCount = src[i].stackCount;
-            converted[i].itemGuid = src[i].itemGuid;
-        }
-        return converted;
-    }
-    return myTradeSlots_;
-}
-const std::array<GameHandler::TradeSlot, GameHandler::TRADE_SLOT_COUNT>& GameHandler::getPeerTradeSlots() const {
-    if (inventoryHandler_) {
-        static std::array<TradeSlot, TRADE_SLOT_COUNT> converted{};
-        const auto& src = inventoryHandler_->getPeerTradeSlots();
-        for (size_t i = 0; i < TRADE_SLOT_COUNT; i++) {
-            converted[i].itemId = src[i].itemId;
-            converted[i].displayId = src[i].displayId;
-            converted[i].stackCount = src[i].stackCount;
-            converted[i].itemGuid = src[i].itemGuid;
-        }
-        return converted;
-    }
-    return peerTradeSlots_;
-}
-uint64_t GameHandler::getMyTradeGold() const {
-    return inventoryHandler_ ? inventoryHandler_->getMyTradeGold() : myTradeGold_;
-}
-uint64_t GameHandler::getPeerTradeGold() const {
-    return inventoryHandler_ ? inventoryHandler_->getPeerTradeGold() : peerTradeGold_;
-}
-
-bool GameHandler::supportsEquipmentSets() const {
-    return inventoryHandler_ && inventoryHandler_->supportsEquipmentSets();
-}
-
-void GameHandler::useEquipmentSet(uint32_t setId) {
-    if (inventoryHandler_) inventoryHandler_->useEquipmentSet(setId);
-}
-
-void GameHandler::saveEquipmentSet(const std::string& name, const std::string& iconName,
-                                    uint64_t existingGuid, uint32_t setIndex) {
-    if (inventoryHandler_) inventoryHandler_->saveEquipmentSet(name, iconName, existingGuid, setIndex);
-}
-
-void GameHandler::deleteEquipmentSet(uint64_t setGuid) {
-    if (inventoryHandler_) inventoryHandler_->deleteEquipmentSet(setGuid);
-}
-
-// --- Inventory state delegation (canonical state lives in InventoryHandler) ---
-
-// Item text
-bool GameHandler::isItemTextOpen() const {
-    return inventoryHandler_ ? inventoryHandler_->isItemTextOpen() : itemTextOpen_;
-}
-const std::string& GameHandler::getItemText() const {
-    if (inventoryHandler_) return inventoryHandler_->getItemText();
-    return itemText_;
-}
-void GameHandler::closeItemText() {
-    if (inventoryHandler_) inventoryHandler_->closeItemText();
-    else itemTextOpen_ = false;
-}
-
-// Loot
-bool GameHandler::isLootWindowOpen() const {
-    return inventoryHandler_ ? inventoryHandler_->isLootWindowOpen() : lootWindowOpen;
-}
-const LootResponseData& GameHandler::getCurrentLoot() const {
-    if (inventoryHandler_) return inventoryHandler_->getCurrentLoot();
-    return currentLoot;
-}
-void GameHandler::setAutoLoot(bool enabled) {
-    if (inventoryHandler_) inventoryHandler_->setAutoLoot(enabled);
-    else autoLoot_ = enabled;
-}
-bool GameHandler::isAutoLoot() const {
-    return inventoryHandler_ ? inventoryHandler_->isAutoLoot() : autoLoot_;
-}
-void GameHandler::setAutoSellGrey(bool enabled) {
-    if (inventoryHandler_) inventoryHandler_->setAutoSellGrey(enabled);
-    else autoSellGrey_ = enabled;
-}
-bool GameHandler::isAutoSellGrey() const {
-    return inventoryHandler_ ? inventoryHandler_->isAutoSellGrey() : autoSellGrey_;
-}
-void GameHandler::setAutoRepair(bool enabled) {
-    if (inventoryHandler_) inventoryHandler_->setAutoRepair(enabled);
-    else autoRepair_ = enabled;
-}
-bool GameHandler::isAutoRepair() const {
-    return inventoryHandler_ ? inventoryHandler_->isAutoRepair() : autoRepair_;
-}
-const std::vector<uint64_t>& GameHandler::getMasterLootCandidates() const {
-    if (inventoryHandler_) return inventoryHandler_->getMasterLootCandidates();
-    return masterLootCandidates_;
-}
-bool GameHandler::hasMasterLootCandidates() const {
-    return inventoryHandler_ ? inventoryHandler_->hasMasterLootCandidates() : !masterLootCandidates_.empty();
-}
-bool GameHandler::hasPendingLootRoll() const {
-    return inventoryHandler_ ? inventoryHandler_->hasPendingLootRoll() : pendingLootRollActive_;
-}
-const LootRollEntry& GameHandler::getPendingLootRoll() const {
-    if (inventoryHandler_) return inventoryHandler_->getPendingLootRoll();
-    return pendingLootRoll_;
-}
-
-// Vendor
-bool GameHandler::isVendorWindowOpen() const {
-    return inventoryHandler_ ? inventoryHandler_->isVendorWindowOpen() : vendorWindowOpen;
-}
-const ListInventoryData& GameHandler::getVendorItems() const {
-    if (inventoryHandler_) return inventoryHandler_->getVendorItems();
-    return currentVendorItems;
-}
-void GameHandler::setVendorCanRepair(bool v) {
-    if (inventoryHandler_) inventoryHandler_->setVendorCanRepair(v);
-    else currentVendorItems.canRepair = v;
-}
-const std::deque<GameHandler::BuybackItem>& GameHandler::getBuybackItems() const {
-    if (inventoryHandler_) {
-        // Layout-identical structs (InventoryHandler::BuybackItem == GameHandler::BuybackItem)
-        return reinterpret_cast<const std::deque<BuybackItem>&>(inventoryHandler_->getBuybackItems());
-    }
-    return buybackItems_;
-}
-uint64_t GameHandler::getVendorGuid() const {
-    if (inventoryHandler_) return inventoryHandler_->getVendorGuid();
-    return currentVendorItems.vendorGuid;
-}
-
-// Mail
-bool GameHandler::isMailboxOpen() const {
-    return inventoryHandler_ ? inventoryHandler_->isMailboxOpen() : mailboxOpen_;
-}
-const std::vector<MailMessage>& GameHandler::getMailInbox() const {
-    if (inventoryHandler_) return inventoryHandler_->getMailInbox();
-    return mailInbox_;
-}
-int GameHandler::getSelectedMailIndex() const {
-    return inventoryHandler_ ? inventoryHandler_->getSelectedMailIndex() : selectedMailIndex_;
-}
-void GameHandler::setSelectedMailIndex(int idx) {
-    if (inventoryHandler_) inventoryHandler_->setSelectedMailIndex(idx);
-    else selectedMailIndex_ = idx;
-}
-bool GameHandler::isMailComposeOpen() const {
-    return inventoryHandler_ ? inventoryHandler_->isMailComposeOpen() : showMailCompose_;
-}
-void GameHandler::openMailCompose() {
-    if (inventoryHandler_) inventoryHandler_->openMailCompose();
-    else { showMailCompose_ = true; clearMailAttachments(); }
-}
-void GameHandler::closeMailCompose() {
-    if (inventoryHandler_) inventoryHandler_->closeMailCompose();
-    else { showMailCompose_ = false; clearMailAttachments(); }
-}
-bool GameHandler::hasNewMail() const {
-    return inventoryHandler_ ? inventoryHandler_->hasNewMail() : hasNewMail_;
-}
-const std::array<GameHandler::MailAttachSlot, 12>& GameHandler::getMailAttachments() const {
-    if (inventoryHandler_) {
-        // Layout-identical structs (InventoryHandler::MailAttachSlot == GameHandler::MailAttachSlot)
-        return reinterpret_cast<const std::array<MailAttachSlot, 12>&>(inventoryHandler_->getMailAttachments());
-    }
-    return mailAttachments_;
-}
-
-// Bank
-bool GameHandler::isBankOpen() const {
-    return inventoryHandler_ ? inventoryHandler_->isBankOpen() : bankOpen_;
-}
-uint64_t GameHandler::getBankerGuid() const {
-    return inventoryHandler_ ? inventoryHandler_->getBankerGuid() : bankerGuid_;
-}
-int GameHandler::getEffectiveBankSlots() const {
-    return inventoryHandler_ ? inventoryHandler_->getEffectiveBankSlots() : effectiveBankSlots_;
-}
-int GameHandler::getEffectiveBankBagSlots() const {
-    return inventoryHandler_ ? inventoryHandler_->getEffectiveBankBagSlots() : effectiveBankBagSlots_;
-}
-
-// Guild Bank
-bool GameHandler::isGuildBankOpen() const {
-    return inventoryHandler_ ? inventoryHandler_->isGuildBankOpen() : guildBankOpen_;
-}
-const GuildBankData& GameHandler::getGuildBankData() const {
-    if (inventoryHandler_) return inventoryHandler_->getGuildBankData();
-    return guildBankData_;
-}
-uint8_t GameHandler::getGuildBankActiveTab() const {
-    return inventoryHandler_ ? inventoryHandler_->getGuildBankActiveTab() : guildBankActiveTab_;
-}
-void GameHandler::setGuildBankActiveTab(uint8_t tab) {
-    if (inventoryHandler_) inventoryHandler_->setGuildBankActiveTab(tab);
-    else guildBankActiveTab_ = tab;
-}
-
-// Auction House
-bool GameHandler::isAuctionHouseOpen() const {
-    return inventoryHandler_ ? inventoryHandler_->isAuctionHouseOpen() : auctionOpen_;
-}
-uint64_t GameHandler::getAuctioneerGuid() const {
-    return inventoryHandler_ ? inventoryHandler_->getAuctioneerGuid() : auctioneerGuid_;
-}
-const AuctionListResult& GameHandler::getAuctionBrowseResults() const {
-    if (inventoryHandler_) return inventoryHandler_->getAuctionBrowseResults();
-    return auctionBrowseResults_;
-}
-const AuctionListResult& GameHandler::getAuctionOwnerResults() const {
-    if (inventoryHandler_) return inventoryHandler_->getAuctionOwnerResults();
-    return auctionOwnerResults_;
-}
-const AuctionListResult& GameHandler::getAuctionBidderResults() const {
-    if (inventoryHandler_) return inventoryHandler_->getAuctionBidderResults();
-    return auctionBidderResults_;
-}
-int GameHandler::getAuctionActiveTab() const {
-    return inventoryHandler_ ? inventoryHandler_->getAuctionActiveTab() : auctionActiveTab_;
-}
-void GameHandler::setAuctionActiveTab(int tab) {
-    if (inventoryHandler_) inventoryHandler_->setAuctionActiveTab(tab);
-    else auctionActiveTab_ = tab;
-}
-float GameHandler::getAuctionSearchDelay() const {
-    return inventoryHandler_ ? inventoryHandler_->getAuctionSearchDelay() : auctionSearchDelayTimer_;
-}
-
-// Trainer
-bool GameHandler::isTrainerWindowOpen() const {
-    return inventoryHandler_ ? inventoryHandler_->isTrainerWindowOpen() : trainerWindowOpen_;
-}
-const TrainerListData& GameHandler::getTrainerSpells() const {
-    if (inventoryHandler_) return inventoryHandler_->getTrainerSpells();
-    return currentTrainerList_;
-}
-const std::vector<GameHandler::TrainerTab>& GameHandler::getTrainerTabs() const {
-    if (inventoryHandler_) {
-        // Layout-identical structs (InventoryHandler::TrainerTab == GameHandler::TrainerTab)
-        return reinterpret_cast<const std::vector<TrainerTab>&>(inventoryHandler_->getTrainerTabs());
-    }
-    return trainerTabs_;
-}
-
-void GameHandler::sendMinimapPing(float wowX, float wowY) {
-    if (socialHandler_) socialHandler_->sendMinimapPing(wowX, wowY);
-}
-
 void GameHandler::handlePong(network::Packet& packet) {
     LOG_DEBUG("Handling SMSG_PONG");
 
@@ -4779,741 +6656,6279 @@ void GameHandler::handlePong(network::Packet& packet) {
         return;
     }
 
-    // Measure round-trip time
-    auto rtt = std::chrono::steady_clock::now() - pingTimestamp_;
-    lastLatency = static_cast<uint32_t>(
-        std::chrono::duration_cast<std::chrono::milliseconds>(rtt).count());
-
-    LOG_DEBUG("SMSG_PONG acknowledged: sequence=", data.sequence,
-              " latencyMs=", lastLatency);
-}
-
-bool GameHandler::isServerMovementAllowed() const {
-    return movementHandler_ ? movementHandler_->isServerMovementAllowed() : true;
+    LOG_DEBUG("Heartbeat acknowledged (sequence: ", data.sequence, ")");
 }
 
 uint32_t GameHandler::nextMovementTimestampMs() {
-    if (movementHandler_) return movementHandler_->nextMovementTimestampMs();
-    return 0;
+    auto now = std::chrono::steady_clock::now();
+    uint64_t elapsed = static_cast<uint64_t>(
+        std::chrono::duration_cast<std::chrono::milliseconds>(now - movementClockStart_).count()) + 1ULL;
+    if (elapsed > std::numeric_limits<uint32_t>::max()) {
+        movementClockStart_ = now;
+        elapsed = 1ULL;
+    }
+
+    uint32_t candidate = static_cast<uint32_t>(elapsed);
+    if (candidate <= lastMovementTimestampMs_) {
+        candidate = lastMovementTimestampMs_ + 1U;
+        if (candidate == 0) {
+            movementClockStart_ = now;
+            candidate = 1U;
+        }
+    }
+
+    lastMovementTimestampMs_ = candidate;
+    return candidate;
 }
 
 void GameHandler::sendMovement(Opcode opcode) {
-    if (movementHandler_) movementHandler_->sendMovement(opcode);
+    if (state != WorldState::IN_WORLD) {
+        LOG_WARNING("Cannot send movement in state: ", (int)state);
+        return;
+    }
+
+    // Block manual movement while taxi is active/mounted, but always allow
+    // stop/heartbeat opcodes so stuck states can be recovered.
+    bool taxiAllowed =
+        (opcode == Opcode::MSG_MOVE_HEARTBEAT) ||
+        (opcode == Opcode::MSG_MOVE_STOP) ||
+        (opcode == Opcode::MSG_MOVE_STOP_STRAFE) ||
+        (opcode == Opcode::MSG_MOVE_STOP_TURN) ||
+        (opcode == Opcode::MSG_MOVE_STOP_SWIM);
+    if (!serverMovementAllowed_ && !taxiAllowed) return;
+    if ((onTaxiFlight_ || taxiMountActive_) && !taxiAllowed) return;
+    if (resurrectPending_ && !taxiAllowed) return;
+
+    // Always send a strictly increasing non-zero client movement clock value.
+    movementInfo.time = nextMovementTimestampMs();
+
+    // Update movement flags based on opcode
+    switch (opcode) {
+        case Opcode::MSG_MOVE_START_FORWARD:
+            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::FORWARD);
+            break;
+        case Opcode::MSG_MOVE_START_BACKWARD:
+            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::BACKWARD);
+            break;
+        case Opcode::MSG_MOVE_STOP:
+            movementInfo.flags &= ~(static_cast<uint32_t>(MovementFlags::FORWARD) |
+                                    static_cast<uint32_t>(MovementFlags::BACKWARD));
+            break;
+        case Opcode::MSG_MOVE_START_STRAFE_LEFT:
+            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::STRAFE_LEFT);
+            break;
+        case Opcode::MSG_MOVE_START_STRAFE_RIGHT:
+            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::STRAFE_RIGHT);
+            break;
+        case Opcode::MSG_MOVE_STOP_STRAFE:
+            movementInfo.flags &= ~(static_cast<uint32_t>(MovementFlags::STRAFE_LEFT) |
+                                    static_cast<uint32_t>(MovementFlags::STRAFE_RIGHT));
+            break;
+        case Opcode::MSG_MOVE_JUMP:
+            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::FALLING);
+            break;
+        case Opcode::MSG_MOVE_START_TURN_LEFT:
+            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::TURN_LEFT);
+            break;
+        case Opcode::MSG_MOVE_START_TURN_RIGHT:
+            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::TURN_RIGHT);
+            break;
+        case Opcode::MSG_MOVE_STOP_TURN:
+            movementInfo.flags &= ~(static_cast<uint32_t>(MovementFlags::TURN_LEFT) |
+                                    static_cast<uint32_t>(MovementFlags::TURN_RIGHT));
+            break;
+        case Opcode::MSG_MOVE_FALL_LAND:
+            movementInfo.flags &= ~static_cast<uint32_t>(MovementFlags::FALLING);
+            break;
+        case Opcode::MSG_MOVE_HEARTBEAT:
+            // No flag changes — just sends current position
+            break;
+        default:
+            break;
+    }
+
+    if (onTaxiFlight_ || taxiMountActive_ || taxiActivatePending_ || taxiClientActive_) {
+        sanitizeMovementForTaxi();
+    }
+
+    // Add transport data if player is on a transport
+    if (isOnTransport()) {
+        // Keep authoritative world position synchronized to parent transport transform
+        // so heartbeats/corrections don't drag the passenger through geometry.
+        if (transportManager_) {
+            glm::vec3 composed = transportManager_->getPlayerWorldPosition(playerTransportGuid_, playerTransportOffset_);
+            movementInfo.x = composed.x;
+            movementInfo.y = composed.y;
+            movementInfo.z = composed.z;
+        }
+        movementInfo.flags |= static_cast<uint32_t>(MovementFlags::ONTRANSPORT);
+        movementInfo.transportGuid = playerTransportGuid_;
+        movementInfo.transportX = playerTransportOffset_.x;
+        movementInfo.transportY = playerTransportOffset_.y;
+        movementInfo.transportZ = playerTransportOffset_.z;
+        movementInfo.transportTime = movementInfo.time;
+        movementInfo.transportSeat = -1;
+        movementInfo.transportTime2 = movementInfo.time;
+
+        // ONTRANSPORT expects local orientation (player yaw relative to transport yaw).
+        // Keep internal yaw canonical; convert to server yaw on the wire.
+        float transportYawCanonical = 0.0f;
+        if (transportManager_) {
+            if (auto* tr = transportManager_->getTransport(playerTransportGuid_); tr) {
+                if (tr->hasServerYaw) {
+                    transportYawCanonical = tr->serverYaw;
+                } else {
+                    transportYawCanonical = glm::eulerAngles(tr->rotation).z;
+                }
+            }
+        }
+
+        movementInfo.transportO =
+            core::coords::normalizeAngleRad(movementInfo.orientation - transportYawCanonical);
+    } else {
+        // Clear transport flag if not on transport
+        movementInfo.flags &= ~static_cast<uint32_t>(MovementFlags::ONTRANSPORT);
+        movementInfo.transportGuid = 0;
+        movementInfo.transportSeat = -1;
+    }
+
+    LOG_DEBUG("Sending movement packet: opcode=0x", std::hex,
+              wireOpcode(opcode), std::dec,
+              (isOnTransport() ? " ONTRANSPORT" : ""));
+
+    // Convert canonical → server coordinates for the wire
+    MovementInfo wireInfo = movementInfo;
+    glm::vec3 serverPos = core::coords::canonicalToServer(glm::vec3(wireInfo.x, wireInfo.y, wireInfo.z));
+    wireInfo.x = serverPos.x;
+    wireInfo.y = serverPos.y;
+    wireInfo.z = serverPos.z;
+
+    // Convert canonical → server yaw for the wire
+    wireInfo.orientation = core::coords::canonicalToServerYaw(wireInfo.orientation);
+
+    // Also convert transport local position to server coordinates if on transport
+    if (isOnTransport()) {
+        glm::vec3 serverTransportPos = core::coords::canonicalToServer(
+            glm::vec3(wireInfo.transportX, wireInfo.transportY, wireInfo.transportZ));
+        wireInfo.transportX = serverTransportPos.x;
+        wireInfo.transportY = serverTransportPos.y;
+        wireInfo.transportZ = serverTransportPos.z;
+        // transportO is a local delta; server<->canonical swap negates delta yaw.
+        wireInfo.transportO = core::coords::normalizeAngleRad(-wireInfo.transportO);
+    }
+
+    // Build and send movement packet (expansion-specific format)
+    auto packet = packetParsers_
+        ? packetParsers_->buildMovementPacket(opcode, wireInfo, playerGuid)
+        : MovementPacket::build(opcode, wireInfo, playerGuid);
+    socket->send(packet);
 }
 
 void GameHandler::sanitizeMovementForTaxi() {
-    if (movementHandler_) movementHandler_->sanitizeMovementForTaxi();
+    constexpr uint32_t kClearTaxiFlags =
+        static_cast<uint32_t>(MovementFlags::FORWARD) |
+        static_cast<uint32_t>(MovementFlags::BACKWARD) |
+        static_cast<uint32_t>(MovementFlags::STRAFE_LEFT) |
+        static_cast<uint32_t>(MovementFlags::STRAFE_RIGHT) |
+        static_cast<uint32_t>(MovementFlags::TURN_LEFT) |
+        static_cast<uint32_t>(MovementFlags::TURN_RIGHT) |
+        static_cast<uint32_t>(MovementFlags::PITCH_UP) |
+        static_cast<uint32_t>(MovementFlags::PITCH_DOWN) |
+        static_cast<uint32_t>(MovementFlags::FALLING) |
+        static_cast<uint32_t>(MovementFlags::FALLINGFAR) |
+        static_cast<uint32_t>(MovementFlags::SWIMMING);
+
+    movementInfo.flags &= ~kClearTaxiFlags;
+    movementInfo.fallTime = 0;
+    movementInfo.jumpVelocity = 0.0f;
+    movementInfo.jumpSinAngle = 0.0f;
+    movementInfo.jumpCosAngle = 0.0f;
+    movementInfo.jumpXYSpeed = 0.0f;
+    movementInfo.pitch = 0.0f;
 }
 
 void GameHandler::forceClearTaxiAndMovementState() {
-    if (movementHandler_) movementHandler_->forceClearTaxiAndMovementState();
+    taxiActivatePending_ = false;
+    taxiActivateTimer_ = 0.0f;
+    taxiClientActive_ = false;
+    taxiClientPath_.clear();
+    taxiRecoverPending_ = false;
+    taxiStartGrace_ = 0.0f;
+    onTaxiFlight_ = false;
+
+    if (taxiMountActive_ && mountCallback_) {
+        mountCallback_(0);
+    }
+    taxiMountActive_ = false;
+    taxiMountDisplayId_ = 0;
+    currentMountDisplayId_ = 0;
+    resurrectPending_ = false;
+    resurrectRequestPending_ = false;
+    playerDead_ = false;
+    releasedSpirit_ = false;
+    repopPending_ = false;
+    pendingSpiritHealerGuid_ = 0;
+    resurrectCasterGuid_ = 0;
+
+    movementInfo.flags = 0;
+    movementInfo.flags2 = 0;
+    movementInfo.transportGuid = 0;
+    clearPlayerTransport();
+
+    if (socket && state == WorldState::IN_WORLD) {
+        sendMovement(Opcode::MSG_MOVE_STOP);
+        sendMovement(Opcode::MSG_MOVE_STOP_STRAFE);
+        sendMovement(Opcode::MSG_MOVE_STOP_TURN);
+        sendMovement(Opcode::MSG_MOVE_STOP_SWIM);
+        sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
+    }
+
+    LOG_INFO("Force-cleared taxi/movement state");
 }
 
 void GameHandler::setPosition(float x, float y, float z) {
-    if (movementHandler_) movementHandler_->setPosition(x, y, z);
+    movementInfo.x = x;
+    movementInfo.y = y;
+    movementInfo.z = z;
 }
 
 void GameHandler::setOrientation(float orientation) {
-    if (movementHandler_) movementHandler_->setOrientation(orientation);
+    movementInfo.orientation = orientation;
 }
 
-// Entity lifecycle methods (handleUpdateObject, processOutOfRangeObjects,
-// applyUpdateObjectBlock, finalizeUpdateObjectBatch, handleCompressedUpdateObject,
-// handleDestroyObject) moved to EntityController — see entity_controller.cpp
+void GameHandler::handleUpdateObject(network::Packet& packet) {
+    static const bool kVerboseUpdateObject = envFlagEnabled("WOWEE_LOG_UPDATE_OBJECT_VERBOSE", false);
+    UpdateObjectData data;
+    if (!packetParsers_->parseUpdateObject(packet, data)) {
+        static int updateObjErrors = 0;
+        if (++updateObjErrors <= 5)
+            LOG_WARNING("Failed to parse SMSG_UPDATE_OBJECT");
+        return;
+    }
 
-void GameHandler::sendChatMessage(ChatType type, const std::string& message, const std::string& target) {
-    if (chatHandler_) chatHandler_->sendChatMessage(type, message, target);
-}
+    auto extractPlayerAppearance = [&](const std::map<uint16_t, uint32_t>& fields,
+                                       uint8_t& outRace,
+                                       uint8_t& outGender,
+                                       uint32_t& outAppearanceBytes,
+                                       uint8_t& outFacial) -> bool {
+        outRace = 0;
+        outGender = 0;
+        outAppearanceBytes = 0;
+        outFacial = 0;
 
-void GameHandler::sendTextEmote(uint32_t textEmoteId, uint64_t targetGuid) {
-    if (chatHandler_) chatHandler_->sendTextEmote(textEmoteId, targetGuid);
-}
+        auto readField = [&](uint16_t idx, uint32_t& out) -> bool {
+            if (idx == 0xFFFF) return false;
+            auto it = fields.find(idx);
+            if (it == fields.end()) return false;
+            out = it->second;
+            return true;
+        };
 
-void GameHandler::joinChannel(const std::string& channelName, const std::string& password) {
-    if (chatHandler_) chatHandler_->joinChannel(channelName, password);
-}
+        uint32_t bytes0 = 0;
+        uint32_t pbytes = 0;
+        uint32_t pbytes2 = 0;
 
-void GameHandler::leaveChannel(const std::string& channelName) {
-    if (chatHandler_) chatHandler_->leaveChannel(channelName);
-}
+        const uint16_t ufBytes0 = fieldIndex(UF::UNIT_FIELD_BYTES_0);
+        const uint16_t ufPbytes = fieldIndex(UF::PLAYER_BYTES);
+        const uint16_t ufPbytes2 = fieldIndex(UF::PLAYER_BYTES_2);
 
-std::string GameHandler::getChannelByIndex(int index) const {
-    return chatHandler_ ? chatHandler_->getChannelByIndex(index) : "";
-}
+        bool haveBytes0 = readField(ufBytes0, bytes0);
+        bool havePbytes = readField(ufPbytes, pbytes);
+        bool havePbytes2 = readField(ufPbytes2, pbytes2);
 
-int GameHandler::getChannelIndex(const std::string& channelName) const {
-    return chatHandler_ ? chatHandler_->getChannelIndex(channelName) : 0;
-}
+        // Heuristic fallback: Turtle can run with unusual build numbers; if the JSON table is missing,
+        // try to locate plausible packed fields by scanning.
+        if (!haveBytes0) {
+            for (const auto& [idx, v] : fields) {
+                uint8_t race = static_cast<uint8_t>(v & 0xFF);
+                uint8_t cls = static_cast<uint8_t>((v >> 8) & 0xFF);
+                uint8_t gender = static_cast<uint8_t>((v >> 16) & 0xFF);
+                uint8_t power = static_cast<uint8_t>((v >> 24) & 0xFF);
+                if (race >= 1 && race <= 20 &&
+                    cls >= 1 && cls <= 20 &&
+                    gender <= 1 &&
+                    power <= 10) {
+                    bytes0 = v;
+                    haveBytes0 = true;
+                    break;
+                }
+            }
+        }
+        if (!havePbytes) {
+            for (const auto& [idx, v] : fields) {
+                uint8_t skin = static_cast<uint8_t>(v & 0xFF);
+                uint8_t face = static_cast<uint8_t>((v >> 8) & 0xFF);
+                uint8_t hair = static_cast<uint8_t>((v >> 16) & 0xFF);
+                uint8_t color = static_cast<uint8_t>((v >> 24) & 0xFF);
+                if (skin <= 50 && face <= 50 && hair <= 100 && color <= 50) {
+                    pbytes = v;
+                    havePbytes = true;
+                    break;
+                }
+            }
+        }
+        if (!havePbytes2) {
+            for (const auto& [idx, v] : fields) {
+                uint8_t facial = static_cast<uint8_t>(v & 0xFF);
+                if (facial <= 100) {
+                    pbytes2 = v;
+                    havePbytes2 = true;
+                    break;
+                }
+            }
+        }
 
-void GameHandler::autoJoinDefaultChannels() {
-    if (chatHandler_) {
-        chatHandler_->chatAutoJoin.general = chatAutoJoin.general;
-        chatHandler_->chatAutoJoin.trade = chatAutoJoin.trade;
-        chatHandler_->chatAutoJoin.localDefense = chatAutoJoin.localDefense;
-        chatHandler_->chatAutoJoin.lfg = chatAutoJoin.lfg;
-        chatHandler_->chatAutoJoin.local = chatAutoJoin.local;
-        chatHandler_->autoJoinDefaultChannels();
+        if (!haveBytes0 || !havePbytes) return false;
+
+        outRace = static_cast<uint8_t>(bytes0 & 0xFF);
+        outGender = static_cast<uint8_t>((bytes0 >> 16) & 0xFF);
+        outAppearanceBytes = pbytes;
+        outFacial = havePbytes2 ? static_cast<uint8_t>(pbytes2 & 0xFF) : 0;
+        return true;
+    };
+
+    auto maybeDetectCoinageIndex = [&](const std::map<uint16_t, uint32_t>& oldFields,
+                                       const std::map<uint16_t, uint32_t>& newFields) {
+        if (pendingMoneyDelta_ == 0 || pendingMoneyDeltaTimer_ <= 0.0f) return;
+        if (oldFields.empty() || newFields.empty()) return;
+
+        constexpr uint32_t kMaxPlausibleCoinage = 2147483647u;
+        std::vector<uint16_t> candidates;
+        candidates.reserve(8);
+
+        for (const auto& [idx, newVal] : newFields) {
+            auto itOld = oldFields.find(idx);
+            if (itOld == oldFields.end()) continue;
+            uint32_t oldVal = itOld->second;
+            if (newVal < oldVal) continue;
+            uint32_t delta = newVal - oldVal;
+            if (delta != pendingMoneyDelta_) continue;
+            if (newVal > kMaxPlausibleCoinage) continue;
+            candidates.push_back(idx);
+        }
+
+        if (candidates.empty()) return;
+
+        uint16_t current = fieldIndex(UF::PLAYER_FIELD_COINAGE);
+        uint16_t chosen = candidates[0];
+        if (std::find(candidates.begin(), candidates.end(), current) != candidates.end()) {
+            chosen = current;
+        } else {
+            std::sort(candidates.begin(), candidates.end());
+            chosen = candidates[0];
+        }
+
+        if (chosen != current && current != 0xFFFF) {
+            updateFieldTable_.setIndex(UF::PLAYER_FIELD_COINAGE, chosen);
+            LOG_WARNING("Auto-detected PLAYER_FIELD_COINAGE index: ", chosen, " (was ", current, ")");
+        }
+
+        pendingMoneyDelta_ = 0;
+        pendingMoneyDeltaTimer_ = 0.0f;
+    };
+
+    // Process out-of-range objects first
+    for (uint64_t guid : data.outOfRangeGuids) {
+        auto entity = entityManager.getEntity(guid);
+        if (!entity) continue;
+
+        const bool isKnownTransport = transportGuids_.count(guid) > 0;
+        if (isKnownTransport) {
+            // Keep transports alive across out-of-range flapping.
+            // Boats/zeppelins are global movers and removing them here can make
+            // them disappear until a later movement snapshot happens to recreate them.
+            const bool playerAboardNow = (playerTransportGuid_ == guid);
+            const bool stickyAboard = (playerTransportStickyGuid_ == guid && playerTransportStickyTimer_ > 0.0f);
+            const bool movementSaysAboard = (movementInfo.transportGuid == guid);
+            LOG_INFO("Preserving transport on out-of-range: 0x",
+                     std::hex, guid, std::dec,
+                     " now=", playerAboardNow,
+                     " sticky=", stickyAboard,
+                     " movement=", movementSaysAboard);
+            continue;
+        }
+
+        LOG_DEBUG("Entity went out of range: 0x", std::hex, guid, std::dec);
+        // Trigger despawn callbacks before removing entity
+        if (entity->getType() == ObjectType::UNIT && creatureDespawnCallback_) {
+            creatureDespawnCallback_(guid);
+        } else if (entity->getType() == ObjectType::PLAYER && playerDespawnCallback_) {
+            playerDespawnCallback_(guid);
+            otherPlayerVisibleItemEntries_.erase(guid);
+            otherPlayerVisibleDirty_.erase(guid);
+            otherPlayerMoveTimeMs_.erase(guid);
+            inspectedPlayerItemEntries_.erase(guid);
+            pendingAutoInspect_.erase(guid);
+        } else if (entity->getType() == ObjectType::GAMEOBJECT && gameObjectDespawnCallback_) {
+            gameObjectDespawnCallback_(guid);
+        }
+        transportGuids_.erase(guid);
+        serverUpdatedTransportGuids_.erase(guid);
+        clearTransportAttachment(guid);
+        if (playerTransportGuid_ == guid) {
+            clearPlayerTransport();
+        }
+        entityManager.removeEntity(guid);
+    }
+
+    // Process update blocks
+    bool newItemCreated = false;
+    for (const auto& block : data.blocks) {
+        switch (block.updateType) {
+            case UpdateType::CREATE_OBJECT:
+            case UpdateType::CREATE_OBJECT2: {
+                // Create new entity
+                std::shared_ptr<Entity> entity;
+
+                switch (block.objectType) {
+                    case ObjectType::PLAYER:
+                        entity = std::make_shared<Player>(block.guid);
+                        break;
+
+                    case ObjectType::UNIT:
+                        entity = std::make_shared<Unit>(block.guid);
+                        break;
+
+                    case ObjectType::GAMEOBJECT:
+                        entity = std::make_shared<GameObject>(block.guid);
+                        break;
+
+                    default:
+                        entity = std::make_shared<Entity>(block.guid);
+                        entity->setType(block.objectType);
+                        break;
+                }
+
+                // Set position from movement block (server → canonical)
+                if (block.hasMovement) {
+                    glm::vec3 pos = core::coords::serverToCanonical(glm::vec3(block.x, block.y, block.z));
+                    float oCanonical = core::coords::serverToCanonicalYaw(block.orientation);
+                    entity->setPosition(pos.x, pos.y, pos.z, oCanonical);
+                    LOG_DEBUG("  Position: (", pos.x, ", ", pos.y, ", ", pos.z, ")");
+                    if (block.guid == playerGuid && block.runSpeed > 0.1f && block.runSpeed < 100.0f) {
+                        serverRunSpeed_ = block.runSpeed;
+                    }
+                    // Track player-on-transport state
+                    if (block.guid == playerGuid) {
+                        if (block.onTransport) {
+                            setPlayerOnTransport(block.transportGuid, glm::vec3(0.0f));
+                            // Convert transport offset from server → canonical coordinates
+                            glm::vec3 serverOffset(block.transportX, block.transportY, block.transportZ);
+                            playerTransportOffset_ = core::coords::serverToCanonical(serverOffset);
+                            if (transportManager_ && transportManager_->getTransport(playerTransportGuid_)) {
+                                glm::vec3 composed = transportManager_->getPlayerWorldPosition(playerTransportGuid_, playerTransportOffset_);
+                                entity->setPosition(composed.x, composed.y, composed.z, oCanonical);
+                                movementInfo.x = composed.x;
+                                movementInfo.y = composed.y;
+                                movementInfo.z = composed.z;
+                            }
+                            LOG_INFO("Player on transport: 0x", std::hex, playerTransportGuid_, std::dec,
+                                    " offset=(", playerTransportOffset_.x, ", ", playerTransportOffset_.y, ", ", playerTransportOffset_.z, ")");
+                        } else {
+                            // Don't clear client-side M2 transport boarding (trams) —
+                            // the server doesn't know about client-detected transport attachment.
+                            bool isClientM2Transport = false;
+                            if (playerTransportGuid_ != 0 && transportManager_) {
+                                auto* tr = transportManager_->getTransport(playerTransportGuid_);
+                                isClientM2Transport = (tr && tr->isM2);
+                            }
+                            if (playerTransportGuid_ != 0 && !isClientM2Transport) {
+                                LOG_INFO("Player left transport");
+                                clearPlayerTransport();
+                            }
+                        }
+                    }
+
+                    // Track transport-relative children so they follow parent transport motion.
+                    if (block.guid != playerGuid &&
+                        (block.objectType == ObjectType::UNIT || block.objectType == ObjectType::GAMEOBJECT)) {
+                        if (block.onTransport && block.transportGuid != 0) {
+                            glm::vec3 localOffset = core::coords::serverToCanonical(
+                                glm::vec3(block.transportX, block.transportY, block.transportZ));
+                            const bool hasLocalOrientation = (block.updateFlags & 0x0020) != 0; // UPDATEFLAG_LIVING
+                            float localOriCanonical = core::coords::normalizeAngleRad(-block.transportO);
+                            setTransportAttachment(block.guid, block.objectType, block.transportGuid,
+                                                   localOffset, hasLocalOrientation, localOriCanonical);
+                            if (transportManager_ && transportManager_->getTransport(block.transportGuid)) {
+                                glm::vec3 composed = transportManager_->getPlayerWorldPosition(block.transportGuid, localOffset);
+                                entity->setPosition(composed.x, composed.y, composed.z, entity->getOrientation());
+                            }
+                        } else {
+                            clearTransportAttachment(block.guid);
+                        }
+                    }
+                }
+
+                // Set fields
+                for (const auto& field : block.fields) {
+                    entity->setField(field.first, field.second);
+                }
+
+                // Add to manager
+                entityManager.addEntity(block.guid, entity);
+
+                // For the local player, capture the full initial field state (CREATE_OBJECT carries the
+                // large baseline update-field set, including visible item fields on many cores).
+                // Later VALUES updates often only include deltas and may never touch visible item fields.
+                if (block.guid == playerGuid && block.objectType == ObjectType::PLAYER) {
+                    lastPlayerFields_ = entity->getFields();
+                    maybeDetectVisibleItemLayout();
+                }
+
+                // Auto-query names (Phase 1)
+                if (block.objectType == ObjectType::PLAYER) {
+                    queryPlayerName(block.guid);
+                    if (block.guid != playerGuid) {
+                        updateOtherPlayerVisibleItems(block.guid, entity->getFields());
+                    }
+                } else if (block.objectType == ObjectType::UNIT) {
+                    auto it = block.fields.find(fieldIndex(UF::OBJECT_FIELD_ENTRY));
+                    if (it != block.fields.end() && it->second != 0) {
+                        auto unit = std::static_pointer_cast<Unit>(entity);
+                        unit->setEntry(it->second);
+                        // Set name from cache immediately if available
+                        std::string cached = getCachedCreatureName(it->second);
+                        if (!cached.empty()) {
+                            unit->setName(cached);
+                        }
+                        queryCreatureInfo(it->second, block.guid);
+                    }
+                }
+
+                // Extract health/mana/power from fields (Phase 2) — single pass
+                if (block.objectType == ObjectType::UNIT || block.objectType == ObjectType::PLAYER) {
+                    auto unit = std::static_pointer_cast<Unit>(entity);
+                    constexpr uint32_t UNIT_DYNFLAG_DEAD = 0x0008;
+                    constexpr uint32_t UNIT_DYNFLAG_LOOTABLE = 0x0001;
+                    bool unitInitiallyDead = false;
+                    const uint16_t ufHealth = fieldIndex(UF::UNIT_FIELD_HEALTH);
+                    const uint16_t ufPowerBase = fieldIndex(UF::UNIT_FIELD_POWER1);
+                    const uint16_t ufMaxHealth = fieldIndex(UF::UNIT_FIELD_MAXHEALTH);
+                    const uint16_t ufMaxPowerBase = fieldIndex(UF::UNIT_FIELD_MAXPOWER1);
+                    const uint16_t ufLevel = fieldIndex(UF::UNIT_FIELD_LEVEL);
+                    const uint16_t ufFaction = fieldIndex(UF::UNIT_FIELD_FACTIONTEMPLATE);
+                    const uint16_t ufFlags = fieldIndex(UF::UNIT_FIELD_FLAGS);
+                    const uint16_t ufDynFlags = fieldIndex(UF::UNIT_DYNAMIC_FLAGS);
+                    const uint16_t ufDisplayId = fieldIndex(UF::UNIT_FIELD_DISPLAYID);
+                    const uint16_t ufMountDisplayId = fieldIndex(UF::UNIT_FIELD_MOUNTDISPLAYID);
+                    const uint16_t ufNpcFlags = fieldIndex(UF::UNIT_NPC_FLAGS);
+                    const uint16_t ufBytes0 = fieldIndex(UF::UNIT_FIELD_BYTES_0);
+                    for (const auto& [key, val] : block.fields) {
+                        // Check all specific fields BEFORE power/maxpower range checks.
+                        // In Classic, power indices (23-27) are adjacent to maxHealth (28),
+                        // and maxPower indices (29-33) are adjacent to level (34) and faction (35).
+                        // A range check like "key >= powerBase && key < powerBase+7" would
+                        // incorrectly capture maxHealth/level/faction in Classic's tight layout.
+                        if (key == ufHealth) {
+                            unit->setHealth(val);
+                            if (block.objectType == ObjectType::UNIT && val == 0) {
+                                unitInitiallyDead = true;
+                            }
+                            if (block.guid == playerGuid && val == 0) {
+                                playerDead_ = true;
+                                LOG_INFO("Player logged in dead");
+                            }
+                        } else if (key == ufMaxHealth) { unit->setMaxHealth(val); }
+                        else if (key == ufLevel) {
+                            unit->setLevel(val);
+                        } else if (key == ufFaction) { unit->setFactionTemplate(val); }
+                        else if (key == ufFlags) { unit->setUnitFlags(val); }
+                        else if (key == ufBytes0) {
+                            unit->setPowerType(static_cast<uint8_t>((val >> 24) & 0xFF));
+                        } else if (key == ufDisplayId) { unit->setDisplayId(val); }
+                        else if (key == ufNpcFlags) { unit->setNpcFlags(val); }
+                        else if (key == ufDynFlags) {
+                            unit->setDynamicFlags(val);
+                            if (block.objectType == ObjectType::UNIT &&
+                                ((val & UNIT_DYNFLAG_DEAD) != 0 || (val & UNIT_DYNFLAG_LOOTABLE) != 0)) {
+                                unitInitiallyDead = true;
+                            }
+                        }
+                        // Power/maxpower range checks AFTER all specific fields
+                        else if (key >= ufPowerBase && key < ufPowerBase + 7) {
+                            unit->setPowerByType(static_cast<uint8_t>(key - ufPowerBase), val);
+                        } else if (key >= ufMaxPowerBase && key < ufMaxPowerBase + 7) {
+                            unit->setMaxPowerByType(static_cast<uint8_t>(key - ufMaxPowerBase), val);
+                        }
+                        else if (key == ufMountDisplayId) {
+                            if (block.guid == playerGuid) {
+                                uint32_t old = currentMountDisplayId_;
+                                currentMountDisplayId_ = val;
+                                if (val != old && mountCallback_) mountCallback_(val);
+                                if (old == 0 && val != 0) {
+                                    // Just mounted — find the mount aura (indefinite duration, self-cast)
+                                    mountAuraSpellId_ = 0;
+                                    for (const auto& a : playerAuras) {
+                                        if (!a.isEmpty() && a.maxDurationMs < 0 && a.casterGuid == playerGuid) {
+                                            mountAuraSpellId_ = a.spellId;
+                                        }
+                                    }
+                                    // Classic/vanilla fallback: scan UNIT_FIELD_AURAS from same update block
+                                    if (mountAuraSpellId_ == 0) {
+                                        const uint16_t ufAuras = fieldIndex(UF::UNIT_FIELD_AURAS);
+                                        if (ufAuras != 0xFFFF) {
+                                            for (const auto& [fk, fv] : block.fields) {
+                                                if (fk >= ufAuras && fk < ufAuras + 48 && fv != 0) {
+                                                    mountAuraSpellId_ = fv;
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    LOG_INFO("Mount detected: displayId=", val, " auraSpellId=", mountAuraSpellId_);
+                                }
+                                if (old != 0 && val == 0) {
+                                    mountAuraSpellId_ = 0;
+                                    for (auto& a : playerAuras)
+                                        if (!a.isEmpty() && a.maxDurationMs < 0) a = AuraSlot{};
+                                }
+                            }
+                            unit->setMountDisplayId(val);
+                        } else if (key == ufNpcFlags) { unit->setNpcFlags(val); }
+                    }
+                    if (block.guid == playerGuid) {
+                        constexpr uint32_t UNIT_FLAG_TAXI_FLIGHT = 0x00000100;
+                        if ((unit->getUnitFlags() & UNIT_FLAG_TAXI_FLIGHT) != 0 && !onTaxiFlight_ && taxiLandingCooldown_ <= 0.0f) {
+                            onTaxiFlight_ = true;
+                            taxiStartGrace_ = std::max(taxiStartGrace_, 2.0f);
+                            sanitizeMovementForTaxi();
+                            applyTaxiMountForCurrentNode();
+                        }
+                    }
+                    if (block.guid == playerGuid &&
+                        (unit->getDynamicFlags() & UNIT_DYNFLAG_DEAD) != 0) {
+                        playerDead_ = true;
+                        LOG_INFO("Player logged in dead (dynamic flags)");
+                    }
+                    // Detect ghost state on login via PLAYER_FLAGS
+                    if (block.guid == playerGuid) {
+                        constexpr uint32_t PLAYER_FLAGS_GHOST = 0x00000010;
+                        auto pfIt = block.fields.find(fieldIndex(UF::PLAYER_FLAGS));
+                        if (pfIt != block.fields.end() && (pfIt->second & PLAYER_FLAGS_GHOST) != 0) {
+                            releasedSpirit_ = true;
+                            playerDead_ = true;
+                            LOG_INFO("Player logged in as ghost (PLAYER_FLAGS)");
+                        }
+                    }
+                    // Determine hostility from faction template for online creatures
+                    if (unit->getFactionTemplate() != 0) {
+                        unit->setHostile(isHostileFaction(unit->getFactionTemplate()));
+                    }
+                // Trigger creature spawn callback for units/players with displayId
+                    if (block.objectType == ObjectType::UNIT && unit->getDisplayId() == 0) {
+                        LOG_WARNING("[Spawn] UNIT guid=0x", std::hex, block.guid, std::dec,
+                                  " has displayId=0 — no spawn (entry=", unit->getEntry(),
+                                  " at ", unit->getX(), ",", unit->getY(), ",", unit->getZ(), ")");
+                    }
+                    if ((block.objectType == ObjectType::UNIT || block.objectType == ObjectType::PLAYER) && unit->getDisplayId() != 0) {
+                        if (block.objectType == ObjectType::PLAYER && block.guid == playerGuid) {
+                            // Skip local player — spawned separately via spawnPlayerCharacter()
+                        } else if (block.objectType == ObjectType::PLAYER) {
+                            if (playerSpawnCallback_) {
+                                uint8_t race = 0, gender = 0, facial = 0;
+                                uint32_t appearanceBytes = 0;
+                                // Use the entity's accumulated field state, not just this block's changed fields.
+                                if (extractPlayerAppearance(entity->getFields(), race, gender, appearanceBytes, facial)) {
+                                    playerSpawnCallback_(block.guid, unit->getDisplayId(), race, gender,
+                                                        appearanceBytes, facial,
+                                                        unit->getX(), unit->getY(), unit->getZ(), unit->getOrientation());
+                                }
+                            }
+                        } else if (creatureSpawnCallback_) {
+                            LOG_DEBUG("[Spawn] UNIT guid=0x", std::hex, block.guid, std::dec,
+                                      " displayId=", unit->getDisplayId(), " at (",
+                                      unit->getX(), ",", unit->getY(), ",", unit->getZ(), ")");
+                            creatureSpawnCallback_(block.guid, unit->getDisplayId(),
+                                unit->getX(), unit->getY(), unit->getZ(), unit->getOrientation());
+                            if (unitInitiallyDead && npcDeathCallback_) {
+                                npcDeathCallback_(block.guid);
+                            }
+                        }
+                        // Query quest giver status for NPCs with questgiver flag (0x02)
+                        if (block.objectType == ObjectType::UNIT && (unit->getNpcFlags() & 0x02) && socket) {
+                            network::Packet qsPkt(wireOpcode(Opcode::CMSG_QUESTGIVER_STATUS_QUERY));
+                            qsPkt.writeUInt64(block.guid);
+                            socket->send(qsPkt);
+                        }
+                    }
+                }
+                // Extract displayId and entry for gameobjects (3.3.5a: GAMEOBJECT_DISPLAYID = field 8)
+                if (block.objectType == ObjectType::GAMEOBJECT) {
+                    auto go = std::static_pointer_cast<GameObject>(entity);
+                    auto itDisp = block.fields.find(fieldIndex(UF::GAMEOBJECT_DISPLAYID));
+                    if (itDisp != block.fields.end()) {
+                        go->setDisplayId(itDisp->second);
+                    }
+                    auto itEntry = block.fields.find(fieldIndex(UF::OBJECT_FIELD_ENTRY));
+                    if (itEntry != block.fields.end() && itEntry->second != 0) {
+                        go->setEntry(itEntry->second);
+                        auto cacheIt = gameObjectInfoCache_.find(itEntry->second);
+                        if (cacheIt != gameObjectInfoCache_.end()) {
+                            go->setName(cacheIt->second.name);
+                        }
+                        queryGameObjectInfo(itEntry->second, block.guid);
+                    }
+                    // Detect transport GameObjects via UPDATEFLAG_TRANSPORT (0x0002)
+                    LOG_WARNING("GameObject CREATE: guid=0x", std::hex, block.guid, std::dec,
+                             " entry=", go->getEntry(), " displayId=", go->getDisplayId(),
+                             " updateFlags=0x", std::hex, block.updateFlags, std::dec,
+                             " pos=(", go->getX(), ", ", go->getY(), ", ", go->getZ(), ")");
+                    if (block.updateFlags & 0x0002) {
+                        transportGuids_.insert(block.guid);
+                        LOG_WARNING("Detected transport GameObject: 0x", std::hex, block.guid, std::dec,
+                                 " entry=", go->getEntry(),
+                                 " displayId=", go->getDisplayId(),
+                                 " pos=(", go->getX(), ", ", go->getY(), ", ", go->getZ(), ")");
+                        // Note: TransportSpawnCallback will be invoked from Application after WMO instance is created
+                    }
+                    if (go->getDisplayId() != 0 && gameObjectSpawnCallback_) {
+                        gameObjectSpawnCallback_(block.guid, go->getEntry(), go->getDisplayId(),
+                            go->getX(), go->getY(), go->getZ(), go->getOrientation());
+                    }
+                    // Fire transport move callback for transports (position update on re-creation)
+                    if (transportGuids_.count(block.guid) && transportMoveCallback_) {
+                        serverUpdatedTransportGuids_.insert(block.guid);
+                        transportMoveCallback_(block.guid,
+                            go->getX(), go->getY(), go->getZ(), go->getOrientation());
+                    }
+                }
+                // Track online item objects (CONTAINER = bags, also tracked as items)
+                if (block.objectType == ObjectType::ITEM || block.objectType == ObjectType::CONTAINER) {
+                    auto entryIt = block.fields.find(fieldIndex(UF::OBJECT_FIELD_ENTRY));
+                    auto stackIt = block.fields.find(fieldIndex(UF::ITEM_FIELD_STACK_COUNT));
+                    if (entryIt != block.fields.end() && entryIt->second != 0) {
+                        OnlineItemInfo info;
+                        info.entry = entryIt->second;
+                        info.stackCount = (stackIt != block.fields.end()) ? stackIt->second : 1;
+                        bool isNew = (onlineItems_.find(block.guid) == onlineItems_.end());
+                        onlineItems_[block.guid] = info;
+                        if (isNew) newItemCreated = true;
+                        queryItemInfo(info.entry, block.guid);
+                    }
+                    // Extract container slot GUIDs for bags
+                    if (block.objectType == ObjectType::CONTAINER) {
+                        extractContainerFields(block.guid, block.fields);
+                    }
+                }
+
+                // Extract XP / inventory slot / skill fields for player entity
+                if (block.guid == playerGuid && block.objectType == ObjectType::PLAYER) {
+                    // Auto-detect coinage index using the previous snapshot vs this full snapshot.
+                    maybeDetectCoinageIndex(lastPlayerFields_, block.fields);
+
+                    lastPlayerFields_ = block.fields;
+                    detectInventorySlotBases(block.fields);
+
+                    if (kVerboseUpdateObject) {
+                        uint16_t maxField = 0;
+                        for (const auto& [key, _val] : block.fields) {
+                            if (key > maxField) maxField = key;
+                        }
+                        LOG_INFO("Player update with ", block.fields.size(),
+                                 " fields (max index=", maxField, ")");
+                    }
+
+                    bool slotsChanged = false;
+                    const uint16_t ufPlayerXp = fieldIndex(UF::PLAYER_XP);
+                    const uint16_t ufPlayerNextXp = fieldIndex(UF::PLAYER_NEXT_LEVEL_XP);
+                    const uint16_t ufPlayerLevel = fieldIndex(UF::UNIT_FIELD_LEVEL);
+                    const uint16_t ufCoinage = fieldIndex(UF::PLAYER_FIELD_COINAGE);
+                    const uint16_t ufArmor = fieldIndex(UF::UNIT_FIELD_RESISTANCES);
+                    const uint16_t ufPBytes2 = fieldIndex(UF::PLAYER_BYTES_2);
+                    for (const auto& [key, val] : block.fields) {
+                        if (key == ufPlayerXp) { playerXp_ = val; }
+                        else if (key == ufPlayerNextXp) { playerNextLevelXp_ = val; }
+                        else if (key == ufPlayerLevel) {
+                            serverPlayerLevel_ = val;
+                            for (auto& ch : characters) {
+                                if (ch.guid == playerGuid) { ch.level = val; break; }
+                            }
+                        }
+                        else if (key == ufCoinage) {
+                            playerMoneyCopper_ = val;
+                            LOG_DEBUG("Money set from update fields: ", val, " copper");
+                        }
+                        else if (ufArmor != 0xFFFF && key == ufArmor) {
+                            playerArmorRating_ = static_cast<int32_t>(val);
+                            LOG_DEBUG("Armor rating from update fields: ", playerArmorRating_);
+                        }
+                        else if (ufPBytes2 != 0xFFFF && key == ufPBytes2) {
+                            uint8_t bankBagSlots = static_cast<uint8_t>((val >> 16) & 0xFF);
+                            LOG_WARNING("PLAYER_BYTES_2 (CREATE): raw=0x", std::hex, val, std::dec,
+                                       " bankBagSlots=", static_cast<int>(bankBagSlots));
+                            inventory.setPurchasedBankBagSlots(bankBagSlots);
+                        }
+                        // Do not synthesize quest-log entries from raw update-field slots.
+                        // Slot layouts differ on some classic-family realms and can produce
+                        // phantom "already accepted" quests that block quest acceptance.
+                    }
+                    if (applyInventoryFields(block.fields)) slotsChanged = true;
+                    if (slotsChanged) rebuildOnlineInventory();
+                    maybeDetectVisibleItemLayout();
+                    extractSkillFields(lastPlayerFields_);
+                    extractExploredZoneFields(lastPlayerFields_);
+                }
+                break;
+            }
+
+            case UpdateType::VALUES: {
+                // Update existing entity fields
+                auto entity = entityManager.getEntity(block.guid);
+                if (entity) {
+                    if (block.hasMovement) {
+                        glm::vec3 pos = core::coords::serverToCanonical(glm::vec3(block.x, block.y, block.z));
+                        float oCanonical = core::coords::serverToCanonicalYaw(block.orientation);
+                        entity->setPosition(pos.x, pos.y, pos.z, oCanonical);
+
+                        if (block.guid != playerGuid &&
+                            (entity->getType() == ObjectType::UNIT || entity->getType() == ObjectType::GAMEOBJECT)) {
+                            if (block.onTransport && block.transportGuid != 0) {
+                                glm::vec3 localOffset = core::coords::serverToCanonical(
+                                    glm::vec3(block.transportX, block.transportY, block.transportZ));
+                                const bool hasLocalOrientation = (block.updateFlags & 0x0020) != 0; // UPDATEFLAG_LIVING
+                                float localOriCanonical = core::coords::normalizeAngleRad(-block.transportO);
+                                setTransportAttachment(block.guid, entity->getType(), block.transportGuid,
+                                                       localOffset, hasLocalOrientation, localOriCanonical);
+                                if (transportManager_ && transportManager_->getTransport(block.transportGuid)) {
+                                    glm::vec3 composed = transportManager_->getPlayerWorldPosition(block.transportGuid, localOffset);
+                                    entity->setPosition(composed.x, composed.y, composed.z, entity->getOrientation());
+                                }
+                            } else {
+                                clearTransportAttachment(block.guid);
+                            }
+                        }
+                    }
+
+                    for (const auto& field : block.fields) {
+                        entity->setField(field.first, field.second);
+                    }
+
+                    if (entity->getType() == ObjectType::PLAYER && block.guid != playerGuid) {
+                        updateOtherPlayerVisibleItems(block.guid, entity->getFields());
+                    }
+
+                    // Update cached health/mana/power values (Phase 2) — single pass
+                    if (entity->getType() == ObjectType::UNIT || entity->getType() == ObjectType::PLAYER) {
+                        auto unit = std::static_pointer_cast<Unit>(entity);
+                        constexpr uint32_t UNIT_DYNFLAG_DEAD = 0x0008;
+                        constexpr uint32_t UNIT_DYNFLAG_LOOTABLE = 0x0001;
+                        uint32_t oldDisplayId = unit->getDisplayId();
+                        bool displayIdChanged = false;
+                        bool npcDeathNotified = false;
+                        bool npcRespawnNotified = false;
+                        const uint16_t ufHealth = fieldIndex(UF::UNIT_FIELD_HEALTH);
+                        const uint16_t ufPowerBase = fieldIndex(UF::UNIT_FIELD_POWER1);
+                        const uint16_t ufMaxHealth = fieldIndex(UF::UNIT_FIELD_MAXHEALTH);
+                        const uint16_t ufMaxPowerBase = fieldIndex(UF::UNIT_FIELD_MAXPOWER1);
+                        const uint16_t ufLevel = fieldIndex(UF::UNIT_FIELD_LEVEL);
+                        const uint16_t ufFaction = fieldIndex(UF::UNIT_FIELD_FACTIONTEMPLATE);
+                        const uint16_t ufFlags = fieldIndex(UF::UNIT_FIELD_FLAGS);
+                        const uint16_t ufDynFlags = fieldIndex(UF::UNIT_DYNAMIC_FLAGS);
+                        const uint16_t ufDisplayId = fieldIndex(UF::UNIT_FIELD_DISPLAYID);
+                        const uint16_t ufMountDisplayId = fieldIndex(UF::UNIT_FIELD_MOUNTDISPLAYID);
+                        const uint16_t ufNpcFlags = fieldIndex(UF::UNIT_NPC_FLAGS);
+                        const uint16_t ufBytes0 = fieldIndex(UF::UNIT_FIELD_BYTES_0);
+                        for (const auto& [key, val] : block.fields) {
+                            if (key == ufHealth) {
+                                uint32_t oldHealth = unit->getHealth();
+                                unit->setHealth(val);
+                                if (val == 0) {
+                                    if (block.guid == autoAttackTarget) {
+                                        stopAutoAttack();
+                                    }
+                                    hostileAttackers_.erase(block.guid);
+                                    if (block.guid == playerGuid) {
+                                        playerDead_ = true;
+                                        releasedSpirit_ = false;
+                                        stopAutoAttack();
+                                        LOG_INFO("Player died!");
+                                    }
+                                    if (entity->getType() == ObjectType::UNIT && npcDeathCallback_) {
+                                        npcDeathCallback_(block.guid);
+                                        npcDeathNotified = true;
+                                    }
+                                } else if (oldHealth == 0 && val > 0) {
+                                    if (block.guid == playerGuid) {
+                                        playerDead_ = false;
+                                        if (!releasedSpirit_) {
+                                            LOG_INFO("Player resurrected!");
+                                        } else {
+                                            LOG_INFO("Player entered ghost form");
+                                        }
+                                    }
+                                    if (entity->getType() == ObjectType::UNIT && npcRespawnCallback_) {
+                                        npcRespawnCallback_(block.guid);
+                                        npcRespawnNotified = true;
+                                    }
+                                }
+                            // Specific fields checked BEFORE power/maxpower range checks
+                            // (Classic packs maxHealth/level/faction adjacent to power indices)
+                            } else if (key == ufMaxHealth) { unit->setMaxHealth(val); }
+                            else if (key == ufBytes0) {
+                                unit->setPowerType(static_cast<uint8_t>((val >> 24) & 0xFF));
+                            } else if (key == ufFlags) { unit->setUnitFlags(val); }
+                            else if (key == ufDynFlags) {
+                                uint32_t oldDyn = unit->getDynamicFlags();
+                                unit->setDynamicFlags(val);
+                                if (block.guid == playerGuid) {
+                                    bool wasDead = (oldDyn & UNIT_DYNFLAG_DEAD) != 0;
+                                    bool nowDead = (val & UNIT_DYNFLAG_DEAD) != 0;
+                                    if (!wasDead && nowDead) {
+                                        playerDead_ = true;
+                                        releasedSpirit_ = false;
+                                        LOG_INFO("Player died (dynamic flags)");
+                                    } else if (wasDead && !nowDead) {
+                                        playerDead_ = false;
+                                        releasedSpirit_ = false;
+                                        LOG_INFO("Player resurrected (dynamic flags)");
+                                    }
+                                } else if (entity->getType() == ObjectType::UNIT) {
+                                    bool wasDead = (oldDyn & UNIT_DYNFLAG_DEAD) != 0;
+                                    bool nowDead = (val & UNIT_DYNFLAG_DEAD) != 0;
+                                    if (!wasDead && nowDead) {
+                                        if (!npcDeathNotified && npcDeathCallback_) {
+                                            npcDeathCallback_(block.guid);
+                                            npcDeathNotified = true;
+                                        }
+                                    } else if (wasDead && !nowDead) {
+                                        if (!npcRespawnNotified && npcRespawnCallback_) {
+                                            npcRespawnCallback_(block.guid);
+                                            npcRespawnNotified = true;
+                                        }
+                                    }
+                                }
+                            } else if (key == ufLevel) {
+                                uint32_t oldLvl = unit->getLevel();
+                                unit->setLevel(val);
+                                if (block.guid != playerGuid &&
+                                    entity->getType() == ObjectType::PLAYER &&
+                                    val > oldLvl && oldLvl > 0 &&
+                                    otherPlayerLevelUpCallback_) {
+                                    otherPlayerLevelUpCallback_(block.guid, val);
+                                }
+                            }
+                            else if (key == ufFaction) {
+                                unit->setFactionTemplate(val);
+                                unit->setHostile(isHostileFaction(val));
+                            } else if (key == ufDisplayId) {
+                                if (val != unit->getDisplayId()) {
+                                    unit->setDisplayId(val);
+                                    displayIdChanged = true;
+                                }
+                            } else if (key == ufMountDisplayId) {
+                                if (block.guid == playerGuid) {
+                                    uint32_t old = currentMountDisplayId_;
+                                    currentMountDisplayId_ = val;
+                                    if (val != old && mountCallback_) mountCallback_(val);
+                                    if (old == 0 && val != 0) {
+                                        mountAuraSpellId_ = 0;
+                                        for (const auto& a : playerAuras) {
+                                            if (!a.isEmpty() && a.maxDurationMs < 0 && a.casterGuid == playerGuid) {
+                                                mountAuraSpellId_ = a.spellId;
+                                            }
+                                        }
+                                        // Classic/vanilla fallback: scan UNIT_FIELD_AURAS from same update block
+                                        if (mountAuraSpellId_ == 0) {
+                                            const uint16_t ufAuras = fieldIndex(UF::UNIT_FIELD_AURAS);
+                                            if (ufAuras != 0xFFFF) {
+                                                for (const auto& [fk, fv] : block.fields) {
+                                                    if (fk >= ufAuras && fk < ufAuras + 48 && fv != 0) {
+                                                        mountAuraSpellId_ = fv;
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        LOG_INFO("Mount detected (values update): displayId=", val, " auraSpellId=", mountAuraSpellId_);
+                                    }
+                                    if (old != 0 && val == 0) {
+                                        mountAuraSpellId_ = 0;
+                                        for (auto& a : playerAuras)
+                                            if (!a.isEmpty() && a.maxDurationMs < 0) a = AuraSlot{};
+                                    }
+                                }
+                                unit->setMountDisplayId(val);
+                            } else if (key == ufNpcFlags) { unit->setNpcFlags(val); }
+                            // Power/maxpower range checks AFTER all specific fields
+                            else if (key >= ufPowerBase && key < ufPowerBase + 7) {
+                                unit->setPowerByType(static_cast<uint8_t>(key - ufPowerBase), val);
+                            } else if (key >= ufMaxPowerBase && key < ufMaxPowerBase + 7) {
+                                unit->setMaxPowerByType(static_cast<uint8_t>(key - ufMaxPowerBase), val);
+                            }
+                        }
+
+                        // Some units/players are created without displayId and get it later via VALUES.
+                        if ((entity->getType() == ObjectType::UNIT || entity->getType() == ObjectType::PLAYER) &&
+                            displayIdChanged &&
+                            unit->getDisplayId() != 0 &&
+                            unit->getDisplayId() != oldDisplayId) {
+                            if (entity->getType() == ObjectType::PLAYER && block.guid == playerGuid) {
+                                // Skip local player — spawned separately
+                            } else if (entity->getType() == ObjectType::PLAYER) {
+                                if (playerSpawnCallback_) {
+                                    uint8_t race = 0, gender = 0, facial = 0;
+                                    uint32_t appearanceBytes = 0;
+                                    // Use the entity's accumulated field state, not just this block's changed fields.
+                                    if (extractPlayerAppearance(entity->getFields(), race, gender, appearanceBytes, facial)) {
+                                        playerSpawnCallback_(block.guid, unit->getDisplayId(), race, gender,
+                                                            appearanceBytes, facial,
+                                                            unit->getX(), unit->getY(), unit->getZ(), unit->getOrientation());
+                                    }
+                                }
+                            } else if (creatureSpawnCallback_) {
+                                creatureSpawnCallback_(block.guid, unit->getDisplayId(),
+                                    unit->getX(), unit->getY(), unit->getZ(), unit->getOrientation());
+                                bool isDeadNow = (unit->getHealth() == 0) ||
+                                    ((unit->getDynamicFlags() & (UNIT_DYNFLAG_DEAD | UNIT_DYNFLAG_LOOTABLE)) != 0);
+                                if (isDeadNow && !npcDeathNotified && npcDeathCallback_) {
+                                    npcDeathCallback_(block.guid);
+                                    npcDeathNotified = true;
+                                }
+                            }
+                            if (entity->getType() == ObjectType::UNIT && (unit->getNpcFlags() & 0x02) && socket) {
+                                network::Packet qsPkt(wireOpcode(Opcode::CMSG_QUESTGIVER_STATUS_QUERY));
+                                qsPkt.writeUInt64(block.guid);
+                                socket->send(qsPkt);
+                            }
+                        }
+                    }
+                    // Update XP / inventory slot / skill fields for player entity
+                    if (block.guid == playerGuid) {
+                        const bool needCoinageDetectSnapshot =
+                            (pendingMoneyDelta_ != 0 && pendingMoneyDeltaTimer_ > 0.0f);
+                        std::map<uint16_t, uint32_t> oldFieldsSnapshot;
+                        if (needCoinageDetectSnapshot) {
+                            oldFieldsSnapshot = lastPlayerFields_;
+                        }
+                        if (block.hasMovement && block.runSpeed > 0.1f && block.runSpeed < 100.0f) {
+                            serverRunSpeed_ = block.runSpeed;
+                            // Some server dismount paths update run speed without updating mount display field.
+                            if (!onTaxiFlight_ && !taxiMountActive_ &&
+                                currentMountDisplayId_ != 0 && block.runSpeed <= 8.5f) {
+                                LOG_INFO("Auto-clearing mount from movement speed update: speed=", block.runSpeed,
+                                         " displayId=", currentMountDisplayId_);
+                                currentMountDisplayId_ = 0;
+                                if (mountCallback_) {
+                                    mountCallback_(0);
+                                }
+                            }
+                        }
+                        auto mergeHint = lastPlayerFields_.end();
+                        for (const auto& [key, val] : block.fields) {
+                            mergeHint = lastPlayerFields_.insert_or_assign(mergeHint, key, val);
+                        }
+                        if (needCoinageDetectSnapshot) {
+                            maybeDetectCoinageIndex(oldFieldsSnapshot, lastPlayerFields_);
+                        }
+                        maybeDetectVisibleItemLayout();
+                        detectInventorySlotBases(block.fields);
+                        bool slotsChanged = false;
+                        const uint16_t ufPlayerXp = fieldIndex(UF::PLAYER_XP);
+                        const uint16_t ufPlayerNextXp = fieldIndex(UF::PLAYER_NEXT_LEVEL_XP);
+                        const uint16_t ufPlayerLevel = fieldIndex(UF::UNIT_FIELD_LEVEL);
+                        const uint16_t ufCoinage = fieldIndex(UF::PLAYER_FIELD_COINAGE);
+                        const uint16_t ufPlayerFlags = fieldIndex(UF::PLAYER_FLAGS);
+                        const uint16_t ufArmor = fieldIndex(UF::UNIT_FIELD_RESISTANCES);
+                        const uint16_t ufPBytes2v = fieldIndex(UF::PLAYER_BYTES_2);
+                        for (const auto& [key, val] : block.fields) {
+                            if (key == ufPlayerXp) {
+                                playerXp_ = val;
+                                LOG_DEBUG("XP updated: ", val);
+                            }
+                            else if (key == ufPlayerNextXp) {
+                                playerNextLevelXp_ = val;
+                                LOG_DEBUG("Next level XP updated: ", val);
+                            }
+                            else if (key == ufPlayerLevel) {
+                                serverPlayerLevel_ = val;
+                                LOG_DEBUG("Level updated: ", val);
+                                for (auto& ch : characters) {
+                                    if (ch.guid == playerGuid) {
+                                        ch.level = val;
+                                        break;
+                                    }
+                                }
+                            }
+                            else if (key == ufCoinage) {
+                                playerMoneyCopper_ = val;
+                                LOG_DEBUG("Money updated via VALUES: ", val, " copper");
+                            }
+                            else if (ufArmor != 0xFFFF && key == ufArmor) {
+                                playerArmorRating_ = static_cast<int32_t>(val);
+                            }
+                            else if (ufPBytes2v != 0xFFFF && key == ufPBytes2v) {
+                                uint8_t bankBagSlots = static_cast<uint8_t>((val >> 16) & 0xFF);
+                                LOG_WARNING("PLAYER_BYTES_2 (VALUES): raw=0x", std::hex, val, std::dec,
+                                           " bankBagSlots=", static_cast<int>(bankBagSlots));
+                                inventory.setPurchasedBankBagSlots(bankBagSlots);
+                            }
+                            else if (key == ufPlayerFlags) {
+                                constexpr uint32_t PLAYER_FLAGS_GHOST = 0x00000010;
+                                bool wasGhost = releasedSpirit_;
+                                bool nowGhost = (val & PLAYER_FLAGS_GHOST) != 0;
+                                if (!wasGhost && nowGhost) {
+                                    releasedSpirit_ = true;
+                                    LOG_INFO("Player entered ghost form (PLAYER_FLAGS)");
+                                } else if (wasGhost && !nowGhost) {
+                                    releasedSpirit_ = false;
+                                    playerDead_ = false;
+                                    repopPending_ = false;
+                                    resurrectPending_ = false;
+                                    LOG_INFO("Player resurrected (PLAYER_FLAGS ghost cleared)");
+                                }
+                            }
+                        }
+                        // Do not auto-create quests from VALUES quest-log slot fields for the
+                        // same reason as CREATE_OBJECT2 above (can be misaligned per realm).
+                        if (applyInventoryFields(block.fields)) slotsChanged = true;
+                        if (slotsChanged) rebuildOnlineInventory();
+                        extractSkillFields(lastPlayerFields_);
+                        extractExploredZoneFields(lastPlayerFields_);
+                    }
+
+                    // Update item stack count for online items
+                    if (entity->getType() == ObjectType::ITEM || entity->getType() == ObjectType::CONTAINER) {
+                        bool inventoryChanged = false;
+                        const uint16_t itemStackField = fieldIndex(UF::ITEM_FIELD_STACK_COUNT);
+                        const uint16_t containerNumSlotsField = fieldIndex(UF::CONTAINER_FIELD_NUM_SLOTS);
+                        const uint16_t containerSlot1Field = fieldIndex(UF::CONTAINER_FIELD_SLOT_1);
+                        for (const auto& [key, val] : block.fields) {
+                            if (key == itemStackField) {
+                                auto it = onlineItems_.find(block.guid);
+                                if (it != onlineItems_.end() && it->second.stackCount != val) {
+                                    it->second.stackCount = val;
+                                    inventoryChanged = true;
+                                }
+                            }
+                        }
+                        // Update container slot GUIDs on bag content changes
+                        if (entity->getType() == ObjectType::CONTAINER) {
+                            for (const auto& [key, _] : block.fields) {
+                                if ((containerNumSlotsField != 0xFFFF && key == containerNumSlotsField) ||
+                                    (containerSlot1Field != 0xFFFF && key >= containerSlot1Field && key < containerSlot1Field + 72)) {
+                                    inventoryChanged = true;
+                                    break;
+                                }
+                            }
+                            extractContainerFields(block.guid, block.fields);
+                        }
+                        if (inventoryChanged) {
+                            rebuildOnlineInventory();
+                        }
+                    }
+                    if (block.hasMovement && entity->getType() == ObjectType::GAMEOBJECT) {
+                        if (transportGuids_.count(block.guid) && transportMoveCallback_) {
+                            serverUpdatedTransportGuids_.insert(block.guid);
+                            transportMoveCallback_(block.guid, entity->getX(), entity->getY(),
+                                                   entity->getZ(), entity->getOrientation());
+                        } else if (gameObjectMoveCallback_) {
+                            gameObjectMoveCallback_(block.guid, entity->getX(), entity->getY(),
+                                                    entity->getZ(), entity->getOrientation());
+                        }
+                    }
+
+                    LOG_DEBUG("Updated entity fields: 0x", std::hex, block.guid, std::dec);
+                } else {
+                }
+                break;
+            }
+
+            case UpdateType::MOVEMENT: {
+                // Diagnostic: Log if we receive MOVEMENT blocks for transports
+                if (transportGuids_.count(block.guid)) {
+                    LOG_INFO("MOVEMENT update for transport 0x", std::hex, block.guid, std::dec,
+                             " pos=(", block.x, ", ", block.y, ", ", block.z, ")");
+                }
+
+                // Update entity position (server → canonical)
+                auto entity = entityManager.getEntity(block.guid);
+                if (entity) {
+                    glm::vec3 pos = core::coords::serverToCanonical(glm::vec3(block.x, block.y, block.z));
+                    float oCanonical = core::coords::serverToCanonicalYaw(block.orientation);
+                    entity->setPosition(pos.x, pos.y, pos.z, oCanonical);
+                    LOG_DEBUG("Updated entity position: 0x", std::hex, block.guid, std::dec);
+
+                    if (block.guid != playerGuid &&
+                        (entity->getType() == ObjectType::UNIT || entity->getType() == ObjectType::GAMEOBJECT)) {
+                        if (block.onTransport && block.transportGuid != 0) {
+                            glm::vec3 localOffset = core::coords::serverToCanonical(
+                                glm::vec3(block.transportX, block.transportY, block.transportZ));
+                            const bool hasLocalOrientation = (block.updateFlags & 0x0020) != 0; // UPDATEFLAG_LIVING
+                            float localOriCanonical = core::coords::normalizeAngleRad(-block.transportO);
+                            setTransportAttachment(block.guid, entity->getType(), block.transportGuid,
+                                                   localOffset, hasLocalOrientation, localOriCanonical);
+                            if (transportManager_ && transportManager_->getTransport(block.transportGuid)) {
+                                glm::vec3 composed = transportManager_->getPlayerWorldPosition(block.transportGuid, localOffset);
+                                entity->setPosition(composed.x, composed.y, composed.z, entity->getOrientation());
+                            }
+                        } else {
+                            clearTransportAttachment(block.guid);
+                        }
+                    }
+
+                    if (block.guid == playerGuid) {
+                        movementInfo.orientation = oCanonical;
+
+                        // Track player-on-transport state from MOVEMENT updates
+                        if (block.onTransport) {
+                            setPlayerOnTransport(block.transportGuid, glm::vec3(0.0f));
+                            // Convert transport offset from server → canonical coordinates
+                            glm::vec3 serverOffset(block.transportX, block.transportY, block.transportZ);
+                            playerTransportOffset_ = core::coords::serverToCanonical(serverOffset);
+                            if (transportManager_ && transportManager_->getTransport(playerTransportGuid_)) {
+                                glm::vec3 composed = transportManager_->getPlayerWorldPosition(playerTransportGuid_, playerTransportOffset_);
+                                entity->setPosition(composed.x, composed.y, composed.z, oCanonical);
+                                movementInfo.x = composed.x;
+                                movementInfo.y = composed.y;
+                                movementInfo.z = composed.z;
+                            } else {
+                                movementInfo.x = pos.x;
+                                movementInfo.y = pos.y;
+                                movementInfo.z = pos.z;
+                            }
+                            LOG_INFO("Player on transport (MOVEMENT): 0x", std::hex, playerTransportGuid_, std::dec);
+                        } else {
+                            movementInfo.x = pos.x;
+                            movementInfo.y = pos.y;
+                            movementInfo.z = pos.z;
+                            // Don't clear client-side M2 transport boarding
+                            bool isClientM2Transport = false;
+                            if (playerTransportGuid_ != 0 && transportManager_) {
+                                auto* tr = transportManager_->getTransport(playerTransportGuid_);
+                                isClientM2Transport = (tr && tr->isM2);
+                            }
+                            if (playerTransportGuid_ != 0 && !isClientM2Transport) {
+                                LOG_INFO("Player left transport (MOVEMENT)");
+                                clearPlayerTransport();
+                            }
+                        }
+                    }
+
+                    // Fire transport move callback if this is a known transport
+                    if (transportGuids_.count(block.guid) && transportMoveCallback_) {
+                        serverUpdatedTransportGuids_.insert(block.guid);
+                        transportMoveCallback_(block.guid, pos.x, pos.y, pos.z, oCanonical);
+                    }
+                    // Fire move callback for non-transport gameobjects.
+                    if (entity->getType() == ObjectType::GAMEOBJECT &&
+                        transportGuids_.count(block.guid) == 0 &&
+                        gameObjectMoveCallback_) {
+                        gameObjectMoveCallback_(block.guid, entity->getX(), entity->getY(),
+                                                entity->getZ(), entity->getOrientation());
+                    }
+                    // Fire move callback for non-player units (creatures).
+                    // SMSG_MONSTER_MOVE handles smooth interpolated movement, but many
+                    // servers (especially vanilla/Turtle WoW) communicate NPC positions
+                    // via MOVEMENT blocks instead. Use duration=0 for an instant snap.
+                    if (block.guid != playerGuid &&
+                        entity->getType() == ObjectType::UNIT &&
+                        transportGuids_.count(block.guid) == 0 &&
+                        creatureMoveCallback_) {
+                        creatureMoveCallback_(block.guid, pos.x, pos.y, pos.z, 0);
+                    }
+                } else {
+                    LOG_WARNING("MOVEMENT update for unknown entity: 0x", std::hex, block.guid, std::dec);
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    tabCycleStale = true;
+    // Entity count logging disabled
+
+    // Deferred rebuild: if new item objects were created in this packet, rebuild
+    // inventory so that slot GUIDs updated earlier in the same packet can resolve.
+    if (newItemCreated) {
+        rebuildOnlineInventory();
+    }
+
+    // Late inventory base detection once items are known
+    if (playerGuid != 0 && invSlotBase_ < 0 && !lastPlayerFields_.empty() && !onlineItems_.empty()) {
+        detectInventorySlotBases(lastPlayerFields_);
+        if (invSlotBase_ >= 0) {
+            if (applyInventoryFields(lastPlayerFields_)) {
+                rebuildOnlineInventory();
+            }
+        }
     }
 }
 
+void GameHandler::handleCompressedUpdateObject(network::Packet& packet) {
+    LOG_DEBUG("Handling SMSG_COMPRESSED_UPDATE_OBJECT, packet size: ", packet.getSize());
+
+    // First 4 bytes = decompressed size
+    if (packet.getSize() < 4) {
+        LOG_WARNING("SMSG_COMPRESSED_UPDATE_OBJECT too small");
+        return;
+    }
+
+    uint32_t decompressedSize = packet.readUInt32();
+    LOG_DEBUG("  Decompressed size: ", decompressedSize);
+
+    if (decompressedSize == 0 || decompressedSize > 1024 * 1024) {
+        LOG_WARNING("Invalid decompressed size: ", decompressedSize);
+        return;
+    }
+
+    // Remaining data is zlib compressed
+    size_t compressedSize = packet.getSize() - packet.getReadPos();
+    const uint8_t* compressedData = packet.getData().data() + packet.getReadPos();
+
+    // Decompress
+    std::vector<uint8_t> decompressed(decompressedSize);
+    uLongf destLen = decompressedSize;
+    int ret = uncompress(decompressed.data(), &destLen, compressedData, compressedSize);
+
+    if (ret != Z_OK) {
+        LOG_WARNING("Failed to decompress UPDATE_OBJECT: zlib error ", ret);
+        return;
+    }
+
+    // Create packet from decompressed data and parse it
+    network::Packet decompressedPacket(wireOpcode(Opcode::SMSG_UPDATE_OBJECT), decompressed);
+    handleUpdateObject(decompressedPacket);
+}
+
+void GameHandler::handleDestroyObject(network::Packet& packet) {
+    LOG_DEBUG("Handling SMSG_DESTROY_OBJECT");
+
+    DestroyObjectData data;
+    if (!DestroyObjectParser::parse(packet, data)) {
+        LOG_WARNING("Failed to parse SMSG_DESTROY_OBJECT");
+        return;
+    }
+
+    // Remove entity
+    if (entityManager.hasEntity(data.guid)) {
+        if (transportGuids_.count(data.guid) > 0) {
+            const bool playerAboardNow = (playerTransportGuid_ == data.guid);
+            const bool stickyAboard = (playerTransportStickyGuid_ == data.guid && playerTransportStickyTimer_ > 0.0f);
+            const bool movementSaysAboard = (movementInfo.transportGuid == data.guid);
+            if (playerAboardNow || stickyAboard || movementSaysAboard) {
+                serverUpdatedTransportGuids_.erase(data.guid);
+                LOG_INFO("Preserving in-use transport on destroy: 0x", std::hex, data.guid, std::dec,
+                         " now=", playerAboardNow,
+                         " sticky=", stickyAboard,
+                         " movement=", movementSaysAboard);
+                return;
+            }
+        }
+        // Mirror out-of-range handling: invoke render-layer despawn callbacks before entity removal.
+        auto entity = entityManager.getEntity(data.guid);
+        if (entity) {
+            if (entity->getType() == ObjectType::UNIT && creatureDespawnCallback_) {
+                creatureDespawnCallback_(data.guid);
+            } else if (entity->getType() == ObjectType::GAMEOBJECT && gameObjectDespawnCallback_) {
+                gameObjectDespawnCallback_(data.guid);
+            }
+        }
+        if (transportGuids_.count(data.guid) > 0) {
+            transportGuids_.erase(data.guid);
+            serverUpdatedTransportGuids_.erase(data.guid);
+            if (playerTransportGuid_ == data.guid) {
+                clearPlayerTransport();
+            }
+        }
+        clearTransportAttachment(data.guid);
+        entityManager.removeEntity(data.guid);
+        LOG_INFO("Destroyed entity: 0x", std::hex, data.guid, std::dec,
+                 " (", (data.isDeath ? "death" : "despawn"), ")");
+    } else {
+        LOG_DEBUG("Destroy object for unknown entity: 0x", std::hex, data.guid, std::dec);
+    }
+
+    // Clean up auto-attack and target if destroyed entity was our target
+    if (data.guid == autoAttackTarget) {
+        stopAutoAttack();
+    }
+    if (data.guid == targetGuid) {
+        targetGuid = 0;
+    }
+    hostileAttackers_.erase(data.guid);
+
+    // Remove online item/container tracking
+    containerContents_.erase(data.guid);
+    if (onlineItems_.erase(data.guid)) {
+        rebuildOnlineInventory();
+    }
+
+    // Clean up quest giver status
+    npcQuestStatus_.erase(data.guid);
+
+    tabCycleStale = true;
+    // Entity count logging disabled
+}
+
+void GameHandler::sendChatMessage(ChatType type, const std::string& message, const std::string& target) {
+    if (state != WorldState::IN_WORLD) {
+        LOG_WARNING("Cannot send chat in state: ", (int)state);
+        return;
+    }
+
+    if (message.empty()) {
+        LOG_WARNING("Cannot send empty chat message");
+        return;
+    }
+
+    LOG_INFO("Sending chat message: [", getChatTypeString(type), "] ", message);
+
+    // Determine language based on character (for now, use COMMON)
+    ChatLanguage language = ChatLanguage::COMMON;
+
+    // Build and send packet
+    auto packet = MessageChatPacket::build(type, language, message, target);
+    socket->send(packet);
+
+    // Add local echo so the player sees their own message immediately
+    MessageChatData echo;
+    echo.senderGuid = playerGuid;
+    echo.language = language;
+    echo.message = message;
+
+    // Look up player name
+    auto nameIt = playerNameCache.find(playerGuid);
+    if (nameIt != playerNameCache.end()) {
+        echo.senderName = nameIt->second;
+    }
+
+    if (type == ChatType::WHISPER) {
+        echo.type = ChatType::WHISPER_INFORM;
+        echo.senderName = target;  // "To [target]: message"
+    } else {
+        echo.type = type;
+    }
+
+    if (type == ChatType::CHANNEL) {
+        echo.channelName = target;
+    }
+
+    addLocalChatMessage(echo);
+}
+
+void GameHandler::handleMessageChat(network::Packet& packet) {
+    LOG_DEBUG("Handling SMSG_MESSAGECHAT");
+
+    MessageChatData data;
+    if (!packetParsers_->parseMessageChat(packet, data)) {
+        LOG_WARNING("Failed to parse SMSG_MESSAGECHAT");
+        return;
+    }
+
+    // Skip server echo of our own messages (we already added a local echo)
+    if (data.senderGuid == playerGuid && data.senderGuid != 0) {
+        // Still track whisper sender for /r even if it's our own whisper-inform
+        if (data.type == ChatType::WHISPER && !data.senderName.empty()) {
+            lastWhisperSender_ = data.senderName;
+        }
+        return;
+    }
+
+    // Resolve sender name from entity/cache if not already set by parser
+    if (data.senderName.empty() && data.senderGuid != 0) {
+        // Check player name cache first
+        auto nameIt = playerNameCache.find(data.senderGuid);
+        if (nameIt != playerNameCache.end()) {
+            data.senderName = nameIt->second;
+        } else {
+            // Try entity name
+            auto entity = entityManager.getEntity(data.senderGuid);
+            if (entity) {
+                if (entity->getType() == ObjectType::PLAYER) {
+                    auto player = std::dynamic_pointer_cast<Player>(entity);
+                    if (player && !player->getName().empty()) {
+                        data.senderName = player->getName();
+                    }
+                } else if (entity->getType() == ObjectType::UNIT) {
+                    auto unit = std::dynamic_pointer_cast<Unit>(entity);
+                    if (unit && !unit->getName().empty()) {
+                        data.senderName = unit->getName();
+                    }
+                }
+            }
+        }
+
+        // If still unknown, proactively query the server so the UI can show names soon after.
+        if (data.senderName.empty()) {
+            queryPlayerName(data.senderGuid);
+        }
+    }
+
+    // Add to chat history
+    chatHistory.push_back(data);
+
+    // Limit chat history size
+    if (chatHistory.size() > maxChatHistory) {
+        chatHistory.erase(chatHistory.begin());
+    }
+
+    // Track whisper sender for /r command
+    if (data.type == ChatType::WHISPER && !data.senderName.empty()) {
+        lastWhisperSender_ = data.senderName;
+    }
+
+    // Trigger chat bubble for SAY/YELL messages from others
+    if (chatBubbleCallback_ && data.senderGuid != 0) {
+        if (data.type == ChatType::SAY || data.type == ChatType::YELL ||
+            data.type == ChatType::MONSTER_SAY || data.type == ChatType::MONSTER_YELL ||
+            data.type == ChatType::MONSTER_PARTY) {
+            bool isYell = (data.type == ChatType::YELL || data.type == ChatType::MONSTER_YELL);
+            chatBubbleCallback_(data.senderGuid, data.message, isYell);
+        }
+    }
+
+    // Log the message
+    std::string senderInfo;
+    if (!data.senderName.empty()) {
+        senderInfo = data.senderName;
+    } else if (data.senderGuid != 0) {
+        senderInfo = "Unknown-" + std::to_string(data.senderGuid);
+    } else {
+        senderInfo = "System";
+    }
+
+    std::string channelInfo;
+    if (!data.channelName.empty()) {
+        channelInfo = "[" + data.channelName + "] ";
+    }
+
+    LOG_DEBUG("[", getChatTypeString(data.type), "] ", channelInfo, senderInfo, ": ", data.message);
+}
+
+void GameHandler::sendTextEmote(uint32_t textEmoteId, uint64_t targetGuid) {
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = TextEmotePacket::build(textEmoteId, targetGuid);
+    socket->send(packet);
+}
+
+void GameHandler::handleTextEmote(network::Packet& packet) {
+    TextEmoteData data;
+    if (!TextEmoteParser::parse(packet, data)) {
+        LOG_WARNING("Failed to parse SMSG_TEXT_EMOTE");
+        return;
+    }
+
+    // Skip our own text emotes (we already have local echo)
+    if (data.senderGuid == playerGuid && data.senderGuid != 0) {
+        return;
+    }
+
+    // Resolve sender name
+    std::string senderName;
+    auto nameIt = playerNameCache.find(data.senderGuid);
+    if (nameIt != playerNameCache.end()) {
+        senderName = nameIt->second;
+    } else {
+        auto entity = entityManager.getEntity(data.senderGuid);
+        if (entity) {
+            auto unit = std::dynamic_pointer_cast<Unit>(entity);
+            if (unit) senderName = unit->getName();
+        }
+    }
+    if (senderName.empty()) {
+        senderName = "Unknown";
+        queryPlayerName(data.senderGuid);
+    }
+
+    // Resolve emote text from DBC using third-person "others see" templates
+    const std::string* targetPtr = data.targetName.empty() ? nullptr : &data.targetName;
+    std::string emoteText = rendering::Renderer::getEmoteTextByDbcId(data.textEmoteId, senderName, targetPtr);
+    if (emoteText.empty()) {
+        // Fallback if DBC lookup fails
+        emoteText = data.targetName.empty()
+            ? senderName + " performs an emote."
+            : senderName + " performs an emote at " + data.targetName + ".";
+    }
+
+    MessageChatData chatMsg;
+    chatMsg.type = ChatType::TEXT_EMOTE;
+    chatMsg.language = ChatLanguage::COMMON;
+    chatMsg.senderGuid = data.senderGuid;
+    chatMsg.senderName = senderName;
+    chatMsg.message = emoteText;
+
+    chatHistory.push_back(chatMsg);
+    if (chatHistory.size() > maxChatHistory) {
+        chatHistory.erase(chatHistory.begin());
+    }
+
+    // Trigger emote animation on sender's entity via callback
+    uint32_t animId = rendering::Renderer::getEmoteAnimByDbcId(data.textEmoteId);
+    if (animId != 0 && emoteAnimCallback_) {
+        emoteAnimCallback_(data.senderGuid, animId);
+    }
+
+    LOG_INFO("TEXT_EMOTE from ", senderName, " (emoteId=", data.textEmoteId, ", anim=", animId, ")");
+}
+
+void GameHandler::joinChannel(const std::string& channelName, const std::string& password) {
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = packetParsers_ ? packetParsers_->buildJoinChannel(channelName, password)
+                                 : JoinChannelPacket::build(channelName, password);
+    socket->send(packet);
+    LOG_INFO("Requesting to join channel: ", channelName);
+}
+
+void GameHandler::leaveChannel(const std::string& channelName) {
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = packetParsers_ ? packetParsers_->buildLeaveChannel(channelName)
+                                 : LeaveChannelPacket::build(channelName);
+    socket->send(packet);
+    LOG_INFO("Requesting to leave channel: ", channelName);
+}
+
+std::string GameHandler::getChannelByIndex(int index) const {
+    if (index < 1 || index > static_cast<int>(joinedChannels_.size())) return "";
+    return joinedChannels_[index - 1];
+}
+
+int GameHandler::getChannelIndex(const std::string& channelName) const {
+    for (int i = 0; i < static_cast<int>(joinedChannels_.size()); ++i) {
+        if (joinedChannels_[i] == channelName) return i + 1;  // 1-based
+    }
+    return 0;
+}
+
+void GameHandler::handleChannelNotify(network::Packet& packet) {
+    ChannelNotifyData data;
+    if (!ChannelNotifyParser::parse(packet, data)) {
+        LOG_WARNING("Failed to parse SMSG_CHANNEL_NOTIFY");
+        return;
+    }
+
+    switch (data.notifyType) {
+        case ChannelNotifyType::YOU_JOINED: {
+            // Add to active channels if not already present
+            bool found = false;
+            for (const auto& ch : joinedChannels_) {
+                if (ch == data.channelName) { found = true; break; }
+            }
+            if (!found) {
+                joinedChannels_.push_back(data.channelName);
+            }
+            MessageChatData msg;
+            msg.type = ChatType::SYSTEM;
+            msg.message = "Joined channel: " + data.channelName;
+            addLocalChatMessage(msg);
+            LOG_INFO("Joined channel: ", data.channelName);
+            break;
+        }
+        case ChannelNotifyType::YOU_LEFT: {
+            joinedChannels_.erase(
+                std::remove(joinedChannels_.begin(), joinedChannels_.end(), data.channelName),
+                joinedChannels_.end());
+            MessageChatData msg;
+            msg.type = ChatType::SYSTEM;
+            msg.message = "Left channel: " + data.channelName;
+            addLocalChatMessage(msg);
+            LOG_INFO("Left channel: ", data.channelName);
+            break;
+        }
+        case ChannelNotifyType::PLAYER_ALREADY_MEMBER: {
+            // Server says we're already in this channel (e.g. server auto-joined us)
+            // Still track it in our channel list
+            bool found = false;
+            for (const auto& ch : joinedChannels_) {
+                if (ch == data.channelName) { found = true; break; }
+            }
+            if (!found) {
+                joinedChannels_.push_back(data.channelName);
+                LOG_INFO("Already in channel: ", data.channelName);
+            }
+            break;
+        }
+        case ChannelNotifyType::NOT_IN_AREA: {
+            LOG_DEBUG("Cannot join channel ", data.channelName, " (not in area)");
+            break;
+        }
+        default:
+            LOG_DEBUG("Channel notify type ", static_cast<int>(data.notifyType),
+                     " for channel ", data.channelName);
+            break;
+    }
+}
+
+void GameHandler::autoJoinDefaultChannels() {
+    LOG_INFO("autoJoinDefaultChannels: general=", chatAutoJoin.general,
+             " trade=", chatAutoJoin.trade, " localDefense=", chatAutoJoin.localDefense,
+             " lfg=", chatAutoJoin.lfg, " local=", chatAutoJoin.local);
+    if (chatAutoJoin.general) joinChannel("General");
+    if (chatAutoJoin.trade) joinChannel("Trade");
+    if (chatAutoJoin.localDefense) joinChannel("LocalDefense");
+    if (chatAutoJoin.lfg) joinChannel("LookingForGroup");
+    if (chatAutoJoin.local) joinChannel("Local");
+}
+
 void GameHandler::setTarget(uint64_t guid) {
-    if (combatHandler_) combatHandler_->setTarget(guid);
+    if (guid == targetGuid) return;
+
+    // Save previous target
+    if (targetGuid != 0) {
+        lastTargetGuid = targetGuid;
+    }
+
+    targetGuid = guid;
+
+    // Inform server of target selection (Phase 1)
+    if (state == WorldState::IN_WORLD && socket) {
+        auto packet = SetSelectionPacket::build(guid);
+        socket->send(packet);
+    }
+
+    if (guid != 0) {
+        LOG_INFO("Target set: 0x", std::hex, guid, std::dec);
+    }
 }
 
 void GameHandler::clearTarget() {
-    if (combatHandler_) combatHandler_->clearTarget();
+    if (targetGuid != 0) {
+        LOG_INFO("Target cleared");
+    }
+    targetGuid = 0;
+    tabCycleIndex = -1;
+    tabCycleStale = true;
 }
 
 std::shared_ptr<Entity> GameHandler::getTarget() const {
-    return combatHandler_ ? combatHandler_->getTarget() : nullptr;
+    if (targetGuid == 0) return nullptr;
+    return entityManager.getEntity(targetGuid);
 }
 
 void GameHandler::setFocus(uint64_t guid) {
-    if (combatHandler_) combatHandler_->setFocus(guid);
+    focusGuid = guid;
+    if (guid != 0) {
+        auto entity = entityManager.getEntity(guid);
+        if (entity) {
+            std::string name = "Unknown";
+            if (entity->getType() == ObjectType::PLAYER) {
+                auto player = std::dynamic_pointer_cast<Player>(entity);
+                if (player && !player->getName().empty()) {
+                    name = player->getName();
+                }
+            }
+            addSystemChatMessage("Focus set: " + name);
+            LOG_INFO("Focus set: 0x", std::hex, guid, std::dec);
+        }
+    }
 }
 
 void GameHandler::clearFocus() {
-    if (combatHandler_) combatHandler_->clearFocus();
-}
-
-void GameHandler::setMouseoverGuid(uint64_t guid) {
-    if (combatHandler_) combatHandler_->setMouseoverGuid(guid);
+    if (focusGuid != 0) {
+        addSystemChatMessage("Focus cleared.");
+        LOG_INFO("Focus cleared");
+    }
+    focusGuid = 0;
 }
 
 std::shared_ptr<Entity> GameHandler::getFocus() const {
-    return combatHandler_ ? combatHandler_->getFocus() : nullptr;
+    if (focusGuid == 0) return nullptr;
+    return entityManager.getEntity(focusGuid);
 }
 
 void GameHandler::targetLastTarget() {
-    if (combatHandler_) combatHandler_->targetLastTarget();
+    if (lastTargetGuid == 0) {
+        addSystemChatMessage("No previous target.");
+        return;
+    }
+
+    // Swap current and last target
+    uint64_t temp = targetGuid;
+    setTarget(lastTargetGuid);
+    lastTargetGuid = temp;
 }
 
 void GameHandler::targetEnemy(bool reverse) {
-    if (combatHandler_) combatHandler_->targetEnemy(reverse);
+    // Get list of hostile entities
+    std::vector<uint64_t> hostiles;
+    auto& entities = entityManager.getEntities();
+
+    for (const auto& [guid, entity] : entities) {
+        if (entity->getType() == ObjectType::UNIT) {
+            // Check if hostile (this is simplified - would need faction checking)
+            auto unit = std::dynamic_pointer_cast<Unit>(entity);
+            if (unit && guid != playerGuid) {
+                hostiles.push_back(guid);
+            }
+        }
+    }
+
+    if (hostiles.empty()) {
+        addSystemChatMessage("No enemies in range.");
+        return;
+    }
+
+    // Find current target in list
+    auto it = std::find(hostiles.begin(), hostiles.end(), targetGuid);
+
+    if (it == hostiles.end()) {
+        // Not currently targeting a hostile, target first one
+        setTarget(reverse ? hostiles.back() : hostiles.front());
+    } else {
+        // Cycle to next/previous
+        if (reverse) {
+            if (it == hostiles.begin()) {
+                setTarget(hostiles.back());
+            } else {
+                setTarget(*(--it));
+            }
+        } else {
+            ++it;
+            if (it == hostiles.end()) {
+                setTarget(hostiles.front());
+            } else {
+                setTarget(*it);
+            }
+        }
+    }
 }
 
 void GameHandler::targetFriend(bool reverse) {
-    if (combatHandler_) combatHandler_->targetFriend(reverse);
+    // Get list of friendly entities (players)
+    std::vector<uint64_t> friendlies;
+    auto& entities = entityManager.getEntities();
+
+    for (const auto& [guid, entity] : entities) {
+        if (entity->getType() == ObjectType::PLAYER && guid != playerGuid) {
+            friendlies.push_back(guid);
+        }
+    }
+
+    if (friendlies.empty()) {
+        addSystemChatMessage("No friendly targets in range.");
+        return;
+    }
+
+    // Find current target in list
+    auto it = std::find(friendlies.begin(), friendlies.end(), targetGuid);
+
+    if (it == friendlies.end()) {
+        // Not currently targeting a friend, target first one
+        setTarget(reverse ? friendlies.back() : friendlies.front());
+    } else {
+        // Cycle to next/previous
+        if (reverse) {
+            if (it == friendlies.begin()) {
+                setTarget(friendlies.back());
+            } else {
+                setTarget(*(--it));
+            }
+        } else {
+            ++it;
+            if (it == friendlies.end()) {
+                setTarget(friendlies.front());
+            } else {
+                setTarget(*it);
+            }
+        }
+    }
 }
 
 void GameHandler::inspectTarget() {
-    if (socialHandler_) socialHandler_->inspectTarget();
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot inspect: not in world or not connected");
+        return;
+    }
+
+    if (targetGuid == 0) {
+        addSystemChatMessage("You must target a player to inspect.");
+        return;
+    }
+
+    auto target = getTarget();
+    if (!target || target->getType() != ObjectType::PLAYER) {
+        addSystemChatMessage("You can only inspect players.");
+        return;
+    }
+
+    auto packet = InspectPacket::build(targetGuid);
+    socket->send(packet);
+
+    auto player = std::static_pointer_cast<Player>(target);
+    std::string name = player->getName().empty() ? "Target" : player->getName();
+    addSystemChatMessage("Inspecting " + name + "...");
+    LOG_INFO("Sent inspect request for player: ", name, " (GUID: 0x", std::hex, targetGuid, std::dec, ")");
 }
 
 void GameHandler::queryServerTime() {
-    if (socialHandler_) socialHandler_->queryServerTime();
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot query time: not in world or not connected");
+        return;
+    }
+
+    auto packet = QueryTimePacket::build();
+    socket->send(packet);
+    LOG_INFO("Requested server time");
 }
 
 void GameHandler::requestPlayedTime() {
-    if (socialHandler_) socialHandler_->requestPlayedTime();
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot request played time: not in world or not connected");
+        return;
+    }
+
+    auto packet = RequestPlayedTimePacket::build(true);
+    socket->send(packet);
+    LOG_INFO("Requested played time");
 }
 
 void GameHandler::queryWho(const std::string& playerName) {
-    if (socialHandler_) socialHandler_->queryWho(playerName);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot query who: not in world or not connected");
+        return;
+    }
+
+    auto packet = WhoPacket::build(0, 0, playerName);
+    socket->send(packet);
+    LOG_INFO("Sent WHO query", playerName.empty() ? "" : " for: " + playerName);
 }
 
 void GameHandler::addFriend(const std::string& playerName, const std::string& note) {
-    if (socialHandler_) socialHandler_->addFriend(playerName, note);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot add friend: not in world or not connected");
+        return;
+    }
+
+    if (playerName.empty()) {
+        addSystemChatMessage("You must specify a player name.");
+        return;
+    }
+
+    auto packet = AddFriendPacket::build(playerName, note);
+    socket->send(packet);
+    addSystemChatMessage("Sending friend request to " + playerName + "...");
+    LOG_INFO("Sent friend request to: ", playerName);
 }
 
 void GameHandler::removeFriend(const std::string& playerName) {
-    if (socialHandler_) socialHandler_->removeFriend(playerName);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot remove friend: not in world or not connected");
+        return;
+    }
+
+    if (playerName.empty()) {
+        addSystemChatMessage("You must specify a player name.");
+        return;
+    }
+
+    // Look up GUID from cache
+    auto it = friendsCache.find(playerName);
+    if (it == friendsCache.end()) {
+        addSystemChatMessage(playerName + " is not in your friends list.");
+        LOG_WARNING("Friend not found in cache: ", playerName);
+        return;
+    }
+
+    auto packet = DelFriendPacket::build(it->second);
+    socket->send(packet);
+    addSystemChatMessage("Removing " + playerName + " from friends list...");
+    LOG_INFO("Sent remove friend request for: ", playerName, " (GUID: 0x", std::hex, it->second, std::dec, ")");
 }
 
 void GameHandler::setFriendNote(const std::string& playerName, const std::string& note) {
-    if (socialHandler_) socialHandler_->setFriendNote(playerName, note);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot set friend note: not in world or not connected");
+        return;
+    }
+
+    if (playerName.empty()) {
+        addSystemChatMessage("You must specify a player name.");
+        return;
+    }
+
+    // Look up GUID from cache
+    auto it = friendsCache.find(playerName);
+    if (it == friendsCache.end()) {
+        addSystemChatMessage(playerName + " is not in your friends list.");
+        return;
+    }
+
+    auto packet = SetContactNotesPacket::build(it->second, note);
+    socket->send(packet);
+    addSystemChatMessage("Updated note for " + playerName);
+    LOG_INFO("Set friend note for: ", playerName);
 }
 
 void GameHandler::randomRoll(uint32_t minRoll, uint32_t maxRoll) {
-    if (socialHandler_) socialHandler_->randomRoll(minRoll, maxRoll);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot roll: not in world or not connected");
+        return;
+    }
+
+    if (minRoll > maxRoll) {
+        std::swap(minRoll, maxRoll);
+    }
+
+    if (maxRoll > 10000) {
+        maxRoll = 10000;  // Cap at reasonable value
+    }
+
+    auto packet = RandomRollPacket::build(minRoll, maxRoll);
+    socket->send(packet);
+    LOG_INFO("Rolled ", minRoll, "-", maxRoll);
 }
 
 void GameHandler::addIgnore(const std::string& playerName) {
-    if (socialHandler_) socialHandler_->addIgnore(playerName);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot add ignore: not in world or not connected");
+        return;
+    }
+
+    if (playerName.empty()) {
+        addSystemChatMessage("You must specify a player name.");
+        return;
+    }
+
+    auto packet = AddIgnorePacket::build(playerName);
+    socket->send(packet);
+    addSystemChatMessage("Adding " + playerName + " to ignore list...");
+    LOG_INFO("Sent ignore request for: ", playerName);
 }
 
 void GameHandler::removeIgnore(const std::string& playerName) {
-    if (socialHandler_) socialHandler_->removeIgnore(playerName);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot remove ignore: not in world or not connected");
+        return;
+    }
+
+    if (playerName.empty()) {
+        addSystemChatMessage("You must specify a player name.");
+        return;
+    }
+
+    // Look up GUID from cache
+    auto it = ignoreCache.find(playerName);
+    if (it == ignoreCache.end()) {
+        addSystemChatMessage(playerName + " is not in your ignore list.");
+        LOG_WARNING("Ignored player not found in cache: ", playerName);
+        return;
+    }
+
+    auto packet = DelIgnorePacket::build(it->second);
+    socket->send(packet);
+    addSystemChatMessage("Removing " + playerName + " from ignore list...");
+    ignoreCache.erase(it);
+    LOG_INFO("Sent remove ignore request for: ", playerName, " (GUID: 0x", std::hex, it->second, std::dec, ")");
 }
 
 void GameHandler::requestLogout() {
-    if (socialHandler_) socialHandler_->requestLogout();
+    if (!socket) {
+        LOG_WARNING("Cannot logout: not connected");
+        return;
+    }
+
+    if (loggingOut_) {
+        addSystemChatMessage("Already logging out.");
+        return;
+    }
+
+    auto packet = LogoutRequestPacket::build();
+    socket->send(packet);
+    loggingOut_ = true;
+    LOG_INFO("Sent logout request");
 }
 
 void GameHandler::cancelLogout() {
-    if (socialHandler_) socialHandler_->cancelLogout();
-}
+    if (!socket) {
+        LOG_WARNING("Cannot cancel logout: not connected");
+        return;
+    }
 
-void GameHandler::sendSetDifficulty(uint32_t difficulty) {
-    if (socialHandler_) socialHandler_->sendSetDifficulty(difficulty);
+    if (!loggingOut_) {
+        addSystemChatMessage("Not currently logging out.");
+        return;
+    }
+
+    auto packet = LogoutCancelPacket::build();
+    socket->send(packet);
+    loggingOut_ = false;
+    addSystemChatMessage("Logout cancelled.");
+    LOG_INFO("Cancelled logout");
 }
 
 void GameHandler::setStandState(uint8_t standState) {
-    if (socialHandler_) socialHandler_->setStandState(standState);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot change stand state: not in world or not connected");
+        return;
+    }
+
+    auto packet = StandStateChangePacket::build(standState);
+    socket->send(packet);
+    LOG_INFO("Changed stand state to: ", (int)standState);
 }
 
 void GameHandler::toggleHelm() {
-    if (socialHandler_) socialHandler_->toggleHelm();
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot toggle helm: not in world or not connected");
+        return;
+    }
+
+    helmVisible_ = !helmVisible_;
+    auto packet = ShowingHelmPacket::build(helmVisible_);
+    socket->send(packet);
+    addSystemChatMessage(helmVisible_ ? "Helm is now visible." : "Helm is now hidden.");
+    LOG_INFO("Helm visibility toggled: ", helmVisible_);
 }
 
 void GameHandler::toggleCloak() {
-    if (socialHandler_) socialHandler_->toggleCloak();
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot toggle cloak: not in world or not connected");
+        return;
+    }
+
+    cloakVisible_ = !cloakVisible_;
+    auto packet = ShowingCloakPacket::build(cloakVisible_);
+    socket->send(packet);
+    addSystemChatMessage(cloakVisible_ ? "Cloak is now visible." : "Cloak is now hidden.");
+    LOG_INFO("Cloak visibility toggled: ", cloakVisible_);
 }
 
 void GameHandler::followTarget() {
-    if (movementHandler_) movementHandler_->followTarget();
-}
+    if (state != WorldState::IN_WORLD) {
+        LOG_WARNING("Cannot follow: not in world");
+        return;
+    }
 
-void GameHandler::cancelFollow() {
-    if (movementHandler_) movementHandler_->cancelFollow();
+    if (targetGuid == 0) {
+        addSystemChatMessage("You must target someone to follow.");
+        return;
+    }
+
+    auto target = getTarget();
+    if (!target) {
+        addSystemChatMessage("Invalid target.");
+        return;
+    }
+
+    // Set follow target
+    followTargetGuid_ = targetGuid;
+
+    // Get target name
+    std::string targetName = "Target";
+    if (target->getType() == ObjectType::PLAYER) {
+        auto player = std::static_pointer_cast<Player>(target);
+        if (!player->getName().empty()) {
+            targetName = player->getName();
+        }
+    } else if (target->getType() == ObjectType::UNIT) {
+        auto unit = std::static_pointer_cast<Unit>(target);
+        targetName = unit->getName();
+    }
+
+    addSystemChatMessage("Now following " + targetName + ".");
+    LOG_INFO("Following target: ", targetName, " (GUID: 0x", std::hex, targetGuid, std::dec, ")");
 }
 
 void GameHandler::assistTarget() {
-    if (combatHandler_) combatHandler_->assistTarget();
+    if (state != WorldState::IN_WORLD) {
+        LOG_WARNING("Cannot assist: not in world");
+        return;
+    }
+
+    if (targetGuid == 0) {
+        addSystemChatMessage("You must target someone to assist.");
+        return;
+    }
+
+    auto target = getTarget();
+    if (!target) {
+        addSystemChatMessage("Invalid target.");
+        return;
+    }
+
+    // Get target name
+    std::string targetName = "Target";
+    if (target->getType() == ObjectType::PLAYER) {
+        auto player = std::static_pointer_cast<Player>(target);
+        if (!player->getName().empty()) {
+            targetName = player->getName();
+        }
+    } else if (target->getType() == ObjectType::UNIT) {
+        auto unit = std::static_pointer_cast<Unit>(target);
+        targetName = unit->getName();
+    }
+
+    // Try to read target GUID from update fields (UNIT_FIELD_TARGET)
+    uint64_t assistTargetGuid = 0;
+    const auto& fields = target->getFields();
+    auto it = fields.find(fieldIndex(UF::UNIT_FIELD_TARGET_LO));
+    if (it != fields.end()) {
+        assistTargetGuid = it->second;
+        auto it2 = fields.find(fieldIndex(UF::UNIT_FIELD_TARGET_HI));
+        if (it2 != fields.end()) {
+            assistTargetGuid |= (static_cast<uint64_t>(it2->second) << 32);
+        }
+    }
+
+    if (assistTargetGuid == 0) {
+        addSystemChatMessage(targetName + " has no target.");
+        LOG_INFO("Assist: ", targetName, " has no target");
+        return;
+    }
+
+    // Set our target to their target
+    setTarget(assistTargetGuid);
+    LOG_INFO("Assisting ", targetName, ", now targeting GUID: 0x", std::hex, assistTargetGuid, std::dec);
 }
 
 void GameHandler::togglePvp() {
-    if (combatHandler_) combatHandler_->togglePvp();
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot toggle PvP: not in world or not connected");
+        return;
+    }
+
+    auto packet = TogglePvpPacket::build();
+    socket->send(packet);
+    // Check current PVP state from player's UNIT_FIELD_FLAGS (index 59)
+    // UNIT_FLAG_PVP = 0x00001000
+    auto entity = entityManager.getEntity(playerGuid);
+    bool currentlyPvp = false;
+    if (entity) {
+        currentlyPvp = (entity->getField(59) & 0x00001000) != 0;
+    }
+    // We're toggling, so report the NEW state
+    if (currentlyPvp) {
+        addSystemChatMessage("PvP flag disabled.");
+    } else {
+        addSystemChatMessage("PvP flag enabled.");
+    }
+    LOG_INFO("Toggled PvP flag");
 }
 
 void GameHandler::requestGuildInfo() {
-    if (socialHandler_) socialHandler_->requestGuildInfo();
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot request guild info: not in world or not connected");
+        return;
+    }
+
+    auto packet = GuildInfoPacket::build();
+    socket->send(packet);
+    LOG_INFO("Requested guild info");
 }
 
 void GameHandler::requestGuildRoster() {
-    if (socialHandler_) socialHandler_->requestGuildRoster();
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot request guild roster: not in world or not connected");
+        return;
+    }
+
+    auto packet = GuildRosterPacket::build();
+    socket->send(packet);
+    addSystemChatMessage("Requesting guild roster...");
+    LOG_INFO("Requested guild roster");
 }
 
 void GameHandler::setGuildMotd(const std::string& motd) {
-    if (socialHandler_) socialHandler_->setGuildMotd(motd);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot set guild MOTD: not in world or not connected");
+        return;
+    }
+
+    auto packet = GuildMotdPacket::build(motd);
+    socket->send(packet);
+    addSystemChatMessage("Guild MOTD updated.");
+    LOG_INFO("Set guild MOTD: ", motd);
 }
 
 void GameHandler::promoteGuildMember(const std::string& playerName) {
-    if (socialHandler_) socialHandler_->promoteGuildMember(playerName);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot promote guild member: not in world or not connected");
+        return;
+    }
+
+    if (playerName.empty()) {
+        addSystemChatMessage("You must specify a player name.");
+        return;
+    }
+
+    auto packet = GuildPromotePacket::build(playerName);
+    socket->send(packet);
+    addSystemChatMessage("Promoting " + playerName + "...");
+    LOG_INFO("Promoting guild member: ", playerName);
 }
 
 void GameHandler::demoteGuildMember(const std::string& playerName) {
-    if (socialHandler_) socialHandler_->demoteGuildMember(playerName);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot demote guild member: not in world or not connected");
+        return;
+    }
+
+    if (playerName.empty()) {
+        addSystemChatMessage("You must specify a player name.");
+        return;
+    }
+
+    auto packet = GuildDemotePacket::build(playerName);
+    socket->send(packet);
+    addSystemChatMessage("Demoting " + playerName + "...");
+    LOG_INFO("Demoting guild member: ", playerName);
 }
 
 void GameHandler::leaveGuild() {
-    if (socialHandler_) socialHandler_->leaveGuild();
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot leave guild: not in world or not connected");
+        return;
+    }
+
+    auto packet = GuildLeavePacket::build();
+    socket->send(packet);
+    addSystemChatMessage("Leaving guild...");
+    LOG_INFO("Leaving guild");
 }
 
 void GameHandler::inviteToGuild(const std::string& playerName) {
-    if (socialHandler_) socialHandler_->inviteToGuild(playerName);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot invite to guild: not in world or not connected");
+        return;
+    }
+
+    if (playerName.empty()) {
+        addSystemChatMessage("You must specify a player name.");
+        return;
+    }
+
+    auto packet = GuildInvitePacket::build(playerName);
+    socket->send(packet);
+    addSystemChatMessage("Inviting " + playerName + " to guild...");
+    LOG_INFO("Inviting to guild: ", playerName);
 }
 
 void GameHandler::initiateReadyCheck() {
-    if (socialHandler_) socialHandler_->initiateReadyCheck();
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot initiate ready check: not in world or not connected");
+        return;
+    }
+
+    if (!isInGroup()) {
+        addSystemChatMessage("You must be in a group to initiate a ready check.");
+        return;
+    }
+
+    auto packet = ReadyCheckPacket::build();
+    socket->send(packet);
+    addSystemChatMessage("Ready check initiated.");
+    LOG_INFO("Initiated ready check");
 }
 
 void GameHandler::respondToReadyCheck(bool ready) {
-    if (socialHandler_) socialHandler_->respondToReadyCheck(ready);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot respond to ready check: not in world or not connected");
+        return;
+    }
+
+    auto packet = ReadyCheckConfirmPacket::build(ready);
+    socket->send(packet);
+    addSystemChatMessage(ready ? "You are ready." : "You are not ready.");
+    LOG_INFO("Responded to ready check: ", ready ? "ready" : "not ready");
 }
 
 void GameHandler::acceptDuel() {
-    if (socialHandler_) socialHandler_->acceptDuel();
+    if (!pendingDuelRequest_ || state != WorldState::IN_WORLD || !socket) return;
+    pendingDuelRequest_ = false;
+    auto pkt = DuelAcceptPacket::build();
+    socket->send(pkt);
+    addSystemChatMessage("You accept the duel.");
+    LOG_INFO("Accepted duel from guid=0x", std::hex, duelChallengerGuid_, std::dec);
 }
 
 void GameHandler::forfeitDuel() {
-    if (socialHandler_) socialHandler_->forfeitDuel();
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot forfeit duel: not in world or not connected");
+        return;
+    }
+    pendingDuelRequest_ = false;  // cancel request if still pending
+    auto packet = DuelCancelPacket::build();
+    socket->send(packet);
+    addSystemChatMessage("You have forfeited the duel.");
+    LOG_INFO("Forfeited duel");
+}
+
+void GameHandler::handleDuelRequested(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 16) {
+        packet.setReadPos(packet.getSize());
+        return;
+    }
+    duelChallengerGuid_ = packet.readUInt64();
+    duelFlagGuid_       = packet.readUInt64();
+
+    // Resolve challenger name from entity list
+    duelChallengerName_.clear();
+    auto entity = entityManager.getEntity(duelChallengerGuid_);
+    if (auto* unit = dynamic_cast<Unit*>(entity.get())) {
+        duelChallengerName_ = unit->getName();
+    }
+    if (duelChallengerName_.empty()) {
+        char tmp[32];
+        std::snprintf(tmp, sizeof(tmp), "0x%llX",
+                      static_cast<unsigned long long>(duelChallengerGuid_));
+        duelChallengerName_ = tmp;
+    }
+    pendingDuelRequest_ = true;
+
+    addSystemChatMessage(duelChallengerName_ + " challenges you to a duel!");
+    LOG_INFO("SMSG_DUEL_REQUESTED: challenger=0x", std::hex, duelChallengerGuid_,
+             " flag=0x", duelFlagGuid_, std::dec, " name=", duelChallengerName_);
+}
+
+void GameHandler::handleDuelComplete(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 1) return;
+    uint8_t started = packet.readUInt8();
+    // started=1: duel began, started=0: duel was cancelled before starting
+    pendingDuelRequest_ = false;
+    if (!started) {
+        addSystemChatMessage("The duel was cancelled.");
+    }
+    LOG_INFO("SMSG_DUEL_COMPLETE: started=", static_cast<int>(started));
+}
+
+void GameHandler::handleDuelWinner(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 3) return;
+    /*uint8_t type =*/ packet.readUInt8();  // 0=normal, 1=flee
+    std::string winner = packet.readString();
+    std::string loser  = packet.readString();
+
+    std::string msg = winner + " has defeated " + loser + " in a duel!";
+    addSystemChatMessage(msg);
+    LOG_INFO("SMSG_DUEL_WINNER: winner=", winner, " loser=", loser);
 }
 
 void GameHandler::toggleAfk(const std::string& message) {
-    if (chatHandler_) chatHandler_->toggleAfk(message);
+    afkStatus_ = !afkStatus_;
+    afkMessage_ = message;
+
+    if (afkStatus_) {
+        if (message.empty()) {
+            addSystemChatMessage("You are now AFK.");
+        } else {
+            addSystemChatMessage("You are now AFK: " + message);
+        }
+        // If DND was active, turn it off
+        if (dndStatus_) {
+            dndStatus_ = false;
+            dndMessage_.clear();
+        }
+    } else {
+        addSystemChatMessage("You are no longer AFK.");
+        afkMessage_.clear();
+    }
+
+    LOG_INFO("AFK status: ", afkStatus_, ", message: ", message);
 }
 
 void GameHandler::toggleDnd(const std::string& message) {
-    if (chatHandler_) chatHandler_->toggleDnd(message);
+    dndStatus_ = !dndStatus_;
+    dndMessage_ = message;
+
+    if (dndStatus_) {
+        if (message.empty()) {
+            addSystemChatMessage("You are now DND (Do Not Disturb).");
+        } else {
+            addSystemChatMessage("You are now DND: " + message);
+        }
+        // If AFK was active, turn it off
+        if (afkStatus_) {
+            afkStatus_ = false;
+            afkMessage_.clear();
+        }
+    } else {
+        addSystemChatMessage("You are no longer DND.");
+        dndMessage_.clear();
+    }
+
+    LOG_INFO("DND status: ", dndStatus_, ", message: ", message);
 }
 
 void GameHandler::replyToLastWhisper(const std::string& message) {
-    if (chatHandler_) chatHandler_->replyToLastWhisper(message);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot send whisper: not in world or not connected");
+        return;
+    }
+
+    if (lastWhisperSender_.empty()) {
+        addSystemChatMessage("No one has whispered you yet.");
+        return;
+    }
+
+    if (message.empty()) {
+        addSystemChatMessage("You must specify a message to send.");
+        return;
+    }
+
+    // Send whisper using the standard message chat function
+    sendChatMessage(ChatType::WHISPER, message, lastWhisperSender_);
+    LOG_INFO("Replied to ", lastWhisperSender_, ": ", message);
 }
 
 void GameHandler::uninvitePlayer(const std::string& playerName) {
-    if (socialHandler_) socialHandler_->uninvitePlayer(playerName);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot uninvite player: not in world or not connected");
+        return;
+    }
+
+    if (playerName.empty()) {
+        addSystemChatMessage("You must specify a player name to uninvite.");
+        return;
+    }
+
+    auto packet = GroupUninvitePacket::build(playerName);
+    socket->send(packet);
+    addSystemChatMessage("Removed " + playerName + " from the group.");
+    LOG_INFO("Uninvited player: ", playerName);
 }
 
 void GameHandler::leaveParty() {
-    if (socialHandler_) socialHandler_->leaveParty();
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot leave party: not in world or not connected");
+        return;
+    }
+
+    auto packet = GroupDisbandPacket::build();
+    socket->send(packet);
+    addSystemChatMessage("You have left the group.");
+    LOG_INFO("Left party/raid");
 }
 
 void GameHandler::setMainTank(uint64_t targetGuid) {
-    if (socialHandler_) socialHandler_->setMainTank(targetGuid);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot set main tank: not in world or not connected");
+        return;
+    }
+
+    if (targetGuid == 0) {
+        addSystemChatMessage("You must have a target selected.");
+        return;
+    }
+
+    // Main tank uses index 0
+    auto packet = RaidTargetUpdatePacket::build(0, targetGuid);
+    socket->send(packet);
+    addSystemChatMessage("Main tank set.");
+    LOG_INFO("Set main tank: 0x", std::hex, targetGuid, std::dec);
 }
 
 void GameHandler::setMainAssist(uint64_t targetGuid) {
-    if (socialHandler_) socialHandler_->setMainAssist(targetGuid);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot set main assist: not in world or not connected");
+        return;
+    }
+
+    if (targetGuid == 0) {
+        addSystemChatMessage("You must have a target selected.");
+        return;
+    }
+
+    // Main assist uses index 1
+    auto packet = RaidTargetUpdatePacket::build(1, targetGuid);
+    socket->send(packet);
+    addSystemChatMessage("Main assist set.");
+    LOG_INFO("Set main assist: 0x", std::hex, targetGuid, std::dec);
 }
 
 void GameHandler::clearMainTank() {
-    if (socialHandler_) socialHandler_->clearMainTank();
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot clear main tank: not in world or not connected");
+        return;
+    }
+
+    // Clear main tank by setting GUID to 0
+    auto packet = RaidTargetUpdatePacket::build(0, 0);
+    socket->send(packet);
+    addSystemChatMessage("Main tank cleared.");
+    LOG_INFO("Cleared main tank");
 }
 
 void GameHandler::clearMainAssist() {
-    if (socialHandler_) socialHandler_->clearMainAssist();
-}
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot clear main assist: not in world or not connected");
+        return;
+    }
 
-void GameHandler::setRaidMark(uint64_t guid, uint8_t icon) {
-    if (socialHandler_) socialHandler_->setRaidMark(guid, icon);
+    // Clear main assist by setting GUID to 0
+    auto packet = RaidTargetUpdatePacket::build(1, 0);
+    socket->send(packet);
+    addSystemChatMessage("Main assist cleared.");
+    LOG_INFO("Cleared main assist");
 }
 
 void GameHandler::requestRaidInfo() {
-    if (socialHandler_) socialHandler_->requestRaidInfo();
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot request raid info: not in world or not connected");
+        return;
+    }
+
+    auto packet = RequestRaidInfoPacket::build();
+    socket->send(packet);
+    addSystemChatMessage("Requesting raid lockout information...");
+    LOG_INFO("Requested raid info");
 }
 
 void GameHandler::proposeDuel(uint64_t targetGuid) {
-    if (socialHandler_) socialHandler_->proposeDuel(targetGuid);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot propose duel: not in world or not connected");
+        return;
+    }
+
+    if (targetGuid == 0) {
+        addSystemChatMessage("You must target a player to challenge to a duel.");
+        return;
+    }
+
+    auto packet = DuelProposedPacket::build(targetGuid);
+    socket->send(packet);
+    addSystemChatMessage("You have challenged your target to a duel.");
+    LOG_INFO("Proposed duel to target: 0x", std::hex, targetGuid, std::dec);
 }
 
 void GameHandler::initiateTrade(uint64_t targetGuid) {
-    if (inventoryHandler_) inventoryHandler_->initiateTrade(targetGuid);
-}
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot initiate trade: not in world or not connected");
+        return;
+    }
 
-void GameHandler::reportPlayer(uint64_t targetGuid, const std::string& reason) {
-    if (socialHandler_) socialHandler_->reportPlayer(targetGuid, reason);
+    if (targetGuid == 0) {
+        addSystemChatMessage("You must target a player to trade with.");
+        return;
+    }
+
+    auto packet = InitiateTradePacket::build(targetGuid);
+    socket->send(packet);
+    addSystemChatMessage("Requesting trade with target.");
+    LOG_INFO("Initiated trade with target: 0x", std::hex, targetGuid, std::dec);
 }
 
 void GameHandler::stopCasting() {
-    if (spellHandler_) spellHandler_->stopCasting();
-}
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("Cannot stop casting: not in world or not connected");
+        return;
+    }
 
-void GameHandler::resetCastState() {
-    if (spellHandler_) spellHandler_->resetCastState();
-}
+    if (!casting) {
+        return; // Not casting anything
+    }
 
-void GameHandler::clearUnitCaches() {
-    if (spellHandler_) spellHandler_->clearUnitCaches();
+    // Send cancel cast packet only for real spell casts.
+    if (pendingGameObjectInteractGuid_ == 0 && currentCastSpellId != 0) {
+        auto packet = CancelCastPacket::build(currentCastSpellId);
+        socket->send(packet);
+    }
+
+    // Reset casting state
+    casting = false;
+    currentCastSpellId = 0;
+    pendingGameObjectInteractGuid_ = 0;
+    castTimeRemaining = 0.0f;
+    castTimeTotal = 0.0f;
+
+    LOG_INFO("Cancelled spell cast");
 }
 
 void GameHandler::releaseSpirit() {
-    if (combatHandler_) combatHandler_->releaseSpirit();
-}
-
-bool GameHandler::canReclaimCorpse() const {
-    return combatHandler_ ? combatHandler_->canReclaimCorpse() : false;
-}
-
-float GameHandler::getCorpseReclaimDelaySec() const {
-    return combatHandler_ ? combatHandler_->getCorpseReclaimDelaySec() : 0.0f;
-}
-
-void GameHandler::reclaimCorpse() {
-    if (combatHandler_) combatHandler_->reclaimCorpse();
-}
-
-void GameHandler::useSelfRes() {
-    if (combatHandler_) combatHandler_->useSelfRes();
+    if (socket && state == WorldState::IN_WORLD) {
+        auto now = std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::steady_clock::now().time_since_epoch()).count();
+        if (repopPending_ && now - static_cast<int64_t>(lastRepopRequestMs_) < 1000) {
+            return;
+        }
+        auto packet = RepopRequestPacket::build();
+        socket->send(packet);
+        releasedSpirit_ = true;
+        repopPending_ = true;
+        lastRepopRequestMs_ = static_cast<uint64_t>(now);
+        LOG_INFO("Sent CMSG_REPOP_REQUEST (Release Spirit)");
+    }
 }
 
 void GameHandler::activateSpiritHealer(uint64_t npcGuid) {
-    if (combatHandler_) combatHandler_->activateSpiritHealer(npcGuid);
+    if (state != WorldState::IN_WORLD || !socket) return;
+    pendingSpiritHealerGuid_ = npcGuid;
+    auto packet = SpiritHealerActivatePacket::build(npcGuid);
+    socket->send(packet);
+    resurrectPending_ = true;
+    LOG_INFO("Sent CMSG_SPIRIT_HEALER_ACTIVATE for 0x", std::hex, npcGuid, std::dec);
 }
 
 void GameHandler::acceptResurrect() {
-    if (combatHandler_) combatHandler_->acceptResurrect();
+    if (state != WorldState::IN_WORLD || !socket || !resurrectRequestPending_) return;
+    // Send spirit healer activate (correct response to SMSG_SPIRIT_HEALER_CONFIRM)
+    auto activate = SpiritHealerActivatePacket::build(resurrectCasterGuid_);
+    socket->send(activate);
+    LOG_INFO("Sent CMSG_SPIRIT_HEALER_ACTIVATE (0x21C) for 0x",
+             std::hex, resurrectCasterGuid_, std::dec);
+    resurrectRequestPending_ = false;
+    resurrectPending_ = true;
 }
 
 void GameHandler::declineResurrect() {
-    if (combatHandler_) combatHandler_->declineResurrect();
+    if (state != WorldState::IN_WORLD || !socket || !resurrectRequestPending_) return;
+    auto resp = ResurrectResponsePacket::build(resurrectCasterGuid_, false);
+    socket->send(resp);
+    LOG_INFO("Sent CMSG_RESURRECT_RESPONSE (decline) for 0x",
+             std::hex, resurrectCasterGuid_, std::dec);
+    resurrectRequestPending_ = false;
 }
 
 void GameHandler::tabTarget(float playerX, float playerY, float playerZ) {
-    if (combatHandler_) combatHandler_->tabTarget(playerX, playerY, playerZ);
+    // Helper: returns true if the entity is a living hostile that can be tab-targeted.
+    auto isValidTabTarget = [&](const std::shared_ptr<Entity>& e) -> bool {
+        if (!e) return false;
+        const uint64_t guid = e->getGuid();
+        auto* unit = dynamic_cast<Unit*>(e.get());
+        if (!unit) return false;           // Not a unit (shouldn't happen after type filter)
+        if (unit->getHealth() == 0) return false;  // Dead / corpse
+        const bool hostileByFaction = unit->isHostile();
+        const bool hostileByCombat = isAggressiveTowardPlayer(guid);
+        if (!hostileByFaction && !hostileByCombat) return false;
+        return true;
+    };
+
+    // Rebuild cycle list if stale (entity added/removed since last tab press).
+    if (tabCycleStale) {
+        tabCycleList.clear();
+        tabCycleIndex = -1;
+
+        struct EntityDist { uint64_t guid; float distance; };
+        std::vector<EntityDist> sortable;
+
+        for (const auto& [guid, entity] : entityManager.getEntities()) {
+            auto t = entity->getType();
+            if (t != ObjectType::UNIT && t != ObjectType::PLAYER) continue;
+            if (guid == playerGuid) continue;
+            if (!isValidTabTarget(entity)) continue;  // Skip dead / non-hostile
+            float dx = entity->getX() - playerX;
+            float dy = entity->getY() - playerY;
+            float dz = entity->getZ() - playerZ;
+            sortable.push_back({guid, std::sqrt(dx*dx + dy*dy + dz*dz)});
+        }
+
+        std::sort(sortable.begin(), sortable.end(),
+                  [](const EntityDist& a, const EntityDist& b) { return a.distance < b.distance; });
+
+        for (const auto& ed : sortable) {
+            tabCycleList.push_back(ed.guid);
+        }
+        tabCycleStale = false;
+    }
+
+    if (tabCycleList.empty()) {
+        clearTarget();
+        return;
+    }
+
+    // Advance through the cycle, skipping any entry that has since died or
+    // turned friendly (e.g. NPC killed between two tab presses).
+    int tries = static_cast<int>(tabCycleList.size());
+    while (tries-- > 0) {
+        tabCycleIndex = (tabCycleIndex + 1) % static_cast<int>(tabCycleList.size());
+        uint64_t guid = tabCycleList[tabCycleIndex];
+        auto entity = entityManager.getEntity(guid);
+        if (isValidTabTarget(entity)) {
+            setTarget(guid);
+            return;
+        }
+    }
+
+    // All cached entries are stale — clear target and force a fresh rebuild next time.
+    tabCycleStale = true;
+    clearTarget();
 }
 
 void GameHandler::addLocalChatMessage(const MessageChatData& msg) {
-    if (chatHandler_) chatHandler_->addLocalChatMessage(msg);
-}
-
-const std::deque<MessageChatData>& GameHandler::getChatHistory() const {
-    if (chatHandler_) return chatHandler_->getChatHistory();
-    static const std::deque<MessageChatData> kEmpty;
-    return kEmpty;
-}
-
-void GameHandler::clearChatHistory() {
-    if (chatHandler_) chatHandler_->getChatHistory().clear();
-}
-
-const std::vector<std::string>& GameHandler::getJoinedChannels() const {
-    if (chatHandler_) return chatHandler_->getJoinedChannels();
-    static const std::vector<std::string> kEmpty;
-    return kEmpty;
+    chatHistory.push_back(msg);
+    if (chatHistory.size() > maxChatHistory) {
+        chatHistory.pop_front();
+    }
 }
 
 // ============================================================
-// Name Queries (delegated to EntityController)
+// Phase 1: Name Queries
 // ============================================================
 
 void GameHandler::queryPlayerName(uint64_t guid) {
-    if (entityController_) entityController_->queryPlayerName(guid);
+    if (playerNameCache.count(guid) || pendingNameQueries.count(guid)) return;
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_INFO("queryPlayerName: skipped guid=0x", std::hex, guid, std::dec,
+                 " state=", worldStateName(state), " socket=", (socket ? "yes" : "no"));
+        return;
+    }
+
+    LOG_INFO("queryPlayerName: sending CMSG_NAME_QUERY for guid=0x", std::hex, guid, std::dec);
+    pendingNameQueries.insert(guid);
+    auto packet = NameQueryPacket::build(guid);
+    socket->send(packet);
 }
 
 void GameHandler::queryCreatureInfo(uint32_t entry, uint64_t guid) {
-    if (entityController_) entityController_->queryCreatureInfo(entry, guid);
+    if (creatureInfoCache.count(entry) || pendingCreatureQueries.count(entry)) return;
+    if (state != WorldState::IN_WORLD || !socket) return;
+
+    pendingCreatureQueries.insert(entry);
+    auto packet = CreatureQueryPacket::build(entry, guid);
+    socket->send(packet);
 }
 
 void GameHandler::queryGameObjectInfo(uint32_t entry, uint64_t guid) {
-    if (entityController_) entityController_->queryGameObjectInfo(entry, guid);
+    if (gameObjectInfoCache_.count(entry) || pendingGameObjectQueries_.count(entry)) return;
+    if (state != WorldState::IN_WORLD || !socket) return;
+
+    pendingGameObjectQueries_.insert(entry);
+    auto packet = GameObjectQueryPacket::build(entry, guid);
+    socket->send(packet);
 }
 
 std::string GameHandler::getCachedPlayerName(uint64_t guid) const {
-    return entityController_ ? entityController_->getCachedPlayerName(guid) : "";
+    auto it = playerNameCache.find(guid);
+    return (it != playerNameCache.end()) ? it->second : "";
 }
 
 std::string GameHandler::getCachedCreatureName(uint32_t entry) const {
-    return entityController_ ? entityController_->getCachedCreatureName(entry) : "";
+    auto it = creatureInfoCache.find(entry);
+    return (it != creatureInfoCache.end()) ? it->second.name : "";
+}
+
+void GameHandler::handleNameQueryResponse(network::Packet& packet) {
+    NameQueryResponseData data;
+    if (!packetParsers_ || !packetParsers_->parseNameQueryResponse(packet, data)) {
+        LOG_WARNING("Failed to parse SMSG_NAME_QUERY_RESPONSE (size=", packet.getSize(), ")");
+        return;
+    }
+
+    pendingNameQueries.erase(data.guid);
+
+    LOG_INFO("Name query response: guid=0x", std::hex, data.guid, std::dec,
+             " found=", (int)data.found, " name='", data.name, "'",
+             " race=", (int)data.race, " class=", (int)data.classId);
+
+    if (data.isValid()) {
+        playerNameCache[data.guid] = data.name;
+        // Update entity name
+        auto entity = entityManager.getEntity(data.guid);
+        if (entity && entity->getType() == ObjectType::PLAYER) {
+            auto player = std::static_pointer_cast<Player>(entity);
+            player->setName(data.name);
+        }
+
+        // Backfill chat history entries that arrived before we knew the name.
+        for (auto& msg : chatHistory) {
+            if (msg.senderGuid == data.guid && msg.senderName.empty()) {
+                msg.senderName = data.name;
+            }
+        }
+
+        // Backfill mail inbox sender names
+        for (auto& mail : mailInbox_) {
+            if (mail.messageType == 0 && mail.senderGuid == data.guid) {
+                mail.senderName = data.name;
+            }
+        }
+    }
+}
+
+void GameHandler::handleCreatureQueryResponse(network::Packet& packet) {
+    CreatureQueryResponseData data;
+    if (!CreatureQueryResponseParser::parse(packet, data)) return;
+
+    pendingCreatureQueries.erase(data.entry);
+
+    if (data.isValid()) {
+        creatureInfoCache[data.entry] = data;
+        // Update all unit entities with this entry
+        for (auto& [guid, entity] : entityManager.getEntities()) {
+            if (entity->getType() == ObjectType::UNIT) {
+                auto unit = std::static_pointer_cast<Unit>(entity);
+                if (unit->getEntry() == data.entry) {
+                    unit->setName(data.name);
+                }
+            }
+        }
+    }
 }
 
 // ============================================================
-// Item Query (forwarded to InventoryHandler)
+// GameObject Query
+// ============================================================
+
+void GameHandler::handleGameObjectQueryResponse(network::Packet& packet) {
+    GameObjectQueryResponseData data;
+    bool ok = packetParsers_ ? packetParsers_->parseGameObjectQueryResponse(packet, data)
+                             : GameObjectQueryResponseParser::parse(packet, data);
+    if (!ok) return;
+
+    pendingGameObjectQueries_.erase(data.entry);
+
+    if (data.isValid()) {
+        gameObjectInfoCache_[data.entry] = data;
+        // Update all gameobject entities with this entry
+        for (auto& [guid, entity] : entityManager.getEntities()) {
+            if (entity->getType() == ObjectType::GAMEOBJECT) {
+                auto go = std::static_pointer_cast<GameObject>(entity);
+                if (go->getEntry() == data.entry) {
+                    go->setName(data.name);
+                }
+            }
+        }
+
+        // MO_TRANSPORT (type 15): assign TaxiPathNode path if available
+        if (data.type == 15 && data.hasData && data.data[0] != 0 && transportManager_) {
+            uint32_t taxiPathId = data.data[0];
+            if (transportManager_->hasTaxiPath(taxiPathId)) {
+                if (transportManager_->assignTaxiPathToTransport(data.entry, taxiPathId)) {
+                    LOG_DEBUG("MO_TRANSPORT entry=", data.entry, " assigned TaxiPathNode path ", taxiPathId);
+                }
+            } else {
+                LOG_DEBUG("MO_TRANSPORT entry=", data.entry, " taxiPathId=", taxiPathId,
+                         " not found in TaxiPathNode.dbc");
+            }
+        }
+    }
+}
+
+void GameHandler::handleGameObjectPageText(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 8) return;
+    uint64_t guid = packet.readUInt64();
+    auto entity = entityManager.getEntity(guid);
+    if (!entity || entity->getType() != ObjectType::GAMEOBJECT) return;
+
+    auto go = std::static_pointer_cast<GameObject>(entity);
+    uint32_t entry = go->getEntry();
+    if (entry == 0) return;
+
+    auto cacheIt = gameObjectInfoCache_.find(entry);
+    if (cacheIt == gameObjectInfoCache_.end()) {
+        queryGameObjectInfo(entry, guid);
+        return;
+    }
+
+    const GameObjectQueryResponseData& info = cacheIt->second;
+    uint32_t pageId = 0;
+    // AzerothCore layout:
+    // type 9 (TEXT): data[0]=pageID
+    // type 10 (GOOBER): data[7]=pageId
+    if (info.type == 9) pageId = info.data[0];
+    else if (info.type == 10) pageId = info.data[7];
+
+    if (pageId != 0 && socket && state == WorldState::IN_WORLD) {
+        auto req = PageTextQueryPacket::build(pageId, guid);
+        socket->send(req);
+        return;
+    }
+
+    if (!info.name.empty()) {
+        addSystemChatMessage(info.name);
+    }
+}
+
+void GameHandler::handlePageTextQueryResponse(network::Packet& packet) {
+    PageTextQueryResponseData data;
+    if (!PageTextQueryResponseParser::parse(packet, data)) return;
+
+    if (!data.text.empty()) {
+        std::istringstream iss(data.text);
+        std::string line;
+        bool wrote = false;
+        while (std::getline(iss, line)) {
+            if (line.empty()) continue;
+            addSystemChatMessage(line);
+            wrote = true;
+        }
+        if (!wrote) {
+            addSystemChatMessage(data.text);
+        }
+    }
+}
+
+// ============================================================
+// Item Query
 // ============================================================
 
 void GameHandler::queryItemInfo(uint32_t entry, uint64_t guid) {
-    if (inventoryHandler_) inventoryHandler_->queryItemInfo(entry, guid);
+    if (itemInfoCache_.count(entry) || pendingItemQueries_.count(entry)) return;
+    if (state != WorldState::IN_WORLD || !socket) return;
+
+    pendingItemQueries_.insert(entry);
+    // Some cores reject CMSG_ITEM_QUERY_SINGLE when the GUID is 0.
+    // If we don't have the item object's GUID (e.g. visible equipment decoding),
+    // fall back to the player's GUID to keep the request non-zero.
+    uint64_t queryGuid = (guid != 0) ? guid : playerGuid;
+    auto packet = packetParsers_
+        ? packetParsers_->buildItemQuery(entry, queryGuid)
+        : ItemQueryPacket::build(entry, queryGuid);
+    socket->send(packet);
+    LOG_INFO("queryItemInfo: entry=", entry, " guid=0x", std::hex, queryGuid, std::dec,
+             " pending=", pendingItemQueries_.size());
 }
 
 void GameHandler::handleItemQueryResponse(network::Packet& packet) {
-    if (inventoryHandler_) inventoryHandler_->handleItemQueryResponse(packet);
+    ItemQueryResponseData data;
+    bool parsed = packetParsers_
+        ? packetParsers_->parseItemQueryResponse(packet, data)
+        : ItemQueryResponseParser::parse(packet, data);
+    if (!parsed) {
+        LOG_WARNING("handleItemQueryResponse: parse failed, size=", packet.getSize());
+        return;
+    }
+
+    pendingItemQueries_.erase(data.entry);
+    LOG_INFO("handleItemQueryResponse: entry=", data.entry, " valid=", data.valid,
+             " name='", data.name, "' displayInfoId=", data.displayInfoId,
+             " pending=", pendingItemQueries_.size());
+
+    if (data.valid) {
+        itemInfoCache_[data.entry] = data;
+        rebuildOnlineInventory();
+        maybeDetectVisibleItemLayout();
+
+        // Selectively re-emit only players whose equipment references this item entry
+        const uint32_t resolvedEntry = data.entry;
+        for (const auto& [guid, entries] : otherPlayerVisibleItemEntries_) {
+            for (uint32_t e : entries) {
+                if (e == resolvedEntry) {
+                    emitOtherPlayerEquipment(guid);
+                    break;
+                }
+            }
+        }
+        // Same for inspect-based entries
+        if (playerEquipmentCallback_) {
+            for (const auto& [guid, entries] : inspectedPlayerItemEntries_) {
+                bool relevant = false;
+                for (uint32_t e : entries) {
+                    if (e == resolvedEntry) { relevant = true; break; }
+                }
+                if (!relevant) continue;
+                std::array<uint32_t, 19> displayIds{};
+                std::array<uint8_t, 19> invTypes{};
+                for (int s = 0; s < 19; s++) {
+                    uint32_t entry = entries[s];
+                    if (entry == 0) continue;
+                    auto infoIt = itemInfoCache_.find(entry);
+                    if (infoIt == itemInfoCache_.end()) continue;
+                    displayIds[s] = infoIt->second.displayInfoId;
+                    invTypes[s] = static_cast<uint8_t>(infoIt->second.inventoryType);
+                }
+                playerEquipmentCallback_(guid, displayIds, invTypes);
+            }
+        }
+    }
+}
+
+void GameHandler::handleInspectResults(network::Packet& packet) {
+    // SMSG_TALENTS_INFO (0x3F4) format:
+    // uint8 talentType: 0 = own talents (sent on login/respec), 1 = inspect result
+    // If type==1: PackedGUID of inspected player
+    // Then: uint32 unspentTalents, uint8 talentGroupCount, uint8 activeTalentGroup
+    // Per talent group: uint8 talentCount, [talentId(u32) + rank(u8)]..., uint8 glyphCount, [glyphId(u16)]...
+    if (packet.getSize() - packet.getReadPos() < 1) return;
+
+    uint8_t talentType = packet.readUInt8();
+
+    if (talentType == 0) {
+        // Own talent info — silently consume (sent on login, talent changes, respecs)
+        LOG_DEBUG("SMSG_TALENTS_INFO: received own talent data, ignoring");
+        return;
+    }
+
+    // talentType == 1: inspect result
+    if (packet.getSize() - packet.getReadPos() < 2) return;
+
+    uint64_t guid = UpdateObjectParser::readPackedGuid(packet);
+    if (guid == 0) return;
+
+    size_t bytesLeft = packet.getSize() - packet.getReadPos();
+    if (bytesLeft < 6) {
+        LOG_WARNING("SMSG_TALENTS_INFO: too short after guid, ", bytesLeft, " bytes");
+        auto entity = entityManager.getEntity(guid);
+        std::string name = "Target";
+        if (entity) {
+            auto player = std::dynamic_pointer_cast<Player>(entity);
+            if (player && !player->getName().empty()) name = player->getName();
+        }
+        addSystemChatMessage("Inspecting " + name + " (no talent data available).");
+        return;
+    }
+
+    uint32_t unspentTalents = packet.readUInt32();
+    uint8_t talentGroupCount = packet.readUInt8();
+    uint8_t activeTalentGroup = packet.readUInt8();
+
+    // Resolve player name
+    auto entity = entityManager.getEntity(guid);
+    std::string playerName = "Target";
+    if (entity) {
+        auto player = std::dynamic_pointer_cast<Player>(entity);
+        if (player && !player->getName().empty()) playerName = player->getName();
+    }
+
+    // Parse talent groups
+    uint32_t totalTalents = 0;
+    for (uint8_t g = 0; g < talentGroupCount && g < 2; ++g) {
+        bytesLeft = packet.getSize() - packet.getReadPos();
+        if (bytesLeft < 1) break;
+
+        uint8_t talentCount = packet.readUInt8();
+        for (uint8_t t = 0; t < talentCount; ++t) {
+            bytesLeft = packet.getSize() - packet.getReadPos();
+            if (bytesLeft < 5) break;
+            packet.readUInt32(); // talentId
+            packet.readUInt8();  // rank
+            totalTalents++;
+        }
+
+        bytesLeft = packet.getSize() - packet.getReadPos();
+        if (bytesLeft < 1) break;
+        uint8_t glyphCount = packet.readUInt8();
+        for (uint8_t gl = 0; gl < glyphCount; ++gl) {
+            bytesLeft = packet.getSize() - packet.getReadPos();
+            if (bytesLeft < 2) break;
+            packet.readUInt16(); // glyphId
+        }
+    }
+
+    // Parse enchantment slot mask + enchant IDs
+    bytesLeft = packet.getSize() - packet.getReadPos();
+    if (bytesLeft >= 4) {
+        uint32_t slotMask = packet.readUInt32();
+        for (int slot = 0; slot < 19; ++slot) {
+            if (slotMask & (1u << slot)) {
+                bytesLeft = packet.getSize() - packet.getReadPos();
+                if (bytesLeft < 2) break;
+                packet.readUInt16(); // enchantId
+            }
+        }
+    }
+
+    // Display inspect results
+    std::string msg = "Inspect: " + playerName;
+    msg += " - " + std::to_string(totalTalents) + " talent points spent";
+    if (unspentTalents > 0) {
+        msg += ", " + std::to_string(unspentTalents) + " unspent";
+    }
+    if (talentGroupCount > 1) {
+        msg += " (dual spec, active: " + std::to_string(activeTalentGroup + 1) + ")";
+    }
+    addSystemChatMessage(msg);
+
+    LOG_INFO("Inspect results for ", playerName, ": ", totalTalents, " talents, ",
+             unspentTalents, " unspent, ", (int)talentGroupCount, " specs");
 }
 
 uint64_t GameHandler::resolveOnlineItemGuid(uint32_t itemId) const {
-    return inventoryHandler_ ? inventoryHandler_->resolveOnlineItemGuid(itemId) : 0;
+    if (itemId == 0) return 0;
+    for (const auto& [guid, info] : onlineItems_) {
+        if (info.entry == itemId) return guid;
+    }
+    return 0;
 }
 
 void GameHandler::detectInventorySlotBases(const std::map<uint16_t, uint32_t>& fields) {
-    if (inventoryHandler_) inventoryHandler_->detectInventorySlotBases(fields);
+    if (invSlotBase_ >= 0 && packSlotBase_ >= 0) return;
+    if (fields.empty()) return;
+
+    std::vector<uint16_t> matchingPairs;
+    matchingPairs.reserve(32);
+
+    for (const auto& [idx, low] : fields) {
+        if ((idx % 2) != 0) continue;
+        auto itHigh = fields.find(static_cast<uint16_t>(idx + 1));
+        if (itHigh == fields.end()) continue;
+        uint64_t guid = (uint64_t(itHigh->second) << 32) | low;
+        if (guid == 0) continue;
+        // Primary signal: GUID pairs that match spawned ITEM objects.
+        if (!onlineItems_.empty() && onlineItems_.count(guid)) {
+            matchingPairs.push_back(idx);
+        }
+    }
+
+    // Fallback signal (when ITEM objects haven't been seen yet):
+    // collect any plausible non-zero GUID pairs and derive a base by density.
+    if (matchingPairs.empty()) {
+        for (const auto& [idx, low] : fields) {
+            if ((idx % 2) != 0) continue;
+            auto itHigh = fields.find(static_cast<uint16_t>(idx + 1));
+            if (itHigh == fields.end()) continue;
+            uint64_t guid = (uint64_t(itHigh->second) << 32) | low;
+            if (guid == 0) continue;
+            // Heuristic: item GUIDs tend to be non-trivial and change often; ignore tiny values.
+            if (guid < 0x10000ull) continue;
+            matchingPairs.push_back(idx);
+        }
+    }
+
+    if (matchingPairs.empty()) return;
+    std::sort(matchingPairs.begin(), matchingPairs.end());
+
+    if (invSlotBase_ < 0) {
+        // The lowest matching field is the first EQUIPPED slot (not necessarily HEAD).
+        // With 2+ matches we can derive the true base: all matches must be at
+        // even offsets from the base, spaced 2 fields per slot.
+        const int knownBase = static_cast<int>(fieldIndex(UF::PLAYER_FIELD_INV_SLOT_HEAD));
+        constexpr int slotStride = 2;
+        bool allAlign = true;
+        for (uint16_t p : matchingPairs) {
+            if (p < knownBase || (p - knownBase) % slotStride != 0) {
+                allAlign = false;
+                break;
+            }
+        }
+        if (allAlign) {
+            invSlotBase_ = knownBase;
+        } else {
+            // Fallback: if we have 2+ matches, derive base from their spacing
+            if (matchingPairs.size() >= 2) {
+                uint16_t lo = matchingPairs[0];
+                // lo must be base + 2*slotN, and slotN is 0..22
+                // Try each possible slot for 'lo' and see if all others also land on valid slots
+                for (int s = 0; s <= 22; s++) {
+                    int candidate = lo - s * slotStride;
+                    if (candidate < 0) break;
+                    bool ok = true;
+                    for (uint16_t p : matchingPairs) {
+                        int off = p - candidate;
+                        if (off < 0 || off % slotStride != 0 || off / slotStride > 22) {
+                            ok = false;
+                            break;
+                        }
+                    }
+                    if (ok) {
+                        invSlotBase_ = candidate;
+                        break;
+                    }
+                }
+                if (invSlotBase_ < 0) invSlotBase_ = knownBase;
+            } else {
+                invSlotBase_ = knownBase;
+            }
+        }
+        packSlotBase_ = invSlotBase_ + (game::Inventory::NUM_EQUIP_SLOTS * 2);
+        LOG_INFO("Detected inventory field base: equip=", invSlotBase_,
+                 " pack=", packSlotBase_);
+    }
 }
 
 bool GameHandler::applyInventoryFields(const std::map<uint16_t, uint32_t>& fields) {
-    return inventoryHandler_ ? inventoryHandler_->applyInventoryFields(fields) : false;
+    bool slotsChanged = false;
+    int equipBase = (invSlotBase_ >= 0) ? invSlotBase_ : static_cast<int>(fieldIndex(UF::PLAYER_FIELD_INV_SLOT_HEAD));
+    int packBase = (packSlotBase_ >= 0) ? packSlotBase_ : static_cast<int>(fieldIndex(UF::PLAYER_FIELD_PACK_SLOT_1));
+
+    for (const auto& [key, val] : fields) {
+        if (key >= equipBase && key <= equipBase + (game::Inventory::NUM_EQUIP_SLOTS * 2 - 1)) {
+            int slotIndex = (key - equipBase) / 2;
+            bool isLow = ((key - equipBase) % 2 == 0);
+            if (slotIndex < static_cast<int>(equipSlotGuids_.size())) {
+                uint64_t& guid = equipSlotGuids_[slotIndex];
+                if (isLow) guid = (guid & 0xFFFFFFFF00000000ULL) | val;
+                else guid = (guid & 0x00000000FFFFFFFFULL) | (uint64_t(val) << 32);
+                slotsChanged = true;
+            }
+        } else if (key >= packBase && key <= packBase + (game::Inventory::BACKPACK_SLOTS * 2 - 1)) {
+            int slotIndex = (key - packBase) / 2;
+            bool isLow = ((key - packBase) % 2 == 0);
+            if (slotIndex < static_cast<int>(backpackSlotGuids_.size())) {
+                uint64_t& guid = backpackSlotGuids_[slotIndex];
+                if (isLow) guid = (guid & 0xFFFFFFFF00000000ULL) | val;
+                else guid = (guid & 0x00000000FFFFFFFFULL) | (uint64_t(val) << 32);
+                slotsChanged = true;
+            }
+        }
+
+        // Bank slots starting at PLAYER_FIELD_BANK_SLOT_1
+        int bankBase = static_cast<int>(fieldIndex(UF::PLAYER_FIELD_BANK_SLOT_1));
+        int bankBagBase = static_cast<int>(fieldIndex(UF::PLAYER_FIELD_BANKBAG_SLOT_1));
+        // Derive slot counts from field gap (Classic=24/6, TBC/WotLK=28/7)
+        if (bankBase != 0xFFFF && bankBagBase != 0xFFFF) {
+            effectiveBankSlots_ = std::min((bankBagBase - bankBase) / 2, 28);
+            effectiveBankBagSlots_ = (effectiveBankSlots_ <= 24) ? 6 : 7;
+        }
+        if (bankBase != 0xFFFF && key >= static_cast<uint16_t>(bankBase) &&
+            key <= static_cast<uint16_t>(bankBase) + (effectiveBankSlots_ * 2 - 1)) {
+            int slotIndex = (key - bankBase) / 2;
+            bool isLow = ((key - bankBase) % 2 == 0);
+            if (slotIndex < static_cast<int>(bankSlotGuids_.size())) {
+                uint64_t& guid = bankSlotGuids_[slotIndex];
+                if (isLow) guid = (guid & 0xFFFFFFFF00000000ULL) | val;
+                else guid = (guid & 0x00000000FFFFFFFFULL) | (uint64_t(val) << 32);
+                slotsChanged = true;
+            }
+        }
+
+        // Bank bag slots starting at PLAYER_FIELD_BANKBAG_SLOT_1
+        if (bankBagBase != 0xFFFF && key >= static_cast<uint16_t>(bankBagBase) &&
+            key <= static_cast<uint16_t>(bankBagBase) + (effectiveBankBagSlots_ * 2 - 1)) {
+            int slotIndex = (key - bankBagBase) / 2;
+            bool isLow = ((key - bankBagBase) % 2 == 0);
+            if (slotIndex < static_cast<int>(bankBagSlotGuids_.size())) {
+                uint64_t& guid = bankBagSlotGuids_[slotIndex];
+                if (isLow) guid = (guid & 0xFFFFFFFF00000000ULL) | val;
+                else guid = (guid & 0x00000000FFFFFFFFULL) | (uint64_t(val) << 32);
+                slotsChanged = true;
+            }
+        }
+    }
+
+    return slotsChanged;
 }
 
 void GameHandler::extractContainerFields(uint64_t containerGuid, const std::map<uint16_t, uint32_t>& fields) {
-    if (inventoryHandler_) inventoryHandler_->extractContainerFields(containerGuid, fields);
+    const uint16_t numSlotsIdx = fieldIndex(UF::CONTAINER_FIELD_NUM_SLOTS);
+    const uint16_t slot1Idx = fieldIndex(UF::CONTAINER_FIELD_SLOT_1);
+    if (numSlotsIdx == 0xFFFF || slot1Idx == 0xFFFF) return;
+
+    auto& info = containerContents_[containerGuid];
+
+    // Read number of slots
+    auto numIt = fields.find(numSlotsIdx);
+    if (numIt != fields.end()) {
+        info.numSlots = std::min(numIt->second, 36u);
+    }
+
+    // Read slot GUIDs (each is 2 uint32 fields: lo + hi)
+    for (const auto& [key, val] : fields) {
+        if (key < slot1Idx) continue;
+        int offset = key - slot1Idx;
+        int slotIndex = offset / 2;
+        if (slotIndex >= 36) continue;
+        bool isLow = (offset % 2 == 0);
+        uint64_t& guid = info.slotGuids[slotIndex];
+        if (isLow) guid = (guid & 0xFFFFFFFF00000000ULL) | val;
+        else guid = (guid & 0x00000000FFFFFFFFULL) | (uint64_t(val) << 32);
+    }
 }
 
 void GameHandler::rebuildOnlineInventory() {
-    if (inventoryHandler_) inventoryHandler_->rebuildOnlineInventory();
+
+    uint8_t savedBankBagSlots = inventory.getPurchasedBankBagSlots();
+    inventory = Inventory();
+    inventory.setPurchasedBankBagSlots(savedBankBagSlots);
+
+    // Equipment slots
+    for (int i = 0; i < 23; i++) {
+        uint64_t guid = equipSlotGuids_[i];
+        if (guid == 0) continue;
+
+        auto itemIt = onlineItems_.find(guid);
+        if (itemIt == onlineItems_.end()) continue;
+
+        ItemDef def;
+        def.itemId = itemIt->second.entry;
+        def.stackCount = itemIt->second.stackCount;
+        def.maxStack = 1;
+
+        auto infoIt = itemInfoCache_.find(itemIt->second.entry);
+        if (infoIt != itemInfoCache_.end()) {
+            def.name = infoIt->second.name;
+            def.quality = static_cast<ItemQuality>(infoIt->second.quality);
+            def.inventoryType = infoIt->second.inventoryType;
+            def.maxStack = std::max(1, infoIt->second.maxStack);
+            def.displayInfoId = infoIt->second.displayInfoId;
+            def.subclassName = infoIt->second.subclassName;
+            def.damageMin = infoIt->second.damageMin;
+            def.damageMax = infoIt->second.damageMax;
+            def.delayMs = infoIt->second.delayMs;
+            def.armor = infoIt->second.armor;
+            def.stamina = infoIt->second.stamina;
+            def.strength = infoIt->second.strength;
+            def.agility = infoIt->second.agility;
+            def.intellect = infoIt->second.intellect;
+            def.spirit = infoIt->second.spirit;
+        } else {
+            def.name = "Item " + std::to_string(def.itemId);
+            queryItemInfo(def.itemId, guid);
+        }
+
+        inventory.setEquipSlot(static_cast<EquipSlot>(i), def);
+    }
+
+    // Backpack slots
+    for (int i = 0; i < 16; i++) {
+        uint64_t guid = backpackSlotGuids_[i];
+        if (guid == 0) continue;
+
+        auto itemIt = onlineItems_.find(guid);
+        if (itemIt == onlineItems_.end()) continue;
+
+        ItemDef def;
+        def.itemId = itemIt->second.entry;
+        def.stackCount = itemIt->second.stackCount;
+        def.maxStack = 1;
+
+        auto infoIt = itemInfoCache_.find(itemIt->second.entry);
+        if (infoIt != itemInfoCache_.end()) {
+            def.name = infoIt->second.name;
+            def.quality = static_cast<ItemQuality>(infoIt->second.quality);
+            def.inventoryType = infoIt->second.inventoryType;
+            def.maxStack = std::max(1, infoIt->second.maxStack);
+            def.displayInfoId = infoIt->second.displayInfoId;
+            def.subclassName = infoIt->second.subclassName;
+            def.damageMin = infoIt->second.damageMin;
+            def.damageMax = infoIt->second.damageMax;
+            def.delayMs = infoIt->second.delayMs;
+            def.armor = infoIt->second.armor;
+            def.stamina = infoIt->second.stamina;
+            def.strength = infoIt->second.strength;
+            def.agility = infoIt->second.agility;
+            def.intellect = infoIt->second.intellect;
+            def.spirit = infoIt->second.spirit;
+        } else {
+            def.name = "Item " + std::to_string(def.itemId);
+            queryItemInfo(def.itemId, guid);
+        }
+
+        inventory.setBackpackSlot(i, def);
+    }
+
+    // Bag contents (BAG1-BAG4 are equip slots 19-22)
+    for (int bagIdx = 0; bagIdx < 4; bagIdx++) {
+        uint64_t bagGuid = equipSlotGuids_[19 + bagIdx];
+        if (bagGuid == 0) continue;
+
+        // Determine bag size from container fields or item template
+        int numSlots = 0;
+        auto contIt = containerContents_.find(bagGuid);
+        if (contIt != containerContents_.end()) {
+            numSlots = static_cast<int>(contIt->second.numSlots);
+        }
+        if (numSlots <= 0) {
+            auto bagItemIt = onlineItems_.find(bagGuid);
+            if (bagItemIt != onlineItems_.end()) {
+                auto bagInfoIt = itemInfoCache_.find(bagItemIt->second.entry);
+                if (bagInfoIt != itemInfoCache_.end()) {
+                    numSlots = bagInfoIt->second.containerSlots;
+                }
+            }
+        }
+        if (numSlots <= 0) continue;
+
+        // Set the bag size in the inventory bag data
+        inventory.setBagSize(bagIdx, numSlots);
+
+        // Also set bagSlots on the equipped bag item (for UI display)
+        auto& bagEquipSlot = inventory.getEquipSlot(static_cast<EquipSlot>(19 + bagIdx));
+        if (!bagEquipSlot.empty()) {
+            ItemDef bagDef = bagEquipSlot.item;
+            bagDef.bagSlots = numSlots;
+            inventory.setEquipSlot(static_cast<EquipSlot>(19 + bagIdx), bagDef);
+        }
+
+        // Populate bag slot items
+        if (contIt == containerContents_.end()) continue;
+        const auto& container = contIt->second;
+        for (int s = 0; s < numSlots && s < 36; s++) {
+            uint64_t itemGuid = container.slotGuids[s];
+            if (itemGuid == 0) continue;
+
+            auto itemIt = onlineItems_.find(itemGuid);
+            if (itemIt == onlineItems_.end()) continue;
+
+            ItemDef def;
+            def.itemId = itemIt->second.entry;
+            def.stackCount = itemIt->second.stackCount;
+            def.maxStack = 1;
+
+            auto infoIt = itemInfoCache_.find(itemIt->second.entry);
+            if (infoIt != itemInfoCache_.end()) {
+                def.name = infoIt->second.name;
+                def.quality = static_cast<ItemQuality>(infoIt->second.quality);
+                def.inventoryType = infoIt->second.inventoryType;
+                def.maxStack = std::max(1, infoIt->second.maxStack);
+                def.displayInfoId = infoIt->second.displayInfoId;
+                def.subclassName = infoIt->second.subclassName;
+                def.damageMin = infoIt->second.damageMin;
+                def.damageMax = infoIt->second.damageMax;
+                def.delayMs = infoIt->second.delayMs;
+                def.armor = infoIt->second.armor;
+                def.stamina = infoIt->second.stamina;
+                def.strength = infoIt->second.strength;
+                def.agility = infoIt->second.agility;
+                def.intellect = infoIt->second.intellect;
+                def.spirit = infoIt->second.spirit;
+                def.bagSlots = infoIt->second.containerSlots;
+            } else {
+                def.name = "Item " + std::to_string(def.itemId);
+                queryItemInfo(def.itemId, itemGuid);
+            }
+
+            inventory.setBagSlot(bagIdx, s, def);
+        }
+    }
+
+    // Bank slots (24 for Classic, 28 for TBC/WotLK)
+    for (int i = 0; i < effectiveBankSlots_; i++) {
+        uint64_t guid = bankSlotGuids_[i];
+        if (guid == 0) { inventory.clearBankSlot(i); continue; }
+
+        auto itemIt = onlineItems_.find(guid);
+        if (itemIt == onlineItems_.end()) { inventory.clearBankSlot(i); continue; }
+
+        ItemDef def;
+        def.itemId = itemIt->second.entry;
+        def.stackCount = itemIt->second.stackCount;
+        def.maxStack = 1;
+
+        auto infoIt = itemInfoCache_.find(itemIt->second.entry);
+        if (infoIt != itemInfoCache_.end()) {
+            def.name = infoIt->second.name;
+            def.quality = static_cast<ItemQuality>(infoIt->second.quality);
+            def.inventoryType = infoIt->second.inventoryType;
+            def.maxStack = std::max(1, infoIt->second.maxStack);
+            def.displayInfoId = infoIt->second.displayInfoId;
+            def.subclassName = infoIt->second.subclassName;
+            def.damageMin = infoIt->second.damageMin;
+            def.damageMax = infoIt->second.damageMax;
+            def.delayMs = infoIt->second.delayMs;
+            def.armor = infoIt->second.armor;
+            def.stamina = infoIt->second.stamina;
+            def.strength = infoIt->second.strength;
+            def.agility = infoIt->second.agility;
+            def.intellect = infoIt->second.intellect;
+            def.spirit = infoIt->second.spirit;
+            def.sellPrice = infoIt->second.sellPrice;
+            def.bagSlots = infoIt->second.containerSlots;
+        } else {
+            def.name = "Item " + std::to_string(def.itemId);
+            queryItemInfo(def.itemId, guid);
+        }
+
+        inventory.setBankSlot(i, def);
+    }
+
+    // Bank bag contents (6 for Classic, 7 for TBC/WotLK)
+    for (int bagIdx = 0; bagIdx < effectiveBankBagSlots_; bagIdx++) {
+        uint64_t bagGuid = bankBagSlotGuids_[bagIdx];
+        if (bagGuid == 0) { inventory.setBankBagSize(bagIdx, 0); continue; }
+
+        int numSlots = 0;
+        auto contIt = containerContents_.find(bagGuid);
+        if (contIt != containerContents_.end()) {
+            numSlots = static_cast<int>(contIt->second.numSlots);
+        }
+
+        // Populate the bag item itself (for icon/name in the bank bag equip slot)
+        auto bagItemIt = onlineItems_.find(bagGuid);
+        if (bagItemIt != onlineItems_.end()) {
+            if (numSlots <= 0) {
+                auto bagInfoIt = itemInfoCache_.find(bagItemIt->second.entry);
+                if (bagInfoIt != itemInfoCache_.end()) {
+                    numSlots = bagInfoIt->second.containerSlots;
+                }
+            }
+            ItemDef bagDef;
+            bagDef.itemId = bagItemIt->second.entry;
+            bagDef.stackCount = 1;
+            bagDef.inventoryType = 18; // bag
+            auto bagInfoIt = itemInfoCache_.find(bagItemIt->second.entry);
+            if (bagInfoIt != itemInfoCache_.end()) {
+                bagDef.name = bagInfoIt->second.name;
+                bagDef.quality = static_cast<ItemQuality>(bagInfoIt->second.quality);
+                bagDef.displayInfoId = bagInfoIt->second.displayInfoId;
+                bagDef.bagSlots = bagInfoIt->second.containerSlots;
+            } else {
+                bagDef.name = "Bag";
+                queryItemInfo(bagDef.itemId, bagGuid);
+            }
+            inventory.setBankBagItem(bagIdx, bagDef);
+        }
+        if (numSlots <= 0) continue;
+
+        inventory.setBankBagSize(bagIdx, numSlots);
+
+        if (contIt == containerContents_.end()) continue;
+        const auto& container = contIt->second;
+        for (int s = 0; s < numSlots && s < 36; s++) {
+            uint64_t itemGuid = container.slotGuids[s];
+            if (itemGuid == 0) continue;
+
+            auto itemIt = onlineItems_.find(itemGuid);
+            if (itemIt == onlineItems_.end()) continue;
+
+            ItemDef def;
+            def.itemId = itemIt->second.entry;
+            def.stackCount = itemIt->second.stackCount;
+            def.maxStack = 1;
+
+            auto infoIt = itemInfoCache_.find(itemIt->second.entry);
+            if (infoIt != itemInfoCache_.end()) {
+                def.name = infoIt->second.name;
+                def.quality = static_cast<ItemQuality>(infoIt->second.quality);
+                def.inventoryType = infoIt->second.inventoryType;
+                def.maxStack = std::max(1, infoIt->second.maxStack);
+                def.displayInfoId = infoIt->second.displayInfoId;
+                def.subclassName = infoIt->second.subclassName;
+                def.damageMin = infoIt->second.damageMin;
+                def.damageMax = infoIt->second.damageMax;
+                def.delayMs = infoIt->second.delayMs;
+                def.armor = infoIt->second.armor;
+                def.stamina = infoIt->second.stamina;
+                def.strength = infoIt->second.strength;
+                def.agility = infoIt->second.agility;
+                def.intellect = infoIt->second.intellect;
+                def.spirit = infoIt->second.spirit;
+                def.sellPrice = infoIt->second.sellPrice;
+                def.bagSlots = infoIt->second.containerSlots;
+            } else {
+                def.name = "Item " + std::to_string(def.itemId);
+                queryItemInfo(def.itemId, itemGuid);
+            }
+
+            inventory.setBankBagSlot(bagIdx, s, def);
+        }
+    }
+
+    // Only mark equipment dirty if equipped item displayInfoIds actually changed
+    std::array<uint32_t, 19> currentEquipDisplayIds{};
+    for (int i = 0; i < 19; i++) {
+        const auto& slot = inventory.getEquipSlot(static_cast<EquipSlot>(i));
+        if (!slot.empty()) currentEquipDisplayIds[i] = slot.item.displayInfoId;
+    }
+    if (currentEquipDisplayIds != lastEquipDisplayIds_) {
+        lastEquipDisplayIds_ = currentEquipDisplayIds;
+        onlineEquipDirty_ = true;
+    }
+
+    LOG_DEBUG("Rebuilt online inventory: equip=", [&](){
+        int c = 0; for (auto g : equipSlotGuids_) if (g) c++; return c;
+    }(), " backpack=", [&](){
+        int c = 0; for (auto g : backpackSlotGuids_) if (g) c++; return c;
+    }());
 }
 
 void GameHandler::maybeDetectVisibleItemLayout() {
-    if (inventoryHandler_) inventoryHandler_->maybeDetectVisibleItemLayout();
+    if (visibleItemLayoutVerified_) return;
+    if (lastPlayerFields_.empty()) return;
+
+    std::array<uint32_t, 19> equipEntries{};
+    int nonZero = 0;
+    // Prefer authoritative equipped item entry IDs derived from item objects (onlineItems_),
+    // because Inventory::ItemDef may not be populated yet if templates haven't been queried.
+    for (int i = 0; i < 19; i++) {
+        uint64_t itemGuid = equipSlotGuids_[i];
+        if (itemGuid != 0) {
+            auto it = onlineItems_.find(itemGuid);
+            if (it != onlineItems_.end() && it->second.entry != 0) {
+                equipEntries[i] = it->second.entry;
+            }
+        }
+        if (equipEntries[i] == 0) {
+            const auto& slot = inventory.getEquipSlot(static_cast<EquipSlot>(i));
+            equipEntries[i] = slot.empty() ? 0u : slot.item.itemId;
+        }
+        if (equipEntries[i] != 0) nonZero++;
+    }
+    if (nonZero < 2) return;
+
+    const uint16_t maxKey = lastPlayerFields_.rbegin()->first;
+    int bestBase = -1;
+    int bestStride = 0;
+    int bestMatches = 0;
+    int bestMismatches = 9999;
+    int bestScore = -999999;
+
+    const int strides[] = {2, 3, 4, 1};
+    for (int stride : strides) {
+        for (const auto& [baseIdxU16, _v] : lastPlayerFields_) {
+            const int base = static_cast<int>(baseIdxU16);
+            if (base + 18 * stride > static_cast<int>(maxKey)) continue;
+
+            int matches = 0;
+            int mismatches = 0;
+            for (int s = 0; s < 19; s++) {
+                uint32_t want = equipEntries[s];
+                if (want == 0) continue;
+                const uint16_t idx = static_cast<uint16_t>(base + s * stride);
+                auto it = lastPlayerFields_.find(idx);
+                if (it == lastPlayerFields_.end()) continue;
+                if (it->second == want) {
+                    matches++;
+                } else if (it->second != 0) {
+                    mismatches++;
+                }
+            }
+
+            int score = matches * 2 - mismatches * 3;
+            if (score > bestScore ||
+                (score == bestScore && matches > bestMatches) ||
+                (score == bestScore && matches == bestMatches && mismatches < bestMismatches) ||
+                (score == bestScore && matches == bestMatches && mismatches == bestMismatches && base < bestBase)) {
+                bestScore = score;
+                bestMatches = matches;
+                bestMismatches = mismatches;
+                bestBase = base;
+                bestStride = stride;
+            }
+        }
+    }
+
+    if (bestMatches >= 2 && bestBase >= 0 && bestStride > 0 && bestMismatches <= 1) {
+        visibleItemEntryBase_ = bestBase;
+        visibleItemStride_ = bestStride;
+        visibleItemLayoutVerified_ = true;
+        LOG_INFO("Detected PLAYER_VISIBLE_ITEM entry layout: base=", visibleItemEntryBase_,
+                 " stride=", visibleItemStride_, " (matches=", bestMatches,
+                 " mismatches=", bestMismatches, " score=", bestScore, ")");
+
+        // Backfill existing player entities already in view.
+        for (const auto& [guid, ent] : entityManager.getEntities()) {
+            if (!ent || ent->getType() != ObjectType::PLAYER) continue;
+            if (guid == playerGuid) continue;
+            updateOtherPlayerVisibleItems(guid, ent->getFields());
+        }
+    }
+    // If heuristic didn't find a match, keep using the default WotLK layout (base=284, stride=2).
 }
 
 void GameHandler::updateOtherPlayerVisibleItems(uint64_t guid, const std::map<uint16_t, uint32_t>& fields) {
-    if (inventoryHandler_) inventoryHandler_->updateOtherPlayerVisibleItems(guid, fields);
+    if (guid == 0 || guid == playerGuid) return;
+    if (visibleItemEntryBase_ < 0 || visibleItemStride_ <= 0) {
+        // Layout not detected yet — queue this player for inspect as fallback.
+        if (socket && state == WorldState::IN_WORLD) {
+            pendingAutoInspect_.insert(guid);
+            LOG_DEBUG("Queued player 0x", std::hex, guid, std::dec, " for auto-inspect (layout not detected)");
+        }
+        return;
+    }
+
+    std::array<uint32_t, 19> newEntries{};
+    for (int s = 0; s < 19; s++) {
+        uint16_t idx = static_cast<uint16_t>(visibleItemEntryBase_ + s * visibleItemStride_);
+        auto it = fields.find(idx);
+        if (it != fields.end()) newEntries[s] = it->second;
+    }
+
+    bool changed = false;
+    auto& old = otherPlayerVisibleItemEntries_[guid];
+    if (old != newEntries) {
+        old = newEntries;
+        changed = true;
+    }
+
+    // Request item templates for any new visible entries.
+    for (uint32_t entry : newEntries) {
+        if (entry == 0) continue;
+        if (!itemInfoCache_.count(entry) && !pendingItemQueries_.count(entry)) {
+            queryItemInfo(entry, 0);
+        }
+    }
+
+    // If the server isn't sending visible item fields (all zeros), fall back to inspect.
+    bool any = false;
+    for (uint32_t e : newEntries) { if (e != 0) { any = true; break; } }
+    if (!any && socket && state == WorldState::IN_WORLD) {
+        pendingAutoInspect_.insert(guid);
+    }
+
+    if (changed) {
+        otherPlayerVisibleDirty_.insert(guid);
+        emitOtherPlayerEquipment(guid);
+    }
 }
 
 void GameHandler::emitOtherPlayerEquipment(uint64_t guid) {
-    if (inventoryHandler_) inventoryHandler_->emitOtherPlayerEquipment(guid);
+    if (!playerEquipmentCallback_) return;
+    auto it = otherPlayerVisibleItemEntries_.find(guid);
+    if (it == otherPlayerVisibleItemEntries_.end()) return;
+
+    std::array<uint32_t, 19> displayIds{};
+    std::array<uint8_t, 19> invTypes{};
+    bool anyEntry = false;
+
+    for (int s = 0; s < 19; s++) {
+        uint32_t entry = it->second[s];
+        if (entry == 0) continue;
+        anyEntry = true;
+        auto infoIt = itemInfoCache_.find(entry);
+        if (infoIt == itemInfoCache_.end()) continue;
+        displayIds[s] = infoIt->second.displayInfoId;
+        invTypes[s] = static_cast<uint8_t>(infoIt->second.inventoryType);
+    }
+
+    playerEquipmentCallback_(guid, displayIds, invTypes);
+    otherPlayerVisibleDirty_.erase(guid);
+
+    // If we had entries but couldn't resolve any templates, also try inspect as a fallback.
+    bool anyResolved = false;
+    for (uint32_t did : displayIds) { if (did != 0) { anyResolved = true; break; } }
+    if (anyEntry && !anyResolved) {
+        pendingAutoInspect_.insert(guid);
+    }
 }
 
 void GameHandler::emitAllOtherPlayerEquipment() {
-    if (inventoryHandler_) inventoryHandler_->emitAllOtherPlayerEquipment();
+    if (!playerEquipmentCallback_) return;
+    for (const auto& [guid, _] : otherPlayerVisibleItemEntries_) {
+        emitOtherPlayerEquipment(guid);
+    }
 }
 
 // ============================================================
-// Combat (delegated to CombatHandler)
+// Phase 2: Combat
 // ============================================================
 
 void GameHandler::startAutoAttack(uint64_t targetGuid) {
-    if (combatHandler_) combatHandler_->startAutoAttack(targetGuid);
+    // Can't attack yourself
+    if (targetGuid == playerGuid) return;
+    if (targetGuid == 0) return;
+
+    // Dismount when entering combat
+    if (isMounted()) {
+        dismount();
+    }
+
+    // Client-side melee range gate to avoid starting "swing forever" loops when
+    // target is already clearly out of range.
+    if (auto target = entityManager.getEntity(targetGuid)) {
+        float dx = movementInfo.x - target->getLatestX();
+        float dy = movementInfo.y - target->getLatestY();
+        float dz = movementInfo.z - target->getLatestZ();
+        float dist3d = std::sqrt(dx * dx + dy * dy + dz * dz);
+        if (dist3d > 8.0f) {
+            if (autoAttackRangeWarnCooldown_ <= 0.0f) {
+                addSystemChatMessage("Target is too far away.");
+                autoAttackRangeWarnCooldown_ = 1.25f;
+            }
+            return;
+        }
+    }
+
+    autoAttackRequested_ = true;
+    // Keep combat animation/state server-authoritative. We only flip autoAttacking
+    // on SMSG_ATTACKSTART where attackerGuid == playerGuid.
+    autoAttacking = false;
+    autoAttackTarget = targetGuid;
+    autoAttackOutOfRange_ = false;
+    autoAttackOutOfRangeTime_ = 0.0f;
+    autoAttackResendTimer_ = 0.0f;
+    autoAttackFacingSyncTimer_ = 0.0f;
+    if (state == WorldState::IN_WORLD && socket) {
+        auto packet = AttackSwingPacket::build(targetGuid);
+        socket->send(packet);
+    }
+    LOG_INFO("Starting auto-attack on 0x", std::hex, targetGuid, std::dec);
 }
 
 void GameHandler::stopAutoAttack() {
-    if (combatHandler_) combatHandler_->stopAutoAttack();
+    if (!autoAttacking && !autoAttackRequested_) return;
+    autoAttackRequested_ = false;
+    autoAttacking = false;
+    autoAttackTarget = 0;
+    autoAttackOutOfRange_ = false;
+    autoAttackOutOfRangeTime_ = 0.0f;
+    autoAttackResendTimer_ = 0.0f;
+    autoAttackFacingSyncTimer_ = 0.0f;
+    if (state == WorldState::IN_WORLD && socket) {
+        auto packet = AttackStopPacket::build();
+        socket->send(packet);
+    }
+    LOG_INFO("Stopping auto-attack");
 }
 
-void GameHandler::addCombatText(CombatTextEntry::Type type, int32_t amount, uint32_t spellId, bool isPlayerSource, uint8_t powerType,
-                                uint64_t srcGuid, uint64_t dstGuid) {
-    if (combatHandler_) combatHandler_->addCombatText(type, amount, spellId, isPlayerSource, powerType, srcGuid, dstGuid);
-}
-
-bool GameHandler::shouldLogSpellstealAura(uint64_t casterGuid, uint64_t victimGuid, uint32_t spellId) {
-    return combatHandler_ ? combatHandler_->shouldLogSpellstealAura(casterGuid, victimGuid, spellId) : false;
+void GameHandler::addCombatText(CombatTextEntry::Type type, int32_t amount, uint32_t spellId, bool isPlayerSource) {
+    CombatTextEntry entry;
+    entry.type = type;
+    entry.amount = amount;
+    entry.spellId = spellId;
+    entry.age = 0.0f;
+    entry.isPlayerSource = isPlayerSource;
+    combatText.push_back(entry);
 }
 
 void GameHandler::updateCombatText(float deltaTime) {
-    if (combatHandler_) combatHandler_->updateCombatText(deltaTime);
+    for (auto& entry : combatText) {
+        entry.age += deltaTime;
+    }
+    combatText.erase(
+        std::remove_if(combatText.begin(), combatText.end(),
+                       [](const CombatTextEntry& e) { return e.isExpired(); }),
+        combatText.end());
 }
 
-bool GameHandler::isAutoAttacking() const {
-    return combatHandler_ ? combatHandler_->isAutoAttacking() : false;
+void GameHandler::autoTargetAttacker(uint64_t attackerGuid) {
+    if (attackerGuid == 0 || attackerGuid == playerGuid) return;
+    if (targetGuid != 0) return;
+    if (!entityManager.hasEntity(attackerGuid)) return;
+    setTarget(attackerGuid);
 }
 
-bool GameHandler::hasAutoAttackIntent() const {
-    return combatHandler_ ? combatHandler_->hasAutoAttackIntent() : false;
+void GameHandler::handleAttackStart(network::Packet& packet) {
+    AttackStartData data;
+    if (!AttackStartParser::parse(packet, data)) return;
+
+    if (data.attackerGuid == playerGuid) {
+        autoAttackRequested_ = true;
+        autoAttacking = true;
+        autoAttackTarget = data.victimGuid;
+    } else if (data.victimGuid == playerGuid && data.attackerGuid != 0) {
+        hostileAttackers_.insert(data.attackerGuid);
+        autoTargetAttacker(data.attackerGuid);
+
+        // Play aggro sound when NPC attacks player
+        if (npcAggroCallback_) {
+            auto entity = entityManager.getEntity(data.attackerGuid);
+            if (entity && entity->getType() == ObjectType::UNIT) {
+                glm::vec3 pos(entity->getX(), entity->getY(), entity->getZ());
+                npcAggroCallback_(data.attackerGuid, pos);
+            }
+        }
+    }
+
+    // Force both participants to face each other at combat start.
+    // Uses atan2(-dy, dx): canonical orientation convention where the West/Y
+    // component is negated (renderYaw = orientation + 90°, model-forward = render+X).
+    auto attackerEnt = entityManager.getEntity(data.attackerGuid);
+    auto victimEnt   = entityManager.getEntity(data.victimGuid);
+    if (attackerEnt && victimEnt) {
+        float dx = victimEnt->getX() - attackerEnt->getX();
+        float dy = victimEnt->getY() - attackerEnt->getY();
+        if (std::abs(dx) > 0.01f || std::abs(dy) > 0.01f) {
+            attackerEnt->setOrientation(std::atan2(-dy,  dx));   // attacker → victim
+            victimEnt->setOrientation  (std::atan2( dy, -dx));   // victim   → attacker
+        }
+    }
 }
 
-bool GameHandler::isInCombat() const {
-    return combatHandler_ ? combatHandler_->isInCombat() : false;
-}
+void GameHandler::handleAttackStop(network::Packet& packet) {
+    AttackStopData data;
+    if (!AttackStopParser::parse(packet, data)) return;
 
-bool GameHandler::isInCombatWith(uint64_t guid) const {
-    return combatHandler_ ? combatHandler_->isInCombatWith(guid) : false;
-}
-
-uint64_t GameHandler::getAutoAttackTargetGuid() const {
-    return combatHandler_ ? combatHandler_->getAutoAttackTargetGuid() : 0;
-}
-
-bool GameHandler::isAggressiveTowardPlayer(uint64_t guid) const {
-    return combatHandler_ ? combatHandler_->isAggressiveTowardPlayer(guid) : false;
-}
-
-uint64_t GameHandler::getLastMeleeSwingMs() const {
-    return combatHandler_ ? combatHandler_->getLastMeleeSwingMs() : 0;
-}
-
-const std::vector<CombatTextEntry>& GameHandler::getCombatText() const {
-    static const std::vector<CombatTextEntry> empty;
-    return combatHandler_ ? combatHandler_->getCombatText() : empty;
-}
-
-const std::deque<CombatLogEntry>& GameHandler::getCombatLog() const {
-    static const std::deque<CombatLogEntry> empty;
-    return combatHandler_ ? combatHandler_->getCombatLog() : empty;
-}
-
-void GameHandler::clearCombatLog() {
-    if (combatHandler_) combatHandler_->clearCombatLog();
-}
-
-void GameHandler::clearCombatText() {
-    if (combatHandler_) combatHandler_->clearCombatText();
-}
-
-void GameHandler::clearHostileAttackers() {
-    if (combatHandler_) combatHandler_->clearHostileAttackers();
-}
-
-const std::vector<GameHandler::ThreatEntry>* GameHandler::getThreatList(uint64_t unitGuid) const {
-    return combatHandler_ ? combatHandler_->getThreatList(unitGuid) : nullptr;
-}
-
-const std::vector<GameHandler::ThreatEntry>* GameHandler::getTargetThreatList() const {
-    return targetGuid ? getThreatList(targetGuid) : nullptr;
-}
-
-bool GameHandler::isHostileAttacker(uint64_t guid) const {
-    return combatHandler_ ? combatHandler_->isHostileAttacker(guid) : false;
+    // Keep intent, but clear server-confirmed active state until ATTACKSTART resumes.
+    if (data.attackerGuid == playerGuid) {
+        autoAttacking = false;
+        LOG_DEBUG("SMSG_ATTACKSTOP received (keeping auto-attack intent)");
+        if (autoAttackRequested_ && autoAttackTarget != 0 && socket) {
+            // Classic-family servers may emit transient ATTACKSTOP when range/facing jitters.
+            // Reassert melee intent immediately instead of waiting for periodic resend.
+            auto pkt = AttackSwingPacket::build(autoAttackTarget);
+            socket->send(pkt);
+        }
+    } else if (data.victimGuid == playerGuid) {
+        hostileAttackers_.erase(data.attackerGuid);
+    }
 }
 
 void GameHandler::dismount() {
-    if (movementHandler_) movementHandler_->dismount();
+    if (!socket) return;
+    // Clear local mount state immediately (optimistic dismount).
+    // Server will confirm via SMSG_UPDATE_OBJECT with mountDisplayId=0.
+    uint32_t savedMountAura = mountAuraSpellId_;
+    if (currentMountDisplayId_ != 0 || taxiMountActive_) {
+        if (mountCallback_) {
+            mountCallback_(0);
+        }
+        currentMountDisplayId_ = 0;
+        taxiMountActive_ = false;
+        taxiMountDisplayId_ = 0;
+        mountAuraSpellId_ = 0;
+        LOG_INFO("Dismount: cleared local mount state");
+    }
+    // CMSG_CANCEL_MOUNT_AURA exists in TBC+ (0x0375). Classic/Vanilla doesn't have it.
+    uint16_t cancelMountWire = wireOpcode(Opcode::CMSG_CANCEL_MOUNT_AURA);
+    if (cancelMountWire != 0xFFFF) {
+        network::Packet pkt(cancelMountWire);
+        socket->send(pkt);
+        LOG_INFO("Sent CMSG_CANCEL_MOUNT_AURA");
+    } else if (savedMountAura != 0) {
+        // Fallback for Classic/Vanilla: cancel the mount aura by spell ID
+        auto pkt = CancelAuraPacket::build(savedMountAura);
+        socket->send(pkt);
+        LOG_INFO("Sent CMSG_CANCEL_AURA (mount spell ", savedMountAura, ") — Classic fallback");
+    } else {
+        // No tracked mount aura — try cancelling all indefinite self-cast auras
+        // (mount aura detection may have missed if aura arrived after mount field)
+        for (const auto& a : playerAuras) {
+            if (!a.isEmpty() && a.maxDurationMs < 0 && a.casterGuid == playerGuid) {
+                auto pkt = CancelAuraPacket::build(a.spellId);
+                socket->send(pkt);
+                LOG_INFO("Sent CMSG_CANCEL_AURA (spell ", a.spellId, ") — brute force dismount");
+            }
+        }
+    }
+}
+
+void GameHandler::handleForceSpeedChange(network::Packet& packet, const char* name,
+                                          Opcode ackOpcode, float* speedStorage) {
+    // Packed GUID
+    uint64_t guid = UpdateObjectParser::readPackedGuid(packet);
+    // uint32 counter
+    uint32_t counter = packet.readUInt32();
+
+    // Determine format from remaining bytes:
+    //   5 bytes remaining = uint8(1) + float(4)  — standard 3.3.5a
+    //   8 bytes remaining = uint32(4) + float(4) — some forks
+    //   4 bytes remaining = float(4)             — no unknown field
+    size_t remaining = packet.getSize() - packet.getReadPos();
+    if (remaining >= 8) {
+        packet.readUInt32();  // unknown (extended format)
+    } else if (remaining >= 5) {
+        packet.readUInt8();   // unknown (standard 3.3.5a)
+    }
+    // float newSpeed
+    float newSpeed = packet.readFloat();
+
+    LOG_INFO("SMSG_FORCE_", name, "_CHANGE: guid=0x", std::hex, guid, std::dec,
+             " counter=", counter, " speed=", newSpeed);
+
+    if (guid != playerGuid) return;
+
+    // Always ACK the speed change to prevent server stall.
+    if (socket && !isClassicLikeExpansion()) {
+        network::Packet ack(wireOpcode(ackOpcode));
+        const bool legacyGuidAck =
+            isActiveExpansion("classic") || isActiveExpansion("tbc") || isActiveExpansion("turtle");
+        if (legacyGuidAck) {
+            ack.writeUInt64(playerGuid);
+        } else {
+            MovementPacket::writePackedGuid(ack, playerGuid);
+        }
+        ack.writeUInt32(counter);
+
+        MovementInfo wire = movementInfo;
+        wire.time = nextMovementTimestampMs();
+        if (wire.hasFlag(MovementFlags::ONTRANSPORT)) {
+            wire.transportTime = wire.time;
+            wire.transportTime2 = wire.time;
+        }
+        glm::vec3 serverPos = core::coords::canonicalToServer(glm::vec3(wire.x, wire.y, wire.z));
+        wire.x = serverPos.x;
+        wire.y = serverPos.y;
+        wire.z = serverPos.z;
+        if (wire.hasFlag(MovementFlags::ONTRANSPORT)) {
+            glm::vec3 serverTransport =
+                core::coords::canonicalToServer(glm::vec3(wire.transportX, wire.transportY, wire.transportZ));
+            wire.transportX = serverTransport.x;
+            wire.transportY = serverTransport.y;
+            wire.transportZ = serverTransport.z;
+        }
+        if (packetParsers_) {
+            packetParsers_->writeMovementPayload(ack, wire);
+        } else {
+            MovementPacket::writeMovementPayload(ack, wire);
+        }
+
+        ack.writeFloat(newSpeed);
+        socket->send(ack);
+    }
+
+    // Validate speed - reject garbage/NaN values but still ACK
+    if (std::isnan(newSpeed) || newSpeed < 0.1f || newSpeed > 100.0f) {
+        LOG_WARNING("Ignoring invalid ", name, " speed: ", newSpeed);
+        return;
+    }
+
+    if (speedStorage) *speedStorage = newSpeed;
+}
+
+void GameHandler::handleForceRunSpeedChange(network::Packet& packet) {
+    handleForceSpeedChange(packet, "RUN_SPEED", Opcode::CMSG_FORCE_RUN_SPEED_CHANGE_ACK, &serverRunSpeed_);
+
+    // Server can auto-dismount (e.g. entering no-mount areas) and only send a speed change.
+    // Keep client mount visuals in sync with server-authoritative movement speed.
+    if (!onTaxiFlight_ && !taxiMountActive_ && currentMountDisplayId_ != 0 && serverRunSpeed_ <= 8.5f) {
+        LOG_INFO("Auto-clearing mount from speed change: speed=", serverRunSpeed_,
+                 " displayId=", currentMountDisplayId_);
+        currentMountDisplayId_ = 0;
+        if (mountCallback_) {
+            mountCallback_(0);
+        }
+    }
+}
+
+void GameHandler::handleForceMoveRootState(network::Packet& packet, bool rooted) {
+    // Packet is server movement control update:
+    // packedGuid + uint32 counter + [optional unknown field(s)].
+    // We always ACK with current movement state, same pattern as speed-change ACKs.
+    if (packet.getSize() - packet.getReadPos() < 2) return;
+    uint64_t guid = UpdateObjectParser::readPackedGuid(packet);
+    if (packet.getSize() - packet.getReadPos() < 4) return;
+    uint32_t counter = packet.readUInt32();
+
+    LOG_INFO(rooted ? "SMSG_FORCE_MOVE_ROOT" : "SMSG_FORCE_MOVE_UNROOT",
+             ": guid=0x", std::hex, guid, std::dec, " counter=", counter);
+
+    if (guid != playerGuid) return;
+
+    // Keep local movement flags aligned with server authoritative root state.
+    if (rooted) {
+        movementInfo.flags |= static_cast<uint32_t>(MovementFlags::ROOT);
+    } else {
+        movementInfo.flags &= ~static_cast<uint32_t>(MovementFlags::ROOT);
+    }
+
+    if (!socket || isClassicLikeExpansion()) return;
+    uint16_t ackWire = wireOpcode(rooted ? Opcode::CMSG_FORCE_MOVE_ROOT_ACK
+                                         : Opcode::CMSG_FORCE_MOVE_UNROOT_ACK);
+    if (ackWire == 0xFFFF) return;
+
+    network::Packet ack(ackWire);
+    const bool legacyGuidAck =
+        isActiveExpansion("classic") || isActiveExpansion("tbc") || isActiveExpansion("turtle");
+    if (legacyGuidAck) {
+        ack.writeUInt64(playerGuid);  // CMaNGOS expects full GUID for root/unroot ACKs
+    } else {
+        MovementPacket::writePackedGuid(ack, playerGuid);
+    }
+    ack.writeUInt32(counter);
+
+    MovementInfo wire = movementInfo;
+    wire.time = nextMovementTimestampMs();
+    if (wire.hasFlag(MovementFlags::ONTRANSPORT)) {
+        wire.transportTime = wire.time;
+        wire.transportTime2 = wire.time;
+    }
+    glm::vec3 serverPos = core::coords::canonicalToServer(glm::vec3(wire.x, wire.y, wire.z));
+    wire.x = serverPos.x;
+    wire.y = serverPos.y;
+    wire.z = serverPos.z;
+    if (wire.hasFlag(MovementFlags::ONTRANSPORT)) {
+        glm::vec3 serverTransport =
+            core::coords::canonicalToServer(glm::vec3(wire.transportX, wire.transportY, wire.transportZ));
+        wire.transportX = serverTransport.x;
+        wire.transportY = serverTransport.y;
+        wire.transportZ = serverTransport.z;
+    }
+    if (packetParsers_) packetParsers_->writeMovementPayload(ack, wire);
+    else MovementPacket::writeMovementPayload(ack, wire);
+
+    socket->send(ack);
+}
+
+void GameHandler::handleForceMoveFlagChange(network::Packet& packet, const char* name,
+                                             Opcode ackOpcode, uint32_t flag, bool set) {
+    if (packet.getSize() - packet.getReadPos() < 2) return;
+    uint64_t guid = UpdateObjectParser::readPackedGuid(packet);
+    if (packet.getSize() - packet.getReadPos() < 4) return;
+    uint32_t counter = packet.readUInt32();
+
+    LOG_INFO("SMSG_FORCE_", name, ": guid=0x", std::hex, guid, std::dec, " counter=", counter);
+
+    if (guid != playerGuid) return;
+
+    // Update local movement flags if a flag was specified
+    if (flag != 0) {
+        if (set) {
+            movementInfo.flags |= flag;
+        } else {
+            movementInfo.flags &= ~flag;
+        }
+    }
+
+    if (!socket || isClassicLikeExpansion()) return;
+    uint16_t ackWire = wireOpcode(ackOpcode);
+    if (ackWire == 0xFFFF) return;
+
+    network::Packet ack(ackWire);
+    const bool legacyGuidAck =
+        isActiveExpansion("classic") || isActiveExpansion("tbc") || isActiveExpansion("turtle");
+    if (legacyGuidAck) {
+        ack.writeUInt64(playerGuid);
+    } else {
+        MovementPacket::writePackedGuid(ack, playerGuid);
+    }
+    ack.writeUInt32(counter);
+
+    MovementInfo wire = movementInfo;
+    wire.time = nextMovementTimestampMs();
+    if (wire.hasFlag(MovementFlags::ONTRANSPORT)) {
+        wire.transportTime = wire.time;
+        wire.transportTime2 = wire.time;
+    }
+    glm::vec3 serverPos = core::coords::canonicalToServer(glm::vec3(wire.x, wire.y, wire.z));
+    wire.x = serverPos.x;
+    wire.y = serverPos.y;
+    wire.z = serverPos.z;
+    if (wire.hasFlag(MovementFlags::ONTRANSPORT)) {
+        glm::vec3 serverTransport =
+            core::coords::canonicalToServer(glm::vec3(wire.transportX, wire.transportY, wire.transportZ));
+        wire.transportX = serverTransport.x;
+        wire.transportY = serverTransport.y;
+        wire.transportZ = serverTransport.z;
+    }
+    if (packetParsers_) packetParsers_->writeMovementPayload(ack, wire);
+    else MovementPacket::writeMovementPayload(ack, wire);
+
+    socket->send(ack);
+}
+
+void GameHandler::handleMoveKnockBack(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 2) return;
+    uint64_t guid = UpdateObjectParser::readPackedGuid(packet);
+    if (packet.getSize() - packet.getReadPos() < 20) return;  // counter(4) + vcos(4) + vsin(4) + hspeed(4) + vspeed(4)
+    uint32_t counter = packet.readUInt32();
+    [[maybe_unused]] float vcos = packet.readFloat();
+    [[maybe_unused]] float vsin = packet.readFloat();
+    [[maybe_unused]] float hspeed = packet.readFloat();
+    [[maybe_unused]] float vspeed = packet.readFloat();
+
+    LOG_INFO("SMSG_MOVE_KNOCK_BACK: guid=0x", std::hex, guid, std::dec,
+             " counter=", counter, " hspeed=", hspeed, " vspeed=", vspeed);
+
+    if (guid != playerGuid) return;
+
+    if (!socket || isClassicLikeExpansion()) return;
+    uint16_t ackWire = wireOpcode(Opcode::CMSG_MOVE_KNOCK_BACK_ACK);
+    if (ackWire == 0xFFFF) return;
+
+    network::Packet ack(ackWire);
+    const bool legacyGuidAck =
+        isActiveExpansion("classic") || isActiveExpansion("tbc") || isActiveExpansion("turtle");
+    if (legacyGuidAck) {
+        ack.writeUInt64(playerGuid);
+    } else {
+        MovementPacket::writePackedGuid(ack, playerGuid);
+    }
+    ack.writeUInt32(counter);
+
+    MovementInfo wire = movementInfo;
+    wire.time = nextMovementTimestampMs();
+    if (wire.hasFlag(MovementFlags::ONTRANSPORT)) {
+        wire.transportTime = wire.time;
+        wire.transportTime2 = wire.time;
+    }
+    glm::vec3 serverPos = core::coords::canonicalToServer(glm::vec3(wire.x, wire.y, wire.z));
+    wire.x = serverPos.x;
+    wire.y = serverPos.y;
+    wire.z = serverPos.z;
+    if (wire.hasFlag(MovementFlags::ONTRANSPORT)) {
+        glm::vec3 serverTransport =
+            core::coords::canonicalToServer(glm::vec3(wire.transportX, wire.transportY, wire.transportZ));
+        wire.transportX = serverTransport.x;
+        wire.transportY = serverTransport.y;
+        wire.transportZ = serverTransport.z;
+    }
+    if (packetParsers_) packetParsers_->writeMovementPayload(ack, wire);
+    else MovementPacket::writeMovementPayload(ack, wire);
+
+    socket->send(ack);
 }
 
 // ============================================================
 // Arena / Battleground Handlers
 // ============================================================
 
-void GameHandler::declineBattlefield(uint32_t queueSlot) {
-    if (socialHandler_) socialHandler_->declineBattlefield(queueSlot);
+void GameHandler::handleBattlefieldStatus(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 4) return;
+    uint32_t queueSlot = packet.readUInt32();
+
+    // Minimal packet = just queueSlot + arenaType(1) when status is NONE
+    if (packet.getSize() - packet.getReadPos() < 1) {
+        LOG_INFO("Battlefield status: queue slot ", queueSlot, " cleared");
+        return;
+    }
+
+    uint8_t arenaType = packet.readUInt8();
+    if (packet.getSize() - packet.getReadPos() < 1) return;
+
+    // Unknown byte
+    packet.readUInt8();
+    if (packet.getSize() - packet.getReadPos() < 4) return;
+    uint32_t bgTypeId = packet.readUInt32();
+
+    if (packet.getSize() - packet.getReadPos() < 2) return;
+    uint16_t unk2 = packet.readUInt16();
+    (void)unk2;
+
+    if (packet.getSize() - packet.getReadPos() < 4) return;
+    uint32_t clientInstanceId = packet.readUInt32();
+    (void)clientInstanceId;
+
+    if (packet.getSize() - packet.getReadPos() < 1) return;
+    uint8_t isRatedArena = packet.readUInt8();
+    (void)isRatedArena;
+
+    if (packet.getSize() - packet.getReadPos() < 4) return;
+    uint32_t statusId = packet.readUInt32();
+
+    std::string bgName = "Battleground #" + std::to_string(bgTypeId);
+    if (arenaType > 0) {
+        bgName = std::to_string(arenaType) + "v" + std::to_string(arenaType) + " Arena";
+    }
+
+    // Store queue state
+    if (queueSlot < bgQueues_.size()) {
+        bgQueues_[queueSlot].queueSlot = queueSlot;
+        bgQueues_[queueSlot].bgTypeId = bgTypeId;
+        bgQueues_[queueSlot].arenaType = arenaType;
+        bgQueues_[queueSlot].statusId = statusId;
+    }
+
+    switch (statusId) {
+        case 0: // STATUS_NONE
+            LOG_INFO("Battlefield status: NONE for ", bgName);
+            break;
+        case 1: // STATUS_WAIT_QUEUE
+            addSystemChatMessage("Queued for " + bgName + ".");
+            LOG_INFO("Battlefield status: WAIT_QUEUE for ", bgName);
+            break;
+        case 2: // STATUS_WAIT_JOIN
+            addSystemChatMessage(bgName + " is ready! Type /join to enter.");
+            LOG_INFO("Battlefield status: WAIT_JOIN for ", bgName);
+            break;
+        case 3: // STATUS_IN_PROGRESS
+            addSystemChatMessage("Entered " + bgName + ".");
+            LOG_INFO("Battlefield status: IN_PROGRESS for ", bgName);
+            break;
+        case 4: // STATUS_WAIT_LEAVE
+            LOG_INFO("Battlefield status: WAIT_LEAVE for ", bgName);
+            break;
+        default:
+            LOG_INFO("Battlefield status: unknown (", statusId, ") for ", bgName);
+            break;
+    }
 }
 
 bool GameHandler::hasPendingBgInvite() const {
-    return socialHandler_ && socialHandler_->hasPendingBgInvite();
+    for (const auto& slot : bgQueues_) {
+        if (slot.statusId == 2) return true;  // STATUS_WAIT_JOIN
+    }
+    return false;
 }
 
 void GameHandler::acceptBattlefield(uint32_t queueSlot) {
-    if (socialHandler_) socialHandler_->acceptBattlefield(queueSlot);
+    if (state != WorldState::IN_WORLD) return;
+    if (!socket) return;
+
+    // Find first WAIT_JOIN slot if no specific slot given
+    const BgQueueSlot* slot = nullptr;
+    if (queueSlot == 0xFFFFFFFF) {
+        for (const auto& s : bgQueues_) {
+            if (s.statusId == 2) { slot = &s; break; }
+        }
+    } else if (queueSlot < bgQueues_.size() && bgQueues_[queueSlot].statusId == 2) {
+        slot = &bgQueues_[queueSlot];
+    }
+
+    if (!slot) {
+        addSystemChatMessage("No battleground invitation pending.");
+        return;
+    }
+
+    // CMSG_BATTLEFIELD_PORT: arenaType(1) + unk(1) + bgTypeId(4) + unk(2) + action(1) = 9 bytes
+    network::Packet pkt(wireOpcode(Opcode::CMSG_BATTLEFIELD_PORT));
+    pkt.writeUInt8(slot->arenaType);
+    pkt.writeUInt8(0x00);
+    pkt.writeUInt32(slot->bgTypeId);
+    pkt.writeUInt16(0x0000);
+    pkt.writeUInt8(1);  // 1 = accept, 0 = decline
+
+    socket->send(pkt);
+
+    addSystemChatMessage("Accepting battleground invitation...");
+    LOG_INFO("Sent CMSG_BATTLEFIELD_PORT: accept bgTypeId=", slot->bgTypeId);
+}
+
+void GameHandler::handleRaidInstanceInfo(network::Packet& packet) {
+    // SMSG_RAID_INSTANCE_INFO: uint32 count, then for each:
+    //   mapId(u32) + difficulty(u32) + resetTime(u64) + locked(u8) + extended(u8)
+    if (packet.getSize() - packet.getReadPos() < 4) return;
+    uint32_t count = packet.readUInt32();
+
+    instanceLockouts_.clear();
+    instanceLockouts_.reserve(count);
+
+    constexpr size_t kEntrySize = 4 + 4 + 8 + 1 + 1;
+    for (uint32_t i = 0; i < count; ++i) {
+        if (packet.getSize() - packet.getReadPos() < kEntrySize) break;
+        InstanceLockout lo;
+        lo.mapId      = packet.readUInt32();
+        lo.difficulty = packet.readUInt32();
+        lo.resetTime  = packet.readUInt64();
+        lo.locked     = packet.readUInt8() != 0;
+        lo.extended   = packet.readUInt8() != 0;
+        instanceLockouts_.push_back(lo);
+        LOG_INFO("Instance lockout: mapId=", lo.mapId, " diff=", lo.difficulty,
+                 " reset=", lo.resetTime, " locked=", lo.locked, " extended=", lo.extended);
+    }
+    LOG_INFO("SMSG_RAID_INSTANCE_INFO: ", instanceLockouts_.size(), " lockout(s)");
+}
+
+void GameHandler::handleInstanceDifficulty(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 8) return;
+    instanceDifficulty_ = packet.readUInt32();
+    uint32_t isHeroic = packet.readUInt32();
+    instanceIsHeroic_ = (isHeroic != 0);
+    LOG_INFO("Instance difficulty: ", instanceDifficulty_, " heroic=", instanceIsHeroic_);
 }
 
 // ---------------------------------------------------------------------------
 // LFG / Dungeon Finder handlers (WotLK 3.3.5a)
 // ---------------------------------------------------------------------------
 
+static const char* lfgJoinResultString(uint8_t result) {
+    switch (result) {
+        case 0:  return nullptr; // success
+        case 1:  return "Role check failed.";
+        case 2:  return "No LFG slots available for your group.";
+        case 3:  return "No LFG object found.";
+        case 4:  return "No slots available (player).";
+        case 5:  return "No slots available (party).";
+        case 6:  return "Dungeon requirements not met by all members.";
+        case 7:  return "Party members are from different realms.";
+        case 8:  return "Not all members are present.";
+        case 9:  return "Get info timeout.";
+        case 10: return "Invalid dungeon slot.";
+        case 11: return "You are marked as a deserter.";
+        case 12: return "A party member is marked as a deserter.";
+        case 13: return "You are on a random dungeon cooldown.";
+        case 14: return "A party member is on a random dungeon cooldown.";
+        case 16: return "No spec/role available.";
+        default: return "Cannot join dungeon finder.";
+    }
+}
+
+static const char* lfgTeleportDeniedString(uint8_t reason) {
+    switch (reason) {
+        case 0:  return "You are not in a LFG group.";
+        case 1:  return "You are not in the dungeon.";
+        case 2:  return "You have a summon pending.";
+        case 3:  return "You are dead.";
+        case 4:  return "You have Deserter.";
+        case 5:  return "You do not meet the requirements.";
+        default: return "Teleport to dungeon denied.";
+    }
+}
+
+void GameHandler::handleLfgJoinResult(network::Packet& packet) {
+    size_t remaining = packet.getSize() - packet.getReadPos();
+    if (remaining < 2) return;
+
+    uint8_t result = packet.readUInt8();
+    uint8_t state  = packet.readUInt8();
+
+    if (result == 0) {
+        // Success — state tells us what phase we're entering
+        lfgState_ = static_cast<LfgState>(state);
+        LOG_INFO("SMSG_LFG_JOIN_RESULT: success, state=", static_cast<int>(state));
+        addSystemChatMessage("Dungeon Finder: Joined the queue.");
+    } else {
+        const char* msg = lfgJoinResultString(result);
+        std::string errMsg = std::string("Dungeon Finder: ") + (msg ? msg : "Join failed.");
+        addSystemChatMessage(errMsg);
+        LOG_INFO("SMSG_LFG_JOIN_RESULT: result=", static_cast<int>(result),
+                 " state=", static_cast<int>(state));
+    }
+}
+
+void GameHandler::handleLfgQueueStatus(network::Packet& packet) {
+    size_t remaining = packet.getSize() - packet.getReadPos();
+    if (remaining < 4 + 6 * 4 + 1 + 4) return;  // dungeonId + 6 int32 + uint8 + uint32
+
+    lfgDungeonId_     = packet.readUInt32();
+    int32_t avgWait   = static_cast<int32_t>(packet.readUInt32());
+    int32_t waitTime  = static_cast<int32_t>(packet.readUInt32());
+    /*int32_t waitTimeTank   =*/ static_cast<int32_t>(packet.readUInt32());
+    /*int32_t waitTimeHealer =*/ static_cast<int32_t>(packet.readUInt32());
+    /*int32_t waitTimeDps    =*/ static_cast<int32_t>(packet.readUInt32());
+    /*uint8_t  queuedByNeeded=*/ packet.readUInt8();
+    lfgTimeInQueueMs_ = packet.readUInt32();
+
+    lfgAvgWaitSec_ = (waitTime >= 0) ? (waitTime / 1000) : (avgWait / 1000);
+    lfgState_ = LfgState::Queued;
+
+    LOG_INFO("SMSG_LFG_QUEUE_STATUS: dungeonId=", lfgDungeonId_,
+             " avgWait=", avgWait, "ms waitTime=", waitTime, "ms");
+}
+
+void GameHandler::handleLfgProposalUpdate(network::Packet& packet) {
+    size_t remaining = packet.getSize() - packet.getReadPos();
+    if (remaining < 16) return;
+
+    uint32_t dungeonId     = packet.readUInt32();
+    uint32_t proposalId    = packet.readUInt32();
+    uint32_t proposalState = packet.readUInt32();
+    /*uint32_t encounterMask =*/ packet.readUInt32();
+
+    if (remaining < 17) return;
+    /*bool canOverride =*/ packet.readUInt8();
+
+    lfgDungeonId_  = dungeonId;
+    lfgProposalId_ = proposalId;
+
+    switch (proposalState) {
+        case 0:
+            lfgState_      = LfgState::Queued;
+            lfgProposalId_ = 0;
+            addSystemChatMessage("Dungeon Finder: Group proposal failed.");
+            break;
+        case 1:
+            lfgState_      = LfgState::InDungeon;
+            lfgProposalId_ = 0;
+            addSystemChatMessage("Dungeon Finder: Group found! Entering dungeon...");
+            break;
+        case 2:
+            lfgState_ = LfgState::Proposal;
+            addSystemChatMessage("Dungeon Finder: A group has been found. Accept or decline.");
+            break;
+        default:
+            break;
+    }
+
+    LOG_INFO("SMSG_LFG_PROPOSAL_UPDATE: dungeonId=", dungeonId,
+             " proposalId=", proposalId, " state=", proposalState);
+}
+
+void GameHandler::handleLfgRoleCheckUpdate(network::Packet& packet) {
+    size_t remaining = packet.getSize() - packet.getReadPos();
+    if (remaining < 6) return;
+
+    /*uint32_t dungeonId =*/ packet.readUInt32();
+    uint8_t  roleCheckState = packet.readUInt8();
+    /*bool     isBeginning =*/ packet.readUInt8();
+
+    // roleCheckState: 0=default, 1=finished, 2=initializing, 3=missing_role, 4=wrong_dungeons
+    if (roleCheckState == 1) {
+        lfgState_ = LfgState::Queued;
+        LOG_INFO("LFG role check finished");
+    } else if (roleCheckState == 3) {
+        lfgState_ = LfgState::None;
+        addSystemChatMessage("Dungeon Finder: Role check failed — missing required role.");
+    } else if (roleCheckState == 2) {
+        lfgState_ = LfgState::RoleCheck;
+        addSystemChatMessage("Dungeon Finder: Performing role check...");
+    }
+
+    LOG_INFO("SMSG_LFG_ROLE_CHECK_UPDATE: roleCheckState=", static_cast<int>(roleCheckState));
+}
+
+void GameHandler::handleLfgUpdatePlayer(network::Packet& packet) {
+    // SMSG_LFG_UPDATE_PLAYER and SMSG_LFG_UPDATE_PARTY share the same layout.
+    size_t remaining = packet.getSize() - packet.getReadPos();
+    if (remaining < 1) return;
+
+    uint8_t updateType = packet.readUInt8();
+
+    // LFGUpdateType values that carry no extra payload
+    // 0=default, 1=leader_unk1, 4=rolecheck_aborted, 8=removed_from_queue,
+    // 9=proposal_failed, 10=proposal_declined, 15=leave_queue, 17=member_offline, 18=group_disband
+    bool hasExtra = (updateType != 0 && updateType != 1 && updateType != 15 &&
+                     updateType != 17 && updateType != 18);
+    if (!hasExtra || packet.getSize() - packet.getReadPos() < 3) {
+        switch (updateType) {
+            case 8:  lfgState_ = LfgState::None;
+                     addSystemChatMessage("Dungeon Finder: Removed from queue."); break;
+            case 9:  lfgState_ = LfgState::Queued;
+                     addSystemChatMessage("Dungeon Finder: Proposal failed — re-queuing."); break;
+            case 10: lfgState_ = LfgState::Queued;
+                     addSystemChatMessage("Dungeon Finder: A member declined the proposal."); break;
+            case 15: lfgState_ = LfgState::None;
+                     addSystemChatMessage("Dungeon Finder: Left the queue."); break;
+            case 18: lfgState_ = LfgState::None;
+                     addSystemChatMessage("Dungeon Finder: Your group disbanded."); break;
+            default: break;
+        }
+        LOG_INFO("SMSG_LFG_UPDATE_PLAYER/PARTY: updateType=", static_cast<int>(updateType));
+        return;
+    }
+
+    /*bool queued =*/ packet.readUInt8();
+    packet.readUInt8(); // unk1
+    packet.readUInt8(); // unk2
+
+    if (packet.getSize() - packet.getReadPos() >= 1) {
+        uint8_t count = packet.readUInt8();
+        for (uint8_t i = 0; i < count && packet.getSize() - packet.getReadPos() >= 4; ++i) {
+            uint32_t dungeonEntry = packet.readUInt32();
+            if (i == 0) lfgDungeonId_ = dungeonEntry;
+        }
+    }
+
+    switch (updateType) {
+        case 6:  lfgState_ = LfgState::Queued;
+                 addSystemChatMessage("Dungeon Finder: You have joined the queue."); break;
+        case 11: lfgState_ = LfgState::Proposal;
+                 addSystemChatMessage("Dungeon Finder: A group has been found!"); break;
+        case 12: lfgState_ = LfgState::Queued;
+                 addSystemChatMessage("Dungeon Finder: Added to queue."); break;
+        case 13: lfgState_ = LfgState::Proposal;
+                 addSystemChatMessage("Dungeon Finder: Proposal started."); break;
+        case 14: lfgState_ = LfgState::InDungeon; break;
+        case 16: addSystemChatMessage("Dungeon Finder: Two members are ready."); break;
+        default: break;
+    }
+    LOG_INFO("SMSG_LFG_UPDATE_PLAYER/PARTY: updateType=", static_cast<int>(updateType));
+}
+
+void GameHandler::handleLfgPlayerReward(network::Packet& packet) {
+    size_t remaining = packet.getSize() - packet.getReadPos();
+    if (remaining < 4 + 4 + 1 + 4 + 4 + 4) return;
+
+    /*uint32_t randomDungeonEntry =*/ packet.readUInt32();
+    /*uint32_t dungeonEntry       =*/ packet.readUInt32();
+    packet.readUInt8();  // unk
+    uint32_t money  = packet.readUInt32();
+    uint32_t xp     = packet.readUInt32();
+
+    std::string rewardMsg = "Dungeon Finder reward: " + std::to_string(money) + "g " +
+                            std::to_string(xp) + " XP";
+
+    if (packet.getSize() - packet.getReadPos() >= 4) {
+        uint32_t rewardCount = packet.readUInt32();
+        for (uint32_t i = 0; i < rewardCount && packet.getSize() - packet.getReadPos() >= 9; ++i) {
+            uint32_t itemId    = packet.readUInt32();
+            uint32_t itemCount = packet.readUInt32();
+            packet.readUInt8();  // unk
+            if (i == 0) {
+                rewardMsg += ", item #" + std::to_string(itemId);
+                if (itemCount > 1) rewardMsg += " x" + std::to_string(itemCount);
+            }
+        }
+    }
+
+    addSystemChatMessage(rewardMsg);
+    lfgState_ = LfgState::FinishedDungeon;
+    LOG_INFO("SMSG_LFG_PLAYER_REWARD: money=", money, " xp=", xp);
+}
+
+void GameHandler::handleLfgBootProposalUpdate(network::Packet& packet) {
+    size_t remaining = packet.getSize() - packet.getReadPos();
+    if (remaining < 7 + 4 + 4 + 4 + 4) return;
+
+    bool inProgress = packet.readUInt8() != 0;
+    bool myVote     = packet.readUInt8() != 0;
+    bool myAnswer   = packet.readUInt8() != 0;
+    uint32_t totalVotes  = packet.readUInt32();
+    uint32_t bootVotes   = packet.readUInt32();
+    uint32_t timeLeft    = packet.readUInt32();
+    uint32_t votesNeeded = packet.readUInt32();
+
+    (void)myVote; (void)totalVotes; (void)bootVotes; (void)timeLeft; (void)votesNeeded;
+
+    if (inProgress) {
+        addSystemChatMessage(
+            std::string("Dungeon Finder: Vote to kick in progress (") +
+            std::to_string(timeLeft) + "s remaining).");
+    } else if (myAnswer) {
+        addSystemChatMessage("Dungeon Finder: Vote kick passed — member removed.");
+    } else {
+        addSystemChatMessage("Dungeon Finder: Vote kick failed.");
+    }
+
+    LOG_INFO("SMSG_LFG_BOOT_PROPOSAL_UPDATE: inProgress=", inProgress,
+             " bootVotes=", bootVotes, "/", totalVotes);
+}
+
+void GameHandler::handleLfgTeleportDenied(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 1) return;
+    uint8_t reason = packet.readUInt8();
+    const char* msg = lfgTeleportDeniedString(reason);
+    addSystemChatMessage(std::string("Dungeon Finder: ") + msg);
+    LOG_INFO("SMSG_LFG_TELEPORT_DENIED: reason=", static_cast<int>(reason));
+}
+
 // ---------------------------------------------------------------------------
 // LFG outgoing packets
 // ---------------------------------------------------------------------------
 
 void GameHandler::lfgJoin(uint32_t dungeonId, uint8_t roles) {
-    if (socialHandler_) socialHandler_->lfgJoin(dungeonId, roles);
+    if (state != WorldState::IN_WORLD || !socket) return;
+
+    network::Packet pkt(wireOpcode(Opcode::CMSG_LFG_JOIN));
+    pkt.writeUInt8(roles);
+    pkt.writeUInt8(0);  // needed
+    pkt.writeUInt8(0);  // unk
+    pkt.writeUInt8(1);  // 1 dungeon in list
+    pkt.writeUInt32(dungeonId);
+    pkt.writeString("");  // comment
+
+    socket->send(pkt);
+    LOG_INFO("Sent CMSG_LFG_JOIN: dungeonId=", dungeonId, " roles=", static_cast<int>(roles));
 }
 
 void GameHandler::lfgLeave() {
-    if (socialHandler_) socialHandler_->lfgLeave();
-}
+    if (!socket) return;
 
-void GameHandler::lfgSetRoles(uint8_t roles) {
-    if (socialHandler_) socialHandler_->lfgSetRoles(roles);
+    network::Packet pkt(wireOpcode(Opcode::CMSG_LFG_LEAVE));
+    // CMSG_LFG_LEAVE has an LFG identifier block; send zeroes to leave any active queue.
+    pkt.writeUInt32(0);  // slot
+    pkt.writeUInt32(0);  // unk
+    pkt.writeUInt32(0);  // dungeonId
+
+    socket->send(pkt);
+    lfgState_ = LfgState::None;
+    LOG_INFO("Sent CMSG_LFG_LEAVE");
 }
 
 void GameHandler::lfgAcceptProposal(uint32_t proposalId, bool accept) {
-    if (socialHandler_) socialHandler_->lfgAcceptProposal(proposalId, accept);
+    if (!socket) return;
+
+    network::Packet pkt(wireOpcode(Opcode::CMSG_LFG_PROPOSAL_RESULT));
+    pkt.writeUInt32(proposalId);
+    pkt.writeUInt8(accept ? 1 : 0);
+
+    socket->send(pkt);
+    LOG_INFO("Sent CMSG_LFG_PROPOSAL_RESULT: proposalId=", proposalId, " accept=", accept);
 }
 
 void GameHandler::lfgTeleport(bool toLfgDungeon) {
-    if (socialHandler_) socialHandler_->lfgTeleport(toLfgDungeon);
-}
+    if (!socket) return;
 
-void GameHandler::lfgSetBootVote(bool vote) {
-    if (socialHandler_) socialHandler_->lfgSetBootVote(vote);
+    network::Packet pkt(wireOpcode(Opcode::CMSG_LFG_TELEPORT));
+    pkt.writeUInt8(toLfgDungeon ? 0 : 1);  // 0=teleport in, 1=teleport out
+
+    socket->send(pkt);
+    LOG_INFO("Sent CMSG_LFG_TELEPORT: toLfgDungeon=", toLfgDungeon);
 }
 
 void GameHandler::loadAreaTriggerDbc() {
-    if (movementHandler_) movementHandler_->loadAreaTriggerDbc();
+    if (areaTriggerDbcLoaded_) return;
+    areaTriggerDbcLoaded_ = true;
+
+    auto* am = core::Application::getInstance().getAssetManager();
+    if (!am || !am->isInitialized()) return;
+
+    auto dbc = am->loadDBC("AreaTrigger.dbc");
+    if (!dbc || !dbc->isLoaded()) {
+        LOG_WARNING("Failed to load AreaTrigger.dbc");
+        return;
+    }
+
+    areaTriggers_.reserve(dbc->getRecordCount());
+    for (uint32_t i = 0; i < dbc->getRecordCount(); i++) {
+        AreaTriggerEntry at;
+        at.id     = dbc->getUInt32(i, 0);
+        at.mapId  = dbc->getUInt32(i, 1);
+        // DBC stores positions in server/wire format (X=west, Y=north) — swap to canonical
+        at.x = dbc->getFloat(i, 3);  // canonical X (north) = DBC field 3 (Y_wire)
+        at.y = dbc->getFloat(i, 2);  // canonical Y (west)  = DBC field 2 (X_wire)
+        at.z = dbc->getFloat(i, 4);
+        at.radius    = dbc->getFloat(i, 5);
+        at.boxLength = dbc->getFloat(i, 6);
+        at.boxWidth  = dbc->getFloat(i, 7);
+        at.boxHeight = dbc->getFloat(i, 8);
+        at.boxYaw    = dbc->getFloat(i, 9);
+        areaTriggers_.push_back(at);
+    }
+
+    LOG_WARNING("Loaded ", areaTriggers_.size(), " area triggers from AreaTrigger.dbc");
 }
 
 void GameHandler::checkAreaTriggers() {
-    if (movementHandler_) movementHandler_->checkAreaTriggers();
+    if (state != WorldState::IN_WORLD || !socket) return;
+    if (onTaxiFlight_ || taxiClientActive_) return;
+
+    loadAreaTriggerDbc();
+    if (areaTriggers_.empty()) return;
+
+    const float px = movementInfo.x;
+    const float py = movementInfo.y;
+    const float pz = movementInfo.z;
+
+    // On first check after map transfer, just mark which triggers we're inside
+    // without firing them — prevents exit portal from immediately sending us back
+    bool suppressFirst = areaTriggerSuppressFirst_;
+    if (suppressFirst) {
+        areaTriggerSuppressFirst_ = false;
+    }
+
+    for (const auto& at : areaTriggers_) {
+        if (at.mapId != currentMapId_) continue;
+
+        bool inside = false;
+        if (at.radius > 0.0f) {
+            // Sphere trigger — use actual radius, with small floor for very tiny triggers
+            float effectiveRadius = std::max(at.radius, 3.0f);
+            float dx = px - at.x;
+            float dy = py - at.y;
+            float dz = pz - at.z;
+            float distSq = dx * dx + dy * dy + dz * dz;
+            inside = (distSq <= effectiveRadius * effectiveRadius);
+        } else if (at.boxLength > 0.0f || at.boxWidth > 0.0f || at.boxHeight > 0.0f) {
+            // Box trigger — use actual size, with small floor for tiny triggers
+            float boxMin = 4.0f;
+            float effLength = std::max(at.boxLength, boxMin);
+            float effWidth = std::max(at.boxWidth, boxMin);
+            float effHeight = std::max(at.boxHeight, boxMin);
+
+            float dx = px - at.x;
+            float dy = py - at.y;
+            float dz = pz - at.z;
+
+            // Rotate into box-local space
+            float cosYaw = std::cos(-at.boxYaw);
+            float sinYaw = std::sin(-at.boxYaw);
+            float localX = dx * cosYaw - dy * sinYaw;
+            float localY = dx * sinYaw + dy * cosYaw;
+
+            inside = (std::abs(localX) <= effLength * 0.5f &&
+                      std::abs(localY) <= effWidth * 0.5f &&
+                      std::abs(dz) <= effHeight * 0.5f);
+        }
+
+        if (inside) {
+            if (activeAreaTriggers_.count(at.id) == 0) {
+                activeAreaTriggers_.insert(at.id);
+
+                if (suppressFirst) {
+                    // After map transfer: mark triggers we're inside of, but don't fire them.
+                    // This prevents the exit portal from immediately sending us back.
+                    LOG_WARNING("AreaTrigger suppressed (post-transfer): AT", at.id);
+                } else {
+                    // Temporarily move player to trigger center so the server's distance
+                    // check passes, then restore to actual position so the server doesn't
+                    // persist the fake position on disconnect.
+                    float savedX = movementInfo.x, savedY = movementInfo.y, savedZ = movementInfo.z;
+                    movementInfo.x = at.x;
+                    movementInfo.y = at.y;
+                    movementInfo.z = at.z;
+                    sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
+
+                    network::Packet pkt(wireOpcode(Opcode::CMSG_AREATRIGGER));
+                    pkt.writeUInt32(at.id);
+                    socket->send(pkt);
+                    LOG_WARNING("Fired CMSG_AREATRIGGER: id=", at.id,
+                             " at (", at.x, ", ", at.y, ", ", at.z, ")");
+
+                    // Restore actual player position
+                    movementInfo.x = savedX;
+                    movementInfo.y = savedY;
+                    movementInfo.z = savedZ;
+                    sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
+                }
+            }
+        } else {
+            // Player left the trigger — allow re-fire on re-entry
+            activeAreaTriggers_.erase(at.id);
+        }
+    }
 }
 
-void GameHandler::requestArenaTeamRoster(uint32_t teamId) {
-    if (socialHandler_) socialHandler_->requestArenaTeamRoster(teamId);
+void GameHandler::handleArenaTeamCommandResult(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 8) return;
+    uint32_t command = packet.readUInt32();
+    std::string name = packet.readString();
+    uint32_t error = packet.readUInt32();
+
+    static const char* commands[] = { "create", "invite", "leave", "remove", "disband", "leader" };
+    std::string cmdName = (command < 6) ? commands[command] : "unknown";
+
+    if (error == 0) {
+        addSystemChatMessage("Arena team " + cmdName + " successful" +
+                           (name.empty() ? "." : ": " + name));
+    } else {
+        addSystemChatMessage("Arena team " + cmdName + " failed" +
+                           (name.empty() ? "." : " for " + name + "."));
+    }
+    LOG_INFO("Arena team command: ", cmdName, " name=", name, " error=", error);
 }
 
-void GameHandler::requestPvpLog() {
-    if (socialHandler_) socialHandler_->requestPvpLog();
+void GameHandler::handleArenaTeamQueryResponse(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 4) return;
+    uint32_t teamId = packet.readUInt32();
+    std::string teamName = packet.readString();
+    LOG_INFO("Arena team query response: id=", teamId, " name=", teamName);
+}
+
+void GameHandler::handleArenaTeamInvite(network::Packet& packet) {
+    std::string playerName = packet.readString();
+    std::string teamName = packet.readString();
+    addSystemChatMessage(playerName + " has invited you to join " + teamName + ".");
+    LOG_INFO("Arena team invite from ", playerName, " to ", teamName);
+}
+
+void GameHandler::handleArenaTeamEvent(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 1) return;
+    uint8_t event = packet.readUInt8();
+
+    static const char* events[] = {
+        "joined", "left", "removed", "leader changed",
+        "disbanded", "created"
+    };
+    std::string eventName = (event < 6) ? events[event] : "unknown event";
+
+    // Read string params (up to 3)
+    uint8_t strCount = 0;
+    if (packet.getSize() - packet.getReadPos() >= 1) {
+        strCount = packet.readUInt8();
+    }
+
+    std::string param1, param2;
+    if (strCount >= 1 && packet.getSize() > packet.getReadPos()) param1 = packet.readString();
+    if (strCount >= 2 && packet.getSize() > packet.getReadPos()) param2 = packet.readString();
+
+    std::string msg = "Arena team " + eventName;
+    if (!param1.empty()) msg += ": " + param1;
+    if (!param2.empty()) msg += " (" + param2 + ")";
+    addSystemChatMessage(msg);
+    LOG_INFO("Arena team event: ", eventName, " ", param1, " ", param2);
+}
+
+void GameHandler::handleArenaError(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 4) return;
+    uint32_t error = packet.readUInt32();
+
+    std::string msg;
+    switch (error) {
+        case 1: msg = "The other team is not big enough."; break;
+        case 2: msg = "That team is full."; break;
+        case 3: msg = "Not enough members to start."; break;
+        case 4: msg = "Too many members."; break;
+        default: msg = "Arena error (code " + std::to_string(error) + ")"; break;
+    }
+    addSystemChatMessage(msg);
+    LOG_INFO("Arena error: ", error, " - ", msg);
+}
+
+void GameHandler::handleOtherPlayerMovement(network::Packet& packet) {
+    // Server relays MSG_MOVE_* for other players: PackedGuid + MovementInfo
+    uint64_t moverGuid = UpdateObjectParser::readPackedGuid(packet);
+    if (moverGuid == playerGuid || moverGuid == 0) {
+        return; // Skip our own echoes
+    }
+
+    // Read movement info (expansion-specific format)
+    // For classic: moveFlags(u32) + time(u32) + pos(4xf32) + [transport] + [pitch] + fallTime(u32) + [jump] + [splineElev]
+    MovementInfo info = {};
+    info.flags = packet.readUInt32();
+    // WotLK has u16 flags2, TBC has u8, Classic has none.
+    // Do NOT use build-number thresholds here (Turtle uses classic formats with a high build).
+    uint8_t flags2Size = packetParsers_ ? packetParsers_->movementFlags2Size() : 2;
+    if (flags2Size == 2) info.flags2 = packet.readUInt16();
+    else if (flags2Size == 1) info.flags2 = packet.readUInt8();
+    info.time = packet.readUInt32();
+    info.x = packet.readFloat();
+    info.y = packet.readFloat();
+    info.z = packet.readFloat();
+    info.orientation = packet.readFloat();
+
+    // Update entity position in entity manager
+    auto entity = entityManager.getEntity(moverGuid);
+    if (!entity) {
+        return;
+    }
+
+    // Convert server coords to canonical
+    glm::vec3 canonical = core::coords::serverToCanonical(glm::vec3(info.x, info.y, info.z));
+    float canYaw = core::coords::serverToCanonicalYaw(info.orientation);
+    // Compute a smoothed interpolation window for this player.
+    // Using a raw packet delta causes jitter when timing spikes (e.g. 50ms then 300ms).
+    // An exponential moving average of intervals gives a stable playback speed that
+    // dead-reckoning in Entity::updateMovement() can bridge without a visible freeze.
+    uint32_t durationMs = 120;
+    auto itPrev = otherPlayerMoveTimeMs_.find(moverGuid);
+    if (itPrev != otherPlayerMoveTimeMs_.end()) {
+        uint32_t rawDt = info.time - itPrev->second;  // wraps naturally on uint32_t
+        if (rawDt >= 20 && rawDt <= 2000) {
+            float fDt = static_cast<float>(rawDt);
+            // EMA: smooth the interval so single spike packets don't stutter playback.
+            auto& smoothed = otherPlayerSmoothedIntervalMs_[moverGuid];
+            if (smoothed < 1.0f) smoothed = fDt;  // first observation — seed directly
+            smoothed = 0.7f * smoothed + 0.3f * fDt;
+            // Clamp to sane WoW movement rates: ~10 Hz (100ms) normal, up to 2Hz (500ms) slow
+            float clamped = std::max(60.0f, std::min(500.0f, smoothed));
+            durationMs = static_cast<uint32_t>(clamped);
+        }
+    }
+    otherPlayerMoveTimeMs_[moverGuid] = info.time;
+
+    entity->startMoveTo(canonical.x, canonical.y, canonical.z, canYaw, durationMs / 1000.0f);
+
+    // Notify renderer
+    if (creatureMoveCallback_) {
+        creatureMoveCallback_(moverGuid, canonical.x, canonical.y, canonical.z, durationMs);
+    }
+}
+
+void GameHandler::handleCompressedMoves(network::Packet& packet) {
+    // Vanilla/Classic SMSG_COMPRESSED_MOVES: raw concatenated sub-packets, NOT zlib.
+    // Evidence: observed 1-byte "00" packets which are not valid zlib streams.
+    // Each sub-packet: uint8 size (of opcode[2]+payload), uint16 opcode, uint8[] payload.
+    // size=0 → invalid/empty, signals end of batch.
+    const auto& data = packet.getData();
+    size_t dataLen = data.size();
+
+    // Wire opcodes for sub-packet routing
+    uint16_t monsterMoveWire          = wireOpcode(Opcode::SMSG_MONSTER_MOVE);
+    uint16_t monsterMoveTransportWire = wireOpcode(Opcode::SMSG_MONSTER_MOVE_TRANSPORT);
+
+    // Player movement sub-opcodes (SMSG_MULTIPLE_MOVES carries MSG_MOVE_*)
+    // Not static — wireOpcode() depends on runtime active opcode table.
+    const std::array<uint16_t, 15> kMoveOpcodes = {
+        wireOpcode(Opcode::MSG_MOVE_START_FORWARD),
+        wireOpcode(Opcode::MSG_MOVE_START_BACKWARD),
+        wireOpcode(Opcode::MSG_MOVE_STOP),
+        wireOpcode(Opcode::MSG_MOVE_START_STRAFE_LEFT),
+        wireOpcode(Opcode::MSG_MOVE_START_STRAFE_RIGHT),
+        wireOpcode(Opcode::MSG_MOVE_STOP_STRAFE),
+        wireOpcode(Opcode::MSG_MOVE_JUMP),
+        wireOpcode(Opcode::MSG_MOVE_START_TURN_LEFT),
+        wireOpcode(Opcode::MSG_MOVE_START_TURN_RIGHT),
+        wireOpcode(Opcode::MSG_MOVE_STOP_TURN),
+        wireOpcode(Opcode::MSG_MOVE_SET_FACING),
+        wireOpcode(Opcode::MSG_MOVE_FALL_LAND),
+        wireOpcode(Opcode::MSG_MOVE_HEARTBEAT),
+        wireOpcode(Opcode::MSG_MOVE_START_SWIM),
+        wireOpcode(Opcode::MSG_MOVE_STOP_SWIM),
+    };
+
+    // Track unhandled sub-opcodes once per compressed packet (avoid log spam)
+    std::unordered_set<uint16_t> unhandledSeen;
+
+    size_t pos = 0;
+    while (pos < dataLen) {
+        if (pos + 1 > dataLen) break;
+        uint8_t subSize = data[pos];
+        if (subSize < 2) break;  // size=0 or 1 → empty/end-of-batch sentinel
+        if (pos + 1 + subSize > dataLen) {
+            LOG_WARNING("SMSG_COMPRESSED_MOVES: sub-packet overruns buffer at pos=", pos);
+            break;
+        }
+        uint16_t subOpcode = static_cast<uint16_t>(data[pos + 1]) |
+                             (static_cast<uint16_t>(data[pos + 2]) << 8);
+        size_t payloadLen = subSize - 2;
+        size_t payloadStart = pos + 3;
+
+        std::vector<uint8_t> subPayload(data.begin() + payloadStart,
+                                        data.begin() + payloadStart + payloadLen);
+        network::Packet subPacket(subOpcode, subPayload);
+
+        if (subOpcode == monsterMoveWire) {
+            handleMonsterMove(subPacket);
+        } else if (subOpcode == monsterMoveTransportWire) {
+            handleMonsterMoveTransport(subPacket);
+        } else if (state == WorldState::IN_WORLD &&
+                   std::find(kMoveOpcodes.begin(), kMoveOpcodes.end(), subOpcode) != kMoveOpcodes.end()) {
+            // Player/NPC movement update packed in SMSG_MULTIPLE_MOVES
+            handleOtherPlayerMovement(subPacket);
+        } else {
+            if (unhandledSeen.insert(subOpcode).second) {
+                LOG_INFO("SMSG_COMPRESSED_MOVES: unhandled sub-opcode 0x",
+                         std::hex, subOpcode, std::dec, " payloadLen=", payloadLen);
+            }
+        }
+
+        pos = payloadStart + payloadLen;
+    }
+}
+
+void GameHandler::handleMonsterMove(network::Packet& packet) {
+    MonsterMoveData data;
+    auto logMonsterMoveParseFailure = [&](const std::string& msg) {
+        static uint32_t failCount = 0;
+        ++failCount;
+        if (failCount <= 10 || (failCount % 100) == 0) {
+            LOG_WARNING(msg, " (occurrence=", failCount, ")");
+        }
+    };
+    auto stripWrappedSubpacket = [&](const std::vector<uint8_t>& bytes, std::vector<uint8_t>& stripped) -> bool {
+        if (bytes.size() < 3) return false;
+        uint8_t subSize = bytes[0];
+        if (subSize < 2) return false;
+        size_t wrappedLen = static_cast<size_t>(subSize) + 1; // size byte + body
+        if (wrappedLen != bytes.size()) return false;
+        size_t payloadLen = static_cast<size_t>(subSize) - 2; // opcode(2) stripped
+        if (3 + payloadLen > bytes.size()) return false;
+        stripped.assign(bytes.begin() + 3, bytes.begin() + 3 + payloadLen);
+        return true;
+    };
+    // Turtle WoW (1.17+) compresses each SMSG_MONSTER_MOVE individually:
+    // format: uint32 decompressedSize + zlib data (zlib magic = 0x78 ??)
+    const auto& rawData = packet.getData();
+    const bool allowTurtleMoveCompression = isActiveExpansion("turtle");
+    bool isCompressed = allowTurtleMoveCompression &&
+                        rawData.size() >= 6 &&
+                        rawData[4] == 0x78 &&
+                        (rawData[5] == 0x01 || rawData[5] == 0x9C ||
+                         rawData[5] == 0xDA || rawData[5] == 0x5E);
+    if (isCompressed) {
+        uint32_t decompSize = static_cast<uint32_t>(rawData[0]) |
+                              (static_cast<uint32_t>(rawData[1]) << 8) |
+                              (static_cast<uint32_t>(rawData[2]) << 16) |
+                              (static_cast<uint32_t>(rawData[3]) << 24);
+        if (decompSize == 0 || decompSize > 65536) {
+            LOG_WARNING("SMSG_MONSTER_MOVE: bad decompSize=", decompSize);
+            return;
+        }
+        std::vector<uint8_t> decompressed(decompSize);
+        uLongf destLen = decompSize;
+        int ret = uncompress(decompressed.data(), &destLen,
+                             rawData.data() + 4, rawData.size() - 4);
+        if (ret != Z_OK) {
+            LOG_WARNING("SMSG_MONSTER_MOVE: zlib error ", ret);
+            return;
+        }
+        decompressed.resize(destLen);
+        // Dump ALL bytes for format diagnosis (remove once confirmed)
+        static int dumpCount = 0;
+        if (dumpCount < 10) {
+            ++dumpCount;
+            std::string hex;
+            for (size_t i = 0; i < destLen; ++i) {
+                char buf[4]; snprintf(buf, sizeof(buf), "%02X ", decompressed[i]); hex += buf;
+            }
+            LOG_INFO("MonsterMove decomp[", destLen, "]: ", hex);
+        }
+        std::vector<uint8_t> stripped;
+        bool hasWrappedForm = stripWrappedSubpacket(decompressed, stripped);
+
+        // Try unwrapped payload first (common form), then wrapped-subpacket fallback.
+        network::Packet decompPacket(packet.getOpcode(), decompressed);
+        if (!packetParsers_->parseMonsterMove(decompPacket, data)) {
+            if (!hasWrappedForm) {
+                logMonsterMoveParseFailure("Failed to parse SMSG_MONSTER_MOVE (decompressed " +
+                                           std::to_string(destLen) + " bytes)");
+                return;
+            }
+            network::Packet wrappedPacket(packet.getOpcode(), stripped);
+            if (!packetParsers_->parseMonsterMove(wrappedPacket, data)) {
+                logMonsterMoveParseFailure("Failed to parse SMSG_MONSTER_MOVE (decompressed " +
+                                           std::to_string(destLen) + " bytes, wrapped payload " +
+                                           std::to_string(stripped.size()) + " bytes)");
+                return;
+            }
+            LOG_WARNING("SMSG_MONSTER_MOVE parsed via wrapped-subpacket fallback");
+        }
+    } else if (!packetParsers_->parseMonsterMove(packet, data)) {
+        // Some realms occasionally embed an extra [size|opcode] wrapper even when the
+        // outer packet wasn't zlib-compressed. Retry with wrapper stripped by structure.
+        std::vector<uint8_t> stripped;
+        if (stripWrappedSubpacket(rawData, stripped)) {
+            network::Packet wrappedPacket(packet.getOpcode(), stripped);
+            if (packetParsers_->parseMonsterMove(wrappedPacket, data)) {
+                LOG_WARNING("SMSG_MONSTER_MOVE parsed via uncompressed wrapped-subpacket fallback");
+            } else {
+                logMonsterMoveParseFailure("Failed to parse SMSG_MONSTER_MOVE");
+                return;
+            }
+        } else {
+            logMonsterMoveParseFailure("Failed to parse SMSG_MONSTER_MOVE");
+            return;
+        }
+    }
+
+    // Update entity position in entity manager
+    auto entity = entityManager.getEntity(data.guid);
+    if (!entity) {
+        return;
+    }
+
+    if (data.hasDest) {
+        // Convert destination from server to canonical coords
+        glm::vec3 destCanonical = core::coords::serverToCanonical(
+            glm::vec3(data.destX, data.destY, data.destZ));
+
+        // Calculate facing angle
+        float orientation = entity->getOrientation();
+        if (data.moveType == 4) {
+            // FacingAngle - server specifies exact angle
+            orientation = core::coords::serverToCanonicalYaw(data.facingAngle);
+        } else if (data.moveType == 3) {
+            // FacingTarget - face toward the target entity.
+            // Canonical orientation uses atan2(-dy, dx): the West/Y component
+            // must be negated because renderYaw = orientation + 90° and
+            // model-forward = render +X, so the sign convention flips.
+            auto target = entityManager.getEntity(data.facingTarget);
+            if (target) {
+                float dx = target->getX() - entity->getX();
+                float dy = target->getY() - entity->getY();
+                if (std::abs(dx) > 0.01f || std::abs(dy) > 0.01f) {
+                    orientation = std::atan2(-dy, dx);
+                }
+            }
+        } else {
+            // Normal move - face toward destination.
+            float dx = destCanonical.x - entity->getX();
+            float dy = destCanonical.y - entity->getY();
+            if (std::abs(dx) > 0.01f || std::abs(dy) > 0.01f) {
+                orientation = std::atan2(-dy, dx);
+            }
+        }
+
+        // Anti-backward-glide: if the computed orientation is more than 90° away from
+        // the actual travel direction, snap to the travel direction.  FacingTarget
+        // (moveType 3) is deliberately different from travel dir, so skip it there.
+        if (data.moveType != 3) {
+            glm::vec3 startCanonical = core::coords::serverToCanonical(
+                glm::vec3(data.x, data.y, data.z));
+            float travelDx = destCanonical.x - startCanonical.x;
+            float travelDy = destCanonical.y - startCanonical.y;
+            float travelLen = std::sqrt(travelDx * travelDx + travelDy * travelDy);
+            if (travelLen > 0.5f) {
+                float travelAngle = std::atan2(-travelDy, travelDx);
+                float diff = orientation - travelAngle;
+                // Normalise diff to [-π, π]
+                while (diff >  static_cast<float>(M_PI)) diff -= 2.0f * static_cast<float>(M_PI);
+                while (diff < -static_cast<float>(M_PI)) diff += 2.0f * static_cast<float>(M_PI);
+                if (std::abs(diff) > static_cast<float>(M_PI) * 0.5f) {
+                    orientation = travelAngle;
+                }
+            }
+        }
+
+        // Interpolate entity position alongside renderer (so targeting matches visual)
+        entity->startMoveTo(destCanonical.x, destCanonical.y, destCanonical.z,
+                            orientation, data.duration / 1000.0f);
+
+        // Notify renderer to smoothly move the creature
+        if (creatureMoveCallback_) {
+            creatureMoveCallback_(data.guid,
+                destCanonical.x, destCanonical.y, destCanonical.z,
+                data.duration);
+        }
+    } else if (data.moveType == 1) {
+        // Stop at current position
+        glm::vec3 posCanonical = core::coords::serverToCanonical(
+            glm::vec3(data.x, data.y, data.z));
+        entity->setPosition(posCanonical.x, posCanonical.y, posCanonical.z,
+                            entity->getOrientation());
+
+        if (creatureMoveCallback_) {
+            creatureMoveCallback_(data.guid,
+                posCanonical.x, posCanonical.y, posCanonical.z, 0);
+        }
+    }
+}
+
+void GameHandler::handleMonsterMoveTransport(network::Packet& packet) {
+    // Parse transport-relative creature movement (NPCs on boats/zeppelins)
+    // Packet: moverGuid(8) + unk(1) + transportGuid(8) + localX/Y/Z(12) + spline data
+
+    if (packet.getSize() - packet.getReadPos() < 8 + 1 + 8 + 12) return;
+    uint64_t moverGuid = packet.readUInt64();
+    /*uint8_t unk =*/ packet.readUInt8();
+    uint64_t transportGuid = packet.readUInt64();
+
+    // Transport-local start position (server coords: x=east/west, y=north/south, z=up)
+    float localX = packet.readFloat();
+    float localY = packet.readFloat();
+    float localZ = packet.readFloat();
+
+    auto entity = entityManager.getEntity(moverGuid);
+    if (!entity) return;
+
+    // ---- Spline data (same format as SMSG_MONSTER_MOVE, transport-local coords) ----
+    if (packet.getReadPos() + 5 > packet.getSize()) {
+        // No spline data — snap to start position
+        if (transportManager_) {
+            glm::vec3 localCanonical = core::coords::serverToCanonical(glm::vec3(localX, localY, localZ));
+            setTransportAttachment(moverGuid, entity->getType(), transportGuid, localCanonical, false, 0.0f);
+            glm::vec3 worldPos = transportManager_->getPlayerWorldPosition(transportGuid, localCanonical);
+            entity->setPosition(worldPos.x, worldPos.y, worldPos.z, entity->getOrientation());
+            if (entity->getType() == ObjectType::UNIT && creatureMoveCallback_)
+                creatureMoveCallback_(moverGuid, worldPos.x, worldPos.y, worldPos.z, 0);
+        }
+        return;
+    }
+
+    /*uint32_t splineId =*/ packet.readUInt32();
+    uint8_t moveType = packet.readUInt8();
+
+    if (moveType == 1) {
+        // Stop — snap to start position
+        if (transportManager_) {
+            glm::vec3 localCanonical = core::coords::serverToCanonical(glm::vec3(localX, localY, localZ));
+            setTransportAttachment(moverGuid, entity->getType(), transportGuid, localCanonical, false, 0.0f);
+            glm::vec3 worldPos = transportManager_->getPlayerWorldPosition(transportGuid, localCanonical);
+            entity->setPosition(worldPos.x, worldPos.y, worldPos.z, entity->getOrientation());
+            if (entity->getType() == ObjectType::UNIT && creatureMoveCallback_)
+                creatureMoveCallback_(moverGuid, worldPos.x, worldPos.y, worldPos.z, 0);
+        }
+        return;
+    }
+
+    // Facing data based on moveType
+    float facingAngle = entity->getOrientation();
+    if (moveType == 2) {       // FacingSpot
+        if (packet.getReadPos() + 12 > packet.getSize()) return;
+        float sx = packet.readFloat(), sy = packet.readFloat(), sz = packet.readFloat();
+        facingAngle = std::atan2(-(sy - localY), sx - localX);
+        (void)sz;
+    } else if (moveType == 3) { // FacingTarget
+        if (packet.getReadPos() + 8 > packet.getSize()) return;
+        uint64_t tgtGuid = packet.readUInt64();
+        if (auto tgt = entityManager.getEntity(tgtGuid)) {
+            float dx = tgt->getX() - entity->getX();
+            float dy = tgt->getY() - entity->getY();
+            if (std::abs(dx) > 0.01f || std::abs(dy) > 0.01f)
+                facingAngle = std::atan2(-dy, dx);
+        }
+    } else if (moveType == 4) { // FacingAngle
+        if (packet.getReadPos() + 4 > packet.getSize()) return;
+        facingAngle = core::coords::serverToCanonicalYaw(packet.readFloat());
+    }
+
+    if (packet.getReadPos() + 4 > packet.getSize()) return;
+    uint32_t splineFlags = packet.readUInt32();
+
+    if (splineFlags & 0x00400000) { // Animation
+        if (packet.getReadPos() + 5 > packet.getSize()) return;
+        packet.readUInt8(); packet.readUInt32();
+    }
+
+    if (packet.getReadPos() + 4 > packet.getSize()) return;
+    uint32_t duration = packet.readUInt32();
+
+    if (splineFlags & 0x00000800) { // Parabolic
+        if (packet.getReadPos() + 8 > packet.getSize()) return;
+        packet.readFloat(); packet.readUInt32();
+    }
+
+    if (packet.getReadPos() + 4 > packet.getSize()) return;
+    uint32_t pointCount = packet.readUInt32();
+
+    // Read destination point (transport-local server coords)
+    float destLocalX = localX, destLocalY = localY, destLocalZ = localZ;
+    bool hasDest = false;
+    if (pointCount > 0) {
+        const bool uncompressed = (splineFlags & (0x00080000 | 0x00002000)) != 0;
+        if (uncompressed) {
+            for (uint32_t i = 0; i < pointCount - 1; ++i) {
+                if (packet.getReadPos() + 12 > packet.getSize()) break;
+                packet.readFloat(); packet.readFloat(); packet.readFloat();
+            }
+            if (packet.getReadPos() + 12 <= packet.getSize()) {
+                destLocalX = packet.readFloat();
+                destLocalY = packet.readFloat();
+                destLocalZ = packet.readFloat();
+                hasDest = true;
+            }
+        } else {
+            if (packet.getReadPos() + 12 <= packet.getSize()) {
+                destLocalX = packet.readFloat();
+                destLocalY = packet.readFloat();
+                destLocalZ = packet.readFloat();
+                hasDest = true;
+            }
+        }
+    }
+
+    if (!transportManager_) {
+        LOG_WARNING("SMSG_MONSTER_MOVE_TRANSPORT: TransportManager not available for mover 0x",
+                    std::hex, moverGuid, std::dec);
+        return;
+    }
+
+    glm::vec3 startLocalCanonical = core::coords::serverToCanonical(glm::vec3(localX, localY, localZ));
+
+    if (hasDest && duration > 0) {
+        glm::vec3 destLocalCanonical = core::coords::serverToCanonical(glm::vec3(destLocalX, destLocalY, destLocalZ));
+        glm::vec3 destWorld  = transportManager_->getPlayerWorldPosition(transportGuid, destLocalCanonical);
+
+        // Face toward destination unless an explicit facing was given
+        if (moveType == 0) {
+            float dx = destLocalCanonical.x - startLocalCanonical.x;
+            float dy = destLocalCanonical.y - startLocalCanonical.y;
+            if (std::abs(dx) > 0.01f || std::abs(dy) > 0.01f)
+                facingAngle = std::atan2(-dy, dx);
+        }
+
+        setTransportAttachment(moverGuid, entity->getType(), transportGuid, destLocalCanonical, false, 0.0f);
+        entity->startMoveTo(destWorld.x, destWorld.y, destWorld.z, facingAngle, duration / 1000.0f);
+
+        if (entity->getType() == ObjectType::UNIT && creatureMoveCallback_)
+            creatureMoveCallback_(moverGuid, destWorld.x, destWorld.y, destWorld.z, duration);
+
+        LOG_DEBUG("SMSG_MONSTER_MOVE_TRANSPORT: mover=0x", std::hex, moverGuid,
+                  " transport=0x", transportGuid, std::dec,
+                  " dur=", duration, "ms dest=(", destWorld.x, ",", destWorld.y, ",", destWorld.z, ")");
+    } else {
+        glm::vec3 startWorld = transportManager_->getPlayerWorldPosition(transportGuid, startLocalCanonical);
+        setTransportAttachment(moverGuid, entity->getType(), transportGuid, startLocalCanonical, false, 0.0f);
+        entity->setPosition(startWorld.x, startWorld.y, startWorld.z, facingAngle);
+        if (entity->getType() == ObjectType::UNIT && creatureMoveCallback_)
+            creatureMoveCallback_(moverGuid, startWorld.x, startWorld.y, startWorld.z, 0);
+    }
+}
+
+void GameHandler::handleAttackerStateUpdate(network::Packet& packet) {
+    AttackerStateUpdateData data;
+    if (!AttackerStateUpdateParser::parse(packet, data)) return;
+
+    bool isPlayerAttacker = (data.attackerGuid == playerGuid);
+    bool isPlayerTarget = (data.targetGuid == playerGuid);
+    if (!isPlayerAttacker && !isPlayerTarget) return;  // Not our combat
+
+    if (isPlayerAttacker && meleeSwingCallback_) {
+        meleeSwingCallback_();
+    }
+    if (!isPlayerAttacker && npcSwingCallback_) {
+        npcSwingCallback_(data.attackerGuid);
+    }
+
+    if (isPlayerTarget && data.attackerGuid != 0) {
+        hostileAttackers_.insert(data.attackerGuid);
+        autoTargetAttacker(data.attackerGuid);
+    }
+
+    // Play combat sounds via CombatSoundManager + character vocalizations
+    if (auto* renderer = core::Application::getInstance().getRenderer()) {
+        if (auto* csm = renderer->getCombatSoundManager()) {
+            auto weaponSize = audio::CombatSoundManager::WeaponSize::MEDIUM;
+            if (data.isMiss()) {
+                csm->playWeaponMiss(false);
+            } else if (data.victimState == 1 || data.victimState == 2) {
+                // Dodge/parry — swing whoosh but no impact
+                csm->playWeaponSwing(weaponSize, false);
+            } else {
+                // Hit — swing + flesh impact
+                csm->playWeaponSwing(weaponSize, data.isCrit());
+                csm->playImpact(weaponSize, audio::CombatSoundManager::ImpactType::FLESH, data.isCrit());
+            }
+        }
+        // Character vocalizations
+        if (auto* asm_ = renderer->getActivitySoundManager()) {
+            if (isPlayerAttacker && !data.isMiss() && data.victimState != 1 && data.victimState != 2) {
+                asm_->playAttackGrunt();
+            }
+            if (isPlayerTarget && !data.isMiss() && data.victimState != 1 && data.victimState != 2) {
+                asm_->playWound(data.isCrit());
+            }
+        }
+    }
+
+    if (data.isMiss()) {
+        addCombatText(CombatTextEntry::MISS, 0, 0, isPlayerAttacker);
+    } else if (data.victimState == 1) {
+        addCombatText(CombatTextEntry::DODGE, 0, 0, isPlayerAttacker);
+    } else if (data.victimState == 2) {
+        addCombatText(CombatTextEntry::PARRY, 0, 0, isPlayerAttacker);
+    } else if (data.victimState == 4) {
+        addCombatText(CombatTextEntry::BLOCK, 0, 0, isPlayerAttacker);
+    } else {
+        auto type = data.isCrit() ? CombatTextEntry::CRIT_DAMAGE : CombatTextEntry::MELEE_DAMAGE;
+        addCombatText(type, data.totalDamage, 0, isPlayerAttacker);
+    }
+
+    (void)isPlayerTarget;
+}
+
+void GameHandler::handleSpellDamageLog(network::Packet& packet) {
+    SpellDamageLogData data;
+    if (!SpellDamageLogParser::parse(packet, data)) return;
+
+    bool isPlayerSource = (data.attackerGuid == playerGuid);
+    bool isPlayerTarget = (data.targetGuid == playerGuid);
+    if (!isPlayerSource && !isPlayerTarget) return;  // Not our combat
+
+    if (isPlayerTarget && data.attackerGuid != 0) {
+        hostileAttackers_.insert(data.attackerGuid);
+        autoTargetAttacker(data.attackerGuid);
+    }
+
+    auto type = data.isCrit ? CombatTextEntry::CRIT_DAMAGE : CombatTextEntry::SPELL_DAMAGE;
+    addCombatText(type, static_cast<int32_t>(data.damage), data.spellId, isPlayerSource);
+}
+
+void GameHandler::handleSpellHealLog(network::Packet& packet) {
+    SpellHealLogData data;
+    if (!SpellHealLogParser::parse(packet, data)) return;
+
+    bool isPlayerSource = (data.casterGuid == playerGuid);
+    bool isPlayerTarget = (data.targetGuid == playerGuid);
+    if (!isPlayerSource && !isPlayerTarget) return;  // Not our combat
+
+    auto type = data.isCrit ? CombatTextEntry::CRIT_HEAL : CombatTextEntry::HEAL;
+    addCombatText(type, static_cast<int32_t>(data.heal), data.spellId, isPlayerSource);
 }
 
 // ============================================================
-// Spells
+// Phase 3: Spells
 // ============================================================
 
 void GameHandler::castSpell(uint32_t spellId, uint64_t targetGuid) {
-    if (spellHandler_) spellHandler_->castSpell(spellId, targetGuid);
+    // Attack (6603) routes to auto-attack instead of cast
+    if (spellId == 6603) {
+        uint64_t target = targetGuid != 0 ? targetGuid : this->targetGuid;
+        if (target != 0) {
+            if (autoAttacking) {
+                stopAutoAttack();
+            } else {
+                startAutoAttack(target);
+            }
+        }
+        return;
+    }
+
+    if (state != WorldState::IN_WORLD || !socket) return;
+
+    // Casting any spell while mounted → dismount instead
+    if (isMounted()) {
+        dismount();
+        return;
+    }
+
+    if (casting) return; // Already casting
+
+    // Hearthstone: cast spell directly (server checks item in inventory)
+    // Using CMSG_CAST_SPELL is more reliable than CMSG_USE_ITEM which
+    // depends on slot indices matching between client and server.
+    uint64_t target = targetGuid != 0 ? targetGuid : this->targetGuid;
+    // Self-targeted spells like hearthstone should not send a target
+    if (spellId == 8690) target = 0;
+
+    // Warrior Charge (ranks 1-3): client-side range check + charge callback
+    // Must face target and validate range BEFORE sending packet to server
+    if (spellId == 100 || spellId == 6178 || spellId == 11578) {
+        if (target == 0) {
+            addSystemChatMessage("You have no target.");
+            return;
+        }
+        auto entity = entityManager.getEntity(target);
+        if (!entity) {
+            addSystemChatMessage("You have no target.");
+            return;
+        }
+        float tx = entity->getX(), ty = entity->getY(), tz = entity->getZ();
+        float dx = tx - movementInfo.x;
+        float dy = ty - movementInfo.y;
+        float dz = tz - movementInfo.z;
+        float dist = std::sqrt(dx * dx + dy * dy + dz * dz);
+        if (dist < 8.0f) {
+            addSystemChatMessage("Target is too close.");
+            return;
+        }
+        if (dist > 25.0f) {
+            addSystemChatMessage("Out of range.");
+            return;
+        }
+        // Face the target before sending the cast packet to avoid "not in front" rejection
+        float yaw = std::atan2(dy, dx);
+        movementInfo.orientation = yaw;
+        sendMovement(Opcode::MSG_MOVE_SET_FACING);
+        if (chargeCallback_) {
+            chargeCallback_(target, tx, ty, tz);
+        }
+    }
+
+    // Instant melee abilities: client-side range + facing check to avoid server "not in front" errors
+    {
+        uint32_t sid = spellId;
+        bool isMeleeAbility =
+            sid == 78   || sid == 284   || sid == 285  || sid == 1608  ||  // Heroic Strike
+            sid == 11564 || sid == 11565 || sid == 11566 || sid == 11567 ||
+            sid == 25286 || sid == 29707 || sid == 30324 ||
+            sid == 772  || sid == 6546  || sid == 6547 || sid == 6548 ||   // Rend
+            sid == 11572 || sid == 11573 || sid == 11574 || sid == 25208 ||
+            sid == 6572 || sid == 6574 || sid == 7379 || sid == 11600 ||   // Revenge
+            sid == 11601 || sid == 25288 || sid == 25269 || sid == 30357 ||
+            sid == 845  || sid == 7369  || sid == 11608 || sid == 11609 || // Cleave
+            sid == 20569 || sid == 25231 || sid == 47519 || sid == 47520 ||
+            sid == 12294 || sid == 21551 || sid == 21552 || sid == 21553 || // Mortal Strike
+            sid == 25248 || sid == 30330 || sid == 47485 || sid == 47486 ||
+            sid == 23922 || sid == 23923 || sid == 23924 || sid == 23925 || // Shield Slam
+            sid == 25258 || sid == 30356 || sid == 47487 || sid == 47488;
+        if (isMeleeAbility && target != 0) {
+            auto entity = entityManager.getEntity(target);
+            if (entity) {
+                float dx = entity->getX() - movementInfo.x;
+                float dy = entity->getY() - movementInfo.y;
+                float dz = entity->getZ() - movementInfo.z;
+                float dist = std::sqrt(dx * dx + dy * dy + dz * dz);
+                if (dist > 8.0f) {
+                    addSystemChatMessage("Out of range.");
+                    return;
+                }
+                // Face the target to prevent "not in front" rejection
+                float yaw = std::atan2(dy, dx);
+                movementInfo.orientation = yaw;
+                sendMovement(Opcode::MSG_MOVE_SET_FACING);
+            }
+        }
+    }
+
+    auto packet = packetParsers_
+        ? packetParsers_->buildCastSpell(spellId, target, ++castCount)
+        : CastSpellPacket::build(spellId, target, ++castCount);
+    socket->send(packet);
+    LOG_INFO("Casting spell: ", spellId, " on 0x", std::hex, target, std::dec);
 }
 
 void GameHandler::cancelCast() {
-    if (spellHandler_) spellHandler_->cancelCast();
-}
-
-void GameHandler::startCraftQueue(uint32_t spellId, int count) {
-    if (spellHandler_) spellHandler_->startCraftQueue(spellId, count);
-}
-
-void GameHandler::cancelCraftQueue() {
-    if (spellHandler_) spellHandler_->cancelCraftQueue();
+    if (!casting) return;
+    // GameObject interaction cast is client-side timing only.
+    if (pendingGameObjectInteractGuid_ == 0 &&
+        state == WorldState::IN_WORLD && socket &&
+        currentCastSpellId != 0) {
+        auto packet = CancelCastPacket::build(currentCastSpellId);
+        socket->send(packet);
+    }
+    pendingGameObjectInteractGuid_ = 0;
+    casting = false;
+    currentCastSpellId = 0;
+    castTimeRemaining = 0.0f;
 }
 
 void GameHandler::cancelAura(uint32_t spellId) {
-    if (spellHandler_) spellHandler_->cancelAura(spellId);
-}
-
-uint32_t GameHandler::getTempEnchantRemainingMs(uint32_t slot) const {
-    return inventoryHandler_ ? inventoryHandler_->getTempEnchantRemainingMs(slot) : 0u;
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = CancelAuraPacket::build(spellId);
+    socket->send(packet);
 }
 
 void GameHandler::handlePetSpells(network::Packet& packet) {
-    if (spellHandler_) spellHandler_->handlePetSpells(packet);
-}
-
-void GameHandler::sendPetAction(uint32_t action, uint64_t targetGuid) {
-    if (spellHandler_) spellHandler_->sendPetAction(action, targetGuid);
+    if (packet.getSize() - packet.getReadPos() < 8) {
+        // Empty packet = pet dismissed/died
+        petGuid_ = 0;
+        LOG_INFO("SMSG_PET_SPELLS: pet cleared (empty packet)");
+        return;
+    }
+    petGuid_ = packet.readUInt64();
+    LOG_INFO("SMSG_PET_SPELLS: petGuid=0x", std::hex, petGuid_, std::dec);
 }
 
 void GameHandler::dismissPet() {
-    if (spellHandler_) spellHandler_->dismissPet();
-}
-
-void GameHandler::togglePetSpellAutocast(uint32_t spellId) {
-    if (spellHandler_) spellHandler_->togglePetSpellAutocast(spellId);
-}
-
-void GameHandler::renamePet(const std::string& newName) {
-    if (spellHandler_) spellHandler_->renamePet(newName);
-}
-
-void GameHandler::requestStabledPetList() {
-    if (spellHandler_) spellHandler_->requestStabledPetList();
-}
-
-void GameHandler::stablePet(uint8_t slot) {
-    if (spellHandler_) spellHandler_->stablePet(slot);
-}
-
-void GameHandler::unstablePet(uint32_t petNumber) {
-    if (spellHandler_) spellHandler_->unstablePet(petNumber);
-}
-
-void GameHandler::handleListStabledPets(network::Packet& packet) {
-    if (spellHandler_) spellHandler_->handleListStabledPets(packet);
+    if (petGuid_ == 0 || state != WorldState::IN_WORLD || !socket) return;
+    auto packet = PetActionPacket::build(petGuid_, 0x07000000);
+    socket->send(packet);
 }
 
 void GameHandler::setActionBarSlot(int slot, ActionBarSlot::Type type, uint32_t id) {
     if (slot < 0 || slot >= ACTION_BAR_SLOTS) return;
     actionBar[slot].type = type;
     actionBar[slot].id = id;
-    // Pre-query item information so action bar displays item name instead of "Item" placeholder
-    if (type == ActionBarSlot::ITEM && id != 0) {
-        queryItemInfo(id, 0);
-    }
     saveCharacterConfig();
-    // Notify Lua addons that the action bar changed
-        fireAddonEvent("ACTIONBAR_SLOT_CHANGED", {std::to_string(slot + 1)});
-        fireAddonEvent("ACTIONBAR_UPDATE_STATE", {});
-    // Notify the server so the action bar persists across relogs.
-    if (isInWorld()) {
-        const bool classic = isClassicLikeExpansion();
-        auto pkt = SetActionButtonPacket::build(
-            static_cast<uint8_t>(slot),
-            static_cast<uint8_t>(type),
-            id,
-            classic);
-        socket->send(pkt);
-    }
 }
 
 float GameHandler::getSpellCooldown(uint32_t spellId) const {
-    if (spellHandler_) return spellHandler_->getSpellCooldown(spellId);
-    return 0;
+    auto it = spellCooldowns.find(spellId);
+    return (it != spellCooldowns.end()) ? it->second : 0.0f;
+}
+
+void GameHandler::handleInitialSpells(network::Packet& packet) {
+    InitialSpellsData data;
+    if (!InitialSpellsParser::parse(packet, data)) return;
+
+    knownSpells = {data.spellIds.begin(), data.spellIds.end()};
+
+    // Debug: check if specific spells are in initial spells
+    bool has527 = knownSpells.count(527u);
+    bool has988 = knownSpells.count(988u);
+    bool has1180 = knownSpells.count(1180u);
+    LOG_INFO("Initial spells include: 527=", has527, " 988=", has988, " 1180=", has1180);
+
+    // Ensure Attack (6603) and Hearthstone (8690) are always present
+    knownSpells.insert(6603u);
+    knownSpells.insert(8690u);
+
+    // Set initial cooldowns
+    for (const auto& cd : data.cooldowns) {
+        if (cd.cooldownMs > 0) {
+            spellCooldowns[cd.spellId] = cd.cooldownMs / 1000.0f;
+        }
+    }
+
+    // Load saved action bar or use defaults (Attack slot 1, Hearthstone slot 12)
+    actionBar[0].type = ActionBarSlot::SPELL;
+    actionBar[0].id = 6603;  // Attack
+    actionBar[11].type = ActionBarSlot::SPELL;
+    actionBar[11].id = 8690;  // Hearthstone
+    loadCharacterConfig();
+
+    LOG_INFO("Learned ", knownSpells.size(), " spells");
+}
+
+void GameHandler::handleCastFailed(network::Packet& packet) {
+    CastFailedData data;
+    bool ok = packetParsers_ ? packetParsers_->parseCastFailed(packet, data)
+                             : CastFailedParser::parse(packet, data);
+    if (!ok) return;
+
+    casting = false;
+    currentCastSpellId = 0;
+    castTimeRemaining = 0.0f;
+
+    // Add system message about failed cast with readable reason
+    int powerType = -1;
+    auto playerEntity = entityManager.getEntity(playerGuid);
+    if (auto playerUnit = std::dynamic_pointer_cast<Unit>(playerEntity)) {
+        powerType = playerUnit->getPowerType();
+    }
+    const char* reason = getSpellCastResultString(data.result, powerType);
+    MessageChatData msg;
+    msg.type = ChatType::SYSTEM;
+    msg.language = ChatLanguage::UNIVERSAL;
+    if (reason) {
+        msg.message = reason;
+    } else {
+        msg.message = "Spell cast failed (error " + std::to_string(data.result) + ")";
+    }
+    addLocalChatMessage(msg);
+}
+
+static audio::SpellSoundManager::MagicSchool schoolMaskToMagicSchool(uint32_t mask) {
+    if (mask & 0x04) return audio::SpellSoundManager::MagicSchool::FIRE;
+    if (mask & 0x10) return audio::SpellSoundManager::MagicSchool::FROST;
+    if (mask & 0x02) return audio::SpellSoundManager::MagicSchool::HOLY;
+    if (mask & 0x08) return audio::SpellSoundManager::MagicSchool::NATURE;
+    if (mask & 0x20) return audio::SpellSoundManager::MagicSchool::SHADOW;
+    if (mask & 0x40) return audio::SpellSoundManager::MagicSchool::ARCANE;
+    return audio::SpellSoundManager::MagicSchool::ARCANE;
+}
+
+void GameHandler::handleSpellStart(network::Packet& packet) {
+    SpellStartData data;
+    if (!SpellStartParser::parse(packet, data)) return;
+
+    // If this is the player's own cast, start cast bar
+    if (data.casterUnit == playerGuid && data.castTime > 0) {
+        casting = true;
+        currentCastSpellId = data.spellId;
+        castTimeTotal = data.castTime / 1000.0f;
+        castTimeRemaining = castTimeTotal;
+
+        // Play precast (channeling) sound with correct magic school
+        if (auto* renderer = core::Application::getInstance().getRenderer()) {
+            if (auto* ssm = renderer->getSpellSoundManager()) {
+                loadSpellNameCache();
+                auto it = spellNameCache_.find(data.spellId);
+                auto school = (it != spellNameCache_.end() && it->second.schoolMask)
+                    ? schoolMaskToMagicSchool(it->second.schoolMask)
+                    : audio::SpellSoundManager::MagicSchool::ARCANE;
+                ssm->playPrecast(school, audio::SpellSoundManager::SpellPower::MEDIUM);
+            }
+        }
+    }
+}
+
+void GameHandler::handleSpellGo(network::Packet& packet) {
+    SpellGoData data;
+    if (!SpellGoParser::parse(packet, data)) return;
+
+    // Cast completed
+    if (data.casterUnit == playerGuid) {
+        // Play cast-complete sound with correct magic school
+        if (auto* renderer = core::Application::getInstance().getRenderer()) {
+            if (auto* ssm = renderer->getSpellSoundManager()) {
+                loadSpellNameCache();
+                auto it = spellNameCache_.find(data.spellId);
+                auto school = (it != spellNameCache_.end() && it->second.schoolMask)
+                    ? schoolMaskToMagicSchool(it->second.schoolMask)
+                    : audio::SpellSoundManager::MagicSchool::ARCANE;
+                ssm->playCast(school);
+            }
+        }
+
+        // Instant melee abilities → trigger attack animation
+        uint32_t sid = data.spellId;
+        bool isMeleeAbility =
+            sid == 78   || sid == 284   || sid == 285  || sid == 1608  ||  // Heroic Strike ranks
+            sid == 11564 || sid == 11565 || sid == 11566 || sid == 11567 ||
+            sid == 25286 || sid == 29707 || sid == 30324 ||
+            sid == 772  || sid == 6546  || sid == 6547 || sid == 6548 ||   // Rend ranks
+            sid == 11572 || sid == 11573 || sid == 11574 || sid == 25208 ||
+            sid == 6572 || sid == 6574 || sid == 7379 || sid == 11600 ||   // Revenge ranks
+            sid == 11601 || sid == 25288 || sid == 25269 || sid == 30357 ||
+            sid == 845  || sid == 7369  || sid == 11608 || sid == 11609 || // Cleave ranks
+            sid == 20569 || sid == 25231 || sid == 47519 || sid == 47520 ||
+            sid == 12294 || sid == 21551 || sid == 21552 || sid == 21553 || // Mortal Strike ranks
+            sid == 25248 || sid == 30330 || sid == 47485 || sid == 47486 ||
+            sid == 23922 || sid == 23923 || sid == 23924 || sid == 23925 || // Shield Slam ranks
+            sid == 25258 || sid == 30356 || sid == 47487 || sid == 47488;
+        if (isMeleeAbility && meleeSwingCallback_) {
+            meleeSwingCallback_();
+        }
+
+        casting = false;
+        currentCastSpellId = 0;
+        castTimeRemaining = 0.0f;
+    }
+
+    // Play impact sound when player is hit by any spell (from self or others)
+    bool playerIsHit = false;
+    for (const auto& tgt : data.hitTargets) {
+        if (tgt == playerGuid) { playerIsHit = true; break; }
+    }
+    if (playerIsHit && data.casterUnit != playerGuid) {
+        if (auto* renderer = core::Application::getInstance().getRenderer()) {
+            if (auto* ssm = renderer->getSpellSoundManager()) {
+                loadSpellNameCache();
+                auto it = spellNameCache_.find(data.spellId);
+                auto school = (it != spellNameCache_.end() && it->second.schoolMask)
+                    ? schoolMaskToMagicSchool(it->second.schoolMask)
+                    : audio::SpellSoundManager::MagicSchool::ARCANE;
+                ssm->playImpact(school, audio::SpellSoundManager::SpellPower::MEDIUM);
+            }
+        }
+    }
+}
+
+void GameHandler::handleSpellCooldown(network::Packet& packet) {
+    SpellCooldownData data;
+    if (!SpellCooldownParser::parse(packet, data)) return;
+
+    for (const auto& [spellId, cooldownMs] : data.cooldowns) {
+        float seconds = cooldownMs / 1000.0f;
+        spellCooldowns[spellId] = seconds;
+        // Update action bar cooldowns
+        for (auto& slot : actionBar) {
+            if (slot.type == ActionBarSlot::SPELL && slot.id == spellId) {
+                slot.cooldownTotal = seconds;
+                slot.cooldownRemaining = seconds;
+            }
+        }
+    }
+}
+
+void GameHandler::handleCooldownEvent(network::Packet& packet) {
+    uint32_t spellId = packet.readUInt32();
+    // Cooldown finished
+    spellCooldowns.erase(spellId);
+    for (auto& slot : actionBar) {
+        if (slot.type == ActionBarSlot::SPELL && slot.id == spellId) {
+            slot.cooldownRemaining = 0.0f;
+        }
+    }
+}
+
+void GameHandler::handleAuraUpdate(network::Packet& packet, bool isAll) {
+    AuraUpdateData data;
+    if (!AuraUpdateParser::parse(packet, data, isAll)) return;
+
+    // Determine which aura list to update
+    std::vector<AuraSlot>* auraList = nullptr;
+    if (data.guid == playerGuid) {
+        auraList = &playerAuras;
+    } else if (data.guid == targetGuid) {
+        auraList = &targetAuras;
+    }
+
+    if (auraList) {
+        if (isAll) {
+            auraList->clear();
+        }
+        uint64_t nowMs = static_cast<uint64_t>(
+            std::chrono::duration_cast<std::chrono::milliseconds>(
+                std::chrono::steady_clock::now().time_since_epoch()).count());
+        for (auto [slot, aura] : data.updates) {
+            // Stamp client timestamp so the UI can count down duration locally
+            if (aura.durationMs >= 0) {
+                aura.receivedAtMs = nowMs;
+            }
+            // Ensure vector is large enough
+            while (auraList->size() <= slot) {
+                auraList->push_back(AuraSlot{});
+            }
+            (*auraList)[slot] = aura;
+        }
+
+        // If player is mounted but we haven't identified the mount aura yet,
+        // check newly added auras (aura update may arrive after mountDisplayId)
+        if (data.guid == playerGuid && currentMountDisplayId_ != 0 && mountAuraSpellId_ == 0) {
+            for (const auto& [slot, aura] : data.updates) {
+                if (!aura.isEmpty() && aura.maxDurationMs < 0 && aura.casterGuid == playerGuid) {
+                    mountAuraSpellId_ = aura.spellId;
+                    LOG_INFO("Mount aura detected from aura update: spellId=", aura.spellId);
+                }
+            }
+        }
+    }
+}
+
+void GameHandler::handleLearnedSpell(network::Packet& packet) {
+    uint32_t spellId = packet.readUInt32();
+    knownSpells.insert(spellId);
+    LOG_INFO("Learned spell: ", spellId);
+
+    // Check if this spell corresponds to a talent rank
+    for (const auto& [talentId, talent] : talentCache_) {
+        for (int rank = 0; rank < 5; ++rank) {
+            if (talent.rankSpells[rank] == spellId) {
+                // Found the talent! Update the rank for the active spec
+                uint8_t newRank = rank + 1; // rank is 0-indexed in array, but stored as 1-indexed
+                learnedTalents_[activeTalentSpec_][talentId] = newRank;
+                LOG_INFO("Talent learned: id=", talentId, " rank=", (int)newRank,
+                         " (spell ", spellId, ") in spec ", (int)activeTalentSpec_);
+                return;
+            }
+        }
+    }
+
+    // Show chat message for non-talent spells
+    const std::string& name = getSpellName(spellId);
+    if (!name.empty()) {
+        addSystemChatMessage("You have learned a new spell: " + name + ".");
+    } else {
+        addSystemChatMessage("You have learned a new spell.");
+    }
+}
+
+void GameHandler::handleRemovedSpell(network::Packet& packet) {
+    uint32_t spellId = packet.readUInt32();
+    knownSpells.erase(spellId);
+    LOG_INFO("Removed spell: ", spellId);
+}
+
+void GameHandler::handleSupercededSpell(network::Packet& packet) {
+    // Old spell replaced by new rank (e.g., Fireball Rank 1 -> Fireball Rank 2)
+    uint32_t oldSpellId = packet.readUInt32();
+    uint32_t newSpellId = packet.readUInt32();
+
+    // Remove old spell
+    knownSpells.erase(oldSpellId);
+
+    // Add new spell
+    knownSpells.insert(newSpellId);
+
+    LOG_INFO("Spell superceded: ", oldSpellId, " -> ", newSpellId);
+
+    const std::string& newName = getSpellName(newSpellId);
+    if (!newName.empty()) {
+        addSystemChatMessage("Upgraded to " + newName);
+    }
+}
+
+void GameHandler::handleUnlearnSpells(network::Packet& packet) {
+    // Sent when unlearning multiple spells (e.g., spec change, respec)
+    uint32_t spellCount = packet.readUInt32();
+    LOG_INFO("Unlearning ", spellCount, " spells");
+
+    for (uint32_t i = 0; i < spellCount && packet.getSize() - packet.getReadPos() >= 4; ++i) {
+        uint32_t spellId = packet.readUInt32();
+        knownSpells.erase(spellId);
+        LOG_INFO("  Unlearned spell: ", spellId);
+    }
+
+    if (spellCount > 0) {
+        addSystemChatMessage("Unlearned " + std::to_string(spellCount) + " spells");
+    }
 }
 
 // ============================================================
 // Talents
 // ============================================================
 
+void GameHandler::handleTalentsInfo(network::Packet& packet) {
+    TalentsInfoData data;
+    if (!TalentsInfoParser::parse(packet, data)) return;
+
+    // Ensure talent DBCs are loaded
+    loadTalentDbc();
+
+    // Validate spec number
+    if (data.talentSpec > 1) {
+        LOG_WARNING("Invalid talent spec: ", (int)data.talentSpec);
+        return;
+    }
+
+    // Store talents for this spec
+    unspentTalentPoints_[data.talentSpec] = data.unspentPoints;
+
+    // Clear and rebuild learned talents map for this spec
+    // Note: If a talent appears in the packet, it's learned (ranks are 0-indexed)
+    learnedTalents_[data.talentSpec].clear();
+    for (const auto& talent : data.talents) {
+        learnedTalents_[data.talentSpec][talent.talentId] = talent.currentRank;
+    }
+
+    LOG_INFO("Talents loaded: spec=", (int)data.talentSpec,
+             " unspent=", (int)unspentTalentPoints_[data.talentSpec],
+             " learned=", learnedTalents_[data.talentSpec].size());
+
+    // If this is the first spec received, set it as active
+    static bool firstSpecReceived = false;
+    if (!firstSpecReceived) {
+        firstSpecReceived = true;
+        activeTalentSpec_ = data.talentSpec;
+
+        // Show message to player about active spec
+        if (unspentTalentPoints_[data.talentSpec] > 0) {
+            std::string msg = "You have " + std::to_string(unspentTalentPoints_[data.talentSpec]) +
+                             " unspent talent point";
+            if (unspentTalentPoints_[data.talentSpec] > 1) msg += "s";
+            msg += " in spec " + std::to_string(data.talentSpec + 1);
+            addSystemChatMessage(msg);
+        }
+    }
+}
+
 void GameHandler::learnTalent(uint32_t talentId, uint32_t requestedRank) {
-    if (spellHandler_) spellHandler_->learnTalent(talentId, requestedRank);
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("learnTalent: Not in world or no socket connection");
+        return;
+    }
+
+    LOG_INFO("Requesting to learn talent: id=", talentId, " rank=", requestedRank);
+
+    auto packet = LearnTalentPacket::build(talentId, requestedRank);
+    socket->send(packet);
 }
 
 void GameHandler::switchTalentSpec(uint8_t newSpec) {
-    if (spellHandler_) spellHandler_->switchTalentSpec(newSpec);
-}
+    if (newSpec > 1) {
+        LOG_WARNING("Invalid talent spec: ", (int)newSpec);
+        return;
+    }
 
-void GameHandler::confirmPetUnlearn() {
-    if (spellHandler_) spellHandler_->confirmPetUnlearn();
-}
+    if (newSpec == activeTalentSpec_) {
+        LOG_INFO("Already on spec ", (int)newSpec);
+        return;
+    }
 
-void GameHandler::confirmTalentWipe() {
-    if (spellHandler_) spellHandler_->confirmTalentWipe();
-}
+    // For now, just switch locally. In a real implementation, we'd send
+    // MSG_TALENT_WIPE_CONFIRM to the server to trigger a spec switch.
+    // The server would respond with new SMSG_TALENTS_INFO for the new spec.
+    activeTalentSpec_ = newSpec;
 
-void GameHandler::sendAlterAppearance(uint32_t hairStyle, uint32_t hairColor, uint32_t facialHair) {
-    if (socialHandler_) socialHandler_->sendAlterAppearance(hairStyle, hairColor, facialHair);
+    LOG_INFO("Switched to talent spec ", (int)newSpec,
+             " (unspent=", (int)unspentTalentPoints_[newSpec],
+             ", learned=", learnedTalents_[newSpec].size(), ")");
+
+    std::string msg = "Switched to spec " + std::to_string(newSpec + 1);
+    if (unspentTalentPoints_[newSpec] > 0) {
+        msg += " (" + std::to_string(unspentTalentPoints_[newSpec]) + " unspent point";
+        if (unspentTalentPoints_[newSpec] > 1) msg += "s";
+        msg += ")";
+    }
+    addSystemChatMessage(msg);
 }
 
 // ============================================================
-// Group/Party
+// Phase 4: Group/Party
 // ============================================================
 
 void GameHandler::inviteToGroup(const std::string& playerName) {
-    if (socialHandler_) socialHandler_->inviteToGroup(playerName);
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = GroupInvitePacket::build(playerName);
+    socket->send(packet);
+    LOG_INFO("Inviting ", playerName, " to group");
 }
 
 void GameHandler::acceptGroupInvite() {
-    if (socialHandler_) socialHandler_->acceptGroupInvite();
+    if (state != WorldState::IN_WORLD || !socket) return;
+    pendingGroupInvite = false;
+    auto packet = GroupAcceptPacket::build();
+    socket->send(packet);
+    LOG_INFO("Accepted group invite");
 }
 
 void GameHandler::declineGroupInvite() {
-    if (socialHandler_) socialHandler_->declineGroupInvite();
+    if (state != WorldState::IN_WORLD || !socket) return;
+    pendingGroupInvite = false;
+    auto packet = GroupDeclinePacket::build();
+    socket->send(packet);
+    LOG_INFO("Declined group invite");
 }
 
 void GameHandler::leaveGroup() {
-    if (socialHandler_) socialHandler_->leaveGroup();
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = GroupDisbandPacket::build();
+    socket->send(packet);
+    partyData = GroupListData{};
+    LOG_INFO("Left group");
 }
 
-void GameHandler::convertToRaid() {
-    if (socialHandler_) socialHandler_->convertToRaid();
+void GameHandler::handleGroupInvite(network::Packet& packet) {
+    GroupInviteResponseData data;
+    if (!GroupInviteResponseParser::parse(packet, data)) return;
+
+    pendingGroupInvite = true;
+    pendingInviterName = data.inviterName;
+    LOG_INFO("Group invite from: ", data.inviterName);
+    if (!data.inviterName.empty()) {
+        addSystemChatMessage(data.inviterName + " has invited you to a group.");
+    }
 }
 
-void GameHandler::sendSetLootMethod(uint32_t method, uint32_t threshold, uint64_t masterLooterGuid) {
-    if (socialHandler_) socialHandler_->sendSetLootMethod(method, threshold, masterLooterGuid);
+void GameHandler::handleGroupDecline(network::Packet& packet) {
+    GroupDeclineData data;
+    if (!GroupDeclineResponseParser::parse(packet, data)) return;
+
+    MessageChatData msg;
+    msg.type = ChatType::SYSTEM;
+    msg.language = ChatLanguage::UNIVERSAL;
+    msg.message = data.playerName + " has declined your group invitation.";
+    addLocalChatMessage(msg);
+}
+
+void GameHandler::handleGroupList(network::Packet& packet) {
+    if (!GroupListParser::parse(packet, partyData)) return;
+
+    if (partyData.isEmpty()) {
+        LOG_INFO("No longer in a group");
+        addSystemChatMessage("You are no longer in a group.");
+    } else {
+        LOG_INFO("In group with ", partyData.memberCount, " members");
+        addSystemChatMessage("You are now in a group with " + std::to_string(partyData.memberCount) + " members.");
+    }
+}
+
+void GameHandler::handleGroupUninvite(network::Packet& packet) {
+    (void)packet;
+    partyData = GroupListData{};
+    LOG_INFO("Removed from group");
+
+    MessageChatData msg;
+    msg.type = ChatType::SYSTEM;
+    msg.language = ChatLanguage::UNIVERSAL;
+    msg.message = "You have been removed from the group.";
+    addLocalChatMessage(msg);
+}
+
+void GameHandler::handlePartyCommandResult(network::Packet& packet) {
+    PartyCommandResultData data;
+    if (!PartyCommandResultParser::parse(packet, data)) return;
+
+    if (data.result != PartyResult::OK) {
+        MessageChatData msg;
+        msg.type = ChatType::SYSTEM;
+        msg.language = ChatLanguage::UNIVERSAL;
+        msg.message = "Party command failed (error " + std::to_string(static_cast<uint32_t>(data.result)) + ")";
+        if (!data.name.empty()) msg.message += " for " + data.name;
+        addLocalChatMessage(msg);
+    }
+}
+
+void GameHandler::handlePartyMemberStats(network::Packet& packet, bool isFull) {
+    auto remaining = [&]() { return packet.getSize() - packet.getReadPos(); };
+
+    // Classic/TBC use uint16 for health fields and simpler aura format;
+    // WotLK uses uint32 health and uint32+uint8 per aura.
+    const bool isWotLK = isActiveExpansion("wotlk");
+
+    // SMSG_PARTY_MEMBER_STATS_FULL has a leading padding byte
+    if (isFull) {
+        if (remaining() < 1) return;
+        packet.readUInt8();
+    }
+
+    uint64_t memberGuid = UpdateObjectParser::readPackedGuid(packet);
+    if (remaining() < 4) return;
+    uint32_t updateFlags = packet.readUInt32();
+
+    // Find matching group member
+    game::GroupMember* member = nullptr;
+    for (auto& m : partyData.members) {
+        if (m.guid == memberGuid) {
+            member = &m;
+            break;
+        }
+    }
+    if (!member) {
+        packet.setReadPos(packet.getSize());
+        return;
+    }
+
+    // Parse each flag field in order
+    if (updateFlags & 0x0001) { // STATUS
+        if (remaining() >= 2)
+            member->onlineStatus = packet.readUInt16();
+    }
+    if (updateFlags & 0x0002) { // CUR_HP
+        if (isWotLK) {
+            if (remaining() >= 4)
+                member->curHealth = packet.readUInt32();
+        } else {
+            if (remaining() >= 2)
+                member->curHealth = packet.readUInt16();
+        }
+    }
+    if (updateFlags & 0x0004) { // MAX_HP
+        if (isWotLK) {
+            if (remaining() >= 4)
+                member->maxHealth = packet.readUInt32();
+        } else {
+            if (remaining() >= 2)
+                member->maxHealth = packet.readUInt16();
+        }
+    }
+    if (updateFlags & 0x0008) { // POWER_TYPE
+        if (remaining() >= 1)
+            member->powerType = packet.readUInt8();
+    }
+    if (updateFlags & 0x0010) { // CUR_POWER
+        if (remaining() >= 2)
+            member->curPower = packet.readUInt16();
+    }
+    if (updateFlags & 0x0020) { // MAX_POWER
+        if (remaining() >= 2)
+            member->maxPower = packet.readUInt16();
+    }
+    if (updateFlags & 0x0040) { // LEVEL
+        if (remaining() >= 2)
+            member->level = packet.readUInt16();
+    }
+    if (updateFlags & 0x0080) { // ZONE
+        if (remaining() >= 2)
+            member->zoneId = packet.readUInt16();
+    }
+    if (updateFlags & 0x0100) { // POSITION
+        if (remaining() >= 4) {
+            member->posX = static_cast<int16_t>(packet.readUInt16());
+            member->posY = static_cast<int16_t>(packet.readUInt16());
+        }
+    }
+    if (updateFlags & 0x0200) { // AURAS
+        if (remaining() >= 8) {
+            uint64_t auraMask = packet.readUInt64();
+            for (int i = 0; i < 64; ++i) {
+                if (auraMask & (uint64_t(1) << i)) {
+                    if (isWotLK) {
+                        // WotLK: uint32 spellId + uint8 auraFlags
+                        if (remaining() < 5) break;
+                        packet.readUInt32();
+                        packet.readUInt8();
+                    } else {
+                        // Classic/TBC: uint16 spellId only
+                        if (remaining() < 2) break;
+                        packet.readUInt16();
+                    }
+                }
+            }
+        }
+    }
+    if (updateFlags & 0x0400) { // PET_GUID
+        if (remaining() >= 8)
+            packet.readUInt64();
+    }
+    if (updateFlags & 0x0800) { // PET_NAME
+        if (remaining() > 0)
+            packet.readString();
+    }
+    if (updateFlags & 0x1000) { // PET_MODEL_ID
+        if (remaining() >= 2)
+            packet.readUInt16();
+    }
+    if (updateFlags & 0x2000) { // PET_CUR_HP
+        if (isWotLK) {
+            if (remaining() >= 4)
+                packet.readUInt32();
+        } else {
+            if (remaining() >= 2)
+                packet.readUInt16();
+        }
+    }
+    if (updateFlags & 0x4000) { // PET_MAX_HP
+        if (isWotLK) {
+            if (remaining() >= 4)
+                packet.readUInt32();
+        } else {
+            if (remaining() >= 2)
+                packet.readUInt16();
+        }
+    }
+    if (updateFlags & 0x8000) { // PET_POWER_TYPE
+        if (remaining() >= 1)
+            packet.readUInt8();
+    }
+    if (updateFlags & 0x10000) { // PET_CUR_POWER
+        if (remaining() >= 2)
+            packet.readUInt16();
+    }
+    if (updateFlags & 0x20000) { // PET_MAX_POWER
+        if (remaining() >= 2)
+            packet.readUInt16();
+    }
+    if (updateFlags & 0x40000) { // PET_AURAS
+        if (remaining() >= 8) {
+            uint64_t petAuraMask = packet.readUInt64();
+            for (int i = 0; i < 64; ++i) {
+                if (petAuraMask & (uint64_t(1) << i)) {
+                    if (isWotLK) {
+                        if (remaining() < 5) break;
+                        packet.readUInt32();
+                        packet.readUInt8();
+                    } else {
+                        if (remaining() < 2) break;
+                        packet.readUInt16();
+                    }
+                }
+            }
+        }
+    }
+    if (isWotLK && (updateFlags & 0x80000)) { // VEHICLE_SEAT (WotLK only)
+        if (remaining() >= 4)
+            packet.readUInt32();
+    }
+
+    member->hasPartyStats = true;
+    LOG_DEBUG("Party member stats for ", member->name,
+              ": HP=", member->curHealth, "/", member->maxHealth,
+              " Level=", member->level);
 }
 
 // ============================================================
@@ -5521,147 +12936,319 @@ void GameHandler::sendSetLootMethod(uint32_t method, uint32_t threshold, uint64_
 // ============================================================
 
 void GameHandler::kickGuildMember(const std::string& playerName) {
-    if (socialHandler_) socialHandler_->kickGuildMember(playerName);
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = GuildRemovePacket::build(playerName);
+    socket->send(packet);
+    LOG_INFO("Kicking guild member: ", playerName);
 }
 
 void GameHandler::disbandGuild() {
-    if (socialHandler_) socialHandler_->disbandGuild();
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = GuildDisbandPacket::build();
+    socket->send(packet);
+    LOG_INFO("Disbanding guild");
 }
 
 void GameHandler::setGuildLeader(const std::string& name) {
-    if (socialHandler_) socialHandler_->setGuildLeader(name);
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = GuildLeaderPacket::build(name);
+    socket->send(packet);
+    LOG_INFO("Setting guild leader: ", name);
 }
 
 void GameHandler::setGuildPublicNote(const std::string& name, const std::string& note) {
-    if (socialHandler_) socialHandler_->setGuildPublicNote(name, note);
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = GuildSetPublicNotePacket::build(name, note);
+    socket->send(packet);
+    LOG_INFO("Setting public note for ", name, ": ", note);
 }
 
 void GameHandler::setGuildOfficerNote(const std::string& name, const std::string& note) {
-    if (socialHandler_) socialHandler_->setGuildOfficerNote(name, note);
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = GuildSetOfficerNotePacket::build(name, note);
+    socket->send(packet);
+    LOG_INFO("Setting officer note for ", name, ": ", note);
 }
 
 void GameHandler::acceptGuildInvite() {
-    if (socialHandler_) socialHandler_->acceptGuildInvite();
+    if (state != WorldState::IN_WORLD || !socket) return;
+    pendingGuildInvite_ = false;
+    auto packet = GuildAcceptPacket::build();
+    socket->send(packet);
+    LOG_INFO("Accepted guild invite");
 }
 
 void GameHandler::declineGuildInvite() {
-    if (socialHandler_) socialHandler_->declineGuildInvite();
-}
-
-void GameHandler::submitGmTicket(const std::string& text) {
-    if (chatHandler_) chatHandler_->submitGmTicket(text);
-}
-
-void GameHandler::deleteGmTicket() {
-    if (socialHandler_) socialHandler_->deleteGmTicket();
-}
-
-void GameHandler::requestGmTicket() {
-    if (socialHandler_) socialHandler_->requestGmTicket();
+    if (state != WorldState::IN_WORLD || !socket) return;
+    pendingGuildInvite_ = false;
+    auto packet = GuildDeclineInvitationPacket::build();
+    socket->send(packet);
+    LOG_INFO("Declined guild invite");
 }
 
 void GameHandler::queryGuildInfo(uint32_t guildId) {
-    if (socialHandler_) socialHandler_->queryGuildInfo(guildId);
-}
-
-static const std::string kEmptyString;
-
-const std::string& GameHandler::lookupGuildName(uint32_t guildId) {
-    static const std::string kEmpty;
-    if (socialHandler_) return socialHandler_->lookupGuildName(guildId);
-    return kEmpty;
-}
-
-uint32_t GameHandler::getEntityGuildId(uint64_t guid) const {
-    if (socialHandler_) return socialHandler_->getEntityGuildId(guid);
-    return 0;
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = GuildQueryPacket::build(guildId);
+    socket->send(packet);
+    LOG_INFO("Querying guild info: guildId=", guildId);
 }
 
 void GameHandler::createGuild(const std::string& guildName) {
-    if (socialHandler_) socialHandler_->createGuild(guildName);
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = GuildCreatePacket::build(guildName);
+    socket->send(packet);
+    LOG_INFO("Creating guild: ", guildName);
 }
 
 void GameHandler::addGuildRank(const std::string& rankName) {
-    if (socialHandler_) socialHandler_->addGuildRank(rankName);
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = GuildAddRankPacket::build(rankName);
+    socket->send(packet);
+    LOG_INFO("Adding guild rank: ", rankName);
+    // Refresh roster to update rank list
+    requestGuildRoster();
 }
 
 void GameHandler::deleteGuildRank() {
-    if (socialHandler_) socialHandler_->deleteGuildRank();
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = GuildDelRankPacket::build();
+    socket->send(packet);
+    LOG_INFO("Deleting last guild rank");
+    // Refresh roster to update rank list
+    requestGuildRoster();
 }
 
 void GameHandler::requestPetitionShowlist(uint64_t npcGuid) {
-    if (socialHandler_) socialHandler_->requestPetitionShowlist(npcGuid);
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = PetitionShowlistPacket::build(npcGuid);
+    socket->send(packet);
 }
 
 void GameHandler::buyPetition(uint64_t npcGuid, const std::string& guildName) {
-    if (socialHandler_) socialHandler_->buyPetition(npcGuid, guildName);
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = PetitionBuyPacket::build(npcGuid, guildName);
+    socket->send(packet);
+    LOG_INFO("Buying guild petition: ", guildName);
 }
 
-void GameHandler::signPetition(uint64_t petitionGuid) {
-    if (socialHandler_) socialHandler_->signPetition(petitionGuid);
+void GameHandler::handlePetitionShowlist(network::Packet& packet) {
+    PetitionShowlistData data;
+    if (!PetitionShowlistParser::parse(packet, data)) return;
+
+    petitionNpcGuid_ = data.npcGuid;
+    petitionCost_ = data.cost;
+    showPetitionDialog_ = true;
+    LOG_INFO("Petition showlist: cost=", data.cost);
 }
 
-void GameHandler::turnInPetition(uint64_t petitionGuid) {
-    if (socialHandler_) socialHandler_->turnInPetition(petitionGuid);
+void GameHandler::handleTurnInPetitionResults(network::Packet& packet) {
+    uint32_t result = 0;
+    if (!TurnInPetitionResultsParser::parse(packet, result)) return;
+
+    switch (result) {
+        case 0: addSystemChatMessage("Guild created successfully!"); break;
+        case 1: addSystemChatMessage("Guild creation failed: already in a guild."); break;
+        case 2: addSystemChatMessage("Guild creation failed: not enough signatures."); break;
+        case 3: addSystemChatMessage("Guild creation failed: name already taken."); break;
+        default: addSystemChatMessage("Guild creation failed (error " + std::to_string(result) + ")."); break;
+    }
+}
+
+void GameHandler::handleGuildInfo(network::Packet& packet) {
+    GuildInfoData data;
+    if (!GuildInfoParser::parse(packet, data)) return;
+
+    guildInfoData_ = data;
+    addSystemChatMessage("Guild: " + data.guildName + " (" +
+                         std::to_string(data.numMembers) + " members, " +
+                         std::to_string(data.numAccounts) + " accounts)");
+}
+
+void GameHandler::handleGuildRoster(network::Packet& packet) {
+    GuildRosterData data;
+    if (!packetParsers_->parseGuildRoster(packet, data)) return;
+
+    guildRoster_ = std::move(data);
+    hasGuildRoster_ = true;
+    LOG_INFO("Guild roster received: ", guildRoster_.members.size(), " members");
+}
+
+void GameHandler::handleGuildQueryResponse(network::Packet& packet) {
+    GuildQueryResponseData data;
+    if (!packetParsers_->parseGuildQueryResponse(packet, data)) return;
+
+    guildName_ = data.guildName;
+    guildQueryData_ = data;
+    guildRankNames_.clear();
+    for (uint32_t i = 0; i < 10; ++i) {
+        guildRankNames_.push_back(data.rankNames[i]);
+    }
+    LOG_INFO("Guild name set to: ", guildName_);
+    addSystemChatMessage("Guild: <" + guildName_ + ">");
+}
+
+void GameHandler::handleGuildEvent(network::Packet& packet) {
+    GuildEventData data;
+    if (!GuildEventParser::parse(packet, data)) return;
+
+    std::string msg;
+    switch (data.eventType) {
+        case GuildEvent::PROMOTION:
+            if (data.numStrings >= 3)
+                msg = data.strings[0] + " has promoted " + data.strings[1] + " to " + data.strings[2] + ".";
+            break;
+        case GuildEvent::DEMOTION:
+            if (data.numStrings >= 3)
+                msg = data.strings[0] + " has demoted " + data.strings[1] + " to " + data.strings[2] + ".";
+            break;
+        case GuildEvent::MOTD:
+            if (data.numStrings >= 1)
+                msg = "Guild MOTD: " + data.strings[0];
+            break;
+        case GuildEvent::JOINED:
+            if (data.numStrings >= 1)
+                msg = data.strings[0] + " has joined the guild.";
+            break;
+        case GuildEvent::LEFT:
+            if (data.numStrings >= 1)
+                msg = data.strings[0] + " has left the guild.";
+            break;
+        case GuildEvent::REMOVED:
+            if (data.numStrings >= 2)
+                msg = data.strings[1] + " has been kicked from the guild by " + data.strings[0] + ".";
+            break;
+        case GuildEvent::LEADER_IS:
+            if (data.numStrings >= 1)
+                msg = data.strings[0] + " is the guild leader.";
+            break;
+        case GuildEvent::LEADER_CHANGED:
+            if (data.numStrings >= 2)
+                msg = data.strings[0] + " has made " + data.strings[1] + " the new guild leader.";
+            break;
+        case GuildEvent::DISBANDED:
+            msg = "Guild has been disbanded.";
+            guildName_.clear();
+            guildRankNames_.clear();
+            guildRoster_ = GuildRosterData{};
+            hasGuildRoster_ = false;
+            break;
+        case GuildEvent::SIGNED_ON:
+            if (data.numStrings >= 1)
+                msg = "[Guild] " + data.strings[0] + " has come online.";
+            break;
+        case GuildEvent::SIGNED_OFF:
+            if (data.numStrings >= 1)
+                msg = "[Guild] " + data.strings[0] + " has gone offline.";
+            break;
+        default:
+            msg = "Guild event " + std::to_string(data.eventType);
+            break;
+    }
+
+    if (!msg.empty()) {
+        MessageChatData chatMsg;
+        chatMsg.type = ChatType::GUILD;
+        chatMsg.language = ChatLanguage::UNIVERSAL;
+        chatMsg.message = msg;
+        addLocalChatMessage(chatMsg);
+    }
+
+    // Auto-refresh roster after membership/rank changes
+    switch (data.eventType) {
+        case GuildEvent::PROMOTION:
+        case GuildEvent::DEMOTION:
+        case GuildEvent::JOINED:
+        case GuildEvent::LEFT:
+        case GuildEvent::REMOVED:
+        case GuildEvent::LEADER_CHANGED:
+            if (hasGuildRoster_) requestGuildRoster();
+            break;
+        default:
+            break;
+    }
+}
+
+void GameHandler::handleGuildInvite(network::Packet& packet) {
+    GuildInviteResponseData data;
+    if (!GuildInviteResponseParser::parse(packet, data)) return;
+
+    pendingGuildInvite_ = true;
+    pendingGuildInviterName_ = data.inviterName;
+    pendingGuildInviteGuildName_ = data.guildName;
+    LOG_INFO("Guild invite from: ", data.inviterName, " to guild: ", data.guildName);
+    addSystemChatMessage(data.inviterName + " has invited you to join " + data.guildName + ".");
+}
+
+void GameHandler::handleGuildCommandResult(network::Packet& packet) {
+    GuildCommandResultData data;
+    if (!GuildCommandResultParser::parse(packet, data)) return;
+
+    if (data.errorCode != 0) {
+        std::string msg = "Guild command failed";
+        if (!data.name.empty()) msg += " for " + data.name;
+        msg += " (error " + std::to_string(data.errorCode) + ")";
+        addSystemChatMessage(msg);
+    }
 }
 
 // ============================================================
-// Loot, Gossip, Vendor
+// Phase 5: Loot, Gossip, Vendor
 // ============================================================
 
 void GameHandler::lootTarget(uint64_t guid) {
-    if (inventoryHandler_) inventoryHandler_->lootTarget(guid);
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = LootPacket::build(guid);
+    socket->send(packet);
 }
 
 void GameHandler::lootItem(uint8_t slotIndex) {
-    if (inventoryHandler_) inventoryHandler_->lootItem(slotIndex);
+    if (state != WorldState::IN_WORLD || !socket) return;
+    auto packet = AutostoreLootItemPacket::build(slotIndex);
+    socket->send(packet);
 }
 
 void GameHandler::closeLoot() {
-    if (inventoryHandler_) inventoryHandler_->closeLoot();
-}
-
-void GameHandler::lootMasterGive(uint8_t lootSlot, uint64_t targetGuid) {
-    if (inventoryHandler_) inventoryHandler_->lootMasterGive(lootSlot, targetGuid);
+    if (!lootWindowOpen) return;
+    lootWindowOpen = false;
+    if (currentLoot.lootGuid != 0 && targetGuid == currentLoot.lootGuid) {
+        clearTarget();
+    }
+    if (state == WorldState::IN_WORLD && socket) {
+        auto packet = LootReleasePacket::build(currentLoot.lootGuid);
+        socket->send(packet);
+    }
+    currentLoot = LootResponseData{};
 }
 
 void GameHandler::interactWithNpc(uint64_t guid) {
-    if (!isInWorld()) return;
+    if (state != WorldState::IN_WORLD || !socket) return;
     auto packet = GossipHelloPacket::build(guid);
     socket->send(packet);
 }
 
 void GameHandler::interactWithGameObject(uint64_t guid) {
-    LOG_WARNING("[GO-DIAG] interactWithGameObject called: guid=0x", std::hex, guid, std::dec);
-    if (guid == 0) { LOG_WARNING("[GO-DIAG] BLOCKED: guid==0"); return; }
-    if (!isInWorld()) { LOG_WARNING("[GO-DIAG] BLOCKED: not in world"); return; }
+    if (guid == 0) return;
+    if (state != WorldState::IN_WORLD || !socket) return;
     // Do not overlap an actual spell cast.
-    if (spellHandler_ && spellHandler_->casting_ && spellHandler_->currentCastSpellId_ != 0) {
-        LOG_WARNING("[GO-DIAG] BLOCKED: already casting spellId=", spellHandler_->currentCastSpellId_);
-        return;
-    }
+    if (casting && currentCastSpellId != 0) return;
     // Always clear melee intent before GO interactions.
     stopAutoAttack();
-    // Set the pending GO guid so that:
-    // 1. cancelCast() won't send CMSG_CANCEL_CAST for GO-triggered casts
-    //    (e.g., "Opening" on a quest chest) — without this, any movement
-    //    during the cast cancels it server-side and quest credit is lost.
-    // 2. The cast-completion fallback in update() can call
-    //    performGameObjectInteractionNow after the cast timer expires.
-    // 3. isGameObjectInteractionCasting() returns true during GO casts.
-    pendingGameObjectInteractGuid_ = guid;
+    // Interact immediately; server drives any real cast/channel feedback.
+    pendingGameObjectInteractGuid_ = 0;
     performGameObjectInteractionNow(guid);
 }
 
 void GameHandler::performGameObjectInteractionNow(uint64_t guid) {
     if (guid == 0) return;
-    if (!isInWorld()) return;
+    if (state != WorldState::IN_WORLD || !socket) return;
+    bool turtleMode = isActiveExpansion("turtle");
+
     // Rate-limit to prevent spamming the server
     static uint64_t lastInteractGuid = 0;
     static std::chrono::steady_clock::time_point lastInteractTime{};
     auto now = std::chrono::steady_clock::now();
     // Keep duplicate suppression, but allow quick retry clicks.
-    constexpr int64_t minRepeatMs = 150;
+    int64_t minRepeatMs = turtleMode ? 150 : 150;
     if (guid == lastInteractGuid &&
         std::chrono::duration_cast<std::chrono::milliseconds>(now - lastInteractTime).count() < minRepeatMs) {
         return;
@@ -5671,7 +13258,7 @@ void GameHandler::performGameObjectInteractionNow(uint64_t guid) {
 
     // Ensure GO interaction isn't blocked by stale or active melee state.
     stopAutoAttack();
-    auto entity = entityController_->getEntityManager().getEntity(guid);
+    auto entity = entityManager.getEntity(guid);
     uint32_t goEntry = 0;
     uint32_t goType = 0;
     std::string goName;
@@ -5697,21 +13284,10 @@ void GameHandler::performGameObjectInteractionNow(uint64_t guid) {
         float dy = entity->getY() - movementInfo.y;
         float dz = entity->getZ() - movementInfo.z;
         float dist3d = std::sqrt(dx * dx + dy * dy + dz * dz);
-        if (dist3d > 10.0f) {
+        if (dist3d > 6.0f) {
             addSystemChatMessage("Too far away.");
             return;
         }
-        // Stop movement before interacting — servers may reject GO use or
-        // immediately cancel the resulting spell cast if the player is moving.
-        const uint32_t moveFlags = movementInfo.flags;
-        const bool isMoving = (moveFlags & 0x00000001u) || // FORWARD
-                              (moveFlags & 0x00000002u) || // BACKWARD
-                              (moveFlags & 0x00000004u) || // STRAFE_LEFT
-                              (moveFlags & 0x00000008u);   // STRAFE_RIGHT
-        if (isMoving) {
-            movementInfo.flags &= ~0x0000000Fu; // clear directional movement flags
-            sendMovement(Opcode::MSG_MOVE_STOP);
-        }
         if (std::abs(dx) > 0.01f || std::abs(dy) > 0.01f) {
             movementInfo.orientation = std::atan2(-dy, dx);
             sendMovement(Opcode::MSG_MOVE_SET_FACING);
@@ -5719,308 +13295,882 @@ void GameHandler::performGameObjectInteractionNow(uint64_t guid) {
         sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
     }
 
-    // Determine GO type for interaction strategy
+    auto packet = GameObjectUsePacket::build(guid);
+    socket->send(packet);
+
+    // For mailbox GameObjects (type 19), open mail UI and request mail list.
+    // In Vanilla/Classic there is no SMSG_SHOW_MAILBOX — the server just sends
+    // animation/sound and expects the client to request the mail list.
     bool isMailbox = false;
     bool chestLike = false;
+    // Stock-like behavior: GO use opens GO loot context. Keep eager CMSG_LOOT only
+    // as Classic/Turtle fallback behavior.
+    bool shouldSendLoot = isActiveExpansion("classic") || isActiveExpansion("turtle");
     if (entity && entity->getType() == ObjectType::GAMEOBJECT) {
         auto go = std::static_pointer_cast<GameObject>(entity);
         auto* info = getCachedGameObjectInfo(go->getEntry());
         if (info && info->type == 19) {
             isMailbox = true;
+            shouldSendLoot = false;
+            LOG_INFO("Mailbox interaction: opening mail UI and requesting mail list");
+            mailboxGuid_ = guid;
+            mailboxOpen_ = true;
+            hasNewMail_ = false;
+            selectedMailIndex_ = -1;
+            showMailCompose_ = false;
+            refreshMailList();
         } else if (info && info->type == 3) {
             chestLike = true;
+        } else if (turtleMode) {
+            // Turtle compatibility: keep eager loot open behavior.
+            shouldSendLoot = true;
         }
     }
     if (!chestLike && !goName.empty()) {
         std::string lower = goName;
         std::transform(lower.begin(), lower.end(), lower.begin(),
                        [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-        chestLike = (lower.find("chest") != std::string::npos ||
-                     lower.find("lockbox") != std::string::npos ||
-                     lower.find("strongbox") != std::string::npos ||
-                     lower.find("coffer") != std::string::npos ||
-                     lower.find("cache") != std::string::npos ||
-                     lower.find("bundle") != std::string::npos);
+        chestLike = (lower.find("chest") != std::string::npos);
     }
-
-    LOG_INFO("GO interaction: guid=0x", std::hex, guid, std::dec,
-             " entry=", goEntry, " type=", goType,
-             " name='", goName, "' chestLike=", chestLike, " isMailbox=", isMailbox);
-
-    // Always send CMSG_GAMEOBJ_USE first — this triggers the server-side
-    // GameObject::Use() handler for all GO types.
-    auto usePacket = GameObjectUsePacket::build(guid);
-    socket->send(usePacket);
-    lastInteractedGoGuid_ = guid;
-
-    if (chestLike) {
-        // Don't send CMSG_LOOT immediately — the server may start a timed cast
-        // (e.g., "Opening") and the GO isn't lootable until the cast finishes.
-        // Sending LOOT prematurely gets an empty response or is silently dropped,
-        // which can interfere with the server's loot state machine.
-        // Instead, handleSpellGo will send LOOT after the cast completes
-        // (using lastInteractedGoGuid_ set above). For instant-open chests
-        // (no cast), the server sends SMSG_LOOT_RESPONSE directly after USE.
-    } else if (isMailbox) {
-        openMailbox(guid);
-    }
-
-    // CMSG_GAMEOBJ_REPORT_USE triggers GO AI scripts (SmartAI, ScriptAI) which
-    // is where many quest objectives grant credit. Previously this was only sent
-    // for non-chest GOs, so chest-type quest objectives (Bundle of Wood, etc.)
-    // never triggered the server-side quest credit script.
-    if (!isMailbox) {
-        const auto* table = getActiveOpcodeTable();
-        if (table && table->hasOpcode(Opcode::CMSG_GAMEOBJ_REPORT_USE)) {
+    // For WotLK chest-like gameobjects, report use but let server open loot.
+    if (!isMailbox && chestLike) {
+        if (isActiveExpansion("wotlk")) {
             network::Packet reportUse(wireOpcode(Opcode::CMSG_GAMEOBJ_REPORT_USE));
             reportUse.writeUInt64(guid);
             socket->send(reportUse);
         }
     }
+    if (shouldSendLoot) {
+        lootTarget(guid);
+    }
+    // Retry use briefly to survive packet loss/order races. Keep loot retries only
+    // when we intentionally use eager loot-open mode.
+    const bool retryLoot = shouldSendLoot && (turtleMode || isActiveExpansion("classic"));
+    const bool retryUse = turtleMode || isActiveExpansion("classic");
+    if (retryUse || retryLoot) {
+        pendingGameObjectLootRetries_.push_back(PendingLootRetry{guid, 0.15f, 2, retryLoot});
+    }
 }
 
 void GameHandler::selectGossipOption(uint32_t optionId) {
-    if (questHandler_) questHandler_->selectGossipOption(optionId);
+    if (state != WorldState::IN_WORLD || !socket || !gossipWindowOpen) return;
+    LOG_INFO("selectGossipOption: optionId=", optionId,
+             " npcGuid=0x", std::hex, currentGossip.npcGuid, std::dec,
+             " menuId=", currentGossip.menuId,
+             " numOptions=", currentGossip.options.size());
+    auto packet = GossipSelectOptionPacket::build(currentGossip.npcGuid, currentGossip.menuId, optionId);
+    socket->send(packet);
+
+    for (const auto& opt : currentGossip.options) {
+        if (opt.id != optionId) continue;
+        LOG_INFO("  matched option: id=", opt.id, " icon=", (int)opt.icon, " text='", opt.text, "'");
+
+        // Icon-based NPC interaction fallbacks
+        // Some servers need the specific activate packet in addition to gossip select
+        if (opt.icon == 6) {
+            // GOSSIP_ICON_MONEY_BAG = banker
+            auto pkt = BankerActivatePacket::build(currentGossip.npcGuid);
+            socket->send(pkt);
+            LOG_INFO("Sent CMSG_BANKER_ACTIVATE for npc=0x", std::hex, currentGossip.npcGuid, std::dec);
+        }
+
+        // Text-based NPC type detection for servers using placeholder strings
+        std::string text = opt.text;
+        std::string textLower = text;
+        std::transform(textLower.begin(), textLower.end(), textLower.begin(),
+                       [](unsigned char c){ return static_cast<char>(std::tolower(c)); });
+
+        if (text == "GOSSIP_OPTION_AUCTIONEER" || textLower.find("auction") != std::string::npos) {
+            auto pkt = AuctionHelloPacket::build(currentGossip.npcGuid);
+            socket->send(pkt);
+            LOG_INFO("Sent MSG_AUCTION_HELLO for npc=0x", std::hex, currentGossip.npcGuid, std::dec);
+        }
+
+        if (text == "GOSSIP_OPTION_BANKER" || textLower.find("deposit box") != std::string::npos) {
+            auto pkt = BankerActivatePacket::build(currentGossip.npcGuid);
+            socket->send(pkt);
+            LOG_INFO("Sent CMSG_BANKER_ACTIVATE for npc=0x", std::hex, currentGossip.npcGuid, std::dec);
+        }
+
+        if (textLower.find("make this inn your home") != std::string::npos ||
+            textLower.find("set your home") != std::string::npos) {
+            auto bindPkt = BinderActivatePacket::build(currentGossip.npcGuid);
+            socket->send(bindPkt);
+            LOG_INFO("Sent CMSG_BINDER_ACTIVATE for npc=0x", std::hex, currentGossip.npcGuid, std::dec);
+        }
+        break;
+    }
 }
 
 void GameHandler::selectGossipQuest(uint32_t questId) {
-    if (questHandler_) questHandler_->selectGossipQuest(questId);
-}
+    if (state != WorldState::IN_WORLD || !socket || !gossipWindowOpen) return;
 
-bool GameHandler::requestQuestQuery(uint32_t questId, bool force) {
-    return questHandler_ && questHandler_->requestQuestQuery(questId, force);
-}
-
-bool GameHandler::hasQuestInLog(uint32_t questId) const {
-    return questHandler_ && questHandler_->hasQuestInLog(questId);
-}
-
-Unit* GameHandler::getUnitByGuid(uint64_t guid) {
-    auto entity = entityController_->getEntityManager().getEntity(guid);
-    return entity ? dynamic_cast<Unit*>(entity.get()) : nullptr;
-}
-
-std::string GameHandler::guidToUnitId(uint64_t guid) const {
-    if (guid == playerGuid)      return "player";
-    if (guid == targetGuid)      return "target";
-    if (guid == focusGuid)       return "focus";
-    if (guid == petGuid_)        return "pet";
-    return {};
-}
-
-std::string GameHandler::getQuestTitle(uint32_t questId) const {
-    for (const auto& q : questLog_)
-        if (q.questId == questId && !q.title.empty()) return q.title;
-    return {};
-}
-
-const GameHandler::QuestLogEntry* GameHandler::findQuestLogEntry(uint32_t questId) const {
-    for (const auto& q : questLog_)
-        if (q.questId == questId) return &q;
-    return nullptr;
-}
-
-int GameHandler::findQuestLogSlotIndexFromServer(uint32_t questId) const {
-    if (questHandler_) return questHandler_->findQuestLogSlotIndexFromServer(questId);
-    return 0;
-}
-
-void GameHandler::addQuestToLocalLogIfMissing(uint32_t questId, const std::string& title, const std::string& objectives) {
-    if (questHandler_) questHandler_->addQuestToLocalLogIfMissing(questId, title, objectives);
-}
-
-bool GameHandler::resyncQuestLogFromServerSlots(bool forceQueryMetadata) {
-    return questHandler_ && questHandler_->resyncQuestLogFromServerSlots(forceQueryMetadata);
-}
-
-// Apply quest completion state from player update fields to already-tracked local quests.
-// Called from VALUES update handler so quests that complete mid-session (or that were
-// complete on login) get quest.complete=true without waiting for SMSG_QUESTUPDATE_COMPLETE.
-void GameHandler::applyQuestStateFromFields(const std::map<uint16_t, uint32_t>& fields) {
-    if (questHandler_) questHandler_->applyQuestStateFromFields(fields);
-}
-
-// Extract packed 6-bit kill/objective counts from WotLK/TBC/Classic quest-log update fields
-// and populate quest.killCounts + quest.itemCounts using the structured objectives obtained
-// from a prior SMSG_QUEST_QUERY_RESPONSE.  Silently does nothing if objectives are absent.
-void GameHandler::applyPackedKillCountsFromFields(QuestLogEntry& quest) {
-    if (questHandler_) questHandler_->applyPackedKillCountsFromFields(quest);
-}
-
-void GameHandler::clearPendingQuestAccept(uint32_t questId) {
-    if (questHandler_) questHandler_->clearPendingQuestAccept(questId);
-}
-
-void GameHandler::triggerQuestAcceptResync(uint32_t questId, uint64_t npcGuid, const char* reason) {
-    if (questHandler_) questHandler_->triggerQuestAcceptResync(questId, npcGuid, reason);
-}
-
-void GameHandler::acceptQuest() {
-    if (questHandler_) questHandler_->acceptQuest();
-}
-
-void GameHandler::declineQuest() {
-    if (questHandler_) questHandler_->declineQuest();
-}
-
-void GameHandler::abandonQuest(uint32_t questId) {
-    if (questHandler_) questHandler_->abandonQuest(questId);
-}
-
-void GameHandler::shareQuestWithParty(uint32_t questId) {
-    if (questHandler_) questHandler_->shareQuestWithParty(questId);
-}
-
-void GameHandler::completeQuest() {
-    if (questHandler_) questHandler_->completeQuest();
-}
-
-void GameHandler::closeQuestRequestItems() {
-    if (questHandler_) questHandler_->closeQuestRequestItems();
-}
-
-void GameHandler::chooseQuestReward(uint32_t rewardIndex) {
-    if (questHandler_) questHandler_->chooseQuestReward(rewardIndex);
-}
-
-void GameHandler::closeQuestOfferReward() {
-    if (questHandler_) questHandler_->closeQuestOfferReward();
-}
-
-void GameHandler::closeGossip() {
-    if (questHandler_) questHandler_->closeGossip();
-}
-
-void GameHandler::offerQuestFromItem(uint64_t itemGuid, uint32_t questId) {
-    if (questHandler_) questHandler_->offerQuestFromItem(itemGuid, questId);
-}
-
-uint64_t GameHandler::getBagItemGuid(int bagIndex, int slotIndex) const {
-    if (bagIndex < 0 || bagIndex >= inventory.NUM_BAG_SLOTS) return 0;
-    if (slotIndex < 0) return 0;
-    uint64_t bagGuid = equipSlotGuids_[Inventory::FIRST_BAG_EQUIP_SLOT + bagIndex];
-    if (bagGuid == 0) return 0;
-    auto it = containerContents_.find(bagGuid);
-    if (it == containerContents_.end()) return 0;
-    if (slotIndex >= static_cast<int>(it->second.numSlots)) return 0;
-    return it->second.slotGuids[slotIndex];
-}
-
-void GameHandler::openVendor(uint64_t npcGuid) {
-    if (inventoryHandler_) inventoryHandler_->openVendor(npcGuid);
-}
-
-void GameHandler::closeVendor() {
-    if (inventoryHandler_) inventoryHandler_->closeVendor();
-}
-
-void GameHandler::buyItem(uint64_t vendorGuid, uint32_t itemId, uint32_t slot, uint32_t count) {
-    if (inventoryHandler_) inventoryHandler_->buyItem(vendorGuid, itemId, slot, count);
-}
-
-void GameHandler::buyBackItem(uint32_t buybackSlot) {
-    if (inventoryHandler_) inventoryHandler_->buyBackItem(buybackSlot);
-}
-
-void GameHandler::repairItem(uint64_t vendorGuid, uint64_t itemGuid) {
-    if (inventoryHandler_) inventoryHandler_->repairItem(vendorGuid, itemGuid);
-}
-
-void GameHandler::repairAll(uint64_t vendorGuid, bool useGuildBank) {
-    if (inventoryHandler_) inventoryHandler_->repairAll(vendorGuid, useGuildBank);
-}
-
-uint32_t GameHandler::estimateRepairAllCost() const {
-    if (inventoryHandler_) return inventoryHandler_->estimateRepairAllCost();
-    return 0;
-}
-
-void GameHandler::sellItem(uint64_t vendorGuid, uint64_t itemGuid, uint32_t count) {
-    if (inventoryHandler_) inventoryHandler_->sellItem(vendorGuid, itemGuid, count);
-}
-
-void GameHandler::sellItemBySlot(int backpackIndex) {
-    if (inventoryHandler_) inventoryHandler_->sellItemBySlot(backpackIndex);
-}
-
-void GameHandler::autoEquipItemBySlot(int backpackIndex) {
-    if (inventoryHandler_) inventoryHandler_->autoEquipItemBySlot(backpackIndex);
-}
-
-void GameHandler::autoEquipItemInBag(int bagIndex, int slotIndex) {
-    if (inventoryHandler_) inventoryHandler_->autoEquipItemInBag(bagIndex, slotIndex);
-}
-
-void GameHandler::sellItemInBag(int bagIndex, int slotIndex) {
-    if (inventoryHandler_) inventoryHandler_->sellItemInBag(bagIndex, slotIndex);
-}
-
-void GameHandler::unequipToBackpack(EquipSlot equipSlot) {
-    if (inventoryHandler_) inventoryHandler_->unequipToBackpack(equipSlot);
-}
-
-void GameHandler::swapContainerItems(uint8_t srcBag, uint8_t srcSlot, uint8_t dstBag, uint8_t dstSlot) {
-    if (inventoryHandler_) inventoryHandler_->swapContainerItems(srcBag, srcSlot, dstBag, dstSlot);
-}
-
-void GameHandler::swapBagSlots(int srcBagIndex, int dstBagIndex) {
-    if (inventoryHandler_) inventoryHandler_->swapBagSlots(srcBagIndex, dstBagIndex);
-}
-
-void GameHandler::destroyItem(uint8_t bag, uint8_t slot, uint8_t count) {
-    if (inventoryHandler_) inventoryHandler_->destroyItem(bag, slot, count);
-}
-
-void GameHandler::splitItem(uint8_t srcBag, uint8_t srcSlot, uint8_t count) {
-    if (inventoryHandler_) inventoryHandler_->splitItem(srcBag, srcSlot, count);
-}
-
-void GameHandler::useItemBySlot(int backpackIndex) {
-    if (inventoryHandler_) inventoryHandler_->useItemBySlot(backpackIndex);
-}
-
-void GameHandler::useItemInBag(int bagIndex, int slotIndex) {
-    if (inventoryHandler_) inventoryHandler_->useItemInBag(bagIndex, slotIndex);
-}
-
-void GameHandler::openItemBySlot(int backpackIndex) {
-    if (inventoryHandler_) inventoryHandler_->openItemBySlot(backpackIndex);
-}
-
-void GameHandler::openItemInBag(int bagIndex, int slotIndex) {
-    if (inventoryHandler_) inventoryHandler_->openItemInBag(bagIndex, slotIndex);
-}
-
-void GameHandler::useItemById(uint32_t itemId) {
-    if (inventoryHandler_) inventoryHandler_->useItemById(itemId);
-}
-
-uint32_t GameHandler::getItemIdForSpell(uint32_t spellId) const {
-    if (spellId == 0) return 0;
-    // Search backpack and bags for an item whose on-use spell matches
-    for (int i = 0; i < inventory.getBackpackSize(); i++) {
-        const auto& slot = inventory.getBackpackSlot(i);
-        if (slot.empty()) continue;
-        auto* info = getItemInfo(slot.item.itemId);
-        if (!info || !info->valid) continue;
-        for (const auto& sp : info->spells) {
-            if (sp.spellId == spellId && (sp.spellTrigger == 0 || sp.spellTrigger == 5))
-                return slot.item.itemId;
+    // Keep quest-log fallback for servers that don't provide stable icon semantics.
+    const QuestLogEntry* activeQuest = nullptr;
+    for (const auto& q : questLog_) {
+        if (q.questId == questId) {
+            activeQuest = &q;
+            break;
         }
     }
-    for (int bag = 0; bag < inventory.NUM_BAG_SLOTS; bag++) {
-        for (int s = 0; s < inventory.getBagSize(bag); s++) {
-            const auto& slot = inventory.getBagSlot(bag, s);
-            if (slot.empty()) continue;
-            auto* info = getItemInfo(slot.item.itemId);
-            if (!info || !info->valid) continue;
-            for (const auto& sp : info->spells) {
-                if (sp.spellId == spellId && (sp.spellTrigger == 0 || sp.spellTrigger == 5))
-                    return slot.item.itemId;
+
+    // Validate against server-auth quest slot fields to avoid stale local entries
+    // forcing turn-in flow for quests that are not actually accepted.
+    auto questInServerLogSlots = [&](uint32_t qid) -> bool {
+        if (qid == 0 || lastPlayerFields_.empty()) return false;
+        const uint16_t ufQuestStart = fieldIndex(UF::PLAYER_QUEST_LOG_START);
+        const uint8_t qStride = packetParsers_ ? packetParsers_->questLogStride() : 5;
+        const uint16_t ufQuestEnd = ufQuestStart + 25 * qStride;
+        for (const auto& [key, val] : lastPlayerFields_) {
+            if (key < ufQuestStart || key >= ufQuestEnd) continue;
+            if ((key - ufQuestStart) % qStride != 0) continue;
+            if (val == qid) return true;
+        }
+        return false;
+    };
+    const bool questInServerLog = questInServerLogSlots(questId);
+    if (questInServerLog && !activeQuest) {
+        addQuestToLocalLogIfMissing(questId, "Quest #" + std::to_string(questId), "");
+        requestQuestQuery(questId, false);
+        for (const auto& q : questLog_) {
+            if (q.questId == questId) {
+                activeQuest = &q;
+                break;
             }
         }
     }
-    return 0;
+    const bool activeQuestConfirmedByServer = questInServerLog;
+    // Only trust server quest-log slots for deciding "already accepted" flow.
+    // Gossip icon values can differ across cores/expansions and misclassify
+    // available quests as active, which blocks acceptance.
+    const bool shouldStartProgressFlow = activeQuestConfirmedByServer;
+    if (shouldStartProgressFlow) {
+        pendingTurnInQuestId_ = questId;
+        pendingTurnInNpcGuid_ = currentGossip.npcGuid;
+        pendingTurnInRewardRequest_ = activeQuest ? activeQuest->complete : false;
+        auto packet = QuestgiverCompleteQuestPacket::build(currentGossip.npcGuid, questId);
+        socket->send(packet);
+    } else {
+        pendingTurnInQuestId_ = 0;
+        pendingTurnInNpcGuid_ = 0;
+        pendingTurnInRewardRequest_ = false;
+        auto packet = packetParsers_
+            ? packetParsers_->buildQueryQuestPacket(currentGossip.npcGuid, questId)
+            : QuestgiverQueryQuestPacket::build(currentGossip.npcGuid, questId);
+        socket->send(packet);
+    }
+
+    gossipWindowOpen = false;
+}
+
+bool GameHandler::requestQuestQuery(uint32_t questId, bool force) {
+    if (questId == 0 || state != WorldState::IN_WORLD || !socket) return false;
+    if (!force && pendingQuestQueryIds_.count(questId)) return false;
+
+    network::Packet pkt(wireOpcode(Opcode::CMSG_QUEST_QUERY));
+    pkt.writeUInt32(questId);
+    socket->send(pkt);
+    pendingQuestQueryIds_.insert(questId);
+    return true;
+}
+
+void GameHandler::handleQuestDetails(network::Packet& packet) {
+    QuestDetailsData data;
+    bool ok = packetParsers_ ? packetParsers_->parseQuestDetails(packet, data)
+                              : QuestDetailsParser::parse(packet, data);
+    if (!ok) {
+        LOG_WARNING("Failed to parse SMSG_QUESTGIVER_QUEST_DETAILS");
+        return;
+    }
+    currentQuestDetails = data;
+    for (auto& q : questLog_) {
+        if (q.questId != data.questId) continue;
+        if (!data.title.empty() && (isPlaceholderQuestTitle(q.title) || data.title.size() >= q.title.size())) {
+            q.title = data.title;
+        }
+        if (!data.objectives.empty() && (q.objectives.empty() || data.objectives.size() > q.objectives.size())) {
+            q.objectives = data.objectives;
+        }
+        break;
+    }
+    questDetailsOpen = true;
+    gossipWindowOpen = false;
+}
+
+bool GameHandler::hasQuestInLog(uint32_t questId) const {
+    for (const auto& q : questLog_) {
+        if (q.questId == questId) return true;
+    }
+    return false;
+}
+
+int GameHandler::findQuestLogSlotIndexFromServer(uint32_t questId) const {
+    if (questId == 0 || lastPlayerFields_.empty()) return -1;
+    const uint16_t ufQuestStart = fieldIndex(UF::PLAYER_QUEST_LOG_START);
+    const uint8_t qStride = packetParsers_ ? packetParsers_->questLogStride() : 5;
+    for (uint16_t slot = 0; slot < 25; ++slot) {
+        const uint16_t idField = ufQuestStart + slot * qStride;
+        auto it = lastPlayerFields_.find(idField);
+        if (it != lastPlayerFields_.end() && it->second == questId) {
+            return static_cast<int>(slot);
+        }
+    }
+    return -1;
+}
+
+void GameHandler::addQuestToLocalLogIfMissing(uint32_t questId, const std::string& title, const std::string& objectives) {
+    if (questId == 0 || hasQuestInLog(questId)) return;
+    QuestLogEntry entry;
+    entry.questId = questId;
+    entry.title = title.empty() ? ("Quest #" + std::to_string(questId)) : title;
+    entry.objectives = objectives;
+    questLog_.push_back(std::move(entry));
+}
+
+bool GameHandler::resyncQuestLogFromServerSlots(bool forceQueryMetadata) {
+    if (lastPlayerFields_.empty()) return false;
+
+    const uint16_t ufQuestStart = fieldIndex(UF::PLAYER_QUEST_LOG_START);
+    const uint8_t qStride = packetParsers_ ? packetParsers_->questLogStride() : 5;
+    std::unordered_set<uint32_t> serverQuestIds;
+    serverQuestIds.reserve(25);
+    for (uint16_t slot = 0; slot < 25; ++slot) {
+        const uint16_t idField = ufQuestStart + slot * qStride;
+        auto it = lastPlayerFields_.find(idField);
+        if (it == lastPlayerFields_.end()) continue;
+        if (it->second != 0) serverQuestIds.insert(it->second);
+    }
+
+    const size_t localBefore = questLog_.size();
+    std::erase_if(questLog_, [&](const QuestLogEntry& q) {
+        return q.questId == 0 || serverQuestIds.count(q.questId) == 0;
+    });
+    const size_t removed = localBefore - questLog_.size();
+
+    size_t added = 0;
+    for (uint32_t questId : serverQuestIds) {
+        if (hasQuestInLog(questId)) continue;
+        addQuestToLocalLogIfMissing(questId, "Quest #" + std::to_string(questId), "");
+        ++added;
+    }
+
+    if (forceQueryMetadata) {
+        for (uint32_t questId : serverQuestIds) {
+            requestQuestQuery(questId, false);
+        }
+    }
+
+    LOG_INFO("Quest log resync from server slots: server=", serverQuestIds.size(),
+             " localBefore=", localBefore, " removed=", removed, " added=", added);
+    return true;
+}
+
+void GameHandler::clearPendingQuestAccept(uint32_t questId) {
+    pendingQuestAcceptTimeouts_.erase(questId);
+    pendingQuestAcceptNpcGuids_.erase(questId);
+}
+
+void GameHandler::triggerQuestAcceptResync(uint32_t questId, uint64_t npcGuid, const char* reason) {
+    if (questId == 0 || !socket || state != WorldState::IN_WORLD) return;
+
+    LOG_INFO("Quest accept resync: questId=", questId, " reason=", reason ? reason : "unknown");
+    requestQuestQuery(questId, true);
+
+    if (npcGuid != 0) {
+        network::Packet qsPkt(wireOpcode(Opcode::CMSG_QUESTGIVER_STATUS_QUERY));
+        qsPkt.writeUInt64(npcGuid);
+        socket->send(qsPkt);
+
+        auto queryPkt = packetParsers_
+            ? packetParsers_->buildQueryQuestPacket(npcGuid, questId)
+            : QuestgiverQueryQuestPacket::build(npcGuid, questId);
+        socket->send(queryPkt);
+    }
+}
+
+void GameHandler::acceptQuest() {
+    if (!questDetailsOpen || state != WorldState::IN_WORLD || !socket) return;
+    const uint32_t questId = currentQuestDetails.questId;
+    if (questId == 0) return;
+    uint64_t npcGuid = currentQuestDetails.npcGuid;
+    if (pendingQuestAcceptTimeouts_.count(questId) != 0) {
+        LOG_DEBUG("Ignoring duplicate quest accept while pending: questId=", questId);
+        triggerQuestAcceptResync(questId, npcGuid, "duplicate-accept");
+        questDetailsOpen = false;
+        currentQuestDetails = QuestDetailsData{};
+        return;
+    }
+    const bool inLocalLog = hasQuestInLog(questId);
+    const int serverSlot = findQuestLogSlotIndexFromServer(questId);
+    if (serverSlot >= 0) {
+        LOG_INFO("Ignoring duplicate quest accept already in server quest log: questId=", questId,
+                 " slot=", serverSlot);
+        questDetailsOpen = false;
+        currentQuestDetails = QuestDetailsData{};
+        return;
+    }
+    if (inLocalLog) {
+        LOG_WARNING("Quest accept local/server mismatch, allowing re-accept: questId=", questId);
+        std::erase_if(questLog_, [&](const QuestLogEntry& q) { return q.questId == questId; });
+    }
+
+    network::Packet packet = packetParsers_
+        ? packetParsers_->buildAcceptQuestPacket(npcGuid, questId)
+        : QuestgiverAcceptQuestPacket::build(npcGuid, questId);
+    socket->send(packet);
+    pendingQuestAcceptTimeouts_[questId] = 5.0f;
+    pendingQuestAcceptNpcGuids_[questId] = npcGuid;
+
+    questDetailsOpen = false;
+    currentQuestDetails = QuestDetailsData{};
+
+    // Re-query quest giver status so marker updates (! → ?)
+    if (npcGuid) {
+        network::Packet qsPkt(wireOpcode(Opcode::CMSG_QUESTGIVER_STATUS_QUERY));
+        qsPkt.writeUInt64(npcGuid);
+        socket->send(qsPkt);
+    }
+}
+
+void GameHandler::declineQuest() {
+    questDetailsOpen = false;
+    currentQuestDetails = QuestDetailsData{};
+}
+
+void GameHandler::abandonQuest(uint32_t questId) {
+    clearPendingQuestAccept(questId);
+    int localIndex = -1;
+    for (size_t i = 0; i < questLog_.size(); ++i) {
+        if (questLog_[i].questId == questId) {
+            localIndex = static_cast<int>(i);
+            break;
+        }
+    }
+
+    int slotIndex = findQuestLogSlotIndexFromServer(questId);
+    if (slotIndex < 0 && localIndex >= 0) {
+        // Best-effort fallback if update fields are stale/missing.
+        slotIndex = localIndex;
+        LOG_WARNING("Abandon quest using local slot fallback: questId=", questId, " slot=", slotIndex);
+    }
+
+    if (slotIndex >= 0 && slotIndex < 25) {
+        if (state == WorldState::IN_WORLD && socket) {
+            network::Packet pkt(wireOpcode(Opcode::CMSG_QUESTLOG_REMOVE_QUEST));
+            pkt.writeUInt8(static_cast<uint8_t>(slotIndex));
+            socket->send(pkt);
+        }
+    } else {
+        LOG_WARNING("Abandon quest failed: no quest-log slot found for questId=", questId);
+    }
+
+    if (localIndex >= 0) {
+        questLog_.erase(questLog_.begin() + static_cast<ptrdiff_t>(localIndex));
+    }
+}
+
+void GameHandler::handleQuestRequestItems(network::Packet& packet) {
+    QuestRequestItemsData data;
+    if (!QuestRequestItemsParser::parse(packet, data)) {
+        LOG_WARNING("Failed to parse SMSG_QUESTGIVER_REQUEST_ITEMS");
+        return;
+    }
+    clearPendingQuestAccept(data.questId);
+
+    // Expansion-safe fallback: COMPLETE_QUEST is the default flow.
+    // If a server echoes REQUEST_ITEMS again while still completable,
+    // request the reward explicitly once.
+    if (pendingTurnInRewardRequest_ &&
+        data.questId == pendingTurnInQuestId_ &&
+        data.npcGuid == pendingTurnInNpcGuid_ &&
+        data.isCompletable() &&
+        socket) {
+        auto rewardReq = QuestgiverRequestRewardPacket::build(data.npcGuid, data.questId);
+        socket->send(rewardReq);
+        pendingTurnInRewardRequest_ = false;
+    }
+
+    currentQuestRequestItems_ = data;
+    questRequestItemsOpen_ = true;
+    gossipWindowOpen = false;
+    questDetailsOpen = false;
+
+    // Query item names for required items
+    for (const auto& item : data.requiredItems) {
+        queryItemInfo(item.itemId, 0);
+    }
+
+    // Server-authoritative turn-in requirements: sync quest-log summary so
+    // UI doesn't show stale/inferred objective numbers.
+    for (auto& q : questLog_) {
+        if (q.questId != data.questId) continue;
+        q.complete = data.isCompletable();
+        q.requiredItemCounts.clear();
+
+        std::ostringstream oss;
+        if (!data.completionText.empty()) {
+            oss << data.completionText;
+            if (!data.requiredItems.empty() || data.requiredMoney > 0) oss << "\n\n";
+        }
+        if (!data.requiredItems.empty()) {
+            oss << "Required items:";
+            for (const auto& item : data.requiredItems) {
+                std::string itemLabel = "Item " + std::to_string(item.itemId);
+                if (const auto* info = getItemInfo(item.itemId)) {
+                    if (!info->name.empty()) itemLabel = info->name;
+                }
+                q.requiredItemCounts[item.itemId] = item.count;
+                oss << "\n- " << itemLabel << " x" << item.count;
+            }
+        }
+        if (data.requiredMoney > 0) {
+            if (!data.requiredItems.empty()) oss << "\n";
+            oss << "\nRequired money: " << formatCopperAmount(data.requiredMoney);
+        }
+        q.objectives = oss.str();
+        break;
+    }
+}
+
+void GameHandler::handleQuestOfferReward(network::Packet& packet) {
+    QuestOfferRewardData data;
+    if (!QuestOfferRewardParser::parse(packet, data)) {
+        LOG_WARNING("Failed to parse SMSG_QUESTGIVER_OFFER_REWARD");
+        return;
+    }
+    clearPendingQuestAccept(data.questId);
+    LOG_INFO("Quest offer reward: questId=", data.questId, " title=\"", data.title, "\"");
+    if (pendingTurnInQuestId_ == data.questId) {
+        pendingTurnInQuestId_ = 0;
+        pendingTurnInNpcGuid_ = 0;
+        pendingTurnInRewardRequest_ = false;
+    }
+    currentQuestOfferReward_ = data;
+    questOfferRewardOpen_ = true;
+    questRequestItemsOpen_ = false;
+    gossipWindowOpen = false;
+    questDetailsOpen = false;
+
+    // Query item names for reward items
+    for (const auto& item : data.choiceRewards)
+        queryItemInfo(item.itemId, 0);
+    for (const auto& item : data.fixedRewards)
+        queryItemInfo(item.itemId, 0);
+}
+
+void GameHandler::completeQuest() {
+    if (!questRequestItemsOpen_ || state != WorldState::IN_WORLD || !socket) return;
+    pendingTurnInQuestId_ = currentQuestRequestItems_.questId;
+    pendingTurnInNpcGuid_ = currentQuestRequestItems_.npcGuid;
+    pendingTurnInRewardRequest_ = currentQuestRequestItems_.isCompletable();
+
+    // Default quest turn-in flow used by all branches.
+    auto packet = QuestgiverCompleteQuestPacket::build(
+        currentQuestRequestItems_.npcGuid, currentQuestRequestItems_.questId);
+    socket->send(packet);
+    questRequestItemsOpen_ = false;
+    currentQuestRequestItems_ = QuestRequestItemsData{};
+}
+
+void GameHandler::closeQuestRequestItems() {
+    pendingTurnInRewardRequest_ = false;
+    questRequestItemsOpen_ = false;
+    currentQuestRequestItems_ = QuestRequestItemsData{};
+}
+
+void GameHandler::chooseQuestReward(uint32_t rewardIndex) {
+    if (!questOfferRewardOpen_ || state != WorldState::IN_WORLD || !socket) return;
+    uint64_t npcGuid = currentQuestOfferReward_.npcGuid;
+    LOG_INFO("Completing quest: questId=", currentQuestOfferReward_.questId,
+             " npcGuid=", npcGuid, " rewardIndex=", rewardIndex);
+    auto packet = QuestgiverChooseRewardPacket::build(
+        npcGuid, currentQuestOfferReward_.questId, rewardIndex);
+    socket->send(packet);
+    pendingTurnInQuestId_ = 0;
+    pendingTurnInNpcGuid_ = 0;
+    pendingTurnInRewardRequest_ = false;
+    questOfferRewardOpen_ = false;
+    currentQuestOfferReward_ = QuestOfferRewardData{};
+
+    // Re-query quest giver status so markers update
+    if (npcGuid) {
+        network::Packet qsPkt(wireOpcode(Opcode::CMSG_QUESTGIVER_STATUS_QUERY));
+        qsPkt.writeUInt64(npcGuid);
+        socket->send(qsPkt);
+    }
+}
+
+void GameHandler::closeQuestOfferReward() {
+    pendingTurnInRewardRequest_ = false;
+    questOfferRewardOpen_ = false;
+    currentQuestOfferReward_ = QuestOfferRewardData{};
+}
+
+void GameHandler::closeGossip() {
+    gossipWindowOpen = false;
+    currentGossip = GossipMessageData{};
+}
+
+void GameHandler::openVendor(uint64_t npcGuid) {
+    if (state != WorldState::IN_WORLD || !socket) return;
+    buybackItems_.clear();
+    auto packet = ListInventoryPacket::build(npcGuid);
+    socket->send(packet);
+}
+
+void GameHandler::closeVendor() {
+    vendorWindowOpen = false;
+    currentVendorItems = ListInventoryData{};
+    buybackItems_.clear();
+    pendingSellToBuyback_.clear();
+    pendingBuybackSlot_ = -1;
+    pendingBuybackWireSlot_ = 0;
+    pendingBuyItemId_ = 0;
+    pendingBuyItemSlot_ = 0;
+}
+
+void GameHandler::buyItem(uint64_t vendorGuid, uint32_t itemId, uint32_t slot, uint32_t count) {
+    if (state != WorldState::IN_WORLD || !socket) return;
+    LOG_INFO("Buy request: vendorGuid=0x", std::hex, vendorGuid, std::dec,
+             " itemId=", itemId, " slot=", slot, " count=", count,
+             " wire=0x", std::hex, wireOpcode(Opcode::CMSG_BUY_ITEM), std::dec);
+    pendingBuyItemId_ = itemId;
+    pendingBuyItemSlot_ = slot;
+    // Build directly to avoid helper-signature drift across branches (3-arg vs 4-arg helper).
+    network::Packet packet(wireOpcode(Opcode::CMSG_BUY_ITEM));
+    packet.writeUInt64(vendorGuid);
+    packet.writeUInt32(itemId); // item entry
+    packet.writeUInt32(slot);   // vendor slot index
+    packet.writeUInt32(count);
+    // WotLK/AzerothCore expects a trailing byte here.
+    packet.writeUInt8(0);
+    socket->send(packet);
+}
+
+void GameHandler::buyBackItem(uint32_t buybackSlot) {
+    if (state != WorldState::IN_WORLD || !socket || currentVendorItems.vendorGuid == 0) return;
+    // AzerothCore/WotLK expects absolute buyback inventory slot IDs, not 0-based UI row index.
+    // BUYBACK_SLOT_START is 74 in this protocol family.
+    constexpr uint32_t kBuybackSlotStart = 74;
+    uint32_t wireSlot = kBuybackSlotStart + buybackSlot;
+    // This request is independent from normal buy path; avoid stale pending buy context in logs.
+    pendingBuyItemId_ = 0;
+    pendingBuyItemSlot_ = 0;
+    // Build directly so this compiles even when Opcode::CMSG_BUYBACK_ITEM / BuybackItemPacket
+    // are not available in some branches.
+    constexpr uint16_t kWotlkCmsgBuybackItemOpcode = 0x290;
+    LOG_INFO("Buyback request: vendorGuid=0x", std::hex, currentVendorItems.vendorGuid,
+             std::dec, " uiSlot=", buybackSlot, " wireSlot=", wireSlot,
+             " source=absolute-buyback-slot",
+             " wire=0x", std::hex, kWotlkCmsgBuybackItemOpcode, std::dec);
+    pendingBuybackSlot_ = static_cast<int>(buybackSlot);
+    pendingBuybackWireSlot_ = wireSlot;
+    network::Packet packet(kWotlkCmsgBuybackItemOpcode);
+    packet.writeUInt64(currentVendorItems.vendorGuid);
+    packet.writeUInt32(wireSlot);
+    socket->send(packet);
+}
+
+void GameHandler::sellItem(uint64_t vendorGuid, uint64_t itemGuid, uint32_t count) {
+    if (state != WorldState::IN_WORLD || !socket) return;
+    LOG_INFO("Sell request: vendorGuid=0x", std::hex, vendorGuid,
+             " itemGuid=0x", itemGuid, std::dec,
+             " count=", count, " wire=0x", std::hex, wireOpcode(Opcode::CMSG_SELL_ITEM), std::dec);
+    auto packet = SellItemPacket::build(vendorGuid, itemGuid, count);
+    socket->send(packet);
+}
+
+void GameHandler::sellItemBySlot(int backpackIndex) {
+    if (backpackIndex < 0 || backpackIndex >= inventory.getBackpackSize()) return;
+    const auto& slot = inventory.getBackpackSlot(backpackIndex);
+    if (slot.empty()) return;
+
+    uint32_t sellPrice = slot.item.sellPrice;
+    if (sellPrice == 0) {
+        if (auto* info = getItemInfo(slot.item.itemId); info && info->valid) {
+            sellPrice = info->sellPrice;
+        }
+    }
+    if (sellPrice == 0) {
+        addSystemChatMessage("Cannot sell: this item has no vendor value.");
+        return;
+    }
+
+    uint64_t itemGuid = backpackSlotGuids_[backpackIndex];
+    if (itemGuid == 0) {
+        itemGuid = resolveOnlineItemGuid(slot.item.itemId);
+    }
+    LOG_DEBUG("sellItemBySlot: slot=", backpackIndex,
+              " item=", slot.item.name,
+              " itemGuid=0x", std::hex, itemGuid, std::dec,
+              " vendorGuid=0x", std::hex, currentVendorItems.vendorGuid, std::dec);
+    if (itemGuid != 0 && currentVendorItems.vendorGuid != 0) {
+        BuybackItem sold;
+        sold.itemGuid = itemGuid;
+        sold.item = slot.item;
+        sold.count = 1;
+        buybackItems_.push_front(sold);
+        if (buybackItems_.size() > 12) buybackItems_.pop_back();
+        pendingSellToBuyback_[itemGuid] = sold;
+        sellItem(currentVendorItems.vendorGuid, itemGuid, 1);
+    } else if (itemGuid == 0) {
+        addSystemChatMessage("Cannot sell: item not found in inventory.");
+        LOG_WARNING("Sell failed: missing item GUID for slot ", backpackIndex);
+    } else {
+        addSystemChatMessage("Cannot sell: no vendor.");
+    }
+}
+
+void GameHandler::autoEquipItemBySlot(int backpackIndex) {
+    if (backpackIndex < 0 || backpackIndex >= inventory.getBackpackSize()) return;
+    const auto& slot = inventory.getBackpackSlot(backpackIndex);
+    if (slot.empty()) return;
+
+    if (state == WorldState::IN_WORLD && socket) {
+        // WoW inventory: equipment 0-18, bags 19-22, backpack 23-38
+        auto packet = AutoEquipItemPacket::build(0xFF, static_cast<uint8_t>(23 + backpackIndex));
+        socket->send(packet);
+    }
+}
+
+void GameHandler::autoEquipItemInBag(int bagIndex, int slotIndex) {
+    if (bagIndex < 0 || bagIndex >= inventory.NUM_BAG_SLOTS) return;
+    if (slotIndex < 0 || slotIndex >= inventory.getBagSize(bagIndex)) return;
+
+    if (state == WorldState::IN_WORLD && socket) {
+        // Bag items: bag = equip slot 19+bagIndex, slot = index within bag
+        auto packet = AutoEquipItemPacket::build(
+            static_cast<uint8_t>(19 + bagIndex), static_cast<uint8_t>(slotIndex));
+        socket->send(packet);
+    }
+}
+
+void GameHandler::sellItemInBag(int bagIndex, int slotIndex) {
+    if (bagIndex < 0 || bagIndex >= inventory.NUM_BAG_SLOTS) return;
+    if (slotIndex < 0 || slotIndex >= inventory.getBagSize(bagIndex)) return;
+    const auto& slot = inventory.getBagSlot(bagIndex, slotIndex);
+    if (slot.empty()) return;
+
+    uint32_t sellPrice = slot.item.sellPrice;
+    if (sellPrice == 0) {
+        if (auto* info = getItemInfo(slot.item.itemId); info && info->valid) {
+            sellPrice = info->sellPrice;
+        }
+    }
+    if (sellPrice == 0) {
+        addSystemChatMessage("Cannot sell: this item has no vendor value.");
+        return;
+    }
+
+    // Resolve item GUID from container contents
+    uint64_t itemGuid = 0;
+    uint64_t bagGuid = equipSlotGuids_[19 + bagIndex];
+    if (bagGuid != 0) {
+        auto it = containerContents_.find(bagGuid);
+        if (it != containerContents_.end() && slotIndex < static_cast<int>(it->second.numSlots)) {
+            itemGuid = it->second.slotGuids[slotIndex];
+        }
+    }
+    if (itemGuid == 0) {
+        itemGuid = resolveOnlineItemGuid(slot.item.itemId);
+    }
+
+    if (itemGuid != 0 && currentVendorItems.vendorGuid != 0) {
+        BuybackItem sold;
+        sold.itemGuid = itemGuid;
+        sold.item = slot.item;
+        sold.count = 1;
+        buybackItems_.push_front(sold);
+        if (buybackItems_.size() > 12) buybackItems_.pop_back();
+        pendingSellToBuyback_[itemGuid] = sold;
+        sellItem(currentVendorItems.vendorGuid, itemGuid, 1);
+    } else if (itemGuid == 0) {
+        addSystemChatMessage("Cannot sell: item not found.");
+    } else {
+        addSystemChatMessage("Cannot sell: no vendor.");
+    }
+}
+
+void GameHandler::unequipToBackpack(EquipSlot equipSlot) {
+    if (state != WorldState::IN_WORLD || !socket) return;
+
+    int freeSlot = inventory.findFreeBackpackSlot();
+    if (freeSlot < 0) {
+        addSystemChatMessage("Cannot unequip: no free backpack slots.");
+        return;
+    }
+
+    // Use SWAP_ITEM for cross-container moves. For inventory slots we address bag as 0xFF.
+    uint8_t srcBag = 0xFF;
+    uint8_t srcSlot = static_cast<uint8_t>(equipSlot);
+    uint8_t dstBag = 0xFF;
+    uint8_t dstSlot = static_cast<uint8_t>(23 + freeSlot);
+
+    LOG_INFO("UnequipToBackpack: equipSlot=", (int)srcSlot,
+             " -> backpackIndex=", freeSlot, " (dstSlot=", (int)dstSlot, ")");
+
+    auto packet = SwapItemPacket::build(dstBag, dstSlot, srcBag, srcSlot);
+    socket->send(packet);
+}
+
+void GameHandler::swapContainerItems(uint8_t srcBag, uint8_t srcSlot, uint8_t dstBag, uint8_t dstSlot) {
+    if (!socket || !socket->isConnected()) return;
+    LOG_INFO("swapContainerItems: src(bag=", (int)srcBag, " slot=", (int)srcSlot,
+             ") -> dst(bag=", (int)dstBag, " slot=", (int)dstSlot, ")");
+    auto packet = SwapItemPacket::build(dstBag, dstSlot, srcBag, srcSlot);
+    socket->send(packet);
+}
+
+void GameHandler::swapBagSlots(int srcBagIndex, int dstBagIndex) {
+    if (srcBagIndex < 0 || srcBagIndex > 3 || dstBagIndex < 0 || dstBagIndex > 3) return;
+    if (srcBagIndex == dstBagIndex) return;
+
+    // Local swap for immediate visual feedback
+    auto srcEquip = static_cast<game::EquipSlot>(static_cast<int>(game::EquipSlot::BAG1) + srcBagIndex);
+    auto dstEquip = static_cast<game::EquipSlot>(static_cast<int>(game::EquipSlot::BAG1) + dstBagIndex);
+    auto srcItem = inventory.getEquipSlot(srcEquip).item;
+    auto dstItem = inventory.getEquipSlot(dstEquip).item;
+    inventory.setEquipSlot(srcEquip, dstItem);
+    inventory.setEquipSlot(dstEquip, srcItem);
+
+    // Also swap bag contents locally
+    inventory.swapBagContents(srcBagIndex, dstBagIndex);
+
+    // Send to server using CMSG_SWAP_ITEM with INVENTORY_SLOT_BAG_0 (255)
+    // CMSG_SWAP_INV_ITEM doesn't support bag equip slots (19-22)
+    if (socket && socket->isConnected()) {
+        uint8_t srcSlot = static_cast<uint8_t>(19 + srcBagIndex);
+        uint8_t dstSlot = static_cast<uint8_t>(19 + dstBagIndex);
+        LOG_INFO("swapBagSlots: bag ", srcBagIndex, " (slot ", (int)srcSlot,
+                 ") <-> bag ", dstBagIndex, " (slot ", (int)dstSlot, ")");
+        auto packet = SwapItemPacket::build(255, dstSlot, 255, srcSlot);
+        socket->send(packet);
+    }
+}
+
+void GameHandler::destroyItem(uint8_t bag, uint8_t slot, uint8_t count) {
+    if (state != WorldState::IN_WORLD || !socket) return;
+    if (count == 0) count = 1;
+
+    // AzerothCore WotLK expects CMSG_DESTROYITEM(bag:u8, slot:u8, count:u32).
+    // This opcode is currently not modeled as a logical opcode in our table.
+    constexpr uint16_t kCmsgDestroyItem = 0x111;
+    network::Packet packet(kCmsgDestroyItem);
+    packet.writeUInt8(bag);
+    packet.writeUInt8(slot);
+    packet.writeUInt32(static_cast<uint32_t>(count));
+    LOG_DEBUG("Destroy item request: bag=", (int)bag, " slot=", (int)slot,
+              " count=", (int)count, " wire=0x", std::hex, kCmsgDestroyItem, std::dec);
+    socket->send(packet);
+}
+
+void GameHandler::useItemBySlot(int backpackIndex) {
+    if (backpackIndex < 0 || backpackIndex >= inventory.getBackpackSize()) return;
+    const auto& slot = inventory.getBackpackSlot(backpackIndex);
+    if (slot.empty()) return;
+
+    uint64_t itemGuid = backpackSlotGuids_[backpackIndex];
+    if (itemGuid == 0) {
+        itemGuid = resolveOnlineItemGuid(slot.item.itemId);
+    }
+
+    if (itemGuid != 0 && state == WorldState::IN_WORLD && socket) {
+        // Find the item's on-use spell ID from cached item info
+        uint32_t useSpellId = 0;
+        if (auto* info = getItemInfo(slot.item.itemId)) {
+            for (const auto& sp : info->spells) {
+                // SpellTrigger: 0=Use, 5=Learn
+                if (sp.spellId != 0 && (sp.spellTrigger == 0 || sp.spellTrigger == 5)) {
+                    useSpellId = sp.spellId;
+                    break;
+                }
+            }
+        }
+
+        // WoW inventory: equipment 0-18, bags 19-22, backpack 23-38
+        auto packet = packetParsers_
+            ? packetParsers_->buildUseItem(0xFF, static_cast<uint8_t>(23 + backpackIndex), itemGuid, useSpellId)
+            : UseItemPacket::build(0xFF, static_cast<uint8_t>(23 + backpackIndex), itemGuid, useSpellId);
+        socket->send(packet);
+    } else if (itemGuid == 0) {
+        addSystemChatMessage("Cannot use that item right now.");
+    }
+}
+
+void GameHandler::useItemInBag(int bagIndex, int slotIndex) {
+    if (bagIndex < 0 || bagIndex >= inventory.NUM_BAG_SLOTS) return;
+    if (slotIndex < 0 || slotIndex >= inventory.getBagSize(bagIndex)) return;
+    const auto& slot = inventory.getBagSlot(bagIndex, slotIndex);
+    if (slot.empty()) return;
+
+    // Resolve item GUID from container contents
+    uint64_t itemGuid = 0;
+    uint64_t bagGuid = equipSlotGuids_[19 + bagIndex];
+    if (bagGuid != 0) {
+        auto it = containerContents_.find(bagGuid);
+        if (it != containerContents_.end() && slotIndex < static_cast<int>(it->second.numSlots)) {
+            itemGuid = it->second.slotGuids[slotIndex];
+        }
+    }
+    if (itemGuid == 0) {
+        itemGuid = resolveOnlineItemGuid(slot.item.itemId);
+    }
+
+    LOG_INFO("useItemInBag: bag=", bagIndex, " slot=", slotIndex, " itemId=", slot.item.itemId,
+             " itemGuid=0x", std::hex, itemGuid, std::dec);
+
+    if (itemGuid != 0 && state == WorldState::IN_WORLD && socket) {
+        // Find the item's on-use spell ID
+        uint32_t useSpellId = 0;
+        if (auto* info = getItemInfo(slot.item.itemId)) {
+            for (const auto& sp : info->spells) {
+                if (sp.spellId != 0 && (sp.spellTrigger == 0 || sp.spellTrigger == 5)) {
+                    useSpellId = sp.spellId;
+                    break;
+                }
+            }
+        }
+
+        // WoW bag addressing: bagIndex = equip slot of bag container (19-22)
+        // For CMSG_USE_ITEM: bag = 19+bagIndex, slot = slot within bag
+        uint8_t wowBag = static_cast<uint8_t>(19 + bagIndex);
+        auto packet = packetParsers_
+            ? packetParsers_->buildUseItem(wowBag, static_cast<uint8_t>(slotIndex), itemGuid, useSpellId)
+            : UseItemPacket::build(wowBag, static_cast<uint8_t>(slotIndex), itemGuid, useSpellId);
+        LOG_INFO("useItemInBag: sending CMSG_USE_ITEM, bag=", (int)wowBag, " slot=", slotIndex,
+                 " packetSize=", packet.getSize());
+        socket->send(packet);
+    } else if (itemGuid == 0) {
+        LOG_WARNING("Use item in bag failed: missing item GUID for bag ", bagIndex, " slot ", slotIndex);
+        addSystemChatMessage("Cannot use that item right now.");
+    }
+}
+
+void GameHandler::useItemById(uint32_t itemId) {
+    if (itemId == 0) return;
+    LOG_INFO("useItemById: searching for itemId=", itemId, " in backpack (", inventory.getBackpackSize(), " slots)");
+    // Search backpack first
+    for (int i = 0; i < inventory.getBackpackSize(); i++) {
+        const auto& slot = inventory.getBackpackSlot(i);
+        if (!slot.empty() && slot.item.itemId == itemId) {
+            LOG_INFO("useItemById: found itemId=", itemId, " at backpack slot ", i);
+            useItemBySlot(i);
+            return;
+        }
+    }
+    // Search bags
+    for (int bag = 0; bag < inventory.NUM_BAG_SLOTS; bag++) {
+        int bagSize = inventory.getBagSize(bag);
+        for (int slot = 0; slot < bagSize; slot++) {
+            const auto& bagSlot = inventory.getBagSlot(bag, slot);
+            if (!bagSlot.empty() && bagSlot.item.itemId == itemId) {
+                LOG_INFO("useItemById: found itemId=", itemId, " in bag ", bag, " slot ", slot);
+                useItemInBag(bag, slot);
+                return;
+            }
+        }
+    }
+    LOG_WARNING("useItemById: itemId=", itemId, " not found in inventory");
 }
 
 void GameHandler::unstuck() {
@@ -6046,118 +14196,608 @@ void GameHandler::unstuckHearth() {
     }
 }
 
+void GameHandler::handleLootResponse(network::Packet& packet) {
+    if (!LootResponseParser::parse(packet, currentLoot)) return;
+    lootWindowOpen = true;
+    localLootState_[currentLoot.lootGuid] = LocalLootState{currentLoot, false};
+
+    // Query item info so loot window can show names instead of IDs
+    for (const auto& item : currentLoot.items) {
+        queryItemInfo(item.itemId, 0);
+    }
+
+    if (currentLoot.gold > 0) {
+        if (state == WorldState::IN_WORLD && socket) {
+            // Auto-loot gold by sending CMSG_LOOT_MONEY (server handles the rest)
+            bool suppressFallback = false;
+            auto cooldownIt = recentLootMoneyAnnounceCooldowns_.find(currentLoot.lootGuid);
+            if (cooldownIt != recentLootMoneyAnnounceCooldowns_.end() && cooldownIt->second > 0.0f) {
+                suppressFallback = true;
+            }
+            pendingLootMoneyGuid_ = suppressFallback ? 0 : currentLoot.lootGuid;
+            pendingLootMoneyAmount_ = suppressFallback ? 0 : currentLoot.gold;
+            pendingLootMoneyNotifyTimer_ = suppressFallback ? 0.0f : 0.4f;
+            auto pkt = LootMoneyPacket::build();
+            socket->send(pkt);
+            currentLoot.gold = 0;
+        }
+    }
+
+    // Auto-loot items when enabled
+    if (autoLoot_ && state == WorldState::IN_WORLD && socket) {
+        for (const auto& item : currentLoot.items) {
+            auto pkt = AutostoreLootItemPacket::build(item.slotIndex);
+            socket->send(pkt);
+        }
+    }
+}
+
+void GameHandler::handleLootReleaseResponse(network::Packet& packet) {
+    (void)packet;
+    localLootState_.erase(currentLoot.lootGuid);
+    lootWindowOpen = false;
+    currentLoot = LootResponseData{};
+}
+
+void GameHandler::handleLootRemoved(network::Packet& packet) {
+    uint8_t slotIndex = packet.readUInt8();
+    for (auto it = currentLoot.items.begin(); it != currentLoot.items.end(); ++it) {
+        if (it->slotIndex == slotIndex) {
+            std::string itemName = "item #" + std::to_string(it->itemId);
+            if (const ItemQueryResponseData* info = getItemInfo(it->itemId)) {
+                if (!info->name.empty()) {
+                    itemName = info->name;
+                }
+            }
+            std::ostringstream msg;
+            msg << "Looted: " << itemName;
+            if (it->count > 1) {
+                msg << " x" << it->count;
+            }
+            addSystemChatMessage(msg.str());
+            currentLoot.items.erase(it);
+            break;
+        }
+    }
+}
+
+void GameHandler::handleGossipMessage(network::Packet& packet) {
+    bool ok = packetParsers_ ? packetParsers_->parseGossipMessage(packet, currentGossip)
+                             : GossipMessageParser::parse(packet, currentGossip);
+    if (!ok) return;
+    if (questDetailsOpen) return; // Don't reopen gossip while viewing quest
+    gossipWindowOpen = true;
+    vendorWindowOpen = false; // Close vendor if gossip opens
+
+    // Update known quest-log entries based on gossip quests.
+    // Do not synthesize new "active quest" entries from gossip alone.
+    bool hasAvailableQuest = false;
+    bool hasRewardQuest = false;
+    bool hasIncompleteQuest = false;
+    auto questIconIsCompletable = [](uint32_t icon) {
+        return icon == 5 || icon == 6 || icon == 10;
+    };
+    auto questIconIsIncomplete = [](uint32_t icon) {
+        return icon == 3 || icon == 4;
+    };
+    auto questIconIsAvailable = [](uint32_t icon) {
+        return icon == 2 || icon == 7 || icon == 8;
+    };
+
+    for (const auto& questItem : currentGossip.quests) {
+        // WotLK gossip questIcon is an integer enum, NOT a bitmask:
+        //   2 = yellow !  (available, not yet accepted)
+        //   4 = gray ?    (active, objectives incomplete)
+        //   5 = gold ?    (complete, ready to turn in)
+        // Bit-masking these values is wrong: 4 & 0x04 = true, treating incomplete
+        // quests as completable and causing the server to reject the turn-in request.
+        bool isCompletable = questIconIsCompletable(questItem.questIcon);
+        bool isIncomplete  = questIconIsIncomplete(questItem.questIcon);
+        bool isAvailable   = questIconIsAvailable(questItem.questIcon);
+
+        hasAvailableQuest |= isAvailable;
+        hasRewardQuest |= isCompletable;
+        hasIncompleteQuest |= isIncomplete;
+
+        // Update existing quest entry if present
+        for (auto& quest : questLog_) {
+            if (quest.questId == questItem.questId) {
+                quest.complete = isCompletable;
+                quest.title = questItem.title;
+                LOG_INFO("Updated quest ", questItem.questId, " in log: complete=", isCompletable);
+                break;
+            }
+        }
+    }
+
+    // Keep overhead marker aligned with what this gossip actually offers.
+    if (currentGossip.npcGuid != 0) {
+        QuestGiverStatus derivedStatus = QuestGiverStatus::NONE;
+        if (hasRewardQuest) derivedStatus = QuestGiverStatus::REWARD;
+        else if (hasAvailableQuest) derivedStatus = QuestGiverStatus::AVAILABLE;
+        else if (hasIncompleteQuest) derivedStatus = QuestGiverStatus::INCOMPLETE;
+        if (derivedStatus != QuestGiverStatus::NONE) {
+            npcQuestStatus_[currentGossip.npcGuid] = derivedStatus;
+        }
+    }
+
+    // Play NPC greeting voice
+    if (npcGreetingCallback_ && currentGossip.npcGuid != 0) {
+        auto entity = entityManager.getEntity(currentGossip.npcGuid);
+        if (entity) {
+            glm::vec3 npcPos(entity->getX(), entity->getY(), entity->getZ());
+            npcGreetingCallback_(currentGossip.npcGuid, npcPos);
+        }
+    }
+}
+
+void GameHandler::handleQuestgiverQuestList(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 8) return;
+
+    GossipMessageData data;
+    data.npcGuid = packet.readUInt64();
+    data.menuId = 0;
+    data.titleTextId = 0;
+
+    // Server text (header/greeting) and optional emote fields.
+    std::string header = packet.readString();
+    if (packet.getSize() - packet.getReadPos() >= 8) {
+        (void)packet.readUInt32(); // emoteDelay / unk
+        (void)packet.readUInt32(); // emote / unk
+    }
+    (void)header;
+
+    auto readQuestCount = [&](network::Packet& pkt) -> uint32_t {
+        size_t rem = pkt.getSize() - pkt.getReadPos();
+        if (rem >= 4) {
+            size_t p = pkt.getReadPos();
+            uint32_t c = pkt.readUInt32();
+            if (c <= 64) return c;
+            pkt.setReadPos(p);
+        }
+        if (rem >= 1) {
+            return static_cast<uint32_t>(pkt.readUInt8());
+        }
+        return 0;
+    };
+
+    uint32_t questCount = readQuestCount(packet);
+    data.quests.reserve(questCount);
+    for (uint32_t i = 0; i < questCount; ++i) {
+        if (packet.getSize() - packet.getReadPos() < 12) break;
+        GossipQuestItem q;
+        q.questId = packet.readUInt32();
+        q.questIcon = packet.readUInt32();
+        q.questLevel = static_cast<int32_t>(packet.readUInt32());
+
+        // WotLK includes questFlags + isRepeatable; Classic variants may omit.
+        size_t titlePos = packet.getReadPos();
+        if (packet.getSize() - packet.getReadPos() >= 5) {
+            q.questFlags = packet.readUInt32();
+            q.isRepeatable = packet.readUInt8();
+            q.title = normalizeWowTextTokens(packet.readString());
+            if (q.title.empty()) {
+                packet.setReadPos(titlePos);
+                q.questFlags = 0;
+                q.isRepeatable = 0;
+                q.title = normalizeWowTextTokens(packet.readString());
+            }
+        } else {
+            q.questFlags = 0;
+            q.isRepeatable = 0;
+            q.title = normalizeWowTextTokens(packet.readString());
+        }
+        if (q.questId != 0) {
+            data.quests.push_back(std::move(q));
+        }
+    }
+
+    currentGossip = std::move(data);
+    gossipWindowOpen = true;
+    vendorWindowOpen = false;
+
+    bool hasAvailableQuest = false;
+    bool hasRewardQuest = false;
+    bool hasIncompleteQuest = false;
+    auto questIconIsCompletable = [](uint32_t icon) {
+        return icon == 5 || icon == 6 || icon == 10;
+    };
+    auto questIconIsIncomplete = [](uint32_t icon) {
+        return icon == 3 || icon == 4;
+    };
+    auto questIconIsAvailable = [](uint32_t icon) {
+        return icon == 2 || icon == 7 || icon == 8;
+    };
+
+    for (const auto& questItem : currentGossip.quests) {
+        bool isCompletable = questIconIsCompletable(questItem.questIcon);
+        bool isIncomplete  = questIconIsIncomplete(questItem.questIcon);
+        bool isAvailable   = questIconIsAvailable(questItem.questIcon);
+        hasAvailableQuest |= isAvailable;
+        hasRewardQuest |= isCompletable;
+        hasIncompleteQuest |= isIncomplete;
+    }
+    if (currentGossip.npcGuid != 0) {
+        QuestGiverStatus derivedStatus = QuestGiverStatus::NONE;
+        if (hasRewardQuest) derivedStatus = QuestGiverStatus::REWARD;
+        else if (hasAvailableQuest) derivedStatus = QuestGiverStatus::AVAILABLE;
+        else if (hasIncompleteQuest) derivedStatus = QuestGiverStatus::INCOMPLETE;
+        if (derivedStatus != QuestGiverStatus::NONE) {
+            npcQuestStatus_[currentGossip.npcGuid] = derivedStatus;
+        }
+    }
+
+    LOG_INFO("Questgiver quest list: npc=0x", std::hex, currentGossip.npcGuid, std::dec,
+             " quests=", currentGossip.quests.size());
+}
+
+void GameHandler::handleGossipComplete(network::Packet& packet) {
+    (void)packet;
+
+    // Play farewell sound before closing
+    if (npcFarewellCallback_ && currentGossip.npcGuid != 0) {
+        auto entity = entityManager.getEntity(currentGossip.npcGuid);
+        if (entity && entity->getType() == ObjectType::UNIT) {
+            glm::vec3 pos(entity->getX(), entity->getY(), entity->getZ());
+            npcFarewellCallback_(currentGossip.npcGuid, pos);
+        }
+    }
+
+    gossipWindowOpen = false;
+    currentGossip = GossipMessageData{};
+}
+
+void GameHandler::handleListInventory(network::Packet& packet) {
+    if (!ListInventoryParser::parse(packet, currentVendorItems)) return;
+    vendorWindowOpen = true;
+    gossipWindowOpen = false; // Close gossip if vendor opens
+
+    // Play vendor sound
+    if (npcVendorCallback_ && currentVendorItems.vendorGuid != 0) {
+        auto entity = entityManager.getEntity(currentVendorItems.vendorGuid);
+        if (entity && entity->getType() == ObjectType::UNIT) {
+            glm::vec3 pos(entity->getX(), entity->getY(), entity->getZ());
+            npcVendorCallback_(currentVendorItems.vendorGuid, pos);
+        }
+    }
+
+    // Query item info for all vendor items so we can show names
+    for (const auto& item : currentVendorItems.items) {
+        queryItemInfo(item.itemId, 0);
+    }
+}
+
 // ============================================================
 // Trainer
 // ============================================================
 
+void GameHandler::handleTrainerList(network::Packet& packet) {
+    if (!TrainerListParser::parse(packet, currentTrainerList_)) return;
+    trainerWindowOpen_ = true;
+    gossipWindowOpen = false;
+
+    // Debug: log known spells
+    LOG_INFO("Known spells count: ", knownSpells.size());
+    if (knownSpells.size() <= 50) {
+        std::string spellList;
+        for (uint32_t id : knownSpells) {
+            if (!spellList.empty()) spellList += ", ";
+            spellList += std::to_string(id);
+        }
+        LOG_INFO("Known spells: ", spellList);
+    }
+
+    // Check if specific prerequisite spells are known
+    bool has527 = knownSpells.count(527u);
+    bool has25312 = knownSpells.count(25312u);
+    LOG_INFO("Prerequisite check: 527=", has527, " 25312=", has25312);
+
+    // Debug: log first few trainer spells to see their state
+    LOG_INFO("Trainer spells received: ", currentTrainerList_.spells.size(), " spells");
+    for (size_t i = 0; i < std::min(size_t(5), currentTrainerList_.spells.size()); ++i) {
+        const auto& s = currentTrainerList_.spells[i];
+        LOG_INFO("  Spell[", i, "]: id=", s.spellId, " state=", (int)s.state,
+                 " cost=", s.spellCost, " reqLvl=", (int)s.reqLevel,
+                 " chain=(", s.chainNode1, ",", s.chainNode2, ",", s.chainNode3, ")");
+    }
+
+
+    // Ensure caches are populated
+    loadSpellNameCache();
+    loadSkillLineDbc();
+    loadSkillLineAbilityDbc();
+    categorizeTrainerSpells();
+}
+
 void GameHandler::trainSpell(uint32_t spellId) {
-    if (inventoryHandler_) inventoryHandler_->trainSpell(spellId);
+    LOG_INFO("trainSpell called: spellId=", spellId, " state=", (int)state, " socket=", (socket ? "yes" : "no"));
+    if (state != WorldState::IN_WORLD || !socket) {
+        LOG_WARNING("trainSpell: Not in world or no socket connection");
+        return;
+    }
+
+    // Find spell cost in trainer list
+    uint32_t spellCost = 0;
+    for (const auto& spell : currentTrainerList_.spells) {
+        if (spell.spellId == spellId) {
+            spellCost = spell.spellCost;
+            break;
+        }
+    }
+    LOG_INFO("Player money: ", playerMoneyCopper_, " copper, spell cost: ", spellCost, " copper");
+
+    LOG_INFO("Sending CMSG_TRAINER_BUY_SPELL: guid=", currentTrainerList_.trainerGuid,
+             " spellId=", spellId);
+    auto packet = TrainerBuySpellPacket::build(
+        currentTrainerList_.trainerGuid,
+        spellId);
+    socket->send(packet);
+    LOG_INFO("CMSG_TRAINER_BUY_SPELL sent");
 }
 
 void GameHandler::closeTrainer() {
-    if (inventoryHandler_) inventoryHandler_->closeTrainer();
+    trainerWindowOpen_ = false;
+    currentTrainerList_ = TrainerListData{};
+    trainerTabs_.clear();
 }
 
-void GameHandler::preloadDBCCaches() const {
-    LOG_INFO("Pre-loading DBC caches during world entry...");
-    auto t0 = std::chrono::steady_clock::now();
+void GameHandler::loadSpellNameCache() {
+    if (spellNameCacheLoaded_) return;
+    spellNameCacheLoaded_ = true;
 
-    loadSpellNameCache();   // Spell.dbc — largest, ~170ms cold
-    loadTitleNameCache();   // CharTitles.dbc
-    loadFactionNameCache(); // Faction.dbc
-    loadAreaNameCache();    // WorldMapArea.dbc
-    loadMapNameCache();     // Map.dbc
-    loadLfgDungeonDbc();    // LFGDungeons.dbc
+    auto* am = core::Application::getInstance().getAssetManager();
+    if (!am || !am->isInitialized()) return;
 
-    // Validate animation constants against AnimationData.dbc
-    if (auto* am = services_.assetManager) {
-        auto animDbc = am->loadDBC("AnimationData.dbc");
-        rendering::anim::validateAgainstDBC(animDbc);
+    auto dbc = am->loadDBC("Spell.dbc");
+    if (!dbc || !dbc->isLoaded()) {
+        LOG_WARNING("Trainer: Could not load Spell.dbc for spell names");
+        return;
     }
 
-    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
-        std::chrono::steady_clock::now() - t0).count();
-    LOG_INFO("DBC cache pre-load complete in ", elapsed, " ms");
-}
+    if (dbc->getFieldCount() < 154) {
+        LOG_WARNING("Trainer: Spell.dbc has too few fields");
+        return;
+    }
 
-void GameHandler::loadSpellNameCache() const {
-    if (spellHandler_) spellHandler_->loadSpellNameCache();
+    const auto* spellL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("Spell") : nullptr;
+
+    // Determine school field (bitmask for TBC/WotLK, enum for Classic/Vanilla)
+    uint32_t schoolMaskField = 0, schoolEnumField = 0;
+    bool hasSchoolMask = false, hasSchoolEnum = false;
+    if (spellL) {
+        uint32_t f = spellL->field("SchoolMask");
+        if (f != 0xFFFFFFFF && f < dbc->getFieldCount()) { schoolMaskField = f; hasSchoolMask = true; }
+        f = spellL->field("SchoolEnum");
+        if (f != 0xFFFFFFFF && f < dbc->getFieldCount()) { schoolEnumField = f; hasSchoolEnum = true; }
+    }
+
+    uint32_t count = dbc->getRecordCount();
+    for (uint32_t i = 0; i < count; ++i) {
+        uint32_t id = dbc->getUInt32(i, spellL ? (*spellL)["ID"] : 0);
+        if (id == 0) continue;
+        std::string name = dbc->getString(i, spellL ? (*spellL)["Name"] : 136);
+        std::string rank = dbc->getString(i, spellL ? (*spellL)["Rank"] : 153);
+        if (!name.empty()) {
+            SpellNameEntry entry{std::move(name), std::move(rank), 0};
+            if (hasSchoolMask) {
+                entry.schoolMask = dbc->getUInt32(i, schoolMaskField);
+            } else if (hasSchoolEnum) {
+                // Classic/Vanilla enum: 0=Physical,1=Holy,2=Fire,3=Nature,4=Frost,5=Shadow,6=Arcane
+                static const uint32_t enumToBitmask[] = {0x01,0x02,0x04,0x08,0x10,0x20,0x40};
+                uint32_t e = dbc->getUInt32(i, schoolEnumField);
+                entry.schoolMask = (e < 7) ? enumToBitmask[e] : 0;
+            }
+            spellNameCache_[id] = std::move(entry);
+        }
+    }
+    LOG_INFO("Trainer: Loaded ", spellNameCache_.size(), " spell names from Spell.dbc");
 }
 
 void GameHandler::loadSkillLineAbilityDbc() {
-    if (spellHandler_) spellHandler_->loadSkillLineAbilityDbc();
-}
+    if (skillLineAbilityLoaded_) return;
+    skillLineAbilityLoaded_ = true;
 
-const std::vector<GameHandler::SpellBookTab>& GameHandler::getSpellBookTabs() {
-    static const std::vector<SpellBookTab> kEmpty;
-    if (spellHandler_) return spellHandler_->getSpellBookTabs();
-    return kEmpty;
+    auto* am = core::Application::getInstance().getAssetManager();
+    if (!am || !am->isInitialized()) return;
+
+    auto slaDbc = am->loadDBC("SkillLineAbility.dbc");
+    if (slaDbc && slaDbc->isLoaded()) {
+        const auto* slaL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("SkillLineAbility") : nullptr;
+        for (uint32_t i = 0; i < slaDbc->getRecordCount(); i++) {
+            uint32_t skillLineId = slaDbc->getUInt32(i, slaL ? (*slaL)["SkillLineID"] : 1);
+            uint32_t spellId = slaDbc->getUInt32(i, slaL ? (*slaL)["SpellID"] : 2);
+            if (spellId > 0 && skillLineId > 0) {
+                spellToSkillLine_[spellId] = skillLineId;
+            }
+        }
+        LOG_INFO("Trainer: Loaded ", spellToSkillLine_.size(), " skill line abilities");
+    }
 }
 
 void GameHandler::categorizeTrainerSpells() {
-    if (spellHandler_) spellHandler_->categorizeTrainerSpells();
+    trainerTabs_.clear();
+
+    static constexpr uint32_t SKILLLINE_CATEGORY_CLASS = 7;
+
+    // Group spells by skill line (category 7 = class spec tabs)
+    std::map<uint32_t, std::vector<const TrainerSpell*>> specialtySpells;
+    std::vector<const TrainerSpell*> generalSpells;
+
+    for (const auto& spell : currentTrainerList_.spells) {
+        auto slIt = spellToSkillLine_.find(spell.spellId);
+        if (slIt != spellToSkillLine_.end()) {
+            uint32_t skillLineId = slIt->second;
+            auto catIt = skillLineCategories_.find(skillLineId);
+            if (catIt != skillLineCategories_.end() && catIt->second == SKILLLINE_CATEGORY_CLASS) {
+                specialtySpells[skillLineId].push_back(&spell);
+                continue;
+            }
+        }
+        generalSpells.push_back(&spell);
+    }
+
+    // Sort by spell name within each group
+    auto byName = [this](const TrainerSpell* a, const TrainerSpell* b) {
+        return getSpellName(a->spellId) < getSpellName(b->spellId);
+    };
+
+    // Build named tabs sorted alphabetically
+    std::vector<std::pair<std::string, std::vector<const TrainerSpell*>>> named;
+    for (auto& [skillLineId, spells] : specialtySpells) {
+        auto nameIt = skillLineNames_.find(skillLineId);
+        std::string tabName = (nameIt != skillLineNames_.end()) ? nameIt->second : "Specialty";
+        std::sort(spells.begin(), spells.end(), byName);
+        named.push_back({std::move(tabName), std::move(spells)});
+    }
+    std::sort(named.begin(), named.end(),
+        [](const auto& a, const auto& b) { return a.first < b.first; });
+
+    for (auto& [name, spells] : named) {
+        trainerTabs_.push_back({std::move(name), std::move(spells)});
+    }
+
+    // General tab last
+    if (!generalSpells.empty()) {
+        std::sort(generalSpells.begin(), generalSpells.end(), byName);
+        trainerTabs_.push_back({"General", std::move(generalSpells)});
+    }
+
+    LOG_INFO("Trainer: Categorized into ", trainerTabs_.size(), " tabs");
 }
 
 void GameHandler::loadTalentDbc() {
-    if (spellHandler_) spellHandler_->loadTalentDbc();
+    if (talentDbcLoaded_) return;
+    talentDbcLoaded_ = true;
+
+    auto* am = core::Application::getInstance().getAssetManager();
+    if (!am || !am->isInitialized()) return;
+
+    // Load Talent.dbc
+    auto talentDbc = am->loadDBC("Talent.dbc");
+    if (talentDbc && talentDbc->isLoaded()) {
+        // Talent.dbc structure (WoW 3.3.5a):
+        // 0: TalentID
+        // 1: TalentTabID
+        // 2: Row (tier)
+        // 3: Column
+        // 4-8: RankID[0-4] (spell IDs for ranks 1-5)
+        // 9-11: PrereqTalent[0-2]
+        // 12-14: PrereqRank[0-2]
+        // (other fields less relevant for basic functionality)
+
+        const auto* talL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("Talent") : nullptr;
+        const uint32_t tID = talL ? (*talL)["ID"] : 0;
+        const uint32_t tTabID = talL ? (*talL)["TabID"] : 1;
+        const uint32_t tRow = talL ? (*talL)["Row"] : 2;
+        const uint32_t tCol = talL ? (*talL)["Column"] : 3;
+        const uint32_t tRank0 = talL ? (*talL)["RankSpell0"] : 4;
+        const uint32_t tPrereq0 = talL ? (*talL)["PrereqTalent0"] : 9;
+        const uint32_t tPrereqR0 = talL ? (*talL)["PrereqRank0"] : 12;
+
+        uint32_t count = talentDbc->getRecordCount();
+        for (uint32_t i = 0; i < count; ++i) {
+            TalentEntry entry;
+            entry.talentId = talentDbc->getUInt32(i, tID);
+            if (entry.talentId == 0) continue;
+
+            entry.tabId = talentDbc->getUInt32(i, tTabID);
+            entry.row = static_cast<uint8_t>(talentDbc->getUInt32(i, tRow));
+            entry.column = static_cast<uint8_t>(talentDbc->getUInt32(i, tCol));
+
+            // Rank spells (1-5 ranks)
+            for (int r = 0; r < 5; ++r) {
+                entry.rankSpells[r] = talentDbc->getUInt32(i, tRank0 + r);
+            }
+
+            // Prerequisites
+            for (int p = 0; p < 3; ++p) {
+                entry.prereqTalent[p] = talentDbc->getUInt32(i, tPrereq0 + p);
+                entry.prereqRank[p] = static_cast<uint8_t>(talentDbc->getUInt32(i, tPrereqR0 + p));
+            }
+
+            // Calculate max rank
+            entry.maxRank = 0;
+            for (int r = 0; r < 5; ++r) {
+                if (entry.rankSpells[r] != 0) {
+                    entry.maxRank = r + 1;
+                }
+            }
+
+            talentCache_[entry.talentId] = entry;
+        }
+        LOG_INFO("Loaded ", talentCache_.size(), " talents from Talent.dbc");
+    } else {
+        LOG_WARNING("Could not load Talent.dbc");
+    }
+
+    // Load TalentTab.dbc
+    auto tabDbc = am->loadDBC("TalentTab.dbc");
+    if (tabDbc && tabDbc->isLoaded()) {
+        // TalentTab.dbc structure (WoW 3.3.5a):
+        // 0: TalentTabID
+        // 1-17: Name (16 localized strings + flags = 17 fields)
+        // 18: SpellIconID
+        // 19: RaceMask
+        // 20: ClassMask
+        // 21: PetTalentMask
+        // 22: OrderIndex
+        // 23-39: BackgroundFile (16 localized strings + flags = 17 fields)
+
+        const auto* ttL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("TalentTab") : nullptr;
+        uint32_t count = tabDbc->getRecordCount();
+        for (uint32_t i = 0; i < count; ++i) {
+            TalentTabEntry entry;
+            entry.tabId = tabDbc->getUInt32(i, ttL ? (*ttL)["ID"] : 0);
+            if (entry.tabId == 0) continue;
+
+            entry.name = tabDbc->getString(i, ttL ? (*ttL)["Name"] : 1);
+            entry.classMask = tabDbc->getUInt32(i, ttL ? (*ttL)["ClassMask"] : 20);
+            entry.orderIndex = static_cast<uint8_t>(tabDbc->getUInt32(i, ttL ? (*ttL)["OrderIndex"] : 22));
+            entry.backgroundFile = tabDbc->getString(i, ttL ? (*ttL)["BackgroundFile"] : 23);
+
+            talentTabCache_[entry.tabId] = entry;
+
+            // Log first few tabs to debug class mask issue
+            if (talentTabCache_.size() <= 10) {
+                LOG_INFO("  Tab ", entry.tabId, ": ", entry.name, " (classMask=0x", std::hex, entry.classMask, std::dec, ")");
+            }
+        }
+        LOG_INFO("Loaded ", talentTabCache_.size(), " talent tabs from TalentTab.dbc");
+    } else {
+        LOG_WARNING("Could not load TalentTab.dbc");
+    }
 }
 
 static const std::string EMPTY_STRING;
 
-const int32_t* GameHandler::getSpellEffectBasePoints(uint32_t spellId) const {
-    if (spellHandler_) return spellHandler_->getSpellEffectBasePoints(spellId);
-    return nullptr;
-}
-
-float GameHandler::getSpellDuration(uint32_t spellId) const {
-    if (spellHandler_) return spellHandler_->getSpellDuration(spellId);
-    return 0.0f;
-}
-
 const std::string& GameHandler::getSpellName(uint32_t spellId) const {
-    if (spellHandler_) return spellHandler_->getSpellName(spellId);
-    return EMPTY_STRING;
+    auto it = spellNameCache_.find(spellId);
+    return (it != spellNameCache_.end()) ? it->second.name : EMPTY_STRING;
 }
 
 const std::string& GameHandler::getSpellRank(uint32_t spellId) const {
-    if (spellHandler_) return spellHandler_->getSpellRank(spellId);
-    return EMPTY_STRING;
-}
-
-const std::string& GameHandler::getSpellDescription(uint32_t spellId) const {
-    if (spellHandler_) return spellHandler_->getSpellDescription(spellId);
-    return EMPTY_STRING;
-}
-
-std::string GameHandler::getEnchantName(uint32_t enchantId) const {
-    if (spellHandler_) return spellHandler_->getEnchantName(enchantId);
-    return {};
-}
-
-uint8_t GameHandler::getSpellDispelType(uint32_t spellId) const {
-    if (spellHandler_) return spellHandler_->getSpellDispelType(spellId);
-    return 0;
-}
-
-bool GameHandler::isSpellInterruptible(uint32_t spellId) const {
-    if (spellHandler_) return spellHandler_->isSpellInterruptible(spellId);
-    return true;
-}
-
-uint32_t GameHandler::getSpellSchoolMask(uint32_t spellId) const {
-    if (spellHandler_) return spellHandler_->getSpellSchoolMask(spellId);
-    return 0;
+    auto it = spellNameCache_.find(spellId);
+    return (it != spellNameCache_.end()) ? it->second.rank : EMPTY_STRING;
 }
 
 const std::string& GameHandler::getSkillLineName(uint32_t spellId) const {
-    if (spellHandler_) return spellHandler_->getSkillLineName(spellId);
-    return EMPTY_STRING;
+    auto slIt = spellToSkillLine_.find(spellId);
+    if (slIt == spellToSkillLine_.end()) return EMPTY_STRING;
+    auto nameIt = skillLineNames_.find(slIt->second);
+    return (nameIt != skillLineNames_.end()) ? nameIt->second : EMPTY_STRING;
 }
 
 // ============================================================
 // Single-player local combat
 // ============================================================
 
+
+
+
+
+
+
+
 // ============================================================
 // XP tracking
 // ============================================================
@@ -6182,40 +14822,966 @@ uint32_t GameHandler::xpForLevel(uint32_t level) {
 }
 
 uint32_t GameHandler::killXp(uint32_t playerLevel, uint32_t victimLevel) {
-    return CombatHandler::killXp(playerLevel, victimLevel);
+    if (playerLevel == 0 || victimLevel == 0) return 0;
+
+    // Gray level check (too low = 0 XP)
+    int32_t grayLevel;
+    if (playerLevel <= 5)        grayLevel = 0;
+    else if (playerLevel <= 39)  grayLevel = static_cast<int32_t>(playerLevel) - 5 - static_cast<int32_t>(playerLevel) / 10;
+    else if (playerLevel <= 59)  grayLevel = static_cast<int32_t>(playerLevel) - 1 - static_cast<int32_t>(playerLevel) / 5;
+    else                         grayLevel = static_cast<int32_t>(playerLevel) - 9;
+
+    if (static_cast<int32_t>(victimLevel) <= grayLevel) return 0;
+
+    // Base XP = 45 + 5 * victimLevel (WoW-like ZeroDifference formula)
+    uint32_t baseXp = 45 + 5 * victimLevel;
+
+    // Level difference multiplier
+    int32_t diff = static_cast<int32_t>(victimLevel) - static_cast<int32_t>(playerLevel);
+    float multiplier = 1.0f + diff * 0.05f;
+    if (multiplier < 0.1f) multiplier = 0.1f;
+    if (multiplier > 2.0f) multiplier = 2.0f;
+
+    return static_cast<uint32_t>(baseXp * multiplier);
 }
 
+
+
 void GameHandler::handleXpGain(network::Packet& packet) {
-    if (combatHandler_) combatHandler_->handleXpGain(packet);
+    XpGainData data;
+    if (!XpGainParser::parse(packet, data)) return;
+
+    // Server already updates PLAYER_XP via update fields,
+    // but we can show combat text for XP gains
+    addCombatText(CombatTextEntry::XP_GAIN, static_cast<int32_t>(data.totalXp), 0, true);
+
+    std::string msg = "You gain " + std::to_string(data.totalXp) + " experience.";
+    if (data.groupBonus > 0) {
+        msg += " (+" + std::to_string(data.groupBonus) + " group bonus)";
+    }
+    addSystemChatMessage(msg);
 }
 
+
 void GameHandler::addMoneyCopper(uint32_t amount) {
-    if (inventoryHandler_) inventoryHandler_->addMoneyCopper(amount);
+    if (amount == 0) return;
+    playerMoneyCopper_ += amount;
+    uint32_t gold = amount / 10000;
+    uint32_t silver = (amount / 100) % 100;
+    uint32_t copper = amount % 100;
+    std::string msg = "You receive ";
+    msg += std::to_string(gold) + "g ";
+    msg += std::to_string(silver) + "s ";
+    msg += std::to_string(copper) + "c.";
+    addSystemChatMessage(msg);
 }
 
 void GameHandler::addSystemChatMessage(const std::string& message) {
-    if (chatHandler_) chatHandler_->addSystemChatMessage(message);
+    if (message.empty()) return;
+    MessageChatData msg;
+    msg.type = ChatType::SYSTEM;
+    msg.language = ChatLanguage::UNIVERSAL;
+    msg.message = message;
+    addLocalChatMessage(msg);
+}
+
+// ============================================================
+// Teleport Handler
+// ============================================================
+
+void GameHandler::handleTeleportAck(network::Packet& packet) {
+    // MSG_MOVE_TELEPORT_ACK (server→client): packedGuid + u32 counter + u32 time
+    // followed by movement info with the new position
+    if (packet.getSize() - packet.getReadPos() < 4) {
+        LOG_WARNING("MSG_MOVE_TELEPORT_ACK too short");
+        return;
+    }
+
+    uint64_t guid = UpdateObjectParser::readPackedGuid(packet);
+    if (packet.getSize() - packet.getReadPos() < 4) return;
+    uint32_t counter = packet.readUInt32();
+
+    // Read the movement info embedded in the teleport
+    // Format: u32 flags, u16 flags2, u32 time, float x, float y, float z, float o
+    if (packet.getSize() - packet.getReadPos() < 4 + 2 + 4 + 4 * 4) {
+        LOG_WARNING("MSG_MOVE_TELEPORT_ACK: not enough data for movement info");
+        return;
+    }
+
+    packet.readUInt32();  // moveFlags
+    packet.readUInt16();  // moveFlags2
+    uint32_t moveTime = packet.readUInt32();
+    float serverX = packet.readFloat();
+    float serverY = packet.readFloat();
+    float serverZ = packet.readFloat();
+    float orientation = packet.readFloat();
+
+    LOG_INFO("MSG_MOVE_TELEPORT_ACK: guid=0x", std::hex, guid, std::dec,
+             " counter=", counter,
+             " pos=(", serverX, ", ", serverY, ", ", serverZ, ")");
+
+    // Update our position
+    glm::vec3 canonical = core::coords::serverToCanonical(glm::vec3(serverX, serverY, serverZ));
+    movementInfo.x = canonical.x;
+    movementInfo.y = canonical.y;
+    movementInfo.z = canonical.z;
+    movementInfo.orientation = core::coords::serverToCanonicalYaw(orientation);
+    movementInfo.flags = 0;
+
+    // Send the ack back to the server
+    // Client→server MSG_MOVE_TELEPORT_ACK: u64 guid + u32 counter + u32 time
+    if (socket && !isClassicLikeExpansion()) {
+        network::Packet ack(wireOpcode(Opcode::MSG_MOVE_TELEPORT_ACK));
+        const bool legacyGuidAck =
+            isActiveExpansion("classic") || isActiveExpansion("tbc") || isActiveExpansion("turtle");
+        if (legacyGuidAck) {
+            ack.writeUInt64(playerGuid);  // CMaNGOS expects full GUID for teleport ACK
+        } else {
+            MovementPacket::writePackedGuid(ack, playerGuid);
+        }
+        ack.writeUInt32(counter);
+        ack.writeUInt32(moveTime);
+        socket->send(ack);
+        LOG_INFO("Sent MSG_MOVE_TELEPORT_ACK response");
+    }
+
+    // Notify application of teleport — the callback decides whether to do
+    // a full world reload (map change) or just update position (same map).
+    if (worldEntryCallback_) {
+        worldEntryCallback_(currentMapId_, serverX, serverY, serverZ);
+    }
+}
+
+void GameHandler::handleNewWorld(network::Packet& packet) {
+    // SMSG_NEW_WORLD: uint32 mapId, float x, y, z, orientation
+    if (packet.getSize() - packet.getReadPos() < 20) {
+        LOG_WARNING("SMSG_NEW_WORLD too short");
+        return;
+    }
+
+    uint32_t mapId = packet.readUInt32();
+    float serverX = packet.readFloat();
+    float serverY = packet.readFloat();
+    float serverZ = packet.readFloat();
+    float orientation = packet.readFloat();
+
+    LOG_WARNING("SMSG_NEW_WORLD: mapId=", mapId,
+             " pos=(", serverX, ", ", serverY, ", ", serverZ, ")",
+             " orient=", orientation);
+
+    // Detect same-map spirit healer resurrection: the server uses SMSG_NEW_WORLD
+    // to reposition the player at the graveyard on the same map.  A full world
+    // reload is not needed and causes terrain to vanish, making the player fall
+    // forever.  Just reposition and send the ack.
+    const bool isSameMap       = (mapId == currentMapId_);
+    const bool isResurrection  = resurrectPending_;
+    if (isSameMap && isResurrection) {
+        LOG_INFO("SMSG_NEW_WORLD same-map resurrection — skipping world reload");
+
+        glm::vec3 canonical = core::coords::serverToCanonical(glm::vec3(serverX, serverY, serverZ));
+        movementInfo.x = canonical.x;
+        movementInfo.y = canonical.y;
+        movementInfo.z = canonical.z;
+        movementInfo.orientation = core::coords::serverToCanonicalYaw(orientation);
+        movementInfo.flags  = 0;
+        movementInfo.flags2 = 0;
+
+        resurrectPending_       = false;
+        resurrectRequestPending_ = false;
+        releasedSpirit_         = false;
+        playerDead_             = false;
+        repopPending_           = false;
+        pendingSpiritHealerGuid_ = 0;
+        resurrectCasterGuid_    = 0;
+        hostileAttackers_.clear();
+        stopAutoAttack();
+        tabCycleStale = true;
+
+        if (socket) {
+            network::Packet ack(wireOpcode(Opcode::MSG_MOVE_WORLDPORT_ACK));
+            socket->send(ack);
+            LOG_INFO("Sent MSG_MOVE_WORLDPORT_ACK (resurrection)");
+        }
+        return;
+    }
+
+    currentMapId_ = mapId;
+
+    // Update player position
+    glm::vec3 canonical = core::coords::serverToCanonical(glm::vec3(serverX, serverY, serverZ));
+    movementInfo.x = canonical.x;
+    movementInfo.y = canonical.y;
+    movementInfo.z = canonical.z;
+    movementInfo.orientation = core::coords::serverToCanonicalYaw(orientation);
+    movementInfo.flags = 0;
+    movementInfo.flags2 = 0;
+    serverMovementAllowed_ = true;
+    resurrectPending_ = false;
+    resurrectRequestPending_ = false;
+    onTaxiFlight_ = false;
+    taxiMountActive_ = false;
+    taxiActivatePending_ = false;
+    taxiClientActive_ = false;
+    taxiClientPath_.clear();
+    taxiRecoverPending_ = false;
+    taxiStartGrace_ = 0.0f;
+    currentMountDisplayId_ = 0;
+    taxiMountDisplayId_ = 0;
+    if (mountCallback_) {
+        mountCallback_(0);
+    }
+
+    // Clear world state for the new map
+    entityManager.clear();
+    hostileAttackers_.clear();
+    worldStates_.clear();
+    worldStateMapId_ = mapId;
+    worldStateZoneId_ = 0;
+    activeAreaTriggers_.clear();
+    areaTriggerCheckTimer_ = -5.0f;  // 5-second cooldown after map transfer
+    areaTriggerSuppressFirst_ = true;  // first check just marks active triggers, doesn't fire
+    stopAutoAttack();
+    casting = false;
+    currentCastSpellId = 0;
+    pendingGameObjectInteractGuid_ = 0;
+    castTimeRemaining = 0.0f;
+
+    // Send MSG_MOVE_WORLDPORT_ACK to tell the server we're ready
+    if (socket) {
+        network::Packet ack(wireOpcode(Opcode::MSG_MOVE_WORLDPORT_ACK));
+        socket->send(ack);
+        LOG_INFO("Sent MSG_MOVE_WORLDPORT_ACK");
+    }
+
+    // Reload terrain at new position
+    if (worldEntryCallback_) {
+        worldEntryCallback_(mapId, serverX, serverY, serverZ);
+    }
 }
 
 // ============================================================
 // Taxi / Flight Path Handlers
 // ============================================================
 
+void GameHandler::loadTaxiDbc() {
+    if (taxiDbcLoaded_) return;
+    taxiDbcLoaded_ = true;
+
+    auto* am = core::Application::getInstance().getAssetManager();
+    if (!am || !am->isInitialized()) return;
+
+    auto nodesDbc = am->loadDBC("TaxiNodes.dbc");
+    if (nodesDbc && nodesDbc->isLoaded()) {
+        const auto* tnL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("TaxiNodes") : nullptr;
+        uint32_t fieldCount = nodesDbc->getFieldCount();
+        for (uint32_t i = 0; i < nodesDbc->getRecordCount(); i++) {
+            TaxiNode node;
+            node.id = nodesDbc->getUInt32(i, tnL ? (*tnL)["ID"] : 0);
+            node.mapId = nodesDbc->getUInt32(i, tnL ? (*tnL)["MapID"] : 1);
+            node.x = nodesDbc->getFloat(i, tnL ? (*tnL)["X"] : 2);
+            node.y = nodesDbc->getFloat(i, tnL ? (*tnL)["Y"] : 3);
+            node.z = nodesDbc->getFloat(i, tnL ? (*tnL)["Z"] : 4);
+            node.name = nodesDbc->getString(i, tnL ? (*tnL)["Name"] : 5);
+            const uint32_t mountAllianceField = tnL ? (*tnL)["MountDisplayIdAlliance"] : 22;
+            const uint32_t mountHordeField = tnL ? (*tnL)["MountDisplayIdHorde"] : 23;
+            const uint32_t mountAllianceFB = tnL ? (*tnL)["MountDisplayIdAllianceFallback"] : 20;
+            const uint32_t mountHordeFB = tnL ? (*tnL)["MountDisplayIdHordeFallback"] : 21;
+            if (fieldCount > mountHordeField) {
+                node.mountDisplayIdAlliance = nodesDbc->getUInt32(i, mountAllianceField);
+                node.mountDisplayIdHorde = nodesDbc->getUInt32(i, mountHordeField);
+                if (node.mountDisplayIdAlliance == 0 && node.mountDisplayIdHorde == 0 && fieldCount > mountHordeFB) {
+                    node.mountDisplayIdAlliance = nodesDbc->getUInt32(i, mountAllianceFB);
+                    node.mountDisplayIdHorde = nodesDbc->getUInt32(i, mountHordeFB);
+                }
+            }
+            uint32_t nodeId = node.id;
+            if (nodeId > 0) {
+                taxiNodes_[nodeId] = std::move(node);
+            }
+            if (nodeId == 195) {
+                std::string fields;
+                for (uint32_t f = 0; f < fieldCount; f++) {
+                    fields += std::to_string(f) + ":" + std::to_string(nodesDbc->getUInt32(i, f)) + " ";
+                }
+                LOG_INFO("TaxiNodes[195] fields: ", fields);
+            }
+        }
+        LOG_INFO("Loaded ", taxiNodes_.size(), " taxi nodes from TaxiNodes.dbc");
+    } else {
+        LOG_WARNING("Could not load TaxiNodes.dbc");
+    }
+
+    auto pathDbc = am->loadDBC("TaxiPath.dbc");
+    if (pathDbc && pathDbc->isLoaded()) {
+        const auto* tpL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("TaxiPath") : nullptr;
+        for (uint32_t i = 0; i < pathDbc->getRecordCount(); i++) {
+            TaxiPathEdge edge;
+            edge.pathId = pathDbc->getUInt32(i, tpL ? (*tpL)["ID"] : 0);
+            edge.fromNode = pathDbc->getUInt32(i, tpL ? (*tpL)["FromNode"] : 1);
+            edge.toNode = pathDbc->getUInt32(i, tpL ? (*tpL)["ToNode"] : 2);
+            edge.cost = pathDbc->getUInt32(i, tpL ? (*tpL)["Cost"] : 3);
+            taxiPathEdges_.push_back(edge);
+        }
+        LOG_INFO("Loaded ", taxiPathEdges_.size(), " taxi path edges from TaxiPath.dbc");
+    } else {
+        LOG_WARNING("Could not load TaxiPath.dbc");
+    }
+
+    auto pathNodeDbc = am->loadDBC("TaxiPathNode.dbc");
+    if (pathNodeDbc && pathNodeDbc->isLoaded()) {
+        const auto* tpnL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("TaxiPathNode") : nullptr;
+        for (uint32_t i = 0; i < pathNodeDbc->getRecordCount(); i++) {
+            TaxiPathNode node;
+            node.id = pathNodeDbc->getUInt32(i, tpnL ? (*tpnL)["ID"] : 0);
+            node.pathId = pathNodeDbc->getUInt32(i, tpnL ? (*tpnL)["PathID"] : 1);
+            node.nodeIndex = pathNodeDbc->getUInt32(i, tpnL ? (*tpnL)["NodeIndex"] : 2);
+            node.mapId = pathNodeDbc->getUInt32(i, tpnL ? (*tpnL)["MapID"] : 3);
+            node.x = pathNodeDbc->getFloat(i, tpnL ? (*tpnL)["X"] : 4);
+            node.y = pathNodeDbc->getFloat(i, tpnL ? (*tpnL)["Y"] : 5);
+            node.z = pathNodeDbc->getFloat(i, tpnL ? (*tpnL)["Z"] : 6);
+            taxiPathNodes_[node.pathId].push_back(node);
+        }
+        // Sort waypoints by nodeIndex for each path
+        for (auto& [pathId, nodes] : taxiPathNodes_) {
+            std::sort(nodes.begin(), nodes.end(),
+                [](const TaxiPathNode& a, const TaxiPathNode& b) {
+                    return a.nodeIndex < b.nodeIndex;
+                });
+        }
+        LOG_INFO("Loaded ", pathNodeDbc->getRecordCount(), " taxi path waypoints from TaxiPathNode.dbc");
+    } else {
+        LOG_WARNING("Could not load TaxiPathNode.dbc");
+    }
+}
+
+void GameHandler::handleShowTaxiNodes(network::Packet& packet) {
+    ShowTaxiNodesData data;
+    if (!ShowTaxiNodesParser::parse(packet, data)) {
+        LOG_WARNING("Failed to parse SMSG_SHOWTAXINODES");
+        return;
+    }
+
+    loadTaxiDbc();
+
+    // Detect newly discovered flight paths by comparing with stored mask
+    if (taxiMaskInitialized_) {
+        for (uint32_t i = 0; i < TLK_TAXI_MASK_SIZE; ++i) {
+            uint32_t newBits = data.nodeMask[i] & ~knownTaxiMask_[i];
+            if (newBits == 0) continue;
+            for (uint32_t bit = 0; bit < 32; ++bit) {
+                if (newBits & (1u << bit)) {
+                    uint32_t nodeId = i * 32 + bit + 1;
+                    auto it = taxiNodes_.find(nodeId);
+                    if (it != taxiNodes_.end()) {
+                        addSystemChatMessage("Discovered flight path: " + it->second.name);
+                    }
+                }
+            }
+        }
+    }
+
+    // Update stored mask
+    for (uint32_t i = 0; i < TLK_TAXI_MASK_SIZE; ++i) {
+        knownTaxiMask_[i] = data.nodeMask[i];
+    }
+    taxiMaskInitialized_ = true;
+
+    currentTaxiData_ = data;
+    taxiNpcGuid_ = data.npcGuid;
+    taxiWindowOpen_ = true;
+    gossipWindowOpen = false;
+    buildTaxiCostMap();
+    auto it = taxiNodes_.find(data.nearestNode);
+    if (it != taxiNodes_.end()) {
+        LOG_INFO("Taxi node ", data.nearestNode, " mounts: A=", it->second.mountDisplayIdAlliance,
+                 " H=", it->second.mountDisplayIdHorde);
+    }
+    LOG_INFO("Taxi window opened, nearest node=", data.nearestNode);
+}
+
+void GameHandler::applyTaxiMountForCurrentNode() {
+    if (taxiMountActive_ || !mountCallback_) return;
+    auto it = taxiNodes_.find(currentTaxiData_.nearestNode);
+    if (it == taxiNodes_.end()) {
+        // Node not in DBC (custom server nodes, missing data) — use hardcoded fallback.
+        bool isAlliance = true;
+        switch (playerRace_) {
+            case Race::ORC: case Race::UNDEAD: case Race::TAUREN: case Race::TROLL:
+            case Race::GOBLIN: case Race::BLOOD_ELF:
+                isAlliance = false; break;
+            default: break;
+        }
+        uint32_t mountId = isAlliance ? 1210u : 1310u;
+        taxiMountDisplayId_ = mountId;
+        taxiMountActive_ = true;
+        LOG_INFO("Taxi mount fallback (node ", currentTaxiData_.nearestNode, " not in DBC): displayId=", mountId);
+        mountCallback_(mountId);
+        return;
+    }
+
+    bool isAlliance = true;
+    switch (playerRace_) {
+        case Race::ORC:
+        case Race::UNDEAD:
+        case Race::TAUREN:
+        case Race::TROLL:
+        case Race::GOBLIN:
+        case Race::BLOOD_ELF:
+            isAlliance = false;
+            break;
+        default:
+            isAlliance = true;
+            break;
+    }
+    uint32_t mountId = isAlliance ? it->second.mountDisplayIdAlliance
+                                  : it->second.mountDisplayIdHorde;
+    if (mountId == 541) mountId = 0;  // Placeholder/invalid in some DBC sets
+    if (mountId == 0) {
+        mountId = isAlliance ? it->second.mountDisplayIdHorde
+                             : it->second.mountDisplayIdAlliance;
+        if (mountId == 541) mountId = 0;
+    }
+    if (mountId == 0) {
+        auto& app = core::Application::getInstance();
+        uint32_t gryphonId = app.getGryphonDisplayId();
+        uint32_t wyvernId = app.getWyvernDisplayId();
+        if (isAlliance && gryphonId != 0) mountId = gryphonId;
+        if (!isAlliance && wyvernId != 0) mountId = wyvernId;
+        if (mountId == 0) {
+            mountId = (isAlliance ? wyvernId : gryphonId);
+        }
+    }
+    if (mountId == 0) {
+        // Fallback: any non-zero mount display from the node.
+        if (it->second.mountDisplayIdAlliance != 0) mountId = it->second.mountDisplayIdAlliance;
+        else if (it->second.mountDisplayIdHorde != 0) mountId = it->second.mountDisplayIdHorde;
+    }
+    if (mountId == 0) {
+        // 3.3.5a fallback display IDs (real CreatureDisplayInfo entries).
+        // Alliance taxi gryphons commonly use 1210-1213.
+        // Horde taxi wyverns commonly use 1310-1312.
+        static const uint32_t kAllianceTaxiDisplays[] = {1210u, 1211u, 1212u, 1213u};
+        static const uint32_t kHordeTaxiDisplays[] = {1310u, 1311u, 1312u};
+        mountId = isAlliance ? kAllianceTaxiDisplays[0] : kHordeTaxiDisplays[0];
+    }
+
+    // Last resort legacy fallback.
+    if (mountId == 0) {
+        mountId = isAlliance ? 30412u : 30413u;
+    }
+    if (mountId != 0) {
+        taxiMountDisplayId_ = mountId;
+        taxiMountActive_ = true;
+        LOG_INFO("Taxi mount apply: displayId=", mountId);
+        mountCallback_(mountId);
+    }
+}
+
+void GameHandler::startClientTaxiPath(const std::vector<uint32_t>& pathNodes) {
+    taxiClientPath_.clear();
+    taxiClientIndex_ = 0;
+    taxiClientActive_ = false;
+    taxiClientSegmentProgress_ = 0.0f;
+
+    // Build full spline path using TaxiPathNode waypoints (not just node positions)
+    for (size_t i = 0; i + 1 < pathNodes.size(); i++) {
+        uint32_t fromNode = pathNodes[i];
+        uint32_t toNode = pathNodes[i + 1];
+        // Find the pathId connecting these nodes
+        uint32_t pathId = 0;
+        for (const auto& edge : taxiPathEdges_) {
+            if (edge.fromNode == fromNode && edge.toNode == toNode) {
+                pathId = edge.pathId;
+                break;
+            }
+        }
+        if (pathId == 0) {
+            LOG_WARNING("No taxi path found from node ", fromNode, " to ", toNode);
+            continue;
+        }
+        // Get spline waypoints for this path segment
+        auto pathIt = taxiPathNodes_.find(pathId);
+        if (pathIt != taxiPathNodes_.end()) {
+            for (const auto& wpNode : pathIt->second) {
+                glm::vec3 serverPos(wpNode.x, wpNode.y, wpNode.z);
+                glm::vec3 canonical = core::coords::serverToCanonical(serverPos);
+                taxiClientPath_.push_back(canonical);
+            }
+        } else {
+            LOG_WARNING("No spline waypoints found for taxi pathId ", pathId);
+        }
+    }
+
+    if (taxiClientPath_.size() < 2) {
+        // Fallback: use TaxiNodes directly when TaxiPathNode spline data is missing.
+        taxiClientPath_.clear();
+        for (uint32_t nodeId : pathNodes) {
+            auto nodeIt = taxiNodes_.find(nodeId);
+            if (nodeIt == taxiNodes_.end()) continue;
+            glm::vec3 serverPos(nodeIt->second.x, nodeIt->second.y, nodeIt->second.z);
+            taxiClientPath_.push_back(core::coords::serverToCanonical(serverPos));
+        }
+    }
+
+    if (taxiClientPath_.size() < 2) {
+        LOG_WARNING("Taxi path too short: ", taxiClientPath_.size(), " waypoints");
+        return;
+    }
+
+    // Set initial orientation to face the first non-degenerate flight segment.
+    glm::vec3 start = taxiClientPath_[0];
+    glm::vec3 dir(0.0f);
+    float dirLen = 0.0f;
+    for (size_t i = 1; i < taxiClientPath_.size(); i++) {
+        dir = taxiClientPath_[i] - start;
+        dirLen = glm::length(dir);
+        if (dirLen >= 0.001f) {
+            break;
+        }
+    }
+
+    float initialOrientation = movementInfo.orientation;
+    float initialRenderYaw = movementInfo.orientation;
+    float initialPitch = 0.0f;
+    float initialRoll = 0.0f;
+    if (dirLen >= 0.001f) {
+        initialOrientation = std::atan2(dir.y, dir.x);
+        glm::vec3 renderDir = core::coords::canonicalToRender(dir);
+        initialRenderYaw = std::atan2(renderDir.y, renderDir.x);
+        glm::vec3 dirNorm = dir / dirLen;
+        initialPitch = std::asin(std::clamp(dirNorm.z, -1.0f, 1.0f));
+    }
+
+    movementInfo.x = start.x;
+    movementInfo.y = start.y;
+    movementInfo.z = start.z;
+    movementInfo.orientation = initialOrientation;
+    sanitizeMovementForTaxi();
+
+    auto playerEntity = entityManager.getEntity(playerGuid);
+    if (playerEntity) {
+        playerEntity->setPosition(start.x, start.y, start.z, initialOrientation);
+    }
+
+    if (taxiOrientationCallback_) {
+        taxiOrientationCallback_(initialRenderYaw, initialPitch, initialRoll);
+    }
+
+    LOG_INFO("Taxi flight started with ", taxiClientPath_.size(), " spline waypoints");
+    taxiClientActive_ = true;
+}
+
 void GameHandler::updateClientTaxi(float deltaTime) {
-    if (movementHandler_) movementHandler_->updateClientTaxi(deltaTime);
+    if (!taxiClientActive_ || taxiClientPath_.size() < 2) return;
+    auto playerEntity = entityManager.getEntity(playerGuid);
+
+    auto finishTaxiFlight = [&]() {
+            // Snap player to the last waypoint (landing position) before clearing state.
+            // Without this, the player would be left at whatever mid-flight position
+            // they were at when the path completion was detected.
+            if (!taxiClientPath_.empty()) {
+                const auto& landingPos = taxiClientPath_.back();
+                if (playerEntity) {
+                    playerEntity->setPosition(landingPos.x, landingPos.y, landingPos.z,
+                                              movementInfo.orientation);
+                }
+                movementInfo.x = landingPos.x;
+                movementInfo.y = landingPos.y;
+                movementInfo.z = landingPos.z;
+                LOG_INFO("Taxi landing: snapped to final waypoint (",
+                         landingPos.x, ", ", landingPos.y, ", ", landingPos.z, ")");
+            }
+            taxiClientActive_ = false;
+            onTaxiFlight_ = false;
+            taxiLandingCooldown_ = 2.0f;  // 2 second cooldown to prevent re-entering
+            if (taxiMountActive_ && mountCallback_) {
+                mountCallback_(0);
+            }
+            taxiMountActive_ = false;
+            taxiMountDisplayId_ = 0;
+            currentMountDisplayId_ = 0;
+            taxiClientPath_.clear();
+            taxiRecoverPending_ = false;
+            movementInfo.flags = 0;
+            movementInfo.flags2 = 0;
+            if (socket) {
+                sendMovement(Opcode::MSG_MOVE_STOP);
+                sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
+            }
+            LOG_INFO("Taxi flight landed (client path)");
+    };
+
+    if (taxiClientIndex_ + 1 >= taxiClientPath_.size()) {
+        finishTaxiFlight();
+        return;
+    }
+
+    float remainingDistance = taxiClientSegmentProgress_ + (taxiClientSpeed_ * deltaTime);
+    glm::vec3 start(0.0f);
+    glm::vec3 end(0.0f);
+    glm::vec3 dir(0.0f);
+    float segmentLen = 0.0f;
+    float t = 0.0f;
+
+    // Consume as many tiny/finished segments as needed this frame so taxi doesn't stall
+    // on dense/degenerate node clusters near takeoff/landing.
+    while (true) {
+        if (taxiClientIndex_ + 1 >= taxiClientPath_.size()) {
+            finishTaxiFlight();
+            return;
+        }
+
+        start = taxiClientPath_[taxiClientIndex_];
+        end = taxiClientPath_[taxiClientIndex_ + 1];
+        dir = end - start;
+        segmentLen = glm::length(dir);
+
+        if (segmentLen < 0.01f) {
+            taxiClientIndex_++;
+            continue;
+        }
+
+        if (remainingDistance >= segmentLen) {
+            remainingDistance -= segmentLen;
+            taxiClientIndex_++;
+            taxiClientSegmentProgress_ = 0.0f;
+            continue;
+        }
+
+        taxiClientSegmentProgress_ = remainingDistance;
+        t = taxiClientSegmentProgress_ / segmentLen;
+        break;
+    }
+
+    // Use Catmull-Rom spline for smooth interpolation between waypoints
+    // Get surrounding points for spline curve
+    glm::vec3 p0 = (taxiClientIndex_ > 0) ? taxiClientPath_[taxiClientIndex_ - 1] : start;
+    glm::vec3 p1 = start;
+    glm::vec3 p2 = end;
+    glm::vec3 p3 = (taxiClientIndex_ + 2 < taxiClientPath_.size()) ?
+                   taxiClientPath_[taxiClientIndex_ + 2] : end;
+
+    // Catmull-Rom spline formula for smooth curves
+    float t2 = t * t;
+    float t3 = t2 * t;
+    glm::vec3 nextPos = 0.5f * (
+        (2.0f * p1) +
+        (-p0 + p2) * t +
+        (2.0f * p0 - 5.0f * p1 + 4.0f * p2 - p3) * t2 +
+        (-p0 + 3.0f * p1 - 3.0f * p2 + p3) * t3
+    );
+
+    // Calculate smooth direction for orientation (tangent to spline)
+    glm::vec3 tangent = 0.5f * (
+        (-p0 + p2) +
+        2.0f * (2.0f * p0 - 5.0f * p1 + 4.0f * p2 - p3) * t +
+        3.0f * (-p0 + 3.0f * p1 - 3.0f * p2 + p3) * t2
+    );
+    float tangentLen = glm::length(tangent);
+    if (tangentLen < 0.0001f) {
+        tangent = dir;
+        tangentLen = glm::length(tangent);
+        if (tangentLen < 0.0001f) {
+            tangent = glm::vec3(std::cos(movementInfo.orientation), std::sin(movementInfo.orientation), 0.0f);
+            tangentLen = glm::length(tangent);
+        }
+    }
+
+    // Calculate yaw from horizontal direction
+    float targetOrientation = std::atan2(tangent.y, tangent.x);
+
+    // Calculate pitch from vertical component (altitude change)
+    glm::vec3 tangentNorm = tangent / std::max(tangentLen, 0.0001f);
+    float pitch = std::asin(std::clamp(tangentNorm.z, -1.0f, 1.0f));
+
+    // Calculate roll (banking) from rate of yaw change
+    float currentOrientation = movementInfo.orientation;
+    float orientDiff = targetOrientation - currentOrientation;
+    // Normalize angle difference to [-PI, PI]
+    while (orientDiff > 3.14159265f) orientDiff -= 6.28318530f;
+    while (orientDiff < -3.14159265f) orientDiff += 6.28318530f;
+    // Bank proportional to turn rate (scaled for visual effect)
+    float roll = -orientDiff * 2.5f;
+    roll = std::clamp(roll, -0.7f, 0.7f);  // Limit to ~40 degrees
+
+    // Smooth rotation transition (lerp towards target)
+    float smoothOrientation = currentOrientation + orientDiff * std::min(1.0f, deltaTime * 3.0f);
+
+    if (playerEntity) {
+        playerEntity->setPosition(nextPos.x, nextPos.y, nextPos.z, smoothOrientation);
+    }
+    movementInfo.x = nextPos.x;
+    movementInfo.y = nextPos.y;
+    movementInfo.z = nextPos.z;
+    movementInfo.orientation = smoothOrientation;
+
+    // Update mount rotation with yaw/pitch/roll. Use render-space tangent yaw to
+    // avoid canonical<->render convention mismatches.
+    if (taxiOrientationCallback_) {
+        glm::vec3 renderTangent = core::coords::canonicalToRender(tangent);
+        float renderYaw = std::atan2(renderTangent.y, renderTangent.x);
+        taxiOrientationCallback_(renderYaw, pitch, roll);
+    }
+}
+
+void GameHandler::handleActivateTaxiReply(network::Packet& packet) {
+    ActivateTaxiReplyData data;
+    if (!ActivateTaxiReplyParser::parse(packet, data)) {
+        LOG_WARNING("Failed to parse SMSG_ACTIVATETAXIREPLY");
+        return;
+    }
+
+    // Guard against stray/mis-mapped packets being treated as taxi replies.
+    // We only consume a reply while an activation request is pending.
+    if (!taxiActivatePending_) {
+        LOG_DEBUG("Ignoring stray taxi reply: result=", data.result);
+        return;
+    }
+
+    if (data.result == 0) {
+        // Some cores can emit duplicate success replies (e.g. basic + express activate).
+        // Ignore repeats once taxi is already active and no activation is pending.
+        if (onTaxiFlight_ && !taxiActivatePending_) {
+            return;
+        }
+        onTaxiFlight_ = true;
+        taxiStartGrace_ = std::max(taxiStartGrace_, 2.0f);
+        sanitizeMovementForTaxi();
+        taxiWindowOpen_ = false;
+        taxiActivatePending_ = false;
+        taxiActivateTimer_ = 0.0f;
+        applyTaxiMountForCurrentNode();
+        if (socket) {
+            sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
+        }
+        LOG_INFO("Taxi flight started!");
+    } else {
+        // If local taxi motion already started, treat late failure as stale and ignore.
+        if (onTaxiFlight_ || taxiClientActive_) {
+            LOG_WARNING("Ignoring stale taxi failure reply while flight is active: result=", data.result);
+            taxiActivatePending_ = false;
+            taxiActivateTimer_ = 0.0f;
+            return;
+        }
+        LOG_WARNING("Taxi activation failed, result=", data.result);
+        addSystemChatMessage("Cannot take that flight path.");
+        taxiActivatePending_ = false;
+        taxiActivateTimer_ = 0.0f;
+        if (taxiMountActive_ && mountCallback_) {
+            mountCallback_(0);
+        }
+        taxiMountActive_ = false;
+        taxiMountDisplayId_ = 0;
+        onTaxiFlight_ = false;
+    }
 }
 
 void GameHandler::closeTaxi() {
-    if (movementHandler_) movementHandler_->closeTaxi();
+    taxiWindowOpen_ = false;
+
+    // Closing the taxi UI must not cancel an active/pending flight.
+    // The window can auto-close due distance checks while takeoff begins.
+    if (taxiActivatePending_ || onTaxiFlight_ || taxiClientActive_) {
+        return;
+    }
+
+    // If we optimistically mounted during node selection, dismount now
+    if (taxiMountActive_ && mountCallback_) {
+        mountCallback_(0);  // Dismount
+    }
+    taxiMountActive_ = false;
+    taxiMountDisplayId_ = 0;
+
+    // Clear any pending activation
+    taxiActivatePending_ = false;
+    onTaxiFlight_ = false;
+
+    // Set cooldown to prevent auto-mount trigger from re-applying taxi mount
+    // (The UNIT_FLAG_TAXI_FLIGHT check in handleUpdateObject won't re-trigger during cooldown)
+    taxiLandingCooldown_ = 2.0f;
+}
+
+void GameHandler::buildTaxiCostMap() {
+    taxiCostMap_.clear();
+    uint32_t startNode = currentTaxiData_.nearestNode;
+    if (startNode == 0) return;
+
+    // Build adjacency list with costs from all edges (path may traverse unknown nodes)
+    struct AdjEntry { uint32_t node; uint32_t cost; };
+    std::unordered_map<uint32_t, std::vector<AdjEntry>> adj;
+    for (const auto& edge : taxiPathEdges_) {
+        adj[edge.fromNode].push_back({edge.toNode, edge.cost});
+    }
+
+    // BFS from startNode, accumulating costs along the path
+    std::deque<uint32_t> queue;
+    queue.push_back(startNode);
+    taxiCostMap_[startNode] = 0;
+
+    while (!queue.empty()) {
+        uint32_t cur = queue.front();
+        queue.pop_front();
+        for (const auto& next : adj[cur]) {
+            if (taxiCostMap_.find(next.node) == taxiCostMap_.end()) {
+                taxiCostMap_[next.node] = taxiCostMap_[cur] + next.cost;
+                queue.push_back(next.node);
+            }
+        }
+    }
 }
 
 uint32_t GameHandler::getTaxiCostTo(uint32_t destNodeId) const {
-    if (movementHandler_) return movementHandler_->getTaxiCostTo(destNodeId);
-    return 0;
+    auto it = taxiCostMap_.find(destNodeId);
+    return (it != taxiCostMap_.end()) ? it->second : 0;
 }
 
 void GameHandler::activateTaxi(uint32_t destNodeId) {
-    if (movementHandler_) movementHandler_->activateTaxi(destNodeId);
+    if (!socket || state != WorldState::IN_WORLD) return;
+
+    // One-shot taxi activation until server replies or timeout.
+    if (taxiActivatePending_ || onTaxiFlight_) {
+        return;
+    }
+
+    uint32_t startNode = currentTaxiData_.nearestNode;
+    if (startNode == 0 || destNodeId == 0 || startNode == destNodeId) return;
+
+    // If already mounted, dismount before starting a taxi flight.
+    if (isMounted()) {
+        LOG_INFO("Taxi activate: dismounting current mount");
+        if (mountCallback_) mountCallback_(0);
+        currentMountDisplayId_ = 0;
+        dismount();
+    }
+
+    addSystemChatMessage("Taxi: requesting flight...");
+
+    // BFS to find path from startNode to destNodeId
+    std::unordered_map<uint32_t, std::vector<uint32_t>> adj;
+    for (const auto& edge : taxiPathEdges_) {
+        adj[edge.fromNode].push_back(edge.toNode);
+    }
+
+    std::unordered_map<uint32_t, uint32_t> parent;
+    std::deque<uint32_t> queue;
+    queue.push_back(startNode);
+    parent[startNode] = startNode;
+
+    bool found = false;
+    while (!queue.empty()) {
+        uint32_t cur = queue.front();
+        queue.pop_front();
+        if (cur == destNodeId) { found = true; break; }
+        for (uint32_t next : adj[cur]) {
+            if (parent.find(next) == parent.end()) {
+                parent[next] = cur;
+                queue.push_back(next);
+            }
+        }
+    }
+
+    if (!found) {
+        LOG_WARNING("No taxi path found from node ", startNode, " to ", destNodeId);
+        addSystemChatMessage("No flight path available to that destination.");
+        return;
+    }
+
+    std::vector<uint32_t> path;
+    for (uint32_t n = destNodeId; n != startNode; n = parent[n]) {
+        path.push_back(n);
+    }
+    path.push_back(startNode);
+    std::reverse(path.begin(), path.end());
+
+    LOG_INFO("Taxi path: ", path.size(), " nodes, from ", startNode, " to ", destNodeId);
+
+    LOG_INFO("Taxi activate: npc=0x", std::hex, taxiNpcGuid_, std::dec,
+             " start=", startNode, " dest=", destNodeId, " pathLen=", path.size());
+    if (!path.empty()) {
+        std::string pathStr;
+        for (size_t i = 0; i < path.size(); i++) {
+            pathStr += std::to_string(path[i]);
+            if (i + 1 < path.size()) pathStr += "->";
+        }
+        LOG_INFO("Taxi path nodes: ", pathStr);
+    }
+
+    uint32_t totalCost = getTaxiCostTo(destNodeId);
+    LOG_INFO("Taxi activate: start=", startNode, " dest=", destNodeId, " cost=", totalCost);
+
+    // Some servers only accept basic CMSG_ACTIVATETAXI.
+    auto basicPkt = ActivateTaxiPacket::build(taxiNpcGuid_, startNode, destNodeId);
+    socket->send(basicPkt);
+
+    // AzerothCore in this setup rejects/misparses CMSG_ACTIVATETAXIEXPRESS (0x312),
+    // so keep taxi activation on the basic packet only.
+
+    // Optimistically start taxi visuals; server will correct if it denies.
+    taxiWindowOpen_ = false;
+    taxiActivatePending_ = true;
+    taxiActivateTimer_ = 0.0f;
+    taxiStartGrace_ = 2.0f;
+    if (!onTaxiFlight_) {
+        onTaxiFlight_ = true;
+        sanitizeMovementForTaxi();
+        applyTaxiMountForCurrentNode();
+    }
+    if (socket) {
+        sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
+    }
+
+    // Trigger terrain precache immediately (non-blocking).
+    if (taxiPrecacheCallback_) {
+        std::vector<glm::vec3> previewPath;
+        // Build full spline path using TaxiPathNode waypoints
+        for (size_t i = 0; i + 1 < path.size(); i++) {
+            uint32_t fromNode = path[i];
+            uint32_t toNode = path[i + 1];
+            // Find the pathId connecting these nodes
+            uint32_t pathId = 0;
+            for (const auto& edge : taxiPathEdges_) {
+                if (edge.fromNode == fromNode && edge.toNode == toNode) {
+                    pathId = edge.pathId;
+                    break;
+                }
+            }
+            if (pathId == 0) continue;
+            // Get spline waypoints for this path segment
+            auto pathIt = taxiPathNodes_.find(pathId);
+            if (pathIt != taxiPathNodes_.end()) {
+                for (const auto& wpNode : pathIt->second) {
+                    glm::vec3 serverPos(wpNode.x, wpNode.y, wpNode.z);
+                    glm::vec3 canonical = core::coords::serverToCanonical(serverPos);
+                    previewPath.push_back(canonical);
+                }
+            }
+        }
+        if (previewPath.size() >= 2) {
+            taxiPrecacheCallback_(previewPath);
+        }
+    }
+
+    // Flight starts immediately; upload callback stays opportunistic/non-blocking.
+    if (taxiFlightStartCallback_) {
+        taxiFlightStartCallback_();
+    }
+    startClientTaxiPath(path);
+    // We run taxi movement locally immediately; don't keep a long-lived pending state.
+    if (taxiClientActive_) {
+        taxiActivatePending_ = false;
+        taxiActivateTimer_ = 0.0f;
+    }
+
+    addSystemChatMessage("Flight started.");
+
+    // Save recovery target in case of disconnect during taxi.
+    auto destIt = taxiNodes_.find(destNodeId);
+    if (destIt != taxiNodes_.end()) {
+        taxiRecoverMapId_ = destIt->second.mapId;
+        taxiRecoverPos_ = core::coords::serverToCanonical(
+            glm::vec3(destIt->second.x, destIt->second.y, destIt->second.z));
+        taxiRecoverPending_ = false;
+    }
 }
 
 // ============================================================
@@ -6240,6 +15806,196 @@ void GameHandler::handleQueryTimeResponse(network::Packet& packet) {
     LOG_INFO("Server time: ", data.serverTime, " (", timeStr, ")");
 }
 
+void GameHandler::handlePlayedTime(network::Packet& packet) {
+    PlayedTimeData data;
+    if (!PlayedTimeParser::parse(packet, data)) {
+        LOG_WARNING("Failed to parse SMSG_PLAYED_TIME");
+        return;
+    }
+
+    if (data.triggerMessage) {
+        // Format total time played
+        uint32_t totalDays = data.totalTimePlayed / 86400;
+        uint32_t totalHours = (data.totalTimePlayed % 86400) / 3600;
+        uint32_t totalMinutes = (data.totalTimePlayed % 3600) / 60;
+
+        // Format level time played
+        uint32_t levelDays = data.levelTimePlayed / 86400;
+        uint32_t levelHours = (data.levelTimePlayed % 86400) / 3600;
+        uint32_t levelMinutes = (data.levelTimePlayed % 3600) / 60;
+
+        std::string totalMsg = "Total time played: ";
+        if (totalDays > 0) totalMsg += std::to_string(totalDays) + " days, ";
+        if (totalHours > 0 || totalDays > 0) totalMsg += std::to_string(totalHours) + " hours, ";
+        totalMsg += std::to_string(totalMinutes) + " minutes";
+
+        std::string levelMsg = "Time played this level: ";
+        if (levelDays > 0) levelMsg += std::to_string(levelDays) + " days, ";
+        if (levelHours > 0 || levelDays > 0) levelMsg += std::to_string(levelHours) + " hours, ";
+        levelMsg += std::to_string(levelMinutes) + " minutes";
+
+        addSystemChatMessage(totalMsg);
+        addSystemChatMessage(levelMsg);
+    }
+
+    LOG_INFO("Played time: total=", data.totalTimePlayed, "s, level=", data.levelTimePlayed, "s");
+}
+
+void GameHandler::handleWho(network::Packet& packet) {
+    // Parse WHO response
+    uint32_t displayCount = packet.readUInt32();
+    uint32_t onlineCount = packet.readUInt32();
+
+    LOG_INFO("WHO response: ", displayCount, " players displayed, ", onlineCount, " total online");
+
+    if (displayCount == 0) {
+        addSystemChatMessage("No players found.");
+        return;
+    }
+
+    addSystemChatMessage(std::to_string(onlineCount) + " player(s) online:");
+
+    for (uint32_t i = 0; i < displayCount; ++i) {
+        std::string playerName = packet.readString();
+        std::string guildName = packet.readString();
+        uint32_t level = packet.readUInt32();
+        uint32_t classId = packet.readUInt32();
+        uint32_t raceId = packet.readUInt32();
+        packet.readUInt8();   // gender (unused)
+        packet.readUInt32();  // zoneId (unused)
+
+        std::string msg = "  " + playerName;
+        if (!guildName.empty()) {
+            msg += " <" + guildName + ">";
+        }
+        msg += " - Level " + std::to_string(level);
+
+        addSystemChatMessage(msg);
+        LOG_INFO("  ", playerName, " (", guildName, ") Lv", level, " Class:", classId, " Race:", raceId);
+    }
+}
+
+void GameHandler::handleFriendStatus(network::Packet& packet) {
+    FriendStatusData data;
+    if (!FriendStatusParser::parse(packet, data)) {
+        LOG_WARNING("Failed to parse SMSG_FRIEND_STATUS");
+        return;
+    }
+
+    // Look up player name from GUID
+    std::string playerName;
+    auto it = playerNameCache.find(data.guid);
+    if (it != playerNameCache.end()) {
+        playerName = it->second;
+    } else {
+        playerName = "Unknown";
+    }
+
+    // Update friends cache
+    if (data.status == 1 || data.status == 2) {  // Added or online
+        friendsCache[playerName] = data.guid;
+    } else if (data.status == 0) {  // Removed
+        friendsCache.erase(playerName);
+    }
+
+    // Status messages
+    switch (data.status) {
+        case 0:
+            addSystemChatMessage(playerName + " has been removed from your friends list.");
+            break;
+        case 1:
+            addSystemChatMessage(playerName + " has been added to your friends list.");
+            break;
+        case 2:
+            addSystemChatMessage(playerName + " is now online.");
+            break;
+        case 3:
+            addSystemChatMessage(playerName + " is now offline.");
+            break;
+        case 4:
+            addSystemChatMessage("Player not found.");
+            break;
+        case 5:
+            addSystemChatMessage(playerName + " is already in your friends list.");
+            break;
+        case 6:
+            addSystemChatMessage("Your friends list is full.");
+            break;
+        case 7:
+            addSystemChatMessage(playerName + " is ignoring you.");
+            break;
+        default:
+            LOG_INFO("Friend status: ", (int)data.status, " for ", playerName);
+            break;
+    }
+
+    LOG_INFO("Friend status update: ", playerName, " status=", (int)data.status);
+}
+
+void GameHandler::handleRandomRoll(network::Packet& packet) {
+    RandomRollData data;
+    if (!RandomRollParser::parse(packet, data)) {
+        LOG_WARNING("Failed to parse SMSG_RANDOM_ROLL");
+        return;
+    }
+
+    // Get roller name
+    std::string rollerName;
+    if (data.rollerGuid == playerGuid) {
+        rollerName = "You";
+    } else {
+        auto it = playerNameCache.find(data.rollerGuid);
+        if (it != playerNameCache.end()) {
+            rollerName = it->second;
+        } else {
+            rollerName = "Someone";
+        }
+    }
+
+    // Build message
+    std::string msg = rollerName;
+    if (data.rollerGuid == playerGuid) {
+        msg += " roll ";
+    } else {
+        msg += " rolls ";
+    }
+    msg += std::to_string(data.result);
+    msg += " (" + std::to_string(data.minRoll) + "-" + std::to_string(data.maxRoll) + ")";
+
+    addSystemChatMessage(msg);
+    LOG_INFO("Random roll: ", rollerName, " rolled ", data.result, " (", data.minRoll, "-", data.maxRoll, ")");
+}
+
+void GameHandler::handleLogoutResponse(network::Packet& packet) {
+    LogoutResponseData data;
+    if (!LogoutResponseParser::parse(packet, data)) {
+        LOG_WARNING("Failed to parse SMSG_LOGOUT_RESPONSE");
+        return;
+    }
+
+    if (data.result == 0) {
+        // Success - logout initiated
+        if (data.instant) {
+            addSystemChatMessage("Logging out...");
+        } else {
+            addSystemChatMessage("Logging out in 20 seconds...");
+        }
+        LOG_INFO("Logout response: success, instant=", (int)data.instant);
+    } else {
+        // Failure
+        addSystemChatMessage("Cannot logout right now.");
+        loggingOut_ = false;
+        LOG_WARNING("Logout failed, result=", data.result);
+    }
+}
+
+void GameHandler::handleLogoutComplete(network::Packet& /*packet*/) {
+    addSystemChatMessage("Logout complete.");
+    loggingOut_ = false;
+    LOG_INFO("Logout complete");
+    // Server will disconnect us
+}
+
 uint32_t GameHandler::generateClientSeed() {
     // Generate cryptographically random seed
     std::random_device rd;
@@ -6250,7 +16006,7 @@ uint32_t GameHandler::generateClientSeed() {
 
 void GameHandler::setState(WorldState newState) {
     if (state != newState) {
-        LOG_DEBUG("World state: ", static_cast<int>(state), " -> ", static_cast<int>(newState));
+        LOG_DEBUG("World state: ", (int)state, " -> ", (int)newState);
         state = newState;
     }
 }
@@ -6264,6 +16020,7 @@ void GameHandler::fail(const std::string& reason) {
     }
 }
 
+
 // ============================================================
 // Player Skills
 // ============================================================
@@ -6280,25 +16037,107 @@ uint32_t GameHandler::getSkillCategory(uint32_t skillId) const {
     return (it != skillLineCategories_.end()) ? it->second : 0;
 }
 
-bool GameHandler::isProfessionSpell(uint32_t spellId) const {
-    auto slIt = spellToSkillLine_.find(spellId);
-    if (slIt == spellToSkillLine_.end()) return false;
-    auto catIt = skillLineCategories_.find(slIt->second);
-    if (catIt == skillLineCategories_.end()) return false;
-    // Category 11 = profession (Blacksmithing, etc.), 9 = secondary (Cooking, First Aid, Fishing)
-    return catIt->second == 11 || catIt->second == 9;
-}
-
 void GameHandler::loadSkillLineDbc() {
-    if (spellHandler_) spellHandler_->loadSkillLineDbc();
+    if (skillLineDbcLoaded_) return;
+    skillLineDbcLoaded_ = true;
+
+    auto* am = core::Application::getInstance().getAssetManager();
+    if (!am || !am->isInitialized()) return;
+
+    auto dbc = am->loadDBC("SkillLine.dbc");
+    if (!dbc || !dbc->isLoaded()) {
+        LOG_WARNING("GameHandler: Could not load SkillLine.dbc");
+        return;
+    }
+
+    const auto* slL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("SkillLine") : nullptr;
+    for (uint32_t i = 0; i < dbc->getRecordCount(); i++) {
+        uint32_t id = dbc->getUInt32(i, slL ? (*slL)["ID"] : 0);
+        uint32_t category = dbc->getUInt32(i, slL ? (*slL)["Category"] : 1);
+        std::string name = dbc->getString(i, slL ? (*slL)["Name"] : 3);
+        if (id > 0 && !name.empty()) {
+            skillLineNames_[id] = name;
+            skillLineCategories_[id] = category;
+        }
+    }
+    LOG_INFO("GameHandler: Loaded ", skillLineNames_.size(), " skill line names");
 }
 
 void GameHandler::extractSkillFields(const std::map<uint16_t, uint32_t>& fields) {
-    if (spellHandler_) spellHandler_->extractSkillFields(fields);
+    loadSkillLineDbc();
+
+    const uint16_t PLAYER_SKILL_INFO_START = fieldIndex(UF::PLAYER_SKILL_INFO_START);
+    static constexpr int MAX_SKILL_SLOTS = 128;
+
+    std::map<uint32_t, PlayerSkill> newSkills;
+
+    for (int slot = 0; slot < MAX_SKILL_SLOTS; slot++) {
+        uint16_t baseField = PLAYER_SKILL_INFO_START + slot * 3;
+
+        auto idIt = fields.find(baseField);
+        if (idIt == fields.end()) continue;
+
+        uint32_t raw0 = idIt->second;
+        uint16_t skillId = raw0 & 0xFFFF;
+        if (skillId == 0) continue;
+
+        auto valIt = fields.find(baseField + 1);
+        if (valIt == fields.end()) continue;
+
+        uint32_t raw1 = valIt->second;
+        uint16_t value = raw1 & 0xFFFF;
+        uint16_t maxValue = (raw1 >> 16) & 0xFFFF;
+
+        PlayerSkill skill;
+        skill.skillId = skillId;
+        skill.value = value;
+        skill.maxValue = maxValue;
+        newSkills[skillId] = skill;
+    }
+
+    // Detect increases and emit chat messages
+    for (const auto& [skillId, skill] : newSkills) {
+        if (skill.value == 0) continue;
+        auto oldIt = playerSkills_.find(skillId);
+        if (oldIt != playerSkills_.end() && skill.value > oldIt->second.value) {
+            // Filter out racial, generic, and hidden skills from announcements
+            // Category 5 = Attributes (Defense, etc.)
+            // Category 10 = Languages (Orcish, Common, etc.)
+            // Category 12 = Not Displayed (generic/hidden)
+            auto catIt = skillLineCategories_.find(skillId);
+            if (catIt != skillLineCategories_.end()) {
+                uint32_t category = catIt->second;
+                if (category == 5 || category == 10 || category == 12) {
+                    continue; // Skip announcement for racial/generic skills
+                }
+            }
+
+            const std::string& name = getSkillName(skillId);
+            std::string skillName = name.empty() ? ("Skill #" + std::to_string(skillId)) : name;
+            addSystemChatMessage("Your skill in " + skillName + " has increased to " + std::to_string(skill.value) + ".");
+        }
+    }
+
+    playerSkills_ = std::move(newSkills);
 }
 
 void GameHandler::extractExploredZoneFields(const std::map<uint16_t, uint32_t>& fields) {
-    if (spellHandler_) spellHandler_->extractExploredZoneFields(fields);
+    if (playerExploredZones_.size() != PLAYER_EXPLORED_ZONES_COUNT) {
+        playerExploredZones_.assign(PLAYER_EXPLORED_ZONES_COUNT, 0u);
+    }
+
+    bool foundAny = false;
+    for (size_t i = 0; i < PLAYER_EXPLORED_ZONES_COUNT; i++) {
+        const uint16_t fieldIdx = static_cast<uint16_t>(fieldIndex(UF::PLAYER_EXPLORED_ZONES_START) + i);
+        auto it = fields.find(fieldIdx);
+        if (it == fields.end()) continue;
+        playerExploredZones_[i] = it->second;
+        foundAny = true;
+    }
+
+    if (foundAny) {
+        hasPlayerExploredZones_ = true;
+    }
 }
 
 std::string GameHandler::getCharacterConfigDir() {
@@ -6313,21 +16152,6 @@ std::string GameHandler::getCharacterConfigDir() {
     return dir;
 }
 
-static const std::string EMPTY_MACRO_TEXT;
-
-const std::string& GameHandler::getMacroText(uint32_t macroId) const {
-    auto it = macros_.find(macroId);
-    return (it != macros_.end()) ? it->second : EMPTY_MACRO_TEXT;
-}
-
-void GameHandler::setMacroText(uint32_t macroId, const std::string& text) {
-    if (text.empty())
-        macros_.erase(macroId);
-    else
-        macros_[macroId] = text;
-    saveCharacterConfig();
-}
-
 void GameHandler::saveCharacterConfig() {
     const Character* ch = getActiveCharacter();
     if (!ch || ch->name.empty()) return;
@@ -6354,21 +16178,6 @@ void GameHandler::saveCharacterConfig() {
         out << "action_bar_" << i << "_id=" << actionBar[i].id << "\n";
     }
 
-    // Save client-side macro text (escape newlines as \n literal)
-    for (const auto& [id, text] : macros_) {
-        if (!text.empty()) {
-            std::string escaped;
-            escaped.reserve(text.size());
-            for (char c : text) {
-                if (c == '\n') { escaped += "\\n"; }
-                else if (c == '\r') { /* skip CR */ }
-                else if (c == '\\') { escaped += "\\\\"; }
-                else { escaped += c; }
-            }
-            out << "macro_" << id << "_text=" << escaped << "\n";
-        }
-    }
-
     // Save quest log
     out << "quest_log_count=" << questLog_.size() << "\n";
     for (size_t i = 0; i < questLog_.size(); i++) {
@@ -6378,16 +16187,6 @@ void GameHandler::saveCharacterConfig() {
         out << "quest_" << i << "_complete=" << (quest.complete ? 1 : 0) << "\n";
     }
 
-    // Save tracked quest IDs so the quest tracker restores on login
-    if (!trackedQuestIds_.empty()) {
-        std::string ids;
-        for (uint32_t qid : trackedQuestIds_) {
-            if (!ids.empty()) ids += ',';
-            ids += std::to_string(qid);
-        }
-        out << "tracked_quests=" << ids << "\n";
-    }
-
     LOG_INFO("Character config saved to ", path);
 }
 
@@ -6419,43 +16218,6 @@ void GameHandler::loadCharacterConfig() {
             try { savedGender = std::stoi(val); } catch (...) {}
         } else if (key == "use_female_model") {
             try { savedUseFemaleModel = std::stoi(val); } catch (...) {}
-        } else if (key.rfind("macro_", 0) == 0) {
-            // Parse macro_N_text
-            size_t firstUnder = 6; // length of "macro_"
-            size_t secondUnder = key.find('_', firstUnder);
-            if (secondUnder == std::string::npos) continue;
-            uint32_t macroId = 0;
-            try { macroId = static_cast<uint32_t>(std::stoul(key.substr(firstUnder, secondUnder - firstUnder))); } catch (...) { continue; }
-            if (key.substr(secondUnder + 1) == "text" && !val.empty()) {
-                // Unescape \n and \\ sequences
-                std::string unescaped;
-                unescaped.reserve(val.size());
-                for (size_t i = 0; i < val.size(); ++i) {
-                    if (val[i] == '\\' && i + 1 < val.size()) {
-                        if (val[i+1] == 'n')  { unescaped += '\n'; ++i; }
-                        else if (val[i+1] == '\\') { unescaped += '\\'; ++i; }
-                        else { unescaped += val[i]; }
-                    } else {
-                        unescaped += val[i];
-                    }
-                }
-                macros_[macroId] = std::move(unescaped);
-            }
-        } else if (key == "tracked_quests" && !val.empty()) {
-            // Parse comma-separated quest IDs
-            trackedQuestIds_.clear();
-            size_t tqPos = 0;
-            while (tqPos <= val.size()) {
-                size_t comma = val.find(',', tqPos);
-                std::string idStr = (comma != std::string::npos)
-                    ? val.substr(tqPos, comma - tqPos) : val.substr(tqPos);
-                try {
-                    uint32_t qid = static_cast<uint32_t>(std::stoul(idStr));
-                    if (qid != 0) trackedQuestIds_.insert(qid);
-                } catch (...) {}
-                if (comma == std::string::npos) break;
-                tqPos = comma + 1;
-            }
         } else if (key.rfind("action_bar_", 0) == 0) {
             // Parse action_bar_N_type or action_bar_N_id
             size_t firstUnderscore = 11; // length of "action_bar_"
@@ -6516,73 +16278,406 @@ void GameHandler::loadCharacterConfig() {
 void GameHandler::setTransportAttachment(uint64_t childGuid, ObjectType type, uint64_t transportGuid,
                                          const glm::vec3& localOffset, bool hasLocalOrientation,
                                          float localOrientation) {
-    if (movementHandler_) movementHandler_->setTransportAttachment(childGuid, type, transportGuid, localOffset, hasLocalOrientation, localOrientation);
+    if (childGuid == 0 || transportGuid == 0) {
+        return;
+    }
+
+    TransportAttachment& attachment = transportAttachments_[childGuid];
+    attachment.type = type;
+    attachment.transportGuid = transportGuid;
+    attachment.localOffset = localOffset;
+    attachment.hasLocalOrientation = hasLocalOrientation;
+    attachment.localOrientation = localOrientation;
 }
 
 void GameHandler::clearTransportAttachment(uint64_t childGuid) {
-    if (movementHandler_) movementHandler_->clearTransportAttachment(childGuid);
+    if (childGuid == 0) {
+        return;
+    }
+    transportAttachments_.erase(childGuid);
 }
 
-void GameHandler::updateAttachedTransportChildren(float deltaTime) {
-    if (movementHandler_) movementHandler_->updateAttachedTransportChildren(deltaTime);
+void GameHandler::updateAttachedTransportChildren(float /*deltaTime*/) {
+    if (!transportManager_ || transportAttachments_.empty()) {
+        return;
+    }
+
+    constexpr float kPosEpsilonSq = 0.0001f;
+    constexpr float kOriEpsilon = 0.001f;
+    std::vector<uint64_t> stale;
+    stale.reserve(8);
+
+    for (const auto& [childGuid, attachment] : transportAttachments_) {
+        auto entity = entityManager.getEntity(childGuid);
+        if (!entity) {
+            stale.push_back(childGuid);
+            continue;
+        }
+
+        ActiveTransport* transport = transportManager_->getTransport(attachment.transportGuid);
+        if (!transport) {
+            continue;
+        }
+
+        glm::vec3 composed = transportManager_->getPlayerWorldPosition(
+            attachment.transportGuid, attachment.localOffset);
+
+        float composedOrientation = entity->getOrientation();
+        if (attachment.hasLocalOrientation) {
+            float baseYaw = transport->hasServerYaw ? transport->serverYaw : 0.0f;
+            composedOrientation = baseYaw + attachment.localOrientation;
+        }
+
+        glm::vec3 oldPos(entity->getX(), entity->getY(), entity->getZ());
+        float oldOrientation = entity->getOrientation();
+        glm::vec3 delta = composed - oldPos;
+        const bool positionChanged = glm::dot(delta, delta) > kPosEpsilonSq;
+        const bool orientationChanged = std::abs(composedOrientation - oldOrientation) > kOriEpsilon;
+        if (!positionChanged && !orientationChanged) {
+            continue;
+        }
+
+        entity->setPosition(composed.x, composed.y, composed.z, composedOrientation);
+
+        if (attachment.type == ObjectType::UNIT) {
+            if (creatureMoveCallback_) {
+                creatureMoveCallback_(childGuid, composed.x, composed.y, composed.z, 0);
+            }
+        } else if (attachment.type == ObjectType::GAMEOBJECT) {
+            if (gameObjectMoveCallback_) {
+                gameObjectMoveCallback_(childGuid, composed.x, composed.y, composed.z, composedOrientation);
+            }
+        }
+    }
+
+    for (uint64_t guid : stale) {
+        transportAttachments_.erase(guid);
+    }
 }
 
 // ============================================================
 // Mail System
 // ============================================================
 
-void GameHandler::openMailbox(uint64_t guid) {
-    if (inventoryHandler_) inventoryHandler_->openMailbox(guid);
-}
-
 void GameHandler::closeMailbox() {
-    if (inventoryHandler_) inventoryHandler_->closeMailbox();
+    mailboxOpen_ = false;
+    mailboxGuid_ = 0;
+    mailInbox_.clear();
+    selectedMailIndex_ = -1;
+    showMailCompose_ = false;
 }
 
 void GameHandler::refreshMailList() {
-    if (inventoryHandler_) inventoryHandler_->refreshMailList();
+    if (state != WorldState::IN_WORLD || !socket || mailboxGuid_ == 0) return;
+    auto packet = GetMailListPacket::build(mailboxGuid_);
+    socket->send(packet);
 }
 
 void GameHandler::sendMail(const std::string& recipient, const std::string& subject,
-                           const std::string& body, uint64_t money, uint64_t cod) {
-    if (inventoryHandler_) inventoryHandler_->sendMail(recipient, subject, body, money, cod);
+                           const std::string& body, uint32_t money, uint32_t cod) {
+    if (state != WorldState::IN_WORLD) {
+        LOG_WARNING("sendMail: not in world");
+        return;
+    }
+    if (!socket) {
+        LOG_WARNING("sendMail: no socket");
+        return;
+    }
+    if (mailboxGuid_ == 0) {
+        LOG_WARNING("sendMail: mailboxGuid_ is 0 (mailbox closed?)");
+        return;
+    }
+    // Collect attached item GUIDs
+    std::vector<uint64_t> itemGuids;
+    for (const auto& att : mailAttachments_) {
+        if (att.occupied()) {
+            itemGuids.push_back(att.itemGuid);
+        }
+    }
+    auto packet = packetParsers_->buildSendMail(mailboxGuid_, recipient, subject, body, money, cod, itemGuids);
+    LOG_INFO("sendMail: to='", recipient, "' subject='", subject, "' money=", money,
+             " attachments=", itemGuids.size(), " mailboxGuid=", mailboxGuid_);
+    socket->send(packet);
+    clearMailAttachments();
 }
 
 bool GameHandler::attachItemFromBackpack(int backpackIndex) {
-    return inventoryHandler_ && inventoryHandler_->attachItemFromBackpack(backpackIndex);
+    if (backpackIndex < 0 || backpackIndex >= inventory.getBackpackSize()) return false;
+    const auto& slot = inventory.getBackpackSlot(backpackIndex);
+    if (slot.empty()) return false;
+
+    uint64_t itemGuid = backpackSlotGuids_[backpackIndex];
+    if (itemGuid == 0) {
+        itemGuid = resolveOnlineItemGuid(slot.item.itemId);
+    }
+    if (itemGuid == 0) {
+        addSystemChatMessage("Cannot attach: item not found.");
+        return false;
+    }
+
+    // Check not already attached
+    for (const auto& att : mailAttachments_) {
+        if (att.occupied() && att.itemGuid == itemGuid) return false;
+    }
+
+    // Find free attachment slot
+    for (int i = 0; i < MAIL_MAX_ATTACHMENTS; ++i) {
+        if (!mailAttachments_[i].occupied()) {
+            mailAttachments_[i].itemGuid = itemGuid;
+            mailAttachments_[i].item = slot.item;
+            mailAttachments_[i].srcBag = 0xFF;
+            mailAttachments_[i].srcSlot = static_cast<uint8_t>(23 + backpackIndex);
+            LOG_INFO("Mail attach: slot=", i, " item='", slot.item.name, "' guid=0x",
+                     std::hex, itemGuid, std::dec, " from backpack[", backpackIndex, "]");
+            return true;
+        }
+    }
+    addSystemChatMessage("Cannot attach: all attachment slots full.");
+    return false;
 }
 
 bool GameHandler::attachItemFromBag(int bagIndex, int slotIndex) {
-    return inventoryHandler_ && inventoryHandler_->attachItemFromBag(bagIndex, slotIndex);
+    if (bagIndex < 0 || bagIndex >= inventory.NUM_BAG_SLOTS) return false;
+    if (slotIndex < 0 || slotIndex >= inventory.getBagSize(bagIndex)) return false;
+    const auto& slot = inventory.getBagSlot(bagIndex, slotIndex);
+    if (slot.empty()) return false;
+
+    uint64_t itemGuid = 0;
+    uint64_t bagGuid = equipSlotGuids_[19 + bagIndex];
+    if (bagGuid != 0) {
+        auto it = containerContents_.find(bagGuid);
+        if (it != containerContents_.end() && slotIndex < static_cast<int>(it->second.numSlots)) {
+            itemGuid = it->second.slotGuids[slotIndex];
+        }
+    }
+    if (itemGuid == 0) {
+        itemGuid = resolveOnlineItemGuid(slot.item.itemId);
+    }
+    if (itemGuid == 0) {
+        addSystemChatMessage("Cannot attach: item not found.");
+        return false;
+    }
+
+    for (const auto& att : mailAttachments_) {
+        if (att.occupied() && att.itemGuid == itemGuid) return false;
+    }
+
+    for (int i = 0; i < MAIL_MAX_ATTACHMENTS; ++i) {
+        if (!mailAttachments_[i].occupied()) {
+            mailAttachments_[i].itemGuid = itemGuid;
+            mailAttachments_[i].item = slot.item;
+            mailAttachments_[i].srcBag = static_cast<uint8_t>(19 + bagIndex);
+            mailAttachments_[i].srcSlot = static_cast<uint8_t>(slotIndex);
+            LOG_INFO("Mail attach: slot=", i, " item='", slot.item.name, "' guid=0x",
+                     std::hex, itemGuid, std::dec, " from bag[", bagIndex, "][", slotIndex, "]");
+            return true;
+        }
+    }
+    addSystemChatMessage("Cannot attach: all attachment slots full.");
+    return false;
 }
 
 bool GameHandler::detachMailAttachment(int attachIndex) {
-    return inventoryHandler_ && inventoryHandler_->detachMailAttachment(attachIndex);
+    if (attachIndex < 0 || attachIndex >= MAIL_MAX_ATTACHMENTS) return false;
+    if (!mailAttachments_[attachIndex].occupied()) return false;
+    LOG_INFO("Mail detach: slot=", attachIndex, " item='", mailAttachments_[attachIndex].item.name, "'");
+    mailAttachments_[attachIndex] = MailAttachSlot{};
+    return true;
 }
 
 void GameHandler::clearMailAttachments() {
-    if (inventoryHandler_) inventoryHandler_->clearMailAttachments();
+    for (auto& att : mailAttachments_) att = MailAttachSlot{};
 }
 
 int GameHandler::getMailAttachmentCount() const {
-    if (inventoryHandler_) return inventoryHandler_->getMailAttachmentCount();
-    return 0;
+    int count = 0;
+    for (const auto& att : mailAttachments_) {
+        if (att.occupied()) ++count;
+    }
+    return count;
 }
 
 void GameHandler::mailTakeMoney(uint32_t mailId) {
-    if (inventoryHandler_) inventoryHandler_->mailTakeMoney(mailId);
+    if (state != WorldState::IN_WORLD || !socket || mailboxGuid_ == 0) return;
+    auto packet = MailTakeMoneyPacket::build(mailboxGuid_, mailId);
+    socket->send(packet);
 }
 
-void GameHandler::mailTakeItem(uint32_t mailId, uint32_t itemGuidLow) {
-    if (inventoryHandler_) inventoryHandler_->mailTakeItem(mailId, itemGuidLow);
+void GameHandler::mailTakeItem(uint32_t mailId, uint32_t itemIndex) {
+    if (state != WorldState::IN_WORLD || !socket || mailboxGuid_ == 0) return;
+    auto packet = packetParsers_->buildMailTakeItem(mailboxGuid_, mailId, itemIndex);
+    socket->send(packet);
 }
 
 void GameHandler::mailDelete(uint32_t mailId) {
-    if (inventoryHandler_) inventoryHandler_->mailDelete(mailId);
+    if (state != WorldState::IN_WORLD || !socket || mailboxGuid_ == 0) return;
+    // Find mail template ID for this mail
+    uint32_t templateId = 0;
+    for (const auto& m : mailInbox_) {
+        if (m.messageId == mailId) {
+            templateId = m.mailTemplateId;
+            break;
+        }
+    }
+    auto packet = packetParsers_->buildMailDelete(mailboxGuid_, mailId, templateId);
+    socket->send(packet);
 }
 
 void GameHandler::mailMarkAsRead(uint32_t mailId) {
-    if (inventoryHandler_) inventoryHandler_->mailMarkAsRead(mailId);
+    if (state != WorldState::IN_WORLD || !socket || mailboxGuid_ == 0) return;
+    auto packet = MailMarkAsReadPacket::build(mailboxGuid_, mailId);
+    socket->send(packet);
+}
+
+void GameHandler::handleShowMailbox(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 8) {
+        LOG_WARNING("SMSG_SHOW_MAILBOX too short");
+        return;
+    }
+    uint64_t guid = packet.readUInt64();
+    LOG_INFO("SMSG_SHOW_MAILBOX: guid=0x", std::hex, guid, std::dec);
+    mailboxGuid_ = guid;
+    mailboxOpen_ = true;
+    hasNewMail_ = false;
+    selectedMailIndex_ = -1;
+    showMailCompose_ = false;
+    // Request inbox contents
+    refreshMailList();
+}
+
+void GameHandler::handleMailListResult(network::Packet& packet) {
+    size_t remaining = packet.getSize() - packet.getReadPos();
+    if (remaining < 1) {
+        LOG_WARNING("SMSG_MAIL_LIST_RESULT too short (", remaining, " bytes)");
+        return;
+    }
+
+    // Delegate parsing to expansion-aware packet parser
+    packetParsers_->parseMailList(packet, mailInbox_);
+
+    // Resolve sender names (needs GameHandler context, so done here)
+    for (auto& msg : mailInbox_) {
+        if (msg.messageType == 0 && msg.senderGuid != 0) {
+            msg.senderName = getCachedPlayerName(msg.senderGuid);
+            if (msg.senderName.empty()) {
+                queryPlayerName(msg.senderGuid);
+                msg.senderName = "Unknown";
+            }
+        } else if (msg.messageType == 2) {
+            msg.senderName = "Auction House";
+        } else if (msg.messageType == 3) {
+            msg.senderName = getCachedCreatureName(msg.senderEntry);
+            if (msg.senderName.empty()) msg.senderName = "NPC";
+        } else {
+            msg.senderName = "System";
+        }
+    }
+
+    // Open the mailbox UI if it isn't already open (Vanilla has no SMSG_SHOW_MAILBOX).
+    if (!mailboxOpen_) {
+        LOG_INFO("Opening mailbox UI (triggered by SMSG_MAIL_LIST_RESULT)");
+        mailboxOpen_ = true;
+        hasNewMail_ = false;
+        selectedMailIndex_ = -1;
+        showMailCompose_ = false;
+    }
+}
+
+void GameHandler::handleSendMailResult(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 12) {
+        LOG_WARNING("SMSG_SEND_MAIL_RESULT too short");
+        return;
+    }
+
+    uint32_t mailId = packet.readUInt32();
+    uint32_t command = packet.readUInt32();
+    uint32_t error = packet.readUInt32();
+
+    // Commands: 0=send, 1=moneyTaken, 2=itemTaken, 3=returnedToSender, 4=deleted, 5=madePermanent
+    // Vanilla errors: 0=OK, 1=equipError, 2=cannotSendToSelf, 3=notEnoughMoney, 4=recipientNotFound, 5=notYourTeam, 6=internalError
+    static const char* cmdNames[] = {"Send", "TakeMoney", "TakeItem", "Return", "Delete", "MadePermanent"};
+    const char* cmdName = (command < 6) ? cmdNames[command] : "Unknown";
+
+    LOG_INFO("SMSG_SEND_MAIL_RESULT: mailId=", mailId, " cmd=", cmdName, " error=", error);
+
+    if (error == 0) {
+        // Success
+        switch (command) {
+            case 0: // Send
+                addSystemChatMessage("Mail sent successfully.");
+                showMailCompose_ = false;
+                refreshMailList();
+                break;
+            case 1: // Money taken
+                addSystemChatMessage("Money received from mail.");
+                refreshMailList();
+                break;
+            case 2: // Item taken
+                addSystemChatMessage("Item received from mail.");
+                refreshMailList();
+                break;
+            case 4: // Deleted
+                selectedMailIndex_ = -1;
+                refreshMailList();
+                break;
+            default:
+                refreshMailList();
+                break;
+        }
+    } else {
+        // Error
+        std::string errMsg = "Mail error: ";
+        switch (error) {
+            case 1: errMsg += "Equipment error."; break;
+            case 2: errMsg += "You cannot send mail to yourself."; break;
+            case 3: errMsg += "Not enough money."; break;
+            case 4: errMsg += "Recipient not found."; break;
+            case 5: errMsg += "Cannot send to the opposing faction."; break;
+            case 6: errMsg += "Internal mail error."; break;
+            case 14: errMsg += "Disabled for trial accounts."; break;
+            case 15: errMsg += "Recipient's mailbox is full."; break;
+            case 16: errMsg += "Cannot send wrapped items COD."; break;
+            case 17: errMsg += "Mail and chat suspended."; break;
+            case 18: errMsg += "Too many attachments."; break;
+            case 19: errMsg += "Invalid attachment."; break;
+            default: errMsg += "Unknown error (" + std::to_string(error) + ")."; break;
+        }
+        addSystemChatMessage(errMsg);
+    }
+}
+
+void GameHandler::handleReceivedMail(network::Packet& packet) {
+    // Server notifies us that new mail arrived
+    if (packet.getSize() - packet.getReadPos() >= 4) {
+        float nextMailTime = packet.readFloat();
+        (void)nextMailTime;
+    }
+    LOG_INFO("SMSG_RECEIVED_MAIL: New mail arrived!");
+    hasNewMail_ = true;
+    addSystemChatMessage("New mail has arrived.");
+    // If mailbox is open, refresh
+    if (mailboxOpen_) {
+        refreshMailList();
+    }
+}
+
+void GameHandler::handleQueryNextMailTime(network::Packet& packet) {
+    // Server response to MSG_QUERY_NEXT_MAIL_TIME
+    // If there's pending mail, the packet contains a float with time until next mail delivery
+    // A value of 0.0 or the presence of mail entries means there IS mail waiting
+    size_t remaining = packet.getSize() - packet.getReadPos();
+    if (remaining >= 4) {
+        float nextMailTime = packet.readFloat();
+        // In Vanilla: 0x00000000 = has mail, 0xC7A8C000 (big negative) = no mail
+        uint32_t rawValue;
+        std::memcpy(&rawValue, &nextMailTime, sizeof(uint32_t));
+        if (rawValue == 0 || nextMailTime >= 0.0f) {
+            hasNewMail_ = true;
+            LOG_INFO("MSG_QUERY_NEXT_MAIL_TIME: Player has pending mail");
+        } else {
+            LOG_INFO("MSG_QUERY_NEXT_MAIL_TIME: No pending mail (value=", nextMailTime, ")");
+        }
+    }
 }
 
 glm::vec3 GameHandler::getComposedWorldPosition() {
@@ -6598,23 +16693,75 @@ glm::vec3 GameHandler::getComposedWorldPosition() {
 // ============================================================
 
 void GameHandler::openBank(uint64_t guid) {
-    if (inventoryHandler_) inventoryHandler_->openBank(guid);
+    if (!isConnected()) return;
+    auto pkt = BankerActivatePacket::build(guid);
+    socket->send(pkt);
 }
 
 void GameHandler::closeBank() {
-    if (inventoryHandler_) inventoryHandler_->closeBank();
+    bankOpen_ = false;
+    bankerGuid_ = 0;
 }
 
 void GameHandler::buyBankSlot() {
-    if (inventoryHandler_) inventoryHandler_->buyBankSlot();
+    if (!isConnected() || !bankOpen_) {
+        LOG_WARNING("buyBankSlot: not connected or bank not open");
+        return;
+    }
+    LOG_WARNING("buyBankSlot: sending CMSG_BUY_BANK_SLOT banker=0x", std::hex, bankerGuid_, std::dec,
+             " purchased=", static_cast<int>(inventory.getPurchasedBankBagSlots()));
+    auto pkt = BuyBankSlotPacket::build(bankerGuid_);
+    socket->send(pkt);
 }
 
 void GameHandler::depositItem(uint8_t srcBag, uint8_t srcSlot) {
-    if (inventoryHandler_) inventoryHandler_->depositItem(srcBag, srcSlot);
+    if (!isConnected() || !bankOpen_) return;
+    auto pkt = AutoBankItemPacket::build(srcBag, srcSlot);
+    socket->send(pkt);
 }
 
 void GameHandler::withdrawItem(uint8_t srcBag, uint8_t srcSlot) {
-    if (inventoryHandler_) inventoryHandler_->withdrawItem(srcBag, srcSlot);
+    if (!isConnected() || !bankOpen_) return;
+    auto pkt = AutoStoreBankItemPacket::build(srcBag, srcSlot);
+    socket->send(pkt);
+}
+
+void GameHandler::handleShowBank(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 8) return;
+    bankerGuid_ = packet.readUInt64();
+    bankOpen_ = true;
+    gossipWindowOpen = false;  // Close gossip when bank opens
+    // Bank items are already tracked via update fields (bank slot GUIDs)
+    // Trigger rebuild to populate bank slots in inventory
+    rebuildOnlineInventory();
+    // Count bank bags that actually have items/containers
+    int filledBags = 0;
+    for (int i = 0; i < effectiveBankBagSlots_; i++) {
+        if (inventory.getBankBagSize(i) > 0) filledBags++;
+    }
+    LOG_WARNING("SMSG_SHOW_BANK: banker=0x", std::hex, bankerGuid_, std::dec,
+             " purchased=", static_cast<int>(inventory.getPurchasedBankBagSlots()),
+             " filledBags=", filledBags,
+             " effectiveBankBagSlots=", effectiveBankBagSlots_);
+}
+
+void GameHandler::handleBuyBankSlotResult(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 4) return;
+    uint32_t result = packet.readUInt32();
+    LOG_WARNING("SMSG_BUY_BANK_SLOT_RESULT: result=", result);
+    // AzerothCore/TrinityCore: 0=TOO_MANY, 1=INSUFFICIENT_FUNDS, 2=NOT_BANKER, 3=OK
+    if (result == 3) {
+        addSystemChatMessage("Bank slot purchased.");
+        inventory.setPurchasedBankBagSlots(inventory.getPurchasedBankBagSlots() + 1);
+    } else if (result == 1) {
+        addSystemChatMessage("Not enough gold to purchase bank slot.");
+    } else if (result == 0) {
+        addSystemChatMessage("No more bank slots available.");
+    } else if (result == 2) {
+        addSystemChatMessage("You must be at a banker to purchase bank slots.");
+    } else {
+        addSystemChatMessage("Cannot purchase bank slot (error " + std::to_string(result) + ").");
+    }
 }
 
 // ============================================================
@@ -6622,35 +16769,73 @@ void GameHandler::withdrawItem(uint8_t srcBag, uint8_t srcSlot) {
 // ============================================================
 
 void GameHandler::openGuildBank(uint64_t guid) {
-    if (inventoryHandler_) inventoryHandler_->openGuildBank(guid);
+    if (!isConnected()) return;
+    auto pkt = GuildBankerActivatePacket::build(guid);
+    socket->send(pkt);
 }
 
 void GameHandler::closeGuildBank() {
-    if (inventoryHandler_) inventoryHandler_->closeGuildBank();
+    guildBankOpen_ = false;
+    guildBankerGuid_ = 0;
 }
 
 void GameHandler::queryGuildBankTab(uint8_t tabId) {
-    if (inventoryHandler_) inventoryHandler_->queryGuildBankTab(tabId);
+    if (!isConnected() || !guildBankOpen_) return;
+    guildBankActiveTab_ = tabId;
+    auto pkt = GuildBankQueryTabPacket::build(guildBankerGuid_, tabId, true);
+    socket->send(pkt);
 }
 
 void GameHandler::buyGuildBankTab() {
-    if (inventoryHandler_) inventoryHandler_->buyGuildBankTab();
+    if (!isConnected() || !guildBankOpen_) return;
+    uint8_t nextTab = static_cast<uint8_t>(guildBankData_.tabs.size());
+    auto pkt = GuildBankBuyTabPacket::build(guildBankerGuid_, nextTab);
+    socket->send(pkt);
 }
 
 void GameHandler::depositGuildBankMoney(uint32_t amount) {
-    if (inventoryHandler_) inventoryHandler_->depositGuildBankMoney(amount);
+    if (!isConnected() || !guildBankOpen_) return;
+    auto pkt = GuildBankDepositMoneyPacket::build(guildBankerGuid_, amount);
+    socket->send(pkt);
 }
 
 void GameHandler::withdrawGuildBankMoney(uint32_t amount) {
-    if (inventoryHandler_) inventoryHandler_->withdrawGuildBankMoney(amount);
+    if (!isConnected() || !guildBankOpen_) return;
+    auto pkt = GuildBankWithdrawMoneyPacket::build(guildBankerGuid_, amount);
+    socket->send(pkt);
 }
 
 void GameHandler::guildBankWithdrawItem(uint8_t tabId, uint8_t bankSlot, uint8_t destBag, uint8_t destSlot) {
-    if (inventoryHandler_) inventoryHandler_->guildBankWithdrawItem(tabId, bankSlot, destBag, destSlot);
+    if (!isConnected() || !guildBankOpen_) return;
+    auto pkt = GuildBankSwapItemsPacket::buildBankToInventory(guildBankerGuid_, tabId, bankSlot, destBag, destSlot);
+    socket->send(pkt);
 }
 
 void GameHandler::guildBankDepositItem(uint8_t tabId, uint8_t bankSlot, uint8_t srcBag, uint8_t srcSlot) {
-    if (inventoryHandler_) inventoryHandler_->guildBankDepositItem(tabId, bankSlot, srcBag, srcSlot);
+    if (!isConnected() || !guildBankOpen_) return;
+    auto pkt = GuildBankSwapItemsPacket::buildInventoryToBank(guildBankerGuid_, tabId, bankSlot, srcBag, srcSlot);
+    socket->send(pkt);
+}
+
+void GameHandler::handleGuildBankList(network::Packet& packet) {
+    GuildBankData data;
+    if (!GuildBankListParser::parse(packet, data)) {
+        LOG_WARNING("Failed to parse SMSG_GUILD_BANK_LIST");
+        return;
+    }
+    guildBankData_ = data;
+    guildBankOpen_ = true;
+    guildBankActiveTab_ = data.tabId;
+
+    // Ensure item info for all guild bank items
+    for (const auto& item : data.tabItems) {
+        if (item.itemEntry != 0) ensureItemInfo(item.itemEntry);
+    }
+
+    LOG_INFO("SMSG_GUILD_BANK_LIST: tab=", (int)data.tabId,
+             " items=", data.tabItems.size(),
+             " tabs=", data.tabs.size(),
+             " money=", data.money);
 }
 
 // ============================================================
@@ -6658,42 +16843,179 @@ void GameHandler::guildBankDepositItem(uint8_t tabId, uint8_t bankSlot, uint8_t
 // ============================================================
 
 void GameHandler::openAuctionHouse(uint64_t guid) {
-    if (inventoryHandler_) inventoryHandler_->openAuctionHouse(guid);
+    if (!isConnected()) return;
+    auto pkt = AuctionHelloPacket::build(guid);
+    socket->send(pkt);
 }
 
 void GameHandler::closeAuctionHouse() {
-    if (inventoryHandler_) inventoryHandler_->closeAuctionHouse();
+    auctionOpen_ = false;
+    auctioneerGuid_ = 0;
 }
 
 void GameHandler::auctionSearch(const std::string& name, uint8_t levelMin, uint8_t levelMax,
                                  uint32_t quality, uint32_t itemClass, uint32_t itemSubClass,
-                                 uint32_t invTypeMask, uint8_t usableOnly, uint32_t offset) {
-    if (inventoryHandler_) inventoryHandler_->auctionSearch(name, levelMin, levelMax, quality, itemClass, itemSubClass, invTypeMask, usableOnly, offset);
+                                 uint32_t invTypeMask, uint8_t usableOnly, uint32_t offset)
+{
+    if (!isConnected() || !auctionOpen_) return;
+    if (auctionSearchDelayTimer_ > 0.0f) {
+        addSystemChatMessage("Please wait before searching again.");
+        return;
+    }
+    // Save search params for pagination and auto-refresh
+    lastAuctionSearch_ = {name, levelMin, levelMax, quality, itemClass, itemSubClass, invTypeMask, usableOnly, offset};
+    pendingAuctionTarget_ = AuctionResultTarget::BROWSE;
+    auto pkt = AuctionListItemsPacket::build(auctioneerGuid_, offset, name,
+                                              levelMin, levelMax, invTypeMask,
+                                              itemClass, itemSubClass, quality, usableOnly, 0);
+    socket->send(pkt);
 }
 
-void GameHandler::auctionSellItem(int backpackIndex, uint32_t bid,
-                                    uint32_t buyout, uint32_t duration) {
-    if (inventoryHandler_) inventoryHandler_->auctionSellItem(backpackIndex, bid, buyout, duration);
+void GameHandler::auctionSellItem(uint64_t itemGuid, uint32_t stackCount,
+                                    uint32_t bid, uint32_t buyout, uint32_t duration)
+{
+    if (!isConnected() || !auctionOpen_) return;
+    auto pkt = AuctionSellItemPacket::build(auctioneerGuid_, itemGuid, stackCount, bid, buyout, duration);
+    socket->send(pkt);
 }
 
 void GameHandler::auctionPlaceBid(uint32_t auctionId, uint32_t amount) {
-    if (inventoryHandler_) inventoryHandler_->auctionPlaceBid(auctionId, amount);
+    if (!isConnected() || !auctionOpen_) return;
+    auto pkt = AuctionPlaceBidPacket::build(auctioneerGuid_, auctionId, amount);
+    socket->send(pkt);
 }
 
 void GameHandler::auctionBuyout(uint32_t auctionId, uint32_t buyoutPrice) {
-    if (inventoryHandler_) inventoryHandler_->auctionBuyout(auctionId, buyoutPrice);
+    auctionPlaceBid(auctionId, buyoutPrice);
 }
 
 void GameHandler::auctionCancelItem(uint32_t auctionId) {
-    if (inventoryHandler_) inventoryHandler_->auctionCancelItem(auctionId);
+    if (!isConnected() || !auctionOpen_) return;
+    auto pkt = AuctionRemoveItemPacket::build(auctioneerGuid_, auctionId);
+    socket->send(pkt);
 }
 
 void GameHandler::auctionListOwnerItems(uint32_t offset) {
-    if (inventoryHandler_) inventoryHandler_->auctionListOwnerItems(offset);
+    if (!isConnected() || !auctionOpen_) return;
+    pendingAuctionTarget_ = AuctionResultTarget::OWNER;
+    auto pkt = AuctionListOwnerItemsPacket::build(auctioneerGuid_, offset);
+    socket->send(pkt);
 }
 
 void GameHandler::auctionListBidderItems(uint32_t offset) {
-    if (inventoryHandler_) inventoryHandler_->auctionListBidderItems(offset);
+    if (!isConnected() || !auctionOpen_) return;
+    pendingAuctionTarget_ = AuctionResultTarget::BIDDER;
+    auto pkt = AuctionListBidderItemsPacket::build(auctioneerGuid_, offset);
+    socket->send(pkt);
+}
+
+void GameHandler::handleAuctionHello(network::Packet& packet) {
+    size_t pktSize = packet.getSize();
+    size_t readPos = packet.getReadPos();
+    LOG_INFO("handleAuctionHello: packetSize=", pktSize, " readPos=", readPos);
+    // Hex dump first 20 bytes for debugging
+    const auto& rawData = packet.getData();
+    std::string hex;
+    size_t dumpLen = std::min<size_t>(rawData.size(), 20);
+    for (size_t i = 0; i < dumpLen; ++i) {
+        char b[4]; snprintf(b, sizeof(b), "%02x ", rawData[i]);
+        hex += b;
+    }
+    LOG_INFO("  hex dump: ", hex);
+    AuctionHelloData data;
+    if (!AuctionHelloParser::parse(packet, data)) {
+        LOG_WARNING("Failed to parse MSG_AUCTION_HELLO response, size=", pktSize, " readPos=", readPos);
+        return;
+    }
+    auctioneerGuid_ = data.auctioneerGuid;
+    auctionHouseId_ = data.auctionHouseId;
+    auctionOpen_ = true;
+    gossipWindowOpen = false;  // Close gossip when auction house opens
+    auctionActiveTab_ = 0;
+    auctionBrowseResults_ = AuctionListResult{};
+    auctionOwnerResults_ = AuctionListResult{};
+    auctionBidderResults_ = AuctionListResult{};
+    LOG_INFO("MSG_AUCTION_HELLO: auctioneer=0x", std::hex, data.auctioneerGuid, std::dec,
+             " house=", data.auctionHouseId, " enabled=", (int)data.enabled);
+}
+
+void GameHandler::handleAuctionListResult(network::Packet& packet) {
+    AuctionListResult result;
+    if (!AuctionListResultParser::parse(packet, result)) {
+        LOG_WARNING("Failed to parse SMSG_AUCTION_LIST_RESULT");
+        return;
+    }
+
+    auctionBrowseResults_ = result;
+    auctionSearchDelayTimer_ = result.searchDelay / 1000.0f;
+
+    // Ensure item info for all auction items
+    for (const auto& entry : result.auctions) {
+        if (entry.itemEntry != 0) ensureItemInfo(entry.itemEntry);
+    }
+
+    LOG_INFO("SMSG_AUCTION_LIST_RESULT: ", result.auctions.size(), " items, total=", result.totalCount);
+}
+
+void GameHandler::handleAuctionOwnerListResult(network::Packet& packet) {
+    AuctionListResult result;
+    if (!AuctionListResultParser::parse(packet, result)) {
+        LOG_WARNING("Failed to parse SMSG_AUCTION_OWNER_LIST_RESULT");
+        return;
+    }
+    auctionOwnerResults_ = result;
+    for (const auto& entry : result.auctions) {
+        if (entry.itemEntry != 0) ensureItemInfo(entry.itemEntry);
+    }
+    LOG_INFO("SMSG_AUCTION_OWNER_LIST_RESULT: ", result.auctions.size(), " items");
+}
+
+void GameHandler::handleAuctionBidderListResult(network::Packet& packet) {
+    AuctionListResult result;
+    if (!AuctionListResultParser::parse(packet, result)) {
+        LOG_WARNING("Failed to parse SMSG_AUCTION_BIDDER_LIST_RESULT");
+        return;
+    }
+    auctionBidderResults_ = result;
+    for (const auto& entry : result.auctions) {
+        if (entry.itemEntry != 0) ensureItemInfo(entry.itemEntry);
+    }
+    LOG_INFO("SMSG_AUCTION_BIDDER_LIST_RESULT: ", result.auctions.size(), " items");
+}
+
+void GameHandler::handleAuctionCommandResult(network::Packet& packet) {
+    AuctionCommandResult result;
+    if (!AuctionCommandResultParser::parse(packet, result)) {
+        LOG_WARNING("Failed to parse SMSG_AUCTION_COMMAND_RESULT");
+        return;
+    }
+
+    const char* actions[] = {"Create", "Cancel", "Bid", "Buyout"};
+    const char* actionName = (result.action < 4) ? actions[result.action] : "Unknown";
+
+    if (result.errorCode == 0) {
+        std::string msg = std::string("Auction ") + actionName + " successful.";
+        addSystemChatMessage(msg);
+        // Refresh appropriate lists
+        if (result.action == 0) auctionListOwnerItems();       // create
+        else if (result.action == 1) auctionListOwnerItems();  // cancel
+        else if (result.action == 2 || result.action == 3) {   // bid or buyout
+            auctionListBidderItems();
+            // Re-query browse results with the same filters the user last searched with
+            const auto& s = lastAuctionSearch_;
+            auctionSearch(s.name, s.levelMin, s.levelMax, s.quality,
+                          s.itemClass, s.itemSubClass, s.invTypeMask, s.usableOnly, s.offset);
+        }
+    } else {
+        const char* errors[] = {"OK", "Inventory", "Not enough money", "Item not found",
+                                "Higher bid", "Increment", "Not enough items",
+                                "DB error", "Restricted account"};
+        const char* errName = (result.errorCode < 9) ? errors[result.errorCode] : "Unknown";
+        std::string msg = std::string("Auction ") + actionName + " failed: " + errName;
+        addSystemChatMessage(msg);
+    }
+    LOG_INFO("SMSG_AUCTION_COMMAND_RESULT: action=", actionName,
+             " error=", result.errorCode);
 }
 
 // ---------------------------------------------------------------------------
@@ -6701,8 +17023,26 @@ void GameHandler::auctionListBidderItems(uint32_t offset) {
 //   uint64 itemGuid + uint8 isEmpty + string text (when !isEmpty)
 // ---------------------------------------------------------------------------
 
+void GameHandler::handleItemTextQueryResponse(network::Packet& packet) {
+    size_t rem = packet.getSize() - packet.getReadPos();
+    if (rem < 9) return;  // guid(8) + isEmpty(1)
+
+    /*uint64_t guid =*/ packet.readUInt64();
+    uint8_t isEmpty = packet.readUInt8();
+    if (!isEmpty) {
+        itemText_    = packet.readString();
+        itemTextOpen_= !itemText_.empty();
+    }
+    LOG_DEBUG("SMSG_ITEM_TEXT_QUERY_RESPONSE: isEmpty=", (int)isEmpty,
+              " len=", itemText_.size());
+}
+
 void GameHandler::queryItemText(uint64_t itemGuid) {
-    if (inventoryHandler_) inventoryHandler_->queryItemText(itemGuid);
+    if (state != WorldState::IN_WORLD || !socket) return;
+    network::Packet pkt(wireOpcode(Opcode::CMSG_ITEM_TEXT_QUERY));
+    pkt.writeUInt64(itemGuid);
+    socket->send(pkt);
+    LOG_DEBUG("CMSG_ITEM_TEXT_QUERY: guid=0x", std::hex, itemGuid, std::dec);
 }
 
 // ---------------------------------------------------------------------------
@@ -6710,12 +17050,47 @@ void GameHandler::queryItemText(uint64_t itemGuid) {
 //   uint32 questId + string questTitle + uint64 sharerGuid
 // ---------------------------------------------------------------------------
 
+void GameHandler::handleQuestConfirmAccept(network::Packet& packet) {
+    size_t rem = packet.getSize() - packet.getReadPos();
+    if (rem < 4) return;
+
+    sharedQuestId_    = packet.readUInt32();
+    sharedQuestTitle_ = packet.readString();
+    if (packet.getSize() - packet.getReadPos() >= 8) {
+        sharedQuestSharerGuid_ = packet.readUInt64();
+    }
+
+    sharedQuestSharerName_.clear();
+    auto entity = entityManager.getEntity(sharedQuestSharerGuid_);
+    if (auto* unit = dynamic_cast<Unit*>(entity.get())) {
+        sharedQuestSharerName_ = unit->getName();
+    }
+    if (sharedQuestSharerName_.empty()) {
+        char tmp[32];
+        std::snprintf(tmp, sizeof(tmp), "0x%llX",
+                      static_cast<unsigned long long>(sharedQuestSharerGuid_));
+        sharedQuestSharerName_ = tmp;
+    }
+
+    pendingSharedQuest_ = true;
+    addSystemChatMessage(sharedQuestSharerName_ + " has shared the quest \"" +
+                         sharedQuestTitle_ + "\" with you.");
+    LOG_INFO("SMSG_QUEST_CONFIRM_ACCEPT: questId=", sharedQuestId_,
+             " title=", sharedQuestTitle_, " sharer=", sharedQuestSharerName_);
+}
+
 void GameHandler::acceptSharedQuest() {
-    if (questHandler_) questHandler_->acceptSharedQuest();
+    if (!pendingSharedQuest_ || !socket) return;
+    pendingSharedQuest_ = false;
+    network::Packet pkt(wireOpcode(Opcode::CMSG_QUEST_CONFIRM_ACCEPT));
+    pkt.writeUInt32(sharedQuestId_);
+    socket->send(pkt);
+    addSystemChatMessage("Accepted: " + sharedQuestTitle_);
 }
 
 void GameHandler::declineSharedQuest() {
-    if (questHandler_) questHandler_->declineSharedQuest();
+    pendingSharedQuest_ = false;
+    // No response packet needed — just dismiss the UI
 }
 
 // ---------------------------------------------------------------------------
@@ -6724,15 +17099,48 @@ void GameHandler::declineSharedQuest() {
 // ---------------------------------------------------------------------------
 
 void GameHandler::handleSummonRequest(network::Packet& packet) {
-    if (socialHandler_) socialHandler_->handleSummonRequest(packet);
+    if (packet.getSize() - packet.getReadPos() < 16) return;
+
+    summonerGuid_        = packet.readUInt64();
+    /*uint32_t zoneId =*/ packet.readUInt32();
+    uint32_t timeoutMs   = packet.readUInt32();
+    summonTimeoutSec_    = timeoutMs / 1000.0f;
+    pendingSummonRequest_= true;
+
+    summonerName_.clear();
+    auto entity = entityManager.getEntity(summonerGuid_);
+    if (auto* unit = dynamic_cast<Unit*>(entity.get())) {
+        summonerName_ = unit->getName();
+    }
+    if (summonerName_.empty()) {
+        char tmp[32];
+        std::snprintf(tmp, sizeof(tmp), "0x%llX",
+                      static_cast<unsigned long long>(summonerGuid_));
+        summonerName_ = tmp;
+    }
+
+    addSystemChatMessage(summonerName_ + " is summoning you.");
+    LOG_INFO("SMSG_SUMMON_REQUEST: summoner=", summonerName_,
+             " timeout=", summonTimeoutSec_, "s");
 }
 
 void GameHandler::acceptSummon() {
-    if (socialHandler_) socialHandler_->acceptSummon();
+    if (!pendingSummonRequest_ || !socket) return;
+    pendingSummonRequest_ = false;
+    network::Packet pkt(wireOpcode(Opcode::CMSG_SUMMON_RESPONSE));
+    pkt.writeUInt8(1);  // 1 = accept
+    socket->send(pkt);
+    addSystemChatMessage("Accepting summon...");
+    LOG_INFO("Accepted summon from ", summonerName_);
 }
 
 void GameHandler::declineSummon() {
-    if (socialHandler_) socialHandler_->declineSummon();
+    if (!socket) return;
+    pendingSummonRequest_ = false;
+    network::Packet pkt(wireOpcode(Opcode::CMSG_SUMMON_RESPONSE));
+    pkt.writeUInt8(0);  // 0 = decline
+    socket->send(pkt);
+    addSystemChatMessage("Summon declined.");
 }
 
 // ---------------------------------------------------------------------------
@@ -6744,44 +17152,205 @@ void GameHandler::declineSummon() {
 //   14-19=stun/dead/logout, 20=trial, 21=conjured_only
 // ---------------------------------------------------------------------------
 
+void GameHandler::handleTradeStatus(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 4) return;
+    uint32_t status = packet.readUInt32();
+
+    switch (status) {
+        case 1: { // BEGIN_TRADE — incoming request; read initiator GUID
+            if (packet.getSize() - packet.getReadPos() >= 8) {
+                tradePeerGuid_ = packet.readUInt64();
+            }
+            // Resolve name from entity list
+            tradePeerName_.clear();
+            auto entity = entityManager.getEntity(tradePeerGuid_);
+            if (auto* unit = dynamic_cast<Unit*>(entity.get())) {
+                tradePeerName_ = unit->getName();
+            }
+            if (tradePeerName_.empty()) {
+                char tmp[32];
+                std::snprintf(tmp, sizeof(tmp), "0x%llX",
+                              static_cast<unsigned long long>(tradePeerGuid_));
+                tradePeerName_ = tmp;
+            }
+            tradeStatus_ = TradeStatus::PendingIncoming;
+            addSystemChatMessage(tradePeerName_ + " wants to trade with you.");
+            break;
+        }
+        case 2: // OPEN_WINDOW
+            tradeStatus_ = TradeStatus::Open;
+            addSystemChatMessage("Trade window opened.");
+            break;
+        case 3: // CANCELLED
+        case 9: // REJECTED
+        case 12: // CLOSE_WINDOW
+            tradeStatus_ = TradeStatus::None;
+            addSystemChatMessage("Trade cancelled.");
+            break;
+        case 4: // ACCEPTED (partner accepted)
+            tradeStatus_ = TradeStatus::Accepted;
+            addSystemChatMessage("Trade accepted. Awaiting other player...");
+            break;
+        case 8: // COMPLETE
+            tradeStatus_ = TradeStatus::Complete;
+            addSystemChatMessage("Trade complete!");
+            tradeStatus_ = TradeStatus::None;  // reset after notification
+            break;
+        case 7: // BACK_TO_TRADE (unaccepted after a change)
+            tradeStatus_ = TradeStatus::Open;
+            addSystemChatMessage("Trade offer changed.");
+            break;
+        case 10: addSystemChatMessage("Trade target is too far away."); break;
+        case 11: addSystemChatMessage("Trade failed: wrong faction."); break;
+        case 13: addSystemChatMessage("Trade failed: player ignores you."); break;
+        case 14: addSystemChatMessage("Trade failed: you are stunned."); break;
+        case 15: addSystemChatMessage("Trade failed: target is stunned."); break;
+        case 16: addSystemChatMessage("Trade failed: you are dead."); break;
+        case 17: addSystemChatMessage("Trade failed: target is dead."); break;
+        case 20: addSystemChatMessage("Trial accounts cannot trade."); break;
+        default: break;
+    }
+    LOG_DEBUG("SMSG_TRADE_STATUS: status=", status);
+}
+
 void GameHandler::acceptTradeRequest() {
-    if (inventoryHandler_) inventoryHandler_->acceptTradeRequest();
+    if (tradeStatus_ != TradeStatus::PendingIncoming || !socket) return;
+    tradeStatus_ = TradeStatus::Open;
+    socket->send(BeginTradePacket::build());
 }
 
 void GameHandler::declineTradeRequest() {
-    if (inventoryHandler_) inventoryHandler_->declineTradeRequest();
+    if (!socket) return;
+    tradeStatus_ = TradeStatus::None;
+    socket->send(CancelTradePacket::build());
 }
 
 void GameHandler::acceptTrade() {
-    if (inventoryHandler_) inventoryHandler_->acceptTrade();
+    if (tradeStatus_ != TradeStatus::Open || !socket) return;
+    tradeStatus_ = TradeStatus::Accepted;
+    socket->send(AcceptTradePacket::build());
 }
 
 void GameHandler::cancelTrade() {
-    if (inventoryHandler_) inventoryHandler_->cancelTrade();
-}
-
-void GameHandler::setTradeItem(uint8_t tradeSlot, uint8_t bag, uint8_t bagSlot) {
-    if (inventoryHandler_) inventoryHandler_->setTradeItem(tradeSlot, bag, bagSlot);
-}
-
-void GameHandler::clearTradeItem(uint8_t tradeSlot) {
-    if (inventoryHandler_) inventoryHandler_->clearTradeItem(tradeSlot);
-}
-
-void GameHandler::setTradeGold(uint64_t copper) {
-    if (inventoryHandler_) inventoryHandler_->setTradeGold(copper);
-}
-
-void GameHandler::resetTradeState() {
-    if (inventoryHandler_) inventoryHandler_->resetTradeState();
+    if (!socket) return;
+    tradeStatus_ = TradeStatus::None;
+    socket->send(CancelTradePacket::build());
 }
 
 // ---------------------------------------------------------------------------
 // Group loot roll (SMSG_LOOT_ROLL / SMSG_LOOT_ROLL_WON / CMSG_LOOT_ROLL)
 // ---------------------------------------------------------------------------
 
+void GameHandler::handleLootRoll(network::Packet& packet) {
+    // uint64 objectGuid, uint32 slot, uint64 playerGuid,
+    // uint32 itemId, uint32 randomSuffix, uint32 randomPropId,
+    // uint8 rollNumber, uint8 rollType
+    size_t rem = packet.getSize() - packet.getReadPos();
+    if (rem < 26) return;  // minimum: 8+4+8+4+4+4+1+1 = 34, be lenient
+
+    uint64_t objectGuid = packet.readUInt64();
+    uint32_t slot       = packet.readUInt32();
+    uint64_t rollerGuid = packet.readUInt64();
+    uint32_t itemId     = packet.readUInt32();
+    /*uint32_t randSuffix =*/ packet.readUInt32();
+    /*uint32_t randProp   =*/ packet.readUInt32();
+    uint8_t  rollNum    = packet.readUInt8();
+    uint8_t  rollType   = packet.readUInt8();
+
+    // rollType 128 = "waiting for this player to roll"
+    if (rollType == 128 && rollerGuid == playerGuid) {
+        // Server is asking us to roll; present the roll UI.
+        pendingLootRollActive_             = true;
+        pendingLootRoll_.objectGuid        = objectGuid;
+        pendingLootRoll_.slot              = slot;
+        pendingLootRoll_.itemId            = itemId;
+        // Look up item name from cache
+        auto* info = getItemInfo(itemId);
+        pendingLootRoll_.itemName  = info ? info->name : std::to_string(itemId);
+        pendingLootRoll_.itemQuality = info ? static_cast<uint8_t>(info->quality) : 0;
+        LOG_INFO("SMSG_LOOT_ROLL: need/greed prompt for item=", itemId,
+                 " (", pendingLootRoll_.itemName, ") slot=", slot);
+        return;
+    }
+
+    // Otherwise it's reporting another player's roll result
+    const char* rollNames[] = {"Need", "Greed", "Disenchant", "Pass"};
+    const char* rollName = (rollType < 4) ? rollNames[rollType] : "Pass";
+
+    std::string rollerName;
+    auto entity = entityManager.getEntity(rollerGuid);
+    if (auto* unit = dynamic_cast<Unit*>(entity.get())) {
+        rollerName = unit->getName();
+    }
+    if (rollerName.empty()) rollerName = "Someone";
+
+    auto* info = getItemInfo(itemId);
+    std::string iName = info ? info->name : std::to_string(itemId);
+
+    char buf[256];
+    std::snprintf(buf, sizeof(buf), "%s rolls %s (%d) on [%s]",
+                  rollerName.c_str(), rollName, static_cast<int>(rollNum), iName.c_str());
+    addSystemChatMessage(buf);
+
+    LOG_DEBUG("SMSG_LOOT_ROLL: ", rollerName, " rolled ", rollName,
+              " (", rollNum, ") on item ", itemId);
+    (void)objectGuid; (void)slot;
+}
+
+void GameHandler::handleLootRollWon(network::Packet& packet) {
+    size_t rem = packet.getSize() - packet.getReadPos();
+    if (rem < 26) return;
+
+    /*uint64_t objectGuid =*/ packet.readUInt64();
+    /*uint32_t slot       =*/ packet.readUInt32();
+    uint64_t winnerGuid = packet.readUInt64();
+    uint32_t itemId     = packet.readUInt32();
+    /*uint32_t randSuffix =*/ packet.readUInt32();
+    /*uint32_t randProp   =*/ packet.readUInt32();
+    uint8_t  rollNum    = packet.readUInt8();
+    uint8_t  rollType   = packet.readUInt8();
+
+    const char* rollNames[] = {"Need", "Greed", "Disenchant"};
+    const char* rollName = (rollType < 3) ? rollNames[rollType] : "Roll";
+
+    std::string winnerName;
+    auto entity = entityManager.getEntity(winnerGuid);
+    if (auto* unit = dynamic_cast<Unit*>(entity.get())) {
+        winnerName = unit->getName();
+    }
+    if (winnerName.empty()) {
+        winnerName = (winnerGuid == playerGuid) ? "You" : "Someone";
+    }
+
+    auto* info = getItemInfo(itemId);
+    std::string iName = info ? info->name : std::to_string(itemId);
+
+    char buf[256];
+    std::snprintf(buf, sizeof(buf), "%s wins [%s] (%s %d)!",
+                  winnerName.c_str(), iName.c_str(), rollName, static_cast<int>(rollNum));
+    addSystemChatMessage(buf);
+
+    // Clear pending roll if it was ours
+    if (pendingLootRollActive_ && winnerGuid == playerGuid) {
+        pendingLootRollActive_ = false;
+    }
+    LOG_INFO("SMSG_LOOT_ROLL_WON: winner=", winnerName, " item=", itemId,
+             " roll=", rollName, "(", rollNum, ")");
+}
+
 void GameHandler::sendLootRoll(uint64_t objectGuid, uint32_t slot, uint8_t rollType) {
-    if (inventoryHandler_) inventoryHandler_->sendLootRoll(objectGuid, slot, rollType);
+    if (state != WorldState::IN_WORLD || !socket) return;
+    pendingLootRollActive_ = false;
+
+    network::Packet pkt(wireOpcode(Opcode::CMSG_LOOT_ROLL));
+    pkt.writeUInt64(objectGuid);
+    pkt.writeUInt32(slot);
+    pkt.writeUInt8(rollType);
+    socket->send(pkt);
+
+    const char* rollNames[] = {"Need", "Greed", "Disenchant", "Pass"};
+    const char* rName = (rollType < 3) ? rollNames[rollType] : "Pass";
+    LOG_INFO("CMSG_LOOT_ROLL: type=", rName, " item=", pendingLootRoll_.itemName);
 }
 
 // ---------------------------------------------------------------------------
@@ -6791,63 +17360,11 @@ void GameHandler::sendLootRoll(uint64_t objectGuid, uint32_t slot, uint8_t rollT
 //   PackedTime date      — uint32 bitfield (seconds since epoch)
 //   uint32 realmFirst    — how many on realm also got it (0 = realm first)
 // ---------------------------------------------------------------------------
-void GameHandler::loadTitleNameCache() const {
-    if (titleNameCacheLoaded_) return;
-    titleNameCacheLoaded_ = true;
-
-    auto* am = services_.assetManager;
-    if (!am || !am->isInitialized()) return;
-
-    auto dbc = am->loadDBC("CharTitles.dbc");
-    if (!dbc || !dbc->isLoaded() || dbc->getFieldCount() < 5) return;
-
-    const auto* layout = pipeline::getActiveDBCLayout()
-        ? pipeline::getActiveDBCLayout()->getLayout("CharTitles") : nullptr;
-
-    uint32_t titleField = layout ? layout->field("Title")    : 2;
-    uint32_t bitField   = layout ? layout->field("TitleBit") : 36;
-    if (titleField == 0xFFFFFFFF) titleField = 2;
-    if (bitField   == 0xFFFFFFFF) bitField   = static_cast<uint32_t>(dbc->getFieldCount() - 1);
-
-    for (uint32_t i = 0; i < dbc->getRecordCount(); ++i) {
-        uint32_t bit = dbc->getUInt32(i, bitField);
-        if (bit == 0) continue;
-        std::string name = dbc->getString(i, titleField);
-        if (!name.empty()) titleNameCache_[bit] = std::move(name);
-    }
-    LOG_INFO("CharTitles: loaded ", titleNameCache_.size(), " title names from DBC");
-}
-
-std::string GameHandler::getFormattedTitle(uint32_t bit) const {
-    loadTitleNameCache();
-    auto it = titleNameCache_.find(bit);
-    if (it == titleNameCache_.end() || it->second.empty()) return {};
-
-    const auto& ln2 = lookupName(playerGuid);
-    static const std::string kUnknown = "unknown";
-    const std::string& pName = ln2.empty() ? kUnknown : ln2;
-
-    const std::string& fmt = it->second;
-    size_t pos = fmt.find("%s");
-    if (pos != std::string::npos) {
-        return fmt.substr(0, pos) + pName + fmt.substr(pos + 2);
-    }
-    return fmt;
-}
-
-void GameHandler::sendSetTitle(int32_t bit) {
-    if (!isInWorld()) return;
-    auto packet = SetTitlePacket::build(bit);
-    socket->send(packet);
-    chosenTitleBit_ = bit;
-    LOG_INFO("sendSetTitle: bit=", bit);
-}
-
 void GameHandler::loadAchievementNameCache() {
     if (achievementNameCacheLoaded_) return;
     achievementNameCacheLoaded_ = true;
 
-    auto* am = services_.assetManager;
+    auto* am = core::Application::getInstance().getAssetManager();
     if (!am || !am->isInitialized()) return;
 
     auto dbc = am->loadDBC("Achievement.dbc");
@@ -6857,82 +17374,81 @@ void GameHandler::loadAchievementNameCache() {
         ? pipeline::getActiveDBCLayout()->getLayout("Achievement") : nullptr;
     uint32_t titleField = achL ? achL->field("Title") : 4;
     if (titleField == 0xFFFFFFFF) titleField = 4;
-    uint32_t descField = achL ? achL->field("Description") : 0xFFFFFFFF;
-    uint32_t ptsField  = achL ? achL->field("Points")      : 0xFFFFFFFF;
 
-    uint32_t fieldCount = dbc->getFieldCount();
     for (uint32_t i = 0; i < dbc->getRecordCount(); ++i) {
         uint32_t id = dbc->getUInt32(i, 0);
         if (id == 0) continue;
         std::string title = dbc->getString(i, titleField);
         if (!title.empty()) achievementNameCache_[id] = std::move(title);
-        if (descField != 0xFFFFFFFF && descField < fieldCount) {
-            std::string desc = dbc->getString(i, descField);
-            if (!desc.empty()) achievementDescCache_[id] = std::move(desc);
-        }
-        if (ptsField != 0xFFFFFFFF && ptsField < fieldCount) {
-            uint32_t pts = dbc->getUInt32(i, ptsField);
-            if (pts > 0) achievementPointsCache_[id] = pts;
-        }
     }
     LOG_INFO("Achievement: loaded ", achievementNameCache_.size(), " names from Achievement.dbc");
 }
 
-// ---------------------------------------------------------------------------
-// SMSG_ALL_ACHIEVEMENT_DATA (WotLK 3.3.5a)
-//   Achievement records: repeated { uint32 id, uint32 packedDate } until 0xFFFFFFFF sentinel
-//   Criteria records:    repeated { uint32 id, uint64 counter, uint32 packedDate, ... } until 0xFFFFFFFF
-// ---------------------------------------------------------------------------
-void GameHandler::handleAllAchievementData(network::Packet& packet) {
+void GameHandler::handleAchievementEarned(network::Packet& packet) {
+    size_t remaining = packet.getSize() - packet.getReadPos();
+    if (remaining < 16) return;  // guid(8) + id(4) + date(4)
+
+    uint64_t guid          = packet.readUInt64();
+    uint32_t achievementId = packet.readUInt32();
+    /*uint32_t date =*/ packet.readUInt32();  // PackedTime — not displayed
+
     loadAchievementNameCache();
-    earnedAchievements_.clear();
-    achievementDates_.clear();
+    auto nameIt = achievementNameCache_.find(achievementId);
+    const std::string& achName = (nameIt != achievementNameCache_.end())
+        ? nameIt->second : std::string();
 
-    // Parse achievement entries (id + packedDate pairs, sentinel 0xFFFFFFFF)
-    while (packet.hasRemaining(4)) {
-        uint32_t id = packet.readUInt32();
-        if (id == 0xFFFFFFFF) break;
-        if (!packet.hasRemaining(4)) break;
-        uint32_t date = packet.readUInt32();
-        earnedAchievements_.insert(id);
-        achievementDates_[id] = date;
+    // Show chat notification
+    bool isSelf = (guid == playerGuid);
+    if (isSelf) {
+        char buf[256];
+        if (!achName.empty()) {
+            std::snprintf(buf, sizeof(buf), "Achievement earned: %s", achName.c_str());
+        } else {
+            std::snprintf(buf, sizeof(buf), "Achievement earned! (ID %u)", achievementId);
+        }
+        addSystemChatMessage(buf);
+
+        if (achievementEarnedCallback_) {
+            achievementEarnedCallback_(achievementId);
+        }
+    } else {
+        // Another player in the zone earned an achievement
+        std::string senderName;
+        auto entity = entityManager.getEntity(guid);
+        if (auto* unit = dynamic_cast<Unit*>(entity.get())) {
+            senderName = unit->getName();
+        }
+        if (senderName.empty()) {
+            char tmp[32];
+            std::snprintf(tmp, sizeof(tmp), "0x%llX",
+                          static_cast<unsigned long long>(guid));
+            senderName = tmp;
+        }
+        char buf[256];
+        if (!achName.empty()) {
+            std::snprintf(buf, sizeof(buf), "%s has earned the achievement: %s",
+                          senderName.c_str(), achName.c_str());
+        } else {
+            std::snprintf(buf, sizeof(buf), "%s has earned an achievement! (ID %u)",
+                          senderName.c_str(), achievementId);
+        }
+        addSystemChatMessage(buf);
     }
 
-    // Parse criteria block: id + uint64 counter + uint32 date + uint32 flags, sentinel 0xFFFFFFFF
-    criteriaProgress_.clear();
-    while (packet.hasRemaining(4)) {
-        uint32_t id = packet.readUInt32();
-        if (id == 0xFFFFFFFF) break;
-        // counter(8) + date(4) + unknown(4) = 16 bytes
-        if (!packet.hasRemaining(16)) break;
-        uint64_t counter = packet.readUInt64();
-        packet.readUInt32();  // date
-        packet.readUInt32();  // unknown / flags
-        criteriaProgress_[id] = counter;
-    }
-
-    LOG_INFO("SMSG_ALL_ACHIEVEMENT_DATA: loaded ", earnedAchievements_.size(),
-             " achievements, ", criteriaProgress_.size(), " criteria");
+    LOG_INFO("SMSG_ACHIEVEMENT_EARNED: guid=0x", std::hex, guid, std::dec,
+             " achievementId=", achievementId, " self=", isSelf,
+             achName.empty() ? "" : " name=", achName);
 }
 
-// ---------------------------------------------------------------------------
-// SMSG_RESPOND_INSPECT_ACHIEVEMENTS (WotLK 3.3.5a)
-//   Wire format: packed_guid (inspected player) + same achievement/criteria
-//   blocks as SMSG_ALL_ACHIEVEMENT_DATA:
-//     Achievement records: repeated { uint32 id, uint32 packedDate } until 0xFFFFFFFF sentinel
-//     Criteria records:    repeated { uint32 id, uint64 counter, uint32 date, uint32 unk }
-//                          until 0xFFFFFFFF sentinel
-//   We store only the earned achievement IDs (not criteria) per inspected player.
-// ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // Faction name cache (lazily loaded from Faction.dbc)
 // ---------------------------------------------------------------------------
 
-void GameHandler::loadFactionNameCache() const {
+void GameHandler::loadFactionNameCache() {
     if (factionNameCacheLoaded_) return;
     factionNameCacheLoaded_ = true;
 
-    auto* am = services_.assetManager;
+    auto* am = core::Application::getInstance().getAssetManager();
     if (!am || !am->isInitialized()) return;
 
     auto dbc = am->loadDBC("Faction.dbc");
@@ -6940,75 +17456,32 @@ void GameHandler::loadFactionNameCache() const {
 
     // Faction.dbc WotLK 3.3.5a field layout:
     //   0: ID
-    //   1: ReputationListID  (-1 / 0xFFFFFFFF = no reputation tracking)
-    //   2-5:  ReputationRaceMask[4]
-    //   6-9:  ReputationClassMask[4]
-    //  10-13: ReputationBase[4]
-    //  14-17: ReputationFlags[4]
-    //  18:    ParentFactionID
-    //  19-20: SpilloverRateIn, SpilloverRateOut (floats)
-    //  21-22: SpilloverMaxRankIn, SpilloverMaxRankOut
-    //  23:    Name (English locale, string ref)
-    constexpr uint32_t ID_FIELD      = 0;
-    constexpr uint32_t REPLIST_FIELD = 1;
-    constexpr uint32_t NAME_FIELD    = 23;  // enUS name string
+    //   1-4:  ReputationRaceMask[4]
+    //   5-8:  ReputationClassMask[4]
+    //   9-12: ReputationBase[4]
+    //  13-16: ReputationFlags[4]
+    //  17:    ParentFactionID
+    //  18-19: Spillover rates (floats)
+    //  20-21: MaxRank
+    //  22:    Name (English locale, string ref)
+    constexpr uint32_t ID_FIELD   = 0;
+    constexpr uint32_t NAME_FIELD = 22;  // enUS name string
 
-    // Classic/TBC have fewer fields; fall back gracefully
-    const bool hasRepListField = dbc->getFieldCount() > REPLIST_FIELD;
     if (dbc->getFieldCount() <= NAME_FIELD) {
         LOG_WARNING("Faction.dbc: unexpected field count ", dbc->getFieldCount());
-        // Don't abort — still try to load names from a shorter layout
+        return;
     }
-    const uint32_t nameField = (dbc->getFieldCount() > NAME_FIELD) ? NAME_FIELD : 22u;
 
     uint32_t count = dbc->getRecordCount();
     for (uint32_t i = 0; i < count; ++i) {
         uint32_t factionId = dbc->getUInt32(i, ID_FIELD);
         if (factionId == 0) continue;
-        if (dbc->getFieldCount() > nameField) {
-            std::string name = dbc->getString(i, nameField);
-            if (!name.empty()) {
-                factionNameCache_[factionId] = std::move(name);
-            }
-        }
-        // Build repListId ↔ factionId mapping (WotLK field 1)
-        if (hasRepListField) {
-            uint32_t repListId = dbc->getUInt32(i, REPLIST_FIELD);
-            if (repListId != 0xFFFFFFFFu) {
-                factionRepListToId_[repListId] = factionId;
-                factionIdToRepList_[factionId] = repListId;
-            }
+        std::string name = dbc->getString(i, NAME_FIELD);
+        if (!name.empty()) {
+            factionNameCache_[factionId] = std::move(name);
         }
     }
-    LOG_INFO("Faction.dbc: loaded ", factionNameCache_.size(), " faction names, ",
-             factionRepListToId_.size(), " with reputation tracking");
-}
-
-uint32_t GameHandler::getFactionIdByRepListId(uint32_t repListId) const {
-    loadFactionNameCache();
-    auto it = factionRepListToId_.find(repListId);
-    return (it != factionRepListToId_.end()) ? it->second : 0u;
-}
-
-uint32_t GameHandler::getRepListIdByFactionId(uint32_t factionId) const {
-    loadFactionNameCache();
-    auto it = factionIdToRepList_.find(factionId);
-    return (it != factionIdToRepList_.end()) ? it->second : 0xFFFFFFFFu;
-}
-
-void GameHandler::setWatchedFactionId(uint32_t factionId) {
-    watchedFactionId_ = factionId;
-    if (!isInWorld()) return;
-    // CMSG_SET_WATCHED_FACTION: int32 repListId (-1 = unwatch)
-    int32_t repListId = -1;
-    if (factionId != 0) {
-        uint32_t rl = getRepListIdByFactionId(factionId);
-        if (rl != 0xFFFFFFFFu) repListId = static_cast<int32_t>(rl);
-    }
-    network::Packet pkt(wireOpcode(Opcode::CMSG_SET_WATCHED_FACTION));
-    pkt.writeUInt32(static_cast<uint32_t>(repListId));
-    socket->send(pkt);
-    LOG_DEBUG("CMSG_SET_WATCHED_FACTION: repListId=", repListId, " (factionId=", factionId, ")");
+    LOG_INFO("Faction.dbc: loaded ", factionNameCache_.size(), " faction names");
 }
 
 std::string GameHandler::getFactionName(uint32_t factionId) const {
@@ -7018,591 +17491,77 @@ std::string GameHandler::getFactionName(uint32_t factionId) const {
 }
 
 const std::string& GameHandler::getFactionNamePublic(uint32_t factionId) const {
-    loadFactionNameCache();
+    const_cast<GameHandler*>(this)->loadFactionNameCache();
     auto it = factionNameCache_.find(factionId);
     if (it != factionNameCache_.end()) return it->second;
     static const std::string empty;
     return empty;
 }
 
-// ---------------------------------------------------------------------------
-// Area name cache (lazy-loaded from WorldMapArea.dbc)
-// ---------------------------------------------------------------------------
-
-void GameHandler::loadAreaNameCache() const {
-    if (areaNameCacheLoaded_) return;
-    areaNameCacheLoaded_ = true;
-
-    auto* am = services_.assetManager;
-    if (!am || !am->isInitialized()) return;
-
-    // AreaTable.dbc has the canonical zone/area names keyed by AreaID.
-    // Field 0 = ID, field 11 = AreaName (enUS locale).
-    auto areaDbc = am->loadDBC("AreaTable.dbc");
-    if (areaDbc && areaDbc->isLoaded() && areaDbc->getFieldCount() > 11) {
-        for (uint32_t i = 0; i < areaDbc->getRecordCount(); ++i) {
-            uint32_t areaId = areaDbc->getUInt32(i, 0);
-            if (areaId == 0) continue;
-            std::string name = areaDbc->getString(i, 11);
-            if (!name.empty()) {
-                areaNameCache_[areaId] = std::move(name);
-            }
-        }
-    }
-
-    // WorldMapArea.dbc supplements with map-UI area names (different ID space).
-    auto dbc = am->loadDBC("WorldMapArea.dbc");
-    if (dbc && dbc->isLoaded()) {
-        const auto* layout = pipeline::getActiveDBCLayout()
-            ? pipeline::getActiveDBCLayout()->getLayout("WorldMapArea") : nullptr;
-        const uint32_t areaIdField   = layout ? (*layout)["AreaID"]   : 2;
-        const uint32_t areaNameField = layout ? (*layout)["AreaName"] : 3;
-
-        if (dbc->getFieldCount() > areaNameField) {
-            for (uint32_t i = 0; i < dbc->getRecordCount(); ++i) {
-                uint32_t areaId = dbc->getUInt32(i, areaIdField);
-                if (areaId == 0) continue;
-                std::string name = dbc->getString(i, areaNameField);
-                // Don't overwrite AreaTable names — those are authoritative
-                if (!name.empty() && !areaNameCache_.count(areaId)) {
-                    areaNameCache_[areaId] = std::move(name);
-                }
-            }
-        }
-    }
-
-    LOG_INFO("Area name cache: loaded ", areaNameCache_.size(), " entries");
-}
-
-std::string GameHandler::getAreaName(uint32_t areaId) const {
-    if (areaId == 0) return {};
-    loadAreaNameCache();
-    auto it = areaNameCache_.find(areaId);
-    return (it != areaNameCache_.end()) ? it->second : std::string{};
-}
-
-void GameHandler::loadMapNameCache() const {
-    if (mapNameCacheLoaded_) return;
-    mapNameCacheLoaded_ = true;
-
-    auto* am = services_.assetManager;
-    if (!am || !am->isInitialized()) return;
-
-    auto dbc = am->loadDBC("Map.dbc");
-    if (!dbc || !dbc->isLoaded()) return;
-
-    // Map.dbc layout: 0=ID, 1=InternalName, 2=InstanceType, 3=Flags,
-    // 4=MapName_enUS (display name), fields 5+ = other locales
-    for (uint32_t i = 0; i < dbc->getRecordCount(); ++i) {
-        uint32_t id = dbc->getUInt32(i, 0);
-        std::string name = dbc->getString(i, 4);
-        if (name.empty()) name = dbc->getString(i, 1); // internal name fallback
-        if (!name.empty() && !mapNameCache_.count(id)) {
-            mapNameCache_[id] = std::move(name);
-        }
-    }
-    LOG_INFO("Map.dbc: loaded ", mapNameCache_.size(), " map names");
-}
-
-std::string GameHandler::getMapName(uint32_t mapId) const {
-    loadMapNameCache();
-    auto it = mapNameCache_.find(mapId);
-    return (it != mapNameCache_.end()) ? it->second : std::string{};
-}
-
-// ---------------------------------------------------------------------------
-// LFG dungeon name cache (WotLK: LFGDungeons.dbc)
-// ---------------------------------------------------------------------------
-
-void GameHandler::loadLfgDungeonDbc() const {
-    if (lfgDungeonNameCacheLoaded_) return;
-    lfgDungeonNameCacheLoaded_ = true;
-
-    auto* am = services_.assetManager;
-    if (!am || !am->isInitialized()) return;
-
-    auto dbc = am->loadDBC("LFGDungeons.dbc");
-    if (!dbc || !dbc->isLoaded()) return;
-
-    const auto* layout = pipeline::getActiveDBCLayout()
-        ? pipeline::getActiveDBCLayout()->getLayout("LFGDungeons") : nullptr;
-    const uint32_t idField   = layout ? (*layout)["ID"]   : 0;
-    const uint32_t nameField = layout ? (*layout)["Name"] : 1;
-
-    for (uint32_t i = 0; i < dbc->getRecordCount(); ++i) {
-        uint32_t id = dbc->getUInt32(i, idField);
-        if (id == 0) continue;
-        std::string name = dbc->getString(i, nameField);
-        if (!name.empty())
-            lfgDungeonNameCache_[id] = std::move(name);
-    }
-    LOG_INFO("LFGDungeons.dbc: loaded ", lfgDungeonNameCache_.size(), " dungeon names");
-}
-
-std::string GameHandler::getLfgDungeonName(uint32_t dungeonId) const {
-    if (dungeonId == 0) return {};
-    loadLfgDungeonDbc();
-    auto it = lfgDungeonNameCache_.find(dungeonId);
-    return (it != lfgDungeonNameCache_.end()) ? it->second : std::string{};
-}
-
 // ---------------------------------------------------------------------------
 // Aura duration update
 // ---------------------------------------------------------------------------
 
 void GameHandler::handleUpdateAuraDuration(uint8_t slot, uint32_t durationMs) {
-    if (spellHandler_) spellHandler_->handleUpdateAuraDuration(slot, durationMs);
+    if (slot >= playerAuras.size()) return;
+    if (playerAuras[slot].isEmpty()) return;
+    playerAuras[slot].durationMs = static_cast<int32_t>(durationMs);
+    playerAuras[slot].receivedAtMs = static_cast<uint64_t>(
+        std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::steady_clock::now().time_since_epoch()).count());
 }
 
 // ---------------------------------------------------------------------------
 // Equipment set list
 // ---------------------------------------------------------------------------
 
-// ---- Battlefield Manager (WotLK Wintergrasp / outdoor battlefields) ----
-
-void GameHandler::acceptBfMgrInvite() {
-    if (socialHandler_) socialHandler_->acceptBfMgrInvite();
+void GameHandler::handleEquipmentSetList(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 4) return;
+    uint32_t count = packet.readUInt32();
+    if (count > 10) {
+        LOG_WARNING("SMSG_EQUIPMENT_SET_LIST: unexpected count ", count, ", ignoring");
+        packet.setReadPos(packet.getSize());
+        return;
+    }
+    equipmentSets_.clear();
+    equipmentSets_.reserve(count);
+    for (uint32_t i = 0; i < count; ++i) {
+        if (packet.getSize() - packet.getReadPos() < 16) break;
+        EquipmentSet es;
+        es.setGuid        = packet.readUInt64();
+        es.setId          = packet.readUInt32();
+        es.name           = packet.readString();
+        es.iconName       = packet.readString();
+        es.ignoreSlotMask = packet.readUInt32();
+        for (int slot = 0; slot < 19; ++slot) {
+            if (packet.getSize() - packet.getReadPos() < 8) break;
+            es.itemGuids[slot] = packet.readUInt64();
+        }
+        equipmentSets_.push_back(std::move(es));
+    }
+    LOG_INFO("SMSG_EQUIPMENT_SET_LIST: ", equipmentSets_.size(), " equipment sets received");
 }
 
-void GameHandler::declineBfMgrInvite() {
-    if (socialHandler_) socialHandler_->declineBfMgrInvite();
-}
+// ---------------------------------------------------------------------------
+// Forced faction reactions
+// ---------------------------------------------------------------------------
 
-// ---- WotLK Calendar ----
-
-void GameHandler::requestCalendar() {
-    if (socialHandler_) socialHandler_->requestCalendar();
-}
-
-// ============================================================
-// Delegating getters — SocialHandler owns the canonical state
-// ============================================================
-
-uint32_t GameHandler::getTotalTimePlayed() const {
-    return socialHandler_ ? socialHandler_->getTotalTimePlayed() : 0;
-}
-
-uint32_t GameHandler::getLevelTimePlayed() const {
-    return socialHandler_ ? socialHandler_->getLevelTimePlayed() : 0;
-}
-
-const std::vector<GameHandler::WhoEntry>& GameHandler::getWhoResults() const {
-    if (socialHandler_) return socialHandler_->getWhoResults();
-    static const std::vector<WhoEntry> empty;
-    return empty;
-}
-
-uint32_t GameHandler::getWhoOnlineCount() const {
-    return socialHandler_ ? socialHandler_->getWhoOnlineCount() : 0;
-}
-
-const std::array<GameHandler::BgQueueSlot, 3>& GameHandler::getBgQueues() const {
-    if (socialHandler_) return socialHandler_->getBgQueues();
-    static const std::array<BgQueueSlot, 3> empty{};
-    return empty;
-}
-
-const std::vector<GameHandler::AvailableBgInfo>& GameHandler::getAvailableBgs() const {
-    if (socialHandler_) return socialHandler_->getAvailableBgs();
-    static const std::vector<AvailableBgInfo> empty;
-    return empty;
-}
-
-const GameHandler::BgScoreboardData* GameHandler::getBgScoreboard() const {
-    return socialHandler_ ? socialHandler_->getBgScoreboard() : nullptr;
-}
-
-const std::vector<GameHandler::BgPlayerPosition>& GameHandler::getBgPlayerPositions() const {
-    if (socialHandler_) return socialHandler_->getBgPlayerPositions();
-    static const std::vector<BgPlayerPosition> empty;
-    return empty;
-}
-
-bool GameHandler::isLoggingOut() const {
-    return socialHandler_ ? socialHandler_->isLoggingOut() : false;
-}
-
-float GameHandler::getLogoutCountdown() const {
-    return socialHandler_ ? socialHandler_->getLogoutCountdown() : 0.0f;
-}
-
-bool GameHandler::isInGuild() const {
-    if (socialHandler_) return socialHandler_->isInGuild();
-    const Character* ch = getActiveCharacter();
-    return ch && ch->hasGuild();
-}
-
-bool GameHandler::hasPendingGroupInvite() const {
-    return socialHandler_ ? socialHandler_->hasPendingGroupInvite() : pendingGroupInvite;
-}
-const std::string& GameHandler::getPendingInviterName() const {
-    if (socialHandler_) return socialHandler_->getPendingInviterName();
-    return pendingInviterName;
-}
-
-const std::string& GameHandler::getGuildName() const {
-    if (socialHandler_) return socialHandler_->getGuildName();
-    static const std::string empty;
-    return empty;
-}
-
-const GuildRosterData& GameHandler::getGuildRoster() const {
-    if (socialHandler_) return socialHandler_->getGuildRoster();
-    static const GuildRosterData empty;
-    return empty;
-}
-
-bool GameHandler::hasGuildRoster() const {
-    return socialHandler_ ? socialHandler_->hasGuildRoster() : false;
-}
-
-const std::vector<std::string>& GameHandler::getGuildRankNames() const {
-    if (socialHandler_) return socialHandler_->getGuildRankNames();
-    static const std::vector<std::string> empty;
-    return empty;
-}
-
-bool GameHandler::hasPendingGuildInvite() const {
-    return socialHandler_ ? socialHandler_->hasPendingGuildInvite() : false;
-}
-
-const std::string& GameHandler::getPendingGuildInviterName() const {
-    if (socialHandler_) return socialHandler_->getPendingGuildInviterName();
-    static const std::string empty;
-    return empty;
-}
-
-const std::string& GameHandler::getPendingGuildInviteGuildName() const {
-    if (socialHandler_) return socialHandler_->getPendingGuildInviteGuildName();
-    static const std::string empty;
-    return empty;
-}
-
-const GuildInfoData& GameHandler::getGuildInfoData() const {
-    if (socialHandler_) return socialHandler_->getGuildInfoData();
-    static const GuildInfoData empty;
-    return empty;
-}
-
-const GuildQueryResponseData& GameHandler::getGuildQueryData() const {
-    if (socialHandler_) return socialHandler_->getGuildQueryData();
-    static const GuildQueryResponseData empty;
-    return empty;
-}
-
-bool GameHandler::hasGuildInfoData() const {
-    return socialHandler_ ? socialHandler_->hasGuildInfoData() : false;
-}
-
-bool GameHandler::hasPetitionShowlist() const {
-    return socialHandler_ ? socialHandler_->hasPetitionShowlist() : false;
-}
-
-uint32_t GameHandler::getPetitionCost() const {
-    return socialHandler_ ? socialHandler_->getPetitionCost() : 0;
-}
-
-uint64_t GameHandler::getPetitionNpcGuid() const {
-    return socialHandler_ ? socialHandler_->getPetitionNpcGuid() : 0;
-}
-
-const GameHandler::PetitionInfo& GameHandler::getPetitionInfo() const {
-    if (socialHandler_) return socialHandler_->getPetitionInfo();
-    static const PetitionInfo empty;
-    return empty;
-}
-
-bool GameHandler::hasPetitionSignaturesUI() const {
-    return socialHandler_ ? socialHandler_->hasPetitionSignaturesUI() : false;
-}
-
-bool GameHandler::hasPendingReadyCheck() const {
-    return socialHandler_ ? socialHandler_->hasPendingReadyCheck() : false;
-}
-
-const std::string& GameHandler::getReadyCheckInitiator() const {
-    if (socialHandler_) return socialHandler_->getReadyCheckInitiator();
-    static const std::string empty;
-    return empty;
-}
-
-const std::vector<GameHandler::ReadyCheckResult>& GameHandler::getReadyCheckResults() const {
-    if (socialHandler_) return socialHandler_->getReadyCheckResults();
-    static const std::vector<ReadyCheckResult> empty;
-    return empty;
-}
-
-uint32_t GameHandler::getInstanceDifficulty() const {
-    return socialHandler_ ? socialHandler_->getInstanceDifficulty() : 0;
-}
-
-bool GameHandler::isInstanceHeroic() const {
-    return socialHandler_ ? socialHandler_->isInstanceHeroic() : false;
-}
-
-bool GameHandler::isInInstance() const {
-    return socialHandler_ ? socialHandler_->isInInstance() : false;
-}
-
-bool GameHandler::hasPendingDuelRequest() const {
-    return socialHandler_ ? socialHandler_->hasPendingDuelRequest() : false;
-}
-
-const std::string& GameHandler::getDuelChallengerName() const {
-    if (socialHandler_) return socialHandler_->getDuelChallengerName();
-    static const std::string empty;
-    return empty;
-}
-
-float GameHandler::getDuelCountdownRemaining() const {
-    return socialHandler_ ? socialHandler_->getDuelCountdownRemaining() : 0.0f;
-}
-
-const std::vector<GameHandler::InstanceLockout>& GameHandler::getInstanceLockouts() const {
-    if (socialHandler_) return socialHandler_->getInstanceLockouts();
-    static const std::vector<InstanceLockout> empty;
-    return empty;
-}
-
-GameHandler::LfgState GameHandler::getLfgState() const {
-    return socialHandler_ ? socialHandler_->getLfgState() : LfgState::None;
-}
-
-bool GameHandler::isLfgQueued() const {
-    return socialHandler_ ? socialHandler_->isLfgQueued() : false;
-}
-
-bool GameHandler::isLfgInDungeon() const {
-    return socialHandler_ ? socialHandler_->isLfgInDungeon() : false;
-}
-
-uint32_t GameHandler::getLfgDungeonId() const {
-    return socialHandler_ ? socialHandler_->getLfgDungeonId() : 0;
-}
-
-std::string GameHandler::getCurrentLfgDungeonName() const {
-    return socialHandler_ ? socialHandler_->getCurrentLfgDungeonName() : std::string{};
-}
-
-uint32_t GameHandler::getLfgProposalId() const {
-    return socialHandler_ ? socialHandler_->getLfgProposalId() : 0;
-}
-
-int32_t GameHandler::getLfgAvgWaitSec() const {
-    return socialHandler_ ? socialHandler_->getLfgAvgWaitSec() : -1;
-}
-
-uint32_t GameHandler::getLfgTimeInQueueMs() const {
-    return socialHandler_ ? socialHandler_->getLfgTimeInQueueMs() : 0;
-}
-
-uint32_t GameHandler::getLfgBootVotes() const {
-    return socialHandler_ ? socialHandler_->getLfgBootVotes() : 0;
-}
-
-uint32_t GameHandler::getLfgBootTotal() const {
-    return socialHandler_ ? socialHandler_->getLfgBootTotal() : 0;
-}
-
-uint32_t GameHandler::getLfgBootTimeLeft() const {
-    return socialHandler_ ? socialHandler_->getLfgBootTimeLeft() : 0;
-}
-
-uint32_t GameHandler::getLfgBootNeeded() const {
-    return socialHandler_ ? socialHandler_->getLfgBootNeeded() : 0;
-}
-
-const std::string& GameHandler::getLfgBootTargetName() const {
-    if (socialHandler_) return socialHandler_->getLfgBootTargetName();
-    static const std::string empty;
-    return empty;
-}
-
-const std::string& GameHandler::getLfgBootReason() const {
-    if (socialHandler_) return socialHandler_->getLfgBootReason();
-    static const std::string empty;
-    return empty;
-}
-
-const std::vector<GameHandler::ArenaTeamStats>& GameHandler::getArenaTeamStats() const {
-    if (socialHandler_) return socialHandler_->getArenaTeamStats();
-    static const std::vector<ArenaTeamStats> empty;
-    return empty;
-}
-
-// ---- SpellHandler delegating getters ----
-
-int GameHandler::getCraftQueueRemaining() const {
-    return spellHandler_ ? spellHandler_->getCraftQueueRemaining() : 0;
-}
-uint32_t GameHandler::getCraftQueueSpellId() const {
-    return spellHandler_ ? spellHandler_->getCraftQueueSpellId() : 0;
-}
-uint32_t GameHandler::getQueuedSpellId() const {
-    return spellHandler_ ? spellHandler_->getQueuedSpellId() : 0;
-}
-const std::unordered_map<uint32_t, TalentEntry>& GameHandler::getAllTalents() const {
-    if (spellHandler_) return spellHandler_->getAllTalents();
-    static const std::unordered_map<uint32_t, TalentEntry> empty;
-    return empty;
-}
-const std::unordered_map<uint32_t, TalentTabEntry>& GameHandler::getAllTalentTabs() const {
-    if (spellHandler_) return spellHandler_->getAllTalentTabs();
-    static const std::unordered_map<uint32_t, TalentTabEntry> empty;
-    return empty;
-}
-float GameHandler::getGCDTotal() const {
-    return spellHandler_ ? spellHandler_->getGCDTotal() : 0.0f;
-}
-bool GameHandler::showTalentWipeConfirmDialog() const {
-    return spellHandler_ ? spellHandler_->showTalentWipeConfirmDialog() : false;
-}
-uint32_t GameHandler::getTalentWipeCost() const {
-    return spellHandler_ ? spellHandler_->getTalentWipeCost() : 0;
-}
-void GameHandler::cancelTalentWipe() {
-    if (spellHandler_) spellHandler_->cancelTalentWipe();
-}
-bool GameHandler::showPetUnlearnDialog() const {
-    return spellHandler_ ? spellHandler_->showPetUnlearnDialog() : false;
-}
-uint32_t GameHandler::getPetUnlearnCost() const {
-    return spellHandler_ ? spellHandler_->getPetUnlearnCost() : 0;
-}
-void GameHandler::cancelPetUnlearn() {
-    if (spellHandler_) spellHandler_->cancelPetUnlearn();
-}
-
-// ---- QuestHandler delegating getters ----
-
-bool GameHandler::isGossipWindowOpen() const {
-    return questHandler_ ? questHandler_->isGossipWindowOpen() : gossipWindowOpen;
-}
-const GossipMessageData& GameHandler::getCurrentGossip() const {
-    if (questHandler_) return questHandler_->getCurrentGossip();
-    return currentGossip;
-}
-bool GameHandler::isQuestDetailsOpen() {
-    if (questHandler_) return questHandler_->isQuestDetailsOpen();
-    return questDetailsOpen;
-}
-const QuestDetailsData& GameHandler::getQuestDetails() const {
-    if (questHandler_) return questHandler_->getQuestDetails();
-    return currentQuestDetails;
-}
-
-const std::vector<GossipPoi>& GameHandler::getGossipPois() const {
-    if (questHandler_) return questHandler_->getGossipPois();
-    static const std::vector<GossipPoi> empty;
-    return empty;
-}
-const std::unordered_map<uint64_t, QuestGiverStatus>& GameHandler::getNpcQuestStatuses() const {
-    if (questHandler_) return questHandler_->getNpcQuestStatuses();
-    static const std::unordered_map<uint64_t, QuestGiverStatus> empty;
-    return empty;
-}
-const std::vector<GameHandler::QuestLogEntry>& GameHandler::getQuestLog() const {
-    if (questHandler_) return questHandler_->getQuestLog();
-    static const std::vector<QuestLogEntry> empty;
-    return empty;
-}
-bool GameHandler::isQuestOfferRewardOpen() const {
-    return questHandler_ ? questHandler_->isQuestOfferRewardOpen() : false;
-}
-const QuestOfferRewardData& GameHandler::getQuestOfferReward() const {
-    if (questHandler_) return questHandler_->getQuestOfferReward();
-    static const QuestOfferRewardData empty;
-    return empty;
-}
-bool GameHandler::isQuestRequestItemsOpen() const {
-    return questHandler_ ? questHandler_->isQuestRequestItemsOpen() : false;
-}
-const QuestRequestItemsData& GameHandler::getQuestRequestItems() const {
-    if (questHandler_) return questHandler_->getQuestRequestItems();
-    static const QuestRequestItemsData empty;
-    return empty;
-}
-int GameHandler::getSelectedQuestLogIndex() const {
-    return questHandler_ ? questHandler_->getSelectedQuestLogIndex() : 0;
-}
-uint32_t GameHandler::getSharedQuestId() const {
-    return questHandler_ ? questHandler_->getSharedQuestId() : 0;
-}
-const std::string& GameHandler::getSharedQuestSharerName() const {
-    if (questHandler_) return questHandler_->getSharedQuestSharerName();
-    static const std::string empty;
-    return empty;
-}
-const std::string& GameHandler::getSharedQuestTitle() const {
-    if (questHandler_) return questHandler_->getSharedQuestTitle();
-    static const std::string empty;
-    return empty;
-}
-const std::unordered_set<uint32_t>& GameHandler::getTrackedQuestIds() const {
-    if (questHandler_) return questHandler_->getTrackedQuestIds();
-    static const std::unordered_set<uint32_t> empty;
-    return empty;
-}
-bool GameHandler::hasPendingSharedQuest() const {
-    return questHandler_ ? questHandler_->hasPendingSharedQuest() : false;
-}
-
-// ---- MovementHandler delegating getters ----
-
-float GameHandler::getServerRunSpeed() const {
-    return movementHandler_ ? movementHandler_->getServerRunSpeed() : 7.0f;
-}
-float GameHandler::getServerWalkSpeed() const {
-    return movementHandler_ ? movementHandler_->getServerWalkSpeed() : 2.5f;
-}
-float GameHandler::getServerSwimSpeed() const {
-    return movementHandler_ ? movementHandler_->getServerSwimSpeed() : 4.722f;
-}
-float GameHandler::getServerSwimBackSpeed() const {
-    return movementHandler_ ? movementHandler_->getServerSwimBackSpeed() : 2.5f;
-}
-float GameHandler::getServerFlightSpeed() const {
-    return movementHandler_ ? movementHandler_->getServerFlightSpeed() : 7.0f;
-}
-float GameHandler::getServerFlightBackSpeed() const {
-    return movementHandler_ ? movementHandler_->getServerFlightBackSpeed() : 4.5f;
-}
-float GameHandler::getServerRunBackSpeed() const {
-    return movementHandler_ ? movementHandler_->getServerRunBackSpeed() : 4.5f;
-}
-float GameHandler::getServerTurnRate() const {
-    return movementHandler_ ? movementHandler_->getServerTurnRate() : 3.14159f;
-}
-bool GameHandler::isTaxiWindowOpen() const {
-    return movementHandler_ ? movementHandler_->isTaxiWindowOpen() : false;
-}
-bool GameHandler::isOnTaxiFlight() const {
-    return movementHandler_ ? movementHandler_->isOnTaxiFlight() : false;
-}
-bool GameHandler::isTaxiMountActive() const {
-    return movementHandler_ ? movementHandler_->isTaxiMountActive() : false;
-}
-bool GameHandler::isTaxiActivationPending() const {
-    return movementHandler_ ? movementHandler_->isTaxiActivationPending() : false;
-}
-const std::string& GameHandler::getTaxiDestName() const {
-    if (movementHandler_) return movementHandler_->getTaxiDestName();
-    static const std::string empty;
-    return empty;
-}
-const ShowTaxiNodesData& GameHandler::getTaxiData() const {
-    if (movementHandler_) return movementHandler_->getTaxiData();
-    static const ShowTaxiNodesData empty;
-    return empty;
-}
-uint32_t GameHandler::getTaxiCurrentNode() const {
-    if (movementHandler_) return movementHandler_->getTaxiData().nearestNode;
-    return 0;
-}
-const std::unordered_map<uint32_t, GameHandler::TaxiNode>& GameHandler::getTaxiNodes() const {
-    if (movementHandler_) return movementHandler_->getTaxiNodes();
-    static const std::unordered_map<uint32_t, TaxiNode> empty;
-    return empty;
+void GameHandler::handleSetForcedReactions(network::Packet& packet) {
+    if (packet.getSize() - packet.getReadPos() < 4) return;
+    uint32_t count = packet.readUInt32();
+    if (count > 64) {
+        LOG_WARNING("SMSG_SET_FORCED_REACTIONS: suspicious count ", count, ", ignoring");
+        packet.setReadPos(packet.getSize());
+        return;
+    }
+    forcedReactions_.clear();
+    for (uint32_t i = 0; i < count; ++i) {
+        if (packet.getSize() - packet.getReadPos() < 8) break;
+        uint32_t factionId = packet.readUInt32();
+        uint32_t reaction  = packet.readUInt32();
+        forcedReactions_[factionId] = static_cast<uint8_t>(reaction);
+    }
+    LOG_INFO("SMSG_SET_FORCED_REACTIONS: ", forcedReactions_.size(), " faction overrides");
 }
 
 } // namespace game
diff --git a/src/game/inventory.cpp b/src/game/inventory.cpp
index b0fe6c48..1750253a 100644
--- a/src/game/inventory.cpp
+++ b/src/game/inventory.cpp
@@ -1,6 +1,5 @@
 #include "game/inventory.hpp"
 #include "core/logger.hpp"
-#include <algorithm>
 
 namespace wowee {
 namespace game {
@@ -46,23 +45,6 @@ bool Inventory::clearEquipSlot(EquipSlot slot) {
     return true;
 }
 
-const ItemSlot& Inventory::getKeyringSlot(int index) const {
-    if (index < 0 || index >= KEYRING_SLOTS) return EMPTY_SLOT;
-    return keyring_[index];
-}
-
-bool Inventory::setKeyringSlot(int index, const ItemDef& item) {
-    if (index < 0 || index >= KEYRING_SLOTS) return false;
-    keyring_[index].item = item;
-    return true;
-}
-
-bool Inventory::clearKeyringSlot(int index) {
-    if (index < 0 || index >= KEYRING_SLOTS) return false;
-    keyring_[index].item = ItemDef{};
-    return true;
-}
-
 int Inventory::getBagSize(int bagIndex) const {
     if (bagIndex < 0 || bagIndex >= NUM_BAG_SLOTS) return 0;
     return bags[bagIndex].size;
@@ -186,130 +168,6 @@ bool Inventory::addItem(const ItemDef& item) {
     return true;
 }
 
-void Inventory::sortBags() {
-    // Collect all items from backpack and equip bags into a flat list.
-    std::vector<ItemDef> items;
-    items.reserve(BACKPACK_SLOTS + NUM_BAG_SLOTS * MAX_BAG_SIZE);
-
-    for (int i = 0; i < BACKPACK_SLOTS; ++i) {
-        if (!backpack[i].empty())
-            items.push_back(backpack[i].item);
-    }
-    for (int b = 0; b < NUM_BAG_SLOTS; ++b) {
-        for (int s = 0; s < bags[b].size; ++s) {
-            if (!bags[b].slots[s].empty())
-                items.push_back(bags[b].slots[s].item);
-        }
-    }
-
-    // Sort: quality descending → itemId ascending → stackCount descending.
-    std::stable_sort(items.begin(), items.end(), [](const ItemDef& a, const ItemDef& b) {
-        if (a.quality != b.quality)
-            return static_cast<int>(a.quality) > static_cast<int>(b.quality);
-        if (a.itemId != b.itemId)
-            return a.itemId < b.itemId;
-        return a.stackCount > b.stackCount;
-    });
-
-    // Write sorted items back, filling backpack first then equip bags.
-    int idx = 0;
-    int n = static_cast<int>(items.size());
-
-    for (int i = 0; i < BACKPACK_SLOTS; ++i)
-        backpack[i].item = (idx < n) ? items[idx++] : ItemDef{};
-
-    for (int b = 0; b < NUM_BAG_SLOTS; ++b) {
-        for (int s = 0; s < bags[b].size; ++s)
-            bags[b].slots[s].item = (idx < n) ? items[idx++] : ItemDef{};
-    }
-}
-
-std::vector<Inventory::SwapOp> Inventory::computeSortSwaps() const {
-    // Build a flat list of (bag, slot, item) entries matching the same traversal
-    // order as sortBags(): backpack first, then equip bags in order.
-    struct Entry {
-        uint8_t bag;   // WoW bag address: 0xFF=backpack, 19+i=equip bag i
-        uint8_t slot;  // WoW slot address: 23+i for backpack, slotIndex for bags
-        uint32_t itemId;
-        ItemQuality quality;
-        uint32_t stackCount;
-    };
-
-    std::vector<Entry> entries;
-    entries.reserve(BACKPACK_SLOTS + NUM_BAG_SLOTS * MAX_BAG_SIZE);
-
-    for (int i = 0; i < BACKPACK_SLOTS; ++i) {
-        entries.push_back({0xFF, static_cast<uint8_t>(NUM_EQUIP_SLOTS + i),
-                           backpack[i].item.itemId, backpack[i].item.quality,
-                           backpack[i].item.stackCount});
-    }
-    for (int b = 0; b < NUM_BAG_SLOTS; ++b) {
-        for (int s = 0; s < bags[b].size; ++s) {
-            entries.push_back({static_cast<uint8_t>(FIRST_BAG_EQUIP_SLOT + b), static_cast<uint8_t>(s),
-                               bags[b].slots[s].item.itemId, bags[b].slots[s].item.quality,
-                               bags[b].slots[s].item.stackCount});
-        }
-    }
-
-    // Build a sorted index array using the same comparator as sortBags().
-    int n = static_cast<int>(entries.size());
-    std::vector<int> sortedIdx(n);
-    for (int i = 0; i < n; ++i) sortedIdx[i] = i;
-
-    // Separate non-empty items and empty slots, then sort the non-empty items.
-    // Items are sorted by quality desc -> itemId asc -> stackCount desc.
-    // Empty slots go to the end.
-    std::stable_sort(sortedIdx.begin(), sortedIdx.end(), [&](int a, int b) {
-        bool aEmpty = (entries[a].itemId == 0);
-        bool bEmpty = (entries[b].itemId == 0);
-        if (aEmpty != bEmpty) return bEmpty; // non-empty before empty
-        if (aEmpty) return false; // both empty: preserve order
-        // Both non-empty: same comparator as sortBags()
-        if (entries[a].quality != entries[b].quality)
-            return static_cast<int>(entries[a].quality) > static_cast<int>(entries[b].quality);
-        if (entries[a].itemId != entries[b].itemId)
-            return entries[a].itemId < entries[b].itemId;
-        return entries[a].stackCount > entries[b].stackCount;
-    });
-
-    // sortedIdx[targetPos] = sourcePos means the item currently at sourcePos
-    // needs to end up at targetPos.  We use selection-sort-style swaps to
-    // permute current positions into sorted order, tracking where items move.
-
-    // posOf[i] = current position of the item that was originally at index i
-    std::vector<int> posOf(n);
-    for (int i = 0; i < n; ++i) posOf[i] = i;
-
-    // invPos[p] = which original item index is currently sitting at position p
-    std::vector<int> invPos(n);
-    for (int i = 0; i < n; ++i) invPos[i] = i;
-
-    std::vector<SwapOp> swaps;
-
-    for (int target = 0; target < n; ++target) {
-        int need = sortedIdx[target]; // original index that should be at 'target'
-        int cur = invPos[target];     // original index currently at 'target'
-        if (cur == need) continue;    // already in place
-
-        // Skip swaps between two empty slots
-        if (entries[cur].itemId == 0 && entries[need].itemId == 0) continue;
-
-        int srcPos = posOf[need]; // current position of the item we need
-
-        // Emit a swap between position srcPos and position target
-        swaps.push_back({entries[srcPos].bag, entries[srcPos].slot,
-                         entries[target].bag, entries[target].slot});
-
-        // Update tracking arrays
-        posOf[cur] = srcPos;
-        posOf[need] = target;
-        invPos[srcPos] = cur;
-        invPos[target] = need;
-    }
-
-    return swaps;
-}
-
 void Inventory::populateTestItems() {
     // Equipment
     {
@@ -455,8 +313,6 @@ const char* getQualityName(ItemQuality quality) {
         case ItemQuality::RARE:      return "Rare";
         case ItemQuality::EPIC:      return "Epic";
         case ItemQuality::LEGENDARY: return "Legendary";
-        case ItemQuality::ARTIFACT:  return "Artifact";
-        case ItemQuality::HEIRLOOM:  return "Heirloom";
         default:                     return "Unknown";
     }
 }
diff --git a/src/game/inventory_handler.cpp b/src/game/inventory_handler.cpp
deleted file mode 100644
index 4abb9f96..00000000
--- a/src/game/inventory_handler.cpp
+++ /dev/null
@@ -1,3394 +0,0 @@
-#include "game/inventory_handler.hpp"
-#include "game/game_handler.hpp"
-#include "game/game_utils.hpp"
-#include "game/entity.hpp"
-#include "game/packet_parsers.hpp"
-#include "rendering/renderer.hpp"
-#include "audio/audio_coordinator.hpp"
-#include "audio/ui_sound_manager.hpp"
-#include "core/application.hpp"
-#include "core/logger.hpp"
-#include "network/world_socket.hpp"
-#include "network/packet.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "pipeline/dbc_loader.hpp"
-#include "pipeline/dbc_layout.hpp"
-#include <algorithm>
-#include <cmath>
-#include <chrono>
-#include <sstream>
-
-namespace wowee {
-namespace game {
-
-std::string formatCopperAmount(uint32_t amount);
-
-InventoryHandler::InventoryHandler(GameHandler& owner)
-    : owner_(owner) {}
-
-// ============================================================
-// Opcode Registration
-// ============================================================
-
-void InventoryHandler::registerOpcodes(DispatchTable& table) {
-    // ---- Item query response ----
-    table[Opcode::SMSG_ITEM_QUERY_SINGLE_RESPONSE] = [this](network::Packet& packet) { handleItemQueryResponse(packet); };
-    table[Opcode::SMSG_ITEM_QUERY_MULTIPLE_RESPONSE] = [this](network::Packet& packet) { handleItemQueryResponse(packet); };
-
-    // ---- Loot ----
-    table[Opcode::SMSG_LOOT_RESPONSE] = [this](network::Packet& packet) { handleLootResponse(packet); };
-    table[Opcode::SMSG_LOOT_RELEASE_RESPONSE] = [this](network::Packet& packet) { handleLootReleaseResponse(packet); };
-    table[Opcode::SMSG_LOOT_REMOVED] = [this](network::Packet& packet) { handleLootRemoved(packet); };
-    table[Opcode::SMSG_LOOT_ROLL] = [this](network::Packet& packet) { handleLootRoll(packet); };
-    table[Opcode::SMSG_LOOT_ROLL_WON] = [this](network::Packet& packet) { handleLootRollWon(packet); };
-    table[Opcode::SMSG_LOOT_MASTER_LIST] = [this](network::Packet& packet) {
-        masterLootCandidates_.clear();
-        if (!packet.hasRemaining(1)) return;
-        uint8_t mlCount = packet.readUInt8();
-        masterLootCandidates_.reserve(mlCount);
-        for (uint8_t i = 0; i < mlCount; ++i) {
-            if (!packet.hasRemaining(8)) break;
-            masterLootCandidates_.push_back(packet.readUInt64());
-        }
-    };
-
-    // ---- Loot money / misc consume ----
-    table[Opcode::SMSG_LOOT_MONEY_NOTIFY] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(4)) return;
-        uint32_t amount = packet.readUInt32();
-        if (packet.hasRemaining(1))
-            /*uint8_t soleLooter =*/ packet.readUInt8();
-        owner_.playerMoneyCopper_ += amount;
-        owner_.pendingMoneyDelta_ = amount;
-        owner_.pendingMoneyDeltaTimer_ = 2.0f;
-        uint64_t notifyGuid = pendingLootMoneyGuid_ != 0 ? pendingLootMoneyGuid_ : currentLoot_.lootGuid;
-        pendingLootMoneyGuid_ = 0;
-        pendingLootMoneyAmount_ = 0;
-        pendingLootMoneyNotifyTimer_ = 0.0f;
-        bool alreadyAnnounced = false;
-        auto it = localLootState_.find(notifyGuid);
-        if (it != localLootState_.end()) {
-            alreadyAnnounced = it->second.moneyTaken;
-            it->second.moneyTaken = true;
-        }
-        if (!alreadyAnnounced) {
-            owner_.addSystemChatMessage("Looted: " + formatCopperAmount(amount));
-            auto* ac = owner_.services().audioCoordinator;
-            if (ac) {
-                if (auto* sfx = ac->getUiSoundManager()) {
-                    if (amount >= 10000) sfx->playLootCoinLarge();
-                    else sfx->playLootCoinSmall();
-                }
-            }
-            if (notifyGuid != 0)
-                recentLootMoneyAnnounceCooldowns_[notifyGuid] = 1.5f;
-        }
-        if (owner_.addonEventCallback_) owner_.addonEventCallback_("PLAYER_MONEY", {});
-    };
-    table[Opcode::SMSG_LOOT_CLEAR_MONEY] = [](network::Packet& /*packet*/) {};
-
-    // ---- Read item (books) (moved from GameHandler) ----
-    table[Opcode::SMSG_READ_ITEM_OK] = [this](network::Packet& packet) {
-        owner_.bookPages_.clear();  // fresh book for this item read
-        packet.skipAll();
-    };
-    table[Opcode::SMSG_READ_ITEM_FAILED] = [this](network::Packet& packet) {
-        owner_.addUIError("You cannot read this item.");
-        owner_.addSystemChatMessage("You cannot read this item.");
-        packet.skipAll();
-    };
-
-    // ---- Loot roll start / notifications ----
-    table[Opcode::SMSG_LOOT_START_ROLL] = [this](network::Packet& packet) {
-        // objectGuid(8) + mapId(4) (WotLK) + lootSlot(4) + itemId(4) + randSuffix(4) +
-        // randProp(4) + countdown(4) + voteMask(1)
-        const bool hasMapId = isActiveExpansion("wotlk");
-        const size_t minSz = hasMapId ? 33 : 29;
-        if (packet.getRemainingSize() < minSz) return;
-        uint64_t objectGuid = packet.readUInt64();
-        if (hasMapId) packet.readUInt32(); // mapId
-        uint32_t lootSlot = packet.readUInt32();
-        uint32_t itemId   = packet.readUInt32();
-        /*uint32_t randSuffix =*/ packet.readUInt32();
-        /*int32_t  randProp   =*/ static_cast<int32_t>(packet.readUInt32());
-        uint32_t countdown = packet.readUInt32();
-        uint8_t  voteMask  = packet.readUInt8();
-
-        // Resolve item name from cache
-        owner_.ensureItemInfo(itemId);
-        auto* info = owner_.getItemInfo(itemId);
-        std::string itemName = (info && !info->name.empty()) ? info->name : ("Item #" + std::to_string(itemId));
-        uint8_t quality = info ? static_cast<uint8_t>(info->quality) : 1;
-
-        pendingLootRollActive_ = true;
-        pendingLootRoll_ = {};
-        pendingLootRoll_.objectGuid = objectGuid;
-        pendingLootRoll_.slot = lootSlot;
-        pendingLootRoll_.itemId = itemId;
-        pendingLootRoll_.itemName = itemName;
-        pendingLootRoll_.itemQuality = quality;
-        pendingLootRoll_.rollCountdownMs = countdown;
-        pendingLootRoll_.voteMask = voteMask;
-        pendingLootRoll_.rollStartedAt = std::chrono::steady_clock::now();
-        pendingLootRoll_.playerRolls.clear();
-        std::string link = buildItemLink(itemId, quality, itemName);
-        owner_.addSystemChatMessage("Loot roll started for " + link + ".");
-        if (owner_.addonEventCallback_) owner_.addonEventCallback_("START_LOOT_ROLL", {});
-    };
-
-    table[Opcode::SMSG_LOOT_ALL_PASSED] = [this](network::Packet& packet) {
-        // objectGuid(8) + lootSlot(4) + itemId(4) + randSuffix(4) + randProp(4)
-        if (!packet.hasRemaining(24)) return;
-        /*uint64_t objectGuid =*/ packet.readUInt64();
-        /*uint32_t lootSlot   =*/ packet.readUInt32();
-        uint32_t itemId     = packet.readUInt32();
-        /*uint32_t randSuffix =*/ packet.readUInt32();
-        /*int32_t  randProp   =*/ static_cast<int32_t>(packet.readUInt32());
-        owner_.ensureItemInfo(itemId);
-        auto* allPassInfo = owner_.getItemInfo(itemId);
-        std::string allPassName = (allPassInfo && !allPassInfo->name.empty())
-            ? allPassInfo->name : ("Item #" + std::to_string(itemId));
-        uint32_t allPassQuality = allPassInfo ? allPassInfo->quality : 1u;
-        owner_.addSystemChatMessage("Everyone passed on " + buildItemLink(itemId, allPassQuality, allPassName) + ".");
-        pendingLootRollActive_ = false;
-    };
-
-    table[Opcode::SMSG_LOOT_ITEM_NOTIFY] = [this](network::Packet& packet) {
-        // objectGuid(8) + lootSlot(1) [Classic: uint32; WotLK: uint8]
-        if (!packet.hasRemaining(9)) return;
-        /*uint64_t objectGuid =*/ packet.readUInt64();
-        uint32_t lootSlot;
-        if (isActiveExpansion("wotlk")) {
-            lootSlot = packet.readUInt8();
-        } else {
-            if (!packet.hasRemaining(4)) return;
-            lootSlot = packet.readUInt32();
-        }
-        // Try to resolve item name
-        uint32_t itemId = 0;
-        for (const auto& lootItem : currentLoot_.items) {
-            if (lootItem.slotIndex == static_cast<uint8_t>(lootSlot)) {
-                itemId = lootItem.itemId;
-                break;
-            }
-        }
-        if (itemId != 0) {
-            auto* notifInfo = owner_.getItemInfo(itemId);
-            std::string itemName = (notifInfo && !notifInfo->name.empty())
-                ? notifInfo->name : ("Item #" + std::to_string(itemId));
-            uint32_t notifyQuality = notifInfo ? notifInfo->quality : 1u;
-            std::string itemLink2 = buildItemLink(itemId, notifyQuality, itemName);
-            owner_.addSystemChatMessage("You receive loot: " + itemLink2 + ".");
-        }
-    };
-
-    table[Opcode::SMSG_LOOT_SLOT_CHANGED] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(1)) {
-            uint8_t slotIdx = packet.readUInt8();
-            LOG_DEBUG("SMSG_LOOT_SLOT_CHANGED: slot=", (int)slotIdx);
-            // The server re-sends loot info for this slot; we can refresh from
-            // the next SMSG_LOOT_RESPONSE or SMSG_LOOT_ITEM_NOTIFY.
-        }
-    };
-
-    // ---- Item push result ----
-    table[Opcode::SMSG_ITEM_PUSH_RESULT] = [this](network::Packet& packet) {
-        // WotLK 3.3.5a: guid(8)+received(4)+created(4)+displayInChat(4)+bagSlot(1)
-        //   +slot(4)+itemId(4)+suffixFactor(4)+randomPropertyId(4)+count(4)+countInInventory(4)
-        if (!packet.hasRemaining(45)) return;
-        uint64_t guid = packet.readUInt64();
-        if (guid != owner_.playerGuid) { packet.skipAll(); return; }
-        /*uint32_t received      =*/ packet.readUInt32();
-        /*uint32_t created       =*/ packet.readUInt32();
-        /*uint32_t displayInChat =*/ packet.readUInt32();
-        /*uint8_t  bagSlot       =*/ packet.readUInt8();
-        /*uint32_t slot          =*/ packet.readUInt32();
-        uint32_t itemId = packet.readUInt32();
-        /*uint32_t suffixFactor  =*/ packet.readUInt32();
-        int32_t randomProp = static_cast<int32_t>(packet.readUInt32());
-        uint32_t count = packet.readUInt32();
-
-        auto* info = owner_.getItemInfo(itemId);
-        if (!info || info->name.empty()) {
-            // Item info not yet cached — defer notification
-            owner_.pendingItemPushNotifs_.push_back({itemId, count});
-            owner_.ensureItemInfo(itemId);
-            return;
-        }
-        std::string itemName = info->name;
-        if (randomProp != 0) {
-            std::string suffix = owner_.getRandomPropertyName(randomProp);
-            if (!suffix.empty()) itemName += " " + suffix;
-        }
-        uint32_t quality = info->quality;
-        std::string link = buildItemLink(itemId, quality, itemName);
-        std::string msg = "Received item: " + link;
-        if (count > 1) msg += " x" + std::to_string(count);
-        owner_.addSystemChatMessage(msg);
-        if (auto* ac = owner_.services().audioCoordinator) {
-            if (auto* sfx = ac->getUiSoundManager())
-                sfx->playLootItem();
-        }
-        if (owner_.addonEventCallback_) {
-            owner_.addonEventCallback_("BAG_UPDATE", {});
-            owner_.addonEventCallback_("ITEM_PUSH", {std::to_string(itemId), std::to_string(count)});
-        }
-        if (owner_.itemLootCallback_)
-            owner_.itemLootCallback_(itemId, count, quality, itemName);
-    };
-
-    // ---- Open container ----
-    table[Opcode::SMSG_OPEN_CONTAINER] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(8)) {
-            uint64_t containerGuid = packet.readUInt64();
-            LOG_DEBUG("SMSG_OPEN_CONTAINER: guid=0x", std::hex, containerGuid, std::dec);
-        }
-    };
-
-    // ---- Sell / Buy / Inventory ----
-    table[Opcode::SMSG_SELL_ITEM] = [this](network::Packet& packet) {
-        if ((packet.getRemainingSize()) >= 17) {
-            uint64_t vendorGuid = packet.readUInt64();
-            uint64_t itemGuid = packet.readUInt64();
-            uint8_t result = packet.readUInt8();
-            LOG_INFO("SMSG_SELL_ITEM: vendorGuid=0x", std::hex, vendorGuid,
-                     " itemGuid=0x", itemGuid, std::dec,
-                     " result=", static_cast<int>(result));
-            if (result == 0) {
-                pendingSellToBuyback_.erase(itemGuid);
-                if (auto* ac = owner_.services().audioCoordinator) {
-                    if (auto* sfx = ac->getUiSoundManager())
-                        sfx->playDropOnGround();
-                }
-                if (owner_.addonEventCallback_) {
-                    owner_.addonEventCallback_("BAG_UPDATE", {});
-                    owner_.addonEventCallback_("PLAYER_MONEY", {});
-                }
-            } else {
-                bool removedPending = false;
-                auto it = pendingSellToBuyback_.find(itemGuid);
-                if (it != pendingSellToBuyback_.end()) {
-                    for (auto bit = buybackItems_.begin(); bit != buybackItems_.end(); ++bit) {
-                        if (bit->itemGuid == itemGuid) {
-                            buybackItems_.erase(bit);
-                            return;
-                        }
-                    }
-                    pendingSellToBuyback_.erase(it);
-                    removedPending = true;
-                }
-                if (!removedPending) {
-                    if (!buybackItems_.empty()) {
-                        uint64_t frontGuid = buybackItems_.front().itemGuid;
-                        if (pendingSellToBuyback_.erase(frontGuid) > 0) {
-                            buybackItems_.pop_front();
-                            removedPending = true;
-                        }
-                    }
-                }
-                if (!removedPending && !pendingSellToBuyback_.empty()) {
-                    pendingSellToBuyback_.clear();
-                    buybackItems_.clear();
-                }
-                static const char* sellErrors[] = {
-                    "OK", "Can't find item", "Can't sell item",
-                    "Can't find vendor", "You don't own that item",
-                    "Unknown error", "Only empty bag"
-                };
-                const char* msg = (result < 7) ? sellErrors[result] : "Unknown sell error";
-                owner_.addUIError(std::string("Sell failed: ") + msg);
-                owner_.addSystemChatMessage(std::string("Sell failed: ") + msg);
-                if (auto* ac = owner_.services().audioCoordinator) {
-                    if (auto* sfx = ac->getUiSoundManager())
-                        sfx->playError();
-                }
-                LOG_WARNING("SMSG_SELL_ITEM error: ", (int)result, " (", msg, ")");
-            }
-        }
-    };
-
-    table[Opcode::SMSG_INVENTORY_CHANGE_FAILURE] = [this](network::Packet& packet) {
-        if ((packet.getRemainingSize()) >= 1) {
-            uint8_t error = packet.readUInt8();
-            if (error != 0) {
-                LOG_WARNING("SMSG_INVENTORY_CHANGE_FAILURE: error=", (int)error);
-                uint32_t requiredLevel = 0;
-                if (packet.hasRemaining(17)) {
-                    packet.readUInt64();
-                    packet.readUInt64();
-                    packet.readUInt8();
-                    if (error == 1 && packet.hasRemaining(4))
-                        requiredLevel = packet.readUInt32();
-                }
-                const char* errMsg = nullptr;
-                char levelBuf[64];
-                switch (error) {
-                    case 1:
-                        if (requiredLevel > 0) {
-                            std::snprintf(levelBuf, sizeof(levelBuf),
-                                          "You must reach level %u to use that item.", requiredLevel);
-                            owner_.addUIError(levelBuf);
-                            owner_.addSystemChatMessage(levelBuf);
-                        } else {
-                            owner_.addUIError("You must reach a higher level to use that item.");
-                            owner_.addSystemChatMessage("You must reach a higher level to use that item.");
-                        }
-                        return;
-                    case 2:  errMsg = "You don't have the required skill."; break;
-                    case 3:  errMsg = "That item doesn't go in that slot."; break;
-                    case 4:  errMsg = "That bag is full."; break;
-                    case 5:  errMsg = "Can't put bags in bags."; break;
-                    case 6:  errMsg = "Can't trade equipped bags."; break;
-                    case 7:  errMsg = "That slot only holds ammo."; break;
-                    case 8:  errMsg = "You can't use that item."; break;
-                    case 9:  errMsg = "No equipment slot available."; break;
-                    case 10: errMsg = "You can never use that item."; break;
-                    case 11: errMsg = "You can never use that item."; break;
-                    case 12: errMsg = "No equipment slot available."; break;
-                    case 13: errMsg = "Can't equip with a two-handed weapon."; break;
-                    case 14: errMsg = "Can't dual-wield."; break;
-                    case 15: errMsg = "That item doesn't go in that bag."; break;
-                    case 16: errMsg = "That item doesn't go in that bag."; break;
-                    case 17: errMsg = "You can't carry any more of those."; break;
-                    case 18: errMsg = "No equipment slot available."; break;
-                    case 19: errMsg = "Can't stack those items."; break;
-                    case 20: errMsg = "That item can't be equipped."; break;
-                    case 21: errMsg = "Can't swap items."; break;
-                    case 22: errMsg = "That slot is empty."; break;
-                    case 23: errMsg = "Item not found."; break;
-                    case 24: errMsg = "Can't drop soulbound items."; break;
-                    case 25: errMsg = "Out of range."; break;
-                    case 26: errMsg = "Need to split more than 1."; break;
-                    case 27: errMsg = "Split failed."; break;
-                    case 28: errMsg = "Not enough reagents."; break;
-                    case 29: errMsg = "Not enough money."; break;
-                    case 30: errMsg = "Not a bag."; break;
-                    case 31: errMsg = "Can't destroy non-empty bag."; break;
-                    case 32: errMsg = "You don't own that item."; break;
-                    case 33: errMsg = "You can only have one quiver."; break;
-                    case 34: errMsg = "No free bank slots."; break;
-                    case 35: errMsg = "No bank here."; break;
-                    case 36: errMsg = "Item is locked."; break;
-                    case 37: errMsg = "You are stunned."; break;
-                    case 38: errMsg = "You are dead."; break;
-                    case 39: errMsg = "Can't do that right now."; break;
-                    case 40: errMsg = "Internal bag error."; break;
-                    case 49: errMsg = "Loot is gone."; break;
-                    case 50: errMsg = "Inventory is full."; break;
-                    case 51: errMsg = "Bank is full."; break;
-                    case 52: errMsg = "That item is sold out."; break;
-                    case 58: errMsg = "That object is busy."; break;
-                    case 60: errMsg = "Can't do that in combat."; break;
-                    case 61: errMsg = "Can't do that while disarmed."; break;
-                    case 63: errMsg = "Requires a higher rank."; break;
-                    case 64: errMsg = "Requires higher reputation."; break;
-                    case 67: errMsg = "That item is unique-equipped."; break;
-                    case 69: errMsg = "Not enough honor points."; break;
-                    case 70: errMsg = "Not enough arena points."; break;
-                    case 77: errMsg = "Too much gold."; break;
-                    case 78: errMsg = "Can't do that during arena match."; break;
-                    case 80: errMsg = "Requires a personal arena rating."; break;
-                    case 87: errMsg = "Requires a higher level."; break;
-                    case 88: errMsg = "Requires the right talent."; break;
-                    default: break;
-                }
-                std::string msg = errMsg ? errMsg : "Inventory error (" + std::to_string(error) + ").";
-                owner_.addUIError(msg);
-                owner_.addSystemChatMessage(msg);
-                if (auto* ac = owner_.services().audioCoordinator) {
-                    if (auto* sfx = ac->getUiSoundManager())
-                        sfx->playError();
-                }
-            }
-        }
-    };
-
-    table[Opcode::SMSG_BUY_FAILED] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(13)) {
-            uint64_t vendorGuid = packet.readUInt64();
-            uint32_t itemIdOrSlot = packet.readUInt32();
-            uint8_t errCode = packet.readUInt8();
-            LOG_INFO("SMSG_BUY_FAILED: vendorGuid=0x", std::hex, vendorGuid, std::dec,
-                     " item/slot=", itemIdOrSlot,
-                     " err=", static_cast<int>(errCode),
-                     " pendingBuybackSlot=", pendingBuybackSlot_,
-                     " pendingBuybackWireSlot=", pendingBuybackWireSlot_,
-                     " pendingBuyItemId=", pendingBuyItemId_,
-                     " pendingBuyItemSlot=", pendingBuyItemSlot_);
-            if (pendingBuybackSlot_ >= 0) {
-                if (errCode == 0) {
-                    constexpr uint32_t kBuybackSlotEnd = 85;
-                    if (pendingBuybackWireSlot_ >= 74 && pendingBuybackWireSlot_ < kBuybackSlotEnd &&
-                        owner_.socket && owner_.state == WorldState::IN_WORLD && currentVendorItems_.vendorGuid != 0) {
-                        ++pendingBuybackWireSlot_;
-                        LOG_INFO("Buyback retry: vendorGuid=0x", std::hex, currentVendorItems_.vendorGuid,
-                                 std::dec, " uiSlot=", pendingBuybackSlot_,
-                                 " wireSlot=", pendingBuybackWireSlot_);
-                        owner_.socket->send(BuybackItemPacket::build(
-                            currentVendorItems_.vendorGuid, pendingBuybackWireSlot_));
-                        return;
-                    }
-                    if (pendingBuybackSlot_ < static_cast<int>(buybackItems_.size())) {
-                        buybackItems_.erase(buybackItems_.begin() + pendingBuybackSlot_);
-                    }
-                    pendingBuybackSlot_ = -1;
-                    pendingBuybackWireSlot_ = 0;
-                    if (currentVendorItems_.vendorGuid != 0 && owner_.socket && owner_.state == WorldState::IN_WORLD) {
-                        auto pkt = ListInventoryPacket::build(currentVendorItems_.vendorGuid);
-                        owner_.socket->send(pkt);
-                    }
-                    return;
-                }
-                pendingBuybackSlot_ = -1;
-                pendingBuybackWireSlot_ = 0;
-            }
-            const char* msg = "Purchase failed.";
-            switch (errCode) {
-                case 0: msg = "Purchase failed: item not found."; break;
-                case 2: msg = "You don't have enough money."; break;
-                case 4: msg = "Seller is too far away."; break;
-                case 5: msg = "That item is sold out."; break;
-                case 6: msg = "You can't carry any more items."; break;
-                default: break;
-            }
-            owner_.addUIError(msg);
-            owner_.addSystemChatMessage(msg);
-            if (auto* ac = owner_.services().audioCoordinator) {
-                if (auto* sfx = ac->getUiSoundManager())
-                    sfx->playError();
-            }
-        }
-    };
-
-    table[Opcode::SMSG_BUY_ITEM] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(20)) {
-            /*uint64_t vendorGuid =*/ packet.readUInt64();
-            /*uint32_t vendorSlot =*/ packet.readUInt32();
-            /*int32_t  newCount   =*/ static_cast<int32_t>(packet.readUInt32());
-            uint32_t itemCount  = packet.readUInt32();
-            if (pendingBuyItemId_ != 0) {
-                std::string itemLabel;
-                uint32_t buyQuality = 1;
-                if (const ItemQueryResponseData* info = owner_.getItemInfo(pendingBuyItemId_)) {
-                    if (!info->name.empty()) itemLabel = info->name;
-                    buyQuality = info->quality;
-                }
-                if (itemLabel.empty()) itemLabel = "item #" + std::to_string(pendingBuyItemId_);
-                std::string msg = "Purchased: " + buildItemLink(pendingBuyItemId_, buyQuality, itemLabel);
-                if (itemCount > 1) msg += " x" + std::to_string(itemCount);
-                owner_.addSystemChatMessage(msg);
-                if (auto* ac = owner_.services().audioCoordinator) {
-                    if (auto* sfx = ac->getUiSoundManager())
-                        sfx->playPickupBag();
-                }
-            }
-            pendingBuyItemId_   = 0;
-            pendingBuyItemSlot_ = 0;
-            if (owner_.addonEventCallback_) {
-                owner_.addonEventCallback_("MERCHANT_UPDATE", {});
-                owner_.addonEventCallback_("BAG_UPDATE", {});
-            }
-        }
-    };
-
-    // ---- Vendor / Trainer ----
-    table[Opcode::SMSG_LIST_INVENTORY] = [this](network::Packet& packet) { handleListInventory(packet); };
-    table[Opcode::SMSG_TRAINER_LIST] = [this](network::Packet& packet) { handleTrainerList(packet); };
-
-    // ---- Mail ----
-    table[Opcode::SMSG_SHOW_MAILBOX] = [this](network::Packet& packet) { handleShowMailbox(packet); };
-    table[Opcode::SMSG_MAIL_LIST_RESULT] = [this](network::Packet& packet) { handleMailListResult(packet); };
-    table[Opcode::SMSG_SEND_MAIL_RESULT] = [this](network::Packet& packet) { handleSendMailResult(packet); };
-    table[Opcode::SMSG_RECEIVED_MAIL] = [this](network::Packet& packet) { handleReceivedMail(packet); };
-    table[Opcode::MSG_QUERY_NEXT_MAIL_TIME] = [this](network::Packet& packet) { handleQueryNextMailTime(packet); };
-
-    // ---- Bank ----
-    table[Opcode::SMSG_SHOW_BANK] = [this](network::Packet& packet) { handleShowBank(packet); };
-    table[Opcode::SMSG_BUY_BANK_SLOT_RESULT] = [this](network::Packet& packet) { handleBuyBankSlotResult(packet); };
-
-    // ---- Guild Bank ----
-    table[Opcode::SMSG_GUILD_BANK_LIST] = [this](network::Packet& packet) { handleGuildBankList(packet); };
-
-    // ---- Auction House ----
-    table[Opcode::MSG_AUCTION_HELLO] = [this](network::Packet& packet) { handleAuctionHello(packet); };
-    table[Opcode::SMSG_AUCTION_LIST_RESULT] = [this](network::Packet& packet) { handleAuctionListResult(packet); };
-    table[Opcode::SMSG_AUCTION_OWNER_LIST_RESULT] = [this](network::Packet& packet) { handleAuctionOwnerListResult(packet); };
-    table[Opcode::SMSG_AUCTION_BIDDER_LIST_RESULT] = [this](network::Packet& packet) { handleAuctionBidderListResult(packet); };
-    table[Opcode::SMSG_AUCTION_COMMAND_RESULT] = [this](network::Packet& packet) { handleAuctionCommandResult(packet); };
-
-    table[Opcode::SMSG_AUCTION_OWNER_NOTIFICATION] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(16)) {
-            /*uint32_t auctionId =*/ packet.readUInt32();
-            uint32_t action    = packet.readUInt32();
-            /*uint32_t error   =*/ packet.readUInt32();
-            uint32_t itemEntry = packet.readUInt32();
-            int32_t ownerRandProp = 0;
-            if (packet.hasRemaining(4))
-                ownerRandProp = static_cast<int32_t>(packet.readUInt32());
-            owner_.ensureItemInfo(itemEntry);
-            auto* info = owner_.getItemInfo(itemEntry);
-            std::string rawName = info && !info->name.empty() ? info->name : ("Item #" + std::to_string(itemEntry));
-            if (ownerRandProp != 0) {
-                std::string suffix = owner_.getRandomPropertyName(ownerRandProp);
-                if (!suffix.empty()) rawName += " " + suffix;
-            }
-            uint32_t aucQuality = info ? info->quality : 1u;
-            std::string itemLink = buildItemLink(itemEntry, aucQuality, rawName);
-            if (action == 1)
-                owner_.addSystemChatMessage("Your auction of " + itemLink + " has expired.");
-            else if (action == 2)
-                owner_.addSystemChatMessage("A bid has been placed on your auction of " + itemLink + ".");
-            else
-                owner_.addSystemChatMessage("Your auction of " + itemLink + " has sold!");
-        }
-        packet.skipAll();
-    };
-
-    table[Opcode::SMSG_AUCTION_BIDDER_NOTIFICATION] = [this](network::Packet& packet) {
-        // WotLK format: auctionHouseId(4) + auctionId(4) + bidderGuid(8) +
-        // bidAmount(4) + outbidAmount(4) + itemEntry(4) + randomPropertyId(4) = 32 bytes.
-        // Previously read auctionHouseId as auctionId and auctionId as itemEntry,
-        // so outbid messages always referenced the wrong item.
-        if (!packet.hasRemaining(32)) { packet.skipAll(); return; }
-        /*uint32_t auctionHouseId =*/ packet.readUInt32();
-        /*uint32_t auctionId      =*/ packet.readUInt32();
-        /*uint64_t bidderGuid     =*/ packet.readUInt64();
-        /*uint32_t bidAmount      =*/ packet.readUInt32();
-        /*uint32_t outbidAmount   =*/ packet.readUInt32();
-        uint32_t itemEntry = packet.readUInt32();
-        int32_t bidRandProp = static_cast<int32_t>(packet.readUInt32());
-        owner_.ensureItemInfo(itemEntry);
-        auto* info = owner_.getItemInfo(itemEntry);
-        std::string rawName = info && !info->name.empty() ? info->name : ("Item #" + std::to_string(itemEntry));
-        if (bidRandProp != 0) {
-            std::string suffix = owner_.getRandomPropertyName(bidRandProp);
-            if (!suffix.empty()) rawName += " " + suffix;
-        }
-        uint32_t bidQuality = info ? info->quality : 1u;
-        owner_.addSystemChatMessage("You have been outbid on " + buildItemLink(itemEntry, bidQuality, rawName) + ".");
-        packet.skipAll();
-    };
-
-    table[Opcode::SMSG_AUCTION_REMOVED_NOTIFICATION] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(12)) {
-            /*uint32_t auctionId =*/ packet.readUInt32();
-            uint32_t itemEntry = packet.readUInt32();
-            int32_t itemRandom = static_cast<int32_t>(packet.readUInt32());
-            owner_.ensureItemInfo(itemEntry);
-            auto* info = owner_.getItemInfo(itemEntry);
-            std::string rawName3 = info && !info->name.empty() ? info->name : ("Item #" + std::to_string(itemEntry));
-            if (itemRandom != 0) {
-                std::string suffix = owner_.getRandomPropertyName(itemRandom);
-                if (!suffix.empty()) rawName3 += " " + suffix;
-            }
-            uint32_t remQuality = info ? info->quality : 1u;
-            std::string remLink = buildItemLink(itemEntry, remQuality, rawName3);
-            owner_.addSystemChatMessage("Your auction of " + remLink + " has expired.");
-        }
-        packet.skipAll();
-    };
-
-    // ---- Equipment Sets ----
-    table[Opcode::SMSG_EQUIPMENT_SET_LIST] = [this](network::Packet& packet) { handleEquipmentSetList(packet); };
-    table[Opcode::SMSG_EQUIPMENT_SET_SAVED] = [this](network::Packet& packet) {
-        std::string setName;
-        if (packet.hasRemaining(12)) {
-            uint32_t setIndex = packet.readUInt32();
-            uint64_t setGuid  = packet.readUInt64();
-            bool found = false;
-            for (auto& es : equipmentSets_) {
-                if (es.setGuid == setGuid || es.setId == setIndex) {
-                    es.setGuid = setGuid;
-                    setName = es.name;
-                    found = true;
-                    break;
-                }
-            }
-            for (auto& info : equipmentSetInfo_) {
-                if (info.setGuid == setGuid || info.setId == setIndex) {
-                    info.setGuid = setGuid;
-                    break;
-                }
-            }
-            if (!found && setGuid != 0) {
-                EquipmentSet newEs;
-                newEs.setGuid = setGuid;
-                newEs.setId   = setIndex;
-                newEs.name    = pendingSaveSetName_;
-                newEs.iconName = pendingSaveSetIcon_;
-                for (int s = 0; s < 19; ++s)
-                    newEs.itemGuids[s] = owner_.getEquipSlotGuid(s);
-                equipmentSets_.push_back(std::move(newEs));
-                EquipmentSetInfo newInfo;
-                newInfo.setGuid = setGuid;
-                newInfo.setId   = setIndex;
-                newInfo.name    = pendingSaveSetName_;
-                newInfo.iconName = pendingSaveSetIcon_;
-                equipmentSetInfo_.push_back(std::move(newInfo));
-                setName = pendingSaveSetName_;
-            }
-            pendingSaveSetName_.clear();
-            pendingSaveSetIcon_.clear();
-            LOG_INFO("SMSG_EQUIPMENT_SET_SAVED: index=", setIndex,
-                     " guid=", setGuid, " name=", setName);
-        }
-        owner_.addSystemChatMessage(setName.empty()
-            ? std::string("Equipment set saved.")
-            : "Equipment set \"" + setName + "\" saved.");
-    };
-
-    table[Opcode::SMSG_EQUIPMENT_SET_USE_RESULT] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(1)) {
-            uint8_t result = packet.readUInt8();
-            if (result != 0) { owner_.addUIError("Failed to equip item set."); owner_.addSystemChatMessage("Failed to equip item set."); }
-        }
-    };
-
-    // ---- Item text ----
-    table[Opcode::SMSG_ITEM_TEXT_QUERY_RESPONSE] = [this](network::Packet& packet) { handleItemTextQueryResponse(packet); };
-
-    // ---- Trade ----
-    table[Opcode::SMSG_TRADE_STATUS] = [this](network::Packet& packet) { handleTradeStatus(packet); };
-    table[Opcode::SMSG_TRADE_STATUS_EXTENDED] = [this](network::Packet& packet) { handleTradeStatusExtended(packet); };
-
-    // ---- Trainer buy ----
-    table[Opcode::SMSG_TRAINER_BUY_SUCCEEDED] = [this](network::Packet& p) { handleTrainerBuySucceeded(p); };
-    table[Opcode::SMSG_TRAINER_BUY_FAILED] = [this](network::Packet& p) { handleTrainerBuyFailed(p); };
-}
-
-// ============================================================
-// Loot
-// ============================================================
-
-void InventoryHandler::lootTarget(uint64_t targetGuid) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    currentLoot_.items.clear();
-    LOG_INFO("Looting target 0x", std::hex, targetGuid, std::dec);
-    auto packet = LootPacket::build(targetGuid);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::lootItem(uint8_t slotIndex) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = AutostoreLootItemPacket::build(slotIndex);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::closeLoot() {
-    if (!lootWindowOpen_) return;
-    if (owner_.state == WorldState::IN_WORLD && owner_.socket) {
-        auto packet = LootReleasePacket::build(currentLoot_.lootGuid);
-        owner_.socket->send(packet);
-    }
-    lootWindowOpen_ = false;
-    if (owner_.lootWindowCallback_) owner_.lootWindowCallback_(false);
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("LOOT_CLOSED", {});
-    currentLoot_ = LootResponseData{};
-}
-
-void InventoryHandler::lootMasterGive(uint8_t lootSlot, uint64_t targetGuid) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_LOOT_MASTER_GIVE));
-    pkt.writeUInt64(currentLoot_.lootGuid);
-    pkt.writeUInt8(lootSlot);
-    pkt.writeUInt64(targetGuid);
-    owner_.socket->send(pkt);
-}
-
-void InventoryHandler::handleLootResponse(network::Packet& packet) {
-    const bool wotlkLoot = isActiveExpansion("wotlk");
-    if (!LootResponseParser::parse(packet, currentLoot_, wotlkLoot)) return;
-    const bool hasLoot = !currentLoot_.items.empty() || currentLoot_.gold > 0;
-    LOG_DEBUG("SMSG_LOOT_RESPONSE: guid=0x", std::hex, currentLoot_.lootGuid, std::dec,
-              " items=", currentLoot_.items.size(), " gold=", currentLoot_.gold);
-    if (!hasLoot && owner_.isCasting() && owner_.getCurrentCastSpellId() != 0 && lastInteractedGoGuid_ != 0) {
-        LOG_DEBUG("Ignoring empty SMSG_LOOT_RESPONSE during gather cast");
-        return;
-    }
-    lootWindowOpen_ = true;
-    if (owner_.lootWindowCallback_) owner_.lootWindowCallback_(true);
-    if (owner_.addonEventCallback_) {
-        owner_.addonEventCallback_("LOOT_OPENED", {});
-        owner_.addonEventCallback_("LOOT_READY", {});
-    }
-    lastInteractedGoGuid_ = 0;
-    pendingGameObjectLootOpens_.erase(
-        std::remove_if(pendingGameObjectLootOpens_.begin(), pendingGameObjectLootOpens_.end(),
-                       [&](const PendingLootOpen& p) { return p.guid == currentLoot_.lootGuid; }),
-        pendingGameObjectLootOpens_.end());
-    auto& localLoot = localLootState_[currentLoot_.lootGuid];
-    localLoot.data = currentLoot_;
-
-    for (const auto& item : currentLoot_.items) {
-        owner_.queryItemInfo(item.itemId, 0);
-    }
-
-    if (currentLoot_.gold > 0) {
-        if (owner_.state == WorldState::IN_WORLD && owner_.socket) {
-            bool suppressFallback = false;
-            auto cooldownIt = recentLootMoneyAnnounceCooldowns_.find(currentLoot_.lootGuid);
-            if (cooldownIt != recentLootMoneyAnnounceCooldowns_.end() && cooldownIt->second > 0.0f) {
-                suppressFallback = true;
-            }
-            pendingLootMoneyGuid_ = suppressFallback ? 0 : currentLoot_.lootGuid;
-            pendingLootMoneyAmount_ = suppressFallback ? 0 : currentLoot_.gold;
-            pendingLootMoneyNotifyTimer_ = suppressFallback ? 0.0f : 0.4f;
-            auto pkt = LootMoneyPacket::build();
-            owner_.socket->send(pkt);
-            currentLoot_.gold = 0;
-        }
-    }
-
-    if (autoLoot_ && owner_.state == WorldState::IN_WORLD && owner_.socket && !localLoot.itemAutoLootSent) {
-        for (const auto& item : currentLoot_.items) {
-            auto pkt = AutostoreLootItemPacket::build(item.slotIndex);
-            owner_.socket->send(pkt);
-        }
-        localLoot.itemAutoLootSent = true;
-    }
-}
-
-void InventoryHandler::handleLootReleaseResponse(network::Packet& packet) {
-    (void)packet;
-    localLootState_.erase(currentLoot_.lootGuid);
-    lootWindowOpen_ = false;
-    if (owner_.lootWindowCallback_) owner_.lootWindowCallback_(false);
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("LOOT_CLOSED", {});
-    currentLoot_ = LootResponseData{};
-}
-
-void InventoryHandler::handleLootRemoved(network::Packet& packet) {
-    uint8_t slotIndex = packet.readUInt8();
-    for (auto it = currentLoot_.items.begin(); it != currentLoot_.items.end(); ++it) {
-        if (it->slotIndex == slotIndex) {
-            std::string itemName = "item #" + std::to_string(it->itemId);
-            uint32_t quality = 1;
-            if (const ItemQueryResponseData* info = owner_.getItemInfo(it->itemId)) {
-                if (!info->name.empty()) itemName = info->name;
-                quality = info->quality;
-            }
-            std::string link = buildItemLink(it->itemId, quality, itemName);
-            std::string msgStr = "Looted: " + link;
-            if (it->count > 1) msgStr += " x" + std::to_string(it->count);
-            owner_.addSystemChatMessage(msgStr);
-            if (auto* ac = owner_.services().audioCoordinator) {
-                if (auto* sfx = ac->getUiSoundManager())
-                    sfx->playLootItem();
-            }
-            currentLoot_.items.erase(it);
-            if (owner_.addonEventCallback_)
-                owner_.addonEventCallback_("LOOT_SLOT_CLEARED", {std::to_string(slotIndex + 1)});
-            break;
-        }
-    }
-}
-
-// ============================================================
-// Loot Roll
-// ============================================================
-
-void InventoryHandler::sendLootRoll(uint64_t objectGuid, uint32_t slot, uint8_t rollType) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_LOOT_ROLL));
-    pkt.writeUInt64(objectGuid);
-    pkt.writeUInt32(slot);
-    pkt.writeUInt8(rollType);
-    owner_.socket->send(pkt);
-    if (rollType == 128) { // pass
-        pendingLootRollActive_ = false;
-    }
-}
-
-void InventoryHandler::handleLootRoll(network::Packet& packet) {
-    // objectGuid(8) + lootSlot(4) + playerGuid(8) + itemId(4) + itemRandSuffix(4) +
-    // itemRandProp(4) + rollNumber(1) + rollType(1) + autoPass(1)
-    if (!packet.hasRemaining(35)) return;
-    uint64_t objectGuid = packet.readUInt64();
-    uint32_t lootSlot   = packet.readUInt32();
-    uint64_t playerGuid = packet.readUInt64();
-    /*uint32_t itemId     =*/ packet.readUInt32();
-    /*uint32_t randSuffix =*/ packet.readUInt32();
-    /*int32_t  randProp   =*/ static_cast<int32_t>(packet.readUInt32());
-    uint8_t rollNumber  = packet.readUInt8();
-    uint8_t rollType    = packet.readUInt8();
-    /*uint8_t autoPass   =*/ packet.readUInt8();
-
-    // Resolve player name
-    std::string playerName;
-    auto nit = owner_.getPlayerNameCache().find(playerGuid);
-    if (nit != owner_.getPlayerNameCache().end()) playerName = nit->second;
-    if (playerName.empty()) playerName = "Player";
-
-    if (pendingLootRollActive_ &&
-        pendingLootRoll_.objectGuid == objectGuid &&
-        pendingLootRoll_.slot == lootSlot) {
-        LootRollEntry::PlayerRollResult result;
-        result.playerName = playerName;
-        result.rollNum = rollNumber;
-        result.rollType = rollType;
-        pendingLootRoll_.playerRolls.push_back(result);
-    }
-
-    const char* typeStr = "passed on";
-    if (rollType == 0) typeStr = "rolled Need";
-    else if (rollType == 1) typeStr = "rolled Greed";
-    else if (rollType == 2) typeStr = "rolled Disenchant";
-    if (rollType <= 2) {
-        owner_.addSystemChatMessage(playerName + " " + typeStr + " - " + std::to_string(rollNumber));
-    } else {
-        owner_.addSystemChatMessage(playerName + " passed.");
-    }
-}
-
-void InventoryHandler::handleLootRollWon(network::Packet& packet) {
-    // objectGuid(8) + lootSlot(4) + itemId(4) + itemSuffix(4) + itemProp(4) + playerGuid(8) + rollNumber(1) + rollType(1)
-    if (!packet.hasRemaining(34)) return;
-    /*uint64_t objectGuid =*/ packet.readUInt64();
-    /*uint32_t lootSlot   =*/ packet.readUInt32();
-    uint32_t itemId     = packet.readUInt32();
-    /*uint32_t randSuffix =*/ packet.readUInt32();
-    int32_t wonRandProp = static_cast<int32_t>(packet.readUInt32());
-    uint64_t winnerGuid = packet.readUInt64();
-    uint8_t rollNumber  = packet.readUInt8();
-    uint8_t rollType    = packet.readUInt8();
-
-    std::string winnerName;
-    auto nit = owner_.getPlayerNameCache().find(winnerGuid);
-    if (nit != owner_.getPlayerNameCache().end()) winnerName = nit->second;
-    if (winnerName.empty()) winnerName = "Player";
-
-    owner_.ensureItemInfo(itemId);
-    auto* info = owner_.getItemInfo(itemId);
-    std::string itemName = (info && !info->name.empty()) ? info->name : ("Item #" + std::to_string(itemId));
-    if (wonRandProp != 0) {
-        std::string suffix = owner_.getRandomPropertyName(wonRandProp);
-        if (!suffix.empty()) itemName += " " + suffix;
-    }
-    uint32_t wonQuality = info ? info->quality : 1u;
-    std::string link = buildItemLink(itemId, wonQuality, itemName);
-
-    const char* typeStr = "Need";
-    if (rollType == 1) typeStr = "Greed";
-    else if (rollType == 2) typeStr = "Disenchant";
-
-    owner_.addSystemChatMessage(winnerName + " won " + link + " (" + typeStr + " - " + std::to_string(rollNumber) + ")");
-    pendingLootRollActive_ = false;
-}
-
-// ============================================================
-// Vendor
-// ============================================================
-
-void InventoryHandler::openVendor(uint64_t npcGuid) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    buybackItems_.clear();
-    auto packet = ListInventoryPacket::build(npcGuid);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::closeVendor() {
-    bool wasOpen = vendorWindowOpen_;
-    vendorWindowOpen_ = false;
-    currentVendorItems_ = ListInventoryData{};
-    buybackItems_.clear();
-    pendingSellToBuyback_.clear();
-    pendingBuybackSlot_ = -1;
-    pendingBuybackWireSlot_ = 0;
-    pendingBuyItemId_ = 0;
-    pendingBuyItemSlot_ = 0;
-    if (wasOpen && owner_.addonEventCallback_) owner_.addonEventCallback_("MERCHANT_CLOSED", {});
-}
-
-void InventoryHandler::buyItem(uint64_t vendorGuid, uint32_t itemId, uint32_t slot, uint32_t count) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    LOG_INFO("Buy request: vendorGuid=0x", std::hex, vendorGuid, std::dec,
-             " itemId=", itemId, " slot=", slot, " count=", count,
-             " wire=0x", std::hex, wireOpcode(Opcode::CMSG_BUY_ITEM), std::dec);
-    pendingBuyItemId_ = itemId;
-    pendingBuyItemSlot_ = slot;
-    network::Packet packet(wireOpcode(Opcode::CMSG_BUY_ITEM));
-    packet.writeUInt64(vendorGuid);
-    packet.writeUInt32(itemId);
-    packet.writeUInt32(slot);
-    packet.writeUInt32(count);
-    const bool isWotLk = isActiveExpansion("wotlk");
-    if (isWotLk) {
-        packet.writeUInt8(0);
-    }
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::sellItem(uint64_t vendorGuid, uint64_t itemGuid, uint32_t count) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    LOG_INFO("Sell request: vendorGuid=0x", std::hex, vendorGuid,
-             " itemGuid=0x", itemGuid, std::dec,
-             " count=", count, " wire=0x", std::hex, wireOpcode(Opcode::CMSG_SELL_ITEM), std::dec);
-    auto packet = SellItemPacket::build(vendorGuid, itemGuid, count);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::sellItemBySlot(int backpackIndex) {
-    if (backpackIndex < 0 || backpackIndex >= owner_.inventory.getBackpackSize()) return;
-    const auto& slot = owner_.inventory.getBackpackSlot(backpackIndex);
-    if (slot.empty()) return;
-
-    uint32_t sellPrice = slot.item.sellPrice;
-    if (sellPrice == 0) {
-        if (auto* info = owner_.getItemInfo(slot.item.itemId); info && info->valid) {
-            sellPrice = info->sellPrice;
-        }
-    }
-    if (sellPrice == 0) {
-        owner_.addSystemChatMessage("Cannot sell: this item has no vendor value.");
-        return;
-    }
-
-    uint64_t itemGuid = owner_.backpackSlotGuids_[backpackIndex];
-    if (itemGuid == 0) {
-        itemGuid = owner_.resolveOnlineItemGuid(slot.item.itemId);
-    }
-    LOG_DEBUG("sellItemBySlot: slot=", backpackIndex,
-              " item=", slot.item.name,
-              " itemGuid=0x", std::hex, itemGuid, std::dec,
-              " vendorGuid=0x", std::hex, currentVendorItems_.vendorGuid, std::dec);
-    if (itemGuid != 0 && currentVendorItems_.vendorGuid != 0) {
-        BuybackItem sold;
-        sold.itemGuid = itemGuid;
-        sold.item = slot.item;
-        sold.count = 1;
-        buybackItems_.push_front(sold);
-        if (buybackItems_.size() > 12) buybackItems_.pop_back();
-        pendingSellToBuyback_[itemGuid] = sold;
-        sellItem(currentVendorItems_.vendorGuid, itemGuid, 1);
-    } else if (itemGuid == 0) {
-        owner_.addSystemChatMessage("Cannot sell: item not found in inventory.");
-        LOG_WARNING("Sell failed: missing item GUID for slot ", backpackIndex);
-    } else {
-        owner_.addSystemChatMessage("Cannot sell: no vendor.");
-    }
-}
-
-void InventoryHandler::sellItemInBag(int bagIndex, int slotIndex) {
-    if (bagIndex < 0 || bagIndex >= owner_.inventory.NUM_BAG_SLOTS) return;
-    if (slotIndex < 0 || slotIndex >= owner_.inventory.getBagSize(bagIndex)) return;
-    const auto& slot = owner_.inventory.getBagSlot(bagIndex, slotIndex);
-    if (slot.empty()) return;
-
-    uint32_t sellPrice = slot.item.sellPrice;
-    if (sellPrice == 0) {
-        if (auto* info = owner_.getItemInfo(slot.item.itemId); info && info->valid) {
-            sellPrice = info->sellPrice;
-        }
-    }
-    if (sellPrice == 0) {
-        owner_.addSystemChatMessage("Cannot sell: this item has no vendor value.");
-        return;
-    }
-
-    uint64_t itemGuid = 0;
-    uint64_t bagGuid = owner_.equipSlotGuids_[Inventory::FIRST_BAG_EQUIP_SLOT + bagIndex];
-    if (bagGuid != 0) {
-        auto it = owner_.containerContents_.find(bagGuid);
-        if (it != owner_.containerContents_.end() && slotIndex < static_cast<int>(it->second.numSlots)) {
-            itemGuid = it->second.slotGuids[slotIndex];
-        }
-    }
-    if (itemGuid == 0) {
-        itemGuid = owner_.resolveOnlineItemGuid(slot.item.itemId);
-    }
-
-    if (itemGuid != 0 && currentVendorItems_.vendorGuid != 0) {
-        BuybackItem sold;
-        sold.itemGuid = itemGuid;
-        sold.item = slot.item;
-        sold.count = 1;
-        buybackItems_.push_front(sold);
-        if (buybackItems_.size() > 12) buybackItems_.pop_back();
-        pendingSellToBuyback_[itemGuid] = sold;
-        sellItem(currentVendorItems_.vendorGuid, itemGuid, 1);
-    } else if (itemGuid == 0) {
-        owner_.addSystemChatMessage("Cannot sell: item not found.");
-    } else {
-        owner_.addSystemChatMessage("Cannot sell: no vendor.");
-    }
-}
-
-void InventoryHandler::buyBackItem(uint32_t buybackSlot) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || currentVendorItems_.vendorGuid == 0) return;
-    constexpr uint32_t kBuybackSlotStart = 74;
-    uint32_t wireSlot = kBuybackSlotStart + buybackSlot;
-    pendingBuyItemId_ = 0;
-    pendingBuyItemSlot_ = 0;
-    LOG_INFO("Buyback request: vendorGuid=0x", std::hex, currentVendorItems_.vendorGuid,
-             std::dec, " uiSlot=", buybackSlot, " wireSlot=", wireSlot);
-    pendingBuybackSlot_ = static_cast<int>(buybackSlot);
-    pendingBuybackWireSlot_ = wireSlot;
-    // Use the expansion-agnostic packet builder so the opcode resolves from
-    // the active expansion's JSON mapping rather than a hardcoded WotLK value.
-    owner_.socket->send(BuybackItemPacket::build(currentVendorItems_.vendorGuid, wireSlot));
-}
-
-void InventoryHandler::repairItem(uint64_t vendorGuid, uint64_t itemGuid) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-
-    uint32_t cost = estimateItemRepairCost(itemGuid);
-    if (cost > 0 && owner_.getMoneyCopper() < cost) {
-        owner_.addUIError("Not enough money");
-        return;
-    }
-
-    network::Packet packet(wireOpcode(Opcode::CMSG_REPAIR_ITEM));
-    packet.writeUInt64(vendorGuid);
-    packet.writeUInt64(itemGuid);
-    if (!isClassicLikeExpansion()) packet.writeUInt8(0);
-    owner_.socket->send(packet);
-
-    // Only do optimistic update if we verified the player can afford it
-    if (cost > 0) {
-        owner_.playerMoneyCopper_ -= cost;
-        auto it = owner_.onlineItems_.find(itemGuid);
-        if (it != owner_.onlineItems_.end()) {
-            it->second.curDurability = it->second.maxDurability;
-            rebuildOnlineInventory();
-        }
-    }
-}
-
-void InventoryHandler::repairAll(uint64_t vendorGuid, bool useGuildBank) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-
-    uint32_t totalCost = estimateRepairAllCost();
-
-    if (!useGuildBank && totalCost > 0 && owner_.getMoneyCopper() < totalCost) {
-        owner_.addUIError("Not enough money");
-        return;
-    }
-
-    network::Packet packet(wireOpcode(Opcode::CMSG_REPAIR_ITEM));
-    packet.writeUInt64(vendorGuid);
-    packet.writeUInt64(0);
-    if (!isClassicLikeExpansion()) packet.writeUInt8(useGuildBank ? 1 : 0);
-    owner_.socket->send(packet);
-
-    // Only do optimistic update if we verified the player can afford it
-    if (totalCost > 0) {
-        if (!useGuildBank) {
-            owner_.playerMoneyCopper_ -= totalCost;
-        }
-        for (auto& [guid, info] : owner_.onlineItems_) {
-            if (info.maxDurability > 0 && info.curDurability < info.maxDurability) {
-                info.curDurability = info.maxDurability;
-            }
-        }
-        rebuildOnlineInventory();
-    }
-}
-
-void InventoryHandler::autoEquipItemBySlot(int backpackIndex) {
-    if (backpackIndex < 0 || backpackIndex >= owner_.inventory.getBackpackSize()) return;
-    const auto& slot = owner_.inventory.getBackpackSlot(backpackIndex);
-    if (slot.empty()) return;
-
-    if (owner_.state == WorldState::IN_WORLD && owner_.socket) {
-        auto packet = AutoEquipItemPacket::build(0xFF, static_cast<uint8_t>(Inventory::NUM_EQUIP_SLOTS + backpackIndex));
-        owner_.socket->send(packet);
-    }
-}
-
-void InventoryHandler::autoEquipItemInBag(int bagIndex, int slotIndex) {
-    if (bagIndex < 0 || bagIndex >= owner_.inventory.NUM_BAG_SLOTS) return;
-    if (slotIndex < 0 || slotIndex >= owner_.inventory.getBagSize(bagIndex)) return;
-
-    if (owner_.state == WorldState::IN_WORLD && owner_.socket) {
-        auto packet = AutoEquipItemPacket::build(
-            static_cast<uint8_t>(Inventory::FIRST_BAG_EQUIP_SLOT + bagIndex), static_cast<uint8_t>(slotIndex));
-        owner_.socket->send(packet);
-    }
-}
-
-void InventoryHandler::useItemBySlot(int backpackIndex) {
-    if (backpackIndex < 0 || backpackIndex >= owner_.inventory.getBackpackSize()) return;
-    const auto& slot = owner_.inventory.getBackpackSlot(backpackIndex);
-    if (slot.empty()) return;
-
-    uint64_t itemGuid = owner_.backpackSlotGuids_[backpackIndex];
-    if (itemGuid == 0) {
-        itemGuid = owner_.resolveOnlineItemGuid(slot.item.itemId);
-    }
-
-    if (itemGuid != 0 && owner_.state == WorldState::IN_WORLD && owner_.socket) {
-        uint32_t useSpellId = 0;
-        if (auto* info = owner_.getItemInfo(slot.item.itemId)) {
-            for (const auto& sp : info->spells) {
-                if (sp.spellId != 0 && (sp.spellTrigger == 0 || sp.spellTrigger == 5)) {
-                    useSpellId = sp.spellId;
-                    break;
-                }
-            }
-            LOG_DEBUG("useItemBySlot: entry=", slot.item.itemId,
-                      " spellId=", useSpellId);
-        }
-        auto packet = owner_.packetParsers_
-            ? owner_.packetParsers_->buildUseItem(0xFF, static_cast<uint8_t>(Inventory::NUM_EQUIP_SLOTS + backpackIndex), itemGuid, useSpellId)
-            : UseItemPacket::build(0xFF, static_cast<uint8_t>(Inventory::NUM_EQUIP_SLOTS + backpackIndex), itemGuid, useSpellId);
-        owner_.socket->send(packet);
-    } else if (itemGuid == 0) {
-        LOG_WARNING("useItemBySlot: itemGuid=0 for item='", slot.item.name,
-                    "' entry=", slot.item.itemId, " — cannot use");
-        owner_.addSystemChatMessage("Cannot use that item right now.");
-    }
-}
-
-void InventoryHandler::useItemInBag(int bagIndex, int slotIndex) {
-    if (bagIndex < 0 || bagIndex >= owner_.inventory.NUM_BAG_SLOTS) return;
-    if (slotIndex < 0 || slotIndex >= owner_.inventory.getBagSize(bagIndex)) return;
-    const auto& slot = owner_.inventory.getBagSlot(bagIndex, slotIndex);
-    if (slot.empty()) return;
-
-    uint64_t itemGuid = 0;
-    uint64_t bagGuid = owner_.equipSlotGuids_[Inventory::FIRST_BAG_EQUIP_SLOT + bagIndex];
-    if (bagGuid != 0) {
-        auto it = owner_.containerContents_.find(bagGuid);
-        if (it != owner_.containerContents_.end() && slotIndex < static_cast<int>(it->second.numSlots)) {
-            itemGuid = it->second.slotGuids[slotIndex];
-        }
-    }
-    if (itemGuid == 0) {
-        itemGuid = owner_.resolveOnlineItemGuid(slot.item.itemId);
-    }
-
-    LOG_INFO("useItemInBag: bag=", bagIndex, " slot=", slotIndex, " itemId=", slot.item.itemId,
-             " itemGuid=0x", std::hex, itemGuid, std::dec);
-
-    if (itemGuid != 0 && owner_.state == WorldState::IN_WORLD && owner_.socket) {
-        uint32_t useSpellId = 0;
-        if (auto* info = owner_.getItemInfo(slot.item.itemId)) {
-            for (const auto& sp : info->spells) {
-                if (sp.spellId != 0 && (sp.spellTrigger == 0 || sp.spellTrigger == 5)) {
-                    useSpellId = sp.spellId;
-                    break;
-                }
-            }
-        }
-        uint8_t wowBag = static_cast<uint8_t>(Inventory::FIRST_BAG_EQUIP_SLOT + bagIndex);
-        auto packet = owner_.packetParsers_
-            ? owner_.packetParsers_->buildUseItem(wowBag, static_cast<uint8_t>(slotIndex), itemGuid, useSpellId)
-            : UseItemPacket::build(wowBag, static_cast<uint8_t>(slotIndex), itemGuid, useSpellId);
-        LOG_INFO("useItemInBag: sending CMSG_USE_ITEM, bag=", (int)wowBag, " slot=", slotIndex,
-                 " packetSize=", packet.getSize());
-        owner_.socket->send(packet);
-    } else if (itemGuid == 0) {
-        LOG_WARNING("Use item in bag failed: missing item GUID for bag ", bagIndex, " slot ", slotIndex);
-        owner_.addSystemChatMessage("Cannot use that item right now.");
-    }
-}
-
-void InventoryHandler::openItemBySlot(int backpackIndex) {
-    if (backpackIndex < 0 || backpackIndex >= owner_.inventory.getBackpackSize()) return;
-    if (owner_.inventory.getBackpackSlot(backpackIndex).empty()) return;
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = OpenItemPacket::build(0xFF, static_cast<uint8_t>(Inventory::NUM_EQUIP_SLOTS + backpackIndex));
-    LOG_INFO("openItemBySlot: CMSG_OPEN_ITEM bag=0xFF slot=", (Inventory::NUM_EQUIP_SLOTS + backpackIndex));
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::openItemInBag(int bagIndex, int slotIndex) {
-    if (bagIndex < 0 || bagIndex >= owner_.inventory.NUM_BAG_SLOTS) return;
-    if (slotIndex < 0 || slotIndex >= owner_.inventory.getBagSize(bagIndex)) return;
-    if (owner_.inventory.getBagSlot(bagIndex, slotIndex).empty()) return;
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    uint8_t wowBag = static_cast<uint8_t>(Inventory::FIRST_BAG_EQUIP_SLOT + bagIndex);
-    auto packet = OpenItemPacket::build(wowBag, static_cast<uint8_t>(slotIndex));
-    LOG_INFO("openItemInBag: CMSG_OPEN_ITEM bag=", (int)wowBag, " slot=", slotIndex);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::destroyItem(uint8_t bag, uint8_t slot, uint8_t count) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    if (count == 0) count = 1;
-    constexpr uint16_t kCmsgDestroyItem = 0x111;
-    network::Packet packet(kCmsgDestroyItem);
-    packet.writeUInt8(bag);
-    packet.writeUInt8(slot);
-    packet.writeUInt32(static_cast<uint32_t>(count));
-    LOG_DEBUG("Destroy item request: bag=", (int)bag, " slot=", (int)slot,
-              " count=", (int)count, " wire=0x", std::hex, kCmsgDestroyItem, std::dec);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::splitItem(uint8_t srcBag, uint8_t srcSlot, uint8_t count) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    if (count == 0) return;
-
-    int freeBp = owner_.inventory.findFreeBackpackSlot();
-    if (freeBp >= 0) {
-        uint8_t dstBag = 0xFF;
-        uint8_t dstSlot = static_cast<uint8_t>(Inventory::NUM_EQUIP_SLOTS + freeBp);
-        LOG_INFO("splitItem: src(bag=", (int)srcBag, " slot=", (int)srcSlot,
-                 ") count=", (int)count, " -> dst(bag=0xFF slot=", (int)dstSlot, ")");
-        auto packet = SplitItemPacket::build(srcBag, srcSlot, dstBag, dstSlot, count);
-        owner_.socket->send(packet);
-        return;
-    }
-    for (int b = 0; b < owner_.inventory.NUM_BAG_SLOTS; b++) {
-        int bagSize = owner_.inventory.getBagSize(b);
-        for (int s = 0; s < bagSize; s++) {
-            if (owner_.inventory.getBagSlot(b, s).empty()) {
-                uint8_t dstBag = static_cast<uint8_t>(Inventory::FIRST_BAG_EQUIP_SLOT + b);
-                uint8_t dstSlot = static_cast<uint8_t>(s);
-                LOG_INFO("splitItem: src(bag=", (int)srcBag, " slot=", (int)srcSlot,
-                         ") count=", (int)count, " -> dst(bag=", (int)dstBag,
-                         " slot=", (int)dstSlot, ")");
-                auto packet = SplitItemPacket::build(srcBag, srcSlot, dstBag, dstSlot, count);
-                owner_.socket->send(packet);
-                return;
-            }
-        }
-    }
-    owner_.addSystemChatMessage("Cannot split: no free inventory slots.");
-}
-
-void InventoryHandler::swapContainerItems(uint8_t srcBag, uint8_t srcSlot, uint8_t dstBag, uint8_t dstSlot) {
-    if (!owner_.socket || !owner_.socket->isConnected()) return;
-    LOG_INFO("swapContainerItems: src(bag=", (int)srcBag, " slot=", (int)srcSlot,
-             ") -> dst(bag=", (int)dstBag, " slot=", (int)dstSlot, ")");
-    auto packet = SwapItemPacket::build(dstBag, dstSlot, srcBag, srcSlot);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::swapBagSlots(int srcBagIndex, int dstBagIndex) {
-    if (srcBagIndex < 0 || srcBagIndex > 3 || dstBagIndex < 0 || dstBagIndex > 3) return;
-    if (srcBagIndex == dstBagIndex) return;
-
-    auto srcEquip = static_cast<game::EquipSlot>(static_cast<int>(game::EquipSlot::BAG1) + srcBagIndex);
-    auto dstEquip = static_cast<game::EquipSlot>(static_cast<int>(game::EquipSlot::BAG1) + dstBagIndex);
-    auto srcItem = owner_.inventory.getEquipSlot(srcEquip).item;
-    auto dstItem = owner_.inventory.getEquipSlot(dstEquip).item;
-    owner_.inventory.setEquipSlot(srcEquip, dstItem);
-    owner_.inventory.setEquipSlot(dstEquip, srcItem);
-    owner_.inventory.swapBagContents(srcBagIndex, dstBagIndex);
-
-    if (owner_.socket && owner_.socket->isConnected()) {
-        uint8_t srcSlot = static_cast<uint8_t>(Inventory::FIRST_BAG_EQUIP_SLOT + srcBagIndex);
-        uint8_t dstSlot = static_cast<uint8_t>(Inventory::FIRST_BAG_EQUIP_SLOT + dstBagIndex);
-        LOG_INFO("swapBagSlots: bag ", srcBagIndex, " (slot ", (int)srcSlot,
-                 ") <-> bag ", dstBagIndex, " (slot ", (int)dstSlot, ")");
-        auto packet = SwapItemPacket::build(255, dstSlot, 255, srcSlot);
-        owner_.socket->send(packet);
-    }
-}
-
-void InventoryHandler::unequipToBackpack(EquipSlot equipSlot) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-
-    int freeSlot = owner_.inventory.findFreeBackpackSlot();
-    if (freeSlot < 0) {
-        owner_.addSystemChatMessage("Cannot unequip: no free backpack slots.");
-        return;
-    }
-
-    uint8_t srcBag = 0xFF;
-    uint8_t srcSlot = static_cast<uint8_t>(equipSlot);
-    uint8_t dstBag = 0xFF;
-    uint8_t dstSlot = static_cast<uint8_t>(Inventory::NUM_EQUIP_SLOTS + freeSlot);
-
-    LOG_INFO("UnequipToBackpack: equipSlot=", (int)srcSlot,
-             " -> backpackIndex=", freeSlot, " (dstSlot=", (int)dstSlot, ")");
-
-    auto packet = SwapItemPacket::build(dstBag, dstSlot, srcBag, srcSlot);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::useItemById(uint32_t itemId) {
-    if (itemId == 0) return;
-    LOG_DEBUG("useItemById: searching for itemId=", itemId);
-    for (int i = 0; i < owner_.inventory.getBackpackSize(); i++) {
-        const auto& slot = owner_.inventory.getBackpackSlot(i);
-        if (!slot.empty() && slot.item.itemId == itemId) {
-            LOG_DEBUG("useItemById: found itemId=", itemId, " at backpack slot ", i);
-            useItemBySlot(i);
-            return;
-        }
-    }
-    for (int bag = 0; bag < owner_.inventory.NUM_BAG_SLOTS; bag++) {
-        int bagSize = owner_.inventory.getBagSize(bag);
-        for (int slot = 0; slot < bagSize; slot++) {
-            const auto& bagSlot = owner_.inventory.getBagSlot(bag, slot);
-            if (!bagSlot.empty() && bagSlot.item.itemId == itemId) {
-                LOG_DEBUG("useItemById: found itemId=", itemId, " in bag ", bag, " slot ", slot);
-                useItemInBag(bag, slot);
-                return;
-            }
-        }
-    }
-    LOG_WARNING("useItemById: itemId=", itemId, " not found in inventory");
-}
-
-void InventoryHandler::handleListInventory(network::Packet& packet) {
-    if (!ListInventoryParser::parse(packet, currentVendorItems_)) return;
-
-    // Detect repair capability from NPC flags (covers direct vendors without gossip).
-    // UNIT_NPC_FLAG_REPAIR = 0x1000.
-    if (!currentVendorItems_.canRepair && currentVendorItems_.vendorGuid != 0) {
-        if (auto* unit = owner_.getUnitByGuid(currentVendorItems_.vendorGuid)) {
-            if (unit->getNpcFlags() & 0x1000) {
-                currentVendorItems_.canRepair = true;
-            }
-        }
-    }
-    vendorWindowOpen_ = true;
-    owner_.closeGossip();
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("MERCHANT_SHOW", {});
-
-    // Auto-sell grey items
-    if (autoSellGrey_ && currentVendorItems_.vendorGuid != 0 && owner_.state == WorldState::IN_WORLD && owner_.socket) {
-        int itemsSold = 0;
-        uint32_t totalSellPrice = 0;
-        for (int i = 0; i < owner_.inventory.getBackpackSize(); ++i) {
-            const auto& slot = owner_.inventory.getBackpackSlot(i);
-            if (slot.empty()) continue;
-            uint32_t quality = 0;
-            uint32_t sellPrice = slot.item.sellPrice;
-            if (auto* info = owner_.getItemInfo(slot.item.itemId); info && info->valid) {
-                quality = info->quality;
-                if (sellPrice == 0) sellPrice = info->sellPrice;
-            }
-            if (quality == 0 && sellPrice > 0) {
-                uint64_t itemGuid = owner_.backpackSlotGuids_[i];
-                if (itemGuid == 0) itemGuid = owner_.resolveOnlineItemGuid(slot.item.itemId);
-                if (itemGuid != 0) {
-                    sellItem(currentVendorItems_.vendorGuid, itemGuid, 1);
-                    totalSellPrice += sellPrice;
-                    ++itemsSold;
-                }
-            }
-        }
-        for (int b = 0; b < owner_.inventory.NUM_BAG_SLOTS; ++b) {
-            int bagSize = owner_.inventory.getBagSize(b);
-            for (int s = 0; s < bagSize; ++s) {
-                const auto& slot = owner_.inventory.getBagSlot(b, s);
-                if (slot.empty()) continue;
-                uint32_t quality = 0;
-                uint32_t sellPrice = slot.item.sellPrice;
-                if (auto* info = owner_.getItemInfo(slot.item.itemId); info && info->valid) {
-                    quality = info->quality;
-                    if (sellPrice == 0) sellPrice = info->sellPrice;
-                }
-                if (quality == 0 && sellPrice > 0) {
-                    uint64_t itemGuid = 0;
-                    uint64_t bagGuid = owner_.equipSlotGuids_[19 + b];
-                    if (bagGuid != 0) {
-                        auto cit = owner_.containerContents_.find(bagGuid);
-                        if (cit != owner_.containerContents_.end() && s < static_cast<int>(cit->second.numSlots))
-                            itemGuid = cit->second.slotGuids[s];
-                    }
-                    if (itemGuid == 0) itemGuid = owner_.resolveOnlineItemGuid(slot.item.itemId);
-                    if (itemGuid != 0) {
-                        sellItem(currentVendorItems_.vendorGuid, itemGuid, 1);
-                        totalSellPrice += sellPrice;
-                        ++itemsSold;
-                    }
-                }
-            }
-        }
-        if (itemsSold > 0) {
-            uint32_t gold = totalSellPrice / 10000;
-            uint32_t silver = (totalSellPrice % 10000) / 100;
-            uint32_t copper = totalSellPrice % 100;
-            char buf[128];
-            std::snprintf(buf, sizeof(buf),
-                "|cffaaaaaaAuto-sold %d grey item%s for %ug %us %uc.|r",
-                itemsSold, itemsSold == 1 ? "" : "s", gold, silver, copper);
-            owner_.addSystemChatMessage(buf);
-        }
-    }
-
-    // Auto-repair
-    if (autoRepair_ && currentVendorItems_.canRepair && currentVendorItems_.vendorGuid != 0) {
-        bool anyDamaged = false;
-        for (int i = 0; i < Inventory::NUM_EQUIP_SLOTS; ++i) {
-            const auto& slot = owner_.inventory.getEquipSlot(static_cast<EquipSlot>(i));
-            if (!slot.empty() && slot.item.maxDurability > 0
-                    && slot.item.curDurability < slot.item.maxDurability) {
-                anyDamaged = true;
-                break;
-            }
-        }
-        if (anyDamaged) {
-            repairAll(currentVendorItems_.vendorGuid, false);
-            owner_.addSystemChatMessage("|cffaaaaaaAuto-repair triggered.|r");
-        }
-    }
-
-    // Play vendor sound
-    if (owner_.npcVendorCallback_ && currentVendorItems_.vendorGuid != 0) {
-        auto entity = owner_.getEntityManager().getEntity(currentVendorItems_.vendorGuid);
-        if (entity && entity->getType() == ObjectType::UNIT) {
-            glm::vec3 pos(entity->getX(), entity->getY(), entity->getZ());
-            owner_.npcVendorCallback_(currentVendorItems_.vendorGuid, pos);
-        }
-    }
-
-    for (const auto& item : currentVendorItems_.items) {
-        owner_.queryItemInfo(item.itemId, 0);
-    }
-}
-
-// ============================================================
-// Trainer
-// ============================================================
-
-void InventoryHandler::handleTrainerList(network::Packet& packet) {
-    const bool isClassic = isClassicLikeExpansion();
-    if (!TrainerListParser::parse(packet, currentTrainerList_, isClassic)) return;
-    trainerWindowOpen_ = true;
-    owner_.closeGossip();
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("TRAINER_SHOW", {});
-
-    LOG_INFO("Trainer list: ", currentTrainerList_.spells.size(), " spells");
-
-    owner_.loadSpellNameCache();
-    owner_.loadSkillLineDbc();
-    owner_.loadSkillLineAbilityDbc();
-    categorizeTrainerSpells();
-}
-
-void InventoryHandler::trainSpell(uint32_t spellId) {
-    LOG_INFO("trainSpell called: spellId=", spellId, " state=", (int)owner_.state, " socket=", (owner_.socket ? "yes" : "no"));
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) {
-        LOG_WARNING("trainSpell: Not in world or no socket connection");
-        return;
-    }
-
-    uint32_t spellCost = 0;
-    for (const auto& spell : currentTrainerList_.spells) {
-        if (spell.spellId == spellId) {
-            spellCost = spell.spellCost;
-            break;
-        }
-    }
-    LOG_INFO("Player money: ", owner_.playerMoneyCopper_, " copper, spell cost: ", spellCost, " copper");
-
-    LOG_INFO("Sending CMSG_TRAINER_BUY_SPELL: guid=", currentTrainerList_.trainerGuid,
-             " spellId=", spellId);
-    auto packet = TrainerBuySpellPacket::build(
-        currentTrainerList_.trainerGuid,
-        spellId);
-    owner_.socket->send(packet);
-    LOG_INFO("CMSG_TRAINER_BUY_SPELL sent");
-}
-
-void InventoryHandler::closeTrainer() {
-    trainerWindowOpen_ = false;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("TRAINER_CLOSED", {});
-    currentTrainerList_ = TrainerListData{};
-    trainerTabs_.clear();
-}
-
-void InventoryHandler::categorizeTrainerSpells() {
-    trainerTabs_.clear();
-
-    static constexpr uint32_t SKILLLINE_CATEGORY_CLASS = 7;
-
-    std::map<uint32_t, std::vector<const TrainerSpell*>> specialtySpells;
-    std::vector<const TrainerSpell*> generalSpells;
-
-    for (const auto& spell : currentTrainerList_.spells) {
-        auto slIt = owner_.spellToSkillLine_.find(spell.spellId);
-        if (slIt != owner_.spellToSkillLine_.end()) {
-            uint32_t skillLineId = slIt->second;
-            auto catIt = owner_.skillLineCategories_.find(skillLineId);
-            if (catIt != owner_.skillLineCategories_.end() && catIt->second == SKILLLINE_CATEGORY_CLASS) {
-                specialtySpells[skillLineId].push_back(&spell);
-                continue;
-            }
-        }
-        generalSpells.push_back(&spell);
-    }
-
-    auto byName = [this](const TrainerSpell* a, const TrainerSpell* b) {
-        return owner_.getSpellName(a->spellId) < owner_.getSpellName(b->spellId);
-    };
-
-    std::vector<std::pair<std::string, std::vector<const TrainerSpell*>>> named;
-    for (auto& [skillLineId, spells] : specialtySpells) {
-        auto nameIt = owner_.skillLineNames_.find(skillLineId);
-        std::string tabName = (nameIt != owner_.skillLineNames_.end()) ? nameIt->second : "Specialty";
-        std::sort(spells.begin(), spells.end(), byName);
-        named.push_back({std::move(tabName), std::move(spells)});
-    }
-    std::sort(named.begin(), named.end(),
-        [](const auto& a, const auto& b) { return a.first < b.first; });
-
-    for (auto& [name, spells] : named) {
-        trainerTabs_.push_back({std::move(name), std::move(spells)});
-    }
-
-    if (!generalSpells.empty()) {
-        std::sort(generalSpells.begin(), generalSpells.end(), byName);
-        trainerTabs_.push_back({"General", std::move(generalSpells)});
-    }
-
-    LOG_INFO("Trainer: Categorized into ", trainerTabs_.size(), " tabs");
-}
-
-// ============================================================
-// Mail
-// ============================================================
-
-void InventoryHandler::openMailbox(uint64_t guid) {
-    mailboxGuid_ = guid;
-    mailboxOpen_ = true;
-    hasNewMail_ = false;
-    selectedMailIndex_ = -1;
-    showMailCompose_ = false;
-    clearMailAttachments();
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("MAIL_SHOW", {});
-    refreshMailList();
-}
-
-void InventoryHandler::closeMailbox() {
-    mailboxOpen_ = false;
-    mailboxGuid_ = 0;
-    showMailCompose_ = false;
-    clearMailAttachments();
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("MAIL_CLOSED", {});
-}
-
-void InventoryHandler::refreshMailList() {
-    if (!mailboxOpen_ || mailboxGuid_ == 0) return;
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = GetMailListPacket::build(mailboxGuid_);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::sendMail(const std::string& recipient, const std::string& subject,
-                                const std::string& body, uint64_t money, uint64_t cod) {
-    if (owner_.state != WorldState::IN_WORLD) {
-        LOG_WARNING("sendMail: not in world");
-        return;
-    }
-    if (!owner_.socket) {
-        LOG_WARNING("sendMail: no socket");
-        return;
-    }
-    if (mailboxGuid_ == 0) {
-        LOG_WARNING("sendMail: mailboxGuid_ is 0 (mailbox closed?)");
-        return;
-    }
-    // Collect attached item GUIDs
-    std::vector<uint64_t> itemGuids;
-    for (const auto& att : mailAttachments_) {
-        if (att.occupied()) {
-            itemGuids.push_back(att.itemGuid);
-        }
-    }
-    auto packet = owner_.packetParsers_->buildSendMail(mailboxGuid_, recipient, subject, body, money, cod, itemGuids);
-    LOG_INFO("sendMail: to='", recipient, "' subject='", subject, "' money=", money,
-             " attachments=", itemGuids.size(), " mailboxGuid=", mailboxGuid_);
-    owner_.socket->send(packet);
-    clearMailAttachments();
-}
-
-bool InventoryHandler::attachItemFromBackpack(int backpackIndex) {
-    if (backpackIndex < 0 || backpackIndex >= owner_.inventory.getBackpackSize()) return false;
-    const auto& slot = owner_.inventory.getBackpackSlot(backpackIndex);
-    if (slot.empty()) return false;
-    uint64_t itemGuid = owner_.backpackSlotGuids_[backpackIndex];
-    if (itemGuid == 0) return false;
-    for (int i = 0; i < MAIL_MAX_ATTACHMENTS; ++i) {
-        if (!mailAttachments_[i].occupied()) {
-            mailAttachments_[i].itemGuid = itemGuid;
-            mailAttachments_[i].item = slot.item;
-            mailAttachments_[i].srcBag = 0xFF;
-            mailAttachments_[i].srcSlot = static_cast<uint8_t>(Inventory::NUM_EQUIP_SLOTS + backpackIndex);
-            return true;
-        }
-    }
-    return false;
-}
-
-bool InventoryHandler::attachItemFromBag(int bagIndex, int slotIndex) {
-    if (bagIndex < 0 || bagIndex >= owner_.inventory.NUM_BAG_SLOTS) return false;
-    if (slotIndex < 0 || slotIndex >= owner_.inventory.getBagSize(bagIndex)) return false;
-    const auto& slot = owner_.inventory.getBagSlot(bagIndex, slotIndex);
-    if (slot.empty()) return false;
-    uint64_t bagGuid = owner_.equipSlotGuids_[Inventory::FIRST_BAG_EQUIP_SLOT + bagIndex];
-    if (bagGuid == 0) return false;
-    auto it = owner_.containerContents_.find(bagGuid);
-    if (it == owner_.containerContents_.end()) return false;
-    if (slotIndex >= static_cast<int>(it->second.numSlots)) return false;
-    uint64_t itemGuid = it->second.slotGuids[slotIndex];
-    if (itemGuid == 0) return false;
-    for (int i = 0; i < MAIL_MAX_ATTACHMENTS; ++i) {
-        if (!mailAttachments_[i].occupied()) {
-            mailAttachments_[i].itemGuid = itemGuid;
-            mailAttachments_[i].item = slot.item;
-            mailAttachments_[i].srcBag = static_cast<uint8_t>(Inventory::FIRST_BAG_EQUIP_SLOT + bagIndex);
-            mailAttachments_[i].srcSlot = static_cast<uint8_t>(slotIndex);
-            return true;
-        }
-    }
-    return false;
-}
-
-bool InventoryHandler::detachMailAttachment(int attachIndex) {
-    if (attachIndex < 0 || attachIndex >= MAIL_MAX_ATTACHMENTS) return false;
-    mailAttachments_[attachIndex] = MailAttachSlot{};
-    return true;
-}
-
-void InventoryHandler::clearMailAttachments() {
-    for (auto& a : mailAttachments_) a = MailAttachSlot{};
-}
-
-int InventoryHandler::getMailAttachmentCount() const {
-    int count = 0;
-    for (const auto& a : mailAttachments_)
-        if (a.occupied()) ++count;
-    return count;
-}
-
-void InventoryHandler::mailTakeMoney(uint32_t mailId) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || mailboxGuid_ == 0) return;
-    auto packet = MailTakeMoneyPacket::build(mailboxGuid_, mailId);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::mailTakeItem(uint32_t mailId, uint32_t itemGuidLow) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || mailboxGuid_ == 0) return;
-    auto packet = MailTakeItemPacket::build(mailboxGuid_, mailId, itemGuidLow);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::mailDelete(uint32_t mailId) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || mailboxGuid_ == 0) return;
-    auto packet = MailDeletePacket::build(mailboxGuid_, mailId, 0);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::mailMarkAsRead(uint32_t mailId) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || mailboxGuid_ == 0) return;
-    auto packet = MailMarkAsReadPacket::build(mailboxGuid_, mailId);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::handleShowMailbox(network::Packet& packet) {
-    if (!packet.hasRemaining(8)) return;
-    mailboxGuid_ = packet.readUInt64();
-    mailboxOpen_ = true;
-    selectedMailIndex_ = -1;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("MAIL_SHOW", {});
-    refreshMailList();
-}
-
-void InventoryHandler::handleMailListResult(network::Packet& packet) {
-    if (!owner_.packetParsers_->parseMailList(packet, mailInbox_)) return;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("MAIL_INBOX_UPDATE", {});
-    for (const auto& mail : mailInbox_) {
-        for (const auto& att : mail.attachments) {
-            if (att.itemId != 0) owner_.ensureItemInfo(att.itemId);
-        }
-    }
-}
-
-void InventoryHandler::handleSendMailResult(network::Packet& packet) {
-    if (!packet.hasRemaining(12)) return;
-    uint32_t mailId = packet.readUInt32();
-    uint32_t action = packet.readUInt32();
-    uint32_t error  = packet.readUInt32();
-    (void)mailId;
-    if (action == 0) { // SEND
-        if (error == 0) {
-            owner_.addSystemChatMessage("Mail sent.");
-            clearMailAttachments();
-            showMailCompose_ = false;
-        } else {
-            owner_.addSystemChatMessage("Failed to send mail (error " + std::to_string(error) + ").");
-        }
-    } else if (action == 4) { // TAKE_ITEM
-        if (error == 0) {
-            owner_.addSystemChatMessage("Item taken from mail.");
-            if (owner_.addonEventCallback_) owner_.addonEventCallback_("BAG_UPDATE", {});
-        } else {
-            owner_.addSystemChatMessage("Failed to take item (error " + std::to_string(error) + ").");
-        }
-    } else if (action == 5) { // TAKE_MONEY
-        if (error == 0) {
-            owner_.addSystemChatMessage("Money taken from mail.");
-            if (owner_.addonEventCallback_) owner_.addonEventCallback_("PLAYER_MONEY", {});
-        }
-    } else if (action == 2) { // DELETE
-        if (error == 0) {
-            owner_.addSystemChatMessage("Mail deleted.");
-        }
-    }
-    refreshMailList();
-}
-
-void InventoryHandler::handleReceivedMail(network::Packet& packet) {
-    (void)packet;
-    hasNewMail_ = true;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("UPDATE_PENDING_MAIL", {});
-}
-
-void InventoryHandler::handleQueryNextMailTime(network::Packet& packet) {
-    if (!packet.hasRemaining(8)) return;
-    // readFloat() uses memcpy internally, avoiding the strict aliasing violation
-    // that the previous reinterpret_cast<float*> on raw packet bytes had.
-    float nextTime = packet.readFloat();
-    uint32_t count = packet.readUInt32();
-    hasNewMail_ = (nextTime >= 0.0f && count > 0);
-    packet.skipAll();
-}
-
-// ============================================================
-// Bank
-// ============================================================
-
-void InventoryHandler::openBank(uint64_t guid) {
-    bankerGuid_ = guid;
-    bankOpen_ = true;
-    if (isClassicLikeExpansion()) {
-        effectiveBankSlots_ = 24;
-        effectiveBankBagSlots_ = 6;
-    } else {
-        effectiveBankSlots_ = 28;
-        effectiveBankBagSlots_ = 7;
-    }
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("BANKFRAME_OPENED", {});
-}
-
-void InventoryHandler::closeBank() {
-    bankOpen_ = false;
-    bankerGuid_ = 0;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("BANKFRAME_CLOSED", {});
-}
-
-void InventoryHandler::buyBankSlot() {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || bankerGuid_ == 0) return;
-    auto packet = BuyBankSlotPacket::build(bankerGuid_);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::depositItem(uint8_t srcBag, uint8_t srcSlot) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    int freeBankSlot = -1;
-    for (int i = 0; i < effectiveBankSlots_; ++i) {
-        if (bankSlotGuids_[i] == 0) { freeBankSlot = i; break; }
-    }
-    if (freeBankSlot < 0) {
-        owner_.addSystemChatMessage("Bank is full.");
-        return;
-    }
-    uint8_t dstSlot = static_cast<uint8_t>(39 + freeBankSlot);
-    auto packet = SwapItemPacket::build(0xFF, dstSlot, srcBag, srcSlot);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::withdrawItem(uint8_t srcBag, uint8_t srcSlot) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    int freeSlot = owner_.inventory.findFreeBackpackSlot();
-    if (freeSlot < 0) {
-        owner_.addSystemChatMessage("Inventory is full.");
-        return;
-    }
-    uint8_t dstSlot = static_cast<uint8_t>(Inventory::NUM_EQUIP_SLOTS + freeSlot);
-    auto packet = SwapItemPacket::build(0xFF, dstSlot, srcBag, srcSlot);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::handleShowBank(network::Packet& packet) {
-    if (!packet.hasRemaining(8)) return;
-    uint64_t guid = packet.readUInt64();
-    openBank(guid);
-}
-
-void InventoryHandler::handleBuyBankSlotResult(network::Packet& packet) {
-    if (!packet.hasRemaining(4)) return;
-    uint32_t result = packet.readUInt32();
-    if (result == 0) {
-        owner_.addSystemChatMessage("Bank slot purchased.");
-        if (owner_.addonEventCallback_) owner_.addonEventCallback_("PLAYERBANKBAGSLOTS_CHANGED", {});
-    } else {
-        owner_.addSystemChatMessage("Failed to purchase bank slot.");
-    }
-}
-
-// ============================================================
-// Guild Bank
-// ============================================================
-
-void InventoryHandler::openGuildBank(uint64_t guid) {
-    guildBankerGuid_ = guid;
-    guildBankOpen_ = true;
-    guildBankActiveTab_ = 0;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("GUILDBANKFRAME_OPENED", {});
-    queryGuildBankTab(0);
-}
-
-void InventoryHandler::closeGuildBank() {
-    guildBankOpen_ = false;
-    guildBankerGuid_ = 0;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("GUILDBANKFRAME_CLOSED", {});
-}
-
-void InventoryHandler::queryGuildBankTab(uint8_t tabId) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || guildBankerGuid_ == 0) return;
-    auto packet = GuildBankQueryTabPacket::build(guildBankerGuid_, tabId, false);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::buyGuildBankTab() {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || guildBankerGuid_ == 0) return;
-    uint8_t nextTab = static_cast<uint8_t>(guildBankData_.tabs.size());
-    auto packet = GuildBankBuyTabPacket::build(guildBankerGuid_, nextTab);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::depositGuildBankMoney(uint32_t amount) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || guildBankerGuid_ == 0) return;
-    auto packet = GuildBankDepositMoneyPacket::build(guildBankerGuid_, amount);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::withdrawGuildBankMoney(uint32_t amount) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || guildBankerGuid_ == 0) return;
-    auto packet = GuildBankWithdrawMoneyPacket::build(guildBankerGuid_, amount);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::guildBankWithdrawItem(uint8_t tabId, uint8_t bankSlot, uint8_t destBag, uint8_t destSlot) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || guildBankerGuid_ == 0) return;
-    auto packet = GuildBankSwapItemsPacket::buildBankToInventory(guildBankerGuid_, tabId, bankSlot, destBag, destSlot);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::guildBankDepositItem(uint8_t tabId, uint8_t bankSlot, uint8_t srcBag, uint8_t srcSlot) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || guildBankerGuid_ == 0) return;
-    auto packet = GuildBankSwapItemsPacket::buildInventoryToBank(guildBankerGuid_, tabId, bankSlot, srcBag, srcSlot);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::handleGuildBankList(network::Packet& packet) {
-    if (!GuildBankListParser::parse(packet, guildBankData_)) return;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("GUILDBANKBAGSLOTS_CHANGED", {});
-    for (const auto& tab : guildBankData_.tabs) {
-        for (const auto& item : tab.items) {
-            if (item.itemEntry != 0) owner_.ensureItemInfo(item.itemEntry);
-        }
-    }
-}
-
-// ============================================================
-// Auction House
-// ============================================================
-
-void InventoryHandler::openAuctionHouse(uint64_t guid) {
-    auctioneerGuid_ = guid;
-    auctionOpen_ = true;
-    auctionActiveTab_ = 0;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("AUCTION_HOUSE_SHOW", {});
-}
-
-void InventoryHandler::closeAuctionHouse() {
-    auctionOpen_ = false;
-    auctioneerGuid_ = 0;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("AUCTION_HOUSE_CLOSED", {});
-}
-
-void InventoryHandler::auctionSearch(const std::string& name, uint8_t levelMin, uint8_t levelMax,
-                                      uint32_t quality, uint32_t itemClass, uint32_t itemSubClass,
-                                      uint32_t invTypeMask, uint8_t usableOnly, uint32_t offset) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || auctioneerGuid_ == 0) return;
-    lastAuctionSearch_ = {name, levelMin, levelMax, quality, itemClass, itemSubClass, invTypeMask, usableOnly, offset};
-    hasAuctionSearch_ = true;
-    pendingAuctionTarget_ = AuctionResultTarget::BROWSE;
-    auto packet = AuctionListItemsPacket::build(auctioneerGuid_, offset, name,
-                                                  levelMin, levelMax, invTypeMask,
-                                                  itemClass, itemSubClass, quality, usableOnly, 0);
-    owner_.socket->send(packet);
-    auctionSearchDelayTimer_ = 5.0f;
-}
-
-void InventoryHandler::auctionSellItem(int backpackIndex, uint32_t bid,
-                                        uint32_t buyout, uint32_t duration) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || auctioneerGuid_ == 0) return;
-    if (backpackIndex < 0 || backpackIndex >= owner_.inventory.getBackpackSize()) return;
-    const auto& slot = owner_.inventory.getBackpackSlot(backpackIndex);
-    if (slot.empty()) return;
-
-    uint64_t itemGuid = owner_.backpackSlotGuids_[backpackIndex];
-    if (itemGuid == 0) {
-        itemGuid = owner_.resolveOnlineItemGuid(slot.item.itemId);
-    }
-    if (itemGuid == 0) {
-        LOG_ERROR("auctionSellItem: could not resolve GUID for backpack slot ", backpackIndex);
-        return;
-    }
-
-    uint32_t stackCount = slot.item.stackCount;
-    auto packet = AuctionSellItemPacket::build(auctioneerGuid_, itemGuid, stackCount, bid, buyout, duration,
-                                                isPreWotlk());
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::auctionPlaceBid(uint32_t auctionId, uint32_t amount) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || auctioneerGuid_ == 0) return;
-    auto packet = AuctionPlaceBidPacket::build(auctioneerGuid_, auctionId, amount);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::auctionBuyout(uint32_t auctionId, uint32_t buyoutPrice) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || auctioneerGuid_ == 0) return;
-    auto packet = AuctionPlaceBidPacket::build(auctioneerGuid_, auctionId, buyoutPrice);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::auctionCancelItem(uint32_t auctionId) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || auctioneerGuid_ == 0) return;
-    auto packet = AuctionRemoveItemPacket::build(auctioneerGuid_, auctionId);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::auctionListOwnerItems(uint32_t offset) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || auctioneerGuid_ == 0) return;
-    pendingAuctionTarget_ = AuctionResultTarget::OWNER;
-    auto packet = AuctionListOwnerItemsPacket::build(auctioneerGuid_, offset);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::auctionListBidderItems(uint32_t offset) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || auctioneerGuid_ == 0) return;
-    pendingAuctionTarget_ = AuctionResultTarget::BIDDER;
-    auto packet = AuctionListBidderItemsPacket::build(auctioneerGuid_, offset);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::handleAuctionHello(network::Packet& packet) {
-    if (!packet.hasRemaining(12)) return;
-    uint64_t guid = packet.readUInt64();
-    uint32_t houseId = packet.readUInt32();
-    auctioneerGuid_ = guid;
-    auctionHouseId_ = houseId;
-    auctionOpen_ = true;
-    auctionActiveTab_ = 0;
-    owner_.closeGossip();
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("AUCTION_HOUSE_SHOW", {});
-}
-
-void InventoryHandler::handleAuctionListResult(network::Packet& packet) {
-    AuctionListResult result;
-    if (!AuctionListResultParser::parse(packet, result)) return;
-
-    if (pendingAuctionTarget_ == AuctionResultTarget::OWNER) {
-        auctionOwnerResults_ = std::move(result);
-        if (owner_.addonEventCallback_) owner_.addonEventCallback_("AUCTION_OWNED_LIST_UPDATE", {});
-    } else if (pendingAuctionTarget_ == AuctionResultTarget::BIDDER) {
-        auctionBidderResults_ = std::move(result);
-        if (owner_.addonEventCallback_) owner_.addonEventCallback_("AUCTION_BIDDER_LIST_UPDATE", {});
-    } else {
-        auctionBrowseResults_ = std::move(result);
-        if (owner_.addonEventCallback_) owner_.addonEventCallback_("AUCTION_ITEM_LIST_UPDATE", {});
-    }
-
-    // Ensure item info for all entries
-    auto ensureEntries = [this](const AuctionListResult& r) {
-        for (const auto& e : r.auctions) {
-            owner_.ensureItemInfo(e.itemEntry);
-        }
-    };
-    if (pendingAuctionTarget_ == AuctionResultTarget::OWNER) ensureEntries(auctionOwnerResults_);
-    else if (pendingAuctionTarget_ == AuctionResultTarget::BIDDER) ensureEntries(auctionBidderResults_);
-    else ensureEntries(auctionBrowseResults_);
-}
-
-void InventoryHandler::handleAuctionOwnerListResult(network::Packet& packet) {
-    pendingAuctionTarget_ = AuctionResultTarget::OWNER;
-    handleAuctionListResult(packet);
-}
-
-void InventoryHandler::handleAuctionBidderListResult(network::Packet& packet) {
-    pendingAuctionTarget_ = AuctionResultTarget::BIDDER;
-    handleAuctionListResult(packet);
-}
-
-void InventoryHandler::handleAuctionCommandResult(network::Packet& packet) {
-    if (!packet.hasRemaining(12)) return;
-    uint32_t auctionId = packet.readUInt32();
-    uint32_t action = packet.readUInt32();
-    uint32_t error  = packet.readUInt32();
-    (void)auctionId;
-
-    const char* actionNames[] = {"sell", "cancel", "bid/buyout"};
-    const char* actionStr = (action < 3) ? actionNames[action] : "unknown";
-
-    if (error == 0) {
-        std::string msg = std::string("Auction ") + actionStr + " successful.";
-        owner_.addSystemChatMessage(msg);
-        if (owner_.addonEventCallback_) {
-            owner_.addonEventCallback_("PLAYER_MONEY", {});
-            owner_.addonEventCallback_("BAG_UPDATE", {});
-        }
-        // Re-query after successful buy/bid so the list reflects the change.
-        // Previously gated on name.length()>0 which skipped browse-all (empty name).
-        if (action == 2 && hasAuctionSearch_) {
-            auctionSearch(lastAuctionSearch_.name, lastAuctionSearch_.levelMin, lastAuctionSearch_.levelMax,
-                         lastAuctionSearch_.quality, lastAuctionSearch_.itemClass, lastAuctionSearch_.itemSubClass,
-                         lastAuctionSearch_.invTypeMask, lastAuctionSearch_.usableOnly, lastAuctionSearch_.offset);
-        }
-    } else {
-        const char* errMsg = "Unknown error.";
-        switch (error) {
-            case 1: errMsg = "Not enough money."; break;
-            case 2: errMsg = "Item not found."; break;
-            case 5: errMsg = "Bid too low."; break;
-            case 6: errMsg = "Bid increment too low."; break;
-            case 7: errMsg = "You cannot bid on your own auction."; break;
-            case 8: errMsg = "Database error."; break;
-            default: break;
-        }
-        owner_.addUIError(std::string("Auction ") + actionStr + " failed: " + errMsg);
-        owner_.addSystemChatMessage(std::string("Auction ") + actionStr + " failed: " + errMsg);
-    }
-}
-
-// ============================================================
-// Item Text
-// ============================================================
-
-void InventoryHandler::queryItemText(uint64_t itemGuid) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_ITEM_TEXT_QUERY));
-    pkt.writeUInt64(itemGuid);
-    owner_.socket->send(pkt);
-}
-
-void InventoryHandler::handleItemTextQueryResponse(network::Packet& packet) {
-    if (!packet.hasRemaining(1)) return;
-    std::string text = packet.readString();
-    if (!text.empty()) {
-        itemText_ = std::move(text);
-        itemTextOpen_ = true;
-    }
-}
-
-// ============================================================
-// Trade
-// ============================================================
-
-void InventoryHandler::acceptTradeRequest() {
-    if (tradeStatus_ != TradeStatus::PendingIncoming) return;
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = BeginTradePacket::build();
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::declineTradeRequest() {
-    if (tradeStatus_ != TradeStatus::PendingIncoming) return;
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = CancelTradePacket::build();
-    owner_.socket->send(packet);
-    resetTradeState();
-}
-
-void InventoryHandler::acceptTrade() {
-    if (tradeStatus_ != TradeStatus::Open) return;
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = AcceptTradePacket::build();
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::cancelTrade() {
-    if (tradeStatus_ == TradeStatus::None) return;
-    if (owner_.state == WorldState::IN_WORLD && owner_.socket) {
-        auto packet = CancelTradePacket::build();
-        owner_.socket->send(packet);
-    }
-    resetTradeState();
-}
-
-void InventoryHandler::setTradeItem(uint8_t tradeSlot, uint8_t srcBag, uint8_t srcSlot) {
-    if (tradeStatus_ != TradeStatus::Open) return;
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = SetTradeItemPacket::build(tradeSlot, srcBag, srcSlot);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::clearTradeItem(uint8_t tradeSlot) {
-    if (tradeStatus_ != TradeStatus::Open) return;
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = ClearTradeItemPacket::build(tradeSlot);
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::setTradeGold(uint64_t amount) {
-    if (tradeStatus_ != TradeStatus::Open) return;
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = SetTradeGoldPacket::build(static_cast<uint32_t>(amount));
-    owner_.socket->send(packet);
-}
-
-void InventoryHandler::resetTradeState() {
-    tradeStatus_ = TradeStatus::None;
-    tradePeerGuid_ = 0;
-    tradePeerName_.clear();
-    myTradeSlots_ = {};
-    peerTradeSlots_ = {};
-    myTradeGold_ = 0;
-    peerTradeGold_ = 0;
-}
-
-void InventoryHandler::handleTradeStatus(network::Packet& packet) {
-    if (!packet.hasRemaining(4)) return;
-    uint32_t status = packet.readUInt32();
-    LOG_WARNING("SMSG_TRADE_STATUS: status=", status, " size=", packet.getSize());
-    switch (status) {
-        case 0: // TRADE_STATUS_PLAYER_BUSY
-            resetTradeState();
-            owner_.addSystemChatMessage("Trade failed: player is busy.");
-            break;
-        case 1: { // TRADE_STATUS_PROPOSED
-            if (packet.hasRemaining(8))
-                tradePeerGuid_ = packet.readUInt64();
-            tradeStatus_ = TradeStatus::PendingIncoming;
-            // Resolve name
-            auto nit = owner_.getPlayerNameCache().find(tradePeerGuid_);
-            if (nit != owner_.getPlayerNameCache().end()) tradePeerName_ = nit->second;
-            else tradePeerName_ = "Unknown";
-            owner_.addSystemChatMessage(tradePeerName_ + " wants to trade with you.");
-            if (owner_.addonEventCallback_) owner_.addonEventCallback_("TRADE_REQUEST", {tradePeerName_});
-            break;
-        }
-        case 2: // TRADE_STATUS_INITIATED
-            tradeStatus_ = TradeStatus::Open;
-            owner_.addSystemChatMessage("Trade opened.");
-            if (owner_.addonEventCallback_) owner_.addonEventCallback_("TRADE_SHOW", {});
-            break;
-        case 3: // TRADE_STATUS_CANCELLED
-            resetTradeState();
-            owner_.addSystemChatMessage("Trade cancelled.");
-            if (owner_.addonEventCallback_) owner_.addonEventCallback_("TRADE_CLOSED", {});
-            break;
-        case 4: // TRADE_STATUS_ACCEPTED
-            tradeStatus_ = TradeStatus::Accepted;
-            owner_.addSystemChatMessage("Trade partner accepted.");
-            if (owner_.addonEventCallback_) owner_.addonEventCallback_("TRADE_ACCEPT_UPDATE", {});
-            break;
-        case 5: // TRADE_STATUS_ALREADY_TRADING
-            owner_.addSystemChatMessage("You are already trading.");
-            break;
-        case 7: // TRADE_STATUS_COMPLETE
-            // Don't reset immediately — TRADE_STATUS_EXTENDED may arrive in the same
-            // packet batch and needs the trade state to store final item/gold data.
-            tradeStatus_ = TradeStatus::None;
-            owner_.addSystemChatMessage("Trade complete.");
-            if (owner_.addonEventCallback_) {
-                owner_.addonEventCallback_("TRADE_CLOSED", {});
-                owner_.addonEventCallback_("BAG_UPDATE", {});
-                owner_.addonEventCallback_("PLAYER_MONEY", {});
-            }
-            break;
-        case 9: // TRADE_STATUS_TARGET_TO_FAR
-            resetTradeState();
-            owner_.addSystemChatMessage("Trade failed: target is too far away.");
-            break;
-        case 13: // TRADE_STATUS_FAILED
-            resetTradeState();
-            owner_.addSystemChatMessage("Trade failed.");
-            if (owner_.addonEventCallback_) owner_.addonEventCallback_("TRADE_CLOSED", {});
-            break;
-        case 8: // TRADE_STATUS_UNACCEPT
-            tradeStatus_ = TradeStatus::Open;
-            if (owner_.addonEventCallback_) owner_.addonEventCallback_("TRADE_ACCEPT_UPDATE", {});
-            break;
-        case 17: // TRADE_STATUS_PETITION
-            owner_.addSystemChatMessage("You cannot trade while petition is active.");
-            break;
-        case 18: // TRADE_STATUS_PLAYER_IGNORED
-            owner_.addSystemChatMessage("That player is ignoring you.");
-            break;
-        default:
-            LOG_DEBUG("Unhandled SMSG_TRADE_STATUS: ", status);
-            break;
-    }
-}
-
-void InventoryHandler::handleTradeStatusExtended(network::Packet& packet) {
-    LOG_WARNING("SMSG_TRADE_STATUS_EXTENDED: size=", packet.getSize(),
-                " readPos=", packet.getReadPos());
-    // WotLK format: whichPlayer(4) + tradeCount(4) + N items × (slot(1)+64bytes) + gold(4)
-    // Total for empty trade: 8 + 8×65 + 4 = 532 (matches observed packet size)
-    if (!packet.hasRemaining(8)) return;
-    uint32_t whichPlayer = packet.readUInt32();   // 0=self, 1=peer (uint32 not uint8!)
-    uint32_t tradeCount = packet.readUInt32();
-    auto& slots = (whichPlayer == 0) ? myTradeSlots_ : peerTradeSlots_;
-    if (tradeCount > 8) tradeCount = 8;  // 7 trade slots + 1 "will not be traded" slot
-    LOG_WARNING("  whichPlayer=", whichPlayer, " tradeCount=", tradeCount);
-
-    for (uint32_t i = 0; i < tradeCount; ++i) {
-        if (!packet.hasRemaining(1)) break;
-        uint8_t slotNum = packet.readUInt8();
-        // Per-slot: 4(item)+4(display)+4(stack)+4(wrapped)+8(creator)
-        //           +4(enchant)+3×4(gems)+4(maxDur)+4(dur)+4(spellCharges)
-        //           +4(suffixFactor)+4(randomPropId)+4(lockId) = 64 bytes
-        if (!packet.hasRemaining(64)) { packet.skipAll(); return; }
-        uint32_t itemId    = packet.readUInt32();
-        uint32_t displayId = packet.readUInt32();
-        uint32_t stackCnt  = packet.readUInt32();
-        /*uint32_t wrapped =*/ packet.readUInt32();
-        /*uint64_t giftCreator =*/ packet.readUInt64();
-        /*uint32_t enchant =*/ packet.readUInt32();
-        for (int g = 0; g < 3; ++g) packet.readUInt32(); // socket enchant IDs
-        /*uint32_t maxDur =*/ packet.readUInt32();
-        /*uint32_t curDur =*/ packet.readUInt32();
-        /*uint32_t spellCharges =*/ packet.readUInt32();
-        /*uint32_t suffixFactor =*/ packet.readUInt32();
-        /*uint32_t randomPropId =*/ packet.readUInt32();
-        /*uint32_t lockId =*/ packet.readUInt32();
-
-        if (slotNum < TRADE_SLOT_COUNT) {
-            slots[slotNum].itemId = itemId;
-            slots[slotNum].displayId = displayId;
-            slots[slotNum].stackCount = stackCnt;
-        }
-        if (itemId != 0) owner_.ensureItemInfo(itemId);
-    }
-
-    // Gold
-    if (packet.hasRemaining(4)) {
-        uint32_t gold = packet.readUInt32();
-        if (whichPlayer == 0) myTradeGold_ = gold;
-        else peerTradeGold_ = gold;
-    }
-
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("TRADE_UPDATE", {});
-}
-
-// ============================================================
-// Equipment Sets
-// ============================================================
-
-bool InventoryHandler::supportsEquipmentSets() const {
-    return isActiveExpansion("wotlk");
-}
-
-void InventoryHandler::useEquipmentSet(uint32_t setId) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    uint16_t wire = wireOpcode(Opcode::CMSG_EQUIPMENT_SET_USE);
-    if (wire == 0xFFFF) { owner_.addUIError("Equipment sets not supported."); return; }
-    const EquipmentSet* es = nullptr;
-    for (const auto& s : equipmentSets_) {
-        if (s.setId == setId) { es = &s; break; }
-    }
-    if (!es) {
-        owner_.addSystemChatMessage("Equipment set not found.");
-        return;
-    }
-    network::Packet pkt(wire);
-    for (int slot = 0; slot < 19; ++slot) {
-        uint64_t itemGuid = es->itemGuids[slot];
-        pkt.writePackedGuid(itemGuid);
-        uint8_t srcBag = 0xFF;
-        uint8_t srcSlot = 0;
-        if (itemGuid != 0) {
-            bool found = false;
-            for (int eq = 0; eq < 19 && !found; ++eq) {
-                if (owner_.getEquipSlotGuid(eq) == itemGuid) {
-                    srcBag = 0xFF;
-                    srcSlot = static_cast<uint8_t>(eq);
-                    found = true;
-                }
-            }
-            for (int bp = 0; bp < 16 && !found; ++bp) {
-                if (owner_.getBackpackItemGuid(bp) == itemGuid) {
-                    srcBag = 0xFF;
-                    srcSlot = static_cast<uint8_t>(Inventory::NUM_EQUIP_SLOTS + bp);
-                    found = true;
-                }
-            }
-            for (int bag = 0; bag < 4 && !found; ++bag) {
-                int bagSize = owner_.inventory.getBagSize(bag);
-                for (int s = 0; s < bagSize && !found; ++s) {
-                    if (owner_.getBagItemGuid(bag, s) == itemGuid) {
-                        srcBag = static_cast<uint8_t>(Inventory::FIRST_BAG_EQUIP_SLOT + bag);
-                        srcSlot = static_cast<uint8_t>(s);
-                        found = true;
-                    }
-                }
-            }
-        }
-        pkt.writeUInt8(srcBag);
-        pkt.writeUInt8(srcSlot);
-    }
-    owner_.socket->send(pkt);
-}
-
-void InventoryHandler::saveEquipmentSet(const std::string& name, const std::string& iconName,
-                                         uint64_t existingGuid, uint32_t setIndex) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    uint16_t wire = wireOpcode(Opcode::CMSG_EQUIPMENT_SET_SAVE);
-    if (wire == 0xFFFF) { owner_.addUIError("Equipment sets not supported."); return; }
-    pendingSaveSetName_ = name;
-    pendingSaveSetIcon_ = iconName;
-    if (setIndex == 0xFFFFFFFF) {
-        setIndex = 0;
-        for (const auto& es : equipmentSets_) {
-            if (es.setId >= setIndex) setIndex = es.setId + 1;
-        }
-    }
-    network::Packet pkt(wire);
-    pkt.writeUInt64(existingGuid);
-    pkt.writeUInt32(setIndex);
-    pkt.writeString(name);
-    pkt.writeString(iconName);
-    for (int i = 0; i < 19; ++i) {
-        pkt.writePackedGuid(owner_.getEquipSlotGuid(i));
-    }
-    owner_.socket->send(pkt);
-}
-
-void InventoryHandler::deleteEquipmentSet(uint64_t setGuid) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    uint16_t wire = wireOpcode(Opcode::CMSG_DELETEEQUIPMENT_SET);
-    if (wire == 0xFFFF) { owner_.addUIError("Equipment sets not supported."); return; }
-    network::Packet pkt(wire);
-    pkt.writeUInt64(setGuid);
-    owner_.socket->send(pkt);
-    equipmentSets_.erase(
-        std::remove_if(equipmentSets_.begin(), equipmentSets_.end(),
-                        [setGuid](const EquipmentSet& es) { return es.setGuid == setGuid; }),
-        equipmentSets_.end());
-    equipmentSetInfo_.erase(
-        std::remove_if(equipmentSetInfo_.begin(), equipmentSetInfo_.end(),
-                        [setGuid](const EquipmentSetInfo& info) { return info.setGuid == setGuid; }),
-        equipmentSetInfo_.end());
-}
-
-void InventoryHandler::handleEquipmentSetList(network::Packet& packet) {
-    if (!packet.hasRemaining(4)) return;
-    uint32_t count = packet.readUInt32();
-    if (count > 10) {
-        LOG_WARNING("SMSG_EQUIPMENT_SET_LIST: unexpected count ", count, ", ignoring");
-        packet.skipAll();
-        return;
-    }
-    equipmentSets_.clear();
-    equipmentSets_.reserve(count);
-    for (uint32_t i = 0; i < count; ++i) {
-        if (!packet.hasRemaining(16)) break;
-        EquipmentSet es;
-        es.setGuid        = packet.readUInt64();
-        es.setId          = packet.readUInt32();
-        es.name           = packet.readString();
-        es.iconName       = packet.readString();
-        es.ignoreSlotMask = packet.readUInt32();
-        for (int slot = 0; slot < 19; ++slot) {
-            if (!packet.hasRemaining(8)) break;
-            es.itemGuids[slot] = packet.readUInt64();
-        }
-        equipmentSets_.push_back(std::move(es));
-    }
-    equipmentSetInfo_.clear();
-    equipmentSetInfo_.reserve(equipmentSets_.size());
-    for (const auto& es : equipmentSets_) {
-        EquipmentSetInfo info;
-        info.setGuid  = es.setGuid;
-        info.setId    = es.setId;
-        info.name     = es.name;
-        info.iconName = es.iconName;
-        equipmentSetInfo_.push_back(std::move(info));
-    }
-    LOG_INFO("SMSG_EQUIPMENT_SET_LIST: ", equipmentSets_.size(), " equipment sets received");
-}
-
-// ============================================================
-// Inventory field / rebuild methods (moved from GameHandler)
-// ============================================================
-
-void InventoryHandler::queryItemInfo(uint32_t entry, uint64_t guid) {
-    if (owner_.itemInfoCache_.count(entry) || owner_.pendingItemQueries_.count(entry)) return;
-    if (!owner_.isInWorld()) return;
-
-    owner_.pendingItemQueries_.insert(entry);
-    // Some cores reject CMSG_ITEM_QUERY_SINGLE when the GUID is 0.
-    // If we don't have the item object's GUID (e.g. visible equipment decoding),
-    // fall back to the player's GUID to keep the request non-zero.
-    uint64_t queryGuid = (guid != 0) ? guid : owner_.playerGuid;
-    auto packet = owner_.packetParsers_
-        ? owner_.packetParsers_->buildItemQuery(entry, queryGuid)
-        : ItemQueryPacket::build(entry, queryGuid);
-    owner_.socket->send(packet);
-    LOG_DEBUG("queryItemInfo: entry=", entry, " guid=0x", std::hex, queryGuid, std::dec,
-              " pending=", owner_.pendingItemQueries_.size());
-}
-
-void InventoryHandler::handleItemQueryResponse(network::Packet& packet) {
-    ItemQueryResponseData data;
-    bool parsed = owner_.packetParsers_
-        ? owner_.packetParsers_->parseItemQueryResponse(packet, data)
-        : ItemQueryResponseParser::parse(packet, data);
-    if (!parsed) {
-        // Extract entry from raw packet so we can clear the pending query even on parse failure.
-        // Without this, the entry stays in pendingItemQueries_ forever, blocking retries.
-        if (packet.getSize() >= 4) {
-            packet.setReadPos(0);
-            // High bit indicates a negative (invalid/missing) item entry response;
-            // mask it off so we can still clear the pending query by entry ID.
-            uint32_t rawEntry = packet.readUInt32() & ~0x80000000u;
-            owner_.pendingItemQueries_.erase(rawEntry);
-        }
-        LOG_WARNING("handleItemQueryResponse: parse failed, size=", packet.getSize());
-        return;
-    }
-
-    owner_.pendingItemQueries_.erase(data.entry);
-    LOG_DEBUG("handleItemQueryResponse: entry=", data.entry, " name='", data.name,
-             "' class=", data.itemClass, " subClass=", data.subClass,
-             " invType=", data.inventoryType, " valid=", data.valid);
-
-    if (data.valid) {
-        owner_.itemInfoCache_[data.entry] = data;
-        rebuildOnlineInventory();
-        maybeDetectVisibleItemLayout();
-
-        // Flush any deferred loot notifications waiting on this item's name/quality.
-        for (auto it = owner_.pendingItemPushNotifs_.begin(); it != owner_.pendingItemPushNotifs_.end(); ) {
-            if (it->itemId == data.entry) {
-                std::string itemName = data.name.empty() ? ("item #" + std::to_string(data.entry)) : data.name;
-                std::string link = buildItemLink(data.entry, data.quality, itemName);
-                std::string msg = "Received: " + link;
-                if (it->count > 1) msg += " x" + std::to_string(it->count);
-                owner_.addSystemChatMessage(msg);
-                if (auto* ac = owner_.services().audioCoordinator) {
-                    if (auto* sfx = ac->getUiSoundManager()) sfx->playLootItem();
-                }
-                if (owner_.itemLootCallback_) owner_.itemLootCallback_(data.entry, it->count, data.quality, itemName);
-                it = owner_.pendingItemPushNotifs_.erase(it);
-            } else {
-                ++it;
-            }
-        }
-
-        // Selectively re-emit only players whose equipment references this item entry
-        const uint32_t resolvedEntry = data.entry;
-        int reemitCount = 0;
-        for (const auto& [guid, entries] : owner_.otherPlayerVisibleItemEntries_) {
-            for (uint32_t e : entries) {
-                if (e == resolvedEntry) {
-                    emitOtherPlayerEquipment(guid);
-                    reemitCount++;
-                    break;
-                }
-            }
-        }
-        if (reemitCount > 0) {
-            LOG_WARNING("Re-emitted equipment for ", reemitCount, " players after resolving entry=", resolvedEntry);
-        }
-        // Same for inspect-based entries
-        if (owner_.playerEquipmentCallback_) {
-            for (const auto& [guid, entries] : owner_.inspectedPlayerItemEntries_) {
-                bool relevant = false;
-                for (uint32_t e : entries) {
-                    if (e == resolvedEntry) { relevant = true; break; }
-                }
-                if (!relevant) continue;
-                std::array<uint32_t, 19> displayIds{};
-                std::array<uint8_t, 19> invTypes{};
-                for (int s = 0; s < 19; s++) {
-                    uint32_t entry = entries[s];
-                    if (entry == 0) continue;
-                    auto infoIt = owner_.itemInfoCache_.find(entry);
-                    if (infoIt == owner_.itemInfoCache_.end()) continue;
-                    displayIds[s] = infoIt->second.displayInfoId;
-                    invTypes[s] = static_cast<uint8_t>(infoIt->second.inventoryType);
-                }
-                owner_.playerEquipmentCallback_(guid, displayIds, invTypes);
-            }
-        }
-    }
-}
-
-uint64_t InventoryHandler::resolveOnlineItemGuid(uint32_t itemId) const {
-    if (itemId == 0) return 0;
-    for (const auto& [guid, info] : owner_.onlineItems_) {
-        if (info.entry == itemId) return guid;
-    }
-    return 0;
-}
-
-void InventoryHandler::detectInventorySlotBases(const std::map<uint16_t, uint32_t>& fields) {
-    if (owner_.invSlotBase_ >= 0 && owner_.packSlotBase_ >= 0) return;
-    if (fields.empty()) return;
-
-    std::vector<uint16_t> matchingPairs;
-    matchingPairs.reserve(32);
-
-    for (const auto& [idx, low] : fields) {
-        if ((idx % 2) != 0) continue;
-        auto itHigh = fields.find(static_cast<uint16_t>(idx + 1));
-        if (itHigh == fields.end()) continue;
-        uint64_t guid = (uint64_t(itHigh->second) << 32) | low;
-        if (guid == 0) continue;
-        // Primary signal: GUID pairs that match spawned ITEM objects.
-        if (!owner_.onlineItems_.empty() && owner_.onlineItems_.count(guid)) {
-            matchingPairs.push_back(idx);
-        }
-    }
-
-    // Fallback signal (when ITEM objects haven't been seen yet):
-    // collect any plausible non-zero GUID pairs and derive a base by density.
-    if (matchingPairs.empty()) {
-        for (const auto& [idx, low] : fields) {
-            if ((idx % 2) != 0) continue;
-            auto itHigh = fields.find(static_cast<uint16_t>(idx + 1));
-            if (itHigh == fields.end()) continue;
-            uint64_t guid = (uint64_t(itHigh->second) << 32) | low;
-            if (guid == 0) continue;
-            // Heuristic: item GUIDs tend to be non-trivial and change often; ignore tiny values.
-            if (guid < 0x10000ull) continue;
-            matchingPairs.push_back(idx);
-        }
-    }
-
-    if (matchingPairs.empty()) return;
-    std::sort(matchingPairs.begin(), matchingPairs.end());
-
-    if (owner_.invSlotBase_ < 0) {
-        // The lowest matching field is the first EQUIPPED slot (not necessarily HEAD).
-        // With 2+ matches we can derive the true base: all matches must be at
-        // even offsets from the base, spaced 2 fields per slot.
-        const int knownBase = static_cast<int>(fieldIndex(UF::PLAYER_FIELD_INV_SLOT_HEAD));
-        constexpr int slotStride = 2;
-        bool allAlign = true;
-        for (uint16_t p : matchingPairs) {
-            if (p < knownBase || (p - knownBase) % slotStride != 0) {
-                allAlign = false;
-                break;
-            }
-        }
-        if (allAlign) {
-            owner_.invSlotBase_ = knownBase;
-        } else {
-            // Fallback: if we have 2+ matches, derive base from their spacing
-            if (matchingPairs.size() >= 2) {
-                uint16_t lo = matchingPairs[0];
-                // lo must be base + 2*slotN, and slotN is 0..22
-                // Try each possible slot for 'lo' and see if all others also land on valid slots
-                for (int s = 0; s <= 22; s++) {
-                    int candidate = lo - s * slotStride;
-                    if (candidate < 0) break;
-                    bool ok = true;
-                    for (uint16_t p : matchingPairs) {
-                        int off = p - candidate;
-                        if (off < 0 || off % slotStride != 0 || off / slotStride > 22) {
-                            ok = false;
-                            break;
-                        }
-                    }
-                    if (ok) {
-                        owner_.invSlotBase_ = candidate;
-                        break;
-                    }
-                }
-                if (owner_.invSlotBase_ < 0) owner_.invSlotBase_ = knownBase;
-            } else {
-                owner_.invSlotBase_ = knownBase;
-            }
-        }
-        owner_.packSlotBase_ = owner_.invSlotBase_ + (game::Inventory::NUM_EQUIP_SLOTS * 2);
-        LOG_INFO("Detected inventory field base: equip=", owner_.invSlotBase_,
-                 " pack=", owner_.packSlotBase_);
-    }
-}
-
-bool InventoryHandler::applyInventoryFields(const std::map<uint16_t, uint32_t>& fields) {
-    bool slotsChanged = false;
-    int equipBase = (owner_.invSlotBase_ >= 0) ? owner_.invSlotBase_ : static_cast<int>(fieldIndex(UF::PLAYER_FIELD_INV_SLOT_HEAD));
-    int packBase = (owner_.packSlotBase_ >= 0) ? owner_.packSlotBase_ : static_cast<int>(fieldIndex(UF::PLAYER_FIELD_PACK_SLOT_1));
-    int bankBase = static_cast<int>(fieldIndex(UF::PLAYER_FIELD_BANK_SLOT_1));
-    int bankBagBase = static_cast<int>(fieldIndex(UF::PLAYER_FIELD_BANKBAG_SLOT_1));
-
-    // Derive slot counts from field gap (Classic=24/6, TBC/WotLK=28/7).
-    if (bankBase != 0xFFFF && bankBagBase != 0xFFFF) {
-        effectiveBankSlots_ = std::min((bankBagBase - bankBase) / 2, 28);
-        effectiveBankBagSlots_ = (effectiveBankSlots_ <= 24) ? 6 : 7;
-    }
-
-    int keyringBase = static_cast<int>(fieldIndex(UF::PLAYER_FIELD_KEYRING_SLOT_1));
-    if (keyringBase == 0xFFFF && bankBagBase != 0xFFFF) {
-        // Layout fallback for profiles that don't define PLAYER_FIELD_KEYRING_SLOT_1.
-        // Bank bag slots are followed by 12 vendor buyback slots (24 fields), then keyring.
-        keyringBase = bankBagBase + (effectiveBankBagSlots_ * 2) + 24;
-    }
-
-    for (const auto& [key, val] : fields) {
-        if (key >= equipBase && key <= equipBase + (game::Inventory::NUM_EQUIP_SLOTS * 2 - 1)) {
-            int slotIndex = (key - equipBase) / 2;
-            bool isLow = ((key - equipBase) % 2 == 0);
-            if (slotIndex < static_cast<int>(owner_.equipSlotGuids_.size())) {
-                uint64_t& guid = owner_.equipSlotGuids_[slotIndex];
-                if (isLow) guid = (guid & 0xFFFFFFFF00000000ULL) | val;
-                else guid = (guid & 0x00000000FFFFFFFFULL) | (uint64_t(val) << 32);
-                slotsChanged = true;
-            }
-        } else if (key >= packBase && key <= packBase + (game::Inventory::BACKPACK_SLOTS * 2 - 1)) {
-            int slotIndex = (key - packBase) / 2;
-            bool isLow = ((key - packBase) % 2 == 0);
-            if (slotIndex < static_cast<int>(owner_.backpackSlotGuids_.size())) {
-                uint64_t& guid = owner_.backpackSlotGuids_[slotIndex];
-                if (isLow) guid = (guid & 0xFFFFFFFF00000000ULL) | val;
-                else guid = (guid & 0x00000000FFFFFFFFULL) | (uint64_t(val) << 32);
-                slotsChanged = true;
-            }
-        } else if (keyringBase != 0xFFFF &&
-                   key >= keyringBase &&
-                   key <= keyringBase + (game::Inventory::KEYRING_SLOTS * 2 - 1)) {
-            int slotIndex = (key - keyringBase) / 2;
-            bool isLow = ((key - keyringBase) % 2 == 0);
-            if (slotIndex < static_cast<int>(owner_.keyringSlotGuids_.size())) {
-                uint64_t& guid = owner_.keyringSlotGuids_[slotIndex];
-                if (isLow) guid = (guid & 0xFFFFFFFF00000000ULL) | val;
-                else guid = (guid & 0x00000000FFFFFFFFULL) | (uint64_t(val) << 32);
-                slotsChanged = true;
-            }
-        }
-        if (bankBase != 0xFFFF && key >= static_cast<uint16_t>(bankBase) &&
-            key <= static_cast<uint16_t>(bankBase) + (effectiveBankSlots_ * 2 - 1)) {
-            int slotIndex = (key - bankBase) / 2;
-            bool isLow = ((key - bankBase) % 2 == 0);
-            if (slotIndex < static_cast<int>(bankSlotGuids_.size())) {
-                uint64_t& guid = bankSlotGuids_[slotIndex];
-                if (isLow) guid = (guid & 0xFFFFFFFF00000000ULL) | val;
-                else guid = (guid & 0x00000000FFFFFFFFULL) | (uint64_t(val) << 32);
-                slotsChanged = true;
-            }
-        }
-
-        // Bank bag slots starting at PLAYER_FIELD_BANKBAG_SLOT_1
-        if (bankBagBase != 0xFFFF && key >= static_cast<uint16_t>(bankBagBase) &&
-            key <= static_cast<uint16_t>(bankBagBase) + (effectiveBankBagSlots_ * 2 - 1)) {
-            int slotIndex = (key - bankBagBase) / 2;
-            bool isLow = ((key - bankBagBase) % 2 == 0);
-            if (slotIndex < static_cast<int>(bankBagSlotGuids_.size())) {
-                uint64_t& guid = bankBagSlotGuids_[slotIndex];
-                if (isLow) guid = (guid & 0xFFFFFFFF00000000ULL) | val;
-                else guid = (guid & 0x00000000FFFFFFFFULL) | (uint64_t(val) << 32);
-                slotsChanged = true;
-            }
-        }
-    }
-
-    return slotsChanged;
-}
-
-void InventoryHandler::extractContainerFields(uint64_t containerGuid, const std::map<uint16_t, uint32_t>& fields) {
-    const uint16_t numSlotsIdx = fieldIndex(UF::CONTAINER_FIELD_NUM_SLOTS);
-    const uint16_t slot1Idx = fieldIndex(UF::CONTAINER_FIELD_SLOT_1);
-    if (numSlotsIdx == 0xFFFF || slot1Idx == 0xFFFF) return;
-
-    auto& info = owner_.containerContents_[containerGuid];
-
-    // Read number of slots
-    auto numIt = fields.find(numSlotsIdx);
-    if (numIt != fields.end()) {
-        info.numSlots = std::min(numIt->second, 36u);
-    }
-
-    // Read slot GUIDs (each is 2 uint32 fields: lo + hi)
-    for (const auto& [key, val] : fields) {
-        if (key < slot1Idx) continue;
-        int offset = key - slot1Idx;
-        int slotIndex = offset / 2;
-        if (slotIndex >= 36) continue;
-        bool isLow = (offset % 2 == 0);
-        uint64_t& guid = info.slotGuids[slotIndex];
-        if (isLow) guid = (guid & 0xFFFFFFFF00000000ULL) | val;
-        else guid = (guid & 0x00000000FFFFFFFFULL) | (uint64_t(val) << 32);
-    }
-}
-
-// Builds an ItemDef from an OnlineItemInfo by merging server field data (stack
-// count, durability) with cached item info (name, stats, quality). Centralised
-// here so adding new ItemDef fields doesn't require editing 4 separate copy-
-// paste sites in rebuildOnlineInventory.
-ItemDef InventoryHandler::buildItemDef(uint32_t entry, uint32_t stackCount,
-                                       uint32_t curDur, uint32_t maxDur, uint64_t guid) {
-    ItemDef def;
-    def.itemId = entry;
-    def.stackCount = stackCount;
-    def.curDurability = curDur;
-    def.maxDurability = maxDur;
-    def.maxStack = 1;
-
-    auto infoIt = owner_.itemInfoCache_.find(entry);
-    if (infoIt != owner_.itemInfoCache_.end()) {
-        const auto& info = infoIt->second;
-        def.name = info.name;
-        def.quality = static_cast<ItemQuality>(info.quality);
-        def.inventoryType = info.inventoryType;
-        def.maxStack = std::max(1, info.maxStack);
-        def.displayInfoId = info.displayInfoId;
-        def.subclassName = info.subclassName;
-        def.damageMin = info.damageMin;
-        def.damageMax = info.damageMax;
-        def.delayMs = info.delayMs;
-        def.armor = info.armor;
-        def.stamina = info.stamina;
-        def.strength = info.strength;
-        def.agility = info.agility;
-        def.intellect = info.intellect;
-        def.spirit = info.spirit;
-        def.sellPrice = info.sellPrice;
-        def.itemLevel = info.itemLevel;
-        def.requiredLevel = info.requiredLevel;
-        def.bindType = info.bindType;
-        def.description = info.description;
-        def.startQuestId = info.startQuestId;
-        def.extraStats.clear();
-        for (const auto& es : info.extraStats)
-            def.extraStats.push_back({es.statType, es.statValue});
-    } else {
-        def.name = "Item " + std::to_string(def.itemId);
-        queryItemInfo(def.itemId, guid);
-    }
-    return def;
-}
-
-void InventoryHandler::rebuildOnlineInventory() {
-
-    uint8_t savedBankBagSlots = owner_.inventory.getPurchasedBankBagSlots();
-    owner_.inventory = Inventory();
-    owner_.inventory.setPurchasedBankBagSlots(savedBankBagSlots);
-
-    // Equipment slots
-    for (int i = 0; i < 23; i++) {
-        uint64_t guid = owner_.equipSlotGuids_[i];
-        if (guid == 0) continue;
-        auto itemIt = owner_.onlineItems_.find(guid);
-        if (itemIt == owner_.onlineItems_.end()) continue;
-        owner_.inventory.setEquipSlot(static_cast<EquipSlot>(i), buildItemDef(itemIt->second.entry, itemIt->second.stackCount, itemIt->second.curDurability, itemIt->second.maxDurability, guid));
-    }
-
-    // Backpack slots
-    for (int i = 0; i < 16; i++) {
-        uint64_t guid = owner_.backpackSlotGuids_[i];
-        if (guid == 0) continue;
-        auto itemIt = owner_.onlineItems_.find(guid);
-        if (itemIt == owner_.onlineItems_.end()) continue;
-        owner_.inventory.setBackpackSlot(i, buildItemDef(itemIt->second.entry, itemIt->second.stackCount, itemIt->second.curDurability, itemIt->second.maxDurability, guid));
-    }
-
-    // Keyring slots
-    for (int i = 0; i < game::Inventory::KEYRING_SLOTS; i++) {
-        uint64_t guid = owner_.keyringSlotGuids_[i];
-        if (guid == 0) continue;
-        auto itemIt = owner_.onlineItems_.find(guid);
-        if (itemIt == owner_.onlineItems_.end()) continue;
-        owner_.inventory.setKeyringSlot(i, buildItemDef(itemIt->second.entry, itemIt->second.stackCount, itemIt->second.curDurability, itemIt->second.maxDurability, guid));
-    }
-
-    // Bag contents (BAG1-BAG4 are equip slots 19-22)
-    for (int bagIdx = 0; bagIdx < 4; bagIdx++) {
-        uint64_t bagGuid = owner_.equipSlotGuids_[Inventory::FIRST_BAG_EQUIP_SLOT + bagIdx];
-        if (bagGuid == 0) continue;
-
-        // Determine bag size from container fields or item template
-        int numSlots = 0;
-        auto contIt = owner_.containerContents_.find(bagGuid);
-        if (contIt != owner_.containerContents_.end()) {
-            numSlots = static_cast<int>(contIt->second.numSlots);
-        }
-        if (numSlots <= 0) {
-            auto bagItemIt = owner_.onlineItems_.find(bagGuid);
-            if (bagItemIt != owner_.onlineItems_.end()) {
-                auto bagInfoIt = owner_.itemInfoCache_.find(bagItemIt->second.entry);
-                if (bagInfoIt != owner_.itemInfoCache_.end()) {
-                    numSlots = bagInfoIt->second.containerSlots;
-                }
-            }
-        }
-        if (numSlots <= 0) continue;
-
-        // Set the bag size in the inventory bag data
-        owner_.inventory.setBagSize(bagIdx, numSlots);
-
-        // Also set bagSlots on the equipped bag item (for UI display)
-        auto& bagEquipSlot = owner_.inventory.getEquipSlot(static_cast<EquipSlot>(Inventory::FIRST_BAG_EQUIP_SLOT + bagIdx));
-        if (!bagEquipSlot.empty()) {
-            ItemDef bagDef = bagEquipSlot.item;
-            bagDef.bagSlots = numSlots;
-            owner_.inventory.setEquipSlot(static_cast<EquipSlot>(Inventory::FIRST_BAG_EQUIP_SLOT + bagIdx), bagDef);
-        }
-
-        // Populate bag slot items
-        if (contIt == owner_.containerContents_.end()) continue;
-        const auto& container = contIt->second;
-        for (int s = 0; s < numSlots && s < 36; s++) {
-            uint64_t itemGuid = container.slotGuids[s];
-            if (itemGuid == 0) continue;
-
-            auto itemIt = owner_.onlineItems_.find(itemGuid);
-            if (itemIt == owner_.onlineItems_.end()) continue;
-            ItemDef def = buildItemDef(itemIt->second.entry, itemIt->second.stackCount, itemIt->second.curDurability, itemIt->second.maxDurability, itemGuid);
-            // Bags inside bags need containerSlots for the UI slot-count display.
-            auto bagInfoIt = owner_.itemInfoCache_.find(itemIt->second.entry);
-            if (bagInfoIt != owner_.itemInfoCache_.end())
-                def.bagSlots = bagInfoIt->second.containerSlots;
-            owner_.inventory.setBagSlot(bagIdx, s, def);
-        }
-    }
-
-    // Bank slots (24 for Classic, 28 for TBC/WotLK)
-    for (int i = 0; i < effectiveBankSlots_; i++) {
-        uint64_t guid = bankSlotGuids_[i];
-        if (guid == 0) { owner_.inventory.clearBankSlot(i); continue; }
-
-        auto itemIt = owner_.onlineItems_.find(guid);
-        if (itemIt == owner_.onlineItems_.end()) { owner_.inventory.clearBankSlot(i); continue; }
-
-        ItemDef def;
-        def.itemId = itemIt->second.entry;
-        def.stackCount = itemIt->second.stackCount;
-        def.curDurability = itemIt->second.curDurability;
-        def.maxDurability = itemIt->second.maxDurability;
-        def.maxStack = 1;
-
-        auto infoIt = owner_.itemInfoCache_.find(itemIt->second.entry);
-        if (infoIt != owner_.itemInfoCache_.end()) {
-            def.name = infoIt->second.name;
-            def.quality = static_cast<ItemQuality>(infoIt->second.quality);
-            def.inventoryType = infoIt->second.inventoryType;
-            def.maxStack = std::max(1, infoIt->second.maxStack);
-            def.displayInfoId = infoIt->second.displayInfoId;
-            def.subclassName = infoIt->second.subclassName;
-            def.damageMin = infoIt->second.damageMin;
-            def.damageMax = infoIt->second.damageMax;
-            def.delayMs = infoIt->second.delayMs;
-            def.armor = infoIt->second.armor;
-            def.stamina = infoIt->second.stamina;
-            def.strength = infoIt->second.strength;
-            def.agility = infoIt->second.agility;
-            def.intellect = infoIt->second.intellect;
-            def.spirit = infoIt->second.spirit;
-            def.itemLevel = infoIt->second.itemLevel;
-            def.requiredLevel = infoIt->second.requiredLevel;
-            def.bindType = infoIt->second.bindType;
-            def.description = infoIt->second.description;
-            def.startQuestId = infoIt->second.startQuestId;
-            def.extraStats.clear();
-            for (const auto& es : infoIt->second.extraStats)
-                def.extraStats.push_back({es.statType, es.statValue});
-            def.sellPrice = infoIt->second.sellPrice;
-            def.bagSlots = infoIt->second.containerSlots;
-        } else {
-            def.name = "Item " + std::to_string(def.itemId);
-            queryItemInfo(def.itemId, guid);
-        }
-
-        owner_.inventory.setBankSlot(i, def);
-    }
-
-    // Bank bag contents (6 for Classic, 7 for TBC/WotLK)
-    for (int bagIdx = 0; bagIdx < effectiveBankBagSlots_; bagIdx++) {
-        uint64_t bagGuid = bankBagSlotGuids_[bagIdx];
-        if (bagGuid == 0) { owner_.inventory.setBankBagSize(bagIdx, 0); continue; }
-
-        int numSlots = 0;
-        auto contIt = owner_.containerContents_.find(bagGuid);
-        if (contIt != owner_.containerContents_.end()) {
-            numSlots = static_cast<int>(contIt->second.numSlots);
-        }
-
-        // Populate the bag item itself (for icon/name in the bank bag equip slot)
-        auto bagItemIt = owner_.onlineItems_.find(bagGuid);
-        if (bagItemIt != owner_.onlineItems_.end()) {
-            if (numSlots <= 0) {
-                auto bagInfoIt = owner_.itemInfoCache_.find(bagItemIt->second.entry);
-                if (bagInfoIt != owner_.itemInfoCache_.end()) {
-                    numSlots = bagInfoIt->second.containerSlots;
-                }
-            }
-            ItemDef bagDef;
-            bagDef.itemId = bagItemIt->second.entry;
-            bagDef.stackCount = 1;
-            bagDef.inventoryType = 18; // bag
-            auto bagInfoIt = owner_.itemInfoCache_.find(bagItemIt->second.entry);
-            if (bagInfoIt != owner_.itemInfoCache_.end()) {
-                bagDef.name = bagInfoIt->second.name;
-                bagDef.quality = static_cast<ItemQuality>(bagInfoIt->second.quality);
-                bagDef.displayInfoId = bagInfoIt->second.displayInfoId;
-                bagDef.bagSlots = bagInfoIt->second.containerSlots;
-            } else {
-                bagDef.name = "Bag";
-                queryItemInfo(bagDef.itemId, bagGuid);
-            }
-            owner_.inventory.setBankBagItem(bagIdx, bagDef);
-        }
-        if (numSlots <= 0) continue;
-
-        owner_.inventory.setBankBagSize(bagIdx, numSlots);
-
-        if (contIt == owner_.containerContents_.end()) continue;
-        const auto& container = contIt->second;
-        for (int s = 0; s < numSlots && s < 36; s++) {
-            uint64_t itemGuid = container.slotGuids[s];
-            if (itemGuid == 0) continue;
-
-            auto itemIt = owner_.onlineItems_.find(itemGuid);
-            if (itemIt == owner_.onlineItems_.end()) continue;
-
-            ItemDef def;
-            def.itemId = itemIt->second.entry;
-            def.stackCount = itemIt->second.stackCount;
-        def.curDurability = itemIt->second.curDurability;
-        def.maxDurability = itemIt->second.maxDurability;
-            def.maxStack = 1;
-
-            auto infoIt = owner_.itemInfoCache_.find(itemIt->second.entry);
-            if (infoIt != owner_.itemInfoCache_.end()) {
-                def.name = infoIt->second.name;
-                def.quality = static_cast<ItemQuality>(infoIt->second.quality);
-                def.inventoryType = infoIt->second.inventoryType;
-                def.maxStack = std::max(1, infoIt->second.maxStack);
-                def.displayInfoId = infoIt->second.displayInfoId;
-                def.subclassName = infoIt->second.subclassName;
-                def.damageMin = infoIt->second.damageMin;
-                def.damageMax = infoIt->second.damageMax;
-                def.delayMs = infoIt->second.delayMs;
-                def.armor = infoIt->second.armor;
-                def.stamina = infoIt->second.stamina;
-                def.strength = infoIt->second.strength;
-                def.agility = infoIt->second.agility;
-                def.intellect = infoIt->second.intellect;
-                def.spirit = infoIt->second.spirit;
-                def.itemLevel = infoIt->second.itemLevel;
-                def.requiredLevel = infoIt->second.requiredLevel;
-                def.sellPrice = infoIt->second.sellPrice;
-                def.bindType = infoIt->second.bindType;
-                def.description = infoIt->second.description;
-                def.startQuestId = infoIt->second.startQuestId;
-                def.extraStats.clear();
-                for (const auto& es : infoIt->second.extraStats)
-                    def.extraStats.push_back({es.statType, es.statValue});
-                def.bagSlots = infoIt->second.containerSlots;
-            } else {
-                def.name = "Item " + std::to_string(def.itemId);
-                queryItemInfo(def.itemId, itemGuid);
-            }
-
-            owner_.inventory.setBankBagSlot(bagIdx, s, def);
-        }
-    }
-
-    // Only mark equipment dirty if equipped item displayInfoIds actually changed
-    std::array<uint32_t, 19> currentEquipDisplayIds{};
-    for (int i = 0; i < 19; i++) {
-        const auto& slot = owner_.inventory.getEquipSlot(static_cast<EquipSlot>(i));
-        if (!slot.empty()) currentEquipDisplayIds[i] = slot.item.displayInfoId;
-    }
-    if (currentEquipDisplayIds != owner_.lastEquipDisplayIds_) {
-        owner_.lastEquipDisplayIds_ = currentEquipDisplayIds;
-        owner_.onlineEquipDirty_ = true;
-    }
-
-    LOG_DEBUG("Rebuilt online inventory: equip=", [&](){
-        int c = 0; for (auto g : owner_.equipSlotGuids_) if (g) c++; return c;
-    }(), " backpack=", [&](){
-        int c = 0; for (auto g : owner_.backpackSlotGuids_) if (g) c++; return c;
-    }(), " keyring=", [&](){
-        int c = 0; for (auto g : owner_.keyringSlotGuids_) if (g) c++; return c;
-    }());
-}
-
-void InventoryHandler::maybeDetectVisibleItemLayout() {
-    if (owner_.visibleItemLayoutVerified_) return;
-    if (owner_.lastPlayerFields_.empty()) return;
-
-    std::array<uint32_t, 19> equipEntries{};
-    int nonZero = 0;
-    // Prefer authoritative equipped item entry IDs derived from item objects (onlineItems_),
-    // because Inventory::ItemDef may not be populated yet if templates haven't been queried.
-    for (int i = 0; i < 19; i++) {
-        uint64_t itemGuid = owner_.equipSlotGuids_[i];
-        if (itemGuid != 0) {
-            auto it = owner_.onlineItems_.find(itemGuid);
-            if (it != owner_.onlineItems_.end() && it->second.entry != 0) {
-                equipEntries[i] = it->second.entry;
-            }
-        }
-        if (equipEntries[i] == 0) {
-            const auto& slot = owner_.inventory.getEquipSlot(static_cast<EquipSlot>(i));
-            equipEntries[i] = slot.empty() ? 0u : slot.item.itemId;
-        }
-        if (equipEntries[i] != 0) nonZero++;
-    }
-    if (nonZero < 2) return;
-
-    const uint16_t maxKey = owner_.lastPlayerFields_.rbegin()->first;
-    int bestBase = -1;
-    int bestStride = 0;
-    int bestMatches = 0;
-    int bestMismatches = 9999;
-    int bestScore = -999999;
-
-    const int strides[] = {2, 3, 4, 1};
-    for (int stride : strides) {
-        for (const auto& [baseIdxU16, _v] : owner_.lastPlayerFields_) {
-            const int base = static_cast<int>(baseIdxU16);
-            if (base + 18 * stride > static_cast<int>(maxKey)) continue;
-
-            int matches = 0;
-            int mismatches = 0;
-            for (int s = 0; s < 19; s++) {
-                uint32_t want = equipEntries[s];
-                if (want == 0) continue;
-                const uint16_t idx = static_cast<uint16_t>(base + s * stride);
-                auto it = owner_.lastPlayerFields_.find(idx);
-                if (it == owner_.lastPlayerFields_.end()) continue;
-                if (it->second == want) {
-                    matches++;
-                } else if (it->second != 0) {
-                    mismatches++;
-                }
-            }
-
-            int score = matches * 2 - mismatches * 3;
-            if (score > bestScore ||
-                (score == bestScore && matches > bestMatches) ||
-                (score == bestScore && matches == bestMatches && mismatches < bestMismatches) ||
-                (score == bestScore && matches == bestMatches && mismatches == bestMismatches && base < bestBase)) {
-                bestScore = score;
-                bestMatches = matches;
-                bestMismatches = mismatches;
-                bestBase = base;
-                bestStride = stride;
-            }
-        }
-    }
-
-    if (bestMatches >= 2 && bestBase >= 0 && bestStride > 0 && bestMismatches <= 1) {
-        owner_.visibleItemEntryBase_ = bestBase;
-        owner_.visibleItemStride_ = bestStride;
-        owner_.visibleItemLayoutVerified_ = true;
-        LOG_INFO("Detected PLAYER_VISIBLE_ITEM entry layout: base=", owner_.visibleItemEntryBase_,
-                 " stride=", owner_.visibleItemStride_, " (matches=", bestMatches,
-                 " mismatches=", bestMismatches, " score=", bestScore, ")");
-
-        // Backfill existing player entities already in view.
-        for (const auto& [guid, ent] : owner_.getEntityManager().getEntities()) {
-            if (!ent || ent->getType() != ObjectType::PLAYER) continue;
-            if (guid == owner_.playerGuid) continue;
-            updateOtherPlayerVisibleItems(guid, ent->getFields());
-        }
-    }
-    // If heuristic didn't find a match, keep using the default WotLK layout (base=284, stride=2).
-}
-
-void InventoryHandler::updateOtherPlayerVisibleItems(uint64_t guid, const std::map<uint16_t, uint32_t>& fields) {
-    if (guid == 0 || guid == owner_.playerGuid) return;
-
-    // Use the current base/stride (defaults are correct for WotLK 3.3.5a: base=284, stride=2).
-    // The heuristic may refine these later, but we proceed immediately with whatever values
-    // are set rather than waiting for verification.
-    const int base = owner_.visibleItemEntryBase_;
-    const int stride = owner_.visibleItemStride_;
-    if (base < 0 || stride <= 0) return; // Defensive: should never happen with defaults.
-
-    std::array<uint32_t, 19> newEntries{};
-    for (int s = 0; s < 19; s++) {
-        uint16_t idx = static_cast<uint16_t>(base + s * stride);
-        auto it = fields.find(idx);
-        if (it != fields.end()) newEntries[s] = it->second;
-    }
-
-    int nonZero = 0;
-    for (uint32_t e : newEntries) { if (e != 0) nonZero++; }
-
-    // Dump raw fields around visible item range to find the correct offset
-    static int dumpCount = 0;
-    if (dumpCount < 3 && fields.size() > 20) {
-        dumpCount++;
-        std::string dump;
-        for (const auto& [idx, val] : fields) {
-            if (idx >= 270 && idx <= 340 && val != 0) {
-                char buf[32];
-                snprintf(buf, sizeof(buf), " [%u]=%u", idx, val);
-                dump += buf;
-            }
-        }
-        LOG_WARNING("RAW FIELDS 270-340:", dump);
-    }
-
-    if (nonZero > 0) {
-        LOG_WARNING("updateOtherPlayerVisibleItems: guid=0x", std::hex, guid, std::dec,
-                 " nonZero=", nonZero, " base=", base, " stride=", stride,
-                 " head=", newEntries[0], " shoulders=", newEntries[2],
-                 " chest=", newEntries[4], " legs=", newEntries[6],
-                 " mainhand=", newEntries[15], " offhand=", newEntries[16]);
-    }
-
-    bool changed = false;
-    auto& old = owner_.otherPlayerVisibleItemEntries_[guid];
-    if (old != newEntries) {
-        old = newEntries;
-        changed = true;
-    }
-
-    // Request item templates for any new visible entries.
-    for (uint32_t entry : newEntries) {
-        if (entry == 0) continue;
-        if (!owner_.itemInfoCache_.count(entry) && !owner_.pendingItemQueries_.count(entry)) {
-            queryItemInfo(entry, 0);
-        }
-    }
-
-    // Only fall back to auto-inspect if ALL extracted entries are zero (server didn't
-    // send visible item fields at all). If we got at least one non-zero entry, the
-    // update-field approach is working and inspect is unnecessary.
-    if (nonZero == 0) {
-        LOG_DEBUG("updateOtherPlayerVisibleItems: guid=0x", std::hex, guid, std::dec,
-                  " all entries zero (base=", base, " stride=", stride,
-                  " fieldCount=", fields.size(), ") — queuing auto-inspect");
-        if (owner_.socket && owner_.state == WorldState::IN_WORLD) {
-            owner_.pendingAutoInspect_.insert(guid);
-        }
-    }
-
-    if (changed) {
-        owner_.otherPlayerVisibleDirty_.insert(guid);
-        emitOtherPlayerEquipment(guid);
-    }
-}
-
-void InventoryHandler::emitOtherPlayerEquipment(uint64_t guid) {
-    if (!owner_.playerEquipmentCallback_) return;
-    auto it = owner_.otherPlayerVisibleItemEntries_.find(guid);
-    if (it == owner_.otherPlayerVisibleItemEntries_.end()) return;
-
-    std::array<uint32_t, 19> displayIds{};
-    std::array<uint8_t, 19> invTypes{};
-    bool anyEntry = false;
-    int resolved = 0, unresolved = 0;
-
-    for (int s = 0; s < 19; s++) {
-        uint32_t entry = it->second[s];
-        if (entry == 0) continue;
-        anyEntry = true;
-        auto infoIt = owner_.itemInfoCache_.find(entry);
-        if (infoIt == owner_.itemInfoCache_.end()) { unresolved++; continue; }
-        displayIds[s] = infoIt->second.displayInfoId;
-        invTypes[s] = static_cast<uint8_t>(infoIt->second.inventoryType);
-        resolved++;
-    }
-
-    LOG_WARNING("emitOtherPlayerEquipment: guid=0x", std::hex, guid, std::dec,
-             " entries=", (anyEntry ? "yes" : "none"),
-             " resolved=", resolved, " unresolved=", unresolved,
-             " head=", displayIds[0], " shoulders=", displayIds[2],
-             " chest=", displayIds[4], " legs=", displayIds[6],
-             " mainhand=", displayIds[15], " offhand=", displayIds[16]);
-
-    // Don't emit all-zero displayIds — that strips existing equipment for no reason.
-    // Wait until at least one item resolves before applying.
-    if (anyEntry && resolved == 0) {
-        LOG_WARNING("emitOtherPlayerEquipment: skipping all-zero emit (waiting for item queries)");
-        return;
-    }
-
-    owner_.playerEquipmentCallback_(guid, displayIds, invTypes);
-    owner_.otherPlayerVisibleDirty_.erase(guid);
-
-    // If we had entries but couldn't resolve any templates, also try inspect as a fallback.
-    if (anyEntry && !resolved) {
-        owner_.pendingAutoInspect_.insert(guid);
-    }
-}
-
-void InventoryHandler::emitAllOtherPlayerEquipment() {
-    if (!owner_.playerEquipmentCallback_) return;
-    for (const auto& [guid, _] : owner_.otherPlayerVisibleItemEntries_) {
-        emitOtherPlayerEquipment(guid);
-    }
-}
-
-// ============================================================
-// Moved opcode handlers (from GameHandler::registerOpcodeHandlers)
-// ============================================================
-
-void InventoryHandler::handleTrainerBuySucceeded(network::Packet& packet) {
-    /*uint64_t guid =*/ packet.readUInt64();
-    uint32_t spellId = packet.readUInt32();
-    if (owner_.spellHandler_ && !owner_.spellHandler_->knownSpells_.count(spellId)) {
-        owner_.spellHandler_->knownSpells_.insert(spellId);
-    }
-    const std::string& name = owner_.getSpellName(spellId);
-    if (!name.empty())
-        owner_.addSystemChatMessage("You have learned " + name + ".");
-    else
-        owner_.addSystemChatMessage("Spell learned.");
-    if (auto* ac = owner_.services().audioCoordinator)
-        if (auto* sfx = ac->getUiSoundManager()) sfx->playQuestActivate();
-    owner_.fireAddonEvent("TRAINER_UPDATE", {});
-    owner_.fireAddonEvent("SPELLS_CHANGED", {});
-}
-
-void InventoryHandler::handleTrainerBuyFailed(network::Packet& packet) {
-    /*uint64_t trainerGuid =*/ packet.readUInt64();
-    uint32_t spellId = packet.readUInt32();
-    uint32_t errorCode = 0;
-    if (packet.hasRemaining(4))
-        errorCode = packet.readUInt32();
-    const std::string& spellName = owner_.getSpellName(spellId);
-    std::string msg = "Cannot learn ";
-    if (!spellName.empty()) msg += spellName;
-    else msg += "spell #" + std::to_string(spellId);
-    if (errorCode == 0) msg += " (not enough money)";
-    else if (errorCode == 1) msg += " (not enough skill)";
-    else if (errorCode == 2) msg += " (already known)";
-    else if (errorCode != 0) msg += " (error " + std::to_string(errorCode) + ")";
-    owner_.addUIError(msg);
-    owner_.addSystemChatMessage(msg);
-    if (auto* ac = owner_.services().audioCoordinator)
-        if (auto* sfx = ac->getUiSoundManager()) sfx->playError();
-}
-
-// ============================================================
-// Methods moved from GameHandler
-// ============================================================
-
-void InventoryHandler::initiateTrade(uint64_t targetGuid) {
-    if (!owner_.isInWorld()) {
-        LOG_WARNING("Cannot initiate trade: not in world or not connected");
-        return;
-    }
-
-    if (targetGuid == 0) {
-        owner_.addSystemChatMessage("You must target a player to trade with.");
-        return;
-    }
-
-    auto packet = InitiateTradePacket::build(targetGuid);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Requesting trade with target.");
-    LOG_INFO("Initiated trade with target: 0x", std::hex, targetGuid, std::dec);
-}
-
-uint32_t InventoryHandler::getTempEnchantRemainingMs(uint32_t slot) const {
-    uint64_t nowMs = static_cast<uint64_t>(
-        std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now().time_since_epoch()).count());
-    for (const auto& t : owner_.tempEnchantTimers_) {
-        if (t.slot == slot) {
-            return (t.expireMs > nowMs)
-                ? static_cast<uint32_t>(t.expireMs - nowMs) : 0u;
-        }
-    }
-    return 0u;
-}
-
-void InventoryHandler::addMoneyCopper(uint32_t amount) {
-    if (amount == 0) return;
-    owner_.playerMoneyCopper_ += amount;
-    uint32_t gold = amount / 10000;
-    uint32_t silver = (amount / 100) % 100;
-    uint32_t copper = amount % 100;
-    std::string msg = "You receive ";
-    msg += std::to_string(gold) + "g ";
-    msg += std::to_string(silver) + "s ";
-    msg += std::to_string(copper) + "c.";
-    owner_.addSystemChatMessage(msg);
-    owner_.fireAddonEvent("CHAT_MSG_MONEY", {msg});
-}
-
-// ============================================================
-// Repair cost estimation from DBC data
-// ============================================================
-
-void InventoryHandler::loadRepairDbc() const {
-    if (repairDbcLoaded_) return;
-    repairDbcLoaded_ = true;
-
-    auto* am = owner_.services().assetManager;
-    if (!am || !am->isInitialized()) return;
-
-    // DurabilityCosts.dbc: field 0 = itemLevel (key), fields 1-29 = cost multipliers
-    // Columns 1-21 = weapon subclass (0-20), columns 22-29 = armor subclass (0-7)
-    auto costsDbc = am->loadDBC("DurabilityCosts.dbc");
-    if (costsDbc && costsDbc->isLoaded()) {
-        uint32_t count = costsDbc->getRecordCount();
-        for (uint32_t i = 0; i < count; ++i) {
-            uint32_t itemLevel = costsDbc->getUInt32(i, 0);
-            std::array<uint32_t, 29> mults{};
-            for (uint32_t f = 0; f < 29; ++f)
-                mults[f] = costsDbc->getUInt32(i, f + 1);
-            durabilityCosts_[itemLevel] = mults;
-        }
-    }
-
-    // DurabilityQuality.dbc: field 0 = id (key), field 1 = quality_mod (float)
-    auto qualDbc = am->loadDBC("DurabilityQuality.dbc");
-    if (qualDbc && qualDbc->isLoaded()) {
-        uint32_t count = qualDbc->getRecordCount();
-        for (uint32_t i = 0; i < count; ++i) {
-            uint32_t id = qualDbc->getUInt32(i, 0);
-            float mod = qualDbc->getFloat(i, 1);
-            durabilityQuality_[id] = mod;
-        }
-    }
-}
-
-uint32_t InventoryHandler::estimateItemRepairCost(uint64_t itemGuid) const {
-    auto itemIt = owner_.onlineItems_.find(itemGuid);
-    if (itemIt == owner_.onlineItems_.end()) return 0;
-    const auto& item = itemIt->second;
-
-    if (item.maxDurability == 0 || item.curDurability >= item.maxDurability) return 0;
-    uint32_t lostDur = item.maxDurability - item.curDurability;
-
-    auto infoIt = owner_.itemInfoCache_.find(item.entry);
-    if (infoIt == owner_.itemInfoCache_.end()) return 0;
-    const auto& info = infoIt->second;
-
-    loadRepairDbc();
-
-    // Look up DurabilityCosts multiplier for this itemLevel
-    auto costIt = durabilityCosts_.find(info.itemLevel);
-    if (costIt == durabilityCosts_.end()) return 0;
-
-    // Determine column index: weapon (class=2) uses subClass directly,
-    // armor (class=4) uses subClass + 21
-    uint32_t colIndex = 0;
-    if (info.itemClass == 2) { // ITEM_CLASS_WEAPON
-        colIndex = info.subClass;
-    } else if (info.itemClass == 4) { // ITEM_CLASS_ARMOR
-        colIndex = info.subClass + 21;
-    } else {
-        return 0; // only weapons and armor have durability
-    }
-    if (colIndex >= 29) return 0;
-
-    uint32_t dmultiplier = costIt->second[colIndex];
-    if (dmultiplier == 0) return 0;
-
-    // Quality modifier lookup: index is (quality + 1) * 2
-    uint32_t qualIndex = (info.quality + 1) * 2;
-    auto qualIt = durabilityQuality_.find(qualIndex);
-    if (qualIt == durabilityQuality_.end()) return 0;
-    float qualMod = qualIt->second;
-
-    uint32_t cost = static_cast<uint32_t>(lostDur * dmultiplier * qualMod);
-    if (cost == 0 && lostDur > 0) cost = 1; // minimum 1 copper
-    return cost;
-}
-
-uint32_t InventoryHandler::estimateRepairAllCost() const {
-    uint32_t total = 0;
-    for (const auto& [guid, info] : owner_.onlineItems_) {
-        total += estimateItemRepairCost(guid);
-    }
-    return total;
-}
-
-} // namespace game
-} // namespace wowee
diff --git a/src/game/movement_handler.cpp b/src/game/movement_handler.cpp
deleted file mode 100644
index c06a45a2..00000000
--- a/src/game/movement_handler.cpp
+++ /dev/null
@@ -1,2749 +0,0 @@
-#include "game/movement_handler.hpp"
-#include "game/game_handler.hpp"
-#include "game/game_utils.hpp"
-#include "game/packet_parsers.hpp"
-#include "game/transport_manager.hpp"
-#include "game/entity.hpp"
-#include "network/world_socket.hpp"
-#include "network/packet.hpp"
-#include "core/coordinates.hpp"
-#include "core/application.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "pipeline/dbc_layout.hpp"
-#include "core/logger.hpp"
-#include <glm/gtx/quaternion.hpp>
-#include <algorithm>
-#include <cmath>
-#include <limits>
-#include <zlib.h>
-#include <array>
-#include <unordered_set>
-
-namespace wowee {
-namespace game {
-
-MovementHandler::MovementHandler(GameHandler& owner)
-    : owner_(owner), movementInfo(owner.movementInfo) {}
-
-void MovementHandler::registerOpcodes(DispatchTable& table) {
-    // Creature movement
-    table[Opcode::SMSG_MONSTER_MOVE] = [this](network::Packet& packet) { handleMonsterMove(packet); };
-    table[Opcode::SMSG_COMPRESSED_MOVES] = [this](network::Packet& packet) { handleCompressedMoves(packet); };
-    table[Opcode::SMSG_MONSTER_MOVE_TRANSPORT] = [this](network::Packet& packet) { handleMonsterMoveTransport(packet); };
-
-    // Spline move: consume-only (no state change)
-    for (auto op : { Opcode::SMSG_SPLINE_MOVE_FEATHER_FALL,
-                     Opcode::SMSG_SPLINE_MOVE_GRAVITY_DISABLE,
-                     Opcode::SMSG_SPLINE_MOVE_GRAVITY_ENABLE,
-                     Opcode::SMSG_SPLINE_MOVE_LAND_WALK,
-                     Opcode::SMSG_SPLINE_MOVE_NORMAL_FALL,
-                     Opcode::SMSG_SPLINE_MOVE_ROOT,
-                     Opcode::SMSG_SPLINE_MOVE_SET_HOVER }) {
-        table[op] = [this](network::Packet& packet) {
-            if (packet.hasRemaining(1))
-                (void)packet.readPackedGuid();
-        };
-    }
-
-    // Spline move: synth flags (each opcode produces different flags)
-    {
-        auto makeSynthHandler = [this](uint32_t synthFlags) {
-            return [this, synthFlags](network::Packet& packet) {
-                if (!packet.hasRemaining(1)) return;
-                uint64_t guid = packet.readPackedGuid();
-                if (guid == 0 || guid == owner_.playerGuid || !owner_.unitMoveFlagsCallback_) return;
-                owner_.unitMoveFlagsCallback_(guid, synthFlags);
-            };
-        };
-        table[Opcode::SMSG_SPLINE_MOVE_SET_WALK_MODE] = makeSynthHandler(0x00000100u);
-        table[Opcode::SMSG_SPLINE_MOVE_SET_RUN_MODE]  = makeSynthHandler(0u);
-        table[Opcode::SMSG_SPLINE_MOVE_SET_FLYING]    = makeSynthHandler(0x01000000u | 0x00800000u);
-        table[Opcode::SMSG_SPLINE_MOVE_START_SWIM]    = makeSynthHandler(0x00200000u);
-        table[Opcode::SMSG_SPLINE_MOVE_STOP_SWIM]     = makeSynthHandler(0u);
-    }
-
-    // Spline speed: all opcodes share the same PackedGuid+float format, differing
-    // only in which member receives the value. Factory avoids 8 copy-pasted lambdas.
-    auto makeSplineSpeedHandler = [this](float MovementHandler::* member) {
-        return [this, member](network::Packet& packet) {
-            if (!packet.hasRemaining(5)) return;
-            uint64_t guid = packet.readPackedGuid();
-            if (!packet.hasRemaining(4)) return;
-            float speed = packet.readFloat();
-            if (guid == owner_.playerGuid && std::isfinite(speed) && speed > 0.01f && speed < 200.0f)
-                this->*member = speed;
-        };
-    };
-    table[Opcode::SMSG_SPLINE_SET_RUN_SPEED]      = makeSplineSpeedHandler(&MovementHandler::serverRunSpeed_);
-    table[Opcode::SMSG_SPLINE_SET_RUN_BACK_SPEED]  = makeSplineSpeedHandler(&MovementHandler::serverRunBackSpeed_);
-    table[Opcode::SMSG_SPLINE_SET_SWIM_SPEED]      = makeSplineSpeedHandler(&MovementHandler::serverSwimSpeed_);
-
-    // Force speed changes
-    table[Opcode::SMSG_FORCE_RUN_SPEED_CHANGE] = [this](network::Packet& packet) { handleForceRunSpeedChange(packet); };
-    table[Opcode::SMSG_FORCE_MOVE_ROOT] = [this](network::Packet& packet) { handleForceMoveRootState(packet, true); };
-    table[Opcode::SMSG_FORCE_MOVE_UNROOT] = [this](network::Packet& packet) { handleForceMoveRootState(packet, false); };
-    table[Opcode::SMSG_FORCE_WALK_SPEED_CHANGE] = [this](network::Packet& packet) {
-        handleForceSpeedChange(packet, "WALK_SPEED", Opcode::CMSG_FORCE_WALK_SPEED_CHANGE_ACK, &serverWalkSpeed_);
-    };
-    table[Opcode::SMSG_FORCE_RUN_BACK_SPEED_CHANGE] = [this](network::Packet& packet) {
-        handleForceSpeedChange(packet, "RUN_BACK_SPEED", Opcode::CMSG_FORCE_RUN_BACK_SPEED_CHANGE_ACK, &serverRunBackSpeed_);
-    };
-    table[Opcode::SMSG_FORCE_SWIM_SPEED_CHANGE] = [this](network::Packet& packet) {
-        handleForceSpeedChange(packet, "SWIM_SPEED", Opcode::CMSG_FORCE_SWIM_SPEED_CHANGE_ACK, &serverSwimSpeed_);
-    };
-    table[Opcode::SMSG_FORCE_SWIM_BACK_SPEED_CHANGE] = [this](network::Packet& packet) {
-        handleForceSpeedChange(packet, "SWIM_BACK_SPEED", Opcode::CMSG_FORCE_SWIM_BACK_SPEED_CHANGE_ACK, &serverSwimBackSpeed_);
-    };
-    table[Opcode::SMSG_FORCE_FLIGHT_SPEED_CHANGE] = [this](network::Packet& packet) {
-        handleForceSpeedChange(packet, "FLIGHT_SPEED", Opcode::CMSG_FORCE_FLIGHT_SPEED_CHANGE_ACK, &serverFlightSpeed_);
-    };
-    table[Opcode::SMSG_FORCE_FLIGHT_BACK_SPEED_CHANGE] = [this](network::Packet& packet) {
-        handleForceSpeedChange(packet, "FLIGHT_BACK_SPEED", Opcode::CMSG_FORCE_FLIGHT_BACK_SPEED_CHANGE_ACK, &serverFlightBackSpeed_);
-    };
-    table[Opcode::SMSG_FORCE_TURN_RATE_CHANGE] = [this](network::Packet& packet) {
-        handleForceSpeedChange(packet, "TURN_RATE", Opcode::CMSG_FORCE_TURN_RATE_CHANGE_ACK, &serverTurnRate_);
-    };
-    table[Opcode::SMSG_FORCE_PITCH_RATE_CHANGE] = [this](network::Packet& packet) {
-        handleForceSpeedChange(packet, "PITCH_RATE", Opcode::CMSG_FORCE_PITCH_RATE_CHANGE_ACK, &serverPitchRate_);
-    };
-
-    // Movement flag toggles
-    table[Opcode::SMSG_MOVE_SET_CAN_FLY] = [this](network::Packet& packet) {
-        handleForceMoveFlagChange(packet, "SET_CAN_FLY", Opcode::CMSG_MOVE_SET_CAN_FLY_ACK,
-            static_cast<uint32_t>(MovementFlags::CAN_FLY), true);
-    };
-    table[Opcode::SMSG_MOVE_UNSET_CAN_FLY] = [this](network::Packet& packet) {
-        handleForceMoveFlagChange(packet, "UNSET_CAN_FLY", Opcode::CMSG_MOVE_SET_CAN_FLY_ACK,
-            static_cast<uint32_t>(MovementFlags::CAN_FLY), false);
-    };
-    table[Opcode::SMSG_MOVE_FEATHER_FALL] = [this](network::Packet& packet) {
-        handleForceMoveFlagChange(packet, "FEATHER_FALL", Opcode::CMSG_MOVE_FEATHER_FALL_ACK,
-            static_cast<uint32_t>(MovementFlags::FEATHER_FALL), true);
-    };
-    table[Opcode::SMSG_MOVE_WATER_WALK] = [this](network::Packet& packet) {
-        handleForceMoveFlagChange(packet, "WATER_WALK", Opcode::CMSG_MOVE_WATER_WALK_ACK,
-            static_cast<uint32_t>(MovementFlags::WATER_WALK), true);
-    };
-    table[Opcode::SMSG_MOVE_SET_HOVER] = [this](network::Packet& packet) {
-        handleForceMoveFlagChange(packet, "SET_HOVER", Opcode::CMSG_MOVE_HOVER_ACK,
-            static_cast<uint32_t>(MovementFlags::HOVER), true);
-    };
-    table[Opcode::SMSG_MOVE_UNSET_HOVER] = [this](network::Packet& packet) {
-        handleForceMoveFlagChange(packet, "UNSET_HOVER", Opcode::CMSG_MOVE_HOVER_ACK,
-            static_cast<uint32_t>(MovementFlags::HOVER), false);
-    };
-    table[Opcode::SMSG_MOVE_KNOCK_BACK] = [this](network::Packet& packet) { handleMoveKnockBack(packet); };
-
-    // Teleport
-    for (auto op : { Opcode::MSG_MOVE_TELEPORT, Opcode::MSG_MOVE_TELEPORT_ACK }) {
-        table[op] = [this](network::Packet& packet) { handleTeleportAck(packet); };
-    }
-    table[Opcode::SMSG_NEW_WORLD] = [this](network::Packet& packet) { handleNewWorld(packet); };
-
-    // Taxi
-    table[Opcode::SMSG_SHOWTAXINODES] = [this](network::Packet& packet) { handleShowTaxiNodes(packet); };
-    table[Opcode::SMSG_ACTIVATETAXIREPLY] = [this](network::Packet& packet) { handleActivateTaxiReply(packet); };
-
-    // MSG_MOVE_* relay (other player movement)
-    for (auto op : { Opcode::MSG_MOVE_START_FORWARD, Opcode::MSG_MOVE_START_BACKWARD,
-                     Opcode::MSG_MOVE_STOP, Opcode::MSG_MOVE_START_STRAFE_LEFT,
-                     Opcode::MSG_MOVE_START_STRAFE_RIGHT, Opcode::MSG_MOVE_STOP_STRAFE,
-                     Opcode::MSG_MOVE_JUMP, Opcode::MSG_MOVE_START_TURN_LEFT,
-                     Opcode::MSG_MOVE_START_TURN_RIGHT, Opcode::MSG_MOVE_STOP_TURN,
-                     Opcode::MSG_MOVE_SET_FACING, Opcode::MSG_MOVE_FALL_LAND,
-                     Opcode::MSG_MOVE_HEARTBEAT, Opcode::MSG_MOVE_START_SWIM,
-                     Opcode::MSG_MOVE_STOP_SWIM, Opcode::MSG_MOVE_SET_WALK_MODE,
-                     Opcode::MSG_MOVE_SET_RUN_MODE, Opcode::MSG_MOVE_START_PITCH_UP,
-                     Opcode::MSG_MOVE_START_PITCH_DOWN, Opcode::MSG_MOVE_STOP_PITCH,
-                     Opcode::MSG_MOVE_START_ASCEND, Opcode::MSG_MOVE_STOP_ASCEND,
-                     Opcode::MSG_MOVE_START_DESCEND, Opcode::MSG_MOVE_SET_PITCH,
-                     Opcode::MSG_MOVE_GRAVITY_CHNG, Opcode::MSG_MOVE_UPDATE_CAN_FLY,
-                     Opcode::MSG_MOVE_UPDATE_CAN_TRANSITION_BETWEEN_SWIM_AND_FLY,
-                     Opcode::MSG_MOVE_ROOT, Opcode::MSG_MOVE_UNROOT }) {
-        table[op] = [this](network::Packet& packet) {
-            if (owner_.getState() == WorldState::IN_WORLD) handleOtherPlayerMovement(packet);
-        };
-    }
-
-    // MSG_MOVE_SET_*_SPEED relay
-    for (auto op : { Opcode::MSG_MOVE_SET_RUN_SPEED, Opcode::MSG_MOVE_SET_RUN_BACK_SPEED,
-                     Opcode::MSG_MOVE_SET_WALK_SPEED, Opcode::MSG_MOVE_SET_SWIM_SPEED,
-                     Opcode::MSG_MOVE_SET_SWIM_BACK_SPEED, Opcode::MSG_MOVE_SET_FLIGHT_SPEED,
-                     Opcode::MSG_MOVE_SET_FLIGHT_BACK_SPEED }) {
-        table[op] = [this](network::Packet& packet) {
-            if (owner_.getState() == WorldState::IN_WORLD) handleMoveSetSpeed(packet);
-        };
-    }
-
-    // ---- Client control & spline speed/flag changes ----
-
-    // Client control update
-    table[Opcode::SMSG_CLIENT_CONTROL_UPDATE] = [this](network::Packet& packet) {
-        handleClientControlUpdate(packet);
-    };
-
-    // Spline move flag changes for other units (unroot/unset_hover/water_walk)
-    for (auto op : {Opcode::SMSG_SPLINE_MOVE_UNROOT,
-                    Opcode::SMSG_SPLINE_MOVE_UNSET_HOVER,
-                    Opcode::SMSG_SPLINE_MOVE_WATER_WALK}) {
-        table[op] = [this](network::Packet& packet) {
-            // Minimal parse: PackedGuid only — no animation-relevant state change.
-            if (packet.hasRemaining(1)) {
-                (void)packet.readPackedGuid();
-            }
-        };
-    }
-
-    table[Opcode::SMSG_SPLINE_MOVE_UNSET_FLYING] = [this](network::Packet& packet) {
-        // PackedGuid + synthesised move-flags=0 → clears flying animation.
-        if (!packet.hasRemaining(1)) return;
-        uint64_t guid = packet.readPackedGuid();
-        if (guid == 0 || guid == owner_.playerGuid || !owner_.unitMoveFlagsCallback_) return;
-        owner_.unitMoveFlagsCallback_(guid, 0u); // clear flying/CAN_FLY
-    };
-
-    // Remaining spline speed opcodes — same factory as above.
-    table[Opcode::SMSG_SPLINE_SET_FLIGHT_SPEED]      = makeSplineSpeedHandler(&MovementHandler::serverFlightSpeed_);
-    table[Opcode::SMSG_SPLINE_SET_FLIGHT_BACK_SPEED]  = makeSplineSpeedHandler(&MovementHandler::serverFlightBackSpeed_);
-    table[Opcode::SMSG_SPLINE_SET_SWIM_BACK_SPEED]    = makeSplineSpeedHandler(&MovementHandler::serverSwimBackSpeed_);
-    table[Opcode::SMSG_SPLINE_SET_WALK_SPEED]          = makeSplineSpeedHandler(&MovementHandler::serverWalkSpeed_);
-    table[Opcode::SMSG_SPLINE_SET_TURN_RATE]           = makeSplineSpeedHandler(&MovementHandler::serverTurnRate_);
-    // Pitch rate not stored locally — consume packet to keep stream aligned.
-    table[Opcode::SMSG_SPLINE_SET_PITCH_RATE] = [](network::Packet& packet) { packet.skipAll(); };
-
-    // ---- Player movement flag changes (server-pushed) ----
-    table[Opcode::SMSG_MOVE_GRAVITY_DISABLE] = [this](network::Packet& packet) {
-        handleForceMoveFlagChange(packet, "GRAVITY_DISABLE", Opcode::CMSG_MOVE_GRAVITY_DISABLE_ACK,
-            static_cast<uint32_t>(MovementFlags::LEVITATING), true);
-    };
-    table[Opcode::SMSG_MOVE_GRAVITY_ENABLE] = [this](network::Packet& packet) {
-        handleForceMoveFlagChange(packet, "GRAVITY_ENABLE", Opcode::CMSG_MOVE_GRAVITY_ENABLE_ACK,
-            static_cast<uint32_t>(MovementFlags::LEVITATING), false);
-    };
-    table[Opcode::SMSG_MOVE_LAND_WALK] = [this](network::Packet& packet) {
-        handleForceMoveFlagChange(packet, "LAND_WALK", Opcode::CMSG_MOVE_WATER_WALK_ACK,
-            static_cast<uint32_t>(MovementFlags::WATER_WALK), false);
-    };
-    table[Opcode::SMSG_MOVE_NORMAL_FALL] = [this](network::Packet& packet) {
-        handleForceMoveFlagChange(packet, "NORMAL_FALL", Opcode::CMSG_MOVE_FEATHER_FALL_ACK,
-            static_cast<uint32_t>(MovementFlags::FEATHER_FALL), false);
-    };
-    table[Opcode::SMSG_MOVE_SET_CAN_TRANSITION_BETWEEN_SWIM_AND_FLY] = [this](network::Packet& packet) {
-        handleForceMoveFlagChange(packet, "SET_CAN_TRANSITION_SWIM_FLY",
-            Opcode::CMSG_MOVE_SET_CAN_TRANSITION_BETWEEN_SWIM_AND_FLY_ACK, 0, true);
-    };
-    table[Opcode::SMSG_MOVE_UNSET_CAN_TRANSITION_BETWEEN_SWIM_AND_FLY] = [this](network::Packet& packet) {
-        handleForceMoveFlagChange(packet, "UNSET_CAN_TRANSITION_SWIM_FLY",
-            Opcode::CMSG_MOVE_SET_CAN_TRANSITION_BETWEEN_SWIM_AND_FLY_ACK, 0, false);
-    };
-    table[Opcode::SMSG_MOVE_SET_COLLISION_HGT] = [this](network::Packet& packet) {
-        handleMoveSetCollisionHeight(packet);
-    };
-    table[Opcode::SMSG_MOVE_SET_FLIGHT] = [this](network::Packet& packet) {
-        handleForceMoveFlagChange(packet, "SET_FLIGHT", Opcode::CMSG_MOVE_FLIGHT_ACK,
-            static_cast<uint32_t>(MovementFlags::FLYING), true);
-    };
-    table[Opcode::SMSG_MOVE_UNSET_FLIGHT] = [this](network::Packet& packet) {
-        handleForceMoveFlagChange(packet, "UNSET_FLIGHT", Opcode::CMSG_MOVE_FLIGHT_ACK,
-            static_cast<uint32_t>(MovementFlags::FLYING), false);
-    };
-}
-
-// ============================================================
-// handleClientControlUpdate
-// ============================================================
-
-void MovementHandler::handleClientControlUpdate(network::Packet& packet) {
-    // Minimal parse: PackedGuid + uint8 allowMovement.
-    if (!packet.hasRemaining(2)) {
-        LOG_WARNING("SMSG_CLIENT_CONTROL_UPDATE too short: ", packet.getSize(), " bytes");
-        return;
-    }
-    uint8_t guidMask = packet.readUInt8();
-    size_t guidBytes = 0;
-    uint64_t controlGuid = 0;
-    for (int i = 0; i < 8; ++i) {
-        if (guidMask & (1u << i)) ++guidBytes;
-    }
-    if (!packet.hasRemaining(guidBytes) + 1) {
-        LOG_WARNING("SMSG_CLIENT_CONTROL_UPDATE malformed (truncated packed guid)");
-        packet.skipAll();
-        return;
-    }
-    for (int i = 0; i < 8; ++i) {
-        if (guidMask & (1u << i)) {
-            uint8_t b = packet.readUInt8();
-            controlGuid |= (static_cast<uint64_t>(b) << (i * 8));
-        }
-    }
-    bool allowMovement = (packet.readUInt8() != 0);
-    if (controlGuid == 0 || controlGuid == owner_.playerGuid) {
-        bool changed = (serverMovementAllowed_ != allowMovement);
-        serverMovementAllowed_ = allowMovement;
-        if (changed && !allowMovement) {
-            // Force-stop local movement immediately when server revokes control.
-            movementInfo.flags &= ~(static_cast<uint32_t>(MovementFlags::FORWARD) |
-                                    static_cast<uint32_t>(MovementFlags::BACKWARD) |
-                                    static_cast<uint32_t>(MovementFlags::STRAFE_LEFT) |
-                                    static_cast<uint32_t>(MovementFlags::STRAFE_RIGHT) |
-                                    static_cast<uint32_t>(MovementFlags::TURN_LEFT) |
-                                    static_cast<uint32_t>(MovementFlags::TURN_RIGHT));
-            owner_.sendMovement(Opcode::MSG_MOVE_STOP);
-            owner_.sendMovement(Opcode::MSG_MOVE_STOP_STRAFE);
-            owner_.sendMovement(Opcode::MSG_MOVE_STOP_TURN);
-            owner_.sendMovement(Opcode::MSG_MOVE_STOP_SWIM);
-            owner_.addSystemChatMessage("Movement disabled by server.");
-            owner_.fireAddonEvent("PLAYER_CONTROL_LOST", {});
-        } else if (changed && allowMovement) {
-            owner_.addSystemChatMessage("Movement re-enabled.");
-            owner_.fireAddonEvent("PLAYER_CONTROL_GAINED", {});
-        }
-    }
-}
-
-// ============================================================
-// Movement Timestamp
-// ============================================================
-
-uint32_t MovementHandler::nextMovementTimestampMs() {
-    auto now = std::chrono::steady_clock::now();
-    uint64_t elapsed = static_cast<uint64_t>(
-        std::chrono::duration_cast<std::chrono::milliseconds>(now - movementClockStart_).count()) + 1ULL;
-    if (elapsed > std::numeric_limits<uint32_t>::max()) {
-        movementClockStart_ = now;
-        elapsed = 1ULL;
-    }
-
-    uint32_t candidate = static_cast<uint32_t>(elapsed);
-    if (candidate <= lastMovementTimestampMs_) {
-        candidate = lastMovementTimestampMs_ + 1U;
-        if (candidate == 0) {
-            movementClockStart_ = now;
-            candidate = 1U;
-        }
-    }
-
-    lastMovementTimestampMs_ = candidate;
-    return candidate;
-}
-
-// ============================================================
-// sendMovement
-// ============================================================
-
-void MovementHandler::sendMovement(Opcode opcode) {
-    if (owner_.state != WorldState::IN_WORLD) {
-        LOG_WARNING("Cannot send movement in state: ", (int)owner_.state);
-        return;
-    }
-
-    // Block manual movement while taxi is active/mounted, but always allow
-    // stop/heartbeat opcodes so stuck states can be recovered.
-    bool taxiAllowed =
-        (opcode == Opcode::MSG_MOVE_HEARTBEAT) ||
-        (opcode == Opcode::MSG_MOVE_STOP) ||
-        (opcode == Opcode::MSG_MOVE_STOP_STRAFE) ||
-        (opcode == Opcode::MSG_MOVE_STOP_TURN) ||
-        (opcode == Opcode::MSG_MOVE_STOP_SWIM);
-    if (!serverMovementAllowed_ && !taxiAllowed) return;
-    if ((onTaxiFlight_ || taxiMountActive_) && !taxiAllowed) return;
-    if (owner_.resurrectPending_ && !taxiAllowed) return;
-
-    // Always send a strictly increasing non-zero client movement clock value.
-    const uint32_t movementTime = nextMovementTimestampMs();
-    movementInfo.time = movementTime;
-
-    if (opcode == Opcode::MSG_MOVE_SET_FACING &&
-        (isClassicLikeExpansion() || isActiveExpansion("tbc"))) {
-        const float facingDelta = core::coords::normalizeAngleRad(
-            movementInfo.orientation - lastFacingSentOrientation_);
-        const uint32_t sinceLastFacingMs =
-            lastFacingSendTimeMs_ != 0 && movementTime >= lastFacingSendTimeMs_
-                ? (movementTime - lastFacingSendTimeMs_)
-                : std::numeric_limits<uint32_t>::max();
-        if (std::abs(facingDelta) < 0.02f && sinceLastFacingMs < 200U) {
-            return;
-        }
-    }
-
-    // Track movement state transition for PLAYER_STARTED/STOPPED_MOVING events
-    const uint32_t kMoveMask = static_cast<uint32_t>(MovementFlags::FORWARD) |
-                               static_cast<uint32_t>(MovementFlags::BACKWARD) |
-                               static_cast<uint32_t>(MovementFlags::STRAFE_LEFT) |
-                               static_cast<uint32_t>(MovementFlags::STRAFE_RIGHT);
-    const bool wasMoving = (movementInfo.flags & kMoveMask) != 0;
-
-    // Cancel any timed (non-channeled) cast the moment the player starts moving.
-    if (owner_.isCasting() && !owner_.isChanneling()) {
-        const bool isPositionalMove =
-            opcode == Opcode::MSG_MOVE_START_FORWARD  ||
-            opcode == Opcode::MSG_MOVE_START_BACKWARD ||
-            opcode == Opcode::MSG_MOVE_START_STRAFE_LEFT  ||
-            opcode == Opcode::MSG_MOVE_START_STRAFE_RIGHT ||
-            opcode == Opcode::MSG_MOVE_JUMP;
-        if (isPositionalMove) {
-            owner_.cancelCast();
-        }
-    }
-
-    // Update movement flags based on opcode
-    switch (opcode) {
-        case Opcode::MSG_MOVE_START_FORWARD:
-            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::FORWARD);
-            break;
-        case Opcode::MSG_MOVE_START_BACKWARD:
-            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::BACKWARD);
-            break;
-        case Opcode::MSG_MOVE_STOP:
-            movementInfo.flags &= ~(static_cast<uint32_t>(MovementFlags::FORWARD) |
-                                    static_cast<uint32_t>(MovementFlags::BACKWARD));
-            break;
-        case Opcode::MSG_MOVE_START_STRAFE_LEFT:
-            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::STRAFE_LEFT);
-            break;
-        case Opcode::MSG_MOVE_START_STRAFE_RIGHT:
-            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::STRAFE_RIGHT);
-            break;
-        case Opcode::MSG_MOVE_STOP_STRAFE:
-            movementInfo.flags &= ~(static_cast<uint32_t>(MovementFlags::STRAFE_LEFT) |
-                                    static_cast<uint32_t>(MovementFlags::STRAFE_RIGHT));
-            break;
-        case Opcode::MSG_MOVE_JUMP:
-            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::FALLING);
-            isFalling_ = true;
-            fallStartMs_ = movementInfo.time;
-            movementInfo.fallTime = 0;
-            movementInfo.jumpVelocity = 7.96f;
-            {
-                const float facingRad = movementInfo.orientation;
-                movementInfo.jumpCosAngle = std::cos(facingRad);
-                movementInfo.jumpSinAngle = std::sin(facingRad);
-                const uint32_t horizFlags =
-                    static_cast<uint32_t>(MovementFlags::FORWARD) |
-                    static_cast<uint32_t>(MovementFlags::BACKWARD) |
-                    static_cast<uint32_t>(MovementFlags::STRAFE_LEFT) |
-                    static_cast<uint32_t>(MovementFlags::STRAFE_RIGHT);
-                const bool movingHoriz = (movementInfo.flags & horizFlags) != 0;
-                if (movingHoriz) {
-                    const bool isWalking = (movementInfo.flags & static_cast<uint32_t>(MovementFlags::WALKING)) != 0;
-                    movementInfo.jumpXYSpeed = isWalking ? 2.5f : (serverRunSpeed_ > 0.0f ? serverRunSpeed_ : 7.0f);
-                } else {
-                    movementInfo.jumpXYSpeed = 0.0f;
-                }
-            }
-            break;
-        case Opcode::MSG_MOVE_START_TURN_LEFT:
-            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::TURN_LEFT);
-            break;
-        case Opcode::MSG_MOVE_START_TURN_RIGHT:
-            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::TURN_RIGHT);
-            break;
-        case Opcode::MSG_MOVE_STOP_TURN:
-            movementInfo.flags &= ~(static_cast<uint32_t>(MovementFlags::TURN_LEFT) |
-                                    static_cast<uint32_t>(MovementFlags::TURN_RIGHT));
-            break;
-        case Opcode::MSG_MOVE_FALL_LAND:
-            movementInfo.flags &= ~static_cast<uint32_t>(MovementFlags::FALLING);
-            isFalling_ = false;
-            fallStartMs_ = 0;
-            movementInfo.fallTime = 0;
-            movementInfo.jumpVelocity = 0.0f;
-            movementInfo.jumpSinAngle = 0.0f;
-            movementInfo.jumpCosAngle = 0.0f;
-            movementInfo.jumpXYSpeed = 0.0f;
-            break;
-        case Opcode::MSG_MOVE_HEARTBEAT:
-            timeSinceLastMoveHeartbeat_ = 0.0f;
-            break;
-        case Opcode::MSG_MOVE_START_ASCEND:
-            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::ASCENDING);
-            movementInfo.flags &= ~static_cast<uint32_t>(MovementFlags::DESCENDING);
-            break;
-        case Opcode::MSG_MOVE_STOP_ASCEND:
-            movementInfo.flags &= ~static_cast<uint32_t>(MovementFlags::ASCENDING);
-            movementInfo.flags &= ~static_cast<uint32_t>(MovementFlags::DESCENDING);
-            break;
-        case Opcode::MSG_MOVE_START_DESCEND:
-            // Must set DESCENDING so outgoing movement packets carry the correct
-            // flag during flight descent. Only clearing ASCENDING left the flag
-            // field ambiguous (neither ascending nor descending).
-            movementInfo.flags &= ~static_cast<uint32_t>(MovementFlags::ASCENDING);
-            movementInfo.flags |= static_cast<uint32_t>(MovementFlags::DESCENDING);
-            break;
-        default:
-            break;
-    }
-
-    // Fire PLAYER_STARTED/STOPPED_MOVING on movement state transitions
-    {
-        const bool isMoving = (movementInfo.flags & kMoveMask) != 0;
-        if (isMoving && !wasMoving && owner_.addonEventCallback_)
-            owner_.addonEventCallback_("PLAYER_STARTED_MOVING", {});
-        else if (!isMoving && wasMoving && owner_.addonEventCallback_)
-            owner_.addonEventCallback_("PLAYER_STOPPED_MOVING", {});
-    }
-
-    if (opcode == Opcode::MSG_MOVE_SET_FACING) {
-        lastFacingSendTimeMs_ = movementInfo.time;
-        lastFacingSentOrientation_ = movementInfo.orientation;
-    }
-
-    // Keep fallTime current
-    if (isFalling_ && movementInfo.hasFlag(MovementFlags::FALLING)) {
-        uint32_t elapsed = (movementInfo.time >= fallStartMs_)
-                               ? (movementInfo.time - fallStartMs_)
-                               : 0u;
-        movementInfo.fallTime = elapsed;
-    } else if (!movementInfo.hasFlag(MovementFlags::FALLING)) {
-        if (isFalling_) {
-            isFalling_ = false;
-            fallStartMs_ = 0;
-        }
-        movementInfo.fallTime = 0;
-    }
-
-    if (onTaxiFlight_ || taxiMountActive_ || taxiActivatePending_ || taxiClientActive_) {
-        sanitizeMovementForTaxi();
-    }
-
-    bool includeTransportInWire = owner_.isOnTransport();
-    if (includeTransportInWire && owner_.transportManager_) {
-        if (auto* tr = owner_.transportManager_->getTransport(owner_.playerTransportGuid_); tr && tr->isM2) {
-            includeTransportInWire = false;
-        }
-    }
-
-    // Add transport data if player is on a server-recognized transport
-    if (includeTransportInWire) {
-        if (owner_.transportManager_) {
-            glm::vec3 composed = owner_.transportManager_->getPlayerWorldPosition(owner_.playerTransportGuid_, owner_.playerTransportOffset_);
-            movementInfo.x = composed.x;
-            movementInfo.y = composed.y;
-            movementInfo.z = composed.z;
-        }
-        movementInfo.flags |= static_cast<uint32_t>(MovementFlags::ONTRANSPORT);
-        movementInfo.transportGuid = owner_.playerTransportGuid_;
-        movementInfo.transportX = owner_.playerTransportOffset_.x;
-        movementInfo.transportY = owner_.playerTransportOffset_.y;
-        movementInfo.transportZ = owner_.playerTransportOffset_.z;
-        movementInfo.transportTime = movementInfo.time;
-        movementInfo.transportSeat = -1;
-        movementInfo.transportTime2 = movementInfo.time;
-
-        float transportYawCanonical = 0.0f;
-        if (owner_.transportManager_) {
-            if (auto* tr = owner_.transportManager_->getTransport(owner_.playerTransportGuid_); tr) {
-                if (tr->hasServerYaw) {
-                    transportYawCanonical = tr->serverYaw;
-                } else {
-                    transportYawCanonical = glm::eulerAngles(tr->rotation).z;
-                }
-            }
-        }
-
-        movementInfo.transportO =
-            core::coords::normalizeAngleRad(movementInfo.orientation - transportYawCanonical);
-    } else {
-        movementInfo.flags &= ~static_cast<uint32_t>(MovementFlags::ONTRANSPORT);
-        movementInfo.transportGuid = 0;
-        movementInfo.transportSeat = -1;
-    }
-
-    if (opcode == Opcode::MSG_MOVE_HEARTBEAT && isClassicLikeExpansion()) {
-        const uint32_t locomotionFlags =
-            static_cast<uint32_t>(MovementFlags::FORWARD) |
-            static_cast<uint32_t>(MovementFlags::BACKWARD) |
-            static_cast<uint32_t>(MovementFlags::STRAFE_LEFT) |
-            static_cast<uint32_t>(MovementFlags::STRAFE_RIGHT) |
-            static_cast<uint32_t>(MovementFlags::TURN_LEFT) |
-            static_cast<uint32_t>(MovementFlags::TURN_RIGHT) |
-            static_cast<uint32_t>(MovementFlags::ASCENDING) |
-            static_cast<uint32_t>(MovementFlags::FALLING) |
-            static_cast<uint32_t>(MovementFlags::FALLINGFAR) |
-            static_cast<uint32_t>(MovementFlags::SWIMMING);
-        const bool stationaryIdle =
-            !onTaxiFlight_ &&
-            !taxiMountActive_ &&
-            !taxiActivatePending_ &&
-            !taxiClientActive_ &&
-            !includeTransportInWire &&
-            (movementInfo.flags & locomotionFlags) == 0;
-        const uint32_t sinceLastHeartbeatMs =
-            lastHeartbeatSendTimeMs_ != 0 && movementTime >= lastHeartbeatSendTimeMs_
-                ? (movementTime - lastHeartbeatSendTimeMs_)
-                : std::numeric_limits<uint32_t>::max();
-        const bool unchangedState =
-            std::abs(movementInfo.x - lastHeartbeatX_) < 0.01f &&
-            std::abs(movementInfo.y - lastHeartbeatY_) < 0.01f &&
-            std::abs(movementInfo.z - lastHeartbeatZ_) < 0.01f &&
-            movementInfo.flags == lastHeartbeatFlags_ &&
-            movementInfo.transportGuid == lastHeartbeatTransportGuid_;
-        if (stationaryIdle && unchangedState && sinceLastHeartbeatMs < 1500U) {
-            timeSinceLastMoveHeartbeat_ = 0.0f;
-            return;
-        }
-        const uint32_t sinceLastNonHeartbeatMoveMs =
-            lastNonHeartbeatMoveSendTimeMs_ != 0 && movementTime >= lastNonHeartbeatMoveSendTimeMs_
-                ? (movementTime - lastNonHeartbeatMoveSendTimeMs_)
-                : std::numeric_limits<uint32_t>::max();
-        if (sinceLastNonHeartbeatMoveMs < 350U) {
-            timeSinceLastMoveHeartbeat_ = 0.0f;
-            return;
-        }
-    }
-
-    LOG_DEBUG("Sending movement packet: opcode=0x", std::hex,
-              wireOpcode(opcode), std::dec,
-              (includeTransportInWire ? " ONTRANSPORT" : ""));
-
-    // Convert canonical → server coordinates for the wire
-    MovementInfo wireInfo = movementInfo;
-    glm::vec3 serverPos = core::coords::canonicalToServer(glm::vec3(wireInfo.x, wireInfo.y, wireInfo.z));
-    wireInfo.x = serverPos.x;
-    wireInfo.y = serverPos.y;
-    wireInfo.z = serverPos.z;
-
-    // Periodic position audit — DEBUG to avoid flooding production logs.
-    if (opcode == Opcode::MSG_MOVE_HEARTBEAT && ++heartbeatLogCount_ % 30 == 0) {
-        LOG_DEBUG("HEARTBEAT pos canonical=(", movementInfo.x, ",", movementInfo.y, ",", movementInfo.z,
-                  ") wire=(", wireInfo.x, ",", wireInfo.y, ",", wireInfo.z, ")");
-    }
-
-    wireInfo.orientation = core::coords::canonicalToServerYaw(wireInfo.orientation);
-
-    if (includeTransportInWire) {
-        glm::vec3 serverTransportPos = core::coords::canonicalToServer(
-            glm::vec3(wireInfo.transportX, wireInfo.transportY, wireInfo.transportZ));
-        wireInfo.transportX = serverTransportPos.x;
-        wireInfo.transportY = serverTransportPos.y;
-        wireInfo.transportZ = serverTransportPos.z;
-        wireInfo.transportO = core::coords::normalizeAngleRad(-wireInfo.transportO);
-    }
-
-    // Build and send movement packet (expansion-specific format)
-    auto packet = owner_.packetParsers_
-        ? owner_.packetParsers_->buildMovementPacket(opcode, wireInfo, owner_.playerGuid)
-        : MovementPacket::build(opcode, wireInfo, owner_.playerGuid);
-    owner_.socket->send(packet);
-
-    if (opcode == Opcode::MSG_MOVE_HEARTBEAT) {
-        lastHeartbeatSendTimeMs_ = movementInfo.time;
-        lastHeartbeatX_ = movementInfo.x;
-        lastHeartbeatY_ = movementInfo.y;
-        lastHeartbeatZ_ = movementInfo.z;
-        lastHeartbeatFlags_ = movementInfo.flags;
-        lastHeartbeatTransportGuid_ = movementInfo.transportGuid;
-    } else {
-        lastNonHeartbeatMoveSendTimeMs_ = movementInfo.time;
-    }
-}
-
-// ============================================================
-// sanitizeMovementForTaxi
-// ============================================================
-
-void MovementHandler::sanitizeMovementForTaxi() {
-    constexpr uint32_t kClearTaxiFlags =
-        static_cast<uint32_t>(MovementFlags::FORWARD) |
-        static_cast<uint32_t>(MovementFlags::BACKWARD) |
-        static_cast<uint32_t>(MovementFlags::STRAFE_LEFT) |
-        static_cast<uint32_t>(MovementFlags::STRAFE_RIGHT) |
-        static_cast<uint32_t>(MovementFlags::TURN_LEFT) |
-        static_cast<uint32_t>(MovementFlags::TURN_RIGHT) |
-        static_cast<uint32_t>(MovementFlags::PITCH_UP) |
-        static_cast<uint32_t>(MovementFlags::PITCH_DOWN) |
-        static_cast<uint32_t>(MovementFlags::FALLING) |
-        static_cast<uint32_t>(MovementFlags::FALLINGFAR) |
-        static_cast<uint32_t>(MovementFlags::SWIMMING);
-
-    movementInfo.flags &= ~kClearTaxiFlags;
-    movementInfo.fallTime = 0;
-    movementInfo.jumpVelocity = 0.0f;
-    movementInfo.jumpSinAngle = 0.0f;
-    movementInfo.jumpCosAngle = 0.0f;
-    movementInfo.jumpXYSpeed = 0.0f;
-    movementInfo.pitch = 0.0f;
-}
-
-// ============================================================
-// forceClearTaxiAndMovementState
-// ============================================================
-
-void MovementHandler::forceClearTaxiAndMovementState() {
-    taxiActivatePending_ = false;
-    taxiActivateTimer_ = 0.0f;
-    taxiClientActive_ = false;
-    taxiClientPath_.clear();
-    taxiRecoverPending_ = false;
-    taxiStartGrace_ = 0.0f;
-    onTaxiFlight_ = false;
-
-    if (taxiMountActive_ && owner_.mountCallback_) {
-        owner_.mountCallback_(0);
-    }
-    taxiMountActive_ = false;
-    taxiMountDisplayId_ = 0;
-    owner_.currentMountDisplayId_ = 0;
-    owner_.vehicleId_ = 0;
-    // Death/resurrect state is intentionally NOT cleared here.
-    // Previously this method reset 10 death-related fields despite being named
-    // "forceClearTaxiAndMovementState", which could cancel pending resurrections
-    // or clear death state on taxi dismount. Death state is managed by
-    // entity_controller (markPlayerDead) and the resurrect packet handlers.
-
-    movementInfo.flags = 0;
-    movementInfo.flags2 = 0;
-    movementInfo.transportGuid = 0;
-    owner_.clearPlayerTransport();
-
-    if (owner_.socket && owner_.state == WorldState::IN_WORLD) {
-        sendMovement(Opcode::MSG_MOVE_STOP);
-        sendMovement(Opcode::MSG_MOVE_STOP_STRAFE);
-        sendMovement(Opcode::MSG_MOVE_STOP_TURN);
-        sendMovement(Opcode::MSG_MOVE_STOP_SWIM);
-        sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
-    }
-
-    LOG_INFO("Force-cleared taxi/movement state");
-}
-
-// ============================================================
-// setPosition / setOrientation
-// ============================================================
-
-void MovementHandler::setPosition(float x, float y, float z) {
-    movementInfo.x = x;
-    movementInfo.y = y;
-    movementInfo.z = z;
-}
-
-void MovementHandler::setOrientation(float orientation) {
-    movementInfo.orientation = orientation;
-}
-
-// ============================================================
-// dismount
-// ============================================================
-
-void MovementHandler::dismount() {
-    if (!owner_.socket) return;
-    uint32_t savedMountAura = owner_.mountAuraSpellId_;
-    if (owner_.currentMountDisplayId_ != 0 || taxiMountActive_) {
-        if (owner_.mountCallback_) {
-            owner_.mountCallback_(0);
-        }
-        owner_.currentMountDisplayId_ = 0;
-        taxiMountActive_ = false;
-        taxiMountDisplayId_ = 0;
-        owner_.mountAuraSpellId_ = 0;
-        LOG_INFO("Dismount: cleared local mount state");
-    }
-    uint16_t cancelMountWire = wireOpcode(Opcode::CMSG_CANCEL_MOUNT_AURA);
-    if (cancelMountWire != 0xFFFF) {
-        network::Packet pkt(cancelMountWire);
-        owner_.socket->send(pkt);
-        LOG_INFO("Sent CMSG_CANCEL_MOUNT_AURA");
-    } else if (savedMountAura != 0) {
-        auto pkt = CancelAuraPacket::build(savedMountAura);
-        owner_.socket->send(pkt);
-        LOG_INFO("Sent CMSG_CANCEL_AURA (mount spell ", savedMountAura, ") — Classic fallback");
-    } else {
-        for (const auto& a : owner_.getPlayerAuras()) {
-            if (!a.isEmpty() && a.maxDurationMs < 0 && a.casterGuid == owner_.playerGuid) {
-                auto pkt = CancelAuraPacket::build(a.spellId);
-                owner_.socket->send(pkt);
-                LOG_INFO("Sent CMSG_CANCEL_AURA (spell ", a.spellId, ") — brute force dismount");
-            }
-        }
-    }
-}
-
-// ============================================================
-// Force Speed / Root / Flag Change Handlers
-// ============================================================
-
-// Shared force-ACK packet builder. All server-forced movement changes (speed,
-// root, flag, collision-height, knockback) require the same ACK structure:
-// GUID + counter + movement payload with server-space coordinates. Centralised
-// here so transport coordinate conversion can't diverge between handlers.
-network::Packet MovementHandler::buildForceAck(Opcode ackOpcode, uint32_t counter) {
-    network::Packet ack(wireOpcode(ackOpcode));
-    const bool legacyGuid =
-        isActiveExpansion("classic") || isActiveExpansion("tbc") || isActiveExpansion("turtle");
-    if (legacyGuid) {
-        ack.writeUInt64(owner_.playerGuid);
-    } else {
-        ack.writePackedGuid(owner_.playerGuid);
-    }
-    ack.writeUInt32(counter);
-
-    MovementInfo wire = movementInfo;
-    wire.time = nextMovementTimestampMs();
-    if (wire.hasFlag(MovementFlags::ONTRANSPORT)) {
-        wire.transportTime = wire.time;
-        wire.transportTime2 = wire.time;
-    }
-    glm::vec3 serverPos = core::coords::canonicalToServer(glm::vec3(wire.x, wire.y, wire.z));
-    wire.x = serverPos.x;
-    wire.y = serverPos.y;
-    wire.z = serverPos.z;
-    if (wire.hasFlag(MovementFlags::ONTRANSPORT)) {
-        glm::vec3 serverTransport =
-            core::coords::canonicalToServer(glm::vec3(wire.transportX, wire.transportY, wire.transportZ));
-        wire.transportX = serverTransport.x;
-        wire.transportY = serverTransport.y;
-        wire.transportZ = serverTransport.z;
-    }
-    if (owner_.packetParsers_) {
-        owner_.packetParsers_->writeMovementPayload(ack, wire);
-    } else {
-        MovementPacket::writeMovementPayload(ack, wire);
-    }
-    return ack;
-}
-
-void MovementHandler::handleForceSpeedChange(network::Packet& packet, const char* name,
-                                              Opcode ackOpcode, float* speedStorage) {
-    const bool fscTbcLike = isClassicLikeExpansion() || isActiveExpansion("tbc");
-    uint64_t guid = fscTbcLike
-        ? packet.readUInt64() : packet.readPackedGuid();
-    uint32_t counter = packet.readUInt32();
-
-    size_t remaining = packet.getRemainingSize();
-    if (remaining >= 8) {
-        packet.readUInt32();
-    } else if (remaining >= 5) {
-        packet.readUInt8();
-    }
-    float newSpeed = packet.readFloat();
-
-    LOG_INFO("SMSG_FORCE_", name, "_CHANGE: guid=0x", std::hex, guid, std::dec,
-             " counter=", counter, " speed=", newSpeed);
-
-    if (guid != owner_.playerGuid) return;
-
-    // Validate BEFORE sending ACK — if we echo a bad speed back to the server
-    // but don't apply it locally, the client and server desync on movement speed.
-    if (std::isnan(newSpeed) || newSpeed < 0.1f || newSpeed > 100.0f) {
-        LOG_WARNING("Ignoring invalid ", name, " speed: ", newSpeed);
-        return;
-    }
-
-    if (owner_.socket) {
-        auto ack = buildForceAck(ackOpcode, counter);
-        ack.writeFloat(newSpeed);
-        owner_.socket->send(ack);
-    }
-
-    if (speedStorage) *speedStorage = newSpeed;
-}
-
-void MovementHandler::handleForceRunSpeedChange(network::Packet& packet) {
-    handleForceSpeedChange(packet, "RUN_SPEED", Opcode::CMSG_FORCE_RUN_SPEED_CHANGE_ACK, &serverRunSpeed_);
-
-    if (!onTaxiFlight_ && !taxiMountActive_ && owner_.currentMountDisplayId_ != 0 && serverRunSpeed_ <= 8.5f) {
-        LOG_INFO("Auto-clearing mount from speed change: speed=", serverRunSpeed_,
-                 " displayId=", owner_.currentMountDisplayId_);
-        owner_.currentMountDisplayId_ = 0;
-        if (owner_.mountCallback_) {
-            owner_.mountCallback_(0);
-        }
-    }
-}
-
-void MovementHandler::handleForceMoveRootState(network::Packet& packet, bool rooted) {
-    const bool rootTbc = isClassicLikeExpansion() || isActiveExpansion("tbc");
-    if (packet.getRemainingSize() < (rootTbc ? 8u : 2u)) return;
-    uint64_t guid = rootTbc
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(4)) return;
-    uint32_t counter = packet.readUInt32();
-
-    LOG_INFO(rooted ? "SMSG_FORCE_MOVE_ROOT" : "SMSG_FORCE_MOVE_UNROOT",
-             ": guid=0x", std::hex, guid, std::dec, " counter=", counter);
-
-    if (guid != owner_.playerGuid) return;
-
-    if (rooted) {
-        movementInfo.flags |= static_cast<uint32_t>(MovementFlags::ROOT);
-    } else {
-        movementInfo.flags &= ~static_cast<uint32_t>(MovementFlags::ROOT);
-    }
-
-    if (!owner_.socket) return;
-    Opcode ackOp = rooted ? Opcode::CMSG_FORCE_MOVE_ROOT_ACK : Opcode::CMSG_FORCE_MOVE_UNROOT_ACK;
-    if (wireOpcode(ackOp) == 0xFFFF) return;
-    owner_.socket->send(buildForceAck(ackOp, counter));
-}
-
-void MovementHandler::handleForceMoveFlagChange(network::Packet& packet, const char* name,
-                                                  Opcode ackOpcode, uint32_t flag, bool set) {
-    const bool fmfTbcLike = isClassicLikeExpansion() || isActiveExpansion("tbc");
-    if (packet.getRemainingSize() < (fmfTbcLike ? 8u : 2u)) return;
-    uint64_t guid = fmfTbcLike
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(4)) return;
-    uint32_t counter = packet.readUInt32();
-
-    LOG_INFO("SMSG_FORCE_", name, ": guid=0x", std::hex, guid, std::dec, " counter=", counter);
-
-    if (guid != owner_.playerGuid) return;
-
-    if (flag != 0) {
-        if (set) {
-            movementInfo.flags |= flag;
-        } else {
-            movementInfo.flags &= ~flag;
-        }
-    }
-
-    if (!owner_.socket) return;
-    if (wireOpcode(ackOpcode) == 0xFFFF) return;
-    owner_.socket->send(buildForceAck(ackOpcode, counter));
-}
-
-void MovementHandler::handleMoveSetCollisionHeight(network::Packet& packet) {
-    const bool legacyGuid = isClassicLikeExpansion() || isActiveExpansion("tbc");
-    if (packet.getRemainingSize() < (legacyGuid ? 8u : 2u)) return;
-    uint64_t guid = legacyGuid ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(8)) return;
-    uint32_t counter = packet.readUInt32();
-    float height = packet.readFloat();
-
-    LOG_INFO("SMSG_MOVE_SET_COLLISION_HGT: guid=0x", std::hex, guid, std::dec,
-             " counter=", counter, " height=", height);
-
-    if (guid != owner_.playerGuid) return;
-    if (!owner_.socket) return;
-
-    if (wireOpcode(Opcode::CMSG_MOVE_SET_COLLISION_HGT_ACK) == 0xFFFF) return;
-    // buildForceAck now handles transport coordinate conversion, fixing the
-    // previous omission that caused desync when riding boats/zeppelins.
-    auto ack = buildForceAck(Opcode::CMSG_MOVE_SET_COLLISION_HGT_ACK, counter);
-    ack.writeFloat(height);
-    owner_.socket->send(ack);
-}
-
-void MovementHandler::handleMoveKnockBack(network::Packet& packet) {
-    const bool mkbTbc = isClassicLikeExpansion() || isActiveExpansion("tbc");
-    if (packet.getRemainingSize() < (mkbTbc ? 8u : 2u)) return;
-    uint64_t guid = mkbTbc
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(20)) return;
-    uint32_t counter = packet.readUInt32();
-    float vcos    = packet.readFloat();
-    float vsin    = packet.readFloat();
-    float hspeed  = packet.readFloat();
-    float vspeed  = packet.readFloat();
-
-    LOG_INFO("SMSG_MOVE_KNOCK_BACK: guid=0x", std::hex, guid, std::dec,
-             " counter=", counter, " vcos=", vcos, " vsin=", vsin,
-             " hspeed=", hspeed, " vspeed=", vspeed);
-
-    if (guid != owner_.playerGuid) return;
-
-    if (owner_.knockBackCallback_) {
-        owner_.knockBackCallback_(vcos, vsin, hspeed, vspeed);
-    }
-
-    if (!owner_.socket) return;
-    if (wireOpcode(Opcode::CMSG_MOVE_KNOCK_BACK_ACK) == 0xFFFF) return;
-    owner_.socket->send(buildForceAck(Opcode::CMSG_MOVE_KNOCK_BACK_ACK, counter));
-}
-
-// ============================================================
-// Other Player / Creature Movement Handlers
-// ============================================================
-
-void MovementHandler::handleMoveSetSpeed(network::Packet& packet) {
-    const bool useFull = isClassicLikeExpansion() || isActiveExpansion("tbc");
-    uint64_t moverGuid = useFull
-        ? packet.readUInt64() : packet.readPackedGuid();
-
-    const size_t remaining = packet.getRemainingSize();
-    if (remaining < 4) return;
-    if (remaining > 4) {
-        packet.setReadPos(packet.getSize() - 4);
-    }
-
-    float speed = packet.readFloat();
-    if (!std::isfinite(speed) || speed <= 0.01f || speed > 200.0f) return;
-
-    if (moverGuid != owner_.playerGuid) return;
-    const uint16_t wireOp = packet.getOpcode();
-    if      (wireOp == wireOpcode(Opcode::MSG_MOVE_SET_RUN_SPEED))        serverRunSpeed_      = speed;
-    else if (wireOp == wireOpcode(Opcode::MSG_MOVE_SET_RUN_BACK_SPEED))   serverRunBackSpeed_  = speed;
-    else if (wireOp == wireOpcode(Opcode::MSG_MOVE_SET_WALK_SPEED))       serverWalkSpeed_     = speed;
-    else if (wireOp == wireOpcode(Opcode::MSG_MOVE_SET_SWIM_SPEED))       serverSwimSpeed_     = speed;
-    else if (wireOp == wireOpcode(Opcode::MSG_MOVE_SET_SWIM_BACK_SPEED))  serverSwimBackSpeed_ = speed;
-    else if (wireOp == wireOpcode(Opcode::MSG_MOVE_SET_FLIGHT_SPEED))     serverFlightSpeed_   = speed;
-    else if (wireOp == wireOpcode(Opcode::MSG_MOVE_SET_FLIGHT_BACK_SPEED))serverFlightBackSpeed_= speed;
-}
-
-void MovementHandler::handleOtherPlayerMovement(network::Packet& packet) {
-    const bool otherMoveTbc = isClassicLikeExpansion() || isActiveExpansion("tbc");
-    uint64_t moverGuid = otherMoveTbc
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (moverGuid == owner_.playerGuid || moverGuid == 0) {
-        return;
-    }
-
-    MovementInfo info = {};
-    info.flags = packet.readUInt32();
-    uint8_t flags2Size = owner_.packetParsers_ ? owner_.packetParsers_->movementFlags2Size() : 2;
-    if (flags2Size == 2) info.flags2 = packet.readUInt16();
-    else if (flags2Size == 1) info.flags2 = packet.readUInt8();
-    info.time = packet.readUInt32();
-    info.x = packet.readFloat();
-    info.y = packet.readFloat();
-    info.z = packet.readFloat();
-    info.orientation = packet.readFloat();
-
-    const uint32_t wireTransportFlag = owner_.packetParsers_ ? owner_.packetParsers_->wireOnTransportFlag() : 0x00000200;
-    const bool onTransport = (info.flags & wireTransportFlag) != 0;
-    uint64_t transportGuid = 0;
-    float tLocalX = 0, tLocalY = 0, tLocalZ = 0, tLocalO = 0;
-    if (onTransport) {
-        transportGuid = packet.readPackedGuid();
-        tLocalX = packet.readFloat();
-        tLocalY = packet.readFloat();
-        tLocalZ = packet.readFloat();
-        tLocalO = packet.readFloat();
-        if (flags2Size >= 1) {
-            /*uint32_t transportTime =*/ packet.readUInt32();
-        }
-        if (flags2Size >= 2) {
-            /*int8_t transportSeat =*/ packet.readUInt8();
-            if (info.flags2 & 0x0200) {
-                /*uint32_t transportTime2 =*/ packet.readUInt32();
-            }
-        }
-    }
-
-    auto entity = owner_.getEntityManager().getEntity(moverGuid);
-    if (!entity) {
-        return;
-    }
-
-    glm::vec3 canonical = core::coords::serverToCanonical(glm::vec3(info.x, info.y, info.z));
-    float canYaw = core::coords::serverToCanonicalYaw(info.orientation);
-
-    if (onTransport && transportGuid != 0 && owner_.transportManager_) {
-        glm::vec3 localCanonical = core::coords::serverToCanonical(glm::vec3(tLocalX, tLocalY, tLocalZ));
-        owner_.setTransportAttachment(moverGuid, entity->getType(), transportGuid, localCanonical, true,
-                               core::coords::serverToCanonicalYaw(tLocalO));
-        glm::vec3 worldPos = owner_.transportManager_->getPlayerWorldPosition(transportGuid, localCanonical);
-        canonical = worldPos;
-    } else if (!onTransport) {
-        owner_.clearTransportAttachment(moverGuid);
-    }
-
-    uint32_t durationMs = 120;
-    auto itPrev = otherPlayerMoveTimeMs_.find(moverGuid);
-    if (itPrev != otherPlayerMoveTimeMs_.end()) {
-        uint32_t rawDt = info.time - itPrev->second;
-        if (rawDt >= 20 && rawDt <= 2000) {
-            float fDt = static_cast<float>(rawDt);
-            auto& smoothed = otherPlayerSmoothedIntervalMs_[moverGuid];
-            if (smoothed < 1.0f) smoothed = fDt;
-            smoothed = 0.7f * smoothed + 0.3f * fDt;
-            float clamped = std::max(60.0f, std::min(500.0f, smoothed));
-            durationMs = static_cast<uint32_t>(clamped);
-        }
-    }
-    otherPlayerMoveTimeMs_[moverGuid] = info.time;
-
-    const uint16_t wireOp = packet.getOpcode();
-    const bool isStopOpcode =
-        (wireOp == wireOpcode(Opcode::MSG_MOVE_STOP)) ||
-        (wireOp == wireOpcode(Opcode::MSG_MOVE_STOP_STRAFE)) ||
-        (wireOp == wireOpcode(Opcode::MSG_MOVE_STOP_TURN)) ||
-        (wireOp == wireOpcode(Opcode::MSG_MOVE_STOP_SWIM)) ||
-        (wireOp == wireOpcode(Opcode::MSG_MOVE_FALL_LAND));
-    const bool isJumpOpcode  = (wireOp == wireOpcode(Opcode::MSG_MOVE_JUMP));
-
-    const float entityDuration = isStopOpcode ? 0.0f : (durationMs / 1000.0f);
-    entity->startMoveTo(canonical.x, canonical.y, canonical.z, canYaw, entityDuration);
-
-    if (owner_.creatureMoveCallback_) {
-        const uint32_t notifyDuration = isStopOpcode ? 0u : durationMs;
-        owner_.creatureMoveCallback_(moverGuid, canonical.x, canonical.y, canonical.z, notifyDuration);
-    }
-
-    if (owner_.unitAnimHintCallback_ && isJumpOpcode) {
-        owner_.unitAnimHintCallback_(moverGuid, 38u);
-    }
-
-    if (owner_.unitMoveFlagsCallback_) {
-        owner_.unitMoveFlagsCallback_(moverGuid, info.flags);
-    }
-}
-
-void MovementHandler::handleCompressedMoves(network::Packet& packet) {
-    std::vector<uint8_t> decompressedStorage;
-    const std::vector<uint8_t>* dataPtr = &packet.getData();
-
-    const auto& rawData = packet.getData();
-    const bool hasCompressedWrapper =
-        rawData.size() >= 6 &&
-        rawData[4] == 0x78 &&
-        (rawData[5] == 0x01 || rawData[5] == 0x9C ||
-         rawData[5] == 0xDA || rawData[5] == 0x5E);
-    if (hasCompressedWrapper) {
-        uint32_t decompressedSize = static_cast<uint32_t>(rawData[0]) |
-                                    (static_cast<uint32_t>(rawData[1]) << 8) |
-                                    (static_cast<uint32_t>(rawData[2]) << 16) |
-                                    (static_cast<uint32_t>(rawData[3]) << 24);
-        if (decompressedSize == 0 || decompressedSize > 65536) {
-            LOG_WARNING("SMSG_COMPRESSED_MOVES: bad decompressedSize=", decompressedSize);
-            return;
-        }
-
-        decompressedStorage.resize(decompressedSize);
-        uLongf destLen = decompressedSize;
-        int ret = uncompress(decompressedStorage.data(), &destLen,
-                             rawData.data() + 4, rawData.size() - 4);
-        if (ret != Z_OK) {
-            LOG_WARNING("SMSG_COMPRESSED_MOVES: zlib error ", ret);
-            return;
-        }
-
-        decompressedStorage.resize(destLen);
-        dataPtr = &decompressedStorage;
-    }
-
-    const auto& data = *dataPtr;
-    const size_t dataLen = data.size();
-
-    uint16_t monsterMoveWire          = wireOpcode(Opcode::SMSG_MONSTER_MOVE);
-    uint16_t monsterMoveTransportWire = wireOpcode(Opcode::SMSG_MONSTER_MOVE_TRANSPORT);
-
-    const std::array<uint16_t, 29> kMoveOpcodes = {
-        wireOpcode(Opcode::MSG_MOVE_START_FORWARD),
-        wireOpcode(Opcode::MSG_MOVE_START_BACKWARD),
-        wireOpcode(Opcode::MSG_MOVE_STOP),
-        wireOpcode(Opcode::MSG_MOVE_START_STRAFE_LEFT),
-        wireOpcode(Opcode::MSG_MOVE_START_STRAFE_RIGHT),
-        wireOpcode(Opcode::MSG_MOVE_STOP_STRAFE),
-        wireOpcode(Opcode::MSG_MOVE_JUMP),
-        wireOpcode(Opcode::MSG_MOVE_START_TURN_LEFT),
-        wireOpcode(Opcode::MSG_MOVE_START_TURN_RIGHT),
-        wireOpcode(Opcode::MSG_MOVE_STOP_TURN),
-        wireOpcode(Opcode::MSG_MOVE_SET_FACING),
-        wireOpcode(Opcode::MSG_MOVE_FALL_LAND),
-        wireOpcode(Opcode::MSG_MOVE_HEARTBEAT),
-        wireOpcode(Opcode::MSG_MOVE_START_SWIM),
-        wireOpcode(Opcode::MSG_MOVE_STOP_SWIM),
-        wireOpcode(Opcode::MSG_MOVE_SET_WALK_MODE),
-        wireOpcode(Opcode::MSG_MOVE_SET_RUN_MODE),
-        wireOpcode(Opcode::MSG_MOVE_START_PITCH_UP),
-        wireOpcode(Opcode::MSG_MOVE_START_PITCH_DOWN),
-        wireOpcode(Opcode::MSG_MOVE_STOP_PITCH),
-        wireOpcode(Opcode::MSG_MOVE_START_ASCEND),
-        wireOpcode(Opcode::MSG_MOVE_STOP_ASCEND),
-        wireOpcode(Opcode::MSG_MOVE_START_DESCEND),
-        wireOpcode(Opcode::MSG_MOVE_SET_PITCH),
-        wireOpcode(Opcode::MSG_MOVE_GRAVITY_CHNG),
-        wireOpcode(Opcode::MSG_MOVE_UPDATE_CAN_FLY),
-        wireOpcode(Opcode::MSG_MOVE_UPDATE_CAN_TRANSITION_BETWEEN_SWIM_AND_FLY),
-        wireOpcode(Opcode::MSG_MOVE_ROOT),
-        wireOpcode(Opcode::MSG_MOVE_UNROOT),
-    };
-
-    struct CompressedMoveSubPacket {
-        uint16_t opcode = 0;
-        std::vector<uint8_t> payload;
-    };
-    struct DecodeResult {
-        bool ok = false;
-        bool overrun = false;
-        bool usedPayloadOnlySize = false;
-        size_t endPos = 0;
-        size_t recognizedCount = 0;
-        size_t subPacketCount = 0;
-        std::vector<CompressedMoveSubPacket> packets;
-    };
-
-    auto isRecognizedSubOpcode = [&](uint16_t subOpcode) {
-        return subOpcode == monsterMoveWire ||
-               subOpcode == monsterMoveTransportWire ||
-               std::find(kMoveOpcodes.begin(), kMoveOpcodes.end(), subOpcode) != kMoveOpcodes.end();
-    };
-
-    auto decodeSubPackets = [&](bool payloadOnlySize) -> DecodeResult {
-        DecodeResult result;
-        result.usedPayloadOnlySize = payloadOnlySize;
-        size_t pos = 0;
-        while (pos < dataLen) {
-            if (pos + 1 > dataLen) break;
-            uint8_t subSize = data[pos];
-            if (subSize == 0) {
-                result.ok = true;
-                result.endPos = pos + 1;
-                return result;
-            }
-
-            const size_t payloadLen = payloadOnlySize
-                ? static_cast<size_t>(subSize)
-                : (subSize >= 2 ? static_cast<size_t>(subSize) - 2 : 0);
-            if (!payloadOnlySize && subSize < 2) {
-                result.endPos = pos;
-                return result;
-            }
-
-            const size_t packetLen = 1 + 2 + payloadLen;
-            if (pos + packetLen > dataLen) {
-                result.overrun = true;
-                result.endPos = pos;
-                return result;
-            }
-
-            uint16_t subOpcode = static_cast<uint16_t>(data[pos + 1]) |
-                                 (static_cast<uint16_t>(data[pos + 2]) << 8);
-            size_t payloadStart = pos + 3;
-
-            CompressedMoveSubPacket subPacket;
-            subPacket.opcode = subOpcode;
-            subPacket.payload.assign(data.begin() + payloadStart,
-                                     data.begin() + payloadStart + payloadLen);
-            result.packets.push_back(std::move(subPacket));
-            ++result.subPacketCount;
-            if (isRecognizedSubOpcode(subOpcode)) {
-                ++result.recognizedCount;
-            }
-
-            pos += packetLen;
-        }
-        result.ok = (result.endPos == 0 || result.endPos == dataLen);
-        result.endPos = dataLen;
-        return result;
-    };
-
-    DecodeResult decoded = decodeSubPackets(false);
-    if (!decoded.ok || decoded.overrun) {
-        DecodeResult payloadOnlyDecoded = decodeSubPackets(true);
-        const bool preferPayloadOnly =
-            payloadOnlyDecoded.ok &&
-            (!decoded.ok || decoded.overrun || payloadOnlyDecoded.recognizedCount > decoded.recognizedCount);
-        if (preferPayloadOnly) {
-            decoded = std::move(payloadOnlyDecoded);
-            static uint32_t payloadOnlyFallbackCount = 0;
-            ++payloadOnlyFallbackCount;
-            if (payloadOnlyFallbackCount <= 10 || (payloadOnlyFallbackCount % 100) == 0) {
-                LOG_WARNING("SMSG_COMPRESSED_MOVES decoded via payload-only size fallback",
-                            " (occurrence=", payloadOnlyFallbackCount, ")");
-            }
-        }
-    }
-
-    if (!decoded.ok || decoded.overrun) {
-        LOG_WARNING("SMSG_COMPRESSED_MOVES: sub-packet overruns buffer at pos=", decoded.endPos);
-        return;
-    }
-
-    std::unordered_set<uint16_t> unhandledSeen;
-
-    for (const auto& entry : decoded.packets) {
-        network::Packet subPacket(entry.opcode, entry.payload);
-
-        if (entry.opcode == monsterMoveWire) {
-            handleMonsterMove(subPacket);
-        } else if (entry.opcode == monsterMoveTransportWire) {
-            handleMonsterMoveTransport(subPacket);
-        } else if (owner_.state == WorldState::IN_WORLD &&
-                   std::find(kMoveOpcodes.begin(), kMoveOpcodes.end(), entry.opcode) != kMoveOpcodes.end()) {
-            handleOtherPlayerMovement(subPacket);
-        } else {
-            if (unhandledSeen.insert(entry.opcode).second) {
-                LOG_INFO("SMSG_COMPRESSED_MOVES: unhandled sub-opcode 0x",
-                         std::hex, entry.opcode, std::dec, " payloadLen=", entry.payload.size());
-            }
-        }
-    }
-}
-
-// ============================================================
-// Monster Move Handlers
-// ============================================================
-
-void MovementHandler::handleMonsterMove(network::Packet& packet) {
-    if (isActiveExpansion("classic") || isActiveExpansion("turtle")) {
-        constexpr uint32_t kMaxMonsterMovesPerTick = 256;
-        ++monsterMovePacketsThisTick_;
-        if (monsterMovePacketsThisTick_ > kMaxMonsterMovesPerTick) {
-            ++monsterMovePacketsDroppedThisTick_;
-            if (monsterMovePacketsDroppedThisTick_ <= 3 ||
-                (monsterMovePacketsDroppedThisTick_ % 100) == 0) {
-                LOG_WARNING("SMSG_MONSTER_MOVE: per-tick cap exceeded, dropping packet",
-                            " (processed=", monsterMovePacketsThisTick_,
-                            " dropped=", monsterMovePacketsDroppedThisTick_, ")");
-            }
-            return;
-        }
-    }
-
-    MonsterMoveData data;
-    auto logMonsterMoveParseFailure = [&](const std::string& msg) {
-        static uint32_t failCount = 0;
-        ++failCount;
-        if (failCount <= 10 || (failCount % 100) == 0) {
-            LOG_WARNING(msg, " (occurrence=", failCount, ")");
-        }
-    };
-    auto logWrappedUncompressedFallbackUsed = [&]() {
-        static uint32_t wrappedUncompressedFallbackCount = 0;
-        ++wrappedUncompressedFallbackCount;
-        if (wrappedUncompressedFallbackCount <= 10 || (wrappedUncompressedFallbackCount % 100) == 0) {
-            LOG_WARNING("SMSG_MONSTER_MOVE parsed via uncompressed wrapped-subpacket fallback",
-                        " (occurrence=", wrappedUncompressedFallbackCount, ")");
-        }
-    };
-    auto stripWrappedSubpacket = [&](const std::vector<uint8_t>& bytes, std::vector<uint8_t>& stripped) -> bool {
-        if (bytes.size() < 3) return false;
-        uint8_t subSize = bytes[0];
-        if (subSize < 2) return false;
-        size_t wrappedLen = static_cast<size_t>(subSize) + 1;
-        if (wrappedLen != bytes.size()) return false;
-        size_t payloadLen = static_cast<size_t>(subSize) - 2;
-        if (3 + payloadLen > bytes.size()) return false;
-        stripped.assign(bytes.begin() + 3, bytes.begin() + 3 + payloadLen);
-        return true;
-    };
-
-    const auto& rawData = packet.getData();
-    const bool allowTurtleMoveCompression = isActiveExpansion("turtle");
-    bool isCompressed = allowTurtleMoveCompression &&
-                        rawData.size() >= 6 &&
-                        rawData[4] == 0x78 &&
-                        (rawData[5] == 0x01 || rawData[5] == 0x9C ||
-                         rawData[5] == 0xDA || rawData[5] == 0x5E);
-    if (isCompressed) {
-        uint32_t decompSize = static_cast<uint32_t>(rawData[0]) |
-                              (static_cast<uint32_t>(rawData[1]) << 8) |
-                              (static_cast<uint32_t>(rawData[2]) << 16) |
-                              (static_cast<uint32_t>(rawData[3]) << 24);
-        if (decompSize == 0 || decompSize > 65536) {
-            LOG_WARNING("SMSG_MONSTER_MOVE: bad decompSize=", decompSize);
-            return;
-        }
-        std::vector<uint8_t> decompressed(decompSize);
-        uLongf destLen = decompSize;
-        int ret = uncompress(decompressed.data(), &destLen,
-                             rawData.data() + 4, rawData.size() - 4);
-        if (ret != Z_OK) {
-            LOG_WARNING("SMSG_MONSTER_MOVE: zlib error ", ret);
-            return;
-        }
-        decompressed.resize(destLen);
-        std::vector<uint8_t> stripped;
-        bool hasWrappedForm = stripWrappedSubpacket(decompressed, stripped);
-
-        bool parsed = false;
-        if (hasWrappedForm) {
-            network::Packet wrappedPacket(packet.getOpcode(), stripped);
-            if (owner_.packetParsers_->parseMonsterMove(wrappedPacket, data)) {
-                parsed = true;
-            }
-        }
-        if (!parsed) {
-            network::Packet decompPacket(packet.getOpcode(), decompressed);
-            if (owner_.packetParsers_->parseMonsterMove(decompPacket, data)) {
-                parsed = true;
-            }
-        }
-
-        if (!parsed) {
-            if (hasWrappedForm) {
-                logMonsterMoveParseFailure("Failed to parse SMSG_MONSTER_MOVE (decompressed " +
-                                           std::to_string(destLen) + " bytes, wrapped payload " +
-                                           std::to_string(stripped.size()) + " bytes)");
-            } else {
-                logMonsterMoveParseFailure("Failed to parse SMSG_MONSTER_MOVE (decompressed " +
-                                           std::to_string(destLen) + " bytes)");
-            }
-            return;
-        }
-    } else if (!owner_.packetParsers_->parseMonsterMove(packet, data)) {
-        std::vector<uint8_t> stripped;
-        if (stripWrappedSubpacket(rawData, stripped)) {
-            network::Packet wrappedPacket(packet.getOpcode(), stripped);
-            if (owner_.packetParsers_->parseMonsterMove(wrappedPacket, data)) {
-                logWrappedUncompressedFallbackUsed();
-            } else {
-                logMonsterMoveParseFailure("Failed to parse SMSG_MONSTER_MOVE");
-                return;
-            }
-        } else {
-            logMonsterMoveParseFailure("Failed to parse SMSG_MONSTER_MOVE");
-            return;
-        }
-    }
-
-    auto entity = owner_.getEntityManager().getEntity(data.guid);
-    if (!entity) {
-        return;
-    }
-
-    if (data.hasDest) {
-        glm::vec3 destCanonical = core::coords::serverToCanonical(
-            glm::vec3(data.destX, data.destY, data.destZ));
-
-        float orientation = entity->getOrientation();
-        if (data.moveType == 4) {
-            orientation = core::coords::serverToCanonicalYaw(data.facingAngle);
-        } else if (data.moveType == 3) {
-            auto target = owner_.getEntityManager().getEntity(data.facingTarget);
-            if (target) {
-                float dx = target->getX() - entity->getX();
-                float dy = target->getY() - entity->getY();
-                if (std::abs(dx) > 0.01f || std::abs(dy) > 0.01f) {
-                    orientation = std::atan2(-dy, dx);
-                }
-            }
-        } else {
-            float dx = destCanonical.x - entity->getX();
-            float dy = destCanonical.y - entity->getY();
-            if (std::abs(dx) > 0.01f || std::abs(dy) > 0.01f) {
-                orientation = std::atan2(-dy, dx);
-            }
-        }
-
-        if (data.moveType != 3) {
-            glm::vec3 startCanonical = core::coords::serverToCanonical(
-                glm::vec3(data.x, data.y, data.z));
-            float travelDx = destCanonical.x - startCanonical.x;
-            float travelDy = destCanonical.y - startCanonical.y;
-            float travelLen = std::sqrt(travelDx * travelDx + travelDy * travelDy);
-            if (travelLen > 0.5f) {
-                float travelAngle = std::atan2(-travelDy, travelDx);
-                float diff = orientation - travelAngle;
-                while (diff >  static_cast<float>(M_PI)) diff -= 2.0f * static_cast<float>(M_PI);
-                while (diff < -static_cast<float>(M_PI)) diff += 2.0f * static_cast<float>(M_PI);
-                if (std::abs(diff) > static_cast<float>(M_PI) * 0.5f) {
-                    orientation = travelAngle;
-                }
-            }
-        }
-
-        entity->startMoveTo(destCanonical.x, destCanonical.y, destCanonical.z,
-                            orientation, data.duration / 1000.0f);
-
-        if (owner_.creatureMoveCallback_) {
-            owner_.creatureMoveCallback_(data.guid,
-                destCanonical.x, destCanonical.y, destCanonical.z,
-                data.duration);
-        }
-    } else if (data.moveType == 1) {
-        glm::vec3 posCanonical = core::coords::serverToCanonical(
-            glm::vec3(data.x, data.y, data.z));
-        entity->setPosition(posCanonical.x, posCanonical.y, posCanonical.z,
-                            entity->getOrientation());
-
-        if (owner_.creatureMoveCallback_) {
-            owner_.creatureMoveCallback_(data.guid,
-                posCanonical.x, posCanonical.y, posCanonical.z, 0);
-        }
-    } else if (data.moveType == 4) {
-        float orientation = core::coords::serverToCanonicalYaw(data.facingAngle);
-        glm::vec3 posCanonical = core::coords::serverToCanonical(
-            glm::vec3(data.x, data.y, data.z));
-        entity->setPosition(posCanonical.x, posCanonical.y, posCanonical.z, orientation);
-        if (owner_.creatureMoveCallback_) {
-            owner_.creatureMoveCallback_(data.guid,
-                posCanonical.x, posCanonical.y, posCanonical.z, 0);
-        }
-    } else if (data.moveType == 3 && data.facingTarget != 0) {
-        auto target = owner_.getEntityManager().getEntity(data.facingTarget);
-        if (target) {
-            float dx = target->getX() - entity->getX();
-            float dy = target->getY() - entity->getY();
-            if (std::abs(dx) > 0.01f || std::abs(dy) > 0.01f) {
-                float orientation = std::atan2(-dy, dx);
-                entity->setOrientation(orientation);
-            }
-        }
-    }
-}
-
-void MovementHandler::handleMonsterMoveTransport(network::Packet& packet) {
-    if (packet.getRemainingSize() < 8 + 1 + 8 + 12) return;
-    uint64_t moverGuid = packet.readUInt64();
-    /*uint8_t unk =*/ packet.readUInt8();
-    uint64_t transportGuid = packet.readUInt64();
-
-    float localX = packet.readFloat();
-    float localY = packet.readFloat();
-    float localZ = packet.readFloat();
-
-    auto entity = owner_.getEntityManager().getEntity(moverGuid);
-    if (!entity) return;
-
-    if (packet.getReadPos() + 5 > packet.getSize()) {
-        if (owner_.transportManager_) {
-            glm::vec3 localCanonical = core::coords::serverToCanonical(glm::vec3(localX, localY, localZ));
-            owner_.setTransportAttachment(moverGuid, entity->getType(), transportGuid, localCanonical, false, 0.0f);
-            glm::vec3 worldPos = owner_.transportManager_->getPlayerWorldPosition(transportGuid, localCanonical);
-            entity->setPosition(worldPos.x, worldPos.y, worldPos.z, entity->getOrientation());
-            if (entity->getType() == ObjectType::UNIT && owner_.creatureMoveCallback_)
-                owner_.creatureMoveCallback_(moverGuid, worldPos.x, worldPos.y, worldPos.z, 0);
-        }
-        return;
-    }
-
-    /*uint32_t splineId =*/ packet.readUInt32();
-    uint8_t moveType = packet.readUInt8();
-
-    if (moveType == 1) {
-        if (owner_.transportManager_) {
-            glm::vec3 localCanonical = core::coords::serverToCanonical(glm::vec3(localX, localY, localZ));
-            owner_.setTransportAttachment(moverGuid, entity->getType(), transportGuid, localCanonical, false, 0.0f);
-            glm::vec3 worldPos = owner_.transportManager_->getPlayerWorldPosition(transportGuid, localCanonical);
-            entity->setPosition(worldPos.x, worldPos.y, worldPos.z, entity->getOrientation());
-            if (entity->getType() == ObjectType::UNIT && owner_.creatureMoveCallback_)
-                owner_.creatureMoveCallback_(moverGuid, worldPos.x, worldPos.y, worldPos.z, 0);
-        }
-        return;
-    }
-
-    float facingAngle = entity->getOrientation();
-    if (moveType == 2) {
-        if (packet.getReadPos() + 12 > packet.getSize()) return;
-        float sx = packet.readFloat(), sy = packet.readFloat(), sz = packet.readFloat();
-        facingAngle = std::atan2(-(sy - localY), sx - localX);
-        (void)sz;
-    } else if (moveType == 3) {
-        if (packet.getReadPos() + 8 > packet.getSize()) return;
-        uint64_t tgtGuid = packet.readUInt64();
-        if (auto tgt = owner_.getEntityManager().getEntity(tgtGuid)) {
-            float dx = tgt->getX() - entity->getX();
-            float dy = tgt->getY() - entity->getY();
-            if (std::abs(dx) > 0.01f || std::abs(dy) > 0.01f)
-                facingAngle = std::atan2(-dy, dx);
-        }
-    } else if (moveType == 4) {
-        if (packet.getReadPos() + 4 > packet.getSize()) return;
-        facingAngle = core::coords::serverToCanonicalYaw(packet.readFloat());
-    }
-
-    if (packet.getReadPos() + 4 > packet.getSize()) return;
-    uint32_t splineFlags = packet.readUInt32();
-
-    if (splineFlags & 0x00400000) {
-        if (packet.getReadPos() + 5 > packet.getSize()) return;
-        packet.readUInt8(); packet.readUInt32();
-    }
-
-    if (packet.getReadPos() + 4 > packet.getSize()) return;
-    uint32_t duration = packet.readUInt32();
-
-    if (splineFlags & 0x00000800) {
-        if (packet.getReadPos() + 8 > packet.getSize()) return;
-        packet.readFloat(); packet.readUInt32();
-    }
-
-    if (packet.getReadPos() + 4 > packet.getSize()) return;
-    uint32_t pointCount = packet.readUInt32();
-    constexpr uint32_t kMaxTransportSplinePoints = 1000;
-    if (pointCount > kMaxTransportSplinePoints) {
-        LOG_WARNING("SMSG_MONSTER_MOVE_TRANSPORT: pointCount=", pointCount,
-                    " clamped to ", kMaxTransportSplinePoints);
-        pointCount = kMaxTransportSplinePoints;
-    }
-
-    float destLocalX = localX, destLocalY = localY, destLocalZ = localZ;
-    bool hasDest = false;
-    if (pointCount > 0) {
-        const bool uncompressed = (splineFlags & (0x00080000 | 0x00002000)) != 0;
-        if (uncompressed) {
-            for (uint32_t i = 0; i < pointCount - 1; ++i) {
-                if (packet.getReadPos() + 12 > packet.getSize()) break;
-                packet.readFloat(); packet.readFloat(); packet.readFloat();
-            }
-            if (packet.getReadPos() + 12 <= packet.getSize()) {
-                destLocalX = packet.readFloat();
-                destLocalY = packet.readFloat();
-                destLocalZ = packet.readFloat();
-                hasDest = true;
-            }
-        } else {
-            if (packet.getReadPos() + 12 <= packet.getSize()) {
-                destLocalX = packet.readFloat();
-                destLocalY = packet.readFloat();
-                destLocalZ = packet.readFloat();
-                hasDest = true;
-            }
-        }
-    }
-
-    if (!owner_.transportManager_) {
-        LOG_WARNING("SMSG_MONSTER_MOVE_TRANSPORT: TransportManager not available for mover 0x",
-                    std::hex, moverGuid, std::dec);
-        return;
-    }
-
-    glm::vec3 startLocalCanonical = core::coords::serverToCanonical(glm::vec3(localX, localY, localZ));
-
-    if (hasDest && duration > 0) {
-        glm::vec3 destLocalCanonical = core::coords::serverToCanonical(glm::vec3(destLocalX, destLocalY, destLocalZ));
-        glm::vec3 destWorld  = owner_.transportManager_->getPlayerWorldPosition(transportGuid, destLocalCanonical);
-
-        if (moveType == 0) {
-            float dx = destLocalCanonical.x - startLocalCanonical.x;
-            float dy = destLocalCanonical.y - startLocalCanonical.y;
-            if (std::abs(dx) > 0.01f || std::abs(dy) > 0.01f)
-                facingAngle = std::atan2(-dy, dx);
-        }
-
-        owner_.setTransportAttachment(moverGuid, entity->getType(), transportGuid, destLocalCanonical, false, 0.0f);
-        entity->startMoveTo(destWorld.x, destWorld.y, destWorld.z, facingAngle, duration / 1000.0f);
-
-        if (entity->getType() == ObjectType::UNIT && owner_.creatureMoveCallback_)
-            owner_.creatureMoveCallback_(moverGuid, destWorld.x, destWorld.y, destWorld.z, duration);
-
-        LOG_DEBUG("SMSG_MONSTER_MOVE_TRANSPORT: mover=0x", std::hex, moverGuid,
-                  " transport=0x", transportGuid, std::dec,
-                  " dur=", duration, "ms dest=(", destWorld.x, ",", destWorld.y, ",", destWorld.z, ")");
-    } else {
-        glm::vec3 startWorld = owner_.transportManager_->getPlayerWorldPosition(transportGuid, startLocalCanonical);
-        owner_.setTransportAttachment(moverGuid, entity->getType(), transportGuid, startLocalCanonical, false, 0.0f);
-        entity->setPosition(startWorld.x, startWorld.y, startWorld.z, facingAngle);
-        if (entity->getType() == ObjectType::UNIT && owner_.creatureMoveCallback_)
-            owner_.creatureMoveCallback_(moverGuid, startWorld.x, startWorld.y, startWorld.z, 0);
-    }
-}
-
-// ============================================================
-// Teleport Handlers
-// ============================================================
-
-void MovementHandler::handleTeleportAck(network::Packet& packet) {
-    const bool taTbc = isClassicLikeExpansion() || isActiveExpansion("tbc");
-    if (packet.getRemainingSize() < (taTbc ? 8u : 4u)) {
-        LOG_WARNING("MSG_MOVE_TELEPORT_ACK too short");
-        return;
-    }
-
-    uint64_t guid = taTbc
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(4)) return;
-    uint32_t counter = packet.readUInt32();
-
-    const bool taNoFlags2 = isClassicLikeExpansion() || isActiveExpansion("tbc");
-    const size_t minMoveSz = taNoFlags2 ? (4 + 4 + 4 * 4) : (4 + 2 + 4 + 4 * 4);
-    if (packet.getRemainingSize() < minMoveSz) {
-        LOG_WARNING("MSG_MOVE_TELEPORT_ACK: not enough data for movement info");
-        return;
-    }
-
-    packet.readUInt32();  // moveFlags
-    if (!taNoFlags2)
-        packet.readUInt16();  // moveFlags2 (WotLK only)
-    uint32_t moveTime = packet.readUInt32();
-    float serverX = packet.readFloat();
-    float serverY = packet.readFloat();
-    float serverZ = packet.readFloat();
-    float orientation = packet.readFloat();
-
-    LOG_INFO("MSG_MOVE_TELEPORT_ACK: guid=0x", std::hex, guid, std::dec,
-             " counter=", counter,
-             " pos=(", serverX, ", ", serverY, ", ", serverZ, ")");
-
-    glm::vec3 canonical = core::coords::serverToCanonical(glm::vec3(serverX, serverY, serverZ));
-    movementInfo.x = canonical.x;
-    movementInfo.y = canonical.y;
-    movementInfo.z = canonical.z;
-    movementInfo.orientation = core::coords::serverToCanonicalYaw(orientation);
-    movementInfo.flags = 0;
-
-    // Clear cast bar on teleport — SpellHandler owns the casting_ flag
-    if (owner_.spellHandler_) owner_.spellHandler_->resetCastState();
-
-    if (owner_.socket) {
-        network::Packet ack(wireOpcode(Opcode::MSG_MOVE_TELEPORT_ACK));
-        const bool legacyGuidAck =
-            isActiveExpansion("classic") || isActiveExpansion("tbc") || isActiveExpansion("turtle");
-        if (legacyGuidAck) {
-            ack.writeUInt64(owner_.playerGuid);
-        } else {
-            ack.writePackedGuid(owner_.playerGuid);
-        }
-        ack.writeUInt32(counter);
-        ack.writeUInt32(moveTime);
-        owner_.socket->send(ack);
-        LOG_INFO("Sent MSG_MOVE_TELEPORT_ACK response");
-    }
-
-    if (owner_.worldEntryCallback_) {
-        owner_.worldEntryCallback_(owner_.currentMapId_, serverX, serverY, serverZ, false);
-    }
-}
-
-void MovementHandler::handleNewWorld(network::Packet& packet) {
-    if (!packet.hasRemaining(20)) {
-        LOG_WARNING("SMSG_NEW_WORLD too short");
-        return;
-    }
-
-    uint32_t mapId = packet.readUInt32();
-    float serverX = packet.readFloat();
-    float serverY = packet.readFloat();
-    float serverZ = packet.readFloat();
-    float orientation = packet.readFloat();
-
-    LOG_INFO("SMSG_NEW_WORLD: mapId=", mapId,
-             " pos=(", serverX, ", ", serverY, ", ", serverZ, ")",
-             " orient=", orientation);
-
-    const bool isSameMap       = (mapId == owner_.currentMapId_);
-    const bool isResurrection  = owner_.resurrectPending_;
-    if (isSameMap && isResurrection) {
-        LOG_INFO("SMSG_NEW_WORLD same-map resurrection — skipping world reload");
-
-        glm::vec3 canonical = core::coords::serverToCanonical(glm::vec3(serverX, serverY, serverZ));
-        movementInfo.x = canonical.x;
-        movementInfo.y = canonical.y;
-        movementInfo.z = canonical.z;
-        movementInfo.orientation = core::coords::serverToCanonicalYaw(orientation);
-        movementInfo.flags  = 0;
-        movementInfo.flags2 = 0;
-
-        owner_.resurrectPending_       = false;
-        owner_.resurrectRequestPending_ = false;
-        owner_.releasedSpirit_         = false;
-        owner_.playerDead_             = false;
-        owner_.repopPending_           = false;
-        owner_.pendingSpiritHealerGuid_ = 0;
-        owner_.resurrectCasterGuid_    = 0;
-        owner_.corpseMapId_            = 0;
-        owner_.corpseGuid_             = 0;
-        owner_.clearHostileAttackers();
-        owner_.stopAutoAttack();
-        owner_.tabCycleStale = true;
-        owner_.resetCastState();
-
-        if (owner_.socket) {
-            network::Packet ack(wireOpcode(Opcode::MSG_MOVE_WORLDPORT_ACK));
-            owner_.socket->send(ack);
-            LOG_INFO("Sent MSG_MOVE_WORLDPORT_ACK (resurrection)");
-        }
-        return;
-    }
-
-    owner_.currentMapId_ = mapId;
-    owner_.inInstance_ = false;
-    if (owner_.socket) {
-        owner_.socket->tracePacketsFor(std::chrono::seconds(12), "new_world");
-    }
-
-    glm::vec3 canonical = core::coords::serverToCanonical(glm::vec3(serverX, serverY, serverZ));
-    movementInfo.x = canonical.x;
-    movementInfo.y = canonical.y;
-    movementInfo.z = canonical.z;
-    movementInfo.orientation = core::coords::serverToCanonicalYaw(orientation);
-    movementInfo.flags = 0;
-    movementInfo.flags2 = 0;
-    serverMovementAllowed_ = true;
-    owner_.resurrectPending_ = false;
-    owner_.resurrectRequestPending_ = false;
-    onTaxiFlight_ = false;
-    taxiMountActive_ = false;
-    taxiActivatePending_ = false;
-    taxiClientActive_ = false;
-    taxiClientPath_.clear();
-    taxiRecoverPending_ = false;
-    taxiStartGrace_ = 0.0f;
-    owner_.currentMountDisplayId_ = 0;
-    taxiMountDisplayId_ = 0;
-    if (owner_.mountCallback_) {
-        owner_.mountCallback_(0);
-    }
-
-    for (const auto& [guid, entity] : owner_.getEntityManager().getEntities()) {
-        if (guid == owner_.playerGuid) continue;
-        if (entity->getType() == ObjectType::UNIT && owner_.creatureDespawnCallback_) {
-            owner_.creatureDespawnCallback_(guid);
-        } else if (entity->getType() == ObjectType::PLAYER && owner_.playerDespawnCallback_) {
-            owner_.playerDespawnCallback_(guid);
-        } else if (entity->getType() == ObjectType::GAMEOBJECT && owner_.gameObjectDespawnCallback_) {
-            owner_.gameObjectDespawnCallback_(guid);
-        }
-    }
-    owner_.otherPlayerVisibleItemEntries_.clear();
-    owner_.otherPlayerVisibleDirty_.clear();
-    otherPlayerMoveTimeMs_.clear();
-    if (owner_.spellHandler_) owner_.spellHandler_->clearUnitCastStates();
-    owner_.unitAurasCache_.clear();
-    owner_.clearCombatText();
-    owner_.getEntityManager().clear();
-    owner_.clearHostileAttackers();
-    owner_.worldStates_.clear();
-    owner_.gossipPois_.clear();
-    owner_.worldStateMapId_ = mapId;
-    owner_.worldStateZoneId_ = 0;
-    owner_.activeAreaTriggers_.clear();
-    owner_.areaTriggerCheckTimer_ = -5.0f;
-    owner_.areaTriggerSuppressFirst_ = true;
-    owner_.stopAutoAttack();
-    owner_.resetCastState();
-
-    if (owner_.socket) {
-        network::Packet ack(wireOpcode(Opcode::MSG_MOVE_WORLDPORT_ACK));
-        owner_.socket->send(ack);
-        LOG_INFO("Sent MSG_MOVE_WORLDPORT_ACK");
-    }
-
-    owner_.timeSinceLastPing = 0.0f;
-    if (owner_.socket) {
-        LOG_WARNING("World transfer keepalive: sending immediate ping after MSG_MOVE_WORLDPORT_ACK");
-        owner_.sendPing();
-    }
-
-    if (owner_.worldEntryCallback_) {
-        owner_.worldEntryCallback_(mapId, serverX, serverY, serverZ, isSameMap);
-    }
-
-    if (owner_.addonEventCallback_) {
-        owner_.addonEventCallback_("PLAYER_ENTERING_WORLD", {"0"});
-        owner_.addonEventCallback_("ZONE_CHANGED_NEW_AREA", {});
-    }
-}
-
-// ============================================================
-// Taxi / Flight Path Handlers
-// ============================================================
-
-void MovementHandler::loadTaxiDbc() {
-    if (taxiDbcLoaded_) return;
-    taxiDbcLoaded_ = true;
-
-    auto* am = owner_.services().assetManager;
-    if (!am || !am->isInitialized()) return;
-
-    auto nodesDbc = am->loadDBC("TaxiNodes.dbc");
-    if (nodesDbc && nodesDbc->isLoaded()) {
-        const auto* tnL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("TaxiNodes") : nullptr;
-        // Cache field indices before the loop
-        const uint32_t tnIdField   = tnL ? (*tnL)["ID"]    : 0;
-        const uint32_t tnMapField  = tnL ? (*tnL)["MapID"] : 1;
-        const uint32_t tnXField    = tnL ? (*tnL)["X"]     : 2;
-        const uint32_t tnYField    = tnL ? (*tnL)["Y"]     : 3;
-        const uint32_t tnZField    = tnL ? (*tnL)["Z"]     : 4;
-        const uint32_t tnNameField = tnL ? (*tnL)["Name"]  : 5;
-        const uint32_t mountAllianceField = tnL ? (*tnL)["MountDisplayIdAlliance"]         : 22;
-        const uint32_t mountHordeField    = tnL ? (*tnL)["MountDisplayIdHorde"]            : 23;
-        const uint32_t mountAllianceFB    = tnL ? (*tnL)["MountDisplayIdAllianceFallback"] : 20;
-        const uint32_t mountHordeFB       = tnL ? (*tnL)["MountDisplayIdHordeFallback"]    : 21;
-        uint32_t fieldCount = nodesDbc->getFieldCount();
-        for (uint32_t i = 0; i < nodesDbc->getRecordCount(); i++) {
-            TaxiNode node;
-            node.id = nodesDbc->getUInt32(i, tnIdField);
-            node.mapId = nodesDbc->getUInt32(i, tnMapField);
-            node.x = nodesDbc->getFloat(i, tnXField);
-            node.y = nodesDbc->getFloat(i, tnYField);
-            node.z = nodesDbc->getFloat(i, tnZField);
-            node.name = nodesDbc->getString(i, tnNameField);
-            if (fieldCount > mountHordeField) {
-                node.mountDisplayIdAlliance = nodesDbc->getUInt32(i, mountAllianceField);
-                node.mountDisplayIdHorde = nodesDbc->getUInt32(i, mountHordeField);
-                if (node.mountDisplayIdAlliance == 0 && node.mountDisplayIdHorde == 0 && fieldCount > mountHordeFB) {
-                    node.mountDisplayIdAlliance = nodesDbc->getUInt32(i, mountAllianceFB);
-                    node.mountDisplayIdHorde = nodesDbc->getUInt32(i, mountHordeFB);
-                }
-            }
-            uint32_t nodeId = node.id;
-            if (nodeId > 0) {
-                taxiNodes_[nodeId] = std::move(node);
-            }
-            if (nodeId == 195) {
-                std::string fields;
-                for (uint32_t f = 0; f < fieldCount; f++) {
-                    fields += std::to_string(f) + ":" + std::to_string(nodesDbc->getUInt32(i, f)) + " ";
-                }
-                LOG_INFO("TaxiNodes[195] fields: ", fields);
-            }
-        }
-        LOG_INFO("Loaded ", taxiNodes_.size(), " taxi nodes from TaxiNodes.dbc");
-    } else {
-        LOG_WARNING("Could not load TaxiNodes.dbc");
-    }
-
-    auto pathDbc = am->loadDBC("TaxiPath.dbc");
-    if (pathDbc && pathDbc->isLoaded()) {
-        const auto* tpL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("TaxiPath") : nullptr;
-        const uint32_t tpIdField   = tpL ? (*tpL)["ID"]       : 0;
-        const uint32_t tpFromField = tpL ? (*tpL)["FromNode"] : 1;
-        const uint32_t tpToField   = tpL ? (*tpL)["ToNode"]   : 2;
-        const uint32_t tpCostField = tpL ? (*tpL)["Cost"]     : 3;
-        for (uint32_t i = 0; i < pathDbc->getRecordCount(); i++) {
-            TaxiPathEdge edge;
-            edge.pathId = pathDbc->getUInt32(i, tpIdField);
-            edge.fromNode = pathDbc->getUInt32(i, tpFromField);
-            edge.toNode = pathDbc->getUInt32(i, tpToField);
-            edge.cost = pathDbc->getUInt32(i, tpCostField);
-            taxiPathEdges_.push_back(edge);
-        }
-        LOG_INFO("Loaded ", taxiPathEdges_.size(), " taxi path edges from TaxiPath.dbc");
-    } else {
-        LOG_WARNING("Could not load TaxiPath.dbc");
-    }
-
-    auto pathNodeDbc = am->loadDBC("TaxiPathNode.dbc");
-    if (pathNodeDbc && pathNodeDbc->isLoaded()) {
-        const auto* tpnL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("TaxiPathNode") : nullptr;
-        const uint32_t tpnIdField    = tpnL ? (*tpnL)["ID"]        : 0;
-        const uint32_t tpnPathField  = tpnL ? (*tpnL)["PathID"]    : 1;
-        const uint32_t tpnIndexField = tpnL ? (*tpnL)["NodeIndex"] : 2;
-        const uint32_t tpnMapField   = tpnL ? (*tpnL)["MapID"]     : 3;
-        const uint32_t tpnXField     = tpnL ? (*tpnL)["X"]         : 4;
-        const uint32_t tpnYField     = tpnL ? (*tpnL)["Y"]         : 5;
-        const uint32_t tpnZField     = tpnL ? (*tpnL)["Z"]         : 6;
-        for (uint32_t i = 0; i < pathNodeDbc->getRecordCount(); i++) {
-            TaxiPathNode node;
-            node.id = pathNodeDbc->getUInt32(i, tpnIdField);
-            node.pathId = pathNodeDbc->getUInt32(i, tpnPathField);
-            node.nodeIndex = pathNodeDbc->getUInt32(i, tpnIndexField);
-            node.mapId = pathNodeDbc->getUInt32(i, tpnMapField);
-            node.x = pathNodeDbc->getFloat(i, tpnXField);
-            node.y = pathNodeDbc->getFloat(i, tpnYField);
-            node.z = pathNodeDbc->getFloat(i, tpnZField);
-            taxiPathNodes_[node.pathId].push_back(node);
-        }
-        for (auto& [pathId, nodes] : taxiPathNodes_) {
-            std::sort(nodes.begin(), nodes.end(),
-                [](const TaxiPathNode& a, const TaxiPathNode& b) {
-                    return a.nodeIndex < b.nodeIndex;
-                });
-        }
-        LOG_INFO("Loaded ", pathNodeDbc->getRecordCount(), " taxi path waypoints from TaxiPathNode.dbc");
-    } else {
-        LOG_WARNING("Could not load TaxiPathNode.dbc");
-    }
-}
-
-void MovementHandler::handleShowTaxiNodes(network::Packet& packet) {
-    ShowTaxiNodesData data;
-    if (!ShowTaxiNodesParser::parse(packet, data)) {
-        LOG_WARNING("Failed to parse SMSG_SHOWTAXINODES");
-        return;
-    }
-
-    loadTaxiDbc();
-
-    if (taxiMaskInitialized_) {
-        for (uint32_t i = 0; i < TLK_TAXI_MASK_SIZE; ++i) {
-            uint32_t newBits = data.nodeMask[i] & ~knownTaxiMask_[i];
-            if (newBits == 0) continue;
-            for (uint32_t bit = 0; bit < 32; ++bit) {
-                if (newBits & (1u << bit)) {
-                    uint32_t nodeId = i * 32 + bit + 1;
-                    auto it = taxiNodes_.find(nodeId);
-                    if (it != taxiNodes_.end()) {
-                        owner_.addSystemChatMessage("Discovered flight path: " + it->second.name);
-                    }
-                }
-            }
-        }
-    }
-
-    for (uint32_t i = 0; i < TLK_TAXI_MASK_SIZE; ++i) {
-        knownTaxiMask_[i] = data.nodeMask[i];
-    }
-    taxiMaskInitialized_ = true;
-
-    currentTaxiData_ = data;
-    taxiNpcGuid_ = data.npcGuid;
-    taxiWindowOpen_ = true;
-    owner_.closeGossip();
-    buildTaxiCostMap();
-    auto it = taxiNodes_.find(data.nearestNode);
-    if (it != taxiNodes_.end()) {
-        LOG_INFO("Taxi node ", data.nearestNode, " mounts: A=", it->second.mountDisplayIdAlliance,
-                 " H=", it->second.mountDisplayIdHorde);
-    }
-    LOG_INFO("Taxi window opened, nearest node=", data.nearestNode);
-}
-
-void MovementHandler::applyTaxiMountForCurrentNode() {
-    if (taxiMountActive_ || !owner_.mountCallback_) return;
-    auto it = taxiNodes_.find(currentTaxiData_.nearestNode);
-    if (it == taxiNodes_.end()) {
-        bool isAlliance = true;
-        switch (owner_.playerRace_) {
-            case Race::ORC: case Race::UNDEAD: case Race::TAUREN: case Race::TROLL:
-            case Race::GOBLIN: case Race::BLOOD_ELF:
-                isAlliance = false; break;
-            default: break;
-        }
-        uint32_t mountId = isAlliance ? 1210u : 1310u;
-        taxiMountDisplayId_ = mountId;
-        taxiMountActive_ = true;
-        LOG_INFO("Taxi mount fallback (node ", currentTaxiData_.nearestNode, " not in DBC): displayId=", mountId);
-        owner_.mountCallback_(mountId);
-        return;
-    }
-
-    bool isAlliance = true;
-    switch (owner_.playerRace_) {
-        case Race::ORC:
-        case Race::UNDEAD:
-        case Race::TAUREN:
-        case Race::TROLL:
-        case Race::GOBLIN:
-        case Race::BLOOD_ELF:
-            isAlliance = false;
-            break;
-        default:
-            isAlliance = true;
-            break;
-    }
-    uint32_t mountId = isAlliance ? it->second.mountDisplayIdAlliance
-                                  : it->second.mountDisplayIdHorde;
-    if (mountId == 541) mountId = 0;
-    if (mountId == 0) {
-        mountId = isAlliance ? it->second.mountDisplayIdHorde
-                             : it->second.mountDisplayIdAlliance;
-        if (mountId == 541) mountId = 0;
-    }
-    if (mountId == 0) {
-        uint32_t gryphonId = owner_.services().gryphonDisplayId;
-        uint32_t wyvernId = owner_.services().wyvernDisplayId;
-        if (isAlliance && gryphonId != 0) mountId = gryphonId;
-        if (!isAlliance && wyvernId != 0) mountId = wyvernId;
-        if (mountId == 0) {
-            mountId = (isAlliance ? wyvernId : gryphonId);
-        }
-    }
-    if (mountId == 0) {
-        if (it->second.mountDisplayIdAlliance != 0) mountId = it->second.mountDisplayIdAlliance;
-        else if (it->second.mountDisplayIdHorde != 0) mountId = it->second.mountDisplayIdHorde;
-    }
-    if (mountId == 0) {
-        static const uint32_t kAllianceTaxiDisplays[] = {1210u, 1211u, 1212u, 1213u};
-        static const uint32_t kHordeTaxiDisplays[] = {1310u, 1311u, 1312u};
-        mountId = isAlliance ? kAllianceTaxiDisplays[0] : kHordeTaxiDisplays[0];
-    }
-    if (mountId == 0) {
-        mountId = isAlliance ? 30412u : 30413u;
-    }
-    if (mountId != 0) {
-        taxiMountDisplayId_ = mountId;
-        taxiMountActive_ = true;
-        LOG_INFO("Taxi mount apply: displayId=", mountId);
-        owner_.mountCallback_(mountId);
-    }
-}
-
-void MovementHandler::startClientTaxiPath(const std::vector<uint32_t>& pathNodes) {
-    taxiClientPath_.clear();
-    taxiClientIndex_ = 0;
-    taxiClientActive_ = false;
-    taxiClientSegmentProgress_ = 0.0f;
-
-    for (size_t i = 0; i + 1 < pathNodes.size(); i++) {
-        uint32_t fromNode = pathNodes[i];
-        uint32_t toNode = pathNodes[i + 1];
-        uint32_t pathId = 0;
-        for (const auto& edge : taxiPathEdges_) {
-            if (edge.fromNode == fromNode && edge.toNode == toNode) {
-                pathId = edge.pathId;
-                break;
-            }
-        }
-        if (pathId == 0) {
-            LOG_WARNING("No taxi path found from node ", fromNode, " to ", toNode);
-            continue;
-        }
-        auto pathIt = taxiPathNodes_.find(pathId);
-        if (pathIt != taxiPathNodes_.end()) {
-            for (const auto& wpNode : pathIt->second) {
-                glm::vec3 serverPos(wpNode.x, wpNode.y, wpNode.z);
-                glm::vec3 canonical = core::coords::serverToCanonical(serverPos);
-                taxiClientPath_.push_back(canonical);
-            }
-        } else {
-            LOG_WARNING("No spline waypoints found for taxi pathId ", pathId);
-        }
-    }
-
-    if (taxiClientPath_.size() < 2) {
-        taxiClientPath_.clear();
-        for (uint32_t nodeId : pathNodes) {
-            auto nodeIt = taxiNodes_.find(nodeId);
-            if (nodeIt == taxiNodes_.end()) continue;
-            glm::vec3 serverPos(nodeIt->second.x, nodeIt->second.y, nodeIt->second.z);
-            taxiClientPath_.push_back(core::coords::serverToCanonical(serverPos));
-        }
-    }
-
-    if (taxiClientPath_.size() < 2) {
-        LOG_WARNING("Taxi path too short: ", taxiClientPath_.size(), " waypoints");
-        return;
-    }
-
-    glm::vec3 start = taxiClientPath_[0];
-    glm::vec3 dir(0.0f);
-    float dirLenSq = 0.0f;
-    for (size_t i = 1; i < taxiClientPath_.size(); i++) {
-        dir = taxiClientPath_[i] - start;
-        dirLenSq = glm::dot(dir, dir);
-        if (dirLenSq >= 1e-6f) {
-            break;
-        }
-    }
-
-    float initialOrientation = movementInfo.orientation;
-    float initialRenderYaw = movementInfo.orientation;
-    float initialPitch = 0.0f;
-    float initialRoll = 0.0f;
-    if (dirLenSq >= 1e-6f) {
-        initialOrientation = std::atan2(dir.y, dir.x);
-        glm::vec3 renderDir = core::coords::canonicalToRender(dir);
-        initialRenderYaw = std::atan2(renderDir.y, renderDir.x);
-        glm::vec3 dirNorm = dir * glm::inversesqrt(dirLenSq);
-        initialPitch = std::asin(std::clamp(dirNorm.z, -1.0f, 1.0f));
-    }
-
-    movementInfo.x = start.x;
-    movementInfo.y = start.y;
-    movementInfo.z = start.z;
-    movementInfo.orientation = initialOrientation;
-    sanitizeMovementForTaxi();
-
-    auto playerEntity = owner_.getEntityManager().getEntity(owner_.playerGuid);
-    if (playerEntity) {
-        playerEntity->setPosition(start.x, start.y, start.z, initialOrientation);
-    }
-
-    if (owner_.taxiOrientationCallback_) {
-        owner_.taxiOrientationCallback_(initialRenderYaw, initialPitch, initialRoll);
-    }
-
-    LOG_INFO("Taxi flight started with ", taxiClientPath_.size(), " spline waypoints");
-    taxiClientActive_ = true;
-}
-
-void MovementHandler::updateClientTaxi(float deltaTime) {
-    if (!taxiClientActive_ || taxiClientPath_.size() < 2) return;
-    auto playerEntity = owner_.getEntityManager().getEntity(owner_.playerGuid);
-
-    auto finishTaxiFlight = [&]() {
-            if (!taxiClientPath_.empty()) {
-                const auto& landingPos = taxiClientPath_.back();
-                if (playerEntity) {
-                    playerEntity->setPosition(landingPos.x, landingPos.y, landingPos.z,
-                                              movementInfo.orientation);
-                }
-                movementInfo.x = landingPos.x;
-                movementInfo.y = landingPos.y;
-                movementInfo.z = landingPos.z;
-                LOG_INFO("Taxi landing: snapped to final waypoint (",
-                         landingPos.x, ", ", landingPos.y, ", ", landingPos.z, ")");
-            }
-            taxiClientActive_ = false;
-            onTaxiFlight_ = false;
-            taxiLandingCooldown_ = 2.0f;
-            if (taxiMountActive_ && owner_.mountCallback_) {
-                owner_.mountCallback_(0);
-            }
-            taxiMountActive_ = false;
-            taxiMountDisplayId_ = 0;
-            owner_.currentMountDisplayId_ = 0;
-            taxiClientPath_.clear();
-            taxiRecoverPending_ = false;
-            movementInfo.flags = 0;
-            movementInfo.flags2 = 0;
-            if (owner_.socket) {
-                sendMovement(Opcode::MSG_MOVE_STOP);
-                sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
-            }
-            LOG_INFO("Taxi flight landed (client path)");
-    };
-
-    if (taxiClientIndex_ + 1 >= taxiClientPath_.size()) {
-        finishTaxiFlight();
-        return;
-    }
-
-    float remainingDistance = taxiClientSegmentProgress_ + (taxiClientSpeed_ * deltaTime);
-    glm::vec3 start(0.0f);
-    glm::vec3 end(0.0f);
-    glm::vec3 dir(0.0f);
-    float segmentLen = 0.0f;
-    float t = 0.0f;
-
-    while (true) {
-        if (taxiClientIndex_ + 1 >= taxiClientPath_.size()) {
-            finishTaxiFlight();
-            return;
-        }
-
-        start = taxiClientPath_[taxiClientIndex_];
-        end = taxiClientPath_[taxiClientIndex_ + 1];
-        dir = end - start;
-        float segLenSq = glm::dot(dir, dir);
-
-        if (segLenSq < 1e-4f) {
-            taxiClientIndex_++;
-            continue;
-        }
-        segmentLen = std::sqrt(segLenSq);
-
-        if (remainingDistance >= segmentLen) {
-            remainingDistance -= segmentLen;
-            taxiClientIndex_++;
-            taxiClientSegmentProgress_ = 0.0f;
-            continue;
-        }
-
-        taxiClientSegmentProgress_ = remainingDistance;
-        t = taxiClientSegmentProgress_ / segmentLen;
-        break;
-    }
-
-    glm::vec3 p0 = (taxiClientIndex_ > 0) ? taxiClientPath_[taxiClientIndex_ - 1] : start;
-    glm::vec3 p1 = start;
-    glm::vec3 p2 = end;
-    glm::vec3 p3 = (taxiClientIndex_ + 2 < taxiClientPath_.size()) ?
-                   taxiClientPath_[taxiClientIndex_ + 2] : end;
-
-    float t2 = t * t;
-    float t3 = t2 * t;
-    glm::vec3 nextPos = 0.5f * (
-        (2.0f * p1) +
-        (-p0 + p2) * t +
-        (2.0f * p0 - 5.0f * p1 + 4.0f * p2 - p3) * t2 +
-        (-p0 + 3.0f * p1 - 3.0f * p2 + p3) * t3
-    );
-
-    glm::vec3 tangent = 0.5f * (
-        (-p0 + p2) +
-        2.0f * (2.0f * p0 - 5.0f * p1 + 4.0f * p2 - p3) * t +
-        3.0f * (-p0 + 3.0f * p1 - 3.0f * p2 + p3) * t2
-    );
-    float tangentLenSq = glm::dot(tangent, tangent);
-    if (tangentLenSq < 1e-8f) {
-        tangent = dir;
-        tangentLenSq = glm::dot(tangent, tangent);
-        if (tangentLenSq < 1e-8f) {
-            tangent = glm::vec3(std::cos(movementInfo.orientation), std::sin(movementInfo.orientation), 0.0f);
-            tangentLenSq = 1.0f; // unit vector
-        }
-    }
-
-    float targetOrientation = std::atan2(tangent.y, tangent.x);
-
-    glm::vec3 tangentNorm = tangent * glm::inversesqrt(std::max(tangentLenSq, 1e-8f));
-    float pitch = std::asin(std::clamp(tangentNorm.z, -1.0f, 1.0f));
-
-    float currentOrientation = movementInfo.orientation;
-    float orientDiff = targetOrientation - currentOrientation;
-    while (orientDiff > 3.14159265f) orientDiff -= 6.28318530f;
-    while (orientDiff < -3.14159265f) orientDiff += 6.28318530f;
-    float roll = -orientDiff * 2.5f;
-    roll = std::clamp(roll, -0.7f, 0.7f);
-
-    float smoothOrientation = currentOrientation + orientDiff * std::min(1.0f, deltaTime * 3.0f);
-
-    if (playerEntity) {
-        playerEntity->setPosition(nextPos.x, nextPos.y, nextPos.z, smoothOrientation);
-    }
-    movementInfo.x = nextPos.x;
-    movementInfo.y = nextPos.y;
-    movementInfo.z = nextPos.z;
-    movementInfo.orientation = smoothOrientation;
-
-    if (owner_.taxiOrientationCallback_) {
-        glm::vec3 renderTangent = core::coords::canonicalToRender(tangent);
-        float renderYaw = std::atan2(renderTangent.y, renderTangent.x);
-        owner_.taxiOrientationCallback_(renderYaw, pitch, roll);
-    }
-}
-
-void MovementHandler::handleActivateTaxiReply(network::Packet& packet) {
-    ActivateTaxiReplyData data;
-    if (!ActivateTaxiReplyParser::parse(packet, data)) {
-        LOG_WARNING("Failed to parse SMSG_ACTIVATETAXIREPLY");
-        return;
-    }
-
-    if (!taxiActivatePending_) {
-        LOG_DEBUG("Ignoring stray taxi reply: result=", data.result);
-        return;
-    }
-
-    if (data.result == 0) {
-        if (onTaxiFlight_ && !taxiActivatePending_) {
-            return;
-        }
-        onTaxiFlight_ = true;
-        taxiStartGrace_ = std::max(taxiStartGrace_, 2.0f);
-        sanitizeMovementForTaxi();
-        taxiWindowOpen_ = false;
-        taxiActivatePending_ = false;
-        taxiActivateTimer_ = 0.0f;
-        applyTaxiMountForCurrentNode();
-        if (owner_.socket) {
-            sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
-        }
-        LOG_INFO("Taxi flight started!");
-    } else {
-        if (onTaxiFlight_ || taxiClientActive_) {
-            LOG_WARNING("Ignoring stale taxi failure reply while flight is active: result=", data.result);
-            taxiActivatePending_ = false;
-            taxiActivateTimer_ = 0.0f;
-            return;
-        }
-        LOG_WARNING("Taxi activation failed, result=", data.result);
-        owner_.addSystemChatMessage("Cannot take that flight path.");
-        taxiActivatePending_ = false;
-        taxiActivateTimer_ = 0.0f;
-        if (taxiMountActive_ && owner_.mountCallback_) {
-            owner_.mountCallback_(0);
-        }
-        taxiMountActive_ = false;
-        taxiMountDisplayId_ = 0;
-        onTaxiFlight_ = false;
-    }
-}
-
-void MovementHandler::closeTaxi() {
-    taxiWindowOpen_ = false;
-
-    if (taxiActivatePending_ || onTaxiFlight_ || taxiClientActive_) {
-        return;
-    }
-
-    if (taxiMountActive_ && owner_.mountCallback_) {
-        owner_.mountCallback_(0);
-    }
-    taxiMountActive_ = false;
-    taxiMountDisplayId_ = 0;
-
-    taxiActivatePending_ = false;
-    onTaxiFlight_ = false;
-
-    taxiLandingCooldown_ = 2.0f;
-}
-
-void MovementHandler::buildTaxiCostMap() {
-    taxiCostMap_.clear();
-    uint32_t startNode = currentTaxiData_.nearestNode;
-    if (startNode == 0) return;
-
-    struct AdjEntry { uint32_t node; uint32_t cost; };
-    std::unordered_map<uint32_t, std::vector<AdjEntry>> adj;
-    for (const auto& edge : taxiPathEdges_) {
-        adj[edge.fromNode].push_back({edge.toNode, edge.cost});
-    }
-
-    std::deque<uint32_t> queue;
-    queue.push_back(startNode);
-    taxiCostMap_[startNode] = 0;
-
-    while (!queue.empty()) {
-        uint32_t cur = queue.front();
-        queue.pop_front();
-        for (const auto& next : adj[cur]) {
-            if (taxiCostMap_.find(next.node) == taxiCostMap_.end()) {
-                taxiCostMap_[next.node] = taxiCostMap_[cur] + next.cost;
-                queue.push_back(next.node);
-            }
-        }
-    }
-}
-
-uint32_t MovementHandler::getTaxiCostTo(uint32_t destNodeId) const {
-    auto it = taxiCostMap_.find(destNodeId);
-    return (it != taxiCostMap_.end()) ? it->second : 0;
-}
-
-void MovementHandler::activateTaxi(uint32_t destNodeId) {
-    if (!owner_.socket || owner_.state != WorldState::IN_WORLD) return;
-
-    if (taxiActivatePending_ || onTaxiFlight_) {
-        return;
-    }
-
-    uint32_t startNode = currentTaxiData_.nearestNode;
-    if (startNode == 0 || destNodeId == 0 || startNode == destNodeId) return;
-
-    if (owner_.isMounted()) {
-        LOG_INFO("Taxi activate: dismounting current mount");
-        if (owner_.mountCallback_) owner_.mountCallback_(0);
-        owner_.currentMountDisplayId_ = 0;
-        dismount();
-    }
-
-    {
-        auto destIt = taxiNodes_.find(destNodeId);
-        if (destIt != taxiNodes_.end() && !destIt->second.name.empty()) {
-            taxiDestName_ = destIt->second.name;
-            owner_.addSystemChatMessage("Requesting flight to " + destIt->second.name + "...");
-        } else {
-            taxiDestName_.clear();
-            owner_.addSystemChatMessage("Taxi: requesting flight...");
-        }
-    }
-
-    // BFS to find path from startNode to destNodeId
-    std::unordered_map<uint32_t, std::vector<uint32_t>> adj;
-    for (const auto& edge : taxiPathEdges_) {
-        adj[edge.fromNode].push_back(edge.toNode);
-    }
-
-    std::unordered_map<uint32_t, uint32_t> parent;
-    std::deque<uint32_t> queue;
-    queue.push_back(startNode);
-    parent[startNode] = startNode;
-
-    bool found = false;
-    while (!queue.empty()) {
-        uint32_t cur = queue.front();
-        queue.pop_front();
-        if (cur == destNodeId) { found = true; break; }
-        for (uint32_t next : adj[cur]) {
-            if (parent.find(next) == parent.end()) {
-                parent[next] = cur;
-                queue.push_back(next);
-            }
-        }
-    }
-
-    if (!found) {
-        LOG_WARNING("No taxi path found from node ", startNode, " to ", destNodeId);
-        owner_.addSystemChatMessage("No flight path available to that destination.");
-        return;
-    }
-
-    std::vector<uint32_t> path;
-    for (uint32_t n = destNodeId; n != startNode; n = parent[n]) {
-        path.push_back(n);
-    }
-    path.push_back(startNode);
-    std::reverse(path.begin(), path.end());
-
-    LOG_INFO("Taxi path: ", path.size(), " nodes, from ", startNode, " to ", destNodeId);
-
-    LOG_INFO("Taxi activate: npc=0x", std::hex, taxiNpcGuid_, std::dec,
-             " start=", startNode, " dest=", destNodeId, " pathLen=", path.size());
-    if (!path.empty()) {
-        std::string pathStr;
-        for (size_t i = 0; i < path.size(); i++) {
-            pathStr += std::to_string(path[i]);
-            if (i + 1 < path.size()) pathStr += "->";
-        }
-        LOG_INFO("Taxi path nodes: ", pathStr);
-    }
-
-    uint32_t totalCost = getTaxiCostTo(destNodeId);
-    LOG_INFO("Taxi activate: start=", startNode, " dest=", destNodeId, " cost=", totalCost);
-
-    auto basicPkt = ActivateTaxiPacket::build(taxiNpcGuid_, startNode, destNodeId);
-    owner_.socket->send(basicPkt);
-
-    taxiWindowOpen_ = false;
-    taxiActivatePending_ = true;
-    taxiActivateTimer_ = 0.0f;
-    taxiStartGrace_ = 2.0f;
-    if (!onTaxiFlight_) {
-        onTaxiFlight_ = true;
-        sanitizeMovementForTaxi();
-        applyTaxiMountForCurrentNode();
-    }
-    if (owner_.socket) {
-        sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
-    }
-
-    if (owner_.taxiPrecacheCallback_) {
-        std::vector<glm::vec3> previewPath;
-        for (size_t i = 0; i + 1 < path.size(); i++) {
-            uint32_t fromNode = path[i];
-            uint32_t toNode = path[i + 1];
-            uint32_t pathId = 0;
-            for (const auto& edge : taxiPathEdges_) {
-                if (edge.fromNode == fromNode && edge.toNode == toNode) {
-                    pathId = edge.pathId;
-                    break;
-                }
-            }
-            if (pathId == 0) continue;
-            auto pathIt = taxiPathNodes_.find(pathId);
-            if (pathIt != taxiPathNodes_.end()) {
-                for (const auto& wpNode : pathIt->second) {
-                    glm::vec3 serverPos(wpNode.x, wpNode.y, wpNode.z);
-                    glm::vec3 canonical = core::coords::serverToCanonical(serverPos);
-                    previewPath.push_back(canonical);
-                }
-            }
-        }
-        if (previewPath.size() >= 2) {
-            owner_.taxiPrecacheCallback_(previewPath);
-        }
-    }
-
-    if (owner_.taxiFlightStartCallback_) {
-        owner_.taxiFlightStartCallback_();
-    }
-    startClientTaxiPath(path);
-}
-
-// ============================================================
-// Area Trigger Detection (moved from GameHandler)
-// ============================================================
-
-void MovementHandler::loadAreaTriggerDbc() {
-    if (owner_.areaTriggerDbcLoaded_) return;
-    owner_.areaTriggerDbcLoaded_ = true;
-
-    auto* am = owner_.services().assetManager;
-    if (!am || !am->isInitialized()) return;
-
-    auto dbc = am->loadDBC("AreaTrigger.dbc");
-    if (!dbc || !dbc->isLoaded()) {
-        LOG_WARNING("Failed to load AreaTrigger.dbc");
-        return;
-    }
-
-    owner_.areaTriggers_.reserve(dbc->getRecordCount());
-    for (uint32_t i = 0; i < dbc->getRecordCount(); i++) {
-        GameHandler::AreaTriggerEntry at;
-        at.id     = dbc->getUInt32(i, 0);
-        at.mapId  = dbc->getUInt32(i, 1);
-        // DBC stores positions in server/wire format (X=west, Y=north) — swap to canonical
-        at.x = dbc->getFloat(i, 3);  // canonical X (north) = DBC field 3 (Y_wire)
-        at.y = dbc->getFloat(i, 2);  // canonical Y (west)  = DBC field 2 (X_wire)
-        at.z = dbc->getFloat(i, 4);
-        at.radius    = dbc->getFloat(i, 5);
-        at.boxLength = dbc->getFloat(i, 6);
-        at.boxWidth  = dbc->getFloat(i, 7);
-        at.boxHeight = dbc->getFloat(i, 8);
-        at.boxYaw    = dbc->getFloat(i, 9);
-        owner_.areaTriggers_.push_back(at);
-    }
-
-    LOG_WARNING("Loaded ", owner_.areaTriggers_.size(), " area triggers from AreaTrigger.dbc");
-}
-
-void MovementHandler::checkAreaTriggers() {
-    if (!owner_.isInWorld()) return;
-    if (onTaxiFlight_ || taxiClientActive_) return;
-
-    loadAreaTriggerDbc();
-    if (owner_.areaTriggers_.empty()) return;
-
-    const float px = movementInfo.x;
-    const float py = movementInfo.y;
-    const float pz = movementInfo.z;
-
-    // On first check after map transfer, just mark which triggers we're inside
-    // without firing them — prevents exit portal from immediately sending us back
-    bool suppressFirst = owner_.areaTriggerSuppressFirst_;
-    if (suppressFirst) {
-        owner_.areaTriggerSuppressFirst_ = false;
-    }
-
-    for (const auto& at : owner_.areaTriggers_) {
-        if (at.mapId != owner_.currentMapId_) continue;
-
-        bool inside = false;
-        if (at.radius > 0.0f) {
-            // Sphere trigger — use actual DBC radius
-            float dx = px - at.x;
-            float dy = py - at.y;
-            float dz = pz - at.z;
-            float distSq = dx * dx + dy * dy + dz * dz;
-            inside = (distSq <= at.radius * at.radius);
-        } else if (at.boxLength > 0.0f || at.boxWidth > 0.0f || at.boxHeight > 0.0f) {
-            // Box trigger — use actual DBC dimensions
-            float effLength = at.boxLength;
-            float effWidth = at.boxWidth;
-            float effHeight = at.boxHeight;
-
-            float dx = px - at.x;
-            float dy = py - at.y;
-            float dz = pz - at.z;
-
-            // Rotate into box-local space
-            float cosYaw = std::cos(-at.boxYaw);
-            float sinYaw = std::sin(-at.boxYaw);
-            float localX = dx * cosYaw - dy * sinYaw;
-            float localY = dx * sinYaw + dy * cosYaw;
-
-            inside = (std::abs(localX) <= effLength * 0.5f &&
-                      std::abs(localY) <= effWidth * 0.5f &&
-                      std::abs(dz) <= effHeight * 0.5f);
-        }
-
-        if (inside) {
-            if (owner_.activeAreaTriggers_.count(at.id) == 0) {
-                owner_.activeAreaTriggers_.insert(at.id);
-
-                if (suppressFirst) {
-                    // After map transfer: mark triggers we're inside of, but don't fire them.
-                    // This prevents the exit portal from immediately sending us back.
-                    LOG_WARNING("AreaTrigger suppressed (post-transfer): AT", at.id);
-                } else {
-                    // Send CMSG_AREATRIGGER — the player is already inside the
-                    // trigger radius so the server's distance check should pass.
-                    // Do NOT spoof position to the trigger center; that tells the
-                    // server we're somewhere we're not and can cause rogue teleports.
-                    network::Packet pkt(wireOpcode(Opcode::CMSG_AREATRIGGER));
-                    pkt.writeUInt32(at.id);
-                    owner_.socket->send(pkt);
-                    LOG_DEBUG("Fired CMSG_AREATRIGGER: id=", at.id);
-                }
-            }
-        } else {
-            // Player left the trigger — allow re-fire on re-entry
-            owner_.activeAreaTriggers_.erase(at.id);
-        }
-    }
-}
-
-// ============================================================
-// Transport Attachments (moved from GameHandler)
-// ============================================================
-
-void MovementHandler::setTransportAttachment(uint64_t childGuid, ObjectType type, uint64_t transportGuid,
-                                             const glm::vec3& localOffset, bool hasLocalOrientation,
-                                             float localOrientation) {
-    if (childGuid == 0 || transportGuid == 0) {
-        return;
-    }
-
-    GameHandler::TransportAttachment& attachment = owner_.transportAttachments_[childGuid];
-    attachment.type = type;
-    attachment.transportGuid = transportGuid;
-    attachment.localOffset = localOffset;
-    attachment.hasLocalOrientation = hasLocalOrientation;
-    attachment.localOrientation = localOrientation;
-}
-
-void MovementHandler::clearTransportAttachment(uint64_t childGuid) {
-    if (childGuid == 0) {
-        return;
-    }
-    owner_.transportAttachments_.erase(childGuid);
-}
-
-void MovementHandler::updateAttachedTransportChildren(float /*deltaTime*/) {
-    if (!owner_.transportManager_ || owner_.transportAttachments_.empty()) {
-        return;
-    }
-
-    constexpr float kPosEpsilonSq = 0.0001f;
-    constexpr float kOriEpsilon = 0.001f;
-    std::vector<uint64_t> stale;
-    stale.reserve(8);
-
-    for (const auto& [childGuid, attachment] : owner_.transportAttachments_) {
-        auto entity = owner_.getEntityManager().getEntity(childGuid);
-        if (!entity) {
-            stale.push_back(childGuid);
-            continue;
-        }
-
-        ActiveTransport* transport = owner_.transportManager_->getTransport(attachment.transportGuid);
-        if (!transport) {
-            continue;
-        }
-
-        glm::vec3 composed = owner_.transportManager_->getPlayerWorldPosition(
-            attachment.transportGuid, attachment.localOffset);
-
-        float composedOrientation = entity->getOrientation();
-        if (attachment.hasLocalOrientation) {
-            float baseYaw = transport->hasServerYaw ? transport->serverYaw : 0.0f;
-            composedOrientation = baseYaw + attachment.localOrientation;
-        }
-
-        glm::vec3 oldPos(entity->getX(), entity->getY(), entity->getZ());
-        float oldOrientation = entity->getOrientation();
-        glm::vec3 delta = composed - oldPos;
-        const bool positionChanged = glm::dot(delta, delta) > kPosEpsilonSq;
-        const bool orientationChanged = std::abs(composedOrientation - oldOrientation) > kOriEpsilon;
-        if (!positionChanged && !orientationChanged) {
-            continue;
-        }
-
-        entity->setPosition(composed.x, composed.y, composed.z, composedOrientation);
-
-        if (attachment.type == ObjectType::UNIT) {
-            if (owner_.creatureMoveCallback_) {
-                owner_.creatureMoveCallback_(childGuid, composed.x, composed.y, composed.z, 0);
-            }
-        } else if (attachment.type == ObjectType::GAMEOBJECT) {
-            if (owner_.gameObjectMoveCallback_) {
-                owner_.gameObjectMoveCallback_(childGuid, composed.x, composed.y, composed.z, composedOrientation);
-            }
-        }
-    }
-
-    for (uint64_t guid : stale) {
-        owner_.transportAttachments_.erase(guid);
-    }
-}
-
-// ============================================================
-// Follow target (moved from GameHandler)
-// ============================================================
-
-void MovementHandler::followTarget() {
-    if (owner_.state != WorldState::IN_WORLD) {
-        LOG_WARNING("Cannot follow: not in world");
-        return;
-    }
-
-    if (owner_.targetGuid == 0) {
-        owner_.addSystemChatMessage("You must target someone to follow.");
-        return;
-    }
-
-    auto target = owner_.getTarget();
-    if (!target) {
-        owner_.addSystemChatMessage("Invalid target.");
-        return;
-    }
-
-    // Set follow target
-    owner_.followTargetGuid_ = owner_.targetGuid;
-
-    // Initialize render-space position from entity's canonical coords
-    owner_.followRenderPos_ = core::coords::canonicalToRender(glm::vec3(target->getX(), target->getY(), target->getZ()));
-
-    // Tell camera controller to start auto-following
-    if (owner_.autoFollowCallback_) {
-        owner_.autoFollowCallback_(&owner_.followRenderPos_);
-    }
-
-    // Get target name
-    std::string targetName = "Target";
-    if (target->getType() == ObjectType::PLAYER) {
-        auto player = std::static_pointer_cast<Player>(target);
-        if (!player->getName().empty()) {
-            targetName = player->getName();
-        }
-    } else if (target->getType() == ObjectType::UNIT) {
-        auto unit = std::static_pointer_cast<Unit>(target);
-        targetName = unit->getName();
-    }
-
-    owner_.addSystemChatMessage("Now following " + targetName + ".");
-    LOG_INFO("Following target: ", targetName, " (GUID: 0x", std::hex, owner_.targetGuid, std::dec, ")");
-    owner_.fireAddonEvent("AUTOFOLLOW_BEGIN", {});
-}
-
-void MovementHandler::cancelFollow() {
-    if (owner_.followTargetGuid_ == 0) {
-        return;
-    }
-    owner_.followTargetGuid_ = 0;
-    if (owner_.autoFollowCallback_) {
-        owner_.autoFollowCallback_(nullptr);
-    }
-    owner_.addSystemChatMessage("You stop following.");
-    owner_.fireAddonEvent("AUTOFOLLOW_END", {});
-}
-
-} // namespace game
-} // namespace wowee
diff --git a/src/game/opcode_table.cpp b/src/game/opcode_table.cpp
index ad9b639f..8178f0f5 100644
--- a/src/game/opcode_table.cpp
+++ b/src/game/opcode_table.cpp
@@ -4,9 +4,7 @@
 #include <sstream>
 #include <algorithm>
 #include <cctype>
-#include <filesystem>
 #include <string_view>
-#include <unordered_set>
 
 namespace wowee {
 namespace game {
@@ -49,155 +47,6 @@ static std::string_view canonicalOpcodeName(std::string_view name) {
     return name;
 }
 
-static std::optional<uint16_t> resolveLogicalOpcodeIndex(std::string_view name) {
-    const std::string_view canonical = canonicalOpcodeName(name);
-    for (size_t i = 0; i < kOpcodeNameCount; ++i) {
-        if (canonical == kOpcodeNames[i].name) {
-            return static_cast<uint16_t>(kOpcodeNames[i].op);
-        }
-    }
-    return std::nullopt;
-}
-
-static std::optional<std::string> parseStringField(const std::string& json, const char* fieldName) {
-    const std::string needle = std::string("\"") + fieldName + "\"";
-    size_t keyPos = json.find(needle);
-    if (keyPos == std::string::npos) return std::nullopt;
-
-    size_t colon = json.find(':', keyPos + needle.size());
-    if (colon == std::string::npos) return std::nullopt;
-
-    size_t valueStart = json.find('"', colon + 1);
-    if (valueStart == std::string::npos) return std::nullopt;
-    size_t valueEnd = json.find('"', valueStart + 1);
-    if (valueEnd == std::string::npos) return std::nullopt;
-    return json.substr(valueStart + 1, valueEnd - valueStart - 1);
-}
-
-static std::vector<std::string> parseStringArrayField(const std::string& json, const char* fieldName) {
-    std::vector<std::string> values;
-    const std::string needle = std::string("\"") + fieldName + "\"";
-    size_t keyPos = json.find(needle);
-    if (keyPos == std::string::npos) return values;
-
-    size_t colon = json.find(':', keyPos + needle.size());
-    if (colon == std::string::npos) return values;
-
-    size_t arrayStart = json.find('[', colon + 1);
-    if (arrayStart == std::string::npos) return values;
-    size_t arrayEnd = json.find(']', arrayStart + 1);
-    if (arrayEnd == std::string::npos) return values;
-
-    size_t pos = arrayStart + 1;
-    while (pos < arrayEnd) {
-        size_t valueStart = json.find('"', pos);
-        if (valueStart == std::string::npos || valueStart >= arrayEnd) break;
-        size_t valueEnd = json.find('"', valueStart + 1);
-        if (valueEnd == std::string::npos || valueEnd > arrayEnd) break;
-        values.push_back(json.substr(valueStart + 1, valueEnd - valueStart - 1));
-        pos = valueEnd + 1;
-    }
-    return values;
-}
-
-static bool loadOpcodeJsonRecursive(const std::filesystem::path& path,
-                                    std::unordered_map<uint16_t, uint16_t>& logicalToWire,
-                                    std::unordered_map<uint16_t, uint16_t>& wireToLogical,
-                                    std::unordered_set<std::string>& loadingStack) {
-    const std::filesystem::path canonicalPath = std::filesystem::weakly_canonical(path);
-    const std::string canonicalKey = canonicalPath.string();
-    if (!loadingStack.insert(canonicalKey).second) {
-        LOG_WARNING("OpcodeTable: inheritance cycle at ", canonicalKey);
-        return false;
-    }
-
-    std::ifstream f(canonicalPath);
-    if (!f.is_open()) {
-        LOG_WARNING("OpcodeTable: cannot open ", canonicalPath.string());
-        loadingStack.erase(canonicalKey);
-        return false;
-    }
-
-    std::string json((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
-    bool ok = true;
-
-    if (auto extends = parseStringField(json, "_extends")) {
-        ok = loadOpcodeJsonRecursive(canonicalPath.parent_path() / *extends,
-                                     logicalToWire, wireToLogical, loadingStack) && ok;
-    }
-
-    for (const std::string& removeName : parseStringArrayField(json, "_remove")) {
-        auto logical = resolveLogicalOpcodeIndex(removeName);
-        if (!logical) continue;
-        auto it = logicalToWire.find(*logical);
-        if (it != logicalToWire.end()) {
-            const uint16_t oldWire = it->second;
-            logicalToWire.erase(it);
-            auto wireIt = wireToLogical.find(oldWire);
-            if (wireIt != wireToLogical.end() && wireIt->second == *logical) {
-                wireToLogical.erase(wireIt);
-            }
-        }
-    }
-
-    size_t pos = 0;
-    while (pos < json.size()) {
-        size_t keyStart = json.find('"', pos);
-        if (keyStart == std::string::npos) break;
-        size_t keyEnd = json.find('"', keyStart + 1);
-        if (keyEnd == std::string::npos) break;
-        std::string key = json.substr(keyStart + 1, keyEnd - keyStart - 1);
-
-        size_t colon = json.find(':', keyEnd);
-        if (colon == std::string::npos) break;
-
-        size_t valStart = colon + 1;
-        while (valStart < json.size() && (json[valStart] == ' ' || json[valStart] == '\t' ||
-               json[valStart] == '\r' || json[valStart] == '\n' || json[valStart] == '"'))
-            ++valStart;
-
-        size_t valEnd = json.find_first_of(",}\"\r\n", valStart);
-        if (valEnd == std::string::npos) valEnd = json.size();
-        std::string valStr = json.substr(valStart, valEnd - valStart);
-
-        uint16_t wire = 0;
-        try {
-            if (valStr.size() > 2 && (valStr[0] == '0' && (valStr[1] == 'x' || valStr[1] == 'X'))) {
-                wire = static_cast<uint16_t>(std::stoul(valStr, nullptr, 16));
-            } else {
-                wire = static_cast<uint16_t>(std::stoul(valStr));
-            }
-        } catch (...) {
-            pos = valEnd + 1;
-            continue;
-        }
-
-        auto logical = resolveLogicalOpcodeIndex(key);
-        if (logical) {
-            auto oldLogicalIt = logicalToWire.find(*logical);
-            if (oldLogicalIt != logicalToWire.end()) {
-                const uint16_t oldWire = oldLogicalIt->second;
-                auto oldWireIt = wireToLogical.find(oldWire);
-                if (oldWireIt != wireToLogical.end() && oldWireIt->second == *logical) {
-                    wireToLogical.erase(oldWireIt);
-                }
-            }
-            auto oldWireIt = wireToLogical.find(wire);
-            if (oldWireIt != wireToLogical.end() && oldWireIt->second != *logical) {
-                logicalToWire.erase(oldWireIt->second);
-                wireToLogical.erase(oldWireIt);
-            }
-            logicalToWire[*logical] = wire;
-            wireToLogical[wire] = *logical;
-        }
-
-        pos = valEnd + 1;
-    }
-
-    loadingStack.erase(canonicalKey);
-    return ok;
-}
-
 std::optional<LogicalOpcode> OpcodeTable::nameToLogical(const std::string& name) {
     const std::string_view canonical = canonicalOpcodeName(name);
     for (size_t i = 0; i < kOpcodeNameCount; ++i) {
@@ -215,18 +64,73 @@ const char* OpcodeTable::logicalToName(LogicalOpcode op) {
 }
 
 bool OpcodeTable::loadFromJson(const std::string& path) {
-    // Start fresh — resolved JSON inheritance is the single source of truth for opcode mappings.
+    std::ifstream f(path);
+    if (!f.is_open()) {
+        LOG_WARNING("OpcodeTable: cannot open ", path, ", using defaults");
+        return false;
+    }
+
+    std::string json((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
+
+    // Start fresh — JSON is the single source of truth for opcode mappings.
     logicalToWire_.clear();
     wireToLogical_.clear();
-    std::unordered_set<std::string> loadingStack;
-    if (!loadOpcodeJsonRecursive(std::filesystem::path(path),
-                                 logicalToWire_, wireToLogical_, loadingStack) ||
-        logicalToWire_.empty()) {
+
+    // Parse simple JSON: { "NAME": "0xHEX", ... } or { "NAME": 123, ... }
+    size_t pos = 0;
+    size_t loaded = 0;
+    while (pos < json.size()) {
+        // Find next quoted key
+        size_t keyStart = json.find('"', pos);
+        if (keyStart == std::string::npos) break;
+        size_t keyEnd = json.find('"', keyStart + 1);
+        if (keyEnd == std::string::npos) break;
+        std::string key = json.substr(keyStart + 1, keyEnd - keyStart - 1);
+
+        // Find colon then value
+        size_t colon = json.find(':', keyEnd);
+        if (colon == std::string::npos) break;
+
+        // Skip whitespace
+        size_t valStart = colon + 1;
+        while (valStart < json.size() && (json[valStart] == ' ' || json[valStart] == '\t' ||
+               json[valStart] == '\r' || json[valStart] == '\n' || json[valStart] == '"'))
+            ++valStart;
+
+        size_t valEnd = json.find_first_of(",}\"\r\n", valStart);
+        if (valEnd == std::string::npos) valEnd = json.size();
+        std::string valStr = json.substr(valStart, valEnd - valStart);
+
+        // Parse hex or decimal value
+        uint16_t wire = 0;
+        try {
+            if (valStr.size() > 2 && (valStr[0] == '0' && (valStr[1] == 'x' || valStr[1] == 'X'))) {
+                wire = static_cast<uint16_t>(std::stoul(valStr, nullptr, 16));
+            } else {
+                wire = static_cast<uint16_t>(std::stoul(valStr));
+            }
+        } catch (...) {
+            pos = valEnd + 1;
+            continue;
+        }
+
+        auto logOp = nameToLogical(key);
+        if (logOp) {
+            uint16_t logIdx = static_cast<uint16_t>(*logOp);
+            logicalToWire_[logIdx] = wire;
+            wireToLogical_[wire] = logIdx;
+            ++loaded;
+        }
+
+        pos = valEnd + 1;
+    }
+
+    if (loaded == 0) {
         LOG_WARNING("OpcodeTable: no opcodes loaded from ", path);
         return false;
     }
 
-    LOG_INFO("OpcodeTable: loaded ", logicalToWire_.size(), " opcodes from ", path);
+    LOG_INFO("OpcodeTable: loaded ", loaded, " opcodes from ", path);
     return true;
 }
 
diff --git a/src/game/packet_parsers_classic.cpp b/src/game/packet_parsers_classic.cpp
index f757b931..2e335af1 100644
--- a/src/game/packet_parsers_classic.cpp
+++ b/src/game/packet_parsers_classic.cpp
@@ -1,121 +1,9 @@
 #include "game/packet_parsers.hpp"
 #include "core/logger.hpp"
-#include <cstdio>
-#include <functional>
-#include <string>
 
 namespace wowee {
 namespace game {
 
-namespace {
-
-std::string formatPacketBytes(const network::Packet& packet, size_t startPos) {
-    const auto& rawData = packet.getData();
-    if (startPos >= rawData.size()) {
-        return {};
-    }
-
-    std::string hex;
-    hex.reserve((rawData.size() - startPos) * 3);
-    for (size_t i = startPos; i < rawData.size(); ++i) {
-        char buf[4];
-        std::snprintf(buf, sizeof(buf), "%02x ", rawData[i]);
-        hex += buf;
-    }
-    if (!hex.empty()) {
-        hex.pop_back();
-    }
-    return hex;
-}
-
-bool skipClassicSpellCastTargets(network::Packet& packet, uint64_t* primaryTargetGuid = nullptr) {
-    if (!packet.hasRemaining(2)) {
-        return false;
-    }
-
-    const uint16_t targetFlags = packet.readUInt16();
-
-    const auto readPackedTargetGuid = [&](bool capture) -> bool {
-        if (!packet.hasFullPackedGuid()) {
-            return false;
-        }
-        const uint64_t guid = packet.readPackedGuid();
-        if (capture && primaryTargetGuid && *primaryTargetGuid == 0) {
-            *primaryTargetGuid = guid;
-        }
-        return true;
-    };
-
-    // Common Classic/Turtle SpellCastTargets payloads.
-    if ((targetFlags & 0x0002) != 0 && !readPackedTargetGuid(true)) {   // UNIT
-        return false;
-    }
-    if ((targetFlags & 0x0004) != 0 && !readPackedTargetGuid(false)) {  // UNIT_MINIPET/extra guid
-        return false;
-    }
-    if ((targetFlags & 0x0010) != 0 && !readPackedTargetGuid(false)) {  // ITEM
-        return false;
-    }
-    if ((targetFlags & 0x0800) != 0 && !readPackedTargetGuid(true)) {   // OBJECT
-        return false;
-    }
-    if ((targetFlags & 0x8000) != 0 && !readPackedTargetGuid(false)) {  // CORPSE
-        return false;
-    }
-
-    if ((targetFlags & 0x0020) != 0) {                                  // SOURCE_LOCATION
-        if (!packet.hasRemaining(12)) {
-            return false;
-        }
-        (void)packet.readFloat();
-        (void)packet.readFloat();
-        (void)packet.readFloat();
-    }
-    if ((targetFlags & 0x0040) != 0) {                                  // DEST_LOCATION
-        if (!packet.hasRemaining(12)) {
-            return false;
-        }
-        (void)packet.readFloat();
-        (void)packet.readFloat();
-        (void)packet.readFloat();
-    }
-
-    if ((targetFlags & 0x1000) != 0) {                                  // TRADE_ITEM
-        if (!packet.hasRemaining(1)) {
-            return false;
-        }
-        (void)packet.readUInt8();
-    }
-
-    if ((targetFlags & 0x2000) != 0) {                                  // STRING
-        const auto& rawData = packet.getData();
-        size_t pos = packet.getReadPos();
-        while (pos < rawData.size() && rawData[pos] != 0) {
-            ++pos;
-        }
-        if (pos >= rawData.size()) {
-            return false;
-        }
-        packet.setReadPos(pos + 1);
-    }
-
-    return true;
-}
-
-const char* updateTypeName(UpdateType type) {
-    switch (type) {
-        case UpdateType::VALUES: return "VALUES";
-        case UpdateType::MOVEMENT: return "MOVEMENT";
-        case UpdateType::CREATE_OBJECT: return "CREATE_OBJECT";
-        case UpdateType::CREATE_OBJECT2: return "CREATE_OBJECT2";
-        case UpdateType::OUT_OF_RANGE_OBJECTS: return "OUT_OF_RANGE_OBJECTS";
-        case UpdateType::NEAR_OBJECTS: return "NEAR_OBJECTS";
-        default: return "UNKNOWN";
-    }
-}
-
-} // namespace
-
 // ============================================================================
 // Classic 1.12.1 movement flag constants
 // Key differences from TBC:
@@ -133,36 +21,6 @@ namespace ClassicMoveFlags {
     constexpr uint32_t SPLINE_ELEVATION = 0x04000000;  // Same as TBC
 }
 
-uint32_t classicWireMoveFlags(uint32_t internalFlags) {
-    uint32_t wireFlags = internalFlags;
-
-    // Internal movement state is tracked with WotLK-era bits. Classic/Turtle
-    // movement packets still use the older transport/jump flag layout.
-    const uint32_t kInternalOnTransport = static_cast<uint32_t>(MovementFlags::ONTRANSPORT);
-    const uint32_t kInternalFalling =
-        static_cast<uint32_t>(MovementFlags::FALLING) |
-        static_cast<uint32_t>(MovementFlags::FALLINGFAR);
-    const uint32_t kClassicConflicts =
-        static_cast<uint32_t>(MovementFlags::ASCENDING) |
-        static_cast<uint32_t>(MovementFlags::CAN_FLY) |
-        static_cast<uint32_t>(MovementFlags::FLYING) |
-        static_cast<uint32_t>(MovementFlags::HOVER);
-
-    wireFlags &= ~kClassicConflicts;
-
-    if ((internalFlags & kInternalOnTransport) != 0) {
-        wireFlags &= ~kInternalOnTransport;
-        wireFlags |= ClassicMoveFlags::ONTRANSPORT;
-    }
-
-    if ((internalFlags & kInternalFalling) != 0) {
-        wireFlags &= ~kInternalFalling;
-        wireFlags |= ClassicMoveFlags::JUMPING;
-    }
-
-    return wireFlags;
-}
-
 // ============================================================================
 // Classic parseMovementBlock
 // Key differences from TBC:
@@ -173,26 +31,20 @@ uint32_t classicWireMoveFlags(uint32_t internalFlags) {
 // Same as TBC: u8 UpdateFlags, JUMPING=0x2000, 8 speeds, no pitchRate
 // ============================================================================
 bool ClassicPacketParsers::parseMovementBlock(network::Packet& packet, UpdateBlock& block) {
-    auto rem = [&]() -> size_t { return packet.getRemainingSize(); };
-    if (rem() < 1) return false;
-
     // Classic: UpdateFlags is uint8 (same as TBC)
     uint8_t updateFlags = packet.readUInt8();
     block.updateFlags = static_cast<uint16_t>(updateFlags);
 
-    LOG_DEBUG("  [Classic] UpdateFlags: 0x", std::hex, static_cast<int>(updateFlags), std::dec);
+    LOG_DEBUG("  [Classic] UpdateFlags: 0x", std::hex, (int)updateFlags, std::dec);
 
-    const uint8_t UPDATEFLAG_TRANSPORT       = 0x02;
-    const uint8_t UPDATEFLAG_MELEE_ATTACKING = 0x04;
-    const uint8_t UPDATEFLAG_HIGHGUID        = 0x08;
-    const uint8_t UPDATEFLAG_ALL             = 0x10;
-    const uint8_t UPDATEFLAG_LIVING          = 0x20;
-    const uint8_t UPDATEFLAG_HAS_POSITION    = 0x40;
+    const uint8_t UPDATEFLAG_LIVING       = 0x20;
+    const uint8_t UPDATEFLAG_HAS_POSITION = 0x40;
+    const uint8_t UPDATEFLAG_HAS_TARGET   = 0x04;
+    const uint8_t UPDATEFLAG_TRANSPORT    = 0x02;
+    const uint8_t UPDATEFLAG_LOWGUID      = 0x08;
+    const uint8_t UPDATEFLAG_HIGHGUID     = 0x10;
 
     if (updateFlags & UPDATEFLAG_LIVING) {
-        // Minimum: moveFlags(4)+time(4)+position(16)+fallTime(4)+speeds(24) = 52 bytes
-        if (rem() < 52) return false;
-
         // Movement flags (u32 only — NO extra flags byte in Classic)
         uint32_t moveFlags = packet.readUInt32();
         /*uint32_t time =*/ packet.readUInt32();
@@ -209,29 +61,26 @@ bool ClassicPacketParsers::parseMovementBlock(network::Packet& packet, UpdateBlo
 
         // Transport data (Classic: ONTRANSPORT=0x02000000, no timestamp)
         if (moveFlags & ClassicMoveFlags::ONTRANSPORT) {
-            if (rem() < 1) return false;
             block.onTransport = true;
-            block.transportGuid = packet.readPackedGuid();
-            if (rem() < 16) return false; // 4 floats
+            block.transportGuid = UpdateObjectParser::readPackedGuid(packet);
             block.transportX = packet.readFloat();
             block.transportY = packet.readFloat();
             block.transportZ = packet.readFloat();
             block.transportO = packet.readFloat();
+            // Classic: NO transport timestamp (TBC adds u32 timestamp)
+            // Classic: NO transport seat byte
         }
 
         // Pitch (Classic: only SWIMMING, no FLYING or ONTRANSPORT pitch)
         if (moveFlags & ClassicMoveFlags::SWIMMING) {
-            if (rem() < 4) return false;
             /*float pitch =*/ packet.readFloat();
         }
 
         // Fall time (always present)
-        if (rem() < 4) return false;
         /*uint32_t fallTime =*/ packet.readUInt32();
 
         // Jumping (Classic: JUMPING=0x2000, same as TBC)
         if (moveFlags & ClassicMoveFlags::JUMPING) {
-            if (rem() < 16) return false;
             /*float jumpVelocity =*/ packet.readFloat();
             /*float jumpSinAngle =*/ packet.readFloat();
             /*float jumpCosAngle =*/ packet.readFloat();
@@ -240,12 +89,12 @@ bool ClassicPacketParsers::parseMovementBlock(network::Packet& packet, UpdateBlo
 
         // Spline elevation
         if (moveFlags & ClassicMoveFlags::SPLINE_ELEVATION) {
-            if (rem() < 4) return false;
             /*float splineElevation =*/ packet.readFloat();
         }
 
         // Speeds (Classic: 6 values — no flight speeds, no pitchRate)
-        if (rem() < 24) return false;
+        // TBC added flying_speed + backwards_flying_speed (8 total)
+        // WotLK added pitchRate (9 total)
         /*float walkSpeed =*/ packet.readFloat();
         float runSpeed = packet.readFloat();
         /*float runBackSpeed =*/ packet.readFloat();
@@ -254,39 +103,37 @@ bool ClassicPacketParsers::parseMovementBlock(network::Packet& packet, UpdateBlo
         /*float turnRate =*/ packet.readFloat();
 
         block.runSpeed = runSpeed;
-        block.moveFlags = moveFlags;
 
         // Spline data (Classic: SPLINE_ENABLED=0x00400000)
         if (moveFlags & ClassicMoveFlags::SPLINE_ENABLED) {
-            if (rem() < 4) return false;
             uint32_t splineFlags = packet.readUInt32();
             LOG_DEBUG("  [Classic] Spline: flags=0x", std::hex, splineFlags, std::dec);
 
             if (splineFlags & 0x00010000) { // FINAL_POINT
-                if (rem() < 12) return false;
                 /*float finalX =*/ packet.readFloat();
                 /*float finalY =*/ packet.readFloat();
                 /*float finalZ =*/ packet.readFloat();
             } else if (splineFlags & 0x00020000) { // FINAL_TARGET
-                if (rem() < 8) return false;
                 /*uint64_t finalTarget =*/ packet.readUInt64();
             } else if (splineFlags & 0x00040000) { // FINAL_ANGLE
-                if (rem() < 4) return false;
                 /*float finalAngle =*/ packet.readFloat();
             }
 
-            // Classic spline: timePassed, duration, id, pointCount
-            if (rem() < 16) return false;
+            // Classic spline: timePassed, duration, id, nodes, finalNode (same as TBC)
             /*uint32_t timePassed =*/ packet.readUInt32();
             /*uint32_t duration =*/ packet.readUInt32();
             /*uint32_t splineId =*/ packet.readUInt32();
 
             uint32_t pointCount = packet.readUInt32();
-            // Cap waypoints to prevent DoS from malformed packets allocating huge arrays
-            if (pointCount > 256) return false;
-
-            // points + endPoint (no splineMode in Classic)
-            if (rem() < static_cast<size_t>(pointCount) * 12 + 12) return false;
+            if (pointCount > 256) {
+                static uint32_t badClassicSplineCount = 0;
+                ++badClassicSplineCount;
+                if (badClassicSplineCount <= 5 || (badClassicSplineCount % 100) == 0) {
+                    LOG_WARNING("  [Classic] Spline pointCount=", pointCount,
+                                " exceeds max, capping (occurrence=", badClassicSplineCount, ")");
+                }
+                pointCount = 0;
+            }
             for (uint32_t i = 0; i < pointCount; i++) {
                 /*float px =*/ packet.readFloat();
                 /*float py =*/ packet.readFloat();
@@ -300,7 +147,6 @@ bool ClassicPacketParsers::parseMovementBlock(network::Packet& packet, UpdateBlo
         }
     }
     else if (updateFlags & UPDATEFLAG_HAS_POSITION) {
-        if (rem() < 16) return false;
         block.x = packet.readFloat();
         block.y = packet.readFloat();
         block.z = packet.readFloat();
@@ -310,30 +156,26 @@ bool ClassicPacketParsers::parseMovementBlock(network::Packet& packet, UpdateBlo
         LOG_DEBUG("  [Classic] STATIONARY: (", block.x, ", ", block.y, ", ", block.z, ")");
     }
 
+    // Target GUID
+    if (updateFlags & UPDATEFLAG_HAS_TARGET) {
+        /*uint64_t targetGuid =*/ UpdateObjectParser::readPackedGuid(packet);
+    }
+
+    // Transport time
+    if (updateFlags & UPDATEFLAG_TRANSPORT) {
+        /*uint32_t transportTime =*/ packet.readUInt32();
+    }
+
+    // Low GUID
+    if (updateFlags & UPDATEFLAG_LOWGUID) {
+        /*uint32_t lowGuid =*/ packet.readUInt32();
+    }
+
     // High GUID
     if (updateFlags & UPDATEFLAG_HIGHGUID) {
-        if (rem() < 4) return false;
         /*uint32_t highGuid =*/ packet.readUInt32();
     }
 
-    // ALL/SELF extra uint32
-    if (updateFlags & UPDATEFLAG_ALL) {
-        if (rem() < 4) return false;
-        /*uint32_t unkAll =*/ packet.readUInt32();
-    }
-
-    // Current melee target as packed guid
-    if (updateFlags & UPDATEFLAG_MELEE_ATTACKING) {
-        if (rem() < 1) return false;
-        /*uint64_t meleeTargetGuid =*/ packet.readPackedGuid();
-    }
-
-    // Transport progress / world time
-    if (updateFlags & UPDATEFLAG_TRANSPORT) {
-        if (rem() < 4) return false;
-        /*uint32_t transportTime =*/ packet.readUInt32();
-    }
-
     return true;
 }
 
@@ -345,10 +187,8 @@ bool ClassicPacketParsers::parseMovementBlock(network::Packet& packet, UpdateBlo
 // - Pitch: only SWIMMING (no ONTRANSPORT pitch)
 // ============================================================================
 void ClassicPacketParsers::writeMovementPayload(network::Packet& packet, const MovementInfo& info) {
-    const uint32_t wireFlags = classicWireMoveFlags(info.flags);
-
     // Movement flags (uint32)
-    packet.writeUInt32(wireFlags);
+    packet.writeUInt32(info.flags);
 
     // Classic: NO flags2 byte (TBC has u8, WotLK has u16)
 
@@ -356,16 +196,14 @@ void ClassicPacketParsers::writeMovementPayload(network::Packet& packet, const M
     packet.writeUInt32(info.time);
 
     // Position
-    packet.writeFloat(info.x);
-    packet.writeFloat(info.y);
-    packet.writeFloat(info.z);
-    packet.writeFloat(info.orientation);
+    packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.x), sizeof(float));
+    packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.y), sizeof(float));
+    packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.z), sizeof(float));
+    packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.orientation), sizeof(float));
 
     // Transport data (Classic ONTRANSPORT = 0x02000000, no timestamp)
-    if (wireFlags & ClassicMoveFlags::ONTRANSPORT) {
-        // Packed GUID compression: only transmit non-zero bytes of the 8-byte GUID.
-        // The mask byte indicates which positions are present (bit N = byte N included).
-        // This is the standard WoW packed GUID wire format across all expansions.
+    if (info.flags & ClassicMoveFlags::ONTRANSPORT) {
+        // Packed transport GUID
         uint8_t transMask = 0;
         uint8_t transGuidBytes[8];
         int transGuidByteCount = 0;
@@ -382,29 +220,29 @@ void ClassicPacketParsers::writeMovementPayload(network::Packet& packet, const M
         }
 
         // Transport local position
-        packet.writeFloat(info.transportX);
-        packet.writeFloat(info.transportY);
-        packet.writeFloat(info.transportZ);
-        packet.writeFloat(info.transportO);
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.transportX), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.transportY), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.transportZ), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.transportO), sizeof(float));
 
         // Classic: NO transport timestamp
         // Classic: NO transport seat byte
     }
 
     // Pitch (Classic: only SWIMMING)
-    if (wireFlags & ClassicMoveFlags::SWIMMING) {
-        packet.writeFloat(info.pitch);
+    if (info.flags & ClassicMoveFlags::SWIMMING) {
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.pitch), sizeof(float));
     }
 
     // Fall time (always present)
     packet.writeUInt32(info.fallTime);
 
     // Jump data (Classic JUMPING = 0x2000)
-    if (wireFlags & ClassicMoveFlags::JUMPING) {
-        packet.writeFloat(info.jumpVelocity);
-        packet.writeFloat(info.jumpSinAngle);
-        packet.writeFloat(info.jumpCosAngle);
-        packet.writeFloat(info.jumpXYSpeed);
+    if (info.flags & ClassicMoveFlags::JUMPING) {
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.jumpVelocity), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.jumpSinAngle), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.jumpCosAngle), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.jumpXYSpeed), sizeof(float));
     }
 }
 
@@ -476,533 +314,6 @@ network::Packet ClassicPacketParsers::buildUseItem(uint8_t bagIndex, uint8_t slo
     return packet;
 }
 
-// ============================================================================
-// Classic parseSpellStart — Vanilla 1.12 SMSG_SPELL_START
-//
-// Key differences from TBC:
-//   - GUIDs are PackedGuid (variable-length byte mask + non-zero bytes),
-//     NOT full uint64 as in TBC/WotLK.
-//   - castFlags is uint16 (NOT uint32 as in TBC/WotLK).
-//   - SpellCastTargets uses uint16 targetFlags (NOT uint32 as in TBC).
-//
-// Format: PackedGuid(casterObj) + PackedGuid(casterUnit)
-//       + uint32(spellId) + uint16(castFlags) + uint32(castTime)
-//       + uint16(targetFlags) [+ PackedGuid(unitTarget) if TARGET_FLAG_UNIT]
-// ============================================================================
-bool ClassicPacketParsers::parseSpellStart(network::Packet& packet, SpellStartData& data) {
-    data = SpellStartData{};
-
-    auto rem = [&]() { return packet.getRemainingSize(); };
-    const size_t startPos = packet.getReadPos();
-    if (rem() < 2) return false;
-
-    if (!packet.hasFullPackedGuid()) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.casterGuid = packet.readPackedGuid();
-    if (!packet.hasFullPackedGuid()) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.casterUnit = packet.readPackedGuid();
-
-    // Vanilla/Turtle SMSG_SPELL_START does not include castCount here.
-    // Layout after the two packed GUIDs is spellId(u32) + castFlags(u16) + castTime(u32).
-    if (rem() < 10) return false;
-    data.castCount = 0;
-    data.spellId   = packet.readUInt32();
-    data.castFlags = packet.readUInt16();   // uint16 in Vanilla (uint32 in TBC/WotLK)
-    data.castTime  = packet.readUInt32();
-
-    // SpellCastTargets: consume ALL target payload types so subsequent reads stay aligned.
-    // Previously only UNIT(0x02)/OBJECT(0x800) were handled; DEST_LOCATION(0x40),
-    // SOURCE_LOCATION(0x20), and ITEM(0x10) bytes were silently skipped, corrupting
-    // castFlags/castTime for every AOE/ground-targeted spell (Rain of Fire, Blizzard, etc.).
-    {
-        uint64_t targetGuid = 0;
-        // skipClassicSpellCastTargets reads uint16 targetFlags and all payloads.
-        // Non-fatal on truncation: self-cast spells have zero-byte targets.
-        skipClassicSpellCastTargets(packet, &targetGuid);
-        data.targetGuid = targetGuid;
-    }
-
-    LOG_DEBUG("[Classic] Spell start: spell=", data.spellId, " castTime=", data.castTime, "ms",
-              " targetGuid=0x", std::hex, data.targetGuid, std::dec);
-    return true;
-}
-
-// ============================================================================
-// Classic parseSpellGo — Vanilla 1.12 SMSG_SPELL_GO
-//
-// Same GUID and castFlags format differences as parseSpellStart:
-//   - GUIDs are PackedGuid (not full uint64)
-//   - castFlags is uint16 (not uint32)
-//   - Hit/miss target GUIDs are also PackedGuid in Vanilla
-//
-// Format: PackedGuid(casterObj) + PackedGuid(casterUnit)
-//       + uint32(spellId) + uint16(castFlags)
-//       + uint8(hitCount) + [PackedGuid(hitTarget) × hitCount]
-//       + uint8(missCount) + [PackedGuid(missTarget) + uint8(missType)] × missCount
-// ============================================================================
-bool ClassicPacketParsers::parseSpellGo(network::Packet& packet, SpellGoData& data) {
-    // Always reset output to avoid stale targets when callers reuse buffers.
-    data = SpellGoData{};
-
-    auto rem = [&]() { return packet.getRemainingSize(); };
-    const size_t startPos = packet.getReadPos();
-    const bool traceSmallSpellGo = (packet.getSize() - startPos) <= 48;
-    const auto traceFailure = [&](const char* stage, size_t pos, uint32_t value = 0) {
-        if (!traceSmallSpellGo) {
-            return;
-        }
-        static uint32_t smallSpellGoTraceCount = 0;
-        ++smallSpellGoTraceCount;
-        if (smallSpellGoTraceCount > 12 && (smallSpellGoTraceCount % 50) != 0) {
-            return;
-        }
-        LOG_WARNING("[Classic] Spell go trace: stage=", stage,
-                    " pos=", pos,
-                    " size=", packet.getSize() - startPos,
-                    " spell=", data.spellId,
-                    " castFlags=0x", std::hex, data.castFlags, std::dec,
-                    " value=", value,
-                    " bytes=[", formatPacketBytes(packet, startPos), "]");
-    };
-    if (rem() < 2) return false;
-
-    if (!packet.hasFullPackedGuid()) return false;
-    data.casterGuid = packet.readPackedGuid();
-    if (!packet.hasFullPackedGuid()) return false;
-    data.casterUnit = packet.readPackedGuid();
-
-    // Vanilla/Turtle SMSG_SPELL_GO does not include castCount here.
-    // Layout after the two packed GUIDs is spellId(u32) + castFlags(u16).
-    if (rem() < 6) return false;
-    data.castCount = 0;
-    data.spellId   = packet.readUInt32();
-    data.castFlags = packet.readUInt16();   // uint16 in Vanilla (uint32 in TBC/WotLK)
-
-    const size_t countsPos = packet.getReadPos();
-    uint64_t ignoredTargetGuid = 0;
-    std::function<bool(bool)> parseHitAndMissLists = [&](bool allowTargetsFallback) -> bool {
-        packet.setReadPos(countsPos);
-        data.hitTargets.clear();
-        data.missTargets.clear();
-        ignoredTargetGuid = 0;
-
-        // hitCount is mandatory in SMSG_SPELL_GO. Missing byte means truncation.
-        if (rem() < 1) {
-            LOG_WARNING("[Classic] Spell go: missing hitCount after fixed fields");
-            traceFailure("missing_hit_count", packet.getReadPos());
-            packet.setReadPos(startPos);
-            return false;
-        }
-        const uint8_t rawHitCount = packet.readUInt8();
-        if (rawHitCount > 128) {
-            LOG_WARNING("[Classic] Spell go: hitCount capped (requested=", static_cast<int>(rawHitCount), ")");
-        }
-        if (rem() < static_cast<size_t>(rawHitCount) + 1u) {
-            static uint32_t badHitCountTrunc = 0;
-            ++badHitCountTrunc;
-            if (badHitCountTrunc <= 10 || (badHitCountTrunc % 100) == 0) {
-                LOG_WARNING("[Classic] Spell go: invalid hitCount/remaining (hits=", static_cast<int>(rawHitCount),
-                            " remaining=", rem(), " occurrence=", badHitCountTrunc, ")");
-            }
-            traceFailure("invalid_hit_count", packet.getReadPos(), rawHitCount);
-            packet.setReadPos(startPos);
-            return false;
-        }
-
-        const auto parseHitList = [&](bool usePackedGuids) -> bool {
-            packet.setReadPos(countsPos + 1); // after hitCount
-            data.hitTargets.clear();
-            const uint8_t storedHitLimit = std::min<uint8_t>(rawHitCount, 128);
-            data.hitTargets.reserve(storedHitLimit);
-            for (uint16_t i = 0; i < rawHitCount; ++i) {
-                uint64_t targetGuid = 0;
-                if (usePackedGuids) {
-                    if (!packet.hasFullPackedGuid()) {
-                        return false;
-                    }
-                    targetGuid = packet.readPackedGuid();
-                } else {
-                    if (rem() < 8) {
-                        return false;
-                    }
-                    targetGuid = packet.readUInt64();
-                }
-                if (i < storedHitLimit) {
-                    data.hitTargets.push_back(targetGuid);
-                }
-            }
-            data.hitCount = static_cast<uint8_t>(data.hitTargets.size());
-            return true;
-        };
-
-        if (!parseHitList(false) && !parseHitList(true)) {
-            LOG_WARNING("[Classic] Spell go: truncated hit targets at index 0/", static_cast<int>(rawHitCount));
-            traceFailure("truncated_hit_target", packet.getReadPos(), rawHitCount);
-            packet.setReadPos(startPos);
-            return false;
-        }
-
-        std::function<bool(size_t, bool)> parseMissListFrom = [&](size_t missStartPos,
-                                                                  bool allowMidTargetsFallback) -> bool {
-            packet.setReadPos(missStartPos);
-            data.missTargets.clear();
-
-            if (rem() < 1) {
-                LOG_WARNING("[Classic] Spell go: missing missCount after hit target list");
-                traceFailure("missing_miss_count", packet.getReadPos());
-                packet.setReadPos(startPos);
-                return false;
-            }
-            const uint8_t rawMissCount = packet.readUInt8();
-            if (rawMissCount > 128) {
-                LOG_WARNING("[Classic] Spell go: missCount capped (requested=", static_cast<int>(rawMissCount), ")");
-                traceFailure("miss_count_capped", packet.getReadPos() - 1, rawMissCount);
-            }
-            if (rem() < static_cast<size_t>(rawMissCount) * 2u) {
-                if (allowMidTargetsFallback) {
-                    packet.setReadPos(missStartPos);
-                    if (skipClassicSpellCastTargets(packet, &ignoredTargetGuid)) {
-                        traceFailure("mid_targets_fallback", missStartPos, ignoredTargetGuid != 0 ? 1u : 0u);
-                        return parseMissListFrom(packet.getReadPos(), false);
-                    }
-                }
-                if (allowTargetsFallback) {
-                    packet.setReadPos(countsPos);
-                    if (skipClassicSpellCastTargets(packet, &ignoredTargetGuid)) {
-                        traceFailure("pre_targets_fallback", countsPos, ignoredTargetGuid != 0 ? 1u : 0u);
-                        return parseHitAndMissLists(false);
-                    }
-                }
-
-                static uint32_t badMissCountTrunc = 0;
-                ++badMissCountTrunc;
-                if (badMissCountTrunc <= 10 || (badMissCountTrunc % 100) == 0) {
-                    LOG_WARNING("[Classic] Spell go: invalid missCount/remaining (misses=", static_cast<int>(rawMissCount),
-                                " remaining=", rem(), " occurrence=", badMissCountTrunc, ")");
-                }
-                traceFailure("invalid_miss_count", packet.getReadPos(), rawMissCount);
-                packet.setReadPos(startPos);
-                return false;
-            }
-
-            const uint8_t storedMissLimit = std::min<uint8_t>(rawMissCount, 128);
-            data.missTargets.reserve(storedMissLimit);
-            bool truncatedMissTargets = false;
-            const auto parseMissEntry = [&](SpellGoMissEntry& m, bool usePackedGuid) -> bool {
-                if (usePackedGuid) {
-                    if (!packet.hasFullPackedGuid()) {
-                        return false;
-                    }
-                    m.targetGuid = packet.readPackedGuid();
-                } else {
-                    if (rem() < 8) {
-                        return false;
-                    }
-                    m.targetGuid = packet.readUInt64();
-                }
-                return true;
-            };
-            for (uint16_t i = 0; i < rawMissCount; ++i) {
-                SpellGoMissEntry m;
-                const size_t missEntryPos = packet.getReadPos();
-                if (!parseMissEntry(m, false)) {
-                    packet.setReadPos(missEntryPos);
-                    if (!parseMissEntry(m, true)) {
-                        LOG_WARNING("[Classic] Spell go: truncated miss targets at index ", i,
-                                    "/", static_cast<int>(rawMissCount));
-                        traceFailure("truncated_miss_target", packet.getReadPos(), i);
-                        truncatedMissTargets = true;
-                        break;
-                    }
-                }
-                if (rem() < 1) {
-                    LOG_WARNING("[Classic] Spell go: missing missType at miss index ", i,
-                                "/", static_cast<int>(rawMissCount));
-                    traceFailure("missing_miss_type", packet.getReadPos(), i);
-                    truncatedMissTargets = true;
-                    break;
-                }
-                m.missType = packet.readUInt8();
-                if (m.missType == 11) {
-                    if (rem() < 1) {
-                        LOG_WARNING("[Classic] Spell go: truncated reflect payload at miss index ", i,
-                                    "/", static_cast<int>(rawMissCount));
-                        traceFailure("truncated_reflect", packet.getReadPos(), i);
-                        truncatedMissTargets = true;
-                        break;
-                    }
-                    (void)packet.readUInt8();
-                }
-                if (i < storedMissLimit) {
-                    data.missTargets.push_back(m);
-                }
-            }
-            if (truncatedMissTargets) {
-                packet.setReadPos(startPos);
-                return false;
-            }
-            data.missCount = static_cast<uint8_t>(data.missTargets.size());
-            return true;
-        };
-
-        return parseMissListFrom(packet.getReadPos(), true);
-    };
-
-    if (!parseHitAndMissLists(true)) {
-        return false;
-    }
-
-    // SpellCastTargets follows the miss list — consume all target bytes so that
-    // any subsequent fields (e.g. castFlags extras) are not misaligned.
-    skipClassicSpellCastTargets(packet, &data.targetGuid);
-
-    LOG_DEBUG("[Classic] Spell go: spell=", data.spellId, " hits=", static_cast<int>(data.hitCount),
-              " misses=", static_cast<int>(data.missCount));
-    return true;
-}
-
-// ============================================================================
-// Classic parseAttackerStateUpdate — Vanilla 1.12 SMSG_ATTACKERSTATEUPDATE
-//
-// Identical to TBC format except GUIDs are PackedGuid (not full uint64).
-// Format: uint32(hitInfo) + PackedGuid(attacker) + PackedGuid(target)
-//       + int32(totalDamage) + uint8(subDamageCount)
-//       + [per sub: uint32(schoolMask) + float(damage) + uint32(intDamage)
-//                 + uint32(absorbed) + uint32(resisted)]
-//       + uint32(victimState) + int32(overkill) [+ uint32(blocked)]
-// ============================================================================
-bool ClassicPacketParsers::parseAttackerStateUpdate(network::Packet& packet, AttackerStateUpdateData& data) {
-    data = AttackerStateUpdateData{};
-
-    auto rem = [&]() { return packet.getRemainingSize(); };
-    if (rem() < 5) return false;  // hitInfo(4) + at least GUID mask byte(1)
-
-    const size_t startPos = packet.getReadPos();
-    data.hitInfo      = packet.readUInt32();
-    if (!packet.hasFullPackedGuid()) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.attackerGuid = packet.readPackedGuid(); // PackedGuid in Vanilla
-    if (!packet.hasFullPackedGuid()) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.targetGuid   = packet.readPackedGuid(); // PackedGuid in Vanilla
-
-    if (rem() < 5) {
-        packet.setReadPos(startPos);
-        return false;
-    }  // int32 totalDamage + uint8 subDamageCount
-    data.totalDamage    = static_cast<int32_t>(packet.readUInt32());
-    data.subDamageCount = packet.readUInt8();
-
-    const uint8_t maxSubDamageCount = static_cast<uint8_t>(std::min<size_t>(rem() / 20, 64));
-    if (data.subDamageCount > maxSubDamageCount) {
-        data.subDamageCount = maxSubDamageCount;
-    }
-
-    data.subDamages.reserve(data.subDamageCount);
-    for (uint8_t i = 0; i < data.subDamageCount; ++i) {
-        if (rem() < 20) {
-            packet.setReadPos(startPos);
-            return false;
-        }
-        SubDamage sub;
-        sub.schoolMask = packet.readUInt32();
-        sub.damage     = packet.readFloat();
-        sub.intDamage  = packet.readUInt32();
-        sub.absorbed   = packet.readUInt32();
-        sub.resisted   = packet.readUInt32();
-        data.subDamages.push_back(sub);
-    }
-    data.subDamageCount = static_cast<uint8_t>(data.subDamages.size());
-
-    if (rem() < 8) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.victimState = packet.readUInt32();
-    data.overkill    = static_cast<int32_t>(packet.readUInt32());
-
-    if (rem() >= 4) {
-        data.blocked = packet.readUInt32();
-    }
-
-    LOG_DEBUG("[Classic] Melee hit: ", data.totalDamage, " damage",
-              data.isCrit() ? " (CRIT)" : "",
-              data.isMiss() ? " (MISS)" : "");
-    return true;
-}
-
-// ============================================================================
-// Classic parseSpellDamageLog — Vanilla 1.12 SMSG_SPELLNONMELEEDAMAGELOG
-//
-// Identical to TBC except GUIDs are PackedGuid (not full uint64).
-// Format: PackedGuid(target) + PackedGuid(caster) + uint32(spellId)
-//       + uint32(damage) + uint8(schoolMask) + uint32(absorbed) + uint32(resisted)
-//       + uint8(periodicLog) + uint8(unused) + uint32(blocked) + uint32(flags)
-// ============================================================================
-bool ClassicPacketParsers::parseSpellDamageLog(network::Packet& packet, SpellDamageLogData& data) {
-    auto rem = [&]() { return packet.getRemainingSize(); };
-    if (rem() < 2 || !packet.hasFullPackedGuid()) return false;
-
-    data.targetGuid   = packet.readPackedGuid(); // PackedGuid in Vanilla
-    if (rem() < 1 || !packet.hasFullPackedGuid()) return false;
-    data.attackerGuid = packet.readPackedGuid(); // PackedGuid in Vanilla
-
-    // uint32(spellId) + uint32(damage) + uint8(schoolMask) + uint32(absorbed)
-    // + uint32(resisted) + uint8 + uint8 + uint32(blocked) + uint32(flags) = 21 bytes
-    if (rem() < 21) return false;
-    data.spellId    = packet.readUInt32();
-    data.damage     = packet.readUInt32();
-    data.schoolMask = packet.readUInt8();
-    data.absorbed   = packet.readUInt32();
-    data.resisted   = packet.readUInt32();
-    packet.readUInt8();    // periodicLog
-    packet.readUInt8();    // unused
-    packet.readUInt32();   // blocked
-    uint32_t flags  = packet.readUInt32();
-    data.isCrit     = (flags & 0x02) != 0;
-    data.overkill   = 0;  // no overkill field in Vanilla (same as TBC)
-
-    LOG_DEBUG("[Classic] Spell damage: spellId=", data.spellId, " dmg=", data.damage,
-              data.isCrit ? " CRIT" : "");
-    return true;
-}
-
-// ============================================================================
-// Classic parseSpellHealLog — Vanilla 1.12 SMSG_SPELLHEALLOG
-//
-// Identical to TBC except GUIDs are PackedGuid (not full uint64).
-// Format: PackedGuid(target) + PackedGuid(caster) + uint32(spellId)
-//       + uint32(heal) + uint32(overheal) + uint8(crit)
-// ============================================================================
-bool ClassicPacketParsers::parseSpellHealLog(network::Packet& packet, SpellHealLogData& data) {
-    auto rem = [&]() { return packet.getRemainingSize(); };
-    if (rem() < 2 || !packet.hasFullPackedGuid()) return false;
-
-    data.targetGuid = packet.readPackedGuid(); // PackedGuid in Vanilla
-    if (rem() < 1 || !packet.hasFullPackedGuid()) return false;
-    data.casterGuid = packet.readPackedGuid(); // PackedGuid in Vanilla
-
-    if (rem() < 13) return false;  // uint32 + uint32 + uint32 + uint8 = 13 bytes
-    data.spellId  = packet.readUInt32();
-    data.heal     = packet.readUInt32();
-    data.overheal = packet.readUInt32();
-    data.isCrit   = (packet.readUInt8() != 0);
-
-    LOG_DEBUG("[Classic] Spell heal: spellId=", data.spellId, " heal=", data.heal,
-              data.isCrit ? " CRIT" : "");
-    return true;
-}
-
-// ============================================================================
-// Classic parseAuraUpdate — Vanilla 1.12 SMSG_AURA_UPDATE / SMSG_AURA_UPDATE_ALL
-//
-// Classic has SMSG_AURA_UPDATE (TBC does not — TBC uses a different aura system
-// and the TBC override returns false with a warning).  Classic inherits TBC's
-// override by default, so this override is needed to restore aura tracking.
-//
-// Classic aura flags differ from WotLK:
-//   0x01/0x02/0x04 = effect indices active   (same as WotLK)
-//   0x08 = CANCELABLE / NOT-NEGATIVE         (WotLK: 0x08 = NOT_CASTER)
-//   0x10 = DURATION                          (WotLK: 0x20 = DURATION)
-//   0x20 = NOT_CASTER                        (WotLK: no caster GUID at all if 0x08)
-//   0x40 = POSITIVE                          (WotLK: 0x40 = EFFECT_AMOUNTS)
-//
-// Key differences from WotLK parser:
-//   - No caster GUID field in Classic SMSG_AURA_UPDATE packets
-//   - DURATION bit is 0x10, not 0x20
-//   - No effect amounts field (WotLK 0x40 = EFFECT_AMOUNTS does not exist here)
-//
-// Format: PackedGuid(entity) + [uint8(slot) + uint32(spellId)
-//         [+ uint8(flags) + uint8(level) + uint8(charges)
-//          + [uint32(maxDuration) + uint32(duration) if flags & 0x10]]*
-// ============================================================================
-bool ClassicPacketParsers::parseAuraUpdate(network::Packet& packet, AuraUpdateData& data, bool isAll) {
-    auto rem = [&]() { return packet.getRemainingSize(); };
-    if (rem() < 1) return false;
-
-    data.guid = packet.readPackedGuid();
-
-    while (rem() > 0) {
-        if (rem() < 1) break;
-        uint8_t slot = packet.readUInt8();
-        if (rem() < 4) break;
-        uint32_t spellId = packet.readUInt32();
-
-        AuraSlot aura;
-        if (spellId != 0) {
-            aura.spellId = spellId;
-            if (rem() < 3) { data.updates.push_back({slot, aura}); break; }
-            aura.flags   = packet.readUInt8();
-            aura.level   = packet.readUInt8();
-            aura.charges = packet.readUInt8();
-
-            // Classic DURATION flag is 0x10 (WotLK uses 0x20)
-            if ((aura.flags & 0x10) && rem() >= 8) {
-                aura.maxDurationMs = static_cast<int32_t>(packet.readUInt32());
-                aura.durationMs    = static_cast<int32_t>(packet.readUInt32());
-            }
-            // No caster GUID field in Classic (WotLK added it gated by 0x08 NOT_CASTER)
-            // No effect amounts field in Classic (WotLK added it gated by 0x40)
-        }
-
-        data.updates.push_back({slot, aura});
-        if (!isAll) break;
-    }
-
-    LOG_DEBUG("[Classic] Aura update for 0x", std::hex, data.guid, std::dec,
-              ": ", data.updates.size(), " slots");
-    return true;
-}
-
-// ============================================================================
-// Classic SMSG_NAME_QUERY_RESPONSE format (1.12 / vmangos):
-//   uint64 guid (full, GetObjectGuid)
-//   CString name
-//   CString realmName (usually empty = single \0 byte)
-//   uint32 race
-//   uint32 gender
-//   uint32 class
-//
-// TBC Variant A (inherited from TbcPacketParsers) skips the realmName CString,
-// causing it to misread the uint32 race field (absorbs the realmName \0 byte
-// as the low byte), producing race=0 and shifted gender/class values.
-// ============================================================================
-bool ClassicPacketParsers::parseNameQueryResponse(network::Packet& packet, NameQueryResponseData& data) {
-    data = NameQueryResponseData{};
-
-    auto rem = [&]() { return packet.getRemainingSize(); };
-    if (rem() < 8) return false;
-
-    data.guid = packet.readUInt64();     // full uint64, not PackedGuid
-    data.name = packet.readString();     // null-terminated name
-    if (rem() == 0) return !data.name.empty();
-
-    data.realmName = packet.readString(); // null-terminated realm name (usually "")
-    if (rem() < 12) return !data.name.empty();
-
-    uint32_t race   = packet.readUInt32();
-    uint32_t gender = packet.readUInt32();
-    uint32_t cls    = packet.readUInt32();
-    data.race    = static_cast<uint8_t>(race   & 0xFF);
-    data.gender  = static_cast<uint8_t>(gender & 0xFF);
-    data.classId = static_cast<uint8_t>(cls    & 0xFF);
-    data.found   = 0;
-
-    LOG_DEBUG("[Classic] Name query response: ", data.name,
-              " (race=", static_cast<int>(data.race), " gender=", static_cast<int>(data.gender),
-              " class=", static_cast<int>(data.classId), ")");
-    return !data.name.empty();
-}
-
 // ============================================================================
 // Classic SMSG_CAST_FAILED: no castCount byte (added in TBC/WotLK)
 // Format: spellId(u32) + result(u8)
@@ -1015,23 +326,7 @@ bool ClassicPacketParsers::parseCastFailed(network::Packet& packet, CastFailedDa
     // WotLK enum starts at 0=SUCCESS, 1=AFFECTING_COMBAT.
     // Shift +1 to align with WotLK result strings.
     data.result = vanillaResult + 1;
-    LOG_DEBUG("[Classic] Cast failed: spell=", data.spellId, " vanillaResult=", static_cast<int>(vanillaResult));
-    return true;
-}
-
-// ============================================================================
-// Classic SMSG_CAST_RESULT: same layout as parseCastFailed (spellId + result),
-// but the result enum starts at 0=AFFECTING_COMBAT (no SUCCESS entry).
-// Apply the same +1 shift used in parseCastFailed so the result codes
-// align with WotLK's getSpellCastResultString table.
-// ============================================================================
-bool ClassicPacketParsers::parseCastResult(network::Packet& packet, uint32_t& spellId, uint8_t& result) {
-    if (!packet.hasRemaining(5)) return false;
-    spellId = packet.readUInt32();
-    uint8_t vanillaResult = packet.readUInt8();
-    // Shift +1: Vanilla result 0=AFFECTING_COMBAT maps to WotLK result 1=AFFECTING_COMBAT
-    result = vanillaResult + 1;
-    LOG_DEBUG("[Classic] Cast result: spell=", spellId, " vanillaResult=", static_cast<int>(vanillaResult));
+    LOG_DEBUG("[Classic] Cast failed: spell=", data.spellId, " vanillaResult=", (int)vanillaResult);
     return true;
 }
 
@@ -1044,40 +339,14 @@ bool ClassicPacketParsers::parseCastResult(network::Packet& packet, uint32_t& sp
 // - After flags: uint8 firstLogin (same as TBC)
 // ============================================================================
 bool ClassicPacketParsers::parseCharEnum(network::Packet& packet, CharEnumResponse& response) {
-    // Validate minimum packet size for count byte
-    if (packet.getSize() < 1) {
-        LOG_ERROR("[Classic] SMSG_CHAR_ENUM packet too small: ", packet.getSize(), " bytes");
-        return false;
-    }
-
     uint8_t count = packet.readUInt8();
 
-    // Cap count to prevent excessive memory allocation
-    constexpr uint8_t kMaxCharacters = 32;
-    if (count > kMaxCharacters) {
-        LOG_WARNING("[Classic] Character count ", static_cast<int>(count), " exceeds max ", static_cast<int>(kMaxCharacters),
-                    ", capping");
-        count = kMaxCharacters;
-    }
-
-    LOG_INFO("[Classic] Parsing SMSG_CHAR_ENUM: ", static_cast<int>(count), " characters");
+    LOG_INFO("[Classic] Parsing SMSG_CHAR_ENUM: ", (int)count, " characters");
 
     response.characters.clear();
     response.characters.reserve(count);
 
     for (uint8_t i = 0; i < count; ++i) {
-        // Sanity check: ensure we have at least minimal data before reading next character
-        // Minimum: guid(8) + name(1) + race(1) + class(1) + gender(1) + appearance(4)
-        //          + facialFeatures(1) + level(1) + zone(4) + map(4) + pos(12) + guild(4)
-        //          + flags(4) + firstLogin(1) + pet(12) + equipment(20*5)
-        constexpr size_t kMinCharacterSize = 8 + 1 + 1 + 1 + 1 + 4 + 1 + 1 + 4 + 4 + 12 + 4 + 4 + 1 + 12 + 100;
-        if (!packet.hasRemaining(kMinCharacterSize)) {
-            LOG_WARNING("[Classic] Character enum packet truncated at character ", static_cast<int>(i + 1),
-                        ", pos=", packet.getReadPos(), " needed=", kMinCharacterSize,
-                        " size=", packet.getSize());
-            break;
-        }
-
         Character character;
 
         // GUID (8 bytes)
@@ -1129,9 +398,13 @@ bool ClassicPacketParsers::parseCharEnum(network::Packet& packet, CharEnumRespon
             character.equipment.push_back(item);
         }
 
-        LOG_DEBUG("  Character ", static_cast<int>(i + 1), ": ", character.name,
-                  " (", getRaceName(character.race), " ", getClassName(character.characterClass),
-                  " level ", static_cast<int>(character.level), " zone ", character.zoneId, ")");
+        LOG_INFO("  Character ", (int)(i + 1), ": ", character.name);
+        LOG_INFO("    GUID: 0x", std::hex, character.guid, std::dec);
+        LOG_INFO("    ", getRaceName(character.race), " ",
+                 getClassName(character.characterClass), " (",
+                 getGenderName(character.gender), ")");
+        LOG_INFO("    Level: ", (int)character.level);
+        LOG_INFO("    Location: Zone ", character.zoneId, ", Map ", character.mapId);
 
         response.characters.push_back(character);
     }
@@ -1249,7 +522,7 @@ bool ClassicPacketParsers::parseMessageChat(network::Packet& packet, MessageChat
     }
 
     // Read chat tag
-    if (packet.hasData()) {
+    if (packet.getReadPos() < packet.getSize()) {
         data.chatTag = packet.readUInt8();
     }
 
@@ -1359,12 +632,6 @@ bool ClassicPacketParsers::parseGuildQueryResponse(network::Packet& packet, Guil
 // ============================================================================
 
 bool ClassicPacketParsers::parseGameObjectQueryResponse(network::Packet& packet, GameObjectQueryResponseData& data) {
-    // Validate minimum packet size: entry(4)
-    if (packet.getSize() < 4) {
-        LOG_ERROR("Classic SMSG_GAMEOBJECT_QUERY_RESPONSE: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
     data.entry = packet.readUInt32();
 
     // High bit set means gameobject not found
@@ -1374,12 +641,6 @@ bool ClassicPacketParsers::parseGameObjectQueryResponse(network::Packet& packet,
         return true;
     }
 
-    // Validate minimum size for fixed fields: type(4) + displayId(4)
-    if (!packet.hasRemaining(8)) {
-        LOG_ERROR("Classic SMSG_GAMEOBJECT_QUERY_RESPONSE: truncated before names (entry=", data.entry, ")");
-        return false;
-    }
-
     data.type = packet.readUInt32();
     data.displayId = packet.readUInt32();
     // 4 name strings
@@ -1389,22 +650,12 @@ bool ClassicPacketParsers::parseGameObjectQueryResponse(network::Packet& packet,
     packet.readString();
 
     // Classic: data[24] comes immediately after names (no extra strings)
-    size_t remaining = packet.getRemainingSize();
+    size_t remaining = packet.getSize() - packet.getReadPos();
     if (remaining >= 24 * 4) {
         for (int i = 0; i < 24; i++) {
             data.data[i] = packet.readUInt32();
         }
         data.hasData = true;
-    } else if (remaining > 0) {
-        // Partial data field; read what we can
-        uint32_t fieldsToRead = remaining / 4;
-        for (uint32_t i = 0; i < fieldsToRead && i < 24; i++) {
-            data.data[i] = packet.readUInt32();
-        }
-        if (fieldsToRead < 24) {
-            LOG_WARNING("Classic SMSG_GAMEOBJECT_QUERY_RESPONSE: truncated in data fields (", fieldsToRead,
-                        " of 24 read, entry=", data.entry, ")");
-        }
     }
 
     if (data.type == 15) { // MO_TRANSPORT
@@ -1422,7 +673,7 @@ bool ClassicPacketParsers::parseGameObjectQueryResponse(network::Packet& packet,
 // ============================================================================
 
 bool ClassicPacketParsers::parseGossipMessage(network::Packet& packet, GossipMessageData& data) {
-    size_t remaining = packet.getRemainingSize();
+    size_t remaining = packet.getSize() - packet.getReadPos();
     if (remaining < 8 + 4 + 4) {
         LOG_ERROR("Classic SMSG_GOSSIP_MESSAGE too small: ", remaining, " bytes");
         return false;
@@ -1434,24 +685,9 @@ bool ClassicPacketParsers::parseGossipMessage(network::Packet& packet, GossipMes
     data.titleTextId = packet.readUInt32();
     uint32_t optionCount = packet.readUInt32();
 
-    // Cap option count to reasonable maximum
-    constexpr uint32_t kMaxGossipOptions = 256;
-    if (optionCount > kMaxGossipOptions) {
-        LOG_WARNING("Classic SMSG_GOSSIP_MESSAGE optionCount=", optionCount, " exceeds max ",
-                    kMaxGossipOptions, ", capping");
-        optionCount = kMaxGossipOptions;
-    }
-
     data.options.clear();
     data.options.reserve(optionCount);
     for (uint32_t i = 0; i < optionCount; ++i) {
-        // Sanity check: ensure minimum bytes available for option (id(4)+icon(1)+isCoded(1)+text(1))
-        remaining = packet.getRemainingSize();
-        if (remaining < 7) {
-            LOG_WARNING("Classic gossip option ", i, " truncated (", remaining, " bytes left)");
-            break;
-        }
-
         GossipOption opt;
         opt.id = packet.readUInt32();
         opt.icon = packet.readUInt8();
@@ -1463,33 +699,10 @@ bool ClassicPacketParsers::parseGossipMessage(network::Packet& packet, GossipMes
         data.options.push_back(opt);
     }
 
-    // Ensure we have at least 4 bytes for questCount
-    remaining = packet.getRemainingSize();
-    if (remaining < 4) {
-        LOG_WARNING("Classic SMSG_GOSSIP_MESSAGE truncated before questCount");
-        return data.options.size() > 0;  // Return true if we got at least some options
-    }
-
     uint32_t questCount = packet.readUInt32();
-
-    // Cap quest count to reasonable maximum
-    constexpr uint32_t kMaxGossipQuests = 256;
-    if (questCount > kMaxGossipQuests) {
-        LOG_WARNING("Classic SMSG_GOSSIP_MESSAGE questCount=", questCount, " exceeds max ",
-                    kMaxGossipQuests, ", capping");
-        questCount = kMaxGossipQuests;
-    }
-
     data.quests.clear();
     data.quests.reserve(questCount);
     for (uint32_t i = 0; i < questCount; ++i) {
-        // Sanity check: ensure minimum bytes available for quest (id(4)+icon(4)+level(4)+title(1))
-        remaining = packet.getRemainingSize();
-        if (remaining < 13) {
-            LOG_WARNING("Classic gossip quest ", i, " truncated (", remaining, " bytes left)");
-            break;
-        }
-
         GossipQuestItem quest;
         quest.questId = packet.readUInt32();
         quest.questIcon = packet.readUInt32();
@@ -1501,7 +714,7 @@ bool ClassicPacketParsers::parseGossipMessage(network::Packet& packet, GossipMes
         data.quests.push_back(quest);
     }
 
-    LOG_DEBUG("Classic Gossip: ", optionCount, " options, ", questCount, " quests");
+    LOG_INFO("Classic Gossip: ", optionCount, " options, ", questCount, " quests");
     return true;
 }
 
@@ -1515,7 +728,7 @@ network::Packet ClassicPacketParsers::buildSendMail(uint64_t mailboxGuid,
                                                      const std::string& recipient,
                                                      const std::string& subject,
                                                      const std::string& body,
-                                                     uint64_t money, uint64_t cod,
+                                                     uint32_t money, uint32_t cod,
                                                      const std::vector<uint64_t>& itemGuids) {
     network::Packet packet(wireOpcode(Opcode::CMSG_SEND_MAIL));
     packet.writeUInt64(mailboxGuid);
@@ -1546,17 +759,17 @@ network::Packet ClassicPacketParsers::buildSendMail(uint64_t mailboxGuid,
 // ============================================================================
 bool ClassicPacketParsers::parseMailList(network::Packet& packet,
                                          std::vector<MailMessage>& inbox) {
-    size_t remaining = packet.getRemainingSize();
+    size_t remaining = packet.getSize() - packet.getReadPos();
     if (remaining < 1) return false;
 
     uint8_t count = packet.readUInt8();
-    LOG_INFO("SMSG_MAIL_LIST_RESULT (Classic): count=", static_cast<int>(count));
+    LOG_INFO("SMSG_MAIL_LIST_RESULT (Classic): count=", (int)count);
 
     inbox.clear();
     inbox.reserve(count);
 
     for (uint8_t i = 0; i < count; ++i) {
-        remaining = packet.getRemainingSize();
+        remaining = packet.getSize() - packet.getReadPos();
         if (remaining < 5) {
             LOG_WARNING("Classic mail entry ", i, " truncated (", remaining, " bytes left)");
             break;
@@ -1665,12 +878,6 @@ network::Packet ClassicPacketParsers::buildItemQuery(uint32_t entry, uint64_t gu
 }
 
 bool ClassicPacketParsers::parseItemQueryResponse(network::Packet& packet, ItemQueryResponseData& data) {
-    // Validate minimum packet size: entry(4)
-    if (packet.getSize() < 4) {
-        LOG_ERROR("Classic SMSG_ITEM_QUERY_SINGLE_RESPONSE: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
     data.entry = packet.readUInt32();
 
     // High bit set means item not found
@@ -1679,12 +886,6 @@ bool ClassicPacketParsers::parseItemQueryResponse(network::Packet& packet, ItemQ
         return true;
     }
 
-    // Validate minimum size for fixed fields: itemClass(4) + subClass(4) + 4 name strings + displayInfoId(4) + quality(4)
-    if (!packet.hasRemaining(8)) {
-        LOG_ERROR("Classic SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated before names (entry=", data.entry, ")");
-        return false;
-    }
-
     uint32_t itemClass = packet.readUInt32();
     uint32_t subClass = packet.readUInt32();
     // Vanilla: NO SoundOverrideSubclass
@@ -1733,50 +934,30 @@ bool ClassicPacketParsers::parseItemQueryResponse(network::Packet& packet, ItemQ
     data.displayInfoId = packet.readUInt32();
     data.quality = packet.readUInt32();
 
-    // Validate minimum size for fixed fields: Flags(4) + BuyPrice(4) + SellPrice(4) + inventoryType(4)
-    if (!packet.hasRemaining(16)) {
-        LOG_ERROR("Classic SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated before inventoryType (entry=", data.entry, ")");
-        return false;
-    }
-
-    data.itemFlags = packet.readUInt32(); // Flags
+    packet.readUInt32(); // Flags
     // Vanilla: NO Flags2
     packet.readUInt32(); // BuyPrice
     data.sellPrice = packet.readUInt32(); // SellPrice
 
     data.inventoryType = packet.readUInt32();
 
-    // Validate minimum size for remaining fixed fields: 13×4 = 52 bytes
-    if (!packet.hasRemaining(52)) {
-        LOG_ERROR("Classic SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated before stats (entry=", data.entry, ")");
-        return false;
-    }
-
-    data.allowableClass = packet.readUInt32(); // AllowableClass
-    data.allowableRace  = packet.readUInt32(); // AllowableRace
-    data.itemLevel = packet.readUInt32();
-    data.requiredLevel = packet.readUInt32();
-    data.requiredSkill     = packet.readUInt32(); // RequiredSkill
-    data.requiredSkillRank = packet.readUInt32(); // RequiredSkillRank
+    packet.readUInt32(); // AllowableClass
+    packet.readUInt32(); // AllowableRace
+    packet.readUInt32(); // ItemLevel
+    packet.readUInt32(); // RequiredLevel
+    packet.readUInt32(); // RequiredSkill
+    packet.readUInt32(); // RequiredSkillRank
     packet.readUInt32(); // RequiredSpell
     packet.readUInt32(); // RequiredHonorRank
     packet.readUInt32(); // RequiredCityRank
-    data.requiredReputationFaction = packet.readUInt32(); // RequiredReputationFaction
-    data.requiredReputationRank    = packet.readUInt32(); // RequiredReputationRank
-    data.maxCount = static_cast<int32_t>(packet.readUInt32()); // MaxCount (1 = Unique)
+    packet.readUInt32(); // RequiredReputationFaction
+    packet.readUInt32(); // RequiredReputationRank
+    packet.readUInt32(); // MaxCount
     data.maxStack = static_cast<int32_t>(packet.readUInt32()); // Stackable
     data.containerSlots = packet.readUInt32();
 
-    // Vanilla: 10 stat pairs, NO statsCount prefix (10×8 = 80 bytes)
-    if (!packet.hasRemaining(80)) {
-        LOG_WARNING("Classic SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated in stats section (entry=", data.entry, ")");
-        // Read what we can
-    }
+    // Vanilla: 10 stat pairs, NO statsCount prefix
     for (uint32_t i = 0; i < 10; i++) {
-        if (!packet.hasRemaining(8)) {
-            LOG_WARNING("Classic SMSG_ITEM_QUERY_SINGLE_RESPONSE: stat ", i, " truncated (entry=", data.entry, ")");
-            break;
-        }
         uint32_t statType = packet.readUInt32();
         int32_t statValue = static_cast<int32_t>(packet.readUInt32());
         if (statType != 0) {
@@ -1786,10 +967,7 @@ bool ClassicPacketParsers::parseItemQueryResponse(network::Packet& packet, ItemQ
                 case 5: data.intellect = statValue; break;
                 case 6: data.spirit = statValue; break;
                 case 7: data.stamina = statValue; break;
-                default:
-                    if (statValue != 0)
-                        data.extraStats.push_back({statType, statValue});
-                    break;
+                default: break;
             }
         }
     }
@@ -1799,11 +977,6 @@ bool ClassicPacketParsers::parseItemQueryResponse(network::Packet& packet, ItemQ
     // Vanilla: 5 damage types (same count as WotLK)
     bool haveWeaponDamage = false;
     for (int i = 0; i < 5; i++) {
-        // Each damage entry is dmgMin(4) + dmgMax(4) + damageType(4) = 12 bytes
-        if (!packet.hasRemaining(12)) {
-            LOG_WARNING("Classic SMSG_ITEM_QUERY_SINGLE_RESPONSE: damage ", i, " truncated (entry=", data.entry, ")");
-            break;
-        }
         float dmgMin = packet.readFloat();
         float dmgMax = packet.readFloat();
         uint32_t damageType = packet.readUInt32();
@@ -1817,58 +990,19 @@ bool ClassicPacketParsers::parseItemQueryResponse(network::Packet& packet, ItemQ
         }
     }
 
-    // Validate minimum size for armor field (4 bytes)
-    if (!packet.hasRemaining(4)) {
-        LOG_WARNING("Classic SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated before armor (entry=", data.entry, ")");
-        return true;  // Have core fields; armor is important but optional
-    }
     data.armor = static_cast<int32_t>(packet.readUInt32());
 
     // Remaining tail can vary by core. Read resistances + delay when present.
-    if (packet.hasRemaining(28)) {
-        data.holyRes   = static_cast<int32_t>(packet.readUInt32()); // HolyRes
-        data.fireRes   = static_cast<int32_t>(packet.readUInt32()); // FireRes
-        data.natureRes = static_cast<int32_t>(packet.readUInt32()); // NatureRes
-        data.frostRes  = static_cast<int32_t>(packet.readUInt32()); // FrostRes
-        data.shadowRes = static_cast<int32_t>(packet.readUInt32()); // ShadowRes
-        data.arcaneRes = static_cast<int32_t>(packet.readUInt32()); // ArcaneRes
+    if (packet.getSize() - packet.getReadPos() >= 28) {
+        packet.readUInt32(); // HolyRes
+        packet.readUInt32(); // FireRes
+        packet.readUInt32(); // NatureRes
+        packet.readUInt32(); // FrostRes
+        packet.readUInt32(); // ShadowRes
+        packet.readUInt32(); // ArcaneRes
         data.delayMs = packet.readUInt32();
     }
 
-    // AmmoType + RangedModRange (2 fields, 8 bytes)
-    if (packet.hasRemaining(8)) {
-        packet.readUInt32(); // AmmoType
-        packet.readFloat();  // RangedModRange
-    }
-
-    // 2 item spells in Vanilla (3 fields each: SpellId, Trigger, Charges)
-    // Actually vanilla has 5 spells: SpellId, Trigger, Charges, Cooldown, Category, CatCooldown = 24 bytes each
-    for (int i = 0; i < 5; i++) {
-        if (!packet.hasRemaining(24)) break;
-        data.spells[i].spellId = packet.readUInt32();
-        data.spells[i].spellTrigger = packet.readUInt32();
-        packet.readUInt32(); // SpellCharges
-        packet.readUInt32(); // SpellCooldown
-        packet.readUInt32(); // SpellCategory
-        packet.readUInt32(); // SpellCategoryCooldown
-    }
-
-    // Bonding type
-    if (packet.hasRemaining(4))
-        data.bindType = packet.readUInt32();
-
-    // Description (flavor/lore text)
-    if (packet.hasData())
-        data.description = packet.readString();
-
-    // Post-description: PageText, LanguageID, PageMaterial, StartQuest
-    if (packet.hasRemaining(16)) {
-        packet.readUInt32(); // PageText
-        packet.readUInt32(); // LanguageID
-        packet.readUInt32(); // PageMaterial
-        data.startQuestId = packet.readUInt32(); // StartQuest
-    }
-
     data.valid = !data.name.empty();
     LOG_DEBUG("[Classic] Item query response: ", data.name, " (quality=", data.quality,
              " invType=", data.inventoryType, " stack=", data.maxStack, ")");
@@ -1913,24 +1047,19 @@ namespace TurtleMoveFlags {
 }
 
 bool TurtlePacketParsers::parseMovementBlock(network::Packet& packet, UpdateBlock& block) {
-    auto rem = [&]() -> size_t { return packet.getRemainingSize(); };
-    if (rem() < 1) return false;
-
     uint8_t updateFlags = packet.readUInt8();
     block.updateFlags = static_cast<uint16_t>(updateFlags);
 
-    LOG_DEBUG("  [Turtle] UpdateFlags: 0x", std::hex, static_cast<int>(updateFlags), std::dec);
+    LOG_DEBUG("  [Turtle] UpdateFlags: 0x", std::hex, (int)updateFlags, std::dec);
 
-    const uint8_t UPDATEFLAG_TRANSPORT       = 0x02;
-    const uint8_t UPDATEFLAG_MELEE_ATTACKING = 0x04;
-    const uint8_t UPDATEFLAG_HIGHGUID        = 0x08;
-    const uint8_t UPDATEFLAG_ALL             = 0x10;
-    const uint8_t UPDATEFLAG_LIVING          = 0x20;
-    const uint8_t UPDATEFLAG_HAS_POSITION    = 0x40;
+    const uint8_t UPDATEFLAG_LIVING       = 0x20;
+    const uint8_t UPDATEFLAG_HAS_POSITION = 0x40;
+    const uint8_t UPDATEFLAG_HAS_TARGET   = 0x04;
+    const uint8_t UPDATEFLAG_TRANSPORT    = 0x02;
+    const uint8_t UPDATEFLAG_LOWGUID      = 0x08;
+    const uint8_t UPDATEFLAG_HIGHGUID     = 0x10;
 
     if (updateFlags & UPDATEFLAG_LIVING) {
-        // Minimum: moveFlags(4)+time(4)+position(16)+fallTime(4)+speeds(24) = 52 bytes
-        if (rem() < 52) return false;
         size_t livingStart = packet.getReadPos();
 
         uint32_t moveFlags = packet.readUInt32();
@@ -1949,10 +1078,8 @@ bool TurtlePacketParsers::parseMovementBlock(network::Packet& packet, UpdateBloc
 
         // Transport — Classic flag position 0x02000000
         if (moveFlags & TurtleMoveFlags::ONTRANSPORT) {
-            if (rem() < 1) return false; // PackedGuid mask byte
             block.onTransport = true;
-            block.transportGuid = packet.readPackedGuid();
-            if (rem() < 20) return false; // 4 floats + u32 timestamp
+            block.transportGuid = UpdateObjectParser::readPackedGuid(packet);
             block.transportX = packet.readFloat();
             block.transportY = packet.readFloat();
             block.transportZ = packet.readFloat();
@@ -1962,17 +1089,14 @@ bool TurtlePacketParsers::parseMovementBlock(network::Packet& packet, UpdateBloc
 
         // Pitch (swimming only, Classic-style)
         if (moveFlags & TurtleMoveFlags::SWIMMING) {
-            if (rem() < 4) return false;
             /*float pitch =*/ packet.readFloat();
         }
 
         // Fall time (always present)
-        if (rem() < 4) return false;
         /*uint32_t fallTime =*/ packet.readUInt32();
 
         // Jump data
         if (moveFlags & TurtleMoveFlags::JUMPING) {
-            if (rem() < 16) return false;
             /*float jumpVelocity =*/ packet.readFloat();
             /*float jumpSinAngle =*/ packet.readFloat();
             /*float jumpCosAngle =*/ packet.readFloat();
@@ -1981,12 +1105,10 @@ bool TurtlePacketParsers::parseMovementBlock(network::Packet& packet, UpdateBloc
 
         // Spline elevation
         if (moveFlags & TurtleMoveFlags::SPLINE_ELEVATION) {
-            if (rem() < 4) return false;
             /*float splineElevation =*/ packet.readFloat();
         }
 
         // Turtle: 6 speeds (same as Classic — no flight speeds)
-        if (rem() < 24) return false; // 6 × float
         float walkSpeed = packet.readFloat();
         float runSpeed = packet.readFloat();
         float runBackSpeed = packet.readFloat();
@@ -2004,23 +1126,17 @@ bool TurtlePacketParsers::parseMovementBlock(network::Packet& packet, UpdateBloc
         bool hasSpline = (moveFlags & TurtleMoveFlags::SPLINE_CLASSIC) ||
                          (moveFlags & TurtleMoveFlags::SPLINE_TBC);
         if (hasSpline) {
-            if (rem() < 4) return false;
             uint32_t splineFlags = packet.readUInt32();
             LOG_DEBUG("  [Turtle] Spline: flags=0x", std::hex, splineFlags, std::dec);
 
             if (splineFlags & 0x00010000) {
-                if (rem() < 12) return false;
                 packet.readFloat(); packet.readFloat(); packet.readFloat();
             } else if (splineFlags & 0x00020000) {
-                if (rem() < 8) return false;
                 packet.readUInt64();
             } else if (splineFlags & 0x00040000) {
-                if (rem() < 4) return false;
                 packet.readFloat();
             }
 
-            // timePassed + duration + splineId + pointCount = 16 bytes
-            if (rem() < 16) return false;
             /*uint32_t timePassed =*/ packet.readUInt32();
             /*uint32_t duration =*/ packet.readUInt32();
             /*uint32_t splineId =*/ packet.readUInt32();
@@ -2031,12 +1147,10 @@ bool TurtlePacketParsers::parseMovementBlock(network::Packet& packet, UpdateBloc
                 ++badTurtleSplineCount;
                 if (badTurtleSplineCount <= 5 || (badTurtleSplineCount % 100) == 0) {
                     LOG_WARNING("  [Turtle] Spline pointCount=", pointCount,
-                                " exceeds max (occurrence=", badTurtleSplineCount, ")");
+                                " exceeds max, capping (occurrence=", badTurtleSplineCount, ")");
                 }
-                return false;
+                pointCount = 0;
             }
-            // points + endPoint
-            if (rem() < static_cast<size_t>(pointCount) * 12 + 12) return false;
             for (uint32_t i = 0; i < pointCount; i++) {
                 packet.readFloat(); packet.readFloat(); packet.readFloat();
             }
@@ -2049,7 +1163,6 @@ bool TurtlePacketParsers::parseMovementBlock(network::Packet& packet, UpdateBloc
                   " bytes, readPos now=", packet.getReadPos());
     }
     else if (updateFlags & UPDATEFLAG_HAS_POSITION) {
-        if (rem() < 16) return false;
         block.x = packet.readFloat();
         block.y = packet.readFloat();
         block.z = packet.readFloat();
@@ -2059,274 +1172,40 @@ bool TurtlePacketParsers::parseMovementBlock(network::Packet& packet, UpdateBloc
         LOG_DEBUG("  [Turtle] STATIONARY: (", block.x, ", ", block.y, ", ", block.z, ")");
     }
 
+    // Target GUID
+    if (updateFlags & UPDATEFLAG_HAS_TARGET) {
+        /*uint64_t targetGuid =*/ UpdateObjectParser::readPackedGuid(packet);
+    }
+
+    // Transport time
+    if (updateFlags & UPDATEFLAG_TRANSPORT) {
+        /*uint32_t transportTime =*/ packet.readUInt32();
+    }
+
+    // Low GUID — Classic-style: 1×u32 (NOT TBC's 2×u32)
+    if (updateFlags & UPDATEFLAG_LOWGUID) {
+        /*uint32_t lowGuid =*/ packet.readUInt32();
+    }
+
     // High GUID — 1×u32
     if (updateFlags & UPDATEFLAG_HIGHGUID) {
-        if (rem() < 4) return false;
         /*uint32_t highGuid =*/ packet.readUInt32();
     }
 
-    if (updateFlags & UPDATEFLAG_ALL) {
-        if (rem() < 4) return false;
-        /*uint32_t unkAll =*/ packet.readUInt32();
-    }
-
-    if (updateFlags & UPDATEFLAG_MELEE_ATTACKING) {
-        if (rem() < 1) return false;
-        /*uint64_t meleeTargetGuid =*/ packet.readPackedGuid();
-    }
-
-    if (updateFlags & UPDATEFLAG_TRANSPORT) {
-        if (rem() < 4) return false;
-        /*uint32_t transportTime =*/ packet.readUInt32();
-    }
-
     return true;
 }
 
-bool TurtlePacketParsers::parseUpdateObject(network::Packet& packet, UpdateObjectData& data) {
-    constexpr uint32_t kMaxReasonableUpdateBlocks = 4096;
-
-    auto parseWithLayout = [&](bool withHasTransportByte, UpdateObjectData& out) -> bool {
-        out = UpdateObjectData{};
-        const size_t start = packet.getReadPos();
-        if (packet.getSize() - start < 4) return false;
-
-        out.blockCount = packet.readUInt32();
-        if (out.blockCount > kMaxReasonableUpdateBlocks) {
-            packet.setReadPos(start);
-            return false;
-        }
-
-        if (withHasTransportByte) {
-            if (!packet.hasData()) {
-                packet.setReadPos(start);
-                return false;
-            }
-            /*uint8_t hasTransport =*/ packet.readUInt8();
-        }
-
-        uint32_t remainingBlockCount = out.blockCount;
-
-        if (packet.hasRemaining(1)) {
-            uint8_t firstByte = packet.readUInt8();
-            if (firstByte == static_cast<uint8_t>(UpdateType::OUT_OF_RANGE_OBJECTS)) {
-                if (remainingBlockCount == 0) {
-                    packet.setReadPos(start);
-                    return false;
-                }
-                --remainingBlockCount;
-                if (!packet.hasRemaining(4)) {
-                    packet.setReadPos(start);
-                    return false;
-                }
-                uint32_t count = packet.readUInt32();
-                if (count > kMaxReasonableUpdateBlocks) {
-                    packet.setReadPos(start);
-                    return false;
-                }
-                for (uint32_t i = 0; i < count; ++i) {
-                    if (!packet.hasData()) {
-                        packet.setReadPos(start);
-                        return false;
-                    }
-                    out.outOfRangeGuids.push_back(packet.readPackedGuid());
-                }
-            } else {
-                packet.setReadPos(packet.getReadPos() - 1);
-            }
-        }
-
-        out.blockCount = remainingBlockCount;
-        out.blocks.reserve(out.blockCount);
-        for (uint32_t i = 0; i < out.blockCount; ++i) {
-            if (!packet.hasData()) {
-                // If we already parsed some blocks, keep them (layout is confirmed valid).
-                if (!out.blocks.empty()) break;
-                packet.setReadPos(start);
-                return false;
-            }
-
-            const size_t blockStart = packet.getReadPos();
-            uint8_t updateTypeVal = packet.readUInt8();
-            if (updateTypeVal > static_cast<uint8_t>(UpdateType::NEAR_OBJECTS)) {
-                if (!out.blocks.empty()) break;
-                packet.setReadPos(start);
-                return false;
-            }
-
-            const UpdateType updateType = static_cast<UpdateType>(updateTypeVal);
-            UpdateBlock block;
-            block.updateType = updateType;
-            bool ok = false;
-
-            auto parseMovementVariant = [&](auto&& movementParser, const char* layoutName) -> bool {
-                packet.setReadPos(blockStart + 1);
-                block = UpdateBlock{};
-                block.updateType = updateType;
-
-                switch (updateType) {
-                    case UpdateType::MOVEMENT:
-                        block.guid = packet.readUInt64();
-                        if (!movementParser(packet, block)) return false;
-                        LOG_DEBUG("[Turtle] Parsed MOVEMENT block via ", layoutName, " layout");
-                        return true;
-                    case UpdateType::CREATE_OBJECT:
-                    case UpdateType::CREATE_OBJECT2:
-                        block.guid = packet.readPackedGuid();
-                        if (!packet.hasData()) return false;
-                        block.objectType = static_cast<ObjectType>(packet.readUInt8());
-                        if (!movementParser(packet, block)) return false;
-                        if (!UpdateObjectParser::parseUpdateFields(packet, block)) return false;
-                        LOG_DEBUG("[Turtle] Parsed CREATE block via ", layoutName, " layout");
-                        return true;
-                    default:
-                        return false;
-                }
-            };
-
-            switch (updateType) {
-                case UpdateType::VALUES:
-                    block.guid = packet.readPackedGuid();
-                    ok = UpdateObjectParser::parseUpdateFields(packet, block);
-                    break;
-                case UpdateType::MOVEMENT:
-                case UpdateType::CREATE_OBJECT:
-                case UpdateType::CREATE_OBJECT2:
-                    ok = parseMovementVariant(
-                        [this](network::Packet& p, UpdateBlock& b) {
-                            return this->TurtlePacketParsers::parseMovementBlock(p, b);
-                        }, "turtle");
-                    if (!ok) {
-                        ok = parseMovementVariant(
-                            [this](network::Packet& p, UpdateBlock& b) {
-                                return this->ClassicPacketParsers::parseMovementBlock(p, b);
-                            }, "classic");
-                    }
-                    if (!ok) {
-                        ok = parseMovementVariant(
-                            [this](network::Packet& p, UpdateBlock& b) {
-                                return this->TbcPacketParsers::parseMovementBlock(p, b);
-                            }, "tbc");
-                    }
-                    // NOTE: Do NOT fall back to WotLK parseMovementBlock here.
-                    // WotLK uses uint16 updateFlags and 9 speeds vs Classic's uint8
-                    // and 6 speeds. A false-positive WotLK parse consumes wrong bytes,
-                    // corrupting subsequent update fields and losing NPC data.
-                    break;
-                case UpdateType::OUT_OF_RANGE_OBJECTS:
-                case UpdateType::NEAR_OBJECTS:
-                    ok = true;
-                    break;
-                default:
-                    ok = false;
-                    break;
-            }
-
-            if (!ok) {
-                static int turtleBlockErrors = 0;
-                if (++turtleBlockErrors <= 5) {
-                    LOG_WARNING("[Turtle] SMSG_UPDATE_OBJECT block parse failed",
-                                " blockIndex=", i, " of ", out.blockCount,
-                                " updateType=", updateTypeName(updateType),
-                                " readPos=", packet.getReadPos(),
-                                " blockStart=", blockStart,
-                                " packetSize=", packet.getSize(),
-                                " (", out.blocks.size(), " blocks kept)");
-                }
-                // Keep successfully parsed blocks instead of discarding all.
-                // Cannot re-sync within the packet, so stop parsing here.
-                break;
-            }
-
-            out.blocks.push_back(std::move(block));
-        }
-
-        return true;
-    };
-
-    const size_t startPos = packet.getReadPos();
-    UpdateObjectData parsed;
-    if (parseWithLayout(true, parsed)) {
-        data = std::move(parsed);
-        return true;
-    }
-
-    packet.setReadPos(startPos);
-    if (parseWithLayout(false, parsed)) {
-        LOG_DEBUG("[Turtle] SMSG_UPDATE_OBJECT parsed without has_transport byte fallback");
-        data = std::move(parsed);
-        return true;
-    }
-
-    packet.setReadPos(startPos);
-    if (ClassicPacketParsers::parseUpdateObject(packet, parsed)) {
-        LOG_DEBUG("[Turtle] SMSG_UPDATE_OBJECT parsed via full classic fallback");
-        data = std::move(parsed);
-        return true;
-    }
-
-    packet.setReadPos(startPos);
-    if (TbcPacketParsers::parseUpdateObject(packet, parsed)) {
-        LOG_DEBUG("[Turtle] SMSG_UPDATE_OBJECT parsed via full TBC fallback");
-        data = std::move(parsed);
-        return true;
-    }
-
-    packet.setReadPos(startPos);
-    return false;
-}
-
 bool TurtlePacketParsers::parseMonsterMove(network::Packet& packet, MonsterMoveData& data) {
-    // Turtle realms can emit vanilla-like, TBC-like, and WotLK-like monster move
-    // bodies. Try the lower-expansion layouts first before the WotLK parser that
-    // expects an extra unk byte after the packed GUID.
+    // Turtle realms can emit both vanilla-like and WotLK-like monster move bodies.
+    // Try the canonical Turtle/vanilla parser first, then fall back to WotLK layout.
     size_t start = packet.getReadPos();
     if (MonsterMoveParser::parseVanilla(packet, data)) {
         return true;
     }
 
-    packet.setReadPos(start);
-    if (TbcPacketParsers::parseMonsterMove(packet, data)) {
-        LOG_DEBUG("[Turtle] SMSG_MONSTER_MOVE parsed via TBC fallback layout");
-        return true;
-    }
-
-    auto looksLikeWotlkMonsterMove = [&](network::Packet& probe) -> bool {
-        const size_t probeStart = probe.getReadPos();
-        uint64_t guid = probe.readPackedGuid();
-        if (guid == 0) {
-            probe.setReadPos(probeStart);
-            return false;
-        }
-        if (probe.getReadPos() >= probe.getSize()) {
-            probe.setReadPos(probeStart);
-            return false;
-        }
-        uint8_t unk = probe.readUInt8();
-        if (unk > 1) {
-            probe.setReadPos(probeStart);
-            return false;
-        }
-        if (probe.getReadPos() + 12 + 4 + 1 > probe.getSize()) {
-            probe.setReadPos(probeStart);
-            return false;
-        }
-        probe.readFloat(); probe.readFloat(); probe.readFloat(); // xyz
-        probe.readUInt32(); // splineId
-        uint8_t moveType = probe.readUInt8();
-        probe.setReadPos(probeStart);
-        return moveType >= 1 && moveType <= 4;
-    };
-
-    packet.setReadPos(start);
-    if (!looksLikeWotlkMonsterMove(packet)) {
-        packet.setReadPos(start);
-        return false;
-    }
-
     packet.setReadPos(start);
     if (MonsterMoveParser::parse(packet, data)) {
-        LOG_DEBUG("[Turtle] SMSG_MONSTER_MOVE parsed via WotLK fallback layout");
+        LOG_WARNING("[Turtle] SMSG_MONSTER_MOVE parsed via WotLK fallback layout");
         return true;
     }
 
@@ -2381,49 +1260,52 @@ network::Packet ClassicPacketParsers::buildAcceptQuestPacket(uint64_t npcGuid, u
 }
 
 // ============================================================================
-// ClassicPacketParsers::parseCreatureQueryResponse
-//
-// Classic 1.12 SMSG_CREATURE_QUERY_RESPONSE lacks the iconName CString field
-// that TBC 2.4.3 and WotLK 3.3.5a include between subName and typeFlags.
-// Without this override, the TBC/WotLK parser reads typeFlags bytes as the
-// iconName string, shifting typeFlags/creatureType/family/rank by 1-4 bytes.
+// Classic SMSG_QUESTGIVER_QUEST_DETAILS — Vanilla 1.12 format
+// WotLK inserts an informUnit GUID (8 bytes) between npcGuid and questId.
+// Vanilla has: npcGuid(8) + questId(4) + title + details + objectives + ...
 // ============================================================================
-bool ClassicPacketParsers::parseCreatureQueryResponse(network::Packet& packet,
-                                                       CreatureQueryResponseData& data) {
-    // Validate minimum packet size: entry(4)
-    if (packet.getSize() < 4) {
-        LOG_ERROR("Classic SMSG_CREATURE_QUERY_RESPONSE: packet too small (", packet.getSize(), " bytes)");
-        return false;
+bool ClassicPacketParsers::parseQuestDetails(network::Packet& packet, QuestDetailsData& data) {
+    if (packet.getSize() < 16) return false;
+
+    data.npcGuid = packet.readUInt64();
+    // Vanilla: questId follows immediately — no informUnit GUID
+    data.questId = packet.readUInt32();
+    data.title      = normalizeWowTextTokens(packet.readString());
+    data.details    = normalizeWowTextTokens(packet.readString());
+    data.objectives = normalizeWowTextTokens(packet.readString());
+
+    if (packet.getReadPos() + 5 > packet.getSize()) {
+        LOG_INFO("Quest details classic (short): id=", data.questId, " title='", data.title, "'");
+        return !data.title.empty() || data.questId != 0;
     }
 
-    data.entry = packet.readUInt32();
-    if (data.entry & 0x80000000) {
-        data.entry &= ~0x80000000;
-        data.name = "";
-        return true;
+    /*activateAccept*/ packet.readUInt8();
+    data.suggestedPlayers = packet.readUInt32();
+
+    // Choice reward items: variable count + 3 uint32s each
+    if (packet.getReadPos() + 4 <= packet.getSize()) {
+        uint32_t choiceCount = packet.readUInt32();
+        for (uint32_t i = 0; i < choiceCount && packet.getReadPos() + 12 <= packet.getSize(); ++i) {
+            packet.readUInt32(); // itemId
+            packet.readUInt32(); // count
+            packet.readUInt32(); // displayInfo
+        }
     }
 
-    data.name = packet.readString();
-    packet.readString(); // name2
-    packet.readString(); // name3
-    packet.readString(); // name4
-    data.subName = packet.readString();
-    // NOTE: NO iconName field in Classic 1.12 — goes straight to typeFlags
-    if (!packet.hasRemaining(16)) {
-        LOG_WARNING("Classic SMSG_CREATURE_QUERY_RESPONSE: truncated at typeFlags (entry=", data.entry, ")");
-        data.typeFlags = 0;
-        data.creatureType = 0;
-        data.family = 0;
-        data.rank = 0;
-        return true;  // Have name/sub fields; base fields are important but optional
+    // Fixed reward items: variable count + 3 uint32s each
+    if (packet.getReadPos() + 4 <= packet.getSize()) {
+        uint32_t rewardCount = packet.readUInt32();
+        for (uint32_t i = 0; i < rewardCount && packet.getReadPos() + 12 <= packet.getSize(); ++i) {
+            packet.readUInt32(); // itemId
+            packet.readUInt32(); // count
+            packet.readUInt32(); // displayInfo
+        }
     }
-    data.typeFlags    = packet.readUInt32();
-    data.creatureType = packet.readUInt32();
-    data.family       = packet.readUInt32();
-    data.rank         = packet.readUInt32();
 
-    LOG_DEBUG("Classic SMSG_CREATURE_QUERY_RESPONSE: ", data.name, " type=", data.creatureType,
-              " rank=", data.rank);
+    if (packet.getReadPos() + 4 <= packet.getSize())
+        data.rewardMoney = packet.readUInt32();
+
+    LOG_INFO("Quest details classic: id=", data.questId, " title='", data.title, "'");
     return true;
 }
 
diff --git a/src/game/packet_parsers_tbc.cpp b/src/game/packet_parsers_tbc.cpp
index 165a4348..e4275640 100644
--- a/src/game/packet_parsers_tbc.cpp
+++ b/src/game/packet_parsers_tbc.cpp
@@ -30,14 +30,11 @@ namespace TbcMoveFlags {
 // - Flag 0x08 (HIGH_GUID) reads 2 u32s (Classic: 1 u32)
 // ============================================================================
 bool TbcPacketParsers::parseMovementBlock(network::Packet& packet, UpdateBlock& block) {
-    auto rem = [&]() -> size_t { return packet.getRemainingSize(); };
-    if (rem() < 1) return false;
-
     // TBC 2.4.3: UpdateFlags is uint8 (1 byte)
     uint8_t updateFlags = packet.readUInt8();
     block.updateFlags = static_cast<uint16_t>(updateFlags);
 
-    LOG_DEBUG("  [TBC] UpdateFlags: 0x", std::hex, static_cast<int>(updateFlags), std::dec);
+    LOG_DEBUG("  [TBC] UpdateFlags: 0x", std::hex, (int)updateFlags, std::dec);
 
     // TBC UpdateFlag bit values (same as lower byte of WotLK):
     // 0x01 = SELF
@@ -55,9 +52,6 @@ bool TbcPacketParsers::parseMovementBlock(network::Packet& packet, UpdateBlock&
     const uint8_t UPDATEFLAG_HIGHGUID            = 0x10;
 
     if (updateFlags & UPDATEFLAG_LIVING) {
-        // Minimum: moveFlags(4)+moveFlags2(1)+time(4)+position(16)+fallTime(4)+speeds(32) = 61
-        if (rem() < 61) return false;
-
         // Full movement block for living units
         uint32_t moveFlags = packet.readUInt32();
         uint8_t moveFlags2 = packet.readUInt8();  // TBC: uint8, not uint16
@@ -76,33 +70,29 @@ bool TbcPacketParsers::parseMovementBlock(network::Packet& packet, UpdateBlock&
 
         // Transport data
         if (moveFlags & TbcMoveFlags::ON_TRANSPORT) {
-            if (rem() < 1) return false;
             block.onTransport = true;
-            block.transportGuid = packet.readPackedGuid();
-            if (rem() < 20) return false; // 4 floats + 1 uint32
+            block.transportGuid = UpdateObjectParser::readPackedGuid(packet);
             block.transportX = packet.readFloat();
             block.transportY = packet.readFloat();
             block.transportZ = packet.readFloat();
             block.transportO = packet.readFloat();
             /*uint32_t tTime =*/ packet.readUInt32();
+            // TBC: NO transport seat byte
+            // TBC: NO interpolated movement check
         }
 
         // Pitch: SWIMMING, or else ONTRANSPORT (TBC-specific secondary pitch)
         if (moveFlags & TbcMoveFlags::SWIMMING) {
-            if (rem() < 4) return false;
             /*float pitch =*/ packet.readFloat();
         } else if (moveFlags & TbcMoveFlags::ONTRANSPORT) {
-            if (rem() < 4) return false;
             /*float pitch =*/ packet.readFloat();
         }
 
         // Fall time (always present)
-        if (rem() < 4) return false;
         /*uint32_t fallTime =*/ packet.readUInt32();
 
         // Jumping (TBC: JUMPING=0x2000, WotLK: FALLING=0x1000)
         if (moveFlags & TbcMoveFlags::JUMPING) {
-            if (rem() < 16) return false;
             /*float jumpVelocity =*/ packet.readFloat();
             /*float jumpSinAngle =*/ packet.readFloat();
             /*float jumpCosAngle =*/ packet.readFloat();
@@ -111,12 +101,11 @@ bool TbcPacketParsers::parseMovementBlock(network::Packet& packet, UpdateBlock&
 
         // Spline elevation (TBC: 0x02000000, WotLK: 0x04000000)
         if (moveFlags & TbcMoveFlags::SPLINE_ELEVATION) {
-            if (rem() < 4) return false;
             /*float splineElevation =*/ packet.readFloat();
         }
 
         // Speeds (TBC: 8 values — walk, run, runBack, swim, fly, flyBack, swimBack, turn)
-        if (rem() < 32) return false;
+        // WotLK adds pitchRate (9 total)
         /*float walkSpeed =*/ packet.readFloat();
         float runSpeed = packet.readFloat();
         /*float runBackSpeed =*/ packet.readFloat();
@@ -127,52 +116,52 @@ bool TbcPacketParsers::parseMovementBlock(network::Packet& packet, UpdateBlock&
         /*float turnRate =*/ packet.readFloat();
 
         block.runSpeed = runSpeed;
-        block.moveFlags = moveFlags;
 
         // Spline data (TBC/WotLK: SPLINE_ENABLED = 0x08000000)
         if (moveFlags & TbcMoveFlags::SPLINE_ENABLED) {
-            if (rem() < 4) return false;
             uint32_t splineFlags = packet.readUInt32();
             LOG_DEBUG("  [TBC] Spline: flags=0x", std::hex, splineFlags, std::dec);
 
             if (splineFlags & 0x00010000) { // FINAL_POINT
-                if (rem() < 12) return false;
                 /*float finalX =*/ packet.readFloat();
                 /*float finalY =*/ packet.readFloat();
                 /*float finalZ =*/ packet.readFloat();
             } else if (splineFlags & 0x00020000) { // FINAL_TARGET
-                if (rem() < 8) return false;
                 /*uint64_t finalTarget =*/ packet.readUInt64();
             } else if (splineFlags & 0x00040000) { // FINAL_ANGLE
-                if (rem() < 4) return false;
                 /*float finalAngle =*/ packet.readFloat();
             }
 
-            // TBC spline: timePassed, duration, id, pointCount
-            if (rem() < 16) return false;
+            // TBC spline: timePassed, duration, id, nodes, finalNode
+            // (no durationMod, durationModNext, verticalAccel, effectStartTime, splineMode)
             /*uint32_t timePassed =*/ packet.readUInt32();
             /*uint32_t duration =*/ packet.readUInt32();
             /*uint32_t splineId =*/ packet.readUInt32();
 
             uint32_t pointCount = packet.readUInt32();
-            // Cap waypoints to prevent DoS from malformed packets allocating huge arrays
-            if (pointCount > 256) return false;
-
-            // points + endPoint (no splineMode in TBC)
-            if (rem() < static_cast<size_t>(pointCount) * 12 + 12) return false;
+            if (pointCount > 256) {
+                static uint32_t badTbcSplineCount = 0;
+                ++badTbcSplineCount;
+                if (badTbcSplineCount <= 5 || (badTbcSplineCount % 100) == 0) {
+                    LOG_WARNING("  [TBC] Spline pointCount=", pointCount,
+                                " exceeds max, capping (occurrence=", badTbcSplineCount, ")");
+                }
+                pointCount = 0;
+            }
             for (uint32_t i = 0; i < pointCount; i++) {
                 /*float px =*/ packet.readFloat();
                 /*float py =*/ packet.readFloat();
                 /*float pz =*/ packet.readFloat();
             }
 
+            // TBC: NO splineMode byte (WotLK adds it)
             /*float endPointX =*/ packet.readFloat();
             /*float endPointY =*/ packet.readFloat();
             /*float endPointZ =*/ packet.readFloat();
         }
     }
     else if (updateFlags & UPDATEFLAG_HAS_POSITION) {
-        if (rem() < 16) return false;
+        // TBC: Simple stationary position (same as WotLK STATIONARY)
         block.x = packet.readFloat();
         block.y = packet.readFloat();
         block.z = packet.readFloat();
@@ -181,29 +170,29 @@ bool TbcPacketParsers::parseMovementBlock(network::Packet& packet, UpdateBlock&
 
         LOG_DEBUG("  [TBC] STATIONARY: (", block.x, ", ", block.y, ", ", block.z, ")");
     }
+    // TBC: No UPDATEFLAG_POSITION (0x0100) code path
 
     // Target GUID
     if (updateFlags & UPDATEFLAG_HAS_TARGET) {
-        if (rem() < 1) return false;
-        /*uint64_t targetGuid =*/ packet.readPackedGuid();
+        /*uint64_t targetGuid =*/ UpdateObjectParser::readPackedGuid(packet);
     }
 
     // Transport time
     if (updateFlags & UPDATEFLAG_TRANSPORT) {
-        if (rem() < 4) return false;
         /*uint32_t transportTime =*/ packet.readUInt32();
     }
 
-    // LOWGUID (0x08) — TBC has 2 u32s, Classic has 1 u32
+    // TBC: No VEHICLE flag (WotLK 0x0080)
+    // TBC: No ROTATION flag (WotLK 0x0200)
+
+    // HIGH_GUID (0x08) — TBC has 2 u32s, Classic has 1 u32
     if (updateFlags & UPDATEFLAG_LOWGUID) {
-        if (rem() < 8) return false;
         /*uint32_t unknown0 =*/ packet.readUInt32();
         /*uint32_t unknown1 =*/ packet.readUInt32();
     }
 
-    // HIGHGUID (0x10)
+    // ALL (0x10)
     if (updateFlags & UPDATEFLAG_HIGHGUID) {
-        if (rem() < 4) return false;
         /*uint32_t unknown2 =*/ packet.readUInt32();
     }
 
@@ -229,10 +218,10 @@ void TbcPacketParsers::writeMovementPayload(network::Packet& packet, const Movem
     packet.writeUInt32(info.time);
 
     // Position
-    packet.writeFloat(info.x);
-    packet.writeFloat(info.y);
-    packet.writeFloat(info.z);
-    packet.writeFloat(info.orientation);
+    packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.x), sizeof(float));
+    packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.y), sizeof(float));
+    packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.z), sizeof(float));
+    packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.orientation), sizeof(float));
 
     // Transport data (TBC ON_TRANSPORT = 0x200, same bit as WotLK)
     if (info.flags & TbcMoveFlags::ON_TRANSPORT) {
@@ -253,10 +242,10 @@ void TbcPacketParsers::writeMovementPayload(network::Packet& packet, const Movem
         }
 
         // Transport local position
-        packet.writeFloat(info.transportX);
-        packet.writeFloat(info.transportY);
-        packet.writeFloat(info.transportZ);
-        packet.writeFloat(info.transportO);
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.transportX), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.transportY), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.transportZ), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.transportO), sizeof(float));
 
         // Transport time
         packet.writeUInt32(info.transportTime);
@@ -267,9 +256,9 @@ void TbcPacketParsers::writeMovementPayload(network::Packet& packet, const Movem
 
     // Pitch: SWIMMING or else ONTRANSPORT (TBC flag positions)
     if (info.flags & TbcMoveFlags::SWIMMING) {
-        packet.writeFloat(info.pitch);
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.pitch), sizeof(float));
     } else if (info.flags & TbcMoveFlags::ONTRANSPORT) {
-        packet.writeFloat(info.pitch);
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.pitch), sizeof(float));
     }
 
     // Fall time (always present)
@@ -277,10 +266,10 @@ void TbcPacketParsers::writeMovementPayload(network::Packet& packet, const Movem
 
     // Jump data (TBC JUMPING = 0x2000, WotLK FALLING = 0x1000)
     if (info.flags & TbcMoveFlags::JUMPING) {
-        packet.writeFloat(info.jumpVelocity);
-        packet.writeFloat(info.jumpSinAngle);
-        packet.writeFloat(info.jumpCosAngle);
-        packet.writeFloat(info.jumpXYSpeed);
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.jumpVelocity), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.jumpSinAngle), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.jumpCosAngle), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.jumpXYSpeed), sizeof(float));
     }
 }
 
@@ -307,40 +296,14 @@ network::Packet TbcPacketParsers::buildMovementPacket(LogicalOpcode opcode,
 // - Equipment: 20 items (not 23)
 // ============================================================================
 bool TbcPacketParsers::parseCharEnum(network::Packet& packet, CharEnumResponse& response) {
-    // Validate minimum packet size for count byte
-    if (packet.getSize() < 1) {
-        LOG_ERROR("[TBC] SMSG_CHAR_ENUM packet too small: ", packet.getSize(), " bytes");
-        return false;
-    }
-
     uint8_t count = packet.readUInt8();
 
-    // Cap count to prevent excessive memory allocation
-    constexpr uint8_t kMaxCharacters = 32;
-    if (count > kMaxCharacters) {
-        LOG_WARNING("[TBC] Character count ", static_cast<int>(count), " exceeds max ", static_cast<int>(kMaxCharacters),
-                    ", capping");
-        count = kMaxCharacters;
-    }
-
-    LOG_INFO("[TBC] Parsing SMSG_CHAR_ENUM: ", static_cast<int>(count), " characters");
+    LOG_INFO("[TBC] Parsing SMSG_CHAR_ENUM: ", (int)count, " characters");
 
     response.characters.clear();
     response.characters.reserve(count);
 
     for (uint8_t i = 0; i < count; ++i) {
-        // Sanity check: ensure we have at least minimal data before reading next character
-        // Minimum: guid(8) + name(1) + race(1) + class(1) + gender(1) + appearance(4)
-        //          + facialFeatures(1) + level(1) + zone(4) + map(4) + pos(12) + guild(4)
-        //          + flags(4) + firstLogin(1) + pet(12) + equipment(20*9)
-        constexpr size_t kMinCharacterSize = 8 + 1 + 1 + 1 + 1 + 4 + 1 + 1 + 4 + 4 + 12 + 4 + 4 + 1 + 12 + 180;
-        if (!packet.hasRemaining(kMinCharacterSize)) {
-            LOG_WARNING("[TBC] Character enum packet truncated at character ", static_cast<int>(i + 1),
-                        ", pos=", packet.getReadPos(), " needed=", kMinCharacterSize,
-                        " size=", packet.getSize());
-            break;
-        }
-
         Character character;
 
         // GUID (8 bytes)
@@ -392,9 +355,13 @@ bool TbcPacketParsers::parseCharEnum(network::Packet& packet, CharEnumResponse&
             character.equipment.push_back(item);
         }
 
-        LOG_DEBUG("  Character ", static_cast<int>(i + 1), ": ", character.name,
-                  " (", getRaceName(character.race), " ", getClassName(character.characterClass),
-                  " level ", static_cast<int>(character.level), " zone ", character.zoneId, ")");
+        LOG_INFO("  Character ", (int)(i + 1), ": ", character.name);
+        LOG_INFO("    GUID: 0x", std::hex, character.guid, std::dec);
+        LOG_INFO("    ", getRaceName(character.race), " ",
+                 getClassName(character.characterClass), " (",
+                 getGenderName(character.gender), ")");
+        LOG_INFO("    Level: ", (int)character.level);
+        LOG_INFO("    Location: Zone ", character.zoneId, ", Map ", character.mapId);
 
         response.characters.push_back(character);
     }
@@ -429,17 +396,10 @@ bool TbcPacketParsers::parseUpdateObject(network::Packet& packet, UpdateObjectDa
             /*uint8_t hasTransport =*/ packet.readUInt8();
         }
 
-        uint32_t remainingBlockCount = out.blockCount;
-
-        if (packet.hasRemaining(1)) {
+        if (packet.getReadPos() + 1 <= packet.getSize()) {
             uint8_t firstByte = packet.readUInt8();
             if (firstByte == static_cast<uint8_t>(UpdateType::OUT_OF_RANGE_OBJECTS)) {
-                if (remainingBlockCount == 0) {
-                    packet.setReadPos(start);
-                    return false;
-                }
-                --remainingBlockCount;
-                if (!packet.hasRemaining(4)) {
+                if (packet.getReadPos() + 4 > packet.getSize()) {
                     packet.setReadPos(start);
                     return false;
                 }
@@ -453,7 +413,7 @@ bool TbcPacketParsers::parseUpdateObject(network::Packet& packet, UpdateObjectDa
                         packet.setReadPos(start);
                         return false;
                     }
-                    uint64_t guid = packet.readPackedGuid();
+                    uint64_t guid = UpdateObjectParser::readPackedGuid(packet);
                     out.outOfRangeGuids.push_back(guid);
                 }
             } else {
@@ -461,7 +421,6 @@ bool TbcPacketParsers::parseUpdateObject(network::Packet& packet, UpdateObjectDa
             }
         }
 
-        out.blockCount = remainingBlockCount;
         out.blocks.reserve(out.blockCount);
         for (uint32_t i = 0; i < out.blockCount; ++i) {
             if (packet.getReadPos() >= packet.getSize()) {
@@ -480,18 +439,18 @@ bool TbcPacketParsers::parseUpdateObject(network::Packet& packet, UpdateObjectDa
             bool ok = false;
             switch (block.updateType) {
                 case UpdateType::VALUES: {
-                    block.guid = packet.readPackedGuid();
+                    block.guid = UpdateObjectParser::readPackedGuid(packet);
                     ok = UpdateObjectParser::parseUpdateFields(packet, block);
                     break;
                 }
                 case UpdateType::MOVEMENT: {
-                    block.guid = packet.readUInt64();
+                    block.guid = UpdateObjectParser::readPackedGuid(packet);
                     ok = this->parseMovementBlock(packet, block);
                     break;
                 }
                 case UpdateType::CREATE_OBJECT:
                 case UpdateType::CREATE_OBJECT2: {
-                    block.guid = packet.readPackedGuid();
+                    block.guid = UpdateObjectParser::readPackedGuid(packet);
                     if (packet.getReadPos() >= packet.getSize()) {
                         ok = false;
                         break;
@@ -529,7 +488,7 @@ bool TbcPacketParsers::parseUpdateObject(network::Packet& packet, UpdateObjectDa
 
     packet.setReadPos(startPos);
     if (parseWithLayout(false, parsed)) {
-        LOG_DEBUG("[TBC] SMSG_UPDATE_OBJECT parsed without has_transport byte fallback");
+        LOG_WARNING("[TBC] SMSG_UPDATE_OBJECT parsed without has_transport byte fallback");
         data = std::move(parsed);
         return true;
     }
@@ -538,241 +497,6 @@ bool TbcPacketParsers::parseUpdateObject(network::Packet& packet, UpdateObjectDa
     return false;
 }
 
-// ============================================================================
-// TBC 2.4.3 SMSG_GOSSIP_MESSAGE
-// Identical to WotLK except each quest entry lacks questFlags(u32) and
-// isRepeatable(u8) that WotLK added. Without this override the WotLK parser
-// reads those 5 bytes as part of the quest title, corrupting all gossip quests.
-// ============================================================================
-bool TbcPacketParsers::parseGossipMessage(network::Packet& packet, GossipMessageData& data) {
-    if (!packet.hasRemaining(16)) return false;
-
-    data.npcGuid = packet.readUInt64();
-    data.menuId = packet.readUInt32();      // TBC added menuId (Classic doesn't have it)
-    data.titleTextId = packet.readUInt32();
-    uint32_t optionCount = packet.readUInt32();
-
-    // Cap option count to reasonable maximum
-    constexpr uint32_t kMaxGossipOptions = 256;
-    if (optionCount > kMaxGossipOptions) {
-        LOG_WARNING("[TBC] SMSG_GOSSIP_MESSAGE optionCount=", optionCount, " exceeds max ",
-                    kMaxGossipOptions, ", capping");
-        optionCount = kMaxGossipOptions;
-    }
-
-    data.options.clear();
-    data.options.reserve(optionCount);
-    for (uint32_t i = 0; i < optionCount; ++i) {
-        // Sanity check: ensure minimum bytes available for option
-        // (id(4)+icon(1)+isCoded(1)+boxMoney(4)+text(1)+boxText(1))
-        size_t remaining = packet.getRemainingSize();
-        if (remaining < 12) {
-            LOG_WARNING("[TBC] gossip option ", i, " truncated (", remaining, " bytes left)");
-            break;
-        }
-
-        GossipOption opt;
-        opt.id = packet.readUInt32();
-        opt.icon = packet.readUInt8();
-        opt.isCoded = (packet.readUInt8() != 0);
-        opt.boxMoney = packet.readUInt32();
-        opt.text = packet.readString();
-        opt.boxText = packet.readString();
-        data.options.push_back(opt);
-    }
-
-    // Ensure we have at least 4 bytes for questCount
-    size_t remaining = packet.getRemainingSize();
-    if (remaining < 4) {
-        LOG_WARNING("[TBC] SMSG_GOSSIP_MESSAGE truncated before questCount");
-        return data.options.size() > 0;  // Return true if we got at least some options
-    }
-
-    uint32_t questCount = packet.readUInt32();
-
-    // Cap quest count to reasonable maximum
-    constexpr uint32_t kMaxGossipQuests = 256;
-    if (questCount > kMaxGossipQuests) {
-        LOG_WARNING("[TBC] SMSG_GOSSIP_MESSAGE questCount=", questCount, " exceeds max ",
-                    kMaxGossipQuests, ", capping");
-        questCount = kMaxGossipQuests;
-    }
-
-    data.quests.clear();
-    data.quests.reserve(questCount);
-    for (uint32_t i = 0; i < questCount; ++i) {
-        // Sanity check: ensure minimum bytes available for quest
-        // (id(4)+icon(4)+level(4)+title(1))
-        remaining = packet.getRemainingSize();
-        if (remaining < 13) {
-            LOG_WARNING("[TBC] gossip quest ", i, " truncated (", remaining, " bytes left)");
-            break;
-        }
-
-        GossipQuestItem quest;
-        quest.questId = packet.readUInt32();
-        quest.questIcon = packet.readUInt32();
-        quest.questLevel = static_cast<int32_t>(packet.readUInt32());
-        // TBC 2.4.3: NO questFlags(u32) and NO isRepeatable(u8) here
-        // WotLK adds these 5 bytes — reading them from TBC garbles the quest title
-        quest.questFlags = 0;
-        quest.isRepeatable = 0;
-        quest.title = normalizeWowTextTokens(packet.readString());
-        data.quests.push_back(quest);
-    }
-
-    LOG_DEBUG("[TBC] Gossip: ", optionCount, " options, ", questCount, " quests");
-    return true;
-}
-
-// ============================================================================
-// TBC 2.4.3 SMSG_MONSTER_MOVE
-// Identical to WotLK except WotLK added a uint8 unk byte immediately after the
-// packed GUID (toggles MOVEMENTFLAG2_UNK7). TBC does NOT have this byte.
-// Without this override, all NPC movement positions/durations are offset by 1
-// byte and parse as garbage.
-// ============================================================================
-bool TbcPacketParsers::parseMonsterMove(network::Packet& packet, MonsterMoveData& data) {
-    data.guid = packet.readPackedGuid();
-    if (data.guid == 0) return false;
-    // No unk byte here in TBC 2.4.3
-
-    if (!packet.hasRemaining(12)) return false;
-    data.x = packet.readFloat();
-    data.y = packet.readFloat();
-    data.z = packet.readFloat();
-
-    if (!packet.hasRemaining(4)) return false;
-    packet.readUInt32(); // splineId
-
-    if (packet.getReadPos() >= packet.getSize()) return false;
-    data.moveType = packet.readUInt8();
-
-    if (data.moveType == 1) {
-        data.destX = data.x;
-        data.destY = data.y;
-        data.destZ = data.z;
-        data.hasDest = false;
-        return true;
-    }
-
-    if (data.moveType == 2) {
-        if (!packet.hasRemaining(12)) return false;
-        packet.readFloat(); packet.readFloat(); packet.readFloat();
-    } else if (data.moveType == 3) {
-        if (!packet.hasRemaining(8)) return false;
-        data.facingTarget = packet.readUInt64();
-    } else if (data.moveType == 4) {
-        if (!packet.hasRemaining(4)) return false;
-        data.facingAngle = packet.readFloat();
-    }
-
-    if (!packet.hasRemaining(4)) return false;
-    data.splineFlags = packet.readUInt32();
-
-    // TBC 2.4.3 SplineFlags animation bit is same as WotLK: 0x00400000
-    if (data.splineFlags & 0x00400000) {
-        if (!packet.hasRemaining(5)) return false;
-        packet.readUInt8();  // animationType
-        packet.readUInt32(); // effectStartTime
-    }
-
-    if (!packet.hasRemaining(4)) return false;
-    data.duration = packet.readUInt32();
-
-    if (data.splineFlags & 0x00000800) {
-        if (!packet.hasRemaining(8)) return false;
-        packet.readFloat();  // verticalAcceleration
-        packet.readUInt32(); // effectStartTime
-    }
-
-    if (!packet.hasRemaining(4)) return false;
-    uint32_t pointCount = packet.readUInt32();
-    if (pointCount == 0) return true;
-    if (pointCount > 16384) return false;
-
-    // Spline points are stored uncompressed when Catmull-Rom interpolation (0x80000)
-    // or linear movement (0x2000) flags are set; otherwise they use packed delta format
-    bool uncompressed = (data.splineFlags & (0x00080000 | 0x00002000)) != 0;
-    if (uncompressed) {
-        for (uint32_t i = 0; i < pointCount - 1; i++) {
-            if (!packet.hasRemaining(12)) return true;
-            packet.readFloat(); packet.readFloat(); packet.readFloat();
-        }
-        if (!packet.hasRemaining(12)) return true;
-        data.destX = packet.readFloat();
-        data.destY = packet.readFloat();
-        data.destZ = packet.readFloat();
-        data.hasDest = true;
-    } else {
-        if (!packet.hasRemaining(12)) return true;
-        data.destX = packet.readFloat();
-        data.destY = packet.readFloat();
-        data.destZ = packet.readFloat();
-        data.hasDest = true;
-    }
-
-    LOG_DEBUG("[TBC] MonsterMove: guid=0x", std::hex, data.guid, std::dec,
-              " type=", static_cast<int>(data.moveType), " dur=", data.duration, "ms",
-              " dest=(", data.destX, ",", data.destY, ",", data.destZ, ")");
-    return true;
-}
-
-// ============================================================================
-// TBC 2.4.3 CMSG_CAST_SPELL
-// Format: castCount(u8) + spellId(u32) + SpellCastTargets
-// WotLK 3.3.5a adds castFlags(u8) between spellId and targets — TBC does NOT.
-// ============================================================================
-network::Packet TbcPacketParsers::buildCastSpell(uint32_t spellId, uint64_t targetGuid, uint8_t castCount) {
-    network::Packet packet(wireOpcode(LogicalOpcode::CMSG_CAST_SPELL));
-    packet.writeUInt8(castCount);
-    packet.writeUInt32(spellId);
-    // No castFlags byte in TBC 2.4.3
-
-    if (targetGuid != 0) {
-        packet.writeUInt32(0x02); // TARGET_FLAG_UNIT
-        // Write packed GUID
-        uint8_t mask = 0;
-        uint8_t bytes[8];
-        int byteCount = 0;
-        uint64_t g = targetGuid;
-        for (int i = 0; i < 8; ++i) {
-            uint8_t b = g & 0xFF;
-            if (b != 0) {
-                mask |= (1 << i);
-                bytes[byteCount++] = b;
-            }
-            g >>= 8;
-        }
-        packet.writeUInt8(mask);
-        for (int i = 0; i < byteCount; ++i)
-            packet.writeUInt8(bytes[i]);
-    } else {
-        packet.writeUInt32(0x00); // TARGET_FLAG_SELF
-    }
-
-    return packet;
-}
-
-// ============================================================================
-// TBC 2.4.3 CMSG_USE_ITEM
-// Format: bag(u8) + slot(u8) + castCount(u8) + spellId(u32) + itemGuid(u64) +
-//         castFlags(u8) + SpellCastTargets
-// WotLK 3.3.5a adds glyphIndex(u32) between itemGuid and castFlags — TBC does NOT.
-// ============================================================================
-network::Packet TbcPacketParsers::buildUseItem(uint8_t bagIndex, uint8_t slotIndex, uint64_t itemGuid, uint32_t spellId) {
-    network::Packet packet(wireOpcode(LogicalOpcode::CMSG_USE_ITEM));
-    packet.writeUInt8(bagIndex);
-    packet.writeUInt8(slotIndex);
-    packet.writeUInt8(0);          // cast count
-    packet.writeUInt32(spellId);   // on-use spell id
-    packet.writeUInt64(itemGuid);  // full 8-byte GUID
-    // No glyph index field in TBC 2.4.3
-    packet.writeUInt8(0);          // cast flags
-    packet.writeUInt32(0x00);      // SpellCastTargets: TARGET_FLAG_SELF
-    return packet;
-}
-
 network::Packet TbcPacketParsers::buildAcceptQuestPacket(uint64_t npcGuid, uint32_t questId) {
     network::Packet packet(wireOpcode(Opcode::CMSG_QUESTGIVER_ACCEPT_QUEST));
     packet.writeUInt64(npcGuid);
@@ -781,107 +505,13 @@ network::Packet TbcPacketParsers::buildAcceptQuestPacket(uint64_t npcGuid, uint3
     return packet;
 }
 
-// ============================================================================
-// TBC 2.4.3 SMSG_QUESTGIVER_QUEST_DETAILS
-//
-// TBC and Classic share the same format — neither has the WotLK-specific fields
-// (informUnit GUID, flags uint32, isFinished uint8) that were added in 3.x.
-//
-// Format:
-//   npcGuid(8) + questId(4) + title + details + objectives
-//   + activateAccept(1) + suggestedPlayers(4)
-//   + emoteCount(4) + [delay(4)+type(4)] × emoteCount
-//   + choiceCount(4) + [itemId(4)+count(4)+displayInfo(4)] × choiceCount
-//   + rewardCount(4) + [itemId(4)+count(4)+displayInfo(4)] × rewardCount
-//   + rewardMoney(4) + rewardXp(4)
-// ============================================================================
-bool TbcPacketParsers::parseQuestDetails(network::Packet& packet, QuestDetailsData& data) {
-    if (packet.getSize() < 16) return false;
-
-    data.npcGuid = packet.readUInt64();
-    data.questId = packet.readUInt32();
-    data.title      = normalizeWowTextTokens(packet.readString());
-    data.details    = normalizeWowTextTokens(packet.readString());
-    data.objectives = normalizeWowTextTokens(packet.readString());
-
-    if (!packet.hasRemaining(5)) {
-        LOG_DEBUG("Quest details tbc/classic (short): id=", data.questId, " title='", data.title, "'");
-        return !data.title.empty() || data.questId != 0;
-    }
-
-    /*activateAccept*/ packet.readUInt8();
-    data.suggestedPlayers = packet.readUInt32();
-
-    // TBC/Classic: emote section before reward items
-    if (packet.hasRemaining(4)) {
-        uint32_t emoteCount = packet.readUInt32();
-        for (uint32_t i = 0; i < emoteCount && packet.hasRemaining(8); ++i) {
-            packet.readUInt32(); // delay
-            packet.readUInt32(); // type
-        }
-    }
-
-    // Choice reward items (variable count, up to QUEST_REWARD_CHOICES_COUNT)
-    if (packet.hasRemaining(4)) {
-        uint32_t choiceCount = packet.readUInt32();
-        for (uint32_t i = 0; i < choiceCount && packet.hasRemaining(12); ++i) {
-            uint32_t itemId = packet.readUInt32();
-            uint32_t count  = packet.readUInt32();
-            uint32_t dispId = packet.readUInt32();
-            if (itemId != 0) {
-                QuestRewardItem ri;
-                ri.itemId = itemId; ri.count = count; ri.displayInfoId = dispId;
-                ri.choiceSlot = i;
-                data.rewardChoiceItems.push_back(ri);
-            }
-        }
-    }
-
-    // Fixed reward items (variable count, up to QUEST_REWARDS_COUNT)
-    if (packet.hasRemaining(4)) {
-        uint32_t rewardCount = packet.readUInt32();
-        for (uint32_t i = 0; i < rewardCount && packet.hasRemaining(12); ++i) {
-            uint32_t itemId = packet.readUInt32();
-            uint32_t count  = packet.readUInt32();
-            uint32_t dispId = packet.readUInt32();
-            if (itemId != 0) {
-                QuestRewardItem ri;
-                ri.itemId = itemId; ri.count = count; ri.displayInfoId = dispId;
-                data.rewardItems.push_back(ri);
-            }
-        }
-    }
-
-    if (packet.hasRemaining(4))
-        data.rewardMoney = packet.readUInt32();
-    if (packet.hasRemaining(4))
-        data.rewardXp = packet.readUInt32();
-
-    LOG_DEBUG("Quest details tbc/classic: id=", data.questId, " title='", data.title, "'");
-    return true;
-}
-
-// ============================================================================
-// TBC 2.4.3 CMSG_QUESTGIVER_QUERY_QUEST
-//
-// WotLK adds a trailing uint8 isDialogContinued byte; TBC does not.
-// TBC format: guid(8) + questId(4) = 12 bytes.
-// ============================================================================
-network::Packet TbcPacketParsers::buildQueryQuestPacket(uint64_t npcGuid, uint32_t questId) {
-    network::Packet packet(wireOpcode(Opcode::CMSG_QUESTGIVER_QUERY_QUEST));
-    packet.writeUInt64(npcGuid);
-    packet.writeUInt32(questId);
-    // No isDialogContinued byte (WotLK-only addition)
-    return packet;
-}
-
 // ============================================================================
 // TBC parseAuraUpdate - SMSG_AURA_UPDATE doesn't exist in TBC
 // TBC uses inline aura update fields + SMSG_INIT_EXTRA_AURA_INFO_OBSOLETE (0x3A3) /
 // SMSG_SET_EXTRA_AURA_INFO_OBSOLETE (0x3A4) instead
 // ============================================================================
 bool TbcPacketParsers::parseAuraUpdate(network::Packet& /*packet*/, AuraUpdateData& /*data*/, bool /*isAll*/) {
-    LOG_DEBUG("[TBC] parseAuraUpdate called but SMSG_AURA_UPDATE does not exist in TBC 2.4.3");
+    LOG_WARNING("[TBC] parseAuraUpdate called but SMSG_AURA_UPDATE does not exist in TBC 2.4.3");
     return false;
 }
 
@@ -915,7 +545,7 @@ bool TbcPacketParsers::parseNameQueryResponse(network::Packet& packet, NameQuery
         data.guid = packet.readUInt64();
         data.found = 0;
         data.name = packet.readString();
-        if (!data.name.empty() && packet.hasRemaining(12)) {
+        if (!data.name.empty() && (packet.getSize() - packet.getReadPos()) >= 12) {
             uint32_t race = packet.readUInt32();
             uint32_t gender = packet.readUInt32();
             uint32_t cls = packet.readUInt32();
@@ -931,7 +561,7 @@ bool TbcPacketParsers::parseNameQueryResponse(network::Packet& packet, NameQuery
     {
         packet.setReadPos(start);
         data.guid = packet.readUInt64();
-        if (!packet.hasRemaining(1)) {
+        if (packet.getSize() - packet.getReadPos() < 1) {
             packet.setReadPos(start);
             return false;
         }
@@ -941,7 +571,7 @@ bool TbcPacketParsers::parseNameQueryResponse(network::Packet& packet, NameQuery
             data.found = found;
             if (data.found != 0) return true;
             data.name = packet.readString();
-            if (!data.name.empty() && packet.hasRemaining(12)) {
+            if (!data.name.empty() && (packet.getSize() - packet.getReadPos()) >= 12) {
                 uint32_t race = packet.readUInt32();
                 uint32_t gender = packet.readUInt32();
                 uint32_t cls = packet.readUInt32();
@@ -972,30 +602,18 @@ bool TbcPacketParsers::parseNameQueryResponse(network::Packet& packet, NameQuery
 //   - Has statsCount prefix (Classic reads 10 pairs with no prefix)
 // ============================================================================
 bool TbcPacketParsers::parseItemQueryResponse(network::Packet& packet, ItemQueryResponseData& data) {
-    // Validate minimum packet size: entry(4)
-    if (packet.getSize() < 4) {
-        LOG_ERROR("TBC SMSG_ITEM_QUERY_SINGLE_RESPONSE: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
     data.entry = packet.readUInt32();
     if (data.entry & 0x80000000) {
         data.entry &= ~0x80000000;
         return true;
     }
 
-    // Validate minimum size for fixed fields: itemClass(4) + subClass(4) + soundOverride(4) + 4 name strings + displayInfoId(4) + quality(4)
-    if (!packet.hasRemaining(12)) {
-        LOG_ERROR("TBC SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated before names (entry=", data.entry, ")");
-        return false;
-    }
-
     uint32_t itemClass = packet.readUInt32();
     uint32_t subClass  = packet.readUInt32();
     data.itemClass = itemClass;
     data.subClass  = subClass;
     packet.readUInt32(); // SoundOverrideSubclass (int32, -1 = no override)
-    data.subclassName = getItemSubclassName(itemClass, subClass);
+    data.subclassName = "";
 
     // Name strings
     data.name = packet.readString();
@@ -1006,57 +624,32 @@ bool TbcPacketParsers::parseItemQueryResponse(network::Packet& packet, ItemQuery
     data.displayInfoId = packet.readUInt32();
     data.quality       = packet.readUInt32();
 
-    // Validate minimum size for fixed fields: Flags(4) + BuyPrice(4) + SellPrice(4) + inventoryType(4)
-    if (!packet.hasRemaining(16)) {
-        LOG_ERROR("TBC SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated before inventoryType (entry=", data.entry, ")");
-        return false;
-    }
-
-    data.itemFlags = packet.readUInt32(); // Flags  (TBC: 1 flags field only — no Flags2)
+    packet.readUInt32(); // Flags  (TBC: 1 flags field only — no Flags2)
     // TBC: NO Flags2, NO BuyCount
     packet.readUInt32(); // BuyPrice
     data.sellPrice = packet.readUInt32();
 
     data.inventoryType = packet.readUInt32();
 
-    // Validate minimum size for remaining fixed fields: 13×4 = 52 bytes
-    if (!packet.hasRemaining(52)) {
-        LOG_ERROR("TBC SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated before statsCount (entry=", data.entry, ")");
-        return false;
-    }
-
-    data.allowableClass = packet.readUInt32(); // AllowableClass
-    data.allowableRace  = packet.readUInt32(); // AllowableRace
-    data.itemLevel = packet.readUInt32();
-    data.requiredLevel = packet.readUInt32();
-    data.requiredSkill     = packet.readUInt32(); // RequiredSkill
-    data.requiredSkillRank = packet.readUInt32(); // RequiredSkillRank
+    packet.readUInt32(); // AllowableClass
+    packet.readUInt32(); // AllowableRace
+    packet.readUInt32(); // ItemLevel
+    packet.readUInt32(); // RequiredLevel
+    packet.readUInt32(); // RequiredSkill
+    packet.readUInt32(); // RequiredSkillRank
     packet.readUInt32(); // RequiredSpell
     packet.readUInt32(); // RequiredHonorRank
     packet.readUInt32(); // RequiredCityRank
-    data.requiredReputationFaction = packet.readUInt32(); // RequiredReputationFaction
-    data.requiredReputationRank    = packet.readUInt32(); // RequiredReputationRank
-    data.maxCount = static_cast<int32_t>(packet.readUInt32()); // MaxCount (1 = Unique)
-    data.maxStack = static_cast<int32_t>(packet.readUInt32()); // Stackable
+    packet.readUInt32(); // RequiredReputationFaction
+    packet.readUInt32(); // RequiredReputationRank
+    packet.readUInt32(); // MaxCount
+    data.maxStack       = static_cast<int32_t>(packet.readUInt32()); // Stackable
     data.containerSlots = packet.readUInt32();
 
     // TBC: statsCount prefix + exactly statsCount pairs (WotLK always sends 10)
-    if (!packet.hasRemaining(4)) {
-        LOG_WARNING("TBC SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated at statsCount (entry=", data.entry, ")");
-        return true;  // Have core fields; stats are optional
-    }
     uint32_t statsCount = packet.readUInt32();
-    if (statsCount > 10) {
-        LOG_WARNING("TBC SMSG_ITEM_QUERY_SINGLE_RESPONSE: statsCount=", statsCount, " exceeds max 10 (entry=",
-                    data.entry, "), capping");
-        statsCount = 10;
-    }
+    if (statsCount > 10) statsCount = 10; // sanity cap
     for (uint32_t i = 0; i < statsCount; i++) {
-        // Each stat is 2 uint32s = 8 bytes
-        if (!packet.hasRemaining(8)) {
-            LOG_WARNING("TBC SMSG_ITEM_QUERY_SINGLE_RESPONSE: stat ", i, " truncated (entry=", data.entry, ")");
-            break;
-        }
         uint32_t statType  = packet.readUInt32();
         int32_t  statValue = static_cast<int32_t>(packet.readUInt32());
         switch (statType) {
@@ -1065,22 +658,14 @@ bool TbcPacketParsers::parseItemQueryResponse(network::Packet& packet, ItemQuery
             case 5: data.intellect = statValue; break;
             case 6: data.spirit   = statValue; break;
             case 7: data.stamina  = statValue; break;
-            default:
-                if (statValue != 0)
-                    data.extraStats.push_back({statType, statValue});
-                break;
+            default: break;
         }
     }
     // TBC: NO ScalingStatDistribution, NO ScalingStatValue (WotLK-only)
 
-    // 5 damage entries (5×12 = 60 bytes)
+    // 5 damage entries
     bool haveWeaponDamage = false;
     for (int i = 0; i < 5; i++) {
-        // Each damage entry is dmgMin(4) + dmgMax(4) + damageType(4) = 12 bytes
-        if (!packet.hasRemaining(12)) {
-            LOG_WARNING("TBC SMSG_ITEM_QUERY_SINGLE_RESPONSE: damage ", i, " truncated (entry=", data.entry, ")");
-            break;
-        }
         float    dmgMin     = packet.readFloat();
         float    dmgMax     = packet.readFloat();
         uint32_t damageType = packet.readUInt32();
@@ -1093,845 +678,23 @@ bool TbcPacketParsers::parseItemQueryResponse(network::Packet& packet, ItemQuery
         }
     }
 
-    // Validate minimum size for armor (4 bytes)
-    if (!packet.hasRemaining(4)) {
-        LOG_WARNING("TBC SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated before armor (entry=", data.entry, ")");
-        return true;  // Have core fields; armor is important but optional
-    }
     data.armor = static_cast<int32_t>(packet.readUInt32());
 
-    if (packet.hasRemaining(28)) {
-        data.holyRes   = static_cast<int32_t>(packet.readUInt32()); // HolyRes
-        data.fireRes   = static_cast<int32_t>(packet.readUInt32()); // FireRes
-        data.natureRes = static_cast<int32_t>(packet.readUInt32()); // NatureRes
-        data.frostRes  = static_cast<int32_t>(packet.readUInt32()); // FrostRes
-        data.shadowRes = static_cast<int32_t>(packet.readUInt32()); // ShadowRes
-        data.arcaneRes = static_cast<int32_t>(packet.readUInt32()); // ArcaneRes
+    if (packet.getSize() - packet.getReadPos() >= 28) {
+        packet.readUInt32(); // HolyRes
+        packet.readUInt32(); // FireRes
+        packet.readUInt32(); // NatureRes
+        packet.readUInt32(); // FrostRes
+        packet.readUInt32(); // ShadowRes
+        packet.readUInt32(); // ArcaneRes
         data.delayMs = packet.readUInt32();
     }
 
-    // AmmoType + RangedModRange
-    if (packet.hasRemaining(8)) {
-        packet.readUInt32(); // AmmoType
-        packet.readFloat();  // RangedModRange
-    }
-
-    // 5 item spells
-    for (int i = 0; i < 5; i++) {
-        if (!packet.hasRemaining(24)) break;
-        data.spells[i].spellId = packet.readUInt32();
-        data.spells[i].spellTrigger = packet.readUInt32();
-        packet.readUInt32(); // SpellCharges
-        packet.readUInt32(); // SpellCooldown
-        packet.readUInt32(); // SpellCategory
-        packet.readUInt32(); // SpellCategoryCooldown
-    }
-
-    // Bonding type
-    if (packet.hasRemaining(4))
-        data.bindType = packet.readUInt32();
-
-    // Flavor/lore text
-    if (packet.getReadPos() < packet.getSize())
-        data.description = packet.readString();
-
-    // Post-description: PageText, LanguageID, PageMaterial, StartQuest
-    if (packet.hasRemaining(16)) {
-        packet.readUInt32(); // PageText
-        packet.readUInt32(); // LanguageID
-        packet.readUInt32(); // PageMaterial
-        data.startQuestId = packet.readUInt32(); // StartQuest
-    }
-
     data.valid = !data.name.empty();
     LOG_DEBUG("[TBC] Item query: ", data.name, " quality=", data.quality,
               " invType=", data.inventoryType, " armor=", data.armor);
     return true;
 }
 
-// ============================================================================
-// TbcPacketParsers::parseMailList — TBC 2.4.3 SMSG_MAIL_LIST_RESULT
-//
-// Differences from WotLK 3.3.5a (base implementation):
-//   - Header: uint8 count only (WotLK: uint32 totalCount + uint8 shownCount)
-//   - No body field — subject IS the full text (WotLK added body when mailTemplateId==0)
-//   - Attachment item GUID: full uint64 (WotLK: uint32 low GUID)
-//   - Attachment enchants: 7 × uint32 id only (WotLK: 7 × {id+duration+charges} = 84 bytes)
-//   - Header fields: cod + itemTextId + stationery (WotLK has extra unknown uint32 between
-//     itemTextId and stationery)
-// ============================================================================
-bool TbcPacketParsers::parseMailList(network::Packet& packet, std::vector<MailMessage>& inbox) {
-    size_t remaining = packet.getRemainingSize();
-    if (remaining < 1) return false;
-
-    uint8_t count = packet.readUInt8();
-    LOG_INFO("SMSG_MAIL_LIST_RESULT (TBC): count=", static_cast<int>(count));
-
-    inbox.clear();
-    inbox.reserve(count);
-
-    for (uint8_t i = 0; i < count; ++i) {
-        remaining = packet.getRemainingSize();
-        if (remaining < 2) break;
-
-        uint16_t msgSize = packet.readUInt16();
-        size_t startPos = packet.getReadPos();
-
-        MailMessage msg;
-        if (remaining < static_cast<size_t>(msgSize) + 2) {
-            LOG_WARNING("[TBC] Mail entry ", i, " truncated");
-            break;
-        }
-
-        msg.messageId = packet.readUInt32();
-        msg.messageType = packet.readUInt8();
-
-        switch (msg.messageType) {
-            case 0: msg.senderGuid = packet.readUInt64(); break;
-            default: msg.senderEntry = packet.readUInt32(); break;
-        }
-
-        msg.cod          = packet.readUInt32();
-        packet.readUInt32();         // itemTextId
-        // NOTE: TBC has NO extra unknown uint32 here (WotLK added one between itemTextId and stationery)
-        msg.stationeryId = packet.readUInt32();
-        msg.money        = packet.readUInt32();
-        msg.flags        = packet.readUInt32();
-        msg.expirationTime = packet.readFloat();
-        msg.mailTemplateId = packet.readUInt32();
-        msg.subject      = packet.readString();
-        // TBC has no separate body field at all
-
-        uint8_t attachCount = packet.readUInt8();
-        msg.attachments.reserve(attachCount);
-        for (uint8_t j = 0; j < attachCount; ++j) {
-            MailAttachment att;
-            att.slot         = packet.readUInt8();
-            uint64_t itemGuid = packet.readUInt64();   // full 64-bit GUID (TBC)
-            att.itemGuidLow  = static_cast<uint32_t>(itemGuid & 0xFFFFFFFF);
-            att.itemId       = packet.readUInt32();
-            // TBC: 7 × uint32 enchant ID only (no duration/charges per slot)
-            for (int e = 0; e < 7; ++e) {
-                uint32_t enchId = packet.readUInt32();
-                if (e == 0) att.enchantId = enchId;
-            }
-            att.randomPropertyId     = packet.readUInt32();
-            att.randomSuffix         = packet.readUInt32();
-            att.stackCount           = packet.readUInt32();
-            att.chargesOrDurability  = packet.readUInt32();
-            att.maxDurability        = packet.readUInt32();
-            packet.readUInt32();  // current durability (separate from chargesOrDurability)
-            msg.attachments.push_back(att);
-        }
-
-        msg.read = (msg.flags & 0x01) != 0;
-        inbox.push_back(std::move(msg));
-
-        // Skip any unread bytes within this mail entry
-        size_t consumed = packet.getReadPos() - startPos;
-        if (consumed < static_cast<size_t>(msgSize)) {
-            packet.setReadPos(startPos + msgSize);
-        }
-    }
-
-    return true;
-}
-
-// ============================================================================
-// ---------------------------------------------------------------------------
-// skipTbcSpellCastTargets — consume all SpellCastTargets payload bytes for TBC.
-//
-// TBC uses uint32 targetFlags (Classic: uint16). Unit/item/object/corpse targets
-// are PackedGuid (same as Classic). Source/dest location is 3 floats (12 bytes)
-// with no transport guid (Classic: same; WotLK adds a transport PackedGuid).
-//
-// This helper is used by parseSpellStart to ensure the read position advances
-// past ALL target payload fields so subsequent fields (e.g. those parsed by the
-// caller after spell targets) are not corrupted.
-// ---------------------------------------------------------------------------
-static bool skipTbcSpellCastTargets(network::Packet& packet, uint64_t* primaryTargetGuid = nullptr) {
-    if (!packet.hasRemaining(4)) return false;
-
-    const uint32_t targetFlags = packet.readUInt32();
-
-    // Returns false if the packed guid can't be read, otherwise reads and optionally captures it.
-    auto readPackedGuidCond = [&](uint32_t flag, bool capture) -> bool {
-        if (!(targetFlags & flag)) return true;
-        // Packed GUID: 1-byte mask + up to 8 data bytes
-        if (packet.getReadPos() >= packet.getSize()) return false;
-        uint8_t mask = packet.getData()[packet.getReadPos()];
-        size_t needed = 1;
-        for (int b = 0; b < 8; ++b) if (mask & (1u << b)) ++needed;
-        if (!packet.hasRemaining(needed)) return false;
-        uint64_t g = packet.readPackedGuid();
-        if (capture && primaryTargetGuid && *primaryTargetGuid == 0) *primaryTargetGuid = g;
-        return true;
-    };
-    auto skipFloats3 = [&](uint32_t flag) -> bool {
-        if (!(targetFlags & flag)) return true;
-        if (!packet.hasRemaining(12)) return false;
-        (void)packet.readFloat(); (void)packet.readFloat(); (void)packet.readFloat();
-        return true;
-    };
-
-    // Process in wire order matching cmangos-tbc SpellCastTargets::write()
-    if (!readPackedGuidCond(0x0002, true))  return false;  // UNIT
-    if (!readPackedGuidCond(0x0004, false)) return false;  // UNIT_MINIPET
-    if (!readPackedGuidCond(0x0010, false)) return false;  // ITEM
-    if (!skipFloats3(0x0020))               return false;  // SOURCE_LOCATION
-    if (!skipFloats3(0x0040))               return false;  // DEST_LOCATION
-
-    if (targetFlags & 0x1000) {  // TRADE_ITEM: uint8
-        if (packet.getReadPos() >= packet.getSize()) return false;
-        (void)packet.readUInt8();
-    }
-    if (targetFlags & 0x2000) {  // STRING: null-terminated
-        const auto& raw = packet.getData();
-        size_t pos = packet.getReadPos();
-        while (pos < raw.size() && raw[pos] != 0) ++pos;
-        if (pos >= raw.size()) return false;
-        packet.setReadPos(pos + 1);
-    }
-    if (!readPackedGuidCond(0x8200, false)) return false;  // CORPSE / PVP_CORPSE
-    if (!readPackedGuidCond(0x0800, true))  return false;  // OBJECT
-
-    return true;
-}
-
-// TbcPacketParsers::parseSpellStart — TBC 2.4.3 SMSG_SPELL_START
-//
-// TBC uses full uint64 GUIDs for casterGuid and casterUnit.
-// WotLK uses packed (variable-length) GUIDs.
-// TBC also lacks the castCount byte — format:
-//   casterGuid(u64) + casterUnit(u64) + castCount(u8) + spellId(u32) + castFlags(u32) + castTime(u32)
-// Wait: TBC DOES have castCount. But WotLK removed spellId in some paths.
-// Correct TBC format (cmangos-tbc): objectGuid(u64) + casterGuid(u64) + castCount(u8) + spellId(u32) + castFlags(u32) + castTime(u32)
-// ============================================================================
-bool TbcPacketParsers::parseSpellStart(network::Packet& packet, SpellStartData& data) {
-    data = SpellStartData{};
-    if (!packet.hasRemaining(22)) return false;
-
-    data.casterGuid = packet.readUInt64();   // full GUID (object)
-    data.casterUnit = packet.readUInt64();   // full GUID (caster unit)
-    data.castCount  = packet.readUInt8();
-    data.spellId    = packet.readUInt32();
-    data.castFlags  = packet.readUInt32();
-    data.castTime   = packet.readUInt32();
-
-    // SpellCastTargets: consume ALL target payload types to keep the read position
-    // aligned for any bytes the caller may parse after this (ammo, etc.).
-    // The previous code only read UNIT(0x02)/OBJECT(0x800) target GUIDs and left
-    // DEST_LOCATION(0x40)/SOURCE_LOCATION(0x20)/ITEM(0x10) bytes unconsumed,
-    // corrupting subsequent reads for every AOE/ground-targeted spell cast.
-    {
-        uint64_t targetGuid = 0;
-        skipTbcSpellCastTargets(packet, &targetGuid);  // non-fatal on truncation
-        data.targetGuid = targetGuid;
-    }
-
-    LOG_DEBUG("[TBC] Spell start: spell=", data.spellId, " castTime=", data.castTime, "ms",
-              " targetGuid=0x", std::hex, data.targetGuid, std::dec);
-    return true;
-}
-
-// ============================================================================
-// TbcPacketParsers::parseSpellGo — TBC 2.4.3 SMSG_SPELL_GO
-//
-// TBC uses full uint64 GUIDs, no timestamp field after castFlags.
-// WotLK uses packed GUIDs and adds a timestamp (u32) after castFlags.
-// ============================================================================
-bool TbcPacketParsers::parseSpellGo(network::Packet& packet, SpellGoData& data) {
-    // Always reset output to avoid stale targets when callers reuse buffers.
-    data = SpellGoData{};
-
-    const size_t startPos = packet.getReadPos();
-    // Fixed header before hit/miss lists:
-    // casterGuid(u64) + casterUnit(u64) + castCount(u8) + spellId(u32) + castFlags(u32)
-    if (!packet.hasRemaining(25)) return false;
-
-    data.casterGuid = packet.readUInt64();   // full GUID in TBC
-    data.casterUnit = packet.readUInt64();   // full GUID in TBC
-    data.castCount  = packet.readUInt8();
-    data.spellId    = packet.readUInt32();
-    data.castFlags  = packet.readUInt32();
-    // NOTE: NO timestamp field here in TBC (WotLK added packet.readUInt32())
-
-    if (packet.getReadPos() >= packet.getSize()) {
-        LOG_WARNING("[TBC] Spell go: missing hitCount after fixed fields");
-        packet.setReadPos(startPos);
-        return false;
-    }
-
-    // Cap hit targets to prevent oversized allocations from malformed spell packets.
-    // 128 is well above any real WoW AOE spell target count (max ~20 in practice).
-    const uint8_t rawHitCount = packet.readUInt8();
-    if (rawHitCount > 128) {
-        LOG_WARNING("[TBC] Spell go: hitCount capped (requested=", static_cast<int>(rawHitCount), ")");
-    }
-    const uint8_t storedHitLimit = std::min<uint8_t>(rawHitCount, 128);
-    data.hitTargets.reserve(storedHitLimit);
-    bool truncatedTargets = false;
-    for (uint16_t i = 0; i < rawHitCount; ++i) {
-        if (!packet.hasRemaining(8)) {
-            LOG_WARNING("[TBC] Spell go: truncated hit targets at index ", i,
-                        "/", static_cast<int>(rawHitCount));
-            truncatedTargets = true;
-            break;
-        }
-        const uint64_t targetGuid = packet.readUInt64();  // full GUID in TBC
-        if (i < storedHitLimit) {
-            data.hitTargets.push_back(targetGuid);
-        }
-    }
-    if (truncatedTargets) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.hitCount = static_cast<uint8_t>(data.hitTargets.size());
-
-    if (packet.getReadPos() >= packet.getSize()) {
-        LOG_WARNING("[TBC] Spell go: missing missCount after hit target list");
-        packet.setReadPos(startPos);
-        return false;
-    }
-
-    const uint8_t rawMissCount = packet.readUInt8();
-    if (rawMissCount > 128) {
-        LOG_WARNING("[TBC] Spell go: missCount capped (requested=", static_cast<int>(rawMissCount), ")");
-    }
-    const uint8_t storedMissLimit = std::min<uint8_t>(rawMissCount, 128);
-    data.missTargets.reserve(storedMissLimit);
-    for (uint16_t i = 0; i < rawMissCount; ++i) {
-        if (!packet.hasRemaining(9)) {
-            LOG_WARNING("[TBC] Spell go: truncated miss targets at index ", i,
-                        "/", static_cast<int>(rawMissCount));
-            truncatedTargets = true;
-            break;
-        }
-        SpellGoMissEntry m;
-        m.targetGuid = packet.readUInt64();  // full GUID in TBC
-        m.missType   = packet.readUInt8();
-        if (m.missType == 11) { // SPELL_MISS_REFLECT
-            if (!packet.hasRemaining(1)) {
-                LOG_WARNING("[TBC] Spell go: truncated reflect payload at miss index ", i,
-                            "/", static_cast<int>(rawMissCount));
-                truncatedTargets = true;
-                break;
-            }
-            (void)packet.readUInt8(); // reflectResult
-        }
-        if (i < storedMissLimit) {
-            data.missTargets.push_back(m);
-        }
-    }
-    if (truncatedTargets) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.missCount = static_cast<uint8_t>(data.missTargets.size());
-
-    // SpellCastTargets follows the miss list — consume all target bytes so that
-    // any subsequent fields are not misaligned for ground-targeted AoE spells.
-    skipTbcSpellCastTargets(packet, &data.targetGuid);
-
-    LOG_DEBUG("[TBC] Spell go: spell=", data.spellId, " hits=", static_cast<int>(data.hitCount),
-              " misses=", static_cast<int>(data.missCount));
-    return true;
-}
-
-// ============================================================================
-// TbcPacketParsers::parseCastResult — TBC 2.4.3 SMSG_CAST_RESULT
-//
-// TBC format: spellId(u32) + result(u8) = 5 bytes
-// WotLK adds a castCount(u8) prefix making it 6 bytes.
-// Without this override, WotLK parser reads spellId[0] as castCount,
-// then the remaining 4 bytes as spellId (off by one), producing wrong result.
-// ============================================================================
-bool TbcPacketParsers::parseCastResult(network::Packet& packet, uint32_t& spellId, uint8_t& result) {
-    if (!packet.hasRemaining(5)) return false;
-    spellId = packet.readUInt32();   // No castCount prefix in TBC
-    result  = packet.readUInt8();
-    return true;
-}
-
-// ============================================================================
-// TbcPacketParsers::parseCastFailed — TBC 2.4.3 SMSG_CAST_FAILED
-//
-// TBC format: spellId(u32) + result(u8)
-// WotLK added castCount(u8) before spellId; reading it on TBC would shift
-// the spellId by one byte and corrupt all subsequent fields.
-// Classic has the same layout, but the result enum starts differently (offset +1);
-// TBC uses the same result values as WotLK so no offset is needed.
-// ============================================================================
-bool TbcPacketParsers::parseCastFailed(network::Packet& packet, CastFailedData& data) {
-    if (!packet.hasRemaining(5)) return false;
-    data.castCount = 0;                      // not present in TBC
-    data.spellId   = packet.readUInt32();
-    data.result    = packet.readUInt8();     // same enum as WotLK
-    LOG_DEBUG("[TBC] Cast failed: spell=", data.spellId, " result=", static_cast<int>(data.result));
-    return true;
-}
-
-// ============================================================================
-// TbcPacketParsers::parseAttackerStateUpdate — TBC 2.4.3 SMSG_ATTACKERSTATEUPDATE
-//
-// TBC uses full uint64 GUIDs for attacker and target.
-// WotLK uses packed (variable-length) GUIDs — using the WotLK reader here
-// would mis-parse TBC's GUIDs and corrupt all subsequent damage fields.
-// ============================================================================
-bool TbcPacketParsers::parseAttackerStateUpdate(network::Packet& packet, AttackerStateUpdateData& data) {
-    data = AttackerStateUpdateData{};
-
-    const size_t startPos = packet.getReadPos();
-    auto rem = [&]() { return packet.getRemainingSize(); };
-
-    // Fixed fields before sub-damage list:
-    // hitInfo(4) + attackerGuid(8) + targetGuid(8) + totalDamage(4) + subDamageCount(1) = 25 bytes
-    if (rem() < 25) return false;
-
-    data.hitInfo        = packet.readUInt32();
-    data.attackerGuid   = packet.readUInt64();   // full GUID in TBC
-    data.targetGuid     = packet.readUInt64();   // full GUID in TBC
-    data.totalDamage    = static_cast<int32_t>(packet.readUInt32());
-    data.subDamageCount = packet.readUInt8();
-
-    // Clamp to what can fit in the remaining payload (20 bytes per sub-damage entry).
-    const uint8_t maxSubDamageCount = static_cast<uint8_t>(std::min<size_t>(rem() / 20, 64));
-    if (data.subDamageCount > maxSubDamageCount) {
-        data.subDamageCount = maxSubDamageCount;
-    }
-
-    data.subDamages.reserve(data.subDamageCount);
-    for (uint8_t i = 0; i < data.subDamageCount; ++i) {
-        if (rem() < 20) {
-            packet.setReadPos(startPos);
-            return false;
-        }
-        SubDamage sub;
-        sub.schoolMask = packet.readUInt32();
-        sub.damage     = packet.readFloat();
-        sub.intDamage  = packet.readUInt32();
-        sub.absorbed   = packet.readUInt32();
-        sub.resisted   = packet.readUInt32();
-        data.subDamages.push_back(sub);
-    }
-
-    data.subDamageCount = static_cast<uint8_t>(data.subDamages.size());
-
-    // victimState + overkill are part of the expected payload.
-    if (rem() < 8) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.victimState = packet.readUInt32();
-    data.overkill    = static_cast<int32_t>(packet.readUInt32());
-
-    if (rem() >= 4) {
-        data.blocked = packet.readUInt32();
-    }
-
-    LOG_DEBUG("[TBC] Melee hit: ", data.totalDamage, " damage",
-              data.isCrit() ? " (CRIT)" : "",
-              data.isMiss() ? " (MISS)" : "");
-    return true;
-}
-
-// ============================================================================
-// TbcPacketParsers::parseSpellDamageLog — TBC 2.4.3 SMSG_SPELLNONMELEEDAMAGELOG
-//
-// TBC uses full uint64 GUIDs; WotLK uses packed GUIDs.
-// ============================================================================
-bool TbcPacketParsers::parseSpellDamageLog(network::Packet& packet, SpellDamageLogData& data) {
-    // Fixed TBC payload size:
-    // targetGuid(8) + attackerGuid(8) + spellId(4) + damage(4) + schoolMask(1)
-    // + absorbed(4) + resisted(4) + periodicLog(1) + unused(1) + blocked(4) + flags(4)
-    // = 43 bytes
-    // Some servers append additional trailing fields; consume the canonical minimum
-    // and leave any extension bytes unread.
-    if (!packet.hasRemaining(43)) return false;
-
-    data = SpellDamageLogData{};
-
-    data.targetGuid   = packet.readUInt64();  // full GUID in TBC
-    data.attackerGuid = packet.readUInt64();  // full GUID in TBC
-    data.spellId      = packet.readUInt32();
-    data.damage       = packet.readUInt32();
-    data.schoolMask   = packet.readUInt8();
-    data.absorbed     = packet.readUInt32();
-    data.resisted     = packet.readUInt32();
-
-    uint8_t periodicLog = packet.readUInt8();
-    (void)periodicLog;
-    packet.readUInt8();   // unused
-    packet.readUInt32();  // blocked
-    uint32_t flags = packet.readUInt32();
-    data.isCrit = (flags & 0x02) != 0;
-
-    // TBC does not have an overkill field here
-    data.overkill = 0;
-
-    LOG_DEBUG("[TBC] Spell damage: spellId=", data.spellId, " dmg=", data.damage,
-              data.isCrit ? " CRIT" : "");
-    return true;
-}
-
-// ============================================================================
-// TbcPacketParsers::parseSpellHealLog — TBC 2.4.3 SMSG_SPELLHEALLOG
-//
-// TBC uses full uint64 GUIDs; WotLK uses packed GUIDs.
-// ============================================================================
-bool TbcPacketParsers::parseSpellHealLog(network::Packet& packet, SpellHealLogData& data) {
-    // Fixed payload is 28 bytes; many cores append crit flag (1 byte).
-    // targetGuid(8) + casterGuid(8) + spellId(4) + heal(4) + overheal(4)
-    if (!packet.hasRemaining(28)) return false;
-
-    data = SpellHealLogData{};
-
-    data.targetGuid = packet.readUInt64();  // full GUID in TBC
-    data.casterGuid = packet.readUInt64();  // full GUID in TBC
-    data.spellId    = packet.readUInt32();
-    data.heal       = packet.readUInt32();
-    data.overheal   = packet.readUInt32();
-    // TBC has no absorbed field in SMSG_SPELLHEALLOG; skip crit flag
-    if (packet.getReadPos() < packet.getSize()) {
-        uint8_t critFlag = packet.readUInt8();
-        data.isCrit = (critFlag != 0);
-    }
-
-    LOG_DEBUG("[TBC] Spell heal: spellId=", data.spellId, " heal=", data.heal,
-              data.isCrit ? " CRIT" : "");
-    return true;
-}
-
-// ============================================================================
-// TBC 2.4.3 SMSG_MESSAGECHAT
-// TBC format: type(u8) + language(u32) + [type-specific data] + msgLen(u32) + msg + tag(u8)
-// WotLK adds senderGuid(u64) + unknown(u32) before type-specific data.
-// ============================================================================
-
-bool TbcPacketParsers::parseMessageChat(network::Packet& packet, MessageChatData& data) {
-    if (packet.getSize() < 10) {
-        LOG_ERROR("[TBC] SMSG_MESSAGECHAT packet too small: ", packet.getSize(), " bytes");
-        return false;
-    }
-
-    uint8_t typeVal = packet.readUInt8();
-    data.type = static_cast<ChatType>(typeVal);
-
-    uint32_t langVal = packet.readUInt32();
-    data.language = static_cast<ChatLanguage>(langVal);
-
-    // TBC: NO senderGuid or unknown field here (WotLK has senderGuid(u64) + unk(u32))
-
-    switch (data.type) {
-        case ChatType::MONSTER_SAY:
-        case ChatType::MONSTER_YELL:
-        case ChatType::MONSTER_EMOTE:
-        case ChatType::MONSTER_WHISPER:
-        case ChatType::MONSTER_PARTY:
-        case ChatType::RAID_BOSS_EMOTE: {
-            // senderGuid(u64) + nameLen(u32) + name + targetGuid(u64)
-            data.senderGuid = packet.readUInt64();
-            uint32_t nameLen = packet.readUInt32();
-            if (nameLen > 0 && nameLen < 256) {
-                data.senderName.resize(nameLen);
-                for (uint32_t i = 0; i < nameLen; ++i) {
-                    data.senderName[i] = static_cast<char>(packet.readUInt8());
-                }
-                if (!data.senderName.empty() && data.senderName.back() == '\0') {
-                    data.senderName.pop_back();
-                }
-            }
-            data.receiverGuid = packet.readUInt64();
-            break;
-        }
-
-        case ChatType::SAY:
-        case ChatType::PARTY:
-        case ChatType::YELL:
-        case ChatType::WHISPER:
-        case ChatType::WHISPER_INFORM:
-        case ChatType::GUILD:
-        case ChatType::OFFICER:
-        case ChatType::RAID:
-        case ChatType::RAID_LEADER:
-        case ChatType::RAID_WARNING:
-        case ChatType::EMOTE:
-        case ChatType::TEXT_EMOTE: {
-            // senderGuid(u64) + senderGuid(u64) — written twice by server
-            data.senderGuid = packet.readUInt64();
-            /*duplicateGuid*/ packet.readUInt64();
-            break;
-        }
-
-        case ChatType::CHANNEL: {
-            // channelName(string) + rank(u32) + senderGuid(u64)
-            data.channelName = packet.readString();
-            /*uint32_t rank =*/ packet.readUInt32();
-            data.senderGuid = packet.readUInt64();
-            break;
-        }
-
-        default: {
-            // All other types: senderGuid(u64) + senderGuid(u64) — written twice
-            data.senderGuid = packet.readUInt64();
-            /*duplicateGuid*/ packet.readUInt64();
-            break;
-        }
-    }
-
-    // Read message length + message
-    uint32_t messageLen = packet.readUInt32();
-    if (messageLen > 0 && messageLen < 8192) {
-        data.message.resize(messageLen);
-        for (uint32_t i = 0; i < messageLen; ++i) {
-            data.message[i] = static_cast<char>(packet.readUInt8());
-        }
-        if (!data.message.empty() && data.message.back() == '\0') {
-            data.message.pop_back();
-        }
-    }
-
-    // Read chat tag
-    if (packet.getReadPos() < packet.getSize()) {
-        data.chatTag = packet.readUInt8();
-    }
-
-    LOG_DEBUG("[TBC] SMSG_MESSAGECHAT: type=", getChatTypeString(data.type),
-             " sender=", data.senderName.empty() ? std::to_string(data.senderGuid) : data.senderName);
-
-    return true;
-}
-
-// ============================================================================
-// TBC 2.4.3 quest giver status
-// TBC sends uint32 (like Classic), WotLK changed to uint8.
-// TBC 2.4.3 enum: 0=NONE,1=UNAVAILABLE,2=CHAT,3=INCOMPLETE,4=REWARD_REP,
-//   5=AVAILABLE_REP,6=AVAILABLE,7=REWARD2,8=REWARD
-// ============================================================================
-
-uint8_t TbcPacketParsers::readQuestGiverStatus(network::Packet& packet) {
-    uint32_t tbcStatus = packet.readUInt32();
-    switch (tbcStatus) {
-        case 0: return 0;   // NONE
-        case 1: return 1;   // UNAVAILABLE
-        case 2: return 0;   // CHAT → NONE (no marker)
-        case 3: return 5;   // INCOMPLETE → WotLK INCOMPLETE
-        case 4: return 6;   // REWARD_REP → WotLK REWARD_REP
-        case 5: return 7;   // AVAILABLE_REP → WotLK AVAILABLE_LOW_LEVEL
-        case 6: return 8;   // AVAILABLE → WotLK AVAILABLE
-        case 7: return 10;  // REWARD2 → WotLK REWARD
-        case 8: return 10;  // REWARD → WotLK REWARD
-        default: return 0;
-    }
-}
-
-// ============================================================================
-// TBC 2.4.3 channel join/leave
-// Classic/TBC: just name+password (no channelId/hasVoice/joinedByZone prefix)
-// ============================================================================
-
-network::Packet TbcPacketParsers::buildJoinChannel(const std::string& channelName, const std::string& password) {
-    network::Packet packet(wireOpcode(Opcode::CMSG_JOIN_CHANNEL));
-    packet.writeString(channelName);
-    packet.writeString(password);
-    LOG_DEBUG("[TBC] Built CMSG_JOIN_CHANNEL: channel=", channelName);
-    return packet;
-}
-
-network::Packet TbcPacketParsers::buildLeaveChannel(const std::string& channelName) {
-    network::Packet packet(wireOpcode(Opcode::CMSG_LEAVE_CHANNEL));
-    packet.writeString(channelName);
-    LOG_DEBUG("[TBC] Built CMSG_LEAVE_CHANNEL: channel=", channelName);
-    return packet;
-}
-
-// ============================================================================
-// TBC 2.4.3 SMSG_GAMEOBJECT_QUERY_RESPONSE
-// TBC has 2 extra strings after name[4] (iconName + castBarCaption).
-// WotLK has 3 (adds unk1). Classic has 0.
-// ============================================================================
-
-bool TbcPacketParsers::parseGameObjectQueryResponse(network::Packet& packet, GameObjectQueryResponseData& data) {
-    if (packet.getSize() < 4) {
-        LOG_ERROR("TBC SMSG_GAMEOBJECT_QUERY_RESPONSE: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
-    data.entry = packet.readUInt32();
-
-    if (data.entry & 0x80000000) {
-        data.entry &= ~0x80000000;
-        data.name = "";
-        return true;
-    }
-
-    if (!packet.hasRemaining(8)) {
-        LOG_ERROR("TBC SMSG_GAMEOBJECT_QUERY_RESPONSE: truncated before names (entry=", data.entry, ")");
-        return false;
-    }
-
-    data.type = packet.readUInt32();
-    data.displayId = packet.readUInt32();
-    // 4 name strings
-    data.name = packet.readString();
-    packet.readString();
-    packet.readString();
-    packet.readString();
-
-    // TBC: 2 extra strings (iconName + castBarCaption) — WotLK has 3, Classic has 0
-    packet.readString();  // iconName
-    packet.readString();  // castBarCaption
-
-    // Read 24 type-specific data fields
-    size_t remaining = packet.getRemainingSize();
-    if (remaining >= 24 * 4) {
-        for (int i = 0; i < 24; i++) {
-            data.data[i] = packet.readUInt32();
-        }
-        data.hasData = true;
-    } else if (remaining > 0) {
-        uint32_t fieldsToRead = remaining / 4;
-        for (uint32_t i = 0; i < fieldsToRead && i < 24; i++) {
-            data.data[i] = packet.readUInt32();
-        }
-        if (fieldsToRead < 24) {
-            LOG_WARNING("TBC SMSG_GAMEOBJECT_QUERY_RESPONSE: truncated in data fields (", fieldsToRead,
-                        " of 24, entry=", data.entry, ")");
-        }
-    }
-
-    if (data.type == 15) { // MO_TRANSPORT
-        LOG_DEBUG("TBC GO query: MO_TRANSPORT entry=", data.entry,
-                  " name=\"", data.name, "\" displayId=", data.displayId,
-                  " taxiPathId=", data.data[0], " moveSpeed=", data.data[1]);
-    } else {
-        LOG_DEBUG("TBC GO query: ", data.name, " type=", data.type, " entry=", data.entry);
-    }
-    return true;
-}
-
-// ============================================================================
-// TBC 2.4.3 guild roster parser
-// Same rank structure as WotLK (variable rankCount + goldLimit + bank tabs),
-// but NO gender byte per member (WotLK added it).
-// ============================================================================
-
-bool TbcPacketParsers::parseGuildRoster(network::Packet& packet, GuildRosterData& data) {
-    if (packet.getSize() < 4) {
-        LOG_ERROR("TBC SMSG_GUILD_ROSTER too small: ", packet.getSize());
-        return false;
-    }
-    uint32_t numMembers = packet.readUInt32();
-
-    // Safety cap — guilds rarely exceed 500 members; 1000 prevents excessive
-    // memory allocation from malformed packets while covering all real cases
-    const uint32_t MAX_GUILD_MEMBERS = 1000;
-    if (numMembers > MAX_GUILD_MEMBERS) {
-        LOG_WARNING("TBC GuildRoster: numMembers capped (requested=", numMembers, ")");
-        numMembers = MAX_GUILD_MEMBERS;
-    }
-
-    data.motd = packet.readString();
-    data.guildInfo = packet.readString();
-
-    if (!packet.hasRemaining(4)) {
-        LOG_WARNING("TBC GuildRoster: truncated before rankCount");
-        data.ranks.clear();
-        data.members.clear();
-        return true;
-    }
-
-    uint32_t rankCount = packet.readUInt32();
-    const uint32_t MAX_GUILD_RANKS = 20;
-    if (rankCount > MAX_GUILD_RANKS) {
-        LOG_WARNING("TBC GuildRoster: rankCount capped (requested=", rankCount, ")");
-        rankCount = MAX_GUILD_RANKS;
-    }
-
-    data.ranks.resize(rankCount);
-    for (uint32_t i = 0; i < rankCount; ++i) {
-        if (!packet.hasRemaining(4)) {
-            LOG_WARNING("TBC GuildRoster: truncated rank at index ", i);
-            break;
-        }
-        data.ranks[i].rights = packet.readUInt32();
-        if (!packet.hasRemaining(4)) {
-            data.ranks[i].goldLimit = 0;
-        } else {
-            data.ranks[i].goldLimit = packet.readUInt32();
-        }
-        // 6 bank tab flags + 6 bank tab items per day (guild banks added in TBC 2.3)
-        for (int t = 0; t < 6; ++t) {
-            if (!packet.hasRemaining(8)) break;
-            packet.readUInt32(); // tabFlags
-            packet.readUInt32(); // tabItemsPerDay
-        }
-    }
-
-    data.members.resize(numMembers);
-    for (uint32_t i = 0; i < numMembers; ++i) {
-        if (!packet.hasRemaining(9)) {
-            LOG_WARNING("TBC GuildRoster: truncated member at index ", i);
-            break;
-        }
-        auto& m = data.members[i];
-        m.guid = packet.readUInt64();
-        m.online = (packet.readUInt8() != 0);
-
-        if (packet.getReadPos() >= packet.getSize()) {
-            m.name.clear();
-        } else {
-            m.name = packet.readString();
-        }
-
-        if (!packet.hasRemaining(1)) {
-            m.rankIndex = 0;
-            m.level = 1;
-            m.classId = 0;
-            m.gender = 0;
-            m.zoneId = 0;
-        } else {
-            m.rankIndex = packet.readUInt32();
-            if (!packet.hasRemaining(2)) {
-                m.level = 1;
-                m.classId = 0;
-            } else {
-                m.level = packet.readUInt8();
-                m.classId = packet.readUInt8();
-            }
-            // TBC: NO gender byte (WotLK added it)
-            m.gender = 0;
-            if (!packet.hasRemaining(4)) {
-                m.zoneId = 0;
-            } else {
-                m.zoneId = packet.readUInt32();
-            }
-        }
-
-        if (!m.online) {
-            if (!packet.hasRemaining(4)) {
-                m.lastOnline = 0.0f;
-            } else {
-                m.lastOnline = packet.readFloat();
-            }
-        }
-
-        if (packet.getReadPos() >= packet.getSize()) {
-            m.publicNote.clear();
-            m.officerNote.clear();
-        } else {
-            m.publicNote = packet.readString();
-            if (packet.getReadPos() >= packet.getSize()) {
-                m.officerNote.clear();
-            } else {
-                m.officerNote = packet.readString();
-            }
-        }
-    }
-    LOG_INFO("Parsed TBC SMSG_GUILD_ROSTER: ", numMembers, " members, motd=", data.motd);
-    return true;
-}
-
 } // namespace game
 } // namespace wowee
diff --git a/src/game/quest_handler.cpp b/src/game/quest_handler.cpp
deleted file mode 100644
index 4b32ae33..00000000
--- a/src/game/quest_handler.cpp
+++ /dev/null
@@ -1,1856 +0,0 @@
-#include "game/quest_handler.hpp"
-#include "game/game_handler.hpp"
-#include "game/game_utils.hpp"
-#include "game/entity.hpp"
-#include "game/update_field_table.hpp"
-#include "game/packet_parsers.hpp"
-#include "network/world_socket.hpp"
-#include "rendering/renderer.hpp"
-#include "audio/audio_coordinator.hpp"
-#include "audio/ui_sound_manager.hpp"
-#include "core/application.hpp"
-#include "core/logger.hpp"
-#include <algorithm>
-#include <cctype>
-#include <cmath>
-#include <cstdio>
-#include <sstream>
-
-namespace wowee {
-namespace game {
-
-QuestGiverStatus QuestHandler::getQuestGiverStatus(uint64_t guid) const {
-    auto it = npcQuestStatus_.find(guid);
-    return (it != npcQuestStatus_.end()) ? it->second : QuestGiverStatus::NONE;
-}
-
-
-static std::string formatCopperAmount(uint32_t amount) {
-    uint32_t gold = amount / 10000;
-    uint32_t silver = (amount / 100) % 100;
-    uint32_t copper = amount % 100;
-
-    std::ostringstream oss;
-    bool wrote = false;
-    if (gold > 0) {
-        oss << gold << "g";
-        wrote = true;
-    }
-    if (silver > 0) {
-        if (wrote) oss << " ";
-        oss << silver << "s";
-        wrote = true;
-    }
-    if (copper > 0 || !wrote) {
-        if (wrote) oss << " ";
-        oss << copper << "c";
-    }
-    return oss.str();
-}
-
-static bool isReadableQuestText(const std::string& s, size_t minLen, size_t maxLen) {
-    if (s.size() < minLen || s.size() > maxLen) return false;
-    bool hasAlpha = false;
-    for (unsigned char c : s) {
-        // Reject control characters but allow UTF-8 multi-byte sequences (0x80+)
-        // so localized servers (French, German, Russian, etc.) work correctly.
-        if (c < 0x20 && c != '\t' && c != '\n' && c != '\r') return false;
-        if (c >= 0x20 && c <= 0x7E && std::isalpha(c)) hasAlpha = true;
-        // UTF-8 continuation/lead bytes (0x80+) are allowed but don't count as alpha
-        // since we only need at least one ASCII letter to distinguish from binary garbage.
-    }
-    return hasAlpha;
-}
-
-static bool isPlaceholderQuestTitle(const std::string& s) {
-    return s.rfind("Quest #", 0) == 0;
-}
-
-static bool looksLikeQuestDescriptionText(const std::string& s) {
-    int spaces = 0;
-    int commas = 0;
-    for (unsigned char c : s) {
-        if (c == ' ') spaces++;
-        if (c == ',') commas++;
-    }
-    const int words = spaces + 1;
-    if (words > 8) return true;
-    if (commas > 0 && words > 5) return true;
-    if (s.find(". ") != std::string::npos) return true;
-    if (s.find(':') != std::string::npos && words > 5) return true;
-    return false;
-}
-
-static bool isStrongQuestTitle(const std::string& s) {
-    if (!isReadableQuestText(s, 6, 72)) return false;
-    if (looksLikeQuestDescriptionText(s)) return false;
-    unsigned char first = static_cast<unsigned char>(s.front());
-    return std::isupper(first) != 0;
-}
-
-static int scoreQuestTitle(const std::string& s) {
-    if (!isReadableQuestText(s, 4, 72)) return -1000;
-    if (looksLikeQuestDescriptionText(s)) return -1000;
-    int score = 0;
-    score += static_cast<int>(std::min<size_t>(s.size(), 32));
-    unsigned char first = static_cast<unsigned char>(s.front());
-    if (std::isupper(first)) score += 20;
-    if (std::islower(first)) score -= 20;
-    if (s.find(' ') != std::string::npos) score += 8;
-    if (s.find('.') != std::string::npos) score -= 18;
-    if (s.find('!') != std::string::npos || s.find('?') != std::string::npos) score -= 6;
-    return score;
-}
-
-static bool readCStringAt(const std::vector<uint8_t>& data, size_t start, std::string& out, size_t& nextPos) {
-    out.clear();
-    if (start >= data.size()) return false;
-    size_t i = start;
-    while (i < data.size()) {
-        uint8_t b = data[i++];
-        if (b == 0) {
-            nextPos = i;
-            return true;
-        }
-        out.push_back(static_cast<char>(b));
-    }
-    return false;
-}
-
-struct QuestQueryTextCandidate {
-    std::string title;
-    std::string objectives;
-    int score = -1000;
-};
-
-static QuestQueryTextCandidate pickBestQuestQueryTexts(const std::vector<uint8_t>& data, bool classicHint) {
-    QuestQueryTextCandidate best;
-    if (data.size() <= 9) return best;
-
-    std::vector<size_t> seedOffsets;
-    const size_t base = 8;
-    const size_t classicOffset = base + 40u * 4u;
-    const size_t wotlkOffset = base + 55u * 4u;
-    if (classicHint) {
-        seedOffsets.push_back(classicOffset);
-        seedOffsets.push_back(wotlkOffset);
-    } else {
-        seedOffsets.push_back(wotlkOffset);
-        seedOffsets.push_back(classicOffset);
-    }
-    for (size_t off : seedOffsets) {
-        if (off < data.size()) {
-            std::string title;
-            size_t next = off;
-            if (readCStringAt(data, off, title, next)) {
-                QuestQueryTextCandidate c;
-                c.title = title;
-                c.score = scoreQuestTitle(title) + 20; // Prefer expected struct offsets
-
-                std::string s2;
-                size_t n2 = next;
-                if (readCStringAt(data, next, s2, n2) && isReadableQuestText(s2, 8, 600)) {
-                    c.objectives = s2;
-                }
-                if (c.score > best.score) best = c;
-            }
-        }
-    }
-
-    // Fallback: scan packet for best printable C-string title candidate.
-    for (size_t start = 8; start < data.size(); ++start) {
-        std::string title;
-        size_t next = start;
-        if (!readCStringAt(data, start, title, next)) continue;
-
-        QuestQueryTextCandidate c;
-        c.title = title;
-        c.score = scoreQuestTitle(title);
-        if (c.score < 0) continue;
-
-        std::string s2, s3;
-        size_t n2 = next, n3 = next;
-        if (readCStringAt(data, next, s2, n2)) {
-            if (isReadableQuestText(s2, 8, 600)) c.objectives = s2;
-            else if (readCStringAt(data, n2, s3, n3) && isReadableQuestText(s3, 8, 600)) c.objectives = s3;
-        }
-        if (c.score > best.score) best = c;
-    }
-
-    return best;
-}
-
-struct QuestQueryObjectives {
-    struct Kill { int32_t npcOrGoId; uint32_t required; };
-    struct Item { uint32_t itemId; uint32_t required; };
-    std::array<Kill, 4> kills{};
-    std::array<Item, 6> items{};
-    bool valid = false;
-};
-
-static uint32_t readU32At(const std::vector<uint8_t>& d, size_t pos) {
-    return static_cast<uint32_t>(d[pos])
-         | (static_cast<uint32_t>(d[pos + 1]) << 8)
-         | (static_cast<uint32_t>(d[pos + 2]) << 16)
-         | (static_cast<uint32_t>(d[pos + 3]) << 24);
-}
-
-static QuestQueryObjectives tryParseQuestObjectivesAt(const std::vector<uint8_t>& data,
-                                                       size_t startPos, int nStrings) {
-    QuestQueryObjectives out;
-    size_t pos = startPos;
-
-    for (int si = 0; si < nStrings; ++si) {
-        while (pos < data.size() && data[pos] != 0) ++pos;
-        if (pos >= data.size()) return out;
-        ++pos;
-    }
-
-    for (int i = 0; i < 4; ++i) {
-        if (pos + 8 > data.size()) return out;
-        out.kills[i].npcOrGoId = static_cast<int32_t>(readU32At(data, pos));  pos += 4;
-        out.kills[i].required  = readU32At(data, pos);                         pos += 4;
-    }
-
-    for (int i = 0; i < 6; ++i) {
-        if (pos + 8 > data.size()) break;
-        out.items[i].itemId   = readU32At(data, pos);  pos += 4;
-        out.items[i].required = readU32At(data, pos);  pos += 4;
-    }
-
-    out.valid = true;
-    return out;
-}
-
-static QuestQueryObjectives extractQuestQueryObjectives(const std::vector<uint8_t>& data, bool classicHint) {
-    if (data.size() < 16) return {};
-
-    const size_t base = 8;
-    const size_t classicStart = base + 40u * 4u;
-    const size_t wotlkStart   = base + 55u * 4u;
-
-    if (classicHint) {
-        auto r = tryParseQuestObjectivesAt(data, classicStart, 4);
-        if (r.valid) return r;
-        return tryParseQuestObjectivesAt(data, wotlkStart, 5);
-    } else {
-        auto r = tryParseQuestObjectivesAt(data, wotlkStart, 5);
-        if (r.valid) return r;
-        return tryParseQuestObjectivesAt(data, classicStart, 4);
-    }
-}
-
-struct QuestQueryRewards {
-    int32_t  rewardMoney = 0;
-    std::array<uint32_t, 4> itemId{};
-    std::array<uint32_t, 4> itemCount{};
-    std::array<uint32_t, 6> choiceItemId{};
-    std::array<uint32_t, 6> choiceItemCount{};
-    bool valid = false;
-};
-
-static QuestQueryRewards tryParseQuestRewards(const std::vector<uint8_t>& data,
-                                               bool classicLayout) {
-    const size_t base = 8;
-    const size_t fieldCount = classicLayout ? 40u : 55u;
-    const size_t headerEnd = base + fieldCount * 4u;
-    if (data.size() < headerEnd) return {};
-
-    const size_t moneyField     = classicLayout ? 14u : 17u;
-    const size_t itemIdField    = classicLayout ? 20u : 30u;
-    const size_t itemCountField = classicLayout ? 24u : 34u;
-    const size_t choiceIdField  = classicLayout ? 28u : 38u;
-    const size_t choiceCntField = classicLayout ? 34u : 44u;
-
-    QuestQueryRewards out;
-    out.rewardMoney = static_cast<int32_t>(readU32At(data, base + moneyField * 4u));
-    for (size_t i = 0; i < 4; ++i) {
-        out.itemId[i]    = readU32At(data, base + (itemIdField    + i) * 4u);
-        out.itemCount[i] = readU32At(data, base + (itemCountField + i) * 4u);
-    }
-    for (size_t i = 0; i < 6; ++i) {
-        out.choiceItemId[i]    = readU32At(data, base + (choiceIdField  + i) * 4u);
-        out.choiceItemCount[i] = readU32At(data, base + (choiceCntField + i) * 4u);
-    }
-    out.valid = true;
-    return out;
-}
-
-// ---------------------------------------------------------------------------
-// Constructor
-// ---------------------------------------------------------------------------
-
-QuestHandler::QuestHandler(GameHandler& owner)
-    : owner_(owner) {}
-
-// ---------------------------------------------------------------------------
-// Opcode registrations
-// ---------------------------------------------------------------------------
-
-void QuestHandler::registerOpcodes(DispatchTable& table) {
-
-    // ---- SMSG_GOSSIP_MESSAGE ----
-    table[Opcode::SMSG_GOSSIP_MESSAGE] = [this](network::Packet& packet) { handleGossipMessage(packet); };
-
-    // ---- SMSG_QUESTGIVER_QUEST_LIST ----
-    table[Opcode::SMSG_QUESTGIVER_QUEST_LIST] = [this](network::Packet& packet) { handleQuestgiverQuestList(packet); };
-
-    // ---- SMSG_GOSSIP_COMPLETE ----
-    table[Opcode::SMSG_GOSSIP_COMPLETE] = [this](network::Packet& packet) { handleGossipComplete(packet); };
-
-    // ---- SMSG_GOSSIP_POI ----
-    table[Opcode::SMSG_GOSSIP_POI] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(20)) return;
-        /*uint32_t flags =*/ packet.readUInt32();
-        float poiX = packet.readFloat();
-        float poiY = packet.readFloat();
-        uint32_t icon = packet.readUInt32();
-        uint32_t data = packet.readUInt32();
-        std::string name = packet.readString();
-        GossipPoi poi; poi.x = poiX; poi.y = poiY; poi.icon = icon; poi.data = data; poi.name = std::move(name);
-        if (gossipPois_.size() >= 200) gossipPois_.erase(gossipPois_.begin());
-        gossipPois_.push_back(std::move(poi));
-        LOG_DEBUG("SMSG_GOSSIP_POI: x=", poiX, " y=", poiY, " icon=", icon);
-    };
-
-    // ---- SMSG_QUESTGIVER_QUEST_DETAILS ----
-    table[Opcode::SMSG_QUESTGIVER_QUEST_DETAILS] = [this](network::Packet& packet) { handleQuestDetails(packet); };
-
-    // ---- SMSG_QUESTLOG_FULL ----
-    table[Opcode::SMSG_QUESTLOG_FULL] = [this](network::Packet& /*packet*/) {
-        owner_.addUIError("Your quest log is full.");
-        owner_.addSystemChatMessage("Your quest log is full.");
-    };
-
-    // ---- SMSG_QUESTGIVER_REQUEST_ITEMS ----
-    table[Opcode::SMSG_QUESTGIVER_REQUEST_ITEMS] = [this](network::Packet& packet) { handleQuestRequestItems(packet); };
-
-    // ---- SMSG_QUESTGIVER_OFFER_REWARD ----
-    table[Opcode::SMSG_QUESTGIVER_OFFER_REWARD] = [this](network::Packet& packet) { handleQuestOfferReward(packet); };
-
-    // ---- SMSG_QUEST_CONFIRM_ACCEPT ----
-    table[Opcode::SMSG_QUEST_CONFIRM_ACCEPT] = [this](network::Packet& packet) { handleQuestConfirmAccept(packet); };
-
-    // ---- SMSG_QUEST_POI_QUERY_RESPONSE ----
-    table[Opcode::SMSG_QUEST_POI_QUERY_RESPONSE] = [this](network::Packet& packet) { handleQuestPoiQueryResponse(packet); };
-
-    // ---- SMSG_QUESTGIVER_STATUS ----
-    table[Opcode::SMSG_QUESTGIVER_STATUS] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(9)) {
-            uint64_t npcGuid = packet.readUInt64();
-            uint8_t status = owner_.packetParsers_->readQuestGiverStatus(packet);
-            npcQuestStatus_[npcGuid] = static_cast<QuestGiverStatus>(status);
-        }
-    };
-
-    // ---- SMSG_QUESTGIVER_STATUS_MULTIPLE ----
-    table[Opcode::SMSG_QUESTGIVER_STATUS_MULTIPLE] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(4)) return;
-        uint32_t count = packet.readUInt32();
-        for (uint32_t i = 0; i < count; ++i) {
-            if (!packet.hasRemaining(9)) break;
-            uint64_t npcGuid = packet.readUInt64();
-            uint8_t status = owner_.packetParsers_->readQuestGiverStatus(packet);
-            npcQuestStatus_[npcGuid] = static_cast<QuestGiverStatus>(status);
-        }
-    };
-
-    // ---- SMSG_QUESTUPDATE_FAILED ----
-    table[Opcode::SMSG_QUESTUPDATE_FAILED] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t questId = packet.readUInt32();
-            std::string questTitle;
-            for (const auto& q : questLog_)
-                if (q.questId == questId && !q.title.empty()) { questTitle = q.title; break; }
-            owner_.addSystemChatMessage(questTitle.empty() ? std::string("Quest failed!")
-                                                           : ('"' + questTitle + "\" failed!"));
-        }
-    };
-
-    // ---- SMSG_QUESTUPDATE_FAILEDTIMER ----
-    table[Opcode::SMSG_QUESTUPDATE_FAILEDTIMER] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t questId = packet.readUInt32();
-            std::string questTitle;
-            for (const auto& q : questLog_)
-                if (q.questId == questId && !q.title.empty()) { questTitle = q.title; break; }
-            owner_.addSystemChatMessage(questTitle.empty() ? std::string("Quest timed out!")
-                                                           : ('"' + questTitle + "\" has timed out."));
-        }
-    };
-
-    // ---- SMSG_QUESTGIVER_QUEST_FAILED ----
-    table[Opcode::SMSG_QUESTGIVER_QUEST_FAILED] = [this](network::Packet& packet) {
-        // uint32 questId + uint32 reason
-        if (packet.hasRemaining(8)) {
-            uint32_t questId = packet.readUInt32();
-            uint32_t reason = packet.readUInt32();
-            std::string questTitle;
-            for (const auto& q : questLog_)
-                if (q.questId == questId && !q.title.empty()) { questTitle = q.title; break; }
-            const char* reasonStr = nullptr;
-            switch (reason) {
-                case 1: reasonStr = "failed conditions"; break;
-                case 2: reasonStr = "inventory full"; break;
-                case 3: reasonStr = "too far away"; break;
-                case 4: reasonStr = "another quest is blocking"; break;
-                case 5: reasonStr = "wrong time of day"; break;
-                case 6: reasonStr = "wrong race"; break;
-                case 7: reasonStr = "wrong class"; break;
-            }
-            std::string msg = questTitle.empty() ? "Quest" : ('"' + questTitle + '"');
-            msg += " failed";
-            if (reasonStr) msg += std::string(": ") + reasonStr;
-            msg += '.';
-            owner_.addSystemChatMessage(msg);
-        }
-    };
-
-    // ---- SMSG_QUESTGIVER_QUEST_INVALID ----
-    table[Opcode::SMSG_QUESTGIVER_QUEST_INVALID] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t failReason = packet.readUInt32();
-            pendingTurnInRewardRequest_ = false;
-            const char* reasonStr = "Unknown";
-            switch (failReason) {
-                case 0: reasonStr = "Don't have quest"; break;
-                case 1: reasonStr = "Quest level too low"; break;
-                case 4: reasonStr = "Insufficient money"; break;
-                case 5: reasonStr = "Inventory full"; break;
-                case 13: reasonStr = "Already on that quest"; break;
-                case 18: reasonStr = "Already completed quest"; break;
-                case 19: reasonStr = "Can't take any more quests"; break;
-            }
-            LOG_WARNING("Quest invalid: reason=", failReason, " (", reasonStr, ")");
-            if (!pendingQuestAcceptTimeouts_.empty()) {
-                std::vector<uint32_t> pendingQuestIds;
-                pendingQuestIds.reserve(pendingQuestAcceptTimeouts_.size());
-                for (const auto& pending : pendingQuestAcceptTimeouts_) {
-                    pendingQuestIds.push_back(pending.first);
-                }
-                for (uint32_t questId : pendingQuestIds) {
-                    const uint64_t npcGuid = pendingQuestAcceptNpcGuids_.count(questId) != 0
-                        ? pendingQuestAcceptNpcGuids_[questId] : 0;
-                    if (failReason == 13) {
-                        std::string fallbackTitle = "Quest #" + std::to_string(questId);
-                        std::string fallbackObjectives;
-                        if (currentQuestDetails_.questId == questId) {
-                            if (!currentQuestDetails_.title.empty()) fallbackTitle = currentQuestDetails_.title;
-                            fallbackObjectives = currentQuestDetails_.objectives;
-                        }
-                        addQuestToLocalLogIfMissing(questId, fallbackTitle, fallbackObjectives);
-                        triggerQuestAcceptResync(questId, npcGuid, "already-on-quest");
-                    } else if (failReason == 18) {
-                        triggerQuestAcceptResync(questId, npcGuid, "already-completed");
-                    }
-                    clearPendingQuestAccept(questId);
-                }
-            }
-            // Only show error to user for real errors (not informational messages)
-            if (failReason != 13 && failReason != 18) {  // Don't spam "already on/completed"
-                owner_.addSystemChatMessage(std::string("Quest unavailable: ") + reasonStr);
-            }
-        }
-    };
-
-    // ---- SMSG_QUESTGIVER_QUEST_COMPLETE ----
-    table[Opcode::SMSG_QUESTGIVER_QUEST_COMPLETE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t questId = packet.readUInt32();
-            LOG_INFO("Quest completed: questId=", questId);
-            if (pendingTurnInQuestId_ == questId) {
-                pendingTurnInQuestId_ = 0;
-                pendingTurnInNpcGuid_ = 0;
-                pendingTurnInRewardRequest_ = false;
-            }
-            for (auto it = questLog_.begin(); it != questLog_.end(); ++it) {
-                if (it->questId == questId) {
-                    // Fire toast callback before erasing
-                    if (owner_.questCompleteCallback_) {
-                        owner_.questCompleteCallback_(questId, it->title);
-                    }
-                    // Play quest-complete sound
-                    if (auto* ac = owner_.services().audioCoordinator) {
-                        if (auto* sfx = ac->getUiSoundManager())
-                            sfx->playQuestComplete();
-                    }
-                    questLog_.erase(it);
-                    LOG_INFO("  Removed quest ", questId, " from quest log");
-                    if (owner_.addonEventCallback_)
-                        owner_.addonEventCallback_("QUEST_TURNED_IN", {std::to_string(questId)});
-                    break;
-                }
-            }
-        }
-        if (owner_.addonEventCallback_) {
-            owner_.addonEventCallback_("QUEST_LOG_UPDATE", {});
-            owner_.addonEventCallback_("UNIT_QUEST_LOG_CHANGED", {"player"});
-        }
-        // Re-query all nearby quest giver NPCs so markers refresh
-        if (owner_.socket) {
-            for (const auto& [guid, entity] : owner_.getEntityManager().getEntities()) {
-                if (entity->getType() != ObjectType::UNIT) continue;
-                auto unit = std::static_pointer_cast<Unit>(entity);
-                if (unit->getNpcFlags() & 0x02) {
-                    network::Packet qsPkt(wireOpcode(Opcode::CMSG_QUESTGIVER_STATUS_QUERY));
-                    qsPkt.writeUInt64(guid);
-                    owner_.socket->send(qsPkt);
-                }
-            }
-        }
-    };
-
-    // ---- SMSG_QUESTUPDATE_ADD_KILL ----
-    table[Opcode::SMSG_QUESTUPDATE_ADD_KILL] = [this](network::Packet& packet) {
-        size_t rem = packet.getRemainingSize();
-        if (rem >= 12) {
-            uint32_t questId = packet.readUInt32();
-            clearPendingQuestAccept(questId);
-            uint32_t entry = packet.readUInt32();
-            uint32_t count = packet.readUInt32();
-            uint32_t reqCount = 0;
-            if (packet.hasRemaining(4)) {
-                reqCount = packet.readUInt32();
-            }
-
-            LOG_INFO("Quest kill update: questId=", questId, " entry=", entry,
-                     " count=", count, "/", reqCount);
-
-            for (auto& quest : questLog_) {
-                if (quest.questId == questId) {
-                    if (reqCount == 0) {
-                        auto it = quest.killCounts.find(entry);
-                        if (it != quest.killCounts.end()) reqCount = it->second.second;
-                    }
-                    // Fall back to killObjectives (parsed from SMSG_QUEST_QUERY_RESPONSE).
-                    if (reqCount == 0) {
-                        for (const auto& obj : quest.killObjectives) {
-                            if (obj.npcOrGoId == 0 || obj.required == 0) continue;
-                            uint32_t objEntry = static_cast<uint32_t>(
-                                obj.npcOrGoId > 0 ? obj.npcOrGoId : -obj.npcOrGoId);
-                            if (objEntry == entry) {
-                                reqCount = obj.required;
-                                break;
-                            }
-                        }
-                    }
-                    // Some quests (e.g. escort/event quests) report kill credit updates without
-                    // a corresponding objective count in SMSG_QUEST_QUERY_RESPONSE. Fall back to
-                    // current count so the progress display shows "N/N" instead of "N/0".
-                    if (reqCount == 0) reqCount = count;
-                    quest.killCounts[entry] = {count, reqCount};
-
-                    std::string creatureName = owner_.getCachedCreatureName(entry);
-                    std::string progressMsg = quest.title + ": ";
-                    if (!creatureName.empty()) {
-                        progressMsg += creatureName + " ";
-                    }
-                    progressMsg += std::to_string(count) + "/" + std::to_string(reqCount);
-                    owner_.addSystemChatMessage(progressMsg);
-
-                    if (owner_.questProgressCallback_) {
-                        owner_.questProgressCallback_(quest.title, creatureName, count, reqCount);
-                    }
-                    if (owner_.addonEventCallback_) {
-                        owner_.addonEventCallback_("QUEST_WATCH_UPDATE", {std::to_string(questId)});
-                        owner_.addonEventCallback_("QUEST_LOG_UPDATE", {});
-                        owner_.addonEventCallback_("UNIT_QUEST_LOG_CHANGED", {"player"});
-                    }
-
-                    LOG_INFO("Updated kill count for quest ", questId, ": ",
-                             count, "/", reqCount);
-                    break;
-                }
-            }
-        } else if (rem >= 4) {
-            // Swapped mapping fallback: treat as QUESTUPDATE_COMPLETE packet.
-            uint32_t questId = packet.readUInt32();
-            clearPendingQuestAccept(questId);
-            LOG_INFO("Quest objectives completed (compat via ADD_KILL): questId=", questId);
-            for (auto& quest : questLog_) {
-                if (quest.questId == questId) {
-                    quest.complete = true;
-                    owner_.addSystemChatMessage("Quest Complete: " + quest.title);
-                    break;
-                }
-            }
-        }
-    };
-
-    // ---- SMSG_QUESTUPDATE_ADD_ITEM ----
-    table[Opcode::SMSG_QUESTUPDATE_ADD_ITEM] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(8)) {
-            uint32_t itemId = packet.readUInt32();
-            uint32_t count = packet.readUInt32();
-            owner_.queryItemInfo(itemId, 0);
-
-            std::string itemLabel = "item #" + std::to_string(itemId);
-            uint32_t questItemQuality = 1;
-            if (const ItemQueryResponseData* info = owner_.getItemInfo(itemId)) {
-                if (!info->name.empty()) itemLabel = info->name;
-                questItemQuality = info->quality;
-            }
-
-            bool updatedAny = false;
-            for (auto& quest : questLog_) {
-                if (quest.complete) continue;
-                bool tracksItem =
-                    quest.requiredItemCounts.count(itemId) > 0 ||
-                    quest.itemCounts.count(itemId) > 0;
-                // Also check itemObjectives parsed from SMSG_QUEST_QUERY_RESPONSE in case
-                // requiredItemCounts hasn't been populated yet (race during quest accept).
-                if (!tracksItem) {
-                    for (const auto& obj : quest.itemObjectives) {
-                        if (obj.itemId == itemId && obj.required > 0) {
-                            quest.requiredItemCounts.emplace(itemId, obj.required);
-                            tracksItem = true;
-                            break;
-                        }
-                    }
-                }
-                if (!tracksItem) continue;
-                quest.itemCounts[itemId] = count;
-                updatedAny = true;
-            }
-            owner_.addSystemChatMessage("Quest item: " + buildItemLink(itemId, questItemQuality, itemLabel) + " (" + std::to_string(count) + ")");
-
-            if (owner_.questProgressCallback_ && updatedAny) {
-                for (const auto& quest : questLog_) {
-                    if (quest.complete) continue;
-                    if (quest.itemCounts.count(itemId) == 0) continue;
-                    uint32_t required = 0;
-                    auto rIt = quest.requiredItemCounts.find(itemId);
-                    if (rIt != quest.requiredItemCounts.end()) required = rIt->second;
-                    if (required == 0) {
-                        for (const auto& obj : quest.itemObjectives) {
-                            if (obj.itemId == itemId) { required = obj.required; break; }
-                        }
-                    }
-                    if (required == 0) required = count;
-                    owner_.questProgressCallback_(quest.title, itemLabel, count, required);
-                    break;
-                }
-            }
-
-            if (owner_.addonEventCallback_ && updatedAny) {
-                owner_.addonEventCallback_("QUEST_WATCH_UPDATE", {});
-                owner_.addonEventCallback_("QUEST_LOG_UPDATE", {});
-                owner_.addonEventCallback_("UNIT_QUEST_LOG_CHANGED", {"player"});
-            }
-            LOG_INFO("Quest item update: itemId=", itemId, " count=", count,
-                     " trackedQuestsUpdated=", updatedAny);
-        }
-    };
-
-    // ---- SMSG_QUESTUPDATE_COMPLETE ----
-    table[Opcode::SMSG_QUESTUPDATE_COMPLETE] = [this](network::Packet& packet) {
-        size_t rem = packet.getRemainingSize();
-        if (rem >= 12) {
-            uint32_t questId = packet.readUInt32();
-            clearPendingQuestAccept(questId);
-            uint32_t entry = packet.readUInt32();
-            uint32_t count = packet.readUInt32();
-            uint32_t reqCount = 0;
-            if (packet.hasRemaining(4)) reqCount = packet.readUInt32();
-            if (reqCount == 0) reqCount = count;
-            LOG_INFO("Quest kill update (compat via COMPLETE): questId=", questId,
-                     " entry=", entry, " count=", count, "/", reqCount);
-            for (auto& quest : questLog_) {
-                if (quest.questId == questId) {
-                    quest.killCounts[entry] = {count, reqCount};
-                    owner_.addSystemChatMessage(quest.title + ": " + std::to_string(count) +
-                                                 "/" + std::to_string(reqCount));
-                    break;
-                }
-            }
-        } else if (rem >= 4) {
-            uint32_t questId = packet.readUInt32();
-            clearPendingQuestAccept(questId);
-            LOG_INFO("Quest objectives completed: questId=", questId);
-
-            for (auto& quest : questLog_) {
-                if (quest.questId == questId) {
-                    quest.complete = true;
-                    owner_.addSystemChatMessage("Quest Complete: " + quest.title);
-                    LOG_INFO("Marked quest ", questId, " as complete");
-                    break;
-                }
-            }
-        }
-    };
-
-    // ---- SMSG_QUEST_FORCE_REMOVE ----
-    table[Opcode::SMSG_QUEST_FORCE_REMOVE] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(4)) {
-            LOG_WARNING("SMSG_QUEST_FORCE_REMOVE/SET_REST_START too short");
-            return;
-        }
-        uint32_t value = packet.readUInt32();
-
-        // WotLK uses this opcode as SMSG_SET_REST_START
-        if (!isClassicLikeExpansion() && !isActiveExpansion("tbc")) {
-            bool nowResting = (value != 0);
-            if (nowResting != owner_.isResting_) {
-                owner_.isResting_ = nowResting;
-                owner_.addSystemChatMessage(owner_.isResting_ ? "You are now resting."
-                                                              : "You are no longer resting.");
-                if (owner_.addonEventCallback_)
-                    owner_.addonEventCallback_("PLAYER_UPDATE_RESTING", {});
-            }
-            return;
-        }
-
-        // Classic/TBC: treat as QUEST_FORCE_REMOVE (uint32 questId)
-        uint32_t questId = value;
-        clearPendingQuestAccept(questId);
-        pendingQuestQueryIds_.erase(questId);
-        if (questId == 0) {
-            return;
-        }
-
-        bool removed = false;
-        std::string removedTitle;
-        for (auto it = questLog_.begin(); it != questLog_.end(); ++it) {
-            if (it->questId == questId) {
-                removedTitle = it->title;
-                questLog_.erase(it);
-                removed = true;
-                break;
-            }
-        }
-        if (currentQuestDetails_.questId == questId) {
-            questDetailsOpen_ = false;
-            questDetailsOpenTime_ = std::chrono::steady_clock::time_point{};
-            currentQuestDetails_ = QuestDetailsData{};
-            removed = true;
-        }
-        if (currentQuestRequestItems_.questId == questId) {
-            questRequestItemsOpen_ = false;
-            currentQuestRequestItems_ = QuestRequestItemsData{};
-            removed = true;
-        }
-        if (currentQuestOfferReward_.questId == questId) {
-            questOfferRewardOpen_ = false;
-            currentQuestOfferReward_ = QuestOfferRewardData{};
-            removed = true;
-        }
-        if (removed) {
-            if (!removedTitle.empty()) {
-                owner_.addSystemChatMessage("Quest removed: " + removedTitle);
-            } else {
-                owner_.addSystemChatMessage("Quest removed (ID " + std::to_string(questId) + ").");
-            }
-            if (owner_.addonEventCallback_) {
-                owner_.addonEventCallback_("QUEST_LOG_UPDATE", {});
-                owner_.addonEventCallback_("UNIT_QUEST_LOG_CHANGED", {"player"});
-                owner_.addonEventCallback_("QUEST_REMOVED", {std::to_string(questId)});
-            }
-        }
-    };
-
-    // ---- SMSG_QUEST_QUERY_RESPONSE ----
-    table[Opcode::SMSG_QUEST_QUERY_RESPONSE] = [this](network::Packet& packet) {
-        if (packet.getSize() < 8) {
-            LOG_WARNING("SMSG_QUEST_QUERY_RESPONSE: packet too small (", packet.getSize(), " bytes)");
-            return;
-        }
-
-        uint32_t questId = packet.readUInt32();
-        packet.readUInt32(); // questMethod
-
-        const bool isClassicLayout = owner_.packetParsers_ && owner_.packetParsers_->questLogStride() <= 4;
-        const QuestQueryTextCandidate parsed = pickBestQuestQueryTexts(packet.getData(), isClassicLayout);
-        const QuestQueryObjectives objs = extractQuestQueryObjectives(packet.getData(), isClassicLayout);
-        const QuestQueryRewards rwds = tryParseQuestRewards(packet.getData(), isClassicLayout);
-
-        for (auto& q : questLog_) {
-            if (q.questId != questId) continue;
-
-            const int existingScore = scoreQuestTitle(q.title);
-            const bool parsedStrong = isStrongQuestTitle(parsed.title);
-            const bool parsedLongEnough = parsed.title.size() >= 6;
-            const bool notShorterThanExisting =
-                isPlaceholderQuestTitle(q.title) || q.title.empty() || parsed.title.size() + 2 >= q.title.size();
-            const bool shouldReplaceTitle =
-                parsed.score > -1000 &&
-                parsedStrong &&
-                parsedLongEnough &&
-                notShorterThanExisting &&
-                (isPlaceholderQuestTitle(q.title) || q.title.empty() || parsed.score >= existingScore + 12);
-
-            if (shouldReplaceTitle && !parsed.title.empty()) {
-                q.title = parsed.title;
-            }
-            if (!parsed.objectives.empty() &&
-                (q.objectives.empty() || q.objectives.size() < 16)) {
-                q.objectives = parsed.objectives;
-            }
-
-            // Store structured kill/item objectives for later kill-count restoration.
-            if (objs.valid) {
-                for (int i = 0; i < 4; ++i) {
-                    q.killObjectives[i].npcOrGoId = objs.kills[i].npcOrGoId;
-                    q.killObjectives[i].required  = objs.kills[i].required;
-                }
-                for (int i = 0; i < 6; ++i) {
-                    q.itemObjectives[i].itemId   = objs.items[i].itemId;
-                    q.itemObjectives[i].required = objs.items[i].required;
-                }
-                applyPackedKillCountsFromFields(q);
-                for (int i = 0; i < 4; ++i) {
-                    int32_t id = objs.kills[i].npcOrGoId;
-                    if (id == 0 || objs.kills[i].required == 0) continue;
-                    if (id > 0) owner_.queryCreatureInfo(static_cast<uint32_t>(id), 0);
-                    else        owner_.queryGameObjectInfo(static_cast<uint32_t>(-id), 0);
-                }
-                for (int i = 0; i < 6; ++i) {
-                    if (objs.items[i].itemId != 0 && objs.items[i].required != 0)
-                        owner_.queryItemInfo(objs.items[i].itemId, 0);
-                }
-                LOG_DEBUG("Quest ", questId, " objectives parsed: kills=[",
-                          objs.kills[0].npcOrGoId, "/", objs.kills[0].required, ", ",
-                          objs.kills[1].npcOrGoId, "/", objs.kills[1].required, ", ",
-                          objs.kills[2].npcOrGoId, "/", objs.kills[2].required, ", ",
-                          objs.kills[3].npcOrGoId, "/", objs.kills[3].required, "]");
-            }
-
-            // Store reward data and pre-fetch item info for icons.
-            if (rwds.valid) {
-                q.rewardMoney = rwds.rewardMoney;
-                for (int i = 0; i < 4; ++i) {
-                    q.rewardItems[i].itemId = rwds.itemId[i];
-                    q.rewardItems[i].count  = (rwds.itemId[i] != 0) ? rwds.itemCount[i] : 0;
-                    if (rwds.itemId[i] != 0) owner_.queryItemInfo(rwds.itemId[i], 0);
-                }
-                for (int i = 0; i < 6; ++i) {
-                    q.rewardChoiceItems[i].itemId = rwds.choiceItemId[i];
-                    q.rewardChoiceItems[i].count  = (rwds.choiceItemId[i] != 0) ? rwds.choiceItemCount[i] : 0;
-                    if (rwds.choiceItemId[i] != 0) owner_.queryItemInfo(rwds.choiceItemId[i], 0);
-                }
-            }
-            break;
-        }
-
-        pendingQuestQueryIds_.erase(questId);
-    };
-
-    // ---- SMSG_QUESTUPDATE_ADD_PVP_KILL ----
-    table[Opcode::SMSG_QUESTUPDATE_ADD_PVP_KILL] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(16)) {
-            /*uint64_t guid =*/ packet.readUInt64();
-            uint32_t questId = packet.readUInt32();
-            uint32_t count   = packet.readUInt32();
-            uint32_t reqCount = 0;
-            if (packet.hasRemaining(4)) {
-                reqCount = packet.readUInt32();
-            }
-
-            constexpr uint32_t PVP_KILL_ENTRY = 0u;
-            for (auto& quest : questLog_) {
-                if (quest.questId != questId) continue;
-
-                if (reqCount == 0) {
-                    auto it = quest.killCounts.find(PVP_KILL_ENTRY);
-                    if (it != quest.killCounts.end()) reqCount = it->second.second;
-                }
-                if (reqCount == 0) {
-                    for (const auto& obj : quest.killObjectives) {
-                        if (obj.npcOrGoId == 0 && obj.required > 0) {
-                            reqCount = obj.required;
-                            break;
-                        }
-                    }
-                }
-                if (reqCount == 0) reqCount = count;
-                quest.killCounts[PVP_KILL_ENTRY] = {count, reqCount};
-
-                std::string progressMsg = quest.title + ": PvP kills " +
-                    std::to_string(count) + "/" + std::to_string(reqCount);
-                owner_.addSystemChatMessage(progressMsg);
-                break;
-            }
-        }
-    };
-
-    // ---- Completed quests response (moved from GameHandler) ----
-    table[Opcode::SMSG_QUERY_QUESTS_COMPLETED_RESPONSE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t count = packet.readUInt32();
-            if (count <= 4096) {
-                for (uint32_t i = 0; i < count; ++i) {
-                    if (!packet.hasRemaining(4)) break;
-                    uint32_t questId = packet.readUInt32();
-                    owner_.completedQuests_.insert(questId);
-                }
-                LOG_DEBUG("SMSG_QUERY_QUESTS_COMPLETED_RESPONSE: ", count, " completed quests");
-            }
-        }
-        packet.skipAll();
-    };
-}
-
-// ---------------------------------------------------------------------------
-// Public API methods
-// ---------------------------------------------------------------------------
-
-void QuestHandler::selectGossipOption(uint32_t optionId) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || !gossipWindowOpen_) return;
-    LOG_INFO("selectGossipOption: optionId=", optionId,
-             " npcGuid=0x", std::hex, currentGossip_.npcGuid, std::dec,
-             " menuId=", currentGossip_.menuId,
-             " numOptions=", currentGossip_.options.size());
-    auto packet = GossipSelectOptionPacket::build(currentGossip_.npcGuid, currentGossip_.menuId, optionId);
-    owner_.socket->send(packet);
-
-    for (const auto& opt : currentGossip_.options) {
-        if (opt.id != optionId) continue;
-        LOG_INFO("  matched option: id=", opt.id, " icon=", (int)opt.icon, " text='", opt.text, "'");
-
-        std::string text = opt.text;
-        std::string textLower = text;
-        std::transform(textLower.begin(), textLower.end(), textLower.begin(),
-                       [](unsigned char c){ return static_cast<char>(std::tolower(c)); });
-
-        // Icon- and text-based NPC interaction fallbacks.
-        // Use flags to avoid sending the same activation packet twice when
-        // both the icon and text match (e.g., banker icon 6 + "deposit box").
-        bool sentBanker = false;
-        bool sentAuction = false;
-
-        if (opt.icon == 6) {
-            auto pkt = BankerActivatePacket::build(currentGossip_.npcGuid);
-            owner_.socket->send(pkt);
-            sentBanker = true;
-            LOG_INFO("Sent CMSG_BANKER_ACTIVATE (icon) for npc=0x", std::hex, currentGossip_.npcGuid, std::dec);
-        }
-
-        if (!sentAuction && (text == "GOSSIP_OPTION_AUCTIONEER" || textLower.find("auction") != std::string::npos)) {
-            auto pkt = AuctionHelloPacket::build(currentGossip_.npcGuid);
-            owner_.socket->send(pkt);
-            sentAuction = true;
-            LOG_INFO("Sent MSG_AUCTION_HELLO for npc=0x", std::hex, currentGossip_.npcGuid, std::dec);
-        }
-
-        if (!sentBanker && (text == "GOSSIP_OPTION_BANKER" || textLower.find("deposit box") != std::string::npos)) {
-            auto pkt = BankerActivatePacket::build(currentGossip_.npcGuid);
-            owner_.socket->send(pkt);
-            sentBanker = true;
-            LOG_INFO("Sent CMSG_BANKER_ACTIVATE (text) for npc=0x", std::hex, currentGossip_.npcGuid, std::dec);
-        }
-
-        const bool isVendor = (text == "GOSSIP_OPTION_VENDOR" ||
-                               (textLower.find("browse") != std::string::npos &&
-                                (textLower.find("goods") != std::string::npos || textLower.find("wares") != std::string::npos)));
-        const bool isArmorer = (text == "GOSSIP_OPTION_ARMORER" || textLower.find("repair") != std::string::npos);
-        if (isVendor || isArmorer) {
-            if (isArmorer) {
-                owner_.setVendorCanRepair(true);
-            }
-            auto pkt = ListInventoryPacket::build(currentGossip_.npcGuid);
-            owner_.socket->send(pkt);
-            LOG_DEBUG("Sent CMSG_LIST_INVENTORY (gossip) to npc=0x", std::hex, currentGossip_.npcGuid, std::dec);
-        }
-
-        if (textLower.find("make this inn your home") != std::string::npos ||
-            textLower.find("set your home") != std::string::npos) {
-            auto bindPkt = BinderActivatePacket::build(currentGossip_.npcGuid);
-            owner_.socket->send(bindPkt);
-            LOG_INFO("Sent CMSG_BINDER_ACTIVATE for npc=0x", std::hex, currentGossip_.npcGuid, std::dec);
-        }
-
-        // Stable master detection
-        if (text == "GOSSIP_OPTION_STABLE" ||
-            textLower.find("stable") != std::string::npos ||
-            textLower.find("my pet") != std::string::npos) {
-            owner_.stableMasterGuid_ = currentGossip_.npcGuid;
-            owner_.stableWindowOpen_ = false;
-            auto listPkt = ListStabledPetsPacket::build(currentGossip_.npcGuid);
-            owner_.socket->send(listPkt);
-            LOG_INFO("Sent MSG_LIST_STABLED_PETS (gossip) to npc=0x",
-                     std::hex, currentGossip_.npcGuid, std::dec);
-        }
-        break;
-    }
-}
-
-void QuestHandler::selectGossipQuest(uint32_t questId) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || !gossipWindowOpen_) return;
-
-    const QuestLogEntry* activeQuest = nullptr;
-    for (const auto& q : questLog_) {
-        if (q.questId == questId) {
-            activeQuest = &q;
-            break;
-        }
-    }
-
-    // Validate against server-auth quest slot fields
-    auto questInServerLogSlots = [&](uint32_t qid) -> bool {
-        if (qid == 0 || owner_.lastPlayerFields_.empty()) return false;
-        const uint16_t ufQuestStart = fieldIndex(UF::PLAYER_QUEST_LOG_START);
-        const uint8_t qStride = owner_.packetParsers_ ? owner_.packetParsers_->questLogStride() : 5;
-        const uint16_t ufQuestEnd = ufQuestStart + 25 * qStride;
-        for (const auto& [key, val] : owner_.lastPlayerFields_) {
-            if (key < ufQuestStart || key >= ufQuestEnd) continue;
-            if ((key - ufQuestStart) % qStride != 0) continue;
-            if (val == qid) return true;
-        }
-        return false;
-    };
-    const bool questInServerLog = questInServerLogSlots(questId);
-    if (questInServerLog && !activeQuest) {
-        addQuestToLocalLogIfMissing(questId, "Quest #" + std::to_string(questId), "");
-        requestQuestQuery(questId, false);
-        for (const auto& q : questLog_) {
-            if (q.questId == questId) {
-                activeQuest = &q;
-                break;
-            }
-        }
-    }
-    const bool activeQuestConfirmedByServer = questInServerLog;
-    const bool shouldStartProgressFlow = activeQuestConfirmedByServer;
-    if (shouldStartProgressFlow) {
-        pendingTurnInQuestId_ = questId;
-        pendingTurnInNpcGuid_ = currentGossip_.npcGuid;
-        pendingTurnInRewardRequest_ = activeQuest ? activeQuest->complete : false;
-        auto packet = QuestgiverCompleteQuestPacket::build(currentGossip_.npcGuid, questId);
-        owner_.socket->send(packet);
-    } else {
-        pendingTurnInQuestId_ = 0;
-        pendingTurnInNpcGuid_ = 0;
-        pendingTurnInRewardRequest_ = false;
-        auto packet = owner_.packetParsers_
-            ? owner_.packetParsers_->buildQueryQuestPacket(currentGossip_.npcGuid, questId)
-            : QuestgiverQueryQuestPacket::build(currentGossip_.npcGuid, questId);
-        owner_.socket->send(packet);
-    }
-
-    gossipWindowOpen_ = false;
-}
-
-bool QuestHandler::requestQuestQuery(uint32_t questId, bool force) {
-    if (questId == 0 || owner_.state != WorldState::IN_WORLD || !owner_.socket) return false;
-    if (!force && pendingQuestQueryIds_.count(questId)) return false;
-
-    network::Packet pkt(wireOpcode(Opcode::CMSG_QUEST_QUERY));
-    pkt.writeUInt32(questId);
-    owner_.socket->send(pkt);
-    pendingQuestQueryIds_.insert(questId);
-
-    // WotLK supports CMSG_QUEST_POI_QUERY to get objective map locations.
-    if (owner_.packetParsers_ && owner_.packetParsers_->questLogStride() == 5) {
-        const uint32_t wirePoiQuery = wireOpcode(Opcode::CMSG_QUEST_POI_QUERY);
-        if (wirePoiQuery != 0xFFFF) {
-            network::Packet poiPkt(static_cast<uint16_t>(wirePoiQuery));
-            poiPkt.writeUInt32(1);          // count = 1
-            poiPkt.writeUInt32(questId);
-            owner_.socket->send(poiPkt);
-        }
-    }
-    return true;
-}
-
-void QuestHandler::setQuestTracked(uint32_t questId, bool tracked) {
-    if (tracked) {
-        trackedQuestIds_.insert(questId);
-    } else {
-        trackedQuestIds_.erase(questId);
-    }
-}
-
-void QuestHandler::acceptQuest() {
-    if (!questDetailsOpen_ || owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    const uint32_t questId = currentQuestDetails_.questId;
-    if (questId == 0) return;
-    uint64_t npcGuid = currentQuestDetails_.npcGuid;
-    if (pendingQuestAcceptTimeouts_.count(questId) != 0) {
-        LOG_DEBUG("Ignoring duplicate quest accept while pending: questId=", questId);
-        triggerQuestAcceptResync(questId, npcGuid, "duplicate-accept");
-        questDetailsOpen_ = false;
-        questDetailsOpenTime_ = std::chrono::steady_clock::time_point{};
-        currentQuestDetails_ = QuestDetailsData{};
-        return;
-    }
-    const bool inLocalLog = hasQuestInLog(questId);
-    const int serverSlot = findQuestLogSlotIndexFromServer(questId);
-    if (serverSlot >= 0) {
-        LOG_INFO("Ignoring duplicate quest accept already in server quest log: questId=", questId,
-                 " slot=", serverSlot);
-        questDetailsOpen_ = false;
-        questDetailsOpenTime_ = std::chrono::steady_clock::time_point{};
-        currentQuestDetails_ = QuestDetailsData{};
-        return;
-    }
-    if (inLocalLog) {
-        LOG_WARNING("Quest accept local/server mismatch, allowing re-accept: questId=", questId);
-        std::erase_if(questLog_, [&](const QuestLogEntry& q) { return q.questId == questId; });
-    }
-
-    network::Packet packet = owner_.packetParsers_
-        ? owner_.packetParsers_->buildAcceptQuestPacket(npcGuid, questId)
-        : QuestgiverAcceptQuestPacket::build(npcGuid, questId);
-    owner_.socket->send(packet);
-    pendingQuestAcceptTimeouts_[questId] = 5.0f;
-    pendingQuestAcceptNpcGuids_[questId] = npcGuid;
-
-    // Play quest-accept sound
-    if (auto* ac = owner_.services().audioCoordinator) {
-        if (auto* sfx = ac->getUiSoundManager())
-            sfx->playQuestActivate();
-    }
-
-    questDetailsOpen_ = false;
-    questDetailsOpenTime_ = std::chrono::steady_clock::time_point{};
-    currentQuestDetails_ = QuestDetailsData{};
-
-    // Re-query quest giver status so marker updates (! → ?)
-    if (npcGuid) {
-        network::Packet qsPkt(wireOpcode(Opcode::CMSG_QUESTGIVER_STATUS_QUERY));
-        qsPkt.writeUInt64(npcGuid);
-        owner_.socket->send(qsPkt);
-    }
-}
-
-void QuestHandler::declineQuest() {
-    questDetailsOpen_ = false;
-    questDetailsOpenTime_ = std::chrono::steady_clock::time_point{};
-    currentQuestDetails_ = QuestDetailsData{};
-}
-
-void QuestHandler::closeGossip() {
-    gossipWindowOpen_ = false;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("GOSSIP_CLOSED", {});
-    currentGossip_ = GossipMessageData{};
-}
-
-void QuestHandler::offerQuestFromItem(uint64_t itemGuid, uint32_t questId) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    if (itemGuid == 0 || questId == 0) {
-        owner_.addSystemChatMessage("Cannot start quest right now.");
-        return;
-    }
-    // Send CMSG_QUESTGIVER_QUERY_QUEST with the item GUID as the "questgiver."
-    // The server responds with SMSG_QUESTGIVER_QUEST_DETAILS which handleQuestDetails()
-    // picks up and opens the Accept/Decline dialog.
-    auto queryPkt = owner_.packetParsers_
-        ? owner_.packetParsers_->buildQueryQuestPacket(itemGuid, questId)
-        : QuestgiverQueryQuestPacket::build(itemGuid, questId);
-    owner_.socket->send(queryPkt);
-    LOG_INFO("offerQuestFromItem: itemGuid=0x", std::hex, itemGuid, std::dec,
-             " questId=", questId);
-}
-
-void QuestHandler::completeQuest() {
-    if (!questRequestItemsOpen_ || owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    pendingTurnInQuestId_ = currentQuestRequestItems_.questId;
-    pendingTurnInNpcGuid_ = currentQuestRequestItems_.npcGuid;
-    pendingTurnInRewardRequest_ = currentQuestRequestItems_.isCompletable();
-
-    auto packet = QuestgiverCompleteQuestPacket::build(
-        currentQuestRequestItems_.npcGuid, currentQuestRequestItems_.questId);
-    owner_.socket->send(packet);
-    questRequestItemsOpen_ = false;
-    currentQuestRequestItems_ = QuestRequestItemsData{};
-}
-
-void QuestHandler::closeQuestRequestItems() {
-    pendingTurnInRewardRequest_ = false;
-    questRequestItemsOpen_ = false;
-    currentQuestRequestItems_ = QuestRequestItemsData{};
-}
-
-void QuestHandler::chooseQuestReward(uint32_t rewardIndex) {
-    if (!questOfferRewardOpen_ || owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    uint64_t npcGuid = currentQuestOfferReward_.npcGuid;
-    LOG_INFO("Completing quest: questId=", currentQuestOfferReward_.questId,
-             " npcGuid=", npcGuid, " rewardIndex=", rewardIndex);
-    auto packet = QuestgiverChooseRewardPacket::build(
-        npcGuid, currentQuestOfferReward_.questId, rewardIndex);
-    owner_.socket->send(packet);
-    pendingTurnInQuestId_ = 0;
-    pendingTurnInNpcGuid_ = 0;
-    pendingTurnInRewardRequest_ = false;
-    questOfferRewardOpen_ = false;
-    currentQuestOfferReward_ = QuestOfferRewardData{};
-
-    // Re-query quest giver status so markers update
-    if (npcGuid) {
-        network::Packet qsPkt(wireOpcode(Opcode::CMSG_QUESTGIVER_STATUS_QUERY));
-        qsPkt.writeUInt64(npcGuid);
-        owner_.socket->send(qsPkt);
-    }
-}
-
-void QuestHandler::closeQuestOfferReward() {
-    pendingTurnInRewardRequest_ = false;
-    questOfferRewardOpen_ = false;
-    currentQuestOfferReward_ = QuestOfferRewardData{};
-}
-
-void QuestHandler::abandonQuest(uint32_t questId) {
-    clearPendingQuestAccept(questId);
-    int localIndex = -1;
-    for (size_t i = 0; i < questLog_.size(); ++i) {
-        if (questLog_[i].questId == questId) {
-            localIndex = static_cast<int>(i);
-            break;
-        }
-    }
-
-    int slotIndex = findQuestLogSlotIndexFromServer(questId);
-    if (slotIndex < 0 && localIndex >= 0) {
-        slotIndex = localIndex;
-        LOG_WARNING("Abandon quest using local slot fallback: questId=", questId, " slot=", slotIndex);
-    }
-
-    if (slotIndex >= 0 && slotIndex < 25) {
-        if (owner_.state == WorldState::IN_WORLD && owner_.socket) {
-            network::Packet pkt(wireOpcode(Opcode::CMSG_QUESTLOG_REMOVE_QUEST));
-            pkt.writeUInt8(static_cast<uint8_t>(slotIndex));
-            owner_.socket->send(pkt);
-        }
-    } else {
-        LOG_WARNING("Abandon quest failed: no quest-log slot found for questId=", questId);
-    }
-
-    if (localIndex >= 0) {
-        questLog_.erase(questLog_.begin() + static_cast<ptrdiff_t>(localIndex));
-        if (owner_.addonEventCallback_) {
-            owner_.addonEventCallback_("QUEST_LOG_UPDATE", {});
-            owner_.addonEventCallback_("UNIT_QUEST_LOG_CHANGED", {"player"});
-            owner_.addonEventCallback_("QUEST_REMOVED", {std::to_string(questId)});
-        }
-    }
-
-    // Remove any quest POI minimap markers for this quest.
-    gossipPois_.erase(
-        std::remove_if(gossipPois_.begin(), gossipPois_.end(),
-            [questId](const GossipPoi& p) { return p.data == questId; }),
-        gossipPois_.end());
-}
-
-void QuestHandler::shareQuestWithParty(uint32_t questId) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) {
-        owner_.addSystemChatMessage("Cannot share quest: not in world.");
-        return;
-    }
-    if (!owner_.isInGroup()) {
-        owner_.addSystemChatMessage("You must be in a group to share a quest.");
-        return;
-    }
-    network::Packet pkt(wireOpcode(Opcode::CMSG_PUSHQUESTTOPARTY));
-    pkt.writeUInt32(questId);
-    owner_.socket->send(pkt);
-    // Local feedback: find quest title
-    for (const auto& q : questLog_) {
-        if (q.questId == questId && !q.title.empty()) {
-            owner_.addSystemChatMessage("Sharing quest: " + q.title);
-            return;
-        }
-    }
-    owner_.addSystemChatMessage("Quest shared.");
-}
-
-void QuestHandler::acceptSharedQuest() {
-    if (!pendingSharedQuest_ || !owner_.socket) return;
-    pendingSharedQuest_ = false;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_QUEST_CONFIRM_ACCEPT));
-    pkt.writeUInt32(sharedQuestId_);
-    owner_.socket->send(pkt);
-    owner_.addSystemChatMessage("Accepted: " + sharedQuestTitle_);
-}
-
-void QuestHandler::declineSharedQuest() {
-    pendingSharedQuest_ = false;
-    // No response packet needed — just dismiss the UI
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-bool QuestHandler::hasQuestInLog(uint32_t questId) const {
-    for (const auto& q : questLog_) {
-        if (q.questId == questId) return true;
-    }
-    return false;
-}
-
-int QuestHandler::findQuestLogSlotIndexFromServer(uint32_t questId) const {
-    if (questId == 0 || owner_.lastPlayerFields_.empty()) return -1;
-    const uint16_t ufQuestStart = fieldIndex(UF::PLAYER_QUEST_LOG_START);
-    const uint8_t qStride = owner_.packetParsers_ ? owner_.packetParsers_->questLogStride() : 5;
-    for (uint16_t slot = 0; slot < 25; ++slot) {
-        const uint16_t idField = ufQuestStart + slot * qStride;
-        auto it = owner_.lastPlayerFields_.find(idField);
-        if (it != owner_.lastPlayerFields_.end() && it->second == questId) {
-            return static_cast<int>(slot);
-        }
-    }
-    return -1;
-}
-
-void QuestHandler::addQuestToLocalLogIfMissing(uint32_t questId, const std::string& title, const std::string& objectives) {
-    if (questId == 0 || hasQuestInLog(questId)) return;
-    QuestLogEntry entry;
-    entry.questId = questId;
-    entry.title = title.empty() ? ("Quest #" + std::to_string(questId)) : title;
-    entry.objectives = objectives;
-    questLog_.push_back(std::move(entry));
-    if (owner_.addonEventCallback_) {
-        owner_.addonEventCallback_("QUEST_ACCEPTED", {std::to_string(questId)});
-        owner_.addonEventCallback_("QUEST_LOG_UPDATE", {});
-        owner_.addonEventCallback_("UNIT_QUEST_LOG_CHANGED", {"player"});
-    }
-}
-
-bool QuestHandler::resyncQuestLogFromServerSlots(bool forceQueryMetadata) {
-    if (owner_.lastPlayerFields_.empty()) return false;
-
-    const uint16_t ufQuestStart = fieldIndex(UF::PLAYER_QUEST_LOG_START);
-    const uint8_t qStride = owner_.packetParsers_ ? owner_.packetParsers_->questLogStride() : 5;
-
-    static constexpr uint32_t kQuestStatusComplete = 1;
-
-    std::unordered_map<uint32_t, bool> serverQuestComplete;
-    serverQuestComplete.reserve(25);
-    for (uint16_t slot = 0; slot < 25; ++slot) {
-        const uint16_t idField    = ufQuestStart + slot * qStride;
-        const uint16_t stateField = ufQuestStart + slot * qStride + 1;
-        auto it = owner_.lastPlayerFields_.find(idField);
-        if (it == owner_.lastPlayerFields_.end()) continue;
-        uint32_t questId = it->second;
-        if (questId == 0) continue;
-
-        bool complete = false;
-        if (qStride >= 2) {
-            auto stateIt = owner_.lastPlayerFields_.find(stateField);
-            if (stateIt != owner_.lastPlayerFields_.end()) {
-                uint32_t state = stateIt->second & 0xFF;
-                complete = (state == kQuestStatusComplete);
-            }
-        }
-        serverQuestComplete[questId] = complete;
-    }
-
-    std::unordered_set<uint32_t> serverQuestIds;
-    serverQuestIds.reserve(serverQuestComplete.size());
-    for (const auto& [qid, _] : serverQuestComplete) serverQuestIds.insert(qid);
-
-    const size_t localBefore = questLog_.size();
-    std::erase_if(questLog_, [&](const QuestLogEntry& q) {
-        return q.questId == 0 || serverQuestIds.count(q.questId) == 0;
-    });
-    const size_t removed = localBefore - questLog_.size();
-
-    size_t added = 0;
-    for (uint32_t questId : serverQuestIds) {
-        if (hasQuestInLog(questId)) continue;
-        addQuestToLocalLogIfMissing(questId, "Quest #" + std::to_string(questId), "");
-        ++added;
-    }
-
-    size_t marked = 0;
-    for (auto& quest : questLog_) {
-        auto it = serverQuestComplete.find(quest.questId);
-        if (it == serverQuestComplete.end()) continue;
-        if (it->second && !quest.complete) {
-            quest.complete = true;
-            ++marked;
-            LOG_DEBUG("Quest ", quest.questId, " marked complete from update fields");
-        }
-    }
-
-    if (forceQueryMetadata) {
-        for (uint32_t questId : serverQuestIds) {
-            requestQuestQuery(questId, false);
-        }
-    }
-
-    LOG_INFO("Quest log resync from server slots: server=", serverQuestIds.size(),
-             " localBefore=", localBefore, " removed=", removed, " added=", added,
-             " markedComplete=", marked);
-    return true;
-}
-
-void QuestHandler::applyQuestStateFromFields(const std::map<uint16_t, uint32_t>& fields) {
-    const uint16_t ufQuestStart = fieldIndex(UF::PLAYER_QUEST_LOG_START);
-    if (ufQuestStart == 0xFFFF || questLog_.empty()) return;
-
-    const uint8_t qStride = owner_.packetParsers_ ? owner_.packetParsers_->questLogStride() : 5;
-    if (qStride < 2) return;
-
-    static constexpr uint32_t kQuestStatusComplete = 1;
-
-    for (uint16_t slot = 0; slot < 25; ++slot) {
-        const uint16_t idField    = ufQuestStart + slot * qStride;
-        const uint16_t stateField = idField + 1;
-        auto idIt = fields.find(idField);
-        if (idIt == fields.end()) continue;
-        uint32_t questId = idIt->second;
-        if (questId == 0) continue;
-
-        auto stateIt = fields.find(stateField);
-        if (stateIt == fields.end()) continue;
-        bool serverComplete = ((stateIt->second & 0xFF) == kQuestStatusComplete);
-        if (!serverComplete) continue;
-
-        for (auto& quest : questLog_) {
-            if (quest.questId == questId && !quest.complete) {
-                quest.complete = true;
-                LOG_INFO("Quest ", questId, " marked complete from VALUES update field state");
-                break;
-            }
-        }
-    }
-}
-
-void QuestHandler::applyPackedKillCountsFromFields(QuestLogEntry& quest) {
-    if (owner_.lastPlayerFields_.empty()) return;
-
-    const uint16_t ufQuestStart = fieldIndex(UF::PLAYER_QUEST_LOG_START);
-    if (ufQuestStart == 0xFFFF) return;
-
-    const uint8_t qStride = owner_.packetParsers_ ? owner_.packetParsers_->questLogStride() : 5;
-    if (qStride < 3) return;
-
-    int slot = findQuestLogSlotIndexFromServer(quest.questId);
-    if (slot < 0) return;
-
-    const uint16_t countField1 = ufQuestStart + static_cast<uint16_t>(slot) * qStride + 2;
-    const uint16_t countField2 = (qStride >= 5)
-                                     ? static_cast<uint16_t>(countField1 + 1)
-                                     : static_cast<uint16_t>(0xFFFF);
-
-    auto f1It = owner_.lastPlayerFields_.find(countField1);
-    if (f1It == owner_.lastPlayerFields_.end()) return;
-    const uint32_t packed1 = f1It->second;
-
-    uint32_t packed2 = 0;
-    if (countField2 != 0xFFFF) {
-        auto f2It = owner_.lastPlayerFields_.find(countField2);
-        if (f2It != owner_.lastPlayerFields_.end()) packed2 = f2It->second;
-    }
-
-    auto unpack6 = [](uint32_t word, int idx) -> uint8_t {
-        return static_cast<uint8_t>((word >> (idx * 6)) & 0x3F);
-    };
-    const uint8_t counts[6] = {
-        unpack6(packed1, 0), unpack6(packed1, 1),
-        unpack6(packed1, 2), unpack6(packed1, 3),
-        unpack6(packed2, 0), unpack6(packed2, 1),
-    };
-
-    // Apply kill objective counts (indices 0-3).
-    for (int i = 0; i < 4; ++i) {
-        const auto& obj = quest.killObjectives[i];
-        if (obj.npcOrGoId == 0 || obj.required == 0) continue;
-        const uint32_t entryKey = static_cast<uint32_t>(
-            obj.npcOrGoId > 0 ? obj.npcOrGoId : -obj.npcOrGoId);
-        if (counts[i] == 0 && quest.killCounts.count(entryKey)) continue;
-        quest.killCounts[entryKey] = {counts[i], obj.required};
-        LOG_DEBUG("Quest ", quest.questId, " objective[", i, "]: npcOrGo=",
-                  obj.npcOrGoId, " count=", (int)counts[i], "/", obj.required);
-    }
-
-    // Apply item objective counts (WotLK only).
-    for (int i = 0; i < 6; ++i) {
-        const auto& obj = quest.itemObjectives[i];
-        if (obj.itemId == 0 || obj.required == 0) continue;
-        if (i < 2 && qStride >= 5) {
-            uint8_t cnt = counts[4 + i];
-            if (cnt > 0) {
-                quest.itemCounts[obj.itemId] = std::max(quest.itemCounts[obj.itemId], static_cast<uint32_t>(cnt));
-            }
-        }
-        quest.requiredItemCounts.emplace(obj.itemId, obj.required);
-    }
-}
-
-void QuestHandler::clearPendingQuestAccept(uint32_t questId) {
-    pendingQuestAcceptTimeouts_.erase(questId);
-    pendingQuestAcceptNpcGuids_.erase(questId);
-}
-
-void QuestHandler::triggerQuestAcceptResync(uint32_t questId, uint64_t npcGuid, const char* reason) {
-    if (questId == 0 || !owner_.socket || owner_.state != WorldState::IN_WORLD) return;
-
-    LOG_INFO("Quest accept resync: questId=", questId, " reason=", reason ? reason : "unknown");
-    requestQuestQuery(questId, true);
-
-    if (npcGuid != 0) {
-        network::Packet qsPkt(wireOpcode(Opcode::CMSG_QUESTGIVER_STATUS_QUERY));
-        qsPkt.writeUInt64(npcGuid);
-        owner_.socket->send(qsPkt);
-
-        auto queryPkt = owner_.packetParsers_
-            ? owner_.packetParsers_->buildQueryQuestPacket(npcGuid, questId)
-            : QuestgiverQueryQuestPacket::build(npcGuid, questId);
-        owner_.socket->send(queryPkt);
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Packet handlers
-// ---------------------------------------------------------------------------
-
-void QuestHandler::handleGossipMessage(network::Packet& packet) {
-    bool ok = owner_.packetParsers_ ? owner_.packetParsers_->parseGossipMessage(packet, currentGossip_)
-                                    : GossipMessageParser::parse(packet, currentGossip_);
-    if (!ok) return;
-    if (questDetailsOpen_) return; // Don't reopen gossip while viewing quest
-    gossipWindowOpen_ = true;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("GOSSIP_SHOW", {});
-    owner_.closeVendor(); // Close vendor if gossip opens
-
-    // Classify gossip quests and update quest log + overhead NPC markers.
-    classifyGossipQuests(true);
-
-    // Play NPC greeting voice
-    if (owner_.npcGreetingCallback_ && currentGossip_.npcGuid != 0) {
-        auto entity = owner_.getEntityManager().getEntity(currentGossip_.npcGuid);
-        if (entity) {
-            glm::vec3 npcPos(entity->getX(), entity->getY(), entity->getZ());
-            owner_.npcGreetingCallback_(currentGossip_.npcGuid, npcPos);
-        }
-    }
-}
-
-void QuestHandler::handleQuestgiverQuestList(network::Packet& packet) {
-    if (!packet.hasRemaining(8)) return;
-
-    GossipMessageData data;
-    data.npcGuid = packet.readUInt64();
-    data.menuId = 0;
-    data.titleTextId = 0;
-
-    std::string header = packet.readString();
-    if (packet.hasRemaining(8)) {
-        (void)packet.readUInt32(); // emoteDelay / unk
-        (void)packet.readUInt32(); // emote / unk
-    }
-    (void)header;
-
-    // questCount is uint8 in all WoW versions for SMSG_QUESTGIVER_QUEST_LIST.
-    uint32_t questCount = 0;
-    if (packet.hasRemaining(1)) {
-        questCount = packet.readUInt8();
-    }
-
-    const bool hasQuestFlagsField = !isClassicLikeExpansion() && !isActiveExpansion("tbc");
-
-    data.quests.reserve(questCount);
-    for (uint32_t i = 0; i < questCount; ++i) {
-        if (!packet.hasRemaining(12)) break;
-        GossipQuestItem q;
-        q.questId = packet.readUInt32();
-        q.questIcon = packet.readUInt32();
-        q.questLevel = static_cast<int32_t>(packet.readUInt32());
-
-        if (hasQuestFlagsField && packet.hasRemaining(5)) {
-            q.questFlags = packet.readUInt32();
-            q.isRepeatable = packet.readUInt8();
-        } else {
-            q.questFlags = 0;
-            q.isRepeatable = 0;
-        }
-        q.title = normalizeWowTextTokens(packet.readString());
-        if (q.questId != 0) {
-            data.quests.push_back(std::move(q));
-        }
-    }
-
-    currentGossip_ = std::move(data);
-    gossipWindowOpen_ = true;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("GOSSIP_SHOW", {});
-    owner_.closeVendor();
-
-    classifyGossipQuests(false);
-
-    LOG_INFO("Questgiver quest list: npc=0x", std::hex, currentGossip_.npcGuid, std::dec,
-             " quests=", currentGossip_.quests.size());
-}
-
-// Shared quest-icon classification for gossip windows. Derives NPC quest status
-// from icon values so overhead markers stay aligned with what the NPC offers.
-// updateQuestLog: if true, also patches quest log completion state (gossip handler
-// does this because it has the freshest data; quest-list handler skips it because
-// completion updates arrive via separate packets).
-void QuestHandler::classifyGossipQuests(bool updateQuestLog) {
-    // Icon values come from the server's QUEST_STATUS enum, not a client constant,
-    // so these magic numbers are protocol-defined and stable across expansions.
-    auto isCompletable = [](uint32_t icon) { return icon == 5 || icon == 6 || icon == 10; };
-    auto isIncomplete  = [](uint32_t icon) { return icon == 3 || icon == 4; };
-    auto isAvailable   = [](uint32_t icon) { return icon == 2 || icon == 7 || icon == 8; };
-
-    bool hasAvailable = false, hasReward = false, hasIncomplete = false;
-    for (const auto& q : currentGossip_.quests) {
-        bool completable = isCompletable(q.questIcon);
-        bool incomplete  = isIncomplete(q.questIcon);
-        bool available   = isAvailable(q.questIcon);
-        hasAvailable |= available;
-        hasReward |= completable;
-        hasIncomplete |= incomplete;
-
-        if (updateQuestLog) {
-            for (auto& entry : questLog_) {
-                if (entry.questId == q.questId) {
-                    entry.complete = completable;
-                    entry.title = q.title;
-                    break;
-                }
-            }
-        }
-    }
-    if (currentGossip_.npcGuid != 0) {
-        QuestGiverStatus status = QuestGiverStatus::NONE;
-        if (hasReward) status = QuestGiverStatus::REWARD;
-        else if (hasAvailable) status = QuestGiverStatus::AVAILABLE;
-        else if (hasIncomplete) status = QuestGiverStatus::INCOMPLETE;
-        if (status != QuestGiverStatus::NONE)
-            npcQuestStatus_[currentGossip_.npcGuid] = status;
-    }
-}
-
-void QuestHandler::handleGossipComplete(network::Packet& packet) {
-    (void)packet;
-
-    // Play farewell sound before closing
-    if (owner_.npcFarewellCallback_ && currentGossip_.npcGuid != 0) {
-        auto entity = owner_.getEntityManager().getEntity(currentGossip_.npcGuid);
-        if (entity && entity->getType() == ObjectType::UNIT) {
-            glm::vec3 pos(entity->getX(), entity->getY(), entity->getZ());
-            owner_.npcFarewellCallback_(currentGossip_.npcGuid, pos);
-        }
-    }
-
-    gossipWindowOpen_ = false;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("GOSSIP_CLOSED", {});
-    currentGossip_ = GossipMessageData{};
-}
-
-void QuestHandler::handleQuestPoiQueryResponse(network::Packet& packet) {
-    // WotLK 3.3.5a SMSG_QUEST_POI_QUERY_RESPONSE format:
-    //   uint32 questCount
-    //   per quest:
-    //     uint32 questId
-    //     uint32 poiCount
-    //     per poi:
-    //       uint32 poiId
-    //       int32  objIndex      (-1 = no specific objective)
-    //       uint32 mapId
-    //       uint32 areaId
-    //       uint32 floorId
-    //       uint32 unk1
-    //       uint32 unk2
-    //       uint32 pointCount
-    //       per point: int32 x, int32 y
-    if (!packet.hasRemaining(4)) return;
-    const uint32_t questCount = packet.readUInt32();
-    for (uint32_t qi = 0; qi < questCount; ++qi) {
-        if (!packet.hasRemaining(8)) return;
-        const uint32_t questId  = packet.readUInt32();
-        const uint32_t poiCount = packet.readUInt32();
-
-        // Remove any previously added POI markers for this quest
-        gossipPois_.erase(
-            std::remove_if(gossipPois_.begin(), gossipPois_.end(),
-                [questId](const GossipPoi& p) {
-                    return p.data == questId;
-                }),
-            gossipPois_.end());
-
-        // Find the quest title for the marker label.
-        std::string questTitle;
-        for (const auto& q : questLog_) {
-            if (q.questId == questId) { questTitle = q.title; break; }
-        }
-
-        for (uint32_t pi = 0; pi < poiCount; ++pi) {
-            if (!packet.hasRemaining(28)) return;
-            packet.readUInt32();  // poiId
-            packet.readUInt32();  // objIndex (int32)
-            const uint32_t mapId    = packet.readUInt32();
-            packet.readUInt32();  // areaId
-            packet.readUInt32();  // floorId
-            packet.readUInt32();  // unk1
-            packet.readUInt32();  // unk2
-            const uint32_t pointCount = packet.readUInt32();
-            if (pointCount == 0) continue;
-            if (packet.getRemainingSize() < pointCount * 8) return;
-            float sumX = 0.0f, sumY = 0.0f;
-            for (uint32_t pt = 0; pt < pointCount; ++pt) {
-                const int32_t px = static_cast<int32_t>(packet.readUInt32());
-                const int32_t py = static_cast<int32_t>(packet.readUInt32());
-                sumX += static_cast<float>(px);
-                sumY += static_cast<float>(py);
-            }
-            // Skip POIs for maps other than the player's current map.
-            if (mapId != owner_.currentMapId_) continue;
-            GossipPoi poi;
-            poi.x    = sumX / static_cast<float>(pointCount);
-            poi.y    = sumY / static_cast<float>(pointCount);
-            poi.icon = 6;  // generic quest POI icon
-            poi.data = questId;
-            poi.name = questTitle.empty() ? "Quest objective" : questTitle;
-            LOG_DEBUG("Quest POI: questId=", questId, " mapId=", mapId,
-                      " centroid=(", poi.x, ",", poi.y, ") title=", poi.name);
-            if (gossipPois_.size() >= 200) gossipPois_.erase(gossipPois_.begin());
-            gossipPois_.push_back(std::move(poi));
-        }
-    }
-}
-
-void QuestHandler::handleQuestDetails(network::Packet& packet) {
-    QuestDetailsData data;
-    bool ok = owner_.packetParsers_ ? owner_.packetParsers_->parseQuestDetails(packet, data)
-                                    : QuestDetailsParser::parse(packet, data);
-    if (!ok) {
-        LOG_WARNING("Failed to parse SMSG_QUESTGIVER_QUEST_DETAILS");
-        return;
-    }
-    currentQuestDetails_ = data;
-    for (auto& q : questLog_) {
-        if (q.questId != data.questId) continue;
-        if (!data.title.empty() && (isPlaceholderQuestTitle(q.title) || data.title.size() >= q.title.size())) {
-            q.title = data.title;
-        }
-        if (!data.objectives.empty() && (q.objectives.empty() || data.objectives.size() > q.objectives.size())) {
-            q.objectives = data.objectives;
-        }
-        break;
-    }
-    // Pre-fetch item info for all reward items
-    for (const auto& item : data.rewardChoiceItems) owner_.queryItemInfo(item.itemId, 0);
-    for (const auto& item : data.rewardItems)       owner_.queryItemInfo(item.itemId, 0);
-    // Delay opening the window slightly to allow item queries to complete
-    questDetailsOpenTime_ = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
-    gossipWindowOpen_ = false;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("QUEST_DETAIL", {});
-}
-
-void QuestHandler::handleQuestRequestItems(network::Packet& packet) {
-    QuestRequestItemsData data;
-    if (!QuestRequestItemsParser::parse(packet, data)) {
-        LOG_WARNING("Failed to parse SMSG_QUESTGIVER_REQUEST_ITEMS");
-        return;
-    }
-    clearPendingQuestAccept(data.questId);
-
-    if (pendingTurnInRewardRequest_ &&
-        data.questId == pendingTurnInQuestId_ &&
-        data.npcGuid == pendingTurnInNpcGuid_ &&
-        data.isCompletable() &&
-        owner_.socket) {
-        auto rewardReq = QuestgiverRequestRewardPacket::build(data.npcGuid, data.questId);
-        owner_.socket->send(rewardReq);
-        pendingTurnInRewardRequest_ = false;
-    }
-
-    currentQuestRequestItems_ = data;
-    questRequestItemsOpen_ = true;
-    gossipWindowOpen_ = false;
-    questDetailsOpen_ = false;
-    questDetailsOpenTime_ = std::chrono::steady_clock::time_point{};
-
-    // Query item names for required items
-    for (const auto& item : data.requiredItems) {
-        owner_.queryItemInfo(item.itemId, 0);
-    }
-
-    // Server-authoritative turn-in requirements
-    for (auto& q : questLog_) {
-        if (q.questId != data.questId) continue;
-        q.complete = data.isCompletable();
-        q.requiredItemCounts.clear();
-
-        std::ostringstream oss;
-        if (!data.completionText.empty()) {
-            oss << data.completionText;
-            if (!data.requiredItems.empty() || data.requiredMoney > 0) oss << "\n\n";
-        }
-        if (!data.requiredItems.empty()) {
-            oss << "Required items:";
-            for (const auto& item : data.requiredItems) {
-                std::string itemLabel = "Item " + std::to_string(item.itemId);
-                if (const auto* info = owner_.getItemInfo(item.itemId)) {
-                    if (!info->name.empty()) itemLabel = info->name;
-                }
-                q.requiredItemCounts[item.itemId] = item.count;
-                oss << "\n- " << itemLabel << " x" << item.count;
-            }
-        }
-        if (data.requiredMoney > 0) {
-            if (!data.requiredItems.empty()) oss << "\n";
-            oss << "\nRequired money: " << formatCopperAmount(data.requiredMoney);
-        }
-        q.objectives = oss.str();
-        break;
-    }
-}
-
-void QuestHandler::handleQuestOfferReward(network::Packet& packet) {
-    QuestOfferRewardData data;
-    if (!QuestOfferRewardParser::parse(packet, data)) {
-        LOG_WARNING("Failed to parse SMSG_QUESTGIVER_OFFER_REWARD");
-        return;
-    }
-    clearPendingQuestAccept(data.questId);
-    LOG_INFO("Quest offer reward: questId=", data.questId, " title=\"", data.title, "\"");
-    if (pendingTurnInQuestId_ == data.questId) {
-        pendingTurnInQuestId_ = 0;
-        pendingTurnInNpcGuid_ = 0;
-        pendingTurnInRewardRequest_ = false;
-    }
-    currentQuestOfferReward_ = data;
-    questOfferRewardOpen_ = true;
-    questRequestItemsOpen_ = false;
-    gossipWindowOpen_ = false;
-    questDetailsOpen_ = false;
-    questDetailsOpenTime_ = std::chrono::steady_clock::time_point{};
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("QUEST_COMPLETE", {});
-
-    // Query item names for reward items
-    for (const auto& item : data.choiceRewards)
-        owner_.queryItemInfo(item.itemId, 0);
-    for (const auto& item : data.fixedRewards)
-        owner_.queryItemInfo(item.itemId, 0);
-}
-
-void QuestHandler::handleQuestConfirmAccept(network::Packet& packet) {
-    size_t rem = packet.getRemainingSize();
-    if (rem < 4) return;
-
-    sharedQuestId_    = packet.readUInt32();
-    sharedQuestTitle_ = packet.readString();
-    if (packet.hasRemaining(8)) {
-        sharedQuestSharerGuid_ = packet.readUInt64();
-    }
-
-    sharedQuestSharerName_.clear();
-    auto entity = owner_.getEntityManager().getEntity(sharedQuestSharerGuid_);
-    if (auto* unit = dynamic_cast<Unit*>(entity.get())) {
-        sharedQuestSharerName_ = unit->getName();
-    }
-    if (sharedQuestSharerName_.empty()) {
-        auto nit = owner_.getPlayerNameCache().find(sharedQuestSharerGuid_);
-        if (nit != owner_.getPlayerNameCache().end())
-            sharedQuestSharerName_ = nit->second;
-    }
-    if (sharedQuestSharerName_.empty()) {
-        char tmp[32];
-        std::snprintf(tmp, sizeof(tmp), "0x%llX",
-                      static_cast<unsigned long long>(sharedQuestSharerGuid_));
-        sharedQuestSharerName_ = tmp;
-    }
-
-    pendingSharedQuest_ = true;
-    owner_.addSystemChatMessage(sharedQuestSharerName_ + " has shared the quest \"" +
-                                sharedQuestTitle_ + "\" with you.");
-    LOG_INFO("SMSG_QUEST_CONFIRM_ACCEPT: questId=", sharedQuestId_,
-             " title=", sharedQuestTitle_, " sharer=", sharedQuestSharerName_);
-}
-
-} // namespace game
-} // namespace wowee
diff --git a/src/game/social_handler.cpp b/src/game/social_handler.cpp
deleted file mode 100644
index 230bb689..00000000
--- a/src/game/social_handler.cpp
+++ /dev/null
@@ -1,2743 +0,0 @@
-#include "game/social_handler.hpp"
-#include "game/game_handler.hpp"
-#include "game/game_utils.hpp"
-#include "game/entity.hpp"
-#include "game/packet_parsers.hpp"
-#include "game/update_field_table.hpp"
-#include "game/opcode_table.hpp"
-#include "audio/audio_coordinator.hpp"
-#include "audio/ui_sound_manager.hpp"
-#include "network/world_socket.hpp"
-#include "rendering/renderer.hpp"
-#include "core/logger.hpp"
-#include "core/application.hpp"
-#include <algorithm>
-#include <cstdio>
-#include <cmath>
-
-namespace wowee {
-namespace game {
-
-
-
-
-// LFG join result codes from LFGJoinResult enum (WotLK 3.3.5a).
-// Case 0 = success (no error message needed), returns nullptr so the caller
-// knows not to display an error string.
-static const char* lfgJoinResultString(uint8_t result) {
-    switch (result) {
-        case 0:  return nullptr;  // LFG_JOIN_OK
-        case 1:  return "Role check failed.";
-        case 2:  return "No LFG slots available for your group.";
-        case 3:  return "No LFG object found.";
-        case 4:  return "No slots available (player).";
-        case 5:  return "No slots available (party).";
-        case 6:  return "Dungeon requirements not met by all members.";
-        case 7:  return "Party members are from different realms.";
-        case 8:  return "Not all members are present.";
-        case 9:  return "Get info timeout.";
-        case 10: return "Invalid dungeon slot.";
-        case 11: return "You are marked as a deserter.";
-        case 12: return "A party member is marked as a deserter.";
-        case 13: return "You are on a random dungeon cooldown.";
-        case 14: return "A party member is on a random dungeon cooldown.";
-        case 15: return "Cannot join dungeon finder.";  // LFG_JOIN_INTERNAL_ERROR
-        case 16: return "No spec/role available.";
-        default: return "Cannot join dungeon finder.";
-    }
-}
-
-static const char* lfgTeleportDeniedString(uint8_t reason) {
-    switch (reason) {
-        case 0:  return "You are not in a LFG group.";
-        case 1:  return "You are not in the dungeon.";
-        case 2:  return "You have a summon pending.";
-        case 3:  return "You are dead.";
-        case 4:  return "You have Deserter.";
-        case 5:  return "You do not meet the requirements.";
-        default: return "Teleport to dungeon denied.";
-    }
-}
-
-static const std::string kEmptyString;
-
-SocialHandler::SocialHandler(GameHandler& owner)
-    : owner_(owner) {}
-
-// ============================================================
-// registerOpcodes
-// ============================================================
-
-void SocialHandler::registerOpcodes(DispatchTable& table) {
-    // ---- Player info queries / social ----
-    table[Opcode::SMSG_QUERY_TIME_RESPONSE] = [this](network::Packet& packet) {
-        if (owner_.getState() == WorldState::IN_WORLD) handleQueryTimeResponse(packet);
-    };
-    table[Opcode::SMSG_PLAYED_TIME] = [this](network::Packet& packet) {
-        if (owner_.getState() == WorldState::IN_WORLD) handlePlayedTime(packet);
-    };
-    table[Opcode::SMSG_WHO] = [this](network::Packet& packet) {
-        if (owner_.getState() == WorldState::IN_WORLD) handleWho(packet);
-    };
-    table[Opcode::SMSG_WHOIS] = [this](network::Packet& packet) {
-        if (packet.getReadPos() < packet.getSize()) {
-            std::string whoisText = packet.readString();
-            if (!whoisText.empty()) {
-                std::string line;
-                for (char c : whoisText) {
-                    if (c == '\n') { if (!line.empty()) owner_.addSystemChatMessage("[Whois] " + line); line.clear(); }
-                    else line += c;
-                }
-                if (!line.empty()) owner_.addSystemChatMessage("[Whois] " + line);
-                LOG_INFO("SMSG_WHOIS: ", whoisText);
-            }
-        }
-    };
-    table[Opcode::SMSG_FRIEND_STATUS] = [this](network::Packet& packet) {
-        if (owner_.getState() == WorldState::IN_WORLD) handleFriendStatus(packet);
-    };
-    table[Opcode::SMSG_CONTACT_LIST] = [this](network::Packet& packet) { handleContactList(packet); };
-    table[Opcode::SMSG_FRIEND_LIST] = [this](network::Packet& packet) { handleFriendList(packet); };
-    table[Opcode::SMSG_IGNORE_LIST] = [this](network::Packet& packet) {
-        // Format: uint8 count + count × uint64 guid (no name strings in packet).
-        // Names are resolved via SMSG_NAME_QUERY_RESPONSE after the list arrives.
-        if (!packet.hasRemaining(1)) return;
-        uint8_t ignCount = packet.readUInt8();
-        owner_.ignoreListGuids_.clear();
-        for (uint8_t i = 0; i < ignCount; ++i) {
-            if (!packet.hasRemaining(8)) break;
-            uint64_t ignGuid = packet.readUInt64();
-            if (ignGuid != 0) {
-                owner_.ignoreListGuids_.insert(ignGuid);
-                // Query name so UI can display it later
-                owner_.queryPlayerName(ignGuid);
-            }
-        }
-        LOG_DEBUG("SMSG_IGNORE_LIST: loaded ", (int)ignCount, " ignored players");
-    };
-    table[Opcode::MSG_RANDOM_ROLL] = [this](network::Packet& packet) {
-        if (owner_.getState() == WorldState::IN_WORLD) handleRandomRoll(packet);
-    };
-
-    // ---- Logout ----
-    table[Opcode::SMSG_LOGOUT_RESPONSE] = [this](network::Packet& packet) { handleLogoutResponse(packet); };
-    table[Opcode::SMSG_LOGOUT_COMPLETE] = [this](network::Packet& packet) { handleLogoutComplete(packet); };
-
-    // ---- Inspect ----
-    table[Opcode::SMSG_INSPECT_TALENT] = [this](network::Packet& packet) { handleInspectResults(packet); };
-    table[Opcode::SMSG_INSPECT_RESULTS_UPDATE] = [this](network::Packet& packet) { handleInspectResults(packet); };
-
-    // ---- Group ----
-    table[Opcode::SMSG_GROUP_INVITE] = [this](network::Packet& packet) { handleGroupInvite(packet); };
-    table[Opcode::SMSG_GROUP_DECLINE] = [this](network::Packet& packet) { handleGroupDecline(packet); };
-    table[Opcode::SMSG_GROUP_LIST] = [this](network::Packet& packet) { handleGroupList(packet); };
-    table[Opcode::SMSG_GROUP_DESTROYED] = [this](network::Packet& /*packet*/) {
-        partyData.members.clear();
-        partyData.memberCount = 0;
-        partyData.leaderGuid = 0;
-        owner_.addUIError("Your party has been disbanded.");
-        owner_.addSystemChatMessage("Your party has been disbanded.");
-        if (owner_.addonEventCallback_) {
-            owner_.addonEventCallback_("GROUP_ROSTER_UPDATE", {});
-            owner_.addonEventCallback_("PARTY_MEMBERS_CHANGED", {});
-        }
-    };
-    table[Opcode::SMSG_GROUP_CANCEL] = [this](network::Packet& /*packet*/) {
-        owner_.addSystemChatMessage("Group invite cancelled.");
-    };
-    table[Opcode::SMSG_GROUP_UNINVITE] = [this](network::Packet& packet) { handleGroupUninvite(packet); };
-    table[Opcode::SMSG_PARTY_COMMAND_RESULT] = [this](network::Packet& packet) { handlePartyCommandResult(packet); };
-    table[Opcode::SMSG_PARTY_MEMBER_STATS] = [this](network::Packet& packet) { handlePartyMemberStats(packet, false); };
-    table[Opcode::SMSG_PARTY_MEMBER_STATS_FULL] = [this](network::Packet& packet) { handlePartyMemberStats(packet, true); };
-
-    // ---- Ready check ----
-    table[Opcode::MSG_RAID_READY_CHECK] = [this](network::Packet& packet) {
-        pendingReadyCheck_ = true;
-        readyCheckReadyCount_ = 0;
-        readyCheckNotReadyCount_ = 0;
-        readyCheckInitiator_.clear();
-        readyCheckResults_.clear();
-        if (packet.hasRemaining(8)) {
-            uint64_t initiatorGuid = packet.readUInt64();
-            auto entity = owner_.getEntityManager().getEntity(initiatorGuid);
-            if (auto* unit = dynamic_cast<Unit*>(entity.get()))
-                readyCheckInitiator_ = unit->getName();
-        }
-        if (readyCheckInitiator_.empty() && partyData.leaderGuid != 0) {
-            for (const auto& member : partyData.members) {
-                if (member.guid == partyData.leaderGuid) { readyCheckInitiator_ = member.name; break; }
-            }
-        }
-        owner_.addSystemChatMessage(readyCheckInitiator_.empty()
-            ? "Ready check initiated!"
-            : readyCheckInitiator_ + " initiated a ready check!");
-        if (owner_.addonEventCallback_)
-            owner_.addonEventCallback_("READY_CHECK", {readyCheckInitiator_});
-    };
-    table[Opcode::MSG_RAID_READY_CHECK_CONFIRM] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(9)) { packet.skipAll(); return; }
-        uint64_t respGuid = packet.readUInt64();
-        uint8_t  isReady  = packet.readUInt8();
-        if (isReady) ++readyCheckReadyCount_; else ++readyCheckNotReadyCount_;
-        auto nit = owner_.getPlayerNameCache().find(respGuid);
-        std::string rname;
-        if (nit != owner_.getPlayerNameCache().end()) rname = nit->second;
-        else {
-            // Only cast to Unit if the entity actually is one — a raw
-            // static_pointer_cast on a GameObject would be undefined behavior.
-            auto ent = owner_.getEntityManager().getEntity(respGuid);
-            if (ent && (ent->getType() == ObjectType::UNIT || ent->getType() == ObjectType::PLAYER))
-                rname = std::static_pointer_cast<game::Unit>(ent)->getName();
-        }
-        if (!rname.empty()) {
-            bool found = false;
-            for (auto& r : readyCheckResults_) {
-                if (r.name == rname) { r.ready = (isReady != 0); found = true; break; }
-            }
-            if (!found) readyCheckResults_.push_back({ rname, isReady != 0 });
-            char rbuf[128];
-            std::snprintf(rbuf, sizeof(rbuf), "%s is %s.", rname.c_str(), isReady ? "Ready" : "Not Ready");
-            owner_.addSystemChatMessage(rbuf);
-        }
-        if (owner_.addonEventCallback_) {
-            char guidBuf[32];
-            snprintf(guidBuf, sizeof(guidBuf), "0x%016llX", (unsigned long long)respGuid);
-            owner_.addonEventCallback_("READY_CHECK_CONFIRM", {guidBuf, isReady ? "1" : "0"});
-        }
-    };
-    table[Opcode::MSG_RAID_READY_CHECK_FINISHED] = [this](network::Packet& /*packet*/) {
-        char fbuf[128];
-        std::snprintf(fbuf, sizeof(fbuf), "Ready check complete: %u ready, %u not ready.",
-                     readyCheckReadyCount_, readyCheckNotReadyCount_);
-        owner_.addSystemChatMessage(fbuf);
-        pendingReadyCheck_ = false;
-        readyCheckReadyCount_ = 0;
-        readyCheckNotReadyCount_ = 0;
-        readyCheckResults_.clear();
-        if (owner_.addonEventCallback_) owner_.addonEventCallback_("READY_CHECK_FINISHED", {});
-    };
-    table[Opcode::SMSG_RAID_INSTANCE_INFO] = [this](network::Packet& packet) { handleRaidInstanceInfo(packet); };
-
-    // ---- Duels ----
-    table[Opcode::SMSG_DUEL_REQUESTED] = [this](network::Packet& packet) { handleDuelRequested(packet); };
-    table[Opcode::SMSG_DUEL_COMPLETE] = [this](network::Packet& packet) { handleDuelComplete(packet); };
-    table[Opcode::SMSG_DUEL_WINNER] = [this](network::Packet& packet) { handleDuelWinner(packet); };
-    table[Opcode::SMSG_DUEL_OUTOFBOUNDS] = [this](network::Packet& /*packet*/) {
-        owner_.addUIError("You are out of the duel area!");
-        owner_.addSystemChatMessage("You are out of the duel area!");
-    };
-    table[Opcode::SMSG_DUEL_INBOUNDS] = [this](network::Packet& /*packet*/) {};
-    table[Opcode::SMSG_DUEL_COUNTDOWN] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t ms = packet.readUInt32();
-            duelCountdownMs_ = (ms > 0 && ms <= 30000) ? ms : 3000;
-            duelCountdownStartedAt_ = std::chrono::steady_clock::now();
-        }
-    };
-    table[Opcode::SMSG_PARTYKILLLOG] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(16)) return;
-        uint64_t killerGuid = packet.readUInt64();
-        uint64_t victimGuid = packet.readUInt64();
-        auto nameFor = [this](uint64_t g) -> std::string {
-            auto nit = owner_.getPlayerNameCache().find(g);
-            if (nit != owner_.getPlayerNameCache().end()) return nit->second;
-            auto ent = owner_.getEntityManager().getEntity(g);
-            if (ent && (ent->getType() == game::ObjectType::UNIT ||
-                        ent->getType() == game::ObjectType::PLAYER))
-                return std::static_pointer_cast<game::Unit>(ent)->getName();
-            return {};
-        };
-        std::string killerName = nameFor(killerGuid);
-        std::string victimName = nameFor(victimGuid);
-        if (!killerName.empty() && !victimName.empty()) {
-            char buf[256];
-            std::snprintf(buf, sizeof(buf), "%s killed %s.", killerName.c_str(), victimName.c_str());
-            owner_.addSystemChatMessage(buf);
-        }
-    };
-
-    // ---- Guild ----
-    table[Opcode::SMSG_GUILD_INFO] = [this](network::Packet& packet) { handleGuildInfo(packet); };
-    table[Opcode::SMSG_GUILD_ROSTER] = [this](network::Packet& packet) { handleGuildRoster(packet); };
-    table[Opcode::SMSG_GUILD_QUERY_RESPONSE] = [this](network::Packet& packet) { handleGuildQueryResponse(packet); };
-    table[Opcode::SMSG_GUILD_EVENT] = [this](network::Packet& packet) { handleGuildEvent(packet); };
-    table[Opcode::SMSG_GUILD_INVITE] = [this](network::Packet& packet) { handleGuildInvite(packet); };
-    table[Opcode::SMSG_GUILD_COMMAND_RESULT] = [this](network::Packet& packet) { handleGuildCommandResult(packet); };
-    table[Opcode::SMSG_PETITION_SHOWLIST] = [this](network::Packet& packet) { handlePetitionShowlist(packet); };
-    table[Opcode::SMSG_TURN_IN_PETITION_RESULTS] = [this](network::Packet& packet) { handleTurnInPetitionResults(packet); };
-    table[Opcode::SMSG_OFFER_PETITION_ERROR] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t err = packet.readUInt32();
-            if (err == 1) owner_.addSystemChatMessage("Player is already in a guild.");
-            else if (err == 2) owner_.addSystemChatMessage("Player already has a petition.");
-            else owner_.addSystemChatMessage("Cannot offer petition to that player.");
-        }
-    };
-    table[Opcode::SMSG_PETITION_QUERY_RESPONSE] = [this](network::Packet& packet) { handlePetitionQueryResponse(packet); };
-    table[Opcode::SMSG_PETITION_SHOW_SIGNATURES] = [this](network::Packet& packet) { handlePetitionShowSignatures(packet); };
-    table[Opcode::SMSG_PETITION_SIGN_RESULTS] = [this](network::Packet& packet) { handlePetitionSignResults(packet); };
-
-    // ---- Battlefield / BG ----
-    table[Opcode::SMSG_BATTLEFIELD_STATUS] = [this](network::Packet& packet) { handleBattlefieldStatus(packet); };
-    table[Opcode::SMSG_BATTLEFIELD_LIST] = [this](network::Packet& packet) { handleBattlefieldList(packet); };
-    table[Opcode::SMSG_BATTLEFIELD_PORT_DENIED] = [this](network::Packet& /*packet*/) {
-        owner_.addUIError("Battlefield port denied.");
-        owner_.addSystemChatMessage("Battlefield port denied.");
-    };
-    table[Opcode::MSG_BATTLEGROUND_PLAYER_POSITIONS] = [this](network::Packet& packet) {
-        bgPlayerPositions_.clear();
-        for (int grp = 0; grp < 2; ++grp) {
-            if (!packet.hasRemaining(4)) break;
-            uint32_t count = packet.readUInt32();
-            for (uint32_t i = 0; i < count && packet.getRemainingSize() >= 16; ++i) {
-                BgPlayerPosition pos;
-                pos.guid = packet.readUInt64();
-                pos.wowX = packet.readFloat();
-                pos.wowY = packet.readFloat();
-                pos.group = grp;
-                bgPlayerPositions_.push_back(pos);
-            }
-        }
-    };
-    table[Opcode::SMSG_REMOVED_FROM_PVP_QUEUE] = [this](network::Packet& /*packet*/) {
-        owner_.addSystemChatMessage("You have been removed from the PvP queue.");
-    };
-    table[Opcode::SMSG_GROUP_JOINED_BATTLEGROUND] = [this](network::Packet& /*packet*/) {
-        owner_.addSystemChatMessage("Your group has joined the battleground.");
-    };
-    table[Opcode::SMSG_JOINED_BATTLEGROUND_QUEUE] = [this](network::Packet& /*packet*/) {
-        owner_.addSystemChatMessage("You have joined the battleground queue.");
-    };
-    table[Opcode::SMSG_BATTLEGROUND_PLAYER_JOINED] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(8)) {
-            uint64_t guid = packet.readUInt64();
-            auto it = owner_.getPlayerNameCache().find(guid);
-            if (it != owner_.getPlayerNameCache().end() && !it->second.empty())
-                owner_.addSystemChatMessage(it->second + " has entered the battleground.");
-        }
-    };
-    table[Opcode::SMSG_BATTLEGROUND_PLAYER_LEFT] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(8)) {
-            uint64_t guid = packet.readUInt64();
-            auto it = owner_.getPlayerNameCache().find(guid);
-            if (it != owner_.getPlayerNameCache().end() && !it->second.empty())
-                owner_.addSystemChatMessage(it->second + " has left the battleground.");
-        }
-    };
-
-    // ---- Instance ----
-    for (auto op : { Opcode::SMSG_INSTANCE_DIFFICULTY, Opcode::MSG_SET_DUNGEON_DIFFICULTY }) {
-        table[op] = [this](network::Packet& packet) { handleInstanceDifficulty(packet); };
-    }
-
-    // ---- Guild / RAF / PvP AFK (moved from GameHandler) ----
-    table[Opcode::SMSG_GUILD_DECLINE] = [this](network::Packet& packet) {
-        if (packet.hasData()) {
-            std::string name = packet.readString();
-            owner_.addSystemChatMessage(name + " declined your guild invitation.");
-        }
-    };
-    table[Opcode::SMSG_REFER_A_FRIEND_EXPIRED] = [this](network::Packet& packet) {
-        owner_.addSystemChatMessage("Your Recruit-A-Friend link has expired.");
-        packet.skipAll();
-    };
-    table[Opcode::SMSG_REFER_A_FRIEND_FAILURE] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(4)) {
-            uint32_t reason = packet.readUInt32();
-            static const char* kRafErrors[] = {
-                "Not eligible",            // 0
-                "Target not eligible",     // 1
-                "Too many referrals",      // 2
-                "Wrong faction",           // 3
-                "Not a recruit",           // 4
-                "Recruit requirements not met", // 5
-                "Level above requirement", // 6
-                "Friend needs account upgrade", // 7
-            };
-            const char* msg = (reason < 8) ? kRafErrors[reason]
-                                           : "Recruit-A-Friend failed.";
-            owner_.addSystemChatMessage(std::string("Recruit-A-Friend: ") + msg);
-        }
-        packet.skipAll();
-    };
-    table[Opcode::SMSG_REPORT_PVP_AFK_RESULT] = [this](network::Packet& packet) {
-        if (packet.hasRemaining(1)) {
-            uint8_t result = packet.readUInt8();
-            if (result == 0)
-                owner_.addSystemChatMessage("AFK report submitted.");
-            else
-                owner_.addSystemChatMessage("Cannot report that player as AFK right now.");
-        }
-        packet.skipAll();
-    };
-    table[Opcode::SMSG_INSTANCE_SAVE_CREATED] = [this](network::Packet& /*packet*/) {
-        owner_.addSystemChatMessage("You are now saved to this instance.");
-    };
-    table[Opcode::SMSG_RAID_INSTANCE_MESSAGE] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(12)) return;
-        uint32_t msgType = packet.readUInt32();
-        uint32_t mapId   = packet.readUInt32();
-        packet.readUInt32(); // diff
-        std::string mapLabel = owner_.getMapName(mapId);
-        if (mapLabel.empty()) mapLabel = "instance #" + std::to_string(mapId);
-        if (msgType == 1 && packet.hasRemaining(4)) {
-            uint32_t timeLeft = packet.readUInt32();
-            owner_.addSystemChatMessage(mapLabel + " will reset in " + std::to_string(timeLeft / 60) + " minute(s).");
-        } else if (msgType == 2) {
-            owner_.addSystemChatMessage("You have been saved to " + mapLabel + ".");
-        } else if (msgType == 3) {
-            owner_.addSystemChatMessage("Welcome to " + mapLabel + ".");
-        }
-    };
-    table[Opcode::SMSG_INSTANCE_RESET] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(4)) return;
-        uint32_t mapId = packet.readUInt32();
-        auto it = std::remove_if(instanceLockouts_.begin(), instanceLockouts_.end(),
-            [mapId](const InstanceLockout& lo){ return lo.mapId == mapId; });
-        instanceLockouts_.erase(it, instanceLockouts_.end());
-        std::string mapLabel = owner_.getMapName(mapId);
-        if (mapLabel.empty()) mapLabel = "instance #" + std::to_string(mapId);
-        owner_.addSystemChatMessage(mapLabel + " has been reset.");
-    };
-    table[Opcode::SMSG_INSTANCE_RESET_FAILED] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(8)) return;
-        uint32_t mapId  = packet.readUInt32();
-        uint32_t reason = packet.readUInt32();
-        static const char* resetFailReasons[] = {
-            "Not max level.", "Offline party members.", "Party members inside.",
-            "Party members changing zone.", "Heroic difficulty only."
-        };
-        const char* reasonMsg = (reason < 5) ? resetFailReasons[reason] : "Unknown reason.";
-        std::string mapLabel = owner_.getMapName(mapId);
-        if (mapLabel.empty()) mapLabel = "instance #" + std::to_string(mapId);
-        owner_.addUIError("Cannot reset " + mapLabel + ": " + reasonMsg);
-        owner_.addSystemChatMessage("Cannot reset " + mapLabel + ": " + reasonMsg);
-    };
-    table[Opcode::SMSG_INSTANCE_LOCK_WARNING_QUERY] = [this](network::Packet& packet) {
-        if (!owner_.socket || !packet.hasRemaining(17)) return;
-        uint32_t ilMapId    = packet.readUInt32();
-        uint32_t ilDiff     = packet.readUInt32();
-        uint32_t ilTimeLeft = packet.readUInt32();
-        packet.readUInt32(); // unk
-        uint8_t  ilLocked   = packet.readUInt8();
-        std::string ilName = owner_.getMapName(ilMapId);
-        if (ilName.empty()) ilName = "instance #" + std::to_string(ilMapId);
-        static const char* kDiff[] = {"Normal","Heroic","25-Man","25-Man Heroic"};
-        std::string ilMsg = "Entering " + ilName;
-        if (ilDiff < 4) ilMsg += std::string(" (") + kDiff[ilDiff] + ")";
-        if (ilLocked && ilTimeLeft > 0)
-            ilMsg += " — " + std::to_string(ilTimeLeft / 60) + " min remaining.";
-        else
-            ilMsg += ".";
-        owner_.addSystemChatMessage(ilMsg);
-        network::Packet resp(wireOpcode(Opcode::CMSG_INSTANCE_LOCK_RESPONSE));
-        resp.writeUInt8(1);
-        owner_.socket->send(resp);
-    };
-
-    // ---- LFG ----
-    table[Opcode::SMSG_LFG_JOIN_RESULT] = [this](network::Packet& packet) { handleLfgJoinResult(packet); };
-    table[Opcode::SMSG_LFG_QUEUE_STATUS] = [this](network::Packet& packet) { handleLfgQueueStatus(packet); };
-    table[Opcode::SMSG_LFG_PROPOSAL_UPDATE] = [this](network::Packet& packet) { handleLfgProposalUpdate(packet); };
-    table[Opcode::SMSG_LFG_ROLE_CHECK_UPDATE] = [this](network::Packet& packet) { handleLfgRoleCheckUpdate(packet); };
-    for (auto op : { Opcode::SMSG_LFG_UPDATE_PLAYER, Opcode::SMSG_LFG_UPDATE_PARTY }) {
-        table[op] = [this](network::Packet& packet) { handleLfgUpdatePlayer(packet); };
-    }
-    table[Opcode::SMSG_LFG_PLAYER_REWARD] = [this](network::Packet& packet) { handleLfgPlayerReward(packet); };
-    table[Opcode::SMSG_LFG_BOOT_PROPOSAL_UPDATE] = [this](network::Packet& packet) { handleLfgBootProposalUpdate(packet); };
-    table[Opcode::SMSG_LFG_TELEPORT_DENIED] = [this](network::Packet& packet) { handleLfgTeleportDenied(packet); };
-    table[Opcode::SMSG_LFG_DISABLED] = [this](network::Packet& /*packet*/) {
-        owner_.addSystemChatMessage("The Dungeon Finder is currently disabled.");
-    };
-    table[Opcode::SMSG_LFG_OFFER_CONTINUE] = [this](network::Packet& /*packet*/) {
-        owner_.addSystemChatMessage("Dungeon Finder: You may continue your dungeon.");
-    };
-    table[Opcode::SMSG_LFG_ROLE_CHOSEN] = [this](network::Packet& packet) {
-        if (!packet.hasRemaining(13)) { packet.skipAll(); return; }
-        uint64_t roleGuid = packet.readUInt64();
-        uint8_t  ready    = packet.readUInt8();
-        uint32_t roles    = packet.readUInt32();
-        std::string roleName;
-        if (roles & 0x02) roleName += "Tank ";
-        if (roles & 0x04) roleName += "Healer ";
-        if (roles & 0x08) roleName += "DPS ";
-        if (roleName.empty()) roleName = "None";
-        std::string pName = "A player";
-        if (auto e = owner_.getEntityManager().getEntity(roleGuid))
-            if (auto u = std::dynamic_pointer_cast<Unit>(e))
-                pName = u->getName();
-        if (ready) owner_.addSystemChatMessage(pName + " has chosen: " + roleName);
-        packet.skipAll();
-    };
-    for (auto op : { Opcode::SMSG_LFG_UPDATE_SEARCH, Opcode::SMSG_UPDATE_LFG_LIST,
-                     Opcode::SMSG_LFG_PLAYER_INFO, Opcode::SMSG_LFG_PARTY_INFO }) {
-        table[op] = [](network::Packet& packet) { packet.skipAll(); };
-    }
-    table[Opcode::SMSG_OPEN_LFG_DUNGEON_FINDER] = [this](network::Packet& packet) {
-        packet.skipAll();
-        if (owner_.openLfgCallback_) owner_.openLfgCallback_();
-    };
-
-    // ---- Arena ----
-    table[Opcode::SMSG_ARENA_TEAM_COMMAND_RESULT] = [this](network::Packet& packet) { handleArenaTeamCommandResult(packet); };
-    table[Opcode::SMSG_ARENA_TEAM_QUERY_RESPONSE] = [this](network::Packet& packet) { handleArenaTeamQueryResponse(packet); };
-    table[Opcode::SMSG_ARENA_TEAM_ROSTER] = [this](network::Packet& packet) { handleArenaTeamRoster(packet); };
-    table[Opcode::SMSG_ARENA_TEAM_INVITE] = [this](network::Packet& packet) { handleArenaTeamInvite(packet); };
-    table[Opcode::SMSG_ARENA_TEAM_EVENT] = [this](network::Packet& packet) { handleArenaTeamEvent(packet); };
-    table[Opcode::SMSG_ARENA_TEAM_STATS] = [this](network::Packet& packet) { handleArenaTeamStats(packet); };
-    table[Opcode::SMSG_ARENA_ERROR] = [this](network::Packet& packet) { handleArenaError(packet); };
-    table[Opcode::MSG_PVP_LOG_DATA] = [this](network::Packet& packet) { handlePvpLogData(packet); };
-
-    // ---- Factions / group leader ----
-    table[Opcode::SMSG_INITIALIZE_FACTIONS] = [this](network::Packet& p) { handleInitializeFactions(p); };
-    table[Opcode::SMSG_SET_FACTION_STANDING] = [this](network::Packet& p) { handleSetFactionStanding(p); };
-    table[Opcode::SMSG_SET_FACTION_ATWAR] = [this](network::Packet& p) { handleSetFactionAtWar(p); };
-    table[Opcode::SMSG_SET_FACTION_VISIBLE] = [this](network::Packet& p) { handleSetFactionVisible(p); };
-    table[Opcode::SMSG_GROUP_SET_LEADER] = [this](network::Packet& p) { handleGroupSetLeader(p); };
-}
-
-// ============================================================
-// Non-inline accessors requiring GameHandler
-// ============================================================
-
-std::string SocialHandler::getWhoAreaName(uint32_t zoneId) const {
-    return owner_.getAreaName(zoneId);
-}
-
-std::string SocialHandler::getCurrentLfgDungeonName() const {
-    return owner_.getLfgDungeonName(lfgDungeonId_);
-}
-
-bool SocialHandler::isInGuild() const {
-    if (!guildName_.empty()) return true;
-    const Character* ch = owner_.getActiveCharacter();
-    return ch && ch->hasGuild();
-}
-
-uint32_t SocialHandler::getEntityGuildId(uint64_t guid) const {
-    auto entity = owner_.getEntityManager().getEntity(guid);
-    if (!entity || entity->getType() != ObjectType::PLAYER) return 0;
-    const uint16_t ufUnitEnd = fieldIndex(UF::UNIT_END);
-    if (ufUnitEnd == 0xFFFF) return 0;
-    return entity->getField(ufUnitEnd + 3);
-}
-
-const std::string& SocialHandler::lookupGuildName(uint32_t guildId) {
-    if (guildId == 0) return kEmptyString;
-    auto it = guildNameCache_.find(guildId);
-    if (it != guildNameCache_.end()) return it->second;
-    if (pendingGuildNameQueries_.insert(guildId).second) {
-        queryGuildInfo(guildId);
-    }
-    return kEmptyString;
-}
-
-// ============================================================
-// Inspection
-// ============================================================
-
-void SocialHandler::inspectTarget() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) {
-        LOG_WARNING("Cannot inspect: not in world or not connected");
-        return;
-    }
-    if (owner_.targetGuid == 0) {
-        owner_.addSystemChatMessage("You must target a player to inspect.");
-        return;
-    }
-    auto target = owner_.getTarget();
-    if (!target || target->getType() != ObjectType::PLAYER) {
-        owner_.addSystemChatMessage("You can only inspect players.");
-        return;
-    }
-    auto packet = InspectPacket::build(owner_.targetGuid);
-    owner_.socket->send(packet);
-    if (isActiveExpansion("wotlk")) {
-        auto achPkt = QueryInspectAchievementsPacket::build(owner_.targetGuid);
-        owner_.socket->send(achPkt);
-    }
-    auto player = std::static_pointer_cast<Player>(target);
-    std::string name = player->getName().empty() ? "Target" : player->getName();
-    owner_.addSystemChatMessage("Inspecting " + name + "...");
-    LOG_INFO("Sent inspect request for player: ", name, " (GUID: 0x", std::hex, owner_.targetGuid, std::dec, ")");
-}
-
-void SocialHandler::handleInspectResults(network::Packet& packet) {
-    if (!packet.hasRemaining(1)) return;
-    uint8_t talentType = packet.readUInt8();
-
-    if (talentType == 0) {
-        // Own talent info
-        if (!packet.hasRemaining(6)) {
-            LOG_DEBUG("SMSG_TALENTS_INFO type=0: too short");
-            return;
-        }
-        uint32_t unspentTalents    = packet.readUInt32();
-        uint8_t  talentGroupCount  = packet.readUInt8();
-        uint8_t  activeTalentGroup = packet.readUInt8();
-        if (activeTalentGroup > 1) activeTalentGroup = 0;
-        owner_.activeTalentSpec_ = activeTalentGroup;
-        for (uint8_t g = 0; g < talentGroupCount && g < 2; ++g) {
-            if (!packet.hasRemaining(1)) break;
-            uint8_t talentCount = packet.readUInt8();
-            owner_.learnedTalents_[g].clear();
-            for (uint8_t t = 0; t < talentCount; ++t) {
-                if (!packet.hasRemaining(5)) break;
-                uint32_t talentId = packet.readUInt32();
-                uint8_t  rank     = packet.readUInt8();
-                owner_.learnedTalents_[g][talentId] = rank + 1u;
-            }
-            if (!packet.hasRemaining(1)) break;
-            owner_.learnedGlyphs_[g].fill(0);
-            uint8_t glyphCount = packet.readUInt8();
-            for (uint8_t gl = 0; gl < glyphCount; ++gl) {
-                if (!packet.hasRemaining(2)) break;
-                uint16_t glyphId = packet.readUInt16();
-                if (gl < GameHandler::MAX_GLYPH_SLOTS) owner_.learnedGlyphs_[g][gl] = glyphId;
-            }
-        }
-        owner_.unspentTalentPoints_[activeTalentGroup] = static_cast<uint8_t>(
-            unspentTalents > 255 ? 255 : unspentTalents);
-        if (!owner_.talentsInitialized_) {
-            owner_.talentsInitialized_ = true;
-            if (unspentTalents > 0) {
-                owner_.addSystemChatMessage("You have " + std::to_string(unspentTalents)
-                    + " unspent talent point" + (unspentTalents != 1 ? "s" : "") + ".");
-            }
-        }
-        LOG_INFO("SMSG_TALENTS_INFO type=0: unspent=", unspentTalents,
-                 " groups=", (int)talentGroupCount, " active=", (int)activeTalentGroup,
-                 " learned=", owner_.learnedTalents_[activeTalentGroup].size());
-        return;
-    }
-
-    // talentType == 1: inspect result
-    const bool talentTbc = isClassicLikeExpansion() || isActiveExpansion("tbc");
-    if (packet.getRemainingSize() < (talentTbc ? 8u : 2u)) return;
-    uint64_t guid = talentTbc
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (guid == 0) return;
-
-    size_t bytesLeft = packet.getRemainingSize();
-    if (bytesLeft < 6) {
-        LOG_WARNING("SMSG_TALENTS_INFO: too short after guid, ", bytesLeft, " bytes");
-        auto entity = owner_.getEntityManager().getEntity(guid);
-        std::string name = "Target";
-        if (entity) {
-            auto player = std::dynamic_pointer_cast<Player>(entity);
-            if (player && !player->getName().empty()) name = player->getName();
-        }
-        owner_.addSystemChatMessage("Inspecting " + name + " (no talent data available).");
-        return;
-    }
-
-    uint32_t unspentTalents = packet.readUInt32();
-    uint8_t talentGroupCount = packet.readUInt8();
-    uint8_t activeTalentGroup = packet.readUInt8();
-
-    auto entity = owner_.getEntityManager().getEntity(guid);
-    std::string playerName = "Target";
-    if (entity) {
-        auto player = std::dynamic_pointer_cast<Player>(entity);
-        if (player && !player->getName().empty()) playerName = player->getName();
-    }
-
-    uint32_t totalTalents = 0;
-    for (uint8_t g = 0; g < talentGroupCount && g < 2; ++g) {
-        bytesLeft = packet.getRemainingSize();
-        if (bytesLeft < 1) break;
-        uint8_t talentCount = packet.readUInt8();
-        for (uint8_t t = 0; t < talentCount; ++t) {
-            bytesLeft = packet.getRemainingSize();
-            if (bytesLeft < 5) break;
-            packet.readUInt32();
-            packet.readUInt8();
-            totalTalents++;
-        }
-        bytesLeft = packet.getRemainingSize();
-        if (bytesLeft < 1) break;
-        uint8_t glyphCount = packet.readUInt8();
-        for (uint8_t gl = 0; gl < glyphCount; ++gl) {
-            bytesLeft = packet.getRemainingSize();
-            if (bytesLeft < 2) break;
-            packet.readUInt16();
-        }
-    }
-
-    std::array<uint16_t, 19> enchantIds{};
-    bytesLeft = packet.getRemainingSize();
-    if (bytesLeft >= 4) {
-        uint32_t slotMask = packet.readUInt32();
-        for (int slot = 0; slot < 19; ++slot) {
-            if (slotMask & (1u << slot)) {
-                bytesLeft = packet.getRemainingSize();
-                if (bytesLeft < 2) break;
-                enchantIds[slot] = packet.readUInt16();
-            }
-        }
-    }
-
-    inspectResult_.guid              = guid;
-    inspectResult_.playerName        = playerName;
-    inspectResult_.totalTalents      = totalTalents;
-    inspectResult_.unspentTalents    = unspentTalents;
-    inspectResult_.talentGroups      = talentGroupCount;
-    inspectResult_.activeTalentGroup = activeTalentGroup;
-    inspectResult_.enchantIds        = enchantIds;
-
-    auto gearIt = owner_.inspectedPlayerItemEntries_.find(guid);
-    if (gearIt != owner_.inspectedPlayerItemEntries_.end()) {
-        inspectResult_.itemEntries = gearIt->second;
-    } else {
-        inspectResult_.itemEntries = {};
-    }
-
-    LOG_INFO("Inspect results for ", playerName, ": ", totalTalents, " talents, ",
-             unspentTalents, " unspent, ", (int)talentGroupCount, " specs");
-    if (owner_.addonEventCallback_) {
-        char guidBuf[32];
-        snprintf(guidBuf, sizeof(guidBuf), "0x%016llX", (unsigned long long)guid);
-        owner_.addonEventCallback_("INSPECT_READY", {guidBuf});
-    }
-}
-
-// ============================================================
-// Server Info / Who / Social
-// ============================================================
-
-void SocialHandler::queryServerTime() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = QueryTimePacket::build();
-    owner_.socket->send(packet);
-    LOG_INFO("Requested server time");
-}
-
-void SocialHandler::requestPlayedTime() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = RequestPlayedTimePacket::build(true);
-    owner_.socket->send(packet);
-    LOG_INFO("Requested played time");
-}
-
-void SocialHandler::queryWho(const std::string& playerName) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = WhoPacket::build(0, 0, playerName);
-    owner_.socket->send(packet);
-    LOG_INFO("Sent WHO query", playerName.empty() ? "" : " for: " + playerName);
-}
-
-void SocialHandler::addFriend(const std::string& playerName, const std::string& note) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (playerName.empty()) { owner_.addSystemChatMessage("You must specify a player name."); return; }
-    auto packet = AddFriendPacket::build(playerName, note);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Sending friend request to " + playerName + "...");
-    LOG_INFO("Sent friend request to: ", playerName);
-}
-
-void SocialHandler::removeFriend(const std::string& playerName) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (playerName.empty()) { owner_.addSystemChatMessage("You must specify a player name."); return; }
-    auto it = owner_.friendsCache.find(playerName);
-    if (it == owner_.friendsCache.end()) {
-        owner_.addSystemChatMessage(playerName + " is not in your friends list.");
-        return;
-    }
-    auto packet = DelFriendPacket::build(it->second);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Removing " + playerName + " from friends list...");
-    LOG_INFO("Sent remove friend request for: ", playerName);
-}
-
-void SocialHandler::setFriendNote(const std::string& playerName, const std::string& note) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (playerName.empty()) { owner_.addSystemChatMessage("You must specify a player name."); return; }
-    auto it = owner_.friendsCache.find(playerName);
-    if (it == owner_.friendsCache.end()) {
-        owner_.addSystemChatMessage(playerName + " is not in your friends list.");
-        return;
-    }
-    auto packet = SetContactNotesPacket::build(it->second, note);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Updated note for " + playerName);
-    LOG_INFO("Set friend note for: ", playerName);
-}
-
-void SocialHandler::addIgnore(const std::string& playerName) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (playerName.empty()) { owner_.addSystemChatMessage("You must specify a player name."); return; }
-    auto packet = AddIgnorePacket::build(playerName);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Adding " + playerName + " to ignore list...");
-    LOG_INFO("Sent ignore request for: ", playerName);
-}
-
-void SocialHandler::removeIgnore(const std::string& playerName) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (playerName.empty()) { owner_.addSystemChatMessage("You must specify a player name."); return; }
-    auto it = owner_.ignoreCache.find(playerName);
-    if (it == owner_.ignoreCache.end()) {
-        owner_.addSystemChatMessage(playerName + " is not in your ignore list.");
-        return;
-    }
-    auto packet = DelIgnorePacket::build(it->second);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Removing " + playerName + " from ignore list...");
-    // Don't erase from ignoreCache here — wait for the server's SMSG_IGNORE_LIST
-    // response to confirm. Erasing optimistically desyncs the cache if the server
-    // rejects the request. (Compare with removeFriend which also waits for
-    // SMSG_FRIEND_STATUS before updating its cache.)
-    owner_.ignoreListGuids_.erase(it->second);
-    LOG_INFO("Sent remove ignore request for: ", playerName);
-}
-
-void SocialHandler::randomRoll(uint32_t minRoll, uint32_t maxRoll) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (minRoll > maxRoll) std::swap(minRoll, maxRoll);
-    if (maxRoll > 10000) maxRoll = 10000;
-    auto packet = RandomRollPacket::build(minRoll, maxRoll);
-    owner_.socket->send(packet);
-    LOG_INFO("Rolled ", minRoll, "-", maxRoll);
-}
-
-// ============================================================
-// Logout
-// ============================================================
-
-void SocialHandler::requestLogout() {
-    if (!owner_.socket) return;
-    if (loggingOut_) { owner_.addSystemChatMessage("Already logging out."); return; }
-    auto packet = LogoutRequestPacket::build();
-    owner_.socket->send(packet);
-    loggingOut_ = true;
-    LOG_INFO("Sent logout request");
-}
-
-void SocialHandler::cancelLogout() {
-    if (!owner_.socket) return;
-    if (!loggingOut_) { owner_.addSystemChatMessage("Not currently logging out."); return; }
-    auto packet = LogoutCancelPacket::build();
-    owner_.socket->send(packet);
-    loggingOut_ = false;
-    logoutCountdown_ = 0.0f;
-    owner_.addSystemChatMessage("Logout cancelled.");
-    LOG_INFO("Cancelled logout");
-}
-
-// ============================================================
-// Guild
-// ============================================================
-
-void SocialHandler::requestGuildInfo() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = GuildInfoPacket::build();
-    owner_.socket->send(packet);
-}
-
-void SocialHandler::requestGuildRoster() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = GuildRosterPacket::build();
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Requesting guild roster...");
-}
-
-void SocialHandler::setGuildMotd(const std::string& motd) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = GuildMotdPacket::build(motd);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Guild MOTD updated.");
-}
-
-void SocialHandler::promoteGuildMember(const std::string& playerName) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (playerName.empty()) { owner_.addSystemChatMessage("You must specify a player name."); return; }
-    auto packet = GuildPromotePacket::build(playerName);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Promoting " + playerName + "...");
-}
-
-void SocialHandler::demoteGuildMember(const std::string& playerName) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (playerName.empty()) { owner_.addSystemChatMessage("You must specify a player name."); return; }
-    auto packet = GuildDemotePacket::build(playerName);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Demoting " + playerName + "...");
-}
-
-void SocialHandler::leaveGuild() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = GuildLeavePacket::build();
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Leaving guild...");
-}
-
-void SocialHandler::inviteToGuild(const std::string& playerName) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (playerName.empty()) { owner_.addSystemChatMessage("You must specify a player name."); return; }
-    auto packet = GuildInvitePacket::build(playerName);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Inviting " + playerName + " to guild...");
-}
-
-void SocialHandler::kickGuildMember(const std::string& playerName) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = GuildRemovePacket::build(playerName);
-    owner_.socket->send(packet);
-}
-
-void SocialHandler::disbandGuild() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = GuildDisbandPacket::build();
-    owner_.socket->send(packet);
-}
-
-void SocialHandler::setGuildLeader(const std::string& name) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = GuildLeaderPacket::build(name);
-    owner_.socket->send(packet);
-}
-
-void SocialHandler::setGuildPublicNote(const std::string& name, const std::string& note) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = GuildSetPublicNotePacket::build(name, note);
-    owner_.socket->send(packet);
-}
-
-void SocialHandler::setGuildOfficerNote(const std::string& name, const std::string& note) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = GuildSetOfficerNotePacket::build(name, note);
-    owner_.socket->send(packet);
-}
-
-void SocialHandler::acceptGuildInvite() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    pendingGuildInvite_ = false;
-    auto packet = GuildAcceptPacket::build();
-    owner_.socket->send(packet);
-}
-
-void SocialHandler::declineGuildInvite() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    pendingGuildInvite_ = false;
-    auto packet = GuildDeclineInvitationPacket::build();
-    owner_.socket->send(packet);
-}
-
-void SocialHandler::queryGuildInfo(uint32_t guildId) {
-    // Allow guild queries at the character screen too — the socket is
-    // connected and the server accepts CMSG_GUILD_QUERY before login.
-    if (!owner_.socket) return;
-    auto packet = GuildQueryPacket::build(guildId);
-    owner_.socket->send(packet);
-}
-
-void SocialHandler::createGuild(const std::string& guildName) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = GuildCreatePacket::build(guildName);
-    owner_.socket->send(packet);
-}
-
-void SocialHandler::addGuildRank(const std::string& rankName) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = GuildAddRankPacket::build(rankName);
-    owner_.socket->send(packet);
-    requestGuildRoster();
-}
-
-void SocialHandler::deleteGuildRank() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = GuildDelRankPacket::build();
-    owner_.socket->send(packet);
-    requestGuildRoster();
-}
-
-void SocialHandler::requestPetitionShowlist(uint64_t npcGuid) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = PetitionShowlistPacket::build(npcGuid);
-    owner_.socket->send(packet);
-}
-
-void SocialHandler::buyPetition(uint64_t npcGuid, const std::string& guildName) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = PetitionBuyPacket::build(npcGuid, guildName);
-    owner_.socket->send(packet);
-}
-
-void SocialHandler::signPetition(uint64_t petitionGuid) {
-    if (!owner_.socket || owner_.getState() != WorldState::IN_WORLD) return;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_PETITION_SIGN));
-    pkt.writeUInt64(petitionGuid);
-    pkt.writeUInt8(0);
-    owner_.socket->send(pkt);
-}
-
-void SocialHandler::turnInPetition(uint64_t petitionGuid) {
-    if (!owner_.socket || owner_.getState() != WorldState::IN_WORLD) return;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_TURN_IN_PETITION));
-    pkt.writeUInt64(petitionGuid);
-    owner_.socket->send(pkt);
-}
-
-// ============================================================
-// Ready Check
-// ============================================================
-
-void SocialHandler::initiateReadyCheck() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (!isInGroup()) { owner_.addSystemChatMessage("You must be in a group to initiate a ready check."); return; }
-    auto packet = ReadyCheckPacket::build();
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Ready check initiated.");
-}
-
-void SocialHandler::respondToReadyCheck(bool ready) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = ReadyCheckConfirmPacket::build(ready);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage(ready ? "You are ready." : "You are not ready.");
-}
-
-// ============================================================
-// Duel
-// ============================================================
-
-void SocialHandler::acceptDuel() {
-    if (!pendingDuelRequest_ || owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    pendingDuelRequest_ = false;
-    auto pkt = DuelAcceptPacket::build();
-    owner_.socket->send(pkt);
-    owner_.addSystemChatMessage("You accept the duel.");
-}
-
-void SocialHandler::forfeitDuel() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    pendingDuelRequest_ = false;
-    auto packet = DuelCancelPacket::build();
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("You have forfeited the duel.");
-}
-
-void SocialHandler::proposeDuel(uint64_t targetGuid) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (targetGuid == 0) { owner_.addSystemChatMessage("You must target a player to challenge to a duel."); return; }
-    auto packet = DuelProposedPacket::build(targetGuid);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("You have challenged your target to a duel.");
-}
-
-void SocialHandler::reportPlayer(uint64_t targetGuid, const std::string& reason) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (targetGuid == 0) {
-        owner_.addSystemChatMessage("You must target a player to report.");
-        return;
-    }
-    auto packet = ComplainPacket::build(targetGuid, reason);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Player report submitted.");
-    LOG_INFO("Reported player: 0x", std::hex, targetGuid, std::dec, " reason=", reason);
-}
-
-void SocialHandler::handleDuelRequested(network::Packet& packet) {
-    if (!packet.hasRemaining(16)) { packet.skipAll(); return; }
-    duelChallengerGuid_ = packet.readUInt64();
-    duelFlagGuid_       = packet.readUInt64();
-    duelChallengerName_.clear();
-    auto entity = owner_.getEntityManager().getEntity(duelChallengerGuid_);
-    if (auto* unit = dynamic_cast<Unit*>(entity.get()))
-        duelChallengerName_ = unit->getName();
-    if (duelChallengerName_.empty()) {
-        auto nit = owner_.getPlayerNameCache().find(duelChallengerGuid_);
-        if (nit != owner_.getPlayerNameCache().end()) duelChallengerName_ = nit->second;
-    }
-    if (duelChallengerName_.empty()) {
-        char tmp[32];
-        std::snprintf(tmp, sizeof(tmp), "0x%llX", static_cast<unsigned long long>(duelChallengerGuid_));
-        duelChallengerName_ = tmp;
-    }
-    pendingDuelRequest_ = true;
-    owner_.addSystemChatMessage(duelChallengerName_ + " challenges you to a duel!");
-    if (auto* ac = owner_.services().audioCoordinator)
-        if (auto* sfx = ac->getUiSoundManager()) sfx->playTargetSelect();
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("DUEL_REQUESTED", {duelChallengerName_});
-}
-
-void SocialHandler::handleDuelComplete(network::Packet& packet) {
-    if (!packet.hasRemaining(1)) return;
-    uint8_t started = packet.readUInt8();
-    pendingDuelRequest_ = false;
-    duelCountdownMs_ = 0;
-    if (!started) owner_.addSystemChatMessage("The duel was cancelled.");
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("DUEL_FINISHED", {});
-}
-
-void SocialHandler::handleDuelWinner(network::Packet& packet) {
-    if (!packet.hasRemaining(3)) return;
-    uint8_t duelType = packet.readUInt8();
-    std::string winner = packet.readString();
-    std::string loser  = packet.readString();
-    std::string msg = (duelType == 1)
-        ? loser + " has fled from the duel. " + winner + " wins!"
-        : winner + " has defeated " + loser + " in a duel!";
-    owner_.addSystemChatMessage(msg);
-}
-
-// ============================================================
-// Party / Raid
-// ============================================================
-
-void SocialHandler::inviteToGroup(const std::string& playerName) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    LOG_WARNING(">>> Sending CMSG_GROUP_INVITE to '", playerName, "'");
-    auto packet = GroupInvitePacket::build(playerName);
-    owner_.socket->send(packet);
-}
-
-void SocialHandler::acceptGroupInvite() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    LOG_WARNING(">>> Sending CMSG_GROUP_ACCEPT");
-    pendingGroupInvite = false;
-    auto packet = GroupAcceptPacket::build();
-    owner_.socket->send(packet);
-}
-
-void SocialHandler::declineGroupInvite() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    pendingGroupInvite = false;
-    auto packet = GroupDeclinePacket::build();
-    owner_.socket->send(packet);
-}
-
-void SocialHandler::leaveGroup() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = GroupDisbandPacket::build();
-    owner_.socket->send(packet);
-    partyData = GroupListData{};
-    if (owner_.addonEventCallback_) {
-        owner_.addonEventCallback_("GROUP_ROSTER_UPDATE", {});
-        owner_.addonEventCallback_("PARTY_MEMBERS_CHANGED", {});
-    }
-}
-
-void SocialHandler::convertToRaid() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (!isInGroup()) {
-        owner_.addSystemChatMessage("You are not in a group.");
-        return;
-    }
-    if (partyData.leaderGuid != owner_.getPlayerGuid()) {
-        owner_.addSystemChatMessage("You must be the party leader to convert to raid.");
-        return;
-    }
-    if (partyData.groupType == 1) {
-        owner_.addSystemChatMessage("You are already in a raid group.");
-        return;
-    }
-    auto packet = GroupRaidConvertPacket::build();
-    owner_.socket->send(packet);
-    LOG_INFO("Sent CMSG_GROUP_RAID_CONVERT");
-}
-
-void SocialHandler::sendSetLootMethod(uint32_t method, uint32_t threshold, uint64_t masterLooterGuid) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = SetLootMethodPacket::build(method, threshold, masterLooterGuid);
-    owner_.socket->send(packet);
-    LOG_INFO("sendSetLootMethod: method=", method, " threshold=", threshold);
-}
-
-void SocialHandler::uninvitePlayer(const std::string& playerName) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (playerName.empty()) { owner_.addSystemChatMessage("You must specify a player name to uninvite."); return; }
-    auto packet = GroupUninvitePacket::build(playerName);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Removed " + playerName + " from the group.");
-}
-
-void SocialHandler::leaveParty() {
-    // Delegates to leaveGroup which handles both the packet send AND local
-    // state cleanup (clearing partyData, firing addon events). Previously
-    // this method only sent the packet, leaving the client thinking it was
-    // still in a group until the server pushed a group list update.
-    leaveGroup();
-}
-
-void SocialHandler::setMainTank(uint64_t targetGuid) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (targetGuid == 0) { owner_.addSystemChatMessage("You must have a target selected."); return; }
-    auto packet = RaidTargetUpdatePacket::build(0, targetGuid);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Main tank set.");
-}
-
-void SocialHandler::setMainAssist(uint64_t targetGuid) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (targetGuid == 0) { owner_.addSystemChatMessage("You must have a target selected."); return; }
-    auto packet = RaidTargetUpdatePacket::build(1, targetGuid);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Main assist set.");
-}
-
-void SocialHandler::clearMainTank() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = RaidTargetUpdatePacket::build(0, 0);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Main tank cleared.");
-}
-
-void SocialHandler::clearMainAssist() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = RaidTargetUpdatePacket::build(1, 0);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Main assist cleared.");
-}
-
-void SocialHandler::setRaidMark(uint64_t guid, uint8_t icon) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    if (icon == 0xFF) {
-        for (int i = 0; i < 8; ++i) {
-            if (raidTargetGuids_[i] == guid) {
-                auto packet = RaidTargetUpdatePacket::build(static_cast<uint8_t>(i), 0);
-                owner_.socket->send(packet);
-                break;
-            }
-        }
-    } else if (icon < 8) {
-        auto packet = RaidTargetUpdatePacket::build(icon, guid);
-        owner_.socket->send(packet);
-    }
-}
-
-void SocialHandler::requestRaidInfo() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = RequestRaidInfoPacket::build();
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage("Requesting raid lockout information...");
-}
-
-// ============================================================
-// Group Handlers
-// ============================================================
-
-void SocialHandler::handleGroupInvite(network::Packet& packet) {
-    GroupInviteResponseData data;
-    if (!GroupInviteResponseParser::parse(packet, data)) return;
-    pendingGroupInvite = true;
-    pendingInviterName = data.inviterName;
-    if (!data.inviterName.empty())
-        owner_.addSystemChatMessage(data.inviterName + " has invited you to a group.");
-    if (auto* ac = owner_.services().audioCoordinator)
-        if (auto* sfx = ac->getUiSoundManager()) sfx->playTargetSelect();
-    if (owner_.addonEventCallback_)
-        owner_.addonEventCallback_("PARTY_INVITE_REQUEST", {data.inviterName});
-}
-
-void SocialHandler::handleGroupDecline(network::Packet& packet) {
-    GroupDeclineData data;
-    if (!GroupDeclineResponseParser::parse(packet, data)) return;
-    owner_.addSystemChatMessage(data.playerName + " has declined your group invitation.");
-}
-
-void SocialHandler::handleGroupList(network::Packet& packet) {
-    const bool hasRoles = isActiveExpansion("wotlk");
-    const uint8_t prevLootMethod = partyData.lootMethod;
-    const bool wasInGroup = !partyData.isEmpty();
-    partyData = GroupListData{};
-    if (!GroupListParser::parse(packet, partyData, hasRoles)) return;
-
-    const bool nowInGroup = !partyData.isEmpty();
-    if (!nowInGroup && wasInGroup) {
-        owner_.addSystemChatMessage("You are no longer in a group.");
-        LOG_INFO("Left group");
-    } else if (nowInGroup && !wasInGroup) {
-        std::string members;
-        for (const auto& m : partyData.members) {
-            if (!members.empty()) members += ", ";
-            members += m.name.empty() ? "?" : m.name;
-        }
-        owner_.addSystemChatMessage("You joined a group with: " + members);
-        LOG_INFO("Joined group with ", partyData.memberCount, " members: ", members);
-    }
-    // Loot method change notification
-    if (wasInGroup && nowInGroup && partyData.lootMethod != prevLootMethod) {
-        static const char* kLootMethods[] = {
-            "Free for All", "Round Robin", "Master Looter", "Group Loot", "Need Before Greed"
-        };
-        const char* methodName = (partyData.lootMethod < 5) ? kLootMethods[partyData.lootMethod] : "Unknown";
-        owner_.addSystemChatMessage(std::string("Loot method changed to ") + methodName + ".");
-    }
-    if (owner_.addonEventCallback_) {
-        owner_.addonEventCallback_("GROUP_ROSTER_UPDATE", {});
-        owner_.addonEventCallback_("PARTY_MEMBERS_CHANGED", {});
-        if (partyData.groupType == 1)
-            owner_.addonEventCallback_("RAID_ROSTER_UPDATE", {});
-    }
-}
-
-void SocialHandler::handleGroupUninvite(network::Packet& packet) {
-    (void)packet;
-    partyData = GroupListData{};
-    if (owner_.addonEventCallback_) {
-        owner_.addonEventCallback_("GROUP_ROSTER_UPDATE", {});
-        owner_.addonEventCallback_("PARTY_MEMBERS_CHANGED", {});
-        owner_.addonEventCallback_("RAID_ROSTER_UPDATE", {});
-    }
-    owner_.addUIError("You have been removed from the group.");
-    owner_.addSystemChatMessage("You have been removed from the group.");
-}
-
-void SocialHandler::handlePartyCommandResult(network::Packet& packet) {
-    PartyCommandResultData data;
-    if (!PartyCommandResultParser::parse(packet, data)) return;
-    if (data.result != PartyResult::OK) {
-        const char* errText = nullptr;
-        switch (data.result) {
-            case PartyResult::BAD_PLAYER_NAME:       errText = "No player named \"%s\" is currently online."; break;
-            case PartyResult::TARGET_NOT_IN_GROUP:   errText = "%s is not in your group."; break;
-            case PartyResult::TARGET_NOT_IN_INSTANCE:errText = "%s is not in your instance."; break;
-            case PartyResult::GROUP_FULL:            errText = "Your party is full."; break;
-            case PartyResult::ALREADY_IN_GROUP:      errText = "%s is already in a group."; break;
-            case PartyResult::NOT_IN_GROUP:          errText = "You are not in a group."; break;
-            case PartyResult::NOT_LEADER:            errText = "You are not the group leader."; break;
-            case PartyResult::PLAYER_WRONG_FACTION:  errText = "%s is the wrong faction for this group."; break;
-            case PartyResult::IGNORING_YOU:          errText = "%s is ignoring you."; break;
-            case PartyResult::LFG_PENDING:           errText = "You cannot do that while in a LFG queue."; break;
-            case PartyResult::INVITE_RESTRICTED:     errText = "Target is not accepting group invites."; break;
-            default:                                 errText = "Party command failed."; break;
-        }
-        char buf[256];
-        if (!data.name.empty() && errText && std::strstr(errText, "%s"))
-            std::snprintf(buf, sizeof(buf), errText, data.name.c_str());
-        else if (errText)
-            std::snprintf(buf, sizeof(buf), "%s", errText);
-        else
-            std::snprintf(buf, sizeof(buf), "Party command failed (error %u).", static_cast<uint32_t>(data.result));
-        owner_.addUIError(buf);
-        owner_.addSystemChatMessage(buf);
-    }
-}
-
-void SocialHandler::handlePartyMemberStats(network::Packet& packet, bool isFull) {
-    auto remaining = [&]() { return packet.getRemainingSize(); };
-    const bool isWotLK = isActiveExpansion("wotlk");
-
-    if (isFull) { if (remaining() < 1) return; packet.readUInt8(); }
-
-    const bool pmsTbc = isActiveExpansion("tbc");
-    if (remaining() < (pmsTbc ? 8u : 1u)) return;
-    uint64_t memberGuid = pmsTbc
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (remaining() < 4) return;
-    uint32_t updateFlags = packet.readUInt32();
-
-    game::GroupMember* member = nullptr;
-    for (auto& m : partyData.members) {
-        if (m.guid == memberGuid) { member = &m; break; }
-    }
-    if (!member) { packet.skipAll(); return; }
-
-    if (updateFlags & 0x0001) { if (remaining() >= 2) member->onlineStatus = packet.readUInt16(); }
-    if (updateFlags & 0x0002) {
-        if (isWotLK) { if (remaining() >= 4) member->curHealth = packet.readUInt32(); }
-        else { if (remaining() >= 2) member->curHealth = packet.readUInt16(); }
-    }
-    if (updateFlags & 0x0004) {
-        if (isWotLK) { if (remaining() >= 4) member->maxHealth = packet.readUInt32(); }
-        else { if (remaining() >= 2) member->maxHealth = packet.readUInt16(); }
-    }
-    if (updateFlags & 0x0008) { if (remaining() >= 1) member->powerType = packet.readUInt8(); }
-    if (updateFlags & 0x0010) { if (remaining() >= 2) member->curPower = packet.readUInt16(); }
-    if (updateFlags & 0x0020) { if (remaining() >= 2) member->maxPower = packet.readUInt16(); }
-    if (updateFlags & 0x0040) { if (remaining() >= 2) member->level = packet.readUInt16(); }
-    if (updateFlags & 0x0080) { if (remaining() >= 2) member->zoneId = packet.readUInt16(); }
-    if (updateFlags & 0x0100) {
-        if (remaining() >= 4) {
-            member->posX = static_cast<int16_t>(packet.readUInt16());
-            member->posY = static_cast<int16_t>(packet.readUInt16());
-        }
-    }
-    if (updateFlags & 0x0200) {
-        if (remaining() >= 8) {
-            uint64_t auraMask = packet.readUInt64();
-            std::vector<AuraSlot> newAuras;
-            for (int i = 0; i < 64; ++i) {
-                if (auraMask & (uint64_t(1) << i)) {
-                    AuraSlot a;
-                    a.level = static_cast<uint8_t>(i);
-                    if (isWotLK) {
-                        if (remaining() < 5) break;
-                        a.spellId = packet.readUInt32();
-                        a.flags   = packet.readUInt8();
-                    } else {
-                        if (remaining() < 2) break;
-                        a.spellId = packet.readUInt16();
-                        uint8_t dt = owner_.getSpellDispelType(a.spellId);
-                        if (dt > 0) a.flags = 0x80;
-                    }
-                    if (a.spellId != 0) newAuras.push_back(a);
-                }
-            }
-            if (memberGuid != 0 && memberGuid != owner_.playerGuid && memberGuid != owner_.targetGuid) {
-                owner_.unitAurasCache_[memberGuid] = std::move(newAuras);
-            }
-        }
-    }
-    // Skip pet fields and vehicle seat
-    if (updateFlags & 0x0400) { if (remaining() >= 8) packet.readUInt64(); }
-    if (updateFlags & 0x0800) { if (remaining() > 0) packet.readString(); }
-    if (updateFlags & 0x1000) { if (remaining() >= 2) packet.readUInt16(); }
-    if (updateFlags & 0x2000) { if (isWotLK) { if (remaining() >= 4) packet.readUInt32(); } else { if (remaining() >= 2) packet.readUInt16(); } }
-    if (updateFlags & 0x4000) { if (isWotLK) { if (remaining() >= 4) packet.readUInt32(); } else { if (remaining() >= 2) packet.readUInt16(); } }
-    if (updateFlags & 0x8000) { if (remaining() >= 1) packet.readUInt8(); }
-    if (updateFlags & 0x10000) { if (remaining() >= 2) packet.readUInt16(); }
-    if (updateFlags & 0x20000) { if (remaining() >= 2) packet.readUInt16(); }
-    if (updateFlags & 0x40000) {
-        if (remaining() >= 8) {
-            uint64_t petAuraMask = packet.readUInt64();
-            for (int i = 0; i < 64; ++i) {
-                if (petAuraMask & (uint64_t(1) << i)) {
-                    if (isWotLK) { if (remaining() < 5) break; packet.readUInt32(); packet.readUInt8(); }
-                    else { if (remaining() < 2) break; packet.readUInt16(); }
-                }
-            }
-        }
-    }
-    if (isWotLK && (updateFlags & 0x80000)) { if (remaining() >= 4) packet.readUInt32(); }
-
-    member->hasPartyStats = true;
-
-    if (owner_.addonEventCallback_) {
-        std::string unitId;
-        if (partyData.groupType == 1) {
-            for (size_t i = 0; i < partyData.members.size(); ++i) {
-                if (partyData.members[i].guid == memberGuid) { unitId = "raid" + std::to_string(i + 1); break; }
-            }
-        } else {
-            int found = 0;
-            for (const auto& m : partyData.members) {
-                if (m.guid == owner_.playerGuid) continue;
-                ++found;
-                if (m.guid == memberGuid) { unitId = "party" + std::to_string(found); break; }
-            }
-        }
-        if (!unitId.empty()) {
-            if (updateFlags & (0x0002 | 0x0004)) owner_.addonEventCallback_("UNIT_HEALTH", {unitId});
-            if (updateFlags & (0x0010 | 0x0020)) owner_.addonEventCallback_("UNIT_POWER", {unitId});
-            if (updateFlags & 0x0200) owner_.addonEventCallback_("UNIT_AURA", {unitId});
-        }
-    }
-}
-
-// ============================================================
-// Guild Handlers
-// ============================================================
-
-void SocialHandler::handleGuildInfo(network::Packet& packet) {
-    GuildInfoData data;
-    if (!GuildInfoParser::parse(packet, data)) return;
-    guildInfoData_ = data;
-    owner_.addSystemChatMessage("Guild: " + data.guildName + " (" +
-                         std::to_string(data.numMembers) + " members, " +
-                         std::to_string(data.numAccounts) + " accounts)");
-}
-
-void SocialHandler::handleGuildRoster(network::Packet& packet) {
-    GuildRosterData data;
-    if (!owner_.packetParsers_->parseGuildRoster(packet, data)) return;
-    guildRoster_ = std::move(data);
-    hasGuildRoster_ = true;
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("GUILD_ROSTER_UPDATE", {});
-}
-
-void SocialHandler::handleGuildQueryResponse(network::Packet& packet) {
-    GuildQueryResponseData data;
-    if (!owner_.packetParsers_->parseGuildQueryResponse(packet, data)) return;
-    if (data.guildId != 0 && !data.guildName.empty()) {
-        guildNameCache_[data.guildId] = data.guildName;
-        pendingGuildNameQueries_.erase(data.guildId);
-    }
-    const Character* ch = owner_.getActiveCharacter();
-    bool isLocalGuild = (ch && ch->hasGuild() && ch->guildId == data.guildId);
-    if (isLocalGuild) {
-        const bool wasUnknown = guildName_.empty();
-        guildName_ = data.guildName;
-        guildQueryData_ = data;
-        guildRankNames_.clear();
-        for (uint32_t i = 0; i < 10; ++i) guildRankNames_.push_back(data.rankNames[i]);
-        if (wasUnknown && !guildName_.empty()) {
-            owner_.addSystemChatMessage("Guild: <" + guildName_ + ">");
-            if (owner_.addonEventCallback_) owner_.addonEventCallback_("PLAYER_GUILD_UPDATE", {});
-        }
-    }
-}
-
-void SocialHandler::handleGuildEvent(network::Packet& packet) {
-    GuildEventData data;
-    if (!GuildEventParser::parse(packet, data)) return;
-
-    std::string msg;
-    switch (data.eventType) {
-        case GuildEvent::PROMOTION:
-            if (data.numStrings >= 3)
-                msg = data.strings[0] + " has promoted " + data.strings[1] + " to " + data.strings[2] + ".";
-            break;
-        case GuildEvent::DEMOTION:
-            if (data.numStrings >= 3)
-                msg = data.strings[0] + " has demoted " + data.strings[1] + " to " + data.strings[2] + ".";
-            break;
-        case GuildEvent::MOTD:
-            if (data.numStrings >= 1) msg = "Guild MOTD: " + data.strings[0];
-            break;
-        case GuildEvent::JOINED:
-            if (data.numStrings >= 1) msg = data.strings[0] + " has joined the guild.";
-            break;
-        case GuildEvent::LEFT:
-            if (data.numStrings >= 1) msg = data.strings[0] + " has left the guild.";
-            break;
-        case GuildEvent::REMOVED:
-            if (data.numStrings >= 2) msg = data.strings[1] + " has been kicked from the guild by " + data.strings[0] + ".";
-            break;
-        case GuildEvent::LEADER_IS:
-            if (data.numStrings >= 1) msg = data.strings[0] + " is the guild leader.";
-            break;
-        case GuildEvent::LEADER_CHANGED:
-            if (data.numStrings >= 2) msg = data.strings[0] + " has made " + data.strings[1] + " the new guild leader.";
-            break;
-        case GuildEvent::DISBANDED:
-            msg = "Guild has been disbanded.";
-            guildName_.clear();
-            guildRankNames_.clear();
-            guildRoster_ = GuildRosterData{};
-            hasGuildRoster_ = false;
-            if (owner_.addonEventCallback_) owner_.addonEventCallback_("PLAYER_GUILD_UPDATE", {});
-            break;
-        case GuildEvent::SIGNED_ON:
-            if (data.numStrings >= 1) msg = "[Guild] " + data.strings[0] + " has come online.";
-            break;
-        case GuildEvent::SIGNED_OFF:
-            if (data.numStrings >= 1) msg = "[Guild] " + data.strings[0] + " has gone offline.";
-            break;
-        default:
-            msg = "Guild event " + std::to_string(data.eventType);
-            // Was `!numStrings && numStrings >= 1` — always false (0 can't be ≥1).
-            if (data.numStrings >= 1) msg += ": " + data.strings[0];
-            break;
-    }
-
-    if (!msg.empty()) {
-        MessageChatData chatMsg;
-        chatMsg.type = ChatType::GUILD;
-        chatMsg.language = ChatLanguage::UNIVERSAL;
-        chatMsg.message = msg;
-        owner_.addLocalChatMessage(chatMsg);
-    }
-
-    if (owner_.addonEventCallback_) {
-        switch (data.eventType) {
-            case GuildEvent::MOTD:
-                owner_.addonEventCallback_("GUILD_MOTD", {data.numStrings >= 1 ? data.strings[0] : ""});
-                break;
-            case GuildEvent::SIGNED_ON: case GuildEvent::SIGNED_OFF:
-            case GuildEvent::PROMOTION: case GuildEvent::DEMOTION:
-            case GuildEvent::JOINED: case GuildEvent::LEFT:
-            case GuildEvent::REMOVED: case GuildEvent::LEADER_CHANGED:
-            case GuildEvent::DISBANDED:
-                owner_.addonEventCallback_("GUILD_ROSTER_UPDATE", {});
-                break;
-            default: break;
-        }
-    }
-
-    switch (data.eventType) {
-        case GuildEvent::PROMOTION: case GuildEvent::DEMOTION:
-        case GuildEvent::JOINED: case GuildEvent::LEFT:
-        case GuildEvent::REMOVED: case GuildEvent::LEADER_CHANGED:
-            if (hasGuildRoster_) requestGuildRoster();
-            break;
-        default: break;
-    }
-}
-
-void SocialHandler::handleGuildInvite(network::Packet& packet) {
-    GuildInviteResponseData data;
-    if (!GuildInviteResponseParser::parse(packet, data)) return;
-    pendingGuildInvite_ = true;
-    pendingGuildInviterName_ = data.inviterName;
-    pendingGuildInviteGuildName_ = data.guildName;
-    owner_.addSystemChatMessage(data.inviterName + " has invited you to join " + data.guildName + ".");
-    if (owner_.addonEventCallback_)
-        owner_.addonEventCallback_("GUILD_INVITE_REQUEST", {data.inviterName, data.guildName});
-}
-
-void SocialHandler::handleGuildCommandResult(network::Packet& packet) {
-    GuildCommandResultData data;
-    if (!GuildCommandResultParser::parse(packet, data)) return;
-    if (data.errorCode == 0) {
-        switch (data.command) {
-            case 0: owner_.addSystemChatMessage("Guild created."); break;
-            case 1:
-                if (!data.name.empty()) owner_.addSystemChatMessage("You have invited " + data.name + " to the guild.");
-                break;
-            case 2:
-                owner_.addSystemChatMessage("You have left the guild.");
-                guildName_.clear(); guildRankNames_.clear();
-                guildRoster_ = GuildRosterData{}; hasGuildRoster_ = false;
-                break;
-            default: break;
-        }
-        return;
-    }
-    const char* errStr = nullptr;
-    switch (data.errorCode) {
-        case 2:  errStr = "You are not in a guild."; break;
-        case 4:  errStr = "No player named \"%s\" is online."; break;
-        case 11: errStr = "\"%s\" is already in a guild."; break;
-        case 13: errStr = "You are already in a guild."; break;
-        case 14: errStr = "\"%s\" has already been invited to a guild."; break;
-        case 16: case 17: errStr = "You are not the guild leader."; break;
-        case 22: errStr = "That player is ignoring you."; break;
-        default: break;
-    }
-    std::string errorMsg;
-    if (errStr) {
-        std::string fmt = errStr;
-        auto pos = fmt.find("%s");
-        if (pos != std::string::npos && !data.name.empty()) fmt.replace(pos, 2, data.name);
-        else if (pos != std::string::npos) fmt.replace(pos, 2, "that player");
-        errorMsg = fmt;
-    } else {
-        errorMsg = "Guild command failed";
-        if (!data.name.empty()) errorMsg += " for " + data.name;
-        errorMsg += " (error " + std::to_string(data.errorCode) + ")";
-    }
-    owner_.addUIError(errorMsg);
-    owner_.addSystemChatMessage(errorMsg);
-}
-
-void SocialHandler::handlePetitionShowlist(network::Packet& packet) {
-    PetitionShowlistData data;
-    if (!PetitionShowlistParser::parse(packet, data)) return;
-    petitionNpcGuid_ = data.npcGuid;
-    petitionCost_ = data.cost;
-    showPetitionDialog_ = true;
-}
-
-void SocialHandler::handlePetitionQueryResponse(network::Packet& packet) {
-    auto rem = [&]() { return packet.getRemainingSize(); };
-    if (rem() < 12) return;
-    /*uint32_t entry =*/ packet.readUInt32();
-    uint64_t petGuid = packet.readUInt64();
-    std::string guildName = packet.readString();
-    /*std::string body =*/ packet.readString();
-    if (petitionInfo_.petitionGuid == petGuid) petitionInfo_.guildName = guildName;
-    packet.skipAll();
-}
-
-void SocialHandler::handlePetitionShowSignatures(network::Packet& packet) {
-    auto rem = [&]() { return packet.getRemainingSize(); };
-    if (rem() < 21) return;
-    petitionInfo_ = PetitionInfo{};
-    petitionInfo_.petitionGuid = packet.readUInt64();
-    petitionInfo_.ownerGuid    = packet.readUInt64();
-    /*uint32_t petEntry =*/     packet.readUInt32();
-    uint8_t sigCount           = packet.readUInt8();
-    petitionInfo_.signatureCount = sigCount;
-    petitionInfo_.signatures.reserve(sigCount);
-    for (uint8_t i = 0; i < sigCount; ++i) {
-        if (rem() < 12) break;
-        PetitionSignature sig;
-        sig.playerGuid = packet.readUInt64();
-        /*uint32_t unk =*/ packet.readUInt32();
-        petitionInfo_.signatures.push_back(sig);
-    }
-    petitionInfo_.showUI = true;
-}
-
-void SocialHandler::handlePetitionSignResults(network::Packet& packet) {
-    auto rem = [&]() { return packet.getRemainingSize(); };
-    if (rem() < 20) return;
-    uint64_t petGuid    = packet.readUInt64();
-    uint64_t playerGuid = packet.readUInt64();
-    uint32_t result     = packet.readUInt32();
-    switch (result) {
-        case 0:
-            owner_.addSystemChatMessage("Petition signed successfully.");
-            if (petitionInfo_.petitionGuid == petGuid) {
-                petitionInfo_.signatureCount++;
-                PetitionSignature sig; sig.playerGuid = playerGuid;
-                petitionInfo_.signatures.push_back(sig);
-            }
-            break;
-        case 1: owner_.addSystemChatMessage("You have already signed that petition."); break;
-        case 2: owner_.addSystemChatMessage("You are already in a guild."); break;
-        case 3: owner_.addSystemChatMessage("You cannot sign your own petition."); break;
-        default: owner_.addSystemChatMessage("Cannot sign petition (error " + std::to_string(result) + ")."); break;
-    }
-}
-
-void SocialHandler::handleTurnInPetitionResults(network::Packet& packet) {
-    uint32_t result = 0;
-    if (!TurnInPetitionResultsParser::parse(packet, result)) return;
-    switch (result) {
-        case 0: owner_.addSystemChatMessage("Guild created successfully!"); break;
-        case 1: owner_.addSystemChatMessage("Guild creation failed: already in a guild."); break;
-        case 2: owner_.addSystemChatMessage("Guild creation failed: not enough signatures."); break;
-        case 3: owner_.addSystemChatMessage("Guild creation failed: name already taken."); break;
-        default: owner_.addSystemChatMessage("Guild creation failed (error " + std::to_string(result) + ")."); break;
-    }
-}
-
-// ============================================================
-// Server Info Handlers
-// ============================================================
-
-void SocialHandler::handleQueryTimeResponse(network::Packet& packet) {
-    QueryTimeResponseData data;
-    if (!QueryTimeResponseParser::parse(packet, data)) return;
-    time_t serverTime = static_cast<time_t>(data.serverTime);
-    struct tm* timeInfo = localtime(&serverTime);
-    char timeStr[64];
-    strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", timeInfo);
-    owner_.addSystemChatMessage("Server time: " + std::string(timeStr));
-}
-
-void SocialHandler::handlePlayedTime(network::Packet& packet) {
-    PlayedTimeData data;
-    if (!PlayedTimeParser::parse(packet, data)) return;
-    totalTimePlayed_ = data.totalTimePlayed;
-    levelTimePlayed_ = data.levelTimePlayed;
-    if (data.triggerMessage) {
-        uint32_t totalDays = data.totalTimePlayed / 86400;
-        uint32_t totalHours = (data.totalTimePlayed % 86400) / 3600;
-        uint32_t totalMinutes = (data.totalTimePlayed % 3600) / 60;
-        uint32_t levelDays = data.levelTimePlayed / 86400;
-        uint32_t levelHours = (data.levelTimePlayed % 86400) / 3600;
-        uint32_t levelMinutes = (data.levelTimePlayed % 3600) / 60;
-        std::string totalMsg = "Total time played: ";
-        if (totalDays > 0) totalMsg += std::to_string(totalDays) + " days, ";
-        if (totalHours > 0 || totalDays > 0) totalMsg += std::to_string(totalHours) + " hours, ";
-        totalMsg += std::to_string(totalMinutes) + " minutes";
-        std::string levelMsg = "Time played this level: ";
-        if (levelDays > 0) levelMsg += std::to_string(levelDays) + " days, ";
-        if (levelHours > 0 || levelDays > 0) levelMsg += std::to_string(levelHours) + " hours, ";
-        levelMsg += std::to_string(levelMinutes) + " minutes";
-        owner_.addSystemChatMessage(totalMsg);
-        owner_.addSystemChatMessage(levelMsg);
-    }
-}
-
-void SocialHandler::handleWho(network::Packet& packet) {
-    const bool hasGender = isActiveExpansion("wotlk");
-    uint32_t displayCount = packet.readUInt32();
-    uint32_t onlineCount = packet.readUInt32();
-    whoResults_.clear();
-    whoOnlineCount_ = onlineCount;
-    if (displayCount == 0) { owner_.addSystemChatMessage("No players found."); return; }
-    for (uint32_t i = 0; i < displayCount; ++i) {
-        if (packet.getReadPos() >= packet.getSize()) break;
-        std::string playerName = packet.readString();
-        std::string guildName = packet.readString();
-        if (!packet.hasRemaining(12)) break;
-        uint32_t level   = packet.readUInt32();
-        uint32_t classId = packet.readUInt32();
-        uint32_t raceId  = packet.readUInt32();
-        if (hasGender && packet.hasRemaining(1)) packet.readUInt8();
-        uint32_t zoneId = 0;
-        if (packet.hasRemaining(4)) zoneId = packet.readUInt32();
-        WhoEntry entry;
-        entry.name = playerName; entry.guildName = guildName;
-        entry.level = level; entry.classId = classId;
-        entry.raceId = raceId; entry.zoneId = zoneId;
-        whoResults_.push_back(std::move(entry));
-    }
-}
-
-// ============================================================
-// Social (Friend/Ignore/Random Roll) Handlers
-// ============================================================
-
-void SocialHandler::handleFriendList(network::Packet& packet) {
-    auto rem = [&]() { return packet.getRemainingSize(); };
-    if (rem() < 1) return;
-    uint8_t count = packet.readUInt8();
-    owner_.contacts_.erase(std::remove_if(owner_.contacts_.begin(), owner_.contacts_.end(),
-        [](const ContactEntry& e){ return e.isFriend(); }), owner_.contacts_.end());
-    for (uint8_t i = 0; i < count && rem() >= 9; ++i) {
-        uint64_t guid   = packet.readUInt64();
-        uint8_t  status = packet.readUInt8();
-        uint32_t area = 0, level = 0, classId = 0;
-        if (status != 0 && rem() >= 12) {
-            area    = packet.readUInt32();
-            level   = packet.readUInt32();
-            classId = packet.readUInt32();
-        }
-        owner_.friendGuids_.insert(guid);
-        auto nit = owner_.getPlayerNameCache().find(guid);
-        std::string name;
-        if (nit != owner_.getPlayerNameCache().end()) {
-            name = nit->second;
-            owner_.friendsCache[name] = guid;
-        } else {
-            owner_.queryPlayerName(guid);
-        }
-        ContactEntry entry;
-        entry.guid = guid; entry.name = name; entry.flags = 0x1;
-        entry.status = status; entry.areaId = area; entry.level = level; entry.classId = classId;
-        owner_.contacts_.push_back(std::move(entry));
-    }
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("FRIENDLIST_UPDATE", {});
-}
-
-void SocialHandler::handleContactList(network::Packet& packet) {
-    auto rem = [&]() { return packet.getRemainingSize(); };
-    if (rem() < 8) { packet.skipAll(); return; }
-    owner_.lastContactListMask_  = packet.readUInt32();
-    owner_.lastContactListCount_ = packet.readUInt32();
-    owner_.contacts_.clear();
-    for (uint32_t i = 0; i < owner_.lastContactListCount_ && rem() >= 8; ++i) {
-        uint64_t guid  = packet.readUInt64();
-        if (rem() < 4) break;
-        uint32_t flags = packet.readUInt32();
-        std::string note = packet.readString();
-        uint8_t status = 0; uint32_t areaId = 0, level = 0, classId = 0;
-        if (flags & 0x1) {
-            if (rem() < 1) break;
-            status = packet.readUInt8();
-            if (status != 0 && rem() >= 12) {
-                areaId = packet.readUInt32(); level = packet.readUInt32(); classId = packet.readUInt32();
-            }
-            owner_.friendGuids_.insert(guid);
-            auto nit = owner_.getPlayerNameCache().find(guid);
-            if (nit != owner_.getPlayerNameCache().end()) owner_.friendsCache[nit->second] = guid;
-            else owner_.queryPlayerName(guid);
-        }
-        ContactEntry entry;
-        entry.guid = guid; entry.flags = flags; entry.note = std::move(note);
-        entry.status = status; entry.areaId = areaId; entry.level = level; entry.classId = classId;
-        auto nit = owner_.getPlayerNameCache().find(guid);
-        if (nit != owner_.getPlayerNameCache().end()) entry.name = nit->second;
-        owner_.contacts_.push_back(std::move(entry));
-    }
-    if (owner_.addonEventCallback_) {
-        owner_.addonEventCallback_("FRIENDLIST_UPDATE", {});
-        if (owner_.lastContactListMask_ & 0x2) owner_.addonEventCallback_("IGNORELIST_UPDATE", {});
-    }
-}
-
-void SocialHandler::handleFriendStatus(network::Packet& packet) {
-    FriendStatusData data;
-    if (!FriendStatusParser::parse(packet, data)) return;
-
-    // Single lookup — reuse iterator for name resolution and update/erase below
-    auto cit = std::find_if(owner_.contacts_.begin(), owner_.contacts_.end(),
-        [&](const ContactEntry& e){ return e.guid == data.guid; });
-
-    // Look up player name: contacts_ (populated by SMSG_FRIEND_LIST) > playerNameCache
-    std::string playerName;
-    if (cit != owner_.contacts_.end() && !cit->name.empty()) {
-        playerName = cit->name;
-    } else {
-        auto it = owner_.getPlayerNameCache().find(data.guid);
-        if (it != owner_.getPlayerNameCache().end()) playerName = it->second;
-    }
-
-    // Only update friendsCache when we have a resolved name — inserting an empty
-    // key creates a phantom entry that masks the real one when the name arrives.
-    if (!playerName.empty()) {
-        if (data.status == 1 || data.status == 2) owner_.friendsCache[playerName] = data.guid;
-        else if (data.status == 0) owner_.friendsCache.erase(playerName);
-    }
-
-    if (data.status == 0) {
-        if (cit != owner_.contacts_.end())
-            owner_.contacts_.erase(cit);
-    } else {
-        if (cit != owner_.contacts_.end()) {
-            if (!playerName.empty() && playerName != "Unknown") cit->name = playerName;
-            if (data.status == 2) cit->status = 1; else if (data.status == 3) cit->status = 0;
-        } else {
-            ContactEntry entry;
-            entry.guid = data.guid; entry.name = playerName; entry.flags = 0x1;
-            entry.status = (data.status == 2) ? 1 : 0;
-            owner_.contacts_.push_back(std::move(entry));
-        }
-    }
-    switch (data.status) {
-        case 0: owner_.addSystemChatMessage(playerName + " has been removed from your friends list."); break;
-        case 1: owner_.addSystemChatMessage(playerName + " has been added to your friends list."); break;
-        case 2: owner_.addSystemChatMessage(playerName + " is now online."); break;
-        case 3: owner_.addSystemChatMessage(playerName + " is now offline."); break;
-        case 4: owner_.addSystemChatMessage("Player not found."); break;
-        case 5: owner_.addSystemChatMessage(playerName + " is already in your friends list."); break;
-        case 6: owner_.addSystemChatMessage("Your friends list is full."); break;
-        case 7: owner_.addSystemChatMessage(playerName + " is ignoring you."); break;
-        default: break;
-    }
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("FRIENDLIST_UPDATE", {});
-}
-
-void SocialHandler::handleRandomRoll(network::Packet& packet) {
-    RandomRollData data;
-    if (!RandomRollParser::parse(packet, data)) return;
-    std::string rollerName = (data.rollerGuid == owner_.playerGuid) ? "You" : "Someone";
-    if (data.rollerGuid != owner_.playerGuid) {
-        auto it = owner_.getPlayerNameCache().find(data.rollerGuid);
-        if (it != owner_.getPlayerNameCache().end()) rollerName = it->second;
-    }
-    std::string msg = rollerName + ((data.rollerGuid == owner_.playerGuid) ? " roll " : " rolls ");
-    msg += std::to_string(data.result) + " (" + std::to_string(data.minRoll) + "-" + std::to_string(data.maxRoll) + ")";
-    owner_.addSystemChatMessage(msg);
-}
-
-// ============================================================
-// Logout Handlers
-// ============================================================
-
-void SocialHandler::handleLogoutResponse(network::Packet& packet) {
-    LogoutResponseData data;
-    if (!LogoutResponseParser::parse(packet, data)) return;
-    if (data.result == 0) {
-        if (data.instant) { owner_.addSystemChatMessage("Logging out..."); logoutCountdown_ = 0.0f; }
-        else { owner_.addSystemChatMessage("Logging out in 20 seconds..."); logoutCountdown_ = 20.0f; }
-        if (owner_.addonEventCallback_) owner_.addonEventCallback_("PLAYER_LOGOUT", {});
-    } else {
-        owner_.addSystemChatMessage("Cannot logout right now.");
-        loggingOut_ = false; logoutCountdown_ = 0.0f;
-    }
-}
-
-void SocialHandler::handleLogoutComplete(network::Packet& /*packet*/) {
-    owner_.addSystemChatMessage("Logout complete.");
-    loggingOut_ = false; logoutCountdown_ = 0.0f;
-}
-
-// ============================================================
-// Battleground Handlers
-// ============================================================
-
-void SocialHandler::handleBattlefieldStatus(network::Packet& packet) {
-    if (!packet.hasRemaining(4)) return;
-    uint32_t queueSlot = packet.readUInt32();
-    const bool classicFormat = isClassicLikeExpansion();
-    uint8_t arenaType = 0;
-    if (!classicFormat) {
-        if (!packet.hasRemaining(1)) return;
-        arenaType = packet.readUInt8();
-        if (!packet.hasRemaining(1)) return;
-        packet.readUInt8();
-    } else {
-        if (!packet.hasRemaining(4)) return;
-    }
-    if (!packet.hasRemaining(4)) return;
-    uint32_t bgTypeId = packet.readUInt32();
-    if (!packet.hasRemaining(2)) return;
-    packet.readUInt16();
-    if (!packet.hasRemaining(4)) return;
-    packet.readUInt32(); // instanceId
-    if (!packet.hasRemaining(1)) return;
-    packet.readUInt8(); // isRated
-    if (!packet.hasRemaining(4)) return;
-    uint32_t statusId = packet.readUInt32();
-
-    static const std::pair<uint32_t, const char*> kBgNames[] = {
-        {1,"Alterac Valley"},{2,"Warsong Gulch"},{3,"Arathi Basin"},
-        {4,"Nagrand Arena"},{5,"Blade's Edge Arena"},{6,"All Arenas"},
-        {7,"Eye of the Storm"},{8,"Ruins of Lordaeron"},{9,"Strand of the Ancients"},
-        {10,"Dalaran Sewers"},{11,"Ring of Valor"},{30,"Isle of Conquest"},{32,"Random Battleground"},
-    };
-    std::string bgName = "Battleground";
-    for (const auto& kv : kBgNames) { if (kv.first == bgTypeId) { bgName = kv.second; break; } }
-    if (bgName == "Battleground") bgName = "Battleground #" + std::to_string(bgTypeId);
-    if (arenaType > 0) {
-        bgName = std::to_string(arenaType) + "v" + std::to_string(arenaType) + " Arena";
-        for (const auto& kv : kBgNames) { if (kv.first == bgTypeId) { bgName += " (" + std::string(kv.second) + ")"; break; } }
-    }
-
-    uint32_t inviteTimeout = 80, avgWaitSec = 0, timeInQueueSec = 0;
-    if (statusId == 1 && packet.hasRemaining(8)) {
-        avgWaitSec = packet.readUInt32() / 1000; timeInQueueSec = packet.readUInt32() / 1000;
-    } else if (statusId == 2) {
-        if (packet.hasRemaining(4)) inviteTimeout = packet.readUInt32();
-        if (packet.hasRemaining(4)) packet.readUInt32();
-    } else if (statusId == 3 && packet.hasRemaining(8)) {
-        packet.readUInt32(); packet.readUInt32();
-    }
-
-    if (queueSlot < bgQueues_.size()) {
-        bool wasInvite = (bgQueues_[queueSlot].statusId == 2);
-        bgQueues_[queueSlot].queueSlot = queueSlot;
-        bgQueues_[queueSlot].bgTypeId = bgTypeId;
-        bgQueues_[queueSlot].arenaType = arenaType;
-        bgQueues_[queueSlot].statusId = statusId;
-        bgQueues_[queueSlot].bgName = bgName;
-        if (statusId == 1) { bgQueues_[queueSlot].avgWaitTimeSec = avgWaitSec; bgQueues_[queueSlot].timeInQueueSec = timeInQueueSec; }
-        if (statusId == 2 && !wasInvite) { bgQueues_[queueSlot].inviteTimeout = inviteTimeout; bgQueues_[queueSlot].inviteReceivedTime = std::chrono::steady_clock::now(); }
-    }
-
-    switch (statusId) {
-        case 1: owner_.addSystemChatMessage("Queued for " + bgName + "."); break;
-        case 2: owner_.addSystemChatMessage(bgName + " is ready!"); break;
-        case 3: owner_.addSystemChatMessage("Entered " + bgName + "."); break;
-        default: break;
-    }
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("UPDATE_BATTLEFIELD_STATUS", {std::to_string(statusId)});
-}
-
-void SocialHandler::handleBattlefieldList(network::Packet& packet) {
-    if (!packet.hasRemaining(5)) return;
-    AvailableBgInfo info;
-    info.bgTypeId = packet.readUInt32();
-    info.isRegistered = packet.readUInt8() != 0;
-    const bool isWotlk = isActiveExpansion("wotlk");
-    const bool isTbc = isActiveExpansion("tbc");
-    if (isTbc || isWotlk) { if (!packet.hasRemaining(1)) return; info.isHoliday = packet.readUInt8() != 0; }
-    if (isWotlk) { if (!packet.hasRemaining(8)) return; info.minLevel = packet.readUInt32(); info.maxLevel = packet.readUInt32(); }
-    if (!packet.hasRemaining(4)) return;
-    uint32_t count = std::min(packet.readUInt32(), 256u);
-    info.instanceIds.reserve(count);
-    for (uint32_t i = 0; i < count; ++i) {
-        if (!packet.hasRemaining(4)) break;
-        info.instanceIds.push_back(packet.readUInt32());
-    }
-    bool updated = false;
-    for (auto& existing : availableBgs_) { if (existing.bgTypeId == info.bgTypeId) { existing = std::move(info); updated = true; break; } }
-    if (!updated) availableBgs_.push_back(std::move(info));
-}
-
-bool SocialHandler::hasPendingBgInvite() const {
-    for (const auto& slot : bgQueues_) { if (slot.statusId == 2) return true; }
-    return false;
-}
-
-void SocialHandler::acceptBattlefield(uint32_t queueSlot) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    const BgQueueSlot* slot = nullptr;
-    if (queueSlot == 0xFFFFFFFF) { for (const auto& s : bgQueues_) { if (s.statusId == 2) { slot = &s; break; } } }
-    else if (queueSlot < bgQueues_.size() && bgQueues_[queueSlot].statusId == 2) slot = &bgQueues_[queueSlot];
-    if (!slot) { owner_.addSystemChatMessage("No battleground invitation pending."); return; }
-    network::Packet pkt(wireOpcode(Opcode::CMSG_BATTLEFIELD_PORT));
-    pkt.writeUInt8(slot->arenaType); pkt.writeUInt8(0x00); pkt.writeUInt32(slot->bgTypeId);
-    pkt.writeUInt16(0x0000); pkt.writeUInt8(1);
-    owner_.socket->send(pkt);
-    uint32_t clearSlot = slot->queueSlot;
-    if (clearSlot < bgQueues_.size()) bgQueues_[clearSlot].statusId = 3;
-    owner_.addSystemChatMessage("Accepting battleground invitation...");
-}
-
-void SocialHandler::declineBattlefield(uint32_t queueSlot) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    const BgQueueSlot* slot = nullptr;
-    if (queueSlot == 0xFFFFFFFF) { for (const auto& s : bgQueues_) { if (s.statusId == 2) { slot = &s; break; } } }
-    else if (queueSlot < bgQueues_.size() && bgQueues_[queueSlot].statusId == 2) slot = &bgQueues_[queueSlot];
-    if (!slot) { owner_.addSystemChatMessage("No battleground invitation pending."); return; }
-    network::Packet pkt(wireOpcode(Opcode::CMSG_BATTLEFIELD_PORT));
-    pkt.writeUInt8(slot->arenaType); pkt.writeUInt8(0x00); pkt.writeUInt32(slot->bgTypeId);
-    pkt.writeUInt16(0x0000); pkt.writeUInt8(0);
-    owner_.socket->send(pkt);
-    uint32_t clearSlot = slot->queueSlot;
-    if (clearSlot < bgQueues_.size()) bgQueues_[clearSlot] = BgQueueSlot{};
-    owner_.addSystemChatMessage("Battleground invitation declined.");
-}
-
-void SocialHandler::requestPvpLog() {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    network::Packet pkt(wireOpcode(Opcode::MSG_PVP_LOG_DATA));
-    owner_.socket->send(pkt);
-}
-
-// ============================================================
-// Instance Handlers
-// ============================================================
-
-void SocialHandler::handleRaidInstanceInfo(network::Packet& packet) {
-    const bool isTbc = isActiveExpansion("tbc");
-    const bool isClassic = isClassicLikeExpansion();
-    const bool useTbcFormat = isTbc || isClassic;
-    if (!packet.hasRemaining(4)) return;
-    uint32_t count = packet.readUInt32();
-    instanceLockouts_.clear();
-    instanceLockouts_.reserve(count);
-    const size_t kEntrySize = useTbcFormat ? 13 : 18;
-    for (uint32_t i = 0; i < count; ++i) {
-        if (packet.getRemainingSize() < kEntrySize) break;
-        InstanceLockout lo;
-        lo.mapId = packet.readUInt32(); lo.difficulty = packet.readUInt32();
-        if (useTbcFormat) { lo.resetTime = packet.readUInt32(); lo.locked = packet.readUInt8() != 0; lo.extended = false; }
-        else { lo.resetTime = packet.readUInt64(); lo.locked = packet.readUInt8() != 0; lo.extended = packet.readUInt8() != 0; }
-        instanceLockouts_.push_back(lo);
-    }
-}
-
-void SocialHandler::handleInstanceDifficulty(network::Packet& packet) {
-    auto rem = [&]() { return packet.getRemainingSize(); };
-    if (rem() < 4) return;
-    uint32_t prevDifficulty = instanceDifficulty_;
-    instanceDifficulty_ = packet.readUInt32();
-    if (rem() >= 4) {
-        uint32_t secondField = packet.readUInt32();
-        if (rem() >= 4) instanceIsHeroic_ = (instanceDifficulty_ == 1);
-        else instanceIsHeroic_ = (secondField != 0);
-    } else {
-        instanceIsHeroic_ = (instanceDifficulty_ == 1);
-    }
-    inInstance_ = true;
-    if (instanceDifficulty_ != prevDifficulty) {
-        static const char* kDiffLabels[] = {"Normal", "Heroic", "25-Man Normal", "25-Man Heroic"};
-        const char* diffLabel = (instanceDifficulty_ < 4) ? kDiffLabels[instanceDifficulty_] : nullptr;
-        if (diffLabel) owner_.addSystemChatMessage(std::string("Dungeon difficulty set to ") + diffLabel + ".");
-    }
-}
-
-// ============================================================
-// LFG Handlers
-// ============================================================
-
-void SocialHandler::handleLfgJoinResult(network::Packet& packet) {
-    if (!packet.hasRemaining(2)) return;
-    uint8_t result = packet.readUInt8();
-    uint8_t state  = packet.readUInt8();
-    if (result == 0) {
-        lfgState_ = static_cast<LfgState>(state);
-        std::string dName = owner_.getLfgDungeonName(lfgDungeonId_);
-        if (!dName.empty()) owner_.addSystemChatMessage("Dungeon Finder: Joined the queue for " + dName + ".");
-        else owner_.addSystemChatMessage("Dungeon Finder: Joined the queue.");
-    } else {
-        const char* msg = lfgJoinResultString(result);
-        std::string errMsg = std::string("Dungeon Finder: ") + (msg ? msg : "Join failed.");
-        owner_.addUIError(errMsg);
-        owner_.addSystemChatMessage(errMsg);
-    }
-}
-
-void SocialHandler::handleLfgQueueStatus(network::Packet& packet) {
-    if (!packet.hasRemaining(33)) return;
-    lfgDungeonId_ = packet.readUInt32();
-    int32_t avgWait = static_cast<int32_t>(packet.readUInt32());
-    int32_t waitTime = static_cast<int32_t>(packet.readUInt32());
-    packet.readUInt32(); packet.readUInt32(); packet.readUInt32();
-    packet.readUInt8();
-    lfgTimeInQueueMs_ = packet.readUInt32();
-    lfgAvgWaitSec_ = (waitTime >= 0) ? (waitTime / 1000) : (avgWait / 1000);
-    lfgState_ = LfgState::Queued;
-}
-
-void SocialHandler::handleLfgProposalUpdate(network::Packet& packet) {
-    if (!packet.hasRemaining(17)) return;
-    uint32_t dungeonId = packet.readUInt32();
-    uint32_t proposalId = packet.readUInt32();
-    uint32_t proposalState = packet.readUInt32();
-    packet.readUInt32(); packet.readUInt8();
-    lfgDungeonId_ = dungeonId; lfgProposalId_ = proposalId;
-    switch (proposalState) {
-        case 0: lfgState_ = LfgState::Queued; lfgProposalId_ = 0;
-            owner_.addUIError("Dungeon Finder: Group proposal failed."); owner_.addSystemChatMessage("Dungeon Finder: Group proposal failed."); break;
-        case 1: { lfgState_ = LfgState::InDungeon; lfgProposalId_ = 0;
-            std::string dName = owner_.getLfgDungeonName(dungeonId);
-            owner_.addSystemChatMessage(dName.empty() ? "Dungeon Finder: Group found! Entering dungeon..." : "Dungeon Finder: Group found for " + dName + "! Entering dungeon..."); break; }
-        case 2: { lfgState_ = LfgState::Proposal;
-            std::string dName = owner_.getLfgDungeonName(dungeonId);
-            owner_.addSystemChatMessage(dName.empty() ? "Dungeon Finder: A group has been found. Accept or decline." : "Dungeon Finder: A group has been found for " + dName + ". Accept or decline."); break; }
-        default: break;
-    }
-}
-
-void SocialHandler::handleLfgRoleCheckUpdate(network::Packet& packet) {
-    if (!packet.hasRemaining(6)) return;
-    packet.readUInt32();
-    uint8_t roleCheckState = packet.readUInt8();
-    packet.readUInt8();
-    if (roleCheckState == 1) lfgState_ = LfgState::Queued;
-    else if (roleCheckState == 3) { lfgState_ = LfgState::None; owner_.addUIError("Dungeon Finder: Role check failed — missing required role."); owner_.addSystemChatMessage("Dungeon Finder: Role check failed — missing required role."); }
-    else if (roleCheckState == 2) { lfgState_ = LfgState::RoleCheck; owner_.addSystemChatMessage("Dungeon Finder: Performing role check..."); }
-}
-
-void SocialHandler::handleLfgUpdatePlayer(network::Packet& packet) {
-    if (!packet.hasRemaining(1)) return;
-    uint8_t updateType = packet.readUInt8();
-    bool hasExtra = (updateType != 0 && updateType != 1 && updateType != 15 && updateType != 17 && updateType != 18);
-    if (!hasExtra || !packet.hasRemaining(3)) {
-        switch (updateType) {
-            case 8:  lfgState_ = LfgState::None; owner_.addSystemChatMessage("Dungeon Finder: Removed from queue."); break;
-            case 9:  lfgState_ = LfgState::Queued; owner_.addSystemChatMessage("Dungeon Finder: Proposal failed — re-queuing."); break;
-            case 10: lfgState_ = LfgState::Queued; owner_.addSystemChatMessage("Dungeon Finder: A member declined the proposal."); break;
-            case 15: lfgState_ = LfgState::None; owner_.addSystemChatMessage("Dungeon Finder: Left the queue."); break;
-            case 18: lfgState_ = LfgState::None; owner_.addSystemChatMessage("Dungeon Finder: Your group disbanded."); break;
-            default: break;
-        }
-        return;
-    }
-    packet.readUInt8(); packet.readUInt8(); packet.readUInt8();
-    if (packet.hasRemaining(1)) {
-        uint8_t count = packet.readUInt8();
-        for (uint8_t i = 0; i < count && packet.getRemainingSize() >= 4; ++i) {
-            uint32_t dungeonEntry = packet.readUInt32();
-            if (i == 0) lfgDungeonId_ = dungeonEntry;
-        }
-    }
-    switch (updateType) {
-        case 6:  lfgState_ = LfgState::Queued; owner_.addSystemChatMessage("Dungeon Finder: You have joined the queue."); break;
-        case 11: lfgState_ = LfgState::Proposal; owner_.addSystemChatMessage("Dungeon Finder: A group has been found!"); break;
-        case 12: lfgState_ = LfgState::Queued; owner_.addSystemChatMessage("Dungeon Finder: Added to queue."); break;
-        case 14: lfgState_ = LfgState::InDungeon; break;
-        default: break;
-    }
-}
-
-void SocialHandler::handleLfgPlayerReward(network::Packet& packet) {
-    if (!packet.hasRemaining( 13)) return;
-    packet.readUInt32(); packet.readUInt32(); packet.readUInt8();
-    uint32_t money = packet.readUInt32();
-    uint32_t xp = packet.readUInt32();
-    uint32_t gold = money / 10000, silver = (money % 10000) / 100, copper = money % 100;
-    char moneyBuf[64];
-    if (gold > 0) snprintf(moneyBuf, sizeof(moneyBuf), "%ug %us %uc", gold, silver, copper);
-    else if (silver > 0) snprintf(moneyBuf, sizeof(moneyBuf), "%us %uc", silver, copper);
-    else snprintf(moneyBuf, sizeof(moneyBuf), "%uc", copper);
-    std::string rewardMsg = std::string("Dungeon Finder reward: ") + moneyBuf + ", " + std::to_string(xp) + " XP";
-    if (packet.hasRemaining( 4)) {
-        uint32_t rewardCount = packet.readUInt32();
-        for (uint32_t i = 0; i < rewardCount && packet.hasRemaining( 9); ++i) {
-            uint32_t itemId = packet.readUInt32();
-            uint32_t itemCount = packet.readUInt32();
-            packet.readUInt8();
-            if (i == 0) {
-                std::string itemLabel = "item #" + std::to_string(itemId);
-                uint32_t lfgItemQuality = 1;
-                if (const ItemQueryResponseData* info = owner_.getItemInfo(itemId)) {
-                    if (!info->name.empty()) itemLabel = info->name;
-                    lfgItemQuality = info->quality;
-                }
-                rewardMsg += ", " + buildItemLink(itemId, lfgItemQuality, itemLabel);
-                if (itemCount > 1) rewardMsg += " x" + std::to_string(itemCount);
-            }
-        }
-    }
-    owner_.addSystemChatMessage(rewardMsg);
-    lfgState_ = LfgState::FinishedDungeon;
-}
-
-void SocialHandler::handleLfgBootProposalUpdate(network::Packet& packet) {
-    if (!packet.hasRemaining( 23)) return;
-    bool inProgress = packet.readUInt8() != 0;
-    packet.readUInt8(); packet.readUInt8();
-    uint32_t totalVotes = packet.readUInt32();
-    uint32_t bootVotes = packet.readUInt32();
-    uint32_t timeLeft = packet.readUInt32();
-    uint32_t votesNeeded = packet.readUInt32();
-    lfgBootVotes_ = bootVotes; lfgBootTotal_ = totalVotes;
-    lfgBootTimeLeft_ = timeLeft; lfgBootNeeded_ = votesNeeded;
-    if (packet.getReadPos() < packet.getSize()) lfgBootReason_ = packet.readString();
-    if (packet.getReadPos() < packet.getSize()) lfgBootTargetName_ = packet.readString();
-    if (inProgress) { lfgState_ = LfgState::Boot; }
-    else {
-        const bool bootPassed = (bootVotes >= votesNeeded);
-        lfgBootVotes_ = lfgBootTotal_ = lfgBootTimeLeft_ = lfgBootNeeded_ = 0;
-        lfgBootTargetName_.clear(); lfgBootReason_.clear();
-        lfgState_ = LfgState::InDungeon;
-        owner_.addSystemChatMessage(bootPassed ? "Dungeon Finder: Vote kick passed — member removed." : "Dungeon Finder: Vote kick failed.");
-    }
-}
-
-void SocialHandler::handleLfgTeleportDenied(network::Packet& packet) {
-    if (!packet.hasRemaining(1)) return;
-    uint8_t reason = packet.readUInt8();
-    owner_.addSystemChatMessage(std::string("Dungeon Finder: ") + lfgTeleportDeniedString(reason));
-}
-
-// ============================================================
-// LFG Outgoing Packets
-// ============================================================
-
-void SocialHandler::lfgJoin(uint32_t dungeonId, uint8_t roles) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_LFG_JOIN));
-    pkt.writeUInt8(roles); pkt.writeUInt8(0); pkt.writeUInt8(0);
-    pkt.writeUInt8(1); pkt.writeUInt32(dungeonId); pkt.writeString("");
-    owner_.socket->send(pkt);
-}
-
-void SocialHandler::lfgLeave() {
-    if (!owner_.socket) return;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_LFG_LEAVE));
-    pkt.writeUInt32(0); pkt.writeUInt32(0); pkt.writeUInt32(0);
-    owner_.socket->send(pkt);
-    lfgState_ = LfgState::None;
-}
-
-void SocialHandler::lfgSetRoles(uint8_t roles) {
-    if (owner_.getState() != WorldState::IN_WORLD || !owner_.socket) return;
-    const uint32_t wire = wireOpcode(Opcode::CMSG_LFG_SET_ROLES);
-    if (wire == 0xFFFF) return;
-    network::Packet pkt(static_cast<uint16_t>(wire));
-    pkt.writeUInt8(roles);
-    owner_.socket->send(pkt);
-}
-
-void SocialHandler::lfgAcceptProposal(uint32_t proposalId, bool accept) {
-    if (!owner_.socket) return;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_LFG_PROPOSAL_RESULT));
-    pkt.writeUInt32(proposalId); pkt.writeUInt8(accept ? 1 : 0);
-    owner_.socket->send(pkt);
-}
-
-void SocialHandler::lfgTeleport(bool toLfgDungeon) {
-    if (!owner_.socket) return;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_LFG_TELEPORT));
-    pkt.writeUInt8(toLfgDungeon ? 0 : 1);
-    owner_.socket->send(pkt);
-}
-
-void SocialHandler::lfgSetBootVote(bool vote) {
-    if (!owner_.socket) return;
-    uint16_t wireOp = wireOpcode(Opcode::CMSG_LFG_SET_BOOT_VOTE);
-    if (wireOp == 0xFFFF) return;
-    network::Packet pkt(wireOp);
-    pkt.writeUInt8(vote ? 1 : 0);
-    owner_.socket->send(pkt);
-}
-
-// ============================================================
-// Arena Handlers
-// ============================================================
-
-void SocialHandler::handleArenaTeamCommandResult(network::Packet& packet) {
-    if (!packet.hasRemaining(8)) return;
-    uint32_t command = packet.readUInt32();
-    std::string name = packet.readString();
-    uint32_t error = packet.readUInt32();
-    static const char* commands[] = {"create","invite","leave","remove","disband","leader"};
-    std::string cmdName = (command < 6) ? commands[command] : "unknown";
-    if (error == 0) owner_.addSystemChatMessage("Arena team " + cmdName + " successful" + (name.empty() ? "." : ": " + name));
-    else owner_.addSystemChatMessage("Arena team " + cmdName + " failed" + (name.empty() ? "." : " for " + name + "."));
-}
-
-void SocialHandler::handleArenaTeamQueryResponse(network::Packet& packet) {
-    if (!packet.hasRemaining(4)) return;
-    uint32_t teamId = packet.readUInt32();
-    std::string teamName = packet.readString();
-    uint32_t teamType = 0;
-    if (packet.hasRemaining(4)) teamType = packet.readUInt32();
-    for (auto& s : arenaTeamStats_) { if (s.teamId == teamId) { s.teamName = teamName; s.teamType = teamType; return; } }
-    ArenaTeamStats stub; stub.teamId = teamId; stub.teamName = teamName; stub.teamType = teamType;
-    arenaTeamStats_.push_back(std::move(stub));
-}
-
-void SocialHandler::handleArenaTeamRoster(network::Packet& packet) {
-    if (!packet.hasRemaining(9)) return;
-    uint32_t teamId = packet.readUInt32();
-    packet.readUInt8();
-    uint32_t memberCount = std::min(packet.readUInt32(), 100u);
-    ArenaTeamRoster roster; roster.teamId = teamId; roster.members.reserve(memberCount);
-    for (uint32_t i = 0; i < memberCount; ++i) {
-        if (!packet.hasRemaining(12)) break;
-        ArenaTeamMember m;
-        m.guid = packet.readUInt64(); m.online = (packet.readUInt8() != 0); m.name = packet.readString();
-        if (!packet.hasRemaining(20)) break;
-        m.weekGames = packet.readUInt32(); m.weekWins = packet.readUInt32();
-        m.seasonGames = packet.readUInt32(); m.seasonWins = packet.readUInt32(); m.personalRating = packet.readUInt32();
-        if (packet.hasRemaining(8)) { packet.readFloat(); packet.readFloat(); }
-        roster.members.push_back(std::move(m));
-    }
-    for (auto& r : arenaTeamRosters_) { if (r.teamId == teamId) { r = std::move(roster); return; } }
-    arenaTeamRosters_.push_back(std::move(roster));
-}
-
-void SocialHandler::handleArenaTeamInvite(network::Packet& packet) {
-    std::string playerName = packet.readString();
-    std::string teamName = packet.readString();
-    owner_.addSystemChatMessage(playerName + " has invited you to join " + teamName + ".");
-}
-
-void SocialHandler::handleArenaTeamEvent(network::Packet& packet) {
-    if (!packet.hasRemaining(1)) return;
-    uint8_t event = packet.readUInt8();
-    uint8_t strCount = 0;
-    if (packet.hasRemaining(1)) strCount = packet.readUInt8();
-    std::string param1, param2;
-    if (strCount >= 1 && packet.getSize() > packet.getReadPos()) param1 = packet.readString();
-    if (strCount >= 2 && packet.getSize() > packet.getReadPos()) param2 = packet.readString();
-    std::string msg;
-    switch (event) {
-        case 0: msg = param1.empty() ? "A player has joined your arena team." : param1 + " has joined your arena team."; break;
-        case 1: msg = param1.empty() ? "A player has left the arena team." : param1 + " has left the arena team."; break;
-        case 2: msg = (!param1.empty() && !param2.empty()) ? param1 + " has been removed from the arena team by " + param2 + "." : "A player has been removed from the arena team."; break;
-        case 3: msg = param1.empty() ? "The arena team captain has changed." : param1 + " is now the arena team captain."; break;
-        case 4: msg = "Your arena team has been disbanded."; break;
-        case 5: msg = param1.empty() ? "Your arena team has been created." : "Arena team \"" + param1 + "\" has been created."; break;
-        default: msg = "Arena team event " + std::to_string(event); if (!param1.empty()) msg += ": " + param1; break;
-    }
-    owner_.addSystemChatMessage(msg);
-}
-
-void SocialHandler::handleArenaTeamStats(network::Packet& packet) {
-    if (!packet.hasRemaining(28)) return;
-    ArenaTeamStats stats;
-    stats.teamId = packet.readUInt32(); stats.rating = packet.readUInt32();
-    stats.weekGames = packet.readUInt32(); stats.weekWins = packet.readUInt32();
-    stats.seasonGames = packet.readUInt32(); stats.seasonWins = packet.readUInt32();
-    stats.rank = packet.readUInt32();
-    for (auto& s : arenaTeamStats_) {
-        if (s.teamId == stats.teamId) { stats.teamName = std::move(s.teamName); stats.teamType = s.teamType; s = std::move(stats); return; }
-    }
-    arenaTeamStats_.push_back(std::move(stats));
-}
-
-void SocialHandler::requestArenaTeamRoster(uint32_t teamId) {
-    if (!owner_.socket) return;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_ARENA_TEAM_ROSTER));
-    pkt.writeUInt32(teamId);
-    owner_.socket->send(pkt);
-}
-
-void SocialHandler::handleArenaError(network::Packet& packet) {
-    if (!packet.hasRemaining(4)) return;
-    uint32_t error = packet.readUInt32();
-    std::string msg;
-    switch (error) {
-        case 1: msg = "The other team is not big enough."; break;
-        case 2: msg = "That team is full."; break;
-        case 3: msg = "Not enough members to start."; break;
-        case 4: msg = "Too many members."; break;
-        default: msg = "Arena error (code " + std::to_string(error) + ")"; break;
-    }
-    owner_.addSystemChatMessage(msg);
-}
-
-void SocialHandler::handlePvpLogData(network::Packet& packet) {
-    auto remaining = [&]() { return packet.getRemainingSize(); };
-    if (remaining() < 1) return;
-    bgScoreboard_ = BgScoreboardData{};
-    bgScoreboard_.isArena = (packet.readUInt8() != 0);
-    if (bgScoreboard_.isArena) {
-        for (int t = 0; t < 2; ++t) {
-            if (remaining() < 20) { packet.skipAll(); return; }
-            bgScoreboard_.arenaTeams[t].ratingChange = packet.readUInt32();
-            bgScoreboard_.arenaTeams[t].newRating = packet.readUInt32();
-            packet.readUInt32(); packet.readUInt32(); packet.readUInt32();
-            bgScoreboard_.arenaTeams[t].teamName = remaining() > 0 ? packet.readString() : "";
-        }
-    }
-    if (remaining() < 4) return;
-    uint32_t playerCount = packet.readUInt32();
-    bgScoreboard_.players.reserve(playerCount);
-    for (uint32_t i = 0; i < playerCount && remaining() >= 13; ++i) {
-        BgPlayerScore ps;
-        ps.guid = packet.readUInt64(); ps.team = packet.readUInt8();
-        ps.killingBlows = packet.readUInt32(); ps.honorableKills = packet.readUInt32();
-        ps.deaths = packet.readUInt32(); ps.bonusHonor = packet.readUInt32();
-        { auto ent = owner_.getEntityManager().getEntity(ps.guid);
-          if (ent && (ent->getType() == game::ObjectType::PLAYER || ent->getType() == game::ObjectType::UNIT))
-              { auto u = std::static_pointer_cast<game::Unit>(ent); if (!u->getName().empty()) ps.name = u->getName(); } }
-        if (remaining() < 4) { bgScoreboard_.players.push_back(std::move(ps)); break; }
-        uint32_t statCount = packet.readUInt32();
-        for (uint32_t s = 0; s < statCount && remaining() >= 5; ++s) {
-            std::string fieldName;
-            while (remaining() > 0) { char c = static_cast<char>(packet.readUInt8()); if (c == '\0') break; fieldName += c; }
-            uint32_t val = (remaining() >= 4) ? packet.readUInt32() : 0;
-            ps.bgStats.emplace_back(std::move(fieldName), val);
-        }
-        bgScoreboard_.players.push_back(std::move(ps));
-    }
-    if (remaining() >= 1) {
-        bgScoreboard_.hasWinner = (packet.readUInt8() != 0);
-        if (bgScoreboard_.hasWinner && remaining() >= 1) bgScoreboard_.winner = packet.readUInt8();
-    }
-}
-
-void SocialHandler::updateLogoutCountdown(float deltaTime) {
-    if (loggingOut_ && logoutCountdown_ > 0.0f) {
-        logoutCountdown_ -= deltaTime;
-        if (logoutCountdown_ < 0.0f) logoutCountdown_ = 0.0f;
-    }
-}
-
-void SocialHandler::resetTransferState() {
-    encounterUnitGuids_.fill(0);
-    raidTargetGuids_.fill(0);
-}
-
-// ============================================================
-// Moved opcode handlers (from GameHandler::registerOpcodeHandlers)
-// ============================================================
-
-void SocialHandler::handleInitializeFactions(network::Packet& packet) {
-    if (!packet.hasRemaining(4)) return;
-    uint32_t count = packet.readUInt32();
-    size_t needed = static_cast<size_t>(count) * 5;
-    if (!packet.hasRemaining(needed)) { packet.skipAll(); return; }
-    owner_.initialFactions_.clear();
-    owner_.initialFactions_.reserve(count);
-    for (uint32_t i = 0; i < count; ++i) {
-        GameHandler::FactionStandingInit fs{};
-        fs.flags = packet.readUInt8();
-        fs.standing = static_cast<int32_t>(packet.readUInt32());
-        owner_.initialFactions_.push_back(fs);
-    }
-}
-
-void SocialHandler::handleSetFactionStanding(network::Packet& packet) {
-    if (!packet.hasRemaining(5)) return;
-    /*uint8_t showVisual =*/ packet.readUInt8();
-    uint32_t count = packet.readUInt32();
-    count = std::min(count, 128u);
-    owner_.loadFactionNameCache();
-    for (uint32_t i = 0; i < count && packet.hasRemaining(8); ++i) {
-        uint32_t factionId = packet.readUInt32();
-        int32_t  standing  = static_cast<int32_t>(packet.readUInt32());
-        int32_t  oldStanding = 0;
-        auto it = owner_.factionStandings_.find(factionId);
-        if (it != owner_.factionStandings_.end()) oldStanding = it->second;
-        owner_.factionStandings_[factionId] = standing;
-        int32_t delta = standing - oldStanding;
-        if (delta != 0) {
-            std::string name = owner_.getFactionName(factionId);
-            char buf[256];
-            std::snprintf(buf, sizeof(buf), "Reputation with %s %s by %d.",
-                          name.c_str(), delta > 0 ? "increased" : "decreased", std::abs(delta));
-            owner_.addSystemChatMessage(buf);
-            owner_.watchedFactionId_ = factionId;
-            if (owner_.repChangeCallback_) owner_.repChangeCallback_(name, delta, standing);
-            // These events fire unconditionally on any rep change (not gated by callback).
-            owner_.fireAddonEvent("UPDATE_FACTION", {});
-            owner_.fireAddonEvent("CHAT_MSG_COMBAT_FACTION_CHANGE", {std::string(buf)});
-        }
-    }
-}
-
-void SocialHandler::handleSetFactionAtWar(network::Packet& packet) {
-    if (!packet.hasRemaining(5)) { packet.skipAll(); return; }
-    uint32_t repListId = packet.readUInt32();
-    uint8_t  setAtWar  = packet.readUInt8();
-    if (repListId < owner_.initialFactions_.size()) {
-        if (setAtWar)
-            owner_.initialFactions_[repListId].flags |=  GameHandler::FACTION_FLAG_AT_WAR;
-        else
-            owner_.initialFactions_[repListId].flags &= ~GameHandler::FACTION_FLAG_AT_WAR;
-    }
-}
-
-void SocialHandler::handleSetFactionVisible(network::Packet& packet) {
-    if (!packet.hasRemaining(5)) { packet.skipAll(); return; }
-    uint32_t repListId = packet.readUInt32();
-    uint8_t  visible   = packet.readUInt8();
-    if (repListId < owner_.initialFactions_.size()) {
-        if (visible)
-            owner_.initialFactions_[repListId].flags |=  GameHandler::FACTION_FLAG_VISIBLE;
-        else
-            owner_.initialFactions_[repListId].flags &= ~GameHandler::FACTION_FLAG_VISIBLE;
-    }
-}
-
-void SocialHandler::handleGroupSetLeader(network::Packet& packet) {
-    if (!packet.hasData()) return;
-    std::string leaderName = packet.readString();
-    auto& pd = mutablePartyData();
-    for (const auto& m : pd.members) {
-        if (m.name == leaderName) { pd.leaderGuid = m.guid; break; }
-    }
-    if (!leaderName.empty())
-        owner_.addSystemChatMessage(leaderName + " is now the group leader.");
-    owner_.fireAddonEvent("PARTY_LEADER_CHANGED", {});
-    owner_.fireAddonEvent("GROUP_ROSTER_UPDATE", {});
-}
-
-// ============================================================
-// Minimap Ping
-// ============================================================
-
-void SocialHandler::sendMinimapPing(float wowX, float wowY) {
-    if (owner_.state != WorldState::IN_WORLD) return;
-
-    // MSG_MINIMAP_PING (CMSG direction): float posX + float posY
-    // Server convention: posX = east/west axis = canonical Y (west)
-    //                    posY = north/south axis = canonical X (north)
-    const float serverX = wowY;  // canonical Y (west) → server posX
-    const float serverY = wowX;  // canonical X (north) → server posY
-
-    network::Packet pkt(wireOpcode(Opcode::MSG_MINIMAP_PING));
-    pkt.writeFloat(serverX);
-    pkt.writeFloat(serverY);
-    owner_.socket->send(pkt);
-
-    // Add ping locally so the sender sees their own ping immediately
-    GameHandler::MinimapPing localPing;
-    localPing.senderGuid = owner_.activeCharacterGuid_;
-    localPing.wowX       = wowX;
-    localPing.wowY       = wowY;
-    localPing.age        = 0.0f;
-    owner_.minimapPings_.push_back(localPing);
-}
-
-// ============================================================
-// Summon Request
-// ============================================================
-
-void SocialHandler::handleSummonRequest(network::Packet& packet) {
-    if (!packet.hasRemaining(16)) return;
-
-    owner_.summonerGuid_        = packet.readUInt64();
-    uint32_t zoneId             = packet.readUInt32();
-    uint32_t timeoutMs          = packet.readUInt32();
-    owner_.summonTimeoutSec_    = timeoutMs / 1000.0f;
-    owner_.pendingSummonRequest_= true;
-
-    owner_.summonerName_.clear();
-    if (auto* unit = owner_.getUnitByGuid(owner_.summonerGuid_)) {
-        owner_.summonerName_ = unit->getName();
-    }
-    if (owner_.summonerName_.empty()) {
-        owner_.summonerName_ = owner_.lookupName(owner_.summonerGuid_);
-    }
-    if (owner_.summonerName_.empty()) {
-        char tmp[32];
-        std::snprintf(tmp, sizeof(tmp), "0x%llX",
-                      static_cast<unsigned long long>(owner_.summonerGuid_));
-        owner_.summonerName_ = tmp;
-    }
-
-    std::string msg = owner_.summonerName_ + " is summoning you";
-    std::string zoneName = owner_.getAreaName(zoneId);
-    if (!zoneName.empty())
-        msg += " to " + zoneName;
-    msg += '.';
-    owner_.addSystemChatMessage(msg);
-    LOG_INFO("SMSG_SUMMON_REQUEST: summoner=", owner_.summonerName_,
-             " zoneId=", zoneId, " timeout=", owner_.summonTimeoutSec_, "s");
-    owner_.fireAddonEvent("CONFIRM_SUMMON", {});
-}
-
-void SocialHandler::acceptSummon() {
-    if (!owner_.pendingSummonRequest_ || !owner_.socket) return;
-    owner_.pendingSummonRequest_ = false;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_SUMMON_RESPONSE));
-    pkt.writeUInt8(1);  // 1 = accept
-    owner_.socket->send(pkt);
-    owner_.addSystemChatMessage("Accepting summon...");
-    LOG_INFO("Accepted summon from ", owner_.summonerName_);
-}
-
-void SocialHandler::declineSummon() {
-    if (!owner_.socket) return;
-    owner_.pendingSummonRequest_ = false;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_SUMMON_RESPONSE));
-    pkt.writeUInt8(0);  // 0 = decline
-    owner_.socket->send(pkt);
-    owner_.addSystemChatMessage("Summon declined.");
-}
-
-// ============================================================
-// Battlefield Manager
-// ============================================================
-
-void SocialHandler::acceptBfMgrInvite() {
-    if (!owner_.bfMgrInvitePending_ || owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    // CMSG_BATTLEFIELD_MGR_ENTRY_INVITE_RESPONSE: uint8 accepted = 1
-    network::Packet pkt(wireOpcode(Opcode::CMSG_BATTLEFIELD_MGR_ENTRY_INVITE_RESPONSE));
-    pkt.writeUInt8(1);  // accepted
-    owner_.socket->send(pkt);
-    owner_.bfMgrInvitePending_ = false;
-    LOG_INFO("acceptBfMgrInvite: sent CMSG_BATTLEFIELD_MGR_ENTRY_INVITE_RESPONSE accepted=1");
-}
-
-void SocialHandler::declineBfMgrInvite() {
-    if (!owner_.bfMgrInvitePending_ || owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    // CMSG_BATTLEFIELD_MGR_ENTRY_INVITE_RESPONSE: uint8 accepted = 0
-    network::Packet pkt(wireOpcode(Opcode::CMSG_BATTLEFIELD_MGR_ENTRY_INVITE_RESPONSE));
-    pkt.writeUInt8(0);  // declined
-    owner_.socket->send(pkt);
-    owner_.bfMgrInvitePending_ = false;
-    LOG_INFO("declineBfMgrInvite: sent CMSG_BATTLEFIELD_MGR_ENTRY_INVITE_RESPONSE accepted=0");
-}
-
-// ============================================================
-// Calendar
-// ============================================================
-
-void SocialHandler::requestCalendar() {
-    if (!owner_.isInWorld()) return;
-    // CMSG_CALENDAR_GET_CALENDAR has no payload
-    network::Packet pkt(wireOpcode(Opcode::CMSG_CALENDAR_GET_CALENDAR));
-    owner_.socket->send(pkt);
-    LOG_INFO("requestCalendar: sent CMSG_CALENDAR_GET_CALENDAR");
-    // Also request pending invite count
-    network::Packet numPkt(wireOpcode(Opcode::CMSG_CALENDAR_GET_NUM_PENDING));
-    owner_.socket->send(numPkt);
-}
-
-// ============================================================
-// Methods moved from GameHandler
-// ============================================================
-
-void SocialHandler::sendSetDifficulty(uint32_t difficulty) {
-    if (!owner_.isInWorld()) {
-        LOG_WARNING("Cannot change difficulty: not in world");
-        return;
-    }
-
-    network::Packet packet(wireOpcode(Opcode::CMSG_CHANGEPLAYER_DIFFICULTY));
-    packet.writeUInt32(difficulty);
-    owner_.socket->send(packet);
-    LOG_INFO("CMSG_CHANGEPLAYER_DIFFICULTY sent: difficulty=", difficulty);
-}
-
-void SocialHandler::toggleHelm() {
-    if (!owner_.isInWorld()) {
-        LOG_WARNING("Cannot toggle helm: not in world or not connected");
-        return;
-    }
-
-    owner_.helmVisible_ = !owner_.helmVisible_;
-    auto packet = ShowingHelmPacket::build(owner_.helmVisible_);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage(owner_.helmVisible_ ? "Helm is now visible." : "Helm is now hidden.");
-    LOG_INFO("Helm visibility toggled: ", owner_.helmVisible_);
-}
-
-void SocialHandler::toggleCloak() {
-    if (!owner_.isInWorld()) {
-        LOG_WARNING("Cannot toggle cloak: not in world or not connected");
-        return;
-    }
-
-    owner_.cloakVisible_ = !owner_.cloakVisible_;
-    auto packet = ShowingCloakPacket::build(owner_.cloakVisible_);
-    owner_.socket->send(packet);
-    owner_.addSystemChatMessage(owner_.cloakVisible_ ? "Cloak is now visible." : "Cloak is now hidden.");
-    LOG_INFO("Cloak visibility toggled: ", owner_.cloakVisible_);
-}
-
-void SocialHandler::setStandState(uint8_t standState) {
-    if (!owner_.isInWorld()) {
-        LOG_WARNING("Cannot change stand state: not in world or not connected");
-        return;
-    }
-
-    auto packet = StandStateChangePacket::build(standState);
-    owner_.socket->send(packet);
-    LOG_INFO("Changed stand state to: ", static_cast<int>(standState));
-}
-
-void SocialHandler::sendAlterAppearance(uint32_t hairStyle, uint32_t hairColor, uint32_t facialHair) {
-    if (!owner_.isInWorld()) return;
-    auto pkt = AlterAppearancePacket::build(hairStyle, hairColor, facialHair);
-    owner_.socket->send(pkt);
-    LOG_INFO("sendAlterAppearance: hair=", hairStyle, " color=", hairColor, " facial=", facialHair);
-}
-
-void SocialHandler::deleteGmTicket() {
-    if (!owner_.isInWorld()) return;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_GMTICKET_DELETETICKET));
-    owner_.socket->send(pkt);
-    owner_.gmTicketActive_ = false;
-    owner_.gmTicketText_.clear();
-    LOG_INFO("Deleting GM ticket");
-}
-
-void SocialHandler::requestGmTicket() {
-    if (!owner_.isInWorld()) return;
-    // CMSG_GMTICKET_GETTICKET has no payload — server responds with SMSG_GMTICKET_GETTICKET
-    network::Packet pkt(wireOpcode(Opcode::CMSG_GMTICKET_GETTICKET));
-    owner_.socket->send(pkt);
-    LOG_DEBUG("Sent CMSG_GMTICKET_GETTICKET — querying open ticket status");
-}
-
-} // namespace game
-} // namespace wowee
diff --git a/src/game/spell_handler.cpp b/src/game/spell_handler.cpp
deleted file mode 100644
index f458a610..00000000
--- a/src/game/spell_handler.cpp
+++ /dev/null
@@ -1,3330 +0,0 @@
-#include "game/spell_handler.hpp"
-#include "game/game_handler.hpp"
-#include "game/game_utils.hpp"
-#include "game/packet_parsers.hpp"
-#include "game/entity.hpp"
-#include "rendering/renderer.hpp"
-#include "audio/audio_coordinator.hpp"
-#include "audio/spell_sound_manager.hpp"
-#include "audio/combat_sound_manager.hpp"
-#include "core/application.hpp"
-#include "core/coordinates.hpp"
-#include "core/logger.hpp"
-#include "network/world_socket.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "pipeline/dbc_layout.hpp"
-#include "audio/ui_sound_manager.hpp"
-#include <algorithm>
-#include <cmath>
-#include <cstdio>
-#include <sstream>
-
-namespace wowee {
-namespace game {
-
-// Merge incoming cooldown with local remaining time — keeps local timer when
-// a stale/duplicate packet arrives after local countdown has progressed.
-static float mergeCooldownSeconds(float current, float incoming) {
-    constexpr float kEpsilon = 0.05f;
-    if (incoming <= 0.0f) return 0.0f;
-    if (current <= 0.0f) return incoming;
-    if (incoming > current + kEpsilon) return current;
-    return incoming;
-}
-
-static CombatTextEntry::Type combatTextTypeFromSpellMissInfo(uint8_t missInfo) {
-    switch (missInfo) {
-        case SpellMissInfo::MISS:    return CombatTextEntry::MISS;
-        case SpellMissInfo::DODGE:   return CombatTextEntry::DODGE;
-        case SpellMissInfo::PARRY:   return CombatTextEntry::PARRY;
-        case SpellMissInfo::BLOCK:   return CombatTextEntry::BLOCK;
-        case SpellMissInfo::EVADE:   return CombatTextEntry::EVADE;
-        case SpellMissInfo::IMMUNE:  return CombatTextEntry::IMMUNE;
-        case SpellMissInfo::DEFLECT: return CombatTextEntry::DEFLECT;
-        case SpellMissInfo::ABSORB:  return CombatTextEntry::ABSORB;
-        case SpellMissInfo::RESIST:  return CombatTextEntry::RESIST;
-        case SpellMissInfo::IMMUNE2:
-        case SpellMissInfo::IMMUNE3:
-            return CombatTextEntry::IMMUNE;
-        case SpellMissInfo::REFLECT: return CombatTextEntry::REFLECT;
-        default: return CombatTextEntry::MISS;
-    }
-}
-
-static audio::SpellSoundManager::MagicSchool schoolMaskToMagicSchool(uint32_t mask) {
-    if (mask & 0x04) return audio::SpellSoundManager::MagicSchool::FIRE;
-    if (mask & 0x10) return audio::SpellSoundManager::MagicSchool::FROST;
-    if (mask & 0x02) return audio::SpellSoundManager::MagicSchool::HOLY;
-    if (mask & 0x08) return audio::SpellSoundManager::MagicSchool::NATURE;
-    if (mask & 0x20) return audio::SpellSoundManager::MagicSchool::SHADOW;
-    if (mask & 0x40) return audio::SpellSoundManager::MagicSchool::ARCANE;
-    return audio::SpellSoundManager::MagicSchool::ARCANE;
-}
-
-
-static std::string displaySpellName(GameHandler& handler, uint32_t spellId) {
-    if (spellId == 0) return {};
-    const std::string& name = handler.getSpellName(spellId);
-    if (!name.empty()) return name;
-    return "spell " + std::to_string(spellId);
-}
-
-static std::string formatSpellNameList(GameHandler& handler,
-                                       const std::vector<uint32_t>& spellIds,
-                                       size_t maxShown = 3) {
-    if (spellIds.empty()) return {};
-
-    const size_t shownCount = std::min(spellIds.size(), maxShown);
-    std::ostringstream oss;
-    for (size_t i = 0; i < shownCount; ++i) {
-        if (i > 0) {
-            if (shownCount == 2) {
-                oss << " and ";
-            } else if (i == shownCount - 1) {
-                oss << ", and ";
-            } else {
-                oss << ", ";
-            }
-        }
-        oss << displaySpellName(handler, spellIds[i]);
-    }
-
-    if (spellIds.size() > shownCount) {
-        oss << ", and " << (spellIds.size() - shownCount) << " more";
-    }
-
-    return oss.str();
-}
-
-SpellHandler::SpellHandler(GameHandler& owner)
-    : owner_(owner) {}
-
-void SpellHandler::registerOpcodes(DispatchTable& table) {
-    table[Opcode::SMSG_INITIAL_SPELLS] = [this](network::Packet& packet) { handleInitialSpells(packet); };
-    table[Opcode::SMSG_CAST_FAILED] = [this](network::Packet& packet) { handleCastFailed(packet); };
-    table[Opcode::SMSG_SPELL_START] = [this](network::Packet& packet) { handleSpellStart(packet); };
-    table[Opcode::SMSG_SPELL_GO] = [this](network::Packet& packet) { handleSpellGo(packet); };
-    table[Opcode::SMSG_SPELL_COOLDOWN] = [this](network::Packet& packet) { handleSpellCooldown(packet); };
-    table[Opcode::SMSG_COOLDOWN_EVENT] = [this](network::Packet& packet) { handleCooldownEvent(packet); };
-    table[Opcode::SMSG_AURA_UPDATE] = [this](network::Packet& packet) {
-        handleAuraUpdate(packet, false);
-    };
-    table[Opcode::SMSG_AURA_UPDATE_ALL] = [this](network::Packet& packet) {
-        handleAuraUpdate(packet, true);
-    };
-    table[Opcode::SMSG_LEARNED_SPELL] = [this](network::Packet& packet) { handleLearnedSpell(packet); };
-    table[Opcode::SMSG_SUPERCEDED_SPELL] = [this](network::Packet& packet) { handleSupercededSpell(packet); };
-    table[Opcode::SMSG_REMOVED_SPELL] = [this](network::Packet& packet) { handleRemovedSpell(packet); };
-    table[Opcode::SMSG_SEND_UNLEARN_SPELLS] = [this](network::Packet& packet) { handleUnlearnSpells(packet); };
-    table[Opcode::SMSG_TALENTS_INFO] = [this](network::Packet& packet) { handleTalentsInfo(packet); };
-    table[Opcode::SMSG_ACHIEVEMENT_EARNED] = [this](network::Packet& packet) {
-        handleAchievementEarned(packet);
-    };
-    // SMSG_EQUIPMENT_SET_LIST — owned by InventoryHandler::registerOpcodes
-
-    // ---- Cast result / spell visuals / cooldowns / modifiers ----
-    table[Opcode::SMSG_CAST_RESULT] = [this](network::Packet& p) { handleCastResult(p); };
-    table[Opcode::SMSG_SPELL_FAILED_OTHER] = [this](network::Packet& p) { handleSpellFailedOther(p); };
-    table[Opcode::SMSG_CLEAR_COOLDOWN] = [this](network::Packet& p) { handleClearCooldown(p); };
-    table[Opcode::SMSG_MODIFY_COOLDOWN] = [this](network::Packet& p) { handleModifyCooldown(p); };
-    table[Opcode::SMSG_PLAY_SPELL_VISUAL] = [this](network::Packet& p) { handlePlaySpellVisual(p); };
-    table[Opcode::SMSG_SET_FLAT_SPELL_MODIFIER] = [this](network::Packet& p) { handleSpellModifier(p, true); };
-    table[Opcode::SMSG_SET_PCT_SPELL_MODIFIER]  = [this](network::Packet& p) { handleSpellModifier(p, false); };
-    table[Opcode::SMSG_SPELL_DELAYED] = [this](network::Packet& p) { handleSpellDelayed(p); };
-
-    // ---- Spell log / aura / dispel / totem / channel handlers ----
-    table[Opcode::SMSG_SPELLLOGMISS] = [this](network::Packet& p) { handleSpellLogMiss(p); };
-    table[Opcode::SMSG_SPELL_FAILURE] = [this](network::Packet& p) { handleSpellFailure(p); };
-    table[Opcode::SMSG_ITEM_COOLDOWN] = [this](network::Packet& p) { handleItemCooldown(p); };
-    table[Opcode::SMSG_DISPEL_FAILED] = [this](network::Packet& p) { handleDispelFailed(p); };
-    table[Opcode::SMSG_TOTEM_CREATED] = [this](network::Packet& p) { handleTotemCreated(p); };
-    table[Opcode::SMSG_PERIODICAURALOG] = [this](network::Packet& p) { handlePeriodicAuraLog(p); };
-    table[Opcode::SMSG_SPELLENERGIZELOG] = [this](network::Packet& p) { handleSpellEnergizeLog(p); };
-    table[Opcode::SMSG_INIT_EXTRA_AURA_INFO_OBSOLETE] = [this](network::Packet& p) { handleExtraAuraInfo(p, true); };
-    table[Opcode::SMSG_SET_EXTRA_AURA_INFO_OBSOLETE] = [this](network::Packet& p) { handleExtraAuraInfo(p, false); };
-    table[Opcode::SMSG_SPELLDISPELLOG] = [this](network::Packet& p) { handleSpellDispelLog(p); };
-    table[Opcode::SMSG_SPELLSTEALLOG] = [this](network::Packet& p) { handleSpellStealLog(p); };
-    table[Opcode::SMSG_SPELL_CHANCE_PROC_LOG] = [this](network::Packet& p) { handleSpellChanceProcLog(p); };
-    table[Opcode::SMSG_SPELLINSTAKILLLOG] = [this](network::Packet& p) { handleSpellInstaKillLog(p); };
-    table[Opcode::SMSG_SPELLLOGEXECUTE] = [this](network::Packet& p) { handleSpellLogExecute(p); };
-    table[Opcode::SMSG_CLEAR_EXTRA_AURA_INFO] = [this](network::Packet& p) { handleClearExtraAuraInfo(p); };
-    table[Opcode::SMSG_ITEM_ENCHANT_TIME_UPDATE] = [this](network::Packet& p) { handleItemEnchantTimeUpdate(p); };
-    table[Opcode::SMSG_RESUME_CAST_BAR] = [this](network::Packet& p) { handleResumeCastBar(p); };
-    table[Opcode::MSG_CHANNEL_START] = [this](network::Packet& p) { handleChannelStart(p); };
-    table[Opcode::MSG_CHANNEL_UPDATE] = [this](network::Packet& p) { handleChannelUpdate(p); };
-}
-
-// ============================================================
-// Public API
-// ============================================================
-
-bool SpellHandler::isGameObjectInteractionCasting() const {
-    return casting_ && currentCastSpellId_ == 0 && owner_.pendingGameObjectInteractGuid_ != 0;
-}
-
-bool SpellHandler::isTargetCasting() const {
-    return getUnitCastState(owner_.targetGuid) != nullptr;
-}
-
-uint32_t SpellHandler::getTargetCastSpellId() const {
-    auto* s = getUnitCastState(owner_.targetGuid);
-    return s ? s->spellId : 0;
-}
-
-float SpellHandler::getTargetCastProgress() const {
-    auto* s = getUnitCastState(owner_.targetGuid);
-    return (s && s->timeTotal > 0.0f)
-        ? (s->timeTotal - s->timeRemaining) / s->timeTotal : 0.0f;
-}
-
-float SpellHandler::getTargetCastTimeRemaining() const {
-    auto* s = getUnitCastState(owner_.targetGuid);
-    return s ? s->timeRemaining : 0.0f;
-}
-
-bool SpellHandler::isTargetCastInterruptible() const {
-    auto* s = getUnitCastState(owner_.targetGuid);
-    return s ? s->interruptible : true;
-}
-
-void SpellHandler::castSpell(uint32_t spellId, uint64_t targetGuid) {
-    LOG_DEBUG("castSpell: spellId=", spellId, " target=0x", std::hex, targetGuid, std::dec);
-    // Attack (6603) routes to auto-attack instead of cast
-    if (spellId == 6603) {
-        uint64_t target = targetGuid != 0 ? targetGuid : owner_.targetGuid;
-        if (target != 0) {
-            if (owner_.isAutoAttacking()) {
-                owner_.stopAutoAttack();
-            } else {
-                owner_.startAutoAttack(target);
-            }
-        }
-        return;
-    }
-
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-
-    // Casting any spell while mounted → dismount instead
-    if (owner_.isMounted()) {
-        owner_.dismount();
-        return;
-    }
-
-    if (casting_) {
-        // Spell queue: if we're within 400ms of the cast completing (and not channeling),
-        // store the spell so it fires automatically when the cast finishes.
-        if (!castIsChannel_ && castTimeRemaining_ > 0.0f && castTimeRemaining_ <= 0.4f) {
-            queuedSpellId_     = spellId;
-            queuedSpellTarget_ = targetGuid != 0 ? targetGuid : owner_.targetGuid;
-            LOG_INFO("Spell queue: queued spellId=", spellId, " (", castTimeRemaining_ * 1000.0f,
-                     "ms remaining)");
-        }
-        return;
-    }
-
-    // Stop movement before casting — servers reject cast-time spells while moving
-    const uint32_t moveFlags = owner_.movementInfo.flags;
-    const bool isMoving = (moveFlags & 0x0Fu) != 0; // FORWARD|BACKWARD|STRAFE_LEFT|STRAFE_RIGHT
-    if (isMoving) {
-        owner_.movementInfo.flags &= ~0x0Fu;
-        owner_.sendMovement(Opcode::MSG_MOVE_STOP);
-    }
-
-    uint64_t target = targetGuid != 0 ? targetGuid : owner_.targetGuid;
-    // Self-targeted spells like hearthstone should not send a target
-    if (spellId == 8690) target = 0;
-
-    // Track whether a spell-specific block already handled facing so the generic
-    // facing block below doesn't send redundant SET_FACING packets.
-    bool facingHandled = false;
-
-    // Warrior Charge (ranks 1-3): client-side range check + charge callback
-    if (spellId == 100 || spellId == 6178 || spellId == 11578) {
-        if (target == 0) {
-            owner_.addSystemChatMessage("You have no target.");
-            return;
-        }
-        auto entity = owner_.getEntityManager().getEntity(target);
-        if (!entity) {
-            owner_.addSystemChatMessage("You have no target.");
-            return;
-        }
-        float tx = entity->getX(), ty = entity->getY(), tz = entity->getZ();
-        float dx = tx - owner_.movementInfo.x;
-        float dy = ty - owner_.movementInfo.y;
-        float dz = tz - owner_.movementInfo.z;
-        float dist = std::sqrt(dx * dx + dy * dy + dz * dz);
-        if (dist < 8.0f) {
-            owner_.addSystemChatMessage("Target is too close.");
-            return;
-        }
-        if (dist > 25.0f) {
-            owner_.addSystemChatMessage("Out of range.");
-            return;
-        }
-        float yaw = std::atan2(-dy, dx);
-        owner_.movementInfo.orientation = yaw;
-        owner_.sendMovement(Opcode::MSG_MOVE_SET_FACING);
-        if (owner_.chargeCallback_) {
-            owner_.chargeCallback_(target, tx, ty, tz);
-        }
-        facingHandled = true;
-    }
-
-    // Instant melee abilities: client-side range + facing check
-    if (!facingHandled) {
-        owner_.loadSpellNameCache();
-        auto cacheIt = owner_.spellNameCache_.find(spellId);
-        bool isMeleeAbility = (cacheIt != owner_.spellNameCache_.end() && cacheIt->second.schoolMask == 1);
-        if (isMeleeAbility && target != 0) {
-            auto entity = owner_.getEntityManager().getEntity(target);
-            if (entity) {
-                float dx = entity->getX() - owner_.movementInfo.x;
-                float dy = entity->getY() - owner_.movementInfo.y;
-                float dz = entity->getZ() - owner_.movementInfo.z;
-                float dist = std::sqrt(dx * dx + dy * dy + dz * dz);
-                if (dist > 8.0f) {
-                    owner_.addSystemChatMessage("Out of range.");
-                    return;
-                }
-                float yaw = std::atan2(-dy, dx);
-                owner_.movementInfo.orientation = yaw;
-                owner_.sendMovement(Opcode::MSG_MOVE_SET_FACING);
-                facingHandled = true;
-            }
-        }
-    }
-
-    // Face the target before casting any targeted spell (server checks facing arc).
-    // Only send if a spell-specific block above didn't already handle facing,
-    // to avoid redundant SET_FACING packets that waste bandwidth.
-    if (!facingHandled && target != 0) {
-        auto entity = owner_.getEntityManager().getEntity(target);
-        if (entity) {
-            float dx = entity->getX() - owner_.movementInfo.x;
-            float dy = entity->getY() - owner_.movementInfo.y;
-            float lenSq = dx * dx + dy * dy;
-            if (lenSq > 0.01f) {
-                float canonYaw = std::atan2(-dy, dx);
-                owner_.movementInfo.orientation = canonYaw;
-                owner_.sendMovement(Opcode::MSG_MOVE_SET_FACING);
-            }
-        }
-    }
-    // Heartbeat ensures the server has the updated orientation before the cast packet.
-    if (target != 0) {
-        owner_.sendMovement(Opcode::MSG_MOVE_HEARTBEAT);
-    }
-
-    auto packet = owner_.packetParsers_
-        ? owner_.packetParsers_->buildCastSpell(spellId, target, ++castCount_)
-        : CastSpellPacket::build(spellId, target, ++castCount_);
-    LOG_DEBUG("CMSG_CAST_SPELL: spellId=", spellId, " target=0x", std::hex, target, std::dec,
-              " castCount=", static_cast<int>(castCount_), " packetSize=", packet.getSize());
-    owner_.socket->send(packet);
-    LOG_INFO("Casting spell: ", spellId, " on 0x", std::hex, target, std::dec);
-
-    // Fire UNIT_SPELLCAST_SENT for cast bar addons
-    if (owner_.addonEventCallback_) {
-        std::string targetName;
-        if (target != 0) targetName = owner_.lookupName(target);
-        owner_.addonEventCallback_("UNIT_SPELLCAST_SENT", {"player", targetName, std::to_string(spellId)});
-    }
-
-    // Optimistically start GCD immediately on cast
-    if (!isGCDActive()) {
-        gcdTotal_ = 1.5f;
-        gcdStartedAt_ = std::chrono::steady_clock::now();
-    }
-}
-
-void SpellHandler::cancelCast() {
-    if (!casting_) return;
-    // GameObject interaction cast is client-side timing only.
-    if (owner_.pendingGameObjectInteractGuid_ == 0 &&
-        owner_.state == WorldState::IN_WORLD && owner_.socket &&
-        currentCastSpellId_ != 0) {
-        auto packet = CancelCastPacket::build(currentCastSpellId_);
-        owner_.socket->send(packet);
-    }
-    owner_.pendingGameObjectInteractGuid_ = 0;
-    owner_.lastInteractedGoGuid_ = 0;
-    casting_ = false;
-    castIsChannel_ = false;
-    currentCastSpellId_ = 0;
-    castTimeRemaining_ = 0.0f;
-    craftQueueSpellId_ = 0;
-    craftQueueRemaining_ = 0;
-    queuedSpellId_ = 0;
-    queuedSpellTarget_ = 0;
-    if (owner_.addonEventCallback_)
-        owner_.addonEventCallback_("UNIT_SPELLCAST_STOP", {"player"});
-}
-
-void SpellHandler::startCraftQueue(uint32_t spellId, int count) {
-    craftQueueSpellId_ = spellId;
-    craftQueueRemaining_ = count;
-    castSpell(spellId, 0);
-}
-
-void SpellHandler::cancelCraftQueue() {
-    craftQueueSpellId_ = 0;
-    craftQueueRemaining_ = 0;
-}
-
-void SpellHandler::cancelAura(uint32_t spellId) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = CancelAuraPacket::build(spellId);
-    owner_.socket->send(packet);
-}
-
-float SpellHandler::getSpellCooldown(uint32_t spellId) const {
-    auto it = spellCooldowns_.find(spellId);
-    return (it != spellCooldowns_.end()) ? it->second : 0.0f;
-}
-
-void SpellHandler::learnTalent(uint32_t talentId, uint32_t requestedRank) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) {
-        LOG_WARNING("learnTalent: Not in world or no socket connection");
-        return;
-    }
-
-    LOG_INFO("Requesting to learn talent: id=", talentId, " rank=", requestedRank);
-
-    auto packet = LearnTalentPacket::build(talentId, requestedRank);
-    owner_.socket->send(packet);
-}
-
-void SpellHandler::switchTalentSpec(uint8_t newSpec) {
-    if (newSpec > 1) {
-        LOG_WARNING("Invalid talent spec: ", (int)newSpec);
-        return;
-    }
-
-    if (newSpec == activeTalentSpec_) {
-        LOG_INFO("Already on spec ", (int)newSpec);
-        return;
-    }
-
-    if (owner_.state == WorldState::IN_WORLD && owner_.socket) {
-        auto pkt = ActivateTalentGroupPacket::build(static_cast<uint32_t>(newSpec));
-        owner_.socket->send(pkt);
-        LOG_INFO("Sent CMSG_SET_ACTIVE_TALENT_GROUP_OBSOLETE: group=", (int)newSpec);
-    }
-    activeTalentSpec_ = newSpec;
-
-    LOG_INFO("Switched to talent spec ", (int)newSpec,
-             " (unspent=", (int)unspentTalentPoints_[newSpec],
-             ", learned=", learnedTalents_[newSpec].size(), ")");
-
-    std::string msg = "Switched to spec " + std::to_string(newSpec + 1);
-    if (unspentTalentPoints_[newSpec] > 0) {
-        msg += " (" + std::to_string(unspentTalentPoints_[newSpec]) + " unspent point";
-        if (unspentTalentPoints_[newSpec] > 1) msg += "s";
-        msg += ")";
-    }
-    owner_.addSystemChatMessage(msg);
-}
-
-void SpellHandler::confirmTalentWipe() {
-    if (!talentWipePending_) return;
-    talentWipePending_ = false;
-
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-
-    network::Packet pkt(wireOpcode(Opcode::MSG_TALENT_WIPE_CONFIRM));
-    pkt.writeUInt64(talentWipeNpcGuid_);
-    owner_.socket->send(pkt);
-
-    LOG_INFO("confirmTalentWipe: sent confirm for npc=0x", std::hex, talentWipeNpcGuid_, std::dec);
-    owner_.addSystemChatMessage("Talent reset confirmed. The server will update your talents.");
-    talentWipeNpcGuid_ = 0;
-    talentWipeCost_ = 0;
-}
-
-void SpellHandler::confirmPetUnlearn() {
-    if (!petUnlearnPending_) return;
-    petUnlearnPending_ = false;
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-
-    network::Packet pkt(wireOpcode(Opcode::CMSG_PET_UNLEARN_TALENTS));
-    owner_.socket->send(pkt);
-    LOG_INFO("confirmPetUnlearn: sent CMSG_PET_UNLEARN_TALENTS");
-    owner_.addSystemChatMessage("Pet talent reset confirmed.");
-    petUnlearnGuid_ = 0;
-    petUnlearnCost_ = 0;
-}
-
-uint32_t SpellHandler::findOnUseSpellId(uint32_t itemId) const {
-    if (auto* info = owner_.getItemInfo(itemId)) {
-        for (const auto& sp : info->spells) {
-            // spellTrigger 0 = "Use", 5 = "No Delay" — both are player-activated on-use effects
-            if (sp.spellId != 0 && (sp.spellTrigger == 0 || sp.spellTrigger == 5)) {
-                return sp.spellId;
-            }
-        }
-    }
-    return 0;
-}
-
-void SpellHandler::useItemBySlot(int backpackIndex) {
-    if (backpackIndex < 0 || backpackIndex >= owner_.inventory.getBackpackSize()) return;
-    const auto& slot = owner_.inventory.getBackpackSlot(backpackIndex);
-    if (slot.empty()) return;
-
-    uint64_t itemGuid = owner_.backpackSlotGuids_[backpackIndex];
-    if (itemGuid == 0) {
-        itemGuid = owner_.resolveOnlineItemGuid(slot.item.itemId);
-    }
-
-    if (itemGuid != 0 && owner_.state == WorldState::IN_WORLD && owner_.socket) {
-        uint32_t useSpellId = findOnUseSpellId(slot.item.itemId);
-        auto packet = owner_.packetParsers_
-            ? owner_.packetParsers_->buildUseItem(0xFF, static_cast<uint8_t>(Inventory::NUM_EQUIP_SLOTS + backpackIndex), itemGuid, useSpellId)
-            : UseItemPacket::build(0xFF, static_cast<uint8_t>(Inventory::NUM_EQUIP_SLOTS + backpackIndex), itemGuid, useSpellId);
-        owner_.socket->send(packet);
-    } else if (itemGuid == 0) {
-        owner_.addSystemChatMessage("Cannot use that item right now.");
-    }
-}
-
-void SpellHandler::useItemInBag(int bagIndex, int slotIndex) {
-    if (bagIndex < 0 || bagIndex >= owner_.inventory.NUM_BAG_SLOTS) return;
-    if (slotIndex < 0 || slotIndex >= owner_.inventory.getBagSize(bagIndex)) return;
-    const auto& slot = owner_.inventory.getBagSlot(bagIndex, slotIndex);
-    if (slot.empty()) return;
-
-    uint64_t itemGuid = 0;
-    uint64_t bagGuid = owner_.equipSlotGuids_[Inventory::FIRST_BAG_EQUIP_SLOT + bagIndex];
-    if (bagGuid != 0) {
-        auto it = owner_.containerContents_.find(bagGuid);
-        if (it != owner_.containerContents_.end() && slotIndex < static_cast<int>(it->second.numSlots)) {
-            itemGuid = it->second.slotGuids[slotIndex];
-        }
-    }
-    if (itemGuid == 0) {
-        itemGuid = owner_.resolveOnlineItemGuid(slot.item.itemId);
-    }
-
-    LOG_INFO("useItemInBag: bag=", bagIndex, " slot=", slotIndex, " itemId=", slot.item.itemId,
-             " itemGuid=0x", std::hex, itemGuid, std::dec);
-
-    if (itemGuid != 0 && owner_.state == WorldState::IN_WORLD && owner_.socket) {
-        uint32_t useSpellId = findOnUseSpellId(slot.item.itemId);
-        uint8_t wowBag = static_cast<uint8_t>(Inventory::FIRST_BAG_EQUIP_SLOT + bagIndex);
-        auto packet = owner_.packetParsers_
-            ? owner_.packetParsers_->buildUseItem(wowBag, static_cast<uint8_t>(slotIndex), itemGuid, useSpellId)
-            : UseItemPacket::build(wowBag, static_cast<uint8_t>(slotIndex), itemGuid, useSpellId);
-        LOG_INFO("useItemInBag: sending CMSG_USE_ITEM, bag=", (int)wowBag, " slot=", slotIndex,
-                 " packetSize=", packet.getSize());
-        owner_.socket->send(packet);
-    } else if (itemGuid == 0) {
-        LOG_WARNING("Use item in bag failed: missing item GUID for bag ", bagIndex, " slot ", slotIndex);
-        owner_.addSystemChatMessage("Cannot use that item right now.");
-    }
-}
-
-void SpellHandler::useItemById(uint32_t itemId) {
-    if (itemId == 0) return;
-    LOG_DEBUG("useItemById: searching for itemId=", itemId);
-    for (int i = 0; i < owner_.inventory.getBackpackSize(); i++) {
-        const auto& slot = owner_.inventory.getBackpackSlot(i);
-        if (!slot.empty() && slot.item.itemId == itemId) {
-            LOG_DEBUG("useItemById: found itemId=", itemId, " at backpack slot ", i);
-            useItemBySlot(i);
-            return;
-        }
-    }
-    for (int bag = 0; bag < owner_.inventory.NUM_BAG_SLOTS; bag++) {
-        int bagSize = owner_.inventory.getBagSize(bag);
-        for (int slot = 0; slot < bagSize; slot++) {
-            const auto& bagSlot = owner_.inventory.getBagSlot(bag, slot);
-            if (!bagSlot.empty() && bagSlot.item.itemId == itemId) {
-                LOG_DEBUG("useItemById: found itemId=", itemId, " in bag ", bag, " slot ", slot);
-                useItemInBag(bag, slot);
-                return;
-            }
-        }
-    }
-    LOG_WARNING("useItemById: itemId=", itemId, " not found in inventory");
-}
-
-const std::vector<SpellHandler::SpellBookTab>& SpellHandler::getSpellBookTabs() {
-    // Must be an instance member, not static — a static is shared across all
-    // SpellHandler instances, so switching characters with the same spell count
-    // would skip the rebuild and return the previous character's tabs.
-    if (lastSpellCount_ == knownSpells_.size() && !spellBookTabsDirty_)
-        return spellBookTabs_;
-    lastSpellCount_ = knownSpells_.size();
-    spellBookTabsDirty_ = false;
-    spellBookTabs_.clear();
-
-    static constexpr uint32_t SKILLLINE_CATEGORY_CLASS = 7;
-
-    std::map<uint32_t, std::vector<uint32_t>> bySkillLine;
-    std::vector<uint32_t> general;
-
-    for (uint32_t spellId : knownSpells_) {
-        auto slIt = owner_.spellToSkillLine_.find(spellId);
-        if (slIt != owner_.spellToSkillLine_.end()) {
-            uint32_t skillLineId = slIt->second;
-            auto catIt = owner_.skillLineCategories_.find(skillLineId);
-            if (catIt != owner_.skillLineCategories_.end() && catIt->second == SKILLLINE_CATEGORY_CLASS) {
-                bySkillLine[skillLineId].push_back(spellId);
-                continue;
-            }
-        }
-        general.push_back(spellId);
-    }
-
-    auto byName = [this](uint32_t a, uint32_t b) {
-        return owner_.getSpellName(a) < owner_.getSpellName(b);
-    };
-
-    if (!general.empty()) {
-        std::sort(general.begin(), general.end(), byName);
-        spellBookTabs_.push_back({"General", "Interface\\Icons\\INV_Misc_Book_09", std::move(general)});
-    }
-
-    std::vector<std::pair<std::string, std::vector<uint32_t>>> named;
-    for (auto& [skillLineId, spells] : bySkillLine) {
-        auto nameIt = owner_.skillLineNames_.find(skillLineId);
-        std::string tabName = (nameIt != owner_.skillLineNames_.end()) ? nameIt->second : "Unknown";
-        std::sort(spells.begin(), spells.end(), byName);
-        named.emplace_back(std::move(tabName), std::move(spells));
-    }
-    std::sort(named.begin(), named.end(), [](const auto& a, const auto& b) { return a.first < b.first; });
-
-    for (auto& [name, spells] : named) {
-        spellBookTabs_.push_back({std::move(name), "Interface\\Icons\\INV_Misc_Book_09", std::move(spells)});
-    }
-
-    return spellBookTabs_;
-}
-
-void SpellHandler::loadTalentDbc() {
-    if (talentDbcLoaded_) return;
-    talentDbcLoaded_ = true;
-
-    auto* am = owner_.services().assetManager;
-    if (!am || !am->isInitialized()) return;
-
-    // Load Talent.dbc
-    auto talentDbc = am->loadDBC("Talent.dbc");
-    if (talentDbc && talentDbc->isLoaded()) {
-        const auto* talL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("Talent") : nullptr;
-        const uint32_t tID = talL ? (*talL)["ID"] : 0;
-        const uint32_t tTabID = talL ? (*talL)["TabID"] : 1;
-        const uint32_t tRow = talL ? (*talL)["Row"] : 2;
-        const uint32_t tCol = talL ? (*talL)["Column"] : 3;
-        const uint32_t tRank0 = talL ? (*talL)["RankSpell0"] : 4;
-        const uint32_t tPrereq0 = talL ? (*talL)["PrereqTalent0"] : 9;
-        const uint32_t tPrereqR0 = talL ? (*talL)["PrereqRank0"] : 12;
-
-        uint32_t count = talentDbc->getRecordCount();
-        for (uint32_t i = 0; i < count; ++i) {
-            TalentEntry entry;
-            entry.talentId = talentDbc->getUInt32(i, tID);
-            if (entry.talentId == 0) continue;
-
-            entry.tabId = talentDbc->getUInt32(i, tTabID);
-            entry.row = static_cast<uint8_t>(talentDbc->getUInt32(i, tRow));
-            entry.column = static_cast<uint8_t>(talentDbc->getUInt32(i, tCol));
-
-            for (int r = 0; r < 5; ++r) {
-                entry.rankSpells[r] = talentDbc->getUInt32(i, tRank0 + r);
-            }
-
-            for (int p = 0; p < 3; ++p) {
-                entry.prereqTalent[p] = talentDbc->getUInt32(i, tPrereq0 + p);
-                entry.prereqRank[p] = static_cast<uint8_t>(talentDbc->getUInt32(i, tPrereqR0 + p));
-            }
-
-            entry.maxRank = 0;
-            for (int r = 0; r < 5; ++r) {
-                if (entry.rankSpells[r] != 0) {
-                    entry.maxRank = r + 1;
-                }
-            }
-
-            talentCache_[entry.talentId] = entry;
-        }
-        LOG_INFO("Loaded ", talentCache_.size(), " talents from Talent.dbc");
-    } else {
-        LOG_WARNING("Could not load Talent.dbc");
-    }
-
-    // Load TalentTab.dbc
-    auto tabDbc = am->loadDBC("TalentTab.dbc");
-    if (tabDbc && tabDbc->isLoaded()) {
-        const auto* ttL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("TalentTab") : nullptr;
-        // Cache field indices before the loop
-        const uint32_t ttIdField    = ttL ? (*ttL)["ID"]             : 0;
-        const uint32_t ttNameField  = ttL ? (*ttL)["Name"]           : 1;
-        const uint32_t ttClassField = ttL ? (*ttL)["ClassMask"]      : 20;
-        const uint32_t ttOrderField = ttL ? (*ttL)["OrderIndex"]     : 22;
-        const uint32_t ttBgField    = ttL ? (*ttL)["BackgroundFile"] : 23;
-
-        uint32_t count = tabDbc->getRecordCount();
-        for (uint32_t i = 0; i < count; ++i) {
-            TalentTabEntry entry;
-            entry.tabId = tabDbc->getUInt32(i, ttIdField);
-            if (entry.tabId == 0) continue;
-
-            entry.name = tabDbc->getString(i, ttNameField);
-            entry.classMask = tabDbc->getUInt32(i, ttClassField);
-            entry.orderIndex = static_cast<uint8_t>(tabDbc->getUInt32(i, ttOrderField));
-            entry.backgroundFile = tabDbc->getString(i, ttBgField);
-
-            talentTabCache_[entry.tabId] = entry;
-
-            if (talentTabCache_.size() <= 10) {
-                LOG_INFO("  Tab ", entry.tabId, ": ", entry.name, " (classMask=0x", std::hex, entry.classMask, std::dec, ")");
-            }
-        }
-        LOG_INFO("Loaded ", talentTabCache_.size(), " talent tabs from TalentTab.dbc");
-    } else {
-        LOG_WARNING("Could not load TalentTab.dbc");
-    }
-}
-
-void SpellHandler::updateTimers(float dt) {
-    // Tick down cast bar
-    if (casting_ && castTimeRemaining_ > 0.0f) {
-        castTimeRemaining_ -= dt;
-        if (castTimeRemaining_ < 0.0f) castTimeRemaining_ = 0.0f;
-    }
-    // Tick down spell cooldowns
-    for (auto it = spellCooldowns_.begin(); it != spellCooldowns_.end(); ) {
-        it->second -= dt;
-        if (it->second <= 0.0f) {
-            it = spellCooldowns_.erase(it);
-        } else {
-            ++it;
-        }
-    }
-    // Tick down unit cast states
-    for (auto it = unitCastStates_.begin(); it != unitCastStates_.end(); ) {
-        if (it->second.casting && it->second.timeRemaining > 0.0f) {
-            it->second.timeRemaining -= dt;
-            if (it->second.timeRemaining <= 0.0f) {
-                it->second.timeRemaining = 0.0f;
-                it->second.casting = false;
-                it = unitCastStates_.erase(it);
-                continue;
-            }
-        }
-        ++it;
-    }
-}
-
-// ============================================================
-// Packet handlers
-// ============================================================
-
-void SpellHandler::handleInitialSpells(network::Packet& packet) {
-    InitialSpellsData data;
-    if (!owner_.packetParsers_->parseInitialSpells(packet, data)) return;
-
-    knownSpells_ = {data.spellIds.begin(), data.spellIds.end()};
-
-    LOG_DEBUG("Initial spells include: 527=", knownSpells_.count(527u),
-              " 988=", knownSpells_.count(988u), " 1180=", knownSpells_.count(1180u));
-
-    // Ensure Attack (6603) and Hearthstone (8690) are always present
-    knownSpells_.insert(6603u);
-    knownSpells_.insert(8690u);
-
-    // Set initial cooldowns
-    for (const auto& cd : data.cooldowns) {
-        uint32_t effectiveMs = std::max(cd.cooldownMs, cd.categoryCooldownMs);
-        if (effectiveMs > 0) {
-            spellCooldowns_[cd.spellId] = effectiveMs / 1000.0f;
-        }
-    }
-
-    // Load saved action bar or use defaults
-    owner_.actionBar[0].type = ActionBarSlot::SPELL;
-    owner_.actionBar[0].id = 6603;  // Attack
-    owner_.actionBar[11].type = ActionBarSlot::SPELL;
-    owner_.actionBar[11].id = 8690;  // Hearthstone
-    owner_.loadCharacterConfig();
-
-    // Sync login-time cooldowns into action bar slot overlays
-    for (auto& slot : owner_.actionBar) {
-        if (slot.type == ActionBarSlot::SPELL && slot.id != 0) {
-            auto it = spellCooldowns_.find(slot.id);
-            if (it != spellCooldowns_.end() && it->second > 0.0f) {
-                slot.cooldownTotal     = it->second;
-                slot.cooldownRemaining = it->second;
-            }
-        } else if (slot.type == ActionBarSlot::ITEM && slot.id != 0) {
-            const auto* qi = owner_.getItemInfo(slot.id);
-            if (qi && qi->valid) {
-                for (const auto& sp : qi->spells) {
-                    if (sp.spellId == 0) continue;
-                    auto it = spellCooldowns_.find(sp.spellId);
-                    if (it != spellCooldowns_.end() && it->second > 0.0f) {
-                        slot.cooldownTotal     = it->second;
-                        slot.cooldownRemaining = it->second;
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    // Pre-load skill line DBCs
-    owner_.loadSkillLineDbc();
-    owner_.loadSkillLineAbilityDbc();
-
-    LOG_INFO("Learned ", knownSpells_.size(), " spells");
-
-    if (owner_.addonEventCallback_) {
-        owner_.addonEventCallback_("SPELLS_CHANGED", {});
-        owner_.addonEventCallback_("LEARNED_SPELL_IN_TAB", {});
-    }
-}
-
-void SpellHandler::handleCastFailed(network::Packet& packet) {
-    CastFailedData data;
-    bool ok = owner_.packetParsers_ ? owner_.packetParsers_->parseCastFailed(packet, data)
-                                    : CastFailedParser::parse(packet, data);
-    if (!ok) return;
-
-    casting_ = false;
-    castIsChannel_ = false;
-    currentCastSpellId_ = 0;
-    castTimeRemaining_ = 0.0f;
-    owner_.lastInteractedGoGuid_ = 0;
-    owner_.pendingGameObjectInteractGuid_ = 0;
-    craftQueueSpellId_ = 0;
-    craftQueueRemaining_ = 0;
-    queuedSpellId_ = 0;
-    queuedSpellTarget_ = 0;
-
-    // Stop precast sound
-    if (auto* ac = owner_.services().audioCoordinator) {
-        if (auto* ssm = ac->getSpellSoundManager()) {
-            ssm->stopPrecast();
-        }
-    }
-
-    // Show failure reason
-    int powerType = -1;
-    auto playerEntity = owner_.getEntityManager().getEntity(owner_.playerGuid);
-    if (auto playerUnit = std::dynamic_pointer_cast<Unit>(playerEntity)) {
-        powerType = playerUnit->getPowerType();
-    }
-    const char* reason = getSpellCastResultString(data.result, powerType);
-    std::string errMsg = reason ? reason
-                                : ("Spell cast failed (error " + std::to_string(data.result) + ")");
-    owner_.addUIError(errMsg);
-    MessageChatData msg;
-    msg.type = ChatType::SYSTEM;
-    msg.language = ChatLanguage::UNIVERSAL;
-    msg.message = errMsg;
-    owner_.addLocalChatMessage(msg);
-
-    if (auto* ac = owner_.services().audioCoordinator) {
-        if (auto* sfx = ac->getUiSoundManager())
-            sfx->playError();
-    }
-
-    if (owner_.addonEventCallback_) {
-        owner_.addonEventCallback_("UNIT_SPELLCAST_FAILED", {"player", std::to_string(data.spellId)});
-        owner_.addonEventCallback_("UNIT_SPELLCAST_STOP", {"player", std::to_string(data.spellId)});
-    }
-    if (owner_.spellCastFailedCallback_) owner_.spellCastFailedCallback_(data.spellId);
-}
-
-void SpellHandler::handleSpellStart(network::Packet& packet) {
-    SpellStartData data;
-    if (!owner_.packetParsers_->parseSpellStart(packet, data)) {
-        LOG_WARNING("Failed to parse SMSG_SPELL_START, size=", packet.getSize());
-        return;
-    }
-    LOG_DEBUG("SMSG_SPELL_START: caster=0x", std::hex, data.casterUnit, std::dec,
-              " spell=", data.spellId, " castTime=", data.castTime,
-              " target=0x", std::hex, data.targetGuid, std::dec);
-
-    // Classify spell targeting for animation selection:
-    //   DIRECTED — targets a specific other unit (Frostbolt, Heal)
-    //   OMNI     — self-cast or no explicit target (Arcane Explosion, buffs)
-    //   AREA     — ground-targeted AoE with no unit target (Blizzard, Rain of Fire)
-    auto classifyCast = [](uint64_t targetGuid, uint64_t casterGuid) -> SpellCastType {
-        if (targetGuid == 0)            return SpellCastType::AREA;
-        if (targetGuid == casterGuid)   return SpellCastType::OMNI;
-        return SpellCastType::DIRECTED;
-    };
-    const SpellCastType castType = classifyCast(data.targetGuid, data.casterUnit);
-
-    // Track cast bar for any non-player caster
-    if (data.casterUnit != owner_.playerGuid && data.castTime > 0) {
-        auto& s = unitCastStates_[data.casterUnit];
-        s.casting        = true;
-        s.isChannel      = false;
-        s.spellId        = data.spellId;
-        s.timeTotal      = data.castTime / 1000.0f;
-        s.timeRemaining  = s.timeTotal;
-        s.interruptible  = owner_.isSpellInterruptible(data.spellId);
-        s.castType       = castType;
-        if (owner_.spellCastAnimCallback_) {
-            owner_.spellCastAnimCallback_(data.casterUnit, true, false, castType);
-        }
-    }
-
-    // Player's own cast
-    if (data.casterUnit == owner_.playerGuid && data.castTime > 0) {
-        // Cancel pending GO retries
-        owner_.pendingGameObjectLootRetries_.erase(
-            std::remove_if(owner_.pendingGameObjectLootRetries_.begin(), owner_.pendingGameObjectLootRetries_.end(),
-                [](const GameHandler::PendingLootRetry&) { return true; }),
-            owner_.pendingGameObjectLootRetries_.end());
-
-        casting_ = true;
-        castIsChannel_ = false;
-        currentCastSpellId_ = data.spellId;
-        castTimeTotal_ = data.castTime / 1000.0f;
-        castTimeRemaining_ = castTimeTotal_;
-        if (owner_.addonEventCallback_) owner_.addonEventCallback_("CURRENT_SPELL_CAST_CHANGED", {});
-
-        // Play precast sound — skip profession/tradeskill spells
-        if (!owner_.isProfessionSpell(data.spellId)) {
-            if (auto* ac = owner_.services().audioCoordinator) {
-                if (auto* ssm = ac->getSpellSoundManager()) {
-                    owner_.loadSpellNameCache();
-                    auto it = owner_.spellNameCache_.find(data.spellId);
-                    auto school = (it != owner_.spellNameCache_.end() && it->second.schoolMask)
-                        ? schoolMaskToMagicSchool(it->second.schoolMask)
-                        : audio::SpellSoundManager::MagicSchool::ARCANE;
-                    ssm->playPrecast(school, audio::SpellSoundManager::SpellPower::MEDIUM);
-                }
-            }
-        }
-
-        if (owner_.spellCastAnimCallback_) {
-            owner_.spellCastAnimCallback_(owner_.playerGuid, true, false, castType);
-        }
-
-        // Hearthstone: pre-load terrain at bind point
-        const bool isHearthstone = (data.spellId == 6948 || data.spellId == 8690);
-        if (isHearthstone && owner_.hasHomeBind_ && owner_.hearthstonePreloadCallback_) {
-            owner_.hearthstonePreloadCallback_(owner_.homeBindMapId_, owner_.homeBindPos_.x, owner_.homeBindPos_.y, owner_.homeBindPos_.z);
-        }
-    }
-
-    // Fire UNIT_SPELLCAST_START
-    if (owner_.addonEventCallback_) {
-        std::string unitId = owner_.guidToUnitId(data.casterUnit);
-        if (!unitId.empty())
-            owner_.addonEventCallback_("UNIT_SPELLCAST_START", {unitId, std::to_string(data.spellId)});
-    }
-}
-
-void SpellHandler::handleSpellGo(network::Packet& packet) {
-    SpellGoData data;
-    if (!owner_.packetParsers_->parseSpellGo(packet, data)) return;
-
-    if (data.casterUnit == owner_.playerGuid) {
-        // Play cast-complete sound
-        if (!owner_.isProfessionSpell(data.spellId)) {
-            if (auto* ac = owner_.services().audioCoordinator) {
-                if (auto* ssm = ac->getSpellSoundManager()) {
-                    owner_.loadSpellNameCache();
-                    auto it = owner_.spellNameCache_.find(data.spellId);
-                    auto school = (it != owner_.spellNameCache_.end() && it->second.schoolMask)
-                        ? schoolMaskToMagicSchool(it->second.schoolMask)
-                        : audio::SpellSoundManager::MagicSchool::ARCANE;
-                    ssm->playCast(school);
-                }
-            }
-        }
-
-        // Instant melee abilities → trigger attack animation
-        uint32_t sid = data.spellId;
-        bool isMeleeAbility = false;
-        if (!owner_.isProfessionSpell(sid)) {
-            owner_.loadSpellNameCache();
-            auto cacheIt = owner_.spellNameCache_.find(sid);
-            if (cacheIt != owner_.spellNameCache_.end() && cacheIt->second.schoolMask == 1) {
-                isMeleeAbility = (currentCastSpellId_ != sid);
-            }
-        }
-        if (isMeleeAbility) {
-            if (owner_.meleeSwingCallback_) owner_.meleeSwingCallback_(sid);
-            if (auto* ac = owner_.services().audioCoordinator) {
-                if (auto* csm = ac->getCombatSoundManager()) {
-                    csm->playWeaponSwing(audio::CombatSoundManager::WeaponSize::MEDIUM, false);
-                    csm->playImpact(audio::CombatSoundManager::WeaponSize::MEDIUM,
-                                    audio::CombatSoundManager::ImpactType::FLESH, false);
-                }
-            }
-        }
-
-        const bool wasInTimedCast = casting_ && (data.spellId == currentCastSpellId_);
-
-        // Instant spell cast animation — if this wasn't a timed cast and isn't a
-        // melee ability, play a brief spell cast animation (one-shot)
-        if (!wasInTimedCast && !isMeleeAbility && !owner_.isProfessionSpell(data.spellId)) {
-            // Classify instant spell from SPELL_GO packet target info
-            SpellCastType goType = SpellCastType::OMNI;
-            if (data.targetGuid != 0 && data.targetGuid != data.casterUnit)
-                goType = SpellCastType::DIRECTED;
-            else if (data.targetGuid == 0 && data.hitCount > 1)
-                goType = SpellCastType::AREA;
-            if (owner_.spellCastAnimCallback_) {
-                owner_.spellCastAnimCallback_(owner_.playerGuid, true, false, goType);
-            }
-        }
-
-        LOG_WARNING("[GO-DIAG] SPELL_GO: spellId=", data.spellId,
-                    " casting=", casting_, " currentCast=", currentCastSpellId_,
-                    " wasInTimedCast=", wasInTimedCast,
-                    " lastGoGuid=0x", std::hex, owner_.lastInteractedGoGuid_,
-                    " pendingGoGuid=0x", owner_.pendingGameObjectInteractGuid_, std::dec);
-
-        casting_ = false;
-        castIsChannel_ = false;
-        currentCastSpellId_ = 0;
-        castTimeRemaining_ = 0.0f;
-
-        // Gather node looting: re-send CMSG_LOOT now that the cast completed.
-        if (wasInTimedCast && owner_.lastInteractedGoGuid_ != 0) {
-            LOG_WARNING("[GO-DIAG] Sending CMSG_LOOT for GO 0x", std::hex,
-                        owner_.lastInteractedGoGuid_, std::dec);
-            owner_.lootTarget(owner_.lastInteractedGoGuid_);
-            owner_.lastInteractedGoGuid_ = 0;
-        }
-        // Clear the GO interaction guard so future cancelCast() calls work
-        // normally. Without this, pendingGameObjectInteractGuid_ stays stale
-        // and suppresses CMSG_CANCEL_CAST for ALL subsequent spell casts.
-        owner_.pendingGameObjectInteractGuid_ = 0;
-
-        if (owner_.spellCastAnimCallback_) {
-            owner_.spellCastAnimCallback_(owner_.playerGuid, false, false, SpellCastType::OMNI);
-        }
-
-        if (owner_.addonEventCallback_)
-            owner_.addonEventCallback_("UNIT_SPELLCAST_STOP", {"player", std::to_string(data.spellId)});
-
-        // Spell queue: fire the next queued spell
-        if (queuedSpellId_ != 0) {
-            uint32_t nextSpell  = queuedSpellId_;
-            uint64_t nextTarget = queuedSpellTarget_;
-            queuedSpellId_     = 0;
-            queuedSpellTarget_ = 0;
-            LOG_INFO("Spell queue: firing queued spellId=", nextSpell);
-            castSpell(nextSpell, nextTarget);
-        }
-    } else {
-        // For non-player casters: if no tracked cast state exists, this was an
-        // instant cast — play a brief one-shot spell animation before stopping
-        auto castIt = unitCastStates_.find(data.casterUnit);
-        bool wasTrackedCast = (castIt != unitCastStates_.end());
-        // Classify NPC instant spell from SPELL_GO target info
-        SpellCastType npcGoType = SpellCastType::OMNI;
-        if (data.targetGuid != 0 && data.targetGuid != data.casterUnit)
-            npcGoType = SpellCastType::DIRECTED;
-        else if (data.targetGuid == 0 && data.hitCount > 1)
-            npcGoType = SpellCastType::AREA;
-        if (!wasTrackedCast && owner_.spellCastAnimCallback_) {
-            owner_.spellCastAnimCallback_(data.casterUnit, true, false, npcGoType);
-        }
-        if (owner_.spellCastAnimCallback_) {
-            owner_.spellCastAnimCallback_(data.casterUnit, false, false, SpellCastType::OMNI);
-        }
-        bool targetsPlayer = false;
-        for (const auto& tgt : data.hitTargets) {
-            if (tgt == owner_.playerGuid) { targetsPlayer = true; break; }
-        }
-        if (targetsPlayer) {
-            if (auto* ac = owner_.services().audioCoordinator) {
-                if (auto* ssm = ac->getSpellSoundManager()) {
-                    owner_.loadSpellNameCache();
-                    auto it = owner_.spellNameCache_.find(data.spellId);
-                    auto school = (it != owner_.spellNameCache_.end() && it->second.schoolMask)
-                        ? schoolMaskToMagicSchool(it->second.schoolMask)
-                        : audio::SpellSoundManager::MagicSchool::ARCANE;
-                    ssm->playCast(school);
-                }
-            }
-        }
-    }
-
-    // Clear unit cast bar
-    unitCastStates_.erase(data.casterUnit);
-
-    // Miss combat text
-    if (!data.missTargets.empty()) {
-        const uint64_t spellCasterGuid = data.casterUnit != 0 ? data.casterUnit : data.casterGuid;
-        const bool playerIsCaster = (spellCasterGuid == owner_.playerGuid);
-
-        for (const auto& m : data.missTargets) {
-            if (!playerIsCaster && m.targetGuid != owner_.playerGuid) {
-                continue;
-            }
-            CombatTextEntry::Type ct = combatTextTypeFromSpellMissInfo(m.missType);
-            owner_.addCombatText(ct, 0, data.spellId, playerIsCaster, 0, spellCasterGuid, m.targetGuid);
-        }
-    }
-
-    // Impact sound
-    bool playerIsHit = false;
-    bool playerHitEnemy = false;
-    for (const auto& tgt : data.hitTargets) {
-        if (tgt == owner_.playerGuid) { playerIsHit = true; }
-        if (data.casterUnit == owner_.playerGuid && tgt != owner_.playerGuid && tgt != 0) { playerHitEnemy = true; }
-    }
-
-    // Fire UNIT_SPELLCAST_SUCCEEDED
-    if (owner_.addonEventCallback_) {
-        std::string unitId = owner_.guidToUnitId(data.casterUnit);
-        if (!unitId.empty())
-            owner_.addonEventCallback_("UNIT_SPELLCAST_SUCCEEDED", {unitId, std::to_string(data.spellId)});
-    }
-
-    if (playerIsHit || playerHitEnemy) {
-        if (auto* ac = owner_.services().audioCoordinator) {
-            if (auto* ssm = ac->getSpellSoundManager()) {
-                owner_.loadSpellNameCache();
-                auto it = owner_.spellNameCache_.find(data.spellId);
-                auto school = (it != owner_.spellNameCache_.end() && it->second.schoolMask)
-                    ? schoolMaskToMagicSchool(it->second.schoolMask)
-                    : audio::SpellSoundManager::MagicSchool::ARCANE;
-                ssm->playImpact(school, audio::SpellSoundManager::SpellPower::MEDIUM);
-            }
-        }
-    }
-}
-
-void SpellHandler::handleSpellCooldown(network::Packet& packet) {
-    const bool isClassicFormat = isClassicLikeExpansion();
-
-    if (!packet.hasRemaining(8)) return;
-    /*guid*/ packet.readUInt64();
-
-    if (!isClassicFormat) {
-        if (!packet.hasRemaining(1)) return;
-        /*flags*/ packet.readUInt8();
-    }
-
-    const size_t entrySize = isClassicFormat ? 12u : 8u;
-    while (packet.getRemainingSize() >= entrySize) {
-        uint32_t spellId    = packet.readUInt32();
-        uint32_t cdItemId   = 0;
-        if (isClassicFormat) cdItemId = packet.readUInt32();
-        uint32_t cooldownMs = packet.readUInt32();
-
-        float seconds = cooldownMs / 1000.0f;
-
-        // spellId=0 is the Global Cooldown marker
-        if (spellId == 0 && cooldownMs > 0 && cooldownMs <= 2000) {
-            gcdTotal_ = seconds;
-            gcdStartedAt_ = std::chrono::steady_clock::now();
-            continue;
-        }
-
-        auto it = spellCooldowns_.find(spellId);
-        if (it == spellCooldowns_.end()) {
-            spellCooldowns_[spellId] = seconds;
-        } else {
-            it->second = mergeCooldownSeconds(it->second, seconds);
-        }
-        for (auto& slot : owner_.actionBar) {
-            bool match = (slot.type == ActionBarSlot::SPELL && slot.id == spellId)
-                      || (cdItemId != 0 && slot.type == ActionBarSlot::ITEM && slot.id == cdItemId);
-            if (match) {
-                float prevRemaining = slot.cooldownRemaining;
-                float merged = mergeCooldownSeconds(slot.cooldownRemaining, seconds);
-                slot.cooldownRemaining = merged;
-                if (slot.cooldownTotal <= 0.0f || prevRemaining <= 0.0f) {
-                    slot.cooldownTotal = seconds;
-                } else {
-                    slot.cooldownTotal = std::max(slot.cooldownTotal, merged);
-                }
-            }
-        }
-    }
-    LOG_DEBUG("handleSpellCooldown: parsed for ",
-              isClassicFormat ? "Classic" : "TBC/WotLK", " format");
-    if (owner_.addonEventCallback_) {
-        owner_.addonEventCallback_("SPELL_UPDATE_COOLDOWN", {});
-        owner_.addonEventCallback_("ACTIONBAR_UPDATE_COOLDOWN", {});
-    }
-}
-
-void SpellHandler::handleCooldownEvent(network::Packet& packet) {
-    if (!packet.hasRemaining(4)) return;
-    uint32_t spellId = packet.readUInt32();
-    if (packet.hasRemaining(8))
-        packet.readUInt64();
-    spellCooldowns_.erase(spellId);
-    for (auto& slot : owner_.actionBar) {
-        if (slot.type == ActionBarSlot::SPELL && slot.id == spellId) {
-            slot.cooldownRemaining = 0.0f;
-        }
-    }
-    if (owner_.addonEventCallback_) {
-        owner_.addonEventCallback_("SPELL_UPDATE_COOLDOWN", {});
-        owner_.addonEventCallback_("ACTIONBAR_UPDATE_COOLDOWN", {});
-    }
-}
-
-void SpellHandler::handleAuraUpdate(network::Packet& packet, bool isAll) {
-    AuraUpdateData data;
-    if (!owner_.packetParsers_->parseAuraUpdate(packet, data, isAll)) return;
-
-    std::vector<AuraSlot>* auraList = nullptr;
-    if (data.guid == owner_.playerGuid) {
-        auraList = &playerAuras_;
-    } else if (data.guid == owner_.targetGuid) {
-        auraList = &targetAuras_;
-    }
-    if (data.guid != 0 && data.guid != owner_.playerGuid && data.guid != owner_.targetGuid) {
-        auraList = &unitAurasCache_[data.guid];
-    }
-
-    if (auraList) {
-        if (isAll) {
-            auraList->clear();
-        }
-        uint64_t nowMs = static_cast<uint64_t>(
-            std::chrono::duration_cast<std::chrono::milliseconds>(
-                std::chrono::steady_clock::now().time_since_epoch()).count());
-        for (auto [slot, aura] : data.updates) {
-            if (aura.durationMs >= 0) {
-                aura.receivedAtMs = nowMs;
-            }
-            while (auraList->size() <= slot) {
-                auraList->push_back(AuraSlot{});
-            }
-            (*auraList)[slot] = aura;
-        }
-
-        if (owner_.addonEventCallback_) {
-            std::string unitId;
-            if (data.guid == owner_.playerGuid) unitId = "player";
-            else if (data.guid == owner_.targetGuid) unitId = "target";
-            else if (data.guid == owner_.focusGuid) unitId = "focus";
-            else if (data.guid == owner_.petGuid_) unitId = "pet";
-            if (!unitId.empty())
-                owner_.addonEventCallback_("UNIT_AURA", {unitId});
-        }
-
-        // Mount aura detection
-        if (data.guid == owner_.playerGuid && owner_.currentMountDisplayId_ != 0 && owner_.mountAuraSpellId_ == 0) {
-            for (const auto& [slot, aura] : data.updates) {
-                if (!aura.isEmpty() && aura.maxDurationMs < 0 && aura.casterGuid == owner_.playerGuid) {
-                    owner_.mountAuraSpellId_ = aura.spellId;
-                    LOG_INFO("Mount aura detected from aura update: spellId=", aura.spellId);
-                }
-            }
-        }
-
-        // Sprint aura detection — check if any sprint/dash speed buff is active
-        if (data.guid == owner_.playerGuid && owner_.sprintAuraCallback_) {
-            static const uint32_t sprintSpells[] = {
-                2983, 8696, 11305,   // Rogue Sprint (ranks 1-3)
-                1850, 9821, 33357,   // Druid Dash (ranks 1-3)
-                36554,               // Shadowstep (speed component)
-                68992, 68991,        // Darkflight (worgen racial)
-                58984,               // Aspect of the Pack speed 
-            };
-            bool hasSprint = false;
-            for (const auto& a : playerAuras_) {
-                if (a.isEmpty()) continue;
-                for (uint32_t sid : sprintSpells) {
-                    if (a.spellId == sid) { hasSprint = true; break; }
-                }
-                if (hasSprint) break;
-            }
-            owner_.sprintAuraCallback_(hasSprint);
-        }
-    }
-}
-
-void SpellHandler::handleLearnedSpell(network::Packet& packet) {
-    const bool classicSpellId = isClassicLikeExpansion();
-    const size_t minSz = classicSpellId ? 2u : 4u;
-    if (packet.getRemainingSize() < minSz) return;
-    uint32_t spellId = classicSpellId ? packet.readUInt16() : packet.readUInt32();
-
-    const bool alreadyKnown = knownSpells_.count(spellId) > 0;
-    knownSpells_.insert(spellId);
-    LOG_INFO("Learned spell: ", spellId, alreadyKnown ? " (already known, skipping chat)" : "");
-
-    // Check if this spell corresponds to a talent rank
-    bool isTalentSpell = false;
-    for (const auto& [talentId, talent] : talentCache_) {
-        for (int rank = 0; rank < 5; ++rank) {
-            if (talent.rankSpells[rank] == spellId) {
-                uint8_t newRank = rank + 1;
-                learnedTalents_[activeTalentSpec_][talentId] = newRank;
-                LOG_INFO("Talent learned: id=", talentId, " rank=", (int)newRank,
-                         " (spell ", spellId, ") in spec ", (int)activeTalentSpec_);
-                isTalentSpell = true;
-                if (owner_.addonEventCallback_) {
-                    owner_.addonEventCallback_("CHARACTER_POINTS_CHANGED", {});
-                    owner_.addonEventCallback_("PLAYER_TALENT_UPDATE", {});
-                }
-                break;
-            }
-        }
-        if (isTalentSpell) break;
-    }
-
-    if (!alreadyKnown && owner_.addonEventCallback_) {
-        owner_.addonEventCallback_("LEARNED_SPELL_IN_TAB", {std::to_string(spellId)});
-        owner_.addonEventCallback_("SPELLS_CHANGED", {});
-    }
-
-    if (isTalentSpell) return;
-
-    if (!alreadyKnown) {
-        const std::string& name = owner_.getSpellName(spellId);
-        if (!name.empty()) {
-            owner_.addSystemChatMessage("You have learned a new spell: " + name + ".");
-        } else {
-            owner_.addSystemChatMessage("You have learned a new spell.");
-        }
-    }
-}
-
-void SpellHandler::handleRemovedSpell(network::Packet& packet) {
-    const bool classicSpellId = isClassicLikeExpansion();
-    const size_t minSz = classicSpellId ? 2u : 4u;
-    if (packet.getRemainingSize() < minSz) return;
-    uint32_t spellId = classicSpellId ? packet.readUInt16() : packet.readUInt32();
-    knownSpells_.erase(spellId);
-    LOG_INFO("Removed spell: ", spellId);
-    if (owner_.addonEventCallback_) owner_.addonEventCallback_("SPELLS_CHANGED", {});
-
-    const std::string& name = owner_.getSpellName(spellId);
-    if (!name.empty())
-        owner_.addSystemChatMessage("You have unlearned: " + name + ".");
-    else
-        owner_.addSystemChatMessage("A spell has been removed.");
-
-    bool barChanged = false;
-    for (auto& slot : owner_.actionBar) {
-        if (slot.type == ActionBarSlot::SPELL && slot.id == spellId) {
-            slot = ActionBarSlot{};
-            barChanged = true;
-        }
-    }
-    if (barChanged) owner_.saveCharacterConfig();
-}
-
-void SpellHandler::handleSupercededSpell(network::Packet& packet) {
-    const bool classicSpellId = isClassicLikeExpansion();
-    const size_t minSz = classicSpellId ? 4u : 8u;
-    if (packet.getRemainingSize() < minSz) return;
-    uint32_t oldSpellId = classicSpellId ? packet.readUInt16() : packet.readUInt32();
-    uint32_t newSpellId = classicSpellId ? packet.readUInt16() : packet.readUInt32();
-
-    knownSpells_.erase(oldSpellId);
-
-    const bool newSpellAlreadyAnnounced = knownSpells_.count(newSpellId) > 0;
-
-    knownSpells_.insert(newSpellId);
-
-    LOG_INFO("Spell superceded: ", oldSpellId, " -> ", newSpellId);
-
-    bool barChanged = false;
-    for (auto& slot : owner_.actionBar) {
-        if (slot.type == ActionBarSlot::SPELL && slot.id == oldSpellId) {
-            slot.id = newSpellId;
-            slot.cooldownRemaining = 0.0f;
-            slot.cooldownTotal = 0.0f;
-            barChanged = true;
-            LOG_DEBUG("Action bar slot upgraded: spell ", oldSpellId, " -> ", newSpellId);
-        }
-    }
-    if (barChanged) {
-        owner_.saveCharacterConfig();
-        if (owner_.addonEventCallback_) owner_.addonEventCallback_("ACTIONBAR_SLOT_CHANGED", {});
-    }
-
-    if (!newSpellAlreadyAnnounced) {
-        const std::string& newName = owner_.getSpellName(newSpellId);
-        if (!newName.empty()) {
-            owner_.addSystemChatMessage("Upgraded to " + newName);
-        }
-    }
-}
-
-void SpellHandler::handleUnlearnSpells(network::Packet& packet) {
-    if (!packet.hasRemaining(4)) return;
-    uint32_t spellCount = packet.readUInt32();
-    LOG_INFO("Unlearning ", spellCount, " spells");
-
-    bool barChanged = false;
-    for (uint32_t i = 0; i < spellCount && packet.getRemainingSize() >= 4; ++i) {
-        uint32_t spellId = packet.readUInt32();
-        knownSpells_.erase(spellId);
-        LOG_INFO("  Unlearned spell: ", spellId);
-        for (auto& slot : owner_.actionBar) {
-            if (slot.type == ActionBarSlot::SPELL && slot.id == spellId) {
-                slot = ActionBarSlot{};
-                barChanged = true;
-            }
-        }
-    }
-    if (barChanged) owner_.saveCharacterConfig();
-
-    if (spellCount > 0) {
-        owner_.addSystemChatMessage("Unlearned " + std::to_string(spellCount) + " spells");
-    }
-}
-
-void SpellHandler::handleTalentsInfo(network::Packet& packet) {
-    if (!packet.hasRemaining(1)) return;
-    uint8_t talentType = packet.readUInt8();
-    if (talentType != 0) {
-        return;
-    }
-    if (!packet.hasRemaining(6)) {
-        LOG_WARNING("handleTalentsInfo: packet too short for header");
-        return;
-    }
-
-    uint32_t unspentTalents    = packet.readUInt32();
-    uint8_t  talentGroupCount  = packet.readUInt8();
-    uint8_t  activeTalentGroup = packet.readUInt8();
-    if (activeTalentGroup > 1) activeTalentGroup = 0;
-
-    loadTalentDbc();
-
-    activeTalentSpec_ = activeTalentGroup;
-
-    for (uint8_t g = 0; g < talentGroupCount && g < 2; ++g) {
-        if (!packet.hasRemaining(1)) break;
-        uint8_t talentCount = packet.readUInt8();
-        learnedTalents_[g].clear();
-        for (uint8_t t = 0; t < talentCount; ++t) {
-            if (!packet.hasRemaining(5)) break;
-            uint32_t talentId = packet.readUInt32();
-            uint8_t  rank     = packet.readUInt8();
-            learnedTalents_[g][talentId] = rank + 1u;
-        }
-        learnedGlyphs_[g].fill(0);
-        if (!packet.hasRemaining(1)) break;
-        uint8_t glyphCount = packet.readUInt8();
-        for (uint8_t gl = 0; gl < glyphCount; ++gl) {
-            if (!packet.hasRemaining(2)) break;
-            uint16_t glyphId = packet.readUInt16();
-            if (gl < MAX_GLYPH_SLOTS) learnedGlyphs_[g][gl] = glyphId;
-        }
-    }
-
-    unspentTalentPoints_[activeTalentGroup] =
-        static_cast<uint8_t>(unspentTalents > 255 ? 255 : unspentTalents);
-
-    LOG_INFO("handleTalentsInfo: unspent=", unspentTalents,
-             " groups=", (int)talentGroupCount, " active=", (int)activeTalentGroup,
-             " learned=", learnedTalents_[activeTalentGroup].size());
-
-    if (owner_.addonEventCallback_) {
-        owner_.addonEventCallback_("CHARACTER_POINTS_CHANGED", {});
-        owner_.addonEventCallback_("ACTIVE_TALENT_GROUP_CHANGED", {});
-        owner_.addonEventCallback_("PLAYER_TALENT_UPDATE", {});
-    }
-
-    if (!talentsInitialized_) {
-        talentsInitialized_ = true;
-        if (unspentTalents > 0) {
-            owner_.addSystemChatMessage("You have " + std::to_string(unspentTalents)
-                + " unspent talent point" + (unspentTalents != 1 ? "s" : "") + ".");
-        }
-    }
-}
-
-void SpellHandler::handleAchievementEarned(network::Packet& packet) {
-    size_t remaining = packet.getRemainingSize();
-    if (remaining < 16) return;
-
-    uint64_t guid          = packet.readUInt64();
-    uint32_t achievementId = packet.readUInt32();
-    uint32_t earnDate      = packet.readUInt32();
-
-    owner_.loadAchievementNameCache();
-    auto nameIt = owner_.achievementNameCache_.find(achievementId);
-    const std::string& achName = (nameIt != owner_.achievementNameCache_.end())
-        ? nameIt->second : std::string();
-
-    bool isSelf = (guid == owner_.playerGuid);
-    if (isSelf) {
-        char buf[256];
-        if (!achName.empty()) {
-            std::snprintf(buf, sizeof(buf), "Achievement earned: %s", achName.c_str());
-        } else {
-            std::snprintf(buf, sizeof(buf), "Achievement earned! (ID %u)", achievementId);
-        }
-        owner_.addSystemChatMessage(buf);
-
-        owner_.earnedAchievements_.insert(achievementId);
-        owner_.achievementDates_[achievementId] = earnDate;
-        if (auto* ac = owner_.services().audioCoordinator) {
-            if (auto* sfx = ac->getUiSoundManager())
-                sfx->playAchievementAlert();
-        }
-        if (owner_.achievementEarnedCallback_) {
-            owner_.achievementEarnedCallback_(achievementId, achName);
-        }
-    } else {
-        std::string senderName;
-        auto entity = owner_.getEntityManager().getEntity(guid);
-        if (auto* unit = dynamic_cast<Unit*>(entity.get())) {
-            senderName = unit->getName();
-        }
-        if (senderName.empty()) {
-            auto nit = owner_.getPlayerNameCache().find(guid);
-            if (nit != owner_.getPlayerNameCache().end())
-                senderName = nit->second;
-        }
-        if (senderName.empty()) {
-            char tmp[32];
-            std::snprintf(tmp, sizeof(tmp), "0x%llX",
-                          static_cast<unsigned long long>(guid));
-            senderName = tmp;
-        }
-        // Use std::string instead of fixed char[256] — achievement names can be
-        // long and combined with senderName could exceed 256 bytes, silently truncating.
-        std::string msg = senderName + (!achName.empty()
-            ? " has earned the achievement: " + achName
-            : " has earned an achievement! (ID " + std::to_string(achievementId) + ")");
-        owner_.addSystemChatMessage(msg);
-    }
-
-    LOG_INFO("SMSG_ACHIEVEMENT_EARNED: guid=0x", std::hex, guid, std::dec,
-             " achievementId=", achievementId, " self=", isSelf,
-             achName.empty() ? "" : " name=", achName);
-    if (owner_.addonEventCallback_)
-        owner_.addonEventCallback_("ACHIEVEMENT_EARNED", {std::to_string(achievementId)});
-}
-
-// SMSG_EQUIPMENT_SET_LIST — moved to InventoryHandler
-
-// ============================================================
-// Pet spell methods (moved from GameHandler)
-// ============================================================
-
-void SpellHandler::handlePetSpells(network::Packet& packet) {
-    const size_t remaining = packet.getRemainingSize();
-    if (remaining < 8) {
-        owner_.petGuid_ = 0;
-        owner_.petSpellList_.clear();
-        owner_.petAutocastSpells_.clear();
-        memset(owner_.petActionSlots_, 0, sizeof(owner_.petActionSlots_));
-        LOG_INFO("SMSG_PET_SPELLS: pet cleared");
-        owner_.fireAddonEvent("UNIT_PET", {"player"});
-        return;
-    }
-
-    owner_.petGuid_ = packet.readUInt64();
-    if (owner_.petGuid_ == 0) {
-        owner_.petSpellList_.clear();
-        owner_.petAutocastSpells_.clear();
-        memset(owner_.petActionSlots_, 0, sizeof(owner_.petActionSlots_));
-        LOG_INFO("SMSG_PET_SPELLS: pet cleared (guid=0)");
-        owner_.fireAddonEvent("UNIT_PET", {"player"});
-        return;
-    }
-
-    // Parse optional pet fields — bail on truncated packets but always log+fire below.
-    do {
-        if (!packet.hasRemaining(4)) break;
-        /*uint16_t dur =*/ packet.readUInt16();
-        /*uint16_t timer =*/ packet.readUInt16();
-
-        if (!packet.hasRemaining(2)) break;
-        owner_.petReact_   = packet.readUInt8();
-        owner_.petCommand_ = packet.readUInt8();
-
-        if (!packet.hasRemaining(GameHandler::PET_ACTION_BAR_SLOTS * 4u)) break;
-        for (int i = 0; i < GameHandler::PET_ACTION_BAR_SLOTS; ++i) {
-            owner_.petActionSlots_[i] = packet.readUInt32();
-        }
-
-        if (!packet.hasRemaining(1)) break;
-        uint8_t spellCount = packet.readUInt8();
-        owner_.petSpellList_.clear();
-        owner_.petAutocastSpells_.clear();
-        for (uint8_t i = 0; i < spellCount; ++i) {
-            if (!packet.hasRemaining(6)) break;
-            uint32_t spellId = packet.readUInt32();
-            uint16_t activeFlags = packet.readUInt16();
-            owner_.petSpellList_.push_back(spellId);
-            if (activeFlags & 0x0001) {
-                owner_.petAutocastSpells_.insert(spellId);
-            }
-        }
-    } while (false);
-
-    LOG_INFO("SMSG_PET_SPELLS: petGuid=0x", std::hex, owner_.petGuid_, std::dec,
-             " react=", static_cast<int>(owner_.petReact_), " command=", static_cast<int>(owner_.petCommand_),
-             " spells=", owner_.petSpellList_.size());
-    owner_.fireAddonEvent("UNIT_PET", {"player"});
-    owner_.fireAddonEvent("PET_BAR_UPDATE", {});
-}
-
-void SpellHandler::sendPetAction(uint32_t action, uint64_t targetGuid) {
-    if (!owner_.hasPet() || owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    auto pkt = PetActionPacket::build(owner_.petGuid_, action, targetGuid);
-    owner_.socket->send(pkt);
-    LOG_DEBUG("sendPetAction: petGuid=0x", std::hex, owner_.petGuid_,
-              " action=0x", action, " target=0x", targetGuid, std::dec);
-}
-
-void SpellHandler::dismissPet() {
-    if (owner_.petGuid_ == 0 || owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    auto packet = PetActionPacket::build(owner_.petGuid_, 0x07000000);
-    owner_.socket->send(packet);
-}
-
-void SpellHandler::togglePetSpellAutocast(uint32_t spellId) {
-    if (owner_.petGuid_ == 0 || spellId == 0 || owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    bool currentlyOn = owner_.petAutocastSpells_.count(spellId) != 0;
-    uint8_t newState = currentlyOn ? 0 : 1;
-    network::Packet pkt(wireOpcode(Opcode::CMSG_PET_SPELL_AUTOCAST));
-    pkt.writeUInt64(owner_.petGuid_);
-    pkt.writeUInt32(spellId);
-    pkt.writeUInt8(newState);
-    owner_.socket->send(pkt);
-    if (newState)
-        owner_.petAutocastSpells_.insert(spellId);
-    else
-        owner_.petAutocastSpells_.erase(spellId);
-    LOG_DEBUG("togglePetSpellAutocast: spellId=", spellId, " autocast=", static_cast<int>(newState));
-}
-
-void SpellHandler::renamePet(const std::string& newName) {
-    if (owner_.petGuid_ == 0 || owner_.state != WorldState::IN_WORLD || !owner_.socket) return;
-    if (newName.empty() || newName.size() > 12) return;
-    auto packet = PetRenamePacket::build(owner_.petGuid_, newName, 0);
-    owner_.socket->send(packet);
-    LOG_INFO("Sent CMSG_PET_RENAME: petGuid=0x", std::hex, owner_.petGuid_, std::dec, " name='", newName, "'");
-}
-
-void SpellHandler::handleListStabledPets(network::Packet& packet) {
-    constexpr size_t kMinHeader = 8 + 1 + 1;
-    if (!packet.hasRemaining(kMinHeader)) {
-        LOG_WARNING("MSG_LIST_STABLED_PETS: packet too short (", packet.getSize(), ")");
-        return;
-    }
-    owner_.stableMasterGuid_ = packet.readUInt64();
-    uint8_t petCount  = packet.readUInt8();
-    owner_.stableNumSlots_   = packet.readUInt8();
-
-    owner_.stabledPets_.clear();
-    owner_.stabledPets_.reserve(petCount);
-
-    for (uint8_t i = 0; i < petCount; ++i) {
-        // petNumber(4) + entry(4) + level(4) = 12 bytes before the name string
-        if (!packet.hasRemaining(12)) break;
-        GameHandler::StabledPet pet;
-        pet.petNumber = packet.readUInt32();
-        pet.entry     = packet.readUInt32();
-        pet.level     = packet.readUInt32();
-        pet.name      = packet.readString();
-        // displayId(4) + isActive(1) = 5 bytes after the name string
-        if (!packet.hasRemaining(5)) break;
-        pet.displayId = packet.readUInt32();
-        pet.isActive  = (packet.readUInt8() != 0);
-        owner_.stabledPets_.push_back(std::move(pet));
-    }
-
-    owner_.stableWindowOpen_ = true;
-    LOG_INFO("MSG_LIST_STABLED_PETS: stableMasterGuid=0x", std::hex, owner_.stableMasterGuid_, std::dec,
-             " petCount=", static_cast<int>(petCount), " numSlots=", static_cast<int>(owner_.stableNumSlots_));
-    for (const auto& p : owner_.stabledPets_) {
-        LOG_DEBUG("  Pet: number=", p.petNumber, " entry=", p.entry,
-                  " level=", p.level, " name='", p.name, "' displayId=", p.displayId,
-                  " active=", p.isActive);
-    }
-}
-
-// ============================================================
-// Cast state methods (moved from GameHandler)
-// ============================================================
-
-void SpellHandler::stopCasting() {
-    if (!owner_.isInWorld()) {
-        LOG_WARNING("Cannot stop casting: not in world or not connected");
-        return;
-    }
-
-    if (!casting_) {
-        return;
-    }
-
-    if (owner_.pendingGameObjectInteractGuid_ == 0 && currentCastSpellId_ != 0) {
-        auto packet = CancelCastPacket::build(currentCastSpellId_);
-        owner_.socket->send(packet);
-    }
-
-    casting_ = false;
-    castIsChannel_ = false;
-    currentCastSpellId_ = 0;
-    castTimeRemaining_ = 0.0f;
-    castTimeTotal_ = 0.0f;
-    owner_.pendingGameObjectInteractGuid_ = 0;
-    owner_.lastInteractedGoGuid_ = 0;
-    craftQueueSpellId_ = 0;
-    craftQueueRemaining_ = 0;
-    queuedSpellId_ = 0;
-    queuedSpellTarget_ = 0;
-
-    LOG_INFO("Cancelled spell cast");
-}
-
-void SpellHandler::resetCastState() {
-    casting_ = false;
-    castIsChannel_ = false;
-    currentCastSpellId_ = 0;
-    castTimeRemaining_ = 0.0f;
-    castTimeTotal_ = 0.0f;  // Must match castTimeRemaining_ to keep getCastProgress() == 0
-    craftQueueSpellId_ = 0;
-    craftQueueRemaining_ = 0;
-    queuedSpellId_ = 0;
-    queuedSpellTarget_ = 0;
-    owner_.pendingGameObjectInteractGuid_ = 0;
-    // lastInteractedGoGuid_ is intentionally NOT cleared here — it must survive
-    // until handleSpellGo sends CMSG_LOOT after the server-side cast completes.
-    // handleSpellGo clears it after use (line 958). Previously this was cleared
-    // here, which meant the client-side timer fallback destroyed the guid before
-    // SMSG_SPELL_GO arrived, preventing loot from opening on quest chests.
-}
-
-void SpellHandler::resetAllState() {
-    knownSpells_.clear();
-    spellCooldowns_.clear();
-    playerAuras_.clear();
-    targetAuras_.clear();
-    unitAurasCache_.clear();
-    unitCastStates_.clear();
-    resetCastState();
-    resetTalentState();
-}
-
-void SpellHandler::resetTalentState() {
-    talentsInitialized_ = false;
-    learnedTalents_[0].clear();
-    learnedTalents_[1].clear();
-    learnedGlyphs_[0].fill(0);
-    learnedGlyphs_[1].fill(0);
-    unspentTalentPoints_[0] = 0;
-    unspentTalentPoints_[1] = 0;
-    activeTalentSpec_ = 0;
-}
-
-void SpellHandler::clearUnitCaches() {
-    unitCastStates_.clear();
-    unitAurasCache_.clear();
-}
-
-// ============================================================
-// Aura duration update (moved from GameHandler)
-// ============================================================
-
-void SpellHandler::handleUpdateAuraDuration(uint8_t slot, uint32_t durationMs) {
-    if (slot >= playerAuras_.size()) return;
-    if (playerAuras_[slot].isEmpty()) return;
-    playerAuras_[slot].durationMs = static_cast<int32_t>(durationMs);
-    playerAuras_[slot].receivedAtMs = static_cast<uint64_t>(
-        std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now().time_since_epoch()).count());
-}
-
-// ============================================================
-// Spell DBC / Cache methods (moved from GameHandler)
-// ============================================================
-
-static const std::string SPELL_EMPTY_STRING;
-
-void SpellHandler::loadSpellNameCache() const {
-    if (owner_.spellNameCacheLoaded_) return;
-    owner_.spellNameCacheLoaded_ = true;
-
-    auto* am = owner_.services().assetManager;
-    if (!am || !am->isInitialized()) return;
-
-    auto dbc = am->loadDBC("Spell.dbc");
-    if (!dbc || !dbc->isLoaded()) {
-        LOG_WARNING("Trainer: Could not load Spell.dbc for spell names");
-        return;
-    }
-
-    if (dbc->getFieldCount() < 148) {
-        LOG_WARNING("Trainer: Spell.dbc has too few fields (", dbc->getFieldCount(), ")");
-        return;
-    }
-
-    const auto* spellL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("Spell") : nullptr;
-
-    uint32_t schoolMaskField = 0, schoolEnumField = 0;
-    bool hasSchoolMask = false, hasSchoolEnum = false;
-    if (spellL) {
-        uint32_t f = spellL->field("SchoolMask");
-        if (f != 0xFFFFFFFF && f < dbc->getFieldCount()) { schoolMaskField = f; hasSchoolMask = true; }
-        f = spellL->field("SchoolEnum");
-        if (f != 0xFFFFFFFF && f < dbc->getFieldCount()) { schoolEnumField = f; hasSchoolEnum = true; }
-    }
-
-    uint32_t dispelField = 0xFFFFFFFF;
-    bool hasDispelField = false;
-    if (spellL) {
-        uint32_t f = spellL->field("DispelType");
-        if (f != 0xFFFFFFFF && f < dbc->getFieldCount()) { dispelField = f; hasDispelField = true; }
-    }
-
-    uint32_t attrExField = 0xFFFFFFFF;
-    bool hasAttrExField = false;
-    if (spellL) {
-        uint32_t f = spellL->field("AttributesEx");
-        if (f != 0xFFFFFFFF && f < dbc->getFieldCount()) { attrExField = f; hasAttrExField = true; }
-    }
-
-    uint32_t tooltipField = 0xFFFFFFFF;
-    if (spellL) {
-        uint32_t f = spellL->field("Tooltip");
-        if (f != 0xFFFFFFFF && f < dbc->getFieldCount()) tooltipField = f;
-    }
-
-    // Cache field indices before the loop to avoid repeated layout lookups
-    const uint32_t idField   = spellL ? (*spellL)["ID"]   : 0;
-    const uint32_t nameField = spellL ? (*spellL)["Name"] : 136;
-    const uint32_t rankField = spellL ? (*spellL)["Rank"] : 153;
-    const uint32_t ebp0Field = spellL ? spellL->field("EffectBasePoints0") : 0xFFFFFFFF;
-    const uint32_t ebp1Field = spellL ? spellL->field("EffectBasePoints1") : 0xFFFFFFFF;
-    const uint32_t ebp2Field = spellL ? spellL->field("EffectBasePoints2") : 0xFFFFFFFF;
-    const uint32_t durIdxField = spellL ? spellL->field("DurationIndex") : 0xFFFFFFFF;
-
-    uint32_t count = dbc->getRecordCount();
-    for (uint32_t i = 0; i < count; ++i) {
-        uint32_t id = dbc->getUInt32(i, idField);
-        if (id == 0) continue;
-        std::string name = dbc->getString(i, nameField);
-        std::string rank = dbc->getString(i, rankField);
-        if (!name.empty()) {
-            GameHandler::SpellNameEntry entry{std::move(name), std::move(rank), {}, 0, 0, 0};
-            if (tooltipField != 0xFFFFFFFF) {
-                entry.description = dbc->getString(i, tooltipField);
-            }
-            if (hasSchoolMask) {
-                entry.schoolMask = dbc->getUInt32(i, schoolMaskField);
-            } else if (hasSchoolEnum) {
-                static const uint32_t enumToBitmask[] = {0x01,0x02,0x04,0x08,0x10,0x20,0x40};
-                uint32_t e = dbc->getUInt32(i, schoolEnumField);
-                entry.schoolMask = (e < 7) ? enumToBitmask[e] : 0;
-            }
-            if (hasDispelField) {
-                entry.dispelType = static_cast<uint8_t>(dbc->getUInt32(i, dispelField));
-            }
-            if (hasAttrExField) {
-                entry.attrEx = dbc->getUInt32(i, attrExField);
-            }
-            // Load effect base points for $s1/$s2/$s3 tooltip substitution
-            if (ebp0Field != 0xFFFFFFFF) entry.effectBasePoints[0] = static_cast<int32_t>(dbc->getUInt32(i, ebp0Field));
-            if (ebp1Field != 0xFFFFFFFF) entry.effectBasePoints[1] = static_cast<int32_t>(dbc->getUInt32(i, ebp1Field));
-            if (ebp2Field != 0xFFFFFFFF) entry.effectBasePoints[2] = static_cast<int32_t>(dbc->getUInt32(i, ebp2Field));
-            // Duration: read DurationIndex and resolve via SpellDuration.dbc later
-            if (durIdxField != 0xFFFFFFFF)
-                entry.durationSec = static_cast<float>(dbc->getUInt32(i, durIdxField)); // store index temporarily
-            owner_.spellNameCache_[id] = std::move(entry);
-        }
-    }
-    auto durDbc = am->loadDBC("SpellDuration.dbc");
-    if (durDbc && durDbc->isLoaded()) {
-        std::unordered_map<uint32_t, float> durMap;
-        for (uint32_t di = 0; di < durDbc->getRecordCount(); ++di) {
-            uint32_t durId = durDbc->getUInt32(di, 0);
-            int32_t baseMs = static_cast<int32_t>(durDbc->getUInt32(di, 1));
-            if (baseMs > 0 && baseMs < 100000000)
-                durMap[durId] = baseMs / 1000.0f;
-        }
-        for (auto& [sid, entry] : owner_.spellNameCache_) {
-            uint32_t durIdx = static_cast<uint32_t>(entry.durationSec);
-            if (durIdx > 0) {
-                auto it = durMap.find(durIdx);
-                entry.durationSec = (it != durMap.end()) ? it->second : 0.0f;
-            }
-        }
-    }
-    LOG_INFO("Trainer: Loaded ", owner_.spellNameCache_.size(), " spell names from Spell.dbc");
-}
-
-void SpellHandler::loadSkillLineAbilityDbc() {
-    if (owner_.skillLineAbilityLoaded_) return;
-    owner_.skillLineAbilityLoaded_ = true;
-
-    auto* am = owner_.services().assetManager;
-    if (!am || !am->isInitialized()) return;
-
-    auto slaDbc = am->loadDBC("SkillLineAbility.dbc");
-    if (slaDbc && slaDbc->isLoaded()) {
-        const auto* slaL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("SkillLineAbility") : nullptr;
-        const uint32_t slaSkillField = slaL ? (*slaL)["SkillLineID"] : 1;
-        const uint32_t slaSpellField = slaL ? (*slaL)["SpellID"]     : 2;
-        for (uint32_t i = 0; i < slaDbc->getRecordCount(); i++) {
-            uint32_t skillLineId = slaDbc->getUInt32(i, slaSkillField);
-            uint32_t spellId = slaDbc->getUInt32(i, slaSpellField);
-            if (spellId > 0 && skillLineId > 0) {
-                owner_.spellToSkillLine_[spellId] = skillLineId;
-            }
-        }
-        LOG_INFO("Trainer: Loaded ", owner_.spellToSkillLine_.size(), " skill line abilities");
-    }
-}
-
-void SpellHandler::categorizeTrainerSpells() {
-    owner_.trainerTabs_.clear();
-
-    static constexpr uint32_t SKILLLINE_CATEGORY_CLASS = 7;
-
-    std::map<uint32_t, std::vector<const TrainerSpell*>> specialtySpells;
-    std::vector<const TrainerSpell*> generalSpells;
-
-    for (const auto& spell : owner_.currentTrainerList_.spells) {
-        auto slIt = owner_.spellToSkillLine_.find(spell.spellId);
-        if (slIt != owner_.spellToSkillLine_.end()) {
-            uint32_t skillLineId = slIt->second;
-            auto catIt = owner_.skillLineCategories_.find(skillLineId);
-            if (catIt != owner_.skillLineCategories_.end() && catIt->second == SKILLLINE_CATEGORY_CLASS) {
-                specialtySpells[skillLineId].push_back(&spell);
-                continue;
-            }
-        }
-        generalSpells.push_back(&spell);
-    }
-
-    auto byName = [this](const TrainerSpell* a, const TrainerSpell* b) {
-        return getSpellName(a->spellId) < getSpellName(b->spellId);
-    };
-
-    std::vector<std::pair<std::string, std::vector<const TrainerSpell*>>> named;
-    for (auto& [skillLineId, spells] : specialtySpells) {
-        auto nameIt = owner_.skillLineNames_.find(skillLineId);
-        std::string tabName = (nameIt != owner_.skillLineNames_.end()) ? nameIt->second : "Specialty";
-        std::sort(spells.begin(), spells.end(), byName);
-        named.push_back({std::move(tabName), std::move(spells)});
-    }
-    std::sort(named.begin(), named.end(),
-        [](const auto& a, const auto& b) { return a.first < b.first; });
-
-    for (auto& [name, spells] : named) {
-        owner_.trainerTabs_.push_back({std::move(name), std::move(spells)});
-    }
-
-    if (!generalSpells.empty()) {
-        std::sort(generalSpells.begin(), generalSpells.end(), byName);
-        owner_.trainerTabs_.push_back({"General", std::move(generalSpells)});
-    }
-
-    LOG_INFO("Trainer: Categorized into ", owner_.trainerTabs_.size(), " tabs");
-}
-
-const int32_t* SpellHandler::getSpellEffectBasePoints(uint32_t spellId) const {
-    loadSpellNameCache();
-    auto it = owner_.spellNameCache_.find(spellId);
-    return (it != owner_.spellNameCache_.end()) ? it->second.effectBasePoints : nullptr;
-}
-
-float SpellHandler::getSpellDuration(uint32_t spellId) const {
-    loadSpellNameCache();
-    auto it = owner_.spellNameCache_.find(spellId);
-    return (it != owner_.spellNameCache_.end()) ? it->second.durationSec : 0.0f;
-}
-
-const std::string& SpellHandler::getSpellName(uint32_t spellId) const {
-    // Lazy-load Spell.dbc so callers don't need to know about initialization order.
-    // Every other DBC-backed getter (getSpellDescription, getSpellSchoolMask, etc.)
-    // already does this; these two were missed.
-    loadSpellNameCache();
-    auto it = owner_.spellNameCache_.find(spellId);
-    return (it != owner_.spellNameCache_.end()) ? it->second.name : SPELL_EMPTY_STRING;
-}
-
-const std::string& SpellHandler::getSpellRank(uint32_t spellId) const {
-    loadSpellNameCache();
-    auto it = owner_.spellNameCache_.find(spellId);
-    return (it != owner_.spellNameCache_.end()) ? it->second.rank : SPELL_EMPTY_STRING;
-}
-
-const std::string& SpellHandler::getSpellDescription(uint32_t spellId) const {
-    loadSpellNameCache();
-    auto it = owner_.spellNameCache_.find(spellId);
-    return (it != owner_.spellNameCache_.end()) ? it->second.description : SPELL_EMPTY_STRING;
-}
-
-std::string SpellHandler::getEnchantName(uint32_t enchantId) const {
-    if (enchantId == 0) return {};
-    auto* am = owner_.services().assetManager;
-    if (!am || !am->isInitialized()) return {};
-    auto dbc = am->loadDBC("SpellItemEnchantment.dbc");
-    if (!dbc || !dbc->isLoaded()) return {};
-    for (uint32_t i = 0; i < dbc->getRecordCount(); ++i) {
-        if (dbc->getUInt32(i, 0) == enchantId) {
-            return dbc->getString(i, 14);
-        }
-    }
-    return {};
-}
-
-uint8_t SpellHandler::getSpellDispelType(uint32_t spellId) const {
-    loadSpellNameCache();
-    auto it = owner_.spellNameCache_.find(spellId);
-    return (it != owner_.spellNameCache_.end()) ? it->second.dispelType : 0;
-}
-
-bool SpellHandler::isSpellInterruptible(uint32_t spellId) const {
-    if (spellId == 0) return true;
-    loadSpellNameCache();
-    auto it = owner_.spellNameCache_.find(spellId);
-    if (it == owner_.spellNameCache_.end()) return true;
-    return (it->second.attrEx & 0x00000010u) == 0;
-}
-
-uint32_t SpellHandler::getSpellSchoolMask(uint32_t spellId) const {
-    if (spellId == 0) return 0;
-    loadSpellNameCache();
-    auto it = owner_.spellNameCache_.find(spellId);
-    return (it != owner_.spellNameCache_.end()) ? it->second.schoolMask : 0;
-}
-
-const std::string& SpellHandler::getSkillLineName(uint32_t spellId) const {
-    auto slIt = owner_.spellToSkillLine_.find(spellId);
-    if (slIt == owner_.spellToSkillLine_.end()) return SPELL_EMPTY_STRING;
-    auto nameIt = owner_.skillLineNames_.find(slIt->second);
-    return (nameIt != owner_.skillLineNames_.end()) ? nameIt->second : SPELL_EMPTY_STRING;
-}
-
-// ============================================================
-// Skill DBC methods (moved from GameHandler)
-// ============================================================
-
-void SpellHandler::loadSkillLineDbc() {
-    if (owner_.skillLineDbcLoaded_) return;
-    owner_.skillLineDbcLoaded_ = true;
-
-    auto* am = owner_.services().assetManager;
-    if (!am || !am->isInitialized()) return;
-
-    auto dbc = am->loadDBC("SkillLine.dbc");
-    if (!dbc || !dbc->isLoaded()) {
-        LOG_WARNING("GameHandler: Could not load SkillLine.dbc");
-        return;
-    }
-
-    const auto* slL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("SkillLine") : nullptr;
-    const uint32_t slIdField   = slL ? (*slL)["ID"]       : 0;
-    const uint32_t slCatField  = slL ? (*slL)["Category"] : 1;
-    const uint32_t slNameField = slL ? (*slL)["Name"]     : 3;
-    for (uint32_t i = 0; i < dbc->getRecordCount(); i++) {
-        uint32_t id = dbc->getUInt32(i, slIdField);
-        uint32_t category = dbc->getUInt32(i, slCatField);
-        std::string name = dbc->getString(i, slNameField);
-        if (id > 0 && !name.empty()) {
-            owner_.skillLineNames_[id] = name;
-            owner_.skillLineCategories_[id] = category;
-        }
-    }
-    LOG_INFO("GameHandler: Loaded ", owner_.skillLineNames_.size(), " skill line names");
-}
-
-void SpellHandler::extractSkillFields(const std::map<uint16_t, uint32_t>& fields) {
-    loadSkillLineDbc();
-
-    const uint16_t PLAYER_SKILL_INFO_START = fieldIndex(UF::PLAYER_SKILL_INFO_START);
-    static constexpr int MAX_SKILL_SLOTS = 128;
-
-    std::unordered_map<uint32_t, PlayerSkill> newSkills;
-
-    for (int slot = 0; slot < MAX_SKILL_SLOTS; slot++) {
-        uint16_t baseField = PLAYER_SKILL_INFO_START + slot * 3;
-
-        auto idIt = fields.find(baseField);
-        if (idIt == fields.end()) continue;
-
-        uint32_t raw0 = idIt->second;
-        uint16_t skillId = raw0 & 0xFFFF;
-        if (skillId == 0) continue;
-
-        auto valIt = fields.find(baseField + 1);
-        if (valIt == fields.end()) continue;
-
-        uint32_t raw1 = valIt->second;
-        uint16_t value = raw1 & 0xFFFF;
-        uint16_t maxValue = (raw1 >> 16) & 0xFFFF;
-
-        uint16_t bonusTemp = 0;
-        uint16_t bonusPerm = 0;
-        auto bonusIt = fields.find(static_cast<uint16_t>(baseField + 2));
-        if (bonusIt != fields.end()) {
-            bonusTemp = bonusIt->second & 0xFFFF;
-            bonusPerm = (bonusIt->second >> 16) & 0xFFFF;
-        }
-
-        PlayerSkill skill;
-        skill.skillId = skillId;
-        skill.value = value;
-        skill.maxValue = maxValue;
-        skill.bonusTemp = bonusTemp;
-        skill.bonusPerm = bonusPerm;
-        newSkills[skillId] = skill;
-    }
-
-    for (const auto& [skillId, skill] : newSkills) {
-        if (skill.value == 0) continue;
-        auto oldIt = owner_.playerSkills_.find(skillId);
-        if (oldIt != owner_.playerSkills_.end() && skill.value > oldIt->second.value) {
-            auto catIt = owner_.skillLineCategories_.find(skillId);
-            if (catIt != owner_.skillLineCategories_.end()) {
-                uint32_t category = catIt->second;
-                if (category == 5 || category == 10 || category == 12) {
-                    continue;
-                }
-            }
-
-            const std::string& name = owner_.getSkillName(skillId);
-            std::string skillName = name.empty() ? ("Skill #" + std::to_string(skillId)) : name;
-            owner_.addSystemChatMessage("Your skill in " + skillName + " has increased to " + std::to_string(skill.value) + ".");
-        }
-    }
-
-    bool skillsChanged = (newSkills.size() != owner_.playerSkills_.size());
-    if (!skillsChanged) {
-        for (const auto& [id, sk] : newSkills) {
-            auto it = owner_.playerSkills_.find(id);
-            if (it == owner_.playerSkills_.end() || it->second.value != sk.value) {
-                skillsChanged = true;
-                break;
-            }
-        }
-    }
-    owner_.playerSkills_ = std::move(newSkills);
-    if (skillsChanged)
-        owner_.fireAddonEvent("SKILL_LINES_CHANGED", {});
-}
-
-void SpellHandler::extractExploredZoneFields(const std::map<uint16_t, uint32_t>& fields) {
-    const size_t zoneCount = owner_.packetParsers_
-        ? static_cast<size_t>(owner_.packetParsers_->exploredZonesCount())
-        : GameHandler::PLAYER_EXPLORED_ZONES_COUNT;
-
-    if (owner_.playerExploredZones_.size() != GameHandler::PLAYER_EXPLORED_ZONES_COUNT) {
-        owner_.playerExploredZones_.assign(GameHandler::PLAYER_EXPLORED_ZONES_COUNT, 0u);
-    }
-
-    bool foundAny = false;
-    for (size_t i = 0; i < zoneCount; i++) {
-        const uint16_t fieldIdx = static_cast<uint16_t>(fieldIndex(UF::PLAYER_EXPLORED_ZONES_START) + i);
-        auto it = fields.find(fieldIdx);
-        if (it == fields.end()) continue;
-        owner_.playerExploredZones_[i] = it->second;
-        foundAny = true;
-    }
-    for (size_t i = zoneCount; i < GameHandler::PLAYER_EXPLORED_ZONES_COUNT; i++) {
-        owner_.playerExploredZones_[i] = 0u;
-    }
-
-    if (foundAny) {
-        owner_.hasPlayerExploredZones_ = true;
-    }
-}
-
-// ============================================================
-// Moved opcode handlers (from GameHandler::registerOpcodeHandlers)
-// ============================================================
-
-void SpellHandler::handleCastResult(network::Packet& packet) {
-    uint32_t castResultSpellId = 0;
-    uint8_t  castResult        = 0;
-    if (owner_.packetParsers_->parseCastResult(packet, castResultSpellId, castResult)) {
-        LOG_DEBUG("SMSG_CAST_RESULT: spellId=", castResultSpellId, " result=", static_cast<int>(castResult));
-        if (castResult != 0) {
-            casting_ = false; castIsChannel_ = false; currentCastSpellId_ = 0; castTimeRemaining_ = 0.0f;
-            owner_.lastInteractedGoGuid_ = 0;
-            craftQueueSpellId_ = 0; craftQueueRemaining_ = 0;
-            queuedSpellId_ = 0; queuedSpellTarget_ = 0;
-            int playerPowerType = -1;
-            if (auto pe = owner_.getEntityManager().getEntity(owner_.playerGuid)) {
-                if (auto pu = std::dynamic_pointer_cast<Unit>(pe))
-                    playerPowerType = static_cast<int>(pu->getPowerType());
-            }
-            const char* reason = getSpellCastResultString(castResult, playerPowerType);
-            std::string errMsg = reason ? reason
-                                        : ("Spell cast failed (error " + std::to_string(castResult) + ")");
-            owner_.addUIError(errMsg);
-            if (owner_.spellCastFailedCallback_) owner_.spellCastFailedCallback_(castResultSpellId);
-                owner_.fireAddonEvent("UNIT_SPELLCAST_FAILED", {"player", std::to_string(castResultSpellId)});
-                owner_.fireAddonEvent("UNIT_SPELLCAST_STOP",   {"player", std::to_string(castResultSpellId)});
-            MessageChatData msg;
-            msg.type     = ChatType::SYSTEM;
-            msg.language = ChatLanguage::UNIVERSAL;
-            msg.message  = errMsg;
-            owner_.addLocalChatMessage(msg);
-        }
-    }
-}
-
-void SpellHandler::handleSpellFailedOther(network::Packet& packet) {
-    const bool tbcLike2 = isPreWotlk();
-    uint64_t failOtherGuid = tbcLike2
-        ? (packet.hasRemaining(8) ? packet.readUInt64() : 0)
-        : packet.readPackedGuid();
-    if (failOtherGuid != 0 && failOtherGuid != owner_.playerGuid) {
-        unitCastStates_.erase(failOtherGuid);
-        if (owner_.addonEventCallback_) {
-            std::string unitId;
-            if (failOtherGuid == owner_.targetGuid)     unitId = "target";
-            else if (failOtherGuid == owner_.focusGuid) unitId = "focus";
-            if (!unitId.empty()) {
-                owner_.fireAddonEvent("UNIT_SPELLCAST_FAILED", {unitId});
-                owner_.fireAddonEvent("UNIT_SPELLCAST_STOP",   {unitId});
-            }
-        }
-    }
-    packet.skipAll();
-}
-
-void SpellHandler::handleClearCooldown(network::Packet& packet) {
-    if (packet.hasRemaining(4)) {
-        uint32_t spellId = packet.readUInt32();
-        spellCooldowns_.erase(spellId);
-        for (auto& slot : owner_.actionBar) {
-            if (slot.type == ActionBarSlot::SPELL && slot.id == spellId)
-                slot.cooldownRemaining = 0.0f;
-        }
-    }
-}
-
-void SpellHandler::handleModifyCooldown(network::Packet& packet) {
-    if (packet.hasRemaining(8)) {
-        uint32_t spellId = packet.readUInt32();
-        int32_t  diffMs  = static_cast<int32_t>(packet.readUInt32());
-        float diffSec = diffMs / 1000.0f;
-        auto it = spellCooldowns_.find(spellId);
-        if (it != spellCooldowns_.end()) {
-            it->second = std::max(0.0f, it->second + diffSec);
-            for (auto& slot : owner_.actionBar) {
-                if (slot.type == ActionBarSlot::SPELL && slot.id == spellId)
-                    slot.cooldownRemaining = std::max(0.0f, slot.cooldownRemaining + diffSec);
-            }
-        }
-    }
-}
-
-void SpellHandler::handlePlaySpellVisual(network::Packet& packet) {
-    if (!packet.hasRemaining(12)) return;
-    uint64_t casterGuid = packet.readUInt64();
-    uint32_t visualId   = packet.readUInt32();
-    if (visualId == 0) return;
-    auto* renderer = owner_.services().renderer;
-    if (!renderer) return;
-    glm::vec3 spawnPos;
-    if (casterGuid == owner_.playerGuid) {
-        spawnPos = renderer->getCharacterPosition();
-    } else {
-        auto entity = owner_.getEntityManager().getEntity(casterGuid);
-        if (!entity) return;
-        glm::vec3 canonical(entity->getLatestX(), entity->getLatestY(), entity->getLatestZ());
-        spawnPos = core::coords::canonicalToRender(canonical);
-    }
-    renderer->playSpellVisual(visualId, spawnPos);
-}
-
-void SpellHandler::handleSpellModifier(network::Packet& packet, bool isFlat) {
-    auto& modMap = isFlat ? owner_.spellFlatMods_ : owner_.spellPctMods_;
-    while (packet.hasRemaining(6)) {
-        uint8_t groupIndex = packet.readUInt8();
-        uint8_t modOpRaw   = packet.readUInt8();
-        int32_t value      = static_cast<int32_t>(packet.readUInt32());
-        if (groupIndex > 5 || modOpRaw >= GameHandler::SPELL_MOD_OP_COUNT) continue;
-        GameHandler::SpellModKey key{ static_cast<GameHandler::SpellModOp>(modOpRaw), groupIndex };
-        modMap[key] = value;
-    }
-    packet.skipAll();
-}
-
-void SpellHandler::handleSpellDelayed(network::Packet& packet) {
-    const bool spellDelayTbcLike = isPreWotlk();
-    if (!packet.hasRemaining(spellDelayTbcLike ? 8u : 1u) ) return;
-    uint64_t caster = spellDelayTbcLike
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(4)) return;
-    uint32_t delayMs = packet.readUInt32();
-    if (delayMs == 0) return;
-    float delaySec = delayMs / 1000.0f;
-    if (caster == owner_.playerGuid) {
-        if (casting_) {
-            castTimeRemaining_ += delaySec;
-            castTimeTotal_     += delaySec;
-        }
-    } else {
-        auto it = unitCastStates_.find(caster);
-        if (it != unitCastStates_.end() && it->second.casting) {
-            it->second.timeRemaining += delaySec;
-            it->second.timeTotal     += delaySec;
-        }
-    }
-}
-
-// ============================================================
-// Extracted opcode handlers (from registerOpcodeHandlers)
-// ============================================================
-
-void SpellHandler::handleSpellLogMiss(network::Packet& packet) {
-    // All expansions: uint32 spellId first.
-    // WotLK/Classic: spellId(4) + packed_guid caster + uint8 unk + uint32 count
-    //                 + count × (packed_guid victim + uint8 missInfo)
-    // TBC:            spellId(4) + uint64 caster + uint8 unk + uint32 count
-    //                 + count × (uint64 victim + uint8 missInfo)
-    // All expansions append uint32 reflectSpellId + uint8 reflectResult when
-    // missInfo==REFLECT (11).
-    const bool spellMissUsesFullGuid = isActiveExpansion("tbc");
-    auto readSpellMissGuid = [&]() -> uint64_t {
-        if (spellMissUsesFullGuid)
-            return (packet.hasRemaining(8)) ? packet.readUInt64() : 0;
-        return packet.readPackedGuid();
-    };
-    // spellId prefix present in all expansions
-    if (!packet.hasRemaining(4)) return;
-    uint32_t spellId = packet.readUInt32();
-    if (!packet.hasRemaining(spellMissUsesFullGuid ? 8u : 1u)
-        || (!spellMissUsesFullGuid && !packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t casterGuid = readSpellMissGuid();
-    if (!packet.hasRemaining(5)) return;
-    /*uint8_t unk =*/ packet.readUInt8();
-    const uint32_t rawCount = packet.readUInt32();
-    if (rawCount > 128) {
-        LOG_WARNING("SMSG_SPELLLOGMISS: miss count capped (requested=", rawCount, ")");
-    }
-    const uint32_t storedLimit = std::min<uint32_t>(rawCount, 128u);
-
-    struct SpellMissLogEntry {
-        uint64_t victimGuid = 0;
-        uint8_t missInfo = 0;
-        uint32_t reflectSpellId = 0;  // Only valid when missInfo==REFLECT
-    };
-    std::vector<SpellMissLogEntry> parsedMisses;
-    parsedMisses.reserve(storedLimit);
-
-    bool truncated = false;
-    for (uint32_t i = 0; i < rawCount; ++i) {
-        if (!packet.hasRemaining(spellMissUsesFullGuid ? 9u : 2u)
-            || (!spellMissUsesFullGuid && !packet.hasFullPackedGuid())) {
-            truncated = true;
-            return;
-        }
-        const uint64_t victimGuid = readSpellMissGuid();
-        if (!packet.hasRemaining(1)) {
-            truncated = true;
-            return;
-        }
-        const uint8_t missInfo = packet.readUInt8();
-        // REFLECT: extra uint32 reflectSpellId + uint8 reflectResult
-        uint32_t reflectSpellId = 0;
-        if (missInfo == SpellMissInfo::REFLECT) {
-            if (packet.hasRemaining(5)) {
-                reflectSpellId = packet.readUInt32();
-                /*uint8_t reflectResult =*/ packet.readUInt8();
-            } else {
-                truncated = true;
-                return;
-            }
-        }
-        if (i < storedLimit) {
-            parsedMisses.push_back({victimGuid, missInfo, reflectSpellId});
-        }
-    }
-
-    if (truncated) {
-        packet.skipAll();
-        return;
-    }
-
-    for (const auto& miss : parsedMisses) {
-        const uint64_t victimGuid = miss.victimGuid;
-        const uint8_t missInfo = miss.missInfo;
-        CombatTextEntry::Type ct = combatTextTypeFromSpellMissInfo(missInfo);
-        // For REFLECT, use the reflected spell ID so combat text shows the spell name
-        uint32_t combatSpellId = (ct == CombatTextEntry::REFLECT && miss.reflectSpellId != 0)
-                                 ? miss.reflectSpellId : spellId;
-        if (casterGuid == owner_.playerGuid) {
-            // We cast a spell and it missed the target
-            owner_.addCombatText(ct, 0, combatSpellId, true, 0, casterGuid, victimGuid);
-        } else if (victimGuid == owner_.playerGuid) {
-            // Enemy spell missed us (we dodged/parried/blocked/resisted/etc.)
-            owner_.addCombatText(ct, 0, combatSpellId, false, 0, casterGuid, victimGuid);
-        }
-    }
-}
-
-void SpellHandler::handleSpellFailure(network::Packet& packet) {
-    // WotLK: packed_guid + uint8 castCount + uint32 spellId + uint8 failReason
-    // TBC:   full uint64 + uint8 castCount + uint32 spellId + uint8 failReason
-    // Classic: full uint64 + uint32 spellId + uint8 failReason  (NO castCount)
-    const bool isClassic = isClassicLikeExpansion();
-    const bool isTbc     = isActiveExpansion("tbc");
-    uint64_t failGuid = (isClassic || isTbc)
-        ? (packet.hasRemaining(8) ? packet.readUInt64() : 0)
-        : packet.readPackedGuid();
-    // Classic omits the castCount byte; TBC and WotLK include it
-    const size_t remainingFields = isClassic ? 5u : 6u;  // spellId(4)+reason(1) [+castCount(1)]
-    if (packet.hasRemaining(remainingFields)) {
-        if (!isClassic) /*uint8_t castCount =*/ packet.readUInt8();
-        uint32_t failSpellId = packet.readUInt32();
-        uint8_t rawFailReason = packet.readUInt8();
-        // Classic result enum starts at 0=AFFECTING_COMBAT; shift +1 for WotLK table
-        uint8_t failReason = isClassic ? static_cast<uint8_t>(rawFailReason + 1) : rawFailReason;
-        if (failGuid == owner_.playerGuid && failReason != 0) {
-            // Show interruption/failure reason in chat and error overlay for player
-            int pt = -1;
-            if (auto pe = owner_.getEntityManager().getEntity(owner_.playerGuid))
-                if (auto pu = std::dynamic_pointer_cast<Unit>(pe))
-                    pt = static_cast<int>(pu->getPowerType());
-            const char* reason = getSpellCastResultString(failReason, pt);
-            if (reason) {
-                // Prefix with spell name for context, e.g. "Fireball: Not in range"
-                const std::string& sName = owner_.getSpellName(failSpellId);
-                std::string fullMsg = sName.empty() ? reason
-                                                    : sName + ": " + reason;
-                owner_.addUIError(fullMsg);
-                MessageChatData emsg;
-                emsg.type = ChatType::SYSTEM;
-                emsg.language = ChatLanguage::UNIVERSAL;
-                emsg.message = std::move(fullMsg);
-                owner_.addLocalChatMessage(emsg);
-            }
-        }
-    }
-    // Fire UNIT_SPELLCAST_INTERRUPTED for Lua addons
-    if (owner_.addonEventCallback_) {
-        auto unitId = (failGuid == 0) ? std::string("player") : owner_.guidToUnitId(failGuid);
-        if (!unitId.empty()) {
-            owner_.fireAddonEvent("UNIT_SPELLCAST_INTERRUPTED", {unitId});
-            owner_.fireAddonEvent("UNIT_SPELLCAST_STOP", {unitId});
-        }
-    }
-    if (failGuid == owner_.playerGuid || failGuid == 0) {
-        // Player's own cast failed — clear gather-node loot target so the
-        // next timed cast doesn't try to loot a stale interrupted gather node.
-        casting_ = false; castIsChannel_ = false; currentCastSpellId_ = 0;
-        owner_.lastInteractedGoGuid_ = 0;
-        craftQueueSpellId_ = 0;
-        craftQueueRemaining_ = 0;
-        queuedSpellId_ = 0;
-        queuedSpellTarget_ = 0;
-        if (auto* ac = owner_.services().audioCoordinator) {
-            if (auto* ssm = ac->getSpellSoundManager()) {
-                ssm->stopPrecast();
-            }
-        }
-        if (owner_.spellCastAnimCallback_) {
-            owner_.spellCastAnimCallback_(owner_.playerGuid, false, false, SpellCastType::OMNI);
-        }
-    } else {
-        // Another unit's cast failed — clear their tracked cast bar
-        unitCastStates_.erase(failGuid);
-        if (owner_.spellCastAnimCallback_) {
-            owner_.spellCastAnimCallback_(failGuid, false, false, SpellCastType::OMNI);
-        }
-    }
-}
-
-void SpellHandler::handleItemCooldown(network::Packet& packet) {
-    // uint64 itemGuid + uint32 spellId + uint32 cooldownMs
-    size_t rem = packet.getRemainingSize();
-    if (rem >= 16) {
-        uint64_t itemGuid = packet.readUInt64();
-        uint32_t spellId  = packet.readUInt32();
-        uint32_t cdMs     = packet.readUInt32();
-        float cdSec = cdMs / 1000.0f;
-        if (cdSec > 0.0f) {
-            if (spellId != 0) {
-                auto it = spellCooldowns_.find(spellId);
-                if (it == spellCooldowns_.end()) {
-                    spellCooldowns_[spellId] = cdSec;
-                } else {
-                    it->second = mergeCooldownSeconds(it->second, cdSec);
-                }
-            }
-            // Resolve itemId from the GUID so item-type slots are also updated
-            uint32_t itemId = 0;
-            auto iit = owner_.onlineItems_.find(itemGuid);
-            if (iit != owner_.onlineItems_.end()) itemId = iit->second.entry;
-            for (auto& slot : owner_.actionBar) {
-                bool match = (spellId != 0 && slot.type == ActionBarSlot::SPELL && slot.id == spellId)
-                          || (itemId  != 0 && slot.type == ActionBarSlot::ITEM  && slot.id == itemId);
-                if (match) {
-                    float prevRemaining = slot.cooldownRemaining;
-                    float merged = mergeCooldownSeconds(slot.cooldownRemaining, cdSec);
-                    slot.cooldownRemaining = merged;
-                    if (slot.cooldownTotal <= 0.0f || prevRemaining <= 0.0f) {
-                        slot.cooldownTotal = cdSec;
-                    } else {
-                        slot.cooldownTotal = std::max(slot.cooldownTotal, merged);
-                    }
-                }
-            }
-            LOG_DEBUG("SMSG_ITEM_COOLDOWN: itemGuid=0x", std::hex, itemGuid, std::dec,
-                      " spellId=", spellId, " itemId=", itemId, " cd=", cdSec, "s");
-        }
-    }
-}
-
-void SpellHandler::handleDispelFailed(network::Packet& packet) {
-    // WotLK:       uint32 dispelSpellId + packed_guid caster + packed_guid victim
-    //              [+ count × uint32 failedSpellId]
-    // Classic:     uint32 dispelSpellId + packed_guid caster + packed_guid victim
-    //              [+ count × uint32 failedSpellId]
-    // TBC:         uint64 caster + uint64 victim + uint32 spellId
-    //              [+ count × uint32 failedSpellId]
-    const bool dispelUsesFullGuid = isActiveExpansion("tbc");
-    uint32_t dispelSpellId = 0;
-    uint64_t dispelCasterGuid = 0;
-    if (dispelUsesFullGuid) {
-        if (!packet.hasRemaining(20)) return;
-        dispelCasterGuid = packet.readUInt64();
-        /*uint64_t victim =*/ packet.readUInt64();
-        dispelSpellId = packet.readUInt32();
-    } else {
-        if (!packet.hasRemaining(4)) return;
-        dispelSpellId = packet.readUInt32();
-        if (!packet.hasFullPackedGuid()) {
-            packet.skipAll(); return;
-        }
-        dispelCasterGuid = packet.readPackedGuid();
-        if (!packet.hasFullPackedGuid()) {
-            packet.skipAll(); return;
-        }
-        /*uint64_t victim =*/ packet.readPackedGuid();
-    }
-    // Only show failure to the player who attempted the dispel
-    if (dispelCasterGuid == owner_.playerGuid) {
-        const auto& name = owner_.getSpellName(dispelSpellId);
-        char buf[128];
-        if (!name.empty())
-            std::snprintf(buf, sizeof(buf), "%s failed to dispel.", name.c_str());
-        else
-            std::snprintf(buf, sizeof(buf), "Dispel failed! (spell %u)", dispelSpellId);
-        owner_.addSystemChatMessage(buf);
-    }
-}
-
-void SpellHandler::handleTotemCreated(network::Packet& packet) {
-    // WotLK:       uint8 slot + packed_guid + uint32 duration + uint32 spellId
-    // TBC/Classic: uint8 slot + uint64 guid  + uint32 duration + uint32 spellId
-    const bool totemTbcLike = isPreWotlk();
-    if (!packet.hasRemaining(totemTbcLike ? 17u : 9u) ) return;
-    uint8_t slot = packet.readUInt8();
-    if (totemTbcLike)
-        /*uint64_t guid =*/ packet.readUInt64();
-    else
-        /*uint64_t guid =*/ packet.readPackedGuid();
-    if (!packet.hasRemaining(8)) return;
-    uint32_t duration = packet.readUInt32();
-    uint32_t spellId  = packet.readUInt32();
-    LOG_DEBUG("SMSG_TOTEM_CREATED: slot=", static_cast<int>(slot),
-              " spellId=", spellId, " duration=", duration, "ms");
-    if (slot < GameHandler::NUM_TOTEM_SLOTS) {
-        owner_.activeTotemSlots_[slot].spellId    = spellId;
-        owner_.activeTotemSlots_[slot].durationMs = duration;
-        owner_.activeTotemSlots_[slot].placedAt   = std::chrono::steady_clock::now();
-    }
-}
-
-void SpellHandler::handlePeriodicAuraLog(network::Packet& packet) {
-    // WotLK: packed_guid victim + packed_guid caster + uint32 spellId + uint32 count + effects
-    // TBC: full uint64 victim + uint64 caster + uint32 spellId + uint32 count + effects
-    // Classic/Vanilla: packed_guid (same as WotLK)
-    const bool periodicTbc = isActiveExpansion("tbc");
-    const size_t guidMinSz = periodicTbc ? 8u : 2u;
-    if (!packet.hasRemaining(guidMinSz)) return;
-    uint64_t victimGuid = periodicTbc
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(guidMinSz)) return;
-    uint64_t casterGuid = periodicTbc
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(8)) return;
-    uint32_t spellId = packet.readUInt32();
-    uint32_t count   = packet.readUInt32();
-    bool isPlayerVictim = (victimGuid == owner_.playerGuid);
-    bool isPlayerCaster = (casterGuid == owner_.playerGuid);
-    if (!isPlayerVictim && !isPlayerCaster) {
-        packet.skipAll();
-        return;
-    }
-    for (uint32_t i = 0; i < count && packet.hasRemaining(1); ++i) {
-        uint8_t auraType = packet.readUInt8();
-        if (auraType == 3 || auraType == 89) {
-            // Classic/TBC: damage(4)+school(4)+absorbed(4)+resisted(4)  = 16 bytes
-            // WotLK 3.3.5a: damage(4)+overkill(4)+school(4)+absorbed(4)+resisted(4)+isCrit(1) = 21 bytes
-            const bool periodicWotlk = isActiveExpansion("wotlk");
-            const size_t dotSz = periodicWotlk ? 21u : 16u;
-            if (!packet.hasRemaining(dotSz)) break;
-            uint32_t dmg      = packet.readUInt32();
-            if (periodicWotlk) /*uint32_t overkill=*/ packet.readUInt32();
-            /*uint32_t school=*/ packet.readUInt32();
-            uint32_t abs      = packet.readUInt32();
-            uint32_t res      = packet.readUInt32();
-            bool dotCrit = false;
-            if (periodicWotlk) dotCrit = (packet.readUInt8() != 0);
-            if (dmg > 0)
-                owner_.addCombatText(dotCrit ? CombatTextEntry::CRIT_DAMAGE : CombatTextEntry::PERIODIC_DAMAGE,
-                              static_cast<int32_t>(dmg),
-                              spellId, isPlayerCaster, 0, casterGuid, victimGuid);
-            if (abs > 0)
-                owner_.addCombatText(CombatTextEntry::ABSORB, static_cast<int32_t>(abs),
-                              spellId, isPlayerCaster, 0, casterGuid, victimGuid);
-            if (res > 0)
-                owner_.addCombatText(CombatTextEntry::RESIST, static_cast<int32_t>(res),
-                              spellId, isPlayerCaster, 0, casterGuid, victimGuid);
-        } else if (auraType == 8 || auraType == 124 || auraType == 45) {
-            // Classic/TBC: heal(4)+maxHeal(4)+overHeal(4)                  = 12 bytes
-            // WotLK 3.3.5a: heal(4)+maxHeal(4)+overHeal(4)+absorbed(4)+isCrit(1) = 17 bytes
-            const bool healWotlk = isActiveExpansion("wotlk");
-            const size_t hotSz = healWotlk ? 17u : 12u;
-            if (!packet.hasRemaining(hotSz)) break;
-            uint32_t heal    = packet.readUInt32();
-            /*uint32_t max=*/  packet.readUInt32();
-            /*uint32_t over=*/ packet.readUInt32();
-            uint32_t hotAbs  = 0;
-            bool hotCrit = false;
-            if (healWotlk) {
-                hotAbs = packet.readUInt32();
-                hotCrit = (packet.readUInt8() != 0);
-            }
-            owner_.addCombatText(hotCrit ? CombatTextEntry::CRIT_HEAL : CombatTextEntry::PERIODIC_HEAL,
-                          static_cast<int32_t>(heal),
-                          spellId, isPlayerCaster, 0, casterGuid, victimGuid);
-            if (hotAbs > 0)
-                owner_.addCombatText(CombatTextEntry::ABSORB, static_cast<int32_t>(hotAbs),
-                              spellId, isPlayerCaster, 0, casterGuid, victimGuid);
-        } else if (auraType == 46 || auraType == 91) {
-            // OBS_MOD_POWER / PERIODIC_ENERGIZE: miscValue(powerType) + amount
-            // Common in WotLK: Replenishment, Mana Spring Totem, Divine Plea, etc.
-            if (!packet.hasRemaining(8)) break;
-            uint8_t periodicPowerType = static_cast<uint8_t>(packet.readUInt32());
-            uint32_t amount = packet.readUInt32();
-            if ((isPlayerVictim || isPlayerCaster) && amount > 0)
-                owner_.addCombatText(CombatTextEntry::ENERGIZE, static_cast<int32_t>(amount),
-                              spellId, isPlayerCaster, periodicPowerType, casterGuid, victimGuid);
-        } else if (auraType == 98) {
-            // PERIODIC_MANA_LEECH: miscValue(powerType) + amount + float multiplier
-            if (!packet.hasRemaining(12)) break;
-            uint8_t powerType = static_cast<uint8_t>(packet.readUInt32());
-            uint32_t amount = packet.readUInt32();
-            float multiplier = packet.readFloat();
-            if (isPlayerVictim && amount > 0)
-                owner_.addCombatText(CombatTextEntry::POWER_DRAIN, static_cast<int32_t>(amount),
-                              spellId, false, powerType, casterGuid, victimGuid);
-            if (isPlayerCaster && amount > 0 && multiplier > 0.0f && std::isfinite(multiplier)) {
-                const uint32_t gainedAmount = static_cast<uint32_t>(
-                    std::lround(static_cast<double>(amount) * static_cast<double>(multiplier)));
-                if (gainedAmount > 0) {
-                    owner_.addCombatText(CombatTextEntry::ENERGIZE, static_cast<int32_t>(gainedAmount),
-                                  spellId, true, powerType, casterGuid, casterGuid);
-                }
-            }
-        } else {
-            // Unknown/untracked aura type — stop parsing this event safely
-            packet.skipAll();
-            break;
-        }
-    }
-    packet.skipAll();
-}
-
-void SpellHandler::handleSpellEnergizeLog(network::Packet& packet) {
-    // WotLK: packed_guid victim + packed_guid caster + uint32 spellId + uint8 powerType + int32 amount
-    // TBC: full uint64 victim + uint64 caster + uint32 spellId + uint8 powerType + int32 amount
-    // Classic/Vanilla: packed_guid (same as WotLK)
-    const bool energizeTbc = isActiveExpansion("tbc");
-    auto readEnergizeGuid = [&]() -> uint64_t {
-        if (energizeTbc)
-            return (packet.hasRemaining(8)) ? packet.readUInt64() : 0;
-        return packet.readPackedGuid();
-    };
-    if (!packet.hasRemaining(energizeTbc ? 8u : 1u)
-        || (!energizeTbc && !packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t victimGuid = readEnergizeGuid();
-    if (!packet.hasRemaining(energizeTbc ? 8u : 1u)
-        || (!energizeTbc && !packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t casterGuid = readEnergizeGuid();
-    if (!packet.hasRemaining(9)) {
-        packet.skipAll(); return;
-    }
-    uint32_t spellId       = packet.readUInt32();
-    uint8_t  energizePowerType = packet.readUInt8();
-    int32_t  amount        = static_cast<int32_t>(packet.readUInt32());
-    bool isPlayerVictim = (victimGuid == owner_.playerGuid);
-    bool isPlayerCaster = (casterGuid == owner_.playerGuid);
-    if ((isPlayerVictim || isPlayerCaster) && amount > 0)
-        owner_.addCombatText(CombatTextEntry::ENERGIZE, amount, spellId, isPlayerCaster, energizePowerType, casterGuid, victimGuid);
-    packet.skipAll();
-}
-
-void SpellHandler::handleExtraAuraInfo(network::Packet& packet, bool isInit) {
-    // TBC 2.4.3 aura tracking: replaces SMSG_AURA_UPDATE which doesn't exist in TBC.
-    // Format: uint64 targetGuid + uint8 count + N×{uint8 slot, uint32 spellId,
-    //         uint8 effectIndex, uint8 flags, uint32 durationMs, uint32 maxDurationMs}
-    auto remaining = [&]() { return packet.getRemainingSize(); };
-    if (remaining() < 9) { packet.skipAll(); return; }
-    uint64_t auraTargetGuid = packet.readUInt64();
-    uint8_t count = packet.readUInt8();
-
-    std::vector<AuraSlot>* auraList = nullptr;
-    if (auraTargetGuid == owner_.playerGuid)       auraList = &playerAuras_;
-    else if (auraTargetGuid == owner_.targetGuid)   auraList = &targetAuras_;
-    else if (auraTargetGuid != 0)                   auraList = &unitAurasCache_[auraTargetGuid];
-
-    if (auraList && isInit) auraList->clear();
-
-    uint64_t nowMs = static_cast<uint64_t>(
-        std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now().time_since_epoch()).count());
-
-    for (uint8_t i = 0; i < count && remaining() >= 15; i++) {
-        uint8_t  slot        = packet.readUInt8();   // 1 byte
-        uint32_t spellId     = packet.readUInt32();  // 4 bytes
-        (void)               packet.readUInt8();     // effectIndex: 1 byte (unused for slot display)
-        uint8_t  flags       = packet.readUInt8();   // 1 byte
-        uint32_t durationMs  = packet.readUInt32();  // 4 bytes
-        uint32_t maxDurMs    = packet.readUInt32();  // 4 bytes — total 15 bytes per entry
-
-        if (auraList) {
-            while (auraList->size() <= slot) auraList->push_back(AuraSlot{});
-            AuraSlot& a = (*auraList)[slot];
-            a.spellId      = spellId;
-            // TBC uses same flag convention as Classic: 0x02=harmful, 0x04=beneficial.
-            // Normalize to WotLK SMSG_AURA_UPDATE convention: 0x80=debuff, 0=buff.
-            a.flags        = (flags & 0x02) ? 0x80u : 0u;
-            a.durationMs   = (durationMs == 0xFFFFFFFF) ? -1 : static_cast<int32_t>(durationMs);
-            a.maxDurationMs= (maxDurMs   == 0xFFFFFFFF) ? -1 : static_cast<int32_t>(maxDurMs);
-            a.receivedAtMs = nowMs;
-        }
-    }
-    packet.skipAll();
-}
-
-void SpellHandler::handleSpellDispelLog(network::Packet& packet) {
-    // WotLK/Classic/Turtle: packed casterGuid + packed victimGuid + uint32 dispelSpell + uint8 isStolen
-    // TBC:                  full uint64 casterGuid + full uint64 victimGuid + ...
-    // + uint32 count + count × (uint32 dispelled_spellId + uint32 unk)
-    const bool dispelUsesFullGuid = isActiveExpansion("tbc");
-    if (!packet.hasRemaining(dispelUsesFullGuid ? 8u : 1u)
-        || (!dispelUsesFullGuid && !packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t casterGuid = dispelUsesFullGuid
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(dispelUsesFullGuid ? 8u : 1u)
-        || (!dispelUsesFullGuid && !packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t victimGuid = dispelUsesFullGuid
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(9)) return;
-    /*uint32_t dispelSpell =*/ packet.readUInt32();
-    uint8_t isStolen = packet.readUInt8();
-    uint32_t count   = packet.readUInt32();
-    // Preserve every dispelled aura in the combat log instead of collapsing
-    // multi-aura packets down to the first entry only.
-    const size_t dispelEntrySize = dispelUsesFullGuid ? 8u : 5u;
-    std::vector<uint32_t> dispelledIds;
-    dispelledIds.reserve(count);
-    for (uint32_t i = 0; i < count && packet.hasRemaining(dispelEntrySize); ++i) {
-        uint32_t dispelledId = packet.readUInt32();
-        if (dispelUsesFullGuid) {
-            /*uint32_t unk =*/ packet.readUInt32();
-        } else {
-            /*uint8_t isPositive =*/ packet.readUInt8();
-        }
-        if (dispelledId != 0) {
-            dispelledIds.push_back(dispelledId);
-        }
-    }
-    // Show system message if player was victim or caster
-    if (victimGuid == owner_.playerGuid || casterGuid == owner_.playerGuid) {
-        std::vector<uint32_t> loggedIds;
-        if (isStolen) {
-            loggedIds.reserve(dispelledIds.size());
-            for (uint32_t dispelledId : dispelledIds) {
-                if (owner_.shouldLogSpellstealAura(casterGuid, victimGuid, dispelledId))
-                    loggedIds.push_back(dispelledId);
-            }
-        } else {
-            loggedIds = dispelledIds;
-        }
-
-        const std::string displaySpellNames = formatSpellNameList(owner_, loggedIds);
-        if (!displaySpellNames.empty()) {
-            char buf[256];
-            const char* passiveVerb = loggedIds.size() == 1 ? "was" : "were";
-            if (isStolen) {
-                if (victimGuid == owner_.playerGuid && casterGuid != owner_.playerGuid)
-                    std::snprintf(buf, sizeof(buf), "%s %s stolen.",
-                                  displaySpellNames.c_str(), passiveVerb);
-                else if (casterGuid == owner_.playerGuid)
-                    std::snprintf(buf, sizeof(buf), "You steal %s.", displaySpellNames.c_str());
-                else
-                    std::snprintf(buf, sizeof(buf), "%s %s stolen.",
-                                  displaySpellNames.c_str(), passiveVerb);
-            } else {
-                if (victimGuid == owner_.playerGuid && casterGuid != owner_.playerGuid)
-                    std::snprintf(buf, sizeof(buf), "%s %s dispelled.",
-                                  displaySpellNames.c_str(), passiveVerb);
-                else if (casterGuid == owner_.playerGuid)
-                    std::snprintf(buf, sizeof(buf), "You dispel %s.", displaySpellNames.c_str());
-                else
-                    std::snprintf(buf, sizeof(buf), "%s %s dispelled.",
-                                  displaySpellNames.c_str(), passiveVerb);
-            }
-            owner_.addSystemChatMessage(buf);
-        }
-        // Preserve stolen auras as spellsteal events so the log wording stays accurate.
-        if (!loggedIds.empty()) {
-            bool isPlayerCaster = (casterGuid == owner_.playerGuid);
-            for (uint32_t dispelledId : loggedIds) {
-                owner_.addCombatText(isStolen ? CombatTextEntry::STEAL : CombatTextEntry::DISPEL,
-                              0, dispelledId, isPlayerCaster, 0,
-                              casterGuid, victimGuid);
-            }
-        }
-    }
-    packet.skipAll();
-}
-
-void SpellHandler::handleSpellStealLog(network::Packet& packet) {
-    // Sent to the CASTER (Mage) when Spellsteal succeeds.
-    // Wire format mirrors SPELLDISPELLOG:
-    // WotLK/Classic/Turtle: packed victim + packed caster + uint32 spellId + uint8 isStolen + uint32 count
-    //                        + count × (uint32 stolenSpellId + uint8 isPositive)
-    // TBC:                   full uint64 victim + full uint64 caster + same tail
-    const bool stealUsesFullGuid = isActiveExpansion("tbc");
-    if (!packet.hasRemaining(stealUsesFullGuid ? 8u : 1u)
-        || (!stealUsesFullGuid && !packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t stealVictim = stealUsesFullGuid
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(stealUsesFullGuid ? 8u : 1u)
-        || (!stealUsesFullGuid && !packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t stealCaster = stealUsesFullGuid
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(9)) {
-        packet.skipAll(); return;
-    }
-    /*uint32_t stealSpellId =*/ packet.readUInt32();
-    /*uint8_t  isStolen    =*/ packet.readUInt8();
-    uint32_t stealCount   = packet.readUInt32();
-    // Preserve every stolen aura in the combat log instead of only the first.
-    const size_t stealEntrySize = stealUsesFullGuid ? 8u : 5u;
-    std::vector<uint32_t> stolenIds;
-    stolenIds.reserve(stealCount);
-    for (uint32_t i = 0; i < stealCount && packet.hasRemaining(stealEntrySize); ++i) {
-        uint32_t stolenId = packet.readUInt32();
-        if (stealUsesFullGuid) {
-            /*uint32_t unk =*/ packet.readUInt32();
-        } else {
-            /*uint8_t isPos  =*/ packet.readUInt8();
-        }
-        if (stolenId != 0) {
-            stolenIds.push_back(stolenId);
-        }
-    }
-    if (stealCaster == owner_.playerGuid || stealVictim == owner_.playerGuid) {
-        std::vector<uint32_t> loggedIds;
-        loggedIds.reserve(stolenIds.size());
-        for (uint32_t stolenId : stolenIds) {
-            if (owner_.shouldLogSpellstealAura(stealCaster, stealVictim, stolenId))
-                loggedIds.push_back(stolenId);
-        }
-
-        const std::string stealDisplayNames = formatSpellNameList(owner_, loggedIds);
-        if (!stealDisplayNames.empty()) {
-            char buf[256];
-            if (stealCaster == owner_.playerGuid)
-                std::snprintf(buf, sizeof(buf), "You stole %s.", stealDisplayNames.c_str());
-            else
-                std::snprintf(buf, sizeof(buf), "%s %s stolen.", stealDisplayNames.c_str(),
-                              loggedIds.size() == 1 ? "was" : "were");
-            owner_.addSystemChatMessage(buf);
-        }
-        // Some servers emit both SPELLDISPELLOG(isStolen=1) and SPELLSTEALLOG
-        // for the same aura. Keep the first event and suppress the duplicate.
-        if (!loggedIds.empty()) {
-            bool isPlayerCaster = (stealCaster == owner_.playerGuid);
-            for (uint32_t stolenId : loggedIds) {
-                owner_.addCombatText(CombatTextEntry::STEAL, 0, stolenId, isPlayerCaster, 0,
-                              stealCaster, stealVictim);
-            }
-        }
-    }
-    packet.skipAll();
-}
-
-void SpellHandler::handleSpellChanceProcLog(network::Packet& packet) {
-    // WotLK/Classic/Turtle: packed_guid target + packed_guid caster + uint32 spellId + ...
-    // TBC:                  uint64 target + uint64 caster + uint32 spellId + ...
-    const bool procChanceUsesFullGuid = isActiveExpansion("tbc");
-    auto readProcChanceGuid = [&]() -> uint64_t {
-        if (procChanceUsesFullGuid)
-            return (packet.hasRemaining(8)) ? packet.readUInt64() : 0;
-        return packet.readPackedGuid();
-    };
-    if (!packet.hasRemaining(procChanceUsesFullGuid ? 8u : 1u)
-        || (!procChanceUsesFullGuid && !packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t procTargetGuid = readProcChanceGuid();
-    if (!packet.hasRemaining(procChanceUsesFullGuid ? 8u : 1u)
-        || (!procChanceUsesFullGuid && !packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t procCasterGuid = readProcChanceGuid();
-    if (!packet.hasRemaining(4)) {
-        packet.skipAll(); return;
-    }
-    uint32_t procSpellId = packet.readUInt32();
-    // Show a "PROC!" floating text when the player triggers the proc
-    if (procCasterGuid == owner_.playerGuid && procSpellId > 0)
-        owner_.addCombatText(CombatTextEntry::PROC_TRIGGER, 0, procSpellId, true, 0,
-                      procCasterGuid, procTargetGuid);
-    packet.skipAll();
-}
-
-void SpellHandler::handleSpellInstaKillLog(network::Packet& packet) {
-    // Sent when a unit is killed by a spell with SPELL_ATTR_EX2_INSTAKILL (e.g. Execute, Obliterate, etc.)
-    // WotLK/Classic/Turtle: packed_guid caster + packed_guid victim + uint32 spellId
-    // TBC:                  full uint64 caster + full uint64 victim + uint32 spellId
-    const bool ikUsesFullGuid = isActiveExpansion("tbc");
-    auto ik_rem = [&]() { return packet.getRemainingSize(); };
-    if (ik_rem() < (ikUsesFullGuid ? 8u : 1u)
-        || (!ikUsesFullGuid && !packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t ikCaster = ikUsesFullGuid
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (ik_rem() < (ikUsesFullGuid ? 8u : 1u)
-        || (!ikUsesFullGuid && !packet.hasFullPackedGuid())) {
-        packet.skipAll(); return;
-    }
-    uint64_t ikVictim = ikUsesFullGuid
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (ik_rem() < 4) {
-        packet.skipAll(); return;
-    }
-    uint32_t ikSpell = packet.readUInt32();
-    // Show kill/death feedback for the local player
-    if (ikCaster == owner_.playerGuid) {
-        owner_.addCombatText(CombatTextEntry::INSTAKILL, 0, ikSpell, true, 0, ikCaster, ikVictim);
-    } else if (ikVictim == owner_.playerGuid) {
-        owner_.addCombatText(CombatTextEntry::INSTAKILL, 0, ikSpell, false, 0, ikCaster, ikVictim);
-        owner_.addUIError("You were killed by an instant-kill effect.");
-        owner_.addSystemChatMessage("You were killed by an instant-kill effect.");
-    }
-    LOG_DEBUG("SMSG_SPELLINSTAKILLLOG: caster=0x", std::hex, ikCaster,
-              " victim=0x", ikVictim, std::dec, " spell=", ikSpell);
-    packet.skipAll();
-}
-
-void SpellHandler::handleSpellLogExecute(network::Packet& packet) {
-    // WotLK/Classic/Turtle: packed_guid caster + uint32 spellId + uint32 effectCount
-    // TBC:                  uint64 caster + uint32 spellId + uint32 effectCount
-    // Per-effect: uint8 effectType + uint32 effectLogCount + effect-specific data
-    // Effect 10 = POWER_DRAIN:   packed_guid target + uint32 amount + uint32 powerType + float multiplier
-    // Effect 11 = HEALTH_LEECH:  packed_guid target + uint32 amount + float multiplier
-    // Effect 24 = CREATE_ITEM:   uint32 itemEntry
-    // Effect 26 = INTERRUPT_CAST: packed_guid target + uint32 interrupted_spell_id
-    // Effect 49 = FEED_PET:      uint32 itemEntry
-    // Effect 114= CREATE_ITEM2:  uint32 itemEntry (same layout as CREATE_ITEM)
-    const bool exeUsesFullGuid = isActiveExpansion("tbc");
-    if (!packet.hasRemaining(exeUsesFullGuid ? 8u : 1u) ) {
-        packet.skipAll(); return;
-    }
-    if (!exeUsesFullGuid && !packet.hasFullPackedGuid()) {
-        packet.skipAll(); return;
-    }
-    uint64_t exeCaster = exeUsesFullGuid
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (!packet.hasRemaining(8)) {
-        packet.skipAll(); return;
-    }
-    uint32_t exeSpellId = packet.readUInt32();
-    uint32_t exeEffectCount = packet.readUInt32();
-    exeEffectCount = std::min(exeEffectCount, 32u); // sanity
-
-    const bool isPlayerCaster = (exeCaster == owner_.playerGuid);
-    for (uint32_t ei = 0; ei < exeEffectCount; ++ei) {
-        if (!packet.hasRemaining(5)) break;
-        uint8_t  effectType     = packet.readUInt8();
-        uint32_t effectLogCount = packet.readUInt32();
-        effectLogCount = std::min(effectLogCount, 64u); // sanity
-        if (effectType == SpellEffect::POWER_DRAIN) {
-            // SPELL_EFFECT_POWER_DRAIN: packed_guid target + uint32 amount + uint32 powerType + float multiplier
-            for (uint32_t li = 0; li < effectLogCount; ++li) {
-                if (!packet.hasRemaining(exeUsesFullGuid ? 8u : 1u)
-                    || (!exeUsesFullGuid && !packet.hasFullPackedGuid())) {
-                    packet.skipAll(); break;
-                }
-                uint64_t drainTarget = exeUsesFullGuid
-                    ? packet.readUInt64()
-                    : packet.readPackedGuid();
-                if (!packet.hasRemaining(12)) { packet.skipAll(); break; }
-                uint32_t drainAmount = packet.readUInt32();
-                uint32_t drainPower  = packet.readUInt32(); // 0=mana,1=rage,3=energy,6=runic
-                float drainMult = packet.readFloat();
-                if (drainAmount > 0) {
-                    if (drainTarget == owner_.playerGuid)
-                        owner_.addCombatText(CombatTextEntry::POWER_DRAIN, static_cast<int32_t>(drainAmount), exeSpellId, false,
-                                      static_cast<uint8_t>(drainPower),
-                                      exeCaster, drainTarget);
-                    if (isPlayerCaster) {
-                        if (drainTarget != owner_.playerGuid) {
-                            owner_.addCombatText(CombatTextEntry::POWER_DRAIN, static_cast<int32_t>(drainAmount), exeSpellId, true,
-                                          static_cast<uint8_t>(drainPower), exeCaster, drainTarget);
-                        }
-                        if (drainMult > 0.0f && std::isfinite(drainMult)) {
-                            const uint32_t gainedAmount = static_cast<uint32_t>(
-                                std::lround(static_cast<double>(drainAmount) * static_cast<double>(drainMult)));
-                            if (gainedAmount > 0) {
-                                owner_.addCombatText(CombatTextEntry::ENERGIZE, static_cast<int32_t>(gainedAmount), exeSpellId, true,
-                                              static_cast<uint8_t>(drainPower), exeCaster, exeCaster);
-                            }
-                        }
-                    }
-                }
-                LOG_DEBUG("SMSG_SPELLLOGEXECUTE POWER_DRAIN: spell=", exeSpellId,
-                          " power=", drainPower, " amount=", drainAmount,
-                          " multiplier=", drainMult);
-            }
-        } else if (effectType == SpellEffect::HEALTH_LEECH) {
-            // SPELL_EFFECT_HEALTH_LEECH: packed_guid target + uint32 amount + float multiplier
-            for (uint32_t li = 0; li < effectLogCount; ++li) {
-                if (!packet.hasRemaining(exeUsesFullGuid ? 8u : 1u)
-                    || (!exeUsesFullGuid && !packet.hasFullPackedGuid())) {
-                    packet.skipAll(); break;
-                }
-                uint64_t leechTarget = exeUsesFullGuid
-                    ? packet.readUInt64()
-                    : packet.readPackedGuid();
-                if (!packet.hasRemaining(8)) { packet.skipAll(); break; }
-                uint32_t leechAmount = packet.readUInt32();
-                float leechMult = packet.readFloat();
-                if (leechAmount > 0) {
-                    if (leechTarget == owner_.playerGuid) {
-                        owner_.addCombatText(CombatTextEntry::SPELL_DAMAGE, static_cast<int32_t>(leechAmount), exeSpellId, false, 0,
-                                      exeCaster, leechTarget);
-                    } else if (isPlayerCaster) {
-                        owner_.addCombatText(CombatTextEntry::SPELL_DAMAGE, static_cast<int32_t>(leechAmount), exeSpellId, true, 0,
-                                      exeCaster, leechTarget);
-                    }
-                    if (isPlayerCaster && leechMult > 0.0f && std::isfinite(leechMult)) {
-                        const uint32_t gainedAmount = static_cast<uint32_t>(
-                            std::lround(static_cast<double>(leechAmount) * static_cast<double>(leechMult)));
-                        if (gainedAmount > 0) {
-                            owner_.addCombatText(CombatTextEntry::HEAL, static_cast<int32_t>(gainedAmount), exeSpellId, true, 0,
-                                          exeCaster, exeCaster);
-                        }
-                    }
-                }
-                LOG_DEBUG("SMSG_SPELLLOGEXECUTE HEALTH_LEECH: spell=", exeSpellId,
-                          " amount=", leechAmount, " multiplier=", leechMult);
-            }
-        } else if (effectType == SpellEffect::CREATE_ITEM || effectType == SpellEffect::CREATE_ITEM2) {
-            // SPELL_EFFECT_CREATE_ITEM / CREATE_ITEM2: uint32 itemEntry per log entry
-            for (uint32_t li = 0; li < effectLogCount; ++li) {
-                if (!packet.hasRemaining(4)) break;
-                uint32_t itemEntry = packet.readUInt32();
-                if (isPlayerCaster && itemEntry != 0) {
-                    owner_.ensureItemInfo(itemEntry);
-                    const ItemQueryResponseData* info = owner_.getItemInfo(itemEntry);
-                    std::string itemName = info && !info->name.empty()
-                        ? info->name : ("item #" + std::to_string(itemEntry));
-                    const auto& spellName = owner_.getSpellName(exeSpellId);
-                    std::string msg = spellName.empty()
-                        ? ("You create: " + itemName + ".")
-                        : ("You create " + itemName + " using " + spellName + ".");
-                    owner_.addSystemChatMessage(msg);
-                    LOG_DEBUG("SMSG_SPELLLOGEXECUTE CREATE_ITEM: spell=", exeSpellId,
-                              " item=", itemEntry, " name=", itemName);
-
-                    // Repeat-craft queue: re-cast if more crafts remaining
-                    if (craftQueueRemaining_ > 0 && craftQueueSpellId_ == exeSpellId) {
-                        --craftQueueRemaining_;
-                        if (craftQueueRemaining_ > 0) {
-                            castSpell(craftQueueSpellId_, 0);
-                        } else {
-                            craftQueueSpellId_ = 0;
-                        }
-                    }
-                }
-            }
-        } else if (effectType == SpellEffect::INTERRUPT_CAST) {
-            // SPELL_EFFECT_INTERRUPT_CAST: packed_guid target + uint32 interrupted_spell_id
-            for (uint32_t li = 0; li < effectLogCount; ++li) {
-                if (!packet.hasRemaining(exeUsesFullGuid ? 8u : 1u)
-                    || (!exeUsesFullGuid && !packet.hasFullPackedGuid())) {
-                    packet.skipAll(); break;
-                }
-                uint64_t icTarget = exeUsesFullGuid
-                    ? packet.readUInt64()
-                    : packet.readPackedGuid();
-                if (!packet.hasRemaining(4)) { packet.skipAll(); break; }
-                uint32_t icSpellId = packet.readUInt32();
-                // Clear the interrupted unit's cast bar immediately
-                unitCastStates_.erase(icTarget);
-                // Record interrupt in combat log when player is involved
-                if (isPlayerCaster || icTarget == owner_.playerGuid)
-                    owner_.addCombatText(CombatTextEntry::INTERRUPT, 0, icSpellId, isPlayerCaster, 0,
-                                  exeCaster, icTarget);
-                LOG_DEBUG("SMSG_SPELLLOGEXECUTE INTERRUPT_CAST: spell=", exeSpellId,
-                          " interrupted=", icSpellId, " target=0x", std::hex, icTarget, std::dec);
-            }
-        } else if (effectType == SpellEffect::FEED_PET) {
-            // SPELL_EFFECT_FEED_PET: uint32 itemEntry per log entry
-            for (uint32_t li = 0; li < effectLogCount; ++li) {
-                if (!packet.hasRemaining(4)) break;
-                uint32_t feedItem = packet.readUInt32();
-                if (isPlayerCaster && feedItem != 0) {
-                    owner_.ensureItemInfo(feedItem);
-                    const ItemQueryResponseData* info = owner_.getItemInfo(feedItem);
-                    std::string itemName = info && !info->name.empty()
-                        ? info->name : ("item #" + std::to_string(feedItem));
-                    uint32_t feedQuality = info ? info->quality : 1u;
-                    owner_.addSystemChatMessage("You feed your pet " + buildItemLink(feedItem, feedQuality, itemName) + ".");
-                    LOG_DEBUG("SMSG_SPELLLOGEXECUTE FEED_PET: item=", feedItem, " name=", itemName);
-                }
-            }
-        } else {
-            // Unknown effect type — stop parsing to avoid misalignment
-            packet.skipAll();
-            break;
-        }
-    }
-    packet.skipAll();
-}
-
-void SpellHandler::handleClearExtraAuraInfo(network::Packet& packet) {
-    // TBC 2.4.3: clear a single aura slot for a unit
-    // Format: uint64 targetGuid + uint8 slot
-    if (packet.hasRemaining(9)) {
-        uint64_t clearGuid  = packet.readUInt64();
-        uint8_t  slot       = packet.readUInt8();
-        std::vector<AuraSlot>* auraList = nullptr;
-        if (clearGuid == owner_.playerGuid)       auraList = &playerAuras_;
-        else if (clearGuid == owner_.targetGuid)   auraList = &targetAuras_;
-        if (auraList && slot < auraList->size()) {
-            (*auraList)[slot] = AuraSlot{};
-        }
-    }
-    packet.skipAll();
-}
-
-void SpellHandler::handleItemEnchantTimeUpdate(network::Packet& packet) {
-    // Format: uint64 itemGuid + uint32 slot + uint32 durationSec + uint64 playerGuid
-    // slot: 0=main-hand, 1=off-hand, 2=ranged
-    if (!packet.hasRemaining(24)) {
-        packet.skipAll(); return;
-    }
-    /*uint64_t itemGuid =*/ packet.readUInt64();
-    uint32_t enchSlot    = packet.readUInt32();
-    uint32_t durationSec = packet.readUInt32();
-    /*uint64_t playerGuid =*/ packet.readUInt64();
-
-    // Clamp to known slots (0-2)
-    if (enchSlot > 2) { return; }
-
-    uint64_t nowMs = static_cast<uint64_t>(
-        std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now().time_since_epoch()).count());
-
-    if (durationSec == 0) {
-        // Enchant expired / removed — erase the slot entry
-        owner_.tempEnchantTimers_.erase(
-            std::remove_if(owner_.tempEnchantTimers_.begin(), owner_.tempEnchantTimers_.end(),
-                           [enchSlot](const GameHandler::TempEnchantTimer& t) { return t.slot == enchSlot; }),
-            owner_.tempEnchantTimers_.end());
-    } else {
-        uint64_t expireMs = nowMs + static_cast<uint64_t>(durationSec) * 1000u;
-        bool found = false;
-        for (auto& t : owner_.tempEnchantTimers_) {
-            if (t.slot == enchSlot) { t.expireMs = expireMs; found = true; break; }
-        }
-        if (!found) owner_.tempEnchantTimers_.push_back({enchSlot, expireMs});
-
-        // Warn at important thresholds
-        if (durationSec <= 60 && durationSec > 55) {
-            const char* slotName = (enchSlot < 3) ? owner_.kTempEnchantSlotNames[enchSlot] : "weapon";
-            char buf[80];
-            std::snprintf(buf, sizeof(buf), "Weapon enchant (%s) expires in 1 minute!", slotName);
-            owner_.addSystemChatMessage(buf);
-        } else if (durationSec <= 300 && durationSec > 295) {
-            const char* slotName = (enchSlot < 3) ? owner_.kTempEnchantSlotNames[enchSlot] : "weapon";
-            char buf[80];
-            std::snprintf(buf, sizeof(buf), "Weapon enchant (%s) expires in 5 minutes.", slotName);
-            owner_.addSystemChatMessage(buf);
-        }
-    }
-    LOG_DEBUG("SMSG_ITEM_ENCHANT_TIME_UPDATE: slot=", enchSlot, " dur=", durationSec, "s");
-}
-
-void SpellHandler::handleResumeCastBar(network::Packet& packet) {
-    // WotLK: packed_guid caster + packed_guid target + uint32 spellId + uint32 remainingMs + uint32 totalMs + uint8 schoolMask
-    // TBC/Classic: uint64 caster + uint64 target + ...
-    const bool rcbTbc = isPreWotlk();
-    auto remaining = [&]() { return packet.getRemainingSize(); };
-    if (remaining() < (rcbTbc ? 8u : 1u)) return;
-    uint64_t caster = rcbTbc
-        ? packet.readUInt64() : packet.readPackedGuid();
-    if (remaining() < (rcbTbc ? 8u : 1u)) return;
-    if (rcbTbc) packet.readUInt64(); // target (discard)
-    else (void)packet.readPackedGuid(); // target
-    if (remaining() < 12) return;
-    uint32_t spellId   = packet.readUInt32();
-    uint32_t remainMs  = packet.readUInt32();
-    uint32_t totalMs   = packet.readUInt32();
-    if (totalMs > 0) {
-        if (caster == owner_.playerGuid) {
-            casting_            = true;
-            castIsChannel_      = false;
-            currentCastSpellId_ = spellId;
-            castTimeTotal_      = totalMs  / 1000.0f;
-            castTimeRemaining_  = remainMs / 1000.0f;
-        } else {
-            auto& s = unitCastStates_[caster];
-            s.casting       = true;
-            s.spellId       = spellId;
-            s.timeTotal     = totalMs  / 1000.0f;
-            s.timeRemaining = remainMs / 1000.0f;
-        }
-        LOG_DEBUG("SMSG_RESUME_CAST_BAR: caster=0x", std::hex, caster, std::dec,
-                  " spell=", spellId, " remaining=", remainMs, "ms total=", totalMs, "ms");
-    }
-}
-
-void SpellHandler::handleChannelStart(network::Packet& packet) {
-    // casterGuid + uint32 spellId + uint32 totalDurationMs
-    const bool tbcOrClassic = isPreWotlk();
-    uint64_t chanCaster = tbcOrClassic
-        ? (packet.hasRemaining(8) ? packet.readUInt64() : 0)
-        : packet.readPackedGuid();
-    if (!packet.hasRemaining(8)) return;
-    uint32_t chanSpellId = packet.readUInt32();
-    uint32_t chanTotalMs = packet.readUInt32();
-    if (chanTotalMs > 0 && chanCaster != 0) {
-        if (chanCaster == owner_.playerGuid) {
-            casting_            = true;
-            castIsChannel_      = true;
-            currentCastSpellId_ = chanSpellId;
-            castTimeTotal_      = chanTotalMs / 1000.0f;
-            castTimeRemaining_  = castTimeTotal_;
-        } else {
-            auto& s = unitCastStates_[chanCaster];
-            s.casting        = true;
-            s.isChannel      = true;
-            s.spellId        = chanSpellId;
-            s.timeTotal      = chanTotalMs / 1000.0f;
-            s.timeRemaining  = s.timeTotal;
-            s.interruptible  = owner_.isSpellInterruptible(chanSpellId);
-        }
-        LOG_DEBUG("MSG_CHANNEL_START: caster=0x", std::hex, chanCaster, std::dec,
-                  " spell=", chanSpellId, " total=", chanTotalMs, "ms");
-
-        // Play channeling animation (looping)
-        // Channel packets don't carry targetGuid — use player's current target as hint
-        SpellCastType chanType = SpellCastType::OMNI;
-        if (chanCaster == owner_.playerGuid && owner_.targetGuid != 0)
-            chanType = SpellCastType::DIRECTED;
-        if (owner_.spellCastAnimCallback_) {
-            owner_.spellCastAnimCallback_(chanCaster, true, true, chanType);
-        }
-
-        // Fire UNIT_SPELLCAST_CHANNEL_START for Lua addons
-        if (owner_.addonEventCallback_) {
-            auto unitId = owner_.guidToUnitId(chanCaster);
-            if (!unitId.empty())
-                owner_.fireAddonEvent("UNIT_SPELLCAST_CHANNEL_START", {unitId, std::to_string(chanSpellId)});
-        }
-    }
-}
-
-void SpellHandler::handleChannelUpdate(network::Packet& packet) {
-    // casterGuid + uint32 remainingMs
-    const bool tbcOrClassic2 = isPreWotlk();
-    uint64_t chanCaster2 = tbcOrClassic2
-        ? (packet.hasRemaining(8) ? packet.readUInt64() : 0)
-        : packet.readPackedGuid();
-    if (!packet.hasRemaining(4)) return;
-    uint32_t chanRemainMs = packet.readUInt32();
-    if (chanCaster2 == owner_.playerGuid) {
-        castTimeRemaining_ = chanRemainMs / 1000.0f;
-        if (chanRemainMs == 0) {
-            casting_ = false;
-            castIsChannel_ = false;
-            currentCastSpellId_ = 0;
-        }
-    } else if (chanCaster2 != 0) {
-        auto it = unitCastStates_.find(chanCaster2);
-        if (it != unitCastStates_.end()) {
-            it->second.timeRemaining = chanRemainMs / 1000.0f;
-            if (chanRemainMs == 0) unitCastStates_.erase(it);
-        }
-    }
-    LOG_DEBUG("MSG_CHANNEL_UPDATE: caster=0x", std::hex, chanCaster2, std::dec,
-              " remaining=", chanRemainMs, "ms");
-    // Fire UNIT_SPELLCAST_CHANNEL_STOP when channel ends
-    if (chanRemainMs == 0) {
-        // Stop channeling animation — return to idle
-        if (owner_.spellCastAnimCallback_) {
-            owner_.spellCastAnimCallback_(chanCaster2, false, true, SpellCastType::OMNI);
-        }
-        auto unitId = owner_.guidToUnitId(chanCaster2);
-        if (!unitId.empty())
-            owner_.fireAddonEvent("UNIT_SPELLCAST_CHANNEL_STOP", {unitId});
-    }
-}
-
-// ============================================================
-// Pet Stable
-// ============================================================
-
-void SpellHandler::requestStabledPetList() {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || owner_.stableMasterGuid_ == 0) return;
-    auto pkt = ListStabledPetsPacket::build(owner_.stableMasterGuid_);
-    owner_.socket->send(pkt);
-    LOG_INFO("Sent MSG_LIST_STABLED_PETS to npc=0x", std::hex, owner_.stableMasterGuid_, std::dec);
-}
-
-void SpellHandler::stablePet(uint8_t slot) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || owner_.stableMasterGuid_ == 0) return;
-    if (owner_.petGuid_ == 0) {
-        owner_.addSystemChatMessage("You do not have an active pet to stable.");
-        return;
-    }
-    auto pkt = StablePetPacket::build(owner_.stableMasterGuid_, slot);
-    owner_.socket->send(pkt);
-    LOG_INFO("Sent CMSG_STABLE_PET: slot=", static_cast<int>(slot));
-}
-
-void SpellHandler::unstablePet(uint32_t petNumber) {
-    if (owner_.state != WorldState::IN_WORLD || !owner_.socket || owner_.stableMasterGuid_ == 0 || petNumber == 0) return;
-    auto pkt = UnstablePetPacket::build(owner_.stableMasterGuid_, petNumber);
-    owner_.socket->send(pkt);
-    LOG_INFO("Sent CMSG_UNSTABLE_PET: petNumber=", petNumber);
-}
-
-} // namespace game
-} // namespace wowee
diff --git a/src/game/transport_manager.cpp b/src/game/transport_manager.cpp
index 113dfad5..955f8eaa 100644
--- a/src/game/transport_manager.cpp
+++ b/src/game/transport_manager.cpp
@@ -9,6 +9,7 @@
 #include <glm/gtc/constants.hpp>
 #include <glm/gtx/quaternion.hpp>
 #include <cmath>
+#include <iostream>
 #include <map>
 #include <algorithm>
 
@@ -30,13 +31,13 @@ void TransportManager::update(float deltaTime) {
 void TransportManager::registerTransport(uint64_t guid, uint32_t wmoInstanceId, uint32_t pathId, const glm::vec3& spawnWorldPos, uint32_t entry) {
     auto pathIt = paths_.find(pathId);
     if (pathIt == paths_.end()) {
-        LOG_ERROR("TransportManager: Path ", pathId, " not found for transport ", guid);
+        std::cerr << "TransportManager: Path " << pathId << " not found for transport " << guid << std::endl;
         return;
     }
 
     const auto& path = pathIt->second;
     if (path.points.empty()) {
-        LOG_ERROR("TransportManager: Path ", pathId, " has no waypoints");
+        std::cerr << "TransportManager: Path " << pathId << " has no waypoints" << std::endl;
         return;
     }
 
@@ -66,7 +67,7 @@ void TransportManager::registerTransport(uint64_t guid, uint32_t wmoInstanceId,
         // TransportAnimation paths are local offsets; first waypoint is expected near origin.
         // Warn only if the local path itself looks suspicious.
         glm::vec3 firstWaypoint = path.points[0].pos;
-        if (glm::dot(firstWaypoint, firstWaypoint) > 100.0f) {
+        if (glm::length(firstWaypoint) > 10.0f) {
             LOG_WARNING("Transport 0x", std::hex, guid, std::dec, " path ", pathId,
                         ": first local waypoint far from origin: (",
                         firstWaypoint.x, ",", firstWaypoint.y, ",", firstWaypoint.z, ")");
@@ -98,7 +99,7 @@ void TransportManager::registerTransport(uint64_t guid, uint32_t wmoInstanceId,
 
     if (transport.useClientAnimation && path.durationMs > 0) {
         // Seed to a stable phase based on our local clock so elevators don't all start at t=0.
-        transport.localClockMs = static_cast<uint32_t>(elapsedTime_ * 1000.0) % path.durationMs;
+        transport.localClockMs = static_cast<uint32_t>(elapsedTime_ * 1000.0f) % path.durationMs;
         LOG_INFO("TransportManager: Enabled client animation for transport 0x",
                  std::hex, guid, std::dec, " path=", pathId,
                  " durationMs=", path.durationMs, " seedMs=", transport.localClockMs,
@@ -127,7 +128,7 @@ void TransportManager::registerTransport(uint64_t guid, uint32_t wmoInstanceId,
 
 void TransportManager::unregisterTransport(uint64_t guid) {
     transports_.erase(guid);
-    LOG_INFO("TransportManager: Unregistered transport ", guid);
+    std::cout << "TransportManager: Unregistered transport " << guid << std::endl;
 }
 
 ActiveTransport* TransportManager::getTransport(uint64_t guid) {
@@ -167,7 +168,7 @@ glm::mat4 TransportManager::getTransportInvTransform(uint64_t transportGuid) {
 
 void TransportManager::loadPathFromNodes(uint32_t pathId, const std::vector<glm::vec3>& waypoints, bool looping, float speed) {
     if (waypoints.empty()) {
-        LOG_ERROR("TransportManager: Cannot load empty path ", pathId);
+        std::cerr << "TransportManager: Cannot load empty path " << pathId << std::endl;
         return;
     }
 
@@ -179,7 +180,7 @@ void TransportManager::loadPathFromNodes(uint32_t pathId, const std::vector<glm:
     // Helper: compute segment duration from distance and speed
     auto segMsFromDist = [&](float dist) -> uint32_t {
         if (speed <= 0.0f) return 1000;
-        return static_cast<uint32_t>((dist / speed) * 1000.0f);
+        return (uint32_t)((dist / speed) * 1000.0f);
     };
 
     // Single point = stationary (durationMs = 0)
@@ -203,17 +204,16 @@ void TransportManager::loadPathFromNodes(uint32_t pathId, const std::vector<glm:
         path.points.push_back({cumulativeMs, waypoints[i]});
     }
 
-    // Add explicit wrap segment (last → first) for looping paths.
-    // By duplicating the first point at the end with cumulative time, the path
-    // becomes time-closed and evalTimedCatmullRom handles wrap via modular time
-    // instead of index wrapping — so looping is always false after construction.
+    // Add explicit wrap segment (last → first) for looping paths
     if (looping) {
         float wrapDist = glm::distance(waypoints.back(), waypoints.front());
         uint32_t wrapMs = glm::max(1u, segMsFromDist(wrapDist));
         cumulativeMs += wrapMs;
-        path.points.push_back({cumulativeMs, waypoints.front()});
+        path.points.push_back({cumulativeMs, waypoints.front()});  // Duplicate first point
+        path.looping = false;  // Time-closed path, no need for index wrapping
+    } else {
+        path.looping = false;
     }
-    path.looping = false;
 
     path.durationMs = cumulativeMs;
     paths_[pathId] = path;
@@ -227,7 +227,7 @@ void TransportManager::loadPathFromNodes(uint32_t pathId, const std::vector<glm:
 void TransportManager::setDeckBounds(uint64_t guid, const glm::vec3& min, const glm::vec3& max) {
     auto* transport = getTransport(guid);
     if (!transport) {
-        LOG_ERROR("TransportManager: Cannot set deck bounds for unknown transport ", guid);
+        std::cerr << "TransportManager: Cannot set deck bounds for unknown transport " << guid << std::endl;
         return;
     }
 
@@ -251,25 +251,23 @@ void TransportManager::updateTransportMovement(ActiveTransport& transport, float
     if (path.durationMs == 0) {
         // Just update transform (position already set)
         updateTransformMatrices(transport);
-        if (transport.isM2) {
-            if (m2Renderer_) m2Renderer_->setInstanceTransform(transport.wmoInstanceId, transport.transform);
-        } else {
-            if (wmoRenderer_) wmoRenderer_->setInstanceTransform(transport.wmoInstanceId, transport.transform);
+        if (wmoRenderer_) {
+            wmoRenderer_->setInstanceTransform(transport.wmoInstanceId, transport.transform);
         }
         return;
     }
 
     // Evaluate path time
-    uint32_t nowMs = static_cast<uint32_t>(elapsedTime_ * 1000.0);
+    uint32_t nowMs = (uint32_t)(elapsedTime_ * 1000.0f);
     uint32_t pathTimeMs = 0;
 
     if (transport.hasServerClock) {
         // Predict server time using clock offset (works for both client and server-driven modes)
-        int64_t serverTimeMs = static_cast<int64_t>(nowMs) + transport.serverClockOffsetMs;
-        int64_t mod = static_cast<int64_t>(path.durationMs);
+        int64_t serverTimeMs = (int64_t)nowMs + transport.serverClockOffsetMs;
+        int64_t mod = (int64_t)path.durationMs;
         int64_t wrapped = serverTimeMs % mod;
         if (wrapped < 0) wrapped += mod;
-        pathTimeMs = static_cast<uint32_t>(wrapped);
+        pathTimeMs = (uint32_t)wrapped;
     } else if (transport.useClientAnimation) {
         // Pure local clock (no server sync yet, client-driven)
         uint32_t dtMs = static_cast<uint32_t>(deltaTime * 1000.0f);
@@ -289,10 +287,8 @@ void TransportManager::updateTransportMovement(ActiveTransport& transport, float
     } else {
         // Strict server-authoritative mode: do not guess movement between server snapshots.
         updateTransformMatrices(transport);
-        if (transport.isM2) {
-            if (m2Renderer_) m2Renderer_->setInstanceTransform(transport.wmoInstanceId, transport.transform);
-        } else {
-            if (wmoRenderer_) wmoRenderer_->setInstanceTransform(transport.wmoInstanceId, transport.transform);
+        if (wmoRenderer_) {
+            wmoRenderer_->setInstanceTransform(transport.wmoInstanceId, transport.transform);
         }
         return;
     }
@@ -302,16 +298,14 @@ void TransportManager::updateTransportMovement(ActiveTransport& transport, float
     // Guard against bad fallback Z curves on some remapped transport paths (notably icebreakers),
     // where path offsets can sink far below sea level when we only have spawn-time data.
     // Skip Z clamping for world-coordinate paths (TaxiPathNode) where values are absolute positions.
-    // Clamp fallback Z offsets for non-world-coordinate paths to prevent transport
-    // models from sinking below sea level on paths derived only from spawn-time data
-    // (notably icebreaker routes where the DBC path has steep vertical curves).
-    constexpr float kMinFallbackZOffset = -2.0f;
-    constexpr float kMaxFallbackZOffset =  8.0f;
     if (!path.worldCoords) {
         if (transport.useClientAnimation && transport.serverUpdateCount <= 1) {
+            constexpr float kMinFallbackZOffset = -2.0f;
             pathOffset.z = glm::max(pathOffset.z, kMinFallbackZOffset);
         }
         if (!transport.useClientAnimation && !transport.hasServerClock) {
+            constexpr float kMinFallbackZOffset = -2.0f;
+            constexpr float kMaxFallbackZOffset = 8.0f;
             pathOffset.z = glm::clamp(pathOffset.z, kMinFallbackZOffset, kMaxFallbackZOffset);
         }
     }
@@ -406,7 +400,7 @@ glm::vec3 TransportManager::evalTimedCatmullRom(const TransportPath& path, uint3
     uint32_t t1Ms = path.points[p1Idx].tMs;
     uint32_t t2Ms = path.points[p2Idx].tMs;
     uint32_t segmentDurationMs = (t2Ms > t1Ms) ? (t2Ms - t1Ms) : 1;
-    float t = static_cast<float>(pathTimeMs - t1Ms) / static_cast<float>(segmentDurationMs);
+    float t = (float)(pathTimeMs - t1Ms) / (float)segmentDurationMs;
     t = glm::clamp(t, 0.0f, 1.0f);
 
     // Catmull-Rom spline formula
@@ -483,7 +477,7 @@ glm::quat TransportManager::orientationFromTangent(const TransportPath& path, ui
     uint32_t t1Ms = path.points[p1Idx].tMs;
     uint32_t t2Ms = path.points[p2Idx].tMs;
     uint32_t segmentDurationMs = (t2Ms > t1Ms) ? (t2Ms - t1Ms) : 1;
-    float t = static_cast<float>(pathTimeMs - t1Ms) / static_cast<float>(segmentDurationMs);
+    float t = (float)(pathTimeMs - t1Ms) / (float)segmentDurationMs;
     t = glm::clamp(t, 0.0f, 1.0f);
 
     // Tangent of Catmull-Rom spline (derivative)
@@ -495,18 +489,18 @@ glm::quat TransportManager::orientationFromTangent(const TransportPath& path, ui
     );
 
     // Normalize tangent
-    float tangentLenSq = glm::dot(tangent, tangent);
-    if (tangentLenSq < 1e-6f) {
+    float tangentLength = glm::length(tangent);
+    if (tangentLength < 0.001f) {
         // Fallback to simple direction
         tangent = p2 - p1;
-        tangentLenSq = glm::dot(tangent, tangent);
+        tangentLength = glm::length(tangent);
     }
 
-    if (tangentLenSq < 1e-6f) {
+    if (tangentLength < 0.001f) {
         return glm::quat(1.0f, 0.0f, 0.0f, 0.0f);  // Identity
     }
 
-    tangent *= glm::inversesqrt(tangentLenSq);
+    tangent /= tangentLength;
 
     // Calculate rotation from forward direction
     glm::vec3 forward = tangent;
@@ -568,7 +562,7 @@ void TransportManager::updateServerTransport(uint64_t guid, const glm::vec3& pos
     const bool isWorldCoordPath = (hasPath && pathIt->second.worldCoords && pathIt->second.durationMs > 0);
 
     // Don't let (0,0,0) server updates override a TaxiPathNode world-coordinate path
-    if (isWorldCoordPath && glm::dot(position, position) < 1.0f) {
+    if (isWorldCoordPath && glm::length(position) < 1.0f) {
         transport->serverUpdateCount++;
         transport->lastServerUpdate = elapsedTime_;
         transport->serverYaw = orientation;
@@ -586,13 +580,12 @@ void TransportManager::updateServerTransport(uint64_t guid, const glm::vec3& pos
     if (isZOnlyPath || isWorldCoordPath) {
         transport->useClientAnimation = true;
     } else if (transport->useClientAnimation && hasPath && pathIt->second.fromDBC) {
-        glm::vec3 pd = position - transport->position;
-        float posDeltaSq = glm::dot(pd, pd);
-        if (posDeltaSq > 1.0f) {
+        float posDelta = glm::length(position - transport->position);
+        if (posDelta > 1.0f) {
             // Server sent a meaningfully different position — it's actively driving this transport
             transport->useClientAnimation = false;
             LOG_INFO("Transport 0x", std::hex, guid, std::dec,
-                     " switching to server-driven (posDeltaSq=", posDeltaSq, ")");
+                     " switching to server-driven (posDelta=", posDelta, ")");
         }
         // Otherwise keep client animation (server just echoed spawn pos or sent small jitter)
     } else if (!hasPath || !pathIt->second.fromDBC) {
@@ -636,16 +629,16 @@ void TransportManager::updateServerTransport(uint64_t guid, const glm::vec3& pos
         const float dt = elapsedTime_ - prevUpdateTime;
         if (dt > 0.001f) {
             glm::vec3 v = (position - prevPos) / dt;
-            float speedSq = glm::dot(v, v);
+            const float speed = glm::length(v);
             constexpr float kMinAuthoritativeSpeed = 0.15f;
             constexpr float kMaxSpeed = 60.0f;
-            if (speedSq >= kMinAuthoritativeSpeed * kMinAuthoritativeSpeed) {
+            if (speed >= kMinAuthoritativeSpeed) {
                 // Auto-detect 180-degree yaw mismatch by comparing heading to movement direction.
                 // Some transports appear to report yaw opposite their actual travel direction.
                 glm::vec2 horizontalV(v.x, v.y);
-                float hLenSq = glm::dot(horizontalV, horizontalV);
-                if (hLenSq > 0.04f) {
-                    horizontalV *= glm::inversesqrt(hLenSq);
+                float hLen = glm::length(horizontalV);
+                if (hLen > 0.2f) {
+                    horizontalV /= hLen;
                     glm::vec2 heading(std::cos(transport->serverYaw), std::sin(transport->serverYaw));
                     float alignDot = glm::dot(heading, horizontalV);
 
@@ -669,8 +662,8 @@ void TransportManager::updateServerTransport(uint64_t guid, const glm::vec3& pos
                     }
                 }
 
-                if (speedSq > kMaxSpeed * kMaxSpeed) {
-                    v *= (kMaxSpeed * glm::inversesqrt(speedSq));
+                if (speed > kMaxSpeed) {
+                    v *= (kMaxSpeed / speed);
                 }
 
                 transport->serverLinearVelocity = v;
@@ -742,10 +735,10 @@ void TransportManager::updateServerTransport(uint64_t guid, const glm::vec3& pos
                         float dtSeg = static_cast<float>(t1 - t0) / 1000.0f;
                         if (dtSeg <= 0.001f) return;
                         glm::vec3 v = seg / dtSeg;
-                        float speedSq = glm::dot(v, v);
-                        if (speedSq < kMinBootstrapSpeed * kMinBootstrapSpeed) return;
-                        if (speedSq > kMaxSpeed * kMaxSpeed) {
-                            v *= (kMaxSpeed * glm::inversesqrt(speedSq));
+                        float speed = glm::length(v);
+                        if (speed < kMinBootstrapSpeed) return;
+                        if (speed > kMaxSpeed) {
+                            v *= (kMaxSpeed / speed);
                         }
                         transport->serverLinearVelocity = v;
                         transport->serverAngularVelocity = 0.0f;
@@ -784,10 +777,8 @@ void TransportManager::updateServerTransport(uint64_t guid, const glm::vec3& pos
     }
 
     updateTransformMatrices(*transport);
-    if (transport->isM2) {
-        if (m2Renderer_) m2Renderer_->setInstanceTransform(transport->wmoInstanceId, transport->transform);
-    } else {
-        if (wmoRenderer_) wmoRenderer_->setInstanceTransform(transport->wmoInstanceId, transport->transform);
+    if (wmoRenderer_) {
+        wmoRenderer_->setInstanceTransform(transport->wmoInstanceId, transport->transform);
     }
     return;
 }
@@ -1140,7 +1131,7 @@ bool TransportManager::assignTaxiPathToTransport(uint32_t entry, uint32_t taxiPa
     // Find transport(s) with matching entry that are at (0,0,0)
     for (auto& [guid, transport] : transports_) {
         if (transport.entry != entry) continue;
-        if (glm::dot(transport.position, transport.position) > 1.0f) continue;  // Already has real position
+        if (glm::length(transport.position) > 1.0f) continue;  // Already has real position
 
         // Copy the taxi path into the main paths_ map (indexed by entry for this transport)
         TransportPath path = taxiIt->second;
@@ -1157,7 +1148,7 @@ bool TransportManager::assignTaxiPathToTransport(uint32_t entry, uint32_t taxiPa
 
         // Seed local clock to a deterministic phase
         if (path.durationMs > 0) {
-            transport.localClockMs = static_cast<uint32_t>(elapsedTime_ * 1000.0) % path.durationMs;
+            transport.localClockMs = static_cast<uint32_t>(elapsedTime_ * 1000.0f) % path.durationMs;
         }
 
         updateTransformMatrices(transport);
diff --git a/src/game/update_field_table.cpp b/src/game/update_field_table.cpp
index d4f2c724..505b86e6 100644
--- a/src/game/update_field_table.cpp
+++ b/src/game/update_field_table.cpp
@@ -19,7 +19,6 @@ struct UFNameEntry {
 
 static const UFNameEntry kUFNames[] = {
     {"OBJECT_FIELD_ENTRY", UF::OBJECT_FIELD_ENTRY},
-    {"OBJECT_FIELD_SCALE_X", UF::OBJECT_FIELD_SCALE_X},
     {"UNIT_FIELD_TARGET_LO", UF::UNIT_FIELD_TARGET_LO},
     {"UNIT_FIELD_TARGET_HI", UF::UNIT_FIELD_TARGET_HI},
     {"UNIT_FIELD_BYTES_0", UF::UNIT_FIELD_BYTES_0},
@@ -34,19 +33,10 @@ static const UFNameEntry kUFNames[] = {
     {"UNIT_FIELD_DISPLAYID", UF::UNIT_FIELD_DISPLAYID},
     {"UNIT_FIELD_MOUNTDISPLAYID", UF::UNIT_FIELD_MOUNTDISPLAYID},
     {"UNIT_FIELD_AURAS", UF::UNIT_FIELD_AURAS},
-    {"UNIT_FIELD_AURAFLAGS", UF::UNIT_FIELD_AURAFLAGS},
     {"UNIT_NPC_FLAGS", UF::UNIT_NPC_FLAGS},
-    {"UNIT_NPC_EMOTESTATE", UF::UNIT_NPC_EMOTESTATE},
     {"UNIT_DYNAMIC_FLAGS", UF::UNIT_DYNAMIC_FLAGS},
     {"UNIT_FIELD_RESISTANCES", UF::UNIT_FIELD_RESISTANCES},
-    {"UNIT_FIELD_STAT0", UF::UNIT_FIELD_STAT0},
-    {"UNIT_FIELD_STAT1", UF::UNIT_FIELD_STAT1},
-    {"UNIT_FIELD_STAT2", UF::UNIT_FIELD_STAT2},
-    {"UNIT_FIELD_STAT3", UF::UNIT_FIELD_STAT3},
-    {"UNIT_FIELD_STAT4", UF::UNIT_FIELD_STAT4},
     {"UNIT_END", UF::UNIT_END},
-    {"UNIT_FIELD_ATTACK_POWER", UF::UNIT_FIELD_ATTACK_POWER},
-    {"UNIT_FIELD_RANGED_ATTACK_POWER", UF::UNIT_FIELD_RANGED_ATTACK_POWER},
     {"PLAYER_FLAGS", UF::PLAYER_FLAGS},
     {"PLAYER_BYTES", UF::PLAYER_BYTES},
     {"PLAYER_BYTES_2", UF::PLAYER_BYTES_2},
@@ -56,29 +46,12 @@ static const UFNameEntry kUFNames[] = {
     {"PLAYER_QUEST_LOG_START", UF::PLAYER_QUEST_LOG_START},
     {"PLAYER_FIELD_INV_SLOT_HEAD", UF::PLAYER_FIELD_INV_SLOT_HEAD},
     {"PLAYER_FIELD_PACK_SLOT_1", UF::PLAYER_FIELD_PACK_SLOT_1},
-    {"PLAYER_FIELD_KEYRING_SLOT_1", UF::PLAYER_FIELD_KEYRING_SLOT_1},
     {"PLAYER_FIELD_BANK_SLOT_1", UF::PLAYER_FIELD_BANK_SLOT_1},
     {"PLAYER_FIELD_BANKBAG_SLOT_1", UF::PLAYER_FIELD_BANKBAG_SLOT_1},
     {"PLAYER_SKILL_INFO_START", UF::PLAYER_SKILL_INFO_START},
     {"PLAYER_EXPLORED_ZONES_START", UF::PLAYER_EXPLORED_ZONES_START},
     {"GAMEOBJECT_DISPLAYID", UF::GAMEOBJECT_DISPLAYID},
-    {"GAMEOBJECT_BYTES_1", UF::GAMEOBJECT_BYTES_1},
     {"ITEM_FIELD_STACK_COUNT", UF::ITEM_FIELD_STACK_COUNT},
-    {"ITEM_FIELD_DURABILITY", UF::ITEM_FIELD_DURABILITY},
-    {"ITEM_FIELD_MAXDURABILITY", UF::ITEM_FIELD_MAXDURABILITY},
-    {"PLAYER_REST_STATE_EXPERIENCE", UF::PLAYER_REST_STATE_EXPERIENCE},
-    {"PLAYER_CHOSEN_TITLE", UF::PLAYER_CHOSEN_TITLE},
-    {"PLAYER_FIELD_MOD_DAMAGE_DONE_POS", UF::PLAYER_FIELD_MOD_DAMAGE_DONE_POS},
-    {"PLAYER_FIELD_MOD_HEALING_DONE_POS", UF::PLAYER_FIELD_MOD_HEALING_DONE_POS},
-    {"PLAYER_BLOCK_PERCENTAGE", UF::PLAYER_BLOCK_PERCENTAGE},
-    {"PLAYER_DODGE_PERCENTAGE", UF::PLAYER_DODGE_PERCENTAGE},
-    {"PLAYER_PARRY_PERCENTAGE", UF::PLAYER_PARRY_PERCENTAGE},
-    {"PLAYER_CRIT_PERCENTAGE", UF::PLAYER_CRIT_PERCENTAGE},
-    {"PLAYER_RANGED_CRIT_PERCENTAGE", UF::PLAYER_RANGED_CRIT_PERCENTAGE},
-    {"PLAYER_SPELL_CRIT_PERCENTAGE1", UF::PLAYER_SPELL_CRIT_PERCENTAGE1},
-    {"PLAYER_FIELD_COMBAT_RATING_1", UF::PLAYER_FIELD_COMBAT_RATING_1},
-    {"PLAYER_FIELD_HONOR_CURRENCY", UF::PLAYER_FIELD_HONOR_CURRENCY},
-    {"PLAYER_FIELD_ARENA_CURRENCY", UF::PLAYER_FIELD_ARENA_CURRENCY},
     {"CONTAINER_FIELD_NUM_SLOTS", UF::CONTAINER_FIELD_NUM_SLOTS},
     {"CONTAINER_FIELD_SLOT_1", UF::CONTAINER_FIELD_SLOT_1},
 };
diff --git a/src/game/warden_emulator.cpp b/src/game/warden_emulator.cpp
index 0fa5bff8..1d43768b 100644
--- a/src/game/warden_emulator.cpp
+++ b/src/game/warden_emulator.cpp
@@ -1,8 +1,7 @@
 #include "game/warden_emulator.hpp"
-#include "core/logger.hpp"
+#include <iostream>
 #include <cstring>
 #include <chrono>
-#include <iterator>
 
 #ifdef HAVE_UNICORN
 // Unicorn Engine headers
@@ -15,11 +14,9 @@ namespace game {
 #ifdef HAVE_UNICORN
 
 // Memory layout for emulated environment
-// Note: heap must not overlap the module region (typically loaded at 0x400000)
-// or the stack. Keep heap above 0x02000000 (32MB) to leave space for module + padding.
 constexpr uint32_t STACK_BASE = 0x00100000;  // 1MB
 constexpr uint32_t STACK_SIZE = 0x00100000;  // 1MB stack
-constexpr uint32_t HEAP_BASE  = 0x02000000;  // 32MB — well above typical module base (0x400000)
+constexpr uint32_t HEAP_BASE  = 0x00200000;  // 2MB
 constexpr uint32_t HEAP_SIZE  = 0x01000000;  // 16MB heap
 constexpr uint32_t API_STUB_BASE = 0x70000000; // API stub area (high memory)
 
@@ -32,8 +29,6 @@ WardenEmulator::WardenEmulator()
     , heapBase_(HEAP_BASE)
     , heapSize_(HEAP_SIZE)
     , apiStubBase_(API_STUB_BASE)
-    , nextApiStubAddr_(API_STUB_BASE)
-    , apiCodeHookRegistered_(false)
     , nextHeapAddr_(HEAP_BASE)
 {
 }
@@ -46,54 +41,27 @@ WardenEmulator::~WardenEmulator() {
 
 bool WardenEmulator::initialize(const void* moduleCode, size_t moduleSize, uint32_t baseAddress) {
     if (uc_) {
-        LOG_ERROR("WardenEmulator: Already initialized");
+        std::cerr << "[WardenEmulator] Already initialized" << '\n';
         return false;
     }
-    // Reset allocator state so re-initialization starts with a clean heap.
-    allocations_.clear();
-    freeBlocks_.clear();
-    apiAddresses_.clear();
-    apiHandlers_.clear();
-    hooks_.clear();
-    nextHeapAddr_ = heapBase_;
-    nextApiStubAddr_ = apiStubBase_;
-    apiCodeHookRegistered_ = false;
 
-    {
-        char addrBuf[32];
-        std::snprintf(addrBuf, sizeof(addrBuf), "0x%X", baseAddress);
-        LOG_INFO("WardenEmulator: Initializing x86 emulator (Unicorn Engine)");
-        LOG_INFO("WardenEmulator:   Module: ", moduleSize, " bytes at ", addrBuf);
-    }
+    std::cout << "[WardenEmulator] Initializing x86 emulator (Unicorn Engine)" << '\n';
+    std::cout << "[WardenEmulator]   Module: " << moduleSize << " bytes at 0x" << std::hex << baseAddress << std::dec << '\n';
 
     // Create x86 32-bit emulator
     uc_err err = uc_open(UC_ARCH_X86, UC_MODE_32, &uc_);
     if (err != UC_ERR_OK) {
-        LOG_ERROR("WardenEmulator: uc_open failed: ", uc_strerror(err));
+        std::cerr << "[WardenEmulator] uc_open failed: " << uc_strerror(err) << '\n';
         return false;
     }
 
     moduleBase_ = baseAddress;
     moduleSize_ = (moduleSize + 0xFFF) & ~0xFFF; // Align to 4KB
 
-    // Detect overlap between module and heap/stack regions early.
-    uint32_t modEnd = moduleBase_ + moduleSize_;
-    if (modEnd > heapBase_ && moduleBase_ < heapBase_ + heapSize_) {
-        {
-            char buf[256];
-            std::snprintf(buf, sizeof(buf), "WardenEmulator: Module [0x%X, 0x%X) overlaps heap [0x%X, 0x%X) - adjust HEAP_BASE",
-                          moduleBase_, modEnd, heapBase_, heapBase_ + heapSize_);
-            LOG_ERROR(buf);
-        }
-        uc_close(uc_);
-        uc_ = nullptr;
-        return false;
-    }
-
     // Map module memory (code + data)
     err = uc_mem_map(uc_, moduleBase_, moduleSize_, UC_PROT_ALL);
     if (err != UC_ERR_OK) {
-        LOG_ERROR("WardenEmulator: Failed to map module memory: ", uc_strerror(err));
+        std::cerr << "[WardenEmulator] Failed to map module memory: " << uc_strerror(err) << '\n';
         uc_close(uc_);
         uc_ = nullptr;
         return false;
@@ -102,7 +70,7 @@ bool WardenEmulator::initialize(const void* moduleCode, size_t moduleSize, uint3
     // Write module code to emulated memory
     err = uc_mem_write(uc_, moduleBase_, moduleCode, moduleSize);
     if (err != UC_ERR_OK) {
-        LOG_ERROR("WardenEmulator: Failed to write module code: ", uc_strerror(err));
+        std::cerr << "[WardenEmulator] Failed to write module code: " << uc_strerror(err) << '\n';
         uc_close(uc_);
         uc_ = nullptr;
         return false;
@@ -111,7 +79,7 @@ bool WardenEmulator::initialize(const void* moduleCode, size_t moduleSize, uint3
     // Map stack
     err = uc_mem_map(uc_, stackBase_, stackSize_, UC_PROT_READ | UC_PROT_WRITE);
     if (err != UC_ERR_OK) {
-        LOG_ERROR("WardenEmulator: Failed to map stack: ", uc_strerror(err));
+        std::cerr << "[WardenEmulator] Failed to map stack: " << uc_strerror(err) << '\n';
         uc_close(uc_);
         uc_ = nullptr;
         return false;
@@ -125,7 +93,7 @@ bool WardenEmulator::initialize(const void* moduleCode, size_t moduleSize, uint3
     // Map heap
     err = uc_mem_map(uc_, heapBase_, heapSize_, UC_PROT_READ | UC_PROT_WRITE);
     if (err != UC_ERR_OK) {
-        LOG_ERROR("WardenEmulator: Failed to map heap: ", uc_strerror(err));
+        std::cerr << "[WardenEmulator] Failed to map heap: " << uc_strerror(err) << '\n';
         uc_close(uc_);
         uc_ = nullptr;
         return false;
@@ -134,97 +102,46 @@ bool WardenEmulator::initialize(const void* moduleCode, size_t moduleSize, uint3
     // Map API stub area
     err = uc_mem_map(uc_, apiStubBase_, 0x10000, UC_PROT_ALL);
     if (err != UC_ERR_OK) {
-        LOG_ERROR("WardenEmulator: Failed to map API stub area: ", uc_strerror(err));
+        std::cerr << "[WardenEmulator] Failed to map API stub area: " << uc_strerror(err) << '\n';
         uc_close(uc_);
         uc_ = nullptr;
         return false;
     }
 
-    // Map a null guard page at address 0 (read-only, zeroed) so that NULL-pointer
-    // dereferences in the module don't crash the emulator with UC_ERR_MAP.
-    // This allows execution to continue past NULL reads, making diagnostics easier.
-    err = uc_mem_map(uc_, 0x0, 0x1000, UC_PROT_READ);
-    if (err != UC_ERR_OK) {
-        // Non-fatal — just log it; the emulator will still function
-        LOG_WARNING("WardenEmulator: could not map null guard page: ", uc_strerror(err));
-    }
-
     // Add hooks for debugging and invalid memory access
     uc_hook hh;
     uc_hook_add(uc_, &hh, UC_HOOK_MEM_INVALID, (void*)hookMemInvalid, this, 1, 0);
     hooks_.push_back(hh);
 
-    // Add code hook over the API stub area so Windows API calls are intercepted
-    uc_hook apiHook;
-    uc_hook_add(uc_, &apiHook, UC_HOOK_CODE, (void*)hookCode, this,
-                API_STUB_BASE, API_STUB_BASE + 0x10000 - 1);
-    hooks_.push_back(apiHook);
-    apiCodeHookRegistered_ = true;
-
-    {
-        char sBuf[128];
-        std::snprintf(sBuf, sizeof(sBuf), "WardenEmulator: Emulator initialized  Stack: 0x%X-0x%X  Heap: 0x%X-0x%X",
-                      stackBase_, stackBase_ + stackSize_, heapBase_, heapBase_ + heapSize_);
-        LOG_INFO(sBuf);
-    }
+    std::cout << "[WardenEmulator] ✓ Emulator initialized successfully" << '\n';
+    std::cout << "[WardenEmulator]   Stack: 0x" << std::hex << stackBase_ << " - 0x" << (stackBase_ + stackSize_) << '\n';
+    std::cout << "[WardenEmulator]   Heap:  0x" << heapBase_ << " - 0x" << (heapBase_ + heapSize_) << std::dec << '\n';
 
     return true;
 }
 
 uint32_t WardenEmulator::hookAPI(const std::string& dllName,
                                  const std::string& functionName,
-                                 std::function<uint32_t(WardenEmulator&, const std::vector<uint32_t>&)> handler) {
-    // Allocate address for this API stub (16 bytes each)
-    uint32_t stubAddr = nextApiStubAddr_;
-    nextApiStubAddr_ += 16;
+                                 [[maybe_unused]] std::function<uint32_t(WardenEmulator&, const std::vector<uint32_t>&)> handler) {
+    // Allocate address for this API stub
+    static uint32_t nextStubAddr = API_STUB_BASE;
+    uint32_t stubAddr = nextStubAddr;
+    nextStubAddr += 16; // Space for stub code
 
-    // Store address mapping for IAT patching
+    // Store mapping
     apiAddresses_[dllName][functionName] = stubAddr;
 
-    // Determine stdcall arg count from known Windows APIs so the hook can
-    // clean up the stack correctly (RETN N convention).
-    static const std::pair<const char*, int> knownArgCounts[] = {
-        {"VirtualAlloc",           4},
-        {"VirtualFree",            3},
-        {"GetTickCount",           0},
-        {"Sleep",                  1},
-        {"GetCurrentThreadId",     0},
-        {"GetCurrentProcessId",    0},
-        {"ReadProcessMemory",      5},
-    };
-    int argCount = 0;
-    for (const auto& [name, cnt] : knownArgCounts) {
-        if (functionName == name) { argCount = cnt; break; }
-    }
+    std::cout << "[WardenEmulator] Hooked " << dllName << "!" << functionName
+              << " at 0x" << std::hex << stubAddr << std::dec << '\n';
 
-    // Store the handler so hookCode() can dispatch to it
-    apiHandlers_[stubAddr] = { argCount, std::move(handler) };
-
-    // Write a RET (0xC3) at the stub address as a safe fallback in case
-    // the code hook fires after EIP has already advanced past our intercept.
-    if (uc_) {
-        static const uint8_t retInstr = 0xC3;
-        uc_mem_write(uc_, stubAddr, &retInstr, 1);
-    }
-
-    {
-        char hBuf[64];
-        std::snprintf(hBuf, sizeof(hBuf), "0x%X (argCount=%d)", stubAddr, argCount);
-        LOG_DEBUG("WardenEmulator: Hooked ", dllName, "!", functionName, " at ", hBuf);
-    }
+    // TODO: Write stub code that triggers a hook callback
+    // For now, just return the address for IAT patching
 
     return stubAddr;
 }
 
-uint32_t WardenEmulator::getAPIAddress(const std::string& dllName, const std::string& funcName) const {
-    auto libIt = apiAddresses_.find(dllName);
-    if (libIt == apiAddresses_.end()) return 0;
-    auto funcIt = libIt->second.find(funcName);
-    return (funcIt != libIt->second.end()) ? funcIt->second : 0;
-}
-
 void WardenEmulator::setupCommonAPIHooks() {
-    LOG_INFO("WardenEmulator: Setting up common Windows API hooks...");
+    std::cout << "[WardenEmulator] Setting up common Windows API hooks..." << '\n';
 
     // kernel32.dll
     hookAPI("kernel32.dll", "VirtualAlloc", apiVirtualAlloc);
@@ -235,7 +152,7 @@ void WardenEmulator::setupCommonAPIHooks() {
     hookAPI("kernel32.dll", "GetCurrentProcessId", apiGetCurrentProcessId);
     hookAPI("kernel32.dll", "ReadProcessMemory", apiReadProcessMemory);
 
-    LOG_INFO("WardenEmulator: Common API hooks registered");
+    std::cout << "[WardenEmulator] ✓ Common API hooks registered" << '\n';
 }
 
 uint32_t WardenEmulator::writeData(const void* data, size_t size) {
@@ -259,15 +176,12 @@ std::vector<uint8_t> WardenEmulator::readData(uint32_t address, size_t size) {
 
 uint32_t WardenEmulator::callFunction(uint32_t address, const std::vector<uint32_t>& args) {
     if (!uc_) {
-        LOG_ERROR("WardenEmulator: Not initialized");
+        std::cerr << "[WardenEmulator] Not initialized" << '\n';
         return 0;
     }
 
-    {
-        char aBuf[32];
-        std::snprintf(aBuf, sizeof(aBuf), "0x%X", address);
-        LOG_DEBUG("WardenEmulator: Calling function at ", aBuf, " with ", args.size(), " args");
-    }
+    std::cout << "[WardenEmulator] Calling function at 0x" << std::hex << address << std::dec
+              << " with " << args.size() << " args" << '\n';
 
     // Get current ESP
     uint32_t esp;
@@ -291,7 +205,7 @@ uint32_t WardenEmulator::callFunction(uint32_t address, const std::vector<uint32
     // Execute until return address
     uc_err err = uc_emu_start(uc_, address, retAddr, 0, 0);
     if (err != UC_ERR_OK) {
-        LOG_ERROR("WardenEmulator: Execution failed: ", uc_strerror(err));
+        std::cerr << "[WardenEmulator] Execution failed: " << uc_strerror(err) << '\n';
         return 0;
     }
 
@@ -299,11 +213,7 @@ uint32_t WardenEmulator::callFunction(uint32_t address, const std::vector<uint32
     uint32_t eax;
     uc_reg_read(uc_, UC_X86_REG_EAX, &eax);
 
-    {
-        char rBuf[32];
-        std::snprintf(rBuf, sizeof(rBuf), "0x%X", eax);
-        LOG_DEBUG("WardenEmulator: Function returned ", rBuf);
-    }
+    std::cout << "[WardenEmulator] Function returned 0x" << std::hex << eax << std::dec << '\n';
 
     return eax;
 }
@@ -330,44 +240,20 @@ std::string WardenEmulator::readString(uint32_t address, size_t maxLen) {
 }
 
 uint32_t WardenEmulator::allocateMemory(size_t size, [[maybe_unused]] uint32_t protection) {
-    if (size == 0) return 0;
-
     // Align to 4KB
     size = (size + 0xFFF) & ~0xFFF;
-    const uint32_t allocSize = static_cast<uint32_t>(size);
 
-    // First-fit from free list so released blocks can be reused.
-    for (auto it = freeBlocks_.begin(); it != freeBlocks_.end(); ++it) {
-        if (it->second < size) continue;
-        const uint32_t addr     = it->first;
-        const size_t   blockSz  = it->second;
-        freeBlocks_.erase(it);
-        if (blockSz > size)
-            freeBlocks_[addr + allocSize] = blockSz - size;
-        allocations_[addr] = size;
-        {
-            char mBuf[32];
-            std::snprintf(mBuf, sizeof(mBuf), "0x%X", addr);
-            LOG_DEBUG("WardenEmulator: Reused ", size, " bytes at ", mBuf);
-        }
-        return addr;
-    }
-
-    const uint64_t heapEnd = static_cast<uint64_t>(heapBase_) + heapSize_;
-    if (static_cast<uint64_t>(nextHeapAddr_) + size > heapEnd) {
-        LOG_ERROR("WardenEmulator: Heap exhausted");
+    if (nextHeapAddr_ + size > heapBase_ + heapSize_) {
+        std::cerr << "[WardenEmulator] Heap exhausted" << '\n';
         return 0;
     }
 
     uint32_t addr = nextHeapAddr_;
-    nextHeapAddr_ += allocSize;
+    nextHeapAddr_ += size;
+
     allocations_[addr] = size;
 
-    {
-        char mBuf[32];
-        std::snprintf(mBuf, sizeof(mBuf), "0x%X", addr);
-        LOG_DEBUG("WardenEmulator: Allocated ", size, " bytes at ", mBuf);
-    }
+    std::cout << "[WardenEmulator] Allocated " << size << " bytes at 0x" << std::hex << addr << std::dec << '\n';
 
     return addr;
 }
@@ -375,54 +261,12 @@ uint32_t WardenEmulator::allocateMemory(size_t size, [[maybe_unused]] uint32_t p
 bool WardenEmulator::freeMemory(uint32_t address) {
     auto it = allocations_.find(address);
     if (it == allocations_.end()) {
-        {
-            char fBuf[32];
-            std::snprintf(fBuf, sizeof(fBuf), "0x%X", address);
-            LOG_ERROR("WardenEmulator: Invalid free at ", fBuf);
-        }
+        std::cerr << "[WardenEmulator] Invalid free at 0x" << std::hex << address << std::dec << '\n';
         return false;
     }
 
-    {
-        char fBuf[32];
-        std::snprintf(fBuf, sizeof(fBuf), "0x%X", address);
-        LOG_DEBUG("WardenEmulator: Freed ", it->second, " bytes at ", fBuf);
-    }
-
-    const size_t freedSize = it->second;
+    std::cout << "[WardenEmulator] Freed " << it->second << " bytes at 0x" << std::hex << address << std::dec << '\n';
     allocations_.erase(it);
-
-    // Insert in free list and coalesce adjacent blocks to limit fragmentation.
-    auto [curr, inserted] = freeBlocks_.emplace(address, freedSize);
-    if (!inserted) curr->second += freedSize;
-
-    if (curr != freeBlocks_.begin()) {
-        auto prev = std::prev(curr);
-        if (static_cast<uint64_t>(prev->first) + prev->second == curr->first) {
-            prev->second += curr->second;
-            freeBlocks_.erase(curr);
-            curr = prev;
-        }
-    }
-
-    auto next = std::next(curr);
-    if (next != freeBlocks_.end() &&
-        static_cast<uint64_t>(curr->first) + curr->second == next->first) {
-        curr->second += next->second;
-        freeBlocks_.erase(next);
-    }
-
-    // Roll back the bump pointer if the highest free block reaches it.
-    while (!freeBlocks_.empty()) {
-        auto last = std::prev(freeBlocks_.end());
-        if (static_cast<uint64_t>(last->first) + last->second == nextHeapAddr_) {
-            nextHeapAddr_ = last->first;
-            freeBlocks_.erase(last);
-        } else {
-            break;
-        }
-    }
-
     return true;
 }
 
@@ -453,12 +297,8 @@ uint32_t WardenEmulator::apiVirtualAlloc(WardenEmulator& emu, const std::vector<
     uint32_t flAllocationType = args[2];
     uint32_t flProtect = args[3];
 
-    {
-        char vBuf[128];
-        std::snprintf(vBuf, sizeof(vBuf), "WinAPI: VirtualAlloc(0x%X, %u, 0x%X, 0x%X)",
-                      lpAddress, dwSize, flAllocationType, flProtect);
-        LOG_DEBUG(vBuf);
-    }
+    std::cout << "[WinAPI] VirtualAlloc(0x" << std::hex << lpAddress << ", " << std::dec
+              << dwSize << ", 0x" << std::hex << flAllocationType << ", 0x" << flProtect << ")" << std::dec << '\n';
 
     // Ignore lpAddress hint for now
     return emu.allocateMemory(dwSize, flProtect);
@@ -470,11 +310,7 @@ uint32_t WardenEmulator::apiVirtualFree(WardenEmulator& emu, const std::vector<u
 
     uint32_t lpAddress = args[0];
 
-    {
-        char vBuf[64];
-        std::snprintf(vBuf, sizeof(vBuf), "WinAPI: VirtualFree(0x%X)", lpAddress);
-        LOG_DEBUG(vBuf);
-    }
+    std::cout << "[WinAPI] VirtualFree(0x" << std::hex << lpAddress << ")" << std::dec << '\n';
 
     return emu.freeMemory(lpAddress) ? 1 : 0;
 }
@@ -484,7 +320,7 @@ uint32_t WardenEmulator::apiGetTickCount([[maybe_unused]] WardenEmulator& emu, [
     auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
     uint32_t ticks = static_cast<uint32_t>(ms & 0xFFFFFFFF);
 
-    LOG_DEBUG("WinAPI: GetTickCount() = ", ticks);
+    std::cout << "[WinAPI] GetTickCount() = " << ticks << '\n';
     return ticks;
 }
 
@@ -492,18 +328,18 @@ uint32_t WardenEmulator::apiSleep([[maybe_unused]] WardenEmulator& emu, const st
     if (args.size() < 1) return 0;
     uint32_t dwMilliseconds = args[0];
 
-    LOG_DEBUG("WinAPI: Sleep(", dwMilliseconds, ")");
+    std::cout << "[WinAPI] Sleep(" << dwMilliseconds << ")" << '\n';
     // Don't actually sleep in emulator
     return 0;
 }
 
 uint32_t WardenEmulator::apiGetCurrentThreadId([[maybe_unused]] WardenEmulator& emu, [[maybe_unused]] const std::vector<uint32_t>& args) {
-    LOG_DEBUG("WinAPI: GetCurrentThreadId() = 1234");
+    std::cout << "[WinAPI] GetCurrentThreadId() = 1234" << '\n';
     return 1234; // Fake thread ID
 }
 
 uint32_t WardenEmulator::apiGetCurrentProcessId([[maybe_unused]] WardenEmulator& emu, [[maybe_unused]] const std::vector<uint32_t>& args) {
-    LOG_DEBUG("WinAPI: GetCurrentProcessId() = 5678");
+    std::cout << "[WinAPI] GetCurrentProcessId() = 5678" << '\n';
     return 5678; // Fake process ID
 }
 
@@ -517,11 +353,8 @@ uint32_t WardenEmulator::apiReadProcessMemory(WardenEmulator& emu, const std::ve
     uint32_t nSize = args[3];
     uint32_t lpNumberOfBytesRead = args[4];
 
-    {
-        char rBuf[64];
-        std::snprintf(rBuf, sizeof(rBuf), "WinAPI: ReadProcessMemory(0x%X, %u bytes)", lpBaseAddress, nSize);
-        LOG_DEBUG(rBuf);
-    }
+    std::cout << "[WinAPI] ReadProcessMemory(0x" << std::hex << lpBaseAddress
+              << ", " << std::dec << nSize << " bytes)" << '\n';
 
     // Read from emulated memory and write to buffer
     std::vector<uint8_t> data(nSize);
@@ -544,40 +377,8 @@ uint32_t WardenEmulator::apiReadProcessMemory(WardenEmulator& emu, const std::ve
 // Unicorn Callbacks
 // ============================================================================
 
-void WardenEmulator::hookCode(uc_engine* uc, uint64_t address, [[maybe_unused]] uint32_t size, void* userData) {
-    auto* self = static_cast<WardenEmulator*>(userData);
-    if (!self) return;
-
-    auto it = self->apiHandlers_.find(static_cast<uint32_t>(address));
-    if (it == self->apiHandlers_.end()) return; // not an API stub — trace disabled to avoid spam
-
-    const ApiHookEntry& entry = it->second;
-
-    // Read stack: [ESP+0] = return address, [ESP+4..] = stdcall args
-    uint32_t esp = 0;
-    uc_reg_read(uc, UC_X86_REG_ESP, &esp);
-
-    uint32_t retAddr = 0;
-    uc_mem_read(uc, esp, &retAddr, 4);
-
-    std::vector<uint32_t> args(static_cast<size_t>(entry.argCount));
-    for (int i = 0; i < entry.argCount; ++i) {
-        uint32_t val = 0;
-        uc_mem_read(uc, esp + 4 + static_cast<uint32_t>(i) * 4, &val, 4);
-        args[static_cast<size_t>(i)] = val;
-    }
-
-    // Dispatch to the C++ handler
-    uint32_t retVal = 0;
-    if (entry.handler) {
-        retVal = entry.handler(*self, args);
-    }
-
-    // Simulate stdcall epilogue: pop return address + args
-    uint32_t newEsp = esp + 4 + static_cast<uint32_t>(entry.argCount) * 4;
-    uc_reg_write(uc, UC_X86_REG_EAX, &retVal);
-    uc_reg_write(uc, UC_X86_REG_ESP, &newEsp);
-    uc_reg_write(uc, UC_X86_REG_EIP, &retAddr);
+void WardenEmulator::hookCode([[maybe_unused]] uc_engine* uc, uint64_t address, [[maybe_unused]] uint32_t size, [[maybe_unused]] void* userData) {
+    std::cout << "[Trace] 0x" << std::hex << address << std::dec << '\n';
 }
 
 void WardenEmulator::hookMemInvalid([[maybe_unused]] uc_engine* uc, int type, uint64_t address, int size, [[maybe_unused]] int64_t value, [[maybe_unused]] void* userData) {
@@ -592,12 +393,9 @@ void WardenEmulator::hookMemInvalid([[maybe_unused]] uc_engine* uc, int type, ui
         case UC_MEM_FETCH_PROT: typeStr = "FETCH_PROT"; break;
     }
 
-    {
-        char mBuf[128];
-        std::snprintf(mBuf, sizeof(mBuf), "WardenEmulator: Invalid memory access: %s at 0x%llX (size=%d)",
-                      typeStr, static_cast<unsigned long long>(address), size);
-        LOG_ERROR(mBuf);
-    }
+    std::cerr << "[WardenEmulator] Invalid memory access: " << typeStr
+              << " at 0x" << std::hex << address << std::dec
+              << " (size=" << size << ")" << '\n';
 }
 
 #else // !HAVE_UNICORN
@@ -606,8 +404,7 @@ WardenEmulator::WardenEmulator()
     : uc_(nullptr), moduleBase_(0), moduleSize_(0)
     , stackBase_(0), stackSize_(0)
     , heapBase_(0), heapSize_(0)
-    , apiStubBase_(0), nextApiStubAddr_(0), apiCodeHookRegistered_(false)
-    , nextHeapAddr_(0) {}
+    , apiStubBase_(0), nextHeapAddr_(0) {}
 WardenEmulator::~WardenEmulator() {}
 bool WardenEmulator::initialize(const void*, size_t, uint32_t) { return false; }
 uint32_t WardenEmulator::hookAPI(const std::string&, const std::string&,
@@ -621,7 +418,6 @@ bool WardenEmulator::freeMemory(uint32_t) { return false; }
 uint32_t WardenEmulator::getRegister(int) { return 0; }
 void WardenEmulator::setRegister(int, uint32_t) {}
 void WardenEmulator::setupCommonAPIHooks() {}
-uint32_t WardenEmulator::getAPIAddress(const std::string&, const std::string&) const { return 0; }
 uint32_t WardenEmulator::writeData(const void*, size_t) { return 0; }
 std::vector<uint8_t> WardenEmulator::readData(uint32_t, size_t) { return {}; }
 void WardenEmulator::hookCode(uc_engine*, uint64_t, uint32_t, void*) {}
diff --git a/src/game/warden_handler.cpp b/src/game/warden_handler.cpp
deleted file mode 100644
index a5f38714..00000000
--- a/src/game/warden_handler.cpp
+++ /dev/null
@@ -1,1382 +0,0 @@
-#include "game/warden_handler.hpp"
-#include "game/game_handler.hpp"
-#include "game/game_utils.hpp"
-#include "game/warden_crypto.hpp"
-#include "game/warden_memory.hpp"
-#include "game/warden_module.hpp"
-#include "network/world_socket.hpp"
-#include "network/packet.hpp"
-#include "auth/crypto.hpp"
-#include "core/application.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "core/logger.hpp"
-#include <algorithm>
-#include <cctype>
-#include <chrono>
-#include <cstring>
-#include <filesystem>
-#include <fstream>
-#include <limits>
-#include <openssl/sha.h>
-#include <openssl/hmac.h>
-
-namespace wowee {
-namespace game {
-
-namespace {
-
-std::string asciiLower(std::string s) {
-    std::transform(s.begin(), s.end(), s.begin(),
-                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-    return s;
-}
-
-std::vector<std::string> splitWowPath(const std::string& wowPath) {
-    std::vector<std::string> out;
-    std::string cur;
-    for (char c : wowPath) {
-        if (c == '\\' || c == '/') {
-            if (!cur.empty()) {
-                out.push_back(cur);
-                cur.clear();
-            }
-            continue;
-        }
-        cur.push_back(c);
-    }
-    if (!cur.empty()) out.push_back(cur);
-    return out;
-}
-
-int pathCaseScore(const std::string& name) {
-    int score = 0;
-    for (unsigned char c : name) {
-        if (std::islower(c)) score += 2;
-        else if (std::isupper(c)) score -= 1;
-    }
-    return score;
-}
-
-std::string resolveCaseInsensitiveDataPath(const std::string& dataRoot, const std::string& wowPath) {
-    if (dataRoot.empty() || wowPath.empty()) return std::string();
-    std::filesystem::path cur(dataRoot);
-    std::error_code ec;
-    if (!std::filesystem::exists(cur, ec) || !std::filesystem::is_directory(cur, ec)) {
-        return std::string();
-    }
-
-    for (const std::string& segment : splitWowPath(wowPath)) {
-        std::string wanted = asciiLower(segment);
-        std::filesystem::path bestPath;
-        int bestScore = std::numeric_limits<int>::min();
-        bool found = false;
-
-        for (const auto& entry : std::filesystem::directory_iterator(cur, ec)) {
-            if (ec) break;
-            std::string name = entry.path().filename().string();
-            if (asciiLower(name) != wanted) continue;
-            int score = pathCaseScore(name);
-            if (!found || score > bestScore) {
-                found = true;
-                bestScore = score;
-                bestPath = entry.path();
-            }
-        }
-        if (!found) return std::string();
-        cur = bestPath;
-    }
-
-    if (!std::filesystem::exists(cur, ec) || std::filesystem::is_directory(cur, ec)) {
-        return std::string();
-    }
-    return cur.string();
-}
-
-std::vector<uint8_t> readFileBinary(const std::string& fsPath) {
-    std::ifstream in(fsPath, std::ios::binary);
-    if (!in) return {};
-    in.seekg(0, std::ios::end);
-    std::streamoff size = in.tellg();
-    if (size <= 0) return {};
-    in.seekg(0, std::ios::beg);
-    std::vector<uint8_t> data(static_cast<size_t>(size));
-    in.read(reinterpret_cast<char*>(data.data()), size);
-    if (!in) return {};
-    return data;
-}
-
-bool hmacSha1Matches(const uint8_t seedBytes[4], const std::string& text, const uint8_t expected[20]) {
-    uint8_t out[SHA_DIGEST_LENGTH];
-    unsigned int outLen = 0;
-    HMAC(EVP_sha1(),
-         seedBytes, 4,
-         reinterpret_cast<const uint8_t*>(text.data()),
-         static_cast<int>(text.size()),
-         out, &outLen);
-    return outLen == SHA_DIGEST_LENGTH && std::memcmp(out, expected, SHA_DIGEST_LENGTH) == 0;
-}
-
-// Pre-computed HMAC-SHA1 hashes of known door M2 models that Warden checks
-// to verify the client hasn't modified collision geometry (wall-hack detection).
-// These hashes match the unmodified 3.3.5a client data files.
-const std::unordered_map<std::string, std::array<uint8_t, 20>>& knownDoorHashes() {
-    static const std::unordered_map<std::string, std::array<uint8_t, 20>> k = {
-        {"world\\lordaeron\\stratholme\\activedoodads\\doors\\nox_door_plague.m2",
-         {0xB4,0x45,0x2B,0x6D,0x95,0xC9,0x8B,0x18,0x6A,0x70,0xB0,0x08,0xFA,0x07,0xBB,0xAE,0xF3,0x0D,0xF7,0xA2}},
-        {"world\\kalimdor\\onyxiaslair\\doors\\onyxiasgate01.m2",
-         {0x75,0x19,0x5E,0x4A,0xED,0xA0,0xBC,0xAF,0x04,0x8C,0xA0,0xE3,0x4D,0x95,0xA7,0x0D,0x4F,0x53,0xC7,0x46}},
-        {"world\\generic\\human\\activedoodads\\doors\\deadminedoor02.m2",
-         {0x3D,0xFF,0x01,0x1B,0x9A,0xB1,0x34,0xF3,0x7F,0x88,0x50,0x97,0xE6,0x95,0x35,0x1B,0x91,0x95,0x35,0x64}},
-        {"world\\kalimdor\\silithus\\activedoodads\\ahnqirajdoor\\ahnqirajdoor02.m2",
-         {0xDB,0xD4,0xF4,0x07,0xC4,0x68,0xCC,0x36,0x13,0x4E,0x62,0x1D,0x16,0x01,0x78,0xFD,0xA4,0xD0,0xD2,0x49}},
-        {"world\\kalimdor\\diremaul\\activedoodads\\doors\\diremaulsmallinstancedoor.m2",
-         {0x0D,0xC8,0xDB,0x46,0xC8,0x55,0x49,0xC0,0xFF,0x1A,0x60,0x0F,0x6C,0x23,0x63,0x57,0xC3,0x05,0x78,0x1A}},
-    };
-    return k;
-}
-
-} // anonymous namespace
-
-// ---------------------------------------------------------------------------
-// Construction / init
-// ---------------------------------------------------------------------------
-
-WardenHandler::WardenHandler(GameHandler& owner)
-    : owner_(owner) {}
-
-void WardenHandler::initModuleManager() {
-    wardenModuleManager_ = std::make_unique<WardenModuleManager>();
-}
-
-// ---------------------------------------------------------------------------
-// Opcode registration
-// ---------------------------------------------------------------------------
-
-void WardenHandler::registerOpcodes(DispatchTable& table) {
-    table[Opcode::SMSG_WARDEN_DATA] = [this](network::Packet& packet) { handleWardenData(packet); };
-}
-
-// ---------------------------------------------------------------------------
-// Reset
-// ---------------------------------------------------------------------------
-
-void WardenHandler::reset() {
-    requiresWarden_ = false;
-    wardenGateSeen_ = false;
-    wardenGateElapsed_ = 0.0f;
-    wardenGateNextStatusLog_ = 2.0f;
-    wardenPacketsAfterGate_ = 0;
-    wardenCharEnumBlockedLogged_ = false;
-    wardenCrypto_.reset();
-    wardenState_ = WardenState::WAIT_MODULE_USE;
-    wardenModuleHash_.clear();
-    wardenModuleKey_.clear();
-    wardenModuleSize_ = 0;
-    wardenModuleData_.clear();
-    wardenLoadedModule_.reset();
-}
-
-// ---------------------------------------------------------------------------
-// Update (called from GameHandler::update)
-// ---------------------------------------------------------------------------
-
-void WardenHandler::update(float deltaTime) {
-    // Drain pending async Warden response (built on background thread to avoid 5s stalls)
-    if (wardenResponsePending_) {
-        auto status = wardenPendingEncrypted_.wait_for(std::chrono::milliseconds(0));
-        if (status == std::future_status::ready) {
-            auto plaintext = wardenPendingEncrypted_.get();
-            wardenResponsePending_ = false;
-            if (!plaintext.empty() && wardenCrypto_) {
-                std::vector<uint8_t> encrypted = wardenCrypto_->encrypt(plaintext);
-                network::Packet response(wireOpcode(Opcode::CMSG_WARDEN_DATA));
-                for (uint8_t byte : encrypted) {
-                    response.writeUInt8(byte);
-                }
-                if (owner_.socket && owner_.socket->isConnected()) {
-                    owner_.socket->send(response);
-                    LOG_WARNING("Warden: Sent async CHEAT_CHECKS_RESULT (", plaintext.size(), " bytes plaintext)");
-                }
-            }
-        }
-    }
-
-    // Post-gate visibility
-    if (wardenGateSeen_ && owner_.socket && owner_.socket->isConnected()) {
-        wardenGateElapsed_ += deltaTime;
-        if (wardenGateElapsed_ >= wardenGateNextStatusLog_) {
-            LOG_DEBUG("Warden gate status: elapsed=", wardenGateElapsed_,
-                     "s connected=", owner_.socket->isConnected() ? "yes" : "no",
-                     " packetsAfterGate=", wardenPacketsAfterGate_);
-            wardenGateNextStatusLog_ += 30.0f;
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------
-// loadWardenCRFile
-// ---------------------------------------------------------------------------
-
-bool WardenHandler::loadWardenCRFile(const std::string& moduleHashHex) {
-    wardenCREntries_.clear();
-
-    // Look for .cr file in warden cache
-    std::string cacheBase;
-#ifdef _WIN32
-    if (const char* h = std::getenv("APPDATA")) cacheBase = std::string(h) + "\\wowee\\warden_cache";
-    else cacheBase = ".\\warden_cache";
-#else
-    if (const char* h = std::getenv("HOME")) cacheBase = std::string(h) + "/.local/share/wowee/warden_cache";
-    else cacheBase = "./warden_cache";
-#endif
-    std::string crPath = cacheBase + "/" + moduleHashHex + ".cr";
-
-    std::ifstream crFile(crPath, std::ios::binary);
-    if (!crFile) {
-        LOG_WARNING("Warden: No .cr file found at ", crPath);
-        return false;
-    }
-
-    // Get file size
-    crFile.seekg(0, std::ios::end);
-    auto fileSize = crFile.tellg();
-    crFile.seekg(0, std::ios::beg);
-
-    // Header: [4 memoryRead][4 pageScanCheck][9 opcodes] = 17 bytes
-    constexpr size_t CR_HEADER_SIZE = 17;
-    constexpr size_t CR_ENTRY_SIZE = 68; // seed[16]+reply[20]+clientKey[16]+serverKey[16]
-
-    if (static_cast<size_t>(fileSize) < CR_HEADER_SIZE) {
-        LOG_ERROR("Warden: .cr file too small (", fileSize, " bytes)");
-        return false;
-    }
-
-    // Read header: [4 memoryRead][4 pageScanCheck][9 opcodes]
-    crFile.seekg(8); // skip memoryRead + pageScanCheck
-    crFile.read(reinterpret_cast<char*>(wardenCheckOpcodes_), 9);
-    {
-        std::string opcHex;
-        // CMaNGOS WindowsScanType order:
-        // 0 READ_MEMORY, 1 FIND_MODULE_BY_NAME, 2 FIND_MEM_IMAGE_CODE_BY_HASH,
-        // 3 FIND_CODE_BY_HASH, 4 HASH_CLIENT_FILE, 5 GET_LUA_VARIABLE,
-        // 6 API_CHECK, 7 FIND_DRIVER_BY_NAME, 8 CHECK_TIMING_VALUES
-        const char* names[] = {"MEM","MODULE","PAGE_A","PAGE_B","MPQ","LUA","PROC","DRIVER","TIMING"};
-        for (int i = 0; i < 9; i++) {
-            char s[16]; snprintf(s, sizeof(s), "%s=0x%02X ", names[i], wardenCheckOpcodes_[i]); opcHex += s;
-        }
-        LOG_WARNING("Warden: Check opcodes: ", opcHex);
-    }
-
-    size_t entryCount = (static_cast<size_t>(fileSize) - CR_HEADER_SIZE) / CR_ENTRY_SIZE;
-    if (entryCount == 0) {
-        LOG_ERROR("Warden: .cr file has no entries");
-        return false;
-    }
-
-    wardenCREntries_.resize(entryCount);
-    for (size_t i = 0; i < entryCount; i++) {
-        auto& e = wardenCREntries_[i];
-        crFile.read(reinterpret_cast<char*>(e.seed), 16);
-        crFile.read(reinterpret_cast<char*>(e.reply), 20);
-        crFile.read(reinterpret_cast<char*>(e.clientKey), 16);
-        crFile.read(reinterpret_cast<char*>(e.serverKey), 16);
-    }
-
-    LOG_INFO("Warden: Loaded ", entryCount, " CR entries from ", crPath);
-    return true;
-}
-
-// ---------------------------------------------------------------------------
-// handleWardenData — main Warden packet dispatcher
-// ---------------------------------------------------------------------------
-
-void WardenHandler::handleWardenData(network::Packet& packet) {
-    const auto& data = packet.getData();
-    if (!wardenGateSeen_) {
-        wardenGateSeen_ = true;
-        wardenGateElapsed_ = 0.0f;
-        wardenGateNextStatusLog_ = 2.0f;
-        wardenPacketsAfterGate_ = 0;
-    }
-
-    // Initialize Warden crypto from session key on first packet
-    if (!wardenCrypto_) {
-        wardenCrypto_ = std::make_unique<WardenCrypto>();
-        if (owner_.sessionKey.size() != 40) {
-            LOG_ERROR("Warden: No valid session key (size=", owner_.sessionKey.size(), "), cannot init crypto");
-            wardenCrypto_.reset();
-            return;
-        }
-        if (!wardenCrypto_->initFromSessionKey(owner_.sessionKey)) {
-            LOG_ERROR("Warden: Failed to initialize crypto from session key");
-            wardenCrypto_.reset();
-            return;
-        }
-        wardenState_ = WardenState::WAIT_MODULE_USE;
-    }
-
-    // Decrypt the payload
-    std::vector<uint8_t> decrypted = wardenCrypto_->decrypt(data);
-
-    // Avoid expensive hex formatting when DEBUG logs are disabled.
-    if (core::Logger::getInstance().shouldLog(core::LogLevel::DEBUG)) {
-        std::string hex;
-        size_t logSize = std::min(decrypted.size(), size_t(256));
-        hex.reserve(logSize * 3);
-        for (size_t i = 0; i < logSize; ++i) {
-            char b[4];
-            snprintf(b, sizeof(b), "%02x ", decrypted[i]);
-            hex += b;
-        }
-        if (decrypted.size() > 64) {
-            hex += "... (" + std::to_string(decrypted.size() - 64) + " more)";
-        }
-        LOG_DEBUG("Warden: Decrypted (", decrypted.size(), " bytes): ", hex);
-    }
-
-    if (decrypted.empty()) {
-        LOG_WARNING("Warden: Empty decrypted payload");
-        return;
-    }
-
-    uint8_t wardenOpcode = decrypted[0];
-
-    // Helper to send an encrypted Warden response
-    auto sendWardenResponse = [&](const std::vector<uint8_t>& plaintext) {
-        std::vector<uint8_t> encrypted = wardenCrypto_->encrypt(plaintext);
-        network::Packet response(wireOpcode(Opcode::CMSG_WARDEN_DATA));
-        for (uint8_t byte : encrypted) {
-            response.writeUInt8(byte);
-        }
-        if (owner_.socket && owner_.socket->isConnected()) {
-            owner_.socket->send(response);
-            LOG_DEBUG("Warden: Sent response (", plaintext.size(), " bytes plaintext)");
-        }
-    };
-
-    switch (wardenOpcode) {
-        case 0x00: { // WARDEN_SMSG_MODULE_USE
-            // Format: [1 opcode][16 moduleHash][16 moduleKey][4 moduleSize]
-            if (decrypted.size() < 37) {
-                LOG_ERROR("Warden: MODULE_USE too short (", decrypted.size(), " bytes, need 37)");
-                return;
-            }
-
-            wardenModuleHash_.assign(decrypted.begin() + 1, decrypted.begin() + 17);
-            wardenModuleKey_.assign(decrypted.begin() + 17, decrypted.begin() + 33);
-            wardenModuleSize_ = static_cast<uint32_t>(decrypted[33])
-                              | (static_cast<uint32_t>(decrypted[34]) << 8)
-                              | (static_cast<uint32_t>(decrypted[35]) << 16)
-                              | (static_cast<uint32_t>(decrypted[36]) << 24);
-            wardenModuleData_.clear();
-
-            {
-                std::string hashHex;
-                for (auto b : wardenModuleHash_) { char s[4]; snprintf(s, 4, "%02x", b); hashHex += s; }
-                LOG_DEBUG("Warden: MODULE_USE hash=", hashHex, " size=", wardenModuleSize_);
-
-                // Try to load pre-computed challenge/response entries
-                loadWardenCRFile(hashHex);
-            }
-
-            // Respond with MODULE_MISSING (opcode 0x00) to request the module data
-            std::vector<uint8_t> resp = { 0x00 }; // WARDEN_CMSG_MODULE_MISSING
-            sendWardenResponse(resp);
-            wardenState_ = WardenState::WAIT_MODULE_CACHE;
-            LOG_WARNING("Warden: Sent MODULE_MISSING for module size=", wardenModuleSize_, ", waiting for data chunks");
-            break;
-        }
-
-        case 0x01: { // WARDEN_SMSG_MODULE_CACHE (module data chunk)
-            // Format: [1 opcode][2 chunkSize LE][chunkSize bytes data]
-            if (decrypted.size() < 3) {
-                LOG_ERROR("Warden: MODULE_CACHE too short");
-                return;
-            }
-
-            uint16_t chunkSize = static_cast<uint16_t>(decrypted[1])
-                               | (static_cast<uint16_t>(decrypted[2]) << 8);
-
-            if (decrypted.size() < 3u + chunkSize) {
-                LOG_ERROR("Warden: MODULE_CACHE chunk truncated (claimed ", chunkSize,
-                          ", have ", decrypted.size() - 3, ")");
-                return;
-            }
-
-            wardenModuleData_.insert(wardenModuleData_.end(),
-                                     decrypted.begin() + 3,
-                                     decrypted.begin() + 3 + chunkSize);
-
-            LOG_WARNING("Warden: MODULE_CACHE chunk ", chunkSize, " bytes, total ",
-                     wardenModuleData_.size(), "/", wardenModuleSize_);
-
-            // Check if module download is complete
-            if (wardenModuleData_.size() >= wardenModuleSize_) {
-                LOG_INFO("Warden: Module download complete (",
-                         wardenModuleData_.size(), " bytes)");
-                wardenState_ = WardenState::WAIT_HASH_REQUEST;
-
-                // Cache raw module to disk
-                {
-#ifdef _WIN32
-                    std::string cacheDir;
-                    if (const char* h = std::getenv("APPDATA")) cacheDir = std::string(h) + "\\wowee\\warden_cache";
-                    else cacheDir = ".\\warden_cache";
-#else
-                    std::string cacheDir;
-                    if (const char* h = std::getenv("HOME")) cacheDir = std::string(h) + "/.local/share/wowee/warden_cache";
-                    else cacheDir = "./warden_cache";
-#endif
-                    std::filesystem::create_directories(cacheDir);
-
-                    std::string hashHex;
-                    for (auto b : wardenModuleHash_) { char s[4]; snprintf(s, 4, "%02x", b); hashHex += s; }
-                    std::string cachePath = cacheDir + "/" + hashHex + ".wdn";
-
-                    std::ofstream wf(cachePath, std::ios::binary);
-                    if (wf) {
-                        wf.write(reinterpret_cast<const char*>(wardenModuleData_.data()), wardenModuleData_.size());
-                        LOG_DEBUG("Warden: Cached module to ", cachePath);
-                    }
-                }
-
-                // Load the module (decrypt, decompress, parse, relocate, init)
-                wardenLoadedModule_ = std::make_shared<WardenModule>();
-                // Inject crypto and socket so module callbacks (sendPacket, generateRC4)
-                // can reach the network layer during initializeModule().
-                wardenLoadedModule_->setCallbackDependencies(
-                    wardenCrypto_.get(),
-                    [this](const uint8_t* data, size_t len) {
-                        if (!wardenCrypto_ || !owner_.socket) return;
-                        std::vector<uint8_t> plaintext(data, data + len);
-                        auto encrypted = wardenCrypto_->encrypt(plaintext);
-                        network::Packet pkt(wireOpcode(Opcode::CMSG_WARDEN_DATA));
-                        for (uint8_t b : encrypted) pkt.writeUInt8(b);
-                        owner_.socket->send(pkt);
-                        LOG_DEBUG("Warden: Module sendPacket callback sent ", len, " bytes");
-                    });
-                if (wardenLoadedModule_->load(wardenModuleData_, wardenModuleHash_, wardenModuleKey_)) { // codeql[cpp/weak-cryptographic-algorithm]
-                    LOG_INFO("Warden: Module loaded successfully (image size=",
-                             wardenLoadedModule_->getModuleSize(), " bytes)");
-                } else {
-                    LOG_ERROR("Warden: Module loading FAILED");
-                    wardenLoadedModule_.reset();
-                }
-
-                // Send MODULE_OK (opcode 0x01)
-                std::vector<uint8_t> resp = { 0x01 }; // WARDEN_CMSG_MODULE_OK
-                sendWardenResponse(resp);
-                LOG_DEBUG("Warden: Sent MODULE_OK");
-            }
-            // No response for intermediate chunks
-            break;
-        }
-
-        case 0x05: { // WARDEN_SMSG_HASH_REQUEST
-            // Format: [1 opcode][16 seed]
-            if (decrypted.size() < 17) {
-                LOG_ERROR("Warden: HASH_REQUEST too short (", decrypted.size(), " bytes, need 17)");
-                return;
-            }
-
-            std::vector<uint8_t> seed(decrypted.begin() + 1, decrypted.begin() + 17);
-            auto applyWardenSeedRekey = [&](const std::vector<uint8_t>& rekeySeed) {
-                // Derive new RC4 keys from the seed using SHA1Randx.
-                uint8_t newEncryptKey[16], newDecryptKey[16];
-                WardenCrypto::sha1RandxGenerate(rekeySeed, newEncryptKey, newDecryptKey);
-
-                std::vector<uint8_t> ek(newEncryptKey, newEncryptKey + 16);
-                std::vector<uint8_t> dk(newDecryptKey, newDecryptKey + 16);
-                wardenCrypto_->replaceKeys(ek, dk);
-                for (auto& b : newEncryptKey) b = 0;
-                for (auto& b : newDecryptKey) b = 0;
-                LOG_DEBUG("Warden: Derived and applied key update from seed");
-            };
-
-            // --- Try CR lookup (pre-computed challenge/response entries) ---
-            if (!wardenCREntries_.empty()) {
-                const WardenCREntry* match = nullptr;
-                for (const auto& entry : wardenCREntries_) {
-                    if (std::memcmp(entry.seed, seed.data(), 16) == 0) {
-                        match = &entry;
-                        break;
-                    }
-                }
-
-                if (match) {
-                    LOG_WARNING("Warden: HASH_REQUEST — CR entry MATCHED, sending pre-computed reply");
-
-                    // Send HASH_RESULT (opcode 0x04 + 20-byte reply)
-                    std::vector<uint8_t> resp;
-                    resp.push_back(0x04);
-                    resp.insert(resp.end(), match->reply, match->reply + 20);
-                    sendWardenResponse(resp);
-
-                    // Switch to new RC4 keys from the CR entry
-                    // clientKey = encrypt (client→server), serverKey = decrypt (server→client)
-                    std::vector<uint8_t> newEncryptKey(match->clientKey, match->clientKey + 16);
-                    std::vector<uint8_t> newDecryptKey(match->serverKey, match->serverKey + 16);
-                    wardenCrypto_->replaceKeys(newEncryptKey, newDecryptKey);
-
-                    LOG_WARNING("Warden: Switched to CR key set");
-
-                    wardenState_ = WardenState::WAIT_CHECKS;
-                    break;
-                } else {
-                    LOG_WARNING("Warden: Seed not found in ", wardenCREntries_.size(), " CR entries");
-                }
-            }
-
-            // --- No CR match: decide strategy based on server strictness ---
-            {
-                std::string seedHex;
-                for (auto b : seed) { char s[4]; snprintf(s, 4, "%02x", b); seedHex += s; }
-
-                bool isTurtle = isActiveExpansion("turtle");
-                bool isClassic = (owner_.build <= 6005) && !isTurtle;
-
-                if (!isTurtle && !isClassic) {
-                    // WotLK/TBC: don't respond to HASH_REQUEST without a valid CR match.
-                    // ChromieCraft/AzerothCore tolerates the silence (no ban, no kick),
-                    // but REJECTS a wrong hash and closes the connection immediately.
-                    // Staying silent lets the server continue the session without Warden checks.
-                    LOG_WARNING("Warden: HASH_REQUEST seed=", seedHex,
-                                " — no CR match, skipping response (server tolerates silence)");
-                    wardenState_ = WardenState::WAIT_CHECKS;
-                    break;
-                }
-
-                LOG_WARNING("Warden: No CR match (seed=", seedHex,
-                            "), sending fallback hash (lenient server)");
-
-                std::vector<uint8_t> fallbackReply;
-                if (wardenLoadedModule_ && wardenLoadedModule_->isLoaded()) {
-                    const uint8_t* moduleImage = static_cast<const uint8_t*>(wardenLoadedModule_->getModuleMemory());
-                    size_t moduleImageSize = wardenLoadedModule_->getModuleSize();
-                    if (moduleImage && moduleImageSize > 0) {
-                        std::vector<uint8_t> imageData(moduleImage, moduleImage + moduleImageSize);
-                        fallbackReply = auth::Crypto::sha1(imageData);
-                    }
-                }
-                if (fallbackReply.empty()) {
-                    if (!wardenModuleData_.empty())
-                        fallbackReply = auth::Crypto::sha1(wardenModuleData_);
-                    else
-                        fallbackReply.assign(20, 0);
-                }
-
-                std::vector<uint8_t> resp;
-                resp.push_back(0x04); // WARDEN_CMSG_HASH_RESULT
-                resp.insert(resp.end(), fallbackReply.begin(), fallbackReply.end());
-                sendWardenResponse(resp);
-                applyWardenSeedRekey(seed);
-            }
-
-            wardenState_ = WardenState::WAIT_CHECKS;
-            break;
-        }
-
-        case 0x02: { // WARDEN_SMSG_CHEAT_CHECKS_REQUEST
-            LOG_DEBUG("Warden: CHEAT_CHECKS_REQUEST (", decrypted.size(), " bytes)");
-
-            if (decrypted.size() < 3) {
-                LOG_ERROR("Warden: CHEAT_CHECKS_REQUEST too short");
-                break;
-            }
-
-            // --- Parse string table ---
-            // Format: [1 opcode][string table: (len+data)*][0x00 end][check data][xorByte]
-            size_t pos = 1;
-            std::vector<std::string> strings;
-            while (pos < decrypted.size()) {
-                uint8_t slen = decrypted[pos++];
-                if (slen == 0) break; // end of string table
-                if (pos + slen > decrypted.size()) break;
-                strings.emplace_back(reinterpret_cast<const char*>(decrypted.data() + pos), slen);
-                pos += slen;
-            }
-            LOG_DEBUG("Warden: String table: ", strings.size(), " entries");
-            for (size_t i = 0; i < strings.size(); i++) {
-                LOG_DEBUG("Warden:   [", i, "] = \"", strings[i], "\"");
-            }
-
-            // XOR byte is the last byte of the packet
-            uint8_t xorByte = decrypted.back();
-            LOG_DEBUG("Warden: XOR byte = 0x", [&]{ char s[4]; snprintf(s,4,"%02x",xorByte); return std::string(s); }());
-
-            // Quick-scan for PAGE_A/PAGE_B checks (these trigger 5-second brute-force searches)
-            {
-                bool hasSlowChecks = false;
-                for (size_t i = pos; i < decrypted.size() - 1; i++) {
-                    uint8_t d = decrypted[i] ^ xorByte;
-                    if (d == wardenCheckOpcodes_[2] || d == wardenCheckOpcodes_[3]) {
-                        hasSlowChecks = true;
-                        break;
-                    }
-                }
-                if (hasSlowChecks && !wardenResponsePending_) {
-                    LOG_WARNING("Warden: PAGE_A/PAGE_B detected — building response async to avoid main-loop stall");
-                    // Ensure wardenMemory_ is loaded on main thread before launching async task
-                    if (!wardenMemory_) {
-                        wardenMemory_ = std::make_unique<WardenMemory>();
-                        if (!wardenMemory_->load(static_cast<uint16_t>(owner_.build), isActiveExpansion("turtle"))) {
-                            LOG_WARNING("Warden: Could not load WoW.exe for MEM_CHECK");
-                        }
-                    }
-                    // Capture state by value (decrypted, strings) and launch async.
-                    // The async task returns plaintext response bytes; main thread encrypts+sends in update().
-                    size_t capturedPos = pos;
-                    wardenPendingEncrypted_ = std::async(std::launch::async,
-                        [this, decrypted, strings, xorByte, capturedPos]() -> std::vector<uint8_t> {
-                            // This runs on a background thread — same logic as the synchronous path below.
-                            // BEGIN: duplicated check processing (kept in sync with synchronous path)
-                            enum CheckType { CT_MEM=0, CT_PAGE_A=1, CT_PAGE_B=2, CT_MPQ=3, CT_LUA=4,
-                                             CT_DRIVER=5, CT_TIMING=6, CT_PROC=7, CT_MODULE=8, CT_UNKNOWN=9 };
-                            size_t checkEnd = decrypted.size() - 1;
-                            size_t pos = capturedPos;
-
-                            auto decodeCheckType = [&](uint8_t raw) -> CheckType {
-                                uint8_t decoded = raw ^ xorByte;
-                                if (decoded == wardenCheckOpcodes_[0]) return CT_MEM;
-                                if (decoded == wardenCheckOpcodes_[1]) return CT_MODULE;
-                                if (decoded == wardenCheckOpcodes_[2]) return CT_PAGE_A;
-                                if (decoded == wardenCheckOpcodes_[3]) return CT_PAGE_B;
-                                if (decoded == wardenCheckOpcodes_[4]) return CT_MPQ;
-                                if (decoded == wardenCheckOpcodes_[5]) return CT_LUA;
-                                if (decoded == wardenCheckOpcodes_[6]) return CT_PROC;
-                                if (decoded == wardenCheckOpcodes_[7]) return CT_DRIVER;
-                                if (decoded == wardenCheckOpcodes_[8]) return CT_TIMING;
-                                return CT_UNKNOWN;
-                            };
-                            auto resolveString = [&](uint8_t idx) -> std::string {
-                                if (idx == 0) return {};
-                                size_t i = idx - 1;
-                                return i < strings.size() ? strings[i] : std::string();
-                            };
-                            auto isKnownWantedCodeScan = [&](const uint8_t seed[4], const uint8_t hash[20],
-                                                             uint32_t off, uint8_t len) -> bool {
-                                auto tryMatch = [&](const uint8_t* pat, size_t patLen) {
-                                    uint8_t out[SHA_DIGEST_LENGTH]; unsigned int outLen = 0;
-                                    HMAC(EVP_sha1(), seed, 4, pat, patLen, out, &outLen);
-                                    return outLen == SHA_DIGEST_LENGTH && !std::memcmp(out, hash, SHA_DIGEST_LENGTH);
-                                };
-                                static const uint8_t p1[] = {0x33,0xD2,0x33,0xC9,0xE8,0x87,0x07,0x1B,0x00,0xE8};
-                                if (off == 13856 && len == sizeof(p1) && tryMatch(p1, sizeof(p1))) return true;
-                                static const uint8_t p2[] = {0x56,0x57,0xFC,0x8B,0x54,0x24,0x14,0x8B,
-                                    0x74,0x24,0x10,0x8B,0x44,0x24,0x0C,0x8B,0xCA,0x8B,0xF8,0xC1,
-                                    0xE9,0x02,0x74,0x02,0xF3,0xA5,0xB1,0x03,0x23,0xCA,0x74,0x02,
-                                    0xF3,0xA4,0x5F,0x5E,0xC3};
-                                if (len == sizeof(p2) && tryMatch(p2, sizeof(p2))) return true;
-                                return false;
-                            };
-
-                            std::vector<uint8_t> resultData;
-                            int checkCount = 0;
-                            int checkTypeCounts[10] = {};
-
-                            #define WARDEN_ASYNC_HANDLER 1
-                            // The check processing loop is identical to the synchronous path.
-                            // See the synchronous case 0x02 below for the canonical version.
-                            while (pos < checkEnd) {
-                                CheckType ct = decodeCheckType(decrypted[pos]);
-                                pos++;
-                                checkCount++;
-                                if (ct <= CT_UNKNOWN) checkTypeCounts[ct]++;
-
-                                switch (ct) {
-                                case CT_TIMING: {
-                                    resultData.push_back(0x01);
-                                    uint32_t ticks = static_cast<uint32_t>(
-                                        std::chrono::duration_cast<std::chrono::milliseconds>(
-                                            std::chrono::steady_clock::now().time_since_epoch()).count());
-                                    resultData.push_back(ticks & 0xFF);
-                                    resultData.push_back((ticks >> 8) & 0xFF);
-                                    resultData.push_back((ticks >> 16) & 0xFF);
-                                    resultData.push_back((ticks >> 24) & 0xFF);
-                                    break;
-                                }
-                                case CT_MEM: {
-                                    if (pos + 6 > checkEnd) { pos = checkEnd; break; }
-                                    uint8_t strIdx = decrypted[pos++];
-                                    std::string moduleName = resolveString(strIdx);
-                                    uint32_t offset = decrypted[pos] | (uint32_t(decrypted[pos+1])<<8)
-                                                    | (uint32_t(decrypted[pos+2])<<16) | (uint32_t(decrypted[pos+3])<<24);
-                                    pos += 4;
-                                    uint8_t readLen = decrypted[pos++];
-                                    LOG_WARNING("Warden:   MEM offset=0x", [&]{char s[12];snprintf(s,12,"%08x",offset);return std::string(s);}(),
-                                             " len=", (int)readLen,
-                                             (strIdx ? " module=\"" + moduleName + "\"" : ""));
-                                    if (offset == 0x00CF0BC8 && readLen == 4 && wardenMemory_ && wardenMemory_->isLoaded()) {
-                                        uint32_t now = static_cast<uint32_t>(
-                                            std::chrono::duration_cast<std::chrono::milliseconds>(
-                                                std::chrono::steady_clock::now().time_since_epoch()).count());
-                                        wardenMemory_->writeLE32(0xCF0BC8, now - 2000);
-                                    }
-                                    std::vector<uint8_t> memBuf(readLen, 0);
-                                    bool memOk = wardenMemory_ && wardenMemory_->isLoaded() &&
-                                                 wardenMemory_->readMemory(offset, readLen, memBuf.data());
-                                    if (memOk) {
-                                        const char* region = "?";
-                                        if (offset >= 0x7FFE0000 && offset < 0x7FFF0000) region = "KUSER";
-                                        else if (offset >= 0x400000 && offset < 0x800000) region = ".text/.code";
-                                        else if (offset >= 0x7FF000 && offset < 0x827000) region = ".rdata";
-                                        else if (offset >= 0x827000 && offset < 0x883000) region = ".data(raw)";
-                                        else if (offset >= 0x883000 && offset < 0xD06000) region = ".data(BSS)";
-                                        bool allZero = true;
-                                        for (int i = 0; i < (int)readLen; i++) { if (memBuf[i] != 0) { allZero = false; break; } }
-                                        std::string hexDump;
-                                        for (int i = 0; i < (int)readLen; i++) { char hx[4]; snprintf(hx,4,"%02x ",memBuf[i]); hexDump += hx; }
-                                        LOG_WARNING("Warden:   MEM_CHECK served: [", hexDump, "] region=", region,
-                                                    (allZero && offset >= 0x883000 ? " \xe2\x98\x85""BSS_ZERO\xe2\x98\x85" : ""));
-                                        if (offset == 0x7FFE026C && readLen == 12)
-                                            LOG_WARNING("Warden:   Applying 4-byte ULONG alignment padding for WinVersionGet");
-                                        resultData.push_back(0x00);
-                                        resultData.insert(resultData.end(), memBuf.begin(), memBuf.end());
-                                    } else {
-                                        LOG_WARNING("Warden:   MEM_CHECK -> 0xE9 (unmapped 0x",
-                                                    [&]{char s[12];snprintf(s,12,"%08x",offset);return std::string(s);}(), ")");
-                                        resultData.push_back(0xE9);
-                                    }
-                                    break;
-                                }
-                                case CT_PAGE_A:
-                                case CT_PAGE_B: {
-                                    constexpr size_t kPageSize = 29;
-                                    const char* pageName = (ct == CT_PAGE_A) ? "PAGE_A" : "PAGE_B";
-                                    bool isImageOnly = (ct == CT_PAGE_A);
-                                    if (pos + kPageSize > checkEnd) { pos = checkEnd; resultData.push_back(0x00); break; }
-                                    const uint8_t* p = decrypted.data() + pos;
-                                    const uint8_t* seed = p;
-                                    const uint8_t* sha1 = p + 4;
-                                    uint32_t off = uint32_t(p[24])|(uint32_t(p[25])<<8)|(uint32_t(p[26])<<16)|(uint32_t(p[27])<<24);
-                                    uint8_t patLen = p[28];
-                                    bool found = false;
-                                    bool turtleFallback = false;
-                                    if (isKnownWantedCodeScan(seed, sha1, off, patLen)) {
-                                        found = true;
-                                    } else if (wardenMemory_ && wardenMemory_->isLoaded() && patLen > 0) {
-                                        bool hintOnly = (ct == CT_PAGE_A && isActiveExpansion("turtle"));
-                                        found = wardenMemory_->searchCodePattern(seed, sha1, patLen, isImageOnly, off, hintOnly);
-                                        if (!found && !hintOnly && wardenLoadedModule_ && wardenLoadedModule_->isLoaded()) {
-                                            const uint8_t* modMem = static_cast<const uint8_t*>(wardenLoadedModule_->getModuleMemory());
-                                            size_t modSize = wardenLoadedModule_->getModuleSize();
-                                            if (modMem && modSize >= patLen) {
-                                                for (size_t i = 0; i < modSize - patLen + 1; i++) {
-                                                    uint8_t h[20]; unsigned int hl = 0;
-                                                    HMAC(EVP_sha1(), seed, 4, modMem+i, patLen, h, &hl);
-                                                    if (hl == 20 && !std::memcmp(h, sha1, 20)) { found = true; break; }
-                                                }
-                                            }
-                                        }
-                                    }
-                                    if (!found && ct == CT_PAGE_A && isActiveExpansion("turtle") && off < 0x600000) {
-                                        found = true;
-                                        turtleFallback = true;
-                                    }
-                                    uint8_t pageResult = found ? 0x4A : 0x00;
-                                    LOG_WARNING("Warden:   ", pageName, " offset=0x",
-                                                [&]{char s[12];snprintf(s,12,"%08x",off);return std::string(s);}(),
-                                                " patLen=", (int)patLen, " found=", found ? "yes" : "no",
-                                                turtleFallback ? " (turtle-fallback)" : "");
-                                    pos += kPageSize;
-                                    resultData.push_back(pageResult);
-                                    break;
-                                }
-                                case CT_MPQ: {
-                                    if (pos + 1 > checkEnd) { pos = checkEnd; break; }
-                                    uint8_t strIdx = decrypted[pos++];
-                                    std::string filePath = resolveString(strIdx);
-                                    LOG_WARNING("Warden:   MPQ file=\"", (filePath.empty() ? "?" : filePath), "\"");
-                                    bool found = false;
-                                    std::vector<uint8_t> hash(20, 0);
-                                    if (!filePath.empty()) {
-                                        std::string np = asciiLower(filePath);
-                                        std::replace(np.begin(), np.end(), '/', '\\');
-                                        auto knownIt = knownDoorHashes().find(np);
-                                        if (knownIt != knownDoorHashes().end()) { found = true; hash.assign(knownIt->second.begin(), knownIt->second.end()); }
-                                        auto* am = owner_.services().assetManager;
-                                        if (am && am->isInitialized() && !found) {
-                                            std::vector<uint8_t> fd;
-                                            std::string rp = resolveCaseInsensitiveDataPath(am->getDataPath(), filePath);
-                                            if (!rp.empty()) fd = readFileBinary(rp);
-                                            if (fd.empty()) fd = am->readFile(filePath);
-                                            if (!fd.empty()) { found = true; hash = auth::Crypto::sha1(fd); }
-                                        }
-                                    }
-                                    LOG_WARNING("Warden:   MPQ result=", (found ? "FOUND" : "NOT_FOUND"));
-                                    if (found) { resultData.push_back(0x00); resultData.insert(resultData.end(), hash.begin(), hash.end()); }
-                                    else { resultData.push_back(0x01); }
-                                    break;
-                                }
-                                case CT_LUA: {
-                                    if (pos + 1 > checkEnd) { pos = checkEnd; break; }
-                                    pos++; resultData.push_back(0x01); break;
-                                }
-                                case CT_DRIVER: {
-                                    if (pos + 25 > checkEnd) { pos = checkEnd; break; }
-                                    pos += 24;
-                                    uint8_t strIdx = decrypted[pos++];
-                                    std::string dn = resolveString(strIdx);
-                                    LOG_WARNING("Warden:   DRIVER=\"", (dn.empty() ? "?" : dn), "\" -> 0x00(not found)");
-                                    resultData.push_back(0x00); break;
-                                }
-                                case CT_MODULE: {
-                                    if (pos + 24 > checkEnd) { pos = checkEnd; resultData.push_back(0x00); break; }
-                                    const uint8_t* p = decrypted.data() + pos;
-                                    uint8_t sb[4] = {p[0],p[1],p[2],p[3]};
-                                    uint8_t rh[20]; std::memcpy(rh, p+4, 20);
-                                    pos += 24;
-                                    bool isWanted = hmacSha1Matches(sb, "KERNEL32.DLL", rh);
-                                    std::string mn = isWanted ? "KERNEL32.DLL" : "?";
-                                    if (!isWanted) {
-                                        // Cheat modules (unwanted — report not found)
-                                        if (hmacSha1Matches(sb,"WPESPY.DLL",rh)) mn = "WPESPY.DLL";
-                                        else if (hmacSha1Matches(sb,"TAMIA.DLL",rh)) mn = "TAMIA.DLL";
-                                        else if (hmacSha1Matches(sb,"PRXDRVPE.DLL",rh)) mn = "PRXDRVPE.DLL";
-                                        else if (hmacSha1Matches(sb,"SPEEDHACK-I386.DLL",rh)) mn = "SPEEDHACK-I386.DLL";
-                                        else if (hmacSha1Matches(sb,"D3DHOOK.DLL",rh)) mn = "D3DHOOK.DLL";
-                                        else if (hmacSha1Matches(sb,"NJUMD.DLL",rh)) mn = "NJUMD.DLL";
-                                        // System DLLs (wanted — report found)
-                                        else if (hmacSha1Matches(sb,"USER32.DLL",rh)) { mn = "USER32.DLL"; isWanted = true; }
-                                        else if (hmacSha1Matches(sb,"NTDLL.DLL",rh)) { mn = "NTDLL.DLL"; isWanted = true; }
-                                        else if (hmacSha1Matches(sb,"WS2_32.DLL",rh)) { mn = "WS2_32.DLL"; isWanted = true; }
-                                        else if (hmacSha1Matches(sb,"WSOCK32.DLL",rh)) { mn = "WSOCK32.DLL"; isWanted = true; }
-                                        else if (hmacSha1Matches(sb,"ADVAPI32.DLL",rh)) { mn = "ADVAPI32.DLL"; isWanted = true; }
-                                        else if (hmacSha1Matches(sb,"SHELL32.DLL",rh)) { mn = "SHELL32.DLL"; isWanted = true; }
-                                        else if (hmacSha1Matches(sb,"GDI32.DLL",rh)) { mn = "GDI32.DLL"; isWanted = true; }
-                                        else if (hmacSha1Matches(sb,"OPENGL32.DLL",rh)) { mn = "OPENGL32.DLL"; isWanted = true; }
-                                        else if (hmacSha1Matches(sb,"WINMM.DLL",rh)) { mn = "WINMM.DLL"; isWanted = true; }
-                                    }
-                                    uint8_t mr = isWanted ? 0x4A : 0x00;
-                                    LOG_WARNING("Warden:   MODULE \"", mn, "\" -> 0x",
-                                                [&]{char s[4];snprintf(s,4,"%02x",mr);return std::string(s);}(),
-                                                isWanted ? "(found)" : "(not found)");
-                                    resultData.push_back(mr); break;
-                                }
-                                case CT_PROC: {
-                                    if (pos + 30 > checkEnd) { pos = checkEnd; break; }
-                                    pos += 30; resultData.push_back(0x01); break;
-                                }
-                                default: pos = checkEnd; break;
-                                }
-                            }
-                            #undef WARDEN_ASYNC_HANDLER
-
-                            // Log summary
-                            {
-                                std::string summary;
-                                const char* ctNames[] = {"MEM","PAGE_A","PAGE_B","MPQ","LUA","DRIVER","TIMING","PROC","MODULE","UNK"};
-                                for (int i = 0; i < 10; i++) {
-                                    if (checkTypeCounts[i] > 0) {
-                                        if (!summary.empty()) summary += " ";
-                                        summary += ctNames[i]; summary += "="; summary += std::to_string(checkTypeCounts[i]);
-                                    }
-                                }
-                                LOG_WARNING("Warden: (async) Parsed ", checkCount, " checks [", summary,
-                                            "] resultSize=", resultData.size());
-                                std::string fullHex;
-                                for (size_t bi = 0; bi < resultData.size(); bi++) {
-                                    char hx[4]; snprintf(hx, 4, "%02x ", resultData[bi]); fullHex += hx;
-                                    if ((bi + 1) % 32 == 0 && bi + 1 < resultData.size()) fullHex += "\n                    ";
-                                }
-                                LOG_WARNING("Warden: RESPONSE_HEX [", fullHex, "]");
-                            }
-
-                            // Build plaintext response: [0x02][uint16 len][uint32 checksum][resultData]
-                            auto resultHash = auth::Crypto::sha1(resultData);
-                            uint32_t checksum = 0;
-                            for (int i = 0; i < 5; i++) {
-                                uint32_t word = resultHash[i*4] | (uint32_t(resultHash[i*4+1])<<8)
-                                              | (uint32_t(resultHash[i*4+2])<<16) | (uint32_t(resultHash[i*4+3])<<24);
-                                checksum ^= word;
-                            }
-                            uint16_t rl = static_cast<uint16_t>(resultData.size());
-                            std::vector<uint8_t> resp;
-                            resp.push_back(0x02);
-                            resp.push_back(rl & 0xFF); resp.push_back((rl >> 8) & 0xFF);
-                            resp.push_back(checksum & 0xFF); resp.push_back((checksum >> 8) & 0xFF);
-                            resp.push_back((checksum >> 16) & 0xFF); resp.push_back((checksum >> 24) & 0xFF);
-                            resp.insert(resp.end(), resultData.begin(), resultData.end());
-                            return resp; // plaintext; main thread will encrypt + send
-                        });
-                    wardenResponsePending_ = true;
-                    break; // exit case 0x02 — response will be sent from update()
-                }
-            }
-
-            // Check type enum indices
-            enum CheckType { CT_MEM=0, CT_PAGE_A=1, CT_PAGE_B=2, CT_MPQ=3, CT_LUA=4,
-                             CT_DRIVER=5, CT_TIMING=6, CT_PROC=7, CT_MODULE=8, CT_UNKNOWN=9 };
-            const char* checkTypeNames[] = {"MEM","PAGE_A","PAGE_B","MPQ","LUA","DRIVER","TIMING","PROC","MODULE","UNKNOWN"};
-            size_t checkEnd = decrypted.size() - 1; // exclude xorByte
-
-            auto decodeCheckType = [&](uint8_t raw) -> CheckType {
-                uint8_t decoded = raw ^ xorByte;
-                if (decoded == wardenCheckOpcodes_[0]) return CT_MEM;    // READ_MEMORY
-                if (decoded == wardenCheckOpcodes_[1]) return CT_MODULE; // FIND_MODULE_BY_NAME
-                if (decoded == wardenCheckOpcodes_[2]) return CT_PAGE_A; // FIND_MEM_IMAGE_CODE_BY_HASH
-                if (decoded == wardenCheckOpcodes_[3]) return CT_PAGE_B; // FIND_CODE_BY_HASH
-                if (decoded == wardenCheckOpcodes_[4]) return CT_MPQ;    // HASH_CLIENT_FILE
-                if (decoded == wardenCheckOpcodes_[5]) return CT_LUA;    // GET_LUA_VARIABLE
-                if (decoded == wardenCheckOpcodes_[6]) return CT_PROC;   // API_CHECK
-                if (decoded == wardenCheckOpcodes_[7]) return CT_DRIVER; // FIND_DRIVER_BY_NAME
-                if (decoded == wardenCheckOpcodes_[8]) return CT_TIMING; // CHECK_TIMING_VALUES
-                return CT_UNKNOWN;
-            };
-            auto isKnownWantedCodeScan = [&](const uint8_t seedBytes[4], const uint8_t reqHash[20],
-                                            uint32_t offset, uint8_t length) -> bool {
-                auto hashPattern = [&](const uint8_t* pattern, size_t patternLen) {
-                    uint8_t out[SHA_DIGEST_LENGTH];
-                    unsigned int outLen = 0;
-                    HMAC(EVP_sha1(),
-                         seedBytes, 4,
-                         pattern, patternLen,
-                         out, &outLen);
-                    return outLen == SHA_DIGEST_LENGTH && std::memcmp(out, reqHash, SHA_DIGEST_LENGTH) == 0;
-                };
-
-                // DB sanity check: "Warden packet process code search sanity check" (id=85)
-                static const uint8_t kPacketProcessSanityPattern[] = {
-                    0x33, 0xD2, 0x33, 0xC9, 0xE8, 0x87, 0x07, 0x1B, 0x00, 0xE8
-                };
-                if (offset == 13856 && length == sizeof(kPacketProcessSanityPattern) &&
-                    hashPattern(kPacketProcessSanityPattern, sizeof(kPacketProcessSanityPattern))) {
-                    return true;
-                }
-
-                // Scripted sanity check: "Warden Memory Read check" in wardenwin.cpp
-                static const uint8_t kWardenMemoryReadPattern[] = {
-                    0x56, 0x57, 0xFC, 0x8B, 0x54, 0x24, 0x14, 0x8B,
-                    0x74, 0x24, 0x10, 0x8B, 0x44, 0x24, 0x0C, 0x8B,
-                    0xCA, 0x8B, 0xF8, 0xC1, 0xE9, 0x02, 0x74, 0x02,
-                    0xF3, 0xA5, 0xB1, 0x03, 0x23, 0xCA, 0x74, 0x02,
-                    0xF3, 0xA4, 0x5F, 0x5E, 0xC3
-                };
-                if (length == sizeof(kWardenMemoryReadPattern) &&
-                    hashPattern(kWardenMemoryReadPattern, sizeof(kWardenMemoryReadPattern))) {
-                    return true;
-                }
-
-                return false;
-            };
-            auto resolveWardenString = [&](uint8_t oneBasedIndex) -> std::string {
-                if (oneBasedIndex == 0) return std::string();
-                size_t idx = static_cast<size_t>(oneBasedIndex - 1);
-                if (idx >= strings.size()) return std::string();
-                return strings[idx];
-            };
-            auto requestSizes = [&](CheckType ct) {
-                switch (ct) {
-                    case CT_TIMING: return std::vector<size_t>{0};
-                    case CT_MEM:    return std::vector<size_t>{6};
-                    case CT_PAGE_A: return std::vector<size_t>{24, 29};
-                    case CT_PAGE_B: return std::vector<size_t>{24, 29};
-                    case CT_MPQ:    return std::vector<size_t>{1};
-                    case CT_LUA:    return std::vector<size_t>{1};
-                    case CT_DRIVER: return std::vector<size_t>{25};
-                    case CT_PROC:   return std::vector<size_t>{30};
-                    case CT_MODULE: return std::vector<size_t>{24};
-                    default:        return std::vector<size_t>{};
-                }
-            };
-            std::unordered_map<size_t, bool> parseMemo;
-            std::function<bool(size_t)> canParseFrom = [&](size_t checkPos) -> bool {
-                if (checkPos == checkEnd) return true;
-                if (checkPos > checkEnd) return false;
-                auto it = parseMemo.find(checkPos);
-                if (it != parseMemo.end()) return it->second;
-
-                CheckType ct = decodeCheckType(decrypted[checkPos]);
-                if (ct == CT_UNKNOWN) {
-                    parseMemo[checkPos] = false;
-                    return false;
-                }
-
-                size_t payloadPos = checkPos + 1;
-                for (size_t reqSize : requestSizes(ct)) {
-                    if (payloadPos + reqSize > checkEnd) continue;
-                    if (canParseFrom(payloadPos + reqSize)) {
-                        parseMemo[checkPos] = true;
-                        return true;
-                    }
-                }
-
-                parseMemo[checkPos] = false;
-                return false;
-            };
-            auto isBoundaryAfter = [&](size_t start, size_t consume) -> bool {
-                size_t next = start + consume;
-                if (next == checkEnd) return true;
-                if (next > checkEnd) return false;
-                return decodeCheckType(decrypted[next]) != CT_UNKNOWN;
-            };
-
-            // --- Parse check entries and build response ---
-            std::vector<uint8_t> resultData;
-            int checkCount = 0;
-
-            while (pos < checkEnd) {
-                CheckType ct = decodeCheckType(decrypted[pos]);
-                pos++;
-                checkCount++;
-
-                LOG_DEBUG("Warden: Check #", checkCount, " type=", checkTypeNames[ct],
-                         " at offset ", pos - 1);
-
-                switch (ct) {
-                    case CT_TIMING: {
-                        // No additional request data
-                        // Response: [uint8 result][uint32 ticks]
-                        resultData.push_back(0x01);
-                        uint32_t ticks = static_cast<uint32_t>(
-                            std::chrono::duration_cast<std::chrono::milliseconds>(
-                                std::chrono::steady_clock::now().time_since_epoch()).count());
-                        resultData.push_back(ticks & 0xFF);
-                        resultData.push_back((ticks >> 8) & 0xFF);
-                        resultData.push_back((ticks >> 16) & 0xFF);
-                        resultData.push_back((ticks >> 24) & 0xFF);
-                        LOG_WARNING("Warden:   (sync) TIMING ticks=", ticks);
-                        break;
-                    }
-                    case CT_MEM: {
-                        // Request: [1 stringIdx][4 offset][1 length]
-                        if (pos + 6 > checkEnd) { pos = checkEnd; break; }
-                        uint8_t strIdx = decrypted[pos++];
-                        std::string moduleName = resolveWardenString(strIdx);
-                        uint32_t offset = decrypted[pos] | (uint32_t(decrypted[pos+1])<<8)
-                                        | (uint32_t(decrypted[pos+2])<<16) | (uint32_t(decrypted[pos+3])<<24);
-                        pos += 4;
-                        uint8_t readLen = decrypted[pos++];
-                        LOG_WARNING("Warden:   (sync) MEM offset=0x", [&]{char s[12];snprintf(s,12,"%08x",offset);return std::string(s);}(),
-                                 " len=", (int)readLen,
-                                 moduleName.empty() ? "" : (" module=\"" + moduleName + "\""));
-
-                        // Lazy-load WoW.exe PE image on first MEM_CHECK
-                        if (!wardenMemory_) {
-                            wardenMemory_ = std::make_unique<WardenMemory>();
-                            if (!wardenMemory_->load(static_cast<uint16_t>(owner_.build), isActiveExpansion("turtle"))) {
-                                LOG_WARNING("Warden: Could not load WoW.exe for MEM_CHECK");
-                            }
-                        }
-
-                        // Dynamically update LastHardwareAction before reading
-                        if (offset == 0x00CF0BC8 && readLen == 4 && wardenMemory_ && wardenMemory_->isLoaded()) {
-                            uint32_t now = static_cast<uint32_t>(
-                                std::chrono::duration_cast<std::chrono::milliseconds>(
-                                    std::chrono::steady_clock::now().time_since_epoch()).count());
-                            wardenMemory_->writeLE32(0xCF0BC8, now - 2000);
-                        }
-
-                        // Read bytes from PE image (includes patched runtime globals)
-                        std::vector<uint8_t> memBuf(readLen, 0);
-                        if (wardenMemory_->isLoaded() && wardenMemory_->readMemory(offset, readLen, memBuf.data())) {
-                            LOG_DEBUG("Warden:   MEM_CHECK served from PE image");
-                            resultData.push_back(0x00);
-                            resultData.insert(resultData.end(), memBuf.begin(), memBuf.end());
-                        } else {
-                            // Address not in PE/KUSER — return 0xE9 (not readable).
-                            LOG_WARNING("Warden:   (sync) MEM_CHECK -> 0xE9 (unmapped 0x",
-                                        [&]{char s[12];snprintf(s,12,"%08x",offset);return std::string(s);}(), ")");
-                            resultData.push_back(0xE9);
-                        }
-                        break;
-                    }
-                    case CT_PAGE_A: {
-                        // Classic has seen two PAGE_A layouts in the wild:
-                        // short: [4 seed][20 sha1] = 24 bytes
-                        // long:  [4 seed][20 sha1][4 addr][1 len] = 29 bytes
-                        constexpr size_t kPageAShort = 24;
-                        constexpr size_t kPageALong = 29;
-                        size_t consume = 0;
-
-                        if (pos + kPageAShort <= checkEnd && canParseFrom(pos + kPageAShort)) {
-                            consume = kPageAShort;
-                        }
-                        if (pos + kPageALong <= checkEnd && canParseFrom(pos + kPageALong) && consume == 0) {
-                            consume = kPageALong;
-                        }
-                        if (consume == 0 && isBoundaryAfter(pos, kPageAShort)) consume = kPageAShort;
-                        if (consume == 0 && isBoundaryAfter(pos, kPageALong)) consume = kPageALong;
-
-                        if (consume == 0) {
-                            size_t remaining = checkEnd - pos;
-                            if (remaining >= kPageAShort && remaining < kPageALong) consume = kPageAShort;
-                            else if (remaining >= kPageALong) consume = kPageALong;
-                            else {
-                                LOG_WARNING("Warden:   PAGE_A check truncated (remaining=", remaining,
-                                            "), consuming remainder");
-                                pos = checkEnd;
-                                resultData.push_back(0x00);
-                                break;
-                            }
-                        }
-
-                        uint8_t pageResult = 0x00;
-                        if (consume >= 29) {
-                            const uint8_t* p = decrypted.data() + pos;
-                            uint8_t seedBytes[4] = { p[0], p[1], p[2], p[3] };
-                            uint8_t reqHash[20];
-                            std::memcpy(reqHash, p + 4, 20);
-                            uint32_t off = uint32_t(p[24]) | (uint32_t(p[25]) << 8) |
-                                           (uint32_t(p[26]) << 16) | (uint32_t(p[27]) << 24);
-                            uint8_t len = p[28];
-                            if (isKnownWantedCodeScan(seedBytes, reqHash, off, len)) {
-                                pageResult = 0x4A;
-                            } else if (wardenMemory_ && wardenMemory_->isLoaded() && len > 0) {
-                                if (wardenMemory_->searchCodePattern(seedBytes, reqHash, len, true, off))
-                                    pageResult = 0x4A;
-                            }
-                            // Turtle PAGE_A fallback: runtime-patched offsets aren't in the
-                            // on-disk PE. Server expects "found" for code integrity checks.
-                            if (pageResult == 0x00 && isActiveExpansion("turtle") && off < 0x600000) {
-                                pageResult = 0x4A;
-                                LOG_WARNING("Warden:   PAGE_A turtle-fallback for offset=0x",
-                                            [&]{char s[12];snprintf(s,12,"%08x",off);return std::string(s);}());
-                            }
-                        }
-                        if (consume >= 29) {
-                            uint32_t off2 = uint32_t((decrypted.data()+pos)[24]) | (uint32_t((decrypted.data()+pos)[25])<<8) |
-                                            (uint32_t((decrypted.data()+pos)[26])<<16) | (uint32_t((decrypted.data()+pos)[27])<<24);
-                            uint8_t len2 = (decrypted.data()+pos)[28];
-                            LOG_WARNING("Warden:   (sync) PAGE_A offset=0x",
-                                        [&]{char s[12];snprintf(s,12,"%08x",off2);return std::string(s);}(),
-                                        " patLen=", (int)len2,
-                                        " result=0x", [&]{char s[4];snprintf(s,4,"%02x",pageResult);return std::string(s);}());
-                        } else {
-                            LOG_WARNING("Warden:   (sync) PAGE_A (short ", consume, "b) result=0x",
-                                        [&]{char s[4];snprintf(s,4,"%02x",pageResult);return std::string(s);}());
-                        }
-                        pos += consume;
-                        resultData.push_back(pageResult);
-                        break;
-                    }
-                    case CT_PAGE_B: {
-                        constexpr size_t kPageBShort = 24;
-                        constexpr size_t kPageBLong = 29;
-                        size_t consume = 0;
-
-                        if (pos + kPageBShort <= checkEnd && canParseFrom(pos + kPageBShort)) {
-                            consume = kPageBShort;
-                        }
-                        if (pos + kPageBLong <= checkEnd && canParseFrom(pos + kPageBLong) && consume == 0) {
-                            consume = kPageBLong;
-                        }
-                        if (consume == 0 && isBoundaryAfter(pos, kPageBShort)) consume = kPageBShort;
-                        if (consume == 0 && isBoundaryAfter(pos, kPageBLong)) consume = kPageBLong;
-
-                        if (consume == 0) {
-                            size_t remaining = checkEnd - pos;
-                            if (remaining >= kPageBShort && remaining < kPageBLong) consume = kPageBShort;
-                            else if (remaining >= kPageBLong) consume = kPageBLong;
-                            else { pos = checkEnd; break; }
-                        }
-                        uint8_t pageResult = 0x00;
-                        if (consume >= 29) {
-                            const uint8_t* p = decrypted.data() + pos;
-                            uint8_t seedBytes[4] = { p[0], p[1], p[2], p[3] };
-                            uint8_t reqHash[20];
-                            std::memcpy(reqHash, p + 4, 20);
-                            uint32_t off = uint32_t(p[24]) | (uint32_t(p[25]) << 8) |
-                                           (uint32_t(p[26]) << 16) | (uint32_t(p[27]) << 24);
-                            uint8_t len = p[28];
-                            if (isKnownWantedCodeScan(seedBytes, reqHash, off, len)) {
-                                pageResult = 0x4A; // PatternFound
-                            }
-                        }
-                        LOG_DEBUG("Warden:   PAGE_B request bytes=", consume,
-                                 " result=0x", [&]{char s[4];snprintf(s,4,"%02x",pageResult);return std::string(s);}());
-                        pos += consume;
-                        resultData.push_back(pageResult);
-                        break;
-                    }
-                    case CT_MPQ: {
-                        // HASH_CLIENT_FILE request: [1 stringIdx]
-                        if (pos + 1 > checkEnd) { pos = checkEnd; break; }
-                        uint8_t strIdx = decrypted[pos++];
-                        std::string filePath = resolveWardenString(strIdx);
-                        LOG_WARNING("Warden:   (sync) MPQ file=\"", (filePath.empty() ? "?" : filePath), "\"");
-
-                        bool found = false;
-                        std::vector<uint8_t> hash(20, 0);
-                        if (!filePath.empty()) {
-                            std::string normalizedPath = asciiLower(filePath);
-                            std::replace(normalizedPath.begin(), normalizedPath.end(), '/', '\\');
-                            auto knownIt = knownDoorHashes().find(normalizedPath);
-                            if (knownIt != knownDoorHashes().end()) {
-                                found = true;
-                                hash.assign(knownIt->second.begin(), knownIt->second.end());
-                            }
-
-                            auto* am = owner_.services().assetManager;
-                            if (am && am->isInitialized() && !found) {
-                                std::vector<uint8_t> fileData;
-                                std::string resolvedFsPath =
-                                    resolveCaseInsensitiveDataPath(am->getDataPath(), filePath);
-                                if (!resolvedFsPath.empty()) {
-                                    fileData = readFileBinary(resolvedFsPath);
-                                }
-                                if (fileData.empty()) {
-                                    fileData = am->readFile(filePath);
-                                }
-
-                                if (!fileData.empty()) {
-                                    found = true;
-                                    hash = auth::Crypto::sha1(fileData);
-                                }
-                            }
-                        }
-
-                        if (found) {
-                            resultData.push_back(0x00);
-                            resultData.insert(resultData.end(), hash.begin(), hash.end());
-                        } else {
-                            resultData.push_back(0x01);
-                        }
-                        LOG_WARNING("Warden:   (sync) MPQ result=", found ? "FOUND" : "NOT_FOUND");
-                        break;
-                    }
-                    case CT_LUA: {
-                        // Request: [1 stringIdx]
-                        if (pos + 1 > checkEnd) { pos = checkEnd; break; }
-                        uint8_t strIdx = decrypted[pos++];
-                        std::string luaVar = resolveWardenString(strIdx);
-                        LOG_WARNING("Warden:   (sync) LUA str=\"", (luaVar.empty() ? "?" : luaVar), "\"");
-                        resultData.push_back(0x01); // not found
-                        break;
-                    }
-                    case CT_DRIVER: {
-                        // Request: [4 seed][20 sha1][1 stringIdx]
-                        if (pos + 25 > checkEnd) { pos = checkEnd; break; }
-                        pos += 24; // skip seed + sha1
-                        uint8_t strIdx = decrypted[pos++];
-                        std::string driverName = resolveWardenString(strIdx);
-                        LOG_WARNING("Warden:   (sync) DRIVER=\"", (driverName.empty() ? "?" : driverName), "\" -> 0x00(not found)");
-                        resultData.push_back(0x00);
-                        break;
-                    }
-                    case CT_MODULE: {
-                        // FIND_MODULE_BY_NAME request: [4 seed][20 sha1] = 24 bytes
-                        int moduleSize = 24;
-                        if (pos + moduleSize > checkEnd) {
-                            size_t remaining = checkEnd - pos;
-                            LOG_WARNING("Warden:   MODULE check truncated (remaining=", remaining,
-                                        ", expected=", moduleSize, "), consuming remainder");
-                            pos = checkEnd;
-                        } else {
-                            const uint8_t* p = decrypted.data() + pos;
-                            uint8_t seedBytes[4] = { p[0], p[1], p[2], p[3] };
-                            uint8_t reqHash[20];
-                            std::memcpy(reqHash, p + 4, 20);
-                            pos += moduleSize;
-
-                            bool shouldReportFound = false;
-                            std::string modName = "?";
-                            // Wanted system modules
-                            if (hmacSha1Matches(seedBytes, "KERNEL32.DLL", reqHash)) { modName = "KERNEL32.DLL"; shouldReportFound = true; }
-                            else if (hmacSha1Matches(seedBytes, "USER32.DLL", reqHash)) { modName = "USER32.DLL"; shouldReportFound = true; }
-                            else if (hmacSha1Matches(seedBytes, "NTDLL.DLL", reqHash)) { modName = "NTDLL.DLL"; shouldReportFound = true; }
-                            else if (hmacSha1Matches(seedBytes, "WS2_32.DLL", reqHash)) { modName = "WS2_32.DLL"; shouldReportFound = true; }
-                            else if (hmacSha1Matches(seedBytes, "WSOCK32.DLL", reqHash)) { modName = "WSOCK32.DLL"; shouldReportFound = true; }
-                            else if (hmacSha1Matches(seedBytes, "ADVAPI32.DLL", reqHash)) { modName = "ADVAPI32.DLL"; shouldReportFound = true; }
-                            else if (hmacSha1Matches(seedBytes, "SHELL32.DLL", reqHash)) { modName = "SHELL32.DLL"; shouldReportFound = true; }
-                            else if (hmacSha1Matches(seedBytes, "GDI32.DLL", reqHash)) { modName = "GDI32.DLL"; shouldReportFound = true; }
-                            else if (hmacSha1Matches(seedBytes, "OPENGL32.DLL", reqHash)) { modName = "OPENGL32.DLL"; shouldReportFound = true; }
-                            else if (hmacSha1Matches(seedBytes, "WINMM.DLL", reqHash)) { modName = "WINMM.DLL"; shouldReportFound = true; }
-                            // Unwanted cheat modules
-                            else if (hmacSha1Matches(seedBytes, "WPESPY.DLL", reqHash)) modName = "WPESPY.DLL";
-                            else if (hmacSha1Matches(seedBytes, "SPEEDHACK-I386.DLL", reqHash)) modName = "SPEEDHACK-I386.DLL";
-                            else if (hmacSha1Matches(seedBytes, "TAMIA.DLL", reqHash)) modName = "TAMIA.DLL";
-                            else if (hmacSha1Matches(seedBytes, "PRXDRVPE.DLL", reqHash)) modName = "PRXDRVPE.DLL";
-                            else if (hmacSha1Matches(seedBytes, "D3DHOOK.DLL", reqHash)) modName = "D3DHOOK.DLL";
-                            else if (hmacSha1Matches(seedBytes, "NJUMD.DLL", reqHash)) modName = "NJUMD.DLL";
-                            LOG_WARNING("Warden:   (sync) MODULE \"", modName,
-                                        "\" -> 0x", [&]{char s[4];snprintf(s,4,"%02x",shouldReportFound?0x4A:0x00);return std::string(s);}(),
-                                        "(", shouldReportFound ? "found" : "not found", ")");
-                            resultData.push_back(shouldReportFound ? 0x4A : 0x00);
-                            break;
-                        }
-                        // Truncated module request fallback: module NOT loaded = clean
-                        resultData.push_back(0x00);
-                        break;
-                    }
-                    case CT_PROC: {
-                        // API_CHECK request:
-                        // [4 seed][20 sha1][1 stringIdx][1 stringIdx2][4 offset] = 30 bytes
-                        int procSize = 30;
-                        if (pos + procSize > checkEnd) { pos = checkEnd; break; }
-                        pos += procSize;
-                        LOG_WARNING("Warden:   (sync) PROC check -> 0x01(not found)");
-                        resultData.push_back(0x01);
-                        break;
-                    }
-                    default: {
-                        uint8_t rawByte = decrypted[pos - 1];
-                        uint8_t decoded = rawByte ^ xorByte;
-                        LOG_WARNING("Warden: Unknown check type raw=0x",
-                                    [&]{char s[4];snprintf(s,4,"%02x",rawByte);return std::string(s);}(),
-                                    " decoded=0x",
-                                    [&]{char s[4];snprintf(s,4,"%02x",decoded);return std::string(s);}(),
-                                    " xorByte=0x",
-                                    [&]{char s[4];snprintf(s,4,"%02x",xorByte);return std::string(s);}(),
-                                    " opcodes=[",
-                                    [&]{std::string r;for(int i=0;i<9;i++){char s[6];snprintf(s,6,"0x%02x ",wardenCheckOpcodes_[i]);r+=s;}return r;}(),
-                                    "] pos=", pos, "/", checkEnd);
-                        pos = checkEnd; // stop parsing
-                        break;
-                    }
-                }
-            }
-
-            // Log synchronous round summary at WARNING level for diagnostics
-            {
-                LOG_WARNING("Warden: (sync) Parsed ", checkCount, " checks, resultSize=", resultData.size());
-                std::string fullHex;
-                for (size_t bi = 0; bi < resultData.size(); bi++) {
-                    char hx[4]; snprintf(hx, 4, "%02x ", resultData[bi]); fullHex += hx;
-                    if ((bi + 1) % 32 == 0 && bi + 1 < resultData.size()) fullHex += "\n                    ";
-                }
-                LOG_WARNING("Warden: (sync) RESPONSE_HEX [", fullHex, "]");
-            }
-
-            // --- Compute checksum: XOR of 5 uint32s from SHA1(resultData) ---
-            auto resultHash = auth::Crypto::sha1(resultData);
-            uint32_t checksum = 0;
-            for (int i = 0; i < 5; i++) {
-                uint32_t word = resultHash[i*4]
-                              | (uint32_t(resultHash[i*4+1]) << 8)
-                              | (uint32_t(resultHash[i*4+2]) << 16)
-                              | (uint32_t(resultHash[i*4+3]) << 24);
-                checksum ^= word;
-            }
-
-            // --- Build response: [0x02][uint16 length][uint32 checksum][resultData] ---
-            uint16_t resultLen = static_cast<uint16_t>(resultData.size());
-            std::vector<uint8_t> resp;
-            resp.push_back(0x02);
-            resp.push_back(resultLen & 0xFF);
-            resp.push_back((resultLen >> 8) & 0xFF);
-            resp.push_back(checksum & 0xFF);
-            resp.push_back((checksum >> 8) & 0xFF);
-            resp.push_back((checksum >> 16) & 0xFF);
-            resp.push_back((checksum >> 24) & 0xFF);
-            resp.insert(resp.end(), resultData.begin(), resultData.end());
-            sendWardenResponse(resp);
-            LOG_DEBUG("Warden: Sent CHEAT_CHECKS_RESULT (", resp.size(), " bytes, ",
-                     checkCount, " checks, checksum=0x",
-                     [&]{char s[12];snprintf(s,12,"%08x",checksum);return std::string(s);}(), ")");
-            break;
-        }
-
-        case 0x03: // WARDEN_SMSG_MODULE_INITIALIZE
-            LOG_DEBUG("Warden: MODULE_INITIALIZE (", decrypted.size(), " bytes, no response needed)");
-            break;
-
-        default:
-            LOG_DEBUG("Warden: Unknown opcode 0x", std::hex, (int)wardenOpcode, std::dec,
-                     " (state=", (int)wardenState_, ", size=", decrypted.size(), ")");
-            break;
-    }
-}
-
-} // namespace game
-} // namespace wowee
diff --git a/src/game/warden_memory.cpp b/src/game/warden_memory.cpp
index 2c0b6c67..c5a0afd2 100644
--- a/src/game/warden_memory.cpp
+++ b/src/game/warden_memory.cpp
@@ -1,6 +1,5 @@
 #include "game/warden_memory.hpp"
 #include "core/logger.hpp"
-#include <chrono>
 #include <fstream>
 #include <cstring>
 #include <cstdlib>
@@ -8,22 +7,16 @@
 #include <filesystem>
 #include <sstream>
 #include <iomanip>
-#include <openssl/hmac.h>
-#include <openssl/evp.h>
 
 namespace wowee {
 namespace game {
 
-// Bounds-checked little-endian reads for PE parsing — malformed Warden modules
-// must not cause out-of-bounds access.
 static inline uint32_t readLE32(const std::vector<uint8_t>& data, size_t offset) {
-    if (offset + 4 > data.size()) return 0;
     return data[offset] | (uint32_t(data[offset+1]) << 8)
          | (uint32_t(data[offset+2]) << 16) | (uint32_t(data[offset+3]) << 24);
 }
 
 static inline uint16_t readLE16(const std::vector<uint8_t>& data, size_t offset) {
-    if (offset + 2 > data.size()) return 0;
     return data[offset] | (uint16_t(data[offset+1]) << 8);
 }
 
@@ -99,14 +92,12 @@ bool WardenMemory::parsePE(const std::vector<uint8_t>& fileData) {
 
         if (rawDataSize == 0 || rawDataOffset == 0) continue;
 
-        // Clamp copy size to file and image bounds.
-        // Guard against underflow: if offset exceeds buffer size, skip the section
-        // entirely rather than wrapping to a huge uint32_t in the subtraction.
-        if (rawDataOffset >= fileData.size() || virtualAddr >= imageSize_) continue;
+        // Clamp copy size to file and image bounds
         uint32_t copySize = std::min(rawDataSize, virtualSize);
-        uint32_t maxFromFile  = static_cast<uint32_t>(fileData.size()) - rawDataOffset;
-        uint32_t maxFromImage = imageSize_ - virtualAddr;
-        copySize = std::min({copySize, maxFromFile, maxFromImage});
+        if (rawDataOffset + copySize > fileData.size())
+            copySize = static_cast<uint32_t>(fileData.size()) - rawDataOffset;
+        if (virtualAddr + copySize > imageSize_)
+            copySize = imageSize_ - virtualAddr;
 
         std::memcpy(image_.data() + virtualAddr, fileData.data() + rawDataOffset, copySize);
 
@@ -115,181 +106,19 @@ bool WardenMemory::parsePE(const std::vector<uint8_t>& fileData) {
                  " size=0x", copySize, std::dec);
     }
 
-    LOG_WARNING("WardenMemory: PE loaded — imageBase=0x", std::hex, imageBase_,
-                " imageSize=0x", imageSize_, std::dec,
-                " (", numSections, " sections, ", fileData.size(), " bytes on disk)");
-
     return true;
 }
 
 void WardenMemory::initKuserSharedData() {
     std::memset(kuserData_, 0, KUSER_SIZE);
 
-    // -------------------------------------------------------------------
-    // KUSER_SHARED_DATA layout — Windows 7 SP1 x86 (from ntddk.h PDB)
-    // Warden reads this in 238-byte chunks for OS fingerprinting.
-    // All offsets verified against the canonical _KUSER_SHARED_DATA struct.
-    // -------------------------------------------------------------------
+    // NtMajorVersion at offset 0x026C = 6 (Vista/7/8/10)
+    uint32_t ntMajor = 6;
+    std::memcpy(kuserData_ + 0x026C, &ntMajor, 4);
 
-    auto w32 = [&](uint32_t off, uint32_t v) { std::memcpy(kuserData_ + off, &v, 4); };
-    auto w16 = [&](uint32_t off, uint16_t v) { std::memcpy(kuserData_ + off, &v, 2); };
-    auto w8  = [&](uint32_t off, uint8_t  v) { kuserData_[off] = v; };
-
-    // +0x000 TickCountLowDeprecated (ULONG)
-    w32(0x0000, 0x003F4A00); // ~70 min uptime
-
-    // +0x004 TickCountMultiplier (ULONG)
-    w32(0x0004, 0x0FA00000);
-
-    // +0x008 InterruptTime (KSYSTEM_TIME: Low4 + High1_4 + High2_4)
-    w32(0x0008, 0x6B49D200);
-    w32(0x000C, 0x00000029);
-    w32(0x0010, 0x00000029);
-
-    // +0x014 SystemTime (KSYSTEM_TIME) — ~2024 epoch FILETIME
-    w32(0x0014, 0xA0B71B00);
-    w32(0x0018, 0x01DA5E80);
-    w32(0x001C, 0x01DA5E80);
-
-    // +0x020 TimeZoneBias (KSYSTEM_TIME) — 0 = UTC
-    // (leave zeros)
-
-    // +0x02C ImageNumberLow / ImageNumberHigh (USHORT each)
-    w16(0x002C, 0x014C); // IMAGE_FILE_MACHINE_I386
-    w16(0x002E, 0x014C);
-
-    // +0x030 NtSystemRoot (WCHAR[260] = 520 bytes, ends at +0x238)
-    const wchar_t* sysRoot = L"C:\\WINDOWS";
-    for (size_t i = 0; i < 10; i++) {
-        w16(0x0030 + static_cast<uint32_t>(i) * 2, static_cast<uint16_t>(sysRoot[i]));
-    }
-
-    // +0x238 MaxStackTraceDepth (ULONG)
-    w32(0x0238, 0);
-
-    // +0x23C CryptoExponent (ULONG) — 65537
-    w32(0x023C, 0x00010001);
-
-    // +0x240 TimeZoneId (ULONG) — TIME_ZONE_ID_UNKNOWN
-    w32(0x0240, 0);
-
-    // +0x244 LargePageMinimum (ULONG) — 2 MB
-    w32(0x0244, 0x00200000);
-
-    // +0x248 Reserved2[7] (28 bytes) — zeros
-    // (leave zeros)
-
-    // +0x264 NtProductType (NT_PRODUCT_TYPE = ULONG) — VER_NT_WORKSTATION
-    w32(0x0264, 1);
-
-    // +0x268 ProductTypeIsValid (BOOLEAN = UCHAR)
-    w8(0x0268, 1);
-
-    // +0x269 Reserved9[3] — padding
-    // (leave zeros)
-
-    // +0x26C NtMajorVersion (ULONG) — 6 (Windows Vista/7/8/10)
-    w32(0x026C, 6);
-
-    // +0x270 NtMinorVersion (ULONG) — 1 (Windows 7)
-    w32(0x0270, 1);
-
-    // +0x274 ProcessorFeatures (BOOLEAN[64] = 64 bytes, ends at +0x2B4)
-    //   Each entry is a single UCHAR (0 or 1).
-    //   Index  Name                                 Value
-    //   [0]    PF_FLOATING_POINT_PRECISION_ERRATA    0
-    //   [1]    PF_FLOATING_POINT_EMULATED            0
-    //   [2]    PF_COMPARE_EXCHANGE_DOUBLE            1
-    //   [3]    PF_MMX_INSTRUCTIONS_AVAILABLE         1
-    //   [4]    PF_PPC_MOVEMEM_64BIT_OK               0
-    //   [5]    PF_ALPHA_BYTE_INSTRUCTIONS            0
-    //   [6]    PF_XMMI_INSTRUCTIONS_AVAILABLE (SSE)  1
-    //   [7]    PF_3DNOW_INSTRUCTIONS_AVAILABLE       0
-    //   [8]    PF_RDTSC_INSTRUCTION_AVAILABLE        1
-    //   [9]    PF_PAE_ENABLED                        1
-    //   [10]   PF_XMMI64_INSTRUCTIONS_AVAILABLE(SSE2)1
-    //   [11]   PF_SSE_DAZ_MODE_AVAILABLE             0
-    //   [12]   PF_NX_ENABLED                         1
-    //   [13]   PF_SSE3_INSTRUCTIONS_AVAILABLE        1
-    //   [14]   PF_COMPARE_EXCHANGE128                0  (x86 typically 0)
-    //   [15]   PF_COMPARE64_EXCHANGE128              0
-    //   [16]   PF_CHANNELS_ENABLED                   0
-    //   [17]   PF_XSAVE_ENABLED                      0
-    w8(0x0274 +  2, 1); // PF_COMPARE_EXCHANGE_DOUBLE
-    w8(0x0274 +  3, 1); // PF_MMX
-    w8(0x0274 +  6, 1); // PF_SSE
-    w8(0x0274 +  8, 1); // PF_RDTSC
-    w8(0x0274 +  9, 1); // PF_PAE_ENABLED
-    w8(0x0274 + 10, 1); // PF_SSE2
-    w8(0x0274 + 12, 1); // PF_NX_ENABLED
-    w8(0x0274 + 13, 1); // PF_SSE3
-
-    // +0x2B4 Reserved1 (ULONG)
-    // +0x2B8 Reserved3 (ULONG)
-    // +0x2BC TimeSlip (ULONG)
-    // +0x2C0 AlternativeArchitecture (ULONG) = 0 (StandardDesign)
-    // +0x2C4 AltArchitecturePad[1] (ULONG)
-    // +0x2C8 SystemExpirationDate (LARGE_INTEGER = 8 bytes)
-    // (leave zeros)
-
-    // +0x2D0 SuiteMask (ULONG) — VER_SUITE_SINGLEUSERTS | VER_SUITE_TERMINAL
-    w32(0x02D0, 0x0110); // 0x0100=SINGLEUSERTS, 0x0010=TERMINAL
-
-    // +0x2D4 KdDebuggerEnabled (BOOLEAN = UCHAR)
-    w8(0x02D4, 0);
-
-    // +0x2D5 NXSupportPolicy (UCHAR) — 2 = OptIn
-    w8(0x02D5, 2);
-
-    // +0x2D6 Reserved6[2]
-    // (leave zeros)
-
-    // +0x2D8 ActiveConsoleId (ULONG) — session 0 or 1
-    w32(0x02D8, 1);
-
-    // +0x2DC DismountCount (ULONG)
-    w32(0x02DC, 0);
-
-    // +0x2E0 ComPlusPackage (ULONG)
-    w32(0x02E0, 0);
-
-    // +0x2E4 LastSystemRITEventTickCount (ULONG) — recent input tick
-    w32(0x02E4, 0x003F4900);
-
-    // +0x2E8 NumberOfPhysicalPages (ULONG) — 4GB / 4KB ≈ 1M pages
-    w32(0x02E8, 0x000FF000);
-
-    // +0x2EC SafeBootMode (BOOLEAN) — 0 = normal boot
-    w8(0x02EC, 0);
-
-    // +0x2F0 SharedDataFlags / TraceLogging (ULONG)
-    w32(0x02F0, 0);
-
-    // +0x2F8 TestRetInstruction (ULONGLONG = 8 bytes) — RET opcode
-    w8(0x02F8, 0xC3); // x86 RET instruction
-
-    // +0x300 SystemCall (ULONG)
-    w32(0x0300, 0);
-
-    // +0x304 SystemCallReturn (ULONG)
-    w32(0x0304, 0);
-
-    // +0x308 SystemCallPad[3] (24 bytes)
-    // (leave zeros)
-
-    // +0x320 TickCount (KSYSTEM_TIME) — matches TickCountLowDeprecated
-    w32(0x0320, 0x003F4A00);
-
-    // +0x32C TickCountPad[1]
-    // (leave zeros)
-
-    // +0x330 Cookie (ULONG) — stack cookie, random-looking value
-    w32(0x0330, 0x4A2F8C15);
-
-    // +0x334 ConsoleSessionForegroundProcessId (ULONG) — some PID
-    w32(0x0334, 0x00001234);
-
-    // Everything after +0x338 is typically zero on Win7 x86
+    // NtMinorVersion at offset 0x0270 = 1 (Windows 7)
+    uint32_t ntMinor = 1;
+    std::memcpy(kuserData_ + 0x0270, &ntMinor, 4);
 }
 
 void WardenMemory::writeLE32(uint32_t va, uint32_t value) {
@@ -303,52 +132,56 @@ void WardenMemory::writeLE32(uint32_t va, uint32_t value) {
 }
 
 void WardenMemory::patchRuntimeGlobals() {
-    if (imageBase_ != 0x00400000) {
-        LOG_WARNING("WardenMemory: unexpected imageBase=0x", std::hex, imageBase_, std::dec,
-                    " — skipping runtime global patches");
+    // Only patch Classic 1.12.1 (build 5875) WoW.exe
+    // Identified by: ImageBase=0x400000, ImageSize=0x906000 (unique to 1.12.1)
+    // Other expansions have different image sizes and different global addresses.
+    if (imageBase_ != 0x00400000 || imageSize_ != 0x00906000) {
+        LOG_INFO("WardenMemory: Not Classic 1.12.1 WoW.exe (imageSize=0x",
+                 std::hex, imageSize_, std::dec, "), skipping runtime global patches");
         return;
     }
 
     // Classic 1.12.1 (build 5875) runtime globals
-    // VMaNGOS has TWO types of Warden scans that read these addresses:
+    // These are in the .data BSS region - zero on disk, populated at runtime.
+    // We patch them with fake but valid values so Warden checks pass.
     //
-    // 1. DB-driven scans (warden_scans table): memcmp against expected bytes.
-    //    These check CODE sections for integrity — never check runtime data addresses.
-    //
-    // 2. Scripted scans (WardenWin::LoadScriptedScans): READ and INTERPRET values.
-    //    - "Warden locate" reads 0xCE897C as a pointer, follows chain to SYSTEM_INFO
-    //    - "Anti-AFK hack" reads 0xCF0BC8 as a timestamp, compares vs TIMING ticks
-    //    - "CWorld::enables" reads 0xC7B2A4, checks flag bits
-    //    - "EndScene" reads 0xC0ED38, follows pointer chain to find EndScene address
-    //
-    // We MUST patch these for ALL clients (including Turtle WoW) because the scripted
-    // scans interpret the values as runtime state, not static code bytes. Returning
-    // raw PE data causes the Anti-AFK scan to see lastHardwareAction > currentTime
-    // (PE bytes happen to be a large value), triggering a kick after ~3.5 minutes.
+    // Offsets from CMaNGOS anticheat module (wardenwin.cpp):
+    //   WardenModule      = 0xCE897C
+    //   OfsWardenSysInfo  = 0x228
+    //   OfsWardenWinSysInfo = 0x08
+    //   g_theGxDevicePtr  = 0xC0ED38
+    //   OfsDevice2        = 0x38A8
+    //   OfsDevice3        = 0x0
+    //   OfsDevice4        = 0xA8
+    //   WorldEnables      = 0xC7B2A4
+    //   LastHardwareAction= 0xCF0BC8
 
-    // === Runtime global patches (applied unconditionally for all image variants) ===
-
-    // Warden SYSTEM_INFO chain
+    // === Warden SYSTEM_INFO chain (3-level pointer chain) ===
+    // Stage 0: [0xCE897C] → fake warden struct base
     constexpr uint32_t WARDEN_MODULE_PTR = 0xCE897C;
     constexpr uint32_t FAKE_WARDEN_BASE  = 0xCE8000;
     writeLE32(WARDEN_MODULE_PTR, FAKE_WARDEN_BASE);
+
+    // Stage 1: [FAKE_WARDEN_BASE + 0x228] → pointer to sysinfo container
+    constexpr uint32_t OFS_WARDEN_SYSINFO = 0x228;
     constexpr uint32_t FAKE_SYSINFO_CONTAINER = 0xCE8300;
-    writeLE32(FAKE_WARDEN_BASE + 0x228, FAKE_SYSINFO_CONTAINER);
+    writeLE32(FAKE_WARDEN_BASE + OFS_WARDEN_SYSINFO, FAKE_SYSINFO_CONTAINER);
 
-    // Write SYSINFO pointer at many offsets from FAKE_WARDEN_BASE so the
-    // chain works regardless of which module-specific offset the server uses.
-    // MUST be done BEFORE writing the actual SYSTEM_INFO struct, because this
-    // loop's range (0xCE8200-0xCE8400) overlaps with the struct at 0xCE8308.
-    for (uint32_t off = 0x200; off <= 0x400; off += 4) {
-        uint32_t addr = FAKE_WARDEN_BASE + off;
-        if (addr >= imageBase_ && (addr - imageBase_) + 4 <= imageSize_) {
-            writeLE32(addr, FAKE_SYSINFO_CONTAINER);
-        }
-    }
-
-    // Now write the actual WIN_SYSTEM_INFO struct AFTER the pointer fill loop,
-    // so it overwrites any values the loop placed in the 0xCE8308+ range.
-    uint32_t sysInfoAddr = FAKE_SYSINFO_CONTAINER + 0x08;
+    // Stage 2: [FAKE_SYSINFO_CONTAINER + 0x08] → 36-byte SYSTEM_INFO struct
+    constexpr uint32_t OFS_WARDEN_WIN_SYSINFO = 0x08;
+    uint32_t sysInfoAddr = FAKE_SYSINFO_CONTAINER + OFS_WARDEN_WIN_SYSINFO; // 0xCE8308
+    // WIN_SYSTEM_INFO is 36 bytes (0x24):
+    //   uint16 wProcessorArchitecture (must be 0 = x86)
+    //   uint16 wReserved
+    //   uint32 dwPageSize
+    //   uint32 lpMinimumApplicationAddress
+    //   uint32 lpMaximumApplicationAddress  (MUST be non-zero!)
+    //   uint32 dwActiveProcessorMask
+    //   uint32 dwNumberOfProcessors
+    //   uint32 dwProcessorType  (must be 386, 486, or 586)
+    //   uint32 dwAllocationGranularity
+    //   uint16 wProcessorLevel
+    //   uint16 wProcessorRevision
 #pragma pack(push, 1)
     struct {
         uint16_t wProcessorArchitecture;
@@ -362,7 +195,19 @@ void WardenMemory::patchRuntimeGlobals() {
         uint32_t dwAllocationGranularity;
         uint16_t wProcessorLevel;
         uint16_t wProcessorRevision;
-    } sysInfo = {0, 0, 4096, 0x00010000, 0x7FFEFFFF, 0x0F, 4, 586, 65536, 6, 0x3A09};
+    } sysInfo = {
+        0,          // x86
+        0,
+        4096,       // 4K page size
+        0x00010000, // min app address
+        0x7FFEFFFF, // max app address (CRITICAL: must be non-zero)
+        0x0F,       // 4 processors
+        4,          // 4 CPUs
+        586,        // Pentium
+        65536,      // 64K granularity
+        6,          // P6 family
+        0x3A09      // revision
+    };
 #pragma pack(pop)
     static_assert(sizeof(sysInfo) == 36, "SYSTEM_INFO must be 36 bytes");
     uint32_t rva = sysInfoAddr - imageBase_;
@@ -370,203 +215,52 @@ void WardenMemory::patchRuntimeGlobals() {
         std::memcpy(image_.data() + rva, &sysInfo, 36);
     }
 
-    // Fallback: if the pointer chain breaks and stage 3 reads from address
-    // 0x00000000 + 0x08 = 8, write valid SYSINFO at RVA 8 (PE DOS header area).
-    if (8 + 36 <= imageSize_) {
-        std::memcpy(image_.data() + 8, &sysInfo, 36);
-    }
+    LOG_INFO("WardenMemory: Patched SYSTEM_INFO chain: [0x", std::hex,
+             WARDEN_MODULE_PTR, "]→0x", FAKE_WARDEN_BASE,
+             " [0x", FAKE_WARDEN_BASE + OFS_WARDEN_SYSINFO, "]→0x", FAKE_SYSINFO_CONTAINER,
+             " SYSTEM_INFO@0x", sysInfoAddr, std::dec);
 
-    LOG_WARNING("WardenMemory: Patched SYSINFO chain @0x", std::hex, WARDEN_MODULE_PTR, std::dec);
-
-    // EndScene chain
-    // VMaNGOS reads g_theGxDevicePtr → device, then device+0x1FC for API kind
-    // (0=OpenGL, 1=Direct3D). If Direct3D, follows device+0x38A8 → ptr → ptr+0xA8 → EndScene.
-    // We set API=1 (Direct3D) and provide the full pointer chain.
+    // === EndScene chain (4-level pointer chain) ===
+    // Stage 1: [0xC0ED38] → fake D3D device
     constexpr uint32_t GX_DEVICE_PTR = 0xC0ED38;
     constexpr uint32_t FAKE_DEVICE   = 0xCE8400;
     writeLE32(GX_DEVICE_PTR, FAKE_DEVICE);
-    writeLE32(FAKE_DEVICE + 0x1FC, 1);                 // API kind = Direct3D
-    // Set up the full EndScene pointer chain at the canonical offsets.
-    constexpr uint32_t FAKE_VTABLE1 = 0xCE8500;
-    constexpr uint32_t FAKE_VTABLE2 = 0xCE8600;
-    constexpr uint32_t FAKE_ENDSCENE = 0x00401000; // start of .text
-    writeLE32(FAKE_DEVICE + 0x38A8, FAKE_VTABLE1);
-    writeLE32(FAKE_VTABLE1, FAKE_VTABLE2);
-    writeLE32(FAKE_VTABLE2 + 0xA8, FAKE_ENDSCENE);
 
-    // The EndScene device+sOfsDevice2 offset may differ from 0x38A8 in Turtle WoW.
-    // Also set API=1 (Direct3D) at multiple offsets so the API kind check passes.
-    // Fill the entire fake device area with the vtable pointer for robustness.
-    for (uint32_t off = 0x3800; off <= 0x3A00; off += 4) {
-        uint32_t addr = FAKE_DEVICE + off;
-        if (addr >= imageBase_ && (addr - imageBase_) + 4 <= imageSize_) {
-            writeLE32(addr, FAKE_VTABLE1);
-        }
-    }
-    LOG_WARNING("WardenMemory: Patched EndScene chain @0x", std::hex, GX_DEVICE_PTR, std::dec);
+    // Stage 2: [FAKE_DEVICE + 0x38A8] → fake intermediate
+    constexpr uint32_t OFS_DEVICE2 = 0x38A8;
+    constexpr uint32_t FAKE_INTERMEDIATE = 0xCE8500;
+    writeLE32(FAKE_DEVICE + OFS_DEVICE2, FAKE_INTERMEDIATE);
 
-    // WorldEnables
+    // Stage 3: [FAKE_INTERMEDIATE + 0x0] → fake vtable
+    constexpr uint32_t OFS_DEVICE3 = 0x0;
+    constexpr uint32_t FAKE_VTABLE = 0xCE8600;
+    writeLE32(FAKE_INTERMEDIATE + OFS_DEVICE3, FAKE_VTABLE);
+
+    // Stage 4: [FAKE_VTABLE + 0xA8] → address of "EndScene" function
+    // Point to a real .text address with normal code (not 0xE9/0xCC = not hooked)
+    constexpr uint32_t OFS_DEVICE4 = 0xA8;
+    constexpr uint32_t FAKE_ENDSCENE = 0x00401000; // Start of .text section
+    writeLE32(FAKE_VTABLE + OFS_DEVICE4, FAKE_ENDSCENE);
+
+    LOG_INFO("WardenMemory: Patched EndScene chain: [0x", std::hex,
+             GX_DEVICE_PTR, "]→0x", FAKE_DEVICE,
+             " ... →EndScene@0x", FAKE_ENDSCENE, std::dec);
+
+    // === WorldEnables (single value) ===
+    // Required flags: TerrainDoodads|Terrain|MapObjects|MapObjectLighting|MapObjectTextures|Water
+    // Plus typical defaults (no Prohibited bits set)
     constexpr uint32_t WORLD_ENABLES = 0xC7B2A4;
     uint32_t enables = 0x1 | 0x2 | 0x10 | 0x20 | 0x40 | 0x100 | 0x200 | 0x400 | 0x800
                      | 0x8000 | 0x10000 | 0x100000 | 0x1000000 | 0x2000000
                      | 0x4000000 | 0x8000000 | 0x10000000;
     writeLE32(WORLD_ENABLES, enables);
-    LOG_WARNING("WardenMemory: Patched WorldEnables @0x", std::hex, WORLD_ENABLES, std::dec);
+    LOG_INFO("WardenMemory: Patched WorldEnables=0x", std::hex, enables, std::dec);
 
-    // LastHardwareAction — must be a recent GetTickCount()-style timestamp
-    // so the anti-AFK scan sees (currentTime - lastAction) < threshold.
+    // === LastHardwareAction (tick count) ===
+    // Must be <= currentTime from timing check. Set to a plausible value.
     constexpr uint32_t LAST_HARDWARE_ACTION = 0xCF0BC8;
-    uint32_t nowMs = static_cast<uint32_t>(
-        std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now().time_since_epoch()).count());
-    writeLE32(LAST_HARDWARE_ACTION, nowMs - 2000);
-    LOG_WARNING("WardenMemory: Patched LastHardwareAction @0x", std::hex, LAST_HARDWARE_ACTION, std::dec);
-
-    // Embed the 37-byte Warden module memcpy pattern in BSS so that
-    // FIND_CODE_BY_HASH (PAGE_B) brute-force search can find it.
-    // This is the pattern VMaNGOS's "Warden Memory Read check" looks for.
-    constexpr uint32_t MEMCPY_PATTERN_VA = 0xCE8700;
-    static const uint8_t kWardenMemcpyPattern[37] = {
-        0x56, 0x57, 0xFC, 0x8B, 0x54, 0x24, 0x14, 0x8B,
-        0x74, 0x24, 0x10, 0x8B, 0x44, 0x24, 0x0C, 0x8B,
-        0xCA, 0x8B, 0xF8, 0xC1, 0xE9, 0x02, 0x74, 0x02,
-        0xF3, 0xA5, 0xB1, 0x03, 0x23, 0xCA, 0x74, 0x02,
-        0xF3, 0xA4, 0x5F, 0x5E, 0xC3
-    };
-    uint32_t patRva = MEMCPY_PATTERN_VA - imageBase_;
-    if (patRva + sizeof(kWardenMemcpyPattern) <= imageSize_) {
-        std::memcpy(image_.data() + patRva, kWardenMemcpyPattern, sizeof(kWardenMemcpyPattern));
-        LOG_WARNING("WardenMemory: Embedded Warden memcpy pattern at 0x", std::hex, MEMCPY_PATTERN_VA, std::dec);
-    }
-}
-
-void WardenMemory::patchTurtleWowBinary() {
-    // Apply TurtlePatcher byte patches to make our PE image match a real Turtle WoW client.
-    // These patches are applied at file offsets which equal RVAs for this PE.
-    // Source: TurtlePatcher/Main.cpp PatchBinary() + PatchVersion()
-
-    auto patchBytes = [&](uint32_t fileOffset, const std::vector<uint8_t>& bytes) {
-        if (fileOffset + bytes.size() > imageSize_) {
-            LOG_WARNING("WardenMemory: Turtle patch at 0x", std::hex, fileOffset,
-                        " exceeds image size, skipping");
-            return;
-        }
-        std::memcpy(image_.data() + fileOffset, bytes.data(), bytes.size());
-    };
-
-    auto patchString = [&](uint32_t fileOffset, const char* str) {
-        size_t len = std::strlen(str) + 1; // include null terminator
-        if (fileOffset + len > imageSize_) return;
-        std::memcpy(image_.data() + fileOffset, str, len);
-    };
-
-    // --- PatchBinary() patches ---
-
-    // Patches 1-4: Unknown purpose code patches in .text
-    patchBytes(0x2F113A, {0xEB, 0x19});
-    patchBytes(0x2F1158, {0x03});
-    patchBytes(0x2F11A7, {0x03});
-    patchBytes(0x2F11F0, {0xEB, 0xB2});
-
-    // PvP rank check removal (6x NOP)
-    patchBytes(0x2093B0, {0x90, 0x90, 0x90, 0x90, 0x90, 0x90});
-
-    // Dwarf mage hackfix removal
-    patchBytes(0x0706E5, {0xFE});
-    patchBytes(0x0706EB, {0xFE});
-    patchBytes(0x07075D, {0xFE});
-    patchBytes(0x070763, {0xFE});
-
-    // Emote sound race ID checks (High Elf support)
-    patchBytes(0x059289, {0x40});
-    patchBytes(0x057C81, {0x40});
-
-    // Nameplate distance (41 yards)
-    patchBytes(0x40C448, {0x00, 0x00, 0x24, 0x42});
-
-    // Large address aware flag in PE header
-    patchBytes(0x000126, {0x2F, 0x01});
-
-    // Sound channel patches
-    patchBytes(0x05728C, {0x38, 0x5D, 0x83, 0x00}); // software channels
-    patchBytes(0x057250, {0x38, 0x5D, 0x83, 0x00}); // hardware channels
-    patchBytes(0x0572C8, {0x6C, 0x5C, 0x83, 0x00}); // memory cache
-
-    // Sound in background (non-FoV build)
-    patchBytes(0x3A4869, {0x14});
-
-    // Hardcore chat patches
-    patchBytes(0x09B0B8, {0x5F});
-    patchBytes(0x09B193, {0xE9, 0xA8, 0xAE, 0x86});
-    patchBytes(0x09F7A5, {0x70, 0x53, 0x56, 0x33, 0xF6, 0xE9, 0x71, 0x68, 0x86, 0x00});
-    patchBytes(0x09F864, {0x94});
-    patchBytes(0x09F878, {0x0E});
-    patchBytes(0x09F887, {0x90});
-    patchBytes(0x11BAE1, {0x0C, 0x60, 0xD0});
-
-    // Hardcore chat code cave at 0x48E000 (85 bytes)
-    patchBytes(0x48E000, {
-        0x48, 0x41, 0x52, 0x44, 0x43, 0x4F, 0x52, 0x45, 0x00, 0x00, 0x00, 0x00, 0x43, 0x48, 0x41, 0x54,
-        0x5F, 0x4D, 0x53, 0x47, 0x5F, 0x48, 0x41, 0x52, 0x44, 0x43, 0x4F, 0x52, 0x45, 0x00, 0x00, 0x00,
-        0x57, 0x8B, 0xDA, 0x8B, 0xF9, 0xC7, 0x45, 0x94, 0x00, 0x60, 0xD0, 0x00, 0xC7, 0x45, 0x90, 0x5E,
-        0x00, 0x00, 0x00, 0xE9, 0x77, 0x97, 0x79, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x68, 0x08, 0x46, 0x84, 0x00, 0x83, 0x7D, 0xF0, 0x5E, 0x75, 0x05, 0xB9, 0x1F, 0x02, 0x00, 0x00,
-        0xE9, 0x43, 0x51, 0x79, 0xFF
-    });
-
-    // Blue child moon patch
-    patchBytes(0x3E5B83, {
-        0xC7, 0x05, 0xA4, 0x98, 0xCE, 0x00, 0xD4, 0xE2, 0xE7, 0xFF, 0xC2, 0x04, 0x00
-    });
-
-    // Blue child moon timer
-    patchBytes(0x2D2095, {0x00, 0x00, 0x80, 0x3F});
-
-    // SetUnit codecave jump
-    patchBytes(0x105E19, {0xE9, 0x02, 0x03, 0x80, 0x00});
-
-    // SetUnit main code cave at 0x48E060 (291 bytes)
-    patchBytes(0x48E060, {
-        0x55, 0x89, 0xE5, 0x83, 0xEC, 0x10, 0x85, 0xD2, 0x53, 0x56, 0x57, 0x89, 0xCF, 0x0F, 0x84, 0xA2,
-        0x00, 0x00, 0x00, 0x89, 0xD0, 0x85, 0xC0, 0x0F, 0x8C, 0x98, 0x00, 0x00, 0x00, 0x3B, 0x05, 0x94,
-        0xDE, 0xC0, 0x00, 0x0F, 0x8F, 0x8C, 0x00, 0x00, 0x00, 0x8B, 0x0D, 0x90, 0xDE, 0xC0, 0x00, 0x8B,
-        0x04, 0x81, 0x85, 0xC0, 0x89, 0x45, 0xF0, 0x74, 0x7C, 0x8B, 0x40, 0x04, 0x85, 0xC0, 0x7C, 0x75,
-        0x3B, 0x05, 0x6C, 0xDE, 0xC0, 0x00, 0x7F, 0x6D, 0x8B, 0x15, 0x68, 0xDE, 0xC0, 0x00, 0x8B, 0x1C,
-        0x82, 0x85, 0xDB, 0x74, 0x60, 0x8B, 0x43, 0x08, 0x6A, 0x00, 0x50, 0x89, 0xF9, 0xE8, 0xFE, 0x6E,
-        0xA6, 0xFF, 0x89, 0xC1, 0xE8, 0x87, 0x12, 0xA0, 0xFF, 0x89, 0xC6, 0x85, 0xF6, 0x74, 0x46, 0x8B,
-        0x55, 0xF0, 0x53, 0x89, 0xF1, 0xE8, 0xD6, 0x36, 0x77, 0xFF, 0x8B, 0x17, 0x56, 0x89, 0xF9, 0xFF,
-        0x92, 0x90, 0x00, 0x00, 0x00, 0x89, 0xF8, 0x99, 0x52, 0x50, 0x68, 0xA0, 0x62, 0x50, 0x00, 0x89,
-        0xF1, 0xE8, 0xBA, 0xBA, 0xA0, 0xFF, 0x6A, 0x01, 0x6A, 0x01, 0x68, 0x00, 0x00, 0x80, 0x3F, 0x6A,
-        0x00, 0x6A, 0xFF, 0x6A, 0x00, 0x6A, 0xFF, 0x89, 0xF1, 0xE8, 0x92, 0xC0, 0xA0, 0xFF, 0x89, 0xF1,
-        0xE8, 0x8B, 0xA2, 0xA0, 0xFF, 0x5F, 0x5E, 0x5B, 0x89, 0xEC, 0x5D, 0xC3, 0x90, 0x90, 0x90, 0x90,
-        0xBA, 0x02, 0x00, 0x00, 0x00, 0x89, 0xF1, 0xE8, 0xD4, 0xD2, 0x9E, 0xFF, 0x83, 0xF8, 0x03, 0x75,
-        0x43, 0xBA, 0x02, 0x00, 0x00, 0x00, 0x89, 0xF1, 0xE8, 0xE3, 0xD4, 0x9E, 0xFF, 0xE8, 0x6E, 0x41,
-        0x70, 0xFF, 0x56, 0x8B, 0xB7, 0xD4, 0x00, 0x00, 0x00, 0x31, 0xD2, 0x39, 0xD6, 0x89, 0x97, 0xE0,
-        0x03, 0x00, 0x00, 0x89, 0x97, 0xE4, 0x03, 0x00, 0x00, 0x89, 0x97, 0xF0, 0x03, 0x00, 0x00, 0x5E,
-        0x0F, 0x84, 0xD3, 0xFC, 0x7F, 0xFF, 0x89, 0xC2, 0x89, 0xF9, 0xE8, 0xF1, 0xFE, 0xFF, 0xFF, 0xE9,
-        0xC5, 0xFC, 0x7F, 0xFF, 0xBA, 0x02, 0x00, 0x00, 0x00, 0xE9, 0xA0, 0xFC, 0x7F, 0xFF, 0x90, 0x90,
-        0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
-    });
-
-    // --- PatchVersion() patches ---
-
-    // Net version: build 7199 (0x1C1F LE)
-    patchBytes(0x1B2122, {0x1F, 0x1C});
-
-    // Visual version string
-    patchString(0x437C04, "1.17.2");
-
-    // Visual build string
-    patchString(0x437BFC, "7199");
-
-    // Build date string
-    patchString(0x434798, "May 20 2024");
-
-    // Website filters
-    patchString(0x45CCD8, "*.turtle-wow.org");
-    patchString(0x45CC9C, "*.discord.gg");
-
-    LOG_WARNING("WardenMemory: Applied TurtlePatcher binary patches (build 7199)");
+    writeLE32(LAST_HARDWARE_ACTION, 60000); // 1 minute
+    LOG_INFO("WardenMemory: Patched LastHardwareAction=60000ms");
 }
 
 bool WardenMemory::readMemory(uint32_t va, uint8_t length, uint8_t* outBuf) const {
@@ -578,40 +272,18 @@ bool WardenMemory::readMemory(uint32_t va, uint8_t length, uint8_t* outBuf) cons
         return true;
     }
 
-    if (!loaded_) return false;
-
-    // Warden MEM_CHECK offsets are seen in multiple forms:
-    // 1) Absolute VA (e.g. 0x00401337)
-    // 2) RVA (e.g. 0x000139A9)
-    // 3) Tiny module-relative offsets (e.g. 0x00000229, 0x00000008)
-    // Accept all three to avoid fallback-to-zeros on Classic/Turtle.
-    uint32_t offset = 0;
-    if (va >= imageBase_) {
-        // Absolute VA.
-        offset = va - imageBase_;
-    } else if (va < imageSize_) {
-        // RVA into WoW.exe image.
-        offset = va;
-    } else {
-        // Tiny relative offsets frequently target fake Warden runtime globals.
-        constexpr uint32_t kFakeWardenBase = 0xCE8000;
-        const uint32_t remappedVa = kFakeWardenBase + va;
-        if (remappedVa < imageBase_) return false;
-        offset = remappedVa - imageBase_;
-    }
-
+    // PE image range
+    if (!loaded_ || va < imageBase_) return false;
+    uint32_t offset = va - imageBase_;
     if (static_cast<uint64_t>(offset) + length > imageSize_) return false;
 
     std::memcpy(outBuf, image_.data() + offset, length);
     return true;
 }
 
-uint32_t WardenMemory::expectedImageSizeForBuild(uint16_t build, bool isTurtle) {
+uint32_t WardenMemory::expectedImageSizeForBuild(uint16_t build) {
     switch (build) {
-        case 5875:
-            // Turtle WoW uses a custom WoW.exe with different code bytes.
-            // Their warden_scans DB expects bytes from this custom exe.
-            return isTurtle ? 0x00906000 : 0x009FD000;
+        case 5875: return 0x00906000; // Classic 1.12.1
         default:   return 0;          // Unknown — accept any
     }
 }
@@ -629,7 +301,6 @@ std::string WardenMemory::findWowExe(uint16_t build) const {
         }
     }
     candidateDirs.push_back("Data/misc");
-    candidateDirs.push_back("Data/expansions/turtle/overlay/misc");
 
     const char* candidateExes[] = { "WoW.exe", "TurtleWoW.exe", "Wow.exe" };
 
@@ -647,7 +318,7 @@ std::string WardenMemory::findWowExe(uint16_t build) const {
     }
 
     // If we know the expected imageSize for this build, try to find a matching PE
-    uint32_t expectedSize = expectedImageSizeForBuild(build, isTurtle_);
+    uint32_t expectedSize = expectedImageSizeForBuild(build);
     if (expectedSize != 0 && allPaths.size() > 1) {
         for (const auto& path : allPaths) {
             std::ifstream f(path, std::ios::binary);
@@ -671,29 +342,17 @@ std::string WardenMemory::findWowExe(uint16_t build) const {
         }
     }
 
-    // Fallback: prefer the largest PE file (modified clients like Turtle WoW are
-    // larger than vanilla, and Warden checks target the actual running client).
-    std::string bestPath;
-    uintmax_t bestSize = 0;
-    for (const auto& path : allPaths) {
-        std::error_code ec;
-        auto sz = std::filesystem::file_size(path, ec);
-        if (!ec && sz > bestSize) {
-            bestSize = sz;
-            bestPath = path;
-        }
-    }
-    return bestPath.empty() && !allPaths.empty() ? allPaths[0] : bestPath;
+    // Fallback: return first available
+    return allPaths.empty() ? "" : allPaths[0];
 }
 
-bool WardenMemory::load(uint16_t build, bool isTurtle) {
-    isTurtle_ = isTurtle;
+bool WardenMemory::load(uint16_t build) {
     std::string path = findWowExe(build);
     if (path.empty()) {
         LOG_WARNING("WardenMemory: WoW.exe not found in any candidate directory");
         return false;
     }
-    LOG_WARNING("WardenMemory: Loading PE image: ", path, " (build=", build, ")");
+    LOG_INFO("WardenMemory: Found ", path);
     return loadFromFile(path);
 }
 
@@ -718,274 +377,11 @@ bool WardenMemory::loadFromFile(const std::string& exePath) {
 
     initKuserSharedData();
     patchRuntimeGlobals();
-    if (isTurtle_ && imageSize_ != 0x00906000) {
-        // Only apply TurtlePatcher patches if we loaded the vanilla exe.
-        // The real Turtle WoW.exe (imageSize=0x906000) already has these bytes.
-        patchTurtleWowBinary();
-        LOG_WARNING("WardenMemory: Applied Turtle patches to vanilla PE (imageSize=0x", std::hex, imageSize_, std::dec, ")");
-    } else if (isTurtle_) {
-        LOG_WARNING("WardenMemory: Loaded native Turtle PE — skipping patches");
-    }
     loaded_ = true;
     LOG_INFO("WardenMemory: Loaded PE image (", fileData.size(), " bytes on disk, ",
              imageSize_, " bytes virtual)");
-
-    // Verify all known warden_scans MEM_CHECK entries against our PE image.
-    // This checks the exact bytes the server will memcmp against.
-    verifyWardenScanEntries();
-
     return true;
 }
 
-void WardenMemory::verifyWardenScanEntries() {
-    struct ScanEntry { int id; uint32_t address; uint8_t length; const char* expectedHex; const char* comment; };
-    static const ScanEntry entries[] = {
-        { 1, 8679268, 6, "686561646572", "Packet internal sign - header"},
-        { 3, 8530960, 6, "53595354454D", "Packet internal sign - SYSTEM"},
-        { 8, 8151666, 4, "D893FEC0", "Jump gravity"},
-        { 9, 8151646, 2, "3075", "Jump gravity water"},
-        {10, 6382555, 2, "8A47", "Anti root"},
-        {11, 6380789, 1, "F8", "Anti move"},
-        {12, 8151647, 1, "75", "Anti jump"},
-        {13, 8152026, 4, "8B4F7889", "No fall damage"},
-        {14, 6504892, 2, "7425", "Super fly"},
-        {15, 6383433, 2, "780F", "Heartbeat interval speedhack"},
-        {16, 6284623, 1, "F4", "Anti slow hack"},
-        {17, 6504931, 2, "85D2", "No fall damage"},
-        {18, 8151565, 2, "2000", "Fly hack"},
-        {19, 7153475, 6, "890D509CCE00", "General hacks"},
-        {20, 7138894, 6, "A3D89BCE00EB", "Wall climb"},
-        {21, 7138907, 6, "890DD89BCE00", "Wall climb"},
-        {22, 6993044, 1, "74", "Zero gravity"},
-        {23, 6502300, 1, "FC", "Air walk"},
-        {24, 6340512, 2, "7F7D", "Wall climb"},
-        {25, 6380455, 4, "F4010000", "Wall climb"},
-        {26, 8151657, 4, "488C11C1", "Wall climb"},
-        {27, 6992319, 3, "894704", "Wall climb"},
-        {28, 6340529, 2, "746C", "No water hack"},
-        {29, 6356016, 10, "C70588D8C4000C000000", "No water hack"},
-        {30, 4730584, 6, "0F8CE1000000", "WMO collision"},
-        {31, 4803152, 7, "A1C0EACE0085C0", "noclip hack"},
-        {32, 5946704, 6, "8BD18B0D80E0", "M2 collision"},
-        {33, 6340543, 2, "7546", "M2 collision"},
-        {34, 5341282, 1, "7F", "Warden disable"},
-        {35, 4989376, 1, "72", "No fog hack"},
-        {36, 8145237, 1, "8B", "No fog hack"},
-        {37, 6392083, 8, "8B450850E824DA1A", "No fog hack"},
-        {38, 8146241, 10, "D9818C0000008BE55DC2", "tp2plane hack"},
-        {39, 6995731, 1, "74", "Air swim hack"},
-        {40, 6964859, 1, "75", "Infinite jump hack"},
-        {41, 6382558, 10, "84C074178B86A4000000", "Gravity water hack"},
-        {42, 8151997, 3, "895108", "Gravity hack"},
-        {43, 8152025, 1, "34", "Plane teleport"},
-        {44, 6516436, 1, "FC", "Zero fall time"},
-        {45, 6501616, 1, "FC", "No fall damage"},
-        {46, 6511674, 1, "FC", "Fall time hack"},
-        {47, 6513048, 1, "FC", "Death bug hack"},
-        {48, 6514072, 1, "FC", "Anti slow hack"},
-        {49, 8152029, 3, "894E38", "Anti slow hack"},
-        {50, 4847346, 3, "8B45D4", "Max camera distance hack"},
-        {51, 4847069, 1, "74", "Wall climb"},
-        {52, 8155231, 3, "000000", "Signature check"},
-        {53, 6356849, 1, "74", "Signature check"},
-        {54, 6354889, 6, "0F8A71FFFFFF", "Signature check"},
-        {55, 4657642, 1, "74", "Max interact distance hack"},
-        {56, 6211360, 8, "558BEC83EC0C8B45", "Hover speed hack"},
-        {57, 8153504, 3, "558BEC", "Flight speed hack"},
-        {58, 6214285, 6, "8B82500E0000", "Track all units hack"},
-        {59, 8151558, 11, "25FFFFDFFB0D0020000089", "No fall damage"},
-        {60, 8155228, 6, "89868C000000", "Run speed hack"},
-        {61, 6356837, 2, "7474", "Follow anything hack"},
-        {62, 6751806, 1, "74", "No water hack"},
-        {63, 4657632, 2, "740A", "Any name hack"},
-        {64, 8151976, 4, "84E5FFFF", "Plane teleport"},
-        {65, 6214371, 6, "8BB1540E0000", "Object tracking hack"},
-        {66, 6818689, 5, "A388F2C700", "No water hack"},
-        {67, 6186028, 5, "C705ACD2C4", "No fog hack"},
-        {68, 5473808, 4, "30855300", "Warden disable hack"},
-        {69, 4208171, 3, "6B2C00", "Warden disable hack"},
-        {70, 7119285, 1, "74", "Warden disable hack"},
-        {71, 4729827, 1, "5E", "Daylight hack"},
-        {72, 6354512, 6, "0F84EA000000", "Ranged attack stop hack"},
-        {73, 5053463, 2, "7415", "Officer note hack"},
-        {79, 8139737, 5, "D84E14DEC1", "UNKNOWN movement hack"},
-        {80, 8902804, 4, "8E977042", "Wall climb hack"},
-        {81, 8902808, 4, "0000E040", "Run speed hack"},
-        {82, 8154755, 7, "8166403FFFDFFF", "Moveflag hack"},
-        {83, 8445948, 4, "BB8D243F", "Wall climb hack"},
-        {84, 6493717, 2, "741D", "Speed hack"},
-    };
-
-    auto hexToByte = [](char hi, char lo) -> uint8_t {
-        auto nibble = [](char c) -> uint8_t {
-            if (c >= '0' && c <= '9') return c - '0';
-            if (c >= 'A' && c <= 'F') return 10 + c - 'A';
-            if (c >= 'a' && c <= 'f') return 10 + c - 'a';
-            return 0;
-        };
-        return (nibble(hi) << 4) | nibble(lo);
-    };
-
-    int mismatches = 0;
-    int patched = 0;
-    for (const auto& e : entries) {
-        std::string hexStr(e.expectedHex);
-        std::vector<uint8_t> expected;
-        for (size_t i = 0; i + 1 < hexStr.size(); i += 2)
-            expected.push_back(hexToByte(hexStr[i], hexStr[i+1]));
-
-        std::vector<uint8_t> actual(e.length, 0);
-        bool ok = readMemory(e.address, e.length, actual.data());
-
-        if (!ok || actual != expected) {
-            mismatches++;
-
-            // In Turtle mode, write the expected bytes into the PE image so
-            // MEM_CHECK responses return what the server expects.
-            if (isTurtle_ && e.address >= imageBase_) {
-                uint32_t offset = e.address - imageBase_;
-                if (offset + expected.size() <= imageSize_) {
-                    std::memcpy(image_.data() + offset, expected.data(), expected.size());
-                    patched++;
-                }
-            }
-        }
-    }
-
-    if (mismatches == 0) {
-        LOG_WARNING("WardenScan: All ", sizeof(entries)/sizeof(entries[0]),
-                    " DB scan entries MATCH PE image");
-    } else if (patched > 0) {
-        LOG_WARNING("WardenScan: Patched ", patched, "/", mismatches,
-                    " mismatched scan entries into PE image");
-    } else {
-        LOG_WARNING("WardenScan: ", mismatches, " / ", sizeof(entries)/sizeof(entries[0]),
-                    " DB scan entries MISMATCH");
-    }
-}
-
-bool WardenMemory::searchCodePattern(const uint8_t seed[4], const uint8_t expectedHash[20],
-                                     uint8_t patternLen, bool imageOnly,
-                                     uint32_t hintOffset, bool hintOnly) const {
-    if (!loaded_ || patternLen == 0) return false;
-
-    // Build cache key from all inputs: seed(4) + hash(20) + patLen(1) + imageOnly(1)
-    std::string cacheKey(26, '\0');
-    std::memcpy(&cacheKey[0], seed, 4);
-    std::memcpy(&cacheKey[4], expectedHash, 20);
-    cacheKey[24] = patternLen;
-    cacheKey[25] = imageOnly ? 1 : 0;
-
-    auto cacheIt = codePatternCache_.find(cacheKey);
-    if (cacheIt != codePatternCache_.end()) {
-        return cacheIt->second;
-    }
-
-    // --- Fast path: check the hint offset directly (single HMAC) ---
-    // The PAGE_A offset field is the RVA where the server expects the pattern.
-    if (hintOffset > 0 && hintOffset + patternLen <= imageSize_) {
-        uint8_t hmacOut[20];
-        unsigned int hmacLen = 0;
-        HMAC(EVP_sha1(), seed, 4,
-             image_.data() + hintOffset, patternLen,
-             hmacOut, &hmacLen);
-        if (hmacLen == 20 && std::memcmp(hmacOut, expectedHash, 20) == 0) {
-            LOG_WARNING("WardenMemory: Code pattern found at hint RVA 0x", std::hex,
-                        hintOffset, std::dec, " (direct hit)");
-            codePatternCache_[cacheKey] = true;
-            return true;
-        }
-    }
-
-    // --- Wider hint window: search ±4096 bytes around hint offset ---
-    if (hintOffset > 0) {
-        size_t winStart = (hintOffset > 4096) ? hintOffset - 4096 : 0;
-        size_t winEnd = std::min(static_cast<size_t>(hintOffset) + 4096 + patternLen,
-                                 static_cast<size_t>(imageSize_));
-        if (winEnd > winStart + patternLen) {
-            for (size_t i = winStart; i + patternLen <= winEnd; i++) {
-                if (i == hintOffset) continue; // already checked
-                uint8_t hmacOut[20];
-                unsigned int hmacLen = 0;
-                HMAC(EVP_sha1(), seed, 4,
-                     image_.data() + i, patternLen,
-                     hmacOut, &hmacLen);
-                if (hmacLen == 20 && std::memcmp(hmacOut, expectedHash, 20) == 0) {
-                    LOG_WARNING("WardenMemory: Code pattern found at RVA 0x", std::hex, i,
-                                std::dec, " (hint window, delta=", static_cast<int>(i) - static_cast<int>(hintOffset), ")");
-                    codePatternCache_[cacheKey] = true;
-                    return true;
-                }
-            }
-        }
-    }
-
-    // If hint-only mode, skip the expensive brute-force search.
-    if (hintOnly) return false;
-
-    // --- Brute-force fallback: search all PE sections ---
-    struct Range { size_t start; size_t end; };
-    std::vector<Range> ranges;
-
-    if (imageOnly && image_.size() >= 64) {
-        uint32_t peOffset = image_[0x3C] | (uint32_t(image_[0x3D]) << 8)
-                          | (uint32_t(image_[0x3E]) << 16) | (uint32_t(image_[0x3F]) << 24);
-        if (peOffset + 4 + 20 <= image_.size()) {
-            uint16_t numSections = image_[peOffset+4+2] | (uint16_t(image_[peOffset+4+3]) << 8);
-            uint16_t optHeaderSize = image_[peOffset+4+16] | (uint16_t(image_[peOffset+4+17]) << 8);
-            size_t secTable = peOffset + 4 + 20 + optHeaderSize;
-            for (uint16_t i = 0; i < numSections; i++) {
-                size_t secOfs = secTable + i * 40;
-                if (secOfs + 40 > image_.size()) break;
-                uint32_t va = image_[secOfs+12] | (uint32_t(image_[secOfs+13]) << 8)
-                            | (uint32_t(image_[secOfs+14]) << 16) | (uint32_t(image_[secOfs+15]) << 24);
-                uint32_t vsize = image_[secOfs+8] | (uint32_t(image_[secOfs+9]) << 8)
-                               | (uint32_t(image_[secOfs+10]) << 16) | (uint32_t(image_[secOfs+11]) << 24);
-                size_t rEnd = std::min(static_cast<size_t>(va + vsize), static_cast<size_t>(imageSize_));
-                if (va + patternLen <= rEnd)
-                    ranges.push_back({va, rEnd});
-            }
-        }
-    }
-
-    if (ranges.empty()) {
-        if (patternLen <= imageSize_)
-            ranges.push_back({0, imageSize_});
-    }
-
-    auto bruteStart = std::chrono::steady_clock::now();
-    LOG_WARNING("WardenMemory: Brute-force searching ", ranges.size(), " section(s), hint=0x",
-                std::hex, hintOffset, std::dec, " patLen=", static_cast<int>(patternLen));
-
-    size_t totalPositions = 0;
-    for (const auto& r : ranges) {
-        size_t positions = r.end - r.start - patternLen + 1;
-        for (size_t i = 0; i < positions; i++) {
-            uint8_t hmacOut[20];
-            unsigned int hmacLen = 0;
-            HMAC(EVP_sha1(), seed, 4,
-                 image_.data() + r.start + i, patternLen,
-                 hmacOut, &hmacLen);
-            if (hmacLen == 20 && std::memcmp(hmacOut, expectedHash, 20) == 0) {
-                auto elapsed = std::chrono::duration<float>(
-                    std::chrono::steady_clock::now() - bruteStart).count();
-                LOG_WARNING("WardenMemory: Code pattern found at RVA 0x", std::hex,
-                            r.start + i, std::dec, " (searched ", totalPositions + i + 1,
-                            " positions in ", elapsed, "s)");
-                codePatternCache_[cacheKey] = true;
-                return true;
-            }
-        }
-        totalPositions += positions;
-    }
-
-    auto elapsed = std::chrono::duration<float>(
-        std::chrono::steady_clock::now() - bruteStart).count();
-    LOG_WARNING("WardenMemory: Code pattern NOT found after ", totalPositions, " positions in ",
-                ranges.size(), " section(s), took ", elapsed, "s");
-    codePatternCache_[cacheKey] = false;
-    return false;
-}
-
 } // namespace game
 } // namespace wowee
diff --git a/src/game/warden_module.cpp b/src/game/warden_module.cpp
index f3ea6723..1c253459 100644
--- a/src/game/warden_module.cpp
+++ b/src/game/warden_module.cpp
@@ -1,10 +1,9 @@
 #include "game/warden_module.hpp"
-#include "game/warden_crypto.hpp"
 #include "auth/crypto.hpp"
-#include "core/logger.hpp"
 #include <cstring>
 #include <fstream>
 #include <filesystem>
+#include <iostream>
 #include <zlib.h>
 #include <openssl/rsa.h>
 #include <openssl/bn.h>
@@ -31,26 +30,14 @@ namespace wowee {
 namespace game {
 
 // ============================================================================
-// Thread-local pointer to the active WardenModule instance during initializeModule().
-// C function pointer callbacks (sendPacket, validateModule, generateRC4) can't capture
-// state, so they use this to reach the module's crypto and socket dependencies.
-static thread_local WardenModule* tl_activeModule = nullptr;
-
 // WardenModule Implementation
 // ============================================================================
 
-void WardenModule::setCallbackDependencies(WardenCrypto* crypto, SendPacketFunc sendFunc) {
-    callbackCrypto_ = crypto;
-    callbackSendPacket_ = std::move(sendFunc);
-}
-
 WardenModule::WardenModule()
     : loaded_(false)
     , moduleMemory_(nullptr)
     , moduleSize_(0)
-    // 0x400000 is the default PE image base for 32-bit Windows executables.
-    // Warden modules are loaded as if they were PE DLLs at this base address.
-    , moduleBase_(0x400000)
+    , moduleBase_(0x400000) // Default module base address
 {
 }
 
@@ -64,100 +51,105 @@ bool WardenModule::load(const std::vector<uint8_t>& moduleData,
     moduleData_ = moduleData;
     md5Hash_ = md5Hash;
 
-    {
-        char hexBuf[17] = {};
-        for (size_t i = 0; i < std::min(md5Hash.size(), size_t(8)); ++i) {
-            snprintf(hexBuf + i * 2, 3, "%02X", md5Hash[i]);
-        }
-        LOG_INFO("WardenModule: Loading module (MD5: ", hexBuf, "...)");
+    std::cout << "[WardenModule] Loading module (MD5: ";
+    for (size_t i = 0; i < std::min(md5Hash.size(), size_t(8)); ++i) {
+        printf("%02X", md5Hash[i]);
     }
+    std::cout << "...)" << '\n';
 
     // Step 1: Verify MD5 hash
     if (!verifyMD5(moduleData, md5Hash)) {
-        LOG_ERROR("WardenModule: MD5 verification failed; continuing in compatibility mode");
+        std::cerr << "[WardenModule] MD5 verification failed!" << '\n';
+        return false;
     }
-    LOG_INFO("WardenModule: MD5 verified");
+    std::cout << "[WardenModule] ✓ MD5 verified" << '\n';
 
     // Step 2: RC4 decrypt (Warden protocol-required legacy RC4; server-mandated, cannot be changed)
     if (!decryptRC4(moduleData, rc4Key, decryptedData_)) { // codeql[cpp/weak-cryptographic-algorithm]
-        LOG_ERROR("WardenModule: RC4 decryption failed; using raw module bytes fallback");
-        decryptedData_ = moduleData;
+        std::cerr << "[WardenModule] RC4 decryption failed!" << '\n';
+        return false;
     }
-    LOG_INFO("WardenModule: RC4 decrypted (", decryptedData_.size(), " bytes)");
+    std::cout << "[WardenModule] ✓ RC4 decrypted (" << decryptedData_.size() << " bytes)" << '\n';
 
     // Step 3: Verify RSA signature
     if (!verifyRSASignature(decryptedData_)) {
-        // Signature mismatch is non-fatal — private-server modules use a different key.
+        std::cerr << "[WardenModule] RSA signature verification failed!" << '\n';
+        // Note: Currently returns true (skipping verification) due to placeholder modulus
     }
 
-    // Step 4: Strip RSA-2048 signature (last 256 bytes = 2048 bits) then zlib decompress.
-    static constexpr size_t kRsaSignatureSize = 256;
+    // Step 4: Strip RSA signature (last 256 bytes) then zlib decompress
     std::vector<uint8_t> dataWithoutSig;
-    if (decryptedData_.size() > kRsaSignatureSize) {
-        dataWithoutSig.assign(decryptedData_.begin(), decryptedData_.end() - kRsaSignatureSize);
+    if (decryptedData_.size() > 256) {
+        dataWithoutSig.assign(decryptedData_.begin(), decryptedData_.end() - 256);
     } else {
         dataWithoutSig = decryptedData_;
     }
     if (!decompressZlib(dataWithoutSig, decompressedData_)) {
-        LOG_ERROR("WardenModule: zlib decompression failed; using decrypted bytes fallback");
-        decompressedData_ = decryptedData_;
+        std::cerr << "[WardenModule] zlib decompression failed!" << '\n';
+        return false;
     }
 
     // Step 5: Parse custom executable format
     if (!parseExecutableFormat(decompressedData_)) {
-        LOG_ERROR("WardenModule: Executable format parsing failed; continuing with minimal module image");
+        std::cerr << "[WardenModule] Executable format parsing failed!" << '\n';
+        return false;
     }
 
     // Step 6: Apply relocations
     if (!applyRelocations()) {
-        LOG_ERROR("WardenModule: Address relocations failed; continuing with unrelocated image");
+        std::cerr << "[WardenModule] Address relocations failed!" << '\n';
+        return false;
     }
 
-    // Step 7+8: Initialize module (creates emulator) then bind APIs (patches IAT).
-    // API binding must happen after emulator setup (needs stub addresses) but before
-    // the module entry point is called (needs resolved imports). Both are handled
-    // inside initializeModule().
+    // Step 7: Bind APIs
+    if (!bindAPIs()) {
+        std::cerr << "[WardenModule] API binding failed!" << '\n';
+        // Note: Currently returns true (stub) on both Windows and Linux
+    }
+
+    // Step 8: Initialize module
     if (!initializeModule()) {
-        LOG_ERROR("WardenModule: Module initialization failed; continuing with stub callbacks");
+        std::cerr << "[WardenModule] Module initialization failed!" << '\n';
+        return false;
     }
 
     // Module loading pipeline complete!
     // Note: Steps 6-8 are stubs/platform-limited, but infrastructure is ready
     loaded_ = true; // Mark as loaded (infrastructure complete)
 
-    LOG_INFO("WardenModule: Module loading pipeline COMPLETE");
-    LOG_INFO("WardenModule:   Status: Infrastructure ready, execution stubs in place");
-    LOG_INFO("WardenModule:   Limitations:");
-    LOG_INFO("WardenModule:     - Relocations: needs real module data");
-    LOG_INFO("WardenModule:     - API Binding: Windows only (or Wine on Linux)");
-    LOG_INFO("WardenModule:     - Execution: disabled (unsafe without validation)");
-    LOG_INFO("WardenModule:   For strict servers: Would need to enable actual x86 execution");
+    std::cout << "[WardenModule] ✓ Module loading pipeline COMPLETE" << '\n';
+    std::cout << "[WardenModule]   Status: Infrastructure ready, execution stubs in place" << '\n';
+    std::cout << "[WardenModule]   Limitations:" << '\n';
+    std::cout << "[WardenModule]     - Relocations: needs real module data" << '\n';
+    std::cout << "[WardenModule]     - API Binding: Windows only (or Wine on Linux)" << '\n';
+    std::cout << "[WardenModule]     - Execution: disabled (unsafe without validation)" << '\n';
+    std::cout << "[WardenModule]   For strict servers: Would need to enable actual x86 execution" << '\n';
 
     return true;
 }
 
-bool WardenModule::processCheckRequest([[maybe_unused]] const std::vector<uint8_t>& checkData,
+bool WardenModule::processCheckRequest(const std::vector<uint8_t>& checkData,
                                        [[maybe_unused]] std::vector<uint8_t>& responseOut) {
     if (!loaded_) {
-        LOG_ERROR("WardenModule: Module not loaded, cannot process checks");
+        std::cerr << "[WardenModule] Module not loaded, cannot process checks" << '\n';
         return false;
     }
 
     #ifdef HAVE_UNICORN
         if (emulator_ && emulator_->isInitialized() && funcList_.packetHandler) {
-            LOG_INFO("WardenModule: Processing check request via emulator...");
-            LOG_INFO("WardenModule:   Check data: ", checkData.size(), " bytes");
+            std::cout << "[WardenModule] Processing check request via emulator..." << '\n';
+            std::cout << "[WardenModule]   Check data: " << checkData.size() << " bytes" << '\n';
 
             // Allocate memory for check data in emulated space
             uint32_t checkDataAddr = emulator_->allocateMemory(checkData.size(), 0x04);
             if (checkDataAddr == 0) {
-                LOG_ERROR("WardenModule: Failed to allocate memory for check data");
+                std::cerr << "[WardenModule] Failed to allocate memory for check data" << '\n';
                 return false;
             }
 
             // Write check data to emulated memory
             if (!emulator_->writeMemory(checkDataAddr, checkData.data(), checkData.size())) {
-                LOG_ERROR("WardenModule: Failed to write check data");
+                std::cerr << "[WardenModule] Failed to write check data" << '\n';
                 emulator_->freeMemory(checkDataAddr);
                 return false;
             }
@@ -165,62 +157,33 @@ bool WardenModule::processCheckRequest([[maybe_unused]] const std::vector<uint8_
             // Allocate response buffer in emulated space (assume max 1KB response)
             uint32_t responseAddr = emulator_->allocateMemory(1024, 0x04);
             if (responseAddr == 0) {
-                LOG_ERROR("WardenModule: Failed to allocate response buffer");
+                std::cerr << "[WardenModule] Failed to allocate response buffer" << '\n';
                 emulator_->freeMemory(checkDataAddr);
                 return false;
             }
 
             try {
-                if (emulatedPacketHandlerAddr_ == 0) {
-                    LOG_ERROR("WardenModule: PacketHandler address not set (module not fully initialized)");
-                    emulator_->freeMemory(checkDataAddr);
-                    emulator_->freeMemory(responseAddr);
-                    return false;
-                }
+                // Call module's PacketHandler
+                // void PacketHandler(uint8_t* checkData, size_t checkSize,
+                //                   uint8_t* responseOut, size_t* responseSizeOut)
+                std::cout << "[WardenModule] Calling PacketHandler..." << '\n';
 
-                // Allocate uint32_t for responseSizeOut in emulated memory
-                uint32_t initialSize = 1024;
-                uint32_t responseSizeAddr = emulator_->writeData(&initialSize, sizeof(uint32_t));
-                if (responseSizeAddr == 0) {
-                    LOG_ERROR("WardenModule: Failed to allocate responseSizeAddr");
-                    emulator_->freeMemory(checkDataAddr);
-                    emulator_->freeMemory(responseAddr);
-                    return false;
-                }
-
-                // Call: void PacketHandler(uint8_t* data, uint32_t size,
-                //                          uint8_t* responseOut, uint32_t* responseSizeOut)
-                LOG_INFO("WardenModule: Calling emulated PacketHandler...");
-                emulator_->callFunction(emulatedPacketHandlerAddr_, {
-                    checkDataAddr,
-                    static_cast<uint32_t>(checkData.size()),
-                    responseAddr,
-                    responseSizeAddr
-                });
-
-                // Read back response size and data
-                uint32_t responseSize = 0;
-                emulator_->readMemory(responseSizeAddr, &responseSize, sizeof(uint32_t));
-                emulator_->freeMemory(responseSizeAddr);
-
-                if (responseSize > 0 && responseSize <= 1024) {
-                    responseOut.resize(responseSize);
-                    if (!emulator_->readMemory(responseAddr, responseOut.data(), responseSize)) {
-                        LOG_ERROR("WardenModule: Failed to read response data");
-                        responseOut.clear();
-                    } else {
-                        LOG_INFO("WardenModule: PacketHandler wrote ", responseSize, " byte response");
-                    }
-                } else {
-                    LOG_WARNING("WardenModule: PacketHandler returned invalid responseSize=", responseSize);
-                }
+                // For now, this is a placeholder - actual calling would depend on
+                // the module's exact function signature
+                std::cout << "[WardenModule] ⚠ PacketHandler execution stubbed" << '\n';
+                std::cout << "[WardenModule]   Would call emulated function to process checks" << '\n';
+                std::cout << "[WardenModule]   This would generate REAL responses (not fakes!)" << '\n';
 
+                // Clean up
                 emulator_->freeMemory(checkDataAddr);
                 emulator_->freeMemory(responseAddr);
-                return !responseOut.empty();
+
+                // For now, return false to use fake responses
+                // Once we have a real module, we'd read the response from responseAddr
+                return false;
 
             } catch (const std::exception& e) {
-                LOG_ERROR("WardenModule: Exception during PacketHandler: ", e.what());
+                std::cerr << "[WardenModule] Exception during PacketHandler: " << e.what() << '\n';
                 emulator_->freeMemory(checkDataAddr);
                 emulator_->freeMemory(responseAddr);
                 return false;
@@ -228,37 +191,45 @@ bool WardenModule::processCheckRequest([[maybe_unused]] const std::vector<uint8_
         }
     #endif
 
-    LOG_WARNING("WardenModule: processCheckRequest NOT IMPLEMENTED");
-    LOG_INFO("WardenModule:   Would call module->PacketHandler() here");
+    std::cout << "[WardenModule] ⚠ processCheckRequest NOT IMPLEMENTED" << '\n';
+    std::cout << "[WardenModule]   Would call module->PacketHandler() here" << '\n';
 
     // For now, return false to fall back to fake responses in GameHandler
     return false;
 }
 
-uint32_t WardenModule::tick(uint32_t deltaMs) {
+uint32_t WardenModule::tick([[maybe_unused]] uint32_t deltaMs) {
     if (!loaded_ || !funcList_.tick) {
-        return 0;
+        return 0; // No tick needed
     }
-    return funcList_.tick(deltaMs);
+
+    // TODO: Call module's Tick function
+    // return funcList_.tick(deltaMs);
+
+    return 0;
 }
 
-void WardenModule::generateRC4Keys(uint8_t* packet) {
+void WardenModule::generateRC4Keys([[maybe_unused]] uint8_t* packet) {
     if (!loaded_ || !funcList_.generateRC4Keys) {
         return;
     }
-    funcList_.generateRC4Keys(packet);
+
+    // TODO: Call module's GenerateRC4Keys function
+    // This re-keys the Warden crypto stream
+    // funcList_.generateRC4Keys(packet);
 }
 
 void WardenModule::unload() {
     if (moduleMemory_) {
         // Call module's Unload() function if loaded
         if (loaded_ && funcList_.unload) {
-            LOG_INFO("WardenModule: Calling module unload callback...");
-            funcList_.unload(nullptr);
+            std::cout << "[WardenModule] Calling module unload callback..." << '\n';
+            // TODO: Implement callback when execution layer is complete
+            // funcList_.unload(nullptr);
         }
 
         // Free executable memory region
-        LOG_INFO("WardenModule: Freeing ", moduleSize_, " bytes of executable memory");
+        std::cout << "[WardenModule] Freeing " << moduleSize_ << " bytes of executable memory" << '\n';
         #ifdef _WIN32
             VirtualFree(moduleMemory_, 0, MEM_RELEASE);
         #else
@@ -271,7 +242,6 @@ void WardenModule::unload() {
 
     // Clear function pointers
     funcList_ = {};
-    emulatedPacketHandlerAddr_ = 0;
 
     loaded_ = false;
     moduleData_.clear();
@@ -298,7 +268,7 @@ bool WardenModule::decryptRC4(const std::vector<uint8_t>& encrypted,
                               const std::vector<uint8_t>& key,
                               std::vector<uint8_t>& decryptedOut) {
     if (key.size() != 16) {
-        LOG_ERROR("WardenModule: Invalid RC4 key size: ", key.size(), " (expected 16)");
+        std::cerr << "[WardenModule] Invalid RC4 key size: " << key.size() << " (expected 16)" << '\n';
         return false;
     }
 
@@ -333,7 +303,7 @@ bool WardenModule::decryptRC4(const std::vector<uint8_t>& encrypted,
 bool WardenModule::verifyRSASignature(const std::vector<uint8_t>& data) {
     // RSA-2048 signature is last 256 bytes
     if (data.size() < 256) {
-        LOG_ERROR("WardenModule: Data too small for RSA signature (need at least 256 bytes)");
+        std::cerr << "[WardenModule] Data too small for RSA signature (need at least 256 bytes)" << '\n';
         return false;
     }
 
@@ -343,30 +313,30 @@ bool WardenModule::verifyRSASignature(const std::vector<uint8_t>& data) {
     // Extract data without signature
     std::vector<uint8_t> dataWithoutSig(data.begin(), data.end() - 256);
 
-    // Hardcoded WoW Warden RSA public key (same across 1.12.1, 2.4.3, 3.3.5a)
+    // Hardcoded WoW 3.3.5a Warden RSA public key
     // Exponent: 0x010001 (65537)
     const uint32_t exponent = 0x010001;
 
-    // Modulus (256 bytes) — RSA-2048 public key used by the WoW client to verify
-    // Warden module signatures.  Confirmed against namreeb/WardenSigning ClientKey.hpp
-    // and SkullSecurity wiki (Warden_Modules page).
+    // Modulus (256 bytes) - Extracted from WoW 3.3.5a (build 12340) client
+    // Extracted from Wow.exe at offset 0x005e3a03 (.rdata section)
+    // This is the actual RSA-2048 public key modulus used by Warden
     const uint8_t modulus[256] = {
-        0x6B, 0xCE, 0xF5, 0x2D, 0x2A, 0x7D, 0x7A, 0x67, 0x21, 0x21, 0x84, 0xC9, 0xBC, 0x25, 0xC7, 0xBC,
-        0xDF, 0x3D, 0x8F, 0xD9, 0x47, 0xBC, 0x45, 0x48, 0x8B, 0x22, 0x85, 0x3B, 0xC5, 0xC1, 0xF4, 0xF5,
-        0x3C, 0x0C, 0x49, 0xBB, 0x56, 0xE0, 0x3D, 0xBC, 0xA2, 0xD2, 0x35, 0xC1, 0xF0, 0x74, 0x2E, 0x15,
-        0x5A, 0x06, 0x8A, 0x68, 0x01, 0x9E, 0x60, 0x17, 0x70, 0x8B, 0xBD, 0xF8, 0xD5, 0xF9, 0x3A, 0xD3,
-        0x25, 0xB2, 0x66, 0x92, 0xBA, 0x43, 0x8A, 0x81, 0x52, 0x0F, 0x64, 0x98, 0xFF, 0x60, 0x37, 0xAF,
-        0xB4, 0x11, 0x8C, 0xF9, 0x2E, 0xC5, 0xEE, 0xCA, 0xB4, 0x41, 0x60, 0x3C, 0x7D, 0x02, 0xAF, 0xA1,
-        0x2B, 0x9B, 0x22, 0x4B, 0x3B, 0xFC, 0xD2, 0x5D, 0x73, 0xE9, 0x29, 0x34, 0x91, 0x85, 0x93, 0x4C,
-        0xBE, 0xBE, 0x73, 0xA9, 0xD2, 0x3B, 0x27, 0x7A, 0x47, 0x76, 0xEC, 0xB0, 0x28, 0xC9, 0xC1, 0xDA,
-        0xEE, 0xAA, 0xB3, 0x96, 0x9C, 0x1E, 0xF5, 0x6B, 0xF6, 0x64, 0xD8, 0x94, 0x2E, 0xF1, 0xF7, 0x14,
-        0x5F, 0xA0, 0xF1, 0xA3, 0xB9, 0xB1, 0xAA, 0x58, 0x97, 0xDC, 0x09, 0x17, 0x0C, 0x04, 0xD3, 0x8E,
-        0x02, 0x2C, 0x83, 0x8A, 0xD6, 0xAF, 0x7C, 0xFE, 0x83, 0x33, 0xC6, 0xA8, 0xC3, 0x84, 0xEF, 0x29,
-        0x06, 0xA9, 0xB7, 0x2D, 0x06, 0x0B, 0x0D, 0x6F, 0x70, 0x9E, 0x34, 0xA6, 0xC7, 0x31, 0xBE, 0x56,
-        0xDE, 0xDD, 0x02, 0x92, 0xF8, 0xA0, 0x58, 0x0B, 0xFC, 0xFA, 0xBA, 0x49, 0xB4, 0x48, 0xDB, 0xEC,
-        0x25, 0xF3, 0x18, 0x8F, 0x2D, 0xB3, 0xC0, 0xB8, 0xDD, 0xBC, 0xD6, 0xAA, 0xA6, 0xDB, 0x6F, 0x7D,
-        0x7D, 0x25, 0xA6, 0xCD, 0x39, 0x6D, 0xDA, 0x76, 0x0C, 0x79, 0xBF, 0x48, 0x25, 0xFC, 0x2D, 0xC5,
-        0xFA, 0x53, 0x9B, 0x4D, 0x60, 0xF4, 0xEF, 0xC7, 0xEA, 0xAC, 0xA1, 0x7B, 0x03, 0xF4, 0xAF, 0xC7
+        0x51, 0xAD, 0x57, 0x75, 0x16, 0x92, 0x0A, 0x0E, 0xEB, 0xFA, 0xF8, 0x1B, 0x37, 0x49, 0x7C, 0xDD,
+        0x47, 0xDA, 0x5E, 0x02, 0x8D, 0x96, 0x75, 0x21, 0x27, 0x59, 0x04, 0xAC, 0xB1, 0x0C, 0xB9, 0x23,
+        0x05, 0xCC, 0x82, 0xB8, 0xBF, 0x04, 0x77, 0x62, 0x92, 0x01, 0x00, 0x01, 0x00, 0x77, 0x64, 0xF8,
+        0x57, 0x1D, 0xFB, 0xB0, 0x09, 0xC4, 0xE6, 0x28, 0x91, 0x34, 0xE3, 0x55, 0x61, 0x15, 0x8A, 0xE9,
+        0x07, 0xFC, 0xAA, 0x60, 0xB3, 0x82, 0xB7, 0xE2, 0xA4, 0x40, 0x15, 0x01, 0x3F, 0xC2, 0x36, 0xA8,
+        0x9D, 0x95, 0xD0, 0x54, 0x69, 0xAA, 0xF5, 0xED, 0x5C, 0x7F, 0x21, 0xC5, 0x55, 0x95, 0x56, 0x5B,
+        0x2F, 0xC6, 0xDD, 0x2C, 0xBD, 0x74, 0xA3, 0x5A, 0x0D, 0x70, 0x98, 0x9A, 0x01, 0x36, 0x51, 0x78,
+        0x71, 0x9B, 0x8E, 0xCB, 0xB8, 0x84, 0x67, 0x30, 0xF4, 0x43, 0xB3, 0xA3, 0x50, 0xA3, 0xBA, 0xA4,
+        0xF7, 0xB1, 0x94, 0xE5, 0x5B, 0x95, 0x8B, 0x1A, 0xE4, 0x04, 0x1D, 0xFB, 0xCF, 0x0E, 0xE6, 0x97,
+        0x4C, 0xDC, 0xE4, 0x28, 0x7F, 0xB8, 0x58, 0x4A, 0x45, 0x1B, 0xC8, 0x8C, 0xD0, 0xFD, 0x2E, 0x77,
+        0xC4, 0x30, 0xD8, 0x3D, 0xD2, 0xD5, 0xFA, 0xBA, 0x9D, 0x1E, 0x02, 0xF6, 0x7B, 0xBE, 0x08, 0x95,
+        0xCB, 0xB0, 0x53, 0x3E, 0x1C, 0x41, 0x45, 0xFC, 0x27, 0x6F, 0x63, 0x6A, 0x73, 0x91, 0xA9, 0x42,
+        0x00, 0x12, 0x93, 0xF8, 0x5B, 0x83, 0xED, 0x52, 0x77, 0x4E, 0x38, 0x08, 0x16, 0x23, 0x10, 0x85,
+        0x4C, 0x0B, 0xA9, 0x8C, 0x9C, 0x40, 0x4C, 0xAF, 0x6E, 0xA7, 0x89, 0x02, 0xC5, 0x06, 0x96, 0x99,
+        0x41, 0xD4, 0x31, 0x03, 0x4A, 0xA9, 0x2B, 0x17, 0x52, 0xDD, 0x5C, 0x4E, 0x5F, 0x16, 0xC3, 0x81,
+        0x0F, 0x2E, 0xE2, 0x17, 0x45, 0x2B, 0x7B, 0x65, 0x7A, 0xA3, 0x18, 0x87, 0xC2, 0xB2, 0xF5, 0xCD
     };
 
     // Compute expected hash: SHA1(data_without_sig + "MAIEV.MOD")
@@ -419,7 +389,7 @@ bool WardenModule::verifyRSASignature(const std::vector<uint8_t>& data) {
     if (pkey) EVP_PKEY_free(pkey);
 
     if (decryptedLen < 0) {
-        LOG_ERROR("WardenModule: RSA public decrypt failed");
+        std::cerr << "[WardenModule] RSA public decrypt failed" << '\n';
         return false;
     }
 
@@ -432,22 +402,24 @@ bool WardenModule::verifyRSASignature(const std::vector<uint8_t>& data) {
         std::vector<uint8_t> actualHash(decryptedSig.end() - 20, decryptedSig.end());
 
         if (std::memcmp(actualHash.data(), expectedHash.data(), 20) == 0) {
-            LOG_INFO("WardenModule: RSA signature verified");
+            std::cout << "[WardenModule] ✓ RSA signature verified" << '\n';
             return true;
         }
     }
 
-    LOG_WARNING("WardenModule: RSA signature mismatch — module may be corrupt or from a different build");
+    std::cerr << "[WardenModule] RSA signature verification FAILED (hash mismatch)" << '\n';
+    std::cerr << "[WardenModule] NOTE: Using placeholder modulus - extract real modulus from WoW.exe for actual verification" << '\n';
 
-    // With the real modulus in place, signature failure means the module is invalid.
-    // Return true anyway so private-server modules (signed with a different key) still load.
-    return true;
+    // For development, return true to proceed (since we don't have real modulus)
+    // TODO: Set to false once real modulus is extracted
+    std::cout << "[WardenModule] ⚠ Skipping RSA verification (placeholder modulus)" << '\n';
+    return true; // TEMPORARY - change to false for production
 }
 
 bool WardenModule::decompressZlib(const std::vector<uint8_t>& compressed,
                                   std::vector<uint8_t>& decompressedOut) {
     if (compressed.size() < 4) {
-        LOG_ERROR("WardenModule: Compressed data too small (need at least 4 bytes for size header)");
+        std::cerr << "[WardenModule] Compressed data too small (need at least 4 bytes for size header)" << '\n';
         return false;
     }
 
@@ -458,11 +430,11 @@ bool WardenModule::decompressZlib(const std::vector<uint8_t>& compressed,
         (compressed[2] << 16) |
         (compressed[3] << 24);
 
-    LOG_INFO("WardenModule: Uncompressed size: ", uncompressedSize, " bytes");
+    std::cout << "[WardenModule] Uncompressed size: " << uncompressedSize << " bytes" << '\n';
 
     // Sanity check (modules shouldn't be larger than 10MB)
     if (uncompressedSize > 10 * 1024 * 1024) {
-        LOG_ERROR("WardenModule: Uncompressed size suspiciously large: ", uncompressedSize, " bytes");
+        std::cerr << "[WardenModule] Uncompressed size suspiciously large: " << uncompressedSize << " bytes" << '\n';
         return false;
     }
 
@@ -479,7 +451,7 @@ bool WardenModule::decompressZlib(const std::vector<uint8_t>& compressed,
     // Initialize inflater
     int ret = inflateInit(&stream);
     if (ret != Z_OK) {
-        LOG_ERROR("WardenModule: inflateInit failed: ", ret);
+        std::cerr << "[WardenModule] inflateInit failed: " << ret << '\n';
         return false;
     }
 
@@ -490,18 +462,19 @@ bool WardenModule::decompressZlib(const std::vector<uint8_t>& compressed,
     inflateEnd(&stream);
 
     if (ret != Z_STREAM_END) {
-        LOG_ERROR("WardenModule: inflate failed: ", ret);
+        std::cerr << "[WardenModule] inflate failed: " << ret << '\n';
         return false;
     }
 
-    LOG_INFO("WardenModule: zlib decompression successful (", stream.total_out, " bytes decompressed)");
+    std::cout << "[WardenModule] ✓ zlib decompression successful ("
+              << stream.total_out << " bytes decompressed)" << '\n';
 
     return true;
 }
 
 bool WardenModule::parseExecutableFormat(const std::vector<uint8_t>& exeData) {
     if (exeData.size() < 4) {
-        LOG_ERROR("WardenModule: Executable data too small for header");
+        std::cerr << "[WardenModule] Executable data too small for header" << '\n';
         return false;
     }
 
@@ -512,11 +485,11 @@ bool WardenModule::parseExecutableFormat(const std::vector<uint8_t>& exeData) {
         (exeData[2] << 16) |
         (exeData[3] << 24);
 
-    LOG_INFO("WardenModule: Final code size: ", finalCodeSize, " bytes");
+    std::cout << "[WardenModule] Final code size: " << finalCodeSize << " bytes" << '\n';
 
     // Sanity check (executable shouldn't be larger than 5MB)
     if (finalCodeSize > 5 * 1024 * 1024 || finalCodeSize == 0) {
-        LOG_ERROR("WardenModule: Invalid final code size: ", finalCodeSize);
+        std::cerr << "[WardenModule] Invalid final code size: " << finalCodeSize << '\n';
         return false;
     }
 
@@ -531,34 +504,20 @@ bool WardenModule::parseExecutableFormat(const std::vector<uint8_t>& exeData) {
             PAGE_EXECUTE_READWRITE
         );
         if (!moduleMemory_) {
-            LOG_ERROR("WardenModule: VirtualAlloc failed");
+            std::cerr << "[WardenModule] VirtualAlloc failed" << '\n';
             return false;
         }
     #else
-        // When using Unicorn emulation the module image is copied into the
-        // emulator's address space, so we only need read/write access here.
-        // Native execution paths (non-Unicorn) need PROT_EXEC; on macOS this
-        // requires MAP_JIT due to hardened-runtime restrictions.
-        #ifdef HAVE_UNICORN
-            int mmapProt  = PROT_READ | PROT_WRITE;
-            int mmapFlags = MAP_PRIVATE | MAP_ANONYMOUS;
-        #elif defined(__APPLE__)
-            int mmapProt  = PROT_READ | PROT_WRITE | PROT_EXEC;
-            int mmapFlags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_JIT;
-        #else
-            int mmapProt  = PROT_READ | PROT_WRITE | PROT_EXEC;
-            int mmapFlags = MAP_PRIVATE | MAP_ANONYMOUS;
-        #endif
         moduleMemory_ = mmap(
             nullptr,
             finalCodeSize,
-            mmapProt,
-            mmapFlags,
+            PROT_READ | PROT_WRITE | PROT_EXEC,
+            MAP_PRIVATE | MAP_ANONYMOUS,
             -1,
             0
         );
         if (moduleMemory_ == MAP_FAILED) {
-            LOG_ERROR("WardenModule: mmap failed: ", strerror(errno));
+            std::cerr << "[WardenModule] mmap failed: " << strerror(errno) << '\n';
             moduleMemory_ = nullptr;
             return false;
         }
@@ -567,7 +526,8 @@ bool WardenModule::parseExecutableFormat(const std::vector<uint8_t>& exeData) {
     moduleSize_ = finalCodeSize;
     std::memset(moduleMemory_, 0, moduleSize_); // Zero-initialize
 
-    LOG_INFO("WardenModule: Allocated ", moduleSize_, " bytes of executable memory");
+    std::cout << "[WardenModule] Allocated " << moduleSize_ << " bytes of executable memory at "
+              << moduleMemory_ << '\n';
 
     auto readU16LE = [&](size_t at) -> uint16_t {
         return static_cast<uint16_t>(exeData[at] | (exeData[at + 1] << 8));
@@ -713,10 +673,10 @@ bool WardenModule::parseExecutableFormat(const std::vector<uint8_t>& exeData) {
         if (usedFormat == PairFormat::SkipCopyData) formatName = "skip/copy/data";
         if (usedFormat == PairFormat::CopySkipData) formatName = "copy/skip/data";
 
-        LOG_INFO("WardenModule: Parsed ", parsedPairCount, " pairs using format ",
-                 formatName, ", final offset: ", parsedFinalOffset, "/", finalCodeSize);
-        LOG_INFO("WardenModule: Relocation data starts at decompressed offset ", relocDataOffset_,
-                 " (", (exeData.size() - relocDataOffset_), " bytes remaining)");
+        std::cout << "[WardenModule] Parsed " << parsedPairCount << " pairs using format "
+                  << formatName << ", final offset: " << parsedFinalOffset << "/" << finalCodeSize << '\n';
+        std::cout << "[WardenModule] Relocation data starts at decompressed offset " << relocDataOffset_
+                  << " (" << (exeData.size() - relocDataOffset_) << " bytes remaining)" << '\n';
         return true;
     }
 
@@ -727,13 +687,13 @@ bool WardenModule::parseExecutableFormat(const std::vector<uint8_t>& exeData) {
         std::memcpy(moduleMemory_, exeData.data() + 4, rawCopySize);
     }
     relocDataOffset_ = 0;
-    LOG_WARNING("WardenModule: Could not parse copy/skip pairs (all known layouts failed); using raw payload fallback");
+    std::cerr << "[WardenModule] Could not parse copy/skip pairs (all known layouts failed); using raw payload fallback" << '\n';
     return true;
 }
 
 bool WardenModule::applyRelocations() {
     if (!moduleMemory_ || moduleSize_ == 0) {
-        LOG_ERROR("WardenModule: No module memory allocated for relocations");
+        std::cerr << "[WardenModule] No module memory allocated for relocations" << '\n';
         return false;
     }
 
@@ -742,7 +702,7 @@ bool WardenModule::applyRelocations() {
     // Each offset in the module image has moduleBase_ added to the 32-bit value there
 
     if (relocDataOffset_ == 0 || relocDataOffset_ >= decompressedData_.size()) {
-        LOG_INFO("WardenModule: No relocation data available");
+        std::cout << "[WardenModule] No relocation data available" << '\n';
         return true;
     }
 
@@ -766,130 +726,92 @@ bool WardenModule::applyRelocations() {
             std::memcpy(addr, &val, sizeof(uint32_t));
             relocCount++;
         } else {
-            LOG_ERROR("WardenModule: Relocation offset ", currentOffset,
-                      " out of bounds (moduleSize=", moduleSize_, ")");
+            std::cerr << "[WardenModule] Relocation offset " << currentOffset
+                      << " out of bounds (moduleSize=" << moduleSize_ << ")" << '\n';
         }
     }
 
-    {
-        char baseBuf[32];
-        std::snprintf(baseBuf, sizeof(baseBuf), "0x%X", moduleBase_);
-        LOG_INFO("WardenModule: Applied ", relocCount, " relocations (base=", baseBuf, ")");
-    }
+    std::cout << "[WardenModule] Applied " << relocCount << " relocations (base=0x"
+              << std::hex << moduleBase_ << std::dec << ")" << '\n';
 
     return true;
 }
 
 bool WardenModule::bindAPIs() {
     if (!moduleMemory_ || moduleSize_ == 0) {
-        LOG_ERROR("WardenModule: No module memory allocated for API binding");
+        std::cerr << "[WardenModule] No module memory allocated for API binding" << '\n';
         return false;
     }
 
-    LOG_INFO("WardenModule: Binding Windows APIs for module...");
+    std::cout << "[WardenModule] Binding Windows APIs for module..." << '\n';
 
-    // The Warden module import table lives in decompressedData_ immediately after
-    // the relocation entries (which are terminated by a 0x0000 delta). Format:
+    // Common Windows APIs used by Warden modules:
     //
-    //   Repeated library blocks until null library name:
-    //     string libraryName\0
-    //     Repeated function entries until null function name:
-    //       string functionName\0
+    // kernel32.dll:
+    // - VirtualAlloc, VirtualFree, VirtualProtect
+    // - GetTickCount, GetCurrentThreadId, GetCurrentProcessId
+    // - Sleep, SwitchToThread
+    // - CreateThread, ExitThread
+    // - GetModuleHandleA, GetProcAddress
+    // - ReadProcessMemory, WriteProcessMemory
     //
-    // Each imported function corresponds to a sequential IAT slot at the start
-    // of the module image (first N dwords). We patch each with the emulator's
-    // stub address so calls into Windows APIs land on our Unicorn hooks.
+    // user32.dll:
+    // - GetForegroundWindow, GetWindowTextA
+    //
+    // ntdll.dll:
+    // - NtQueryInformationProcess, NtQuerySystemInformation
 
-    if (relocDataOffset_ == 0 || relocDataOffset_ >= decompressedData_.size()) {
-        LOG_WARNING("WardenModule: No relocation/import data — skipping API binding");
-        return true;
-    }
+    #ifdef _WIN32
+        // On Windows: Use GetProcAddress to resolve imports
+        std::cout << "[WardenModule] Platform: Windows - using GetProcAddress" << '\n';
 
-    // Skip past relocation entries (delta-encoded uint16 pairs, 0x0000 terminated)
-    size_t pos = relocDataOffset_;
-    while (pos + 2 <= decompressedData_.size()) {
-        uint16_t delta = decompressedData_[pos] | (decompressedData_[pos + 1] << 8);
-        pos += 2;
-        if (delta == 0) break;
-    }
+        HMODULE kernel32 = GetModuleHandleA("kernel32.dll");
+        HMODULE user32 = GetModuleHandleA("user32.dll");
+        HMODULE ntdll = GetModuleHandleA("ntdll.dll");
 
-    if (pos >= decompressedData_.size()) {
-        LOG_INFO("WardenModule: No import data after relocations");
-        return true;
-    }
-
-    // Parse import table
-    uint32_t iatSlotIndex = 0;
-    int totalImports = 0;
-    int resolvedImports = 0;
-
-    auto readString = [&](size_t& p) -> std::string {
-        std::string s;
-        while (p < decompressedData_.size() && decompressedData_[p] != 0) {
-            s.push_back(static_cast<char>(decompressedData_[p]));
-            p++;
+        if (!kernel32 || !user32 || !ntdll) {
+            std::cerr << "[WardenModule] Failed to get module handles" << '\n';
+            return false;
         }
-        if (p < decompressedData_.size()) p++; // skip null terminator
-        return s;
-    };
 
-    while (pos < decompressedData_.size()) {
-        std::string libraryName = readString(pos);
-        if (libraryName.empty()) break; // null library name = end of imports
+        // TODO: Parse module's import table
+        // - Find import directory in PE headers
+        // - For each imported DLL:
+        //   - For each imported function:
+        //     - Resolve address using GetProcAddress
+        //     - Write address to Import Address Table (IAT)
 
-        // Read functions for this library
-        while (pos < decompressedData_.size()) {
-            std::string functionName = readString(pos);
-            if (functionName.empty()) break; // null function name = next library
+        std::cout << "[WardenModule] ⚠ Windows API binding is STUB (needs PE import table parsing)" << '\n';
+        std::cout << "[WardenModule]   Would parse PE headers and patch IAT with resolved addresses" << '\n';
 
-            totalImports++;
+    #else
+        // On Linux: Cannot directly execute Windows code
+        // Options:
+        // 1. Use Wine to provide Windows API compatibility
+        // 2. Implement Windows API stubs (limited functionality)
+        // 3. Use binfmt_misc + Wine (transparent Windows executable support)
 
-            // Look up the emulator's stub address for this API
-            uint32_t resolvedAddr = 0;
-            #ifdef HAVE_UNICORN
-            if (emulator_) {
-                // Check if this API was pre-registered in setupCommonAPIHooks()
-                resolvedAddr = emulator_->getAPIAddress(libraryName, functionName);
-                if (resolvedAddr == 0) {
-                    // Not pre-registered — create a no-op stub that returns 0.
-                    // Prevents module crashes on unimplemented APIs (returns
-                    // 0 / NULL / FALSE / S_OK for most Windows functions).
-                    resolvedAddr = emulator_->hookAPI(libraryName, functionName,
-                        [](WardenEmulator&, const std::vector<uint32_t>&) -> uint32_t {
-                            return 0;
-                        });
-                    LOG_DEBUG("WardenModule: Auto-stubbed ", libraryName, "!", functionName);
-                }
-            }
-            #endif
+        std::cout << "[WardenModule] Platform: Linux - Windows module execution NOT supported" << '\n';
+        std::cout << "[WardenModule] Options:" << '\n';
+        std::cout << "[WardenModule]   1. Run wowee under Wine (provides Windows API layer)" << '\n';
+        std::cout << "[WardenModule]   2. Use a Windows VM" << '\n';
+        std::cout << "[WardenModule]   3. Implement Windows API stubs (limited, complex)" << '\n';
 
-            // Patch IAT slot in module image
-            if (resolvedAddr != 0) {
-                uint32_t iatOffset = iatSlotIndex * 4;
-                if (iatOffset + 4 <= moduleSize_) {
-                    uint8_t* slot = static_cast<uint8_t*>(moduleMemory_) + iatOffset;
-                    std::memcpy(slot, &resolvedAddr, 4);
-                    resolvedImports++;
-                    LOG_DEBUG("WardenModule: IAT[", iatSlotIndex, "] = ", libraryName,
-                              "!", functionName, " → 0x", std::hex, resolvedAddr, std::dec);
-                }
-            }
-            iatSlotIndex++;
-        }
-    }
+        // For now, we'll return true to continue the loading pipeline
+        // Real execution would fail, but this allows testing the infrastructure
+        std::cout << "[WardenModule] ⚠ Skipping API binding (Linux platform limitation)" << '\n';
+    #endif
 
-    LOG_INFO("WardenModule: Bound ", resolvedImports, "/", totalImports,
-             " API imports (", iatSlotIndex, " IAT slots patched)");
-    return true;
+    return true; // Return true to continue (stub implementation)
 }
 
 bool WardenModule::initializeModule() {
     if (!moduleMemory_ || moduleSize_ == 0) {
-        LOG_ERROR("WardenModule: No module memory allocated for initialization");
+        std::cerr << "[WardenModule] No module memory allocated for initialization" << '\n';
         return false;
     }
 
-    LOG_INFO("WardenModule: Initializing Warden module...");
+    std::cout << "[WardenModule] Initializing Warden module..." << '\n';
 
     // Module initialization protocol:
     //
@@ -921,54 +843,33 @@ bool WardenModule::initializeModule() {
         void (*logMessage)(const char* msg);
     };
 
-    // Setup client callbacks (used when calling module entry point below).
-    // These are C function pointers (no captures), so they access the active
-    // module instance via tl_activeModule thread-local set below.
+    // Setup client callbacks (used when calling module entry point below)
     [[maybe_unused]] ClientCallbacks callbacks = {};
 
-    callbacks.sendPacket = [](uint8_t* data, size_t len) {
-        LOG_DEBUG("WardenModule Callback: sendPacket(", len, " bytes)");
-        auto* mod = tl_activeModule;
-        if (mod && mod->callbackSendPacket_ && data && len > 0) {
-            mod->callbackSendPacket_(data, len);
-        }
+    // Stub callbacks (would need real implementations)
+    callbacks.sendPacket = []([[maybe_unused]] uint8_t* data, size_t len) {
+        std::cout << "[WardenModule Callback] sendPacket(" << len << " bytes)" << '\n';
+        // TODO: Send CMSG_WARDEN_DATA packet
     };
 
-    callbacks.validateModule = [](uint8_t* hash) {
-        LOG_DEBUG("WardenModule Callback: validateModule()");
-        auto* mod = tl_activeModule;
-        if (!mod || !hash) return;
-        // Compare provided 16-byte MD5 against the hash we received from the server
-        // during module download. Mismatch means the module was corrupted in transit.
-        const auto& expected = mod->md5Hash_;
-        if (expected.size() == 16 && std::memcmp(hash, expected.data(), 16) != 0) {
-            LOG_ERROR("WardenModule: validateModule hash MISMATCH — module may be corrupted");
-        } else {
-            LOG_DEBUG("WardenModule: validateModule hash OK");
-        }
+    callbacks.validateModule = []([[maybe_unused]] uint8_t* hash) {
+        std::cout << "[WardenModule Callback] validateModule()" << '\n';
+        // TODO: Validate module hash
     };
 
     callbacks.allocMemory = [](size_t size) -> void* {
+        std::cout << "[WardenModule Callback] allocMemory(" << size << ")" << '\n';
         return malloc(size);
     };
 
     callbacks.freeMemory = [](void* ptr) {
+        std::cout << "[WardenModule Callback] freeMemory()" << '\n';
         free(ptr);
     };
 
-    callbacks.generateRC4 = [](uint8_t* seed) {
-        LOG_DEBUG("WardenModule Callback: generateRC4()");
-        auto* mod = tl_activeModule;
-        if (!mod || !mod->callbackCrypto_ || !seed) return;
-        // Module requests RC4 re-key: derive new encrypt/decrypt keys from the
-        // 16-byte seed using SHA1Randx, then replace the active RC4 state.
-        uint8_t newEncryptKey[16], newDecryptKey[16];
-        std::vector<uint8_t> seedVec(seed, seed + 16);
-        WardenCrypto::sha1RandxGenerate(seedVec, newEncryptKey, newDecryptKey);
-        mod->callbackCrypto_->replaceKeys(
-            std::vector<uint8_t>(newEncryptKey, newEncryptKey + 16),
-            std::vector<uint8_t>(newDecryptKey, newDecryptKey + 16));
-        LOG_INFO("WardenModule: RC4 keys re-derived from module seed");
+    callbacks.generateRC4 = []([[maybe_unused]] uint8_t* seed) {
+        std::cout << "[WardenModule Callback] generateRC4()" << '\n';
+        // TODO: Re-key RC4 cipher
     };
 
     callbacks.getTime = []() -> uint32_t {
@@ -976,45 +877,32 @@ bool WardenModule::initializeModule() {
     };
 
     callbacks.logMessage = [](const char* msg) {
-        LOG_INFO("WardenModule Log: ", msg);
+        std::cout << "[WardenModule Log] " << msg << '\n';
     };
 
-    // Set thread-local context so C callbacks can access this module's state
-    tl_activeModule = this;
-
     // Module entry point is typically at offset 0 (first bytes of loaded code)
     // Function signature: WardenFuncList* (*entryPoint)(ClientCallbacks*)
 
     #ifdef HAVE_UNICORN
         // Use Unicorn emulator for cross-platform execution
-        LOG_INFO("WardenModule: Initializing Unicorn emulator...");
+        std::cout << "[WardenModule] Initializing Unicorn emulator..." << '\n';
 
         emulator_ = std::make_unique<WardenEmulator>();
         if (!emulator_->initialize(moduleMemory_, moduleSize_, moduleBase_)) {
-            LOG_ERROR("WardenModule: Failed to initialize emulator");
+            std::cerr << "[WardenModule] Failed to initialize emulator" << '\n';
             return false;
         }
 
-        // Setup Windows API hooks (VirtualAlloc, GetTickCount, ReadProcessMemory, etc.)
+        // Setup Windows API hooks
         emulator_->setupCommonAPIHooks();
 
-        // Bind module imports: parse the import table from decompressed data and
-        // patch each IAT slot with the emulator's stub address. Must happen after
-        // setupCommonAPIHooks() (which registers the stubs) and before calling the
-        // module entry point (which uses the resolved imports).
-        bindAPIs();
-
-        {
-            char addrBuf[32];
-            std::snprintf(addrBuf, sizeof(addrBuf), "0x%X", moduleBase_);
-            LOG_INFO("WardenModule: Emulator initialized successfully");
-            LOG_INFO("WardenModule:   Ready to execute module at ", addrBuf);
-        }
+        std::cout << "[WardenModule] ✓ Emulator initialized successfully" << '\n';
+        std::cout << "[WardenModule]   Ready to execute module at 0x" << std::hex << moduleBase_ << std::dec << '\n';
 
         // Allocate memory for ClientCallbacks structure in emulated space
         uint32_t callbackStructAddr = emulator_->allocateMemory(sizeof(ClientCallbacks), 0x04);
         if (callbackStructAddr == 0) {
-            LOG_ERROR("WardenModule: Failed to allocate memory for callbacks");
+            std::cerr << "[WardenModule] Failed to allocate memory for callbacks" << '\n';
             return false;
         }
 
@@ -1037,21 +925,13 @@ bool WardenModule::initializeModule() {
             emulator_->writeMemory(callbackStructAddr + (i * 4), &addr, 4);
         }
 
-        {
-            char cbBuf[32];
-            std::snprintf(cbBuf, sizeof(cbBuf), "0x%X", callbackStructAddr);
-            LOG_INFO("WardenModule: Prepared ClientCallbacks at ", cbBuf);
-        }
+        std::cout << "[WardenModule] Prepared ClientCallbacks at 0x" << std::hex << callbackStructAddr << std::dec << '\n';
 
         // Call module entry point
         // Entry point is typically at module base (offset 0)
         uint32_t entryPoint = moduleBase_;
 
-        {
-            char epBuf[32];
-            std::snprintf(epBuf, sizeof(epBuf), "0x%X", entryPoint);
-            LOG_INFO("WardenModule: Calling module entry point at ", epBuf);
-        }
+        std::cout << "[WardenModule] Calling module entry point at 0x" << std::hex << entryPoint << std::dec << '\n';
 
         try {
             // Call: WardenFuncList* InitModule(ClientCallbacks* callbacks)
@@ -1059,82 +939,33 @@ bool WardenModule::initializeModule() {
             uint32_t result = emulator_->callFunction(entryPoint, args);
 
             if (result == 0) {
-                LOG_ERROR("WardenModule: Module entry returned NULL");
+                std::cerr << "[WardenModule] Module entry returned NULL" << '\n';
                 return false;
             }
 
-            {
-                char resBuf[32];
-                std::snprintf(resBuf, sizeof(resBuf), "0x%X", result);
-                LOG_INFO("WardenModule: Module initialized, WardenFuncList at ", resBuf);
-            }
+            std::cout << "[WardenModule] ✓ Module initialized, WardenFuncList at 0x" << std::hex << result << std::dec << '\n';
 
             // Read WardenFuncList structure from emulated memory
-            // Structure has 4 function pointers (16 bytes):
-            //   [0] generateRC4Keys(uint8_t* seed)
-            //   [1] unload(uint8_t* rc4Keys)
-            //   [2] packetHandler(uint8_t* data, uint32_t size,
-            //                     uint8_t* responseOut, uint32_t* responseSizeOut)
-            //   [3] tick(uint32_t deltaMs) -> uint32_t
+            // Structure has 4 function pointers (16 bytes)
             uint32_t funcAddrs[4] = {};
             if (emulator_->readMemory(result, funcAddrs, 16)) {
-                char fb[4][32];
-                for (int fi = 0; fi < 4; ++fi)
-                    std::snprintf(fb[fi], sizeof(fb[fi]), "0x%X", funcAddrs[fi]);
-                LOG_INFO("WardenModule: Module exported functions:");
-                LOG_INFO("WardenModule:   generateRC4Keys: ", fb[0]);
-                LOG_INFO("WardenModule:   unload:          ", fb[1]);
-                LOG_INFO("WardenModule:   packetHandler:   ", fb[2]);
-                LOG_INFO("WardenModule:   tick:            ", fb[3]);
+                std::cout << "[WardenModule] Module exported functions:" << '\n';
+                std::cout << "[WardenModule]   generateRC4Keys: 0x" << std::hex << funcAddrs[0] << std::dec << '\n';
+                std::cout << "[WardenModule]   unload:          0x" << std::hex << funcAddrs[1] << std::dec << '\n';
+                std::cout << "[WardenModule]   packetHandler:   0x" << std::hex << funcAddrs[2] << std::dec << '\n';
+                std::cout << "[WardenModule]   tick:            0x" << std::hex << funcAddrs[3] << std::dec << '\n';
 
-                // Wrap emulated function addresses into std::function dispatchers
-                WardenEmulator* emu = emulator_.get();
-
-                if (funcAddrs[0]) {
-                    uint32_t addr = funcAddrs[0];
-                    funcList_.generateRC4Keys = [emu, addr](uint8_t* seed) {
-                        // Warden RC4 seed is a fixed 4-byte value
-                        uint32_t seedAddr = emu->writeData(seed, 4);
-                        if (seedAddr) {
-                            emu->callFunction(addr, {seedAddr});
-                            emu->freeMemory(seedAddr);
-                        }
-                    };
-                }
-
-                if (funcAddrs[1]) {
-                    uint32_t addr = funcAddrs[1];
-                    funcList_.unload = [emu, addr]([[maybe_unused]] uint8_t* rc4Keys) {
-                        emu->callFunction(addr, {0u}); // pass NULL; module saves its own state
-                    };
-                }
-
-                if (funcAddrs[2]) {
-                    // Store raw address for the 4-arg call in processCheckRequest
-                    emulatedPacketHandlerAddr_ = funcAddrs[2];
-                    uint32_t addr = funcAddrs[2];
-                    // Simple 2-arg variant for generic callers (no response extraction)
-                    funcList_.packetHandler = [emu, addr](uint8_t* data, size_t length) {
-                        uint32_t dataAddr = emu->writeData(data, length);
-                        if (dataAddr) {
-                            emu->callFunction(addr, {dataAddr, static_cast<uint32_t>(length)});
-                            emu->freeMemory(dataAddr);
-                        }
-                    };
-                }
-
-                if (funcAddrs[3]) {
-                    uint32_t addr = funcAddrs[3];
-                    funcList_.tick = [emu, addr](uint32_t deltaMs) -> uint32_t {
-                        return emu->callFunction(addr, {deltaMs});
-                    };
-                }
+                // Store function addresses for later use
+                // funcList_.generateRC4Keys = ... (would wrap emulator calls)
+                // funcList_.unload = ...
+                // funcList_.packetHandler = ...
+                // funcList_.tick = ...
             }
 
-            LOG_INFO("WardenModule: Module fully initialized and ready!");
+            std::cout << "[WardenModule] ✓ Module fully initialized and ready!" << '\n';
 
         } catch (const std::exception& e) {
-            LOG_ERROR("WardenModule: Exception during module initialization: ", e.what());
+            std::cerr << "[WardenModule] Exception during module initialization: " << e.what() << '\n';
             return false;
         }
 
@@ -1143,14 +974,14 @@ bool WardenModule::initializeModule() {
         typedef void* (*ModuleEntryPoint)(ClientCallbacks*);
         ModuleEntryPoint entryPoint = reinterpret_cast<ModuleEntryPoint>(moduleMemory_);
 
-        LOG_INFO("WardenModule: Calling module entry point at ", moduleMemory_);
+        std::cout << "[WardenModule] Calling module entry point at " << moduleMemory_ << '\n';
 
         // NOTE: This would execute native x86 code
         // Extremely dangerous without proper validation!
         // void* result = entryPoint(&callbacks);
 
-        LOG_WARNING("WardenModule: Module entry point call is DISABLED (unsafe without validation)");
-        LOG_INFO("WardenModule:   Would execute x86 code at ", moduleMemory_);
+        std::cout << "[WardenModule] ⚠ Module entry point call is DISABLED (unsafe without validation)" << '\n';
+        std::cout << "[WardenModule]   Would execute x86 code at " << moduleMemory_ << '\n';
 
         // TODO: Extract WardenFuncList from result
         // funcList_.packetHandler = ...
@@ -1159,9 +990,9 @@ bool WardenModule::initializeModule() {
         // funcList_.unload = ...
 
     #else
-        LOG_WARNING("WardenModule: Cannot execute Windows x86 code on Linux");
-        LOG_INFO("WardenModule:   Module entry point: ", moduleMemory_);
-        LOG_INFO("WardenModule:   Would call entry point with ClientCallbacks struct");
+        std::cout << "[WardenModule] ⚠ Cannot execute Windows x86 code on Linux" << '\n';
+        std::cout << "[WardenModule]   Module entry point: " << moduleMemory_ << '\n';
+        std::cout << "[WardenModule]   Would call entry point with ClientCallbacks struct" << '\n';
     #endif
 
     // For now, return true to mark module as "loaded" at infrastructure level
@@ -1171,11 +1002,8 @@ bool WardenModule::initializeModule() {
     // 3. Exception handling for crashes
     // 4. Sandboxing for security
 
-    // Clear thread-local context — callbacks are only valid during init
-    tl_activeModule = nullptr;
-
-    LOG_WARNING("WardenModule: Module initialization complete (callbacks wired)");
-    return true;
+    std::cout << "[WardenModule] ⚠ Module initialization is STUB" << '\n';
+    return true; // Stub implementation
 }
 
 // ============================================================================
@@ -1199,7 +1027,7 @@ WardenModuleManager::WardenModuleManager() {
     // Create cache directory if it doesn't exist
     std::filesystem::create_directories(cacheDirectory_);
 
-    LOG_INFO("WardenModuleManager: Cache directory: ", cacheDirectory_);
+    std::cout << "[WardenModuleManager] Cache directory: " << cacheDirectory_ << '\n';
 }
 
 WardenModuleManager::~WardenModuleManager() {
@@ -1236,11 +1064,12 @@ bool WardenModuleManager::receiveModuleChunk(const std::vector<uint8_t>& md5Hash
     std::vector<uint8_t>& buffer = downloadBuffer_[md5Hash];
     buffer.insert(buffer.end(), chunkData.begin(), chunkData.end());
 
-    LOG_INFO("WardenModuleManager: Received chunk (", chunkData.size(),
-             " bytes, total: ", buffer.size(), ")");
+    std::cout << "[WardenModuleManager] Received chunk (" << chunkData.size()
+              << " bytes, total: " << buffer.size() << ")" << '\n';
 
     if (isComplete) {
-        LOG_INFO("WardenModuleManager: Module download complete (", buffer.size(), " bytes)");
+        std::cout << "[WardenModuleManager] Module download complete ("
+                  << buffer.size() << " bytes)" << '\n';
 
         // Cache to disk
         cacheModule(md5Hash, buffer);
@@ -1260,14 +1089,14 @@ bool WardenModuleManager::cacheModule(const std::vector<uint8_t>& md5Hash,
 
     std::ofstream file(cachePath, std::ios::binary);
     if (!file) {
-        LOG_ERROR("WardenModuleManager: Failed to write cache: ", cachePath);
+        std::cerr << "[WardenModuleManager] Failed to write cache: " << cachePath << '\n';
         return false;
     }
 
     file.write(reinterpret_cast<const char*>(moduleData.data()), moduleData.size());
     file.close();
 
-    LOG_INFO("WardenModuleManager: Cached module to: ", cachePath);
+    std::cout << "[WardenModuleManager] Cached module to: " << cachePath << '\n';
     return true;
 }
 
@@ -1291,7 +1120,7 @@ bool WardenModuleManager::loadCachedModule(const std::vector<uint8_t>& md5Hash,
     file.read(reinterpret_cast<char*>(moduleDataOut.data()), fileSize);
     file.close();
 
-    LOG_INFO("WardenModuleManager: Loaded cached module (", fileSize, " bytes)");
+    std::cout << "[WardenModuleManager] Loaded cached module (" << fileSize << " bytes)" << '\n';
     return true;
 }
 
diff --git a/src/game/world_packets.cpp b/src/game/world_packets.cpp
index 8df1dec0..c83563f0 100644
--- a/src/game/world_packets.cpp
+++ b/src/game/world_packets.cpp
@@ -5,9 +5,7 @@
 #include "auth/crypto.hpp"
 #include "core/logger.hpp"
 #include <algorithm>
-#include <array>
 #include <cctype>
-#include <cmath>
 #include <cstring>
 #include <sstream>
 #include <iomanip>
@@ -21,19 +19,6 @@ namespace {
     inline uint16_t bswap16(uint16_t v) {
         return static_cast<uint16_t>(((v & 0xFF00u) >> 8) | ((v & 0x00FFu) << 8));
     }
-
-    const char* updateTypeName(wowee::game::UpdateType type) {
-        using wowee::game::UpdateType;
-        switch (type) {
-            case UpdateType::VALUES: return "VALUES";
-            case UpdateType::MOVEMENT: return "MOVEMENT";
-            case UpdateType::CREATE_OBJECT: return "CREATE_OBJECT";
-            case UpdateType::CREATE_OBJECT2: return "CREATE_OBJECT2";
-            case UpdateType::OUT_OF_RANGE_OBJECTS: return "OUT_OF_RANGE_OBJECTS";
-            case UpdateType::NEAR_OBJECTS: return "NEAR_OBJECTS";
-            default: return "UNKNOWN";
-        }
-    }
 }
 
 namespace wowee {
@@ -81,7 +66,7 @@ network::Packet AuthSessionPacket::build(uint32_t build,
     // Convert account name to uppercase
     std::string upperAccount = accountName;
     std::transform(upperAccount.begin(), upperAccount.end(),
-                   upperAccount.begin(), [](unsigned char c) { return static_cast<char>(std::toupper(c)); });
+                   upperAccount.begin(), ::toupper);
 
     LOG_INFO("Building CMSG_AUTH_SESSION for account: ", upperAccount);
 
@@ -186,8 +171,15 @@ network::Packet AuthSessionPacket::build(uint32_t build,
     LOG_INFO("CMSG_AUTH_SESSION packet built: ", packet.getSize(), " bytes");
 
     // Dump full packet for protocol debugging
-    LOG_DEBUG("CMSG_AUTH_SESSION full dump:\n",
-              core::toHexString(packet.getData().data(), packet.getData().size(), true));
+    const auto& data = packet.getData();
+    std::string hexDump;
+    for (size_t i = 0; i < data.size(); ++i) {
+        char buf[4];
+        snprintf(buf, sizeof(buf), "%02x ", data[i]);
+        hexDump += buf;
+        if ((i + 1) % 16 == 0) hexDump += "\n";
+    }
+    LOG_DEBUG("CMSG_AUTH_SESSION full dump:\n", hexDump);
 
     return packet;
 }
@@ -228,14 +220,33 @@ std::vector<uint8_t> AuthSessionPacket::computeAuthHash(
     hashInput.insert(hashInput.end(), sessionKey.begin(), sessionKey.end());
 
     // Diagnostic: dump auth hash inputs for debugging AUTH_REJECT
-    LOG_DEBUG("AUTH HASH: account='", accountName, "' clientSeed=0x", std::hex, clientSeed,
-              " serverSeed=0x", serverSeed, std::dec);
-    LOG_DEBUG("AUTH HASH: sessionKey=", core::toHexString(sessionKey.data(), sessionKey.size()));
-    LOG_DEBUG("AUTH HASH: input(", hashInput.size(), ")=", core::toHexString(hashInput.data(), hashInput.size()));
+    {
+        auto toHex = [](const uint8_t* data, size_t len) {
+            std::string s;
+            for (size_t i = 0; i < len; ++i) {
+                char buf[4]; snprintf(buf, sizeof(buf), "%02x", data[i]); s += buf;
+            }
+            return s;
+        };
+        LOG_INFO("AUTH HASH: account='", accountName, "' clientSeed=0x", std::hex, clientSeed,
+                 " serverSeed=0x", serverSeed, std::dec);
+        LOG_INFO("AUTH HASH: sessionKey=", toHex(sessionKey.data(), sessionKey.size()));
+        LOG_INFO("AUTH HASH: input(", hashInput.size(), ")=", toHex(hashInput.data(), hashInput.size()));
+    }
 
     // Compute SHA1 hash
     auto result = auth::Crypto::sha1(hashInput);
-    LOG_DEBUG("AUTH HASH: digest=", core::toHexString(result.data(), result.size()));
+
+    {
+        auto toHex = [](const uint8_t* data, size_t len) {
+            std::string s;
+            for (size_t i = 0; i < len; ++i) {
+                char buf[4]; snprintf(buf, sizeof(buf), "%02x", data[i]); s += buf;
+            }
+            return s;
+        };
+        LOG_INFO("AUTH HASH: digest=", toHex(result.data(), result.size()));
+    }
 
     return result;
 }
@@ -254,22 +265,22 @@ bool AuthChallengeParser::parse(network::Packet& packet, AuthChallengeData& data
         // Original vanilla/TBC format: just the server seed (4 bytes)
         data.unknown1 = 0;
         data.serverSeed = packet.readUInt32();
-        LOG_INFO("SMSG_AUTH_CHALLENGE: TBC format (", packet.getSize(), " bytes)");
+        LOG_INFO("Parsed SMSG_AUTH_CHALLENGE (TBC format, 4 bytes):");
     } else if (packet.getSize() < 40) {
         // Vanilla with encryption seeds (36 bytes): serverSeed + 32 bytes seeds
         // No "unknown1" prefix — first uint32 IS the server seed
         data.unknown1 = 0;
         data.serverSeed = packet.readUInt32();
-        LOG_INFO("SMSG_AUTH_CHALLENGE: Classic+seeds format (", packet.getSize(), " bytes)");
+        LOG_INFO("Parsed SMSG_AUTH_CHALLENGE (Classic+seeds format, ", packet.getSize(), " bytes):");
     } else {
         // WotLK format (40+ bytes): unknown1 + serverSeed + 32 bytes encryption seeds
         data.unknown1 = packet.readUInt32();
         data.serverSeed = packet.readUInt32();
-        LOG_INFO("SMSG_AUTH_CHALLENGE: WotLK format (", packet.getSize(), " bytes)");
-        LOG_DEBUG("  Unknown1: 0x", std::hex, data.unknown1, std::dec);
+        LOG_INFO("Parsed SMSG_AUTH_CHALLENGE (WotLK format, ", packet.getSize(), " bytes):");
+        LOG_INFO("  Unknown1: 0x", std::hex, data.unknown1, std::dec);
     }
 
-    LOG_DEBUG("  Server seed: 0x", std::hex, data.serverSeed, std::dec);
+    LOG_INFO("  Server seed: 0x", std::hex, data.serverSeed, std::dec);
 
     return true;
 }
@@ -380,19 +391,19 @@ network::Packet CharCreatePacket::build(const CharCreateData& data) {
               " facial=", static_cast<int>(data.facialHair));
 
     // Dump full packet for protocol debugging
-    LOG_DEBUG("CMSG_CHAR_CREATE full dump: ",
-              core::toHexString(packet.getData().data(), packet.getData().size(), true));
+    const auto& pktData = packet.getData();
+    std::string hexDump;
+    for (size_t i = 0; i < pktData.size(); ++i) {
+        char buf[4];
+        snprintf(buf, sizeof(buf), "%02x ", pktData[i]);
+        hexDump += buf;
+    }
+    LOG_DEBUG("CMSG_CHAR_CREATE full dump: ", hexDump);
 
     return packet;
 }
 
 bool CharCreateResponseParser::parse(network::Packet& packet, CharCreateResponseData& data) {
-    // Validate minimum packet size: result(1)
-    if (!packet.hasRemaining(1)) {
-        LOG_WARNING("SMSG_CHAR_CREATE: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
     data.result = static_cast<CharCreateResult>(packet.readUInt8());
     LOG_INFO("SMSG_CHAR_CREATE result: ", static_cast<int>(data.result));
     return true;
@@ -408,13 +419,10 @@ network::Packet CharEnumPacket::build() {
 }
 
 bool CharEnumParser::parse(network::Packet& packet, CharEnumResponse& response) {
-    // Upfront validation: count(1) + at least minimal character data
-    if (!packet.hasRemaining(1)) return false;
-
     // Read character count
     uint8_t count = packet.readUInt8();
 
-    LOG_INFO("Parsing SMSG_CHAR_ENUM: ", static_cast<int>(count), " characters");
+    LOG_INFO("Parsing SMSG_CHAR_ENUM: ", (int)count, " characters");
 
     response.characters.clear();
     response.characters.reserve(count);
@@ -422,126 +430,49 @@ bool CharEnumParser::parse(network::Packet& packet, CharEnumResponse& response)
     for (uint8_t i = 0; i < count; ++i) {
         Character character;
 
-        // Validate minimum bytes for this character entry before reading:
-        // GUID(8) + name(>=1 for empty string) + race(1) + class(1) + gender(1) +
-        // appearanceBytes(4) + facialFeatures(1) + level(1) + zoneId(4) + mapId(4) +
-        // x(4) + y(4) + z(4) + guildId(4) + flags(4) + customization(4) + unknown(1) +
-        // petDisplayModel(4) + petLevel(4) + petFamily(4) + 23items*(dispModel(4)+invType(1)+enchant(4)) = 207 bytes
-        const size_t minCharacterSize = 8 + 1 + 1 + 1 + 1 + 4 + 1 + 1 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 1 + 4 + 4 + 4 + (23 * 9);
-        if (!packet.hasRemaining(minCharacterSize)) {
-            LOG_WARNING("CharEnumParser: truncated character at index ", static_cast<int>(i));
-            break;
-        }
-
         // Read GUID (8 bytes, little-endian)
         character.guid = packet.readUInt64();
 
-        // Read name (null-terminated string) - validate before reading
-        if (!packet.hasData()) {
-            LOG_WARNING("CharEnumParser: no bytes for name at index ", static_cast<int>(i));
-            break;
-        }
+        // Read name (null-terminated string)
         character.name = packet.readString();
 
-        // Validate remaining bytes before reading fixed-size fields
-        if (!packet.hasRemaining(1)) {
-            LOG_WARNING("CharEnumParser: truncated before race/class/gender at index ", static_cast<int>(i));
-            character.race = Race::HUMAN;
-            character.characterClass = Class::WARRIOR;
-            character.gender = Gender::MALE;
-        } else {
-            // Read race, class, gender
-            character.race = static_cast<Race>(packet.readUInt8());
-            if (!packet.hasRemaining(1)) {
-                character.characterClass = Class::WARRIOR;
-                character.gender = Gender::MALE;
-            } else {
-                character.characterClass = static_cast<Class>(packet.readUInt8());
-                if (!packet.hasRemaining(1)) {
-                    character.gender = Gender::MALE;
-                } else {
-                    character.gender = static_cast<Gender>(packet.readUInt8());
-                }
-            }
-        }
+        // Read race, class, gender
+        character.race = static_cast<Race>(packet.readUInt8());
+        character.characterClass = static_cast<Class>(packet.readUInt8());
+        character.gender = static_cast<Gender>(packet.readUInt8());
 
-        // Validate before reading appearance data
-        if (!packet.hasRemaining(4)) {
-            character.appearanceBytes = 0;
-            character.facialFeatures = 0;
-        } else {
-            // Read appearance data
-            character.appearanceBytes = packet.readUInt32();
-            if (!packet.hasRemaining(1)) {
-                character.facialFeatures = 0;
-            } else {
-                character.facialFeatures = packet.readUInt8();
-            }
-        }
+        // Read appearance data
+        character.appearanceBytes = packet.readUInt32();
+        character.facialFeatures = packet.readUInt8();
 
         // Read level
-        if (!packet.hasRemaining(1)) {
-            character.level = 1;
-        } else {
-            character.level = packet.readUInt8();
-        }
+        character.level = packet.readUInt8();
 
         // Read location
-        if (!packet.hasRemaining(12)) {
-            character.zoneId = 0;
-            character.mapId = 0;
-            character.x = 0.0f;
-            character.y = 0.0f;
-            character.z = 0.0f;
-        } else {
-            character.zoneId = packet.readUInt32();
-            character.mapId = packet.readUInt32();
-            character.x = packet.readFloat();
-            character.y = packet.readFloat();
-            character.z = packet.readFloat();
-        }
+        character.zoneId = packet.readUInt32();
+        character.mapId = packet.readUInt32();
+        character.x = packet.readFloat();
+        character.y = packet.readFloat();
+        character.z = packet.readFloat();
 
         // Read affiliations
-        if (!packet.hasRemaining(4)) {
-            character.guildId = 0;
-        } else {
-            character.guildId = packet.readUInt32();
-        }
+        character.guildId = packet.readUInt32();
 
         // Read flags
-        if (!packet.hasRemaining(4)) {
-            character.flags = 0;
-        } else {
-            character.flags = packet.readUInt32();
-        }
+        character.flags = packet.readUInt32();
 
         // Skip customization flag (uint32) and unknown byte
-        if (!packet.hasRemaining(4)) {
-            // Customization missing, skip unknown
-        } else {
-            packet.readUInt32();  // Customization
-            if (!packet.hasRemaining(1)) {
-                // Unknown missing
-            } else {
-                packet.readUInt8();   // Unknown
-            }
-        }
+        packet.readUInt32();  // Customization
+        packet.readUInt8();   // Unknown
 
         // Read pet data (always present, even if no pet)
-        if (!packet.hasRemaining(12)) {
-            character.pet.displayModel = 0;
-            character.pet.level = 0;
-            character.pet.family = 0;
-        } else {
-            character.pet.displayModel = packet.readUInt32();
-            character.pet.level = packet.readUInt32();
-            character.pet.family = packet.readUInt32();
-        }
+        character.pet.displayModel = packet.readUInt32();
+        character.pet.level = packet.readUInt32();
+        character.pet.family = packet.readUInt32();
 
         // Read equipment (23 items)
         character.equipment.reserve(23);
         for (int j = 0; j < 23; ++j) {
-            if (!packet.hasRemaining(9)) break;
             EquipmentItem item;
             item.displayModel = packet.readUInt32();
             item.inventoryType = packet.readUInt8();
@@ -549,9 +480,21 @@ bool CharEnumParser::parse(network::Packet& packet, CharEnumResponse& response)
             character.equipment.push_back(item);
         }
 
-        LOG_DEBUG("  Character ", static_cast<int>(i + 1), ": ", character.name,
-                  " (", getRaceName(character.race), " ", getClassName(character.characterClass),
-                  " level ", static_cast<int>(character.level), " zone ", character.zoneId, ")");
+        LOG_INFO("  Character ", (int)(i + 1), ": ", character.name);
+        LOG_INFO("    GUID: 0x", std::hex, character.guid, std::dec);
+        LOG_INFO("    ", getRaceName(character.race), " ",
+                 getClassName(character.characterClass), " (",
+                 getGenderName(character.gender), ")");
+        LOG_INFO("    Level: ", (int)character.level);
+        LOG_INFO("    Location: Zone ", character.zoneId, ", Map ", character.mapId);
+        LOG_INFO("    Position: (", character.x, ", ", character.y, ", ", character.z, ")");
+        if (character.hasGuild()) {
+            LOG_INFO("    Guild ID: ", character.guildId);
+        }
+        if (character.hasPet()) {
+            LOG_INFO("    Pet: Model ", character.pet.displayModel,
+                     ", Level ", character.pet.level);
+        }
 
         response.characters.push_back(character);
     }
@@ -615,18 +558,18 @@ bool AccountDataTimesParser::parse(network::Packet& packet, AccountDataTimesData
     data.serverTime = packet.readUInt32();
     data.unknown = packet.readUInt8();
 
-    size_t remaining = packet.getRemainingSize();
+    size_t remaining = packet.getSize() - packet.getReadPos();
     uint32_t mask = 0xFF;
     if (remaining >= 4 && ((remaining - 4) % 4) == 0) {
         // Treat first dword as slot mask when payload shape matches.
         mask = packet.readUInt32();
     }
-    remaining = packet.getRemainingSize();
+    remaining = packet.getSize() - packet.getReadPos();
     size_t slotWords = std::min<size_t>(8, remaining / 4);
 
     LOG_DEBUG("Parsed SMSG_ACCOUNT_DATA_TIMES:");
     LOG_DEBUG("  Server time: ", data.serverTime);
-    LOG_DEBUG("  Unknown: ", static_cast<int>(data.unknown));
+    LOG_DEBUG("  Unknown: ", (int)data.unknown);
     LOG_DEBUG("  Mask: 0x", std::hex, mask, std::dec, " slotsInPacket=", slotWords);
 
     for (size_t i = 0; i < slotWords; ++i) {
@@ -636,8 +579,8 @@ bool AccountDataTimesParser::parse(network::Packet& packet, AccountDataTimesData
         }
     }
     if (packet.getReadPos() != packet.getSize()) {
-        LOG_DEBUG("  AccountDataTimes trailing bytes: ", packet.getRemainingSize());
-        packet.skipAll();
+        LOG_DEBUG("  AccountDataTimes trailing bytes: ", packet.getSize() - packet.getReadPos());
+        packet.setReadPos(packet.getSize());
     }
 
     return true;
@@ -655,27 +598,16 @@ bool MotdParser::parse(network::Packet& packet, MotdData& data) {
 
     uint32_t lineCount = packet.readUInt32();
 
-    // Cap lineCount to prevent unbounded memory allocation
-    const uint32_t MAX_MOTD_LINES = 64;
-    if (lineCount > MAX_MOTD_LINES) {
-        LOG_WARNING("MotdParser: lineCount capped (requested=", lineCount, ")");
-        lineCount = MAX_MOTD_LINES;
-    }
-
-    LOG_INFO("Parsed SMSG_MOTD: ", lineCount, " line(s)");
+    LOG_INFO("Parsed SMSG_MOTD:");
+    LOG_INFO("  Line count: ", lineCount);
 
     data.lines.clear();
     data.lines.reserve(lineCount);
 
     for (uint32_t i = 0; i < lineCount; ++i) {
-        // Validate at least 1 byte available for the string
-        if (!packet.hasData()) {
-            LOG_WARNING("MotdParser: truncated at line ", i + 1);
-            break;
-        }
         std::string line = packet.readString();
         data.lines.push_back(line);
-        LOG_DEBUG("  MOTD[", i + 1, "]: ", line);
+        LOG_INFO("  [", i + 1, "] ", line);
     }
 
     return true;
@@ -714,6 +646,23 @@ bool PongParser::parse(network::Packet& packet, PongData& data) {
     return true;
 }
 
+void MovementPacket::writePackedGuid(network::Packet& packet, uint64_t guid) {
+    uint8_t mask = 0;
+    uint8_t guidBytes[8];
+    int guidByteCount = 0;
+    for (int i = 0; i < 8; i++) {
+        uint8_t byte = static_cast<uint8_t>((guid >> (i * 8)) & 0xFF);
+        if (byte != 0) {
+            mask |= (1 << i);
+            guidBytes[guidByteCount++] = byte;
+        }
+    }
+    packet.writeUInt8(mask);
+    for (int i = 0; i < guidByteCount; i++) {
+        packet.writeUInt8(guidBytes[i]);
+    }
+}
+
 void MovementPacket::writeMovementPayload(network::Packet& packet, const MovementInfo& info) {
     // Movement packet format (WoW 3.3.5a) payload:
     // uint32 flags
@@ -730,24 +679,37 @@ void MovementPacket::writeMovementPayload(network::Packet& packet, const Movemen
     packet.writeUInt32(info.time);
 
     // Write position
-    packet.writeFloat(info.x);
-    packet.writeFloat(info.y);
-    packet.writeFloat(info.z);
+    packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.x), sizeof(float));
+    packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.y), sizeof(float));
+    packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.z), sizeof(float));
 
     // Write orientation
-    packet.writeFloat(info.orientation);
+    packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.orientation), sizeof(float));
 
     // Write transport data if on transport.
     // 3.3.5a ordering: transport block appears before pitch/fall/jump.
     if (info.hasFlag(MovementFlags::ONTRANSPORT)) {
         // Write packed transport GUID
-        packet.writePackedGuid(info.transportGuid);
+        uint8_t transMask = 0;
+        uint8_t transGuidBytes[8];
+        int transGuidByteCount = 0;
+        for (int i = 0; i < 8; i++) {
+            uint8_t byte = static_cast<uint8_t>((info.transportGuid >> (i * 8)) & 0xFF);
+            if (byte != 0) {
+                transMask |= (1 << i);
+                transGuidBytes[transGuidByteCount++] = byte;
+            }
+        }
+        packet.writeUInt8(transMask);
+        for (int i = 0; i < transGuidByteCount; i++) {
+            packet.writeUInt8(transGuidBytes[i]);
+        }
 
         // Write transport local position
-        packet.writeFloat(info.transportX);
-        packet.writeFloat(info.transportY);
-        packet.writeFloat(info.transportZ);
-        packet.writeFloat(info.transportO);
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.transportX), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.transportY), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.transportZ), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.transportO), sizeof(float));
 
         // Write transport time
         packet.writeUInt32(info.transportTime);
@@ -756,14 +718,14 @@ void MovementPacket::writeMovementPayload(network::Packet& packet, const Movemen
         packet.writeUInt8(static_cast<uint8_t>(info.transportSeat));
 
         // Optional second transport time for interpolated movement.
-        if (info.flags2 & 0x0400) { // MOVEMENTFLAG2_INTERPOLATED_MOVEMENT
+        if (info.flags2 & 0x0200) {
             packet.writeUInt32(info.transportTime2);
         }
     }
 
     // Write pitch if swimming/flying
     if (info.hasFlag(MovementFlags::SWIMMING) || info.hasFlag(MovementFlags::FLYING)) {
-        packet.writeFloat(info.pitch);
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.pitch), sizeof(float));
     }
 
     // Fall time is ALWAYS present in the packet (server reads it unconditionally).
@@ -771,10 +733,10 @@ void MovementPacket::writeMovementPayload(network::Packet& packet, const Movemen
     packet.writeUInt32(info.fallTime);
 
     if (info.hasFlag(MovementFlags::FALLING)) {
-        packet.writeFloat(info.jumpVelocity);
-        packet.writeFloat(info.jumpSinAngle);
-        packet.writeFloat(info.jumpCosAngle);
-        packet.writeFloat(info.jumpXYSpeed);
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.jumpVelocity), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.jumpSinAngle), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.jumpCosAngle), sizeof(float));
+        packet.writeBytes(reinterpret_cast<const uint8_t*>(&info.jumpXYSpeed), sizeof(float));
     }
 }
 
@@ -783,7 +745,7 @@ network::Packet MovementPacket::build(Opcode opcode, const MovementInfo& info, u
 
     // Movement packet format (WoW 3.3.5a):
     // packed GUID + movement payload
-    packet.writePackedGuid(playerGuid);
+    writePackedGuid(packet, playerGuid);
     writeMovementPayload(packet, info);
 
     // Detailed hex dump for debugging
@@ -812,14 +774,31 @@ network::Packet MovementPacket::build(Opcode opcode, const MovementInfo& info, u
     return packet;
 }
 
+uint64_t UpdateObjectParser::readPackedGuid(network::Packet& packet) {
+    // Read packed GUID format:
+    // First byte is a mask indicating which bytes are present
+    uint8_t mask = packet.readUInt8();
+
+    if (mask == 0) {
+        return 0;
+    }
+
+    uint64_t guid = 0;
+    for (int i = 0; i < 8; ++i) {
+        if (mask & (1 << i)) {
+            uint8_t byte = packet.readUInt8();
+            guid |= (static_cast<uint64_t>(byte) << (i * 8));
+        }
+    }
+
+    return guid;
+}
+
 bool UpdateObjectParser::parseMovementBlock(network::Packet& packet, UpdateBlock& block) {
     // WoW 3.3.5a UPDATE_OBJECT movement block structure:
     // 1. UpdateFlags (1 byte, sometimes 2)
     // 2. Movement data depends on update flags
 
-    auto rem = [&]() -> size_t { return packet.getRemainingSize(); };
-    if (rem() < 2) return false;
-
     // Update flags (3.3.5a uses 2 bytes for flags)
     uint16_t updateFlags = packet.readUInt16();
     block.updateFlags = updateFlags;
@@ -864,9 +843,6 @@ bool UpdateObjectParser::parseMovementBlock(network::Packet& packet, UpdateBlock
     const uint16_t UPDATEFLAG_HIGHGUID = 0x0010;
 
     if (updateFlags & UPDATEFLAG_LIVING) {
-        // Minimum: moveFlags(4)+moveFlags2(2)+time(4)+position(16)+fallTime(4)+speeds(36) = 66
-        if (rem() < 66) return false;
-
         // Full movement block for living units
         uint32_t moveFlags = packet.readUInt32();
         uint16_t moveFlags2 = packet.readUInt16();
@@ -884,10 +860,8 @@ bool UpdateObjectParser::parseMovementBlock(network::Packet& packet, UpdateBlock
 
         // Transport data (if on transport)
         if (moveFlags & 0x00000200) { // MOVEMENTFLAG_ONTRANSPORT
-            if (rem() < 1) return false;
             block.onTransport = true;
-            block.transportGuid = packet.readPackedGuid();
-            if (rem() < 21) return false; // 4 floats + uint32 + uint8
+            block.transportGuid = readPackedGuid(packet);
             block.transportX = packet.readFloat();
             block.transportY = packet.readFloat();
             block.transportZ = packet.readFloat();
@@ -898,38 +872,21 @@ bool UpdateObjectParser::parseMovementBlock(network::Packet& packet, UpdateBlock
             LOG_DEBUG("  OnTransport: guid=0x", std::hex, block.transportGuid, std::dec,
                       " offset=(", block.transportX, ", ", block.transportY, ", ", block.transportZ, ")");
 
-            if (moveFlags2 & 0x0400) { // MOVEMENTFLAG2_INTERPOLATED_MOVEMENT
-                if (rem() < 4) return false;
+            if (moveFlags2 & 0x0200) { // MOVEMENTFLAG2_INTERPOLATED_MOVEMENT
                 /*uint32_t tTime2 =*/ packet.readUInt32();
             }
         }
 
         // Swimming/flying pitch
-        // WotLK 3.3.5a movement flags (wire format):
-        //   SWIMMING          = 0x00200000
-        //   CAN_FLY           = 0x01000000  (ability to fly — no pitch field)
-        //   FLYING            = 0x02000000  (actively flying — has pitch field)
-        //   SPLINE_ELEVATION  = 0x04000000  (smooth vertical spline offset)
-        // MovementFlags2:
-        //   MOVEMENTFLAG2_ALWAYS_ALLOW_PITCHING = 0x0020
-        //
-        // Pitch is present when SWIMMING or FLYING are set, or the always-allow flag is set.
-        // Note: CAN_FLY (0x01000000) does NOT gate pitch; only FLYING (0x02000000) does.
-        // (TBC uses 0x01000000 for FLYING — see TbcMoveFlags in packet_parsers_tbc.cpp.)
-        if ((moveFlags & 0x00200000) /* SWIMMING */ ||
-            (moveFlags & 0x02000000) /* FLYING */ ||
-            (moveFlags2 & 0x0020)    /* MOVEMENTFLAG2_ALWAYS_ALLOW_PITCHING */) {
-            if (rem() < 4) return false;
+        if ((moveFlags & 0x02000000) || (moveFlags2 & 0x0010)) { // MOVEMENTFLAG_SWIMMING or MOVEMENTFLAG2_ALWAYS_ALLOW_PITCHING
             /*float pitch =*/ packet.readFloat();
         }
 
         // Fall time
-        if (rem() < 4) return false;
         /*uint32_t fallTime =*/ packet.readUInt32();
 
         // Jumping
         if (moveFlags & 0x00001000) { // MOVEMENTFLAG_FALLING
-            if (rem() < 16) return false;
             /*float jumpVelocity =*/ packet.readFloat();
             /*float jumpSinAngle =*/ packet.readFloat();
             /*float jumpCosAngle =*/ packet.readFloat();
@@ -938,12 +895,10 @@ bool UpdateObjectParser::parseMovementBlock(network::Packet& packet, UpdateBlock
 
         // Spline elevation
         if (moveFlags & 0x04000000) { // MOVEMENTFLAG_SPLINE_ELEVATION
-            if (rem() < 4) return false;
             /*float splineElevation =*/ packet.readFloat();
         }
 
-        // Speeds (9 values in WotLK: walk/run/runBack/swim/swimBack/flight/flightBack/turn/pitch)
-        if (rem() < 36) return false;
+        // Speeds (7 speed values)
         /*float walkSpeed =*/ packet.readFloat();
         float runSpeed = packet.readFloat();
         /*float runBackSpeed =*/ packet.readFloat();
@@ -955,11 +910,10 @@ bool UpdateObjectParser::parseMovementBlock(network::Packet& packet, UpdateBlock
         /*float pitchRate =*/ packet.readFloat();
 
         block.runSpeed = runSpeed;
-        block.moveFlags = moveFlags;
 
         // Spline data
         if (moveFlags & 0x08000000) { // MOVEMENTFLAG_SPLINE_ENABLED
-            auto bytesAvailable = [&](size_t n) -> bool { return packet.hasRemaining(n); };
+            auto bytesAvailable = [&](size_t n) -> bool { return packet.getReadPos() + n <= packet.getSize(); };
             if (!bytesAvailable(4)) return false;
             uint32_t splineFlags = packet.readUInt32();
             LOG_DEBUG("  Spline: flags=0x", std::hex, splineFlags, std::dec);
@@ -977,124 +931,86 @@ bool UpdateObjectParser::parseMovementBlock(network::Packet& packet, UpdateBlock
                 /*float finalAngle =*/ packet.readFloat();
             }
 
-            // WotLK spline data layout:
-            //   timePassed(4)+duration(4)+splineId(4)+durationMod(4)+durationModNext(4)
-            //   +[ANIMATION(5)]+verticalAccel(4)+effectStartTime(4)+pointCount(4)+points+mode(1)+endPoint(12)
-            if (!bytesAvailable(12)) return false;
+            // Legacy UPDATE_OBJECT spline layout used by many servers:
+            // timePassed, duration, splineId, durationMod, durationModNext,
+            // verticalAccel, effectStartTime, pointCount, points, splineMode, endPoint.
+            const size_t legacyStart = packet.getReadPos();
+            if (!bytesAvailable(12 + 8 + 8 + 4)) return false;
             /*uint32_t timePassed =*/ packet.readUInt32();
             /*uint32_t duration =*/ packet.readUInt32();
             /*uint32_t splineId =*/ packet.readUInt32();
+            /*float durationMod =*/ packet.readFloat();
+            /*float durationModNext =*/ packet.readFloat();
+            /*float verticalAccel =*/ packet.readFloat();
+            /*uint32_t effectStartTime =*/ packet.readUInt32();
+            uint32_t pointCount = packet.readUInt32();
 
-            // Helper: parse spline points + splineMode + endPoint.
-            // WotLK uses compressed points by default (first=12 bytes, rest=4 bytes packed).
-            auto tryParseSplinePoints = [&](bool compressed, const char* tag) -> bool {
-                if (!bytesAvailable(4)) return false;
-                size_t prePointCount = packet.getReadPos();
-                uint32_t pc = packet.readUInt32();
-                if (pc > 256) return false;
-                size_t pointsBytes;
-                if (compressed && pc > 0) {
-                    // First point = 3 floats (12 bytes), rest = packed uint32 (4 bytes each)
-                    pointsBytes = 12ull + (pc > 1 ? static_cast<size_t>(pc - 1) * 4ull : 0ull);
-                } else {
-                    // All uncompressed: 3 floats each
-                    pointsBytes = static_cast<size_t>(pc) * 12ull;
-                }
-                size_t needed = pointsBytes + 13ull; // + splineMode(1) + endPoint(12)
-                if (!bytesAvailable(needed)) {
-                    packet.setReadPos(prePointCount);
-                    return false;
-                }
-                packet.setReadPos(packet.getReadPos() + pointsBytes);
-                uint8_t splineMode = packet.readUInt8();
-                if (splineMode > 3) {
-                    packet.setReadPos(prePointCount);
-                    return false;
-                }
-                float epX = packet.readFloat();
-                float epY = packet.readFloat();
-                float epZ = packet.readFloat();
-                // Validate endPoint: garbage bytes rarely produce finite world coords
-                if (!std::isfinite(epX) || !std::isfinite(epY) || !std::isfinite(epZ) ||
-                    std::fabs(epX) > 65000.0f || std::fabs(epY) > 65000.0f ||
-                    std::fabs(epZ) > 65000.0f) {
-                    packet.setReadPos(prePointCount);
-                    return false;
-                }
-                LOG_DEBUG("  Spline pointCount=", pc, " compressed=", compressed,
-                          " endPt=(", epX, ",", epY, ",", epZ, ") (", tag, ")");
-                return true;
-            };
+            const size_t remainingAfterCount = packet.getSize() - packet.getReadPos();
+            const bool legacyCountLooksValid = (pointCount <= 256);
+            const size_t legacyPointsBytes = static_cast<size_t>(pointCount) * 12ull;
+            const bool legacyPayloadFits = (legacyPointsBytes + 13ull) <= remainingAfterCount;
 
-            // Save position before WotLK spline header for fallback
-            size_t beforeSplineHeader = packet.getReadPos();
-
-            // Try 1: WotLK format (durationMod+durationModNext+[ANIMATION]+vertAccel+effectStart+points)
-            bool splineParsed = false;
-            if (bytesAvailable(8)) {
-                /*float durationMod =*/ packet.readFloat();
-                /*float durationModNext =*/ packet.readFloat();
-                bool wotlkOk = true;
-                if (splineFlags & 0x00400000) { // SPLINEFLAG_ANIMATION
-                    if (!bytesAvailable(5)) { wotlkOk = false; }
-                    else { packet.readUInt8(); packet.readUInt32(); }
-                }
-                // AzerothCore/ChromieCraft always writes verticalAcceleration(float)
-                // + effectStartTime(uint32) unconditionally -- NOT gated by PARABOLIC flag.
-                if (wotlkOk) {
-                    if (!bytesAvailable(8)) { wotlkOk = false; }
-                    else { /*float vertAccel =*/ packet.readFloat(); /*uint32_t effectStart =*/ packet.readUInt32(); }
-                }
-                if (wotlkOk) {
-                    // WotLK: compressed unless CYCLIC(0x80000) or ENTER_CYCLE(0x2000) set
-                    bool useCompressed = (splineFlags & (0x00080000 | 0x00002000)) == 0;
-                    splineParsed = tryParseSplinePoints(useCompressed, "wotlk-compressed");
-                    if (!splineParsed) {
-                        splineParsed = tryParseSplinePoints(false, "wotlk-uncompressed");
-                    }
+            if (legacyCountLooksValid && legacyPayloadFits) {
+                for (uint32_t i = 0; i < pointCount; i++) {
+                    /*float px =*/ packet.readFloat();
+                    /*float py =*/ packet.readFloat();
+                    /*float pz =*/ packet.readFloat();
                 }
+                /*uint8_t splineMode =*/ packet.readUInt8();
+                /*float endPointX =*/ packet.readFloat();
+                /*float endPointY =*/ packet.readFloat();
+                /*float endPointZ =*/ packet.readFloat();
+                LOG_DEBUG("  Spline pointCount=", pointCount, " (legacy)");
+            } else {
+            // Legacy pointCount looks invalid; try compact WotLK layout as recovery.
+            // This keeps malformed/variant packets from desyncing the whole update block.
+            packet.setReadPos(legacyStart);
+            const size_t afterFinalFacingPos = packet.getReadPos();
+            if (splineFlags & 0x00400000) { // Animation
+                if (!bytesAvailable(5)) return false;
+                /*uint8_t animType =*/ packet.readUInt8();
+                /*uint32_t animStart =*/ packet.readUInt32();
             }
-
-            if (!splineParsed) {
-                // WotLK compressed+uncompressed both failed. Try without the parabolic
-                // fields (some cores don't send vertAccel+effectStart unconditionally).
-                packet.setReadPos(beforeSplineHeader);
-                if (bytesAvailable(8)) {
-                    packet.readFloat(); // durationMod
-                    packet.readFloat(); // durationModNext
-                    // Skip parabolic fields — try points directly
-                    splineParsed = tryParseSplinePoints(false, "wotlk-no-parabolic");
-                    if (!splineParsed) {
-                        bool useComp = (splineFlags & (0x00080000 | 0x00002000)) == 0;
-                        splineParsed = tryParseSplinePoints(useComp, "wotlk-no-parabolic-compressed");
-                    }
-                }
+            if (!bytesAvailable(4)) return false;
+            /*uint32_t duration =*/ packet.readUInt32();
+            if (splineFlags & 0x00000800) { // Parabolic
+                if (!bytesAvailable(8)) return false;
+                /*float verticalAccel =*/ packet.readFloat();
+                /*uint32_t effectStartTime =*/ packet.readUInt32();
             }
-
-            // Try 3: bare points (no WotLK header at all — some spline types skip everything)
-            if (!splineParsed) {
-                packet.setReadPos(beforeSplineHeader);
-                splineParsed = tryParseSplinePoints(false, "bare-uncompressed");
-                if (!splineParsed) {
-                    packet.setReadPos(beforeSplineHeader);
-                    bool useComp = (splineFlags & (0x00080000 | 0x00002000)) == 0;
-                    splineParsed = tryParseSplinePoints(useComp, "bare-compressed");
+            if (!bytesAvailable(4)) return false;
+            const uint32_t compactPointCount = packet.readUInt32();
+            if (compactPointCount > 16384) {
+                static uint32_t badSplineCount = 0;
+                ++badSplineCount;
+                if (badSplineCount <= 5 || (badSplineCount % 100) == 0) {
+                    LOG_WARNING("  Spline pointCount=", pointCount,
+                                " invalid (legacy+compact) at readPos=",
+                                afterFinalFacingPos, "/", packet.getSize(),
+                                ", occurrence=", badSplineCount);
                 }
-            }
-
-            if (!splineParsed) {
-                LOG_WARNING("WotLK spline parse failed for guid=0x", std::hex, block.guid, std::dec,
-                            " splineFlags=0x", std::hex, splineFlags, std::dec,
-                            " remaining=", packet.getRemainingSize());
                 return false;
             }
+            const bool uncompressed = (splineFlags & (0x00080000 | 0x00002000)) != 0;
+            size_t compactPayloadBytes = 0;
+            if (compactPointCount > 0) {
+                if (uncompressed) {
+                    compactPayloadBytes = static_cast<size_t>(compactPointCount) * 12ull;
+                } else {
+                    compactPayloadBytes = 12ull;
+                    if (compactPointCount > 1) {
+                        compactPayloadBytes += static_cast<size_t>(compactPointCount - 1) * 4ull;
+                    }
+                }
+                if (!bytesAvailable(compactPayloadBytes)) return false;
+                packet.setReadPos(packet.getReadPos() + compactPayloadBytes);
+            }
+            } // end else (compact fallback)
         }
     }
     else if (updateFlags & UPDATEFLAG_POSITION) {
         // Transport position update (UPDATEFLAG_POSITION = 0x0100)
-        if (rem() < 1) return false;
-        uint64_t transportGuid = packet.readPackedGuid();
-        if (rem() < 32) return false; // 8 floats
+        uint64_t transportGuid = readPackedGuid(packet);
         block.x = packet.readFloat();
         block.y = packet.readFloat();
         block.z = packet.readFloat();
@@ -1117,13 +1033,13 @@ bool UpdateObjectParser::parseMovementBlock(network::Packet& packet, UpdateBlock
         block.hasMovement = true;
 
         if (block.onTransport) {
-            LOG_DEBUG("  TRANSPORT POSITION UPDATE: guid=0x", std::hex, transportGuid, std::dec,
-                      " pos=(", block.x, ", ", block.y, ", ", block.z, "), o=", block.orientation,
-                      " offset=(", block.transportX, ", ", block.transportY, ", ", block.transportZ, ")");
+            LOG_INFO("  TRANSPORT POSITION UPDATE: guid=0x", std::hex, transportGuid, std::dec,
+                     " pos=(", block.x, ", ", block.y, ", ", block.z, "), o=", block.orientation,
+                     " offset=(", block.transportX, ", ", block.transportY, ", ", block.transportZ, ")");
         }
     }
     else if (updateFlags & UPDATEFLAG_STATIONARY_POSITION) {
-        if (rem() < 16) return false;
+        // Simple stationary position (4 floats)
         block.x = packet.readFloat();
         block.y = packet.readFloat();
         block.z = packet.readFloat();
@@ -1135,38 +1051,32 @@ bool UpdateObjectParser::parseMovementBlock(network::Packet& packet, UpdateBlock
 
     // Target GUID (for units with target)
     if (updateFlags & UPDATEFLAG_HAS_TARGET) {
-        if (rem() < 1) return false;
-        /*uint64_t targetGuid =*/ packet.readPackedGuid();
+        /*uint64_t targetGuid =*/ readPackedGuid(packet);
     }
 
     // Transport time
     if (updateFlags & UPDATEFLAG_TRANSPORT) {
-        if (rem() < 4) return false;
         /*uint32_t transportTime =*/ packet.readUInt32();
     }
 
     // Vehicle
     if (updateFlags & UPDATEFLAG_VEHICLE) {
-        if (rem() < 8) return false;
         /*uint32_t vehicleId =*/ packet.readUInt32();
         /*float vehicleOrientation =*/ packet.readFloat();
     }
 
     // Rotation (GameObjects)
     if (updateFlags & UPDATEFLAG_ROTATION) {
-        if (rem() < 8) return false;
         /*int64_t rotation =*/ packet.readUInt64();
     }
 
     // Low GUID
     if (updateFlags & UPDATEFLAG_LOWGUID) {
-        if (rem() < 4) return false;
         /*uint32_t lowGuid =*/ packet.readUInt32();
     }
 
     // High GUID
     if (updateFlags & UPDATEFLAG_HIGHGUID) {
-        if (rem() < 4) return false;
         /*uint32_t highGuid =*/ packet.readUInt32();
     }
 
@@ -1176,8 +1086,6 @@ bool UpdateObjectParser::parseMovementBlock(network::Packet& packet, UpdateBlock
 bool UpdateObjectParser::parseUpdateFields(network::Packet& packet, UpdateBlock& block) {
     size_t startPos = packet.getReadPos();
 
-    if (!packet.hasData()) return false;
-
     // Read number of blocks (each block is 32 fields = 32 bits)
     uint8_t blockCount = packet.readUInt8();
 
@@ -1185,44 +1093,15 @@ bool UpdateObjectParser::parseUpdateFields(network::Packet& packet, UpdateBlock&
         return true; // No fields to update
     }
 
-    // Sanity check: UNIT_END=148 needs 5 mask blocks, PLAYER_END=1472 needs 46.
-    // VALUES updates don't carry objectType (defaults to 0), so allow up to 55
-    // for any VALUES update (could be a PLAYER). Only flag CREATE_OBJECT blocks
-    // with genuinely excessive block counts.
-    bool isCreateBlock = (block.updateType == UpdateType::CREATE_OBJECT ||
-                          block.updateType == UpdateType::CREATE_OBJECT2);
-    uint8_t maxExpectedBlocks = isCreateBlock
-        ? ((block.objectType == ObjectType::PLAYER) ? 55 : 10)
-        : 55;  // VALUES: allow PLAYER-sized masks
-    if (blockCount > maxExpectedBlocks) {
-        LOG_WARNING("UpdateObjectParser: suspicious maskBlockCount=", static_cast<int>(blockCount),
-                    " for objectType=", static_cast<int>(block.objectType),
-                    " guid=0x", std::hex, block.guid, std::dec,
-                    " updateFlags=0x", std::hex, block.updateFlags, std::dec,
-                    " moveFlags=0x", std::hex, block.moveFlags, std::dec,
-                    " readPos=", packet.getReadPos(), " size=", packet.getSize());
-    }
-
     uint32_t fieldsCapacity = blockCount * 32;
     LOG_DEBUG("  UPDATE MASK PARSE:");
-    LOG_DEBUG("    maskBlockCount = ", static_cast<int>(blockCount));
+    LOG_DEBUG("    maskBlockCount = ", (int)blockCount);
     LOG_DEBUG("    fieldsCapacity (blocks * 32) = ", fieldsCapacity);
 
     // Read update mask into a reused scratch buffer to avoid per-block allocations.
     static thread_local std::vector<uint32_t> updateMask;
     updateMask.resize(blockCount);
     for (int i = 0; i < blockCount; ++i) {
-        // Validate 4 bytes available before each block read
-        if (!packet.hasRemaining(4)) {
-            LOG_WARNING("UpdateObjectParser: truncated update mask at block ", i,
-                        " type=", updateTypeName(block.updateType),
-                        " objectType=", static_cast<int>(block.objectType),
-                        " guid=0x", std::hex, block.guid, std::dec,
-                        " readPos=", packet.getReadPos(),
-                        " size=", packet.getSize(),
-                        " maskBlockCount=", static_cast<int>(blockCount));
-            return false;
-        }
         updateMask[i] = packet.readUInt32();
     }
 
@@ -1247,18 +1126,6 @@ bool UpdateObjectParser::parseUpdateFields(network::Packet& packet, UpdateBlock&
             if (fieldIndex > highestSetBit) {
                 highestSetBit = fieldIndex;
             }
-            // Validate 4 bytes available before reading field value
-            if (!packet.hasRemaining(4)) {
-                LOG_WARNING("UpdateObjectParser: truncated field value at field ", fieldIndex,
-                            " type=", updateTypeName(block.updateType),
-                            " objectType=", static_cast<int>(block.objectType),
-                            " guid=0x", std::hex, block.guid, std::dec,
-                            " readPos=", packet.getReadPos(),
-                            " size=", packet.getSize(),
-                            " maskBlockIndex=", blockIdx,
-                            " maskBlock=0x", std::hex, updateMask[blockIdx], std::dec);
-                return false;
-            }
             uint32_t value = packet.readUInt32();
             // fieldIndex is monotonically increasing here, so end() is a good insertion hint.
             block.fields.emplace_hint(block.fields.end(), fieldIndex, value);
@@ -1283,19 +1150,16 @@ bool UpdateObjectParser::parseUpdateFields(network::Packet& packet, UpdateBlock&
 }
 
 bool UpdateObjectParser::parseUpdateBlock(network::Packet& packet, UpdateBlock& block) {
-    if (!packet.hasData()) return false;
-
     // Read update type
     uint8_t updateTypeVal = packet.readUInt8();
     block.updateType = static_cast<UpdateType>(updateTypeVal);
 
-    LOG_DEBUG("Update block: type=", static_cast<int>(updateTypeVal));
+    LOG_DEBUG("Update block: type=", (int)updateTypeVal);
 
     switch (block.updateType) {
         case UpdateType::VALUES: {
             // Partial update - changed fields only
-            if (!packet.hasData()) return false;
-            block.guid = packet.readPackedGuid();
+            block.guid = readPackedGuid(packet);
             LOG_DEBUG("  VALUES update for GUID: 0x", std::hex, block.guid, std::dec);
 
             return parseUpdateFields(packet, block);
@@ -1303,8 +1167,7 @@ bool UpdateObjectParser::parseUpdateBlock(network::Packet& packet, UpdateBlock&
 
         case UpdateType::MOVEMENT: {
             // Movement update
-            if (!packet.hasRemaining(8)) return false;
-            block.guid = packet.readUInt64();
+            block.guid = readPackedGuid(packet);
             LOG_DEBUG("  MOVEMENT update for GUID: 0x", std::hex, block.guid, std::dec);
 
             return parseMovementBlock(packet, block);
@@ -1313,15 +1176,13 @@ bool UpdateObjectParser::parseUpdateBlock(network::Packet& packet, UpdateBlock&
         case UpdateType::CREATE_OBJECT:
         case UpdateType::CREATE_OBJECT2: {
             // Create new object with full data
-            if (!packet.hasData()) return false;
-            block.guid = packet.readPackedGuid();
+            block.guid = readPackedGuid(packet);
             LOG_DEBUG("  CREATE_OBJECT for GUID: 0x", std::hex, block.guid, std::dec);
 
             // Read object type
-            if (!packet.hasData()) return false;
             uint8_t objectTypeVal = packet.readUInt8();
             block.objectType = static_cast<ObjectType>(objectTypeVal);
-            LOG_DEBUG("  Object type: ", static_cast<int>(objectTypeVal));
+            LOG_DEBUG("  Object type: ", (int)objectTypeVal);
 
             // Parse movement if present
             bool hasMovement = parseMovementBlock(packet, block);
@@ -1346,16 +1207,14 @@ bool UpdateObjectParser::parseUpdateBlock(network::Packet& packet, UpdateBlock&
         }
 
         default:
-            LOG_WARNING("Unknown update type: ", static_cast<int>(updateTypeVal));
+            LOG_WARNING("Unknown update type: ", (int)updateTypeVal);
             return false;
     }
 }
 
 bool UpdateObjectParser::parse(network::Packet& packet, UpdateObjectData& data) {
-    // Keep worst-case packet parsing bounded. Extremely large counts are typically
-    // malformed/desynced and can stall a frame long enough to trigger disconnects.
-    constexpr uint32_t kMaxReasonableUpdateBlocks = 1024;
-    constexpr uint32_t kMaxReasonableOutOfRangeGuids = 4096;
+    constexpr uint32_t kMaxReasonableUpdateBlocks = 4096;
+    constexpr uint32_t kMaxReasonableOutOfRangeGuids = 16384;
 
     // Read block count
     data.blockCount = packet.readUInt32();
@@ -1369,18 +1228,11 @@ bool UpdateObjectParser::parse(network::Packet& packet, UpdateObjectData& data)
     LOG_DEBUG("  objectCount = ", data.blockCount);
     LOG_DEBUG("  packetSize = ", packet.getSize());
 
-    uint32_t remainingBlockCount = data.blockCount;
-
     // Check for out-of-range objects first
-    if (packet.hasRemaining(1)) {
+    if (packet.getReadPos() + 1 <= packet.getSize()) {
         uint8_t firstByte = packet.readUInt8();
 
         if (firstByte == static_cast<uint8_t>(UpdateType::OUT_OF_RANGE_OBJECTS)) {
-            if (remainingBlockCount == 0) {
-                LOG_ERROR("SMSG_UPDATE_OBJECT rejected: OUT_OF_RANGE_OBJECTS with zero blockCount");
-                return false;
-            }
-            --remainingBlockCount;
             // Read out-of-range GUID count
             uint32_t count = packet.readUInt32();
             if (count > kMaxReasonableOutOfRangeGuids) {
@@ -1390,7 +1242,7 @@ bool UpdateObjectParser::parse(network::Packet& packet, UpdateObjectData& data)
             }
 
             for (uint32_t i = 0; i < count; ++i) {
-                uint64_t guid = packet.readPackedGuid();
+                uint64_t guid = readPackedGuid(packet);
                 data.outOfRangeGuids.push_back(guid);
                 LOG_DEBUG("    Out of range: 0x", std::hex, guid, std::dec);
             }
@@ -1404,7 +1256,6 @@ bool UpdateObjectParser::parse(network::Packet& packet, UpdateObjectData& data)
     }
 
     // Parse update blocks
-    data.blockCount = remainingBlockCount;
     data.blocks.reserve(data.blockCount);
 
     for (uint32_t i = 0; i < data.blockCount; ++i) {
@@ -1414,14 +1265,11 @@ bool UpdateObjectParser::parse(network::Packet& packet, UpdateObjectData& data)
         if (!parseUpdateBlock(packet, block)) {
             static int parseBlockErrors = 0;
             if (++parseBlockErrors <= 5) {
-                LOG_ERROR("Failed to parse update block ", i + 1, " of ", data.blockCount,
-                          " (", i, " blocks parsed successfully before failure)");
+                LOG_ERROR("Failed to parse update block ", i + 1);
                 if (parseBlockErrors == 5)
                     LOG_ERROR("(suppressing further update block parse errors)");
             }
-            // Cannot reliably re-sync to the next block after a parse failure,
-            // but still return true so the blocks already parsed are processed.
-            break;
+            return false;
         }
 
         data.blocks.emplace_back(std::move(block));
@@ -1443,7 +1291,7 @@ bool DestroyObjectParser::parse(network::Packet& packet, DestroyObjectData& data
 
     data.guid = packet.readUInt64();
     // WotLK adds isDeath byte; vanilla/TBC packets are exactly 8 bytes
-    if (packet.hasData()) {
+    if (packet.getReadPos() < packet.getSize()) {
         data.isDeath = (packet.readUInt8() != 0);
     } else {
         data.isDeath = false;
@@ -1516,53 +1364,6 @@ bool MessageChatParser::parse(network::Packet& packet, MessageChatData& data) {
     // Read unknown field
     packet.readUInt32();
 
-    auto tryReadSizedCString = [&](std::string& out, uint32_t maxLen, size_t minTrailingBytes) -> bool {
-        size_t start = packet.getReadPos();
-        size_t remaining = packet.getSize() - start;
-        if (remaining < 4 + minTrailingBytes) return false;
-
-        uint32_t len = packet.readUInt32();
-        if (len < 2 || len > maxLen) {
-            packet.setReadPos(start);
-            return false;
-        }
-        if (!packet.hasRemaining(static_cast<size_t>(len) + minTrailingBytes)) {
-            packet.setReadPos(start);
-            return false;
-        }
-
-        // Stack buffer for typical messages; heap fallback for oversized ones.
-        static constexpr uint32_t kStackBufSize = 256;
-        std::array<char, kStackBufSize> stackBuf;
-        std::string heapBuf;
-        char* buf;
-        if (len <= kStackBufSize) {
-            buf = stackBuf.data();
-        } else {
-            heapBuf.resize(len);
-            buf = heapBuf.data();
-        }
-
-        for (uint32_t i = 0; i < len; ++i) {
-            buf[i] = static_cast<char>(packet.readUInt8());
-        }
-        if (buf[len - 1] != '\0') {
-            packet.setReadPos(start);
-            return false;
-        }
-        // len >= 2 guaranteed above, so len-1 >= 1 — string body is non-empty.
-        for (uint32_t i = 0; i < len - 1; ++i) {
-            auto uc = static_cast<unsigned char>(buf[i]);
-            if (uc < 32 || uc > 126) {
-                packet.setReadPos(start);
-                return false;
-            }
-        }
-
-        out.assign(buf, len - 1);
-        return true;
-    };
-
     // Type-specific data
     // WoW 3.3.5 SMSG_MESSAGECHAT format: after senderGuid+unk, most types
     // have a receiverGuid (uint64). Some types have extra fields before it.
@@ -1576,7 +1377,6 @@ bool MessageChatParser::parse(network::Packet& packet, MessageChatData& data) {
         case ChatType::RAID_BOSS_WHISPER: {
             // Read sender name (SizedCString: uint32 len including null + chars)
             uint32_t nameLen = packet.readUInt32();
-            if (nameLen > packet.getRemainingSize()) return false;
             if (nameLen > 0 && nameLen < 256) {
                 data.senderName.resize(nameLen);
                 for (uint32_t i = 0; i < nameLen; ++i) {
@@ -1590,17 +1390,10 @@ bool MessageChatParser::parse(network::Packet& packet, MessageChatData& data) {
             // Read receiver GUID (NamedGuid: guid + optional name for non-player targets)
             data.receiverGuid = packet.readUInt64();
             if (data.receiverGuid != 0) {
-                // WoW GUID type encoding: bits 48-63 identify entity type.
-                // Players have highGuid=0x0000. Pets use 0xF040 (active pet) or
-                // 0xF014 (creature treated as pet). Mask 0xF0FF isolates the type
-                // nibbles while ignoring the server-specific middle bits.
-                constexpr uint16_t kGuidTypeMask   = 0xF0FF;
-                constexpr uint16_t kGuidTypePet     = 0xF040;
-                constexpr uint16_t kGuidTypeVehicle = 0xF014;
+                // Non-player, non-pet GUIDs have high type bits set (0xF1xx/0xF0xx range)
                 uint16_t highGuid = static_cast<uint16_t>(data.receiverGuid >> 48);
                 bool isPlayer = (highGuid == 0x0000);
-                bool isPet = ((highGuid & kGuidTypeMask) == kGuidTypePet) ||
-                             ((highGuid & kGuidTypeMask) == kGuidTypeVehicle);
+                bool isPet = ((highGuid & 0xF0FF) == 0xF040) || ((highGuid & 0xF0FF) == 0xF014);
                 if (!isPlayer && !isPet) {
                     // Read receiver name (SizedCString)
                     uint32_t recvNameLen = packet.readUInt32();
@@ -1626,35 +1419,6 @@ bool MessageChatParser::parse(network::Packet& packet, MessageChatData& data) {
             break;
         }
 
-        case ChatType::WHISPER:
-        case ChatType::WHISPER_INFORM: {
-            // Some cores include an explicit sized sender/receiver name for whisper chat.
-            // Consume it when present so /r has a reliable last whisper sender.
-            if (data.type == ChatType::WHISPER) {
-                tryReadSizedCString(data.senderName, 128, 8 + 4 + 1);
-            } else {
-                tryReadSizedCString(data.receiverName, 128, 8 + 4 + 1);
-            }
-
-            data.receiverGuid = packet.readUInt64();
-
-            // Optional trailing whisper target/source name on some formats.
-            if (data.type == ChatType::WHISPER && data.receiverName.empty()) {
-                tryReadSizedCString(data.receiverName, 128, 4 + 1);
-            } else if (data.type == ChatType::WHISPER_INFORM && data.senderName.empty()) {
-                tryReadSizedCString(data.senderName, 128, 4 + 1);
-            }
-            break;
-        }
-
-        case ChatType::BG_SYSTEM_NEUTRAL:
-        case ChatType::BG_SYSTEM_ALLIANCE:
-        case ChatType::BG_SYSTEM_HORDE:
-            // BG/Arena system messages — no sender GUID or name field, just message.
-            // Reclassify as SYSTEM for consistent display.
-            data.type = ChatType::SYSTEM;
-            break;
-
         default:
             // SAY, GUILD, PARTY, YELL, WHISPER, WHISPER_INFORM, RAID, etc.
             // All have receiverGuid (typically senderGuid repeated)
@@ -1664,7 +1428,6 @@ bool MessageChatParser::parse(network::Packet& packet, MessageChatData& data) {
 
     // Read message length
     uint32_t messageLen = packet.readUInt32();
-    if (messageLen > packet.getRemainingSize()) return false;
 
     // Read message
     if (messageLen > 0 && messageLen < 8192) {
@@ -1692,7 +1455,7 @@ bool MessageChatParser::parse(network::Packet& packet, MessageChatData& data) {
         LOG_DEBUG("  Channel: ", data.channelName);
     }
     LOG_DEBUG("  Message: ", data.message);
-    LOG_DEBUG("  Chat tag: 0x", std::hex, static_cast<int>(data.chatTag), std::dec);
+    LOG_DEBUG("  Chat tag: 0x", std::hex, (int)data.chatTag, std::dec);
 
     return true;
 }
@@ -1747,30 +1510,20 @@ network::Packet TextEmotePacket::build(uint32_t textEmoteId, uint64_t targetGuid
     return packet;
 }
 
-bool TextEmoteParser::parse(network::Packet& packet, TextEmoteData& data, bool legacyFormat) {
-    size_t bytesLeft = packet.getRemainingSize();
+bool TextEmoteParser::parse(network::Packet& packet, TextEmoteData& data) {
+    size_t bytesLeft = packet.getSize() - packet.getReadPos();
     if (bytesLeft < 20) {
         LOG_WARNING("SMSG_TEXT_EMOTE too short: ", bytesLeft, " bytes");
         return false;
     }
-
-    if (legacyFormat) {
-        // Classic 1.12 / TBC 2.4.3: textEmoteId(u32) + emoteNum(u32) + senderGuid(u64)
-        data.textEmoteId = packet.readUInt32();
-        data.emoteNum    = packet.readUInt32();
-        data.senderGuid  = packet.readUInt64();
-    } else {
-        // WotLK 3.3.5a: senderGuid(u64) + textEmoteId(u32) + emoteNum(u32)
-        data.senderGuid  = packet.readUInt64();
-        data.textEmoteId = packet.readUInt32();
-        data.emoteNum    = packet.readUInt32();
-    }
-
+    data.senderGuid = packet.readUInt64();
+    data.textEmoteId = packet.readUInt32();
+    data.emoteNum = packet.readUInt32();
     uint32_t nameLen = packet.readUInt32();
     if (nameLen > 0 && nameLen <= 256) {
         data.targetName = packet.readString();
     } else if (nameLen > 0) {
-        // Implausible name length — misaligned read
+        // Skip garbage
         return false;
     }
     return true;
@@ -1800,7 +1553,7 @@ network::Packet LeaveChannelPacket::build(const std::string& channelName) {
 }
 
 bool ChannelNotifyParser::parse(network::Packet& packet, ChannelNotifyData& data) {
-    size_t bytesLeft = packet.getRemainingSize();
+    size_t bytesLeft = packet.getSize() - packet.getReadPos();
     if (bytesLeft < 2) {
         LOG_WARNING("SMSG_CHANNEL_NOTIFY too short");
         return false;
@@ -1808,7 +1561,7 @@ bool ChannelNotifyParser::parse(network::Packet& packet, ChannelNotifyData& data
     data.notifyType = static_cast<ChannelNotifyType>(packet.readUInt8());
     data.channelName = packet.readString();
     // Some notification types have additional fields (guid, etc.)
-    bytesLeft = packet.getRemainingSize();
+    bytesLeft = packet.getSize() - packet.getReadPos();
     if (bytesLeft >= 8) {
         data.senderGuid = packet.readUInt64();
     }
@@ -1835,19 +1588,11 @@ network::Packet SetActiveMoverPacket::build(uint64_t guid) {
 
 network::Packet InspectPacket::build(uint64_t targetGuid) {
     network::Packet packet(wireOpcode(Opcode::CMSG_INSPECT));
-    packet.writePackedGuid(targetGuid);
+    packet.writeUInt64(targetGuid);
     LOG_DEBUG("Built CMSG_INSPECT: target=0x", std::hex, targetGuid, std::dec);
     return packet;
 }
 
-network::Packet QueryInspectAchievementsPacket::build(uint64_t targetGuid) {
-    // CMSG_QUERY_INSPECT_ACHIEVEMENTS: PackedGuid targetGuid
-    network::Packet packet(wireOpcode(Opcode::CMSG_QUERY_INSPECT_ACHIEVEMENTS));
-    packet.writePackedGuid(targetGuid);
-    LOG_DEBUG("Built CMSG_QUERY_INSPECT_ACHIEVEMENTS: target=0x", std::hex, targetGuid, std::dec);
-    return packet;
-}
-
 // ============================================================
 // Server Info Commands
 // ============================================================
@@ -1859,12 +1604,6 @@ network::Packet QueryTimePacket::build() {
 }
 
 bool QueryTimeResponseParser::parse(network::Packet& packet, QueryTimeResponseData& data) {
-    // Validate minimum packet size: serverTime(4) + timeOffset(4)
-    if (!packet.hasRemaining(8)) {
-        LOG_WARNING("SMSG_QUERY_TIME_RESPONSE: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
     data.serverTime = packet.readUInt32();
     data.timeOffset = packet.readUInt32();
     LOG_DEBUG("Parsed SMSG_QUERY_TIME_RESPONSE: time=", data.serverTime, " offset=", data.timeOffset);
@@ -1879,16 +1618,9 @@ network::Packet RequestPlayedTimePacket::build(bool sendToChat) {
 }
 
 bool PlayedTimeParser::parse(network::Packet& packet, PlayedTimeData& data) {
-    // Classic/Turtle may omit the trailing trigger-message byte and send only
-    // totalTime(4) + levelTime(4). Later expansions append triggerMsg(1).
-    if (!packet.hasRemaining(8)) {
-        LOG_WARNING("SMSG_PLAYED_TIME: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
     data.totalTimePlayed = packet.readUInt32();
     data.levelTimePlayed = packet.readUInt32();
-    data.triggerMessage = (packet.hasRemaining(1)) && (packet.readUInt8() != 0);
+    data.triggerMessage = packet.readUInt8() != 0;
     LOG_DEBUG("Parsed SMSG_PLAYED_TIME: total=", data.totalTimePlayed, " level=", data.levelTimePlayed);
     return true;
 }
@@ -1941,24 +1673,13 @@ network::Packet SetContactNotesPacket::build(uint64_t friendGuid, const std::str
 }
 
 bool FriendStatusParser::parse(network::Packet& packet, FriendStatusData& data) {
-    // Validate minimum packet size: status(1) + guid(8)
-    if (!packet.hasRemaining(9)) {
-        LOG_WARNING("SMSG_FRIEND_STATUS: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
     data.status = packet.readUInt8();
     data.guid = packet.readUInt64();
     if (data.status == 1) {  // Online
-        // Conditional: note (string) + chatFlag (1)
-        if (packet.hasData()) {
-            data.note = packet.readString();
-            if (packet.hasRemaining(1)) {
-                data.chatFlag = packet.readUInt8();
-            }
-        }
+        data.note = packet.readString();
+        data.chatFlag = packet.readUInt8();
     }
-    LOG_DEBUG("Parsed SMSG_FRIEND_STATUS: status=", static_cast<int>(data.status), " guid=0x", std::hex, data.guid, std::dec);
+    LOG_DEBUG("Parsed SMSG_FRIEND_STATUS: status=", (int)data.status, " guid=0x", std::hex, data.guid, std::dec);
     return true;
 }
 
@@ -1976,19 +1697,6 @@ network::Packet DelIgnorePacket::build(uint64_t ignoreGuid) {
     return packet;
 }
 
-network::Packet ComplainPacket::build(uint64_t targetGuid, const std::string& reason) {
-    network::Packet packet(wireOpcode(Opcode::CMSG_COMPLAIN));
-    packet.writeUInt8(1);               // complaintType: 1 = spam
-    packet.writeUInt64(targetGuid);
-    packet.writeUInt32(0);              // unk
-    packet.writeUInt32(0);              // messageType
-    packet.writeUInt32(0);              // channelId
-    packet.writeUInt32(static_cast<uint32_t>(time(nullptr))); // timestamp
-    packet.writeString(reason);
-    LOG_DEBUG("Built CMSG_COMPLAIN: target=0x", std::hex, targetGuid, std::dec, " reason=", reason);
-    return packet;
-}
-
 // ============================================================
 // Logout Commands
 // ============================================================
@@ -2006,15 +1714,9 @@ network::Packet LogoutCancelPacket::build() {
 }
 
 bool LogoutResponseParser::parse(network::Packet& packet, LogoutResponseData& data) {
-    // Validate minimum packet size: result(4) + instant(1)
-    if (!packet.hasRemaining(5)) {
-        LOG_WARNING("SMSG_LOGOUT_RESPONSE: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
     data.result = packet.readUInt32();
     data.instant = packet.readUInt8();
-    LOG_DEBUG("Parsed SMSG_LOGOUT_RESPONSE: result=", data.result, " instant=", static_cast<int>(data.instant));
+    LOG_DEBUG("Parsed SMSG_LOGOUT_RESPONSE: result=", data.result, " instant=", (int)data.instant);
     return true;
 }
 
@@ -2025,43 +1727,7 @@ bool LogoutResponseParser::parse(network::Packet& packet, LogoutResponseData& da
 network::Packet StandStateChangePacket::build(uint8_t state) {
     network::Packet packet(wireOpcode(Opcode::CMSG_STANDSTATECHANGE));
     packet.writeUInt32(state);
-    LOG_DEBUG("Built CMSG_STANDSTATECHANGE: state=", static_cast<int>(state));
-    return packet;
-}
-
-// ============================================================
-// Action Bar
-// ============================================================
-
-network::Packet SetActionButtonPacket::build(uint8_t button, uint8_t type, uint32_t id, bool isClassic) {
-    // Classic/Turtle (1.12): uint8 button + uint16 id + uint8 type + uint8 misc(0)
-    //   type encoding: 0=spell, 1=item, 64=macro
-    // TBC/WotLK:       uint8 button + uint32 packed (type<<24 | id)
-    //   type encoding: 0x00=spell, 0x80=item, 0x40=macro
-    //   packed=0 means clear the slot
-    network::Packet packet(wireOpcode(Opcode::CMSG_SET_ACTION_BUTTON));
-    packet.writeUInt8(button);
-    if (isClassic) {
-        // Classic: 16-bit id, 8-bit type code, 8-bit misc
-        // Map ActionBarSlot::Type (0=EMPTY,1=SPELL,2=ITEM,3=MACRO) → classic type byte
-        uint8_t classicType = 0; // 0 = spell
-        if (type == 2 /* ITEM */)  classicType = 1;
-        if (type == 3 /* MACRO */) classicType = 64;
-        packet.writeUInt16(static_cast<uint16_t>(id));
-        packet.writeUInt8(classicType);
-        packet.writeUInt8(0); // misc
-        LOG_DEBUG("Built CMSG_SET_ACTION_BUTTON (Classic): button=", static_cast<int>(button),
-                  " id=", id, " type=", static_cast<int>(classicType));
-    } else {
-        // TBC/WotLK: type in bits 24–31, id in bits 0–23; packed=0 clears slot
-        uint8_t packedType = 0x00; // spell
-        if (type == 2 /* ITEM */)  packedType = 0x80;
-        if (type == 3 /* MACRO */) packedType = 0x40;
-        uint32_t packed = (id == 0) ? 0 : (static_cast<uint32_t>(packedType) << 24) | (id & 0x00FFFFFF);
-        packet.writeUInt32(packed);
-        LOG_DEBUG("Built CMSG_SET_ACTION_BUTTON (TBC/WotLK): button=", static_cast<int>(button),
-                  " packed=0x", std::hex, packed, std::dec);
-    }
+    LOG_DEBUG("Built CMSG_STANDSTATECHANGE: state=", (int)state);
     return packet;
 }
 
@@ -2258,7 +1924,7 @@ bool PetitionShowlistParser::parse(network::Packet& packet, PetitionShowlistData
         data.displayId = packet.readUInt32();
         data.cost = packet.readUInt32();
         // Skip unused fields if present
-        if (packet.hasRemaining(8)) {
+        if ((packet.getSize() - packet.getReadPos()) >= 8) {
             data.charterType = packet.readUInt32();
             data.requiredSigs = packet.readUInt32();
         }
@@ -2283,43 +1949,16 @@ bool GuildQueryResponseParser::parse(network::Packet& packet, GuildQueryResponse
         return false;
     }
     data.guildId = packet.readUInt32();
-
-    // Validate before reading guild name
-    if (!packet.hasData()) {
-        LOG_WARNING("GuildQueryResponseParser: truncated before guild name");
-        data.guildName.clear();
-        return true;
-    }
     data.guildName = packet.readString();
-
-    // Read 10 rank names with validation
     for (int i = 0; i < 10; ++i) {
-        if (!packet.hasData()) {
-            LOG_WARNING("GuildQueryResponseParser: truncated at rank name ", i);
-            data.rankNames[i].clear();
-        } else {
-            data.rankNames[i] = packet.readString();
-        }
+        data.rankNames[i] = packet.readString();
     }
-
-    // Validate before reading emblem fields (5 uint32s = 20 bytes)
-    if (!packet.hasRemaining(20)) {
-        LOG_WARNING("GuildQueryResponseParser: truncated before emblem data");
-        data.emblemStyle = 0;
-        data.emblemColor = 0;
-        data.borderStyle = 0;
-        data.borderColor = 0;
-        data.backgroundColor = 0;
-        return true;
-    }
-
     data.emblemStyle = packet.readUInt32();
     data.emblemColor = packet.readUInt32();
     data.borderStyle = packet.readUInt32();
     data.borderColor = packet.readUInt32();
     data.backgroundColor = packet.readUInt32();
-
-    if (packet.hasRemaining(4)) {
+    if ((packet.getSize() - packet.getReadPos()) >= 4) {
         data.rankCount = packet.readUInt32();
     }
     LOG_INFO("Parsed SMSG_GUILD_QUERY_RESPONSE: guild=", data.guildName, " id=", data.guildId);
@@ -2347,49 +1986,16 @@ bool GuildRosterParser::parse(network::Packet& packet, GuildRosterData& data) {
         return false;
     }
     uint32_t numMembers = packet.readUInt32();
-
-    // Cap members and ranks to prevent unbounded memory allocation
-    const uint32_t MAX_GUILD_MEMBERS = 1000;
-    if (numMembers > MAX_GUILD_MEMBERS) {
-        LOG_WARNING("GuildRosterParser: numMembers capped (requested=", numMembers, ")");
-        numMembers = MAX_GUILD_MEMBERS;
-    }
-
     data.motd = packet.readString();
     data.guildInfo = packet.readString();
 
-    if (!packet.hasRemaining(4)) {
-        LOG_WARNING("GuildRosterParser: truncated before rankCount");
-        data.ranks.clear();
-        data.members.clear();
-        return true;
-    }
-
     uint32_t rankCount = packet.readUInt32();
-
-    // Cap rank count to prevent unbounded allocation
-    const uint32_t MAX_GUILD_RANKS = 20;
-    if (rankCount > MAX_GUILD_RANKS) {
-        LOG_WARNING("GuildRosterParser: rankCount capped (requested=", rankCount, ")");
-        rankCount = MAX_GUILD_RANKS;
-    }
-
     data.ranks.resize(rankCount);
     for (uint32_t i = 0; i < rankCount; ++i) {
-        // Validate 4 bytes before each rank rights read
-        if (!packet.hasRemaining(4)) {
-            LOG_WARNING("GuildRosterParser: truncated rank at index ", i);
-            break;
-        }
         data.ranks[i].rights = packet.readUInt32();
-        if (!packet.hasRemaining(4)) {
-            data.ranks[i].goldLimit = 0;
-        } else {
-            data.ranks[i].goldLimit = packet.readUInt32();
-        }
+        data.ranks[i].goldLimit = packet.readUInt32();
         // 6 bank tab flags + 6 bank tab items per day
         for (int t = 0; t < 6; ++t) {
-            if (!packet.hasRemaining(8)) break;
             packet.readUInt32(); // tabFlags
             packet.readUInt32(); // tabItemsPerDay
         }
@@ -2397,68 +2003,20 @@ bool GuildRosterParser::parse(network::Packet& packet, GuildRosterData& data) {
 
     data.members.resize(numMembers);
     for (uint32_t i = 0; i < numMembers; ++i) {
-        // Validate minimum bytes before reading member (guid+online+name at minimum is 9+ bytes)
-        if (!packet.hasRemaining(9)) {
-            LOG_WARNING("GuildRosterParser: truncated member at index ", i);
-            break;
-        }
         auto& m = data.members[i];
         m.guid = packet.readUInt64();
         m.online = (packet.readUInt8() != 0);
-
-        // Validate before reading name string
-        if (!packet.hasData()) {
-            m.name.clear();
-        } else {
-            m.name = packet.readString();
-        }
-
-        // Validate before reading rank/level/class/gender/zone
-        if (!packet.hasRemaining(1)) {
-            m.rankIndex = 0;
-            m.level = 1;
-            m.classId = 0;
-            m.gender = 0;
-            m.zoneId = 0;
-        } else {
-            m.rankIndex = packet.readUInt32();
-            if (!packet.hasRemaining(3)) {
-                m.level = 1;
-                m.classId = 0;
-                m.gender = 0;
-            } else {
-                m.level = packet.readUInt8();
-                m.classId = packet.readUInt8();
-                m.gender = packet.readUInt8();
-            }
-            if (!packet.hasRemaining(4)) {
-                m.zoneId = 0;
-            } else {
-                m.zoneId = packet.readUInt32();
-            }
-        }
-
-        // Online status affects next fields
+        m.name = packet.readString();
+        m.rankIndex = packet.readUInt32();
+        m.level = packet.readUInt8();
+        m.classId = packet.readUInt8();
+        m.gender = packet.readUInt8();
+        m.zoneId = packet.readUInt32();
         if (!m.online) {
-            if (!packet.hasRemaining(4)) {
-                m.lastOnline = 0.0f;
-            } else {
-                m.lastOnline = packet.readFloat();
-            }
-        }
-
-        // Read notes
-        if (!packet.hasData()) {
-            m.publicNote.clear();
-            m.officerNote.clear();
-        } else {
-            m.publicNote = packet.readString();
-            if (!packet.hasData()) {
-                m.officerNote.clear();
-            } else {
-                m.officerNote = packet.readString();
-            }
+            m.lastOnline = packet.readFloat();
         }
+        m.publicNote = packet.readString();
+        m.officerNote = packet.readString();
     }
     LOG_INFO("Parsed SMSG_GUILD_ROSTER: ", numMembers, " members, motd=", data.motd);
     return true;
@@ -2474,10 +2032,10 @@ bool GuildEventParser::parse(network::Packet& packet, GuildEventData& data) {
     for (uint8_t i = 0; i < data.numStrings && i < 3; ++i) {
         data.strings[i] = packet.readString();
     }
-    if (packet.hasRemaining(8)) {
+    if ((packet.getSize() - packet.getReadPos()) >= 8) {
         data.guid = packet.readUInt64();
     }
-    LOG_INFO("Parsed SMSG_GUILD_EVENT: type=", static_cast<int>(data.eventType), " strings=", static_cast<int>(data.numStrings));
+    LOG_INFO("Parsed SMSG_GUILD_EVENT: type=", (int)data.eventType, " strings=", (int)data.numStrings);
     return true;
 }
 
@@ -2554,27 +2112,11 @@ network::Packet GroupDisbandPacket::build() {
     return packet;
 }
 
-network::Packet GroupRaidConvertPacket::build() {
-    network::Packet packet(wireOpcode(Opcode::CMSG_GROUP_RAID_CONVERT));
-    LOG_DEBUG("Built CMSG_GROUP_RAID_CONVERT");
-    return packet;
-}
-
-network::Packet SetLootMethodPacket::build(uint32_t method, uint32_t threshold, uint64_t masterLooterGuid) {
-    network::Packet packet(wireOpcode(Opcode::CMSG_LOOT_METHOD));
-    packet.writeUInt32(method);
-    packet.writeUInt32(threshold);
-    packet.writeUInt64(masterLooterGuid);
-    LOG_DEBUG("Built CMSG_LOOT_METHOD: method=", method, " threshold=", threshold,
-              " masterLooter=0x", std::hex, masterLooterGuid, std::dec);
-    return packet;
-}
-
 network::Packet RaidTargetUpdatePacket::build(uint8_t targetIndex, uint64_t targetGuid) {
     network::Packet packet(wireOpcode(Opcode::MSG_RAID_TARGET_UPDATE));
     packet.writeUInt8(targetIndex);
     packet.writeUInt64(targetGuid);
-    LOG_DEBUG("Built MSG_RAID_TARGET_UPDATE, index: ", static_cast<uint32_t>(targetIndex), ", guid: 0x", std::hex, targetGuid, std::dec);
+    LOG_DEBUG("Built MSG_RAID_TARGET_UPDATE, index: ", (uint32_t)targetIndex, ", guid: 0x", std::hex, targetGuid, std::dec);
     return packet;
 }
 
@@ -2614,35 +2156,6 @@ network::Packet AcceptTradePacket::build() {
     return packet;
 }
 
-network::Packet SetTradeItemPacket::build(uint8_t tradeSlot, uint8_t bag, uint8_t bagSlot) {
-    network::Packet packet(wireOpcode(Opcode::CMSG_SET_TRADE_ITEM));
-    packet.writeUInt8(tradeSlot);
-    packet.writeUInt8(bag);
-    packet.writeUInt8(bagSlot);
-    LOG_DEBUG("Built CMSG_SET_TRADE_ITEM slot=", static_cast<int>(tradeSlot), " bag=", static_cast<int>(bag), " bagSlot=", static_cast<int>(bagSlot));
-    return packet;
-}
-
-network::Packet ClearTradeItemPacket::build(uint8_t tradeSlot) {
-    network::Packet packet(wireOpcode(Opcode::CMSG_CLEAR_TRADE_ITEM));
-    packet.writeUInt8(tradeSlot);
-    LOG_DEBUG("Built CMSG_CLEAR_TRADE_ITEM slot=", static_cast<int>(tradeSlot));
-    return packet;
-}
-
-network::Packet SetTradeGoldPacket::build(uint64_t copper) {
-    network::Packet packet(wireOpcode(Opcode::CMSG_SET_TRADE_GOLD));
-    packet.writeUInt64(copper);
-    LOG_DEBUG("Built CMSG_SET_TRADE_GOLD copper=", copper);
-    return packet;
-}
-
-network::Packet UnacceptTradePacket::build() {
-    network::Packet packet(wireOpcode(Opcode::CMSG_UNACCEPT_TRADE));
-    LOG_DEBUG("Built CMSG_UNACCEPT_TRADE");
-    return packet;
-}
-
 network::Packet InitiateTradePacket::build(uint64_t targetGuid) {
     network::Packet packet(wireOpcode(Opcode::CMSG_INITIATE_TRADE));
     packet.writeUInt64(targetGuid);
@@ -2684,19 +2197,11 @@ network::Packet RandomRollPacket::build(uint32_t minRoll, uint32_t maxRoll) {
 }
 
 bool RandomRollParser::parse(network::Packet& packet, RandomRollData& data) {
-    // WotLK 3.3.5a format: min(4) + max(4) + result(4) + rollerGuid(8) = 20 bytes.
-    // Previously read guid first (treating min|max as a uint64 GUID), producing
-    // garbled roller identity and random numbers in /roll chat messages.
-    if (!packet.hasRemaining(20)) {
-        LOG_WARNING("SMSG_RANDOM_ROLL: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
+    data.rollerGuid = packet.readUInt64();
+    data.targetGuid = packet.readUInt64();
     data.minRoll = packet.readUInt32();
     data.maxRoll = packet.readUInt32();
     data.result = packet.readUInt32();
-    data.rollerGuid = packet.readUInt64();
-    data.targetGuid = 0;  // not present in protocol; kept for struct compatibility
     LOG_DEBUG("Parsed SMSG_RANDOM_ROLL: roller=0x", std::hex, data.rollerGuid, std::dec,
               " result=", data.result, " (", data.minRoll, "-", data.maxRoll, ")");
     return true;
@@ -2712,17 +2217,7 @@ network::Packet NameQueryPacket::build(uint64_t playerGuid) {
 bool NameQueryResponseParser::parse(network::Packet& packet, NameQueryResponseData& data) {
     // 3.3.5a: packedGuid, uint8 found
     // If found==0: CString name, CString realmName, uint8 race, uint8 gender, uint8 classId
-    // Validation: packed GUID (1-8 bytes) + found flag (1 byte minimum)
-    if (!packet.hasRemaining(2)) return false; // At least 1 for packed GUID + 1 for found
-
-    size_t startPos = packet.getReadPos();
-    data.guid = packet.readPackedGuid();
-
-    // Validate found flag read
-    if (!packet.hasRemaining(1)) {
-        packet.setReadPos(startPos);
-        return false;
-    }
+    data.guid = UpdateObjectParser::readPackedGuid(packet);
     data.found = packet.readUInt8();
 
     if (data.found != 0) {
@@ -2730,31 +2225,14 @@ bool NameQueryResponseParser::parse(network::Packet& packet, NameQueryResponseDa
         return true; // Valid response, just not found
     }
 
-    // Validate strings: need at least 2 null terminators for empty strings
-    if (!packet.hasRemaining(2)) {
-        data.name.clear();
-        data.realmName.clear();
-        return !data.name.empty(); // Fail if name was required
-    }
-
     data.name = packet.readString();
     data.realmName = packet.readString();
-
-    // Validate final 3 uint8 fields (race, gender, classId)
-    if (!packet.hasRemaining(3)) {
-        LOG_WARNING("Name query: truncated fields after realmName, expected 3 uint8s");
-        data.race = 0;
-        data.gender = 0;
-        data.classId = 0;
-        return !data.name.empty();
-    }
-
     data.race = packet.readUInt8();
     data.gender = packet.readUInt8();
     data.classId = packet.readUInt8();
 
-    LOG_DEBUG("Name query response: ", data.name, " (race=", static_cast<int>(data.race),
-             " class=", static_cast<int>(data.classId), ")");
+    LOG_INFO("Name query response: ", data.name, " (race=", (int)data.race,
+             " class=", (int)data.classId, ")");
     return true;
 }
 
@@ -2767,12 +2245,6 @@ network::Packet CreatureQueryPacket::build(uint32_t entry, uint64_t guid) {
 }
 
 bool CreatureQueryResponseParser::parse(network::Packet& packet, CreatureQueryResponseData& data) {
-    // Validate minimum packet size: entry(4)
-    if (packet.getSize() < 4) {
-        LOG_ERROR("SMSG_CREATURE_QUERY_RESPONSE: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
     data.entry = packet.readUInt32();
 
     // High bit set means creature not found
@@ -2790,43 +2262,16 @@ bool CreatureQueryResponseParser::parse(network::Packet& packet, CreatureQueryRe
     packet.readString(); // name4
     data.subName = packet.readString();
     data.iconName = packet.readString();
-
-    // WotLK: 4 fixed fields after iconName (typeFlags, creatureType, family, rank)
-    // Validate minimum size for these fields: 4×4 = 16 bytes
-    if (!packet.hasRemaining(16)) {
-        LOG_WARNING("SMSG_CREATURE_QUERY_RESPONSE: truncated before typeFlags (entry=", data.entry, ")");
-        data.typeFlags = 0;
-        data.creatureType = 0;
-        data.family = 0;
-        data.rank = 0;
-        return true;  // Have name/sub/icon; base fields are important but optional
-    }
-
     data.typeFlags = packet.readUInt32();
     data.creatureType = packet.readUInt32();
     data.family = packet.readUInt32();
     data.rank = packet.readUInt32();
 
-    // killCredit[2] + displayId[4] = 6 × 4 = 24 bytes
-    if (!packet.hasRemaining(24)) {
-        LOG_WARNING("SMSG_CREATURE_QUERY_RESPONSE: truncated before displayIds (entry=", data.entry, ")");
-        LOG_DEBUG("Creature query response: ", data.name, " (type=", data.creatureType,
-                 " rank=", data.rank, ")");
-        return true;
-    }
-
-    packet.readUInt32();  // killCredit[0]
-    packet.readUInt32();  // killCredit[1]
-    data.displayId[0] = packet.readUInt32();
-    data.displayId[1] = packet.readUInt32();
-    data.displayId[2] = packet.readUInt32();
-    data.displayId[3] = packet.readUInt32();
-
-    // Skip remaining fields (healthMultiplier, powerMultiplier, racialLeader, questItems, movementId)
+    // Skip remaining fields (kill credits, display IDs, modifiers, quest items, etc.)
+    // We've got what we need for display purposes
 
     LOG_DEBUG("Creature query response: ", data.name, " (type=", data.creatureType,
-             " rank=", data.rank, " displayIds=[", data.displayId[0], ",",
-             data.displayId[1], ",", data.displayId[2], ",", data.displayId[3], "])");
+             " rank=", data.rank, ")");
     return true;
 }
 
@@ -2841,12 +2286,6 @@ network::Packet GameObjectQueryPacket::build(uint32_t entry, uint64_t guid) {
 }
 
 bool GameObjectQueryResponseParser::parse(network::Packet& packet, GameObjectQueryResponseData& data) {
-    // Validate minimum packet size: entry(4)
-    if (packet.getSize() < 4) {
-        LOG_ERROR("SMSG_GAMEOBJECT_QUERY_RESPONSE: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
     data.entry = packet.readUInt32();
 
     // High bit set means gameobject not found
@@ -2857,12 +2296,6 @@ bool GameObjectQueryResponseParser::parse(network::Packet& packet, GameObjectQue
         return true;
     }
 
-    // Validate minimum size for fixed fields: type(4) + displayId(4)
-    if (!packet.hasRemaining(8)) {
-        LOG_ERROR("SMSG_GAMEOBJECT_QUERY_RESPONSE: truncated before names (entry=", data.entry, ")");
-        return false;
-    }
-
     data.type = packet.readUInt32();       // GameObjectType
     data.displayId = packet.readUInt32();
     // 4 name strings (only first is usually populated)
@@ -2878,22 +2311,12 @@ bool GameObjectQueryResponseParser::parse(network::Packet& packet, GameObjectQue
     packet.readString();  // unk1
 
     // Read 24 type-specific data fields
-    size_t remaining = packet.getRemainingSize();
+    size_t remaining = packet.getSize() - packet.getReadPos();
     if (remaining >= 24 * 4) {
         for (int i = 0; i < 24; i++) {
             data.data[i] = packet.readUInt32();
         }
         data.hasData = true;
-    } else if (remaining > 0) {
-        // Partial data field; read what we can
-        uint32_t fieldsToRead = remaining / 4;
-        for (uint32_t i = 0; i < fieldsToRead && i < 24; i++) {
-            data.data[i] = packet.readUInt32();
-        }
-        if (fieldsToRead < 24) {
-            LOG_WARNING("SMSG_GAMEOBJECT_QUERY_RESPONSE: truncated in data fields (", fieldsToRead,
-                        " of 24 read, entry=", data.entry, ")");
-        }
     }
 
     LOG_DEBUG("GameObject query response: ", data.name, " (type=", data.type, " entry=", data.entry, ")");
@@ -2908,10 +2331,10 @@ network::Packet PageTextQueryPacket::build(uint32_t pageId, uint64_t guid) {
 }
 
 bool PageTextQueryResponseParser::parse(network::Packet& packet, PageTextQueryResponseData& data) {
-    if (!packet.hasRemaining(4)) return false;
+    if (packet.getSize() - packet.getReadPos() < 4) return false;
     data.pageId = packet.readUInt32();
     data.text = normalizeWowTextTokens(packet.readString());
-    if (packet.hasRemaining(4)) {
+    if (packet.getSize() - packet.getReadPos() >= 4) {
         data.nextPageId = packet.readUInt32();
     } else {
         data.nextPageId = 0;
@@ -2929,7 +2352,7 @@ network::Packet ItemQueryPacket::build(uint32_t entry, uint64_t guid) {
     return packet;
 }
 
-const char* getItemSubclassName(uint32_t itemClass, uint32_t subClass) {
+static const char* getItemSubclassName(uint32_t itemClass, uint32_t subClass) {
     if (itemClass == 2) { // Weapon
         switch (subClass) {
             case 0: return "Axe"; case 1: return "Axe";
@@ -2956,12 +2379,6 @@ const char* getItemSubclassName(uint32_t itemClass, uint32_t subClass) {
 }
 
 bool ItemQueryResponseParser::parse(network::Packet& packet, ItemQueryResponseData& data) {
-    // Validate minimum packet size: entry(4) + item not found check
-    if (packet.getSize() < 4) {
-        LOG_ERROR("SMSG_ITEM_QUERY_SINGLE_RESPONSE: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
     data.entry = packet.readUInt32();
 
     // High bit set means item not found
@@ -2971,13 +2388,6 @@ bool ItemQueryResponseParser::parse(network::Packet& packet, ItemQueryResponseDa
         return true;
     }
 
-    // Validate minimum size for fixed fields before reading: itemClass(4) + subClass(4) + soundOverride(4)
-    // + 4 name strings + displayInfoId(4) + quality(4) = at least 24 bytes more
-    if (!packet.hasRemaining(24)) {
-        LOG_ERROR("SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated before displayInfoId (entry=", data.entry, ")");
-        return false;
-    }
-
     uint32_t itemClass = packet.readUInt32();
     uint32_t subClass = packet.readUInt32();
     data.itemClass = itemClass;
@@ -2999,11 +2409,7 @@ bool ItemQueryResponseParser::parse(network::Packet& packet, ItemQueryResponseDa
     // Some server variants omit BuyCount (4 fields instead of 5).
     // Read 5 fields and validate InventoryType; if it looks implausible, rewind and try 4.
     const size_t postQualityPos = packet.getReadPos();
-    if (!packet.hasRemaining(24)) {
-        LOG_ERROR("SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated before flags (entry=", data.entry, ")");
-        return false;
-    }
-    data.itemFlags = packet.readUInt32(); // Flags
+    packet.readUInt32(); // Flags
     packet.readUInt32(); // Flags2
     packet.readUInt32(); // BuyCount
     packet.readUInt32(); // BuyPrice
@@ -3013,56 +2419,32 @@ bool ItemQueryResponseParser::parse(network::Packet& packet, ItemQueryResponseDa
     if (data.inventoryType > 28) {
         // inventoryType out of range — BuyCount probably not present; rewind and try 4 fields
         packet.setReadPos(postQualityPos);
-        data.itemFlags = packet.readUInt32(); // Flags
+        packet.readUInt32(); // Flags
         packet.readUInt32(); // Flags2
         packet.readUInt32(); // BuyPrice
         data.sellPrice = packet.readUInt32(); // SellPrice
         data.inventoryType = packet.readUInt32();
     }
 
-    // Validate minimum size for remaining fixed fields before inventoryType through containerSlots: 13×4 = 52 bytes
-    if (!packet.hasRemaining(52)) {
-        LOG_ERROR("SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated before statsCount (entry=", data.entry, ")");
-        return false;
-    }
-    data.allowableClass = packet.readUInt32(); // AllowableClass
-    data.allowableRace  = packet.readUInt32(); // AllowableRace
-    data.itemLevel = packet.readUInt32();
-    data.requiredLevel = packet.readUInt32();
-    data.requiredSkill     = packet.readUInt32(); // RequiredSkill
-    data.requiredSkillRank = packet.readUInt32(); // RequiredSkillRank
+    packet.readUInt32(); // AllowableClass
+    packet.readUInt32(); // AllowableRace
+    packet.readUInt32(); // ItemLevel
+    packet.readUInt32(); // RequiredLevel
+    packet.readUInt32(); // RequiredSkill
+    packet.readUInt32(); // RequiredSkillRank
     packet.readUInt32(); // RequiredSpell
     packet.readUInt32(); // RequiredHonorRank
     packet.readUInt32(); // RequiredCityRank
-    data.requiredReputationFaction = packet.readUInt32(); // RequiredReputationFaction
-    data.requiredReputationRank    = packet.readUInt32(); // RequiredReputationRank
-    data.maxCount = static_cast<int32_t>(packet.readUInt32()); // MaxCount (1 = Unique)
+    packet.readUInt32(); // RequiredReputationFaction
+    packet.readUInt32(); // RequiredReputationRank
+    packet.readUInt32(); // MaxCount
     data.maxStack = static_cast<int32_t>(packet.readUInt32()); // Stackable
     data.containerSlots = packet.readUInt32();
 
-    // Read statsCount with bounds validation
-    if (!packet.hasRemaining(4)) {
-        LOG_WARNING("SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated at statsCount (entry=", data.entry, ")");
-        return true;  // Have enough for core fields; stats are optional
-    }
     uint32_t statsCount = packet.readUInt32();
-
-    // Cap statsCount to prevent excessive iteration
-    constexpr uint32_t kMaxItemStats = 10;
-    if (statsCount > kMaxItemStats) {
-        LOG_WARNING("SMSG_ITEM_QUERY_SINGLE_RESPONSE: statsCount=", statsCount, " exceeds max ",
-                    kMaxItemStats, " (entry=", data.entry, "), capping");
-        statsCount = kMaxItemStats;
-    }
-
     // Server sends exactly statsCount stat pairs (not always 10).
     uint32_t statsToRead = std::min(statsCount, 10u);
     for (uint32_t i = 0; i < statsToRead; i++) {
-        // Each stat is 2 uint32s (type + value) = 8 bytes
-        if (!packet.hasRemaining(8)) {
-            LOG_WARNING("SMSG_ITEM_QUERY_SINGLE_RESPONSE: stat ", i, " truncated (entry=", data.entry, ")");
-            break;
-        }
         uint32_t statType = packet.readUInt32();
         int32_t statValue = static_cast<int32_t>(packet.readUInt32());
         switch (statType) {
@@ -3071,29 +2453,13 @@ bool ItemQueryResponseParser::parse(network::Packet& packet, ItemQueryResponseDa
             case 5: data.intellect = statValue; break;
             case 6: data.spirit = statValue; break;
             case 7: data.stamina = statValue; break;
-            default:
-                if (statValue != 0)
-                    data.extraStats.push_back({statType, statValue});
-                break;
+            default: break;
         }
     }
 
-    // ScalingStatDistribution and ScalingStatValue
-    if (!packet.hasRemaining(8)) {
-        LOG_WARNING("SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated before scaling stats (entry=", data.entry, ")");
-        return true;  // Have core fields; scaling is optional
-    }
     packet.readUInt32(); // ScalingStatDistribution
     packet.readUInt32(); // ScalingStatValue
 
-    // WotLK 3.3.5a: 2 damage entries (12 bytes each) + armor + 6 resists + delay + ammoType + rangedModRange
-    // = 24 + 36 + 4 = 64 bytes minimum. Guard here because the section above
-    // returns early on truncation, and every other section has its own guard.
-    if (!packet.hasRemaining(64)) {
-        LOG_WARNING("SMSG_ITEM_QUERY_SINGLE_RESPONSE: truncated before damage/armor (entry=", data.entry, ")");
-        return true;
-    }
-
     // WotLK 3.3.5a: MAX_ITEM_PROTO_DAMAGES = 2
     bool haveWeaponDamage = false;
     for (int i = 0; i < 2; i++) {
@@ -3110,19 +2476,19 @@ bool ItemQueryResponseParser::parse(network::Packet& packet, ItemQueryResponseDa
     }
 
     data.armor = static_cast<int32_t>(packet.readUInt32());
-    data.holyRes   = static_cast<int32_t>(packet.readUInt32()); // HolyRes
-    data.fireRes   = static_cast<int32_t>(packet.readUInt32()); // FireRes
-    data.natureRes = static_cast<int32_t>(packet.readUInt32()); // NatureRes
-    data.frostRes  = static_cast<int32_t>(packet.readUInt32()); // FrostRes
-    data.shadowRes = static_cast<int32_t>(packet.readUInt32()); // ShadowRes
-    data.arcaneRes = static_cast<int32_t>(packet.readUInt32()); // ArcaneRes
+    packet.readUInt32(); // HolyRes
+    packet.readUInt32(); // FireRes
+    packet.readUInt32(); // NatureRes
+    packet.readUInt32(); // FrostRes
+    packet.readUInt32(); // ShadowRes
+    packet.readUInt32(); // ArcaneRes
     data.delayMs = packet.readUInt32();
     packet.readUInt32(); // AmmoType
     packet.readFloat();  // RangedModRange
 
     // 5 item spells: SpellId, SpellTrigger, SpellCharges, SpellCooldown, SpellCategory, SpellCategoryCooldown
     for (int i = 0; i < 5; i++) {
-        if (!packet.hasRemaining(24)) break;
+        if (packet.getReadPos() + 24 > packet.getSize()) break;
         data.spells[i].spellId = packet.readUInt32();
         data.spells[i].spellTrigger = packet.readUInt32();
         packet.readUInt32(); // SpellCharges
@@ -3131,45 +2497,6 @@ bool ItemQueryResponseParser::parse(network::Packet& packet, ItemQueryResponseDa
         packet.readUInt32(); // SpellCategoryCooldown
     }
 
-    // Bonding type (0=none, 1=BoP, 2=BoE, 3=BoU, 4=BoQ)
-    if (packet.hasRemaining(4))
-        data.bindType = packet.readUInt32();
-
-    // Flavor/lore text (Description cstring)
-    if (packet.hasData())
-        data.description = packet.readString();
-
-    // Post-description fields: PageText, LanguageID, PageMaterial, StartQuest
-    if (packet.hasRemaining(16)) {
-        packet.readUInt32(); // PageText
-        packet.readUInt32(); // LanguageID
-        packet.readUInt32(); // PageMaterial
-        data.startQuestId = packet.readUInt32(); // StartQuest
-    }
-
-    // WotLK 3.3.5a: additional fields after StartQuest (read up to socket data)
-    // LockID(4), Material(4), Sheath(4), RandomProperty(4), RandomSuffix(4),
-    // Block(4), ItemSet(4), MaxDurability(4), Area(4), Map(4), BagFamily(4),
-    // TotemCategory(4) = 48 bytes before sockets
-    constexpr size_t kPreSocketSkip = 48;
-    if (packet.getReadPos() + kPreSocketSkip + 28 <= packet.getSize()) {
-        // LockID(0), Material(1), Sheath(2), RandomProperty(3), RandomSuffix(4), Block(5)
-        for (size_t i = 0; i < 6; ++i) packet.readUInt32();
-        data.itemSetId = packet.readUInt32(); // ItemSet(6)
-        // MaxDurability(7), Area(8), Map(9), BagFamily(10), TotemCategory(11)
-        for (size_t i = 0; i < 5; ++i) packet.readUInt32();
-        // 3 socket slots: socketColor (4 bytes each)
-        data.socketColor[0] = packet.readUInt32();
-        data.socketColor[1] = packet.readUInt32();
-        data.socketColor[2] = packet.readUInt32();
-        // 3 socket content (gem enchantment IDs — skip, not currently displayed)
-        packet.readUInt32();
-        packet.readUInt32();
-        packet.readUInt32();
-        // socketBonus (enchantmentId)
-        data.socketBonus = packet.readUInt32();
-    }
-
     data.valid = !data.name.empty();
     return true;
 }
@@ -3180,25 +2507,25 @@ bool ItemQueryResponseParser::parse(network::Packet& packet, ItemQueryResponseDa
 
 bool MonsterMoveParser::parse(network::Packet& packet, MonsterMoveData& data) {
     // PackedGuid
-    data.guid = packet.readPackedGuid();
+    data.guid = UpdateObjectParser::readPackedGuid(packet);
     if (data.guid == 0) return false;
 
     // uint8 unk (toggle for MOVEMENTFLAG2_UNK7)
-    if (!packet.hasData()) return false;
+    if (packet.getReadPos() >= packet.getSize()) return false;
     packet.readUInt8();
 
     // Current position (server coords: float x, y, z)
-    if (!packet.hasRemaining(12)) return false;
+    if (packet.getReadPos() + 12 > packet.getSize()) return false;
     data.x = packet.readFloat();
     data.y = packet.readFloat();
     data.z = packet.readFloat();
 
     // uint32 splineId
-    if (!packet.hasRemaining(4)) return false;
+    if (packet.getReadPos() + 4 > packet.getSize()) return false;
     packet.readUInt32();
 
     // uint8 moveType
-    if (!packet.hasData()) return false;
+    if (packet.getReadPos() >= packet.getSize()) return false;
     data.moveType = packet.readUInt8();
 
     if (data.moveType == 1) {
@@ -3213,20 +2540,20 @@ bool MonsterMoveParser::parse(network::Packet& packet, MonsterMoveData& data) {
     // Read facing data based on move type
     if (data.moveType == 2) {
         // FacingSpot: float x, y, z
-        if (!packet.hasRemaining(12)) return false;
+        if (packet.getReadPos() + 12 > packet.getSize()) return false;
         packet.readFloat(); packet.readFloat(); packet.readFloat();
     } else if (data.moveType == 3) {
         // FacingTarget: uint64 guid
-        if (!packet.hasRemaining(8)) return false;
+        if (packet.getReadPos() + 8 > packet.getSize()) return false;
         data.facingTarget = packet.readUInt64();
     } else if (data.moveType == 4) {
         // FacingAngle: float angle
-        if (!packet.hasRemaining(4)) return false;
+        if (packet.getReadPos() + 4 > packet.getSize()) return false;
         data.facingAngle = packet.readFloat();
     }
 
     // uint32 splineFlags
-    if (!packet.hasRemaining(4)) return false;
+    if (packet.getReadPos() + 4 > packet.getSize()) return false;
     data.splineFlags = packet.readUInt32();
 
     // WotLK 3.3.5a SplineFlags (from TrinityCore/MaNGOS MoveSplineFlag.h):
@@ -3237,35 +2564,28 @@ bool MonsterMoveParser::parse(network::Packet& packet, MonsterMoveData& data) {
 
     // [if Animation] uint8 animationType + int32 effectStartTime (5 bytes)
     if (data.splineFlags & 0x00400000) {
-        if (!packet.hasRemaining(5)) return false;
+        if (packet.getReadPos() + 5 > packet.getSize()) return false;
         packet.readUInt8();  // animationType
         packet.readUInt32(); // effectStartTime (int32, read as uint32 same size)
     }
 
     // uint32 duration
-    if (!packet.hasRemaining(4)) return false;
+    if (packet.getReadPos() + 4 > packet.getSize()) return false;
     data.duration = packet.readUInt32();
 
     // [if Parabolic] float verticalAcceleration + int32 effectStartTime (8 bytes)
     if (data.splineFlags & 0x00000800) {
-        if (!packet.hasRemaining(8)) return false;
+        if (packet.getReadPos() + 8 > packet.getSize()) return false;
         packet.readFloat(); // verticalAcceleration
         packet.readUInt32(); // effectStartTime
     }
 
     // uint32 pointCount
-    if (!packet.hasRemaining(4)) return false;
+    if (packet.getReadPos() + 4 > packet.getSize()) return false;
     uint32_t pointCount = packet.readUInt32();
 
     if (pointCount == 0) return true;
 
-    constexpr uint32_t kMaxSplinePoints = 1000;
-    if (pointCount > kMaxSplinePoints) {
-        LOG_WARNING("SMSG_MONSTER_MOVE: pointCount=", pointCount, " exceeds max ", kMaxSplinePoints,
-                    " (guid=0x", std::hex, data.guid, std::dec, ")");
-        return false;
-    }
-
     // Catmullrom or Flying → all waypoints stored as absolute float3 (uncompressed).
     // Otherwise: first float3 is final destination, remaining are packed deltas.
     bool uncompressed = (data.splineFlags & (0x00080000 | 0x00002000)) != 0;
@@ -3273,20 +2593,18 @@ bool MonsterMoveParser::parse(network::Packet& packet, MonsterMoveData& data) {
     if (uncompressed) {
         // Read last point as destination
         // Skip to last point: each point is 12 bytes
-        if (pointCount > 1) {
-            for (uint32_t i = 0; i < pointCount - 1; i++) {
-                if (!packet.hasRemaining(12)) return true;
-                packet.readFloat(); packet.readFloat(); packet.readFloat();
-            }
+        for (uint32_t i = 0; i < pointCount - 1; i++) {
+            if (packet.getReadPos() + 12 > packet.getSize()) return true;
+            packet.readFloat(); packet.readFloat(); packet.readFloat();
         }
-        if (!packet.hasRemaining(12)) return true;
+        if (packet.getReadPos() + 12 > packet.getSize()) return true;
         data.destX = packet.readFloat();
         data.destY = packet.readFloat();
         data.destZ = packet.readFloat();
         data.hasDest = true;
     } else {
         // Compressed: first 3 floats are the destination (final point)
-        if (!packet.hasRemaining(12)) return true;
+        if (packet.getReadPos() + 12 > packet.getSize()) return true;
         data.destX = packet.readFloat();
         data.destY = packet.readFloat();
         data.destZ = packet.readFloat();
@@ -3294,17 +2612,17 @@ bool MonsterMoveParser::parse(network::Packet& packet, MonsterMoveData& data) {
     }
 
     LOG_DEBUG("MonsterMove: guid=0x", std::hex, data.guid, std::dec,
-              " type=", static_cast<int>(data.moveType), " dur=", data.duration, "ms",
+              " type=", (int)data.moveType, " dur=", data.duration, "ms",
               " dest=(", data.destX, ",", data.destY, ",", data.destZ, ")");
 
     return true;
 }
 
 bool MonsterMoveParser::parseVanilla(network::Packet& packet, MonsterMoveData& data) {
-    data.guid = packet.readPackedGuid();
+    data.guid = UpdateObjectParser::readPackedGuid(packet);
     if (data.guid == 0) return false;
 
-    if (!packet.hasRemaining(12)) return false;
+    if (packet.getReadPos() + 12 > packet.getSize()) return false;
     data.x = packet.readFloat();
     data.y = packet.readFloat();
     data.z = packet.readFloat();
@@ -3320,10 +2638,10 @@ bool MonsterMoveParser::parseVanilla(network::Packet& packet, MonsterMoveData& d
     //   uint32 pointCount
     //   float[3] dest
     //   uint32 packedPoints[pointCount-1]
-    if (!packet.hasRemaining(4)) return false;
+    if (packet.getReadPos() + 4 > packet.getSize()) return false;
     /*uint32_t splineIdOrTick =*/ packet.readUInt32();
 
-    if (!packet.hasData()) return false;
+    if (packet.getReadPos() >= packet.getSize()) return false;
     data.moveType = packet.readUInt8();
 
     if (data.moveType == 1) {
@@ -3335,54 +2653,44 @@ bool MonsterMoveParser::parseVanilla(network::Packet& packet, MonsterMoveData& d
     }
 
     if (data.moveType == 2) {
-        if (!packet.hasRemaining(12)) return false;
+        if (packet.getReadPos() + 12 > packet.getSize()) return false;
         packet.readFloat(); packet.readFloat(); packet.readFloat();
     } else if (data.moveType == 3) {
-        if (!packet.hasRemaining(8)) return false;
+        if (packet.getReadPos() + 8 > packet.getSize()) return false;
         data.facingTarget = packet.readUInt64();
     } else if (data.moveType == 4) {
-        if (!packet.hasRemaining(4)) return false;
+        if (packet.getReadPos() + 4 > packet.getSize()) return false;
         data.facingAngle = packet.readFloat();
     }
 
-    if (!packet.hasRemaining(4)) return false;
+    if (packet.getReadPos() + 4 > packet.getSize()) return false;
     data.splineFlags = packet.readUInt32();
 
     // Animation flag (same bit as WotLK MoveSplineFlag::Animation)
     if (data.splineFlags & 0x00400000) {
-        if (!packet.hasRemaining(5)) return false;
+        if (packet.getReadPos() + 5 > packet.getSize()) return false;
         packet.readUInt8();
         packet.readUInt32();
     }
 
-    if (!packet.hasRemaining(4)) return false;
+    if (packet.getReadPos() + 4 > packet.getSize()) return false;
     data.duration = packet.readUInt32();
 
     // Parabolic flag (same bit as WotLK MoveSplineFlag::Parabolic)
     if (data.splineFlags & 0x00000800) {
-        if (!packet.hasRemaining(8)) return false;
+        if (packet.getReadPos() + 8 > packet.getSize()) return false;
         packet.readFloat();
         packet.readUInt32();
     }
 
-    if (!packet.hasRemaining(4)) return false;
+    if (packet.getReadPos() + 4 > packet.getSize()) return false;
     uint32_t pointCount = packet.readUInt32();
 
     if (pointCount == 0) return true;
-
-    // Reject extreme point counts from malformed packets.
-    constexpr uint32_t kMaxSplinePoints = 1000;
-    if (pointCount > kMaxSplinePoints) {
-        return false;
-    }
-
-    size_t requiredBytes = 12;
-    if (pointCount > 1) {
-        requiredBytes += static_cast<size_t>(pointCount - 1) * 4ull;
-    }
-    if (!packet.hasRemaining(requiredBytes)) return false;
+    if (pointCount > 16384) return false; // sanity
 
     // First float[3] is destination.
+    if (packet.getReadPos() + 12 > packet.getSize()) return true;
     data.destX = packet.readFloat();
     data.destY = packet.readFloat();
     data.destZ = packet.readFloat();
@@ -3392,12 +2700,13 @@ bool MonsterMoveParser::parseVanilla(network::Packet& packet, MonsterMoveData& d
     if (pointCount > 1) {
         size_t skipBytes = static_cast<size_t>(pointCount - 1) * 4;
         size_t newPos = packet.getReadPos() + skipBytes;
-        if (newPos > packet.getSize()) return false;
-        packet.setReadPos(newPos);
+        if (newPos <= packet.getSize()) {
+            packet.setReadPos(newPos);
+        }
     }
 
     LOG_DEBUG("MonsterMove(turtle): guid=0x", std::hex, data.guid, std::dec,
-              " type=", static_cast<int>(data.moveType), " dur=", data.duration, "ms",
+              " type=", (int)data.moveType, " dur=", data.duration, "ms",
               " dest=(", data.destX, ",", data.destY, ",", data.destZ, ")");
 
     return true;
@@ -3412,69 +2721,29 @@ bool AttackStartParser::parse(network::Packet& packet, AttackStartData& data) {
     if (packet.getSize() < 16) return false;
     data.attackerGuid = packet.readUInt64();
     data.victimGuid = packet.readUInt64();
-    LOG_DEBUG("Attack started: 0x", std::hex, data.attackerGuid,
+    LOG_INFO("Attack started: 0x", std::hex, data.attackerGuid,
              " -> 0x", data.victimGuid, std::dec);
     return true;
 }
 
 bool AttackStopParser::parse(network::Packet& packet, AttackStopData& data) {
-    data.attackerGuid = packet.readPackedGuid();
-    data.victimGuid = packet.readPackedGuid();
-    if (packet.hasData()) {
+    data.attackerGuid = UpdateObjectParser::readPackedGuid(packet);
+    data.victimGuid = UpdateObjectParser::readPackedGuid(packet);
+    if (packet.getReadPos() < packet.getSize()) {
         data.unknown = packet.readUInt32();
     }
-    LOG_DEBUG("Attack stopped: 0x", std::hex, data.attackerGuid, std::dec);
+    LOG_INFO("Attack stopped: 0x", std::hex, data.attackerGuid, std::dec);
     return true;
 }
 
 bool AttackerStateUpdateParser::parse(network::Packet& packet, AttackerStateUpdateData& data) {
-    // Upfront validation: hitInfo(4) + packed GUIDs(1-8 each) + totalDamage(4) + subDamageCount(1) = 13 bytes minimum
-    if (!packet.hasRemaining(13)) return false;
-
-    size_t startPos = packet.getReadPos();
     data.hitInfo = packet.readUInt32();
-    if (!packet.hasFullPackedGuid()) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.attackerGuid = packet.readPackedGuid();
-    if (!packet.hasFullPackedGuid()) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.targetGuid = packet.readPackedGuid();
-
-    // Validate totalDamage + subDamageCount can be read (5 bytes)
-    if (!packet.hasRemaining(5)) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-
+    data.attackerGuid = UpdateObjectParser::readPackedGuid(packet);
+    data.targetGuid = UpdateObjectParser::readPackedGuid(packet);
     data.totalDamage = static_cast<int32_t>(packet.readUInt32());
     data.subDamageCount = packet.readUInt8();
 
-    // Cap subDamageCount: each entry is 20 bytes. If the claimed count
-    // exceeds what the remaining bytes can hold, a GUID was mis-parsed
-    // (off by one byte), causing the school-mask byte to be read as count.
-    // In that case clamp to the number of full entries that fit.
-    {
-        size_t remaining = packet.getRemainingSize();
-        size_t maxFit    = remaining / 20;
-        if (data.subDamageCount > maxFit) {
-            data.subDamageCount = static_cast<uint8_t>(std::min<size_t>(maxFit, 64));
-        } else if (data.subDamageCount > 64) {
-            data.subDamageCount = 64;
-        }
-    }
-    if (data.subDamageCount == 0) return false;
-
-    data.subDamages.reserve(data.subDamageCount);
     for (uint8_t i = 0; i < data.subDamageCount; ++i) {
-        // Each sub-damage entry needs 20 bytes: schoolMask(4) + damage(4) + intDamage(4) + absorbed(4) + resisted(4)
-        if (!packet.hasRemaining(20)) {
-            data.subDamageCount = i;
-            break;
-        }
         SubDamage sub;
         sub.schoolMask = packet.readUInt32();
         sub.damage = packet.readFloat();
@@ -3484,59 +2753,23 @@ bool AttackerStateUpdateParser::parse(network::Packet& packet, AttackerStateUpda
         data.subDamages.push_back(sub);
     }
 
-    // Validate victimState + overkill fields (8 bytes)
-    if (!packet.hasRemaining(8)) {
-        data.victimState = 0;
-        data.overkill = 0;
-        return !data.subDamages.empty();
+    data.victimState = packet.readUInt32();
+    data.overkill = static_cast<int32_t>(packet.readUInt32());
+
+    // Read blocked amount
+    if (packet.getReadPos() < packet.getSize()) {
+        data.blocked = packet.readUInt32();
     }
 
-    data.victimState = packet.readUInt32();
-    // WotLK (AzerothCore): two unknown uint32 fields follow victimState before overkill.
-    // Older parsers omitted these, reading overkill from the wrong offset.
-    auto rem = [&]() { return packet.getRemainingSize(); };
-    if (rem() >= 4) packet.readUInt32(); // unk1 (always 0)
-    if (rem() >= 4) packet.readUInt32(); // unk2 (melee spell ID, 0 for auto-attack)
-    data.overkill = (rem() >= 4) ? static_cast<int32_t>(packet.readUInt32()) : -1;
-
-    // hitInfo-conditional fields: HITINFO_BLOCK(0x2000), RAGE_GAIN(0x20000), FAKE_DAMAGE(0x40)
-    if ((data.hitInfo & 0x2000) && rem() >= 4)  data.blocked  = packet.readUInt32();
-    else data.blocked = 0;
-    // RAGE_GAIN and FAKE_DAMAGE both add a uint32 we can skip
-    if ((data.hitInfo & 0x20000) && rem() >= 4) packet.readUInt32(); // rage gain
-    if ((data.hitInfo & 0x40)    && rem() >= 4) packet.readUInt32(); // fake damage total
-
-    LOG_DEBUG("Melee hit: ", data.totalDamage, " damage",
-              data.isCrit() ? " (CRIT)" : "",
-              data.isMiss() ? " (MISS)" : "");
+    LOG_INFO("Melee hit: ", data.totalDamage, " damage",
+             data.isCrit() ? " (CRIT)" : "",
+             data.isMiss() ? " (MISS)" : "");
     return true;
 }
 
 bool SpellDamageLogParser::parse(network::Packet& packet, SpellDamageLogData& data) {
-    // Upfront validation:
-    // packed GUIDs(1-8 each) + spellId(4) + damage(4) + overkill(4) + schoolMask(1)
-    // + absorbed(4) + resisted(4) + periodicLog(1) + unused(1) + blocked(4) + flags(4)
-    // = 33 bytes minimum.
-    if (!packet.hasRemaining(33)) return false;
-
-    size_t startPos = packet.getReadPos();
-    if (!packet.hasFullPackedGuid()) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.targetGuid = packet.readPackedGuid();
-    if (!packet.hasFullPackedGuid()) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.attackerGuid = packet.readPackedGuid();
-
-    // Validate core fields (spellId + damage + overkill + schoolMask + absorbed + resisted = 21 bytes)
-    if (!packet.hasRemaining(21)) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-
+    data.targetGuid = UpdateObjectParser::readPackedGuid(packet);
+    data.attackerGuid = UpdateObjectParser::readPackedGuid(packet);
     data.spellId = packet.readUInt32();
     data.damage = packet.readUInt32();
     data.overkill = packet.readUInt32();
@@ -3544,46 +2777,24 @@ bool SpellDamageLogParser::parse(network::Packet& packet, SpellDamageLogData& da
     data.absorbed = packet.readUInt32();
     data.resisted = packet.readUInt32();
 
-    // Remaining fields are required for a complete event.
-    // Reject truncated packets so we do not emit partial/incorrect combat entries.
-    if (!packet.hasRemaining(10)) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-
-    (void)packet.readUInt8(); // periodicLog (not displayed)
+    // Skip remaining fields
+    uint8_t periodicLog = packet.readUInt8();
+    (void)periodicLog;
     packet.readUInt8(); // unused
     packet.readUInt32(); // blocked
-    uint32_t flags = packet.readUInt32();  // flags IS used — bit 0x02 = crit
+    uint32_t flags = packet.readUInt32();
+    (void)flags;
+    // Check crit flag
     data.isCrit = (flags & 0x02) != 0;
 
-    LOG_DEBUG("Spell damage: spellId=", data.spellId, " dmg=", data.damage,
-              data.isCrit ? " CRIT" : "");
+    LOG_INFO("Spell damage: spellId=", data.spellId, " dmg=", data.damage,
+             data.isCrit ? " CRIT" : "");
     return true;
 }
 
 bool SpellHealLogParser::parse(network::Packet& packet, SpellHealLogData& data) {
-    // Upfront validation: packed GUIDs(1-8 each) + spellId(4) + heal(4) + overheal(4) + absorbed(4) + critFlag(1) = 21 bytes minimum
-    if (!packet.hasRemaining(21)) return false;
-
-    size_t startPos = packet.getReadPos();
-    if (!packet.hasFullPackedGuid()) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.targetGuid = packet.readPackedGuid();
-    if (!packet.hasFullPackedGuid()) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.casterGuid = packet.readPackedGuid();
-
-    // Validate remaining fields (spellId + heal + overheal + absorbed + critFlag = 17 bytes)
-    if (!packet.hasRemaining(17)) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-
+    data.targetGuid = UpdateObjectParser::readPackedGuid(packet);
+    data.casterGuid = UpdateObjectParser::readPackedGuid(packet);
     data.spellId = packet.readUInt32();
     data.heal = packet.readUInt32();
     data.overheal = packet.readUInt32();
@@ -3591,8 +2802,8 @@ bool SpellHealLogParser::parse(network::Packet& packet, SpellHealLogData& data)
     uint8_t critFlag = packet.readUInt8();
     data.isCrit = (critFlag != 0);
 
-    LOG_DEBUG("Spell heal: spellId=", data.spellId, " heal=", data.heal,
-              data.isCrit ? " CRIT" : "");
+    LOG_INFO("Spell heal: spellId=", data.spellId, " heal=", data.heal,
+             data.isCrit ? " CRIT" : "");
     return true;
 }
 
@@ -3601,28 +2812,19 @@ bool SpellHealLogParser::parse(network::Packet& packet, SpellHealLogData& data)
 // ============================================================
 
 bool XpGainParser::parse(network::Packet& packet, XpGainData& data) {
-    // Validate minimum packet size: victimGuid(8) + totalXp(4) + type(1)
-    if (!packet.hasRemaining(13)) {
-        LOG_WARNING("SMSG_LOG_XPGAIN: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
     data.victimGuid = packet.readUInt64();
     data.totalXp = packet.readUInt32();
     data.type = packet.readUInt8();
     if (data.type == 0) {
         // Kill XP: float groupRate (1.0 = solo) + uint8 RAF flag
-        // Validate before reading conditional fields
-        if (packet.hasRemaining(5)) {
-            float groupRate = packet.readFloat();
-            packet.readUInt8(); // RAF bonus flag
-            // Group bonus = total - (total / rate); only if grouped (rate > 1)
-            if (groupRate > 1.0f) {
-                data.groupBonus = data.totalXp - static_cast<uint32_t>(data.totalXp / groupRate);
-            }
+        float groupRate = packet.readFloat();
+        packet.readUInt8(); // RAF bonus flag
+        // Group bonus = total - (total / rate); only if grouped (rate > 1)
+        if (groupRate > 1.0f) {
+            data.groupBonus = data.totalXp - static_cast<uint32_t>(data.totalXp / groupRate);
         }
     }
-    LOG_DEBUG("XP gain: ", data.totalXp, " xp (type=", static_cast<int>(data.type), ")");
+    LOG_INFO("XP gain: ", data.totalXp, " xp (type=", static_cast<int>(data.type), ")");
     return data.totalXp > 0;
 }
 
@@ -3630,40 +2832,21 @@ bool XpGainParser::parse(network::Packet& packet, XpGainData& data) {
 // Phase 3: Spells, Action Bar, Auras
 // ============================================================
 
-bool InitialSpellsParser::parse(network::Packet& packet, InitialSpellsData& data,
-                                bool vanillaFormat) {
-    // Validate minimum packet size for header: talentSpec(1) + spellCount(2)
-    if (!packet.hasRemaining(3)) {
-        LOG_ERROR("SMSG_INITIAL_SPELLS: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
+bool InitialSpellsParser::parse(network::Packet& packet, InitialSpellsData& data) {
+    size_t packetSize = packet.getSize();
     data.talentSpec = packet.readUInt8();
     uint16_t spellCount = packet.readUInt16();
 
-    // Cap spell count to prevent excessive iteration.
-    // WotLK characters with all ranks, mounts, professions, and racials can
-    // know 400-600 spells; 1024 covers all practical cases with headroom.
-    constexpr uint16_t kMaxSpells = 1024;
-    if (spellCount > kMaxSpells) {
-        LOG_WARNING("SMSG_INITIAL_SPELLS: spellCount=", spellCount, " exceeds max ", kMaxSpells,
-                    ", capping");
-        spellCount = kMaxSpells;
-    }
+    // Detect vanilla (uint16 spellId) vs WotLK (uint32 spellId) format
+    // Vanilla: 4 bytes/spell (uint16 id + uint16 slot), WotLK: 6 bytes/spell (uint32 id + uint16 unk)
+    size_t remainingAfterHeader = packetSize - 3; // subtract talentSpec(1) + spellCount(2)
+    bool vanillaFormat = remainingAfterHeader < static_cast<size_t>(spellCount) * 6 + 2;
 
-    LOG_DEBUG("SMSG_INITIAL_SPELLS: spellCount=", spellCount,
-              vanillaFormat ? " (vanilla uint16 format)" : " (TBC/WotLK uint32 format)");
+    LOG_INFO("SMSG_INITIAL_SPELLS: packetSize=", packetSize, " bytes, spellCount=", spellCount,
+             vanillaFormat ? " (vanilla uint16 format)" : " (WotLK uint32 format)");
 
     data.spellIds.reserve(spellCount);
     for (uint16_t i = 0; i < spellCount; ++i) {
-        // Vanilla spell: spellId(2) + slot(2) = 4 bytes
-        // TBC/WotLK spell: spellId(4) + unknown(2) = 6 bytes
-        size_t spellEntrySize = vanillaFormat ? 4 : 6;
-        if (!packet.hasRemaining(spellEntrySize)) {
-            LOG_WARNING("SMSG_INITIAL_SPELLS: spell ", i, " truncated (", spellCount, " expected)");
-            break;
-        }
-
         uint32_t spellId;
         if (vanillaFormat) {
             spellId = packet.readUInt16();
@@ -3677,35 +2860,9 @@ bool InitialSpellsParser::parse(network::Packet& packet, InitialSpellsData& data
         }
     }
 
-    // Validate minimum packet size for cooldownCount (2 bytes)
-    if (!packet.hasRemaining(2)) {
-        LOG_WARNING("SMSG_INITIAL_SPELLS: truncated before cooldownCount (parsed ", data.spellIds.size(),
-                    " spells)");
-        return true;  // Have spells; cooldowns are optional
-    }
-
     uint16_t cooldownCount = packet.readUInt16();
-
-    // Cap cooldown count to prevent excessive iteration.
-    // Some servers include entries for all spells (even with zero remaining time)
-    // to communicate category cooldown data, so the count can be high.
-    constexpr uint16_t kMaxCooldowns = 1024;
-    if (cooldownCount > kMaxCooldowns) {
-        LOG_WARNING("SMSG_INITIAL_SPELLS: cooldownCount=", cooldownCount, " exceeds max ", kMaxCooldowns,
-                    ", capping");
-        cooldownCount = kMaxCooldowns;
-    }
-
     data.cooldowns.reserve(cooldownCount);
     for (uint16_t i = 0; i < cooldownCount; ++i) {
-        // Vanilla cooldown: spellId(2) + itemId(2) + categoryId(2) + cooldownMs(4) + categoryCooldownMs(4) = 14 bytes
-        // TBC/WotLK cooldown: spellId(4) + itemId(2) + categoryId(2) + cooldownMs(4) + categoryCooldownMs(4) = 16 bytes
-        size_t cooldownEntrySize = vanillaFormat ? 14 : 16;
-        if (!packet.hasRemaining(cooldownEntrySize)) {
-            LOG_WARNING("SMSG_INITIAL_SPELLS: cooldown ", i, " truncated (", cooldownCount, " expected)");
-            break;
-        }
-
         SpellCooldownEntry entry;
         if (vanillaFormat) {
             entry.spellId = packet.readUInt16();
@@ -3722,13 +2879,14 @@ bool InitialSpellsParser::parse(network::Packet& packet, InitialSpellsData& data
     LOG_INFO("Initial spells parsed: ", data.spellIds.size(), " spells, ",
              data.cooldowns.size(), " cooldowns");
 
+    // Log first 10 spell IDs for debugging
     if (!data.spellIds.empty()) {
         std::string first10;
         for (size_t i = 0; i < std::min(size_t(10), data.spellIds.size()); ++i) {
             if (!first10.empty()) first10 += ", ";
             first10 += std::to_string(data.spellIds[i]);
         }
-        LOG_DEBUG("Initial spell IDs (first 10): ", first10);
+        LOG_INFO("First spells: ", first10);
     }
 
     return true;
@@ -3776,100 +2934,35 @@ network::Packet CancelAuraPacket::build(uint32_t spellId) {
     return packet;
 }
 
-network::Packet PetActionPacket::build(uint64_t petGuid, uint32_t action, uint64_t targetGuid) {
-    // CMSG_PET_ACTION: petGuid(8) + action(4) + targetGuid(8)
+network::Packet PetActionPacket::build(uint64_t petGuid, uint32_t action) {
     network::Packet packet(wireOpcode(Opcode::CMSG_PET_ACTION));
     packet.writeUInt64(petGuid);
     packet.writeUInt32(action);
-    packet.writeUInt64(targetGuid);
     return packet;
 }
 
 bool CastFailedParser::parse(network::Packet& packet, CastFailedData& data) {
-    // WotLK format: castCount(1) + spellId(4) + result(1) = 6 bytes minimum
-    if (!packet.hasRemaining(6)) return false;
-
     data.castCount = packet.readUInt8();
     data.spellId = packet.readUInt32();
     data.result = packet.readUInt8();
-    LOG_INFO("Cast failed: spell=", data.spellId, " result=", static_cast<int>(data.result));
+    LOG_INFO("Cast failed: spell=", data.spellId, " result=", (int)data.result);
     return true;
 }
 
 bool SpellStartParser::parse(network::Packet& packet, SpellStartData& data) {
-    data = SpellStartData{};
-
-    // Packed GUIDs are variable-length; only require minimal packet shape up front:
-    // two GUID masks + castCount(1) + spellId(4) + castFlags(4) + castTime(4).
-    if (!packet.hasRemaining(15)) return false;
-
-    size_t startPos = packet.getReadPos();
-    if (!packet.hasFullPackedGuid()) {
-        return false;
-    }
-    data.casterGuid = packet.readPackedGuid();
-    if (!packet.hasFullPackedGuid()) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.casterUnit = packet.readPackedGuid();
-
-    // Validate remaining fixed fields (castCount + spellId + castFlags + castTime = 13 bytes)
-    if (!packet.hasRemaining(13)) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-
+    data.casterGuid = UpdateObjectParser::readPackedGuid(packet);
+    data.casterUnit = UpdateObjectParser::readPackedGuid(packet);
     data.castCount = packet.readUInt8();
     data.spellId = packet.readUInt32();
     data.castFlags = packet.readUInt32();
     data.castTime = packet.readUInt32();
 
-    // SpellCastTargets starts with target flags and is mandatory.
-    if (!packet.hasRemaining(4)) {
-        LOG_WARNING("Spell start: missing targetFlags");
-        packet.setReadPos(startPos);
-        return false;
-    }
-
-    // WotLK 3.3.5a SpellCastTargets — consume ALL target payload bytes so that
-    // subsequent fields (e.g. school mask, cast flags 0x20 extra data) are not
-    // misaligned for ground-targeted or AoE spells.
-    uint32_t targetFlags = packet.readUInt32();
-
-    auto readPackedTarget = [&](uint64_t* out) -> bool {
-        if (!packet.hasFullPackedGuid()) return false;
-        uint64_t g = packet.readPackedGuid();
-        if (out) *out = g;
-        return true;
-    };
-    auto skipPackedAndFloats3 = [&]() -> bool {
-        if (!packet.hasFullPackedGuid()) return false;
-        packet.readPackedGuid(); // transport GUID (may be zero)
-        if (!packet.hasRemaining(12)) return false;
-        packet.readFloat(); packet.readFloat(); packet.readFloat();
-        return true;
-    };
-
-    // UNIT/UNIT_MINIPET/CORPSE_ALLY/GAMEOBJECT share a single object target GUID
-    if (targetFlags & (0x0002u | 0x0004u | 0x0400u | 0x0800u)) {
-        readPackedTarget(&data.targetGuid); // best-effort; ignore failure
-    }
-    // ITEM/TRADE_ITEM share a single item target GUID
-    if (targetFlags & (0x0010u | 0x0100u)) {
-        readPackedTarget(nullptr);
-    }
-    // SOURCE_LOCATION: PackedGuid (transport) + float x,y,z
-    if (targetFlags & 0x0020u) {
-        skipPackedAndFloats3();
-    }
-    // DEST_LOCATION: PackedGuid (transport) + float x,y,z
-    if (targetFlags & 0x0040u) {
-        skipPackedAndFloats3();
-    }
-    // STRING: null-terminated
-    if (targetFlags & 0x0200u) {
-        while (packet.hasData() && packet.readUInt8() != 0) {}
+    // Read target flags and target (simplified)
+    if (packet.getReadPos() < packet.getSize()) {
+        uint32_t targetFlags = packet.readUInt32();
+        if (targetFlags & 0x02) { // TARGET_FLAG_UNIT
+            data.targetGuid = UpdateObjectParser::readPackedGuid(packet);
+        }
     }
 
     LOG_DEBUG("Spell start: spell=", data.spellId, " castTime=", data.castTime, "ms");
@@ -3877,249 +2970,57 @@ bool SpellStartParser::parse(network::Packet& packet, SpellStartData& data) {
 }
 
 bool SpellGoParser::parse(network::Packet& packet, SpellGoData& data) {
-    // Always reset output to avoid stale targets when callers reuse buffers.
-    data = SpellGoData{};
-
-    // Packed GUIDs are variable-length, so only require the smallest possible
-    // shape up front: 2 GUID masks + fixed fields through hitCount.
-    if (!packet.hasRemaining(16)) return false;
-
-    size_t startPos = packet.getReadPos();
-    if (!packet.hasFullPackedGuid()) {
-        return false;
-    }
-    data.casterGuid = packet.readPackedGuid();
-    if (!packet.hasFullPackedGuid()) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.casterUnit = packet.readPackedGuid();
-
-    // Validate remaining fixed fields up to hitCount/missCount
-    if (!packet.hasRemaining(14)) { // castCount(1) + spellId(4) + castFlags(4) + timestamp(4) + hitCount(1)
-        packet.setReadPos(startPos);
-        return false;
-    }
-
+    data.casterGuid = UpdateObjectParser::readPackedGuid(packet);
+    data.casterUnit = UpdateObjectParser::readPackedGuid(packet);
     data.castCount = packet.readUInt8();
     data.spellId = packet.readUInt32();
     data.castFlags = packet.readUInt32();
     // Timestamp in 3.3.5a
     packet.readUInt32();
 
-    const uint8_t rawHitCount = packet.readUInt8();
-    if (rawHitCount > 128) {
-        LOG_WARNING("Spell go: hitCount capped (requested=", static_cast<int>(rawHitCount), ")");
-    }
-    const uint8_t storedHitLimit = std::min<uint8_t>(rawHitCount, 128);
-
-    bool truncatedTargets = false;
-
-    data.hitTargets.reserve(storedHitLimit);
-    for (uint16_t i = 0; i < rawHitCount; ++i) {
-        // WotLK 3.3.5a hit targets are full uint64 GUIDs (not PackedGuid).
-        if (!packet.hasRemaining(8)) {
-            LOG_WARNING("Spell go: truncated hit targets at index ", i, "/", static_cast<int>(rawHitCount));
-            truncatedTargets = true;
-            break;
-        }
-        const uint64_t targetGuid = packet.readUInt64();
-        if (i < storedHitLimit) {
-            data.hitTargets.push_back(targetGuid);
-        }
-    }
-    if (truncatedTargets) {
-        packet.setReadPos(startPos);
-        return false;
-    }
-    data.hitCount = static_cast<uint8_t>(data.hitTargets.size());
-
-    // missCount is mandatory in SMSG_SPELL_GO. Missing byte means truncation.
-    if (!packet.hasRemaining(1)) {
-        LOG_WARNING("Spell go: missing missCount after hit target list");
-        packet.setReadPos(startPos);
-        return false;
+    data.hitCount = packet.readUInt8();
+    data.hitTargets.reserve(data.hitCount);
+    for (uint8_t i = 0; i < data.hitCount; ++i) {
+        data.hitTargets.push_back(packet.readUInt64());
     }
 
-    const size_t missCountPos = packet.getReadPos();
-    const uint8_t rawMissCount = packet.readUInt8();
-    if (rawMissCount > 20) {
-        // Likely offset error — dump context bytes for diagnostics.
-        const auto& raw = packet.getData();
-        std::string hexCtx;
-        size_t dumpStart = (missCountPos >= 8) ? missCountPos - 8 : startPos;
-        size_t dumpEnd = std::min(missCountPos + 16, raw.size());
-        for (size_t i = dumpStart; i < dumpEnd; ++i) {
-            char buf[4];
-            std::snprintf(buf, sizeof(buf), "%02x ", raw[i]);
-            hexCtx += buf;
-            if (i == missCountPos - 1) hexCtx += "[";
-            if (i == missCountPos) hexCtx += "] ";
-        }
-        LOG_WARNING("Spell go: suspect missCount=", static_cast<int>(rawMissCount),
-                    " spell=", data.spellId, " hits=", static_cast<int>(data.hitCount),
-                    " castFlags=0x", std::hex, data.castFlags, std::dec,
-                    " missCountPos=", missCountPos, " pktSize=", packet.getSize(),
-                    " ctx=", hexCtx);
-    }
-    if (rawMissCount > 128) {
-        LOG_WARNING("Spell go: missCount capped (requested=", static_cast<int>(rawMissCount),
-                    ") spell=", data.spellId, " hits=", static_cast<int>(data.hitCount),
-                    " remaining=", packet.getRemainingSize());
-    }
-    const uint8_t storedMissLimit = std::min<uint8_t>(rawMissCount, 128);
+    data.missCount = packet.readUInt8();
+    // Skip miss details for now
 
-    data.missTargets.reserve(storedMissLimit);
-    for (uint16_t i = 0; i < rawMissCount; ++i) {
-        // WotLK 3.3.5a miss targets are full uint64 GUIDs + uint8 missType.
-        // REFLECT additionally appends uint8 reflectResult.
-        if (!packet.hasRemaining(9)) { // 8 GUID + 1 missType
-            LOG_WARNING("Spell go: truncated miss targets at index ", i, "/", static_cast<int>(rawMissCount),
-                        " spell=", data.spellId, " hits=", static_cast<int>(data.hitCount));
-            truncatedTargets = true;
-            break;
-        }
-        SpellGoMissEntry m;
-        m.targetGuid = packet.readUInt64();
-        m.missType = packet.readUInt8();
-        if (m.missType == 11) { // SPELL_MISS_REFLECT
-            if (!packet.hasRemaining(1)) {
-                LOG_WARNING("Spell go: truncated reflect payload at miss index ", i, "/", static_cast<int>(rawMissCount));
-                truncatedTargets = true;
-                break;
-            }
-            (void)packet.readUInt8(); // reflectResult
-        }
-        if (i < storedMissLimit) {
-            data.missTargets.push_back(m);
-        }
-    }
-    data.missCount = static_cast<uint8_t>(data.missTargets.size());
-
-    // If miss targets were truncated, salvage the successfully-parsed hit data
-    // rather than discarding the entire spell. The server already applied effects;
-    // we just need the hit list for UI feedback (combat text, health bars).
-    if (truncatedTargets) {
-        LOG_DEBUG("Spell go: salvaging ", static_cast<int>(data.hitCount), " hits despite miss truncation");
-        packet.skipAll(); // consume remaining bytes
-        return true;
-    }
-
-    // WotLK 3.3.5a SpellCastTargets — consume ALL target payload bytes so that
-    // any trailing fields after the target section are not misaligned for
-    // ground-targeted or AoE spells.  Same layout as SpellStartParser.
-    if (packet.hasData()) {
-        if (packet.hasRemaining(4)) {
-            uint32_t targetFlags = packet.readUInt32();
-
-            auto readPackedTarget = [&](uint64_t* out) -> bool {
-                if (!packet.hasFullPackedGuid()) return false;
-                uint64_t g = packet.readPackedGuid();
-                if (out) *out = g;
-                return true;
-            };
-            auto skipPackedAndFloats3 = [&]() -> bool {
-                if (!packet.hasFullPackedGuid()) return false;
-                packet.readPackedGuid(); // transport GUID
-                if (!packet.hasRemaining(12)) return false;
-                packet.readFloat(); packet.readFloat(); packet.readFloat();
-                return true;
-            };
-
-            // UNIT/UNIT_MINIPET/CORPSE_ALLY/GAMEOBJECT share one object target GUID
-            if (targetFlags & (0x0002u | 0x0004u | 0x0400u | 0x0800u)) {
-                readPackedTarget(&data.targetGuid);
-            }
-            // ITEM/TRADE_ITEM share one item target GUID
-            if (targetFlags & (0x0010u | 0x0100u)) {
-                readPackedTarget(nullptr);
-            }
-            // SOURCE_LOCATION: PackedGuid (transport) + float x,y,z
-            if (targetFlags & 0x0020u) {
-                skipPackedAndFloats3();
-            }
-            // DEST_LOCATION: PackedGuid (transport) + float x,y,z
-            if (targetFlags & 0x0040u) {
-                skipPackedAndFloats3();
-            }
-            // STRING: null-terminated
-            if (targetFlags & 0x0200u) {
-                while (packet.hasData() && packet.readUInt8() != 0) {}
-            }
-        }
-    }
-
-    LOG_DEBUG("Spell go: spell=", data.spellId, " hits=", static_cast<int>(data.hitCount),
-             " misses=", static_cast<int>(data.missCount));
+    LOG_DEBUG("Spell go: spell=", data.spellId, " hits=", (int)data.hitCount,
+             " misses=", (int)data.missCount);
     return true;
 }
 
 bool AuraUpdateParser::parse(network::Packet& packet, AuraUpdateData& data, bool isAll) {
-    // Validation: packed GUID (1-8 bytes minimum for reading)
-    if (!packet.hasRemaining(1)) return false;
-
-    data.guid = packet.readPackedGuid();
-
-    // Cap number of aura entries to prevent unbounded loop DoS
-    uint32_t maxAuras = isAll ? 512 : 1;
-    uint32_t auraCount = 0;
-
-    while (packet.hasData() && auraCount < maxAuras) {
-        // Validate we can read slot (1) + spellId (4) = 5 bytes minimum
-        if (!packet.hasRemaining(5)) {
-            LOG_DEBUG("Aura update: truncated entry at position ", auraCount);
-            break;
-        }
+    data.guid = UpdateObjectParser::readPackedGuid(packet);
 
+    while (packet.getReadPos() < packet.getSize()) {
         uint8_t slot = packet.readUInt8();
         uint32_t spellId = packet.readUInt32();
-        auraCount++;
 
         AuraSlot aura;
         if (spellId != 0) {
             aura.spellId = spellId;
-
-            // Validate flags + level + charges (3 bytes)
-            if (!packet.hasRemaining(3)) {
-                LOG_WARNING("Aura update: truncated flags/level/charges at entry ", auraCount);
-                aura.flags = 0;
-                aura.level = 0;
-                aura.charges = 0;
-            } else {
-                aura.flags = packet.readUInt8();
-                aura.level = packet.readUInt8();
-                aura.charges = packet.readUInt8();
-            }
+            aura.flags = packet.readUInt8();
+            aura.level = packet.readUInt8();
+            aura.charges = packet.readUInt8();
 
             if (!(aura.flags & 0x08)) { // NOT_CASTER flag
-                // Validate space for packed GUID read (minimum 1 byte)
-                if (!packet.hasRemaining(1)) {
-                    aura.casterGuid = 0;
-                } else {
-                    aura.casterGuid = packet.readPackedGuid();
-                }
+                aura.casterGuid = UpdateObjectParser::readPackedGuid(packet);
             }
 
-            if (aura.flags & 0x20) { // DURATION - need 8 bytes (two uint32s)
-                if (!packet.hasRemaining(8)) {
-                    LOG_WARNING("Aura update: truncated duration fields at entry ", auraCount);
-                    aura.maxDurationMs = 0;
-                    aura.durationMs = 0;
-                } else {
-                    aura.maxDurationMs = static_cast<int32_t>(packet.readUInt32());
-                    aura.durationMs = static_cast<int32_t>(packet.readUInt32());
-                }
+            if (aura.flags & 0x20) { // DURATION
+                aura.maxDurationMs = static_cast<int32_t>(packet.readUInt32());
+                aura.durationMs = static_cast<int32_t>(packet.readUInt32());
             }
 
             if (aura.flags & 0x40) { // EFFECT_AMOUNTS
                 // Only read amounts for active effect indices (flags 0x01, 0x02, 0x04)
                 for (int i = 0; i < 3; ++i) {
                     if (aura.flags & (1 << i)) {
-                        if (packet.hasRemaining(4)) {
+                        if (packet.getReadPos() < packet.getSize()) {
                             packet.readUInt32();
-                        } else {
-                            LOG_WARNING("Aura update: truncated effect amount ", i, " at entry ", auraCount);
-                            break;
                         }
                     }
                 }
@@ -4132,35 +3033,19 @@ bool AuraUpdateParser::parse(network::Packet& packet, AuraUpdateData& data, bool
         if (!isAll) break;
     }
 
-    if (auraCount >= maxAuras && packet.hasData()) {
-        LOG_WARNING("Aura update: capped at ", maxAuras, " entries, remaining data ignored");
-    }
-
     LOG_DEBUG("Aura update for 0x", std::hex, data.guid, std::dec,
               ": ", data.updates.size(), " slots");
     return true;
 }
 
 bool SpellCooldownParser::parse(network::Packet& packet, SpellCooldownData& data) {
-    // Upfront validation: guid(8) + flags(1) = 9 bytes minimum
-    if (!packet.hasRemaining(9)) return false;
-
     data.guid = packet.readUInt64();
     data.flags = packet.readUInt8();
 
-    // Cap cooldown entries to prevent unbounded memory allocation (each entry is 8 bytes)
-    uint32_t maxCooldowns = 512;
-    uint32_t cooldownCount = 0;
-
-    while (packet.hasRemaining(8) && cooldownCount < maxCooldowns) {
+    while (packet.getReadPos() + 8 <= packet.getSize()) {
         uint32_t spellId = packet.readUInt32();
         uint32_t cooldownMs = packet.readUInt32();
         data.cooldowns.push_back({spellId, cooldownMs});
-        cooldownCount++;
-    }
-
-    if (cooldownCount >= maxCooldowns && packet.hasRemaining(8)) {
-        LOG_WARNING("Spell cooldowns: capped at ", maxCooldowns, " entries, remaining data ignored");
     }
 
     LOG_DEBUG("Spell cooldowns: ", data.cooldowns.size(), " entries");
@@ -4180,16 +3065,9 @@ network::Packet GroupInvitePacket::build(const std::string& playerName) {
 }
 
 bool GroupInviteResponseParser::parse(network::Packet& packet, GroupInviteResponseData& data) {
-    // Validate minimum packet size: canAccept(1)
-    if (!packet.hasRemaining(1)) {
-        LOG_WARNING("SMSG_GROUP_INVITE: packet too small (", packet.getSize(), " bytes)");
-        return false;
-    }
-
     data.canAccept = packet.readUInt8();
-    // Note: inviterName is a string, which is always safe to read even if empty
     data.inviterName = packet.readString();
-    LOG_INFO("Group invite from: ", data.inviterName, " (canAccept=", static_cast<int>(data.canAccept), ")");
+    LOG_INFO("Group invite from: ", data.inviterName, " (canAccept=", (int)data.canAccept, ")");
     return true;
 }
 
@@ -4204,82 +3082,47 @@ network::Packet GroupDeclinePacket::build() {
     return packet;
 }
 
-bool GroupListParser::parse(network::Packet& packet, GroupListData& data, bool hasRoles) {
-    auto rem = [&]() { return packet.getRemainingSize(); };
-
-    if (rem() < 3) return false;
+bool GroupListParser::parse(network::Packet& packet, GroupListData& data) {
     data.groupType = packet.readUInt8();
-    data.subGroup  = packet.readUInt8();
-    data.flags     = packet.readUInt8();
+    data.subGroup = packet.readUInt8();
+    data.flags = packet.readUInt8();
+    data.roles = packet.readUInt8();
 
-    // WotLK 3.3.5a added a roles byte (tank/healer/dps) for the dungeon finder.
-    // Classic 1.12 and TBC 2.4.3 do not have this byte.
-    if (hasRoles) {
-        if (rem() < 1) return false;
-        data.roles = packet.readUInt8();
-    } else {
-        data.roles = 0;
-    }
-
-    // WotLK: LFG data gated by groupType bit 0x04 (LFD group type)
-    if (hasRoles && (data.groupType & 0x04)) {
-        if (rem() < 5) return false;
-        packet.readUInt8();  // lfg state
+    // Skip LFG data if present
+    if (data.groupType & 0x04) {
+        packet.readUInt8(); // lfg state
         packet.readUInt32(); // lfg entry
-        // WotLK 3.3.5a may or may not send the lfg flags byte — read it only if present
-        if (rem() >= 13) { // enough for lfgFlags(1)+groupGuid(8)+counter(4)
-            packet.readUInt8(); // lfg flags
-        }
+        packet.readUInt8(); // lfg flags (3.3.5a may not have this)
     }
 
-    if (rem() < 12) return false;
     packet.readUInt64(); // group GUID
-    packet.readUInt32(); // update counter
+    packet.readUInt32(); // counter
 
-    if (rem() < 4) return false;
     data.memberCount = packet.readUInt32();
-    if (data.memberCount > 40) {
-        LOG_WARNING("GroupListParser: implausible memberCount=", data.memberCount, ", clamping");
-        data.memberCount = 40;
-    }
     data.members.reserve(data.memberCount);
 
     for (uint32_t i = 0; i < data.memberCount; ++i) {
-        if (rem() == 0) break;
         GroupMember member;
-        member.name     = packet.readString();
-        if (rem() < 8) break;
-        member.guid     = packet.readUInt64();
-        if (rem() < 3) break;
+        member.name = packet.readString();
+        member.guid = packet.readUInt64();
         member.isOnline = packet.readUInt8();
         member.subGroup = packet.readUInt8();
-        member.flags    = packet.readUInt8();
-        // WotLK added per-member roles byte; Classic/TBC do not have it.
-        if (hasRoles) {
-            if (rem() < 1) break;
-            member.roles = packet.readUInt8();
-        } else {
-            member.roles = 0;
-        }
+        member.flags = packet.readUInt8();
+        member.roles = packet.readUInt8();
         data.members.push_back(member);
     }
 
-    if (rem() < 8) {
-        LOG_INFO("Group list: ", data.memberCount, " members (no leader GUID in packet)");
-        return true;
-    }
     data.leaderGuid = packet.readUInt64();
 
-    if (data.memberCount > 0 && rem() >= 10) {
-        data.lootMethod   = packet.readUInt8();
-        data.looterGuid   = packet.readUInt64();
+    if (data.memberCount > 0 && packet.getReadPos() < packet.getSize()) {
+        data.lootMethod = packet.readUInt8();
+        data.looterGuid = packet.readUInt64();
         data.lootThreshold = packet.readUInt8();
-        // Dungeon difficulty (heroic/normal) — Classic doesn't send this; TBC/WotLK do
-        if (rem() >= 1) data.difficultyId     = packet.readUInt8();
-        // Raid difficulty — WotLK only
-        if (rem() >= 1) data.raidDifficultyId = packet.readUInt8();
-        // Extra byte in some 3.3.5a builds
-        if (hasRoles && rem() >= 1) packet.readUInt8();
+        data.difficultyId = packet.readUInt8();
+        data.raidDifficultyId = packet.readUInt8();
+        if (packet.getReadPos() < packet.getSize()) {
+            packet.readUInt8(); // unknown byte
+        }
     }
 
     LOG_INFO("Group list: ", data.memberCount, " members, leader=0x",
@@ -4288,27 +3131,14 @@ bool GroupListParser::parse(network::Packet& packet, GroupListData& data, bool h
 }
 
 bool PartyCommandResultParser::parse(network::Packet& packet, PartyCommandResultData& data) {
-    // Upfront validation: command(4) + name(var) + result(4) = 8 bytes minimum (plus name string)
-    if (!packet.hasRemaining(8)) return false;
-
     data.command = static_cast<PartyCommand>(packet.readUInt32());
     data.name = packet.readString();
-
-    // Validate result field exists (4 bytes)
-    if (!packet.hasRemaining(4)) {
-        data.result = static_cast<PartyResult>(0);
-        return true; // Partial read is acceptable
-    }
-
     data.result = static_cast<PartyResult>(packet.readUInt32());
-    LOG_DEBUG("Party command result: ", static_cast<int>(data.result));
+    LOG_INFO("Party command result: ", (int)data.result);
     return true;
 }
 
 bool GroupDeclineResponseParser::parse(network::Packet& packet, GroupDeclineData& data) {
-    // Upfront validation: playerName is a CString (minimum 1 null terminator)
-    if (!packet.hasRemaining(1)) return false;
-
     data.playerName = packet.readString();
     LOG_INFO("Group decline from: ", data.playerName);
     return true;
@@ -4345,13 +3175,6 @@ network::Packet UseItemPacket::build(uint8_t bagIndex, uint8_t slotIndex, uint64
     return packet;
 }
 
-network::Packet OpenItemPacket::build(uint8_t bagIndex, uint8_t slotIndex) {
-    network::Packet packet(wireOpcode(Opcode::CMSG_OPEN_ITEM));
-    packet.writeUInt8(bagIndex);
-    packet.writeUInt8(slotIndex);
-    return packet;
-}
-
 network::Packet AutoEquipItemPacket::build(uint8_t srcBag, uint8_t srcSlot) {
     network::Packet packet(wireOpcode(Opcode::CMSG_AUTOEQUIP_ITEM));
     packet.writeUInt8(srcBag);
@@ -4368,17 +3191,6 @@ network::Packet SwapItemPacket::build(uint8_t dstBag, uint8_t dstSlot, uint8_t s
     return packet;
 }
 
-network::Packet SplitItemPacket::build(uint8_t srcBag, uint8_t srcSlot,
-                                       uint8_t dstBag, uint8_t dstSlot, uint8_t count) {
-    network::Packet packet(wireOpcode(Opcode::CMSG_SPLIT_ITEM));
-    packet.writeUInt8(srcBag);
-    packet.writeUInt8(srcSlot);
-    packet.writeUInt8(dstBag);
-    packet.writeUInt8(dstSlot);
-    packet.writeUInt8(count);
-    return packet;
-}
-
 network::Packet SwapInvItemPacket::build(uint8_t srcSlot, uint8_t dstSlot) {
     network::Packet packet(wireOpcode(Opcode::CMSG_SWAP_INV_ITEM));
     packet.writeUInt8(srcSlot);
@@ -4397,52 +3209,57 @@ network::Packet LootReleasePacket::build(uint64_t lootGuid) {
     return packet;
 }
 
-bool LootResponseParser::parse(network::Packet& packet, LootResponseData& data, bool isWotlkFormat) {
+bool LootResponseParser::parse(network::Packet& packet, LootResponseData& data) {
     data = LootResponseData{};
-    size_t avail = packet.getRemainingSize();
-
-    // Minimum is guid(8)+lootType(1) = 9 bytes.  Servers send a short packet with
-    // lootType=0 (LOOT_NONE) when loot is unavailable (e.g. chest not yet opened,
-    // needs a key, or another player is looting).  We treat this as an empty-loot
-    // signal and return false so the caller knows not to open the loot window.
-    if (avail < 9) {
-        LOG_WARNING("LootResponseParser: packet too short (", avail, " bytes)");
+    if (packet.getSize() - packet.getReadPos() < 14) {
+        LOG_WARNING("LootResponseParser: packet too short");
         return false;
     }
 
     data.lootGuid = packet.readUInt64();
     data.lootType = packet.readUInt8();
-
-    // Short failure packet — no gold/item data follows.
-    avail = packet.getRemainingSize();
-    if (avail < 5) {
-        LOG_DEBUG("LootResponseParser: lootType=", static_cast<int>(data.lootType), " (empty/failure response)");
-        return false;
-    }
-
     data.gold = packet.readUInt32();
     uint8_t itemCount = packet.readUInt8();
 
-    // Per-item wire size is 22 bytes across all expansions:
-    //   slot(1)+itemId(4)+count(4)+displayInfo(4)+randSuffix(4)+randProp(4)+slotType(1) = 22
-    constexpr size_t kItemSize = 22u;
-
     auto parseLootItemList = [&](uint8_t listCount, bool markQuestItems) -> bool {
         for (uint8_t i = 0; i < listCount; ++i) {
-            size_t remaining = packet.getRemainingSize();
-            if (remaining < kItemSize) {
+            size_t remaining = packet.getSize() - packet.getReadPos();
+            if (remaining < 10) {
                 return false;
             }
 
+            // Prefer the richest format when possible:
+            // 22-byte (WotLK/full): slot+id+count+display+randSuffix+randProp+slotType
+            // 14-byte (compact):    slot+id+count+display+slotType
+            // 10-byte (minimal):    slot+id+count+slotType
+            uint8_t bytesPerItem = 10;
+            if (remaining >= 22) {
+                bytesPerItem = 22;
+            } else if (remaining >= 14) {
+                bytesPerItem = 14;
+            }
+
             LootItem item;
-            item.slotIndex        = packet.readUInt8();
-            item.itemId           = packet.readUInt32();
-            item.count            = packet.readUInt32();
-            item.displayInfoId    = packet.readUInt32();
-            item.randomSuffix     = packet.readUInt32();
-            item.randomPropertyId = packet.readUInt32();
-            item.lootSlotType     = packet.readUInt8();
-            item.isQuestItem      = markQuestItems;
+            item.slotIndex = packet.readUInt8();
+            item.itemId = packet.readUInt32();
+            item.count = packet.readUInt32();
+
+            if (bytesPerItem >= 14) {
+                item.displayInfoId = packet.readUInt32();
+            } else {
+                item.displayInfoId = 0;
+            }
+
+            if (bytesPerItem == 22) {
+                item.randomSuffix = packet.readUInt32();
+                item.randomPropertyId = packet.readUInt32();
+            } else {
+                item.randomSuffix = 0;
+                item.randomPropertyId = 0;
+            }
+
+            item.lootSlotType = packet.readUInt8();
+            item.isQuestItem = markQuestItems;
             data.items.push_back(item);
         }
         return true;
@@ -4454,9 +3271,8 @@ bool LootResponseParser::parse(network::Packet& packet, LootResponseData& data,
         return false;
     }
 
-    // Quest item section only present in WotLK 3.3.5a
     uint8_t questItemCount = 0;
-    if (isWotlkFormat && packet.hasRemaining(1)) {
+    if (packet.getSize() - packet.getReadPos() >= 1) {
         questItemCount = packet.readUInt8();
         data.items.reserve(data.items.size() + questItemCount);
         if (!parseLootItemList(questItemCount, true)) {
@@ -4465,7 +3281,7 @@ bool LootResponseParser::parse(network::Packet& packet, LootResponseData& data,
         }
     }
 
-    LOG_DEBUG("Loot response: ", static_cast<int>(itemCount), " regular + ", static_cast<int>(questItemCount),
+    LOG_INFO("Loot response: ", (int)itemCount, " regular + ", (int)questItemCount,
              " quest items, ", data.gold, " copper");
     return true;
 }
@@ -4533,8 +3349,8 @@ bool QuestDetailsParser::parse(network::Packet& packet, QuestDetailsData& data)
     data.details = normalizeWowTextTokens(packet.readString());
     data.objectives = normalizeWowTextTokens(packet.readString());
 
-    if (!packet.hasRemaining(10)) {
-        LOG_DEBUG("Quest details (short): id=", data.questId, " title='", data.title, "'");
+    if (packet.getReadPos() + 10 > packet.getSize()) {
+        LOG_INFO("Quest details (short): id=", data.questId, " title='", data.title, "'");
         return true;
     }
 
@@ -4544,73 +3360,46 @@ bool QuestDetailsParser::parse(network::Packet& packet, QuestDetailsData& data)
     /*isFinished*/ packet.readUInt8();
 
     // Reward choice items: server always writes 6 entries (QUEST_REWARD_CHOICES_COUNT)
-    if (packet.hasRemaining(4)) {
+    if (packet.getReadPos() + 4 <= packet.getSize()) {
         /*choiceCount*/ packet.readUInt32();
         for (int i = 0; i < 6; i++) {
-            if (!packet.hasRemaining(12)) break;
-            uint32_t itemId = packet.readUInt32();
-            uint32_t count  = packet.readUInt32();
-            uint32_t dispId = packet.readUInt32();
-            if (itemId != 0) {
-                QuestRewardItem ri;
-                ri.itemId = itemId; ri.count = count; ri.displayInfoId = dispId;
-                ri.choiceSlot = static_cast<uint32_t>(i);
-                data.rewardChoiceItems.push_back(ri);
-            }
+            if (packet.getReadPos() + 12 > packet.getSize()) break;
+            packet.readUInt32(); // itemId
+            packet.readUInt32(); // count
+            packet.readUInt32(); // displayInfo
         }
     }
 
     // Reward items: server always writes 4 entries (QUEST_REWARDS_COUNT)
-    if (packet.hasRemaining(4)) {
+    if (packet.getReadPos() + 4 <= packet.getSize()) {
         /*rewardCount*/ packet.readUInt32();
         for (int i = 0; i < 4; i++) {
-            if (!packet.hasRemaining(12)) break;
-            uint32_t itemId = packet.readUInt32();
-            uint32_t count  = packet.readUInt32();
-            uint32_t dispId = packet.readUInt32();
-            if (itemId != 0) {
-                QuestRewardItem ri;
-                ri.itemId = itemId; ri.count = count; ri.displayInfoId = dispId;
-                data.rewardItems.push_back(ri);
-            }
+            if (packet.getReadPos() + 12 > packet.getSize()) break;
+            packet.readUInt32(); // itemId
+            packet.readUInt32(); // count
+            packet.readUInt32(); // displayInfo
         }
     }
 
     // Money and XP rewards
-    if (packet.hasRemaining(4))
+    if (packet.getReadPos() + 4 <= packet.getSize())
         data.rewardMoney = packet.readUInt32();
-    if (packet.hasRemaining(4))
+    if (packet.getReadPos() + 4 <= packet.getSize())
         data.rewardXp = packet.readUInt32();
 
-    LOG_DEBUG("Quest details: id=", data.questId, " title='", data.title, "'");
+    LOG_INFO("Quest details: id=", data.questId, " title='", data.title, "'");
     return true;
 }
 
 bool GossipMessageParser::parse(network::Packet& packet, GossipMessageData& data) {
-    // Upfront validation: npcGuid(8) + menuId(4) + titleTextId(4) + optionCount(4) = 20 bytes minimum
-    if (!packet.hasRemaining(20)) return false;
-
     data.npcGuid = packet.readUInt64();
     data.menuId = packet.readUInt32();
     data.titleTextId = packet.readUInt32();
     uint32_t optionCount = packet.readUInt32();
 
-    // Cap option count to prevent unbounded memory allocation
-    const uint32_t MAX_GOSSIP_OPTIONS = 64;
-    if (optionCount > MAX_GOSSIP_OPTIONS) {
-        LOG_WARNING("GossipMessageParser: optionCount capped (requested=", optionCount, ")");
-        optionCount = MAX_GOSSIP_OPTIONS;
-    }
-
     data.options.clear();
     data.options.reserve(optionCount);
     for (uint32_t i = 0; i < optionCount; ++i) {
-        // Each option: id(4) + icon(1) + isCoded(1) + boxMoney(4) + text(var) + boxText(var)
-        // Minimum: 10 bytes + 2 empty strings (2 null terminators) = 12 bytes
-        if (!packet.hasRemaining(12)) {
-            LOG_WARNING("GossipMessageParser: truncated options at index ", i, "/", optionCount);
-            break;
-        }
         GossipOption opt;
         opt.id = packet.readUInt32();
         opt.icon = packet.readUInt8();
@@ -4621,29 +3410,10 @@ bool GossipMessageParser::parse(network::Packet& packet, GossipMessageData& data
         data.options.push_back(opt);
     }
 
-    // Validate questCount field exists (4 bytes)
-    if (!packet.hasRemaining(4)) {
-        LOG_DEBUG("Gossip: ", data.options.size(), " options (no quest data)");
-        return true;
-    }
-
     uint32_t questCount = packet.readUInt32();
-    // Cap quest count to prevent unbounded memory allocation
-    const uint32_t MAX_GOSSIP_QUESTS = 64;
-    if (questCount > MAX_GOSSIP_QUESTS) {
-        LOG_WARNING("GossipMessageParser: questCount capped (requested=", questCount, ")");
-        questCount = MAX_GOSSIP_QUESTS;
-    }
-
     data.quests.clear();
     data.quests.reserve(questCount);
     for (uint32_t i = 0; i < questCount; ++i) {
-        // Each quest: questId(4) + questIcon(4) + questLevel(4) + questFlags(4) + isRepeatable(1) + title(var)
-        // Minimum: 17 bytes + empty string (1 null terminator) = 18 bytes
-        if (!packet.hasRemaining(18)) {
-            LOG_WARNING("GossipMessageParser: truncated quests at index ", i, "/", questCount);
-            break;
-        }
         GossipQuestItem quest;
         quest.questId = packet.readUInt32();
         quest.questIcon = packet.readUInt32();
@@ -4654,7 +3424,7 @@ bool GossipMessageParser::parse(network::Packet& packet, GossipMessageData& data
         data.quests.push_back(quest);
     }
 
-    LOG_DEBUG("Gossip: ", data.options.size(), " options, ", data.quests.size(), " quests");
+    LOG_INFO("Gossip: ", optionCount, " options, ", questCount, " quests");
     return true;
 }
 
@@ -4679,14 +3449,14 @@ bool BindPointUpdateParser::parse(network::Packet& packet, BindPointUpdateData&
 }
 
 bool QuestRequestItemsParser::parse(network::Packet& packet, QuestRequestItemsData& data) {
-    if (!packet.hasRemaining(20)) return false;
+    if (packet.getSize() - packet.getReadPos() < 20) return false;
     data.npcGuid = packet.readUInt64();
     data.questId = packet.readUInt32();
     data.title = normalizeWowTextTokens(packet.readString());
     data.completionText = normalizeWowTextTokens(packet.readString());
 
-    if (!packet.hasRemaining(9)) {
-        LOG_DEBUG("Quest request items (short): id=", data.questId, " title='", data.title, "'");
+    if (packet.getReadPos() + 9 > packet.getSize()) {
+        LOG_INFO("Quest request items (short): id=", data.questId, " title='", data.title, "'");
         return true;
     }
 
@@ -4702,17 +3472,17 @@ bool QuestRequestItemsParser::parse(network::Packet& packet, QuestRequestItemsDa
         ParsedTail out;
         packet.setReadPos(startPos);
 
-        if (!packet.hasRemaining(prefixSkip)) return out;
+        if (packet.getReadPos() + prefixSkip > packet.getSize()) return out;
         packet.setReadPos(packet.getReadPos() + prefixSkip);
 
-        if (!packet.hasRemaining(8)) return out;
+        if (packet.getReadPos() + 8 > packet.getSize()) return out;
         out.requiredMoney = packet.readUInt32();
         uint32_t requiredItemCount = packet.readUInt32();
         if (requiredItemCount > 64) return out;  // sanity guard against misalignment
 
         out.requiredItems.reserve(requiredItemCount);
         for (uint32_t i = 0; i < requiredItemCount; ++i) {
-            if (!packet.hasRemaining(12)) return out;
+            if (packet.getReadPos() + 12 > packet.getSize()) return out;
             QuestRewardItem item;
             item.itemId = packet.readUInt32();
             item.count = packet.readUInt32();
@@ -4720,7 +3490,7 @@ bool QuestRequestItemsParser::parse(network::Packet& packet, QuestRequestItemsDa
             if (item.itemId != 0) out.requiredItems.push_back(item);
         }
 
-        if (!packet.hasRemaining(4)) return out;
+        if (packet.getReadPos() + 4 > packet.getSize()) return out;
         out.completableFlags = packet.readUInt32();
         out.ok = true;
 
@@ -4733,7 +3503,7 @@ bool QuestRequestItemsParser::parse(network::Packet& packet, QuestRequestItemsDa
         else if (out.requiredMoney <= 100000) out.score += 2;       // <=10g is common
         else if (out.requiredMoney >= 1000000) out.score -= 3;      // implausible for most quests
         if (!out.requiredItems.empty()) out.score += 1;
-        size_t remaining = packet.getRemainingSize();
+        size_t remaining = packet.getSize() - packet.getReadPos();
         if (remaining <= 16) out.score += 3;
         else if (remaining <= 32) out.score += 2;
         else if (remaining <= 64) out.score += 1;
@@ -4762,31 +3532,23 @@ bool QuestRequestItemsParser::parse(network::Packet& packet, QuestRequestItemsDa
     data.completableFlags = chosen->completableFlags;
     data.requiredItems = chosen->requiredItems;
 
-    LOG_DEBUG("Quest request items: id=", data.questId, " title='", data.title,
+    LOG_INFO("Quest request items: id=", data.questId, " title='", data.title,
              "' items=", data.requiredItems.size(), " completable=", data.isCompletable());
     return true;
 }
 
 bool QuestOfferRewardParser::parse(network::Packet& packet, QuestOfferRewardData& data) {
-    if (!packet.hasRemaining(20)) return false;
+    if (packet.getSize() - packet.getReadPos() < 20) return false;
     data.npcGuid = packet.readUInt64();
     data.questId = packet.readUInt32();
     data.title = normalizeWowTextTokens(packet.readString());
     data.rewardText = normalizeWowTextTokens(packet.readString());
 
-    if (!packet.hasRemaining(8)) {
-        LOG_DEBUG("Quest offer reward (short): id=", data.questId, " title='", data.title, "'");
+    if (packet.getReadPos() + 10 > packet.getSize()) {
+        LOG_INFO("Quest offer reward (short): id=", data.questId, " title='", data.title, "'");
         return true;
     }
 
-    // After the two strings the packet contains a variable prefix (autoFinish + optional fields)
-    // before the emoteCount.  Different expansions and server emulator versions differ:
-    //   Classic 1.12   : uint8 autoFinish + uint32 suggestedPlayers  = 5 bytes
-    //   TBC 2.4.3      : uint32 autoFinish + uint32 suggestedPlayers = 8 bytes (variable arrays)
-    //   WotLK 3.3.5a   : uint32 autoFinish + uint32 suggestedPlayers = 8 bytes (fixed 6/4 arrays)
-    // Some vanilla-family servers omit autoFinish entirely (0 bytes of prefix).
-    // We scan prefix sizes 0..16 bytes with both fixed and variable array layouts, scoring each.
-
     struct ParsedTail {
         uint32_t rewardMoney = 0;
         uint32_t rewardXp = 0;
@@ -4794,37 +3556,38 @@ bool QuestOfferRewardParser::parse(network::Packet& packet, QuestOfferRewardData
         std::vector<QuestRewardItem> fixedRewards;
         bool ok = false;
         int score = -1000;
-        size_t prefixSkip = 0;
-        bool fixedArrays = false;
     };
 
-    auto parseTail = [&](size_t startPos, size_t prefixSkip, bool fixedArrays) -> ParsedTail {
+    auto parseTail = [&](size_t startPos, bool hasFlags, bool fixedArrays) -> ParsedTail {
         ParsedTail out;
-        out.prefixSkip  = prefixSkip;
-        out.fixedArrays = fixedArrays;
         packet.setReadPos(startPos);
 
-        // Skip the prefix bytes (autoFinish + optional suggestedPlayers before emoteCount)
-        if (!packet.hasRemaining(prefixSkip)) return out;
-        packet.setReadPos(packet.getReadPos() + prefixSkip);
+        if (packet.getReadPos() + 1 > packet.getSize()) return out;
+        /*autoFinish*/ packet.readUInt8();
+        if (hasFlags) {
+            if (packet.getReadPos() + 4 > packet.getSize()) return out;
+            /*flags*/ packet.readUInt32();
+        }
+        if (packet.getReadPos() + 4 > packet.getSize()) return out;
+        /*suggestedPlayers*/ packet.readUInt32();
 
-        if (!packet.hasRemaining(4)) return out;
+        if (packet.getReadPos() + 4 > packet.getSize()) return out;
         uint32_t emoteCount = packet.readUInt32();
-        if (emoteCount > 32) return out;  // guard against misalignment
+        if (emoteCount > 64) return out;  // guard against misalignment
         for (uint32_t i = 0; i < emoteCount; ++i) {
-            if (!packet.hasRemaining(8)) return out;
+            if (packet.getReadPos() + 8 > packet.getSize()) return out;
             packet.readUInt32(); // delay
-            packet.readUInt32(); // emote type
+            packet.readUInt32(); // emote
         }
 
-        if (!packet.hasRemaining(4)) return out;
+        if (packet.getReadPos() + 4 > packet.getSize()) return out;
         uint32_t choiceCount = packet.readUInt32();
         if (choiceCount > 6) return out;
         uint32_t choiceSlots = fixedArrays ? 6u : choiceCount;
         out.choiceRewards.reserve(choiceCount);
         uint32_t nonZeroChoice = 0;
         for (uint32_t i = 0; i < choiceSlots; ++i) {
-            if (!packet.hasRemaining(12)) return out;
+            if (packet.getReadPos() + 12 > packet.getSize()) return out;
             QuestRewardItem item;
             item.itemId = packet.readUInt32();
             item.count = packet.readUInt32();
@@ -4832,85 +3595,72 @@ bool QuestOfferRewardParser::parse(network::Packet& packet, QuestOfferRewardData
             item.choiceSlot = i;
             if (item.itemId > 0) {
                 out.choiceRewards.push_back(item);
-                ++nonZeroChoice;
+                nonZeroChoice++;
             }
         }
 
-        if (!packet.hasRemaining(4)) return out;
+        if (packet.getReadPos() + 4 > packet.getSize()) return out;
         uint32_t rewardCount = packet.readUInt32();
         if (rewardCount > 4) return out;
         uint32_t rewardSlots = fixedArrays ? 4u : rewardCount;
         out.fixedRewards.reserve(rewardCount);
         uint32_t nonZeroFixed = 0;
         for (uint32_t i = 0; i < rewardSlots; ++i) {
-            if (!packet.hasRemaining(12)) return out;
+            if (packet.getReadPos() + 12 > packet.getSize()) return out;
             QuestRewardItem item;
             item.itemId = packet.readUInt32();
             item.count = packet.readUInt32();
             item.displayInfoId = packet.readUInt32();
             if (item.itemId > 0) {
                 out.fixedRewards.push_back(item);
-                ++nonZeroFixed;
+                nonZeroFixed++;
             }
         }
 
-        if (packet.hasRemaining(4))
+        if (packet.getReadPos() + 4 <= packet.getSize())
             out.rewardMoney = packet.readUInt32();
-        if (packet.hasRemaining(4))
+        if (packet.getReadPos() + 4 <= packet.getSize())
             out.rewardXp = packet.readUInt32();
 
         out.ok = true;
         out.score = 0;
-        // Prefer the standard WotLK/TBC 8-byte prefix (uint32 autoFinish + uint32 suggestedPlayers)
-        if (prefixSkip == 8) out.score += 3;
-        else if (prefixSkip == 5) out.score += 1;  // Classic uint8 autoFinish + uint32 suggestedPlayers
-        // Prefer fixed arrays (WotLK/TBC servers always send 6+4 slots)
-        if (fixedArrays) out.score += 2;
-        // Valid counts
+        if (hasFlags) out.score += 1;
+        if (fixedArrays) out.score += 1;
         if (choiceCount <= 6) out.score += 3;
         if (rewardCount <= 4) out.score += 3;
-        // All non-zero items are within declared counts
-        if (nonZeroChoice <= choiceCount) out.score += 2;
-        if (nonZeroFixed <= rewardCount) out.score += 2;
-        // No bytes left over (or only a few)
-        size_t remaining = packet.getRemainingSize();
-        if (remaining == 0) out.score += 5;
-        else if (remaining <= 4) out.score += 3;
-        else if (remaining <= 8) out.score += 2;
-        else if (remaining <= 16) out.score += 1;
-        else out.score -= static_cast<int>(remaining / 4);
-        // Plausible money/XP values
-        if (out.rewardMoney < 5000000u) out.score += 1;   // < 500g
-        if (out.rewardXp < 200000u) out.score += 1;       // < 200k XP
+        if (fixedArrays) {
+            if (nonZeroChoice <= choiceCount) out.score += 3;
+            if (nonZeroFixed <= rewardCount) out.score += 3;
+        } else {
+            out.score += 3;  // variable arrays align naturally with count
+        }
+        if (packet.getReadPos() <= packet.getSize()) out.score += 2;
+        size_t remaining = packet.getSize() - packet.getReadPos();
+        if (remaining <= 32) out.score += 2;
         return out;
     };
 
     size_t tailStart = packet.getReadPos();
-    // Try prefix sizes 0..16 bytes with both fixed and variable array layouts
-    std::vector<ParsedTail> candidates;
-    candidates.reserve(34);
-    for (size_t skip = 0; skip <= 16; ++skip) {
-        candidates.push_back(parseTail(tailStart, skip, true));   // fixed arrays
-        candidates.push_back(parseTail(tailStart, skip, false));  // variable arrays
-    }
+    ParsedTail a = parseTail(tailStart, true, true);    // WotLK-like (flags + fixed 6/4 arrays)
+    ParsedTail b = parseTail(tailStart, false, true);   // no flags + fixed 6/4 arrays
+    ParsedTail c = parseTail(tailStart, true, false);   // flags + variable arrays
+    ParsedTail d = parseTail(tailStart, false, false);  // classic-like variable arrays
 
     const ParsedTail* best = nullptr;
-    for (const auto& cand : candidates) {
-        if (!cand.ok) continue;
-        if (!best || cand.score > best->score) best = &cand;
+    for (const ParsedTail* cand : {&a, &b, &c, &d}) {
+        if (!cand->ok) continue;
+        if (!best || cand->score > best->score) best = cand;
     }
 
     if (best) {
         data.choiceRewards = best->choiceRewards;
-        data.fixedRewards  = best->fixedRewards;
-        data.rewardMoney   = best->rewardMoney;
-        data.rewardXp      = best->rewardXp;
+        data.fixedRewards = best->fixedRewards;
+        data.rewardMoney = best->rewardMoney;
+        data.rewardXp = best->rewardXp;
     }
 
-    LOG_DEBUG("Quest offer reward: id=", data.questId, " title='", data.title,
-             "' choices=", data.choiceRewards.size(), " fixed=", data.fixedRewards.size(),
-             " prefix=", (best ? best->prefixSkip : size_t(0)),
-             (best && best->fixedArrays ? " fixed" : " var"));
+    LOG_INFO("Quest offer reward: id=", data.questId, " title='", data.title,
+             "' choices=", data.choiceRewards.size(), " fixed=", data.fixedRewards.size());
     return true;
 }
 
@@ -4952,9 +3702,7 @@ network::Packet BuyItemPacket::build(uint64_t vendorGuid, uint32_t itemId, uint3
     packet.writeUInt32(itemId);  // item entry
     packet.writeUInt32(slot);    // vendor slot index from SMSG_LIST_INVENTORY
     packet.writeUInt32(count);
-    // Note: WotLK/AzerothCore expects a trailing byte; Classic/TBC do not.
-    // This static helper always adds it (appropriate for CMaNGOS/AzerothCore).
-    // For Classic/TBC, use the GameHandler::buyItem() path which checks expansion.
+    // WotLK/AzerothCore expects a trailing byte on CMSG_BUY_ITEM.
     packet.writeUInt8(0);
     return packet;
 }
@@ -4975,13 +3723,8 @@ network::Packet BuybackItemPacket::build(uint64_t vendorGuid, uint32_t slot) {
 }
 
 bool ListInventoryParser::parse(network::Packet& packet, ListInventoryData& data) {
-    // Preserve canRepair — it was set by the gossip handler before this packet
-    // arrived and is not part of the wire format.
-    const bool savedCanRepair = data.canRepair;
     data = ListInventoryData{};
-    data.canRepair = savedCanRepair;
-
-    if (!packet.hasRemaining(9)) {
+    if (packet.getSize() - packet.getReadPos() < 9) {
         LOG_WARNING("ListInventoryParser: packet too short");
         return false;
     }
@@ -4997,12 +3740,12 @@ bool ListInventoryParser::parse(network::Packet& packet, ListInventoryData& data
     // Auto-detect whether server sends 7 fields (28 bytes/item) or 8 fields (32 bytes/item).
     // Some servers omit the extendedCost field entirely; reading 8 fields on a 7-field packet
     // misaligns every item after the first and produces garbage prices.
-    size_t remaining = packet.getRemainingSize();
+    size_t remaining = packet.getSize() - packet.getReadPos();
     const size_t bytesPerItemNoExt = 28;
     const size_t bytesPerItemWithExt = 32;
     bool hasExtendedCost = false;
     if (remaining < static_cast<size_t>(itemCount) * bytesPerItemNoExt) {
-        LOG_WARNING("ListInventoryParser: truncated packet (items=", static_cast<int>(itemCount),
+        LOG_WARNING("ListInventoryParser: truncated packet (items=", (int)itemCount,
                     ", remaining=", remaining, ")");
         return false;
     }
@@ -5013,8 +3756,8 @@ bool ListInventoryParser::parse(network::Packet& packet, ListInventoryData& data
     data.items.reserve(itemCount);
     for (uint8_t i = 0; i < itemCount; ++i) {
         const size_t perItemBytes = hasExtendedCost ? bytesPerItemWithExt : bytesPerItemNoExt;
-        if (!packet.hasRemaining(perItemBytes)) {
-            LOG_WARNING("ListInventoryParser: item ", static_cast<int>(i), " truncated");
+        if (packet.getSize() - packet.getReadPos() < perItemBytes) {
+            LOG_WARNING("ListInventoryParser: item ", (int)i, " truncated");
             return false;
         }
         VendorItem item;
@@ -5029,7 +3772,7 @@ bool ListInventoryParser::parse(network::Packet& packet, ListInventoryData& data
         data.items.push_back(item);
     }
 
-    LOG_DEBUG("Vendor inventory: ", static_cast<int>(itemCount), " items (extendedCost: ", hasExtendedCost ? "yes" : "no", ")");
+    LOG_INFO("Vendor inventory: ", (int)itemCount, " items (extendedCost: ", hasExtendedCost ? "yes" : "no", ")");
     return true;
 }
 
@@ -5037,14 +3780,8 @@ bool ListInventoryParser::parse(network::Packet& packet, ListInventoryData& data
 // Trainer
 // ============================================================
 
-bool TrainerListParser::parse(network::Packet& packet, TrainerListData& data, bool isClassic) {
-    // WotLK per-entry: spellId(4) + state(1) + cost(4) + profDialog(4) + profButton(4) +
-    //                  reqLevel(1) + reqSkill(4) + reqSkillValue(4) + chain×3(12) = 38 bytes
-    // Classic per-entry: spellId(4) + state(1) + cost(4) + reqLevel(1) +
-    //                    reqSkill(4) + reqSkillValue(4) + chain×3(12) + unk(4) = 34 bytes
+bool TrainerListParser::parse(network::Packet& packet, TrainerListData& data) {
     data = TrainerListData{};
-    if (!packet.hasRemaining(16)) return false; // guid(8) + type(4) + count(4)
-
     data.trainerGuid = packet.readUInt64();
     data.trainerType = packet.readUInt32();
     uint32_t spellCount = packet.readUInt32();
@@ -5056,48 +3793,24 @@ bool TrainerListParser::parse(network::Packet& packet, TrainerListData& data, bo
 
     data.spells.reserve(spellCount);
     for (uint32_t i = 0; i < spellCount; ++i) {
-        // Validate minimum entry size before reading
-        const size_t minEntrySize = isClassic ? 34 : 38;
-        if (!packet.hasRemaining(minEntrySize)) {
-            LOG_WARNING("TrainerListParser: truncated at spell ", i);
-            break;
-        }
-
         TrainerSpell spell;
-        spell.spellId   = packet.readUInt32();
-        spell.state     = packet.readUInt8();
-        spell.spellCost = packet.readUInt32();
-        if (isClassic) {
-            // Classic 1.12: reqLevel immediately after cost; no profDialog/profButton
-            spell.profDialog = 0;
-            spell.profButton = 0;
-            spell.reqLevel   = packet.readUInt8();
-        } else {
-            // TBC / WotLK: profDialog + profButton before reqLevel
-            spell.profDialog = packet.readUInt32();
-            spell.profButton = packet.readUInt32();
-            spell.reqLevel   = packet.readUInt8();
-        }
-        spell.reqSkill      = packet.readUInt32();
+        spell.spellId    = packet.readUInt32();
+        spell.state      = packet.readUInt8();
+        spell.spellCost  = packet.readUInt32();
+        spell.profDialog = packet.readUInt32();
+        spell.profButton = packet.readUInt32();
+        spell.reqLevel   = packet.readUInt8();
+        spell.reqSkill   = packet.readUInt32();
         spell.reqSkillValue = packet.readUInt32();
-        spell.chainNode1    = packet.readUInt32();
-        spell.chainNode2    = packet.readUInt32();
-        spell.chainNode3    = packet.readUInt32();
-        if (isClassic) {
-            packet.readUInt32(); // trailing unk / sort index
-        }
+        spell.chainNode1 = packet.readUInt32();
+        spell.chainNode2 = packet.readUInt32();
+        spell.chainNode3 = packet.readUInt32();
         data.spells.push_back(spell);
     }
 
-    if (!packet.hasData()) {
-        LOG_WARNING("TrainerListParser: truncated before greeting");
-        data.greeting.clear();
-    } else {
-        data.greeting = packet.readString();
-    }
+    data.greeting = packet.readString();
 
-    LOG_INFO("Trainer list (", isClassic ? "Classic" : "TBC/WotLK", "): ",
-             spellCount, " spells, type=", data.trainerType,
+    LOG_INFO("Trainer list: ", spellCount, " spells, type=", data.trainerType,
              ", greeting=\"", data.greeting, "\"");
     return true;
 }
@@ -5150,8 +3863,8 @@ bool TalentsInfoParser::parse(network::Packet& packet, TalentsInfoData& data) {
         return false;
     }
 
-    LOG_INFO("SMSG_TALENTS_INFO: spec=", static_cast<int>(data.talentSpec),
-             " unspent=", static_cast<int>(data.unspentPoints),
+    LOG_INFO("SMSG_TALENTS_INFO: spec=", (int)data.talentSpec,
+             " unspent=", (int)data.unspentPoints,
              " talentCount=", talentCount,
              " entryCount=", entryCount);
 
@@ -5161,7 +3874,7 @@ bool TalentsInfoParser::parse(network::Packet& packet, TalentsInfoData& data) {
     data.talents.reserve(entryCount);
 
     for (uint16_t i = 0; i < entryCount; ++i) {
-        if (!packet.hasRemaining(5)) {
+        if (packet.getSize() - packet.getReadPos() < 5) {
             LOG_ERROR("SMSG_TALENTS_INFO: truncated entry list at i=", i);
             return false;
         }
@@ -5169,11 +3882,11 @@ bool TalentsInfoParser::parse(network::Packet& packet, TalentsInfoData& data) {
         uint8_t rank = packet.readUInt8();
         data.talents.push_back({id, rank});
 
-        LOG_INFO("  Entry: id=", id, " rank=", static_cast<int>(rank));
+        LOG_INFO("  Entry: id=", id, " rank=", (int)rank);
     }
 
     // Parse glyph tail: glyphSlots + glyphIds[]
-    if (!packet.hasRemaining(1)) {
+    if (packet.getSize() - packet.getReadPos() < 1) {
         LOG_WARNING("SMSG_TALENTS_INFO: no glyph tail data");
         return true;  // Not fatal, older formats may not have glyphs
     }
@@ -5182,17 +3895,17 @@ bool TalentsInfoParser::parse(network::Packet& packet, TalentsInfoData& data) {
 
     // Sanity check: Wrath has 6 glyph slots, cap at 12 for safety
     if (glyphSlots > 12) {
-        LOG_WARNING("SMSG_TALENTS_INFO: glyphSlots too large (", static_cast<int>(glyphSlots), "), clamping to 12");
+        LOG_WARNING("SMSG_TALENTS_INFO: glyphSlots too large (", (int)glyphSlots, "), clamping to 12");
         glyphSlots = 12;
     }
 
-    LOG_INFO("  GlyphSlots: ", static_cast<int>(glyphSlots));
+    LOG_INFO("  GlyphSlots: ", (int)glyphSlots);
 
     data.glyphs.clear();
     data.glyphs.reserve(glyphSlots);
 
     for (uint8_t i = 0; i < glyphSlots; ++i) {
-        if (!packet.hasRemaining(2)) {
+        if (packet.getSize() - packet.getReadPos() < 2) {
             LOG_ERROR("SMSG_TALENTS_INFO: truncated glyph list at i=", i);
             return false;
         }
@@ -5204,7 +3917,7 @@ bool TalentsInfoParser::parse(network::Packet& packet, TalentsInfoData& data) {
     }
 
     LOG_INFO("SMSG_TALENTS_INFO: bytesConsumed=", (packet.getReadPos() - startPos),
-             " bytesRemaining=", (packet.getRemainingSize()));
+             " bytesRemaining=", (packet.getSize() - packet.getReadPos()));
 
     return true;
 }
@@ -5222,14 +3935,6 @@ network::Packet TalentWipeConfirmPacket::build(bool accept) {
     return packet;
 }
 
-network::Packet ActivateTalentGroupPacket::build(uint32_t group) {
-    // CMSG_SET_ACTIVE_TALENT_GROUP_OBSOLETE (0x4C3 in WotLK 3.3.5a)
-    // Payload: uint32 group (0 = primary, 1 = secondary)
-    network::Packet packet(wireOpcode(Opcode::CMSG_SET_ACTIVE_TALENT_GROUP_OBSOLETE));
-    packet.writeUInt32(group);
-    return packet;
-}
-
 // ============================================================
 // Death/Respawn
 // ============================================================
@@ -5240,12 +3945,6 @@ network::Packet RepopRequestPacket::build() {
     return packet;
 }
 
-network::Packet ReclaimCorpsePacket::build(uint64_t guid) {
-    network::Packet packet(wireOpcode(Opcode::CMSG_RECLAIM_CORPSE));
-    packet.writeUInt64(guid);
-    return packet;
-}
-
 network::Packet SpiritHealerActivatePacket::build(uint64_t npcGuid) {
     network::Packet packet(wireOpcode(Opcode::CMSG_SPIRIT_HEALER_ACTIVATE));
     packet.writeUInt64(npcGuid);
@@ -5265,7 +3964,7 @@ network::Packet ResurrectResponsePacket::build(uint64_t casterGuid, bool accept)
 
 bool ShowTaxiNodesParser::parse(network::Packet& packet, ShowTaxiNodesData& data) {
     // Minimum: windowInfo(4) + npcGuid(8) + nearestNode(4) + at least 1 mask uint32(4)
-    size_t remaining = packet.getRemainingSize();
+    size_t remaining = packet.getSize() - packet.getReadPos();
     if (remaining < 4 + 8 + 4 + 4) {
         LOG_ERROR("ShowTaxiNodesParser: packet too short (", remaining, " bytes)");
         return false;
@@ -5274,7 +3973,7 @@ bool ShowTaxiNodesParser::parse(network::Packet& packet, ShowTaxiNodesData& data
     data.npcGuid = packet.readUInt64();
     data.nearestNode = packet.readUInt32();
     // Read as many mask uint32s as available (Classic/Vanilla=4, WotLK=12)
-    size_t maskBytes = packet.getRemainingSize();
+    size_t maskBytes = packet.getSize() - packet.getReadPos();
     uint32_t maskCount = static_cast<uint32_t>(maskBytes / 4);
     if (maskCount > TLK_TAXI_MASK_SIZE) maskCount = TLK_TAXI_MASK_SIZE;
     for (uint32_t i = 0; i < maskCount; ++i) {
@@ -5286,7 +3985,7 @@ bool ShowTaxiNodesParser::parse(network::Packet& packet, ShowTaxiNodesData& data
 }
 
 bool ActivateTaxiReplyParser::parse(network::Packet& packet, ActivateTaxiReplyData& data) {
-    size_t remaining = packet.getRemainingSize();
+    size_t remaining = packet.getSize() - packet.getReadPos();
     if (remaining >= 4) {
         data.result = packet.readUInt32();
     } else if (remaining >= 1) {
@@ -5338,7 +4037,7 @@ network::Packet GetMailListPacket::build(uint64_t mailboxGuid) {
 
 network::Packet SendMailPacket::build(uint64_t mailboxGuid, const std::string& recipient,
                                       const std::string& subject, const std::string& body,
-                                      uint64_t money, uint64_t cod,
+                                      uint32_t money, uint32_t cod,
                                       const std::vector<uint64_t>& itemGuids) {
     // WotLK 3.3.5a format
     network::Packet packet(wireOpcode(Opcode::CMSG_SEND_MAIL));
@@ -5354,8 +4053,8 @@ network::Packet SendMailPacket::build(uint64_t mailboxGuid, const std::string& r
         packet.writeUInt8(i);            // attachment slot index
         packet.writeUInt64(itemGuids[i]);
     }
-    packet.writeUInt64(money);
-    packet.writeUInt64(cod);
+    packet.writeUInt32(money);
+    packet.writeUInt32(cod);
     return packet;
 }
 
@@ -5366,12 +4065,11 @@ network::Packet MailTakeMoneyPacket::build(uint64_t mailboxGuid, uint32_t mailId
     return packet;
 }
 
-network::Packet MailTakeItemPacket::build(uint64_t mailboxGuid, uint32_t mailId, uint32_t itemGuidLow) {
+network::Packet MailTakeItemPacket::build(uint64_t mailboxGuid, uint32_t mailId, uint32_t itemIndex) {
     network::Packet packet(wireOpcode(Opcode::CMSG_MAIL_TAKE_ITEM));
     packet.writeUInt64(mailboxGuid);
     packet.writeUInt32(mailId);
-    // WotLK expects attachment item GUID low, not attachment slot index.
-    packet.writeUInt32(itemGuidLow);
+    packet.writeUInt32(itemIndex);
     return packet;
 }
 
@@ -5394,20 +4092,20 @@ network::Packet MailMarkAsReadPacket::build(uint64_t mailboxGuid, uint32_t mailI
 // PacketParsers::parseMailList — WotLK 3.3.5a format (base/default)
 // ============================================================================
 bool PacketParsers::parseMailList(network::Packet& packet, std::vector<MailMessage>& inbox) {
-    size_t remaining = packet.getRemainingSize();
+    size_t remaining = packet.getSize() - packet.getReadPos();
     if (remaining < 5) return false;
 
     uint32_t totalCount = packet.readUInt32();
     uint8_t shownCount = packet.readUInt8();
     (void)totalCount;
 
-    LOG_INFO("SMSG_MAIL_LIST_RESULT (WotLK): total=", totalCount, " shown=", static_cast<int>(shownCount));
+    LOG_INFO("SMSG_MAIL_LIST_RESULT (WotLK): total=", totalCount, " shown=", (int)shownCount);
 
     inbox.clear();
     inbox.reserve(shownCount);
 
     for (uint8_t i = 0; i < shownCount; ++i) {
-        remaining = packet.getRemainingSize();
+        remaining = packet.getSize() - packet.getReadPos();
         if (remaining < 2) break;
 
         uint16_t msgSize = packet.readUInt16();
@@ -5429,18 +4127,19 @@ bool PacketParsers::parseMailList(network::Packet& packet, std::vector<MailMessa
             default: msg.senderEntry = packet.readUInt32(); break;
         }
 
-        msg.cod = packet.readUInt64();
+        msg.cod = packet.readUInt32();
         packet.readUInt32(); // item text id
         packet.readUInt32(); // unknown
         msg.stationeryId = packet.readUInt32();
-        msg.money = packet.readUInt64();
+        msg.money = packet.readUInt32();
         msg.flags = packet.readUInt32();
         msg.expirationTime = packet.readFloat();
         msg.mailTemplateId = packet.readUInt32();
         msg.subject = packet.readString();
-        // WotLK 3.3.5a always includes body text in SMSG_MAIL_LIST_RESULT.
-        // mailTemplateId != 0 still carries a (possibly empty) body string.
-        msg.body = packet.readString();
+
+        if (msg.mailTemplateId == 0) {
+            msg.body = packet.readString();
+        }
 
         uint8_t attachCount = packet.readUInt8();
         msg.attachments.reserve(attachCount);
@@ -5460,8 +4159,6 @@ bool PacketParsers::parseMailList(network::Packet& packet, std::vector<MailMessa
             att.stackCount = packet.readUInt32();
             att.chargesOrDurability = packet.readUInt32();
             att.maxDurability = packet.readUInt32();
-            packet.readUInt32(); // durability/current durability
-            packet.readUInt8();  // unknown WotLK trailing byte per attachment
             msg.attachments.push_back(att);
         }
 
@@ -5472,7 +4169,7 @@ bool PacketParsers::parseMailList(network::Packet& packet, std::vector<MailMessa
         size_t consumed = packet.getReadPos() - startPos;
         if (consumed < msgSize) {
             size_t skip = msgSize - consumed;
-            for (size_t s = 0; s < skip && packet.hasData(); ++s)
+            for (size_t s = 0; s < skip && packet.getReadPos() < packet.getSize(); ++s)
                 packet.readUInt8();
         }
     }
@@ -5590,7 +4287,7 @@ network::Packet GuildBankSwapItemsPacket::buildInventoryToBank(
 }
 
 bool GuildBankListParser::parse(network::Packet& packet, GuildBankData& data) {
-    if (!packet.hasRemaining(14)) return false;
+    if (packet.getSize() - packet.getReadPos() < 14) return false;
 
     data.money = packet.readUInt64();
     data.tabId = packet.readUInt8();
@@ -5598,61 +4295,25 @@ bool GuildBankListParser::parse(network::Packet& packet, GuildBankData& data) {
     uint8_t fullUpdate = packet.readUInt8();
 
     if (fullUpdate) {
-        if (!packet.hasRemaining(1)) {
-            LOG_WARNING("GuildBankListParser: truncated before tabCount");
-            data.tabs.clear();
-        } else {
-            uint8_t tabCount = packet.readUInt8();
-            // Cap at 8 (normal guild bank tab limit in WoW)
-            if (tabCount > 8) {
-                LOG_WARNING("GuildBankListParser: tabCount capped (requested=", static_cast<int>(tabCount), ")");
-                tabCount = 8;
-            }
-            data.tabs.resize(tabCount);
-            for (uint8_t i = 0; i < tabCount; ++i) {
-                // Validate before reading strings
-                if (!packet.hasData()) {
-                    LOG_WARNING("GuildBankListParser: truncated tab at index ", static_cast<int>(i));
-                    break;
-                }
-                data.tabs[i].tabName = packet.readString();
-                if (!packet.hasData()) {
-                    data.tabs[i].tabIcon.clear();
-                } else {
-                    data.tabs[i].tabIcon = packet.readString();
-                }
-            }
+        uint8_t tabCount = packet.readUInt8();
+        data.tabs.resize(tabCount);
+        for (uint8_t i = 0; i < tabCount; ++i) {
+            data.tabs[i].tabName = packet.readString();
+            data.tabs[i].tabIcon = packet.readString();
         }
     }
 
-    if (!packet.hasRemaining(1)) {
-        LOG_WARNING("GuildBankListParser: truncated before numSlots");
-        data.tabItems.clear();
-        return true;
-    }
-
     uint8_t numSlots = packet.readUInt8();
     data.tabItems.clear();
     for (uint8_t i = 0; i < numSlots; ++i) {
-        // Validate minimum bytes before reading slot (slotId(1) + itemEntry(4) = 5)
-        if (!packet.hasRemaining(5)) {
-            LOG_WARNING("GuildBankListParser: truncated slot at index ", static_cast<int>(i));
-            break;
-        }
         GuildBankItemSlot slot;
         slot.slotId = packet.readUInt8();
         slot.itemEntry = packet.readUInt32();
         if (slot.itemEntry != 0) {
-            // Validate before reading enchant mask
-            if (!packet.hasRemaining(4)) break;
             // Enchant info
             uint32_t enchantMask = packet.readUInt32();
             for (int bit = 0; bit < 10; ++bit) {
                 if (enchantMask & (1u << bit)) {
-                    if (!packet.hasRemaining(12)) {
-                        LOG_WARNING("GuildBankListParser: truncated enchant data");
-                        break;
-                    }
                     uint32_t enchId = packet.readUInt32();
                     uint32_t enchDur = packet.readUInt32();
                     uint32_t enchCharges = packet.readUInt32();
@@ -5660,19 +4321,10 @@ bool GuildBankListParser::parse(network::Packet& packet, GuildBankData& data) {
                     (void)enchDur; (void)enchCharges;
                 }
             }
-            // Validate before reading remaining item fields
-            if (!packet.hasRemaining(12)) {
-                LOG_WARNING("GuildBankListParser: truncated item fields");
-                break;
-            }
             slot.stackCount = packet.readUInt32();
             /*spare=*/ packet.readUInt32();
             slot.randomPropertyId = packet.readUInt32();
             if (slot.randomPropertyId) {
-                if (!packet.hasRemaining(4)) {
-                    LOG_WARNING("GuildBankListParser: truncated suffix factor");
-                    break;
-                }
                 /*suffixFactor=*/ packet.readUInt32();
             }
         }
@@ -5692,7 +4344,7 @@ network::Packet AuctionHelloPacket::build(uint64_t guid) {
 }
 
 bool AuctionHelloParser::parse(network::Packet& packet, AuctionHelloData& data) {
-    size_t remaining = packet.getRemainingSize();
+    size_t remaining = packet.getSize() - packet.getReadPos();
     if (remaining < 12) {
         LOG_WARNING("AuctionHelloParser: too small, remaining=", remaining);
         return false;
@@ -5700,7 +4352,7 @@ bool AuctionHelloParser::parse(network::Packet& packet, AuctionHelloData& data)
     data.auctioneerGuid = packet.readUInt64();
     data.auctionHouseId = packet.readUInt32();
     // WotLK has an extra uint8 enabled field; Vanilla does not
-    if (packet.hasData()) {
+    if (packet.getReadPos() < packet.getSize()) {
         data.enabled = packet.readUInt8();
     } else {
         data.enabled = 1;
@@ -5737,20 +4389,13 @@ network::Packet AuctionListItemsPacket::build(
 network::Packet AuctionSellItemPacket::build(
     uint64_t auctioneerGuid, uint64_t itemGuid,
     uint32_t stackCount, uint32_t bid,
-    uint32_t buyout, uint32_t duration,
-    bool preWotlk)
+    uint32_t buyout, uint32_t duration)
 {
     network::Packet p(wireOpcode(Opcode::CMSG_AUCTION_SELL_ITEM));
     p.writeUInt64(auctioneerGuid);
-    if (!preWotlk) {
-        // WotLK: itemCount(4) + per-item [guid(8) + stackCount(4)]
-        p.writeUInt32(1);
-        p.writeUInt64(itemGuid);
-        p.writeUInt32(stackCount);
-    } else {
-        // Classic/TBC: just itemGuid, no count fields
-        p.writeUInt64(itemGuid);
-    }
+    p.writeUInt32(1);  // item count (WotLK supports multiple, we send 1)
+    p.writeUInt64(itemGuid);
+    p.writeUInt32(stackCount);
     p.writeUInt32(bid);
     p.writeUInt32(buyout);
     p.writeUInt32(duration);
@@ -5792,122 +4437,58 @@ network::Packet AuctionListBidderItemsPacket::build(
     return p;
 }
 
-bool AuctionListResultParser::parse(network::Packet& packet, AuctionListResult& data, int numEnchantSlots) {
-    // Per-entry fixed size: auctionId(4) + itemEntry(4) + enchantSlots×3×4 +
-    //   randProp(4) + suffix(4) + stack(4) + charges(4) + flags(4) +
-    //   ownerGuid(8) + startBid(4) + outbid(4) + buyout(4) + expire(4) +
-    //   bidderGuid(8) + curBid(4)
-    // Classic: numEnchantSlots=1 → 80 bytes/entry
-    // TBC/WotLK: numEnchantSlots=3 → 104 bytes/entry
-    if (!packet.hasRemaining(4)) return false;
+bool AuctionListResultParser::parse(network::Packet& packet, AuctionListResult& data) {
+    if (packet.getSize() - packet.getReadPos() < 4) return false;
 
     uint32_t count = packet.readUInt32();
-    // Cap auction count to prevent unbounded memory allocation
-    const uint32_t MAX_AUCTION_RESULTS = 256;
-    if (count > MAX_AUCTION_RESULTS) {
-        LOG_WARNING("AuctionListResultParser: count capped (requested=", count, ")");
-        count = MAX_AUCTION_RESULTS;
-    }
-
     data.auctions.clear();
     data.auctions.reserve(count);
 
-    const size_t minPerEntry = static_cast<size_t>(8 + numEnchantSlots * 12 + 28 + 8 + 8);
     for (uint32_t i = 0; i < count; ++i) {
-        if (!packet.hasRemaining(minPerEntry)) break;
+        if (packet.getReadPos() + 64 > packet.getSize()) break;
         AuctionEntry e;
         e.auctionId = packet.readUInt32();
         e.itemEntry = packet.readUInt32();
-        // First enchant slot always present
+        // 3 enchant slots: enchantId, duration, charges
         e.enchantId = packet.readUInt32();
-        packet.readUInt32(); // enchant1 duration
-        packet.readUInt32(); // enchant1 charges
-        // Extra enchant slots for TBC/WotLK
-        for (int s = 1; s < numEnchantSlots; ++s) {
-            packet.readUInt32(); // enchant N id
-            packet.readUInt32(); // enchant N duration
-            packet.readUInt32(); // enchant N charges
-        }
+        packet.readUInt32(); // enchant duration
+        packet.readUInt32(); // enchant charges
+        packet.readUInt32(); // enchant2 id
+        packet.readUInt32(); // enchant2 duration
+        packet.readUInt32(); // enchant2 charges
+        packet.readUInt32(); // enchant3 id
+        packet.readUInt32(); // enchant3 duration
+        packet.readUInt32(); // enchant3 charges
         e.randomPropertyId = packet.readUInt32();
-        e.suffixFactor     = packet.readUInt32();
-        e.stackCount       = packet.readUInt32();
+        e.suffixFactor = packet.readUInt32();
+        e.stackCount = packet.readUInt32();
         packet.readUInt32(); // item charges
         packet.readUInt32(); // item flags (unused)
-        e.ownerGuid        = packet.readUInt64();
-        e.startBid         = packet.readUInt32();
-        e.minBidIncrement  = packet.readUInt32();
-        e.buyoutPrice      = packet.readUInt32();
-        e.timeLeftMs       = packet.readUInt32();
-        e.bidderGuid       = packet.readUInt64();
-        e.currentBid       = packet.readUInt32();
+        e.ownerGuid = packet.readUInt64();
+        e.startBid = packet.readUInt32();
+        e.minBidIncrement = packet.readUInt32();
+        e.buyoutPrice = packet.readUInt32();
+        e.timeLeftMs = packet.readUInt32();
+        e.bidderGuid = packet.readUInt64();
+        e.currentBid = packet.readUInt32();
         data.auctions.push_back(e);
     }
 
-    if (packet.hasRemaining(8)) {
-        data.totalCount = packet.readUInt32();
-        data.searchDelay = packet.readUInt32();
-    }
+    data.totalCount = packet.readUInt32();
+    data.searchDelay = packet.readUInt32();
     return true;
 }
 
 bool AuctionCommandResultParser::parse(network::Packet& packet, AuctionCommandResult& data) {
-    if (!packet.hasRemaining(12)) return false;
+    if (packet.getSize() - packet.getReadPos() < 12) return false;
     data.auctionId = packet.readUInt32();
     data.action = packet.readUInt32();
     data.errorCode = packet.readUInt32();
-    if (data.errorCode != 0 && data.action == 2 && packet.hasRemaining(4)) {
+    if (data.errorCode != 0 && data.action == 2 && packet.getReadPos() + 4 <= packet.getSize()) {
         data.bidError = packet.readUInt32();
     }
     return true;
 }
 
-// ============================================================
-// Pet Stable System
-// ============================================================
-
-network::Packet ListStabledPetsPacket::build(uint64_t stableMasterGuid) {
-    network::Packet p(wireOpcode(Opcode::MSG_LIST_STABLED_PETS));
-    p.writeUInt64(stableMasterGuid);
-    return p;
-}
-
-network::Packet StablePetPacket::build(uint64_t stableMasterGuid, uint8_t slot) {
-    network::Packet p(wireOpcode(Opcode::CMSG_STABLE_PET));
-    p.writeUInt64(stableMasterGuid);
-    p.writeUInt8(slot);
-    return p;
-}
-
-network::Packet UnstablePetPacket::build(uint64_t stableMasterGuid, uint32_t petNumber) {
-    network::Packet p(wireOpcode(Opcode::CMSG_UNSTABLE_PET));
-    p.writeUInt64(stableMasterGuid);
-    p.writeUInt32(petNumber);
-    return p;
-}
-
-network::Packet PetRenamePacket::build(uint64_t petGuid, const std::string& name, uint8_t isDeclined) {
-    network::Packet p(wireOpcode(Opcode::CMSG_PET_RENAME));
-    p.writeUInt64(petGuid);
-    p.writeString(name);    // null-terminated
-    p.writeUInt8(isDeclined);
-    return p;
-}
-
-network::Packet SetTitlePacket::build(int32_t titleBit) {
-    // CMSG_SET_TITLE: int32 titleBit (-1 = remove active title)
-    network::Packet p(wireOpcode(Opcode::CMSG_SET_TITLE));
-    p.writeUInt32(static_cast<uint32_t>(titleBit));
-    return p;
-}
-
-network::Packet AlterAppearancePacket::build(uint32_t hairStyle, uint32_t hairColor, uint32_t facialHair) {
-    // CMSG_ALTER_APPEARANCE: uint32 hairStyle + uint32 hairColor + uint32 facialHair
-    network::Packet p(wireOpcode(Opcode::CMSG_ALTER_APPEARANCE));
-    p.writeUInt32(hairStyle);
-    p.writeUInt32(hairColor);
-    p.writeUInt32(facialHair);
-    return p;
-}
-
 } // namespace game
 } // namespace wowee
diff --git a/src/game/zone_manager.cpp b/src/game/zone_manager.cpp
index c7590b2c..10921baf 100644
--- a/src/game/zone_manager.cpp
+++ b/src/game/zone_manager.cpp
@@ -4,7 +4,6 @@
 #include <cstdlib>
 #include <ctime>
 #include <filesystem>
-#include <random>
 #include <unordered_set>
 
 namespace wowee {
@@ -296,12 +295,7 @@ void ZoneManager::initialize() {
     };
     zones[1657] = darnassus;
 
-    // Tile-to-zone fallback mappings for Azeroth (Eastern Kingdoms).
-    // WoW's world is a grid of 64×64 ADT tiles per continent. We encode (tileX, tileY)
-    // into a single key as tileX * 100 + tileY (safe because tileY < 64 < 100).
-    // These ranges are empirically determined from the retail map layout and provide
-    // zone identification when AreaTable.dbc data is unavailable.
-    //
+    // Tile-to-zone mappings for Azeroth (Eastern Kingdoms)
     // Elwynn Forest tiles
     for (int tx = 31; tx <= 34; tx++) {
         for (int ty = 48; ty <= 51; ty++) {
@@ -415,7 +409,7 @@ void ZoneManager::initialize() {
     tileToZone[14 * 100 + 16] = 1657;
     tileToZone[14 * 100 + 17] = 1657;
 
-    // Seed removed — music shuffle now uses a local mt19937 (see pickMusicTrack).
+    std::srand(static_cast<unsigned>(std::time(nullptr)));
 
     LOG_INFO("Zone manager initialized: ", zones.size(), " zones, ", tileToZone.size(), " tile mappings");
 }
@@ -464,8 +458,7 @@ std::string ZoneManager::getRandomMusic(uint32_t zoneId) {
     // Avoid playing the same track back-to-back
     const std::string* pick = pool[0];
     for (int attempts = 0; attempts < 5; ++attempts) {
-        static std::mt19937 musicRng(std::random_device{}());
-        pick = pool[std::uniform_int_distribution<size_t>(0, pool.size() - 1)(musicRng)];
+        pick = pool[std::rand() % pool.size()];
         if (*pick != lastPlayedMusic_) break;
     }
     lastPlayedMusic_ = *pick;
diff --git a/src/main.cpp b/src/main.cpp
index 7ac84715..d3811b3b 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -6,17 +6,8 @@
 #include <cctype>
 #include <string>
 #include <SDL2/SDL.h>
-#ifdef __APPLE__
-#include <mach-o/dyld.h>
-#include <libgen.h>
-#include <unistd.h>
-#endif
 #ifdef __linux__
 #include <X11/Xlib.h>
-#include <execinfo.h>
-#include <unistd.h>
-#include <libgen.h>
-#include <cstring>
 
 // Keep a persistent X11 connection for emergency mouse release in signal handlers.
 // XOpenDisplay inside a signal handler is unreliable, so we open it once at startup.
@@ -33,40 +24,11 @@ static void releaseMouseGrab() {
 static void releaseMouseGrab() {}
 #endif
 
-#ifdef __linux__
-static void crashHandlerSigaction(int sig, siginfo_t* info, void* /*ucontext*/) {
-    releaseMouseGrab();
-    void* frames[64];
-    int n = backtrace(frames, 64);
-    const char* sigName = (sig == SIGSEGV) ? "SIGSEGV" :
-                          (sig == SIGABRT) ? "SIGABRT" :
-                          (sig == SIGFPE)  ? "SIGFPE"  : "UNKNOWN";
-    void* faultAddr = info ? info->si_addr : nullptr;
-    fprintf(stderr, "\n=== CRASH: signal %s (%d) faultAddr=%p ===\n",
-            sigName, sig, faultAddr);
-    backtrace_symbols_fd(frames, n, STDERR_FILENO);
-    FILE* f = fopen("/tmp/wowee_debug.log", "a");
-    if (f) {
-        fprintf(f, "\n=== CRASH: signal %s (%d) faultAddr=%p ===\n",
-                sigName, sig, faultAddr);
-        fflush(f);
-        backtrace_symbols_fd(frames, n, fileno(f));
-        fclose(f);
-    }
-    // Re-raise with default handler
-    struct sigaction sa;
-    memset(&sa, 0, sizeof(sa));
-    sa.sa_handler = SIG_DFL;
-    sigaction(sig, &sa, nullptr);
-    raise(sig);
-}
-#else
 static void crashHandler(int sig) {
     releaseMouseGrab();
     std::signal(sig, SIG_DFL);
     std::raise(sig);
 }
-#endif
 
 static wowee::core::LogLevel readLogLevelFromEnv() {
     const char* raw = std::getenv("WOWEE_LOG_LEVEL");
@@ -84,43 +46,12 @@ static wowee::core::LogLevel readLogLevelFromEnv() {
 int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[]) {
 #ifdef __linux__
     g_emergencyDisplay = XOpenDisplay(nullptr);
-    // Use sigaction for SIGSEGV/SIGABRT/SIGFPE to get si_addr (faulting address)
-    {
-        struct sigaction sa;
-        memset(&sa, 0, sizeof(sa));
-        sa.sa_sigaction = crashHandlerSigaction;
-        sa.sa_flags = SA_SIGINFO;
-        sigaction(SIGSEGV, &sa, nullptr);
-        sigaction(SIGABRT, &sa, nullptr);
-        sigaction(SIGFPE,  &sa, nullptr);
-    }
-    std::signal(SIGTERM, [](int) { std::_Exit(1); });
-    std::signal(SIGINT,  [](int) { std::_Exit(1); });
-#else
+#endif
     std::signal(SIGSEGV, crashHandler);
     std::signal(SIGABRT, crashHandler);
     std::signal(SIGFPE,  crashHandler);
     std::signal(SIGTERM, crashHandler);
     std::signal(SIGINT,  crashHandler);
-#endif
-    // Change working directory to the executable's directory so relative asset
-    // paths (assets/shaders/, Data/, etc.) resolve correctly from any launch location.
-#ifdef __APPLE__
-    {
-        uint32_t bufSize = 0;
-        _NSGetExecutablePath(nullptr, &bufSize);
-        std::string exePath(bufSize, '\0');
-        _NSGetExecutablePath(exePath.data(), &bufSize);
-        if (chdir(dirname(exePath.data())) != 0) {}
-    }
-#elif defined(__linux__)
-    {
-        char buf[4096];
-        ssize_t len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
-        if (len > 0) { buf[len] = '\0'; if (chdir(dirname(buf)) != 0) {} }
-    }
-#endif
-
     try {
         wowee::core::Logger::getInstance().setLogLevel(readLogLevelFromEnv());
         LOG_INFO("=== Wowee Native Client ===");
diff --git a/src/network/packet.cpp b/src/network/packet.cpp
index 2a20298e..d82469b9 100644
--- a/src/network/packet.cpp
+++ b/src/network/packet.cpp
@@ -86,33 +86,6 @@ float Packet::readFloat() {
     return value;
 }
 
-uint64_t Packet::readPackedGuid() {
-    uint8_t mask = readUInt8();
-    if (mask == 0) return 0;
-    uint64_t guid = 0;
-    for (int i = 0; i < 8; ++i) {
-        if (mask & (1 << i))
-            guid |= static_cast<uint64_t>(readUInt8()) << (i * 8);
-    }
-    return guid;
-}
-
-void Packet::writePackedGuid(uint64_t guid) {
-    uint8_t mask = 0;
-    uint8_t guidBytes[8];
-    int count = 0;
-    for (int i = 0; i < 8; ++i) {
-        uint8_t byte = static_cast<uint8_t>((guid >> (i * 8)) & 0xFF);
-        if (byte != 0) {
-            mask |= (1 << i);
-            guidBytes[count++] = byte;
-        }
-    }
-    writeUInt8(mask);
-    for (int i = 0; i < count; ++i)
-        writeUInt8(guidBytes[i]);
-}
-
 std::string Packet::readString() {
     std::string result;
     while (readPos < data.size()) {
diff --git a/src/network/tcp_socket.cpp b/src/network/tcp_socket.cpp
index 33c21ce1..2dbf1b57 100644
--- a/src/network/tcp_socket.cpp
+++ b/src/network/tcp_socket.cpp
@@ -86,11 +86,6 @@ bool TCPSocket::connect(const std::string& host, uint16_t port) {
         }
     }
 
-    // Disable Nagle's algorithm — send small packets immediately.
-    int one = 1;
-    setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY,
-               reinterpret_cast<const char*>(&one), sizeof(one));
-
     connected = true;
     LOG_INFO("Connected to ", host, ":", port);
     return true;
@@ -139,9 +134,6 @@ void TCPSocket::update() {
     bool sawClose = false;
     bool receivedAny = false;
     for (;;) {
-        // 4 KB per recv() call — large enough for any single game packet while keeping
-        // stack usage reasonable. Typical WoW packets are 20-500 bytes; UPDATE_OBJECT
-        // can reach ~2 KB in crowded zones.
         uint8_t buffer[4096];
         ssize_t received = net::portableRecv(sockfd, buffer, sizeof(buffer));
 
@@ -193,7 +185,7 @@ void TCPSocket::tryParsePackets() {
 
         if (expectedSize == 0) {
             // Unknown opcode or need more data to determine size
-            LOG_WARNING("Unknown opcode or indeterminate size: 0x", std::hex, static_cast<int>(opcode), std::dec);
+            LOG_WARNING("Unknown opcode or indeterminate size: 0x", std::hex, (int)opcode, std::dec);
             break;
         }
 
@@ -205,7 +197,7 @@ void TCPSocket::tryParsePackets() {
         }
 
         // We have a complete packet!
-        LOG_DEBUG("Parsing packet: opcode=0x", std::hex, static_cast<int>(opcode), std::dec,
+        LOG_DEBUG("Parsing packet: opcode=0x", std::hex, (int)opcode, std::dec,
                  " size=", expectedSize, " bytes");
 
         // Create packet from buffer data
@@ -293,7 +285,7 @@ size_t TCPSocket::getExpectedPacketSize(uint8_t opcode) {
             return 0;  // Need more data to read size field
 
         default:
-            LOG_WARNING("Unknown auth packet opcode: 0x", std::hex, static_cast<int>(opcode), std::dec);
+            LOG_WARNING("Unknown auth packet opcode: 0x", std::hex, (int)opcode, std::dec);
             return 0;
     }
 }
diff --git a/src/network/world_socket.cpp b/src/network/world_socket.cpp
index a3cc56b9..78c90c8e 100644
--- a/src/network/world_socket.cpp
+++ b/src/network/world_socket.cpp
@@ -1,65 +1,18 @@
 #include "network/world_socket.hpp"
 #include "network/packet.hpp"
 #include "network/net_platform.hpp"
-#include "game/opcode_table.hpp"
 #include "auth/crypto.hpp"
 #include "core/logger.hpp"
-#include "core/profiler.hpp"
 #include <iomanip>
 #include <sstream>
 #include <cstdio>
 #include <fstream>
 #include <cstdlib>
 #include <cstring>
-#include <chrono>
-#include <thread>
 
 namespace {
 constexpr size_t kMaxReceiveBufferBytes = 8 * 1024 * 1024;
-// Per-frame packet budgets prevent a burst of server data from starving the
-// render loop. Tunable via env vars for debugging heavy-traffic scenarios
-// (e.g. SMSG_UPDATE_OBJECT floods on login to crowded zones).
-constexpr int kDefaultMaxParsedPacketsPerUpdate = 64;
-constexpr int kAbsoluteMaxParsedPacketsPerUpdate = 220;
-constexpr int kMinParsedPacketsPerUpdate = 8;
-constexpr int kDefaultMaxPacketCallbacksPerUpdate = 48;
-constexpr int kAbsoluteMaxPacketCallbacksPerUpdate = 64;
-constexpr int kMinPacketCallbacksPerUpdate = 1;
-constexpr int kMaxRecvCallsPerUpdate = 64;
-constexpr size_t kMaxRecvBytesPerUpdate = 512 * 1024;
-constexpr size_t kMaxQueuedPacketCallbacks = 4096;
-constexpr int kAsyncPumpSleepMs = 2;
-constexpr size_t kRecentPacketHistoryLimit = 96;
-constexpr auto kRecentPacketHistoryWindow = std::chrono::seconds(15);
-constexpr const char* kCloseTraceEnv = "WOWEE_NET_CLOSE_TRACE";
-
-inline int parsedPacketsBudgetPerUpdate() {
-    static int budget = []() {
-        const char* raw = std::getenv("WOWEE_NET_MAX_PARSED_PACKETS");
-        if (!raw || !*raw) return kDefaultMaxParsedPacketsPerUpdate;
-        char* end = nullptr;
-        long parsed = std::strtol(raw, &end, 10);
-        if (end == raw) return kDefaultMaxParsedPacketsPerUpdate;
-        if (parsed < kMinParsedPacketsPerUpdate) return kMinParsedPacketsPerUpdate;
-        if (parsed > kAbsoluteMaxParsedPacketsPerUpdate) return kAbsoluteMaxParsedPacketsPerUpdate;
-        return static_cast<int>(parsed);
-    }();
-    return budget;
-}
-
-inline int packetCallbacksBudgetPerUpdate() {
-    static int budget = []() {
-        const char* raw = std::getenv("WOWEE_NET_MAX_PACKET_CALLBACKS");
-        if (!raw || !*raw) return kDefaultMaxPacketCallbacksPerUpdate;
-        char* end = nullptr;
-        long parsed = std::strtol(raw, &end, 10);
-        if (end == raw) return kDefaultMaxPacketCallbacksPerUpdate;
-        if (parsed < kMinPacketCallbacksPerUpdate) return kMinPacketCallbacksPerUpdate;
-        if (parsed > kAbsoluteMaxPacketCallbacksPerUpdate) return kAbsoluteMaxPacketCallbacksPerUpdate;
-        return static_cast<int>(parsed);
-    }();
-    return budget;
-}
+constexpr int kMaxParsedPacketsPerUpdate = 220;
 
 inline bool isLoginPipelineSmsg(uint16_t opcode) {
     switch (opcode) {
@@ -96,14 +49,6 @@ inline bool envFlagEnabled(const char* key, bool defaultValue = false) {
     return !(raw[0] == '0' || raw[0] == 'f' || raw[0] == 'F' ||
              raw[0] == 'n' || raw[0] == 'N');
 }
-
-const char* opcodeNameForTrace(uint16_t wireOpcode) {
-    const auto* table = wowee::game::getActiveOpcodeTable();
-    if (!table) return "UNKNOWN";
-    auto logical = table->fromWire(wireOpcode);
-    if (!logical) return "UNKNOWN";
-    return wowee::game::OpcodeTable::logicalToName(*logical);
-}
 } // namespace
 
 namespace wowee {
@@ -126,7 +71,6 @@ WorldSocket::WorldSocket() {
     receiveBuffer.reserve(64 * 1024);
     useFastRecvAppend_ = envFlagEnabled("WOWEE_NET_FAST_RECV_APPEND", true);
     useParseScratchQueue_ = envFlagEnabled("WOWEE_NET_PARSE_SCRATCH", false);
-    useAsyncPump_ = envFlagEnabled("WOWEE_NET_ASYNC_PUMP", true);
     if (useParseScratchQueue_) {
         LOG_WARNING("WOWEE_NET_PARSE_SCRATCH is temporarily disabled (known unstable); forcing off");
         useParseScratchQueue_ = false;
@@ -135,10 +79,7 @@ WorldSocket::WorldSocket() {
         parsedPacketsScratch_.reserve(64);
     }
     LOG_INFO("WorldSocket net opts: fast_recv_append=", useFastRecvAppend_ ? "on" : "off",
-             " async_pump=", useAsyncPump_ ? "on" : "off",
-             " parse_scratch=", useParseScratchQueue_ ? "on" : "off",
-             " max_parsed_packets=", parsedPacketsBudgetPerUpdate(),
-             " max_packet_callbacks=", packetCallbacksBudgetPerUpdate());
+             " parse_scratch=", useParseScratchQueue_ ? "on" : "off");
 }
 
 WorldSocket::~WorldSocket() {
@@ -148,8 +89,6 @@ WorldSocket::~WorldSocket() {
 bool WorldSocket::connect(const std::string& host, uint16_t port) {
     LOG_INFO("Connecting to world server: ", host, ":", port);
 
-    stopAsyncPump();
-
     // Create socket
     sockfd = socket(AF_INET, SOCK_STREAM, 0);
     if (sockfd == INVALID_SOCK) {
@@ -224,108 +163,37 @@ bool WorldSocket::connect(const std::string& host, uint16_t port) {
         }
     }
 
-    // Disable Nagle's algorithm — send small packets immediately.
-    int one = 1;
-    setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY,
-               reinterpret_cast<const char*>(&one), sizeof(one));
-
     connected = true;
     LOG_INFO("Connected to world server: ", host, ":", port);
-    startAsyncPump();
     return true;
 }
 
 void WorldSocket::disconnect() {
-    stopAsyncPump();
-    {
-        std::lock_guard<std::mutex> lock(ioMutex_);
-        closeSocketNoJoin();
-        encryptionEnabled = false;
-        useVanillaCrypt = false;
-        receiveBuffer.clear();
-        receiveReadOffset_ = 0;
-        parsedPacketsScratch_.clear();
-        headerBytesDecrypted = 0;
-        packetTraceStart_ = {};
-        packetTraceUntil_ = {};
-        packetTraceReason_.clear();
-    }
-    {
-        std::lock_guard<std::mutex> lock(callbackMutex_);
-        pendingPacketCallbacks_.clear();
-    }
-    LOG_INFO("Disconnected from world server");
-}
-
-void WorldSocket::tracePacketsFor(std::chrono::milliseconds duration, const std::string& reason) {
-    std::lock_guard<std::mutex> lock(ioMutex_);
-    packetTraceStart_ = std::chrono::steady_clock::now();
-    packetTraceUntil_ = packetTraceStart_ + duration;
-    packetTraceReason_ = reason;
-    LOG_DEBUG("WS TRACE enabled: reason='", packetTraceReason_,
-              "' durationMs=", duration.count());
-}
-
-bool WorldSocket::isConnected() const {
-    std::lock_guard<std::mutex> lock(ioMutex_);
-    return connected;
-}
-
-void WorldSocket::closeSocketNoJoin() {
     if (sockfd != INVALID_SOCK) {
         net::closeSocket(sockfd);
         sockfd = INVALID_SOCK;
     }
     connected = false;
+    encryptionEnabled = false;
+    useVanillaCrypt = false;
+    receiveBuffer.clear();
+    receiveReadOffset_ = 0;
+    parsedPacketsScratch_.clear();
+    headerBytesDecrypted = 0;
+    LOG_INFO("Disconnected from world server");
 }
 
-void WorldSocket::recordRecentPacket(bool outbound, uint16_t opcode, uint16_t payloadLen) {
-    const auto now = std::chrono::steady_clock::now();
-    recentPacketHistory_.push_back(RecentPacketTrace{now, outbound, opcode, payloadLen});
-    while (!recentPacketHistory_.empty() &&
-           (recentPacketHistory_.size() > kRecentPacketHistoryLimit ||
-            (now - recentPacketHistory_.front().when) > kRecentPacketHistoryWindow)) {
-        recentPacketHistory_.pop_front();
-    }
-}
-
-void WorldSocket::dumpRecentPacketHistoryLocked(const char* reason, size_t bufferedBytes) {
-    if (recentPacketHistory_.empty()) {
-        LOG_WARNING("WS CLOSE TRACE reason='", reason, "' buffered=", bufferedBytes,
-                  " no recent packet history");
-        return;
-    }
-
-    const auto lastWhen = recentPacketHistory_.back().when;
-    LOG_WARNING("WS CLOSE TRACE reason='", reason, "' buffered=", bufferedBytes,
-              " recentPackets=", recentPacketHistory_.size());
-    for (const auto& entry : recentPacketHistory_) {
-        const auto ageMs = std::chrono::duration_cast<std::chrono::milliseconds>(
-            lastWhen - entry.when).count();
-        LOG_WARNING("WS CLOSE TRACE ", entry.outbound ? "TX" : "RX",
-                  " -", ageMs, "ms opcode=0x",
-                  std::hex, entry.opcode, std::dec,
-                  " logical=", opcodeNameForTrace(entry.opcode),
-                  " payload=", entry.payloadLen);
-    }
+bool WorldSocket::isConnected() const {
+    return connected;
 }
 
 void WorldSocket::send(const Packet& packet) {
+    if (!connected) return;
     static const bool kLogCharCreatePayload = envFlagEnabled("WOWEE_NET_LOG_CHAR_CREATE", false);
     static const bool kLogSwapItemPackets = envFlagEnabled("WOWEE_NET_LOG_SWAP_ITEM", false);
-    std::lock_guard<std::mutex> lock(ioMutex_);
-    if (!connected || sockfd == INVALID_SOCK) return;
 
     const auto& data = packet.getData();
     uint16_t opcode = packet.getOpcode();
-    // CMSG header uses a 16-bit size field, so payloads > 64KB are unsupported.
-    // Guard here rather than silently truncating via cast, which would write a
-    // wrong size to the header while still appending all bytes.
-    if (data.size() > 0xFFFF) {
-        LOG_ERROR("Packet payload too large for CMSG header: ", data.size(),
-                  " bytes (opcode=0x", std::hex, opcode, std::dec, "). Dropping.");
-        return;
-    }
     uint16_t payloadLen = static_cast<uint16_t>(data.size());
 
     // Debug: parse and log character-create payload fields (helps diagnose appearance issues).
@@ -349,24 +217,24 @@ void WorldSocket::send(const Packet& packet) {
             rd8(skin) && rd8(face) && rd8(hairStyle) && rd8(hairColor) && rd8(facial) && rd8(outfit);
         if (ok) {
             LOG_INFO("CMSG_CHAR_CREATE payload: name='", name,
-                     "' race=", static_cast<int>(race), " class=", static_cast<int>(cls), " gender=", static_cast<int>(gender),
-                     " skin=", static_cast<int>(skin), " face=", static_cast<int>(face),
-                     " hairStyle=", static_cast<int>(hairStyle), " hairColor=", static_cast<int>(hairColor),
-                     " facial=", static_cast<int>(facial), " outfit=", static_cast<int>(outfit),
+                     "' race=", (int)race, " class=", (int)cls, " gender=", (int)gender,
+                     " skin=", (int)skin, " face=", (int)face,
+                     " hairStyle=", (int)hairStyle, " hairColor=", (int)hairColor,
+                     " facial=", (int)facial, " outfit=", (int)outfit,
                      " payloadLen=", payloadLen);
             // Persist to disk so we can compare TX vs DB even if the console scrolls away.
             std::ofstream f("charcreate_payload.log", std::ios::app);
             if (f.is_open()) {
                 f << "name='" << name << "'"
-                  << " race=" << static_cast<int>(race)
-                  << " class=" << static_cast<int>(cls)
-                  << " gender=" << static_cast<int>(gender)
-                  << " skin=" << static_cast<int>(skin)
-                  << " face=" << static_cast<int>(face)
-                  << " hairStyle=" << static_cast<int>(hairStyle)
-                  << " hairColor=" << static_cast<int>(hairColor)
-                  << " facial=" << static_cast<int>(facial)
-                  << " outfit=" << static_cast<int>(outfit)
+                  << " race=" << (int)race
+                  << " class=" << (int)cls
+                  << " gender=" << (int)gender
+                  << " skin=" << (int)skin
+                  << " face=" << (int)face
+                  << " hairStyle=" << (int)hairStyle
+                  << " hairColor=" << (int)hairColor
+                  << " facial=" << (int)facial
+                  << " outfit=" << (int)outfit
                   << " payloadLen=" << payloadLen
                   << "\n";
             }
@@ -377,20 +245,13 @@ void WorldSocket::send(const Packet& packet) {
     }
 
     if (kLogSwapItemPackets && (opcode == 0x10C || opcode == 0x10D)) { // CMSG_SWAP_ITEM / CMSG_SWAP_INV_ITEM
-        LOG_INFO("WS TX opcode=0x", std::hex, opcode, std::dec, " payloadLen=", payloadLen,
-                 " data=[", core::toHexString(data.data(), data.size(), true), "]");
-    }
-
-    const auto traceNow = std::chrono::steady_clock::now();
-    recordRecentPacket(true, opcode, payloadLen);
-    if (packetTraceUntil_ > traceNow) {
-        const auto elapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(
-            traceNow - packetTraceStart_).count();
-        LOG_DEBUG("WS TRACE TX +", elapsedMs, "ms opcode=0x",
-                  std::hex, opcode, std::dec,
-                  " logical=", opcodeNameForTrace(opcode),
-                  " payload=", payloadLen,
-                  " reason='", packetTraceReason_, "'");
+        std::string hex;
+        for (size_t i = 0; i < data.size(); i++) {
+            char buf[4];
+            snprintf(buf, sizeof(buf), "%02x ", data[i]);
+            hex += buf;
+        }
+        LOG_INFO("WS TX opcode=0x", std::hex, opcode, std::dec, " payloadLen=", payloadLen, " data=[", hex, "]");
     }
 
     // WotLK 3.3.5 CMSG header (6 bytes total):
@@ -430,82 +291,33 @@ void WorldSocket::send(const Packet& packet) {
 
     // Debug: dump packet bytes for AUTH_SESSION
     if (opcode == 0x1ED) {
-        LOG_DEBUG("AUTH_SESSION raw bytes: ",
-                  core::toHexString(sendData.data(), sendData.size(), true));
+        std::string hexDump = "AUTH_SESSION raw bytes: ";
+        for (size_t i = 0; i < sendData.size(); ++i) {
+            char buf[4];
+            snprintf(buf, sizeof(buf), "%02x ", sendData[i]);
+            hexDump += buf;
+            if ((i + 1) % 32 == 0) hexDump += "\n";
+        }
+        LOG_DEBUG(hexDump);
     }
     if (isLoginPipelineCmsg(opcode)) {
         LOG_INFO("WS TX LOGIN opcode=0x", std::hex, opcode, std::dec,
                  " payload=", payloadLen, " enc=", encryptionEnabled ? "yes" : "no");
     }
 
-    // Send complete packet, retrying on partial sends. Non-blocking sockets
-    // can return fewer bytes than requested when the kernel buffer is full.
-    // Without a retry loop, the server receives a truncated packet and the
-    // TCP stream permanently desyncs (next header lands mid-payload).
-    size_t totalSent = 0;
-    while (totalSent < sendData.size()) {
-        ssize_t sent = net::portableSend(sockfd, sendData.data() + totalSent,
-                                          sendData.size() - totalSent);
-        if (sent < 0) {
-            int err = net::lastError();
-            if (net::isWouldBlock(err)) {
-                // Kernel buffer full — yield briefly and retry.
-                std::this_thread::sleep_for(std::chrono::microseconds(100));
-                continue;
-            }
-            LOG_ERROR("Send failed: ", net::errorString(err));
-            break;
+    // Send complete packet
+    ssize_t sent = net::portableSend(sockfd, sendData.data(), sendData.size());
+    if (sent < 0) {
+        LOG_ERROR("Send failed: ", net::errorString(net::lastError()));
+    } else {
+        if (static_cast<size_t>(sent) != sendData.size()) {
+            LOG_WARNING("Partial send: ", sent, " of ", sendData.size(), " bytes");
         }
-        if (sent == 0) break;  // connection closed
-        totalSent += static_cast<size_t>(sent);
-    }
-    if (totalSent != sendData.size()) {
-        LOG_WARNING("Incomplete send: ", totalSent, " of ", sendData.size(), " bytes");
     }
 }
 
 void WorldSocket::update() {
-    ZoneScopedN("WorldSocket::update");
-    if (!useAsyncPump_) {
-        pumpNetworkIO();
-    }
-    dispatchQueuedPackets();
-}
-
-void WorldSocket::startAsyncPump() {
-    if (!useAsyncPump_ || asyncPumpRunning_.load(std::memory_order_acquire)) {
-        return;
-    }
-    asyncPumpStop_.store(false, std::memory_order_release);
-    asyncPumpThread_ = std::thread(&WorldSocket::asyncPumpLoop, this);
-}
-
-void WorldSocket::stopAsyncPump() {
-    asyncPumpStop_.store(true, std::memory_order_release);
-    if (asyncPumpThread_.joinable()) {
-        asyncPumpThread_.join();
-    }
-    asyncPumpRunning_.store(false, std::memory_order_release);
-}
-
-void WorldSocket::asyncPumpLoop() {
-    asyncPumpRunning_.store(true, std::memory_order_release);
-    while (!asyncPumpStop_.load(std::memory_order_acquire)) {
-        pumpNetworkIO();
-        {
-            std::lock_guard<std::mutex> lock(ioMutex_);
-            if (!connected) {
-                break;
-            }
-        }
-        std::this_thread::sleep_for(std::chrono::milliseconds(kAsyncPumpSleepMs));
-    }
-    asyncPumpRunning_.store(false, std::memory_order_release);
-}
-
-void WorldSocket::pumpNetworkIO() {
-    std::lock_guard<std::mutex> lock(ioMutex_);
-    if (!connected || sockfd == INVALID_SOCK) return;
+    if (!connected) return;
     auto bufferedBytes = [&]() -> size_t {
         return (receiveBuffer.size() >= receiveReadOffset_)
             ? (receiveBuffer.size() - receiveReadOffset_)
@@ -531,8 +343,7 @@ void WorldSocket::pumpNetworkIO() {
     bool receivedAny = false;
     size_t bytesReadThisTick = 0;
     int readOps = 0;
-    while (connected && readOps < kMaxRecvCallsPerUpdate &&
-           bytesReadThisTick < kMaxRecvBytesPerUpdate) {
+    while (connected) {
         uint8_t buffer[4096];
         ssize_t received = net::portableRecv(sockfd, buffer, sizeof(buffer));
 
@@ -551,7 +362,7 @@ void WorldSocket::pumpNetworkIO() {
                     LOG_ERROR("World socket receive buffer would overflow (buffered=", liveBytes,
                               " incoming=", receivedSize, " max=", kMaxReceiveBufferBytes,
                               "). Disconnecting to recover framing.");
-                    closeSocketNoJoin();
+                    disconnect();
                     return;
                 }
                 const size_t oldSize = receiveBuffer.size();
@@ -564,7 +375,7 @@ void WorldSocket::pumpNetworkIO() {
                     if (newCap < needed) {
                         LOG_ERROR("World socket receive buffer capacity growth failed (needed=", needed,
                                   " max=", kMaxReceiveBufferBytes, "). Disconnecting to recover framing.");
-                        closeSocketNoJoin();
+                        disconnect();
                         return;
                     }
                     receiveBuffer.reserve(newCap);
@@ -576,7 +387,7 @@ void WorldSocket::pumpNetworkIO() {
             if (bufferedBytes() > kMaxReceiveBufferBytes) {
                 LOG_ERROR("World socket receive buffer overflow (", bufferedBytes(),
                           " bytes). Disconnecting to recover framing.");
-                closeSocketNoJoin();
+                disconnect();
                 return;
             }
             continue;
@@ -598,7 +409,7 @@ void WorldSocket::pumpNetworkIO() {
         }
 
         LOG_ERROR("Receive failed: ", net::errorString(err));
-        closeSocketNoJoin();
+        disconnect();
         return;
     }
 
@@ -610,9 +421,11 @@ void WorldSocket::pumpNetworkIO() {
         }
         // Hex dump received bytes for auth debugging (debug-only to avoid per-frame string work)
         if (debugLog && bytesReadThisTick <= 128) {
-            LOG_DEBUG("World socket raw bytes: ",
-                      core::toHexString(receiveBuffer.data() + receiveReadOffset_,
-                                        receiveBuffer.size() - receiveReadOffset_, true));
+            std::string hex;
+            for (size_t i = receiveReadOffset_; i < receiveBuffer.size(); ++i) {
+                char buf[4]; snprintf(buf, sizeof(buf), "%02x ", receiveBuffer[i]); hex += buf;
+            }
+            LOG_DEBUG("World socket raw bytes: ", hex);
         }
         tryParsePackets();
         if (debugLog && connected && bufferedBytes() > 0) {
@@ -621,16 +434,10 @@ void WorldSocket::pumpNetworkIO() {
         }
     }
 
-    if (connected && (readOps >= kMaxRecvCallsPerUpdate || bytesReadThisTick >= kMaxRecvBytesPerUpdate)) {
-        LOG_DEBUG("World socket recv budget reached (calls=", readOps,
-                  ", bytes=", bytesReadThisTick, "), deferring remaining socket drain");
-    }
-
     if (sawClose) {
-        dumpRecentPacketHistoryLocked("peer_closed", bufferedBytes());
-        LOG_WARNING("World server connection closed by peer (receivedAny=", receivedAny,
+        LOG_INFO("World server connection closed (receivedAny=", receivedAny,
                  " buffered=", bufferedBytes(), ")");
-        closeSocketNoJoin();
+        disconnect();
         return;
     }
 }
@@ -655,8 +462,7 @@ void WorldSocket::tryParsePackets() {
     } else {
         parsedPacketsLocal.reserve(32);
     }
-    const int maxParsedThisTick = parsedPacketsBudgetPerUpdate();
-    while ((receiveBuffer.size() - parseOffset) >= 4 && parsedThisTick < maxParsedThisTick) {
+    while ((receiveBuffer.size() - parseOffset) >= 4 && parsedThisTick < kMaxParsedPacketsPerUpdate) {
         uint8_t rawHeader[4] = {0, 0, 0, 0};
         std::memcpy(rawHeader, receiveBuffer.data() + parseOffset, 4);
 
@@ -685,10 +491,10 @@ void WorldSocket::tryParsePackets() {
                       static_cast<int>(rawHeader[2]), " ",
                       static_cast<int>(rawHeader[3]), std::dec,
                       " enc=", encryptionEnabled, ". Disconnecting to recover stream.");
-            closeSocketNoJoin();
+            disconnect();
             return;
         }
-        constexpr uint16_t kMaxWorldPacketSize = 0x8000;  // 32KB — allows large guild rosters, auction lists
+        constexpr uint16_t kMaxWorldPacketSize = 0x4000;
         if (size > kMaxWorldPacketSize) {
             LOG_ERROR("World packet framing desync: oversized packet size=", size,
                       " rawHdr=", std::hex,
@@ -697,7 +503,7 @@ void WorldSocket::tryParsePackets() {
                       static_cast<int>(rawHeader[2]), " ",
                       static_cast<int>(rawHeader[3]), std::dec,
                       " enc=", encryptionEnabled, ". Disconnecting to recover stream.");
-            closeSocketNoJoin();
+            disconnect();
             return;
         }
 
@@ -729,17 +535,6 @@ void WorldSocket::tryParsePackets() {
                      " buffered=", (receiveBuffer.size() - parseOffset),
                      " enc=", encryptionEnabled ? "yes" : "no");
         }
-        recordRecentPacket(false, opcode, payloadLen);
-        const auto traceNow = std::chrono::steady_clock::now();
-        if (packetTraceUntil_ > traceNow) {
-            const auto elapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(
-                traceNow - packetTraceStart_).count();
-            LOG_DEBUG("WS TRACE RX +", elapsedMs, "ms opcode=0x",
-                      std::hex, opcode, std::dec,
-                      " logical=", opcodeNameForTrace(opcode),
-                      " payload=", payloadLen,
-                      " reason='", packetTraceReason_, "'");
-        }
 
         if ((receiveBuffer.size() - parseOffset) < totalSize) {
             // Not enough data yet - header stays decrypted in buffer
@@ -760,7 +555,7 @@ void WorldSocket::tryParsePackets() {
                       " payload=", payloadLen, " buffered=", receiveBuffer.size(),
                       " parseOffset=", parseOffset, " what=", e.what(),
                       ". Disconnecting to recover.");
-            closeSocketNoJoin();
+            disconnect();
             return;
         }
         parseOffset += totalSize;
@@ -783,57 +578,23 @@ void WorldSocket::tryParsePackets() {
     }
     headerBytesDecrypted = localHeaderBytesDecrypted;
 
-    // Queue parsed packets for main-thread dispatch.
-    if (!parsedPackets->empty()) {
-        std::lock_guard<std::mutex> callbackLock(callbackMutex_);
-        for (auto& packet : *parsedPackets) {
-            pendingPacketCallbacks_.push_back(std::move(packet));
-        }
-        if (pendingPacketCallbacks_.size() > kMaxQueuedPacketCallbacks) {
-            LOG_ERROR("World socket callback queue overflow (", pendingPacketCallbacks_.size(),
-                      " packets). Disconnecting to recover.");
-            pendingPacketCallbacks_.clear();
-            closeSocketNoJoin();
-            return;
+    if (packetCallback) {
+        for (const auto& packet : *parsedPackets) {
+            if (!connected) break;
+            packetCallback(packet);
         }
     }
 
     const size_t buffered = (receiveBuffer.size() >= receiveReadOffset_)
         ? (receiveBuffer.size() - receiveReadOffset_)
         : 0;
-    if (parsedThisTick >= maxParsedThisTick && buffered >= 4) {
+    if (parsedThisTick >= kMaxParsedPacketsPerUpdate && buffered >= 4) {
         LOG_DEBUG("World socket parse budget reached (", parsedThisTick,
                  " packets); deferring remaining buffered data=", buffered, " bytes");
     }
 }
 
-void WorldSocket::dispatchQueuedPackets() {
-    std::deque<Packet> localPackets;
-    {
-        std::lock_guard<std::mutex> lock(callbackMutex_);
-        if (!packetCallback || pendingPacketCallbacks_.empty()) {
-            return;
-        }
-        const int maxCallbacksThisTick = packetCallbacksBudgetPerUpdate();
-        for (int i = 0; i < maxCallbacksThisTick && !pendingPacketCallbacks_.empty(); ++i) {
-            localPackets.push_back(std::move(pendingPacketCallbacks_.front()));
-            pendingPacketCallbacks_.pop_front();
-        }
-        if (!pendingPacketCallbacks_.empty()) {
-            LOG_DEBUG("World socket callback budget reached (", localPackets.size(),
-                      " callbacks); deferring ", pendingPacketCallbacks_.size(),
-                      " queued packet callbacks");
-        }
-    }
-
-    while (!localPackets.empty()) {
-        packetCallback(localPackets.front());
-        localPackets.pop_front();
-    }
-}
-
 void WorldSocket::initEncryption(const std::vector<uint8_t>& sessionKey, uint32_t build) {
-    std::lock_guard<std::mutex> lock(ioMutex_);
     if (sessionKey.size() != 40) {
         LOG_ERROR("Invalid session key size: ", sessionKey.size(), " (expected 40)");
         return;
diff --git a/src/pipeline/adt_loader.cpp b/src/pipeline/adt_loader.cpp
index 12154407..af3da5ce 100644
--- a/src/pipeline/adt_loader.cpp
+++ b/src/pipeline/adt_loader.cpp
@@ -1,35 +1,31 @@
 #include "pipeline/adt_loader.hpp"
 #include "core/logger.hpp"
-#include "core/profiler.hpp"
 #include <cstring>
 #include <cmath>
 #include <algorithm>
-#include <limits>
 
 namespace wowee {
 namespace pipeline {
 
-// MCVT height grid: 9 outer + 8 inner vertices per row, 9 rows = 145 total.
-// Each row is 17 entries: 9 outer corner vertices then 8 inner midpoints.
-static constexpr int kMCVTVertexCount = 145;
-static constexpr int kMCVTRowStride   = 17;  // 9 outer + 8 inner per row
-
 // HeightMap implementation
 float HeightMap::getHeight(int x, int y) const {
     if (x < 0 || x > 8 || y < 0 || y > 8) {
         return 0.0f;
     }
 
-    // Outer vertex (x, y) in the interleaved grid
-    int index = y * kMCVTRowStride + x;
-    if (index < 0 || index >= kMCVTVertexCount) return 0.0f;
+    // MCVT heights are stored in interleaved 9x17 row-major layout:
+    //   Row 0: 9 outer (indices 0-8), then 8 inner (indices 9-16)
+    //   Row 1: 9 outer (indices 17-25), then 8 inner (indices 26-33)
+    //   ...
+    // Outer vertex (x, y) is at index: y * 17 + x
+    int index = y * 17 + x;
+    if (index < 0 || index >= 145) return 0.0f;
 
     return heights[index];
 }
 
 // ADTLoader implementation
 ADTTerrain ADTLoader::load(const std::vector<uint8_t>& adtData) {
-    ZoneScopedN("ADTLoader::load");
     ADTTerrain terrain;
 
     if (adtData.empty()) {
@@ -54,6 +50,11 @@ ADTTerrain ADTLoader::load(const std::vector<uint8_t>& adtData) {
         size_t chunkSize = header.size;
 
         totalChunks++;
+        if (totalChunks <= 5) {
+            // Log first few chunks for debugging
+            char magic[5] = {0};
+            std::memcpy(magic, &header.magic, 4);
+        }
 
         // Parse based on chunk type
         if (header.magic == MVER) {
@@ -138,15 +139,12 @@ void ADTLoader::parseMVER(const uint8_t* data, size_t size, ADTTerrain& terrain)
 }
 
 void ADTLoader::parseMTEX(const uint8_t* data, size_t size, ADTTerrain& terrain) {
-    // MTEX contains null-terminated texture filenames.
-    // Use bounded scan instead of strlen to avoid reading past the chunk
-    // boundary if the last string is not null-terminated (truncated file).
+    // MTEX contains null-terminated texture filenames
     size_t offset = 0;
 
     while (offset < size) {
         const char* textureName = reinterpret_cast<const char*>(data + offset);
-        size_t maxLen = size - offset;
-        size_t nameLen = strnlen(textureName, maxLen);
+        size_t nameLen = std::strlen(textureName);
 
         if (nameLen == 0) {
             break;
@@ -165,7 +163,7 @@ void ADTLoader::parseMMDX(const uint8_t* data, size_t size, ADTTerrain& terrain)
 
     while (offset < size) {
         const char* modelName = reinterpret_cast<const char*>(data + offset);
-        size_t nameLen = strnlen(modelName, size - offset);
+        size_t nameLen = std::strlen(modelName);
 
         if (nameLen == 0) {
             break;
@@ -184,7 +182,7 @@ void ADTLoader::parseMWMO(const uint8_t* data, size_t size, ADTTerrain& terrain)
 
     while (offset < size) {
         const char* wmoName = reinterpret_cast<const char*>(data + offset);
-        size_t nameLen = strnlen(wmoName, size - offset);
+        size_t nameLen = std::strlen(wmoName);
 
         if (nameLen == 0) {
             break;
@@ -195,6 +193,14 @@ void ADTLoader::parseMWMO(const uint8_t* data, size_t size, ADTTerrain& terrain)
     }
 
     LOG_DEBUG("Loaded ", terrain.wmoNames.size(), " WMO names from MWMO chunk");
+    for (size_t i = 0; i < terrain.wmoNames.size(); i++) {
+        LOG_DEBUG("  WMO[", i, "]: ", terrain.wmoNames[i]);
+        // Flag potential duplicate cathedral models
+        if (terrain.wmoNames[i].find("cathedral") != std::string::npos ||
+            terrain.wmoNames[i].find("Cathedral") != std::string::npos) {
+            LOG_DEBUG("*** CATHEDRAL WMO FOUND: ", terrain.wmoNames[i]);
+        }
+    }
 }
 
 void ADTLoader::parseMDDF(const uint8_t* data, size_t size, ADTTerrain& terrain) {
@@ -250,6 +256,22 @@ void ADTLoader::parseMODF(const uint8_t* data, size_t size, ADTTerrain& terrain)
         placement.doodadSet = readUInt16(data, offset + 58);
 
         terrain.wmoPlacements.push_back(placement);
+
+        // Log STORMWIND.WMO placements to detect duplicates at different Z heights
+        if (placement.nameId < terrain.wmoNames.size()) {
+            const std::string& wmoName = terrain.wmoNames[placement.nameId];
+            std::string upperName = wmoName;
+            std::transform(upperName.begin(), upperName.end(), upperName.begin(), ::toupper);
+
+            if (upperName.find("STORMWIND.WMO") != std::string::npos) {
+                LOG_DEBUG("*** STORMWIND.WMO PLACEMENT:",
+                         " uniqueId=", placement.uniqueId,
+                         " pos=(", placement.position[0], ", ", placement.position[1], ", ", placement.position[2], ")",
+                         " rot=(", placement.rotation[0], ", ", placement.rotation[1], ", ", placement.rotation[2], ")",
+                         " doodadSet=", placement.doodadSet,
+                         " flags=0x", std::hex, placement.flags, std::dec);
+            }
+        }
     }
 
     LOG_DEBUG("Loaded ", terrain.wmoPlacements.size(), " WMO placements");
@@ -307,14 +329,13 @@ void ADTLoader::parseMCNK(const uint8_t* data, size_t size, int chunkIndex, ADTT
     // WoW ADT sub-chunks may have their own 8-byte headers (magic+size)
     // Check by inspecting the first 4 bytes at the offset
 
-    // Height map (MCVT) - 145 floats = 580 bytes.
-    // Guard must include the potential 8-byte sub-chunk header, otherwise the
-    // parser reads up to 8 bytes past the validated range.
-    if (ofsHeight > 0 && ofsHeight + 580 + 8 <= size) {
+    // Height map (MCVT) - 145 floats = 580 bytes
+    if (ofsHeight > 0 && ofsHeight + 580 <= size) {
+        // Check if this points to a sub-chunk header (magic "MCVT" = 0x4D435654)
         uint32_t possibleMagic = readUInt32(data, ofsHeight);
         uint32_t headerSkip = 0;
         if (possibleMagic == MCVT) {
-            headerSkip = 8;
+            headerSkip = 8;  // Skip magic + size
             if (chunkIndex == 0) {
                 LOG_DEBUG("MCNK sub-chunks have headers (MCVT magic found at offset ", ofsHeight, ")");
             }
@@ -322,8 +343,8 @@ void ADTLoader::parseMCNK(const uint8_t* data, size_t size, int chunkIndex, ADTT
         parseMCVT(data + ofsHeight + headerSkip, 580, chunk);
     }
 
-    // Normals (MCNR) - 145 normals (3 bytes each) + 13 padding = 448 bytes.
-    if (ofsNormal > 0 && ofsNormal + 448 + 8 <= size) {
+    // Normals (MCNR) - 145 normals (3 bytes each) + 13 padding = 448 bytes
+    if (ofsNormal > 0 && ofsNormal + 448 <= size) {
         uint32_t possibleMagic = readUInt32(data, ofsNormal);
         uint32_t skip = (possibleMagic == MCNR) ? 8 : 0;
         parseMCNR(data + ofsNormal + skip, 448, chunk);
@@ -359,15 +380,16 @@ void ADTLoader::parseMCNK(const uint8_t* data, size_t size, int chunkIndex, ADTT
 }
 
 void ADTLoader::parseMCVT(const uint8_t* data, size_t size, MapChunk& chunk) {
-    if (size < kMCVTVertexCount * sizeof(float)) {
+    // MCVT contains 145 height values (floats)
+    if (size < 145 * sizeof(float)) {
         LOG_WARNING("MCVT chunk too small: ", size, " bytes");
         return;
     }
 
-    float minHeight = std::numeric_limits<float>::max();
-    float maxHeight = std::numeric_limits<float>::lowest();
+    float minHeight = 999999.0f;
+    float maxHeight = -999999.0f;
 
-    for (int i = 0; i < kMCVTVertexCount; i++) {
+    for (int i = 0; i < 145; i++) {
         float height = readFloat(data, i * sizeof(float));
         chunk.heightMap.heights[i] = height;
 
@@ -389,13 +411,13 @@ void ADTLoader::parseMCVT(const uint8_t* data, size_t size, MapChunk& chunk) {
 }
 
 void ADTLoader::parseMCNR(const uint8_t* data, size_t size, MapChunk& chunk) {
-    // MCNR: one signed XYZ normal per vertex (3 bytes each)
-    if (size < kMCVTVertexCount * 3) {
+    // MCNR contains 145 normals (3 bytes each, signed)
+    if (size < 145 * 3) {
         LOG_WARNING("MCNR chunk too small: ", size, " bytes");
         return;
     }
 
-    for (int i = 0; i < kMCVTVertexCount * 3; i++) {
+    for (int i = 0; i < 145 * 3; i++) {
         chunk.normals[i] = static_cast<int8_t>(data[i]);
     }
 }
diff --git a/src/pipeline/asset_manager.cpp b/src/pipeline/asset_manager.cpp
index 8429bb5b..19fa13f8 100644
--- a/src/pipeline/asset_manager.cpp
+++ b/src/pipeline/asset_manager.cpp
@@ -1,13 +1,11 @@
 #include "pipeline/asset_manager.hpp"
 #include "core/logger.hpp"
 #include "core/memory_monitor.hpp"
-#include "core/profiler.hpp"
 #include <algorithm>
 #include <cstdlib>
 #include <filesystem>
 #include <fstream>
 #include <limits>
-#include <mutex>
 #include <unordered_set>
 
 #include "stb_image.h"
@@ -94,7 +92,7 @@ void AssetManager::setupFileCacheBudget() {
     const size_t envMaxMB = parseEnvSizeMB("WOWEE_FILE_CACHE_MAX_MB");
 
     const size_t minBudgetBytes = 256ull * 1024ull * 1024ull;
-    const size_t defaultMaxBudgetBytes = 12288ull * 1024ull * 1024ull;  // 12 GB max for file cache
+    const size_t defaultMaxBudgetBytes = 32768ull * 1024ull * 1024ull;
     const size_t maxBudgetBytes = (envMaxMB > 0)
         ? (envMaxMB * 1024ull * 1024ull)
         : defaultMaxBudgetBytes;
@@ -119,9 +117,9 @@ void AssetManager::shutdown() {
     LOG_INFO("Shutting down asset manager");
 
     if (fileCacheHits + fileCacheMisses > 0) {
-        float hitRate = static_cast<float>(fileCacheHits) / (fileCacheHits + fileCacheMisses) * 100.0f;
+        float hitRate = (float)fileCacheHits / (fileCacheHits + fileCacheMisses) * 100.0f;
         LOG_INFO("File cache stats: ", fileCacheHits, " hits, ", fileCacheMisses, " misses (",
-                 static_cast<int>(hitRate), "% hit rate), ", fileCacheTotalBytes / 1024 / 1024, " MB cached");
+                 (int)hitRate, "% hit rate), ", fileCacheTotalBytes / 1024 / 1024, " MB cached");
     }
 
     clearCache();
@@ -139,35 +137,11 @@ std::string AssetManager::resolveFile(const std::string& normalizedPath) const {
             }
         }
     }
-    // Primary manifest
-    std::string primaryPath = manifest_.resolveFilesystemPath(normalizedPath);
-    if (!primaryPath.empty()) return primaryPath;
-
-    // If a base-path fallback is configured (expansion-specific primary that only
-    // holds DBC overrides), retry against the base extraction.
-    if (!baseFallbackDataPath_.empty()) {
-        return baseFallbackManifest_.resolveFilesystemPath(normalizedPath);
-    }
-    return {};
-}
-
-void AssetManager::setBaseFallbackPath(const std::string& basePath) {
-    if (basePath.empty() || basePath == dataPath) return;  // nothing to do
-    std::string manifestPath = basePath + "/manifest.json";
-    if (!std::filesystem::exists(manifestPath)) {
-        LOG_DEBUG("AssetManager: base fallback manifest not found at ", manifestPath,
-                  " — fallback disabled");
-        return;
-    }
-    if (baseFallbackManifest_.load(manifestPath)) {
-        baseFallbackDataPath_ = basePath;
-        LOG_INFO("AssetManager: base fallback path set to '", basePath,
-                 "' (", baseFallbackManifest_.getEntryCount(), " files)");
-    }
+    // Fall back to base manifest
+    return manifest_.resolveFilesystemPath(normalizedPath);
 }
 
 BLPImage AssetManager::loadTexture(const std::string& path) {
-    ZoneScopedN("AssetManager::loadTexture");
     if (!initialized) {
         LOG_ERROR("AssetManager not initialized");
         return BLPImage();
@@ -185,12 +159,10 @@ BLPImage AssetManager::loadTexture(const std::string& path) {
 
     std::vector<uint8_t> blpData = readFile(normalizedPath);
     if (blpData.empty()) {
-        static std::mutex logMtx;
         static std::unordered_set<std::string> loggedMissingTextures;
         static bool missingTextureLogSuppressed = false;
         static const size_t kMaxMissingTextureLogKeys =
             parseEnvCount("WOWEE_TEXTURE_MISS_LOG_KEYS", 400);
-        std::lock_guard<std::mutex> lock(logMtx);
         if (loggedMissingTextures.size() < kMaxMissingTextureLogKeys &&
             loggedMissingTextures.insert(normalizedPath).second) {
             LOG_WARNING("Texture not found: ", normalizedPath);
@@ -204,12 +176,10 @@ BLPImage AssetManager::loadTexture(const std::string& path) {
 
     BLPImage image = BLPLoader::load(blpData);
     if (!image.isValid()) {
-        static std::mutex logMtx;
         static std::unordered_set<std::string> loggedDecodeFails;
         static bool decodeFailLogSuppressed = false;
         static const size_t kMaxDecodeFailLogKeys =
             parseEnvCount("WOWEE_TEXTURE_DECODE_LOG_KEYS", 200);
-        std::lock_guard<std::mutex> lock(logMtx);
         if (loggedDecodeFails.size() < kMaxDecodeFailLogKeys &&
             loggedDecodeFails.insert(normalizedPath).second) {
             LOG_ERROR("Failed to load texture: ", normalizedPath);
@@ -235,7 +205,6 @@ BLPImage AssetManager::tryLoadPngOverride(const std::string& normalizedPath) con
     if (fsPath.empty()) return BLPImage();
 
     // Replace .blp/.BLP extension with .png
-    if (fsPath.size() < 4) return BLPImage();
     std::string pngPath = fsPath.substr(0, fsPath.size() - 4) + ".png";
     if (!LooseFileReader::fileExists(pngPath)) {
         return BLPImage();
@@ -267,7 +236,6 @@ void AssetManager::setExpansionDataPath(const std::string& path) {
 }
 
 std::shared_ptr<DBCFile> AssetManager::loadDBC(const std::string& name) {
-    ZoneScopedN("AssetManager::loadDBC");
     if (!initialized) {
         LOG_ERROR("AssetManager not initialized");
         return nullptr;
@@ -289,28 +257,6 @@ std::shared_ptr<DBCFile> AssetManager::loadDBC(const std::string& name) {
         dbcData = readFile(dbcPath);
     }
 
-    // Try Data/db/ directory (pre-extracted binary DBCs shared across expansions)
-    if (dbcData.empty()) {
-        // dataPath is expansion-specific (e.g. Data/expansions/wotlk/); go up to Data/
-        for (const std::string& base : {dataPath + "/db/" + name,
-                                         dataPath + "/../../db/" + name,
-                                         "Data/db/" + name}) {
-            if (std::filesystem::exists(base)) {
-                std::ifstream f(base, std::ios::binary | std::ios::ate);
-                if (f) {
-                    auto size = f.tellg();
-                    if (size > 0) {
-                        f.seekg(0);
-                        dbcData.resize(static_cast<size_t>(size));
-                        f.read(reinterpret_cast<char*>(dbcData.data()), size);
-                        LOG_INFO("Loaded binary DBC from: ", base, " (", size, " bytes)");
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
     // Fall back to expansion-specific CSV (e.g. Data/expansions/wotlk/db/Spell.csv)
     if (dbcData.empty() && !expansionDataPath_.empty()) {
         std::string baseName = name;
@@ -350,55 +296,6 @@ std::shared_ptr<DBCFile> AssetManager::loadDBC(const std::string& name) {
     return dbc;
 }
 
-std::shared_ptr<DBCFile> AssetManager::loadDBCOptional(const std::string& name) {
-    // Check cache first
-    auto it = dbcCache.find(name);
-    if (it != dbcCache.end()) return it->second;
-
-    // Try binary DBC
-    std::vector<uint8_t> dbcData;
-    {
-        std::string dbcPath = "DBFilesClient\\" + name;
-        dbcData = readFile(dbcPath);
-    }
-
-    // Fall back to expansion-specific CSV
-    if (dbcData.empty() && !expansionDataPath_.empty()) {
-        std::string baseName = name;
-        auto dot = baseName.rfind('.');
-        if (dot != std::string::npos) baseName = baseName.substr(0, dot);
-        std::string csvPath = expansionDataPath_ + "/db/" + baseName + ".csv";
-        if (std::filesystem::exists(csvPath)) {
-            std::ifstream f(csvPath, std::ios::binary | std::ios::ate);
-            if (f) {
-                auto size = f.tellg();
-                if (size > 0) {
-                    f.seekg(0);
-                    dbcData.resize(static_cast<size_t>(size));
-                    f.read(reinterpret_cast<char*>(dbcData.data()), size);
-                    LOG_INFO("Binary DBC not found, using CSV fallback: ", csvPath);
-                }
-            }
-        }
-    }
-
-    if (dbcData.empty()) {
-        // Expected on some expansions — log at debug level only.
-        LOG_DEBUG("Optional DBC not found (expected on some expansions): ", name);
-        return nullptr;
-    }
-
-    auto dbc = std::make_shared<DBCFile>();
-    if (!dbc->load(dbcData)) {
-        LOG_ERROR("Failed to load DBC: ", name);
-        return nullptr;
-    }
-
-    dbcCache[name] = dbc;
-    LOG_INFO("Loaded optional DBC: ", name, " (", dbc->getRecordCount(), " records)");
-    return dbc;
-}
-
 std::shared_ptr<DBCFile> AssetManager::getDBC(const std::string& name) const {
     auto it = dbcCache.find(name);
     if (it != dbcCache.end()) {
@@ -422,15 +319,14 @@ std::vector<uint8_t> AssetManager::readFile(const std::string& path) const {
 
     std::string normalized = normalizePath(path);
 
-    // Check cache first (shared lock allows concurrent reads)
+    // Check cache first
     {
-        std::shared_lock<std::shared_mutex> cacheLock(cacheMutex);
+        std::lock_guard<std::mutex> cacheLock(cacheMutex);
         auto it = fileCache.find(normalized);
         if (it != fileCache.end()) {
-            auto data = it->second.data;
-            cacheLock.unlock();
+            it->second.lastAccessTime = ++fileCacheAccessCounter;
             fileCacheHits++;
-            return data;
+            return it->second.data;
         }
     }
 
@@ -449,7 +345,7 @@ std::vector<uint8_t> AssetManager::readFile(const std::string& path) const {
     // Add to cache if within budget
     size_t fileSize = data.size();
     if (fileSize > 0 && fileSize < fileCacheBudget / 2) {
-        std::lock_guard<std::shared_mutex> cacheLock(cacheMutex);
+        std::lock_guard<std::mutex> cacheLock(cacheMutex);
         // Evict old entries if needed (LRU)
         while (fileCacheTotalBytes + fileSize > fileCacheBudget && !fileCache.empty()) {
             auto lru = fileCache.begin();
@@ -483,13 +379,13 @@ std::vector<uint8_t> AssetManager::readFileOptional(const std::string& path) con
 }
 
 void AssetManager::clearDBCCache() {
-    std::lock_guard<std::shared_mutex> lock(cacheMutex);
+    std::lock_guard<std::mutex> lock(cacheMutex);
     dbcCache.clear();
     LOG_INFO("Cleared DBC cache");
 }
 
 void AssetManager::clearCache() {
-    std::lock_guard<std::shared_mutex> lock(cacheMutex);
+    std::lock_guard<std::mutex> lock(cacheMutex);
     dbcCache.clear();
     fileCache.clear();
     fileCacheTotalBytes = 0;
@@ -630,15 +526,6 @@ std::string AssetManager::normalizePath(const std::string& path) const {
     std::replace(normalized.begin(), normalized.end(), '/', '\\');
     std::transform(normalized.begin(), normalized.end(), normalized.begin(),
                    [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-
-    // Reject path traversal sequences
-    if (normalized.find("..\\") != std::string::npos ||
-        normalized.find("../") != std::string::npos ||
-        normalized == "..") {
-        LOG_WARNING("Path traversal rejected: ", path);
-        return {};
-    }
-
     return normalized;
 }
 
diff --git a/src/pipeline/blp_loader.cpp b/src/pipeline/blp_loader.cpp
index 02281dbe..8c817890 100644
--- a/src/pipeline/blp_loader.cpp
+++ b/src/pipeline/blp_loader.cpp
@@ -71,11 +71,8 @@ BLPImage BLPLoader::loadBLP1(const uint8_t* data, size_t size) {
 
     const uint8_t* mipData = data + offset;
 
-    if (image.width <= 0 || image.height <= 0 || image.width > 4096 || image.height > 4096) {
-        LOG_ERROR("BLP1 dimensions out of range: ", image.width, "x", image.height);
-        return BLPImage();
-    }
-    uint32_t pixelCount = static_cast<uint32_t>(image.width) * static_cast<uint32_t>(image.height);
+    // Allocate output buffer
+    int pixelCount = image.width * image.height;
     image.data.resize(pixelCount * 4);  // RGBA8
 
     decompressPalette(mipData, image.data.data(), header.palette,
@@ -129,8 +126,8 @@ BLPImage BLPLoader::loadBLP2(const uint8_t* data, size_t size) {
 
     LOG_DEBUG("Loading BLP2: ", image.width, "x", image.height, " ",
               getCompressionName(image.compression),
-              " (comp=", static_cast<int>(header.compression), " alphaDepth=", static_cast<int>(header.alphaDepth),
-              " alphaEnc=", static_cast<int>(header.alphaEncoding), " mipOfs=", header.mipOffsets[0],
+              " (comp=", (int)header.compression, " alphaDepth=", (int)header.alphaDepth,
+              " alphaEnc=", (int)header.alphaEncoding, " mipOfs=", header.mipOffsets[0],
               " mipSize=", header.mipSizes[0], ")");
 
     // Get first mipmap (full resolution)
@@ -144,19 +141,9 @@ BLPImage BLPLoader::loadBLP2(const uint8_t* data, size_t size) {
 
     const uint8_t* mipData = data + offset;
 
-    if (image.width <= 0 || image.height <= 0 || image.width > 4096 || image.height > 4096) {
-        LOG_ERROR("BLP2 dimensions out of range: ", image.width, "x", image.height);
-        return BLPImage();
-    }
-    uint32_t pixelCount = static_cast<uint32_t>(image.width) * static_cast<uint32_t>(image.height);
-    uint32_t requiredArgb = pixelCount * 4;
-    // For ARGB8888 the source must be at least pixelCount*4 bytes; for DXT/palette
-    // the source is smaller but the decompressors have their own internal bounds.
-    if (image.compression == BLPCompression::ARGB8888 && mipSize < requiredArgb) {
-        LOG_ERROR("BLP2 ARGB8888 mipSize (", mipSize, ") < required (", requiredArgb, ")");
-        return BLPImage();
-    }
-    image.data.resize(requiredArgb);  // RGBA8
+    // Allocate output buffer
+    int pixelCount = image.width * image.height;
+    image.data.resize(pixelCount * 4);  // RGBA8
 
     switch (image.compression) {
         case BLPCompression::DXT1:
@@ -177,7 +164,7 @@ BLPImage BLPLoader::loadBLP2(const uint8_t* data, size_t size) {
             break;
 
         case BLPCompression::ARGB8888:
-            for (uint32_t i = 0; i < pixelCount; i++) {
+            for (int i = 0; i < pixelCount; i++) {
                 image.data[i * 4 + 0] = mipData[i * 4 + 2];  // R
                 image.data[i * 4 + 1] = mipData[i * 4 + 1];  // G
                 image.data[i * 4 + 2] = mipData[i * 4 + 0];  // B
@@ -209,8 +196,7 @@ void BLPLoader::decompressDXT1(const uint8_t* src, uint8_t* dst, int width, int
             uint16_t c0 = block[0] | (block[1] << 8);
             uint16_t c1 = block[2] | (block[3] << 8);
 
-            // Convert RGB565 to RGB888: extract 5/6/5-bit channels and scale to [0..255].
-            // R = bits[15:11] (5-bit, /31), G = bits[10:5] (6-bit, /63), B = bits[4:0] (5-bit, /31)
+            // Convert RGB565 to RGB888
             uint8_t r0 = ((c0 >> 11) & 0x1F) * 255 / 31;
             uint8_t g0 = ((c0 >> 5) & 0x3F) * 255 / 63;
             uint8_t b0 = (c0 & 0x1F) * 255 / 31;
@@ -267,7 +253,7 @@ void BLPLoader::decompressDXT3(const uint8_t* src, uint8_t* dst, int width, int
             // First 8 bytes: 4-bit alpha values
             uint64_t alphaBlock = 0;
             for (int i = 0; i < 8; i++) {
-                alphaBlock |= static_cast<uint64_t>(block[i]) << (i * 8);
+                alphaBlock |= (uint64_t)block[i] << (i * 8);
             }
 
             // Color block (same as DXT1) starts at byte 8
@@ -304,7 +290,7 @@ void BLPLoader::decompressDXT3(const uint8_t* src, uint8_t* dst, int width, int
                         case 3: pixel[0] = (r0 + 2*r1) / 3; pixel[1] = (g0 + 2*g1) / 3; pixel[2] = (b0 + 2*b1) / 3; break;
                     }
 
-                    // Apply 4-bit alpha: scale [0..15] → [0..255] via (n * 255 / 15)
+                    // Apply 4-bit alpha
                     int alphaIndex = py * 4 + px;
                     uint8_t alpha4 = (alphaBlock >> (alphaIndex * 4)) & 0xF;
                     pixel[3] = alpha4 * 255 / 15;
@@ -350,7 +336,7 @@ void BLPLoader::decompressDXT5(const uint8_t* src, uint8_t* dst, int width, int
             // Alpha indices (48 bits for 16 pixels, 3 bits each)
             uint64_t alphaIndices = 0;
             for (int i = 2; i < 8; i++) {
-                alphaIndices |= static_cast<uint64_t>(block[i]) << ((i - 2) * 8);
+                alphaIndices |= (uint64_t)block[i] << ((i - 2) * 8);
             }
 
             // Color block (same as DXT1) starts at byte 8
@@ -417,8 +403,7 @@ void BLPLoader::decompressPalette(const uint8_t* src, uint8_t* dst, const uint32
         if (alphaDepth == 8) {
             dst[i * 4 + 3] = alphaData[i];
         } else if (alphaDepth == 4) {
-            // 4-bit alpha: 2 pixels packed per byte (low nibble first).
-            // Multiply by 17 to scale [0..15] → [0..255] (equivalent to n * 255 / 15).
+            // 4-bit alpha: 2 pixels per byte
             uint8_t alphaByte = alphaData[i / 2];
             dst[i * 4 + 3] = (i % 2 == 0) ? ((alphaByte & 0x0F) * 17) : ((alphaByte >> 4) * 17);
         } else if (alphaDepth == 1) {
diff --git a/src/pipeline/dbc_layout.cpp b/src/pipeline/dbc_layout.cpp
index 7d3878fe..08730536 100644
--- a/src/pipeline/dbc_layout.cpp
+++ b/src/pipeline/dbc_layout.cpp
@@ -1,9 +1,7 @@
 #include "pipeline/dbc_layout.hpp"
-#include "pipeline/dbc_loader.hpp"
 #include "core/logger.hpp"
 #include <fstream>
 #include <sstream>
-#include <algorithm>
 
 namespace wowee {
 namespace pipeline {
@@ -96,69 +94,5 @@ const DBCFieldMap* DBCLayout::getLayout(const std::string& dbcName) const {
     return (it != layouts_.end()) ? &it->second : nullptr;
 }
 
-CharSectionsFields detectCharSectionsFields(const DBCFile* dbc, const DBCFieldMap* csL) {
-    // Cache: avoid re-probing the same DBC on every call.
-    static const DBCFile* s_cachedDbc = nullptr;
-    static CharSectionsFields s_cachedResult;
-    if (dbc && dbc == s_cachedDbc) return s_cachedResult;
-
-    CharSectionsFields f;
-    if (!dbc || dbc->getRecordCount() == 0) return f;
-
-    // Start from the JSON layout (or defaults matching Classic-style: variation-first)
-    f.raceId         = csL ? (*csL)["RaceID"]         : 1;
-    f.sexId          = csL ? (*csL)["SexID"]           : 2;
-    f.baseSection    = csL ? (*csL)["BaseSection"]     : 3;
-    f.variationIndex = csL ? (*csL)["VariationIndex"]  : 4;
-    f.colorIndex     = csL ? (*csL)["ColorIndex"]      : 5;
-    f.texture1       = csL ? (*csL)["Texture1"]        : 6;
-    f.texture2       = csL ? (*csL)["Texture2"]        : 7;
-    f.texture3       = csL ? (*csL)["Texture3"]        : 8;
-    f.flags          = csL ? (*csL)["Flags"]           : 9;
-
-    // Auto-detect: probe the field that the JSON layout says is VariationIndex.
-    // In Classic-style layout, VariationIndex (field 4) holds small integers 0-15.
-    // In stock WotLK layout, field 4 is actually Texture1 (a string block offset, typically > 100).
-    // Sample up to 20 records and check if all field-4 values are small integers.
-    uint32_t probeField = f.variationIndex;
-    if (probeField >= dbc->getFieldCount()) {
-        s_cachedDbc = dbc;
-        s_cachedResult = f;
-        return f;  // safety
-    }
-
-    uint32_t sampleCount = std::min(dbc->getRecordCount(), 20u);
-    uint32_t largeCount = 0;
-    uint32_t smallCount = 0;
-    for (uint32_t r = 0; r < sampleCount; r++) {
-        uint32_t val = dbc->getUInt32(r, probeField);
-        if (val > 50) {
-            ++largeCount;
-        } else {
-            ++smallCount;
-        }
-    }
-
-    // If most sampled values are large, the JSON layout's VariationIndex field
-    // actually contains string offsets => this is stock WotLK (texture-first).
-    // Swap to texture-first layout: Tex1=4, Tex2=5, Tex3=6, Flags=7, Var=8, Color=9.
-    if (largeCount > smallCount) {
-        uint32_t base = probeField;  // the field index the JSON calls VariationIndex (typically 4)
-        f.texture1       = base;
-        f.texture2       = base + 1;
-        f.texture3       = base + 2;
-        f.flags          = base + 3;
-        f.variationIndex = base + 4;
-        f.colorIndex     = base + 5;
-        LOG_INFO("CharSections.dbc: detected stock WotLK layout (textures-first at field ", base, ")");
-    } else {
-        LOG_INFO("CharSections.dbc: detected Classic-style layout (variation-first at field ", probeField, ")");
-    }
-
-    s_cachedDbc = dbc;
-    s_cachedResult = f;
-    return f;
-}
-
 } // namespace pipeline
 } // namespace wowee
diff --git a/src/pipeline/dbc_loader.cpp b/src/pipeline/dbc_loader.cpp
index bb35ba44..4adb9bfa 100644
--- a/src/pipeline/dbc_loader.cpp
+++ b/src/pipeline/dbc_loader.cpp
@@ -64,8 +64,7 @@ bool DBCFile::load(const std::vector<uint8_t>& dbcData) {
         return false;
     }
 
-    // DBC fields are fixed-width uint32 (4 bytes each); record size must match.
-    // Mismatches indicate a corrupted header or unsupported DBC variant.
+    // Validate record size matches field count
     if (recordSize != fieldCount * 4) {
         LOG_WARNING("DBC record size mismatch: recordSize=", recordSize,
                     " but fieldCount*4=", fieldCount * 4);
@@ -79,9 +78,7 @@ bool DBCFile::load(const std::vector<uint8_t>& dbcData) {
     const uint8_t* recordStart = dbcData.data() + sizeof(DBCHeader);
     uint32_t totalRecordSize = recordCount * recordSize;
     recordData.resize(totalRecordSize);
-    if (totalRecordSize > 0) {
-        std::memcpy(recordData.data(), recordStart, totalRecordSize);
-    }
+    std::memcpy(recordData.data(), recordStart, totalRecordSize);
 
     // Copy string block
     const uint8_t* stringStart = recordStart + totalRecordSize;
@@ -140,32 +137,26 @@ float DBCFile::getFloat(uint32_t recordIndex, uint32_t fieldIndex) const {
 }
 
 std::string DBCFile::getString(uint32_t recordIndex, uint32_t fieldIndex) const {
-    return std::string(getStringView(recordIndex, fieldIndex));
-}
-
-std::string_view DBCFile::getStringView(uint32_t recordIndex, uint32_t fieldIndex) const {
     uint32_t offset = getUInt32(recordIndex, fieldIndex);
-    return getStringViewByOffset(offset);
+    return getStringByOffset(offset);
 }
 
 std::string DBCFile::getStringByOffset(uint32_t offset) const {
-    return std::string(getStringViewByOffset(offset));
-}
-
-std::string_view DBCFile::getStringViewByOffset(uint32_t offset) const {
     if (!loaded || offset >= stringBlockSize) {
-        return {};
+        return "";
     }
 
+    // Find null terminator
     const char* str = reinterpret_cast<const char*>(stringBlock.data() + offset);
     const char* end = reinterpret_cast<const char*>(stringBlock.data() + stringBlockSize);
 
+    // Find string length (up to null terminator or end of block)
     size_t length = 0;
     while (str + length < end && str[length] != '\0') {
         length++;
     }
 
-    return std::string_view(str, length);
+    return std::string(str, length);
 }
 
 int32_t DBCFile::findRecordById(uint32_t id) const {
diff --git a/src/pipeline/m2_loader.cpp b/src/pipeline/m2_loader.cpp
index 08014f75..b3d057d6 100644
--- a/src/pipeline/m2_loader.cpp
+++ b/src/pipeline/m2_loader.cpp
@@ -364,10 +364,7 @@ std::vector<T> readArray(const std::vector<uint8_t>& data, uint32_t offset, uint
 }
 
 std::string readString(const std::vector<uint8_t>& data, uint32_t offset, uint32_t length) {
-    // Use size_t arithmetic to prevent uint32 wraparound (same fix as readArray).
-    // A crafted M2 with offset=0xFFFFFFFF, length=2 would wrap to 1 in uint32,
-    // passing the check and reading out of bounds.
-    if (static_cast<size_t>(offset) + static_cast<size_t>(length) > data.size()) {
+    if (offset + length > data.size()) {
         return "";
     }
 
@@ -384,15 +381,11 @@ std::string readString(const std::vector<uint8_t>& data, uint32_t offset, uint32
 
 enum class TrackType { VEC3, QUAT_COMPRESSED, FLOAT };
 
-// M2 sequence flag: when set, keyframe data is embedded in the M2 file.
-// When clear, data lives in an external .anim file and the M2 offsets are
-// .anim-relative — reading them from the M2 produces garbage.
-constexpr uint32_t kM2SeqFlagEmbeddedData = 0x20;
-
 // Parse an M2 animation track from the binary data.
 // The track uses an "array of arrays" layout: nTimestamps pairs of {count, offset}.
-// sequenceFlags: per-sequence flags; sequences without kM2SeqFlagEmbeddedData store
-// their keyframe data in external .anim files, so their sub-array offsets must be skipped.
+// sequenceFlags: per-sequence flags; sequences WITHOUT flag 0x20 store their keyframe
+// data in external .anim files, so their sub-array offsets are .anim-relative and must
+// be skipped when reading from the M2 file.
 void parseAnimTrack(const std::vector<uint8_t>& data,
                     const M2TrackDisk& disk,
                     M2AnimationTrack& track,
@@ -412,7 +405,7 @@ void parseAnimTrack(const std::vector<uint8_t>& data,
         // Sequences without flag 0x20 have their animation data in external .anim files.
         // Their sub-array offsets are .anim-file-relative, not M2-relative, so reading
         // from the M2 file would produce garbage data.
-        if (i < sequenceFlags.size() && !(sequenceFlags[i] & kM2SeqFlagEmbeddedData)) continue;
+        if (i < sequenceFlags.size() && !(sequenceFlags[i] & 0x20)) continue;
         // Each sub-array header is {uint32_t count, uint32_t offset} = 8 bytes
         uint32_t tsHeaderOfs = disk.ofsTimestamps + i * 8;
         uint32_t keyHeaderOfs = disk.ofsKeys + i * 8;
@@ -522,22 +515,6 @@ void parseAnimTrackVanilla(const std::vector<uint8_t>& data,
         ranges.push_back({0, disk.nTimestamps});
     }
 
-    // Read the flat key array ONCE before the per-sequence loop. Previously
-    // readArray was called inside the loop on every iteration, re-parsing and
-    // copying the entire array (O(sequences × keys) redundant memcpy).
-    struct Vec3Disk { float x, y, z; };
-    struct C4Quaternion { float x, y, z, w; };
-    std::vector<float> allFloatKeys;
-    std::vector<Vec3Disk> allVec3Keys;
-    std::vector<C4Quaternion> allQuatKeys;
-    if (type == TrackType::FLOAT) {
-        allFloatKeys = readArray<float>(data, disk.ofsKeys, disk.nKeys);
-    } else if (type == TrackType::VEC3) {
-        allVec3Keys = readArray<Vec3Disk>(data, disk.ofsKeys, disk.nKeys);
-    } else {
-        allQuatKeys = readArray<C4Quaternion>(data, disk.ofsKeys, disk.nKeys);
-    }
-
     track.sequences.resize(ranges.size());
 
     for (size_t i = 0; i < ranges.size(); i++) {
@@ -546,6 +523,9 @@ void parseAnimTrackVanilla(const std::vector<uint8_t>& data,
         if (start >= end || start >= disk.nTimestamps) continue;
         end = std::min(end, disk.nTimestamps);
 
+        // Copy timestamps for this sequence, normalized to start at 0
+        // (vanilla stores absolute timestamps in the flat array, but the
+        // renderer expects 0-relative times matching sequence duration)
         track.sequences[i].timestamps.assign(
             allTimestamps.begin() + start, allTimestamps.begin() + end);
         if (!track.sequences[i].timestamps.empty()) {
@@ -555,24 +535,31 @@ void parseAnimTrackVanilla(const std::vector<uint8_t>& data,
             }
         }
 
+        // Copy key values for this sequence
         if (start >= disk.nKeys) continue;
         uint32_t keyEnd = std::min(end, disk.nKeys);
         uint32_t keyCount = keyEnd - start;
 
         if (type == TrackType::FLOAT) {
+            auto allValues = readArray<float>(data, disk.ofsKeys, disk.nKeys);
             track.sequences[i].floatValues.assign(
-                allFloatKeys.begin() + start, allFloatKeys.begin() + start + keyCount);
+                allValues.begin() + start, allValues.begin() + start + keyCount);
         } else if (type == TrackType::VEC3) {
+            struct Vec3Disk { float x, y, z; };
+            auto allValues = readArray<Vec3Disk>(data, disk.ofsKeys, disk.nKeys);
             track.sequences[i].vec3Values.reserve(keyCount);
             for (uint32_t k = start; k < start + keyCount; k++) {
                 track.sequences[i].vec3Values.emplace_back(
-                    allVec3Keys[k].x, allVec3Keys[k].y, allVec3Keys[k].z);
+                    allValues[k].x, allValues[k].y, allValues[k].z);
             }
         } else {
             // Vanilla: C4Quaternion — full float[4] per key (XYZW on disk)
+            // NOT compressed int16 like WotLK
+            struct C4Quaternion { float x, y, z, w; };
+            auto allQ = readArray<C4Quaternion>(data, disk.ofsKeys, disk.nKeys);
             track.sequences[i].quatValues.reserve(keyCount);
             for (uint32_t k = start; k < start + keyCount; k++) {
-                const auto& fq = allQuatKeys[k];
+                const auto& fq = allQ[k];
                 // Disk order: XYZW, glm::quat constructor: (w, x, y, z)
                 glm::quat q(fq.w, fq.x, fq.y, fq.z);
                 float len = glm::length(q);
@@ -588,7 +575,7 @@ void parseAnimTrackVanilla(const std::vector<uint8_t>& data,
 // FBlocks are like M2Track but WITHOUT the interpolationType/globalSequence prefix.
 void parseFBlock(const std::vector<uint8_t>& data, uint32_t offset,
                  M2FBlock& fb, int valueType) {
-    // valueType: 0 = color (C3Vector, 3 floats in 0-255 range), 1 = alpha (uint16), 2 = scale (float pair)
+    // valueType: 0 = color (CImVector, 4 bytes RGBA), 1 = alpha (uint16), 2 = scale (float pair)
     if (offset + sizeof(FBlockDisk) > data.size()) return;
 
     FBlockDisk disk = readValue<FBlockDisk>(data, offset);
@@ -1271,125 +1258,6 @@ M2Model M2Loader::load(const std::vector<uint8_t>& m2Data) {
         } // end size check
     }
 
-    // Parse ribbon emitters (WotLK only; vanilla format TBD).
-    // WotLK M2RibbonEmitter = 0xAC (172) bytes per entry.
-    static constexpr uint32_t RIBBON_SIZE_WOTLK = 0xAC;
-    if (header.nRibbonEmitters > 0 && header.ofsRibbonEmitters > 0 &&
-        header.nRibbonEmitters < 64 && header.version >= 264) {
-
-        if (static_cast<size_t>(header.ofsRibbonEmitters) +
-                static_cast<size_t>(header.nRibbonEmitters) * RIBBON_SIZE_WOTLK <= m2Data.size()) {
-
-            // Build sequence flags for parseAnimTrack
-            std::vector<uint32_t> ribSeqFlags;
-            ribSeqFlags.reserve(model.sequences.size());
-            for (const auto& seq : model.sequences) {
-                ribSeqFlags.push_back(seq.flags);
-            }
-
-            for (uint32_t ri = 0; ri < header.nRibbonEmitters; ri++) {
-                uint32_t base = header.ofsRibbonEmitters + ri * RIBBON_SIZE_WOTLK;
-
-                M2RibbonEmitter rib;
-                rib.ribbonId     = readValue<int32_t>(m2Data, base + 0x00);
-                rib.bone         = readValue<uint32_t>(m2Data, base + 0x04);
-                rib.position.x   = readValue<float>(m2Data, base + 0x08);
-                rib.position.y   = readValue<float>(m2Data, base + 0x0C);
-                rib.position.z   = readValue<float>(m2Data, base + 0x10);
-
-                // textureIndices M2Array (0x14): count + offset → first element = texture lookup index
-                {
-                    uint32_t nTex = readValue<uint32_t>(m2Data, base + 0x14);
-                    uint32_t ofsTex = readValue<uint32_t>(m2Data, base + 0x18);
-                    if (nTex > 0 && ofsTex + sizeof(uint16_t) <= m2Data.size()) {
-                        rib.textureIndex = readValue<uint16_t>(m2Data, ofsTex);
-                    }
-                }
-
-                // materialIndices M2Array (0x1C): count + offset → first element = material index
-                {
-                    uint32_t nMat = readValue<uint32_t>(m2Data, base + 0x1C);
-                    uint32_t ofsMat = readValue<uint32_t>(m2Data, base + 0x20);
-                    if (nMat > 0 && ofsMat + sizeof(uint16_t) <= m2Data.size()) {
-                        rib.materialIndex = readValue<uint16_t>(m2Data, ofsMat);
-                    }
-                }
-
-                // colorTrack M2TrackDisk at 0x24 (vec3 RGB 0..1)
-                if (base + 0x24 + sizeof(M2TrackDisk) <= m2Data.size()) {
-                    M2TrackDisk disk = readValue<M2TrackDisk>(m2Data, base + 0x24);
-                    parseAnimTrack(m2Data, disk, rib.colorTrack, TrackType::VEC3, ribSeqFlags);
-                }
-
-                // alphaTrack M2TrackDisk at 0x38 (fixed16: int16/32767)
-                // Same nested-array layout as parseAnimTrack but keys are int16.
-                if (base + 0x38 + sizeof(M2TrackDisk) <= m2Data.size()) {
-                    M2TrackDisk disk = readValue<M2TrackDisk>(m2Data, base + 0x38);
-                    auto& track = rib.alphaTrack;
-                    track.interpolationType = disk.interpolationType;
-                    track.globalSequence    = disk.globalSequence;
-                    uint32_t nSeqs = disk.nTimestamps;
-                    if (nSeqs > 0 && nSeqs <= 4096) {
-                        track.sequences.resize(nSeqs);
-                        for (uint32_t s = 0; s < nSeqs; s++) {
-                            if (s < ribSeqFlags.size() && !(ribSeqFlags[s] & kM2SeqFlagEmbeddedData)) continue;
-                            uint32_t tsHdr  = disk.ofsTimestamps + s * 8;
-                            uint32_t keyHdr = disk.ofsKeys + s * 8;
-                            if (tsHdr + 8 > m2Data.size() || keyHdr + 8 > m2Data.size()) continue;
-                            uint32_t tsCount = readValue<uint32_t>(m2Data, tsHdr);
-                            uint32_t tsOfs   = readValue<uint32_t>(m2Data, tsHdr + 4);
-                            uint32_t kCount  = readValue<uint32_t>(m2Data, keyHdr);
-                            uint32_t kOfs    = readValue<uint32_t>(m2Data, keyHdr + 4);
-                            if (tsCount == 0 || kCount == 0) continue;
-                            if (tsOfs + tsCount * 4 > m2Data.size()) continue;
-                            if (kOfs + kCount * sizeof(int16_t) > m2Data.size()) continue;
-                            track.sequences[s].timestamps = readArray<uint32_t>(m2Data, tsOfs, tsCount);
-                            auto raw = readArray<int16_t>(m2Data, kOfs, kCount);
-                            track.sequences[s].floatValues.reserve(raw.size());
-                            for (auto v : raw) {
-                                track.sequences[s].floatValues.push_back(
-                                    static_cast<float>(v) / 32767.0f);
-                            }
-                        }
-                    }
-                }
-
-                // heightAboveTrack M2TrackDisk at 0x4C (float)
-                if (base + 0x4C + sizeof(M2TrackDisk) <= m2Data.size()) {
-                    M2TrackDisk disk = readValue<M2TrackDisk>(m2Data, base + 0x4C);
-                    parseAnimTrack(m2Data, disk, rib.heightAboveTrack, TrackType::FLOAT, ribSeqFlags);
-                }
-
-                // heightBelowTrack M2TrackDisk at 0x60 (float)
-                if (base + 0x60 + sizeof(M2TrackDisk) <= m2Data.size()) {
-                    M2TrackDisk disk = readValue<M2TrackDisk>(m2Data, base + 0x60);
-                    parseAnimTrack(m2Data, disk, rib.heightBelowTrack, TrackType::FLOAT, ribSeqFlags);
-                }
-
-                rib.edgesPerSecond = readValue<float>(m2Data, base + 0x74);
-                rib.edgeLifetime   = readValue<float>(m2Data, base + 0x78);
-                rib.gravity        = readValue<float>(m2Data, base + 0x7C);
-                rib.textureRows    = readValue<uint16_t>(m2Data, base + 0x80);
-                rib.textureCols    = readValue<uint16_t>(m2Data, base + 0x82);
-                if (rib.textureRows == 0) rib.textureRows = 1;
-                if (rib.textureCols == 0) rib.textureCols = 1;
-
-                // Clamp to sane values
-                if (rib.edgesPerSecond < 1.0f  || rib.edgesPerSecond > 200.0f) rib.edgesPerSecond = 15.0f;
-                if (rib.edgeLifetime   < 0.05f || rib.edgeLifetime   > 10.0f)  rib.edgeLifetime   = 0.5f;
-
-                // visibilityTrack M2TrackDisk at 0x98 (uint8, treat as float 0/1)
-                if (base + 0x98 + sizeof(M2TrackDisk) <= m2Data.size()) {
-                    M2TrackDisk disk = readValue<M2TrackDisk>(m2Data, base + 0x98);
-                    parseAnimTrack(m2Data, disk, rib.visibilityTrack, TrackType::FLOAT, ribSeqFlags);
-                }
-
-                model.ribbonEmitters.push_back(std::move(rib));
-            }
-            core::Logger::getInstance().debug("  Ribbon emitters: ", model.ribbonEmitters.size());
-        }
-    }
-
     // Read collision mesh (bounding triangles/vertices/normals)
     if (header.nBoundingVertices > 0 && header.ofsBoundingVertices > 0) {
         struct Vec3Disk { float x, y, z; };
diff --git a/src/pipeline/mpq_manager.cpp b/src/pipeline/mpq_manager.cpp
new file mode 100644
index 00000000..98a984b1
--- /dev/null
+++ b/src/pipeline/mpq_manager.cpp
@@ -0,0 +1,565 @@
+#include "pipeline/mpq_manager.hpp"
+#include "core/logger.hpp"
+#include <algorithm>
+#include <chrono>
+#include <cstdlib>
+#include <limits>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <cctype>
+
+#ifdef HAVE_STORMLIB
+#include <StormLib.h>
+#endif
+
+// Define HANDLE and INVALID_HANDLE_VALUE for both cases
+#ifndef HAVE_STORMLIB
+typedef void* HANDLE;
+#endif
+
+#ifndef INVALID_HANDLE_VALUE
+#define INVALID_HANDLE_VALUE ((HANDLE)(long long)-1)
+#endif
+
+namespace wowee {
+namespace pipeline {
+
+namespace {
+std::string toLowerCopy(std::string value) {
+    std::transform(value.begin(), value.end(), value.begin(),
+                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+    return value;
+}
+
+std::string normalizeVirtualFilenameForLookup(std::string value) {
+    // StormLib uses backslash-separated virtual paths; treat lookups as case-insensitive.
+    std::replace(value.begin(), value.end(), '/', '\\');
+    value = toLowerCopy(std::move(value));
+    while (!value.empty() && (value.front() == '\\' || value.front() == '/')) {
+        value.erase(value.begin());
+    }
+    return value;
+}
+
+bool envFlagEnabled(const char* name) {
+    const char* v = std::getenv(name);
+    if (!v || !*v) {
+        return false;
+    }
+    std::string s = toLowerCopy(v);
+    return s == "1" || s == "true" || s == "yes" || s == "on";
+}
+
+size_t envSizeTOrDefault(const char* name, size_t defValue) {
+    const char* v = std::getenv(name);
+    if (!v || !*v) return defValue;
+    char* end = nullptr;
+    unsigned long long value = std::strtoull(v, &end, 10);
+    if (end == v || value == 0) return defValue;
+    if (value > static_cast<unsigned long long>(std::numeric_limits<size_t>::max())) return defValue;
+    return static_cast<size_t>(value);
+}
+}
+
+MPQManager::MPQManager() = default;
+
+MPQManager::~MPQManager() {
+    shutdown();
+}
+
+bool MPQManager::initialize(const std::string& dataPath_) {
+    if (initialized) {
+        LOG_WARNING("MPQManager already initialized");
+        return true;
+    }
+
+    dataPath = dataPath_;
+    LOG_INFO("Initializing MPQ manager with data path: ", dataPath);
+
+    // Guard against cache blowups from huge numbers of unique probes.
+    fileArchiveCacheMaxEntries_ = envSizeTOrDefault("WOWEE_MPQ_ARCHIVE_CACHE_MAX", fileArchiveCacheMaxEntries_);
+    fileArchiveCacheMisses_ = envFlagEnabled("WOWEE_MPQ_CACHE_MISSES");
+    LOG_INFO("MPQ archive lookup cache: maxEntries=", fileArchiveCacheMaxEntries_,
+             " cacheMisses=", (fileArchiveCacheMisses_ ? "yes" : "no"));
+
+    // Check if data directory exists
+    if (!std::filesystem::exists(dataPath)) {
+        LOG_ERROR("Data directory does not exist: ", dataPath);
+        return false;
+    }
+
+#ifdef HAVE_STORMLIB
+    // Load base archives (in order of priority)
+    std::vector<std::string> baseArchives = {
+        "common.MPQ",
+        "common-2.MPQ",
+        "expansion.MPQ",
+        "lichking.MPQ",
+    };
+
+    for (const auto& archive : baseArchives) {
+        std::string fullPath = dataPath + "/" + archive;
+        if (std::filesystem::exists(fullPath)) {
+            loadArchive(fullPath, 100);  // Base archives have priority 100
+        } else {
+            LOG_DEBUG("Base archive not found (optional): ", archive);
+        }
+    }
+
+    // Load patch archives (highest priority)
+    loadPatchArchives();
+
+    // Load locale archives — auto-detect from available locale directories
+    {
+        // Prefer the locale override from environment, then scan for installed ones
+        const char* localeEnv = std::getenv("WOWEE_LOCALE");
+        std::string detectedLocale;
+        if (localeEnv && localeEnv[0] != '\0') {
+            detectedLocale = localeEnv;
+            LOG_INFO("Using locale from WOWEE_LOCALE env: ", detectedLocale);
+        } else {
+            // Priority order: enUS first, then other common locales
+            static const std::array<const char*, 12> knownLocales = {
+                "enUS", "enGB", "deDE", "frFR", "esES", "esMX",
+                "zhCN", "zhTW", "koKR", "ruRU", "ptBR", "itIT"
+            };
+            for (const char* loc : knownLocales) {
+                if (std::filesystem::exists(dataPath + "/" + loc)) {
+                    detectedLocale = loc;
+                    LOG_INFO("Auto-detected WoW locale: ", detectedLocale);
+                    break;
+                }
+            }
+            if (detectedLocale.empty()) {
+                detectedLocale = "enUS";
+                LOG_WARNING("No locale directory found in data path; defaulting to enUS");
+            }
+        }
+        loadLocaleArchives(detectedLocale);
+    }
+
+    if (archives.empty()) {
+        LOG_WARNING("No MPQ archives loaded - will use loose file fallback");
+    } else {
+        LOG_INFO("MPQ manager initialized with ", archives.size(), " archives");
+    }
+#else
+    LOG_WARNING("StormLib not available - using loose file fallback only");
+#endif
+
+    initialized = true;
+    return true;
+}
+
+void MPQManager::shutdown() {
+    if (!initialized) {
+        return;
+    }
+
+#ifdef HAVE_STORMLIB
+    LOG_INFO("Shutting down MPQ manager");
+    for (auto& entry : archives) {
+        if (entry.handle != INVALID_HANDLE_VALUE) {
+            SFileCloseArchive(entry.handle);
+        }
+    }
+#endif
+
+    archives.clear();
+    archiveNames.clear();
+    {
+        std::lock_guard<std::mutex> lock(fileArchiveCacheMutex_);
+        fileArchiveCache_.clear();
+    }
+    {
+        std::lock_guard<std::mutex> lock(missingFileMutex_);
+        missingFileWarnings_.clear();
+    }
+    initialized = false;
+}
+
+bool MPQManager::loadArchive(const std::string& path, int priority) {
+#ifndef HAVE_STORMLIB
+    LOG_ERROR("Cannot load archive - StormLib not available");
+    return false;
+#endif
+
+#ifdef HAVE_STORMLIB
+    // Check if file exists
+    if (!std::filesystem::exists(path)) {
+        LOG_ERROR("Archive file not found: ", path);
+        return false;
+    }
+
+    HANDLE handle = INVALID_HANDLE_VALUE;
+    if (!SFileOpenArchive(path.c_str(), 0, 0, &handle)) {
+        LOG_ERROR("Failed to open MPQ archive: ", path);
+        return false;
+    }
+
+    ArchiveEntry entry;
+    entry.handle = handle;
+    entry.path = path;
+    entry.priority = priority;
+
+    archives.push_back(entry);
+    archiveNames.push_back(path);
+
+    // Sort archives by priority (highest first)
+    std::sort(archives.begin(), archives.end(),
+              [](const ArchiveEntry& a, const ArchiveEntry& b) {
+                  return a.priority > b.priority;
+              });
+
+    // Archive set/priority changed, so cached filename -> archive mappings may be stale.
+    {
+        std::lock_guard<std::mutex> lock(fileArchiveCacheMutex_);
+        fileArchiveCache_.clear();
+    }
+
+    LOG_INFO("Loaded MPQ archive: ", path, " (priority ", priority, ")");
+    return true;
+#endif
+
+    return false;
+}
+
+bool MPQManager::fileExists(const std::string& filename) const {
+#ifdef HAVE_STORMLIB
+    // Check MPQ archives first if available
+    if (!archives.empty()) {
+        HANDLE archive = findFileArchive(filename);
+        if (archive != INVALID_HANDLE_VALUE) {
+            return true;
+        }
+    }
+#endif
+
+    // Fall back to checking for loose file
+    std::string loosePath = filename;
+    std::replace(loosePath.begin(), loosePath.end(), '\\', '/');
+    std::string fullPath = dataPath + "/" + loosePath;
+    return std::filesystem::exists(fullPath);
+}
+
+std::vector<uint8_t> MPQManager::readFile(const std::string& filename) const {
+#ifdef HAVE_STORMLIB
+    // Try MPQ archives first if available
+    if (!archives.empty()) {
+        HANDLE archive = findFileArchive(filename);
+        if (archive != INVALID_HANDLE_VALUE) {
+            std::string stormFilename = filename;
+            std::replace(stormFilename.begin(), stormFilename.end(), '/', '\\');
+            // Open the file
+            HANDLE file = INVALID_HANDLE_VALUE;
+            if (SFileOpenFileEx(archive, stormFilename.c_str(), 0, &file)) {
+                // Get file size
+                DWORD fileSize = SFileGetFileSize(file, nullptr);
+                if (fileSize > 0 && fileSize != SFILE_INVALID_SIZE) {
+                    // Read file data
+                    std::vector<uint8_t> data(fileSize);
+                    DWORD bytesRead = 0;
+                    if (SFileReadFile(file, data.data(), fileSize, &bytesRead, nullptr)) {
+                        SFileCloseFile(file);
+                        LOG_DEBUG("Read file from MPQ: ", filename, " (", bytesRead, " bytes)");
+                        return data;
+                    }
+                }
+                SFileCloseFile(file);
+            }
+        }
+    }
+#endif
+
+    // Fall back to loose file loading
+    // Convert WoW path (backslashes) to filesystem path (forward slashes)
+    std::string loosePath = filename;
+    std::replace(loosePath.begin(), loosePath.end(), '\\', '/');
+
+    // Try with original case
+    std::string fullPath = dataPath + "/" + loosePath;
+    if (std::filesystem::exists(fullPath)) {
+        std::ifstream file(fullPath, std::ios::binary | std::ios::ate);
+        if (file.is_open()) {
+            size_t size = file.tellg();
+            file.seekg(0, std::ios::beg);
+            std::vector<uint8_t> data(size);
+            file.read(reinterpret_cast<char*>(data.data()), size);
+            LOG_DEBUG("Read loose file: ", loosePath, " (", size, " bytes)");
+            return data;
+        }
+    }
+
+    // Try case-insensitive search (common for Linux)
+    std::filesystem::path searchPath = dataPath;
+    std::vector<std::string> pathComponents;
+    std::istringstream iss(loosePath);
+    std::string component;
+    while (std::getline(iss, component, '/')) {
+        if (!component.empty()) {
+            pathComponents.push_back(component);
+        }
+    }
+
+    // Try to find file with case-insensitive matching
+    for (const auto& comp : pathComponents) {
+        bool found = false;
+        if (std::filesystem::exists(searchPath) && std::filesystem::is_directory(searchPath)) {
+            for (const auto& entry : std::filesystem::directory_iterator(searchPath)) {
+                std::string entryName = entry.path().filename().string();
+                // Case-insensitive comparison
+                if (std::equal(comp.begin(), comp.end(), entryName.begin(), entryName.end(),
+                              [](char a, char b) { return std::tolower(a) == std::tolower(b); })) {
+                    searchPath = entry.path();
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if (!found) {
+            logMissingFileOnce(filename);
+            return std::vector<uint8_t>();
+        }
+    }
+
+    // Try to read the found file
+    if (std::filesystem::exists(searchPath) && std::filesystem::is_regular_file(searchPath)) {
+        std::ifstream file(searchPath, std::ios::binary | std::ios::ate);
+        if (file.is_open()) {
+            size_t size = file.tellg();
+            file.seekg(0, std::ios::beg);
+            std::vector<uint8_t> data(size);
+            file.read(reinterpret_cast<char*>(data.data()), size);
+            LOG_DEBUG("Read loose file (case-insensitive): ", searchPath.string(), " (", size, " bytes)");
+            return data;
+        }
+    }
+
+    logMissingFileOnce(filename);
+    return std::vector<uint8_t>();
+}
+
+void MPQManager::logMissingFileOnce(const std::string& filename) const {
+    std::string normalized = toLowerCopy(filename);
+    std::lock_guard<std::mutex> lock(missingFileMutex_);
+    if (missingFileWarnings_.insert(normalized).second) {
+        LOG_WARNING("File not found: ", filename);
+    }
+}
+
+uint32_t MPQManager::getFileSize(const std::string& filename) const {
+#ifndef HAVE_STORMLIB
+    return 0;
+#endif
+
+#ifdef HAVE_STORMLIB
+    HANDLE archive = findFileArchive(filename);
+    if (archive == INVALID_HANDLE_VALUE) {
+        return 0;
+    }
+
+    std::string stormFilename = filename;
+    std::replace(stormFilename.begin(), stormFilename.end(), '/', '\\');
+    HANDLE file = INVALID_HANDLE_VALUE;
+    if (!SFileOpenFileEx(archive, stormFilename.c_str(), 0, &file)) {
+        return 0;
+    }
+
+    DWORD fileSize = SFileGetFileSize(file, nullptr);
+    SFileCloseFile(file);
+
+    return (fileSize == SFILE_INVALID_SIZE) ? 0 : fileSize;
+#endif
+
+    return 0;
+}
+
+HANDLE MPQManager::findFileArchive(const std::string& filename) const {
+#ifndef HAVE_STORMLIB
+    return INVALID_HANDLE_VALUE;
+#endif
+
+#ifdef HAVE_STORMLIB
+    std::string cacheKey = normalizeVirtualFilenameForLookup(filename);
+    {
+        std::lock_guard<std::mutex> lock(fileArchiveCacheMutex_);
+        auto it = fileArchiveCache_.find(cacheKey);
+        if (it != fileArchiveCache_.end()) {
+            return it->second;
+        }
+    }
+
+    std::string stormFilename = filename;
+    std::replace(stormFilename.begin(), stormFilename.end(), '/', '\\');
+
+    const auto start = std::chrono::steady_clock::now();
+    HANDLE found = INVALID_HANDLE_VALUE;
+    // Search archives in priority order (already sorted)
+    for (const auto& entry : archives) {
+        if (SFileHasFile(entry.handle, stormFilename.c_str())) {
+            found = entry.handle;
+            break;
+        }
+    }
+
+    const auto end = std::chrono::steady_clock::now();
+    const auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
+
+    // Avoid caching misses unless explicitly enabled; miss caching can explode memory when
+    // code probes many unique non-existent paths (common with HD patch sets).
+    if (found == INVALID_HANDLE_VALUE && !fileArchiveCacheMisses_) {
+        if (ms >= 100) {
+            LOG_WARNING("Slow MPQ lookup: '", filename, "' scanned ", archives.size(), " archives in ", ms, " ms");
+        }
+        return found;
+    }
+
+    {
+        std::lock_guard<std::mutex> lock(fileArchiveCacheMutex_);
+        if (fileArchiveCache_.size() >= fileArchiveCacheMaxEntries_) {
+            // Simple safety valve: clear the cache rather than allowing an unbounded growth.
+            LOG_WARNING("MPQ archive lookup cache cleared (size=", fileArchiveCache_.size(),
+                        " reached maxEntries=", fileArchiveCacheMaxEntries_, ")");
+            fileArchiveCache_.clear();
+        }
+        // Another thread may have raced to populate; if so, prefer the existing value.
+        auto [it, inserted] = fileArchiveCache_.emplace(std::move(cacheKey), found);
+        if (!inserted) {
+            found = it->second;
+        }
+    }
+
+    // With caching this should only happen once per unique filename; keep threshold conservative.
+    if (ms >= 100) {
+        LOG_WARNING("Slow MPQ lookup: '", filename, "' scanned ", archives.size(), " archives in ", ms, " ms");
+    }
+
+    return found;
+#endif
+
+    return INVALID_HANDLE_VALUE;
+}
+
+bool MPQManager::loadPatchArchives() {
+#ifndef HAVE_STORMLIB
+    return false;
+#endif
+
+    const bool disableLetterPatches = envFlagEnabled("WOWEE_DISABLE_LETTER_PATCHES");
+    const bool disableNumericPatches = envFlagEnabled("WOWEE_DISABLE_NUMERIC_PATCHES");
+
+    if (disableLetterPatches) {
+        LOG_WARNING("MPQ letter patches disabled via WOWEE_DISABLE_LETTER_PATCHES=1");
+    }
+    if (disableNumericPatches) {
+        LOG_WARNING("MPQ numeric patches disabled via WOWEE_DISABLE_NUMERIC_PATCHES=1");
+    }
+
+    // WoW 3.3.5a patch archives (in order of priority, highest first)
+    std::vector<std::pair<std::string, int>> patchArchives = {
+        // Lettered patch MPQs are used by some clients/distributions (e.g. Patch-A.mpq..Patch-E.mpq).
+        // Treat them as higher priority than numeric patch MPQs.
+        // Keep priorities well above numeric patch-*.MPQ so lettered patches always win when both exist.
+        {"Patch-Z.mpq", 925}, {"Patch-Y.mpq", 924}, {"Patch-X.mpq", 923}, {"Patch-W.mpq", 922},
+        {"Patch-V.mpq", 921}, {"Patch-U.mpq", 920}, {"Patch-T.mpq", 919}, {"Patch-S.mpq", 918},
+        {"Patch-R.mpq", 917}, {"Patch-Q.mpq", 916}, {"Patch-P.mpq", 915}, {"Patch-O.mpq", 914},
+        {"Patch-N.mpq", 913}, {"Patch-M.mpq", 912}, {"Patch-L.mpq", 911}, {"Patch-K.mpq", 910},
+        {"Patch-J.mpq", 909}, {"Patch-I.mpq", 908}, {"Patch-H.mpq", 907}, {"Patch-G.mpq", 906},
+        {"Patch-F.mpq", 905}, {"Patch-E.mpq", 904}, {"Patch-D.mpq", 903}, {"Patch-C.mpq", 902},
+        {"Patch-B.mpq", 901}, {"Patch-A.mpq", 900},
+        // Lowercase variants (Linux case-sensitive filesystems).
+        {"patch-z.mpq", 825}, {"patch-y.mpq", 824}, {"patch-x.mpq", 823}, {"patch-w.mpq", 822},
+        {"patch-v.mpq", 821}, {"patch-u.mpq", 820}, {"patch-t.mpq", 819}, {"patch-s.mpq", 818},
+        {"patch-r.mpq", 817}, {"patch-q.mpq", 816}, {"patch-p.mpq", 815}, {"patch-o.mpq", 814},
+        {"patch-n.mpq", 813}, {"patch-m.mpq", 812}, {"patch-l.mpq", 811}, {"patch-k.mpq", 810},
+        {"patch-j.mpq", 809}, {"patch-i.mpq", 808}, {"patch-h.mpq", 807}, {"patch-g.mpq", 806},
+        {"patch-f.mpq", 805}, {"patch-e.mpq", 804}, {"patch-d.mpq", 803}, {"patch-c.mpq", 802},
+        {"patch-b.mpq", 801}, {"patch-a.mpq", 800},
+
+        {"patch-5.MPQ", 500},
+        {"patch-4.MPQ", 400},
+        {"patch-3.MPQ", 300},
+        {"patch-2.MPQ", 200},
+        {"patch.MPQ", 150},
+    };
+
+    // Build a case-insensitive lookup of files in the data directory so that
+    // Patch-A.MPQ, patch-a.mpq, PATCH-A.MPQ, etc. all resolve correctly on
+    // case-sensitive filesystems (Linux).
+    std::unordered_map<std::string, std::string> lowerToActual;  // lowercase name → actual path
+    if (std::filesystem::is_directory(dataPath)) {
+        for (const auto& entry : std::filesystem::directory_iterator(dataPath)) {
+            if (!entry.is_regular_file()) continue;
+            std::string fname = entry.path().filename().string();
+            std::string lower = toLowerCopy(fname);
+            lowerToActual[lower] = entry.path().string();
+        }
+    }
+
+    int loadedPatches = 0;
+    for (const auto& [archive, priority] : patchArchives) {
+        // Classify letter vs numeric patch for the disable flags
+        std::string lowerArchive = toLowerCopy(archive);
+        const bool isLetterPatch =
+            (lowerArchive.size() >= 11) &&                     // "patch-X.mpq" = 11 chars
+            (lowerArchive.rfind("patch-", 0) == 0) &&          // starts with "patch-"
+            (lowerArchive[6] >= 'a' && lowerArchive[6] <= 'z'); // letter after dash
+        if (isLetterPatch && disableLetterPatches) {
+            continue;
+        }
+        if (!isLetterPatch && disableNumericPatches) {
+            continue;
+        }
+
+        // Case-insensitive file lookup
+        auto it = lowerToActual.find(lowerArchive);
+        if (it != lowerToActual.end()) {
+            if (loadArchive(it->second, priority)) {
+                loadedPatches++;
+            }
+        }
+    }
+
+    LOG_INFO("Loaded ", loadedPatches, " patch archives");
+    return loadedPatches > 0;
+}
+
+bool MPQManager::loadLocaleArchives(const std::string& locale) {
+#ifndef HAVE_STORMLIB
+    return false;
+#endif
+
+    std::string localePath = dataPath + "/" + locale;
+    if (!std::filesystem::exists(localePath)) {
+        LOG_WARNING("Locale directory not found: ", localePath);
+        return false;
+    }
+
+    // Locale-specific archives (including speech MPQs for NPC voices)
+    std::vector<std::pair<std::string, int>> localeArchives = {
+        {"locale-" + locale + ".MPQ", 250},
+        {"speech-" + locale + ".MPQ", 240},  // Base speech/NPC voices
+        {"expansion-speech-" + locale + ".MPQ", 245},  // TBC speech
+        {"lichking-speech-" + locale + ".MPQ", 248},  // WotLK speech
+        {"patch-" + locale + ".MPQ", 450},
+        {"patch-" + locale + "-2.MPQ", 460},
+        {"patch-" + locale + "-3.MPQ", 470},
+    };
+
+    int loadedLocale = 0;
+    for (const auto& [archive, priority] : localeArchives) {
+        std::string fullPath = localePath + "/" + archive;
+        if (std::filesystem::exists(fullPath)) {
+            if (loadArchive(fullPath, priority)) {
+                loadedLocale++;
+            }
+        }
+    }
+
+    LOG_INFO("Loaded ", loadedLocale, " locale archives for ", locale);
+    return loadedLocale > 0;
+}
+
+} // namespace pipeline
+} // namespace wowee
diff --git a/src/pipeline/wdt_loader.cpp b/src/pipeline/wdt_loader.cpp
index cb59cec5..dde1bb94 100644
--- a/src/pipeline/wdt_loader.cpp
+++ b/src/pipeline/wdt_loader.cpp
@@ -69,9 +69,7 @@ WDTInfo parseWDT(const std::vector<uint8_t>& data) {
             // Null-terminated WMO path string(s)
             if (chunkSize > 0) {
                 const char* str = reinterpret_cast<const char*>(chunkData);
-                // Bound scan to chunkSize to avoid OOB read on truncated files
-                // (strlen has no upper bound if the data lacks a null terminator).
-                size_t len = strnlen(str, chunkSize);
+                size_t len = std::strlen(str);
                 if (len > 0) {
                     info.rootWMOPath = std::string(str, len);
                     LOG_DEBUG("WDT root WMO: ", info.rootWMOPath);
diff --git a/src/pipeline/wmo_loader.cpp b/src/pipeline/wmo_loader.cpp
index a228da44..22a4df42 100644
--- a/src/pipeline/wmo_loader.cpp
+++ b/src/pipeline/wmo_loader.cpp
@@ -49,16 +49,11 @@ T read(const std::vector<uint8_t>& data, uint32_t& offset) {
 template<typename T>
 std::vector<T> readArray(const std::vector<uint8_t>& data, uint32_t offset, uint32_t count) {
     std::vector<T> result;
-    // Use 64-bit arithmetic to prevent uint32 overflow on crafted count values.
-    // A large count (e.g., 0x20000001 with sizeof(T)=8) would wrap to a small
-    // value in 32-bit, pass the bounds check, then cause a multi-GB allocation.
-    uint64_t totalBytes = static_cast<uint64_t>(count) * sizeof(T);
-    constexpr uint64_t kMaxReadBytes = 64u * 1024u * 1024u;  // 64MB sanity cap
-    if (totalBytes > kMaxReadBytes || static_cast<uint64_t>(offset) + totalBytes > data.size()) {
+    if (offset + count * sizeof(T) > data.size()) {
         return result;
     }
     result.resize(count);
-    std::memcpy(result.data(), &data[offset], static_cast<size_t>(totalBytes));
+    std::memcpy(result.data(), &data[offset], count * sizeof(T));
     return result;
 }
 
@@ -114,11 +109,7 @@ WMOModel WMOLoader::load(const std::vector<uint8_t>& wmoData) {
                 model.nDoodadDefs = read<uint32_t>(wmoData, offset);
                 model.nDoodadSets = read<uint32_t>(wmoData, offset);
 
-                uint32_t ambColor = read<uint32_t>(wmoData, offset);  // Ambient color (BGRA)
-                // Unpack BGRA bytes to normalized [0,1] RGB
-                model.ambientColor.r = ((ambColor >> 16) & 0xFF) / 255.0f;
-                model.ambientColor.g = ((ambColor >>  8) & 0xFF) / 255.0f;
-                model.ambientColor.b = ((ambColor >>  0) & 0xFF) / 255.0f;
+                [[maybe_unused]] uint32_t ambColor = read<uint32_t>(wmoData, offset);  // Ambient color (BGRA)
                 [[maybe_unused]] uint32_t wmoID = read<uint32_t>(wmoData, offset);
 
                 model.boundingBoxMin.x = read<float>(wmoData, offset);
@@ -291,11 +282,9 @@ WMOModel WMOLoader::load(const std::vector<uint8_t>& wmoData) {
                 for (uint32_t i = 0; i < nDoodads; i++) {
                     WMODoodad doodad;
 
-                    // WMO doodad placement: name index packed in lower 24 bits, flags in upper 8.
-                    // The name index is an offset into the MODN string table (doodad names).
-                    constexpr uint32_t kDoodadNameIndexMask = 0x00FFFFFF;
+                    // Name index (3 bytes) + flags (1 byte)
                     uint32_t nameAndFlags = read<uint32_t>(wmoData, offset);
-                    doodad.nameIndex = nameAndFlags & kDoodadNameIndexMask;
+                    doodad.nameIndex = nameAndFlags & 0x00FFFFFF;
 
                     doodad.position.x = read<float>(wmoData, offset);
                     doodad.position.y = read<float>(wmoData, offset);
@@ -322,13 +311,10 @@ WMOModel WMOLoader::load(const std::vector<uint8_t>& wmoData) {
             }
 
             case MODS: {
-                // Doodad sets: 20-byte name + 3×uint32 = 32 bytes each.
-                // Use bounds check before memcpy to avoid OOB on truncated files
-                // (the raw memcpy bypassed the safe read<T> template).
-                uint32_t nSets = chunkSize / 32;
+                // Doodad sets
+                uint32_t nSets = chunkSize / 32;  // Each set is 32 bytes
                 for (uint32_t i = 0; i < nSets; i++) {
                     WMODoodadSet set;
-                    if (offset + 20 > wmoData.size()) break;
                     std::memcpy(set.name, &wmoData[offset], 20);
                     offset += 20;
                     set.startIndex = read<uint32_t>(wmoData, offset);
@@ -471,7 +457,6 @@ bool WMOLoader::loadGroup(const std::vector<uint8_t>& groupData,
             mogpOffset = offset + 68;
 
             // Parse sub-chunks within MOGP
-            int groupLogCount = 0;
             while (mogpOffset + 8 < chunkEnd) {
                 uint32_t subChunkId = read<uint32_t>(groupData, mogpOffset);
                 uint32_t subChunkSize = read<uint32_t>(groupData, mogpOffset);
@@ -487,11 +472,10 @@ bool WMOLoader::loadGroup(const std::vector<uint8_t>& groupData,
                 magic[1] = (subChunkId >> 8) & 0xFF;
                 magic[2] = (subChunkId >> 16) & 0xFF;
                 magic[3] = (subChunkId >> 24) & 0xFF;
-                // Not static — previously this throttle was per-process, silencing
-                // all WMO group logging after the first 30 sub-chunks globally.
-                if (groupLogCount < 30) {
+                static int logCount = 0;
+                if (logCount < 30) {
                     core::Logger::getInstance().debug("  WMO sub-chunk: ", magic, " (0x", std::hex, subChunkId, std::dec, ") size=", subChunkSize);
-                    groupLogCount++;
+                    logCount++;
                 }
 
                 if (subChunkId == 0x4D4F5654) { // MOVT - Vertices
@@ -586,11 +570,12 @@ bool WMOLoader::loadGroup(const std::vector<uint8_t>& groupData,
                         batch.materialId = read<uint8_t>(groupData, mogpOffset);
                         group.batches.push_back(batch);
 
-                        // Non-static so each group gets its own throttle window.
-                        if (static_cast<int>(i) < 15) {
+                        static int batchLogCount = 0;
+                        if (batchLogCount < 15) {
                             core::Logger::getInstance().debug("  Batch[", i, "]: start=", batch.startIndex,
                                 " count=", batch.indexCount, " verts=[", batch.startVertex, "-",
-                                batch.lastVertex, "] mat=", static_cast<int>(batch.materialId), " flags=", static_cast<int>(batch.flags));
+                                batch.lastVertex, "] mat=", (int)batch.materialId, " flags=", (int)batch.flags);
+                            batchLogCount++;
                         }
                     }
                 }
diff --git a/src/rendering/amd_fsr3_runtime.cpp b/src/rendering/amd_fsr3_runtime.cpp
index 469056d9..e7606fb6 100644
--- a/src/rendering/amd_fsr3_runtime.cpp
+++ b/src/rendering/amd_fsr3_runtime.cpp
@@ -64,7 +64,7 @@ std::string narrowWString(const wchar_t* msg) {
     std::string out;
     for (const wchar_t* p = msg; *p; ++p) {
         const wchar_t wc = *p;
-        if (wc <= 0x7f) {
+        if (wc >= 0 && wc <= 0x7f) {
             out.push_back(static_cast<char>(wc));
         } else {
             out.push_back('?');
@@ -341,13 +341,7 @@ bool AmdFsr3Runtime::initialize(const AmdFsr3RuntimeInitDesc& desc) {
             const std::string loadedPath = loadedLibraryPath_;
             lastError_ = "ffxCreateContext (upscale) failed rc=" + std::to_string(upCreateRc) +
                          " (" + ffxApiReturnCodeName(upCreateRc) + "), runtimeLib=" + loadedPath;
-            LOG_ERROR("FSR3 runtime/API: FSR3 Upscale create failed at ffxCreateContext: rc=", upCreateRc);
-            // Don't call full shutdown() here — dlclose() on the AMD runtime library
-            // can hang on some drivers (notably NVIDIA) when context creation failed.
-            // Just clean up local state; library stays loaded (harmless leak).
-            delete fns_; fns_ = nullptr;
-            ready_ = false;
-            apiMode_ = ApiMode::LegacyFsr3;
+            shutdown();
             return false;
         }
         genericUpscaleContext_ = upscaleCtx;
diff --git a/src/rendering/animation/activity_fsm.cpp b/src/rendering/animation/activity_fsm.cpp
deleted file mode 100644
index 71138998..00000000
--- a/src/rendering/animation/activity_fsm.cpp
+++ /dev/null
@@ -1,339 +0,0 @@
-#include "rendering/animation/activity_fsm.hpp"
-#include "rendering/animation/animation_ids.hpp"
-
-namespace wowee {
-namespace rendering {
-
-// ── One-shot completion helper ───────────────────────────────────────────────
-
-bool ActivityFSM::oneShotComplete(const Input& in, uint32_t expectedAnimId) const {
-    if (!in.haveAnimState) return false;
-    return in.currentAnimId != expectedAnimId ||
-           (in.currentAnimDuration > 0.1f && in.currentAnimTime >= in.currentAnimDuration - 0.05f);
-}
-
-// ── Event handling ───────────────────────────────────────────────────────────
-
-void ActivityFSM::onEvent(AnimEvent event) {
-    switch (event) {
-        case AnimEvent::EMOTE_START:
-            // Handled by startEmote() with animId
-            break;
-        case AnimEvent::EMOTE_STOP:
-            cancelEmote();
-            break;
-        case AnimEvent::LOOT_START:
-            startLooting();
-            break;
-        case AnimEvent::LOOT_STOP:
-            stopLooting();
-            break;
-        case AnimEvent::SIT:
-            // Handled by setStandState()
-            break;
-        case AnimEvent::STAND_UP:
-            if (state_ == State::SITTING || state_ == State::SIT_DOWN) {
-                if (sitUpAnim_ != 0)
-                    state_ = State::SIT_UP;
-                else
-                    state_ = State::NONE;
-            }
-            break;
-        case AnimEvent::MOVE_START:
-        case AnimEvent::JUMP:
-        case AnimEvent::SWIM_ENTER:
-            // Movement cancels all activities
-            if (state_ == State::EMOTE) cancelEmote();
-            if (state_ == State::LOOTING || state_ == State::LOOT_KNEELING || state_ == State::LOOT_END)
-                state_ = State::NONE;
-            if (state_ == State::SIT_UP || state_ == State::SIT_DOWN) {
-                state_ = State::NONE;
-                standState_ = 0;
-            }
-            break;
-        default:
-            break;
-    }
-}
-
-// ── Emote management ─────────────────────────────────────────────────────────
-
-void ActivityFSM::startEmote(uint32_t animId, bool loop) {
-    emoteActive_ = true;
-    emoteAnimId_ = animId;
-    emoteLoop_ = loop;
-    state_ = State::EMOTE;
-}
-
-void ActivityFSM::cancelEmote() {
-    emoteActive_ = false;
-    emoteAnimId_ = 0;
-    emoteLoop_ = false;
-    if (state_ == State::EMOTE) state_ = State::NONE;
-}
-
-// ── Sit/sleep/kneel ──────────────────────────────────────────────────────────
-
-void ActivityFSM::setStandState(uint8_t standState) {
-    if (standState == standState_) return;
-    standState_ = standState;
-
-    if (standState == STAND_STATE_STAND) {
-        // Standing up — exit via SIT_UP if we have an exit animation
-        return;
-    }
-
-    if (standState == STAND_STATE_SIT) {
-        sitDownAnim_ = anim::SIT_GROUND_DOWN;
-        sitLoopAnim_ = anim::SITTING;
-        sitUpAnim_   = anim::SIT_GROUND_UP;
-        sitDownAnimSeen_ = false;
-        sitDownFrames_ = 0;
-        state_ = State::SIT_DOWN;
-    } else if (standState == STAND_STATE_SLEEP) {
-        sitDownAnim_ = anim::SLEEP_DOWN;
-        sitLoopAnim_ = anim::SLEEP;
-        sitUpAnim_   = anim::SLEEP_UP;
-        sitDownAnimSeen_ = false;
-        sitDownFrames_ = 0;
-        state_ = State::SIT_DOWN;
-    } else if (standState == STAND_STATE_KNEEL) {
-        sitDownAnim_ = anim::KNEEL_START;
-        sitLoopAnim_ = anim::KNEEL_LOOP;
-        sitUpAnim_   = anim::KNEEL_END;
-        sitDownAnimSeen_ = false;
-        sitDownFrames_ = 0;
-        state_ = State::SIT_DOWN;
-    } else if (standState >= STAND_STATE_SIT_CHAIR && standState <= STAND_STATE_SIT_HIGH) {
-        // Chair variants — no transition animation, go directly to loop
-        sitDownAnim_ = 0;
-        sitUpAnim_   = 0;
-        if (standState == STAND_STATE_SIT_LOW) {
-            sitLoopAnim_ = anim::SIT_CHAIR_LOW;
-        } else if (standState == STAND_STATE_SIT_HIGH) {
-            sitLoopAnim_ = anim::SIT_CHAIR_HIGH;
-        } else {
-            sitLoopAnim_ = anim::SIT_CHAIR_MED;
-        }
-        state_ = State::SITTING;
-    } else if (standState == STAND_STATE_DEAD) {
-        sitDownAnim_ = 0;
-        sitLoopAnim_ = 0;
-        sitUpAnim_   = 0;
-        return;
-    }
-}
-
-// ── Loot management ──────────────────────────────────────────────────────────
-
-void ActivityFSM::startLooting() {
-    state_ = State::LOOTING;
-    lootAnimSeen_ = false;
-    lootFrames_ = 0;
-}
-
-void ActivityFSM::stopLooting() {
-    if (state_ == State::LOOTING || state_ == State::LOOT_KNEELING) {
-        state_ = State::LOOT_END;
-        lootEndAnimSeen_ = false;
-        lootEndFrames_ = 0;
-    }
-}
-
-// ── State transitions ────────────────────────────────────────────────────────
-
-void ActivityFSM::updateTransitions(const Input& in) {
-    switch (state_) {
-        case State::NONE:
-            break;
-
-        case State::EMOTE:
-            if (in.swimming || (in.jumping && !in.grounded) || in.moving || in.sitting) {
-                cancelEmote();
-            } else if (!emoteLoop_ && in.haveAnimState) {
-                if (oneShotComplete(in, emoteAnimId_)) {
-                    cancelEmote();
-                }
-            }
-            break;
-
-        case State::LOOTING:
-            if (in.swimming || (in.jumping && !in.grounded) || in.moving) {
-                state_ = State::NONE;
-            } else if (in.haveAnimState) {
-                if (in.currentAnimId == anim::LOOT) lootAnimSeen_ = true;
-                if (lootAnimSeen_ && oneShotComplete(in, anim::LOOT)) {
-                    state_ = State::LOOT_KNEELING;
-                }
-                // Safety: if anim never seen (model lacks it), advance after a timeout
-                if (!lootAnimSeen_ && ++lootFrames_ > 10) {
-                    state_ = State::LOOT_KNEELING;
-                }
-            }
-            break;
-
-        case State::LOOT_KNEELING:
-            if (in.swimming || (in.jumping && !in.grounded) || in.moving) {
-                state_ = State::NONE;
-            }
-            // Stays in LOOT_KNEELING until stopLooting() transitions to LOOT_END
-            break;
-
-        case State::LOOT_END:
-            if (in.swimming || (in.jumping && !in.grounded) || in.moving) {
-                state_ = State::NONE;
-            } else if (in.haveAnimState) {
-                if (in.currentAnimId == anim::KNEEL_END) lootEndAnimSeen_ = true;
-                if (lootEndAnimSeen_ && oneShotComplete(in, anim::KNEEL_END)) {
-                    state_ = State::NONE;
-                }
-                // Safety timeout
-                if (!lootEndAnimSeen_ && ++lootEndFrames_ > 10) {
-                    state_ = State::NONE;
-                }
-            }
-            break;
-
-        case State::SIT_DOWN:
-            if (in.swimming) {
-                state_ = State::NONE;
-                standState_ = 0;
-            } else if (!in.sitting) {
-                // Stand up requested
-                if (sitUpAnim_ != 0 && !in.moving) {
-                    sitUpAnimSeen_ = false;
-                    sitUpFrames_ = 0;
-                    state_ = State::SIT_UP;
-                } else {
-                    state_ = State::NONE;
-                    standState_ = 0;
-                }
-            } else if (sitDownAnim_ != 0 && in.haveAnimState) {
-                // Track whether the sit-down anim has started playing
-                if (in.currentAnimId == sitDownAnim_) sitDownAnimSeen_ = true;
-                // Only detect completion after the anim has been seen at least once
-                if (sitDownAnimSeen_ && oneShotComplete(in, sitDownAnim_)) {
-                    state_ = State::SITTING;
-                }
-                // Safety: if animation was never seen after enough frames (model
-                // may lack it), fall through to the sitting loop.
-                if (!sitDownAnimSeen_ && ++sitDownFrames_ > 10) {
-                    state_ = State::SITTING;
-                }
-            }
-            break;
-
-        case State::SITTING:
-            if (in.swimming) {
-                state_ = State::NONE;
-                standState_ = 0;
-            } else if (!in.sitting) {
-                if (sitUpAnim_ != 0 && !in.moving) {
-                    sitUpAnimSeen_ = false;
-                    sitUpFrames_ = 0;
-                    state_ = State::SIT_UP;
-                } else {
-                    state_ = State::NONE;
-                    standState_ = 0;
-                }
-            }
-            break;
-
-        case State::SIT_UP:
-            if (in.swimming || in.moving) {
-                state_ = State::NONE;
-                standState_ = 0;
-            } else if (in.haveAnimState) {
-                uint32_t expected = sitUpAnim_ ? sitUpAnim_ : anim::SIT_GROUND_UP;
-                // Track whether the sit-up anim has started playing
-                if (in.currentAnimId == expected) sitUpAnimSeen_ = true;
-                // Only detect completion after the anim has been seen at least once
-                if (sitUpAnimSeen_ && oneShotComplete(in, expected)) {
-                    state_ = State::NONE;
-                    standState_ = 0;
-                }
-                // Safety: if animation was never seen after enough frames, finish
-                if (!sitUpAnimSeen_ && ++sitUpFrames_ > 10) {
-                    state_ = State::NONE;
-                    standState_ = 0;
-                }
-            }
-            break;
-    }
-}
-
-// ── Animation resolution ─────────────────────────────────────────────────────
-
-AnimOutput ActivityFSM::resolve(const Input& in, const AnimCapabilitySet& /*caps*/) {
-    updateTransitions(in);
-
-    if (state_ == State::NONE) return AnimOutput::stay();
-
-    uint32_t animId = 0;
-    bool loop = true;
-
-    switch (state_) {
-        case State::NONE:
-            return AnimOutput::stay();
-
-        case State::EMOTE:
-            animId = emoteAnimId_;
-            loop = emoteLoop_;
-            break;
-
-        case State::LOOTING:
-            animId = anim::LOOT;
-            loop = false;
-            break;
-
-        case State::LOOT_KNEELING:
-            animId = anim::KNEEL_LOOP;
-            loop = true;
-            break;
-
-        case State::LOOT_END:
-            animId = anim::KNEEL_END;
-            loop = false;
-            break;
-
-        case State::SIT_DOWN:
-            animId = sitDownAnim_ ? sitDownAnim_ : anim::SIT_GROUND_DOWN;
-            loop = false;
-            break;
-
-        case State::SITTING:
-            animId = sitLoopAnim_ ? sitLoopAnim_ : anim::SITTING;
-            loop = true;
-            break;
-
-        case State::SIT_UP:
-            animId = sitUpAnim_ ? sitUpAnim_ : anim::SIT_GROUND_UP;
-            loop = false;
-            break;
-    }
-
-    if (animId == 0) return AnimOutput::stay();
-    return AnimOutput::ok(animId, loop);
-}
-
-// ── Reset ────────────────────────────────────────────────────────────────────
-
-void ActivityFSM::reset() {
-    state_ = State::NONE;
-    cancelEmote();
-    standState_ = 0;
-    sitDownAnim_ = 0;
-    sitLoopAnim_ = 0;
-    sitUpAnim_ = 0;
-    sitDownAnimSeen_ = false;
-    sitUpAnimSeen_ = false;
-    sitDownFrames_ = 0;
-    sitUpFrames_ = 0;
-    lootAnimSeen_ = false;
-    lootFrames_ = 0;
-    lootEndAnimSeen_ = false;
-    lootEndFrames_ = 0;
-}
-
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/animation/anim_capability_probe.cpp b/src/rendering/animation/anim_capability_probe.cpp
deleted file mode 100644
index b48fa66b..00000000
--- a/src/rendering/animation/anim_capability_probe.cpp
+++ /dev/null
@@ -1,287 +0,0 @@
-// ============================================================================
-// AnimCapabilityProbe
-//
-// Scans a model's animation capabilities once and returns an
-// AnimCapabilitySet with resolved IDs (after fallback chains).
-// Extracted from the scattered hasAnimation/pickFirstAvailable calls
-// in AnimationController.
-// ============================================================================
-
-#include "rendering/animation/anim_capability_probe.hpp"
-#include "rendering/animation/animation_ids.hpp"
-#include "rendering/renderer.hpp"
-#include "rendering/character_renderer.hpp"
-#include "rendering/m2_renderer.hpp"
-
-namespace wowee {
-namespace rendering {
-
-uint32_t AnimCapabilityProbe::pickFirst(Renderer* renderer, uint32_t instanceId,
-                                        const uint32_t* candidates, size_t count) {
-    auto* charRenderer = renderer->getCharacterRenderer();
-    if (!charRenderer) return 0;
-    for (size_t i = 0; i < count; ++i) {
-        if (charRenderer->hasAnimation(instanceId, candidates[i])) {
-            return candidates[i];
-        }
-    }
-    return 0;
-}
-
-AnimCapabilitySet AnimCapabilityProbe::probe(Renderer* renderer, uint32_t instanceId) {
-    AnimCapabilitySet caps;
-    if (!renderer || instanceId == 0) return caps;
-
-    auto* cr = renderer->getCharacterRenderer();
-    if (!cr) return caps;
-
-    auto has = [&](uint32_t id) -> bool {
-        return cr->hasAnimation(instanceId, id);
-    };
-
-    // Helper: pick first available from static array
-    auto pick = [&](const uint32_t* candidates, size_t count) -> uint32_t {
-        return pickFirst(renderer, instanceId, candidates, count);
-    };
-
-    // ── Locomotion ──────────────────────────────────────────────────────
-    // STAND is animation ID 0. Every M2 model has sequence 0 as its base idle.
-    // Cannot use ternary `has(0) ? 0 : 0` — both branches are 0.
-    caps.resolvedStand = anim::STAND;
-    caps.hasStand = has(anim::STAND);
-
-    {
-        static const uint32_t walkCands[] = {anim::WALK, anim::RUN};
-        caps.resolvedWalk = pick(walkCands, 2);
-        caps.hasWalk = (caps.resolvedWalk != 0);
-    }
-    {
-        static const uint32_t runCands[] = {anim::RUN, anim::WALK};
-        caps.resolvedRun = pick(runCands, 2);
-        caps.hasRun = (caps.resolvedRun != 0);
-    }
-    {
-        static const uint32_t sprintCands[] = {anim::SPRINT, anim::RUN, anim::WALK};
-        caps.resolvedSprint = pick(sprintCands, 3);
-        caps.hasSprint = (caps.resolvedSprint != 0);
-    }
-    {
-        static const uint32_t walkBackCands[] = {anim::WALK_BACKWARDS, anim::WALK};
-        caps.resolvedWalkBackwards = pick(walkBackCands, 2);
-        caps.hasWalkBackwards = (caps.resolvedWalkBackwards != 0);
-    }
-    {
-        static const uint32_t strafeLeftCands[] = {anim::SHUFFLE_LEFT, anim::RUN_LEFT, anim::WALK};
-        caps.resolvedStrafeLeft = pick(strafeLeftCands, 3);
-    }
-    {
-        static const uint32_t strafeRightCands[] = {anim::SHUFFLE_RIGHT, anim::RUN_RIGHT, anim::WALK};
-        caps.resolvedStrafeRight = pick(strafeRightCands, 3);
-    }
-    {
-        static const uint32_t runLeftCands[] = {anim::RUN_LEFT, anim::RUN};
-        caps.resolvedRunLeft = pick(runLeftCands, 2);
-    }
-    {
-        static const uint32_t runRightCands[] = {anim::RUN_RIGHT, anim::RUN};
-        caps.resolvedRunRight = pick(runRightCands, 2);
-    }
-
-    // ── Jump ────────────────────────────────────────────────────────────
-    caps.resolvedJumpStart = has(anim::JUMP_START) ? anim::JUMP_START : 0;
-    caps.resolvedJump = has(anim::JUMP) ? anim::JUMP : 0;
-    caps.resolvedJumpEnd = has(anim::JUMP_END) ? anim::JUMP_END : 0;
-    caps.hasJump = (caps.resolvedJumpStart != 0);
-
-    // ── Swim ────────────────────────────────────────────────────────────
-    caps.resolvedSwimIdle = has(anim::SWIM_IDLE) ? anim::SWIM_IDLE : 0;
-    caps.resolvedSwim = has(anim::SWIM) ? anim::SWIM : 0;
-    caps.hasSwim = (caps.resolvedSwimIdle != 0 || caps.resolvedSwim != 0);
-    {
-        static const uint32_t swimBackCands[] = {anim::SWIM_BACKWARDS, anim::SWIM};
-        caps.resolvedSwimBackwards = pick(swimBackCands, 2);
-    }
-    {
-        static const uint32_t swimLeftCands[] = {anim::SWIM_LEFT, anim::SWIM};
-        caps.resolvedSwimLeft = pick(swimLeftCands, 2);
-    }
-    {
-        static const uint32_t swimRightCands[] = {anim::SWIM_RIGHT, anim::SWIM};
-        caps.resolvedSwimRight = pick(swimRightCands, 2);
-    }
-
-    // ── Melee combat (fallback chains match resolveMeleeAnimId) ─────────
-    {
-        static const uint32_t melee1HCands[] = {
-            anim::ATTACK_1H, anim::ATTACK_2H, anim::ATTACK_UNARMED,
-            anim::ATTACK_2H_LOOSE, anim::PARRY_UNARMED, anim::PARRY_1H};
-        caps.resolvedMelee1H = pick(melee1HCands, 6);
-    }
-    {
-        static const uint32_t melee2HCands[] = {
-            anim::ATTACK_2H, anim::ATTACK_1H, anim::ATTACK_UNARMED,
-            anim::ATTACK_2H_LOOSE, anim::PARRY_UNARMED, anim::PARRY_1H};
-        caps.resolvedMelee2H = pick(melee2HCands, 6);
-    }
-    {
-        static const uint32_t melee2HLooseCands[] = {
-            anim::ATTACK_2H_LOOSE_PIERCE, anim::ATTACK_2H_LOOSE,
-            anim::ATTACK_2H, anim::ATTACK_1H, anim::ATTACK_UNARMED};
-        caps.resolvedMelee2HLoose = pick(melee2HLooseCands, 5);
-    }
-    {
-        static const uint32_t meleeUnarmedCands[] = {
-            anim::ATTACK_UNARMED, anim::ATTACK_1H, anim::ATTACK_2H,
-            anim::ATTACK_2H_LOOSE, anim::PARRY_UNARMED, anim::PARRY_1H};
-        caps.resolvedMeleeUnarmed = pick(meleeUnarmedCands, 6);
-    }
-    {
-        static const uint32_t meleeFistCands[] = {
-            anim::ATTACK_FIST_1H, anim::ATTACK_FIST_1H_OFF,
-            anim::ATTACK_1H, anim::ATTACK_UNARMED,
-            anim::PARRY_FIST_1H, anim::PARRY_1H};
-        caps.resolvedMeleeFist = pick(meleeFistCands, 6);
-    }
-    {
-        static const uint32_t meleePierceCands[] = {
-            anim::ATTACK_1H_PIERCE, anim::ATTACK_1H, anim::ATTACK_UNARMED};
-        caps.resolvedMeleePierce = pick(meleePierceCands, 3);
-    }
-    {
-        static const uint32_t meleeOffCands[] = {
-            anim::ATTACK_OFF, anim::ATTACK_1H, anim::ATTACK_UNARMED};
-        caps.resolvedMeleeOffHand = pick(meleeOffCands, 3);
-    }
-    {
-        static const uint32_t meleeOffFistCands[] = {
-            anim::ATTACK_FIST_1H_OFF, anim::ATTACK_OFF,
-            anim::ATTACK_FIST_1H, anim::ATTACK_1H};
-        caps.resolvedMeleeOffHandFist = pick(meleeOffFistCands, 4);
-    }
-    {
-        static const uint32_t meleeOffPierceCands[] = {
-            anim::ATTACK_OFF_PIERCE, anim::ATTACK_OFF,
-            anim::ATTACK_1H_PIERCE, anim::ATTACK_1H};
-        caps.resolvedMeleeOffHandPierce = pick(meleeOffPierceCands, 4);
-    }
-    {
-        static const uint32_t meleeOffUnarmedCands[] = {
-            anim::ATTACK_UNARMED_OFF, anim::ATTACK_UNARMED,
-            anim::ATTACK_OFF, anim::ATTACK_1H};
-        caps.resolvedMeleeOffHandUnarmed = pick(meleeOffUnarmedCands, 4);
-    }
-    caps.hasMelee = (caps.resolvedMelee1H != 0 || caps.resolvedMeleeUnarmed != 0);
-
-    // ── Ready stances ───────────────────────────────────────────────────
-    {
-        static const uint32_t ready1HCands[] = {
-            anim::READY_1H, anim::READY_2H, anim::READY_UNARMED};
-        caps.resolvedReady1H = pick(ready1HCands, 3);
-    }
-    {
-        static const uint32_t ready2HCands[] = {
-            anim::READY_2H, anim::READY_2H_LOOSE, anim::READY_1H, anim::READY_UNARMED};
-        caps.resolvedReady2H = pick(ready2HCands, 4);
-    }
-    {
-        static const uint32_t ready2HLooseCands[] = {
-            anim::READY_2H_LOOSE, anim::READY_2H, anim::READY_1H, anim::READY_UNARMED};
-        caps.resolvedReady2HLoose = pick(ready2HLooseCands, 4);
-    }
-    {
-        static const uint32_t readyUnarmedCands[] = {
-            anim::READY_UNARMED, anim::READY_1H, anim::READY_FIST};
-        caps.resolvedReadyUnarmed = pick(readyUnarmedCands, 3);
-    }
-    {
-        static const uint32_t readyFistCands[] = {
-            anim::READY_FIST_1H, anim::READY_FIST, anim::READY_1H, anim::READY_UNARMED};
-        caps.resolvedReadyFist = pick(readyFistCands, 4);
-    }
-    {
-        static const uint32_t readyBowCands[] = {
-            anim::READY_BOW, anim::READY_1H, anim::READY_UNARMED};
-        caps.resolvedReadyBow = pick(readyBowCands, 3);
-    }
-    {
-        static const uint32_t readyRifleCands[] = {
-            anim::READY_RIFLE, anim::READY_BOW, anim::READY_1H, anim::READY_UNARMED};
-        caps.resolvedReadyRifle = pick(readyRifleCands, 4);
-    }
-    {
-        static const uint32_t readyCrossbowCands[] = {
-            anim::READY_CROSSBOW, anim::READY_BOW, anim::READY_1H, anim::READY_UNARMED};
-        caps.resolvedReadyCrossbow = pick(readyCrossbowCands, 4);
-    }
-    {
-        static const uint32_t readyThrownCands[] = {
-            anim::READY_THROWN, anim::READY_1H, anim::READY_UNARMED};
-        caps.resolvedReadyThrown = pick(readyThrownCands, 3);
-    }
-
-    // ── Ranged attacks ──────────────────────────────────────────────────
-    {
-        static const uint32_t fireBowCands[] = {anim::FIRE_BOW, anim::ATTACK_BOW};
-        caps.resolvedFireBow = pick(fireBowCands, 2);
-    }
-    caps.resolvedAttackRifle = has(anim::ATTACK_RIFLE) ? anim::ATTACK_RIFLE : 0;
-    {
-        static const uint32_t attackCrossbowCands[] = {anim::ATTACK_CROSSBOW, anim::ATTACK_BOW};
-        caps.resolvedAttackCrossbow = pick(attackCrossbowCands, 2);
-    }
-    caps.resolvedAttackThrown = has(anim::ATTACK_THROWN) ? anim::ATTACK_THROWN : 0;
-    caps.resolvedLoadBow = has(anim::LOAD_BOW) ? anim::LOAD_BOW : 0;
-    caps.resolvedLoadRifle = has(anim::LOAD_RIFLE) ? anim::LOAD_RIFLE : 0;
-
-    // ── Special attacks ─────────────────────────────────────────────────
-    caps.resolvedSpecial1H = has(anim::SPECIAL_1H) ? anim::SPECIAL_1H : 0;
-    caps.resolvedSpecial2H = has(anim::SPECIAL_2H) ? anim::SPECIAL_2H : 0;
-    caps.resolvedSpecialUnarmed = has(anim::SPECIAL_UNARMED) ? anim::SPECIAL_UNARMED : 0;
-    caps.resolvedShieldBash = has(anim::SHIELD_BASH) ? anim::SHIELD_BASH : 0;
-
-    // ── Combat idle ─────────────────────────────────────────────────────
-    // Base combat idle — weapon-specific stances are resolved per-frame
-    // using ready stance fields above
-    caps.resolvedCombatIdle = has(anim::READY_1H) ? anim::READY_1H
-                            : (has(anim::READY_UNARMED) ? anim::READY_UNARMED : 0);
-
-    // ── Activity animations ─────────────────────────────────────────────
-    caps.resolvedStandWound = has(anim::STAND_WOUND) ? anim::STAND_WOUND : 0;
-    caps.resolvedDeath = has(anim::DEATH) ? anim::DEATH : 0;
-    caps.hasDeath = (caps.resolvedDeath != 0);
-    caps.resolvedLoot = has(anim::LOOT) ? anim::LOOT : 0;
-    caps.resolvedSitDown = has(anim::SIT_GROUND_DOWN) ? anim::SIT_GROUND_DOWN : 0;
-    caps.resolvedSitLoop = has(anim::SITTING) ? anim::SITTING : 0;
-    caps.resolvedSitUp = has(anim::SIT_GROUND_UP) ? anim::SIT_GROUND_UP : 0;
-    caps.resolvedKneel = has(anim::KNEEL_LOOP) ? anim::KNEEL_LOOP : 0;
-
-    // ── Stealth ─────────────────────────────────────────────────────────
-    caps.resolvedStealthIdle = has(anim::STEALTH_STAND) ? anim::STEALTH_STAND : 0;
-    caps.resolvedStealthWalk = has(anim::STEALTH_WALK) ? anim::STEALTH_WALK : 0;
-    caps.resolvedStealthRun = has(anim::STEALTH_RUN) ? anim::STEALTH_RUN : 0;
-    caps.hasStealth = (caps.resolvedStealthIdle != 0);
-
-    // ── Misc ────────────────────────────────────────────────────────────
-    caps.resolvedMount = has(anim::MOUNT) ? anim::MOUNT : 0;
-    caps.hasMount = (caps.resolvedMount != 0);
-    caps.resolvedUnsheathe = has(anim::UNSHEATHE) ? anim::UNSHEATHE : 0;
-    {
-        static const uint32_t sheatheCands[] = {anim::SHEATHE, anim::HIP_SHEATHE};
-        caps.resolvedSheathe = pick(sheatheCands, 2);
-    }
-    caps.resolvedStun = has(anim::STUN) ? anim::STUN : 0;
-    caps.resolvedCombatWound = has(anim::COMBAT_WOUND) ? anim::COMBAT_WOUND : 0;
-
-    return caps;
-}
-
-AnimCapabilitySet AnimCapabilityProbe::probeMountModel(Renderer* /*renderer*/, uint32_t /*mountInstanceId*/) {
-    // Mount models use M2Renderer, not CharacterRenderer
-    // For now, mount capabilities are handled separately via MountAnimSet discovery
-    // This stub returns an empty set — mount animations are discovered in setMounted()
-    AnimCapabilitySet caps;
-    return caps;
-}
-
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/animation/animation_ids.cpp b/src/rendering/animation/animation_ids.cpp
deleted file mode 100644
index 22f5b607..00000000
--- a/src/rendering/animation/animation_ids.cpp
+++ /dev/null
@@ -1,567 +0,0 @@
-// ============================================================================
-// animation_ids.cpp — Inverse lookup & DBC validation
-// Generated from animation_ids.hpp (452 constants, IDs 0–451)
-// ============================================================================
-#include "rendering/animation/animation_ids.hpp"
-#include "pipeline/dbc_loader.hpp"
-#include "core/logger.hpp"
-
-#include <unordered_set>
-
-namespace wowee {
-namespace rendering {
-namespace anim {
-
-const char* nameFromId(uint32_t id) {
-    static const char* const names[ANIM_COUNT] = {
-        /*   0 */ "STAND",
-        /*   1 */ "DEATH",
-        /*   2 */ "SPELL",
-        /*   3 */ "STOP",
-        /*   4 */ "WALK",
-        /*   5 */ "RUN",
-        /*   6 */ "DEAD",
-        /*   7 */ "RISE",
-        /*   8 */ "STAND_WOUND",
-        /*   9 */ "COMBAT_WOUND",
-        /*  10 */ "COMBAT_CRITICAL",
-        /*  11 */ "SHUFFLE_LEFT",
-        /*  12 */ "SHUFFLE_RIGHT",
-        /*  13 */ "WALK_BACKWARDS",
-        /*  14 */ "STUN",
-        /*  15 */ "HANDS_CLOSED",
-        /*  16 */ "ATTACK_UNARMED",
-        /*  17 */ "ATTACK_1H",
-        /*  18 */ "ATTACK_2H",
-        /*  19 */ "ATTACK_2H_LOOSE",
-        /*  20 */ "PARRY_UNARMED",
-        /*  21 */ "PARRY_1H",
-        /*  22 */ "PARRY_2H",
-        /*  23 */ "PARRY_2H_LOOSE",
-        /*  24 */ "SHIELD_BLOCK",
-        /*  25 */ "READY_UNARMED",
-        /*  26 */ "READY_1H",
-        /*  27 */ "READY_2H",
-        /*  28 */ "READY_2H_LOOSE",
-        /*  29 */ "READY_BOW",
-        /*  30 */ "DODGE",
-        /*  31 */ "SPELL_PRECAST",
-        /*  32 */ "SPELL_CAST",
-        /*  33 */ "SPELL_CAST_AREA",
-        /*  34 */ "NPC_WELCOME",
-        /*  35 */ "NPC_GOODBYE",
-        /*  36 */ "BLOCK",
-        /*  37 */ "JUMP_START",
-        /*  38 */ "JUMP",
-        /*  39 */ "JUMP_END",
-        /*  40 */ "FALL",
-        /*  41 */ "SWIM_IDLE",
-        /*  42 */ "SWIM",
-        /*  43 */ "SWIM_LEFT",
-        /*  44 */ "SWIM_RIGHT",
-        /*  45 */ "SWIM_BACKWARDS",
-        /*  46 */ "ATTACK_BOW",
-        /*  47 */ "FIRE_BOW",
-        /*  48 */ "READY_RIFLE",
-        /*  49 */ "ATTACK_RIFLE",
-        /*  50 */ "LOOT",
-        /*  51 */ "READY_SPELL_DIRECTED",
-        /*  52 */ "READY_SPELL_OMNI",
-        /*  53 */ "SPELL_CAST_DIRECTED",
-        /*  54 */ "SPELL_CAST_OMNI",
-        /*  55 */ "BATTLE_ROAR",
-        /*  56 */ "READY_ABILITY",
-        /*  57 */ "SPECIAL_1H",
-        /*  58 */ "SPECIAL_2H",
-        /*  59 */ "SHIELD_BASH",
-        /*  60 */ "EMOTE_TALK",
-        /*  61 */ "EMOTE_EAT",
-        /*  62 */ "EMOTE_WORK",
-        /*  63 */ "EMOTE_USE_STANDING",
-        /*  64 */ "EMOTE_EXCLAMATION",
-        /*  65 */ "EMOTE_QUESTION",
-        /*  66 */ "EMOTE_BOW",
-        /*  67 */ "EMOTE_WAVE",
-        /*  68 */ "EMOTE_CHEER",
-        /*  69 */ "EMOTE_DANCE",
-        /*  70 */ "EMOTE_LAUGH",
-        /*  71 */ "EMOTE_SLEEP",
-        /*  72 */ "EMOTE_SIT_GROUND",
-        /*  73 */ "EMOTE_RUDE",
-        /*  74 */ "EMOTE_ROAR",
-        /*  75 */ "EMOTE_KNEEL",
-        /*  76 */ "EMOTE_KISS",
-        /*  77 */ "EMOTE_CRY",
-        /*  78 */ "EMOTE_CHICKEN",
-        /*  79 */ "EMOTE_BEG",
-        /*  80 */ "EMOTE_APPLAUD",
-        /*  81 */ "EMOTE_SHOUT",
-        /*  82 */ "EMOTE_FLEX",
-        /*  83 */ "EMOTE_SHY",
-        /*  84 */ "EMOTE_POINT",
-        /*  85 */ "ATTACK_1H_PIERCE",
-        /*  86 */ "ATTACK_2H_LOOSE_PIERCE",
-        /*  87 */ "ATTACK_OFF",
-        /*  88 */ "ATTACK_OFF_PIERCE",
-        /*  89 */ "SHEATHE",
-        /*  90 */ "HIP_SHEATHE",
-        /*  91 */ "MOUNT",
-        /*  92 */ "RUN_RIGHT",
-        /*  93 */ "RUN_LEFT",
-        /*  94 */ "MOUNT_SPECIAL",
-        /*  95 */ "KICK",
-        /*  96 */ "SIT_GROUND_DOWN",
-        /*  97 */ "SITTING",
-        /*  98 */ "SIT_GROUND_UP",
-        /*  99 */ "SLEEP_DOWN",
-        /* 100 */ "SLEEP",
-        /* 101 */ "SLEEP_UP",
-        /* 102 */ "SIT_CHAIR_LOW",
-        /* 103 */ "SIT_CHAIR_MED",
-        /* 104 */ "SIT_CHAIR_HIGH",
-        /* 105 */ "LOAD_BOW",
-        /* 106 */ "LOAD_RIFLE",
-        /* 107 */ "ATTACK_THROWN",
-        /* 108 */ "READY_THROWN",
-        /* 109 */ "HOLD_BOW",
-        /* 110 */ "HOLD_RIFLE",
-        /* 111 */ "HOLD_THROWN",
-        /* 112 */ "LOAD_THROWN",
-        /* 113 */ "EMOTE_SALUTE",
-        /* 114 */ "KNEEL_START",
-        /* 115 */ "KNEEL_LOOP",
-        /* 116 */ "KNEEL_END",
-        /* 117 */ "ATTACK_UNARMED_OFF",
-        /* 118 */ "SPECIAL_UNARMED",
-        /* 119 */ "STEALTH_WALK",
-        /* 120 */ "STEALTH_STAND",
-        /* 121 */ "KNOCKDOWN",
-        /* 122 */ "EATING_LOOP",
-        /* 123 */ "USE_STANDING_LOOP",
-        /* 124 */ "CHANNEL_CAST_DIRECTED",
-        /* 125 */ "CHANNEL_CAST_OMNI",
-        /* 126 */ "WHIRLWIND",
-        /* 127 */ "BIRTH",
-        /* 128 */ "USE_STANDING_START",
-        /* 129 */ "USE_STANDING_END",
-        /* 130 */ "CREATURE_SPECIAL",
-        /* 131 */ "DROWN",
-        /* 132 */ "DROWNED",
-        /* 133 */ "FISHING_CAST",
-        /* 134 */ "FISHING_LOOP",
-        /* 135 */ "FLY",
-        /* 136 */ "EMOTE_WORK_NO_SHEATHE",
-        /* 137 */ "EMOTE_STUN_NO_SHEATHE",
-        /* 138 */ "EMOTE_USE_STANDING_NO_SHEATHE",
-        /* 139 */ "SPELL_SLEEP_DOWN",
-        /* 140 */ "SPELL_KNEEL_START",
-        /* 141 */ "SPELL_KNEEL_LOOP",
-        /* 142 */ "SPELL_KNEEL_END",
-        /* 143 */ "SPRINT",
-        /* 144 */ "IN_FLIGHT",
-        /* 145 */ "SPAWN",
-        /* 146 */ "CLOSE",
-        /* 147 */ "CLOSED",
-        /* 148 */ "OPEN",
-        /* 149 */ "DESTROY",
-        /* 150 */ "DESTROYED",
-        /* 151 */ "UNSHEATHE",
-        /* 152 */ "SHEATHE_ALT",
-        /* 153 */ "ATTACK_UNARMED_NO_SHEATHE",
-        /* 154 */ "STEALTH_RUN",
-        /* 155 */ "READY_CROSSBOW",
-        /* 156 */ "ATTACK_CROSSBOW",
-        /* 157 */ "EMOTE_TALK_EXCLAMATION",
-        /* 158 */ "FLY_IDLE",
-        /* 159 */ "FLY_FORWARD",
-        /* 160 */ "FLY_BACKWARDS",
-        /* 161 */ "FLY_LEFT",
-        /* 162 */ "FLY_RIGHT",
-        /* 163 */ "FLY_UP",
-        /* 164 */ "FLY_DOWN",
-        /* 165 */ "FLY_LAND_START",
-        /* 166 */ "FLY_LAND_RUN",
-        /* 167 */ "FLY_LAND_END",
-        /* 168 */ "EMOTE_TALK_QUESTION",
-        /* 169 */ "EMOTE_READ",
-        /* 170 */ "EMOTE_SHIELDBLOCK",
-        /* 171 */ "EMOTE_CHOP",
-        /* 172 */ "EMOTE_HOLDRIFLE",
-        /* 173 */ "EMOTE_HOLDBOW",
-        /* 174 */ "EMOTE_HOLDTHROWN",
-        /* 175 */ "CUSTOM_SPELL_02",
-        /* 176 */ "CUSTOM_SPELL_03",
-        /* 177 */ "CUSTOM_SPELL_04",
-        /* 178 */ "CUSTOM_SPELL_05",
-        /* 179 */ "CUSTOM_SPELL_06",
-        /* 180 */ "CUSTOM_SPELL_07",
-        /* 181 */ "CUSTOM_SPELL_08",
-        /* 182 */ "CUSTOM_SPELL_09",
-        /* 183 */ "CUSTOM_SPELL_10",
-        /* 184 */ "EMOTE_STATE_DANCE",
-        /* 185 */ "FLY_STAND",
-        /* 186 */ "EMOTE_STATE_LAUGH",
-        /* 187 */ "EMOTE_STATE_POINT",
-        /* 188 */ "EMOTE_STATE_EAT",
-        /* 189 */ "EMOTE_STATE_WORK",
-        /* 190 */ "EMOTE_STATE_SIT_GROUND",
-        /* 191 */ "EMOTE_STATE_HOLD_BOW",
-        /* 192 */ "EMOTE_STATE_HOLD_RIFLE",
-        /* 193 */ "EMOTE_STATE_HOLD_THROWN",
-        /* 194 */ "FLY_COMBAT_WOUND",
-        /* 195 */ "FLY_COMBAT_CRITICAL",
-        /* 196 */ "RECLINED",
-        /* 197 */ "EMOTE_STATE_ROAR",
-        /* 198 */ "EMOTE_USE_STANDING_LOOP_2",
-        /* 199 */ "EMOTE_STATE_APPLAUD",
-        /* 200 */ "READY_FIST",
-        /* 201 */ "SPELL_CHANNEL_DIRECTED_OMNI",
-        /* 202 */ "SPECIAL_ATTACK_1H_OFF",
-        /* 203 */ "ATTACK_FIST_1H",
-        /* 204 */ "ATTACK_FIST_1H_OFF",
-        /* 205 */ "PARRY_FIST_1H",
-        /* 206 */ "READY_FIST_1H",
-        /* 207 */ "EMOTE_STATE_READ_AND_TALK",
-        /* 208 */ "EMOTE_STATE_WORK_NO_SHEATHE",
-        /* 209 */ "FLY_RUN",
-        /* 210 */ "EMOTE_STATE_KNEEL_2",
-        /* 211 */ "EMOTE_STATE_SPELL_KNEEL",
-        /* 212 */ "EMOTE_STATE_USE_STANDING",
-        /* 213 */ "EMOTE_STATE_STUN",
-        /* 214 */ "EMOTE_STATE_STUN_NO_SHEATHE",
-        /* 215 */ "EMOTE_TRAIN",
-        /* 216 */ "EMOTE_DEAD",
-        /* 217 */ "EMOTE_STATE_DANCE_ONCE",
-        /* 218 */ "FLY_DEATH",
-        /* 219 */ "FLY_STAND_WOUND",
-        /* 220 */ "FLY_SHUFFLE_LEFT",
-        /* 221 */ "FLY_SHUFFLE_RIGHT",
-        /* 222 */ "FLY_WALK_BACKWARDS",
-        /* 223 */ "FLY_STUN",
-        /* 224 */ "FLY_HANDS_CLOSED",
-        /* 225 */ "FLY_ATTACK_UNARMED",
-        /* 226 */ "FLY_ATTACK_1H",
-        /* 227 */ "FLY_ATTACK_2H",
-        /* 228 */ "FLY_ATTACK_2H_LOOSE",
-        /* 229 */ "FLY_SPELL",
-        /* 230 */ "FLY_STOP",
-        /* 231 */ "FLY_WALK",
-        /* 232 */ "FLY_DEAD",
-        /* 233 */ "FLY_RISE",
-        /* 234 */ "FLY_RUN_2",
-        /* 235 */ "FLY_FALL",
-        /* 236 */ "FLY_SWIM_IDLE",
-        /* 237 */ "FLY_SWIM",
-        /* 238 */ "FLY_SWIM_LEFT",
-        /* 239 */ "FLY_SWIM_RIGHT",
-        /* 240 */ "FLY_SWIM_BACKWARDS",
-        /* 241 */ "FLY_ATTACK_BOW",
-        /* 242 */ "FLY_FIRE_BOW",
-        /* 243 */ "FLY_READY_RIFLE",
-        /* 244 */ "FLY_ATTACK_RIFLE",
-        /* 245 */ "TOTEM_SMALL",
-        /* 246 */ "TOTEM_MEDIUM",
-        /* 247 */ "TOTEM_LARGE",
-        /* 248 */ "FLY_LOOT",
-        /* 249 */ "FLY_READY_SPELL_DIRECTED",
-        /* 250 */ "FLY_READY_SPELL_OMNI",
-        /* 251 */ "FLY_SPELL_CAST_DIRECTED",
-        /* 252 */ "FLY_SPELL_CAST_OMNI",
-        /* 253 */ "FLY_BATTLE_ROAR",
-        /* 254 */ "FLY_READY_ABILITY",
-        /* 255 */ "FLY_SPECIAL_1H",
-        /* 256 */ "FLY_SPECIAL_2H",
-        /* 257 */ "FLY_SHIELD_BASH",
-        /* 258 */ "FLY_EMOTE_TALK",
-        /* 259 */ "FLY_EMOTE_EAT",
-        /* 260 */ "FLY_EMOTE_WORK",
-        /* 261 */ "FLY_EMOTE_USE_STANDING",
-        /* 262 */ "FLY_EMOTE_BOW",
-        /* 263 */ "FLY_EMOTE_WAVE",
-        /* 264 */ "FLY_EMOTE_CHEER",
-        /* 265 */ "FLY_EMOTE_DANCE",
-        /* 266 */ "FLY_EMOTE_LAUGH",
-        /* 267 */ "FLY_EMOTE_SLEEP",
-        /* 268 */ "FLY_EMOTE_SIT_GROUND",
-        /* 269 */ "FLY_EMOTE_RUDE",
-        /* 270 */ "FLY_EMOTE_ROAR",
-        /* 271 */ "FLY_EMOTE_KNEEL",
-        /* 272 */ "FLY_EMOTE_KISS",
-        /* 273 */ "FLY_EMOTE_CRY",
-        /* 274 */ "FLY_EMOTE_CHICKEN",
-        /* 275 */ "FLY_EMOTE_BEG",
-        /* 276 */ "FLY_EMOTE_APPLAUD",
-        /* 277 */ "FLY_EMOTE_SHOUT",
-        /* 278 */ "FLY_EMOTE_FLEX",
-        /* 279 */ "FLY_EMOTE_SHY",
-        /* 280 */ "FLY_EMOTE_POINT",
-        /* 281 */ "FLY_ATTACK_1H_PIERCE",
-        /* 282 */ "FLY_ATTACK_2H_LOOSE_PIERCE",
-        /* 283 */ "FLY_ATTACK_OFF",
-        /* 284 */ "FLY_ATTACK_OFF_PIERCE",
-        /* 285 */ "FLY_SHEATHE",
-        /* 286 */ "FLY_HIP_SHEATHE",
-        /* 287 */ "FLY_MOUNT",
-        /* 288 */ "FLY_RUN_RIGHT",
-        /* 289 */ "FLY_RUN_LEFT",
-        /* 290 */ "FLY_MOUNT_SPECIAL",
-        /* 291 */ "FLY_KICK",
-        /* 292 */ "FLY_SIT_GROUND_DOWN",
-        /* 293 */ "FLY_SITTING",
-        /* 294 */ "FLY_SIT_GROUND_UP",
-        /* 295 */ "FLY_SLEEP_DOWN",
-        /* 296 */ "FLY_SLEEP",
-        /* 297 */ "FLY_SLEEP_UP",
-        /* 298 */ "FLY_SIT_CHAIR_LOW",
-        /* 299 */ "FLY_SIT_CHAIR_MED",
-        /* 300 */ "FLY_SIT_CHAIR_HIGH",
-        /* 301 */ "FLY_LOAD_BOW",
-        /* 302 */ "FLY_LOAD_RIFLE",
-        /* 303 */ "FLY_ATTACK_THROWN",
-        /* 304 */ "FLY_READY_THROWN",
-        /* 305 */ "FLY_HOLD_BOW",
-        /* 306 */ "FLY_HOLD_RIFLE",
-        /* 307 */ "FLY_HOLD_THROWN",
-        /* 308 */ "FLY_LOAD_THROWN",
-        /* 309 */ "FLY_EMOTE_SALUTE",
-        /* 310 */ "FLY_KNEEL_START",
-        /* 311 */ "FLY_KNEEL_LOOP",
-        /* 312 */ "FLY_KNEEL_END",
-        /* 313 */ "FLY_ATTACK_UNARMED_OFF",
-        /* 314 */ "FLY_SPECIAL_UNARMED",
-        /* 315 */ "FLY_STEALTH_WALK",
-        /* 316 */ "FLY_STEALTH_STAND",
-        /* 317 */ "FLY_KNOCKDOWN",
-        /* 318 */ "FLY_EATING_LOOP",
-        /* 319 */ "FLY_USE_STANDING_LOOP",
-        /* 320 */ "FLY_CHANNEL_CAST_DIRECTED",
-        /* 321 */ "FLY_CHANNEL_CAST_OMNI",
-        /* 322 */ "FLY_WHIRLWIND",
-        /* 323 */ "FLY_BIRTH",
-        /* 324 */ "FLY_USE_STANDING_START",
-        /* 325 */ "FLY_USE_STANDING_END",
-        /* 326 */ "FLY_CREATURE_SPECIAL",
-        /* 327 */ "FLY_DROWN",
-        /* 328 */ "FLY_DROWNED",
-        /* 329 */ "FLY_FISHING_CAST",
-        /* 330 */ "FLY_FISHING_LOOP",
-        /* 331 */ "FLY_FLY",
-        /* 332 */ "FLY_EMOTE_WORK_NO_SHEATHE",
-        /* 333 */ "FLY_EMOTE_STUN_NO_SHEATHE",
-        /* 334 */ "FLY_EMOTE_USE_STANDING_NO_SHEATHE",
-        /* 335 */ "FLY_SPELL_SLEEP_DOWN",
-        /* 336 */ "FLY_SPELL_KNEEL_START",
-        /* 337 */ "FLY_SPELL_KNEEL_LOOP",
-        /* 338 */ "FLY_SPELL_KNEEL_END",
-        /* 339 */ "FLY_SPRINT",
-        /* 340 */ "FLY_IN_FLIGHT",
-        /* 341 */ "FLY_SPAWN",
-        /* 342 */ "FLY_CLOSE",
-        /* 343 */ "FLY_CLOSED",
-        /* 344 */ "FLY_OPEN",
-        /* 345 */ "FLY_DESTROY",
-        /* 346 */ "FLY_DESTROYED",
-        /* 347 */ "FLY_UNSHEATHE",
-        /* 348 */ "FLY_SHEATHE_ALT",
-        /* 349 */ "FLY_ATTACK_UNARMED_NO_SHEATHE",
-        /* 350 */ "FLY_STEALTH_RUN",
-        /* 351 */ "FLY_READY_CROSSBOW",
-        /* 352 */ "FLY_ATTACK_CROSSBOW",
-        /* 353 */ "FLY_EMOTE_TALK_EXCLAMATION",
-        /* 354 */ "FLY_EMOTE_TALK_QUESTION",
-        /* 355 */ "FLY_EMOTE_READ",
-        /* 356 */ "EMOTE_HOLD_CROSSBOW",
-        /* 357 */ "FLY_EMOTE_HOLD_BOW",
-        /* 358 */ "FLY_EMOTE_HOLD_RIFLE",
-        /* 359 */ "FLY_EMOTE_HOLD_THROWN",
-        /* 360 */ "FLY_EMOTE_HOLD_CROSSBOW",
-        /* 361 */ "FLY_CUSTOM_SPELL_02",
-        /* 362 */ "FLY_CUSTOM_SPELL_03",
-        /* 363 */ "FLY_CUSTOM_SPELL_04",
-        /* 364 */ "FLY_CUSTOM_SPELL_05",
-        /* 365 */ "FLY_CUSTOM_SPELL_06",
-        /* 366 */ "FLY_CUSTOM_SPELL_07",
-        /* 367 */ "FLY_CUSTOM_SPELL_08",
-        /* 368 */ "FLY_CUSTOM_SPELL_09",
-        /* 369 */ "FLY_CUSTOM_SPELL_10",
-        /* 370 */ "FLY_EMOTE_STATE_DANCE",
-        /* 371 */ "EMOTE_EAT_NO_SHEATHE",
-        /* 372 */ "MOUNT_RUN_RIGHT",
-        /* 373 */ "MOUNT_RUN_LEFT",
-        /* 374 */ "MOUNT_WALK_BACKWARDS",
-        /* 375 */ "MOUNT_SWIM_IDLE",
-        /* 376 */ "MOUNT_SWIM",
-        /* 377 */ "MOUNT_SWIM_LEFT",
-        /* 378 */ "MOUNT_SWIM_RIGHT",
-        /* 379 */ "MOUNT_SWIM_BACKWARDS",
-        /* 380 */ "MOUNT_FLIGHT_IDLE",
-        /* 381 */ "MOUNT_FLIGHT_FORWARD",
-        /* 382 */ "MOUNT_FLIGHT_BACKWARDS",
-        /* 383 */ "MOUNT_FLIGHT_LEFT",
-        /* 384 */ "MOUNT_FLIGHT_RIGHT",
-        /* 385 */ "MOUNT_FLIGHT_UP",
-        /* 386 */ "MOUNT_FLIGHT_DOWN",
-        /* 387 */ "MOUNT_FLIGHT_LAND_START",
-        /* 388 */ "MOUNT_FLIGHT_LAND_RUN",
-        /* 389 */ "MOUNT_FLIGHT_LAND_END",
-        /* 390 */ "FLY_EMOTE_STATE_LAUGH",
-        /* 391 */ "FLY_EMOTE_STATE_POINT",
-        /* 392 */ "FLY_EMOTE_STATE_EAT",
-        /* 393 */ "FLY_EMOTE_STATE_WORK",
-        /* 394 */ "FLY_EMOTE_STATE_SIT_GROUND",
-        /* 395 */ "FLY_EMOTE_STATE_HOLD_BOW",
-        /* 396 */ "FLY_EMOTE_STATE_HOLD_RIFLE",
-        /* 397 */ "FLY_EMOTE_STATE_HOLD_THROWN",
-        /* 398 */ "FLY_EMOTE_STATE_ROAR",
-        /* 399 */ "FLY_RECLINED",
-        /* 400 */ "EMOTE_TRAIN_2",
-        /* 401 */ "EMOTE_DEAD_2",
-        /* 402 */ "FLY_EMOTE_USE_STANDING_LOOP_2",
-        /* 403 */ "FLY_EMOTE_STATE_APPLAUD",
-        /* 404 */ "FLY_READY_FIST",
-        /* 405 */ "FLY_SPELL_CHANNEL_DIRECTED_OMNI",
-        /* 406 */ "FLY_SPECIAL_ATTACK_1H_OFF",
-        /* 407 */ "FLY_ATTACK_FIST_1H",
-        /* 408 */ "FLY_ATTACK_FIST_1H_OFF",
-        /* 409 */ "FLY_PARRY_FIST_1H",
-        /* 410 */ "FLY_READY_FIST_1H",
-        /* 411 */ "FLY_EMOTE_STATE_READ_AND_TALK",
-        /* 412 */ "FLY_EMOTE_STATE_WORK_NO_SHEATHE",
-        /* 413 */ "FLY_EMOTE_STATE_KNEEL_2",
-        /* 414 */ "FLY_EMOTE_STATE_SPELL_KNEEL",
-        /* 415 */ "FLY_EMOTE_STATE_USE_STANDING",
-        /* 416 */ "FLY_EMOTE_STATE_STUN",
-        /* 417 */ "FLY_EMOTE_STATE_STUN_NO_SHEATHE",
-        /* 418 */ "FLY_EMOTE_TRAIN",
-        /* 419 */ "FLY_EMOTE_DEAD",
-        /* 420 */ "FLY_EMOTE_STATE_DANCE_ONCE",
-        /* 421 */ "FLY_EMOTE_EAT_NO_SHEATHE",
-        /* 422 */ "FLY_MOUNT_RUN_RIGHT",
-        /* 423 */ "FLY_MOUNT_RUN_LEFT",
-        /* 424 */ "FLY_MOUNT_WALK_BACKWARDS",
-        /* 425 */ "FLY_MOUNT_SWIM_IDLE",
-        /* 426 */ "FLY_MOUNT_SWIM",
-        /* 427 */ "FLY_MOUNT_SWIM_LEFT",
-        /* 428 */ "FLY_MOUNT_SWIM_RIGHT",
-        /* 429 */ "FLY_MOUNT_SWIM_BACKWARDS",
-        /* 430 */ "FLY_MOUNT_FLIGHT_IDLE",
-        /* 431 */ "FLY_MOUNT_FLIGHT_FORWARD",
-        /* 432 */ "FLY_MOUNT_FLIGHT_BACKWARDS",
-        /* 433 */ "FLY_MOUNT_FLIGHT_LEFT",
-        /* 434 */ "FLY_MOUNT_FLIGHT_RIGHT",
-        /* 435 */ "FLY_MOUNT_FLIGHT_UP",
-        /* 436 */ "FLY_MOUNT_FLIGHT_DOWN",
-        /* 437 */ "FLY_MOUNT_FLIGHT_LAND_START",
-        /* 438 */ "FLY_MOUNT_FLIGHT_LAND_RUN",
-        /* 439 */ "FLY_MOUNT_FLIGHT_LAND_END",
-        /* 440 */ "FLY_TOTEM_SMALL",
-        /* 441 */ "FLY_TOTEM_MEDIUM",
-        /* 442 */ "FLY_TOTEM_LARGE",
-        /* 443 */ "FLY_EMOTE_HOLD_CROSSBOW_2",
-        /* 444 */ "VEHICLE_GRAB",
-        /* 445 */ "VEHICLE_THROW",
-        /* 446 */ "FLY_VEHICLE_GRAB",
-        /* 447 */ "FLY_VEHICLE_THROW",
-        /* 448 */ "GUILD_CHAMPION_1",
-        /* 449 */ "GUILD_CHAMPION_2",
-        /* 450 */ "FLY_GUILD_CHAMPION_1",
-        /* 451 */ "FLY_GUILD_CHAMPION_2",
-    };
-    if (id < ANIM_COUNT) return names[id];
-    return "UNKNOWN";
-}
-
-uint32_t flyVariant(uint32_t groundId) {
-    // Compact lookup: ground animation ID (0–451) → FLY_* variant, or 0 if none.
-    // Built from the 155 ground→fly pairs in animation_ids.hpp.
-    static const uint16_t table[] = {
-        // 0-9
-        185, 218, 229, 230, 231, 209, 232, 233, 219, 194,
-        // 10-19
-        195, 220, 221, 222, 223, 224, 225, 226, 227, 228,
-        // 20-29 (PARRY/READY/DODGE — no fly variants)
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // 30-39 (BLOCK/SPELL_PRECAST/NPC — no fly variants)
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // 40-49
-        235, 236, 237, 238, 239, 240, 241, 242, 243, 244,
-        // 50-59
-        248, 249, 250, 251, 252, 253, 254, 255, 256, 257,
-        // 60-69
-        258, 259, 260, 261, 0, 0, 262, 263, 264, 265,
-        // 70-79
-        266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
-        // 80-89
-        276, 277, 278, 279, 280, 281, 282, 283, 284, 285,
-        // 90-99
-        286, 287, 288, 289, 290, 291, 292, 293, 294, 295,
-        // 100-109
-        296, 297, 298, 299, 300, 301, 302, 303, 304, 305,
-        // 110-119
-        306, 307, 308, 309, 310, 311, 312, 313, 314, 315,
-        // 120-129
-        316, 317, 318, 319, 320, 321, 322, 323, 324, 325,
-        // 130-139
-        326, 327, 328, 329, 330, 331, 332, 333, 334, 335,
-        // 140-149
-        336, 337, 338, 339, 340, 341, 342, 343, 344, 345,
-        // 150-159
-        346, 347, 348, 349, 350, 351, 352, 353, 0, 0,
-        // 160-169 (FLY_BACKWARDS..FLY_LAND_END are already FLY_ themselves: 0)
-        0, 0, 0, 0, 0, 0, 0, 0, 354, 355,
-        // 170-179
-        0, 0, 0, 0, 0, 361, 362, 363, 364, 365,
-        // 180-189
-        366, 367, 368, 369, 370, 0, 390, 391, 392, 393,
-        // 190-199
-        394, 395, 396, 397, 0, 0, 399, 398, 402, 403,
-        // 200-209
-        404, 405, 406, 407, 408, 409, 410, 411, 412, 0,
-        // 210-217
-        413, 414, 415, 416, 417, 418, 419, 420,
-    };
-    constexpr uint32_t tableSize = sizeof(table) / sizeof(table[0]);
-    if (groundId >= tableSize) return 0;
-    return table[groundId];
-}
-
-void validateAgainstDBC(const std::shared_ptr<wowee::pipeline::DBCFile>& dbc) {
-    if (!dbc || !dbc->isLoaded()) {
-        LOG_WARNING("AnimationData.dbc not available — skipping animation ID validation");
-        return;
-    }
-
-    // Collect all IDs present in the DBC (first field is the animation ID)
-    std::unordered_set<uint32_t> dbcIds;
-    for (uint32_t i = 0; i < dbc->getRecordCount(); ++i) {
-        uint32_t id = dbc->getUInt32(i, 0);
-        dbcIds.insert(id);
-    }
-
-    // Check: constants we define that are missing from DBC
-    uint32_t missingInDbc = 0;
-    for (uint32_t id = 0; id < ANIM_COUNT; ++id) {
-        if (dbcIds.find(id) == dbcIds.end()) {
-            LOG_WARNING("Animation ID ", id, " (", nameFromId(id),
-                        ") defined in constants but missing from AnimationData.dbc");
-            ++missingInDbc;
-        }
-    }
-
-    // Check: DBC IDs beyond our constant range
-    uint32_t extraInDbc = 0;
-    for (uint32_t dbcId : dbcIds) {
-        if (dbcId >= ANIM_COUNT) {
-            ++extraInDbc;
-        }
-    }
-
-    LOG_INFO("AnimationData.dbc validation: ", dbc->getRecordCount(), " DBC records, ",
-             ANIM_COUNT, " constants, ",
-             missingInDbc, " missing from DBC, ",
-             extraInDbc, " DBC-only IDs beyond constant range");
-}
-
-} // namespace anim
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/animation/animation_manager.cpp b/src/rendering/animation/animation_manager.cpp
deleted file mode 100644
index 5951a015..00000000
--- a/src/rendering/animation/animation_manager.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-// Renamed from PlayerAnimator/NpcAnimator dual-map → unified CharacterAnimator registry.
-// NpcAnimator methods removed — all characters use CharacterAnimator.
-#include "rendering/animation/animation_manager.hpp"
-
-namespace wowee {
-namespace rendering {
-
-// ── Character animators ──────────────────────────────────────────────────────
-
-CharacterAnimator& AnimationManager::getOrCreate(uint32_t instanceId) {
-    auto it = animators_.find(instanceId);
-    if (it != animators_.end()) return *it->second;
-
-    auto [inserted, _] = animators_.emplace(instanceId, std::make_unique<CharacterAnimator>());
-    return *inserted->second;
-}
-
-CharacterAnimator* AnimationManager::get(uint32_t instanceId) {
-    auto it = animators_.find(instanceId);
-    return it != animators_.end() ? it->second.get() : nullptr;
-}
-
-void AnimationManager::remove(uint32_t instanceId) {
-    animators_.erase(instanceId);
-}
-
-// ── Update all ───────────────────────────────────────────────────────────────
-
-void AnimationManager::updateAll(float dt) {
-    for (auto& [id, animator] : animators_) {
-        animator->update(dt);
-    }
-}
-
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/animation/character_animator.cpp b/src/rendering/animation/character_animator.cpp
deleted file mode 100644
index c7a74abb..00000000
--- a/src/rendering/animation/character_animator.cpp
+++ /dev/null
@@ -1,216 +0,0 @@
-// Renamed from player_animator.cpp → character_animator.cpp
-// Class renamed: PlayerAnimator → CharacterAnimator
-// All animations are now generic (character-based, not player-specific).
-#include "rendering/animation/character_animator.hpp"
-#include "rendering/animation/animation_ids.hpp"
-#include "game/inventory.hpp"
-
-namespace wowee {
-namespace rendering {
-
-CharacterAnimator::CharacterAnimator() = default;
-
-// ── IAnimator ────────────────────────────────────────────────────────────────
-
-void CharacterAnimator::onEvent(AnimEvent event) {
-    locomotion_.onEvent(event);
-    combat_.onEvent(event);
-    activity_.onEvent(event);
-    mount_.onEvent(event);
-}
-
-void CharacterAnimator::update(float dt) {
-    lastDt_ = dt;
-    lastOutput_ = resolveAnimation();
-}
-
-// ── ICharacterAnimator ──────────────────────────────────────────────────────
-
-void CharacterAnimator::startSpellCast(uint32_t precast, uint32_t cast, bool loop, uint32_t finalize) {
-    combat_.startSpellCast(precast, cast, loop, finalize);
-}
-
-void CharacterAnimator::stopSpellCast() {
-    combat_.stopSpellCast();
-}
-
-void CharacterAnimator::triggerMeleeSwing() {
-    // Melee is handled via timer in FrameInput — CombatFSM transitions automatically
-}
-
-void CharacterAnimator::triggerRangedShot() {
-    // Ranged is handled via timer in FrameInput — CombatFSM transitions automatically
-}
-
-void CharacterAnimator::triggerHitReaction(uint32_t animId) {
-    combat_.triggerHitReaction(animId);
-}
-
-void CharacterAnimator::triggerSpecialAttack(uint32_t /*spellId*/) {
-    // Special attack animation is injected via FrameInput::specialAttackAnimId
-}
-
-void CharacterAnimator::setEquippedWeaponType(const WeaponLoadout& loadout) {
-    loadout_ = loadout;
-}
-
-void CharacterAnimator::setEquippedRangedType(RangedWeaponType type) {
-    loadout_.rangedType = type;
-}
-
-void CharacterAnimator::playEmote(uint32_t animId, bool loop) {
-    activity_.startEmote(animId, loop);
-}
-
-void CharacterAnimator::cancelEmote() {
-    activity_.cancelEmote();
-}
-
-void CharacterAnimator::startLooting() {
-    activity_.startLooting();
-}
-
-void CharacterAnimator::stopLooting() {
-    activity_.stopLooting();
-}
-
-void CharacterAnimator::setStunned(bool stunned) {
-    combat_.setStunned(stunned);
-}
-
-void CharacterAnimator::setCharging(bool charging) {
-    combat_.setCharging(charging);
-}
-
-void CharacterAnimator::setStandState(uint8_t state) {
-    activity_.setStandState(state);
-}
-
-void CharacterAnimator::setStealthed(bool stealth) {
-    stealthed_ = stealth;
-}
-
-void CharacterAnimator::setInCombat(bool combat) {
-    inCombat_ = combat;
-}
-
-void CharacterAnimator::setLowHealth(bool low) {
-    lowHealth_ = low;
-}
-
-void CharacterAnimator::setSprintAuraActive(bool active) {
-    sprintAura_ = active;
-}
-
-// ── Mount ────────────────────────────────────────────────────────────────────
-
-void CharacterAnimator::configureMountFSM(const MountFSM::MountAnimSet& anims, bool taxiFlight) {
-    mount_.configure(anims, taxiFlight);
-}
-
-void CharacterAnimator::clearMountFSM() {
-    mount_.clear();
-}
-
-// ── Priority resolver ────────────────────────────────────────────────────────
-
-AnimOutput CharacterAnimator::resolveAnimation() {
-    const auto& fi = frameInput_;
-
-    // ── Mount takes over everything ─────────────────────────────────────
-    if (mount_.isActive()) {
-        // MountFSM returns mount-specific output; rider anim is separate
-        // For the main character animation, we return MOUNT (or flight variant)
-        uint32_t riderAnim = caps_.resolvedMount ? caps_.resolvedMount : anim::MOUNT;
-        return AnimOutput::ok(riderAnim, true);
-    }
-
-    // ── Build combat input ──────────────────────────────────────────────
-    CombatFSM::Input combatIn;
-    combatIn.inCombat = inCombat_;
-    combatIn.grounded = fi.grounded;
-    combatIn.jumping = fi.jumping;
-    combatIn.swimming = fi.swimming;
-    combatIn.moving = fi.moving;
-    combatIn.sprinting = fi.sprinting;
-    combatIn.lowHealth = lowHealth_;
-    combatIn.meleeSwingTimer = fi.meleeSwingTimer;
-    combatIn.rangedShootTimer = fi.rangedShootTimer;
-    combatIn.specialAttackAnimId = fi.specialAttackAnimId;
-    combatIn.rangedAnimId = fi.rangedAnimId;
-    combatIn.currentAnimId = fi.currentAnimId;
-    combatIn.currentAnimTime = fi.currentAnimTime;
-    combatIn.currentAnimDuration = fi.currentAnimDuration;
-    combatIn.haveAnimState = fi.haveAnimState;
-    combatIn.hasUnsheathe = caps_.resolvedUnsheathe != 0;
-    combatIn.hasSheathe = caps_.resolvedSheathe != 0;
-
-    // ── Combat FSM (highest priority for non-mount) ─────────────────────
-    auto combatOut = combat_.resolve(combatIn, caps_, loadout_);
-    if (combatOut.valid) return applyOverlays(combatOut);
-
-    // ── Activity FSM (emote, loot, sit) ─────────────────────────────────
-    ActivityFSM::Input actIn;
-    actIn.moving = fi.moving;
-    actIn.sprinting = fi.sprinting;
-    actIn.jumping = fi.jumping;
-    actIn.grounded = fi.grounded;
-    actIn.swimming = fi.swimming;
-    actIn.sitting = fi.sitting;
-    actIn.stunned = combat_.isStunned();
-    actIn.currentAnimId = fi.currentAnimId;
-    actIn.currentAnimTime = fi.currentAnimTime;
-    actIn.currentAnimDuration = fi.currentAnimDuration;
-    actIn.haveAnimState = fi.haveAnimState;
-
-    auto actOut = activity_.resolve(actIn, caps_);
-    if (actOut.valid) return actOut;
-
-    // ── Locomotion FSM (lowest priority) ────────────────────────────────
-    LocomotionFSM::Input locoIn;
-    locoIn.moving = fi.moving;
-    locoIn.movingForward = fi.movingForward;
-    locoIn.sprinting = fi.sprinting;
-    locoIn.movingBackward = fi.movingBackward;
-    locoIn.strafeLeft = fi.strafeLeft;
-    locoIn.strafeRight = fi.strafeRight;
-    locoIn.grounded = fi.grounded;
-    locoIn.jumping = fi.jumping;
-    locoIn.swimming = fi.swimming;
-    locoIn.sitting = fi.sitting;
-    locoIn.sprintAura = sprintAura_;
-    locoIn.deltaTime = lastDt_;
-    // Animation state for one-shot completion detection (jump start/end)
-    locoIn.currentAnimId = fi.currentAnimId;
-    locoIn.currentAnimTime = fi.currentAnimTime;
-    locoIn.currentAnimDuration = fi.currentAnimDuration;
-    locoIn.haveAnimState = fi.haveAnimState;
-
-    auto locoOut = locomotion_.resolve(locoIn, caps_);
-    if (locoOut.valid) return applyOverlays(locoOut);
-
-    // All FSMs returned invalid → STAY (keep last animation)
-    return AnimOutput::stay();
-}
-
-// ── Overlay application ──────────────────────────────────────────────────────
-
-AnimOutput CharacterAnimator::applyOverlays(AnimOutput base) const {
-    if (!stealthed_) return base;
-
-    // Stealth substitution based on locomotion state
-    auto locoState = locomotion_.getState();
-    if (locoState == LocomotionFSM::State::IDLE) {
-        if (caps_.resolvedStealthIdle) base.animId = caps_.resolvedStealthIdle;
-    } else if (locoState == LocomotionFSM::State::WALK) {
-        if (caps_.resolvedStealthWalk) base.animId = caps_.resolvedStealthWalk;
-    } else if (locoState == LocomotionFSM::State::RUN) {
-        if (caps_.resolvedStealthRun) base.animId = caps_.resolvedStealthRun;
-        else if (caps_.resolvedStealthWalk) base.animId = caps_.resolvedStealthWalk;
-    }
-
-    return base;
-}
-
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/animation/combat_fsm.cpp b/src/rendering/animation/combat_fsm.cpp
deleted file mode 100644
index 997fb938..00000000
--- a/src/rendering/animation/combat_fsm.cpp
+++ /dev/null
@@ -1,459 +0,0 @@
-#include "rendering/animation/combat_fsm.hpp"
-#include "rendering/animation/animation_ids.hpp"
-#include "game/inventory.hpp"
-
-namespace wowee {
-namespace rendering {
-
-// ── One-shot completion helper ───────────────────────────────────────────────
-
-bool CombatFSM::oneShotComplete(const Input& in, uint32_t expectedAnimId) const {
-    if (!in.haveAnimState) return false;
-    // Renderer auto-returns one-shots to STAND; detect that OR normal completion
-    return in.currentAnimId != expectedAnimId ||
-           (in.currentAnimDuration > 0.1f && in.currentAnimTime >= in.currentAnimDuration - 0.05f);
-}
-
-// ── Event handling ───────────────────────────────────────────────────────────
-
-void CombatFSM::onEvent(AnimEvent event) {
-    switch (event) {
-        case AnimEvent::COMBAT_ENTER:
-            if (state_ == State::INACTIVE)
-                state_ = State::UNSHEATHE;
-            break;
-        case AnimEvent::COMBAT_EXIT:
-            if (state_ == State::COMBAT_IDLE)
-                state_ = State::SHEATHE;
-            break;
-        case AnimEvent::STUN_ENTER:
-            clearSpellState();
-            hitReactionAnimId_ = 0;
-            stunned_ = true;
-            state_ = State::STUNNED;
-            break;
-        case AnimEvent::STUN_EXIT:
-            stunned_ = false;
-            if (state_ == State::STUNNED)
-                state_ = State::INACTIVE;
-            break;
-        case AnimEvent::HIT_REACT:
-            // Handled by triggerHitReaction() with animId
-            break;
-        case AnimEvent::CHARGE_START:
-            charging_ = true;
-            clearSpellState();
-            state_ = State::CHARGE;
-            break;
-        case AnimEvent::CHARGE_END:
-            charging_ = false;
-            if (state_ == State::CHARGE)
-                state_ = State::INACTIVE;
-            break;
-        case AnimEvent::SWIM_ENTER:
-            clearSpellState();
-            hitReactionAnimId_ = 0;
-            stunned_ = false;
-            state_ = State::INACTIVE;
-            break;
-        default:
-            break;
-    }
-}
-
-// ── Spell cast management ────────────────────────────────────────────────────
-
-void CombatFSM::startSpellCast(uint32_t precast, uint32_t cast, bool castLoop, uint32_t finalize) {
-    spellPrecastAnimId_ = precast;
-    spellCastAnimId_ = cast;
-    spellCastLoop_ = castLoop;
-    spellFinalizeAnimId_ = finalize;
-    spellPrecastAnimSeen_ = false;
-    spellPrecastFrames_ = 0;
-    spellFinalizeAnimSeen_ = false;
-    spellFinalizeFrames_ = 0;
-    state_ = (precast != 0) ? State::SPELL_PRECAST : State::SPELL_CASTING;
-}
-
-void CombatFSM::stopSpellCast() {
-    if (state_ != State::SPELL_PRECAST && state_ != State::SPELL_CASTING) return;
-    spellFinalizeAnimSeen_ = false;
-    spellFinalizeFrames_ = 0;
-    state_ = State::SPELL_FINALIZE;
-}
-
-void CombatFSM::clearSpellState() {
-    spellPrecastAnimId_ = 0;
-    spellCastAnimId_ = 0;
-    spellCastLoop_ = false;
-    spellFinalizeAnimId_ = 0;
-    spellPrecastAnimSeen_ = false;
-    spellPrecastFrames_ = 0;
-    spellFinalizeAnimSeen_ = false;
-    spellFinalizeFrames_ = 0;
-}
-
-// ── Hit/stun ─────────────────────────────────────────────────────────────────
-
-void CombatFSM::triggerHitReaction(uint32_t animId) {
-    // Don't interrupt swim/jump/stun states
-    if (state_ == State::STUNNED) return;
-    // Interrupt spell casting
-    if (state_ == State::SPELL_PRECAST || state_ == State::SPELL_CASTING || state_ == State::SPELL_FINALIZE) {
-        clearSpellState();
-    }
-    hitReactionAnimId_ = animId;
-    state_ = State::HIT_REACTION;
-}
-
-void CombatFSM::setStunned(bool stunned) {
-    stunned_ = stunned;
-    if (stunned) {
-        if (state_ == State::SPELL_PRECAST || state_ == State::SPELL_CASTING || state_ == State::SPELL_FINALIZE) {
-            clearSpellState();
-        }
-        hitReactionAnimId_ = 0;
-        state_ = State::STUNNED;
-    } else {
-        if (state_ == State::STUNNED)
-            state_ = State::INACTIVE;
-    }
-}
-
-void CombatFSM::setCharging(bool charging) {
-    charging_ = charging;
-    if (charging) {
-        clearSpellState();
-        hitReactionAnimId_ = 0;
-        state_ = State::CHARGE;
-    } else if (state_ == State::CHARGE) {
-        state_ = State::INACTIVE;
-    }
-}
-
-// ── State transitions ────────────────────────────────────────────────────────
-
-void CombatFSM::updateTransitions(const Input& in) {
-    // Stun override: can't act while stunned
-    if (stunned_ && state_ != State::STUNNED) {
-        state_ = State::STUNNED;
-        return;
-    }
-
-    // Force melee/ranged overrides
-    if (in.meleeSwingTimer > 0.0f && !stunned_ && in.grounded && !in.swimming) {
-        if (state_ != State::MELEE_SWING) {
-            clearSpellState();
-            hitReactionAnimId_ = 0;
-        }
-        state_ = State::MELEE_SWING;
-        return;
-    }
-    if (in.rangedShootTimer > 0.0f && !stunned_ && in.meleeSwingTimer <= 0.0f && in.grounded && !in.swimming) {
-        if (state_ != State::RANGED_SHOOT) {
-            clearSpellState();
-            hitReactionAnimId_ = 0;
-        }
-        state_ = State::RANGED_SHOOT;
-        return;
-    }
-    if (charging_ && !stunned_) {
-        if (state_ != State::CHARGE) {
-            clearSpellState();
-            hitReactionAnimId_ = 0;
-        }
-        state_ = State::CHARGE;
-        return;
-    }
-
-    switch (state_) {
-        case State::INACTIVE:
-            if (in.inCombat && in.grounded && !in.swimming && !in.moving) {
-                state_ = in.hasUnsheathe ? State::UNSHEATHE : State::COMBAT_IDLE;
-            }
-            break;
-
-        case State::COMBAT_IDLE:
-            if (in.swimming || in.jumping || !in.grounded || in.moving) {
-                state_ = State::INACTIVE;
-            } else if (!in.inCombat) {
-                state_ = in.hasSheathe ? State::SHEATHE : State::INACTIVE;
-            }
-            break;
-
-        case State::MELEE_SWING:
-            if (in.meleeSwingTimer <= 0.0f) {
-                if (in.swimming) {
-                    state_ = State::INACTIVE;
-                } else if (in.inCombat && in.grounded) {
-                    state_ = State::COMBAT_IDLE;
-                } else {
-                    state_ = State::INACTIVE;
-                }
-            }
-            break;
-
-        case State::RANGED_SHOOT:
-            if (in.rangedShootTimer <= 0.0f) {
-                if (in.swimming) {
-                    state_ = State::INACTIVE;
-                } else if (in.inCombat && in.grounded) {
-                    state_ = State::RANGED_LOAD;
-                } else {
-                    state_ = State::INACTIVE;
-                }
-            }
-            break;
-
-        case State::RANGED_LOAD:
-            if (in.swimming || in.jumping || !in.grounded || in.moving) {
-                state_ = State::INACTIVE;
-            } else if (in.inCombat) {
-                state_ = State::COMBAT_IDLE;
-            } else {
-                state_ = State::INACTIVE;
-            }
-            break;
-
-        case State::SPELL_PRECAST:
-            if (in.swimming || (in.jumping && !in.grounded) || (!in.grounded && !in.jumping)) {
-                clearSpellState();
-                state_ = State::INACTIVE;
-            } else if (in.haveAnimState) {
-                uint32_t expectedAnim = spellPrecastAnimId_ ? spellPrecastAnimId_ : anim::SPELL_PRECAST;
-                if (in.currentAnimId == expectedAnim) spellPrecastAnimSeen_ = true;
-                if (spellPrecastAnimSeen_ && oneShotComplete(in, expectedAnim)) {
-                    state_ = State::SPELL_CASTING;
-                }
-                if (!spellPrecastAnimSeen_ && ++spellPrecastFrames_ > 10) {
-                    state_ = State::SPELL_CASTING;
-                }
-            }
-            break;
-
-        case State::SPELL_CASTING:
-            if (in.swimming || (in.jumping && !in.grounded) || (!in.grounded && !in.jumping)) {
-                clearSpellState();
-                state_ = State::INACTIVE;
-            } else if (in.moving) {
-                clearSpellState();
-                state_ = State::INACTIVE;
-            }
-            // Stays in SPELL_CASTING until stopSpellCast() is called externally
-            break;
-
-        case State::SPELL_FINALIZE: {
-            if (in.swimming || (in.jumping && !in.grounded)) {
-                clearSpellState();
-                state_ = State::INACTIVE;
-            } else if (in.haveAnimState) {
-                uint32_t expectedAnim = spellFinalizeAnimId_ ? spellFinalizeAnimId_
-                    : (spellCastAnimId_ ? spellCastAnimId_ : anim::SPELL);
-                if (in.currentAnimId == expectedAnim) spellFinalizeAnimSeen_ = true;
-                if (spellFinalizeAnimSeen_ && oneShotComplete(in, expectedAnim)) {
-                    clearSpellState();
-                    state_ = in.inCombat ? State::COMBAT_IDLE : State::INACTIVE;
-                }
-                // Safety: if finalize anim never seen (model lacks it), finish after timeout
-                if (!spellFinalizeAnimSeen_ && ++spellFinalizeFrames_ > 10) {
-                    clearSpellState();
-                    state_ = in.inCombat ? State::COMBAT_IDLE : State::INACTIVE;
-                }
-            }
-            break;
-        }
-
-        case State::HIT_REACTION:
-            if (in.swimming || in.moving) {
-                hitReactionAnimId_ = 0;
-                state_ = State::INACTIVE;
-            } else if (in.haveAnimState) {
-                uint32_t expectedAnim = hitReactionAnimId_ ? hitReactionAnimId_ : anim::COMBAT_WOUND;
-                if (oneShotComplete(in, expectedAnim)) {
-                    hitReactionAnimId_ = 0;
-                    state_ = in.inCombat ? State::COMBAT_IDLE : State::INACTIVE;
-                }
-            }
-            break;
-
-        case State::STUNNED:
-            if (!stunned_) {
-                state_ = in.inCombat ? State::COMBAT_IDLE : State::INACTIVE;
-            } else if (in.swimming) {
-                stunned_ = false;
-                state_ = State::INACTIVE;
-            }
-            break;
-
-        case State::CHARGE:
-            if (!charging_) {
-                state_ = State::INACTIVE;
-            }
-            break;
-
-        case State::UNSHEATHE:
-            if (in.swimming || in.moving) {
-                state_ = State::INACTIVE;
-            } else if (in.haveAnimState && oneShotComplete(in, anim::UNSHEATHE)) {
-                state_ = State::COMBAT_IDLE;
-            }
-            break;
-
-        case State::SHEATHE:
-            if (in.swimming || in.moving) {
-                state_ = State::INACTIVE;
-            } else if (in.inCombat) {
-                state_ = State::COMBAT_IDLE;
-            } else if (in.haveAnimState && oneShotComplete(in, anim::SHEATHE)) {
-                state_ = State::INACTIVE;
-            }
-            break;
-    }
-}
-
-// ── Animation resolution ─────────────────────────────────────────────────────
-
-AnimOutput CombatFSM::resolve(const Input& in, const AnimCapabilitySet& caps,
-                               const WeaponLoadout& loadout) {
-    updateTransitions(in);
-
-    if (state_ == State::INACTIVE) return AnimOutput::stay();
-
-    uint32_t animId = 0;
-    bool loop = true;
-
-    switch (state_) {
-        case State::INACTIVE:
-            return AnimOutput::stay();
-
-        case State::COMBAT_IDLE:
-            if (in.lowHealth && caps.resolvedStandWound) {
-                animId = caps.resolvedStandWound;
-            } else if (loadout.rangedType == RangedWeaponType::BOW) {
-                animId = caps.resolvedReadyBow;
-            } else if (loadout.rangedType == RangedWeaponType::GUN) {
-                animId = caps.resolvedReadyRifle;
-            } else if (loadout.rangedType == RangedWeaponType::CROSSBOW) {
-                animId = caps.resolvedReadyCrossbow;
-            } else if (loadout.rangedType == RangedWeaponType::THROWN) {
-                animId = caps.resolvedReadyThrown;
-            } else if (loadout.is2HLoose) {
-                animId = caps.resolvedReady2HLoose;
-            } else if (loadout.inventoryType == game::InvType::TWO_HAND) {
-                animId = caps.resolvedReady2H;
-            } else if (loadout.isFist) {
-                animId = caps.resolvedReadyFist;
-            } else if (loadout.inventoryType == game::InvType::NON_EQUIP) {
-                animId = caps.resolvedReadyUnarmed;
-            } else {
-                animId = caps.resolvedReady1H;
-            }
-            loop = true;
-            break;
-
-        case State::MELEE_SWING:
-            if (in.specialAttackAnimId != 0) {
-                animId = in.specialAttackAnimId;
-            } else {
-                // Resolve melee animation using probed capabilities + weapon loadout
-                bool useOffHand = loadout.hasOffHand && offHandTurn_;
-                offHandTurn_ = loadout.hasOffHand ? !offHandTurn_ : false;
-
-                if (useOffHand) {
-                    if (loadout.isFist) animId = caps.resolvedMeleeOffHandFist;
-                    else if (loadout.isDagger) animId = caps.resolvedMeleeOffHandPierce;
-                    else if (loadout.inventoryType == game::InvType::NON_EQUIP) animId = caps.resolvedMeleeOffHandUnarmed;
-                    else animId = caps.resolvedMeleeOffHand;
-                } else if (loadout.isFist) {
-                    animId = caps.resolvedMeleeFist;
-                } else if (loadout.isDagger) {
-                    animId = caps.resolvedMeleePierce;
-                } else if (loadout.is2HLoose) {
-                    animId = caps.resolvedMelee2HLoose;
-                } else if (loadout.inventoryType == game::InvType::TWO_HAND) {
-                    animId = caps.resolvedMelee2H;
-                } else if (loadout.inventoryType == game::InvType::NON_EQUIP) {
-                    animId = caps.resolvedMeleeUnarmed;
-                } else {
-                    animId = caps.resolvedMelee1H;
-                }
-            }
-            if (animId == 0) animId = anim::STAND; // Melee must play something
-            loop = false;
-            break;
-
-        case State::RANGED_SHOOT:
-            animId = in.rangedAnimId ? in.rangedAnimId : anim::ATTACK_BOW;
-            loop = false;
-            break;
-
-        case State::RANGED_LOAD:
-            switch (loadout.rangedType) {
-                case RangedWeaponType::BOW:      animId = caps.resolvedLoadBow; break;
-                case RangedWeaponType::GUN:      animId = caps.resolvedLoadRifle; break;
-                case RangedWeaponType::CROSSBOW: animId = caps.resolvedLoadBow; break;
-                default: break;
-            }
-            loop = false;
-            break;
-
-        case State::SPELL_PRECAST:
-            animId = spellPrecastAnimId_ ? spellPrecastAnimId_ : anim::SPELL_PRECAST;
-            loop = false;
-            break;
-
-        case State::SPELL_CASTING:
-            animId = spellCastAnimId_ ? spellCastAnimId_ : anim::SPELL;
-            loop = spellCastLoop_;
-            break;
-
-        case State::SPELL_FINALIZE:
-            animId = spellFinalizeAnimId_ ? spellFinalizeAnimId_
-                   : (spellCastAnimId_ ? spellCastAnimId_ : anim::SPELL);
-            loop = false;
-            break;
-
-        case State::HIT_REACTION:
-            animId = hitReactionAnimId_ ? hitReactionAnimId_
-                   : (caps.resolvedCombatWound ? caps.resolvedCombatWound : anim::COMBAT_WOUND);
-            loop = false;
-            break;
-
-        case State::STUNNED:
-            animId = caps.resolvedStun ? caps.resolvedStun : anim::STUN;
-            loop = true;
-            break;
-
-        case State::CHARGE:
-            animId = caps.resolvedRun ? caps.resolvedRun : anim::RUN;
-            loop = true;
-            break;
-
-        case State::UNSHEATHE:
-            animId = caps.resolvedUnsheathe ? caps.resolvedUnsheathe : anim::UNSHEATHE;
-            loop = false;
-            break;
-
-        case State::SHEATHE:
-            animId = caps.resolvedSheathe ? caps.resolvedSheathe : anim::SHEATHE;
-            loop = false;
-            break;
-    }
-
-    if (animId == 0) return AnimOutput::stay();
-    return AnimOutput::ok(animId, loop);
-}
-
-// ── Reset ────────────────────────────────────────────────────────────────────
-
-void CombatFSM::reset() {
-    state_ = State::INACTIVE;
-    clearSpellState();
-    hitReactionAnimId_ = 0;
-    stunned_ = false;
-    charging_ = false;
-    offHandTurn_ = false;
-}
-
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/animation/emote_registry.cpp b/src/rendering/animation/emote_registry.cpp
deleted file mode 100644
index 88236349..00000000
--- a/src/rendering/animation/emote_registry.cpp
+++ /dev/null
@@ -1,299 +0,0 @@
-#include "rendering/animation/emote_registry.hpp"
-#include "rendering/animation/animation_ids.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "pipeline/dbc_loader.hpp"
-#include "pipeline/dbc_layout.hpp"
-#include "core/application.hpp"
-#include "core/logger.hpp"
-
-#include <algorithm>
-#include <cctype>
-#include <unordered_set>
-
-namespace wowee {
-namespace rendering {
-
-// ── Helper functions (moved from animation_controller.cpp) ───────────────────
-
-static std::vector<std::string> parseEmoteCommands(const std::string& raw) {
-    std::vector<std::string> out;
-    std::string cur;
-    for (char c : raw) {
-        if (std::isalnum(static_cast<unsigned char>(c)) || c == '_') {
-            cur.push_back(static_cast<char>(std::tolower(static_cast<unsigned char>(c))));
-        } else if (!cur.empty()) {
-            out.push_back(cur);
-            cur.clear();
-        }
-    }
-    if (!cur.empty()) out.push_back(cur);
-    return out;
-}
-
-static bool isLoopingEmote(const std::string& command) {
-    static const std::unordered_set<std::string> kLooping = {
-        "dance", "train", "dead", "eat", "work",
-    };
-    return kLooping.find(command) != kLooping.end();
-}
-
-// Map one-shot emote animation IDs to their persistent EMOTE_STATE_* looping variants.
-// When a looping emote is played, we prefer the STATE variant if the model has it.
-static uint32_t getEmoteStateVariantStatic(uint32_t oneShotAnimId) {
-    static const std::unordered_map<uint32_t, uint32_t> kStateMap = {
-        {anim::EMOTE_DANCE,         anim::EMOTE_STATE_DANCE},
-        {anim::EMOTE_LAUGH,         anim::EMOTE_STATE_LAUGH},
-        {anim::EMOTE_POINT,         anim::EMOTE_STATE_POINT},
-        {anim::EMOTE_EAT,           anim::EMOTE_STATE_EAT},
-        {anim::EMOTE_ROAR,          anim::EMOTE_STATE_ROAR},
-        {anim::EMOTE_APPLAUD,       anim::EMOTE_STATE_APPLAUD},
-        {anim::EMOTE_WORK,          anim::EMOTE_STATE_WORK},
-        {anim::EMOTE_USE_STANDING,  anim::EMOTE_STATE_USE_STANDING},
-        {anim::EATING_LOOP,         anim::EMOTE_STATE_EAT},
-    };
-    auto it = kStateMap.find(oneShotAnimId);
-    return it != kStateMap.end() ? it->second : 0;
-}
-
-static std::string replacePlaceholders(const std::string& text, const std::string* targetName) {
-    if (text.empty()) return text;
-    std::string out;
-    out.reserve(text.size() + 16);
-    for (size_t i = 0; i < text.size(); ++i) {
-        if (text[i] == '%' && i + 1 < text.size() && text[i + 1] == 's') {
-            if (targetName && !targetName->empty()) out += *targetName;
-            i++;
-        } else {
-            out.push_back(text[i]);
-        }
-    }
-    return out;
-}
-
-// ── EmoteRegistry implementation ─────────────────────────────────────────────
-
-EmoteRegistry& EmoteRegistry::instance() {
-    static EmoteRegistry inst;
-    return inst;
-}
-
-void EmoteRegistry::loadFromDbc() {
-    if (loaded_) return;
-    loaded_ = true;
-
-    auto* assetManager = core::Application::getInstance().getAssetManager();
-    if (!assetManager) {
-        LOG_WARNING("Emotes: no AssetManager");
-        loadFallbackEmotes();
-        return;
-    }
-
-    auto emotesTextDbc = assetManager->loadDBC("EmotesText.dbc");
-    auto emotesTextDataDbc = assetManager->loadDBC("EmotesTextData.dbc");
-    if (!emotesTextDbc || !emotesTextDataDbc || !emotesTextDbc->isLoaded() || !emotesTextDataDbc->isLoaded()) {
-        LOG_WARNING("Emotes: DBCs not available (EmotesText/EmotesTextData)");
-        loadFallbackEmotes();
-        return;
-    }
-
-    const auto* activeLayout = pipeline::getActiveDBCLayout();
-    const auto* etdL = activeLayout ? activeLayout->getLayout("EmotesTextData") : nullptr;
-    const auto* emL  = activeLayout ? activeLayout->getLayout("Emotes") : nullptr;
-    const auto* etL  = activeLayout ? activeLayout->getLayout("EmotesText") : nullptr;
-
-    std::unordered_map<uint32_t, std::string> textData;
-    textData.reserve(emotesTextDataDbc->getRecordCount());
-    for (uint32_t r = 0; r < emotesTextDataDbc->getRecordCount(); ++r) {
-        uint32_t id = emotesTextDataDbc->getUInt32(r, etdL ? (*etdL)["ID"] : 0);
-        std::string text = emotesTextDataDbc->getString(r, etdL ? (*etdL)["Text"] : 1);
-        if (!text.empty()) textData.emplace(id, std::move(text));
-    }
-
-    std::unordered_map<uint32_t, uint32_t> emoteIdToAnim;
-    if (auto emotesDbc = assetManager->loadDBC("Emotes.dbc"); emotesDbc && emotesDbc->isLoaded()) {
-        emoteIdToAnim.reserve(emotesDbc->getRecordCount());
-        for (uint32_t r = 0; r < emotesDbc->getRecordCount(); ++r) {
-            uint32_t emoteId = emotesDbc->getUInt32(r, emL ? (*emL)["ID"] : 0);
-            uint32_t animId = emotesDbc->getUInt32(r, emL ? (*emL)["AnimID"] : 2);
-            if (animId != 0) emoteIdToAnim[emoteId] = animId;
-        }
-    }
-
-    emoteTable_.clear();
-    emoteTable_.reserve(emotesTextDbc->getRecordCount());
-    for (uint32_t r = 0; r < emotesTextDbc->getRecordCount(); ++r) {
-        uint32_t recordId = emotesTextDbc->getUInt32(r, etL ? (*etL)["ID"] : 0);
-        std::string cmdRaw = emotesTextDbc->getString(r, etL ? (*etL)["Command"] : 1);
-        if (cmdRaw.empty()) continue;
-
-        uint32_t emoteRef = emotesTextDbc->getUInt32(r, etL ? (*etL)["EmoteRef"] : 2);
-        uint32_t animId = 0;
-        auto animIt = emoteIdToAnim.find(emoteRef);
-        if (animIt != emoteIdToAnim.end()) {
-            animId = animIt->second;
-        } else {
-            animId = emoteRef;
-        }
-
-        uint32_t senderTargetTextId = emotesTextDbc->getUInt32(r, etL ? (*etL)["SenderTargetTextID"] : 5);
-        uint32_t senderNoTargetTextId = emotesTextDbc->getUInt32(r, etL ? (*etL)["SenderNoTargetTextID"] : 9);
-        uint32_t othersTargetTextId = emotesTextDbc->getUInt32(r, etL ? (*etL)["OthersTargetTextID"] : 3);
-        uint32_t othersNoTargetTextId = emotesTextDbc->getUInt32(r, etL ? (*etL)["OthersNoTargetTextID"] : 7);
-
-        std::string textTarget, textNoTarget, oTarget, oNoTarget;
-        if (auto it = textData.find(senderTargetTextId); it != textData.end()) textTarget = it->second;
-        if (auto it = textData.find(senderNoTargetTextId); it != textData.end()) textNoTarget = it->second;
-        if (auto it = textData.find(othersTargetTextId); it != textData.end()) oTarget = it->second;
-        if (auto it = textData.find(othersNoTargetTextId); it != textData.end()) oNoTarget = it->second;
-
-        for (const std::string& cmd : parseEmoteCommands(cmdRaw)) {
-            if (cmd.empty()) continue;
-            EmoteInfo info;
-            info.animId = animId;
-            info.dbcId = recordId;
-            info.loop = isLoopingEmote(cmd);
-            info.textNoTarget = textNoTarget;
-            info.textTarget = textTarget;
-            info.othersNoTarget = oNoTarget;
-            info.othersTarget = oTarget;
-            info.command = cmd;
-            emoteTable_.emplace(cmd, std::move(info));
-        }
-    }
-
-    if (emoteTable_.empty()) {
-        LOG_WARNING("Emotes: DBC loaded but no commands parsed, using fallback list");
-        loadFallbackEmotes();
-    } else {
-        LOG_INFO("Emotes: loaded ", emoteTable_.size(), " commands from DBC");
-    }
-
-    buildDbcIdIndex();
-}
-
-void EmoteRegistry::loadFallbackEmotes() {
-    if (!emoteTable_.empty()) return;
-    emoteTable_ = {
-        {"wave",    {anim::EMOTE_WAVE,    0, false, "You wave.", "You wave at %s.", "%s waves.", "%s waves at %s.", "wave"}},
-        {"bow",     {anim::EMOTE_BOW,     0, false, "You bow down graciously.", "You bow down before %s.", "%s bows down graciously.", "%s bows down before %s.", "bow"}},
-        {"laugh",   {anim::EMOTE_LAUGH,   0, false, "You laugh.", "You laugh at %s.", "%s laughs.", "%s laughs at %s.", "laugh"}},
-        {"point",   {anim::EMOTE_POINT,   0, false, "You point over yonder.", "You point at %s.", "%s points over yonder.", "%s points at %s.", "point"}},
-        {"cheer",   {anim::EMOTE_CHEER,   0, false, "You cheer!", "You cheer at %s.", "%s cheers!", "%s cheers at %s.", "cheer"}},
-        {"dance",   {anim::EMOTE_DANCE,   0, true,  "You burst into dance.", "You dance with %s.", "%s bursts into dance.", "%s dances with %s.", "dance"}},
-        {"kneel",   {anim::EMOTE_KNEEL,   0, false, "You kneel down.", "You kneel before %s.", "%s kneels down.", "%s kneels before %s.", "kneel"}},
-        {"applaud", {anim::EMOTE_APPLAUD, 0, false, "You applaud. Bravo!", "You applaud at %s. Bravo!", "%s applauds. Bravo!", "%s applauds at %s. Bravo!", "applaud"}},
-        {"shout",   {anim::EMOTE_SHOUT,   0, false, "You shout.", "You shout at %s.", "%s shouts.", "%s shouts at %s.", "shout"}},
-        {"chicken", {anim::EMOTE_CHICKEN, 0, false, "With arms flapping, you strut around. Cluck, Cluck, Chicken!",
-                     "With arms flapping, you strut around %s. Cluck, Cluck, Chicken!",
-                     "%s struts around. Cluck, Cluck, Chicken!", "%s struts around %s. Cluck, Cluck, Chicken!", "chicken"}},
-        {"cry",     {anim::EMOTE_CRY,     0, false, "You cry.", "You cry on %s's shoulder.", "%s cries.", "%s cries on %s's shoulder.", "cry"}},
-        {"kiss",    {anim::EMOTE_KISS,    0, false, "You blow a kiss into the wind.", "You blow a kiss to %s.", "%s blows a kiss into the wind.", "%s blows a kiss to %s.", "kiss"}},
-        {"roar",    {anim::EMOTE_ROAR,    0, false, "You roar with bestial vigor. So fierce!", "You roar with bestial vigor at %s. So fierce!", "%s roars with bestial vigor. So fierce!", "%s roars with bestial vigor at %s. So fierce!", "roar"}},
-        {"salute",  {anim::EMOTE_SALUTE,  0, false, "You salute.", "You salute %s with respect.", "%s salutes.", "%s salutes %s with respect.", "salute"}},
-        {"rude",    {anim::EMOTE_RUDE,    0, false, "You make a rude gesture.", "You make a rude gesture at %s.", "%s makes a rude gesture.", "%s makes a rude gesture at %s.", "rude"}},
-        {"flex",    {anim::EMOTE_FLEX,    0, false, "You flex your muscles. Oooooh so strong!", "You flex at %s. Oooooh so strong!", "%s flexes. Oooooh so strong!", "%s flexes at %s. Oooooh so strong!", "flex"}},
-        {"shy",     {anim::EMOTE_SHY,     0, false, "You smile shyly.", "You smile shyly at %s.", "%s smiles shyly.", "%s smiles shyly at %s.", "shy"}},
-        {"beg",     {anim::EMOTE_BEG,     0, false, "You beg everyone around you. How pathetic.", "You beg %s. How pathetic.", "%s begs everyone around. How pathetic.", "%s begs %s. How pathetic.", "beg"}},
-        {"eat",     {anim::EMOTE_EAT,     0, true,  "You begin to eat.", "You begin to eat in front of %s.", "%s begins to eat.", "%s begins to eat in front of %s.", "eat"}},
-        {"talk",    {anim::EMOTE_TALK,    0, false, "You talk.", "You talk to %s.", "%s talks.", "%s talks to %s.", "talk"}},
-        {"work",    {anim::EMOTE_WORK,    0, true,  "You begin to work.", "You begin to work near %s.", "%s begins to work.", "%s begins to work near %s.", "work"}},
-        {"train",   {anim::EMOTE_TRAIN,   0, true,  "You let off a train whistle. Choo Choo!", "You let off a train whistle at %s. Choo Choo!", "%s lets off a train whistle. Choo Choo!", "%s lets off a train whistle at %s. Choo Choo!", "train"}},
-        {"dead",    {anim::EMOTE_DEAD,    0, true,  "You play dead.", "You play dead in front of %s.", "%s plays dead.", "%s plays dead in front of %s.", "dead"}},
-    };
-    buildDbcIdIndex();
-}
-
-void EmoteRegistry::buildDbcIdIndex() {
-    emoteByDbcId_.clear();
-    for (auto& [cmd, info] : emoteTable_) {
-        if (info.dbcId != 0) {
-            emoteByDbcId_.emplace(info.dbcId, &info);
-        }
-    }
-}
-
-std::optional<EmoteRegistry::EmoteResult> EmoteRegistry::findEmote(const std::string& command) const {
-    auto it = emoteTable_.find(command);
-    if (it == emoteTable_.end()) return std::nullopt;
-    const auto& info = it->second;
-    if (info.animId == 0) return std::nullopt;
-    return EmoteResult{info.animId, info.loop};
-}
-
-uint32_t EmoteRegistry::animByDbcId(uint32_t dbcId) const {
-    auto it = emoteByDbcId_.find(dbcId);
-    if (it != emoteByDbcId_.end()) {
-        return it->second->animId;
-    }
-    return 0;
-}
-
-uint32_t EmoteRegistry::getStateVariant(uint32_t oneShotAnimId) const {
-    return getEmoteStateVariantStatic(oneShotAnimId);
-}
-
-const EmoteInfo* EmoteRegistry::findInfo(const std::string& command) const {
-    auto it = emoteTable_.find(command);
-    return it != emoteTable_.end() ? &it->second : nullptr;
-}
-
-std::string EmoteRegistry::textFor(const std::string& emoteName,
-                                   const std::string* targetName) const {
-    auto it = emoteTable_.find(emoteName);
-    if (it != emoteTable_.end()) {
-        const auto& info = it->second;
-        const std::string& base = (targetName ? info.textTarget : info.textNoTarget);
-        if (!base.empty()) {
-            return replacePlaceholders(base, targetName);
-        }
-        if (targetName && !targetName->empty()) {
-            return "You " + info.command + " at " + *targetName + ".";
-        }
-        return "You " + info.command + ".";
-    }
-    return "";
-}
-
-uint32_t EmoteRegistry::dbcIdFor(const std::string& emoteName) const {
-    auto it = emoteTable_.find(emoteName);
-    if (it != emoteTable_.end()) {
-        return it->second.dbcId;
-    }
-    return 0;
-}
-
-std::string EmoteRegistry::textByDbcId(uint32_t dbcId,
-                                       const std::string& senderName,
-                                       const std::string* targetName) const {
-    auto it = emoteByDbcId_.find(dbcId);
-    if (it == emoteByDbcId_.end()) return "";
-
-    const EmoteInfo& info = *it->second;
-
-    if (targetName && !targetName->empty()) {
-        if (!info.othersTarget.empty()) {
-            std::string out;
-            out.reserve(info.othersTarget.size() + senderName.size() + targetName->size());
-            bool firstReplaced = false;
-            for (size_t i = 0; i < info.othersTarget.size(); ++i) {
-                if (info.othersTarget[i] == '%' && i + 1 < info.othersTarget.size() && info.othersTarget[i + 1] == 's') {
-                    out += firstReplaced ? *targetName : senderName;
-                    firstReplaced = true;
-                    ++i;
-                } else {
-                    out.push_back(info.othersTarget[i]);
-                }
-            }
-            return out;
-        }
-        return senderName + " " + info.command + "s at " + *targetName + ".";
-    } else {
-        if (!info.othersNoTarget.empty()) {
-            return replacePlaceholders(info.othersNoTarget, &senderName);
-        }
-        return senderName + " " + info.command + "s.";
-    }
-}
-
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/animation/footstep_driver.cpp b/src/rendering/animation/footstep_driver.cpp
deleted file mode 100644
index 60d4a074..00000000
--- a/src/rendering/animation/footstep_driver.cpp
+++ /dev/null
@@ -1,207 +0,0 @@
-#include "rendering/animation/footstep_driver.hpp"
-#include "rendering/renderer.hpp"
-#include "rendering/camera_controller.hpp"
-#include "rendering/character_renderer.hpp"
-#include "rendering/terrain_manager.hpp"
-#include "rendering/wmo_renderer.hpp"
-#include "rendering/water_renderer.hpp"
-#include "rendering/swim_effects.hpp"
-#include "audio/audio_coordinator.hpp"
-#include "audio/footstep_manager.hpp"
-#include "audio/movement_sound_manager.hpp"
-
-#include <algorithm>
-#include <cctype>
-#include <cmath>
-
-namespace wowee {
-namespace rendering {
-
-// ── Footstep event detection (moved from AnimationController) ────────────────
-
-bool FootstepDriver::shouldTriggerFootstepEvent(uint32_t animationId, float animationTimeMs, float animationDurationMs) {
-    if (animationDurationMs <= 1.0f) {
-        footstepNormInitialized_ = false;
-        return false;
-    }
-
-    float wrappedTime = animationTimeMs;
-    while (wrappedTime >= animationDurationMs) {
-        wrappedTime -= animationDurationMs;
-    }
-    if (wrappedTime < 0.0f) wrappedTime += animationDurationMs;
-    float norm = wrappedTime / animationDurationMs;
-
-    if (animationId != footstepLastAnimationId_) {
-        footstepLastAnimationId_ = animationId;
-        footstepLastNormTime_ = norm;
-        footstepNormInitialized_ = true;
-        return false;
-    }
-
-    if (!footstepNormInitialized_) {
-        footstepNormInitialized_ = true;
-        footstepLastNormTime_ = norm;
-        return false;
-    }
-
-    auto crossed = [&](float eventNorm) {
-        if (footstepLastNormTime_ <= norm) {
-            return footstepLastNormTime_ < eventNorm && eventNorm <= norm;
-        }
-        return footstepLastNormTime_ < eventNorm || eventNorm <= norm;
-    };
-
-    bool trigger = crossed(0.22f) || crossed(0.72f);
-    footstepLastNormTime_ = norm;
-    return trigger;
-}
-
-audio::FootstepSurface FootstepDriver::resolveFootstepSurface(Renderer* renderer) const {
-    auto* cameraController = renderer->getCameraController();
-    if (!cameraController || !cameraController->isThirdPerson()) {
-        return audio::FootstepSurface::STONE;
-    }
-
-    const glm::vec3& p = renderer->getCharacterPosition();
-
-    float distSq = glm::dot(p - cachedFootstepPosition_, p - cachedFootstepPosition_);
-    if (distSq < 2.25f && cachedFootstepUpdateTimer_ < 0.5f) {
-        return cachedFootstepSurface_;
-    }
-
-    cachedFootstepPosition_ = p;
-    cachedFootstepUpdateTimer_ = 0.0f;
-
-    if (cameraController->isSwimming()) {
-        cachedFootstepSurface_ = audio::FootstepSurface::WATER;
-        return audio::FootstepSurface::WATER;
-    }
-
-    auto* waterRenderer = renderer->getWaterRenderer();
-    if (waterRenderer) {
-        auto waterH = waterRenderer->getWaterHeightAt(p.x, p.y);
-        if (waterH && p.z < (*waterH + 0.25f)) {
-            cachedFootstepSurface_ = audio::FootstepSurface::WATER;
-            return audio::FootstepSurface::WATER;
-        }
-    }
-
-    auto* wmoRenderer = renderer->getWMORenderer();
-    auto* terrainManager = renderer->getTerrainManager();
-    if (wmoRenderer) {
-        auto wmoFloor = wmoRenderer->getFloorHeight(p.x, p.y, p.z + 1.5f);
-        auto terrainFloor = terrainManager ? terrainManager->getHeightAt(p.x, p.y) : std::nullopt;
-        if (wmoFloor && (!terrainFloor || *wmoFloor >= *terrainFloor - 0.1f)) {
-            cachedFootstepSurface_ = audio::FootstepSurface::STONE;
-            return audio::FootstepSurface::STONE;
-        }
-    }
-
-    audio::FootstepSurface surface = audio::FootstepSurface::STONE;
-
-    if (terrainManager) {
-        auto texture = terrainManager->getDominantTextureAt(p.x, p.y);
-        if (texture) {
-            std::string t = *texture;
-            for (char& c : t) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-            if (t.find("snow") != std::string::npos || t.find("ice") != std::string::npos) surface = audio::FootstepSurface::SNOW;
-            else if (t.find("grass") != std::string::npos || t.find("moss") != std::string::npos || t.find("leaf") != std::string::npos) surface = audio::FootstepSurface::GRASS;
-            else if (t.find("sand") != std::string::npos || t.find("dirt") != std::string::npos || t.find("mud") != std::string::npos) surface = audio::FootstepSurface::DIRT;
-            else if (t.find("wood") != std::string::npos || t.find("timber") != std::string::npos) surface = audio::FootstepSurface::WOOD;
-            else if (t.find("metal") != std::string::npos || t.find("iron") != std::string::npos) surface = audio::FootstepSurface::METAL;
-            else if (t.find("stone") != std::string::npos || t.find("rock") != std::string::npos || t.find("cobble") != std::string::npos || t.find("brick") != std::string::npos) surface = audio::FootstepSurface::STONE;
-        }
-    }
-
-    cachedFootstepSurface_ = surface;
-    return surface;
-}
-
-// ── Footstep update (moved from AnimationController::updateFootsteps) ────────
-
-void FootstepDriver::update(float deltaTime, Renderer* renderer,
-                             bool mounted, uint32_t mountInstanceId, bool taxiFlight,
-                             bool isFootstepState) {
-    auto* footstepManager = renderer->getAudioCoordinator()->getFootstepManager();
-    if (!footstepManager) return;
-
-    auto* characterRenderer = renderer->getCharacterRenderer();
-    auto* cameraController = renderer->getCameraController();
-    uint32_t characterInstanceId = renderer->getCharacterInstanceId();
-
-    footstepManager->update(deltaTime);
-    cachedFootstepUpdateTimer_ += deltaTime;
-
-    bool canPlayFootsteps = characterRenderer && characterInstanceId > 0 &&
-        cameraController && cameraController->isThirdPerson() &&
-        cameraController->isGrounded() && !cameraController->isSwimming();
-
-    if (canPlayFootsteps && mounted && mountInstanceId > 0 && !taxiFlight) {
-        // Mount footsteps: use mount's animation for timing
-        uint32_t animId = 0;
-        float animTimeMs = 0.0f, animDurationMs = 0.0f;
-        if (characterRenderer->getAnimationState(mountInstanceId, animId, animTimeMs, animDurationMs) &&
-            animDurationMs > 1.0f && cameraController->isMoving()) {
-            float wrappedTime = animTimeMs;
-            while (wrappedTime >= animDurationMs) {
-                wrappedTime -= animDurationMs;
-            }
-            if (wrappedTime < 0.0f) wrappedTime += animDurationMs;
-            float norm = wrappedTime / animDurationMs;
-
-            if (animId != mountFootstepLastAnimId_) {
-                mountFootstepLastAnimId_ = animId;
-                mountFootstepLastNormTime_ = norm;
-                mountFootstepNormInitialized_ = true;
-            } else if (!mountFootstepNormInitialized_) {
-                mountFootstepNormInitialized_ = true;
-                mountFootstepLastNormTime_ = norm;
-            } else {
-                auto crossed = [&](float eventNorm) {
-                    if (mountFootstepLastNormTime_ <= norm) {
-                        return mountFootstepLastNormTime_ < eventNorm && eventNorm <= norm;
-                    }
-                    return mountFootstepLastNormTime_ < eventNorm || eventNorm <= norm;
-                };
-                if (crossed(0.25f) || crossed(0.75f)) {
-                    footstepManager->playFootstep(resolveFootstepSurface(renderer), true);
-                }
-                mountFootstepLastNormTime_ = norm;
-            }
-        } else {
-            mountFootstepNormInitialized_ = false;
-        }
-        footstepNormInitialized_ = false;
-    } else if (canPlayFootsteps && isFootstepState) {
-        uint32_t animId = 0;
-        float animTimeMs = 0.0f;
-        float animDurationMs = 0.0f;
-        if (characterRenderer->getAnimationState(characterInstanceId, animId, animTimeMs, animDurationMs) &&
-            shouldTriggerFootstepEvent(animId, animTimeMs, animDurationMs)) {
-            auto surface = resolveFootstepSurface(renderer);
-            footstepManager->playFootstep(surface, cameraController->isSprinting());
-            if (surface == audio::FootstepSurface::WATER) {
-                if (renderer->getAudioCoordinator()->getMovementSoundManager()) {
-                    renderer->getAudioCoordinator()->getMovementSoundManager()->playWaterFootstep(audio::MovementSoundManager::CharacterSize::MEDIUM);
-                }
-                auto* swimEffects = renderer->getSwimEffects();
-                auto* waterRenderer = renderer->getWaterRenderer();
-                if (swimEffects && waterRenderer) {
-                    const glm::vec3& characterPosition = renderer->getCharacterPosition();
-                    auto wh = waterRenderer->getWaterHeightAt(characterPosition.x, characterPosition.y);
-                    if (wh) {
-                        swimEffects->spawnFootSplash(characterPosition, *wh);
-                    }
-                }
-            }
-        }
-        mountFootstepNormInitialized_ = false;
-    } else {
-        footstepNormInitialized_ = false;
-        mountFootstepNormInitialized_ = false;
-    }
-}
-
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/animation/locomotion_fsm.cpp b/src/rendering/animation/locomotion_fsm.cpp
deleted file mode 100644
index 75c226e2..00000000
--- a/src/rendering/animation/locomotion_fsm.cpp
+++ /dev/null
@@ -1,283 +0,0 @@
-#include "rendering/animation/locomotion_fsm.hpp"
-#include "rendering/animation/animation_ids.hpp"
-#include <algorithm>
-
-namespace wowee {
-namespace rendering {
-
-// ── One-shot completion helper ─────────────────────────────────────────────────────────
-
-bool LocomotionFSM::oneShotComplete(const Input& in, uint32_t expectedAnimId) const {
-    if (!in.haveAnimState) return false;
-    return in.currentAnimId != expectedAnimId ||
-           (in.currentAnimDuration > 0.1f && in.currentAnimTime >= in.currentAnimDuration - 0.05f);
-}
-
-// ── Event handling ───────────────────────────────────────────────────────────
-
-void LocomotionFSM::onEvent(AnimEvent event) {
-    switch (event) {
-        case AnimEvent::SWIM_ENTER:
-            state_ = State::SWIM_IDLE;
-            break;
-        case AnimEvent::SWIM_EXIT:
-            state_ = State::IDLE;
-            break;
-        case AnimEvent::JUMP:
-            if (state_ != State::SWIM_IDLE && state_ != State::SWIM) {
-                jumpStartSeen_ = false;
-                state_ = State::JUMP_START;
-            }
-            break;
-        case AnimEvent::LANDED:
-            if (state_ == State::JUMP_MID || state_ == State::JUMP_START) {
-                jumpEndSeen_ = false;
-                state_ = State::JUMP_END;
-            }
-            break;
-        case AnimEvent::MOVE_START:
-            graceTimer_ = kGraceSec;
-            break;
-        case AnimEvent::MOVE_STOP:
-            // Grace timer handles the delay in updateTransitions
-            break;
-        default:
-            break;
-    }
-}
-
-// ── State transitions ────────────────────────────────────────────────────────
-
-void LocomotionFSM::updateTransitions(const Input& in, const AnimCapabilitySet& caps) {
-    // Update grace timer
-    if (in.moving) {
-        graceTimer_ = kGraceSec;
-        wasSprinting_ = in.sprinting;
-    } else {
-        graceTimer_ = std::max(0.0f, graceTimer_ - in.deltaTime);
-    }
-
-    const bool effectiveMoving = in.moving || graceTimer_ > 0.0f;
-    const bool effectiveSprinting = in.sprinting || (!in.moving && effectiveMoving && wasSprinting_);
-
-    switch (state_) {
-        case State::IDLE:
-            if (in.swimming) {
-                state_ = effectiveMoving ? State::SWIM : State::SWIM_IDLE;
-            } else if (!in.grounded && in.jumping) {
-                jumpStartSeen_ = false;
-                state_ = State::JUMP_START;
-            } else if (!in.grounded) {
-                state_ = State::JUMP_MID;
-            } else if (effectiveMoving && effectiveSprinting) {
-                state_ = State::RUN;
-            } else if (effectiveMoving) {
-                state_ = State::WALK;
-            }
-            break;
-
-        case State::WALK:
-            if (in.swimming) {
-                state_ = effectiveMoving ? State::SWIM : State::SWIM_IDLE;
-            } else if (!in.grounded && in.jumping) {
-                jumpStartSeen_ = false;
-                state_ = State::JUMP_START;
-            } else if (!in.grounded) {
-                state_ = State::JUMP_MID;
-            } else if (!effectiveMoving) {
-                state_ = State::IDLE;
-            } else if (effectiveSprinting) {
-                state_ = State::RUN;
-            }
-            break;
-
-        case State::RUN:
-            if (in.swimming) {
-                state_ = effectiveMoving ? State::SWIM : State::SWIM_IDLE;
-            } else if (!in.grounded && in.jumping) {
-                jumpStartSeen_ = false;
-                state_ = State::JUMP_START;
-            } else if (!in.grounded) {
-                state_ = State::JUMP_MID;
-            } else if (!effectiveMoving) {
-                state_ = State::IDLE;
-            } else if (!effectiveSprinting) {
-                state_ = State::WALK;
-            }
-            break;
-
-        case State::JUMP_START:
-            if (in.swimming) {
-                state_ = State::SWIM_IDLE;
-            } else if (in.grounded) {
-                state_ = State::JUMP_END;
-                jumpEndSeen_ = false;
-            } else if (caps.resolvedJumpStart == 0) {
-                // Model doesn't have JUMP_START animation — skip to mid-air
-                state_ = State::JUMP_MID;
-            } else if (in.haveAnimState) {
-                // Use the same resolved ID that resolve() outputs
-                uint32_t expected = caps.resolvedJumpStart;
-                if (in.currentAnimId == expected) jumpStartSeen_ = true;
-                // Also detect completion via renderer's auto-STAND reset:
-                // once the animation was seen and currentAnimId changed, it completed.
-                if (jumpStartSeen_ && oneShotComplete(in, expected)) {
-                    state_ = State::JUMP_MID;
-                }
-            } else {
-                // No animation state available — fall through after 1 frame
-                state_ = State::JUMP_MID;
-            }
-            break;
-
-        case State::JUMP_MID:
-            if (in.swimming) {
-                state_ = State::SWIM_IDLE;
-            } else if (in.grounded) {
-                state_ = State::JUMP_END;
-            }
-            break;
-
-        case State::JUMP_END:
-            if (in.swimming) {
-                state_ = effectiveMoving ? State::SWIM : State::SWIM_IDLE;
-            } else if (effectiveMoving) {
-                // Movement overrides landing animation
-                state_ = effectiveSprinting ? State::RUN : State::WALK;
-            } else if (caps.resolvedJumpEnd == 0) {
-                // Model doesn't have JUMP_END animation — go straight to IDLE
-                state_ = State::IDLE;
-            } else if (in.haveAnimState) {
-                uint32_t expected = caps.resolvedJumpEnd;
-                if (in.currentAnimId == expected) jumpEndSeen_ = true;
-                // Only transition to IDLE after landing animation completes
-                if (jumpEndSeen_ && oneShotComplete(in, expected)) {
-                    state_ = State::IDLE;
-                }
-            } else {
-                state_ = State::IDLE;
-            }
-            break;
-
-        case State::SWIM_IDLE:
-            if (!in.swimming) {
-                state_ = effectiveMoving ? State::WALK : State::IDLE;
-            } else if (effectiveMoving) {
-                state_ = State::SWIM;
-            }
-            break;
-
-        case State::SWIM:
-            if (!in.swimming) {
-                state_ = effectiveMoving ? State::WALK : State::IDLE;
-            } else if (!effectiveMoving) {
-                state_ = State::SWIM_IDLE;
-            }
-            break;
-    }
-}
-
-// ── Animation resolution ─────────────────────────────────────────────────────
-
-AnimOutput LocomotionFSM::resolve(const Input& in, const AnimCapabilitySet& caps) {
-    updateTransitions(in, caps);
-
-    const bool pureStrafe = !in.movingForward && !in.movingBackward; // strafe without forward/back
-    const bool anyStrafeLeft = in.strafeLeft && !in.strafeRight && pureStrafe;
-    const bool anyStrafeRight = in.strafeRight && !in.strafeLeft && pureStrafe;
-
-    uint32_t animId = anim::STAND;
-    bool animSelected = true;
-    bool loop = true;
-
-    switch (state_) {
-        case State::IDLE:
-            animId = anim::STAND;
-            break;
-
-        case State::WALK:
-            if (in.movingBackward) {
-                animId = caps.resolvedWalkBackwards ? caps.resolvedWalkBackwards
-                       : caps.resolvedWalk           ? caps.resolvedWalk
-                       :                               anim::WALK_BACKWARDS;
-            } else if (anyStrafeLeft) {
-                animId = caps.resolvedStrafeLeft ? caps.resolvedStrafeLeft : anim::SHUFFLE_LEFT;
-            } else if (anyStrafeRight) {
-                animId = caps.resolvedStrafeRight ? caps.resolvedStrafeRight : anim::SHUFFLE_RIGHT;
-            } else {
-                animId = caps.resolvedWalk ? caps.resolvedWalk : anim::WALK;
-            }
-            break;
-
-        case State::RUN:
-            if (in.movingBackward) {
-                animId = caps.resolvedWalkBackwards ? caps.resolvedWalkBackwards
-                       : caps.resolvedWalk           ? caps.resolvedWalk
-                       :                               anim::WALK_BACKWARDS;
-            } else if (anyStrafeLeft) {
-                animId = caps.resolvedRunLeft ? caps.resolvedRunLeft
-                       : caps.resolvedRun    ? caps.resolvedRun
-                       :                       anim::RUN;
-            } else if (anyStrafeRight) {
-                animId = caps.resolvedRunRight ? caps.resolvedRunRight
-                       : caps.resolvedRun     ? caps.resolvedRun
-                       :                        anim::RUN;
-            } else if (in.sprintAura) {
-                animId = caps.resolvedSprint ? caps.resolvedSprint : anim::RUN;
-            } else {
-                animId = caps.resolvedRun ? caps.resolvedRun : anim::RUN;
-            }
-            break;
-
-        case State::JUMP_START:
-            animId = caps.resolvedJumpStart ? caps.resolvedJumpStart : anim::JUMP_START;
-            loop = false;
-            break;
-        case State::JUMP_MID:
-            animId = caps.resolvedJump ? caps.resolvedJump : anim::JUMP;
-            loop = true;  // Must loop — long falls outlast a single play cycle
-            break;
-        case State::JUMP_END:
-            animId = caps.resolvedJumpEnd ? caps.resolvedJumpEnd : anim::JUMP_END;
-            loop = false;
-            break;
-
-        case State::SWIM_IDLE:
-            animId = caps.resolvedSwimIdle ? caps.resolvedSwimIdle : anim::SWIM_IDLE;
-            break;
-
-        case State::SWIM:
-            if (in.movingBackward) {
-                animId = caps.resolvedSwimBackwards ? caps.resolvedSwimBackwards
-                       : caps.resolvedSwim           ? caps.resolvedSwim
-                       :                               anim::SWIM;
-            } else if (anyStrafeLeft) {
-                animId = caps.resolvedSwimLeft ? caps.resolvedSwimLeft
-                       : caps.resolvedSwim    ? caps.resolvedSwim
-                       :                        anim::SWIM;
-            } else if (anyStrafeRight) {
-                animId = caps.resolvedSwimRight ? caps.resolvedSwimRight
-                       : caps.resolvedSwim     ? caps.resolvedSwim
-                       :                         anim::SWIM;
-            } else {
-                animId = caps.resolvedSwim ? caps.resolvedSwim : anim::SWIM;
-            }
-            break;
-    }
-
-    if (!animSelected) return AnimOutput::stay();
-    return AnimOutput::ok(animId, loop);
-}
-
-// ── Reset ────────────────────────────────────────────────────────────────────
-
-void LocomotionFSM::reset() {
-    state_ = State::IDLE;
-    graceTimer_ = 0.0f;
-    wasSprinting_ = false;
-    jumpStartSeen_ = false;
-    jumpEndSeen_ = false;
-}
-
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/animation/mount_fsm.cpp b/src/rendering/animation/mount_fsm.cpp
deleted file mode 100644
index b34d73d0..00000000
--- a/src/rendering/animation/mount_fsm.cpp
+++ /dev/null
@@ -1,342 +0,0 @@
-#include "rendering/animation/mount_fsm.hpp"
-#include "rendering/animation/animation_ids.hpp"
-#include <algorithm>
-#include <cmath>
-
-namespace wowee {
-namespace rendering {
-
-// ── Configure / Clear ────────────────────────────────────────────────────────
-
-void MountFSM::configure(const MountAnimSet& anims, bool taxiFlight) {
-    anims_ = anims;
-    taxiFlight_ = taxiFlight;
-    active_ = true;
-    state_ = MountState::IDLE;
-    action_ = MountAction::None;
-    actionPhase_ = 0;
-    fidgetTimer_ = 0.0f;
-    activeFidget_ = 0;
-    idleSoundTimer_ = 0.0f;
-    prevYaw_ = 0.0f;
-    roll_ = 0.0f;
-    lastMountAnim_ = 0;
-
-    // Seed per-instance RNG
-    std::random_device rd;
-    rng_.seed(rd());
-    nextFidgetTime_ = std::uniform_real_distribution<float>(6.0f, 12.0f)(rng_);
-    nextIdleSoundTime_ = std::uniform_real_distribution<float>(45.0f, 90.0f)(rng_);
-}
-
-void MountFSM::clear() {
-    active_ = false;
-    state_ = MountState::IDLE;
-    action_ = MountAction::None;
-    actionPhase_ = 0;
-    taxiFlight_ = false;
-    anims_ = {};
-    fidgetTimer_ = 0.0f;
-    activeFidget_ = 0;
-    idleSoundTimer_ = 0.0f;
-    lastMountAnim_ = 0;
-}
-
-// ── Event handling ───────────────────────────────────────────────────────────
-
-void MountFSM::onEvent(AnimEvent event) {
-    if (!active_) return;
-    switch (event) {
-        case AnimEvent::JUMP:
-            // Jump only triggered via evaluate() input check
-            break;
-        case AnimEvent::DISMOUNT:
-            clear();
-            break;
-        default:
-            break;
-    }
-}
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-bool MountFSM::actionAnimComplete(const Input& in) const {
-    return in.haveMountState && in.curMountDuration > 0.1f &&
-           (in.curMountTime >= in.curMountDuration - 0.05f);
-}
-
-uint32_t MountFSM::resolveGroundOrFlyAnim(const Input& in) const {
-    const bool pureStrafe = !in.movingBackward;
-    const bool anyStrafeLeft = in.strafeLeft && !in.strafeRight && pureStrafe;
-    const bool anyStrafeRight = in.strafeRight && !in.strafeLeft && pureStrafe;
-
-    if (in.moving) {
-        if (in.flying) {
-            if (in.ascending) {
-                return anims_.flyUp ? anims_.flyUp : (anims_.flyForward ? anims_.flyForward : anim::RUN);
-            } else if (in.descending) {
-                return anims_.flyDown ? anims_.flyDown : (anims_.flyForward ? anims_.flyForward : anim::RUN);
-            } else if (anyStrafeLeft) {
-                return anims_.flyLeft ? anims_.flyLeft : (anims_.flyForward ? anims_.flyForward : anim::RUN);
-            } else if (anyStrafeRight) {
-                return anims_.flyRight ? anims_.flyRight : (anims_.flyForward ? anims_.flyForward : anim::RUN);
-            } else if (in.movingBackward) {
-                return anims_.flyBackwards ? anims_.flyBackwards : (anims_.flyForward ? anims_.flyForward : anim::RUN);
-            } else {
-                return anims_.flyForward ? anims_.flyForward : (anims_.flyIdle ? anims_.flyIdle : anim::RUN);
-            }
-        } else if (in.swimming) {
-            // Mounted swimming — simplified, no per-direction mount swim anims needed here
-            // (the original code used pickMountAnim with mount-specific swim IDs)
-            return anims_.run ? anims_.run : anim::RUN;
-        } else if (anyStrafeLeft) {
-            return anims_.run ? anims_.run : anim::RUN;
-        } else if (anyStrafeRight) {
-            return anims_.run ? anims_.run : anim::RUN;
-        } else if (in.movingBackward) {
-            return anims_.run ? anims_.run : anim::RUN;
-        } else {
-            return anim::RUN;
-        }
-    } else {
-        // Idle
-        if (in.swimming) {
-            return anims_.stand ? anims_.stand : anim::STAND;
-        } else if (in.flying) {
-            if (in.ascending) {
-                return anims_.flyUp ? anims_.flyUp : (anims_.flyIdle ? anims_.flyIdle : anim::STAND);
-            } else if (in.descending) {
-                return anims_.flyDown ? anims_.flyDown : (anims_.flyIdle ? anims_.flyIdle : anim::STAND);
-            } else {
-                return anims_.flyIdle ? anims_.flyIdle : (anims_.flyForward ? anims_.flyForward : anim::STAND);
-            }
-        } else {
-            return anims_.stand ? anims_.stand : anim::STAND;
-        }
-    }
-}
-
-// ── Main evaluation ──────────────────────────────────────────────────────────
-
-MountFSM::Output MountFSM::evaluate(const Input& in) {
-    Output out;
-    if (!active_) return out;
-
-    const float dt = in.deltaTime;
-
-    // ── Procedural lean ─────────────────────────────────────────────────
-    if (!taxiFlight_ && in.moving && dt > 0.0f) {
-        float turnRate = (in.characterYaw - prevYaw_) / dt;
-        while (turnRate > 180.0f) turnRate -= 360.0f;
-        while (turnRate < -180.0f) turnRate += 360.0f;
-        float targetLean = std::clamp(turnRate * 0.15f, -0.25f, 0.25f);
-        roll_ = roll_ + (targetLean - roll_) * (1.0f - std::exp(-6.0f * dt));
-    } else {
-        roll_ = roll_ + (0.0f - roll_) * (1.0f - std::exp(-8.0f * dt));
-    }
-    prevYaw_ = in.characterYaw;
-    out.mountRoll = roll_;
-
-    // ── Rider animation ─────────────────────────────────────────────────
-    out.riderAnimId = anim::MOUNT;
-    out.riderAnimLoop = true;
-    // (Flight rider variants handled by the caller via capability set, not here)
-
-    // ── Taxi flight branch ──────────────────────────────────────────────
-    if (taxiFlight_) {
-        // Try flight animations in preference order using discovered anims
-        uint32_t taxiAnim = anim::STAND;
-        if (anims_.flyForward) taxiAnim = anims_.flyForward;
-        else if (anims_.flyIdle) taxiAnim = anims_.flyIdle;
-        else if (anims_.run) taxiAnim = anims_.run;
-
-        out.mountAnimId = taxiAnim;
-        out.mountAnimLoop = true;
-        out.mountAnimChanged = (!in.haveMountState || in.curMountAnim != taxiAnim);
-
-        // Bob calculation for taxi
-        if (in.moving && in.haveMountState && in.curMountDuration > 1.0f) {
-            float wrappedTime = in.curMountTime;
-            while (wrappedTime >= in.curMountDuration) wrappedTime -= in.curMountDuration;
-            float norm = wrappedTime / in.curMountDuration;
-            out.mountBob = std::sin(norm * 2.0f * 3.14159f * 2.0f) * 0.12f;
-        }
-
-        lastMountAnim_ = out.mountAnimId;
-        return out;
-    }
-
-    // ── Jump/rear-up trigger ────────────────────────────────────────────
-    if (in.jumpKeyPressed && in.grounded && action_ == MountAction::None) {
-        if (in.moving && anims_.jumpLoop > 0) {
-            action_ = MountAction::Jump;
-            actionPhase_ = 1; // Start with loop directly (matching original)
-            out.mountAnimId = anims_.jumpLoop;
-            out.mountAnimLoop = true;
-            out.mountAnimChanged = true;
-            out.playJumpSound = true;
-            out.triggerMountJump = true;
-            lastMountAnim_ = out.mountAnimId;
-
-            // Bob calc
-            if (in.haveMountState && in.curMountDuration > 1.0f) {
-                float wrappedTime = in.curMountTime;
-                while (wrappedTime >= in.curMountDuration) wrappedTime -= in.curMountDuration;
-                float norm = wrappedTime / in.curMountDuration;
-                out.mountBob = std::sin(norm * 2.0f * 3.14159f) * 0.12f;
-            }
-            return out;
-        } else if (!in.moving && anims_.rearUp > 0) {
-            action_ = MountAction::RearUp;
-            actionPhase_ = 0;
-            out.mountAnimId = anims_.rearUp;
-            out.mountAnimLoop = false;
-            out.mountAnimChanged = true;
-            out.playRearUpSound = true;
-            lastMountAnim_ = out.mountAnimId;
-            return out;
-        }
-    }
-
-    // ── Handle active mount actions (jump chaining or rear-up) ──────────
-    if (action_ != MountAction::None) {
-        bool animFinished = actionAnimComplete(in);
-
-        if (action_ == MountAction::Jump) {
-            if (actionPhase_ == 0 && animFinished && anims_.jumpLoop > 0) {
-                actionPhase_ = 1;
-                out.mountAnimId = anims_.jumpLoop;
-                out.mountAnimLoop = true;
-                out.mountAnimChanged = true;
-            } else if (actionPhase_ == 0 && animFinished) {
-                actionPhase_ = 1;
-                out.mountAnimId = in.curMountAnim;
-            } else if (actionPhase_ == 1 && in.grounded && anims_.jumpEnd > 0) {
-                actionPhase_ = 2;
-                out.mountAnimId = anims_.jumpEnd;
-                out.mountAnimLoop = false;
-                out.mountAnimChanged = true;
-                out.playLandSound = true;
-            } else if (actionPhase_ == 1 && in.grounded) {
-                action_ = MountAction::None;
-                out.mountAnimId = in.moving ? anims_.run : anims_.stand;
-                out.mountAnimLoop = true;
-                out.mountAnimChanged = true;
-            } else if (actionPhase_ == 2 && animFinished) {
-                action_ = MountAction::None;
-                out.mountAnimId = in.moving ? anims_.run : anims_.stand;
-                out.mountAnimLoop = true;
-                out.mountAnimChanged = true;
-            } else {
-                out.mountAnimId = in.curMountAnim;
-            }
-        } else if (action_ == MountAction::RearUp) {
-            if (animFinished) {
-                action_ = MountAction::None;
-                out.mountAnimId = in.moving ? anims_.run : anims_.stand;
-                out.mountAnimLoop = true;
-                out.mountAnimChanged = true;
-            } else {
-                out.mountAnimId = in.curMountAnim;
-            }
-        }
-
-        // Bob calc
-        if (in.moving && in.haveMountState && in.curMountDuration > 1.0f) {
-            float wrappedTime = in.curMountTime;
-            while (wrappedTime >= in.curMountDuration) wrappedTime -= in.curMountDuration;
-            float norm = wrappedTime / in.curMountDuration;
-            out.mountBob = std::sin(norm * 2.0f * 3.14159f) * 0.12f;
-        }
-        lastMountAnim_ = out.mountAnimId;
-        return out;
-    }
-
-    // ── Normal movement animation resolution ────────────────────────────
-    uint32_t mountAnimId = resolveGroundOrFlyAnim(in);
-
-    // ── Cancel active fidget on movement ────────────────────────────────
-    if (in.moving && activeFidget_ != 0) {
-        activeFidget_ = 0;
-        out.mountAnimId = mountAnimId;
-        out.mountAnimLoop = true;
-        out.mountAnimChanged = true;
-        lastMountAnim_ = out.mountAnimId;
-
-        // Bob calc
-        if (in.haveMountState && in.curMountDuration > 1.0f) {
-            float wrappedTime = in.curMountTime;
-            while (wrappedTime >= in.curMountDuration) wrappedTime -= in.curMountDuration;
-            float norm = wrappedTime / in.curMountDuration;
-            out.mountBob = std::sin(norm * 2.0f * 3.14159f) * 0.12f;
-        }
-        return out;
-    }
-
-    // ── Check if active fidget completed ────────────────────────────────
-    if (!in.moving && activeFidget_ != 0) {
-        if (in.haveMountState) {
-            if (in.curMountAnim != activeFidget_ ||
-                in.curMountTime >= in.curMountDuration * 0.95f) {
-                activeFidget_ = 0;
-            }
-        }
-    }
-
-    // ── Idle fidgets ────────────────────────────────────────────────────
-    if (!in.moving && action_ == MountAction::None && activeFidget_ == 0 && !anims_.fidgets.empty()) {
-        fidgetTimer_ += dt;
-        if (fidgetTimer_ >= nextFidgetTime_) {
-            std::uniform_int_distribution<size_t> dist(0, anims_.fidgets.size() - 1);
-            uint32_t fidgetAnim = anims_.fidgets[dist(rng_)];
-            activeFidget_ = fidgetAnim;
-            fidgetTimer_ = 0.0f;
-            nextFidgetTime_ = std::uniform_real_distribution<float>(6.0f, 12.0f)(rng_);
-
-            out.mountAnimId = fidgetAnim;
-            out.mountAnimLoop = false;
-            out.mountAnimChanged = true;
-            out.fidgetStarted = true;
-            lastMountAnim_ = out.mountAnimId;
-            return out;
-        }
-    }
-    if (in.moving) fidgetTimer_ = 0.0f;
-
-    // ── Idle ambient sounds ─────────────────────────────────────────────
-    if (!in.moving) {
-        idleSoundTimer_ += dt;
-        if (idleSoundTimer_ >= nextIdleSoundTime_) {
-            out.playIdleSound = true;
-            idleSoundTimer_ = 0.0f;
-            nextIdleSoundTime_ = std::uniform_real_distribution<float>(45.0f, 90.0f)(rng_);
-        }
-    } else {
-        idleSoundTimer_ = 0.0f;
-    }
-
-    // ── Set output ──────────────────────────────────────────────────────
-    out.mountAnimId = activeFidget_ != 0 ? activeFidget_ : mountAnimId;
-    out.mountAnimLoop = (activeFidget_ == 0);
-    // Only trigger playAnimation if animation actually changed and no action/fidget active
-    if (action_ == MountAction::None && activeFidget_ == 0 &&
-        (!in.haveMountState || in.curMountAnim != mountAnimId)) {
-        out.mountAnimChanged = true;
-        out.mountAnimId = mountAnimId;
-    }
-
-    // Bob calculation
-    if (in.moving && in.haveMountState && in.curMountDuration > 1.0f) {
-        float wrappedTime = in.curMountTime;
-        while (wrappedTime >= in.curMountDuration) wrappedTime -= in.curMountDuration;
-        float norm = wrappedTime / in.curMountDuration;
-        float bobSpeed = taxiFlight_ ? 2.0f : 1.0f;
-        out.mountBob = std::sin(norm * 2.0f * 3.14159f * bobSpeed) * 0.12f;
-    }
-
-    lastMountAnim_ = out.mountAnimId;
-    return out;
-}
-
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/animation/sfx_state_driver.cpp b/src/rendering/animation/sfx_state_driver.cpp
deleted file mode 100644
index 5eb241d0..00000000
--- a/src/rendering/animation/sfx_state_driver.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-// ============================================================================
-// SfxStateDriver — extracted from AnimationController
-//
-// Tracks state transitions for activity SFX (jump, landing, swim) and
-// mount ambient sounds.  Moved from AnimationController::updateSfxState().
-// ============================================================================
-
-#include "rendering/animation/sfx_state_driver.hpp"
-#include "rendering/animation/footstep_driver.hpp"
-#include "rendering/renderer.hpp"
-#include "audio/audio_coordinator.hpp"
-#include "audio/activity_sound_manager.hpp"
-#include "audio/mount_sound_manager.hpp"
-#include "audio/music_manager.hpp"
-#include "rendering/camera_controller.hpp"
-
-namespace wowee {
-namespace rendering {
-
-void SfxStateDriver::update(float deltaTime, Renderer* renderer,
-                            bool mounted, bool taxiFlight,
-                            FootstepDriver& footstepDriver) {
-    auto* activitySoundManager = renderer->getAudioCoordinator()->getActivitySoundManager();
-    if (!activitySoundManager) return;
-
-    auto* cameraController = renderer->getCameraController();
-
-    activitySoundManager->update(deltaTime);
-    if (cameraController && cameraController->isThirdPerson()) {
-        bool grounded = cameraController->isGrounded();
-        bool jumping = cameraController->isJumping();
-        bool falling = cameraController->isFalling();
-        bool swimming = cameraController->isSwimming();
-        bool moving = cameraController->isMoving();
-
-        if (!initialized_) {
-            prevGrounded_ = grounded;
-            prevJumping_ = jumping;
-            prevFalling_ = falling;
-            prevSwimming_ = swimming;
-            initialized_ = true;
-        }
-
-        // Jump detection
-        if (jumping && !prevJumping_ && !swimming) {
-            activitySoundManager->playJump();
-        }
-
-        // Landing detection
-        if (grounded && !prevGrounded_) {
-            bool hardLanding = prevFalling_;
-            activitySoundManager->playLanding(
-                footstepDriver.resolveFootstepSurface(renderer), hardLanding);
-        }
-
-        // Water transitions
-        if (swimming && !prevSwimming_) {
-            activitySoundManager->playWaterEnter();
-        } else if (!swimming && prevSwimming_) {
-            activitySoundManager->playWaterExit();
-        }
-
-        activitySoundManager->setSwimmingState(swimming, moving);
-
-        if (renderer->getAudioCoordinator()->getMusicManager()) {
-            renderer->getAudioCoordinator()->getMusicManager()->setUnderwaterMode(swimming);
-        }
-
-        prevGrounded_ = grounded;
-        prevJumping_ = jumping;
-        prevFalling_ = falling;
-        prevSwimming_ = swimming;
-    } else {
-        activitySoundManager->setSwimmingState(false, false);
-        if (renderer->getAudioCoordinator()->getMusicManager()) {
-            renderer->getAudioCoordinator()->getMusicManager()->setUnderwaterMode(false);
-        }
-        initialized_ = false;
-    }
-
-    // Mount ambient sounds
-    if (renderer->getAudioCoordinator()->getMountSoundManager()) {
-        renderer->getAudioCoordinator()->getMountSoundManager()->update(deltaTime);
-        if (cameraController && mounted) {
-            bool isMoving = cameraController->isMoving();
-            bool flying = taxiFlight || !cameraController->isGrounded();
-            renderer->getAudioCoordinator()->getMountSoundManager()->setMoving(isMoving);
-            renderer->getAudioCoordinator()->getMountSoundManager()->setFlying(flying);
-        }
-    }
-}
-
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/animation_controller.cpp b/src/rendering/animation_controller.cpp
deleted file mode 100644
index c1cdb610..00000000
--- a/src/rendering/animation_controller.cpp
+++ /dev/null
@@ -1,1144 +0,0 @@
-#include "rendering/animation_controller.hpp"
-#include "rendering/animation/emote_registry.hpp"
-#include "rendering/animation/anim_capability_probe.hpp"
-#include "rendering/animation/mount_fsm.hpp"
-#include "rendering/animation/animation_ids.hpp"
-#include "rendering/renderer.hpp"
-#include "rendering/camera.hpp"
-#include "rendering/camera_controller.hpp"
-#include "rendering/character_renderer.hpp"
-#include "rendering/terrain_manager.hpp"
-#include "rendering/wmo_renderer.hpp"
-#include "rendering/water_renderer.hpp"
-#include "rendering/m2_renderer.hpp"
-#include "rendering/levelup_effect.hpp"
-#include "rendering/charge_effect.hpp"
-#include "rendering/spell_visual_system.hpp"
-#include "pipeline/m2_loader.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "game/inventory.hpp"
-#include "core/application.hpp"
-#include "core/logger.hpp"
-#include "audio/audio_coordinator.hpp"
-#include "audio/audio_engine.hpp"
-#include "audio/footstep_manager.hpp"
-#include "audio/activity_sound_manager.hpp"
-#include "audio/mount_sound_manager.hpp"
-#include "audio/music_manager.hpp"
-#include "audio/movement_sound_manager.hpp"
-#include "rendering/swim_effects.hpp"
-#include <algorithm>
-#include <cstdlib>
-#include <unordered_map>
-#include <set>
-#include <random>
-#include <cctype>
-#include <cmath>
-#include <glm/gtc/matrix_transform.hpp>
-
-namespace wowee {
-namespace rendering {
-
-// ── AnimationController implementation ───────────────────────────────────────
-
-AnimationController::AnimationController() = default;
-AnimationController::~AnimationController() = default;
-
-void AnimationController::initialize(Renderer* renderer) {
-    renderer_ = renderer;
-}
-
-void AnimationController::probeCapabilities() {
-    if (!renderer_) return;
-    uint32_t instanceId = renderer_->getCharacterInstanceId();
-    if (instanceId == 0) return;
-    auto caps = AnimCapabilityProbe::probe(renderer_, instanceId);
-    characterAnimator_.setCapabilities(caps);
-    capabilitiesProbed_ = true;
-}
-
-void AnimationController::onCharacterFollow(uint32_t /*instanceId*/) {
-    // Reset animation state when follow target changes
-    capabilitiesProbed_ = false;
-}
-
-// ── Emote support ────────────────────────────────────────────────────────────
-
-void AnimationController::playEmote(const std::string& emoteName) {
-    auto& registry = EmoteRegistry::instance();
-    registry.loadFromDbc();
-    auto result = registry.findEmote(emoteName);
-    if (!result) return;
-
-    uint32_t animId = result->animId;
-    bool loop = result->loop;
-
-    // For looping emotes, prefer the EMOTE_STATE_* variant if the model has it
-    if (loop) {
-        uint32_t stateVariant = registry.getStateVariant(animId);
-        if (stateVariant != 0) {
-            auto* characterRenderer = renderer_->getCharacterRenderer();
-            uint32_t characterInstanceId = renderer_->getCharacterInstanceId();
-            if (characterRenderer && characterInstanceId > 0 &&
-                characterRenderer->hasAnimation(characterInstanceId, stateVariant)) {
-                animId = stateVariant;
-            }
-        }
-    }
-
-    // Forward to CharacterAnimator (ActivityFSM handles emote state)
-    characterAnimator_.playEmote(animId, loop);
-
-    // Immediately play the emote animation on the renderer
-    auto* characterRenderer = renderer_->getCharacterRenderer();
-    uint32_t characterInstanceId = renderer_->getCharacterInstanceId();
-    if (characterRenderer && characterInstanceId > 0) {
-        characterRenderer->playAnimation(characterInstanceId, animId, loop);
-        lastPlayerAnimRequest_ = animId;
-        lastPlayerAnimLoopRequest_ = loop;
-    }
-}
-
-void AnimationController::cancelEmote() {
-    characterAnimator_.cancelEmote();
-}
-
-std::string AnimationController::getEmoteText(const std::string& emoteName, const std::string* targetName) {
-    auto& registry = EmoteRegistry::instance();
-    registry.loadFromDbc();
-    return registry.textFor(emoteName, targetName);
-}
-
-uint32_t AnimationController::getEmoteDbcId(const std::string& emoteName) {
-    auto& registry = EmoteRegistry::instance();
-    registry.loadFromDbc();
-    return registry.dbcIdFor(emoteName);
-}
-
-std::string AnimationController::getEmoteTextByDbcId(uint32_t dbcId, const std::string& senderName,
-                                                      const std::string* targetName) {
-    auto& registry = EmoteRegistry::instance();
-    registry.loadFromDbc();
-    return registry.textByDbcId(dbcId, senderName, targetName);
-}
-
-uint32_t AnimationController::getEmoteAnimByDbcId(uint32_t dbcId) {
-    auto& registry = EmoteRegistry::instance();
-    registry.loadFromDbc();
-    return registry.animByDbcId(dbcId);
-}
-
-// ── Spell casting ────────────────────────────────────────────────────────────
-
-void AnimationController::startSpellCast(uint32_t precastAnimId, uint32_t castAnimId, bool castLoop,
-                                         uint32_t finalizeAnimId) {
-    characterAnimator_.startSpellCast(precastAnimId, castAnimId, castLoop, finalizeAnimId);
-}
-
-void AnimationController::stopSpellCast() {
-    characterAnimator_.stopSpellCast();
-}
-
-// ── Loot animation ───────────────────────────────────────────────────────────
-
-void AnimationController::startLooting() {
-    characterAnimator_.startLooting();
-}
-
-void AnimationController::stopLooting() {
-    characterAnimator_.stopLooting();
-}
-
-// ── Hit reactions ────────────────────────────────────────────────────────────
-
-void AnimationController::triggerHitReaction(uint32_t animId) {
-    characterAnimator_.triggerHitReaction(animId);
-}
-
-// ── Crowd control ────────────────────────────────────────────────────────────
-
-void AnimationController::setStunned(bool stunned) {
-    stunned_ = stunned;
-    characterAnimator_.setStunned(stunned);
-}
-
-// ── Health-based idle ────────────────────────────────────────────────────────
-
-void AnimationController::setLowHealth(bool low) {
-    characterAnimator_.setLowHealth(low);
-}
-
-// ── Stand state ──────────────────────────────────────────────────────────────
-
-void AnimationController::setStandState(uint8_t state) {
-    characterAnimator_.setStandState(state);
-}
-
-// ── Stealth ──────────────────────────────────────────────────────────────────
-
-void AnimationController::setStealthed(bool stealth) {
-    characterAnimator_.setStealthed(stealth);
-}
-
-// ── Sprint aura ──────────────────────────────────────────────────────────────
-
-void AnimationController::setSprintAuraActive(bool active) {
-    sprintAuraActive_ = active;
-    characterAnimator_.setSprintAuraActive(active);
-}
-
-// ── Targeting / combat ───────────────────────────────────────────────────────
-
-void AnimationController::setTargetPosition(const glm::vec3* pos) {
-    targetPosition_ = pos;
-}
-
-void AnimationController::setInCombat(bool combat) {
-    inCombat_ = combat;
-    characterAnimator_.setInCombat(combat);
-}
-
-void AnimationController::resetCombatVisualState() {
-    inCombat_ = false;
-    targetPosition_ = nullptr;
-    meleeSwingTimer_ = 0.0f;
-    meleeSwingCooldown_ = 0.0f;
-    specialAttackAnimId_ = 0;
-    rangedShootTimer_ = 0.0f;
-    rangedAnimId_ = 0;
-    stunned_ = false;
-    charging_ = false;
-
-    // Reset all CharacterAnimator combat state
-    characterAnimator_.setInCombat(false);
-    characterAnimator_.setStunned(false);
-    characterAnimator_.setCharging(false);
-    characterAnimator_.setLowHealth(false);
-    characterAnimator_.stopSpellCast();
-    characterAnimator_.triggerHitReaction(0);  // Clear hit reaction
-
-    if (auto* svs = renderer_->getSpellVisualSystem()) svs->reset();
-}
-
-bool AnimationController::isMoving() const {
-    auto* cameraController = renderer_->getCameraController();
-    return cameraController && cameraController->isMoving();
-}
-
-// ── Melee combat ─────────────────────────────────────────────────────────────
-
-void AnimationController::triggerMeleeSwing() {
-    auto* characterRenderer = renderer_->getCharacterRenderer();
-    uint32_t characterInstanceId = renderer_->getCharacterInstanceId();
-    if (!characterRenderer || characterInstanceId == 0) return;
-    if (meleeSwingCooldown_ > 0.0f) return;
-    if (characterAnimator_.getActivity().isEmoteActive()) {
-        characterAnimator_.cancelEmote();
-    }
-    specialAttackAnimId_ = 0;  // Clear any special attack override
-    resolveMeleeAnimId();
-    meleeSwingCooldown_ = 0.1f;
-    float durationSec = meleeAnimDurationMs_ > 0.0f ? meleeAnimDurationMs_ / 1000.0f : 0.6f;
-    if (durationSec < 0.25f) durationSec = 0.25f;
-    if (durationSec > 1.0f) durationSec = 1.0f;
-    meleeSwingTimer_ = durationSec;
-    if (renderer_->getAudioCoordinator()->getActivitySoundManager()) {
-        renderer_->getAudioCoordinator()->getActivitySoundManager()->playMeleeSwing();
-    }
-}
-
-void AnimationController::setEquippedWeaponType(uint32_t inventoryType, bool is2HLoose,
-                                                 bool isFist, bool isDagger,
-                                                 bool hasOffHand, bool hasShield) {
-    weaponLoadout_.inventoryType = inventoryType;
-    weaponLoadout_.is2HLoose = is2HLoose;
-    weaponLoadout_.isFist = isFist;
-    weaponLoadout_.isDagger = isDagger;
-    weaponLoadout_.hasOffHand = hasOffHand;
-    weaponLoadout_.hasShield = hasShield;
-    meleeAnimId_ = 0;  // Force re-resolve on next swing
-    characterAnimator_.setEquippedWeaponType(weaponLoadout_);
-}
-
-void AnimationController::triggerSpecialAttack(uint32_t /*spellId*/) {
-    auto* characterRenderer = renderer_->getCharacterRenderer();
-    uint32_t characterInstanceId = renderer_->getCharacterInstanceId();
-    if (!characterRenderer || characterInstanceId == 0) return;
-    if (meleeSwingCooldown_ > 0.0f) return;
-    if (characterAnimator_.getActivity().isEmoteActive()) {
-        characterAnimator_.cancelEmote();
-    }
-
-    auto has = [&](uint32_t id) { return characterRenderer->hasAnimation(characterInstanceId, id); };
-
-    // Choose special attack animation based on equipped weapon type
-    uint32_t specAnim = 0;
-    if (weaponLoadout_.hasShield && has(anim::SHIELD_BASH)) {
-        specAnim = anim::SHIELD_BASH;
-    } else if ((weaponLoadout_.inventoryType == game::InvType::TWO_HAND || weaponLoadout_.is2HLoose) && has(anim::SPECIAL_2H)) {
-        specAnim = anim::SPECIAL_2H;
-    } else if (weaponLoadout_.inventoryType != game::InvType::NON_EQUIP && has(anim::SPECIAL_1H)) {
-        specAnim = anim::SPECIAL_1H;
-    } else if (has(anim::SPECIAL_UNARMED)) {
-        specAnim = anim::SPECIAL_UNARMED;
-    } else if (has(anim::SPECIAL_1H)) {
-        specAnim = anim::SPECIAL_1H;
-    }
-
-    if (specAnim == 0) {
-        // No special animation available — fall back to regular melee swing
-        triggerMeleeSwing();
-        return;
-    }
-
-    specialAttackAnimId_ = specAnim;
-    meleeSwingCooldown_ = 0.1f;
-    // Query the special attack animation duration
-    std::vector<pipeline::M2Sequence> sequences;
-    float dur = 0.6f;
-    if (characterRenderer->getAnimationSequences(characterInstanceId, sequences)) {
-        for (const auto& seq : sequences) {
-            if (seq.id == specAnim && seq.duration > 0) {
-                dur = static_cast<float>(seq.duration) / 1000.0f;
-                break;
-            }
-        }
-    }
-    if (dur < 0.25f) dur = 0.25f;
-    if (dur > 1.0f) dur = 1.0f;
-    meleeSwingTimer_ = dur;
-    if (renderer_->getAudioCoordinator()->getActivitySoundManager()) {
-        renderer_->getAudioCoordinator()->getActivitySoundManager()->playMeleeSwing();
-    }
-}
-
-// ── Ranged combat ────────────────────────────────────────────────────────────
-
-void AnimationController::setEquippedRangedType(RangedWeaponType type) {
-    weaponLoadout_.rangedType = type;
-    rangedAnimId_ = 0;
-    characterAnimator_.setEquippedRangedType(type);
-}
-
-void AnimationController::setCharging(bool c) {
-    charging_ = c;
-    characterAnimator_.setCharging(c);
-}
-
-void AnimationController::triggerRangedShot() {
-    auto* characterRenderer = renderer_->getCharacterRenderer();
-    uint32_t characterInstanceId = renderer_->getCharacterInstanceId();
-    if (!characterRenderer || characterInstanceId == 0) return;
-    if (rangedShootTimer_ > 0.0f) return;
-    if (characterAnimator_.getActivity().isEmoteActive()) characterAnimator_.cancelEmote();
-
-    auto has = [&](uint32_t id) { return characterRenderer->hasAnimation(characterInstanceId, id); };
-
-    // Resolve ranged attack animation based on weapon type
-    uint32_t shootAnim = 0;
-    switch (weaponLoadout_.rangedType) {
-        case RangedWeaponType::BOW:
-            if (has(anim::FIRE_BOW))        shootAnim = anim::FIRE_BOW;
-            else if (has(anim::ATTACK_BOW)) shootAnim = anim::ATTACK_BOW;
-            break;
-        case RangedWeaponType::GUN:
-            if (has(anim::ATTACK_RIFLE))    shootAnim = anim::ATTACK_RIFLE;
-            break;
-        case RangedWeaponType::CROSSBOW:
-            if (has(anim::ATTACK_CROSSBOW)) shootAnim = anim::ATTACK_CROSSBOW;
-            else if (has(anim::ATTACK_BOW)) shootAnim = anim::ATTACK_BOW;
-            break;
-        case RangedWeaponType::THROWN:
-            if (has(anim::ATTACK_THROWN))    shootAnim = anim::ATTACK_THROWN;
-            break;
-        default: break;
-    }
-    if (shootAnim == 0) return;  // Model has no ranged animation
-
-    rangedAnimId_ = shootAnim;
-
-    // Query animation duration
-    std::vector<pipeline::M2Sequence> sequences;
-    float dur = 0.6f;
-    if (characterRenderer->getAnimationSequences(characterInstanceId, sequences)) {
-        for (const auto& seq : sequences) {
-            if (seq.id == shootAnim && seq.duration > 0) {
-                dur = static_cast<float>(seq.duration) / 1000.0f;
-                break;
-            }
-        }
-    }
-    if (dur < 0.25f) dur = 0.25f;
-    if (dur > 1.5f) dur = 1.5f;
-    rangedShootTimer_ = dur;
-}
-
-uint32_t AnimationController::resolveMeleeAnimId() {
-    auto* characterRenderer = renderer_->getCharacterRenderer();
-    uint32_t characterInstanceId = renderer_->getCharacterInstanceId();
-    if (!characterRenderer || characterInstanceId == 0) {
-        meleeAnimId_ = 0;
-        meleeAnimDurationMs_ = 0.0f;
-        return 0;
-    }
-
-    // When dual-wielding, bypass cache to alternate main/off-hand animations
-    if (!weaponLoadout_.hasOffHand && meleeAnimId_ != 0 && characterRenderer->hasAnimation(characterInstanceId, meleeAnimId_)) {
-        return meleeAnimId_;
-    }
-
-    std::vector<pipeline::M2Sequence> sequences;
-    if (!characterRenderer->getAnimationSequences(characterInstanceId, sequences)) {
-        meleeAnimId_ = 0;
-        meleeAnimDurationMs_ = 0.0f;
-        return 0;
-    }
-
-    auto findDuration = [&](uint32_t id) -> float {
-        for (const auto& seq : sequences) {
-            if (seq.id == id && seq.duration > 0) {
-                return static_cast<float>(seq.duration);
-            }
-        }
-        return 0.0f;
-    };
-
-    const uint32_t* attackCandidates;
-    size_t candidateCount;
-    static const uint32_t candidates2H[] = {anim::ATTACK_2H, anim::ATTACK_1H, anim::ATTACK_UNARMED, anim::ATTACK_2H_LOOSE, anim::PARRY_UNARMED, anim::PARRY_1H};
-    static const uint32_t candidates2HLoosePierce[] = {anim::ATTACK_2H_LOOSE_PIERCE, anim::ATTACK_2H_LOOSE, anim::ATTACK_2H, anim::ATTACK_1H, anim::ATTACK_UNARMED};
-    static const uint32_t candidates1H[] = {anim::ATTACK_1H, anim::ATTACK_2H, anim::ATTACK_UNARMED, anim::ATTACK_2H_LOOSE, anim::PARRY_UNARMED, anim::PARRY_1H};
-    static const uint32_t candidatesDagger[] = {anim::ATTACK_1H_PIERCE, anim::ATTACK_1H, anim::ATTACK_UNARMED};
-    static const uint32_t candidatesUnarmed[] = {anim::ATTACK_UNARMED, anim::ATTACK_1H, anim::ATTACK_2H, anim::ATTACK_2H_LOOSE, anim::PARRY_UNARMED, anim::PARRY_1H};
-    static const uint32_t candidatesFist[] = {anim::ATTACK_FIST_1H, anim::ATTACK_FIST_1H_OFF, anim::ATTACK_1H, anim::ATTACK_UNARMED, anim::PARRY_FIST_1H, anim::PARRY_1H};
-    // Off-hand attack variants (used when dual-wielding on off-hand turn)
-    static const uint32_t candidatesOffHand[] = {anim::ATTACK_OFF, anim::ATTACK_1H, anim::ATTACK_UNARMED};
-    static const uint32_t candidatesOffHandPierce[] = {anim::ATTACK_OFF_PIERCE, anim::ATTACK_OFF, anim::ATTACK_1H_PIERCE, anim::ATTACK_1H};
-    static const uint32_t candidatesOffHandFist[] = {anim::ATTACK_FIST_1H_OFF, anim::ATTACK_OFF, anim::ATTACK_FIST_1H, anim::ATTACK_1H};
-    static const uint32_t candidatesOffHandUnarmed[] = {anim::ATTACK_UNARMED_OFF, anim::ATTACK_UNARMED, anim::ATTACK_OFF, anim::ATTACK_1H};
-
-    // Dual-wield: alternate main-hand and off-hand swings
-    bool useOffHand = weaponLoadout_.hasOffHand && meleeOffHandTurn_;
-    meleeOffHandTurn_ = weaponLoadout_.hasOffHand ? !meleeOffHandTurn_ : false;
-
-    if (useOffHand) {
-        if (weaponLoadout_.isFist) {
-            attackCandidates = candidatesOffHandFist;
-            candidateCount = 4;
-        } else if (weaponLoadout_.isDagger) {
-            attackCandidates = candidatesOffHandPierce;
-            candidateCount = 4;
-        } else if (weaponLoadout_.inventoryType == game::InvType::NON_EQUIP) {
-            attackCandidates = candidatesOffHandUnarmed;
-            candidateCount = 4;
-        } else {
-            attackCandidates = candidatesOffHand;
-            candidateCount = 3;
-        }
-    } else if (weaponLoadout_.isFist) {
-        attackCandidates = candidatesFist;
-        candidateCount = 6;
-    } else if (weaponLoadout_.isDagger) {
-        attackCandidates = candidatesDagger;
-        candidateCount = 3;
-    } else if (weaponLoadout_.is2HLoose) {
-        // Polearm thrust uses pierce variant
-        attackCandidates = candidates2HLoosePierce;
-        candidateCount = 5;
-    } else if (weaponLoadout_.inventoryType == game::InvType::TWO_HAND) {
-        attackCandidates = candidates2H;
-        candidateCount = 6;
-    } else if (weaponLoadout_.inventoryType == game::InvType::NON_EQUIP) {
-        attackCandidates = candidatesUnarmed;
-        candidateCount = 6;
-    } else {
-        attackCandidates = candidates1H;
-        candidateCount = 6;
-    }
-    for (size_t ci = 0; ci < candidateCount; ci++) {
-        uint32_t id = attackCandidates[ci];
-        if (characterRenderer->hasAnimation(characterInstanceId, id)) {
-            meleeAnimId_ = id;
-            meleeAnimDurationMs_ = findDuration(id);
-            return meleeAnimId_;
-        }
-    }
-
-    const uint32_t avoidIds[] = {anim::STAND, anim::DEATH, anim::WALK, anim::RUN, anim::SHUFFLE_LEFT, anim::SHUFFLE_RIGHT, anim::WALK_BACKWARDS, anim::JUMP_START, anim::JUMP, anim::JUMP_END, anim::SWIM_IDLE, anim::SWIM, anim::SITTING};
-    auto isAvoid = [&](uint32_t id) -> bool {
-        for (uint32_t avoid : avoidIds) {
-            if (id == avoid) return true;
-        }
-        return false;
-    };
-
-    uint32_t bestId = 0;
-    uint32_t bestDuration = 0;
-    for (const auto& seq : sequences) {
-        if (seq.duration == 0) continue;
-        if (isAvoid(seq.id)) continue;
-        if (seq.movingSpeed > 0.1f) continue;
-        if (seq.duration < 150 || seq.duration > 2000) continue;
-        if (bestId == 0 || seq.duration < bestDuration) {
-            bestId = seq.id;
-            bestDuration = seq.duration;
-        }
-    }
-
-    if (bestId == 0) {
-        for (const auto& seq : sequences) {
-            if (seq.duration == 0) continue;
-            if (isAvoid(seq.id)) continue;
-            if (bestId == 0 || seq.duration < bestDuration) {
-                bestId = seq.id;
-                bestDuration = seq.duration;
-            }
-        }
-    }
-
-    meleeAnimId_ = bestId;
-    meleeAnimDurationMs_ = static_cast<float>(bestDuration);
-    return meleeAnimId_;
-}
-
-// ── Effect triggers ──────────────────────────────────────────────────────────
-
-void AnimationController::triggerLevelUpEffect(const glm::vec3& position) {
-    auto* levelUpEffect = renderer_->getLevelUpEffect();
-    if (!levelUpEffect) return;
-
-    if (!levelUpEffect->isModelLoaded()) {
-        auto* m2Renderer = renderer_->getM2Renderer();
-        if (m2Renderer) {
-            auto* assetManager = core::Application::getInstance().getAssetManager();
-            if (!assetManager) {
-                LOG_WARNING("LevelUpEffect: no asset manager available");
-            } else {
-                auto m2Data = assetManager->readFile("Spells\\LevelUp\\LevelUp.m2");
-                auto skinData = assetManager->readFile("Spells\\LevelUp\\LevelUp00.skin");
-                LOG_INFO("LevelUpEffect: m2Data=", m2Data.size(), " skinData=", skinData.size());
-                if (!m2Data.empty()) {
-                    levelUpEffect->loadModel(m2Renderer, m2Data, skinData);
-                } else {
-                    LOG_WARNING("LevelUpEffect: failed to read Spell\\LevelUp\\LevelUp.m2");
-                }
-            }
-        }
-    }
-
-    levelUpEffect->trigger(position);
-}
-
-void AnimationController::startChargeEffect(const glm::vec3& position, const glm::vec3& direction) {
-    auto* chargeEffect = renderer_->getChargeEffect();
-    if (!chargeEffect) return;
-
-    if (!chargeEffect->isActive()) {
-        auto* m2Renderer = renderer_->getM2Renderer();
-        if (m2Renderer) {
-            auto* assetManager = core::Application::getInstance().getAssetManager();
-            if (assetManager) {
-                chargeEffect->tryLoadM2Models(m2Renderer, assetManager);
-            }
-        }
-    }
-
-    chargeEffect->start(position, direction);
-}
-
-void AnimationController::emitChargeEffect(const glm::vec3& position, const glm::vec3& direction) {
-    if (auto* chargeEffect = renderer_->getChargeEffect()) {
-        chargeEffect->emit(position, direction);
-    }
-}
-
-void AnimationController::stopChargeEffect() {
-    if (auto* chargeEffect = renderer_->getChargeEffect()) {
-        chargeEffect->stop();
-    }
-}
-
-// ── Mount ────────────────────────────────────────────────────────────────────
-
-void AnimationController::setMounted(uint32_t mountInstId, uint32_t mountDisplayId, float heightOffset, const std::string& modelPath) {
-    auto* characterRenderer = renderer_->getCharacterRenderer();
-    auto* cameraController = renderer_->getCameraController();
-
-    mountInstanceId_ = mountInstId;
-    mountHeightOffset_ = heightOffset;
-    mountSeatAttachmentId_ = -1;
-    smoothedMountSeatPos_ = renderer_->getCharacterPosition();
-    mountSeatSmoothingInit_ = false;
-    mountPitch_ = 0.0f;
-
-    if (cameraController) {
-        cameraController->setMounted(true);
-        cameraController->setMountHeightOffset(heightOffset);
-    }
-
-    if (characterRenderer && mountInstId > 0) {
-        characterRenderer->dumpAnimations(mountInstId);
-    }
-
-    // Discover mount animation capabilities (property-based, not hardcoded IDs)
-    LOG_DEBUG("=== Mount Animation Dump (Display ID ", mountDisplayId, ") ===");
-    if (characterRenderer) characterRenderer->dumpAnimations(mountInstId);
-
-    std::vector<pipeline::M2Sequence> sequences;
-    if (!characterRenderer || !characterRenderer->getAnimationSequences(mountInstId, sequences)) {
-        LOG_WARNING("Failed to get animation sequences for mount, using fallback IDs");
-        sequences.clear();
-    }
-
-    auto findFirst = [&](std::initializer_list<uint32_t> candidates) -> uint32_t {
-        for (uint32_t id : candidates) {
-            if (characterRenderer && characterRenderer->hasAnimation(mountInstId, id)) {
-                return id;
-            }
-        }
-        return 0;
-    };
-
-    // Property-based jump animation discovery with chain-based scoring
-    auto discoverJumpSet = [&]() {
-        LOG_DEBUG("=== Full sequence table for mount ===");
-        for (const auto& seq : sequences) {
-            LOG_DEBUG("SEQ id=", seq.id,
-                     " dur=", seq.duration,
-                     " flags=0x", std::hex, seq.flags, std::dec,
-                     " moveSpd=", seq.movingSpeed,
-                     " blend=", seq.blendTime,
-                     " next=", seq.nextAnimation,
-                     " alias=", seq.aliasNext);
-        }
-        LOG_DEBUG("=== End sequence table ===");
-
-        std::set<uint32_t> forbiddenIds = {53, 54, 16};
-
-        auto scoreNear = [](int a, int b) -> int {
-            int d = std::abs(a - b);
-            return (d <= 8) ? (20 - d) : 0;
-        };
-
-        auto isForbidden = [&](uint32_t id) {
-            return forbiddenIds.count(id) != 0;
-        };
-
-        auto findSeqById = [&](uint32_t id) -> const pipeline::M2Sequence* {
-            for (const auto& s : sequences) {
-                if (s.id == id) return &s;
-            }
-            return nullptr;
-        };
-
-        uint32_t runId = findFirst({anim::RUN, anim::WALK});
-        uint32_t standId = findFirst({anim::STAND});
-
-        std::vector<uint32_t> loops;
-        for (const auto& seq : sequences) {
-            if (isForbidden(seq.id)) continue;
-            bool isLoop = (seq.flags & 0x01) == 0;
-            if (isLoop && seq.duration >= 350 && seq.duration <= 1000 &&
-                seq.id != runId && seq.id != standId) {
-                loops.push_back(seq.id);
-            }
-        }
-
-        uint32_t loop = 0;
-        if (!loops.empty()) {
-            uint32_t best = loops[0];
-            int bestScore = -999;
-            for (uint32_t id : loops) {
-                int sc = 0;
-                sc += scoreNear(static_cast<int>(id), 38);
-                const auto* s = findSeqById(id);
-                if (s) sc += (s->duration >= 500 && s->duration <= 800) ? 5 : 0;
-                if (sc > bestScore) {
-                    bestScore = sc;
-                    best = id;
-                }
-            }
-            loop = best;
-        }
-
-        uint32_t start = 0, end = 0;
-        int bestStart = -999, bestEnd = -999;
-
-        for (const auto& seq : sequences) {
-            if (isForbidden(seq.id)) continue;
-            bool isLoop = (seq.flags & 0x01) == 0;
-            if (isLoop) continue;
-
-            if (seq.duration >= 450 && seq.duration <= 1100) {
-                int sc = 0;
-                if (loop) sc += scoreNear(static_cast<int>(seq.id), static_cast<int>(loop));
-                if (loop && (seq.nextAnimation == static_cast<int16_t>(loop) || seq.aliasNext == loop)) sc += 30;
-                if (loop && scoreNear(seq.nextAnimation, static_cast<int>(loop)) > 0) sc += 10;
-                if (seq.blendTime > 400) sc -= 5;
-
-                if (sc > bestStart) {
-                    bestStart = sc;
-                    start = seq.id;
-                }
-            }
-
-            if (seq.duration >= 650 && seq.duration <= 1600) {
-                int sc = 0;
-                if (loop) sc += scoreNear(static_cast<int>(seq.id), static_cast<int>(loop));
-                if (seq.nextAnimation == static_cast<int16_t>(runId) || seq.nextAnimation == static_cast<int16_t>(standId)) sc += 10;
-                if (seq.nextAnimation < 0) sc += 5;
-                if (sc > bestEnd) {
-                    bestEnd = sc;
-                    end = seq.id;
-                }
-            }
-        }
-
-        LOG_DEBUG("Property-based jump discovery: start=", start, " loop=", loop, " end=", end,
-                 " scores: start=", bestStart, " end=", bestEnd);
-        return std::make_tuple(start, loop, end);
-    };
-
-    auto [discoveredStart, discoveredLoop, discoveredEnd] = discoverJumpSet();
-
-    // Build MountAnimSet for MountFSM
-    MountFSM::MountAnimSet mountAnims;
-    mountAnims.jumpStart = discoveredStart > 0 ? discoveredStart : findFirst({anim::FALL, anim::JUMP_START});
-    mountAnims.jumpLoop  = discoveredLoop > 0 ? discoveredLoop : findFirst({anim::JUMP});
-    mountAnims.jumpEnd   = discoveredEnd > 0 ? discoveredEnd : findFirst({anim::JUMP_END});
-    mountAnims.rearUp    = findFirst({anim::MOUNT_SPECIAL, anim::RUN_RIGHT, anim::FALL});
-    mountAnims.run       = findFirst({anim::RUN, anim::WALK});
-    mountAnims.stand     = findFirst({anim::STAND});
-    // Discover flight animations (flying mounts only — may all be 0 for ground mounts)
-    mountAnims.flyIdle      = findFirst({anim::FLY_IDLE});
-    mountAnims.flyForward   = findFirst({anim::FLY_FORWARD, anim::FLY_RUN_2});
-    mountAnims.flyBackwards = findFirst({anim::FLY_BACKWARDS, anim::FLY_WALK_BACKWARDS});
-    mountAnims.flyLeft      = findFirst({anim::FLY_LEFT, anim::FLY_SHUFFLE_LEFT});
-    mountAnims.flyRight     = findFirst({anim::FLY_RIGHT, anim::FLY_SHUFFLE_RIGHT});
-    mountAnims.flyUp        = findFirst({anim::FLY_UP, anim::FLY_RISE});
-    mountAnims.flyDown      = findFirst({anim::FLY_DOWN});
-
-    // Discover idle fidget animations using proper WoW M2 metadata
-    core::Logger::getInstance().debug("Scanning for fidget animations in ", sequences.size(), " sequences");
-
-    core::Logger::getInstance().debug("=== ALL potential fidgets (no metadata filter) ===");
-    for (const auto& seq : sequences) {
-        bool isLoop = (seq.flags & 0x01) == 0;
-        bool isStationary = std::abs(seq.movingSpeed) < 0.05f;
-        bool reasonableDuration = seq.duration >= 400 && seq.duration <= 2500;
-
-        if (!isLoop && reasonableDuration && isStationary) {
-            core::Logger::getInstance().debug("  ALL: id=", seq.id,
-                " dur=", seq.duration, "ms",
-                " freq=", seq.frequency,
-                " replay=", seq.replayMin, "-", seq.replayMax,
-                " flags=0x", std::hex, seq.flags, std::dec,
-                " next=", seq.nextAnimation);
-        }
-    }
-
-    for (const auto& seq : sequences) {
-        bool isLoop = (seq.flags & 0x01) == 0;
-        bool hasFrequency = seq.frequency > 0;
-        bool hasReplay = seq.replayMax > 0;
-        bool isStationary = std::abs(seq.movingSpeed) < 0.05f;
-        bool reasonableDuration = seq.duration >= 400 && seq.duration <= 2500;
-
-        if (!isLoop && reasonableDuration && isStationary && (hasFrequency || hasReplay)) {
-            core::Logger::getInstance().debug("  Candidate: id=", seq.id,
-                " dur=", seq.duration, "ms",
-                " freq=", seq.frequency,
-                " replay=", seq.replayMin, "-", seq.replayMax,
-                " next=", seq.nextAnimation,
-                " speed=", seq.movingSpeed);
-        }
-
-        bool isDeathOrWound = (seq.id >= 5 && seq.id <= 9);
-        bool isAttackOrCombat = (seq.id >= 11 && seq.id <= 21);
-        bool isSpecial = (seq.id == 2 || seq.id == 3);
-
-        if (!isLoop && (hasFrequency || hasReplay) && isStationary && reasonableDuration &&
-            !isDeathOrWound && !isAttackOrCombat && !isSpecial) {
-            bool chainsToStand = (seq.nextAnimation == static_cast<int16_t>(mountAnims.stand)) ||
-                                 (seq.aliasNext == mountAnims.stand) ||
-                                 (seq.nextAnimation == -1);
-
-            mountAnims.fidgets.push_back(seq.id);
-            core::Logger::getInstance().debug("  >> Selected fidget: id=", seq.id,
-                (chainsToStand ? " (chains to stand)" : ""));
-        }
-    }
-
-    if (mountAnims.run == 0) mountAnims.run = mountAnims.stand;
-
-    core::Logger::getInstance().debug("Mount animation set: jumpStart=", mountAnims.jumpStart,
-        " jumpLoop=", mountAnims.jumpLoop,
-        " jumpEnd=", mountAnims.jumpEnd,
-        " rearUp=", mountAnims.rearUp,
-        " run=", mountAnims.run,
-        " stand=", mountAnims.stand,
-        " fidgets=", mountAnims.fidgets.size());
-
-    // Configure MountFSM via CharacterAnimator
-    characterAnimator_.configureMountFSM(mountAnims, taxiFlight_);
-
-    if (renderer_->getAudioCoordinator()->getMountSoundManager()) {
-        bool isFlying = taxiFlight_;
-        renderer_->getAudioCoordinator()->getMountSoundManager()->onMount(mountDisplayId, isFlying, modelPath);
-    }
-}
-
-void AnimationController::clearMount() {
-    mountInstanceId_ = 0;
-    mountHeightOffset_ = 0.0f;
-    mountPitch_ = 0.0f;
-    mountRoll_ = 0.0f;
-    mountSeatAttachmentId_ = -1;
-    smoothedMountSeatPos_ = glm::vec3(0.0f);
-    mountSeatSmoothingInit_ = false;
-
-    // Clear MountFSM via CharacterAnimator
-    characterAnimator_.clearMountFSM();
-
-    if (auto* cameraController = renderer_->getCameraController()) {
-        cameraController->setMounted(false);
-        cameraController->setMountHeightOffset(0.0f);
-    }
-
-    if (renderer_->getAudioCoordinator()->getMountSoundManager()) {
-        renderer_->getAudioCoordinator()->getMountSoundManager()->onDismount();
-    }
-}
-
-// ── Query helpers ────────────────────────────────────────────────────────────
-
-bool AnimationController::isFootstepAnimationState() const {
-    auto state = characterAnimator_.getLocomotion().getState();
-    return state == LocomotionFSM::State::WALK || state == LocomotionFSM::State::RUN;
-}
-
-// ── Melee timers ─────────────────────────────────────────────────────────────
-
-void AnimationController::updateMeleeTimers(float deltaTime) {
-    if (meleeSwingCooldown_ > 0.0f) {
-        meleeSwingCooldown_ = std::max(0.0f, meleeSwingCooldown_ - deltaTime);
-    }
-    if (meleeSwingTimer_ > 0.0f) {
-        meleeSwingTimer_ = std::max(0.0f, meleeSwingTimer_ - deltaTime);
-        if (meleeSwingTimer_ <= 0.0f) specialAttackAnimId_ = 0;
-    }
-    // Ranged shot timer (same pattern as melee)
-    if (rangedShootTimer_ > 0.0f) {
-        rangedShootTimer_ = std::max(0.0f, rangedShootTimer_ - deltaTime);
-    }
-}
-
-// ── Mount positioning helper ─────────────────────────────────────────────────
-
-void AnimationController::applyMountPositioning(float mountBob, float mountRoll, float characterYaw) {
-    auto* characterRenderer = renderer_->getCharacterRenderer();
-    uint32_t characterInstanceId = renderer_->getCharacterInstanceId();
-    if (!characterRenderer || characterInstanceId == 0) return;
-
-    float mountYawRad = glm::radians(characterYaw);
-
-    // Position mount model
-    if (mountInstanceId_ > 0) {
-        const glm::vec3& characterPosition = renderer_->getCharacterPosition();
-        characterRenderer->setInstancePosition(mountInstanceId_, characterPosition);
-        characterRenderer->setInstanceRotation(mountInstanceId_, glm::vec3(mountPitch_, mountRoll, mountYawRad));
-    }
-
-    // Use mount's attachment point for proper bone-driven rider positioning.
-    if (taxiFlight_) {
-        glm::mat4 mountSeatTransform(1.0f);
-        bool haveSeat = false;
-        static constexpr uint32_t kTaxiSeatAttachmentId = 0;
-        if (mountSeatAttachmentId_ == -1) {
-            mountSeatAttachmentId_ = static_cast<int>(kTaxiSeatAttachmentId);
-        }
-        if (mountSeatAttachmentId_ >= 0) {
-            haveSeat = characterRenderer->getAttachmentTransform(
-                mountInstanceId_, static_cast<uint32_t>(mountSeatAttachmentId_), mountSeatTransform);
-        }
-        if (!haveSeat) {
-            mountSeatAttachmentId_ = -2;
-        }
-
-        if (haveSeat) {
-            glm::vec3 targetRiderPos = glm::vec3(mountSeatTransform[3]) + glm::vec3(0.0f, 0.0f, 0.02f);
-            mountSeatSmoothingInit_ = false;
-            smoothedMountSeatPos_ = targetRiderPos;
-            characterRenderer->setInstancePosition(characterInstanceId, targetRiderPos);
-        } else {
-            mountSeatSmoothingInit_ = false;
-            const glm::vec3& characterPosition = renderer_->getCharacterPosition();
-            glm::vec3 playerPos = characterPosition + glm::vec3(0.0f, 0.0f, mountHeightOffset_ + 0.10f);
-            characterRenderer->setInstancePosition(characterInstanceId, playerPos);
-        }
-
-        float riderPitch = mountPitch_ * 0.35f;
-        float riderRoll = mountRoll * 0.35f;
-        characterRenderer->setInstanceRotation(characterInstanceId, glm::vec3(riderPitch, riderRoll, mountYawRad));
-        return;
-    }
-
-    // Ground mounts: try a seat attachment first.
-    const glm::vec3& characterPosition = renderer_->getCharacterPosition();
-    bool moving = renderer_->getCameraController() && renderer_->getCameraController()->isMoving();
-
-    glm::mat4 mountSeatTransform;
-    bool haveSeat = false;
-    if (mountSeatAttachmentId_ >= 0) {
-        haveSeat = characterRenderer->getAttachmentTransform(
-            mountInstanceId_, static_cast<uint32_t>(mountSeatAttachmentId_), mountSeatTransform);
-    } else if (mountSeatAttachmentId_ == -1) {
-        static constexpr uint32_t kSeatAttachments[] = {0, 5, 6, 7, 8};
-        for (uint32_t attId : kSeatAttachments) {
-            if (characterRenderer->getAttachmentTransform(mountInstanceId_, attId, mountSeatTransform)) {
-                mountSeatAttachmentId_ = static_cast<int>(attId);
-                haveSeat = true;
-                break;
-            }
-        }
-        if (!haveSeat) {
-            mountSeatAttachmentId_ = -2;
-        }
-    }
-
-    if (haveSeat) {
-        glm::vec3 mountSeatPos = glm::vec3(mountSeatTransform[3]);
-        glm::vec3 seatOffset = glm::vec3(0.0f, 0.0f, taxiFlight_ ? 0.04f : 0.08f);
-        glm::vec3 targetRiderPos = mountSeatPos + seatOffset;
-        if (moving) {
-            mountSeatSmoothingInit_ = false;
-            smoothedMountSeatPos_ = targetRiderPos;
-        } else if (!mountSeatSmoothingInit_) {
-            smoothedMountSeatPos_ = targetRiderPos;
-            mountSeatSmoothingInit_ = true;
-        } else {
-            float smoothHz = taxiFlight_ ? 10.0f : 14.0f;
-            float alpha = 1.0f - std::exp(-smoothHz * std::max(lastDeltaTime_, 0.001f));
-            smoothedMountSeatPos_ = glm::mix(smoothedMountSeatPos_, targetRiderPos, alpha);
-        }
-
-        characterRenderer->setInstancePosition(characterInstanceId, smoothedMountSeatPos_);
-
-        float yawRad = glm::radians(characterYaw);
-        float riderPitch = mountPitch_ * 0.35f;
-        float riderRoll = mountRoll * 0.35f;
-        characterRenderer->setInstanceRotation(characterInstanceId, glm::vec3(riderPitch, riderRoll, yawRad));
-    } else {
-        mountSeatSmoothingInit_ = false;
-        float yawRad = glm::radians(characterYaw);
-        glm::mat4 mountRotation = glm::mat4(1.0f);
-        mountRotation = glm::rotate(mountRotation, yawRad, glm::vec3(0.0f, 0.0f, 1.0f));
-        mountRotation = glm::rotate(mountRotation, mountRoll, glm::vec3(1.0f, 0.0f, 0.0f));
-        mountRotation = glm::rotate(mountRotation, mountPitch_, glm::vec3(0.0f, 1.0f, 0.0f));
-        glm::vec3 localOffset(0.0f, 0.0f, mountHeightOffset_ + mountBob);
-        glm::vec3 worldOffset = glm::vec3(mountRotation * glm::vec4(localOffset, 0.0f));
-        glm::vec3 playerPos = characterPosition + worldOffset;
-        characterRenderer->setInstancePosition(characterInstanceId, playerPos);
-        characterRenderer->setInstanceRotation(characterInstanceId, glm::vec3(mountPitch_, mountRoll, yawRad));
-    }
-}
-
-// ── Mounted animation update (uses MountFSM) ────────────────────────────────
-
-void AnimationController::updateMountedAnimation(float deltaTime) {
-    auto* characterRenderer = renderer_->getCharacterRenderer();
-    auto* cameraController = renderer_->getCameraController();
-    uint32_t characterInstanceId = renderer_->getCharacterInstanceId();
-    float characterYaw = renderer_->getCharacterYaw();
-    auto& mountFSM = characterAnimator_.getMountFSM();
-
-    // Build MountFSM input
-    MountFSM::Input mountIn;
-    mountIn.moving = cameraController->isMoving();
-    mountIn.movingBackward = cameraController->isMovingBackward();
-    mountIn.strafeLeft = cameraController->isStrafingLeft();
-    mountIn.strafeRight = cameraController->isStrafingRight();
-    mountIn.grounded = cameraController->isGrounded();
-    mountIn.jumpKeyPressed = cameraController->isJumpKeyPressed();
-    mountIn.flying = cameraController->isFlyingActive();
-    mountIn.swimming = cameraController->isSwimming();
-    mountIn.ascending = cameraController->isAscending();
-    mountIn.descending = cameraController->isDescending();
-    mountIn.taxiFlight = taxiFlight_;
-    mountIn.deltaTime = deltaTime;
-    mountIn.characterYaw = characterYaw;
-    // Mount animation state query
-    if (mountInstanceId_ > 0 && characterRenderer) {
-        mountIn.haveMountState = characterRenderer->getAnimationState(
-            mountInstanceId_, mountIn.curMountAnim, mountIn.curMountTime, mountIn.curMountDuration);
-    }
-
-    // Evaluate MountFSM
-    auto mountOut = mountFSM.evaluate(mountIn);
-
-    // Apply mount animation if changed
-    if (mountOut.mountAnimChanged && mountInstanceId_ > 0 && characterRenderer) {
-        characterRenderer->playAnimation(mountInstanceId_, mountOut.mountAnimId, mountOut.mountAnimLoop);
-    }
-
-    // Rider animation — defaults to MOUNT, but uses MOUNT_FLIGHT_* variants when flying
-    uint32_t riderAnim = anim::MOUNT;
-    if (cameraController->isFlyingActive()) {
-        auto hasRider = [&](uint32_t id) { return characterRenderer->hasAnimation(characterInstanceId, id); };
-        if (mountIn.moving) {
-            if (cameraController->isAscending() && hasRider(anim::MOUNT_FLIGHT_UP))
-                riderAnim = anim::MOUNT_FLIGHT_UP;
-            else if (cameraController->isDescending() && hasRider(anim::MOUNT_FLIGHT_DOWN))
-                riderAnim = anim::MOUNT_FLIGHT_DOWN;
-            else if (hasRider(anim::MOUNT_FLIGHT_FORWARD))
-                riderAnim = anim::MOUNT_FLIGHT_FORWARD;
-        } else {
-            if (hasRider(anim::MOUNT_FLIGHT_IDLE))
-                riderAnim = anim::MOUNT_FLIGHT_IDLE;
-        }
-    }
-
-    // Apply rider animation
-    uint32_t currentAnimId = 0;
-    float currentAnimTimeMs = 0.0f, currentAnimDurationMs = 0.0f;
-    bool haveState = characterRenderer->getAnimationState(characterInstanceId, currentAnimId, currentAnimTimeMs, currentAnimDurationMs);
-    if (!haveState || currentAnimId != riderAnim) {
-        characterRenderer->playAnimation(characterInstanceId, riderAnim, true);
-        lastPlayerAnimRequest_ = riderAnim;
-        lastPlayerAnimLoopRequest_ = true;
-    }
-
-    // Handle mount sounds
-    auto* mountSoundMgr = renderer_->getAudioCoordinator()->getMountSoundManager();
-    if (mountOut.playJumpSound && mountSoundMgr) {
-        mountSoundMgr->playJumpSound();
-    }
-    if (mountOut.playLandSound && mountSoundMgr) {
-        mountSoundMgr->playLandSound();
-    }
-    if (mountOut.playRearUpSound && mountSoundMgr) {
-        mountSoundMgr->playRearUpSound();
-    }
-    if (mountOut.playIdleSound && mountSoundMgr) {
-        mountSoundMgr->playIdleSound();
-    }
-    if (mountOut.triggerMountJump && cameraController) {
-        cameraController->triggerMountJump();
-    }
-
-    // Apply positioning (uses mountBob and mountRoll from MountFSM)
-    // For taxi flights, use external mountRoll_ set by setMountPitchRoll
-    // For ground mounts, use MountFSM's computed lean roll
-    float finalRoll = taxiFlight_ ? mountRoll_ : mountOut.mountRoll;
-    applyMountPositioning(mountOut.mountBob, finalRoll, characterYaw);
-}
-
-// ── Character animation state machine (delegates to CharacterAnimator) ──────────
-
-void AnimationController::updateCharacterAnimation() {
-    auto* characterRenderer = renderer_->getCharacterRenderer();
-    auto* cameraController = renderer_->getCameraController();
-    uint32_t characterInstanceId = renderer_->getCharacterInstanceId();
-
-    // Lazy probe: populate capability set once per model
-    if (!capabilitiesProbed_ && characterRenderer && characterInstanceId != 0) {
-        probeCapabilities();
-    }
-
-    // When mounted, delegate to MountFSM and handle positioning
-    if (isMounted()) {
-        updateMountedAnimation(lastDeltaTime_);
-        return;
-    }
-
-    // Build FrameInput for CharacterAnimator from camera/renderer state
-    CharacterAnimator::FrameInput fi;
-    fi.moving = cameraController->isMoving();
-    fi.sprinting = cameraController->isSprinting();
-    fi.movingForward = cameraController->isMovingForward();
-    fi.movingBackward = cameraController->isMovingBackward();
-    fi.autoRunning = cameraController->isAutoRunning();
-    fi.strafeLeft = cameraController->isStrafingLeft();
-    fi.strafeRight = cameraController->isStrafingRight();
-    fi.grounded = cameraController->isGrounded();
-    fi.jumping = cameraController->isJumping();
-    fi.swimming = cameraController->isSwimming();
-    fi.sitting = cameraController->isSitting();
-    fi.flyingActive = cameraController->isFlyingActive();
-    fi.ascending = cameraController->isAscending();
-    fi.descending = cameraController->isDescending();
-    fi.jumpKeyPressed = cameraController->isJumpKeyPressed();
-    fi.characterYaw = renderer_->getCharacterYaw();
-    // Melee/ranged timers
-    fi.meleeSwingTimer = meleeSwingTimer_;
-    fi.rangedShootTimer = rangedShootTimer_;
-    fi.specialAttackAnimId = specialAttackAnimId_;
-    fi.rangedAnimId = rangedAnimId_;
-    // Animation state query for one-shot completion detection
-    if (characterRenderer && characterInstanceId > 0) {
-        fi.haveAnimState = characterRenderer->getAnimationState(
-            characterInstanceId, fi.currentAnimId, fi.currentAnimTime, fi.currentAnimDuration);
-    }
-
-    // Inject FrameInput and resolve animation via CharacterAnimator
-    characterAnimator_.setFrameInput(fi);
-    characterAnimator_.update(lastDeltaTime_);
-
-    // Read the resolved animation output
-    AnimOutput output = characterAnimator_.getLastOutput();
-
-    // STAY policy: if CharacterAnimator returns invalid, keep current animation
-    if (!output.valid) return;
-
-    uint32_t animId = output.animId;
-    bool loop = output.loop;
-
-    // Apply animation to the character renderer
-    uint32_t currentAnimId = 0;
-    float currentAnimTimeMs = 0.0f;
-    float currentAnimDurationMs = 0.0f;
-    bool haveState = characterRenderer->getAnimationState(characterInstanceId, currentAnimId, currentAnimTimeMs, currentAnimDurationMs);
-    const bool requestChanged = (lastPlayerAnimRequest_ != animId) || (lastPlayerAnimLoopRequest_ != loop);
-    // Only re-assert looping animations if the renderer drifted (e.g., external
-    // playAnimation call).  One-shot animations must NOT be re-asserted after the
-    // renderer auto-resets them to STAND on completion — the FSM detects the ID
-    // change via oneShotComplete and transitions to the next state in the same frame.
-    const bool drifted = haveState && currentAnimId != animId && loop;
-    const bool shouldPlay = requestChanged || drifted;
-
-    // Debug: log animation decisions (only when animation changes or replays)
-    static uint32_t dbgLastAnim = UINT32_MAX;
-    if (shouldPlay || animId != dbgLastAnim) {
-        LOG_DEBUG("[AnimDbg] FSM→", animId, " loop=", loop,
-                  " cur=", currentAnimId, " t=", currentAnimTimeMs, "/", currentAnimDurationMs,
-                  " haveState=", haveState,
-                  " reqChanged=", requestChanged, " drifted=", drifted, " shouldPlay=", shouldPlay,
-                  " lastReq=", lastPlayerAnimRequest_,
-                  " locoState=", static_cast<int>(characterAnimator_.getLocomotion().getState()),
-                  " actState=", static_cast<int>(characterAnimator_.getActivity().getState()));
-        dbgLastAnim = animId;
-    }
-
-    if (shouldPlay) {
-        characterRenderer->playAnimation(characterInstanceId, animId, loop);
-        lastPlayerAnimRequest_ = animId;
-        lastPlayerAnimLoopRequest_ = loop;
-    }
-}
-
-// ── Footstep update (delegated to FootstepDriver) ───────────────────────────
-
-void AnimationController::updateFootsteps(float deltaTime) {
-    footstepDriver_.update(deltaTime, renderer_, isMounted(), mountInstanceId_,
-                            taxiFlight_, isFootstepAnimationState());
-}
-
-// ── Activity SFX state tracking ──────────────────────────────────────────────
-
-void AnimationController::updateSfxState(float deltaTime) {
-    sfxStateDriver_.update(deltaTime, renderer_, isMounted(), taxiFlight_,
-                           footstepDriver_);
-}
-
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/camera.cpp b/src/rendering/camera.cpp
index a169d9fc..bd1ebe0a 100644
--- a/src/rendering/camera.cpp
+++ b/src/rendering/camera.cpp
@@ -48,10 +48,7 @@ glm::vec3 Camera::getUp() const {
 }
 
 void Camera::setJitter(float jx, float jy) {
-    // Sub-pixel jitter for temporal anti-aliasing (TAA / FSR2).
-    // Column 2 of the projection matrix holds the NDC x/y offset — modifying
-    // [2][0] and [2][1] shifts the entire rendered image by a sub-pixel amount
-    // each frame, giving the upscaler different sample positions to reconstruct.
+    // Remove old jitter, apply new
     projectionMatrix[2][0] -= jitterOffset.x;
     projectionMatrix[2][1] -= jitterOffset.y;
     jitterOffset = glm::vec2(jx, jy);
diff --git a/src/rendering/camera_controller.cpp b/src/rendering/camera_controller.cpp
index 18ac8441..891d53ba 100644
--- a/src/rendering/camera_controller.cpp
+++ b/src/rendering/camera_controller.cpp
@@ -10,6 +10,7 @@
 #include "game/opcodes.hpp"
 #include "core/logger.hpp"
 #include <glm/glm.hpp>
+#include <imgui.h>
 #include <cmath>
 #include <limits>
 
@@ -18,8 +19,6 @@ namespace rendering {
 
 namespace {
 
-constexpr float kMaxPhysicsDelta = 1.0f / 30.0f;
-
 std::optional<float> selectReachableFloor(const std::optional<float>& terrainH,
                                           const std::optional<float>& wmoH,
                                           float refZ,
@@ -113,11 +112,9 @@ std::optional<float> CameraController::getCachedFloorHeight(float x, float y, fl
     // Check cache validity (position within threshold and frame count)
     glm::vec2 queryPos(x, y);
     glm::vec2 cachedPos(lastFloorQueryPos.x, lastFloorQueryPos.y);
-    glm::vec2 dq = queryPos - cachedPos;
-    float distSq = glm::dot(dq, dq);
-    constexpr float kFloorThresholdSq = FLOOR_QUERY_DISTANCE_THRESHOLD * FLOOR_QUERY_DISTANCE_THRESHOLD;
+    float dist = glm::length(queryPos - cachedPos);
 
-    if (distSq < kFloorThresholdSq && floorQueryFrameCounter < FLOOR_QUERY_FRAME_INTERVAL) {
+    if (dist < FLOOR_QUERY_DISTANCE_THRESHOLD && floorQueryFrameCounter < FLOOR_QUERY_FRAME_INTERVAL) {
         floorQueryFrameCounter++;
         return cachedFloorHeight;
     }
@@ -143,23 +140,12 @@ std::optional<float> CameraController::getCachedFloorHeight(float x, float y, fl
     return result;
 }
 
-void CameraController::triggerShake(float magnitude, float frequency, float duration) {
-    // Allow stronger shake to override weaker; don't allow zero magnitude.
-    if (magnitude <= 0.0f || duration <= 0.0f) return;
-    if (magnitude > shakeMagnitude_ || shakeElapsed_ >= shakeDuration_) {
-        shakeMagnitude_ = magnitude;
-        shakeFrequency_ = frequency;
-        shakeDuration_  = duration;
-        shakeElapsed_   = 0.0f;
-    }
-}
-
 void CameraController::update(float deltaTime) {
     if (!enabled || !camera) {
         return;
     }
     // Keep physics integration stable during render hitches to avoid floor tunneling.
-    const float physicsDeltaTime = std::min(deltaTime, kMaxPhysicsDelta);
+    const float physicsDeltaTime = std::min(deltaTime, 1.0f / 30.0f);
 
     // During taxi flights, skip movement logic but keep camera orbit/zoom controls.
     if (externalFollow_) {
@@ -181,7 +167,7 @@ void CameraController::update(float deltaTime) {
 
             // Pivot point at upper chest/neck
             float mountedOffset = mounted_ ? mountHeightOffset_ : 0.0f;
-            glm::vec3 pivot = targetPos + glm::vec3(0.0f, 0.0f, pivotHeight_ + mountedOffset);
+            glm::vec3 pivot = targetPos + glm::vec3(0.0f, 0.0f, PIVOT_HEIGHT + mountedOffset);
 
             // Camera direction from yaw/pitch
             glm::vec3 camDir = -forward3D;
@@ -191,20 +177,17 @@ void CameraController::update(float deltaTime) {
 
             // Compute camera position
             glm::vec3 actualCam;
-            // Small offset prevents the camera from clipping into the character
-            // model when collision pushes it to near-minimum distance.
-            constexpr float kCameraClipEpsilon = 0.1f;
-            if (actualDist < MIN_DISTANCE + kCameraClipEpsilon) {
-                actualCam = pivot + forward3D * kCameraClipEpsilon;
+            if (actualDist < MIN_DISTANCE + 0.1f) {
+                actualCam = pivot + forward3D * 0.1f;
             } else {
                 actualCam = pivot + camDir * actualDist;
             }
 
             // Smooth camera position
-            if (glm::dot(smoothedCamPos, smoothedCamPos) < 1e-4f) {
+            if (glm::length(smoothedCamPos) < 0.01f) {
                 smoothedCamPos = actualCam;
             }
-            float camLerp = 1.0f - std::exp(-camSmoothSpeed_ * deltaTime);
+            float camLerp = 1.0f - std::exp(-CAM_SMOOTH_SPEED * deltaTime);
             smoothedCamPos += (actualCam - smoothedCamPos) * camLerp;
 
             camera->setPosition(smoothedCamPos);
@@ -234,7 +217,6 @@ void CameraController::update(float deltaTime) {
     bool shiftDown = !uiWantsKeyboard && (input.isKeyPressed(SDL_SCANCODE_LSHIFT) || input.isKeyPressed(SDL_SCANCODE_RSHIFT));
     bool ctrlDown = !uiWantsKeyboard && (input.isKeyPressed(SDL_SCANCODE_LCTRL) || input.isKeyPressed(SDL_SCANCODE_RCTRL));
     bool nowJump = !uiWantsKeyboard && !sitting && !movementSuppressed && input.isKeyJustPressed(SDL_SCANCODE_SPACE);
-    bool spaceDown = !uiWantsKeyboard && !sitting && !movementSuppressed && input.isKeyPressed(SDL_SCANCODE_SPACE);
 
     // Idle camera: any input resets the timer; timeout triggers a slow orbit pan
     bool anyInput = leftMouseDown || rightMouseDown || keyW || keyS || keyA || keyD || keyQ || keyE || nowJump;
@@ -279,66 +261,22 @@ void CameraController::update(float deltaTime) {
         keyW = keyS = keyA = keyD = keyQ = keyE = nowJump = false;
     }
 
-    // Tilde or NumLock toggles auto-run; any forward/backward key cancels it
-    bool tildeDown = !uiWantsKeyboard && (input.isKeyPressed(SDL_SCANCODE_GRAVE) ||
-                                           input.isKeyPressed(SDL_SCANCODE_NUMLOCKCLEAR));
+    // Tilde toggles auto-run; any forward/backward key cancels it
+    bool tildeDown = !uiWantsKeyboard && input.isKeyPressed(SDL_SCANCODE_GRAVE);
     if (tildeDown && !tildeWasDown) {
         autoRunning = !autoRunning;
     }
     tildeWasDown = tildeDown;
-    // Helper: cancel auto-follow and notify game handler
-    auto doCancelAutoFollow = [&]() {
-        if (autoFollowTarget_) {
-            autoFollowTarget_ = nullptr;
-            if (autoFollowCancelCallback_) autoFollowCancelCallback_();
-        }
-    };
-
     if (keyW || keyS) {
         autoRunning = false;
-        doCancelAutoFollow();
     }
 
     bool mouseAutorun = !uiWantsKeyboard && !sitting && leftMouseDown && rightMouseDown;
     if (mouseAutorun) {
         autoRunning = false;
-        doCancelAutoFollow();
     }
-
-    // Auto-follow: face target and run toward them when within range
-    bool autoFollowMove = false;
-    if (autoFollowTarget_ && followTarget && !movementRooted_) {
-        glm::vec3 myPos = *followTarget;
-        glm::vec3 tgtPos = *autoFollowTarget_;
-        float dx = tgtPos.x - myPos.x;
-        float dy = tgtPos.y - myPos.y;
-        float distSq2D = dx * dx + dy * dy;
-
-        if (distSq2D > FOLLOW_MAX_DIST * FOLLOW_MAX_DIST) {
-            doCancelAutoFollow();
-        } else if (distSq2D > FOLLOW_STOP_DIST * FOLLOW_STOP_DIST) {
-            // Face target (render-space yaw: atan2(-dx, -dy) -> degrees)
-            float targetYawRad = std::atan2(-dx, -dy);
-            float targetYawDeg = targetYawRad * 180.0f / 3.14159265f;
-            facingYaw = targetYawDeg;
-            yaw = targetYawDeg;
-            autoFollowMove = true;
-        }
-        // else: within stop distance, stay put
-
-        // Cancel on strafe/turn keys
-        if (keyA || keyD || keyQ || keyE) {
-            doCancelAutoFollow();
-            autoFollowMove = false;
-        }
-    }
-
-    // When the server has rooted the player, suppress all horizontal movement input.
-    const bool movBlocked = movementRooted_;
-    // Auto-follow uses run speed (same as auto-run), not walk speed
-    if (autoFollowMove) autoRunning = true;
-    bool nowForward = !movBlocked && (keyW || mouseAutorun || autoRunning);
-    bool nowBackward = !movBlocked && keyS;
+    bool nowForward = keyW || mouseAutorun || autoRunning;
+    bool nowBackward = keyS;
     bool nowStrafeLeft = false;
     bool nowStrafeRight = false;
     bool nowTurnLeft = false;
@@ -347,61 +285,39 @@ void CameraController::update(float deltaTime) {
     // WoW-like third-person keyboard behavior:
     // - RMB held: A/D strafe
     // - RMB released: A/D turn character+camera, Q/E strafe
-    // Turning is allowed even while rooted; only positional movement is blocked.
     if (thirdPerson && !rightMouseDown) {
         nowTurnLeft = keyA;
         nowTurnRight = keyD;
-        nowStrafeLeft = !movBlocked && keyQ;
-        nowStrafeRight = !movBlocked && keyE;
+        nowStrafeLeft = keyQ;
+        nowStrafeRight = keyE;
     } else {
-        nowStrafeLeft = !movBlocked && (keyA || keyQ);
-        nowStrafeRight = !movBlocked && (keyD || keyE);
+        nowStrafeLeft = keyA || keyQ;
+        nowStrafeRight = keyD || keyE;
     }
 
-    // Keyboard turning updates camera yaw (character follows yaw in renderer).
-    // Use server turn rate (rad/s) when set; otherwise fall back to WOW_TURN_SPEED (deg/s).
-    const float activeTurnSpeedDeg = (turnRateOverride_ > 0.0f && turnRateOverride_ < 20.0f
-                                       && !std::isnan(turnRateOverride_))
-                                         ? glm::degrees(turnRateOverride_)
-                                         : WOW_TURN_SPEED;
+    // Keyboard turning updates camera yaw (character follows yaw in renderer)
     if (nowTurnLeft && !nowTurnRight) {
-        yaw += activeTurnSpeedDeg * deltaTime;
+        yaw += WOW_TURN_SPEED * deltaTime;
     } else if (nowTurnRight && !nowTurnLeft) {
-        yaw -= activeTurnSpeedDeg * deltaTime;
+        yaw -= WOW_TURN_SPEED * deltaTime;
     }
     if (nowTurnLeft || nowTurnRight) {
         camera->setRotation(yaw, pitch);
         facingYaw = yaw;
     }
 
-    // Tick down gravity suspension timer (used after world entry to prevent
-    // falling through WMO floors before collision is loaded)
-    if (gravitySuspendTimer_ > 0.0f) {
-        gravitySuspendTimer_ -= deltaTime;
-    }
-
     // Select physics constants based on mode
     float gravity = useWoWSpeed ? WOW_GRAVITY : GRAVITY;
     float jumpVel = useWoWSpeed ? WOW_JUMP_VELOCITY : JUMP_VELOCITY;
 
-    // Suspend gravity after world entry — hold Z position until timer expires
-    // OR a floor is detected. This prevents falling through unloaded WMO floors.
-    if (gravitySuspendTimer_ > 0.0f) {
-        gravity = 0.0f;
-        verticalVelocity = 0.0f;
-    }
-
     // Calculate movement speed based on direction and modifiers
     float speed;
     if (useWoWSpeed) {
         // Movement speeds (WoW-like: Ctrl walk, default run, backpedal slower)
         if (nowBackward && !nowForward) {
-            speed = (runBackSpeedOverride_ > 0.0f && runBackSpeedOverride_ < 100.0f
-                     && !std::isnan(runBackSpeedOverride_))
-                        ? runBackSpeedOverride_ : WOW_BACK_SPEED;
+            speed = WOW_BACK_SPEED;
         } else if (ctrlDown) {
-            speed = (walkSpeedOverride_ > 0.0f && walkSpeedOverride_ < 100.0f && !std::isnan(walkSpeedOverride_))
-                        ? walkSpeedOverride_ : WOW_WALK_SPEED;
+            speed = WOW_WALK_SPEED;
         } else if (runSpeedOverride_ > 0.0f && runSpeedOverride_ < 100.0f && !std::isnan(runSpeedOverride_)) {
             speed = runSpeedOverride_;
         } else {
@@ -441,7 +357,6 @@ void CameraController::update(float deltaTime) {
 
     // Toggle sit/crouch with X key (edge-triggered) — only when UI doesn't want keyboard
     // Blocked while mounted
-    bool prevSitting = sitting;
     bool xDown = !uiWantsKeyboard && input.isKeyPressed(SDL_SCANCODE_X);
     if (xDown && !xKeyWasDown && !mounted_) {
         sitting = !sitting;
@@ -449,34 +364,6 @@ void CameraController::update(float deltaTime) {
     if (mounted_) sitting = false;
     xKeyWasDown = xDown;
 
-    // Reset camera angles with R key (edge-triggered) — only when UI doesn't want keyboard
-    // Does NOT move the player; full reset() is reserved for world-entry/respawn.
-    bool rDown = !uiWantsKeyboard && input.isKeyPressed(SDL_SCANCODE_R);
-    if (rDown && !rKeyWasDown) {
-        resetAngles();
-    }
-    rKeyWasDown = rDown;
-
-    // Stand up on any movement key or jump while sitting (WoW behaviour)
-    if (!uiWantsKeyboard && sitting && !movementSuppressed) {
-        bool anyMoveKey =
-            input.isKeyPressed(SDL_SCANCODE_W) || input.isKeyPressed(SDL_SCANCODE_S) ||
-            input.isKeyPressed(SDL_SCANCODE_A) || input.isKeyPressed(SDL_SCANCODE_D) ||
-            input.isKeyPressed(SDL_SCANCODE_Q) || input.isKeyPressed(SDL_SCANCODE_E) ||
-            input.isKeyPressed(SDL_SCANCODE_SPACE);
-        if (anyMoveKey) sitting = false;
-    }
-
-    // Notify server when the player stands up via local input
-    if (prevSitting && !sitting && standUpCallback_) {
-        standUpCallback_();
-    }
-
-    // Notify server when the player sits down via local input
-    if (!prevSitting && sitting && sitDownCallback_) {
-        sitDownCallback_();
-    }
-
     // Update eye height based on crouch state (smooth transition)
     float targetEyeHeight = sitting ? CROUCH_EYE_HEIGHT : STAND_EYE_HEIGHT;
     float heightLerpSpeed = 10.0f * deltaTime;
@@ -490,6 +377,11 @@ void CameraController::update(float deltaTime) {
     if (nowStrafeLeft) movement += right;
     if (nowStrafeRight) movement -= right;
 
+    // Stand up if jumping while crouched
+    if (!uiWantsKeyboard && sitting && input.isKeyPressed(SDL_SCANCODE_SPACE)) {
+        sitting = false;
+    }
+
     // Third-person orbit camera mode
     if (thirdPerson && followTarget) {
         // Move the follow target (character position) instead of the camera
@@ -514,14 +406,7 @@ void CameraController::update(float deltaTime) {
             constexpr float MAX_SWIM_DEPTH_FROM_SURFACE = 12.0f;
             constexpr float MIN_SWIM_WATER_DEPTH = 1.0f;
             bool inWater = false;
-            // Water Walk: treat water surface as ground — player walks on top, not through.
-            if (waterWalkActive_ && waterH && targetPos.z >= *waterH - 0.5f) {
-                // Clamp to water surface so the player stands on it
-                targetPos.z = *waterH;
-                verticalVelocity = 0.0f;
-                grounded = true;
-                inWater = false;
-            } else if (waterH && targetPos.z < *waterH) {
+            if (waterH && targetPos.z < *waterH) {
                 std::optional<uint16_t> waterType;
                 if (waterRenderer) {
                     waterType = waterRenderer->getWaterTypeAt(targetPos.x, targetPos.y);
@@ -582,9 +467,9 @@ void CameraController::update(float deltaTime) {
                         };
 
                         glm::vec2 fwd2(forward.x, forward.y);
-                        float fwdLenSq = glm::dot(fwd2, fwd2);
-                        if (fwdLenSq > 1e-8f) {
-                            fwd2 *= glm::inversesqrt(fwdLenSq);
+                        float fwdLen = glm::length(fwd2);
+                        if (fwdLen > 1e-4f) {
+                            fwd2 /= fwdLen;
                             std::optional<float> aheadFloor;
                             const float probeZ = targetPos.z + 2.0f;
                             const float dists[] = {0.45f, 0.90f, 1.25f};
@@ -619,8 +504,7 @@ void CameraController::update(float deltaTime) {
             swimming = true;
             // Swim movement follows look pitch (forward/back), while strafe stays
             // lateral for stable control.
-            float swimSpeed = (swimSpeedOverride_ > 0.0f && swimSpeedOverride_ < 100.0f && !std::isnan(swimSpeedOverride_))
-                                  ? swimSpeedOverride_ : speed * SWIM_SPEED_FACTOR;
+            float swimSpeed = speed * SWIM_SPEED_FACTOR;
             float waterSurfaceZ = waterH ? (*waterH - WATER_SURFACE_OFFSET) : targetPos.z;
 
             // For auto-run/auto-swim: use character facing (immune to camera pan)
@@ -632,29 +516,22 @@ void CameraController::update(float deltaTime) {
             } else {
                 // Manual control: use camera's 3D direction (swim where you look)
                 swimForward = glm::normalize(forward3D);
-                if (glm::dot(swimForward, swimForward) < 1e-8f) {
+                if (glm::length(swimForward) < 1e-4f) {
                     swimForward = forward;
                 }
             }
             // Use character's facing direction for strafe, not camera's right vector
             glm::vec3 swimRight = right;  // Character's right (horizontal facing), not camera's
 
-            float swimBackSpeed = (swimBackSpeedOverride_ > 0.0f && swimBackSpeedOverride_ < 100.0f
-                                    && !std::isnan(swimBackSpeedOverride_))
-                                       ? swimBackSpeedOverride_ : swimSpeed * 0.5f;
-
             glm::vec3 swimMove(0.0f);
             if (nowForward) swimMove += swimForward;
             if (nowBackward) swimMove -= swimForward;
             if (nowStrafeLeft) swimMove += swimRight;
             if (nowStrafeRight) swimMove -= swimRight;
 
-            float swimMoveLenSq = glm::dot(swimMove, swimMove);
-            if (swimMoveLenSq > 1e-6f) {
-                swimMove *= glm::inversesqrt(swimMoveLenSq);
-                // Use backward swim speed when moving backwards only (not when combining with strafe)
-                float applySpeed = (nowBackward && !nowForward) ? swimBackSpeed : swimSpeed;
-                targetPos += swimMove * applySpeed * physicsDeltaTime;
+            if (glm::length(swimMove) > 0.001f) {
+                swimMove = glm::normalize(swimMove);
+                targetPos += swimMove * swimSpeed * physicsDeltaTime;
             }
 
             // Spacebar = swim up (continuous, not a jump)
@@ -690,12 +567,10 @@ void CameraController::update(float deltaTime) {
             // Prevent sinking/clipping through world floor while swimming.
             // Cache floor queries (update every 3 frames or 1 unit movement)
             std::optional<float> floorH;
-            float dx2D = targetPos.x - lastFloorQueryPos.x;
-            float dy2D = targetPos.y - lastFloorQueryPos.y;
-            float dist2DSq = dx2D * dx2D + dy2D * dy2D;
-            constexpr float kFloorDistSq = FLOOR_QUERY_DISTANCE_THRESHOLD * FLOOR_QUERY_DISTANCE_THRESHOLD;
+            float dist2D = glm::length(glm::vec2(targetPos.x - lastFloorQueryPos.x,
+                                                   targetPos.y - lastFloorQueryPos.y));
             bool updateFloorCache = (floorQueryFrameCounter++ >= FLOOR_QUERY_FRAME_INTERVAL) ||
-                                     (dist2DSq > kFloorDistSq);
+                                     (dist2D > FLOOR_QUERY_DISTANCE_THRESHOLD);
 
             if (updateFloorCache) {
                 floorQueryFrameCounter = 0;
@@ -754,12 +629,10 @@ void CameraController::update(float deltaTime) {
             {
                 glm::vec3 swimFrom = *followTarget;
                 glm::vec3 swimTo = targetPos;
-                glm::vec3 swimDelta = swimTo - swimFrom;
-                float swimMoveDistSq = glm::dot(swimDelta, swimDelta);
+                float swimMoveDist = glm::length(swimTo - swimFrom);
                 glm::vec3 stepPos = swimFrom;
 
-                if (swimMoveDistSq > 1e-4f) {
-                    float swimMoveDist = std::sqrt(swimMoveDistSq);
+                if (swimMoveDist > 0.01f) {
                     float swimStepSize = cachedInsideWMO ? 0.20f : 0.35f;
                     int swimSteps = std::max(1, std::min(8, static_cast<int>(std::ceil(swimMoveDist / swimStepSize))));
                     glm::vec3 stepDelta = (swimTo - swimFrom) / static_cast<float>(swimSteps);
@@ -807,62 +680,11 @@ void CameraController::update(float deltaTime) {
             }
             swimming = false;
 
-            // Player-controlled flight (flying mount / druid Flight Form):
-            // Use 3D pitch-following movement with no gravity or grounding.
-            if (flyingActive_) {
-                grounded = true;  // suppress fall-damage checks
-                verticalVelocity = 0.0f;
-                jumpBufferTimer = 0.0f;
-                coyoteTimer = 0.0f;
-
-                // Forward/back follows camera 3D direction (same as swim)
-                glm::vec3 flyFwd = glm::normalize(forward3D);
-                if (glm::dot(flyFwd, flyFwd) < 1e-8f) flyFwd = forward;
-                glm::vec3 flyMove(0.0f);
-                if (nowForward)     flyMove += flyFwd;
-                if (nowBackward)    flyMove -= flyFwd;
-                if (nowStrafeLeft)  flyMove += right;
-                if (nowStrafeRight) flyMove -= right;
-                // Space = ascend, X = descend while airborne
-                bool flyDescend = !uiWantsKeyboard && xDown && mounted_;
-                if (nowJump)       flyMove.z += 1.0f;
-                if (flyDescend)    flyMove.z -= 1.0f;
-                float flyMoveLenSq = glm::dot(flyMove, flyMove);
-                if (flyMoveLenSq > 1e-6f) {
-                    flyMove *= glm::inversesqrt(flyMoveLenSq);
-                    float flyFwdSpeed = (flightSpeedOverride_ > 0.0f && flightSpeedOverride_ < 200.0f
-                                         && !std::isnan(flightSpeedOverride_))
-                                            ? flightSpeedOverride_ : speed;
-                    float flyBackSpeed = (flightBackSpeedOverride_ > 0.0f && flightBackSpeedOverride_ < 200.0f
-                                          && !std::isnan(flightBackSpeedOverride_))
-                                             ? flightBackSpeedOverride_ : flyFwdSpeed * 0.5f;
-                    float flySpeed = (nowBackward && !nowForward) ? flyBackSpeed : flyFwdSpeed;
-                    targetPos += flyMove * flySpeed * physicsDeltaTime;
-                }
-                targetPos.z += verticalVelocity * physicsDeltaTime;
-                // Skip all ground physics — go straight to collision/WMO sections
-            } else {
-
-            float moveLenSq = glm::dot(movement, movement);
-            if (moveLenSq > 1e-6f) {
-                movement *= glm::inversesqrt(moveLenSq);
+            if (glm::length(movement) > 0.001f) {
+                movement = glm::normalize(movement);
                 targetPos += movement * speed * physicsDeltaTime;
             }
 
-            // Apply server-driven knockback horizontal velocity (decays over time).
-            if (knockbackActive_) {
-                targetPos.x += knockbackHorizVel_.x * physicsDeltaTime;
-                targetPos.y += knockbackHorizVel_.y * physicsDeltaTime;
-                // Exponential drag: reduce each frame so the player decelerates naturally.
-                float drag = std::exp(-KNOCKBACK_HORIZ_DRAG * physicsDeltaTime);
-                knockbackHorizVel_ *= drag;
-                // Once negligible, clear the flag so collision/grounding work normally.
-                if (glm::dot(knockbackHorizVel_, knockbackHorizVel_) < 0.0025f) {
-                    knockbackActive_ = false;
-                    knockbackHorizVel_ = glm::vec2(0.0f);
-                }
-            }
-
             // Jump with input buffering and coyote time
             if (nowJump) jumpBufferTimer = JUMP_BUFFER_TIME;
             if (grounded) coyoteTimer = COYOTE_TIME;
@@ -878,20 +700,10 @@ void CameraController::update(float deltaTime) {
             jumpBufferTimer -= physicsDeltaTime;
             coyoteTimer -= physicsDeltaTime;
 
-            // Apply gravity (skip when server has disabled gravity, e.g. Levitate spell)
-            if (gravityDisabled_) {
-                // Float in place: bleed off any downward velocity, allow upward to decay slowly
-                if (verticalVelocity < 0.0f) verticalVelocity = 0.0f;
-                else verticalVelocity *= std::max(0.0f, 1.0f - 3.0f * physicsDeltaTime);
-            } else {
-                verticalVelocity += gravity * physicsDeltaTime;
-                // Feather Fall / Slow Fall: cap downward terminal velocity to ~2 m/s
-                if (featherFallActive_ && verticalVelocity < -2.0f)
-                    verticalVelocity = -2.0f;
-            }
+            // Apply gravity
+            verticalVelocity += gravity * physicsDeltaTime;
             targetPos.z += verticalVelocity * physicsDeltaTime;
-            } // end !flyingActive_ ground physics
-            } // end !inWater
+            }
         } else {
             // External follow (e.g., taxi): trust server position without grounding.
             swimming = false;
@@ -902,9 +714,8 @@ void CameraController::update(float deltaTime) {
         // Refresh inside-WMO state before collision/grounding so we don't use stale
         // terrain-first caches while entering enclosed tunnel/building spaces.
         if (wmoRenderer && !externalFollow_) {
-            glm::vec3 insideDelta = targetPos - lastInsideStateCheckPos_;
-            float insideDistSq = glm::dot(insideDelta, insideDelta);
-            if (++insideStateCheckCounter_ >= 2 || insideDistSq > 0.1225f) {
+            const float insideDist = glm::length(targetPos - lastInsideStateCheckPos_);
+            if (++insideStateCheckCounter_ >= 2 || insideDist > 0.35f) {
                 insideStateCheckCounter_ = 0;
                 lastInsideStateCheckPos_ = targetPos;
 
@@ -927,11 +738,9 @@ void CameraController::update(float deltaTime) {
         {
             glm::vec3 startPos = *followTarget;
             glm::vec3 desiredPos = targetPos;
-            glm::vec3 moveDelta = desiredPos - startPos;
-            float moveDistSq = glm::dot(moveDelta, moveDelta);
+            float moveDist = glm::length(desiredPos - startPos);
 
-            if (moveDistSq > 1e-4f) {
-                float moveDist = std::sqrt(moveDistSq);
+            if (moveDist > 0.01f) {
                 // Smaller step size when inside buildings for tighter collision
                 float stepSize = cachedInsideWMO ? 0.20f : 0.35f;
                 int sweepSteps = std::max(1, std::min(8, static_cast<int>(std::ceil(moveDist / stepSize))));
@@ -985,11 +794,9 @@ void CameraController::update(float deltaTime) {
             std::optional<float> centerM2H;
             {
                 // Collision cache: skip expensive checks if barely moved (15cm threshold)
-                float dmx = targetPos.x - lastCollisionCheckPos_.x;
-                float dmy = targetPos.y - lastCollisionCheckPos_.y;
-                float distMovedSq = dmx * dmx + dmy * dmy;
-                constexpr float kCollisionCacheDistSq = COLLISION_CACHE_DISTANCE * COLLISION_CACHE_DISTANCE;
-                bool useCached = grounded && hasCachedFloor_ && distMovedSq < kCollisionCacheDistSq;
+                float distMoved = glm::length(glm::vec2(targetPos.x, targetPos.y) -
+                                             glm::vec2(lastCollisionCheckPos_.x, lastCollisionCheckPos_.y));
+                bool useCached = grounded && hasCachedFloor_ && distMoved < COLLISION_CACHE_DISTANCE;
                 if (useCached) {
                     // Never trust cached ground while actively descending or when
                     // vertical drift from cached floor is meaningful.
@@ -1041,17 +848,16 @@ void CameraController::update(float deltaTime) {
                         terrainH = terrainManager->getHeightAt(targetPos.x, targetPos.y);
                     }
                     if (wmoAsync) {
-                        try { auto [h, nz] = wmoFuture.get(); wmoH = h; wmoNormalZ = nz; }
-                        catch (const std::exception& e) { LOG_ERROR("WMO floor query: ", e.what()); }
+                        auto [h, nz] = wmoFuture.get();
+                        wmoH = h;
+                        wmoNormalZ = nz;
                     }
                     if (m2Async) {
-                        try {
-                            auto [h, nz] = m2Future.get();
-                            m2H = h;
-                            if (m2H && nz < MIN_WALKABLE_NORMAL_M2) {
-                                m2H = std::nullopt;
-                            }
-                        } catch (const std::exception& e) { LOG_ERROR("M2 floor query: ", e.what()); }
+                        auto [h, nz] = m2Future.get();
+                        m2H = h;
+                        if (m2H && nz < MIN_WALKABLE_NORMAL_M2) {
+                            m2H = std::nullopt;
+                        }
                     }
 
                     // Reject steep WMO slopes
@@ -1115,8 +921,6 @@ void CameraController::update(float deltaTime) {
                     if (groundH) {
                         cachedFloorHeight_ = *groundH;
                         hasCachedFloor_ = true;
-                        // Ground found — cancel gravity suspension (WMO floor loaded)
-                        if (gravitySuspendTimer_ > 0.0f) gravitySuspendTimer_ = 0.0f;
                     } else {
                         hasCachedFloor_ = false;
                     }
@@ -1369,22 +1173,14 @@ void CameraController::update(float deltaTime) {
                 // Only snap when:
                 // 1. Near ground (within step-up range above) - handles walking
                 // 2. Actually falling from height (was airborne + falling fast)
-                //    Scale snap range with fall speed so slow falls don't teleport
-                //    while extreme speeds still catch geometry penetration.
                 // 3. Was grounded + ground is close (grace for slopes)
                 bool nearGround = (dz >= 0.0f && dz <= stepUp);
-                float airSnapRange = std::min(fallCatch,
-                    std::max(0.5f, std::abs(verticalVelocity) * physicsDeltaTime * 2.0f));
-                bool airFalling = (!grounded && verticalVelocity < -5.0f
-                                   && dz >= -airSnapRange);
+                bool airFalling = (!grounded && verticalVelocity < -5.0f);
                 bool slopeGrace = (grounded && verticalVelocity > -1.0f &&
                                    dz >= -0.25f && dz <= stepUp * 1.5f);
 
                 if (dz >= -fallCatch && (nearGround || airFalling || slopeGrace)) {
-                    // HOVER: float at fixed height above ground instead of standing on it
-                    static constexpr float HOVER_HEIGHT = 4.0f;  // ~4 yards above ground
-                    const float snapH = hoverActive_ ? (*groundH + HOVER_HEIGHT) : *groundH;
-                    targetPos.z = snapH;
+                    targetPos.z = *groundH;
                     verticalVelocity = 0.0f;
                     grounded = true;
                     lastGroundZ = *groundH;
@@ -1457,13 +1253,11 @@ void CameraController::update(float deltaTime) {
         float mountedOffset = mounted_ ? mountHeightOffset_ : 0.0f;
         float pivotLift = 0.0f;
         if (terrainManager && !externalFollow_ && !cachedInsideInteriorWMO) {
-            float plx = targetPos.x - lastPivotLiftQueryPos_.x;
-            float ply = targetPos.y - lastPivotLiftQueryPos_.y;
-            float movedSq = plx * plx + ply * ply;
-            constexpr float kPivotLiftPosSq = PIVOT_LIFT_POS_THRESHOLD * PIVOT_LIFT_POS_THRESHOLD;
+            float moved = glm::length(glm::vec2(targetPos.x - lastPivotLiftQueryPos_.x,
+                                                targetPos.y - lastPivotLiftQueryPos_.y));
             float distDelta = std::abs(currentDistance - lastPivotLiftDistance_);
             bool queryLift = (++pivotLiftQueryCounter_ >= PIVOT_LIFT_QUERY_INTERVAL) ||
-                             (movedSq >= kPivotLiftPosSq) ||
+                             (moved >= PIVOT_LIFT_POS_THRESHOLD) ||
                              (distDelta >= PIVOT_LIFT_DIST_THRESHOLD);
             if (queryLift) {
                 pivotLiftQueryCounter_ = 0;
@@ -1479,7 +1273,7 @@ void CameraController::update(float deltaTime) {
                 if (terrainAtCam) {
                     // Keep pivot high enough so near-hill camera rays don't cut through terrain.
                     constexpr float kMinRayClearance = 2.0f;
-                    float basePivotZ = targetPos.z + pivotHeight_ + mountedOffset;
+                    float basePivotZ = targetPos.z + PIVOT_HEIGHT + mountedOffset;
                     float rayClearance = basePivotZ - *terrainAtCam;
                     if (rayClearance < kMinRayClearance) {
                         desiredLift = std::clamp(kMinRayClearance - rayClearance, 0.0f, 1.4f);
@@ -1497,7 +1291,7 @@ void CameraController::update(float deltaTime) {
             // are not relevant for camera pivoting.
             cachedPivotLift_ = 0.0f;
         }
-        glm::vec3 pivot = targetPos + glm::vec3(0.0f, 0.0f, pivotHeight_ + mountedOffset + pivotLift);
+        glm::vec3 pivot = targetPos + glm::vec3(0.0f, 0.0f, PIVOT_HEIGHT + mountedOffset + pivotLift);
 
         // Camera direction from yaw/pitch (already computed as forward3D)
         glm::vec3 camDir = -forward3D;  // Camera looks at pivot, so it's behind
@@ -1509,9 +1303,8 @@ void CameraController::update(float deltaTime) {
         // Limit max zoom when inside a WMO with a ceiling (building interior)
         // Throttle: only recheck every 10 frames or when position changes >2 units.
         if (wmoRenderer) {
-            glm::vec3 wmoCheckDelta = targetPos - lastInsideWMOCheckPos;
-            float distFromLastCheckSq = glm::dot(wmoCheckDelta, wmoCheckDelta);
-            if (++insideWMOCheckCounter >= 10 || distFromLastCheckSq > 4.0f) {
+            float distFromLastCheck = glm::length(targetPos - lastInsideWMOCheckPos);
+            if (++insideWMOCheckCounter >= 10 || distFromLastCheck > 2.0f) {
                 wmoRenderer->updateActiveGroup(targetPos.x, targetPos.y, targetPos.z + 1.0f);
                 insideWMOCheckCounter = 0;
                 lastInsideWMOCheckPos = targetPos;
@@ -1523,36 +1316,12 @@ void CameraController::update(float deltaTime) {
             }
         }
 
-        // ===== Camera collision (WMO raycast) =====
-        // Cast a ray from the pivot toward the camera direction to find the
-        // nearest WMO wall.  Uses asymmetric smoothing: pull-in is fast (so
-        // the camera never visibly clips through a wall) but recovery is slow
-        // (so passing through a doorway doesn't cause a zoom-out snap).
+        // ===== Camera collision (sphere sweep approximation) =====
+        // Find max safe distance using raycast + sphere radius
         collisionDistance = currentDistance;
 
-        if (wmoRenderer && currentDistance > MIN_DISTANCE) {
-            float rawHitDist = wmoRenderer->raycastBoundingBoxes(pivot, camDir, currentDistance);
-            // rawHitDist == currentDistance means no hit (function returns maxDistance on miss)
-            float rawLimit = (rawHitDist < currentDistance)
-                ? std::max(MIN_DISTANCE, rawHitDist - CAM_SPHERE_RADIUS - CAM_EPSILON)
-                : currentDistance;
-
-            // Initialise smoothed state on first use.
-            if (smoothedCollisionDist_ < 0.0f) {
-                smoothedCollisionDist_ = rawLimit;
-            }
-
-            // Asymmetric smoothing:
-            //   • Pull-in: τ ≈ 60 ms  — react quickly to prevent clipping
-            //   • Recover: τ ≈ 400 ms — zoom out slowly after leaving geometry
-            const float tau = (rawLimit < smoothedCollisionDist_) ? 0.06f : 0.40f;
-            float alpha = 1.0f - std::exp(-deltaTime / tau);
-            smoothedCollisionDist_ += (rawLimit - smoothedCollisionDist_) * alpha;
-
-            collisionDistance = std::min(collisionDistance, smoothedCollisionDist_);
-        } else {
-            smoothedCollisionDist_ = -1.0f;   // Reset when wmoRenderer unavailable
-        }
+        // WMO/M2 camera collision disabled — was pulling camera through
+        // geometry at doorway transitions and causing erratic zoom behaviour.
 
         // Camera collision: terrain-only floor clamping
         auto getTerrainFloorAt = [&](float x, float y) -> std::optional<float> {
@@ -1575,10 +1344,10 @@ void CameraController::update(float deltaTime) {
         }
 
         // Smooth camera position to avoid jitter
-        if (glm::dot(smoothedCamPos, smoothedCamPos) < 1e-4f) {
+        if (glm::length(smoothedCamPos) < 0.01f) {
             smoothedCamPos = actualCam;  // Initialize
         }
-        float camLerp = 1.0f - std::exp(-camSmoothSpeed_ * deltaTime);
+        float camLerp = 1.0f - std::exp(-CAM_SMOOTH_SPEED * deltaTime);
         smoothedCamPos += (actualCam - smoothedCamPos) * camLerp;
 
         // ===== Final floor clearance check =====
@@ -1592,10 +1361,9 @@ void CameraController::update(float deltaTime) {
             std::optional<float> camWmoH;
             if (wmoRenderer) {
                 // Skip expensive WMO floor query if camera barely moved
-                float cdx = smoothedCamPos.x - lastCamFloorQueryPos.x;
-                float cdy = smoothedCamPos.y - lastCamFloorQueryPos.y;
-                float camDeltaSq = cdx * cdx + cdy * cdy;
-                if (camDeltaSq < 0.09f && hasCachedCamFloor) {
+                float camDelta = glm::length(glm::vec2(smoothedCamPos.x - lastCamFloorQueryPos.x,
+                                                         smoothedCamPos.y - lastCamFloorQueryPos.y));
+                if (camDelta < 0.3f && hasCachedCamFloor) {
                     camWmoH = cachedCamWmoFloor;
                 } else {
                     float camFloorProbeZ = smoothedCamPos.z;
@@ -1653,9 +1421,6 @@ void CameraController::update(float deltaTime) {
             // Honor first-person intent even if anti-clipping pushes camera back slightly.
             bool shouldHidePlayer = isFirstPersonView() || (actualDist < MIN_DISTANCE + 0.1f);
             characterRenderer->setInstanceVisible(playerInstanceId, !shouldHidePlayer);
-
-            // Note: the Renderer's CharAnimState machine drives player character animations
-            // (Run, Walk, Jump, Swim, etc.) — no additional animation driving needed here.
         }
     } else {
         // Free-fly camera mode (original behavior)
@@ -1703,14 +1468,12 @@ void CameraController::update(float deltaTime) {
 
         if (inWater) {
             swimming = true;
-            float swimSpeed = (swimSpeedOverride_ > 0.0f && swimSpeedOverride_ < 100.0f && !std::isnan(swimSpeedOverride_))
-                                  ? swimSpeedOverride_ : speed * SWIM_SPEED_FACTOR;
+            float swimSpeed = speed * SWIM_SPEED_FACTOR;
             float waterSurfaceCamZ = waterH ? (*waterH - WATER_SURFACE_OFFSET + eyeHeight) : newPos.z;
             bool diveIntent = nowForward && (forward3D.z < -0.28f);
 
-            float movLenSq = glm::dot(movement, movement);
-            if (movLenSq > 1e-6f) {
-                movement *= glm::inversesqrt(movLenSq);
+            if (glm::length(movement) > 0.001f) {
+                movement = glm::normalize(movement);
                 newPos += movement * swimSpeed * physicsDeltaTime;
             }
 
@@ -1743,9 +1506,8 @@ void CameraController::update(float deltaTime) {
         } else {
             swimming = false;
 
-            float movLenSq2 = glm::dot(movement, movement);
-            if (movLenSq2 > 1e-6f) {
-                movement *= glm::inversesqrt(movLenSq2);
+            if (glm::length(movement) > 0.001f) {
+                movement = glm::normalize(movement);
                 newPos += movement * speed * physicsDeltaTime;
             }
 
@@ -1772,11 +1534,9 @@ void CameraController::update(float deltaTime) {
         if (wmoRenderer) {
             glm::vec3 startFeet = camera->getPosition() - glm::vec3(0, 0, eyeHeight);
             glm::vec3 desiredFeet = newPos - glm::vec3(0, 0, eyeHeight);
-            glm::vec3 feetDelta = desiredFeet - startFeet;
-            float moveDistSq2 = glm::dot(feetDelta, feetDelta);
+            float moveDist = glm::length(desiredFeet - startFeet);
 
-            if (moveDistSq2 > 1e-4f) {
-                float moveDist = std::sqrt(moveDistSq2);
+            if (moveDist > 0.01f) {
                 float stepSize = cachedInsideWMO ? 0.20f : 0.35f;
                 int sweepSteps = std::max(1, std::min(8, static_cast<int>(std::ceil(moveDist / stepSize))));
                 glm::vec3 stepPos = startFeet;
@@ -1920,35 +1680,6 @@ void CameraController::update(float deltaTime) {
         }
     }
 
-    // Flight ascend/descend transitions (Space = ascend, X = descend while mounted+flying)
-    if (movementCallback && !externalFollow_) {
-        const bool nowAscending = flyingActive_ && spaceDown;
-        const bool nowDescending = flyingActive_ && xDown && mounted_;
-
-        if (flyingActive_) {
-            if (nowAscending && !wasAscending_) {
-                movementCallback(static_cast<uint32_t>(game::Opcode::MSG_MOVE_START_ASCEND));
-            } else if (!nowAscending && wasAscending_) {
-                movementCallback(static_cast<uint32_t>(game::Opcode::MSG_MOVE_STOP_ASCEND));
-            }
-            if (nowDescending && !wasDescending_) {
-                movementCallback(static_cast<uint32_t>(game::Opcode::MSG_MOVE_START_DESCEND));
-            } else if (!nowDescending && wasDescending_) {
-                // No separate STOP_DESCEND opcode; STOP_ASCEND ends all vertical movement
-                movementCallback(static_cast<uint32_t>(game::Opcode::MSG_MOVE_STOP_ASCEND));
-            }
-        } else {
-            // Left flight mode: clear any lingering vertical movement states
-            if (wasAscending_) {
-                movementCallback(static_cast<uint32_t>(game::Opcode::MSG_MOVE_STOP_ASCEND));
-            } else if (wasDescending_) {
-                movementCallback(static_cast<uint32_t>(game::Opcode::MSG_MOVE_STOP_ASCEND));
-            }
-        }
-        wasAscending_ = nowAscending;
-        wasDescending_ = nowDescending;
-    }
-
     // Update previous-frame state
     wasSwimming = swimming;
     wasMovingForward = nowForward;
@@ -1964,24 +1695,8 @@ void CameraController::update(float deltaTime) {
     wasJumping = nowJump;
     wasFalling = !grounded && verticalVelocity <= 0.0f;
 
-    // R key is now handled above with chat safeguard (WantTextInput check)
-
-    // Camera shake (SMSG_CAMERA_SHAKE): apply sinusoidal offset to final camera position.
-    if (shakeElapsed_ < shakeDuration_) {
-        shakeElapsed_ += deltaTime;
-        float t = shakeElapsed_ / shakeDuration_;
-        // Envelope: fade out over the last 30% of shake duration
-        float envelope = (t < 0.7f) ? 1.0f : (1.0f - (t - 0.7f) / 0.3f);
-        float theta = shakeElapsed_ * shakeFrequency_ * 2.0f * 3.14159265f;
-        glm::vec3 offset(
-            shakeMagnitude_ * envelope * std::sin(theta),
-            shakeMagnitude_ * envelope * std::cos(theta * 1.3f),
-            shakeMagnitude_ * envelope * std::sin(theta * 0.7f) * 0.5f
-        );
-        if (camera) {
-            camera->setPosition(camera->getPosition() + offset);
-        }
-    }
+    // R key disabled — was camera reset, conflicts with chat reply
+    rKeyWasDown = false;
 }
 
 void CameraController::processMouseMotion(const SDL_MouseMotionEvent& event) {
@@ -1998,9 +1713,7 @@ void CameraController::processMouseMotion(const SDL_MouseMotionEvent& event) {
 
     // Directly update stored yaw/pitch (no lossy forward-vector derivation)
     yaw -= event.xrel * mouseSensitivity;
-    // SDL yrel > 0 = mouse moved DOWN. In WoW, mouse-down = look down = pitch decreases.
-    // invertMouse flips to flight-sim style (mouse-down = look up).
-    float invert = invertMouse ? 1.0f : -1.0f;
+    float invert = invertMouse ? -1.0f : 1.0f;
     pitch += event.yrel * mouseSensitivity * invert;
 
     // WoW-style pitch limits: can look almost straight down, limited upward
@@ -2036,14 +1749,6 @@ void CameraController::processMouseButton(const SDL_MouseButtonEvent& event) {
     mouseButtonDown = anyDown;
 }
 
-void CameraController::resetAngles() {
-    if (!camera) return;
-    yaw = defaultYaw;
-    facingYaw = defaultYaw;
-    pitch = defaultPitch;
-    camera->setRotation(yaw, pitch);
-}
-
 void CameraController::reset() {
     if (!camera) {
         return;
@@ -2119,7 +1824,7 @@ void CameraController::reset() {
             currentDistance = userTargetDistance;
             collisionDistance = currentDistance;
             float mountedOffset = mounted_ ? mountHeightOffset_ : 0.0f;
-            glm::vec3 pivot = spawnPos + glm::vec3(0.0f, 0.0f, pivotHeight_ + mountedOffset);
+            glm::vec3 pivot = spawnPos + glm::vec3(0.0f, 0.0f, PIVOT_HEIGHT + mountedOffset);
             glm::vec3 camDir = -forward3D;
             glm::vec3 camPos = pivot + camDir * currentDistance;
             smoothedCamPos = camPos;
@@ -2261,7 +1966,7 @@ void CameraController::reset() {
         collisionDistance = currentDistance;
 
         float mountedOffset = mounted_ ? mountHeightOffset_ : 0.0f;
-        glm::vec3 pivot = spawnPos + glm::vec3(0.0f, 0.0f, pivotHeight_ + mountedOffset);
+        glm::vec3 pivot = spawnPos + glm::vec3(0.0f, 0.0f, PIVOT_HEIGHT + mountedOffset);
         glm::vec3 camDir = -forward3D;
         glm::vec3 camPos = pivot + camDir * currentDistance;
         smoothedCamPos = camPos;
@@ -2300,7 +2005,7 @@ void CameraController::teleportTo(const glm::vec3& pos) {
         camera->setRotation(yaw, pitch);
         glm::vec3 forward3D = camera->getForward();
         float mountedOffset = mounted_ ? mountHeightOffset_ : 0.0f;
-        glm::vec3 pivot = pos + glm::vec3(0.0f, 0.0f, pivotHeight_ + mountedOffset);
+        glm::vec3 pivot = pos + glm::vec3(0.0f, 0.0f, PIVOT_HEIGHT + mountedOffset);
         glm::vec3 camDir = -forward3D;
         glm::vec3 camPos = pivot + camDir * currentDistance;
         smoothedCamPos = camPos;
@@ -2364,28 +2069,5 @@ void CameraController::triggerMountJump() {
     }
 }
 
-void CameraController::applyKnockBack(float vcos, float vsin, float hspeed, float vspeed) {
-    // The server sends (vcos, vsin) as the 2D direction vector in server/wire
-    // coordinate space.  After the server→canonical→render swaps, the direction
-    // in render space is simply (vcos, vsin) — the two swaps cancel each other.
-    knockbackHorizVel_ = glm::vec2(vcos, vsin) * hspeed;
-    knockbackActive_ = true;
-
-    // vspeed in the wire packet is negative when the server wants to launch the
-    // player upward (matches TrinityCore: data << float(-speedZ)).  Negate it
-    // here to obtain the correct upward initial velocity.
-    verticalVelocity = -vspeed;
-    grounded = false;
-    coyoteTimer = 0.0f;
-    jumpBufferTimer = 0.0f;
-
-    // Notify the server that the player left the ground so the FALLING flag is
-    // set in subsequent movement heartbeats.  The normal jump detection
-    // (nowJump && grounded) does not fire during a server-driven knockback.
-    if (movementCallback) {
-        movementCallback(static_cast<uint32_t>(game::Opcode::MSG_MOVE_JUMP));
-    }
-}
-
 } // namespace rendering
 } // namespace wowee
diff --git a/src/rendering/celestial.cpp b/src/rendering/celestial.cpp
index 320e7fb3..798ac5d5 100644
--- a/src/rendering/celestial.cpp
+++ b/src/rendering/celestial.cpp
@@ -84,13 +84,13 @@ bool Celestial::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout)
         .setVertexInput({binding}, {posAttr, uvAttr})
         .setTopology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
         .setRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE)
-        .setNoDepthTest() // Sky layer: celestials always render (skybox doesn't write depth)
+        .setDepthTest(true, false, VK_COMPARE_OP_LESS_OR_EQUAL) // test on, write off (sky layer)
         .setColorBlendAttachment(PipelineBuilder::blendAdditive())
         .setMultisample(vkCtx_->getMsaaSamples())
         .setLayout(pipelineLayout_)
         .setRenderPass(vkCtx_->getImGuiRenderPass())
         .setDynamicStates(dynamicStates)
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     vertModule.destroy();
     fragModule.destroy();
@@ -162,7 +162,7 @@ void Celestial::recreatePipelines() {
         .setLayout(pipelineLayout_)
         .setRenderPass(vkCtx_->getImGuiRenderPass())
         .setDynamicStates(dynamicStates)
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     vertModule.destroy();
     fragModule.destroy();
@@ -411,12 +411,6 @@ float Celestial::calculateCelestialAngle(float timeOfDay, float riseTime, float
 
 void Celestial::update(float deltaTime) {
     sunHazeTimer_ += deltaTime;
-    // Keep timer in a range where GPU sin() precision is reliable (< ~10000).
-    // The noise period repeats at multiples of 1.0 on each axis, so fmod by a
-    // large integer preserves visual continuity.
-    if (sunHazeTimer_ > 10000.0f) {
-        sunHazeTimer_ = std::fmod(sunHazeTimer_, 10000.0f);
-    }
 
     if (!moonPhaseCycling_) {
         return;
diff --git a/src/rendering/character_preview.cpp b/src/rendering/character_preview.cpp
index f8666fcd..964357f4 100644
--- a/src/rendering/character_preview.cpp
+++ b/src/rendering/character_preview.cpp
@@ -1,6 +1,5 @@
 #include "rendering/character_preview.hpp"
 #include "rendering/character_renderer.hpp"
-#include "rendering/animation/animation_ids.hpp"
 #include "rendering/vk_render_target.hpp"
 #include "rendering/vk_texture.hpp"
 #include "rendering/vk_context.hpp"
@@ -65,9 +64,9 @@ bool CharacterPreview::initialize(pipeline::AssetManager* am) {
         return false;
     }
 
-    // Configure lighting for character preview
-    // Use distant fog to avoid clipping, enable shadows for visual depth
+    // Disable fog and shadows for the preview
     charRenderer_->setFog(glm::vec3(0.05f, 0.05f, 0.1f), 9999.0f, 10000.0f);
+    charRenderer_->clearShadowMap();
 
     camera_ = std::make_unique<Camera>();
     // Portrait-style camera: WoW Z-up coordinate system
@@ -136,72 +135,13 @@ void CharacterPreview::createFBO() {
         vkCtx_->endSingleTimeCommands(cmd);
     }
 
-    // 2. Create 1x1 dummy depth texture (shadow map placeholder, depth=1.0 = no shadow).
-    //    Must be a depth format for sampler2DShadow compatibility.
+    // 2. Create 1x1 dummy white texture (shadow map placeholder)
     {
-        VkImageCreateInfo imgCI{VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
-        imgCI.imageType = VK_IMAGE_TYPE_2D;
-        imgCI.format = VK_FORMAT_D16_UNORM;
-        imgCI.extent = {1, 1, 1};
-        imgCI.mipLevels = 1;
-        imgCI.arrayLayers = 1;
-        imgCI.samples = VK_SAMPLE_COUNT_1_BIT;
-        imgCI.tiling = VK_IMAGE_TILING_OPTIMAL;
-        imgCI.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
-        VmaAllocationCreateInfo allocCI{};
-        allocCI.usage = VMA_MEMORY_USAGE_GPU_ONLY;
-        if (vmaCreateImage(vkCtx_->getAllocator(), &imgCI, &allocCI,
-                &dummyShadowImage_, &dummyShadowAlloc_, nullptr) != VK_SUCCESS) {
-            LOG_ERROR("CharacterPreview: failed to create dummy shadow image");
-            return;
-        }
-        VkImageViewCreateInfo viewCI{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
-        viewCI.image = dummyShadowImage_;
-        viewCI.viewType = VK_IMAGE_VIEW_TYPE_2D;
-        viewCI.format = VK_FORMAT_D16_UNORM;
-        viewCI.subresourceRange = {VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1};
-        if (vkCreateImageView(device, &viewCI, nullptr, &dummyShadowView_) != VK_SUCCESS) {
-            LOG_ERROR("CharacterPreview: failed to create dummy shadow image view");
-            return;
-        }
-        // Clear to depth 1.0 and transition to shader-read layout
-        vkCtx_->immediateSubmit([&](VkCommandBuffer cmd) {
-            VkImageMemoryBarrier toTransfer{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER};
-            toTransfer.image = dummyShadowImage_;
-            toTransfer.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-            toTransfer.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-            toTransfer.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-            toTransfer.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-            toTransfer.subresourceRange = {VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1};
-            toTransfer.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-            vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
-                                 0, 0, nullptr, 0, nullptr, 1, &toTransfer);
-            VkClearDepthStencilValue clearVal{1.0f, 0};
-            VkImageSubresourceRange range{VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1};
-            vkCmdClearDepthStencilImage(cmd, dummyShadowImage_, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearVal, 1, &range);
-            VkImageMemoryBarrier toRead{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER};
-            toRead.image = dummyShadowImage_;
-            toRead.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-            toRead.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-            toRead.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-            toRead.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-            toRead.subresourceRange = {VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1};
-            toRead.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-            toRead.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-            vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-                                 0, 0, nullptr, 0, nullptr, 1, &toRead);
-        });
-        // Comparison sampler for sampler2DShadow
-        VkSamplerCreateInfo sampCI{VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO};
-        sampCI.magFilter = VK_FILTER_NEAREST;
-        sampCI.minFilter = VK_FILTER_NEAREST;
-        sampCI.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
-        sampCI.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
-        sampCI.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
-        sampCI.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
-        sampCI.compareEnable = VK_TRUE;
-        sampCI.compareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
-        dummyShadowSampler_ = vkCtx_->getOrCreateSampler(sampCI);
+        uint8_t white[] = {255, 255, 255, 255};
+        dummyWhiteTex_ = std::make_unique<VkTexture>();
+        dummyWhiteTex_->upload(*vkCtx_, white, 1, 1, VK_FORMAT_R8G8B8A8_UNORM, false);
+        dummyWhiteTex_->createSampler(device, VK_FILTER_NEAREST, VK_FILTER_NEAREST,
+                                       VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE);
     }
 
     // 3. Create descriptor pool for per-frame sets (2 UBO + 2 sampler)
@@ -260,10 +200,7 @@ void CharacterPreview::createFBO() {
         descBuf.offset = 0;
         descBuf.range = sizeof(GPUPerFrameData);
 
-        VkDescriptorImageInfo shadowImg{};
-        shadowImg.sampler = dummyShadowSampler_;
-        shadowImg.imageView = dummyShadowView_;
-        shadowImg.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+        VkDescriptorImageInfo shadowImg = dummyWhiteTex_->descriptorInfo();
 
         VkWriteDescriptorSet writes[2]{};
         writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
@@ -313,9 +250,7 @@ void CharacterPreview::destroyFBO() {
         previewDescPool_ = VK_NULL_HANDLE;
     }
 
-    // dummyShadowSampler_ is owned by VkContext sampler cache — do NOT destroy
-    if (dummyShadowView_) { vkDestroyImageView(device, dummyShadowView_, nullptr); dummyShadowView_ = VK_NULL_HANDLE; }
-    if (dummyShadowImage_) { vmaDestroyImage(allocator, dummyShadowImage_, dummyShadowAlloc_); dummyShadowImage_ = VK_NULL_HANDLE; dummyShadowAlloc_ = VK_NULL_HANDLE; }
+    dummyWhiteTex_.reset();
 
     if (renderTarget_) {
         renderTarget_->destroy(device, allocator);
@@ -366,8 +301,7 @@ bool CharacterPreview::loadCharacter(game::Race race, game::Gender gender,
 
     auto model = pipeline::M2Loader::load(m2Data);
 
-    // M2 version 264+ (WotLK) stores submesh/bone data in external .skin files.
-    // Earlier versions (Classic ≤256, TBC ≤263) have skin data embedded in the M2.
+    // Load skin file (only for WotLK M2s - vanilla has embedded skin)
     std::string skinPath = modelDir + baseName + "00.skin";
     auto skinData = assetManager_->readFile(skinPath);
     if (!skinData.empty() && model.version >= 264) {
@@ -398,21 +332,25 @@ bool CharacterPreview::loadCharacter(game::Race race, game::Gender gender,
         bool foundUnderwear = false;
 
         const auto* csL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CharSections") : nullptr;
-        auto csF = pipeline::detectCharSectionsFields(charSectionsDbc.get(), csL);
 
+        uint32_t fRace = csL ? (*csL)["RaceID"] : 1;
+        uint32_t fSex = csL ? (*csL)["SexID"] : 2;
+        uint32_t fBase = csL ? (*csL)["BaseSection"] : 3;
+        uint32_t fVar = csL ? (*csL)["VariationIndex"] : 4;
+        uint32_t fColor = csL ? (*csL)["ColorIndex"] : 5;
         for (uint32_t r = 0; r < charSectionsDbc->getRecordCount(); r++) {
-            uint32_t raceId = charSectionsDbc->getUInt32(r, csF.raceId);
-            uint32_t sexId = charSectionsDbc->getUInt32(r, csF.sexId);
-            uint32_t baseSection = charSectionsDbc->getUInt32(r, csF.baseSection);
-            uint32_t variationIndex = charSectionsDbc->getUInt32(r, csF.variationIndex);
-            uint32_t colorIndex = charSectionsDbc->getUInt32(r, csF.colorIndex);
+            uint32_t raceId = charSectionsDbc->getUInt32(r, fRace);
+            uint32_t sexId = charSectionsDbc->getUInt32(r, fSex);
+            uint32_t baseSection = charSectionsDbc->getUInt32(r, fBase);
+            uint32_t variationIndex = charSectionsDbc->getUInt32(r, fVar);
+            uint32_t colorIndex = charSectionsDbc->getUInt32(r, fColor);
 
             if (raceId != targetRaceId || sexId != targetSexId) continue;
 
             // Section 0: Body skin (variation=0, colorIndex = skin color)
             if (baseSection == 0 && !foundSkin &&
                 variationIndex == 0 && colorIndex == static_cast<uint32_t>(skin)) {
-                std::string tex1 = charSectionsDbc->getString(r, csF.texture1);
+                std::string tex1 = charSectionsDbc->getString(r, csL ? (*csL)["Texture1"] : 6);
                 if (!tex1.empty()) {
                     bodySkinPath_ = tex1;
                     foundSkin = true;
@@ -422,8 +360,8 @@ bool CharacterPreview::loadCharacter(game::Race race, game::Gender gender,
             else if (baseSection == 1 && !foundFace &&
                      variationIndex == static_cast<uint32_t>(face) &&
                      colorIndex == static_cast<uint32_t>(skin)) {
-                std::string tex1 = charSectionsDbc->getString(r, csF.texture1);
-                std::string tex2 = charSectionsDbc->getString(r, csF.texture2);
+                std::string tex1 = charSectionsDbc->getString(r, csL ? (*csL)["Texture1"] : 6);
+                std::string tex2 = charSectionsDbc->getString(r, csL ? (*csL)["Texture2"] : 7);
                 if (!tex1.empty()) faceLowerPath = tex1;
                 if (!tex2.empty()) faceUpperPath = tex2;
                 foundFace = true;
@@ -432,7 +370,7 @@ bool CharacterPreview::loadCharacter(game::Race race, game::Gender gender,
             else if (baseSection == 3 && !foundHair &&
                      variationIndex == static_cast<uint32_t>(hairStyle) &&
                      colorIndex == static_cast<uint32_t>(hairColor)) {
-                std::string tex1 = charSectionsDbc->getString(r, csF.texture1);
+                std::string tex1 = charSectionsDbc->getString(r, csL ? (*csL)["Texture1"] : 6);
                 if (!tex1.empty()) {
                     hairScalpPath = tex1;
                     foundHair = true;
@@ -441,7 +379,8 @@ bool CharacterPreview::loadCharacter(game::Race race, game::Gender gender,
             // Section 4: Underwear (variation=0, colorIndex = skin color)
             else if (baseSection == 4 && !foundUnderwear &&
                      variationIndex == 0 && colorIndex == static_cast<uint32_t>(skin)) {
-                for (uint32_t f = csF.texture1; f <= csF.texture1 + 2; f++) {
+                uint32_t texBase = csL ? (*csL)["Texture1"] : 6;
+                for (uint32_t f = texBase; f <= texBase + 2; f++) {
                     std::string tex = charSectionsDbc->getString(r, f);
                     if (!tex.empty()) {
                         underwearPaths.push_back(tex);
@@ -464,8 +403,6 @@ bool CharacterPreview::loadCharacter(game::Race race, game::Gender gender,
         auto& tex = model.textures[ti];
         LOG_INFO("  Model texture[", ti, "]: type=", tex.type,
                  " filename='", tex.filename, "'");
-        // M2 texture types: 1=character skin, 6=hair/scalp. Empty filename means
-        // the texture is resolved at runtime via CharSections.dbc lookup.
         if (tex.type == 1 && tex.filename.empty() && !bodySkinPath_.empty()) {
             tex.filename = bodySkinPath_;
         } else if (tex.type == 6 && tex.filename.empty() && !hairScalpPath.empty()) {
@@ -473,8 +410,7 @@ bool CharacterPreview::loadCharacter(game::Race race, game::Gender gender,
         }
     }
 
-    // Load external .anim files for sequences that store keyframes outside the M2.
-    // Flag 0x20 = embedded data; when clear, animation lives in {ModelName}{SeqID}-{Var}.anim
+    // Load external .anim files
     for (uint32_t si = 0; si < model.sequences.size(); si++) {
         if (!(model.sequences[si].flags & 0x20)) {
             char animFileName[256];
@@ -526,17 +462,6 @@ bool CharacterPreview::loadCharacter(game::Race race, game::Gender gender,
                     }
                 }
             }
-        } else {
-            // Single layer (body skin only, no face/underwear overlays) — load directly
-            VkTexture* skinTex = charRenderer_->loadTexture(bodySkinPath_);
-            if (skinTex != nullptr) {
-                for (size_t ti = 0; ti < model.textures.size(); ti++) {
-                    if (model.textures[ti].type == 1) {
-                        charRenderer_->setModelTexture(PREVIEW_MODEL_ID, static_cast<uint32_t>(ti), skinTex);
-                        break;
-                    }
-                }
-            }
         }
     }
 
@@ -585,7 +510,7 @@ bool CharacterPreview::loadCharacter(game::Race race, game::Gender gender,
     charRenderer_->setActiveGeosets(instanceId_, activeGeosets);
 
     // Play idle animation (Stand = animation ID 0)
-    charRenderer_->playAnimation(instanceId_, rendering::anim::STAND, true);
+    charRenderer_->playAnimation(instanceId_, 0, true);
 
     // Cache core appearance for later equipment geosets.
     race_ = race;
@@ -605,9 +530,9 @@ bool CharacterPreview::loadCharacter(game::Race race, game::Gender gender,
 
     modelLoaded_ = true;
     LOG_INFO("CharacterPreview: loaded ", m2Path,
-             " skin=", static_cast<int>(skin), " face=", static_cast<int>(face),
-             " hair=", static_cast<int>(hairStyle), " hairColor=", static_cast<int>(hairColor),
-             " facial=", static_cast<int>(facialHair));
+             " skin=", (int)skin, " face=", (int)face,
+             " hair=", (int)hairStyle, " hairColor=", (int)hairColor,
+             " facial=", (int)facialHair);
     return true;
 }
 
@@ -618,7 +543,6 @@ bool CharacterPreview::applyEquipment(const std::vector<game::EquipmentItem>& eq
 
     auto displayInfoDbc = assetManager_->loadDBC("ItemDisplayInfo.dbc");
     if (!displayInfoDbc || !displayInfoDbc->isLoaded()) {
-        LOG_WARNING("applyEquipment: ItemDisplayInfo.dbc not loaded");
         return false;
     }
 
@@ -636,7 +560,7 @@ bool CharacterPreview::applyEquipment(const std::vector<game::EquipmentItem>& eq
         for (const auto& it : equipment) {
             if (it.displayModel == 0) continue;
             for (uint8_t t : types) {
-                if (it.inventoryType == t) return it.displayModel;
+                if (it.inventoryType == t) return it.displayModel; // ItemDisplayInfo ID (3.3.5a char enum)
             }
         }
         return 0;
@@ -646,14 +570,10 @@ bool CharacterPreview::applyEquipment(const std::vector<game::EquipmentItem>& eq
         if (displayInfoId == 0) return 0;
         int32_t recIdx = displayInfoDbc->findRecordById(displayInfoId);
         if (recIdx < 0) return 0;
-        uint32_t val = displayInfoDbc->getUInt32(static_cast<uint32_t>(recIdx), 7 + groupField);
-        return val;
+        return displayInfoDbc->getUInt32(static_cast<uint32_t>(recIdx), 7 + groupField);
     };
 
     // --- Geosets ---
-    // M2 geoset IDs encode body part group × 100 + variant (e.g., 801 = group 8
-    // (sleeves) variant 1, 1301 = group 13 (pants) variant 1). ItemDisplayInfo.dbc
-    // provides the variant offset per equipped item; base IDs are per-group constants.
     std::unordered_set<uint16_t> geosets;
     for (uint16_t i = 0; i <= 99; i++) geosets.insert(i);
     geosets.insert(static_cast<uint16_t>(100 + hairStyle_ + 1));    // Hair style
@@ -695,27 +615,11 @@ bool CharacterPreview::applyEquipment(const std::vector<game::EquipmentItem>& eq
         uint32_t gg = getGeosetGroup(did, 0);
         if (gg > 0) geosetGloves = static_cast<uint16_t>(401 + gg);
     }
-    // Wrists/Bracers → group 8 (sleeves, only if chest/shirt didn't set it)
-    {
-        uint32_t did = findDisplayId({9});
-        if (did != 0 && geosetSleeves == 801) {
-            uint32_t gg = getGeosetGroup(did, 0);
-            if (gg > 0) geosetSleeves = static_cast<uint16_t>(801 + gg);
-        }
-    }
-    // Belt → group 18 (buckle)
-    uint16_t geosetBelt = 0;
-    {
-        uint32_t did = findDisplayId({6});
-        uint32_t gg = getGeosetGroup(did, 0);
-        if (gg > 0) geosetBelt = static_cast<uint16_t>(1801 + gg);
-    }
 
     geosets.insert(geosetGloves);
     geosets.insert(geosetBoots);
     geosets.insert(geosetSleeves);
     geosets.insert(geosetPants);
-    if (geosetBelt != 0) geosets.insert(geosetBelt);
     geosets.insert(hasInvType({16}) ? 1502 : 1501); // Cloak mesh toggle (visual may still be limited)
     if (hasInvType({19})) geosets.insert(1201);     // Tabard mesh toggle
 
@@ -731,18 +635,12 @@ bool CharacterPreview::applyEquipment(const std::vector<game::EquipmentItem>& eq
     // --- Textures (equipment overlays onto body skin) ---
     if (bodySkinPath_.empty()) return true; // geosets applied, but can't composite
 
-    static constexpr const char* componentDirs[] = {
+    static const char* componentDirs[] = {
         "ArmUpperTexture", "ArmLowerTexture", "HandTexture",
         "TorsoUpperTexture", "TorsoLowerTexture",
         "LegUpperTexture", "LegLowerTexture", "FootTexture",
     };
 
-    // Texture component region fields — use DBC layout when available, fall back to binary offsets.
-    const auto* idiL = pipeline::getActiveDBCLayout()
-        ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
-    uint32_t texRegionFields[8];
-    pipeline::getItemDisplayInfoTextureFields(*displayInfoDbc, idiL, texRegionFields);
-
     std::vector<std::pair<int, std::string>> regionLayers;
     regionLayers.reserve(32);
 
@@ -752,7 +650,8 @@ bool CharacterPreview::applyEquipment(const std::vector<game::EquipmentItem>& eq
         if (recIdx < 0) continue;
 
         for (int region = 0; region < 8; region++) {
-            std::string texName = displayInfoDbc->getString(static_cast<uint32_t>(recIdx), texRegionFields[region]);
+            uint32_t fieldIdx = 14 + region; // texture_1..texture_8
+            std::string texName = displayInfoDbc->getString(static_cast<uint32_t>(recIdx), fieldIdx);
             if (texName.empty()) continue;
 
             std::string base = "Item\\TextureComponents\\" +
@@ -905,8 +804,8 @@ void CharacterPreview::compositePass(VkCommandBuffer cmd, uint32_t frameIndex) {
     // No fog in preview
     ubo.fogColor = glm::vec4(0.05f, 0.05f, 0.1f, 0.0f);
     ubo.fogParams = glm::vec4(9999.0f, 10000.0f, 0.0f, 0.0f);
-    // Enable shadows for visual depth in preview (strength=0.5 for subtle effect)
-    ubo.shadowParams = glm::vec4(1.0f, 0.5f, 0.0f, 0.0f);
+    // Shadows disabled
+    ubo.shadowParams = glm::vec4(0.0f, 0.0f, 0.0f, 0.0f);
 
     std::memcpy(previewUBOMapped_[fi], &ubo, sizeof(GPUPerFrameData));
 
diff --git a/src/rendering/character_renderer.cpp b/src/rendering/character_renderer.cpp
index 06bb4e08..f69ae75c 100644
--- a/src/rendering/character_renderer.cpp
+++ b/src/rendering/character_renderer.cpp
@@ -15,16 +15,13 @@
  * the original WoW Model Viewer (charcontrol.h, REGION_FAC=2).
  */
 #include "rendering/character_renderer.hpp"
-#include "rendering/animation/animation_ids.hpp"
 #include "rendering/vk_context.hpp"
 #include "rendering/vk_texture.hpp"
 #include "rendering/vk_pipeline.hpp"
 #include "rendering/vk_shader.hpp"
 #include "rendering/vk_buffer.hpp"
 #include "rendering/vk_utils.hpp"
-#include "rendering/vk_frame_data.hpp"
 #include "rendering/camera.hpp"
-#include "rendering/frustum.hpp"
 #include "pipeline/asset_manager.hpp"
 #include "pipeline/blp_loader.hpp"
 #include "core/logger.hpp"
@@ -35,13 +32,13 @@
 #include <cmath>
 #include <filesystem>
 #include <future>
-#include <numeric>
 #include <thread>
 #include <functional>
 #include <unordered_map>
 #include <unordered_set>
 #include <chrono>
 #include <cstdlib>
+#include <fstream>
 #include <limits>
 #include <cstring>
 
@@ -49,6 +46,25 @@ namespace wowee {
 namespace rendering {
 
 namespace {
+size_t envSizeMBOrDefault(const char* name, size_t defMb) {
+    const char* v = std::getenv(name);
+    if (!v || !*v) return defMb;
+    char* end = nullptr;
+    unsigned long long mb = std::strtoull(v, &end, 10);
+    if (end == v || mb == 0) return defMb;
+    if (mb > (std::numeric_limits<size_t>::max() / (1024ull * 1024ull))) return defMb;
+    return static_cast<size_t>(mb);
+}
+
+size_t envSizeOrDefault(const char* name, size_t defValue) {
+    const char* v = std::getenv(name);
+    if (!v || !*v) return defValue;
+    char* end = nullptr;
+    unsigned long long n = std::strtoull(v, &end, 10);
+    if (end == v || n == 0) return defValue;
+    return static_cast<size_t>(n);
+}
+
 size_t approxTextureBytesWithMips(int w, int h) {
     if (w <= 0 || h <= 0) return 0;
     size_t base = static_cast<size_t>(w) * static_cast<size_t>(h) * 4ull;
@@ -60,10 +76,6 @@ size_t approxTextureBytesWithMips(int w, int h) {
 static constexpr uint32_t MAX_MATERIAL_SETS = 4096;
 static constexpr uint32_t MAX_BONE_SETS = 8192;
 
-// Texture compositing sizes (NPC skin upscale)
-static constexpr int kBaseTexSize    = 256;  // NPC baked texture default
-static constexpr int kUpscaleTexSize = 512;  // Target size for region compositing
-
 // CharMaterial UBO layout (matches character.frag.glsl set=1 binding=1)
 struct CharMaterialUBO {
     float opacity;
@@ -228,8 +240,10 @@ bool CharacterRenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFram
 
     // --- Load shaders ---
     rendering::VkShaderModule charVert, charFrag;
-    if (!charVert.loadFromFile(device, "assets/shaders/character.vert.spv") ||
-        !charFrag.loadFromFile(device, "assets/shaders/character.frag.spv")) {
+    charVert.loadFromFile(device, "assets/shaders/character.vert.spv");
+    charFrag.loadFromFile(device, "assets/shaders/character.frag.spv");
+
+    if (!charVert.isValid() || !charFrag.isValid()) {
         LOG_ERROR("Character: Missing required shaders, cannot initialize");
         return false;
     }
@@ -248,36 +262,31 @@ bool CharacterRenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFram
     std::vector<VkVertexInputAttributeDescription> charAttrs = {
         {0, 0, VK_FORMAT_R32G32B32_SFLOAT, static_cast<uint32_t>(offsetof(CharVertexGPU, position))},
         {1, 0, VK_FORMAT_R8G8B8A8_UNORM,   static_cast<uint32_t>(offsetof(CharVertexGPU, boneWeights))},
-        {2, 0, VK_FORMAT_R8G8B8A8_SINT,     static_cast<uint32_t>(offsetof(CharVertexGPU, boneIndices))},
+        {2, 0, VK_FORMAT_R8G8B8A8_UINT,     static_cast<uint32_t>(offsetof(CharVertexGPU, boneIndices))},
         {3, 0, VK_FORMAT_R32G32B32_SFLOAT,  static_cast<uint32_t>(offsetof(CharVertexGPU, normal))},
         {4, 0, VK_FORMAT_R32G32_SFLOAT,     static_cast<uint32_t>(offsetof(CharVertexGPU, texCoords))},
         {5, 0, VK_FORMAT_R32G32B32A32_SFLOAT, static_cast<uint32_t>(offsetof(CharVertexGPU, tangent))},
     };
 
     // --- Build pipelines ---
-    auto buildCharPipeline = [&](VkPipelineColorBlendAttachmentState blendState,
-                                  bool depthWrite, bool alphaToCoverage = false) -> VkPipeline {
-        auto builder = PipelineBuilder()
+    auto buildCharPipeline = [&](VkPipelineColorBlendAttachmentState blendState, bool depthWrite) -> VkPipeline {
+        return PipelineBuilder()
             .setShaders(charVert.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
                         charFrag.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
             .setVertexInput({charBinding}, charAttrs)
             .setTopology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
             .setRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE)
-            .setDepthTest(true, depthWrite, VK_COMPARE_OP_LESS)
-            .setDepthBias(0.0f, 0.0f)
+            .setDepthTest(true, depthWrite, VK_COMPARE_OP_LESS_OR_EQUAL)
             .setColorBlendAttachment(blendState)
-            .setMultisample(samples);
-        if (alphaToCoverage)
-            builder.setAlphaToCoverage(true);
-        return builder
+            .setMultisample(samples)
             .setLayout(pipelineLayout_)
             .setRenderPass(mainPass)
-            .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_DEPTH_BIAS})
-            .build(device, vkCtx_->getPipelineCache());
+            .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
+            .build(device);
     };
 
     opaquePipeline_ = buildCharPipeline(PipelineBuilder::blendDisabled(), true);
-    alphaTestPipeline_ = buildCharPipeline(PipelineBuilder::blendDisabled(), true, true);
+    alphaTestPipeline_ = buildCharPipeline(PipelineBuilder::blendAlpha(), true);
     alphaPipeline_ = buildCharPipeline(PipelineBuilder::blendAlpha(), false);
     additivePipeline_ = buildCharPipeline(PipelineBuilder::blendAdditive(), false);
 
@@ -285,7 +294,29 @@ bool CharacterRenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFram
     charVert.destroy();
     charFrag.destroy();
 
-    createFallbackTextures(device);
+    // --- Create white fallback texture ---
+    {
+        uint8_t white[] = {255, 255, 255, 255};
+        whiteTexture_ = std::make_unique<VkTexture>();
+        whiteTexture_->upload(*vkCtx_, white, 1, 1, VK_FORMAT_R8G8B8A8_UNORM, false);
+        whiteTexture_->createSampler(device, VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_ADDRESS_MODE_REPEAT);
+    }
+
+    // --- Create transparent fallback texture ---
+    {
+        uint8_t transparent[] = {0, 0, 0, 0};
+        transparentTexture_ = std::make_unique<VkTexture>();
+        transparentTexture_->upload(*vkCtx_, transparent, 1, 1, VK_FORMAT_R8G8B8A8_UNORM, false);
+        transparentTexture_->createSampler(device, VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_ADDRESS_MODE_REPEAT);
+    }
+
+    // --- Create flat normal placeholder texture (128,128,255,128) = neutral normal, 0.5 height ---
+    {
+        uint8_t flatNormal[] = {128, 128, 255, 128};
+        flatNormalTexture_ = std::make_unique<VkTexture>();
+        flatNormalTexture_->upload(*vkCtx_, flatNormal, 1, 1, VK_FORMAT_R8G8B8A8_UNORM, false);
+        flatNormalTexture_->createSampler(device, VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_ADDRESS_MODE_REPEAT);
+    }
 
     // Diagnostics-only: cache lifetime is currently tied to renderer lifetime.
     textureCacheBudgetBytes_ = envSizeMBOrDefault("WOWEE_CHARACTER_TEX_CACHE_MB", 4096) * 1024ull * 1024ull;
@@ -302,11 +333,8 @@ void CharacterRenderer::shutdown() {
              " models=", models.size(), " override=", (void*)renderPassOverride_);
 
     // Wait for any in-flight background normal map generation threads
-    {
-        std::unique_lock<std::mutex> lock(normalMapResultsMutex_);
-        normalMapDoneCV_.wait(lock, [this] {
-            return pendingNormalMapCount_.load(std::memory_order_acquire) == 0;
-        });
+    while (pendingNormalMapCount_.load(std::memory_order_relaxed) > 0) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }
 
     vkDeviceWaitIdle(vkCtx_->getDevice());
@@ -325,15 +353,14 @@ void CharacterRenderer::shutdown() {
 
     // Clean up texture cache (VkTexture unique_ptrs auto-destroy)
     textureCache.clear();
-    texturePropsByPtr_.clear();
+    textureHasAlphaByPtr_.clear();
+    textureColorKeyBlackByPtr_.clear();
     textureCacheBytes_ = 0;
     textureCacheCounter_ = 0;
 
     // Clean up composite cache
     compositeCache_.clear();
     failedTextureCache_.clear();
-    failedTextureRetryAt_.clear();
-    textureLookupSerial_ = 0;
 
     whiteTexture_.reset();
     transparentTexture_.reset();
@@ -392,11 +419,8 @@ void CharacterRenderer::clear() {
              " models=", models.size());
 
     // Wait for any in-flight background normal map generation threads
-    {
-        std::unique_lock<std::mutex> lock(normalMapResultsMutex_);
-        normalMapDoneCV_.wait(lock, [this] {
-            return pendingNormalMapCount_.load(std::memory_order_acquire) == 0;
-        });
+    while (pendingNormalMapCount_.load(std::memory_order_relaxed) > 0) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }
     // Discard any completed results that haven't been uploaded
     {
@@ -419,12 +443,11 @@ void CharacterRenderer::clear() {
 
     // Clear texture cache (VkTexture unique_ptrs auto-destroy)
     textureCache.clear();
-    texturePropsByPtr_.clear();
+    textureHasAlphaByPtr_.clear();
+    textureColorKeyBlackByPtr_.clear();
     textureCacheBytes_ = 0;
     textureCacheCounter_ = 0;
     loggedTextureLoadFails_.clear();
-    failedTextureRetryAt_.clear();
-    textureLookupSerial_ = 0;
 
     // Clear composite and failed caches
     compositeCache_.clear();
@@ -434,7 +457,24 @@ void CharacterRenderer::clear() {
     whiteTexture_.reset();
     transparentTexture_.reset();
     flatNormalTexture_.reset();
-    createFallbackTextures(device);
+    {
+        uint8_t white[] = {255, 255, 255, 255};
+        whiteTexture_ = std::make_unique<VkTexture>();
+        whiteTexture_->upload(*vkCtx_, white, 1, 1, VK_FORMAT_R8G8B8A8_UNORM, false);
+        whiteTexture_->createSampler(device, VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_ADDRESS_MODE_REPEAT);
+    }
+    {
+        uint8_t transparent[] = {0, 0, 0, 0};
+        transparentTexture_ = std::make_unique<VkTexture>();
+        transparentTexture_->upload(*vkCtx_, transparent, 1, 1, VK_FORMAT_R8G8B8A8_UNORM, false);
+        transparentTexture_->createSampler(device, VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_ADDRESS_MODE_REPEAT);
+    }
+    {
+        uint8_t flatNormal[] = {128, 128, 255, 128};
+        flatNormalTexture_ = std::make_unique<VkTexture>();
+        flatNormalTexture_->upload(*vkCtx_, flatNormal, 1, 1, VK_FORMAT_R8G8B8A8_UNORM, false);
+        flatNormalTexture_->createSampler(device, VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_ADDRESS_MODE_REPEAT);
+    }
 
     models.clear();
     instances.clear();
@@ -455,90 +495,27 @@ void CharacterRenderer::clear() {
     }
 }
 
-void CharacterRenderer::createFallbackTextures(VkDevice device) {
-    // White: default diffuse when no texture is assigned
-    {
-        uint8_t white[] = {255, 255, 255, 255};
-        whiteTexture_ = std::make_unique<VkTexture>();
-        whiteTexture_->upload(*vkCtx_, white, 1, 1, VK_FORMAT_R8G8B8A8_UNORM, false);
-        whiteTexture_->createSampler(device, VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_ADDRESS_MODE_REPEAT);
-    }
-    // Transparent: placeholder for optional overlay layers (e.g. hair highlights)
-    {
-        uint8_t transparent[] = {0, 0, 0, 0};
-        transparentTexture_ = std::make_unique<VkTexture>();
-        transparentTexture_->upload(*vkCtx_, transparent, 1, 1, VK_FORMAT_R8G8B8A8_UNORM, false);
-        transparentTexture_->createSampler(device, VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_ADDRESS_MODE_REPEAT);
-    }
-    // Flat normal: neutral normal map (128,128,255) + 0.5 height in alpha channel
-    {
-        uint8_t flatNormal[] = {128, 128, 255, 128};
-        flatNormalTexture_ = std::make_unique<VkTexture>();
-        flatNormalTexture_->upload(*vkCtx_, flatNormal, 1, 1, VK_FORMAT_R8G8B8A8_UNORM, false);
-        flatNormalTexture_->createSampler(device, VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_ADDRESS_MODE_REPEAT);
-    }
-}
-
-void CharacterRenderer::destroyModelGPU(M2ModelGPU& gpuModel, bool defer) {
+void CharacterRenderer::destroyModelGPU(M2ModelGPU& gpuModel) {
     if (!vkCtx_) return;
     VmaAllocator alloc = vkCtx_->getAllocator();
-
-    // Snapshot raw handles and null the model fields immediately
-    ::VkBuffer vb = gpuModel.vertexBuffer;
-    VmaAllocation vbAlloc = gpuModel.vertexAlloc;
-    ::VkBuffer ib = gpuModel.indexBuffer;
-    VmaAllocation ibAlloc = gpuModel.indexAlloc;
-    gpuModel.vertexBuffer = VK_NULL_HANDLE;
-    gpuModel.vertexAlloc = VK_NULL_HANDLE;
-    gpuModel.indexBuffer = VK_NULL_HANDLE;
-    gpuModel.indexAlloc = VK_NULL_HANDLE;
-
-    if (!defer) {
-        // Safe after vkDeviceWaitIdle (shutdown / clear paths)
-        if (vb) vmaDestroyBuffer(alloc, vb, vbAlloc);
-        if (ib) vmaDestroyBuffer(alloc, ib, ibAlloc);
-    } else if (vb || ib) {
-        // Streaming path: in-flight command buffers may still reference these
-        vkCtx_->deferAfterAllFrameFences([alloc, vb, vbAlloc, ib, ibAlloc]() {
-            if (vb) vmaDestroyBuffer(alloc, vb, vbAlloc);
-            if (ib) vmaDestroyBuffer(alloc, ib, ibAlloc);
-        });
-    }
+    if (gpuModel.vertexBuffer) { vmaDestroyBuffer(alloc, gpuModel.vertexBuffer, gpuModel.vertexAlloc); gpuModel.vertexBuffer = VK_NULL_HANDLE; }
+    if (gpuModel.indexBuffer) { vmaDestroyBuffer(alloc, gpuModel.indexBuffer, gpuModel.indexAlloc); gpuModel.indexBuffer = VK_NULL_HANDLE; }
 }
 
-void CharacterRenderer::destroyInstanceBones(CharacterInstance& inst, bool defer) {
+void CharacterRenderer::destroyInstanceBones(CharacterInstance& inst) {
     if (!vkCtx_) return;
     VmaAllocator alloc = vkCtx_->getAllocator();
     VkDevice device = vkCtx_->getDevice();
     for (int i = 0; i < 2; i++) {
-        VkDescriptorSet boneSet = inst.boneSet[i];
-        ::VkBuffer boneBuf = inst.boneBuffer[i];
-        VmaAllocation boneAlloc = inst.boneAlloc[i];
-        inst.boneSet[i] = VK_NULL_HANDLE;
-        inst.boneBuffer[i] = VK_NULL_HANDLE;
-        inst.boneAlloc[i] = VK_NULL_HANDLE;
-        inst.boneMapped[i] = nullptr;
-
-        if (!defer) {
-            if (boneSet != VK_NULL_HANDLE && boneDescPool_ != VK_NULL_HANDLE) {
-                vkFreeDescriptorSets(device, boneDescPool_, 1, &boneSet);
-            }
-            if (boneBuf) {
-                vmaDestroyBuffer(alloc, boneBuf, boneAlloc);
-            }
-        } else if (boneSet != VK_NULL_HANDLE || boneBuf) {
-            // Loop destroys bone sets for ALL frame slots — the other slot's
-            // command buffer may still be in flight. Wait for all fences.
-            VkDescriptorPool pool = boneDescPool_;
-            vkCtx_->deferAfterAllFrameFences([device, alloc, pool, boneSet, boneBuf, boneAlloc]() {
-                if (boneSet != VK_NULL_HANDLE && pool != VK_NULL_HANDLE) {
-                    VkDescriptorSet s = boneSet;
-                    vkFreeDescriptorSets(device, pool, 1, &s);
-                }
-                if (boneBuf) {
-                    vmaDestroyBuffer(alloc, boneBuf, boneAlloc);
-                }
-            });
+        if (inst.boneSet[i] != VK_NULL_HANDLE && boneDescPool_ != VK_NULL_HANDLE) {
+            vkFreeDescriptorSets(device, boneDescPool_, 1, &inst.boneSet[i]);
+            inst.boneSet[i] = VK_NULL_HANDLE;
+        }
+        if (inst.boneBuffer[i]) {
+            vmaDestroyBuffer(alloc, inst.boneBuffer[i], inst.boneAlloc[i]);
+            inst.boneBuffer[i] = VK_NULL_HANDLE;
+            inst.boneAlloc[i] = VK_NULL_HANDLE;
+            inst.boneMapped[i] = nullptr;
         }
     }
 }
@@ -575,13 +552,12 @@ CharacterRenderer::NormalMapResult CharacterRenderer::generateNormalHeightMapCPU
     const uint8_t* pixels = srcPixels.data();
 
     // Step 1: Compute height from luminance
-    constexpr float kInv255 = 1.0f / 255.0f;
     std::vector<float> heightMap(totalPixels);
     double sumH = 0.0, sumH2 = 0.0;
     for (uint32_t i = 0; i < totalPixels; i++) {
-        float r = pixels[i * 4 + 0] * kInv255;
-        float g = pixels[i * 4 + 1] * kInv255;
-        float b = pixels[i * 4 + 2] * kInv255;
+        float r = pixels[i * 4 + 0] / 255.0f;
+        float g = pixels[i * 4 + 1] / 255.0f;
+        float b = pixels[i * 4 + 2] / 255.0f;
         float h = 0.299f * r + 0.587f * g + 0.114f * b;
         heightMap[i] = h;
         sumH += h;
@@ -592,8 +568,8 @@ CharacterRenderer::NormalMapResult CharacterRenderer::generateNormalHeightMapCPU
 
     // Step 1.5: Box blur the height map to reduce noise from diffuse textures
     auto wrapSample = [&](const std::vector<float>& map, int x, int y) -> float {
-        x = ((x % static_cast<int>(width)) + static_cast<int>(width)) % static_cast<int>(width);
-        y = ((y % static_cast<int>(height)) + static_cast<int>(height)) % static_cast<int>(height);
+        x = ((x % (int)width) + (int)width) % (int)width;
+        y = ((y % (int)height) + (int)height) % (int)height;
         return map[y * width + x];
     };
 
@@ -614,8 +590,8 @@ CharacterRenderer::NormalMapResult CharacterRenderer::generateNormalHeightMapCPU
     result.pixels.resize(totalPixels * 4);
 
     auto sampleH = [&](int x, int y) -> float {
-        x = ((x % static_cast<int>(width)) + static_cast<int>(width)) % static_cast<int>(width);
-        y = ((y % static_cast<int>(height)) + static_cast<int>(height)) % static_cast<int>(height);
+        x = ((x % (int)width) + (int)width) % (int)width;
+        y = ((y % (int)height) + (int)height) % (int)height;
         return heightMap[y * width + x];
     };
 
@@ -646,7 +622,6 @@ CharacterRenderer::NormalMapResult CharacterRenderer::generateNormalHeightMapCPU
 }
 
 VkTexture* CharacterRenderer::loadTexture(const std::string& path) {
-    constexpr uint64_t kFailedTextureRetryLookups = 512;
     // Skip empty or whitespace-only paths (type-0 textures have no filename)
     if (path.empty()) return whiteTexture_.get();
     bool allWhitespace = true;
@@ -662,7 +637,6 @@ VkTexture* CharacterRenderer::loadTexture(const std::string& path) {
         return key;
     };
     std::string key = normalizeKey(path);
-    const uint64_t lookupSerial = ++textureLookupSerial_;
     auto containsToken = [](const std::string& haystack, const char* token) {
         return haystack.find(token) != std::string::npos;
     };
@@ -678,10 +652,6 @@ VkTexture* CharacterRenderer::loadTexture(const std::string& path) {
         it->second.lastUse = ++textureCacheCounter_;
         return it->second.texture.get();
     }
-    auto failIt = failedTextureRetryAt_.find(key);
-    if (failIt != failedTextureRetryAt_.end() && lookupSerial < failIt->second) {
-        return whiteTexture_.get();
-    }
 
     if (!assetManager || !assetManager->isInitialized()) {
         return whiteTexture_.get();
@@ -700,9 +670,8 @@ VkTexture* CharacterRenderer::loadTexture(const std::string& path) {
         blpImage = assetManager->loadTexture(key);
     }
     if (!blpImage.isValid()) {
-        // Cache misses briefly to avoid repeated expensive MPQ/disk probes.
-        failedTextureCache_.insert(key);
-        failedTextureRetryAt_[key] = lookupSerial + kFailedTextureRetryLookups;
+        // Return white fallback but don't cache the failure — allow retry
+        // on next character load in case the asset becomes available.
         if (loggedTextureLoadFails_.insert(key).second) {
             core::Logger::getInstance().warning("Failed to load texture: ", path);
         }
@@ -715,7 +684,6 @@ VkTexture* CharacterRenderer::loadTexture(const std::string& path) {
         if (failedTextureCache_.size() < kMaxFailedTextureCache) {
             // Budget is saturated; avoid repeatedly decoding/uploading this texture.
             failedTextureCache_.insert(key);
-            failedTextureRetryAt_[key] = lookupSerial + kFailedTextureRetryLookups;
         }
         if (textureBudgetRejectWarnings_ < 3) {
             core::Logger::getInstance().warning(
@@ -757,36 +725,23 @@ VkTexture* CharacterRenderer::loadTexture(const std::string& path) {
         uint32_t w = blpImage.width, h = blpImage.height;
         std::string ck = key;
         std::vector<uint8_t> px(blpImage.data.begin(), blpImage.data.end());
-        // Use acq_rel so the increment is visible to shutdown()'s acquire load
-        // before the thread body begins (relaxed could delay visibility and cause
-        // shutdown() to see 0 and proceed while a thread is still running).
-        pendingNormalMapCount_.fetch_add(1, std::memory_order_acq_rel);
+        pendingNormalMapCount_.fetch_add(1, std::memory_order_relaxed);
         auto* self = this;
         std::thread([self, ck = std::move(ck), px = std::move(px), w, h]() mutable {
-            // try-catch guarantees the counter is decremented even if the compute
-            // throws (e.g., bad_alloc). Without this, shutdown() would deadlock
-            // waiting for a count that never reaches zero.
-            try {
-                auto result = generateNormalHeightMapCPU(std::move(ck), std::move(px), w, h);
-                {
-                    std::lock_guard<std::mutex> lock(self->normalMapResultsMutex_);
-                    self->completedNormalMaps_.push_back(std::move(result));
-                }
-            } catch (const std::exception& e) {
-                LOG_ERROR("Normal map generation failed: ", e.what());
-            }
-            if (self->pendingNormalMapCount_.fetch_sub(1, std::memory_order_release) == 1) {
-                self->normalMapDoneCV_.notify_one();
+            auto result = generateNormalHeightMapCPU(std::move(ck), std::move(px), w, h);
+            {
+                std::lock_guard<std::mutex> lock(self->normalMapResultsMutex_);
+                self->completedNormalMaps_.push_back(std::move(result));
             }
+            self->pendingNormalMapCount_.fetch_sub(1, std::memory_order_relaxed);
         }).detach();
         e.normalMapPending = true;
     }
 
     textureCacheBytes_ += e.approxBytes;
-    texturePropsByPtr_[texPtr] = {hasAlpha, colorKeyBlackHint};
+    textureHasAlphaByPtr_[texPtr] = hasAlpha;
+    textureColorKeyBlackByPtr_[texPtr] = colorKeyBlackHint;
     textureCache[key] = std::move(e);
-    failedTextureCache_.erase(key);
-    failedTextureRetryAt_.erase(key);
 
     core::Logger::getInstance().debug("Loaded character texture: ", path, " (", blpImage.width, "x", blpImage.height, ")");
     return texPtr;
@@ -1043,7 +998,7 @@ VkTexture* CharacterRenderer::compositeTextures(const std::vector<std::string>&
             int dstX = 0, dstY = 0;
             int expectedW256 = 0, expectedH256 = 0; // Expected size at 256-base
             std::string pathLower = layerPaths[layer];
-            for (auto& c : pathLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+            for (auto& c : pathLower) c = std::tolower(c);
 
             if (pathLower.find("faceupper") != std::string::npos) {
                 dstX = faceUpperRegion256.x; dstY = faceUpperRegion256.y;
@@ -1106,6 +1061,19 @@ VkTexture* CharacterRenderer::compositeTextures(const std::vector<std::string>&
         }
     }
 
+    // Debug: dump composite to temp dir for visual inspection
+    {
+        std::string dumpPath = (std::filesystem::temp_directory_path() / ("wowee_composite_debug_" +
+            std::to_string(width) + "x" + std::to_string(height) + ".raw")).string();
+        std::ofstream dump(dumpPath, std::ios::binary);
+        if (dump) {
+            dump.write(reinterpret_cast<const char*>(composite.data()),
+                       static_cast<std::streamsize>(composite.size()));
+            core::Logger::getInstance().info("Composite debug dump: ", dumpPath,
+                " (", width, "x", height, ", ", composite.size(), " bytes)");
+        }
+    }
+
     // Upload composite to GPU via VkTexture
     auto tex = std::make_unique<VkTexture>();
     tex->upload(*vkCtx_, composite.data(), width, height, VK_FORMAT_R8G8B8A8_UNORM, true);
@@ -1167,7 +1135,7 @@ VkTexture* CharacterRenderer::compositeWithRegions(const std::string& basePath,
 
     // Region index -> pixel coordinates on the 256x256 base atlas
     // These are scaled up by (width/256, height/256) for larger textures (512x512, 1024x1024)
-    static constexpr int regionCoords256[][2] = {
+    static const int regionCoords256[][2] = {
         {   0,   0 },  // 0 = ArmUpper
         {   0,  64 },  // 1 = ArmLower
         {   0, 128 },  // 2 = Hand
@@ -1212,17 +1180,17 @@ VkTexture* CharacterRenderer::compositeWithRegions(const std::string& basePath,
 
     // If base texture is 256x256 (e.g., baked NPC texture), upscale to 512x512
     // so equipment regions can be composited at correct coordinates
-    if (width == kBaseTexSize && height == kBaseTexSize && !regionLayers.empty()) {
-        width = kUpscaleTexSize;
-        height = kUpscaleTexSize;
+    if (width == 256 && height == 256 && !regionLayers.empty()) {
+        width = 512;
+        height = 512;
         composite.resize(width * height * 4);
         // Simple 2x nearest-neighbor upscale
-        for (int y = 0; y < kUpscaleTexSize; y++) {
-            for (int x = 0; x < kUpscaleTexSize; x++) {
+        for (int y = 0; y < 512; y++) {
+            for (int x = 0; x < 512; x++) {
                 int srcX = x / 2;
                 int srcY = y / 2;
-                int srcIdx = (srcY * kBaseTexSize + srcX) * 4;
-                int dstIdx = (y * kUpscaleTexSize + x) * 4;
+                int srcIdx = (srcY * 256 + srcX) * 4;
+                int dstIdx = (y * 512 + x) * 4;
                 composite[dstIdx + 0] = base.data[srcIdx + 0];
                 composite[dstIdx + 1] = base.data[srcIdx + 1];
                 composite[dstIdx + 2] = base.data[srcIdx + 2];
@@ -1237,7 +1205,7 @@ VkTexture* CharacterRenderer::compositeWithRegions(const std::string& basePath,
     // Blend face + underwear overlays
     // If we upscaled from 256->512, scale coords and texels with blitOverlayScaled2x.
     // For native 512/1024 textures, face overlays are full atlas size (hit width==width branch).
-    bool upscaled = (base.width == kBaseTexSize && base.height == kBaseTexSize && width == kUpscaleTexSize);
+    bool upscaled = (base.width == 256 && base.height == 256 && width == 512);
     for (const auto& ul : baseLayers) {
         if (ul.empty()) continue;
         pipeline::BLPImage overlay;
@@ -1261,7 +1229,7 @@ VkTexture* CharacterRenderer::compositeWithRegions(const std::string& basePath,
             // WoW 256-scale atlas coordinates (from CharComponentTextureSections)
             int dstX = 0, dstY = 0;
             std::string pathLower = ul;
-            for (auto& c : pathLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+            for (auto& c : pathLower) c = std::tolower(c);
 
             // Scale factor from 256-base coordinates to actual canvas size
             int coordScale = width / 256;
@@ -1308,7 +1276,7 @@ VkTexture* CharacterRenderer::compositeWithRegions(const std::string& basePath,
     }
 
     // Expected region sizes on the 256x256 base atlas (scaled like coords)
-    static constexpr int regionSizes256[][2] = {
+    static const int regionSizes256[][2] = {
         { 128,  64 },  // 0 = ArmUpper
         { 128,  64 },  // 1 = ArmLower
         { 128,  32 },  // 2 = Hand
@@ -1373,12 +1341,12 @@ VkTexture* CharacterRenderer::compositeWithRegions(const std::string& basePath,
                 blitOverlay(composite, width, height, overlay, dstX, dstY);
             }
         } else {
-            // Size mismatch — blit at natural size (may clip or leave gap)
-            core::Logger::getInstance().warning("compositeWithRegions: region ", regionIdx,
-                " at (", dstX, ",", dstY, ") overlay=", overlay.width, "x", overlay.height,
-                " expected=", expectedW, "x", expectedH, " from ", rl.second);
             blitOverlay(composite, width, height, overlay, dstX, dstY);
         }
+
+        core::Logger::getInstance().warning("compositeWithRegions: region ", regionIdx,
+            " at (", dstX, ",", dstY, ") overlay=", overlay.width, "x", overlay.height,
+            " expected=", expectedW, "x", expectedH, " from ", rl.second);
     }
 
     // Upload to GPU via VkTexture
@@ -1441,7 +1409,7 @@ bool CharacterRenderer::loadModel(const pipeline::M2Model& model, uint32_t id) {
 
     if (models.find(id) != models.end()) {
         core::Logger::getInstance().warning("Model ID ", id, " already loaded, replacing");
-        destroyModelGPU(models[id], /*defer=*/true);
+        destroyModelGPU(models[id]);
     }
 
     M2ModelGPU gpuModel;
@@ -1488,8 +1456,6 @@ void CharacterRenderer::setupModelBuffers(M2ModelGPU& gpuModel) {
     std::vector<glm::vec3> bitanAccum(vertCount, glm::vec3(0.0f));
 
     // Copy base vertex data
-    size_t numBones = model.bones.size();
-    int outOfRangeCount = 0, ge128Count = 0, nonzeroWeightOOR = 0;
     for (size_t i = 0; i < vertCount; i++) {
         const auto& src = model.vertices[i];
         auto& dst = gpuVerts[i];
@@ -1499,22 +1465,6 @@ void CharacterRenderer::setupModelBuffers(M2ModelGPU& gpuModel) {
         dst.normal = src.normal;
         dst.texCoords = src.texCoords[0]; // Use first UV set
         dst.tangent = glm::vec4(1.0f, 0.0f, 0.0f, 1.0f); // default
-
-        // Diagnostic: check bone indices
-        for (int j = 0; j < 4; j++) {
-            uint8_t bi = src.boneIndices[j];
-            uint8_t bw = src.boneWeights[j];
-            if (bi >= numBones) {
-                outOfRangeCount++;
-                if (bw > 0) nonzeroWeightOOR++;
-            }
-            if (bi >= 128) ge128Count++;
-        }
-    }
-    if (outOfRangeCount > 0 || ge128Count > 0) {
-        LOG_WARNING("VERTEX DIAG: model bones=", numBones, " verts=", vertCount,
-                    " outOfRange=", outOfRangeCount, " (nonzeroWeight=", nonzeroWeightOOR, ")",
-                    " ge128=", ge128Count);
     }
 
     // Accumulate tangent/bitangent per triangle
@@ -1644,20 +1594,12 @@ void CharacterRenderer::playAnimation(uint32_t instanceId, uint32_t animationId,
     instance.animationTime = 0.0f;
     instance.animationLoop = loop;
 
-    // Prefer variationIndex==0 (primary animation); fall back to first match
-    int firstMatch = -1;
     for (size_t i = 0; i < model.sequences.size(); i++) {
         if (model.sequences[i].id == animationId) {
-            if (firstMatch < 0) firstMatch = static_cast<int>(i);
-            if (model.sequences[i].variationIndex == 0) {
-                instance.currentSequenceIndex = static_cast<int>(i);
-                break;
-            }
+            instance.currentSequenceIndex = static_cast<int>(i);
+            break;
         }
     }
-    if (instance.currentSequenceIndex < 0 && firstMatch >= 0) {
-        instance.currentSequenceIndex = firstMatch;
-    }
 
     if (instance.currentSequenceIndex < 0) {
         // Fall back to first sequence
@@ -1704,6 +1646,10 @@ void CharacterRenderer::update(float deltaTime, const glm::vec3& cameraPos) {
             if (t >= 1.0f) {
                 inst.position = inst.moveEnd;
                 inst.isMoving = false;
+                // Return to idle when movement completes
+                if (inst.currentAnimationId == 4 || inst.currentAnimationId == 5) {
+                    playAnimation(pair.first, 0, true);
+                }
             } else {
                 inst.position = glm::mix(inst.moveStart, inst.moveEnd, t);
             }
@@ -1715,9 +1661,6 @@ void CharacterRenderer::update(float deltaTime, const glm::vec3& cameraPos) {
         float distSq = glm::distance2(inst.position, cameraPos);
         if (distSq >= animUpdateRadiusSq) continue;
 
-        // Advance global sequence timer (accumulates independently of animation wrapping)
-        inst.globalSequenceTime += deltaTime * 1000.0f;
-
         // Always advance animation time (cheap)
         if (inst.cachedModel && !inst.cachedModel->data.sequences.empty()) {
             if (inst.currentSequenceIndex < 0) {
@@ -1728,21 +1671,9 @@ void CharacterRenderer::update(float deltaTime, const glm::vec3& cameraPos) {
             inst.animationTime += deltaTime * 1000.0f;
             if (seq.duration > 0 && inst.animationTime >= static_cast<float>(seq.duration)) {
                 if (inst.animationLoop) {
-                    // Subtract duration instead of fmod to preserve float precision
-                    // fmod() loses precision with large animationTime values
-                    inst.animationTime -= static_cast<float>(seq.duration);
-                    // Clamp to [0, duration) to handle multiple loops in one frame
-                    while (inst.animationTime >= static_cast<float>(seq.duration)) {
-                        inst.animationTime -= static_cast<float>(seq.duration);
-                    }
+                    inst.animationTime = std::fmod(inst.animationTime, static_cast<float>(seq.duration));
                 } else {
-                    // One-shot animation finished: return to Stand unless dead
-                    if (inst.currentAnimationId != anim::DEATH) {
-                        playAnimation(pair.first, anim::STAND, true);
-                    } else {
-                        // Stay on last frame of death
-                        inst.animationTime = static_cast<float>(seq.duration);
-                    }
+                    inst.animationTime = static_cast<float>(seq.duration);
                 }
             }
         }
@@ -1879,29 +1810,6 @@ int CharacterRenderer::findKeyframeIndex(const std::vector<uint32_t>& timestamps
     return static_cast<int>(std::min(idx, timestamps.size() - 2));
 }
 
-// Resolve sequence index and time for a track, handling global sequences.
-// globalSeqTime is a separate accumulating timer that is NOT wrapped at the
-// current animation's sequence duration, so global sequences get full range.
-static void resolveTrackTime(const pipeline::M2AnimationTrack& track,
-                              int seqIdx, float animTime, float globalSeqTime,
-                              const std::vector<uint32_t>& globalSeqDurations,
-                              int& outSeqIdx, float& outTime) {
-    if (track.globalSequence >= 0 &&
-        static_cast<size_t>(track.globalSequence) < globalSeqDurations.size()) {
-        outSeqIdx = 0;
-        float dur = static_cast<float>(globalSeqDurations[track.globalSequence]);
-        if (dur > 0.0f) {
-            outTime = std::fmod(globalSeqTime, dur);
-            if (outTime < 0.0f) outTime += dur;
-        } else {
-            outTime = 0.0f;
-        }
-    } else {
-        outSeqIdx = seqIdx;
-        outTime = animTime;
-    }
-}
-
 glm::vec3 CharacterRenderer::interpolateVec3(const pipeline::M2AnimationTrack& track,
                                               int seqIdx, float time, const glm::vec3& defaultVal) {
     if (!track.hasData()) return defaultVal;
@@ -1982,28 +1890,12 @@ void CharacterRenderer::calculateBoneMatrices(CharacterInstance& instance) {
     size_t numBones = model.bones.size();
     instance.boneMatrices.resize(numBones);
 
-    const auto& gsd = model.globalSequenceDurations;
-
-    // One-time diagnostic: check bone ordering (parents must precede children)
-    static bool checkedBoneOrder = false;
-    if (!checkedBoneOrder) {
-        checkedBoneOrder = true;
-        for (size_t i = 0; i < numBones; i++) {
-            const auto& bone = model.bones[i];
-            if (bone.parentBone >= 0 && static_cast<size_t>(bone.parentBone) >= i) {
-                LOG_WARNING("Bone ", i, " references parent ", bone.parentBone,
-                            " which comes AFTER it — will use stale matrix!");
-            }
-        }
-    }
-
     for (size_t i = 0; i < numBones; i++) {
         const auto& bone = model.bones[i];
 
         // Local transform includes pivot bracket: T(pivot)*T*R*S*T(-pivot)
         // At rest this is identity, so no separate bind pose is needed
-        glm::mat4 localTransform = getBoneTransform(bone, instance.animationTime, instance.globalSequenceTime,
-                                                    instance.currentSequenceIndex, gsd);
+        glm::mat4 localTransform = getBoneTransform(bone, instance.animationTime, instance.currentSequenceIndex);
 
         // Compose with parent
         if (bone.parentBone >= 0 && static_cast<size_t>(bone.parentBone) < numBones) {
@@ -2011,43 +1903,13 @@ void CharacterRenderer::calculateBoneMatrices(CharacterInstance& instance) {
         } else {
             instance.boneMatrices[i] = localTransform;
         }
-
-        // Diagnostic: detect bones with extreme translation
-        float tx = std::abs(instance.boneMatrices[i][3][0]);
-        float ty = std::abs(instance.boneMatrices[i][3][1]);
-        float tz = std::abs(instance.boneMatrices[i][3][2]);
-        static int diagFrames = 0;
-        if (diagFrames < 3 && (tx > 50.0f || ty > 50.0f || tz > 50.0f)) {
-            LOG_WARNING("BONE DIAG: bone[", i, "] keyBone=", bone.keyBoneId,
-                        " flags=0x", std::hex, bone.flags, std::dec,
-                        " parent=", bone.parentBone,
-                        " pivot=(", bone.pivot.x, ",", bone.pivot.y, ",", bone.pivot.z, ")",
-                        " mat_t=(", instance.boneMatrices[i][3][0], ",",
-                        instance.boneMatrices[i][3][1], ",", instance.boneMatrices[i][3][2], ")",
-                        " local_t=(", localTransform[3][0], ",", localTransform[3][1], ",",
-                        localTransform[3][2], ")",
-                        " animTime=", instance.animationTime,
-                        " gsTime=", instance.globalSequenceTime,
-                        " seqIdx=", instance.currentSequenceIndex);
-        }
-        if (i == numBones - 1) diagFrames++;
     }
 }
 
-glm::mat4 CharacterRenderer::getBoneTransform(const pipeline::M2Bone& bone, float animTime, float globalSeqTime,
-                                               int sequenceIndex, const std::vector<uint32_t>& globalSeqDurations) {
-    // Resolve global sequences: bones with globalSequence >= 0 use sequence 0
-    // with time wrapped at the global sequence duration, independent of the
-    // character's current animation.
-    int tSeq, rSeq, sSeq;
-    float tTime, rTime, sTime;
-    resolveTrackTime(bone.translation, sequenceIndex, animTime, globalSeqTime, globalSeqDurations, tSeq, tTime);
-    resolveTrackTime(bone.rotation, sequenceIndex, animTime, globalSeqTime, globalSeqDurations, rSeq, rTime);
-    resolveTrackTime(bone.scale, sequenceIndex, animTime, globalSeqTime, globalSeqDurations, sSeq, sTime);
-
-    glm::vec3 translation = interpolateVec3(bone.translation, tSeq, tTime, glm::vec3(0.0f));
-    glm::quat rotation = interpolateQuat(bone.rotation, rSeq, rTime);
-    glm::vec3 scale = interpolateVec3(bone.scale, sSeq, sTime, glm::vec3(1.0f));
+glm::mat4 CharacterRenderer::getBoneTransform(const pipeline::M2Bone& bone, float time, int sequenceIndex) {
+    glm::vec3 translation = interpolateVec3(bone.translation, sequenceIndex, time, glm::vec3(0.0f));
+    glm::quat rotation = interpolateQuat(bone.rotation, sequenceIndex, time);
+    glm::vec3 scale = interpolateVec3(bone.scale, sequenceIndex, time, glm::vec3(1.0f));
 
     // M2 bone transform: T(pivot) * T(trans) * R(rot) * S(scale) * T(-pivot)
     // At rest (no animation): T(pivot) * I * I * I * T(-pivot) = identity
@@ -2082,13 +1944,6 @@ void CharacterRenderer::prepareRender(uint32_t frameIndex) {
                             &instance.boneBuffer[frameIndex], &instance.boneAlloc[frameIndex], &allocInfo);
             instance.boneMapped[frameIndex] = allocInfo.pMappedData;
 
-            // Initialize all bone slots to identity so out-of-range indices
-            // produce correct (neutral) transforms instead of GPU garbage
-            if (instance.boneMapped[frameIndex]) {
-                auto* dst = static_cast<glm::mat4*>(instance.boneMapped[frameIndex]);
-                for (int j = 0; j < MAX_BONES; j++) dst[j] = glm::mat4(1.0f);
-            }
-
             VkDescriptorSetAllocateInfo ai{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
             ai.descriptorPool = boneDescPool_;
             ai.descriptorSetCount = 1;
@@ -2124,18 +1979,16 @@ void CharacterRenderer::prepareRender(uint32_t frameIndex) {
     }
 }
 
-void CharacterRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const Camera& camera) {
+void CharacterRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, [[maybe_unused]] const Camera& camera) {
     if (instances.empty() || !opaquePipeline_) {
         return;
     }
     const float renderRadius = static_cast<float>(envSizeOrDefault("WOWEE_CHAR_RENDER_RADIUS", 130));
     const float renderRadiusSq = renderRadius * renderRadius;
-    const float characterCullRadius = 2.0f;  // Estimate character radius for frustum testing
+    const float nearNoConeCullSq = 16.0f * 16.0f;
+    const float backfaceDotCull = -0.30f;
     const glm::vec3 camPos = camera.getPosition();
-
-    // Extract frustum planes for per-instance visibility testing
-    Frustum frustum;
-    frustum.extractFromMatrix(camera.getViewProjectionMatrix());
+    const glm::vec3 camForward = camera.getForward();
 
     uint32_t frameIndex = vkCtx_->getCurrentFrame();
     uint32_t frameSlot = frameIndex % 2u;
@@ -2161,22 +2014,27 @@ void CharacterRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet,
     VkPipeline currentPipeline = opaquePipeline_;
     vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, currentPipeline);
 
-    for (auto& pair : instances) {
-        auto& instance = pair.second;
+    for (const auto& pair : instances) {
+        const auto& instance = pair.second;
 
         // Skip invisible instances (e.g., player in first-person mode)
         if (!instance.visible) continue;
-
-        // Character instance culling: test both distance and frustum visibility
+        // Character instance culling: avoid drawing far-away / strongly behind-camera
+        // actors in dense city scenes.
         if (!instance.hasOverrideModelMatrix) {
             glm::vec3 toInst = instance.position - camPos;
             float distSq = glm::dot(toInst, toInst);
-
-            // Distance cull: skip if beyond render radius
             if (distSq > renderRadiusSq) continue;
-
-            // Frustum cull: skip if outside view frustum
-            if (!frustum.intersectsSphere(instance.position, characterCullRadius)) continue;
+            if (distSq > nearNoConeCullSq) {
+                // Backface cull without sqrt: dot(toInst, camFwd) / |toInst| < threshold
+                // ⟺ dot < 0 || dot² < threshold² * distSq  (when threshold < 0, dot must be negative)
+                float rawDot = glm::dot(toInst, camForward);
+                if (backfaceDotCull >= 0.0f) {
+                    if (rawDot < 0.0f || rawDot * rawDot < backfaceDotCull * backfaceDotCull * distSq) continue;
+                } else {
+                    if (rawDot < 0.0f && rawDot * rawDot > backfaceDotCull * backfaceDotCull * distSq) continue;
+                }
+            }
         }
 
         if (!instance.cachedModel) continue;
@@ -2200,7 +2058,8 @@ void CharacterRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet,
         int numBones = std::min(static_cast<int>(instance.boneMatrices.size()), MAX_BONES);
         if (numBones > 0) {
             // Lazy-allocate bone SSBO on first use
-            if (!instance.boneBuffer[frameIndex]) {
+            auto& instMut = const_cast<CharacterInstance&>(instance);
+            if (!instMut.boneBuffer[frameIndex]) {
                 VkBufferCreateInfo bci{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
                 bci.size = MAX_BONES * sizeof(glm::mat4);
                 bci.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
@@ -2209,41 +2068,34 @@ void CharacterRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet,
                 aci.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
                 VmaAllocationInfo allocInfo{};
                 vmaCreateBuffer(vkCtx_->getAllocator(), &bci, &aci,
-                                &instance.boneBuffer[frameIndex], &instance.boneAlloc[frameIndex], &allocInfo);
-                instance.boneMapped[frameIndex] = allocInfo.pMappedData;
-
-                // Initialize all bone slots to identity so out-of-range indices
-                // produce correct (neutral) transforms instead of GPU garbage
-                if (instance.boneMapped[frameIndex]) {
-                    auto* dst = static_cast<glm::mat4*>(instance.boneMapped[frameIndex]);
-                    for (int j = 0; j < MAX_BONES; j++) dst[j] = glm::mat4(1.0f);
-                }
+                                &instMut.boneBuffer[frameIndex], &instMut.boneAlloc[frameIndex], &allocInfo);
+                instMut.boneMapped[frameIndex] = allocInfo.pMappedData;
 
                 // Allocate descriptor set for bone SSBO
                 VkDescriptorSetAllocateInfo ai{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
                 ai.descriptorPool = boneDescPool_;
                 ai.descriptorSetCount = 1;
                 ai.pSetLayouts = &boneSetLayout_;
-                VkResult dsRes = vkAllocateDescriptorSets(vkCtx_->getDevice(), &ai, &instance.boneSet[frameIndex]);
+                VkResult dsRes = vkAllocateDescriptorSets(vkCtx_->getDevice(), &ai, &instMut.boneSet[frameIndex]);
                 if (dsRes != VK_SUCCESS) {
                     LOG_ERROR("CharacterRenderer: bone descriptor allocation failed (instance=",
-                              instance.id, ", frame=", frameIndex, ", vk=", static_cast<int>(dsRes), ")");
-                    if (instance.boneBuffer[frameIndex]) {
+                              instMut.id, ", frame=", frameIndex, ", vk=", static_cast<int>(dsRes), ")");
+                    if (instMut.boneBuffer[frameIndex]) {
                         vmaDestroyBuffer(vkCtx_->getAllocator(),
-                                         instance.boneBuffer[frameIndex], instance.boneAlloc[frameIndex]);
-                        instance.boneBuffer[frameIndex] = VK_NULL_HANDLE;
-                        instance.boneAlloc[frameIndex] = VK_NULL_HANDLE;
-                        instance.boneMapped[frameIndex] = nullptr;
+                                         instMut.boneBuffer[frameIndex], instMut.boneAlloc[frameIndex]);
+                        instMut.boneBuffer[frameIndex] = VK_NULL_HANDLE;
+                        instMut.boneAlloc[frameIndex] = VK_NULL_HANDLE;
+                        instMut.boneMapped[frameIndex] = nullptr;
                     }
                 }
 
-                if (instance.boneSet[frameIndex]) {
+                if (instMut.boneSet[frameIndex]) {
                     VkDescriptorBufferInfo bufInfo{};
-                    bufInfo.buffer = instance.boneBuffer[frameIndex];
+                    bufInfo.buffer = instMut.boneBuffer[frameIndex];
                     bufInfo.offset = 0;
                     bufInfo.range = bci.size;
                     VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
-                    write.dstSet = instance.boneSet[frameIndex];
+                    write.dstSet = instMut.boneSet[frameIndex];
                     write.dstBinding = 0;
                     write.descriptorCount = 1;
                     write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
@@ -2253,15 +2105,15 @@ void CharacterRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet,
             }
 
             // Upload bone matrices
-            if (instance.boneMapped[frameIndex]) {
-                memcpy(instance.boneMapped[frameIndex], instance.boneMatrices.data(),
+            if (instMut.boneMapped[frameIndex]) {
+                memcpy(instMut.boneMapped[frameIndex], instance.boneMatrices.data(),
                        numBones * sizeof(glm::mat4));
             }
 
             // Bind bone descriptor set (set 2)
-            if (instance.boneSet[frameIndex]) {
+            if (instMut.boneSet[frameIndex]) {
                 vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                        pipelineLayout_, 2, 1, &instance.boneSet[frameIndex], 0, nullptr);
+                                        pipelineLayout_, 2, 1, &instMut.boneSet[frameIndex], 0, nullptr);
             }
         }
 
@@ -2355,65 +2207,13 @@ void CharacterRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet,
                 return whiteTexture_.get();
             };
 
-            // One-time batch diagnostic for first character instance
-            static bool batchDiagDone = false;
-            if (!batchDiagDone && !instance.hasOverrideModelMatrix) {
-                batchDiagDone = true;
-                for (const auto& b : gpuModel.data.batches) {
-                    uint16_t bm = 0, mf = 0;
-                    if (b.materialIndex < gpuModel.data.materials.size()) {
-                        bm = gpuModel.data.materials[b.materialIndex].blendMode;
-                        mf = gpuModel.data.materials[b.materialIndex].flags;
-                    }
-                    uint16_t bg = static_cast<uint16_t>(b.submeshId / 100);
-                    bool active = instance.activeGeosets.empty() ||
-                                  instance.activeGeosets.count(b.submeshId);
-                    LOG_WARNING("BATCH DIAG: submesh=", b.submeshId, " group=", bg,
-                                " blend=", bm, " matFlags=0x", std::hex, mf, std::dec,
-                                " texIdx=", b.textureIndex, " matIdx=", b.materialIndex,
-                                " active=", active);
-                }
-            }
-
-            // Draw batches in two passes: opaque (blendMode 0) first, then
-            // alpha-key/blend after.  This ensures capes and body parts write
-            // depth before hair overlay, preventing hair→cape z-fight.
-            auto getBatchBlendMode = [&](const pipeline::M2Batch& b) -> uint16_t {
-                if (b.materialIndex < gpuModel.data.materials.size())
-                    return gpuModel.data.materials[b.materialIndex].blendMode;
-                return 0;
-            };
-
-            // Sort batches by (priorityPlane, materialLayer) so equipment layers
-            // render in the order the M2 format intends. priorityPlane separates
-            // overlay effects; materialLayer orders coplanar body parts.
-            std::vector<size_t> sortedBatchIndices(gpuModel.data.batches.size());
-            std::iota(sortedBatchIndices.begin(), sortedBatchIndices.end(), 0);
-            std::stable_sort(sortedBatchIndices.begin(), sortedBatchIndices.end(),
-                [&](size_t a, size_t b) {
-                    const auto& ba = gpuModel.data.batches[a];
-                    const auto& bb = gpuModel.data.batches[b];
-                    if (ba.priorityPlane != bb.priorityPlane)
-                        return ba.priorityPlane < bb.priorityPlane;
-                    return ba.materialLayer < bb.materialLayer;
-                });
-
-            for (int pass = 0; pass < 2; pass++) {
-            for (size_t bi : sortedBatchIndices) {
-                const auto& batch = gpuModel.data.batches[bi];
-                uint16_t bm = getBatchBlendMode(batch);
-                if (pass == 0 && bm != 0) continue;  // pass 0: opaque only
-                if (pass == 1 && bm == 0) continue;   // pass 1: non-opaque only
+            // One-time debug dump of rendered batches per model
+            // Draw batches (submeshes) with per-batch textures
+            for (const auto& batch : gpuModel.data.batches) {
                 if (applyGeosetFilter) {
                     if (instance.activeGeosets.find(batch.submeshId) == instance.activeGeosets.end()) {
                         continue;
                     }
-                } else {
-                    // Even without a geoset filter, skip eye glow (group 17)
-                    // and group 18 unless explicitly opted in. These geosets are
-                    // only for DK/NE eye glow and should be off by default.
-                    uint16_t grp = batch.submeshId / 100;
-                    if (grp == 17 || grp == 18) continue;
                 }
 
                 // Resolve texture for this batch (prefer hair textures for hair geosets).
@@ -2491,11 +2291,10 @@ void CharacterRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet,
                 bool alphaCutout = false;
                 bool colorKeyBlack = false;
                 if (texPtr != nullptr && texPtr != whiteTexture_.get()) {
-                    auto pit = texturePropsByPtr_.find(texPtr);
-                    if (pit != texturePropsByPtr_.end()) {
-                        alphaCutout = pit->second.hasAlpha;
-                        colorKeyBlack = pit->second.colorKeyBlack;
-                    }
+                    auto ait = textureHasAlphaByPtr_.find(texPtr);
+                    alphaCutout = (ait != textureHasAlphaByPtr_.end()) ? ait->second : false;
+                    auto cit = textureColorKeyBlackByPtr_.find(texPtr);
+                    colorKeyBlack = (cit != textureColorKeyBlackByPtr_.end()) ? cit->second : false;
                 }
                 const bool blendNeedsCutout = (blendMode == 1) || (blendMode >= 2 && !alphaCutout);
                 const bool unlit = ((materialFlags & 0x01) != 0) || (blendMode >= 3);
@@ -2560,7 +2359,7 @@ void CharacterRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet,
                 // Create per-batch material UBO
                 CharMaterialUBO matData{};
                 matData.opacity = instance.opacity;
-                matData.alphaTest = blendNeedsCutout ? 1 : 0;
+                matData.alphaTest = (blendNeedsCutout || alphaCutout) ? 1 : 0;
                 matData.colorKeyBlack = (blendNeedsCutout || colorKeyBlack) ? 1 : 0;
                 matData.unlit = unlit ? 1 : 0;
                 matData.emissiveBoost = emissiveBoost;
@@ -2618,13 +2417,8 @@ void CharacterRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet,
                 vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
                                         pipelineLayout_, 1, 1, &materialSet, 0, nullptr);
 
-                // Per-batch depth bias from materialLayer to separate coplanar
-                // armor pieces (chest/legs/gloves) that share identical depth.
-                vkCmdSetDepthBias(cmd, static_cast<float>(batch.materialLayer) * 0.5f, 0.0f, 0.0f);
-
                 vkCmdDrawIndexed(cmd, batch.indexCount, 1, batch.indexStart, 0, 0);
             }
-            } // end pass loop
         } else {
             // Draw entire model with first texture
             VkTexture* texPtr = !gpuModel.textureIds.empty() ? gpuModel.textureIds[0] : whiteTexture_.get();
@@ -2834,7 +2628,7 @@ bool CharacterRenderer::initializeShadow(VkRenderPass shadowRenderPass) {
     // Character vertex format (CharVertexGPU): stride = 56 bytes
     // loc 0: vec3 aPos          (R32G32B32_SFLOAT, offset 0)
     // loc 1: vec4 aBoneWeights  (R8G8B8A8_UNORM,   offset 12)
-    // loc 2: ivec4 aBoneIndices (R8G8B8A8_SINT,    offset 16)
+    // loc 2: ivec4 aBoneIndices (R8G8B8A8_UINT,    offset 16)
     // loc 3: vec2 aTexCoord     (R32G32_SFLOAT,    offset 32)
     VkVertexInputBindingDescription vertBind{};
     vertBind.binding = 0;
@@ -2843,7 +2637,7 @@ bool CharacterRenderer::initializeShadow(VkRenderPass shadowRenderPass) {
     std::vector<VkVertexInputAttributeDescription> vertAttrs = {
         {0, 0, VK_FORMAT_R32G32B32_SFLOAT, static_cast<uint32_t>(offsetof(CharVertexGPU, position))},
         {1, 0, VK_FORMAT_R8G8B8A8_UNORM,   static_cast<uint32_t>(offsetof(CharVertexGPU, boneWeights))},
-        {2, 0, VK_FORMAT_R8G8B8A8_SINT,    static_cast<uint32_t>(offsetof(CharVertexGPU, boneIndices))},
+        {2, 0, VK_FORMAT_R8G8B8A8_UINT,    static_cast<uint32_t>(offsetof(CharVertexGPU, boneIndices))},
         {3, 0, VK_FORMAT_R32G32_SFLOAT,    static_cast<uint32_t>(offsetof(CharVertexGPU, texCoords))},
     };
 
@@ -2859,7 +2653,7 @@ bool CharacterRenderer::initializeShadow(VkRenderPass shadowRenderPass) {
         .setLayout(shadowPipelineLayout_)
         .setRenderPass(shadowRenderPass)
         .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     vertShader.destroy();
     fragShader.destroy();
@@ -2885,6 +2679,8 @@ void CharacterRenderer::renderShadow(VkCommandBuffer cmd, const glm::mat4& light
     vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, shadowPipelineLayout_,
         1, 1, &shadowParamsSet_, 0, nullptr);
 
+    struct ShadowPush { glm::mat4 lightSpaceMatrix; glm::mat4 model; };
+
     const float shadowRadiusSq = shadowRadius * shadowRadius;
     for (auto& pair : instances) {
         auto& inst = pair.second;
@@ -2917,13 +2713,6 @@ void CharacterRenderer::renderShadow(VkCommandBuffer cmd, const glm::mat4& light
                     &inst.boneBuffer[frameIndex], &inst.boneAlloc[frameIndex], &ai);
                 inst.boneMapped[frameIndex] = ai.pMappedData;
 
-                // Initialize all bone slots to identity so out-of-range indices
-                // produce correct (neutral) transforms instead of GPU garbage
-                if (inst.boneMapped[frameIndex]) {
-                    auto* dst = static_cast<glm::mat4*>(inst.boneMapped[frameIndex]);
-                    for (int j = 0; j < MAX_BONES; j++) dst[j] = glm::mat4(1.0f);
-                }
-
                 VkDescriptorSetAllocateInfo dsAI{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
                 dsAI.descriptorPool = boneDescPool_;
                 dsAI.descriptorSetCount = 1;
@@ -2983,10 +2772,6 @@ void CharacterRenderer::renderShadow(VkCommandBuffer cmd, const glm::mat4& light
             if (blendMode >= 2) continue; // skip transparent
             if (applyGeosetFilter &&
                 inst.activeGeosets.find(batch.submeshId) == inst.activeGeosets.end()) continue;
-            if (!applyGeosetFilter) {
-                uint16_t grp = batch.submeshId / 100;
-                if (grp == 17 || grp == 18) continue;
-            }
             vkCmdDrawIndexed(cmd, batch.indexCount, 1, batch.indexStart, 0, 0);
         }
     }
@@ -3044,23 +2829,22 @@ void CharacterRenderer::moveInstanceTo(uint32_t instanceId, const glm::vec3& des
         return 0;
     };
 
-    float pdx = destination.x - inst.position.x;
-    float pdy = destination.y - inst.position.y;
-    float planarDistSq = pdx * pdx + pdy * pdy;
+    float planarDist = glm::length(glm::vec2(destination.x - inst.position.x,
+                                             destination.y - inst.position.y));
     bool synthesizedDuration = false;
     if (durationSeconds <= 0.0f) {
-        if (planarDistSq < 1e-4f) {
+        if (planarDist < 0.01f) {
             // Stop at current location.
             inst.position = destination;
             inst.isMoving = false;
-            if (inst.currentAnimationId == anim::WALK || inst.currentAnimationId == anim::RUN) {
-                playAnimation(instanceId, anim::STAND, true);
+            if (inst.currentAnimationId == 4 || inst.currentAnimationId == 5) {
+                playAnimation(instanceId, 0, true);
             }
             return;
         }
         // Some cores send movement-only deltas without spline duration.
         // Synthesize a tiny duration so movement anim/rotation still updates.
-        durationSeconds = std::clamp(std::sqrt(planarDistSq) / 7.0f, 0.05f, 0.20f);
+        durationSeconds = std::clamp(planarDist / 7.0f, 0.05f, 0.20f);
         synthesizedDuration = true;
     }
 
@@ -3072,14 +2856,14 @@ void CharacterRenderer::moveInstanceTo(uint32_t instanceId, const glm::vec3& des
 
     // Face toward destination (yaw around Z axis since Z is up)
     glm::vec3 dir = destination - inst.position;
-    if (dir.x * dir.x + dir.y * dir.y > 1e-6f) {
+    if (glm::length(glm::vec2(dir.x, dir.y)) > 0.001f) {
         float angle = std::atan2(dir.y, dir.x);
         inst.rotation.z = angle;
     }
 
     // Play movement animation while moving.
     // Prefer run only when speed is clearly above normal walk pace.
-    float moveSpeed = std::sqrt(planarDistSq) / std::max(durationSeconds, 0.001f);
+    float moveSpeed = planarDist / std::max(durationSeconds, 0.001f);
     bool preferRun = (!synthesizedDuration && moveSpeed >= 4.5f);
     uint32_t moveAnim = pickMoveAnim(preferRun);
     if (moveAnim != 0 && inst.currentAnimationId != moveAnim) {
@@ -3101,15 +2885,6 @@ void CharacterRenderer::startFadeIn(uint32_t instanceId, float durationSeconds)
     it->second.fadeInDuration = durationSeconds;
 }
 
-void CharacterRenderer::setInstanceOpacity(uint32_t instanceId, float opacity) {
-    auto it = instances.find(instanceId);
-    if (it != instances.end()) {
-        it->second.opacity = std::clamp(opacity, 0.0f, 1.0f);
-        // Cancel any fade-in in progress to avoid overwriting the new opacity
-        it->second.fadeInDuration = 0.0f;
-    }
-}
-
 void CharacterRenderer::setActiveGeosets(uint32_t instanceId, const std::unordered_set<uint16_t>& geosets) {
     auto it = instances.find(instanceId);
     if (it != instances.end()) {
@@ -3172,9 +2947,8 @@ void CharacterRenderer::removeInstance(uint32_t instanceId) {
         removeInstance(wa.weaponInstanceId);
     }
 
-    // Defer bone buffer destruction — in-flight command buffers may still
-    // reference these descriptor sets.
-    destroyInstanceBones(it->second, /*defer=*/true);
+    // Destroy bone buffers for this instance
+    destroyInstanceBones(it->second);
 
     instances.erase(it);
 }
@@ -3252,65 +3026,6 @@ bool CharacterRenderer::getInstanceModelName(uint32_t instanceId, std::string& m
     return !modelName.empty();
 }
 
-bool CharacterRenderer::findAttachmentBone(uint32_t modelId, uint32_t attachmentId,
-                                          uint16_t& outBoneIndex, glm::vec3& outOffset) const {
-    auto modelIt = models.find(modelId);
-    if (modelIt == models.end()) return false;
-    const auto& model = modelIt->second.data;
-
-    outBoneIndex = 0;
-    outOffset = glm::vec3(0.0f);
-    bool found = false;
-
-    // Try attachment lookup first
-    if (attachmentId < model.attachmentLookup.size()) {
-        uint16_t attIdx = model.attachmentLookup[attachmentId];
-        if (attIdx < model.attachments.size()) {
-            outBoneIndex = model.attachments[attIdx].bone;
-            outOffset = model.attachments[attIdx].position;
-            found = true;
-        }
-    }
-
-    // Fallback: scan attachments by id
-    if (!found) {
-        for (const auto& att : model.attachments) {
-            if (att.id == attachmentId) {
-                outBoneIndex = att.bone;
-                outOffset = att.position;
-                found = true;
-                break;
-            }
-        }
-    }
-
-    // Fallback: key-bone lookup for weapon hand attachment IDs (ID 1 = right hand, ID 2 = left hand)
-    if (!found && (attachmentId == 1 || attachmentId == 2)) {
-        int32_t targetKeyBone = (attachmentId == 1) ? 26 : 27;
-        for (size_t i = 0; i < model.bones.size(); i++) {
-            if (model.bones[i].keyBoneId == targetKeyBone) {
-                outBoneIndex = static_cast<uint16_t>(i);
-                outOffset = glm::vec3(0.0f);
-                found = true;
-                break;
-            }
-        }
-    }
-
-    // Fallback for head attachment (ID 11): use bone 0 if attachment not defined
-    if (!found && attachmentId == 11 && model.bones.size() > 0) {
-        outBoneIndex = 0;
-        found = true;
-    }
-
-    // Validate bone index
-    if (found && outBoneIndex >= model.bones.size()) {
-        found = false;
-    }
-
-    return found;
-}
-
 bool CharacterRenderer::attachWeapon(uint32_t charInstanceId, uint32_t attachmentId,
                                       const pipeline::M2Model& weaponModel, uint32_t weaponModelId,
                                       const std::string& texturePath) {
@@ -3322,11 +3037,62 @@ bool CharacterRenderer::attachWeapon(uint32_t charInstanceId, uint32_t attachmen
     auto& charInstance = charIt->second;
     auto charModelIt = models.find(charInstance.modelId);
     if (charModelIt == models.end()) return false;
+    const auto& charModel = charModelIt->second.data;
 
     // Find bone index for this attachment point
     uint16_t boneIndex = 0;
     glm::vec3 offset(0.0f);
-    if (!findAttachmentBone(charInstance.modelId, attachmentId, boneIndex, offset)) {
+    bool found = false;
+
+    // Try attachment lookup first
+    if (attachmentId < charModel.attachmentLookup.size()) {
+        uint16_t attIdx = charModel.attachmentLookup[attachmentId];
+        if (attIdx < charModel.attachments.size()) {
+            boneIndex = charModel.attachments[attIdx].bone;
+            offset = charModel.attachments[attIdx].position;
+            found = true;
+        }
+    }
+    // Fallback: scan attachments by id
+    if (!found) {
+        for (const auto& att : charModel.attachments) {
+            if (att.id == attachmentId) {
+                boneIndex = att.bone;
+                offset = att.position;
+                found = true;
+                break;
+            }
+        }
+    }
+    // Fallback to key-bone lookup only for weapon hand attachment IDs.
+    if (!found && (attachmentId == 1 || attachmentId == 2)) {
+        int32_t targetKeyBone = (attachmentId == 1) ? 26 : 27;
+        for (size_t i = 0; i < charModel.bones.size(); i++) {
+            if (charModel.bones[i].keyBoneId == targetKeyBone) {
+                boneIndex = static_cast<uint16_t>(i);
+                found = true;
+                break;
+            }
+        }
+    }
+
+    // Validate bone index (bad attachment tables should not silently bind to origin)
+    if (found && boneIndex >= charModel.bones.size()) {
+        found = false;
+    }
+    if (!found && (attachmentId == 1 || attachmentId == 2)) {
+        int32_t targetKeyBone = (attachmentId == 1) ? 26 : 27;
+        for (size_t i = 0; i < charModel.bones.size(); i++) {
+            if (charModel.bones[i].keyBoneId == targetKeyBone) {
+                boneIndex = static_cast<uint16_t>(i);
+                offset = glm::vec3(0.0f);
+                found = true;
+                break;
+            }
+        }
+    }
+
+    if (!found) {
         core::Logger::getInstance().warning("attachWeapon: no bone found for attachment ", attachmentId);
         return false;
     }
@@ -3409,13 +3175,6 @@ bool CharacterRenderer::getInstanceFootZ(uint32_t instanceId, float& outFootZ) c
     return true;
 }
 
-bool CharacterRenderer::getInstancePosition(uint32_t instanceId, glm::vec3& outPos) const {
-    auto it = instances.find(instanceId);
-    if (it == instances.end()) return false;
-    outPos = it->second.position;
-    return true;
-}
-
 void CharacterRenderer::detachWeapon(uint32_t charInstanceId, uint32_t attachmentId) {
     auto charIt = instances.find(charInstanceId);
     if (charIt == instances.end()) return;
@@ -3437,11 +3196,57 @@ bool CharacterRenderer::getAttachmentTransform(uint32_t instanceId, uint32_t att
     if (instIt == instances.end()) return false;
     const auto& instance = instIt->second;
 
-    // Find attachment point using shared lookup logic
+    auto modelIt = models.find(instance.modelId);
+    if (modelIt == models.end()) return false;
+    const auto& model = modelIt->second.data;
+
+    // Find attachment point
     uint16_t boneIndex = 0;
     glm::vec3 offset(0.0f);
-    if (!findAttachmentBone(instance.modelId, attachmentId, boneIndex, offset)) {
-        return false;
+    bool found = false;
+
+    // Try attachment lookup first
+    if (attachmentId < model.attachmentLookup.size()) {
+        uint16_t attIdx = model.attachmentLookup[attachmentId];
+        if (attIdx < model.attachments.size()) {
+            boneIndex = model.attachments[attIdx].bone;
+            offset = model.attachments[attIdx].position;
+            found = true;
+        }
+    }
+
+    // Fallback: scan attachments by id
+    if (!found) {
+        for (const auto& att : model.attachments) {
+            if (att.id == attachmentId) {
+                boneIndex = att.bone;
+                offset = att.position;
+                found = true;
+                break;
+            }
+        }
+    }
+
+    if (!found) return false;
+
+    // Validate bone index; invalid indices bind attachments to origin (looks like weapons at feet).
+    if (boneIndex >= model.bones.size()) {
+        // Fallback: key bones (26/27) only for hand attachments.
+        if (attachmentId == 1 || attachmentId == 2) {
+            int32_t targetKeyBone = (attachmentId == 1) ? 26 : 27;
+            found = false;
+            for (size_t i = 0; i < model.bones.size(); i++) {
+                if (model.bones[i].keyBoneId == targetKeyBone) {
+                    boneIndex = static_cast<uint16_t>(i);
+                    offset = glm::vec3(0.0f);
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) return false;
+        } else {
+            return false;
+        }
     }
 
     // Get bone matrix
@@ -3500,8 +3305,10 @@ void CharacterRenderer::recreatePipelines() {
 
     // --- Load shaders ---
     rendering::VkShaderModule charVert, charFrag;
-    if (!charVert.loadFromFile(device, "assets/shaders/character.vert.spv") ||
-        !charFrag.loadFromFile(device, "assets/shaders/character.frag.spv")) {
+    charVert.loadFromFile(device, "assets/shaders/character.vert.spv");
+    charFrag.loadFromFile(device, "assets/shaders/character.frag.spv");
+
+    if (!charVert.isValid() || !charFrag.isValid()) {
         LOG_ERROR("CharacterRenderer::recreatePipelines: missing required shaders");
         return;
     }
@@ -3518,31 +3325,26 @@ void CharacterRenderer::recreatePipelines() {
     std::vector<VkVertexInputAttributeDescription> charAttrs = {
         {0, 0, VK_FORMAT_R32G32B32_SFLOAT, static_cast<uint32_t>(offsetof(CharVertexGPU, position))},
         {1, 0, VK_FORMAT_R8G8B8A8_UNORM,   static_cast<uint32_t>(offsetof(CharVertexGPU, boneWeights))},
-        {2, 0, VK_FORMAT_R8G8B8A8_SINT,     static_cast<uint32_t>(offsetof(CharVertexGPU, boneIndices))},
+        {2, 0, VK_FORMAT_R8G8B8A8_UINT,     static_cast<uint32_t>(offsetof(CharVertexGPU, boneIndices))},
         {3, 0, VK_FORMAT_R32G32B32_SFLOAT,  static_cast<uint32_t>(offsetof(CharVertexGPU, normal))},
         {4, 0, VK_FORMAT_R32G32_SFLOAT,     static_cast<uint32_t>(offsetof(CharVertexGPU, texCoords))},
         {5, 0, VK_FORMAT_R32G32B32A32_SFLOAT, static_cast<uint32_t>(offsetof(CharVertexGPU, tangent))},
     };
 
-    auto buildCharPipeline = [&](VkPipelineColorBlendAttachmentState blendState,
-                                  bool depthWrite, bool alphaToCoverage = false) -> VkPipeline {
-        auto builder = PipelineBuilder()
+    auto buildCharPipeline = [&](VkPipelineColorBlendAttachmentState blendState, bool depthWrite) -> VkPipeline {
+        return PipelineBuilder()
             .setShaders(charVert.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
                         charFrag.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
             .setVertexInput({charBinding}, charAttrs)
             .setTopology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
             .setRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE)
-            .setDepthTest(true, depthWrite, VK_COMPARE_OP_LESS)
-            .setDepthBias(0.0f, 0.0f)
+            .setDepthTest(true, depthWrite, VK_COMPARE_OP_LESS_OR_EQUAL)
             .setColorBlendAttachment(blendState)
-            .setMultisample(samples);
-        if (alphaToCoverage)
-            builder.setAlphaToCoverage(true);
-        return builder
+            .setMultisample(samples)
             .setLayout(pipelineLayout_)
             .setRenderPass(mainPass)
-            .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_DEPTH_BIAS})
-            .build(device, vkCtx_->getPipelineCache());
+            .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
+            .build(device);
     };
 
     LOG_INFO("CharacterRenderer::recreatePipelines: renderPass=", (void*)mainPass,
@@ -3550,7 +3352,7 @@ void CharacterRenderer::recreatePipelines() {
              " pipelineLayout=", (void*)pipelineLayout_);
 
     opaquePipeline_ = buildCharPipeline(PipelineBuilder::blendDisabled(), true);
-    alphaTestPipeline_ = buildCharPipeline(PipelineBuilder::blendDisabled(), true, true);
+    alphaTestPipeline_ = buildCharPipeline(PipelineBuilder::blendAlpha(), true);
     alphaPipeline_ = buildCharPipeline(PipelineBuilder::blendAlpha(), false);
     additivePipeline_ = buildCharPipeline(PipelineBuilder::blendAdditive(), false);
 
diff --git a/src/rendering/charge_effect.cpp b/src/rendering/charge_effect.cpp
index 60cc5ae7..d6fba4de 100644
--- a/src/rendering/charge_effect.cpp
+++ b/src/rendering/charge_effect.cpp
@@ -101,7 +101,7 @@ bool ChargeEffect::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayo
             .setLayout(ribbonPipelineLayout_)
             .setRenderPass(vkCtx_->getImGuiRenderPass())
             .setDynamicStates(dynamicStates)
-            .build(device, vkCtx_->getPipelineCache());
+            .build(device);
 
         vertModule.destroy();
         fragModule.destroy();
@@ -165,7 +165,7 @@ bool ChargeEffect::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayo
             .setLayout(dustPipelineLayout_)
             .setRenderPass(vkCtx_->getImGuiRenderPass())
             .setDynamicStates(dynamicStates)
-            .build(device, vkCtx_->getPipelineCache());
+            .build(device);
 
         vertModule.destroy();
         fragModule.destroy();
@@ -273,12 +273,9 @@ void ChargeEffect::recreatePipelines() {
     // ---- Rebuild ribbon trail pipeline (TRIANGLE_STRIP) ----
     {
         VkShaderModule vertModule;
+        vertModule.loadFromFile(device, "assets/shaders/charge_ribbon.vert.spv");
         VkShaderModule fragModule;
-        if (!vertModule.loadFromFile(device, "assets/shaders/charge_ribbon.vert.spv") ||
-            !fragModule.loadFromFile(device, "assets/shaders/charge_ribbon.frag.spv")) {
-            LOG_ERROR("ChargeEffect::recreatePipelines: failed to load ribbon shader modules");
-            return;
-        }
+        fragModule.loadFromFile(device, "assets/shaders/charge_ribbon.frag.spv");
 
         VkPipelineShaderStageCreateInfo vertStage = vertModule.stageInfo(VK_SHADER_STAGE_VERTEX_BIT);
         VkPipelineShaderStageCreateInfo fragStage = fragModule.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT);
@@ -317,7 +314,7 @@ void ChargeEffect::recreatePipelines() {
             .setLayout(ribbonPipelineLayout_)
             .setRenderPass(vkCtx_->getImGuiRenderPass())
             .setDynamicStates(dynamicStates)
-            .build(device, vkCtx_->getPipelineCache());
+            .build(device);
 
         vertModule.destroy();
         fragModule.destroy();
@@ -326,12 +323,9 @@ void ChargeEffect::recreatePipelines() {
     // ---- Rebuild dust puff pipeline (POINT_LIST) ----
     {
         VkShaderModule vertModule;
+        vertModule.loadFromFile(device, "assets/shaders/charge_dust.vert.spv");
         VkShaderModule fragModule;
-        if (!vertModule.loadFromFile(device, "assets/shaders/charge_dust.vert.spv") ||
-            !fragModule.loadFromFile(device, "assets/shaders/charge_dust.frag.spv")) {
-            LOG_ERROR("ChargeEffect::recreatePipelines: failed to load dust shader modules");
-            return;
-        }
+        fragModule.loadFromFile(device, "assets/shaders/charge_dust.frag.spv");
 
         VkPipelineShaderStageCreateInfo vertStage = vertModule.stageInfo(VK_SHADER_STAGE_VERTEX_BIT);
         VkPipelineShaderStageCreateInfo fragStage = fragModule.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT);
@@ -366,7 +360,7 @@ void ChargeEffect::recreatePipelines() {
             .setLayout(dustPipelineLayout_)
             .setRenderPass(vkCtx_->getImGuiRenderPass())
             .setDynamicStates(dynamicStates)
-            .build(device, vkCtx_->getPipelineCache());
+            .build(device);
 
         vertModule.destroy();
         fragModule.destroy();
@@ -455,9 +449,8 @@ void ChargeEffect::emit(const glm::vec3& position, const glm::vec3& direction) {
     }
 
     // Only add a new trail point if we've moved enough
-    glm::vec3 emitDelta = position - lastEmitPos_;
-    float distSq = glm::dot(emitDelta, emitDelta);
-    if (distSq >= TRAIL_SPAWN_DIST * TRAIL_SPAWN_DIST || trail_.empty()) {
+    float dist = glm::length(position - lastEmitPos_);
+    if (dist >= TRAIL_SPAWN_DIST || trail_.empty()) {
         // Ribbon is vertical: side vector points straight up
         glm::vec3 side = glm::vec3(0.0f, 0.0f, 1.0f);
 
@@ -473,14 +466,11 @@ void ChargeEffect::emit(const glm::vec3& position, const glm::vec3& direction) {
 
     // Spawn dust puffs at feet
     glm::vec3 horizDir = glm::vec3(direction.x, direction.y, 0.0f);
-    float horizLenSq = glm::dot(horizDir, horizDir);
-    // Skip dust when character is nearly stationary — prevents NaN from inversesqrt(0)
-    if (horizLenSq < 1e-6f) return;
-    float invHorizLen = glm::inversesqrt(horizLenSq);
-    glm::vec3 backDir = -horizDir * invHorizLen;
+    float horizLen = glm::length(horizDir);
+    if (horizLen < 0.001f) return;
+    glm::vec3 backDir = -horizDir / horizLen;
     glm::vec3 sideDir = glm::vec3(-backDir.y, backDir.x, 0.0f);
 
-    // Accumulate ~0.48 per frame at 60fps (30 particles/sec * 16ms); emit when >= 1.0
     dustAccum_ += 30.0f * 0.016f;
     while (dustAccum_ >= 1.0f && dustPuffs_.size() < MAX_DUST) {
         dustAccum_ -= 1.0f;
diff --git a/src/rendering/clouds.cpp b/src/rendering/clouds.cpp
index 6b682850..eb2a5a25 100644
--- a/src/rendering/clouds.cpp
+++ b/src/rendering/clouds.cpp
@@ -83,7 +83,7 @@ bool Clouds::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout) {
         .setLayout(pipelineLayout_)
         .setRenderPass(vkCtx_->getImGuiRenderPass())
         .setDynamicStates(dynamicStates)
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     vertModule.destroy();
     fragModule.destroy();
@@ -149,7 +149,7 @@ void Clouds::recreatePipelines() {
         .setLayout(pipelineLayout_)
         .setRenderPass(vkCtx_->getImGuiRenderPass())
         .setDynamicStates(dynamicStates)
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     vertModule.destroy();
     fragModule.destroy();
diff --git a/src/rendering/frustum.cpp b/src/rendering/frustum.cpp
index cec70fc6..5df490fc 100644
--- a/src/rendering/frustum.cpp
+++ b/src/rendering/frustum.cpp
@@ -63,14 +63,10 @@ void Frustum::extractFromMatrix(const glm::mat4& vp) {
 }
 
 void Frustum::normalizePlane(Plane& plane) {
-    float lenSq = glm::dot(plane.normal, plane.normal);
-    // Skip normalization for degenerate planes (near-zero normal) to avoid
-    // division by zero or amplifying floating-point noise into huge normals.
-    constexpr float kMinNormalLenSq = 1e-8f;
-    if (lenSq > kMinNormalLenSq) {
-        float invLen = glm::inversesqrt(lenSq);
-        plane.normal *= invLen;
-        plane.distance *= invLen;
+    float length = glm::length(plane.normal);
+    if (length > 0.0001f) {
+        plane.normal /= length;
+        plane.distance /= length;
     }
 }
 
diff --git a/src/rendering/lens_flare.cpp b/src/rendering/lens_flare.cpp
index 9e462367..820641af 100644
--- a/src/rendering/lens_flare.cpp
+++ b/src/rendering/lens_flare.cpp
@@ -109,7 +109,7 @@ bool LensFlare::initialize(VkContext* ctx, VkDescriptorSetLayout /*perFrameLayou
         .setLayout(pipelineLayout)
         .setRenderPass(vkCtx->getImGuiRenderPass())
         .setDynamicStates(dynamicStates)
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     // Shader modules can be freed after pipeline creation
     vertModule.destroy();
@@ -158,12 +158,9 @@ void LensFlare::recreatePipelines() {
     }
 
     VkShaderModule vertModule;
+    vertModule.loadFromFile(device, "assets/shaders/lens_flare.vert.spv");
     VkShaderModule fragModule;
-    if (!vertModule.loadFromFile(device, "assets/shaders/lens_flare.vert.spv") ||
-        !fragModule.loadFromFile(device, "assets/shaders/lens_flare.frag.spv")) {
-        LOG_ERROR("LensFlare::recreatePipelines: failed to load shader modules");
-        return;
-    }
+    fragModule.loadFromFile(device, "assets/shaders/lens_flare.frag.spv");
 
     VkPipelineShaderStageCreateInfo vertStage = vertModule.stageInfo(VK_SHADER_STAGE_VERTEX_BIT);
     VkPipelineShaderStageCreateInfo fragStage = fragModule.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT);
@@ -201,7 +198,7 @@ void LensFlare::recreatePipelines() {
         .setLayout(pipelineLayout)
         .setRenderPass(vkCtx->getImGuiRenderPass())
         .setDynamicStates(dynamicStates)
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     vertModule.destroy();
     fragModule.destroy();
@@ -304,11 +301,10 @@ void LensFlare::render(VkCommandBuffer cmd, const Camera& camera, const glm::vec
     // Sun billboard rendering is sky-locked (view translation removed), so anchor
     // flare projection to camera position along sun direction to avoid parallax drift.
     glm::vec3 sunDir = sunPosition;
-    float sunDirLenSq = glm::dot(sunDir, sunDir);
-    if (sunDirLenSq < 1e-8f) {
+    if (glm::length(sunDir) < 0.0001f) {
         return;
     }
-    sunDir *= glm::inversesqrt(sunDirLenSq);
+    sunDir = glm::normalize(sunDir);
     glm::vec3 anchoredSunPos = camera.getPosition() + sunDir * 800.0f;
 
     // Calculate sun visibility
@@ -317,12 +313,8 @@ void LensFlare::render(VkCommandBuffer cmd, const Camera& camera, const glm::vec
         return;
     }
 
-    // Sun height attenuation — flare weakens when sun is near horizon (sunrise/sunset)
-    float sunHeight = sunDir.z;  // z = up in render space; 0 = horizon, 1 = zenith
-    float heightFactor = glm::smoothstep(-0.05f, 0.25f, sunHeight);
-
     // Atmospheric attenuation — fog, clouds, and weather reduce lens flare
-    float atmosphericFactor = heightFactor;
+    float atmosphericFactor = 1.0f;
     atmosphericFactor *= (1.0f - glm::clamp(fogDensity * 0.8f, 0.0f, 0.9f));       // Heavy fog nearly kills flare
     atmosphericFactor *= (1.0f - glm::clamp(cloudDensity * 0.6f, 0.0f, 0.7f));     // Clouds attenuate
     atmosphericFactor *= (1.0f - glm::clamp(weatherIntensity * 0.9f, 0.0f, 0.95f)); // Rain/snow heavily attenuates
@@ -347,9 +339,6 @@ void LensFlare::render(VkCommandBuffer cmd, const Camera& camera, const glm::vec
     VkDeviceSize offset = 0;
     vkCmdBindVertexBuffers(cmd, 0, 1, &vertexBuffer, &offset);
 
-    // Warm tint at sunrise/sunset — shift flare color toward orange/amber when sun is low
-    float warmTint = 1.0f - glm::smoothstep(0.05f, 0.35f, sunHeight);
-
     // Render each flare element
     for (const auto& element : flareElements) {
         // Calculate position along sun-to-center axis
@@ -358,19 +347,12 @@ void LensFlare::render(VkCommandBuffer cmd, const Camera& camera, const glm::vec
         // Apply visibility, intensity, and atmospheric attenuation
         float brightness = element.brightness * visibility * intensityMultiplier * atmosphericFactor;
 
-        // Apply warm sunset/sunrise color shift
-        glm::vec3 tintedColor = element.color;
-        if (warmTint > 0.01f) {
-            glm::vec3 warmColor(1.0f, 0.6f, 0.25f);  // amber/orange
-            tintedColor = glm::mix(tintedColor, warmColor, warmTint * 0.5f);
-        }
-
         // Set push constants
         FlarePushConstants push{};
         push.position = position;
         push.size = element.size;
         push.aspectRatio = aspectRatio;
-        push.colorBrightness = glm::vec4(tintedColor, brightness);
+        push.colorBrightness = glm::vec4(element.color, brightness);
 
         vkCmdPushConstants(cmd, pipelineLayout,
             VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
diff --git a/src/rendering/lighting_manager.cpp b/src/rendering/lighting_manager.cpp
index b5f2fdc6..beaef514 100644
--- a/src/rendering/lighting_manager.cpp
+++ b/src/rendering/lighting_manager.cpp
@@ -1,5 +1,4 @@
 #include "rendering/lighting_manager.hpp"
-#include <glm/gtc/constants.hpp>
 #include "pipeline/asset_manager.hpp"
 #include "pipeline/dbc_loader.hpp"
 #include "pipeline/dbc_layout.hpp"
@@ -14,10 +13,6 @@ namespace rendering {
 // Light coordinate scaling (test with 1.0f first, then try 36.0f if distances seem off)
 constexpr float LIGHT_COORD_SCALE = 1.0f;
 
-// WoW's Light.dbc stores time-of-day as half-minutes (0..2879).
-// 24 hours × 60 minutes × 2 = 2880 half-minute ticks per day cycle.
-constexpr uint16_t kHalfMinutesPerDay = 2880;
-
 // Maximum volumes to blend (top 2-4)
 constexpr size_t MAX_BLEND_VOLUMES = 2;
 
@@ -176,7 +171,7 @@ bool LightingManager::loadLightBandDbcs(pipeline::AssetManager* assetManager) {
                 uint32_t timeKeyBase = libL ? (*libL)["TimeKey0"] : 3;
                 for (uint8_t k = 0; k < band.numKeyframes && k < 16; ++k) {
                     uint32_t timeValue = dbc->getUInt32(i, timeKeyBase + k);
-                    band.times[k] = static_cast<uint16_t>(timeValue % kHalfMinutesPerDay);  // Clamp to valid range
+                    band.times[k] = static_cast<uint16_t>(timeValue % 2880);  // Clamp to valid range
                 }
 
                 // Read color values (field 19-34) - stored as BGRA packed uint32
@@ -218,7 +213,7 @@ bool LightingManager::loadLightBandDbcs(pipeline::AssetManager* assetManager) {
                 uint32_t timeKeyBase = lfbL ? (*lfbL)["TimeKey0"] : 3;
                 for (uint8_t k = 0; k < band.numKeyframes && k < 16; ++k) {
                     uint32_t timeValue = dbc->getUInt32(i, timeKeyBase + k);
-                    band.times[k] = static_cast<uint16_t>(timeValue % kHalfMinutesPerDay);  // Clamp to valid range
+                    band.times[k] = static_cast<uint16_t>(timeValue % 2880);  // Clamp to valid range
                 }
 
                 // Read float values (field 19-34)
@@ -258,7 +253,7 @@ void LightingManager::update(const glm::vec3& playerPos, uint32_t mapId,
     // else: manualTime_ is set, use timeOfDay_ as-is
 
     // Convert time to half-minutes (WoW DBC format: 0-2879)
-    uint16_t timeHalfMinutes = static_cast<uint16_t>(timeOfDay_ * static_cast<float>(kHalfMinutesPerDay)) % kHalfMinutesPerDay;
+    uint16_t timeHalfMinutes = static_cast<uint16_t>(timeOfDay_ * 2880.0f) % 2880;
 
     // Update player position and map
     currentPlayerPos_ = playerPos;
@@ -310,9 +305,8 @@ void LightingManager::update(const glm::vec3& playerPos, uint32_t mapId,
         }
 
         // Normalize blended direction
-        float blendedDirLenSq = glm::dot(blendedDir, blendedDir);
-        if (blendedDirLenSq > 1e-6f) {
-            newParams.directionalDir = blendedDir * glm::inversesqrt(blendedDirLenSq);
+        if (glm::length(blendedDir) > 0.001f) {
+            newParams.directionalDir = glm::normalize(blendedDir);
         } else {
             // Fallback if all directions cancelled out
             newParams.directionalDir = glm::vec3(0.3f, -0.7f, 0.6f);
@@ -322,7 +316,7 @@ void LightingManager::update(const glm::vec3& playerPos, uint32_t mapId,
         newParams = fallbackParams_;
 
         // Animate sun direction
-        float angle = timeOfDay_ * glm::two_pi<float>();
+        float angle = timeOfDay_ * 2.0f * 3.14159f;
         newParams.directionalDir = glm::normalize(glm::vec3(
             std::sin(angle) * 0.6f,
             -0.6f + std::cos(angle) * 0.4f,
@@ -377,16 +371,14 @@ std::vector<LightingManager::WeightedVolume> LightingManager::findLightVolumes(c
     for (const auto& volume : volumes) {
         // Apply coordinate scaling (test with 1.0f, try 36.0f if distances are off)
         glm::vec3 scaledPos = volume.position * LIGHT_COORD_SCALE;
-        glm::vec3 toPlayer = playerPos - scaledPos;
-        float distSq = glm::dot(toPlayer, toPlayer);
+        float dist = glm::length(playerPos - scaledPos);
 
         float weight = 0.0f;
-        if (distSq <= volume.innerRadius * volume.innerRadius) {
+        if (dist <= volume.innerRadius) {
             // Inside inner radius: full weight
             weight = 1.0f;
-        } else if (distSq < volume.outerRadius * volume.outerRadius) {
-            // Between inner and outer: fade out with smoothstep (sqrt needed for interpolation)
-            float dist = std::sqrt(distSq);
+        } else if (dist < volume.outerRadius) {
+            // Between inner and outer: fade out with smoothstep
             float t = (dist - volume.innerRadius) / (volume.outerRadius - volume.innerRadius);
             t = glm::clamp(t, 0.0f, 1.0f);
             weight = 1.0f - (t * t * (3.0f - 2.0f * t));  // Smoothstep
@@ -397,7 +389,7 @@ std::vector<LightingManager::WeightedVolume> LightingManager::findLightVolumes(c
 
             // Debug logging for first few volumes
             if (weighted.size() <= 3) {
-                LOG_INFO("Light volume ", volume.lightId, ": distSq=", distSq,
+                LOG_INFO("Light volume ", volume.lightId, ": dist=", dist,
                          " inner=", volume.innerRadius, " outer=", volume.outerRadius,
                          " weight=", weight);
             }
@@ -408,20 +400,15 @@ std::vector<LightingManager::WeightedVolume> LightingManager::findLightVolumes(c
         return {};
     }
 
-    // Keep top N volumes by weight (partial sort is O(n) vs O(n log n) for full sort)
+    // Sort by weight descending
+    std::sort(weighted.begin(), weighted.end(),
+              [](const WeightedVolume& a, const WeightedVolume& b) {
+                  return a.weight > b.weight;
+              });
+
+    // Keep top N volumes
     if (weighted.size() > MAX_BLEND_VOLUMES) {
-        std::partial_sort(weighted.begin(),
-                          weighted.begin() + MAX_BLEND_VOLUMES,
-                          weighted.end(),
-                          [](const WeightedVolume& a, const WeightedVolume& b) {
-                              return a.weight > b.weight;
-                          });
         weighted.resize(MAX_BLEND_VOLUMES);
-    } else {
-        std::sort(weighted.begin(), weighted.end(),
-                  [](const WeightedVolume& a, const WeightedVolume& b) {
-                      return a.weight > b.weight;
-                  });
     }
 
     // Normalize weights to sum to 1.0
@@ -482,7 +469,7 @@ LightingParams LightingManager::sampleLightParams(const LightParamsProfile* prof
     }
 
     // Compute sun direction from time
-    float angle = (timeHalfMinutes / static_cast<float>(kHalfMinutesPerDay)) * glm::two_pi<float>();
+    float angle = (timeHalfMinutes / 2880.0f) * 2.0f * 3.14159f;
     params.directionalDir = glm::normalize(glm::vec3(
         std::sin(angle) * 0.6f,
         -0.6f + std::cos(angle) * 0.4f,
@@ -519,8 +506,8 @@ glm::vec3 LightingManager::sampleColorBand(const ColorBand& band, uint16_t timeH
     uint16_t t2 = band.times[idx2];
 
     // Handle midnight wrap
-    uint16_t timeSpan = (t2 > t1) ? (t2 - t1) : (kHalfMinutesPerDay - t1 + t2);
-    uint16_t elapsed = (timeHalfMinutes >= t1) ? (timeHalfMinutes - t1) : (kHalfMinutesPerDay - t1 + timeHalfMinutes);
+    uint16_t timeSpan = (t2 > t1) ? (t2 - t1) : (2880 - t1 + t2);
+    uint16_t elapsed = (timeHalfMinutes >= t1) ? (timeHalfMinutes - t1) : (2880 - t1 + timeHalfMinutes);
 
     float t = (timeSpan > 0) ? (static_cast<float>(elapsed) / static_cast<float>(timeSpan)) : 0.0f;
     t = glm::clamp(t, 0.0f, 1.0f);
@@ -554,8 +541,8 @@ float LightingManager::sampleFloatBand(const FloatBand& band, uint16_t timeHalfM
     uint16_t t1 = band.times[idx1];
     uint16_t t2 = band.times[idx2];
 
-    uint16_t timeSpan = (t2 > t1) ? (t2 - t1) : (kHalfMinutesPerDay - t1 + t2);
-    uint16_t elapsed = (timeHalfMinutes >= t1) ? (timeHalfMinutes - t1) : (kHalfMinutesPerDay - t1 + timeHalfMinutes);
+    uint16_t timeSpan = (t2 > t1) ? (t2 - t1) : (2880 - t1 + t2);
+    uint16_t elapsed = (timeHalfMinutes >= t1) ? (timeHalfMinutes - t1) : (2880 - t1 + timeHalfMinutes);
 
     float t = (timeSpan > 0) ? (static_cast<float>(elapsed) / static_cast<float>(timeSpan)) : 0.0f;
     t = glm::clamp(t, 0.0f, 1.0f);
diff --git a/src/rendering/lightning.cpp b/src/rendering/lightning.cpp
index 2c403a66..9dbd1b95 100644
--- a/src/rendering/lightning.cpp
+++ b/src/rendering/lightning.cpp
@@ -107,7 +107,7 @@ bool Lightning::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout)
             .setLayout(boltPipelineLayout)
             .setRenderPass(vkCtx->getImGuiRenderPass())
             .setDynamicStates(dynamicStates)
-            .build(device, vkCtx->getPipelineCache());
+            .build(device);
 
         vertModule.destroy();
         fragModule.destroy();
@@ -169,7 +169,7 @@ bool Lightning::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout)
             .setLayout(flashPipelineLayout)
             .setRenderPass(vkCtx->getImGuiRenderPass())
             .setDynamicStates(dynamicStates)
-            .build(device, vkCtx->getPipelineCache());
+            .build(device);
 
         vertModule.destroy();
         fragModule.destroy();
@@ -277,12 +277,9 @@ void Lightning::recreatePipelines() {
     // ---- Rebuild bolt pipeline (LINE_STRIP) ----
     {
         VkShaderModule vertModule;
+        vertModule.loadFromFile(device, "assets/shaders/lightning_bolt.vert.spv");
         VkShaderModule fragModule;
-        if (!vertModule.loadFromFile(device, "assets/shaders/lightning_bolt.vert.spv") ||
-            !fragModule.loadFromFile(device, "assets/shaders/lightning_bolt.frag.spv")) {
-            LOG_ERROR("Lightning::recreatePipelines: failed to load bolt shader modules");
-            return;
-        }
+        fragModule.loadFromFile(device, "assets/shaders/lightning_bolt.frag.spv");
 
         VkPipelineShaderStageCreateInfo vertStage = vertModule.stageInfo(VK_SHADER_STAGE_VERTEX_BIT);
         VkPipelineShaderStageCreateInfo fragStage = fragModule.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT);
@@ -309,7 +306,7 @@ void Lightning::recreatePipelines() {
             .setLayout(boltPipelineLayout)
             .setRenderPass(vkCtx->getImGuiRenderPass())
             .setDynamicStates(dynamicStates)
-            .build(device, vkCtx->getPipelineCache());
+            .build(device);
 
         vertModule.destroy();
         fragModule.destroy();
@@ -318,12 +315,9 @@ void Lightning::recreatePipelines() {
     // ---- Rebuild flash pipeline (TRIANGLE_STRIP) ----
     {
         VkShaderModule vertModule;
+        vertModule.loadFromFile(device, "assets/shaders/lightning_flash.vert.spv");
         VkShaderModule fragModule;
-        if (!vertModule.loadFromFile(device, "assets/shaders/lightning_flash.vert.spv") ||
-            !fragModule.loadFromFile(device, "assets/shaders/lightning_flash.frag.spv")) {
-            LOG_ERROR("Lightning::recreatePipelines: failed to load flash shader modules");
-            return;
-        }
+        fragModule.loadFromFile(device, "assets/shaders/lightning_flash.frag.spv");
 
         VkPipelineShaderStageCreateInfo vertStage = vertModule.stageInfo(VK_SHADER_STAGE_VERTEX_BIT);
         VkPipelineShaderStageCreateInfo fragStage = fragModule.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT);
@@ -350,7 +344,7 @@ void Lightning::recreatePipelines() {
             .setLayout(flashPipelineLayout)
             .setRenderPass(vkCtx->getImGuiRenderPass())
             .setDynamicStates(dynamicStates)
-            .build(device, vkCtx->getPipelineCache());
+            .build(device);
 
         vertModule.destroy();
         fragModule.destroy();
diff --git a/src/rendering/loading_screen.cpp b/src/rendering/loading_screen.cpp
index 6916380f..a2e83a2b 100644
--- a/src/rendering/loading_screen.cpp
+++ b/src/rendering/loading_screen.cpp
@@ -40,7 +40,10 @@ void LoadingScreen::shutdown() {
             // ImGui manages descriptor set lifetime
             bgDescriptorSet = VK_NULL_HANDLE;
         }
-        bgSampler = VK_NULL_HANDLE; // Owned by VkContext sampler cache
+        if (bgSampler) {
+            vkDestroySampler(device, bgSampler, nullptr);
+            bgSampler = VK_NULL_HANDLE;
+        }
         if (bgImageView) {
             vkDestroyImageView(device, bgImageView, nullptr);
             bgImageView = VK_NULL_HANDLE;
@@ -78,8 +81,7 @@ static uint32_t findMemoryType(VkPhysicalDevice physDevice, uint32_t typeFilter,
             return i;
         }
     }
-    LOG_ERROR("LoadingScreen: no suitable memory type found");
-    return UINT32_MAX;
+    return 0;
 }
 
 bool LoadingScreen::loadImage(const std::string& path) {
@@ -92,7 +94,7 @@ bool LoadingScreen::loadImage(const std::string& path) {
     if (bgImage) {
         VkDevice device = vkCtx->getDevice();
         vkDeviceWaitIdle(device);
-        bgSampler = VK_NULL_HANDLE; // Owned by VkContext sampler cache
+        if (bgSampler) { vkDestroySampler(device, bgSampler, nullptr); bgSampler = VK_NULL_HANDLE; }
         if (bgImageView) { vkDestroyImageView(device, bgImageView, nullptr); bgImageView = VK_NULL_HANDLE; }
         if (bgImage) { vkDestroyImage(device, bgImage, nullptr); bgImage = VK_NULL_HANDLE; }
         if (bgMemory) { vkFreeMemory(device, bgMemory, nullptr); bgMemory = VK_NULL_HANDLE; }
@@ -228,7 +230,7 @@ bool LoadingScreen::loadImage(const std::string& path) {
         samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
         samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
         samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-        bgSampler = vkCtx->getOrCreateSampler(samplerInfo);
+        vkCreateSampler(device, &samplerInfo, nullptr, &bgSampler);
     }
 
     // Register with ImGui as a texture
@@ -259,20 +261,6 @@ void LoadingScreen::renderOverlay() {
             ImVec2(0, 0), ImVec2(screenW, screenH));
     }
 
-    // Zone name header
-    if (!zoneName.empty()) {
-        ImFont* font = ImGui::GetFont();
-        float zoneTextSize = 24.0f;
-        ImVec2 zoneSize = font->CalcTextSizeA(zoneTextSize, FLT_MAX, 0.0f, zoneName.c_str());
-        float zoneX = (screenW - zoneSize.x) * 0.5f;
-        float zoneY = screenH * 0.06f - 44.0f;
-        ImDrawList* dl = ImGui::GetWindowDrawList();
-        dl->AddText(font, zoneTextSize, ImVec2(zoneX + 2.0f, zoneY + 2.0f),
-                    IM_COL32(0, 0, 0, 200), zoneName.c_str());
-        dl->AddText(font, zoneTextSize, ImVec2(zoneX, zoneY),
-                    IM_COL32(255, 220, 120, 255), zoneName.c_str());
-    }
-
     // Progress bar
     {
         const float barWidthFrac = 0.6f;
@@ -344,22 +332,6 @@ void LoadingScreen::render() {
             ImVec2(0, 0), ImVec2(screenW, screenH));
     }
 
-    // Zone name header (large text centered above progress bar)
-    if (!zoneName.empty()) {
-        ImFont* font = ImGui::GetFont();
-        float zoneTextSize = 24.0f;
-        ImVec2 zoneSize = font->CalcTextSizeA(zoneTextSize, FLT_MAX, 0.0f, zoneName.c_str());
-        float zoneX = (screenW - zoneSize.x) * 0.5f;
-        float zoneY = screenH * 0.06f - 44.0f;  // above percentage text
-        ImDrawList* dl = ImGui::GetWindowDrawList();
-        // Drop shadow
-        dl->AddText(font, zoneTextSize, ImVec2(zoneX + 2.0f, zoneY + 2.0f),
-                    IM_COL32(0, 0, 0, 200), zoneName.c_str());
-        // Gold text
-        dl->AddText(font, zoneTextSize, ImVec2(zoneX, zoneY),
-                    IM_COL32(255, 220, 120, 255), zoneName.c_str());
-    }
-
     // Progress bar (top of screen)
     {
         const float barWidthFrac = 0.6f;
@@ -421,7 +393,7 @@ void LoadingScreen::render() {
             int w = 0, h = 0;
             SDL_GetWindowSize(sdlWindow, &w, &h);
             if (w > 0 && h > 0) {
-                (void)vkCtx->recreateSwapchain(w, h);
+                vkCtx->recreateSwapchain(w, h);
             }
         }
 
diff --git a/src/rendering/m2_model_classifier.cpp b/src/rendering/m2_model_classifier.cpp
deleted file mode 100644
index 424bfc42..00000000
--- a/src/rendering/m2_model_classifier.cpp
+++ /dev/null
@@ -1,248 +0,0 @@
-#include "rendering/m2_model_classifier.hpp"
-
-#include <algorithm>
-#include <array>
-#include <cctype>
-#include <string_view>
-
-namespace wowee {
-namespace rendering {
-
-namespace {
-
-// Returns true if `lower` contains `token` as a substring.
-// Caller must provide an already-lowercased string.
-inline bool has(const std::string& lower, std::string_view token) noexcept {
-    return lower.find(token) != std::string::npos;
-}
-
-// Returns true if any token in the compile-time array is a substring of `lower`.
-template <std::size_t N>
-bool hasAny(const std::string& lower,
-            const std::array<std::string_view, N>& tokens) noexcept {
-    for (auto tok : tokens)
-        if (lower.find(tok) != std::string::npos) return true;
-    return false;
-}
-
-} // namespace
-
-M2ClassificationResult classifyM2Model(
-    const std::string& name,
-    const glm::vec3&   boundsMin,
-    const glm::vec3&   boundsMax,
-    std::size_t        vertexCount,
-    std::size_t        emitterCount)
-{
-    // Single lowercased copy — all token checks share it.
-    std::string n = name;
-    std::transform(n.begin(), n.end(), n.begin(),
-                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-
-    M2ClassificationResult r;
-
-    // ---------------------------------------------------------------
-    // Geometry metrics
-    // ---------------------------------------------------------------
-    const glm::vec3 dims = boundsMax - boundsMin;
-    const float horiz    = std::max(dims.x, dims.y);
-    const float vert     = std::max(0.0f, dims.z);
-    const bool lowWide   = (horiz > 1.4f && vert > 0.2f && vert < horiz * 0.70f);
-    const bool lowPlat   = (horiz > 1.8f && vert > 0.2f && vert < 1.8f);
-
-    // ---------------------------------------------------------------
-    // Simple single-token flags
-    // ---------------------------------------------------------------
-    r.isInvisibleTrap = has(n, "invisibletrap");
-    r.isGroundDetail  = has(n, "\\nodxt\\detail\\") || has(n, "\\detail\\");
-    r.isSmoke         = has(n, "smoke");
-    r.isLavaModel     = has(n, "forgelava") || has(n, "lavapot") || has(n, "lavaflow");
-
-    r.isInstancePortal  = has(n, "instanceportal") || has(n, "instancenewportal")
-                        || has(n, "portalfx")       || has(n, "spellportal");
-
-    r.isWaterVegetation = has(n, "cattail") || has(n, "reed")     || has(n, "bulrush")
-                        || has(n, "seaweed") || has(n, "kelp")    || has(n, "lilypad");
-
-    r.isElvenLike   = has(n, "elf")     || has(n, "elven") || has(n, "quel");
-    r.isLanternLike = has(n, "lantern") || has(n, "lamp")  || has(n, "light");
-    r.isKoboldFlame = has(n, "kobold")
-                    && (has(n, "candle") || has(n, "torch") || has(n, "mine"));
-
-    // ---------------------------------------------------------------
-    // Collision: shape categories (mirrors original logic ordering)
-    // ---------------------------------------------------------------
-    const bool isPlanter      = has(n, "planter");
-    const bool likelyCurb     = isPlanter || has(n, "curb")  || has(n, "base")
-                                           || has(n, "ring")  || has(n, "well");
-    const bool knownSwPlanter = has(n, "stormwindplanter")
-                              || has(n, "stormwindwindowplanter");
-    const bool bridgeName     = has(n, "bridge") || has(n, "plank") || has(n, "walkway");
-    const bool statueName     = has(n, "statue") || has(n, "monument") || has(n, "sculpture");
-    const bool sittable       = has(n, "chair")  || has(n, "bench") || has(n, "stool")
-                                                 || has(n, "seat")  || has(n, "throne");
-    const bool smallSolid     = (statueName && !sittable)
-                              || has(n, "crate") || has(n, "box")
-                              || has(n, "chest") || has(n, "barrel");
-    const bool chestName      = has(n, "chest");
-
-    r.collisionSteppedFountain    = has(n, "fountain");
-    r.collisionSteppedLowPlatform = !r.collisionSteppedFountain
-                                  && (knownSwPlanter || bridgeName
-                                      || (likelyCurb && (lowPlat || lowWide)));
-    r.collisionBridge             = bridgeName;
-    r.collisionPlanter            = isPlanter;
-    r.collisionStatue             = statueName;
-
-    const bool narrowVertName  = has(n, "lamp")    || has(n, "lantern")
-                               || has(n, "post")    || has(n, "pole");
-    const bool narrowVertShape = (horiz > 0.12f && horiz < 2.0f
-                               && vert  > 2.2f  && vert  > horiz * 1.8f);
-    r.collisionNarrowVerticalProp = !r.collisionSteppedFountain
-                                  && !r.collisionSteppedLowPlatform
-                                  && (narrowVertName || narrowVertShape);
-
-    // ---------------------------------------------------------------
-    // Foliage token table (sorted alphabetically)
-    // ---------------------------------------------------------------
-    static constexpr auto kFoliageTokens = std::to_array<std::string_view>({
-        "algae",      "bamboo",     "banana",     "branch",     "bush",
-        "cactus",     "canopy",     "cattail",    "coconut",    "coral",
-        "corn",       "crop",       "dead-grass", "dead_grass", "deadgrass",
-        "dry-grass",  "dry_grass",  "drygrass",
-        "fern",       "fireflies",  "firefly",    "fireflys",
-        "flower",     "frond",      "fungus",     "gourd",      "grass",
-        "hay",        "hedge",      "ivy",        "kelp",       "leaf",
-        "leaves",     "lily",       "melon",      "moss",       "mushroom",
-        "palm",       "pumpkin",    "reed",       "root",       "seaweed",
-        "shrub",      "squash",     "stalk",      "thorn",      "toadstool",
-        "vine",       "watermelon", "weed",       "wheat",
-    });
-
-    // "plant" is foliage unless "planter" is also present (planters are solid curbs).
-    const bool foliagePlant = has(n, "plant") && !isPlanter;
-    const bool foliageName  = foliagePlant || hasAny(n, kFoliageTokens);
-    const bool treeLike     = has(n, "tree");
-    const bool hardTreePart = has(n, "trunk") || has(n, "stump") || has(n, "log");
-
-    // Trees wide/tall enough to have a visible trunk → solid cylinder collision.
-    const bool treeWithTrunk = treeLike && !hardTreePart && !foliageName
-                             && horiz > 6.0f && vert > 4.0f;
-    const bool softTree      = treeLike && !hardTreePart && !treeWithTrunk;
-
-    r.collisionTreeTrunk = treeWithTrunk;
-
-    const bool genericSolid     = (horiz > 0.6f && horiz < 6.0f
-                                && vert  > 0.30f && vert  < 4.0f
-                                && vert  > horiz * 0.16f) || statueName;
-    const bool curbLikeName     = has(n, "curb")   || has(n, "planter")
-                                || has(n, "ring")   || has(n, "well")  || has(n, "base");
-    const bool lowPlatLikeShape = lowWide || lowPlat;
-
-    r.collisionSmallSolidProp = !r.collisionSteppedFountain
-                              && !r.collisionSteppedLowPlatform
-                              && !r.collisionNarrowVerticalProp
-                              && !r.collisionTreeTrunk
-                              && !curbLikeName
-                              && !lowPlatLikeShape
-                              && (smallSolid
-                                  || (genericSolid && !foliageName && !softTree));
-
-    const bool carpetOrRug    = has(n, "carpet") || has(n, "rug");
-    const bool forceSolidCurb = r.collisionSteppedLowPlatform || knownSwPlanter
-                              || likelyCurb || r.collisionPlanter;
-    r.collisionNoBlock        = (foliageName || softTree || carpetOrRug) && !forceSolidCurb;
-    // Ground-clutter detail cards are always non-blocking.
-    if (r.isGroundDetail) r.collisionNoBlock = true;
-
-    // ---------------------------------------------------------------
-    // Ambient creatures: fireflies, dragonflies, moths, butterflies
-    // ---------------------------------------------------------------
-    static constexpr auto kAmbientTokens = std::to_array<std::string_view>({
-        "butterfly", "dragonflies", "dragonfly",
-        "fireflies", "firefly",     "fireflys", "moth",
-    });
-    const bool ambientCreature = hasAny(n, kAmbientTokens);
-
-    // ---------------------------------------------------------------
-    // Animation / foliage rendering flags
-    // ---------------------------------------------------------------
-    const bool foliageOrTree = foliageName || treeLike;
-    r.isFoliageLike    = foliageOrTree && !ambientCreature;
-    r.disableAnimation = r.isFoliageLike || chestName;
-    r.shadowWindFoliage = r.isFoliageLike;
-    r.isFireflyEffect   = ambientCreature;
-
-    // ---------------------------------------------------------------
-    // Spell effects (named tokens + particle-dominated geometry heuristic)
-    // ---------------------------------------------------------------
-    static constexpr auto kEffectTokens = std::to_array<std::string_view>({
-        "bubbles",        "hazardlight",      "instancenewportal", "instanceportal",
-        "lavabubble",     "lavasplash",        "lavasteam",         "levelup",
-        "lightshaft",     "mageportal",        "particleemitter",
-        "spotlight",      "volumetriclight",   "wisps",             "worldtreeportal",
-    });
-    r.isSpellEffect = hasAny(n, kEffectTokens)
-                    || (emitterCount >= 3 && vertexCount <= 200);
-    // Instance portals are spell effects too.
-    if (r.isInstancePortal) r.isSpellEffect = true;
-
-    return r;
-}
-
-// ---------------------------------------------------------------------------
-// classifyBatchTexture
-// ---------------------------------------------------------------------------
-
-M2BatchTexClassification classifyBatchTexture(const std::string& lowerTexKey)
-{
-    M2BatchTexClassification r;
-
-    // Exact paths for well-known lantern / lamp glow-card textures.
-    static constexpr auto kExactGlowTextures = std::to_array<std::string_view>({
-        "world\\azeroth\\karazahn\\passivedoodads\\bonfire\\flamelicksmallblue.blp",
-        "world\\expansion06\\doodads\\nightelf\\7ne_druid_streetlamp01_light.blp",
-        "world\\generic\\human\\passive doodads\\stormwind\\t_vfx_glow01_64.blp",
-        "world\\generic\\nightelf\\passive doodads\\lamps\\glowblue32.blp",
-        "world\\generic\\nightelf\\passive doodads\\magicalimplements\\glow.blp",
-    });
-    for (auto s : kExactGlowTextures)
-        if (lowerTexKey == s) { r.exactLanternGlowTex = true; break; }
-
-    static constexpr auto kGlowTokens = std::to_array<std::string_view>({
-        "flare", "glow", "halo", "light",
-    });
-    static constexpr auto kFlameTokens = std::to_array<std::string_view>({
-        "ember", "fire", "flame", "flamelick",
-    });
-    static constexpr auto kGlowCardTokens = std::to_array<std::string_view>({
-        "flamelick", "genericglow", "glow", "glowball",
-        "lensflare", "lightbeam",   "t_vfx",
-    });
-    static constexpr auto kLikelyFlameTokens = std::to_array<std::string_view>({
-        "fire", "flame", "torch",
-    });
-    static constexpr auto kLanternFamilyTokens = std::to_array<std::string_view>({
-        "elf", "lamp", "lantern", "quel", "silvermoon", "thalas",
-    });
-    static constexpr auto kCoolTintTokens = std::to_array<std::string_view>({
-        "arcane", "blue", "nightelf",
-    });
-    static constexpr auto kRedTintTokens = std::to_array<std::string_view>({
-        "red", "ruby", "scarlet",
-    });
-
-    r.hasGlowToken     = hasAny(lowerTexKey, kGlowTokens);
-    r.hasFlameToken    = hasAny(lowerTexKey, kFlameTokens);
-    r.hasGlowCardToken = hasAny(lowerTexKey, kGlowCardTokens);
-    r.likelyFlame      = hasAny(lowerTexKey, kLikelyFlameTokens);
-    r.lanternFamily    = hasAny(lowerTexKey, kLanternFamilyTokens);
-    r.glowTint         = hasAny(lowerTexKey, kCoolTintTokens) ? 1
-                       : hasAny(lowerTexKey, kRedTintTokens)  ? 2
-                       : 0;
-
-    return r;
-}
-
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/m2_renderer.cpp b/src/rendering/m2_renderer.cpp
index fd7c6bd4..a28e49a6 100644
--- a/src/rendering/m2_renderer.cpp
+++ b/src/rendering/m2_renderer.cpp
@@ -1,5 +1,4 @@
 #include "rendering/m2_renderer.hpp"
-#include "rendering/m2_model_classifier.hpp"
 #include "rendering/vk_context.hpp"
 #include "rendering/vk_buffer.hpp"
 #include "rendering/vk_texture.hpp"
@@ -12,7 +11,6 @@
 #include "pipeline/asset_manager.hpp"
 #include "pipeline/blp_loader.hpp"
 #include "core/logger.hpp"
-#include "core/profiler.hpp"
 #include <chrono>
 #include <cctype>
 #include <glm/gtc/matrix_transform.hpp>
@@ -23,7 +21,6 @@
 #include <algorithm>
 #include <cmath>
 #include <cstdlib>
-#include <random>
 #include <limits>
 #include <future>
 #include <thread>
@@ -33,24 +30,6 @@ namespace rendering {
 
 namespace {
 
-// Seeded RNG for animation time offsets and variation timers. Using rand()
-// without srand() produces the same sequence every launch, causing all
-// doodads (trees, torches, grass) to sway/flicker in sync.
-std::mt19937& rng() {
-    static std::mt19937 gen(std::random_device{}());
-    return gen;
-}
-uint32_t randRange(uint32_t maxExclusive) {
-    if (maxExclusive == 0) return 0;
-    return std::uniform_int_distribution<uint32_t>(0, maxExclusive - 1)(rng());
-}
-float randFloat(float lo, float hi) {
-    return std::uniform_real_distribution<float>(lo, hi)(rng());
-}
-
-// Shared lava UV scroll timer — ensures consistent animation across all render passes
-const auto kLavaAnimStart = std::chrono::steady_clock::now();
-
 bool envFlagEnabled(const char* key, bool defaultValue) {
     const char* raw = std::getenv(key);
     if (!raw || !*raw) return defaultValue;
@@ -61,9 +40,26 @@ bool envFlagEnabled(const char* key, bool defaultValue) {
     return !(v == "0" || v == "false" || v == "off" || v == "no");
 }
 
+size_t envSizeMBOrDefault(const char* name, size_t defMb) {
+    const char* raw = std::getenv(name);
+    if (!raw || !*raw) return defMb;
+    char* end = nullptr;
+    unsigned long long mb = std::strtoull(raw, &end, 10);
+    if (end == raw || mb == 0) return defMb;
+    return static_cast<size_t>(mb);
+}
+
+size_t envSizeOrDefault(const char* name, size_t defValue) {
+    const char* raw = std::getenv(name);
+    if (!raw || !*raw) return defValue;
+    char* end = nullptr;
+    unsigned long long v = std::strtoull(raw, &end, 10);
+    if (end == raw || v == 0) return defValue;
+    return static_cast<size_t>(v);
+}
+
 static constexpr uint32_t kParticleFlagRandomized = 0x40;
 static constexpr uint32_t kParticleFlagTiled = 0x80;
-static constexpr float kSmokeEmitInterval = 1.0f / 48.0f;
 
 float computeGroundDetailDownOffset(const M2ModelGPU& model, float scale) {
     // Keep a tiny sink to avoid hovering, but cap pivot compensation so details
@@ -214,6 +210,22 @@ float pointAABBDistanceSq(const glm::vec3& p, const glm::vec3& bmin, const glm::
     return glm::dot(d, d);
 }
 
+struct QueryTimer {
+    double* totalMs = nullptr;
+    uint32_t* callCount = nullptr;
+    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+    QueryTimer(double* total, uint32_t* calls) : totalMs(total), callCount(calls) {}
+    ~QueryTimer() {
+        if (callCount) {
+            (*callCount)++;
+        }
+        if (totalMs) {
+            auto end = std::chrono::steady_clock::now();
+            *totalMs += std::chrono::duration<double, std::milli>(end - start).count();
+        }
+    }
+};
+
 // Möller–Trumbore ray-triangle intersection.
 // Returns distance along ray if hit, negative if miss.
 float rayTriangleIntersect(const glm::vec3& origin, const glm::vec3& dir,
@@ -349,20 +361,6 @@ bool M2Renderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout
         vkCreateDescriptorSetLayout(device, &ci, nullptr, &boneSetLayout_);
     }
 
-    // Instance data set layout (set 3): binding 0 = STORAGE_BUFFER (per-instance data)
-    {
-        VkDescriptorSetLayoutBinding binding{};
-        binding.binding = 0;
-        binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-        binding.descriptorCount = 1;
-        binding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
-
-        VkDescriptorSetLayoutCreateInfo ci{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO};
-        ci.bindingCount = 1;
-        ci.pBindings = &binding;
-        vkCreateDescriptorSetLayout(device, &ci, nullptr, &instanceSetLayout_);
-    }
-
     // Particle texture set layout (set 1 for particles): binding 0 = sampler2D
     {
         VkDescriptorSetLayoutBinding binding{};
@@ -402,279 +400,19 @@ bool M2Renderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout
         vkCreateDescriptorPool(device, &ci, nullptr, &boneDescPool_);
     }
 
-    // Create a small identity-bone SSBO + descriptor set so that non-animated
-    // draws always have a valid set 2 bound.  The Intel ANV driver segfaults
-    // on vkCmdDrawIndexed when a declared descriptor set slot is unbound.
-    {
-        // Single identity matrix (bone 0 = identity)
-        glm::mat4 identity(1.0f);
-        VkBufferCreateInfo bci{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
-        bci.size = sizeof(glm::mat4);
-        bci.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-        VmaAllocationCreateInfo aci{};
-        aci.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
-        aci.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
-        VmaAllocationInfo allocInfo{};
-        vmaCreateBuffer(ctx->getAllocator(), &bci, &aci,
-                        &dummyBoneBuffer_, &dummyBoneAlloc_, &allocInfo);
-        if (allocInfo.pMappedData) {
-            memcpy(allocInfo.pMappedData, &identity, sizeof(identity));
-        }
-
-        dummyBoneSet_ = allocateBoneSet();
-        if (dummyBoneSet_) {
-            VkDescriptorBufferInfo bufInfo{};
-            bufInfo.buffer = dummyBoneBuffer_;
-            bufInfo.offset = 0;
-            bufInfo.range = sizeof(glm::mat4);
-            VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
-            write.dstSet = dummyBoneSet_;
-            write.dstBinding = 0;
-            write.descriptorCount = 1;
-            write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-            write.pBufferInfo = &bufInfo;
-            vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
-        }
-    }
-
-    // Mega bone SSBO — consolidates all animated instance bones into one buffer per frame.
-    // Slot 0 = identity matrix (for non-animated instances), slots 1..N = animated instances.
-    {
-        const VkDeviceSize megaSize = MEGA_BONE_MAX_INSTANCES * MAX_BONES_PER_INSTANCE * sizeof(glm::mat4);
-        glm::mat4 identity(1.0f);
-        for (int i = 0; i < 2; i++) {
-            VkBufferCreateInfo bci{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
-            bci.size = megaSize;
-            bci.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-            VmaAllocationCreateInfo aci{};
-            aci.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
-            aci.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
-            VmaAllocationInfo allocInfo{};
-            vmaCreateBuffer(ctx->getAllocator(), &bci, &aci,
-                            &megaBoneBuffer_[i], &megaBoneAlloc_[i], &allocInfo);
-            megaBoneMapped_[i] = allocInfo.pMappedData;
-
-            // Slot 0: identity matrix (for non-animated instances)
-            if (megaBoneMapped_[i]) {
-                memcpy(megaBoneMapped_[i], &identity, sizeof(identity));
-            }
-
-            megaBoneSet_[i] = allocateBoneSet();
-            if (megaBoneSet_[i]) {
-                VkDescriptorBufferInfo bufInfo{};
-                bufInfo.buffer = megaBoneBuffer_[i];
-                bufInfo.offset = 0;
-                bufInfo.range = megaSize;
-                VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
-                write.dstSet = megaBoneSet_[i];
-                write.dstBinding = 0;
-                write.descriptorCount = 1;
-                write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-                write.pBufferInfo = &bufInfo;
-                vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
-            }
-        }
-    }
-
-    // Instance data SSBO — per-frame buffer holding per-instance transforms, fade, bones.
-    // Shader reads instanceData[push.instanceDataOffset + gl_InstanceIndex].
-    {
-        static_assert(sizeof(M2InstanceGPU) == 96, "M2InstanceGPU must be 96 bytes (std430)");
-        const VkDeviceSize instBufSize = MAX_INSTANCE_DATA * sizeof(M2InstanceGPU);
-
-        // Descriptor pool for 2 sets (double-buffered)
-        VkDescriptorPoolSize poolSize{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 2};
-        VkDescriptorPoolCreateInfo poolCi{VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO};
-        poolCi.maxSets = 2;
-        poolCi.poolSizeCount = 1;
-        poolCi.pPoolSizes = &poolSize;
-        vkCreateDescriptorPool(device, &poolCi, nullptr, &instanceDescPool_);
-
-        for (int i = 0; i < 2; i++) {
-            VkBufferCreateInfo bci{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
-            bci.size = instBufSize;
-            bci.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-            VmaAllocationCreateInfo aci{};
-            aci.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
-            aci.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
-            VmaAllocationInfo allocInfo{};
-            vmaCreateBuffer(ctx->getAllocator(), &bci, &aci,
-                            &instanceBuffer_[i], &instanceAlloc_[i], &allocInfo);
-            instanceMapped_[i] = allocInfo.pMappedData;
-
-            VkDescriptorSetAllocateInfo setAi{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
-            setAi.descriptorPool = instanceDescPool_;
-            setAi.descriptorSetCount = 1;
-            setAi.pSetLayouts = &instanceSetLayout_;
-            vkAllocateDescriptorSets(device, &setAi, &instanceSet_[i]);
-
-            VkDescriptorBufferInfo bufInfo{};
-            bufInfo.buffer = instanceBuffer_[i];
-            bufInfo.offset = 0;
-            bufInfo.range = instBufSize;
-            VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
-            write.dstSet = instanceSet_[i];
-            write.dstBinding = 0;
-            write.descriptorCount = 1;
-            write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-            write.pBufferInfo = &bufInfo;
-            vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
-        }
-    }
-
-    // GPU frustum culling — compute pipeline, buffers, descriptors.
-    // Compute shader tests each instance bounding sphere against 6 frustum planes + distance.
-    // Output: uint visibility[] read back by CPU to skip culled instances in sortedVisible_ build.
-    {
-        static_assert(sizeof(CullInstanceGPU) == 32, "CullInstanceGPU must be 32 bytes (std430)");
-        static_assert(sizeof(CullUniformsGPU) == 128, "CullUniformsGPU must be 128 bytes (std140)");
-
-        // Descriptor set layout: binding 0 = UBO (frustum+camera), 1 = SSBO (input), 2 = SSBO (output)
-        VkDescriptorSetLayoutBinding bindings[3] = {};
-        bindings[0].binding = 0;
-        bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-        bindings[0].descriptorCount = 1;
-        bindings[0].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
-        bindings[1].binding = 1;
-        bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-        bindings[1].descriptorCount = 1;
-        bindings[1].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
-        bindings[2].binding = 2;
-        bindings[2].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-        bindings[2].descriptorCount = 1;
-        bindings[2].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
-
-        VkDescriptorSetLayoutCreateInfo layoutCi{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO};
-        layoutCi.bindingCount = 3;
-        layoutCi.pBindings = bindings;
-        vkCreateDescriptorSetLayout(device, &layoutCi, nullptr, &cullSetLayout_);
-
-        // Pipeline layout (no push constants — everything via UBO)
-        VkPipelineLayoutCreateInfo plCi{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO};
-        plCi.setLayoutCount = 1;
-        plCi.pSetLayouts = &cullSetLayout_;
-        vkCreatePipelineLayout(device, &plCi, nullptr, &cullPipelineLayout_);
-
-        // Load compute shader
-        rendering::VkShaderModule cullComp;
-        if (!cullComp.loadFromFile(device, "assets/shaders/m2_cull.comp.spv")) {
-            LOG_ERROR("M2Renderer: failed to load m2_cull.comp.spv — GPU culling disabled");
-        } else {
-            VkComputePipelineCreateInfo cpCi{VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO};
-            cpCi.stage = cullComp.stageInfo(VK_SHADER_STAGE_COMPUTE_BIT);
-            cpCi.layout = cullPipelineLayout_;
-            if (vkCreateComputePipelines(device, VK_NULL_HANDLE, 1, &cpCi, nullptr, &cullPipeline_) != VK_SUCCESS) {
-                LOG_ERROR("M2Renderer: failed to create cull compute pipeline");
-                cullPipeline_ = VK_NULL_HANDLE;
-            }
-            cullComp.destroy();
-        }
-
-        // Descriptor pool: 2 sets × 3 descriptors each (1 UBO + 2 SSBO)
-        VkDescriptorPoolSize poolSizes[2] = {};
-        poolSizes[0] = {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 2};
-        poolSizes[1] = {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 4};  // 2 input + 2 output
-        VkDescriptorPoolCreateInfo poolCi{VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO};
-        poolCi.maxSets = 2;
-        poolCi.poolSizeCount = 2;
-        poolCi.pPoolSizes = poolSizes;
-        vkCreateDescriptorPool(device, &poolCi, nullptr, &cullDescPool_);
-
-        const VkDeviceSize uniformSize = sizeof(CullUniformsGPU);
-        const VkDeviceSize inputSize   = MAX_CULL_INSTANCES * sizeof(CullInstanceGPU);
-        const VkDeviceSize outputSize  = MAX_CULL_INSTANCES * sizeof(uint32_t);
-
-        for (int i = 0; i < 2; i++) {
-            // Uniform buffer (frustum planes + camera)
-            {
-                VkBufferCreateInfo bci{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
-                bci.size = uniformSize;
-                bci.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
-                VmaAllocationCreateInfo aci{};
-                aci.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
-                aci.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
-                VmaAllocationInfo ai{};
-                vmaCreateBuffer(ctx->getAllocator(), &bci, &aci,
-                                &cullUniformBuffer_[i], &cullUniformAlloc_[i], &ai);
-                cullUniformMapped_[i] = ai.pMappedData;
-            }
-            // Input SSBO (per-instance cull data)
-            {
-                VkBufferCreateInfo bci{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
-                bci.size = inputSize;
-                bci.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-                VmaAllocationCreateInfo aci{};
-                aci.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
-                aci.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
-                VmaAllocationInfo ai{};
-                vmaCreateBuffer(ctx->getAllocator(), &bci, &aci,
-                                &cullInputBuffer_[i], &cullInputAlloc_[i], &ai);
-                cullInputMapped_[i] = ai.pMappedData;
-            }
-            // Output SSBO (visibility flags — GPU writes, CPU reads)
-            {
-                VkBufferCreateInfo bci{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
-                bci.size = outputSize;
-                bci.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-                VmaAllocationCreateInfo aci{};
-                aci.usage = VMA_MEMORY_USAGE_GPU_TO_CPU;
-                aci.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
-                VmaAllocationInfo ai{};
-                vmaCreateBuffer(ctx->getAllocator(), &bci, &aci,
-                                &cullOutputBuffer_[i], &cullOutputAlloc_[i], &ai);
-                cullOutputMapped_[i] = ai.pMappedData;
-            }
-
-            // Allocate and write descriptor set
-            VkDescriptorSetAllocateInfo setAi{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
-            setAi.descriptorPool = cullDescPool_;
-            setAi.descriptorSetCount = 1;
-            setAi.pSetLayouts = &cullSetLayout_;
-            vkAllocateDescriptorSets(device, &setAi, &cullSet_[i]);
-
-            VkDescriptorBufferInfo uboInfo{cullUniformBuffer_[i], 0, uniformSize};
-            VkDescriptorBufferInfo inputInfo{cullInputBuffer_[i], 0, inputSize};
-            VkDescriptorBufferInfo outputInfo{cullOutputBuffer_[i], 0, outputSize};
-
-            VkWriteDescriptorSet writes[3] = {};
-            writes[0] = {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
-            writes[0].dstSet = cullSet_[i];
-            writes[0].dstBinding = 0;
-            writes[0].descriptorCount = 1;
-            writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-            writes[0].pBufferInfo = &uboInfo;
-
-            writes[1] = {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
-            writes[1].dstSet = cullSet_[i];
-            writes[1].dstBinding = 1;
-            writes[1].descriptorCount = 1;
-            writes[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-            writes[1].pBufferInfo = &inputInfo;
-
-            writes[2] = {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
-            writes[2].dstSet = cullSet_[i];
-            writes[2].dstBinding = 2;
-            writes[2].descriptorCount = 1;
-            writes[2].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-            writes[2].pBufferInfo = &outputInfo;
-
-            vkUpdateDescriptorSets(device, 3, writes, 0, nullptr);
-        }
-    }
-
     // --- Pipeline layouts ---
 
-    // Main M2 pipeline layout: set 0 = perFrame, set 1 = material, set 2 = bones, set 3 = instances
-    // Push constant: int texCoordSet + int isFoliage + int instanceDataOffset (12 bytes)
+    // Main M2 pipeline layout: set 0 = perFrame, set 1 = material, set 2 = bones
+    // Push constant: mat4 model + vec2 uvOffset + int texCoordSet + int useBones = 80 bytes
     {
-        VkDescriptorSetLayout setLayouts[] = {perFrameLayout, materialSetLayout_, boneSetLayout_, instanceSetLayout_};
+        VkDescriptorSetLayout setLayouts[] = {perFrameLayout, materialSetLayout_, boneSetLayout_};
         VkPushConstantRange pushRange{};
         pushRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
         pushRange.offset = 0;
-        pushRange.size = 12; // int texCoordSet + int isFoliage + int instanceDataOffset
+        pushRange.size = 88; // mat4(64) + vec2(8) + int(4) + int(4) + int(4) + float(4)
 
         VkPipelineLayoutCreateInfo ci{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO};
-        ci.setLayoutCount = 4;
+        ci.setLayoutCount = 3;
         ci.pSetLayouts = setLayouts;
         ci.pushConstantRangeCount = 1;
         ci.pPushConstantRanges = &pushRange;
@@ -720,12 +458,12 @@ bool M2Renderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout
     rendering::VkShaderModule particleVert, particleFrag;
     rendering::VkShaderModule smokeVert, smokeFrag;
 
-    (void)m2Vert.loadFromFile(device, "assets/shaders/m2.vert.spv");
-    (void)m2Frag.loadFromFile(device, "assets/shaders/m2.frag.spv");
-    (void)particleVert.loadFromFile(device, "assets/shaders/m2_particle.vert.spv");
-    (void)particleFrag.loadFromFile(device, "assets/shaders/m2_particle.frag.spv");
-    (void)smokeVert.loadFromFile(device, "assets/shaders/m2_smoke.vert.spv");
-    (void)smokeFrag.loadFromFile(device, "assets/shaders/m2_smoke.frag.spv");
+    m2Vert.loadFromFile(device, "assets/shaders/m2.vert.spv");
+    m2Frag.loadFromFile(device, "assets/shaders/m2.frag.spv");
+    particleVert.loadFromFile(device, "assets/shaders/m2_particle.vert.spv");
+    particleFrag.loadFromFile(device, "assets/shaders/m2_particle.frag.spv");
+    smokeVert.loadFromFile(device, "assets/shaders/m2_smoke.vert.spv");
+    smokeFrag.loadFromFile(device, "assets/shaders/m2_smoke.frag.spv");
 
     if (!m2Vert.isValid() || !m2Frag.isValid()) {
         LOG_ERROR("M2: Missing required shaders, cannot initialize");
@@ -752,9 +490,7 @@ bool M2Renderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout
         {4, 0, VK_FORMAT_R32G32B32A32_SFLOAT, 14 * sizeof(float)}, // boneIndices (float)
     };
 
-    // Pipeline derivatives — opaque is the base, others derive from it for shared state optimization
-    auto buildM2Pipeline = [&](VkPipelineColorBlendAttachmentState blendState, bool depthWrite,
-                               VkPipelineCreateFlags flags = 0, VkPipeline basePipeline = VK_NULL_HANDLE) -> VkPipeline {
+    auto buildM2Pipeline = [&](VkPipelineColorBlendAttachmentState blendState, bool depthWrite) -> VkPipeline {
         return PipelineBuilder()
             .setShaders(m2Vert.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
                         m2Frag.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
@@ -767,19 +503,13 @@ bool M2Renderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout
             .setLayout(pipelineLayout_)
             .setRenderPass(mainPass)
             .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-            .setFlags(flags)
-            .setBasePipeline(basePipeline)
-            .build(device, vkCtx_->getPipelineCache());
+            .build(device);
     };
 
-    opaquePipeline_ = buildM2Pipeline(PipelineBuilder::blendDisabled(), true,
-                                      VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT);
-    alphaTestPipeline_ = buildM2Pipeline(PipelineBuilder::blendAlpha(), true,
-                                         VK_PIPELINE_CREATE_DERIVATIVE_BIT, opaquePipeline_);
-    alphaPipeline_ = buildM2Pipeline(PipelineBuilder::blendAlpha(), false,
-                                     VK_PIPELINE_CREATE_DERIVATIVE_BIT, opaquePipeline_);
-    additivePipeline_ = buildM2Pipeline(PipelineBuilder::blendAdditive(), false,
-                                        VK_PIPELINE_CREATE_DERIVATIVE_BIT, opaquePipeline_);
+    opaquePipeline_ = buildM2Pipeline(PipelineBuilder::blendDisabled(), true);
+    alphaTestPipeline_ = buildM2Pipeline(PipelineBuilder::blendAlpha(), true);
+    alphaPipeline_ = buildM2Pipeline(PipelineBuilder::blendAlpha(), false);
+    additivePipeline_ = buildM2Pipeline(PipelineBuilder::blendAdditive(), false);
 
     // --- Build particle pipelines ---
     if (particleVert.isValid() && particleFrag.isValid()) {
@@ -808,7 +538,7 @@ bool M2Renderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout
                 .setLayout(particlePipelineLayout_)
                 .setRenderPass(mainPass)
                 .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-                .build(device, vkCtx_->getPipelineCache());
+                .build(device);
         };
 
         particlePipeline_ = buildParticlePipeline(PipelineBuilder::blendAlpha());
@@ -841,55 +571,7 @@ bool M2Renderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout
             .setLayout(smokePipelineLayout_)
             .setRenderPass(mainPass)
             .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-            .build(device, vkCtx_->getPipelineCache());
-    }
-
-    // --- Build ribbon pipelines ---
-    // Vertex format: pos(3) + color(3) + alpha(1) + uv(2) = 9 floats = 36 bytes
-    {
-        rendering::VkShaderModule ribVert, ribFrag;
-        (void)ribVert.loadFromFile(device, "assets/shaders/m2_ribbon.vert.spv");
-        (void)ribFrag.loadFromFile(device, "assets/shaders/m2_ribbon.frag.spv");
-        if (ribVert.isValid() && ribFrag.isValid()) {
-            // Reuse particleTexLayout_ for set 1 (single texture sampler)
-            VkDescriptorSetLayout ribLayouts[] = {perFrameLayout, particleTexLayout_};
-            VkPipelineLayoutCreateInfo lci{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO};
-            lci.setLayoutCount = 2;
-            lci.pSetLayouts = ribLayouts;
-            vkCreatePipelineLayout(device, &lci, nullptr, &ribbonPipelineLayout_);
-
-            VkVertexInputBindingDescription rBind{};
-            rBind.binding = 0;
-            rBind.stride = 9 * sizeof(float);
-            rBind.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
-
-            std::vector<VkVertexInputAttributeDescription> rAttrs = {
-                {0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0},                    // pos
-                {1, 0, VK_FORMAT_R32G32B32_SFLOAT, 3 * sizeof(float)},    // color
-                {2, 0, VK_FORMAT_R32_SFLOAT,       6 * sizeof(float)},    // alpha
-                {3, 0, VK_FORMAT_R32G32_SFLOAT,    7 * sizeof(float)},    // uv
-            };
-
-            auto buildRibbonPipeline = [&](VkPipelineColorBlendAttachmentState blend) -> VkPipeline {
-                return PipelineBuilder()
-                    .setShaders(ribVert.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
-                                ribFrag.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
-                    .setVertexInput({rBind}, rAttrs)
-                    .setTopology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP)
-                    .setRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE)
-                    .setDepthTest(true, false, VK_COMPARE_OP_LESS_OR_EQUAL)
-                    .setColorBlendAttachment(blend)
-                    .setMultisample(vkCtx_->getMsaaSamples())
-                    .setLayout(ribbonPipelineLayout_)
-                    .setRenderPass(mainPass)
-                    .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-                    .build(device, vkCtx_->getPipelineCache());
-            };
-
-            ribbonPipeline_         = buildRibbonPipeline(PipelineBuilder::blendAlpha());
-            ribbonAdditivePipeline_ = buildRibbonPipeline(PipelineBuilder::blendAdditive());
-        }
-        ribVert.destroy(); ribFrag.destroy();
+            .build(device);
     }
 
     // Clean up shader modules
@@ -922,11 +604,6 @@ bool M2Renderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout
         bci.size = MAX_GLOW_SPRITES * 9 * sizeof(float);
         vmaCreateBuffer(vkCtx_->getAllocator(), &bci, &aci, &glowVB_, &glowVBAlloc_, &allocInfo);
         glowVBMapped_ = allocInfo.pMappedData;
-
-        // Ribbon vertex buffer — triangle strip: pos(3)+color(3)+alpha(1)+uv(2)=9 floats/vert
-        bci.size = MAX_RIBBON_VERTS * 9 * sizeof(float);
-        vmaCreateBuffer(vkCtx_->getAllocator(), &bci, &aci, &ribbonVB_, &ribbonVBAlloc_, &allocInfo);
-        ribbonVBMapped_ = allocInfo.pMappedData;
     }
 
     // --- Create white fallback texture ---
@@ -1015,20 +692,18 @@ void M2Renderer::shutdown() {
     textureCache.clear();
     textureCacheBytes_ = 0;
     textureCacheCounter_ = 0;
-    texturePropsByPtr_.clear();
+    textureHasAlphaByPtr_.clear();
+    textureColorKeyBlackByPtr_.clear();
     failedTextureCache_.clear();
-    failedTextureRetryAt_.clear();
     loggedTextureLoadFails_.clear();
-    textureLookupSerial_ = 0;
     textureBudgetRejectWarnings_ = 0;
     whiteTexture_.reset();
     glowTexture_.reset();
 
-    // Clean up particle/ribbon buffers
+    // Clean up particle buffers
     if (smokeVB_) { vmaDestroyBuffer(alloc, smokeVB_, smokeVBAlloc_); smokeVB_ = VK_NULL_HANDLE; }
     if (m2ParticleVB_) { vmaDestroyBuffer(alloc, m2ParticleVB_, m2ParticleVBAlloc_); m2ParticleVB_ = VK_NULL_HANDLE; }
     if (glowVB_) { vmaDestroyBuffer(alloc, glowVB_, glowVBAlloc_); glowVB_ = VK_NULL_HANDLE; }
-    if (ribbonVB_) { vmaDestroyBuffer(alloc, ribbonVB_, ribbonVBAlloc_); ribbonVB_ = VK_NULL_HANDLE; }
     smokeParticles.clear();
 
     // Destroy pipelines
@@ -1040,56 +715,22 @@ void M2Renderer::shutdown() {
     destroyPipeline(particlePipeline_);
     destroyPipeline(particleAdditivePipeline_);
     destroyPipeline(smokePipeline_);
-    destroyPipeline(ribbonPipeline_);
-    destroyPipeline(ribbonAdditivePipeline_);
 
     if (pipelineLayout_) { vkDestroyPipelineLayout(device, pipelineLayout_, nullptr); pipelineLayout_ = VK_NULL_HANDLE; }
     if (particlePipelineLayout_) { vkDestroyPipelineLayout(device, particlePipelineLayout_, nullptr); particlePipelineLayout_ = VK_NULL_HANDLE; }
     if (smokePipelineLayout_) { vkDestroyPipelineLayout(device, smokePipelineLayout_, nullptr); smokePipelineLayout_ = VK_NULL_HANDLE; }
-    if (ribbonPipelineLayout_) { vkDestroyPipelineLayout(device, ribbonPipelineLayout_, nullptr); ribbonPipelineLayout_ = VK_NULL_HANDLE; }
 
     // Destroy descriptor pools and layouts
-    if (dummyBoneBuffer_) { vmaDestroyBuffer(alloc, dummyBoneBuffer_, dummyBoneAlloc_); dummyBoneBuffer_ = VK_NULL_HANDLE; }
-    // dummyBoneSet_ is freed implicitly when boneDescPool_ is destroyed
-    dummyBoneSet_ = VK_NULL_HANDLE;
-    // Mega bone SSBO cleanup (sets freed implicitly with boneDescPool_)
-    for (int i = 0; i < 2; i++) {
-        if (megaBoneBuffer_[i]) { vmaDestroyBuffer(alloc, megaBoneBuffer_[i], megaBoneAlloc_[i]); megaBoneBuffer_[i] = VK_NULL_HANDLE; }
-        megaBoneMapped_[i] = nullptr;
-        megaBoneSet_[i] = VK_NULL_HANDLE;
-    }
     if (materialDescPool_) { vkDestroyDescriptorPool(device, materialDescPool_, nullptr); materialDescPool_ = VK_NULL_HANDLE; }
     if (boneDescPool_) { vkDestroyDescriptorPool(device, boneDescPool_, nullptr); boneDescPool_ = VK_NULL_HANDLE; }
-    // Instance data SSBO cleanup (sets freed with instanceDescPool_)
-    for (int i = 0; i < 2; i++) {
-        if (instanceBuffer_[i]) { vmaDestroyBuffer(alloc, instanceBuffer_[i], instanceAlloc_[i]); instanceBuffer_[i] = VK_NULL_HANDLE; }
-        instanceMapped_[i] = nullptr;
-        instanceSet_[i] = VK_NULL_HANDLE;
-    }
-    if (instanceDescPool_) { vkDestroyDescriptorPool(device, instanceDescPool_, nullptr); instanceDescPool_ = VK_NULL_HANDLE; }
-
-    // GPU frustum culling compute pipeline + buffers cleanup
-    if (cullPipeline_) { vkDestroyPipeline(device, cullPipeline_, nullptr); cullPipeline_ = VK_NULL_HANDLE; }
-    if (cullPipelineLayout_) { vkDestroyPipelineLayout(device, cullPipelineLayout_, nullptr); cullPipelineLayout_ = VK_NULL_HANDLE; }
-    for (int i = 0; i < 2; i++) {
-        if (cullUniformBuffer_[i]) { vmaDestroyBuffer(alloc, cullUniformBuffer_[i], cullUniformAlloc_[i]); cullUniformBuffer_[i] = VK_NULL_HANDLE; }
-        if (cullInputBuffer_[i])   { vmaDestroyBuffer(alloc, cullInputBuffer_[i], cullInputAlloc_[i]); cullInputBuffer_[i] = VK_NULL_HANDLE; }
-        if (cullOutputBuffer_[i])  { vmaDestroyBuffer(alloc, cullOutputBuffer_[i], cullOutputAlloc_[i]); cullOutputBuffer_[i] = VK_NULL_HANDLE; }
-        cullUniformMapped_[i] = cullInputMapped_[i] = cullOutputMapped_[i] = nullptr;
-        cullSet_[i] = VK_NULL_HANDLE;
-    }
-    if (cullDescPool_) { vkDestroyDescriptorPool(device, cullDescPool_, nullptr); cullDescPool_ = VK_NULL_HANDLE; }
-    if (cullSetLayout_) { vkDestroyDescriptorSetLayout(device, cullSetLayout_, nullptr); cullSetLayout_ = VK_NULL_HANDLE; }
-
     if (materialSetLayout_) { vkDestroyDescriptorSetLayout(device, materialSetLayout_, nullptr); materialSetLayout_ = VK_NULL_HANDLE; }
     if (boneSetLayout_) { vkDestroyDescriptorSetLayout(device, boneSetLayout_, nullptr); boneSetLayout_ = VK_NULL_HANDLE; }
-    if (instanceSetLayout_) { vkDestroyDescriptorSetLayout(device, instanceSetLayout_, nullptr); instanceSetLayout_ = VK_NULL_HANDLE; }
     if (particleTexLayout_) { vkDestroyDescriptorSetLayout(device, particleTexLayout_, nullptr); particleTexLayout_ = VK_NULL_HANDLE; }
 
     // Destroy shadow resources
     destroyPipeline(shadowPipeline_);
     if (shadowPipelineLayout_) { vkDestroyPipelineLayout(device, shadowPipelineLayout_, nullptr); shadowPipelineLayout_ = VK_NULL_HANDLE; }
-    for (auto& pool : shadowTexPool_) { if (pool) { vkDestroyDescriptorPool(device, pool, nullptr); pool = VK_NULL_HANDLE; } }
+    if (shadowTexPool_) { vkDestroyDescriptorPool(device, shadowTexPool_, nullptr); shadowTexPool_ = VK_NULL_HANDLE; }
     if (shadowParamsPool_) { vkDestroyDescriptorPool(device, shadowParamsPool_, nullptr); shadowParamsPool_ = VK_NULL_HANDLE; }
     if (shadowParamsLayout_) { vkDestroyDescriptorSetLayout(device, shadowParamsLayout_, nullptr); shadowParamsLayout_ = VK_NULL_HANDLE; }
     if (shadowParamsUBO_) { vmaDestroyBuffer(alloc, shadowParamsUBO_, shadowParamsAlloc_); shadowParamsUBO_ = VK_NULL_HANDLE; }
@@ -1102,59 +743,29 @@ void M2Renderer::destroyModelGPU(M2ModelGPU& model) {
     VmaAllocator alloc = vkCtx_->getAllocator();
     if (model.vertexBuffer) { vmaDestroyBuffer(alloc, model.vertexBuffer, model.vertexAlloc); model.vertexBuffer = VK_NULL_HANDLE; }
     if (model.indexBuffer) { vmaDestroyBuffer(alloc, model.indexBuffer, model.indexAlloc); model.indexBuffer = VK_NULL_HANDLE; }
-    VkDevice device = vkCtx_->getDevice();
     for (auto& batch : model.batches) {
-        if (batch.materialSet) { vkFreeDescriptorSets(device, materialDescPool_, 1, &batch.materialSet); batch.materialSet = VK_NULL_HANDLE; }
         if (batch.materialUBO) { vmaDestroyBuffer(alloc, batch.materialUBO, batch.materialUBOAlloc); batch.materialUBO = VK_NULL_HANDLE; }
+        // materialSet freed when pool is reset/destroyed
     }
-    // Free pre-allocated particle texture descriptor sets
-    for (auto& pSet : model.particleTexSets) {
-        if (pSet) { vkFreeDescriptorSets(device, materialDescPool_, 1, &pSet); pSet = VK_NULL_HANDLE; }
-    }
-    model.particleTexSets.clear();
-    // Free ribbon texture descriptor sets
-    for (auto& rSet : model.ribbonTexSets) {
-        if (rSet) { vkFreeDescriptorSets(device, materialDescPool_, 1, &rSet); rSet = VK_NULL_HANDLE; }
-    }
-    model.ribbonTexSets.clear();
 }
 
-void M2Renderer::destroyInstanceBones(M2Instance& inst, bool defer) {
+void M2Renderer::destroyInstanceBones(M2Instance& inst) {
     if (!vkCtx_) return;
     VkDevice device = vkCtx_->getDevice();
     VmaAllocator alloc = vkCtx_->getAllocator();
     for (int i = 0; i < 2; i++) {
-        // Snapshot handles before clearing the instance — needed for both
-        // immediate and deferred paths.
-        VkDescriptorSet boneSet = inst.boneSet[i];
-        ::VkBuffer boneBuf = inst.boneBuffer[i];
-        VmaAllocation boneAlloc = inst.boneAlloc[i];
-        inst.boneSet[i] = VK_NULL_HANDLE;
-        inst.boneBuffer[i] = VK_NULL_HANDLE;
-        inst.boneMapped[i] = nullptr;
-
-        if (!defer) {
-            // Immediate destruction (safe after vkDeviceWaitIdle)
-            if (boneSet != VK_NULL_HANDLE) {
-                vkFreeDescriptorSets(device, boneDescPool_, 1, &boneSet);
-            }
-            if (boneBuf) {
-                vmaDestroyBuffer(alloc, boneBuf, boneAlloc);
-            }
-        } else if (boneSet != VK_NULL_HANDLE || boneBuf) {
-            // Deferred destruction — the loop destroys bone sets for ALL frame
-            // slots, so the other slot's command buffer may still be in flight.
-            // Must wait for all fences, not just the current frame's.
-            VkDescriptorPool pool = boneDescPool_;
-            vkCtx_->deferAfterAllFrameFences([device, alloc, pool, boneSet, boneBuf, boneAlloc]() {
-                if (boneSet != VK_NULL_HANDLE) {
-                    VkDescriptorSet s = boneSet;
-                    vkFreeDescriptorSets(device, pool, 1, &s);
-                }
-                if (boneBuf) {
-                    vmaDestroyBuffer(alloc, boneBuf, boneAlloc);
-                }
-            });
+        // Free bone descriptor set so the pool slot is immediately reusable.
+        // Without this, the pool fills up over a play session as tiles stream
+        // in/out, eventually causing vkAllocateDescriptorSets to fail and
+        // making animated instances invisible (perceived as flickering).
+        if (inst.boneSet[i] != VK_NULL_HANDLE) {
+            vkFreeDescriptorSets(device, boneDescPool_, 1, &inst.boneSet[i]);
+            inst.boneSet[i] = VK_NULL_HANDLE;
+        }
+        if (inst.boneBuffer[i]) {
+            vmaDestroyBuffer(alloc, inst.boneBuffer[i], inst.boneAlloc[i]);
+            inst.boneBuffer[i] = VK_NULL_HANDLE;
+            inst.boneMapped[i] = nullptr;
         }
     }
 }
@@ -1165,11 +776,7 @@ VkDescriptorSet M2Renderer::allocateMaterialSet() {
     ai.descriptorSetCount = 1;
     ai.pSetLayouts = &materialSetLayout_;
     VkDescriptorSet set = VK_NULL_HANDLE;
-    VkResult result = vkAllocateDescriptorSets(vkCtx_->getDevice(), &ai, &set);
-    if (result != VK_SUCCESS) {
-        LOG_ERROR("M2Renderer: material descriptor set allocation failed (", result, ")");
-        return VK_NULL_HANDLE;
-    }
+    vkAllocateDescriptorSets(vkCtx_->getDevice(), &ai, &set);
     return set;
 }
 
@@ -1179,11 +786,7 @@ VkDescriptorSet M2Renderer::allocateBoneSet() {
     ai.descriptorSetCount = 1;
     ai.pSetLayouts = &boneSetLayout_;
     VkDescriptorSet set = VK_NULL_HANDLE;
-    VkResult result = vkAllocateDescriptorSets(vkCtx_->getDevice(), &ai, &set);
-    if (result != VK_SUCCESS) {
-        LOG_ERROR("M2Renderer: bone descriptor set allocation failed (", result, ")");
-        return VK_NULL_HANDLE;
-    }
+    vkAllocateDescriptorSets(vkCtx_->getDevice(), &ai, &set);
     return set;
 }
 
@@ -1258,9 +861,6 @@ void M2ModelGPU::CollisionMesh::getFloorTrisInRange(
     int cxMax = std::clamp(static_cast<int>((maxX - gridOrigin.x) / CELL_SIZE), 0, gridCellsX - 1);
     int cyMin = std::clamp(static_cast<int>((minY - gridOrigin.y) / CELL_SIZE), 0, gridCellsY - 1);
     int cyMax = std::clamp(static_cast<int>((maxY - gridOrigin.y) / CELL_SIZE), 0, gridCellsY - 1);
-    const size_t cellCount = static_cast<size_t>(cxMax - cxMin + 1) *
-                             static_cast<size_t>(cyMax - cyMin + 1);
-    out.reserve(cellCount * 8);
     for (int cy = cyMin; cy <= cyMax; cy++) {
         for (int cx = cxMin; cx <= cxMax; cx++) {
             const auto& cell = cellFloorTris[cy * gridCellsX + cx];
@@ -1280,9 +880,6 @@ void M2ModelGPU::CollisionMesh::getWallTrisInRange(
     int cxMax = std::clamp(static_cast<int>((maxX - gridOrigin.x) / CELL_SIZE), 0, gridCellsX - 1);
     int cyMin = std::clamp(static_cast<int>((minY - gridOrigin.y) / CELL_SIZE), 0, gridCellsY - 1);
     int cyMax = std::clamp(static_cast<int>((maxY - gridOrigin.y) / CELL_SIZE), 0, gridCellsY - 1);
-    const size_t cellCount = static_cast<size_t>(cxMax - cxMin + 1) *
-                             static_cast<size_t>(cyMax - cyMin + 1);
-    out.reserve(cellCount * 8);
     for (int cy = cyMin; cy <= cyMax; cy++) {
         for (int cx = cxMin; cx <= cxMax; cx++) {
             const auto& cell = cellWallTris[cy * gridCellsX + cx];
@@ -1313,15 +910,23 @@ bool M2Renderer::loadModel(const pipeline::M2Model& model, uint32_t modelId) {
 
     bool hasGeometry = !model.vertices.empty() && !model.indices.empty();
     bool hasParticles = !model.particleEmitters.empty();
-    bool hasRibbons   = !model.ribbonEmitters.empty();
-    if (!hasGeometry && !hasParticles && !hasRibbons) {
-        LOG_WARNING("M2 model has no renderable content: ", model.name);
+    if (!hasGeometry && !hasParticles) {
+        LOG_WARNING("M2 model has no geometry and no particles: ", model.name);
         return false;
     }
 
     M2ModelGPU gpuModel;
     gpuModel.name = model.name;
 
+    // Detect invisible trap models (event objects that should not render or collide)
+    std::string lowerName = model.name;
+    std::transform(lowerName.begin(), lowerName.end(), lowerName.begin(),
+                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+    bool isInvisibleTrap = (lowerName.find("invisibletrap") != std::string::npos);
+    gpuModel.isInvisibleTrap = isInvisibleTrap;
+    if (isInvisibleTrap) {
+        LOG_INFO("Loading InvisibleTrap model: ", model.name, " (will be invisible, no collision)");
+    }
     // Use tight bounds from actual vertices for collision/camera occlusion.
     // Header bounds in some M2s are overly conservative.
     glm::vec3 tightMin(0.0f);
@@ -1334,48 +939,156 @@ bool M2Renderer::loadModel(const pipeline::M2Model& model, uint32_t modelId) {
             tightMax = glm::max(tightMax, v.position);
         }
     }
+    bool foliageOrTreeLike = false;
+    bool chestName = false;
+    bool groundDetailModel = false;
+    {
+        std::string lowerName = model.name;
+        std::transform(lowerName.begin(), lowerName.end(), lowerName.begin(),
+                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+        gpuModel.collisionSteppedFountain = (lowerName.find("fountain") != std::string::npos);
 
-    // Classify model from name and geometry — pure function, no GPU dependencies.
-    auto cls = classifyM2Model(model.name, tightMin, tightMax,
-                                model.vertices.size(),
-                                model.particleEmitters.size());
-    const bool isInvisibleTrap   = cls.isInvisibleTrap;
-    const bool groundDetailModel = cls.isGroundDetail;
-    if (isInvisibleTrap) {
-        LOG_INFO("Loading InvisibleTrap model: ", model.name, " (will be invisible, no collision)");
+        glm::vec3 dims = tightMax - tightMin;
+        float horiz = std::max(dims.x, dims.y);
+        float vert = std::max(0.0f, dims.z);
+        bool lowWideShape = (horiz > 1.4f && vert > 0.2f && vert < horiz * 0.70f);
+        bool likelyCurbName =
+            (lowerName.find("planter") != std::string::npos) ||
+            (lowerName.find("curb") != std::string::npos) ||
+            (lowerName.find("base") != std::string::npos) ||
+            (lowerName.find("ring") != std::string::npos) ||
+            (lowerName.find("well") != std::string::npos);
+        bool knownStormwindPlanter =
+            (lowerName.find("stormwindplanter") != std::string::npos) ||
+            (lowerName.find("stormwindwindowplanter") != std::string::npos);
+        bool lowPlatformShape = (horiz > 1.8f && vert > 0.2f && vert < 1.8f);
+        bool bridgeName =
+            (lowerName.find("bridge") != std::string::npos) ||
+            (lowerName.find("plank") != std::string::npos) ||
+            (lowerName.find("walkway") != std::string::npos);
+        gpuModel.collisionSteppedLowPlatform = (!gpuModel.collisionSteppedFountain) &&
+                                               (knownStormwindPlanter ||
+                                                bridgeName ||
+                                                (likelyCurbName && (lowPlatformShape || lowWideShape)));
+        gpuModel.collisionBridge = bridgeName;
+
+        bool isPlanter = (lowerName.find("planter") != std::string::npos);
+        gpuModel.collisionPlanter = isPlanter;
+        bool statueName =
+            (lowerName.find("statue") != std::string::npos) ||
+            (lowerName.find("monument") != std::string::npos) ||
+            (lowerName.find("sculpture") != std::string::npos);
+        gpuModel.collisionStatue = statueName;
+        bool smallSolidPropName =
+            statueName ||
+            (lowerName.find("crate") != std::string::npos) ||
+            (lowerName.find("box") != std::string::npos) ||
+            (lowerName.find("chest") != std::string::npos) ||
+            (lowerName.find("barrel") != std::string::npos);
+        chestName = (lowerName.find("chest") != std::string::npos);
+        bool foliageName =
+            (lowerName.find("bush") != std::string::npos) ||
+            (lowerName.find("grass") != std::string::npos) ||
+            (lowerName.find("drygrass") != std::string::npos) ||
+            (lowerName.find("dry_grass") != std::string::npos) ||
+            (lowerName.find("dry-grass") != std::string::npos) ||
+            (lowerName.find("deadgrass") != std::string::npos) ||
+            (lowerName.find("dead_grass") != std::string::npos) ||
+            (lowerName.find("dead-grass") != std::string::npos) ||
+            ((lowerName.find("plant") != std::string::npos) && !isPlanter) ||
+            (lowerName.find("flower") != std::string::npos) ||
+            (lowerName.find("shrub") != std::string::npos) ||
+            (lowerName.find("fern") != std::string::npos) ||
+            (lowerName.find("vine") != std::string::npos) ||
+            (lowerName.find("lily") != std::string::npos) ||
+            (lowerName.find("weed") != std::string::npos) ||
+            (lowerName.find("wheat") != std::string::npos) ||
+            (lowerName.find("pumpkin") != std::string::npos) ||
+            (lowerName.find("firefly") != std::string::npos) ||
+            (lowerName.find("fireflies") != std::string::npos) ||
+            (lowerName.find("fireflys") != std::string::npos) ||
+            (lowerName.find("mushroom") != std::string::npos) ||
+            (lowerName.find("fungus") != std::string::npos) ||
+            (lowerName.find("toadstool") != std::string::npos) ||
+            (lowerName.find("root") != std::string::npos) ||
+            (lowerName.find("branch") != std::string::npos) ||
+            (lowerName.find("thorn") != std::string::npos) ||
+            (lowerName.find("moss") != std::string::npos) ||
+            (lowerName.find("ivy") != std::string::npos) ||
+            (lowerName.find("seaweed") != std::string::npos) ||
+            (lowerName.find("kelp") != std::string::npos) ||
+            (lowerName.find("cattail") != std::string::npos) ||
+            (lowerName.find("reed") != std::string::npos) ||
+            (lowerName.find("palm") != std::string::npos) ||
+            (lowerName.find("bamboo") != std::string::npos) ||
+            (lowerName.find("banana") != std::string::npos) ||
+            (lowerName.find("coconut") != std::string::npos) ||
+            (lowerName.find("canopy") != std::string::npos) ||
+            (lowerName.find("hedge") != std::string::npos) ||
+            (lowerName.find("cactus") != std::string::npos) ||
+            (lowerName.find("leaf") != std::string::npos) ||
+            (lowerName.find("leaves") != std::string::npos) ||
+            (lowerName.find("stalk") != std::string::npos) ||
+            (lowerName.find("corn") != std::string::npos) ||
+            (lowerName.find("crop") != std::string::npos) ||
+            (lowerName.find("hay") != std::string::npos) ||
+            (lowerName.find("frond") != std::string::npos) ||
+            (lowerName.find("algae") != std::string::npos) ||
+            (lowerName.find("coral") != std::string::npos);
+        bool treeLike = (lowerName.find("tree") != std::string::npos);
+        foliageOrTreeLike = (foliageName || treeLike);
+        groundDetailModel =
+            (lowerName.find("\\nodxt\\detail\\") != std::string::npos) ||
+            (lowerName.find("\\detail\\") != std::string::npos);
+        bool hardTreePart =
+            (lowerName.find("trunk") != std::string::npos) ||
+            (lowerName.find("stump") != std::string::npos) ||
+            (lowerName.find("log") != std::string::npos);
+        // Trees with visible trunks get collision. Threshold: canopy wider than 6
+        // model units AND taller than 4 units (filters out small bushes/saplings).
+        bool treeWithTrunk = treeLike && !hardTreePart && !foliageName && horiz > 6.0f && vert > 4.0f;
+        bool softTree = treeLike && !hardTreePart && !treeWithTrunk;
+        bool forceSolidCurb = gpuModel.collisionSteppedLowPlatform || knownStormwindPlanter || likelyCurbName || gpuModel.collisionPlanter;
+        bool narrowVerticalName =
+            (lowerName.find("lamp") != std::string::npos) ||
+            (lowerName.find("lantern") != std::string::npos) ||
+            (lowerName.find("post") != std::string::npos) ||
+            (lowerName.find("pole") != std::string::npos);
+        bool narrowVerticalShape =
+            (horiz > 0.12f && horiz < 2.0f && vert > 2.2f && vert > horiz * 1.8f);
+        gpuModel.collisionTreeTrunk = treeWithTrunk;
+        gpuModel.collisionNarrowVerticalProp =
+            !gpuModel.collisionSteppedFountain &&
+            !gpuModel.collisionSteppedLowPlatform &&
+            (narrowVerticalName || narrowVerticalShape);
+        bool genericSolidPropShape =
+            (horiz > 0.6f && horiz < 6.0f && vert > 0.30f && vert < 4.0f && vert > horiz * 0.16f) ||
+            statueName;
+        bool curbLikeName =
+            (lowerName.find("curb") != std::string::npos) ||
+            (lowerName.find("planter") != std::string::npos) ||
+            (lowerName.find("ring") != std::string::npos) ||
+            (lowerName.find("well") != std::string::npos) ||
+            (lowerName.find("base") != std::string::npos);
+        bool lowPlatformLikeShape = lowWideShape || lowPlatformShape;
+        bool carpetOrRug =
+            (lowerName.find("carpet") != std::string::npos) ||
+            (lowerName.find("rug") != std::string::npos);
+        gpuModel.collisionSmallSolidProp =
+            !gpuModel.collisionSteppedFountain &&
+            !gpuModel.collisionSteppedLowPlatform &&
+            !gpuModel.collisionNarrowVerticalProp &&
+            !gpuModel.collisionTreeTrunk &&
+            !curbLikeName &&
+            !lowPlatformLikeShape &&
+            (smallSolidPropName || (genericSolidPropShape && !foliageName && !softTree));
+        // Disable collision for foliage, soft trees, and decorative carpets/rugs
+        gpuModel.collisionNoBlock = ((foliageName || softTree || carpetOrRug) &&
+                                     !forceSolidCurb);
     }
-
-    gpuModel.isInvisibleTrap             = cls.isInvisibleTrap;
-    gpuModel.collisionSteppedFountain    = cls.collisionSteppedFountain;
-    gpuModel.collisionSteppedLowPlatform = cls.collisionSteppedLowPlatform;
-    gpuModel.collisionBridge             = cls.collisionBridge;
-    gpuModel.collisionPlanter            = cls.collisionPlanter;
-    gpuModel.collisionStatue             = cls.collisionStatue;
-    gpuModel.collisionTreeTrunk          = cls.collisionTreeTrunk;
-    gpuModel.collisionNarrowVerticalProp = cls.collisionNarrowVerticalProp;
-    gpuModel.collisionSmallSolidProp     = cls.collisionSmallSolidProp;
-    gpuModel.collisionNoBlock            = cls.collisionNoBlock;
-    gpuModel.isGroundDetail              = cls.isGroundDetail;
-    gpuModel.isFoliageLike               = cls.isFoliageLike;
-    gpuModel.disableAnimation            = cls.disableAnimation;
-    gpuModel.shadowWindFoliage           = cls.shadowWindFoliage;
-    gpuModel.isFireflyEffect             = cls.isFireflyEffect;
-    gpuModel.isSmoke                     = cls.isSmoke;
-    gpuModel.isSpellEffect               = cls.isSpellEffect;
-    gpuModel.isLavaModel                 = cls.isLavaModel;
-    gpuModel.isInstancePortal            = cls.isInstancePortal;
-    gpuModel.isWaterVegetation           = cls.isWaterVegetation;
-    gpuModel.isElvenLike                 = cls.isElvenLike;
-    gpuModel.isLanternLike               = cls.isLanternLike;
-    gpuModel.isKoboldFlame               = cls.isKoboldFlame;
     gpuModel.boundMin = tightMin;
     gpuModel.boundMax = tightMax;
     gpuModel.boundRadius = model.boundRadius;
-    // Fallback: compute bound radius from vertex extents when M2 header reports 0
-    if (gpuModel.boundRadius < 0.01f && !model.vertices.empty()) {
-        glm::vec3 extent = tightMax - tightMin;
-        gpuModel.boundRadius = glm::length(extent) * 0.5f;
-    }
     gpuModel.indexCount = static_cast<uint32_t>(model.indices.size());
     gpuModel.vertexCount = static_cast<uint32_t>(model.vertices.size());
 
@@ -1390,7 +1103,78 @@ bool M2Renderer::loadModel(const pipeline::M2Model& model, uint32_t modelId) {
             break;
         }
     }
-
+    bool ambientCreature =
+        (lowerName.find("firefly") != std::string::npos) ||
+        (lowerName.find("fireflies") != std::string::npos) ||
+        (lowerName.find("fireflys") != std::string::npos) ||
+        (lowerName.find("dragonfly") != std::string::npos) ||
+        (lowerName.find("dragonflies") != std::string::npos) ||
+        (lowerName.find("butterfly") != std::string::npos) ||
+        (lowerName.find("moth") != std::string::npos);
+    gpuModel.disableAnimation = (foliageOrTreeLike && !ambientCreature) || chestName;
+    gpuModel.shadowWindFoliage = foliageOrTreeLike && !ambientCreature;
+    gpuModel.isFoliageLike = foliageOrTreeLike && !ambientCreature;
+    gpuModel.isElvenLike =
+        (lowerName.find("elf") != std::string::npos) ||
+        (lowerName.find("elven") != std::string::npos) ||
+        (lowerName.find("quel") != std::string::npos);
+    gpuModel.isLanternLike =
+        (lowerName.find("lantern") != std::string::npos) ||
+        (lowerName.find("lamp") != std::string::npos) ||
+        (lowerName.find("light") != std::string::npos);
+    gpuModel.isKoboldFlame =
+        (lowerName.find("kobold") != std::string::npos) &&
+        ((lowerName.find("candle") != std::string::npos) ||
+         (lowerName.find("torch") != std::string::npos) ||
+         (lowerName.find("mine") != std::string::npos));
+    gpuModel.isGroundDetail = groundDetailModel;
+    if (groundDetailModel) {
+        // Ground clutter (grass/pebbles/detail cards) should never block camera/movement.
+        gpuModel.collisionNoBlock = true;
+    }
+    // Spell effect / pure-visual models: particle-dominated with minimal geometry,
+    // or named effect models (light shafts, portals, emitters, spotlights)
+    bool effectByName =
+        (lowerName.find("lightshaft") != std::string::npos) ||
+        (lowerName.find("volumetriclight") != std::string::npos) ||
+        (lowerName.find("instanceportal") != std::string::npos) ||
+        (lowerName.find("instancenewportal") != std::string::npos) ||
+        (lowerName.find("mageportal") != std::string::npos) ||
+        (lowerName.find("worldtreeportal") != std::string::npos) ||
+        (lowerName.find("particleemitter") != std::string::npos) ||
+        (lowerName.find("bubbles") != std::string::npos) ||
+        (lowerName.find("spotlight") != std::string::npos) ||
+        (lowerName.find("hazardlight") != std::string::npos) ||
+        (lowerName.find("lavasplash") != std::string::npos) ||
+        (lowerName.find("lavabubble") != std::string::npos) ||
+        (lowerName.find("lavasteam") != std::string::npos) ||
+        (lowerName.find("wisps") != std::string::npos);
+    gpuModel.isSpellEffect = effectByName ||
+                              (hasParticles && model.vertices.size() <= 200 &&
+                               model.particleEmitters.size() >= 3);
+    gpuModel.isLavaModel =
+        (lowerName.find("forgelava") != std::string::npos) ||
+        (lowerName.find("lavapot") != std::string::npos) ||
+        (lowerName.find("lavaflow") != std::string::npos);
+    gpuModel.isInstancePortal =
+        (lowerName.find("instanceportal") != std::string::npos) ||
+        (lowerName.find("instancenewportal") != std::string::npos) ||
+        (lowerName.find("portalfx") != std::string::npos) ||
+        (lowerName.find("spellportal") != std::string::npos);
+    // Instance portals are spell effects too (additive blend, no collision)
+    if (gpuModel.isInstancePortal) {
+        gpuModel.isSpellEffect = true;
+    }
+    // Water vegetation: cattails, reeds, bulrushes, kelp, seaweed, lilypad near water
+    gpuModel.isWaterVegetation =
+        (lowerName.find("cattail") != std::string::npos) ||
+        (lowerName.find("reed") != std::string::npos) ||
+        (lowerName.find("bulrush") != std::string::npos) ||
+        (lowerName.find("seaweed") != std::string::npos) ||
+        (lowerName.find("kelp") != std::string::npos) ||
+        (lowerName.find("lilypad") != std::string::npos);
+    // Ambient creature effects: particle-based glow (exempt from particle dampeners)
+    gpuModel.isFireflyEffect = ambientCreature;
 
     // Build collision mesh + spatial grid from M2 bounding geometry
     gpuModel.collision.vertices = model.collisionVertices;
@@ -1401,6 +1185,14 @@ bool M2Renderer::loadModel(const pipeline::M2Model& model, uint32_t modelId) {
             " tris, grid ", gpuModel.collision.gridCellsX, "x", gpuModel.collision.gridCellsY);
     }
 
+    // Flag smoke models for UV scroll animation (particle emitters not implemented)
+    {
+        std::string smokeName = model.name;
+        std::transform(smokeName.begin(), smokeName.end(), smokeName.begin(),
+                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+        gpuModel.isSmoke = (smokeName.find("smoke") != std::string::npos);
+    }
+
     // Identify idle variation sequences (animation ID 0 = Stand)
     for (int i = 0; i < static_cast<int>(model.sequences.size()); i++) {
         if (model.sequences[i].id == 0 && model.sequences[i].duration > 0) {
@@ -1461,10 +1253,6 @@ bool M2Renderer::loadModel(const pipeline::M2Model& model, uint32_t modelId) {
             gpuModel.indexBuffer = buf.buffer;
             gpuModel.indexAlloc = buf.allocation;
         }
-
-        if (!gpuModel.vertexBuffer || !gpuModel.indexBuffer) {
-            LOG_ERROR("M2Renderer::loadModel: GPU buffer upload failed for model ", modelId);
-        }
     }
 
     // Load ALL textures from the model into a local vector.
@@ -1521,7 +1309,14 @@ bool M2Renderer::loadModel(const pipeline::M2Model& model, uint32_t modelId) {
 
     static const bool kGlowDiag = envFlagEnabled("WOWEE_M2_GLOW_DIAG", false);
     if (kGlowDiag) {
-        if (gpuModel.isLanternLike) {
+        std::string lowerName = model.name;
+        std::transform(lowerName.begin(), lowerName.end(), lowerName.begin(),
+                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+        const bool lanternLike =
+            (lowerName.find("lantern") != std::string::npos) ||
+            (lowerName.find("lamp") != std::string::npos) ||
+            (lowerName.find("light") != std::string::npos);
+        if (lanternLike) {
             for (size_t ti = 0; ti < model.textures.size(); ++ti) {
                 const std::string key = (ti < textureKeysLower.size()) ? textureKeysLower[ti] : std::string();
                 LOG_DEBUG("M2 GLOW TEX '", model.name, "' tex[", ti, "]='", key, "' flags=0x",
@@ -1537,80 +1332,9 @@ bool M2Renderer::loadModel(const pipeline::M2Model& model, uint32_t modelId) {
         uint16_t texIdx = model.particleEmitters[ei].texture;
         if (texIdx < allTextures.size() && allTextures[texIdx] != nullptr) {
             gpuModel.particleTextures[ei] = allTextures[texIdx];
-        } else {
-            LOG_WARNING("M2 '", model.name, "' particle emitter[", ei,
-                        "] texture index ", texIdx, " out of range (", allTextures.size(),
-                        " textures) — using white fallback");
         }
     }
 
-    // Pre-allocate one stable descriptor set per particle emitter to avoid per-frame allocation.
-    // This prevents materialDescPool_ exhaustion when many emitters are active each frame.
-    if (particleTexLayout_ && materialDescPool_ && !model.particleEmitters.empty()) {
-        VkDevice device = vkCtx_->getDevice();
-        gpuModel.particleTexSets.resize(model.particleEmitters.size(), VK_NULL_HANDLE);
-        for (size_t ei = 0; ei < model.particleEmitters.size(); ei++) {
-            VkDescriptorSetAllocateInfo ai{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
-            ai.descriptorPool = materialDescPool_;
-            ai.descriptorSetCount = 1;
-            ai.pSetLayouts = &particleTexLayout_;
-            if (vkAllocateDescriptorSets(device, &ai, &gpuModel.particleTexSets[ei]) == VK_SUCCESS) {
-                VkTexture* tex = gpuModel.particleTextures[ei];
-                VkDescriptorImageInfo imgInfo = tex->descriptorInfo();
-                VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
-                write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-                write.dstSet = gpuModel.particleTexSets[ei];
-                write.dstBinding = 0;
-                write.descriptorCount = 1;
-                write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-                write.pImageInfo = &imgInfo;
-                vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
-            }
-        }
-    }
-
-    // Copy ribbon emitter data and resolve textures
-    gpuModel.ribbonEmitters = model.ribbonEmitters;
-    if (!model.ribbonEmitters.empty()) {
-        VkDevice device = vkCtx_->getDevice();
-        gpuModel.ribbonTextures.resize(model.ribbonEmitters.size(), whiteTexture_.get());
-        gpuModel.ribbonTexSets.resize(model.ribbonEmitters.size(), VK_NULL_HANDLE);
-        for (size_t ri = 0; ri < model.ribbonEmitters.size(); ri++) {
-            // Resolve texture via textureLookup table
-            uint16_t texLookupIdx = model.ribbonEmitters[ri].textureIndex;
-            uint32_t texIdx = (texLookupIdx < model.textureLookup.size())
-                              ? model.textureLookup[texLookupIdx] : UINT32_MAX;
-            if (texIdx < allTextures.size() && allTextures[texIdx] != nullptr) {
-                gpuModel.ribbonTextures[ri] = allTextures[texIdx];
-            } else {
-                LOG_WARNING("M2 '", model.name, "' ribbon emitter[", ri,
-                            "] texLookup=", texLookupIdx, " resolved texIdx=", texIdx,
-                            " out of range (", allTextures.size(),
-                            " textures) — using white fallback");
-            }
-            // Allocate descriptor set (reuse particleTexLayout_ = single sampler)
-            if (particleTexLayout_ && materialDescPool_) {
-                VkDescriptorSetAllocateInfo ai{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
-                ai.descriptorPool = materialDescPool_;
-                ai.descriptorSetCount = 1;
-                ai.pSetLayouts = &particleTexLayout_;
-                if (vkAllocateDescriptorSets(device, &ai, &gpuModel.ribbonTexSets[ri]) == VK_SUCCESS) {
-                    VkTexture* tex = gpuModel.ribbonTextures[ri];
-                    VkDescriptorImageInfo imgInfo = tex->descriptorInfo();
-                    VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
-                    write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-                    write.dstSet = gpuModel.ribbonTexSets[ri];
-                    write.dstBinding = 0;
-                    write.descriptorCount = 1;
-                    write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-                    write.pImageInfo = &imgInfo;
-                    vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
-                }
-            }
-        }
-        LOG_DEBUG("  Ribbon emitters loaded: ", model.ribbonEmitters.size());
-    }
-
     // Copy texture transform data for UV animation
     gpuModel.textureTransforms = model.textureTransforms;
     gpuModel.textureTransformLookup = model.textureTransformLookup;
@@ -1633,7 +1357,6 @@ bool M2Renderer::loadModel(const pipeline::M2Model& model, uint32_t modelId) {
             if (batch.materialIndex < model.materials.size()) {
                 bgpu.blendMode = model.materials[batch.materialIndex].blendMode;
                 bgpu.materialFlags = model.materials[batch.materialIndex].flags;
-                if (bgpu.blendMode >= 2) gpuModel.hasTransparentBatches = true;
             }
 
             // Copy LOD level from batch
@@ -1656,9 +1379,6 @@ bool M2Renderer::loadModel(const pipeline::M2Model& model, uint32_t modelId) {
                     bgpu.texFlags = static_cast<uint8_t>(model.textures[texIdx].flags & 0x3);
                 }
             } else if (!allTextures.empty()) {
-                LOG_WARNING("M2 '", model.name, "' batch textureIndex ", batch.textureIndex,
-                            " out of range (textureLookup size=", model.textureLookup.size(),
-                            ") — falling back to texture[0]");
                 tex = allTextures[0];
                 texFailed = !textureLoadFailed.empty() && textureLoadFailed[0];
                 if (!textureKeysLower.empty()) {
@@ -1675,47 +1395,83 @@ bool M2Renderer::loadModel(const pipeline::M2Model& model, uint32_t modelId) {
                 }
             }
             bgpu.texture = tex;
-            const auto tcls = classifyBatchTexture(batchTexKeyLower);
-            const bool modelLanternFamily = gpuModel.isLanternLike;
+            const bool exactLanternGlowTexture =
+                (batchTexKeyLower == "world\\expansion06\\doodads\\nightelf\\7ne_druid_streetlamp01_light.blp") ||
+                (batchTexKeyLower == "world\\generic\\nightelf\\passive doodads\\lamps\\glowblue32.blp") ||
+                (batchTexKeyLower == "world\\generic\\human\\passive doodads\\stormwind\\t_vfx_glow01_64.blp") ||
+                (batchTexKeyLower == "world\\azeroth\\karazahn\\passivedoodads\\bonfire\\flamelicksmallblue.blp") ||
+                (batchTexKeyLower == "world\\generic\\nightelf\\passive doodads\\magicalimplements\\glow.blp");
+            const bool texHasGlowToken =
+                (batchTexKeyLower.find("glow") != std::string::npos) ||
+                (batchTexKeyLower.find("flare") != std::string::npos) ||
+                (batchTexKeyLower.find("halo") != std::string::npos) ||
+                (batchTexKeyLower.find("light") != std::string::npos);
+            const bool texHasFlameToken =
+                (batchTexKeyLower.find("flame") != std::string::npos) ||
+                (batchTexKeyLower.find("fire") != std::string::npos) ||
+                (batchTexKeyLower.find("flamelick") != std::string::npos) ||
+                (batchTexKeyLower.find("ember") != std::string::npos);
+            const bool texGlowCardToken =
+                (batchTexKeyLower.find("glow") != std::string::npos) ||
+                (batchTexKeyLower.find("flamelick") != std::string::npos) ||
+                (batchTexKeyLower.find("lensflare") != std::string::npos) ||
+                (batchTexKeyLower.find("t_vfx") != std::string::npos) ||
+                (batchTexKeyLower.find("lightbeam") != std::string::npos) ||
+                (batchTexKeyLower.find("glowball") != std::string::npos) ||
+                (batchTexKeyLower.find("genericglow") != std::string::npos);
+            const bool texLikelyFlame =
+                (batchTexKeyLower.find("fire") != std::string::npos) ||
+                (batchTexKeyLower.find("flame") != std::string::npos) ||
+                (batchTexKeyLower.find("torch") != std::string::npos);
+            const bool texLanternFamily =
+                (batchTexKeyLower.find("lantern") != std::string::npos) ||
+                (batchTexKeyLower.find("lamp") != std::string::npos) ||
+                (batchTexKeyLower.find("elf") != std::string::npos) ||
+                (batchTexKeyLower.find("silvermoon") != std::string::npos) ||
+                (batchTexKeyLower.find("quel") != std::string::npos) ||
+                (batchTexKeyLower.find("thalas") != std::string::npos);
+            const bool modelLanternFamily =
+                (lowerName.find("lantern") != std::string::npos) ||
+                (lowerName.find("lamp") != std::string::npos) ||
+                (lowerName.find("light") != std::string::npos);
             bgpu.lanternGlowHint =
-                tcls.exactLanternGlowTex ||
-                ((tcls.hasGlowToken || (modelLanternFamily && tcls.hasFlameToken)) &&
-                 (tcls.lanternFamily || modelLanternFamily) &&
-                 (!tcls.likelyFlame || modelLanternFamily));
-            bgpu.glowCardLike = bgpu.lanternGlowHint && tcls.hasGlowCardToken;
-            bgpu.glowTint = tcls.glowTint;
+                exactLanternGlowTexture ||
+                ((texHasGlowToken || (modelLanternFamily && texHasFlameToken)) &&
+                 (texLanternFamily || modelLanternFamily) &&
+                 (!texLikelyFlame || modelLanternFamily));
+            bgpu.glowCardLike = bgpu.lanternGlowHint && texGlowCardToken;
+            const bool texCoolTint =
+                (batchTexKeyLower.find("blue") != std::string::npos) ||
+                (batchTexKeyLower.find("nightelf") != std::string::npos) ||
+                (batchTexKeyLower.find("arcane") != std::string::npos);
+            const bool texRedTint =
+                (batchTexKeyLower.find("red") != std::string::npos) ||
+                (batchTexKeyLower.find("scarlet") != std::string::npos) ||
+                (batchTexKeyLower.find("ruby") != std::string::npos);
+            bgpu.glowTint = texCoolTint ? 1 : (texRedTint ? 2 : 0);
+            bool texHasAlpha = false;
             if (tex != nullptr && tex != whiteTexture_.get()) {
-                auto pit = texturePropsByPtr_.find(tex);
-                if (pit != texturePropsByPtr_.end()) {
-                    bgpu.hasAlpha = pit->second.hasAlpha;
-                    bgpu.colorKeyBlack = pit->second.colorKeyBlack;
-                }
+                auto ait = textureHasAlphaByPtr_.find(tex);
+                texHasAlpha = (ait != textureHasAlphaByPtr_.end()) ? ait->second : false;
             }
+            bgpu.hasAlpha = texHasAlpha;
+            bool colorKeyBlack = false;
+            if (tex != nullptr && tex != whiteTexture_.get()) {
+                auto cit = textureColorKeyBlackByPtr_.find(tex);
+                colorKeyBlack = (cit != textureColorKeyBlackByPtr_.end()) ? cit->second : false;
+            }
+            bgpu.colorKeyBlack = colorKeyBlack;
             // textureCoordIndex is an index into a texture coord combo table, not directly
             // a UV set selector. Most batches have index=0 (UV set 0). We always use UV set 0
             // since we don't have the full combo table — dual-UV effects are rare edge cases.
             bgpu.textureUnit = 0;
 
-            // Start at full opacity; hide only if texture failed to load.
+            // Batch is hidden only when its named texture failed to load (avoids white shell artifacts).
+            // Do NOT bake transparency/color animation tracks here — they animate over time and
+            // baking the first keyframe value causes legitimate meshes to become invisible.
+            // Keep terrain clutter visible even when source texture paths are malformed.
             bgpu.batchOpacity = (texFailed && !groundDetailModel) ? 0.0f : 1.0f;
 
-            // Apply at-rest transparency and color alpha from the M2 animation tracks.
-            // These provide per-batch opacity for ghosts, ethereal effects, fading doodads, etc.
-            // Skip zero values: some animated tracks start at 0 and animate up, and baking
-            // that first keyframe would make the entire batch permanently invisible.
-            if (bgpu.batchOpacity > 0.0f) {
-                float animAlpha = 1.0f;
-                if (batch.colorIndex < model.colorAlphas.size()) {
-                    float ca = model.colorAlphas[batch.colorIndex];
-                    if (ca > 0.001f) animAlpha *= ca;
-                }
-                if (batch.transparencyIndex < model.textureWeights.size()) {
-                    float tw = model.textureWeights[batch.transparencyIndex];
-                    if (tw > 0.001f) animAlpha *= tw;
-                }
-                bgpu.batchOpacity *= animAlpha;
-            }
-
             // Compute batch center and radius for glow sprite positioning
             if ((bgpu.blendMode >= 3 || bgpu.colorKeyBlack) && batch.indexCount > 0) {
                 glm::vec3 sum(0.0f);
@@ -1746,7 +1502,10 @@ bool M2Renderer::loadModel(const pipeline::M2Model& model, uint32_t modelId) {
             }
 
             // Optional diagnostics for glow/light batches (disabled by default).
-            if (kGlowDiag && gpuModel.isLanternLike) {
+            if (kGlowDiag &&
+                (lowerName.find("light") != std::string::npos ||
+                 lowerName.find("lamp") != std::string::npos ||
+                 lowerName.find("lantern") != std::string::npos)) {
                 LOG_DEBUG("M2 GLOW DIAG '", model.name, "' batch ", gpuModel.batches.size(),
                           ": blend=", bgpu.blendMode, " matFlags=0x",
                           std::hex, bgpu.materialFlags, std::dec,
@@ -1766,13 +1525,18 @@ bool M2Renderer::loadModel(const pipeline::M2Model& model, uint32_t modelId) {
         bgpu.indexStart = 0;
         bgpu.indexCount = gpuModel.indexCount;
         bgpu.texture = allTextures.empty() ? whiteTexture_.get() : allTextures[0];
+        bool texHasAlpha = false;
         if (bgpu.texture != nullptr && bgpu.texture != whiteTexture_.get()) {
-            auto pit = texturePropsByPtr_.find(bgpu.texture);
-            if (pit != texturePropsByPtr_.end()) {
-                bgpu.hasAlpha = pit->second.hasAlpha;
-                bgpu.colorKeyBlack = pit->second.colorKeyBlack;
-            }
+            auto ait = textureHasAlphaByPtr_.find(bgpu.texture);
+            texHasAlpha = (ait != textureHasAlphaByPtr_.end()) ? ait->second : false;
         }
+        bgpu.hasAlpha = texHasAlpha;
+        bool colorKeyBlack = false;
+        if (bgpu.texture != nullptr && bgpu.texture != whiteTexture_.get()) {
+            auto cit = textureColorKeyBlackByPtr_.find(bgpu.texture);
+            colorKeyBlack = (cit != textureColorKeyBlackByPtr_.end()) ? cit->second : false;
+        }
+        bgpu.colorKeyBlack = colorKeyBlack;
         gpuModel.batches.push_back(bgpu);
     }
 
@@ -1860,7 +1624,6 @@ bool M2Renderer::loadModel(const pipeline::M2Model& model, uint32_t modelId) {
     }
 
     models[modelId] = std::move(gpuModel);
-    spatialIndexDirty_ = true;  // Map may have rehashed — refresh cachedModel pointers
 
     LOG_DEBUG("Loaded M2 model: ", model.name, " (", models[modelId].vertexCount, " vertices, ",
               models[modelId].indexCount / 3, " triangles, ", models[modelId].batches.size(), " batches)");
@@ -1877,7 +1640,6 @@ uint32_t M2Renderer::createInstance(uint32_t modelId, const glm::vec3& position,
         return 0;
     }
     const auto& mdlRef = modelIt->second;
-    modelUnusedSince_.erase(modelId);
 
     // Deduplicate: skip if same model already at nearly the same position.
     // Uses hash map for O(1) lookup instead of O(N) scan.
@@ -1920,14 +1682,12 @@ uint32_t M2Renderer::createInstance(uint32_t modelId, const glm::vec3& position,
 
     // Initialize animation: play first sequence (usually Stand/Idle)
     const auto& mdl = mdlRef;
-    if (mdl.hasAnimation && !mdl.disableAnimation) {
-        if (!mdl.sequences.empty()) {
-            instance.currentSequenceIndex = 0;
-            instance.idleSequenceIndex = 0;
-            instance.animDuration = static_cast<float>(mdl.sequences[0].duration);
-            instance.animTime = static_cast<float>(randRange(std::max(1u, mdl.sequences[0].duration)));
-            instance.variationTimer = randFloat(3000.0f, 11000.0f);
-        }
+    if (mdl.hasAnimation && !mdl.disableAnimation && !mdl.sequences.empty()) {
+        instance.currentSequenceIndex = 0;
+        instance.idleSequenceIndex = 0;
+        instance.animDuration = static_cast<float>(mdl.sequences[0].duration);
+        instance.animTime = static_cast<float>(rand() % std::max(1u, mdl.sequences[0].duration));
+        instance.variationTimer = 3000.0f + static_cast<float>(rand() % 8000);
 
         // Seed bone matrices from an existing instance of the same model so the
         // new instance renders immediately instead of being invisible until the
@@ -1991,7 +1751,6 @@ uint32_t M2Renderer::createInstanceWithMatrix(uint32_t modelId, const glm::mat4&
         LOG_WARNING("Cannot create instance: model ", modelId, " not loaded");
         return 0;
     }
-    modelUnusedSince_.erase(modelId);
 
     // Deduplicate: O(1) hash lookup
     {
@@ -2029,14 +1788,12 @@ uint32_t M2Renderer::createInstanceWithMatrix(uint32_t modelId, const glm::mat4&
     instance.cachedModel = &mdl2;
 
     // Initialize animation
-    if (mdl2.hasAnimation && !mdl2.disableAnimation) {
-        if (!mdl2.sequences.empty()) {
-            instance.currentSequenceIndex = 0;
-            instance.idleSequenceIndex = 0;
-            instance.animDuration = static_cast<float>(mdl2.sequences[0].duration);
-            instance.animTime = static_cast<float>(randRange(std::max(1u, mdl2.sequences[0].duration)));
-            instance.variationTimer = randFloat(3000.0f, 11000.0f);
-        }
+    if (mdl2.hasAnimation && !mdl2.disableAnimation && !mdl2.sequences.empty()) {
+        instance.currentSequenceIndex = 0;
+        instance.idleSequenceIndex = 0;
+        instance.animDuration = static_cast<float>(mdl2.sequences[0].duration);
+        instance.animTime = static_cast<float>(rand() % std::max(1u, mdl2.sequences[0].duration));
+        instance.variationTimer = 3000.0f + static_cast<float>(rand() % 8000);
 
         // Seed bone matrices from an existing sibling so the instance renders immediately
         for (const auto& existing : instances) {
@@ -2050,7 +1807,7 @@ uint32_t M2Renderer::createInstanceWithMatrix(uint32_t modelId, const glm::mat4&
             computeBoneMatrices(mdl2, instance);
         }
     } else {
-        instance.animTime = randFloat(0.0f, 10000.0f);
+        instance.animTime = static_cast<float>(rand()) / RAND_MAX * 10000.0f;
     }
 
     // Register in dedup map
@@ -2112,15 +1869,7 @@ static void resolveTrackTime(const pipeline::M2AnimationTrack& track,
         // Global sequence: always use sub-array 0, wrap time at global duration
         outSeqIdx = 0;
         float dur = static_cast<float>(globalSeqDurations[track.globalSequence]);
-        if (dur > 0.0f) {
-            // Use iterative subtraction instead of fmod() to preserve precision
-            outTime = time;
-            while (outTime >= dur) {
-                outTime -= dur;
-            }
-        } else {
-            outTime = 0.0f;
-        }
+        outTime = (dur > 0.0f) ? std::fmod(time, dur) : 0.0f;
     } else {
         outSeqIdx = seqIdx;
         outTime = time;
@@ -2182,7 +1931,6 @@ static glm::quat interpQuat(const pipeline::M2AnimationTrack& track,
 }
 
 static void computeBoneMatrices(const M2ModelGPU& model, M2Instance& instance) {
-    ZoneScopedN("M2::computeBoneMatrices");
     size_t numBones = std::min(model.bones.size(), size_t(128));
     if (numBones == 0) return;
     instance.boneMatrices.resize(numBones);
@@ -2215,7 +1963,6 @@ static void computeBoneMatrices(const M2ModelGPU& model, M2Instance& instance) {
 }
 
 void M2Renderer::update(float deltaTime, const glm::vec3& cameraPos, const glm::mat4& viewProjection) {
-    ZoneScopedN("M2Renderer::update");
     if (spatialIndexDirty_) {
         rebuildSpatialIndex();
     }
@@ -2239,7 +1986,7 @@ void M2Renderer::update(float deltaTime, const glm::vec3& cameraPos, const glm::
     std::uniform_real_distribution<float> distDrift(-0.2f, 0.2f);
 
     smokeEmitAccum += deltaTime;
-    constexpr float emitInterval = kSmokeEmitInterval;  // 48 particles per second per emitter
+    float emitInterval = 1.0f / 8.0f;  // 8 particles per second per emitter
 
     if (smokeEmitAccum >= emitInterval &&
         static_cast<int>(smokeParticles.size()) < MAX_SMOKE_PARTICLES) {
@@ -2292,13 +2039,12 @@ void M2Renderer::update(float deltaTime, const glm::vec3& cameraPos, const glm::
 
     // --- Spin instance portals ---
     static constexpr float PORTAL_SPIN_SPEED = 1.2f; // radians/sec
-    static constexpr float kTwoPi = 6.2831853f;
     for (size_t idx : portalInstanceIndices_) {
         if (idx >= instances.size()) continue;
         auto& inst = instances[idx];
         inst.portalSpinAngle += PORTAL_SPIN_SPEED * deltaTime;
-        if (inst.portalSpinAngle > kTwoPi)
-            inst.portalSpinAngle -= kTwoPi;
+        if (inst.portalSpinAngle > 6.2831853f)
+            inst.portalSpinAngle -= 6.2831853f;
         inst.rotation.z = inst.portalSpinAngle;
         inst.updateModelMatrix();
     }
@@ -2309,17 +2055,12 @@ void M2Renderer::update(float deltaTime, const glm::vec3& cameraPos, const glm::
     for (auto& instance : instances) {
         instance.animTime += dtMs;
     }
-    // Wrap animTime for particle-only instances so emission rate tracks keep looping.
-    // 3333ms chosen as a safe wrap period: long enough to cover the longest known M2
-    // particle emission cycle (~3s for torch/campfire effects) while preventing float
-    // precision loss that accumulates over hours of runtime.
-    static constexpr float kParticleWrapMs = 3333.0f;
+    // Wrap animTime for particle-only instances so emission rate tracks keep looping
     for (size_t idx : particleOnlyInstanceIndices_) {
         if (idx >= instances.size()) continue;
         auto& instance = instances[idx];
-        // Use iterative subtraction instead of fmod() to preserve precision
-        while (instance.animTime > kParticleWrapMs) {
-            instance.animTime -= kParticleWrapMs;
+        if (instance.animTime > 3333.0f) {
+            instance.animTime = std::fmod(instance.animTime, 3333.0f);
         }
     }
 
@@ -2360,13 +2101,9 @@ void M2Renderer::update(float deltaTime, const glm::vec3& cameraPos, const glm::
                     instance.animDuration = static_cast<float>(model.sequences[instance.idleSequenceIndex].duration);
                 }
                 instance.animTime = 0.0f;
-                instance.variationTimer = randFloat(4000.0f, 10000.0f);
+                instance.variationTimer = 4000.0f + static_cast<float>(rand() % 6000);
             } else {
-                // Use iterative subtraction instead of fmod() to preserve precision
-                float duration = std::max(1.0f, instance.animDuration);
-                while (instance.animTime >= duration) {
-                    instance.animTime -= duration;
-                }
+                instance.animTime = std::fmod(instance.animTime, std::max(1.0f, instance.animDuration));
             }
         }
 
@@ -2374,7 +2111,7 @@ void M2Renderer::update(float deltaTime, const glm::vec3& cameraPos, const glm::
         if (!instance.playingVariation && model.idleVariationIndices.size() > 1) {
             instance.variationTimer -= dtMs;
             if (instance.variationTimer <= 0.0f) {
-                int pick = static_cast<int>(randRange(static_cast<uint32_t>(model.idleVariationIndices.size())));
+                int pick = rand() % static_cast<int>(model.idleVariationIndices.size());
                 int newSeq = model.idleVariationIndices[pick];
                 if (newSeq != instance.currentSequenceIndex && newSeq < static_cast<int>(model.sequences.size())) {
                     instance.playingVariation = true;
@@ -2382,7 +2119,7 @@ void M2Renderer::update(float deltaTime, const glm::vec3& cameraPos, const glm::
                     instance.animDuration = static_cast<float>(model.sequences[newSeq].duration);
                     instance.animTime = 0.0f;
                 } else {
-                    instance.variationTimer = randFloat(2000.0f, 6000.0f);
+                    instance.variationTimer = 2000.0f + static_cast<float>(rand() % 4000);
                 }
             }
         }
@@ -2397,15 +2134,10 @@ void M2Renderer::update(float deltaTime, const glm::vec3& cameraPos, const glm::
         float paddedRadius = std::max(cullRadius * 1.5f, cullRadius + 3.0f);
         if (cullRadius > 0.0f && !updateFrustum.intersectsSphere(instance.position, paddedRadius)) continue;
 
-        // LOD 3 skip: models beyond 150 units use the lowest LOD mesh which has
-        // no visible skeletal animation.  Keep their last-computed bone matrices
-        // (always valid — seeded on spawn) and avoid the expensive per-bone work.
-        constexpr float kLOD3DistSq = 150.0f * 150.0f;
-        if (distSq > kLOD3DistSq) continue;
-
         // Distance-based frame skipping: update distant bones less frequently
         uint32_t boneInterval = 1;
-        if (distSq > 100.0f * 100.0f) boneInterval = 4;
+        if (distSq > 200.0f * 200.0f) boneInterval = 8;
+        else if (distSq > 100.0f * 100.0f) boneInterval = 4;
         else if (distSq > 50.0f * 50.0f) boneInterval = 2;
         instance.frameSkipCounter++;
         if ((instance.frameSkipCounter % boneInterval) != 0) continue;
@@ -2413,7 +2145,7 @@ void M2Renderer::update(float deltaTime, const glm::vec3& cameraPos, const glm::
         boneWorkIndices_.push_back(idx);
     }
 
-    // Compute bone matrices (expensive, parallel if enough work)
+    // Phase 2: Compute bone matrices (expensive, parallel if enough work)
     const size_t animCount = boneWorkIndices_.size();
     if (animCount > 0) {
         static const size_t minParallelAnimInstances = std::max<size_t>(
@@ -2473,7 +2205,7 @@ void M2Renderer::update(float deltaTime, const glm::vec3& cameraPos, const glm::
         }
     }
 
-    // Particle update (sequential — uses RNG, not thread-safe)
+    // Phase 3: Particle update (sequential — uses RNG, not thread-safe)
     // Only iterate instances that have particle emitters (pre-built list).
     for (size_t idx : particleInstanceIndices_) {
         if (idx >= instances.size()) continue;
@@ -2485,9 +2217,6 @@ void M2Renderer::update(float deltaTime, const glm::vec3& cameraPos, const glm::
         if (!instance.cachedModel) continue;
         emitParticles(instance, *instance.cachedModel, deltaTime);
         updateParticles(instance, deltaTime);
-        if (!instance.cachedModel->ribbonEmitters.empty()) {
-            updateRibbons(instance, *instance.cachedModel, deltaTime);
-        }
     }
 
 }
@@ -2496,117 +2225,47 @@ void M2Renderer::prepareRender(uint32_t frameIndex, const Camera& camera) {
     if (!initialized_ || instances.empty()) return;
     (void)camera;  // reserved for future frustum-based culling
 
-    // --- Mega bone SSBO: assign slots and upload all animated instance bones ---
-    // Slot 0 = identity (non-animated), slots 1..N = animated instances.
-    uint32_t nextSlot = 1;
+    // Pre-allocate bone SSBOs + descriptor sets on main thread (pool ops not thread-safe).
+    // Only iterate animated instances — static doodads don't need bone buffers.
     for (size_t idx : animatedInstanceIndices_) {
         if (idx >= instances.size()) continue;
         auto& instance = instances[idx];
 
-        if (instance.boneMatrices.empty()) {
-            instance.megaBoneOffset = 0;  // Use identity slot
-            continue;
-        }
+        if (instance.boneMatrices.empty()) continue;
 
-        if (nextSlot >= MEGA_BONE_MAX_INSTANCES) {
-            instance.megaBoneOffset = 0;  // Overflow — use identity
-            continue;
-        }
+        if (!instance.boneBuffer[frameIndex]) {
+            VkBufferCreateInfo bci{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
+            bci.size = 128 * sizeof(glm::mat4);
+            bci.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+            VmaAllocationCreateInfo aci{};
+            aci.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
+            aci.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
+            VmaAllocationInfo allocInfo{};
+            vmaCreateBuffer(vkCtx_->getAllocator(), &bci, &aci,
+                            &instance.boneBuffer[frameIndex], &instance.boneAlloc[frameIndex], &allocInfo);
+            instance.boneMapped[frameIndex] = allocInfo.pMappedData;
 
-        instance.megaBoneOffset = nextSlot * MAX_BONES_PER_INSTANCE;
+            // Force dirty so current boneMatrices get copied into this
+            // newly-allocated buffer during render (prevents garbage/zero
+            // bones when the other frame index already cleared bonesDirty).
+            instance.bonesDirty[frameIndex] = true;
 
-        // Upload bone matrices to mega buffer
-        if (megaBoneMapped_[frameIndex]) {
-            int numBones = std::min(static_cast<int>(instance.boneMatrices.size()),
-                                    static_cast<int>(MAX_BONES_PER_INSTANCE));
-            auto* dst = static_cast<glm::mat4*>(megaBoneMapped_[frameIndex]) + instance.megaBoneOffset;
-            memcpy(dst, instance.boneMatrices.data(), numBones * sizeof(glm::mat4));
-        }
-
-        nextSlot++;
-    }
-}
-
-// Dispatch GPU frustum culling compute shader.
-// Called on the primary command buffer BEFORE the render pass begins so that
-// compute dispatch and memory barrier complete before secondary command buffers
-// read the visibility output in render().
-void M2Renderer::dispatchCullCompute(VkCommandBuffer cmd, uint32_t frameIndex, const Camera& camera) {
-    if (!cullPipeline_ || instances.empty()) return;
-
-    const uint32_t numInstances = std::min(static_cast<uint32_t>(instances.size()), MAX_CULL_INSTANCES);
-
-    // --- Compute per-instance adaptive distances (same formula as old CPU cull) ---
-    const float targetRenderDist = (instances.size() > 2000) ? 300.0f
-                                 : (instances.size() > 1000) ? 500.0f
-                                 : 1000.0f;
-    const float shrinkRate = 0.005f;
-    const float growRate   = 0.05f;
-    float blendRate = (targetRenderDist < smoothedRenderDist_) ? shrinkRate : growRate;
-    smoothedRenderDist_ = glm::mix(smoothedRenderDist_, targetRenderDist, blendRate);
-    const float maxRenderDistance = smoothedRenderDist_;
-    const float maxRenderDistanceSq = maxRenderDistance * maxRenderDistance;
-    const float maxPossibleDistSq = maxRenderDistanceSq * 4.0f; // 2x safety margin
-
-    // --- Upload frustum planes + camera (UBO, binding 0) ---
-    const glm::mat4 vp = camera.getProjectionMatrix() * camera.getViewMatrix();
-    Frustum frustum;
-    frustum.extractFromMatrix(vp);
-    const glm::vec3 camPos = camera.getPosition();
-
-    if (cullUniformMapped_[frameIndex]) {
-        auto* ubo = static_cast<CullUniformsGPU*>(cullUniformMapped_[frameIndex]);
-        for (int i = 0; i < 6; i++) {
-            const auto& p = frustum.getPlane(static_cast<Frustum::Side>(i));
-            ubo->frustumPlanes[i] = glm::vec4(p.normal, p.distance);
-        }
-        ubo->cameraPos = glm::vec4(camPos, maxPossibleDistSq);
-        ubo->instanceCount = numInstances;
-    }
-
-    // --- Upload per-instance cull data (SSBO, binding 1) ---
-    if (cullInputMapped_[frameIndex]) {
-        auto* input = static_cast<CullInstanceGPU*>(cullInputMapped_[frameIndex]);
-        for (uint32_t i = 0; i < numInstances; i++) {
-            const auto& inst = instances[i];
-            float worldRadius = inst.cachedBoundRadius * inst.scale;
-            float cullRadius = worldRadius;
-            if (inst.cachedDisableAnimation) {
-                cullRadius = std::max(cullRadius, 3.0f);
+            instance.boneSet[frameIndex] = allocateBoneSet();
+            if (instance.boneSet[frameIndex]) {
+                VkDescriptorBufferInfo bufInfo{};
+                bufInfo.buffer = instance.boneBuffer[frameIndex];
+                bufInfo.offset = 0;
+                bufInfo.range = bci.size;
+                VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
+                write.dstSet = instance.boneSet[frameIndex];
+                write.dstBinding = 0;
+                write.descriptorCount = 1;
+                write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+                write.pBufferInfo = &bufInfo;
+                vkUpdateDescriptorSets(vkCtx_->getDevice(), 1, &write, 0, nullptr);
             }
-            float effectiveMaxDistSq = maxRenderDistanceSq * std::max(1.0f, cullRadius / 12.0f);
-            if (inst.cachedDisableAnimation)  effectiveMaxDistSq *= 2.6f;
-            if (inst.cachedIsGroundDetail)     effectiveMaxDistSq *= 0.9f;
-
-            float paddedRadius = std::max(cullRadius * 1.5f, cullRadius + 3.0f);
-
-            uint32_t flags = 0;
-            if (inst.cachedIsValid)          flags |= 1u;
-            if (inst.cachedIsSmoke)           flags |= 2u;
-            if (inst.cachedIsInvisibleTrap)   flags |= 4u;
-
-            input[i].sphere = glm::vec4(inst.position, paddedRadius);
-            input[i].effectiveMaxDistSq = effectiveMaxDistSq;
-            input[i].flags = flags;
         }
     }
-
-    // --- Dispatch compute shader ---
-    vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, cullPipeline_);
-    vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_COMPUTE,
-                            cullPipelineLayout_, 0, 1, &cullSet_[frameIndex], 0, nullptr);
-
-    const uint32_t groupCount = (numInstances + 63) / 64;
-    vkCmdDispatch(cmd, groupCount, 1, 1);
-
-    // --- Memory barrier: compute writes → host reads ---
-    VkMemoryBarrier barrier{VK_STRUCTURE_TYPE_MEMORY_BARRIER};
-    barrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
-    barrier.dstAccessMask = VK_ACCESS_HOST_READ_BIT;
-    vkCmdPipelineBarrier(cmd,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-        VK_PIPELINE_STAGE_HOST_BIT,
-        0, 1, &barrier, 0, nullptr, 0, nullptr);
 }
 
 void M2Renderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const Camera& camera) {
@@ -2621,142 +2280,96 @@ void M2Renderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const
         LOG_INFO("M2 render: ", instances.size(), " instances, ", models.size(), " models");
     }
 
-    // Periodic diagnostic: report render pipeline stats every 10 seconds
-    static int diagCounter = 0;
-    if (++diagCounter == 600) { // ~10s at 60fps
-        diagCounter = 0;
-        uint32_t totalValid = 0, totalAnimated = 0, totalBonesReady = 0, totalMegaBoneOk = 0;
-        for (const auto& inst : instances) {
-            if (inst.cachedIsValid) totalValid++;
-            if (inst.cachedHasAnimation && !inst.cachedDisableAnimation) {
-                totalAnimated++;
-                if (!inst.boneMatrices.empty()) totalBonesReady++;
-                if (inst.megaBoneOffset != 0) totalMegaBoneOk++;
-            }
-        }
-        LOG_INFO("M2 diag: total=", instances.size(),
-                 " valid=", totalValid,
-                 " animated=", totalAnimated,
-                 " bonesReady=", totalBonesReady,
-                 " megaBoneOk=", totalMegaBoneOk,
-                 " visible=", sortedVisible_.size(),
-                 " draws=", lastDrawCallCount);
-    }
+    // Build frustum for culling
+    const glm::mat4 view = camera.getViewMatrix();
+    const glm::mat4 projection = camera.getProjectionMatrix();
+    Frustum frustum;
+    frustum.extractFromMatrix(projection * view);
 
     // Reuse persistent buffers (clear instead of reallocating)
     glowSprites_.clear();
 
     lastDrawCallCount = 0;
 
-    // GPU cull results — dispatchCullCompute() already updated smoothedRenderDist_.
-    // Use the cached value (set by dispatchCullCompute or fallback below).
-    const uint32_t frameIndex = vkCtx_->getCurrentFrame();
-    const uint32_t numInstances = std::min(static_cast<uint32_t>(instances.size()), MAX_CULL_INSTANCES);
-    const uint32_t* visibility = static_cast<const uint32_t*>(cullOutputMapped_[frameIndex]);
-    const bool gpuCullAvailable = (cullPipeline_ != VK_NULL_HANDLE && visibility != nullptr);
-
-    // If GPU culling was not dispatched, fallback: compute distances on CPU
-    float maxRenderDistanceSq;
-    if (!gpuCullAvailable) {
-        const float targetRenderDist = (instances.size() > 2000) ? 300.0f
-                                     : (instances.size() > 1000) ? 500.0f
-                                     : 1000.0f;
-        const float shrinkRate = 0.005f;
-        const float growRate = 0.05f;
-        float blendRate = (targetRenderDist < smoothedRenderDist_) ? shrinkRate : growRate;
-        smoothedRenderDist_ = glm::mix(smoothedRenderDist_, targetRenderDist, blendRate);
-        maxRenderDistanceSq = smoothedRenderDist_ * smoothedRenderDist_;
-    } else {
-        maxRenderDistanceSq = smoothedRenderDist_ * smoothedRenderDist_;
-    }
-
+    // Adaptive render distance: smoothed to prevent pop-in/pop-out flickering
+    const float targetRenderDist = (instances.size() > 2000) ? 300.0f
+                                 : (instances.size() > 1000) ? 500.0f
+                                 : 1000.0f;
+    // Smooth transitions: shrink slowly (avoid popping out nearby objects)
+    const float shrinkRate = 0.005f;  // very slow decrease
+    const float growRate = 0.05f;     // faster increase
+    float blendRate = (targetRenderDist < smoothedRenderDist_) ? shrinkRate : growRate;
+    smoothedRenderDist_ = glm::mix(smoothedRenderDist_, targetRenderDist, blendRate);
+    const float maxRenderDistance = smoothedRenderDist_;
+    const float maxRenderDistanceSq = maxRenderDistance * maxRenderDistance;
     const float fadeStartFraction = 0.75f;
     const glm::vec3 camPos = camera.getPosition();
 
-    // Build sorted visible instance list
+    // Build sorted visible instance list: cull then sort by modelId to batch VAO binds
+    // Reuse persistent vector to avoid allocation
     sortedVisible_.clear();
+    // Reserve based on expected visible count (roughly 30% of total instances in dense areas)
     const size_t expectedVisible = std::min(instances.size() / 3, size_t(600));
     if (sortedVisible_.capacity() < expectedVisible) {
         sortedVisible_.reserve(expectedVisible);
     }
 
-    // GPU frustum culling — build frustum for CPU fallback path and overflow instances
-    Frustum frustum;
-    {
-        const glm::mat4 vp = camera.getProjectionMatrix() * camera.getViewMatrix();
-        frustum.extractFromMatrix(vp);
-    }
-    const float maxPossibleDistSq = maxRenderDistanceSq * 4.0f;
+    // Early distance rejection: max possible render distance (tight but safe upper bound)
+    const float maxPossibleDistSq = maxRenderDistance * maxRenderDistance * 4.0f;  // 2x safety margin (reduced from 4x)
 
-    const uint32_t totalInstances = static_cast<uint32_t>(instances.size());
-    for (uint32_t i = 0; i < totalInstances; ++i) {
+    for (uint32_t i = 0; i < static_cast<uint32_t>(instances.size()); ++i) {
         const auto& instance = instances[i];
 
-        if (gpuCullAvailable && i < numInstances) {
-            // GPU already tested flags + distance + frustum
-            if (!visibility[i]) continue;
-        } else {
-            // CPU fallback: for non-GPU path or instances beyond cull buffer
-            if (!instance.cachedIsValid || instance.cachedIsSmoke || instance.cachedIsInvisibleTrap) continue;
+        // Use cached model flags — no hash lookup needed
+        if (!instance.cachedIsValid || instance.cachedIsSmoke || instance.cachedIsInvisibleTrap) continue;
 
-            glm::vec3 toCam = instance.position - camPos;
-            float distSqTest = glm::dot(toCam, toCam);
-            if (distSqTest > maxPossibleDistSq) continue;
-
-            float worldRadius = instance.cachedBoundRadius * instance.scale;
-            float cullRadius = worldRadius;
-            if (instance.cachedDisableAnimation) cullRadius = std::max(cullRadius, 3.0f);
-            float effDistSq = maxRenderDistanceSq * std::max(1.0f, cullRadius / 12.0f);
-            if (instance.cachedDisableAnimation) effDistSq *= 2.6f;
-            if (instance.cachedIsGroundDetail) effDistSq *= 0.9f;
-            if (distSqTest > effDistSq) continue;
-
-            float paddedRadius = std::max(cullRadius * 1.5f, cullRadius + 3.0f);
-            if (cullRadius > 0.0f && !frustum.intersectsSphere(instance.position, paddedRadius)) continue;
-        }
-
-        // Compute distSq + effectiveMaxDistSq for sorting and fade alpha (cheap for visible-only)
         glm::vec3 toCam = instance.position - camPos;
         float distSq = glm::dot(toCam, toCam);
+        if (distSq > maxPossibleDistSq) continue;
+
         float worldRadius = instance.cachedBoundRadius * instance.scale;
         float cullRadius = worldRadius;
-        if (instance.cachedDisableAnimation) cullRadius = std::max(cullRadius, 3.0f);
+        if (instance.cachedDisableAnimation) {
+            cullRadius = std::max(cullRadius, 3.0f);
+        }
         float effectiveMaxDistSq = maxRenderDistanceSq * std::max(1.0f, cullRadius / 12.0f);
-        if (instance.cachedDisableAnimation)  effectiveMaxDistSq *= 2.6f;
-        if (instance.cachedIsGroundDetail)     effectiveMaxDistSq *= 0.9f;
+        if (instance.cachedDisableAnimation) {
+            effectiveMaxDistSq *= 2.6f;
+        }
+        if (instance.cachedIsGroundDetail) {
+            effectiveMaxDistSq *= 0.75f;
+        }
+
+        if (distSq > effectiveMaxDistSq) continue;
+
+        // Frustum cull with padding
+        float paddedRadius = std::max(cullRadius * 1.5f, cullRadius + 3.0f);
+        if (cullRadius > 0.0f && !frustum.intersectsSphere(instance.position, paddedRadius)) continue;
 
         sortedVisible_.push_back({i, instance.modelId, distSq, effectiveMaxDistSq});
     }
 
-    // Two-pass rendering: opaque/alpha-test first (depth write ON), then transparent/additive
-    // (depth write OFF, sorted back-to-front) so transparent geometry composites correctly
-    // against all opaque geometry rather than only against what was rendered before it.
-
-    // Pass 1: sort by modelId for minimum buffer rebinds (opaque batches)
+    // Sort by modelId to minimize vertex/index buffer rebinds
     std::sort(sortedVisible_.begin(), sortedVisible_.end(),
               [](const VisibleEntry& a, const VisibleEntry& b) { return a.modelId < b.modelId; });
 
     uint32_t currentModelId = UINT32_MAX;
     const M2ModelGPU* currentModel = nullptr;
-    bool currentModelValid = false;
 
     // State tracking
     VkPipeline currentPipeline = VK_NULL_HANDLE;
-    VkDescriptorSet currentMaterialSet = VK_NULL_HANDLE;
+    uint32_t frameIndex = vkCtx_->getCurrentFrame();
 
-    // Push constants now carry per-batch data only; per-instance data is in instance SSBO.
+    // Push constants struct matching m2.vert.glsl push_constant block
     struct M2PushConstants {
-        int32_t texCoordSet;        // UV set index (0 or 1)
-        int32_t isFoliage;          // Foliage wind animation flag
-        int32_t instanceDataOffset; // Base index into instance SSBO for this draw group
+        glm::mat4 model;
+        glm::vec2 uvOffset;
+        int texCoordSet;
+        int useBones;
+        int isFoliage;
+        float fadeAlpha;
     };
 
-    // Validate per-frame descriptor set before any Vulkan commands
-    if (!perFrameSet) {
-        LOG_ERROR("M2Renderer::render: perFrameSet is VK_NULL_HANDLE — skipping M2 render");
-        return;
-    }
-
     // Bind per-frame descriptor set (set 0) — shared across all draws
     vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
                             pipelineLayout_, 0, 1, &perFrameSet, 0, nullptr);
@@ -2765,354 +2378,25 @@ void M2Renderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const
     vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, opaquePipeline_);
     currentPipeline = opaquePipeline_;
 
-    // Bind dummy bone set (set 2) so non-animated draws have a valid binding.
-    // Bind mega bone SSBO instead — all instances index into one buffer via boneBase.
-    if (megaBoneSet_[frameIndex]) {
-        vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                pipelineLayout_, 2, 1, &megaBoneSet_[frameIndex], 0, nullptr);
-    } else if (dummyBoneSet_) {
-        vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                pipelineLayout_, 2, 1, &dummyBoneSet_, 0, nullptr);
-    }
-
-    // Bind instance data SSBO (set 3) — per-instance transforms, fade, bones
-    if (instanceSet_[frameIndex]) {
-        vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                pipelineLayout_, 3, 1, &instanceSet_[frameIndex], 0, nullptr);
-    }
-
-    // Reset instance SSBO write cursor for this frame
-    instanceDataCount_ = 0;
-    auto* instSSBO = static_cast<M2InstanceGPU*>(instanceMapped_[frameIndex]);
-
-    // =====================================================================
-    // Opaque pass — instanced draws grouped by (modelId, LOD)
-    // =====================================================================
-    // sortedVisible_ is already sorted by modelId so consecutive entries share
-    // the same vertex/index buffer.  Within each model group we sub-group by
-    // targetLOD to guarantee all instances in one vkCmdDrawIndexed use the
-    // same batch set.  Per-instance data (model matrix, fade, bones) is
-    // written to the instance SSBO; the shader reads it via gl_InstanceIndex.
-    {
-        struct PendingInstance {
-            uint32_t instanceIdx;
-            float fadeAlpha;
-            bool useBones;
-            uint16_t targetLOD;
-        };
-        std::vector<PendingInstance> pending;
-        pending.reserve(128);
-
-        size_t visStart = 0;
-        while (visStart < sortedVisible_.size()) {
-            // Find group of consecutive entries with same modelId
-            uint32_t groupModelId = sortedVisible_[visStart].modelId;
-            size_t groupEnd = visStart;
-            while (groupEnd < sortedVisible_.size() && sortedVisible_[groupEnd].modelId == groupModelId)
-                groupEnd++;
-
-            auto mdlIt = models.find(groupModelId);
-            if (mdlIt == models.end() || !mdlIt->second.vertexBuffer || !mdlIt->second.indexBuffer) {
-                visStart = groupEnd;
-                continue;
-            }
-            const M2ModelGPU& model = mdlIt->second;
-
-            bool modelNeedsAnimation = model.hasAnimation && !model.disableAnimation;
-            const bool foliageLikeModel = model.isFoliageLike;
-            const bool particleDominantEffect = model.isSpellEffect &&
-                !model.particleEmitters.empty() && model.batches.size() <= 2;
-
-            // Collect per-instance data for this model group
-            pending.clear();
-            for (size_t vi = visStart; vi < groupEnd; vi++) {
-                const auto& entry = sortedVisible_[vi];
-                if (entry.index >= instances.size()) continue;
-                auto& instance = instances[entry.index];
-
-                // Distance-based fade alpha
-                float fadeFrac = model.disableAnimation ? 0.55f : fadeStartFraction;
-                float fadeStartDistSq = entry.effectiveMaxDistSq * fadeFrac * fadeFrac;
-                float fadeAlpha = 1.0f;
-                if (entry.distSq > fadeStartDistSq) {
-                    fadeAlpha = std::clamp((entry.effectiveMaxDistSq - entry.distSq) /
-                                          (entry.effectiveMaxDistSq - fadeStartDistSq), 0.0f, 1.0f);
-                }
-                float instanceFadeAlpha = fadeAlpha;
-                if (model.isGroundDetail) instanceFadeAlpha *= 0.82f;
-                if (model.isInstancePortal) {
-                    instanceFadeAlpha *= 0.12f;
-                    if (entry.distSq < 400.0f * 400.0f) {
-                        glm::vec3 center = glm::vec3(instance.modelMatrix * glm::vec4(0.0f, 0.0f, 0.0f, 1.0f));
-                        GlowSprite gs;
-                        gs.worldPos = center;
-                        gs.color = glm::vec4(0.35f, 0.5f, 1.0f, 1.1f);
-                        gs.size = instance.scale * 5.0f;
-                        glowSprites_.push_back(gs);
-                        GlowSprite halo = gs;
-                        halo.color.a *= 0.3f;
-                        halo.size *= 2.2f;
-                        glowSprites_.push_back(halo);
-                    }
-                }
-
-                // Bone readiness check
-                if (modelNeedsAnimation && instance.boneMatrices.empty()) continue;
-                bool needsBones = modelNeedsAnimation && !instance.boneMatrices.empty();
-                if (needsBones && instance.megaBoneOffset == 0) continue;
-
-                // LOD selection
-                uint16_t desiredLOD = 0;
-                if (entry.distSq > 150.0f * 150.0f) desiredLOD = 3;
-                else if (entry.distSq > 80.0f * 80.0f) desiredLOD = 2;
-                else if (entry.distSq > 40.0f * 40.0f) desiredLOD = 1;
-                uint16_t targetLOD = desiredLOD;
-                if (desiredLOD > 0 && !(model.availableLODs & (1u << desiredLOD))) targetLOD = 0;
-
-                pending.push_back({entry.index, instanceFadeAlpha, needsBones, targetLOD});
-            }
-
-            if (pending.empty()) { visStart = groupEnd; continue; }
-
-            // Sort by targetLOD so each sub-group occupies a contiguous SSBO range
-            std::sort(pending.begin(), pending.end(),
-                      [](const PendingInstance& a, const PendingInstance& b) { return a.targetLOD < b.targetLOD; });
-
-            // Bind vertex/index buffers once per model group
-            VkDeviceSize vbOffset = 0;
-            vkCmdBindVertexBuffers(cmd, 0, 1, &model.vertexBuffer, &vbOffset);
-            vkCmdBindIndexBuffer(cmd, model.indexBuffer, 0, VK_INDEX_TYPE_UINT16);
-
-            // Write base instance data to SSBO (uvOffset=0 — overridden for tex-anim batches)
-            uint32_t baseSSBOOffset = instanceDataCount_;
-            for (const auto& p : pending) {
-                if (instanceDataCount_ >= MAX_INSTANCE_DATA) break;
-                auto& inst = instances[p.instanceIdx];
-                auto& e = instSSBO[instanceDataCount_];
-                e.model = inst.modelMatrix;
-                e.uvOffset = glm::vec2(0.0f);
-                e.fadeAlpha = p.fadeAlpha;
-                e.useBones = p.useBones ? 1 : 0;
-                e.boneBase = p.useBones ? static_cast<int32_t>(inst.megaBoneOffset) : 0;
-                std::memset(e._pad, 0, sizeof(e._pad));
-                instanceDataCount_++;
-            }
-
-            // Process LOD sub-groups within this model group
-            size_t lodIdx = 0;
-            while (lodIdx < pending.size()) {
-                uint16_t lod = pending[lodIdx].targetLOD;
-                size_t lodEnd = lodIdx + 1;
-                while (lodEnd < pending.size() && pending[lodEnd].targetLOD == lod) lodEnd++;
-                uint32_t groupSize = static_cast<uint32_t>(lodEnd - lodIdx);
-                uint32_t groupSSBOOffset = baseSSBOOffset + static_cast<uint32_t>(lodIdx);
-
-                for (size_t bi = 0; bi < model.batches.size(); bi++) {
-                    const auto& batch = model.batches[bi];
-                    if (batch.indexCount == 0) continue;
-                    if (!model.isGroundDetail && batch.submeshLevel != lod) continue;
-                    if (batch.batchOpacity < 0.01f) continue;
-
-                    // Opaque gate — skip transparent batches
-                    const bool rawTransparent = (batch.blendMode >= 2) || model.isSpellEffect;
-                    if (rawTransparent) continue;
-
-                    // Particle-dominant effects: emission geometry — skip opaque
-                    if (particleDominantEffect && batch.blendMode <= 1) continue;
-
-                    // Glow sprite check (per model+batch, sprites generated per instance)
-                    const bool koboldFlameCard = batch.colorKeyBlack && model.isKoboldFlame;
-                    const bool smallCardLikeBatch =
-                        (batch.glowSize <= 1.35f) ||
-                        (batch.lanternGlowHint && batch.glowSize <= 6.0f);
-                    const bool batchUnlit = (batch.materialFlags & 0x01) != 0;
-                    const bool shouldUseGlowSprite =
-                        !koboldFlameCard &&
-                        (model.isElvenLike || (model.isLanternLike && batch.lanternGlowHint)) &&
-                        !model.isSpellEffect &&
-                        smallCardLikeBatch &&
-                        (batch.lanternGlowHint ||
-                         (batch.blendMode >= 3) ||
-                         (batch.colorKeyBlack && batchUnlit && batch.blendMode >= 1));
-                    if (shouldUseGlowSprite) {
-                        // Generate glow sprites for each instance in the group
-                        for (size_t j = lodIdx; j < lodEnd; j++) {
-                            auto& inst = instances[pending[j].instanceIdx];
-                            float distSq = sortedVisible_[visStart].distSq; // approximate with group
-                            if (distSq < 180.0f * 180.0f) {
-                                glm::vec3 worldPos = glm::vec3(inst.modelMatrix * glm::vec4(batch.center, 1.0f));
-                                GlowSprite gs;
-                                gs.worldPos = worldPos;
-                                if (batch.glowTint == 1 || model.isElvenLike)
-                                    gs.color = glm::vec4(0.48f, 0.72f, 1.0f, 1.05f);
-                                else if (batch.glowTint == 2)
-                                    gs.color = glm::vec4(1.0f, 0.28f, 0.22f, 1.10f);
-                                else
-                                    gs.color = glm::vec4(1.0f, 0.82f, 0.46f, 1.15f);
-                                gs.size = batch.glowSize * inst.scale * 1.45f;
-                                glowSprites_.push_back(gs);
-                                GlowSprite halo = gs;
-                                halo.color.a *= 0.42f;
-                                halo.size *= 1.8f;
-                                glowSprites_.push_back(halo);
-                            }
-                        }
-                        const bool cardLikeSkipMesh =
-                            (batch.blendMode >= 3) || batch.colorKeyBlack || batchUnlit;
-                        const bool lanternGlowCardSkip =
-                            model.isLanternLike && batch.lanternGlowHint &&
-                            smallCardLikeBatch && cardLikeSkipMesh;
-                        if (lanternGlowCardSkip || (cardLikeSkipMesh && !model.isLanternLike))
-                            continue;
-                    }
-
-                    // Handle texture animation: if this batch has per-instance uvOffset,
-                    // write a separate SSBO range with the correct offsets.
-                    bool hasBatchTexAnim = (batch.textureAnimIndex != 0xFFFF && model.hasTextureAnimation)
-                                           || model.isLavaModel;
-                    uint32_t drawOffset = groupSSBOOffset;
-                    if (hasBatchTexAnim && instanceDataCount_ + groupSize <= MAX_INSTANCE_DATA) {
-                        drawOffset = instanceDataCount_;
-                        for (size_t j = lodIdx; j < lodEnd; j++) {
-                            auto& inst = instances[pending[j].instanceIdx];
-                            glm::vec2 uvOffset(0.0f);
-                            if (batch.textureAnimIndex != 0xFFFF && model.hasTextureAnimation) {
-                                uint16_t lookupIdx = batch.textureAnimIndex;
-                                if (lookupIdx < model.textureTransformLookup.size()) {
-                                    uint16_t transformIdx = model.textureTransformLookup[lookupIdx];
-                                    if (transformIdx < model.textureTransforms.size()) {
-                                        const auto& tt = model.textureTransforms[transformIdx];
-                                        glm::vec3 trans = interpVec3(tt.translation,
-                                            inst.currentSequenceIndex, inst.animTime,
-                                            glm::vec3(0.0f), model.globalSequenceDurations);
-                                        uvOffset = glm::vec2(trans.x, trans.y);
-                                    }
-                                }
-                            }
-                            if (model.isLavaModel && uvOffset == glm::vec2(0.0f)) {
-                                float t = std::chrono::duration<float>(
-                                    std::chrono::steady_clock::now() - kLavaAnimStart).count();
-                                uvOffset = glm::vec2(t * 0.03f, -t * 0.08f);
-                            }
-                            // Copy base entry and override uvOffset
-                            instSSBO[instanceDataCount_] = instSSBO[groupSSBOOffset + (j - lodIdx)];
-                            instSSBO[instanceDataCount_].uvOffset = uvOffset;
-                            instanceDataCount_++;
-                        }
-                    }
-
-                    // Pipeline selection (per-model/batch, not per-instance)
-                    const bool foliageCutout = foliageLikeModel && !model.isSpellEffect && batch.blendMode <= 3;
-                    const bool forceCutout =
-                        !model.isSpellEffect &&
-                        (model.isGroundDetail || foliageCutout ||
-                         batch.blendMode == 1 ||
-                         (batch.blendMode >= 2 && !batch.hasAlpha) ||
-                         batch.colorKeyBlack);
-
-                    uint8_t effectiveBlendMode = batch.blendMode;
-                    if (model.isSpellEffect) {
-                        if (effectiveBlendMode <= 1) effectiveBlendMode = 3;
-                        else if (effectiveBlendMode == 4 || effectiveBlendMode == 5) effectiveBlendMode = 3;
-                    }
-                    if (forceCutout) effectiveBlendMode = 1;
-
-                    VkPipeline desiredPipeline;
-                    if (forceCutout) {
-                        desiredPipeline = opaquePipeline_;
-                    } else {
-                        switch (effectiveBlendMode) {
-                            case 0: desiredPipeline = opaquePipeline_; break;
-                            case 1: desiredPipeline = alphaTestPipeline_; break;
-                            case 2: desiredPipeline = alphaPipeline_; break;
-                            default: desiredPipeline = additivePipeline_; break;
-                        }
-                    }
-                    if (desiredPipeline != currentPipeline) {
-                        vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, desiredPipeline);
-                        currentPipeline = desiredPipeline;
-                    }
-
-                    // Update material UBO
-                    if (batch.materialUBOMapped) {
-                        auto* mat = static_cast<M2MaterialUBO*>(batch.materialUBOMapped);
-                        mat->interiorDarken = insideInterior ? 1.0f : 0.0f;
-                        if (batch.colorKeyBlack)
-                            mat->colorKeyThreshold = (effectiveBlendMode == 4 || effectiveBlendMode == 5) ? 0.7f : 0.08f;
-                        if (forceCutout) {
-                            mat->alphaTest = model.isGroundDetail ? 3 : (foliageCutout ? 2 : 1);
-                            if (model.isGroundDetail) mat->unlit = 0;
-                        }
-                    }
-
-                    // Bind material descriptor set (set 1)
-                    if (!batch.materialSet) continue;
-                    if (batch.materialSet != currentMaterialSet) {
-                        vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                                pipelineLayout_, 1, 1, &batch.materialSet, 0, nullptr);
-                        currentMaterialSet = batch.materialSet;
-                    }
-
-                    // Push constants + instanced draw
-                    M2PushConstants pc;
-                    pc.texCoordSet = static_cast<int32_t>(batch.textureUnit);
-                    pc.isFoliage = model.shadowWindFoliage ? 1 : 0;
-                    pc.instanceDataOffset = static_cast<int32_t>(drawOffset);
-                    vkCmdPushConstants(cmd, pipelineLayout_, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(pc), &pc);
-                    vkCmdDrawIndexed(cmd, batch.indexCount, groupSize, batch.indexStart, 0, 0);
-                    lastDrawCallCount++;
-                }
-
-                lodIdx = lodEnd;
-            }
-
-            visStart = groupEnd;
-        }
-    }
-
-    // =====================================================================
-    // Pass 2: Transparent/additive batches — back-to-front per instance
-    // =====================================================================
-    // Transparent geometry must be drawn individually per instance in back-to-
-    // front order for correct alpha compositing.  Each draw writes one
-    // M2InstanceGPU entry and issues a single-instance indexed draw.
-    std::sort(sortedVisible_.begin(), sortedVisible_.end(),
-              [](const VisibleEntry& a, const VisibleEntry& b) { return a.distSq > b.distSq; });
-
-    currentModelId = UINT32_MAX;
-    currentModel = nullptr;
-    currentModelValid = false;
-    currentPipeline = opaquePipeline_;
-    currentMaterialSet = VK_NULL_HANDLE;
-
     for (const auto& entry : sortedVisible_) {
         if (entry.index >= instances.size()) continue;
         auto& instance = instances[entry.index];
 
-        // Quick skip: if model has no transparent batches at all
-        if (entry.modelId != currentModelId) {
-            auto mdlIt = models.find(entry.modelId);
-            if (mdlIt == models.end()) continue;
-            if (!mdlIt->second.hasTransparentBatches && !mdlIt->second.isSpellEffect) continue;
-        }
-
+        // Bind vertex + index buffers once per model group
         if (entry.modelId != currentModelId) {
             currentModelId = entry.modelId;
-            currentModelValid = false;
             auto mdlIt = models.find(currentModelId);
             if (mdlIt == models.end()) continue;
             currentModel = &mdlIt->second;
-            if (!currentModel->vertexBuffer || !currentModel->indexBuffer) continue;
-            currentModelValid = true;
-            VkDeviceSize vbOff = 0;
-            vkCmdBindVertexBuffers(cmd, 0, 1, &currentModel->vertexBuffer, &vbOff);
+            if (!currentModel->vertexBuffer) continue;
+            VkDeviceSize offset = 0;
+            vkCmdBindVertexBuffers(cmd, 0, 1, &currentModel->vertexBuffer, &offset);
             vkCmdBindIndexBuffer(cmd, currentModel->indexBuffer, 0, VK_INDEX_TYPE_UINT16);
         }
-        if (!currentModelValid) continue;
 
         const M2ModelGPU& model = *currentModel;
 
-        // Fade alpha
+        // Distance-based fade alpha for smooth pop-in (squared-distance, no sqrt)
         float fadeAlpha = 1.0f;
         float fadeFrac = model.disableAnimation ? 0.55f : fadeStartFraction;
         float fadeStartDistSq = entry.effectiveMaxDistSq * fadeFrac * fadeFrac;
@@ -3120,64 +2404,123 @@ void M2Renderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const
             fadeAlpha = std::clamp((entry.effectiveMaxDistSq - entry.distSq) /
                                   (entry.effectiveMaxDistSq - fadeStartDistSq), 0.0f, 1.0f);
         }
+
         float instanceFadeAlpha = fadeAlpha;
-        if (model.isGroundDetail) instanceFadeAlpha *= 0.82f;
-        if (model.isInstancePortal) instanceFadeAlpha *= 0.12f;
+        if (model.isGroundDetail) {
+            instanceFadeAlpha *= 0.82f;
+        }
+        if (model.isInstancePortal) {
+            // Render mesh at low alpha + emit glow sprite at center
+            instanceFadeAlpha *= 0.12f;
+            if (entry.distSq < 400.0f * 400.0f) {
+                glm::vec3 center = glm::vec3(instance.modelMatrix * glm::vec4(0.0f, 0.0f, 0.0f, 1.0f));
+                GlowSprite gs;
+                gs.worldPos = center;
+                gs.color = glm::vec4(0.35f, 0.5f, 1.0f, 1.1f);
+                gs.size = instance.scale * 5.0f;
+                glowSprites_.push_back(gs);
+                GlowSprite halo = gs;
+                halo.color.a *= 0.3f;
+                halo.size *= 2.2f;
+                glowSprites_.push_back(halo);
+            }
+        }
 
+        // Upload bone matrices to SSBO if model has skeletal animation.
+        // Skip animated instances entirely until bones are computed + buffers allocated
+        // to prevent bind-pose/T-pose flash on first appearance.
         bool modelNeedsAnimation = model.hasAnimation && !model.disableAnimation;
-        if (modelNeedsAnimation && instance.boneMatrices.empty()) continue;
+        if (modelNeedsAnimation && instance.boneMatrices.empty()) {
+            continue;  // Bones not yet computed — skip to avoid bind-pose flash
+        }
         bool needsBones = modelNeedsAnimation && !instance.boneMatrices.empty();
-        if (needsBones && instance.megaBoneOffset == 0) continue;
+        if (needsBones && (!instance.boneBuffer[frameIndex] || !instance.boneSet[frameIndex])) {
+            continue;  // Bone buffers not yet allocated — skip to avoid bind-pose flash
+        }
+        bool useBones = needsBones;
+        if (useBones) {
+            // Upload bone matrices only when recomputed (per-frame-index tracking
+            // ensures both double-buffered SSBOs get the latest bone data)
+            if (instance.bonesDirty[frameIndex] && instance.boneMapped[frameIndex]) {
+                int numBones = std::min(static_cast<int>(instance.boneMatrices.size()), 128);
+                memcpy(instance.boneMapped[frameIndex], instance.boneMatrices.data(),
+                       numBones * sizeof(glm::mat4));
+                instance.bonesDirty[frameIndex] = false;
+            }
 
+            // Bind bone descriptor set (set 2)
+            if (instance.boneSet[frameIndex]) {
+                vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
+                                        pipelineLayout_, 2, 1, &instance.boneSet[frameIndex], 0, nullptr);
+            }
+        }
+
+        // LOD selection based on squared distance (avoid sqrt)
         uint16_t desiredLOD = 0;
         if (entry.distSq > 150.0f * 150.0f) desiredLOD = 3;
         else if (entry.distSq > 80.0f * 80.0f) desiredLOD = 2;
         else if (entry.distSq > 40.0f * 40.0f) desiredLOD = 1;
-        uint16_t targetLOD = desiredLOD;
-        if (desiredLOD > 0 && !(model.availableLODs & (1u << desiredLOD))) targetLOD = 0;
 
+        uint16_t targetLOD = desiredLOD;
+        if (desiredLOD > 0 && !(model.availableLODs & (1u << desiredLOD))) {
+            targetLOD = 0;
+        }
+
+        const bool foliageLikeModel = model.isFoliageLike;
+        // Particle-dominant spell effects: mesh is emission geometry, render dim
         const bool particleDominantEffect = model.isSpellEffect &&
             !model.particleEmitters.empty() && model.batches.size() <= 2;
-
         for (const auto& batch : model.batches) {
             if (batch.indexCount == 0) continue;
             if (!model.isGroundDetail && batch.submeshLevel != targetLOD) continue;
             if (batch.batchOpacity < 0.01f) continue;
 
-            // Pass 2 gate: only transparent/additive batches
-            {
-                const bool rawTransparent = (batch.blendMode >= 2) || model.isSpellEffect;
-                if (!rawTransparent) continue;
-            }
-
-            // Skip glow sprites (handled in opaque pass)
-            const bool batchUnlit = (batch.materialFlags & 0x01) != 0;
             const bool koboldFlameCard = batch.colorKeyBlack && model.isKoboldFlame;
             const bool smallCardLikeBatch =
                 (batch.glowSize <= 1.35f) ||
                 (batch.lanternGlowHint && batch.glowSize <= 6.0f);
+            const bool batchUnlit = (batch.materialFlags & 0x01) != 0;
+            const bool elvenLikeModel = model.isElvenLike;
+            const bool lanternLikeModel = model.isLanternLike;
             const bool shouldUseGlowSprite =
                 !koboldFlameCard &&
-                (model.isElvenLike || model.isLanternLike) &&
+                (elvenLikeModel || (lanternLikeModel && batch.lanternGlowHint)) &&
                 !model.isSpellEffect &&
                 smallCardLikeBatch &&
-                (batch.lanternGlowHint || (batch.blendMode >= 3) ||
+                (batch.lanternGlowHint ||
+                 (batch.blendMode >= 3) ||
                  (batch.colorKeyBlack && batchUnlit && batch.blendMode >= 1));
             if (shouldUseGlowSprite) {
-                const bool cardLikeSkipMesh = (batch.blendMode >= 3) || batch.colorKeyBlack || batchUnlit;
-                const bool lanternGlowCardSkip =
-                    model.isLanternLike &&
-                    batch.lanternGlowHint &&
-                    smallCardLikeBatch &&
-                    cardLikeSkipMesh;
-                if (lanternGlowCardSkip || (cardLikeSkipMesh && !model.isLanternLike))
+                if (entry.distSq < 180.0f * 180.0f) {
+                    glm::vec3 worldPos = glm::vec3(instance.modelMatrix * glm::vec4(batch.center, 1.0f));
+                    GlowSprite gs;
+                    gs.worldPos = worldPos;
+                    if (batch.glowTint == 1 || elvenLikeModel) {
+                        gs.color = glm::vec4(0.48f, 0.72f, 1.0f, 1.05f);
+                    } else if (batch.glowTint == 2) {
+                        gs.color = glm::vec4(1.0f, 0.28f, 0.22f, 1.10f);
+                    } else {
+                        gs.color = glm::vec4(1.0f, 0.82f, 0.46f, 1.15f);
+                    }
+                    gs.size = batch.glowSize * instance.scale * 1.45f;
+                    glowSprites_.push_back(gs);
+                    GlowSprite halo = gs;
+                    halo.color.a *= 0.42f;
+                    halo.size *= 1.8f;
+                    glowSprites_.push_back(halo);
+                }
+                const bool cardLikeSkipMesh =
+                    (batch.blendMode >= 3) ||
+                    batch.colorKeyBlack ||
+                    ((batch.materialFlags & 0x01) != 0);
+                if ((batch.glowCardLike && lanternLikeModel) ||
+                    (cardLikeSkipMesh && !lanternLikeModel)) {
                     continue;
+                }
             }
 
-            if (particleDominantEffect) continue; // emission-only mesh
-
-            // Compute UV offset for this instance + batch
-            glm::vec2 uvOffset(0.0f);
+            // Compute UV offset for texture animation
+            glm::vec2 uvOffset(0.0f, 0.0f);
             if (batch.textureAnimIndex != 0xFFFF && model.hasTextureAnimation) {
                 uint16_t lookupIdx = batch.textureAnimIndex;
                 if (lookupIdx < model.textureTransformLookup.size()) {
@@ -3191,60 +2534,95 @@ void M2Renderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const
                     }
                 }
             }
+            // Lava M2 models: fallback UV scroll if no texture animation
             if (model.isLavaModel && uvOffset == glm::vec2(0.0f)) {
-                float t = std::chrono::duration<float>(std::chrono::steady_clock::now() - kLavaAnimStart).count();
+                static auto startTime = std::chrono::steady_clock::now();
+                float t = std::chrono::duration<float>(std::chrono::steady_clock::now() - startTime).count();
                 uvOffset = glm::vec2(t * 0.03f, -t * 0.08f);
             }
 
-            // Write single instance entry to SSBO
-            if (instanceDataCount_ >= MAX_INSTANCE_DATA) continue;
-            uint32_t drawOffset = instanceDataCount_;
-            auto& e = instSSBO[instanceDataCount_];
-            e.model = instance.modelMatrix;
-            e.uvOffset = uvOffset;
-            e.fadeAlpha = instanceFadeAlpha;
-            e.useBones = needsBones ? 1 : 0;
-            e.boneBase = needsBones ? static_cast<int32_t>(instance.megaBoneOffset) : 0;
-            std::memset(e._pad, 0, sizeof(e._pad));
-            instanceDataCount_++;
+            // Foliage/card-like batches render more stably as cutout (depth-write on)
+            // instead of alpha-blended sorting.
+            const bool foliageCutout =
+                foliageLikeModel &&
+                !model.isSpellEffect &&
+                batch.blendMode <= 3;
+            const bool forceCutout =
+                !model.isSpellEffect &&
+                (model.isGroundDetail ||
+                 foliageCutout ||
+                 batch.blendMode == 1 ||
+                 (batch.blendMode >= 2 && !batch.hasAlpha) ||
+                 batch.colorKeyBlack);
 
-            // Pipeline selection
+            // Select pipeline based on blend mode
             uint8_t effectiveBlendMode = batch.blendMode;
             if (model.isSpellEffect) {
-                if (effectiveBlendMode <= 1) effectiveBlendMode = 3;
-                else if (effectiveBlendMode == 4 || effectiveBlendMode == 5) effectiveBlendMode = 3;
+                // Effect models: force additive blend for opaque/cutout batches
+                // so the mesh renders as a transparent glow, not a solid object
+                if (effectiveBlendMode <= 1) {
+                    effectiveBlendMode = 3;  // additive
+                } else if (effectiveBlendMode == 4 || effectiveBlendMode == 5) {
+                    effectiveBlendMode = 3;
+                }
+            }
+            if (forceCutout) {
+                effectiveBlendMode = 1;
             }
 
             VkPipeline desiredPipeline;
-            switch (effectiveBlendMode) {
-                case 2: desiredPipeline = alphaPipeline_; break;
-                default: desiredPipeline = additivePipeline_; break;
+            if (forceCutout) {
+                // Use opaque pipeline + shader discard for stable foliage cards.
+                desiredPipeline = opaquePipeline_;
+            } else {
+                switch (effectiveBlendMode) {
+                    case 0: desiredPipeline = opaquePipeline_; break;
+                    case 1: desiredPipeline = alphaTestPipeline_; break;
+                    case 2: desiredPipeline = alphaPipeline_; break;
+                    default: desiredPipeline = additivePipeline_; break;
+                }
             }
             if (desiredPipeline != currentPipeline) {
                 vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, desiredPipeline);
                 currentPipeline = desiredPipeline;
             }
 
+            // Update material UBO with per-draw dynamic values (interiorDarken, forceCutout overrides)
+            // Note: fadeAlpha is in push constants (per-draw) to avoid shared-UBO race
             if (batch.materialUBOMapped) {
                 auto* mat = static_cast<M2MaterialUBO*>(batch.materialUBOMapped);
                 mat->interiorDarken = insideInterior ? 1.0f : 0.0f;
-                if (batch.colorKeyBlack)
+                if (batch.colorKeyBlack) {
                     mat->colorKeyThreshold = (effectiveBlendMode == 4 || effectiveBlendMode == 5) ? 0.7f : 0.08f;
+                }
+                if (forceCutout) {
+                    mat->alphaTest = model.isGroundDetail ? 3 : (foliageCutout ? 2 : 1);
+                    if (model.isGroundDetail) {
+                        mat->unlit = 0;
+                    }
+                }
             }
 
+            // Bind material descriptor set (set 1) — skip batch if missing
+            // to avoid inheriting a stale descriptor set from a prior renderer
             if (!batch.materialSet) continue;
-            if (batch.materialSet != currentMaterialSet) {
-                vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                        pipelineLayout_, 1, 1, &batch.materialSet, 0, nullptr);
-                currentMaterialSet = batch.materialSet;
-            }
+            vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
+                                    pipelineLayout_, 1, 1, &batch.materialSet, 0, nullptr);
 
-            // Push constants + single-instance draw
+            // Push constants
             M2PushConstants pc;
-            pc.texCoordSet = static_cast<int32_t>(batch.textureUnit);
+            pc.model = instance.modelMatrix;
+            pc.uvOffset = uvOffset;
+            pc.texCoordSet = static_cast<int>(batch.textureUnit);
+            pc.useBones = useBones ? 1 : 0;
             pc.isFoliage = model.shadowWindFoliage ? 1 : 0;
-            pc.instanceDataOffset = static_cast<int32_t>(drawOffset);
+            pc.fadeAlpha = instanceFadeAlpha;
+            // Particle-dominant effects: mesh is emission geometry, don't render
+            if (particleDominantEffect && batch.blendMode <= 1) {
+                continue;
+            }
             vkCmdPushConstants(cmd, pipelineLayout_, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(pc), &pc);
+
             vkCmdDrawIndexed(cmd, batch.indexCount, 1, batch.indexStart, 0, 0);
             lastDrawCallCount++;
         }
@@ -3290,6 +2668,16 @@ bool M2Renderer::initializeShadow(VkRenderPass shadowRenderPass) {
     if (!vkCtx_ || shadowRenderPass == VK_NULL_HANDLE) return false;
     VkDevice device = vkCtx_->getDevice();
 
+    // ShadowParams UBO: useBones, useTexture, alphaTest, foliageSway, windTime, foliageMotionDamp
+    struct ShadowParamsUBO {
+        int32_t useBones = 0;
+        int32_t useTexture = 0;
+        int32_t alphaTest = 0;
+        int32_t foliageSway = 0;
+        float windTime = 0.0f;
+        float foliageMotionDamp = 1.0f;
+    };
+
     // Create ShadowParams UBO
     VkBufferCreateInfo bufCI{};
     bufCI.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
@@ -3379,7 +2767,7 @@ bool M2Renderer::initializeShadow(VkRenderPass shadowRenderPass) {
     writes[1].pBufferInfo = &bufInfo;
     vkUpdateDescriptorSets(device, 2, writes, 0, nullptr);
 
-    // Per-frame pools for foliage shadow texture sets (one per frame-in-flight, reset each frame)
+    // Per-frame pool for foliage shadow texture sets (reset each frame)
     {
         VkDescriptorPoolSize texPoolSizes[2]{};
         texPoolSizes[0].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
@@ -3391,11 +2779,9 @@ bool M2Renderer::initializeShadow(VkRenderPass shadowRenderPass) {
         texPoolCI.maxSets = 256;
         texPoolCI.poolSizeCount = 2;
         texPoolCI.pPoolSizes = texPoolSizes;
-        for (uint32_t f = 0; f < kShadowTexPoolFrames; ++f) {
-            if (vkCreateDescriptorPool(device, &texPoolCI, nullptr, &shadowTexPool_[f]) != VK_SUCCESS) {
-                LOG_ERROR("M2Renderer: failed to create shadow texture pool ", f);
-                return false;
-            }
+        if (vkCreateDescriptorPool(device, &texPoolCI, nullptr, &shadowTexPool_) != VK_SUCCESS) {
+            LOG_ERROR("M2Renderer: failed to create shadow texture pool");
+            return false;
         }
     }
 
@@ -3451,7 +2837,7 @@ bool M2Renderer::initializeShadow(VkRenderPass shadowRenderPass) {
         .setLayout(shadowPipelineLayout_)
         .setRenderPass(shadowRenderPass)
         .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     vertShader.destroy();
     fragShader.destroy();
@@ -3469,18 +2855,23 @@ void M2Renderer::renderShadow(VkCommandBuffer cmd, const glm::mat4& lightSpaceMa
     if (!shadowPipeline_ || !shadowParamsSet_) return;
     if (instances.empty() || models.empty()) return;
 
+    struct ShadowPush { glm::mat4 lightSpaceMatrix; glm::mat4 model; };
+    struct ShadowParamsUBO {
+        int32_t useBones = 0;
+        int32_t useTexture = 0;
+        int32_t alphaTest = 0;
+        int32_t foliageSway = 0;
+        float windTime = 0.0f;
+        float foliageMotionDamp = 1.0f;
+    };
     const float shadowRadiusSq = shadowRadius * shadowRadius;
 
-    // Reset this frame slot's texture descriptor pool (safe: fence was waited on in beginFrame)
-    const uint32_t frameIdx = vkCtx_->getCurrentFrame();
-    VkDescriptorPool curShadowTexPool = shadowTexPool_[frameIdx];
-    if (curShadowTexPool) {
-        vkResetDescriptorPool(vkCtx_->getDevice(), curShadowTexPool, 0);
+    // Reset per-frame texture descriptor pool for foliage alpha-test sets
+    if (shadowTexPool_) {
+        vkResetDescriptorPool(vkCtx_->getDevice(), shadowTexPool_, 0);
     }
     // Cache: texture imageView -> allocated descriptor set (avoids duplicates within frame)
-    // Reuse persistent map — pool reset already invalidated the sets.
-    shadowTexSetCache_.clear();
-    auto& texSetCache = shadowTexSetCache_;
+    std::unordered_map<VkImageView, VkDescriptorSet> texSetCache;
 
     auto getTexDescSet = [&](VkTexture* tex) -> VkDescriptorSet {
         VkImageView iv = tex->getImageView();
@@ -3490,7 +2881,7 @@ void M2Renderer::renderShadow(VkCommandBuffer cmd, const glm::mat4& lightSpaceMa
         VkDescriptorSet set = VK_NULL_HANDLE;
         VkDescriptorSetAllocateInfo ai{};
         ai.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
-        ai.descriptorPool = curShadowTexPool;
+        ai.descriptorPool = shadowTexPool_;
         ai.descriptorSetCount = 1;
         ai.pSetLayouts = &shadowParamsLayout_;
         if (vkAllocateDescriptorSets(vkCtx_->getDevice(), &ai, &set) != VK_SUCCESS) {
@@ -3619,14 +3010,11 @@ float M2Renderer::interpFloat(const pipeline::M2AnimationTrack& track, float ani
     return glm::mix(keys.floatValues[i0], keys.floatValues[i1], frac);
 }
 
-// Interpolate an M2 FBlock (particle lifetime curve) at a given life ratio [0..1].
-// FBlocks store per-lifetime keyframes for particle color, alpha, and scale.
-// NOTE: interpFBlockFloat and interpFBlockVec3 share identical interpolation logic —
-// if you fix a bug in one, update the other to match.
 float M2Renderer::interpFBlockFloat(const pipeline::M2FBlock& fb, float lifeRatio) {
     if (fb.floatValues.empty()) return 1.0f;
     if (fb.floatValues.size() == 1 || fb.timestamps.empty()) return fb.floatValues[0];
     lifeRatio = glm::clamp(lifeRatio, 0.0f, 1.0f);
+    // Find surrounding timestamps
     for (size_t i = 0; i < fb.timestamps.size() - 1; i++) {
         if (lifeRatio <= fb.timestamps[i + 1]) {
             float t0 = fb.timestamps[i];
@@ -3725,8 +3113,8 @@ void M2Renderer::emitParticles(M2Instance& inst, const M2ModelGPU& gpu, float dt
             dir.x += distN(particleRng_) * hRange;
             dir.y += distN(particleRng_) * hRange;
             dir.z += distN(particleRng_) * vRange;
-            float lenSq = glm::dot(dir, dir);
-            if (lenSq > 0.001f * 0.001f) dir *= glm::inversesqrt(lenSq);
+            float len = glm::length(dir);
+            if (len > 0.001f) dir /= len;
 
             // Transform direction by bone + model orientation (rotation only)
             glm::mat3 rotMat = glm::mat3(inst.modelMatrix * boneXform);
@@ -3812,219 +3200,39 @@ void M2Renderer::updateParticles(M2Instance& inst, float dt) {
     }
 }
 
-// ---------------------------------------------------------------------------
-// Ribbon emitter simulation
-// ---------------------------------------------------------------------------
-void M2Renderer::updateRibbons(M2Instance& inst, const M2ModelGPU& gpu, float dt) {
-    const auto& emitters = gpu.ribbonEmitters;
-    if (emitters.empty()) return;
-
-    // Grow per-instance state arrays if needed
-    if (inst.ribbonEdges.size() != emitters.size()) {
-        inst.ribbonEdges.resize(emitters.size());
-    }
-    if (inst.ribbonEdgeAccumulators.size() != emitters.size()) {
-        inst.ribbonEdgeAccumulators.resize(emitters.size(), 0.0f);
-    }
-
-    for (size_t ri = 0; ri < emitters.size(); ri++) {
-        const auto& em = emitters[ri];
-        auto& edges    = inst.ribbonEdges[ri];
-        auto& accum    = inst.ribbonEdgeAccumulators[ri];
-
-        // Determine bone world position for spine
-        glm::vec3 spineWorld = inst.position;
-        if (em.bone < inst.boneMatrices.size()) {
-            glm::vec4 local(em.position.x, em.position.y, em.position.z, 1.0f);
-            spineWorld = glm::vec3(inst.modelMatrix * inst.boneMatrices[em.bone] * local);
-        } else {
-            glm::vec4 local(em.position.x, em.position.y, em.position.z, 1.0f);
-            spineWorld = glm::vec3(inst.modelMatrix * local);
-        }
-
-        // Evaluate animated tracks (use first available sequence key, or fallback value)
-        auto getFloatVal = [&](const pipeline::M2AnimationTrack& track, float fallback) -> float {
-            for (const auto& seq : track.sequences) {
-                if (!seq.floatValues.empty()) return seq.floatValues[0];
-            }
-            return fallback;
-        };
-        auto getVec3Val = [&](const pipeline::M2AnimationTrack& track, glm::vec3 fallback) -> glm::vec3 {
-            for (const auto& seq : track.sequences) {
-                if (!seq.vec3Values.empty()) return seq.vec3Values[0];
-            }
-            return fallback;
-        };
-
-        float visibility  = getFloatVal(em.visibilityTrack, 1.0f);
-        float heightAbove = getFloatVal(em.heightAboveTrack, 0.5f);
-        float heightBelow = getFloatVal(em.heightBelowTrack, 0.5f);
-        glm::vec3 color   = getVec3Val(em.colorTrack, glm::vec3(1.0f));
-        float alpha       = getFloatVal(em.alphaTrack, 1.0f);
-
-        // Age existing edges and remove expired ones
-        for (auto& e : edges) {
-            e.age += dt;
-            // Apply gravity
-            if (em.gravity != 0.0f) {
-                e.worldPos.z -= em.gravity * dt * dt * 0.5f;
-            }
-        }
-        while (!edges.empty() && edges.front().age >= em.edgeLifetime) {
-            edges.pop_front();
-        }
-
-        // Emit new edges based on edgesPerSecond
-        if (visibility > 0.5f) {
-            accum += em.edgesPerSecond * dt;
-            while (accum >= 1.0f) {
-                accum -= 1.0f;
-                M2Instance::RibbonEdge e;
-                e.worldPos    = spineWorld;
-                e.color       = color;
-                e.alpha       = alpha;
-                e.heightAbove = heightAbove;
-                e.heightBelow = heightBelow;
-                e.age         = 0.0f;
-                edges.push_back(e);
-                // Cap trail length
-                if (edges.size() > 128) edges.pop_front();
-            }
-        } else {
-            accum = 0.0f;
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Ribbon rendering
-// ---------------------------------------------------------------------------
-void M2Renderer::renderM2Ribbons(VkCommandBuffer cmd, VkDescriptorSet perFrameSet) {
-    if (!ribbonPipeline_ || !ribbonAdditivePipeline_ || !ribbonVB_ || !ribbonVBMapped_) return;
-
-    // Build camera right vector for billboard orientation
-    // For ribbons we orient the quad strip along the spine with screen-space up.
-    // Simple approach: use world-space Z=up for the ribbon cross direction.
-    const glm::vec3 upWorld(0.0f, 0.0f, 1.0f);
-
-    float* dst     = static_cast<float*>(ribbonVBMapped_);
-    size_t written = 0;
-
-    ribbonDraws_.clear();
-    auto& draws = ribbonDraws_;
-
-    for (const auto& inst : instances) {
-        if (!inst.cachedModel) continue;
-        const auto& gpu = *inst.cachedModel;
-        if (gpu.ribbonEmitters.empty()) continue;
-
-        for (size_t ri = 0; ri < gpu.ribbonEmitters.size(); ri++) {
-            if (ri >= inst.ribbonEdges.size()) continue;
-            const auto& edges = inst.ribbonEdges[ri];
-            if (edges.size() < 2) continue;
-
-            const auto& em = gpu.ribbonEmitters[ri];
-
-            // Select blend pipeline based on material blend mode
-            bool additive = false;
-            if (em.materialIndex < gpu.batches.size()) {
-                additive = (gpu.batches[em.materialIndex].blendMode >= 3);
-            }
-            VkPipeline pipe = additive ? ribbonAdditivePipeline_ : ribbonPipeline_;
-
-            // Descriptor set for texture
-            VkDescriptorSet texSet = (ri < gpu.ribbonTexSets.size())
-                                     ? gpu.ribbonTexSets[ri] : VK_NULL_HANDLE;
-            if (!texSet) continue;
-
-            uint32_t firstVert = static_cast<uint32_t>(written);
-
-            // Emit triangle strip: 2 verts per edge (top + bottom)
-            for (size_t ei = 0; ei < edges.size(); ei++) {
-                if (written + 2 > MAX_RIBBON_VERTS) break;
-                const auto& e = edges[ei];
-                float t = (em.edgeLifetime > 0.0f)
-                          ? 1.0f - (e.age / em.edgeLifetime) : 1.0f;
-                float a = e.alpha * t;
-                float u = static_cast<float>(ei) / static_cast<float>(edges.size() - 1);
-
-                // Top vertex (above spine along upWorld)
-                glm::vec3 top = e.worldPos + upWorld * e.heightAbove;
-                dst[written * 9 + 0] = top.x;
-                dst[written * 9 + 1] = top.y;
-                dst[written * 9 + 2] = top.z;
-                dst[written * 9 + 3] = e.color.r;
-                dst[written * 9 + 4] = e.color.g;
-                dst[written * 9 + 5] = e.color.b;
-                dst[written * 9 + 6] = a;
-                dst[written * 9 + 7] = u;
-                dst[written * 9 + 8] = 0.0f; // v = top
-                written++;
-
-                // Bottom vertex (below spine)
-                glm::vec3 bot = e.worldPos - upWorld * e.heightBelow;
-                dst[written * 9 + 0] = bot.x;
-                dst[written * 9 + 1] = bot.y;
-                dst[written * 9 + 2] = bot.z;
-                dst[written * 9 + 3] = e.color.r;
-                dst[written * 9 + 4] = e.color.g;
-                dst[written * 9 + 5] = e.color.b;
-                dst[written * 9 + 6] = a;
-                dst[written * 9 + 7] = u;
-                dst[written * 9 + 8] = 1.0f; // v = bottom
-                written++;
-            }
-
-            uint32_t vertCount = static_cast<uint32_t>(written) - firstVert;
-            if (vertCount >= 4) {
-                draws.push_back({texSet, pipe, firstVert, vertCount});
-            } else {
-                // Rollback if too few verts
-                written = firstVert;
-            }
-        }
-    }
-
-    if (draws.empty() || written == 0) return;
-
-    VkExtent2D ext = vkCtx_->getSwapchainExtent();
-    VkViewport vp{};
-    vp.x = 0; vp.y = 0;
-    vp.width  = static_cast<float>(ext.width);
-    vp.height = static_cast<float>(ext.height);
-    vp.minDepth = 0.0f; vp.maxDepth = 1.0f;
-    VkRect2D sc{};
-    sc.offset = {0, 0};
-    sc.extent = ext;
-    vkCmdSetViewport(cmd, 0, 1, &vp);
-    vkCmdSetScissor(cmd, 0, 1, &sc);
-
-    VkPipeline lastPipe = VK_NULL_HANDLE;
-    for (const auto& dc : draws) {
-        if (dc.pipeline != lastPipe) {
-            vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, dc.pipeline);
-            vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                    ribbonPipelineLayout_, 0, 1, &perFrameSet, 0, nullptr);
-            lastPipe = dc.pipeline;
-        }
-        vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                ribbonPipelineLayout_, 1, 1, &dc.texSet, 0, nullptr);
-        VkDeviceSize offset = 0;
-        vkCmdBindVertexBuffers(cmd, 0, 1, &ribbonVB_, &offset);
-        vkCmdDraw(cmd, dc.vertexCount, 1, dc.firstVertex, 0);
-    }
-}
-
 void M2Renderer::renderM2Particles(VkCommandBuffer cmd, VkDescriptorSet perFrameSet) {
     if (!particlePipeline_ || !m2ParticleVB_) return;
 
     // Collect all particles from all instances, grouped by texture+blend
-    // Reuse persistent map — clear each group's vertex data but keep bucket structure.
-    for (auto& [k, g] : particleGroups_) {
-        g.vertexData.clear();
-        g.preAllocSet = VK_NULL_HANDLE;
-    }
-    auto& groups = particleGroups_;
+    struct ParticleGroupKey {
+        VkTexture* texture;
+        uint8_t blendType;
+        uint16_t tilesX;
+        uint16_t tilesY;
+
+        bool operator==(const ParticleGroupKey& other) const {
+            return texture == other.texture &&
+                   blendType == other.blendType &&
+                   tilesX == other.tilesX &&
+                   tilesY == other.tilesY;
+        }
+    };
+    struct ParticleGroupKeyHash {
+        size_t operator()(const ParticleGroupKey& key) const {
+            size_t h1 = std::hash<uintptr_t>{}(reinterpret_cast<uintptr_t>(key.texture));
+            size_t h2 = std::hash<uint32_t>{}((static_cast<uint32_t>(key.tilesX) << 16) | key.tilesY);
+            size_t h3 = std::hash<uint8_t>{}(key.blendType);
+            return h1 ^ (h2 * 0x9e3779b9u) ^ (h3 * 0x85ebca6bu);
+        }
+    };
+    struct ParticleGroup {
+        VkTexture* texture;
+        uint8_t blendType;
+        uint16_t tilesX;
+        uint16_t tilesY;
+        std::vector<float> vertexData;  // 9 floats per particle
+    };
+    std::unordered_map<ParticleGroupKey, ParticleGroup, ParticleGroupKeyHash> groups;
 
     size_t totalParticles = 0;
 
@@ -4063,11 +3271,6 @@ void M2Renderer::renderM2Particles(VkCommandBuffer cmd, VkDescriptorSet perFrame
             group.blendType = em.blendingType;
             group.tilesX = tilesX;
             group.tilesY = tilesY;
-            // Capture pre-allocated descriptor set on first insertion for this key
-            if (group.preAllocSet == VK_NULL_HANDLE &&
-                p.emitterIndex < static_cast<int>(gpu.particleTexSets.size())) {
-                group.preAllocSet = gpu.particleTexSets[p.emitterIndex];
-            }
 
             group.vertexData.push_back(p.position.x);
             group.vertexData.push_back(p.position.y);
@@ -4081,12 +3284,8 @@ void M2Renderer::renderM2Particles(VkCommandBuffer cmd, VkDescriptorSet perFrame
             if ((em.flags & kParticleFlagTiled) && totalTiles > 1) {
                 float animSeconds = inst.animTime / 1000.0f;
                 uint32_t animFrame = static_cast<uint32_t>(std::floor(animSeconds * totalTiles)) % totalTiles;
-                tileIndex = p.tileIndex + static_cast<float>(animFrame);
-                float tilesFloat = static_cast<float>(totalTiles);
-                // Wrap tile index within totalTiles range
-                while (tileIndex >= tilesFloat) {
-                    tileIndex -= tilesFloat;
-                }
+                tileIndex = std::fmod(p.tileIndex + static_cast<float>(animFrame),
+                                      static_cast<float>(totalTiles));
             }
             group.vertexData.push_back(tileIndex);
             totalParticles++;
@@ -4115,27 +3314,23 @@ void M2Renderer::renderM2Particles(VkCommandBuffer cmd, VkDescriptorSet perFrame
             currentPipeline = desiredPipeline;
         }
 
-        // Use pre-allocated stable descriptor set; fall back to per-frame alloc only if unavailable
-        VkDescriptorSet texSet = group.preAllocSet;
-        if (texSet == VK_NULL_HANDLE) {
-            // Fallback: allocate per-frame (pool exhaustion risk — should not happen in practice)
-            VkDescriptorSetAllocateInfo ai{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
-            ai.descriptorPool = materialDescPool_;
-            ai.descriptorSetCount = 1;
-            ai.pSetLayouts = &particleTexLayout_;
-            if (vkAllocateDescriptorSets(vkCtx_->getDevice(), &ai, &texSet) == VK_SUCCESS) {
-                VkTexture* tex = group.texture ? group.texture : whiteTexture_.get();
-                VkDescriptorImageInfo imgInfo = tex->descriptorInfo();
-                VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
-                write.dstSet = texSet;
-                write.dstBinding = 0;
-                write.descriptorCount = 1;
-                write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-                write.pImageInfo = &imgInfo;
-                vkUpdateDescriptorSets(vkCtx_->getDevice(), 1, &write, 0, nullptr);
-            }
-        }
-        if (texSet != VK_NULL_HANDLE) {
+        // Allocate descriptor set for this group's texture
+        VkDescriptorSetAllocateInfo ai{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
+        ai.descriptorPool = materialDescPool_;
+        ai.descriptorSetCount = 1;
+        ai.pSetLayouts = &particleTexLayout_;
+        VkDescriptorSet texSet = VK_NULL_HANDLE;
+        if (vkAllocateDescriptorSets(vkCtx_->getDevice(), &ai, &texSet) == VK_SUCCESS) {
+            VkTexture* tex = group.texture ? group.texture : whiteTexture_.get();
+            VkDescriptorImageInfo imgInfo = tex->descriptorInfo();
+            VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
+            write.dstSet = texSet;
+            write.dstBinding = 0;
+            write.descriptorCount = 1;
+            write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+            write.pImageInfo = &imgInfo;
+            vkUpdateDescriptorSets(vkCtx_->getDevice(), 1, &write, 0, nullptr);
+
             vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
                                     particlePipelineLayout_, 1, 1, &texSet, 0, nullptr);
         }
@@ -4244,49 +3439,6 @@ void M2Renderer::setInstanceAnimationFrozen(uint32_t instanceId, bool frozen) {
     }
 }
 
-void M2Renderer::setInstanceAnimation(uint32_t instanceId, uint32_t animationId, bool loop) {
-    auto idxIt = instanceIndexById.find(instanceId);
-    if (idxIt == instanceIndexById.end()) return;
-    auto& inst = instances[idxIt->second];
-    if (!inst.cachedModel) return;
-    const auto& seqs = inst.cachedModel->sequences;
-    // Find the first sequence matching the requested animation ID
-    for (int i = 0; i < static_cast<int>(seqs.size()); ++i) {
-        if (seqs[i].id == animationId) {
-            inst.currentSequenceIndex = i;
-            inst.animDuration = static_cast<float>(seqs[i].duration);
-            inst.animTime = 0.0f;
-            inst.animSpeed = 1.0f;
-            // Use playingVariation=true for one-shot (returns to idle when done)
-            inst.playingVariation = !loop;
-            return;
-        }
-    }
-}
-
-bool M2Renderer::hasAnimation(uint32_t instanceId, uint32_t animationId) const {
-    auto idxIt = instanceIndexById.find(instanceId);
-    if (idxIt == instanceIndexById.end()) return false;
-    const auto& inst = instances[idxIt->second];
-    if (!inst.cachedModel) return false;
-    for (const auto& seq : inst.cachedModel->sequences) {
-        if (seq.id == animationId) return true;
-    }
-    return false;
-}
-
-float M2Renderer::getInstanceAnimDuration(uint32_t instanceId) const {
-    auto idxIt = instanceIndexById.find(instanceId);
-    if (idxIt == instanceIndexById.end()) return 0.0f;
-    const auto& inst = instances[idxIt->second];
-    if (!inst.cachedModel) return 0.0f;
-    const auto& seqs = inst.cachedModel->sequences;
-    if (seqs.empty()) return 0.0f;
-    int seqIdx = inst.currentSequenceIndex;
-    if (seqIdx < 0 || seqIdx >= static_cast<int>(seqs.size())) seqIdx = 0;
-    return seqs[seqIdx].duration; // in milliseconds
-}
-
 void M2Renderer::setInstanceTransform(uint32_t instanceId, const glm::mat4& transform) {
     auto idxIt = instanceIndexById.find(instanceId);
     if (idxIt == instanceIndexById.end()) return;
@@ -4341,67 +3493,14 @@ void M2Renderer::setInstanceTransform(uint32_t instanceId, const glm::mat4& tran
 }
 
 void M2Renderer::removeInstance(uint32_t instanceId) {
-    auto idxIt = instanceIndexById.find(instanceId);
-    if (idxIt == instanceIndexById.end()) return;
-    size_t idx = idxIt->second;
-    if (idx >= instances.size()) return;
-
-    auto& inst = instances[idx];
-
-    // Remove from spatial grid incrementally (same pattern as the move-update path)
-    GridCell minCell = toCell(inst.worldBoundsMin);
-    GridCell maxCell = toCell(inst.worldBoundsMax);
-    for (int z = minCell.z; z <= maxCell.z; z++) {
-        for (int y = minCell.y; y <= maxCell.y; y++) {
-            for (int x = minCell.x; x <= maxCell.x; x++) {
-                auto gIt = spatialGrid.find(GridCell{x, y, z});
-                if (gIt != spatialGrid.end()) {
-                    auto& vec = gIt->second;
-                    vec.erase(std::remove(vec.begin(), vec.end(), instanceId), vec.end());
-                }
-            }
+    for (auto it = instances.begin(); it != instances.end(); ++it) {
+        if (it->id == instanceId) {
+            destroyInstanceBones(*it);
+            instances.erase(it);
+            rebuildSpatialIndex();
+            return;
         }
     }
-
-    // Remove from dedup map
-    if (!inst.cachedIsGroundDetail) {
-        DedupKey dk{inst.modelId,
-                    static_cast<int32_t>(std::round(inst.position.x * 10.0f)),
-                    static_cast<int32_t>(std::round(inst.position.y * 10.0f)),
-                    static_cast<int32_t>(std::round(inst.position.z * 10.0f))};
-        instanceDedupMap_.erase(dk);
-    }
-
-    destroyInstanceBones(inst, /*defer=*/true);
-
-    // Swap-remove: move last element to the hole and pop_back to avoid O(n) shift
-    instanceIndexById.erase(instanceId);
-    if (idx < instances.size() - 1) {
-        uint32_t movedId = instances.back().id;
-        instances[idx] = std::move(instances.back());
-        instances.pop_back();
-        instanceIndexById[movedId] = idx;
-    } else {
-        instances.pop_back();
-    }
-
-    // Rebuild the lightweight auxiliary index vectors (smoke, portal, etc.)
-    // These are small vectors of indices that are rebuilt cheaply.
-    smokeInstanceIndices_.clear();
-    portalInstanceIndices_.clear();
-    animatedInstanceIndices_.clear();
-    particleOnlyInstanceIndices_.clear();
-    particleInstanceIndices_.clear();
-    for (size_t i = 0; i < instances.size(); i++) {
-        auto& ri = instances[i];
-        if (ri.cachedIsSmoke) smokeInstanceIndices_.push_back(i);
-        if (ri.cachedIsInstancePortal) portalInstanceIndices_.push_back(i);
-        if (ri.cachedHasParticleEmitters) particleInstanceIndices_.push_back(i);
-        if (ri.cachedHasAnimation && !ri.cachedDisableAnimation)
-            animatedInstanceIndices_.push_back(i);
-        else if (ri.cachedHasParticleEmitters)
-            particleOnlyInstanceIndices_.push_back(i);
-    }
 }
 
 void M2Renderer::setSkipCollision(uint32_t instanceId, bool skip) {
@@ -4422,7 +3521,7 @@ void M2Renderer::removeInstances(const std::vector<uint32_t>& instanceIds) {
     const size_t oldSize = instances.size();
     for (auto& inst : instances) {
         if (toRemove.count(inst.id)) {
-            destroyInstanceBones(inst, /*defer=*/true);
+            destroyInstanceBones(inst);
         }
     }
     instances.erase(std::remove_if(instances.begin(), instances.end(),
@@ -4473,21 +3572,6 @@ void M2Renderer::clear() {
         }
         if (boneDescPool_) {
             vkResetDescriptorPool(device, boneDescPool_, 0);
-            // Re-allocate the dummy bone set (invalidated by pool reset)
-            dummyBoneSet_ = allocateBoneSet();
-            if (dummyBoneSet_ && dummyBoneBuffer_) {
-                VkDescriptorBufferInfo bufInfo{};
-                bufInfo.buffer = dummyBoneBuffer_;
-                bufInfo.offset = 0;
-                bufInfo.range = sizeof(glm::mat4);
-                VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
-                write.dstSet = dummyBoneSet_;
-                write.dstBinding = 0;
-                write.descriptorCount = 1;
-                write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-                write.pBufferInfo = &bufInfo;
-                vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
-            }
         }
     }
     models.clear();
@@ -4624,39 +3708,15 @@ void M2Renderer::cleanupUnusedModels() {
         usedModelIds.insert(instance.modelId);
     }
 
-    const auto now = std::chrono::steady_clock::now();
-    constexpr auto kGracePeriod = std::chrono::seconds(60);
-
-    // Find models with no instances that have exceeded the grace period.
-    // Models that just lost their last instance get tracked but not evicted
-    // immediately — this prevents thrashing when GO models are briefly
-    // instance-free between despawn and respawn cycles.
+    // Find and remove models with no instances
     std::vector<uint32_t> toRemove;
     for (const auto& [id, model] : models) {
-        if (usedModelIds.find(id) != usedModelIds.end()) {
-            // Model still in use — clear any pending unused timestamp
-            modelUnusedSince_.erase(id);
-            continue;
-        }
-        auto unusedIt = modelUnusedSince_.find(id);
-        if (unusedIt == modelUnusedSince_.end()) {
-            // First cycle with no instances — start the grace timer
-            modelUnusedSince_[id] = now;
-        } else if (now - unusedIt->second >= kGracePeriod) {
-            // Grace period expired — mark for removal
+        if (usedModelIds.find(id) == usedModelIds.end()) {
             toRemove.push_back(id);
-            modelUnusedSince_.erase(unusedIt);
         }
     }
 
-    // Delete GPU resources and remove from map.
-    // Wait for the GPU to finish all in-flight frames before destroying any
-    // buffers — the previous frame's command buffer may still be referencing
-    // vertex/index buffers that are about to be freed. Without this wait,
-    // the GPU reads freed memory, which can cause VK_ERROR_DEVICE_LOST.
-    if (!toRemove.empty() && vkCtx_) {
-        vkDeviceWaitIdle(vkCtx_->getDevice());
-    }
+    // Delete GPU resources and remove from map
     for (uint32_t id : toRemove) {
         auto it = models.find(id);
         if (it != models.end()) {
@@ -4671,7 +3731,6 @@ void M2Renderer::cleanupUnusedModels() {
 }
 
 VkTexture* M2Renderer::loadTexture(const std::string& path, uint32_t texFlags) {
-    constexpr uint64_t kFailedTextureRetryLookups = 512;
     auto normalizeKey = [](std::string key) {
         std::replace(key.begin(), key.end(), '/', '\\');
         std::transform(key.begin(), key.end(), key.begin(),
@@ -4679,7 +3738,6 @@ VkTexture* M2Renderer::loadTexture(const std::string& path, uint32_t texFlags) {
         return key;
     };
     std::string key = normalizeKey(path);
-    const uint64_t lookupSerial = ++textureLookupSerial_;
 
     // Check cache
     auto it = textureCache.find(key);
@@ -4687,10 +3745,7 @@ VkTexture* M2Renderer::loadTexture(const std::string& path, uint32_t texFlags) {
         it->second.lastUse = ++textureCacheCounter_;
         return it->second.texture.get();
     }
-    auto failIt = failedTextureRetryAt_.find(key);
-    if (failIt != failedTextureRetryAt_.end() && lookupSerial < failIt->second) {
-        return whiteTexture_.get();
-    }
+    // No negative cache check — allow retries for transiently missing textures
 
     auto containsToken = [](const std::string& haystack, const char* token) {
         return haystack.find(token) != std::string::npos;
@@ -4721,9 +3776,8 @@ VkTexture* M2Renderer::loadTexture(const std::string& path, uint32_t texFlags) {
         blp = assetManager->loadTexture(key);
     }
     if (!blp.isValid()) {
-        // Cache misses briefly to avoid repeated expensive MPQ/disk probes.
-        failedTextureCache_.insert(key);
-        failedTextureRetryAt_[key] = lookupSerial + kFailedTextureRetryLookups;
+        // Return white fallback but don't cache the failure — MPQ reads can
+        // fail transiently during streaming; allow retry on next model load.
         if (loggedTextureLoadFails_.insert(key).second) {
             LOG_WARNING("M2: Failed to load texture: ", path);
         }
@@ -4738,7 +3792,6 @@ VkTexture* M2Renderer::loadTexture(const std::string& path, uint32_t texFlags) {
             // Cache budget-rejected keys too; without this we repeatedly decode/load
             // the same textures every frame once budget is saturated.
             failedTextureCache_.insert(key);
-            failedTextureRetryAt_[key] = lookupSerial + kFailedTextureRetryLookups;
         }
         if (textureBudgetRejectWarnings_ < 3) {
             LOG_WARNING("M2 texture cache full (", textureCacheBytes_ / (1024 * 1024),
@@ -4777,9 +3830,8 @@ VkTexture* M2Renderer::loadTexture(const std::string& path, uint32_t texFlags) {
     e.lastUse = ++textureCacheCounter_;
     textureCacheBytes_ += e.approxBytes;
     textureCache[key] = std::move(e);
-    failedTextureCache_.erase(key);
-    failedTextureRetryAt_.erase(key);
-    texturePropsByPtr_[texPtr] = {hasAlpha, colorKeyBlackHint};
+    textureHasAlphaByPtr_[texPtr] = hasAlpha;
+    textureColorKeyBlackByPtr_[texPtr] = colorKeyBlackHint;
     LOG_DEBUG("M2: Loaded texture: ", path, " (", blp.width, "x", blp.height, ")");
 
     return texPtr;
@@ -5214,7 +4266,7 @@ float M2Renderer::raycastBoundingBoxes(const glm::vec3& origin, const glm::vec3&
         getTightCollisionBounds(model, localMin, localMax);
         // Skip tiny doodads for camera occlusion; they cause jitter and false hits.
         glm::vec3 extents = (localMax - localMin) * instance.scale;
-        if (glm::dot(extents, extents) < 0.5625f) continue;
+        if (glm::length(extents) < 0.75f) continue;
 
         glm::vec3 localOrigin = glm::vec3(instance.invModelMatrix * glm::vec4(origin, 1.0f));
         glm::vec3 localDir = glm::normalize(glm::vec3(instance.invModelMatrix * glm::vec4(direction, 0.0f)));
@@ -5257,20 +4309,18 @@ void M2Renderer::recreatePipelines() {
     if (particlePipeline_)          { vkDestroyPipeline(device, particlePipeline_, nullptr); particlePipeline_ = VK_NULL_HANDLE; }
     if (particleAdditivePipeline_)  { vkDestroyPipeline(device, particleAdditivePipeline_, nullptr); particleAdditivePipeline_ = VK_NULL_HANDLE; }
     if (smokePipeline_)             { vkDestroyPipeline(device, smokePipeline_, nullptr); smokePipeline_ = VK_NULL_HANDLE; }
-    if (ribbonPipeline_)            { vkDestroyPipeline(device, ribbonPipeline_, nullptr); ribbonPipeline_ = VK_NULL_HANDLE; }
-    if (ribbonAdditivePipeline_)    { vkDestroyPipeline(device, ribbonAdditivePipeline_, nullptr); ribbonAdditivePipeline_ = VK_NULL_HANDLE; }
 
     // --- Load shaders ---
     rendering::VkShaderModule m2Vert, m2Frag;
     rendering::VkShaderModule particleVert, particleFrag;
     rendering::VkShaderModule smokeVert, smokeFrag;
 
-    (void)m2Vert.loadFromFile(device, "assets/shaders/m2.vert.spv");
-    (void)m2Frag.loadFromFile(device, "assets/shaders/m2.frag.spv");
-    (void)particleVert.loadFromFile(device, "assets/shaders/m2_particle.vert.spv");
-    (void)particleFrag.loadFromFile(device, "assets/shaders/m2_particle.frag.spv");
-    (void)smokeVert.loadFromFile(device, "assets/shaders/m2_smoke.vert.spv");
-    (void)smokeFrag.loadFromFile(device, "assets/shaders/m2_smoke.frag.spv");
+    m2Vert.loadFromFile(device, "assets/shaders/m2.vert.spv");
+    m2Frag.loadFromFile(device, "assets/shaders/m2.frag.spv");
+    particleVert.loadFromFile(device, "assets/shaders/m2_particle.vert.spv");
+    particleFrag.loadFromFile(device, "assets/shaders/m2_particle.frag.spv");
+    smokeVert.loadFromFile(device, "assets/shaders/m2_smoke.vert.spv");
+    smokeFrag.loadFromFile(device, "assets/shaders/m2_smoke.frag.spv");
 
     if (!m2Vert.isValid() || !m2Frag.isValid()) {
         LOG_ERROR("M2Renderer::recreatePipelines: missing required shaders");
@@ -5294,9 +4344,7 @@ void M2Renderer::recreatePipelines() {
         {4, 0, VK_FORMAT_R32G32B32A32_SFLOAT, 14 * sizeof(float)}, // boneIndices (float)
     };
 
-    // Pipeline derivatives — opaque is the base, others derive from it for shared state optimization
-    auto buildM2Pipeline = [&](VkPipelineColorBlendAttachmentState blendState, bool depthWrite,
-                               VkPipelineCreateFlags flags = 0, VkPipeline basePipeline = VK_NULL_HANDLE) -> VkPipeline {
+    auto buildM2Pipeline = [&](VkPipelineColorBlendAttachmentState blendState, bool depthWrite) -> VkPipeline {
         return PipelineBuilder()
             .setShaders(m2Vert.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
                         m2Frag.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
@@ -5309,19 +4357,13 @@ void M2Renderer::recreatePipelines() {
             .setLayout(pipelineLayout_)
             .setRenderPass(mainPass)
             .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-            .setFlags(flags)
-            .setBasePipeline(basePipeline)
-            .build(device, vkCtx_->getPipelineCache());
+            .build(device);
     };
 
-    opaquePipeline_ = buildM2Pipeline(PipelineBuilder::blendDisabled(), true,
-                                      VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT);
-    alphaTestPipeline_ = buildM2Pipeline(PipelineBuilder::blendAlpha(), true,
-                                         VK_PIPELINE_CREATE_DERIVATIVE_BIT, opaquePipeline_);
-    alphaPipeline_ = buildM2Pipeline(PipelineBuilder::blendAlpha(), false,
-                                     VK_PIPELINE_CREATE_DERIVATIVE_BIT, opaquePipeline_);
-    additivePipeline_ = buildM2Pipeline(PipelineBuilder::blendAdditive(), false,
-                                        VK_PIPELINE_CREATE_DERIVATIVE_BIT, opaquePipeline_);
+    opaquePipeline_ = buildM2Pipeline(PipelineBuilder::blendDisabled(), true);
+    alphaTestPipeline_ = buildM2Pipeline(PipelineBuilder::blendAlpha(), true);
+    alphaPipeline_ = buildM2Pipeline(PipelineBuilder::blendAlpha(), false);
+    additivePipeline_ = buildM2Pipeline(PipelineBuilder::blendAdditive(), false);
 
     // --- Particle pipelines ---
     if (particleVert.isValid() && particleFrag.isValid()) {
@@ -5350,7 +4392,7 @@ void M2Renderer::recreatePipelines() {
                 .setLayout(particlePipelineLayout_)
                 .setRenderPass(mainPass)
                 .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-                .build(device, vkCtx_->getPipelineCache());
+                .build(device);
         };
 
         particlePipeline_ = buildParticlePipeline(PipelineBuilder::blendAlpha());
@@ -5383,47 +4425,7 @@ void M2Renderer::recreatePipelines() {
             .setLayout(smokePipelineLayout_)
             .setRenderPass(mainPass)
             .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-            .build(device, vkCtx_->getPipelineCache());
-    }
-
-    // --- Ribbon pipelines ---
-    {
-        rendering::VkShaderModule ribVert, ribFrag;
-        (void)ribVert.loadFromFile(device, "assets/shaders/m2_ribbon.vert.spv");
-        (void)ribFrag.loadFromFile(device, "assets/shaders/m2_ribbon.frag.spv");
-        if (ribVert.isValid() && ribFrag.isValid()) {
-            VkVertexInputBindingDescription rBind{};
-            rBind.binding = 0;
-            rBind.stride = 9 * sizeof(float);
-            rBind.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
-
-            std::vector<VkVertexInputAttributeDescription> rAttrs = {
-                {0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0},
-                {1, 0, VK_FORMAT_R32G32B32_SFLOAT, 3 * sizeof(float)},
-                {2, 0, VK_FORMAT_R32_SFLOAT,       6 * sizeof(float)},
-                {3, 0, VK_FORMAT_R32G32_SFLOAT,    7 * sizeof(float)},
-            };
-
-            auto buildRibbonPipeline = [&](VkPipelineColorBlendAttachmentState blend) -> VkPipeline {
-                return PipelineBuilder()
-                    .setShaders(ribVert.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
-                                ribFrag.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
-                    .setVertexInput({rBind}, rAttrs)
-                    .setTopology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP)
-                    .setRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE)
-                    .setDepthTest(true, false, VK_COMPARE_OP_LESS_OR_EQUAL)
-                    .setColorBlendAttachment(blend)
-                    .setMultisample(vkCtx_->getMsaaSamples())
-                    .setLayout(ribbonPipelineLayout_)
-                    .setRenderPass(mainPass)
-                    .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-                    .build(device, vkCtx_->getPipelineCache());
-            };
-
-            ribbonPipeline_         = buildRibbonPipeline(PipelineBuilder::blendAlpha());
-            ribbonAdditivePipeline_ = buildRibbonPipeline(PipelineBuilder::blendAdditive());
-        }
-        ribVert.destroy(); ribFrag.destroy();
+            .build(device);
     }
 
     m2Vert.destroy(); m2Frag.destroy();
diff --git a/src/rendering/mesh.cpp b/src/rendering/mesh.cpp
new file mode 100644
index 00000000..59d40893
--- /dev/null
+++ b/src/rendering/mesh.cpp
@@ -0,0 +1,56 @@
+#include "rendering/mesh.hpp"
+
+namespace wowee {
+namespace rendering {
+
+Mesh::~Mesh() {
+    destroy();
+}
+
+void Mesh::create(const std::vector<Vertex>& vertices, const std::vector<uint32_t>& indices) {
+    indexCount = indices.size();
+
+    glGenVertexArrays(1, &VAO);
+    glGenBuffers(1, &VBO);
+    glGenBuffers(1, &EBO);
+
+    glBindVertexArray(VAO);
+
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), vertices.data(), GL_STATIC_DRAW);
+
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(uint32_t), indices.data(), GL_STATIC_DRAW);
+
+    // Position
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, position));
+
+    // Normal
+    glEnableVertexAttribArray(1);
+    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, normal));
+
+    // TexCoord
+    glEnableVertexAttribArray(2);
+    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, texCoord));
+
+    glBindVertexArray(0);
+}
+
+void Mesh::destroy() {
+    if (VAO) glDeleteVertexArrays(1, &VAO);
+    if (VBO) glDeleteBuffers(1, &VBO);
+    if (EBO) glDeleteBuffers(1, &EBO);
+    VAO = VBO = EBO = 0;
+}
+
+void Mesh::draw() const {
+    if (VAO && indexCount > 0) {
+        glBindVertexArray(VAO);
+        glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, 0);
+        glBindVertexArray(0);
+    }
+}
+
+} // namespace rendering
+} // namespace wowee
diff --git a/src/rendering/minimap.cpp b/src/rendering/minimap.cpp
index 6e9fbb05..0f44869b 100644
--- a/src/rendering/minimap.cpp
+++ b/src/rendering/minimap.cpp
@@ -11,7 +11,6 @@
 #include "core/coordinates.hpp"
 #include "core/logger.hpp"
 #include <glm/gtc/matrix_transform.hpp>
-#include <array>
 #include <sstream>
 #include <cmath>
 
@@ -166,7 +165,7 @@ bool Minimap::initialize(VkContext* ctx, VkDescriptorSetLayout /*perFrameLayout*
             .setLayout(tilePipelineLayout)
             .setRenderPass(compositeTarget->getRenderPass())
             .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-            .build(device, vkCtx->getPipelineCache());
+            .build(device);
 
         vs.destroy();
         fs.destroy();
@@ -193,7 +192,7 @@ bool Minimap::initialize(VkContext* ctx, VkDescriptorSetLayout /*perFrameLayout*
             .setLayout(displayPipelineLayout)
             .setRenderPass(vkCtx->getImGuiRenderPass())
             .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-            .build(device, vkCtx->getPipelineCache());
+            .build(device);
 
         vs.destroy();
         fs.destroy();
@@ -229,7 +228,6 @@ void Minimap::shutdown() {
         if (tex) tex->destroy(device, alloc);
     }
     tileTextureCache.clear();
-    tileInsertionOrder.clear();
 
     if (noDataTexture) { noDataTexture->destroy(device, alloc); noDataTexture.reset(); }
     if (compositeTarget) { compositeTarget->destroy(device, alloc); compositeTarget.reset(); }
@@ -271,7 +269,7 @@ void Minimap::recreatePipelines() {
         .setLayout(displayPipelineLayout)
         .setRenderPass(vkCtx->getImGuiRenderPass())
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     vs.destroy();
     fs.destroy();
@@ -364,15 +362,6 @@ VkTexture* Minimap::getOrLoadTileTexture(int tileX, int tileY) {
 
     VkTexture* ptr = tex.get();
     tileTextureCache[hash] = std::move(tex);
-    tileInsertionOrder.push_back(hash);
-
-    // Evict oldest tiles when cache grows too large to bound GPU memory usage.
-    while (tileInsertionOrder.size() > MAX_TILE_CACHE) {
-        const std::string& oldest = tileInsertionOrder.front();
-        tileTextureCache.erase(oldest);
-        tileInsertionOrder.pop_front();
-    }
-
     return ptr;
 }
 
@@ -381,10 +370,7 @@ VkTexture* Minimap::getOrLoadTileTexture(int tileX, int tileY) {
 // --------------------------------------------------------
 
 void Minimap::updateTileDescriptors(uint32_t frameIdx, int centerTileX, int centerTileY) {
-    constexpr int kTileCount = 9; // 3x3 grid
     VkDevice device = vkCtx->getDevice();
-    std::array<VkDescriptorImageInfo, kTileCount> imgInfos{};
-    std::array<VkWriteDescriptorSet, kTileCount> writes{};
     int slot = 0;
 
     for (int dr = -1; dr <= 1; dr++) {
@@ -396,20 +382,20 @@ void Minimap::updateTileDescriptors(uint32_t frameIdx, int centerTileX, int cent
             if (!tileTex || !tileTex->isValid())
                 tileTex = noDataTexture.get();
 
-            imgInfos[slot] = tileTex->descriptorInfo();
+            VkDescriptorImageInfo imgInfo = tileTex->descriptorInfo();
 
-            writes[slot] = {};
-            writes[slot].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-            writes[slot].dstSet = tileDescSets[frameIdx][slot];
-            writes[slot].dstBinding = 0;
-            writes[slot].descriptorCount = 1;
-            writes[slot].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-            writes[slot].pImageInfo = &imgInfos[slot];
+            VkWriteDescriptorSet write{};
+            write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+            write.dstSet = tileDescSets[frameIdx][slot];
+            write.dstBinding = 0;
+            write.descriptorCount = 1;
+            write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+            write.pImageInfo = &imgInfo;
+
+            vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
             slot++;
         }
     }
-
-    vkUpdateDescriptorSets(device, kTileCount, writes.data(), 0, nullptr);
 }
 
 // --------------------------------------------------------
@@ -425,11 +411,10 @@ void Minimap::compositePass(VkCommandBuffer cmd, const glm::vec3& centerWorldPos
     const auto now = std::chrono::steady_clock::now();
     bool needsRefresh = !hasCachedFrame;
     if (!needsRefresh) {
-        float mdx = centerWorldPos.x - lastUpdatePos.x;
-        float mdy = centerWorldPos.y - lastUpdatePos.y;
-        float movedSq = mdx * mdx + mdy * mdy;
+        float moved = glm::length(glm::vec2(centerWorldPos.x - lastUpdatePos.x,
+                                             centerWorldPos.y - lastUpdatePos.y));
         float elapsed = std::chrono::duration<float>(now - lastUpdateTime).count();
-        needsRefresh = (movedSq >= updateDistance * updateDistance) || (elapsed >= updateIntervalSec);
+        needsRefresh = (moved >= updateDistance) || (elapsed >= updateIntervalSec);
     }
 
     // Also refresh if player crossed a tile boundary
@@ -528,15 +513,14 @@ void Minimap::render(VkCommandBuffer cmd, const Camera& playerCamera,
 
     float arrowRotation = 0.0f;
     if (!rotateWithCamera) {
+        // Prefer authoritative orientation if provided. This value is expected
+        // to already match minimap shader rotation convention.
         if (hasPlayerOrientation) {
             arrowRotation = playerOrientation;
         } else {
             glm::vec3 fwd = playerCamera.getForward();
-            arrowRotation = -std::atan2(-fwd.x, fwd.y);
+            arrowRotation = std::atan2(-fwd.x, fwd.y);
         }
-    } else if (hasPlayerOrientation) {
-        // Show character facing relative to the rotated map
-        arrowRotation = playerOrientation + rotation;
     }
 
     MinimapDisplayPush push{};
diff --git a/src/rendering/mount_dust.cpp b/src/rendering/mount_dust.cpp
index 7292bcb5..5678f31c 100644
--- a/src/rendering/mount_dust.cpp
+++ b/src/rendering/mount_dust.cpp
@@ -92,7 +92,7 @@ bool MountDust::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout)
         .setLayout(pipelineLayout)
         .setRenderPass(vkCtx->getImGuiRenderPass())
         .setDynamicStates(dynamicStates)
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     vertModule.destroy();
     fragModule.destroy();
@@ -157,12 +157,9 @@ void MountDust::recreatePipelines() {
     }
 
     VkShaderModule vertModule;
+    vertModule.loadFromFile(device, "assets/shaders/mount_dust.vert.spv");
     VkShaderModule fragModule;
-    if (!vertModule.loadFromFile(device, "assets/shaders/mount_dust.vert.spv") ||
-        !fragModule.loadFromFile(device, "assets/shaders/mount_dust.frag.spv")) {
-        LOG_ERROR("MountDust::recreatePipelines: failed to load shader modules");
-        return;
-    }
+    fragModule.loadFromFile(device, "assets/shaders/mount_dust.frag.spv");
 
     VkPipelineShaderStageCreateInfo vertStage = vertModule.stageInfo(VK_SHADER_STAGE_VERTEX_BIT);
     VkPipelineShaderStageCreateInfo fragStage = fragModule.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT);
@@ -202,7 +199,7 @@ void MountDust::recreatePipelines() {
         .setLayout(pipelineLayout)
         .setRenderPass(vkCtx->getImGuiRenderPass())
         .setDynamicStates(dynamicStates)
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     vertModule.destroy();
     fragModule.destroy();
diff --git a/src/rendering/performance_hud.cpp b/src/rendering/performance_hud.cpp
index 7fd5ff4b..09430dce 100644
--- a/src/rendering/performance_hud.cpp
+++ b/src/rendering/performance_hud.cpp
@@ -10,12 +10,10 @@
 #include "rendering/clouds.hpp"
 #include "rendering/lens_flare.hpp"
 #include "rendering/weather.hpp"
-#include "rendering/lightning.hpp"
 #include "rendering/character_renderer.hpp"
 #include "rendering/wmo_renderer.hpp"
 #include "rendering/m2_renderer.hpp"
 #include "rendering/camera.hpp"
-#include "ui/ui_colors.hpp"
 #include <imgui.h>
 #include <algorithm>
 #include <sstream>
@@ -24,13 +22,6 @@
 namespace wowee {
 namespace rendering {
 
-namespace {
-    using namespace wowee::ui;
-    constexpr ImVec4 kSectionHeader = {0.8f, 0.8f, 0.5f, 1.0f};
-    const auto& kHelpText = colors::kGray;
-    const auto& kTitle    = colors::kLightGray;
-} // namespace
-
 PerformanceHUD::PerformanceHUD() {
 }
 
@@ -199,7 +190,7 @@ void PerformanceHUD::render(const Renderer* renderer, const Camera* camera) {
 
         // FSR info
         if (renderer->isFSREnabled()) {
-            ImGui::TextColored(colors::kGreen, "FSR 1.0: ON");
+            ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, 1.0f), "FSR 1.0: ON");
             auto* ctx = renderer->getVkContext();
             if (ctx) {
                 auto ext = ctx->getSwapchainExtent();
@@ -228,13 +219,6 @@ void PerformanceHUD::render(const Renderer* renderer, const Camera* camera) {
             ImGui::Text("  Upscale Dispatches: %zu", renderer->getAmdFsr3UpscaleDispatchCount());
             ImGui::Text("  FG Fallbacks: %zu", renderer->getAmdFsr3FallbackCount());
         }
-        if (renderer->isFXAAEnabled()) {
-            if (renderer->isFSR2Enabled()) {
-                ImGui::TextColored(ImVec4(0.6f, 1.0f, 0.8f, 1.0f), "FXAA: ON (FSR3+FXAA combined)");
-            } else {
-                ImGui::TextColored(ImVec4(0.8f, 1.0f, 0.6f, 1.0f), "FXAA: ON");
-            }
-        }
 
         ImGui::Spacing();
     }
@@ -378,11 +362,6 @@ void PerformanceHUD::render(const Renderer* renderer, const Camera* camera) {
                 ImGui::Text("Intensity: %.0f%%", weather->getIntensity() * 100.0f);
             }
 
-            auto* lightning = renderer->getLightning();
-            if (lightning && lightning->isEnabled()) {
-                ImGui::Text("Lightning: active (%.0f%%)", lightning->getIntensity() * 100.0f);
-            }
-
             ImGui::Spacing();
         }
     }
@@ -464,39 +443,39 @@ void PerformanceHUD::render(const Renderer* renderer, const Camera* camera) {
 
     // Controls help
     if (showControls) {
-        ImGui::TextColored(kTitle, "CONTROLS");
+        ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f), "CONTROLS");
         ImGui::Separator();
 
-        ImGui::TextColored(kSectionHeader, "Movement");
-        ImGui::TextColored(kHelpText, "WASD: Move/Strafe");
-        ImGui::TextColored(kHelpText, "Q/E: Strafe left/right");
-        ImGui::TextColored(kHelpText, "Space: Jump");
-        ImGui::TextColored(kHelpText, "X: Sit/Stand");
-        ImGui::TextColored(kHelpText, "~: Auto-run");
-        ImGui::TextColored(kHelpText, "Z: Sheathe weapons");
+        ImGui::TextColored(ImVec4(0.8f, 0.8f, 0.5f, 1.0f), "Movement");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "WASD: Move/Strafe");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Q/E: Turn left/right");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Space: Jump");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "X: Sit/Stand");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "~: Auto-run");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Z: Sheathe weapons");
 
         ImGui::Spacing();
-        ImGui::TextColored(kSectionHeader, "UI Panels");
-        ImGui::TextColored(kHelpText, "B: Bags/Inventory");
-        ImGui::TextColored(kHelpText, "C: Character sheet");
-        ImGui::TextColored(kHelpText, "L: Quest log");
-        ImGui::TextColored(kHelpText, "N: Talents");
-        ImGui::TextColored(kHelpText, "P: Spellbook");
-        ImGui::TextColored(kHelpText, "M: World map");
+        ImGui::TextColored(ImVec4(0.8f, 0.8f, 0.5f, 1.0f), "UI Panels");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "B: Bags/Inventory");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "C: Character sheet");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "L: Quest log");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "N: Talents");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "P: Spellbook");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "M: World map");
 
         ImGui::Spacing();
-        ImGui::TextColored(kSectionHeader, "Combat & Chat");
-        ImGui::TextColored(kHelpText, "1-0,-,=: Action bar");
-        ImGui::TextColored(kHelpText, "Tab: Target cycle");
-        ImGui::TextColored(kHelpText, "Enter: Chat");
-        ImGui::TextColored(kHelpText, "/: Chat command");
+        ImGui::TextColored(ImVec4(0.8f, 0.8f, 0.5f, 1.0f), "Combat & Chat");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "1-0,-,=: Action bar");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Tab: Target cycle");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Enter: Chat");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "/: Chat command");
 
         ImGui::Spacing();
-        ImGui::TextColored(kSectionHeader, "Debug");
-        ImGui::TextColored(kHelpText, "F1: Toggle this HUD");
-        ImGui::TextColored(kHelpText, "F4: Toggle shadows");
-        ImGui::TextColored(kHelpText, "F7: Level-up FX");
-        ImGui::TextColored(kHelpText, "Esc: Settings/Close");
+        ImGui::TextColored(ImVec4(0.8f, 0.8f, 0.5f, 1.0f), "Debug");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F1: Toggle this HUD");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F4: Toggle shadows");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F7: Level-up FX");
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Esc: Settings/Close");
     }
 
     ImGui::End();
diff --git a/src/rendering/post_process_pipeline.cpp b/src/rendering/post_process_pipeline.cpp
deleted file mode 100644
index a8213a7c..00000000
--- a/src/rendering/post_process_pipeline.cpp
+++ /dev/null
@@ -1,1891 +0,0 @@
-// PostProcessPipeline — FSR 1.0, FXAA, FSR 2.2/3 state and passes (§4.3)
-// Extracted from Renderer to isolate post-processing concerns.
-
-#include "rendering/post_process_pipeline.hpp"
-#include "rendering/vk_context.hpp"
-#include "rendering/vk_shader.hpp"
-#include "rendering/vk_pipeline.hpp"
-#include "rendering/camera.hpp"
-#include "rendering/amd_fsr3_runtime.hpp"
-#include "core/logger.hpp"
-#include "core/profiler.hpp"
-#include <cstdlib>
-#include <algorithm>
-#include <glm/gtc/matrix_inverse.hpp>
-
-namespace wowee {
-namespace rendering {
-
-PostProcessPipeline::PostProcessPipeline() = default;
-PostProcessPipeline::~PostProcessPipeline() { shutdown(); }
-
-void PostProcessPipeline::initialize(VkContext* ctx) {
-    vkCtx_ = ctx;
-}
-
-void PostProcessPipeline::shutdown() {
-    destroyFSRResources();
-    destroyFSR2Resources();
-    destroyFXAAResources();
-    vkCtx_ = nullptr;
-}
-
-// ========================= Frame-loop integration =========================
-
-void PostProcessPipeline::manageResources() {
-    // FSR resource management (safe: between frames, no command buffer in flight)
-    if (fsr_.needsRecreate && fsr_.sceneFramebuffer) {
-        destroyFSRResources();
-        fsr_.needsRecreate = false;
-        if (!fsr_.enabled) LOG_INFO("FSR: disabled");
-    }
-    if (fsr_.enabled && !fsr2_.enabled && !fsr_.sceneFramebuffer) {
-        if (!initFSRResources()) {
-            LOG_ERROR("FSR: initialization failed, disabling");
-            fsr_.enabled = false;
-        }
-    }
-
-    // FSR 2.2 resource management
-    if (fsr2_.needsRecreate && fsr2_.sceneFramebuffer) {
-        destroyFSR2Resources();
-        fsr2_.needsRecreate = false;
-        if (!fsr2_.enabled) LOG_INFO("FSR2: disabled");
-    }
-    if (fsr2_.enabled && !fsr2_.sceneFramebuffer) {
-        if (!initFSR2Resources()) {
-            LOG_ERROR("FSR2: initialization failed, disabling");
-            fsr2_.enabled = false;
-        }
-    }
-
-    // FXAA resource management — FXAA can coexist with FSR1 and FSR3.
-    // When both FXAA and FSR3 are enabled, FXAA runs as a post-FSR3 pass.
-    // Do not force this pass for ghost mode; keep AA quality strictly user-controlled.
-    const bool useFXAA = fxaa_.enabled;
-    if ((fxaa_.needsRecreate || !useFXAA) && fxaa_.sceneFramebuffer) {
-        destroyFXAAResources();
-        fxaa_.needsRecreate = false;
-        if (!useFXAA) LOG_INFO("FXAA: disabled");
-    }
-    if (useFXAA && !fxaa_.sceneFramebuffer) {
-        if (!initFXAAResources()) {
-            LOG_ERROR("FXAA: initialization failed, disabling");
-            fxaa_.enabled = false;
-        }
-    }
-}
-
-void PostProcessPipeline::handleSwapchainResize() {
-    const bool useFXAA = fxaa_.enabled;
-    // Recreate FSR resources for new swapchain dimensions
-    if (fsr_.enabled && !fsr2_.enabled) {
-        destroyFSRResources();
-        initFSRResources();
-    }
-    if (fsr2_.enabled) {
-        destroyFSR2Resources();
-        initFSR2Resources();
-    }
-    // Recreate FXAA resources for new swapchain dimensions.
-    if (useFXAA) {
-        destroyFXAAResources();
-        initFXAAResources();
-    }
-}
-
-void PostProcessPipeline::applyJitter(Camera* camera) {
-    if (!fsr2_.enabled || !fsr2_.sceneFramebuffer || !camera) return;
-
-    if (!fsr2_.useAmdBackend) {
-        camera->setJitter(0.0f, 0.0f);
-    } else {
-#if WOWEE_HAS_AMD_FSR2
-        // AMD-recommended jitter sequence in pixel space, converted to NDC projection offset.
-        int32_t phaseCount = ffxFsr2GetJitterPhaseCount(
-            static_cast<int32_t>(fsr2_.internalWidth),
-            static_cast<int32_t>(vkCtx_->getSwapchainExtent().width));
-        float jitterX = 0.0f;
-        float jitterY = 0.0f;
-        if (phaseCount > 0 &&
-            ffxFsr2GetJitterOffset(&jitterX, &jitterY, static_cast<int32_t>(fsr2_.frameIndex % static_cast<uint32_t>(phaseCount)), phaseCount) == FFX_OK) {
-            float ndcJx = (2.0f * jitterX) / static_cast<float>(fsr2_.internalWidth);
-            float ndcJy = (2.0f * jitterY) / static_cast<float>(fsr2_.internalHeight);
-            // Keep projection jitter and FSR dispatch jitter in sync.
-            camera->setJitter(fsr2_.jitterSign * ndcJx, fsr2_.jitterSign * ndcJy);
-        } else {
-            camera->setJitter(0.0f, 0.0f);
-        }
-#else
-        const float jitterScale = 0.5f;
-        float jx = (halton(fsr2_.frameIndex + 1, 2) - 0.5f) * 2.0f * jitterScale / static_cast<float>(fsr2_.internalWidth);
-        float jy = (halton(fsr2_.frameIndex + 1, 3) - 0.5f) * 2.0f * jitterScale / static_cast<float>(fsr2_.internalHeight);
-        camera->setJitter(fsr2_.jitterSign * jx, fsr2_.jitterSign * jy);
-#endif
-    }
-}
-
-VkFramebuffer PostProcessPipeline::getSceneFramebuffer() const {
-    if (fsr2_.enabled && fsr2_.sceneFramebuffer)
-        return fsr2_.sceneFramebuffer;
-    if (fxaa_.enabled && fxaa_.sceneFramebuffer)
-        return fxaa_.sceneFramebuffer;
-    if (fsr_.enabled && fsr_.sceneFramebuffer)
-        return fsr_.sceneFramebuffer;
-    return VK_NULL_HANDLE;
-}
-
-VkExtent2D PostProcessPipeline::getSceneRenderExtent() const {
-    if (fsr2_.enabled && fsr2_.sceneFramebuffer)
-        return { fsr2_.internalWidth, fsr2_.internalHeight };
-    if (fxaa_.enabled && fxaa_.sceneFramebuffer)
-        return vkCtx_->getSwapchainExtent();  // native resolution — no downscaling
-    if (fsr_.enabled && fsr_.sceneFramebuffer)
-        return { fsr_.internalWidth, fsr_.internalHeight };
-    return vkCtx_->getSwapchainExtent();
-}
-
-bool PostProcessPipeline::hasActivePostProcess() const {
-    return (fsr2_.enabled && fsr2_.sceneFramebuffer)
-        || (fxaa_.enabled && fxaa_.sceneFramebuffer)
-        || (fsr_.enabled && fsr_.sceneFramebuffer);
-}
-
-bool PostProcessPipeline::executePostProcessing(VkCommandBuffer cmd, uint32_t imageIndex,
-                                                  Camera* camera, float deltaTime) {
-    ZoneScopedN("PostProcess::execute");
-    currentCmd_ = cmd;
-    camera_ = camera;
-    lastDeltaTime_ = deltaTime;
-    bool inlineMode = false;
-
-    if (fsr2_.enabled && fsr2_.sceneFramebuffer) {
-        // End the off-screen scene render pass
-        vkCmdEndRenderPass(currentCmd_);
-
-        if (fsr2_.useAmdBackend) {
-            // Compute passes: motion vectors -> temporal accumulation
-            dispatchMotionVectors();
-            if (fsr2_.amdFsr3FramegenEnabled && fsr2_.amdFsr3FramegenRuntimeReady) {
-                dispatchAmdFsr3Framegen();
-                if (!fsr2_.amdFsr3FramegenRuntimeActive) {
-                    dispatchAmdFsr2();
-                }
-            } else {
-                dispatchAmdFsr2();
-            }
-
-            // Transition post-FSR input for sharpen pass.
-            if (fsr2_.amdFsr3FramegenRuntimeActive && fsr2_.framegenOutput.image) {
-                transitionImageLayout(currentCmd_, fsr2_.framegenOutput.image,
-                    VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-                    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
-                fsr2_.framegenOutputValid = true;
-            } else {
-                transitionImageLayout(currentCmd_, fsr2_.history[fsr2_.currentHistory].image,
-                    VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-                    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
-            }
-        } else {
-            transitionImageLayout(currentCmd_, fsr2_.sceneColor.image,
-                VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-                VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-                VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
-        }
-
-        // FSR3+FXAA combined: re-point FXAA's descriptor to the FSR3 temporal output
-        // so renderFXAAPass() applies spatial AA on the temporally-stabilized frame.
-        // This must happen outside the render pass (descriptor updates are CPU-side).
-        // Use per-frame descriptor set to avoid race with in-flight command buffers.
-        uint32_t fxaaFrameIdx = vkCtx_->getCurrentFrame();
-        if (fxaa_.enabled && fxaa_.descSet[fxaaFrameIdx] && fxaa_.sceneSampler) {
-            VkImageView fsr3OutputView = VK_NULL_HANDLE;
-            if (fsr2_.useAmdBackend) {
-                if (fsr2_.amdFsr3FramegenRuntimeActive && fsr2_.framegenOutput.image)
-                    fsr3OutputView = fsr2_.framegenOutput.imageView;
-                else if (fsr2_.history[fsr2_.currentHistory].image)
-                    fsr3OutputView = fsr2_.history[fsr2_.currentHistory].imageView;
-            } else if (fsr2_.history[fsr2_.currentHistory].image) {
-                fsr3OutputView = fsr2_.history[fsr2_.currentHistory].imageView;
-            }
-            if (fsr3OutputView) {
-                VkDescriptorImageInfo imgInfo{};
-                imgInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-                imgInfo.imageView   = fsr3OutputView;
-                imgInfo.sampler     = fxaa_.sceneSampler;
-                VkWriteDescriptorSet write{};
-                write.sType            = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-                write.dstSet           = fxaa_.descSet[fxaaFrameIdx];
-                write.dstBinding       = 0;
-                write.descriptorCount  = 1;
-                write.descriptorType   = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-                write.pImageInfo       = &imgInfo;
-                vkUpdateDescriptorSets(vkCtx_->getDevice(), 1, &write, 0, nullptr);
-            }
-        }
-
-        // Begin swapchain render pass at full resolution for sharpening + ImGui
-        VkRenderPassBeginInfo rpInfo{};
-        rpInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
-        rpInfo.renderPass = vkCtx_->getImGuiRenderPass();
-        rpInfo.framebuffer = vkCtx_->getSwapchainFramebuffers()[imageIndex];
-        rpInfo.renderArea.offset = {0, 0};
-        rpInfo.renderArea.extent = vkCtx_->getSwapchainExtent();
-
-        bool msaaOn = (vkCtx_->getMsaaSamples() > VK_SAMPLE_COUNT_1_BIT);
-        VkClearValue clearValues[4]{};
-        clearValues[0].color = {{0.0f, 0.0f, 0.0f, 1.0f}};
-        clearValues[1].depthStencil = {1.0f, 0};
-        clearValues[2].color = {{0.0f, 0.0f, 0.0f, 1.0f}};
-        clearValues[3].depthStencil = {1.0f, 0};
-        rpInfo.clearValueCount = msaaOn ? (vkCtx_->getDepthResolveImageView() ? 4u : 3u) : 2u;
-        rpInfo.pClearValues = clearValues;
-
-        inlineMode = true; vkCmdBeginRenderPass(currentCmd_, &rpInfo, VK_SUBPASS_CONTENTS_INLINE);
-
-        VkExtent2D ext = vkCtx_->getSwapchainExtent();
-        VkViewport vp{};
-        vp.width = static_cast<float>(ext.width);
-        vp.height = static_cast<float>(ext.height);
-        vp.maxDepth = 1.0f;
-        vkCmdSetViewport(currentCmd_, 0, 1, &vp);
-        VkRect2D sc{};
-        sc.extent = ext;
-        vkCmdSetScissor(currentCmd_, 0, 1, &sc);
-
-        // When FXAA is also enabled: apply FXAA on the FSR3 temporal output instead
-        // of RCAS sharpening. FXAA descriptor is temporarily pointed to the FSR3
-        // history buffer (which is already in SHADER_READ_ONLY_OPTIMAL). This gives
-        // FSR3 temporal stability + FXAA spatial edge smoothing ("ultra quality native").
-        if (fxaa_.enabled && fxaa_.pipeline && fxaa_.descSet[fxaaFrameIdx]) {
-            renderFXAAPass();
-        } else {
-            // Draw RCAS sharpening from accumulated history buffer
-            renderFSR2Sharpen();
-        }
-
-        // Restore this frame's FXAA descriptor to its normal scene color source
-        // so standalone FXAA frames are not affected by the FSR3 history pointer.
-        if (fxaa_.enabled && fxaa_.descSet[fxaaFrameIdx] && fxaa_.sceneSampler && fxaa_.sceneColor.imageView) {
-            VkDescriptorImageInfo restoreInfo{};
-            restoreInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-            restoreInfo.imageView   = fxaa_.sceneColor.imageView;
-            restoreInfo.sampler     = fxaa_.sceneSampler;
-            VkWriteDescriptorSet restoreWrite{};
-            restoreWrite.sType           = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-            restoreWrite.dstSet          = fxaa_.descSet[fxaaFrameIdx];
-            restoreWrite.dstBinding      = 0;
-            restoreWrite.descriptorCount = 1;
-            restoreWrite.descriptorType  = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-            restoreWrite.pImageInfo      = &restoreInfo;
-            vkUpdateDescriptorSets(vkCtx_->getDevice(), 1, &restoreWrite, 0, nullptr);
-        }
-
-        // Maintain frame bookkeeping
-        fsr2_.prevViewProjection = camera_->getViewProjectionMatrix();
-        fsr2_.prevJitter = camera_->getJitter();
-        camera_->clearJitter();
-        if (fsr2_.useAmdBackend) {
-            fsr2_.currentHistory = 1 - fsr2_.currentHistory;
-        }
-        fsr2_.frameIndex = (fsr2_.frameIndex + 1) % 256;  // Wrap to keep Halton values well-distributed
-
-    } else if (fxaa_.enabled && fxaa_.sceneFramebuffer) {
-        inlineMode = true;
-        // End the off-screen scene render pass
-        vkCmdEndRenderPass(currentCmd_);
-
-        // Transition resolved scene color: PRESENT_SRC_KHR → SHADER_READ_ONLY
-        transitionImageLayout(currentCmd_, fxaa_.sceneColor.image,
-            VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-            VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-            VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
-
-        // Begin swapchain render pass (1x — no MSAA on the output pass)
-        VkRenderPassBeginInfo rpInfo{};
-        rpInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
-        rpInfo.renderPass = vkCtx_->getImGuiRenderPass();
-        rpInfo.framebuffer = vkCtx_->getSwapchainFramebuffers()[imageIndex];
-        rpInfo.renderArea.offset = {0, 0};
-        rpInfo.renderArea.extent = vkCtx_->getSwapchainExtent();
-        // The swapchain render pass always has 2 attachments when MSAA is off;
-        // FXAA output goes to the non-MSAA swapchain directly.
-        VkClearValue fxaaClear[2]{};
-        fxaaClear[0].color = {{0.0f, 0.0f, 0.0f, 1.0f}};
-        fxaaClear[1].depthStencil = {1.0f, 0};
-        rpInfo.clearValueCount = 2;
-        rpInfo.pClearValues = fxaaClear;
-
-        vkCmdBeginRenderPass(currentCmd_, &rpInfo, VK_SUBPASS_CONTENTS_INLINE);
-
-        VkExtent2D ext = vkCtx_->getSwapchainExtent();
-        VkViewport vp{};
-        vp.width = static_cast<float>(ext.width);
-        vp.height = static_cast<float>(ext.height);
-        vp.maxDepth = 1.0f;
-        vkCmdSetViewport(currentCmd_, 0, 1, &vp);
-        VkRect2D sc{};
-        sc.extent = ext;
-        vkCmdSetScissor(currentCmd_, 0, 1, &sc);
-
-        // Draw FXAA pass
-        renderFXAAPass();
-
-    } else if (fsr_.enabled && fsr_.sceneFramebuffer) {
-        inlineMode = true;
-        // FSR1 upscale path — only runs when FXAA is not active.
-        // When both FSR1 and FXAA are enabled, FXAA took priority above.
-        vkCmdEndRenderPass(currentCmd_);
-
-        // Transition scene color (1x resolve/color target): PRESENT_SRC_KHR → SHADER_READ_ONLY
-        transitionImageLayout(currentCmd_, fsr_.sceneColor.image,
-            VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-            VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-            VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
-
-        // Begin swapchain render pass at full resolution
-        VkRenderPassBeginInfo fsrRpInfo{};
-        fsrRpInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
-        fsrRpInfo.renderPass = vkCtx_->getImGuiRenderPass();
-        fsrRpInfo.framebuffer = vkCtx_->getSwapchainFramebuffers()[imageIndex];
-        fsrRpInfo.renderArea.offset = {0, 0};
-        fsrRpInfo.renderArea.extent = vkCtx_->getSwapchainExtent();
-
-        bool fsrMsaaOn = (vkCtx_->getMsaaSamples() > VK_SAMPLE_COUNT_1_BIT);
-        VkClearValue fsrClearValues[4]{};
-        fsrClearValues[0].color = {{0.0f, 0.0f, 0.0f, 1.0f}};
-        fsrClearValues[1].depthStencil = {1.0f, 0};
-        fsrClearValues[2].color = {{0.0f, 0.0f, 0.0f, 1.0f}};
-        fsrClearValues[3].depthStencil = {1.0f, 0};
-        if (fsrMsaaOn) {
-            bool depthRes = (vkCtx_->getDepthResolveImageView() != VK_NULL_HANDLE);
-            fsrRpInfo.clearValueCount = depthRes ? 4 : 3;
-        } else {
-            fsrRpInfo.clearValueCount = 2;
-        }
-        fsrRpInfo.pClearValues = fsrClearValues;
-
-        vkCmdBeginRenderPass(currentCmd_, &fsrRpInfo, VK_SUBPASS_CONTENTS_INLINE);
-
-        VkExtent2D fsrExt = vkCtx_->getSwapchainExtent();
-        VkViewport fsrVp{};
-        fsrVp.width = static_cast<float>(fsrExt.width);
-        fsrVp.height = static_cast<float>(fsrExt.height);
-        fsrVp.maxDepth = 1.0f;
-        vkCmdSetViewport(currentCmd_, 0, 1, &fsrVp);
-        VkRect2D fsrSc{};
-        fsrSc.extent = fsrExt;
-        vkCmdSetScissor(currentCmd_, 0, 1, &fsrSc);
-
-        renderFSRUpscale();
-    }
-
-    currentCmd_ = VK_NULL_HANDLE;
-    camera_ = nullptr;
-    return inlineMode;
-}
-
-void PostProcessPipeline::destroyAllResources() {
-    if (fsr_.sceneFramebuffer) destroyFSRResources();
-    if (fsr2_.sceneFramebuffer) destroyFSR2Resources();
-    if (fxaa_.sceneFramebuffer) destroyFXAAResources();
-}
-
-// ========================= Public API =========================
-
-void PostProcessPipeline::setFXAAEnabled(bool enabled) {
-    if (fxaa_.enabled == enabled) return;
-    // FXAA is a post-process AA pass intended to supplement FSR temporal output.
-    // It conflicts with MSAA (which resolves AA during the scene render pass), so
-    // refuse to enable FXAA when hardware MSAA is active.
-    if (enabled && vkCtx_ && vkCtx_->getMsaaSamples() > VK_SAMPLE_COUNT_1_BIT) {
-        LOG_INFO("FXAA: blocked while MSAA is active — disable MSAA first");
-        return;
-    }
-    fxaa_.enabled = enabled;
-    if (!enabled) {
-        fxaa_.needsRecreate = true;  // defer destruction to next beginFrame()
-    }
-}
-
-MsaaChangeRequest PostProcessPipeline::setFSREnabled(bool enabled) {
-    MsaaChangeRequest req;
-    if (fsr_.enabled == enabled) return req;
-    fsr_.enabled = enabled;
-
-    if (enabled) {
-        // FSR1 upscaling renders its own AA — disable MSAA to avoid redundant work
-        if (vkCtx_ && vkCtx_->getMsaaSamples() > VK_SAMPLE_COUNT_1_BIT) {
-            req.requested = true;
-            req.samples = VK_SAMPLE_COUNT_1_BIT;
-        }
-    } else {
-        // Defer destruction to next beginFrame() — can't destroy mid-render
-        fsr_.needsRecreate = true;
-    }
-    // Resources created/destroyed lazily in beginFrame()
-    return req;
-}
-
-void PostProcessPipeline::setFSRQuality(float scaleFactor) {
-    scaleFactor = glm::clamp(scaleFactor, 0.5f, 1.0f);
-    fsr_.scaleFactor = scaleFactor;
-    fsr2_.scaleFactor = scaleFactor;
-    // Don't destroy/recreate mid-frame — mark for lazy recreation in next beginFrame()
-    if (fsr_.enabled && fsr_.sceneFramebuffer) {
-        fsr_.needsRecreate = true;
-    }
-    if (fsr2_.enabled && fsr2_.sceneFramebuffer) {
-        fsr2_.needsRecreate = true;
-        fsr2_.needsHistoryReset = true;
-    }
-}
-
-void PostProcessPipeline::setFSRSharpness(float sharpness) {
-    fsr_.sharpness = glm::clamp(sharpness, 0.0f, 2.0f);
-    fsr2_.sharpness = glm::clamp(sharpness, 0.0f, 2.0f);
-}
-
-MsaaChangeRequest PostProcessPipeline::setFSR2Enabled(bool enabled, Camera* camera) {
-    MsaaChangeRequest req;
-    if (fsr2_.enabled == enabled) return req;
-    fsr2_.enabled = enabled;
-
-    if (enabled) {
-        static bool initFramegenToggleFromEnv = false;
-        if (!initFramegenToggleFromEnv) {
-            initFramegenToggleFromEnv = true;
-            if (std::getenv("WOWEE_ENABLE_AMD_FSR3_FRAMEGEN_RUNTIME") != nullptr) {
-                fsr2_.amdFsr3FramegenEnabled = true;
-            }
-        }
-        // FSR2 replaces both FSR1 and MSAA
-        if (fsr_.enabled) {
-            fsr_.enabled = false;
-            fsr_.needsRecreate = true;
-        }
-        // FSR2 requires non-MSAA render pass (its framebuffer has 2 attachments)
-        if (vkCtx_ && vkCtx_->getMsaaSamples() > VK_SAMPLE_COUNT_1_BIT) {
-            req.requested = true;
-            req.samples = VK_SAMPLE_COUNT_1_BIT;
-        }
-        // Use FSR1's scale factor and sharpness as defaults
-        fsr2_.scaleFactor = fsr_.scaleFactor;
-        fsr2_.sharpness = fsr_.sharpness;
-        fsr2_.needsHistoryReset = true;
-    } else {
-        fsr2_.needsRecreate = true;
-        if (camera) camera->clearJitter();
-    }
-    return req;
-}
-
-void PostProcessPipeline::setFSR2DebugTuning(float jitterSign, float motionVecScaleX, float motionVecScaleY) {
-    fsr2_.jitterSign = glm::clamp(jitterSign, -2.0f, 2.0f);
-    fsr2_.motionVecScaleX = glm::clamp(motionVecScaleX, -2.0f, 2.0f);
-    fsr2_.motionVecScaleY = glm::clamp(motionVecScaleY, -2.0f, 2.0f);
-}
-
-void PostProcessPipeline::setAmdFsr3FramegenEnabled(bool enabled) {
-    if (fsr2_.amdFsr3FramegenEnabled == enabled) return;
-    fsr2_.amdFsr3FramegenEnabled = enabled;
-#if WOWEE_HAS_AMD_FSR3_FRAMEGEN
-    if (enabled) {
-        fsr2_.amdFsr3FramegenRuntimeActive = false;
-        fsr2_.framegenOutputValid = false;
-        fsr2_.needsRecreate = true;
-        fsr2_.needsHistoryReset = true;
-        fsr2_.amdFsr3FramegenRuntimeReady = false;
-        fsr2_.amdFsr3RuntimePath = "Path C";
-        fsr2_.amdFsr3RuntimeLastError.clear();
-        LOG_INFO("FSR3 framegen requested; runtime will initialize on next FSR2 resource creation.");
-    } else {
-        fsr2_.amdFsr3FramegenRuntimeActive = false;
-        fsr2_.amdFsr3FramegenRuntimeReady = false;
-        fsr2_.framegenOutputValid = false;
-        fsr2_.needsHistoryReset = true;
-        fsr2_.needsRecreate = true;
-        fsr2_.amdFsr3RuntimePath = "Path C";
-        fsr2_.amdFsr3RuntimeLastError = "disabled by user";
-        if (fsr2_.amdFsr3Runtime) {
-            fsr2_.amdFsr3Runtime->shutdown();
-            fsr2_.amdFsr3Runtime.reset();
-        }
-        LOG_INFO("FSR3 framegen disabled; forcing FSR2-only path rebuild.");
-    }
-#else
-    fsr2_.amdFsr3FramegenRuntimeActive = false;
-    fsr2_.amdFsr3FramegenRuntimeReady = false;
-    fsr2_.framegenOutputValid = false;
-    if (enabled) {
-        LOG_WARNING("FSR3 framegen requested, but AMD FSR3 framegen SDK headers are unavailable in this build.");
-    }
-#endif
-}
-
-const char* PostProcessPipeline::getAmdFsr3FramegenRuntimePath() const {
-    return fsr2_.amdFsr3RuntimePath.c_str();
-}
-
-// ========================= FSR 1.0 Upscaling =========================
-
-bool PostProcessPipeline::initFSRResources() {
-    if (!vkCtx_) return false;
-
-    VkDevice device = vkCtx_->getDevice();
-    VmaAllocator alloc = vkCtx_->getAllocator();
-    VkExtent2D swapExtent = vkCtx_->getSwapchainExtent();
-    VkSampleCountFlagBits msaa = vkCtx_->getMsaaSamples();
-    bool useMsaa = (msaa > VK_SAMPLE_COUNT_1_BIT);
-    bool useDepthResolve = (vkCtx_->getDepthResolveImageView() != VK_NULL_HANDLE);
-
-    fsr_.internalWidth = static_cast<uint32_t>(swapExtent.width * fsr_.scaleFactor);
-    fsr_.internalHeight = static_cast<uint32_t>(swapExtent.height * fsr_.scaleFactor);
-    fsr_.internalWidth = (fsr_.internalWidth + 1) & ~1u;
-    fsr_.internalHeight = (fsr_.internalHeight + 1) & ~1u;
-
-    LOG_INFO("FSR: initializing at ", fsr_.internalWidth, "x", fsr_.internalHeight,
-             " -> ", swapExtent.width, "x", swapExtent.height,
-             " (scale=", fsr_.scaleFactor, ", MSAA=", static_cast<int>(msaa), "x)");
-
-    VkFormat colorFmt = vkCtx_->getSwapchainFormat();
-    VkFormat depthFmt = vkCtx_->getDepthFormat();
-
-    // sceneColor: always 1x, always sampled — this is what FSR reads
-    // Non-MSAA: direct render target. MSAA: resolve target.
-    fsr_.sceneColor = createImage(device, alloc, fsr_.internalWidth, fsr_.internalHeight,
-        colorFmt, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
-    if (!fsr_.sceneColor.image) {
-        LOG_ERROR("FSR: failed to create scene color image");
-        return false;
-    }
-
-    // sceneDepth: matches current MSAA sample count
-    fsr_.sceneDepth = createImage(device, alloc, fsr_.internalWidth, fsr_.internalHeight,
-        depthFmt, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, msaa);
-    if (!fsr_.sceneDepth.image) {
-        LOG_ERROR("FSR: failed to create scene depth image");
-        destroyFSRResources();
-        return false;
-    }
-
-    if (useMsaa) {
-        // sceneMsaaColor: multisampled color target
-        fsr_.sceneMsaaColor = createImage(device, alloc, fsr_.internalWidth, fsr_.internalHeight,
-            colorFmt, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, msaa);
-        if (!fsr_.sceneMsaaColor.image) {
-            LOG_ERROR("FSR: failed to create MSAA color image");
-            destroyFSRResources();
-            return false;
-        }
-
-        if (useDepthResolve) {
-            fsr_.sceneDepthResolve = createImage(device, alloc, fsr_.internalWidth, fsr_.internalHeight,
-                depthFmt, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
-            if (!fsr_.sceneDepthResolve.image) {
-                LOG_ERROR("FSR: failed to create depth resolve image");
-                destroyFSRResources();
-                return false;
-            }
-        }
-    }
-
-    // Build framebuffer matching the main render pass attachment layout:
-    //   Non-MSAA:              [color, depth]
-    //   MSAA (no depth res):   [msaaColor, depth, resolve]
-    //   MSAA (depth res):      [msaaColor, depth, resolve, depthResolve]
-    VkImageView fbAttachments[4]{};
-    uint32_t fbCount;
-    if (useMsaa) {
-        fbAttachments[0] = fsr_.sceneMsaaColor.imageView;
-        fbAttachments[1] = fsr_.sceneDepth.imageView;
-        fbAttachments[2] = fsr_.sceneColor.imageView;  // resolve target
-        fbCount = 3;
-        if (useDepthResolve) {
-            fbAttachments[3] = fsr_.sceneDepthResolve.imageView;
-            fbCount = 4;
-        }
-    } else {
-        fbAttachments[0] = fsr_.sceneColor.imageView;
-        fbAttachments[1] = fsr_.sceneDepth.imageView;
-        fbCount = 2;
-    }
-
-    VkFramebufferCreateInfo fbInfo{};
-    fbInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
-    fbInfo.renderPass = vkCtx_->getImGuiRenderPass();
-    fbInfo.attachmentCount = fbCount;
-    fbInfo.pAttachments = fbAttachments;
-    fbInfo.width = fsr_.internalWidth;
-    fbInfo.height = fsr_.internalHeight;
-    fbInfo.layers = 1;
-
-    if (vkCreateFramebuffer(device, &fbInfo, nullptr, &fsr_.sceneFramebuffer) != VK_SUCCESS) {
-        LOG_ERROR("FSR: failed to create scene framebuffer");
-        destroyFSRResources();
-        return false;
-    }
-
-    // Sampler for the resolved scene color
-    VkSamplerCreateInfo samplerInfo{};
-    samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
-    samplerInfo.minFilter = VK_FILTER_LINEAR;
-    samplerInfo.magFilter = VK_FILTER_LINEAR;
-    samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-    samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-    samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-    samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
-    fsr_.sceneSampler = vkCtx_->getOrCreateSampler(samplerInfo);
-    if (fsr_.sceneSampler == VK_NULL_HANDLE) {
-        LOG_ERROR("FSR: failed to create sampler");
-        destroyFSRResources();
-        return false;
-    }
-
-    // Descriptor set layout: binding 0 = combined image sampler
-    VkDescriptorSetLayoutBinding binding{};
-    binding.binding = 0;
-    binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-    binding.descriptorCount = 1;
-    binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
-
-    VkDescriptorSetLayoutCreateInfo layoutInfo{};
-    layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
-    layoutInfo.bindingCount = 1;
-    layoutInfo.pBindings = &binding;
-    vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &fsr_.descSetLayout);
-
-    VkDescriptorPoolSize poolSize{};
-    poolSize.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-    poolSize.descriptorCount = 1;
-    VkDescriptorPoolCreateInfo poolInfo{};
-    poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-    poolInfo.maxSets = 1;
-    poolInfo.poolSizeCount = 1;
-    poolInfo.pPoolSizes = &poolSize;
-    vkCreateDescriptorPool(device, &poolInfo, nullptr, &fsr_.descPool);
-
-    VkDescriptorSetAllocateInfo dsAllocInfo{};
-    dsAllocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
-    dsAllocInfo.descriptorPool = fsr_.descPool;
-    dsAllocInfo.descriptorSetCount = 1;
-    dsAllocInfo.pSetLayouts = &fsr_.descSetLayout;
-    vkAllocateDescriptorSets(device, &dsAllocInfo, &fsr_.descSet);
-
-    // Always bind the 1x sceneColor (FSR reads the resolved image)
-    VkDescriptorImageInfo imgInfo{};
-    imgInfo.sampler = fsr_.sceneSampler;
-    imgInfo.imageView = fsr_.sceneColor.imageView;
-    imgInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-
-    VkWriteDescriptorSet write{};
-    write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    write.dstSet = fsr_.descSet;
-    write.dstBinding = 0;
-    write.descriptorCount = 1;
-    write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-    write.pImageInfo = &imgInfo;
-    vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
-
-    // Pipeline layout
-    VkPushConstantRange pc{};
-    pc.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
-    pc.offset = 0;
-    pc.size = 64;
-    VkPipelineLayoutCreateInfo plCI{};
-    plCI.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
-    plCI.setLayoutCount = 1;
-    plCI.pSetLayouts = &fsr_.descSetLayout;
-    plCI.pushConstantRangeCount = 1;
-    plCI.pPushConstantRanges = &pc;
-    vkCreatePipelineLayout(device, &plCI, nullptr, &fsr_.pipelineLayout);
-
-    // Load shaders
-    VkShaderModule vertMod, fragMod;
-    if (!vertMod.loadFromFile(device, "assets/shaders/postprocess.vert.spv") ||
-        !fragMod.loadFromFile(device, "assets/shaders/fsr_easu.frag.spv")) {
-        LOG_ERROR("FSR: failed to load shaders");
-        destroyFSRResources();
-        return false;
-    }
-
-    // FSR upscale pipeline renders into the swapchain pass at full resolution
-    // Must match swapchain pass MSAA setting
-    fsr_.pipeline = PipelineBuilder()
-        .setShaders(vertMod.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
-                    fragMod.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
-        .setVertexInput({}, {})
-        .setTopology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
-        .setRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE)
-        .setNoDepthTest()
-        .setColorBlendAttachment(PipelineBuilder::blendDisabled())
-        .setMultisample(msaa)
-        .setLayout(fsr_.pipelineLayout)
-        .setRenderPass(vkCtx_->getImGuiRenderPass())
-        .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-        .build(device, vkCtx_->getPipelineCache());
-
-    vertMod.destroy();
-    fragMod.destroy();
-
-    if (!fsr_.pipeline) {
-        LOG_ERROR("FSR: failed to create upscale pipeline");
-        destroyFSRResources();
-        return false;
-    }
-
-    LOG_INFO("FSR: initialized successfully");
-    return true;
-}
-
-void PostProcessPipeline::destroyFSRResources() {
-    if (!vkCtx_) return;
-
-    VkDevice device = vkCtx_->getDevice();
-    VmaAllocator alloc = vkCtx_->getAllocator();
-    vkDeviceWaitIdle(device);
-
-    if (fsr_.pipeline) { vkDestroyPipeline(device, fsr_.pipeline, nullptr); fsr_.pipeline = VK_NULL_HANDLE; }
-    if (fsr_.pipelineLayout) { vkDestroyPipelineLayout(device, fsr_.pipelineLayout, nullptr); fsr_.pipelineLayout = VK_NULL_HANDLE; }
-    if (fsr_.descPool) { vkDestroyDescriptorPool(device, fsr_.descPool, nullptr); fsr_.descPool = VK_NULL_HANDLE; fsr_.descSet = VK_NULL_HANDLE; }
-    if (fsr_.descSetLayout) { vkDestroyDescriptorSetLayout(device, fsr_.descSetLayout, nullptr); fsr_.descSetLayout = VK_NULL_HANDLE; }
-    if (fsr_.sceneFramebuffer) { vkDestroyFramebuffer(device, fsr_.sceneFramebuffer, nullptr); fsr_.sceneFramebuffer = VK_NULL_HANDLE; }
-    fsr_.sceneSampler = VK_NULL_HANDLE; // Owned by VkContext sampler cache
-    destroyImage(device, alloc, fsr_.sceneDepthResolve);
-    destroyImage(device, alloc, fsr_.sceneMsaaColor);
-    destroyImage(device, alloc, fsr_.sceneDepth);
-    destroyImage(device, alloc, fsr_.sceneColor);
-
-    fsr_.internalWidth = 0;
-    fsr_.internalHeight = 0;
-}
-
-void PostProcessPipeline::renderFSRUpscale() {
-    if (!fsr_.pipeline || currentCmd_ == VK_NULL_HANDLE) return;
-
-    VkExtent2D outExtent = vkCtx_->getSwapchainExtent();
-    float inW = static_cast<float>(fsr_.internalWidth);
-    float inH = static_cast<float>(fsr_.internalHeight);
-    float outW = static_cast<float>(outExtent.width);
-    float outH = static_cast<float>(outExtent.height);
-
-    // FSR push constants
-    struct {
-        glm::vec4 con0;  // inputSize.xy, 1/inputSize.xy
-        glm::vec4 con1;  // inputSize.xy / outputSize.xy, 0.5 * inputSize.xy / outputSize.xy
-        glm::vec4 con2;  // outputSize.xy, 1/outputSize.xy
-        glm::vec4 con3;  // sharpness, 0, 0, 0
-    } fsrConst;
-
-    fsrConst.con0 = glm::vec4(inW, inH, 1.0f / inW, 1.0f / inH);
-    fsrConst.con1 = glm::vec4(inW / outW, inH / outH, 0.5f * inW / outW, 0.5f * inH / outH);
-    fsrConst.con2 = glm::vec4(outW, outH, 1.0f / outW, 1.0f / outH);
-    fsrConst.con3 = glm::vec4(fsr_.sharpness, 0.0f, 0.0f, 0.0f);
-
-    vkCmdBindPipeline(currentCmd_, VK_PIPELINE_BIND_POINT_GRAPHICS, fsr_.pipeline);
-    vkCmdBindDescriptorSets(currentCmd_, VK_PIPELINE_BIND_POINT_GRAPHICS,
-        fsr_.pipelineLayout, 0, 1, &fsr_.descSet, 0, nullptr);
-    vkCmdPushConstants(currentCmd_, fsr_.pipelineLayout,
-        VK_SHADER_STAGE_FRAGMENT_BIT, 0, 64, &fsrConst);
-    vkCmdDraw(currentCmd_, 3, 1, 0, 0);
-}
-
-// ========================= FSR 2.2 Temporal Upscaling =========================
-
-float PostProcessPipeline::halton(uint32_t index, uint32_t base) {
-    float f = 1.0f;
-    float r = 0.0f;
-    uint32_t current = index;
-    while (current > 0) {
-        f /= static_cast<float>(base);
-        r += f * static_cast<float>(current % base);
-        current /= base;
-    }
-    return r;
-}
-
-bool PostProcessPipeline::initFSR2Resources() {
-    if (!vkCtx_) return false;
-
-    VkDevice device = vkCtx_->getDevice();
-    VmaAllocator alloc = vkCtx_->getAllocator();
-    VkExtent2D swapExtent = vkCtx_->getSwapchainExtent();
-
-    // Temporary stability fallback: keep FSR2 path at native internal resolution
-    // until temporal reprojection is reworked.
-    fsr2_.internalWidth = static_cast<uint32_t>(swapExtent.width * fsr2_.scaleFactor);
-    fsr2_.internalHeight = static_cast<uint32_t>(swapExtent.height * fsr2_.scaleFactor);
-    fsr2_.internalWidth = (fsr2_.internalWidth + 1) & ~1u;
-    fsr2_.internalHeight = (fsr2_.internalHeight + 1) & ~1u;
-
-    LOG_INFO("FSR2: initializing at ", fsr2_.internalWidth, "x", fsr2_.internalHeight,
-             " -> ", swapExtent.width, "x", swapExtent.height,
-             " (scale=", fsr2_.scaleFactor, ")");
-    fsr2_.useAmdBackend = false;
-    fsr2_.amdFsr3FramegenRuntimeActive = false;
-    fsr2_.amdFsr3FramegenRuntimeReady = false;
-    fsr2_.framegenOutputValid = false;
-    fsr2_.amdFsr3RuntimePath = "Path C";
-    fsr2_.amdFsr3RuntimeLastError.clear();
-    fsr2_.amdFsr3UpscaleDispatchCount = 0;
-    fsr2_.amdFsr3FramegenDispatchCount = 0;
-    fsr2_.amdFsr3FallbackCount = 0;
-    fsr2_.amdFsr3InteropSyncValue = 1;
-#if WOWEE_HAS_AMD_FSR2
-    LOG_INFO("FSR2: AMD FidelityFX SDK detected at build time.");
-#else
-    LOG_WARNING("FSR2: AMD FidelityFX SDK not detected; using internal fallback path.");
-#endif
-
-    VkFormat colorFmt = vkCtx_->getSwapchainFormat();
-    VkFormat depthFmt = vkCtx_->getDepthFormat();
-
-    // Scene color (internal resolution, 1x — FSR2 replaces MSAA)
-    fsr2_.sceneColor = createImage(device, alloc, fsr2_.internalWidth, fsr2_.internalHeight,
-        colorFmt, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
-    if (!fsr2_.sceneColor.image) { LOG_ERROR("FSR2: failed to create scene color"); return false; }
-
-    // Scene depth (internal resolution, 1x, sampled for motion vectors)
-    fsr2_.sceneDepth = createImage(device, alloc, fsr2_.internalWidth, fsr2_.internalHeight,
-        depthFmt, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
-    if (!fsr2_.sceneDepth.image) { LOG_ERROR("FSR2: failed to create scene depth"); destroyFSR2Resources(); return false; }
-
-    // Motion vector buffer (internal resolution)
-    fsr2_.motionVectors = createImage(device, alloc, fsr2_.internalWidth, fsr2_.internalHeight,
-        VK_FORMAT_R16G16_SFLOAT, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
-    if (!fsr2_.motionVectors.image) { LOG_ERROR("FSR2: failed to create motion vectors"); destroyFSR2Resources(); return false; }
-
-    // History buffers (display resolution, ping-pong)
-    for (int i = 0; i < 2; i++) {
-        fsr2_.history[i] = createImage(device, alloc, swapExtent.width, swapExtent.height,
-            VK_FORMAT_R16G16B16A16_SFLOAT,
-            VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
-        if (!fsr2_.history[i].image) { LOG_ERROR("FSR2: failed to create history buffer ", i); destroyFSR2Resources(); return false; }
-    }
-    fsr2_.framegenOutput = createImage(device, alloc, swapExtent.width, swapExtent.height,
-        VK_FORMAT_R16G16B16A16_SFLOAT, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
-    if (!fsr2_.framegenOutput.image) { LOG_ERROR("FSR2: failed to create framegen output"); destroyFSR2Resources(); return false; }
-
-    // Scene framebuffer (non-MSAA: [color, depth])
-    // Must use the same render pass as the swapchain — which must be non-MSAA when FSR2 is active
-    VkImageView fbAttachments[2] = { fsr2_.sceneColor.imageView, fsr2_.sceneDepth.imageView };
-    VkFramebufferCreateInfo fbInfo{};
-    fbInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
-    fbInfo.renderPass = vkCtx_->getImGuiRenderPass();
-    fbInfo.attachmentCount = 2;
-    fbInfo.pAttachments = fbAttachments;
-    fbInfo.width = fsr2_.internalWidth;
-    fbInfo.height = fsr2_.internalHeight;
-    fbInfo.layers = 1;
-    if (vkCreateFramebuffer(device, &fbInfo, nullptr, &fsr2_.sceneFramebuffer) != VK_SUCCESS) {
-        LOG_ERROR("FSR2: failed to create scene framebuffer");
-        destroyFSR2Resources();
-        return false;
-    }
-
-    // Samplers
-    VkSamplerCreateInfo samplerInfo{};
-    samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
-    samplerInfo.minFilter = VK_FILTER_LINEAR;
-    samplerInfo.magFilter = VK_FILTER_LINEAR;
-    samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-    samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-    samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-    fsr2_.linearSampler = vkCtx_->getOrCreateSampler(samplerInfo);
-
-    samplerInfo.minFilter = VK_FILTER_NEAREST;
-    samplerInfo.magFilter = VK_FILTER_NEAREST;
-    fsr2_.nearestSampler = vkCtx_->getOrCreateSampler(samplerInfo);
-
-#if WOWEE_HAS_AMD_FSR2
-    // Initialize AMD FSR2 context; fall back to internal path on any failure.
-    fsr2_.amdScratchBufferSize = ffxFsr2GetScratchMemorySizeVK(vkCtx_->getPhysicalDevice());
-    if (fsr2_.amdScratchBufferSize > 0) {
-        fsr2_.amdScratchBuffer = std::malloc(fsr2_.amdScratchBufferSize);
-    }
-    if (!fsr2_.amdScratchBuffer) {
-        LOG_WARNING("FSR2 AMD: failed to allocate scratch buffer, using internal fallback.");
-    } else {
-        FfxErrorCode ifaceErr = ffxFsr2GetInterfaceVK(
-            &fsr2_.amdInterface,
-            fsr2_.amdScratchBuffer,
-            fsr2_.amdScratchBufferSize,
-            vkCtx_->getPhysicalDevice(),
-            vkGetDeviceProcAddr);
-        if (ifaceErr != FFX_OK) {
-            LOG_WARNING("FSR2 AMD: ffxFsr2GetInterfaceVK failed (", static_cast<int>(ifaceErr), "), using internal fallback.");
-            std::free(fsr2_.amdScratchBuffer);
-            fsr2_.amdScratchBuffer = nullptr;
-            fsr2_.amdScratchBufferSize = 0;
-        } else {
-            FfxFsr2ContextDescription ctxDesc{};
-            ctxDesc.flags = FFX_FSR2_ENABLE_AUTO_EXPOSURE | FFX_FSR2_ENABLE_MOTION_VECTORS_JITTER_CANCELLATION;
-            ctxDesc.maxRenderSize.width = fsr2_.internalWidth;
-            ctxDesc.maxRenderSize.height = fsr2_.internalHeight;
-            ctxDesc.displaySize.width = swapExtent.width;
-            ctxDesc.displaySize.height = swapExtent.height;
-            ctxDesc.callbacks = fsr2_.amdInterface;
-            ctxDesc.device = ffxGetDeviceVK(vkCtx_->getDevice());
-            ctxDesc.fpMessage = nullptr;
-
-            FfxErrorCode ctxErr = ffxFsr2ContextCreate(&fsr2_.amdContext, &ctxDesc);
-            if (ctxErr == FFX_OK) {
-                fsr2_.useAmdBackend = true;
-                LOG_INFO("FSR2 AMD: context created successfully.");
-#if WOWEE_HAS_AMD_FSR3_FRAMEGEN
-                // FSR3 frame generation runtime uses AMD FidelityFX SDK which can
-                // corrupt Vulkan driver state on NVIDIA GPUs when context creation
-                // fails, causing subsequent vkCmdBeginRenderPass to crash.
-                // Skip FSR3 frame gen entirely on non-AMD GPUs.
-                if (fsr2_.amdFsr3FramegenEnabled && vkCtx_->isAmdGpu()) {
-                    fsr2_.amdFsr3FramegenRuntimeActive = false;
-                    if (!fsr2_.amdFsr3Runtime) fsr2_.amdFsr3Runtime = std::make_unique<AmdFsr3Runtime>();
-                    AmdFsr3RuntimeInitDesc fgInit{};
-                    fgInit.physicalDevice = vkCtx_->getPhysicalDevice();
-                    fgInit.device = vkCtx_->getDevice();
-                    fgInit.getDeviceProcAddr = vkGetDeviceProcAddr;
-                    fgInit.maxRenderWidth = fsr2_.internalWidth;
-                    fgInit.maxRenderHeight = fsr2_.internalHeight;
-                    fgInit.displayWidth = swapExtent.width;
-                    fgInit.displayHeight = swapExtent.height;
-                    fgInit.colorFormat = VK_FORMAT_R16G16B16A16_SFLOAT;
-                    fgInit.hdrInput = false;
-                    fgInit.depthInverted = false;
-                    fgInit.enableFrameGeneration = true;
-                    fsr2_.amdFsr3FramegenRuntimeReady = fsr2_.amdFsr3Runtime->initialize(fgInit);
-                    if (fsr2_.amdFsr3FramegenRuntimeReady) {
-                        fsr2_.amdFsr3RuntimeLastError.clear();
-                        fsr2_.amdFsr3RuntimePath = "Path A";
-                        LOG_INFO("FSR3 framegen runtime library loaded from ", fsr2_.amdFsr3Runtime->loadedLibraryPath(),
-                                 " (upscale+framegen dispatch enabled)");
-                    } else {
-                        fsr2_.amdFsr3RuntimePath = "Path C";
-                        fsr2_.amdFsr3RuntimeLastError = fsr2_.amdFsr3Runtime->lastError();
-                        LOG_WARNING("FSR3 framegen toggle is enabled, but runtime initialization failed. ",
-                                    "path=", fsr2_.amdFsr3RuntimePath,
-                                    " error=", fsr2_.amdFsr3RuntimeLastError.empty() ? "(none)" : fsr2_.amdFsr3RuntimeLastError,
-                                    " runtimeLib=", fsr2_.amdFsr3Runtime->loadedLibraryPath().empty() ? "(not loaded)" : fsr2_.amdFsr3Runtime->loadedLibraryPath());
-                    }
-                }
-#endif
-            } else {
-                LOG_WARNING("FSR2 AMD: context creation failed (", static_cast<int>(ctxErr), "), using internal fallback.");
-                std::free(fsr2_.amdScratchBuffer);
-                fsr2_.amdScratchBuffer = nullptr;
-                fsr2_.amdScratchBufferSize = 0;
-            }
-        }
-    }
-#endif
-
-    // --- Motion Vector Compute Pipeline ---
-    {
-        // Descriptor set layout: binding 0 = depth (sampler), binding 1 = motion vectors (storage image)
-        VkDescriptorSetLayoutBinding bindings[2] = {};
-        bindings[0].binding = 0;
-        bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-        bindings[0].descriptorCount = 1;
-        bindings[0].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
-        bindings[1].binding = 1;
-        bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
-        bindings[1].descriptorCount = 1;
-        bindings[1].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
-
-        VkDescriptorSetLayoutCreateInfo layoutInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO};
-        layoutInfo.bindingCount = 2;
-        layoutInfo.pBindings = bindings;
-        vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &fsr2_.motionVecDescSetLayout);
-
-        VkPushConstantRange pc{};
-        pc.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
-        pc.offset = 0;
-        pc.size = 2 * sizeof(glm::mat4);  // 128 bytes
-
-        VkPipelineLayoutCreateInfo plCI{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO};
-        plCI.setLayoutCount = 1;
-        plCI.pSetLayouts = &fsr2_.motionVecDescSetLayout;
-        plCI.pushConstantRangeCount = 1;
-        plCI.pPushConstantRanges = &pc;
-        vkCreatePipelineLayout(device, &plCI, nullptr, &fsr2_.motionVecPipelineLayout);
-
-        VkShaderModule compMod;
-        if (!compMod.loadFromFile(device, "assets/shaders/fsr2_motion.comp.spv")) {
-            LOG_ERROR("FSR2: failed to load motion vector compute shader");
-            destroyFSR2Resources();
-            return false;
-        }
-
-        VkComputePipelineCreateInfo cpCI{VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO};
-        cpCI.stage = compMod.stageInfo(VK_SHADER_STAGE_COMPUTE_BIT);
-        cpCI.layout = fsr2_.motionVecPipelineLayout;
-        if (vkCreateComputePipelines(device, VK_NULL_HANDLE, 1, &cpCI, nullptr, &fsr2_.motionVecPipeline) != VK_SUCCESS) {
-            LOG_ERROR("FSR2: failed to create motion vector pipeline");
-            compMod.destroy();
-            destroyFSR2Resources();
-            return false;
-        }
-        compMod.destroy();
-
-        // Descriptor pool + set
-        VkDescriptorPoolSize poolSizes[2] = {};
-        poolSizes[0] = {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1};
-        poolSizes[1] = {VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1};
-        VkDescriptorPoolCreateInfo poolInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO};
-        poolInfo.maxSets = 1;
-        poolInfo.poolSizeCount = 2;
-        poolInfo.pPoolSizes = poolSizes;
-        vkCreateDescriptorPool(device, &poolInfo, nullptr, &fsr2_.motionVecDescPool);
-
-        VkDescriptorSetAllocateInfo dsAI{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
-        dsAI.descriptorPool = fsr2_.motionVecDescPool;
-        dsAI.descriptorSetCount = 1;
-        dsAI.pSetLayouts = &fsr2_.motionVecDescSetLayout;
-        vkAllocateDescriptorSets(device, &dsAI, &fsr2_.motionVecDescSet);
-
-        // Write descriptors
-        VkDescriptorImageInfo depthImgInfo{};
-        depthImgInfo.sampler = fsr2_.nearestSampler;
-        depthImgInfo.imageView = fsr2_.sceneDepth.imageView;
-        depthImgInfo.imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
-
-        VkDescriptorImageInfo mvImgInfo{};
-        mvImgInfo.imageView = fsr2_.motionVectors.imageView;
-        mvImgInfo.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
-
-        VkWriteDescriptorSet writes[2] = {};
-        writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-        writes[0].dstSet = fsr2_.motionVecDescSet;
-        writes[0].dstBinding = 0;
-        writes[0].descriptorCount = 1;
-        writes[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-        writes[0].pImageInfo = &depthImgInfo;
-
-        writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-        writes[1].dstSet = fsr2_.motionVecDescSet;
-        writes[1].dstBinding = 1;
-        writes[1].descriptorCount = 1;
-        writes[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
-        writes[1].pImageInfo = &mvImgInfo;
-
-        vkUpdateDescriptorSets(device, 2, writes, 0, nullptr);
-    }
-
-    // --- Temporal Accumulation Compute Pipeline ---
-    {
-        // bindings: 0=sceneColor, 1=depth, 2=motionVectors, 3=historyInput, 4=historyOutput
-        VkDescriptorSetLayoutBinding bindings[5] = {};
-        for (int i = 0; i < 4; i++) {
-            bindings[i].binding = i;
-            bindings[i].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-            bindings[i].descriptorCount = 1;
-            bindings[i].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
-        }
-        bindings[4].binding = 4;
-        bindings[4].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
-        bindings[4].descriptorCount = 1;
-        bindings[4].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
-
-        VkDescriptorSetLayoutCreateInfo layoutInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO};
-        layoutInfo.bindingCount = 5;
-        layoutInfo.pBindings = bindings;
-        vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &fsr2_.accumulateDescSetLayout);
-
-        VkPushConstantRange pc{};
-        pc.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
-        pc.offset = 0;
-        pc.size = 4 * sizeof(glm::vec4);  // 64 bytes
-
-        VkPipelineLayoutCreateInfo plCI{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO};
-        plCI.setLayoutCount = 1;
-        plCI.pSetLayouts = &fsr2_.accumulateDescSetLayout;
-        plCI.pushConstantRangeCount = 1;
-        plCI.pPushConstantRanges = &pc;
-        vkCreatePipelineLayout(device, &plCI, nullptr, &fsr2_.accumulatePipelineLayout);
-
-        VkShaderModule compMod;
-        if (!compMod.loadFromFile(device, "assets/shaders/fsr2_accumulate.comp.spv")) {
-            LOG_ERROR("FSR2: failed to load accumulation compute shader");
-            destroyFSR2Resources();
-            return false;
-        }
-
-        VkComputePipelineCreateInfo cpCI{VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO};
-        cpCI.stage = compMod.stageInfo(VK_SHADER_STAGE_COMPUTE_BIT);
-        cpCI.layout = fsr2_.accumulatePipelineLayout;
-        if (vkCreateComputePipelines(device, VK_NULL_HANDLE, 1, &cpCI, nullptr, &fsr2_.accumulatePipeline) != VK_SUCCESS) {
-            LOG_ERROR("FSR2: failed to create accumulation pipeline");
-            compMod.destroy();
-            destroyFSR2Resources();
-            return false;
-        }
-        compMod.destroy();
-
-        // Descriptor pool: 2 sets (ping-pong), each with 4 samplers + 1 storage image
-        VkDescriptorPoolSize poolSizes[2] = {};
-        poolSizes[0] = {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 8};
-        poolSizes[1] = {VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 2};
-        VkDescriptorPoolCreateInfo poolInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO};
-        poolInfo.maxSets = 2;
-        poolInfo.poolSizeCount = 2;
-        poolInfo.pPoolSizes = poolSizes;
-        vkCreateDescriptorPool(device, &poolInfo, nullptr, &fsr2_.accumulateDescPool);
-
-        // Allocate 2 descriptor sets (one per ping-pong direction)
-        VkDescriptorSetLayout layouts[2] = { fsr2_.accumulateDescSetLayout, fsr2_.accumulateDescSetLayout };
-        VkDescriptorSetAllocateInfo dsAI{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
-        dsAI.descriptorPool = fsr2_.accumulateDescPool;
-        dsAI.descriptorSetCount = 2;
-        dsAI.pSetLayouts = layouts;
-        vkAllocateDescriptorSets(device, &dsAI, fsr2_.accumulateDescSets);
-
-        // Write descriptors for both ping-pong sets
-        for (int pp = 0; pp < 2; pp++) {
-            int inputHistory = 1 - pp;   // Read from the other
-            int outputHistory = pp;       // Write to this one
-
-            // The accumulation shader already performs custom Lanczos reconstruction.
-            // Use nearest here to avoid double filtering (linear + Lanczos) softening.
-            VkDescriptorImageInfo colorInfo{fsr2_.nearestSampler, fsr2_.sceneColor.imageView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL};
-            VkDescriptorImageInfo depthInfo{fsr2_.nearestSampler, fsr2_.sceneDepth.imageView, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL};
-            VkDescriptorImageInfo mvInfo{fsr2_.nearestSampler, fsr2_.motionVectors.imageView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL};
-            VkDescriptorImageInfo histInInfo{fsr2_.linearSampler, fsr2_.history[inputHistory].imageView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL};
-            VkDescriptorImageInfo histOutInfo{VK_NULL_HANDLE, fsr2_.history[outputHistory].imageView, VK_IMAGE_LAYOUT_GENERAL};
-
-            VkWriteDescriptorSet writes[5] = {};
-            for (int w = 0; w < 5; w++) {
-                writes[w].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-                writes[w].dstSet = fsr2_.accumulateDescSets[pp];
-                writes[w].dstBinding = w;
-                writes[w].descriptorCount = 1;
-            }
-            writes[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; writes[0].pImageInfo = &colorInfo;
-            writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; writes[1].pImageInfo = &depthInfo;
-            writes[2].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; writes[2].pImageInfo = &mvInfo;
-            writes[3].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; writes[3].pImageInfo = &histInInfo;
-            writes[4].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;          writes[4].pImageInfo = &histOutInfo;
-
-            vkUpdateDescriptorSets(device, 5, writes, 0, nullptr);
-        }
-    }
-
-    // --- RCAS Sharpening Pipeline (fragment shader, fullscreen pass) ---
-    {
-        VkDescriptorSetLayoutBinding binding{};
-        binding.binding = 0;
-        binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-        binding.descriptorCount = 1;
-        binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
-
-        VkDescriptorSetLayoutCreateInfo layoutInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO};
-        layoutInfo.bindingCount = 1;
-        layoutInfo.pBindings = &binding;
-        vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &fsr2_.sharpenDescSetLayout);
-
-        VkPushConstantRange pc{};
-        pc.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
-        pc.offset = 0;
-        pc.size = sizeof(glm::vec4);
-
-        VkPipelineLayoutCreateInfo plCI{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO};
-        plCI.setLayoutCount = 1;
-        plCI.pSetLayouts = &fsr2_.sharpenDescSetLayout;
-        plCI.pushConstantRangeCount = 1;
-        plCI.pPushConstantRanges = &pc;
-        vkCreatePipelineLayout(device, &plCI, nullptr, &fsr2_.sharpenPipelineLayout);
-
-        VkShaderModule vertMod, fragMod;
-        if (!vertMod.loadFromFile(device, "assets/shaders/postprocess.vert.spv") ||
-            !fragMod.loadFromFile(device, "assets/shaders/fsr2_sharpen.frag.spv")) {
-            LOG_ERROR("FSR2: failed to load sharpen shaders");
-            destroyFSR2Resources();
-            return false;
-        }
-
-        fsr2_.sharpenPipeline = PipelineBuilder()
-            .setShaders(vertMod.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
-                        fragMod.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
-            .setVertexInput({}, {})
-            .setTopology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
-            .setRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE)
-            .setNoDepthTest()
-            .setColorBlendAttachment(PipelineBuilder::blendDisabled())
-            .setMultisample(VK_SAMPLE_COUNT_1_BIT)
-            .setLayout(fsr2_.sharpenPipelineLayout)
-            .setRenderPass(vkCtx_->getImGuiRenderPass())
-            .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-            .build(device, vkCtx_->getPipelineCache());
-
-        vertMod.destroy();
-        fragMod.destroy();
-
-        if (!fsr2_.sharpenPipeline) {
-            LOG_ERROR("FSR2: failed to create sharpen pipeline");
-            destroyFSR2Resources();
-            return false;
-        }
-
-        // Descriptor pool + sets for sharpen pass (double-buffered to avoid race condition)
-        VkDescriptorPoolSize poolSize{VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 2};
-        VkDescriptorPoolCreateInfo poolInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO};
-        poolInfo.maxSets = 2;
-        poolInfo.poolSizeCount = 1;
-        poolInfo.pPoolSizes = &poolSize;
-        vkCreateDescriptorPool(device, &poolInfo, nullptr, &fsr2_.sharpenDescPool);
-
-        VkDescriptorSetLayout layouts[2] = {fsr2_.sharpenDescSetLayout, fsr2_.sharpenDescSetLayout};
-        VkDescriptorSetAllocateInfo dsAI{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
-        dsAI.descriptorPool = fsr2_.sharpenDescPool;
-        dsAI.descriptorSetCount = 2;
-        dsAI.pSetLayouts = layouts;
-        vkAllocateDescriptorSets(device, &dsAI, fsr2_.sharpenDescSets);
-        // Descriptors updated dynamically each frame to point at the correct history buffer
-    }
-
-    fsr2_.needsHistoryReset = true;
-    fsr2_.frameIndex = 0;
-    LOG_INFO("FSR2: initialized successfully");
-    return true;
-}
-
-void PostProcessPipeline::destroyFSR2Resources() {
-    if (!vkCtx_) return;
-
-    VkDevice device = vkCtx_->getDevice();
-    VmaAllocator alloc = vkCtx_->getAllocator();
-    vkDeviceWaitIdle(device);
-
-#if WOWEE_HAS_AMD_FSR2
-    if (fsr2_.useAmdBackend) {
-        ffxFsr2ContextDestroy(&fsr2_.amdContext);
-        fsr2_.useAmdBackend = false;
-    }
-    if (fsr2_.amdScratchBuffer) {
-        std::free(fsr2_.amdScratchBuffer);
-        fsr2_.amdScratchBuffer = nullptr;
-    }
-    fsr2_.amdScratchBufferSize = 0;
-#endif
-    fsr2_.amdFsr3FramegenRuntimeActive = false;
-    fsr2_.amdFsr3FramegenRuntimeReady = false;
-    fsr2_.framegenOutputValid = false;
-    fsr2_.amdFsr3RuntimePath = "Path C";
-    fsr2_.amdFsr3RuntimeLastError.clear();
-    fsr2_.amdFsr3InteropSyncValue = 1;
-#if WOWEE_HAS_AMD_FSR3_FRAMEGEN
-    if (fsr2_.amdFsr3Runtime) {
-        fsr2_.amdFsr3Runtime->shutdown();
-        fsr2_.amdFsr3Runtime.reset();
-    }
-#endif
-
-    if (fsr2_.sharpenPipeline) { vkDestroyPipeline(device, fsr2_.sharpenPipeline, nullptr); fsr2_.sharpenPipeline = VK_NULL_HANDLE; }
-    if (fsr2_.sharpenPipelineLayout) { vkDestroyPipelineLayout(device, fsr2_.sharpenPipelineLayout, nullptr); fsr2_.sharpenPipelineLayout = VK_NULL_HANDLE; }
-    if (fsr2_.sharpenDescPool) { vkDestroyDescriptorPool(device, fsr2_.sharpenDescPool, nullptr); fsr2_.sharpenDescPool = VK_NULL_HANDLE; fsr2_.sharpenDescSets[0] = fsr2_.sharpenDescSets[1] = VK_NULL_HANDLE; }
-    if (fsr2_.sharpenDescSetLayout) { vkDestroyDescriptorSetLayout(device, fsr2_.sharpenDescSetLayout, nullptr); fsr2_.sharpenDescSetLayout = VK_NULL_HANDLE; }
-
-    if (fsr2_.accumulatePipeline) { vkDestroyPipeline(device, fsr2_.accumulatePipeline, nullptr); fsr2_.accumulatePipeline = VK_NULL_HANDLE; }
-    if (fsr2_.accumulatePipelineLayout) { vkDestroyPipelineLayout(device, fsr2_.accumulatePipelineLayout, nullptr); fsr2_.accumulatePipelineLayout = VK_NULL_HANDLE; }
-    if (fsr2_.accumulateDescPool) { vkDestroyDescriptorPool(device, fsr2_.accumulateDescPool, nullptr); fsr2_.accumulateDescPool = VK_NULL_HANDLE; fsr2_.accumulateDescSets[0] = fsr2_.accumulateDescSets[1] = VK_NULL_HANDLE; }
-    if (fsr2_.accumulateDescSetLayout) { vkDestroyDescriptorSetLayout(device, fsr2_.accumulateDescSetLayout, nullptr); fsr2_.accumulateDescSetLayout = VK_NULL_HANDLE; }
-
-    if (fsr2_.motionVecPipeline) { vkDestroyPipeline(device, fsr2_.motionVecPipeline, nullptr); fsr2_.motionVecPipeline = VK_NULL_HANDLE; }
-    if (fsr2_.motionVecPipelineLayout) { vkDestroyPipelineLayout(device, fsr2_.motionVecPipelineLayout, nullptr); fsr2_.motionVecPipelineLayout = VK_NULL_HANDLE; }
-    if (fsr2_.motionVecDescPool) { vkDestroyDescriptorPool(device, fsr2_.motionVecDescPool, nullptr); fsr2_.motionVecDescPool = VK_NULL_HANDLE; fsr2_.motionVecDescSet = VK_NULL_HANDLE; }
-    if (fsr2_.motionVecDescSetLayout) { vkDestroyDescriptorSetLayout(device, fsr2_.motionVecDescSetLayout, nullptr); fsr2_.motionVecDescSetLayout = VK_NULL_HANDLE; }
-
-    if (fsr2_.sceneFramebuffer) { vkDestroyFramebuffer(device, fsr2_.sceneFramebuffer, nullptr); fsr2_.sceneFramebuffer = VK_NULL_HANDLE; }
-    fsr2_.linearSampler = VK_NULL_HANDLE;  // Owned by VkContext sampler cache
-    fsr2_.nearestSampler = VK_NULL_HANDLE; // Owned by VkContext sampler cache
-
-    destroyImage(device, alloc, fsr2_.motionVectors);
-    for (int i = 0; i < 2; i++) destroyImage(device, alloc, fsr2_.history[i]);
-    destroyImage(device, alloc, fsr2_.framegenOutput);
-    destroyImage(device, alloc, fsr2_.sceneDepth);
-    destroyImage(device, alloc, fsr2_.sceneColor);
-
-    fsr2_.internalWidth = 0;
-    fsr2_.internalHeight = 0;
-}
-
-void PostProcessPipeline::dispatchMotionVectors() {
-    if (!fsr2_.motionVecPipeline || currentCmd_ == VK_NULL_HANDLE) return;
-
-    // Transition depth: DEPTH_STENCIL_ATTACHMENT → DEPTH_STENCIL_READ_ONLY
-    transitionImageLayout(currentCmd_, fsr2_.sceneDepth.image,
-        VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
-        VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
-        VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-
-    // Transition motion vectors: UNDEFINED → GENERAL
-    transitionImageLayout(currentCmd_, fsr2_.motionVectors.image,
-        VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
-        VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-
-    vkCmdBindPipeline(currentCmd_, VK_PIPELINE_BIND_POINT_COMPUTE, fsr2_.motionVecPipeline);
-    vkCmdBindDescriptorSets(currentCmd_, VK_PIPELINE_BIND_POINT_COMPUTE,
-        fsr2_.motionVecPipelineLayout, 0, 1, &fsr2_.motionVecDescSet, 0, nullptr);
-
-    // Reprojection with jittered matrices:
-    // reconstruct world position from current depth, then project into previous clip.
-    struct {
-        glm::mat4 prevViewProjection;
-        glm::mat4 invCurrentViewProj;
-    } pc;
-
-    glm::mat4 currentVP = camera_->getViewProjectionMatrix();
-    pc.prevViewProjection = fsr2_.prevViewProjection;
-    pc.invCurrentViewProj = glm::inverse(currentVP);
-
-    vkCmdPushConstants(currentCmd_, fsr2_.motionVecPipelineLayout,
-        VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pc), &pc);
-
-    uint32_t gx = (fsr2_.internalWidth + 7) / 8;
-    uint32_t gy = (fsr2_.internalHeight + 7) / 8;
-    vkCmdDispatch(currentCmd_, gx, gy, 1);
-
-    // Transition motion vectors: GENERAL → SHADER_READ_ONLY for accumulation
-    transitionImageLayout(currentCmd_, fsr2_.motionVectors.image,
-        VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-}
-
-void PostProcessPipeline::dispatchTemporalAccumulate() {
-    if (!fsr2_.accumulatePipeline || currentCmd_ == VK_NULL_HANDLE) return;
-
-    VkExtent2D swapExtent = vkCtx_->getSwapchainExtent();
-    uint32_t outputIdx = fsr2_.currentHistory;
-    uint32_t inputIdx = 1 - outputIdx;
-
-    // Transition scene color: PRESENT_SRC_KHR → SHADER_READ_ONLY
-    transitionImageLayout(currentCmd_, fsr2_.sceneColor.image,
-        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-
-    // History layout lifecycle:
-    //   First frame: both in UNDEFINED
-    //   Subsequent frames: both in SHADER_READ_ONLY (output was transitioned for sharpen,
-    //                      input was left in SHADER_READ_ONLY from its sharpen read)
-    VkImageLayout historyOldLayout = fsr2_.needsHistoryReset
-        ? VK_IMAGE_LAYOUT_UNDEFINED
-        : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-
-    // Transition history input: SHADER_READ_ONLY → SHADER_READ_ONLY (barrier for sync)
-    transitionImageLayout(currentCmd_, fsr2_.history[inputIdx].image,
-        historyOldLayout, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-        VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,  // sharpen read in previous frame
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-
-    // Transition history output: SHADER_READ_ONLY → GENERAL (for compute write)
-    transitionImageLayout(currentCmd_, fsr2_.history[outputIdx].image,
-        historyOldLayout, VK_IMAGE_LAYOUT_GENERAL,
-        VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-
-    vkCmdBindPipeline(currentCmd_, VK_PIPELINE_BIND_POINT_COMPUTE, fsr2_.accumulatePipeline);
-    vkCmdBindDescriptorSets(currentCmd_, VK_PIPELINE_BIND_POINT_COMPUTE,
-        fsr2_.accumulatePipelineLayout, 0, 1, &fsr2_.accumulateDescSets[outputIdx], 0, nullptr);
-
-    // Push constants
-    struct {
-        glm::vec4 internalSize;
-        glm::vec4 displaySize;
-        glm::vec4 jitterOffset;
-        glm::vec4 params;
-    } pc;
-
-    pc.internalSize = glm::vec4(
-        static_cast<float>(fsr2_.internalWidth), static_cast<float>(fsr2_.internalHeight),
-        1.0f / fsr2_.internalWidth, 1.0f / fsr2_.internalHeight);
-    pc.displaySize = glm::vec4(
-        static_cast<float>(swapExtent.width), static_cast<float>(swapExtent.height),
-        1.0f / swapExtent.width, 1.0f / swapExtent.height);
-    glm::vec2 jitter = camera_->getJitter();
-    pc.jitterOffset = glm::vec4(jitter.x, jitter.y, 0.0f, 0.0f);
-    pc.params = glm::vec4(
-        fsr2_.needsHistoryReset ? 1.0f : 0.0f,
-        fsr2_.sharpness,
-        static_cast<float>(fsr2_.convergenceFrame),
-        0.0f);
-
-    vkCmdPushConstants(currentCmd_, fsr2_.accumulatePipelineLayout,
-        VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pc), &pc);
-
-    uint32_t gx = (swapExtent.width + 7) / 8;
-    uint32_t gy = (swapExtent.height + 7) / 8;
-    vkCmdDispatch(currentCmd_, gx, gy, 1);
-
-    fsr2_.needsHistoryReset = false;
-}
-
-void PostProcessPipeline::dispatchAmdFsr2() {
-    if (currentCmd_ == VK_NULL_HANDLE || !camera_) return;
-#if WOWEE_HAS_AMD_FSR2
-    if (!fsr2_.useAmdBackend) return;
-
-    VkExtent2D swapExtent = vkCtx_->getSwapchainExtent();
-    uint32_t outputIdx = fsr2_.currentHistory;
-
-    transitionImageLayout(currentCmd_, fsr2_.sceneColor.image,
-        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-    transitionImageLayout(currentCmd_, fsr2_.motionVectors.image,
-        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-    transitionImageLayout(currentCmd_, fsr2_.sceneDepth.image,
-        VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-    transitionImageLayout(currentCmd_, fsr2_.history[outputIdx].image,
-        fsr2_.needsHistoryReset ? VK_IMAGE_LAYOUT_UNDEFINED : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-        VK_IMAGE_LAYOUT_GENERAL,
-        VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-
-    FfxFsr2DispatchDescription desc{};
-    desc.commandList = ffxGetCommandListVK(currentCmd_);
-    desc.color = ffxGetTextureResourceVK(&fsr2_.amdContext,
-        fsr2_.sceneColor.image, fsr2_.sceneColor.imageView,
-        fsr2_.internalWidth, fsr2_.internalHeight, vkCtx_->getSwapchainFormat(),
-        L"FSR2_InputColor", FFX_RESOURCE_STATE_COMPUTE_READ);
-    desc.depth = ffxGetTextureResourceVK(&fsr2_.amdContext,
-        fsr2_.sceneDepth.image, fsr2_.sceneDepth.imageView,
-        fsr2_.internalWidth, fsr2_.internalHeight, vkCtx_->getDepthFormat(),
-        L"FSR2_InputDepth", FFX_RESOURCE_STATE_COMPUTE_READ);
-    desc.motionVectors = ffxGetTextureResourceVK(&fsr2_.amdContext,
-        fsr2_.motionVectors.image, fsr2_.motionVectors.imageView,
-        fsr2_.internalWidth, fsr2_.internalHeight, VK_FORMAT_R16G16_SFLOAT,
-        L"FSR2_InputMotionVectors", FFX_RESOURCE_STATE_COMPUTE_READ);
-    desc.output = ffxGetTextureResourceVK(&fsr2_.amdContext,
-        fsr2_.history[outputIdx].image, fsr2_.history[outputIdx].imageView,
-        swapExtent.width, swapExtent.height, VK_FORMAT_R16G16B16A16_SFLOAT,
-        L"FSR2_Output", FFX_RESOURCE_STATE_UNORDERED_ACCESS);
-
-    // Camera jitter is stored as NDC projection offsets; convert to render-pixel offsets.
-    // Do not apply jitterSign again here: it is already baked into camera jitter.
-    glm::vec2 jitterNdc = camera_->getJitter();
-    desc.jitterOffset.x = jitterNdc.x * 0.5f * static_cast<float>(fsr2_.internalWidth);
-    desc.jitterOffset.y = jitterNdc.y * 0.5f * static_cast<float>(fsr2_.internalHeight);
-    desc.motionVectorScale.x = static_cast<float>(fsr2_.internalWidth) * fsr2_.motionVecScaleX;
-    desc.motionVectorScale.y = static_cast<float>(fsr2_.internalHeight) * fsr2_.motionVecScaleY;
-    desc.renderSize.width = fsr2_.internalWidth;
-    desc.renderSize.height = fsr2_.internalHeight;
-    desc.enableSharpening = false;  // Keep existing RCAS post pass.
-    desc.sharpness = 0.0f;
-    desc.frameTimeDelta = glm::max(0.001f, lastDeltaTime_ * 1000.0f);
-    desc.preExposure = 1.0f;
-    desc.reset = fsr2_.needsHistoryReset;
-    desc.cameraNear = camera_->getNearPlane();
-    desc.cameraFar = camera_->getFarPlane();
-    desc.cameraFovAngleVertical = glm::radians(camera_->getFovDegrees());
-    desc.viewSpaceToMetersFactor = 1.0f;
-    desc.enableAutoReactive = false;
-
-    FfxErrorCode dispatchErr = ffxFsr2ContextDispatch(&fsr2_.amdContext, &desc);
-    if (dispatchErr != FFX_OK) {
-        LOG_WARNING("FSR2 AMD: dispatch failed (", static_cast<int>(dispatchErr), "), forcing history reset.");
-        fsr2_.needsHistoryReset = true;
-    } else {
-        fsr2_.needsHistoryReset = false;
-    }
-#endif
-}
-
-void PostProcessPipeline::dispatchAmdFsr3Framegen() {
-#if WOWEE_HAS_AMD_FSR3_FRAMEGEN
-    if (!fsr2_.amdFsr3FramegenEnabled) {
-        fsr2_.amdFsr3FramegenRuntimeActive = false;
-        return;
-    }
-    if (!fsr2_.amdFsr3Runtime || !fsr2_.amdFsr3FramegenRuntimeReady) {
-        fsr2_.amdFsr3FramegenRuntimeActive = false;
-        return;
-    }
-    uint32_t outputIdx = fsr2_.currentHistory;
-    transitionImageLayout(currentCmd_, fsr2_.sceneColor.image,
-        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-    transitionImageLayout(currentCmd_, fsr2_.motionVectors.image,
-        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-    transitionImageLayout(currentCmd_, fsr2_.sceneDepth.image,
-        VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-    transitionImageLayout(currentCmd_, fsr2_.history[outputIdx].image,
-        fsr2_.needsHistoryReset ? VK_IMAGE_LAYOUT_UNDEFINED : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-        VK_IMAGE_LAYOUT_GENERAL,
-        VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-    if (fsr2_.amdFsr3FramegenEnabled && fsr2_.framegenOutput.image) {
-        transitionImageLayout(currentCmd_, fsr2_.framegenOutput.image,
-            fsr2_.framegenOutputValid ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED,
-            VK_IMAGE_LAYOUT_GENERAL,
-            VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-            VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-    }
-
-    AmdFsr3RuntimeDispatchDesc fgDispatch{};
-    fgDispatch.commandBuffer = currentCmd_;
-    fgDispatch.colorImage = fsr2_.sceneColor.image;
-    fgDispatch.depthImage = fsr2_.sceneDepth.image;
-    fgDispatch.motionVectorImage = fsr2_.motionVectors.image;
-    fgDispatch.outputImage = fsr2_.history[fsr2_.currentHistory].image;
-    fgDispatch.renderWidth = fsr2_.internalWidth;
-    fgDispatch.renderHeight = fsr2_.internalHeight;
-    fgDispatch.outputWidth = vkCtx_->getSwapchainExtent().width;
-    fgDispatch.outputHeight = vkCtx_->getSwapchainExtent().height;
-    fgDispatch.colorFormat = VK_FORMAT_R16G16B16A16_SFLOAT;
-    fgDispatch.depthFormat = vkCtx_->getDepthFormat();
-    fgDispatch.motionVectorFormat = VK_FORMAT_R16G16_SFLOAT;
-    fgDispatch.outputFormat = VK_FORMAT_R16G16B16A16_SFLOAT;
-    fgDispatch.frameGenOutputImage = fsr2_.framegenOutput.image;
-    glm::vec2 jitterNdc = camera_ ? camera_->getJitter() : glm::vec2(0.0f);
-    fgDispatch.jitterX = jitterNdc.x * 0.5f * static_cast<float>(fsr2_.internalWidth);
-    fgDispatch.jitterY = jitterNdc.y * 0.5f * static_cast<float>(fsr2_.internalHeight);
-    fgDispatch.motionScaleX = static_cast<float>(fsr2_.internalWidth) * fsr2_.motionVecScaleX;
-    fgDispatch.motionScaleY = static_cast<float>(fsr2_.internalHeight) * fsr2_.motionVecScaleY;
-    fgDispatch.frameTimeDeltaMs = glm::max(0.001f, lastDeltaTime_ * 1000.0f);
-    fgDispatch.cameraNear = camera_ ? camera_->getNearPlane() : 0.1f;
-    fgDispatch.cameraFar = camera_ ? camera_->getFarPlane() : 1000.0f;
-    fgDispatch.cameraFovYRadians = camera_ ? glm::radians(camera_->getFovDegrees()) : 1.0f;
-    fgDispatch.reset = fsr2_.needsHistoryReset;
-
-
-    if (!fsr2_.amdFsr3Runtime->dispatchUpscale(fgDispatch)) {
-        static bool warnedRuntimeDispatch = false;
-        if (!warnedRuntimeDispatch) {
-            warnedRuntimeDispatch = true;
-            LOG_WARNING("FSR3 runtime upscale dispatch failed; falling back to FSR2 dispatch output.");
-        }
-        fsr2_.amdFsr3RuntimeLastError = fsr2_.amdFsr3Runtime->lastError();
-        fsr2_.amdFsr3FallbackCount++;
-        fsr2_.amdFsr3FramegenRuntimeActive = false;
-        return;
-    }
-    fsr2_.amdFsr3RuntimeLastError.clear();
-    fsr2_.amdFsr3UpscaleDispatchCount++;
-
-    if (!fsr2_.amdFsr3FramegenEnabled) {
-        fsr2_.amdFsr3FramegenRuntimeActive = false;
-        return;
-    }
-    if (!fsr2_.amdFsr3Runtime->isFrameGenerationReady()) {
-        fsr2_.amdFsr3FramegenRuntimeActive = false;
-        return;
-    }
-    if (!fsr2_.amdFsr3Runtime->dispatchFrameGeneration(fgDispatch)) {
-        static bool warnedFgDispatch = false;
-        if (!warnedFgDispatch) {
-            warnedFgDispatch = true;
-            LOG_WARNING("FSR3 runtime frame generation dispatch failed; using upscaled output only.");
-        }
-        fsr2_.amdFsr3RuntimeLastError = fsr2_.amdFsr3Runtime->lastError();
-        fsr2_.amdFsr3FallbackCount++;
-        fsr2_.amdFsr3FramegenRuntimeActive = false;
-        return;
-    }
-    fsr2_.amdFsr3RuntimeLastError.clear();
-    fsr2_.amdFsr3FramegenDispatchCount++;
-    fsr2_.framegenOutputValid = true;
-    fsr2_.amdFsr3FramegenRuntimeActive = true;
-#else
-    fsr2_.amdFsr3FramegenRuntimeActive = false;
-#endif
-}
-
-void PostProcessPipeline::renderFSR2Sharpen() {
-    if (!fsr2_.sharpenPipeline || currentCmd_ == VK_NULL_HANDLE) return;
-
-    VkExtent2D ext = vkCtx_->getSwapchainExtent();
-    uint32_t outputIdx = fsr2_.currentHistory;
-
-    // Use per-frame descriptor set to avoid race with in-flight command buffers
-    uint32_t frameIdx = vkCtx_->getCurrentFrame();
-    VkDescriptorSet descSet = fsr2_.sharpenDescSets[frameIdx];
-
-    // Update sharpen descriptor to point at current history output
-    VkDescriptorImageInfo imgInfo{};
-    imgInfo.sampler = fsr2_.linearSampler;
-    if (fsr2_.useAmdBackend) {
-        imgInfo.imageView = (fsr2_.amdFsr3FramegenEnabled && fsr2_.amdFsr3FramegenRuntimeActive && fsr2_.framegenOutput.imageView)
-            ? fsr2_.framegenOutput.imageView
-            : fsr2_.history[outputIdx].imageView;
-    } else {
-        imgInfo.imageView = fsr2_.sceneColor.imageView;
-    }
-    imgInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-
-    VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
-    write.dstSet = descSet;
-    write.dstBinding = 0;
-    write.descriptorCount = 1;
-    write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-    write.pImageInfo = &imgInfo;
-    vkUpdateDescriptorSets(vkCtx_->getDevice(), 1, &write, 0, nullptr);
-
-    vkCmdBindPipeline(currentCmd_, VK_PIPELINE_BIND_POINT_GRAPHICS, fsr2_.sharpenPipeline);
-    vkCmdBindDescriptorSets(currentCmd_, VK_PIPELINE_BIND_POINT_GRAPHICS,
-        fsr2_.sharpenPipelineLayout, 0, 1, &descSet, 0, nullptr);
-
-    glm::vec4 params(1.0f / ext.width, 1.0f / ext.height, fsr2_.sharpness, 0.0f);
-    vkCmdPushConstants(currentCmd_, fsr2_.sharpenPipelineLayout,
-        VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(glm::vec4), &params);
-
-    vkCmdDraw(currentCmd_, 3, 1, 0, 0);
-}
-
-// ========================= FXAA Post-Process =========================
-
-bool PostProcessPipeline::initFXAAResources() {
-    if (!vkCtx_) return false;
-
-    VkDevice device = vkCtx_->getDevice();
-    VmaAllocator alloc = vkCtx_->getAllocator();
-    VkExtent2D ext = vkCtx_->getSwapchainExtent();
-    VkSampleCountFlagBits msaa = vkCtx_->getMsaaSamples();
-    bool useMsaa = (msaa > VK_SAMPLE_COUNT_1_BIT);
-    bool useDepthResolve = (vkCtx_->getDepthResolveImageView() != VK_NULL_HANDLE);
-
-    LOG_INFO("FXAA: initializing at ", ext.width, "x", ext.height,
-             " (MSAA=", static_cast<int>(msaa), "x)");
-
-    VkFormat colorFmt = vkCtx_->getSwapchainFormat();
-    VkFormat depthFmt = vkCtx_->getDepthFormat();
-
-    // sceneColor: 1x resolved color target — FXAA reads from here
-    fxaa_.sceneColor = createImage(device, alloc, ext.width, ext.height,
-        colorFmt, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
-    if (!fxaa_.sceneColor.image) {
-        LOG_ERROR("FXAA: failed to create scene color image");
-        return false;
-    }
-
-    // sceneDepth: depth buffer at current MSAA sample count
-    fxaa_.sceneDepth = createImage(device, alloc, ext.width, ext.height,
-        depthFmt, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, msaa);
-    if (!fxaa_.sceneDepth.image) {
-        LOG_ERROR("FXAA: failed to create scene depth image");
-        destroyFXAAResources();
-        return false;
-    }
-
-    if (useMsaa) {
-        fxaa_.sceneMsaaColor = createImage(device, alloc, ext.width, ext.height,
-            colorFmt, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, msaa);
-        if (!fxaa_.sceneMsaaColor.image) {
-            LOG_ERROR("FXAA: failed to create MSAA color image");
-            destroyFXAAResources();
-            return false;
-        }
-        if (useDepthResolve) {
-            fxaa_.sceneDepthResolve = createImage(device, alloc, ext.width, ext.height,
-                depthFmt, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
-            if (!fxaa_.sceneDepthResolve.image) {
-                LOG_ERROR("FXAA: failed to create depth resolve image");
-                destroyFXAAResources();
-                return false;
-            }
-        }
-    }
-
-    // Framebuffer — same attachment layout as main render pass
-    VkImageView fbAttachments[4]{};
-    uint32_t fbCount;
-    if (useMsaa) {
-        fbAttachments[0] = fxaa_.sceneMsaaColor.imageView;
-        fbAttachments[1] = fxaa_.sceneDepth.imageView;
-        fbAttachments[2] = fxaa_.sceneColor.imageView;  // resolve target
-        fbCount = 3;
-        if (useDepthResolve) {
-            fbAttachments[3] = fxaa_.sceneDepthResolve.imageView;
-            fbCount = 4;
-        }
-    } else {
-        fbAttachments[0] = fxaa_.sceneColor.imageView;
-        fbAttachments[1] = fxaa_.sceneDepth.imageView;
-        fbCount = 2;
-    }
-
-    VkFramebufferCreateInfo fbInfo{};
-    fbInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
-    fbInfo.renderPass = vkCtx_->getImGuiRenderPass();
-    fbInfo.attachmentCount = fbCount;
-    fbInfo.pAttachments = fbAttachments;
-    fbInfo.width = ext.width;
-    fbInfo.height = ext.height;
-    fbInfo.layers = 1;
-    if (vkCreateFramebuffer(device, &fbInfo, nullptr, &fxaa_.sceneFramebuffer) != VK_SUCCESS) {
-        LOG_ERROR("FXAA: failed to create scene framebuffer");
-        destroyFXAAResources();
-        return false;
-    }
-
-    // Sampler
-    VkSamplerCreateInfo samplerInfo{};
-    samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
-    samplerInfo.minFilter = VK_FILTER_LINEAR;
-    samplerInfo.magFilter = VK_FILTER_LINEAR;
-    samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-    samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-    samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-    samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
-    fxaa_.sceneSampler = vkCtx_->getOrCreateSampler(samplerInfo);
-    if (fxaa_.sceneSampler == VK_NULL_HANDLE) {
-        LOG_ERROR("FXAA: failed to create sampler");
-        destroyFXAAResources();
-        return false;
-    }
-
-    // Descriptor set layout: binding 0 = combined image sampler
-    VkDescriptorSetLayoutBinding binding{};
-    binding.binding = 0;
-    binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-    binding.descriptorCount = 1;
-    binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
-    VkDescriptorSetLayoutCreateInfo layoutInfo{};
-    layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
-    layoutInfo.bindingCount = 1;
-    layoutInfo.pBindings = &binding;
-    vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &fxaa_.descSetLayout);
-
-    constexpr uint32_t setCount = FXAAState::DESC_SET_COUNT;
-    VkDescriptorPoolSize poolSize{};
-    poolSize.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-    poolSize.descriptorCount = setCount;
-    VkDescriptorPoolCreateInfo poolInfo{};
-    poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-    poolInfo.maxSets = setCount;
-    poolInfo.poolSizeCount = 1;
-    poolInfo.pPoolSizes = &poolSize;
-    vkCreateDescriptorPool(device, &poolInfo, nullptr, &fxaa_.descPool);
-
-    VkDescriptorSetLayout layouts[setCount];
-    for (uint32_t i = 0; i < setCount; i++) layouts[i] = fxaa_.descSetLayout;
-    VkDescriptorSetAllocateInfo dsAllocInfo{};
-    dsAllocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
-    dsAllocInfo.descriptorPool = fxaa_.descPool;
-    dsAllocInfo.descriptorSetCount = setCount;
-    dsAllocInfo.pSetLayouts = layouts;
-    vkAllocateDescriptorSets(device, &dsAllocInfo, fxaa_.descSet);
-
-    // Bind the resolved 1x sceneColor to all per-frame sets
-    VkDescriptorImageInfo imgInfo{};
-    imgInfo.sampler = fxaa_.sceneSampler;
-    imgInfo.imageView = fxaa_.sceneColor.imageView;
-    imgInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-    for (uint32_t i = 0; i < setCount; i++) {
-        VkWriteDescriptorSet write{};
-        write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-        write.dstSet = fxaa_.descSet[i];
-        write.dstBinding = 0;
-        write.descriptorCount = 1;
-        write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-        write.pImageInfo = &imgInfo;
-        vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
-    }
-
-    // Pipeline layout — push constant holds vec4(rcpFrame.xy, sharpness, pad)
-    VkPushConstantRange pc{};
-    pc.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
-    pc.offset = 0;
-    pc.size = 16;  // vec4
-    VkPipelineLayoutCreateInfo plCI{};
-    plCI.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
-    plCI.setLayoutCount = 1;
-    plCI.pSetLayouts = &fxaa_.descSetLayout;
-    plCI.pushConstantRangeCount = 1;
-    plCI.pPushConstantRanges = &pc;
-    vkCreatePipelineLayout(device, &plCI, nullptr, &fxaa_.pipelineLayout);
-
-    // FXAA pipeline — fullscreen triangle into the swapchain render pass
-    // Uses VK_SAMPLE_COUNT_1_BIT: it always runs after MSAA resolve.
-    VkShaderModule vertMod, fragMod;
-    if (!vertMod.loadFromFile(device, "assets/shaders/postprocess.vert.spv") ||
-        !fragMod.loadFromFile(device, "assets/shaders/fxaa.frag.spv")) {
-        LOG_ERROR("FXAA: failed to load shaders");
-        destroyFXAAResources();
-        return false;
-    }
-
-    fxaa_.pipeline = PipelineBuilder()
-        .setShaders(vertMod.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
-                    fragMod.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
-        .setVertexInput({}, {})
-        .setTopology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
-        .setRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE)
-        .setNoDepthTest()
-        .setColorBlendAttachment(PipelineBuilder::blendDisabled())
-        .setMultisample(VK_SAMPLE_COUNT_1_BIT)  // swapchain pass is always 1x
-        .setLayout(fxaa_.pipelineLayout)
-        .setRenderPass(vkCtx_->getImGuiRenderPass())
-        .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-        .build(device, vkCtx_->getPipelineCache());
-
-    vertMod.destroy();
-    fragMod.destroy();
-
-    if (!fxaa_.pipeline) {
-        LOG_ERROR("FXAA: failed to create pipeline");
-        destroyFXAAResources();
-        return false;
-    }
-
-    LOG_INFO("FXAA: initialized successfully");
-    return true;
-}
-
-void PostProcessPipeline::destroyFXAAResources() {
-    if (!vkCtx_) return;
-    VkDevice device = vkCtx_->getDevice();
-    VmaAllocator alloc = vkCtx_->getAllocator();
-    vkDeviceWaitIdle(device);
-
-    if (fxaa_.pipeline)       { vkDestroyPipeline(device, fxaa_.pipeline, nullptr);             fxaa_.pipeline = VK_NULL_HANDLE; }
-    if (fxaa_.pipelineLayout) { vkDestroyPipelineLayout(device, fxaa_.pipelineLayout, nullptr); fxaa_.pipelineLayout = VK_NULL_HANDLE; }
-    if (fxaa_.descPool)       { vkDestroyDescriptorPool(device, fxaa_.descPool, nullptr);       fxaa_.descPool = VK_NULL_HANDLE; for (auto& s : fxaa_.descSet) s = VK_NULL_HANDLE; }
-    if (fxaa_.descSetLayout)  { vkDestroyDescriptorSetLayout(device, fxaa_.descSetLayout, nullptr); fxaa_.descSetLayout = VK_NULL_HANDLE; }
-    if (fxaa_.sceneFramebuffer) { vkDestroyFramebuffer(device, fxaa_.sceneFramebuffer, nullptr); fxaa_.sceneFramebuffer = VK_NULL_HANDLE; }
-    fxaa_.sceneSampler = VK_NULL_HANDLE; // Owned by VkContext sampler cache
-    destroyImage(device, alloc, fxaa_.sceneDepthResolve);
-    destroyImage(device, alloc, fxaa_.sceneMsaaColor);
-    destroyImage(device, alloc, fxaa_.sceneDepth);
-    destroyImage(device, alloc, fxaa_.sceneColor);
-}
-
-void PostProcessPipeline::renderFXAAPass() {
-    if (!fxaa_.pipeline || currentCmd_ == VK_NULL_HANDLE) return;
-    VkExtent2D ext = vkCtx_->getSwapchainExtent();
-
-    uint32_t fi = vkCtx_->getCurrentFrame();
-    vkCmdBindPipeline(currentCmd_, VK_PIPELINE_BIND_POINT_GRAPHICS, fxaa_.pipeline);
-    vkCmdBindDescriptorSets(currentCmd_, VK_PIPELINE_BIND_POINT_GRAPHICS,
-                            fxaa_.pipelineLayout, 0, 1, &fxaa_.descSet[fi], 0, nullptr);
-
-    // Pass rcpFrame + sharpness + effect flag (vec4, 16 bytes).
-    // When FSR2/FSR3 is active alongside FXAA, forward FSR2's sharpness so the
-    // post-FXAA unsharp-mask step restores the crispness that FXAA's blur removes.
-    float sharpness = fsr2_.enabled ? fsr2_.sharpness : 0.0f;
-    float pc[4] = {
-        1.0f / static_cast<float>(ext.width),
-        1.0f / static_cast<float>(ext.height),
-        sharpness,
-        0.0f
-    };
-    vkCmdPushConstants(currentCmd_, fxaa_.pipelineLayout,
-                       VK_SHADER_STAGE_FRAGMENT_BIT, 0, 16, pc);
-
-    vkCmdDraw(currentCmd_, 3, 1, 0, 0);  // fullscreen triangle
-}
-
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/quest_marker_renderer.cpp b/src/rendering/quest_marker_renderer.cpp
index b9cb209a..bc481d5a 100644
--- a/src/rendering/quest_marker_renderer.cpp
+++ b/src/rendering/quest_marker_renderer.cpp
@@ -1,6 +1,5 @@
 #include "rendering/quest_marker_renderer.hpp"
 #include "rendering/camera.hpp"
-#include "rendering/frustum.hpp"
 #include "rendering/vk_context.hpp"
 #include "rendering/vk_shader.hpp"
 #include "rendering/vk_pipeline.hpp"
@@ -18,9 +17,8 @@ namespace wowee { namespace rendering {
 
 // Push constant layout matching quest_marker.vert.glsl / quest_marker.frag.glsl
 struct QuestMarkerPushConstants {
-    glm::mat4 model;   // 64 bytes, used by vertex shader
-    float alpha;        // 4 bytes, used by fragment shader
-    float grayscale;    // 4 bytes: 0=colour, 1=desaturated (trivial quests)
+    glm::mat4 model;  // 64 bytes, used by vertex shader
+    float alpha;       // 4 bytes, used by fragment shader
 };
 
 QuestMarkerRenderer::QuestMarkerRenderer() {
@@ -114,7 +112,7 @@ bool QuestMarkerRenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFr
         .setLayout(pipelineLayout_)
         .setRenderPass(vkCtx_->getImGuiRenderPass())
         .setDynamicStates(dynamicStates)
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     vertModule.destroy();
     fragModule.destroy();
@@ -193,12 +191,9 @@ void QuestMarkerRenderer::recreatePipelines() {
     }
 
     VkShaderModule vertModule;
+    vertModule.loadFromFile(device, "assets/shaders/quest_marker.vert.spv");
     VkShaderModule fragModule;
-    if (!vertModule.loadFromFile(device, "assets/shaders/quest_marker.vert.spv") ||
-        !fragModule.loadFromFile(device, "assets/shaders/quest_marker.frag.spv")) {
-        LOG_ERROR("QuestMarkerRenderer::recreatePipelines: failed to load shader modules");
-        return;
-    }
+    fragModule.loadFromFile(device, "assets/shaders/quest_marker.frag.spv");
 
     VkPipelineShaderStageCreateInfo vertStage = vertModule.stageInfo(VK_SHADER_STAGE_VERTEX_BIT);
     VkPipelineShaderStageCreateInfo fragStage = fragModule.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT);
@@ -236,7 +231,7 @@ void QuestMarkerRenderer::recreatePipelines() {
         .setLayout(pipelineLayout_)
         .setRenderPass(vkCtx_->getImGuiRenderPass())
         .setDynamicStates(dynamicStates)
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     vertModule.destroy();
     fragModule.destroy();
@@ -345,9 +340,8 @@ void QuestMarkerRenderer::loadTextures(pipeline::AssetManager* assetManager) {
     }
 }
 
-void QuestMarkerRenderer::setMarker(uint64_t guid, const glm::vec3& position, int markerType,
-                                    float boundingHeight, float grayscale) {
-    markers_[guid] = {position, markerType, boundingHeight, grayscale};
+void QuestMarkerRenderer::setMarker(uint64_t guid, const glm::vec3& position, int markerType, float boundingHeight) {
+    markers_[guid] = {position, markerType, boundingHeight};
 }
 
 void QuestMarkerRenderer::removeMarker(uint64_t guid) {
@@ -378,10 +372,6 @@ void QuestMarkerRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSe
     glm::mat4 view = camera.getViewMatrix();
     glm::vec3 cameraPos = camera.getPosition();
 
-    // Extract frustum planes for visibility testing
-    Frustum frustum;
-    frustum.extractFromMatrix(camera.getViewProjectionMatrix());
-
     // Get camera right and up vectors for billboarding
     glm::vec3 cameraRight = glm::vec3(view[0][0], view[1][0], view[2][0]);
     glm::vec3 cameraUp = glm::vec3(view[0][1], view[1][1], view[2][1]);
@@ -406,11 +396,6 @@ void QuestMarkerRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSe
         glm::vec3 toCamera = cameraPos - marker.position;
         float distSq = glm::dot(toCamera, toCamera);
         if (distSq > CULL_DIST_SQ) continue;
-
-        // Frustum cull quest markers (small sphere for icon)
-        constexpr float markerCullRadius = 0.5f;
-        if (!frustum.intersectsSphere(marker.position, markerCullRadius)) continue;
-
         float dist = std::sqrt(distSq);
 
         // Calculate fade alpha
@@ -451,11 +436,10 @@ void QuestMarkerRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSe
         vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout_,
             1, 1, &texDescSets_[marker.type], 0, nullptr);
 
-        // Push constants: model matrix + alpha + grayscale tint
+        // Push constants: model matrix + alpha
         QuestMarkerPushConstants push{};
         push.model = model;
         push.alpha = fadeAlpha;
-        push.grayscale = marker.grayscale;
 
         vkCmdPushConstants(cmd, pipelineLayout_,
             VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
diff --git a/src/rendering/render_graph.cpp b/src/rendering/render_graph.cpp
deleted file mode 100644
index d36d20bc..00000000
--- a/src/rendering/render_graph.cpp
+++ /dev/null
@@ -1,194 +0,0 @@
-#include "rendering/render_graph.hpp"
-#include "core/logger.hpp"
-#include <algorithm>
-#include <unordered_map>
-#include <queue>
-
-namespace wowee {
-namespace rendering {
-
-void RenderGraph::reset() {
-    passes_.clear();
-    executionOrder_.clear();
-    compiled_ = false;
-    // Keep resource registry — resources are stable across frames
-}
-
-RGResource RenderGraph::registerResource(const std::string& name) {
-    // Check for duplicate
-    for (const auto& r : resources_) {
-        if (r.name == name) return {r.id};
-    }
-    uint32_t id = nextResourceId_++;
-    resources_.push_back({name, id});
-    return {id};
-}
-
-RGResource RenderGraph::findResource(const std::string& name) const {
-    for (const auto& r : resources_) {
-        if (r.name == name) return {r.id};
-    }
-    return {}; // invalid
-}
-
-void RenderGraph::addPass(const std::string& name,
-                          const std::vector<RGResource>& inputs,
-                          const std::vector<RGResource>& outputs,
-                          std::function<void(VkCommandBuffer cmd)> execute) {
-    RGPass pass;
-    pass.name = name;
-    pass.inputs = inputs;
-    pass.outputs = outputs;
-    pass.execute = std::move(execute);
-    pass.enabled = true;
-    passes_.push_back(std::move(pass));
-}
-
-void RenderGraph::setPassEnabled(const std::string& name, bool enabled) {
-    for (auto& pass : passes_) {
-        if (pass.name == name) {
-            pass.enabled = enabled;
-            return;
-        }
-    }
-}
-
-void RenderGraph::compile() {
-    topologicalSort();
-    compiled_ = true;
-}
-
-void RenderGraph::topologicalSort() {
-    const uint32_t n = static_cast<uint32_t>(passes_.size());
-    if (n == 0) { executionOrder_.clear(); return; }
-
-    // Build adjacency: if pass A outputs resource R and pass B inputs resource R,
-    // then A must execute before B (edge A → B).
-    // Map: resource id → index of pass that produces it
-    std::unordered_map<uint32_t, uint32_t> producer;
-    for (uint32_t i = 0; i < n; ++i) {
-        for (const auto& out : passes_[i].outputs) {
-            producer[out.id] = i;
-        }
-    }
-
-    // Build in-degree and adjacency list
-    std::vector<uint32_t> inDegree(n, 0);
-    std::vector<std::vector<uint32_t>> adj(n);
-
-    for (uint32_t i = 0; i < n; ++i) {
-        for (const auto& inp : passes_[i].inputs) {
-            auto it = producer.find(inp.id);
-            if (it != producer.end() && it->second != i) {
-                adj[it->second].push_back(i);
-                inDegree[i]++;
-            }
-        }
-    }
-
-    // Kahn's algorithm
-    std::queue<uint32_t> queue;
-    for (uint32_t i = 0; i < n; ++i) {
-        if (inDegree[i] == 0) queue.push(i);
-    }
-
-    executionOrder_.clear();
-    executionOrder_.reserve(n);
-
-    while (!queue.empty()) {
-        uint32_t u = queue.front();
-        queue.pop();
-        executionOrder_.push_back(u);
-        for (uint32_t v : adj[u]) {
-            if (--inDegree[v] == 0) queue.push(v);
-        }
-    }
-
-    // If not all passes are in the order, there's a cycle — fall back to insertion order
-    if (executionOrder_.size() != n) {
-        LOG_WARNING("RenderGraph: dependency cycle detected, falling back to insertion order");
-        executionOrder_.clear();
-        for (uint32_t i = 0; i < n; ++i) executionOrder_.push_back(i);
-    }
-}
-
-void RenderGraph::execute(VkCommandBuffer cmd) {
-    if (!compiled_) {
-        LOG_WARNING("RenderGraph::execute called without compile()");
-        compile();
-    }
-
-    for (uint32_t idx : executionOrder_) {
-        const auto& pass = passes_[idx];
-        if (!pass.enabled) continue;
-
-        // Insert image barriers declared for this pass
-        if (!pass.imageBarriers.empty()) {
-            std::vector<VkImageMemoryBarrier> barriers;
-            barriers.reserve(pass.imageBarriers.size());
-
-            VkPipelineStageFlags srcStages = 0;
-            VkPipelineStageFlags dstStages = 0;
-
-            for (const auto& b : pass.imageBarriers) {
-                VkImageMemoryBarrier ib{};
-                ib.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-                ib.oldLayout = b.oldLayout;
-                ib.newLayout = b.newLayout;
-                ib.srcAccessMask = b.srcAccess;
-                ib.dstAccessMask = b.dstAccess;
-                ib.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-                ib.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-                ib.image = b.image;
-                ib.subresourceRange = {b.aspectMask, 0, 1, 0, 1};
-                barriers.push_back(ib);
-                srcStages |= b.srcStage;
-                dstStages |= b.dstStage;
-            }
-
-            vkCmdPipelineBarrier(cmd,
-                srcStages, dstStages,
-                0,
-                0, nullptr,
-                0, nullptr,
-                static_cast<uint32_t>(barriers.size()), barriers.data());
-        }
-
-        // Insert buffer barriers declared for this pass
-        if (!pass.bufferBarriers.empty()) {
-            std::vector<VkBufferMemoryBarrier> barriers;
-            barriers.reserve(pass.bufferBarriers.size());
-
-            VkPipelineStageFlags srcStages = 0;
-            VkPipelineStageFlags dstStages = 0;
-
-            for (const auto& b : pass.bufferBarriers) {
-                VkBufferMemoryBarrier bb{};
-                bb.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
-                bb.srcAccessMask = b.srcAccess;
-                bb.dstAccessMask = b.dstAccess;
-                bb.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-                bb.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-                bb.buffer = b.buffer;
-                bb.offset = b.offset;
-                bb.size = b.size;
-                barriers.push_back(bb);
-                srcStages |= b.srcStage;
-                dstStages |= b.dstStage;
-            }
-
-            vkCmdPipelineBarrier(cmd,
-                srcStages, dstStages,
-                0,
-                0, nullptr,
-                static_cast<uint32_t>(barriers.size()), barriers.data(),
-                0, nullptr);
-        }
-
-        // Execute the pass
-        pass.execute(cmd);
-    }
-}
-
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/renderer.cpp b/src/rendering/renderer.cpp
index 4fb0af07..0fd4beb9 100644
--- a/src/rendering/renderer.cpp
+++ b/src/rendering/renderer.cpp
@@ -1,6 +1,7 @@
 #include "rendering/renderer.hpp"
 #include "rendering/camera.hpp"
 #include "rendering/camera_controller.hpp"
+#include "rendering/scene.hpp"
 #include "rendering/terrain_renderer.hpp"
 #include "rendering/terrain_manager.hpp"
 #include "rendering/performance_hud.hpp"
@@ -11,9 +12,7 @@
 #include "rendering/clouds.hpp"
 #include "rendering/lens_flare.hpp"
 #include "rendering/weather.hpp"
-#include "rendering/lightning.hpp"
 #include "rendering/lighting_manager.hpp"
-#include "core/profiler.hpp"
 #include "rendering/sky_system.hpp"
 #include "rendering/swim_effects.hpp"
 #include "rendering/mount_dust.hpp"
@@ -26,12 +25,14 @@
 #include "rendering/minimap.hpp"
 #include "rendering/world_map.hpp"
 #include "rendering/quest_marker_renderer.hpp"
+#include "rendering/shader.hpp"
 #include "game/game_handler.hpp"
 #include "pipeline/m2_loader.hpp"
 #include <algorithm>
 #include "pipeline/asset_manager.hpp"
 #include "pipeline/dbc_loader.hpp"
 #include "pipeline/dbc_layout.hpp"
+#include "pipeline/m2_loader.hpp"
 #include "pipeline/wmo_loader.hpp"
 #include "pipeline/adt_loader.hpp"
 #include "pipeline/terrain_mesh.hpp"
@@ -40,7 +41,6 @@
 #include "core/logger.hpp"
 #include "game/world.hpp"
 #include "game/zone_manager.hpp"
-#include "audio/audio_coordinator.hpp"
 #include "audio/audio_engine.hpp"
 #include "audio/music_manager.hpp"
 #include "audio/footstep_manager.hpp"
@@ -58,10 +58,6 @@
 #include "rendering/vk_pipeline.hpp"
 #include "rendering/vk_utils.hpp"
 #include "rendering/amd_fsr3_runtime.hpp"
-#include "rendering/spell_visual_system.hpp"
-#include "rendering/post_process_pipeline.hpp"
-#include "rendering/animation_controller.hpp"
-#include "rendering/render_graph.hpp"
 #include <imgui.h>
 #include <imgui_impl_vulkan.h>
 #include <glm/gtc/matrix_transform.hpp>
@@ -70,10 +66,6 @@
 #include <cctype>
 #include <cmath>
 #include <chrono>
-#include <filesystem>
-
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-#include "stb_image_write.h"
 #include <cstdlib>
 #include <optional>
 #include <unordered_map>
@@ -89,6 +81,21 @@
 namespace wowee {
 namespace rendering {
 
+struct EmoteInfo {
+    uint32_t animId = 0;
+    uint32_t dbcId = 0;  // EmotesText.dbc record ID (for CMSG_TEXT_EMOTE)
+    bool loop = false;
+    std::string textNoTarget;       // sender sees, no target: "You dance."
+    std::string textTarget;         // sender sees, with target: "You dance with %s."
+    std::string othersNoTarget;     // others see, no target: "%s dances."
+    std::string othersTarget;       // others see, with target: "%s dances with %s."
+    std::string command;
+};
+
+static std::unordered_map<std::string, EmoteInfo> EMOTE_TABLE;
+static std::unordered_map<uint32_t, const EmoteInfo*> EMOTE_BY_DBCID; // reverse lookup: dbcId → EmoteInfo*
+static bool emoteTableLoaded = false;
+
 static bool envFlagEnabled(const char* key, bool defaultValue) {
     const char* raw = std::getenv(key);
     if (!raw || !*raw) return defaultValue;
@@ -108,15 +115,180 @@ static int envIntOrDefault(const char* key, int defaultValue) {
     return static_cast<int>(n);
 }
 
+
+
+static std::vector<std::string> parseEmoteCommands(const std::string& raw) {
+    std::vector<std::string> out;
+    std::string cur;
+    for (char c : raw) {
+        if (std::isalnum(static_cast<unsigned char>(c)) || c == '_') {
+            cur.push_back(static_cast<char>(std::tolower(static_cast<unsigned char>(c))));
+        } else if (!cur.empty()) {
+            out.push_back(cur);
+            cur.clear();
+        }
+    }
+    if (!cur.empty()) out.push_back(cur);
+    return out;
+}
+
+static bool isLoopingEmote(const std::string& command) {
+    static const std::unordered_set<std::string> kLooping = {
+        "dance",
+        "train",
+    };
+    return kLooping.find(command) != kLooping.end();
+}
+
+static void loadFallbackEmotes() {
+    if (!EMOTE_TABLE.empty()) return;
+    EMOTE_TABLE = {
+        {"wave",    {67,  0, false, "You wave.", "You wave at %s.", "%s waves.", "%s waves at %s.", "wave"}},
+        {"bow",     {66,  0, false, "You bow down graciously.", "You bow down before %s.", "%s bows down graciously.", "%s bows down before %s.", "bow"}},
+        {"laugh",   {70,  0, false, "You laugh.", "You laugh at %s.", "%s laughs.", "%s laughs at %s.", "laugh"}},
+        {"point",   {84,  0, false, "You point over yonder.", "You point at %s.", "%s points over yonder.", "%s points at %s.", "point"}},
+        {"cheer",   {68,  0, false, "You cheer!", "You cheer at %s.", "%s cheers!", "%s cheers at %s.", "cheer"}},
+        {"dance",   {69,  0, true,  "You burst into dance.", "You dance with %s.", "%s bursts into dance.", "%s dances with %s.", "dance"}},
+        {"kneel",   {75,  0, false, "You kneel down.", "You kneel before %s.", "%s kneels down.", "%s kneels before %s.", "kneel"}},
+        {"applaud", {80,  0, false, "You applaud. Bravo!", "You applaud at %s. Bravo!", "%s applauds. Bravo!", "%s applauds at %s. Bravo!", "applaud"}},
+        {"shout",   {81,  0, false, "You shout.", "You shout at %s.", "%s shouts.", "%s shouts at %s.", "shout"}},
+        {"chicken", {78,  0, false, "With arms flapping, you strut around. Cluck, Cluck, Chicken!",
+                     "With arms flapping, you strut around %s. Cluck, Cluck, Chicken!",
+                     "%s struts around. Cluck, Cluck, Chicken!", "%s struts around %s. Cluck, Cluck, Chicken!", "chicken"}},
+        {"cry",     {77,  0, false, "You cry.", "You cry on %s's shoulder.", "%s cries.", "%s cries on %s's shoulder.", "cry"}},
+        {"kiss",    {76,  0, false, "You blow a kiss into the wind.", "You blow a kiss to %s.", "%s blows a kiss into the wind.", "%s blows a kiss to %s.", "kiss"}},
+        {"roar",    {74,  0, false, "You roar with bestial vigor. So fierce!", "You roar with bestial vigor at %s. So fierce!", "%s roars with bestial vigor. So fierce!", "%s roars with bestial vigor at %s. So fierce!", "roar"}},
+        {"salute",  {113, 0, false, "You salute.", "You salute %s with respect.", "%s salutes.", "%s salutes %s with respect.", "salute"}},
+        {"rude",    {73,  0, false, "You make a rude gesture.", "You make a rude gesture at %s.", "%s makes a rude gesture.", "%s makes a rude gesture at %s.", "rude"}},
+        {"flex",    {82,  0, false, "You flex your muscles. Oooooh so strong!", "You flex at %s. Oooooh so strong!", "%s flexes. Oooooh so strong!", "%s flexes at %s. Oooooh so strong!", "flex"}},
+        {"shy",     {83,  0, false, "You smile shyly.", "You smile shyly at %s.", "%s smiles shyly.", "%s smiles shyly at %s.", "shy"}},
+        {"beg",     {79,  0, false, "You beg everyone around you. How pathetic.", "You beg %s. How pathetic.", "%s begs everyone around. How pathetic.", "%s begs %s. How pathetic.", "beg"}},
+        {"eat",     {61,  0, false, "You begin to eat.", "You begin to eat in front of %s.", "%s begins to eat.", "%s begins to eat in front of %s.", "eat"}},
+    };
+}
+
+static std::string replacePlaceholders(const std::string& text, const std::string* targetName) {
+    if (text.empty()) return text;
+    std::string out;
+    out.reserve(text.size() + 16);
+    for (size_t i = 0; i < text.size(); ++i) {
+        if (text[i] == '%' && i + 1 < text.size() && text[i + 1] == 's') {
+            if (targetName && !targetName->empty()) out += *targetName;
+            i++;
+        } else {
+            out.push_back(text[i]);
+        }
+    }
+    return out;
+}
+
+static void loadEmotesFromDbc() {
+    if (emoteTableLoaded) return;
+    emoteTableLoaded = true;
+
+    auto* assetManager = core::Application::getInstance().getAssetManager();
+    if (!assetManager) {
+        LOG_WARNING("Emotes: no AssetManager");
+        loadFallbackEmotes();
+        return;
+    }
+
+    auto emotesTextDbc = assetManager->loadDBC("EmotesText.dbc");
+    auto emotesTextDataDbc = assetManager->loadDBC("EmotesTextData.dbc");
+    if (!emotesTextDbc || !emotesTextDataDbc || !emotesTextDbc->isLoaded() || !emotesTextDataDbc->isLoaded()) {
+        LOG_WARNING("Emotes: DBCs not available (EmotesText/EmotesTextData)");
+        loadFallbackEmotes();
+        return;
+    }
+
+    const auto* activeLayout = pipeline::getActiveDBCLayout();
+    const auto* etdL = activeLayout ? activeLayout->getLayout("EmotesTextData") : nullptr;
+    const auto* emL  = activeLayout ? activeLayout->getLayout("Emotes") : nullptr;
+    const auto* etL  = activeLayout ? activeLayout->getLayout("EmotesText") : nullptr;
+
+    std::unordered_map<uint32_t, std::string> textData;
+    textData.reserve(emotesTextDataDbc->getRecordCount());
+    for (uint32_t r = 0; r < emotesTextDataDbc->getRecordCount(); ++r) {
+        uint32_t id = emotesTextDataDbc->getUInt32(r, etdL ? (*etdL)["ID"] : 0);
+        std::string text = emotesTextDataDbc->getString(r, etdL ? (*etdL)["Text"] : 1);
+        if (!text.empty()) textData.emplace(id, std::move(text));
+    }
+
+    std::unordered_map<uint32_t, uint32_t> emoteIdToAnim;
+    if (auto emotesDbc = assetManager->loadDBC("Emotes.dbc"); emotesDbc && emotesDbc->isLoaded()) {
+        emoteIdToAnim.reserve(emotesDbc->getRecordCount());
+        for (uint32_t r = 0; r < emotesDbc->getRecordCount(); ++r) {
+            uint32_t emoteId = emotesDbc->getUInt32(r, emL ? (*emL)["ID"] : 0);
+            uint32_t animId = emotesDbc->getUInt32(r, emL ? (*emL)["AnimID"] : 2);
+            if (animId != 0) emoteIdToAnim[emoteId] = animId;
+        }
+    }
+
+    EMOTE_TABLE.clear();
+    EMOTE_TABLE.reserve(emotesTextDbc->getRecordCount());
+    for (uint32_t r = 0; r < emotesTextDbc->getRecordCount(); ++r) {
+        uint32_t recordId = emotesTextDbc->getUInt32(r, etL ? (*etL)["ID"] : 0);
+        std::string cmdRaw = emotesTextDbc->getString(r, etL ? (*etL)["Command"] : 1);
+        if (cmdRaw.empty()) continue;
+
+        uint32_t emoteRef = emotesTextDbc->getUInt32(r, etL ? (*etL)["EmoteRef"] : 2);
+        uint32_t animId = 0;
+        auto animIt = emoteIdToAnim.find(emoteRef);
+        if (animIt != emoteIdToAnim.end()) {
+            animId = animIt->second;
+        } else {
+            animId = emoteRef;  // fallback if EmotesText stores animation id directly
+        }
+
+        uint32_t senderTargetTextId = emotesTextDbc->getUInt32(r, etL ? (*etL)["SenderTargetTextID"] : 5);
+        uint32_t senderNoTargetTextId = emotesTextDbc->getUInt32(r, etL ? (*etL)["SenderNoTargetTextID"] : 9);
+        uint32_t othersTargetTextId = emotesTextDbc->getUInt32(r, etL ? (*etL)["OthersTargetTextID"] : 3);
+        uint32_t othersNoTargetTextId = emotesTextDbc->getUInt32(r, etL ? (*etL)["OthersNoTargetTextID"] : 7);
+
+        std::string textTarget, textNoTarget, oTarget, oNoTarget;
+        if (auto it = textData.find(senderTargetTextId); it != textData.end()) textTarget = it->second;
+        if (auto it = textData.find(senderNoTargetTextId); it != textData.end()) textNoTarget = it->second;
+        if (auto it = textData.find(othersTargetTextId); it != textData.end()) oTarget = it->second;
+        if (auto it = textData.find(othersNoTargetTextId); it != textData.end()) oNoTarget = it->second;
+
+        for (const std::string& cmd : parseEmoteCommands(cmdRaw)) {
+            if (cmd.empty()) continue;
+            EmoteInfo info;
+            info.animId = animId;
+            info.dbcId = recordId;
+            info.loop = isLoopingEmote(cmd);
+            info.textNoTarget = textNoTarget;
+            info.textTarget = textTarget;
+            info.othersNoTarget = oNoTarget;
+            info.othersTarget = oTarget;
+            info.command = cmd;
+            EMOTE_TABLE.emplace(cmd, std::move(info));
+        }
+    }
+
+    if (EMOTE_TABLE.empty()) {
+        LOG_WARNING("Emotes: DBC loaded but no commands parsed, using fallback list");
+        loadFallbackEmotes();
+    } else {
+        LOG_INFO("Emotes: loaded ", EMOTE_TABLE.size(), " commands from DBC");
+    }
+
+    // Build reverse lookup by dbcId (only first command per emote needed)
+    EMOTE_BY_DBCID.clear();
+    for (auto& [cmd, info] : EMOTE_TABLE) {
+        if (info.dbcId != 0) {
+            EMOTE_BY_DBCID.emplace(info.dbcId, &info);
+        }
+    }
+}
+
 Renderer::Renderer() = default;
 Renderer::~Renderer() = default;
 
 bool Renderer::createPerFrameResources() {
     VkDevice device = vkCtx->getDevice();
 
-    // --- Create per-frame shadow depth images (one per in-flight frame) ---
-    // Each frame slot has its own depth image so that frame N's shadow read and
-    // frame N+1's shadow write cannot race on the same image.
+    // --- Create shadow depth image ---
     VkImageCreateInfo imgCI{};
     imgCI.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
     imgCI.imageType = VK_IMAGE_TYPE_2D;
@@ -129,30 +301,26 @@ bool Renderer::createPerFrameResources() {
     imgCI.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
     VmaAllocationCreateInfo imgAllocCI{};
     imgAllocCI.usage = VMA_MEMORY_USAGE_GPU_ONLY;
-    for (uint32_t i = 0; i < MAX_FRAMES; i++) {
-        if (vmaCreateImage(vkCtx->getAllocator(), &imgCI, &imgAllocCI,
-                &shadowDepthImage[i], &shadowDepthAlloc[i], nullptr) != VK_SUCCESS) {
-            LOG_ERROR("Failed to create shadow depth image [", i, "]");
-            return false;
-        }
-        shadowDepthLayout_[i] = VK_IMAGE_LAYOUT_UNDEFINED;
+    if (vmaCreateImage(vkCtx->getAllocator(), &imgCI, &imgAllocCI,
+            &shadowDepthImage, &shadowDepthAlloc, nullptr) != VK_SUCCESS) {
+        LOG_ERROR("Failed to create shadow depth image");
+        return false;
     }
+    shadowDepthLayout_ = VK_IMAGE_LAYOUT_UNDEFINED;
 
-    // --- Create per-frame shadow depth image views ---
+    // --- Create shadow depth image view ---
     VkImageViewCreateInfo viewCI{};
     viewCI.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+    viewCI.image = shadowDepthImage;
     viewCI.viewType = VK_IMAGE_VIEW_TYPE_2D;
     viewCI.format = VK_FORMAT_D32_SFLOAT;
     viewCI.subresourceRange = {VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1};
-    for (uint32_t i = 0; i < MAX_FRAMES; i++) {
-        viewCI.image = shadowDepthImage[i];
-        if (vkCreateImageView(device, &viewCI, nullptr, &shadowDepthView[i]) != VK_SUCCESS) {
-            LOG_ERROR("Failed to create shadow depth image view [", i, "]");
-            return false;
-        }
+    if (vkCreateImageView(device, &viewCI, nullptr, &shadowDepthView) != VK_SUCCESS) {
+        LOG_ERROR("Failed to create shadow depth image view");
+        return false;
     }
 
-    // --- Create shadow sampler (shared — read-only, no per-frame needed) ---
+    // --- Create shadow sampler ---
     VkSamplerCreateInfo sampCI{};
     sampCI.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
     sampCI.magFilter = VK_FILTER_LINEAR;
@@ -164,8 +332,7 @@ bool Renderer::createPerFrameResources() {
     sampCI.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
     sampCI.compareEnable = VK_TRUE;
     sampCI.compareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
-    shadowSampler = vkCtx->getOrCreateSampler(sampCI);
-    if (shadowSampler == VK_NULL_HANDLE) {
+    if (vkCreateSampler(device, &sampCI, nullptr, &shadowSampler) != VK_SUCCESS) {
         LOG_ERROR("Failed to create shadow sampler");
         return false;
     }
@@ -210,20 +377,18 @@ bool Renderer::createPerFrameResources() {
         return false;
     }
 
-    // --- Create per-frame shadow framebuffers ---
+    // --- Create shadow framebuffer ---
     VkFramebufferCreateInfo fbCI{};
     fbCI.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
     fbCI.renderPass = shadowRenderPass;
     fbCI.attachmentCount = 1;
+    fbCI.pAttachments = &shadowDepthView;
     fbCI.width = SHADOW_MAP_SIZE;
     fbCI.height = SHADOW_MAP_SIZE;
     fbCI.layers = 1;
-    for (uint32_t i = 0; i < MAX_FRAMES; i++) {
-        fbCI.pAttachments = &shadowDepthView[i];
-        if (vkCreateFramebuffer(device, &fbCI, nullptr, &shadowFramebuffer[i]) != VK_SUCCESS) {
-            LOG_ERROR("Failed to create shadow framebuffer [", i, "]");
-            return false;
-        }
+    if (vkCreateFramebuffer(device, &fbCI, nullptr, &shadowFramebuffer) != VK_SUCCESS) {
+        LOG_ERROR("Failed to create shadow framebuffer");
+        return false;
     }
 
     // --- Create descriptor set layout for set 0 (per-frame UBO + shadow sampler) ---
@@ -250,13 +415,13 @@ bool Renderer::createPerFrameResources() {
     // --- Create descriptor pool for UBO + image sampler (normal frames + reflection) ---
     VkDescriptorPoolSize poolSizes[2]{};
     poolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-    poolSizes[0].descriptorCount = MAX_FRAMES * 2; // normal frames + reflection frames
+    poolSizes[0].descriptorCount = MAX_FRAMES + 1; // +1 for reflection perFrame UBO
     poolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-    poolSizes[1].descriptorCount = MAX_FRAMES * 2;
+    poolSizes[1].descriptorCount = MAX_FRAMES + 1;
 
     VkDescriptorPoolCreateInfo poolInfo{};
     poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-    poolInfo.maxSets = MAX_FRAMES * 2; // normal frames + reflection frames
+    poolInfo.maxSets = MAX_FRAMES + 1; // +1 for reflection descriptor set
     poolInfo.poolSizeCount = 2;
     poolInfo.pPoolSizes = poolSizes;
 
@@ -305,7 +470,7 @@ bool Renderer::createPerFrameResources() {
 
         VkDescriptorImageInfo shadowImgInfo{};
         shadowImgInfo.sampler = shadowSampler;
-        shadowImgInfo.imageView = shadowDepthView[i];
+        shadowImgInfo.imageView = shadowDepthView;
         shadowImgInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 
         VkWriteDescriptorSet writes[2]{};
@@ -344,48 +509,42 @@ bool Renderer::createPerFrameResources() {
         }
         reflPerFrameUBOMapped = mapInfo.pMappedData;
 
-        VkDescriptorSetLayout layouts[MAX_FRAMES];
-        for (uint32_t i = 0; i < MAX_FRAMES; i++) layouts[i] = perFrameSetLayout;
-
         VkDescriptorSetAllocateInfo setAlloc{};
         setAlloc.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
         setAlloc.descriptorPool = sceneDescriptorPool;
-        setAlloc.descriptorSetCount = MAX_FRAMES;
-        setAlloc.pSetLayouts = layouts;
+        setAlloc.descriptorSetCount = 1;
+        setAlloc.pSetLayouts = &perFrameSetLayout;
 
-        if (vkAllocateDescriptorSets(device, &setAlloc, reflPerFrameDescSet) != VK_SUCCESS) {
-            LOG_ERROR("Failed to allocate reflection per-frame descriptor sets");
+        if (vkAllocateDescriptorSets(device, &setAlloc, &reflPerFrameDescSet) != VK_SUCCESS) {
+            LOG_ERROR("Failed to allocate reflection per-frame descriptor set");
             return false;
         }
 
-        // Bind each reflection descriptor to the same UBO but its own frame's shadow view
-        for (uint32_t i = 0; i < MAX_FRAMES; i++) {
-            VkDescriptorBufferInfo descBuf{};
-            descBuf.buffer = reflPerFrameUBO;
-            descBuf.offset = 0;
-            descBuf.range = sizeof(GPUPerFrameData);
+        VkDescriptorBufferInfo descBuf{};
+        descBuf.buffer = reflPerFrameUBO;
+        descBuf.offset = 0;
+        descBuf.range = sizeof(GPUPerFrameData);
 
-            VkDescriptorImageInfo shadowImgInfo{};
-            shadowImgInfo.sampler = shadowSampler;
-            shadowImgInfo.imageView = shadowDepthView[i];
-            shadowImgInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+        VkDescriptorImageInfo shadowImgInfo{};
+        shadowImgInfo.sampler = shadowSampler;
+        shadowImgInfo.imageView = shadowDepthView;
+        shadowImgInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 
-            VkWriteDescriptorSet writes[2]{};
-            writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-            writes[0].dstSet = reflPerFrameDescSet[i];
-            writes[0].dstBinding = 0;
-            writes[0].descriptorCount = 1;
-            writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-            writes[0].pBufferInfo = &descBuf;
-            writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-            writes[1].dstSet = reflPerFrameDescSet[i];
-            writes[1].dstBinding = 1;
-            writes[1].descriptorCount = 1;
-            writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-            writes[1].pImageInfo = &shadowImgInfo;
+        VkWriteDescriptorSet writes[2]{};
+        writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+        writes[0].dstSet = reflPerFrameDescSet;
+        writes[0].dstBinding = 0;
+        writes[0].descriptorCount = 1;
+        writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+        writes[0].pBufferInfo = &descBuf;
+        writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+        writes[1].dstSet = reflPerFrameDescSet;
+        writes[1].dstBinding = 1;
+        writes[1].descriptorCount = 1;
+        writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+        writes[1].pImageInfo = &shadowImgInfo;
 
-            vkUpdateDescriptorSets(device, 2, writes, 0, nullptr);
-        }
+        vkUpdateDescriptorSets(device, 2, writes, 0, nullptr);
     }
 
     LOG_INFO("Per-frame Vulkan resources created (shadow map ", SHADOW_MAP_SIZE, "x", SHADOW_MAP_SIZE, ")");
@@ -417,15 +576,13 @@ void Renderer::destroyPerFrameResources() {
         perFrameSetLayout = VK_NULL_HANDLE;
     }
 
-    // Destroy per-frame shadow resources
-    for (uint32_t i = 0; i < MAX_FRAMES; i++) {
-        if (shadowFramebuffer[i]) { vkDestroyFramebuffer(device, shadowFramebuffer[i], nullptr); shadowFramebuffer[i] = VK_NULL_HANDLE; }
-        if (shadowDepthView[i]) { vkDestroyImageView(device, shadowDepthView[i], nullptr); shadowDepthView[i] = VK_NULL_HANDLE; }
-        if (shadowDepthImage[i]) { vmaDestroyImage(vkCtx->getAllocator(), shadowDepthImage[i], shadowDepthAlloc[i]); shadowDepthImage[i] = VK_NULL_HANDLE; shadowDepthAlloc[i] = VK_NULL_HANDLE; }
-        shadowDepthLayout_[i] = VK_IMAGE_LAYOUT_UNDEFINED;
-    }
+    // Destroy shadow resources
+    if (shadowFramebuffer) { vkDestroyFramebuffer(device, shadowFramebuffer, nullptr); shadowFramebuffer = VK_NULL_HANDLE; }
     if (shadowRenderPass) { vkDestroyRenderPass(device, shadowRenderPass, nullptr); shadowRenderPass = VK_NULL_HANDLE; }
-    shadowSampler = VK_NULL_HANDLE; // Owned by VkContext sampler cache
+    if (shadowDepthView) { vkDestroyImageView(device, shadowDepthView, nullptr); shadowDepthView = VK_NULL_HANDLE; }
+    if (shadowDepthImage) { vmaDestroyImage(vkCtx->getAllocator(), shadowDepthImage, shadowDepthAlloc); shadowDepthImage = VK_NULL_HANDLE; shadowDepthAlloc = VK_NULL_HANDLE; }
+    if (shadowSampler) { vkDestroySampler(device, shadowSampler, nullptr); shadowSampler = VK_NULL_HANDLE; }
+    shadowDepthLayout_ = VK_IMAGE_LAYOUT_UNDEFINED;
 }
 
 void Renderer::updatePerFrameUBO() {
@@ -465,9 +622,7 @@ void Renderer::updatePerFrameUBO() {
     }
 
     currentFrameData.lightSpaceMatrix = lightSpaceMatrix;
-    // Scale shadow bias proportionally to ortho extent to avoid acne at close range / gaps at far range
-    float shadowBias = glm::clamp(0.8f * (shadowDistance_ / 300.0f), 0.0f, 1.0f);
-    currentFrameData.shadowParams = glm::vec4(shadowsEnabled ? 1.0f : 0.0f, shadowBias, 0.0f, 0.0f);
+    currentFrameData.shadowParams = glm::vec4(shadowsEnabled ? 1.0f : 0.0f, 0.8f, 0.0f, 0.0f);
 
     // Player water ripple data: pack player XY into shadowParams.zw, ripple strength into fogParams.w
     if (cameraController) {
@@ -503,6 +658,9 @@ bool Renderer::initialize(core::Window* win) {
     cameraController->setUseWoWSpeed(true);  // Use realistic WoW movement speed
     cameraController->setMouseSensitivity(0.15f);
 
+    // Create scene
+    scene = std::make_unique<Scene>();
+
     // Create performance HUD
     performanceHUD = std::make_unique<PerformanceHUD>();
     performanceHUD->setPosition(PerformanceHUD::Position::TOP_LEFT);
@@ -531,9 +689,6 @@ bool Renderer::initialize(core::Window* win) {
     weather = std::make_unique<Weather>();
     weather->initialize(vkCtx, perFrameSetLayout);
 
-    lightning = std::make_unique<Lightning>();
-    lightning->initialize(vkCtx, perFrameSetLayout);
-
     swimEffects = std::make_unique<SwimEffects>();
     swimEffects->initialize(vkCtx, perFrameSetLayout);
 
@@ -545,8 +700,6 @@ bool Renderer::initialize(core::Window* win) {
 
     levelUpEffect = std::make_unique<LevelUpEffect>();
 
-    questMarkerRenderer = std::make_unique<QuestMarkerRenderer>();
-
     LOG_INFO("Vulkan sub-renderers initialized (Phase 3)");
 
     // LightingManager doesn't use GL — initialize for data-only use
@@ -560,27 +713,28 @@ bool Renderer::initialize(core::Window* win) {
         zoneManager->enrichFromDBC(assetManager);
     }
 
-    // Audio is now owned by AudioCoordinator (created by Application).
-    // Renderer receives AudioCoordinator* via setAudioCoordinator().
+    // Initialize AudioEngine (singleton)
+    if (!audio::AudioEngine::instance().initialize()) {
+        LOG_WARNING("Failed to initialize AudioEngine - audio will be disabled");
+    }
+
+    // Create music manager (initialized later with asset manager)
+    musicManager = std::make_unique<audio::MusicManager>();
+    footstepManager = std::make_unique<audio::FootstepManager>();
+    activitySoundManager = std::make_unique<audio::ActivitySoundManager>();
+    mountSoundManager = std::make_unique<audio::MountSoundManager>();
+    npcVoiceManager = std::make_unique<audio::NpcVoiceManager>();
+    ambientSoundManager = std::make_unique<audio::AmbientSoundManager>();
+    uiSoundManager = std::make_unique<audio::UiSoundManager>();
+    combatSoundManager = std::make_unique<audio::CombatSoundManager>();
+    spellSoundManager = std::make_unique<audio::SpellSoundManager>();
+    movementSoundManager = std::make_unique<audio::MovementSoundManager>();
 
     // Create secondary command buffer resources for multithreaded rendering
     if (!createSecondaryCommandResources()) {
         LOG_WARNING("Failed to create secondary command buffers — falling back to single-threaded rendering");
     }
 
-    // Create PostProcessPipeline (§4.3 — owns FSR/FXAA/FSR2/FSR3/brightness)
-    postProcessPipeline_ = std::make_unique<PostProcessPipeline>();
-    postProcessPipeline_->initialize(vkCtx);
-
-    // Create render graph and register virtual resources
-    renderGraph_ = std::make_unique<RenderGraph>();
-    renderGraph_->registerResource("shadow_depth");
-    renderGraph_->registerResource("reflection_texture");
-    renderGraph_->registerResource("cull_visibility");
-    renderGraph_->registerResource("scene_color");
-    renderGraph_->registerResource("scene_depth");
-    renderGraph_->registerResource("final_image");
-
     LOG_INFO("Renderer initialized");
     return true;
 }
@@ -636,11 +790,6 @@ void Renderer::shutdown() {
         weather.reset();
     }
 
-    if (lightning) {
-        lightning->shutdown();
-        lightning.reset();
-    }
-
     if (swimEffects) {
         swimEffects->shutdown();
         swimEffects.reset();
@@ -652,29 +801,37 @@ void Renderer::shutdown() {
         characterRenderer.reset();
     }
 
-    // Shutdown AnimationController before renderers it references (§4.2)
-    animationController_.reset();
-
     LOG_WARNING("Renderer::shutdown - wmoRenderer...");
     if (wmoRenderer) {
         wmoRenderer->shutdown();
         wmoRenderer.reset();
     }
 
-    // Shutdown SpellVisualSystem before M2Renderer (it holds M2Renderer pointer) (§4.4)
-    if (spellVisualSystem_) {
-        spellVisualSystem_->shutdown();
-        spellVisualSystem_.reset();
-    }
-
     LOG_WARNING("Renderer::shutdown - m2Renderer...");
     if (m2Renderer) {
         m2Renderer->shutdown();
         m2Renderer.reset();
     }
 
-    // Audio shutdown is handled by AudioCoordinator (owned by Application).
-    audioCoordinator_ = nullptr;
+    LOG_WARNING("Renderer::shutdown - musicManager...");
+    if (musicManager) {
+        musicManager->shutdown();
+        musicManager.reset();
+    }
+    LOG_WARNING("Renderer::shutdown - footstepManager...");
+    if (footstepManager) {
+        footstepManager->shutdown();
+        footstepManager.reset();
+    }
+    LOG_WARNING("Renderer::shutdown - activitySoundManager...");
+    if (activitySoundManager) {
+        activitySoundManager->shutdown();
+        activitySoundManager.reset();
+    }
+
+    LOG_WARNING("Renderer::shutdown - AudioEngine...");
+    // Shutdown AudioEngine singleton
+    audio::AudioEngine::instance().shutdown();
 
     // Cleanup Vulkan selection circle resources
     if (vkCtx) {
@@ -687,20 +844,14 @@ void Renderer::shutdown() {
         if (overlayPipelineLayout) { vkDestroyPipelineLayout(device, overlayPipelineLayout, nullptr); overlayPipelineLayout = VK_NULL_HANDLE; }
     }
 
-    // Shutdown post-process pipeline (FSR/FXAA/FSR2 resources) (§4.3)
-    if (postProcessPipeline_) {
-        postProcessPipeline_->shutdown();
-        postProcessPipeline_.reset();
-    }
-
-    // Destroy render graph
-    renderGraph_.reset();
-
+    destroyFSRResources();
+    destroyFSR2Resources();
     destroyPerFrameResources();
 
     zoneManager.reset();
 
     performanceHUD.reset();
+    scene.reset();
     cameraController.reset();
     camera.reset();
 
@@ -734,7 +885,7 @@ void Renderer::setMsaaSamples(VkSampleCountFlagBits samples) {
     if (!vkCtx) return;
 
     // FSR2 requires non-MSAA render pass — block MSAA changes while FSR2 is active
-    if (postProcessPipeline_ && postProcessPipeline_->isFsr2BlockingMsaa() && samples > VK_SAMPLE_COUNT_1_BIT) return;
+    if (fsr2_.enabled && samples > VK_SAMPLE_COUNT_1_BIT) return;
 
     // Clamp to device maximum
     VkSampleCountFlagBits maxSamples = vkCtx->getMaxUsableSampleCount();
@@ -751,16 +902,11 @@ void Renderer::applyMsaaChange() {
     VkSampleCountFlagBits samples = pendingMsaaSamples_;
     msaaChangePending_ = false;
 
-    // FSR2 requires non-MSAA render pass — if FSR2 was enabled after the MSAA
-    // change was queued (startup race), force 1x to avoid framebuffer mismatch.
-    if (samples > VK_SAMPLE_COUNT_1_BIT &&
-        postProcessPipeline_ && postProcessPipeline_->isFsr2BlockingMsaa()) {
-        samples = VK_SAMPLE_COUNT_1_BIT;
-    }
-
     VkSampleCountFlagBits current = vkCtx->getMsaaSamples();
     if (samples == current) return;
 
+    LOG_INFO("Changing MSAA from ", static_cast<int>(current), "x to ", static_cast<int>(samples), "x");
+
     // Single GPU wait — all subsequent operations are CPU-side object creation
     vkDeviceWaitIdle(vkCtx->getDevice());
 
@@ -769,7 +915,7 @@ void Renderer::applyMsaaChange() {
     if (!vkCtx->recreateSwapchain(window->getWidth(), window->getHeight())) {
         LOG_ERROR("MSAA change failed — reverting to 1x");
         vkCtx->setMsaaSamples(VK_SAMPLE_COUNT_1_BIT);
-        (void)vkCtx->recreateSwapchain(window->getWidth(), window->getHeight());
+        vkCtx->recreateSwapchain(window->getWidth(), window->getHeight());
     }
 
     // Recreate all sub-renderer pipelines (they embed sample count from render pass)
@@ -783,7 +929,6 @@ void Renderer::applyMsaaChange() {
     if (characterRenderer) characterRenderer->recreatePipelines();
     if (questMarkerRenderer) questMarkerRenderer->recreatePipelines();
     if (weather) weather->recreatePipelines();
-    if (lightning) lightning->recreatePipelines();
     if (swimEffects) swimEffects->recreatePipelines();
     if (mountDust) mountDust->recreatePipelines();
     if (chargeEffect) chargeEffect->recreatePipelines();
@@ -803,7 +948,8 @@ void Renderer::applyMsaaChange() {
     VkDevice device = vkCtx->getDevice();
     if (selCirclePipeline) { vkDestroyPipeline(device, selCirclePipeline, nullptr); selCirclePipeline = VK_NULL_HANDLE; }
     if (overlayPipeline) { vkDestroyPipeline(device, overlayPipeline, nullptr); overlayPipeline = VK_NULL_HANDLE; }
-    if (postProcessPipeline_) postProcessPipeline_->destroyAllResources(); // Will be lazily recreated in beginFrame()
+    if (fsr_.sceneFramebuffer) destroyFSRResources();  // Will be lazily recreated in beginFrame()
+    if (fsr2_.sceneFramebuffer) destroyFSR2Resources();
 
     // Reinitialize ImGui Vulkan backend with new MSAA sample count
     ImGui_ImplVulkan_Shutdown();
@@ -819,16 +965,12 @@ void Renderer::applyMsaaChange() {
     initInfo.ImageCount = vkCtx->getSwapchainImageCount();
     initInfo.PipelineInfoMain.RenderPass = vkCtx->getImGuiRenderPass();
     initInfo.PipelineInfoMain.MSAASamples = vkCtx->getMsaaSamples();
-    initInfo.CheckVkResultFn = [](VkResult err) {
-        if (err != VK_SUCCESS)
-            LOG_ERROR("ImGui Vulkan error: ", static_cast<int>(err));
-    };
     ImGui_ImplVulkan_Init(&initInfo);
 
+    LOG_INFO("MSAA change complete");
 }
 
 void Renderer::beginFrame() {
-    ZoneScopedN("Renderer::beginFrame");
     if (!vkCtx) return;
     if (vkCtx->isDeviceLost()) return;
 
@@ -837,18 +979,48 @@ void Renderer::beginFrame() {
         applyMsaaChange();
     }
 
-    // Post-process resource management (§4.3 — delegates to PostProcessPipeline)
-    if (postProcessPipeline_) postProcessPipeline_->manageResources();
+    // FSR resource management (safe: between frames, no command buffer in flight)
+    if (fsr_.needsRecreate && fsr_.sceneFramebuffer) {
+        destroyFSRResources();
+        fsr_.needsRecreate = false;
+        if (!fsr_.enabled) LOG_INFO("FSR: disabled");
+    }
+    if (fsr_.enabled && !fsr2_.enabled && !fsr_.sceneFramebuffer) {
+        if (!initFSRResources()) {
+            LOG_ERROR("FSR: initialization failed, disabling");
+            fsr_.enabled = false;
+        }
+    }
+
+    // FSR 2.2 resource management
+    if (fsr2_.needsRecreate && fsr2_.sceneFramebuffer) {
+        destroyFSR2Resources();
+        fsr2_.needsRecreate = false;
+        if (!fsr2_.enabled) LOG_INFO("FSR2: disabled");
+    }
+    if (fsr2_.enabled && !fsr2_.sceneFramebuffer) {
+        if (!initFSR2Resources()) {
+            LOG_ERROR("FSR2: initialization failed, disabling");
+            fsr2_.enabled = false;
+        }
+    }
 
     // Handle swapchain recreation if needed
     if (vkCtx->isSwapchainDirty()) {
-        (void)vkCtx->recreateSwapchain(window->getWidth(), window->getHeight());
+        vkCtx->recreateSwapchain(window->getWidth(), window->getHeight());
         // Rebuild water resources that reference swapchain extent/views
         if (waterRenderer) {
             waterRenderer->recreatePipelines();
         }
-        // Recreate post-process resources for new swapchain dimensions
-        if (postProcessPipeline_) postProcessPipeline_->handleSwapchainResize();
+        // Recreate FSR resources for new swapchain dimensions
+        if (fsr_.enabled && !fsr2_.enabled) {
+            destroyFSRResources();
+            initFSRResources();
+        }
+        if (fsr2_.enabled) {
+            destroyFSR2Resources();
+            initFSR2Resources();
+        }
     }
 
     // Acquire swapchain image and begin command buffer
@@ -858,34 +1030,86 @@ void Renderer::beginFrame() {
         return;
     }
 
-    // FSR2 jitter pattern (§4.3 — delegates to PostProcessPipeline)
-    if (postProcessPipeline_ && camera) postProcessPipeline_->applyJitter(camera.get());
-
-    // Compute fresh shadow matrix BEFORE UBO update so shaders get current-frame data.
-    lightSpaceMatrix = computeLightSpaceMatrix();
+    // FSR2 jitter pattern.
+    if (fsr2_.enabled && fsr2_.sceneFramebuffer && camera) {
+        if (!fsr2_.useAmdBackend) {
+            camera->setJitter(0.0f, 0.0f);
+        } else {
+#if WOWEE_HAS_AMD_FSR2
+            // AMD-recommended jitter sequence in pixel space, converted to NDC projection offset.
+            int32_t phaseCount = ffxFsr2GetJitterPhaseCount(
+                static_cast<int32_t>(fsr2_.internalWidth),
+                static_cast<int32_t>(vkCtx->getSwapchainExtent().width));
+            float jitterX = 0.0f;
+            float jitterY = 0.0f;
+            if (phaseCount > 0 &&
+                ffxFsr2GetJitterOffset(&jitterX, &jitterY, static_cast<int32_t>(fsr2_.frameIndex % static_cast<uint32_t>(phaseCount)), phaseCount) == FFX_OK) {
+                float ndcJx = (2.0f * jitterX) / static_cast<float>(fsr2_.internalWidth);
+                float ndcJy = (2.0f * jitterY) / static_cast<float>(fsr2_.internalHeight);
+                // Keep projection jitter and FSR dispatch jitter in sync.
+                camera->setJitter(fsr2_.jitterSign * ndcJx, fsr2_.jitterSign * ndcJy);
+            } else {
+                camera->setJitter(0.0f, 0.0f);
+            }
+#else
+            const float jitterScale = 0.5f;
+            float jx = (halton(fsr2_.frameIndex + 1, 2) - 0.5f) * 2.0f * jitterScale / static_cast<float>(fsr2_.internalWidth);
+            float jy = (halton(fsr2_.frameIndex + 1, 3) - 0.5f) * 2.0f * jitterScale / static_cast<float>(fsr2_.internalHeight);
+            camera->setJitter(fsr2_.jitterSign * jx, fsr2_.jitterSign * jy);
+#endif
+        }
+    }
 
     // Update per-frame UBO with current camera/lighting state
     updatePerFrameUBO();
 
-    // --- Off-screen pre-passes ---
-    // Build frame graph: registers pre-passes as graph nodes with dependencies.
-    // compile() topologically sorts; execute() runs them with auto barriers.
-    buildFrameGraph(nullptr);
-    if (renderGraph_) {
-        renderGraph_->execute(currentCmd);
+    // GPU crash diagnostic: skip all pre-passes to isolate crash source
+    static const bool skipPrePasses = (std::getenv("WOWEE_SKIP_PREPASSES") != nullptr);
+
+    if (!skipPrePasses) {
+    // --- Off-screen pre-passes (before main render pass) ---
+    // Minimap composite (renders 3x3 tile grid into 768x768 render target)
+    if (minimap && minimap->isEnabled() && camera) {
+        glm::vec3 minimapCenter = camera->getPosition();
+        if (cameraController && cameraController->isThirdPerson())
+            minimapCenter = characterPosition;
+        minimap->compositePass(currentCmd, minimapCenter);
+    }
+    // World map composite (renders zone tiles into 1024x768 render target)
+    if (worldMap) {
+        worldMap->compositePass(currentCmd);
     }
 
+    // Character preview composite passes
+    for (auto* preview : activePreviews_) {
+        if (preview && preview->isModelLoaded()) {
+            preview->compositePass(currentCmd, vkCtx->getCurrentFrame());
+        }
+    }
+
+    // Shadow pre-pass (before main render pass)
+    if (shadowsEnabled && shadowDepthImage != VK_NULL_HANDLE) {
+        renderShadowPass();
+    }
+
+    // Water reflection pre-pass (renders scene from mirrored camera into 512x512 texture)
+    renderReflectionPass();
+    } // !skipPrePasses
+
     // --- Begin render pass ---
-    // Select framebuffer: PP off-screen target or swapchain (§4.3 — PostProcessPipeline)
+    // If FSR is enabled, render scene to off-screen target at reduced resolution.
+    // Otherwise, render directly to swapchain.
     VkRenderPassBeginInfo rpInfo{};
     rpInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
     rpInfo.renderPass = vkCtx->getImGuiRenderPass();
 
     VkExtent2D renderExtent;
-    VkFramebuffer ppFB = postProcessPipeline_ ? postProcessPipeline_->getSceneFramebuffer() : VK_NULL_HANDLE;
-    if (ppFB != VK_NULL_HANDLE) {
-        rpInfo.framebuffer = ppFB;
-        renderExtent = postProcessPipeline_->getSceneRenderExtent();
+    if (fsr2_.enabled && fsr2_.sceneFramebuffer) {
+        rpInfo.framebuffer = fsr2_.sceneFramebuffer;
+        renderExtent = { fsr2_.internalWidth, fsr2_.internalHeight };
+    } else if (fsr_.enabled && fsr_.sceneFramebuffer) {
+        rpInfo.framebuffer = fsr_.sceneFramebuffer;
+        renderExtent = { fsr_.internalWidth, fsr_.internalHeight };
     } else {
         rpInfo.framebuffer = vkCtx->getSwapchainFramebuffers()[currentImageIndex];
         renderExtent = vkCtx->getSwapchainExtent();
@@ -934,36 +1158,147 @@ void Renderer::beginFrame() {
 }
 
 void Renderer::endFrame() {
-    ZoneScopedN("Renderer::endFrame");
     if (!vkCtx || currentCmd == VK_NULL_HANDLE) return;
 
-    // Track whether a post-processing path switched to an INLINE render pass.
-    // beginFrame() may have started the scene pass with SECONDARY_COMMAND_BUFFERS;
-    // post-proc paths end it and begin a new INLINE pass for the swapchain output.
-    endFrameInlineMode_ = false;
+    if (fsr2_.enabled && fsr2_.sceneFramebuffer) {
+        // End the off-screen scene render pass
+        vkCmdEndRenderPass(currentCmd);
 
-    // Post-process execution (§4.3 — delegates to PostProcessPipeline)
-    if (postProcessPipeline_) {
-        endFrameInlineMode_ = postProcessPipeline_->executePostProcessing(
-            currentCmd, currentImageIndex, camera.get(), lastDeltaTime_);
+        if (fsr2_.useAmdBackend) {
+            // Compute passes: motion vectors -> temporal accumulation
+            dispatchMotionVectors();
+            if (fsr2_.amdFsr3FramegenEnabled && fsr2_.amdFsr3FramegenRuntimeReady) {
+                dispatchAmdFsr3Framegen();
+                if (!fsr2_.amdFsr3FramegenRuntimeActive) {
+                    dispatchAmdFsr2();
+                }
+            } else {
+                dispatchAmdFsr2();
+            }
+
+            // Transition post-FSR input for sharpen pass.
+            if (fsr2_.amdFsr3FramegenRuntimeActive && fsr2_.framegenOutput.image) {
+                transitionImageLayout(currentCmd, fsr2_.framegenOutput.image,
+                    VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+                    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
+                fsr2_.framegenOutputValid = true;
+            } else {
+                transitionImageLayout(currentCmd, fsr2_.history[fsr2_.currentHistory].image,
+                    VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+                    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
+            }
+        } else {
+            transitionImageLayout(currentCmd, fsr2_.sceneColor.image,
+                VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
+        }
+
+        // Begin swapchain render pass at full resolution for sharpening + ImGui
+        VkRenderPassBeginInfo rpInfo{};
+        rpInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+        rpInfo.renderPass = vkCtx->getImGuiRenderPass();
+        rpInfo.framebuffer = vkCtx->getSwapchainFramebuffers()[currentImageIndex];
+        rpInfo.renderArea.offset = {0, 0};
+        rpInfo.renderArea.extent = vkCtx->getSwapchainExtent();
+
+        bool msaaOn = (vkCtx->getMsaaSamples() > VK_SAMPLE_COUNT_1_BIT);
+        VkClearValue clearValues[4]{};
+        clearValues[0].color = {{0.0f, 0.0f, 0.0f, 1.0f}};
+        clearValues[1].depthStencil = {1.0f, 0};
+        clearValues[2].color = {{0.0f, 0.0f, 0.0f, 1.0f}};
+        clearValues[3].depthStencil = {1.0f, 0};
+        rpInfo.clearValueCount = msaaOn ? (vkCtx->getDepthResolveImageView() ? 4u : 3u) : 2u;
+        rpInfo.pClearValues = clearValues;
+
+        vkCmdBeginRenderPass(currentCmd, &rpInfo, VK_SUBPASS_CONTENTS_INLINE);
+
+        VkExtent2D ext = vkCtx->getSwapchainExtent();
+        VkViewport vp{};
+        vp.width = static_cast<float>(ext.width);
+        vp.height = static_cast<float>(ext.height);
+        vp.maxDepth = 1.0f;
+        vkCmdSetViewport(currentCmd, 0, 1, &vp);
+        VkRect2D sc{};
+        sc.extent = ext;
+        vkCmdSetScissor(currentCmd, 0, 1, &sc);
+
+        // Draw RCAS sharpening from accumulated history buffer
+        renderFSR2Sharpen();
+
+        // Maintain frame bookkeeping
+        fsr2_.prevViewProjection = camera->getViewProjectionMatrix();
+        fsr2_.prevJitter = camera->getJitter();
+        camera->clearJitter();
+        if (fsr2_.useAmdBackend) {
+            fsr2_.currentHistory = 1 - fsr2_.currentHistory;
+        }
+        fsr2_.frameIndex = (fsr2_.frameIndex + 1) % 256;  // Wrap to keep Halton values well-distributed
+
+    } else if (fsr_.enabled && fsr_.sceneFramebuffer) {
+        // End the off-screen scene render pass
+        vkCmdEndRenderPass(currentCmd);
+
+        // Transition scene color (1x resolve/color target): PRESENT_SRC_KHR → SHADER_READ_ONLY
+        // The render pass finalLayout puts the resolve/color attachment in PRESENT_SRC_KHR
+        transitionImageLayout(currentCmd, fsr_.sceneColor.image,
+            VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+            VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+            VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
+
+        // Begin swapchain render pass at full resolution
+        VkRenderPassBeginInfo rpInfo{};
+        rpInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+        rpInfo.renderPass = vkCtx->getImGuiRenderPass();
+        rpInfo.framebuffer = vkCtx->getSwapchainFramebuffers()[currentImageIndex];
+        rpInfo.renderArea.offset = {0, 0};
+        rpInfo.renderArea.extent = vkCtx->getSwapchainExtent();
+
+        // Clear values must match the render pass attachment count
+        bool msaaOn = (vkCtx->getMsaaSamples() > VK_SAMPLE_COUNT_1_BIT);
+        VkClearValue clearValues[4]{};
+        clearValues[0].color = {{0.0f, 0.0f, 0.0f, 1.0f}};
+        clearValues[1].depthStencil = {1.0f, 0};
+        clearValues[2].color = {{0.0f, 0.0f, 0.0f, 1.0f}};
+        clearValues[3].depthStencil = {1.0f, 0};
+        if (msaaOn) {
+            bool depthRes = (vkCtx->getDepthResolveImageView() != VK_NULL_HANDLE);
+            rpInfo.clearValueCount = depthRes ? 4 : 3;
+        } else {
+            rpInfo.clearValueCount = 2;
+        }
+        rpInfo.pClearValues = clearValues;
+
+        vkCmdBeginRenderPass(currentCmd, &rpInfo, VK_SUBPASS_CONTENTS_INLINE);
+
+        // Set full-resolution viewport and scissor
+        VkExtent2D ext = vkCtx->getSwapchainExtent();
+        VkViewport vp{};
+        vp.width = static_cast<float>(ext.width);
+        vp.height = static_cast<float>(ext.height);
+        vp.maxDepth = 1.0f;
+        vkCmdSetViewport(currentCmd, 0, 1, &vp);
+        VkRect2D sc{};
+        sc.extent = ext;
+        vkCmdSetScissor(currentCmd, 0, 1, &sc);
+
+        // Draw FSR upscale fullscreen quad
+        renderFSRUpscale();
     }
 
-    // ImGui rendering — must respect the subpass contents mode of the
-    // CURRENT render pass. Post-processing paths (FSR/FXAA) end the scene
-    // pass and begin a new INLINE pass; if none ran, we're still inside the
-    // scene pass which may be SECONDARY_COMMAND_BUFFERS when parallel recording
-    // is active. Track this via endFrameInlineMode_ (set true by any post-proc
-    // path that started an INLINE render pass).
-    if (parallelRecordingEnabled_ && !endFrameInlineMode_) {
-        // Still in the scene pass with SECONDARY_COMMAND_BUFFERS — record
-        // ImGui into a secondary command buffer.
+    // ImGui rendering — must respect subpass contents mode
+    if (!fsr_.enabled && !fsr2_.enabled && parallelRecordingEnabled_) {
+        // Scene pass was begun with VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
+        // so ImGui must be recorded into a secondary command buffer.
         VkCommandBuffer imguiCmd = beginSecondary(SEC_IMGUI);
         setSecondaryViewportScissor(imguiCmd);
         ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), imguiCmd);
         vkEndCommandBuffer(imguiCmd);
         vkCmdExecuteCommands(currentCmd, 1, &imguiCmd);
     } else {
-        // INLINE render pass (post-process pass or non-parallel mode).
+        // FSR swapchain pass uses INLINE mode; non-parallel also uses INLINE.
         ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), currentCmd);
     }
 
@@ -995,231 +1330,1326 @@ void Renderer::setCharacterFollow(uint32_t instanceId) {
     if (cameraController && instanceId > 0) {
         cameraController->setFollowTarget(&characterPosition);
     }
-    if (animationController_) animationController_->onCharacterFollow(instanceId);
 }
 
 void Renderer::setMounted(uint32_t mountInstId, uint32_t mountDisplayId, float heightOffset, const std::string& modelPath) {
-    if (animationController_) animationController_->setMounted(mountInstId, mountDisplayId, heightOffset, modelPath);
+    mountInstanceId_ = mountInstId;
+    mountHeightOffset_ = heightOffset;
+    mountSeatAttachmentId_ = -1;
+    smoothedMountSeatPos_ = characterPosition;
+    mountSeatSmoothingInit_ = false;
+    mountAction_ = MountAction::None;  // Clear mount action state
+    mountActionPhase_ = 0;
+    charAnimState = CharAnimState::MOUNT;
+    if (cameraController) {
+        cameraController->setMounted(true);
+        cameraController->setMountHeightOffset(heightOffset);
+    }
+
+    // Debug: dump available mount animations
+    if (characterRenderer && mountInstId > 0) {
+        characterRenderer->dumpAnimations(mountInstId);
+    }
+
+    // Discover mount animation capabilities (property-based, not hardcoded IDs)
+    LOG_DEBUG("=== Mount Animation Dump (Display ID ", mountDisplayId, ") ===");
+    characterRenderer->dumpAnimations(mountInstId);
+
+    // Get all sequences for property-based analysis
+    std::vector<pipeline::M2Sequence> sequences;
+    if (!characterRenderer->getAnimationSequences(mountInstId, sequences)) {
+        LOG_WARNING("Failed to get animation sequences for mount, using fallback IDs");
+        sequences.clear();
+    }
+
+    // Helper: ID-based fallback finder
+    auto findFirst = [&](std::initializer_list<uint32_t> candidates) -> uint32_t {
+        for (uint32_t id : candidates) {
+            if (characterRenderer->hasAnimation(mountInstId, id)) {
+                return id;
+            }
+        }
+        return 0;
+    };
+
+    // Property-based jump animation discovery with chain-based scoring
+    auto discoverJumpSet = [&]() {
+        // Debug: log all sequences for analysis
+        LOG_DEBUG("=== Full sequence table for mount ===");
+        for (const auto& seq : sequences) {
+            LOG_DEBUG("SEQ id=", seq.id,
+                     " dur=", seq.duration,
+                     " flags=0x", std::hex, seq.flags, std::dec,
+                     " moveSpd=", seq.movingSpeed,
+                     " blend=", seq.blendTime,
+                     " next=", seq.nextAnimation,
+                     " alias=", seq.aliasNext);
+        }
+        LOG_DEBUG("=== End sequence table ===");
+
+        // Known combat/bad animation IDs to avoid
+        std::set<uint32_t> forbiddenIds = {53, 54, 16};  // jumpkick, attack
+
+        auto scoreNear = [](int a, int b) -> int {
+            int d = std::abs(a - b);
+            return (d <= 8) ? (20 - d) : 0; // within 8 IDs gets points
+        };
+
+        auto isForbidden = [&](uint32_t id) {
+            return forbiddenIds.count(id) != 0;
+        };
+
+        auto findSeqById = [&](uint32_t id) -> const pipeline::M2Sequence* {
+            for (const auto& s : sequences) {
+                if (s.id == id) return &s;
+            }
+            return nullptr;
+        };
+
+        uint32_t runId = findFirst({5, 4});
+        uint32_t standId = findFirst({0});
+
+        // Step A: Find loop candidates
+        std::vector<uint32_t> loops;
+        for (const auto& seq : sequences) {
+            if (isForbidden(seq.id)) continue;
+            // Bit 0x01 NOT set = loops (0x20, 0x60), bit 0x01 set = non-looping (0x21, 0x61)
+            bool isLoop = (seq.flags & 0x01) == 0;
+            if (isLoop && seq.duration >= 350 && seq.duration <= 1000 &&
+                seq.id != runId && seq.id != standId) {
+                loops.push_back(seq.id);
+            }
+        }
+
+        // Choose loop: prefer one near known classic IDs (38), else best duration
+        uint32_t loop = 0;
+        if (!loops.empty()) {
+            uint32_t best = loops[0];
+            int bestScore = -999;
+            for (uint32_t id : loops) {
+                int sc = 0;
+                sc += scoreNear((int)id, 38);  // classic hint
+                const auto* s = findSeqById(id);
+                if (s) sc += (s->duration >= 500 && s->duration <= 800) ? 5 : 0;
+                if (sc > bestScore) {
+                    bestScore = sc;
+                    best = id;
+                }
+            }
+            loop = best;
+        }
+
+        // Step B: Score start/end candidates
+        uint32_t start = 0, end = 0;
+        int bestStart = -999, bestEnd = -999;
+
+        for (const auto& seq : sequences) {
+            if (isForbidden(seq.id)) continue;
+            // Only consider non-looping animations for start/end
+            bool isLoop = (seq.flags & 0x01) == 0;
+            if (isLoop) continue;
+
+            // Start window
+            if (seq.duration >= 450 && seq.duration <= 1100) {
+                int sc = 0;
+                if (loop) sc += scoreNear((int)seq.id, (int)loop);
+                // Chain bonus: if this start points at loop or near it
+                if (loop && (seq.nextAnimation == (int16_t)loop || seq.aliasNext == loop)) sc += 30;
+                if (loop && scoreNear(seq.nextAnimation, (int)loop) > 0) sc += 10;
+                // Penalize "stop/brake-ish": very long blendTime can be a stop transition
+                if (seq.blendTime > 400) sc -= 5;
+
+                if (sc > bestStart) {
+                    bestStart = sc;
+                    start = seq.id;
+                }
+            }
+
+            // End window
+            if (seq.duration >= 650 && seq.duration <= 1600) {
+                int sc = 0;
+                if (loop) sc += scoreNear((int)seq.id, (int)loop);
+                // Chain bonus: end often points to run/stand or has no next
+                if (seq.nextAnimation == (int16_t)runId || seq.nextAnimation == (int16_t)standId) sc += 10;
+                if (seq.nextAnimation < 0) sc += 5; // no chain sometimes = terminal
+                if (sc > bestEnd) {
+                    bestEnd = sc;
+                    end = seq.id;
+                }
+            }
+        }
+
+        LOG_DEBUG("Property-based jump discovery: start=", start, " loop=", loop, " end=", end,
+                 " scores: start=", bestStart, " end=", bestEnd);
+        return std::make_tuple(start, loop, end);
+    };
+
+    auto [discoveredStart, discoveredLoop, discoveredEnd] = discoverJumpSet();
+
+    // Use discovered animations, fallback to known IDs if discovery fails
+    mountAnims_.jumpStart = discoveredStart > 0 ? discoveredStart : findFirst({40, 37});
+    mountAnims_.jumpLoop  = discoveredLoop > 0 ? discoveredLoop : findFirst({38});
+    mountAnims_.jumpEnd   = discoveredEnd > 0 ? discoveredEnd : findFirst({39});
+    mountAnims_.rearUp    = findFirst({94, 92, 40}); // RearUp/Special
+    mountAnims_.run       = findFirst({5, 4});       // Run/Walk
+    mountAnims_.stand     = findFirst({0});          // Stand (almost always 0)
+
+    // Discover idle fidget animations using proper WoW M2 metadata (frequency, replay timers)
+    mountAnims_.fidgets.clear();
+    core::Logger::getInstance().debug("Scanning for fidget animations in ", sequences.size(), " sequences");
+
+    // DEBUG: Log ALL non-looping, short, stationary animations to identify stamps/tosses
+    core::Logger::getInstance().debug("=== ALL potential fidgets (no metadata filter) ===");
+    for (const auto& seq : sequences) {
+        bool isLoop = (seq.flags & 0x01) == 0;
+        bool isStationary = std::abs(seq.movingSpeed) < 0.05f;
+        bool reasonableDuration = seq.duration >= 400 && seq.duration <= 2500;
+
+        if (!isLoop && reasonableDuration && isStationary) {
+            core::Logger::getInstance().debug("  ALL: id=", seq.id,
+                " dur=", seq.duration, "ms",
+                " freq=", seq.frequency,
+                " replay=", seq.replayMin, "-", seq.replayMax,
+                " flags=0x", std::hex, seq.flags, std::dec,
+                " next=", seq.nextAnimation);
+        }
+    }
+
+    // Proper fidget discovery: frequency > 0 + replay timers indicate random idle animations
+    for (const auto& seq : sequences) {
+        bool isLoop = (seq.flags & 0x01) == 0;
+        bool hasFrequency = seq.frequency > 0;
+        bool hasReplay = seq.replayMax > 0;
+        bool isStationary = std::abs(seq.movingSpeed) < 0.05f;
+        bool reasonableDuration = seq.duration >= 400 && seq.duration <= 2500;
+
+        // Log candidates with metadata
+        if (!isLoop && reasonableDuration && isStationary && (hasFrequency || hasReplay)) {
+            core::Logger::getInstance().debug("  Candidate: id=", seq.id,
+                " dur=", seq.duration, "ms",
+                " freq=", seq.frequency,
+                " replay=", seq.replayMin, "-", seq.replayMax,
+                " next=", seq.nextAnimation,
+                " speed=", seq.movingSpeed);
+        }
+
+        // Exclude known problematic animations: death (5-6), wounds (7-9), combat (16-21), attacks (11-15)
+        bool isDeathOrWound = (seq.id >= 5 && seq.id <= 9);
+        bool isAttackOrCombat = (seq.id >= 11 && seq.id <= 21);
+        bool isSpecial = (seq.id == 2 || seq.id == 3);  // Often aggressive specials
+
+        // Select fidgets: (frequency OR replay) + exclude problematic ID ranges
+        // Relaxed back to OR since some mounts may only have one metadata marker
+        if (!isLoop && (hasFrequency || hasReplay) && isStationary && reasonableDuration &&
+            !isDeathOrWound && !isAttackOrCombat && !isSpecial) {
+            // Bonus: chains back to stand (indicates idle behavior)
+            bool chainsToStand = (seq.nextAnimation == (int16_t)mountAnims_.stand) ||
+                                 (seq.aliasNext == mountAnims_.stand) ||
+                                 (seq.nextAnimation == -1);
+
+            mountAnims_.fidgets.push_back(seq.id);
+            core::Logger::getInstance().debug("  >> Selected fidget: id=", seq.id,
+                (chainsToStand ? " (chains to stand)" : ""));
+        }
+    }
+
+    // Ensure we have fallbacks for movement
+    if (mountAnims_.stand == 0) mountAnims_.stand = 0;  // Force 0 even if not found
+    if (mountAnims_.run == 0) mountAnims_.run = mountAnims_.stand;  // Fallback to stand if no run
+
+    core::Logger::getInstance().debug("Mount animation set: jumpStart=", mountAnims_.jumpStart,
+        " jumpLoop=", mountAnims_.jumpLoop,
+        " jumpEnd=", mountAnims_.jumpEnd,
+        " rearUp=", mountAnims_.rearUp,
+        " run=", mountAnims_.run,
+        " stand=", mountAnims_.stand,
+        " fidgets=", mountAnims_.fidgets.size());
+
+    // Notify mount sound manager
+    if (mountSoundManager) {
+        bool isFlying = taxiFlight_;  // Taxi flights are flying mounts
+        mountSoundManager->onMount(mountDisplayId, isFlying, modelPath);
+    }
 }
 
 void Renderer::clearMount() {
-    if (animationController_) animationController_->clearMount();
+    mountInstanceId_ = 0;
+    mountHeightOffset_ = 0.0f;
+    mountPitch_ = 0.0f;
+    mountRoll_ = 0.0f;
+    mountSeatAttachmentId_ = -1;
+    smoothedMountSeatPos_ = glm::vec3(0.0f);
+    mountSeatSmoothingInit_ = false;
+    mountAction_ = MountAction::None;
+    mountActionPhase_ = 0;
+    charAnimState = CharAnimState::IDLE;
+    if (cameraController) {
+        cameraController->setMounted(false);
+        cameraController->setMountHeightOffset(0.0f);
+    }
+
+    // Notify mount sound manager
+    if (mountSoundManager) {
+        mountSoundManager->onDismount();
+    }
 }
 
+uint32_t Renderer::resolveMeleeAnimId() {
+    if (!characterRenderer || characterInstanceId == 0) {
+        meleeAnimId = 0;
+        meleeAnimDurationMs = 0.0f;
+        return 0;
+    }
 
+    if (meleeAnimId != 0 && characterRenderer->hasAnimation(characterInstanceId, meleeAnimId)) {
+        return meleeAnimId;
+    }
+
+    std::vector<pipeline::M2Sequence> sequences;
+    if (!characterRenderer->getAnimationSequences(characterInstanceId, sequences)) {
+        meleeAnimId = 0;
+        meleeAnimDurationMs = 0.0f;
+        return 0;
+    }
+
+    auto findDuration = [&](uint32_t id) -> float {
+        for (const auto& seq : sequences) {
+            if (seq.id == id && seq.duration > 0) {
+                return static_cast<float>(seq.duration);
+            }
+        }
+        return 0.0f;
+    };
+
+    // Select animation priority based on equipped weapon type
+    // WoW inventory types: 17 = 2H weapon, 13/21 = 1H, 0 = unarmed
+    // WoW anim IDs: 16 = unarmed, 17 = 1H attack, 18 = 2H attack
+    const uint32_t* attackCandidates;
+    size_t candidateCount;
+    static const uint32_t candidates2H[] = {18, 17, 16, 19, 20, 21};
+    static const uint32_t candidates1H[] = {17, 18, 16, 19, 20, 21};
+    static const uint32_t candidatesUnarmed[] = {16, 17, 18, 19, 20, 21};
+    if (equippedWeaponInvType_ == 17) { // INVTYPE_2HWEAPON
+        attackCandidates = candidates2H;
+        candidateCount = 6;
+    } else if (equippedWeaponInvType_ == 0) {
+        attackCandidates = candidatesUnarmed;
+        candidateCount = 6;
+    } else {
+        attackCandidates = candidates1H;
+        candidateCount = 6;
+    }
+    for (size_t ci = 0; ci < candidateCount; ci++) {
+        uint32_t id = attackCandidates[ci];
+        if (characterRenderer->hasAnimation(characterInstanceId, id)) {
+            meleeAnimId = id;
+            meleeAnimDurationMs = findDuration(id);
+            return meleeAnimId;
+        }
+    }
+
+    const uint32_t avoidIds[] = {0, 1, 4, 5, 11, 12, 13, 37, 38, 39, 41, 42, 97};
+    auto isAvoid = [&](uint32_t id) -> bool {
+        for (uint32_t avoid : avoidIds) {
+            if (id == avoid) return true;
+        }
+        return false;
+    };
+
+    uint32_t bestId = 0;
+    uint32_t bestDuration = 0;
+    for (const auto& seq : sequences) {
+        if (seq.duration == 0) continue;
+        if (isAvoid(seq.id)) continue;
+        if (seq.movingSpeed > 0.1f) continue;
+        if (seq.duration < 150 || seq.duration > 2000) continue;
+        if (bestId == 0 || seq.duration < bestDuration) {
+            bestId = seq.id;
+            bestDuration = seq.duration;
+        }
+    }
+
+    if (bestId == 0) {
+        for (const auto& seq : sequences) {
+            if (seq.duration == 0) continue;
+            if (isAvoid(seq.id)) continue;
+            if (bestId == 0 || seq.duration < bestDuration) {
+                bestId = seq.id;
+                bestDuration = seq.duration;
+            }
+        }
+    }
+
+    meleeAnimId = bestId;
+    meleeAnimDurationMs = static_cast<float>(bestDuration);
+    return meleeAnimId;
+}
+
+void Renderer::updateCharacterAnimation() {
+    // WoW WotLK AnimationData.dbc IDs
+    constexpr uint32_t ANIM_STAND      = 0;
+    constexpr uint32_t ANIM_WALK       = 4;
+    constexpr uint32_t ANIM_RUN        = 5;
+    // Candidate locomotion clips by common WotLK IDs.
+    constexpr uint32_t ANIM_STRAFE_RUN_RIGHT  = 92;
+    constexpr uint32_t ANIM_STRAFE_RUN_LEFT   = 93;
+    constexpr uint32_t ANIM_STRAFE_WALK_LEFT  = 11;
+    constexpr uint32_t ANIM_STRAFE_WALK_RIGHT = 12;
+    constexpr uint32_t ANIM_BACKPEDAL         = 13;
+    constexpr uint32_t ANIM_JUMP_START = 37;
+    constexpr uint32_t ANIM_JUMP_MID   = 38;
+    constexpr uint32_t ANIM_JUMP_END   = 39;
+    constexpr uint32_t ANIM_SIT_DOWN   = 97;  // SitGround — transition to sitting
+    constexpr uint32_t ANIM_SITTING    = 97;  // Hold on same animation (no separate idle)
+    constexpr uint32_t ANIM_SWIM_IDLE  = 41;  // Treading water (SwimIdle)
+    constexpr uint32_t ANIM_SWIM       = 42;  // Swimming forward (Swim)
+    constexpr uint32_t ANIM_MOUNT      = 91;  // Seated on mount
+    // Canonical player ready stances (AnimationData.dbc)
+    constexpr uint32_t ANIM_READY_UNARMED = 22;  // ReadyUnarmed
+    constexpr uint32_t ANIM_READY_1H      = 23;  // Ready1H
+    constexpr uint32_t ANIM_READY_2H      = 24;  // Ready2H
+    constexpr uint32_t ANIM_READY_2H_L    = 25;  // Ready2HL (some 2H left-handed rigs)
+    constexpr uint32_t ANIM_FLY_IDLE   = 158; // Flying mount idle/hover
+    constexpr uint32_t ANIM_FLY_FORWARD = 159; // Flying mount forward
+
+    CharAnimState newState = charAnimState;
+
+    bool moving = cameraController->isMoving();
+    bool movingForward = cameraController->isMovingForward();
+    bool movingBackward = cameraController->isMovingBackward();
+    bool autoRunning = cameraController->isAutoRunning();
+    bool strafeLeft = cameraController->isStrafingLeft();
+    bool strafeRight = cameraController->isStrafingRight();
+    // Strafe animation only plays during *pure* strafing (no forward/backward/autorun).
+    // When forward+strafe are both held, the walk/run animation plays — same as the real client.
+    bool pureStrafe = !movingForward && !movingBackward && !autoRunning;
+    bool anyStrafeLeft = strafeLeft && !strafeRight && pureStrafe;
+    bool anyStrafeRight = strafeRight && !strafeLeft && pureStrafe;
+    bool grounded = cameraController->isGrounded();
+    bool jumping = cameraController->isJumping();
+    bool sprinting = cameraController->isSprinting();
+    bool sitting = cameraController->isSitting();
+    bool swim = cameraController->isSwimming();
+    bool forceMelee = meleeSwingTimer > 0.0f && grounded && !swim;
+
+    // When mounted, force MOUNT state and skip normal transitions
+    if (isMounted()) {
+        newState = CharAnimState::MOUNT;
+        charAnimState = newState;
+
+        // Play seated animation on player
+        uint32_t currentAnimId = 0;
+        float currentAnimTimeMs = 0.0f, currentAnimDurationMs = 0.0f;
+        bool haveState = characterRenderer->getAnimationState(characterInstanceId, currentAnimId, currentAnimTimeMs, currentAnimDurationMs);
+        if (!haveState || currentAnimId != ANIM_MOUNT) {
+            characterRenderer->playAnimation(characterInstanceId, ANIM_MOUNT, true);
+        }
+
+        // Sync mount instance position and rotation
+        float mountBob = 0.0f;
+        float mountYawRad = glm::radians(characterYaw);
+        if (mountInstanceId_ > 0) {
+            characterRenderer->setInstancePosition(mountInstanceId_, characterPosition);
+
+            // Procedural lean into turns (ground mounts only, optional enhancement)
+            if (!taxiFlight_ && moving && lastDeltaTime_ > 0.0f) {
+                float currentYawDeg = characterYaw;
+                float turnRate = (currentYawDeg - prevMountYaw_) / lastDeltaTime_;
+                // Normalize to [-180, 180] for wrap-around
+                while (turnRate > 180.0f) turnRate -= 360.0f;
+                while (turnRate < -180.0f) turnRate += 360.0f;
+
+                float targetLean = glm::clamp(turnRate * 0.15f, -0.25f, 0.25f);
+                mountRoll_ = glm::mix(mountRoll_, targetLean, lastDeltaTime_ * 6.0f);
+                prevMountYaw_ = currentYawDeg;
+            } else {
+                // Return to upright when not turning
+                mountRoll_ = glm::mix(mountRoll_, 0.0f, lastDeltaTime_ * 8.0f);
+            }
+
+            // Apply pitch (up/down), roll (banking), and yaw for realistic flight
+            characterRenderer->setInstanceRotation(mountInstanceId_, glm::vec3(mountPitch_, mountRoll_, mountYawRad));
+
+            // Drive mount model animation: idle when still, run when moving
+            auto pickMountAnim = [&](std::initializer_list<uint32_t> candidates, uint32_t fallback) -> uint32_t {
+                for (uint32_t id : candidates) {
+                    if (characterRenderer->hasAnimation(mountInstanceId_, id)) {
+                        return id;
+                    }
+                }
+                return fallback;
+            };
+
+            uint32_t mountAnimId = ANIM_STAND;
+
+            // Get current mount animation state (used throughout)
+            uint32_t curMountAnim = 0;
+            float curMountTime = 0, curMountDur = 0;
+            bool haveMountState = characterRenderer->getAnimationState(mountInstanceId_, curMountAnim, curMountTime, curMountDur);
+
+            // Taxi flight: use flying animations instead of ground movement
+            if (taxiFlight_) {
+                // Log available animations once when taxi starts
+                if (!taxiAnimsLogged_) {
+                    taxiAnimsLogged_ = true;
+                    LOG_INFO("Taxi flight active: mountInstanceId_=", mountInstanceId_,
+                             " curMountAnim=", curMountAnim, " haveMountState=", haveMountState);
+                    std::vector<pipeline::M2Sequence> seqs;
+                    if (characterRenderer->getAnimationSequences(mountInstanceId_, seqs)) {
+                        std::string animList;
+                        for (const auto& s : seqs) {
+                            if (!animList.empty()) animList += ", ";
+                            animList += std::to_string(s.id);
+                        }
+                        LOG_INFO("Taxi mount available animations: [", animList, "]");
+                    }
+                }
+
+                // Try multiple flying animation IDs in priority order:
+                // 159=FlyForward, 158=FlyIdle (WotLK flying mounts)
+                // 234=FlyRun, 229=FlyStand (Vanilla creature fly anims)
+                // 233=FlyWalk, 141=FlyMounted, 369=FlyRun (alternate IDs)
+                // 6=Fly (classic creature fly)
+                // Fallback: Run, then Stand (hover)
+                uint32_t flyAnims[] = {ANIM_FLY_FORWARD, ANIM_FLY_IDLE, 234, 229, 233, 141, 369, 6, ANIM_RUN};
+                mountAnimId = ANIM_STAND; // ultimate fallback: hover/idle
+                for (uint32_t fa : flyAnims) {
+                    if (characterRenderer->hasAnimation(mountInstanceId_, fa)) {
+                        mountAnimId = fa;
+                        break;
+                    }
+                }
+
+                if (!haveMountState || curMountAnim != mountAnimId) {
+                    LOG_INFO("Taxi mount: playing animation ", mountAnimId);
+                    characterRenderer->playAnimation(mountInstanceId_, mountAnimId, true);
+                }
+
+                // Skip all ground mount logic (jumps, fidgets, etc.)
+                goto taxi_mount_done;
+            } else {
+                taxiAnimsLogged_ = false;
+            }
+
+            // Check for jump trigger - use cached per-mount animation IDs
+            if (cameraController->isJumpKeyPressed() && grounded && mountAction_ == MountAction::None) {
+                if (moving && mountAnims_.jumpLoop > 0) {
+                    // Moving: skip JumpStart (looks like stopping), go straight to airborne loop
+                    LOG_DEBUG("Mount jump triggered while moving: using jumpLoop anim ", mountAnims_.jumpLoop);
+                    characterRenderer->playAnimation(mountInstanceId_, mountAnims_.jumpLoop, true);
+                    mountAction_ = MountAction::Jump;
+                    mountActionPhase_ = 1;  // Start in airborne phase
+                    mountAnimId = mountAnims_.jumpLoop;
+                    if (mountSoundManager) {
+                        mountSoundManager->playJumpSound();
+                    }
+                    if (cameraController) {
+                        cameraController->triggerMountJump();
+                    }
+                } else if (!moving && mountAnims_.rearUp > 0) {
+                    // Standing still: rear-up flourish
+                    LOG_DEBUG("Mount rear-up triggered: playing rearUp anim ", mountAnims_.rearUp);
+                    characterRenderer->playAnimation(mountInstanceId_, mountAnims_.rearUp, false);
+                    mountAction_ = MountAction::RearUp;
+                    mountActionPhase_ = 0;
+                    mountAnimId = mountAnims_.rearUp;
+                    // Trigger semantic rear-up sound
+                    if (mountSoundManager) {
+                        mountSoundManager->playRearUpSound();
+                    }
+                }
+            }
+
+            // Handle active mount actions (jump chaining or rear-up)
+            if (mountAction_ != MountAction::None) {
+                bool animFinished = haveMountState && curMountDur > 0.1f &&
+                                   (curMountTime >= curMountDur - 0.05f);
+
+                if (mountAction_ == MountAction::Jump) {
+                    // Jump sequence: start → loop → end (physics-driven)
+                    if (mountActionPhase_ == 0 && animFinished && mountAnims_.jumpLoop > 0) {
+                        // JumpStart finished, go to JumpLoop (airborne)
+                        LOG_DEBUG("Mount jump: phase 0→1 (JumpStart→JumpLoop anim ", mountAnims_.jumpLoop, ")");
+                        characterRenderer->playAnimation(mountInstanceId_, mountAnims_.jumpLoop, true);
+                        mountActionPhase_ = 1;
+                        mountAnimId = mountAnims_.jumpLoop;
+                    } else if (mountActionPhase_ == 0 && animFinished && mountAnims_.jumpLoop == 0) {
+                        // No JumpLoop, go straight to airborne phase 1 (hold JumpStart pose)
+                        LOG_DEBUG("Mount jump: phase 0→1 (no JumpLoop, holding JumpStart)");
+                        mountActionPhase_ = 1;
+                    } else if (mountActionPhase_ == 1 && grounded && mountAnims_.jumpEnd > 0) {
+                        // Landed after airborne phase! Go to JumpEnd (grounded-triggered)
+                        LOG_DEBUG("Mount jump: phase 1→2 (landed, JumpEnd anim ", mountAnims_.jumpEnd, ")");
+                        characterRenderer->playAnimation(mountInstanceId_, mountAnims_.jumpEnd, false);
+                        mountActionPhase_ = 2;
+                        mountAnimId = mountAnims_.jumpEnd;
+                        // Trigger semantic landing sound
+                        if (mountSoundManager) {
+                            mountSoundManager->playLandSound();
+                        }
+                    } else if (mountActionPhase_ == 1 && grounded && mountAnims_.jumpEnd == 0) {
+                        // No JumpEnd animation, return directly to movement after landing
+                        LOG_DEBUG("Mount jump: phase 1→done (landed, no JumpEnd, returning to ",
+                                 moving ? "run" : "stand", " anim ", (moving ? mountAnims_.run : mountAnims_.stand), ")");
+                        mountAction_ = MountAction::None;
+                        mountAnimId = moving ? mountAnims_.run : mountAnims_.stand;
+                        characterRenderer->playAnimation(mountInstanceId_, mountAnimId, true);
+                    } else if (mountActionPhase_ == 2 && animFinished) {
+                        // JumpEnd finished, return to movement
+                        LOG_DEBUG("Mount jump: phase 2→done (JumpEnd finished, returning to ",
+                                 moving ? "run" : "stand", " anim ", (moving ? mountAnims_.run : mountAnims_.stand), ")");
+                        mountAction_ = MountAction::None;
+                        mountAnimId = moving ? mountAnims_.run : mountAnims_.stand;
+                        characterRenderer->playAnimation(mountInstanceId_, mountAnimId, true);
+                    } else {
+                        mountAnimId = curMountAnim;  // Keep current jump animation
+                    }
+                } else if (mountAction_ == MountAction::RearUp) {
+                    // Rear-up: single animation, return to stand when done
+                    if (animFinished) {
+                        LOG_DEBUG("Mount rear-up: finished, returning to ",
+                                 moving ? "run" : "stand", " anim ", (moving ? mountAnims_.run : mountAnims_.stand));
+                        mountAction_ = MountAction::None;
+                        mountAnimId = moving ? mountAnims_.run : mountAnims_.stand;
+                        characterRenderer->playAnimation(mountInstanceId_, mountAnimId, true);
+                    } else {
+                        mountAnimId = curMountAnim;  // Keep current rear-up animation
+                    }
+                }
+            } else if (moving) {
+                // Normal movement animations
+                if (anyStrafeLeft) {
+                    mountAnimId = pickMountAnim({ANIM_STRAFE_RUN_LEFT, ANIM_STRAFE_WALK_LEFT, ANIM_RUN}, ANIM_RUN);
+                } else if (anyStrafeRight) {
+                    mountAnimId = pickMountAnim({ANIM_STRAFE_RUN_RIGHT, ANIM_STRAFE_WALK_RIGHT, ANIM_RUN}, ANIM_RUN);
+                } else if (movingBackward) {
+                    mountAnimId = pickMountAnim({ANIM_BACKPEDAL}, ANIM_RUN);
+                } else {
+                    mountAnimId = ANIM_RUN;
+                }
+            }
+
+            // Cancel active fidget immediately if movement starts
+            if (moving && mountActiveFidget_ != 0) {
+                mountActiveFidget_ = 0;
+                // Force play run animation to stop fidget immediately
+                characterRenderer->playAnimation(mountInstanceId_, mountAnimId, true);
+            }
+
+            // Check if active fidget has completed (only when not moving)
+            if (!moving && mountActiveFidget_ != 0) {
+                uint32_t curAnim = 0;
+                float curTime = 0.0f, curDur = 0.0f;
+                if (characterRenderer->getAnimationState(mountInstanceId_, curAnim, curTime, curDur)) {
+                    // If animation changed or completed, clear active fidget
+                    if (curAnim != mountActiveFidget_ || curTime >= curDur * 0.95f) {
+                        mountActiveFidget_ = 0;
+                        LOG_DEBUG("Mount fidget completed");
+                    }
+                }
+            }
+
+            // Idle fidgets: random one-shot animations when standing still
+            if (!moving && mountAction_ == MountAction::None && mountActiveFidget_ == 0 && !mountAnims_.fidgets.empty()) {
+                mountIdleFidgetTimer_ += lastDeltaTime_;
+                static float nextFidgetTime = 6.0f + (rand() % 7);  // 6-12 seconds
+
+                if (mountIdleFidgetTimer_ >= nextFidgetTime) {
+                    // Trigger random fidget animation
+                    static std::mt19937 rng(std::random_device{}());
+                    std::uniform_int_distribution<size_t> dist(0, mountAnims_.fidgets.size() - 1);
+                    uint32_t fidgetAnim = mountAnims_.fidgets[dist(rng)];
+
+                    characterRenderer->playAnimation(mountInstanceId_, fidgetAnim, false);
+                    mountActiveFidget_ = fidgetAnim;  // Track active fidget
+                    mountIdleFidgetTimer_ = 0.0f;
+                    nextFidgetTime = 6.0f + (rand() % 7);  // Randomize next fidget time
+
+                    LOG_DEBUG("Mount idle fidget: playing anim ", fidgetAnim);
+                }
+            }
+            if (moving) {
+                mountIdleFidgetTimer_ = 0.0f;  // Reset timer when moving
+            }
+
+            // Idle ambient sounds: snorts and whinnies only, infrequent
+            if (!moving && mountSoundManager) {
+                mountIdleSoundTimer_ += lastDeltaTime_;
+                static float nextIdleSoundTime = 45.0f + (rand() % 46);  // 45-90 seconds
+
+                if (mountIdleSoundTimer_ >= nextIdleSoundTime) {
+                    mountSoundManager->playIdleSound();
+                    mountIdleSoundTimer_ = 0.0f;
+                    nextIdleSoundTime = 45.0f + (rand() % 46);  // Randomize next sound time
+                }
+            } else if (moving) {
+                mountIdleSoundTimer_ = 0.0f;  // Reset timer when moving
+            }
+
+            // Only update animation if it changed and we're not in an action sequence or playing a fidget
+            if (mountAction_ == MountAction::None && mountActiveFidget_ == 0 && (!haveMountState || curMountAnim != mountAnimId)) {
+                bool loop = true;  // Normal movement animations loop
+                characterRenderer->playAnimation(mountInstanceId_, mountAnimId, loop);
+            }
+
+            taxi_mount_done:
+            // Rider bob: sinusoidal motion synced to mount's run animation (only used in fallback positioning)
+            mountBob = 0.0f;
+            if (moving && haveMountState && curMountDur > 1.0f) {
+                float norm = std::fmod(curMountTime, curMountDur) / curMountDur;
+                // One bounce per stride cycle
+                float bobSpeed = taxiFlight_ ? 2.0f : 1.0f;
+                mountBob = std::sin(norm * 2.0f * 3.14159f * bobSpeed) * 0.12f;
+            }
+        }
+
+        // Use mount's attachment point for proper bone-driven rider positioning.
+        if (taxiFlight_) {
+            glm::mat4 mountSeatTransform(1.0f);
+            bool haveSeat = false;
+            static constexpr uint32_t kTaxiSeatAttachmentId = 0;  // deterministic rider seat
+            if (mountSeatAttachmentId_ == -1) {
+                mountSeatAttachmentId_ = static_cast<int>(kTaxiSeatAttachmentId);
+            }
+            if (mountSeatAttachmentId_ >= 0) {
+                haveSeat = characterRenderer->getAttachmentTransform(
+                    mountInstanceId_, static_cast<uint32_t>(mountSeatAttachmentId_), mountSeatTransform);
+            }
+            if (!haveSeat) {
+                mountSeatAttachmentId_ = -2;
+            }
+
+            if (haveSeat) {
+                glm::vec3 targetRiderPos = glm::vec3(mountSeatTransform[3]) + glm::vec3(0.0f, 0.0f, 0.02f);
+                // Taxi passengers should be rigidly parented to mount attachment transforms.
+                // Smoothing here introduces visible seat lag/drift on turns.
+                mountSeatSmoothingInit_ = false;
+                smoothedMountSeatPos_ = targetRiderPos;
+                characterRenderer->setInstancePosition(characterInstanceId, targetRiderPos);
+            } else {
+                mountSeatSmoothingInit_ = false;
+                glm::vec3 playerPos = characterPosition + glm::vec3(0.0f, 0.0f, mountHeightOffset_ + 0.10f);
+                characterRenderer->setInstancePosition(characterInstanceId, playerPos);
+            }
+
+            float riderPitch = mountPitch_ * 0.35f;
+            float riderRoll = mountRoll_ * 0.35f;
+            characterRenderer->setInstanceRotation(characterInstanceId, glm::vec3(riderPitch, riderRoll, mountYawRad));
+            return;
+        }
+
+        // Ground mounts: try a seat attachment first.
+        glm::mat4 mountSeatTransform;
+        bool haveSeat = false;
+        if (mountSeatAttachmentId_ >= 0) {
+            haveSeat = characterRenderer->getAttachmentTransform(
+                mountInstanceId_, static_cast<uint32_t>(mountSeatAttachmentId_), mountSeatTransform);
+        } else if (mountSeatAttachmentId_ == -1) {
+            // Probe common rider seat attachment IDs once per mount.
+            static constexpr uint32_t kSeatAttachments[] = {0, 5, 6, 7, 8};
+            for (uint32_t attId : kSeatAttachments) {
+                if (characterRenderer->getAttachmentTransform(mountInstanceId_, attId, mountSeatTransform)) {
+                    mountSeatAttachmentId_ = static_cast<int>(attId);
+                    haveSeat = true;
+                    break;
+                }
+            }
+            if (!haveSeat) {
+                mountSeatAttachmentId_ = -2;
+            }
+        }
+
+        if (haveSeat) {
+            // Extract position from mount seat transform (attachment point already includes proper seat height)
+            glm::vec3 mountSeatPos = glm::vec3(mountSeatTransform[3]);
+
+            // Keep seat offset minimal; large offsets amplify visible bobble.
+            glm::vec3 seatOffset = glm::vec3(0.0f, 0.0f, taxiFlight_ ? 0.04f : 0.08f);
+            glm::vec3 targetRiderPos = mountSeatPos + seatOffset;
+            // When moving, smoothing the seat position produces visible lag that looks like
+            // the rider sliding toward the rump. Anchor rigidly while moving.
+            if (moving) {
+                mountSeatSmoothingInit_ = false;
+                smoothedMountSeatPos_ = targetRiderPos;
+            } else if (!mountSeatSmoothingInit_) {
+                smoothedMountSeatPos_ = targetRiderPos;
+                mountSeatSmoothingInit_ = true;
+            } else {
+                float smoothHz = taxiFlight_ ? 10.0f : 14.0f;
+                float alpha = 1.0f - std::exp(-smoothHz * std::max(lastDeltaTime_, 0.001f));
+                smoothedMountSeatPos_ = glm::mix(smoothedMountSeatPos_, targetRiderPos, alpha);
+            }
+
+            // Position rider at mount seat
+            characterRenderer->setInstancePosition(characterInstanceId, smoothedMountSeatPos_);
+
+            // Rider uses character facing yaw, not mount bone rotation
+            // (rider faces character direction, seat bone only provides position)
+            float yawRad = glm::radians(characterYaw);
+            float riderPitch = taxiFlight_ ? mountPitch_ * 0.35f : 0.0f;
+            float riderRoll = taxiFlight_ ? mountRoll_ * 0.35f : 0.0f;
+            characterRenderer->setInstanceRotation(characterInstanceId, glm::vec3(riderPitch, riderRoll, yawRad));
+        } else {
+            // Fallback to old manual positioning if attachment not found
+            mountSeatSmoothingInit_ = false;
+            float yawRad = glm::radians(characterYaw);
+            glm::mat4 mountRotation = glm::mat4(1.0f);
+            mountRotation = glm::rotate(mountRotation, yawRad, glm::vec3(0.0f, 0.0f, 1.0f));
+            mountRotation = glm::rotate(mountRotation, mountRoll_, glm::vec3(1.0f, 0.0f, 0.0f));
+            mountRotation = glm::rotate(mountRotation, mountPitch_, glm::vec3(0.0f, 1.0f, 0.0f));
+            glm::vec3 localOffset(0.0f, 0.0f, mountHeightOffset_ + mountBob);
+            glm::vec3 worldOffset = glm::vec3(mountRotation * glm::vec4(localOffset, 0.0f));
+            glm::vec3 playerPos = characterPosition + worldOffset;
+            characterRenderer->setInstancePosition(characterInstanceId, playerPos);
+            characterRenderer->setInstanceRotation(characterInstanceId, glm::vec3(mountPitch_, mountRoll_, yawRad));
+        }
+        return;
+    }
+
+    if (!forceMelee) switch (charAnimState) {
+        case CharAnimState::IDLE:
+            if (swim) {
+                newState = moving ? CharAnimState::SWIM : CharAnimState::SWIM_IDLE;
+            } else if (sitting && grounded) {
+                newState = CharAnimState::SIT_DOWN;
+            } else if (!grounded && jumping) {
+                newState = CharAnimState::JUMP_START;
+            } else if (!grounded) {
+                newState = CharAnimState::JUMP_MID;
+            } else if (moving && sprinting) {
+                newState = CharAnimState::RUN;
+            } else if (moving) {
+                newState = CharAnimState::WALK;
+            } else if (inCombat_ && grounded) {
+                newState = CharAnimState::COMBAT_IDLE;
+            }
+            break;
+
+        case CharAnimState::WALK:
+            if (swim) {
+                newState = moving ? CharAnimState::SWIM : CharAnimState::SWIM_IDLE;
+            } else if (!grounded && jumping) {
+                newState = CharAnimState::JUMP_START;
+            } else if (!grounded) {
+                newState = CharAnimState::JUMP_MID;
+            } else if (!moving) {
+                newState = CharAnimState::IDLE;
+            } else if (sprinting) {
+                newState = CharAnimState::RUN;
+            }
+            break;
+
+        case CharAnimState::RUN:
+            if (swim) {
+                newState = moving ? CharAnimState::SWIM : CharAnimState::SWIM_IDLE;
+            } else if (!grounded && jumping) {
+                newState = CharAnimState::JUMP_START;
+            } else if (!grounded) {
+                newState = CharAnimState::JUMP_MID;
+            } else if (!moving) {
+                newState = CharAnimState::IDLE;
+            } else if (!sprinting) {
+                newState = CharAnimState::WALK;
+            }
+            break;
+
+        case CharAnimState::JUMP_START:
+            if (swim) {
+                newState = CharAnimState::SWIM_IDLE;
+            } else if (grounded) {
+                newState = CharAnimState::JUMP_END;
+            } else {
+                newState = CharAnimState::JUMP_MID;
+            }
+            break;
+
+        case CharAnimState::JUMP_MID:
+            if (swim) {
+                newState = CharAnimState::SWIM_IDLE;
+            } else if (grounded) {
+                newState = CharAnimState::JUMP_END;
+            }
+            break;
+
+        case CharAnimState::JUMP_END:
+            if (swim) {
+                newState = moving ? CharAnimState::SWIM : CharAnimState::SWIM_IDLE;
+            } else if (moving && sprinting) {
+                newState = CharAnimState::RUN;
+            } else if (moving) {
+                newState = CharAnimState::WALK;
+            } else {
+                newState = CharAnimState::IDLE;
+            }
+            break;
+
+        case CharAnimState::SIT_DOWN:
+            if (swim) {
+                newState = CharAnimState::SWIM_IDLE;
+            } else if (!sitting) {
+                newState = CharAnimState::IDLE;
+            }
+            break;
+
+        case CharAnimState::SITTING:
+            if (swim) {
+                newState = CharAnimState::SWIM_IDLE;
+            } else if (!sitting) {
+                newState = CharAnimState::IDLE;
+            }
+            break;
+
+        case CharAnimState::EMOTE:
+            if (swim) {
+                cancelEmote();
+                newState = CharAnimState::SWIM_IDLE;
+            } else if (jumping || !grounded) {
+                cancelEmote();
+                newState = CharAnimState::JUMP_START;
+            } else if (moving) {
+                cancelEmote();
+                newState = sprinting ? CharAnimState::RUN : CharAnimState::WALK;
+            } else if (sitting) {
+                cancelEmote();
+                newState = CharAnimState::SIT_DOWN;
+            }
+            break;
+
+        case CharAnimState::SWIM_IDLE:
+            if (!swim) {
+                newState = moving ? CharAnimState::WALK : CharAnimState::IDLE;
+            } else if (moving) {
+                newState = CharAnimState::SWIM;
+            }
+            break;
+
+        case CharAnimState::SWIM:
+            if (!swim) {
+                newState = moving ? CharAnimState::WALK : CharAnimState::IDLE;
+            } else if (!moving) {
+                newState = CharAnimState::SWIM_IDLE;
+            }
+            break;
+
+        case CharAnimState::MELEE_SWING:
+            if (swim) {
+                newState = CharAnimState::SWIM_IDLE;
+            } else if (!grounded && jumping) {
+                newState = CharAnimState::JUMP_START;
+            } else if (!grounded) {
+                newState = CharAnimState::JUMP_MID;
+            } else if (moving && sprinting) {
+                newState = CharAnimState::RUN;
+            } else if (moving) {
+                newState = CharAnimState::WALK;
+            } else if (sitting) {
+                newState = CharAnimState::SIT_DOWN;
+            } else if (inCombat_) {
+                newState = CharAnimState::COMBAT_IDLE;
+            } else {
+                newState = CharAnimState::IDLE;
+            }
+            break;
+
+        case CharAnimState::MOUNT:
+            // If we got here, the mount state was cleared externally but the
+            // animation state hasn't been reset yet. Fall back to normal logic.
+            if (swim) {
+                newState = moving ? CharAnimState::SWIM : CharAnimState::SWIM_IDLE;
+            } else if (sitting && grounded) {
+                newState = CharAnimState::SIT_DOWN;
+            } else if (!grounded && jumping) {
+                newState = CharAnimState::JUMP_START;
+            } else if (!grounded) {
+                newState = CharAnimState::JUMP_MID;
+            } else if (moving && sprinting) {
+                newState = CharAnimState::RUN;
+            } else if (moving) {
+                newState = CharAnimState::WALK;
+            } else {
+                newState = CharAnimState::IDLE;
+            }
+            break;
+
+        case CharAnimState::COMBAT_IDLE:
+            if (swim) {
+                newState = moving ? CharAnimState::SWIM : CharAnimState::SWIM_IDLE;
+            } else if (!grounded && jumping) {
+                newState = CharAnimState::JUMP_START;
+            } else if (!grounded) {
+                newState = CharAnimState::JUMP_MID;
+            } else if (moving && sprinting) {
+                newState = CharAnimState::RUN;
+            } else if (moving) {
+                newState = CharAnimState::WALK;
+            } else if (!inCombat_) {
+                newState = CharAnimState::IDLE;
+            }
+            break;
+
+        case CharAnimState::CHARGE:
+            // Stay in CHARGE until charging_ is cleared
+            break;
+    }
+
+    if (forceMelee) {
+        newState = CharAnimState::MELEE_SWING;
+    }
+
+    if (charging_) {
+        newState = CharAnimState::CHARGE;
+    }
+
+    if (newState != charAnimState) {
+        charAnimState = newState;
+    }
+
+    auto pickFirstAvailable = [&](std::initializer_list<uint32_t> candidates, uint32_t fallback) -> uint32_t {
+        for (uint32_t id : candidates) {
+            if (characterRenderer->hasAnimation(characterInstanceId, id)) {
+                return id;
+            }
+        }
+        return fallback;
+    };
+
+    uint32_t animId = ANIM_STAND;
+    bool loop = true;
+
+    switch (charAnimState) {
+        case CharAnimState::IDLE:       animId = ANIM_STAND;      loop = true;  break;
+        case CharAnimState::WALK:
+            if (movingBackward) {
+                animId = pickFirstAvailable({ANIM_BACKPEDAL}, ANIM_WALK);
+            } else if (anyStrafeLeft) {
+                animId = pickFirstAvailable({ANIM_STRAFE_WALK_LEFT, ANIM_STRAFE_RUN_LEFT}, ANIM_WALK);
+            } else if (anyStrafeRight) {
+                animId = pickFirstAvailable({ANIM_STRAFE_WALK_RIGHT, ANIM_STRAFE_RUN_RIGHT}, ANIM_WALK);
+            } else {
+                animId = pickFirstAvailable({ANIM_WALK, ANIM_RUN}, ANIM_STAND);
+            }
+            loop = true;
+            break;
+        case CharAnimState::RUN:
+            if (movingBackward) {
+                animId = pickFirstAvailable({ANIM_BACKPEDAL}, ANIM_WALK);
+            } else if (anyStrafeLeft) {
+                animId = pickFirstAvailable({ANIM_STRAFE_RUN_LEFT}, ANIM_RUN);
+            } else if (anyStrafeRight) {
+                animId = pickFirstAvailable({ANIM_STRAFE_RUN_RIGHT}, ANIM_RUN);
+            } else {
+                animId = pickFirstAvailable({ANIM_RUN, ANIM_WALK}, ANIM_STAND);
+            }
+            loop = true;
+            break;
+        case CharAnimState::JUMP_START: animId = ANIM_JUMP_START; loop = false; break;
+        case CharAnimState::JUMP_MID:   animId = ANIM_JUMP_MID;   loop = false; break;
+        case CharAnimState::JUMP_END:   animId = ANIM_JUMP_END;   loop = false; break;
+        case CharAnimState::SIT_DOWN:   animId = ANIM_SIT_DOWN;   loop = false; break;
+        case CharAnimState::SITTING:    animId = ANIM_SITTING;    loop = true;  break;
+        case CharAnimState::EMOTE:      animId = emoteAnimId;     loop = emoteLoop; break;
+        case CharAnimState::SWIM_IDLE:  animId = ANIM_SWIM_IDLE;  loop = true;  break;
+        case CharAnimState::SWIM:       animId = ANIM_SWIM;       loop = true;  break;
+        case CharAnimState::MELEE_SWING:
+            animId = resolveMeleeAnimId();
+            if (animId == 0) {
+                animId = ANIM_STAND;
+            }
+            loop = false;
+            break;
+        case CharAnimState::MOUNT:      animId = ANIM_MOUNT;      loop = true;  break;
+        case CharAnimState::COMBAT_IDLE:
+            animId = pickFirstAvailable(
+                {ANIM_READY_1H, ANIM_READY_2H, ANIM_READY_2H_L, ANIM_READY_UNARMED},
+                ANIM_STAND);
+            loop = true;
+            break;
+        case CharAnimState::CHARGE:
+            animId = ANIM_RUN;
+            loop = true;
+            break;
+    }
+
+    uint32_t currentAnimId = 0;
+    float currentAnimTimeMs = 0.0f;
+    float currentAnimDurationMs = 0.0f;
+    bool haveState = characterRenderer->getAnimationState(characterInstanceId, currentAnimId, currentAnimTimeMs, currentAnimDurationMs);
+    if (!haveState || currentAnimId != animId) {
+        characterRenderer->playAnimation(characterInstanceId, animId, loop);
+    }
+}
 
 void Renderer::playEmote(const std::string& emoteName) {
-    if (animationController_) animationController_->playEmote(emoteName);
+    loadEmotesFromDbc();
+    auto it = EMOTE_TABLE.find(emoteName);
+    if (it == EMOTE_TABLE.end()) return;
+
+    const auto& info = it->second;
+    if (info.animId == 0) return;
+    emoteActive = true;
+    emoteAnimId = info.animId;
+    emoteLoop = info.loop;
+    charAnimState = CharAnimState::EMOTE;
+
+    if (characterRenderer && characterInstanceId > 0) {
+        characterRenderer->playAnimation(characterInstanceId, emoteAnimId, emoteLoop);
+    }
 }
 
 void Renderer::cancelEmote() {
-    if (animationController_) animationController_->cancelEmote();
-}
-
-bool Renderer::isEmoteActive() const {
-    return animationController_ && animationController_->isEmoteActive();
-}
-
-void Renderer::setInCombat(bool combat) {
-    if (animationController_) animationController_->setInCombat(combat);
-}
-
-void Renderer::setEquippedWeaponType(uint32_t inventoryType, bool is2HLoose, bool isFist,
-                                     bool isDagger, bool hasOffHand, bool hasShield) {
-    if (animationController_) animationController_->setEquippedWeaponType(inventoryType, is2HLoose, isFist, isDagger, hasOffHand, hasShield);
-}
-
-void Renderer::triggerSpecialAttack(uint32_t spellId) {
-    if (animationController_) animationController_->triggerSpecialAttack(spellId);
-}
-
-void Renderer::setEquippedRangedType(RangedWeaponType type) {
-    if (animationController_) animationController_->setEquippedRangedType(type);
-}
-
-void Renderer::triggerRangedShot() {
-    if (animationController_) animationController_->triggerRangedShot();
-}
-
-RangedWeaponType Renderer::getEquippedRangedType() const {
-    return animationController_ ? animationController_->getEquippedRangedType()
-                                : RangedWeaponType::NONE;
-}
-
-void Renderer::setCharging(bool c) {
-    if (animationController_) animationController_->setCharging(c);
-}
-
-bool Renderer::isCharging() const {
-    return animationController_ && animationController_->isCharging();
-}
-
-void Renderer::setTaxiFlight(bool taxi) {
-    if (animationController_) animationController_->setTaxiFlight(taxi);
-}
-
-void Renderer::setMountPitchRoll(float pitch, float roll) {
-    if (animationController_) animationController_->setMountPitchRoll(pitch, roll);
-}
-
-bool Renderer::isMounted() const {
-    return animationController_ && animationController_->isMounted();
-}
-
-bool Renderer::captureScreenshot(const std::string& outputPath) {
-    if (!vkCtx) return false;
-
-    VkDevice device     = vkCtx->getDevice();
-    VmaAllocator alloc  = vkCtx->getAllocator();
-    VkExtent2D extent   = vkCtx->getSwapchainExtent();
-    const auto& images  = vkCtx->getSwapchainImages();
-
-    if (images.empty() || currentImageIndex >= images.size()) return false;
-
-    VkImage srcImage = images[currentImageIndex];
-    uint32_t w = extent.width;
-    uint32_t h = extent.height;
-    VkDeviceSize bufSize = static_cast<VkDeviceSize>(w) * h * 4;
-
-    // Stall GPU so the swapchain image is idle
-    vkDeviceWaitIdle(device);
-
-    // Create staging buffer
-    VkBufferCreateInfo bufInfo{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
-    bufInfo.size  = bufSize;
-    bufInfo.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
-
-    VmaAllocationCreateInfo allocCI{};
-    allocCI.usage = VMA_MEMORY_USAGE_CPU_ONLY;
-
-    VkBuffer stagingBuf = VK_NULL_HANDLE;
-    VmaAllocation stagingAlloc = VK_NULL_HANDLE;
-    if (vmaCreateBuffer(alloc, &bufInfo, &allocCI, &stagingBuf, &stagingAlloc, nullptr) != VK_SUCCESS) {
-        LOG_WARNING("Screenshot: failed to create staging buffer");
-        return false;
-    }
-
-    // Record copy commands
-    VkCommandBuffer cmd = vkCtx->beginSingleTimeCommands();
-
-    // Transition swapchain image: PRESENT_SRC → TRANSFER_SRC
-    VkImageMemoryBarrier toTransfer{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER};
-    toTransfer.srcAccessMask       = VK_ACCESS_MEMORY_READ_BIT;
-    toTransfer.dstAccessMask       = VK_ACCESS_TRANSFER_READ_BIT;
-    toTransfer.oldLayout           = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
-    toTransfer.newLayout           = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
-    toTransfer.image               = srcImage;
-    toTransfer.subresourceRange    = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
-    vkCmdPipelineBarrier(cmd,
-        VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
-        0, 0, nullptr, 0, nullptr, 1, &toTransfer);
-
-    // Copy image to buffer
-    VkBufferImageCopy region{};
-    region.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1};
-    region.imageExtent      = {w, h, 1};
-    vkCmdCopyImageToBuffer(cmd, srcImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-                           stagingBuf, 1, &region);
-
-    // Transition back: TRANSFER_SRC → PRESENT_SRC
-    VkImageMemoryBarrier toPresent = toTransfer;
-    toPresent.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
-    toPresent.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
-    toPresent.oldLayout     = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
-    toPresent.newLayout     = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
-    vkCmdPipelineBarrier(cmd,
-        VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
-        0, 0, nullptr, 0, nullptr, 1, &toPresent);
-
-    vkCtx->endSingleTimeCommands(cmd);
-
-    // Map and convert BGRA → RGBA
-    void* mapped = nullptr;
-    vmaMapMemory(alloc, stagingAlloc, &mapped);
-    auto* pixels = static_cast<uint8_t*>(mapped);
-    for (uint32_t i = 0; i < w * h; ++i) {
-        std::swap(pixels[i * 4 + 0], pixels[i * 4 + 2]); // B ↔ R
-    }
-
-    // Ensure output directory exists
-    std::filesystem::path outPath(outputPath);
-    if (outPath.has_parent_path())
-        std::filesystem::create_directories(outPath.parent_path());
-
-    int ok = stbi_write_png(outputPath.c_str(),
-                            static_cast<int>(w), static_cast<int>(h),
-                            4, pixels, static_cast<int>(w * 4));
-
-    vmaUnmapMemory(alloc, stagingAlloc);
-    vmaDestroyBuffer(alloc, stagingBuf, stagingAlloc);
-
-    if (ok) {
-        LOG_INFO("Screenshot saved: ", outputPath);
-    } else {
-        LOG_WARNING("Screenshot: stbi_write_png failed for ", outputPath);
-    }
-    return ok != 0;
+    emoteActive = false;
+    emoteAnimId = 0;
+    emoteLoop = false;
 }
 
 void Renderer::triggerLevelUpEffect(const glm::vec3& position) {
-    if (animationController_) animationController_->triggerLevelUpEffect(position);
+    if (!levelUpEffect) return;
+
+    // Lazy-load the M2 model on first trigger
+    if (!levelUpEffect->isModelLoaded() && m2Renderer) {
+        if (!cachedAssetManager) {
+            cachedAssetManager = core::Application::getInstance().getAssetManager();
+        }
+        if (!cachedAssetManager) {
+            LOG_WARNING("LevelUpEffect: no asset manager available");
+        } else {
+            auto m2Data = cachedAssetManager->readFile("Spells\\LevelUp\\LevelUp.m2");
+            auto skinData = cachedAssetManager->readFile("Spells\\LevelUp\\LevelUp00.skin");
+            LOG_INFO("LevelUpEffect: m2Data=", m2Data.size(), " skinData=", skinData.size());
+            if (!m2Data.empty()) {
+                levelUpEffect->loadModel(m2Renderer.get(), m2Data, skinData);
+            } else {
+                LOG_WARNING("LevelUpEffect: failed to read Spell\\LevelUp\\LevelUp.m2");
+            }
+        }
+    }
+
+    levelUpEffect->trigger(position);
 }
 
 void Renderer::startChargeEffect(const glm::vec3& position, const glm::vec3& direction) {
-    if (animationController_) animationController_->startChargeEffect(position, direction);
+    if (!chargeEffect) return;
+
+    // Lazy-load M2 models on first use
+    if (!chargeEffect->isActive() && m2Renderer) {
+        if (!cachedAssetManager) {
+            cachedAssetManager = core::Application::getInstance().getAssetManager();
+        }
+        if (cachedAssetManager) {
+            chargeEffect->tryLoadM2Models(m2Renderer.get(), cachedAssetManager);
+        }
+    }
+
+    chargeEffect->start(position, direction);
 }
 
 void Renderer::emitChargeEffect(const glm::vec3& position, const glm::vec3& direction) {
-    if (animationController_) animationController_->emitChargeEffect(position, direction);
+    if (chargeEffect) {
+        chargeEffect->emit(position, direction);
+    }
 }
 
 void Renderer::stopChargeEffect() {
-    if (animationController_) animationController_->stopChargeEffect();
-}
-
-// ─── Spell Visual Effects — delegated to SpellVisualSystem (§4.4) ────────────
-
-void Renderer::playSpellVisual(uint32_t visualId, const glm::vec3& worldPosition,
-                                bool useImpactKit) {
-    if (spellVisualSystem_) spellVisualSystem_->playSpellVisual(visualId, worldPosition, useImpactKit);
+    if (chargeEffect) {
+        chargeEffect->stop();
+    }
 }
 
 void Renderer::triggerMeleeSwing() {
-    if (animationController_) animationController_->triggerMeleeSwing();
+    if (!characterRenderer || characterInstanceId == 0) return;
+    if (meleeSwingCooldown > 0.0f) return;
+    if (emoteActive) {
+        cancelEmote();
+    }
+    resolveMeleeAnimId();
+    meleeSwingCooldown = 0.1f;
+    float durationSec = meleeAnimDurationMs > 0.0f ? meleeAnimDurationMs / 1000.0f : 0.6f;
+    if (durationSec < 0.25f) durationSec = 0.25f;
+    if (durationSec > 1.0f) durationSec = 1.0f;
+    meleeSwingTimer = durationSec;
+    if (activitySoundManager) {
+        activitySoundManager->playMeleeSwing();
+    }
 }
 
 std::string Renderer::getEmoteText(const std::string& emoteName, const std::string* targetName) {
-    return AnimationController::getEmoteText(emoteName, targetName);
+    loadEmotesFromDbc();
+    auto it = EMOTE_TABLE.find(emoteName);
+    if (it != EMOTE_TABLE.end()) {
+        const auto& info = it->second;
+        const std::string& base = (targetName ? info.textTarget : info.textNoTarget);
+        if (!base.empty()) {
+            return replacePlaceholders(base, targetName);
+        }
+        if (targetName && !targetName->empty()) {
+            return "You " + info.command + " at " + *targetName + ".";
+        }
+        return "You " + info.command + ".";
+    }
+    return "";
 }
 
 uint32_t Renderer::getEmoteDbcId(const std::string& emoteName) {
-    return AnimationController::getEmoteDbcId(emoteName);
+    loadEmotesFromDbc();
+    auto it = EMOTE_TABLE.find(emoteName);
+    if (it != EMOTE_TABLE.end()) {
+        return it->second.dbcId;
+    }
+    return 0;
 }
 
 std::string Renderer::getEmoteTextByDbcId(uint32_t dbcId, const std::string& senderName,
                                            const std::string* targetName) {
-    return AnimationController::getEmoteTextByDbcId(dbcId, senderName, targetName);
+    loadEmotesFromDbc();
+    auto it = EMOTE_BY_DBCID.find(dbcId);
+    if (it == EMOTE_BY_DBCID.end()) return "";
+
+    const EmoteInfo& info = *it->second;
+
+    // Use "others see" text templates: "%s dances." / "%s dances with %s."
+    if (targetName && !targetName->empty()) {
+        if (!info.othersTarget.empty()) {
+            // Replace first %s with sender, second %s with target
+            std::string out;
+            out.reserve(info.othersTarget.size() + senderName.size() + targetName->size());
+            bool firstReplaced = false;
+            for (size_t i = 0; i < info.othersTarget.size(); ++i) {
+                if (info.othersTarget[i] == '%' && i + 1 < info.othersTarget.size() && info.othersTarget[i + 1] == 's') {
+                    out += firstReplaced ? *targetName : senderName;
+                    firstReplaced = true;
+                    ++i;
+                } else {
+                    out.push_back(info.othersTarget[i]);
+                }
+            }
+            return out;
+        }
+        return senderName + " " + info.command + "s at " + *targetName + ".";
+    } else {
+        if (!info.othersNoTarget.empty()) {
+            return replacePlaceholders(info.othersNoTarget, &senderName);
+        }
+        return senderName + " " + info.command + "s.";
+    }
 }
 
 uint32_t Renderer::getEmoteAnimByDbcId(uint32_t dbcId) {
-    return AnimationController::getEmoteAnimByDbcId(dbcId);
+    loadEmotesFromDbc();
+    auto it = EMOTE_BY_DBCID.find(dbcId);
+    if (it != EMOTE_BY_DBCID.end()) {
+        return it->second->animId;
+    }
+    return 0;
 }
 
 void Renderer::setTargetPosition(const glm::vec3* pos) {
-    if (animationController_) animationController_->setTargetPosition(pos);
-}
-
-void Renderer::resetCombatVisualState() {
-    if (animationController_) animationController_->resetCombatVisualState();
-    if (spellVisualSystem_) spellVisualSystem_->reset();
+    targetPosition = pos;
 }
 
 bool Renderer::isMoving() const {
     return cameraController && cameraController->isMoving();
 }
 
+bool Renderer::isFootstepAnimationState() const {
+    return charAnimState == CharAnimState::WALK || charAnimState == CharAnimState::RUN;
+}
+
+bool Renderer::shouldTriggerFootstepEvent(uint32_t animationId, float animationTimeMs, float animationDurationMs) {
+    if (animationDurationMs <= 1.0f) {
+        footstepNormInitialized = false;
+        return false;
+    }
+
+    float norm = std::fmod(animationTimeMs, animationDurationMs) / animationDurationMs;
+    if (norm < 0.0f) norm += 1.0f;
+
+    if (animationId != footstepLastAnimationId) {
+        footstepLastAnimationId = animationId;
+        footstepLastNormTime = norm;
+        footstepNormInitialized = true;
+        return false;
+    }
+
+    if (!footstepNormInitialized) {
+        footstepNormInitialized = true;
+        footstepLastNormTime = norm;
+        return false;
+    }
+
+    auto crossed = [&](float eventNorm) {
+        if (footstepLastNormTime <= norm) {
+            return footstepLastNormTime < eventNorm && eventNorm <= norm;
+        }
+        return footstepLastNormTime < eventNorm || eventNorm <= norm;
+    };
+
+    bool trigger = crossed(0.22f) || crossed(0.72f);
+    footstepLastNormTime = norm;
+    return trigger;
+}
+
+audio::FootstepSurface Renderer::resolveFootstepSurface() const {
+    if (!cameraController || !cameraController->isThirdPerson()) {
+        return audio::FootstepSurface::STONE;
+    }
+
+    const glm::vec3& p = characterPosition;
+
+    // Cache footstep surface to avoid expensive queries every step
+    // Only update if moved >1.5 units or timer expired (0.5s)
+    float distSq = glm::dot(p - cachedFootstepPosition, p - cachedFootstepPosition);
+    if (distSq < 2.25f && cachedFootstepUpdateTimer < 0.5f) {
+        return cachedFootstepSurface;
+    }
+
+    // Update cache
+    cachedFootstepPosition = p;
+    cachedFootstepUpdateTimer = 0.0f;
+
+    if (cameraController->isSwimming()) {
+        cachedFootstepSurface = audio::FootstepSurface::WATER;
+        return audio::FootstepSurface::WATER;
+    }
+
+    if (waterRenderer) {
+        auto waterH = waterRenderer->getWaterHeightAt(p.x, p.y);
+        if (waterH && p.z < (*waterH + 0.25f)) {
+            cachedFootstepSurface = audio::FootstepSurface::WATER;
+            return audio::FootstepSurface::WATER;
+        }
+    }
+
+    if (wmoRenderer) {
+        auto wmoFloor = wmoRenderer->getFloorHeight(p.x, p.y, p.z + 1.5f);
+        auto terrainFloor = terrainManager ? terrainManager->getHeightAt(p.x, p.y) : std::nullopt;
+        if (wmoFloor && (!terrainFloor || *wmoFloor >= *terrainFloor - 0.1f)) {
+            cachedFootstepSurface = audio::FootstepSurface::STONE;
+            return audio::FootstepSurface::STONE;
+        }
+    }
+
+    // Determine surface type (expensive - only done when cache needs update)
+    audio::FootstepSurface surface = audio::FootstepSurface::STONE;
+
+    if (terrainManager) {
+        auto texture = terrainManager->getDominantTextureAt(p.x, p.y);
+        if (texture) {
+            std::string t = *texture;
+            for (char& c : t) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+            if (t.find("snow") != std::string::npos || t.find("ice") != std::string::npos) surface = audio::FootstepSurface::SNOW;
+            else if (t.find("grass") != std::string::npos || t.find("moss") != std::string::npos || t.find("leaf") != std::string::npos) surface = audio::FootstepSurface::GRASS;
+            else if (t.find("sand") != std::string::npos || t.find("dirt") != std::string::npos || t.find("mud") != std::string::npos) surface = audio::FootstepSurface::DIRT;
+            else if (t.find("wood") != std::string::npos || t.find("timber") != std::string::npos) surface = audio::FootstepSurface::WOOD;
+            else if (t.find("metal") != std::string::npos || t.find("iron") != std::string::npos) surface = audio::FootstepSurface::METAL;
+            else if (t.find("stone") != std::string::npos || t.find("rock") != std::string::npos || t.find("cobble") != std::string::npos || t.find("brick") != std::string::npos) surface = audio::FootstepSurface::STONE;
+        }
+    }
+
+    cachedFootstepSurface = surface;
+    return surface;
+}
+
 void Renderer::update(float deltaTime) {
-    ZoneScopedN("Renderer::update");
     globalTime += deltaTime;
     if (musicSwitchCooldown_ > 0.0f) {
         musicSwitchCooldown_ = std::max(0.0f, musicSwitchCooldown_ - deltaTime);
@@ -1227,7 +2657,7 @@ void Renderer::update(float deltaTime) {
     runDeferredWorldInitStep(deltaTime);
 
     auto updateStart = std::chrono::steady_clock::now();
-    lastDeltaTime_ = deltaTime;
+    lastDeltaTime_ = deltaTime;  // Cache for use in updateCharacterAnimation()
 
     if (wmoRenderer) wmoRenderer->resetQueryStats();
     if (m2Renderer) m2Renderer->resetQueryStats();
@@ -1253,7 +2683,7 @@ void Renderer::update(float deltaTime) {
     // Visibility hardening: ensure player instance cannot stay hidden after
     // taxi/camera transitions, but preserve first-person self-hide.
     if (characterRenderer && characterInstanceId > 0 && cameraController) {
-        if ((cameraController->isThirdPerson() && !cameraController->isFirstPersonView()) || (animationController_ && animationController_->isTaxiFlight())) {
+        if ((cameraController->isThirdPerson() && !cameraController->isFirstPersonView()) || taxiFlight_) {
             characterRenderer->setInstanceVisible(characterInstanceId, true);
         }
     }
@@ -1276,7 +2706,6 @@ void Renderer::update(float deltaTime) {
                 // Server-driven weather (SMSG_WEATHER) — authoritative
                 if (wType == 1)      weather->setWeatherType(Weather::Type::RAIN);
                 else if (wType == 2) weather->setWeatherType(Weather::Type::SNOW);
-                else if (wType == 3) weather->setWeatherType(Weather::Type::STORM);
                 else                 weather->setWeatherType(Weather::Type::NONE);
                 weather->setIntensity(wInt);
             } else {
@@ -1284,11 +2713,6 @@ void Renderer::update(float deltaTime) {
                 weather->updateZoneWeather(currentZoneId, deltaTime);
             }
             weather->setEnabled(true);
-
-            // Lightning flash disabled
-            if (lightning) {
-                lightning->setEnabled(false);
-            }
         } else if (weather) {
             // No game handler (single-player without network) — zone weather only
             weather->updateZoneWeather(currentZoneId, deltaTime);
@@ -1298,18 +2722,26 @@ void Renderer::update(float deltaTime) {
 
     // Sync character model position/rotation and animation with follow target
     if (characterInstanceId > 0 && characterRenderer && cameraController) {
+        if (meleeSwingCooldown > 0.0f) {
+            meleeSwingCooldown = std::max(0.0f, meleeSwingCooldown - deltaTime);
+        }
+        if (meleeSwingTimer > 0.0f) {
+            meleeSwingTimer = std::max(0.0f, meleeSwingTimer - deltaTime);
+        }
+
         characterRenderer->setInstancePosition(characterInstanceId, characterPosition);
 
         // Movement-facing comes from camera controller and is decoupled from LMB orbit.
-        bool taxiFlight = animationController_ && animationController_->isTaxiFlight();
-        if (taxiFlight) {
+        // During taxi flights, orientation is controlled by the flight path (not player input)
+        if (taxiFlight_) {
+            // Taxi flight: use orientation from flight path
             characterYaw = cameraController->getFacingYaw();
         } else if (cameraController->isMoving() || cameraController->isRightMouseHeld()) {
             characterYaw = cameraController->getFacingYaw();
-        } else if (animationController_ && animationController_->isInCombat() &&
-                   animationController_->getTargetPosition() && !animationController_->isEmoteActive() && !isMounted()) {
-            glm::vec3 toTarget = *animationController_->getTargetPosition() - characterPosition;
-            if (toTarget.x * toTarget.x + toTarget.y * toTarget.y > 0.01f) {
+        } else if (inCombat_ && targetPosition && !emoteActive && !isMounted()) {
+            // Face target when in combat and idle
+            glm::vec3 toTarget = *targetPosition - characterPosition;
+            if (glm::length(glm::vec2(toTarget.x, toTarget.y)) > 0.1f) {
                 float targetYaw = glm::degrees(std::atan2(toTarget.y, toTarget.x));
                 float diff = targetYaw - characterYaw;
                 while (diff > 180.0f) diff -= 360.0f;
@@ -1325,12 +2757,8 @@ void Renderer::update(float deltaTime) {
         float yawRad = glm::radians(characterYaw);
         characterRenderer->setInstanceRotation(characterInstanceId, glm::vec3(0.0f, 0.0f, yawRad));
 
-        // Update animation based on movement state (delegated to AnimationController §4.2)
-        if (animationController_) {
-            animationController_->updateMeleeTimers(deltaTime);
-            animationController_->setDeltaTime(deltaTime);
-            animationController_->updateCharacterAnimation();
-        }
+        // Update animation based on movement state
+        updateCharacterAnimation();
     }
 
     // Update terrain streaming
@@ -1354,11 +2782,6 @@ void Renderer::update(float deltaTime) {
         weather->update(*camera, deltaTime);
     }
 
-    // Update lightning (storm / heavy rain)
-    if (lightning && camera && lightning->isEnabled()) {
-        lightning->update(deltaTime, *camera);
-    }
-
     // Update swim effects
     if (swimEffects && camera && cameraController && waterRenderer) {
         swimEffects->update(*camera, *cameraController, *waterRenderer, deltaTime);
@@ -1369,7 +2792,7 @@ void Renderer::update(float deltaTime) {
         mountDust->update(deltaTime);
 
         // Spawn dust when mounted and moving on ground
-        if (isMounted() && camera && cameraController && !(animationController_ && animationController_->isTaxiFlight())) {
+        if (isMounted() && camera && cameraController && !taxiFlight_) {
             bool isMoving = cameraController->isMoving();
             bool onGround = cameraController->isGrounded();
 
@@ -1381,8 +2804,7 @@ void Renderer::update(float deltaTime) {
                 velocity.z = 0.0f;  // Ignore vertical component
 
                 // Spawn dust at mount's feet (slightly below character position)
-                float mho = animationController_ ? animationController_->getMountHeightOffset() : 0.0f;
-                glm::vec3 dustPos = characterPosition - glm::vec3(0.0f, 0.0f, mho * 0.8f);
+                glm::vec3 dustPos = characterPosition - glm::vec3(0.0f, 0.0f, mountHeightOffset_ * 0.8f);
                 mountDust->spawnDust(dustPos, velocity, isMoving);
             }
         }
@@ -1395,8 +2817,6 @@ void Renderer::update(float deltaTime) {
     if (chargeEffect) {
         chargeEffect->update(deltaTime);
     }
-    // Update transient spell visual instances (delegated to SpellVisualSystem §4.4)
-    if (spellVisualSystem_) spellVisualSystem_->update(deltaTime);
 
 
     // Launch M2 doodad animation on background thread (overlaps with character animation + audio)
@@ -1421,27 +2841,152 @@ void Renderer::update(float deltaTime) {
     // Update AudioEngine (cleanup finished sounds, etc.)
     audio::AudioEngine::instance().update(deltaTime);
 
-    // Footsteps: delegated to AnimationController (§4.2)
-    if (animationController_) animationController_->updateFootsteps(deltaTime);
+    // Footsteps: animation-event driven + surface query at event time.
+    if (footstepManager) {
+        footstepManager->update(deltaTime);
+        cachedFootstepUpdateTimer += deltaTime;  // Update surface cache timer
+        bool canPlayFootsteps = characterRenderer && characterInstanceId > 0 &&
+            cameraController && cameraController->isThirdPerson() &&
+            cameraController->isGrounded() && !cameraController->isSwimming();
 
-    // Activity SFX + mount ambient sounds: delegated to AnimationController (§4.2)
-    if (animationController_) animationController_->updateSfxState(deltaTime);
+        if (canPlayFootsteps && isMounted() && mountInstanceId_ > 0 && !taxiFlight_) {
+            // Mount footsteps: use mount's animation for timing
+            uint32_t animId = 0;
+            float animTimeMs = 0.0f, animDurationMs = 0.0f;
+            if (characterRenderer->getAnimationState(mountInstanceId_, animId, animTimeMs, animDurationMs) &&
+                animDurationMs > 1.0f && cameraController->isMoving()) {
+                float norm = std::fmod(animTimeMs, animDurationMs) / animDurationMs;
+                if (norm < 0.0f) norm += 1.0f;
+
+                if (animId != mountFootstepLastAnimId) {
+                    mountFootstepLastAnimId = animId;
+                    mountFootstepLastNormTime = norm;
+                    mountFootstepNormInitialized = true;
+                } else if (!mountFootstepNormInitialized) {
+                    mountFootstepNormInitialized = true;
+                    mountFootstepLastNormTime = norm;
+                } else {
+                    // Mount gait: 2 hoofbeats per cycle (synced with animation)
+                    auto crossed = [&](float eventNorm) {
+                        if (mountFootstepLastNormTime <= norm) {
+                            return mountFootstepLastNormTime < eventNorm && eventNorm <= norm;
+                        }
+                        return mountFootstepLastNormTime < eventNorm || eventNorm <= norm;
+                    };
+                    if (crossed(0.25f) || crossed(0.75f)) {
+                        footstepManager->playFootstep(resolveFootstepSurface(), true);
+                    }
+                    mountFootstepLastNormTime = norm;
+                }
+            } else {
+                mountFootstepNormInitialized = false;
+            }
+            footstepNormInitialized = false;  // Reset player footstep tracking
+        } else if (canPlayFootsteps && isFootstepAnimationState()) {
+            uint32_t animId = 0;
+            float animTimeMs = 0.0f;
+            float animDurationMs = 0.0f;
+            if (characterRenderer->getAnimationState(characterInstanceId, animId, animTimeMs, animDurationMs) &&
+                shouldTriggerFootstepEvent(animId, animTimeMs, animDurationMs)) {
+                auto surface = resolveFootstepSurface();
+                footstepManager->playFootstep(surface, cameraController->isSprinting());
+                // Play additional splash sound and spawn foot splash particles when wading
+                if (surface == audio::FootstepSurface::WATER) {
+                    if (movementSoundManager) {
+                        movementSoundManager->playWaterFootstep(audio::MovementSoundManager::CharacterSize::MEDIUM);
+                    }
+                    if (swimEffects && waterRenderer) {
+                        auto wh = waterRenderer->getWaterHeightAt(characterPosition.x, characterPosition.y);
+                        if (wh) {
+                            swimEffects->spawnFootSplash(characterPosition, *wh);
+                        }
+                    }
+                }
+            }
+            mountFootstepNormInitialized = false;
+        } else {
+            footstepNormInitialized = false;
+            mountFootstepNormInitialized = false;
+        }
+    }
+
+    // Activity SFX: animation/state-driven jump, landing, and swim loops/splashes.
+    if (activitySoundManager) {
+        activitySoundManager->update(deltaTime);
+        if (cameraController && cameraController->isThirdPerson()) {
+            bool grounded = cameraController->isGrounded();
+            bool jumping = cameraController->isJumping();
+            bool falling = cameraController->isFalling();
+            bool swimming = cameraController->isSwimming();
+            bool moving = cameraController->isMoving();
+
+            if (!sfxStateInitialized) {
+                sfxPrevGrounded = grounded;
+                sfxPrevJumping = jumping;
+                sfxPrevFalling = falling;
+                sfxPrevSwimming = swimming;
+                sfxStateInitialized = true;
+            }
+
+            if (jumping && !sfxPrevJumping && !swimming) {
+                activitySoundManager->playJump();
+            }
+
+            if (grounded && !sfxPrevGrounded) {
+                bool hardLanding = sfxPrevFalling;
+                activitySoundManager->playLanding(resolveFootstepSurface(), hardLanding);
+            }
+
+            if (swimming && !sfxPrevSwimming) {
+                activitySoundManager->playWaterEnter();
+            } else if (!swimming && sfxPrevSwimming) {
+                activitySoundManager->playWaterExit();
+            }
+
+            activitySoundManager->setSwimmingState(swimming, moving);
+
+            // Fade music underwater
+            if (musicManager) {
+                musicManager->setUnderwaterMode(swimming);
+            }
+
+            sfxPrevGrounded = grounded;
+            sfxPrevJumping = jumping;
+            sfxPrevFalling = falling;
+            sfxPrevSwimming = swimming;
+        } else {
+            activitySoundManager->setSwimmingState(false, false);
+            // Restore music volume when activity sounds disabled
+            if (musicManager) {
+                musicManager->setUnderwaterMode(false);
+            }
+            sfxStateInitialized = false;
+        }
+    }
+
+    // Mount ambient sounds: wing flaps, breathing, etc.
+    if (mountSoundManager) {
+        mountSoundManager->update(deltaTime);
+        if (cameraController && isMounted()) {
+            bool moving = cameraController->isMoving();
+            bool flying = taxiFlight_ || !cameraController->isGrounded();  // Flying if taxi or airborne
+            mountSoundManager->setMoving(moving);
+            mountSoundManager->setFlying(flying);
+        }
+    }
 
     const bool canQueryWmo = (camera && wmoRenderer);
     const glm::vec3 camPos = camera ? camera->getPosition() : glm::vec3(0.0f);
     uint32_t insideWmoId = 0;
     const bool insideWmo = canQueryWmo &&
         wmoRenderer->isInsideWMO(camPos.x, camPos.y, camPos.z, &insideWmoId);
-    playerIndoors_ = insideWmo;
 
     // Ambient environmental sounds: fireplaces, water, birds, etc.
-    if (audioCoordinator_->getAmbientSoundManager() && camera && wmoRenderer && cameraController) {
+    if (ambientSoundManager && camera && wmoRenderer && cameraController) {
         bool isIndoor = insideWmo;
         bool isSwimming = cameraController->isSwimming();
 
-        // Detect blacksmith buildings to play ambient forge/anvil sounds.
-        // 96048 is the WMO group ID for the Goldshire blacksmith interior.
-        // TODO: extend to other smithy WMO IDs (Ironforge, Orgrimmar, etc.)
+        // Check if inside blacksmith (96048 = Goldshire blacksmith)
         bool isBlacksmith = (insideWmoId == 96048);
 
         // Sync weather audio with visual weather system
@@ -1469,30 +3014,29 @@ void Renderer::update(float deltaTime) {
                 }
             }
 
-            audioCoordinator_->getAmbientSoundManager()->setWeather(audioWeatherType);
+            ambientSoundManager->setWeather(audioWeatherType);
         }
 
-        audioCoordinator_->getAmbientSoundManager()->update(deltaTime, camPos, isIndoor, isSwimming, isBlacksmith);
+        ambientSoundManager->update(deltaTime, camPos, isIndoor, isSwimming, isBlacksmith);
     }
 
     // Wait for M2 doodad animation to finish (was launched earlier in parallel with character anim)
     if (m2AnimLaunched) {
-        try { m2AnimFuture.get(); }
-        catch (const std::exception& e) { LOG_ERROR("M2 animation worker: ", e.what()); }
+        m2AnimFuture.get();
     }
 
     // Helper: play zone music, dispatching local files (file: prefix) vs MPQ paths
     auto playZoneMusic = [&](const std::string& music) {
         if (music.empty()) return;
         if (music.rfind("file:", 0) == 0) {
-            audioCoordinator_->getMusicManager()->crossfadeToFile(music.substr(5));
+            musicManager->crossfadeToFile(music.substr(5));
         } else {
-            audioCoordinator_->getMusicManager()->crossfadeTo(music);
+            musicManager->crossfadeTo(music);
         }
     };
 
     // Update zone detection and music
-    if (zoneManager && audioCoordinator_->getMusicManager() && terrainManager && camera) {
+    if (zoneManager && musicManager && terrainManager && camera) {
         // Prefer server-authoritative zone ID (from SMSG_INIT_WORLD_STATES);
         // fall back to tile-based lookup for single-player / offline mode.
         const auto* gh = core::Application::getInstance().getGameHandler();
@@ -1521,8 +3065,8 @@ void Renderer::update(float deltaTime) {
                     lastLoggedWmoId = wmoModelId;
                 }
 
-                // Detect blacksmith WMO for ambient forge sounds
-                if (wmoModelId == 96048) {  // Goldshire blacksmith interior
+                // Blacksmith detection
+                if (wmoModelId == 96048) {  // Goldshire blacksmith
                     insideBlacksmith = true;
                     LOG_INFO("Detected blacksmith WMO ", wmoModelId);
                 }
@@ -1543,10 +3087,8 @@ void Renderer::update(float deltaTime) {
                         "Sound\\Music\\ZoneMusic\\TavernHuman\\RA_HumanTavern1A.mp3",
                         "Sound\\Music\\ZoneMusic\\TavernHuman\\RA_HumanTavern2A.mp3",
                     };
-                    // Rotate through tracks so the player doesn't always hear the same one.
-                    // Post-increment: first visit plays index 0, next plays 1, etc.
                     static int tavernTrackIndex = 0;
-                    tavernMusic = tavernTracks[tavernTrackIndex++ % tavernTracks.size()];
+                    tavernMusic = tavernTracks[tavernTrackIndex % tavernTracks.size()];
                     LOG_INFO("Detected tavern WMO ", wmoModelId, ", playing: ", tavernMusic);
                 }
             }
@@ -1557,7 +3099,7 @@ void Renderer::update(float deltaTime) {
             if (!inTavern_ && !tavernMusic.empty()) {
                 inTavern_ = true;
                 LOG_INFO("Entered tavern");
-                audioCoordinator_->getMusicManager()->playMusic(tavernMusic, true);  // Immediate playback, looping
+                musicManager->playMusic(tavernMusic, true);  // Immediate playback, looping
                 musicSwitchCooldown_ = 6.0f;
             }
         } else if (inTavern_) {
@@ -1579,7 +3121,7 @@ void Renderer::update(float deltaTime) {
             if (!inBlacksmith_) {
                 inBlacksmith_ = true;
                 LOG_INFO("Entered blacksmith - stopping music");
-                audioCoordinator_->getMusicManager()->stopMusic();
+                musicManager->stopMusic();
             }
         } else if (inBlacksmith_) {
             // Exited blacksmith - restore zone music with crossfade
@@ -1611,15 +3153,15 @@ void Renderer::update(float deltaTime) {
                 }
             }
             // Update ambient sound manager zone type
-            if (audioCoordinator_->getAmbientSoundManager()) {
-                audioCoordinator_->getAmbientSoundManager()->setZoneId(zoneId);
+            if (ambientSoundManager) {
+                ambientSoundManager->setZoneId(zoneId);
             }
         }
 
-        audioCoordinator_->getMusicManager()->update(deltaTime);
+        musicManager->update(deltaTime);
 
         // When a track finishes, pick a new random track from the current zone
-        if (!audioCoordinator_->getMusicManager()->isPlaying() && !inTavern_ && !inBlacksmith_ &&
+        if (!musicManager->isPlaying() && !inTavern_ && !inBlacksmith_ &&
             currentZoneId != 0 && musicSwitchCooldown_ <= 0.0f) {
             std::string music = zoneManager->getRandomMusic(currentZoneId);
             if (!music.empty()) {
@@ -1660,24 +3202,24 @@ void Renderer::runDeferredWorldInitStep(float deltaTime) {
 
     switch (deferredWorldInitStage_) {
         case 0:
-            if (audioCoordinator_->getAmbientSoundManager()) {
-                audioCoordinator_->getAmbientSoundManager()->initialize(cachedAssetManager);
+            if (ambientSoundManager) {
+                ambientSoundManager->initialize(cachedAssetManager);
             }
-            if (terrainManager && audioCoordinator_->getAmbientSoundManager()) {
-                terrainManager->setAmbientSoundManager(audioCoordinator_->getAmbientSoundManager());
+            if (terrainManager && ambientSoundManager) {
+                terrainManager->setAmbientSoundManager(ambientSoundManager.get());
             }
             break;
         case 1:
-            if (audioCoordinator_->getUiSoundManager()) audioCoordinator_->getUiSoundManager()->initialize(cachedAssetManager);
+            if (uiSoundManager) uiSoundManager->initialize(cachedAssetManager);
             break;
         case 2:
-            if (audioCoordinator_->getCombatSoundManager()) audioCoordinator_->getCombatSoundManager()->initialize(cachedAssetManager);
+            if (combatSoundManager) combatSoundManager->initialize(cachedAssetManager);
             break;
         case 3:
-            if (audioCoordinator_->getSpellSoundManager()) audioCoordinator_->getSpellSoundManager()->initialize(cachedAssetManager);
+            if (spellSoundManager) spellSoundManager->initialize(cachedAssetManager);
             break;
         case 4:
-            if (audioCoordinator_->getMovementSoundManager()) audioCoordinator_->getMovementSoundManager()->initialize(cachedAssetManager);
+            if (movementSoundManager) movementSoundManager->initialize(cachedAssetManager);
             break;
         case 5:
             if (questMarkerRenderer) questMarkerRenderer->initialize(vkCtx, perFrameSetLayout, cachedAssetManager);
@@ -1773,7 +3315,7 @@ void Renderer::initSelectionCircle() {
         .setLayout(selCirclePipelineLayout)
         .setRenderPass(vkCtx->getImGuiRenderPass())
         .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     vertShader.destroy();
     fragShader.destroy();
@@ -1885,7 +3427,7 @@ void Renderer::initOverlayPipeline() {
         .setLayout(overlayPipelineLayout)
         .setRenderPass(vkCtx->getImGuiRenderPass())
         .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     vertMod.destroy(); fragMod.destroy();
 
@@ -1902,115 +3444,1226 @@ void Renderer::renderOverlay(const glm::vec4& color, VkCommandBuffer overrideCmd
     vkCmdDraw(cmd, 3, 1, 0, 0); // fullscreen triangle
 }
 
-// ========================= PostProcessPipeline delegation stubs (§4.3) =========================
+// ========================= FSR 1.0 Upscaling =========================
 
-PostProcessPipeline* Renderer::getPostProcessPipeline() const {
-    return postProcessPipeline_.get();
+bool Renderer::initFSRResources() {
+    if (!vkCtx) return false;
+
+    VkDevice device = vkCtx->getDevice();
+    VmaAllocator alloc = vkCtx->getAllocator();
+    VkExtent2D swapExtent = vkCtx->getSwapchainExtent();
+    VkSampleCountFlagBits msaa = vkCtx->getMsaaSamples();
+    bool useMsaa = (msaa > VK_SAMPLE_COUNT_1_BIT);
+    bool useDepthResolve = (vkCtx->getDepthResolveImageView() != VK_NULL_HANDLE);
+
+    fsr_.internalWidth = static_cast<uint32_t>(swapExtent.width * fsr_.scaleFactor);
+    fsr_.internalHeight = static_cast<uint32_t>(swapExtent.height * fsr_.scaleFactor);
+    fsr_.internalWidth = (fsr_.internalWidth + 1) & ~1u;
+    fsr_.internalHeight = (fsr_.internalHeight + 1) & ~1u;
+
+    LOG_INFO("FSR: initializing at ", fsr_.internalWidth, "x", fsr_.internalHeight,
+             " -> ", swapExtent.width, "x", swapExtent.height,
+             " (scale=", fsr_.scaleFactor, ", MSAA=", static_cast<int>(msaa), "x)");
+
+    VkFormat colorFmt = vkCtx->getSwapchainFormat();
+    VkFormat depthFmt = vkCtx->getDepthFormat();
+
+    // sceneColor: always 1x, always sampled — this is what FSR reads
+    // Non-MSAA: direct render target. MSAA: resolve target.
+    fsr_.sceneColor = createImage(device, alloc, fsr_.internalWidth, fsr_.internalHeight,
+        colorFmt, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
+    if (!fsr_.sceneColor.image) {
+        LOG_ERROR("FSR: failed to create scene color image");
+        return false;
+    }
+
+    // sceneDepth: matches current MSAA sample count
+    fsr_.sceneDepth = createImage(device, alloc, fsr_.internalWidth, fsr_.internalHeight,
+        depthFmt, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, msaa);
+    if (!fsr_.sceneDepth.image) {
+        LOG_ERROR("FSR: failed to create scene depth image");
+        destroyFSRResources();
+        return false;
+    }
+
+    if (useMsaa) {
+        // sceneMsaaColor: multisampled color target
+        fsr_.sceneMsaaColor = createImage(device, alloc, fsr_.internalWidth, fsr_.internalHeight,
+            colorFmt, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, msaa);
+        if (!fsr_.sceneMsaaColor.image) {
+            LOG_ERROR("FSR: failed to create MSAA color image");
+            destroyFSRResources();
+            return false;
+        }
+
+        if (useDepthResolve) {
+            fsr_.sceneDepthResolve = createImage(device, alloc, fsr_.internalWidth, fsr_.internalHeight,
+                depthFmt, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
+            if (!fsr_.sceneDepthResolve.image) {
+                LOG_ERROR("FSR: failed to create depth resolve image");
+                destroyFSRResources();
+                return false;
+            }
+        }
+    }
+
+    // Build framebuffer matching the main render pass attachment layout:
+    //   Non-MSAA:              [color, depth]
+    //   MSAA (no depth res):   [msaaColor, depth, resolve]
+    //   MSAA (depth res):      [msaaColor, depth, resolve, depthResolve]
+    VkImageView fbAttachments[4]{};
+    uint32_t fbCount;
+    if (useMsaa) {
+        fbAttachments[0] = fsr_.sceneMsaaColor.imageView;
+        fbAttachments[1] = fsr_.sceneDepth.imageView;
+        fbAttachments[2] = fsr_.sceneColor.imageView;  // resolve target
+        fbCount = 3;
+        if (useDepthResolve) {
+            fbAttachments[3] = fsr_.sceneDepthResolve.imageView;
+            fbCount = 4;
+        }
+    } else {
+        fbAttachments[0] = fsr_.sceneColor.imageView;
+        fbAttachments[1] = fsr_.sceneDepth.imageView;
+        fbCount = 2;
+    }
+
+    VkFramebufferCreateInfo fbInfo{};
+    fbInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+    fbInfo.renderPass = vkCtx->getImGuiRenderPass();
+    fbInfo.attachmentCount = fbCount;
+    fbInfo.pAttachments = fbAttachments;
+    fbInfo.width = fsr_.internalWidth;
+    fbInfo.height = fsr_.internalHeight;
+    fbInfo.layers = 1;
+
+    if (vkCreateFramebuffer(device, &fbInfo, nullptr, &fsr_.sceneFramebuffer) != VK_SUCCESS) {
+        LOG_ERROR("FSR: failed to create scene framebuffer");
+        destroyFSRResources();
+        return false;
+    }
+
+    // Sampler for the resolved scene color
+    VkSamplerCreateInfo samplerInfo{};
+    samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+    samplerInfo.minFilter = VK_FILTER_LINEAR;
+    samplerInfo.magFilter = VK_FILTER_LINEAR;
+    samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+    samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+    samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+    samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
+    if (vkCreateSampler(device, &samplerInfo, nullptr, &fsr_.sceneSampler) != VK_SUCCESS) {
+        LOG_ERROR("FSR: failed to create sampler");
+        destroyFSRResources();
+        return false;
+    }
+
+    // Descriptor set layout: binding 0 = combined image sampler
+    VkDescriptorSetLayoutBinding binding{};
+    binding.binding = 0;
+    binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+    binding.descriptorCount = 1;
+    binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
+
+    VkDescriptorSetLayoutCreateInfo layoutInfo{};
+    layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+    layoutInfo.bindingCount = 1;
+    layoutInfo.pBindings = &binding;
+    vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &fsr_.descSetLayout);
+
+    VkDescriptorPoolSize poolSize{};
+    poolSize.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+    poolSize.descriptorCount = 1;
+    VkDescriptorPoolCreateInfo poolInfo{};
+    poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+    poolInfo.maxSets = 1;
+    poolInfo.poolSizeCount = 1;
+    poolInfo.pPoolSizes = &poolSize;
+    vkCreateDescriptorPool(device, &poolInfo, nullptr, &fsr_.descPool);
+
+    VkDescriptorSetAllocateInfo dsAllocInfo{};
+    dsAllocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+    dsAllocInfo.descriptorPool = fsr_.descPool;
+    dsAllocInfo.descriptorSetCount = 1;
+    dsAllocInfo.pSetLayouts = &fsr_.descSetLayout;
+    vkAllocateDescriptorSets(device, &dsAllocInfo, &fsr_.descSet);
+
+    // Always bind the 1x sceneColor (FSR reads the resolved image)
+    VkDescriptorImageInfo imgInfo{};
+    imgInfo.sampler = fsr_.sceneSampler;
+    imgInfo.imageView = fsr_.sceneColor.imageView;
+    imgInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+
+    VkWriteDescriptorSet write{};
+    write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    write.dstSet = fsr_.descSet;
+    write.dstBinding = 0;
+    write.descriptorCount = 1;
+    write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+    write.pImageInfo = &imgInfo;
+    vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
+
+    // Pipeline layout
+    VkPushConstantRange pc{};
+    pc.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
+    pc.offset = 0;
+    pc.size = 64;
+    VkPipelineLayoutCreateInfo plCI{};
+    plCI.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+    plCI.setLayoutCount = 1;
+    plCI.pSetLayouts = &fsr_.descSetLayout;
+    plCI.pushConstantRangeCount = 1;
+    plCI.pPushConstantRanges = &pc;
+    vkCreatePipelineLayout(device, &plCI, nullptr, &fsr_.pipelineLayout);
+
+    // Load shaders
+    VkShaderModule vertMod, fragMod;
+    if (!vertMod.loadFromFile(device, "assets/shaders/postprocess.vert.spv") ||
+        !fragMod.loadFromFile(device, "assets/shaders/fsr_easu.frag.spv")) {
+        LOG_ERROR("FSR: failed to load shaders");
+        destroyFSRResources();
+        return false;
+    }
+
+    // FSR upscale pipeline renders into the swapchain pass at full resolution
+    // Must match swapchain pass MSAA setting
+    fsr_.pipeline = PipelineBuilder()
+        .setShaders(vertMod.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
+                    fragMod.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
+        .setVertexInput({}, {})
+        .setTopology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
+        .setRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE)
+        .setNoDepthTest()
+        .setColorBlendAttachment(PipelineBuilder::blendDisabled())
+        .setMultisample(msaa)
+        .setLayout(fsr_.pipelineLayout)
+        .setRenderPass(vkCtx->getImGuiRenderPass())
+        .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
+        .build(device);
+
+    vertMod.destroy();
+    fragMod.destroy();
+
+    if (!fsr_.pipeline) {
+        LOG_ERROR("FSR: failed to create upscale pipeline");
+        destroyFSRResources();
+        return false;
+    }
+
+    LOG_INFO("FSR: initialized successfully");
+    return true;
 }
 
-void Renderer::setFXAAEnabled(bool enabled) {
-    if (postProcessPipeline_) postProcessPipeline_->setFXAAEnabled(enabled);
+void Renderer::destroyFSRResources() {
+    if (!vkCtx) return;
+
+    VkDevice device = vkCtx->getDevice();
+    VmaAllocator alloc = vkCtx->getAllocator();
+    vkDeviceWaitIdle(device);
+
+    if (fsr_.pipeline) { vkDestroyPipeline(device, fsr_.pipeline, nullptr); fsr_.pipeline = VK_NULL_HANDLE; }
+    if (fsr_.pipelineLayout) { vkDestroyPipelineLayout(device, fsr_.pipelineLayout, nullptr); fsr_.pipelineLayout = VK_NULL_HANDLE; }
+    if (fsr_.descPool) { vkDestroyDescriptorPool(device, fsr_.descPool, nullptr); fsr_.descPool = VK_NULL_HANDLE; fsr_.descSet = VK_NULL_HANDLE; }
+    if (fsr_.descSetLayout) { vkDestroyDescriptorSetLayout(device, fsr_.descSetLayout, nullptr); fsr_.descSetLayout = VK_NULL_HANDLE; }
+    if (fsr_.sceneFramebuffer) { vkDestroyFramebuffer(device, fsr_.sceneFramebuffer, nullptr); fsr_.sceneFramebuffer = VK_NULL_HANDLE; }
+    if (fsr_.sceneSampler) { vkDestroySampler(device, fsr_.sceneSampler, nullptr); fsr_.sceneSampler = VK_NULL_HANDLE; }
+    destroyImage(device, alloc, fsr_.sceneDepthResolve);
+    destroyImage(device, alloc, fsr_.sceneMsaaColor);
+    destroyImage(device, alloc, fsr_.sceneDepth);
+    destroyImage(device, alloc, fsr_.sceneColor);
+
+    fsr_.internalWidth = 0;
+    fsr_.internalHeight = 0;
 }
-bool Renderer::isFXAAEnabled() const {
-    return postProcessPipeline_ && postProcessPipeline_->isFXAAEnabled();
+
+void Renderer::renderFSRUpscale() {
+    if (!fsr_.pipeline || currentCmd == VK_NULL_HANDLE) return;
+
+    VkExtent2D outExtent = vkCtx->getSwapchainExtent();
+    float inW = static_cast<float>(fsr_.internalWidth);
+    float inH = static_cast<float>(fsr_.internalHeight);
+    float outW = static_cast<float>(outExtent.width);
+    float outH = static_cast<float>(outExtent.height);
+
+    // FSR push constants
+    struct {
+        glm::vec4 con0;  // inputSize.xy, 1/inputSize.xy
+        glm::vec4 con1;  // inputSize.xy / outputSize.xy, 0.5 * inputSize.xy / outputSize.xy
+        glm::vec4 con2;  // outputSize.xy, 1/outputSize.xy
+        glm::vec4 con3;  // sharpness, 0, 0, 0
+    } fsrConst;
+
+    fsrConst.con0 = glm::vec4(inW, inH, 1.0f / inW, 1.0f / inH);
+    fsrConst.con1 = glm::vec4(inW / outW, inH / outH, 0.5f * inW / outW, 0.5f * inH / outH);
+    fsrConst.con2 = glm::vec4(outW, outH, 1.0f / outW, 1.0f / outH);
+    fsrConst.con3 = glm::vec4(fsr_.sharpness, 0.0f, 0.0f, 0.0f);
+
+    vkCmdBindPipeline(currentCmd, VK_PIPELINE_BIND_POINT_GRAPHICS, fsr_.pipeline);
+    vkCmdBindDescriptorSets(currentCmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
+        fsr_.pipelineLayout, 0, 1, &fsr_.descSet, 0, nullptr);
+    vkCmdPushConstants(currentCmd, fsr_.pipelineLayout,
+        VK_SHADER_STAGE_FRAGMENT_BIT, 0, 64, &fsrConst);
+    vkCmdDraw(currentCmd, 3, 1, 0, 0);
 }
 
 void Renderer::setFSREnabled(bool enabled) {
-    if (!postProcessPipeline_) return;
-    auto req = postProcessPipeline_->setFSREnabled(enabled);
-    if (req.requested) {
-        pendingMsaaSamples_ = req.samples;
-        msaaChangePending_ = true;
+    if (fsr_.enabled == enabled) return;
+    fsr_.enabled = enabled;
+
+    if (!enabled) {
+        // Defer destruction to next beginFrame() — can't destroy mid-render
+        fsr_.needsRecreate = true;
+    }
+    // Resources created/destroyed lazily in beginFrame()
+}
+
+void Renderer::setFSRQuality(float scaleFactor) {
+    scaleFactor = glm::clamp(scaleFactor, 0.5f, 1.0f);
+    fsr_.scaleFactor = scaleFactor;
+    fsr2_.scaleFactor = scaleFactor;
+    // Don't destroy/recreate mid-frame — mark for lazy recreation in next beginFrame()
+    if (fsr_.enabled && fsr_.sceneFramebuffer) {
+        fsr_.needsRecreate = true;
+    }
+    if (fsr2_.enabled && fsr2_.sceneFramebuffer) {
+        fsr2_.needsRecreate = true;
+        fsr2_.needsHistoryReset = true;
     }
 }
-bool Renderer::isFSREnabled() const {
-    return postProcessPipeline_ && postProcessPipeline_->isFSREnabled();
-}
-void Renderer::setFSRQuality(float scaleFactor) {
-    if (postProcessPipeline_) postProcessPipeline_->setFSRQuality(scaleFactor);
-}
+
 void Renderer::setFSRSharpness(float sharpness) {
-    if (postProcessPipeline_) postProcessPipeline_->setFSRSharpness(sharpness);
+    fsr_.sharpness = glm::clamp(sharpness, 0.0f, 2.0f);
+    fsr2_.sharpness = glm::clamp(sharpness, 0.0f, 2.0f);
 }
-float Renderer::getFSRScaleFactor() const {
-    return postProcessPipeline_ ? postProcessPipeline_->getFSRScaleFactor() : 1.0f;
+
+// ========================= End FSR 1.0 =========================
+
+// ========================= FSR 2.2 Temporal Upscaling =========================
+
+float Renderer::halton(uint32_t index, uint32_t base) {
+    float f = 1.0f;
+    float r = 0.0f;
+    uint32_t current = index;
+    while (current > 0) {
+        f /= static_cast<float>(base);
+        r += f * static_cast<float>(current % base);
+        current /= base;
+    }
+    return r;
 }
-float Renderer::getFSRSharpness() const {
-    return postProcessPipeline_ ? postProcessPipeline_->getFSRSharpness() : 0.0f;
+
+bool Renderer::initFSR2Resources() {
+    if (!vkCtx) return false;
+
+    VkDevice device = vkCtx->getDevice();
+    VmaAllocator alloc = vkCtx->getAllocator();
+    VkExtent2D swapExtent = vkCtx->getSwapchainExtent();
+
+    // Temporary stability fallback: keep FSR2 path at native internal resolution
+    // until temporal reprojection is reworked.
+    fsr2_.internalWidth = static_cast<uint32_t>(swapExtent.width * fsr2_.scaleFactor);
+    fsr2_.internalHeight = static_cast<uint32_t>(swapExtent.height * fsr2_.scaleFactor);
+    fsr2_.internalWidth = (fsr2_.internalWidth + 1) & ~1u;
+    fsr2_.internalHeight = (fsr2_.internalHeight + 1) & ~1u;
+
+    LOG_INFO("FSR2: initializing at ", fsr2_.internalWidth, "x", fsr2_.internalHeight,
+             " -> ", swapExtent.width, "x", swapExtent.height,
+             " (scale=", fsr2_.scaleFactor, ")");
+    fsr2_.useAmdBackend = false;
+    fsr2_.amdFsr3FramegenRuntimeActive = false;
+    fsr2_.amdFsr3FramegenRuntimeReady = false;
+    fsr2_.framegenOutputValid = false;
+    fsr2_.amdFsr3RuntimePath = "Path C";
+    fsr2_.amdFsr3RuntimeLastError.clear();
+    fsr2_.amdFsr3UpscaleDispatchCount = 0;
+    fsr2_.amdFsr3FramegenDispatchCount = 0;
+    fsr2_.amdFsr3FallbackCount = 0;
+    fsr2_.amdFsr3InteropSyncValue = 1;
+#if WOWEE_HAS_AMD_FSR2
+    LOG_INFO("FSR2: AMD FidelityFX SDK detected at build time.");
+#else
+    LOG_WARNING("FSR2: AMD FidelityFX SDK not detected; using internal fallback path.");
+#endif
+
+    VkFormat colorFmt = vkCtx->getSwapchainFormat();
+    VkFormat depthFmt = vkCtx->getDepthFormat();
+
+    // Scene color (internal resolution, 1x — FSR2 replaces MSAA)
+    fsr2_.sceneColor = createImage(device, alloc, fsr2_.internalWidth, fsr2_.internalHeight,
+        colorFmt, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
+    if (!fsr2_.sceneColor.image) { LOG_ERROR("FSR2: failed to create scene color"); return false; }
+
+    // Scene depth (internal resolution, 1x, sampled for motion vectors)
+    fsr2_.sceneDepth = createImage(device, alloc, fsr2_.internalWidth, fsr2_.internalHeight,
+        depthFmt, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
+    if (!fsr2_.sceneDepth.image) { LOG_ERROR("FSR2: failed to create scene depth"); destroyFSR2Resources(); return false; }
+
+    // Motion vector buffer (internal resolution)
+    fsr2_.motionVectors = createImage(device, alloc, fsr2_.internalWidth, fsr2_.internalHeight,
+        VK_FORMAT_R16G16_SFLOAT, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
+    if (!fsr2_.motionVectors.image) { LOG_ERROR("FSR2: failed to create motion vectors"); destroyFSR2Resources(); return false; }
+
+    // History buffers (display resolution, ping-pong)
+    for (int i = 0; i < 2; i++) {
+        fsr2_.history[i] = createImage(device, alloc, swapExtent.width, swapExtent.height,
+            VK_FORMAT_R16G16B16A16_SFLOAT,
+            VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
+        if (!fsr2_.history[i].image) { LOG_ERROR("FSR2: failed to create history buffer ", i); destroyFSR2Resources(); return false; }
+    }
+    fsr2_.framegenOutput = createImage(device, alloc, swapExtent.width, swapExtent.height,
+        VK_FORMAT_R16G16B16A16_SFLOAT, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
+    if (!fsr2_.framegenOutput.image) { LOG_ERROR("FSR2: failed to create framegen output"); destroyFSR2Resources(); return false; }
+
+    // Scene framebuffer (non-MSAA: [color, depth])
+    // Must use the same render pass as the swapchain — which must be non-MSAA when FSR2 is active
+    VkImageView fbAttachments[2] = { fsr2_.sceneColor.imageView, fsr2_.sceneDepth.imageView };
+    VkFramebufferCreateInfo fbInfo{};
+    fbInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+    fbInfo.renderPass = vkCtx->getImGuiRenderPass();
+    fbInfo.attachmentCount = 2;
+    fbInfo.pAttachments = fbAttachments;
+    fbInfo.width = fsr2_.internalWidth;
+    fbInfo.height = fsr2_.internalHeight;
+    fbInfo.layers = 1;
+    if (vkCreateFramebuffer(device, &fbInfo, nullptr, &fsr2_.sceneFramebuffer) != VK_SUCCESS) {
+        LOG_ERROR("FSR2: failed to create scene framebuffer");
+        destroyFSR2Resources();
+        return false;
+    }
+
+    // Samplers
+    VkSamplerCreateInfo samplerInfo{};
+    samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+    samplerInfo.minFilter = VK_FILTER_LINEAR;
+    samplerInfo.magFilter = VK_FILTER_LINEAR;
+    samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+    samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+    samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+    vkCreateSampler(device, &samplerInfo, nullptr, &fsr2_.linearSampler);
+
+    samplerInfo.minFilter = VK_FILTER_NEAREST;
+    samplerInfo.magFilter = VK_FILTER_NEAREST;
+    vkCreateSampler(device, &samplerInfo, nullptr, &fsr2_.nearestSampler);
+
+#if WOWEE_HAS_AMD_FSR2
+    // Initialize AMD FSR2 context; fall back to internal path on any failure.
+    fsr2_.amdScratchBufferSize = ffxFsr2GetScratchMemorySizeVK(vkCtx->getPhysicalDevice());
+    if (fsr2_.amdScratchBufferSize > 0) {
+        fsr2_.amdScratchBuffer = std::malloc(fsr2_.amdScratchBufferSize);
+    }
+    if (!fsr2_.amdScratchBuffer) {
+        LOG_WARNING("FSR2 AMD: failed to allocate scratch buffer, using internal fallback.");
+    } else {
+        FfxErrorCode ifaceErr = ffxFsr2GetInterfaceVK(
+            &fsr2_.amdInterface,
+            fsr2_.amdScratchBuffer,
+            fsr2_.amdScratchBufferSize,
+            vkCtx->getPhysicalDevice(),
+            vkGetDeviceProcAddr);
+        if (ifaceErr != FFX_OK) {
+            LOG_WARNING("FSR2 AMD: ffxFsr2GetInterfaceVK failed (", static_cast<int>(ifaceErr), "), using internal fallback.");
+            std::free(fsr2_.amdScratchBuffer);
+            fsr2_.amdScratchBuffer = nullptr;
+            fsr2_.amdScratchBufferSize = 0;
+        } else {
+            FfxFsr2ContextDescription ctxDesc{};
+            ctxDesc.flags = FFX_FSR2_ENABLE_AUTO_EXPOSURE | FFX_FSR2_ENABLE_MOTION_VECTORS_JITTER_CANCELLATION;
+            ctxDesc.maxRenderSize.width = fsr2_.internalWidth;
+            ctxDesc.maxRenderSize.height = fsr2_.internalHeight;
+            ctxDesc.displaySize.width = swapExtent.width;
+            ctxDesc.displaySize.height = swapExtent.height;
+            ctxDesc.callbacks = fsr2_.amdInterface;
+            ctxDesc.device = ffxGetDeviceVK(vkCtx->getDevice());
+            ctxDesc.fpMessage = nullptr;
+
+            FfxErrorCode ctxErr = ffxFsr2ContextCreate(&fsr2_.amdContext, &ctxDesc);
+            if (ctxErr == FFX_OK) {
+                fsr2_.useAmdBackend = true;
+                LOG_INFO("FSR2 AMD: context created successfully.");
+#if WOWEE_HAS_AMD_FSR3_FRAMEGEN
+                if (fsr2_.amdFsr3FramegenEnabled) {
+                    fsr2_.amdFsr3FramegenRuntimeActive = false;
+                    if (!fsr2_.amdFsr3Runtime) fsr2_.amdFsr3Runtime = std::make_unique<AmdFsr3Runtime>();
+                    AmdFsr3RuntimeInitDesc fgInit{};
+                    fgInit.physicalDevice = vkCtx->getPhysicalDevice();
+                    fgInit.device = vkCtx->getDevice();
+                    fgInit.getDeviceProcAddr = vkGetDeviceProcAddr;
+                    fgInit.maxRenderWidth = fsr2_.internalWidth;
+                    fgInit.maxRenderHeight = fsr2_.internalHeight;
+                    fgInit.displayWidth = swapExtent.width;
+                    fgInit.displayHeight = swapExtent.height;
+                    fgInit.colorFormat = VK_FORMAT_R16G16B16A16_SFLOAT;
+                    fgInit.hdrInput = false;
+                    fgInit.depthInverted = false;
+                    fgInit.enableFrameGeneration = true;
+                    fsr2_.amdFsr3FramegenRuntimeReady = fsr2_.amdFsr3Runtime->initialize(fgInit);
+                    if (fsr2_.amdFsr3FramegenRuntimeReady) {
+                        fsr2_.amdFsr3RuntimeLastError.clear();
+                        fsr2_.amdFsr3RuntimePath = "Path A";
+                        LOG_INFO("FSR3 framegen runtime library loaded from ", fsr2_.amdFsr3Runtime->loadedLibraryPath(),
+                                 " (upscale+framegen dispatch enabled)");
+                    } else {
+                        fsr2_.amdFsr3RuntimePath = "Path C";
+                        fsr2_.amdFsr3RuntimeLastError = fsr2_.amdFsr3Runtime->lastError();
+                        LOG_WARNING("FSR3 framegen toggle is enabled, but runtime initialization failed. ",
+                                    "path=", fsr2_.amdFsr3RuntimePath,
+                                    " error=", fsr2_.amdFsr3RuntimeLastError.empty() ? "(none)" : fsr2_.amdFsr3RuntimeLastError,
+                                    " runtimeLib=", fsr2_.amdFsr3Runtime->loadedLibraryPath().empty() ? "(not loaded)" : fsr2_.amdFsr3Runtime->loadedLibraryPath());
+                    }
+                }
+#endif
+            } else {
+                LOG_WARNING("FSR2 AMD: context creation failed (", static_cast<int>(ctxErr), "), using internal fallback.");
+                std::free(fsr2_.amdScratchBuffer);
+                fsr2_.amdScratchBuffer = nullptr;
+                fsr2_.amdScratchBufferSize = 0;
+            }
+        }
+    }
+#endif
+
+    // --- Motion Vector Compute Pipeline ---
+    {
+        // Descriptor set layout: binding 0 = depth (sampler), binding 1 = motion vectors (storage image)
+        VkDescriptorSetLayoutBinding bindings[2] = {};
+        bindings[0].binding = 0;
+        bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+        bindings[0].descriptorCount = 1;
+        bindings[0].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+        bindings[1].binding = 1;
+        bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+        bindings[1].descriptorCount = 1;
+        bindings[1].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+
+        VkDescriptorSetLayoutCreateInfo layoutInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO};
+        layoutInfo.bindingCount = 2;
+        layoutInfo.pBindings = bindings;
+        vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &fsr2_.motionVecDescSetLayout);
+
+        VkPushConstantRange pc{};
+        pc.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+        pc.offset = 0;
+        pc.size = 2 * sizeof(glm::mat4);  // 128 bytes
+
+        VkPipelineLayoutCreateInfo plCI{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO};
+        plCI.setLayoutCount = 1;
+        plCI.pSetLayouts = &fsr2_.motionVecDescSetLayout;
+        plCI.pushConstantRangeCount = 1;
+        plCI.pPushConstantRanges = &pc;
+        vkCreatePipelineLayout(device, &plCI, nullptr, &fsr2_.motionVecPipelineLayout);
+
+        VkShaderModule compMod;
+        if (!compMod.loadFromFile(device, "assets/shaders/fsr2_motion.comp.spv")) {
+            LOG_ERROR("FSR2: failed to load motion vector compute shader");
+            destroyFSR2Resources();
+            return false;
+        }
+
+        VkComputePipelineCreateInfo cpCI{VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO};
+        cpCI.stage = compMod.stageInfo(VK_SHADER_STAGE_COMPUTE_BIT);
+        cpCI.layout = fsr2_.motionVecPipelineLayout;
+        if (vkCreateComputePipelines(device, VK_NULL_HANDLE, 1, &cpCI, nullptr, &fsr2_.motionVecPipeline) != VK_SUCCESS) {
+            LOG_ERROR("FSR2: failed to create motion vector pipeline");
+            compMod.destroy();
+            destroyFSR2Resources();
+            return false;
+        }
+        compMod.destroy();
+
+        // Descriptor pool + set
+        VkDescriptorPoolSize poolSizes[2] = {};
+        poolSizes[0] = {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1};
+        poolSizes[1] = {VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1};
+        VkDescriptorPoolCreateInfo poolInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO};
+        poolInfo.maxSets = 1;
+        poolInfo.poolSizeCount = 2;
+        poolInfo.pPoolSizes = poolSizes;
+        vkCreateDescriptorPool(device, &poolInfo, nullptr, &fsr2_.motionVecDescPool);
+
+        VkDescriptorSetAllocateInfo dsAI{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
+        dsAI.descriptorPool = fsr2_.motionVecDescPool;
+        dsAI.descriptorSetCount = 1;
+        dsAI.pSetLayouts = &fsr2_.motionVecDescSetLayout;
+        vkAllocateDescriptorSets(device, &dsAI, &fsr2_.motionVecDescSet);
+
+        // Write descriptors
+        VkDescriptorImageInfo depthImgInfo{};
+        depthImgInfo.sampler = fsr2_.nearestSampler;
+        depthImgInfo.imageView = fsr2_.sceneDepth.imageView;
+        depthImgInfo.imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
+
+        VkDescriptorImageInfo mvImgInfo{};
+        mvImgInfo.imageView = fsr2_.motionVectors.imageView;
+        mvImgInfo.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
+
+        VkWriteDescriptorSet writes[2] = {};
+        writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+        writes[0].dstSet = fsr2_.motionVecDescSet;
+        writes[0].dstBinding = 0;
+        writes[0].descriptorCount = 1;
+        writes[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+        writes[0].pImageInfo = &depthImgInfo;
+
+        writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+        writes[1].dstSet = fsr2_.motionVecDescSet;
+        writes[1].dstBinding = 1;
+        writes[1].descriptorCount = 1;
+        writes[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+        writes[1].pImageInfo = &mvImgInfo;
+
+        vkUpdateDescriptorSets(device, 2, writes, 0, nullptr);
+    }
+
+    // --- Temporal Accumulation Compute Pipeline ---
+    {
+        // bindings: 0=sceneColor, 1=depth, 2=motionVectors, 3=historyInput, 4=historyOutput
+        VkDescriptorSetLayoutBinding bindings[5] = {};
+        for (int i = 0; i < 4; i++) {
+            bindings[i].binding = i;
+            bindings[i].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+            bindings[i].descriptorCount = 1;
+            bindings[i].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+        }
+        bindings[4].binding = 4;
+        bindings[4].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+        bindings[4].descriptorCount = 1;
+        bindings[4].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+
+        VkDescriptorSetLayoutCreateInfo layoutInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO};
+        layoutInfo.bindingCount = 5;
+        layoutInfo.pBindings = bindings;
+        vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &fsr2_.accumulateDescSetLayout);
+
+        VkPushConstantRange pc{};
+        pc.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
+        pc.offset = 0;
+        pc.size = 4 * sizeof(glm::vec4);  // 64 bytes
+
+        VkPipelineLayoutCreateInfo plCI{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO};
+        plCI.setLayoutCount = 1;
+        plCI.pSetLayouts = &fsr2_.accumulateDescSetLayout;
+        plCI.pushConstantRangeCount = 1;
+        plCI.pPushConstantRanges = &pc;
+        vkCreatePipelineLayout(device, &plCI, nullptr, &fsr2_.accumulatePipelineLayout);
+
+        VkShaderModule compMod;
+        if (!compMod.loadFromFile(device, "assets/shaders/fsr2_accumulate.comp.spv")) {
+            LOG_ERROR("FSR2: failed to load accumulation compute shader");
+            destroyFSR2Resources();
+            return false;
+        }
+
+        VkComputePipelineCreateInfo cpCI{VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO};
+        cpCI.stage = compMod.stageInfo(VK_SHADER_STAGE_COMPUTE_BIT);
+        cpCI.layout = fsr2_.accumulatePipelineLayout;
+        if (vkCreateComputePipelines(device, VK_NULL_HANDLE, 1, &cpCI, nullptr, &fsr2_.accumulatePipeline) != VK_SUCCESS) {
+            LOG_ERROR("FSR2: failed to create accumulation pipeline");
+            compMod.destroy();
+            destroyFSR2Resources();
+            return false;
+        }
+        compMod.destroy();
+
+        // Descriptor pool: 2 sets (ping-pong), each with 4 samplers + 1 storage image
+        VkDescriptorPoolSize poolSizes[2] = {};
+        poolSizes[0] = {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 8};
+        poolSizes[1] = {VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 2};
+        VkDescriptorPoolCreateInfo poolInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO};
+        poolInfo.maxSets = 2;
+        poolInfo.poolSizeCount = 2;
+        poolInfo.pPoolSizes = poolSizes;
+        vkCreateDescriptorPool(device, &poolInfo, nullptr, &fsr2_.accumulateDescPool);
+
+        // Allocate 2 descriptor sets (one per ping-pong direction)
+        VkDescriptorSetLayout layouts[2] = { fsr2_.accumulateDescSetLayout, fsr2_.accumulateDescSetLayout };
+        VkDescriptorSetAllocateInfo dsAI{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
+        dsAI.descriptorPool = fsr2_.accumulateDescPool;
+        dsAI.descriptorSetCount = 2;
+        dsAI.pSetLayouts = layouts;
+        vkAllocateDescriptorSets(device, &dsAI, fsr2_.accumulateDescSets);
+
+        // Write descriptors for both ping-pong sets
+        for (int pp = 0; pp < 2; pp++) {
+            int inputHistory = 1 - pp;   // Read from the other
+            int outputHistory = pp;       // Write to this one
+
+            // The accumulation shader already performs custom Lanczos reconstruction.
+            // Use nearest here to avoid double filtering (linear + Lanczos) softening.
+            VkDescriptorImageInfo colorInfo{fsr2_.nearestSampler, fsr2_.sceneColor.imageView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL};
+            VkDescriptorImageInfo depthInfo{fsr2_.nearestSampler, fsr2_.sceneDepth.imageView, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL};
+            VkDescriptorImageInfo mvInfo{fsr2_.nearestSampler, fsr2_.motionVectors.imageView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL};
+            VkDescriptorImageInfo histInInfo{fsr2_.linearSampler, fsr2_.history[inputHistory].imageView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL};
+            VkDescriptorImageInfo histOutInfo{VK_NULL_HANDLE, fsr2_.history[outputHistory].imageView, VK_IMAGE_LAYOUT_GENERAL};
+
+            VkWriteDescriptorSet writes[5] = {};
+            for (int w = 0; w < 5; w++) {
+                writes[w].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+                writes[w].dstSet = fsr2_.accumulateDescSets[pp];
+                writes[w].dstBinding = w;
+                writes[w].descriptorCount = 1;
+            }
+            writes[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; writes[0].pImageInfo = &colorInfo;
+            writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; writes[1].pImageInfo = &depthInfo;
+            writes[2].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; writes[2].pImageInfo = &mvInfo;
+            writes[3].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; writes[3].pImageInfo = &histInInfo;
+            writes[4].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;          writes[4].pImageInfo = &histOutInfo;
+
+            vkUpdateDescriptorSets(device, 5, writes, 0, nullptr);
+        }
+    }
+
+    // --- RCAS Sharpening Pipeline (fragment shader, fullscreen pass) ---
+    {
+        VkDescriptorSetLayoutBinding binding{};
+        binding.binding = 0;
+        binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+        binding.descriptorCount = 1;
+        binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
+
+        VkDescriptorSetLayoutCreateInfo layoutInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO};
+        layoutInfo.bindingCount = 1;
+        layoutInfo.pBindings = &binding;
+        vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &fsr2_.sharpenDescSetLayout);
+
+        VkPushConstantRange pc{};
+        pc.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
+        pc.offset = 0;
+        pc.size = sizeof(glm::vec4);
+
+        VkPipelineLayoutCreateInfo plCI{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO};
+        plCI.setLayoutCount = 1;
+        plCI.pSetLayouts = &fsr2_.sharpenDescSetLayout;
+        plCI.pushConstantRangeCount = 1;
+        plCI.pPushConstantRanges = &pc;
+        vkCreatePipelineLayout(device, &plCI, nullptr, &fsr2_.sharpenPipelineLayout);
+
+        VkShaderModule vertMod, fragMod;
+        if (!vertMod.loadFromFile(device, "assets/shaders/postprocess.vert.spv") ||
+            !fragMod.loadFromFile(device, "assets/shaders/fsr2_sharpen.frag.spv")) {
+            LOG_ERROR("FSR2: failed to load sharpen shaders");
+            destroyFSR2Resources();
+            return false;
+        }
+
+        fsr2_.sharpenPipeline = PipelineBuilder()
+            .setShaders(vertMod.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
+                        fragMod.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
+            .setVertexInput({}, {})
+            .setTopology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
+            .setRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE)
+            .setNoDepthTest()
+            .setColorBlendAttachment(PipelineBuilder::blendDisabled())
+            .setMultisample(VK_SAMPLE_COUNT_1_BIT)
+            .setLayout(fsr2_.sharpenPipelineLayout)
+            .setRenderPass(vkCtx->getImGuiRenderPass())
+            .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
+            .build(device);
+
+        vertMod.destroy();
+        fragMod.destroy();
+
+        if (!fsr2_.sharpenPipeline) {
+            LOG_ERROR("FSR2: failed to create sharpen pipeline");
+            destroyFSR2Resources();
+            return false;
+        }
+
+        // Descriptor pool + sets for sharpen pass (double-buffered to avoid race condition)
+        VkDescriptorPoolSize poolSize{VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 2};
+        VkDescriptorPoolCreateInfo poolInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO};
+        poolInfo.maxSets = 2;
+        poolInfo.poolSizeCount = 1;
+        poolInfo.pPoolSizes = &poolSize;
+        vkCreateDescriptorPool(device, &poolInfo, nullptr, &fsr2_.sharpenDescPool);
+
+        VkDescriptorSetLayout layouts[2] = {fsr2_.sharpenDescSetLayout, fsr2_.sharpenDescSetLayout};
+        VkDescriptorSetAllocateInfo dsAI{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
+        dsAI.descriptorPool = fsr2_.sharpenDescPool;
+        dsAI.descriptorSetCount = 2;
+        dsAI.pSetLayouts = layouts;
+        vkAllocateDescriptorSets(device, &dsAI, fsr2_.sharpenDescSets);
+        // Descriptors updated dynamically each frame to point at the correct history buffer
+    }
+
+    fsr2_.needsHistoryReset = true;
+    fsr2_.frameIndex = 0;
+    LOG_INFO("FSR2: initialized successfully");
+    return true;
+}
+
+void Renderer::destroyFSR2Resources() {
+    if (!vkCtx) return;
+
+    VkDevice device = vkCtx->getDevice();
+    VmaAllocator alloc = vkCtx->getAllocator();
+    vkDeviceWaitIdle(device);
+
+#if WOWEE_HAS_AMD_FSR2
+    if (fsr2_.useAmdBackend) {
+        ffxFsr2ContextDestroy(&fsr2_.amdContext);
+        fsr2_.useAmdBackend = false;
+    }
+    if (fsr2_.amdScratchBuffer) {
+        std::free(fsr2_.amdScratchBuffer);
+        fsr2_.amdScratchBuffer = nullptr;
+    }
+    fsr2_.amdScratchBufferSize = 0;
+#endif
+    fsr2_.amdFsr3FramegenRuntimeActive = false;
+    fsr2_.amdFsr3FramegenRuntimeReady = false;
+    fsr2_.framegenOutputValid = false;
+    fsr2_.amdFsr3RuntimePath = "Path C";
+    fsr2_.amdFsr3RuntimeLastError.clear();
+    fsr2_.amdFsr3InteropSyncValue = 1;
+#if WOWEE_HAS_AMD_FSR3_FRAMEGEN
+    if (fsr2_.amdFsr3Runtime) {
+        fsr2_.amdFsr3Runtime->shutdown();
+        fsr2_.amdFsr3Runtime.reset();
+    }
+#endif
+
+    if (fsr2_.sharpenPipeline) { vkDestroyPipeline(device, fsr2_.sharpenPipeline, nullptr); fsr2_.sharpenPipeline = VK_NULL_HANDLE; }
+    if (fsr2_.sharpenPipelineLayout) { vkDestroyPipelineLayout(device, fsr2_.sharpenPipelineLayout, nullptr); fsr2_.sharpenPipelineLayout = VK_NULL_HANDLE; }
+    if (fsr2_.sharpenDescPool) { vkDestroyDescriptorPool(device, fsr2_.sharpenDescPool, nullptr); fsr2_.sharpenDescPool = VK_NULL_HANDLE; fsr2_.sharpenDescSets[0] = fsr2_.sharpenDescSets[1] = VK_NULL_HANDLE; }
+    if (fsr2_.sharpenDescSetLayout) { vkDestroyDescriptorSetLayout(device, fsr2_.sharpenDescSetLayout, nullptr); fsr2_.sharpenDescSetLayout = VK_NULL_HANDLE; }
+
+    if (fsr2_.accumulatePipeline) { vkDestroyPipeline(device, fsr2_.accumulatePipeline, nullptr); fsr2_.accumulatePipeline = VK_NULL_HANDLE; }
+    if (fsr2_.accumulatePipelineLayout) { vkDestroyPipelineLayout(device, fsr2_.accumulatePipelineLayout, nullptr); fsr2_.accumulatePipelineLayout = VK_NULL_HANDLE; }
+    if (fsr2_.accumulateDescPool) { vkDestroyDescriptorPool(device, fsr2_.accumulateDescPool, nullptr); fsr2_.accumulateDescPool = VK_NULL_HANDLE; fsr2_.accumulateDescSets[0] = fsr2_.accumulateDescSets[1] = VK_NULL_HANDLE; }
+    if (fsr2_.accumulateDescSetLayout) { vkDestroyDescriptorSetLayout(device, fsr2_.accumulateDescSetLayout, nullptr); fsr2_.accumulateDescSetLayout = VK_NULL_HANDLE; }
+
+    if (fsr2_.motionVecPipeline) { vkDestroyPipeline(device, fsr2_.motionVecPipeline, nullptr); fsr2_.motionVecPipeline = VK_NULL_HANDLE; }
+    if (fsr2_.motionVecPipelineLayout) { vkDestroyPipelineLayout(device, fsr2_.motionVecPipelineLayout, nullptr); fsr2_.motionVecPipelineLayout = VK_NULL_HANDLE; }
+    if (fsr2_.motionVecDescPool) { vkDestroyDescriptorPool(device, fsr2_.motionVecDescPool, nullptr); fsr2_.motionVecDescPool = VK_NULL_HANDLE; fsr2_.motionVecDescSet = VK_NULL_HANDLE; }
+    if (fsr2_.motionVecDescSetLayout) { vkDestroyDescriptorSetLayout(device, fsr2_.motionVecDescSetLayout, nullptr); fsr2_.motionVecDescSetLayout = VK_NULL_HANDLE; }
+
+    if (fsr2_.sceneFramebuffer) { vkDestroyFramebuffer(device, fsr2_.sceneFramebuffer, nullptr); fsr2_.sceneFramebuffer = VK_NULL_HANDLE; }
+    if (fsr2_.linearSampler) { vkDestroySampler(device, fsr2_.linearSampler, nullptr); fsr2_.linearSampler = VK_NULL_HANDLE; }
+    if (fsr2_.nearestSampler) { vkDestroySampler(device, fsr2_.nearestSampler, nullptr); fsr2_.nearestSampler = VK_NULL_HANDLE; }
+
+    destroyImage(device, alloc, fsr2_.motionVectors);
+    for (int i = 0; i < 2; i++) destroyImage(device, alloc, fsr2_.history[i]);
+    destroyImage(device, alloc, fsr2_.framegenOutput);
+    destroyImage(device, alloc, fsr2_.sceneDepth);
+    destroyImage(device, alloc, fsr2_.sceneColor);
+
+    fsr2_.internalWidth = 0;
+    fsr2_.internalHeight = 0;
+}
+
+void Renderer::dispatchMotionVectors() {
+    if (!fsr2_.motionVecPipeline || currentCmd == VK_NULL_HANDLE) return;
+
+    // Transition depth: DEPTH_STENCIL_ATTACHMENT → DEPTH_STENCIL_READ_ONLY
+    transitionImageLayout(currentCmd, fsr2_.sceneDepth.image,
+        VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+        VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
+        VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+
+    // Transition motion vectors: UNDEFINED → GENERAL
+    transitionImageLayout(currentCmd, fsr2_.motionVectors.image,
+        VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
+        VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+
+    vkCmdBindPipeline(currentCmd, VK_PIPELINE_BIND_POINT_COMPUTE, fsr2_.motionVecPipeline);
+    vkCmdBindDescriptorSets(currentCmd, VK_PIPELINE_BIND_POINT_COMPUTE,
+        fsr2_.motionVecPipelineLayout, 0, 1, &fsr2_.motionVecDescSet, 0, nullptr);
+
+    // Reprojection with jittered matrices:
+    // reconstruct world position from current depth, then project into previous clip.
+    struct {
+        glm::mat4 prevViewProjection;
+        glm::mat4 invCurrentViewProj;
+    } pc;
+
+    glm::mat4 currentVP = camera->getViewProjectionMatrix();
+    pc.prevViewProjection = fsr2_.prevViewProjection;
+    pc.invCurrentViewProj = glm::inverse(currentVP);
+
+    vkCmdPushConstants(currentCmd, fsr2_.motionVecPipelineLayout,
+        VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pc), &pc);
+
+    uint32_t gx = (fsr2_.internalWidth + 7) / 8;
+    uint32_t gy = (fsr2_.internalHeight + 7) / 8;
+    vkCmdDispatch(currentCmd, gx, gy, 1);
+
+    // Transition motion vectors: GENERAL → SHADER_READ_ONLY for accumulation
+    transitionImageLayout(currentCmd, fsr2_.motionVectors.image,
+        VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+}
+
+void Renderer::dispatchTemporalAccumulate() {
+    if (!fsr2_.accumulatePipeline || currentCmd == VK_NULL_HANDLE) return;
+
+    VkExtent2D swapExtent = vkCtx->getSwapchainExtent();
+    uint32_t outputIdx = fsr2_.currentHistory;
+    uint32_t inputIdx = 1 - outputIdx;
+
+    // Transition scene color: PRESENT_SRC_KHR → SHADER_READ_ONLY
+    transitionImageLayout(currentCmd, fsr2_.sceneColor.image,
+        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+
+    // History layout lifecycle:
+    //   First frame: both in UNDEFINED
+    //   Subsequent frames: both in SHADER_READ_ONLY (output was transitioned for sharpen,
+    //                      input was left in SHADER_READ_ONLY from its sharpen read)
+    VkImageLayout historyOldLayout = fsr2_.needsHistoryReset
+        ? VK_IMAGE_LAYOUT_UNDEFINED
+        : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+
+    // Transition history input: SHADER_READ_ONLY → SHADER_READ_ONLY (barrier for sync)
+    transitionImageLayout(currentCmd, fsr2_.history[inputIdx].image,
+        historyOldLayout, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+        VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,  // sharpen read in previous frame
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+
+    // Transition history output: SHADER_READ_ONLY → GENERAL (for compute write)
+    transitionImageLayout(currentCmd, fsr2_.history[outputIdx].image,
+        historyOldLayout, VK_IMAGE_LAYOUT_GENERAL,
+        VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+
+    vkCmdBindPipeline(currentCmd, VK_PIPELINE_BIND_POINT_COMPUTE, fsr2_.accumulatePipeline);
+    vkCmdBindDescriptorSets(currentCmd, VK_PIPELINE_BIND_POINT_COMPUTE,
+        fsr2_.accumulatePipelineLayout, 0, 1, &fsr2_.accumulateDescSets[outputIdx], 0, nullptr);
+
+    // Push constants
+    struct {
+        glm::vec4 internalSize;
+        glm::vec4 displaySize;
+        glm::vec4 jitterOffset;
+        glm::vec4 params;
+    } pc;
+
+    pc.internalSize = glm::vec4(
+        static_cast<float>(fsr2_.internalWidth), static_cast<float>(fsr2_.internalHeight),
+        1.0f / fsr2_.internalWidth, 1.0f / fsr2_.internalHeight);
+    pc.displaySize = glm::vec4(
+        static_cast<float>(swapExtent.width), static_cast<float>(swapExtent.height),
+        1.0f / swapExtent.width, 1.0f / swapExtent.height);
+    glm::vec2 jitter = camera->getJitter();
+    pc.jitterOffset = glm::vec4(jitter.x, jitter.y, 0.0f, 0.0f);
+    pc.params = glm::vec4(
+        fsr2_.needsHistoryReset ? 1.0f : 0.0f,
+        fsr2_.sharpness,
+        static_cast<float>(fsr2_.convergenceFrame),
+        0.0f);
+
+    vkCmdPushConstants(currentCmd, fsr2_.accumulatePipelineLayout,
+        VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pc), &pc);
+
+    uint32_t gx = (swapExtent.width + 7) / 8;
+    uint32_t gy = (swapExtent.height + 7) / 8;
+    vkCmdDispatch(currentCmd, gx, gy, 1);
+
+    fsr2_.needsHistoryReset = false;
+}
+
+void Renderer::dispatchAmdFsr2() {
+    if (currentCmd == VK_NULL_HANDLE || !camera) return;
+#if WOWEE_HAS_AMD_FSR2
+    if (!fsr2_.useAmdBackend) return;
+
+    VkExtent2D swapExtent = vkCtx->getSwapchainExtent();
+    uint32_t outputIdx = fsr2_.currentHistory;
+
+    transitionImageLayout(currentCmd, fsr2_.sceneColor.image,
+        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+    transitionImageLayout(currentCmd, fsr2_.motionVectors.image,
+        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+    transitionImageLayout(currentCmd, fsr2_.sceneDepth.image,
+        VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+    transitionImageLayout(currentCmd, fsr2_.history[outputIdx].image,
+        fsr2_.needsHistoryReset ? VK_IMAGE_LAYOUT_UNDEFINED : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+        VK_IMAGE_LAYOUT_GENERAL,
+        VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+
+    FfxFsr2DispatchDescription desc{};
+    desc.commandList = ffxGetCommandListVK(currentCmd);
+    desc.color = ffxGetTextureResourceVK(&fsr2_.amdContext,
+        fsr2_.sceneColor.image, fsr2_.sceneColor.imageView,
+        fsr2_.internalWidth, fsr2_.internalHeight, vkCtx->getSwapchainFormat(),
+        L"FSR2_InputColor", FFX_RESOURCE_STATE_COMPUTE_READ);
+    desc.depth = ffxGetTextureResourceVK(&fsr2_.amdContext,
+        fsr2_.sceneDepth.image, fsr2_.sceneDepth.imageView,
+        fsr2_.internalWidth, fsr2_.internalHeight, vkCtx->getDepthFormat(),
+        L"FSR2_InputDepth", FFX_RESOURCE_STATE_COMPUTE_READ);
+    desc.motionVectors = ffxGetTextureResourceVK(&fsr2_.amdContext,
+        fsr2_.motionVectors.image, fsr2_.motionVectors.imageView,
+        fsr2_.internalWidth, fsr2_.internalHeight, VK_FORMAT_R16G16_SFLOAT,
+        L"FSR2_InputMotionVectors", FFX_RESOURCE_STATE_COMPUTE_READ);
+    desc.output = ffxGetTextureResourceVK(&fsr2_.amdContext,
+        fsr2_.history[outputIdx].image, fsr2_.history[outputIdx].imageView,
+        swapExtent.width, swapExtent.height, VK_FORMAT_R16G16B16A16_SFLOAT,
+        L"FSR2_Output", FFX_RESOURCE_STATE_UNORDERED_ACCESS);
+
+    // Camera jitter is stored as NDC projection offsets; convert to render-pixel offsets.
+    // Do not apply jitterSign again here: it is already baked into camera jitter.
+    glm::vec2 jitterNdc = camera->getJitter();
+    desc.jitterOffset.x = jitterNdc.x * 0.5f * static_cast<float>(fsr2_.internalWidth);
+    desc.jitterOffset.y = jitterNdc.y * 0.5f * static_cast<float>(fsr2_.internalHeight);
+    desc.motionVectorScale.x = static_cast<float>(fsr2_.internalWidth) * fsr2_.motionVecScaleX;
+    desc.motionVectorScale.y = static_cast<float>(fsr2_.internalHeight) * fsr2_.motionVecScaleY;
+    desc.renderSize.width = fsr2_.internalWidth;
+    desc.renderSize.height = fsr2_.internalHeight;
+    desc.enableSharpening = false;  // Keep existing RCAS post pass.
+    desc.sharpness = 0.0f;
+    desc.frameTimeDelta = glm::max(0.001f, lastDeltaTime_ * 1000.0f);
+    desc.preExposure = 1.0f;
+    desc.reset = fsr2_.needsHistoryReset;
+    desc.cameraNear = camera->getNearPlane();
+    desc.cameraFar = camera->getFarPlane();
+    desc.cameraFovAngleVertical = glm::radians(camera->getFovDegrees());
+    desc.viewSpaceToMetersFactor = 1.0f;
+    desc.enableAutoReactive = false;
+
+    FfxErrorCode dispatchErr = ffxFsr2ContextDispatch(&fsr2_.amdContext, &desc);
+    if (dispatchErr != FFX_OK) {
+        LOG_WARNING("FSR2 AMD: dispatch failed (", static_cast<int>(dispatchErr), "), forcing history reset.");
+        fsr2_.needsHistoryReset = true;
+    } else {
+        fsr2_.needsHistoryReset = false;
+    }
+#endif
+}
+
+void Renderer::dispatchAmdFsr3Framegen() {
+#if WOWEE_HAS_AMD_FSR3_FRAMEGEN
+    if (!fsr2_.amdFsr3FramegenEnabled) {
+        fsr2_.amdFsr3FramegenRuntimeActive = false;
+        return;
+    }
+    if (!fsr2_.amdFsr3Runtime || !fsr2_.amdFsr3FramegenRuntimeReady) {
+        fsr2_.amdFsr3FramegenRuntimeActive = false;
+        return;
+    }
+    uint32_t outputIdx = fsr2_.currentHistory;
+    transitionImageLayout(currentCmd, fsr2_.sceneColor.image,
+        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+    transitionImageLayout(currentCmd, fsr2_.motionVectors.image,
+        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+    transitionImageLayout(currentCmd, fsr2_.sceneDepth.image,
+        VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+    transitionImageLayout(currentCmd, fsr2_.history[outputIdx].image,
+        fsr2_.needsHistoryReset ? VK_IMAGE_LAYOUT_UNDEFINED : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+        VK_IMAGE_LAYOUT_GENERAL,
+        VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+    if (fsr2_.amdFsr3FramegenEnabled && fsr2_.framegenOutput.image) {
+        transitionImageLayout(currentCmd, fsr2_.framegenOutput.image,
+            fsr2_.framegenOutputValid ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED,
+            VK_IMAGE_LAYOUT_GENERAL,
+            VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+            VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+    }
+
+    AmdFsr3RuntimeDispatchDesc fgDispatch{};
+    fgDispatch.commandBuffer = currentCmd;
+    fgDispatch.colorImage = fsr2_.sceneColor.image;
+    fgDispatch.depthImage = fsr2_.sceneDepth.image;
+    fgDispatch.motionVectorImage = fsr2_.motionVectors.image;
+    fgDispatch.outputImage = fsr2_.history[fsr2_.currentHistory].image;
+    fgDispatch.renderWidth = fsr2_.internalWidth;
+    fgDispatch.renderHeight = fsr2_.internalHeight;
+    fgDispatch.outputWidth = vkCtx->getSwapchainExtent().width;
+    fgDispatch.outputHeight = vkCtx->getSwapchainExtent().height;
+    fgDispatch.colorFormat = VK_FORMAT_R16G16B16A16_SFLOAT;
+    fgDispatch.depthFormat = vkCtx->getDepthFormat();
+    fgDispatch.motionVectorFormat = VK_FORMAT_R16G16_SFLOAT;
+    fgDispatch.outputFormat = VK_FORMAT_R16G16B16A16_SFLOAT;
+    fgDispatch.frameGenOutputImage = fsr2_.framegenOutput.image;
+    glm::vec2 jitterNdc = camera ? camera->getJitter() : glm::vec2(0.0f);
+    fgDispatch.jitterX = jitterNdc.x * 0.5f * static_cast<float>(fsr2_.internalWidth);
+    fgDispatch.jitterY = jitterNdc.y * 0.5f * static_cast<float>(fsr2_.internalHeight);
+    fgDispatch.motionScaleX = static_cast<float>(fsr2_.internalWidth) * fsr2_.motionVecScaleX;
+    fgDispatch.motionScaleY = static_cast<float>(fsr2_.internalHeight) * fsr2_.motionVecScaleY;
+    fgDispatch.frameTimeDeltaMs = glm::max(0.001f, lastDeltaTime_ * 1000.0f);
+    fgDispatch.cameraNear = camera ? camera->getNearPlane() : 0.1f;
+    fgDispatch.cameraFar = camera ? camera->getFarPlane() : 1000.0f;
+    fgDispatch.cameraFovYRadians = camera ? glm::radians(camera->getFovDegrees()) : 1.0f;
+    fgDispatch.reset = fsr2_.needsHistoryReset;
+
+
+    if (!fsr2_.amdFsr3Runtime->dispatchUpscale(fgDispatch)) {
+        static bool warnedRuntimeDispatch = false;
+        if (!warnedRuntimeDispatch) {
+            warnedRuntimeDispatch = true;
+            LOG_WARNING("FSR3 runtime upscale dispatch failed; falling back to FSR2 dispatch output.");
+        }
+        fsr2_.amdFsr3RuntimeLastError = fsr2_.amdFsr3Runtime->lastError();
+        fsr2_.amdFsr3FallbackCount++;
+        fsr2_.amdFsr3FramegenRuntimeActive = false;
+        return;
+    }
+    fsr2_.amdFsr3RuntimeLastError.clear();
+    fsr2_.amdFsr3UpscaleDispatchCount++;
+
+    if (!fsr2_.amdFsr3FramegenEnabled) {
+        fsr2_.amdFsr3FramegenRuntimeActive = false;
+        return;
+    }
+    if (!fsr2_.amdFsr3Runtime->isFrameGenerationReady()) {
+        fsr2_.amdFsr3FramegenRuntimeActive = false;
+        return;
+    }
+    if (!fsr2_.amdFsr3Runtime->dispatchFrameGeneration(fgDispatch)) {
+        static bool warnedFgDispatch = false;
+        if (!warnedFgDispatch) {
+            warnedFgDispatch = true;
+            LOG_WARNING("FSR3 runtime frame generation dispatch failed; using upscaled output only.");
+        }
+        fsr2_.amdFsr3RuntimeLastError = fsr2_.amdFsr3Runtime->lastError();
+        fsr2_.amdFsr3FallbackCount++;
+        fsr2_.amdFsr3FramegenRuntimeActive = false;
+        return;
+    }
+    fsr2_.amdFsr3RuntimeLastError.clear();
+    fsr2_.amdFsr3FramegenDispatchCount++;
+    fsr2_.framegenOutputValid = true;
+    fsr2_.amdFsr3FramegenRuntimeActive = true;
+#else
+    fsr2_.amdFsr3FramegenRuntimeActive = false;
+#endif
+}
+
+void Renderer::renderFSR2Sharpen() {
+    if (!fsr2_.sharpenPipeline || currentCmd == VK_NULL_HANDLE) return;
+
+    VkExtent2D ext = vkCtx->getSwapchainExtent();
+    uint32_t outputIdx = fsr2_.currentHistory;
+
+    // Use per-frame descriptor set to avoid race with in-flight command buffers
+    uint32_t frameIdx = vkCtx->getCurrentFrame();
+    VkDescriptorSet descSet = fsr2_.sharpenDescSets[frameIdx];
+
+    // Update sharpen descriptor to point at current history output
+    VkDescriptorImageInfo imgInfo{};
+    imgInfo.sampler = fsr2_.linearSampler;
+    if (fsr2_.useAmdBackend) {
+        imgInfo.imageView = (fsr2_.amdFsr3FramegenEnabled && fsr2_.amdFsr3FramegenRuntimeActive && fsr2_.framegenOutput.imageView)
+            ? fsr2_.framegenOutput.imageView
+            : fsr2_.history[outputIdx].imageView;
+    } else {
+        imgInfo.imageView = fsr2_.sceneColor.imageView;
+    }
+    imgInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+
+    VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
+    write.dstSet = descSet;
+    write.dstBinding = 0;
+    write.descriptorCount = 1;
+    write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+    write.pImageInfo = &imgInfo;
+    vkUpdateDescriptorSets(vkCtx->getDevice(), 1, &write, 0, nullptr);
+
+    vkCmdBindPipeline(currentCmd, VK_PIPELINE_BIND_POINT_GRAPHICS, fsr2_.sharpenPipeline);
+    vkCmdBindDescriptorSets(currentCmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
+        fsr2_.sharpenPipelineLayout, 0, 1, &descSet, 0, nullptr);
+
+    glm::vec4 params(1.0f / ext.width, 1.0f / ext.height, fsr2_.sharpness, 0.0f);
+    vkCmdPushConstants(currentCmd, fsr2_.sharpenPipelineLayout,
+        VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(glm::vec4), &params);
+
+    vkCmdDraw(currentCmd, 3, 1, 0, 0);
 }
 
 void Renderer::setFSR2Enabled(bool enabled) {
-    if (!postProcessPipeline_) return;
-    auto req = postProcessPipeline_->setFSR2Enabled(enabled, camera.get());
-    if (req.requested) {
-        pendingMsaaSamples_ = req.samples;
-        msaaChangePending_ = true;
-    }
-    // If enabling FSR2 and there's already a pending MSAA change to >1x
-    // (e.g. startup settings loaded MSAA before FSR2), override it to 1x.
-    if (enabled && msaaChangePending_ && pendingMsaaSamples_ > VK_SAMPLE_COUNT_1_BIT) {
-        pendingMsaaSamples_ = VK_SAMPLE_COUNT_1_BIT;
+    if (fsr2_.enabled == enabled) return;
+    fsr2_.enabled = enabled;
+
+    if (enabled) {
+        static bool initFramegenToggleFromEnv = false;
+        if (!initFramegenToggleFromEnv) {
+            initFramegenToggleFromEnv = true;
+            if (std::getenv("WOWEE_ENABLE_AMD_FSR3_FRAMEGEN_RUNTIME") != nullptr) {
+                fsr2_.amdFsr3FramegenEnabled = true;
+            }
+        }
+        // FSR2 replaces both FSR1 and MSAA
+        if (fsr_.enabled) {
+            fsr_.enabled = false;
+            fsr_.needsRecreate = true;
+        }
+        // FSR2 requires non-MSAA render pass (its framebuffer has 2 attachments)
+        if (vkCtx && vkCtx->getMsaaSamples() > VK_SAMPLE_COUNT_1_BIT) {
+            pendingMsaaSamples_ = VK_SAMPLE_COUNT_1_BIT;
+            msaaChangePending_ = true;
+        }
+        // Use FSR1's scale factor and sharpness as defaults
+        fsr2_.scaleFactor = fsr_.scaleFactor;
+        fsr2_.sharpness = fsr_.sharpness;
+        fsr2_.needsHistoryReset = true;
+    } else {
+        fsr2_.needsRecreate = true;
+        if (camera) camera->clearJitter();
     }
 }
-bool Renderer::isFSR2Enabled() const {
-    return postProcessPipeline_ && postProcessPipeline_->isFSR2Enabled();
-}
+
 void Renderer::setFSR2DebugTuning(float jitterSign, float motionVecScaleX, float motionVecScaleY) {
-    if (postProcessPipeline_) postProcessPipeline_->setFSR2DebugTuning(jitterSign, motionVecScaleX, motionVecScaleY);
+    fsr2_.jitterSign = glm::clamp(jitterSign, -2.0f, 2.0f);
+    fsr2_.motionVecScaleX = glm::clamp(motionVecScaleX, -2.0f, 2.0f);
+    fsr2_.motionVecScaleY = glm::clamp(motionVecScaleY, -2.0f, 2.0f);
 }
 
 void Renderer::setAmdFsr3FramegenEnabled(bool enabled) {
-    if (postProcessPipeline_) postProcessPipeline_->setAmdFsr3FramegenEnabled(enabled);
-}
-bool Renderer::isAmdFsr3FramegenEnabled() const {
-    return postProcessPipeline_ && postProcessPipeline_->isAmdFsr3FramegenEnabled();
-}
-float Renderer::getFSR2JitterSign() const {
-    return postProcessPipeline_ ? postProcessPipeline_->getFSR2JitterSign() : 1.0f;
-}
-float Renderer::getFSR2MotionVecScaleX() const {
-    return postProcessPipeline_ ? postProcessPipeline_->getFSR2MotionVecScaleX() : 1.0f;
-}
-float Renderer::getFSR2MotionVecScaleY() const {
-    return postProcessPipeline_ ? postProcessPipeline_->getFSR2MotionVecScaleY() : 1.0f;
-}
-bool Renderer::isAmdFsr2SdkAvailable() const {
-    return postProcessPipeline_ && postProcessPipeline_->isAmdFsr2SdkAvailable();
-}
-bool Renderer::isAmdFsr3FramegenSdkAvailable() const {
-    return postProcessPipeline_ && postProcessPipeline_->isAmdFsr3FramegenSdkAvailable();
-}
-bool Renderer::isAmdFsr3FramegenRuntimeActive() const {
-    return postProcessPipeline_ && postProcessPipeline_->isAmdFsr3FramegenRuntimeActive();
-}
-bool Renderer::isAmdFsr3FramegenRuntimeReady() const {
-    return postProcessPipeline_ && postProcessPipeline_->isAmdFsr3FramegenRuntimeReady();
-}
-const char* Renderer::getAmdFsr3FramegenRuntimePath() const {
-    return postProcessPipeline_ ? postProcessPipeline_->getAmdFsr3FramegenRuntimePath() : "";
-}
-const std::string& Renderer::getAmdFsr3FramegenRuntimeError() const {
-    static const std::string empty;
-    return postProcessPipeline_ ? postProcessPipeline_->getAmdFsr3FramegenRuntimeError() : empty;
-}
-size_t Renderer::getAmdFsr3UpscaleDispatchCount() const {
-    return postProcessPipeline_ ? postProcessPipeline_->getAmdFsr3UpscaleDispatchCount() : 0;
-}
-size_t Renderer::getAmdFsr3FramegenDispatchCount() const {
-    return postProcessPipeline_ ? postProcessPipeline_->getAmdFsr3FramegenDispatchCount() : 0;
-}
-size_t Renderer::getAmdFsr3FallbackCount() const {
-    return postProcessPipeline_ ? postProcessPipeline_->getAmdFsr3FallbackCount() : 0;
-}
-void Renderer::setBrightness(float b) {
-    if (postProcessPipeline_) postProcessPipeline_->setBrightness(b);
-}
-float Renderer::getBrightness() const {
-    return postProcessPipeline_ ? postProcessPipeline_->getBrightness() : 1.0f;
+    if (fsr2_.amdFsr3FramegenEnabled == enabled) return;
+    fsr2_.amdFsr3FramegenEnabled = enabled;
+#if WOWEE_HAS_AMD_FSR3_FRAMEGEN
+    if (enabled) {
+        fsr2_.amdFsr3FramegenRuntimeActive = false;
+        fsr2_.framegenOutputValid = false;
+        fsr2_.needsRecreate = true;
+        fsr2_.needsHistoryReset = true;
+        fsr2_.amdFsr3FramegenRuntimeReady = false;
+        fsr2_.amdFsr3RuntimePath = "Path C";
+        fsr2_.amdFsr3RuntimeLastError.clear();
+        LOG_INFO("FSR3 framegen requested; runtime will initialize on next FSR2 resource creation.");
+    } else {
+        fsr2_.amdFsr3FramegenRuntimeActive = false;
+        fsr2_.amdFsr3FramegenRuntimeReady = false;
+        fsr2_.framegenOutputValid = false;
+        fsr2_.needsHistoryReset = true;
+        fsr2_.needsRecreate = true;
+        fsr2_.amdFsr3RuntimePath = "Path C";
+        fsr2_.amdFsr3RuntimeLastError = "disabled by user";
+        if (fsr2_.amdFsr3Runtime) {
+            fsr2_.amdFsr3Runtime->shutdown();
+            fsr2_.amdFsr3Runtime.reset();
+        }
+        LOG_INFO("FSR3 framegen disabled; forcing FSR2-only path rebuild.");
+    }
+#else
+    fsr2_.amdFsr3FramegenRuntimeActive = false;
+    fsr2_.amdFsr3FramegenRuntimeReady = false;
+    fsr2_.framegenOutputValid = false;
+    if (enabled) {
+        LOG_WARNING("FSR3 framegen requested, but AMD FSR3 framegen SDK headers are unavailable in this build.");
+    }
+#endif
 }
 
+// ========================= End FSR 2.2 =========================
+
 void Renderer::renderWorld(game::World* world, game::GameHandler* gameHandler) {
-    ZoneScopedN("Renderer::renderWorld");
     (void)world;
 
     // Guard against null command buffer (e.g. after VK_ERROR_DEVICE_LOST)
@@ -2025,9 +4678,6 @@ void Renderer::renderWorld(game::World* world, game::GameHandler* gameHandler) {
     lastWMORenderMs = 0.0;
     lastM2RenderMs = 0.0;
 
-    // Cache ghost state for use in overlay and FXAA passes this frame.
-    ghostMode_ = (gameHandler && gameHandler->isPlayerGhost());
-
     uint32_t frameIdx = vkCtx->getCurrentFrame();
     VkDescriptorSet perFrameSet = perFrameDescSets[frameIdx];
     const glm::mat4& view = camera ? camera->getViewMatrix() : glm::mat4(1.0f);
@@ -2041,8 +4691,7 @@ void Renderer::renderWorld(game::World* world, game::GameHandler* gameHandler) {
     static const bool skipSky = (std::getenv("WOWEE_SKIP_SKY") != nullptr);
 
     // Get time of day for sky-related rendering
-    auto* skybox = skySystem ? skySystem->getSkybox() : nullptr;
-    float timeOfDay = skybox ? skybox->getTimeOfDay() : 12.0f;
+    float timeOfDay = (skySystem && skySystem->getSkybox()) ? skySystem->getSkybox()->getTimeOfDay() : 12.0f;
 
     // ── Multithreaded secondary command buffer recording ──
     // Terrain, WMO, and M2 record on worker threads while main thread handles
@@ -2078,7 +4727,7 @@ void Renderer::renderWorld(game::World* world, game::GameHandler* gameHandler) {
                 auto t0 = std::chrono::steady_clock::now();
                 VkCommandBuffer cmd = beginSecondary(SEC_WMO);
                 setSecondaryViewportScissor(cmd);
-                wmoRenderer->render(cmd, perFrameSet, *camera, &characterPosition);
+                wmoRenderer->render(cmd, perFrameSet, *camera);
                 vkEndCommandBuffer(cmd);
                 return std::chrono::duration<double, std::milli>(
                     std::chrono::steady_clock::now() - t0).count();
@@ -2093,7 +4742,6 @@ void Renderer::renderWorld(game::World* world, game::GameHandler* gameHandler) {
                 m2Renderer->render(cmd, perFrameSet, *camera);
                 m2Renderer->renderSmokeParticles(cmd, perFrameSet);
                 m2Renderer->renderM2Particles(cmd, perFrameSet);
-                m2Renderer->renderM2Ribbons(cmd, perFrameSet);
                 vkEndCommandBuffer(cmd);
                 return std::chrono::duration<double, std::milli>(
                     std::chrono::steady_clock::now() - t0).count();
@@ -2140,15 +4788,9 @@ void Renderer::renderWorld(game::World* world, game::GameHandler* gameHandler) {
         }
 
         // --- Wait for workers ---
-        // Guard with try-catch: future::get() re-throws any exception from the
-        // async task. Without this, a single bad_alloc in a render worker would
-        // propagate as an unhandled exception and terminate the process.
-        try { if (terrainFuture.valid()) lastTerrainRenderMs = terrainFuture.get(); }
-        catch (const std::exception& e) { LOG_ERROR("Terrain render worker: ", e.what()); }
-        try { if (wmoFuture.valid()) lastWMORenderMs = wmoFuture.get(); }
-        catch (const std::exception& e) { LOG_ERROR("WMO render worker: ", e.what()); }
-        try { if (m2Future.valid()) lastM2RenderMs = m2Future.get(); }
-        catch (const std::exception& e) { LOG_ERROR("M2 render worker: ", e.what()); }
+        if (terrainFuture.valid()) lastTerrainRenderMs = terrainFuture.get();
+        if (wmoFuture.valid()) lastWMORenderMs = wmoFuture.get();
+        if (m2Future.valid()) lastM2RenderMs = m2Future.get();
 
         // --- Main thread: record post-opaque (SEC_POST) ---
         {
@@ -2157,7 +4799,6 @@ void Renderer::renderWorld(game::World* world, game::GameHandler* gameHandler) {
             if (waterRenderer && camera)
                 waterRenderer->render(cmd, perFrameSet, *camera, globalTime, false, frameIdx);
             if (weather && camera) weather->render(cmd, perFrameSet);
-            if (lightning && camera && lightning->isEnabled()) lightning->render(cmd, perFrameSet);
             if (swimEffects && camera) swimEffects->render(cmd, perFrameSet);
             if (mountDust && camera) mountDust->render(cmd, perFrameSet);
             if (chargeEffect && camera) chargeEffect->render(cmd, perFrameSet);
@@ -2182,20 +4823,6 @@ void Renderer::renderWorld(game::World* world, game::GameHandler* gameHandler) {
                     renderOverlay(tint, cmd);
                 }
             }
-            // Ghost mode desaturation: cold blue-grey overlay when dead/ghost
-            if (ghostMode_) {
-                renderOverlay(glm::vec4(0.30f, 0.35f, 0.42f, 0.45f), cmd);
-            }
-            // Brightness overlay (applied before minimap so it doesn't affect UI)
-            {
-                float br = postProcessPipeline_ ? postProcessPipeline_->getBrightness() : 1.0f;
-                if (br < 0.99f) {
-                    renderOverlay(glm::vec4(0.0f, 0.0f, 0.0f, 1.0f - br), cmd);
-                } else if (br > 1.01f) {
-                    float alpha = (br - 1.0f) / 1.0f;
-                    renderOverlay(glm::vec4(1.0f, 1.0f, 1.0f, alpha), cmd);
-                }
-            }
             if (minimap && minimap->isEnabled() && camera && window) {
                 glm::vec3 minimapCenter = camera->getPosition();
                 if (cameraController && cameraController->isThirdPerson())
@@ -2205,14 +4832,10 @@ void Renderer::renderWorld(game::World* world, game::GameHandler* gameHandler) {
                 if (cameraController) {
                     float facingRad = glm::radians(characterYaw);
                     glm::vec3 facingFwd(std::cos(facingRad), std::sin(facingRad), 0.0f);
-                    // atan2(-x,y) = canonical yaw (0=North); negate for shader convention.
-                    minimapPlayerOrientation = -std::atan2(-facingFwd.x, facingFwd.y);
+                    minimapPlayerOrientation = std::atan2(-facingFwd.x, facingFwd.y);
                     hasMinimapPlayerOrientation = true;
                 } else if (gameHandler) {
-                    // movementInfo.orientation is canonical yaw: 0=North, π/2=East.
-                    // Minimap shader: arrowRotation=0 points up (North), positive rotates CW
-                    // (π/2=West, -π/2=East). Correct mapping: arrowRotation = -canonical_yaw.
-                    minimapPlayerOrientation = -gameHandler->getMovementInfo().orientation;
+                    minimapPlayerOrientation = gameHandler->getMovementInfo().orientation;
                     hasMinimapPlayerOrientation = true;
                 }
                 minimap->render(cmd, *camera, minimapCenter,
@@ -2272,7 +4895,7 @@ void Renderer::renderWorld(game::World* world, game::GameHandler* gameHandler) {
         if (wmoRenderer && camera && !skipWMO) {
             wmoRenderer->prepareRender();
             auto wmoStart = std::chrono::steady_clock::now();
-            wmoRenderer->render(currentCmd, perFrameSet, *camera, &characterPosition);
+            wmoRenderer->render(currentCmd, perFrameSet, *camera);
             lastWMORenderMs = std::chrono::duration<double, std::milli>(
                 std::chrono::steady_clock::now() - wmoStart).count();
         }
@@ -2294,7 +4917,6 @@ void Renderer::renderWorld(game::World* world, game::GameHandler* gameHandler) {
             m2Renderer->render(currentCmd, perFrameSet, *camera);
             m2Renderer->renderSmokeParticles(currentCmd, perFrameSet);
             m2Renderer->renderM2Particles(currentCmd, perFrameSet);
-            m2Renderer->renderM2Ribbons(currentCmd, perFrameSet);
             lastM2RenderMs = std::chrono::duration<double, std::milli>(
                 std::chrono::steady_clock::now() - m2Start).count();
         }
@@ -2302,7 +4924,6 @@ void Renderer::renderWorld(game::World* world, game::GameHandler* gameHandler) {
         if (waterRenderer && camera)
             waterRenderer->render(currentCmd, perFrameSet, *camera, globalTime, false, frameIdx);
         if (weather && camera) weather->render(currentCmd, perFrameSet);
-        if (lightning && camera && lightning->isEnabled()) lightning->render(currentCmd, perFrameSet);
         if (swimEffects && camera) swimEffects->render(currentCmd, perFrameSet);
         if (mountDust && camera) mountDust->render(currentCmd, perFrameSet);
         if (chargeEffect && camera) chargeEffect->render(currentCmd, perFrameSet);
@@ -2330,20 +4951,6 @@ void Renderer::renderWorld(game::World* world, game::GameHandler* gameHandler) {
                 renderOverlay(tint);
             }
         }
-        // Ghost mode desaturation: cold blue-grey overlay when dead/ghost
-        if (ghostMode_) {
-            renderOverlay(glm::vec4(0.30f, 0.35f, 0.42f, 0.45f));
-        }
-        // Brightness overlay (applied before minimap so it doesn't affect UI)
-        {
-            float br = postProcessPipeline_ ? postProcessPipeline_->getBrightness() : 1.0f;
-            if (br < 0.99f) {
-                renderOverlay(glm::vec4(0.0f, 0.0f, 0.0f, 1.0f - br));
-            } else if (br > 1.01f) {
-                float alpha = (br - 1.0f) / 1.0f;
-                renderOverlay(glm::vec4(1.0f, 1.0f, 1.0f, alpha));
-            }
-        }
         if (minimap && minimap->isEnabled() && camera && window) {
             glm::vec3 minimapCenter = camera->getPosition();
             if (cameraController && cameraController->isThirdPerson())
@@ -2353,14 +4960,10 @@ void Renderer::renderWorld(game::World* world, game::GameHandler* gameHandler) {
             if (cameraController) {
                 float facingRad = glm::radians(characterYaw);
                 glm::vec3 facingFwd(std::cos(facingRad), std::sin(facingRad), 0.0f);
-                // atan2(-x,y) = canonical yaw (0=North); negate for shader convention.
-                minimapPlayerOrientation = -std::atan2(-facingFwd.x, facingFwd.y);
+                minimapPlayerOrientation = std::atan2(-facingFwd.x, facingFwd.y);
                 hasMinimapPlayerOrientation = true;
             } else if (gameHandler) {
-                // movementInfo.orientation is canonical yaw: 0=North, π/2=East.
-                // Minimap shader: arrowRotation=0 points up (North), positive rotates CW
-                // (π/2=West, -π/2=East). Correct mapping: arrowRotation = -canonical_yaw.
-                minimapPlayerOrientation = -gameHandler->getMovementInfo().orientation;
+                minimapPlayerOrientation = gameHandler->getMovementInfo().orientation;
                 hasMinimapPlayerOrientation = true;
             }
             minimap->render(currentCmd, *camera, minimapCenter,
@@ -2433,11 +5036,6 @@ bool Renderer::initializeRenderers(pipeline::AssetManager* assetManager, const s
         if (swimEffects) {
             swimEffects->setM2Renderer(m2Renderer.get());
         }
-        // Initialize SpellVisualSystem once M2Renderer is available (§4.4)
-        if (!spellVisualSystem_) {
-            spellVisualSystem_ = std::make_unique<SpellVisualSystem>();
-            spellVisualSystem_->initialize(m2Renderer.get());
-        }
     }
     if (!wmoRenderer) {
         wmoRenderer = std::make_unique<WMORenderer>();
@@ -2459,12 +5057,6 @@ bool Renderer::initializeRenderers(pipeline::AssetManager* assetManager, const s
         }
     }
 
-    // Initialize AnimationController (§4.2)
-    if (!animationController_) {
-        animationController_ = std::make_unique<AnimationController>();
-        animationController_->initialize(this);
-    }
-
     // Create and initialize terrain manager
     if (!terrainManager) {
         terrainManager = std::make_unique<TerrainManager>();
@@ -2486,8 +5078,8 @@ bool Renderer::initializeRenderers(pipeline::AssetManager* assetManager, const s
             terrainManager->setWMORenderer(wmoRenderer.get());
         }
         // Set ambient sound manager for environmental audio emitters
-        if (audioCoordinator_->getAmbientSoundManager()) {
-            terrainManager->setAmbientSoundManager(audioCoordinator_->getAmbientSoundManager());
+        if (ambientSoundManager) {
+            terrainManager->setAmbientSoundManager(ambientSoundManager.get());
         }
         // Pass asset manager to character renderer for texture loading
         if (characterRenderer) {
@@ -2518,36 +5110,36 @@ bool Renderer::initializeRenderers(pipeline::AssetManager* assetManager, const s
     if (worldMap) worldMap->setMapName(mapName);
 
     // Initialize audio managers
-    if (audioCoordinator_->getMusicManager() && assetManager && !cachedAssetManager) {
+    if (musicManager && assetManager && !cachedAssetManager) {
         audio::AudioEngine::instance().setAssetManager(assetManager);
-        audioCoordinator_->getMusicManager()->initialize(assetManager);
-        if (audioCoordinator_->getFootstepManager()) {
-            audioCoordinator_->getFootstepManager()->initialize(assetManager);
+        musicManager->initialize(assetManager);
+        if (footstepManager) {
+            footstepManager->initialize(assetManager);
         }
-        if (audioCoordinator_->getActivitySoundManager()) {
-            audioCoordinator_->getActivitySoundManager()->initialize(assetManager);
+        if (activitySoundManager) {
+            activitySoundManager->initialize(assetManager);
         }
-        if (audioCoordinator_->getMountSoundManager()) {
-            audioCoordinator_->getMountSoundManager()->initialize(assetManager);
+        if (mountSoundManager) {
+            mountSoundManager->initialize(assetManager);
         }
-        if (audioCoordinator_->getNpcVoiceManager()) {
-            audioCoordinator_->getNpcVoiceManager()->initialize(assetManager);
+        if (npcVoiceManager) {
+            npcVoiceManager->initialize(assetManager);
         }
         if (!deferredWorldInitEnabled_) {
-            if (audioCoordinator_->getAmbientSoundManager()) {
-                audioCoordinator_->getAmbientSoundManager()->initialize(assetManager);
+            if (ambientSoundManager) {
+                ambientSoundManager->initialize(assetManager);
             }
-            if (audioCoordinator_->getUiSoundManager()) {
-                audioCoordinator_->getUiSoundManager()->initialize(assetManager);
+            if (uiSoundManager) {
+                uiSoundManager->initialize(assetManager);
             }
-            if (audioCoordinator_->getCombatSoundManager()) {
-                audioCoordinator_->getCombatSoundManager()->initialize(assetManager);
+            if (combatSoundManager) {
+                combatSoundManager->initialize(assetManager);
             }
-            if (audioCoordinator_->getSpellSoundManager()) {
-                audioCoordinator_->getSpellSoundManager()->initialize(assetManager);
+            if (spellSoundManager) {
+                spellSoundManager->initialize(assetManager);
             }
-            if (audioCoordinator_->getMovementSoundManager()) {
-                audioCoordinator_->getMovementSoundManager()->initialize(assetManager);
+            if (movementSoundManager) {
+                movementSoundManager->initialize(assetManager);
             }
             if (questMarkerRenderer) {
                 questMarkerRenderer->initialize(vkCtx, perFrameSetLayout, assetManager);
@@ -2556,7 +5148,7 @@ bool Renderer::initializeRenderers(pipeline::AssetManager* assetManager, const s
             if (envFlagEnabled("WOWEE_PREWARM_ZONE_MUSIC", false)) {
                 if (zoneManager) {
                     for (const auto& musicPath : zoneManager->getAllMusicPaths()) {
-                        audioCoordinator_->getMusicManager()->preloadMusic(musicPath);
+                        musicManager->preloadMusic(musicPath);
                     }
                 }
                 static const std::vector<std::string> tavernTracks = {
@@ -2566,7 +5158,7 @@ bool Renderer::initializeRenderers(pipeline::AssetManager* assetManager, const s
                     "Sound\\Music\\ZoneMusic\\TavernHuman\\RA_HumanTavern2A.mp3",
                 };
                 for (const auto& musicPath : tavernTracks) {
-                    audioCoordinator_->getMusicManager()->preloadMusic(musicPath);
+                    musicManager->preloadMusic(musicPath);
                 }
             }
         } else {
@@ -2628,12 +5220,8 @@ bool Renderer::loadTestTerrain(pipeline::AssetManager* assetManager, const std::
                 if (secondUnderscore != std::string::npos) {
                     size_t dot = filename.find('.', secondUnderscore);
                     if (dot != std::string::npos) {
-                        try {
-                            tileX = std::stoi(filename.substr(firstUnderscore + 1, secondUnderscore - firstUnderscore - 1));
-                            tileY = std::stoi(filename.substr(secondUnderscore + 1, dot - secondUnderscore - 1));
-                        } catch (...) {
-                            LOG_WARNING("Failed to parse tile coords from: ", filename);
-                        }
+                        tileX = std::stoi(filename.substr(firstUnderscore + 1, secondUnderscore - firstUnderscore - 1));
+                        tileY = std::stoi(filename.substr(secondUnderscore + 1, dot - secondUnderscore - 1));
                     }
                 }
             }
@@ -2705,42 +5293,42 @@ bool Renderer::loadTerrainArea(const std::string& mapName, int centerX, int cent
     }
 
     // Initialize music manager with asset manager
-    if (audioCoordinator_->getMusicManager() && cachedAssetManager) {
-        if (!audioCoordinator_->getMusicManager()->isInitialized()) {
-            audioCoordinator_->getMusicManager()->initialize(cachedAssetManager);
+    if (musicManager && cachedAssetManager) {
+        if (!musicManager->isInitialized()) {
+            musicManager->initialize(cachedAssetManager);
         }
     }
-    if (audioCoordinator_->getFootstepManager() && cachedAssetManager) {
-        if (!audioCoordinator_->getFootstepManager()->isInitialized()) {
-            audioCoordinator_->getFootstepManager()->initialize(cachedAssetManager);
+    if (footstepManager && cachedAssetManager) {
+        if (!footstepManager->isInitialized()) {
+            footstepManager->initialize(cachedAssetManager);
         }
     }
-    if (audioCoordinator_->getActivitySoundManager() && cachedAssetManager) {
-        if (!audioCoordinator_->getActivitySoundManager()->isInitialized()) {
-            audioCoordinator_->getActivitySoundManager()->initialize(cachedAssetManager);
+    if (activitySoundManager && cachedAssetManager) {
+        if (!activitySoundManager->isInitialized()) {
+            activitySoundManager->initialize(cachedAssetManager);
         }
     }
-    if (audioCoordinator_->getMountSoundManager() && cachedAssetManager) {
-        audioCoordinator_->getMountSoundManager()->initialize(cachedAssetManager);
+    if (mountSoundManager && cachedAssetManager) {
+        mountSoundManager->initialize(cachedAssetManager);
     }
-    if (audioCoordinator_->getNpcVoiceManager() && cachedAssetManager) {
-        audioCoordinator_->getNpcVoiceManager()->initialize(cachedAssetManager);
+    if (npcVoiceManager && cachedAssetManager) {
+        npcVoiceManager->initialize(cachedAssetManager);
     }
     if (!deferredWorldInitEnabled_) {
-        if (audioCoordinator_->getAmbientSoundManager() && cachedAssetManager) {
-            audioCoordinator_->getAmbientSoundManager()->initialize(cachedAssetManager);
+        if (ambientSoundManager && cachedAssetManager) {
+            ambientSoundManager->initialize(cachedAssetManager);
         }
-        if (audioCoordinator_->getUiSoundManager() && cachedAssetManager) {
-            audioCoordinator_->getUiSoundManager()->initialize(cachedAssetManager);
+        if (uiSoundManager && cachedAssetManager) {
+            uiSoundManager->initialize(cachedAssetManager);
         }
-        if (audioCoordinator_->getCombatSoundManager() && cachedAssetManager) {
-            audioCoordinator_->getCombatSoundManager()->initialize(cachedAssetManager);
+        if (combatSoundManager && cachedAssetManager) {
+            combatSoundManager->initialize(cachedAssetManager);
         }
-        if (audioCoordinator_->getSpellSoundManager() && cachedAssetManager) {
-            audioCoordinator_->getSpellSoundManager()->initialize(cachedAssetManager);
+        if (spellSoundManager && cachedAssetManager) {
+            spellSoundManager->initialize(cachedAssetManager);
         }
-        if (audioCoordinator_->getMovementSoundManager() && cachedAssetManager) {
-            audioCoordinator_->getMovementSoundManager()->initialize(cachedAssetManager);
+        if (movementSoundManager && cachedAssetManager) {
+            movementSoundManager->initialize(cachedAssetManager);
         }
         if (questMarkerRenderer && cachedAssetManager) {
             questMarkerRenderer->initialize(vkCtx, perFrameSetLayout, cachedAssetManager);
@@ -2752,8 +5340,8 @@ bool Renderer::loadTerrainArea(const std::string& mapName, int centerX, int cent
     }
 
     // Wire ambient sound manager to terrain manager for emitter registration
-    if (terrainManager && audioCoordinator_->getAmbientSoundManager()) {
-        terrainManager->setAmbientSoundManager(audioCoordinator_->getAmbientSoundManager());
+    if (terrainManager && ambientSoundManager) {
+        terrainManager->setAmbientSoundManager(ambientSoundManager.get());
     }
 
     // Wire WMO, M2, and water renderer to camera controller
@@ -2784,6 +5372,10 @@ void Renderer::setTerrainStreaming(bool enabled) {
     }
 }
 
+const char* Renderer::getAmdFsr3FramegenRuntimePath() const {
+    return fsr2_.amdFsr3RuntimePath.c_str();
+}
+
 void Renderer::renderHUD() {
     if (currentCmd == VK_NULL_HANDLE) return;
     if (performanceHUD && camera) {
@@ -2810,9 +5402,8 @@ glm::mat4 Renderer::computeLightSpaceMatrix() {
     glm::vec3 sunDir = glm::normalize(glm::vec3(-0.3f, -0.7f, -0.6f));
     if (lightingManager) {
         const auto& lighting = lightingManager->getLightingParams();
-        float ldirLenSq = glm::dot(lighting.directionalDir, lighting.directionalDir);
-        if (ldirLenSq > 1e-6f) {
-            sunDir = -lighting.directionalDir * glm::inversesqrt(ldirLenSq);
+        if (glm::length(lighting.directionalDir) > 0.001f) {
+            sunDir = glm::normalize(-lighting.directionalDir);
         }
     }
     // Shadow camera expects light rays pointing downward in render space (Z up).
@@ -2821,8 +5412,8 @@ glm::mat4 Renderer::computeLightSpaceMatrix() {
         sunDir = -sunDir;
     }
     // Keep a minimum downward component so the frustum doesn't collapse at grazing angles.
-    if (sunDir.z > -0.15f) {
-        sunDir.z = -0.15f;
+    if (sunDir.z > -0.08f) {
+        sunDir.z = -0.08f;
         sunDir = glm::normalize(sunDir);
     }
 
@@ -3010,24 +5601,18 @@ void Renderer::renderReflectionPass() {
     if (!waterRenderer || !camera || !waterRenderer->hasReflectionPass() || !waterRenderer->hasSurfaces()) return;
     if (currentCmd == VK_NULL_HANDLE || !reflPerFrameUBOMapped) return;
 
-    // Select the current frame's pre-bound reflection descriptor set
-    // (each frame's set was bound to its own shadow depth view at init).
-    uint32_t frame = vkCtx->getCurrentFrame();
-    VkDescriptorSet reflDescSet = reflPerFrameDescSet[frame];
-
     // Reflection pass uses 1x MSAA. Scene pipelines must be render-pass-compatible,
     // which requires matching sample counts. Only render scene into reflection when MSAA is off.
     bool canRenderScene = (vkCtx->getMsaaSamples() == VK_SAMPLE_COUNT_1_BIT);
 
     // Find dominant water height near camera
-    const glm::vec3 camPos = camera->getPosition();
-    auto waterH = waterRenderer->getDominantWaterHeight(camPos);
+    auto waterH = waterRenderer->getDominantWaterHeight(camera->getPosition());
     if (!waterH) return;
 
     float waterHeight = *waterH;
 
     // Skip reflection if camera is underwater (Z is up)
-    if (camPos.z < waterHeight + 0.5f) return;
+    if (camera->getPosition().z < waterHeight + 0.5f) return;
 
     // Compute reflected view and oblique projection
     glm::mat4 reflView = WaterRenderer::computeReflectedView(*camera, waterHeight);
@@ -3042,7 +5627,7 @@ void Renderer::renderReflectionPass() {
     reflData.view = reflView;
     reflData.projection = reflProj;
     // Reflected camera position (Z is up)
-    glm::vec3 reflPos = camPos;
+    glm::vec3 reflPos = camera->getPosition();
     reflPos.z = 2.0f * waterHeight - reflPos.z;
     reflData.viewPos = glm::vec4(reflPos, 1.0f);
     std::memcpy(reflPerFrameUBOMapped, &reflData, sizeof(GPUPerFrameData));
@@ -3054,8 +5639,7 @@ void Renderer::renderReflectionPass() {
         // Render scene into reflection texture (sky + terrain + WMO only for perf)
         if (skySystem) {
             rendering::SkyParams skyParams;
-            auto* reflSkybox = skySystem->getSkybox();
-            skyParams.timeOfDay = reflSkybox ? reflSkybox->getTimeOfDay() : 12.0f;
+            skyParams.timeOfDay = (skySystem->getSkybox()) ? skySystem->getSkybox()->getTimeOfDay() : 12.0f;
             if (lightingManager) {
                 const auto& lp = lightingManager->getLightingParams();
                 skyParams.directionalDir = lp.directionalDir;
@@ -3069,13 +5653,13 @@ void Renderer::renderReflectionPass() {
                 skyParams.horizonGlow = lp.horizonGlow;
             }
             // weatherIntensity left at default 0 for reflection pass (no game handler in scope)
-            skySystem->render(currentCmd, reflDescSet, *camera, skyParams);
+            skySystem->render(currentCmd, reflPerFrameDescSet, *camera, skyParams);
         }
         if (terrainRenderer && terrainEnabled) {
-            terrainRenderer->render(currentCmd, reflDescSet, *camera);
+            terrainRenderer->render(currentCmd, reflPerFrameDescSet, *camera);
         }
         if (wmoRenderer) {
-            wmoRenderer->render(currentCmd, reflDescSet, *camera);
+            wmoRenderer->render(currentCmd, reflPerFrameDescSet, *camera);
         }
     }
 
@@ -3083,34 +5667,40 @@ void Renderer::renderReflectionPass() {
 }
 
 void Renderer::renderShadowPass() {
-    ZoneScopedN("Renderer::renderShadowPass");
     static const bool skipShadows = (std::getenv("WOWEE_SKIP_SHADOWS") != nullptr);
     if (skipShadows) return;
-    if (!shadowsEnabled || shadowDepthImage[0] == VK_NULL_HANDLE) return;
+    if (!shadowsEnabled || shadowDepthImage == VK_NULL_HANDLE) return;
     if (currentCmd == VK_NULL_HANDLE) return;
 
     // Shadows render every frame — throttling causes visible flicker on player/NPCs
 
-    // lightSpaceMatrix was already computed at frame start (before updatePerFrameUBO).
+    // Compute and store light space matrix; write to per-frame UBO
+    lightSpaceMatrix = computeLightSpaceMatrix();
     // Zero matrix means character position isn't set yet — skip shadow pass entirely.
     if (lightSpaceMatrix == glm::mat4(0.0f)) return;
     uint32_t frame = vkCtx->getCurrentFrame();
+    auto* ubo = reinterpret_cast<GPUPerFrameData*>(perFrameUBOMapped[frame]);
+    if (ubo) {
+        ubo->lightSpaceMatrix = lightSpaceMatrix;
+        ubo->shadowParams.x = shadowsEnabled ? 1.0f : 0.0f;
+        ubo->shadowParams.y = 0.8f;
+    }
 
-    // Barrier 1: transition this frame's shadow map into writable depth layout.
+    // Barrier 1: transition shadow map into writable depth layout.
     VkImageMemoryBarrier b1{};
     b1.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-    b1.oldLayout = shadowDepthLayout_[frame];
+    b1.oldLayout = shadowDepthLayout_;
     b1.newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
     b1.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
     b1.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-    b1.srcAccessMask = (shadowDepthLayout_[frame] == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
+    b1.srcAccessMask = (shadowDepthLayout_ == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
         ? VK_ACCESS_SHADER_READ_BIT
         : 0;
     b1.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
                        VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
-    b1.image = shadowDepthImage[frame];
+    b1.image = shadowDepthImage;
     b1.subresourceRange = {VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1};
-    VkPipelineStageFlags srcStage = (shadowDepthLayout_[frame] == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
+    VkPipelineStageFlags srcStage = (shadowDepthLayout_ == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
         ? VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
         : VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
     vkCmdPipelineBarrier(currentCmd,
@@ -3121,7 +5711,7 @@ void Renderer::renderShadowPass() {
     VkRenderPassBeginInfo rpInfo{};
     rpInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
     rpInfo.renderPass = shadowRenderPass;
-    rpInfo.framebuffer = shadowFramebuffer[frame];
+    rpInfo.framebuffer = shadowFramebuffer;
     rpInfo.renderArea = {{0, 0}, {SHADOW_MAP_SIZE, SHADOW_MAP_SIZE}};
     VkClearValue clear{};
     clear.depthStencil = {1.0f, 0};
@@ -3160,76 +5750,12 @@ void Renderer::renderShadowPass() {
     b2.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
     b2.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
     b2.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-    b2.image = shadowDepthImage[frame];
+    b2.image = shadowDepthImage;
     b2.subresourceRange = {VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1};
     vkCmdPipelineBarrier(currentCmd,
         VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
         0, 0, nullptr, 0, nullptr, 1, &b2);
-    shadowDepthLayout_[frame] = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-}
-
-// Build the per-frame render graph for off-screen pre-passes.
-// Declares passes as graph nodes with input/output dependencies.
-// compile() performs topological sort; execute() runs them with auto barriers.
-void Renderer::buildFrameGraph(game::GameHandler* gameHandler) {
-    (void)gameHandler;
-    if (!renderGraph_) return;
-
-    renderGraph_->reset();
-
-    auto shadowDepth = renderGraph_->findResource("shadow_depth");
-    auto reflTex = renderGraph_->findResource("reflection_texture");
-    auto cullVis = renderGraph_->findResource("cull_visibility");
-
-    // Minimap composites (no dependencies — standalone off-screen render target)
-    renderGraph_->addPass("minimap_composite", {}, {},
-        [this](VkCommandBuffer cmd) {
-            if (minimap && minimap->isEnabled() && camera) {
-                glm::vec3 minimapCenter = camera->getPosition();
-                if (cameraController && cameraController->isThirdPerson())
-                    minimapCenter = characterPosition;
-                minimap->compositePass(cmd, minimapCenter);
-            }
-        });
-
-    // World map composite (standalone)
-    renderGraph_->addPass("worldmap_composite", {}, {},
-        [this](VkCommandBuffer cmd) {
-            if (worldMap) worldMap->compositePass(cmd);
-        });
-
-    // Character preview composites (standalone)
-    renderGraph_->addPass("preview_composite", {}, {},
-        [this](VkCommandBuffer cmd) {
-            uint32_t frame = vkCtx->getCurrentFrame();
-            for (auto* preview : activePreviews_) {
-                if (preview && preview->isModelLoaded())
-                    preview->compositePass(cmd, frame);
-            }
-        });
-
-    // Shadow pre-pass → outputs shadow_depth
-    renderGraph_->addPass("shadow_pass", {}, {shadowDepth},
-        [this](VkCommandBuffer) {
-            if (shadowsEnabled && shadowDepthImage[0] != VK_NULL_HANDLE)
-                renderShadowPass();
-        });
-    renderGraph_->setPassEnabled("shadow_pass", shadowsEnabled && shadowDepthImage[0] != VK_NULL_HANDLE);
-
-    // Reflection pre-pass → outputs reflection_texture (reads scene, so after shadow)
-    renderGraph_->addPass("reflection_pass", {shadowDepth}, {reflTex},
-        [this](VkCommandBuffer) {
-            renderReflectionPass();
-        });
-
-    // GPU frustum cull compute → outputs cull_visibility
-    renderGraph_->addPass("compute_cull", {}, {cullVis},
-        [this](VkCommandBuffer cmd) {
-            if (m2Renderer && camera)
-                m2Renderer->dispatchCullCompute(cmd, vkCtx->getCurrentFrame(), *camera);
-        });
-
-    renderGraph_->compile();
+    shadowDepthLayout_ = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 }
 
 } // namespace rendering
diff --git a/src/rendering/scene.cpp b/src/rendering/scene.cpp
new file mode 100644
index 00000000..c10ad56d
--- /dev/null
+++ b/src/rendering/scene.cpp
@@ -0,0 +1,24 @@
+#include "rendering/scene.hpp"
+#include "rendering/mesh.hpp"
+#include <algorithm>
+
+namespace wowee {
+namespace rendering {
+
+void Scene::addMesh(std::shared_ptr<Mesh> mesh) {
+    meshes.push_back(std::move(mesh));
+}
+
+void Scene::removeMesh(const std::shared_ptr<Mesh>& mesh) {
+    auto it = std::find(meshes.begin(), meshes.end(), mesh);
+    if (it != meshes.end()) {
+        meshes.erase(it);
+    }
+}
+
+void Scene::clear() {
+    meshes.clear();
+}
+
+} // namespace rendering
+} // namespace wowee
diff --git a/src/rendering/shader.cpp b/src/rendering/shader.cpp
new file mode 100644
index 00000000..2a748539
--- /dev/null
+++ b/src/rendering/shader.cpp
@@ -0,0 +1,140 @@
+#include "rendering/shader.hpp"
+#include "core/logger.hpp"
+#include <fstream>
+#include <sstream>
+
+namespace wowee {
+namespace rendering {
+
+Shader::~Shader() {
+    if (program) glDeleteProgram(program);
+    if (vertexShader) glDeleteShader(vertexShader);
+    if (fragmentShader) glDeleteShader(fragmentShader);
+}
+
+bool Shader::loadFromFile(const std::string& vertexPath, const std::string& fragmentPath) {
+    // Load vertex shader
+    std::ifstream vFile(vertexPath);
+    if (!vFile.is_open()) {
+        LOG_ERROR("Failed to open vertex shader: ", vertexPath);
+        return false;
+    }
+    std::stringstream vStream;
+    vStream << vFile.rdbuf();
+    std::string vertexSource = vStream.str();
+
+    // Load fragment shader
+    std::ifstream fFile(fragmentPath);
+    if (!fFile.is_open()) {
+        LOG_ERROR("Failed to open fragment shader: ", fragmentPath);
+        return false;
+    }
+    std::stringstream fStream;
+    fStream << fFile.rdbuf();
+    std::string fragmentSource = fStream.str();
+
+    return compile(vertexSource, fragmentSource);
+}
+
+bool Shader::loadFromSource(const std::string& vertexSource, const std::string& fragmentSource) {
+    return compile(vertexSource, fragmentSource);
+}
+
+bool Shader::compile(const std::string& vertexSource, const std::string& fragmentSource) {
+    GLint success;
+    GLchar infoLog[512];
+
+    // Compile vertex shader
+    const char* vCode = vertexSource.c_str();
+    vertexShader = glCreateShader(GL_VERTEX_SHADER);
+    glShaderSource(vertexShader, 1, &vCode, nullptr);
+    glCompileShader(vertexShader);
+    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
+    if (!success) {
+        glGetShaderInfoLog(vertexShader, 512, nullptr, infoLog);
+        LOG_ERROR("Vertex shader compilation failed: ", infoLog);
+        return false;
+    }
+
+    // Compile fragment shader
+    const char* fCode = fragmentSource.c_str();
+    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(fragmentShader, 1, &fCode, nullptr);
+    glCompileShader(fragmentShader);
+    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
+    if (!success) {
+        glGetShaderInfoLog(fragmentShader, 512, nullptr, infoLog);
+        LOG_ERROR("Fragment shader compilation failed: ", infoLog);
+        return false;
+    }
+
+    // Link program
+    program = glCreateProgram();
+    glAttachShader(program, vertexShader);
+    glAttachShader(program, fragmentShader);
+    glLinkProgram(program);
+    glGetProgramiv(program, GL_LINK_STATUS, &success);
+    if (!success) {
+        glGetProgramInfoLog(program, 512, nullptr, infoLog);
+        LOG_ERROR("Shader program linking failed: ", infoLog);
+        return false;
+    }
+
+    return true;
+}
+
+void Shader::use() const {
+    glUseProgram(program);
+}
+
+void Shader::unuse() const {
+    glUseProgram(0);
+}
+
+GLint Shader::getUniformLocation(const std::string& name) const {
+    // Check cache first
+    auto it = uniformLocationCache.find(name);
+    if (it != uniformLocationCache.end()) {
+        return it->second;
+    }
+
+    // Look up and cache
+    GLint location = glGetUniformLocation(program, name.c_str());
+    uniformLocationCache[name] = location;
+    return location;
+}
+
+void Shader::setUniform(const std::string& name, int value) {
+    glUniform1i(getUniformLocation(name), value);
+}
+
+void Shader::setUniform(const std::string& name, float value) {
+    glUniform1f(getUniformLocation(name), value);
+}
+
+void Shader::setUniform(const std::string& name, const glm::vec2& value) {
+    glUniform2fv(getUniformLocation(name), 1, &value[0]);
+}
+
+void Shader::setUniform(const std::string& name, const glm::vec3& value) {
+    glUniform3fv(getUniformLocation(name), 1, &value[0]);
+}
+
+void Shader::setUniform(const std::string& name, const glm::vec4& value) {
+    glUniform4fv(getUniformLocation(name), 1, &value[0]);
+}
+
+void Shader::setUniform(const std::string& name, const glm::mat3& value) {
+    glUniformMatrix3fv(getUniformLocation(name), 1, GL_FALSE, &value[0][0]);
+}
+
+void Shader::setUniform(const std::string& name, const glm::mat4& value) {
+    glUniformMatrix4fv(getUniformLocation(name), 1, GL_FALSE, &value[0][0]);
+}
+
+void Shader::setUniformMatrixArray(const std::string& name, const glm::mat4* matrices, int count) {
+    glUniformMatrix4fv(getUniformLocation(name), count, GL_FALSE, &matrices[0][0][0]);
+}
+
+} // namespace rendering
+} // namespace wowee
diff --git a/src/rendering/sky_system.cpp b/src/rendering/sky_system.cpp
index af2e87e5..9509cdc2 100644
--- a/src/rendering/sky_system.cpp
+++ b/src/rendering/sky_system.cpp
@@ -135,14 +135,6 @@ void SkySystem::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet,
 
     // --- Clouds (DBC-driven colors + sun lighting) ---
     if (clouds_) {
-        // Sync cloud density with weather/DBC-driven cloud coverage.
-        // Active weather (rain/snow/storm) increases cloud density for visual consistency.
-        float effectiveDensity = params.cloudDensity;
-        if (params.weatherIntensity > 0.05f) {
-            float weatherBoost = params.weatherIntensity * 0.4f;  // storms add up to 0.4 density
-            effectiveDensity = glm::min(1.0f, effectiveDensity + weatherBoost);
-        }
-        clouds_->setDensity(effectiveDensity);
         clouds_->render(cmd, perFrameSet, params);
     }
 
@@ -156,9 +148,8 @@ void SkySystem::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet,
 }
 
 glm::vec3 SkySystem::getSunPosition(const SkyParams& params) const {
-    float dirLenSq = glm::dot(params.directionalDir, params.directionalDir);
-    glm::vec3 dir = (dirLenSq > 1e-8f) ? params.directionalDir * glm::inversesqrt(dirLenSq) : glm::vec3(0.0f);
-    if (dirLenSq < 1e-8f) {
+    glm::vec3 dir = glm::normalize(params.directionalDir);
+    if (glm::length(dir) < 0.0001f) {
         dir = glm::vec3(0.0f, 0.0f, -1.0f);
     }
     glm::vec3 sunDir = -dir;
diff --git a/src/rendering/skybox.cpp b/src/rendering/skybox.cpp
index d8cfba06..3e0e7de6 100644
--- a/src/rendering/skybox.cpp
+++ b/src/rendering/skybox.cpp
@@ -81,7 +81,7 @@ bool Skybox::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout) {
         .setLayout(pipelineLayout)
         .setRenderPass(vkCtx->getImGuiRenderPass())
         .setDynamicStates(dynamicStates)
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     // Shader modules can be freed after pipeline creation
     vertModule.destroy();
@@ -133,7 +133,7 @@ void Skybox::recreatePipelines() {
         .setLayout(pipelineLayout)
         .setRenderPass(vkCtx->getImGuiRenderPass())
         .setDynamicStates(dynamicStates)
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     vertModule.destroy();
     fragModule.destroy();
@@ -202,9 +202,10 @@ void Skybox::update(float deltaTime) {
 }
 
 void Skybox::setTimeOfDay(float time) {
-    // Wrap to [0, 24) range using fmod instead of iterative subtraction
-    time = std::fmod(time, 24.0f);
-    if (time < 0.0f) time += 24.0f;
+    // Clamp to 0-24 range
+    while (time < 0.0f) time += 24.0f;
+    while (time >= 24.0f) time -= 24.0f;
+
     timeOfDay = time;
 }
 
diff --git a/src/rendering/spell_visual_system.cpp b/src/rendering/spell_visual_system.cpp
deleted file mode 100644
index a60a3870..00000000
--- a/src/rendering/spell_visual_system.cpp
+++ /dev/null
@@ -1,231 +0,0 @@
-#include "rendering/spell_visual_system.hpp"
-#include "rendering/m2_renderer.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "pipeline/dbc_loader.hpp"
-#include "pipeline/dbc_layout.hpp"
-#include "pipeline/m2_loader.hpp"
-#include "core/application.hpp"
-#include "core/logger.hpp"
-#include <algorithm>
-
-namespace wowee {
-namespace rendering {
-
-void SpellVisualSystem::initialize(M2Renderer* m2Renderer) {
-    m2Renderer_ = m2Renderer;
-}
-
-void SpellVisualSystem::shutdown() {
-    reset();
-    m2Renderer_ = nullptr;
-    cachedAssetManager_ = nullptr;
-}
-
-// Load SpellVisual DBC chain: SpellVisualEffectName → SpellVisualKit → SpellVisual
-// to build cast/impact M2 path lookup maps.
-void SpellVisualSystem::loadSpellVisualDbc() {
-    if (spellVisualDbcLoaded_) return;
-    spellVisualDbcLoaded_ = true; // Set early to prevent re-entry on failure
-
-    if (!cachedAssetManager_) {
-        cachedAssetManager_ = core::Application::getInstance().getAssetManager();
-    }
-    if (!cachedAssetManager_) return;
-
-    auto* layout = pipeline::getActiveDBCLayout();
-    const pipeline::DBCFieldMap* svLayout  = layout ? layout->getLayout("SpellVisual")           : nullptr;
-    const pipeline::DBCFieldMap* kitLayout = layout ? layout->getLayout("SpellVisualKit")        : nullptr;
-    const pipeline::DBCFieldMap* fxLayout  = layout ? layout->getLayout("SpellVisualEffectName") : nullptr;
-
-    uint32_t svCastKitField   = svLayout  ? (*svLayout)["CastKit"]       : 2;
-    uint32_t svImpactKitField = svLayout  ? (*svLayout)["ImpactKit"]     : 3;
-    uint32_t svMissileField   = svLayout  ? (*svLayout)["MissileModel"]  : 8;
-    uint32_t kitSpecial0Field = kitLayout ? (*kitLayout)["SpecialEffect0"] : 11;
-    uint32_t kitBaseField     = kitLayout ? (*kitLayout)["BaseEffect"]     : 5;
-    uint32_t fxFilePathField  = fxLayout  ? (*fxLayout)["FilePath"]       : 2;
-
-    // Helper to look up effectName path from a kit ID
-    // Load SpellVisualEffectName.dbc — ID → M2 path
-    auto fxDbc = cachedAssetManager_->loadDBC("SpellVisualEffectName.dbc");
-    if (!fxDbc || !fxDbc->isLoaded() || fxDbc->getFieldCount() <= fxFilePathField) {
-        LOG_DEBUG("SpellVisual: SpellVisualEffectName.dbc unavailable (fc=",
-                  fxDbc ? fxDbc->getFieldCount() : 0, ")");
-        return;
-    }
-    std::unordered_map<uint32_t, std::string> effectPaths; // effectNameId → path
-    for (uint32_t i = 0; i < fxDbc->getRecordCount(); ++i) {
-        uint32_t id   = fxDbc->getUInt32(i, 0);
-        std::string p = fxDbc->getString(i, fxFilePathField);
-        if (id && !p.empty()) effectPaths[id] = p;
-    }
-
-    // Load SpellVisualKit.dbc — kitId → best SpellVisualEffectName ID
-    auto kitDbc = cachedAssetManager_->loadDBC("SpellVisualKit.dbc");
-    std::unordered_map<uint32_t, uint32_t> kitToEffectName; // kitId → effectNameId
-    if (kitDbc && kitDbc->isLoaded()) {
-        uint32_t fc = kitDbc->getFieldCount();
-        for (uint32_t i = 0; i < kitDbc->getRecordCount(); ++i) {
-            uint32_t kitId = kitDbc->getUInt32(i, 0);
-            if (!kitId) continue;
-            // Prefer SpecialEffect0, fall back to BaseEffect
-            uint32_t eff = 0;
-            if (kitSpecial0Field < fc) eff = kitDbc->getUInt32(i, kitSpecial0Field);
-            if (!eff && kitBaseField < fc) eff = kitDbc->getUInt32(i, kitBaseField);
-            if (eff) kitToEffectName[kitId] = eff;
-        }
-    }
-
-    // Helper: resolve path for a given kit ID
-    auto kitPath = [&](uint32_t kitId) -> std::string {
-        if (!kitId) return {};
-        auto kitIt = kitToEffectName.find(kitId);
-        if (kitIt == kitToEffectName.end()) return {};
-        auto fxIt = effectPaths.find(kitIt->second);
-        return (fxIt != effectPaths.end()) ? fxIt->second : std::string{};
-    };
-    auto missilePath = [&](uint32_t effId) -> std::string {
-        if (!effId) return {};
-        auto fxIt = effectPaths.find(effId);
-        return (fxIt != effectPaths.end()) ? fxIt->second : std::string{};
-    };
-
-    // Load SpellVisual.dbc — visualId → cast/impact M2 paths via kit chain
-    auto svDbc = cachedAssetManager_->loadDBC("SpellVisual.dbc");
-    if (!svDbc || !svDbc->isLoaded()) {
-        LOG_DEBUG("SpellVisual: SpellVisual.dbc unavailable");
-        return;
-    }
-    uint32_t svFc = svDbc->getFieldCount();
-    uint32_t loadedCast = 0, loadedImpact = 0;
-    for (uint32_t i = 0; i < svDbc->getRecordCount(); ++i) {
-        uint32_t vid = svDbc->getUInt32(i, 0);
-        if (!vid) continue;
-
-        // Cast path: CastKit → SpecialEffect0/BaseEffect, fallback to MissileModel
-        {
-            std::string path;
-            if (svCastKitField < svFc)
-                path = kitPath(svDbc->getUInt32(i, svCastKitField));
-            if (path.empty() && svMissileField < svFc)
-                path = missilePath(svDbc->getUInt32(i, svMissileField));
-            if (!path.empty()) { spellVisualCastPath_[vid] = path; ++loadedCast; }
-        }
-        // Impact path: ImpactKit → SpecialEffect0/BaseEffect, fallback to MissileModel
-        {
-            std::string path;
-            if (svImpactKitField < svFc)
-                path = kitPath(svDbc->getUInt32(i, svImpactKitField));
-            if (path.empty() && svMissileField < svFc)
-                path = missilePath(svDbc->getUInt32(i, svMissileField));
-            if (!path.empty()) { spellVisualImpactPath_[vid] = path; ++loadedImpact; }
-        }
-    }
-    LOG_INFO("SpellVisual: loaded cast=", loadedCast, " impact=", loadedImpact,
-             " visual→M2 mappings (of ", svDbc->getRecordCount(), " records)");
-}
-
-void SpellVisualSystem::playSpellVisual(uint32_t visualId, const glm::vec3& worldPosition,
-                                         bool useImpactKit) {
-    if (!m2Renderer_ || visualId == 0) return;
-
-    if (!cachedAssetManager_)
-        cachedAssetManager_ = core::Application::getInstance().getAssetManager();
-    if (!cachedAssetManager_) return;
-
-    if (!spellVisualDbcLoaded_) loadSpellVisualDbc();
-
-    // Select cast or impact path map
-    auto& pathMap = useImpactKit ? spellVisualImpactPath_ : spellVisualCastPath_;
-    auto pathIt = pathMap.find(visualId);
-    if (pathIt == pathMap.end()) return; // No model for this visual
-
-    const std::string& modelPath = pathIt->second;
-
-    // Get or assign a model ID for this path
-    auto midIt = spellVisualModelIds_.find(modelPath);
-    uint32_t modelId = 0;
-    if (midIt != spellVisualModelIds_.end()) {
-        modelId = midIt->second;
-    } else {
-        if (nextSpellVisualModelId_ >= 999800) {
-            LOG_WARNING("SpellVisual: model ID pool exhausted");
-            return;
-        }
-        modelId = nextSpellVisualModelId_++;
-        spellVisualModelIds_[modelPath] = modelId;
-    }
-
-    // Skip models that have previously failed to load (avoid repeated I/O)
-    if (spellVisualFailedModels_.count(modelId)) return;
-
-    // Load the M2 model if not already loaded
-    if (!m2Renderer_->hasModel(modelId)) {
-        auto m2Data = cachedAssetManager_->readFile(modelPath);
-        if (m2Data.empty()) {
-            LOG_DEBUG("SpellVisual: could not read model: ", modelPath);
-            spellVisualFailedModels_.insert(modelId);
-            return;
-        }
-        pipeline::M2Model model = pipeline::M2Loader::load(m2Data);
-        if (model.vertices.empty() && model.particleEmitters.empty()) {
-            LOG_DEBUG("SpellVisual: empty model: ", modelPath);
-            spellVisualFailedModels_.insert(modelId);
-            return;
-        }
-        // Load skin file for WotLK-format M2s
-        if (model.version >= 264) {
-            std::string skinPath = modelPath.substr(0, modelPath.rfind('.')) + "00.skin";
-            auto skinData = cachedAssetManager_->readFile(skinPath);
-            if (!skinData.empty()) pipeline::M2Loader::loadSkin(skinData, model);
-        }
-        if (!m2Renderer_->loadModel(model, modelId)) {
-            LOG_WARNING("SpellVisual: failed to load model to GPU: ", modelPath);
-            spellVisualFailedModels_.insert(modelId);
-            return;
-        }
-        LOG_DEBUG("SpellVisual: loaded model id=", modelId, " path=", modelPath);
-    }
-
-    // Spawn instance at world position
-    uint32_t instanceId = m2Renderer_->createInstance(modelId, worldPosition,
-                                                       glm::vec3(0.0f), 1.0f);
-    if (instanceId == 0) {
-        LOG_WARNING("SpellVisual: failed to create instance for visualId=", visualId);
-        return;
-    }
-    // Determine lifetime from M2 animation duration (clamp to reasonable range)
-    float animDurMs = m2Renderer_->getInstanceAnimDuration(instanceId);
-    float duration = (animDurMs > 100.0f)
-        ? std::clamp(animDurMs / 1000.0f, 0.5f, SPELL_VISUAL_MAX_DURATION)
-        : SPELL_VISUAL_DEFAULT_DURATION;
-    activeSpellVisuals_.push_back({instanceId, 0.0f, duration});
-    LOG_DEBUG("SpellVisual: spawned visualId=", visualId, " instanceId=", instanceId,
-              " duration=", duration, "s model=", modelPath);
-}
-
-void SpellVisualSystem::update(float deltaTime) {
-    if (activeSpellVisuals_.empty() || !m2Renderer_) return;
-    for (auto it = activeSpellVisuals_.begin(); it != activeSpellVisuals_.end(); ) {
-        it->elapsed += deltaTime;
-        if (it->elapsed >= it->duration) {
-            m2Renderer_->removeInstance(it->instanceId);
-            it = activeSpellVisuals_.erase(it);
-        } else {
-            ++it;
-        }
-    }
-}
-
-void SpellVisualSystem::reset() {
-    // Clear lingering spell visual instances from the previous map/combat session.
-    // Without this, old effects could remain visible after teleport or map change.
-    for (auto& sv : activeSpellVisuals_) {
-        if (m2Renderer_) m2Renderer_->removeInstance(sv.instanceId);
-    }
-    activeSpellVisuals_.clear();
-    // Reset the negative cache so models that failed during asset loading can retry.
-    spellVisualFailedModels_.clear();
-}
-
-} // namespace rendering
-} // namespace wowee
diff --git a/src/rendering/starfield.cpp b/src/rendering/starfield.cpp
index 30847d0c..e472bc8d 100644
--- a/src/rendering/starfield.cpp
+++ b/src/rendering/starfield.cpp
@@ -13,14 +13,6 @@
 namespace wowee {
 namespace rendering {
 
-// Day/night cycle thresholds (hours, 24h clock) for star visibility.
-// Stars fade in over 2 hours at dusk, stay full during night, fade out at dawn.
-static constexpr float kDuskStart = 18.0f;  // stars begin fading in
-static constexpr float kNightStart = 20.0f; // full star visibility
-static constexpr float kDawnStart = 4.0f;   // stars begin fading out
-static constexpr float kDawnEnd = 6.0f;     // stars fully gone
-static constexpr float kFadeDuration = 2.0f;
-
 StarField::StarField() = default;
 
 StarField::~StarField() {
@@ -99,7 +91,7 @@ bool StarField::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout)
         .setMultisample(vkCtx->getMsaaSamples())
         .setLayout(pipelineLayout)
         .setRenderPass(vkCtx->getImGuiRenderPass())
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     vertModule.destroy();
     fragModule.destroy();
@@ -172,7 +164,7 @@ void StarField::recreatePipelines() {
         .setMultisample(vkCtx->getMsaaSamples())
         .setLayout(pipelineLayout)
         .setRenderPass(vkCtx->getImGuiRenderPass())
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     vertModule.destroy();
     fragModule.destroy();
@@ -311,20 +303,22 @@ void StarField::destroyStarBuffers() {
 }
 
 float StarField::getStarIntensity(float timeOfDay) const {
-    // Full night
-    if (timeOfDay >= kNightStart || timeOfDay < kDawnStart) {
+    // Full night: 20:00–4:00
+    if (timeOfDay >= 20.0f || timeOfDay < 4.0f) {
         return 1.0f;
     }
-    // Fade in at dusk
-    if (timeOfDay >= kDuskStart) {
-        return (timeOfDay - kDuskStart) / kFadeDuration;
+    // Fade in at dusk: 18:00–20:00
+    else if (timeOfDay >= 18.0f && timeOfDay < 20.0f) {
+        return (timeOfDay - 18.0f) / 2.0f;  // 0 → 1 over 2 hours
     }
-    // Fade out at dawn
-    if (timeOfDay < kDawnEnd) {
-        return 1.0f - (timeOfDay - kDawnStart) / kFadeDuration;
+    // Fade out at dawn: 4:00–6:00
+    else if (timeOfDay >= 4.0f && timeOfDay < 6.0f) {
+        return 1.0f - (timeOfDay - 4.0f) / 2.0f;  // 1 → 0 over 2 hours
     }
     // Daytime: no stars
-    return 0.0f;
+    else {
+        return 0.0f;
+    }
 }
 
 } // namespace rendering
diff --git a/src/rendering/swim_effects.cpp b/src/rendering/swim_effects.cpp
index 5e7f4599..9a7ad119 100644
--- a/src/rendering/swim_effects.cpp
+++ b/src/rendering/swim_effects.cpp
@@ -98,7 +98,7 @@ bool SwimEffects::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayou
             .setLayout(ripplePipelineLayout)
             .setRenderPass(vkCtx->getImGuiRenderPass())
             .setDynamicStates(dynamicStates)
-            .build(device, vkCtx->getPipelineCache());
+            .build(device);
 
         vertModule.destroy();
         fragModule.destroy();
@@ -142,7 +142,7 @@ bool SwimEffects::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayou
             .setLayout(bubblePipelineLayout)
             .setRenderPass(vkCtx->getImGuiRenderPass())
             .setDynamicStates(dynamicStates)
-            .build(device, vkCtx->getPipelineCache());
+            .build(device);
 
         vertModule.destroy();
         fragModule.destroy();
@@ -175,8 +175,6 @@ bool SwimEffects::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayou
             return false;
         }
 
-        // Depth test disabled — insects are screen-space sprites that must always
-        // render above the water surface regardless of scene geometry.
         insectPipeline = PipelineBuilder()
             .setShaders(vertStage, fragStage)
             .setVertexInput({binding}, attrs)
@@ -188,7 +186,7 @@ bool SwimEffects::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayou
             .setLayout(insectPipelineLayout)
             .setRenderPass(vkCtx->getImGuiRenderPass())
             .setDynamicStates(dynamicStates)
-            .build(device, vkCtx->getPipelineCache());
+            .build(device);
 
         vertModule.destroy();
         fragModule.destroy();
@@ -350,9 +348,9 @@ void SwimEffects::recreatePipelines() {
     // ---- Rebuild ripple pipeline ----
     {
         VkShaderModule vertModule;
-        (void)vertModule.loadFromFile(device, "assets/shaders/swim_ripple.vert.spv");
+        vertModule.loadFromFile(device, "assets/shaders/swim_ripple.vert.spv");
         VkShaderModule fragModule;
-        (void)fragModule.loadFromFile(device, "assets/shaders/swim_ripple.frag.spv");
+        fragModule.loadFromFile(device, "assets/shaders/swim_ripple.frag.spv");
 
         VkPipelineShaderStageCreateInfo vertStage = vertModule.stageInfo(VK_SHADER_STAGE_VERTEX_BIT);
         VkPipelineShaderStageCreateInfo fragStage = fragModule.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT);
@@ -368,7 +366,7 @@ void SwimEffects::recreatePipelines() {
             .setLayout(ripplePipelineLayout)
             .setRenderPass(vkCtx->getImGuiRenderPass())
             .setDynamicStates(dynamicStates)
-            .build(device, vkCtx->getPipelineCache());
+            .build(device);
 
         vertModule.destroy();
         fragModule.destroy();
@@ -377,9 +375,9 @@ void SwimEffects::recreatePipelines() {
     // ---- Rebuild bubble pipeline ----
     {
         VkShaderModule vertModule;
-        (void)vertModule.loadFromFile(device, "assets/shaders/swim_bubble.vert.spv");
+        vertModule.loadFromFile(device, "assets/shaders/swim_bubble.vert.spv");
         VkShaderModule fragModule;
-        (void)fragModule.loadFromFile(device, "assets/shaders/swim_bubble.frag.spv");
+        fragModule.loadFromFile(device, "assets/shaders/swim_bubble.frag.spv");
 
         VkPipelineShaderStageCreateInfo vertStage = vertModule.stageInfo(VK_SHADER_STAGE_VERTEX_BIT);
         VkPipelineShaderStageCreateInfo fragStage = fragModule.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT);
@@ -395,7 +393,7 @@ void SwimEffects::recreatePipelines() {
             .setLayout(bubblePipelineLayout)
             .setRenderPass(vkCtx->getImGuiRenderPass())
             .setDynamicStates(dynamicStates)
-            .build(device, vkCtx->getPipelineCache());
+            .build(device);
 
         vertModule.destroy();
         fragModule.destroy();
@@ -404,9 +402,9 @@ void SwimEffects::recreatePipelines() {
     // ---- Rebuild insect pipeline ----
     {
         VkShaderModule vertModule;
-        (void)vertModule.loadFromFile(device, "assets/shaders/swim_ripple.vert.spv");
+        vertModule.loadFromFile(device, "assets/shaders/swim_ripple.vert.spv");
         VkShaderModule fragModule;
-        (void)fragModule.loadFromFile(device, "assets/shaders/swim_insect.frag.spv");
+        fragModule.loadFromFile(device, "assets/shaders/swim_insect.frag.spv");
 
         VkPipelineShaderStageCreateInfo vertStage = vertModule.stageInfo(VK_SHADER_STAGE_VERTEX_BIT);
         VkPipelineShaderStageCreateInfo fragStage = fragModule.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT);
@@ -422,7 +420,7 @@ void SwimEffects::recreatePipelines() {
             .setLayout(insectPipelineLayout)
             .setRenderPass(vkCtx->getImGuiRenderPass())
             .setDynamicStates(dynamicStates)
-            .build(device, vkCtx->getPipelineCache());
+            .build(device);
 
         vertModule.destroy();
         fragModule.destroy();
@@ -544,7 +542,7 @@ void SwimEffects::update(const Camera& camera, const CameraController& cc,
         // Compute movement direction from camera yaw
         float yawRad = glm::radians(cc.getYaw());
         glm::vec3 moveDir(std::cos(yawRad), std::sin(yawRad), 0.0f);
-        if (moveDir.x * moveDir.x + moveDir.y * moveDir.y > 1e-6f) {
+        if (glm::length(glm::vec2(moveDir)) > 0.001f) {
             moveDir = glm::normalize(moveDir);
         }
 
@@ -678,7 +676,6 @@ void SwimEffects::update(const Camera& camera, const CameraController& cc,
 
     // --- Build vertex data ---
     rippleVertexData.clear();
-    rippleVertexData.reserve(ripples.size() * 5);
     for (const auto& p : ripples) {
         rippleVertexData.push_back(p.position.x);
         rippleVertexData.push_back(p.position.y);
@@ -688,7 +685,6 @@ void SwimEffects::update(const Camera& camera, const CameraController& cc,
     }
 
     bubbleVertexData.clear();
-    bubbleVertexData.reserve(bubbles.size() * 5);
     for (const auto& p : bubbles) {
         bubbleVertexData.push_back(p.position.x);
         bubbleVertexData.push_back(p.position.y);
@@ -698,7 +694,6 @@ void SwimEffects::update(const Camera& camera, const CameraController& cc,
     }
 
     insectVertexData.clear();
-    insectVertexData.reserve(insects.size() * 5);
     for (const auto& p : insects) {
         insectVertexData.push_back(p.position.x);
         insectVertexData.push_back(p.position.y);
diff --git a/src/rendering/terrain_manager.cpp b/src/rendering/terrain_manager.cpp
index 2639a1b1..e186ed96 100644
--- a/src/rendering/terrain_manager.cpp
+++ b/src/rendering/terrain_manager.cpp
@@ -8,7 +8,6 @@
 #include "audio/ambient_sound_manager.hpp"
 #include "core/coordinates.hpp"
 #include "core/memory_monitor.hpp"
-#include "core/profiler.hpp"
 #include "pipeline/asset_manager.hpp"
 #include "pipeline/adt_loader.hpp"
 #include "pipeline/m2_loader.hpp"
@@ -43,20 +42,6 @@ namespace rendering {
 
 namespace {
 
-// Alpha map format constants
-constexpr size_t  ALPHA_MAP_SIZE    = 4096;  // 64×64 uncompressed alpha bytes
-constexpr size_t  ALPHA_MAP_PACKED  = 2048;  // 64×64 packed 4-bit alpha (half size)
-static_assert(ALPHA_MAP_PACKED * 2 == ALPHA_MAP_SIZE, "packed alpha must unpack to full size");
-constexpr uint8_t ALPHA_FILL_FLAG   = 0x80;  // RLE command: fill vs. copy
-constexpr uint8_t ALPHA_COUNT_MASK  = 0x7F;  // RLE command: count bits
-
-// Random float normalization: mask to 16-bit then divide by max value to get [0..1]
-constexpr float kRand16Max = 65535.0f;
-
-// Placement transform constants
-constexpr float kDegToRad = 3.14159f / 180.0f;
-constexpr float kInv1024  = 1.0f / 1024.0f;
-
 int computeTerrainWorkerCount() {
     const char* raw = std::getenv("WOWEE_TERRAIN_WORKERS");
     if (raw && *raw) {
@@ -69,11 +54,9 @@ int computeTerrainWorkerCount() {
 
     unsigned hc = std::thread::hardware_concurrency();
     if (hc > 0) {
-        // Keep terrain workers conservative by default. Over-subscribing loader
-        // threads can starve main-thread networking/render updates on large-core CPUs.
-        const unsigned reserved = (hc >= 16u) ? 4u : ((hc >= 8u) ? 2u : 1u);
-        const unsigned maxDefaultWorkers = 8u;
-        const unsigned targetWorkers = std::max(4u, std::min(maxDefaultWorkers, hc - reserved));
+        // Use most cores for loading — leave 1-2 for render/update threads.
+        const unsigned reserved = (hc >= 8u) ? 2u : 1u;
+        const unsigned targetWorkers = std::max(4u, hc - reserved);
         return static_cast<int>(targetWorkers);
     }
     return 4;  // Fallback
@@ -93,24 +76,24 @@ bool decodeLayerAlpha(const pipeline::MapChunk& chunk, size_t layerIdx, std::vec
         }
     }
 
-    outAlpha.assign(ALPHA_MAP_SIZE, 255);
+    outAlpha.assign(4096, 255);
 
     if (layer.compressedAlpha()) {
         size_t readPos = offset;
         size_t writePos = 0;
-        while (writePos < ALPHA_MAP_SIZE && readPos < chunk.alphaMap.size()) {
+        while (writePos < 4096 && readPos < chunk.alphaMap.size()) {
             uint8_t cmd = chunk.alphaMap[readPos++];
-            bool fill = (cmd & ALPHA_FILL_FLAG) != 0;
-            int count = (cmd & ALPHA_COUNT_MASK) + 1;
+            bool fill = (cmd & 0x80) != 0;
+            int count = (cmd & 0x7F) + 1;
 
             if (fill) {
                 if (readPos >= chunk.alphaMap.size()) break;
                 uint8_t val = chunk.alphaMap[readPos++];
-                for (int i = 0; i < count && writePos < ALPHA_MAP_SIZE; i++) {
+                for (int i = 0; i < count && writePos < 4096; i++) {
                     outAlpha[writePos++] = val;
                 }
             } else {
-                for (int i = 0; i < count && writePos < ALPHA_MAP_SIZE && readPos < chunk.alphaMap.size(); i++) {
+                for (int i = 0; i < count && writePos < 4096 && readPos < chunk.alphaMap.size(); i++) {
                     outAlpha[writePos++] = chunk.alphaMap[readPos++];
                 }
             }
@@ -118,13 +101,13 @@ bool decodeLayerAlpha(const pipeline::MapChunk& chunk, size_t layerIdx, std::vec
         return true;
     }
 
-    if (layerSize >= ALPHA_MAP_SIZE) {
-        std::copy(chunk.alphaMap.begin() + offset, chunk.alphaMap.begin() + offset + ALPHA_MAP_SIZE, outAlpha.begin());
+    if (layerSize >= 4096) {
+        std::copy(chunk.alphaMap.begin() + offset, chunk.alphaMap.begin() + offset + 4096, outAlpha.begin());
         return true;
     }
 
-    if (layerSize >= ALPHA_MAP_PACKED) {
-        for (size_t i = 0; i < ALPHA_MAP_PACKED; i++) {
+    if (layerSize >= 2048) {
+        for (size_t i = 0; i < 2048; i++) {
             uint8_t v = chunk.alphaMap[offset + i];
             outAlpha[i * 2] = (v & 0x0F) * 17;
             outAlpha[i * 2 + 1] = (v >> 4) * 17;
@@ -189,13 +172,12 @@ bool TerrainManager::initialize(pipeline::AssetManager* assets, TerrainRenderer*
 }
 
 void TerrainManager::update(const Camera& camera, float deltaTime) {
-    ZoneScopedN("TerrainManager::update");
     if (!streamingEnabled || !assetManager || !terrainRenderer) {
         return;
     }
 
     // Always process ready tiles each frame (GPU uploads from background thread)
-    // Time-budgeted internally to prevent frame spikes.
+    // Time budget prevents frame spikes from heavy tiles
     processReadyTiles();
 
     timeSinceLastUpdate += deltaTime;
@@ -501,11 +483,11 @@ std::shared_ptr<PendingTile> TerrainManager::prepareTile(int x, int y) {
         p.uniqueId = placement.uniqueId;
         p.position = glPos;
         p.rotation = glm::vec3(
-            -placement.rotation[2] * kDegToRad,
-            -placement.rotation[0] * kDegToRad,
-            (placement.rotation[1] + 180.0f) * kDegToRad
+            -placement.rotation[2] * 3.14159f / 180.0f,
+            -placement.rotation[0] * 3.14159f / 180.0f,
+            (placement.rotation[1] + 180.0f) * 3.14159f / 180.0f
         );
-        p.scale = placement.scale * kInv1024;
+        p.scale = placement.scale / 1024.0f;
         pending->m2Placements.push_back(p);
     }
 
@@ -540,7 +522,7 @@ std::shared_ptr<PendingTile> TerrainManager::prepareTile(int x, int y) {
                 if (basePath.size() > 4) {
                     extension = basePath.substr(basePath.size() - 4);
                     std::string extLower = extension;
-                    for (char& c : extLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+                    for (char& c : extLower) c = std::tolower(c);
                     if (extLower == ".wmo") {
                         basePath = basePath.substr(0, basePath.size() - 4);
                     }
@@ -571,24 +553,14 @@ std::shared_ptr<PendingTile> TerrainManager::prepareTile(int x, int y) {
                                                        placement.position[2]);
 
                 glm::vec3 rot(
-                    -placement.rotation[2] * kDegToRad,
-                    -placement.rotation[0] * kDegToRad,
-                    (placement.rotation[1] + 180.0f) * kDegToRad
+                    -placement.rotation[2] * 3.14159f / 180.0f,
+                    -placement.rotation[0] * 3.14159f / 180.0f,
+                    (placement.rotation[1] + 180.0f) * 3.14159f / 180.0f
                 );
 
                 // Pre-load WMO doodads (M2 models inside WMO)
                 if (!workerRunning.load()) return nullptr;
-
-                // Skip WMO doodads if this placement was already prepared by another tile's worker.
-                // This prevents 15+ copies of Stormwind's ~6000 doodads from being parsed
-                // simultaneously, which was the primary cause of OOM during world load.
-                bool wmoAlreadyPrepared = false;
-                if (placement.uniqueId != 0) {
-                    std::lock_guard<std::mutex> lock(preparedWmoUniqueIdsMutex_);
-                    wmoAlreadyPrepared = !preparedWmoUniqueIds_.insert(placement.uniqueId).second;
-                }
-
-                if (!wmoAlreadyPrepared && !wmoModel.doodadSets.empty() && !wmoModel.doodads.empty()) {
+                if (!wmoModel.doodadSets.empty() && !wmoModel.doodads.empty()) {
                     glm::mat4 wmoMatrix(1.0f);
                     wmoMatrix = glm::translate(wmoMatrix, pos);
                     wmoMatrix = glm::rotate(wmoMatrix, rot.z, glm::vec3(0, 0, 1));
@@ -601,7 +573,6 @@ std::shared_ptr<PendingTile> TerrainManager::prepareTile(int x, int y) {
                         setsToLoad.push_back(placement.doodadSet);
                     }
                     std::unordered_set<uint32_t> loadedDoodadIndices;
-                    std::unordered_set<uint32_t> wmoPreparedModelIds;  // within-WMO model dedup
                     for (uint32_t setIdx : setsToLoad) {
                         const auto& doodadSet = wmoModel.doodadSets[setIdx];
                     for (uint32_t di = 0; di < doodadSet.count; di++) {
@@ -618,7 +589,7 @@ std::shared_ptr<PendingTile> TerrainManager::prepareTile(int x, int y) {
 
                         if (m2Path.size() > 4) {
                             std::string ext = m2Path.substr(m2Path.size() - 4);
-                            for (char& c : ext) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+                            for (char& c : ext) c = std::tolower(c);
                             if (ext == ".mdx" || ext == ".mdl") {
                                 m2Path = m2Path.substr(0, m2Path.size() - 4) + ".m2";
                             }
@@ -626,16 +597,15 @@ std::shared_ptr<PendingTile> TerrainManager::prepareTile(int x, int y) {
 
                         uint32_t doodadModelId = static_cast<uint32_t>(std::hash<std::string>{}(m2Path));
 
-                        // Skip file I/O if model already uploaded or already prepared within this WMO
+                        // Skip file I/O if model already uploaded from a previous tile
                         bool modelAlreadyUploaded = false;
                         {
                             std::lock_guard<std::mutex> lock(uploadedM2IdsMutex_);
                             modelAlreadyUploaded = uploadedM2Ids_.count(doodadModelId) > 0;
                         }
-                        bool modelAlreadyPreparedInWmo = !wmoPreparedModelIds.insert(doodadModelId).second;
 
                         pipeline::M2Model m2Model;
-                        if (!modelAlreadyUploaded && !modelAlreadyPreparedInWmo) {
+                        if (!modelAlreadyUploaded) {
                             std::vector<uint8_t> m2Data = assetManager->readFile(m2Path);
                             if (m2Data.empty()) continue;
 
@@ -915,18 +885,13 @@ bool TerrainManager::advanceFinalization(FinalizingTile& ft) {
     }
 
     case FinalizationPhase::M2_INSTANCES: {
-        // Create M2 instances incrementally to avoid main-thread stalls.
-        // createInstance includes an O(n) bone-sibling scan that becomes expensive
-        // on dense tiles with many placements and a large existing instance list.
-        if (m2Renderer && ft.m2InstanceIndex < pending->m2Placements.size()) {
-            constexpr size_t kInstancesPerStep = 32;
-            size_t created = 0;
-            while (ft.m2InstanceIndex < pending->m2Placements.size() && created < kInstancesPerStep) {
-                const auto& p = pending->m2Placements[ft.m2InstanceIndex++];
+        // Create all M2 instances (lightweight struct allocation, no GPU work)
+        if (m2Renderer) {
+            int loadedDoodads = 0;
+            int skippedDedup = 0;
+            for (const auto& p : pending->m2Placements) {
                 if (p.uniqueId != 0 && placedDoodadIds.count(p.uniqueId)) {
-                    continue;
-                }
-                if (!m2Renderer->hasModel(p.modelId)) {
+                    skippedDedup++;
                     continue;
                 }
                 uint32_t instId = m2Renderer->createInstance(p.modelId, p.position, p.rotation, p.scale);
@@ -936,14 +901,12 @@ bool TerrainManager::advanceFinalization(FinalizingTile& ft) {
                         placedDoodadIds.insert(p.uniqueId);
                         ft.tileUniqueIds.push_back(p.uniqueId);
                     }
-                    created++;
+                    loadedDoodads++;
                 }
             }
-            if (ft.m2InstanceIndex < pending->m2Placements.size()) {
-                return false; // More instances to create — yield
-            }
             LOG_DEBUG("  Loaded doodads for tile [", x, ",", y, "]: ",
-                     ft.m2InstanceIds.size(), " instances (", ft.uploadedM2ModelIds.size(), " new models)");
+                     loadedDoodads, " instances (", ft.uploadedM2ModelIds.size(), " new models, ",
+                     skippedDedup, " dedup skipped)");
         }
         ft.phase = FinalizationPhase::WMO_MODELS;
         return false;
@@ -985,74 +948,54 @@ bool TerrainManager::advanceFinalization(FinalizingTile& ft) {
     }
 
     case FinalizationPhase::WMO_INSTANCES: {
-        // Create WMO instances incrementally to avoid stalls on tiles with many WMOs.
-        // Liquid group loading is also budgeted (max 4 per call) to prevent stalls
-        // on WMOs with many liquid groups (e.g. Stormwind canals).
-        if (wmoRenderer && ft.wmoInstanceIndex < pending->wmoModels.size()) {
-            constexpr size_t kWmoInstancesPerStep = 4;
-            constexpr size_t kLiquidGroupsPerStep = 4;
-            size_t created = 0;
-            size_t liquidGroupsLoaded = 0;
-            while (ft.wmoInstanceIndex < pending->wmoModels.size() && created < kWmoInstancesPerStep) {
-                auto& wmoReady = pending->wmoModels[ft.wmoInstanceIndex];
-                // Skip duplicates and unloaded models
+        // Create all WMO instances + load WMO liquids
+        if (wmoRenderer) {
+            int loadedWMOs = 0;
+            int loadedLiquids = 0;
+            int skippedWmoDedup = 0;
+            for (auto& wmoReady : pending->wmoModels) {
                 if (wmoReady.uniqueId != 0 && placedWmoIds.count(wmoReady.uniqueId)) {
-                    ft.wmoInstanceIndex++;
-                    ft.wmoLiquidGroupIndex = 0;
+                    skippedWmoDedup++;
                     continue;
                 }
-                if (!wmoRenderer->isModelLoaded(wmoReady.modelId)) {
-                    ft.wmoInstanceIndex++;
-                    ft.wmoLiquidGroupIndex = 0;
-                    continue;
-                }
-                // Create the instance on first visit (liquidGroupIndex == 0)
-                if (ft.wmoLiquidGroupIndex == 0) {
-                    uint32_t wmoInstId = wmoRenderer->createInstance(wmoReady.modelId, wmoReady.position, wmoReady.rotation);
-                    if (!wmoInstId) {
-                        ft.wmoInstanceIndex++;
-                        continue;
-                    }
+
+                uint32_t wmoInstId = wmoRenderer->createInstance(wmoReady.modelId, wmoReady.position, wmoReady.rotation);
+                if (wmoInstId) {
                     ft.wmoInstanceIds.push_back(wmoInstId);
                     if (wmoReady.uniqueId != 0) {
                         placedWmoIds.insert(wmoReady.uniqueId);
                         ft.tileWmoUniqueIds.push_back(wmoReady.uniqueId);
                     }
-                }
-                // Load WMO liquids incrementally (canals, pools, etc.)
-                if (waterRenderer) {
-                    uint32_t wmoInstId = ft.wmoInstanceIds.back();
-                    glm::mat4 modelMatrix = glm::mat4(1.0f);
-                    modelMatrix = glm::translate(modelMatrix, wmoReady.position);
-                    modelMatrix = glm::rotate(modelMatrix, wmoReady.rotation.z, glm::vec3(0.0f, 0.0f, 1.0f));
-                    modelMatrix = glm::rotate(modelMatrix, wmoReady.rotation.y, glm::vec3(0.0f, 1.0f, 0.0f));
-                    modelMatrix = glm::rotate(modelMatrix, wmoReady.rotation.x, glm::vec3(1.0f, 0.0f, 0.0f));
-                    const auto& groups = wmoReady.model.groups;
-                    while (ft.wmoLiquidGroupIndex < groups.size() && liquidGroupsLoaded < kLiquidGroupsPerStep) {
-                        const auto& group = groups[ft.wmoLiquidGroupIndex];
-                        ft.wmoLiquidGroupIndex++;
-                        if (!group.liquid.hasLiquid()) continue;
-                        if (group.flags & 0x2000) {
-                            uint16_t lt = group.liquid.materialId;
-                            uint8_t basicType = (lt == 0) ? 0 : ((lt - 1) % 4);
-                            if (basicType < 2) continue;
+                    loadedWMOs++;
+
+                    // Load WMO liquids (canals, pools, etc.)
+                    if (waterRenderer) {
+                        glm::mat4 modelMatrix = glm::mat4(1.0f);
+                        modelMatrix = glm::translate(modelMatrix, wmoReady.position);
+                        modelMatrix = glm::rotate(modelMatrix, wmoReady.rotation.z, glm::vec3(0.0f, 0.0f, 1.0f));
+                        modelMatrix = glm::rotate(modelMatrix, wmoReady.rotation.y, glm::vec3(0.0f, 1.0f, 0.0f));
+                        modelMatrix = glm::rotate(modelMatrix, wmoReady.rotation.x, glm::vec3(1.0f, 0.0f, 0.0f));
+                        for (const auto& group : wmoReady.model.groups) {
+                            if (!group.liquid.hasLiquid()) continue;
+                            // Skip interior water/ocean but keep magma/slime (e.g. Ironforge lava)
+                            if (group.flags & 0x2000) {
+                                uint16_t lt = group.liquid.materialId;
+                                uint8_t basicType = (lt == 0) ? 0 : ((lt - 1) % 4);
+                                if (basicType < 2) continue;
+                            }
+                            waterRenderer->loadFromWMO(group.liquid, modelMatrix, wmoInstId);
+                            loadedLiquids++;
                         }
-                        waterRenderer->loadFromWMO(group.liquid, modelMatrix, wmoInstId);
-                        liquidGroupsLoaded++;
-                    }
-                    // More liquid groups remain on this WMO — yield
-                    if (ft.wmoLiquidGroupIndex < groups.size()) {
-                        return false;
                     }
                 }
-                ft.wmoInstanceIndex++;
-                ft.wmoLiquidGroupIndex = 0;
-                created++;
             }
-            if (ft.wmoInstanceIndex < pending->wmoModels.size()) {
-                return false; // More WMO instances to create — yield
+            if (loadedWMOs > 0 || skippedWmoDedup > 0) {
+                LOG_DEBUG("  Loaded WMOs for tile [", x, ",", y, "]: ",
+                         loadedWMOs, " instances, ", skippedWmoDedup, " dedup skipped");
+            }
+            if (loadedLiquids > 0) {
+                LOG_DEBUG("  Loaded WMO liquids for tile [", x, ",", y, "]: ", loadedLiquids);
             }
-            LOG_DEBUG("  Loaded WMOs for tile [", x, ",", y, "]: ", ft.wmoInstanceIds.size(), " instances");
         }
         ft.phase = FinalizationPhase::WMO_DOODADS;
         return false;
@@ -1238,7 +1181,6 @@ void TerrainManager::workerLoop() {
 }
 
 void TerrainManager::processReadyTiles() {
-    ZoneScopedN("TerrainManager::processReadyTiles");
     // Move newly ready tiles into the finalizing deque.
     // Keep them in pendingTiles so streamTiles() won't re-enqueue them.
     {
@@ -1265,25 +1207,18 @@ void TerrainManager::processReadyTiles() {
     // Async upload batch: record GPU copies into a command buffer, submit with
     // a fence, but DON'T wait.  The fence is polled on subsequent frames.
     // This eliminates the main-thread stall from vkWaitForFences entirely.
-    //
-    // Time-budgeted: yield after 8ms to prevent main-loop stalls. Each
-    // advanceFinalization step is designed to be small, but texture uploads
-    // and M2 model loads can occasionally spike. The budget ensures we
-    // spread heavy tiles across multiple frames instead of blocking.
-    const auto budgetStart = std::chrono::steady_clock::now();
-    const float budgetMs = taxiStreamingMode_ ? 16.0f : 8.0f;
+    const int maxSteps = taxiStreamingMode_ ? 4 : 1;
+    int steps = 0;
 
     if (vkCtx) vkCtx->beginUploadBatch();
 
-    while (!finalizingTiles_.empty()) {
+    while (!finalizingTiles_.empty() && steps < maxSteps) {
         auto& ft = finalizingTiles_.front();
         bool done = advanceFinalization(ft);
         if (done) {
             finalizingTiles_.pop_front();
         }
-        float elapsed = std::chrono::duration<float, std::milli>(
-            std::chrono::steady_clock::now() - budgetStart).count();
-        if (elapsed >= budgetMs) break;
+        steps++;
     }
 
     if (vkCtx) vkCtx->endUploadBatch();  // Async — submits but doesn't wait
@@ -1446,10 +1381,6 @@ void TerrainManager::unloadTile(int x, int y) {
     // Water may have already been loaded in TERRAIN phase, so clean it up.
     for (auto fit = finalizingTiles_.begin(); fit != finalizingTiles_.end(); ++fit) {
         if (fit->pending && fit->pending->coord == coord) {
-            // If terrain chunks were already uploaded, free their descriptor sets
-            if (fit->terrainMeshDone && terrainRenderer) {
-                terrainRenderer->removeTile(x, y);
-            }
             // If past TERRAIN phase, water was already loaded — remove it
             if (fit->phase != FinalizationPhase::TERRAIN && waterRenderer) {
                 waterRenderer->removeTile(x, y);
@@ -1465,11 +1396,7 @@ void TerrainManager::unloadTile(int x, int y) {
                 wmoRenderer->removeInstances(fit->wmoInstanceIds);
             }
             for (uint32_t uid : fit->tileUniqueIds) placedDoodadIds.erase(uid);
-            for (uint32_t uid : fit->tileWmoUniqueIds) {
-                placedWmoIds.erase(uid);
-                std::lock_guard<std::mutex> lock(preparedWmoUniqueIdsMutex_);
-                preparedWmoUniqueIds_.erase(uid);
-            }
+            for (uint32_t uid : fit->tileWmoUniqueIds) placedWmoIds.erase(uid);
             finalizingTiles_.erase(fit);
             return;
         }
@@ -1490,8 +1417,6 @@ void TerrainManager::unloadTile(int x, int y) {
     }
     for (uint32_t uid : tile->wmoUniqueIds) {
         placedWmoIds.erase(uid);
-        std::lock_guard<std::mutex> lock(preparedWmoUniqueIdsMutex_);
-        preparedWmoUniqueIds_.erase(uid);
     }
 
     // Remove M2 doodad instances
@@ -1576,10 +1501,6 @@ void TerrainManager::unloadAll() {
         std::lock_guard<std::mutex> lock(uploadedM2IdsMutex_);
         uploadedM2Ids_.clear();
     }
-    {
-        std::lock_guard<std::mutex> lock(preparedWmoUniqueIdsMutex_);
-        preparedWmoUniqueIds_.clear();
-    }
 
     LOG_INFO("Unloading all terrain tiles");
     loadedTiles.clear();
@@ -1632,10 +1553,6 @@ void TerrainManager::softReset() {
         std::lock_guard<std::mutex> lock(uploadedM2IdsMutex_);
         uploadedM2Ids_.clear();
     }
-    {
-        std::lock_guard<std::mutex> lock(preparedWmoUniqueIdsMutex_);
-        preparedWmoUniqueIds_.clear();
-    }
 
     // Clear tile cache — keys are (x,y) without map name, so stale entries from
     // a different map with overlapping coordinates would produce wrong geometry.
@@ -1904,8 +1821,8 @@ void TerrainManager::generateGroundClutterPlacements(std::shared_ptr<PendingTile
                 };
 
                 for (uint32_t a = 0; a < attempts; ++a) {
-                    float fracX = (nextRand() & 0xFFFFu) / kRand16Max * 8.0f;
-                    float fracY = (nextRand() & 0xFFFFu) / kRand16Max * 8.0f;
+                    float fracX = (nextRand() & 0xFFFFu) / 65535.0f * 8.0f;
+                    float fracY = (nextRand() & 0xFFFFu) / 65535.0f * 8.0f;
 
                     if (hasAlpha && !alphaScratch.empty()) {
                         int alphaX = glm::clamp(static_cast<int>((fracX / 8.0f) * 63.0f), 0, 63);
@@ -1972,8 +1889,8 @@ void TerrainManager::generateGroundClutterPlacements(std::shared_ptr<PendingTile
                     p.uniqueId = 0;
                     // MCNK chunk.position is already in terrain/render world space.
                     // Do not convert via ADT placement mapping (that is for MDDF/MODF records).
-                    p.rotation = glm::vec3(0.0f, 0.0f, (nextRand() & 0xFFFFu) / kRand16Max * (2.0f * pi));
-                    p.scale = 0.80f + ((nextRand() & 0xFFFFu) / kRand16Max) * 0.35f;
+                    p.rotation = glm::vec3(0.0f, 0.0f, (nextRand() & 0xFFFFu) / 65535.0f * (2.0f * pi));
+                    p.scale = 0.80f + ((nextRand() & 0xFFFFu) / 65535.0f) * 0.35f;
                     // Snap directly to sampled terrain height.
                     p.position = glm::vec3(worldX, worldY, worldZ + 0.01f);
                     pending->m2Placements.push_back(p);
@@ -2012,8 +1929,8 @@ void TerrainManager::generateGroundClutterPlacements(std::shared_ptr<PendingTile
                             return seed;
                         };
 
-                        float fracX = (nextRand() & 0xFFFFu) / kRand16Max * 8.0f;
-                        float fracY = (nextRand() & 0xFFFFu) / kRand16Max * 8.0f;
+                        float fracX = (nextRand() & 0xFFFFu) / 65535.0f * 8.0f;
+                        float fracY = (nextRand() & 0xFFFFu) / 65535.0f * 8.0f;
                         if (hasRoadLikeTextureAt(chunk, fracX, fracY)) {
                             roadRejected++;
                             continue;
@@ -2040,8 +1957,8 @@ void TerrainManager::generateGroundClutterPlacements(std::shared_ptr<PendingTile
                         PendingTile::M2Placement p;
                         p.modelId = proxyModelId;
                         p.uniqueId = 0;
-                        p.rotation = glm::vec3(0.0f, 0.0f, (nextRand() & 0xFFFFu) / kRand16Max * (2.0f * pi));
-                        p.scale = 0.75f + ((nextRand() & 0xFFFFu) / kRand16Max) * 0.40f;
+                        p.rotation = glm::vec3(0.0f, 0.0f, (nextRand() & 0xFFFFu) / 65535.0f * (2.0f * pi));
+                        p.scale = 0.75f + ((nextRand() & 0xFFFFu) / 65535.0f) * 0.40f;
                         p.position = glm::vec3(worldX, worldY, worldZ + 0.01f);
                         pending->m2Placements.push_back(p);
                         fallbackAdded++;
@@ -2296,16 +2213,10 @@ void TerrainManager::streamTiles() {
         return false;
     };
 
-    // Enqueue tiles in radius around current tile for async loading.
-    // Collect all newly-needed tiles, then sort by distance so the closest
-    // (most visible) tiles get loaded first.  This is critical during taxi
-    // flight where new tiles enter the radius faster than they can load.
+    // Enqueue tiles in radius around current tile for async loading
     {
         std::lock_guard<std::mutex> lock(queueMutex);
 
-        struct PendingEntry { TileCoord coord; int distSq; };
-        std::vector<PendingEntry> newTiles;
-
         for (int dy = -loadRadius; dy <= loadRadius; dy++) {
             for (int dx = -loadRadius; dx <= loadRadius; dx++) {
                 int tileX = currentTile.x + dx;
@@ -2329,19 +2240,10 @@ void TerrainManager::streamTiles() {
                 if (failedTiles.find(coord) != failedTiles.end()) continue;
                 if (shouldSkipMissingAdt(coord)) continue;
 
-                newTiles.push_back({coord, dx*dx + dy*dy});
+                loadQueue.push_back(coord);
                 pendingTiles[coord] = true;
             }
         }
-
-        // Sort nearest tiles first so workers service the most visible tiles
-        std::sort(newTiles.begin(), newTiles.end(),
-                  [](const PendingEntry& a, const PendingEntry& b) { return a.distSq < b.distSq; });
-
-        // Insert at front so new close tiles preempt any distant tiles already queued
-        for (auto it = newTiles.rbegin(); it != newTiles.rend(); ++it) {
-            loadQueue.push_front(it->coord);
-        }
     }
 
     // Notify workers that there's work
@@ -2367,6 +2269,17 @@ void TerrainManager::streamTiles() {
     }
 
     if (!tilesToUnload.empty()) {
+        // Don't clean up models during streaming - keep them in VRAM for performance
+        // Modern GPUs have 8-16GB VRAM, models are only ~hundreds of MB
+        // Cleanup can be done manually when memory pressure is detected
+        // NOTE: Disabled permanent model cleanup to leverage modern VRAM capacity
+        // if (m2Renderer) {
+        //     m2Renderer->cleanupUnusedModels();
+        // }
+        // if (wmoRenderer) {
+        //     wmoRenderer->cleanupUnusedModels();
+        // }
+
         LOG_INFO("Unloaded ", tilesToUnload.size(), " distant tiles, ",
                  loadedTiles.size(), " remain (models kept in VRAM)");
     }
diff --git a/src/rendering/terrain_renderer.cpp b/src/rendering/terrain_renderer.cpp
index 67b27463..4e8593f5 100644
--- a/src/rendering/terrain_renderer.cpp
+++ b/src/rendering/terrain_renderer.cpp
@@ -20,6 +20,17 @@
 namespace wowee {
 namespace rendering {
 
+namespace {
+size_t envSizeMBOrDefault(const char* name, size_t defMb) {
+    const char* raw = std::getenv(name);
+    if (!raw || !*raw) return defMb;
+    char* end = nullptr;
+    unsigned long long mb = std::strtoull(raw, &end, 10);
+    if (end == raw || mb == 0) return defMb;
+    return static_cast<size_t>(mb);
+}
+} // namespace
+
 // Matches set 1 binding 7 in terrain.frag.glsl
 struct TerrainParamsUBO {
     int32_t layerCount;
@@ -78,7 +89,6 @@ bool TerrainRenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameL
 
     VkDescriptorPoolCreateInfo poolInfo{};
     poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-    poolInfo.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
     poolInfo.maxSets = MAX_MATERIAL_SETS;
     poolInfo.poolSizeCount = 2;
     poolInfo.pPoolSizes = poolSizes;
@@ -128,7 +138,7 @@ bool TerrainRenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameL
     vertexAttribs[3] = { 3, 0, VK_FORMAT_R32G32_SFLOAT,
         static_cast<uint32_t>(offsetof(pipeline::TerrainVertex, layerUV)) };
 
-    // --- Build fill pipeline (base for derivatives — shared state optimization) ---
+    // --- Build fill pipeline ---
     VkRenderPass mainPass = vkCtx->getImGuiRenderPass();
 
     pipeline = PipelineBuilder()
@@ -143,8 +153,7 @@ bool TerrainRenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameL
         .setLayout(pipelineLayout)
         .setRenderPass(mainPass)
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .setFlags(VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT)
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     if (!pipeline) {
         LOG_ERROR("TerrainRenderer: failed to create fill pipeline");
@@ -153,7 +162,7 @@ bool TerrainRenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameL
         return false;
     }
 
-    // --- Build wireframe pipeline (derivative of fill) ---
+    // --- Build wireframe pipeline ---
     wireframePipeline = PipelineBuilder()
         .setShaders(vertShader.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
                     fragShader.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
@@ -166,9 +175,7 @@ bool TerrainRenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameL
         .setLayout(pipelineLayout)
         .setRenderPass(mainPass)
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .setFlags(VK_PIPELINE_CREATE_DERIVATIVE_BIT)
-        .setBasePipeline(pipeline)
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     if (!wireframePipeline) {
         LOG_WARNING("TerrainRenderer: wireframe pipeline not available");
@@ -193,64 +200,6 @@ bool TerrainRenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameL
         envSizeMBOrDefault("WOWEE_TERRAIN_TEX_CACHE_MB", 4096) * 1024ull * 1024ull;
     LOG_INFO("Terrain texture cache budget: ", textureCacheBudgetBytes_ / (1024 * 1024), " MB");
 
-    // Allocate mega vertex/index buffers and indirect draw buffer.
-    // All terrain chunks share these buffers, eliminating per-chunk VB/IB rebinds.
-    {
-        VmaAllocator allocator = vkCtx->getAllocator();
-
-        // Mega vertex buffer (host-visible for direct write during chunk upload)
-        VkBufferCreateInfo vbCI{};
-        vbCI.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
-        vbCI.size = static_cast<VkDeviceSize>(MEGA_VB_MAX_VERTS) * sizeof(pipeline::TerrainVertex);
-        vbCI.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
-        VmaAllocationCreateInfo vbAllocCI{};
-        vbAllocCI.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
-        vbAllocCI.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
-        VmaAllocationInfo vbInfo{};
-        if (vmaCreateBuffer(allocator, &vbCI, &vbAllocCI,
-                &megaVB_, &megaVBAlloc_, &vbInfo) == VK_SUCCESS) {
-            megaVBMapped_ = vbInfo.pMappedData;
-        } else {
-            LOG_WARNING("TerrainRenderer: mega VB allocation failed, per-chunk fallback");
-        }
-
-        // Mega index buffer
-        VkBufferCreateInfo ibCI{};
-        ibCI.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
-        ibCI.size = static_cast<VkDeviceSize>(MEGA_IB_MAX_INDICES) * sizeof(uint32_t);
-        ibCI.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
-        VmaAllocationCreateInfo ibAllocCI{};
-        ibAllocCI.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
-        ibAllocCI.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
-        VmaAllocationInfo ibInfo{};
-        if (vmaCreateBuffer(allocator, &ibCI, &ibAllocCI,
-                &megaIB_, &megaIBAlloc_, &ibInfo) == VK_SUCCESS) {
-            megaIBMapped_ = ibInfo.pMappedData;
-        } else {
-            LOG_WARNING("TerrainRenderer: mega IB allocation failed, per-chunk fallback");
-        }
-
-        // Indirect draw command buffer
-        VkBufferCreateInfo indCI{};
-        indCI.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
-        indCI.size = MAX_INDIRECT_DRAWS * sizeof(VkDrawIndexedIndirectCommand);
-        indCI.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
-        VmaAllocationCreateInfo indAllocCI{};
-        indAllocCI.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
-        indAllocCI.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
-        VmaAllocationInfo indInfo{};
-        if (vmaCreateBuffer(allocator, &indCI, &indAllocCI,
-                &indirectBuffer_, &indirectAlloc_, &indInfo) == VK_SUCCESS) {
-            indirectMapped_ = indInfo.pMappedData;
-        } else {
-            LOG_WARNING("TerrainRenderer: indirect buffer allocation failed");
-        }
-
-        LOG_INFO("Terrain mega buffers: VB=", vbCI.size / (1024*1024), "MB IB=",
-                 ibCI.size / (1024*1024), "MB indirect=",
-                 indCI.size / 1024, "KB");
-    }
-
     LOG_INFO("Terrain renderer initialized (Vulkan)");
     return true;
 }
@@ -293,7 +242,7 @@ void TerrainRenderer::recreatePipelines() {
 
     VkRenderPass mainPass = vkCtx->getImGuiRenderPass();
 
-    // Rebuild fill pipeline (base for derivatives — shared state optimization)
+    // Rebuild fill pipeline
     pipeline = PipelineBuilder()
         .setShaders(vertShader.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
                     fragShader.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
@@ -306,14 +255,13 @@ void TerrainRenderer::recreatePipelines() {
         .setLayout(pipelineLayout)
         .setRenderPass(mainPass)
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .setFlags(VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT)
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     if (!pipeline) {
         LOG_ERROR("TerrainRenderer::recreatePipelines: failed to create fill pipeline");
     }
 
-    // Rebuild wireframe pipeline (derivative of fill)
+    // Rebuild wireframe pipeline
     wireframePipeline = PipelineBuilder()
         .setShaders(vertShader.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
                     fragShader.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
@@ -326,9 +274,7 @@ void TerrainRenderer::recreatePipelines() {
         .setLayout(pipelineLayout)
         .setRenderPass(mainPass)
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .setFlags(VK_PIPELINE_CREATE_DERIVATIVE_BIT)
-        .setBasePipeline(pipeline)
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     if (!wireframePipeline) {
         LOG_WARNING("TerrainRenderer::recreatePipelines: wireframe pipeline not available");
@@ -375,13 +321,6 @@ void TerrainRenderer::shutdown() {
     if (shadowParamsLayout_) { vkDestroyDescriptorSetLayout(device, shadowParamsLayout_, nullptr); shadowParamsLayout_ = VK_NULL_HANDLE; }
     if (shadowParamsUBO_) { vmaDestroyBuffer(allocator, shadowParamsUBO_, shadowParamsAlloc_); shadowParamsUBO_ = VK_NULL_HANDLE; shadowParamsAlloc_ = VK_NULL_HANDLE; }
 
-    // Destroy mega buffers and indirect draw buffer
-    if (megaVB_) { vmaDestroyBuffer(allocator, megaVB_, megaVBAlloc_); megaVB_ = VK_NULL_HANDLE; megaVBAlloc_ = VK_NULL_HANDLE; megaVBMapped_ = nullptr; }
-    if (megaIB_) { vmaDestroyBuffer(allocator, megaIB_, megaIBAlloc_); megaIB_ = VK_NULL_HANDLE; megaIBAlloc_ = VK_NULL_HANDLE; megaIBMapped_ = nullptr; }
-    if (indirectBuffer_) { vmaDestroyBuffer(allocator, indirectBuffer_, indirectAlloc_); indirectBuffer_ = VK_NULL_HANDLE; indirectAlloc_ = VK_NULL_HANDLE; indirectMapped_ = nullptr; }
-    megaVBUsed_ = 0;
-    megaIBUsed_ = 0;
-
     vkCtx = nullptr;
 }
 
@@ -415,9 +354,6 @@ bool TerrainRenderer::loadTerrain(const pipeline::TerrainMesh& mesh,
                 if (baseTexId < texturePaths.size()) {
                     gpuChunk.baseTexture = loadTexture(texturePaths[baseTexId]);
                 } else {
-                    LOG_WARNING("Terrain[", tileX, ",", tileY, "] chunk[", x, ",", y,
-                                "] base textureId ", baseTexId, " >= texturePaths size ",
-                                texturePaths.size(), " — white fallback");
                     gpuChunk.baseTexture = whiteTexture.get();
                 }
 
@@ -428,11 +364,6 @@ bool TerrainRenderer::loadTerrain(const pipeline::TerrainMesh& mesh,
                     VkTexture* layerTex = whiteTexture.get();
                     if (layer.textureId < texturePaths.size()) {
                         layerTex = loadTexture(texturePaths[layer.textureId]);
-                    } else {
-                        LOG_WARNING("Terrain[", tileX, ",", tileY, "] chunk[", x, ",", y,
-                                    "] layer[", i, "] textureId ", layer.textureId,
-                                    " >= texturePaths size ", texturePaths.size(),
-                                    " — white fallback");
                     }
                     gpuChunk.layerTextures[li] = layerTex;
 
@@ -467,25 +398,17 @@ bool TerrainRenderer::loadTerrain(const pipeline::TerrainMesh& mesh,
             allocCI.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
 
             VmaAllocationInfo mapInfo{};
-            // Check return value — a null UBO handle would cause the GPU to
-            // read from an invalid descriptor, crashing the driver under
-            // memory pressure instead of gracefully skipping the chunk.
-            if (vmaCreateBuffer(vkCtx->getAllocator(), &bufCI, &allocCI,
-                                &gpuChunk.paramsUBO, &gpuChunk.paramsAlloc, &mapInfo) != VK_SUCCESS) {
-                LOG_WARNING("Terrain chunk UBO allocation failed — skipping chunk");
-                destroyChunkGPU(gpuChunk);
-                continue;
-            }
+            vmaCreateBuffer(vkCtx->getAllocator(), &bufCI, &allocCI,
+                            &gpuChunk.paramsUBO, &gpuChunk.paramsAlloc, &mapInfo);
             if (mapInfo.pMappedData) {
                 std::memcpy(mapInfo.pMappedData, &params, sizeof(params));
             }
 
+            // Allocate and write material descriptor set
             gpuChunk.materialSet = allocateMaterialSet();
-            if (!gpuChunk.materialSet) {
-                destroyChunkGPU(gpuChunk);
-                continue;
+            if (gpuChunk.materialSet) {
+                writeMaterialDescriptors(gpuChunk.materialSet, gpuChunk);
             }
-            writeMaterialDescriptors(gpuChunk.materialSet, gpuChunk);
 
             chunks.push_back(std::move(gpuChunk));
         }
@@ -524,9 +447,6 @@ bool TerrainRenderer::loadTerrainIncremental(const pipeline::TerrainMesh& mesh,
             if (baseTexId < texturePaths.size()) {
                 gpuChunk.baseTexture = loadTexture(texturePaths[baseTexId]);
             } else {
-                LOG_WARNING("Terrain[", tileX, ",", tileY, "] chunk[", cx, ",", cy,
-                            "] base textureId ", baseTexId, " >= texturePaths size ",
-                            texturePaths.size(), " — white fallback");
                 gpuChunk.baseTexture = whiteTexture.get();
             }
 
@@ -537,11 +457,6 @@ bool TerrainRenderer::loadTerrainIncremental(const pipeline::TerrainMesh& mesh,
                 VkTexture* layerTex = whiteTexture.get();
                 if (layer.textureId < texturePaths.size()) {
                     layerTex = loadTexture(texturePaths[layer.textureId]);
-                } else {
-                    LOG_WARNING("Terrain[", tileX, ",", tileY, "] chunk[", cx, ",", cy,
-                                "] layer[", i, "] textureId ", layer.textureId,
-                                " >= texturePaths size ", texturePaths.size(),
-                                " — white fallback");
                 }
                 gpuChunk.layerTextures[li] = layerTex;
 
@@ -575,22 +490,16 @@ bool TerrainRenderer::loadTerrainIncremental(const pipeline::TerrainMesh& mesh,
         allocCI.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
 
         VmaAllocationInfo mapInfo{};
-        if (vmaCreateBuffer(vkCtx->getAllocator(), &bufCI, &allocCI,
-                            &gpuChunk.paramsUBO, &gpuChunk.paramsAlloc, &mapInfo) != VK_SUCCESS) {
-            LOG_WARNING("Terrain chunk UBO allocation failed (incremental) — skipping chunk");
-            destroyChunkGPU(gpuChunk);
-            continue;
-        }
+        vmaCreateBuffer(vkCtx->getAllocator(), &bufCI, &allocCI,
+                        &gpuChunk.paramsUBO, &gpuChunk.paramsAlloc, &mapInfo);
         if (mapInfo.pMappedData) {
             std::memcpy(mapInfo.pMappedData, &params, sizeof(params));
         }
 
         gpuChunk.materialSet = allocateMaterialSet();
-        if (!gpuChunk.materialSet) {
-            destroyChunkGPU(gpuChunk);
-            continue;
+        if (gpuChunk.materialSet) {
+            writeMaterialDescriptors(gpuChunk.materialSet, gpuChunk);
         }
-        writeMaterialDescriptors(gpuChunk.materialSet, gpuChunk);
 
         chunks.push_back(std::move(gpuChunk));
         uploaded++;
@@ -608,7 +517,6 @@ TerrainChunkGPU TerrainRenderer::uploadChunk(const pipeline::ChunkMesh& chunk) {
     gpuChunk.worldY = chunk.worldY;
     gpuChunk.worldZ = chunk.worldZ;
     gpuChunk.indexCount = static_cast<uint32_t>(chunk.indices.size());
-    gpuChunk.vertexCount = static_cast<uint32_t>(chunk.vertices.size());
 
     VkDeviceSize vbSize = chunk.vertices.size() * sizeof(pipeline::TerrainVertex);
     AllocatedBuffer vb = uploadBuffer(*vkCtx, chunk.vertices.data(), vbSize,
@@ -622,25 +530,6 @@ TerrainChunkGPU TerrainRenderer::uploadChunk(const pipeline::ChunkMesh& chunk) {
     gpuChunk.indexBuffer = ib.buffer;
     gpuChunk.indexAlloc = ib.allocation;
 
-    // Also copy into mega buffers for indirect drawing
-    uint32_t vertCount = static_cast<uint32_t>(chunk.vertices.size());
-    uint32_t idxCount = static_cast<uint32_t>(chunk.indices.size());
-    if (megaVBMapped_ && megaIBMapped_ &&
-        megaVBUsed_ + vertCount <= MEGA_VB_MAX_VERTS &&
-        megaIBUsed_ + idxCount <= MEGA_IB_MAX_INDICES) {
-        // Copy vertices
-        auto* vbDst = static_cast<pipeline::TerrainVertex*>(megaVBMapped_) + megaVBUsed_;
-        std::memcpy(vbDst, chunk.vertices.data(), vertCount * sizeof(pipeline::TerrainVertex));
-        // Copy indices
-        auto* ibDst = static_cast<uint32_t*>(megaIBMapped_) + megaIBUsed_;
-        std::memcpy(ibDst, chunk.indices.data(), idxCount * sizeof(uint32_t));
-
-        gpuChunk.megaBaseVertex = static_cast<int32_t>(megaVBUsed_);
-        gpuChunk.megaFirstIndex = megaIBUsed_;
-        megaVBUsed_ += vertCount;
-        megaIBUsed_ += idxCount;
-    }
-
     return gpuChunk;
 }
 
@@ -774,11 +663,7 @@ VkDescriptorSet TerrainRenderer::allocateMaterialSet() {
 
     VkDescriptorSet set = VK_NULL_HANDLE;
     if (vkAllocateDescriptorSets(vkCtx->getDevice(), &allocInfo, &set) != VK_SUCCESS) {
-        static uint64_t failCount = 0;
-        ++failCount;
-        if (failCount <= 8 || (failCount % 256) == 0) {
-            LOG_WARNING("TerrainRenderer: failed to allocate material descriptor set (count=", failCount, ")");
-        }
+        LOG_WARNING("TerrainRenderer: failed to allocate material descriptor set");
         return VK_NULL_HANDLE;
     }
     return set;
@@ -834,7 +719,7 @@ void TerrainRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, c
         glm::vec3 cam = camera.getPosition();
         // Find chunk nearest to camera
         const TerrainChunkGPU* nearest = nullptr;
-        float nearestDist = std::numeric_limits<float>::max();
+        float nearestDist = 1e30f;
         for (const auto& ch : chunks) {
             float dx = ch.boundingSphereCenter.x - cam.x;
             float dy = ch.boundingSphereCenter.y - cam.y;
@@ -872,23 +757,11 @@ void TerrainRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, c
     }
 
     glm::vec3 camPos = camera.getPosition();
-    // Terrain chunks beyond this distance are culled. 1200 world units ≈ 9 ADT tiles,
-    // matching the asset loading radius (8 tiles) plus a buffer for pop-in avoidance.
-    constexpr float kMaxTerrainViewDist = 1200.0f;
-    const float maxTerrainDistSq = kMaxTerrainViewDist * kMaxTerrainViewDist;
+    const float maxTerrainDistSq = 1200.0f * 1200.0f;
 
     renderedChunks = 0;
     culledChunks = 0;
 
-    // Use mega VB + IB when available.
-    // Bind mega buffers once, then use direct draws with base vertex/index offsets.
-    const bool useMegaBuffers = (megaVB_ && megaIB_);
-    if (useMegaBuffers) {
-        VkDeviceSize megaOffset = 0;
-        vkCmdBindVertexBuffers(cmd, 0, 1, &megaVB_, &megaOffset);
-        vkCmdBindIndexBuffer(cmd, megaIB_, 0, VK_INDEX_TYPE_UINT32);
-    }
-
     for (const auto& chunk : chunks) {
         if (!chunk.isValid() || !chunk.materialSet) continue;
 
@@ -908,17 +781,11 @@ void TerrainRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, c
         vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout,
                                  1, 1, &chunk.materialSet, 0, nullptr);
 
-        if (useMegaBuffers && chunk.megaBaseVertex >= 0) {
-            // Direct draw from mega buffer — single VB/IB already bound
-            vkCmdDrawIndexed(cmd, chunk.indexCount, 1,
-                             chunk.megaFirstIndex, chunk.megaBaseVertex, 0);
-        } else {
-            // Fallback: per-chunk VB/IB bind + direct draw
-            VkDeviceSize offset = 0;
-            vkCmdBindVertexBuffers(cmd, 0, 1, &chunk.vertexBuffer, &offset);
-            vkCmdBindIndexBuffer(cmd, chunk.indexBuffer, 0, VK_INDEX_TYPE_UINT32);
-            vkCmdDrawIndexed(cmd, chunk.indexCount, 1, 0, 0, 0);
-        }
+        VkDeviceSize offset = 0;
+        vkCmdBindVertexBuffers(cmd, 0, 1, &chunk.vertexBuffer, &offset);
+        vkCmdBindIndexBuffer(cmd, chunk.indexBuffer, 0, VK_INDEX_TYPE_UINT32);
+
+        vkCmdDrawIndexed(cmd, chunk.indexCount, 1, 0, 0, 0);
         renderedChunks++;
     }
 
@@ -931,6 +798,15 @@ bool TerrainRenderer::initializeShadow(VkRenderPass shadowRenderPass) {
     VmaAllocator allocator = vkCtx->getAllocator();
 
     // ShadowParams UBO — terrain uses no bones, no texture, no alpha test
+    struct ShadowParamsUBO {
+        int32_t useBones        = 0;
+        int32_t useTexture      = 0;
+        int32_t alphaTest       = 0;
+        int32_t foliageSway     = 0;
+        float   windTime        = 0.0f;
+        float   foliageMotionDamp = 1.0f;
+    };
+
     VkBufferCreateInfo bufCI{};
     bufCI.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
     bufCI.size = sizeof(ShadowParamsUBO);
@@ -1064,7 +940,7 @@ bool TerrainRenderer::initializeShadow(VkRenderPass shadowRenderPass) {
         .setLayout(shadowPipelineLayout_)
         .setRenderPass(shadowRenderPass)
         .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     vertShader.destroy();
     fragShader.destroy();
@@ -1088,18 +964,11 @@ void TerrainRenderer::renderShadow(VkCommandBuffer cmd, const glm::mat4& lightSp
 
     // Identity model matrix — terrain vertices are already in world space
     static const glm::mat4 identity(1.0f);
+    struct ShadowPush { glm::mat4 lightSpaceMatrix; glm::mat4 model; };
     ShadowPush push{ lightSpaceMatrix, identity };
     vkCmdPushConstants(cmd, shadowPipelineLayout_, VK_SHADER_STAGE_VERTEX_BIT,
                        0, 128, &push);
 
-    // Bind mega buffers once for shadow pass (same as opaque)
-    const bool useMegaShadow = (megaVB_ && megaIB_);
-    if (useMegaShadow) {
-        VkDeviceSize megaOffset = 0;
-        vkCmdBindVertexBuffers(cmd, 0, 1, &megaVB_, &megaOffset);
-        vkCmdBindIndexBuffer(cmd, megaIB_, 0, VK_INDEX_TYPE_UINT32);
-    }
-
     for (const auto& chunk : chunks) {
         if (!chunk.isValid()) continue;
 
@@ -1109,14 +978,10 @@ void TerrainRenderer::renderShadow(VkCommandBuffer cmd, const glm::mat4& lightSp
         float combinedRadius = shadowRadius + chunk.boundingSphereRadius;
         if (distSq > combinedRadius * combinedRadius) continue;
 
-        if (useMegaShadow && chunk.megaBaseVertex >= 0) {
-            vkCmdDrawIndexed(cmd, chunk.indexCount, 1, chunk.megaFirstIndex, chunk.megaBaseVertex, 0);
-        } else {
-            VkDeviceSize offset = 0;
-            vkCmdBindVertexBuffers(cmd, 0, 1, &chunk.vertexBuffer, &offset);
-            vkCmdBindIndexBuffer(cmd, chunk.indexBuffer, 0, VK_INDEX_TYPE_UINT32);
-            vkCmdDrawIndexed(cmd, chunk.indexCount, 1, 0, 0, 0);
-        }
+        VkDeviceSize offset = 0;
+        vkCmdBindVertexBuffers(cmd, 0, 1, &chunk.vertexBuffer, &offset);
+        vkCmdBindIndexBuffer(cmd, chunk.indexBuffer, 0, VK_INDEX_TYPE_UINT16);
+        vkCmdDrawIndexed(cmd, chunk.indexCount, 1, 0, 0, 0);
     }
 }
 
@@ -1145,64 +1010,38 @@ void TerrainRenderer::clear() {
     }
     chunks.clear();
     renderedChunks = 0;
+
+    if (materialDescPool) {
+        vkResetDescriptorPool(vkCtx->getDevice(), materialDescPool, 0);
+    }
 }
 
 void TerrainRenderer::destroyChunkGPU(TerrainChunkGPU& chunk) {
-    if (!vkCtx) return;
-
-    VkDevice device = vkCtx->getDevice();
     VmaAllocator allocator = vkCtx->getAllocator();
 
-    // These resources may still be referenced by in-flight command buffers from
-    // previous frames. Defer actual destruction until this frame slot is safe.
-    ::VkBuffer vertexBuffer = chunk.vertexBuffer;
-    VmaAllocation vertexAlloc = chunk.vertexAlloc;
-    ::VkBuffer indexBuffer = chunk.indexBuffer;
-    VmaAllocation indexAlloc = chunk.indexAlloc;
-    ::VkBuffer paramsUBO = chunk.paramsUBO;
-    VmaAllocation paramsAlloc = chunk.paramsAlloc;
-    VkDescriptorPool pool = materialDescPool;
-    VkDescriptorSet materialSet = chunk.materialSet;
-
-    std::vector<VkTexture*> alphaTextures;
-    alphaTextures.reserve(chunk.ownedAlphaTextures.size());
-    for (auto& tex : chunk.ownedAlphaTextures) {
-        alphaTextures.push_back(tex.release());
+    if (chunk.vertexBuffer) {
+        AllocatedBuffer ab{}; ab.buffer = chunk.vertexBuffer; ab.allocation = chunk.vertexAlloc;
+        destroyBuffer(allocator, ab);
+        chunk.vertexBuffer = VK_NULL_HANDLE;
+    }
+    if (chunk.indexBuffer) {
+        AllocatedBuffer ab{}; ab.buffer = chunk.indexBuffer; ab.allocation = chunk.indexAlloc;
+        destroyBuffer(allocator, ab);
+        chunk.indexBuffer = VK_NULL_HANDLE;
+    }
+    if (chunk.paramsUBO) {
+        AllocatedBuffer ab{}; ab.buffer = chunk.paramsUBO; ab.allocation = chunk.paramsAlloc;
+        destroyBuffer(allocator, ab);
+        chunk.paramsUBO = VK_NULL_HANDLE;
     }
-
-    chunk.vertexBuffer = VK_NULL_HANDLE;
-    chunk.vertexAlloc = VK_NULL_HANDLE;
-    chunk.indexBuffer = VK_NULL_HANDLE;
-    chunk.indexAlloc = VK_NULL_HANDLE;
-    chunk.paramsUBO = VK_NULL_HANDLE;
-    chunk.paramsAlloc = VK_NULL_HANDLE;
     chunk.materialSet = VK_NULL_HANDLE;
-    chunk.ownedAlphaTextures.clear();
 
-    vkCtx->deferAfterAllFrameFences([device, allocator, vertexBuffer, vertexAlloc, indexBuffer, indexAlloc,
-                                     paramsUBO, paramsAlloc, pool, materialSet, alphaTextures]() {
-        if (vertexBuffer) {
-            AllocatedBuffer ab{}; ab.buffer = vertexBuffer; ab.allocation = vertexAlloc;
-            destroyBuffer(allocator, ab);
-        }
-        if (indexBuffer) {
-            AllocatedBuffer ab{}; ab.buffer = indexBuffer; ab.allocation = indexAlloc;
-            destroyBuffer(allocator, ab);
-        }
-        if (paramsUBO) {
-            AllocatedBuffer ab{}; ab.buffer = paramsUBO; ab.allocation = paramsAlloc;
-            destroyBuffer(allocator, ab);
-        }
-        if (materialSet && pool) {
-            VkDescriptorSet set = materialSet;
-            vkFreeDescriptorSets(device, pool, 1, &set);
-        }
-        for (VkTexture* tex : alphaTextures) {
-            if (!tex) continue;
-            tex->destroy(device, allocator);
-            delete tex;
-        }
-    });
+    // Destroy owned alpha textures (VkTexture::~VkTexture is a no-op, must call destroy() explicitly)
+    VkDevice device = vkCtx->getDevice();
+    for (auto& tex : chunk.ownedAlphaTextures) {
+        if (tex) tex->destroy(device, allocator);
+    }
+    chunk.ownedAlphaTextures.clear();
 }
 
 int TerrainRenderer::getTriangleCount() const {
diff --git a/src/rendering/video_player.cpp b/src/rendering/video_player.cpp
new file mode 100644
index 00000000..c11dd799
--- /dev/null
+++ b/src/rendering/video_player.cpp
@@ -0,0 +1,253 @@
+#include "rendering/video_player.hpp"
+#include "core/logger.hpp"
+#include <GL/glew.h>
+
+extern "C" {
+#include <libavformat/avformat.h>
+#include <libavcodec/avcodec.h>
+#include <libswscale/swscale.h>
+#include <libavutil/imgutils.h>
+}
+
+namespace wowee {
+namespace rendering {
+
+VideoPlayer::VideoPlayer() = default;
+
+VideoPlayer::~VideoPlayer() {
+    close();
+}
+
+bool VideoPlayer::open(const std::string& path) {
+    if (!path.empty() && sourcePath == path && formatCtx) return true;
+    close();
+
+    sourcePath = path;
+    AVFormatContext* fmt = nullptr;
+    if (avformat_open_input(&fmt, path.c_str(), nullptr, nullptr) != 0) {
+        LOG_WARNING("VideoPlayer: failed to open ", path);
+        return false;
+    }
+    if (avformat_find_stream_info(fmt, nullptr) < 0) {
+        LOG_WARNING("VideoPlayer: failed to read stream info for ", path);
+        avformat_close_input(&fmt);
+        return false;
+    }
+
+    int streamIndex = -1;
+    for (unsigned int i = 0; i < fmt->nb_streams; i++) {
+        if (fmt->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
+            streamIndex = static_cast<int>(i);
+            break;
+        }
+    }
+    if (streamIndex < 0) {
+        LOG_WARNING("VideoPlayer: no video stream in ", path);
+        avformat_close_input(&fmt);
+        return false;
+    }
+
+    AVCodecParameters* codecpar = fmt->streams[streamIndex]->codecpar;
+    const AVCodec* codec = avcodec_find_decoder(codecpar->codec_id);
+    if (!codec) {
+        LOG_WARNING("VideoPlayer: unsupported codec for ", path);
+        avformat_close_input(&fmt);
+        return false;
+    }
+
+    AVCodecContext* ctx = avcodec_alloc_context3(codec);
+    if (!ctx) {
+        avformat_close_input(&fmt);
+        return false;
+    }
+    if (avcodec_parameters_to_context(ctx, codecpar) < 0) {
+        avcodec_free_context(&ctx);
+        avformat_close_input(&fmt);
+        return false;
+    }
+    if (avcodec_open2(ctx, codec, nullptr) < 0) {
+        avcodec_free_context(&ctx);
+        avformat_close_input(&fmt);
+        return false;
+    }
+
+    AVFrame* f = av_frame_alloc();
+    AVFrame* rgb = av_frame_alloc();
+    AVPacket* pkt = av_packet_alloc();
+    if (!f || !rgb || !pkt) {
+        if (pkt) av_packet_free(&pkt);
+        if (rgb) av_frame_free(&rgb);
+        if (f) av_frame_free(&f);
+        avcodec_free_context(&ctx);
+        avformat_close_input(&fmt);
+        return false;
+    }
+
+    width = ctx->width;
+    height = ctx->height;
+    if (width <= 0 || height <= 0) {
+        av_packet_free(&pkt);
+        av_frame_free(&rgb);
+        av_frame_free(&f);
+        avcodec_free_context(&ctx);
+        avformat_close_input(&fmt);
+        return false;
+    }
+
+    int bufferSize = av_image_get_buffer_size(AV_PIX_FMT_RGB24, width, height, 1);
+    rgbBuffer.resize(static_cast<size_t>(bufferSize));
+    av_image_fill_arrays(rgb->data, rgb->linesize,
+                         rgbBuffer.data(), AV_PIX_FMT_RGB24, width, height, 1);
+
+    SwsContext* sws = sws_getContext(width, height, ctx->pix_fmt,
+                                     width, height, AV_PIX_FMT_RGB24,
+                                     SWS_BILINEAR, nullptr, nullptr, nullptr);
+    if (!sws) {
+        av_packet_free(&pkt);
+        av_frame_free(&rgb);
+        av_frame_free(&f);
+        avcodec_free_context(&ctx);
+        avformat_close_input(&fmt);
+        return false;
+    }
+
+    AVRational fr = fmt->streams[streamIndex]->avg_frame_rate;
+    if (fr.num <= 0 || fr.den <= 0) {
+        fr = fmt->streams[streamIndex]->r_frame_rate;
+    }
+    double fps = (fr.num > 0 && fr.den > 0) ? static_cast<double>(fr.num) / fr.den : 30.0;
+    if (fps <= 0.0) fps = 30.0;
+    frameTime = 1.0 / fps;
+    accumulator = 0.0;
+    eof = false;
+
+    formatCtx = fmt;
+    codecCtx = ctx;
+    frame = f;
+    rgbFrame = rgb;
+    packet = pkt;
+    swsCtx = sws;
+    videoStreamIndex = streamIndex;
+
+    textureReady = false;
+    return true;
+}
+
+void VideoPlayer::close() {
+    if (textureId) {
+        glDeleteTextures(1, &textureId);
+        textureId = 0;
+    }
+    textureReady = false;
+
+    if (packet) {
+        av_packet_free(reinterpret_cast<AVPacket**>(&packet));
+        packet = nullptr;
+    }
+    if (rgbFrame) {
+        av_frame_free(reinterpret_cast<AVFrame**>(&rgbFrame));
+        rgbFrame = nullptr;
+    }
+    if (frame) {
+        av_frame_free(reinterpret_cast<AVFrame**>(&frame));
+        frame = nullptr;
+    }
+    if (codecCtx) {
+        avcodec_free_context(reinterpret_cast<AVCodecContext**>(&codecCtx));
+        codecCtx = nullptr;
+    }
+    if (formatCtx) {
+        avformat_close_input(reinterpret_cast<AVFormatContext**>(&formatCtx));
+        formatCtx = nullptr;
+    }
+    if (swsCtx) {
+        sws_freeContext(reinterpret_cast<SwsContext*>(swsCtx));
+        swsCtx = nullptr;
+    }
+    videoStreamIndex = -1;
+    width = 0;
+    height = 0;
+    rgbBuffer.clear();
+}
+
+void VideoPlayer::update(float deltaTime) {
+    if (!formatCtx || !codecCtx) return;
+    accumulator += deltaTime;
+    while (accumulator >= frameTime) {
+        if (!decodeNextFrame()) break;
+        accumulator -= frameTime;
+    }
+}
+
+bool VideoPlayer::decodeNextFrame() {
+    AVFormatContext* fmt = reinterpret_cast<AVFormatContext*>(formatCtx);
+    AVCodecContext* ctx = reinterpret_cast<AVCodecContext*>(codecCtx);
+    AVFrame* f = reinterpret_cast<AVFrame*>(frame);
+    AVFrame* rgb = reinterpret_cast<AVFrame*>(rgbFrame);
+    AVPacket* pkt = reinterpret_cast<AVPacket*>(packet);
+    SwsContext* sws = reinterpret_cast<SwsContext*>(swsCtx);
+
+    while (true) {
+        int ret = av_read_frame(fmt, pkt);
+        if (ret < 0) {
+            if (av_seek_frame(fmt, videoStreamIndex, 0, AVSEEK_FLAG_BACKWARD) >= 0) {
+                avcodec_flush_buffers(ctx);
+                continue;
+            }
+            return false;
+        }
+
+        if (pkt->stream_index != videoStreamIndex) {
+            av_packet_unref(pkt);
+            continue;
+        }
+
+        if (avcodec_send_packet(ctx, pkt) < 0) {
+            av_packet_unref(pkt);
+            continue;
+        }
+        av_packet_unref(pkt);
+
+        ret = avcodec_receive_frame(ctx, f);
+        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
+            continue;
+        }
+        if (ret < 0) {
+            continue;
+        }
+
+        sws_scale(sws,
+                  f->data, f->linesize,
+                  0, ctx->height,
+                  rgb->data, rgb->linesize);
+
+        uploadFrame();
+        return true;
+    }
+}
+
+void VideoPlayer::uploadFrame() {
+    if (width <= 0 || height <= 0) return;
+    if (!textureId) {
+        glGenTextures(1, &textureId);
+        glBindTexture(GL_TEXTURE_2D, textureId);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0,
+                     GL_RGB, GL_UNSIGNED_BYTE, rgbBuffer.data());
+        glBindTexture(GL_TEXTURE_2D, 0);
+        textureReady = true;
+        return;
+    }
+
+    glBindTexture(GL_TEXTURE_2D, textureId);
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height,
+                    GL_RGB, GL_UNSIGNED_BYTE, rgbBuffer.data());
+    glBindTexture(GL_TEXTURE_2D, 0);
+    textureReady = true;
+}
+
+} // namespace rendering
+} // namespace wowee
diff --git a/src/rendering/vk_context.cpp b/src/rendering/vk_context.cpp
index 4a5d6366..dc4144fa 100644
--- a/src/rendering/vk_context.cpp
+++ b/src/rendering/vk_context.cpp
@@ -6,54 +6,10 @@
 #include <imgui_impl_vulkan.h>
 #include <algorithm>
 #include <cstring>
-#include <filesystem>
-#include <fstream>
-#include <string>
 
 namespace wowee {
 namespace rendering {
 
-VkContext* VkContext::sInstance_ = nullptr;
-
-// Hash a VkSamplerCreateInfo into a 64-bit key for the sampler cache.
-// FNV-1a chosen for speed and low collision rate on small structured data.
-// Constants from: http://www.isthe.com/chongo/tech/comp/fnv/
-static constexpr uint64_t kFnv1aOffsetBasis = 14695981039346656037ULL;
-static constexpr uint64_t kFnv1aPrime       = 1099511628211ULL;
-
-static uint64_t hashSamplerCreateInfo(const VkSamplerCreateInfo& s) {
-    uint64_t h = kFnv1aOffsetBasis;
-    auto mix = [&](uint64_t v) {
-        h ^= v;
-        h *= kFnv1aPrime;
-    };
-    mix(static_cast<uint64_t>(s.minFilter));
-    mix(static_cast<uint64_t>(s.magFilter));
-    mix(static_cast<uint64_t>(s.mipmapMode));
-    mix(static_cast<uint64_t>(s.addressModeU));
-    mix(static_cast<uint64_t>(s.addressModeV));
-    mix(static_cast<uint64_t>(s.addressModeW));
-    mix(static_cast<uint64_t>(s.anisotropyEnable));
-    // Bit-cast floats to uint32_t for hashing
-    uint32_t aniso;
-    std::memcpy(&aniso, &s.maxAnisotropy, sizeof(aniso));
-    mix(static_cast<uint64_t>(aniso));
-    uint32_t maxLodBits;
-    std::memcpy(&maxLodBits, &s.maxLod, sizeof(maxLodBits));
-    mix(static_cast<uint64_t>(maxLodBits));
-    uint32_t minLodBits;
-    std::memcpy(&minLodBits, &s.minLod, sizeof(minLodBits));
-    mix(static_cast<uint64_t>(minLodBits));
-    mix(static_cast<uint64_t>(s.compareEnable));
-    mix(static_cast<uint64_t>(s.compareOp));
-    mix(static_cast<uint64_t>(s.borderColor));
-    uint32_t biasBits;
-    std::memcpy(&biasBits, &s.mipLodBias, sizeof(biasBits));
-    mix(static_cast<uint64_t>(biasBits));
-    mix(static_cast<uint64_t>(s.unnormalizedCoordinates));
-    return h;
-}
-
 static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(
     VkDebugUtilsMessageSeverityFlagBitsEXT severity,
     [[maybe_unused]] VkDebugUtilsMessageTypeFlagsEXT type,
@@ -81,10 +37,6 @@ bool VkContext::initialize(SDL_Window* window) {
     if (!createLogicalDevice()) return false;
     if (!createAllocator()) return false;
 
-    // Pipeline cache: try to load from disk, fall back to empty cache.
-    // Not fatal — if it fails we just skip caching.
-    createPipelineCache();
-
     int w, h;
     SDL_Vulkan_GetDrawableSize(window, &w, &h);
     if (!createSwapchain(w, h)) return false;
@@ -93,49 +45,27 @@ bool VkContext::initialize(SDL_Window* window) {
     if (!createSyncObjects()) return false;
     if (!createImGuiResources()) return false;
 
-    // Query anisotropy support from the physical device.
-    VkPhysicalDeviceFeatures supportedFeatures{};
-    vkGetPhysicalDeviceFeatures(physicalDevice, &supportedFeatures);
-    samplerAnisotropySupported_ = (supportedFeatures.samplerAnisotropy == VK_TRUE);
-    LOG_INFO("Sampler anisotropy supported: ", samplerAnisotropySupported_ ? "YES" : "NO");
-
-    sInstance_ = this;
-
     LOG_INFO("Vulkan context initialized successfully");
     return true;
 }
 
 void VkContext::shutdown() {
-    if (!device && !instance) return;  // Already shut down or never initialized
-
     LOG_WARNING("VkContext::shutdown - vkDeviceWaitIdle...");
     if (device) {
         vkDeviceWaitIdle(device);
     }
 
-    // Clear deferred cleanup queues WITHOUT executing them.  By this point the
-    // sub-renderers (which own the descriptor pools/buffers these lambdas
-    // reference) have already been destroyed, so running them would call
-    // vkFreeDescriptorSets on invalid pools.  vkDestroyDevice reclaims all
-    // device-child resources anyway.
-    for (uint32_t fi = 0; fi < MAX_FRAMES_IN_FLIGHT; fi++) {
-        deferredCleanup_[fi].clear();
-    }
-
     LOG_WARNING("VkContext::shutdown - destroyImGuiResources...");
     destroyImGuiResources();
 
     // Destroy sync objects
     for (auto& frame : frames) {
         if (frame.inFlightFence) vkDestroyFence(device, frame.inFlightFence, nullptr);
+        if (frame.renderFinishedSemaphore) vkDestroySemaphore(device, frame.renderFinishedSemaphore, nullptr);
+        if (frame.imageAvailableSemaphore) vkDestroySemaphore(device, frame.imageAvailableSemaphore, nullptr);
         if (frame.commandPool) vkDestroyCommandPool(device, frame.commandPool, nullptr);
         frame = {};
     }
-    for (auto sem : imageAcquiredSemaphores_) { if (sem) vkDestroySemaphore(device, sem, nullptr); }
-    imageAcquiredSemaphores_.clear();
-    for (auto sem : renderFinishedSemaphores_) { if (sem) vkDestroySemaphore(device, sem, nullptr); }
-    renderFinishedSemaphores_.clear();
-    if (nextAcquireSemaphore_) { vkDestroySemaphore(device, nextAcquireSemaphore_, nullptr); nextAcquireSemaphore_ = VK_NULL_HANDLE; }
 
     // Clean up any in-flight async upload batches (device already idle)
     for (auto& batch : inFlightBatches_) {
@@ -147,23 +77,6 @@ void VkContext::shutdown() {
 
     if (immFence) { vkDestroyFence(device, immFence, nullptr); immFence = VK_NULL_HANDLE; }
     if (immCommandPool) { vkDestroyCommandPool(device, immCommandPool, nullptr); immCommandPool = VK_NULL_HANDLE; }
-    if (transferCommandPool_) { vkDestroyCommandPool(device, transferCommandPool_, nullptr); transferCommandPool_ = VK_NULL_HANDLE; }
-
-    // Persist pipeline cache to disk before tearing down the device.
-    savePipelineCache();
-    if (pipelineCache_) {
-        vkDestroyPipelineCache(device, pipelineCache_, nullptr);
-        pipelineCache_ = VK_NULL_HANDLE;
-    }
-
-    // Destroy all cached samplers.
-    for (auto& [key, sampler] : samplerCache_) {
-        if (sampler) vkDestroySampler(device, sampler, nullptr);
-    }
-    samplerCache_.clear();
-    LOG_INFO("Sampler cache cleared");
-
-    sInstance_ = nullptr;
 
     LOG_WARNING("VkContext::shutdown - destroySwapchain...");
     destroySwapchain();
@@ -190,76 +103,6 @@ void VkContext::shutdown() {
     LOG_WARNING("Vulkan context shutdown complete");
 }
 
-void VkContext::deferAfterFrameFence(std::function<void()>&& fn) {
-    deferredCleanup_[currentFrame].push_back(std::move(fn));
-}
-
-void VkContext::deferAfterAllFrameFences(std::function<void()>&& fn) {
-    // Shared resources (material descriptor sets, vertex/index buffers) are
-    // bound by every in-flight frame's command buffer.  deferAfterFrameFence
-    // only waits for ONE slot's fence — the other slot may still be executing.
-    // Add to every slot; a shared counter ensures the lambda runs exactly once,
-    // after the LAST slot has been fenced.
-    auto counter  = std::make_shared<uint32_t>(MAX_FRAMES_IN_FLIGHT);
-    auto sharedFn = std::make_shared<std::function<void()>>(std::move(fn));
-    for (uint32_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
-        deferredCleanup_[i].push_back([counter, sharedFn]() {
-            if (--(*counter) == 0) {
-                (*sharedFn)();
-            }
-        });
-    }
-}
-
-void VkContext::runDeferredCleanup(uint32_t frameIndex) {
-    auto& q = deferredCleanup_[frameIndex];
-    if (q.empty()) return;
-    for (auto& fn : q) {
-        if (fn) fn();
-    }
-    q.clear();
-}
-
-VkSampler VkContext::getOrCreateSampler(const VkSamplerCreateInfo& info) {
-    // Clamp anisotropy if the device doesn't support the feature.
-    VkSamplerCreateInfo adjusted = info;
-    if (!samplerAnisotropySupported_) {
-        adjusted.anisotropyEnable = VK_FALSE;
-        adjusted.maxAnisotropy = 1.0f;
-    }
-
-    uint64_t key = hashSamplerCreateInfo(adjusted);
-
-    {
-        std::lock_guard<std::mutex> lock(samplerCacheMutex_);
-        auto it = samplerCache_.find(key);
-        if (it != samplerCache_.end()) {
-            return it->second;
-        }
-    }
-
-    // Create a new sampler outside the lock (vkCreateSampler is thread-safe
-    // for distinct create infos, but we re-lock to insert).
-    VkSampler sampler = VK_NULL_HANDLE;
-    if (vkCreateSampler(device, &adjusted, nullptr, &sampler) != VK_SUCCESS) {
-        LOG_ERROR("getOrCreateSampler: vkCreateSampler failed");
-        return VK_NULL_HANDLE;
-    }
-
-    {
-        std::lock_guard<std::mutex> lock(samplerCacheMutex_);
-        // Double-check: another thread may have inserted while we were creating.
-        auto [it, inserted] = samplerCache_.emplace(key, sampler);
-        if (!inserted) {
-            // Another thread won the race — destroy our duplicate and use theirs.
-            vkDestroySampler(device, sampler, nullptr);
-            return it->second;
-        }
-    }
-
-    return sampler;
-}
-
 bool VkContext::createInstance(SDL_Window* window) {
     // Get required SDL extensions
     unsigned int sdlExtCount = 0;
@@ -270,8 +113,7 @@ bool VkContext::createInstance(SDL_Window* window) {
     vkb::InstanceBuilder builder;
     builder.set_app_name("Wowee")
            .set_app_version(VK_MAKE_VERSION(1, 0, 0))
-           .require_api_version(1, 2, 0)
-           .set_minimum_instance_version(1, 1, 0);
+           .require_api_version(1, 1, 0);
 
     for (auto ext : sdlExts) {
         builder.enable_extension(ext);
@@ -292,14 +134,7 @@ bool VkContext::createInstance(SDL_Window* window) {
     instance = vkbInstance_.instance;
     debugMessenger = vkbInstance_.debug_messenger;
 
-    // Query the actual instance API version for gating core 1.2+ calls
-    uint32_t instVer = VK_API_VERSION_1_1;
-    if (vkEnumerateInstanceVersion(&instVer) != VK_SUCCESS)
-        instVer = VK_API_VERSION_1_1;
-    instanceApiVersion_ = instVer;
-    LOG_INFO("Vulkan instance created (instance API version: ",
-             VK_VERSION_MAJOR(instVer), ".", VK_VERSION_MINOR(instVer), ".",
-             VK_VERSION_PATCH(instVer), ")");
+    LOG_INFO("Vulkan instance created");
     return true;
 }
 
@@ -313,14 +148,8 @@ bool VkContext::createSurface(SDL_Window* window) {
 
 bool VkContext::selectPhysicalDevice() {
     vkb::PhysicalDeviceSelector selector{vkbInstance_};
-    VkPhysicalDeviceFeatures requiredFeatures{};
-    requiredFeatures.samplerAnisotropy = VK_TRUE;
-    requiredFeatures.fillModeNonSolid = VK_TRUE;  // wireframe debug pipelines
-    requiredFeatures.shaderStorageImageWriteWithoutFormat = VK_TRUE;  // FSR2 compute shaders
-    requiredFeatures.shaderInt16 = VK_TRUE;  // FSR2 compute shaders
     selector.set_surface(surface)
             .set_minimum_version(1, 1)
-            .set_required_features(requiredFeatures)
             .prefer_gpu_device_type(vkb::PreferredDeviceType::discrete);
 
     auto physRet = selector.select();
@@ -334,11 +163,7 @@ bool VkContext::selectPhysicalDevice() {
 
     VkPhysicalDeviceProperties props;
     vkGetPhysicalDeviceProperties(physicalDevice, &props);
-    (void)props.apiVersion; // Available if needed for version checks
-    gpuVendorId_ = props.vendorID;
-    std::strncpy(gpuName_, props.deviceName, sizeof(gpuName_) - 1);
-    gpuName_[sizeof(gpuName_) - 1] = '\0';
-    LOG_INFO("GPU: ", gpuName_, " (vendor 0x", std::hex, gpuVendorId_, std::dec, ")");
+    uint32_t apiVersion = props.apiVersion;
 
     VkPhysicalDeviceDepthStencilResolveProperties dsResolveProps{};
     dsResolveProps.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
@@ -347,10 +172,7 @@ bool VkContext::selectPhysicalDevice() {
     props2.pNext = &dsResolveProps;
     vkGetPhysicalDeviceProperties2(physicalDevice, &props2);
 
-    // Gate on instance API version — vkCreateRenderPass2 is core 1.2 and only
-    // available when the instance was created with apiVersion >= 1.2.
-    // The device may report 1.2+ but a 1.1 instance won't have the function pointer.
-    if (instanceApiVersion_ >= VK_API_VERSION_1_2) {
+    if (apiVersion >= VK_API_VERSION_1_2) {
         VkResolveModeFlags modes = dsResolveProps.supportedDepthResolveModes;
         if (modes & VK_RESOLVE_MODE_SAMPLE_ZERO_BIT) {
             depthResolveMode_ = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT;
@@ -375,79 +197,11 @@ bool VkContext::selectPhysicalDevice() {
              VK_VERSION_MINOR(props.apiVersion), ".", VK_VERSION_PATCH(props.apiVersion));
     LOG_INFO("Depth resolve support: ", depthResolveSupported_ ? "YES" : "NO");
 
-    // Probe queue families to see if the graphics family supports multiple queues
-    // (used in createLogicalDevice to request a second queue for parallel uploads).
-    auto queueFamilies = vkbPhysicalDevice_.get_queue_families();
-    for (uint32_t i = 0; i < static_cast<uint32_t>(queueFamilies.size()); i++) {
-        if (queueFamilies[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
-            graphicsQueueFamilyQueueCount_ = queueFamilies[i].queueCount;
-            LOG_INFO("Graphics queue family ", i, " supports ", graphicsQueueFamilyQueueCount_, " queue(s)");
-            break;
-        }
-    }
-
     return true;
 }
 
 bool VkContext::createLogicalDevice() {
     vkb::DeviceBuilder deviceBuilder{vkbPhysicalDevice_};
-
-    // Enable optional Vulkan 1.2 features for FSR2 compute shaders (shaderFloat16)
-    VkPhysicalDeviceVulkan12Features enabled12{};
-    enabled12.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
-    if (instanceApiVersion_ >= VK_API_VERSION_1_2) {
-        VkPhysicalDeviceVulkan12Features supported12{};
-        supported12.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
-        VkPhysicalDeviceFeatures2 features2{};
-        features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
-        features2.pNext = &supported12;
-        vkGetPhysicalDeviceFeatures2(physicalDevice, &features2);
-        if (supported12.shaderFloat16) {
-            enabled12.shaderFloat16 = VK_TRUE;
-            LOG_INFO("Enabling shaderFloat16 for FSR2 compute shaders");
-        }
-        deviceBuilder.add_pNext(&enabled12);
-    }
-
-    // Enable AMD device coherent memory feature if the extension was enabled
-    // (prevents validation errors when VMA selects memory types with DEVICE_COHERENT_BIT_AMD)
-    VkPhysicalDeviceCoherentMemoryFeaturesAMD coherentFeatures{};
-    coherentFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
-    if (vkbPhysicalDevice_.enable_extension_if_present(VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME)) {
-        coherentFeatures.deviceCoherentMemory = VK_TRUE;
-        deviceBuilder.add_pNext(&coherentFeatures);
-        LOG_INFO("Enabling AMD device coherent memory");
-    }
-
-    // If the graphics queue family supports >= 2 queues, request a second one
-    // for parallel texture/buffer uploads.  Both queues share the same family
-    // so no queue-ownership-transfer barriers are needed.
-    const bool requestTransferQueue = (graphicsQueueFamilyQueueCount_ >= 2);
-
-    if (requestTransferQueue) {
-        // Build a custom queue description list: 2 queues from the graphics
-        // family, 1 queue from every other family (so present etc. still work).
-        auto families = vkbPhysicalDevice_.get_queue_families();
-        uint32_t gfxFamily = UINT32_MAX;
-        for (uint32_t i = 0; i < static_cast<uint32_t>(families.size()); i++) {
-            if (families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
-                gfxFamily = i;
-                break;
-            }
-        }
-
-        std::vector<vkb::CustomQueueDescription> queueDescs;
-        for (uint32_t i = 0; i < static_cast<uint32_t>(families.size()); i++) {
-            if (i == gfxFamily) {
-                // Request 2 queues: [0] graphics, [1] transfer uploads
-                queueDescs.emplace_back(i, std::vector<float>{1.0f, 1.0f});
-            } else {
-                queueDescs.emplace_back(i, std::vector<float>{1.0f});
-            }
-        }
-        deviceBuilder.custom_queue_setup(queueDescs);
-    }
-
     auto devRet = deviceBuilder.build();
     if (!devRet) {
         LOG_ERROR("Failed to create Vulkan logical device: ", devRet.error().message());
@@ -457,45 +211,22 @@ bool VkContext::createLogicalDevice() {
     auto vkbDevice = devRet.value();
     device = vkbDevice.device;
 
-    if (requestTransferQueue) {
-        // With custom_queue_setup, we must retrieve queues manually.
-        auto families = vkbPhysicalDevice_.get_queue_families();
-        uint32_t gfxFamily = UINT32_MAX;
-        for (uint32_t i = 0; i < static_cast<uint32_t>(families.size()); i++) {
-            if (families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
-                gfxFamily = i;
-                break;
-            }
-        }
-        graphicsQueueFamily = gfxFamily;
-        vkGetDeviceQueue(device, gfxFamily, 0, &graphicsQueue);
-        vkGetDeviceQueue(device, gfxFamily, 1, &transferQueue_);
-        hasDedicatedTransfer_ = true;
+    auto gqRet = vkbDevice.get_queue(vkb::QueueType::graphics);
+    if (!gqRet) {
+        LOG_ERROR("Failed to get graphics queue");
+        return false;
+    }
+    graphicsQueue = gqRet.value();
+    graphicsQueueFamily = vkbDevice.get_queue_index(vkb::QueueType::graphics).value();
 
-        // Present queue: try the graphics family first (most common), otherwise
-        // find a family that supports presentation.
+    auto pqRet = vkbDevice.get_queue(vkb::QueueType::present);
+    if (!pqRet) {
+        // Fall back to graphics queue for presentation
         presentQueue = graphicsQueue;
-        presentQueueFamily = gfxFamily;
-
-        LOG_INFO("Dedicated transfer queue enabled (family ", gfxFamily, ", queue index 1)");
+        presentQueueFamily = graphicsQueueFamily;
     } else {
-        // Standard path — let vkb resolve queues.
-        auto gqRet = vkbDevice.get_queue(vkb::QueueType::graphics);
-        if (!gqRet) {
-            LOG_ERROR("Failed to get graphics queue");
-            return false;
-        }
-        graphicsQueue = gqRet.value();
-        graphicsQueueFamily = vkbDevice.get_queue_index(vkb::QueueType::graphics).value();
-
-        auto pqRet = vkbDevice.get_queue(vkb::QueueType::present);
-        if (!pqRet) {
-            presentQueue = graphicsQueue;
-            presentQueueFamily = graphicsQueueFamily;
-        } else {
-            presentQueue = pqRet.value();
-            presentQueueFamily = vkbDevice.get_queue_index(vkb::QueueType::present).value();
-        }
+        presentQueue = pqRet.value();
+        presentQueueFamily = vkbDevice.get_queue_index(vkb::QueueType::present).value();
     }
 
     LOG_INFO("Vulkan logical device created");
@@ -507,7 +238,7 @@ bool VkContext::createAllocator() {
     allocInfo.instance = instance;
     allocInfo.physicalDevice = physicalDevice;
     allocInfo.device = device;
-    allocInfo.vulkanApiVersion = instanceApiVersion_;
+    allocInfo.vulkanApiVersion = VK_API_VERSION_1_1;
 
     if (vmaCreateAllocator(&allocInfo, &allocator) != VK_SUCCESS) {
         LOG_ERROR("Failed to create VMA allocator");
@@ -518,114 +249,6 @@ bool VkContext::createAllocator() {
     return true;
 }
 
-// ---------------------------------------------------------------------------
-// Pipeline cache persistence
-// ---------------------------------------------------------------------------
-
-static std::string getPipelineCachePath() {
-#ifdef _WIN32
-    if (const char* appdata = std::getenv("APPDATA"))
-        return std::string(appdata) + "\\wowee\\pipeline_cache.bin";
-    return ".\\pipeline_cache.bin";
-#elif defined(__APPLE__)
-    if (const char* home = std::getenv("HOME"))
-        return std::string(home) + "/Library/Caches/wowee/pipeline_cache.bin";
-    return "./pipeline_cache.bin";
-#else
-    if (const char* home = std::getenv("HOME"))
-        return std::string(home) + "/.local/share/wowee/pipeline_cache.bin";
-    return "./pipeline_cache.bin";
-#endif
-}
-
-bool VkContext::createPipelineCache() {
-    // NVIDIA drivers have their own built-in pipeline/shader disk cache.
-    // Using VkPipelineCache on NVIDIA 590.x causes vkCmdBeginRenderPass to
-    // SIGSEGV inside libnvidia-glcore — skip entirely on NVIDIA GPUs.
-    if (gpuVendorId_ == 0x10DE) {
-        LOG_INFO("Pipeline cache: skipped (NVIDIA driver provides built-in caching)");
-        return true;
-    }
-
-    std::string path = getPipelineCachePath();
-
-    // Try to load existing cache data from disk.
-    std::vector<char> cacheData;
-    {
-        std::ifstream file(path, std::ios::binary | std::ios::ate);
-        if (file.is_open()) {
-            auto size = file.tellg();
-            if (size > 0) {
-                cacheData.resize(static_cast<size_t>(size));
-                file.seekg(0);
-                file.read(cacheData.data(), size);
-                if (!file) {
-                    LOG_WARNING("Pipeline cache file read failed, starting with empty cache");
-                    cacheData.clear();
-                }
-            }
-        }
-    }
-
-    VkPipelineCacheCreateInfo cacheCI{};
-    cacheCI.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
-    cacheCI.initialDataSize = cacheData.size();
-    cacheCI.pInitialData = cacheData.empty() ? nullptr : cacheData.data();
-
-    VkResult result = vkCreatePipelineCache(device, &cacheCI, nullptr, &pipelineCache_);
-    if (result != VK_SUCCESS) {
-        // If loading stale/corrupt data caused failure, retry with empty cache.
-        if (!cacheData.empty()) {
-            LOG_WARNING("Pipeline cache creation failed with saved data, retrying empty");
-            cacheCI.initialDataSize = 0;
-            cacheCI.pInitialData = nullptr;
-            result = vkCreatePipelineCache(device, &cacheCI, nullptr, &pipelineCache_);
-        }
-        if (result != VK_SUCCESS) {
-            LOG_WARNING("Pipeline cache creation failed — pipelines will not be cached");
-            pipelineCache_ = VK_NULL_HANDLE;
-            return false;
-        }
-    }
-
-    if (!cacheData.empty()) {
-        LOG_INFO("Pipeline cache loaded from disk (", cacheData.size(), " bytes)");
-    } else {
-        LOG_INFO("Pipeline cache created (empty)");
-    }
-    return true;
-}
-
-void VkContext::savePipelineCache() {
-    if (!pipelineCache_ || !device) return;
-
-    size_t dataSize = 0;
-    if (vkGetPipelineCacheData(device, pipelineCache_, &dataSize, nullptr) != VK_SUCCESS || dataSize == 0) {
-        LOG_WARNING("Failed to query pipeline cache size");
-        return;
-    }
-
-    std::vector<char> data(dataSize);
-    if (vkGetPipelineCacheData(device, pipelineCache_, &dataSize, data.data()) != VK_SUCCESS) {
-        LOG_WARNING("Failed to retrieve pipeline cache data");
-        return;
-    }
-
-    std::string path = getPipelineCachePath();
-    std::filesystem::create_directories(std::filesystem::path(path).parent_path());
-
-    std::ofstream file(path, std::ios::binary | std::ios::trunc);
-    if (!file.is_open()) {
-        LOG_WARNING("Failed to open pipeline cache file for writing: ", path);
-        return;
-    }
-
-    file.write(data.data(), static_cast<std::streamsize>(dataSize));
-    file.close();
-
-    LOG_INFO("Pipeline cache saved to disk (", dataSize, " bytes)");
-}
-
 bool VkContext::createSwapchain(int width, int height) {
     vkb::SwapchainBuilder swapchainBuilder{physicalDevice, device, surface};
 
@@ -726,19 +349,6 @@ bool VkContext::createCommandPools() {
         return false;
     }
 
-    // Separate command pool for the transfer queue (same family, different queue)
-    if (hasDedicatedTransfer_) {
-        VkCommandPoolCreateInfo transferPoolInfo{};
-        transferPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
-        transferPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
-        transferPoolInfo.queueFamilyIndex = graphicsQueueFamily;
-
-        if (vkCreateCommandPool(device, &transferPoolInfo, nullptr, &transferCommandPool_) != VK_SUCCESS) {
-            LOG_ERROR("Failed to create transfer command pool");
-            return false;
-        }
-    }
-
     return true;
 }
 
@@ -751,32 +361,14 @@ bool VkContext::createSyncObjects() {
     fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT; // Start signaled so first frame doesn't block
 
     for (uint32_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
-        if (vkCreateFence(device, &fenceInfo, nullptr, &frames[i].inFlightFence) != VK_SUCCESS) {
+        if (vkCreateSemaphore(device, &semInfo, nullptr, &frames[i].imageAvailableSemaphore) != VK_SUCCESS ||
+            vkCreateSemaphore(device, &semInfo, nullptr, &frames[i].renderFinishedSemaphore) != VK_SUCCESS ||
+            vkCreateFence(device, &fenceInfo, nullptr, &frames[i].inFlightFence) != VK_SUCCESS) {
             LOG_ERROR("Failed to create sync objects for frame ", i);
             return false;
         }
     }
 
-    // Per-swapchain-image semaphores: avoids reuse while the presentation engine
-    // still holds a reference.  After acquiring image N we swap the acquire semaphore
-    // into imageAcquiredSemaphores_[N], recycling the old one for the next acquire.
-    const uint32_t imgCount = static_cast<uint32_t>(swapchainImages.size());
-    imageAcquiredSemaphores_.resize(imgCount);
-    renderFinishedSemaphores_.resize(imgCount);
-    for (uint32_t i = 0; i < imgCount; i++) {
-        if (vkCreateSemaphore(device, &semInfo, nullptr, &imageAcquiredSemaphores_[i]) != VK_SUCCESS ||
-            vkCreateSemaphore(device, &semInfo, nullptr, &renderFinishedSemaphores_[i]) != VK_SUCCESS) {
-            LOG_ERROR("Failed to create per-image semaphores for image ", i);
-            return false;
-        }
-    }
-    // One extra acquire semaphore — we need it for the next vkAcquireNextImageKHR
-    // before we know which image we'll get.
-    if (vkCreateSemaphore(device, &semInfo, nullptr, &nextAcquireSemaphore_) != VK_SUCCESS) {
-        LOG_ERROR("Failed to create next-acquire semaphore");
-        return false;
-    }
-
     // Immediate submit fence (not signaled initially)
     VkFenceCreateInfo immFenceInfo{};
     immFenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
@@ -833,20 +425,6 @@ void VkContext::destroyDepthBuffer() {
 bool VkContext::createMsaaColorImage() {
     if (msaaSamples_ == VK_SAMPLE_COUNT_1_BIT) return true; // No MSAA image needed
 
-    // Check if lazily allocated memory is available — only use TRANSIENT when it is.
-    // AMD GPUs (especially RDNA4) don't expose lazily allocated memory; using TRANSIENT
-    // without it can cause the driver to optimize for tile-only storage, leading to
-    // crashes during MSAA resolve when the backing memory was never populated.
-    bool hasLazyMemory = false;
-    VkPhysicalDeviceMemoryProperties memProps;
-    vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProps);
-    for (uint32_t i = 0; i < memProps.memoryTypeCount; i++) {
-        if (memProps.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) {
-            hasLazyMemory = true;
-            break;
-        }
-    }
-
     VkImageCreateInfo imgInfo{};
     imgInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
     imgInfo.imageType = VK_IMAGE_TYPE_2D;
@@ -856,16 +434,11 @@ bool VkContext::createMsaaColorImage() {
     imgInfo.arrayLayers = 1;
     imgInfo.samples = msaaSamples_;
     imgInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+    imgInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
 
     VmaAllocationCreateInfo allocInfo{};
     allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
-
-    if (hasLazyMemory) {
-        imgInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
-        allocInfo.preferredFlags = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
-    } else {
-        imgInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
-    }
+    allocInfo.preferredFlags = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
 
     if (vmaCreateImage(allocator, &imgInfo, &allocInfo, &msaaColorImage_, &msaaColorAllocation_, nullptr) != VK_SUCCESS) {
         // Retry without TRANSIENT (some drivers reject it at high sample counts)
@@ -1235,18 +808,15 @@ bool VkContext::createImGuiResources() {
         }
     }
 
-    // Create descriptor pool for ImGui.
-    // Budget: ~10 internal ImGui sets + up to 2000 UI icon textures (spells,
-    // items, talents, buffs, etc.) that are uploaded and cached for the session.
-    static constexpr uint32_t IMGUI_POOL_SIZE = 2048;
+    // Create descriptor pool for ImGui
     VkDescriptorPoolSize poolSizes[] = {
-        {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, IMGUI_POOL_SIZE},
+        {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 100},
     };
 
     VkDescriptorPoolCreateInfo dpInfo{};
     dpInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
     dpInfo.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
-    dpInfo.maxSets = IMGUI_POOL_SIZE;
+    dpInfo.maxSets = 100;
     dpInfo.poolSizeCount = 1;
     dpInfo.pPoolSizes = poolSizes;
 
@@ -1266,7 +836,10 @@ void VkContext::destroyImGuiResources() {
         if (tex.memory) vkFreeMemory(device, tex.memory, nullptr);
     }
     uiTextures_.clear();
-    uiTextureSampler_ = VK_NULL_HANDLE; // Owned by sampler cache
+    if (uiTextureSampler_) {
+        vkDestroySampler(device, uiTextureSampler_, nullptr);
+        uiTextureSampler_ = VK_NULL_HANDLE;
+    }
 
     if (imguiDescriptorPool) {
         vkDestroyDescriptorPool(device, imguiDescriptorPool, nullptr);
@@ -1289,8 +862,7 @@ static uint32_t findMemType(VkPhysicalDevice physDev, uint32_t typeFilter, VkMem
         if ((typeFilter & (1 << i)) && (memProps.memoryTypes[i].propertyFlags & props) == props)
             return i;
     }
-    LOG_ERROR("VkContext: no suitable memory type found");
-    return UINT32_MAX;
+    return 0;
 }
 
 VkDescriptorSet VkContext::uploadImGuiTexture(const uint8_t* rgba, int width, int height) {
@@ -1299,7 +871,7 @@ VkDescriptorSet VkContext::uploadImGuiTexture(const uint8_t* rgba, int width, in
 
     VkDeviceSize imageSize = static_cast<VkDeviceSize>(width) * height * 4;
 
-    // Create shared sampler on first call (via sampler cache)
+    // Create shared sampler on first call
     if (!uiTextureSampler_) {
         VkSamplerCreateInfo si{};
         si.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
@@ -1308,8 +880,7 @@ VkDescriptorSet VkContext::uploadImGuiTexture(const uint8_t* rgba, int width, in
         si.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
         si.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
         si.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-        uiTextureSampler_ = getOrCreateSampler(si);
-        if (!uiTextureSampler_) {
+        if (vkCreateSampler(device, &si, nullptr, &uiTextureSampler_) != VK_SUCCESS) {
             LOG_ERROR("Failed to create UI texture sampler");
             return VK_NULL_HANDLE;
         }
@@ -1435,18 +1006,10 @@ VkDescriptorSet VkContext::uploadImGuiTexture(const uint8_t* rgba, int width, in
         }
     }
 
-    // Register with ImGui (allocates from imguiDescriptorPool)
+    // Register with ImGui
     VkDescriptorSet ds = ImGui_ImplVulkan_AddTexture(uiTextureSampler_, imageView,
         VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
 
-    if (!ds) {
-        LOG_ERROR("ImGui descriptor pool exhausted — cannot upload UI texture");
-        vkDestroyImageView(device, imageView, nullptr);
-        vkDestroyImage(device, image, nullptr);
-        vkFreeMemory(device, imageMemory, nullptr);
-        return VK_NULL_HANDLE;
-    }
-
     // Track for cleanup
     uiTextures_.push_back({image, imageMemory, imageView});
 
@@ -1488,23 +1051,16 @@ bool VkContext::recreateSwapchain(int width, int height) {
 
     auto swapRet = builder.build();
 
-    if (!swapRet) {
-        // Destroy old swapchain now that we failed (it can't be used either)
-        if (oldSwapchain) {
-            vkDestroySwapchainKHR(device, oldSwapchain, nullptr);
-            swapchain = VK_NULL_HANDLE;
-        }
-        LOG_ERROR("Failed to recreate swapchain: ", swapRet.error().message());
-        // Keep swapchainDirty=true so the next frame retries
-        swapchainDirty = true;
-        return false;
-    }
-
-    // Success — safe to retire the old swapchain
     if (oldSwapchain) {
         vkDestroySwapchainKHR(device, oldSwapchain, nullptr);
     }
 
+    if (!swapRet) {
+        LOG_ERROR("Failed to recreate swapchain: ", swapRet.error().message());
+        swapchain = VK_NULL_HANDLE;
+        return false;
+    }
+
     auto vkbSwap = swapRet.value();
     swapchain = vkbSwap.swapchain;
     swapchainFormat = vkbSwap.image_format;
@@ -1512,26 +1068,6 @@ bool VkContext::recreateSwapchain(int width, int height) {
     swapchainImages = vkbSwap.get_images().value();
     swapchainImageViews = vkbSwap.get_image_views().value();
 
-    // Resize per-image semaphore arrays if the swapchain image count changed
-    {
-        const uint32_t newCount = static_cast<uint32_t>(swapchainImages.size());
-        const uint32_t oldCount = static_cast<uint32_t>(imageAcquiredSemaphores_.size());
-        VkSemaphoreCreateInfo semInfo{};
-        semInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
-        // Destroy excess semaphores if shrinking
-        for (uint32_t i = newCount; i < oldCount; i++) {
-            if (imageAcquiredSemaphores_[i]) vkDestroySemaphore(device, imageAcquiredSemaphores_[i], nullptr);
-            if (renderFinishedSemaphores_[i]) vkDestroySemaphore(device, renderFinishedSemaphores_[i], nullptr);
-        }
-        imageAcquiredSemaphores_.resize(newCount);
-        renderFinishedSemaphores_.resize(newCount);
-        // Create new semaphores if growing
-        for (uint32_t i = oldCount; i < newCount; i++) {
-            vkCreateSemaphore(device, &semInfo, nullptr, &imageAcquiredSemaphores_[i]);
-            vkCreateSemaphore(device, &semInfo, nullptr, &renderFinishedSemaphores_[i]);
-        }
-    }
-
     // Recreate depth buffer + MSAA color image + depth resolve image
     destroyMsaaColorImage();
     destroyDepthResolveImage();
@@ -1786,7 +1322,6 @@ bool VkContext::recreateSwapchain(int width, int height) {
 
 VkCommandBuffer VkContext::beginFrame(uint32_t& imageIndex) {
     if (deviceLost_) return VK_NULL_HANDLE;
-    if (swapchain == VK_NULL_HANDLE) return VK_NULL_HANDLE;  // Swapchain lost; recreate pending
 
     auto& frame = frames[currentFrame];
 
@@ -1799,21 +1334,16 @@ VkCommandBuffer VkContext::beginFrame(uint32_t& imageIndex) {
         return VK_NULL_HANDLE;
     }
     if (fenceResult != VK_SUCCESS) {
-        LOG_ERROR("beginFrame[", beginFrameCounter, "] fence wait failed: ", static_cast<int>(fenceResult));
+        LOG_ERROR("beginFrame[", beginFrameCounter, "] fence wait failed: ", (int)fenceResult);
         if (fenceResult == VK_ERROR_DEVICE_LOST) {
             deviceLost_ = true;
         }
         return VK_NULL_HANDLE;
     }
 
-    // Any work queued for this frame slot is now guaranteed to be unused by the GPU.
-    runDeferredCleanup(currentFrame);
-
-    // Acquire next swapchain image using the free semaphore.
-    // After acquiring we swap it into the per-image slot so the old per-image
-    // semaphore (now released by the presentation engine) becomes the free one.
+    // Acquire next swapchain image
     VkResult result = vkAcquireNextImageKHR(device, swapchain, UINT64_MAX,
-        nextAcquireSemaphore_, VK_NULL_HANDLE, &imageIndex);
+        frame.imageAvailableSemaphore, VK_NULL_HANDLE, &imageIndex);
 
     if (result == VK_ERROR_OUT_OF_DATE_KHR) {
         swapchainDirty = true;
@@ -1824,13 +1354,6 @@ VkCommandBuffer VkContext::beginFrame(uint32_t& imageIndex) {
         return VK_NULL_HANDLE;
     }
 
-    // Swap semaphores: the image's old acquire semaphore is now free (the presentation
-    // engine released it when this image was re-acquired).  The semaphore we just used
-    // becomes the per-image one for submit/present.
-    currentAcquireSemaphore_ = nextAcquireSemaphore_;
-    nextAcquireSemaphore_ = imageAcquiredSemaphores_[imageIndex];
-    imageAcquiredSemaphores_[imageIndex] = currentAcquireSemaphore_;
-
     vkResetFences(device, 1, &frame.inFlightFence);
     vkResetCommandBuffer(frame.commandBuffer, 0);
 
@@ -1840,22 +1363,6 @@ VkCommandBuffer VkContext::beginFrame(uint32_t& imageIndex) {
 
     vkBeginCommandBuffer(frame.commandBuffer, &beginInfo);
 
-    // If async upload batches are still in flight (submitted to the transfer queue),
-    // wait for their fences and insert a memory barrier so the graphics queue sees
-    // the completed layout transitions and transfer writes.
-    if (!inFlightBatches_.empty()) {
-        waitAllUploads();
-
-        VkMemoryBarrier memBarrier{};
-        memBarrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
-        memBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-        memBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-        vkCmdPipelineBarrier(frame.commandBuffer,
-            VK_PIPELINE_STAGE_TRANSFER_BIT,
-            VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-            0, 1, &memBarrier, 0, nullptr, 0, nullptr);
-    }
-
     return frame.commandBuffer;
 }
 
@@ -1865,31 +1372,26 @@ void VkContext::endFrame(VkCommandBuffer cmd, uint32_t imageIndex) {
 
     VkResult endResult = vkEndCommandBuffer(cmd);
     if (endResult != VK_SUCCESS) {
-        LOG_ERROR("endFrame[", endFrameCounter, "] vkEndCommandBuffer FAILED: ", static_cast<int>(endResult));
+        LOG_ERROR("endFrame[", endFrameCounter, "] vkEndCommandBuffer FAILED: ", (int)endResult);
     }
 
     auto& frame = frames[currentFrame];
 
     VkPipelineStageFlags waitStage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
 
-    // Use per-image semaphores: acquire semaphore was swapped into the per-image
-    // slot in beginFrame; renderFinished is also indexed by the acquired image.
-    VkSemaphore& acquireSem = imageAcquiredSemaphores_[imageIndex];
-    VkSemaphore& renderSem = renderFinishedSemaphores_[imageIndex];
-
     VkSubmitInfo submitInfo{};
     submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
     submitInfo.waitSemaphoreCount = 1;
-    submitInfo.pWaitSemaphores = &acquireSem;
+    submitInfo.pWaitSemaphores = &frame.imageAvailableSemaphore;
     submitInfo.pWaitDstStageMask = &waitStage;
     submitInfo.commandBufferCount = 1;
     submitInfo.pCommandBuffers = &cmd;
     submitInfo.signalSemaphoreCount = 1;
-    submitInfo.pSignalSemaphores = &renderSem;
+    submitInfo.pSignalSemaphores = &frame.renderFinishedSemaphore;
 
     VkResult submitResult = vkQueueSubmit(graphicsQueue, 1, &submitInfo, frame.inFlightFence);
     if (submitResult != VK_SUCCESS) {
-        LOG_ERROR("endFrame[", endFrameCounter, "] vkQueueSubmit FAILED: ", static_cast<int>(submitResult));
+        LOG_ERROR("endFrame[", endFrameCounter, "] vkQueueSubmit FAILED: ", (int)submitResult);
         if (submitResult == VK_ERROR_DEVICE_LOST) {
             deviceLost_ = true;
         }
@@ -1898,7 +1400,7 @@ void VkContext::endFrame(VkCommandBuffer cmd, uint32_t imageIndex) {
     VkPresentInfoKHR presentInfo{};
     presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
     presentInfo.waitSemaphoreCount = 1;
-    presentInfo.pWaitSemaphores = &renderSem;
+    presentInfo.pWaitSemaphores = &frame.renderFinishedSemaphore;
     presentInfo.swapchainCount = 1;
     presentInfo.pSwapchains = &swapchain;
     presentInfo.pImageIndices = &imageIndex;
@@ -1959,21 +1461,7 @@ void VkContext::beginUploadBatch() {
     uploadBatchDepth_++;
     if (inUploadBatch_) return; // already in a batch (nested call)
     inUploadBatch_ = true;
-
-    // Allocate from transfer pool if available, otherwise from immCommandPool.
-    VkCommandPool pool = hasDedicatedTransfer_ ? transferCommandPool_ : immCommandPool;
-
-    VkCommandBufferAllocateInfo allocInfo{};
-    allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
-    allocInfo.commandPool = pool;
-    allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
-    allocInfo.commandBufferCount = 1;
-    vkAllocateCommandBuffers(device, &allocInfo, &batchCmd_);
-
-    VkCommandBufferBeginInfo beginInfo{};
-    beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
-    beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
-    vkBeginCommandBuffer(batchCmd_, &beginInfo);
+    batchCmd_ = beginSingleTimeCommands();
 }
 
 void VkContext::endUploadBatch() {
@@ -1983,12 +1471,10 @@ void VkContext::endUploadBatch() {
 
     inUploadBatch_ = false;
 
-    VkCommandPool pool = hasDedicatedTransfer_ ? transferCommandPool_ : immCommandPool;
-
     if (batchStagingBuffers_.empty()) {
         // No GPU copies were recorded — skip the submit entirely.
         vkEndCommandBuffer(batchCmd_);
-        vkFreeCommandBuffers(device, pool, 1, &batchCmd_);
+        vkFreeCommandBuffers(device, immCommandPool, 1, &batchCmd_);
         batchCmd_ = VK_NULL_HANDLE;
         return;
     }
@@ -2005,10 +1491,7 @@ void VkContext::endUploadBatch() {
     submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
     submitInfo.commandBufferCount = 1;
     submitInfo.pCommandBuffers = &batchCmd_;
-
-    // Submit to the dedicated transfer queue if available, otherwise graphics.
-    VkQueue targetQueue = hasDedicatedTransfer_ ? transferQueue_ : graphicsQueue;
-    vkQueueSubmit(targetQueue, 1, &submitInfo, fence);
+    vkQueueSubmit(graphicsQueue, 1, &submitInfo, fence);
 
     // Stash everything for later cleanup when fence signals
     InFlightBatch batch;
@@ -2028,30 +1511,15 @@ void VkContext::endUploadBatchSync() {
 
     inUploadBatch_ = false;
 
-    VkCommandPool pool = hasDedicatedTransfer_ ? transferCommandPool_ : immCommandPool;
-
     if (batchStagingBuffers_.empty()) {
         vkEndCommandBuffer(batchCmd_);
-        vkFreeCommandBuffers(device, pool, 1, &batchCmd_);
+        vkFreeCommandBuffers(device, immCommandPool, 1, &batchCmd_);
         batchCmd_ = VK_NULL_HANDLE;
         return;
     }
 
-    // Synchronous path for load screens — submit and wait on the target queue.
-    VkQueue targetQueue = hasDedicatedTransfer_ ? transferQueue_ : graphicsQueue;
-
-    vkEndCommandBuffer(batchCmd_);
-
-    VkSubmitInfo submitInfo{};
-    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
-    submitInfo.commandBufferCount = 1;
-    submitInfo.pCommandBuffers = &batchCmd_;
-
-    vkQueueSubmit(targetQueue, 1, &submitInfo, immFence);
-    vkWaitForFences(device, 1, &immFence, VK_TRUE, UINT64_MAX);
-    vkResetFences(device, 1, &immFence);
-
-    vkFreeCommandBuffers(device, pool, 1, &batchCmd_);
+    // Synchronous path for load screens — submit and wait
+    endSingleTimeCommands(batchCmd_);
     batchCmd_ = VK_NULL_HANDLE;
 
     for (auto& staging : batchStagingBuffers_) {
@@ -2063,8 +1531,6 @@ void VkContext::endUploadBatchSync() {
 void VkContext::pollUploadBatches() {
     if (inFlightBatches_.empty()) return;
 
-    VkCommandPool pool = hasDedicatedTransfer_ ? transferCommandPool_ : immCommandPool;
-
     for (auto it = inFlightBatches_.begin(); it != inFlightBatches_.end(); ) {
         VkResult result = vkGetFenceStatus(device, it->fence);
         if (result == VK_SUCCESS) {
@@ -2072,7 +1538,7 @@ void VkContext::pollUploadBatches() {
             for (auto& staging : it->stagingBuffers) {
                 destroyBuffer(allocator, staging);
             }
-            vkFreeCommandBuffers(device, pool, 1, &it->cmd);
+            vkFreeCommandBuffers(device, immCommandPool, 1, &it->cmd);
             vkDestroyFence(device, it->fence, nullptr);
             it = inFlightBatches_.erase(it);
         } else {
@@ -2082,14 +1548,12 @@ void VkContext::pollUploadBatches() {
 }
 
 void VkContext::waitAllUploads() {
-    VkCommandPool pool = hasDedicatedTransfer_ ? transferCommandPool_ : immCommandPool;
-
     for (auto& batch : inFlightBatches_) {
         vkWaitForFences(device, 1, &batch.fence, VK_TRUE, UINT64_MAX);
         for (auto& staging : batch.stagingBuffers) {
             destroyBuffer(allocator, staging);
         }
-        vkFreeCommandBuffers(device, pool, 1, &batch.cmd);
+        vkFreeCommandBuffers(device, immCommandPool, 1, &batch.cmd);
         vkDestroyFence(device, batch.fence, nullptr);
     }
     inFlightBatches_.clear();
diff --git a/src/rendering/vk_pipeline.cpp b/src/rendering/vk_pipeline.cpp
index e5c32e6c..4e565b07 100644
--- a/src/rendering/vk_pipeline.cpp
+++ b/src/rendering/vk_pipeline.cpp
@@ -111,18 +111,7 @@ PipelineBuilder& PipelineBuilder::setDynamicStates(const std::vector<VkDynamicSt
     return *this;
 }
 
-// Pipeline derivatives — hint driver to share compiled state between similar pipelines
-PipelineBuilder& PipelineBuilder::setFlags(VkPipelineCreateFlags flags) {
-    flags_ = flags;
-    return *this;
-}
-
-PipelineBuilder& PipelineBuilder::setBasePipeline(VkPipeline basePipeline) {
-    basePipelineHandle_ = basePipeline;
-    return *this;
-}
-
-VkPipeline PipelineBuilder::build(VkDevice device, VkPipelineCache cache) const {
+VkPipeline PipelineBuilder::build(VkDevice device) const {
     // Vertex input
     VkPipelineVertexInputStateCreateInfo vertexInput{};
     vertexInput.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
@@ -199,14 +188,11 @@ VkPipeline PipelineBuilder::build(VkDevice device, VkPipelineCache cache) const
     pipelineInfo.pColorBlendState = colorBlendAttachments_.empty() ? nullptr : &colorBlending;
     pipelineInfo.pDynamicState = dynamicStates_.empty() ? nullptr : &dynamicState;
     pipelineInfo.layout = pipelineLayout_;
-    pipelineInfo.flags = flags_;
-    pipelineInfo.basePipelineHandle = basePipelineHandle_;
-    pipelineInfo.basePipelineIndex = -1;
     pipelineInfo.renderPass = renderPass_;
     pipelineInfo.subpass = subpass_;
 
     VkPipeline pipeline = VK_NULL_HANDLE;
-    if (vkCreateGraphicsPipelines(device, cache, 1, &pipelineInfo,
+    if (vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo,
             nullptr, &pipeline) != VK_SUCCESS)
     {
         LOG_ERROR("Failed to create graphics pipeline");
@@ -216,22 +202,18 @@ VkPipeline PipelineBuilder::build(VkDevice device, VkPipelineCache cache) const
     return pipeline;
 }
 
-// All RGBA channels enabled — used by every blend mode since we never need to
-// mask individual channels (WoW's fixed-function pipeline always writes all four).
-static constexpr VkColorComponentFlags kColorWriteAll =
-    VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
-    VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
-
 VkPipelineColorBlendAttachmentState PipelineBuilder::blendDisabled() {
     VkPipelineColorBlendAttachmentState state{};
-    state.colorWriteMask = kColorWriteAll;
+    state.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
+        VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
     state.blendEnable = VK_FALSE;
     return state;
 }
 
 VkPipelineColorBlendAttachmentState PipelineBuilder::blendAlpha() {
     VkPipelineColorBlendAttachmentState state{};
-    state.colorWriteMask = kColorWriteAll;
+    state.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
+        VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
     state.blendEnable = VK_TRUE;
     state.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
     state.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
@@ -244,7 +226,8 @@ VkPipelineColorBlendAttachmentState PipelineBuilder::blendAlpha() {
 
 VkPipelineColorBlendAttachmentState PipelineBuilder::blendPremultiplied() {
     VkPipelineColorBlendAttachmentState state{};
-    state.colorWriteMask = kColorWriteAll;
+    state.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
+        VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
     state.blendEnable = VK_TRUE;
     state.srcColorBlendFactor = VK_BLEND_FACTOR_ONE;
     state.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
@@ -257,7 +240,8 @@ VkPipelineColorBlendAttachmentState PipelineBuilder::blendPremultiplied() {
 
 VkPipelineColorBlendAttachmentState PipelineBuilder::blendAdditive() {
     VkPipelineColorBlendAttachmentState state{};
-    state.colorWriteMask = kColorWriteAll;
+    state.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
+        VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
     state.blendEnable = VK_TRUE;
     state.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
     state.dstColorBlendFactor = VK_BLEND_FACTOR_ONE;
diff --git a/src/rendering/vk_render_target.cpp b/src/rendering/vk_render_target.cpp
index 4692d45f..f2099bbf 100644
--- a/src/rendering/vk_render_target.cpp
+++ b/src/rendering/vk_render_target.cpp
@@ -49,7 +49,7 @@ bool VkRenderTarget::create(VkContext& ctx, uint32_t width, uint32_t height,
         }
     }
 
-    // Create sampler (linear filtering, clamp to edge) via cache
+    // Create sampler (linear filtering, clamp to edge)
     VkSamplerCreateInfo samplerInfo{};
     samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
     samplerInfo.minFilter = VK_FILTER_LINEAR;
@@ -61,13 +61,11 @@ bool VkRenderTarget::create(VkContext& ctx, uint32_t width, uint32_t height,
     samplerInfo.minLod = 0.0f;
     samplerInfo.maxLod = 0.0f;
 
-    sampler_ = ctx.getOrCreateSampler(samplerInfo);
-    if (sampler_ == VK_NULL_HANDLE) {
+    if (vkCreateSampler(device, &samplerInfo, nullptr, &sampler_) != VK_SUCCESS) {
         LOG_ERROR("VkRenderTarget: failed to create sampler");
         destroy(device, allocator);
         return false;
     }
-    ownsSampler_ = false;
 
     // Create render pass
     if (useMSAA) {
@@ -261,11 +259,10 @@ void VkRenderTarget::destroy(VkDevice device, VmaAllocator allocator) {
         vkDestroyRenderPass(device, renderPass_, nullptr);
         renderPass_ = VK_NULL_HANDLE;
     }
-    if (sampler_ && ownsSampler_) {
+    if (sampler_) {
         vkDestroySampler(device, sampler_, nullptr);
+        sampler_ = VK_NULL_HANDLE;
     }
-    sampler_ = VK_NULL_HANDLE;
-    ownsSampler_ = true;
     destroyImage(device, allocator, resolveImage_);
     destroyImage(device, allocator, depthImage_);
     destroyImage(device, allocator, colorImage_);
diff --git a/src/rendering/vk_shader.cpp b/src/rendering/vk_shader.cpp
index e20a2dc0..5ebc7a08 100644
--- a/src/rendering/vk_shader.cpp
+++ b/src/rendering/vk_shader.cpp
@@ -32,7 +32,6 @@ bool VkShaderModule::loadFromFile(VkDevice device, const std::string& path) {
     }
 
     size_t fileSize = static_cast<size_t>(file.tellg());
-    // SPIR-V is a stream of 32-bit words — file size must be a multiple of 4
     if (fileSize == 0 || fileSize % 4 != 0) {
         LOG_ERROR("Invalid SPIR-V file size (", fileSize, "): ", path);
         return false;
diff --git a/src/rendering/vk_texture.cpp b/src/rendering/vk_texture.cpp
index c11b5921..415e3d56 100644
--- a/src/rendering/vk_texture.cpp
+++ b/src/rendering/vk_texture.cpp
@@ -13,12 +13,9 @@ VkTexture::~VkTexture() {
 }
 
 VkTexture::VkTexture(VkTexture&& other) noexcept
-    : image_(other.image_), sampler_(other.sampler_), mipLevels_(other.mipLevels_),
-      ownsSampler_(other.ownsSampler_) {
+    : image_(other.image_), sampler_(other.sampler_), mipLevels_(other.mipLevels_) {
     other.image_ = {};
     other.sampler_ = VK_NULL_HANDLE;
-    // Source no longer owns the sampler — ownership transferred to this instance
-    other.ownsSampler_ = false;
 }
 
 VkTexture& VkTexture::operator=(VkTexture&& other) noexcept {
@@ -26,10 +23,8 @@ VkTexture& VkTexture::operator=(VkTexture&& other) noexcept {
         image_ = other.image_;
         sampler_ = other.sampler_;
         mipLevels_ = other.mipLevels_;
-        ownsSampler_ = other.ownsSampler_;
         other.image_ = {};
         other.sampler_ = VK_NULL_HANDLE;
-        other.ownsSampler_ = false;
     }
     return *this;
 }
@@ -197,23 +192,6 @@ bool VkTexture::createDepth(VkContext& ctx, uint32_t width, uint32_t height, VkF
     return true;
 }
 
-// Shared sampler finalization: try the global cache first (avoids duplicate Vulkan
-// sampler objects), fall back to direct creation if no VkContext is available.
-bool VkTexture::finalizeSampler(VkDevice device, const VkSamplerCreateInfo& samplerInfo) {
-    auto* ctx = VkContext::globalInstance();
-    if (ctx) {
-        sampler_ = ctx->getOrCreateSampler(samplerInfo);
-        ownsSampler_ = false;
-        return sampler_ != VK_NULL_HANDLE;
-    }
-    if (vkCreateSampler(device, &samplerInfo, nullptr, &sampler_) != VK_SUCCESS) {
-        LOG_ERROR("Failed to create texture sampler");
-        return false;
-    }
-    ownsSampler_ = true;
-    return true;
-}
-
 bool VkTexture::createSampler(VkDevice device,
     VkFilter minFilter, VkFilter magFilter,
     VkSamplerAddressMode addressMode, float maxAnisotropy)
@@ -235,7 +213,13 @@ bool VkTexture::createSampler(VkDevice device,
     samplerInfo.mipLodBias = 0.0f;
     samplerInfo.minLod = 0.0f;
     samplerInfo.maxLod = static_cast<float>(mipLevels_);
-    return finalizeSampler(device, samplerInfo);
+
+    if (vkCreateSampler(device, &samplerInfo, nullptr, &sampler_) != VK_SUCCESS) {
+        LOG_ERROR("Failed to create texture sampler");
+        return false;
+    }
+
+    return true;
 }
 
 bool VkTexture::createSampler(VkDevice device,
@@ -261,7 +245,13 @@ bool VkTexture::createSampler(VkDevice device,
     samplerInfo.mipLodBias = 0.0f;
     samplerInfo.minLod = 0.0f;
     samplerInfo.maxLod = static_cast<float>(mipLevels_);
-    return finalizeSampler(device, samplerInfo);
+
+    if (vkCreateSampler(device, &samplerInfo, nullptr, &sampler_) != VK_SUCCESS) {
+        LOG_ERROR("Failed to create texture sampler");
+        return false;
+    }
+
+    return true;
 }
 
 bool VkTexture::createShadowSampler(VkDevice device) {
@@ -278,15 +268,20 @@ bool VkTexture::createShadowSampler(VkDevice device) {
     samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
     samplerInfo.minLod = 0.0f;
     samplerInfo.maxLod = 1.0f;
-    return finalizeSampler(device, samplerInfo);
+
+    if (vkCreateSampler(device, &samplerInfo, nullptr, &sampler_) != VK_SUCCESS) {
+        LOG_ERROR("Failed to create shadow sampler");
+        return false;
+    }
+
+    return true;
 }
 
 void VkTexture::destroy(VkDevice device, VmaAllocator allocator) {
-    if (sampler_ != VK_NULL_HANDLE && ownsSampler_) {
+    if (sampler_ != VK_NULL_HANDLE) {
         vkDestroySampler(device, sampler_, nullptr);
+        sampler_ = VK_NULL_HANDLE;
     }
-    sampler_ = VK_NULL_HANDLE;
-    ownsSampler_ = false;
     destroyImage(device, allocator, image_);
 }
 
diff --git a/src/rendering/water_renderer.cpp b/src/rendering/water_renderer.cpp
index 4870e16d..d79e53f7 100644
--- a/src/rendering/water_renderer.cpp
+++ b/src/rendering/water_renderer.cpp
@@ -5,7 +5,6 @@
 #include "rendering/vk_utils.hpp"
 #include "rendering/vk_frame_data.hpp"
 #include "rendering/camera.hpp"
-#include "rendering/frustum.hpp"
 #include "pipeline/adt_loader.hpp"
 #include "pipeline/wmo_loader.hpp"
 #include "core/logger.hpp"
@@ -194,7 +193,7 @@ bool WaterRenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLay
         .setLayout(pipelineLayout)
         .setRenderPass(mainPass)
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     vertShader.destroy();
     fragShader.destroy();
@@ -258,7 +257,7 @@ void WaterRenderer::recreatePipelines() {
         .setLayout(pipelineLayout)
         .setRenderPass(mainPass)
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     vertShader.destroy();
     fragShader.destroy();
@@ -353,8 +352,8 @@ void WaterRenderer::destroySceneHistoryResources() {
         if (sh.depthImage) { vmaDestroyImage(vkCtx->getAllocator(), sh.depthImage, sh.depthAlloc); sh.depthImage = VK_NULL_HANDLE; sh.depthAlloc = VK_NULL_HANDLE; }
         sh.sceneSet = VK_NULL_HANDLE;
     }
-    sceneColorSampler = VK_NULL_HANDLE; // Owned by VkContext sampler cache
-    sceneDepthSampler = VK_NULL_HANDLE; // Owned by VkContext sampler cache
+    if (sceneColorSampler) { vkDestroySampler(device, sceneColorSampler, nullptr); sceneColorSampler = VK_NULL_HANDLE; }
+    if (sceneDepthSampler) { vkDestroySampler(device, sceneDepthSampler, nullptr); sceneDepthSampler = VK_NULL_HANDLE; }
     sceneHistoryExtent = {0, 0};
     sceneHistoryReady = false;
 }
@@ -375,15 +374,13 @@ void WaterRenderer::createSceneHistoryResources(VkExtent2D extent, VkFormat colo
     sampCI.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
     sampCI.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
     sampCI.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-    sceneColorSampler = vkCtx->getOrCreateSampler(sampCI);
-    if (sceneColorSampler == VK_NULL_HANDLE) {
+    if (vkCreateSampler(device, &sampCI, nullptr, &sceneColorSampler) != VK_SUCCESS) {
         LOG_ERROR("WaterRenderer: failed to create scene color sampler");
         return;
     }
     sampCI.magFilter = VK_FILTER_NEAREST;
     sampCI.minFilter = VK_FILTER_NEAREST;
-    sceneDepthSampler = vkCtx->getOrCreateSampler(sampCI);
-    if (sceneDepthSampler == VK_NULL_HANDLE) {
+    if (vkCreateSampler(device, &sampCI, nullptr, &sceneDepthSampler) != VK_SUCCESS) {
         LOG_ERROR("WaterRenderer: failed to create scene depth sampler");
         return;
     }
@@ -923,8 +920,7 @@ void WaterRenderer::loadFromWMO([[maybe_unused]] const pipeline::WMOLiquid& liqu
     float stepXLen = glm::length(surface.stepX);
     float stepYLen = glm::length(surface.stepY);
     glm::vec3 planeN = glm::cross(surface.stepX, surface.stepY);
-    float planeNLenSq = glm::dot(planeN, planeN);
-    float nz = (planeNLenSq > 1e-8f) ? std::abs(planeN.z * glm::inversesqrt(planeNLenSq)) : 0.0f;
+    float nz = (glm::length(planeN) > 1e-4f) ? std::abs(glm::normalize(planeN).z) : 0.0f;
     float spanX = stepXLen * static_cast<float>(surface.width);
     float spanY = stepYLen * static_cast<float>(surface.height);
     if (stepXLen < 0.2f || stepXLen > 12.0f ||
@@ -1004,7 +1000,7 @@ void WaterRenderer::loadFromWMO([[maybe_unused]] const pipeline::WMOLiquid& liqu
         }
     }
     LOG_DEBUG("WMO water: origin=(", surface.origin.x, ",", surface.origin.y, ",", surface.origin.z,
-             ") tiles=", static_cast<int>(surface.width), "x", static_cast<int>(surface.height),
+             ") tiles=", (int)surface.width, "x", (int)surface.height,
              " active=", activeTiles, "/", tileCount,
              " wmoId=", wmoId, " indexCount=", surface.indexCount,
              " bounds x=[", minWX, "..", maxWX, "] y=[", minWY, "..", maxWY, "]");
@@ -1033,6 +1029,10 @@ void WaterRenderer::clear() {
         destroyWaterMesh(surface);
     }
     surfaces.clear();
+
+    if (vkCtx && materialDescPool) {
+        vkResetDescriptorPool(vkCtx->getDevice(), materialDescPool, 0);
+    }
 }
 
 // ==============================================================
@@ -1040,7 +1040,7 @@ void WaterRenderer::clear() {
 // ==============================================================
 
 void WaterRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet,
-                            const Camera& camera, float /*time*/, bool use1x, uint32_t frameIndex) {
+                            const Camera& /*camera*/, float /*time*/, bool use1x, uint32_t frameIndex) {
     VkPipeline pipeline = (use1x && water1xPipeline) ? water1xPipeline : waterPipeline;
     if (!renderingEnabled || surfaces.empty() || !pipeline) {
         if (renderDiagCounter_++ % 300 == 0 && !surfaces.empty()) {
@@ -1060,10 +1060,6 @@ void WaterRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet,
         return;
     }
 
-    // Frustum culling setup
-    Frustum frustum;
-    frustum.extractFromMatrix(camera.getViewProjectionMatrix());
-
     vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
 
     vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout,
@@ -1075,27 +1071,6 @@ void WaterRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet,
         if (surface.vertexBuffer == VK_NULL_HANDLE || surface.indexCount == 0) continue;
         if (!surface.materialSet) continue;
 
-        // Frustum cull: compute AABB from surface origin + step vectors
-        {
-            const glm::vec3 extentX = surface.stepX * static_cast<float>(surface.width);
-            const glm::vec3 extentY = surface.stepY * static_cast<float>(surface.height);
-            const glm::vec3 c0 = surface.origin;
-            const glm::vec3 c1 = surface.origin + extentX;
-            const glm::vec3 c2 = surface.origin + extentY;
-            const glm::vec3 c3 = surface.origin + extentX + extentY;
-            const glm::vec3 aabbMin(
-                std::min({c0.x, c1.x, c2.x, c3.x}),
-                std::min({c0.y, c1.y, c2.y, c3.y}),
-                surface.minHeight
-            );
-            const glm::vec3 aabbMax(
-                std::max({c0.x, c1.x, c2.x, c3.x}),
-                std::max({c0.y, c1.y, c2.y, c3.y}),
-                surface.maxHeight
-            );
-            if (!frustum.intersectsAABB(aabbMin, aabbMax)) continue;
-        }
-
         bool isWmoWater = (surface.wmoId != 0);
         bool canalProfile = isWmoWater || (surface.liquidType == 5);
         uint8_t basicType = (surface.liquidType == 0) ? 0 : ((surface.liquidType - 1) % 4);
@@ -1171,14 +1146,10 @@ void WaterRenderer::captureSceneHistory(VkCommandBuffer cmd,
     };
 
     // Color source: final render pass layout is PRESENT_SRC.
-    // srcAccessMask must be COLOR_ATTACHMENT_WRITE (not 0) so that GPU cache flushes
-    // happen before the transfer read.  Using srcAccessMask=0 with BOTTOM_OF_PIPE
-    // causes VK_ERROR_DEVICE_LOST on strict drivers (AMD/Mali) because color writes
-    // are not made visible to the transfer unit before the copy begins.
     barrier2(srcColorImage, VK_IMAGE_ASPECT_COLOR_BIT,
              VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-             VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
-             VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
+             0, VK_ACCESS_TRANSFER_READ_BIT,
+             VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
     barrier2(sh.colorImage, VK_IMAGE_ASPECT_COLOR_BIT,
              VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
              VK_ACCESS_SHADER_READ_BIT, VK_ACCESS_TRANSFER_WRITE_BIT,
@@ -1295,36 +1266,38 @@ void WaterRenderer::createWaterMesh(WaterSurface& surface) {
                         renderTile = lsbOrder || msbOrder;
                     }
 
-                    // Render masked-out tiles if any adjacent neighbor is visible,
-                    // to avoid seam gaps at water surface edges.
                     if (!renderTile) {
-                        renderTile = [&]() {
-                            for (int dy = -1; dy <= 1; dy++) {
-                                for (int dx = -1; dx <= 1; dx++) {
-                                    if (dx == 0 && dy == 0) continue;
-                                    int nx = x + dx, ny = y + dy;
-                                    if (nx < 0 || ny < 0 || nx >= gridWidth-1 || ny >= gridHeight-1) continue;
-                                    int neighborIdx;
-                                    if (surface.wmoId == 0 && surface.width <= 8 && surface.mask.size() >= 8) {
-                                        neighborIdx = (static_cast<int>(surface.yOffset) + ny) * 8 +
-                                                      (static_cast<int>(surface.xOffset) + nx);
+                        for (int dy = -1; dy <= 1; dy++) {
+                            for (int dx = -1; dx <= 1; dx++) {
+                                if (dx == 0 && dy == 0) continue;
+                                int nx = x + dx, ny = y + dy;
+                                if (nx < 0 || ny < 0 || nx >= gridWidth-1 || ny >= gridHeight-1) continue;
+                                int neighborIdx;
+                                if (surface.wmoId == 0 && surface.width <= 8 && surface.mask.size() >= 8) {
+                                    neighborIdx = (static_cast<int>(surface.yOffset) + ny) * 8 +
+                                                  (static_cast<int>(surface.xOffset) + nx);
+                                } else {
+                                    neighborIdx = ny * surface.width + nx;
+                                }
+                                int nByteIdx = neighborIdx / 8;
+                                int nBitIdx = neighborIdx % 8;
+                                if (nByteIdx < static_cast<int>(surface.mask.size())) {
+                                    uint8_t nMask = surface.mask[nByteIdx];
+                                    if (isMergedTerrain) {
+                                        if (nMask & (1 << nBitIdx)) {
+                                            renderTile = true;
+                                            goto found_neighbor;
+                                        }
                                     } else {
-                                        neighborIdx = ny * surface.width + nx;
-                                    }
-                                    int nByteIdx = neighborIdx / 8;
-                                    int nBitIdx = neighborIdx % 8;
-                                    if (nByteIdx < static_cast<int>(surface.mask.size())) {
-                                        uint8_t nMask = surface.mask[nByteIdx];
-                                        if (isMergedTerrain) {
-                                            if (nMask & (1 << nBitIdx)) return true;
-                                        } else {
-                                            if ((nMask & (1 << nBitIdx)) || (nMask & (1 << (7 - nBitIdx)))) return true;
+                                        if ((nMask & (1 << nBitIdx)) || (nMask & (1 << (7 - nBitIdx)))) {
+                                            renderTile = true;
+                                            goto found_neighbor;
                                         }
                                     }
                                 }
                             }
-                            return false;
-                        }();
+                        }
+                        found_neighbor:;
                     }
                 }
             }
@@ -1385,45 +1358,27 @@ void WaterRenderer::createWaterMesh(WaterSurface& surface) {
 
 void WaterRenderer::destroyWaterMesh(WaterSurface& surface) {
     if (!vkCtx) return;
-    VkDevice device = vkCtx->getDevice();
     VmaAllocator allocator = vkCtx->getAllocator();
 
-    ::VkBuffer vertexBuffer = surface.vertexBuffer;
-    VmaAllocation vertexAlloc = surface.vertexAlloc;
-    ::VkBuffer indexBuffer = surface.indexBuffer;
-    VmaAllocation indexAlloc = surface.indexAlloc;
-    ::VkBuffer materialUBO = surface.materialUBO;
-    VmaAllocation materialAlloc = surface.materialAlloc;
-    VkDescriptorPool pool = materialDescPool;
-    VkDescriptorSet materialSet = surface.materialSet;
-
-    surface.vertexBuffer = VK_NULL_HANDLE;
-    surface.vertexAlloc = VK_NULL_HANDLE;
-    surface.indexBuffer = VK_NULL_HANDLE;
-    surface.indexAlloc = VK_NULL_HANDLE;
-    surface.materialUBO = VK_NULL_HANDLE;
-    surface.materialAlloc = VK_NULL_HANDLE;
+    if (surface.vertexBuffer) {
+        AllocatedBuffer ab{}; ab.buffer = surface.vertexBuffer; ab.allocation = surface.vertexAlloc;
+        destroyBuffer(allocator, ab);
+        surface.vertexBuffer = VK_NULL_HANDLE;
+    }
+    if (surface.indexBuffer) {
+        AllocatedBuffer ab{}; ab.buffer = surface.indexBuffer; ab.allocation = surface.indexAlloc;
+        destroyBuffer(allocator, ab);
+        surface.indexBuffer = VK_NULL_HANDLE;
+    }
+    if (surface.materialUBO) {
+        AllocatedBuffer ab{}; ab.buffer = surface.materialUBO; ab.allocation = surface.materialAlloc;
+        destroyBuffer(allocator, ab);
+        surface.materialUBO = VK_NULL_HANDLE;
+    }
+    if (surface.materialSet && materialDescPool) {
+        vkFreeDescriptorSets(vkCtx->getDevice(), materialDescPool, 1, &surface.materialSet);
+    }
     surface.materialSet = VK_NULL_HANDLE;
-
-    vkCtx->deferAfterAllFrameFences([device, allocator, vertexBuffer, vertexAlloc, indexBuffer, indexAlloc,
-                                     materialUBO, materialAlloc, pool, materialSet]() {
-        if (vertexBuffer) {
-            AllocatedBuffer ab{}; ab.buffer = vertexBuffer; ab.allocation = vertexAlloc;
-            destroyBuffer(allocator, ab);
-        }
-        if (indexBuffer) {
-            AllocatedBuffer ab{}; ab.buffer = indexBuffer; ab.allocation = indexAlloc;
-            destroyBuffer(allocator, ab);
-        }
-        if (materialUBO) {
-            AllocatedBuffer ab{}; ab.buffer = materialUBO; ab.allocation = materialAlloc;
-            destroyBuffer(allocator, ab);
-        }
-        if (materialSet && pool) {
-            VkDescriptorSet set = materialSet;
-            vkFreeDescriptorSets(device, pool, 1, &set);
-        }
-    });
 }
 
 // ==============================================================
@@ -1745,8 +1700,7 @@ void WaterRenderer::createReflectionResources() {
     sampCI.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
     sampCI.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
     sampCI.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-    reflectionSampler = vkCtx->getOrCreateSampler(sampCI);
-    if (reflectionSampler == VK_NULL_HANDLE) {
+    if (vkCreateSampler(device, &sampCI, nullptr, &reflectionSampler) != VK_SUCCESS) {
         LOG_ERROR("WaterRenderer: failed to create reflection sampler");
         return;
     }
@@ -1784,7 +1738,7 @@ void WaterRenderer::createReflectionResources() {
     VkSubpassDependency dep{};
     dep.srcSubpass = VK_SUBPASS_EXTERNAL;
     dep.dstSubpass = 0;
-    dep.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
+    dep.srcStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
     dep.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
     dep.srcAccessMask = 0;
     dep.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
@@ -1876,7 +1830,7 @@ void WaterRenderer::destroyReflectionResources() {
     if (reflectionDepthView) { vkDestroyImageView(device, reflectionDepthView, nullptr); reflectionDepthView = VK_NULL_HANDLE; }
     if (reflectionColorImage) { vmaDestroyImage(allocator, reflectionColorImage, reflectionColorAlloc); reflectionColorImage = VK_NULL_HANDLE; }
     if (reflectionDepthImage) { vmaDestroyImage(allocator, reflectionDepthImage, reflectionDepthAlloc); reflectionDepthImage = VK_NULL_HANDLE; }
-    reflectionSampler = VK_NULL_HANDLE; // Owned by VkContext sampler cache
+    if (reflectionSampler) { vkDestroySampler(device, reflectionSampler, nullptr); reflectionSampler = VK_NULL_HANDLE; }
     if (reflectionUBO) {
         AllocatedBuffer ab{}; ab.buffer = reflectionUBO; ab.allocation = reflectionUBOAlloc;
         destroyBuffer(allocator, ab);
@@ -1920,25 +1874,27 @@ void WaterRenderer::endReflectionPass(VkCommandBuffer cmd) {
     vkCmdEndRenderPass(cmd);
     reflectionColorLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 
-    // Update only the current frame's scene descriptor set with the reflection texture.
-    // Updating all frames would race with in-flight command buffers that have the
-    // other frame's descriptor set bound.
-    if (reflectionColorView && reflectionSampler && vkCtx) {
-        uint32_t fi = vkCtx->getCurrentFrame() % SCENE_HISTORY_FRAMES;
-        if (sceneHistory[fi].sceneSet) {
-            VkDescriptorImageInfo reflInfo{};
-            reflInfo.sampler = reflectionSampler;
-            reflInfo.imageView = reflectionColorView;
-            reflInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+    // Update all per-frame scene descriptor sets with the freshly rendered reflection texture
+    if (reflectionColorView && reflectionSampler) {
+        VkDescriptorImageInfo reflInfo{};
+        reflInfo.sampler = reflectionSampler;
+        reflInfo.imageView = reflectionColorView;
+        reflInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 
+        std::vector<VkWriteDescriptorSet> writes;
+        for (uint32_t f = 0; f < SCENE_HISTORY_FRAMES; f++) {
+            if (!sceneHistory[f].sceneSet) continue;
             VkWriteDescriptorSet write{};
             write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-            write.dstSet = sceneHistory[fi].sceneSet;
+            write.dstSet = sceneHistory[f].sceneSet;
             write.dstBinding = 2;
             write.descriptorCount = 1;
             write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
             write.pImageInfo = &reflInfo;
-            vkUpdateDescriptorSets(vkCtx->getDevice(), 1, &write, 0, nullptr);
+            writes.push_back(write);
+        }
+        if (!writes.empty()) {
+            vkUpdateDescriptorSets(vkCtx->getDevice(), static_cast<uint32_t>(writes.size()), writes.data(), 0, nullptr);
         }
     }
 }
@@ -2118,7 +2074,7 @@ bool WaterRenderer::createWater1xPass(VkFormat colorFormat, VkFormat depthFormat
         .setLayout(pipelineLayout)
         .setRenderPass(water1xRenderPass)
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     vertShader.destroy();
     fragShader.destroy();
diff --git a/src/rendering/weather.cpp b/src/rendering/weather.cpp
index dcc673d6..fed604dc 100644
--- a/src/rendering/weather.cpp
+++ b/src/rendering/weather.cpp
@@ -14,19 +14,6 @@
 namespace wowee {
 namespace rendering {
 
-namespace {
-// Seeded RNG for weather particle positions and cycle durations.
-// Replaces bare rand() which defaults to seed 1 without srand(),
-// producing identical weather patterns on every launch.
-std::mt19937& weatherRng() {
-    static std::mt19937 gen(std::random_device{}());
-    return gen;
-}
-float weatherRandFloat() {
-    return std::uniform_real_distribution<float>(0.0f, 1.0f)(weatherRng());
-}
-} // namespace
-
 Weather::Weather() {
 }
 
@@ -98,7 +85,7 @@ bool Weather::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout) {
         .setLayout(pipelineLayout)
         .setRenderPass(vkCtx->getImGuiRenderPass())
         .setDynamicStates(dynamicStates)
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     vertModule.destroy();
     fragModule.destroy();
@@ -178,7 +165,7 @@ void Weather::recreatePipelines() {
         .setLayout(pipelineLayout)
         .setRenderPass(vkCtx->getImGuiRenderPass())
         .setDynamicStates(dynamicStates)
-        .build(device, vkCtx->getPipelineCache());
+        .build(device);
 
     vertModule.destroy();
     fragModule.destroy();
@@ -211,10 +198,6 @@ void Weather::update(const Camera& camera, float deltaTime) {
         if (weatherType == Type::RAIN) {
             p.velocity = glm::vec3(0.0f, -50.0f, 0.0f);  // Fast downward
             p.maxLifetime = 5.0f;
-        } else if (weatherType == Type::STORM) {
-            // Storm: faster, angled rain with wind
-            p.velocity = glm::vec3(15.0f, -70.0f, 8.0f);
-            p.maxLifetime = 3.5f;
         } else {  // SNOW
             p.velocity = glm::vec3(0.0f, -5.0f, 0.0f);   // Slow downward
             p.maxLifetime = 10.0f;
@@ -234,7 +217,6 @@ void Weather::update(const Camera& camera, float deltaTime) {
 
     // Update position buffer
     particlePositions.clear();
-    particlePositions.reserve(particles.size());
     for (const auto& particle : particles) {
         particlePositions.push_back(particle.position);
     }
@@ -246,10 +228,9 @@ void Weather::updateParticle(Particle& particle, const Camera& camera, float del
 
     // Reset if lifetime exceeded or too far from camera
     glm::vec3 cameraPos = camera.getPosition();
-    glm::vec3 toCamera = particle.position - cameraPos;
-    float distSq = glm::dot(toCamera, toCamera);
+    float distance = glm::length(particle.position - cameraPos);
 
-    if (particle.lifetime >= particle.maxLifetime || distSq > SPAWN_VOLUME_SIZE * SPAWN_VOLUME_SIZE ||
+    if (particle.lifetime >= particle.maxLifetime || distance > SPAWN_VOLUME_SIZE ||
         particle.position.y < cameraPos.y - 20.0f) {
         // Respawn at top
         particle.position = getRandomPosition(cameraPos);
@@ -264,12 +245,6 @@ void Weather::updateParticle(Particle& particle, const Camera& camera, float del
         particle.velocity.x = windX;
         particle.velocity.z = windZ;
     }
-    // Storm: gusty, turbulent wind with varying direction
-    if (weatherType == Type::STORM) {
-        float gust = std::sin(particle.lifetime * 1.5f + particle.position.x * 0.1f) * 5.0f;
-        particle.velocity.x = 15.0f + gust;
-        particle.velocity.z = 8.0f + std::cos(particle.lifetime * 2.0f) * 3.0f;
-    }
 
     // Update position
     particle.position += particle.velocity * deltaTime;
@@ -300,9 +275,6 @@ void Weather::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet) {
     if (weatherType == Type::RAIN) {
         push.particleSize = 3.0f;
         push.particleColor = glm::vec4(0.7f, 0.8f, 0.9f, 0.6f);
-    } else if (weatherType == Type::STORM) {
-        push.particleSize = 3.5f;
-        push.particleColor = glm::vec4(0.6f, 0.65f, 0.75f, 0.7f);  // Darker, more opaque
     } else {  // SNOW
         push.particleSize = 8.0f;
         push.particleColor = glm::vec4(1.0f, 1.0f, 1.0f, 0.9f);
@@ -337,7 +309,7 @@ void Weather::resetParticles(const Camera& camera) {
     for (int i = 0; i < particleCount; ++i) {
         Particle p;
         p.position = getRandomPosition(cameraPos);
-        p.position.y = cameraPos.y + SPAWN_HEIGHT * (weatherRandFloat());
+        p.position.y = cameraPos.y + SPAWN_HEIGHT * (static_cast<float>(rand()) / RAND_MAX);
         p.lifetime = 0.0f;
 
         if (weatherType == Type::RAIN) {
@@ -353,11 +325,12 @@ void Weather::resetParticles(const Camera& camera) {
 }
 
 glm::vec3 Weather::getRandomPosition(const glm::vec3& center) const {
-    // Reuse the shared weather RNG to avoid duplicate generator state
+    static std::random_device rd;
+    static std::mt19937 gen(rd());
     static std::uniform_real_distribution<float> dist(-1.0f, 1.0f);
 
-    float x = center.x + dist(weatherRng()) * SPAWN_VOLUME_SIZE;
-    float z = center.z + dist(weatherRng()) * SPAWN_VOLUME_SIZE;
+    float x = center.x + dist(gen) * SPAWN_VOLUME_SIZE;
+    float z = center.z + dist(gen) * SPAWN_VOLUME_SIZE;
     float y = center.y;
 
     return glm::vec3(x, y, z);
@@ -439,6 +412,7 @@ void Weather::initializeZoneWeatherDefaults() {
     setZoneWeather(148,  Type::RAIN, 0.1f, 0.4f, 0.15f);  // Darkshore
     setZoneWeather(331,  Type::RAIN, 0.1f, 0.3f, 0.1f);   // Ashenvale
     setZoneWeather(405,  Type::RAIN, 0.1f, 0.3f, 0.1f);   // Desolace
+    setZoneWeather(15,   Type::RAIN, 0.2f, 0.5f, 0.2f);   // Dustwallow Marsh
     setZoneWeather(490,  Type::RAIN, 0.1f, 0.4f, 0.15f);  // Un'Goro Crater
     setZoneWeather(493,  Type::RAIN, 0.1f, 0.3f, 0.1f);   // Moonglade
 
@@ -467,19 +441,19 @@ void Weather::updateZoneWeather(uint32_t zoneId, float deltaTime) {
             targetIntensity_ = 0.0f;
         } else {
             // Roll whether weather is active based on probability
-            float roll = weatherRandFloat();
+            float roll = static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
             zoneWeatherActive_ = (roll < it->second.probability);
 
             if (zoneWeatherActive_) {
                 weatherType = it->second.type;
                 // Random intensity within configured range
-                float t = weatherRandFloat();
+                float t = static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
                 targetIntensity_ = glm::mix(it->second.minIntensity, it->second.maxIntensity, t);
                 // Random cycle duration: 3-8 minutes
-                zoneWeatherCycleDuration_ = 180.0f + weatherRandFloat() * 300.0f;
+                zoneWeatherCycleDuration_ = 180.0f + static_cast<float>(rand()) / static_cast<float>(RAND_MAX) * 300.0f;
             } else {
                 targetIntensity_ = 0.0f;
-                zoneWeatherCycleDuration_ = 120.0f + weatherRandFloat() * 180.0f;
+                zoneWeatherCycleDuration_ = 120.0f + static_cast<float>(rand()) / static_cast<float>(RAND_MAX) * 180.0f;
             }
         }
     }
@@ -507,19 +481,19 @@ void Weather::updateZoneWeather(uint32_t zoneId, float deltaTime) {
 
         auto it = zoneWeatherTable_.find(zoneId);
         if (it != zoneWeatherTable_.end()) {
-            float roll = weatherRandFloat();
+            float roll = static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
             zoneWeatherActive_ = (roll < it->second.probability);
 
             if (zoneWeatherActive_) {
                 weatherType = it->second.type;
-                float t = weatherRandFloat();
+                float t = static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
                 targetIntensity_ = glm::mix(it->second.minIntensity, it->second.maxIntensity, t);
             } else {
                 targetIntensity_ = 0.0f;
             }
 
             // New cycle duration
-            zoneWeatherCycleDuration_ = 180.0f + weatherRandFloat() * 300.0f;
+            zoneWeatherCycleDuration_ = 180.0f + static_cast<float>(rand()) / static_cast<float>(RAND_MAX) * 300.0f;
         }
     }
 }
diff --git a/src/rendering/wmo_renderer.cpp b/src/rendering/wmo_renderer.cpp
index 32996c31..51d8c2a2 100644
--- a/src/rendering/wmo_renderer.cpp
+++ b/src/rendering/wmo_renderer.cpp
@@ -29,7 +29,23 @@ namespace wowee {
 namespace rendering {
 
 namespace {
-constexpr int kPomSampleTable[] = { 16, 32, 64 };
+size_t envSizeMBOrDefault(const char* name, size_t defMb) {
+    const char* raw = std::getenv(name);
+    if (!raw || !*raw) return defMb;
+    char* end = nullptr;
+    unsigned long long mb = std::strtoull(raw, &end, 10);
+    if (end == raw || mb == 0) return defMb;
+    return static_cast<size_t>(mb);
+}
+
+size_t envSizeOrDefault(const char* name, size_t defValue) {
+    const char* raw = std::getenv(name);
+    if (!raw || !*raw) return defValue;
+    char* end = nullptr;
+    unsigned long long v = std::strtoull(raw, &end, 10);
+    if (end == raw || v == 0) return defValue;
+    return static_cast<size_t>(v);
+}
 } // namespace
 
 // Thread-local scratch buffers for collision queries (allows concurrent getFloorHeight/checkWallCollision calls)
@@ -108,7 +124,6 @@ bool WMORenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayou
 
     VkDescriptorPoolCreateInfo poolInfo{};
     poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-    poolInfo.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
     poolInfo.maxSets = MAX_MATERIAL_SETS;
     poolInfo.poolSizeCount = 2;
     poolInfo.pPoolSizes = poolSizes;
@@ -169,7 +184,7 @@ bool WMORenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayou
     vertexAttribs[4] = { 4, 0, VK_FORMAT_R32G32B32A32_SFLOAT,
         static_cast<uint32_t>(offsetof(WMOVertexData, tangent)) };
 
-    // --- Build opaque pipeline (base for derivatives — shared state optimization) ---
+    // --- Build opaque pipeline ---
     VkRenderPass mainPass = vkCtx_->getImGuiRenderPass();
 
     opaquePipeline_ = PipelineBuilder()
@@ -184,8 +199,7 @@ bool WMORenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayou
         .setLayout(pipelineLayout_)
         .setRenderPass(mainPass)
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .setFlags(VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT)
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     if (!opaquePipeline_) {
         core::Logger::getInstance().error("WMORenderer: failed to create opaque pipeline");
@@ -194,7 +208,7 @@ bool WMORenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayou
         return false;
     }
 
-    // --- Build transparent pipeline (derivative of opaque) ---
+    // --- Build transparent pipeline ---
     transparentPipeline_ = PipelineBuilder()
         .setShaders(vertShader.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
                     fragShader.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
@@ -207,15 +221,13 @@ bool WMORenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayou
         .setLayout(pipelineLayout_)
         .setRenderPass(mainPass)
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .setFlags(VK_PIPELINE_CREATE_DERIVATIVE_BIT)
-        .setBasePipeline(opaquePipeline_)
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     if (!transparentPipeline_) {
         core::Logger::getInstance().warning("WMORenderer: transparent pipeline not available");
     }
 
-    // --- Build glass pipeline (derivative — alpha blend WITH depth write for windows) ---
+    // --- Build glass pipeline (alpha blend WITH depth write for windows) ---
     glassPipeline_ = PipelineBuilder()
         .setShaders(vertShader.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
                     fragShader.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
@@ -228,11 +240,9 @@ bool WMORenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayou
         .setLayout(pipelineLayout_)
         .setRenderPass(mainPass)
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .setFlags(VK_PIPELINE_CREATE_DERIVATIVE_BIT)
-        .setBasePipeline(opaquePipeline_)
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
-    // --- Build wireframe pipeline (derivative of opaque) ---
+    // --- Build wireframe pipeline ---
     wireframePipeline_ = PipelineBuilder()
         .setShaders(vertShader.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
                     fragShader.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
@@ -245,9 +255,7 @@ bool WMORenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayou
         .setLayout(pipelineLayout_)
         .setRenderPass(mainPass)
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .setFlags(VK_PIPELINE_CREATE_DERIVATIVE_BIT)
-        .setBasePipeline(opaquePipeline_)
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     if (!wireframePipeline_) {
         core::Logger::getInstance().warning("WMORenderer: wireframe pipeline not available");
@@ -315,9 +323,7 @@ void WMORenderer::shutdown() {
     textureCacheBytes_ = 0;
     textureCacheCounter_ = 0;
     failedTextureCache_.clear();
-    failedTextureRetryAt_.clear();
     loggedTextureLoadFails_.clear();
-    textureLookupSerial_ = 0;
     textureBudgetRejectWarnings_ = 0;
 
     // Free white texture and flat normal texture
@@ -370,16 +376,12 @@ bool WMORenderer::loadModel(const pipeline::WMOModel& model, uint32_t id) {
                     break;
                 }
             }
-            // Track which WMO models have been force-reloaded after resolving only to
-            // fallback textures. Cap the set to avoid unbounded memory growth in worlds
-            // with many unique WMO groups (e.g. Dalaran has 2000+).
-            static constexpr size_t kMaxRetryTracked = 8192;
             static std::unordered_set<uint32_t> retryReloadedModels;
             static bool retryReloadedModelsCapped = false;
-            if (retryReloadedModels.size() > kMaxRetryTracked) {
+            if (retryReloadedModels.size() > 8192) {
                 retryReloadedModels.clear();
                 if (!retryReloadedModelsCapped) {
-                    core::Logger::getInstance().warning("WMO fallback-retry set exceeded ", kMaxRetryTracked, " entries; reset");
+                    core::Logger::getInstance().warning("WMO fallback-retry set exceeded 8192 entries; reset");
                     retryReloadedModelsCapped = true;
                 }
             }
@@ -412,7 +414,6 @@ bool WMORenderer::loadModel(const pipeline::WMOModel& model, uint32_t id) {
     modelData.id = id;
     modelData.boundingBoxMin = model.boundingBoxMin;
     modelData.boundingBoxMax = model.boundingBoxMax;
-    modelData.wmoAmbientColor = model.ambientColor;
     {
         glm::vec3 ext = model.boundingBoxMax - model.boundingBoxMin;
         float horiz = std::max(ext.x, ext.y);
@@ -582,15 +583,7 @@ bool WMORenderer::loadModel(const pipeline::WMOModel& model, uint32_t id) {
                     tex = modelData.textures[texIndex];
                     hasTexture = (tex != nullptr && tex != whiteTexture_.get());
                     if (!tex) tex = whiteTexture_.get();
-                } else {
-                    LOG_WARNING("WMO ", id, " batch materialId=", batch.materialId,
-                                " texIndex=", texIndex, " >= textures size ",
-                                modelData.textures.size(), " — white fallback");
                 }
-            } else {
-                LOG_WARNING("WMO ", id, " batch materialId=", batch.materialId,
-                            " >= materialTextureIndices size ",
-                            modelData.materialTextureIndices.size(), " — white fallback");
             }
 
             bool alphaTest = false;
@@ -681,13 +674,13 @@ bool WMORenderer::loadModel(const pipeline::WMOModel& model, uint32_t id) {
             matData.enableNormalMap = normalMappingEnabled_ ? 1 : 0;
             matData.enablePOM = pomEnabled_ ? 1 : 0;
             matData.pomScale = 0.012f;
-            matData.pomMaxSamples = kPomSampleTable[std::clamp(pomQuality_, 0, 2)];
+            {
+                static const int pomSampleTable[] = { 16, 32, 64 };
+                matData.pomMaxSamples = pomSampleTable[std::clamp(pomQuality_, 0, 2)];
+            }
             matData.heightMapVariance = mb.heightMapVariance;
             matData.normalMapStrength = normalMapStrength_;
             matData.isLava = mb.isLava ? 1 : 0;
-            matData.wmoAmbientR = modelData.wmoAmbientColor.r;
-            matData.wmoAmbientG = modelData.wmoAmbientColor.g;
-            matData.wmoAmbientB = modelData.wmoAmbientColor.b;
             if (matBuf.info.pMappedData) {
                 memcpy(matBuf.info.pMappedData, &matData, sizeof(matData));
             }
@@ -792,7 +785,7 @@ bool WMORenderer::loadModel(const pipeline::WMOModel& model, uint32_t id) {
             // Convert .mdx/.mdl to .m2
             if (m2Path.size() > 4) {
                 std::string ext = m2Path.substr(m2Path.size() - 4);
-                for (char& c : ext) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+                for (char& c : ext) c = std::tolower(c);
                 if (ext == ".mdx" || ext == ".mdl") {
                     m2Path = m2Path.substr(0, m2Path.size() - 4) + ".m2";
                 }
@@ -824,20 +817,15 @@ bool WMORenderer::loadModel(const pipeline::WMOModel& model, uint32_t id) {
     return true;
 }
 
-bool WMORenderer::isModelLoaded(uint32_t id) const {
-    return loadedModels.find(id) != loadedModels.end();
-}
-
 void WMORenderer::unloadModel(uint32_t id) {
     auto it = loadedModels.find(id);
     if (it == loadedModels.end()) {
         return;
     }
 
-    // Free GPU resources — defer because in-flight command buffers may
-    // still reference this model's vertex/index buffers and descriptors.
+    // Free GPU resources
     for (auto& group : it->second.groups) {
-        destroyGroupGPU(group, /*defer=*/true);
+        destroyGroupGPU(group);
     }
 
     loadedModels.erase(it);
@@ -859,12 +847,7 @@ void WMORenderer::cleanupUnusedModels() {
         }
     }
 
-    // Delete GPU resources and remove from map.
-    // Ensure all in-flight frames are complete before freeing vertex/index buffers —
-    // the GPU may still be reading them from the previous frame's command buffer.
-    if (!toRemove.empty() && vkCtx_) {
-        vkDeviceWaitIdle(vkCtx_->getDevice());
-    }
+    // Delete GPU resources and remove from map
     for (uint32_t id : toRemove) {
         unloadModel(id);
     }
@@ -1107,9 +1090,7 @@ void WMORenderer::clearAll() {
     textureCacheBytes_ = 0;
     textureCacheCounter_ = 0;
     failedTextureCache_.clear();
-    failedTextureRetryAt_.clear();
     loggedTextureLoadFails_.clear();
-    textureLookupSerial_ = 0;
     textureBudgetRejectWarnings_ = 0;
     precomputedFloorGrid.clear();
 
@@ -1348,7 +1329,8 @@ void WMORenderer::prepareRender() {
     // Update material UBOs if settings changed (mapped memory writes — main thread only)
     if (materialSettingsDirty_) {
         materialSettingsDirty_ = false;
-        int maxSamples = kPomSampleTable[std::clamp(pomQuality_, 0, 2)];
+        static const int pomSampleTable[] = { 16, 32, 64 };
+        int maxSamples = pomSampleTable[std::clamp(pomQuality_, 0, 2)];
         for (auto& [modelId, model] : loadedModels) {
             for (auto& group : model.groups) {
                 for (auto& mb : group.mergedBatches) {
@@ -1370,8 +1352,7 @@ void WMORenderer::prepareRender() {
     }
 }
 
-void WMORenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const Camera& camera,
-                         const glm::vec3* viewerPos) {
+void WMORenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const Camera& camera) {
     if (!opaquePipeline_ || instances.empty()) {
         lastDrawCalls = 0;
         return;
@@ -1395,11 +1376,6 @@ void WMORenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const
     }
 
     glm::vec3 camPos = camera.getPosition();
-    // For portal culling, use the character/player position when available.
-    // The 3rd-person camera can orbit outside a WMO while the character is inside,
-    // causing the portal traversal to start from outside and cull interior groups.
-    // Passing the actual character position as the viewer fixes this.
-    glm::vec3 portalViewerPos = viewerPos ? *viewerPos : camPos;
     bool doPortalCull = portalCulling;
     bool doDistanceCull = distanceCulling;
 
@@ -1415,21 +1391,21 @@ void WMORenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const
         result.portalCulled = 0;
         result.distanceCulled = 0;
 
-        // Portal-based visibility — reuse member scratch buffers (avoid per-frame alloc)
-        portalVisibleGroups_.clear();
+        // Portal-based visibility — use a flat sorted vector instead of unordered_set
+        std::vector<uint32_t> portalVisibleGroups;
         bool usePortalCulling = doPortalCull && !model.portals.empty() && !model.portalRefs.empty();
         if (usePortalCulling) {
-            portalVisibleGroupSet_.clear();
-            glm::vec4 localCamPos = instance.invModelMatrix * glm::vec4(portalViewerPos, 1.0f);
+            std::unordered_set<uint32_t> pvgSet;
+            glm::vec4 localCamPos = instance.invModelMatrix * glm::vec4(camPos, 1.0f);
             getVisibleGroupsViaPortals(model, glm::vec3(localCamPos), frustum,
-                                       instance.modelMatrix, portalVisibleGroupSet_);
-            portalVisibleGroups_.assign(portalVisibleGroupSet_.begin(), portalVisibleGroupSet_.end());
-            std::sort(portalVisibleGroups_.begin(), portalVisibleGroups_.end());
+                                       instance.modelMatrix, pvgSet);
+            portalVisibleGroups.assign(pvgSet.begin(), pvgSet.end());
+            std::sort(portalVisibleGroups.begin(), portalVisibleGroups.end());
         }
 
         for (size_t gi = 0; gi < model.groups.size(); ++gi) {
             if (usePortalCulling &&
-                !std::binary_search(portalVisibleGroups_.begin(), portalVisibleGroups_.end(),
+                !std::binary_search(portalVisibleGroups.begin(), portalVisibleGroups.end(),
                                     static_cast<uint32_t>(gi))) {
                 result.portalCulled++;
                 continue;
@@ -1441,7 +1417,7 @@ void WMORenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const
                 if (doDistanceCull) {
                     glm::vec3 closestPoint = glm::clamp(camPos, gMin, gMax);
                     float distSq = glm::dot(closestPoint - camPos, closestPoint - camPos);
-                    if (distSq > 1440000.0f) { // 1200 units — matches terrain view distance
+                    if (distSq > 250000.0f) {
                         result.distanceCulled++;
                         continue;
                     }
@@ -1558,6 +1534,16 @@ bool WMORenderer::initializeShadow(VkRenderPass shadowRenderPass) {
     if (!vkCtx_ || shadowRenderPass == VK_NULL_HANDLE) return false;
     VkDevice device = vkCtx_->getDevice();
 
+    // ShadowParams UBO: useBones, useTexture, alphaTest, foliageSway, windTime, foliageMotionDamp
+    struct ShadowParamsUBO {
+        int32_t useBones = 0;
+        int32_t useTexture = 0;
+        int32_t alphaTest = 0;
+        int32_t foliageSway = 0;
+        float windTime = 0.0f;
+        float foliageMotionDamp = 1.0f;
+    };
+
     // Create ShadowParams UBO
     VkBufferCreateInfo bufCI{};
     bufCI.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
@@ -1696,7 +1682,7 @@ bool WMORenderer::initializeShadow(VkRenderPass shadowRenderPass) {
         .setLayout(shadowPipelineLayout_)
         .setRenderPass(shadowRenderPass)
         .setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     vertShader.destroy();
     fragShader.destroy();
@@ -1718,6 +1704,8 @@ void WMORenderer::renderShadow(VkCommandBuffer cmd, const glm::mat4& lightSpaceM
     vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, shadowPipelineLayout_,
         0, 1, &shadowParamsSet_, 0, nullptr);
 
+    struct ShadowPush { glm::mat4 lightSpaceMatrix; glm::mat4 model; };
+
     // WMO shadow cull uses the ortho half-extent (shadow map coverage) rather than
     // the proximity radius so that distant buildings whose shadows reach the player
     // are still rendered into the shadow map.
@@ -1933,64 +1921,28 @@ bool WMORenderer::createGroupResources(const pipeline::WMOGroup& group, GroupRes
 
 // renderGroup removed — draw calls are inlined in render()
 
-void WMORenderer::destroyGroupGPU(GroupResources& group, bool defer) {
+void WMORenderer::destroyGroupGPU(GroupResources& group) {
     if (!vkCtx_) return;
-    VkDevice device = vkCtx_->getDevice();
     VmaAllocator allocator = vkCtx_->getAllocator();
 
-    if (!defer) {
-        // Immediate destruction (safe after vkDeviceWaitIdle)
-        if (group.vertexBuffer) {
-            vmaDestroyBuffer(allocator, group.vertexBuffer, group.vertexAlloc);
-            group.vertexBuffer = VK_NULL_HANDLE;
-        }
-        if (group.indexBuffer) {
-            vmaDestroyBuffer(allocator, group.indexBuffer, group.indexAlloc);
-            group.indexBuffer = VK_NULL_HANDLE;
-        }
-        for (auto& mb : group.mergedBatches) {
-            if (mb.materialSet) {
-                vkFreeDescriptorSets(device, materialDescPool_, 1, &mb.materialSet);
-                mb.materialSet = VK_NULL_HANDLE;
-            }
-            if (mb.materialUBO) {
-                vmaDestroyBuffer(allocator, mb.materialUBO, mb.materialUBOAlloc);
-                mb.materialUBO = VK_NULL_HANDLE;
-            }
-        }
-    } else {
-        // Deferred destruction — previous frame's command buffer may still
-        // reference these buffers and descriptor sets.
-        ::VkBuffer vb = group.vertexBuffer;
-        VmaAllocation vbAlloc = group.vertexAlloc;
-        ::VkBuffer ib = group.indexBuffer;
-        VmaAllocation ibAlloc = group.indexAlloc;
+    if (group.vertexBuffer) {
+        vmaDestroyBuffer(allocator, group.vertexBuffer, group.vertexAlloc);
         group.vertexBuffer = VK_NULL_HANDLE;
+        group.vertexAlloc = VK_NULL_HANDLE;
+    }
+    if (group.indexBuffer) {
+        vmaDestroyBuffer(allocator, group.indexBuffer, group.indexAlloc);
         group.indexBuffer = VK_NULL_HANDLE;
+        group.indexAlloc = VK_NULL_HANDLE;
+    }
 
-        // Snapshot material handles (::VkBuffer = raw Vulkan handle, not RAII wrapper)
-        struct MatSnapshot { VkDescriptorSet set; ::VkBuffer ubo; VmaAllocation uboAlloc; };
-        std::vector<MatSnapshot> mats;
-        mats.reserve(group.mergedBatches.size());
-        for (auto& mb : group.mergedBatches) {
-            mats.push_back({mb.materialSet, mb.materialUBO, mb.materialUBOAlloc});
-            mb.materialSet = VK_NULL_HANDLE;
+    // Destroy material UBOs (descriptor sets are freed when pool is reset/destroyed)
+    for (auto& mb : group.mergedBatches) {
+        if (mb.materialUBO) {
+            vmaDestroyBuffer(allocator, mb.materialUBO, mb.materialUBOAlloc);
             mb.materialUBO = VK_NULL_HANDLE;
+            mb.materialUBOAlloc = VK_NULL_HANDLE;
         }
-
-        VkDescriptorPool pool = materialDescPool_;
-        vkCtx_->deferAfterAllFrameFences([device, allocator, pool, vb, vbAlloc, ib, ibAlloc,
-                                      mats = std::move(mats)]() {
-            if (vb) vmaDestroyBuffer(allocator, vb, vbAlloc);
-            if (ib) vmaDestroyBuffer(allocator, ib, ibAlloc);
-            for (auto& m : mats) {
-                if (m.set) {
-                    VkDescriptorSet s = m.set;
-                    vkFreeDescriptorSets(device, pool, 1, &s);
-                }
-                if (m.ubo) vmaDestroyBuffer(allocator, m.ubo, m.uboAlloc);
-            }
-        });
     }
 }
 
@@ -2013,27 +1965,40 @@ VkDescriptorSet WMORenderer::allocateMaterialSet() {
 
 bool WMORenderer::isGroupVisible(const GroupResources& group, const glm::mat4& modelMatrix,
                                  const Camera& camera) const {
-    // Proper frustum-AABB intersection test for accurate visibility culling
-    // Transform bounding box min/max to world space
-    glm::vec3 localMin = group.boundingBoxMin;
-    glm::vec3 localMax = group.boundingBoxMax;
+    // Simple frustum culling using bounding box
+    // Transform bounding box corners to world space
+    glm::vec3 corners[8] = {
+        glm::vec3(group.boundingBoxMin.x, group.boundingBoxMin.y, group.boundingBoxMin.z),
+        glm::vec3(group.boundingBoxMax.x, group.boundingBoxMin.y, group.boundingBoxMin.z),
+        glm::vec3(group.boundingBoxMin.x, group.boundingBoxMax.y, group.boundingBoxMin.z),
+        glm::vec3(group.boundingBoxMax.x, group.boundingBoxMax.y, group.boundingBoxMin.z),
+        glm::vec3(group.boundingBoxMin.x, group.boundingBoxMin.y, group.boundingBoxMax.z),
+        glm::vec3(group.boundingBoxMax.x, group.boundingBoxMin.y, group.boundingBoxMax.z),
+        glm::vec3(group.boundingBoxMin.x, group.boundingBoxMax.y, group.boundingBoxMax.z),
+        glm::vec3(group.boundingBoxMax.x, group.boundingBoxMax.y, group.boundingBoxMax.z)
+    };
 
-    // Transform min and max to world space
-    glm::vec4 worldMinH = modelMatrix * glm::vec4(localMin, 1.0f);
-    glm::vec4 worldMaxH = modelMatrix * glm::vec4(localMax, 1.0f);
-    glm::vec3 worldMin = glm::vec3(worldMinH);
-    glm::vec3 worldMax = glm::vec3(worldMaxH);
+    // Transform corners to world space
+    for (int i = 0; i < 8; i++) {
+        glm::vec4 worldPos = modelMatrix * glm::vec4(corners[i], 1.0f);
+        corners[i] = glm::vec3(worldPos);
+    }
 
-    // Ensure min/max are correct after transformation (handles non-uniform scaling)
-    glm::vec3 boundsMin = glm::min(worldMin, worldMax);
-    glm::vec3 boundsMax = glm::max(worldMin, worldMax);
+    // Simple check: if all corners are behind camera, cull
+    // (This is a very basic culling implementation - a full frustum test would be better)
+    glm::vec3 forward = camera.getForward();
+    glm::vec3 camPos = camera.getPosition();
 
-    // Extract frustum planes from view-projection matrix
-    Frustum frustum;
-    frustum.extractFromMatrix(camera.getViewProjectionMatrix());
+    int behindCount = 0;
+    for (int i = 0; i < 8; i++) {
+        glm::vec3 toCorner = corners[i] - camPos;
+        if (glm::dot(toCorner, forward) < 0.0f) {
+            behindCount++;
+        }
+    }
 
-    // Test if AABB intersects view frustum
-    return frustum.intersectsAABB(boundsMin, boundsMax);
+    // If all corners are behind camera, cull
+    return behindCount < 8;
 }
 
 int WMORenderer::findContainingGroup(const ModelData& model, const glm::vec3& localPos) const {
@@ -2080,25 +2045,12 @@ bool WMORenderer::isPortalVisible(const ModelData& model, uint16_t portalIndex,
     }
     center /= static_cast<float>(portal.vertexCount);
 
-    // Transform all 8 corners to world space to build the correct world AABB.
-    // Direct transform of pMin/pMax is wrong for rotated WMOs — the matrix can
-    // swap or negate components, inverting min/max and causing frustum test failures.
-    const glm::vec3 corners[8] = {
-        {pMin.x, pMin.y, pMin.z}, {pMax.x, pMin.y, pMin.z},
-        {pMin.x, pMax.y, pMin.z}, {pMax.x, pMax.y, pMin.z},
-        {pMin.x, pMin.y, pMax.z}, {pMax.x, pMin.y, pMax.z},
-        {pMin.x, pMax.y, pMax.z}, {pMax.x, pMax.y, pMax.z},
-    };
-    glm::vec3 worldMin( std::numeric_limits<float>::max());
-    glm::vec3 worldMax(-std::numeric_limits<float>::max());
-    for (const auto& c : corners) {
-        glm::vec3 wc = glm::vec3(modelMatrix * glm::vec4(c, 1.0f));
-        worldMin = glm::min(worldMin, wc);
-        worldMax = glm::max(worldMax, wc);
-    }
+    // Transform bounds to world space for frustum test
+    glm::vec4 worldMin = modelMatrix * glm::vec4(pMin, 1.0f);
+    glm::vec4 worldMax = modelMatrix * glm::vec4(pMax, 1.0f);
 
     // Check if portal AABB intersects frustum (more robust than point test)
-    return frustum.intersectsAABB(worldMin, worldMax);
+    return frustum.intersectsAABB(glm::vec3(worldMin), glm::vec3(worldMax));
 }
 
 void WMORenderer::getVisibleGroupsViaPortals(const ModelData& model,
@@ -2106,9 +2058,6 @@ void WMORenderer::getVisibleGroupsViaPortals(const ModelData& model,
                                               const Frustum& frustum,
                                               const glm::mat4& modelMatrix,
                                               std::unordered_set<uint32_t>& outVisibleGroups) const {
-    constexpr uint32_t WMO_GROUP_FLAG_OUTDOOR = 0x8;
-    constexpr uint32_t WMO_GROUP_FLAG_INDOOR = 0x2000;
-
     // Find camera's containing group
     int cameraGroup = findContainingGroup(model, cameraLocalPos);
 
@@ -2122,37 +2071,9 @@ void WMORenderer::getVisibleGroupsViaPortals(const ModelData& model,
         return;
     }
 
-    // Outdoor city WMOs (e.g. Stormwind) often have portal graphs that are valid for
-    // indoor visibility but too aggressive outdoors, causing direction-dependent popout.
-    // Only trust portal traversal when the camera is in an interior-only group.
-    if (cameraGroup < static_cast<int>(model.groups.size())) {
-        const uint32_t gFlags = model.groups[cameraGroup].groupFlags;
-        const bool isIndoor = (gFlags & WMO_GROUP_FLAG_INDOOR) != 0;
-        const bool isOutdoor = (gFlags & WMO_GROUP_FLAG_OUTDOOR) != 0;
-        if (!isIndoor || isOutdoor) {
-            for (size_t gi = 0; gi < model.groups.size(); gi++) {
-                outVisibleGroups.insert(static_cast<uint32_t>(gi));
-            }
-            return;
-        }
-    }
-
-    // If the camera group has no portal refs, it's a dead-end group (utility/transition group).
-    // Fall back to showing all groups to avoid the rest of the WMO going invisible.
-    if (cameraGroup < static_cast<int>(model.groupPortalRefs.size())) {
-        auto [portalStart, portalCount] = model.groupPortalRefs[cameraGroup];
-        if (portalCount == 0) {
-            for (size_t gi = 0; gi < model.groups.size(); gi++) {
-                outVisibleGroups.insert(static_cast<uint32_t>(gi));
-            }
-            return;
-        }
-    }
-
     // BFS through portals from camera's group
     std::vector<bool> visited(model.groups.size(), false);
     std::vector<uint32_t> queue;
-    queue.reserve(model.groups.size());
     queue.push_back(static_cast<uint32_t>(cameraGroup));
     visited[cameraGroup] = true;
     outVisibleGroups.insert(static_cast<uint32_t>(cameraGroup));
@@ -2210,13 +2131,12 @@ std::unique_ptr<VkTexture> WMORenderer::generateNormalHeightMap(
     const uint32_t totalPixels = width * height;
 
     // Step 1: Compute height from luminance
-    constexpr float kInv255 = 1.0f / 255.0f;
     std::vector<float> heightMap(totalPixels);
     double sumH = 0.0, sumH2 = 0.0;
     for (uint32_t i = 0; i < totalPixels; i++) {
-        float r = pixels[i * 4 + 0] * kInv255;
-        float g = pixels[i * 4 + 1] * kInv255;
-        float b = pixels[i * 4 + 2] * kInv255;
+        float r = pixels[i * 4 + 0] / 255.0f;
+        float g = pixels[i * 4 + 1] / 255.0f;
+        float b = pixels[i * 4 + 2] / 255.0f;
         float h = 0.299f * r + 0.587f * g + 0.114f * b;
         heightMap[i] = h;
         sumH += h;
@@ -2227,8 +2147,8 @@ std::unique_ptr<VkTexture> WMORenderer::generateNormalHeightMap(
 
     // Step 1.5: Box blur the height map to reduce noise from diffuse textures
     auto wrapSample = [&](const std::vector<float>& map, int x, int y) -> float {
-        x = ((x % static_cast<int>(width)) + static_cast<int>(width)) % static_cast<int>(width);
-        y = ((y % static_cast<int>(height)) + static_cast<int>(height)) % static_cast<int>(height);
+        x = ((x % (int)width) + (int)width) % (int)width;
+        y = ((y % (int)height) + (int)height) % (int)height;
         return map[y * width + x];
     };
 
@@ -2250,8 +2170,8 @@ std::unique_ptr<VkTexture> WMORenderer::generateNormalHeightMap(
     std::vector<uint8_t> output(totalPixels * 4);
 
     auto sampleH = [&](int x, int y) -> float {
-        x = ((x % static_cast<int>(width)) + static_cast<int>(width)) % static_cast<int>(width);
-        y = ((y % static_cast<int>(height)) + static_cast<int>(height)) % static_cast<int>(height);
+        x = ((x % (int)width) + (int)width) % (int)width;
+        y = ((y % (int)height) + (int)height) % (int)height;
         return heightMap[y * width + x];
     };
 
@@ -2291,7 +2211,6 @@ std::unique_ptr<VkTexture> WMORenderer::generateNormalHeightMap(
 }
 
 VkTexture* WMORenderer::loadTexture(const std::string& path) {
-    constexpr uint64_t kFailedTextureRetryLookups = 512;
     if (!assetManager || !vkCtx_) {
         return whiteTexture_.get();
     }
@@ -2367,19 +2286,7 @@ VkTexture* WMORenderer::loadTexture(const std::string& path) {
         }
     }
 
-    const uint64_t lookupSerial = ++textureLookupSerial_;
-    std::vector<std::string> attemptedCandidates;
-    attemptedCandidates.reserve(uniqueCandidates.size());
-    for (const auto& c : uniqueCandidates) {
-        auto fit = failedTextureRetryAt_.find(c);
-        if (fit != failedTextureRetryAt_.end() && lookupSerial < fit->second) {
-            continue;
-        }
-        attemptedCandidates.push_back(c);
-    }
-    if (attemptedCandidates.empty()) {
-        return whiteTexture_.get();
-    }
+    const auto& attemptedCandidates = uniqueCandidates;
 
     // Try loading all candidates until one succeeds
     // Check pre-decoded BLP cache first (populated by background worker threads)
@@ -2406,10 +2313,6 @@ VkTexture* WMORenderer::loadTexture(const std::string& path) {
         }
     }
     if (!blp.isValid()) {
-        for (const auto& c : attemptedCandidates) {
-            failedTextureCache_.insert(c);
-            failedTextureRetryAt_[c] = lookupSerial + kFailedTextureRetryLookups;
-        }
         if (loggedTextureLoadFails_.insert(key).second) {
             core::Logger::getInstance().warning("WMO: Failed to load texture: ", path);
         }
@@ -2424,10 +2327,6 @@ VkTexture* WMORenderer::loadTexture(const std::string& path) {
     size_t base = static_cast<size_t>(blp.width) * static_cast<size_t>(blp.height) * 4ull;
     size_t approxBytes = base + (base / 3);
     if (textureCacheBytes_ + approxBytes > textureCacheBudgetBytes_) {
-        for (const auto& c : attemptedCandidates) {
-            failedTextureCache_.insert(c);
-            failedTextureRetryAt_[c] = lookupSerial + kFailedTextureRetryLookups;
-        }
         if (textureBudgetRejectWarnings_ < 3) {
             core::Logger::getInstance().warning(
                 "WMO texture cache full (", textureCacheBytes_ / (1024 * 1024),
@@ -2469,12 +2368,8 @@ VkTexture* WMORenderer::loadTexture(const std::string& path) {
     textureCacheBytes_ += e.approxBytes;
     if (!resolvedKey.empty()) {
         textureCache[resolvedKey] = std::move(e);
-        failedTextureCache_.erase(resolvedKey);
-        failedTextureRetryAt_.erase(resolvedKey);
     } else {
         textureCache[key] = std::move(e);
-        failedTextureCache_.erase(key);
-        failedTextureRetryAt_.erase(key);
     }
     core::Logger::getInstance().debug("WMO: Loaded texture: ", path, " (", blp.width, "x", blp.height, ")");
 
@@ -2506,9 +2401,6 @@ void WMORenderer::backfillNormalMaps() {
 
     if (generated > 0) {
         VkDevice device = vkCtx_->getDevice();
-        // Wait for in-flight command buffers before updating descriptor sets —
-        // the previous frame may still reference them via binding 2.
-        vkDeviceWaitIdle(device);
         int rebound = 0;
         // Update merged batches: assign normal map pointer and rebind descriptor set
         for (auto& [modelId, model] : loadedModels) {
@@ -2600,6 +2492,22 @@ static float pointAABBDistanceSq(const glm::vec3& p, const glm::vec3& bmin, cons
     return glm::dot(d, d);
 }
 
+struct QueryTimer {
+    double* totalMs = nullptr;
+    uint32_t* callCount = nullptr;
+    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+    QueryTimer(double* total, uint32_t* calls) : totalMs(total), callCount(calls) {}
+    ~QueryTimer() {
+        if (callCount) {
+            (*callCount)++;
+        }
+        if (totalMs) {
+            auto end = std::chrono::steady_clock::now();
+            *totalMs += std::chrono::duration<double, std::milli>(end - start).count();
+        }
+    }
+};
+
 // Möller–Trumbore ray-triangle intersection
 // Returns distance along ray if hit, or negative if miss
 static float rayTriangleIntersect(const glm::vec3& origin, const glm::vec3& dir,
@@ -2730,11 +2638,10 @@ void WMORenderer::GroupResources::buildCollisionGrid() {
         triNormals[i / 3] = normal;
 
         // Classify floor vs wall by normal.
-        // Wall threshold matches MAX_WALK_SLOPE (cos 50° ≈ 0.6428): surfaces steeper
-        // than 50° from horizontal are walls. Must match checkWallCollision runtime skip.
+        // Wall threshold matches the runtime skip in checkWallCollision (absNz >= 0.35).
         float absNz = std::abs(normal.z);
-        bool isFloor = (absNz >= 0.65f);
-        bool isWall = (absNz < 0.65f);
+        bool isFloor = (absNz >= 0.35f);  // ~70° max slope (relaxed for steep stairs)
+        bool isWall = (absNz < 0.35f);    // Matches checkWallCollision skip threshold
 
         int cellMinX = std::max(0, static_cast<int>((triMinX - gridOrigin.x) * invCellW));
         int cellMinY = std::max(0, static_cast<int>((triMinY - gridOrigin.y) * invCellH));
@@ -2787,11 +2694,6 @@ void WMORenderer::GroupResources::getTrianglesInRange(
 
     if (cellMinX > cellMaxX || cellMinY > cellMaxY) return;
 
-    // Reserve estimate: cells queried * ~8 triangles per cell
-    const size_t cellCount = static_cast<size_t>(cellMaxX - cellMinX + 1) *
-                             static_cast<size_t>(cellMaxY - cellMinY + 1);
-    out.reserve(cellCount * 8);
-
     // Collect unique triangle indices using visited bitset (O(n) dedup)
     bool multiCell = (cellMinX != cellMaxX || cellMinY != cellMaxY);
     if (multiCell && !triVisited.empty()) {
@@ -2837,10 +2739,6 @@ void WMORenderer::GroupResources::getFloorTrianglesInRange(
 
     if (cellMinX > cellMaxX || cellMinY > cellMaxY) return;
 
-    const size_t cellCount = static_cast<size_t>(cellMaxX - cellMinX + 1) *
-                             static_cast<size_t>(cellMaxY - cellMinY + 1);
-    out.reserve(cellCount * 8);
-
     bool multiCell = (cellMinX != cellMaxX || cellMinY != cellMaxY);
     if (multiCell && !triVisited.empty()) {
         for (int cy = cellMinY; cy <= cellMaxY; ++cy) {
@@ -2884,10 +2782,6 @@ void WMORenderer::GroupResources::getWallTrianglesInRange(
 
     if (cellMinX > cellMaxX || cellMinY > cellMaxY) return;
 
-    const size_t cellCount = static_cast<size_t>(cellMaxX - cellMinX + 1) *
-                             static_cast<size_t>(cellMaxY - cellMinY + 1);
-    out.reserve(cellCount * 8);
-
     bool multiCell = (cellMinX != cellMaxX || cellMinY != cellMaxY);
     if (multiCell && !triVisited.empty()) {
         for (int cy = cellMinY; cy <= cellMaxY; ++cy) {
@@ -3181,8 +3075,8 @@ bool WMORenderer::checkWallCollision(const glm::vec3& from, const glm::vec3& to,
     bool blocked = false;
 
     glm::vec3 moveDir = to - from;
-    float moveDistSq = glm::dot(moveDir, moveDir);
-    if (moveDistSq < 1e-6f) return false;
+    float moveDist = glm::length(moveDir);
+    if (moveDist < 0.001f) return false;
 
     // Player collision parameters — WoW-style horizontal cylinder
     // Tighter radius when inside for more responsive indoor collision
@@ -3315,10 +3209,10 @@ bool WMORenderer::checkWallCollision(const glm::vec3& from, const glm::vec3& to,
                                 glm::vec3 safeLocal = hitPoint + normal * side * (PLAYER_RADIUS + 0.05f);
                                 glm::vec3 pushLocal(safeLocal.x - localTo.x, safeLocal.y - localTo.y, 0.0f);
                                 // Cap swept pushback so walls don't shove the player violently
-                                float pushLenSq = pushLocal.x * pushLocal.x + pushLocal.y * pushLocal.y;
+                                float pushLen = glm::length(glm::vec2(pushLocal.x, pushLocal.y));
                                 const float MAX_SWEPT_PUSH = insideWMO ? 0.45f : 0.25f;
-                                if (pushLenSq > MAX_SWEPT_PUSH * MAX_SWEPT_PUSH) {
-                                    float scale = MAX_SWEPT_PUSH * glm::inversesqrt(pushLenSq);
+                                if (pushLen > MAX_SWEPT_PUSH) {
+                                    float scale = MAX_SWEPT_PUSH / pushLen;
                                     pushLocal.x *= scale;
                                     pushLocal.y *= scale;
                                 }
@@ -3337,29 +3231,26 @@ bool WMORenderer::checkWallCollision(const glm::vec3& from, const glm::vec3& to,
                 // Horizontal cylinder collision: closest point + horizontal distance
                 glm::vec3 closest = closestPointOnTriangle(localTo, v0, v1, v2);
                 glm::vec3 delta = localTo - closest;
-                float horizDistSq = delta.x * delta.x + delta.y * delta.y;
+                float horizDist = glm::length(glm::vec2(delta.x, delta.y));
 
-                if (horizDistSq <= PLAYER_RADIUS * PLAYER_RADIUS) {
-                    // Skip floor-like surfaces — grounding handles them, not wall collision.
-                    // Threshold matches MAX_WALK_SLOPE (cos 50° ≈ 0.6428): surfaces steeper
-                    // than 50° from horizontal must be tested as walls to prevent clip-through.
+                if (horizDist <= PLAYER_RADIUS) {
+                    // Skip floor-like surfaces — grounding handles them, not wall collision
                     float absNz = std::abs(normal.z);
-                    if (absNz >= 0.65f) continue;
+                    if (absNz >= 0.35f) continue;
 
                     const float SKIN = 0.005f;        // small separation so we don't re-collide immediately
                     // Push must cover full penetration to prevent gradual clip-through
                     const float MAX_PUSH = PLAYER_RADIUS;
-                    float horizDist = std::sqrt(horizDistSq);
                     float penetration = (PLAYER_RADIUS - horizDist);
                     float pushDist = glm::clamp(penetration + SKIN, 0.0f, MAX_PUSH);
                     glm::vec2 pushDir2;
-                    if (horizDistSq > 1e-8f) {
-                        pushDir2 = glm::vec2(delta.x, delta.y) * (1.0f / horizDist);
+                    if (horizDist > 1e-4f) {
+                        pushDir2 = glm::normalize(glm::vec2(delta.x, delta.y));
                     } else {
                         glm::vec2 n2(normal.x, normal.y);
-                        float n2LenSq = glm::dot(n2, n2);
-                        if (n2LenSq < 1e-8f) continue;
-                        pushDir2 = n2 * glm::inversesqrt(n2LenSq);
+                        float n2Len = glm::length(n2);
+                        if (n2Len < 1e-4f) continue;
+                        pushDir2 = n2 / n2Len;
                     }
                     glm::vec3 pushLocal(pushDir2.x * pushDist, pushDir2.y * pushDist, 0.0f);
 
@@ -3594,12 +3485,8 @@ float WMORenderer::raycastBoundingBoxes(const glm::vec3& origin, const glm::vec3
         }
 
         glm::vec3 center = (instance.worldBoundsMin + instance.worldBoundsMax) * 0.5f;
-        glm::vec3 halfExtent = instance.worldBoundsMax - center;
-        float radiusSq = glm::dot(halfExtent, halfExtent);
-        glm::vec3 toCenter = center - origin;
-        float distSq = glm::dot(toCenter, toCenter);
-        float maxR = maxDistance + std::sqrt(radiusSq) + 1.0f;
-        if (distSq > maxR * maxR) {
+        float radius = glm::length(instance.worldBoundsMax - center);
+        if (glm::length(center - origin) > (maxDistance + radius + 1.0f)) {
             continue;
         }
 
@@ -3652,7 +3539,7 @@ float WMORenderer::raycastBoundingBoxes(const glm::vec3& origin, const glm::vec3
                 const glm::vec3& v2 = verts[indices[triStart + 2]];
                 glm::vec3 triNormal = group.triNormals[triStart / 3];
                 if (glm::dot(triNormal, triNormal) < 0.5f) continue;  // degenerate
-                // Wall list pre-filters at 0.65; apply stricter camera threshold
+                // Wall list pre-filters at 0.35; apply stricter camera threshold
                 if (std::abs(triNormal.z) > MAX_WALKABLE_ABS_NORMAL_Z) {
                     continue;
                 }
@@ -3712,13 +3599,12 @@ void WMORenderer::recreatePipelines() {
     }
 
     // --- Vertex input ---
-    // WMO vertex: pos3 + normal3 + texCoord2 + color4 + tangent4 = 64 bytes
     struct WMOVertexData {
         glm::vec3 position;
         glm::vec3 normal;
         glm::vec2 texCoord;
         glm::vec4 color;
-        glm::vec4 tangent;  // xyz=tangent dir, w=handedness ±1
+        glm::vec4 tangent;
     };
 
     VkVertexInputBindingDescription vertexBinding{};
@@ -3740,7 +3626,6 @@ void WMORenderer::recreatePipelines() {
 
     VkRenderPass mainPass = vkCtx_->getImGuiRenderPass();
 
-    // Pipeline derivatives — opaque is the base, others derive for shared state optimization
     opaquePipeline_ = PipelineBuilder()
         .setShaders(vertShader.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
                     fragShader.stageInfo(VK_SHADER_STAGE_FRAGMENT_BIT))
@@ -3753,8 +3638,7 @@ void WMORenderer::recreatePipelines() {
         .setLayout(pipelineLayout_)
         .setRenderPass(mainPass)
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .setFlags(VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT)
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     transparentPipeline_ = PipelineBuilder()
         .setShaders(vertShader.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
@@ -3768,9 +3652,7 @@ void WMORenderer::recreatePipelines() {
         .setLayout(pipelineLayout_)
         .setRenderPass(mainPass)
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .setFlags(VK_PIPELINE_CREATE_DERIVATIVE_BIT)
-        .setBasePipeline(opaquePipeline_)
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     glassPipeline_ = PipelineBuilder()
         .setShaders(vertShader.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
@@ -3784,9 +3666,7 @@ void WMORenderer::recreatePipelines() {
         .setLayout(pipelineLayout_)
         .setRenderPass(mainPass)
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .setFlags(VK_PIPELINE_CREATE_DERIVATIVE_BIT)
-        .setBasePipeline(opaquePipeline_)
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     wireframePipeline_ = PipelineBuilder()
         .setShaders(vertShader.stageInfo(VK_SHADER_STAGE_VERTEX_BIT),
@@ -3800,9 +3680,7 @@ void WMORenderer::recreatePipelines() {
         .setLayout(pipelineLayout_)
         .setRenderPass(mainPass)
         .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-        .setFlags(VK_PIPELINE_CREATE_DERIVATIVE_BIT)
-        .setBasePipeline(opaquePipeline_)
-        .build(device, vkCtx_->getPipelineCache());
+        .build(device);
 
     vertShader.destroy();
     fragShader.destroy();
diff --git a/src/rendering/world_map.cpp b/src/rendering/world_map.cpp
index 769bea70..a1debba9 100644
--- a/src/rendering/world_map.cpp
+++ b/src/rendering/world_map.cpp
@@ -10,10 +10,8 @@
 #include "core/coordinates.hpp"
 #include "core/input.hpp"
 #include "core/logger.hpp"
-#include "ui/ui_colors.hpp"
 #include <imgui.h>
 #include <cmath>
-#include <cstdio>
 #include <algorithm>
 #include <limits>
 
@@ -166,7 +164,7 @@ bool WorldMap::initialize(VkContext* ctx, pipeline::AssetManager* am) {
             .setLayout(tilePipelineLayout)
             .setRenderPass(compositeTarget->getRenderPass())
             .setDynamicStates({ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR })
-            .build(device, vkCtx->getPipelineCache());
+            .build(device);
 
         vs.destroy();
         fs.destroy();
@@ -235,10 +233,6 @@ void WorldMap::setMapName(const std::string& name) {
 
 void WorldMap::setServerExplorationMask(const std::vector<uint32_t>& masks, bool hasData) {
     if (!hasData || masks.empty()) {
-        // New session or no data yet — reset both server mask and local accumulation
-        if (hasServerExplorationMask) {
-            locallyExploredZones_.clear();
-        }
         hasServerExplorationMask = false;
         serverExplorationMask.clear();
         return;
@@ -281,11 +275,8 @@ void WorldMap::loadZonesFromDBC() {
         }
     }
 
-    // Use expansion-aware DBC layout when available; fall back to WotLK stock field
-    // indices (ID=0, ParentAreaNum=2, ExploreFlag=3) when layout metadata is missing.
-    // Incorrect field indices silently return wrong data, so these defaults must match
-    // the most common AreaTable.dbc layout to minimize breakage.
     const auto* atL = activeLayout ? activeLayout->getLayout("AreaTable") : nullptr;
+    // Map areaID → its own AreaBit, and parentAreaID → list of child AreaBits
     std::unordered_map<uint32_t, uint32_t> exploreFlagByAreaId;
     std::unordered_map<uint32_t, std::vector<uint32_t>> childBitsByParent;
     auto areaDbc = assetManager->loadDBC("AreaTable.dbc");
@@ -367,15 +358,14 @@ void WorldMap::loadZonesFromDBC() {
                 cont.locTop = z.locTop; cont.locBottom = z.locBottom;
                 first = false;
             } else {
-                cont.locLeft = std::min(cont.locLeft, z.locLeft);
-                cont.locRight = std::max(cont.locRight, z.locRight);
-                cont.locTop = std::min(cont.locTop, z.locTop);
-                cont.locBottom = std::max(cont.locBottom, z.locBottom);
+                cont.locLeft = std::max(cont.locLeft, z.locLeft);
+                cont.locRight = std::min(cont.locRight, z.locRight);
+                cont.locTop = std::max(cont.locTop, z.locTop);
+                cont.locBottom = std::min(cont.locBottom, z.locBottom);
             }
         }
     }
 
-    currentMapId_ = mapID;
     LOG_INFO("WorldMap: loaded ", zones.size(), " zones for mapID=", mapID,
              ", continentIdx=", continentIdx);
 }
@@ -758,6 +748,7 @@ void WorldMap::updateExploration(const glm::vec3& playerRenderPos) {
         return (serverExplorationMask[word] & (1u << (bitIndex % 32))) != 0;
     };
 
+    bool markedAny = false;
     if (hasServerExplorationMask) {
         exploredZones.clear();
         for (int i = 0; i < static_cast<int>(zones.size()); i++) {
@@ -766,24 +757,17 @@ void WorldMap::updateExploration(const glm::vec3& playerRenderPos) {
             for (uint32_t bit : z.exploreBits) {
                 if (isBitSet(bit)) {
                     exploredZones.insert(i);
+                    markedAny = true;
                     break;
                 }
             }
         }
-        // Always trust the server mask when available — even if empty (unexplored character).
-        // Also reveal the zone the player is currently standing in so the map isn't pitch-black
-        // the moment they first enter a new zone (the server bit arrives on the next update).
-        int curZone = findZoneForPlayer(playerRenderPos);
-        if (curZone >= 0) exploredZones.insert(curZone);
-        return;
     }
+    if (markedAny) return;
 
-    // Server mask unavailable — fall back to locally-accumulated position tracking.
-    // Add the zone the player is currently in to the local set and display that.
     float wowX = playerRenderPos.y;
     float wowY = playerRenderPos.x;
 
-    bool foundPos = false;
     for (int i = 0; i < static_cast<int>(zones.size()); i++) {
         const auto& z = zones[i];
         if (z.areaID == 0) continue;
@@ -791,18 +775,15 @@ void WorldMap::updateExploration(const glm::vec3& playerRenderPos) {
         float minY = std::min(z.locTop, z.locBottom), maxY = std::max(z.locTop, z.locBottom);
         if (maxX - minX < 0.001f || maxY - minY < 0.001f) continue;
         if (wowX >= minX && wowX <= maxX && wowY >= minY && wowY <= maxY) {
-            locallyExploredZones_.insert(i);
-            foundPos = true;
+            exploredZones.insert(i);
+            markedAny = true;
         }
     }
 
-    if (!foundPos) {
+    if (!markedAny) {
         int zoneIdx = findZoneForPlayer(playerRenderPos);
-        if (zoneIdx >= 0) locallyExploredZones_.insert(zoneIdx);
+        if (zoneIdx >= 0) exploredZones.insert(zoneIdx);
     }
-
-    // Display the accumulated local set
-    exploredZones = locallyExploredZones_;
 }
 
 void WorldMap::zoomIn(const glm::vec3& playerRenderPos) {
@@ -840,66 +821,63 @@ void WorldMap::zoomOut() {
 // Main render (input + ImGui overlay)
 // --------------------------------------------------------
 
-void WorldMap::render(const glm::vec3& playerRenderPos, int screenWidth, int screenHeight,
-                      float playerYawDeg) {
+void WorldMap::render(const glm::vec3& playerRenderPos, int screenWidth, int screenHeight) {
     if (!initialized || !assetManager) return;
 
     auto& input = core::Input::getInstance();
 
     if (!zones.empty()) updateExploration(playerRenderPos);
 
-    // game_screen owns the open/close toggle (via showWorldMap_ + TOGGLE_WORLD_MAP keybinding).
-    // render() is only called when showWorldMap_ is true, so treat each call as "should be open".
-    if (!open) {
-        // First time shown: load zones and navigate to player's location.
-        open = true;
-        if (zones.empty()) loadZonesFromDBC();
-
-        int bestContinent = findBestContinentForPlayer(playerRenderPos);
-        if (bestContinent >= 0 && bestContinent != continentIdx) {
-            continentIdx = bestContinent;
-            compositedIdx = -1;
+    if (open) {
+        if (input.isKeyJustPressed(SDL_SCANCODE_M) ||
+            input.isKeyJustPressed(SDL_SCANCODE_ESCAPE)) {
+            open = false;
+            return;
         }
 
-        int playerZone = findZoneForPlayer(playerRenderPos);
-        if (playerZone >= 0 && continentIdx >= 0 &&
-            zoneBelongsToContinent(playerZone, continentIdx)) {
-            loadZoneTextures(playerZone);
-            requestComposite(playerZone);
-            currentIdx = playerZone;
-            viewLevel = ViewLevel::ZONE;
-        } else if (continentIdx >= 0) {
-            loadZoneTextures(continentIdx);
-            requestComposite(continentIdx);
-            currentIdx = continentIdx;
-            viewLevel = ViewLevel::CONTINENT;
-        }
-    }
-
-    // ESC closes the map; game_screen will sync showWorldMap_ via wm->isOpen() next frame.
-    if (input.isKeyJustPressed(SDL_SCANCODE_ESCAPE)) {
-        open = false;
-        return;
-    }
-
-    {
         auto& io = ImGui::GetIO();
         float wheelDelta = io.MouseWheel;
         if (std::abs(wheelDelta) < 0.001f)
             wheelDelta = input.getMouseWheelDelta();
         if (wheelDelta > 0.0f) zoomIn(playerRenderPos);
         else if (wheelDelta < 0.0f) zoomOut();
+    } else {
+        auto& io = ImGui::GetIO();
+        if (!io.WantCaptureKeyboard && input.isKeyJustPressed(SDL_SCANCODE_M)) {
+            open = true;
+            if (zones.empty()) loadZonesFromDBC();
+
+            int bestContinent = findBestContinentForPlayer(playerRenderPos);
+            if (bestContinent >= 0 && bestContinent != continentIdx) {
+                continentIdx = bestContinent;
+                compositedIdx = -1;
+            }
+
+            int playerZone = findZoneForPlayer(playerRenderPos);
+            if (playerZone >= 0 && continentIdx >= 0 &&
+                zoneBelongsToContinent(playerZone, continentIdx)) {
+                loadZoneTextures(playerZone);
+                requestComposite(playerZone);
+                currentIdx = playerZone;
+                viewLevel = ViewLevel::ZONE;
+            } else if (continentIdx >= 0) {
+                loadZoneTextures(continentIdx);
+                requestComposite(continentIdx);
+                currentIdx = continentIdx;
+                viewLevel = ViewLevel::CONTINENT;
+            }
+        }
     }
 
     if (!open) return;
-    renderImGuiOverlay(playerRenderPos, screenWidth, screenHeight, playerYawDeg);
+    renderImGuiOverlay(playerRenderPos, screenWidth, screenHeight);
 }
 
 // --------------------------------------------------------
 // ImGui overlay
 // --------------------------------------------------------
 
-void WorldMap::renderImGuiOverlay(const glm::vec3& playerRenderPos, int screenWidth, int screenHeight, float playerYawDeg) {
+void WorldMap::renderImGuiOverlay(const glm::vec3& playerRenderPos, int screenWidth, int screenHeight) {
     float sw = static_cast<float>(screenWidth);
     float sh = static_cast<float>(screenHeight);
 
@@ -1020,179 +998,8 @@ void WorldMap::renderImGuiOverlay(const glm::vec3& playerRenderPos, int screenWi
                 playerUV.y >= 0.0f && playerUV.y <= 1.0f) {
                 float px = imgMin.x + playerUV.x * displayW;
                 float py = imgMin.y + playerUV.y * displayH;
-                // Directional arrow: render-space (cos,sin) maps to screen (-dx,-dy)
-                // because render+X=west=left and render+Y=north=up (screen Y is down).
-                float yawRad = glm::radians(playerYawDeg);
-                float adx = -std::cos(yawRad);   // screen-space arrow X
-                float ady = -std::sin(yawRad);   // screen-space arrow Y
-                float apx = -ady, apy = adx;     // perpendicular (left/right of arrow)
-                constexpr float TIP  = 9.0f;     // tip distance from center
-                constexpr float TAIL = 4.0f;     // tail distance from center
-                constexpr float HALF = 5.0f;     // half base width
-                ImVec2 tip(px + adx * TIP,  py + ady * TIP);
-                ImVec2 bl (px - adx * TAIL + apx * HALF,  py - ady * TAIL + apy * HALF);
-                ImVec2 br (px - adx * TAIL - apx * HALF,  py - ady * TAIL - apy * HALF);
-                drawList->AddTriangleFilled(tip, bl, br, IM_COL32(255, 40, 40, 255));
-                drawList->AddTriangle(tip, bl, br, IM_COL32(0, 0, 0, 200), 1.5f);
-            }
-        }
-
-        // Party member dots
-        if (currentIdx >= 0 && viewLevel != ViewLevel::WORLD) {
-            ImFont* font = ImGui::GetFont();
-            for (const auto& dot : partyDots_) {
-                glm::vec2 uv = renderPosToMapUV(dot.renderPos, currentIdx);
-                if (uv.x < 0.0f || uv.x > 1.0f || uv.y < 0.0f || uv.y > 1.0f) continue;
-                float px = imgMin.x + uv.x * displayW;
-                float py = imgMin.y + uv.y * displayH;
-                drawList->AddCircleFilled(ImVec2(px, py), 5.0f, dot.color);
-                drawList->AddCircle(ImVec2(px, py), 5.0f, IM_COL32(0, 0, 0, 200), 0, 1.5f);
-                // Name tooltip on hover
-                if (!dot.name.empty()) {
-                    ImVec2 mp = ImGui::GetMousePos();
-                    float dx = mp.x - px, dy = mp.y - py;
-                    if (dx * dx + dy * dy <= 49.0f) {  // radius 7 px hit area
-                        ImGui::SetTooltip("%s", dot.name.c_str());
-                    }
-                    // Draw name label above the dot
-                    ImVec2 nameSz = font->CalcTextSizeA(ImGui::GetFontSize(), FLT_MAX, 0.0f, dot.name.c_str());
-                    float tx = px - nameSz.x * 0.5f;
-                    float ty = py - nameSz.y - 7.0f;
-                    drawList->AddText(ImVec2(tx + 1.0f, ty + 1.0f), IM_COL32(0, 0, 0, 180), dot.name.c_str());
-                    drawList->AddText(ImVec2(tx, ty), IM_COL32(255, 255, 255, 220), dot.name.c_str());
-                }
-            }
-        }
-
-        // Taxi node markers — flight master icons on the map
-        if (currentIdx >= 0 && viewLevel != ViewLevel::WORLD && !taxiNodes_.empty()) {
-            ImVec2 mp = ImGui::GetMousePos();
-            for (const auto& node : taxiNodes_) {
-                if (!node.known) continue;
-                if (static_cast<int>(node.mapId) != currentMapId_) continue;
-
-                glm::vec3 rPos = core::coords::canonicalToRender(
-                    glm::vec3(node.wowX, node.wowY, node.wowZ));
-                glm::vec2 uv = renderPosToMapUV(rPos, currentIdx);
-                if (uv.x < 0.0f || uv.x > 1.0f || uv.y < 0.0f || uv.y > 1.0f) continue;
-
-                float px = imgMin.x + uv.x * displayW;
-                float py = imgMin.y + uv.y * displayH;
-
-                // Flight-master icon: yellow diamond with dark border
-                constexpr float H = 5.0f;  // half-size of diamond
-                ImVec2 top2(px,     py - H);
-                ImVec2 right2(px + H, py    );
-                ImVec2 bot2(px,     py + H);
-                ImVec2 left2(px - H, py    );
-                drawList->AddQuadFilled(top2, right2, bot2, left2,
-                                        IM_COL32(255, 215, 0, 230));
-                drawList->AddQuad(top2, right2, bot2, left2,
-                                  IM_COL32(80, 50, 0, 200), 1.2f);
-
-                // Tooltip on hover
-                if (!node.name.empty()) {
-                    float mdx = mp.x - px, mdy = mp.y - py;
-                    if (mdx * mdx + mdy * mdy < 49.0f) {
-                        ImGui::SetTooltip("%s\n(Flight Master)", node.name.c_str());
-                    }
-                }
-            }
-        }
-
-        // Quest POI markers — golden exclamation marks / question marks
-        if (currentIdx >= 0 && viewLevel != ViewLevel::WORLD && !questPois_.empty()) {
-            ImVec2 mp = ImGui::GetMousePos();
-            ImFont* qFont = ImGui::GetFont();
-            for (const auto& qp : questPois_) {
-                glm::vec3 rPos = core::coords::canonicalToRender(
-                    glm::vec3(qp.wowX, qp.wowY, 0.0f));
-                glm::vec2 uv = renderPosToMapUV(rPos, currentIdx);
-                if (uv.x < 0.0f || uv.x > 1.0f || uv.y < 0.0f || uv.y > 1.0f) continue;
-
-                float px = imgMin.x + uv.x * displayW;
-                float py = imgMin.y + uv.y * displayH;
-
-                // Cyan circle with golden ring (matches minimap POI style)
-                drawList->AddCircleFilled(ImVec2(px, py), 5.0f, IM_COL32(0, 210, 255, 220));
-                drawList->AddCircle(ImVec2(px, py), 5.0f, IM_COL32(255, 215, 0, 220), 0, 1.5f);
-
-                // Quest name label
-                if (!qp.name.empty()) {
-                    ImVec2 nameSz = qFont->CalcTextSizeA(ImGui::GetFontSize() * 0.85f, FLT_MAX, 0.0f, qp.name.c_str());
-                    float tx = px - nameSz.x * 0.5f;
-                    float ty = py - nameSz.y - 7.0f;
-                    drawList->AddText(qFont, ImGui::GetFontSize() * 0.85f,
-                                      ImVec2(tx + 1.0f, ty + 1.0f), IM_COL32(0, 0, 0, 180), qp.name.c_str());
-                    drawList->AddText(qFont, ImGui::GetFontSize() * 0.85f,
-                                      ImVec2(tx, ty), IM_COL32(255, 230, 100, 230), qp.name.c_str());
-                }
-                // Tooltip on hover
-                float mdx = mp.x - px, mdy = mp.y - py;
-                if (mdx * mdx + mdy * mdy < 49.0f && !qp.name.empty()) {
-                    ImGui::SetTooltip("%s\n(Quest Objective)", qp.name.c_str());
-                }
-            }
-        }
-
-        // Corpse marker — skull X shown when player is a ghost with unclaimed corpse
-        if (hasCorpse_ && currentIdx >= 0 && viewLevel != ViewLevel::WORLD) {
-            glm::vec2 uv = renderPosToMapUV(corpseRenderPos_, currentIdx);
-            if (uv.x >= 0.0f && uv.x <= 1.0f && uv.y >= 0.0f && uv.y <= 1.0f) {
-                float cx = imgMin.x + uv.x * displayW;
-                float cy = imgMin.y + uv.y * displayH;
-                constexpr float R = 5.0f;   // cross arm half-length
-                constexpr float T = 1.8f;   // line thickness
-                // Dark outline
-                drawList->AddLine(ImVec2(cx - R, cy - R), ImVec2(cx + R, cy + R),
-                                  IM_COL32(0, 0, 0, 220), T + 1.5f);
-                drawList->AddLine(ImVec2(cx + R, cy - R), ImVec2(cx - R, cy + R),
-                                  IM_COL32(0, 0, 0, 220), T + 1.5f);
-                // Bone-white X
-                drawList->AddLine(ImVec2(cx - R, cy - R), ImVec2(cx + R, cy + R),
-                                  IM_COL32(230, 220, 200, 240), T);
-                drawList->AddLine(ImVec2(cx + R, cy - R), ImVec2(cx - R, cy + R),
-                                  IM_COL32(230, 220, 200, 240), T);
-                // Tooltip on hover
-                ImVec2 mp = ImGui::GetMousePos();
-                float dx = mp.x - cx, dy = mp.y - cy;
-                if (dx * dx + dy * dy < 64.0f) {
-                    ImGui::SetTooltip("Your corpse");
-                }
-            }
-        }
-
-        // Hover coordinate display — show WoW coordinates under cursor
-        if (currentIdx >= 0 && viewLevel != ViewLevel::WORLD) {
-            auto& io = ImGui::GetIO();
-            ImVec2 mp = io.MousePos;
-            if (mp.x >= imgMin.x && mp.x <= imgMin.x + displayW &&
-                mp.y >= imgMin.y && mp.y <= imgMin.y + displayH) {
-                float mu = (mp.x - imgMin.x) / displayW;
-                float mv = (mp.y - imgMin.y) / displayH;
-
-                const auto& zone = zones[currentIdx];
-                float left = zone.locLeft, right = zone.locRight;
-                float top = zone.locTop, bottom = zone.locBottom;
-                if (zone.areaID == 0) {
-                    float l, r, t, b;
-                    getContinentProjectionBounds(currentIdx, l, r, t, b);
-                    left = l; right = r; top = t; bottom = b;
-                    // Undo the kVOffset applied during renderPosToMapUV for continent
-                    constexpr float kVOffset = -0.15f;
-                    mv -= kVOffset;
-                }
-
-                float hWowX = left - mu * (left - right);
-                float hWowY = top  - mv * (top  - bottom);
-
-                char coordBuf[32];
-                snprintf(coordBuf, sizeof(coordBuf), "%.0f, %.0f", hWowX, hWowY);
-                ImVec2 coordSz = ImGui::CalcTextSize(coordBuf);
-                float cx = imgMin.x + displayW - coordSz.x - 8.0f;
-                float cy = imgMin.y + displayH - coordSz.y - 8.0f;
-                drawList->AddText(ImVec2(cx + 1.0f, cy + 1.0f), IM_COL32(0, 0, 0, 180), coordBuf);
-                drawList->AddText(ImVec2(cx, cy), IM_COL32(220, 210, 150, 230), coordBuf);
+                drawList->AddCircleFilled(ImVec2(px, py), 6.0f, IM_COL32(255, 40, 40, 255));
+                drawList->AddCircle(ImVec2(px, py), 6.0f, IM_COL32(0, 0, 0, 200), 0, 2.0f);
             }
         }
 
@@ -1260,23 +1067,6 @@ void WorldMap::renderImGuiOverlay(const glm::vec3& playerRenderPos, int screenWi
                         drawList->AddRect(ImVec2(sx0, sy0), ImVec2(sx1, sy1),
                                           IM_COL32(255, 255, 255, 30), 0.0f, 0, 1.0f);
                     }
-
-                    // Zone name label — only if the rect is large enough to fit it
-                    if (!z.areaName.empty()) {
-                        ImVec2 textSz = ImGui::CalcTextSize(z.areaName.c_str());
-                        float rectW = sx1 - sx0;
-                        float rectH = sy1 - sy0;
-                        if (rectW > textSz.x + 4.0f && rectH > textSz.y + 2.0f) {
-                            float tx = (sx0 + sx1) * 0.5f - textSz.x * 0.5f;
-                            float ty = (sy0 + sy1) * 0.5f - textSz.y * 0.5f;
-                            ImU32 labelCol = explored
-                                ? IM_COL32(255, 230, 150, 210)
-                                : IM_COL32(160, 160, 160, 80);
-                            drawList->AddText(ImVec2(tx + 1.0f, ty + 1.0f),
-                                              IM_COL32(0, 0, 0, 130), z.areaName.c_str());
-                            drawList->AddText(ImVec2(tx, ty), labelCol, z.areaName.c_str());
-                        }
-                    }
                 }
             }
 
@@ -1299,7 +1089,7 @@ void WorldMap::renderImGuiOverlay(const glm::vec3& playerRenderPos, int screenWi
             ImGui::SetCursorPos(ImVec2(mapX + 8.0f, mapY + 8.0f));
             ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.15f, 0.15f, 0.15f, 0.8f));
             ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.3f, 0.3f, 0.1f, 0.9f));
-            ImGui::PushStyleColor(ImGuiCol_Text, ui::colors::kBrightGold);
+            ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.85f, 0.0f, 1.0f));
             if (ImGui::Button("< Back")) goBack = true;
             ImGui::PopStyleColor(3);
 
@@ -1327,7 +1117,7 @@ void WorldMap::renderImGuiOverlay(const glm::vec3& playerRenderPos, int screenWi
             ImGui::SetCursorPos(ImVec2(mapX + 8.0f, worldBtnY));
             ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.15f, 0.15f, 0.15f, 0.8f));
             ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.3f, 0.3f, 0.1f, 0.9f));
-            ImGui::PushStyleColor(ImGuiCol_Text, ui::colors::kBrightGold);
+            ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.85f, 0.0f, 1.0f));
             if (ImGui::Button("< World")) goWorld = true;
             ImGui::PopStyleColor(3);
 
diff --git a/src/ui/action_bar_panel.cpp b/src/ui/action_bar_panel.cpp
deleted file mode 100644
index 49460c14..00000000
--- a/src/ui/action_bar_panel.cpp
+++ /dev/null
@@ -1,1751 +0,0 @@
-// ============================================================
-// ActionBarPanel — extracted from GameScreen
-// Owns all action bar rendering: main bar, stance bar, bag bar,
-// XP bar, reputation bar, macro resolution.
-// ============================================================
-#include "ui/action_bar_panel.hpp"
-#include "ui/chat_panel.hpp"
-#include "ui/settings_panel.hpp"
-#include "ui/spellbook_screen.hpp"
-#include "ui/inventory_screen.hpp"
-#include "ui/quest_log_screen.hpp"
-#include "ui/ui_colors.hpp"
-#include "core/application.hpp"
-#include "core/logger.hpp"
-#include "rendering/renderer.hpp"
-#include "rendering/vk_context.hpp"
-#include "core/window.hpp"
-#include "game/game_handler.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "pipeline/dbc_layout.hpp"
-#include "audio/ui_sound_manager.hpp"
-#include <imgui.h>
-#include <imgui_internal.h>
-#include <algorithm>
-#include <cmath>
-#include <cstdio>
-#include <string>
-
-namespace {
-    using namespace wowee::ui::colors;
-    constexpr auto& kColorRed         = kRed;
-    constexpr auto& kColorGreen       = kGreen;
-    constexpr auto& kColorBrightGreen = kBrightGreen;
-    constexpr auto& kColorYellow      = kYellow;
-    constexpr auto& kColorGray        = kGray;
-    constexpr auto& kColorDarkGray    = kDarkGray;
-
-    // Collect all non-comment, non-empty lines from a macro body.
-    std::vector<std::string> allMacroCommands(const std::string& macroText) {
-        std::vector<std::string> cmds;
-        size_t pos = 0;
-        while (pos <= macroText.size()) {
-            size_t nl = macroText.find('\n', pos);
-            std::string line = (nl != std::string::npos) ? macroText.substr(pos, nl - pos) : macroText.substr(pos);
-            if (!line.empty() && line.back() == '\r') line.pop_back();
-            size_t start = line.find_first_not_of(" \t");
-            if (start != std::string::npos) line = line.substr(start);
-            if (!line.empty() && line.front() != '#')
-                cmds.push_back(std::move(line));
-            if (nl == std::string::npos) break;
-            pos = nl + 1;
-        }
-        return cmds;
-    }
-
-    // Returns the #showtooltip argument from a macro body.
-    std::string getMacroShowtooltipArg(const std::string& macroText) {
-        size_t pos = 0;
-        while (pos <= macroText.size()) {
-            size_t nl = macroText.find('\n', pos);
-            std::string line = (nl != std::string::npos) ? macroText.substr(pos, nl - pos) : macroText.substr(pos);
-            if (!line.empty() && line.back() == '\r') line.pop_back();
-            size_t fs = line.find_first_not_of(" \t");
-            if (fs != std::string::npos) line = line.substr(fs);
-            if (line.rfind("#showtooltip", 0) == 0 || line.rfind("#show", 0) == 0) {
-                size_t sp = line.find(' ');
-                if (sp != std::string::npos) {
-                    std::string arg = line.substr(sp + 1);
-                    size_t as = arg.find_first_not_of(" \t");
-                    if (as != std::string::npos) arg = arg.substr(as);
-                    size_t ae = arg.find_last_not_of(" \t");
-                    if (ae != std::string::npos) arg.resize(ae + 1);
-                    if (!arg.empty()) return arg;
-                }
-                return "__auto__";
-            }
-            if (nl == std::string::npos) break;
-            pos = nl + 1;
-        }
-        return {};
-    }
-
-} // anonymous namespace
-
-namespace wowee {
-namespace ui {
-
-uint32_t ActionBarPanel::resolveMacroPrimarySpellId(uint32_t macroId, game::GameHandler& gameHandler) {
-    // Invalidate cache when spell list changes (learning/unlearning spells)
-    size_t curSpellCount = gameHandler.getKnownSpells().size();
-    if (curSpellCount != macroCacheSpellCount_) {
-        macroPrimarySpellCache_.clear();
-        macroCacheSpellCount_ = curSpellCount;
-    }
-    auto cacheIt = macroPrimarySpellCache_.find(macroId);
-    if (cacheIt != macroPrimarySpellCache_.end()) return cacheIt->second;
-
-    const std::string& macroText = gameHandler.getMacroText(macroId);
-    uint32_t result = 0;
-    if (!macroText.empty()) {
-        for (const auto& cmdLine : allMacroCommands(macroText)) {
-            std::string cl = cmdLine;
-            for (char& c : cl) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-            bool isCast = (cl.rfind("/cast ", 0) == 0);
-            bool isCastSeq = (cl.rfind("/castsequence ", 0) == 0);
-            bool isUse = (cl.rfind("/use ", 0) == 0);
-            if (!isCast && !isCastSeq && !isUse) continue;
-            size_t sp2 = cmdLine.find(' ');
-            if (sp2 == std::string::npos) continue;
-            std::string spellArg = cmdLine.substr(sp2 + 1);
-            // Strip conditionals [...]
-            if (!spellArg.empty() && spellArg.front() == '[') {
-                size_t ce = spellArg.find(']');
-                if (ce != std::string::npos) spellArg = spellArg.substr(ce + 1);
-            }
-            // Strip reset= spec for castsequence
-            if (isCastSeq) {
-                std::string tmp = spellArg;
-                while (!tmp.empty() && tmp.front() == ' ') tmp.erase(tmp.begin());
-                if (tmp.rfind("reset=", 0) == 0) {
-                    size_t spAfter = tmp.find(' ');
-                    if (spAfter != std::string::npos) spellArg = tmp.substr(spAfter + 1);
-                }
-            }
-            // Take first alternative before ';' (for /cast) or first spell before ',' (for /castsequence)
-            size_t semi = spellArg.find(isCastSeq ? ',' : ';');
-            if (semi != std::string::npos) spellArg = spellArg.substr(0, semi);
-            size_t ss = spellArg.find_first_not_of(" \t!");
-            if (ss != std::string::npos) spellArg = spellArg.substr(ss);
-            size_t se = spellArg.find_last_not_of(" \t");
-            if (se != std::string::npos) spellArg.resize(se + 1);
-            if (spellArg.empty()) continue;
-            std::string spLow = spellArg;
-            for (char& c : spLow) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-            if (isUse) {
-                // /use resolves an item name → find the item's on-use spell ID
-                for (const auto& [entry, info] : gameHandler.getItemInfoCache()) {
-                    if (!info.valid) continue;
-                    std::string iName = info.name;
-                    for (char& c : iName) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                    if (iName == spLow) {
-                        for (const auto& sp : info.spells) {
-                            if (sp.spellId != 0 && sp.spellTrigger == 0) { result = sp.spellId; break; }
-                        }
-                        break;
-                    }
-                }
-            } else {
-                // /cast and /castsequence resolve a spell name
-                for (uint32_t sid : gameHandler.getKnownSpells()) {
-                    std::string sn = gameHandler.getSpellName(sid);
-                    for (char& c : sn) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                    if (sn == spLow) { result = sid; break; }
-                }
-            }
-            break;
-        }
-    }
-    macroPrimarySpellCache_[macroId] = result;
-    return result;
-}
-
-void ActionBarPanel::renderActionBar(game::GameHandler& gameHandler,
-                             SettingsPanel& settingsPanel,
-                             ChatPanel& chatPanel,
-                             InventoryScreen& inventoryScreen,
-                             SpellbookScreen& spellbookScreen,
-                             QuestLogScreen& questLogScreen,
-                             SpellIconFn getSpellIcon) {
-    // Use ImGui's display size — always in sync with the current swap-chain/frame,
-    // whereas window->getWidth/Height() can lag by one frame on resize events.
-    ImVec2 displaySize = ImGui::GetIO().DisplaySize;
-    float screenW = displaySize.x > 0.0f ? displaySize.x : 1280.0f;
-    float screenH = displaySize.y > 0.0f ? displaySize.y : 720.0f;
-    auto* assetMgr = services_.assetManager;
-
-    float slotSize = 48.0f * settingsPanel.pendingActionBarScale;
-    float spacing = 4.0f;
-    float padding = 8.0f;
-    float barW = 12 * slotSize + 11 * spacing + padding * 2;
-    float barH = slotSize + 24.0f;
-    float barX = (screenW - barW) / 2.0f;
-    float barY = screenH - barH;
-
-    ImGui::SetNextWindowPos(ImVec2(barX, barY), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(barW, barH), ImGuiCond_Always);
-
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
-                             ImGuiWindowFlags_NoScrollbar;
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(padding, padding));
-    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0.0f, 0.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.05f, 0.05f, 0.05f, 0.9f));
-
-    // Per-slot rendering lambda — shared by both action bars
-    const auto& bar = gameHandler.getActionBar();
-    static constexpr const char* keyLabels1[] = {"1","2","3","4","5","6","7","8","9","0","-","="};
-    // "⇧N" labels for bar 2 (UTF-8: E2 87 A7 = U+21E7 UPWARDS WHITE ARROW)
-    static constexpr const char* keyLabels2[] = {
-        "\xe2\x87\xa7" "1", "\xe2\x87\xa7" "2", "\xe2\x87\xa7" "3",
-        "\xe2\x87\xa7" "4", "\xe2\x87\xa7" "5", "\xe2\x87\xa7" "6",
-        "\xe2\x87\xa7" "7", "\xe2\x87\xa7" "8", "\xe2\x87\xa7" "9",
-        "\xe2\x87\xa7" "0", "\xe2\x87\xa7" "-", "\xe2\x87\xa7" "="
-    };
-
-    auto renderBarSlot = [&](int absSlot, const char* keyLabel) {
-        ImGui::BeginGroup();
-        ImGui::PushID(absSlot);
-
-        const auto& slot = bar[absSlot];
-        bool onCooldown = !slot.isReady();
-
-        // Macro cooldown: check the cached primary spell's cooldown.
-        float macroCooldownRemaining = 0.0f;
-        float macroCooldownTotal = 0.0f;
-        if (slot.type == game::ActionBarSlot::MACRO && slot.id != 0 && !onCooldown) {
-            uint32_t macroSpellId = resolveMacroPrimarySpellId(slot.id, gameHandler);
-            if (macroSpellId != 0) {
-                float cd = gameHandler.getSpellCooldown(macroSpellId);
-                if (cd > 0.0f) {
-                    macroCooldownRemaining = cd;
-                    macroCooldownTotal = cd;
-                    onCooldown = true;
-                }
-            }
-        }
-
-        const bool onGCD = gameHandler.isGCDActive() && !onCooldown && !slot.isEmpty();
-
-        // Out-of-range check: red tint when a targeted spell cannot reach the current target.
-        // Applies to SPELL and MACRO slots with a known max range (>5 yd) and an active target.
-        // Item range is checked below after barItemDef is populated.
-        bool outOfRange = false;
-        {
-            uint32_t rangeCheckSpellId = 0;
-            if (slot.type == game::ActionBarSlot::SPELL && slot.id != 0)
-                rangeCheckSpellId = slot.id;
-            else if (slot.type == game::ActionBarSlot::MACRO && slot.id != 0)
-                rangeCheckSpellId = resolveMacroPrimarySpellId(slot.id, gameHandler);
-            if (rangeCheckSpellId != 0 && !onCooldown && gameHandler.hasTarget()) {
-                uint32_t maxRange = spellbookScreen.getSpellMaxRange(rangeCheckSpellId, assetMgr);
-                if (maxRange > 5) {
-                    auto& em = gameHandler.getEntityManager();
-                    auto playerEnt = em.getEntity(gameHandler.getPlayerGuid());
-                    auto targetEnt = em.getEntity(gameHandler.getTargetGuid());
-                    if (playerEnt && targetEnt) {
-                        float dx = playerEnt->getX() - targetEnt->getX();
-                        float dy = playerEnt->getY() - targetEnt->getY();
-                        float dz = playerEnt->getZ() - targetEnt->getZ();
-                        if (std::sqrt(dx*dx + dy*dy + dz*dz) > static_cast<float>(maxRange))
-                            outOfRange = true;
-                    }
-                }
-            }
-        }
-
-        // Insufficient-power check: tint when player doesn't have enough power to cast.
-        // Applies to SPELL and MACRO slots with a known power cost.
-        bool insufficientPower = false;
-        {
-            uint32_t powerCheckSpellId = 0;
-            if (slot.type == game::ActionBarSlot::SPELL && slot.id != 0)
-                powerCheckSpellId = slot.id;
-            else if (slot.type == game::ActionBarSlot::MACRO && slot.id != 0)
-                powerCheckSpellId = resolveMacroPrimarySpellId(slot.id, gameHandler);
-            uint32_t spellCost = 0, spellPowerType = 0;
-            if (powerCheckSpellId != 0 && !onCooldown)
-                spellbookScreen.getSpellPowerInfo(powerCheckSpellId, assetMgr, spellCost, spellPowerType);
-            if (spellCost > 0) {
-                auto playerEnt = gameHandler.getEntityManager().getEntity(gameHandler.getPlayerGuid());
-                if (playerEnt && (playerEnt->getType() == game::ObjectType::PLAYER ||
-                                  playerEnt->getType() == game::ObjectType::UNIT)) {
-                    auto unit = std::static_pointer_cast<game::Unit>(playerEnt);
-                    if (unit->getPowerType() == static_cast<uint8_t>(spellPowerType)) {
-                        if (unit->getPower() < spellCost)
-                            insufficientPower = true;
-                    }
-                }
-            }
-        }
-
-        auto getSpellName = [&](uint32_t spellId) -> std::string {
-            std::string name = spellbookScreen.lookupSpellName(spellId, assetMgr);
-            if (!name.empty()) return name;
-            return "Spell #" + std::to_string(spellId);
-        };
-
-        // Try to get icon texture for this slot
-        VkDescriptorSet iconTex = VK_NULL_HANDLE;
-        const game::ItemDef* barItemDef = nullptr;
-        uint32_t itemDisplayInfoId = 0;
-        std::string itemNameFromQuery;
-        if (slot.type == game::ActionBarSlot::SPELL && slot.id != 0) {
-            iconTex = getSpellIcon(slot.id, assetMgr);
-        } else if (slot.type == game::ActionBarSlot::ITEM && slot.id != 0) {
-            auto& inv = gameHandler.getInventory();
-            for (int bi = 0; bi < inv.getBackpackSize(); bi++) {
-                const auto& bs = inv.getBackpackSlot(bi);
-                if (!bs.empty() && bs.item.itemId == slot.id) { barItemDef = &bs.item; break; }
-            }
-            if (!barItemDef) {
-                for (int ei = 0; ei < game::Inventory::NUM_EQUIP_SLOTS; ei++) {
-                    const auto& es = inv.getEquipSlot(static_cast<game::EquipSlot>(ei));
-                    if (!es.empty() && es.item.itemId == slot.id) { barItemDef = &es.item; break; }
-                }
-            }
-            if (!barItemDef) {
-                for (int bag = 0; bag < game::Inventory::NUM_BAG_SLOTS && !barItemDef; bag++) {
-                    for (int si = 0; si < inv.getBagSize(bag); si++) {
-                        const auto& bs = inv.getBagSlot(bag, si);
-                        if (!bs.empty() && bs.item.itemId == slot.id) { barItemDef = &bs.item; break; }
-                    }
-                }
-            }
-            if (barItemDef && barItemDef->displayInfoId != 0)
-                itemDisplayInfoId = barItemDef->displayInfoId;
-            if (itemDisplayInfoId == 0) {
-                if (auto* info = gameHandler.getItemInfo(slot.id)) {
-                    itemDisplayInfoId = info->displayInfoId;
-                    if (itemNameFromQuery.empty() && !info->name.empty())
-                        itemNameFromQuery = info->name;
-                }
-            }
-            if (itemDisplayInfoId != 0)
-                iconTex = inventoryScreen.getItemIcon(itemDisplayInfoId);
-        }
-
-        // Macro icon: #showtooltip [SpellName] → show that spell's icon on the button
-        bool macroIsUseCmd = false;  // tracks if the macro's primary command is /use (for item icon fallback)
-        if (slot.type == game::ActionBarSlot::MACRO && slot.id != 0 && !iconTex) {
-            const std::string& macroText = gameHandler.getMacroText(slot.id);
-            if (!macroText.empty()) {
-                std::string showArg = getMacroShowtooltipArg(macroText);
-                if (showArg.empty() || showArg == "__auto__") {
-                    // No explicit #showtooltip arg — derive spell from first /cast, /castsequence, or /use line
-                    for (const auto& cmdLine : allMacroCommands(macroText)) {
-                        if (cmdLine.size() < 6) continue;
-                        std::string cl = cmdLine;
-                        for (char& c : cl) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        bool isCastCmd = (cl.rfind("/cast ", 0) == 0 || cl == "/cast");
-                        bool isCastSeqCmd = (cl.rfind("/castsequence ", 0) == 0);
-                        bool isUseCmd = (cl.rfind("/use ", 0) == 0);
-                        if (isUseCmd) macroIsUseCmd = true;
-                        if (!isCastCmd && !isCastSeqCmd && !isUseCmd) continue;
-                        size_t sp2 = cmdLine.find(' ');
-                        if (sp2 == std::string::npos) continue;
-                        showArg = cmdLine.substr(sp2 + 1);
-                        // Strip conditionals [...]
-                        if (!showArg.empty() && showArg.front() == '[') {
-                            size_t ce = showArg.find(']');
-                            if (ce != std::string::npos) showArg = showArg.substr(ce + 1);
-                        }
-                        // Strip reset= spec for castsequence
-                        if (isCastSeqCmd) {
-                            std::string tmp = showArg;
-                            while (!tmp.empty() && tmp.front() == ' ') tmp.erase(tmp.begin());
-                            if (tmp.rfind("reset=", 0) == 0) {
-                                size_t spA = tmp.find(' ');
-                                if (spA != std::string::npos) showArg = tmp.substr(spA + 1);
-                            }
-                        }
-                        // First alternative: ';' for /cast, ',' for /castsequence
-                        size_t sep = showArg.find(isCastSeqCmd ? ',' : ';');
-                        if (sep != std::string::npos) showArg = showArg.substr(0, sep);
-                        // Trim and strip '!'
-                        size_t ss = showArg.find_first_not_of(" \t!");
-                        if (ss != std::string::npos) showArg = showArg.substr(ss);
-                        size_t se = showArg.find_last_not_of(" \t");
-                        if (se != std::string::npos) showArg.resize(se + 1);
-                        break;
-                    }
-                }
-                // Look up the spell icon by name
-                if (!showArg.empty() && showArg != "__auto__") {
-                    std::string showLower = showArg;
-                    for (char& c : showLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                    // Also strip "(Rank N)" suffix for matching
-                    size_t rankParen = showLower.find('(');
-                    if (rankParen != std::string::npos) showLower.resize(rankParen);
-                    while (!showLower.empty() && showLower.back() == ' ') showLower.pop_back();
-                    for (uint32_t sid : gameHandler.getKnownSpells()) {
-                        const std::string& sn = gameHandler.getSpellName(sid);
-                        if (sn.empty()) continue;
-                        std::string snl = sn;
-                        for (char& c : snl) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        if (snl == showLower) {
-                            iconTex = assetMgr ? getSpellIcon(sid, assetMgr) : VK_NULL_HANDLE;
-                            if (iconTex) break;
-                        }
-                    }
-                    // Fallback for /use macros: if no spell matched, search item cache for the item icon
-                    if (!iconTex && macroIsUseCmd) {
-                        for (const auto& [entry, info] : gameHandler.getItemInfoCache()) {
-                            if (!info.valid) continue;
-                            std::string iName = info.name;
-                            for (char& c : iName) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                            if (iName == showLower && info.displayInfoId != 0) {
-                                iconTex = inventoryScreen.getItemIcon(info.displayInfoId);
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        // Item-missing check: grey out item slots whose item is not in the player's inventory.
-        const bool itemMissing = (slot.type == game::ActionBarSlot::ITEM && slot.id != 0
-                                  && barItemDef == nullptr && !onCooldown);
-
-        // Ranged item out-of-range check (runs after barItemDef is populated above).
-        // invType 15=Ranged (bow/gun/crossbow), 26=Thrown, 28=RangedRight (wand/crossbow).
-        if (!outOfRange && slot.type == game::ActionBarSlot::ITEM && barItemDef
-            && !onCooldown && gameHandler.hasTarget()) {
-            constexpr uint8_t INVTYPE_RANGED      = 15;
-            constexpr uint8_t INVTYPE_THROWN      = 26;
-            constexpr uint8_t INVTYPE_RANGEDRIGHT = 28;
-            uint32_t itemMaxRange = 0;
-            if (barItemDef->inventoryType == INVTYPE_RANGED ||
-                barItemDef->inventoryType == INVTYPE_RANGEDRIGHT)
-                itemMaxRange = 40;
-            else if (barItemDef->inventoryType == INVTYPE_THROWN)
-                itemMaxRange = 30;
-            if (itemMaxRange > 0) {
-                auto& em = gameHandler.getEntityManager();
-                auto playerEnt = em.getEntity(gameHandler.getPlayerGuid());
-                auto targetEnt = em.getEntity(gameHandler.getTargetGuid());
-                if (playerEnt && targetEnt) {
-                    float dx = playerEnt->getX() - targetEnt->getX();
-                    float dy = playerEnt->getY() - targetEnt->getY();
-                    float dz = playerEnt->getZ() - targetEnt->getZ();
-                    if (std::sqrt(dx*dx + dy*dy + dz*dz) > static_cast<float>(itemMaxRange))
-                        outOfRange = true;
-                }
-            }
-        }
-
-        bool clicked = false;
-        if (iconTex) {
-            ImVec4 tintColor(1, 1, 1, 1);
-            ImVec4 bgColor(0.1f, 0.1f, 0.1f, 0.9f);
-            if (onCooldown)          { tintColor = ImVec4(0.4f, 0.4f, 0.4f, 0.8f); }
-            else if (onGCD)          { tintColor = ImVec4(0.6f, 0.6f, 0.6f, 0.85f); }
-            else if (outOfRange)     { tintColor = ImVec4(0.85f, 0.35f, 0.35f, 0.9f); }
-            else if (insufficientPower) { tintColor = ImVec4(0.6f, 0.5f, 0.9f, 0.85f); }
-            else if (itemMissing)    { tintColor = ImVec4(0.35f, 0.35f, 0.35f, 0.7f); }
-            clicked = ImGui::ImageButton("##icon",
-                (ImTextureID)(uintptr_t)iconTex,
-                ImVec2(slotSize, slotSize),
-                ImVec2(0, 0), ImVec2(1, 1),
-                bgColor, tintColor);
-        } else {
-            if (onCooldown)            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.2f, 0.2f, 0.2f, 0.8f));
-            else if (outOfRange)       ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.45f, 0.15f, 0.15f, 0.9f));
-            else if (insufficientPower)ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.2f, 0.15f, 0.4f, 0.9f));
-            else if (itemMissing)      ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.12f, 0.12f, 0.12f, 0.7f));
-            else if (slot.isEmpty())   ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.15f, 0.15f, 0.15f, 0.8f));
-            else                       ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.3f, 0.3f, 0.5f, 0.9f));
-
-            char label[32];
-            if (slot.type == game::ActionBarSlot::SPELL) {
-                std::string spellName = getSpellName(slot.id);
-                if (spellName.size() > 6) spellName = spellName.substr(0, 6);
-                snprintf(label, sizeof(label), "%s", spellName.c_str());
-            } else if (slot.type == game::ActionBarSlot::ITEM && barItemDef) {
-                std::string itemName = barItemDef->name;
-                if (itemName.size() > 6) itemName = itemName.substr(0, 6);
-                snprintf(label, sizeof(label), "%s", itemName.c_str());
-            } else if (slot.type == game::ActionBarSlot::ITEM) {
-                snprintf(label, sizeof(label), "Item");
-            } else if (slot.type == game::ActionBarSlot::MACRO) {
-                snprintf(label, sizeof(label), "Macro");
-            } else {
-                snprintf(label, sizeof(label), "--");
-            }
-            clicked = ImGui::Button(label, ImVec2(slotSize, slotSize));
-            ImGui::PopStyleColor();
-        }
-
-        // Error-flash overlay: red fade on spell cast failure (~0.5 s).
-        // Check both spell slots directly and macro slots via their primary spell.
-        {
-            uint32_t flashSpellId = 0;
-            if (slot.type == game::ActionBarSlot::SPELL && slot.id != 0)
-                flashSpellId = slot.id;
-            else if (slot.type == game::ActionBarSlot::MACRO && slot.id != 0)
-                flashSpellId = resolveMacroPrimarySpellId(slot.id, gameHandler);
-            auto flashIt = (flashSpellId != 0) ? actionFlashEndTimes_.find(flashSpellId) : actionFlashEndTimes_.end();
-            if (flashIt != actionFlashEndTimes_.end()) {
-                float now = static_cast<float>(ImGui::GetTime());
-                float remaining = flashIt->second - now;
-                if (remaining > 0.0f) {
-                    float alpha = remaining / kActionFlashDuration;  // 1→0
-                    ImVec2 rMin = ImGui::GetItemRectMin();
-                    ImVec2 rMax = ImGui::GetItemRectMax();
-                    ImGui::GetWindowDrawList()->AddRectFilled(
-                        rMin, rMax,
-                        ImGui::ColorConvertFloat4ToU32(ImVec4(1.0f, 0.1f, 0.1f, 0.55f * alpha)));
-                } else {
-                    actionFlashEndTimes_.erase(flashIt);
-                }
-            }
-        }
-
-        bool hoveredOnRelease = ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem) &&
-                                ImGui::IsMouseReleased(ImGuiMouseButton_Left);
-
-        if (hoveredOnRelease && spellbookScreen.isDraggingSpell()) {
-            gameHandler.setActionBarSlot(absSlot, game::ActionBarSlot::SPELL,
-                spellbookScreen.getDragSpellId());
-            spellbookScreen.consumeDragSpell();
-        } else if (hoveredOnRelease && inventoryScreen.isHoldingItem()) {
-            const auto& held = inventoryScreen.getHeldItem();
-            gameHandler.setActionBarSlot(absSlot, game::ActionBarSlot::ITEM, held.itemId);
-            inventoryScreen.returnHeldItem(gameHandler.getInventory());
-        } else if (clicked && actionBarDragSlot_ >= 0) {
-            if (absSlot != actionBarDragSlot_) {
-                const auto& dragSrc = bar[actionBarDragSlot_];
-                gameHandler.setActionBarSlot(actionBarDragSlot_, slot.type, slot.id);
-                gameHandler.setActionBarSlot(absSlot, dragSrc.type, dragSrc.id);
-            }
-            actionBarDragSlot_ = -1;
-            actionBarDragIcon_ = 0;
-        } else if (clicked && !slot.isEmpty()) {
-            if (slot.type == game::ActionBarSlot::SPELL && slot.isReady()) {
-                // Check if this spell belongs to an item (e.g., Hearthstone spell 8690).
-                // Item-use spells must go through CMSG_USE_ITEM, not CMSG_CAST_SPELL.
-                uint32_t itemForSpell = gameHandler.getItemIdForSpell(slot.id);
-                if (itemForSpell != 0) {
-                    gameHandler.useItemById(itemForSpell);
-                } else {
-                    uint64_t target = gameHandler.hasTarget() ? gameHandler.getTargetGuid() : 0;
-                    gameHandler.castSpell(slot.id, target);
-                }
-            } else if (slot.type == game::ActionBarSlot::ITEM && slot.id != 0) {
-                gameHandler.useItemById(slot.id);
-            } else if (slot.type == game::ActionBarSlot::MACRO) {
-                chatPanel.executeMacroText(gameHandler, inventoryScreen, spellbookScreen, questLogScreen, gameHandler.getMacroText(slot.id));
-            }
-        }
-
-        // Right-click context menu for non-empty slots
-        if (!slot.isEmpty()) {
-            // Use a unique popup ID per slot so multiple slots don't share state
-            char ctxId[32];
-            snprintf(ctxId, sizeof(ctxId), "##ABCtx%d", absSlot);
-            if (ImGui::BeginPopupContextItem(ctxId)) {
-                if (slot.type == game::ActionBarSlot::SPELL) {
-                    std::string spellName = getSpellName(slot.id);
-                    ImGui::TextDisabled("%s", spellName.c_str());
-                    ImGui::Separator();
-                    if (onCooldown) ImGui::BeginDisabled();
-                    if (ImGui::MenuItem("Cast")) {
-                        uint64_t target = gameHandler.hasTarget() ? gameHandler.getTargetGuid() : 0;
-                        gameHandler.castSpell(slot.id, target);
-                    }
-                    if (onCooldown) ImGui::EndDisabled();
-                } else if (slot.type == game::ActionBarSlot::ITEM) {
-                    const char* iName = (barItemDef && !barItemDef->name.empty())
-                        ? barItemDef->name.c_str()
-                        : (!itemNameFromQuery.empty() ? itemNameFromQuery.c_str() : "Item");
-                    ImGui::TextDisabled("%s", iName);
-                    ImGui::Separator();
-                    if (ImGui::MenuItem("Use")) {
-                        gameHandler.useItemById(slot.id);
-                    }
-                } else if (slot.type == game::ActionBarSlot::MACRO) {
-                    ImGui::TextDisabled("Macro #%u", slot.id);
-                    ImGui::Separator();
-                    if (ImGui::MenuItem("Execute")) {
-                        chatPanel.executeMacroText(gameHandler, inventoryScreen, spellbookScreen, questLogScreen, gameHandler.getMacroText(slot.id));
-                    }
-                    if (ImGui::MenuItem("Edit")) {
-                        const std::string& txt = gameHandler.getMacroText(slot.id);
-                        strncpy(macroEditorBuf_, txt.c_str(), sizeof(macroEditorBuf_) - 1);
-                        macroEditorBuf_[sizeof(macroEditorBuf_) - 1] = '\0';
-                        macroEditorId_   = slot.id;
-                        macroEditorOpen_ = true;
-                    }
-                }
-                ImGui::Separator();
-                if (ImGui::MenuItem("Clear Slot")) {
-                    gameHandler.setActionBarSlot(absSlot, game::ActionBarSlot::EMPTY, 0);
-                }
-                ImGui::EndPopup();
-            }
-        }
-
-        // Tooltip
-        if (ImGui::IsItemHovered() && !slot.isEmpty() && slot.id != 0) {
-            if (slot.type == game::ActionBarSlot::SPELL) {
-                // Use the spellbook's rich tooltip (school, cost, cast time, range, description).
-                // Falls back to the simple name if DBC data isn't loaded yet.
-                ImGui::BeginTooltip();
-                bool richOk = spellbookScreen.renderSpellInfoTooltip(slot.id, gameHandler, assetMgr);
-                if (!richOk) {
-                    ImGui::Text("%s", getSpellName(slot.id).c_str());
-                }
-                // Hearthstone: add location note after the spell tooltip body
-                if (slot.id == 8690) {
-                    uint32_t mapId = 0; glm::vec3 pos;
-                    if (gameHandler.getHomeBind(mapId, pos)) {
-                        std::string homeLocation;
-                        // Zone name (from zoneId stored in bind point)
-                        uint32_t zoneId = gameHandler.getHomeBindZoneId();
-                        if (zoneId != 0) {
-                            homeLocation = gameHandler.getWhoAreaName(zoneId);
-                        }
-                        // Fall back to continent name if zone unavailable
-                        if (homeLocation.empty()) {
-                            switch (mapId) {
-                                case 0:   homeLocation = "Eastern Kingdoms"; break;
-                                case 1:   homeLocation = "Kalimdor"; break;
-                                case 530: homeLocation = "Outland"; break;
-                                case 571: homeLocation = "Northrend"; break;
-                                default:  homeLocation = "Unknown"; break;
-                            }
-                        }
-                        ImGui::TextColored(ImVec4(0.8f, 0.9f, 1.0f, 1.0f),
-                                           "Home: %s", homeLocation.c_str());
-                    }
-                }
-                if (outOfRange) {
-                    ImGui::TextColored(colors::kHostileRed, "Out of range");
-                }
-                if (insufficientPower) {
-                    ImGui::TextColored(ImVec4(0.75f, 0.55f, 1.0f, 1.0f), "Not enough power");
-                }
-                if (onCooldown) {
-                    float cd = slot.cooldownRemaining;
-                    if (cd >= 60.0f)
-                        ImGui::TextColored(kColorRed,
-                            "Cooldown: %d min %d sec", static_cast<int>(cd)/60, static_cast<int>(cd)%60);
-                    else
-                        ImGui::TextColored(kColorRed, "Cooldown: %.1f sec", cd);
-                }
-                ImGui::EndTooltip();
-            } else if (slot.type == game::ActionBarSlot::MACRO) {
-                ImGui::BeginTooltip();
-                // Show the primary spell's rich tooltip (like WoW does for macro buttons)
-                uint32_t macroSpellId = resolveMacroPrimarySpellId(slot.id, gameHandler);
-                bool showedRich = false;
-                if (macroSpellId != 0) {
-                    showedRich = spellbookScreen.renderSpellInfoTooltip(macroSpellId, gameHandler, assetMgr);
-                    if (onCooldown && macroCooldownRemaining > 0.0f) {
-                        float cd = macroCooldownRemaining;
-                        if (cd >= 60.0f)
-                            ImGui::TextColored(kColorRed,
-                                "Cooldown: %d min %d sec", static_cast<int>(cd)/60, static_cast<int>(cd)%60);
-                        else
-                            ImGui::TextColored(kColorRed, "Cooldown: %.1f sec", cd);
-                    }
-                }
-                if (!showedRich) {
-                    // For /use macros: try showing the item tooltip instead
-                    if (macroIsUseCmd) {
-                        const std::string& macroText = gameHandler.getMacroText(slot.id);
-                        // Extract item name from first /use command
-                        for (const auto& cmd : allMacroCommands(macroText)) {
-                            std::string cl = cmd;
-                            for (char& c : cl) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                            if (cl.rfind("/use ", 0) != 0) continue;
-                            size_t sp = cmd.find(' ');
-                            if (sp == std::string::npos) continue;
-                            std::string itemArg = cmd.substr(sp + 1);
-                            while (!itemArg.empty() && itemArg.front() == ' ') itemArg.erase(itemArg.begin());
-                            while (!itemArg.empty() && itemArg.back() == ' ') itemArg.pop_back();
-                            std::string itemLow = itemArg;
-                            for (char& c : itemLow) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                            for (const auto& [entry, info] : gameHandler.getItemInfoCache()) {
-                                if (!info.valid) continue;
-                                std::string iName = info.name;
-                                for (char& c : iName) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                                if (iName == itemLow) {
-                                    inventoryScreen.renderItemTooltip(info);
-                                    showedRich = true;
-                                    break;
-                                }
-                            }
-                            break;
-                        }
-                    }
-                    if (!showedRich) {
-                        ImGui::Text("Macro #%u", slot.id);
-                        const std::string& macroText = gameHandler.getMacroText(slot.id);
-                        if (!macroText.empty()) {
-                            ImGui::Separator();
-                            ImGui::TextUnformatted(macroText.c_str());
-                        } else {
-                            ImGui::TextDisabled("(no text — right-click to Edit)");
-                        }
-                    }
-                }
-                ImGui::EndTooltip();
-            } else if (slot.type == game::ActionBarSlot::ITEM) {
-                ImGui::BeginTooltip();
-                // Prefer full rich tooltip from ItemQueryResponseData (has stats, quality, set info)
-                const auto* itemQueryInfo = gameHandler.getItemInfo(slot.id);
-                if (itemQueryInfo && itemQueryInfo->valid) {
-                    inventoryScreen.renderItemTooltip(*itemQueryInfo);
-                } else if (barItemDef && !barItemDef->name.empty()) {
-                    ImGui::Text("%s", barItemDef->name.c_str());
-                } else if (!itemNameFromQuery.empty()) {
-                    ImGui::Text("%s", itemNameFromQuery.c_str());
-                } else {
-                    ImGui::Text("Item #%u", slot.id);
-                }
-                if (onCooldown) {
-                    float cd = slot.cooldownRemaining;
-                    if (cd >= 60.0f)
-                        ImGui::TextColored(kColorRed,
-                            "Cooldown: %d min %d sec", static_cast<int>(cd)/60, static_cast<int>(cd)%60);
-                    else
-                        ImGui::TextColored(kColorRed, "Cooldown: %.1f sec", cd);
-                }
-                ImGui::EndTooltip();
-            }
-        }
-
-        // Cooldown overlay: WoW-style clock-sweep + time text
-        if (onCooldown) {
-            ImVec2 btnMin = ImGui::GetItemRectMin();
-            ImVec2 btnMax = ImGui::GetItemRectMax();
-            float cx = (btnMin.x + btnMax.x) * 0.5f;
-            float cy = (btnMin.y + btnMax.y) * 0.5f;
-            float r  = (btnMax.x - btnMin.x) * 0.5f;
-            auto* dl = ImGui::GetWindowDrawList();
-
-            // For macros, use the resolved primary spell cooldown instead of the slot's own.
-            float effCdTotal = (macroCooldownTotal > 0.0f) ? macroCooldownTotal : slot.cooldownTotal;
-            float effCdRemaining = (macroCooldownRemaining > 0.0f) ? macroCooldownRemaining : slot.cooldownRemaining;
-            float total       = (effCdTotal > 0.0f) ? effCdTotal : 1.0f;
-            float elapsed     = total - effCdRemaining;
-            float elapsedFrac = std::min(1.0f, std::max(0.0f, elapsed / total));
-            if (elapsedFrac > 0.005f) {
-                constexpr int N_SEGS = 32;
-                float startAngle = -IM_PI * 0.5f;
-                float endAngle   = startAngle + elapsedFrac * 2.0f * IM_PI;
-                float fanR       = r * 1.5f;
-                ImVec2 pts[N_SEGS + 2];
-                pts[0] = ImVec2(cx, cy);
-                for (int s = 0; s <= N_SEGS; ++s) {
-                    float a = startAngle + (endAngle - startAngle) * s / static_cast<float>(N_SEGS);
-                    pts[s + 1] = ImVec2(cx + std::cos(a) * fanR, cy + std::sin(a) * fanR);
-                }
-                dl->AddConvexPolyFilled(pts, N_SEGS + 2, IM_COL32(0, 0, 0, 170));
-            }
-
-            char cdText[16];
-            float cd = effCdRemaining;
-            if (cd >= 3600.0f)    snprintf(cdText, sizeof(cdText), "%dh", static_cast<int>(cd) / 3600);
-            else if (cd >= 60.0f) snprintf(cdText, sizeof(cdText), "%dm%ds", static_cast<int>(cd) / 60, static_cast<int>(cd) % 60);
-            else if (cd >= 5.0f)  snprintf(cdText, sizeof(cdText), "%ds", static_cast<int>(cd));
-            else                  snprintf(cdText, sizeof(cdText), "%.1f", cd);
-            ImVec2 textSize = ImGui::CalcTextSize(cdText);
-            float tx = cx - textSize.x * 0.5f;
-            float ty = cy - textSize.y * 0.5f;
-            dl->AddText(ImVec2(tx + 1.0f, ty + 1.0f), IM_COL32(0, 0, 0, 220), cdText);
-            dl->AddText(ImVec2(tx, ty), IM_COL32(255, 255, 255, 255), cdText);
-        }
-
-        // GCD overlay — subtle dark fan sweep (thinner/lighter than regular cooldown)
-        if (onGCD) {
-            ImVec2 btnMin = ImGui::GetItemRectMin();
-            ImVec2 btnMax = ImGui::GetItemRectMax();
-            float cx = (btnMin.x + btnMax.x) * 0.5f;
-            float cy = (btnMin.y + btnMax.y) * 0.5f;
-            float r  = (btnMax.x - btnMin.x) * 0.5f;
-            auto* dl = ImGui::GetWindowDrawList();
-            float gcdRem   = gameHandler.getGCDRemaining();
-            float gcdTotal = gameHandler.getGCDTotal();
-            if (gcdTotal > 0.0f) {
-                float elapsed     = gcdTotal - gcdRem;
-                float elapsedFrac = std::min(1.0f, std::max(0.0f, elapsed / gcdTotal));
-                if (elapsedFrac > 0.005f) {
-                    constexpr int N_SEGS = 24;
-                    float startAngle = -IM_PI * 0.5f;
-                    float endAngle   = startAngle + elapsedFrac * 2.0f * IM_PI;
-                    float fanR       = r * 1.4f;
-                    ImVec2 pts[N_SEGS + 2];
-                    pts[0] = ImVec2(cx, cy);
-                    for (int s = 0; s <= N_SEGS; ++s) {
-                        float a = startAngle + (endAngle - startAngle) * s / static_cast<float>(N_SEGS);
-                        pts[s + 1] = ImVec2(cx + std::cos(a) * fanR, cy + std::sin(a) * fanR);
-                    }
-                    dl->AddConvexPolyFilled(pts, N_SEGS + 2, IM_COL32(0, 0, 0, 110));
-                }
-            }
-        }
-
-        // Auto-attack active glow — pulsing golden border when slot 6603 (Attack) is toggled on
-        if (slot.type == game::ActionBarSlot::SPELL && slot.id == 6603
-            && gameHandler.isAutoAttacking()) {
-            ImVec2 bMin = ImGui::GetItemRectMin();
-            ImVec2 bMax = ImGui::GetItemRectMax();
-            float pulse = 0.55f + 0.45f * std::sin(static_cast<float>(ImGui::GetTime()) * 5.0f);
-            ImU32 glowCol = IM_COL32(
-                static_cast<int>(255),
-                static_cast<int>(200 * pulse),
-                static_cast<int>(0),
-                static_cast<int>(200 * pulse));
-            ImGui::GetWindowDrawList()->AddRect(bMin, bMax, glowCol, 2.0f, 0, 2.5f);
-        }
-
-        // Item stack count overlay — bottom-right corner of icon
-        if (slot.type == game::ActionBarSlot::ITEM && slot.id != 0) {
-            // Count total of this item across all inventory slots
-            auto& inv = gameHandler.getInventory();
-            int totalCount = 0;
-            for (int bi = 0; bi < inv.getBackpackSize(); bi++) {
-                const auto& bs = inv.getBackpackSlot(bi);
-                if (!bs.empty() && bs.item.itemId == slot.id) totalCount += bs.item.stackCount;
-            }
-            for (int bag = 0; bag < game::Inventory::NUM_BAG_SLOTS; bag++) {
-                for (int si = 0; si < inv.getBagSize(bag); si++) {
-                    const auto& bs = inv.getBagSlot(bag, si);
-                    if (!bs.empty() && bs.item.itemId == slot.id) totalCount += bs.item.stackCount;
-                }
-            }
-            if (totalCount > 0) {
-                char countStr[16];
-                snprintf(countStr, sizeof(countStr), "%d", totalCount);
-                ImVec2 btnMax = ImGui::GetItemRectMax();
-                ImVec2 tsz = ImGui::CalcTextSize(countStr);
-                float cx2 = btnMax.x - tsz.x - 2.0f;
-                float cy2 = btnMax.y - tsz.y - 1.0f;
-                auto* cdl = ImGui::GetWindowDrawList();
-                cdl->AddText(ImVec2(cx2 + 1.0f, cy2 + 1.0f), IM_COL32(0, 0, 0, 200), countStr);
-                cdl->AddText(ImVec2(cx2, cy2),
-                    totalCount <= 1 ? IM_COL32(220, 100, 100, 255) : IM_COL32(255, 255, 255, 255),
-                    countStr);
-            }
-        }
-
-        // Ready glow: animate a gold border for ~1.5s when a cooldown just expires
-        {
-            static std::unordered_map<int, float> slotGlowTimers;    // absSlot -> remaining glow seconds
-            static std::unordered_map<int, bool>  slotWasOnCooldown; // absSlot -> last frame state
-
-            float dt = ImGui::GetIO().DeltaTime;
-            bool wasOnCd = slotWasOnCooldown.count(absSlot) ? slotWasOnCooldown[absSlot] : false;
-
-            // Trigger glow when transitioning from on-cooldown to ready (and slot isn't empty)
-            if (wasOnCd && !onCooldown && !slot.isEmpty()) {
-                slotGlowTimers[absSlot] = 1.5f;
-            }
-            slotWasOnCooldown[absSlot] = onCooldown;
-
-            auto git = slotGlowTimers.find(absSlot);
-            if (git != slotGlowTimers.end() && git->second > 0.0f) {
-                git->second -= dt;
-                float t = git->second / 1.5f; // 1.0 → 0.0 over lifetime
-                // Pulse: bright when fresh, fading out
-                float pulse = std::sin(t * IM_PI * 4.0f) * 0.5f + 0.5f; // 4 pulses
-                uint8_t alpha = static_cast<uint8_t>(200 * t * (0.5f + 0.5f * pulse));
-                if (alpha > 0) {
-                    ImVec2 bMin = ImGui::GetItemRectMin();
-                    ImVec2 bMax = ImGui::GetItemRectMax();
-                    auto* gdl = ImGui::GetWindowDrawList();
-                    // Gold glow border (2px inset, 3px thick)
-                    gdl->AddRect(ImVec2(bMin.x - 2, bMin.y - 2),
-                                 ImVec2(bMax.x + 2, bMax.y + 2),
-                                 IM_COL32(255, 215, 0, alpha), 3.0f, 0, 3.0f);
-                }
-                if (git->second <= 0.0f) slotGlowTimers.erase(git);
-            }
-        }
-
-        // Key label below
-        ImGui::TextDisabled("%s", keyLabel);
-
-        ImGui::PopID();
-        ImGui::EndGroup();
-    };
-
-    // Bar 2 (slots 12-23) — only show if at least one slot is populated
-    if (settingsPanel.pendingShowActionBar2) {
-        bool bar2HasContent = false;
-        for (int i = 0; i < game::GameHandler::SLOTS_PER_BAR; ++i)
-            if (!bar[game::GameHandler::SLOTS_PER_BAR + i].isEmpty()) { bar2HasContent = true; break; }
-
-        float bar2X = barX + settingsPanel.pendingActionBar2OffsetX;
-        float bar2Y = barY - barH - 2.0f + settingsPanel.pendingActionBar2OffsetY;
-        ImGui::SetNextWindowPos(ImVec2(bar2X, bar2Y), ImGuiCond_Always);
-        ImGui::SetNextWindowSize(ImVec2(barW, barH), ImGuiCond_Always);
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(padding, padding));
-        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0.0f, 0.0f));
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-        ImGui::PushStyleColor(ImGuiCol_WindowBg,
-            bar2HasContent ? ImVec4(0.05f, 0.05f, 0.05f, 0.85f) : ImVec4(0.05f, 0.05f, 0.05f, 0.4f));
-        if (ImGui::Begin("##ActionBar2", nullptr, flags)) {
-            for (int i = 0; i < game::GameHandler::SLOTS_PER_BAR; ++i) {
-                if (i > 0) ImGui::SameLine(0, spacing);
-                renderBarSlot(game::GameHandler::SLOTS_PER_BAR + i, keyLabels2[i]);
-            }
-        }
-        ImGui::End();
-        ImGui::PopStyleColor();
-        ImGui::PopStyleVar(4);
-    }
-
-    // Bar 1 (slots 0-11)
-    if (ImGui::Begin("##ActionBar", nullptr, flags)) {
-        for (int i = 0; i < game::GameHandler::SLOTS_PER_BAR; ++i) {
-            if (i > 0) ImGui::SameLine(0, spacing);
-            renderBarSlot(i, keyLabels1[i]);
-        }
-
-        // Macro editor modal — opened by "Edit" in action bar context menus
-        if (macroEditorOpen_) {
-            ImGui::OpenPopup("Edit Macro###MacroEdit");
-            macroEditorOpen_ = false;
-        }
-        if (ImGui::BeginPopupModal("Edit Macro###MacroEdit", nullptr,
-                                   ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse)) {
-            ImGui::Text("Macro #%u  (all lines execute; [cond] Spell; Default supported)", macroEditorId_);
-            ImGui::SetNextItemWidth(320.0f);
-            ImGui::InputTextMultiline("##MacroText", macroEditorBuf_, sizeof(macroEditorBuf_),
-                                      ImVec2(320.0f, 80.0f));
-            if (ImGui::Button("Save")) {
-                gameHandler.setMacroText(macroEditorId_, std::string(macroEditorBuf_));
-                macroPrimarySpellCache_.clear();  // invalidate resolved spell IDs
-                ImGui::CloseCurrentPopup();
-            }
-            ImGui::SameLine();
-            if (ImGui::Button("Cancel")) {
-                ImGui::CloseCurrentPopup();
-            }
-            ImGui::EndPopup();
-        }
-    }
-    ImGui::End();
-
-    ImGui::PopStyleColor();
-    ImGui::PopStyleVar(4);
-
-    // Right side vertical bar (bar 3, slots 24-35)
-    if (settingsPanel.pendingShowRightBar) {
-        bool bar3HasContent = false;
-        for (int i = 0; i < game::GameHandler::SLOTS_PER_BAR; ++i)
-            if (!bar[game::GameHandler::SLOTS_PER_BAR * 2 + i].isEmpty()) { bar3HasContent = true; break; }
-
-        float sideBarW = slotSize + padding * 2;
-        float sideBarH = game::GameHandler::SLOTS_PER_BAR * slotSize + (game::GameHandler::SLOTS_PER_BAR - 1) * spacing + padding * 2;
-        float sideBarX = screenW - sideBarW - 4.0f;
-        float sideBarY = (screenH - sideBarH) / 2.0f + settingsPanel.pendingRightBarOffsetY;
-
-        ImGui::SetNextWindowPos(ImVec2(sideBarX, sideBarY), ImGuiCond_Always);
-        ImGui::SetNextWindowSize(ImVec2(sideBarW, sideBarH), ImGuiCond_Always);
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(padding, padding));
-        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0.0f, 0.0f));
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-        ImGui::PushStyleColor(ImGuiCol_WindowBg,
-            bar3HasContent ? ImVec4(0.05f, 0.05f, 0.05f, 0.85f) : ImVec4(0.05f, 0.05f, 0.05f, 0.4f));
-        if (ImGui::Begin("##ActionBarRight", nullptr, flags)) {
-            for (int i = 0; i < game::GameHandler::SLOTS_PER_BAR; ++i) {
-                renderBarSlot(game::GameHandler::SLOTS_PER_BAR * 2 + i, "");
-            }
-        }
-        ImGui::End();
-        ImGui::PopStyleColor();
-        ImGui::PopStyleVar(4);
-    }
-
-    // Left side vertical bar (bar 4, slots 36-47)
-    if (settingsPanel.pendingShowLeftBar) {
-        bool bar4HasContent = false;
-        for (int i = 0; i < game::GameHandler::SLOTS_PER_BAR; ++i)
-            if (!bar[game::GameHandler::SLOTS_PER_BAR * 3 + i].isEmpty()) { bar4HasContent = true; break; }
-
-        float sideBarW = slotSize + padding * 2;
-        float sideBarH = game::GameHandler::SLOTS_PER_BAR * slotSize + (game::GameHandler::SLOTS_PER_BAR - 1) * spacing + padding * 2;
-        float sideBarX = 4.0f;
-        float sideBarY = (screenH - sideBarH) / 2.0f + settingsPanel.pendingLeftBarOffsetY;
-
-        ImGui::SetNextWindowPos(ImVec2(sideBarX, sideBarY), ImGuiCond_Always);
-        ImGui::SetNextWindowSize(ImVec2(sideBarW, sideBarH), ImGuiCond_Always);
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(padding, padding));
-        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0.0f, 0.0f));
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-        ImGui::PushStyleColor(ImGuiCol_WindowBg,
-            bar4HasContent ? ImVec4(0.05f, 0.05f, 0.05f, 0.85f) : ImVec4(0.05f, 0.05f, 0.05f, 0.4f));
-        if (ImGui::Begin("##ActionBarLeft", nullptr, flags)) {
-            for (int i = 0; i < game::GameHandler::SLOTS_PER_BAR; ++i) {
-                renderBarSlot(game::GameHandler::SLOTS_PER_BAR * 3 + i, "");
-            }
-        }
-        ImGui::End();
-        ImGui::PopStyleColor();
-        ImGui::PopStyleVar(4);
-    }
-
-    // Vehicle exit button (WotLK): floating button above action bar when player is in a vehicle
-    if (gameHandler.isInVehicle()) {
-        const float btnW = 120.0f;
-        const float btnH = 32.0f;
-        const float btnX = (screenW - btnW) / 2.0f;
-        const float btnY = barY - btnH - 6.0f;
-
-        ImGui::SetNextWindowPos(ImVec2(btnX, btnY), ImGuiCond_Always);
-        ImGui::SetNextWindowSize(ImVec2(btnW, btnH), ImGuiCond_Always);
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(4.0f, 4.0f));
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-        ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.0f, 0.0f, 0.0f, 0.0f));
-        ImGuiWindowFlags vFlags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-                                  ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
-                                  ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoBackground;
-        if (ImGui::Begin("##VehicleExit", nullptr, vFlags)) {
-            ImGui::PushStyleColor(ImGuiCol_Button,        ImVec4(0.6f, 0.1f, 0.1f, 0.9f));
-            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colors::kLowHealthRed);
-            ImGui::PushStyleColor(ImGuiCol_ButtonActive,  ImVec4(0.4f, 0.0f, 0.0f, 1.0f));
-            ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 4.0f);
-            if (ImGui::Button("Leave Vehicle", ImVec2(btnW - 8.0f, btnH - 8.0f))) {
-                gameHandler.sendRequestVehicleExit();
-            }
-            ImGui::PopStyleVar();
-            ImGui::PopStyleColor(3);
-        }
-        ImGui::End();
-        ImGui::PopStyleColor();
-        ImGui::PopStyleVar(3);
-    }
-
-    // Handle action bar drag: render icon at cursor and detect drop outside
-    if (actionBarDragSlot_ >= 0) {
-        ImVec2 mousePos = ImGui::GetMousePos();
-
-        // Draw dragged icon at cursor
-        if (actionBarDragIcon_) {
-            ImGui::GetForegroundDrawList()->AddImage(
-                (ImTextureID)(uintptr_t)actionBarDragIcon_,
-                ImVec2(mousePos.x - 20, mousePos.y - 20),
-                ImVec2(mousePos.x + 20, mousePos.y + 20));
-        } else {
-            ImGui::GetForegroundDrawList()->AddRectFilled(
-                ImVec2(mousePos.x - 20, mousePos.y - 20),
-                ImVec2(mousePos.x + 20, mousePos.y + 20),
-                IM_COL32(80, 80, 120, 180));
-        }
-
-        // On right mouse release, check if outside the action bar area
-        if (ImGui::IsMouseReleased(ImGuiMouseButton_Right)) {
-            bool insideBar = (mousePos.x >= barX && mousePos.x <= barX + barW &&
-                              mousePos.y >= barY && mousePos.y <= barY + barH);
-            if (!insideBar) {
-                // Dropped outside - clear the slot
-                gameHandler.setActionBarSlot(actionBarDragSlot_, game::ActionBarSlot::EMPTY, 0);
-            }
-            actionBarDragSlot_ = -1;
-            actionBarDragIcon_ = 0;
-        }
-    }
-}
-
-void ActionBarPanel::renderStanceBar(game::GameHandler& gameHandler,
-                             SettingsPanel& settingsPanel,
-                             SpellbookScreen& spellbookScreen,
-                             SpellIconFn getSpellIcon) {
-    uint8_t playerClass = gameHandler.getPlayerClass();
-
-    // Stance/form spell IDs per class (ordered by display priority)
-    // Class IDs: 1=Warrior, 4=Rogue, 5=Priest, 6=DeathKnight, 11=Druid
-    static const uint32_t warriorStances[]  = { 2457, 71, 2458 };        // Battle, Defensive, Berserker
-    static const uint32_t dkPresences[]     = { 48266, 48263, 48265 };   // Blood, Frost, Unholy
-    static const uint32_t druidForms[]      = { 5487, 9634, 768, 783, 1066, 24858, 33891, 33943, 40120 };
-    //                                           Bear, DireBear, Cat, Travel, Aquatic, Moonkin, Tree, Flight, SwiftFlight
-    static const uint32_t rogueForms[]      = { 1784 };  // Stealth
-    static const uint32_t priestForms[]     = { 15473 }; // Shadowform
-
-    const uint32_t* stanceArr = nullptr;
-    int stanceCount = 0;
-    switch (playerClass) {
-        case 1:  stanceArr = warriorStances; stanceCount = 3; break;
-        case 6:  stanceArr = dkPresences;    stanceCount = 3; break;
-        case 11: stanceArr = druidForms;     stanceCount = 9; break;
-        case 4:  stanceArr = rogueForms;     stanceCount = 1; break;
-        case 5:  stanceArr = priestForms;    stanceCount = 1; break;
-        default: return;
-    }
-
-    // Filter to spells the player actually knows
-    const auto& known = gameHandler.getKnownSpells();
-    std::vector<uint32_t> available;
-    available.reserve(stanceCount);
-    for (int i = 0; i < stanceCount; ++i)
-        if (known.count(stanceArr[i])) available.push_back(stanceArr[i]);
-
-    if (available.empty()) return;
-
-    // Detect active stance from permanent player auras (maxDurationMs == -1)
-    uint32_t activeStance = 0;
-    for (const auto& aura : gameHandler.getPlayerAuras()) {
-        if (aura.isEmpty() || aura.maxDurationMs != -1) continue;
-        for (uint32_t sid : available) {
-            if (aura.spellId == sid) { activeStance = sid; break; }
-        }
-        if (activeStance) break;
-    }
-
-    ImVec2 displaySize = ImGui::GetIO().DisplaySize;
-    float screenW = displaySize.x > 0.0f ? displaySize.x : 1280.0f;
-    float screenH = displaySize.y > 0.0f ? displaySize.y : 720.0f;
-    auto* assetMgr = services_.assetManager;
-
-    // Match the action bar slot size so they align neatly
-    float slotSize = 38.0f;
-    float spacing  = 4.0f;
-    float padding  = 6.0f;
-    int   count    = static_cast<int>(available.size());
-
-    float barW = count * slotSize + (count - 1) * spacing + padding * 2.0f;
-    float barH = slotSize + padding * 2.0f;
-
-    // Position the stance bar immediately to the left of the action bar
-    float actionSlot = 48.0f * settingsPanel.pendingActionBarScale;
-    float actionBarW = 12.0f * actionSlot + 11.0f * 4.0f + 8.0f * 2.0f;
-    float actionBarX = (screenW - actionBarW) / 2.0f;
-    float actionBarH = actionSlot + 24.0f;
-    float actionBarY = screenH - actionBarH;
-
-    float barX = actionBarX - barW - 8.0f;
-    float barY = actionBarY + (actionBarH - barH) / 2.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(barX, barY), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(barW, barH), ImGuiCond_Always);
-
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
-                             ImGuiWindowFlags_NoScrollbar;
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(padding, padding));
-    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0.0f, 0.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.05f, 0.05f, 0.05f, 0.9f));
-
-    if (ImGui::Begin("##StanceBar", nullptr, flags)) {
-        ImDrawList* dl = ImGui::GetWindowDrawList();
-
-        for (int i = 0; i < count; ++i) {
-            if (i > 0) ImGui::SameLine(0.0f, spacing);
-            ImGui::PushID(i);
-
-            uint32_t spellId = available[i];
-            bool isActive = (spellId == activeStance);
-
-            VkDescriptorSet iconTex = assetMgr ? getSpellIcon(spellId, assetMgr) : VK_NULL_HANDLE;
-
-            ImVec2 pos = ImGui::GetCursorScreenPos();
-            ImVec2 posEnd = ImVec2(pos.x + slotSize, pos.y + slotSize);
-
-            // Background — green tint when active
-            ImU32 bgCol     = isActive ? IM_COL32(30, 70, 30, 230) : IM_COL32(20, 20, 20, 220);
-            ImU32 borderCol = isActive ? IM_COL32(80, 220, 80, 255) : IM_COL32(80, 80, 80, 200);
-            dl->AddRectFilled(pos, posEnd, bgCol, 4.0f);
-
-            if (iconTex) {
-                dl->AddImage((ImTextureID)(uintptr_t)iconTex, pos, posEnd);
-                // Darken inactive buttons slightly
-                if (!isActive)
-                    dl->AddRectFilled(pos, posEnd, IM_COL32(0, 0, 0, 70), 4.0f);
-            }
-            dl->AddRect(pos, posEnd, borderCol, 4.0f, 0, 2.0f);
-
-            ImGui::InvisibleButton("##btn", ImVec2(slotSize, slotSize));
-
-            if (ImGui::IsItemClicked(ImGuiMouseButton_Left))
-                gameHandler.castSpell(spellId);
-
-            if (ImGui::IsItemHovered()) {
-                ImGui::BeginTooltip();
-                std::string name = spellbookScreen.lookupSpellName(spellId, assetMgr);
-                if (!name.empty()) ImGui::TextUnformatted(name.c_str());
-                else               ImGui::Text("Spell #%u", spellId);
-                ImGui::EndTooltip();
-            }
-
-            ImGui::PopID();
-        }
-    }
-    ImGui::End();
-    ImGui::PopStyleColor();
-    ImGui::PopStyleVar(4);
-}
-
-void ActionBarPanel::renderBagBar(game::GameHandler& gameHandler,
-                         SettingsPanel& /*settingsPanel*/,
-                         InventoryScreen& inventoryScreen) {
-    ImVec2 displaySize = ImGui::GetIO().DisplaySize;
-    float screenW = displaySize.x > 0.0f ? displaySize.x : 1280.0f;
-    float screenH = displaySize.y > 0.0f ? displaySize.y : 720.0f;
-    auto* assetMgr = services_.assetManager;
-
-    float slotSize = 42.0f;
-    float spacing = 4.0f;
-    float padding = 6.0f;
-
-    // 5 slots: backpack + 4 bags
-    float barW = 5 * slotSize + 4 * spacing + padding * 2;
-    float barH = slotSize + padding * 2;
-
-    // Position in bottom right corner
-    float barX = screenW - barW - 10.0f;
-    float barY = screenH - barH - 10.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(barX, barY), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(barW, barH), ImGuiCond_Always);
-
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
-                             ImGuiWindowFlags_NoScrollbar;
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(padding, padding));
-    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0.0f, 0.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.05f, 0.05f, 0.05f, 0.9f));
-
-    if (ImGui::Begin("##BagBar", nullptr, flags)) {
-        auto& inv = gameHandler.getInventory();
-
-        // Load backpack icon if needed
-        if (!backpackIconTexture_ && assetMgr && assetMgr->isInitialized()) {
-            auto blpData = assetMgr->readFile("Interface\\Buttons\\Button-Backpack-Up.blp");
-            if (!blpData.empty()) {
-                auto image = pipeline::BLPLoader::load(blpData);
-                if (image.isValid()) {
-                    auto* w = services_.window;
-                    auto* vkCtx = w ? w->getVkContext() : nullptr;
-                    if (vkCtx)
-                        backpackIconTexture_ = vkCtx->uploadImGuiTexture(image.data.data(), image.width, image.height);
-                }
-            }
-        }
-
-        // Track bag slot screen rects for drop detection
-        ImVec2 bagSlotMins[4], bagSlotMaxs[4];
-
-        // Slots 1-4: Bag slots (leftmost)
-        for (int i = 0; i < 4; ++i) {
-            if (i > 0) ImGui::SameLine(0, spacing);
-            ImGui::PushID(i + 1);
-
-            game::EquipSlot bagSlot = static_cast<game::EquipSlot>(static_cast<int>(game::EquipSlot::BAG1) + i);
-            const auto& bagItem = inv.getEquipSlot(bagSlot);
-
-            VkDescriptorSet bagIcon = VK_NULL_HANDLE;
-            if (!bagItem.empty() && bagItem.item.displayInfoId != 0) {
-                bagIcon = inventoryScreen.getItemIcon(bagItem.item.displayInfoId);
-            }
-            // Render the slot as an invisible button so we control all interaction
-            ImVec2 cpos = ImGui::GetCursorScreenPos();
-            ImGui::InvisibleButton("##bagSlot", ImVec2(slotSize, slotSize));
-            bagSlotMins[i] = cpos;
-            bagSlotMaxs[i] = ImVec2(cpos.x + slotSize, cpos.y + slotSize);
-
-            ImDrawList* dl = ImGui::GetWindowDrawList();
-
-            // Draw background + icon
-            if (bagIcon) {
-                dl->AddRectFilled(bagSlotMins[i], bagSlotMaxs[i], IM_COL32(25, 25, 25, 230));
-                dl->AddImage((ImTextureID)(uintptr_t)bagIcon, bagSlotMins[i], bagSlotMaxs[i]);
-            } else {
-                dl->AddRectFilled(bagSlotMins[i], bagSlotMaxs[i], IM_COL32(38, 38, 38, 204));
-            }
-
-            // Hover highlight
-            bool hovered = ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem);
-            if (hovered && bagBarPickedSlot_ < 0) {
-                dl->AddRect(bagSlotMins[i], bagSlotMaxs[i], IM_COL32(255, 255, 255, 100));
-            }
-
-            // Track which slot was pressed for drag detection
-            if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left) && bagBarPickedSlot_ < 0 && bagIcon) {
-                bagBarDragSource_ = i;
-            }
-
-            // Click toggles bag open/close (handled in mouse release section below)
-
-            // Dim the slot being dragged
-            if (bagBarPickedSlot_ == i) {
-                dl->AddRectFilled(bagSlotMins[i], bagSlotMaxs[i], IM_COL32(0, 0, 0, 150));
-            }
-
-            // Tooltip
-            if (hovered && bagBarPickedSlot_ < 0) {
-                if (bagIcon)
-                    ImGui::SetTooltip("%s", bagItem.item.name.c_str());
-                else
-                    ImGui::SetTooltip("Empty Bag Slot");
-            }
-
-            // Open bag indicator
-            if (inventoryScreen.isSeparateBags() && inventoryScreen.isBagOpen(i)) {
-                dl->AddRect(bagSlotMins[i], bagSlotMaxs[i], IM_COL32(255, 255, 255, 255), 3.0f, 0, 2.0f);
-            }
-
-            // Right-click context menu
-            if (ImGui::BeginPopupContextItem("##bagSlotCtx")) {
-                if (!bagItem.empty()) {
-                    ImGui::TextDisabled("%s", bagItem.item.name.c_str());
-                    ImGui::Separator();
-                    bool isOpen = inventoryScreen.isSeparateBags() && inventoryScreen.isBagOpen(i);
-                    if (ImGui::MenuItem(isOpen ? "Close Bag" : "Open Bag")) {
-                        if (inventoryScreen.isSeparateBags())
-                            inventoryScreen.toggleBag(i);
-                        else
-                            inventoryScreen.toggle();
-                    }
-                    if (ImGui::MenuItem("Unequip Bag")) {
-                        gameHandler.unequipToBackpack(bagSlot);
-                    }
-                } else {
-                    ImGui::TextDisabled("Empty Bag Slot");
-                }
-                ImGui::EndPopup();
-            }
-
-            // Accept dragged item from inventory
-            if (hovered && inventoryScreen.isHoldingItem()) {
-                const auto& heldItem = inventoryScreen.getHeldItem();
-                if ((heldItem.inventoryType == 18 || heldItem.bagSlots > 0) &&
-                    ImGui::IsMouseReleased(ImGuiMouseButton_Left)) {
-                    auto& inventory = gameHandler.getInventory();
-                    inventoryScreen.dropHeldItemToEquipSlot(inventory, bagSlot);
-                }
-            }
-
-            ImGui::PopID();
-        }
-
-        // Drag lifecycle: press on a slot sets bagBarDragSource_,
-        // dragging 3+ pixels promotes to bagBarPickedSlot_ (visual drag),
-        // releasing completes swap or click
-        if (bagBarDragSource_ >= 0) {
-            if (ImGui::IsMouseDragging(ImGuiMouseButton_Left, 3.0f) && bagBarPickedSlot_ < 0) {
-                // If an inventory window is open, hand off drag to inventory held-item
-                // so the bag can be dropped into backpack/bag slots.
-                if (inventoryScreen.isOpen() || inventoryScreen.isCharacterOpen()) {
-                    auto equip = static_cast<game::EquipSlot>(
-                        static_cast<int>(game::EquipSlot::BAG1) + bagBarDragSource_);
-                    if (inventoryScreen.beginPickupFromEquipSlot(inv, equip)) {
-                        bagBarDragSource_ = -1;
-                    } else {
-                        bagBarPickedSlot_ = bagBarDragSource_;
-                    }
-                } else {
-                    // Mouse moved enough — start visual drag
-                    bagBarPickedSlot_ = bagBarDragSource_;
-                }
-            }
-            if (ImGui::IsMouseReleased(ImGuiMouseButton_Left)) {
-                if (bagBarPickedSlot_ >= 0) {
-                    // Was dragging — check for drop target
-                    ImVec2 mousePos = ImGui::GetIO().MousePos;
-                    int dropTarget = -1;
-                    for (int j = 0; j < 4; ++j) {
-                        if (j == bagBarPickedSlot_) continue;
-                        if (mousePos.x >= bagSlotMins[j].x && mousePos.x <= bagSlotMaxs[j].x &&
-                            mousePos.y >= bagSlotMins[j].y && mousePos.y <= bagSlotMaxs[j].y) {
-                            dropTarget = j;
-                            break;
-                        }
-                    }
-                    if (dropTarget >= 0) {
-                        gameHandler.swapBagSlots(bagBarPickedSlot_, dropTarget);
-                    }
-                    bagBarPickedSlot_ = -1;
-                } else {
-                    // Was just a click (no drag) — toggle bag
-                    int slot = bagBarDragSource_;
-                    auto equip = static_cast<game::EquipSlot>(static_cast<int>(game::EquipSlot::BAG1) + slot);
-                    if (!inv.getEquipSlot(equip).empty()) {
-                        if (inventoryScreen.isSeparateBags())
-                            inventoryScreen.toggleBag(slot);
-                        else
-                            inventoryScreen.toggle();
-                    }
-                }
-                bagBarDragSource_ = -1;
-            }
-        }
-
-        // Backpack (rightmost slot)
-        ImGui::SameLine(0, spacing);
-        ImGui::PushID(0);
-        if (backpackIconTexture_) {
-            if (ImGui::ImageButton("##backpack", (ImTextureID)(uintptr_t)backpackIconTexture_,
-                                   ImVec2(slotSize, slotSize),
-                                   ImVec2(0, 0), ImVec2(1, 1),
-                                   ImVec4(0.1f, 0.1f, 0.1f, 0.9f),
-                                   colors::kWhite)) {
-                if (inventoryScreen.isSeparateBags())
-                    inventoryScreen.toggleBackpack();
-                else
-                    inventoryScreen.toggle();
-            }
-        } else {
-            if (ImGui::Button("B", ImVec2(slotSize, slotSize))) {
-                if (inventoryScreen.isSeparateBags())
-                    inventoryScreen.toggleBackpack();
-                else
-                    inventoryScreen.toggle();
-            }
-        }
-        if (ImGui::IsItemHovered()) {
-            ImGui::SetTooltip("Backpack");
-        }
-        // Right-click context menu on backpack
-        if (ImGui::BeginPopupContextItem("##backpackCtx")) {
-            bool isOpen = inventoryScreen.isSeparateBags() && inventoryScreen.isBackpackOpen();
-            if (ImGui::MenuItem(isOpen ? "Close Backpack" : "Open Backpack")) {
-                if (inventoryScreen.isSeparateBags())
-                    inventoryScreen.toggleBackpack();
-                else
-                    inventoryScreen.toggle();
-            }
-            ImGui::Separator();
-            if (ImGui::MenuItem("Open All Bags")) {
-                inventoryScreen.openAllBags();
-            }
-            if (ImGui::MenuItem("Close All Bags")) {
-                inventoryScreen.closeAllBags();
-            }
-            ImGui::EndPopup();
-        }
-        if (inventoryScreen.isSeparateBags() &&
-            inventoryScreen.isBackpackOpen()) {
-            ImDrawList* dl = ImGui::GetWindowDrawList();
-            ImVec2 r0 = ImGui::GetItemRectMin();
-            ImVec2 r1 = ImGui::GetItemRectMax();
-            dl->AddRect(r0, r1, IM_COL32(255, 255, 255, 255), 3.0f, 0, 2.0f);
-        }
-        ImGui::PopID();
-
-    }
-    ImGui::End();
-
-    ImGui::PopStyleColor();
-    ImGui::PopStyleVar(4);
-
-    // Draw dragged bag icon following cursor
-    if (bagBarPickedSlot_ >= 0) {
-        auto& inv2 = gameHandler.getInventory();
-        auto pickedEquip = static_cast<game::EquipSlot>(
-            static_cast<int>(game::EquipSlot::BAG1) + bagBarPickedSlot_);
-        const auto& pickedItem = inv2.getEquipSlot(pickedEquip);
-        VkDescriptorSet pickedIcon = VK_NULL_HANDLE;
-        if (!pickedItem.empty() && pickedItem.item.displayInfoId != 0) {
-            pickedIcon = inventoryScreen.getItemIcon(pickedItem.item.displayInfoId);
-        }
-        if (pickedIcon) {
-            ImVec2 mousePos = ImGui::GetIO().MousePos;
-            float sz = 40.0f;
-            ImVec2 p0(mousePos.x - sz * 0.5f, mousePos.y - sz * 0.5f);
-            ImVec2 p1(mousePos.x + sz * 0.5f, mousePos.y + sz * 0.5f);
-            ImDrawList* fg = ImGui::GetForegroundDrawList();
-            fg->AddImage((ImTextureID)(uintptr_t)pickedIcon, p0, p1);
-            fg->AddRect(p0, p1, IM_COL32(200, 200, 200, 255), 0.0f, 0, 2.0f);
-        }
-    }
-}
-
-void ActionBarPanel::renderXpBar(game::GameHandler& gameHandler,
-                        SettingsPanel& settingsPanel) {
-    uint32_t nextLevelXp  = gameHandler.getPlayerNextLevelXp();
-    uint32_t playerLevel  = gameHandler.getPlayerLevel();
-    // At max level, server sends nextLevelXp=0. Only skip entirely when we have
-    // no level info at all (not yet logged in / no update-field data).
-    const bool isMaxLevel = (nextLevelXp == 0 && playerLevel > 0);
-    if (nextLevelXp == 0 && !isMaxLevel) return;
-
-    uint32_t currentXp  = gameHandler.getPlayerXp();
-    uint32_t restedXp   = gameHandler.getPlayerRestedXp();
-    bool     isResting  = gameHandler.isPlayerResting();
-    ImVec2 displaySize = ImGui::GetIO().DisplaySize;
-    float screenW = displaySize.x > 0.0f ? displaySize.x : 1280.0f;
-    float screenH = displaySize.y > 0.0f ? displaySize.y : 720.0f;
-    auto* window = services_.window;
-    (void)window;  // Not used for positioning; kept for AssetManager if needed
-
-    // Position just above both action bars (bar1 at screenH-barH, bar2 above that)
-    float slotSize = 48.0f * settingsPanel.pendingActionBarScale;
-    float spacing = 4.0f;
-    float padding = 8.0f;
-    float barW = 12 * slotSize + 11 * spacing + padding * 2;
-    float barH = slotSize + 24.0f;
-
-    float xpBarH = 20.0f;
-    float xpBarW = barW;
-    float xpBarX = (screenW - xpBarW) / 2.0f;
-    // XP bar sits just above whichever bar is topmost.
-    // bar1 top edge: screenH - barH
-    // bar2 top edge (when visible): bar1 top - barH - 2 + bar2 vertical offset
-    float bar1TopY = screenH - barH;
-    float xpBarY;
-    if (settingsPanel.pendingShowActionBar2) {
-        float bar2TopY = bar1TopY - barH - 2.0f + settingsPanel.pendingActionBar2OffsetY;
-        xpBarY = bar2TopY - xpBarH - 2.0f;
-    } else {
-        xpBarY = bar1TopY - xpBarH - 2.0f;
-    }
-
-    ImGui::SetNextWindowPos(ImVec2(xpBarX, xpBarY), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(xpBarW, xpBarH + 4.0f), ImGuiCond_Always);
-
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
-                             ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_AlwaysAutoResize;
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 2.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(2.0f, 2.0f));
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.05f, 0.05f, 0.05f, 0.9f));
-    ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.3f, 0.3f, 0.3f, 0.8f));
-
-    if (ImGui::Begin("##XpBar", nullptr, flags)) {
-        ImVec2 barMin  = ImGui::GetCursorScreenPos();
-        ImVec2 barSize = ImVec2(ImGui::GetContentRegionAvail().x, xpBarH - 4.0f);
-        ImVec2 barMax  = ImVec2(barMin.x + barSize.x, barMin.y + barSize.y);
-        auto*  drawList = ImGui::GetWindowDrawList();
-
-        if (isMaxLevel) {
-            // Max-level bar: fully filled in muted gold with "Max Level" label
-            ImU32 bgML  = IM_COL32(15, 12, 5, 220);
-            ImU32 fgML  = IM_COL32(180, 140, 40, 200);
-            drawList->AddRectFilled(barMin, barMax, bgML, 2.0f);
-            drawList->AddRectFilled(barMin, barMax, fgML, 2.0f);
-            drawList->AddRect(barMin, barMax, IM_COL32(100, 80, 20, 220), 2.0f);
-            const char* mlLabel = "Max Level";
-            ImVec2 mlSz = ImGui::CalcTextSize(mlLabel);
-            drawList->AddText(
-                ImVec2(barMin.x + (barSize.x - mlSz.x) * 0.5f,
-                       barMin.y + (barSize.y - mlSz.y) * 0.5f),
-                IM_COL32(255, 230, 120, 255), mlLabel);
-            ImGui::Dummy(barSize);
-            if (ImGui::IsItemHovered())
-                ImGui::SetTooltip("Level %u — Maximum level reached", playerLevel);
-        } else {
-        float pct = static_cast<float>(currentXp) / static_cast<float>(nextLevelXp);
-        if (pct > 1.0f) pct = 1.0f;
-
-        // Custom segmented XP bar (20 bubbles)
-        ImU32 bg      = IM_COL32(15, 15, 20, 220);
-        ImU32 fg      = IM_COL32(148, 51, 238, 255);
-        ImU32 fgRest  = IM_COL32(200, 170, 255, 220); // lighter purple for rested portion
-        ImU32 seg     = IM_COL32(35, 35, 45, 255);
-        drawList->AddRectFilled(barMin, barMax, bg, 2.0f);
-        drawList->AddRect(barMin, barMax, IM_COL32(80, 80, 90, 220), 2.0f);
-
-        float fillW = barSize.x * pct;
-        if (fillW > 0.0f) {
-            drawList->AddRectFilled(barMin, ImVec2(barMin.x + fillW, barMax.y), fg, 2.0f);
-        }
-
-        // Rested XP overlay: draw from current XP fill to (currentXp + restedXp) fill
-        if (restedXp > 0) {
-            float restedEndPct = std::min(1.0f, static_cast<float>(currentXp + restedXp)
-                                                / static_cast<float>(nextLevelXp));
-            float restedStartX = barMin.x + fillW;
-            float restedEndX   = barMin.x + barSize.x * restedEndPct;
-            if (restedEndX > restedStartX) {
-                drawList->AddRectFilled(ImVec2(restedStartX, barMin.y),
-                                        ImVec2(restedEndX,   barMax.y),
-                                        fgRest, 2.0f);
-            }
-        }
-
-        const int segments = 20;
-        float segW = barSize.x / static_cast<float>(segments);
-        for (int i = 1; i < segments; ++i) {
-            float x = barMin.x + segW * i;
-            drawList->AddLine(ImVec2(x, barMin.y + 1.0f), ImVec2(x, barMax.y - 1.0f), seg, 1.0f);
-        }
-
-        // Rest indicator "zzz" to the right of the bar when resting
-        if (isResting) {
-            const char* zzz = "zzz";
-            ImVec2 zSize = ImGui::CalcTextSize(zzz);
-            float zx = barMax.x - zSize.x - 4.0f;
-            float zy = barMin.y + (barSize.y - zSize.y) * 0.5f;
-            drawList->AddText(ImVec2(zx, zy), IM_COL32(180, 150, 255, 220), zzz);
-        }
-
-        char overlay[96];
-        if (restedXp > 0) {
-            snprintf(overlay, sizeof(overlay), "%u / %u XP  (+%u rested)", currentXp, nextLevelXp, restedXp);
-        } else {
-            snprintf(overlay, sizeof(overlay), "%u / %u XP", currentXp, nextLevelXp);
-        }
-        ImVec2 textSize = ImGui::CalcTextSize(overlay);
-        float tx = barMin.x + (barSize.x - textSize.x) * 0.5f;
-        float ty = barMin.y + (barSize.y - textSize.y) * 0.5f;
-        drawList->AddText(ImVec2(tx, ty), IM_COL32(230, 230, 230, 255), overlay);
-
-        ImGui::Dummy(barSize);
-
-        // Tooltip with XP-to-level and rested details
-        if (ImGui::IsItemHovered()) {
-            ImGui::BeginTooltip();
-            uint32_t xpToLevel = (currentXp < nextLevelXp) ? (nextLevelXp - currentXp) : 0;
-            ImGui::TextColored(ImVec4(0.9f, 0.85f, 1.0f, 1.0f), "Experience");
-            ImGui::Separator();
-            float xpPct = nextLevelXp > 0 ? (100.0f * currentXp / nextLevelXp) : 0.0f;
-            ImGui::Text("Current: %u / %u XP (%.1f%%)", currentXp, nextLevelXp, xpPct);
-            ImGui::Text("To next level: %u XP", xpToLevel);
-            if (restedXp > 0) {
-                float restedLevels = static_cast<float>(restedXp) / static_cast<float>(nextLevelXp);
-                ImGui::Spacing();
-                ImGui::TextColored(ImVec4(0.78f, 0.60f, 1.0f, 1.0f),
-                    "Rested: +%u XP (%.1f%% of a level)", restedXp, restedLevels * 100.0f);
-                if (isResting)
-                    ImGui::TextColored(ImVec4(0.6f, 0.9f, 0.6f, 1.0f),
-                        "Resting — accumulating bonus XP");
-            }
-            ImGui::EndTooltip();
-        }
-    }
-    }
-    ImGui::End();
-
-    ImGui::PopStyleColor(2);
-    ImGui::PopStyleVar(2);
-}
-
-void ActionBarPanel::renderRepBar(game::GameHandler& gameHandler,
-                         SettingsPanel& settingsPanel) {
-    uint32_t factionId = gameHandler.getWatchedFactionId();
-    if (factionId == 0) return;
-
-    const auto& standings = gameHandler.getFactionStandings();
-    auto it = standings.find(factionId);
-    if (it == standings.end()) return;
-
-    int32_t standing = it->second;
-
-    // WoW reputation rank thresholds
-    struct RepRank { const char* name; int32_t min; int32_t max; ImU32 color; };
-    static const RepRank kRanks[] = {
-        { "Hated",      -42000, -6001,  IM_COL32(180,  40,  40, 255) },
-        { "Hostile",     -6000, -3001,  IM_COL32(180,  40,  40, 255) },
-        { "Unfriendly",  -3000,    -1,  IM_COL32(220, 100,  50, 255) },
-        { "Neutral",         0,  2999,  IM_COL32(200, 200,  60, 255) },
-        { "Friendly",     3000,  8999,  IM_COL32( 60, 180,  60, 255) },
-        { "Honored",      9000, 20999,  IM_COL32( 60, 160, 220, 255) },
-        { "Revered",     21000, 41999,  IM_COL32(140,  80, 220, 255) },
-        { "Exalted",     42000, 42999,  IM_COL32(255, 200,  50, 255) },
-    };
-    constexpr int kNumRanks = static_cast<int>(sizeof(kRanks) / sizeof(kRanks[0]));
-
-    int rankIdx = kNumRanks - 1; // default to Exalted
-    for (int i = 0; i < kNumRanks; ++i) {
-        if (standing <= kRanks[i].max) { rankIdx = i; break; }
-    }
-    const RepRank& rank = kRanks[rankIdx];
-
-    float fraction = 1.0f;
-    if (rankIdx < kNumRanks - 1) {
-        float range = static_cast<float>(rank.max - rank.min + 1);
-        fraction = static_cast<float>(standing - rank.min) / range;
-        fraction = std::max(0.0f, std::min(1.0f, fraction));
-    }
-
-    const std::string& factionName = gameHandler.getFactionNamePublic(factionId);
-
-    // Position directly above the XP bar
-    ImVec2 displaySize = ImGui::GetIO().DisplaySize;
-    float screenW = displaySize.x > 0.0f ? displaySize.x : 1280.0f;
-    float screenH = displaySize.y > 0.0f ? displaySize.y : 720.0f;
-
-    float slotSize = 48.0f * settingsPanel.pendingActionBarScale;
-    float spacing  = 4.0f;
-    float padding  = 8.0f;
-    float barW     = 12 * slotSize + 11 * spacing + padding * 2;
-    float barH_ab  = slotSize + 24.0f;
-    float xpBarH   = 20.0f;
-    float repBarH  = 12.0f;
-    float xpBarW   = barW;
-    float xpBarX   = (screenW - xpBarW) / 2.0f;
-
-    float bar1TopY = screenH - barH_ab;
-    float xpBarY;
-    if (settingsPanel.pendingShowActionBar2) {
-        float bar2TopY = bar1TopY - barH_ab - 2.0f + settingsPanel.pendingActionBar2OffsetY;
-        xpBarY = bar2TopY - xpBarH - 2.0f;
-    } else {
-        xpBarY = bar1TopY - xpBarH - 2.0f;
-    }
-    float repBarY = xpBarY - repBarH - 2.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(xpBarX, repBarY), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(xpBarW, repBarH + 4.0f), ImGuiCond_Always);
-
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
-                             ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_AlwaysAutoResize;
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 2.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(2.0f, 2.0f));
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.05f, 0.05f, 0.05f, 0.9f));
-    ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.3f, 0.3f, 0.3f, 0.8f));
-
-    if (ImGui::Begin("##RepBar", nullptr, flags)) {
-        ImVec2 barMin  = ImGui::GetCursorScreenPos();
-        ImVec2 barSize = ImVec2(ImGui::GetContentRegionAvail().x, repBarH - 4.0f);
-        ImVec2 barMax  = ImVec2(barMin.x + barSize.x, barMin.y + barSize.y);
-        auto* dl = ImGui::GetWindowDrawList();
-
-        dl->AddRectFilled(barMin, barMax, IM_COL32(15, 15, 20, 220), 2.0f);
-        dl->AddRect(barMin, barMax, IM_COL32(80, 80, 90, 220), 2.0f);
-
-        float fillW = barSize.x * fraction;
-        if (fillW > 0.0f)
-            dl->AddRectFilled(barMin, ImVec2(barMin.x + fillW, barMax.y), rank.color, 2.0f);
-
-        // Label: "FactionName - Rank"
-        char label[96];
-        snprintf(label, sizeof(label), "%s - %s", factionName.c_str(), rank.name);
-        ImVec2 textSize = ImGui::CalcTextSize(label);
-        float tx = barMin.x + (barSize.x - textSize.x) * 0.5f;
-        float ty = barMin.y + (barSize.y - textSize.y) * 0.5f;
-        dl->AddText(ImVec2(tx, ty), IM_COL32(230, 230, 230, 255), label);
-
-        // Tooltip with exact values on hover
-        ImGui::Dummy(barSize);
-        if (ImGui::IsItemHovered()) {
-            ImGui::BeginTooltip();
-            float cr = ((rank.color      ) & 0xFF) / 255.0f;
-            float cg = ((rank.color >>  8) & 0xFF) / 255.0f;
-            float cb = ((rank.color >> 16) & 0xFF) / 255.0f;
-            ImGui::TextColored(ImVec4(cr, cg, cb, 1.0f), "%s", rank.name);
-            int32_t rankMin = rank.min;
-            int32_t rankMax = (rankIdx < kNumRanks - 1) ? rank.max : 42000;
-            ImGui::Text("%s: %d / %d", factionName.c_str(), standing - rankMin, rankMax - rankMin + 1);
-            ImGui::EndTooltip();
-        }
-    }
-    ImGui::End();
-    ImGui::PopStyleColor(2);
-    ImGui::PopStyleVar(2);
-}
-
-
-} // namespace ui
-} // namespace wowee
diff --git a/src/ui/auth_screen.cpp b/src/ui/auth_screen.cpp
index ac613a68..2f4b83cc 100644
--- a/src/ui/auth_screen.cpp
+++ b/src/ui/auth_screen.cpp
@@ -1,25 +1,22 @@
 #include "ui/auth_screen.hpp"
-#include "ui/ui_colors.hpp"
-#include "ui/settings_panel.hpp"
 #include "auth/crypto.hpp"
 #include "core/application.hpp"
 #include "core/logger.hpp"
 #include "rendering/renderer.hpp"
 #include "rendering/vk_context.hpp"
 #include "pipeline/asset_manager.hpp"
-#include "audio/audio_coordinator.hpp"
 #include "audio/music_manager.hpp"
 #include "game/expansion_profile.hpp"
 #include <imgui.h>
 #include <imgui_impl_vulkan.h>
 #include "stb_image.h"
 #include <filesystem>
-#include <fstream>
-#include <map>
 #include <sstream>
+#include <fstream>
 #include <cstdlib>
 #include <cstring>
 #include <cstdio>
+#include <filesystem>
 #include <algorithm>
 #include <iomanip>
 #include <array>
@@ -40,19 +37,15 @@ static std::string trimAscii(std::string s) {
 static std::string hexEncode(const std::vector<uint8_t>& data) {
     std::ostringstream ss;
     for (uint8_t b : data)
-        ss << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>(b);
+        ss << std::hex << std::setfill('0') << std::setw(2) << (int)b;
     return ss.str();
 }
 
 static std::vector<uint8_t> hexDecode(const std::string& hex) {
     std::vector<uint8_t> bytes;
     for (size_t i = 0; i + 1 < hex.size(); i += 2) {
-        try {
-            uint8_t b = static_cast<uint8_t>(std::stoul(hex.substr(i, 2), nullptr, 16));
-            bytes.push_back(b);
-        } catch (...) {
-            return {};
-        }
+        uint8_t b = static_cast<uint8_t>(std::stoul(hex.substr(i, 2), nullptr, 16));
+        bytes.push_back(b);
     }
     return bytes;
 }
@@ -202,26 +195,24 @@ void AuthScreen::render(auth::AuthHandler& authHandler) {
     }
 
     auto& app = core::Application::getInstance();
-    auto* ac = app.getAudioCoordinator();
+    auto* renderer = app.getRenderer();
     if (!musicInitAttempted) {
         musicInitAttempted = true;
         auto* assets = app.getAssetManager();
-        if (ac) {
-            auto* music = ac->getMusicManager();
+        if (renderer) {
+            auto* music = renderer->getMusicManager();
             if (music && assets && assets->isInitialized() && !music->isInitialized()) {
                 music->initialize(assets);
             }
         }
     }
-    // Login screen music
-    if (ac) {
-        auto* music = ac->getMusicManager();
+    // Login screen music disabled
+    if (false && renderer) {
+        auto* music = renderer->getMusicManager();
         if (music) {
             if (!loginMusicVolumeAdjusted_) {
                 savedMusicVolume_ = music->getVolume();
-                // Reduce music to 80% during login so UI button clicks and error sounds
-                // remain audible over the background track
-                int loginVolume = (savedMusicVolume_ * 80) / 100;
+                int loginVolume = (savedMusicVolume_ * 80) / 100; // reduce auth music by 20%
                 if (loginVolume < 0) loginVolume = 0;
                 if (loginVolume > 100) loginVolume = 100;
                 music->setVolume(loginVolume);
@@ -402,9 +393,9 @@ void AuthScreen::render(auth::AuthHandler& authHandler) {
     // Connection status
     if (!statusMessage.empty()) {
         if (statusIsError) {
-            ImGui::PushStyleColor(ImGuiCol_Text, ui::colors::kRed);
+            ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.3f, 0.3f, 1.0f));
         } else {
-            ImGui::PushStyleColor(ImGuiCol_Text, ui::colors::kBrightGreen);
+            ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.3f, 1.0f, 0.3f, 1.0f));
         }
         ImGui::TextWrapped("%s", statusMessage.c_str());
         ImGui::PopStyleColor();
@@ -459,9 +450,8 @@ void AuthScreen::render(auth::AuthHandler& authHandler) {
             if (!usingStoredHash) {
                 std::string upperUser = username;
                 std::string upperPass = password;
-                auto toUp = [](unsigned char c) { return static_cast<char>(std::toupper(c)); };
-                std::transform(upperUser.begin(), upperUser.end(), upperUser.begin(), toUp);
-                std::transform(upperPass.begin(), upperPass.end(), upperPass.begin(), toUp);
+                std::transform(upperUser.begin(), upperUser.end(), upperUser.begin(), ::toupper);
+                std::transform(upperPass.begin(), upperPass.end(), upperPass.begin(), ::toupper);
                 std::string combined = upperUser + ":" + upperPass;
                 auto hash = auth::Crypto::sha1(combined);
                 savedPasswordHash = hexEncode(hash);
@@ -494,11 +484,6 @@ void AuthScreen::render(auth::AuthHandler& authHandler) {
         if (ImGui::Button("Clear", ImVec2(160, 40))) {
             statusMessage.clear();
         }
-
-        ImGui::SameLine();
-        if (ImGui::Button("Settings", ImVec2(160, 40))) {
-            showLoginSettings_ = true;
-        }
     }
 
     ImGui::Spacing();
@@ -510,15 +495,13 @@ void AuthScreen::render(auth::AuthHandler& authHandler) {
     ImGui::TextWrapped("Default port is 3724.");
 
     ImGui::End();
-
-    renderLoginSettingsWindow();
 }
 
 void AuthScreen::stopLoginMusic() {
     auto& app = core::Application::getInstance();
-    auto* ac = app.getAudioCoordinator();
-    if (!ac) return;
-    auto* music = ac->getMusicManager();
+    auto* renderer = app.getRenderer();
+    if (!renderer) return;
+    auto* music = renderer->getMusicManager();
     if (!music) return;
     if (musicPlaying) {
         music->stopMusic(500.0f);
@@ -799,8 +782,7 @@ static uint32_t findMemType(VkPhysicalDevice pd, uint32_t filter, VkMemoryProper
     for (uint32_t i = 0; i < mp.memoryTypeCount; i++) {
         if ((filter & (1 << i)) && (mp.memoryTypes[i].propertyFlags & props) == props) return i;
     }
-    LOG_ERROR("AuthScreen: no suitable memory type found");
-    return UINT32_MAX;
+    return 0;
 }
 
 bool AuthScreen::loadBackgroundImage() {
@@ -933,7 +915,7 @@ bool AuthScreen::loadBackgroundImage() {
         samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
         samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
         samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-        bgSampler = bgVkCtx->getOrCreateSampler(samplerInfo);
+        vkCreateSampler(device, &samplerInfo, nullptr, &bgSampler);
     }
 
     bgDescriptorSet = ImGui_ImplVulkan_AddTexture(bgSampler, bgImageView,
@@ -948,222 +930,10 @@ void AuthScreen::destroyBackgroundImage() {
     VkDevice device = bgVkCtx->getDevice();
     vkDeviceWaitIdle(device);
     if (bgDescriptorSet) { ImGui_ImplVulkan_RemoveTexture(bgDescriptorSet); bgDescriptorSet = VK_NULL_HANDLE; }
-    bgSampler = VK_NULL_HANDLE; // Owned by VkContext sampler cache
+    if (bgSampler) { vkDestroySampler(device, bgSampler, nullptr); bgSampler = VK_NULL_HANDLE; }
     if (bgImageView) { vkDestroyImageView(device, bgImageView, nullptr); bgImageView = VK_NULL_HANDLE; }
     if (bgImage) { vkDestroyImage(device, bgImage, nullptr); bgImage = VK_NULL_HANDLE; }
     if (bgMemory) { vkFreeMemory(device, bgMemory, nullptr); bgMemory = VK_NULL_HANDLE; }
 }
 
-// ---------------------------------------------------------------------------
-// Login-screen graphics settings popup
-// ---------------------------------------------------------------------------
-
-void AuthScreen::applyPresetToState(LoginGraphicsState& s, int preset) {
-    switch (preset) {
-    case 1: // Low
-        s.shadows = false; s.shadowDistance = 75.0f; s.antiAliasing = 0;
-        s.fxaa = false; s.normalMapping = false; s.pom = false; s.pomQuality = 1;
-        s.upscalingMode = 0; s.waterRefraction = false; s.groundClutter = 25;
-        s.brightness = 50; s.vsync = false; s.fullscreen = false;
-        break;
-    case 2: // Medium
-        s.shadows = true; s.shadowDistance = 150.0f; s.antiAliasing = 0;
-        s.fxaa = false; s.normalMapping = true; s.pom = true; s.pomQuality = 1;
-        s.upscalingMode = 0; s.waterRefraction = true; s.groundClutter = 100;
-        s.brightness = 50; s.vsync = false; s.fullscreen = false;
-        break;
-    case 3: // High
-        s.shadows = true; s.shadowDistance = 250.0f; s.antiAliasing = 1;
-        s.fxaa = true; s.normalMapping = true; s.pom = true; s.pomQuality = 1;
-        s.upscalingMode = 0; s.waterRefraction = true; s.groundClutter = 130;
-        s.brightness = 50; s.vsync = false; s.fullscreen = false;
-        break;
-    case 4: // Ultra
-        s.shadows = true; s.shadowDistance = 400.0f; s.antiAliasing = 2;
-        s.fxaa = true; s.normalMapping = true; s.pom = true; s.pomQuality = 2;
-        s.upscalingMode = 0; s.waterRefraction = true; s.groundClutter = 150;
-        s.brightness = 50; s.vsync = false; s.fullscreen = false;
-        break;
-    default: // Custom — no change
-        break;
-    }
-}
-
-void AuthScreen::loadLoginGraphicsState() {
-    std::ifstream file(SettingsPanel::getSettingsPath());
-    if (!file.is_open()) {
-        // File doesn't exist yet — keep struct defaults (Medium equivalent)
-        return;
-    }
-
-    std::string line;
-    while (std::getline(file, line)) {
-        auto eq = line.find('=');
-        if (eq == std::string::npos) continue;
-        std::string key = line.substr(0, eq);
-        std::string val = line.substr(eq + 1);
-
-        if (key == "graphics_preset")       loginGfx_.preset        = std::stoi(val);
-        else if (key == "shadows")          loginGfx_.shadows        = (val == "1");
-        else if (key == "shadow_distance")  loginGfx_.shadowDistance = std::stof(val);
-        else if (key == "antialiasing")     loginGfx_.antiAliasing   = std::stoi(val);
-        else if (key == "fxaa")             loginGfx_.fxaa           = (val == "1");
-        else if (key == "normal_mapping")   loginGfx_.normalMapping  = (val == "1");
-        else if (key == "pom")              loginGfx_.pom            = (val == "1");
-        else if (key == "pom_quality")      loginGfx_.pomQuality     = std::stoi(val);
-        else if (key == "upscaling_mode")   loginGfx_.upscalingMode  = std::stoi(val);
-        else if (key == "water_refraction") loginGfx_.waterRefraction = (val == "1");
-        else if (key == "ground_clutter_density") loginGfx_.groundClutter = std::stoi(val);
-        else if (key == "brightness")       loginGfx_.brightness     = std::stoi(val);
-        else if (key == "vsync")            loginGfx_.vsync          = (val == "1");
-        else if (key == "fullscreen")       loginGfx_.fullscreen     = (val == "1");
-    }
-}
-
-void AuthScreen::saveLoginGraphicsState() {
-    // Read the full settings file into a map to preserve non-graphics keys.
-    std::map<std::string, std::string> cfg;
-    std::ifstream in(SettingsPanel::getSettingsPath());
-    if (in.is_open()) {
-        std::string line;
-        while (std::getline(in, line)) {
-            auto eq = line.find('=');
-            if (eq != std::string::npos)
-                cfg[line.substr(0, eq)] = line.substr(eq + 1);
-        }
-        in.close();
-    }
-
-    // Overwrite graphics keys.
-    cfg["graphics_preset"]       = std::to_string(loginGfx_.preset);
-    cfg["shadows"]               = loginGfx_.shadows        ? "1" : "0";
-    cfg["shadow_distance"]       = std::to_string(static_cast<int>(loginGfx_.shadowDistance));
-    cfg["antialiasing"]          = std::to_string(loginGfx_.antiAliasing);
-    cfg["fxaa"]                  = loginGfx_.fxaa           ? "1" : "0";
-    cfg["normal_mapping"]        = loginGfx_.normalMapping  ? "1" : "0";
-    cfg["pom"]                   = loginGfx_.pom            ? "1" : "0";
-    cfg["pom_quality"]           = std::to_string(loginGfx_.pomQuality);
-    cfg["upscaling_mode"]        = std::to_string(loginGfx_.upscalingMode);
-    cfg["water_refraction"]      = loginGfx_.waterRefraction ? "1" : "0";
-    cfg["ground_clutter_density"]= std::to_string(loginGfx_.groundClutter);
-    cfg["brightness"]            = std::to_string(loginGfx_.brightness);
-    cfg["vsync"]                 = loginGfx_.vsync           ? "1" : "0";
-    cfg["fullscreen"]            = loginGfx_.fullscreen      ? "1" : "0";
-
-    // Write everything back.
-    std::ofstream out(SettingsPanel::getSettingsPath());
-    if (!out.is_open()) return;
-    for (const auto& [k, v] : cfg)
-        out << k << "=" << v << "\n";
-}
-
-void AuthScreen::renderLoginSettingsWindow() {
-    if (showLoginSettings_) {
-        ImGui::OpenPopup("Graphics Settings");
-        showLoginSettings_ = false;
-        loginGfxLoaded_ = false; // Reload from disk each time the popup opens.
-    }
-
-    ImVec2 center = ImGui::GetMainViewport()->GetCenter();
-    ImGui::SetNextWindowPos(center, ImGuiCond_Always, ImVec2(0.5f, 0.5f));
-    ImGui::SetNextWindowSize(ImVec2(500, 560), ImGuiCond_Always);
-
-    if (ImGui::BeginPopupModal("Graphics Settings", nullptr, ImGuiWindowFlags_NoResize)) {
-        if (!loginGfxLoaded_) {
-            loadLoginGraphicsState();
-            loginGfxLoaded_ = true;
-        }
-
-        ImGui::TextColored(ImVec4(1.0f, 0.85f, 0.0f, 1.0f), "Graphics Settings");
-        ImGui::TextWrapped("Adjust settings below or reset to a safe preset. Changes take effect on next login.");
-        ImGui::Separator();
-        ImGui::Spacing();
-
-        // Preset selector
-        const char* presetNames[] = {"Custom", "Low", "Medium", "High", "Ultra"};
-        ImGui::Text("Preset:");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(160.0f);
-        if (ImGui::Combo("##preset", &loginGfx_.preset, presetNames, 5)) {
-            if (loginGfx_.preset != 0) // 0 = Custom — don't override manually set values
-                applyPresetToState(loginGfx_, loginGfx_.preset);
-        }
-
-        ImGui::Spacing();
-        ImGui::Separator();
-        ImGui::Spacing();
-
-        // Shadow settings
-        ImGui::Checkbox("Shadows", &loginGfx_.shadows);
-        if (loginGfx_.shadows) {
-            ImGui::SameLine();
-            ImGui::SetNextItemWidth(200.0f);
-            float sd = loginGfx_.shadowDistance;
-            if (ImGui::SliderFloat("Shadow Distance", &sd, 50.0f, 600.0f, "%.0f"))
-                loginGfx_.shadowDistance = sd;
-        }
-
-        // Anti-aliasing
-        const char* aaNames[] = {"Off", "2x MSAA", "4x MSAA"};
-        ImGui::Text("Anti-Aliasing:");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(130.0f);
-        ImGui::Combo("##aa", &loginGfx_.antiAliasing, aaNames, 3);
-
-        ImGui::Checkbox("FXAA",           &loginGfx_.fxaa);
-        ImGui::Checkbox("Normal Mapping", &loginGfx_.normalMapping);
-
-        // POM
-        ImGui::Checkbox("Parallax Occlusion Mapping (POM)", &loginGfx_.pom);
-        if (loginGfx_.pom) {
-            const char* pomQ[] = {"Medium", "High"};
-            ImGui::Text("  POM Quality:");
-            ImGui::SameLine();
-            ImGui::SetNextItemWidth(110.0f);
-            ImGui::Combo("##pomq", &loginGfx_.pomQuality, pomQ, 2);
-        }
-
-        ImGui::Checkbox("Water Refraction",  &loginGfx_.waterRefraction);
-
-        // Ground clutter density
-        ImGui::Text("Ground Clutter:");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(200.0f);
-        ImGui::SliderInt("##clutter", &loginGfx_.groundClutter, 0, 200);
-
-        // Brightness
-        ImGui::Text("Brightness:");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(200.0f);
-        ImGui::SliderInt("##brightness", &loginGfx_.brightness, 0, 100);
-
-        ImGui::Checkbox("V-Sync",      &loginGfx_.vsync);
-        ImGui::Checkbox("Fullscreen",  &loginGfx_.fullscreen);
-
-        ImGui::Spacing();
-        ImGui::Separator();
-        ImGui::Spacing();
-
-        // Action buttons
-        if (ImGui::Button("Reset to Medium", ImVec2(160, 32))) {
-            applyPresetToState(loginGfx_, 2);
-            loginGfx_.preset = 2;
-        }
-        ImGui::SameLine();
-
-        float rightEdge = ImGui::GetContentRegionAvail().x;
-        ImGui::SetCursorPosX(ImGui::GetCursorPosX() + rightEdge - 220.0f);
-        if (ImGui::Button("Cancel", ImVec2(100, 32))) {
-            ImGui::CloseCurrentPopup();
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Apply", ImVec2(100, 32))) {
-            saveLoginGraphicsState();
-            ImGui::CloseCurrentPopup();
-        }
-
-        ImGui::EndPopup();
-    }
-}
-
 }} // namespace wowee::ui
diff --git a/src/ui/character_create_screen.cpp b/src/ui/character_create_screen.cpp
index 415bd493..fa81756f 100644
--- a/src/ui/character_create_screen.cpp
+++ b/src/ui/character_create_screen.cpp
@@ -1,5 +1,4 @@
 #include "ui/character_create_screen.hpp"
-#include "ui/ui_colors.hpp"
 #include "rendering/character_preview.hpp"
 #include "rendering/renderer.hpp"
 #include "core/application.hpp"
@@ -14,7 +13,7 @@ namespace wowee {
 namespace ui {
 
 // Full WotLK race/class lists (used as defaults when no expansion constraints set)
-static constexpr game::Race kAllRaces[] = {
+static const game::Race kAllRaces[] = {
     // Alliance
     game::Race::HUMAN, game::Race::DWARF, game::Race::NIGHT_ELF,
     game::Race::GNOME, game::Race::DRAENEI,
@@ -25,7 +24,7 @@ static constexpr game::Race kAllRaces[] = {
 static constexpr int kAllRaceCount = 10;
 static constexpr int kAllianceCount = 5;
 
-static constexpr game::Class kAllClasses[] = {
+static const game::Class kAllClasses[] = {
     game::Class::WARRIOR, game::Class::PALADIN, game::Class::HUNTER,
     game::Class::ROGUE, game::Class::PRIEST, game::Class::DEATH_KNIGHT,
     game::Class::SHAMAN, game::Class::MAGE, game::Class::WARLOCK,
@@ -250,17 +249,16 @@ void CharacterCreateScreen::updateAppearanceRanges() {
     uint32_t targetSexId = (genderIndex == 1) ? 1u : 0u;
 
     const auto* csL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("CharSections") : nullptr;
-    auto csF = pipeline::detectCharSectionsFields(dbc.get(), csL);
     int skinMax = -1;
     int hairStyleMax = -1;
     for (uint32_t r = 0; r < dbc->getRecordCount(); r++) {
-        uint32_t raceId = dbc->getUInt32(r, csF.raceId);
-        uint32_t sexId = dbc->getUInt32(r, csF.sexId);
+        uint32_t raceId = dbc->getUInt32(r, csL ? (*csL)["RaceID"] : 1);
+        uint32_t sexId = dbc->getUInt32(r, csL ? (*csL)["SexID"] : 2);
         if (raceId != targetRaceId || sexId != targetSexId) continue;
 
-        uint32_t baseSection = dbc->getUInt32(r, csF.baseSection);
-        uint32_t variationIndex = dbc->getUInt32(r, csF.variationIndex);
-        uint32_t colorIndex = dbc->getUInt32(r, csF.colorIndex);
+        uint32_t baseSection = dbc->getUInt32(r, csL ? (*csL)["BaseSection"] : 3);
+        uint32_t variationIndex = dbc->getUInt32(r, csL ? (*csL)["VariationIndex"] : 4);
+        uint32_t colorIndex = dbc->getUInt32(r, csL ? (*csL)["ColorIndex"] : 5);
 
         if (baseSection == 0 && variationIndex == 0) {
             skinMax = std::max(skinMax, static_cast<int>(colorIndex));
@@ -281,13 +279,13 @@ void CharacterCreateScreen::updateAppearanceRanges() {
     int faceMax = -1;
     std::vector<uint8_t> hairColorIds;
     for (uint32_t r = 0; r < dbc->getRecordCount(); r++) {
-        uint32_t raceId = dbc->getUInt32(r, csF.raceId);
-        uint32_t sexId = dbc->getUInt32(r, csF.sexId);
+        uint32_t raceId = dbc->getUInt32(r, csL ? (*csL)["RaceID"] : 1);
+        uint32_t sexId = dbc->getUInt32(r, csL ? (*csL)["SexID"] : 2);
         if (raceId != targetRaceId || sexId != targetSexId) continue;
 
-        uint32_t baseSection = dbc->getUInt32(r, csF.baseSection);
-        uint32_t variationIndex = dbc->getUInt32(r, csF.variationIndex);
-        uint32_t colorIndex = dbc->getUInt32(r, csF.colorIndex);
+        uint32_t baseSection = dbc->getUInt32(r, csL ? (*csL)["BaseSection"] : 3);
+        uint32_t variationIndex = dbc->getUInt32(r, csL ? (*csL)["VariationIndex"] : 4);
+        uint32_t colorIndex = dbc->getUInt32(r, csL ? (*csL)["ColorIndex"] : 5);
 
         if (baseSection == 1 && colorIndex == static_cast<uint32_t>(skin)) {
             faceMax = std::max(faceMax, static_cast<int>(variationIndex));
@@ -383,7 +381,7 @@ void CharacterCreateScreen::render(game::GameHandler& /*gameHandler*/) {
                 preview_->rotate(deltaX * 0.2f);
             }
 
-            ImGui::TextColored(ui::colors::kDarkGray, "Drag to rotate");
+            ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "Drag to rotate");
         }
         ImGui::EndChild();
 
@@ -425,7 +423,7 @@ void CharacterCreateScreen::render(game::GameHandler& /*gameHandler*/) {
         }
     }
     if (allianceRaceCount_ < raceCount) {
-        ImGui::TextColored(ui::colors::kRed, "Horde:");
+        ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f), "Horde:");
         ImGui::SameLine();
         for (int i = allianceRaceCount_; i < raceCount; ++i) {
             if (i > allianceRaceCount_) ImGui::SameLine();
@@ -518,7 +516,7 @@ void CharacterCreateScreen::render(game::GameHandler& /*gameHandler*/) {
     if (!statusMessage.empty()) {
         ImGui::Separator();
         ImGui::Spacing();
-        ImVec4 color = statusIsError ? ui::colors::kRed : ui::colors::kBrightGreen;
+        ImVec4 color = statusIsError ? ImVec4(1.0f, 0.3f, 0.3f, 1.0f) : ImVec4(0.3f, 1.0f, 0.3f, 1.0f);
         ImGui::TextColored(color, "%s", statusMessage.c_str());
     }
 
diff --git a/src/ui/character_screen.cpp b/src/ui/character_screen.cpp
index 8024ee5e..406164ac 100644
--- a/src/ui/character_screen.cpp
+++ b/src/ui/character_screen.cpp
@@ -1,5 +1,4 @@
 #include "ui/character_screen.hpp"
-#include "ui/ui_colors.hpp"
 #include "rendering/character_preview.hpp"
 #include "rendering/renderer.hpp"
 #include "pipeline/asset_manager.hpp"
@@ -38,8 +37,6 @@ static uint64_t hashEquipment(const std::vector<game::EquipmentItem>& eq) {
     return h;
 }
 
-static ImVec4 classColor(uint8_t classId) { return ui::getClassColor(classId); }
-
 void CharacterScreen::render(game::GameHandler& gameHandler) {
     ImGuiViewport* vp = ImGui::GetMainViewport();
     const ImVec2 pad(24.0f, 24.0f);
@@ -80,7 +77,7 @@ void CharacterScreen::render(game::GameHandler& gameHandler) {
     if (characters.empty() &&
         (gameHandler.getState() == game::WorldState::DISCONNECTED ||
          gameHandler.getState() == game::WorldState::FAILED)) {
-        ImGui::TextColored(ui::colors::kSoftRed, "Disconnected from server.");
+        ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f), "Disconnected from server.");
         ImGui::TextWrapped("The server closed the connection before sending the character list.");
         ImGui::Spacing();
         if (ImGui::Button("Back", ImVec2(120, 36))) { if (onBack) onBack(); }
@@ -160,7 +157,7 @@ void CharacterScreen::render(game::GameHandler& gameHandler) {
 
     // Status message
     if (!statusMessage.empty()) {
-        ImVec4 color = statusIsError ? ui::colors::kRed : ui::colors::kBrightGreen;
+        ImVec4 color = statusIsError ? ImVec4(1.0f, 0.3f, 0.3f, 1.0f) : ImVec4(0.3f, 1.0f, 0.3f, 1.0f);
         ImGui::PushStyleColor(ImGuiCol_Text, color);
         ImGui::TextWrapped("%s", statusMessage.c_str());
         ImGui::PopStyleColor();
@@ -187,7 +184,7 @@ void CharacterScreen::render(game::GameHandler& gameHandler) {
         ImGui::TableSetupColumn("Level", ImGuiTableColumnFlags_WidthFixed, 45.0f);
         ImGui::TableSetupColumn("Race",  ImGuiTableColumnFlags_WidthStretch, 1.0f);
         ImGui::TableSetupColumn("Class", ImGuiTableColumnFlags_WidthStretch, 1.2f);
-        ImGui::TableSetupColumn("Zone",  ImGuiTableColumnFlags_WidthStretch, 1.5f);
+        ImGui::TableSetupColumn("Zone",  ImGuiTableColumnFlags_WidthFixed, 55.0f);
         ImGui::TableSetupScrollFreeze(0, 1);
         ImGui::TableHeadersRow();
 
@@ -227,16 +224,10 @@ void CharacterScreen::render(game::GameHandler& gameHandler) {
             ImGui::Text("%s", game::getRaceName(character.race));
 
             ImGui::TableSetColumnIndex(3);
-            ImGui::TextColored(classColor(static_cast<uint8_t>(character.characterClass)), "%s", game::getClassName(character.characterClass));
+            ImGui::Text("%s", game::getClassName(character.characterClass));
 
             ImGui::TableSetColumnIndex(4);
-            {
-                std::string zoneName = gameHandler.getWhoAreaName(character.zoneId);
-                if (!zoneName.empty())
-                    ImGui::TextUnformatted(zoneName.c_str());
-                else
-                    ImGui::Text("%u", character.zoneId);
-            }
+            ImGui::Text("%d", character.zoneId);
         }
 
         ImGui::EndTable();
@@ -334,23 +325,13 @@ void CharacterScreen::render(game::GameHandler& gameHandler) {
 
         ImGui::Text("Level %d", character.level);
         ImGui::Text("%s", game::getRaceName(character.race));
-        ImGui::TextColored(classColor(static_cast<uint8_t>(character.characterClass)), "%s", game::getClassName(character.characterClass));
+        ImGui::Text("%s", game::getClassName(character.characterClass));
         ImGui::Text("%s", game::getGenderName(character.gender));
         ImGui::Spacing();
-        {
-            std::string zoneName = gameHandler.getWhoAreaName(character.zoneId);
-            if (!zoneName.empty())
-                ImGui::TextUnformatted(zoneName.c_str());
-            else
-                ImGui::Text("Zone %u", character.zoneId);
-        }
+        ImGui::Text("Map %d, Zone %d", character.mapId, character.zoneId);
 
         if (character.hasGuild()) {
-            const std::string& guildName = gameHandler.lookupGuildName(character.guildId);
-            if (!guildName.empty())
-                ImGui::Text("<%s>", guildName.c_str());
-            else
-                ImGui::TextDisabled("<Guild %u>", character.guildId);
+            ImGui::Text("Guild ID: %d", character.guildId);
         } else {
             ImGui::TextDisabled("No Guild");
         }
@@ -448,7 +429,7 @@ void CharacterScreen::render(game::GameHandler& gameHandler) {
     if (ImGui::BeginPopupModal("DeleteConfirm2", nullptr,
             ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove)) {
         const auto& ch = characters[selectedCharacterIndex];
-        ImGui::PushStyleColor(ImGuiCol_Text, ui::colors::kRed);
+        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.3f, 0.3f, 1.0f));
         ImGui::Text("THIS CANNOT BE UNDONE!");
         ImGui::PopStyleColor();
         ImGui::Spacing();
@@ -504,10 +485,10 @@ ImVec4 CharacterScreen::getFactionColor(game::Race race) const {
         race == game::Race::TAUREN ||
         race == game::Race::TROLL ||
         race == game::Race::BLOOD_ELF) {
-        return ui::colors::kRed;
+        return ImVec4(1.0f, 0.3f, 0.3f, 1.0f);
     }
 
-    return ui::colors::kWhite;
+    return ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
 }
 
 std::string CharacterScreen::getConfigDir() {
diff --git a/src/ui/chat_panel.cpp b/src/ui/chat_panel.cpp
deleted file mode 100644
index 49d37249..00000000
--- a/src/ui/chat_panel.cpp
+++ /dev/null
@@ -1,4834 +0,0 @@
-#include "ui/chat_panel.hpp"
-#include "ui/inventory_screen.hpp"
-#include "ui/spellbook_screen.hpp"
-#include "ui/quest_log_screen.hpp"
-#include "ui/ui_colors.hpp"
-#include "rendering/vk_context.hpp"
-#include "core/application.hpp"
-#include "addons/addon_manager.hpp"
-#include "core/coordinates.hpp"
-#include "core/input.hpp"
-#include "rendering/renderer.hpp"
-#include "rendering/camera.hpp"
-#include "rendering/camera_controller.hpp"
-#include "audio/audio_coordinator.hpp"
-#include "audio/audio_engine.hpp"
-#include "audio/ui_sound_manager.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "pipeline/dbc_loader.hpp"
-#include "pipeline/dbc_layout.hpp"
-#include "game/expansion_profile.hpp"
-#include "game/character.hpp"
-#include "core/logger.hpp"
-#include <imgui.h>
-#include <imgui_internal.h>
-#include <algorithm>
-#include <cmath>
-#include <cstring>
-#include <sstream>
-#include <cstdlib>
-#include <cctype>
-#include <chrono>
-#include <ctime>
-#include <unordered_set>
-#include <unordered_map>
-
-namespace {
-    // Common ImGui colors (aliases)
-    using namespace wowee::ui::colors;
-    constexpr auto& kColorRed        = kRed;
-    constexpr auto& kColorGreen      = kGreen;
-    constexpr auto& kColorBrightGreen= kBrightGreen;
-    constexpr auto& kColorYellow     = kYellow;
-    constexpr auto& kColorGray       = kGray;
-    constexpr auto& kColorDarkGray   = kDarkGray;
-
-    // Common ImGui window flags for popup dialogs
-    const ImGuiWindowFlags kDialogFlags = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize;
-
-    std::string trim(const std::string& s) {
-        size_t first = s.find_first_not_of(" \t\r\n");
-        if (first == std::string::npos) return "";
-        size_t last = s.find_last_not_of(" \t\r\n");
-        return s.substr(first, last - first + 1);
-    }
-
-    std::string toLower(std::string s) {
-        std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) {
-            return static_cast<char>(std::tolower(c));
-        });
-        return s;
-    }
-
-    bool isPortBotTarget(const std::string& target) {
-        std::string t = toLower(trim(target));
-        return t == "portbot" || t == "gmbot" || t == "telebot";
-    }
-
-    std::string buildPortBotCommand(const std::string& rawInput) {
-        std::string input = trim(rawInput);
-        if (input.empty()) return "";
-
-        std::string lower = toLower(input);
-        if (lower == "help" || lower == "?") {
-            return "__help__";
-        }
-
-        if (lower.rfind(".tele ", 0) == 0 || lower.rfind(".go ", 0) == 0) {
-            return input;
-        }
-
-        if (lower.rfind("xyz ", 0) == 0) {
-            return ".go " + input;
-        }
-
-        if (lower == "sw" || lower == "stormwind") return ".tele stormwind";
-        if (lower == "if" || lower == "ironforge") return ".tele ironforge";
-        if (lower == "darn" || lower == "darnassus") return ".tele darnassus";
-        if (lower == "org" || lower == "orgrimmar") return ".tele orgrimmar";
-        if (lower == "tb" || lower == "thunderbluff") return ".tele thunderbluff";
-        if (lower == "uc" || lower == "undercity") return ".tele undercity";
-        if (lower == "shatt" || lower == "shattrath") return ".tele shattrath";
-        if (lower == "dal" || lower == "dalaran") return ".tele dalaran";
-
-        return ".tele " + input;
-    }
-
-    std::string getEntityName(const std::shared_ptr<wowee::game::Entity>& entity) {
-        if (entity->getType() == wowee::game::ObjectType::PLAYER) {
-            auto player = std::static_pointer_cast<wowee::game::Player>(entity);
-            if (!player->getName().empty()) return player->getName();
-        } else if (entity->getType() == wowee::game::ObjectType::UNIT) {
-            auto unit = std::static_pointer_cast<wowee::game::Unit>(entity);
-            if (!unit->getName().empty()) return unit->getName();
-        } else if (entity->getType() == wowee::game::ObjectType::GAMEOBJECT) {
-            auto go = std::static_pointer_cast<wowee::game::GameObject>(entity);
-            if (!go->getName().empty()) return go->getName();
-        }
-        return "Unknown";
-    }
-}
-
-namespace wowee { namespace ui {
-
-ChatPanel::ChatPanel() {
-    initChatTabs();
-}
-
-void ChatPanel::initChatTabs() {
-    chatTabs_.clear();
-    // General tab: shows everything
-    chatTabs_.push_back({"General", ~0ULL});
-    // Combat tab: system, loot, skills, achievements, and NPC speech/emotes
-    chatTabs_.push_back({"Combat", (1ULL << static_cast<uint8_t>(game::ChatType::SYSTEM)) |
-                                    (1ULL << static_cast<uint8_t>(game::ChatType::LOOT)) |
-                                    (1ULL << static_cast<uint8_t>(game::ChatType::SKILL)) |
-                                    (1ULL << static_cast<uint8_t>(game::ChatType::ACHIEVEMENT)) |
-                                    (1ULL << static_cast<uint8_t>(game::ChatType::GUILD_ACHIEVEMENT)) |
-                                    (1ULL << static_cast<uint8_t>(game::ChatType::MONSTER_SAY)) |
-                                    (1ULL << static_cast<uint8_t>(game::ChatType::MONSTER_YELL)) |
-                                    (1ULL << static_cast<uint8_t>(game::ChatType::MONSTER_EMOTE)) |
-                                    (1ULL << static_cast<uint8_t>(game::ChatType::MONSTER_WHISPER)) |
-                                    (1ULL << static_cast<uint8_t>(game::ChatType::MONSTER_PARTY)) |
-                                    (1ULL << static_cast<uint8_t>(game::ChatType::RAID_BOSS_WHISPER)) |
-                                    (1ULL << static_cast<uint8_t>(game::ChatType::RAID_BOSS_EMOTE))});
-    // Whispers tab
-    chatTabs_.push_back({"Whispers", (1ULL << static_cast<uint8_t>(game::ChatType::WHISPER)) |
-                                      (1ULL << static_cast<uint8_t>(game::ChatType::WHISPER_INFORM))});
-    // Guild tab: guild and officer chat
-    chatTabs_.push_back({"Guild", (1ULL << static_cast<uint8_t>(game::ChatType::GUILD)) |
-                                   (1ULL << static_cast<uint8_t>(game::ChatType::OFFICER)) |
-                                   (1ULL << static_cast<uint8_t>(game::ChatType::GUILD_ACHIEVEMENT))});
-    // Trade/LFG tab: channel messages
-    chatTabs_.push_back({"Trade/LFG", (1ULL << static_cast<uint8_t>(game::ChatType::CHANNEL))});
-    // Reset unread counts to match new tab list
-    chatTabUnread_.assign(chatTabs_.size(), 0);
-    chatTabSeenCount_ = 0;
-}
-
-bool ChatPanel::shouldShowMessage(const game::MessageChatData& msg, int tabIndex) const {
-    if (tabIndex < 0 || tabIndex >= static_cast<int>(chatTabs_.size())) return true;
-    const auto& tab = chatTabs_[tabIndex];
-    if (tab.typeMask == ~0ULL) return true;  // General tab shows all
-
-    uint64_t typeBit = 1ULL << static_cast<uint8_t>(msg.type);
-
-    // For Trade/LFG tab (now index 4), also filter by channel name
-    if (tabIndex == 4 && msg.type == game::ChatType::CHANNEL) {
-        const std::string& ch = msg.channelName;
-        if (ch.find("Trade") == std::string::npos &&
-            ch.find("General") == std::string::npos &&
-            ch.find("LookingForGroup") == std::string::npos &&
-            ch.find("Local") == std::string::npos) {
-            return false;
-        }
-        return true;
-    }
-
-    return (tab.typeMask & typeBit) != 0;
-}
-
-
-// Forward declaration — defined below
-static std::vector<std::string> allMacroCommands(const std::string& macroText);
-static std::string evaluateMacroConditionals(const std::string& rawArg,
-                                              game::GameHandler& gameHandler,
-                                              uint64_t& targetOverride);
-
-void ChatPanel::render(game::GameHandler& gameHandler,
-                       InventoryScreen& inventoryScreen,
-                       SpellbookScreen& spellbookScreen,
-                       QuestLogScreen& questLogScreen) {
-    auto* window = services_.window;
-    auto* assetMgr = services_.assetManager;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-    float chatW = std::min(500.0f, screenW * 0.4f);
-    float chatH = 220.0f;
-    float chatX = 8.0f;
-    float chatY = screenH - chatH - 80.0f;  // Above action bar
-    if (chatWindowLocked_) {
-        // Always recompute position from current window size when locked
-        chatWindowPos_ = ImVec2(chatX, chatY);
-        ImGui::SetNextWindowSize(ImVec2(chatW, chatH), ImGuiCond_Always);
-        ImGui::SetNextWindowPos(chatWindowPos_, ImGuiCond_Always);
-    } else {
-        if (!chatWindowPosInit_) {
-            chatWindowPos_ = ImVec2(chatX, chatY);
-            chatWindowPosInit_ = true;
-        }
-        ImGui::SetNextWindowSize(ImVec2(chatW, chatH), ImGuiCond_FirstUseEver);
-        ImGui::SetNextWindowPos(chatWindowPos_, ImGuiCond_FirstUseEver);
-    }
-    ImGuiWindowFlags flags = kDialogFlags;
-    if (chatWindowLocked_) {
-        flags |= ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar;
-    }
-    ImGui::Begin("Chat", nullptr, flags);
-
-    if (!chatWindowLocked_) {
-        chatWindowPos_ = ImGui::GetWindowPos();
-    }
-
-    // Update unread counts: scan any new messages since last frame
-    {
-        const auto& history = gameHandler.getChatHistory();
-        // Ensure unread array is sized correctly (guards against late init)
-        if (chatTabUnread_.size() != chatTabs_.size())
-            chatTabUnread_.assign(chatTabs_.size(), 0);
-        // If history shrank (e.g. cleared), reset
-        if (chatTabSeenCount_ > history.size()) chatTabSeenCount_ = 0;
-        for (size_t mi = chatTabSeenCount_; mi < history.size(); ++mi) {
-            const auto& msg = history[mi];
-            // For each non-General (non-0) tab that isn't currently active, check visibility
-            for (int ti = 1; ti < static_cast<int>(chatTabs_.size()); ++ti) {
-                if (ti == activeChatTab) continue;
-                if (shouldShowMessage(msg, ti)) {
-                    chatTabUnread_[ti]++;
-                }
-            }
-        }
-        chatTabSeenCount_ = history.size();
-    }
-
-    // Chat tabs
-    if (ImGui::BeginTabBar("ChatTabs")) {
-        for (int i = 0; i < static_cast<int>(chatTabs_.size()); ++i) {
-            // Build label with unread count suffix for non-General tabs
-            std::string tabLabel = chatTabs_[i].name;
-            if (i > 0 && i < static_cast<int>(chatTabUnread_.size()) && chatTabUnread_[i] > 0) {
-                tabLabel += " (" + std::to_string(chatTabUnread_[i]) + ")";
-            }
-            // Flash tab text color when unread messages exist
-            bool hasUnread = (i > 0 && i < static_cast<int>(chatTabUnread_.size()) && chatTabUnread_[i] > 0);
-            if (hasUnread) {
-                float pulse = 0.6f + 0.4f * std::sin(static_cast<float>(ImGui::GetTime()) * 4.0f);
-                ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.85f * pulse, 0.2f * pulse, 1.0f));
-            }
-            if (ImGui::BeginTabItem(tabLabel.c_str())) {
-                if (activeChatTab != i) {
-                    activeChatTab = i;
-                    // Clear unread count when tab becomes active
-                    if (i < static_cast<int>(chatTabUnread_.size()))
-                        chatTabUnread_[i] = 0;
-                }
-                ImGui::EndTabItem();
-            }
-            if (hasUnread) ImGui::PopStyleColor();
-        }
-        ImGui::EndTabBar();
-    }
-
-    // Chat history
-    const auto& chatHistory = gameHandler.getChatHistory();
-
-    // Apply chat font size scaling
-    float chatScale = chatFontSize == 0 ? 0.85f : (chatFontSize == 2 ? 1.2f : 1.0f);
-    ImGui::SetWindowFontScale(chatScale);
-
-    ImGui::BeginChild("ChatHistory", ImVec2(0, -70), true, ImGuiWindowFlags_HorizontalScrollbar);
-    bool chatHistoryHovered = ImGui::IsWindowHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem);
-
-    // Helper: parse WoW color code |cAARRGGBB → ImVec4
-    auto parseWowColor = [](const std::string& text, size_t pos) -> ImVec4 {
-        // |cAARRGGBB (10 chars total: |c + 8 hex)
-        if (pos + 10 > text.size()) return colors::kWhite;
-        auto hexByte = [&](size_t offset) -> float {
-            const char* s = text.c_str() + pos + offset;
-            char buf[3] = {s[0], s[1], '\0'};
-            return static_cast<float>(strtol(buf, nullptr, 16)) / 255.0f;
-        };
-        float a = hexByte(2);
-        float r = hexByte(4);
-        float g = hexByte(6);
-        float b = hexByte(8);
-        return ImVec4(r, g, b, a);
-    };
-
-    // Helper: render an item tooltip from ItemQueryResponseData
-    auto renderItemLinkTooltip = [&](uint32_t itemEntry) {
-        const auto* info = gameHandler.getItemInfo(itemEntry);
-        if (!info || !info->valid) return;
-        auto findComparableEquipped = [&](uint8_t inventoryType) -> const game::ItemSlot* {
-            using ES = game::EquipSlot;
-            const auto& inv = gameHandler.getInventory();
-            auto slotPtr = [&](ES slot) -> const game::ItemSlot* {
-                const auto& s = inv.getEquipSlot(slot);
-                return s.empty() ? nullptr : &s;
-            };
-            switch (inventoryType) {
-                case 1: return slotPtr(ES::HEAD);
-                case 2: return slotPtr(ES::NECK);
-                case 3: return slotPtr(ES::SHOULDERS);
-                case 4: return slotPtr(ES::SHIRT);
-                case 5:
-                case 20: return slotPtr(ES::CHEST);
-                case 6: return slotPtr(ES::WAIST);
-                case 7: return slotPtr(ES::LEGS);
-                case 8: return slotPtr(ES::FEET);
-                case 9: return slotPtr(ES::WRISTS);
-                case 10: return slotPtr(ES::HANDS);
-                case 11: {
-                    if (auto* s = slotPtr(ES::RING1)) return s;
-                    return slotPtr(ES::RING2);
-                }
-                case 12: {
-                    if (auto* s = slotPtr(ES::TRINKET1)) return s;
-                    return slotPtr(ES::TRINKET2);
-                }
-                case 13:
-                    if (auto* s = slotPtr(ES::MAIN_HAND)) return s;
-                    return slotPtr(ES::OFF_HAND);
-                case 14:
-                case 22:
-                case 23: return slotPtr(ES::OFF_HAND);
-                case 15:
-                case 25:
-                case 26: return slotPtr(ES::RANGED);
-                case 16: return slotPtr(ES::BACK);
-                case 17:
-                case 21: return slotPtr(ES::MAIN_HAND);
-                case 18:
-                    for (int i = 0; i < game::Inventory::NUM_BAG_SLOTS; ++i) {
-                        auto slot = static_cast<ES>(static_cast<int>(ES::BAG1) + i);
-                        if (auto* s = slotPtr(slot)) return s;
-                    }
-                    return nullptr;
-                case 19: return slotPtr(ES::TABARD);
-                default: return nullptr;
-            }
-        };
-
-        ImGui::BeginTooltip();
-        // Quality color for name
-        auto qColor = ui::getQualityColor(static_cast<game::ItemQuality>(info->quality));
-        ImGui::TextColored(qColor, "%s", info->name.c_str());
-
-        // Heroic indicator (green, matches WoW tooltip style)
-        constexpr uint32_t kFlagHeroic         = 0x8;
-        constexpr uint32_t kFlagUniqueEquipped = 0x1000000;
-        if (info->itemFlags & kFlagHeroic)
-            ImGui::TextColored(ImVec4(0.0f, 0.8f, 0.0f, 1.0f), "Heroic");
-
-        // Bind type (appears right under name in WoW)
-        switch (info->bindType) {
-            case 1: ImGui::TextDisabled("Binds when picked up");   break;
-            case 2: ImGui::TextDisabled("Binds when equipped");    break;
-            case 3: ImGui::TextDisabled("Binds when used");        break;
-            case 4: ImGui::TextDisabled("Quest Item");             break;
-        }
-        // Unique / Unique-Equipped
-        if (info->maxCount == 1)
-            ImGui::TextColored(ui::colors::kTooltipGold, "Unique");
-        else if (info->itemFlags & kFlagUniqueEquipped)
-            ImGui::TextColored(ui::colors::kTooltipGold, "Unique-Equipped");
-
-        // Slot type
-        if (info->inventoryType > 0) {
-            const char* slotName = ui::getInventorySlotName(info->inventoryType);
-            if (slotName[0]) {
-                if (!info->subclassName.empty())
-                    ImGui::TextColored(ui::colors::kLightGray, "%s  %s", slotName, info->subclassName.c_str());
-                else
-                    ImGui::TextColored(ui::colors::kLightGray, "%s", slotName);
-            }
-        }
-        auto isWeaponInventoryType = [](uint32_t invType) {
-            switch (invType) {
-                case 13: // One-Hand
-                case 15: // Ranged
-                case 17: // Two-Hand
-                case 21: // Main Hand
-                case 25: // Thrown
-                case 26: // Ranged Right
-                    return true;
-                default:
-                    return false;
-            }
-        };
-        const bool isWeapon = isWeaponInventoryType(info->inventoryType);
-
-        // Item level (after slot/subclass)
-        if (info->itemLevel > 0)
-            ImGui::TextDisabled("Item Level %u", info->itemLevel);
-
-        if (isWeapon && info->damageMax > 0.0f && info->delayMs > 0) {
-            float speed = static_cast<float>(info->delayMs) / 1000.0f;
-            float dps = ((info->damageMin + info->damageMax) * 0.5f) / speed;
-            // WoW-style: "22 - 41 Damage" with speed right-aligned on same row
-            char dmgBuf[64], spdBuf[32];
-            std::snprintf(dmgBuf, sizeof(dmgBuf), "%d - %d Damage",
-                          static_cast<int>(info->damageMin), static_cast<int>(info->damageMax));
-            std::snprintf(spdBuf, sizeof(spdBuf), "Speed %.2f", speed);
-            float spdW = ImGui::CalcTextSize(spdBuf).x;
-            ImGui::Text("%s", dmgBuf);
-            ImGui::SameLine(ImGui::GetWindowWidth() - spdW - 16.0f);
-            ImGui::Text("%s", spdBuf);
-            ImGui::TextDisabled("(%.1f damage per second)", dps);
-        }
-        ImVec4 green(0.0f, 1.0f, 0.0f, 1.0f);
-        auto appendBonus = [](std::string& out, int32_t val, const char* shortName) {
-            if (val <= 0) return;
-            if (!out.empty()) out += "  ";
-            out += "+" + std::to_string(val) + " ";
-            out += shortName;
-        };
-        std::string bonusLine;
-        appendBonus(bonusLine, info->strength, "Str");
-        appendBonus(bonusLine, info->agility, "Agi");
-        appendBonus(bonusLine, info->stamina, "Sta");
-        appendBonus(bonusLine, info->intellect, "Int");
-        appendBonus(bonusLine, info->spirit, "Spi");
-        if (!bonusLine.empty()) {
-            ImGui::TextColored(green, "%s", bonusLine.c_str());
-        }
-        if (info->armor > 0) {
-            ImGui::Text("%d Armor", info->armor);
-        }
-        // Elemental resistances (fire resist gear, nature resist gear, etc.)
-        {
-            const int32_t resVals[6] = {
-                info->holyRes, info->fireRes, info->natureRes,
-                info->frostRes, info->shadowRes, info->arcaneRes
-            };
-            static constexpr const char* resLabels[6] = {
-                "Holy Resistance", "Fire Resistance", "Nature Resistance",
-                "Frost Resistance", "Shadow Resistance", "Arcane Resistance"
-            };
-            for (int ri = 0; ri < 6; ++ri)
-                if (resVals[ri] > 0) ImGui::Text("+%d %s", resVals[ri], resLabels[ri]);
-        }
-        // Extra stats (hit/crit/haste/sp/ap/expertise/resilience/etc.)
-        if (!info->extraStats.empty()) {
-            auto statName = [](uint32_t t) -> const char* {
-                switch (t) {
-                    case 12: return "Defense Rating";
-                    case 13: return "Dodge Rating";
-                    case 14: return "Parry Rating";
-                    case 15: return "Block Rating";
-                    case 16: case 17: case 18: case 31: return "Hit Rating";
-                    case 19: case 20: case 21: case 32: return "Critical Strike Rating";
-                    case 28: case 29: case 30: case 35: return "Haste Rating";
-                    case 34: return "Resilience Rating";
-                    case 36: return "Expertise Rating";
-                    case 37: return "Attack Power";
-                    case 38: return "Ranged Attack Power";
-                    case 45: return "Spell Power";
-                    case 46: return "Healing Power";
-                    case 47: return "Spell Damage";
-                    case 49: return "Mana per 5 sec.";
-                    case 43: return "Spell Penetration";
-                    case 44: return "Block Value";
-                    default: return nullptr;
-                }
-            };
-            for (const auto& es : info->extraStats) {
-                const char* nm = statName(es.statType);
-                if (nm && es.statValue > 0)
-                    ImGui::TextColored(green, "+%d %s", es.statValue, nm);
-            }
-        }
-        // Gem sockets (WotLK only — socketColor != 0 means socket present)
-        // socketColor bitmask: 1=Meta, 2=Red, 4=Yellow, 8=Blue
-        {
-            const auto& kSocketTypes = ui::kSocketTypes;
-            bool hasSocket = false;
-            for (int s = 0; s < 3; ++s) {
-                if (info->socketColor[s] == 0) continue;
-                if (!hasSocket) { ImGui::Spacing(); hasSocket = true; }
-                for (const auto& st : kSocketTypes) {
-                    if (info->socketColor[s] & st.mask) {
-                        ImGui::TextColored(st.col, "%s", st.label);
-                        break;
-                    }
-                }
-            }
-            if (hasSocket && info->socketBonus != 0) {
-                // Socket bonus ID maps to SpellItemEnchantment.dbc — lazy-load names
-                static std::unordered_map<uint32_t, std::string> s_enchantNames;
-                static bool s_enchantNamesLoaded = false;
-                if (!s_enchantNamesLoaded && assetMgr) {
-                    s_enchantNamesLoaded = true;
-                    auto dbc = assetMgr->loadDBC("SpellItemEnchantment.dbc");
-                    if (dbc && dbc->isLoaded()) {
-                        const auto* lay = pipeline::getActiveDBCLayout()
-                            ? pipeline::getActiveDBCLayout()->getLayout("SpellItemEnchantment") : nullptr;
-                        uint32_t nameField = lay ? lay->field("Name") : 8u;
-                        if (nameField == 0xFFFFFFFF) nameField = 8;
-                        uint32_t fc = dbc->getFieldCount();
-                        for (uint32_t r = 0; r < dbc->getRecordCount(); ++r) {
-                            uint32_t eid = dbc->getUInt32(r, 0);
-                            if (eid == 0 || nameField >= fc) continue;
-                            std::string ename = dbc->getString(r, nameField);
-                            if (!ename.empty()) s_enchantNames[eid] = std::move(ename);
-                        }
-                    }
-                }
-                auto enchIt = s_enchantNames.find(info->socketBonus);
-                if (enchIt != s_enchantNames.end())
-                    ImGui::TextColored(colors::kSocketGreen, "Socket Bonus: %s", enchIt->second.c_str());
-                else
-                    ImGui::TextColored(colors::kSocketGreen, "Socket Bonus: (id %u)", info->socketBonus);
-            }
-        }
-        // Item set membership
-        if (info->itemSetId != 0) {
-            struct SetEntry {
-                std::string name;
-                std::array<uint32_t, 10> itemIds{};
-                std::array<uint32_t, 10> spellIds{};
-                std::array<uint32_t, 10> thresholds{};
-            };
-            static std::unordered_map<uint32_t, SetEntry> s_setData;
-            static bool s_setDataLoaded = false;
-            if (!s_setDataLoaded && assetMgr) {
-                s_setDataLoaded = true;
-                auto dbc = assetMgr->loadDBC("ItemSet.dbc");
-                if (dbc && dbc->isLoaded()) {
-                    const auto* layout = pipeline::getActiveDBCLayout()
-                        ? pipeline::getActiveDBCLayout()->getLayout("ItemSet") : nullptr;
-                    auto lf = [&](const char* k, uint32_t def) -> uint32_t {
-                        return layout ? (*layout)[k] : def;
-                    };
-                    uint32_t idF = lf("ID", 0), nameF = lf("Name", 1);
-                    const auto& itemKeys = ui::kItemSetItemKeys;
-                    const auto& spellKeys = ui::kItemSetSpellKeys;
-                    const auto& thrKeys = ui::kItemSetThresholdKeys;
-                    for (uint32_t r = 0; r < dbc->getRecordCount(); ++r) {
-                        uint32_t id = dbc->getUInt32(r, idF);
-                        if (!id) continue;
-                        SetEntry e;
-                        e.name = dbc->getString(r, nameF);
-                        for (int i = 0; i < 10; ++i) {
-                            e.itemIds[i]    = dbc->getUInt32(r, layout ? (*layout)[itemKeys[i]]  : uint32_t(18 + i));
-                            e.spellIds[i]   = dbc->getUInt32(r, layout ? (*layout)[spellKeys[i]] : uint32_t(28 + i));
-                            e.thresholds[i] = dbc->getUInt32(r, layout ? (*layout)[thrKeys[i]]   : uint32_t(38 + i));
-                        }
-                        s_setData[id] = std::move(e);
-                    }
-                }
-            }
-            ImGui::Spacing();
-            const auto& inv = gameHandler.getInventory();
-            auto setIt = s_setData.find(info->itemSetId);
-            if (setIt != s_setData.end()) {
-                const SetEntry& se = setIt->second;
-                int equipped = 0, total = 0;
-                for (int i = 0; i < 10; ++i) {
-                    if (se.itemIds[i] == 0) continue;
-                    ++total;
-                    for (int sl = 0; sl < game::Inventory::NUM_EQUIP_SLOTS; sl++) {
-                        const auto& eq = inv.getEquipSlot(static_cast<game::EquipSlot>(sl));
-                        if (!eq.empty() && eq.item.itemId == se.itemIds[i]) { ++equipped; break; }
-                    }
-                }
-                if (total > 0)
-                    ImGui::TextColored(ui::colors::kTooltipGold,
-                        "%s (%d/%d)", se.name.empty() ? "Set" : se.name.c_str(), equipped, total);
-                else if (!se.name.empty())
-                    ImGui::TextColored(ui::colors::kTooltipGold, "%s", se.name.c_str());
-                for (int i = 0; i < 10; ++i) {
-                    if (se.spellIds[i] == 0 || se.thresholds[i] == 0) continue;
-                    const std::string& bname = gameHandler.getSpellName(se.spellIds[i]);
-                    bool active = (equipped >= static_cast<int>(se.thresholds[i]));
-                    ImVec4 col = active ? colors::kActiveGreen : colors::kInactiveGray;
-                    if (!bname.empty())
-                        ImGui::TextColored(col, "(%u) %s", se.thresholds[i], bname.c_str());
-                    else
-                        ImGui::TextColored(col, "(%u) Set Bonus", se.thresholds[i]);
-                }
-            } else {
-                ImGui::TextColored(ui::colors::kTooltipGold, "Set (id %u)", info->itemSetId);
-            }
-        }
-        // Item spell effects (Use / Equip / Chance on Hit / Teaches)
-        for (const auto& sp : info->spells) {
-            if (sp.spellId == 0) continue;
-            const char* triggerLabel = nullptr;
-            switch (sp.spellTrigger) {
-                case 0: triggerLabel = "Use";          break;
-                case 1: triggerLabel = "Equip";        break;
-                case 2: triggerLabel = "Chance on Hit"; break;
-                case 5: triggerLabel = "Teaches";      break;
-            }
-            if (!triggerLabel) continue;
-            // Use full spell description if available (matches inventory tooltip style)
-            const std::string& spDesc = gameHandler.getSpellDescription(sp.spellId);
-            const std::string& spText = !spDesc.empty() ? spDesc
-                                        : gameHandler.getSpellName(sp.spellId);
-            if (!spText.empty()) {
-                ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + 300.0f);
-                ImGui::TextColored(colors::kCyan,
-                                   "%s: %s", triggerLabel, spText.c_str());
-                ImGui::PopTextWrapPos();
-            }
-        }
-        // Required level
-        if (info->requiredLevel > 1)
-            ImGui::TextDisabled("Requires Level %u", info->requiredLevel);
-        // Required skill (e.g. "Requires Blacksmithing (300)")
-        if (info->requiredSkill != 0 && info->requiredSkillRank > 0) {
-            static std::unordered_map<uint32_t, std::string> s_skillNames;
-            static bool s_skillNamesLoaded = false;
-            if (!s_skillNamesLoaded && assetMgr) {
-                s_skillNamesLoaded = true;
-                auto dbc = assetMgr->loadDBC("SkillLine.dbc");
-                if (dbc && dbc->isLoaded()) {
-                    const auto* layout = pipeline::getActiveDBCLayout()
-                        ? pipeline::getActiveDBCLayout()->getLayout("SkillLine") : nullptr;
-                    uint32_t idF   = layout ? (*layout)["ID"]   : 0u;
-                    uint32_t nameF = layout ? (*layout)["Name"] : 2u;
-                    for (uint32_t r = 0; r < dbc->getRecordCount(); ++r) {
-                        uint32_t sid = dbc->getUInt32(r, idF);
-                        if (!sid) continue;
-                        std::string sname = dbc->getString(r, nameF);
-                        if (!sname.empty()) s_skillNames[sid] = std::move(sname);
-                    }
-                }
-            }
-            uint32_t playerSkillVal = 0;
-            const auto& skills = gameHandler.getPlayerSkills();
-            auto skPit = skills.find(info->requiredSkill);
-            if (skPit != skills.end()) playerSkillVal = skPit->second.effectiveValue();
-            bool meetsSkill = (playerSkillVal == 0 || playerSkillVal >= info->requiredSkillRank);
-            ImVec4 skColor = meetsSkill ? ImVec4(1.0f, 1.0f, 1.0f, 0.75f) : colors::kPaleRed;
-            auto skIt = s_skillNames.find(info->requiredSkill);
-            if (skIt != s_skillNames.end())
-                ImGui::TextColored(skColor, "Requires %s (%u)", skIt->second.c_str(), info->requiredSkillRank);
-            else
-                ImGui::TextColored(skColor, "Requires Skill %u (%u)", info->requiredSkill, info->requiredSkillRank);
-        }
-        // Required reputation (e.g. "Requires Exalted with Argent Dawn")
-        if (info->requiredReputationFaction != 0 && info->requiredReputationRank > 0) {
-            static std::unordered_map<uint32_t, std::string> s_factionNames;
-            static bool s_factionNamesLoaded = false;
-            if (!s_factionNamesLoaded && assetMgr) {
-                s_factionNamesLoaded = true;
-                auto dbc = assetMgr->loadDBC("Faction.dbc");
-                if (dbc && dbc->isLoaded()) {
-                    const auto* layout = pipeline::getActiveDBCLayout()
-                        ? pipeline::getActiveDBCLayout()->getLayout("Faction") : nullptr;
-                    uint32_t idF   = layout ? (*layout)["ID"]   : 0u;
-                    uint32_t nameF = layout ? (*layout)["Name"] : 20u;
-                    for (uint32_t r = 0; r < dbc->getRecordCount(); ++r) {
-                        uint32_t fid = dbc->getUInt32(r, idF);
-                        if (!fid) continue;
-                        std::string fname = dbc->getString(r, nameF);
-                        if (!fname.empty()) s_factionNames[fid] = std::move(fname);
-                    }
-                }
-            }
-            static constexpr const char* kRepRankNames[] = {
-                "Hated", "Hostile", "Unfriendly", "Neutral",
-                "Friendly", "Honored", "Revered", "Exalted"
-            };
-            const char* rankName = (info->requiredReputationRank < 8)
-                ? kRepRankNames[info->requiredReputationRank] : "Unknown";
-            auto fIt = s_factionNames.find(info->requiredReputationFaction);
-            ImGui::TextColored(ImVec4(1.0f, 1.0f, 1.0f, 0.75f), "Requires %s with %s",
-                rankName,
-                fIt != s_factionNames.end() ? fIt->second.c_str() : "Unknown Faction");
-        }
-        // Class restriction (e.g. "Classes: Paladin, Warrior")
-        if (info->allowableClass != 0) {
-            const auto& kClasses = ui::kClassMasks;
-            int matchCount = 0;
-            for (const auto& kc : kClasses)
-                if (info->allowableClass & kc.mask) ++matchCount;
-            if (matchCount > 0 && matchCount < 10) {
-                char classBuf[128] = "Classes: ";
-                bool first = true;
-                for (const auto& kc : kClasses) {
-                    if (!(info->allowableClass & kc.mask)) continue;
-                    if (!first) strncat(classBuf, ", ", sizeof(classBuf) - strlen(classBuf) - 1);
-                    strncat(classBuf, kc.name, sizeof(classBuf) - strlen(classBuf) - 1);
-                    first = false;
-                }
-                uint8_t pc = gameHandler.getPlayerClass();
-                uint32_t pmask = (pc > 0 && pc <= 10) ? (1u << (pc - 1)) : 0u;
-                bool playerAllowed = (pmask == 0 || (info->allowableClass & pmask));
-                ImVec4 clColor = playerAllowed ? ImVec4(1.0f, 1.0f, 1.0f, 0.75f) : colors::kPaleRed;
-                ImGui::TextColored(clColor, "%s", classBuf);
-            }
-        }
-        // Race restriction (e.g. "Races: Night Elf, Human")
-        if (info->allowableRace != 0) {
-            const auto& kRaces = ui::kRaceMasks;
-            constexpr uint32_t kAllPlayable = 1|2|4|8|16|32|64|128|512|1024;
-            if ((info->allowableRace & kAllPlayable) != kAllPlayable) {
-                int matchCount = 0;
-                for (const auto& kr : kRaces)
-                    if (info->allowableRace & kr.mask) ++matchCount;
-                if (matchCount > 0) {
-                    char raceBuf[160] = "Races: ";
-                    bool first = true;
-                    for (const auto& kr : kRaces) {
-                        if (!(info->allowableRace & kr.mask)) continue;
-                        if (!first) strncat(raceBuf, ", ", sizeof(raceBuf) - strlen(raceBuf) - 1);
-                        strncat(raceBuf, kr.name, sizeof(raceBuf) - strlen(raceBuf) - 1);
-                        first = false;
-                    }
-                    uint8_t pr = gameHandler.getPlayerRace();
-                    uint32_t pmask = (pr > 0 && pr <= 11) ? (1u << (pr - 1)) : 0u;
-                    bool playerAllowed = (pmask == 0 || (info->allowableRace & pmask));
-                    ImVec4 rColor = playerAllowed ? ImVec4(1.0f, 1.0f, 1.0f, 0.75f) : colors::kPaleRed;
-                    ImGui::TextColored(rColor, "%s", raceBuf);
-                }
-            }
-        }
-        // Flavor / lore text (shown in gold italic in WoW, use a yellow-ish dim color here)
-        if (!info->description.empty()) {
-            ImGui::Spacing();
-            ImGui::PushTextWrapPos(300.0f);
-            ImGui::TextColored(ImVec4(1.0f, 0.82f, 0.0f, 0.85f), "\"%s\"", info->description.c_str());
-            ImGui::PopTextWrapPos();
-        }
-        if (info->sellPrice > 0) {
-            ImGui::TextDisabled("Sell:"); ImGui::SameLine(0, 4);
-            renderCoinsFromCopper(info->sellPrice);
-        }
-
-        if (ImGui::GetIO().KeyShift && info->inventoryType > 0) {
-            if (const auto* eq = findComparableEquipped(static_cast<uint8_t>(info->inventoryType))) {
-                ImGui::Separator();
-                ImGui::TextDisabled("Equipped:");
-                VkDescriptorSet eqIcon = inventoryScreen.getItemIcon(eq->item.displayInfoId);
-                if (eqIcon) {
-                    ImGui::Image((ImTextureID)(uintptr_t)eqIcon, ImVec2(18.0f, 18.0f));
-                    ImGui::SameLine();
-                }
-                ImGui::TextColored(InventoryScreen::getQualityColor(eq->item.quality), "%s", eq->item.name.c_str());
-                if (isWeaponInventoryType(eq->item.inventoryType) &&
-                    eq->item.damageMax > 0.0f && eq->item.delayMs > 0) {
-                    float speed = static_cast<float>(eq->item.delayMs) / 1000.0f;
-                    float dps = ((eq->item.damageMin + eq->item.damageMax) * 0.5f) / speed;
-                    char eqDmg[64], eqSpd[32];
-                    std::snprintf(eqDmg, sizeof(eqDmg), "%d - %d Damage",
-                                  static_cast<int>(eq->item.damageMin), static_cast<int>(eq->item.damageMax));
-                    std::snprintf(eqSpd, sizeof(eqSpd), "Speed %.2f", speed);
-                    float eqSpdW = ImGui::CalcTextSize(eqSpd).x;
-                    ImGui::Text("%s", eqDmg);
-                    ImGui::SameLine(ImGui::GetWindowWidth() - eqSpdW - 16.0f);
-                    ImGui::Text("%s", eqSpd);
-                    ImGui::TextDisabled("(%.1f damage per second)", dps);
-                }
-                if (eq->item.armor > 0) {
-                    ImGui::Text("%d Armor", eq->item.armor);
-                }
-                std::string eqBonusLine;
-                appendBonus(eqBonusLine, eq->item.strength, "Str");
-                appendBonus(eqBonusLine, eq->item.agility, "Agi");
-                appendBonus(eqBonusLine, eq->item.stamina, "Sta");
-                appendBonus(eqBonusLine, eq->item.intellect, "Int");
-                appendBonus(eqBonusLine, eq->item.spirit, "Spi");
-                if (!eqBonusLine.empty()) {
-                    ImGui::TextColored(green, "%s", eqBonusLine.c_str());
-                }
-                // Extra stats for the equipped item
-                for (const auto& es : eq->item.extraStats) {
-                    const char* nm = nullptr;
-                    switch (es.statType) {
-                        case 12: nm = "Defense Rating"; break;
-                        case 13: nm = "Dodge Rating"; break;
-                        case 14: nm = "Parry Rating"; break;
-                        case 16: case 17: case 18: case 31: nm = "Hit Rating"; break;
-                        case 19: case 20: case 21: case 32: nm = "Critical Strike Rating"; break;
-                        case 28: case 29: case 30: case 35: nm = "Haste Rating"; break;
-                        case 34: nm = "Resilience Rating"; break;
-                        case 36: nm = "Expertise Rating"; break;
-                        case 37: nm = "Attack Power"; break;
-                        case 38: nm = "Ranged Attack Power"; break;
-                        case 45: nm = "Spell Power"; break;
-                        case 46: nm = "Healing Power"; break;
-                        case 49: nm = "Mana per 5 sec."; break;
-                        default: break;
-                    }
-                    if (nm && es.statValue > 0)
-                        ImGui::TextColored(green, "+%d %s", es.statValue, nm);
-                }
-            }
-        }
-        ImGui::EndTooltip();
-    };
-
-    // Helper: render text with clickable URLs and WoW item links
-    auto renderTextWithLinks = [&](const std::string& text, const ImVec4& color) {
-        size_t pos = 0;
-        while (pos < text.size()) {
-            // Find next special element: URL or WoW link
-            size_t urlStart = text.find("https://", pos);
-
-            // Find next WoW link (may be colored with |c prefix or bare |H)
-            size_t linkStart = text.find("|c", pos);
-            // Also handle bare |H links without color prefix
-            size_t bareItem  = text.find("|Hitem:",  pos);
-            size_t bareSpell = text.find("|Hspell:", pos);
-            size_t bareQuest = text.find("|Hquest:", pos);
-            size_t bareLinkStart = std::min({bareItem, bareSpell, bareQuest});
-
-            // Determine which comes first
-            size_t nextSpecial = std::min({urlStart, linkStart, bareLinkStart});
-
-            if (nextSpecial == std::string::npos) {
-                // No more special elements, render remaining text
-                std::string remaining = text.substr(pos);
-                if (!remaining.empty()) {
-                    ImGui::PushStyleColor(ImGuiCol_Text, color);
-                    ImGui::TextWrapped("%s", remaining.c_str());
-                    ImGui::PopStyleColor();
-                }
-                break;
-            }
-
-            // Render plain text before special element
-            if (nextSpecial > pos) {
-                std::string before = text.substr(pos, nextSpecial - pos);
-                ImGui::PushStyleColor(ImGuiCol_Text, color);
-                ImGui::TextWrapped("%s", before.c_str());
-                ImGui::PopStyleColor();
-                ImGui::SameLine(0, 0);
-            }
-
-            // Handle WoW item link
-            if (nextSpecial == linkStart || nextSpecial == bareLinkStart) {
-                ImVec4 linkColor = color;
-                size_t hStart = std::string::npos;
-
-                if (nextSpecial == linkStart && text.size() > linkStart + 10) {
-                    // Parse |cAARRGGBB color
-                    linkColor = parseWowColor(text, linkStart);
-                    // Find the nearest |H link of any supported type
-                    size_t hItem  = text.find("|Hitem:",        linkStart + 10);
-                    size_t hSpell = text.find("|Hspell:",       linkStart + 10);
-                    size_t hQuest = text.find("|Hquest:",       linkStart + 10);
-                    size_t hAch   = text.find("|Hachievement:", linkStart + 10);
-                    hStart = std::min({hItem, hSpell, hQuest, hAch});
-                } else if (nextSpecial == bareLinkStart) {
-                    hStart = bareLinkStart;
-                }
-
-                if (hStart != std::string::npos) {
-                    // Determine link type
-                    const bool isSpellLink = (text.compare(hStart, 8, "|Hspell:") == 0);
-                    const bool isQuestLink = (text.compare(hStart, 8, "|Hquest:") == 0);
-                    const bool isAchievLink = (text.compare(hStart, 14, "|Hachievement:") == 0);
-                    // Default: item link
-
-                    // Parse the first numeric ID after |Htype:
-                    size_t idOffset = isSpellLink ? 8 : (isQuestLink ? 8 : (isAchievLink ? 14 : 7));
-                    size_t entryStart = hStart + idOffset;
-                    size_t entryEnd = text.find(':', entryStart);
-                    uint32_t linkId = 0;
-                    if (entryEnd != std::string::npos) {
-                        linkId = static_cast<uint32_t>(strtoul(
-                            text.substr(entryStart, entryEnd - entryStart).c_str(), nullptr, 10));
-                    }
-
-                    // Find display name: |h[Name]|h
-                    size_t nameTagStart = text.find("|h[", hStart);
-                    size_t nameTagEnd = (nameTagStart != std::string::npos)
-                        ? text.find("]|h", nameTagStart + 3) : std::string::npos;
-
-                    std::string linkName = isSpellLink ? "Unknown Spell"
-                                        : isQuestLink  ? "Unknown Quest"
-                                        : isAchievLink ? "Unknown Achievement"
-                                        : "Unknown Item";
-                    if (nameTagStart != std::string::npos && nameTagEnd != std::string::npos) {
-                        linkName = text.substr(nameTagStart + 3, nameTagEnd - nameTagStart - 3);
-                    }
-
-                    // Find end of entire link sequence (|r or after ]|h)
-                    size_t linkEnd = (nameTagEnd != std::string::npos) ? nameTagEnd + 3 : hStart + idOffset;
-                    size_t resetPos = text.find("|r", linkEnd);
-                    if (resetPos != std::string::npos && resetPos <= linkEnd + 2) {
-                        linkEnd = resetPos + 2;
-                    }
-
-                    if (!isSpellLink && !isQuestLink && !isAchievLink) {
-                        // --- Item link ---
-                        uint32_t itemEntry = linkId;
-                        if (itemEntry > 0) {
-                            gameHandler.ensureItemInfo(itemEntry);
-                        }
-
-                        // Show small icon before item link if available
-                        if (itemEntry > 0) {
-                            const auto* chatInfo = gameHandler.getItemInfo(itemEntry);
-                            if (chatInfo && chatInfo->valid && chatInfo->displayInfoId != 0) {
-                                VkDescriptorSet chatIcon = inventoryScreen.getItemIcon(chatInfo->displayInfoId);
-                                if (chatIcon) {
-                                    ImGui::Image((ImTextureID)(uintptr_t)chatIcon, ImVec2(12, 12));
-                                    if (ImGui::IsItemHovered()) {
-                                        ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
-                                        renderItemLinkTooltip(itemEntry);
-                                    }
-                                    ImGui::SameLine(0, 2);
-                                }
-                            }
-                        }
-
-                        // Render bracketed item name in quality color
-                        std::string display = "[" + linkName + "]";
-                        ImGui::PushStyleColor(ImGuiCol_Text, linkColor);
-                        ImGui::TextWrapped("%s", display.c_str());
-                        ImGui::PopStyleColor();
-
-                        if (ImGui::IsItemHovered()) {
-                            ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
-                            if (itemEntry > 0) {
-                                renderItemLinkTooltip(itemEntry);
-                            }
-                        }
-                    } else if (isSpellLink) {
-                        // --- Spell link: |Hspell:SPELLID:RANK|h[Name]|h ---
-                        // Small icon (use spell icon cache if available)
-                        VkDescriptorSet spellIcon = (linkId > 0) ? getSpellIcon(linkId, assetMgr) : VK_NULL_HANDLE;
-                        if (spellIcon) {
-                            ImGui::Image((ImTextureID)(uintptr_t)spellIcon, ImVec2(12, 12));
-                            if (ImGui::IsItemHovered()) {
-                                ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
-                                spellbookScreen.renderSpellInfoTooltip(linkId, gameHandler, assetMgr);
-                            }
-                            ImGui::SameLine(0, 2);
-                        }
-
-                        std::string display = "[" + linkName + "]";
-                        ImGui::PushStyleColor(ImGuiCol_Text, linkColor);
-                        ImGui::TextWrapped("%s", display.c_str());
-                        ImGui::PopStyleColor();
-
-                        if (ImGui::IsItemHovered()) {
-                            ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
-                            if (linkId > 0) {
-                                spellbookScreen.renderSpellInfoTooltip(linkId, gameHandler, assetMgr);
-                            }
-                        }
-                    } else if (isQuestLink) {
-                        // --- Quest link: |Hquest:QUESTID:QUESTLEVEL|h[Name]|h ---
-                        std::string display = "[" + linkName + "]";
-                        ImGui::PushStyleColor(ImGuiCol_Text, colors::kWarmGold); // gold
-                        ImGui::TextWrapped("%s", display.c_str());
-                        ImGui::PopStyleColor();
-
-                        if (ImGui::IsItemHovered()) {
-                            ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
-                            ImGui::BeginTooltip();
-                            ImGui::TextColored(colors::kWarmGold, "%s", linkName.c_str());
-                            // Parse quest level (second field after questId)
-                            if (entryEnd != std::string::npos) {
-                                size_t lvlEnd = text.find(':', entryEnd + 1);
-                                if (lvlEnd == std::string::npos) lvlEnd = text.find('|', entryEnd + 1);
-                                if (lvlEnd != std::string::npos) {
-                                    uint32_t qLvl = static_cast<uint32_t>(strtoul(
-                                        text.substr(entryEnd + 1, lvlEnd - entryEnd - 1).c_str(), nullptr, 10));
-                                    if (qLvl > 0) ImGui::TextDisabled("Level %u Quest", qLvl);
-                                }
-                            }
-                            ImGui::TextDisabled("Click quest log to view details");
-                            ImGui::EndTooltip();
-                        }
-                        // Click: open quest log and select this quest if we have it
-                        if (ImGui::IsItemClicked() && linkId > 0) {
-                            questLogScreen.openAndSelectQuest(linkId);
-                        }
-                    } else {
-                        // --- Achievement link ---
-                        std::string display = "[" + linkName + "]";
-                        ImGui::PushStyleColor(ImGuiCol_Text, colors::kBrightGold); // gold
-                        ImGui::TextWrapped("%s", display.c_str());
-                        ImGui::PopStyleColor();
-
-                        if (ImGui::IsItemHovered()) {
-                            ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
-                            ImGui::SetTooltip("Achievement: %s", linkName.c_str());
-                        }
-                    }
-
-                    // Shift-click: insert entire link back into chat input
-                    if (ImGui::IsItemClicked() && ImGui::GetIO().KeyShift) {
-                        std::string linkText = text.substr(nextSpecial, linkEnd - nextSpecial);
-                        size_t curLen = strlen(chatInputBuffer_);
-                        if (curLen + linkText.size() + 1 < sizeof(chatInputBuffer_)) {
-                            strncat(chatInputBuffer_, linkText.c_str(), sizeof(chatInputBuffer_) - curLen - 1);
-                            chatInputMoveCursorToEnd_ = true;
-                        }
-                    }
-
-                    pos = linkEnd;
-                    continue;
-                }
-
-                // Not an item link — treat as colored text: |cAARRGGBB...text...|r
-                if (nextSpecial == linkStart && text.size() > linkStart + 10) {
-                    ImVec4 cColor = parseWowColor(text, linkStart);
-                    size_t textStart = linkStart + 10; // after |cAARRGGBB
-                    size_t resetPos2 = text.find("|r", textStart);
-                    std::string coloredText;
-                    if (resetPos2 != std::string::npos) {
-                        coloredText = text.substr(textStart, resetPos2 - textStart);
-                        pos = resetPos2 + 2; // skip |r
-                    } else {
-                        coloredText = text.substr(textStart);
-                        pos = text.size();
-                    }
-                    // Strip any remaining WoW markup from the colored segment
-                    // (e.g. |H...|h pairs that aren't item links)
-                    std::string clean;
-                    for (size_t i = 0; i < coloredText.size(); i++) {
-                        if (coloredText[i] == '|' && i + 1 < coloredText.size()) {
-                            char next = coloredText[i + 1];
-                            if (next == 'H') {
-                                // Skip |H...|h
-                                size_t hEnd = coloredText.find("|h", i + 2);
-                                if (hEnd != std::string::npos) { i = hEnd + 1; continue; }
-                            } else if (next == 'h') {
-                                i += 1; continue; // skip |h
-                            } else if (next == 'r') {
-                                i += 1; continue; // skip |r
-                            }
-                        }
-                        clean += coloredText[i];
-                    }
-                    if (!clean.empty()) {
-                        ImGui::PushStyleColor(ImGuiCol_Text, cColor);
-                        ImGui::TextWrapped("%s", clean.c_str());
-                        ImGui::PopStyleColor();
-                        ImGui::SameLine(0, 0);
-                    }
-                } else {
-                    // Bare |c without enough chars for color — render literally
-                    ImGui::PushStyleColor(ImGuiCol_Text, color);
-                    ImGui::TextWrapped("|c");
-                    ImGui::PopStyleColor();
-                    ImGui::SameLine(0, 0);
-                    pos = nextSpecial + 2;
-                }
-                continue;
-            }
-
-            // Handle URL
-            if (nextSpecial == urlStart) {
-                size_t urlEnd = text.find_first_of(" \t\n\r", urlStart);
-                if (urlEnd == std::string::npos) urlEnd = text.size();
-                std::string url = text.substr(urlStart, urlEnd - urlStart);
-
-                ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.4f, 0.7f, 1.0f, 1.0f));
-                ImGui::TextWrapped("%s", url.c_str());
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
-                    ImGui::SetTooltip("Open: %s", url.c_str());
-                }
-                if (ImGui::IsItemClicked()) {
-                    std::string cmd = "xdg-open '" + url + "' &";
-                    [[maybe_unused]] int result = system(cmd.c_str());
-                }
-                ImGui::PopStyleColor();
-
-                pos = urlEnd;
-                continue;
-            }
-        }
-    };
-
-    // Determine local player name for mention detection (case-insensitive)
-    std::string selfNameLower;
-    {
-        const auto* ch = gameHandler.getActiveCharacter();
-        if (ch && !ch->name.empty()) {
-            selfNameLower = ch->name;
-            for (auto& c : selfNameLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-        }
-    }
-
-    // Scan NEW messages (beyond chatMentionSeenCount_) for mentions and play notification sound
-    if (!selfNameLower.empty() && chatHistory.size() > chatMentionSeenCount_) {
-        for (size_t mi = chatMentionSeenCount_; mi < chatHistory.size(); ++mi) {
-            const auto& mMsg = chatHistory[mi];
-            // Skip outgoing whispers, system, and monster messages
-            if (mMsg.type == game::ChatType::WHISPER_INFORM ||
-                mMsg.type == game::ChatType::SYSTEM) continue;
-            // Case-insensitive search in message body
-            std::string bodyLower = mMsg.message;
-            for (auto& c : bodyLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-            if (bodyLower.find(selfNameLower) != std::string::npos) {
-                if (auto* ac = services_.audioCoordinator) {
-                    if (auto* ui = ac->getUiSoundManager())
-                        ui->playWhisperReceived();
-                }
-                break; // play at most once per scan pass
-            }
-        }
-        chatMentionSeenCount_ = chatHistory.size();
-    } else if (chatHistory.size() <= chatMentionSeenCount_) {
-        chatMentionSeenCount_ = chatHistory.size();  // reset if history was cleared
-    }
-
-    // Whisper toast scanning left in GameScreen (will move to ToastManager later)
-
-    int chatMsgIdx = 0;
-    for (const auto& msg : chatHistory) {
-        if (!shouldShowMessage(msg, activeChatTab)) continue;
-        std::string processedMessage = replaceGenderPlaceholders(msg.message, gameHandler);
-
-        // Resolve sender name at render time in case it wasn't available at parse time.
-        // This handles the race where SMSG_MESSAGECHAT arrives before the entity spawns.
-        const std::string& resolvedSenderName = [&]() -> const std::string& {
-            if (!msg.senderName.empty()) return msg.senderName;
-            if (msg.senderGuid == 0) return msg.senderName;
-            const std::string& cached = gameHandler.lookupName(msg.senderGuid);
-            if (!cached.empty()) return cached;
-            return msg.senderName;
-        }();
-
-        ImVec4 color = getChatTypeColor(msg.type);
-
-        // Optional timestamp prefix
-        std::string tsPrefix;
-        if (chatShowTimestamps) {
-            auto tt = std::chrono::system_clock::to_time_t(msg.timestamp);
-            std::tm tm{};
-#ifdef _WIN32
-            localtime_s(&tm, &tt);
-#else
-            localtime_r(&tt, &tm);
-#endif
-            char tsBuf[16];
-            snprintf(tsBuf, sizeof(tsBuf), "[%02d:%02d] ", tm.tm_hour, tm.tm_min);
-            tsPrefix = tsBuf;
-        }
-
-        // Build chat tag prefix: <GM>, <AFK>, <DND> from chatTag bitmask
-        std::string tagPrefix;
-        if (msg.chatTag & 0x04) tagPrefix = "<GM> ";
-        else if (msg.chatTag & 0x01) tagPrefix = "<AFK> ";
-        else if (msg.chatTag & 0x02) tagPrefix = "<DND> ";
-
-        // Build full message string for this entry
-        std::string fullMsg;
-        if (msg.type == game::ChatType::SYSTEM || msg.type == game::ChatType::TEXT_EMOTE) {
-            fullMsg = tsPrefix + processedMessage;
-        } else if (!resolvedSenderName.empty()) {
-            if (msg.type == game::ChatType::SAY ||
-                msg.type == game::ChatType::MONSTER_SAY || msg.type == game::ChatType::MONSTER_PARTY) {
-                fullMsg = tsPrefix + tagPrefix + resolvedSenderName + " says: " + processedMessage;
-            } else if (msg.type == game::ChatType::YELL || msg.type == game::ChatType::MONSTER_YELL) {
-                fullMsg = tsPrefix + tagPrefix + resolvedSenderName + " yells: " + processedMessage;
-            } else if (msg.type == game::ChatType::WHISPER ||
-                       msg.type == game::ChatType::MONSTER_WHISPER || msg.type == game::ChatType::RAID_BOSS_WHISPER) {
-                fullMsg = tsPrefix + tagPrefix + resolvedSenderName + " whispers: " + processedMessage;
-            } else if (msg.type == game::ChatType::WHISPER_INFORM) {
-                const std::string& target = !msg.receiverName.empty() ? msg.receiverName : resolvedSenderName;
-                fullMsg = tsPrefix + "To " + target + ": " + processedMessage;
-            } else if (msg.type == game::ChatType::EMOTE ||
-                       msg.type == game::ChatType::MONSTER_EMOTE || msg.type == game::ChatType::RAID_BOSS_EMOTE) {
-                fullMsg = tsPrefix + tagPrefix + resolvedSenderName + " " + processedMessage;
-            } else if (msg.type == game::ChatType::CHANNEL && !msg.channelName.empty()) {
-                int chIdx = gameHandler.getChannelIndex(msg.channelName);
-                std::string chDisplay = chIdx > 0
-                    ? "[" + std::to_string(chIdx) + ". " + msg.channelName + "]"
-                    : "[" + msg.channelName + "]";
-                fullMsg = tsPrefix + chDisplay + " [" + tagPrefix + resolvedSenderName + "]: " + processedMessage;
-            } else {
-                fullMsg = tsPrefix + "[" + std::string(getChatTypeName(msg.type)) + "] " + tagPrefix + resolvedSenderName + ": " + processedMessage;
-            }
-        } else {
-            bool isGroupType =
-                msg.type == game::ChatType::PARTY ||
-                msg.type == game::ChatType::GUILD ||
-                msg.type == game::ChatType::OFFICER ||
-                msg.type == game::ChatType::RAID ||
-                msg.type == game::ChatType::RAID_LEADER ||
-                msg.type == game::ChatType::RAID_WARNING ||
-                msg.type == game::ChatType::BATTLEGROUND ||
-                msg.type == game::ChatType::BATTLEGROUND_LEADER;
-            if (isGroupType) {
-                fullMsg = tsPrefix + "[" + std::string(getChatTypeName(msg.type)) + "] " + processedMessage;
-            } else {
-                fullMsg = tsPrefix + processedMessage;
-            }
-        }
-
-        // Detect mention: does this message contain the local player's name?
-        bool isMention = false;
-        if (!selfNameLower.empty() &&
-            msg.type != game::ChatType::WHISPER_INFORM &&
-            msg.type != game::ChatType::SYSTEM) {
-            std::string msgLower = fullMsg;
-            for (auto& c : msgLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-            isMention = (msgLower.find(selfNameLower) != std::string::npos);
-        }
-
-        // Render message in a group so we can attach a right-click context menu
-        ImGui::PushID(chatMsgIdx++);
-        ImGui::BeginGroup();
-        renderTextWithLinks(fullMsg, isMention ? ImVec4(1.0f, 0.9f, 0.35f, 1.0f) : color);
-        ImGui::EndGroup();
-        if (isMention) {
-            // Draw highlight AFTER rendering so the rect covers all wrapped lines,
-            // not just the first. Previously used a pre-render single-lineH rect.
-            ImVec2 rMin = ImGui::GetItemRectMin();
-            ImVec2 rMax = ImGui::GetItemRectMax();
-            float availW = ImGui::GetContentRegionAvail().x + ImGui::GetCursorScreenPos().x - rMin.x;
-            ImGui::GetWindowDrawList()->AddRectFilled(
-                rMin, ImVec2(rMin.x + availW, rMax.y),
-                IM_COL32(255, 200, 50, 45));  // soft golden tint
-        }
-
-        // Right-click context menu (only for player messages with a sender)
-        bool isPlayerMsg = !resolvedSenderName.empty() &&
-            msg.type != game::ChatType::SYSTEM &&
-            msg.type != game::ChatType::TEXT_EMOTE &&
-            msg.type != game::ChatType::MONSTER_SAY &&
-            msg.type != game::ChatType::MONSTER_YELL &&
-            msg.type != game::ChatType::MONSTER_WHISPER &&
-            msg.type != game::ChatType::MONSTER_EMOTE &&
-            msg.type != game::ChatType::MONSTER_PARTY &&
-            msg.type != game::ChatType::RAID_BOSS_WHISPER &&
-            msg.type != game::ChatType::RAID_BOSS_EMOTE;
-
-        if (isPlayerMsg && ImGui::BeginPopupContextItem("ChatMsgCtx")) {
-            ImGui::TextDisabled("%s", resolvedSenderName.c_str());
-            ImGui::Separator();
-            if (ImGui::MenuItem("Whisper")) {
-                selectedChatType_ = 4; // WHISPER
-                strncpy(whisperTargetBuffer_, resolvedSenderName.c_str(), sizeof(whisperTargetBuffer_) - 1);
-                whisperTargetBuffer_[sizeof(whisperTargetBuffer_) - 1] = '\0';
-                refocusChatInput_ = true;
-            }
-            if (ImGui::MenuItem("Invite to Group")) {
-                gameHandler.inviteToGroup(resolvedSenderName);
-            }
-            if (ImGui::MenuItem("Add Friend")) {
-                gameHandler.addFriend(resolvedSenderName);
-            }
-            if (ImGui::MenuItem("Ignore")) {
-                gameHandler.addIgnore(resolvedSenderName);
-            }
-            ImGui::EndPopup();
-        }
-
-        ImGui::PopID();
-    }
-
-    // Auto-scroll to bottom; track whether user has scrolled up
-    {
-        float scrollY    = ImGui::GetScrollY();
-        float scrollMaxY = ImGui::GetScrollMaxY();
-        bool atBottom = (scrollMaxY <= 0.0f) || (scrollY >= scrollMaxY - 2.0f);
-        if (atBottom || chatForceScrollToBottom_) {
-            ImGui::SetScrollHereY(1.0f);
-            chatScrolledUp_ = false;
-            chatForceScrollToBottom_ = false;
-        } else {
-            chatScrolledUp_ = true;
-        }
-    }
-
-    ImGui::EndChild();
-
-    // Reset font scale after chat history
-    ImGui::SetWindowFontScale(1.0f);
-
-    // "Jump to bottom" indicator when scrolled up
-    if (chatScrolledUp_) {
-        ImGui::PushStyleColor(ImGuiCol_Button,        ImVec4(0.2f, 0.35f, 0.7f, 0.9f));
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.3f, 0.5f,  0.9f, 1.0f));
-        if (ImGui::SmallButton("  v  New messages  ")) {
-            chatForceScrollToBottom_ = true;
-        }
-        ImGui::PopStyleColor(2);
-        ImGui::SameLine();
-    }
-
-    ImGui::Spacing();
-    ImGui::Separator();
-    ImGui::Spacing();
-    // Lock toggle
-    ImGui::Checkbox("Lock", &chatWindowLocked_);
-    ImGui::SameLine();
-    ImGui::TextDisabled(chatWindowLocked_ ? "(locked)" : "(movable)");
-
-    // Chat input
-    ImGui::Text("Type:");
-    ImGui::SameLine();
-    ImGui::SetNextItemWidth(100);
-    const char* chatTypes[] = { "SAY", "YELL", "PARTY", "GUILD", "WHISPER", "RAID", "OFFICER", "BATTLEGROUND", "RAID WARNING", "INSTANCE", "CHANNEL" };
-    ImGui::Combo("##ChatType", &selectedChatType_, chatTypes, 11);
-
-    // Auto-fill whisper target when switching to WHISPER mode
-    if (selectedChatType_ == 4 && lastChatType_ != 4) {
-        // Just switched to WHISPER mode
-        if (gameHandler.hasTarget()) {
-            auto target = gameHandler.getTarget();
-            if (target && target->getType() == game::ObjectType::PLAYER) {
-                auto player = std::static_pointer_cast<game::Player>(target);
-                if (!player->getName().empty()) {
-                    strncpy(whisperTargetBuffer_, player->getName().c_str(), sizeof(whisperTargetBuffer_) - 1);
-                    whisperTargetBuffer_[sizeof(whisperTargetBuffer_) - 1] = '\0';
-                }
-            }
-        }
-    }
-    lastChatType_ = selectedChatType_;
-
-    // Show whisper target field if WHISPER is selected
-    if (selectedChatType_ == 4) {
-        ImGui::SameLine();
-        ImGui::Text("To:");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(120);
-        ImGui::InputText("##WhisperTarget", whisperTargetBuffer_, sizeof(whisperTargetBuffer_));
-    }
-
-    // Show channel picker if CHANNEL is selected
-    if (selectedChatType_ == 10) {
-        const auto& channels = gameHandler.getJoinedChannels();
-        if (channels.empty()) {
-            ImGui::SameLine();
-            ImGui::TextDisabled("(no channels joined)");
-        } else {
-            ImGui::SameLine();
-            if (selectedChannelIdx_ >= static_cast<int>(channels.size())) selectedChannelIdx_ = 0;
-            ImGui::SetNextItemWidth(140);
-            if (ImGui::BeginCombo("##ChannelPicker", channels[selectedChannelIdx_].c_str())) {
-                for (int ci = 0; ci < static_cast<int>(channels.size()); ++ci) {
-                    bool selected = (ci == selectedChannelIdx_);
-                    if (ImGui::Selectable(channels[ci].c_str(), selected)) selectedChannelIdx_ = ci;
-                    if (selected) ImGui::SetItemDefaultFocus();
-                }
-                ImGui::EndCombo();
-            }
-        }
-    }
-
-    ImGui::SameLine();
-    ImGui::Text("Message:");
-    ImGui::SameLine();
-
-    ImGui::SetNextItemWidth(-1);
-    if (refocusChatInput_) {
-        ImGui::SetKeyboardFocusHere();
-        refocusChatInput_ = false;
-    }
-
-    // Detect chat channel prefix as user types and switch the dropdown
-    {
-        std::string buf(chatInputBuffer_);
-        if (buf.size() >= 2 && buf[0] == '/') {
-            // Find the command and check if there's a space after it
-            size_t sp = buf.find(' ', 1);
-            if (sp != std::string::npos) {
-                std::string cmd = buf.substr(1, sp - 1);
-                for (char& c : cmd) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                int detected = -1;
-                bool isReply = false;
-                if (cmd == "s" || cmd == "say") detected = 0;
-                else if (cmd == "y" || cmd == "yell" || cmd == "shout") detected = 1;
-                else if (cmd == "p" || cmd == "party") detected = 2;
-                else if (cmd == "g" || cmd == "guild") detected = 3;
-                else if (cmd == "w" || cmd == "whisper" || cmd == "tell" || cmd == "t") detected = 4;
-                else if (cmd == "r" || cmd == "reply") { detected = 4; isReply = true; }
-                else if (cmd == "raid" || cmd == "rsay" || cmd == "ra") detected = 5;
-                else if (cmd == "o" || cmd == "officer" || cmd == "osay") detected = 6;
-                else if (cmd == "bg" || cmd == "battleground") detected = 7;
-                else if (cmd == "rw" || cmd == "raidwarning") detected = 8;
-                else if (cmd == "i" || cmd == "instance") detected = 9;
-                else if (cmd.size() == 1 && cmd[0] >= '1' && cmd[0] <= '9') detected = 10; // /1, /2 etc.
-                if (detected >= 0 && (selectedChatType_ != detected || detected == 10 || isReply)) {
-                    // For channel shortcuts, also update selectedChannelIdx_
-                    if (detected == 10) {
-                        int chanIdx = cmd[0] - '1'; // /1 -> index 0, /2 -> index 1, etc.
-                        const auto& chans = gameHandler.getJoinedChannels();
-                        if (chanIdx >= 0 && chanIdx < static_cast<int>(chans.size())) {
-                            selectedChannelIdx_ = chanIdx;
-                        }
-                    }
-                    selectedChatType_ = detected;
-                    // Strip the prefix, keep only the message part
-                    std::string remaining = buf.substr(sp + 1);
-                    // /r reply: pre-fill whisper target from last whisper sender
-                    if (detected == 4 && isReply) {
-                        std::string lastSender = gameHandler.getLastWhisperSender();
-                        if (!lastSender.empty()) {
-                            strncpy(whisperTargetBuffer_, lastSender.c_str(), sizeof(whisperTargetBuffer_) - 1);
-                            whisperTargetBuffer_[sizeof(whisperTargetBuffer_) - 1] = '\0';
-                        }
-                        // remaining is the message — don't extract a target from it
-                    } else if (detected == 4) {
-                        // For whisper, first word after /w is the target
-                        size_t msgStart = remaining.find(' ');
-                        if (msgStart != std::string::npos) {
-                            std::string wTarget = remaining.substr(0, msgStart);
-                            strncpy(whisperTargetBuffer_, wTarget.c_str(), sizeof(whisperTargetBuffer_) - 1);
-                            whisperTargetBuffer_[sizeof(whisperTargetBuffer_) - 1] = '\0';
-                            remaining = remaining.substr(msgStart + 1);
-                        } else {
-                            // Just the target name so far, no message yet
-                            strncpy(whisperTargetBuffer_, remaining.c_str(), sizeof(whisperTargetBuffer_) - 1);
-                            whisperTargetBuffer_[sizeof(whisperTargetBuffer_) - 1] = '\0';
-                            remaining = "";
-                        }
-                    }
-                    strncpy(chatInputBuffer_, remaining.c_str(), sizeof(chatInputBuffer_) - 1);
-                    chatInputBuffer_[sizeof(chatInputBuffer_) - 1] = '\0';
-                    chatInputMoveCursorToEnd_ = true;
-                }
-            }
-        }
-    }
-
-    // Color the input text based on current chat type
-    ImVec4 inputColor;
-    switch (selectedChatType_) {
-        case 1: inputColor = kColorRed; break;  // YELL - red
-        case 2: inputColor = colors::kLightBlue; break;  // PARTY - blue
-        case 3: inputColor = kColorBrightGreen; break;  // GUILD - green
-        case 4: inputColor = ImVec4(1.0f, 0.5f, 1.0f, 1.0f); break;  // WHISPER - pink
-        case 5: inputColor = ImVec4(1.0f, 0.5f, 0.0f, 1.0f); break;  // RAID - orange
-        case 6: inputColor = kColorBrightGreen; break;  // OFFICER - green
-        case 7: inputColor = ImVec4(1.0f, 0.5f, 0.0f, 1.0f); break;  // BG - orange
-        case 8: inputColor = ImVec4(1.0f, 0.3f, 0.0f, 1.0f); break;  // RAID WARNING - red-orange
-        case 9:  inputColor = colors::kLightBlue; break;  // INSTANCE - blue
-        case 10: inputColor = ImVec4(0.3f, 0.9f, 0.9f, 1.0f); break; // CHANNEL - cyan
-        default: inputColor = ui::colors::kWhite; break; // SAY - white
-    }
-    ImGui::PushStyleColor(ImGuiCol_Text, inputColor);
-
-    auto inputCallback = [](ImGuiInputTextCallbackData* data) -> int {
-        auto* self = static_cast<ChatPanel*>(data->UserData);
-        if (!self) return 0;
-
-        // Cursor-to-end after channel switch
-        if (self->chatInputMoveCursorToEnd_) {
-            int len = static_cast<int>(std::strlen(data->Buf));
-            data->CursorPos = len;
-            data->SelectionStart = len;
-            data->SelectionEnd = len;
-            self->chatInputMoveCursorToEnd_ = false;
-        }
-
-        // Tab: slash-command autocomplete
-        if (data->EventFlag == ImGuiInputTextFlags_CallbackCompletion) {
-            if (data->BufTextLen > 0 && data->Buf[0] == '/') {
-                // Split buffer into command word and trailing args
-                std::string fullBuf(data->Buf, data->BufTextLen);
-                size_t spacePos = fullBuf.find(' ');
-                std::string word = (spacePos != std::string::npos) ? fullBuf.substr(0, spacePos) : fullBuf;
-                std::string rest = (spacePos != std::string::npos) ? fullBuf.substr(spacePos) : "";
-
-                // Normalize to lowercase for matching
-                std::string lowerWord = word;
-                for (auto& ch : lowerWord) ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
-
-                static const std::vector<std::string> kCmds = {
-                    "/afk", "/assist", "/away",
-                    "/cancelaura", "/cancelform", "/cancellogout", "/cancelshapeshift",
-                    "/cast", "/castsequence", "/chathelp", "/clear", "/clearfocus",
-                    "/clearmainassist", "/clearmaintank", "/cleartarget", "/cloak",
-                    "/combatlog", "/dance", "/difficulty", "/dismount", "/dnd", "/do", "/duel", "/dump",
-                    "/e", "/emote", "/equip", "/equipset", "/exit",
-                    "/focus", "/follow", "/forfeit", "/friend",
-                    "/g", "/gdemote", "/ginvite", "/gkick", "/gleader", "/gmotd",
-                    "/gmticket", "/gpromote", "/gquit", "/grouploot", "/groster",
-                    "/guild", "/guildinfo",
-                    "/helm", "/help",
-                    "/i", "/ignore", "/inspect", "/instance", "/invite",
-                    "/j", "/join", "/kick", "/kneel",
-                    "/l", "/leave", "/leaveparty", "/loc", "/local", "/logout",
-                    "/lootmethod", "/lootthreshold",
-                    "/macrohelp", "/mainassist", "/maintank", "/mark", "/me",
-                    "/notready",
-                    "/p", "/party", "/petaggressive", "/petattack", "/petdefensive",
-                    "/petdismiss", "/petfollow", "/pethalt", "/petpassive", "/petstay",
-                    "/played", "/pvp",
-                    "/quit",
-                    "/r", "/raid", "/raidconvert", "/raidinfo", "/raidwarning", "/random", "/ready",
-                    "/readycheck", "/reload", "/reloadui", "/removefriend",
-                    "/reply", "/rl", "/roll", "/run",
-                    "/s", "/say", "/score", "/screenshot", "/script", "/setloot",
-                    "/shout", "/sit", "/stand",
-                    "/startattack", "/stopattack", "/stopcasting", "/stopfollow", "/stopmacro",
-                    "/t", "/target", "/targetenemy", "/targetfriend", "/targetlast",
-                    "/threat", "/ticket", "/time", "/trade",
-                    "/unignore", "/uninvite", "/unstuck", "/use",
-                    "/w", "/whisper", "/who", "/wts", "/wtb",
-                    "/y", "/yell", "/zone"
-                };
-
-                // New session if prefix changed
-                if (self->chatTabMatchIdx_ < 0 || self->chatTabPrefix_ != lowerWord) {
-                    self->chatTabPrefix_ = lowerWord;
-                    self->chatTabMatches_.clear();
-                    for (const auto& cmd : kCmds) {
-                        if (cmd.size() >= lowerWord.size() &&
-                            cmd.compare(0, lowerWord.size(), lowerWord) == 0)
-                            self->chatTabMatches_.push_back(cmd);
-                    }
-                    self->chatTabMatchIdx_ = 0;
-                } else {
-                    // Cycle forward through matches
-                    ++self->chatTabMatchIdx_;
-                    if (self->chatTabMatchIdx_ >= static_cast<int>(self->chatTabMatches_.size()))
-                        self->chatTabMatchIdx_ = 0;
-                }
-
-                if (!self->chatTabMatches_.empty()) {
-                    std::string match = self->chatTabMatches_[self->chatTabMatchIdx_];
-                    // Append trailing space when match is unambiguous
-                    if (self->chatTabMatches_.size() == 1 && rest.empty())
-                        match += ' ';
-                    std::string newBuf = match + rest;
-                    data->DeleteChars(0, data->BufTextLen);
-                    data->InsertChars(0, newBuf.c_str());
-                }
-            } else if (data->BufTextLen > 0) {
-                // Player name tab-completion for commands like /w, /whisper, /invite, /trade, /duel
-                // Also works for plain text (completes nearby player names)
-                std::string fullBuf(data->Buf, data->BufTextLen);
-                size_t spacePos = fullBuf.find(' ');
-                bool isNameCommand = false;
-                std::string namePrefix;
-                size_t replaceStart = 0;
-
-                if (fullBuf[0] == '/' && spacePos != std::string::npos) {
-                    std::string cmd = fullBuf.substr(0, spacePos);
-                    for (char& c : cmd) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                    // Commands that take a player name as the first argument after the command
-                    if (cmd == "/w" || cmd == "/whisper" || cmd == "/invite" ||
-                        cmd == "/trade" || cmd == "/duel" || cmd == "/follow" ||
-                        cmd == "/inspect" || cmd == "/friend" || cmd == "/removefriend" ||
-                        cmd == "/ignore" || cmd == "/unignore" || cmd == "/who" ||
-                        cmd == "/t" || cmd == "/target" || cmd == "/kick" ||
-                        cmd == "/uninvite" || cmd == "/ginvite" || cmd == "/gkick") {
-                        // Extract the partial name after the space
-                        namePrefix = fullBuf.substr(spacePos + 1);
-                        // Only complete the first word after the command
-                        size_t nameSpace = namePrefix.find(' ');
-                        if (nameSpace == std::string::npos) {
-                            isNameCommand = true;
-                            replaceStart = spacePos + 1;
-                        }
-                    }
-                }
-
-                if (isNameCommand && !namePrefix.empty()) {
-                    std::string lowerPrefix = namePrefix;
-                    for (char& c : lowerPrefix) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-
-                    if (self->chatTabMatchIdx_ < 0 || self->chatTabPrefix_ != lowerPrefix) {
-                        self->chatTabPrefix_ = lowerPrefix;
-                        self->chatTabMatches_.clear();
-                        // Search player name cache and nearby entities
-                        auto* gh = self->cachedGameHandler_;
-                        // Party/raid members
-                        for (const auto& m : gh->getPartyData().members) {
-                            if (m.name.empty()) continue;
-                            std::string lname = m.name;
-                            for (char& c : lname) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                            if (lname.compare(0, lowerPrefix.size(), lowerPrefix) == 0)
-                                self->chatTabMatches_.push_back(m.name);
-                        }
-                        // Friends
-                        for (const auto& c : gh->getContacts()) {
-                            if (!c.isFriend() || c.name.empty()) continue;
-                            std::string lname = c.name;
-                            for (char& cc : lname) cc = static_cast<char>(std::tolower(static_cast<unsigned char>(cc)));
-                            if (lname.compare(0, lowerPrefix.size(), lowerPrefix) == 0) {
-                                // Avoid duplicates from party
-                                bool dup = false;
-                                for (const auto& em : self->chatTabMatches_)
-                                    if (em == c.name) { dup = true; break; }
-                                if (!dup) self->chatTabMatches_.push_back(c.name);
-                            }
-                        }
-                        // Nearby visible players
-                        for (const auto& [guid, entity] : gh->getEntityManager().getEntities()) {
-                            if (!entity || entity->getType() != game::ObjectType::PLAYER) continue;
-                            auto player = std::static_pointer_cast<game::Player>(entity);
-                            if (player->getName().empty()) continue;
-                            std::string lname = player->getName();
-                            for (char& cc : lname) cc = static_cast<char>(std::tolower(static_cast<unsigned char>(cc)));
-                            if (lname.compare(0, lowerPrefix.size(), lowerPrefix) == 0) {
-                                bool dup = false;
-                                for (const auto& em : self->chatTabMatches_)
-                                    if (em == player->getName()) { dup = true; break; }
-                                if (!dup) self->chatTabMatches_.push_back(player->getName());
-                            }
-                        }
-                        // Last whisper sender
-                        if (!gh->getLastWhisperSender().empty()) {
-                            std::string lname = gh->getLastWhisperSender();
-                            for (char& cc : lname) cc = static_cast<char>(std::tolower(static_cast<unsigned char>(cc)));
-                            if (lname.compare(0, lowerPrefix.size(), lowerPrefix) == 0) {
-                                bool dup = false;
-                                for (const auto& em : self->chatTabMatches_)
-                                    if (em == gh->getLastWhisperSender()) { dup = true; break; }
-                                if (!dup) self->chatTabMatches_.insert(self->chatTabMatches_.begin(), gh->getLastWhisperSender());
-                            }
-                        }
-                        self->chatTabMatchIdx_ = 0;
-                    } else {
-                        ++self->chatTabMatchIdx_;
-                        if (self->chatTabMatchIdx_ >= static_cast<int>(self->chatTabMatches_.size()))
-                            self->chatTabMatchIdx_ = 0;
-                    }
-
-                    if (!self->chatTabMatches_.empty()) {
-                        std::string match = self->chatTabMatches_[self->chatTabMatchIdx_];
-                        std::string prefix = fullBuf.substr(0, replaceStart);
-                        std::string newBuf = prefix + match;
-                        if (self->chatTabMatches_.size() == 1) newBuf += ' ';
-                        data->DeleteChars(0, data->BufTextLen);
-                        data->InsertChars(0, newBuf.c_str());
-                    }
-                }
-            }
-            return 0;
-        }
-
-        // Up/Down arrow: cycle through sent message history
-        if (data->EventFlag == ImGuiInputTextFlags_CallbackHistory) {
-            // Any history navigation resets autocomplete
-            self->chatTabMatchIdx_ = -1;
-            self->chatTabMatches_.clear();
-
-            const int histSize = static_cast<int>(self->chatSentHistory_.size());
-            if (histSize == 0) return 0;
-
-            if (data->EventKey == ImGuiKey_UpArrow) {
-                // Go back in history
-                if (self->chatHistoryIdx_ == -1)
-                    self->chatHistoryIdx_ = histSize - 1;
-                else if (self->chatHistoryIdx_ > 0)
-                    --self->chatHistoryIdx_;
-            } else if (data->EventKey == ImGuiKey_DownArrow) {
-                if (self->chatHistoryIdx_ == -1) return 0;
-                ++self->chatHistoryIdx_;
-                if (self->chatHistoryIdx_ >= histSize) {
-                    self->chatHistoryIdx_ = -1;
-                    data->DeleteChars(0, data->BufTextLen);
-                    return 0;
-                }
-            }
-
-            if (self->chatHistoryIdx_ >= 0 && self->chatHistoryIdx_ < histSize) {
-                const std::string& entry = self->chatSentHistory_[self->chatHistoryIdx_];
-                data->DeleteChars(0, data->BufTextLen);
-                data->InsertChars(0, entry.c_str());
-            }
-        }
-        return 0;
-    };
-
-    ImGuiInputTextFlags inputFlags = ImGuiInputTextFlags_EnterReturnsTrue |
-                                     ImGuiInputTextFlags_CallbackAlways |
-                                     ImGuiInputTextFlags_CallbackHistory |
-                                     ImGuiInputTextFlags_CallbackCompletion;
-    if (ImGui::InputText("##ChatInput", chatInputBuffer_, sizeof(chatInputBuffer_), inputFlags, inputCallback, this)) {
-        sendChatMessage(gameHandler, inventoryScreen, spellbookScreen, questLogScreen);
-        // Close chat input on send so movement keys work immediately.
-        refocusChatInput_ = false;
-        ImGui::ClearActiveID();
-    }
-    ImGui::PopStyleColor();
-
-    if (ImGui::IsItemActive()) {
-        chatInputActive_ = true;
-    } else {
-        chatInputActive_ = false;
-    }
-
-    // Click in chat history area (received messages) → focus input.
-    {
-        if (chatHistoryHovered && ImGui::IsMouseClicked(0)) {
-            refocusChatInput_ = true;
-        }
-    }
-
-    ImGui::End();
-}
-
-
-// Collect all non-comment, non-empty lines from a macro body.
-static std::vector<std::string> allMacroCommands(const std::string& macroText) {
-    std::vector<std::string> cmds;
-    size_t pos = 0;
-    while (pos <= macroText.size()) {
-        size_t nl = macroText.find('\n', pos);
-        std::string line = (nl != std::string::npos) ? macroText.substr(pos, nl - pos) : macroText.substr(pos);
-        if (!line.empty() && line.back() == '\r') line.pop_back();
-        size_t start = line.find_first_not_of(" \t");
-        if (start != std::string::npos) line = line.substr(start);
-        if (!line.empty() && line.front() != '#')
-            cmds.push_back(std::move(line));
-        if (nl == std::string::npos) break;
-        pos = nl + 1;
-    }
-    return cmds;
-}
-
-// ---------------------------------------------------------------------------
-// WoW macro conditional evaluator
-// Parses:  [cond1,cond2] Spell1; [cond3] Spell2; DefaultSpell
-// Returns the first matching alternative's argument, or "" if none matches.
-// targetOverride is set to a specific GUID if [target=X] was in the conditions,
-// or left as UINT64_MAX to mean "use the normal target".
-// ---------------------------------------------------------------------------
-static std::string evaluateMacroConditionals(const std::string& rawArg,
-                                              game::GameHandler& gameHandler,
-                                              uint64_t& targetOverride) {
-    targetOverride = static_cast<uint64_t>(-1);
-
-    auto& input = core::Input::getInstance();
-
-    const bool shiftHeld = input.isKeyPressed(SDL_SCANCODE_LSHIFT) ||
-                           input.isKeyPressed(SDL_SCANCODE_RSHIFT);
-    const bool ctrlHeld  = input.isKeyPressed(SDL_SCANCODE_LCTRL)  ||
-                           input.isKeyPressed(SDL_SCANCODE_RCTRL);
-    const bool altHeld   = input.isKeyPressed(SDL_SCANCODE_LALT)   ||
-                           input.isKeyPressed(SDL_SCANCODE_RALT);
-    const bool anyMod    = shiftHeld || ctrlHeld || altHeld;
-
-    // Split rawArg on ';' → alternatives
-    std::vector<std::string> alts;
-    {
-        std::string cur;
-        for (char c : rawArg) {
-            if (c == ';') { alts.push_back(cur); cur.clear(); }
-            else            cur += c;
-        }
-        alts.push_back(cur);
-    }
-
-    // Evaluate a single comma-separated condition token.
-    // tgt is updated if a target= or @ specifier is found.
-    auto evalCond = [&](const std::string& raw, uint64_t& tgt) -> bool {
-        std::string c = raw;
-        // trim
-        size_t s = c.find_first_not_of(" \t"); if (s) c = (s != std::string::npos) ? c.substr(s) : "";
-        size_t e = c.find_last_not_of(" \t");  if (e != std::string::npos) c.resize(e + 1);
-        if (c.empty()) return true;
-
-        // @target specifiers: @player, @focus, @pet, @mouseover, @target
-        if (!c.empty() && c[0] == '@') {
-            std::string spec = c.substr(1);
-            if (spec == "player")          tgt = gameHandler.getPlayerGuid();
-            else if (spec == "focus")      tgt = gameHandler.getFocusGuid();
-            else if (spec == "target")     tgt = gameHandler.getTargetGuid();
-            else if (spec == "pet") {
-                uint64_t pg = gameHandler.getPetGuid();
-                if (pg != 0) tgt = pg;
-                else return false;  // no pet — skip this alternative
-            }
-            else if (spec == "mouseover") {
-                uint64_t mo = gameHandler.getMouseoverGuid();
-                if (mo != 0) tgt = mo;
-                else return false;  // no mouseover — skip this alternative
-            }
-            return true;
-        }
-        // target=X specifiers
-        if (c.rfind("target=", 0) == 0) {
-            std::string spec = c.substr(7);
-            if (spec == "player")          tgt = gameHandler.getPlayerGuid();
-            else if (spec == "focus")      tgt = gameHandler.getFocusGuid();
-            else if (spec == "target")     tgt = gameHandler.getTargetGuid();
-            else if (spec == "pet") {
-                uint64_t pg = gameHandler.getPetGuid();
-                if (pg != 0) tgt = pg;
-                else return false;  // no pet — skip this alternative
-            }
-            else if (spec == "mouseover") {
-                uint64_t mo = gameHandler.getMouseoverGuid();
-                if (mo != 0) tgt = mo;
-                else return false;  // no mouseover — skip this alternative
-            }
-            return true;
-        }
-
-        // mod / nomod
-        if (c == "nomod" || c == "mod:none") return !anyMod;
-        if (c.rfind("mod:", 0) == 0) {
-            std::string mods = c.substr(4);
-            bool ok = true;
-            if (mods.find("shift") != std::string::npos && !shiftHeld) ok = false;
-            if (mods.find("ctrl")  != std::string::npos && !ctrlHeld)  ok = false;
-            if (mods.find("alt")   != std::string::npos && !altHeld)   ok = false;
-            return ok;
-        }
-
-        // combat / nocombat
-        if (c == "combat")   return gameHandler.isInCombat();
-        if (c == "nocombat") return !gameHandler.isInCombat();
-
-        // Helper to get the effective target entity
-        auto effTarget = [&]() -> std::shared_ptr<game::Entity> {
-            if (tgt != static_cast<uint64_t>(-1) && tgt != 0)
-                return gameHandler.getEntityManager().getEntity(tgt);
-            return gameHandler.getTarget();
-        };
-
-        // exists / noexists
-        if (c == "exists")   return effTarget() != nullptr;
-        if (c == "noexists") return effTarget() == nullptr;
-
-        // dead / nodead
-        if (c == "dead")   {
-            auto t = effTarget();
-            auto u = t ? std::dynamic_pointer_cast<game::Unit>(t) : nullptr;
-            return u && u->getHealth() == 0;
-        }
-        if (c == "nodead") {
-            auto t = effTarget();
-            auto u = t ? std::dynamic_pointer_cast<game::Unit>(t) : nullptr;
-            return u && u->getHealth() > 0;
-        }
-
-        // help (friendly) / harm (hostile) and their no- variants
-        auto unitHostile = [&](const std::shared_ptr<game::Entity>& t) -> bool {
-            if (!t) return false;
-            auto u = std::dynamic_pointer_cast<game::Unit>(t);
-            return u && gameHandler.isHostileFactionPublic(u->getFactionTemplate());
-        };
-        if (c == "harm" || c == "nohelp") { return unitHostile(effTarget()); }
-        if (c == "help" || c == "noharm") { return !unitHostile(effTarget()); }
-
-        // mounted / nomounted
-        if (c == "mounted")   return gameHandler.isMounted();
-        if (c == "nomounted") return !gameHandler.isMounted();
-
-        // swimming / noswimming
-        if (c == "swimming")   return gameHandler.isSwimming();
-        if (c == "noswimming") return !gameHandler.isSwimming();
-
-        // flying / noflying (CAN_FLY + FLYING flags active)
-        if (c == "flying")   return gameHandler.isPlayerFlying();
-        if (c == "noflying") return !gameHandler.isPlayerFlying();
-
-        // channeling / nochanneling
-        if (c == "channeling")   return gameHandler.isCasting() && gameHandler.isChanneling();
-        if (c == "nochanneling") return !(gameHandler.isCasting() && gameHandler.isChanneling());
-
-        // stealthed / nostealthed (unit flag 0x02000000 = UNIT_FLAG_SNEAKING)
-        auto isStealthedFn = [&]() -> bool {
-            auto pe = gameHandler.getEntityManager().getEntity(gameHandler.getPlayerGuid());
-            if (!pe) return false;
-            auto pu = std::dynamic_pointer_cast<game::Unit>(pe);
-            return pu && (pu->getUnitFlags() & 0x02000000u) != 0;
-        };
-        if (c == "stealthed")   return isStealthedFn();
-        if (c == "nostealthed") return !isStealthedFn();
-
-        // pet / nopet — player has an active pet (hunters, warlocks, DKs)
-        if (c == "pet")   return gameHandler.hasPet();
-        if (c == "nopet") return !gameHandler.hasPet();
-
-        // indoors / outdoors — WMO interior detection (affects mount type selection)
-        if (c == "indoors" || c == "nooutdoors") {
-            auto* r = core::Application::getInstance().getRenderer();
-            return r && r->isPlayerIndoors();
-        }
-        if (c == "outdoors" || c == "noindoors") {
-            auto* r = core::Application::getInstance().getRenderer();
-            return !r || !r->isPlayerIndoors();
-        }
-
-        // group / nogroup — player is in a party or raid
-        if (c == "group" || c == "party") return gameHandler.isInGroup();
-        if (c == "nogroup")               return !gameHandler.isInGroup();
-
-        // raid / noraid — player is in a raid group (groupType == 1)
-        if (c == "raid") return gameHandler.isInGroup() && gameHandler.getPartyData().groupType == 1;
-        if (c == "noraid") return !gameHandler.isInGroup() || gameHandler.getPartyData().groupType != 1;
-
-        // spec:N — active talent spec (1-based: spec:1 = primary, spec:2 = secondary)
-        if (c.rfind("spec:", 0) == 0) {
-            uint8_t wantSpec = 0;
-            try { wantSpec = static_cast<uint8_t>(std::stoul(c.substr(5))); } catch (...) {}
-            return wantSpec > 0 && gameHandler.getActiveTalentSpec() == (wantSpec - 1);
-        }
-
-        // noform / nostance — player is NOT in a shapeshift/stance
-        if (c == "noform" || c == "nostance") {
-            for (const auto& a : gameHandler.getPlayerAuras())
-                if (!a.isEmpty() && a.maxDurationMs == -1) return false;
-            return true;
-        }
-        // form:0 same as noform
-        if (c == "form:0" || c == "stance:0") {
-            for (const auto& a : gameHandler.getPlayerAuras())
-                if (!a.isEmpty() && a.maxDurationMs == -1) return false;
-            return true;
-        }
-
-        // buff:SpellName / nobuff:SpellName — check if the effective target (or player
-        // if no target specified) has a buff with the given name.
-        // debuff:SpellName / nodebuff:SpellName — same for debuffs (harmful auras).
-        auto checkAuraByName = [&](const std::string& spellName, bool wantDebuff,
-                                   bool negate) -> bool {
-            // Determine which aura list to check: effective target or player
-            const std::vector<game::AuraSlot>* auras = nullptr;
-            if (tgt != static_cast<uint64_t>(-1) && tgt != 0 && tgt != gameHandler.getPlayerGuid()) {
-                // Check target's auras
-                auras = &gameHandler.getTargetAuras();
-            } else {
-                auras = &gameHandler.getPlayerAuras();
-            }
-            std::string nameLow = spellName;
-            for (char& ch : nameLow) ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
-            for (const auto& a : *auras) {
-                if (a.isEmpty() || a.spellId == 0) continue;
-                // Filter: debuffs have the HARMFUL flag (0x80) or spell has a dispel type
-                bool isDebuff = (a.flags & 0x80) != 0;
-                if (wantDebuff ? !isDebuff : isDebuff) continue;
-                std::string sn = gameHandler.getSpellName(a.spellId);
-                for (char& ch : sn) ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
-                if (sn == nameLow) return !negate;
-            }
-            return negate;
-        };
-        if (c.rfind("buff:", 0) == 0 && c.size() > 5)
-            return checkAuraByName(c.substr(5), false, false);
-        if (c.rfind("nobuff:", 0) == 0 && c.size() > 7)
-            return checkAuraByName(c.substr(7), false, true);
-        if (c.rfind("debuff:", 0) == 0 && c.size() > 7)
-            return checkAuraByName(c.substr(7), true, false);
-        if (c.rfind("nodebuff:", 0) == 0 && c.size() > 9)
-            return checkAuraByName(c.substr(9), true, true);
-
-        // mounted / nomounted
-        if (c == "mounted")   return gameHandler.isMounted();
-        if (c == "nomounted") return !gameHandler.isMounted();
-
-        // group (any group) / nogroup / raid
-        if (c == "group")  return !gameHandler.getPartyData().isEmpty();
-        if (c == "nogroup") return gameHandler.getPartyData().isEmpty();
-        if (c == "raid")   {
-            const auto& pd = gameHandler.getPartyData();
-            return pd.groupType >= 1;  // groupType 1 = raid, 0 = party
-        }
-
-        // channeling:SpellName — player is currently channeling that spell
-        if (c.rfind("channeling:", 0) == 0 && c.size() > 11) {
-            if (!gameHandler.isChanneling()) return false;
-            std::string want = c.substr(11);
-            for (char& ch : want) ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
-            uint32_t castSpellId = gameHandler.getCurrentCastSpellId();
-            std::string sn = gameHandler.getSpellName(castSpellId);
-            for (char& ch : sn) ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
-            return sn == want;
-        }
-        if (c == "channeling") return gameHandler.isChanneling();
-        if (c == "nochanneling") return !gameHandler.isChanneling();
-
-        // casting (any active cast or channel)
-        if (c == "casting")   return gameHandler.isCasting();
-        if (c == "nocasting") return !gameHandler.isCasting();
-
-        // vehicle / novehicle (WotLK)
-        if (c == "vehicle")   return gameHandler.getVehicleId() != 0;
-        if (c == "novehicle") return gameHandler.getVehicleId() == 0;
-
-        // Unknown → permissive (don't block)
-        return true;
-    };
-
-    for (auto& alt : alts) {
-        // trim
-        size_t fs = alt.find_first_not_of(" \t");
-        if (fs == std::string::npos) continue;
-        alt = alt.substr(fs);
-        size_t ls = alt.find_last_not_of(" \t");
-        if (ls != std::string::npos) alt.resize(ls + 1);
-
-        if (!alt.empty() && alt[0] == '[') {
-            size_t close = alt.find(']');
-            if (close == std::string::npos) continue;
-            std::string condStr  = alt.substr(1, close - 1);
-            std::string argPart  = alt.substr(close + 1);
-            // Trim argPart
-            size_t as = argPart.find_first_not_of(" \t");
-            argPart = (as != std::string::npos) ? argPart.substr(as) : "";
-
-            // Evaluate comma-separated conditions
-            uint64_t tgt = static_cast<uint64_t>(-1);
-            bool pass = true;
-            size_t cp = 0;
-            while (pass) {
-                size_t comma = condStr.find(',', cp);
-                std::string tok = condStr.substr(cp, comma == std::string::npos ? std::string::npos : comma - cp);
-                if (!evalCond(tok, tgt)) { pass = false; break; }
-                if (comma == std::string::npos) break;
-                cp = comma + 1;
-            }
-            if (pass) {
-                if (tgt != static_cast<uint64_t>(-1)) targetOverride = tgt;
-                return argPart;
-            }
-        } else {
-            // No condition block — default fallback always matches
-            return alt;
-        }
-    }
-    return {};
-}
-
-// Execute all non-comment lines of a macro body in sequence.
-// In WoW, every line executes per click; the server enforces spell-cast limits.
-// /stopmacro (with optional conditionals) halts the remaining commands early.
-
-void ChatPanel::executeMacroText(game::GameHandler& gameHandler,
-                                  InventoryScreen& inventoryScreen,
-                                  SpellbookScreen& spellbookScreen,
-                                  QuestLogScreen& questLogScreen,
-                                  const std::string& macroText) {
-    macroStopped_ = false;
-    for (const auto& cmd : allMacroCommands(macroText)) {
-        strncpy(chatInputBuffer_, cmd.c_str(), sizeof(chatInputBuffer_) - 1);
-        chatInputBuffer_[sizeof(chatInputBuffer_) - 1] = '\0';
-        sendChatMessage(gameHandler, inventoryScreen, spellbookScreen, questLogScreen);
-        if (macroStopped_) break;
-    }
-    macroStopped_ = false;
-}
-
-// /castsequence persistent state — shared across all macros using the same spell list.
-// Keyed by the normalized (lowercase, comma-joined) spell sequence string.
-namespace {
-struct CastSeqState {
-    size_t   index = 0;
-    float    lastPressSec = 0.0f;
-    uint64_t lastTargetGuid = 0;
-    bool     lastInCombat = false;
-};
-std::unordered_map<std::string, CastSeqState> s_castSeqStates;
-}  // namespace
-
-
-void ChatPanel::sendChatMessage(game::GameHandler& gameHandler,
-                                 InventoryScreen& /*inventoryScreen*/,
-                                 SpellbookScreen& /*spellbookScreen*/,
-                                 QuestLogScreen& /*questLogScreen*/) {
-    if (strlen(chatInputBuffer_) > 0) {
-        std::string input(chatInputBuffer_);
-
-        // Save to sent-message history (skip pure whitespace, cap at 50 entries)
-        {
-            bool allSpace = true;
-            for (char c : input) { if (!std::isspace(static_cast<unsigned char>(c))) { allSpace = false; break; } }
-            if (!allSpace) {
-                // Remove duplicate of last entry if identical
-                if (chatSentHistory_.empty() || chatSentHistory_.back() != input) {
-                    chatSentHistory_.push_back(input);
-                    if (chatSentHistory_.size() > 50)
-                        chatSentHistory_.erase(chatSentHistory_.begin());
-                }
-            }
-        }
-        chatHistoryIdx_ = -1;  // reset browsing position after send
-
-        game::ChatType type = game::ChatType::SAY;
-        std::string message = input;
-        std::string target;
-
-        // Track if a channel shortcut should change the chat type dropdown
-        int switchChatType = -1;
-
-        // Check for slash commands
-        if (input.size() > 1 && input[0] == '/') {
-            std::string command = input.substr(1);
-            size_t spacePos = command.find(' ');
-            std::string cmd = (spacePos != std::string::npos) ? command.substr(0, spacePos) : command;
-
-            // Convert command to lowercase for comparison
-            std::string cmdLower = cmd;
-            for (char& c : cmdLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-
-            // /run <lua code> — execute Lua script via addon system
-            if ((cmdLower == "run" || cmdLower == "script") && spacePos != std::string::npos) {
-                std::string luaCode = command.substr(spacePos + 1);
-                auto* am = services_.addonManager;
-                if (am) {
-                    am->runScript(luaCode);
-                } else {
-                    gameHandler.addUIError("Addon system not initialized.");
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /dump <expression> — evaluate Lua expression and print result
-            if ((cmdLower == "dump" || cmdLower == "print") && spacePos != std::string::npos) {
-                std::string expr = command.substr(spacePos + 1);
-                auto* am = services_.addonManager;
-                if (am && am->isInitialized()) {
-                    // Wrap expression in print(tostring(...)) to display the value
-                    std::string wrapped = "local __v = " + expr +
-                        "; if type(__v) == 'table' then "
-                        "  local parts = {} "
-                        "  for k,v in pairs(__v) do parts[#parts+1] = tostring(k)..'='..tostring(v) end "
-                        "  print('{' .. table.concat(parts, ', ') .. '}') "
-                        "else print(tostring(__v)) end";
-                    am->runScript(wrapped);
-                } else {
-                    game::MessageChatData errMsg;
-                    errMsg.type = game::ChatType::SYSTEM;
-                    errMsg.language = game::ChatLanguage::UNIVERSAL;
-                    errMsg.message = "Addon system not initialized.";
-                    gameHandler.addLocalChatMessage(errMsg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // Check addon slash commands (SlashCmdList) before built-in commands
-            {
-                auto* am = services_.addonManager;
-                if (am && am->isInitialized()) {
-                    std::string slashCmd = "/" + cmdLower;
-                    std::string slashArgs;
-                    if (spacePos != std::string::npos) slashArgs = command.substr(spacePos + 1);
-                    if (am->getLuaEngine()->dispatchSlashCommand(slashCmd, slashArgs)) {
-                        chatInputBuffer_[0] = '\0';
-                        return;
-                    }
-                }
-            }
-
-            // Special commands
-            if (cmdLower == "logout") {
-                core::Application::getInstance().logoutToLogin();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "clear") {
-                gameHandler.clearChatHistory();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /reload or /reloadui — reload all addons (save variables, re-init Lua, re-scan .toc files)
-            if (cmdLower == "reload" || cmdLower == "reloadui" || cmdLower == "rl") {
-                auto* am = services_.addonManager;
-                if (am) {
-                    am->reload();
-                    am->fireEvent("VARIABLES_LOADED");
-                    am->fireEvent("PLAYER_LOGIN");
-                    am->fireEvent("PLAYER_ENTERING_WORLD");
-                    game::MessageChatData rlMsg;
-                    rlMsg.type = game::ChatType::SYSTEM;
-                    rlMsg.language = game::ChatLanguage::UNIVERSAL;
-                    rlMsg.message = "Interface reloaded.";
-                    gameHandler.addLocalChatMessage(rlMsg);
-                } else {
-                    game::MessageChatData rlMsg;
-                    rlMsg.type = game::ChatType::SYSTEM;
-                    rlMsg.language = game::ChatLanguage::UNIVERSAL;
-                    rlMsg.message = "Addon system not available.";
-                    gameHandler.addLocalChatMessage(rlMsg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /stopmacro [conditions]
-            // Halts execution of the current macro (remaining lines are skipped).
-            // With a condition block, only stops if the conditions evaluate to true.
-            //   /stopmacro            → always stops
-            //   /stopmacro [combat]   → stops only while in combat
-            //   /stopmacro [nocombat] → stops only when not in combat
-            if (cmdLower == "stopmacro") {
-                bool shouldStop = true;
-                if (spacePos != std::string::npos) {
-                    std::string condArg = command.substr(spacePos + 1);
-                    while (!condArg.empty() && condArg.front() == ' ') condArg.erase(condArg.begin());
-                    if (!condArg.empty() && condArg.front() == '[') {
-                        // Append a sentinel action so evaluateMacroConditionals can signal a match.
-                        uint64_t tgtOver = static_cast<uint64_t>(-1);
-                        std::string hit = evaluateMacroConditionals(condArg + " __stop__", gameHandler, tgtOver);
-                        shouldStop = !hit.empty();
-                    }
-                }
-                if (shouldStop) macroStopped_ = true;
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /invite command
-            if (cmdLower == "invite" && spacePos != std::string::npos) {
-                std::string targetName = command.substr(spacePos + 1);
-                gameHandler.inviteToGroup(targetName);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /inspect command
-            if (cmdLower == "inspect") {
-                gameHandler.inspectTarget();
-                slashCmds_.showInspect = true;
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /threat command
-            if (cmdLower == "threat") {
-                slashCmds_.toggleThreat = true;
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /score command — BG scoreboard
-            if (cmdLower == "score") {
-                gameHandler.requestPvpLog();
-                slashCmds_.showBgScore = true;
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /time command
-            if (cmdLower == "time") {
-                gameHandler.queryServerTime();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /loc command — print player coordinates and zone name
-            if (cmdLower == "loc" || cmdLower == "coords" || cmdLower == "whereami") {
-                const auto& pmi = gameHandler.getMovementInfo();
-                std::string zoneName;
-                if (auto* rend = services_.renderer)
-                    zoneName = rend->getCurrentZoneName();
-                char buf[256];
-                snprintf(buf, sizeof(buf), "%.1f, %.1f, %.1f%s%s",
-                         pmi.x, pmi.y, pmi.z,
-                         zoneName.empty() ? "" : " — ",
-                         zoneName.c_str());
-                game::MessageChatData sysMsg;
-                sysMsg.type = game::ChatType::SYSTEM;
-                sysMsg.language = game::ChatLanguage::UNIVERSAL;
-                sysMsg.message = buf;
-                gameHandler.addLocalChatMessage(sysMsg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /screenshot command — capture current frame to PNG
-            if (cmdLower == "screenshot" || cmdLower == "ss") {
-                slashCmds_.takeScreenshot = true;
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /zone command — print current zone name
-            if (cmdLower == "zone") {
-                std::string zoneName;
-                if (auto* rend = services_.renderer)
-                    zoneName = rend->getCurrentZoneName();
-                game::MessageChatData sysMsg;
-                sysMsg.type = game::ChatType::SYSTEM;
-                sysMsg.language = game::ChatLanguage::UNIVERSAL;
-                sysMsg.message = zoneName.empty() ? "You are not in a known zone." : "You are in: " + zoneName;
-                gameHandler.addLocalChatMessage(sysMsg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /played command
-            if (cmdLower == "played") {
-                gameHandler.requestPlayedTime();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /ticket command — open GM ticket window
-            if (cmdLower == "ticket" || cmdLower == "gmticket" || cmdLower == "gm") {
-                slashCmds_.showGmTicket = true;
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /chathelp command — list chat-channel slash commands
-            if (cmdLower == "chathelp") {
-                static constexpr const char* kChatHelp[] = {
-                    "--- Chat Channel Commands ---",
-                    "/s [msg]          Say to nearby players",
-                    "/y [msg]          Yell to a wider area",
-                    "/w <name> [msg]   Whisper to player",
-                    "/r [msg]          Reply to last whisper",
-                    "/p [msg]          Party chat",
-                    "/g [msg]          Guild chat",
-                    "/o [msg]          Guild officer chat",
-                    "/raid [msg]       Raid chat",
-                    "/rw [msg]         Raid warning",
-                    "/bg [msg]         Battleground chat",
-                    "/1 [msg]          General channel",
-                    "/2 [msg]          Trade channel  (also /wts /wtb)",
-                    "/<N> [msg]        Channel by number",
-                    "/join <chan>      Join a channel",
-                    "/leave <chan>     Leave a channel",
-                    "/afk [msg]        Set AFK status",
-                    "/dnd [msg]        Set Do Not Disturb",
-                };
-                for (const char* line : kChatHelp) {
-                    game::MessageChatData helpMsg;
-                    helpMsg.type = game::ChatType::SYSTEM;
-                    helpMsg.language = game::ChatLanguage::UNIVERSAL;
-                    helpMsg.message = line;
-                    gameHandler.addLocalChatMessage(helpMsg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /macrohelp command — list available macro conditionals
-            if (cmdLower == "macrohelp") {
-                static constexpr const char* kMacroHelp[] = {
-                    "--- Macro Conditionals ---",
-                    "Usage: /cast [cond1,cond2] Spell1; [cond3] Spell2; Default",
-                    "State:   [combat] [mounted] [swimming] [flying] [stealthed]",
-                    "         [channeling] [pet] [group] [raid] [indoors] [outdoors]",
-                    "Spec:    [spec:1] [spec:2]  (active talent spec, 1-based)",
-                    "         (prefix no- to negate any condition)",
-                    "Target:  [harm] [help] [exists] [noexists] [dead] [nodead]",
-                    "         [target=focus] [target=pet] [target=mouseover] [target=player]",
-                    "         (also: @focus, @pet, @mouseover, @player, @target)",
-                    "Form:    [noform] [nostance] [form:0]",
-                    "Keys:    [mod:shift] [mod:ctrl] [mod:alt]",
-                    "Aura:    [buff:Name] [nobuff:Name] [debuff:Name] [nodebuff:Name]",
-                    "Other:   #showtooltip, /stopmacro [cond], /castsequence",
-                };
-                for (const char* line : kMacroHelp) {
-                    game::MessageChatData m;
-                    m.type = game::ChatType::SYSTEM;
-                    m.language = game::ChatLanguage::UNIVERSAL;
-                    m.message = line;
-                    gameHandler.addLocalChatMessage(m);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /help command — list available slash commands
-            if (cmdLower == "help" || cmdLower == "?") {
-                static constexpr const char* kHelpLines[] = {
-                    "--- Wowee Slash Commands ---",
-                    "Chat: /s /y /p /g /raid /rw /o /bg /w <name> /r  /join /leave",
-                    "Social: /who  /friend add/remove  /ignore  /unignore",
-                    "Party: /invite  /uninvite  /leave  /readycheck  /mark  /roll",
-                    "       /maintank  /mainassist  /raidconvert  /raidinfo",
-                    "       /lootmethod  /lootthreshold",
-                    "Guild: /ginvite  /gkick  /gquit  /gpromote  /gdemote  /gmotd",
-                    "       /gleader  /groster  /ginfo  /gcreate  /gdisband",
-                    "Combat: /cast  /castsequence  /use  /startattack  /stopattack",
-                    "        /stopcasting  /duel  /forfeit  /pvp  /assist",
-                    "        /follow  /stopfollow  /threat  /combatlog",
-                    "Items: /use <item>  /equip <item>  /equipset [name]",
-                    "Target: /target  /cleartarget  /focus  /clearfocus  /inspect",
-                    "Movement: /sit  /stand  /kneel  /dismount",
-                    "Misc: /played  /time  /zone  /loc  /afk  /dnd  /helm  /cloak",
-                    "      /trade  /score  /unstuck  /logout  /quit  /exit  /ticket",
-                    "      /screenshot  /difficulty",
-                    "      /macrohelp  /chathelp  /help",
-                };
-                for (const char* line : kHelpLines) {
-                    game::MessageChatData helpMsg;
-                    helpMsg.type = game::ChatType::SYSTEM;
-                    helpMsg.language = game::ChatLanguage::UNIVERSAL;
-                    helpMsg.message = line;
-                    gameHandler.addLocalChatMessage(helpMsg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /who commands
-            if (cmdLower == "who" || cmdLower == "whois" || cmdLower == "online" || cmdLower == "players") {
-                std::string query;
-                if (spacePos != std::string::npos) {
-                    query = command.substr(spacePos + 1);
-                    // Trim leading/trailing whitespace
-                    size_t first = query.find_first_not_of(" \t\r\n");
-                    if (first == std::string::npos) {
-                        query.clear();
-                    } else {
-                        size_t last = query.find_last_not_of(" \t\r\n");
-                        query = query.substr(first, last - first + 1);
-                    }
-                }
-
-                if ((cmdLower == "whois") && query.empty()) {
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = "Usage: /whois <playerName>";
-                    gameHandler.addLocalChatMessage(msg);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-
-                if (cmdLower == "who" && (query == "help" || query == "?")) {
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = "Who commands: /who [name/filter], /whois <name>, /online";
-                    gameHandler.addLocalChatMessage(msg);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-
-                gameHandler.queryWho(query);
-                slashCmds_.showWho = true;
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /combatlog command
-            if (cmdLower == "combatlog" || cmdLower == "cl") {
-                slashCmds_.toggleCombatLog = true;
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /roll command
-            if (cmdLower == "roll" || cmdLower == "random" || cmdLower == "rnd") {
-                uint32_t minRoll = 1;
-                uint32_t maxRoll = 100;
-
-                if (spacePos != std::string::npos) {
-                    std::string args = command.substr(spacePos + 1);
-                    size_t dashPos = args.find('-');
-                    size_t spacePos2 = args.find(' ');
-
-                    if (dashPos != std::string::npos) {
-                        // Format: /roll 1-100
-                        try {
-                            minRoll = std::stoul(args.substr(0, dashPos));
-                            maxRoll = std::stoul(args.substr(dashPos + 1));
-                        } catch (...) {}
-                    } else if (spacePos2 != std::string::npos) {
-                        // Format: /roll 1 100
-                        try {
-                            minRoll = std::stoul(args.substr(0, spacePos2));
-                            maxRoll = std::stoul(args.substr(spacePos2 + 1));
-                        } catch (...) {}
-                    } else {
-                        // Format: /roll 100 (means 1-100)
-                        try {
-                            maxRoll = std::stoul(args);
-                        } catch (...) {}
-                    }
-                }
-
-                gameHandler.randomRoll(minRoll, maxRoll);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /friend or /addfriend command
-            if (cmdLower == "friend" || cmdLower == "addfriend") {
-                if (spacePos != std::string::npos) {
-                    std::string args = command.substr(spacePos + 1);
-                    size_t subCmdSpace = args.find(' ');
-
-                    if (cmdLower == "friend" && subCmdSpace != std::string::npos) {
-                        std::string subCmd = args.substr(0, subCmdSpace);
-                        std::transform(subCmd.begin(), subCmd.end(), subCmd.begin(), ::tolower);
-
-                        if (subCmd == "add") {
-                            std::string playerName = args.substr(subCmdSpace + 1);
-                            gameHandler.addFriend(playerName);
-                            chatInputBuffer_[0] = '\0';
-                            return;
-                        } else if (subCmd == "remove" || subCmd == "delete" || subCmd == "rem") {
-                            std::string playerName = args.substr(subCmdSpace + 1);
-                            gameHandler.removeFriend(playerName);
-                            chatInputBuffer_[0] = '\0';
-                            return;
-                        }
-                    } else {
-                        // /addfriend name or /friend name (assume add)
-                        gameHandler.addFriend(args);
-                        chatInputBuffer_[0] = '\0';
-                        return;
-                    }
-                }
-
-                game::MessageChatData msg;
-                msg.type = game::ChatType::SYSTEM;
-                msg.language = game::ChatLanguage::UNIVERSAL;
-                msg.message = "Usage: /friend add <name> or /friend remove <name>";
-                gameHandler.addLocalChatMessage(msg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /removefriend or /delfriend command
-            if (cmdLower == "removefriend" || cmdLower == "delfriend" || cmdLower == "remfriend") {
-                if (spacePos != std::string::npos) {
-                    std::string playerName = command.substr(spacePos + 1);
-                    gameHandler.removeFriend(playerName);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-
-                game::MessageChatData msg;
-                msg.type = game::ChatType::SYSTEM;
-                msg.language = game::ChatLanguage::UNIVERSAL;
-                msg.message = "Usage: /removefriend <name>";
-                gameHandler.addLocalChatMessage(msg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /ignore command
-            if (cmdLower == "ignore") {
-                if (spacePos != std::string::npos) {
-                    std::string playerName = command.substr(spacePos + 1);
-                    gameHandler.addIgnore(playerName);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-
-                game::MessageChatData msg;
-                msg.type = game::ChatType::SYSTEM;
-                msg.language = game::ChatLanguage::UNIVERSAL;
-                msg.message = "Usage: /ignore <name>";
-                gameHandler.addLocalChatMessage(msg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /unignore command
-            if (cmdLower == "unignore") {
-                if (spacePos != std::string::npos) {
-                    std::string playerName = command.substr(spacePos + 1);
-                    gameHandler.removeIgnore(playerName);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-
-                game::MessageChatData msg;
-                msg.type = game::ChatType::SYSTEM;
-                msg.language = game::ChatLanguage::UNIVERSAL;
-                msg.message = "Usage: /unignore <name>";
-                gameHandler.addLocalChatMessage(msg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /dismount command
-            if (cmdLower == "dismount") {
-                gameHandler.dismount();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // Pet control commands (common macro use)
-            // Action IDs: 1=passive, 2=follow, 3=stay, 4=defensive, 5=attack, 6=aggressive
-            if (cmdLower == "petattack") {
-                uint64_t target = gameHandler.hasTarget() ? gameHandler.getTargetGuid() : 0;
-                gameHandler.sendPetAction(5, target);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-            if (cmdLower == "petfollow") {
-                gameHandler.sendPetAction(2, 0);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-            if (cmdLower == "petstay" || cmdLower == "pethalt") {
-                gameHandler.sendPetAction(3, 0);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-            if (cmdLower == "petpassive") {
-                gameHandler.sendPetAction(1, 0);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-            if (cmdLower == "petdefensive") {
-                gameHandler.sendPetAction(4, 0);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-            if (cmdLower == "petaggressive") {
-                gameHandler.sendPetAction(6, 0);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-            if (cmdLower == "petdismiss") {
-                gameHandler.dismissPet();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /cancelform / /cancelshapeshift — leave current shapeshift/stance
-            if (cmdLower == "cancelform" || cmdLower == "cancelshapeshift") {
-                // Cancel the first permanent shapeshift aura the player has
-                for (const auto& aura : gameHandler.getPlayerAuras()) {
-                    if (aura.spellId == 0) continue;
-                    // Permanent shapeshift auras have the permanent flag (0x20) set
-                    if (aura.flags & 0x20) {
-                        gameHandler.cancelAura(aura.spellId);
-                        break;
-                    }
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /cancelaura <spell name|#id> — cancel a specific buff by name or ID
-            if (cmdLower == "cancelaura" && spacePos != std::string::npos) {
-                std::string auraArg = command.substr(spacePos + 1);
-                while (!auraArg.empty() && auraArg.front() == ' ') auraArg.erase(auraArg.begin());
-                while (!auraArg.empty() && auraArg.back()  == ' ') auraArg.pop_back();
-                // Try numeric ID first
-                {
-                    std::string numStr = auraArg;
-                    if (!numStr.empty() && numStr.front() == '#') numStr.erase(numStr.begin());
-                    bool isNum = !numStr.empty() &&
-                        std::all_of(numStr.begin(), numStr.end(),
-                                    [](unsigned char c){ return std::isdigit(c); });
-                    if (isNum) {
-                        uint32_t spellId = 0;
-                        try { spellId = static_cast<uint32_t>(std::stoul(numStr)); } catch (...) {}
-                        if (spellId) gameHandler.cancelAura(spellId);
-                        chatInputBuffer_[0] = '\0';
-                        return;
-                    }
-                }
-                // Name match against player auras
-                std::string argLow = auraArg;
-                for (char& c : argLow) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                for (const auto& aura : gameHandler.getPlayerAuras()) {
-                    if (aura.spellId == 0) continue;
-                    std::string sn = gameHandler.getSpellName(aura.spellId);
-                    for (char& c : sn) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                    if (sn == argLow) {
-                        gameHandler.cancelAura(aura.spellId);
-                        break;
-                    }
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /sit command
-            if (cmdLower == "sit") {
-                gameHandler.setStandState(1);  // 1 = sit
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /stand command
-            if (cmdLower == "stand") {
-                gameHandler.setStandState(0);  // 0 = stand
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /kneel command
-            if (cmdLower == "kneel") {
-                gameHandler.setStandState(8);  // 8 = kneel
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /logout command (also /camp, /quit, /exit)
-            if (cmdLower == "logout" || cmdLower == "camp" || cmdLower == "quit" || cmdLower == "exit") {
-                gameHandler.requestLogout();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /cancellogout command
-            if (cmdLower == "cancellogout") {
-                gameHandler.cancelLogout();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /difficulty command — set dungeon/raid difficulty (WotLK)
-            if (cmdLower == "difficulty") {
-                std::string arg;
-                if (spacePos != std::string::npos) {
-                    arg = command.substr(spacePos + 1);
-                    // Trim whitespace
-                    size_t first = arg.find_first_not_of(" \t");
-                    size_t last  = arg.find_last_not_of(" \t");
-                    if (first != std::string::npos)
-                        arg = arg.substr(first, last - first + 1);
-                    else
-                        arg.clear();
-                    for (auto& ch : arg) ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
-                }
-
-                uint32_t diff = 0;
-                bool valid = true;
-                if (arg == "normal" || arg == "0")         diff = 0;
-                else if (arg == "heroic" || arg == "1")    diff = 1;
-                else if (arg == "25" || arg == "25normal" || arg == "25man" || arg == "2")
-                    diff = 2;
-                else if (arg == "25heroic" || arg == "25manheroic" || arg == "3")
-                    diff = 3;
-                else valid = false;
-
-                if (!valid || arg.empty()) {
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = "Usage: /difficulty normal|heroic|25|25heroic  (0-3)";
-                    gameHandler.addLocalChatMessage(msg);
-                } else {
-                    static constexpr const char* kDiffNames[] = {
-                        "Normal (5-man)", "Heroic (5-man)", "Normal (25-man)", "Heroic (25-man)"
-                    };
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = std::string("Setting difficulty to: ") + kDiffNames[diff];
-                    gameHandler.addLocalChatMessage(msg);
-                    gameHandler.sendSetDifficulty(diff);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /helm command
-            if (cmdLower == "helm" || cmdLower == "helmet" || cmdLower == "showhelm") {
-                gameHandler.toggleHelm();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /cloak command
-            if (cmdLower == "cloak" || cmdLower == "showcloak") {
-                gameHandler.toggleCloak();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /follow command
-            if (cmdLower == "follow" || cmdLower == "f") {
-                gameHandler.followTarget();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /stopfollow command
-            if (cmdLower == "stopfollow") {
-                gameHandler.cancelFollow();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /assist command
-            if (cmdLower == "assist") {
-                // /assist              → assist current target (use their target)
-                // /assist PlayerName   → find PlayerName, target their target
-                // /assist [target=X]   → evaluate conditional, target that entity's target
-                auto assistEntityTarget = [&](uint64_t srcGuid) {
-                    auto srcEnt = gameHandler.getEntityManager().getEntity(srcGuid);
-                    if (!srcEnt) { gameHandler.assistTarget(); return; }
-                    uint64_t atkGuid = 0;
-                    const auto& flds = srcEnt->getFields();
-                    auto iLo = flds.find(game::fieldIndex(game::UF::UNIT_FIELD_TARGET_LO));
-                    if (iLo != flds.end()) {
-                        atkGuid = iLo->second;
-                        auto iHi = flds.find(game::fieldIndex(game::UF::UNIT_FIELD_TARGET_HI));
-                        if (iHi != flds.end()) atkGuid |= (static_cast<uint64_t>(iHi->second) << 32);
-                    }
-                    if (atkGuid != 0) {
-                        gameHandler.setTarget(atkGuid);
-                    } else {
-                        std::string sn = getEntityName(srcEnt);
-                        game::MessageChatData msg;
-                        msg.type = game::ChatType::SYSTEM;
-                        msg.language = game::ChatLanguage::UNIVERSAL;
-                        msg.message = (sn.empty() ? "Target" : sn) + " has no target.";
-                        gameHandler.addLocalChatMessage(msg);
-                    }
-                };
-
-                if (spacePos != std::string::npos) {
-                    std::string assistArg = command.substr(spacePos + 1);
-                    while (!assistArg.empty() && assistArg.front() == ' ') assistArg.erase(assistArg.begin());
-
-                    // Evaluate conditionals if present
-                    uint64_t assistOver = static_cast<uint64_t>(-1);
-                    if (!assistArg.empty() && assistArg.front() == '[') {
-                        assistArg = evaluateMacroConditionals(assistArg, gameHandler, assistOver);
-                        if (assistArg.empty() && assistOver == static_cast<uint64_t>(-1)) {
-                            chatInputBuffer_[0] = '\0'; return;  // no condition matched
-                        }
-                        while (!assistArg.empty() && assistArg.front() == ' ') assistArg.erase(assistArg.begin());
-                        while (!assistArg.empty() && assistArg.back()  == ' ') assistArg.pop_back();
-                    }
-
-                    if (assistOver != static_cast<uint64_t>(-1) && assistOver != 0) {
-                        assistEntityTarget(assistOver);
-                    } else if (!assistArg.empty()) {
-                        // Name search
-                        std::string argLow = assistArg;
-                        for (char& c : argLow) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        uint64_t bestGuid = 0; float bestDist = std::numeric_limits<float>::max();
-                        const auto& pmi = gameHandler.getMovementInfo();
-                        for (const auto& [guid, ent] : gameHandler.getEntityManager().getEntities()) {
-                            if (!ent || ent->getType() == game::ObjectType::OBJECT) continue;
-                            std::string nm = getEntityName(ent);
-                            std::string nml = nm;
-                            for (char& c : nml) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                            if (nml.find(argLow) != 0) continue;
-                            float d2 = (ent->getX()-pmi.x)*(ent->getX()-pmi.x)
-                                     + (ent->getY()-pmi.y)*(ent->getY()-pmi.y);
-                            if (d2 < bestDist) { bestDist = d2; bestGuid = guid; }
-                        }
-                        if (bestGuid) assistEntityTarget(bestGuid);
-                        else {
-                            game::MessageChatData msg;
-                            msg.type = game::ChatType::SYSTEM;
-                            msg.language = game::ChatLanguage::UNIVERSAL;
-                            msg.message = "No unit matching '" + assistArg + "' found.";
-                            gameHandler.addLocalChatMessage(msg);
-                        }
-                    } else {
-                        gameHandler.assistTarget();
-                    }
-                } else {
-                    gameHandler.assistTarget();
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /pvp command
-            if (cmdLower == "pvp") {
-                gameHandler.togglePvp();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /ginfo command
-            if (cmdLower == "ginfo" || cmdLower == "guildinfo") {
-                gameHandler.requestGuildInfo();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /groster command
-            if (cmdLower == "groster" || cmdLower == "guildroster") {
-                gameHandler.requestGuildRoster();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /gmotd command
-            if (cmdLower == "gmotd" || cmdLower == "guildmotd") {
-                if (spacePos != std::string::npos) {
-                    std::string motd = command.substr(spacePos + 1);
-                    gameHandler.setGuildMotd(motd);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-
-                game::MessageChatData msg;
-                msg.type = game::ChatType::SYSTEM;
-                msg.language = game::ChatLanguage::UNIVERSAL;
-                msg.message = "Usage: /gmotd <message>";
-                gameHandler.addLocalChatMessage(msg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /gpromote command
-            if (cmdLower == "gpromote" || cmdLower == "guildpromote") {
-                if (spacePos != std::string::npos) {
-                    std::string playerName = command.substr(spacePos + 1);
-                    gameHandler.promoteGuildMember(playerName);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-
-                game::MessageChatData msg;
-                msg.type = game::ChatType::SYSTEM;
-                msg.language = game::ChatLanguage::UNIVERSAL;
-                msg.message = "Usage: /gpromote <player>";
-                gameHandler.addLocalChatMessage(msg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /gdemote command
-            if (cmdLower == "gdemote" || cmdLower == "guilddemote") {
-                if (spacePos != std::string::npos) {
-                    std::string playerName = command.substr(spacePos + 1);
-                    gameHandler.demoteGuildMember(playerName);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-
-                game::MessageChatData msg;
-                msg.type = game::ChatType::SYSTEM;
-                msg.language = game::ChatLanguage::UNIVERSAL;
-                msg.message = "Usage: /gdemote <player>";
-                gameHandler.addLocalChatMessage(msg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /gquit command
-            if (cmdLower == "gquit" || cmdLower == "guildquit" || cmdLower == "leaveguild") {
-                gameHandler.leaveGuild();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /ginvite command
-            if (cmdLower == "ginvite" || cmdLower == "guildinvite") {
-                if (spacePos != std::string::npos) {
-                    std::string playerName = command.substr(spacePos + 1);
-                    gameHandler.inviteToGuild(playerName);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-
-                game::MessageChatData msg;
-                msg.type = game::ChatType::SYSTEM;
-                msg.language = game::ChatLanguage::UNIVERSAL;
-                msg.message = "Usage: /ginvite <player>";
-                gameHandler.addLocalChatMessage(msg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /gkick command
-            if (cmdLower == "gkick" || cmdLower == "guildkick") {
-                if (spacePos != std::string::npos) {
-                    std::string playerName = command.substr(spacePos + 1);
-                    gameHandler.kickGuildMember(playerName);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-
-                game::MessageChatData msg;
-                msg.type = game::ChatType::SYSTEM;
-                msg.language = game::ChatLanguage::UNIVERSAL;
-                msg.message = "Usage: /gkick <player>";
-                gameHandler.addLocalChatMessage(msg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /gcreate command
-            if (cmdLower == "gcreate" || cmdLower == "guildcreate") {
-                if (spacePos != std::string::npos) {
-                    std::string guildName = command.substr(spacePos + 1);
-                    gameHandler.createGuild(guildName);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-
-                game::MessageChatData msg;
-                msg.type = game::ChatType::SYSTEM;
-                msg.language = game::ChatLanguage::UNIVERSAL;
-                msg.message = "Usage: /gcreate <guild name>";
-                gameHandler.addLocalChatMessage(msg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /gdisband command
-            if (cmdLower == "gdisband" || cmdLower == "guilddisband") {
-                gameHandler.disbandGuild();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /gleader command
-            if (cmdLower == "gleader" || cmdLower == "guildleader") {
-                if (spacePos != std::string::npos) {
-                    std::string playerName = command.substr(spacePos + 1);
-                    gameHandler.setGuildLeader(playerName);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-
-                game::MessageChatData msg;
-                msg.type = game::ChatType::SYSTEM;
-                msg.language = game::ChatLanguage::UNIVERSAL;
-                msg.message = "Usage: /gleader <player>";
-                gameHandler.addLocalChatMessage(msg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /readycheck command
-            if (cmdLower == "readycheck" || cmdLower == "rc") {
-                gameHandler.initiateReadyCheck();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /ready command (respond yes to ready check)
-            if (cmdLower == "ready") {
-                gameHandler.respondToReadyCheck(true);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /notready command (respond no to ready check)
-            if (cmdLower == "notready" || cmdLower == "nr") {
-                gameHandler.respondToReadyCheck(false);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /yield or /forfeit command
-            if (cmdLower == "yield" || cmdLower == "forfeit" || cmdLower == "surrender") {
-                gameHandler.forfeitDuel();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // AFK command
-            if (cmdLower == "afk" || cmdLower == "away") {
-                std::string afkMsg = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
-                gameHandler.toggleAfk(afkMsg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // DND command
-            if (cmdLower == "dnd" || cmdLower == "busy") {
-                std::string dndMsg = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
-                gameHandler.toggleDnd(dndMsg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // Reply command
-            if (cmdLower == "r" || cmdLower == "reply") {
-                std::string lastSender = gameHandler.getLastWhisperSender();
-                if (lastSender.empty()) {
-                    game::MessageChatData errMsg;
-                    errMsg.type = game::ChatType::SYSTEM;
-                    errMsg.language = game::ChatLanguage::UNIVERSAL;
-                    errMsg.message = "No one has whispered you yet.";
-                    gameHandler.addLocalChatMessage(errMsg);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-                // Set whisper target to last whisper sender
-                strncpy(whisperTargetBuffer_, lastSender.c_str(), sizeof(whisperTargetBuffer_) - 1);
-                whisperTargetBuffer_[sizeof(whisperTargetBuffer_) - 1] = '\0';
-                if (spacePos != std::string::npos) {
-                    // /r message — send reply immediately
-                    std::string replyMsg = command.substr(spacePos + 1);
-                    gameHandler.sendChatMessage(game::ChatType::WHISPER, replyMsg, lastSender);
-                }
-                // Switch to whisper tab
-                selectedChatType_ = 4;
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // Party/Raid management commands
-            if (cmdLower == "uninvite" || cmdLower == "kick") {
-                if (spacePos != std::string::npos) {
-                    std::string playerName = command.substr(spacePos + 1);
-                    gameHandler.uninvitePlayer(playerName);
-                } else {
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = "Usage: /uninvite <player name>";
-                    gameHandler.addLocalChatMessage(msg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "leave" || cmdLower == "leaveparty") {
-                gameHandler.leaveParty();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "maintank" || cmdLower == "mt") {
-                if (gameHandler.hasTarget()) {
-                    gameHandler.setMainTank(gameHandler.getTargetGuid());
-                } else {
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = "You must target a player to set as main tank.";
-                    gameHandler.addLocalChatMessage(msg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "mainassist" || cmdLower == "ma") {
-                if (gameHandler.hasTarget()) {
-                    gameHandler.setMainAssist(gameHandler.getTargetGuid());
-                } else {
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = "You must target a player to set as main assist.";
-                    gameHandler.addLocalChatMessage(msg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "clearmaintank") {
-                gameHandler.clearMainTank();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "clearmainassist") {
-                gameHandler.clearMainAssist();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "raidinfo") {
-                gameHandler.requestRaidInfo();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "raidconvert") {
-                gameHandler.convertToRaid();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /lootmethod (or /grouploot, /setloot) — set party/raid loot method
-            if (cmdLower == "lootmethod" || cmdLower == "grouploot" || cmdLower == "setloot") {
-                if (!gameHandler.isInGroup()) {
-                    gameHandler.addUIError("You are not in a group.");
-                } else if (spacePos == std::string::npos) {
-                    // No argument — show current method and usage
-                    static constexpr const char* kMethodNames[] = {
-                        "Free for All", "Round Robin", "Master Looter", "Group Loot", "Need Before Greed"
-                    };
-                    const auto& pd = gameHandler.getPartyData();
-                    const char* cur = (pd.lootMethod < 5) ? kMethodNames[pd.lootMethod] : "Unknown";
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = std::string("Current loot method: ") + cur;
-                    gameHandler.addLocalChatMessage(msg);
-                    msg.message = "Usage: /lootmethod ffa|roundrobin|master|group|needbeforegreed";
-                    gameHandler.addLocalChatMessage(msg);
-                } else {
-                    std::string arg = command.substr(spacePos + 1);
-                    // Lowercase the argument
-                    for (auto& c : arg) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                    uint32_t method = 0xFFFFFFFF;
-                    if (arg == "ffa" || arg == "freeforall")         method = 0;
-                    else if (arg == "roundrobin" || arg == "rr")     method = 1;
-                    else if (arg == "master" || arg == "masterloot") method = 2;
-                    else if (arg == "group" || arg == "grouploot")   method = 3;
-                    else if (arg == "needbeforegreed" || arg == "nbg" || arg == "need") method = 4;
-
-                    if (method == 0xFFFFFFFF) {
-                        gameHandler.addUIError("Unknown loot method. Use: ffa, roundrobin, master, group, needbeforegreed");
-                    } else {
-                        const auto& pd = gameHandler.getPartyData();
-                        // Master loot uses player guid as master looter; otherwise 0
-                        uint64_t masterGuid = (method == 2) ? gameHandler.getPlayerGuid() : 0;
-                        gameHandler.sendSetLootMethod(method, pd.lootThreshold, masterGuid);
-                    }
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /lootthreshold — set minimum item quality for group loot rolls
-            if (cmdLower == "lootthreshold") {
-                if (!gameHandler.isInGroup()) {
-                    gameHandler.addUIError("You are not in a group.");
-                } else if (spacePos == std::string::npos) {
-                    const auto& pd = gameHandler.getPartyData();
-                    static constexpr const char* kQualityNames[] = {
-                        "Poor (grey)", "Common (white)", "Uncommon (green)",
-                        "Rare (blue)", "Epic (purple)", "Legendary (orange)"
-                    };
-                    const char* cur = (pd.lootThreshold < 6) ? kQualityNames[pd.lootThreshold] : "Unknown";
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = std::string("Current loot threshold: ") + cur;
-                    gameHandler.addLocalChatMessage(msg);
-                    msg.message = "Usage: /lootthreshold <0-5> (0=Poor, 1=Common, 2=Uncommon, 3=Rare, 4=Epic, 5=Legendary)";
-                    gameHandler.addLocalChatMessage(msg);
-                } else {
-                    std::string arg = command.substr(spacePos + 1);
-                    // Trim whitespace
-                    while (!arg.empty() && arg.front() == ' ') arg.erase(arg.begin());
-                    uint32_t threshold = 0xFFFFFFFF;
-                    if (arg.size() == 1 && arg[0] >= '0' && arg[0] <= '5') {
-                        threshold = static_cast<uint32_t>(arg[0] - '0');
-                    } else {
-                        // Accept quality names
-                        for (auto& c : arg) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        if (arg == "poor" || arg == "grey" || arg == "gray") threshold = 0;
-                        else if (arg == "common" || arg == "white")          threshold = 1;
-                        else if (arg == "uncommon" || arg == "green")        threshold = 2;
-                        else if (arg == "rare" || arg == "blue")             threshold = 3;
-                        else if (arg == "epic" || arg == "purple")           threshold = 4;
-                        else if (arg == "legendary" || arg == "orange")      threshold = 5;
-                    }
-
-                    if (threshold == 0xFFFFFFFF) {
-                        gameHandler.addUIError("Invalid threshold. Use 0-5 or: poor, common, uncommon, rare, epic, legendary");
-                    } else {
-                        const auto& pd = gameHandler.getPartyData();
-                        uint64_t masterGuid = (pd.lootMethod == 2) ? gameHandler.getPlayerGuid() : 0;
-                        gameHandler.sendSetLootMethod(pd.lootMethod, threshold, masterGuid);
-                    }
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /mark [icon] — set or clear a raid target mark on the current target.
-            // Icon names (case-insensitive): star, circle, diamond, triangle, moon, square, cross, skull
-            // /mark clear | /mark 0 — remove all marks (sets icon 0xFF = clear)
-            // /mark — no arg marks with skull (icon 7)
-            if (cmdLower == "mark" || cmdLower == "marktarget" || cmdLower == "raidtarget") {
-                if (!gameHandler.hasTarget()) {
-                    game::MessageChatData noTgt;
-                    noTgt.type = game::ChatType::SYSTEM;
-                    noTgt.language = game::ChatLanguage::UNIVERSAL;
-                    noTgt.message = "No target selected.";
-                    gameHandler.addLocalChatMessage(noTgt);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-                static constexpr const char* kMarkWords[] = {
-                    "star", "circle", "diamond", "triangle", "moon", "square", "cross", "skull"
-                };
-                uint8_t icon = 7; // default: skull
-                if (spacePos != std::string::npos) {
-                    std::string arg = command.substr(spacePos + 1);
-                    while (!arg.empty() && arg.front() == ' ') arg.erase(arg.begin());
-                    std::string argLow = arg;
-                    for (auto& c : argLow) c = static_cast<char>(std::tolower(c));
-                    if (argLow == "clear" || argLow == "0" || argLow == "none") {
-                        gameHandler.setRaidMark(gameHandler.getTargetGuid(), 0xFF);
-                        chatInputBuffer_[0] = '\0';
-                        return;
-                    }
-                    bool found = false;
-                    for (int mi = 0; mi < 8; ++mi) {
-                        if (argLow == kMarkWords[mi]) { icon = static_cast<uint8_t>(mi); found = true; break; }
-                    }
-                    if (!found && !argLow.empty() && argLow[0] >= '1' && argLow[0] <= '8') {
-                        icon = static_cast<uint8_t>(argLow[0] - '1');
-                        found = true;
-                    }
-                    if (!found) {
-                        game::MessageChatData badArg;
-                        badArg.type = game::ChatType::SYSTEM;
-                        badArg.language = game::ChatLanguage::UNIVERSAL;
-                        badArg.message = "Unknown mark. Use: star circle diamond triangle moon square cross skull";
-                        gameHandler.addLocalChatMessage(badArg);
-                        chatInputBuffer_[0] = '\0';
-                        return;
-                    }
-                }
-                gameHandler.setRaidMark(gameHandler.getTargetGuid(), icon);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // Combat and Trade commands
-            if (cmdLower == "duel") {
-                if (gameHandler.hasTarget()) {
-                    gameHandler.proposeDuel(gameHandler.getTargetGuid());
-                } else if (spacePos != std::string::npos) {
-                    // Target player by name (would need name-to-GUID lookup)
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = "You must target a player to challenge to a duel.";
-                    gameHandler.addLocalChatMessage(msg);
-                } else {
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = "You must target a player to challenge to a duel.";
-                    gameHandler.addLocalChatMessage(msg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "trade") {
-                if (gameHandler.hasTarget()) {
-                    gameHandler.initiateTrade(gameHandler.getTargetGuid());
-                } else {
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = "You must target a player to trade with.";
-                    gameHandler.addLocalChatMessage(msg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "startattack") {
-                // Support macro conditionals: /startattack [harm,nodead]
-                bool condPass = true;
-                uint64_t saOverride = static_cast<uint64_t>(-1);
-                if (spacePos != std::string::npos) {
-                    std::string saArg = command.substr(spacePos + 1);
-                    while (!saArg.empty() && saArg.front() == ' ') saArg.erase(saArg.begin());
-                    if (!saArg.empty() && saArg.front() == '[') {
-                        std::string result = evaluateMacroConditionals(saArg, gameHandler, saOverride);
-                        condPass = !(result.empty() && saOverride == static_cast<uint64_t>(-1));
-                    }
-                }
-                if (condPass) {
-                    uint64_t atkTarget = (saOverride != static_cast<uint64_t>(-1) && saOverride != 0)
-                        ? saOverride : (gameHandler.hasTarget() ? gameHandler.getTargetGuid() : 0);
-                    if (atkTarget != 0) {
-                        gameHandler.startAutoAttack(atkTarget);
-                    } else {
-                        game::MessageChatData msg;
-                        msg.type = game::ChatType::SYSTEM;
-                        msg.language = game::ChatLanguage::UNIVERSAL;
-                        msg.message = "You have no target.";
-                        gameHandler.addLocalChatMessage(msg);
-                    }
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "stopattack") {
-                gameHandler.stopAutoAttack();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "stopcasting") {
-                gameHandler.stopCasting();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "cancelqueuedspell" || cmdLower == "stopspellqueue") {
-                gameHandler.cancelQueuedSpell();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /equipset [name] — equip a saved equipment set by name (partial match, case-insensitive)
-            // /equipset          — list available sets in chat
-            if (cmdLower == "equipset") {
-                const auto& sets = gameHandler.getEquipmentSets();
-                auto sysSay = [&](const std::string& msg) {
-                    game::MessageChatData m;
-                    m.type = game::ChatType::SYSTEM;
-                    m.language = game::ChatLanguage::UNIVERSAL;
-                    m.message = msg;
-                    gameHandler.addLocalChatMessage(m);
-                };
-                if (spacePos == std::string::npos) {
-                    // No argument: list available sets
-                    if (sets.empty()) {
-                        sysSay("[System] No equipment sets saved.");
-                    } else {
-                        sysSay("[System] Equipment sets:");
-                        for (const auto& es : sets)
-                            sysSay("  " + es.name);
-                    }
-                } else {
-                    std::string setName = command.substr(spacePos + 1);
-                    while (!setName.empty() && setName.front() == ' ') setName.erase(setName.begin());
-                    while (!setName.empty() && setName.back()  == ' ') setName.pop_back();
-                    // Case-insensitive prefix match
-                    std::string setLower = setName;
-                    std::transform(setLower.begin(), setLower.end(), setLower.begin(), ::tolower);
-                    const game::GameHandler::EquipmentSetInfo* found = nullptr;
-                    for (const auto& es : sets) {
-                        std::string nameLow = es.name;
-                        std::transform(nameLow.begin(), nameLow.end(), nameLow.begin(), ::tolower);
-                        if (nameLow == setLower || nameLow.find(setLower) == 0) {
-                            found = &es;
-                            break;
-                        }
-                    }
-                    if (found) {
-                        gameHandler.useEquipmentSet(found->setId);
-                    } else {
-                        sysSay("[System] No equipment set matching '" + setName + "'.");
-                    }
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /castsequence [conds] [reset=N/target/combat] Spell1, Spell2, ...
-            // Cycles through the spell list on successive presses; resets per the reset= spec.
-            if (cmdLower == "castsequence" && spacePos != std::string::npos) {
-                std::string seqArg = command.substr(spacePos + 1);
-                while (!seqArg.empty() && seqArg.front() == ' ') seqArg.erase(seqArg.begin());
-
-                // Macro conditionals
-                uint64_t seqTgtOver = static_cast<uint64_t>(-1);
-                if (!seqArg.empty() && seqArg.front() == '[') {
-                    seqArg = evaluateMacroConditionals(seqArg, gameHandler, seqTgtOver);
-                    if (seqArg.empty() && seqTgtOver == static_cast<uint64_t>(-1)) {
-                        chatInputBuffer_[0] = '\0'; return;
-                    }
-                    while (!seqArg.empty() && seqArg.front() == ' ') seqArg.erase(seqArg.begin());
-                    while (!seqArg.empty() && seqArg.back()  == ' ') seqArg.pop_back();
-                }
-
-                // Optional reset= spec (may contain slash-separated conditions: reset=5/target)
-                std::string resetSpec;
-                if (seqArg.rfind("reset=", 0) == 0) {
-                    size_t spAfter = seqArg.find(' ');
-                    if (spAfter != std::string::npos) {
-                        resetSpec = seqArg.substr(6, spAfter - 6);
-                        seqArg = seqArg.substr(spAfter + 1);
-                        while (!seqArg.empty() && seqArg.front() == ' ') seqArg.erase(seqArg.begin());
-                    }
-                }
-
-                // Parse comma-separated spell list
-                std::vector<std::string> seqSpells;
-                {
-                    std::string cur;
-                    for (char c : seqArg) {
-                        if (c == ',') {
-                            while (!cur.empty() && cur.front() == ' ') cur.erase(cur.begin());
-                            while (!cur.empty() && cur.back()  == ' ') cur.pop_back();
-                            if (!cur.empty()) seqSpells.push_back(cur);
-                            cur.clear();
-                        } else { cur += c; }
-                    }
-                    while (!cur.empty() && cur.front() == ' ') cur.erase(cur.begin());
-                    while (!cur.empty() && cur.back()  == ' ') cur.pop_back();
-                    if (!cur.empty()) seqSpells.push_back(cur);
-                }
-                if (seqSpells.empty()) { chatInputBuffer_[0] = '\0'; return; }
-
-                // Build stable key from lowercase spell list
-                std::string seqKey;
-                for (size_t k = 0; k < seqSpells.size(); ++k) {
-                    if (k) seqKey += ',';
-                    std::string sl = seqSpells[k];
-                    for (char& c : sl) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                    seqKey += sl;
-                }
-
-                auto& seqState = s_castSeqStates[seqKey];
-
-                // Check reset conditions (slash-separated: e.g. "5/target")
-                float nowSec = static_cast<float>(ImGui::GetTime());
-                bool shouldReset = false;
-                if (!resetSpec.empty()) {
-                    size_t rpos = 0;
-                    while (rpos <= resetSpec.size()) {
-                        size_t slash = resetSpec.find('/', rpos);
-                        std::string part = (slash != std::string::npos)
-                            ? resetSpec.substr(rpos, slash - rpos)
-                            : resetSpec.substr(rpos);
-                        std::string plow = part;
-                        for (char& c : plow) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        bool isNum = !plow.empty() && std::all_of(plow.begin(), plow.end(),
-                            [](unsigned char c){ return std::isdigit(c) || c == '.'; });
-                        if (isNum) {
-                            float rSec = 0.0f;
-                            try { rSec = std::stof(plow); } catch (...) {}
-                            if (rSec > 0.0f && nowSec - seqState.lastPressSec > rSec) shouldReset = true;
-                        } else if (plow == "target") {
-                            if (gameHandler.getTargetGuid() != seqState.lastTargetGuid) shouldReset = true;
-                        } else if (plow == "combat") {
-                            if (gameHandler.isInCombat() != seqState.lastInCombat) shouldReset = true;
-                        }
-                        if (slash == std::string::npos) break;
-                        rpos = slash + 1;
-                    }
-                }
-                if (shouldReset || seqState.index >= seqSpells.size()) seqState.index = 0;
-
-                const std::string& seqSpell = seqSpells[seqState.index];
-                seqState.index = (seqState.index + 1) % seqSpells.size();
-                seqState.lastPressSec  = nowSec;
-                seqState.lastTargetGuid = gameHandler.getTargetGuid();
-                seqState.lastInCombat   = gameHandler.isInCombat();
-
-                // Cast the selected spell — mirrors /cast spell lookup
-                std::string ssLow = seqSpell;
-                for (char& c : ssLow) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                if (!ssLow.empty() && ssLow.front() == '!') ssLow.erase(ssLow.begin());
-
-                uint64_t seqTargetGuid = (seqTgtOver != static_cast<uint64_t>(-1) && seqTgtOver != 0)
-                    ? seqTgtOver : (gameHandler.hasTarget() ? gameHandler.getTargetGuid() : 0);
-
-                // Numeric ID
-                if (!ssLow.empty() && ssLow.front() == '#') ssLow.erase(ssLow.begin());
-                bool ssNumeric = !ssLow.empty() && std::all_of(ssLow.begin(), ssLow.end(),
-                    [](unsigned char c){ return std::isdigit(c); });
-                if (ssNumeric) {
-                    uint32_t ssId = 0;
-                    try { ssId = static_cast<uint32_t>(std::stoul(ssLow)); } catch (...) {}
-                    if (ssId) gameHandler.castSpell(ssId, seqTargetGuid);
-                } else {
-                    uint32_t ssBest = 0; int ssBestRank = -1;
-                    for (uint32_t sid : gameHandler.getKnownSpells()) {
-                        const std::string& sn = gameHandler.getSpellName(sid);
-                        if (sn.empty()) continue;
-                        std::string snl = sn;
-                        for (char& c : snl) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        if (snl != ssLow) continue;
-                        int sRnk = 0;
-                        const std::string& rk = gameHandler.getSpellRank(sid);
-                        if (!rk.empty()) {
-                            std::string rkl = rk;
-                            for (char& c : rkl) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                            if (rkl.rfind("rank ", 0) == 0) { try { sRnk = std::stoi(rkl.substr(5)); } catch (...) {} }
-                        }
-                        if (sRnk > ssBestRank) { ssBestRank = sRnk; ssBest = sid; }
-                    }
-                    if (ssBest) gameHandler.castSpell(ssBest, seqTargetGuid);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "cast" && spacePos != std::string::npos) {
-                std::string spellArg = command.substr(spacePos + 1);
-                // Trim leading/trailing whitespace
-                while (!spellArg.empty() && spellArg.front() == ' ') spellArg.erase(spellArg.begin());
-                while (!spellArg.empty() && spellArg.back()  == ' ') spellArg.pop_back();
-
-                // Evaluate WoW macro conditionals: /cast [mod:shift] Greater Heal; Flash Heal
-                uint64_t castTargetOverride = static_cast<uint64_t>(-1);
-                if (!spellArg.empty() && spellArg.front() == '[') {
-                    spellArg = evaluateMacroConditionals(spellArg, gameHandler, castTargetOverride);
-                    if (spellArg.empty()) {
-                        chatInputBuffer_[0] = '\0';
-                        return;  // No conditional matched — skip cast
-                    }
-                    while (!spellArg.empty() && spellArg.front() == ' ') spellArg.erase(spellArg.begin());
-                    while (!spellArg.empty() && spellArg.back()  == ' ') spellArg.pop_back();
-                }
-
-                // Strip leading '!' (WoW /cast !Spell forces recast without toggling off)
-                if (!spellArg.empty() && spellArg.front() == '!') spellArg.erase(spellArg.begin());
-
-                // Support numeric spell ID: /cast 133 or /cast #133
-                {
-                    std::string numStr = spellArg;
-                    if (!numStr.empty() && numStr.front() == '#') numStr.erase(numStr.begin());
-                    bool isNumeric = !numStr.empty() &&
-                        std::all_of(numStr.begin(), numStr.end(),
-                                    [](unsigned char c){ return std::isdigit(c); });
-                    if (isNumeric) {
-                        uint32_t spellId = 0;
-                        try { spellId = static_cast<uint32_t>(std::stoul(numStr)); } catch (...) {}
-                        if (spellId != 0) {
-                            uint64_t targetGuid = (castTargetOverride != static_cast<uint64_t>(-1))
-                                ? castTargetOverride
-                                : (gameHandler.hasTarget() ? gameHandler.getTargetGuid() : 0);
-                            gameHandler.castSpell(spellId, targetGuid);
-                        }
-                        chatInputBuffer_[0] = '\0';
-                        return;
-                    }
-                }
-
-                // Parse optional "(Rank N)" suffix: "Fireball(Rank 3)" or "Fireball (Rank 3)"
-                int requestedRank = -1;  // -1 = highest rank
-                std::string spellName = spellArg;
-                {
-                    auto rankPos = spellArg.find('(');
-                    if (rankPos != std::string::npos) {
-                        std::string rankStr = spellArg.substr(rankPos + 1);
-                        // Strip closing paren and whitespace
-                        auto closePos = rankStr.find(')');
-                        if (closePos != std::string::npos) rankStr = rankStr.substr(0, closePos);
-                        for (char& c : rankStr) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        // Expect "rank N"
-                        if (rankStr.rfind("rank ", 0) == 0) {
-                            try { requestedRank = std::stoi(rankStr.substr(5)); } catch (...) {}
-                        }
-                        spellName = spellArg.substr(0, rankPos);
-                        while (!spellName.empty() && spellName.back() == ' ') spellName.pop_back();
-                    }
-                }
-
-                std::string spellNameLower = spellName;
-                for (char& c : spellNameLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-
-                // Search known spells for a name match; pick highest rank (or specific rank)
-                uint32_t bestSpellId = 0;
-                int bestRank = -1;
-                for (uint32_t sid : gameHandler.getKnownSpells()) {
-                    const std::string& sName = gameHandler.getSpellName(sid);
-                    if (sName.empty()) continue;
-                    std::string sNameLower = sName;
-                    for (char& c : sNameLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                    if (sNameLower != spellNameLower) continue;
-
-                    // Parse numeric rank from rank string ("Rank 3" → 3, "" → 0)
-                    int sRank = 0;
-                    const std::string& rankStr = gameHandler.getSpellRank(sid);
-                    if (!rankStr.empty()) {
-                        std::string rLow = rankStr;
-                        for (char& c : rLow) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        if (rLow.rfind("rank ", 0) == 0) {
-                            try { sRank = std::stoi(rLow.substr(5)); } catch (...) {}
-                        }
-                    }
-
-                    if (requestedRank >= 0) {
-                        if (sRank == requestedRank) { bestSpellId = sid; break; }
-                    } else {
-                        if (sRank > bestRank) { bestRank = sRank; bestSpellId = sid; }
-                    }
-                }
-
-                if (bestSpellId) {
-                    uint64_t targetGuid = (castTargetOverride != static_cast<uint64_t>(-1))
-                        ? castTargetOverride
-                        : (gameHandler.hasTarget() ? gameHandler.getTargetGuid() : 0);
-                    gameHandler.castSpell(bestSpellId, targetGuid);
-                } else {
-                    game::MessageChatData sysMsg;
-                    sysMsg.type = game::ChatType::SYSTEM;
-                    sysMsg.language = game::ChatLanguage::UNIVERSAL;
-                    sysMsg.message = requestedRank >= 0
-                        ? "You don't know '" + spellName + "' (Rank " + std::to_string(requestedRank) + ")."
-                        : "Unknown spell: '" + spellName + "'.";
-                    gameHandler.addLocalChatMessage(sysMsg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /use <item name|#id|bag slot|equip slot>
-            // Supports: item name, numeric item ID (#N or N), bag/slot (/use 0 1 = backpack slot 1,
-            //           /use 1-4 slot = bag slot), equipment slot number (/use 16 = main hand)
-            if (cmdLower == "use" && spacePos != std::string::npos) {
-                std::string useArg = command.substr(spacePos + 1);
-                while (!useArg.empty() && useArg.front() == ' ') useArg.erase(useArg.begin());
-                while (!useArg.empty() && useArg.back()  == ' ') useArg.pop_back();
-
-                // Handle macro conditionals: /use [mod:shift] ItemName; OtherItem
-                if (!useArg.empty() && useArg.front() == '[') {
-                    uint64_t dummy = static_cast<uint64_t>(-1);
-                    useArg = evaluateMacroConditionals(useArg, gameHandler, dummy);
-                    if (useArg.empty()) { chatInputBuffer_[0] = '\0'; return; }
-                    while (!useArg.empty() && useArg.front() == ' ') useArg.erase(useArg.begin());
-                    while (!useArg.empty() && useArg.back()  == ' ') useArg.pop_back();
-                }
-
-                // Check for bag/slot notation: two numbers separated by whitespace
-                {
-                    std::istringstream iss(useArg);
-                    int bagNum = -1, slotNum = -1;
-                    iss >> bagNum >> slotNum;
-                    if (!iss.fail() && slotNum >= 1) {
-                        if (bagNum == 0) {
-                            // Backpack: bag=0, slot 1-based → 0-based
-                            gameHandler.useItemBySlot(slotNum - 1);
-                            chatInputBuffer_[0] = '\0';
-                            return;
-                        } else if (bagNum >= 1 && bagNum <= game::Inventory::NUM_BAG_SLOTS) {
-                            // Equip bag: bags are 1-indexed (bag 1 = bagIndex 0)
-                            gameHandler.useItemInBag(bagNum - 1, slotNum - 1);
-                            chatInputBuffer_[0] = '\0';
-                            return;
-                        }
-                    }
-                }
-
-                // Numeric equip slot: /use 16 = slot 16 (1-based, WoW equip slot enum)
-                {
-                    std::string numStr = useArg;
-                    if (!numStr.empty() && numStr.front() == '#') numStr.erase(numStr.begin());
-                    bool isNumeric = !numStr.empty() &&
-                        std::all_of(numStr.begin(), numStr.end(),
-                                    [](unsigned char c){ return std::isdigit(c); });
-                    if (isNumeric) {
-                        // Treat as equip slot (1-based, maps to EquipSlot enum 0-based)
-                        int slotNum = 0;
-                        try { slotNum = std::stoi(numStr); } catch (...) {}
-                        if (slotNum >= 1 && slotNum <= static_cast<int>(game::EquipSlot::BAG4) + 1) {
-                            auto eslot = static_cast<game::EquipSlot>(slotNum - 1);
-                            const auto& esl = gameHandler.getInventory().getEquipSlot(eslot);
-                            if (!esl.empty())
-                                gameHandler.useItemById(esl.item.itemId);
-                        }
-                        chatInputBuffer_[0] = '\0';
-                        return;
-                    }
-                }
-
-                std::string useArgLower = useArg;
-                for (char& c : useArgLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-
-                bool found = false;
-                const auto& inv = gameHandler.getInventory();
-                // Search backpack
-                for (int s = 0; s < inv.getBackpackSize() && !found; ++s) {
-                    const auto& slot = inv.getBackpackSlot(s);
-                    if (slot.empty()) continue;
-                    const auto* info = gameHandler.getItemInfo(slot.item.itemId);
-                    if (!info) continue;
-                    std::string nameLow = info->name;
-                    for (char& c : nameLow) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                    if (nameLow == useArgLower) {
-                        gameHandler.useItemBySlot(s);
-                        found = true;
-                    }
-                }
-                // Search bags
-                for (int b = 0; b < game::Inventory::NUM_BAG_SLOTS && !found; ++b) {
-                    for (int s = 0; s < inv.getBagSize(b) && !found; ++s) {
-                        const auto& slot = inv.getBagSlot(b, s);
-                        if (slot.empty()) continue;
-                        const auto* info = gameHandler.getItemInfo(slot.item.itemId);
-                        if (!info) continue;
-                        std::string nameLow = info->name;
-                        for (char& c : nameLow) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        if (nameLow == useArgLower) {
-                            gameHandler.useItemInBag(b, s);
-                            found = true;
-                        }
-                    }
-                }
-                if (!found) {
-                    game::MessageChatData sysMsg;
-                    sysMsg.type = game::ChatType::SYSTEM;
-                    sysMsg.language = game::ChatLanguage::UNIVERSAL;
-                    sysMsg.message = "Item not found: '" + useArg + "'.";
-                    gameHandler.addLocalChatMessage(sysMsg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /equip <item name> — auto-equip an item from backpack/bags by name
-            if (cmdLower == "equip" && spacePos != std::string::npos) {
-                std::string equipArg = command.substr(spacePos + 1);
-                while (!equipArg.empty() && equipArg.front() == ' ') equipArg.erase(equipArg.begin());
-                while (!equipArg.empty() && equipArg.back()  == ' ') equipArg.pop_back();
-                std::string equipArgLower = equipArg;
-                for (char& c : equipArgLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-
-                bool found = false;
-                const auto& inv = gameHandler.getInventory();
-                // Search backpack
-                for (int s = 0; s < inv.getBackpackSize() && !found; ++s) {
-                    const auto& slot = inv.getBackpackSlot(s);
-                    if (slot.empty()) continue;
-                    const auto* info = gameHandler.getItemInfo(slot.item.itemId);
-                    if (!info) continue;
-                    std::string nameLow = info->name;
-                    for (char& c : nameLow) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                    if (nameLow == equipArgLower) {
-                        gameHandler.autoEquipItemBySlot(s);
-                        found = true;
-                    }
-                }
-                // Search bags
-                for (int b = 0; b < game::Inventory::NUM_BAG_SLOTS && !found; ++b) {
-                    for (int s = 0; s < inv.getBagSize(b) && !found; ++s) {
-                        const auto& slot = inv.getBagSlot(b, s);
-                        if (slot.empty()) continue;
-                        const auto* info = gameHandler.getItemInfo(slot.item.itemId);
-                        if (!info) continue;
-                        std::string nameLow = info->name;
-                        for (char& c : nameLow) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        if (nameLow == equipArgLower) {
-                            gameHandler.autoEquipItemInBag(b, s);
-                            found = true;
-                        }
-                    }
-                }
-                if (!found) {
-                    game::MessageChatData sysMsg;
-                    sysMsg.type = game::ChatType::SYSTEM;
-                    sysMsg.language = game::ChatLanguage::UNIVERSAL;
-                    sysMsg.message = "Item not found: '" + equipArg + "'.";
-                    gameHandler.addLocalChatMessage(sysMsg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // Targeting commands
-            if (cmdLower == "cleartarget") {
-                // Support macro conditionals: /cleartarget [dead] clears only if target is dead
-                bool ctCondPass = true;
-                if (spacePos != std::string::npos) {
-                    std::string ctArg = command.substr(spacePos + 1);
-                    while (!ctArg.empty() && ctArg.front() == ' ') ctArg.erase(ctArg.begin());
-                    if (!ctArg.empty() && ctArg.front() == '[') {
-                        uint64_t ctOver = static_cast<uint64_t>(-1);
-                        std::string res = evaluateMacroConditionals(ctArg, gameHandler, ctOver);
-                        ctCondPass = !(res.empty() && ctOver == static_cast<uint64_t>(-1));
-                    }
-                }
-                if (ctCondPass) gameHandler.clearTarget();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "target" && spacePos != std::string::npos) {
-                // Search visible entities for name match (case-insensitive prefix).
-                // Among all matches, pick the nearest living unit to the player.
-                // Supports WoW macro conditionals: /target [target=mouseover]; /target [mod:shift] Boss
-                std::string targetArg = command.substr(spacePos + 1);
-
-                // Evaluate conditionals if present
-                uint64_t targetCmdOverride = static_cast<uint64_t>(-1);
-                if (!targetArg.empty() && targetArg.front() == '[') {
-                    targetArg = evaluateMacroConditionals(targetArg, gameHandler, targetCmdOverride);
-                    if (targetArg.empty() && targetCmdOverride == static_cast<uint64_t>(-1)) {
-                        // No condition matched — silently skip (macro fallthrough)
-                        chatInputBuffer_[0] = '\0';
-                        return;
-                    }
-                    while (!targetArg.empty() && targetArg.front() == ' ') targetArg.erase(targetArg.begin());
-                    while (!targetArg.empty() && targetArg.back()  == ' ') targetArg.pop_back();
-                }
-
-                // If conditionals resolved to a specific GUID, target it directly
-                if (targetCmdOverride != static_cast<uint64_t>(-1) && targetCmdOverride != 0) {
-                    gameHandler.setTarget(targetCmdOverride);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-
-                // If no name remains (bare conditional like [target=mouseover] with 0 guid), skip silently
-                if (targetArg.empty()) {
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-
-                std::string targetArgLower = targetArg;
-                for (char& c : targetArgLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                uint64_t bestGuid = 0;
-                float    bestDist = std::numeric_limits<float>::max();
-                const auto& pmi = gameHandler.getMovementInfo();
-                const float playerX = pmi.x;
-                const float playerY = pmi.y;
-                const float playerZ = pmi.z;
-                for (const auto& [guid, entity] : gameHandler.getEntityManager().getEntities()) {
-                    if (!entity || entity->getType() == game::ObjectType::OBJECT) continue;
-                    std::string name;
-                    if (entity->getType() == game::ObjectType::PLAYER ||
-                        entity->getType() == game::ObjectType::UNIT) {
-                        auto unit = std::static_pointer_cast<game::Unit>(entity);
-                        name = unit->getName();
-                    }
-                    if (name.empty()) continue;
-                    std::string nameLower = name;
-                    for (char& c : nameLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                    if (nameLower.find(targetArgLower) == 0) {
-                        float dx = entity->getX() - playerX;
-                        float dy = entity->getY() - playerY;
-                        float dz = entity->getZ() - playerZ;
-                        float dist = dx*dx + dy*dy + dz*dz;
-                        if (dist < bestDist) {
-                            bestDist = dist;
-                            bestGuid = guid;
-                        }
-                    }
-                }
-                if (bestGuid) {
-                    gameHandler.setTarget(bestGuid);
-                } else {
-                    game::MessageChatData sysMsg;
-                    sysMsg.type = game::ChatType::SYSTEM;
-                    sysMsg.language = game::ChatLanguage::UNIVERSAL;
-                    sysMsg.message = "No target matching '" + targetArg + "' found.";
-                    gameHandler.addLocalChatMessage(sysMsg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "targetenemy") {
-                gameHandler.targetEnemy(false);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "targetfriend") {
-                gameHandler.targetFriend(false);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "targetlasttarget" || cmdLower == "targetlast") {
-                gameHandler.targetLastTarget();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "targetlastenemy") {
-                gameHandler.targetEnemy(true);  // Reverse direction
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "targetlastfriend") {
-                gameHandler.targetFriend(true);  // Reverse direction
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "focus") {
-                // /focus                  → set current target as focus
-                // /focus PlayerName       → search for entity by name and set as focus
-                // /focus [target=X] Name  → macro conditional: set focus to resolved target
-                if (spacePos != std::string::npos) {
-                    std::string focusArg = command.substr(spacePos + 1);
-
-                    // Evaluate conditionals if present
-                    uint64_t focusCmdOverride = static_cast<uint64_t>(-1);
-                    if (!focusArg.empty() && focusArg.front() == '[') {
-                        focusArg = evaluateMacroConditionals(focusArg, gameHandler, focusCmdOverride);
-                        if (focusArg.empty() && focusCmdOverride == static_cast<uint64_t>(-1)) {
-                            chatInputBuffer_[0] = '\0';
-                            return;
-                        }
-                        while (!focusArg.empty() && focusArg.front() == ' ') focusArg.erase(focusArg.begin());
-                        while (!focusArg.empty() && focusArg.back()  == ' ') focusArg.pop_back();
-                    }
-
-                    if (focusCmdOverride != static_cast<uint64_t>(-1) && focusCmdOverride != 0) {
-                        // Conditional resolved to a specific GUID (e.g. [target=mouseover])
-                        gameHandler.setFocus(focusCmdOverride);
-                    } else if (!focusArg.empty()) {
-                        // Name search — same logic as /target
-                        std::string focusArgLower = focusArg;
-                        for (char& c : focusArgLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        uint64_t bestGuid = 0;
-                        float    bestDist = std::numeric_limits<float>::max();
-                        const auto& pmi = gameHandler.getMovementInfo();
-                        for (const auto& [guid, entity] : gameHandler.getEntityManager().getEntities()) {
-                            if (!entity || entity->getType() == game::ObjectType::OBJECT) continue;
-                            std::string name;
-                            if (entity->getType() == game::ObjectType::PLAYER ||
-                                entity->getType() == game::ObjectType::UNIT) {
-                                auto unit = std::static_pointer_cast<game::Unit>(entity);
-                                name = unit->getName();
-                            }
-                            if (name.empty()) continue;
-                            std::string nameLower = name;
-                            for (char& c : nameLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                            if (nameLower.find(focusArgLower) == 0) {
-                                float dx = entity->getX() - pmi.x;
-                                float dy = entity->getY() - pmi.y;
-                                float dz = entity->getZ() - pmi.z;
-                                float dist = dx*dx + dy*dy + dz*dz;
-                                if (dist < bestDist) { bestDist = dist; bestGuid = guid; }
-                            }
-                        }
-                        if (bestGuid) {
-                            gameHandler.setFocus(bestGuid);
-                        } else {
-                            game::MessageChatData msg;
-                            msg.type = game::ChatType::SYSTEM;
-                            msg.language = game::ChatLanguage::UNIVERSAL;
-                            msg.message = "No unit matching '" + focusArg + "' found.";
-                            gameHandler.addLocalChatMessage(msg);
-                        }
-                    }
-                } else if (gameHandler.hasTarget()) {
-                    gameHandler.setFocus(gameHandler.getTargetGuid());
-                } else {
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = "You must target a unit to set as focus.";
-                    gameHandler.addLocalChatMessage(msg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            if (cmdLower == "clearfocus") {
-                gameHandler.clearFocus();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /unstuck command — resets player position to floor height
-            if (cmdLower == "unstuck") {
-                gameHandler.unstuck();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-            // /unstuckgy command — move to nearest graveyard
-            if (cmdLower == "unstuckgy") {
-                gameHandler.unstuckGy();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-            // /unstuckhearth command — teleport to hearthstone bind point
-            if (cmdLower == "unstuckhearth") {
-                gameHandler.unstuckHearth();
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /transport board — board test transport
-            if (cmdLower == "transport board") {
-                auto* tm = gameHandler.getTransportManager();
-                if (tm) {
-                    // Test transport GUID
-                    uint64_t testTransportGuid = 0x1000000000000001ULL;
-                    // Place player at center of deck (rough estimate)
-                    glm::vec3 deckCenter(0.0f, 0.0f, 5.0f);
-                    gameHandler.setPlayerOnTransport(testTransportGuid, deckCenter);
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = "Boarded test transport. Use '/transport leave' to disembark.";
-                    gameHandler.addLocalChatMessage(msg);
-                } else {
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = "Transport system not available.";
-                    gameHandler.addLocalChatMessage(msg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // /transport leave — disembark from transport
-            if (cmdLower == "transport leave") {
-                if (gameHandler.isOnTransport()) {
-                    gameHandler.clearPlayerTransport();
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = "Disembarked from transport.";
-                    gameHandler.addLocalChatMessage(msg);
-                } else {
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::SYSTEM;
-                    msg.language = game::ChatLanguage::UNIVERSAL;
-                    msg.message = "You are not on a transport.";
-                    gameHandler.addLocalChatMessage(msg);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            // Chat channel slash commands
-            // If used without a message (e.g. just "/s"), switch the chat type dropdown
-            bool isChannelCommand = false;
-            if (cmdLower == "s" || cmdLower == "say") {
-                type = game::ChatType::SAY;
-                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
-                isChannelCommand = true;
-                switchChatType = 0;
-            } else if (cmdLower == "y" || cmdLower == "yell" || cmdLower == "shout") {
-                type = game::ChatType::YELL;
-                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
-                isChannelCommand = true;
-                switchChatType = 1;
-            } else if (cmdLower == "p" || cmdLower == "party") {
-                type = game::ChatType::PARTY;
-                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
-                isChannelCommand = true;
-                switchChatType = 2;
-            } else if (cmdLower == "g" || cmdLower == "guild") {
-                type = game::ChatType::GUILD;
-                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
-                isChannelCommand = true;
-                switchChatType = 3;
-            } else if (cmdLower == "raid" || cmdLower == "rsay" || cmdLower == "ra") {
-                type = game::ChatType::RAID;
-                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
-                isChannelCommand = true;
-                switchChatType = 5;
-            } else if (cmdLower == "raidwarning" || cmdLower == "rw") {
-                type = game::ChatType::RAID_WARNING;
-                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
-                isChannelCommand = true;
-                switchChatType = 8;
-            } else if (cmdLower == "officer" || cmdLower == "o" || cmdLower == "osay") {
-                type = game::ChatType::OFFICER;
-                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
-                isChannelCommand = true;
-                switchChatType = 6;
-            } else if (cmdLower == "battleground" || cmdLower == "bg") {
-                type = game::ChatType::BATTLEGROUND;
-                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
-                isChannelCommand = true;
-                switchChatType = 7;
-            } else if (cmdLower == "instance" || cmdLower == "i") {
-                // Instance chat uses PARTY chat type
-                type = game::ChatType::PARTY;
-                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
-                isChannelCommand = true;
-                switchChatType = 9;
-            } else if (cmdLower == "join") {
-                // /join with no args: accept pending BG invite if any
-                if (spacePos == std::string::npos && gameHandler.hasPendingBgInvite()) {
-                    gameHandler.acceptBattlefield();
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-                // /join ChannelName [password]
-                if (spacePos != std::string::npos) {
-                    std::string rest = command.substr(spacePos + 1);
-                    size_t pwStart = rest.find(' ');
-                    std::string channelName = (pwStart != std::string::npos) ? rest.substr(0, pwStart) : rest;
-                    std::string password = (pwStart != std::string::npos) ? rest.substr(pwStart + 1) : "";
-                    gameHandler.joinChannel(channelName, password);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            } else if (cmdLower == "leave") {
-                // /leave ChannelName
-                if (spacePos != std::string::npos) {
-                    std::string channelName = command.substr(spacePos + 1);
-                    gameHandler.leaveChannel(channelName);
-                }
-                chatInputBuffer_[0] = '\0';
-                return;
-            } else if ((cmdLower == "wts" || cmdLower == "wtb") && spacePos != std::string::npos) {
-                // /wts and /wtb — send to Trade channel
-                // Prefix with [WTS] / [WTB] and route to the Trade channel
-                const std::string tag = (cmdLower == "wts") ? "[WTS] " : "[WTB] ";
-                const std::string body = command.substr(spacePos + 1);
-                // Find the Trade channel among joined channels (case-insensitive prefix match)
-                std::string tradeChan;
-                for (const auto& ch : gameHandler.getJoinedChannels()) {
-                    std::string chLow = ch;
-                    for (char& c : chLow) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                    if (chLow.rfind("trade", 0) == 0) { tradeChan = ch; break; }
-                }
-                if (tradeChan.empty()) {
-                    game::MessageChatData errMsg;
-                    errMsg.type = game::ChatType::SYSTEM;
-                    errMsg.language = game::ChatLanguage::UNIVERSAL;
-                    errMsg.message = "You are not in the Trade channel.";
-                    gameHandler.addLocalChatMessage(errMsg);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-                message = tag + body;
-                type = game::ChatType::CHANNEL;
-                target = tradeChan;
-                isChannelCommand = true;
-            } else if (cmdLower.size() == 1 && cmdLower[0] >= '1' && cmdLower[0] <= '9') {
-                // /1 msg, /2 msg — channel shortcuts
-                int channelIdx = cmdLower[0] - '0';
-                std::string channelName = gameHandler.getChannelByIndex(channelIdx);
-                if (!channelName.empty() && spacePos != std::string::npos) {
-                    message = command.substr(spacePos + 1);
-                    type = game::ChatType::CHANNEL;
-                    target = channelName;
-                    isChannelCommand = true;
-                } else if (channelName.empty()) {
-                    game::MessageChatData errMsg;
-                    errMsg.type = game::ChatType::SYSTEM;
-                    errMsg.message = "You are not in channel " + std::to_string(channelIdx) + ".";
-                    gameHandler.addLocalChatMessage(errMsg);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                } else {
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-            } else if (cmdLower == "w" || cmdLower == "whisper" || cmdLower == "tell" || cmdLower == "t") {
-                switchChatType = 4;
-                if (spacePos != std::string::npos) {
-                    std::string rest = command.substr(spacePos + 1);
-                    size_t msgStart = rest.find(' ');
-                    if (msgStart != std::string::npos) {
-                        // /w PlayerName message — send whisper immediately
-                        target = rest.substr(0, msgStart);
-                        message = rest.substr(msgStart + 1);
-                        type = game::ChatType::WHISPER;
-                        isChannelCommand = true;
-                        // Set whisper target for future messages
-                        strncpy(whisperTargetBuffer_, target.c_str(), sizeof(whisperTargetBuffer_) - 1);
-                        whisperTargetBuffer_[sizeof(whisperTargetBuffer_) - 1] = '\0';
-                    } else {
-                        // /w PlayerName — switch to whisper mode with target set
-                        strncpy(whisperTargetBuffer_, rest.c_str(), sizeof(whisperTargetBuffer_) - 1);
-                        whisperTargetBuffer_[sizeof(whisperTargetBuffer_) - 1] = '\0';
-                        message = "";
-                        isChannelCommand = true;
-                    }
-                } else {
-                    // Just "/w" — switch to whisper mode
-                    message = "";
-                    isChannelCommand = true;
-                }
-            } else if (cmdLower == "r" || cmdLower == "reply") {
-                switchChatType = 4;
-                std::string lastSender = gameHandler.getLastWhisperSender();
-                if (lastSender.empty()) {
-                    game::MessageChatData sysMsg;
-                    sysMsg.type = game::ChatType::SYSTEM;
-                    sysMsg.language = game::ChatLanguage::UNIVERSAL;
-                    sysMsg.message = "No one has whispered you yet.";
-                    gameHandler.addLocalChatMessage(sysMsg);
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-                target = lastSender;
-                strncpy(whisperTargetBuffer_, target.c_str(), sizeof(whisperTargetBuffer_) - 1);
-                whisperTargetBuffer_[sizeof(whisperTargetBuffer_) - 1] = '\0';
-                if (spacePos != std::string::npos) {
-                    message = command.substr(spacePos + 1);
-                    type = game::ChatType::WHISPER;
-                } else {
-                    message = "";
-                }
-                isChannelCommand = true;
-            }
-
-            // Check for emote commands
-            if (!isChannelCommand) {
-                std::string targetName;
-                const std::string* targetNamePtr = nullptr;
-                if (gameHandler.hasTarget()) {
-                    auto targetEntity = gameHandler.getTarget();
-                    if (targetEntity) {
-                        targetName = getEntityName(targetEntity);
-                        if (!targetName.empty()) targetNamePtr = &targetName;
-                    }
-                }
-
-                std::string emoteText = rendering::Renderer::getEmoteText(cmdLower, targetNamePtr);
-                if (!emoteText.empty()) {
-                    // Play the emote animation
-                    auto* renderer = services_.renderer;
-                    if (renderer) {
-                        renderer->playEmote(cmdLower);
-                    }
-
-                    // Send CMSG_TEXT_EMOTE to server
-                    uint32_t dbcId = rendering::Renderer::getEmoteDbcId(cmdLower);
-                    if (dbcId != 0) {
-                        uint64_t targetGuid = gameHandler.hasTarget() ? gameHandler.getTargetGuid() : 0;
-                        gameHandler.sendTextEmote(dbcId, targetGuid);
-                    }
-
-                    // Add local chat message
-                    game::MessageChatData msg;
-                    msg.type = game::ChatType::TEXT_EMOTE;
-                    msg.language = game::ChatLanguage::COMMON;
-                    msg.message = emoteText;
-                    gameHandler.addLocalChatMessage(msg);
-
-                    chatInputBuffer_[0] = '\0';
-                    return;
-                }
-
-                // Not a recognized command — fall through and send as normal chat
-                if (!isChannelCommand) {
-                    message = input;
-                }
-            }
-
-            // If no valid command found and starts with /, just send as-is
-            if (!isChannelCommand && message == input) {
-                // Use the selected chat type from dropdown
-                switch (selectedChatType_) {
-                    case 0: type = game::ChatType::SAY; break;
-                    case 1: type = game::ChatType::YELL; break;
-                    case 2: type = game::ChatType::PARTY; break;
-                    case 3: type = game::ChatType::GUILD; break;
-                    case 4: type = game::ChatType::WHISPER; target = whisperTargetBuffer_; break;
-                    case 5: type = game::ChatType::RAID; break;
-                    case 6: type = game::ChatType::OFFICER; break;
-                    case 7: type = game::ChatType::BATTLEGROUND; break;
-                    case 8: type = game::ChatType::RAID_WARNING; break;
-                    case 9: type = game::ChatType::PARTY; break; // INSTANCE uses PARTY
-                    case 10: { // CHANNEL
-                        const auto& chans = gameHandler.getJoinedChannels();
-                        if (!chans.empty() && selectedChannelIdx_ < static_cast<int>(chans.size())) {
-                            type = game::ChatType::CHANNEL;
-                            target = chans[selectedChannelIdx_];
-                        } else { type = game::ChatType::SAY; }
-                        break;
-                    }
-                    default: type = game::ChatType::SAY; break;
-                }
-            }
-        } else {
-            // No slash command, use the selected chat type from dropdown
-            switch (selectedChatType_) {
-                case 0: type = game::ChatType::SAY; break;
-                case 1: type = game::ChatType::YELL; break;
-                case 2: type = game::ChatType::PARTY; break;
-                case 3: type = game::ChatType::GUILD; break;
-                case 4: type = game::ChatType::WHISPER; target = whisperTargetBuffer_; break;
-                case 5: type = game::ChatType::RAID; break;
-                case 6: type = game::ChatType::OFFICER; break;
-                case 7: type = game::ChatType::BATTLEGROUND; break;
-                case 8: type = game::ChatType::RAID_WARNING; break;
-                case 9: type = game::ChatType::PARTY; break; // INSTANCE uses PARTY
-                case 10: { // CHANNEL
-                    const auto& chans = gameHandler.getJoinedChannels();
-                    if (!chans.empty() && selectedChannelIdx_ < static_cast<int>(chans.size())) {
-                        type = game::ChatType::CHANNEL;
-                        target = chans[selectedChannelIdx_];
-                    } else { type = game::ChatType::SAY; }
-                    break;
-                }
-                default: type = game::ChatType::SAY; break;
-            }
-        }
-
-        // Whisper shortcuts to PortBot/GMBot: translate to GM teleport commands.
-        if (type == game::ChatType::WHISPER && isPortBotTarget(target)) {
-            std::string cmd = buildPortBotCommand(message);
-            game::MessageChatData msg;
-            msg.type = game::ChatType::SYSTEM;
-            msg.language = game::ChatLanguage::UNIVERSAL;
-            if (cmd.empty() || cmd == "__help__") {
-                msg.message = "PortBot: /w PortBot <dest>. Aliases: sw if darn org tb uc shatt dal. Also supports '.tele ...' or 'xyz x y z [map [o]]'.";
-                gameHandler.addLocalChatMessage(msg);
-                chatInputBuffer_[0] = '\0';
-                return;
-            }
-
-            gameHandler.sendChatMessage(game::ChatType::SAY, cmd, "");
-            msg.message = "PortBot executed: " + cmd;
-            gameHandler.addLocalChatMessage(msg);
-            chatInputBuffer_[0] = '\0';
-            return;
-        }
-
-        // Validate whisper has a target
-        if (type == game::ChatType::WHISPER && target.empty()) {
-            game::MessageChatData msg;
-            msg.type = game::ChatType::SYSTEM;
-            msg.language = game::ChatLanguage::UNIVERSAL;
-            msg.message = "You must specify a player name for whisper.";
-            gameHandler.addLocalChatMessage(msg);
-            chatInputBuffer_[0] = '\0';
-            return;
-        }
-
-        // Don't send empty messages — but switch chat type if a channel shortcut was used
-        if (!message.empty()) {
-            gameHandler.sendChatMessage(type, message, target);
-        }
-
-        // Switch chat type dropdown when channel shortcut used (with or without message)
-        if (switchChatType >= 0) {
-            selectedChatType_ = switchChatType;
-        }
-
-        // Clear input
-        chatInputBuffer_[0] = '\0';
-    }
-}
-
-
-const char* ChatPanel::getChatTypeName(game::ChatType type) const {
-    switch (type) {
-        case game::ChatType::SAY: return "Say";
-        case game::ChatType::YELL: return "Yell";
-        case game::ChatType::EMOTE: return "Emote";
-        case game::ChatType::TEXT_EMOTE: return "Emote";
-        case game::ChatType::PARTY: return "Party";
-        case game::ChatType::GUILD: return "Guild";
-        case game::ChatType::OFFICER: return "Officer";
-        case game::ChatType::RAID: return "Raid";
-        case game::ChatType::RAID_LEADER: return "Raid Leader";
-        case game::ChatType::RAID_WARNING: return "Raid Warning";
-        case game::ChatType::BATTLEGROUND: return "Battleground";
-        case game::ChatType::BATTLEGROUND_LEADER: return "Battleground Leader";
-        case game::ChatType::WHISPER: return "Whisper";
-        case game::ChatType::WHISPER_INFORM: return "To";
-        case game::ChatType::SYSTEM: return "System";
-        case game::ChatType::MONSTER_SAY: return "Say";
-        case game::ChatType::MONSTER_YELL: return "Yell";
-        case game::ChatType::MONSTER_EMOTE: return "Emote";
-        case game::ChatType::CHANNEL: return "Channel";
-        case game::ChatType::ACHIEVEMENT: return "Achievement";
-        case game::ChatType::DND: return "DND";
-        case game::ChatType::AFK: return "AFK";
-        case game::ChatType::BG_SYSTEM_NEUTRAL:
-        case game::ChatType::BG_SYSTEM_ALLIANCE:
-        case game::ChatType::BG_SYSTEM_HORDE: return "System";
-        default: return "Unknown";
-    }
-}
-
-
-ImVec4 ChatPanel::getChatTypeColor(game::ChatType type) const {
-    switch (type) {
-        case game::ChatType::SAY:
-            return ui::colors::kWhite;  // White
-        case game::ChatType::YELL:
-            return kColorRed;  // Red
-        case game::ChatType::EMOTE:
-            return ImVec4(1.0f, 0.7f, 0.3f, 1.0f);  // Orange
-        case game::ChatType::TEXT_EMOTE:
-            return ImVec4(1.0f, 0.7f, 0.3f, 1.0f);  // Orange
-        case game::ChatType::PARTY:
-            return ImVec4(0.5f, 0.5f, 1.0f, 1.0f);  // Light blue
-        case game::ChatType::GUILD:
-            return kColorBrightGreen;  // Green
-        case game::ChatType::OFFICER:
-            return ImVec4(0.3f, 0.8f, 0.3f, 1.0f);  // Dark green
-        case game::ChatType::RAID:
-            return ImVec4(1.0f, 0.5f, 0.0f, 1.0f);  // Orange
-        case game::ChatType::RAID_LEADER:
-            return ImVec4(1.0f, 0.4f, 0.0f, 1.0f);  // Darker orange
-        case game::ChatType::RAID_WARNING:
-            return ImVec4(1.0f, 0.0f, 0.0f, 1.0f);  // Red
-        case game::ChatType::BATTLEGROUND:
-            return ImVec4(1.0f, 0.6f, 0.0f, 1.0f);  // Orange-gold
-        case game::ChatType::BATTLEGROUND_LEADER:
-            return ImVec4(1.0f, 0.5f, 0.0f, 1.0f);  // Orange
-        case game::ChatType::WHISPER:
-            return ImVec4(1.0f, 0.5f, 1.0f, 1.0f);  // Pink
-        case game::ChatType::WHISPER_INFORM:
-            return ImVec4(1.0f, 0.5f, 1.0f, 1.0f);  // Pink
-        case game::ChatType::SYSTEM:
-            return kColorYellow;  // Yellow
-        case game::ChatType::MONSTER_SAY:
-            return ui::colors::kWhite;  // White (same as SAY)
-        case game::ChatType::MONSTER_YELL:
-            return kColorRed;  // Red (same as YELL)
-        case game::ChatType::MONSTER_EMOTE:
-            return ImVec4(1.0f, 0.7f, 0.3f, 1.0f);  // Orange (same as EMOTE)
-        case game::ChatType::CHANNEL:
-            return ImVec4(1.0f, 0.7f, 0.7f, 1.0f);  // Light pink
-        case game::ChatType::ACHIEVEMENT:
-            return ImVec4(1.0f, 1.0f, 0.0f, 1.0f);  // Bright yellow
-        case game::ChatType::GUILD_ACHIEVEMENT:
-            return colors::kWarmGold; // Gold
-        case game::ChatType::SKILL:
-            return colors::kCyan;  // Cyan
-        case game::ChatType::LOOT:
-            return ImVec4(0.8f, 0.5f, 1.0f, 1.0f);  // Light purple
-        case game::ChatType::MONSTER_WHISPER:
-        case game::ChatType::RAID_BOSS_WHISPER:
-            return ImVec4(1.0f, 0.5f, 1.0f, 1.0f);  // Pink (same as WHISPER)
-        case game::ChatType::RAID_BOSS_EMOTE:
-            return ImVec4(1.0f, 0.7f, 0.3f, 1.0f);  // Orange (same as EMOTE)
-        case game::ChatType::MONSTER_PARTY:
-            return ImVec4(0.5f, 0.5f, 1.0f, 1.0f);  // Light blue (same as PARTY)
-        case game::ChatType::BG_SYSTEM_NEUTRAL:
-            return colors::kWarmGold; // Gold
-        case game::ChatType::BG_SYSTEM_ALLIANCE:
-            return ImVec4(0.3f, 0.6f, 1.0f, 1.0f);  // Blue
-        case game::ChatType::BG_SYSTEM_HORDE:
-            return kColorRed;  // Red
-        case game::ChatType::AFK:
-        case game::ChatType::DND:
-            return ImVec4(0.85f, 0.85f, 0.85f, 0.8f); // Light gray
-        default:
-            return ui::colors::kLightGray;  // Gray
-    }
-}
-
-
-std::string ChatPanel::replaceGenderPlaceholders(const std::string& text, game::GameHandler& gameHandler) {
-    // Get player gender, pronouns, and name
-    game::Gender gender = game::Gender::NONBINARY;
-    std::string playerName = "Adventurer";
-    const auto* character = gameHandler.getActiveCharacter();
-    if (character) {
-        gender = character->gender;
-        if (!character->name.empty()) {
-            playerName = character->name;
-        }
-    }
-    game::Pronouns pronouns = game::Pronouns::forGender(gender);
-
-    std::string result = text;
-
-    // Helper to trim whitespace
-    auto trim = [](std::string& s) {
-        const char* ws = " \t\n\r";
-        size_t start = s.find_first_not_of(ws);
-        if (start == std::string::npos) { s.clear(); return; }
-        size_t end = s.find_last_not_of(ws);
-        s = s.substr(start, end - start + 1);
-    };
-
-    // Replace $g/$G placeholders first.
-    size_t pos = 0;
-    while ((pos = result.find('$', pos)) != std::string::npos) {
-        if (pos + 1 >= result.length()) break;
-        char marker = result[pos + 1];
-        if (marker != 'g' && marker != 'G') { pos++; continue; }
-
-        size_t endPos = result.find(';', pos);
-        if (endPos == std::string::npos) { pos += 2; continue; }
-
-        std::string placeholder = result.substr(pos + 2, endPos - pos - 2);
-
-        // Split by colons
-        std::vector<std::string> parts;
-        size_t start = 0;
-        size_t colonPos;
-        while ((colonPos = placeholder.find(':', start)) != std::string::npos) {
-            std::string part = placeholder.substr(start, colonPos - start);
-            trim(part);
-            parts.push_back(part);
-            start = colonPos + 1;
-        }
-        // Add the last part
-        std::string lastPart = placeholder.substr(start);
-        trim(lastPart);
-        parts.push_back(lastPart);
-
-        // Select appropriate text based on gender
-        std::string replacement;
-        if (parts.size() >= 3) {
-            // Three options: male, female, nonbinary
-            switch (gender) {
-                case game::Gender::MALE:
-                    replacement = parts[0];
-                    break;
-                case game::Gender::FEMALE:
-                    replacement = parts[1];
-                    break;
-                case game::Gender::NONBINARY:
-                    replacement = parts[2];
-                    break;
-            }
-        } else if (parts.size() >= 2) {
-            // Two options: male, female (use first for nonbinary)
-            switch (gender) {
-                case game::Gender::MALE:
-                    replacement = parts[0];
-                    break;
-                case game::Gender::FEMALE:
-                    replacement = parts[1];
-                    break;
-                case game::Gender::NONBINARY:
-                    // Default to gender-neutral: use the shorter/simpler option
-                    replacement = parts[0].length() <= parts[1].length() ? parts[0] : parts[1];
-                    break;
-            }
-        } else {
-            // Malformed placeholder
-            pos = endPos + 1;
-            continue;
-        }
-
-        result.replace(pos, endPos - pos + 1, replacement);
-        pos += replacement.length();
-    }
-
-    // Resolve class and race names for $C and $R placeholders
-    std::string className = "Adventurer";
-    std::string raceName = "Unknown";
-    if (character) {
-        className = game::getClassName(character->characterClass);
-        raceName = game::getRaceName(character->race);
-    }
-
-    // Replace simple placeholders.
-    // $n/$N = player name, $c/$C = class name, $r/$R = race name
-    // $p = subject pronoun (he/she/they)
-    // $o = object pronoun (him/her/them)
-    // $s = possessive adjective (his/her/their)
-    // $S = possessive pronoun (his/hers/theirs)
-    // $b/$B = line break
-    pos = 0;
-    while ((pos = result.find('$', pos)) != std::string::npos) {
-        if (pos + 1 >= result.length()) break;
-
-        char code = result[pos + 1];
-        std::string replacement;
-        switch (code) {
-            case 'n': case 'N': replacement = playerName; break;
-            case 'c': case 'C': replacement = className; break;
-            case 'r': case 'R': replacement = raceName; break;
-            case 'p': replacement = pronouns.subject; break;
-            case 'o': replacement = pronouns.object; break;
-            case 's': replacement = pronouns.possessive; break;
-            case 'S': replacement = pronouns.possessiveP; break;
-            case 'b': case 'B': replacement = "\n"; break;
-            case 'g': case 'G': pos++; continue;
-            default: pos++; continue;
-        }
-
-        result.replace(pos, 2, replacement);
-        pos += replacement.length();
-    }
-
-    // WoW markup linebreak token.
-    pos = 0;
-    while ((pos = result.find("|n", pos)) != std::string::npos) {
-        result.replace(pos, 2, "\n");
-        pos += 1;
-    }
-    pos = 0;
-    while ((pos = result.find("|N", pos)) != std::string::npos) {
-        result.replace(pos, 2, "\n");
-        pos += 1;
-    }
-
-    return result;
-}
-
-void ChatPanel::renderBubbles(game::GameHandler& gameHandler) {
-    if (chatBubbles_.empty()) return;
-
-    auto* renderer = services_.renderer;
-    auto* camera = renderer ? renderer->getCamera() : nullptr;
-    if (!camera) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    // Get delta time from ImGui
-    float dt = ImGui::GetIO().DeltaTime;
-
-    glm::mat4 viewProj = camera->getProjectionMatrix() * camera->getViewMatrix();
-
-    // Update and render bubbles
-    for (int i = static_cast<int>(chatBubbles_.size()) - 1; i >= 0; --i) {
-        auto& bubble = chatBubbles_[i];
-        bubble.timeRemaining -= dt;
-        if (bubble.timeRemaining <= 0.0f) {
-            chatBubbles_.erase(chatBubbles_.begin() + i);
-            continue;
-        }
-
-        // Get entity position
-        auto entity = gameHandler.getEntityManager().getEntity(bubble.senderGuid);
-        if (!entity) continue;
-
-        // Convert canonical → render coordinates, offset up by 2.5 units for bubble above head
-        glm::vec3 canonical(entity->getX(), entity->getY(), entity->getZ() + 2.5f);
-        glm::vec3 renderPos = core::coords::canonicalToRender(canonical);
-
-        // Project to screen
-        glm::vec4 clipPos = viewProj * glm::vec4(renderPos, 1.0f);
-        if (clipPos.w <= 0.0f) continue;  // Behind camera
-
-        glm::vec2 ndc(clipPos.x / clipPos.w, clipPos.y / clipPos.w);
-        float screenX = (ndc.x * 0.5f + 0.5f) * screenW;
-        // Camera bakes the Vulkan Y-flip into the projection matrix:
-        // NDC y=-1 is top, y=1 is bottom — same convention as nameplate/minimap projection.
-        float screenY = (ndc.y * 0.5f + 0.5f) * screenH;
-
-        // Skip if off-screen
-        if (screenX < -200.0f || screenX > screenW + 200.0f ||
-            screenY < -100.0f || screenY > screenH + 100.0f) continue;
-
-        // Fade alpha over last 2 seconds
-        float alpha = 1.0f;
-        if (bubble.timeRemaining < 2.0f) {
-            alpha = bubble.timeRemaining / 2.0f;
-        }
-
-        // Draw bubble window
-        std::string winId = "##ChatBubble" + std::to_string(bubble.senderGuid);
-        ImGui::SetNextWindowPos(ImVec2(screenX, screenY), ImGuiCond_Always, ImVec2(0.5f, 1.0f));
-        ImGui::SetNextWindowBgAlpha(0.7f * alpha);
-        ImGuiWindowFlags flags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
-            ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar |
-            ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoInputs |
-            ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav;
-
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.0f);
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(8, 4));
-
-        ImGui::Begin(winId.c_str(), nullptr, flags);
-
-        ImVec4 textColor = bubble.isYell
-            ? ImVec4(1.0f, 0.2f, 0.2f, alpha)
-            : ImVec4(1.0f, 1.0f, 1.0f, alpha);
-
-        ImGui::PushStyleColor(ImGuiCol_Text, textColor);
-        ImGui::PushTextWrapPos(200.0f);
-        ImGui::TextWrapped("%s", bubble.message.c_str());
-        ImGui::PopTextWrapPos();
-        ImGui::PopStyleColor();
-
-        ImGui::End();
-        ImGui::PopStyleVar(2);
-    }
-}
-
-
-// ---- Public interface methods ----
-
-void ChatPanel::setupCallbacks(game::GameHandler& gameHandler) {
-    if (!chatBubbleCallbackSet_) {
-        gameHandler.setChatBubbleCallback([this](uint64_t guid, const std::string& msg, bool isYell) {
-            float duration = 8.0f + static_cast<float>(msg.size()) * 0.06f;
-            if (isYell) duration += 2.0f;
-            if (duration > 15.0f) duration = 15.0f;
-
-            // Replace existing bubble for same sender
-            for (auto& b : chatBubbles_) {
-                if (b.senderGuid == guid) {
-                    b.message = msg;
-                    b.timeRemaining = duration;
-                    b.totalDuration = duration;
-                    b.isYell = isYell;
-                    return;
-                }
-            }
-            // Evict oldest if too many
-            if (chatBubbles_.size() >= 10) {
-                chatBubbles_.erase(chatBubbles_.begin());
-            }
-            chatBubbles_.push_back({guid, msg, duration, duration, isYell});
-        });
-        chatBubbleCallbackSet_ = true;
-    }
-}
-
-void ChatPanel::insertChatLink(const std::string& link) {
-    if (link.empty()) return;
-    size_t curLen = strlen(chatInputBuffer_);
-    if (curLen + link.size() + 1 < sizeof(chatInputBuffer_)) {
-        strncat(chatInputBuffer_, link.c_str(), sizeof(chatInputBuffer_) - curLen - 1);
-        chatInputMoveCursorToEnd_ = true;
-        refocusChatInput_ = true;
-    }
-}
-
-void ChatPanel::activateSlashInput() {
-    refocusChatInput_ = true;
-    chatInputBuffer_[0] = '/';
-    chatInputBuffer_[1] = '\0';
-    chatInputMoveCursorToEnd_ = true;
-}
-
-void ChatPanel::activateInput() {
-    refocusChatInput_ = true;
-}
-
-void ChatPanel::setWhisperTarget(const std::string& name) {
-    selectedChatType_ = 4;  // WHISPER
-    strncpy(whisperTargetBuffer_, name.c_str(), sizeof(whisperTargetBuffer_) - 1);
-    whisperTargetBuffer_[sizeof(whisperTargetBuffer_) - 1] = '\0';
-    refocusChatInput_ = true;
-}
-
-ChatPanel::SlashCommands ChatPanel::consumeSlashCommands() {
-    SlashCommands result = slashCmds_;
-    slashCmds_ = {};
-    return result;
-}
-
-void ChatPanel::renderSettingsTab(std::function<void()> saveSettingsFn) {
-    ImGui::Spacing();
-
-    ImGui::Text("Appearance");
-    ImGui::Separator();
-
-    if (ImGui::Checkbox("Show Timestamps", &chatShowTimestamps)) {
-        saveSettingsFn();
-    }
-    ImGui::SetItemTooltip("Show [HH:MM] before each chat message");
-
-    const char* fontSizes[] = { "Small", "Medium", "Large" };
-    if (ImGui::Combo("Chat Font Size", &chatFontSize, fontSizes, 3)) {
-        saveSettingsFn();
-    }
-
-    ImGui::Spacing();
-    ImGui::Spacing();
-    ImGui::Text("Auto-Join Channels");
-    ImGui::Separator();
-
-    if (ImGui::Checkbox("General", &chatAutoJoinGeneral)) saveSettingsFn();
-    if (ImGui::Checkbox("Trade", &chatAutoJoinTrade)) saveSettingsFn();
-    if (ImGui::Checkbox("LocalDefense", &chatAutoJoinLocalDefense)) saveSettingsFn();
-    if (ImGui::Checkbox("LookingForGroup", &chatAutoJoinLFG)) saveSettingsFn();
-    if (ImGui::Checkbox("Local", &chatAutoJoinLocal)) saveSettingsFn();
-
-    ImGui::Spacing();
-    ImGui::Spacing();
-    ImGui::Text("Joined Channels");
-    ImGui::Separator();
-
-    ImGui::TextDisabled("Use /join and /leave commands in chat to manage channels.");
-
-    ImGui::Spacing();
-    ImGui::Separator();
-    ImGui::Spacing();
-
-    if (ImGui::Button("Restore Chat Defaults", ImVec2(-1, 0))) {
-        restoreDefaults();
-        saveSettingsFn();
-    }
-}
-
-void ChatPanel::restoreDefaults() {
-    chatShowTimestamps = false;
-    chatFontSize = 1;
-    chatAutoJoinGeneral = true;
-    chatAutoJoinTrade = true;
-    chatAutoJoinLocalDefense = true;
-    chatAutoJoinLFG = true;
-    chatAutoJoinLocal = true;
-}
-
-} // namespace ui
-} // namespace wowee
diff --git a/src/ui/combat_ui.cpp b/src/ui/combat_ui.cpp
deleted file mode 100644
index 1f371da0..00000000
--- a/src/ui/combat_ui.cpp
+++ /dev/null
@@ -1,1877 +0,0 @@
-// ============================================================
-// CombatUI — extracted from GameScreen
-// Owns all combat-related UI rendering: cast bar, cooldown tracker,
-// raid warning overlay, combat text, DPS meter, buff bar,
-// battleground score HUD, combat log, threat window, BG scoreboard.
-// ============================================================
-#include "ui/combat_ui.hpp"
-#include "ui/settings_panel.hpp"
-#include "ui/spellbook_screen.hpp"
-#include "ui/ui_colors.hpp"
-#include "ui/ui_helpers.hpp"
-#include "core/application.hpp"
-#include "core/logger.hpp"
-#include "core/coordinates.hpp"
-#include "rendering/renderer.hpp"
-#include "rendering/camera.hpp"
-#include "game/game_handler.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "audio/audio_coordinator.hpp"
-#include "audio/audio_engine.hpp"
-#include "audio/ui_sound_manager.hpp"
-#include <imgui.h>
-#include <imgui_internal.h>
-#include <algorithm>
-#include <cmath>
-#include <cstdio>
-#include <string>
-
-namespace {
-    using namespace wowee::ui::colors;
-    using namespace wowee::ui::helpers;
-    constexpr auto& kColorRed         = kRed;
-    constexpr auto& kColorGreen       = kGreen;
-    constexpr auto& kColorBrightGreen = kBrightGreen;
-    constexpr auto& kColorYellow      = kYellow;
-} // anonymous namespace
-
-namespace wowee {
-namespace ui {
-
-
-// ============================================================
-// Cast Bar
-// ============================================================
-
-void CombatUI::renderCastBar(game::GameHandler& gameHandler, SpellIconFn getSpellIcon) {
-    if (!gameHandler.isCasting()) return;
-
-    auto* assetMgr = services_.assetManager;
-
-    ImVec2 displaySize = ImGui::GetIO().DisplaySize;
-    float screenW = displaySize.x > 0.0f ? displaySize.x : 1280.0f;
-    float screenH = displaySize.y > 0.0f ? displaySize.y : 720.0f;
-
-    uint32_t currentSpellId = gameHandler.getCurrentCastSpellId();
-    VkDescriptorSet iconTex = (currentSpellId != 0 && assetMgr)
-        ? getSpellIcon(currentSpellId, assetMgr) : VK_NULL_HANDLE;
-
-    float barW = 300.0f;
-    float barX = (screenW - barW) / 2.0f;
-    float barY = screenH - 120.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(barX, barY), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(barW, 40), ImGuiCond_Always);
-
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize |
-                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
-                             ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoSavedSettings |
-                             ImGuiWindowFlags_NoFocusOnAppearing;
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.1f, 0.1f, 0.1f, 0.9f));
-
-    if (ImGui::Begin("##CastBar", nullptr, flags)) {
-        const bool channeling = gameHandler.isChanneling();
-        // Channels drain right-to-left; regular casts fill left-to-right
-        float progress = channeling
-            ? (1.0f - gameHandler.getCastProgress())
-            : gameHandler.getCastProgress();
-
-        // Color by spell school for cast identification; channels always blue
-        ImVec4 barColor;
-        if (channeling) {
-            barColor = ImVec4(0.3f, 0.6f, 0.9f, 1.0f);  // blue for channels
-        } else {
-            uint32_t school = (currentSpellId != 0) ? gameHandler.getSpellSchoolMask(currentSpellId) : 0;
-            if      (school & 0x04) barColor = ImVec4(0.95f, 0.40f, 0.10f, 1.0f);  // Fire: orange-red
-            else if (school & 0x10) barColor = ImVec4(0.30f, 0.65f, 0.95f, 1.0f);  // Frost: icy blue
-            else if (school & 0x20) barColor = ImVec4(0.55f, 0.15f, 0.70f, 1.0f);  // Shadow: purple
-            else if (school & 0x40) barColor = ImVec4(0.65f, 0.30f, 0.85f, 1.0f);  // Arcane: violet
-            else if (school & 0x08) barColor = ImVec4(0.20f, 0.75f, 0.25f, 1.0f);  // Nature: green
-            else if (school & 0x02) barColor = ImVec4(0.90f, 0.80f, 0.30f, 1.0f);  // Holy: golden
-            else                    barColor = ImVec4(0.80f, 0.60f, 0.20f, 1.0f);  // Physical/default: gold
-        }
-        ImGui::PushStyleColor(ImGuiCol_PlotHistogram, barColor);
-
-        char overlay[96];
-        if (currentSpellId == 0) {
-            snprintf(overlay, sizeof(overlay), "Opening... (%.1fs)", gameHandler.getCastTimeRemaining());
-        } else {
-            const std::string& spellName = gameHandler.getSpellName(currentSpellId);
-            const char* verb = channeling ? "Channeling" : "Casting";
-            int queueLeft = gameHandler.getCraftQueueRemaining();
-            if (!spellName.empty()) {
-                if (queueLeft > 0)
-                    snprintf(overlay, sizeof(overlay), "%s (%.1fs) [%d left]", spellName.c_str(), gameHandler.getCastTimeRemaining(), queueLeft);
-                else
-                    snprintf(overlay, sizeof(overlay), "%s (%.1fs)", spellName.c_str(), gameHandler.getCastTimeRemaining());
-            } else {
-                snprintf(overlay, sizeof(overlay), "%s... (%.1fs)", verb, gameHandler.getCastTimeRemaining());
-            }
-        }
-
-        // Queued spell icon (right edge): the next spell queued to fire within 400ms.
-        uint32_t queuedId = gameHandler.getQueuedSpellId();
-        VkDescriptorSet queuedTex = (queuedId != 0 && assetMgr)
-            ? getSpellIcon(queuedId, assetMgr) : VK_NULL_HANDLE;
-
-        const float iconSz = 20.0f;
-        const float reservedRight = (queuedTex) ? (iconSz + 4.0f) : 0.0f;
-
-        if (iconTex) {
-            // Spell icon to the left of the progress bar
-            ImGui::Image((ImTextureID)(uintptr_t)iconTex, ImVec2(iconSz, iconSz));
-            ImGui::SameLine(0, 4);
-            ImGui::ProgressBar(progress, ImVec2(-reservedRight - 1.0f, iconSz), overlay);
-        } else {
-            ImGui::ProgressBar(progress, ImVec2(-reservedRight - 1.0f, iconSz), overlay);
-        }
-        // Draw queued-spell icon on the right with a ">" arrow prefix tooltip.
-        if (queuedTex) {
-            ImGui::SameLine(0, 4);
-            ImGui::Image((ImTextureID)(uintptr_t)queuedTex, ImVec2(iconSz, iconSz),
-                         ImVec2(0,0), ImVec2(1,1),
-                         ImVec4(1,1,1,0.8f), ImVec4(0,0,0,0));  // slightly dimmed
-            if (ImGui::IsItemHovered()) {
-                const std::string& qn = gameHandler.getSpellName(queuedId);
-                ImGui::SetTooltip("Queued: %s", qn.empty() ? "Unknown" : qn.c_str());
-            }
-        }
-        ImGui::PopStyleColor();
-    }
-    ImGui::End();
-
-    ImGui::PopStyleColor();
-    ImGui::PopStyleVar();
-}
-
-
-// ============================================================
-// Cooldown Tracker — floating panel showing all active spell CDs
-// ============================================================
-
-void CombatUI::renderCooldownTracker(game::GameHandler& gameHandler,
-                                     const SettingsPanel& settings,
-                                     SpellIconFn getSpellIcon) {
-    if (!settings.showCooldownTracker_) return;
-
-    const auto& cooldowns = gameHandler.getSpellCooldowns();
-    if (cooldowns.empty()) return;
-
-    // Collect spells with remaining cooldown > 0.5s (skip GCD noise)
-    struct CDEntry { uint32_t spellId; float remaining; };
-    std::vector<CDEntry> active;
-    active.reserve(16);
-    for (const auto& [sid, rem] : cooldowns) {
-        if (rem > 0.5f) active.push_back({sid, rem});
-    }
-    if (active.empty()) return;
-
-    // Sort: longest remaining first
-    std::sort(active.begin(), active.end(), [](const CDEntry& a, const CDEntry& b) {
-        return a.remaining > b.remaining;
-    });
-
-    auto* assetMgr = services_.assetManager;
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    constexpr float TRACKER_W = 200.0f;
-    constexpr int MAX_SHOWN = 12;
-    float posX = screenW - TRACKER_W - 10.0f;
-    float posY = screenH - 220.0f;  // above the action bar area
-
-    ImGui::SetNextWindowPos(ImVec2(posX, posY), ImGuiCond_Always, ImVec2(1.0f, 1.0f));
-    ImGui::SetNextWindowSize(ImVec2(TRACKER_W, 0.0f), ImGuiCond_Always);
-    ImGui::SetNextWindowBgAlpha(0.75f);
-
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoNav |
-                             ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize |
-                             ImGuiWindowFlags_NoBringToFrontOnFocus;
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(4.0f, 4.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(4.0f, 2.0f));
-
-    if (ImGui::Begin("##CooldownTracker", nullptr, flags)) {
-        ImGui::TextDisabled("Cooldowns");
-        ImGui::Separator();
-
-        int shown = 0;
-        for (const auto& cd : active) {
-            if (shown >= MAX_SHOWN) break;
-
-            const std::string& name = gameHandler.getSpellName(cd.spellId);
-            if (name.empty()) continue;  // skip unnamed spells (internal/passive)
-
-            // Small icon if available
-            VkDescriptorSet icon = assetMgr ? getSpellIcon(cd.spellId, assetMgr) : VK_NULL_HANDLE;
-            if (icon) {
-                ImGui::Image((ImTextureID)(uintptr_t)icon, ImVec2(14, 14));
-                ImGui::SameLine(0, 3);
-            }
-
-            // Name (truncated) + remaining time
-            char timeStr[16];
-            if (cd.remaining >= 60.0f)
-                snprintf(timeStr, sizeof(timeStr), "%dm%ds", static_cast<int>(cd.remaining) / 60, static_cast<int>(cd.remaining) % 60);
-            else
-                snprintf(timeStr, sizeof(timeStr), "%.0fs", cd.remaining);
-
-            // Color: red > 30s, orange > 10s, yellow > 5s, green otherwise
-            ImVec4 cdColor = cd.remaining > 30.0f ? kColorRed :
-                             cd.remaining > 10.0f ? ImVec4(1.0f, 0.6f, 0.2f, 1.0f) :
-                             cd.remaining > 5.0f  ? kColorYellow :
-                                                    colors::kActiveGreen;
-
-            // Truncate name to fit
-            std::string displayName = name;
-            if (displayName.size() > 16) displayName = displayName.substr(0, 15) + "\xe2\x80\xa6"; // ellipsis
-
-            ImGui::TextColored(ImVec4(0.9f, 0.9f, 0.9f, 1.0f), "%s", displayName.c_str());
-            ImGui::SameLine(TRACKER_W - 48.0f);
-            ImGui::TextColored(cdColor, "%s", timeStr);
-
-            ++shown;
-        }
-    }
-    ImGui::End();
-    ImGui::PopStyleVar(3);
-}
-
-
-// ============================================================
-// Raid Warning / Boss Emote Center-Screen Overlay
-// ============================================================
-
-void CombatUI::renderRaidWarningOverlay(game::GameHandler& gameHandler) {
-    // Scan chat history for new RAID_WARNING / RAID_BOSS_EMOTE messages
-    const auto& chatHistory = gameHandler.getChatHistory();
-    size_t newCount = chatHistory.size();
-    if (newCount > raidWarnChatSeenCount_) {
-        // Walk only the new messages (deque — iterate from back by skipping old ones)
-        size_t toScan = newCount - raidWarnChatSeenCount_;
-        size_t startIdx = newCount > toScan ? newCount - toScan : 0;
-        for (size_t i = startIdx; i < newCount; ++i) {
-            const auto& msg = chatHistory[i];
-            if (msg.type == game::ChatType::RAID_WARNING ||
-                msg.type == game::ChatType::RAID_BOSS_EMOTE ||
-                msg.type == game::ChatType::MONSTER_EMOTE) {
-                bool isBoss = (msg.type != game::ChatType::RAID_WARNING);
-                // Limit display text length to avoid giant overlay
-                std::string text = msg.message;
-                if (text.size() > 200) text = text.substr(0, 200) + "...";
-                raidWarnEntries_.push_back({text, 0.0f, isBoss});
-                if (raidWarnEntries_.size() > 3)
-                    raidWarnEntries_.erase(raidWarnEntries_.begin());
-            }
-            // Whisper audio notification
-            if (msg.type == game::ChatType::WHISPER) {
-                if (auto* ac = services_.audioCoordinator) {
-                    if (auto* ui = ac->getUiSoundManager())
-                        ui->playWhisperReceived();
-                }
-            }
-        }
-        raidWarnChatSeenCount_ = newCount;
-    }
-
-    // Age and remove expired entries
-    float dt = ImGui::GetIO().DeltaTime;
-    for (auto& e : raidWarnEntries_) e.age += dt;
-    raidWarnEntries_.erase(
-        std::remove_if(raidWarnEntries_.begin(), raidWarnEntries_.end(),
-            [](const RaidWarnEntry& e){ return e.age >= RaidWarnEntry::LIFETIME; }),
-        raidWarnEntries_.end());
-
-    if (raidWarnEntries_.empty()) return;
-
-    ImGuiIO& io = ImGui::GetIO();
-    float screenW = io.DisplaySize.x;
-    float screenH = io.DisplaySize.y;
-    ImDrawList* fg = ImGui::GetForegroundDrawList();
-
-    // Stack entries vertically near upper-center (below target frame area)
-    float baseY = screenH * 0.28f;
-    for (const auto& e : raidWarnEntries_) {
-        float alpha = std::clamp(1.0f - (e.age / RaidWarnEntry::LIFETIME), 0.0f, 1.0f);
-        // Fade in quickly, hold, then fade out last 20%
-        if (e.age < 0.3f) alpha = e.age / 0.3f;
-
-        // Truncate to fit screen width reasonably
-        const char* txt = e.text.c_str();
-        const float fontSize = 22.0f;
-        ImFont* font = ImGui::GetFont();
-
-        // Word-wrap manually: compute text size, center horizontally
-        float maxW = screenW * 0.7f;
-        ImVec2 textSz = font->CalcTextSizeA(fontSize, maxW, maxW, txt);
-        float tx = (screenW - textSz.x) * 0.5f;
-
-        ImU32 shadowCol = IM_COL32(0, 0, 0, static_cast<int>(alpha * 200));
-        ImU32 mainCol;
-        if (e.isBossEmote) {
-            mainCol = IM_COL32(255, 185, 60, static_cast<int>(alpha * 255));   // amber
-        } else {
-            // Raid warning: alternating red/yellow flash during first second
-            float flashT = std::fmod(e.age * 4.0f, 1.0f);
-            if (flashT < 0.5f)
-                mainCol = IM_COL32(255, 50, 50, static_cast<int>(alpha * 255));
-            else
-                mainCol = IM_COL32(255, 220, 50, static_cast<int>(alpha * 255));
-        }
-
-        // Background dim box for readability
-        float pad = 8.0f;
-        fg->AddRectFilled(ImVec2(tx - pad, baseY - pad),
-                           ImVec2(tx + textSz.x + pad, baseY + textSz.y + pad),
-                           IM_COL32(0, 0, 0, static_cast<int>(alpha * 120)), 4.0f);
-
-        // Shadow + main text
-        fg->AddText(font, fontSize, ImVec2(tx + 2.0f, baseY + 2.0f), shadowCol, txt,
-                    nullptr, maxW);
-        fg->AddText(font, fontSize, ImVec2(tx,         baseY),         mainCol,  txt,
-                    nullptr, maxW);
-
-        baseY += textSz.y + 6.0f;
-    }
-}
-
-
-// ============================================================
-// Floating Combat Text
-// ============================================================
-
-void CombatUI::renderCombatText(game::GameHandler& gameHandler) {
-    const auto& entries = gameHandler.getCombatText();
-    if (entries.empty()) return;
-
-    auto* window = services_.window;
-    if (!window) return;
-    const float screenW = static_cast<float>(window->getWidth());
-    const float screenH = static_cast<float>(window->getHeight());
-
-    // Camera for world-space projection
-    auto* appRenderer = services_.renderer;
-    rendering::Camera* camera = appRenderer ? appRenderer->getCamera() : nullptr;
-    glm::mat4 viewProj;
-    if (camera) viewProj = camera->getProjectionMatrix() * camera->getViewMatrix();
-
-    ImDrawList* drawList = ImGui::GetForegroundDrawList();
-    ImFont* font = ImGui::GetFont();
-    const float baseFontSize = ImGui::GetFontSize();
-
-    // HUD fallback: entries without world-space anchor use classic screen-position layout.
-    // We still need an ImGui window for those.
-    const float hudIncomingX = screenW * 0.40f;
-    const float hudOutgoingX = screenW * 0.68f;
-    int hudInIdx = 0, hudOutIdx = 0;
-    bool needsHudWindow = false;
-
-    for (const auto& entry : entries) {
-        const float alpha = 1.0f - (entry.age / game::CombatTextEntry::LIFETIME);
-        const bool outgoing = entry.isPlayerSource;
-
-        // --- Format text and color (identical logic for both world and HUD paths) ---
-        ImVec4 color;
-        char text[128];
-        switch (entry.type) {
-            case game::CombatTextEntry::MELEE_DAMAGE:
-            case game::CombatTextEntry::SPELL_DAMAGE:
-                snprintf(text, sizeof(text), "-%d", entry.amount);
-                color = outgoing ?
-                    ImVec4(1.0f, 1.0f, 0.3f, alpha) :
-                    ImVec4(1.0f, 0.3f, 0.3f, alpha);
-                break;
-            case game::CombatTextEntry::CRIT_DAMAGE:
-                snprintf(text, sizeof(text), "-%d!", entry.amount);
-                color = outgoing ?
-                    ImVec4(1.0f, 0.8f, 0.0f, alpha) :
-                    ImVec4(1.0f, 0.5f, 0.0f, alpha);
-                break;
-            case game::CombatTextEntry::HEAL:
-                snprintf(text, sizeof(text), "+%d", entry.amount);
-                color = ImVec4(0.3f, 1.0f, 0.3f, alpha);
-                break;
-            case game::CombatTextEntry::CRIT_HEAL:
-                snprintf(text, sizeof(text), "+%d!", entry.amount);
-                color = ImVec4(0.3f, 1.0f, 0.3f, alpha);
-                break;
-            case game::CombatTextEntry::MISS:
-                snprintf(text, sizeof(text), "Miss");
-                color = ImVec4(0.7f, 0.7f, 0.7f, alpha);
-                break;
-            case game::CombatTextEntry::DODGE:
-                snprintf(text, sizeof(text), outgoing ? "Dodge" : "You Dodge");
-                color = outgoing ? ImVec4(0.6f, 0.6f, 0.6f, alpha)
-                                 : ImVec4(0.4f, 0.9f, 1.0f, alpha);
-                break;
-            case game::CombatTextEntry::PARRY:
-                snprintf(text, sizeof(text), outgoing ? "Parry" : "You Parry");
-                color = outgoing ? ImVec4(0.6f, 0.6f, 0.6f, alpha)
-                                 : ImVec4(0.4f, 0.9f, 1.0f, alpha);
-                break;
-            case game::CombatTextEntry::BLOCK:
-                if (entry.amount > 0)
-                    snprintf(text, sizeof(text), outgoing ? "Block %d" : "You Block %d", entry.amount);
-                else
-                    snprintf(text, sizeof(text), outgoing ? "Block" : "You Block");
-                color = outgoing ? ImVec4(0.6f, 0.6f, 0.6f, alpha)
-                                 : ImVec4(0.4f, 0.9f, 1.0f, alpha);
-                break;
-            case game::CombatTextEntry::EVADE:
-                snprintf(text, sizeof(text), outgoing ? "Evade" : "You Evade");
-                color = outgoing ? ImVec4(0.6f, 0.6f, 0.6f, alpha)
-                                 : ImVec4(0.4f, 0.9f, 1.0f, alpha);
-                break;
-            case game::CombatTextEntry::PERIODIC_DAMAGE:
-                snprintf(text, sizeof(text), "-%d", entry.amount);
-                color = outgoing ?
-                    ImVec4(1.0f, 0.9f, 0.3f, alpha) :
-                    ImVec4(1.0f, 0.4f, 0.4f, alpha);
-                break;
-            case game::CombatTextEntry::PERIODIC_HEAL:
-                snprintf(text, sizeof(text), "+%d", entry.amount);
-                color = ImVec4(0.4f, 1.0f, 0.5f, alpha);
-                break;
-            case game::CombatTextEntry::ENVIRONMENTAL: {
-                const char* envLabel = "";
-                switch (entry.powerType) {
-                    case 0: envLabel = "Fatigue "; break;
-                    case 1: envLabel = "Drowning "; break;
-                    case 2: envLabel = ""; break;
-                    case 3: envLabel = "Lava "; break;
-                    case 4: envLabel = "Slime "; break;
-                    case 5: envLabel = "Fire "; break;
-                    default: envLabel = ""; break;
-                }
-                snprintf(text, sizeof(text), "%s-%d", envLabel, entry.amount);
-                color = ImVec4(0.9f, 0.5f, 0.2f, alpha);
-                break;
-            }
-            case game::CombatTextEntry::ENERGIZE:
-                snprintf(text, sizeof(text), "+%d", entry.amount);
-                switch (entry.powerType) {
-                    case 1:  color = ImVec4(1.0f, 0.2f, 0.2f, alpha); break;
-                    case 2:  color = ImVec4(1.0f, 0.6f, 0.1f, alpha); break;
-                    case 3:  color = ImVec4(1.0f, 0.9f, 0.2f, alpha); break;
-                    case 6:  color = ImVec4(0.3f, 0.9f, 0.8f, alpha); break;
-                    default: color = ImVec4(0.3f, 0.6f, 1.0f, alpha); break;
-                }
-                break;
-            case game::CombatTextEntry::POWER_DRAIN:
-                snprintf(text, sizeof(text), "-%d", entry.amount);
-                switch (entry.powerType) {
-                    case 1:  color = ImVec4(1.0f, 0.35f, 0.35f, alpha); break;
-                    case 2:  color = ImVec4(1.0f, 0.7f, 0.2f, alpha); break;
-                    case 3:  color = ImVec4(1.0f, 0.95f, 0.35f, alpha); break;
-                    case 6:  color = ImVec4(0.45f, 0.95f, 0.85f, alpha); break;
-                    default: color = ImVec4(0.45f, 0.75f, 1.0f, alpha); break;
-                }
-                break;
-            case game::CombatTextEntry::XP_GAIN:
-                snprintf(text, sizeof(text), "+%d XP", entry.amount);
-                color = ImVec4(0.7f, 0.3f, 1.0f, alpha);
-                break;
-            case game::CombatTextEntry::IMMUNE:
-                snprintf(text, sizeof(text), "Immune!");
-                color = ImVec4(0.9f, 0.9f, 0.9f, alpha);
-                break;
-            case game::CombatTextEntry::ABSORB:
-                if (entry.amount > 0)
-                    snprintf(text, sizeof(text), "Absorbed %d", entry.amount);
-                else
-                    snprintf(text, sizeof(text), "Absorbed");
-                color = ImVec4(0.5f, 0.8f, 1.0f, alpha);
-                break;
-            case game::CombatTextEntry::RESIST:
-                if (entry.amount > 0)
-                    snprintf(text, sizeof(text), "Resisted %d", entry.amount);
-                else
-                    snprintf(text, sizeof(text), "Resisted");
-                color = ImVec4(0.7f, 0.7f, 0.7f, alpha);
-                break;
-            case game::CombatTextEntry::DEFLECT:
-                snprintf(text, sizeof(text), outgoing ? "Deflect" : "You Deflect");
-                color = outgoing ? ImVec4(0.7f, 0.7f, 0.7f, alpha)
-                                 : ImVec4(0.5f, 0.9f, 1.0f, alpha);
-                break;
-            case game::CombatTextEntry::REFLECT: {
-                const std::string& reflectName = entry.spellId ? gameHandler.getSpellName(entry.spellId) : "";
-                if (!reflectName.empty())
-                    snprintf(text, sizeof(text), outgoing ? "Reflected: %s" : "Reflect: %s", reflectName.c_str());
-                else
-                    snprintf(text, sizeof(text), outgoing ? "Reflected" : "You Reflect");
-                color = outgoing ? ImVec4(0.85f, 0.75f, 1.0f, alpha)
-                                 : ImVec4(0.75f, 0.85f, 1.0f, alpha);
-                break;
-            }
-            case game::CombatTextEntry::PROC_TRIGGER: {
-                const std::string& procName = entry.spellId ? gameHandler.getSpellName(entry.spellId) : "";
-                if (!procName.empty())
-                    snprintf(text, sizeof(text), "%s!", procName.c_str());
-                else
-                    snprintf(text, sizeof(text), "PROC!");
-                color = ImVec4(1.0f, 0.85f, 0.0f, alpha);
-                break;
-            }
-            case game::CombatTextEntry::DISPEL:
-                if (entry.spellId != 0) {
-                    const std::string& dispelledName = gameHandler.getSpellName(entry.spellId);
-                    if (!dispelledName.empty())
-                        snprintf(text, sizeof(text), "Dispel %s", dispelledName.c_str());
-                    else
-                        snprintf(text, sizeof(text), "Dispel");
-                } else {
-                    snprintf(text, sizeof(text), "Dispel");
-                }
-                color = ImVec4(0.6f, 0.9f, 1.0f, alpha);
-                break;
-            case game::CombatTextEntry::STEAL:
-                if (entry.spellId != 0) {
-                    const std::string& stolenName = gameHandler.getSpellName(entry.spellId);
-                    if (!stolenName.empty())
-                        snprintf(text, sizeof(text), "Spellsteal %s", stolenName.c_str());
-                    else
-                        snprintf(text, sizeof(text), "Spellsteal");
-                } else {
-                    snprintf(text, sizeof(text), "Spellsteal");
-                }
-                color = ImVec4(0.8f, 0.7f, 1.0f, alpha);
-                break;
-            case game::CombatTextEntry::INTERRUPT: {
-                const std::string& interruptedName = entry.spellId ? gameHandler.getSpellName(entry.spellId) : "";
-                if (!interruptedName.empty())
-                    snprintf(text, sizeof(text), "Interrupt %s", interruptedName.c_str());
-                else
-                    snprintf(text, sizeof(text), "Interrupt");
-                color = ImVec4(1.0f, 0.6f, 0.9f, alpha);
-                break;
-            }
-            case game::CombatTextEntry::INSTAKILL:
-                snprintf(text, sizeof(text), outgoing ? "Kill!" : "Killed!");
-                color = outgoing ? ImVec4(1.0f, 0.25f, 0.25f, alpha)
-                                 : ImVec4(1.0f, 0.1f, 0.1f, alpha);
-                break;
-            case game::CombatTextEntry::HONOR_GAIN:
-                snprintf(text, sizeof(text), "+%d Honor", entry.amount);
-                color = ImVec4(1.0f, 0.85f, 0.0f, alpha);
-                break;
-            case game::CombatTextEntry::GLANCING:
-                snprintf(text, sizeof(text), "~%d", entry.amount);
-                color = outgoing ?
-                    ImVec4(0.75f, 0.75f, 0.5f, alpha) :
-                    ImVec4(0.75f, 0.35f, 0.35f, alpha);
-                break;
-            case game::CombatTextEntry::CRUSHING:
-                snprintf(text, sizeof(text), "%d!", entry.amount);
-                color = outgoing ?
-                    ImVec4(1.0f, 0.55f, 0.1f, alpha) :
-                    ImVec4(1.0f, 0.15f, 0.15f, alpha);
-                break;
-            default:
-                snprintf(text, sizeof(text), "%d", entry.amount);
-                color = ImVec4(1.0f, 1.0f, 1.0f, alpha);
-                break;
-        }
-
-        // --- Rendering style ---
-        bool isCrit = (entry.type == game::CombatTextEntry::CRIT_DAMAGE ||
-                       entry.type == game::CombatTextEntry::CRIT_HEAL);
-        float renderFontSize = isCrit ? baseFontSize * 1.35f : baseFontSize;
-
-        ImU32 shadowCol = IM_COL32(0, 0, 0, static_cast<int>(alpha * 180));
-        ImU32 textCol   = ImGui::ColorConvertFloat4ToU32(color);
-
-        // --- Try world-space anchor if we have a destination entity ---
-        // Types that should always stay as HUD elements (no world anchor)
-        bool isHudOnly = (entry.type == game::CombatTextEntry::XP_GAIN ||
-                          entry.type == game::CombatTextEntry::HONOR_GAIN ||
-                          entry.type == game::CombatTextEntry::PROC_TRIGGER);
-
-        bool rendered = false;
-        if (!isHudOnly && camera && entry.dstGuid != 0) {
-            // Look up the destination entity's render position
-            glm::vec3 renderPos;
-            bool havePos = core::Application::getInstance().getRenderPositionForGuid(entry.dstGuid, renderPos);
-            if (!havePos) {
-                // Fallback to entity canonical position
-                auto entity = gameHandler.getEntityManager().getEntity(entry.dstGuid);
-                if (entity) {
-                    auto* unit = entity->isUnit() ? static_cast<game::Unit*>(entity.get()) : nullptr;
-                    if (unit) {
-                        renderPos = core::coords::canonicalToRender(
-                            glm::vec3(unit->getX(), unit->getY(), unit->getZ()));
-                        havePos = true;
-                    }
-                }
-            }
-
-            if (havePos) {
-                // Float upward from above the entity's head
-                renderPos.z += 2.5f + entry.age * 1.2f;
-
-                // Project to screen
-                glm::vec4 clipPos = viewProj * glm::vec4(renderPos, 1.0f);
-                if (clipPos.w > 0.01f) {
-                    glm::vec3 ndc = glm::vec3(clipPos) / clipPos.w;
-                    if (ndc.x >= -1.5f && ndc.x <= 1.5f && ndc.y >= -1.5f && ndc.y <= 1.5f) {
-                        float sx = (ndc.x * 0.5f + 0.5f) * screenW;
-                        float sy = (ndc.y * 0.5f + 0.5f) * screenH;
-
-                        // Horizontal stagger using the random seed
-                        sx += entry.xSeed * 40.0f;
-
-                        // Center the text horizontally on the projected point
-                        ImVec2 ts = font->CalcTextSizeA(renderFontSize, FLT_MAX, 0.0f, text);
-                        sx -= ts.x * 0.5f;
-
-                        // Clamp to screen bounds
-                        sx = std::max(2.0f, std::min(sx, screenW - ts.x - 2.0f));
-
-                        drawList->AddText(font, renderFontSize,
-                                          ImVec2(sx + 1.0f, sy + 1.0f), shadowCol, text);
-                        drawList->AddText(font, renderFontSize,
-                                          ImVec2(sx, sy), textCol, text);
-                        rendered = true;
-                    }
-                }
-            }
-        }
-
-        // --- HUD fallback for entries without world anchor or HUD-only types ---
-        if (!rendered) {
-            if (!needsHudWindow) {
-                needsHudWindow = true;
-                ImGui::SetNextWindowPos(ImVec2(0, 0));
-                ImGui::SetNextWindowSize(ImVec2(screenW, 400));
-                ImGuiWindowFlags flags = ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoDecoration |
-                                         ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoNav;
-                ImGui::Begin("##CombatText", nullptr, flags);
-            }
-
-            float yOffset = 200.0f - entry.age * 60.0f;
-            int& idx = outgoing ? hudOutIdx : hudInIdx;
-            float baseX = outgoing ? hudOutgoingX : hudIncomingX;
-            float xOffset = baseX + (idx % 3 - 1) * 60.0f;
-            ++idx;
-
-            ImGui::SetCursorPos(ImVec2(xOffset, yOffset));
-            ImVec2 screenPos = ImGui::GetCursorScreenPos();
-
-            ImDrawList* dl = ImGui::GetWindowDrawList();
-            dl->AddText(font, renderFontSize, ImVec2(screenPos.x + 1.0f, screenPos.y + 1.0f),
-                        shadowCol, text);
-            dl->AddText(font, renderFontSize, screenPos, textCol, text);
-
-            ImVec2 ts = font->CalcTextSizeA(renderFontSize, FLT_MAX, 0.0f, text);
-            ImGui::Dummy(ts);
-        }
-    }
-
-    if (needsHudWindow) {
-        ImGui::End();
-    }
-}
-
-
-// ============================================================
-// DPS / HPS Meter
-// ============================================================
-
-void CombatUI::renderDPSMeter(game::GameHandler& gameHandler,
-                              const SettingsPanel& settings) {
-    if (!settings.showDPSMeter_) return;
-    if (gameHandler.getState() != game::WorldState::IN_WORLD) return;
-
-    const float dt = ImGui::GetIO().DeltaTime;
-
-    // Track combat duration for accurate DPS denominator in short fights
-    bool inCombat = gameHandler.isInCombat();
-    if (inCombat && !dpsWasInCombat_) {
-        // Just entered combat — reset encounter accumulators
-        dpsEncounterDamage_ = 0.0f;
-        dpsEncounterHeal_   = 0.0f;
-        dpsLogSeenCount_    = gameHandler.getCombatLog().size();
-        dpsCombatAge_       = 0.0f;
-    }
-    if (inCombat) {
-        dpsCombatAge_ += dt;
-        // Scan any new log entries since last frame
-        const auto& log = gameHandler.getCombatLog();
-        while (dpsLogSeenCount_ < log.size()) {
-            const auto& e = log[dpsLogSeenCount_++];
-            if (!e.isPlayerSource) continue;
-            switch (e.type) {
-                case game::CombatTextEntry::MELEE_DAMAGE:
-                case game::CombatTextEntry::SPELL_DAMAGE:
-                case game::CombatTextEntry::CRIT_DAMAGE:
-                case game::CombatTextEntry::PERIODIC_DAMAGE:
-                case game::CombatTextEntry::GLANCING:
-                case game::CombatTextEntry::CRUSHING:
-                    dpsEncounterDamage_ += static_cast<float>(e.amount);
-                    break;
-                case game::CombatTextEntry::HEAL:
-                case game::CombatTextEntry::CRIT_HEAL:
-                case game::CombatTextEntry::PERIODIC_HEAL:
-                    dpsEncounterHeal_ += static_cast<float>(e.amount);
-                    break;
-                default: break;
-            }
-        }
-    } else if (dpsWasInCombat_) {
-        // Just left combat — keep encounter totals but stop accumulating
-    }
-    dpsWasInCombat_ = inCombat;
-
-    // Sum all player-source damage and healing in the current combat-text window
-    float totalDamage = 0.0f, totalHeal = 0.0f;
-    for (const auto& e : gameHandler.getCombatText()) {
-        if (!e.isPlayerSource) continue;
-        switch (e.type) {
-            case game::CombatTextEntry::MELEE_DAMAGE:
-            case game::CombatTextEntry::SPELL_DAMAGE:
-            case game::CombatTextEntry::CRIT_DAMAGE:
-            case game::CombatTextEntry::PERIODIC_DAMAGE:
-            case game::CombatTextEntry::GLANCING:
-            case game::CombatTextEntry::CRUSHING:
-                totalDamage += static_cast<float>(e.amount);
-                break;
-            case game::CombatTextEntry::HEAL:
-            case game::CombatTextEntry::CRIT_HEAL:
-            case game::CombatTextEntry::PERIODIC_HEAL:
-                totalHeal += static_cast<float>(e.amount);
-                break;
-            default: break;
-        }
-    }
-
-    // Only show if there's something to report (rolling window or lingering encounter data)
-    if (totalDamage < 1.0f && totalHeal < 1.0f && !inCombat &&
-        dpsEncounterDamage_ < 1.0f && dpsEncounterHeal_ < 1.0f) return;
-
-    // DPS window = min(combat age, combat-text lifetime) to avoid under-counting
-    // at the start of a fight and over-counting when entries expire.
-    float window = std::min(dpsCombatAge_, game::CombatTextEntry::LIFETIME);
-    if (window < 0.1f) window = 0.1f;
-
-    float dps = totalDamage / window;
-    float hps = totalHeal / window;
-
-    // Format numbers with K/M suffix for readability
-    auto fmtNum = [](float v, char* buf, int bufSz) {
-        if (v >= 1e6f)       snprintf(buf, bufSz, "%.1fM", v / 1e6f);
-        else if (v >= 1000.f) snprintf(buf, bufSz, "%.1fK", v / 1000.f);
-        else                 snprintf(buf, bufSz, "%.0f", v);
-    };
-
-    char dpsBuf[16], hpsBuf[16];
-    fmtNum(dps, dpsBuf, sizeof(dpsBuf));
-    fmtNum(hps, hpsBuf, sizeof(hpsBuf));
-
-    // Position: small floating label just above the action bar, right of center
-    auto* appWin = services_.window;
-    float screenW = appWin ? static_cast<float>(appWin->getWidth())  : 1280.0f;
-    float screenH = appWin ? static_cast<float>(appWin->getHeight()) : 720.0f;
-
-    // Show encounter row when fight has been going long enough (> 3s)
-    bool showEnc = (dpsCombatAge_ > 3.0f || (!inCombat && dpsEncounterDamage_ > 0.0f));
-    float encDPS = (dpsCombatAge_ > 0.1f) ? dpsEncounterDamage_ / dpsCombatAge_ : 0.0f;
-    float encHPS = (dpsCombatAge_ > 0.1f) ? dpsEncounterHeal_   / dpsCombatAge_ : 0.0f;
-
-    char encDpsBuf[16], encHpsBuf[16];
-    fmtNum(encDPS, encDpsBuf, sizeof(encDpsBuf));
-    fmtNum(encHPS, encHpsBuf, sizeof(encHpsBuf));
-
-    constexpr float WIN_W = 90.0f;
-    // Extra rows for encounter DPS/HPS if active
-    int extraRows = 0;
-    if (showEnc && encDPS > 0.5f) ++extraRows;
-    if (showEnc && encHPS > 0.5f) ++extraRows;
-    float WIN_H = 18.0f + extraRows * 14.0f;
-    if (dps > 0.5f || hps > 0.5f) WIN_H = std::max(WIN_H, 36.0f);
-    float wx = screenW * 0.5f + 160.0f;   // right of cast bar
-    float wy = screenH - 130.0f;           // above action bar area
-
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove    |
-                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
-                             ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoNav    |
-                             ImGuiWindowFlags_NoInputs;
-    ImGui::SetNextWindowPos(ImVec2(wx, wy), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(WIN_W, WIN_H), ImGuiCond_Always);
-    ImGui::SetNextWindowBgAlpha(0.55f);
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(4, 3));
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-    ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.3f, 0.3f, 0.3f, 0.7f));
-
-    if (ImGui::Begin("##DPSMeter", nullptr, flags)) {
-        if (dps > 0.5f) {
-            ImGui::TextColored(ImVec4(1.0f, 0.45f, 0.15f, 1.0f), "%s", dpsBuf);
-            ImGui::SameLine(0, 2);
-            ImGui::TextDisabled("dps");
-        }
-        if (hps > 0.5f) {
-            ImGui::TextColored(ImVec4(0.35f, 1.0f, 0.35f, 1.0f), "%s", hpsBuf);
-            ImGui::SameLine(0, 2);
-            ImGui::TextDisabled("hps");
-        }
-        // Encounter totals (full-fight average, shown when fight > 3s)
-        if (showEnc && encDPS > 0.5f) {
-            ImGui::TextColored(ImVec4(1.0f, 0.65f, 0.25f, 0.80f), "%s", encDpsBuf);
-            ImGui::SameLine(0, 2);
-            ImGui::TextDisabled("enc");
-        }
-        if (showEnc && encHPS > 0.5f) {
-            ImGui::TextColored(ImVec4(0.50f, 1.0f, 0.50f, 0.80f), "%s", encHpsBuf);
-            ImGui::SameLine(0, 2);
-            ImGui::TextDisabled("enc");
-        }
-    }
-    ImGui::End();
-
-    ImGui::PopStyleColor();
-    ImGui::PopStyleVar(2);
-}
-
-
-// ============================================================
-// Buff/Debuff Bar
-// ============================================================
-
-void CombatUI::renderBuffBar(game::GameHandler& gameHandler,
-                             SpellbookScreen& spellbookScreen,
-                             SpellIconFn getSpellIcon) {
-    const auto& auras = gameHandler.getPlayerAuras();
-
-    // Count non-empty auras
-    int activeCount = 0;
-    for (const auto& a : auras) {
-        if (!a.isEmpty()) activeCount++;
-    }
-    if (activeCount == 0 && !gameHandler.hasPet()) return;
-
-    auto* assetMgr = services_.assetManager;
-
-    // Position below the minimap (minimap: 200x200 at top-right, bottom edge at Y≈210)
-    // Anchored to the right side to stay away from party frames on the left
-    constexpr float ICON_SIZE = 32.0f;
-    constexpr int ICONS_PER_ROW = 8;
-    float barW = ICONS_PER_ROW * (ICON_SIZE + 4.0f) + 8.0f;
-    ImVec2 displaySize = ImGui::GetIO().DisplaySize;
-    float screenW = displaySize.x > 0.0f ? displaySize.x : 1280.0f;
-    // Y=215 puts us just below the minimap's bottom edge (minimap bottom ≈ 210)
-    ImGui::SetNextWindowPos(ImVec2(screenW - barW - 10.0f, 215.0f), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(barW, 0), ImGuiCond_Always);
-
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
-                             ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoScrollbar;
-
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.0f, 0.0f, 0.0f, 0.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(2.0f, 2.0f));
-
-    if (ImGui::Begin("##BuffBar", nullptr, flags)) {
-        // Pre-sort auras: buffs first, then debuffs; within each group, shorter remaining first
-        uint64_t buffNowMs = static_cast<uint64_t>(
-            std::chrono::duration_cast<std::chrono::milliseconds>(
-                std::chrono::steady_clock::now().time_since_epoch()).count());
-        std::vector<size_t> buffSortedIdx;
-        buffSortedIdx.reserve(auras.size());
-        for (size_t i = 0; i < auras.size(); ++i)
-            if (!auras[i].isEmpty()) buffSortedIdx.push_back(i);
-        std::sort(buffSortedIdx.begin(), buffSortedIdx.end(), [&](size_t a, size_t b) {
-            const auto& aa = auras[a]; const auto& ab = auras[b];
-            bool aDebuff = (aa.flags & 0x80) != 0;
-            bool bDebuff = (ab.flags & 0x80) != 0;
-            if (aDebuff != bDebuff) return aDebuff < bDebuff; // buffs (0) first
-            int32_t ra = aa.getRemainingMs(buffNowMs);
-            int32_t rb = ab.getRemainingMs(buffNowMs);
-            if (ra < 0 && rb < 0) return false;
-            if (ra < 0) return false;
-            if (rb < 0) return true;
-            return ra < rb;
-        });
-
-        // Render one pass for buffs, one for debuffs
-        for (int pass = 0; pass < 2; ++pass) {
-            bool wantBuff = (pass == 0);
-            int shown = 0;
-        for (size_t si = 0; si < buffSortedIdx.size() && shown < 40; ++si) {
-            size_t i = buffSortedIdx[si];
-            const auto& aura = auras[i];
-            if (aura.isEmpty()) continue;
-
-            bool isBuff = (aura.flags & 0x80) == 0;  // 0x80 = negative/debuff flag
-            if (isBuff != wantBuff) continue;  // only render matching pass
-
-            if (shown > 0 && shown % ICONS_PER_ROW != 0) ImGui::SameLine();
-
-            ImGui::PushID(static_cast<int>(i) + (pass * 256));
-
-            // Determine border color: buffs = green; debuffs use WoW dispel-type colors
-            ImVec4 borderColor;
-            if (isBuff) {
-                borderColor = ImVec4(0.2f, 0.8f, 0.2f, 0.9f);  // green
-            } else {
-                // Debuff: color by dispel type (0=none/red, 1=magic/blue, 2=curse/purple,
-                //         3=disease/brown, 4=poison/green, other=dark-red)
-                uint8_t dt = gameHandler.getSpellDispelType(aura.spellId);
-                switch (dt) {
-                    case 1:  borderColor = ImVec4(0.15f, 0.50f, 1.00f, 0.9f); break;  // magic: blue
-                    case 2:  borderColor = ImVec4(0.70f, 0.20f, 0.90f, 0.9f); break;  // curse: purple
-                    case 3:  borderColor = ImVec4(0.55f, 0.30f, 0.10f, 0.9f); break;  // disease: brown
-                    case 4:  borderColor = ImVec4(0.10f, 0.70f, 0.10f, 0.9f); break;  // poison: green
-                    default: borderColor = ImVec4(0.80f, 0.20f, 0.20f, 0.9f); break;  // other: red
-                }
-            }
-
-            // Try to get spell icon
-            VkDescriptorSet iconTex = VK_NULL_HANDLE;
-            if (assetMgr) {
-                iconTex = getSpellIcon(aura.spellId, assetMgr);
-            }
-
-            if (iconTex) {
-                ImGui::PushStyleColor(ImGuiCol_Button, borderColor);
-                ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(2, 2));
-                ImGui::ImageButton("##aura",
-                    (ImTextureID)(uintptr_t)iconTex,
-                    ImVec2(ICON_SIZE - 4, ICON_SIZE - 4));
-                ImGui::PopStyleVar();
-                ImGui::PopStyleColor();
-            } else {
-                ImGui::PushStyleColor(ImGuiCol_Button, borderColor);
-                const std::string& pAuraName = gameHandler.getSpellName(aura.spellId);
-                char label[32];
-                if (!pAuraName.empty())
-                    snprintf(label, sizeof(label), "%.6s", pAuraName.c_str());
-                else
-                    snprintf(label, sizeof(label), "%u", aura.spellId);
-                ImGui::Button(label, ImVec2(ICON_SIZE, ICON_SIZE));
-                ImGui::PopStyleColor();
-            }
-
-            // Compute remaining duration once (shared by overlay and tooltip)
-            uint64_t nowMs = static_cast<uint64_t>(
-                std::chrono::duration_cast<std::chrono::milliseconds>(
-                    std::chrono::steady_clock::now().time_since_epoch()).count());
-            int32_t remainMs = aura.getRemainingMs(nowMs);
-
-            // Clock-sweep overlay: dark fan shows elapsed time (WoW style)
-            if (remainMs > 0 && aura.maxDurationMs > 0) {
-                ImVec2 iconMin2 = ImGui::GetItemRectMin();
-                ImVec2 iconMax2 = ImGui::GetItemRectMax();
-                float cx2 = (iconMin2.x + iconMax2.x) * 0.5f;
-                float cy2 = (iconMin2.y + iconMax2.y) * 0.5f;
-                float fanR2 = (iconMax2.x - iconMin2.x) * 0.5f;
-                float total2 = static_cast<float>(aura.maxDurationMs);
-                float elapsedFrac2 = std::clamp(
-                    1.0f - static_cast<float>(remainMs) / total2, 0.0f, 1.0f);
-                if (elapsedFrac2 > 0.005f) {
-                    constexpr int SWEEP_SEGS = 24;
-                    float sa = -IM_PI * 0.5f;
-                    float ea = sa + elapsedFrac2 * 2.0f * IM_PI;
-                    ImVec2 pts[SWEEP_SEGS + 2];
-                    pts[0] = ImVec2(cx2, cy2);
-                    for (int s = 0; s <= SWEEP_SEGS; ++s) {
-                        float a = sa + (ea - sa) * s / static_cast<float>(SWEEP_SEGS);
-                        pts[s + 1] = ImVec2(cx2 + std::cos(a) * fanR2,
-                                            cy2 + std::sin(a) * fanR2);
-                    }
-                    ImGui::GetWindowDrawList()->AddConvexPolyFilled(
-                        pts, SWEEP_SEGS + 2, IM_COL32(0, 0, 0, 145));
-                }
-            }
-
-            // Duration countdown overlay — always visible on the icon bottom
-            if (remainMs > 0) {
-                ImVec2 iconMin = ImGui::GetItemRectMin();
-                ImVec2 iconMax = ImGui::GetItemRectMax();
-                char timeStr[12];
-                int secs = (remainMs + 999) / 1000;  // ceiling seconds
-                if (secs >= 3600)
-                    snprintf(timeStr, sizeof(timeStr), "%dh", secs / 3600);
-                else if (secs >= 60)
-                    snprintf(timeStr, sizeof(timeStr), "%d:%02d", secs / 60, secs % 60);
-                else
-                    snprintf(timeStr, sizeof(timeStr), "%d", secs);
-                ImVec2 textSize = ImGui::CalcTextSize(timeStr);
-                float cx = iconMin.x + (iconMax.x - iconMin.x - textSize.x) * 0.5f;
-                float cy = iconMax.y - textSize.y - 2.0f;
-                // Choose timer color based on urgency
-                ImU32 timerColor;
-                if (remainMs < 10000) {
-                    // < 10s: pulse red
-                    float pulse = 0.7f + 0.3f * std::sin(
-                        static_cast<float>(ImGui::GetTime()) * 6.0f);
-                    timerColor = IM_COL32(
-                        static_cast<int>(255 * pulse),
-                        static_cast<int>(80 * pulse),
-                        static_cast<int>(60 * pulse), 255);
-                } else if (remainMs < 30000) {
-                    timerColor = IM_COL32(255, 165, 0, 255); // orange
-                } else {
-                    timerColor = IM_COL32(255, 255, 255, 255); // white
-                }
-                // Drop shadow for readability over any icon colour
-                ImGui::GetWindowDrawList()->AddText(ImVec2(cx + 1, cy + 1),
-                    IM_COL32(0, 0, 0, 200), timeStr);
-                ImGui::GetWindowDrawList()->AddText(ImVec2(cx, cy),
-                    timerColor, timeStr);
-            }
-
-            // Stack / charge count overlay — upper-left corner of the icon
-            if (aura.charges > 1) {
-                ImVec2 iconMin = ImGui::GetItemRectMin();
-                char chargeStr[8];
-                snprintf(chargeStr, sizeof(chargeStr), "%u", static_cast<unsigned>(aura.charges));
-                // Drop shadow then bright yellow text
-                ImGui::GetWindowDrawList()->AddText(ImVec2(iconMin.x + 3, iconMin.y + 3),
-                    IM_COL32(0, 0, 0, 200), chargeStr);
-                ImGui::GetWindowDrawList()->AddText(ImVec2(iconMin.x + 2, iconMin.y + 2),
-                    IM_COL32(255, 220, 50, 255), chargeStr);
-            }
-
-            // Right-click to cancel buffs / dismount
-            if (ImGui::IsItemClicked(ImGuiMouseButton_Right)) {
-                if (gameHandler.isMounted()) {
-                    gameHandler.dismount();
-                } else if (isBuff) {
-                    gameHandler.cancelAura(aura.spellId);
-                }
-            }
-
-            // Tooltip: rich spell info + remaining duration
-            if (ImGui::IsItemHovered()) {
-                ImGui::BeginTooltip();
-                bool richOk = spellbookScreen.renderSpellInfoTooltip(aura.spellId, gameHandler, assetMgr);
-                if (!richOk) {
-                    std::string name = spellbookScreen.lookupSpellName(aura.spellId, assetMgr);
-                    if (name.empty()) name = "Spell #" + std::to_string(aura.spellId);
-                    ImGui::Text("%s", name.c_str());
-                }
-                renderAuraRemaining(remainMs);
-                ImGui::EndTooltip();
-            }
-
-            ImGui::PopID();
-            shown++;
-        }  // end aura loop
-        // Add visual gap between buffs and debuffs
-        if (pass == 0 && shown > 0) ImGui::Spacing();
-        }  // end pass loop
-
-        // Dismiss Pet button
-        if (gameHandler.hasPet()) {
-            ImGui::Spacing();
-            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.6f, 0.2f, 0.2f, 0.9f));
-            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.8f, 0.3f, 0.3f, 1.0f));
-            if (ImGui::Button("Dismiss Pet", ImVec2(-1, 0))) {
-                gameHandler.dismissPet();
-            }
-            ImGui::PopStyleColor(2);
-        }
-
-        // Temporary weapon enchant timers (Shaman imbues, Rogue poisons, whetstones, etc.)
-        {
-            const auto& timers = gameHandler.getTempEnchantTimers();
-            if (!timers.empty()) {
-                ImGui::Spacing();
-                ImGui::Separator();
-                static constexpr ImVec4 kEnchantSlotColors[] = {
-                    colors::kOrange,  // main-hand: gold
-                    ImVec4(0.5f, 0.8f, 0.9f, 1.0f),  // off-hand:  teal
-                    ImVec4(0.7f, 0.5f, 0.9f, 1.0f),  // ranged:    purple
-                };
-                uint64_t enchNowMs = static_cast<uint64_t>(
-                    std::chrono::duration_cast<std::chrono::milliseconds>(
-                        std::chrono::steady_clock::now().time_since_epoch()).count());
-
-                for (const auto& t : timers) {
-                    if (t.slot > 2) continue;
-                    uint64_t remMs = (t.expireMs > enchNowMs) ? (t.expireMs - enchNowMs) : 0;
-                    if (remMs == 0) continue;
-
-                    ImVec4 col = kEnchantSlotColors[t.slot];
-                    // Flash red when < 60s remaining
-                    if (remMs < 60000) {
-                        float pulse = 0.6f + 0.4f * std::sin(
-                            static_cast<float>(ImGui::GetTime()) * 4.0f);
-                        col = ImVec4(pulse, 0.2f, 0.1f, 1.0f);
-                    }
-
-                    // Format remaining time
-                    uint32_t secs = static_cast<uint32_t>((remMs + 999) / 1000);
-                    char timeStr[16];
-                    if (secs >= 3600)
-                        snprintf(timeStr, sizeof(timeStr), "%dh%02dm", secs / 3600, (secs % 3600) / 60);
-                    else if (secs >= 60)
-                        snprintf(timeStr, sizeof(timeStr), "%d:%02d", secs / 60, secs % 60);
-                    else
-                        snprintf(timeStr, sizeof(timeStr), "%ds", secs);
-
-                    ImGui::PushID(static_cast<int>(t.slot) + 5000);
-                    ImGui::PushStyleColor(ImGuiCol_Button, col);
-                    char label[40];
-                    snprintf(label, sizeof(label), "~%s  %s",
-                             game::GameHandler::kTempEnchantSlotNames[t.slot], timeStr);
-                    ImGui::Button(label, ImVec2(-1, 16));
-                    if (ImGui::IsItemHovered())
-                        ImGui::SetTooltip("Temporary weapon enchant: %s\nRemaining: %s",
-                                          game::GameHandler::kTempEnchantSlotNames[t.slot],
-                                          timeStr);
-                    ImGui::PopStyleColor();
-                    ImGui::PopID();
-                }
-            }
-        }
-    }
-    ImGui::End();
-
-    ImGui::PopStyleVar();
-    ImGui::PopStyleColor();
-}
-
-//   WSG  489 – Alliance / Horde flag captures (max 3)
-//   AB   529 – Alliance / Horde resource scores (max 1600)
-//   AV    30 – Alliance / Horde reinforcements
-//   EotS 566 – Alliance / Horde resource scores (max 1600)
-// ============================================================================
-void CombatUI::renderBattlegroundScore(game::GameHandler& gameHandler) {
-    // Only show when in a recognised battleground map
-    uint32_t mapId = gameHandler.getWorldStateMapId();
-
-    // World state key sets per battleground
-    // Keys from the WoW 3.3.5a WorldState.dbc / client source
-    struct BgScoreDef {
-        uint32_t mapId;
-        const char* name;
-        uint32_t allianceKey;   // world state key for Alliance value
-        uint32_t hordeKey;      // world state key for Horde value
-        uint32_t maxKey;        // max score world state key (0 = use hardcoded)
-        uint32_t hardcodedMax;  // used when maxKey == 0
-        const char* unit;       // suffix label (e.g. "flags", "resources")
-    };
-
-    static constexpr BgScoreDef kBgDefs[] = {
-        // Warsong Gulch: 3 flag captures wins
-        { 489, "Warsong Gulch", 1581, 1582, 0, 3, "flags" },
-        // Arathi Basin: 1600 resources wins
-        { 529, "Arathi Basin",  1218, 1219, 0, 1600, "resources" },
-        // Alterac Valley: reinforcements count down from 600 / 800 etc.
-        {  30, "Alterac Valley", 1322, 1323, 0, 600, "reinforcements" },
-        // Eye of the Storm: 1600 resources wins
-        { 566, "Eye of the Storm", 2757, 2758, 0, 1600, "resources" },
-        // Strand of the Ancients (WotLK)
-        { 607, "Strand of the Ancients", 3476, 3477, 0, 4, "" },
-        // Isle of Conquest (WotLK): reinforcements (300 default)
-        { 628, "Isle of Conquest", 4221, 4222, 0, 300, "reinforcements" },
-    };
-
-    const BgScoreDef* def = nullptr;
-    for (const auto& d : kBgDefs) {
-        if (d.mapId == mapId) { def = &d; break; }
-    }
-    if (!def) return;
-
-    auto allianceOpt = gameHandler.getWorldState(def->allianceKey);
-    auto hordeOpt    = gameHandler.getWorldState(def->hordeKey);
-    if (!allianceOpt && !hordeOpt) return;
-
-    uint32_t allianceScore = allianceOpt.value_or(0);
-    uint32_t hordeScore    = hordeOpt.value_or(0);
-    uint32_t maxScore      = def->hardcodedMax;
-    if (def->maxKey != 0) {
-        if (auto mv = gameHandler.getWorldState(def->maxKey)) maxScore = *mv;
-    }
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth())  : 1280.0f;
-
-    // Width scales with screen but stays reasonable
-    float frameW = 260.0f;
-    float frameH = 60.0f;
-    float posX   = screenW / 2.0f - frameW / 2.0f;
-    float posY   = 4.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(posX, posY), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(frameW, frameH), ImGuiCond_Always);
-    ImGui::SetNextWindowBgAlpha(0.75f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 6.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding,  ImVec2(6.0f, 4.0f));
-
-    if (ImGui::Begin("##BGScore", nullptr,
-            ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-            ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoBringToFrontOnFocus |
-            ImGuiWindowFlags_NoSavedSettings)) {
-
-        // BG name centred at top
-        float nameW = ImGui::CalcTextSize(def->name).x;
-        ImGui::SetCursorPosX((frameW - nameW) / 2.0f);
-        ImGui::TextColored(colors::kBrightGold, "%s", def->name);
-
-        // Alliance score | separator | Horde score
-        float innerW  = frameW - 12.0f;
-        float halfW   = innerW / 2.0f - 4.0f;
-
-        ImGui::SetCursorPosX(6.0f);
-        ImGui::BeginGroup();
-        {
-            // Alliance (blue)
-            char aBuf[32];
-            if (maxScore > 0 && strlen(def->unit) > 0)
-                snprintf(aBuf, sizeof(aBuf), "\xF0\x9F\x94\xB5 %u / %u", allianceScore, maxScore);
-            else
-                snprintf(aBuf, sizeof(aBuf), "\xF0\x9F\x94\xB5 %u", allianceScore);
-            ImGui::TextColored(colors::kLightBlue, "%s", aBuf);
-        }
-        ImGui::EndGroup();
-
-        ImGui::SameLine(halfW + 16.0f);
-
-        ImGui::BeginGroup();
-        {
-            // Horde (red)
-            char hBuf[32];
-            if (maxScore > 0 && strlen(def->unit) > 0)
-                snprintf(hBuf, sizeof(hBuf), "\xF0\x9F\x94\xB4 %u / %u", hordeScore, maxScore);
-            else
-                snprintf(hBuf, sizeof(hBuf), "\xF0\x9F\x94\xB4 %u", hordeScore);
-            ImGui::TextColored(colors::kHostileRed, "%s", hBuf);
-        }
-        ImGui::EndGroup();
-    }
-    ImGui::End();
-    ImGui::PopStyleVar(2);
-}
-
-
-// ─── Combat Log Window ────────────────────────────────────────────────────────
-void CombatUI::renderCombatLog(game::GameHandler& gameHandler,
-                              SpellbookScreen& spellbookScreen) {
-    if (!showCombatLog_) return;
-
-    const auto& log = gameHandler.getCombatLog();
-
-    ImGui::SetNextWindowSize(ImVec2(520, 320), ImGuiCond_FirstUseEver);
-    ImGui::SetNextWindowPos(ImVec2(160, 200), ImGuiCond_FirstUseEver);
-
-    char title[64];
-    snprintf(title, sizeof(title), "Combat Log (%zu)###CombatLog", log.size());
-    if (!ImGui::Begin(title, &showCombatLog_)) {
-        ImGui::End();
-        return;
-    }
-
-    // Filter toggles
-    static bool filterDamage  = true;
-    static bool filterHeal    = true;
-    static bool filterMisc    = true;
-    static bool autoScroll    = true;
-
-    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(4, 2));
-    ImGui::Checkbox("Damage",  &filterDamage); ImGui::SameLine();
-    ImGui::Checkbox("Healing", &filterHeal);   ImGui::SameLine();
-    ImGui::Checkbox("Misc",    &filterMisc);   ImGui::SameLine();
-    ImGui::Checkbox("Auto-scroll", &autoScroll);
-    ImGui::SameLine(ImGui::GetContentRegionAvail().x - 40.0f);
-    if (ImGui::SmallButton("Clear"))
-        gameHandler.clearCombatLog();
-    ImGui::PopStyleVar();
-    ImGui::Separator();
-
-    // Helper: categorize entry
-    auto isDamageType = [](game::CombatTextEntry::Type t) {
-        using T = game::CombatTextEntry;
-        return t == T::MELEE_DAMAGE || t == T::SPELL_DAMAGE ||
-               t == T::CRIT_DAMAGE  || t == T::PERIODIC_DAMAGE ||
-               t == T::ENVIRONMENTAL || t == T::GLANCING || t == T::CRUSHING;
-    };
-    auto isHealType = [](game::CombatTextEntry::Type t) {
-        using T = game::CombatTextEntry;
-        return t == T::HEAL || t == T::CRIT_HEAL || t == T::PERIODIC_HEAL;
-    };
-
-    // Two-column table: Time | Event description
-    ImGuiTableFlags tableFlags = ImGuiTableFlags_ScrollY | ImGuiTableFlags_RowBg |
-                                 ImGuiTableFlags_SizingFixedFit;
-    float availH = ImGui::GetContentRegionAvail().y;
-    if (ImGui::BeginTable("##CombatLogTable", 2, tableFlags, ImVec2(0.0f, availH))) {
-        ImGui::TableSetupScrollFreeze(0, 0);
-        ImGui::TableSetupColumn("Time",  ImGuiTableColumnFlags_WidthFixed, 62.0f);
-        ImGui::TableSetupColumn("Event", ImGuiTableColumnFlags_WidthStretch);
-
-        for (const auto& e : log) {
-            // Apply filters
-            bool isDmg  = isDamageType(e.type);
-            bool isHeal = isHealType(e.type);
-            bool isMisc = !isDmg && !isHeal;
-            if (isDmg  && !filterDamage) continue;
-            if (isHeal && !filterHeal)   continue;
-            if (isMisc && !filterMisc)   continue;
-
-            // Format timestamp as HH:MM:SS
-            char timeBuf[10];
-            {
-                struct tm* tm_info = std::localtime(&e.timestamp);
-                if (tm_info)
-                    snprintf(timeBuf, sizeof(timeBuf), "%02d:%02d:%02d",
-                             tm_info->tm_hour, tm_info->tm_min, tm_info->tm_sec);
-                else
-                    snprintf(timeBuf, sizeof(timeBuf), "--:--:--");
-            }
-
-            // Build event description and choose color
-            char desc[256];
-            ImVec4 color;
-            using T = game::CombatTextEntry;
-            const char* src = e.sourceName.empty() ? (e.isPlayerSource ? "You" : "?") : e.sourceName.c_str();
-            const char* tgt = e.targetName.empty() ? "?" : e.targetName.c_str();
-            const std::string& spellName = (e.spellId != 0) ? gameHandler.getSpellName(e.spellId) : std::string();
-            const char* spell = spellName.empty() ? nullptr : spellName.c_str();
-
-            switch (e.type) {
-                case T::MELEE_DAMAGE:
-                    snprintf(desc, sizeof(desc), "%s hits %s for %d", src, tgt, e.amount);
-                    color = e.isPlayerSource ? ImVec4(1.0f, 0.9f, 0.3f, 1.0f) : colors::kSoftRed;
-                    break;
-                case T::CRIT_DAMAGE:
-                    snprintf(desc, sizeof(desc), "%s crits %s for %d!", src, tgt, e.amount);
-                    color = e.isPlayerSource ? ImVec4(1.0f, 1.0f, 0.0f, 1.0f) : colors::kBrightRed;
-                    break;
-                case T::SPELL_DAMAGE:
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s's %s hits %s for %d", src, spell, tgt, e.amount);
-                    else
-                        snprintf(desc, sizeof(desc), "%s's spell hits %s for %d", src, tgt, e.amount);
-                    color = e.isPlayerSource ? ImVec4(1.0f, 0.9f, 0.3f, 1.0f) : colors::kSoftRed;
-                    break;
-                case T::PERIODIC_DAMAGE:
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s's %s ticks %s for %d", src, spell, tgt, e.amount);
-                    else
-                        snprintf(desc, sizeof(desc), "%s's DoT ticks %s for %d", src, tgt, e.amount);
-                    color = e.isPlayerSource ? ImVec4(0.9f, 0.7f, 0.3f, 1.0f) : ImVec4(0.9f, 0.3f, 0.3f, 1.0f);
-                    break;
-                case T::HEAL:
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s heals %s for %d (%s)", src, tgt, e.amount, spell);
-                    else
-                        snprintf(desc, sizeof(desc), "%s heals %s for %d", src, tgt, e.amount);
-                    color = kColorGreen;
-                    break;
-                case T::CRIT_HEAL:
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s critically heals %s for %d! (%s)", src, tgt, e.amount, spell);
-                    else
-                        snprintf(desc, sizeof(desc), "%s critically heals %s for %d!", src, tgt, e.amount);
-                    color = kColorBrightGreen;
-                    break;
-                case T::PERIODIC_HEAL:
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s's %s heals %s for %d", src, spell, tgt, e.amount);
-                    else
-                        snprintf(desc, sizeof(desc), "%s's HoT heals %s for %d", src, tgt, e.amount);
-                    color = ImVec4(0.4f, 0.9f, 0.4f, 1.0f);
-                    break;
-                case T::MISS:
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s's %s misses %s", src, spell, tgt);
-                    else
-                        snprintf(desc, sizeof(desc), "%s misses %s", src, tgt);
-                    color = colors::kMediumGray;
-                    break;
-                case T::DODGE:
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s dodges %s's %s", tgt, src, spell);
-                    else
-                        snprintf(desc, sizeof(desc), "%s dodges %s's attack", tgt, src);
-                    color = colors::kMediumGray;
-                    break;
-                case T::PARRY:
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s parries %s's %s", tgt, src, spell);
-                    else
-                        snprintf(desc, sizeof(desc), "%s parries %s's attack", tgt, src);
-                    color = colors::kMediumGray;
-                    break;
-                case T::BLOCK:
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s blocks %s's %s (%d blocked)", tgt, src, spell, e.amount);
-                    else
-                        snprintf(desc, sizeof(desc), "%s blocks %s's attack (%d blocked)", tgt, src, e.amount);
-                    color = ImVec4(0.65f, 0.75f, 0.65f, 1.0f);
-                    break;
-                case T::EVADE:
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s evades %s's %s", tgt, src, spell);
-                    else
-                        snprintf(desc, sizeof(desc), "%s evades %s's attack", tgt, src);
-                    color = colors::kMediumGray;
-                    break;
-                case T::IMMUNE:
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s is immune to %s", tgt, spell);
-                    else
-                        snprintf(desc, sizeof(desc), "%s is immune", tgt);
-                    color = colors::kSilver;
-                    break;
-                case T::ABSORB:
-                    if (spell && e.amount > 0)
-                        snprintf(desc, sizeof(desc), "%s's %s absorbs %d", src, spell, e.amount);
-                    else if (spell)
-                        snprintf(desc, sizeof(desc), "%s absorbs %s", tgt, spell);
-                    else if (e.amount > 0)
-                        snprintf(desc, sizeof(desc), "%d absorbed", e.amount);
-                    else
-                        snprintf(desc, sizeof(desc), "Absorbed");
-                    color = ImVec4(0.5f, 0.8f, 1.0f, 1.0f);
-                    break;
-                case T::RESIST:
-                    if (spell && e.amount > 0)
-                        snprintf(desc, sizeof(desc), "%s resists %s's %s (%d resisted)", tgt, src, spell, e.amount);
-                    else if (spell)
-                        snprintf(desc, sizeof(desc), "%s resists %s's %s", tgt, src, spell);
-                    else if (e.amount > 0)
-                        snprintf(desc, sizeof(desc), "%d resisted", e.amount);
-                    else
-                        snprintf(desc, sizeof(desc), "Resisted");
-                    color = ImVec4(0.6f, 0.6f, 0.9f, 1.0f);
-                    break;
-                case T::DEFLECT:
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s deflects %s's %s", tgt, src, spell);
-                    else
-                        snprintf(desc, sizeof(desc), "%s deflects %s's attack", tgt, src);
-                    color = ImVec4(0.65f, 0.8f, 0.95f, 1.0f);
-                    break;
-                case T::REFLECT:
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s reflects %s's %s", tgt, src, spell);
-                    else
-                        snprintf(desc, sizeof(desc), "%s reflects %s's attack", tgt, src);
-                    color = ImVec4(0.8f, 0.7f, 1.0f, 1.0f);
-                    break;
-                case T::ENVIRONMENTAL: {
-                    const char* envName = "Environmental";
-                    switch (e.powerType) {
-                        case 0: envName = "Fatigue"; break;
-                        case 1: envName = "Drowning"; break;
-                        case 2: envName = "Falling"; break;
-                        case 3: envName = "Lava"; break;
-                        case 4: envName = "Slime"; break;
-                        case 5: envName = "Fire"; break;
-                    }
-                    snprintf(desc, sizeof(desc), "%s damage: %d", envName, e.amount);
-                    color = ImVec4(1.0f, 0.5f, 0.2f, 1.0f);
-                    break;
-                }
-                case T::ENERGIZE: {
-                    const char* pwrName = "power";
-                    switch (e.powerType) {
-                        case 0: pwrName = "Mana"; break;
-                        case 1: pwrName = "Rage"; break;
-                        case 2: pwrName = "Focus"; break;
-                        case 3: pwrName = "Energy"; break;
-                        case 4: pwrName = "Happiness"; break;
-                        case 6: pwrName = "Runic Power"; break;
-                    }
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s gains %d %s (%s)", tgt, e.amount, pwrName, spell);
-                    else
-                        snprintf(desc, sizeof(desc), "%s gains %d %s", tgt, e.amount, pwrName);
-                    color = colors::kLightBlue;
-                    break;
-                }
-                case T::POWER_DRAIN: {
-                    const char* drainName = "power";
-                    switch (e.powerType) {
-                        case 0: drainName = "Mana"; break;
-                        case 1: drainName = "Rage"; break;
-                        case 2: drainName = "Focus"; break;
-                        case 3: drainName = "Energy"; break;
-                        case 4: drainName = "Happiness"; break;
-                        case 6: drainName = "Runic Power"; break;
-                    }
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s loses %d %s to %s's %s", tgt, e.amount, drainName, src, spell);
-                    else
-                        snprintf(desc, sizeof(desc), "%s loses %d %s", tgt, e.amount, drainName);
-                    color = ImVec4(0.45f, 0.75f, 1.0f, 1.0f);
-                    break;
-                }
-                case T::XP_GAIN:
-                    snprintf(desc, sizeof(desc), "You gain %d experience", e.amount);
-                    color = ImVec4(0.8f, 0.6f, 1.0f, 1.0f);
-                    break;
-                case T::PROC_TRIGGER:
-                    if (spell)
-                        snprintf(desc, sizeof(desc), "%s procs!", spell);
-                    else
-                        snprintf(desc, sizeof(desc), "Proc triggered");
-                    color = ImVec4(1.0f, 0.85f, 0.3f, 1.0f);
-                    break;
-                case T::DISPEL:
-                    if (spell && e.isPlayerSource)
-                        snprintf(desc, sizeof(desc), "You dispel %s from %s", spell, tgt);
-                    else if (spell)
-                        snprintf(desc, sizeof(desc), "%s dispels %s from %s", src, spell, tgt);
-                    else if (e.isPlayerSource)
-                        snprintf(desc, sizeof(desc), "You dispel from %s", tgt);
-                    else
-                        snprintf(desc, sizeof(desc), "%s dispels from %s", src, tgt);
-                    color = ImVec4(0.6f, 0.9f, 1.0f, 1.0f);
-                    break;
-                case T::STEAL:
-                    if (spell && e.isPlayerSource)
-                        snprintf(desc, sizeof(desc), "You steal %s from %s", spell, tgt);
-                    else if (spell)
-                        snprintf(desc, sizeof(desc), "%s steals %s from %s", src, spell, tgt);
-                    else if (e.isPlayerSource)
-                        snprintf(desc, sizeof(desc), "You steal from %s", tgt);
-                    else
-                        snprintf(desc, sizeof(desc), "%s steals from %s", src, tgt);
-                    color = ImVec4(0.8f, 0.7f, 1.0f, 1.0f);
-                    break;
-                case T::INTERRUPT:
-                    if (spell && e.isPlayerSource)
-                        snprintf(desc, sizeof(desc), "You interrupt %s's %s", tgt, spell);
-                    else if (spell)
-                        snprintf(desc, sizeof(desc), "%s interrupts %s's %s", src, tgt, spell);
-                    else if (e.isPlayerSource)
-                        snprintf(desc, sizeof(desc), "You interrupt %s", tgt);
-                    else
-                        snprintf(desc, sizeof(desc), "%s interrupted", tgt);
-                    color = ImVec4(1.0f, 0.6f, 0.9f, 1.0f);
-                    break;
-                case T::INSTAKILL:
-                    if (spell && e.isPlayerSource)
-                        snprintf(desc, sizeof(desc), "You instantly kill %s with %s", tgt, spell);
-                    else if (spell)
-                        snprintf(desc, sizeof(desc), "%s instantly kills %s with %s", src, tgt, spell);
-                    else if (e.isPlayerSource)
-                        snprintf(desc, sizeof(desc), "You instantly kill %s", tgt);
-                    else
-                        snprintf(desc, sizeof(desc), "%s instantly kills %s", src, tgt);
-                    color = colors::kBrightRed;
-                    break;
-                case T::HONOR_GAIN:
-                    snprintf(desc, sizeof(desc), "You gain %d honor", e.amount);
-                    color = colors::kBrightGold;
-                    break;
-                case T::GLANCING:
-                    snprintf(desc, sizeof(desc), "%s glances %s for %d", src, tgt, e.amount);
-                    color = e.isPlayerSource ? ImVec4(0.75f, 0.75f, 0.5f, 1.0f)
-                                             : ImVec4(0.75f, 0.4f, 0.4f, 1.0f);
-                    break;
-                case T::CRUSHING:
-                    snprintf(desc, sizeof(desc), "%s crushes %s for %d!", src, tgt, e.amount);
-                    color = e.isPlayerSource ? ImVec4(1.0f, 0.55f, 0.1f, 1.0f)
-                                             : ImVec4(1.0f, 0.15f, 0.15f, 1.0f);
-                    break;
-                default:
-                    snprintf(desc, sizeof(desc), "Combat event (type %d, amount %d)", static_cast<int>(e.type), e.amount);
-                    color = ui::colors::kLightGray;
-                    break;
-            }
-
-            ImGui::TableNextRow();
-            ImGui::TableSetColumnIndex(0);
-            ImGui::TextDisabled("%s", timeBuf);
-            ImGui::TableSetColumnIndex(1);
-            ImGui::TextColored(color, "%s", desc);
-            // Hover tooltip: show rich spell info for entries with a known spell
-            if (e.spellId != 0 && ImGui::IsItemHovered()) {
-                auto* assetMgrLog = services_.assetManager;
-                ImGui::BeginTooltip();
-                bool richOk = spellbookScreen.renderSpellInfoTooltip(e.spellId, gameHandler, assetMgrLog);
-                if (!richOk) {
-                    ImGui::Text("%s", spellName.c_str());
-                }
-                ImGui::EndTooltip();
-            }
-        }
-
-        // Auto-scroll to bottom
-        if (autoScroll && ImGui::GetScrollY() >= ImGui::GetScrollMaxY())
-            ImGui::SetScrollHereY(1.0f);
-
-        ImGui::EndTable();
-    }
-
-    ImGui::End();
-}
-
-
-// ─── Threat Window ────────────────────────────────────────────────────────────
-void CombatUI::renderThreatWindow(game::GameHandler& gameHandler) {
-    if (!showThreatWindow_) return;
-
-    const auto* list = gameHandler.getTargetThreatList();
-
-    ImGui::SetNextWindowSize(ImVec2(280, 220), ImGuiCond_FirstUseEver);
-    ImGui::SetNextWindowPos(ImVec2(10, 300), ImGuiCond_FirstUseEver);
-    ImGui::SetNextWindowBgAlpha(0.85f);
-
-    if (!ImGui::Begin("Threat###ThreatWin", &showThreatWindow_,
-                      ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize)) {
-        ImGui::End();
-        return;
-    }
-
-    if (!list || list->empty()) {
-        ImGui::TextDisabled("No threat data for current target.");
-        ImGui::End();
-        return;
-    }
-
-    uint32_t maxThreat = list->front().threat;
-
-    // Pre-scan to find the player's rank and threat percentage
-    uint64_t playerGuid = gameHandler.getPlayerGuid();
-    int playerRank = 0;
-    float playerPct = 0.0f;
-    {
-        int scan = 0;
-        for (const auto& e : *list) {
-            ++scan;
-            if (e.victimGuid == playerGuid) {
-                playerRank = scan;
-                playerPct  = (maxThreat > 0) ? static_cast<float>(e.threat) / static_cast<float>(maxThreat) : 0.0f;
-                break;
-            }
-            if (scan >= 10) break;
-        }
-    }
-
-    // Status bar: aggro alert or rank summary
-    if (playerRank == 1) {
-        // Player has aggro — persistent red warning
-        ImGui::TextColored(ImVec4(1.0f, 0.25f, 0.25f, 1.0f), "!! YOU HAVE AGGRO !!");
-    } else if (playerRank > 1 && playerPct >= 0.8f) {
-        // Close to pulling — pulsing warning
-        float pulse = 0.55f + 0.45f * sinf(static_cast<float>(ImGui::GetTime()) * 5.0f);
-        ImGui::TextColored(ImVec4(1.0f, 0.55f, 0.1f, pulse), "! PULLING AGGRO (%.0f%%) !", playerPct * 100.0f);
-    } else if (playerRank > 0) {
-        ImGui::TextColored(ImVec4(0.6f, 0.8f, 0.6f, 1.0f), "You: #%d  %.0f%% threat", playerRank, playerPct * 100.0f);
-    }
-
-    ImGui::TextDisabled("%-19s  Threat", "Player");
-    ImGui::Separator();
-
-    int rank = 0;
-    for (const auto& entry : *list) {
-        ++rank;
-        bool isPlayer = (entry.victimGuid == playerGuid);
-
-        // Resolve name
-        std::string victimName;
-        auto entity = gameHandler.getEntityManager().getEntity(entry.victimGuid);
-        if (entity) {
-            if (entity->getType() == game::ObjectType::PLAYER) {
-                auto p = std::static_pointer_cast<game::Player>(entity);
-                victimName = p->getName().empty() ? "Player" : p->getName();
-            } else if (entity->getType() == game::ObjectType::UNIT) {
-                auto u = std::static_pointer_cast<game::Unit>(entity);
-                victimName = u->getName().empty() ? "NPC" : u->getName();
-            }
-        }
-        if (victimName.empty())
-            victimName = "0x" + [&](){
-                char buf[20]; snprintf(buf, sizeof(buf), "%llX",
-                    static_cast<unsigned long long>(entry.victimGuid)); return std::string(buf); }();
-
-        // Colour: gold for #1 (tank), red if player is highest, white otherwise
-        ImVec4 col = ui::colors::kWhite;
-        if (rank == 1) col = ui::colors::kTooltipGold;      // gold
-        if (isPlayer && rank == 1) col = kColorRed; // red — you have aggro
-
-        // Threat bar
-        float pct = (maxThreat > 0) ? static_cast<float>(entry.threat) / static_cast<float>(maxThreat) : 0.0f;
-        ImGui::PushStyleColor(ImGuiCol_PlotHistogram,
-            isPlayer ? ImVec4(0.8f, 0.2f, 0.2f, 0.7f) : ImVec4(0.2f, 0.5f, 0.8f, 0.5f));
-        char barLabel[48];
-        snprintf(barLabel, sizeof(barLabel), "%.0f%%", pct * 100.0f);
-        ImGui::ProgressBar(pct, ImVec2(60, 14), barLabel);
-        ImGui::PopStyleColor();
-        ImGui::SameLine();
-
-        ImGui::TextColored(col, "%-18s  %u", victimName.c_str(), entry.threat);
-
-        if (rank >= 10) break; // cap display at 10 entries
-    }
-
-    ImGui::End();
-}
-
-
-// ─── BG Scoreboard ────────────────────────────────────────────────────────────
-void CombatUI::renderBgScoreboard(game::GameHandler& gameHandler) {
-    if (!showBgScoreboard_) return;
-
-    const game::GameHandler::BgScoreboardData* data = gameHandler.getBgScoreboard();
-
-    ImGui::SetNextWindowSize(ImVec2(600, 400), ImGuiCond_FirstUseEver);
-    ImGui::SetNextWindowPos(ImVec2(150, 100), ImGuiCond_FirstUseEver);
-
-    const char* title = data && data->isArena ? "Arena Score###BgScore"
-                                              : "Battleground Score###BgScore";
-    if (!ImGui::Begin(title, &showBgScoreboard_, ImGuiWindowFlags_NoCollapse)) {
-        ImGui::End();
-        return;
-    }
-
-    if (!data) {
-        ImGui::TextDisabled("No score data yet.");
-        ImGui::TextDisabled("Use /score to request the scoreboard while in a battleground or arena.");
-        ImGui::End();
-        return;
-    }
-
-    // Arena team rating banner (shown only for arenas)
-    if (data->isArena) {
-        for (int t = 0; t < 2; ++t) {
-            const auto& at = data->arenaTeams[t];
-            if (at.teamName.empty()) continue;
-            int32_t ratingDelta = static_cast<int32_t>(at.ratingChange);
-            ImVec4 teamCol = (t == 0) ? colors::kHostileRed   // team 0: red
-                                      : colors::kLightBlue;    // team 1: blue
-            ImGui::TextColored(teamCol, "%s", at.teamName.c_str());
-            ImGui::SameLine();
-            char ratingBuf[32];
-            if (ratingDelta >= 0)
-                std::snprintf(ratingBuf, sizeof(ratingBuf), "Rating: %u (+%d)", at.newRating, ratingDelta);
-            else
-                std::snprintf(ratingBuf, sizeof(ratingBuf), "Rating: %u (%d)", at.newRating, ratingDelta);
-            ImGui::TextDisabled("%s", ratingBuf);
-        }
-        ImGui::Separator();
-    }
-
-    // Winner banner
-    if (data->hasWinner) {
-        const char* winnerStr;
-        ImVec4 winnerColor;
-        if (data->isArena) {
-            // For arenas, winner byte 0/1 refers to team index in arenaTeams[]
-            const auto& winTeam = data->arenaTeams[data->winner & 1];
-            winnerStr  = winTeam.teamName.empty() ? "Team 1" : winTeam.teamName.c_str();
-            winnerColor = (data->winner == 0) ? colors::kHostileRed
-                                              : colors::kLightBlue;
-        } else {
-            winnerStr  = (data->winner == 1) ? "Alliance" : "Horde";
-            winnerColor = (data->winner == 1) ? colors::kLightBlue
-                                              : colors::kHostileRed;
-        }
-        float textW = ImGui::CalcTextSize(winnerStr).x + ImGui::CalcTextSize("  Victory!").x;
-        ImGui::SetCursorPosX((ImGui::GetContentRegionAvail().x - textW) * 0.5f);
-        ImGui::TextColored(winnerColor, "%s", winnerStr);
-        ImGui::SameLine(0, 4);
-        ImGui::TextColored(colors::kBrightGold, "Victory!");
-        ImGui::Separator();
-    }
-
-    // Refresh button
-    if (ImGui::SmallButton("Refresh")) {
-        gameHandler.requestPvpLog();
-    }
-    ImGui::SameLine();
-    ImGui::TextDisabled("%zu players", data->players.size());
-
-    // Score table
-    constexpr ImGuiTableFlags kTableFlags =
-        ImGuiTableFlags_ScrollY | ImGuiTableFlags_RowBg |
-        ImGuiTableFlags_BordersOuter | ImGuiTableFlags_BordersV |
-        ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_Sortable;
-
-    // Build dynamic column count based on what BG-specific stats are present
-    int numBgCols = 0;
-    std::vector<std::string> bgColNames;
-    for (const auto& ps : data->players) {
-        for (const auto& [fieldName, val] : ps.bgStats) {
-            // Extract short name after last '.' (e.g. "BattlegroundAB.AbFlagCaptures" → "Caps")
-            std::string shortName = fieldName;
-            auto dotPos = fieldName.rfind('.');
-            if (dotPos != std::string::npos) shortName = fieldName.substr(dotPos + 1);
-            bool found = false;
-            for (const auto& n : bgColNames) { if (n == shortName) { found = true; break; } }
-            if (!found) bgColNames.push_back(shortName);
-        }
-    }
-    numBgCols = static_cast<int>(bgColNames.size());
-
-    // Fixed cols: Team | Name | KB | Deaths | HKs | Honor; then BG-specific
-    int totalCols = 6 + numBgCols;
-    float tableH = ImGui::GetContentRegionAvail().y;
-    if (ImGui::BeginTable("##BgScoreTable", totalCols, kTableFlags, ImVec2(0.0f, tableH))) {
-        ImGui::TableSetupScrollFreeze(0, 1);
-        ImGui::TableSetupColumn("Team",   ImGuiTableColumnFlags_WidthFixed,   56.0f);
-        ImGui::TableSetupColumn("Name",   ImGuiTableColumnFlags_WidthStretch);
-        ImGui::TableSetupColumn("KB",     ImGuiTableColumnFlags_WidthFixed,   38.0f);
-        ImGui::TableSetupColumn("Deaths", ImGuiTableColumnFlags_WidthFixed,   52.0f);
-        ImGui::TableSetupColumn("HKs",    ImGuiTableColumnFlags_WidthFixed,   38.0f);
-        ImGui::TableSetupColumn("Honor",  ImGuiTableColumnFlags_WidthFixed,   52.0f);
-        for (const auto& col : bgColNames)
-            ImGui::TableSetupColumn(col.c_str(), ImGuiTableColumnFlags_WidthFixed, 52.0f);
-        ImGui::TableHeadersRow();
-
-        // Sort: Alliance first, then Horde; within each team by KB desc
-        std::vector<const game::GameHandler::BgPlayerScore*> sorted;
-        sorted.reserve(data->players.size());
-        for (const auto& ps : data->players) sorted.push_back(&ps);
-        std::stable_sort(sorted.begin(), sorted.end(),
-            [](const game::GameHandler::BgPlayerScore* a,
-               const game::GameHandler::BgPlayerScore* b) {
-                if (a->team != b->team) return a->team > b->team;  // Alliance(1) first
-                return a->killingBlows > b->killingBlows;
-            });
-
-        uint64_t playerGuid = gameHandler.getPlayerGuid();
-        for (const auto* ps : sorted) {
-            ImGui::TableNextRow();
-
-            // Team
-            ImGui::TableNextColumn();
-            if (ps->team == 1)
-                ImGui::TextColored(colors::kLightBlue, "Alliance");
-            else
-                ImGui::TextColored(colors::kHostileRed, "Horde");
-
-            // Name (highlight player's own row)
-            ImGui::TableNextColumn();
-            bool isSelf = (ps->guid == playerGuid);
-            if (isSelf) ImGui::PushStyleColor(ImGuiCol_Text, colors::kBrightGold);
-            const char* nameStr = ps->name.empty() ? "Unknown" : ps->name.c_str();
-            ImGui::TextUnformatted(nameStr);
-            if (isSelf) ImGui::PopStyleColor();
-
-            ImGui::TableNextColumn(); ImGui::Text("%u", ps->killingBlows);
-            ImGui::TableNextColumn(); ImGui::Text("%u", ps->deaths);
-            ImGui::TableNextColumn(); ImGui::Text("%u", ps->honorableKills);
-            ImGui::TableNextColumn(); ImGui::Text("%u", ps->bonusHonor);
-
-            for (const auto& col : bgColNames) {
-                ImGui::TableNextColumn();
-                uint32_t val = 0;
-                for (const auto& [fieldName, fval] : ps->bgStats) {
-                    std::string shortName = fieldName;
-                    auto dotPos = fieldName.rfind('.');
-                    if (dotPos != std::string::npos) shortName = fieldName.substr(dotPos + 1);
-                    if (shortName == col) { val = fval; break; }
-                }
-                if (val > 0) ImGui::Text("%u", val);
-                else ImGui::TextDisabled("-");
-            }
-        }
-        ImGui::EndTable();
-    }
-
-    ImGui::End();
-}
-
-
-} // namespace ui
-} // namespace wowee
diff --git a/src/ui/dialog_manager.cpp b/src/ui/dialog_manager.cpp
deleted file mode 100644
index 26ba6c21..00000000
--- a/src/ui/dialog_manager.cpp
+++ /dev/null
@@ -1,1115 +0,0 @@
-#include "ui/dialog_manager.hpp"
-#include "ui/inventory_screen.hpp"
-#include "ui/chat_panel.hpp"
-#include "ui/ui_colors.hpp"
-#include "game/game_handler.hpp"
-#include "core/application.hpp"
-
-#include <imgui.h>
-#include <algorithm>
-#include <cstdio>
-#include <cmath>
-#include <chrono>
-
-namespace wowee { namespace ui {
-
-namespace {
-    using namespace wowee::ui::colors;
-    constexpr auto& kColorDarkGray = kDarkGray;
-    constexpr auto& kColorGreen    = kGreen;
-} // namespace
-
-// Build a WoW-format item link string for chat insertion.
-// Format: |cff<qualHex>|Hitem:<itemId>:0:0:0:0:0:0:0:0|h[<name>]|h|r
-static std::string buildItemChatLink(uint32_t itemId, uint8_t quality, const std::string& name) {
-    static constexpr const char* kQualHex[] = {"9d9d9d","ffffff","1eff00","0070dd","a335ee","ff8000","e6cc80","e6cc80"};
-    uint8_t qi = quality < 8 ? quality : 1;
-    char buf[512];
-    snprintf(buf, sizeof(buf), "|cff%s|Hitem:%u:0:0:0:0:0:0:0:0|h[%s]|h|r",
-             kQualHex[qi], itemId, name.c_str());
-    return buf;
-}
-
-// ---------------------------------------------------------------------------
-// Render early dialogs (group invite through LFG role check)
-// ---------------------------------------------------------------------------
-void DialogManager::renderDialogs(game::GameHandler& gameHandler,
-                                  InventoryScreen& inventoryScreen,
-                                  ChatPanel& chatPanel) {
-    renderGroupInvitePopup(gameHandler);
-    renderDuelRequestPopup(gameHandler);
-    renderDuelCountdown(gameHandler);
-    renderLootRollPopup(gameHandler, inventoryScreen, chatPanel);
-    renderTradeRequestPopup(gameHandler);
-    renderTradeWindow(gameHandler, inventoryScreen, chatPanel);
-    renderSummonRequestPopup(gameHandler);
-    renderSharedQuestPopup(gameHandler);
-    renderItemTextWindow(gameHandler);
-    renderGuildInvitePopup(gameHandler);
-    renderReadyCheckPopup(gameHandler);
-    renderBgInvitePopup(gameHandler);
-    renderBfMgrInvitePopup(gameHandler);
-    renderLfgProposalPopup(gameHandler);
-    renderLfgRoleCheckPopup(gameHandler);
-}
-
-// ---------------------------------------------------------------------------
-// Render late dialogs (resurrect, talent wipe, pet unlearn)
-// ---------------------------------------------------------------------------
-void DialogManager::renderLateDialogs(game::GameHandler& gameHandler) {
-    renderResurrectDialog(gameHandler);
-    renderTalentWipeConfirmDialog(gameHandler);
-    renderPetUnlearnConfirmDialog(gameHandler);
-}
-
-// ============================================================
-// Group Invite Popup
-// ============================================================
-
-void DialogManager::renderGroupInvitePopup(game::GameHandler& gameHandler) {
-    if (!gameHandler.hasPendingGroupInvite()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 150, 200), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(300, 0), ImGuiCond_Always);
-
-    if (ImGui::Begin("Group Invite", nullptr, kDialogFlags)) {
-        ImGui::Text("%s has invited you to a group.", gameHandler.getPendingInviterName().c_str());
-        ImGui::Spacing();
-
-        if (ImGui::Button("Accept", ImVec2(130, 30))) {
-            gameHandler.acceptGroupInvite();
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Decline", ImVec2(130, 30))) {
-            gameHandler.declineGroupInvite();
-        }
-    }
-    ImGui::End();
-}
-
-void DialogManager::renderDuelRequestPopup(game::GameHandler& gameHandler) {
-    if (!gameHandler.hasPendingDuelRequest()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 150, 250), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(300, 0), ImGuiCond_Always);
-
-    if (ImGui::Begin("Duel Request", nullptr, kDialogFlags)) {
-        ImGui::Text("%s challenges you to a duel!", gameHandler.getDuelChallengerName().c_str());
-        ImGui::Spacing();
-
-        if (ImGui::Button("Accept", ImVec2(130, 30))) {
-            gameHandler.acceptDuel();
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Decline", ImVec2(130, 30))) {
-            gameHandler.forfeitDuel();
-        }
-    }
-    ImGui::End();
-}
-
-void DialogManager::renderDuelCountdown(game::GameHandler& gameHandler) {
-    float remaining = gameHandler.getDuelCountdownRemaining();
-    if (remaining <= 0.0f) return;
-
-    ImVec2 displaySize = ImGui::GetIO().DisplaySize;
-    float screenW = displaySize.x > 0.0f ? displaySize.x : 1280.0f;
-    float screenH = displaySize.y > 0.0f ? displaySize.y : 720.0f;
-
-    auto* dl = ImGui::GetForegroundDrawList();
-    ImFont* font = ImGui::GetFont();
-    float fontSize = ImGui::GetFontSize();
-
-    // Show integer countdown or "Fight!" when under 0.5s
-    char buf[32];
-    if (remaining > 0.5f) {
-        snprintf(buf, sizeof(buf), "%d", static_cast<int>(std::ceil(remaining)));
-    } else {
-        snprintf(buf, sizeof(buf), "Fight!");
-    }
-
-    // Large font by scaling — use 4x font size for dramatic effect
-    float scale = 4.0f;
-    float scaledSize = fontSize * scale;
-    ImVec2 textSz = font->CalcTextSizeA(scaledSize, FLT_MAX, 0.0f, buf);
-    float tx = (screenW - textSz.x) * 0.5f;
-    float ty = screenH * 0.35f - textSz.y * 0.5f;
-
-    // Pulsing alpha: fades in and out per second
-    float pulse = 0.75f + 0.25f * std::sin(static_cast<float>(ImGui::GetTime()) * 6.28f);
-    uint8_t alpha = static_cast<uint8_t>(255 * pulse);
-
-    // Color: golden countdown, red "Fight!"
-    ImU32 color = (remaining > 0.5f)
-        ? IM_COL32(255, 200, 50, alpha)
-        : IM_COL32(255, 60, 60, alpha);
-
-    // Drop shadow
-    dl->AddText(font, scaledSize, ImVec2(tx + 2.0f, ty + 2.0f), IM_COL32(0, 0, 0, alpha / 2), buf);
-    dl->AddText(font, scaledSize, ImVec2(tx, ty), color, buf);
-}
-
-void DialogManager::renderItemTextWindow(game::GameHandler& gameHandler) {
-    if (!gameHandler.isItemTextOpen()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) :  720.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW * 0.5f - 200, screenH * 0.15f),
-                            ImGuiCond_FirstUseEver);
-    ImGui::SetNextWindowSize(ImVec2(400, 300), ImGuiCond_FirstUseEver);
-
-    bool open = true;
-    if (!ImGui::Begin("Book", &open, ImGuiWindowFlags_NoCollapse)) {
-        ImGui::End();
-        if (!open) gameHandler.closeItemText();
-        return;
-    }
-    if (!open) {
-        ImGui::End();
-        gameHandler.closeItemText();
-        return;
-    }
-
-    // Parchment-toned background text
-    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.2f, 0.1f, 0.0f, 1.0f));
-    ImGui::TextWrapped("%s", gameHandler.getItemText().c_str());
-    ImGui::PopStyleColor();
-
-    ImGui::Spacing();
-    if (ImGui::Button("Close", ImVec2(80, 0))) {
-        gameHandler.closeItemText();
-    }
-
-    ImGui::End();
-}
-
-void DialogManager::renderSharedQuestPopup(game::GameHandler& gameHandler) {
-    if (!gameHandler.hasPendingSharedQuest()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 175, 490), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(350, 0), ImGuiCond_Always);
-
-    if (ImGui::Begin("Shared Quest", nullptr, kDialogFlags)) {
-        ImGui::Text("%s has shared a quest with you:", gameHandler.getSharedQuestSharerName().c_str());
-        ImGui::TextColored(colors::kBrightGold, "\"%s\"", gameHandler.getSharedQuestTitle().c_str());
-        ImGui::Spacing();
-
-        if (ImGui::Button("Accept", ImVec2(130, 30))) {
-            gameHandler.acceptSharedQuest();
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Decline", ImVec2(130, 30))) {
-            gameHandler.declineSharedQuest();
-        }
-    }
-    ImGui::End();
-}
-
-void DialogManager::renderSummonRequestPopup(game::GameHandler& gameHandler) {
-    if (!gameHandler.hasPendingSummonRequest()) return;
-
-    // Tick the timeout down
-    float dt = ImGui::GetIO().DeltaTime;
-    gameHandler.tickSummonTimeout(dt);
-    if (!gameHandler.hasPendingSummonRequest()) return;  // expired
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 175, 430), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(350, 0), ImGuiCond_Always);
-
-    if (ImGui::Begin("Summon Request", nullptr, kDialogFlags)) {
-        ImGui::Text("%s is summoning you.", gameHandler.getSummonerName().c_str());
-        float t = gameHandler.getSummonTimeoutSec();
-        if (t > 0.0f) {
-            ImGui::Text("Time remaining: %.0fs", t);
-        }
-        ImGui::Spacing();
-
-        if (ImGui::Button("Accept", ImVec2(130, 30))) {
-            gameHandler.acceptSummon();
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Decline", ImVec2(130, 30))) {
-            gameHandler.declineSummon();
-        }
-    }
-    ImGui::End();
-}
-
-void DialogManager::renderTradeRequestPopup(game::GameHandler& gameHandler) {
-    if (!gameHandler.hasPendingTradeRequest()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 150, 370), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(300, 0), ImGuiCond_Always);
-
-    if (ImGui::Begin("Trade Request", nullptr, kDialogFlags)) {
-        ImGui::Text("%s wants to trade with you.", gameHandler.getTradePeerName().c_str());
-        ImGui::Spacing();
-
-        if (ImGui::Button("Accept", ImVec2(130, 30))) {
-            gameHandler.acceptTradeRequest();
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Decline", ImVec2(130, 30))) {
-            gameHandler.declineTradeRequest();
-        }
-    }
-    ImGui::End();
-}
-
-void DialogManager::renderTradeWindow(game::GameHandler& gameHandler,
-                                       InventoryScreen& inventoryScreen,
-                                       ChatPanel& chatPanel) {
-    if (!gameHandler.isTradeOpen()) return;
-
-    const auto& mySlots   = gameHandler.getMyTradeSlots();
-    const auto& peerSlots = gameHandler.getPeerTradeSlots();
-    const uint64_t myGold   = gameHandler.getMyTradeGold();
-    const uint64_t peerGold = gameHandler.getPeerTradeGold();
-    const auto& peerName = gameHandler.getTradePeerName();
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2.0f - 240.0f, screenH / 2.0f - 180.0f), ImGuiCond_Once);
-    ImGui::SetNextWindowSize(ImVec2(480.0f, 360.0f), ImGuiCond_Once);
-
-    bool open = true;
-    if (ImGui::Begin(("Trade with " + peerName).c_str(), &open,
-                     kDialogFlags)) {
-
-        auto formatGold = [](uint64_t copper, char* buf, size_t bufsz) {
-            uint64_t g = copper / 10000;
-            uint64_t s = (copper % 10000) / 100;
-            uint64_t c = copper % 100;
-            if (g > 0) std::snprintf(buf, bufsz, "%llug %llus %lluc",
-                                     (unsigned long long)g, (unsigned long long)s, (unsigned long long)c);
-            else if (s > 0) std::snprintf(buf, bufsz, "%llus %lluc",
-                                          (unsigned long long)s, (unsigned long long)c);
-            else std::snprintf(buf, bufsz, "%lluc", (unsigned long long)c);
-        };
-
-        auto renderSlotColumn = [&](const char* label,
-                                    const std::array<game::GameHandler::TradeSlot,
-                                                     game::GameHandler::TRADE_SLOT_COUNT>& slots,
-                                    uint64_t gold, bool isMine) {
-            ImGui::Text("%s", label);
-            ImGui::Separator();
-
-            for (int i = 0; i < game::GameHandler::TRADE_SLOT_COUNT; ++i) {
-                const auto& slot = slots[i];
-                ImGui::PushID(i * (isMine ? 1 : -1) - (isMine ? 0 : 100));
-
-                if (slot.occupied && slot.itemId != 0) {
-                    const auto* info = gameHandler.getItemInfo(slot.itemId);
-                    std::string name = (info && info->valid && !info->name.empty())
-                        ? info->name
-                        : ("Item " + std::to_string(slot.itemId));
-                    if (slot.stackCount > 1)
-                        name += " x" + std::to_string(slot.stackCount);
-                    ImVec4 qc = (info && info->valid)
-                        ? InventoryScreen::getQualityColor(static_cast<game::ItemQuality>(info->quality))
-                        : ImVec4(1.0f, 0.9f, 0.5f, 1.0f);
-                    if (info && info->valid && info->displayInfoId != 0) {
-                        VkDescriptorSet iconTex = inventoryScreen.getItemIcon(info->displayInfoId);
-                        if (iconTex) {
-                            ImGui::Image((ImTextureID)(uintptr_t)iconTex, ImVec2(16, 16));
-                            ImGui::SameLine();
-                        }
-                    }
-                    ImGui::TextColored(qc, "%d. %s", i + 1, name.c_str());
-                    if (isMine && ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) {
-                        gameHandler.clearTradeItem(static_cast<uint8_t>(i));
-                    }
-                    if (ImGui::IsItemHovered()) {
-                        if (info && info->valid) inventoryScreen.renderItemTooltip(*info);
-                        else if (isMine) ImGui::SetTooltip("Double-click to remove");
-                    }
-                    if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left) &&
-                        ImGui::GetIO().KeyShift && info && info->valid && !info->name.empty()) {
-                        std::string link = buildItemChatLink(info->entry, info->quality, info->name);
-                        chatPanel.insertChatLink(link);
-                    }
-                } else {
-                    ImGui::TextDisabled("  %d. (empty)", i + 1);
-
-                    // Allow dragging inventory items into trade slots via right-click context menu
-                    char addItemId[16]; snprintf(addItemId, sizeof(addItemId), "##additem%d", i);
-                    if (isMine && ImGui::IsItemClicked(ImGuiMouseButton_Right)) {
-                        ImGui::OpenPopup(addItemId);
-                    }
-                }
-
-                if (isMine) {
-                    char addItemId[16]; snprintf(addItemId, sizeof(addItemId), "##additem%d", i);
-                    // Drag-from-inventory: show small popup listing bag items
-                    if (ImGui::BeginPopup(addItemId)) {
-                        ImGui::TextDisabled("Add from inventory:");
-                        const auto& inv = gameHandler.getInventory();
-                        // Backpack slots 0-15 (bag=255)
-                        for (int si = 0; si < game::Inventory::BACKPACK_SLOTS; ++si) {
-                            const auto& slot = inv.getBackpackSlot(si);
-                            if (slot.empty()) continue;
-                            const auto* ii = gameHandler.getItemInfo(slot.item.itemId);
-                            std::string iname = (ii && ii->valid && !ii->name.empty())
-                                ? ii->name
-                                : (!slot.item.name.empty() ? slot.item.name
-                                   : ("Item " + std::to_string(slot.item.itemId)));
-                            if (ImGui::Selectable(iname.c_str())) {
-                                // bag=255 = main backpack
-                                gameHandler.setTradeItem(static_cast<uint8_t>(i), 255u,
-                                                         static_cast<uint8_t>(si));
-                                ImGui::CloseCurrentPopup();
-                            }
-                        }
-                        ImGui::EndPopup();
-                    }
-                }
-                ImGui::PopID();
-            }
-
-            // Gold row
-            char gbuf[48];
-            formatGold(gold, gbuf, sizeof(gbuf));
-            ImGui::Spacing();
-            if (isMine) {
-                ImGui::Text("Gold offered: %s", gbuf);
-                static char goldInput[32] = "0";
-                ImGui::SetNextItemWidth(120.0f);
-                if (ImGui::InputText("##goldset", goldInput, sizeof(goldInput),
-                                     ImGuiInputTextFlags_CharsDecimal | ImGuiInputTextFlags_EnterReturnsTrue)) {
-                    uint64_t copper = std::strtoull(goldInput, nullptr, 10);
-                    gameHandler.setTradeGold(copper);
-                }
-                ImGui::SameLine();
-                ImGui::TextDisabled("(copper, Enter to set)");
-            } else {
-                ImGui::Text("Gold offered: %s", gbuf);
-            }
-        };
-
-        // Two-column layout: my offer | peer offer
-        float colW = ImGui::GetContentRegionAvail().x * 0.5f - 4.0f;
-        ImGui::BeginChild("##myoffer", ImVec2(colW, 240.0f), true);
-        renderSlotColumn("Your offer", mySlots, myGold, true);
-        ImGui::EndChild();
-
-        ImGui::SameLine();
-
-        ImGui::BeginChild("##peroffer", ImVec2(colW, 240.0f), true);
-        renderSlotColumn((peerName + "'s offer").c_str(), peerSlots, peerGold, false);
-        ImGui::EndChild();
-
-        // Buttons
-        ImGui::Spacing();
-        ImGui::Separator();
-        float bw = (ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x) * 0.5f;
-        if (ImGui::Button("Accept Trade", ImVec2(bw, 0))) {
-            gameHandler.acceptTrade();
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Cancel", ImVec2(bw, 0))) {
-            gameHandler.cancelTrade();
-        }
-    }
-    ImGui::End();
-
-    if (!open) {
-        gameHandler.cancelTrade();
-    }
-}
-
-void DialogManager::renderLootRollPopup(game::GameHandler& gameHandler,
-                                         InventoryScreen& inventoryScreen,
-                                         ChatPanel& chatPanel) {
-    if (!gameHandler.hasPendingLootRoll()) return;
-
-    const auto& roll = gameHandler.getPendingLootRoll();
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 175, 310), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(350, 0), ImGuiCond_Always);
-
-    if (ImGui::Begin("Loot Roll", nullptr, kDialogFlags)) {
-        // Quality color for item name
-        uint8_t q = roll.itemQuality;
-        ImVec4 col = ui::getQualityColor(static_cast<game::ItemQuality>(q));
-
-        // Countdown bar
-        {
-            auto now = std::chrono::steady_clock::now();
-            float elapsedMs = static_cast<float>(
-                std::chrono::duration_cast<std::chrono::milliseconds>(now - roll.rollStartedAt).count());
-            float totalMs   = static_cast<float>(roll.rollCountdownMs > 0 ? roll.rollCountdownMs : 60000);
-            float fraction  = 1.0f - std::min(elapsedMs / totalMs, 1.0f);
-            float remainSec = (totalMs - elapsedMs) / 1000.0f;
-            if (remainSec < 0.0f) remainSec = 0.0f;
-
-            // Color: green → yellow → red
-            ImVec4 barColor;
-            if (fraction > 0.5f)
-                barColor = ImVec4(0.2f + (1.0f - fraction) * 1.4f, 0.85f, 0.2f, 1.0f);
-            else if (fraction > 0.2f)
-                barColor = ImVec4(1.0f, fraction * 1.7f, 0.1f, 1.0f);
-            else {
-                float pulse = 0.7f + 0.3f * std::sin(static_cast<float>(ImGui::GetTime()) * 6.0f);
-                barColor = ImVec4(pulse, 0.1f * pulse, 0.1f * pulse, 1.0f);
-            }
-
-            char timeBuf[16];
-            std::snprintf(timeBuf, sizeof(timeBuf), "%.0fs", remainSec);
-            ImGui::PushStyleColor(ImGuiCol_PlotHistogram, barColor);
-            ImGui::ProgressBar(fraction, ImVec2(-1, 12), timeBuf);
-            ImGui::PopStyleColor();
-        }
-
-        ImGui::Text("An item is up for rolls:");
-
-        // Show item icon if available
-        const auto* rollInfo = gameHandler.getItemInfo(roll.itemId);
-        uint32_t rollDisplayId = rollInfo ? rollInfo->displayInfoId : 0;
-        VkDescriptorSet rollIcon = rollDisplayId ? inventoryScreen.getItemIcon(rollDisplayId) : VK_NULL_HANDLE;
-        if (rollIcon) {
-            ImGui::Image((ImTextureID)(uintptr_t)rollIcon, ImVec2(24, 24));
-            ImGui::SameLine();
-        }
-        // Prefer live item info (arrives via SMSG_ITEM_QUERY_SINGLE_RESPONSE after the
-        // roll popup opens); fall back to the name cached at SMSG_LOOT_START_ROLL time.
-        const char* displayName = (rollInfo && rollInfo->valid && !rollInfo->name.empty())
-            ? rollInfo->name.c_str()
-            : roll.itemName.c_str();
-        if (rollInfo && rollInfo->valid)
-            col = ui::getQualityColor(static_cast<game::ItemQuality>(rollInfo->quality));
-        ImGui::TextColored(col, "[%s]", displayName);
-        if (ImGui::IsItemHovered() && rollInfo && rollInfo->valid) {
-            inventoryScreen.renderItemTooltip(*rollInfo);
-        }
-        if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left) &&
-            ImGui::GetIO().KeyShift && rollInfo && rollInfo->valid && !rollInfo->name.empty()) {
-            std::string link = buildItemChatLink(rollInfo->entry, rollInfo->quality, rollInfo->name);
-            chatPanel.insertChatLink(link);
-        }
-        ImGui::Spacing();
-
-        // voteMask bits: 0x01=pass, 0x02=need, 0x04=greed, 0x08=disenchant
-        const uint8_t vm = roll.voteMask;
-        bool first = true;
-        if (vm & 0x02) {
-            if (ImGui::Button("Need", ImVec2(80, 30)))
-                gameHandler.sendLootRoll(roll.objectGuid, roll.slot, 0);
-            first = false;
-        }
-        if (vm & 0x04) {
-            if (!first) ImGui::SameLine();
-            if (ImGui::Button("Greed", ImVec2(80, 30)))
-                gameHandler.sendLootRoll(roll.objectGuid, roll.slot, 1);
-            first = false;
-        }
-        if (vm & 0x08) {
-            if (!first) ImGui::SameLine();
-            if (ImGui::Button("Disenchant", ImVec2(95, 30)))
-                gameHandler.sendLootRoll(roll.objectGuid, roll.slot, 2);
-            first = false;
-        }
-        if (vm & 0x01) {
-            if (!first) ImGui::SameLine();
-            if (ImGui::Button("Pass", ImVec2(70, 30)))
-                gameHandler.sendLootRoll(roll.objectGuid, roll.slot, 96);
-        }
-
-        // Live roll results from group members
-        if (!roll.playerRolls.empty()) {
-            ImGui::Separator();
-            ImGui::TextDisabled("Rolls so far:");
-            // Roll-type label + color
-            static constexpr const char* kRollLabels[] = {"Need", "Greed", "Disenchant", "Pass"};
-            static constexpr ImVec4 kRollColors[] = {
-                ImVec4(0.2f, 0.9f, 0.2f, 1.0f),  // Need  — green
-                ImVec4(0.3f, 0.6f, 1.0f, 1.0f),  // Greed — blue
-                ImVec4(0.7f, 0.3f, 0.9f, 1.0f),  // Disenchant — purple
-                kColorDarkGray,  // Pass  — gray
-            };
-            auto rollTypeIndex = [](uint8_t t) -> int {
-                if (t == 0) return 0;
-                if (t == 1) return 1;
-                if (t == 2) return 2;
-                return 3; // pass (96 or unknown)
-            };
-
-            if (ImGui::BeginTable("##lootrolls", 3,
-                    ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_RowBg)) {
-                ImGui::TableSetupColumn("Player", ImGuiTableColumnFlags_WidthStretch);
-                ImGui::TableSetupColumn("Type",   ImGuiTableColumnFlags_WidthFixed, 72.0f);
-                ImGui::TableSetupColumn("Roll",   ImGuiTableColumnFlags_WidthFixed, 32.0f);
-                for (const auto& r : roll.playerRolls) {
-                    int ri = rollTypeIndex(r.rollType);
-                    ImGui::TableNextRow();
-                    ImGui::TableSetColumnIndex(0);
-                    ImGui::TextUnformatted(r.playerName.c_str());
-                    ImGui::TableSetColumnIndex(1);
-                    ImGui::TextColored(kRollColors[ri], "%s", kRollLabels[ri]);
-                    ImGui::TableSetColumnIndex(2);
-                    if (r.rollType != 96) {
-                        ImGui::TextColored(kRollColors[ri], "%d", static_cast<int>(r.rollNum));
-                    } else {
-                        ImGui::TextDisabled("—");
-                    }
-                }
-                ImGui::EndTable();
-            }
-        }
-    }
-    ImGui::End();
-}
-
-void DialogManager::renderGuildInvitePopup(game::GameHandler& gameHandler) {
-    if (!gameHandler.hasPendingGuildInvite()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 175, 250), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(350, 0), ImGuiCond_Always);
-
-    if (ImGui::Begin("Guild Invite", nullptr, kDialogFlags)) {
-        ImGui::TextWrapped("%s has invited you to join %s.",
-                           gameHandler.getPendingGuildInviterName().c_str(),
-                           gameHandler.getPendingGuildInviteGuildName().c_str());
-        ImGui::Spacing();
-
-        if (ImGui::Button("Accept", ImVec2(155, 30))) {
-            gameHandler.acceptGuildInvite();
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Decline", ImVec2(155, 30))) {
-            gameHandler.declineGuildInvite();
-        }
-    }
-    ImGui::End();
-}
-
-void DialogManager::renderReadyCheckPopup(game::GameHandler& gameHandler) {
-    if (!gameHandler.hasPendingReadyCheck()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 175, screenH / 2 - 60), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(350, 0), ImGuiCond_Always);
-
-    if (ImGui::Begin("Ready Check", nullptr, kDialogFlags)) {
-        const std::string& initiator = gameHandler.getReadyCheckInitiator();
-        if (initiator.empty()) {
-            ImGui::Text("A ready check has been initiated!");
-        } else {
-            ImGui::TextWrapped("%s has initiated a ready check!", initiator.c_str());
-        }
-        ImGui::Spacing();
-
-        if (ImGui::Button("Ready", ImVec2(155, 30))) {
-            gameHandler.respondToReadyCheck(true);
-            gameHandler.dismissReadyCheck();
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Not Ready", ImVec2(155, 30))) {
-            gameHandler.respondToReadyCheck(false);
-            gameHandler.dismissReadyCheck();
-        }
-
-        // Live player responses
-        const auto& results = gameHandler.getReadyCheckResults();
-        if (!results.empty()) {
-            ImGui::Separator();
-            if (ImGui::BeginTable("##rcresults", 2,
-                    ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_RowBg)) {
-                ImGui::TableSetupColumn("Player", ImGuiTableColumnFlags_WidthStretch);
-                ImGui::TableSetupColumn("Status", ImGuiTableColumnFlags_WidthFixed, 72.0f);
-                for (const auto& r : results) {
-                    ImGui::TableNextRow();
-                    ImGui::TableSetColumnIndex(0);
-                    ImGui::TextUnformatted(r.name.c_str());
-                    ImGui::TableSetColumnIndex(1);
-                    if (r.ready) {
-                        ImGui::TextColored(ImVec4(0.2f, 0.9f, 0.2f, 1.0f), "Ready");
-                    } else {
-                        ImGui::TextColored(ImVec4(0.9f, 0.3f, 0.3f, 1.0f), "Not Ready");
-                    }
-                }
-                ImGui::EndTable();
-            }
-        }
-    }
-    ImGui::End();
-}
-
-void DialogManager::renderBgInvitePopup(game::GameHandler& gameHandler) {
-    if (!gameHandler.hasPendingBgInvite()) return;
-
-    const auto& queues = gameHandler.getBgQueues();
-    // Find the first WAIT_JOIN slot
-    const game::GameHandler::BgQueueSlot* slot = nullptr;
-    for (const auto& s : queues) {
-        if (s.statusId == 2) { slot = &s; break; }
-    }
-    if (!slot) return;
-
-    // Compute time remaining
-    auto now = std::chrono::steady_clock::now();
-    double elapsed = std::chrono::duration<double>(now - slot->inviteReceivedTime).count();
-    double remaining = static_cast<double>(slot->inviteTimeout) - elapsed;
-
-    // If invite has expired, clear it silently (server will handle the queue)
-    if (remaining <= 0.0) {
-        gameHandler.declineBattlefield(slot->queueSlot);
-        return;
-    }
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 190, screenH / 2 - 70), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(380, 0), ImGuiCond_Always);
-
-    ImGui::PushStyleColor(ImGuiCol_WindowBg,   ImVec4(0.08f, 0.08f, 0.18f, 0.95f));
-    ImGui::PushStyleColor(ImGuiCol_Border,     ImVec4(0.4f, 0.4f, 1.0f, 1.0f));
-    ImGui::PushStyleColor(ImGuiCol_TitleBgActive, ImVec4(0.15f, 0.15f, 0.4f, 1.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 6.0f);
-
-    const ImGuiWindowFlags popupFlags =
-        ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse;
-
-    if (ImGui::Begin("Battleground Ready!", nullptr, popupFlags)) {
-        // BG name from stored queue data
-        std::string bgName = slot->bgName.empty() ? "Battleground" : slot->bgName;
-        ImGui::TextColored(ImVec4(1.0f, 0.85f, 0.2f, 1.0f), "%s", bgName.c_str());
-        ImGui::TextWrapped("A spot has opened! You have %d seconds to enter.", static_cast<int>(remaining));
-        ImGui::Spacing();
-
-        // Countdown progress bar
-        float frac = static_cast<float>(remaining / static_cast<double>(slot->inviteTimeout));
-        frac = std::clamp(frac, 0.0f, 1.0f);
-        ImVec4 barColor = frac > 0.5f ? colors::kHealthGreen
-                        : frac > 0.25f ? ImVec4(0.9f, 0.7f, 0.1f, 1.0f)
-                                       : colors::kDarkRed;
-        ImGui::PushStyleColor(ImGuiCol_PlotHistogram, barColor);
-        char countdownLabel[32];
-        snprintf(countdownLabel, sizeof(countdownLabel), "%ds", static_cast<int>(remaining));
-        ImGui::ProgressBar(frac, ImVec2(-1, 16), countdownLabel);
-        ImGui::PopStyleColor();
-        ImGui::Spacing();
-
-        ImGui::PushStyleColor(ImGuiCol_Button,        colors::kBtnGreen);
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colors::kFriendlyGreen);
-        if (ImGui::Button("Enter Battleground", ImVec2(180, 30))) {
-            gameHandler.acceptBattlefield(slot->queueSlot);
-        }
-        ImGui::PopStyleColor(2);
-
-        ImGui::SameLine();
-
-        ImGui::PushStyleColor(ImGuiCol_Button,        colors::kBtnRed);
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colors::kDangerRed);
-        if (ImGui::Button("Leave Queue", ImVec2(175, 30))) {
-            gameHandler.declineBattlefield(slot->queueSlot);
-        }
-        ImGui::PopStyleColor(2);
-    }
-    ImGui::End();
-
-    ImGui::PopStyleVar();
-    ImGui::PopStyleColor(3);
-}
-
-void DialogManager::renderBfMgrInvitePopup(game::GameHandler& gameHandler) {
-    // Only shown on WotLK servers (outdoor battlefields like Wintergrasp use the BF Manager)
-    if (!gameHandler.hasBfMgrInvite()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2.0f - 190.0f, screenH / 2.0f - 55.0f), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(380.0f, 0.0f), ImGuiCond_Always);
-
-    ImGui::PushStyleColor(ImGuiCol_WindowBg,      ImVec4(0.08f, 0.10f, 0.20f, 0.96f));
-    ImGui::PushStyleColor(ImGuiCol_Border,        ImVec4(0.5f, 0.5f, 1.0f, 1.0f));
-    ImGui::PushStyleColor(ImGuiCol_TitleBgActive, ImVec4(0.15f, 0.15f, 0.45f, 1.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 6.0f);
-
-    const ImGuiWindowFlags flags =
-        ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse;
-
-    if (ImGui::Begin("Battlefield", nullptr, flags)) {
-        // Resolve zone name for Wintergrasp (zoneId 4197)
-        uint32_t zoneId = gameHandler.getBfMgrZoneId();
-        const char* zoneName = nullptr;
-        if (zoneId == 4197) zoneName = "Wintergrasp";
-        else if (zoneId == 5095) zoneName = "Tol Barad";
-
-        if (zoneName) {
-            ImGui::TextColored(ImVec4(1.0f, 0.85f, 0.2f, 1.0f), "%s", zoneName);
-        } else {
-            ImGui::TextColored(ImVec4(1.0f, 0.85f, 0.2f, 1.0f), "Outdoor Battlefield");
-        }
-        ImGui::Spacing();
-        ImGui::TextWrapped("You are invited to join the outdoor battlefield. Do you want to enter?");
-        ImGui::Spacing();
-
-        ImGui::PushStyleColor(ImGuiCol_Button,        colors::kBtnGreen);
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colors::kFriendlyGreen);
-        if (ImGui::Button("Enter Battlefield", ImVec2(178, 28))) {
-            gameHandler.acceptBfMgrInvite();
-        }
-        ImGui::PopStyleColor(2);
-
-        ImGui::SameLine();
-
-        ImGui::PushStyleColor(ImGuiCol_Button,        colors::kBtnRed);
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colors::kDangerRed);
-        if (ImGui::Button("Decline", ImVec2(175, 28))) {
-            gameHandler.declineBfMgrInvite();
-        }
-        ImGui::PopStyleColor(2);
-    }
-    ImGui::End();
-
-    ImGui::PopStyleVar();
-    ImGui::PopStyleColor(3);
-}
-
-void DialogManager::renderLfgProposalPopup(game::GameHandler& gameHandler) {
-    using LfgState = game::GameHandler::LfgState;
-    if (gameHandler.getLfgState() != LfgState::Proposal) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2.0f - 175.0f, screenH / 2.0f - 65.0f), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(350.0f, 0.0f), ImGuiCond_Always);
-
-    ImGui::PushStyleColor(ImGuiCol_WindowBg,      ImVec4(0.08f, 0.14f, 0.08f, 0.96f));
-    ImGui::PushStyleColor(ImGuiCol_Border,        ImVec4(0.3f, 0.8f, 0.3f, 1.0f));
-    ImGui::PushStyleColor(ImGuiCol_TitleBgActive, ImVec4(0.1f, 0.3f, 0.1f, 1.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 6.0f);
-
-    const ImGuiWindowFlags flags =
-        ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse;
-
-    if (ImGui::Begin("Dungeon Finder", nullptr, flags)) {
-        ImGui::TextColored(kColorGreen, "A group has been found!");
-        ImGui::Spacing();
-        ImGui::TextWrapped("Please accept or decline to join the dungeon.");
-        ImGui::Spacing();
-        ImGui::Separator();
-        ImGui::Spacing();
-
-        ImGui::PushStyleColor(ImGuiCol_Button,        colors::kBtnGreen);
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colors::kFriendlyGreen);
-        if (ImGui::Button("Accept", ImVec2(155.0f, 30.0f))) {
-            gameHandler.lfgAcceptProposal(gameHandler.getLfgProposalId(), true);
-        }
-        ImGui::PopStyleColor(2);
-
-        ImGui::SameLine();
-
-        ImGui::PushStyleColor(ImGuiCol_Button,        colors::kBtnRed);
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colors::kDangerRed);
-        if (ImGui::Button("Decline", ImVec2(155.0f, 30.0f))) {
-            gameHandler.lfgAcceptProposal(gameHandler.getLfgProposalId(), false);
-        }
-        ImGui::PopStyleColor(2);
-    }
-    ImGui::End();
-
-    ImGui::PopStyleVar();
-    ImGui::PopStyleColor(3);
-}
-
-void DialogManager::renderLfgRoleCheckPopup(game::GameHandler& gameHandler) {
-    using LfgState = game::GameHandler::LfgState;
-    if (gameHandler.getLfgState() != LfgState::RoleCheck) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2.0f - 160.0f, screenH / 2.0f - 80.0f), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(320.0f, 0.0f), ImGuiCond_Always);
-
-    ImGui::PushStyleColor(ImGuiCol_WindowBg,      ImVec4(0.08f, 0.08f, 0.18f, 0.96f));
-    ImGui::PushStyleColor(ImGuiCol_Border,        ImVec4(0.3f, 0.5f, 0.9f, 1.0f));
-    ImGui::PushStyleColor(ImGuiCol_TitleBgActive, ImVec4(0.1f, 0.1f, 0.3f, 1.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 6.0f);
-
-    const ImGuiWindowFlags flags =
-        ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse;
-
-    if (ImGui::Begin("Role Check##LfgRoleCheck", nullptr, flags)) {
-        ImGui::TextColored(ImVec4(0.4f, 0.7f, 1.0f, 1.0f), "Confirm your role:");
-        ImGui::Spacing();
-
-        // Role checkboxes
-        bool isTank   = (lfgRoles_ & 0x02) != 0;
-        bool isHealer = (lfgRoles_ & 0x04) != 0;
-        bool isDps    = (lfgRoles_ & 0x08) != 0;
-
-        if (ImGui::Checkbox("Tank",   &isTank))   lfgRoles_ = (lfgRoles_ & ~0x02) | (isTank   ? 0x02 : 0);
-        ImGui::SameLine(120.0f);
-        if (ImGui::Checkbox("Healer", &isHealer)) lfgRoles_ = (lfgRoles_ & ~0x04) | (isHealer ? 0x04 : 0);
-        ImGui::SameLine(220.0f);
-        if (ImGui::Checkbox("DPS",    &isDps))    lfgRoles_ = (lfgRoles_ & ~0x08) | (isDps    ? 0x08 : 0);
-
-        ImGui::Spacing();
-        ImGui::Separator();
-        ImGui::Spacing();
-
-        bool hasRole = (lfgRoles_ & 0x0E) != 0;
-        if (!hasRole) ImGui::BeginDisabled();
-
-        ImGui::PushStyleColor(ImGuiCol_Button,        ImVec4(0.15f, 0.4f, 0.15f, 1.0f));
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.2f, 0.6f, 0.2f, 1.0f));
-        if (ImGui::Button("Accept", ImVec2(140.0f, 28.0f))) {
-            gameHandler.lfgSetRoles(lfgRoles_);
-        }
-        ImGui::PopStyleColor(2);
-
-        if (!hasRole) ImGui::EndDisabled();
-
-        ImGui::SameLine();
-
-        ImGui::PushStyleColor(ImGuiCol_Button,        ImVec4(0.4f, 0.15f, 0.15f, 1.0f));
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.6f, 0.2f, 0.2f, 1.0f));
-        if (ImGui::Button("Leave Queue", ImVec2(140.0f, 28.0f))) {
-            gameHandler.lfgLeave();
-        }
-        ImGui::PopStyleColor(2);
-    }
-    ImGui::End();
-
-    ImGui::PopStyleVar();
-    ImGui::PopStyleColor(3);
-}
-
-void DialogManager::renderResurrectDialog(game::GameHandler& gameHandler) {
-    if (!gameHandler.showResurrectDialog()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    float dlgW = 300.0f;
-    float dlgH = 110.0f;
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - dlgW / 2, screenH * 0.3f), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(dlgW, dlgH), ImGuiCond_Always);
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.0f);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.1f, 0.1f, 0.15f, 0.95f));
-    ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.4f, 0.4f, 0.8f, 1.0f));
-
-    if (ImGui::Begin("##ResurrectDialog", nullptr,
-            ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-            ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar)) {
-
-        ImGui::Spacing();
-        const std::string& casterName = gameHandler.getResurrectCasterName();
-        std::string text = casterName.empty()
-            ? "Return to life?"
-            : casterName + " wishes to resurrect you.";
-        float textW = ImGui::CalcTextSize(text.c_str()).x;
-        ImGui::SetCursorPosX(std::max(4.0f, (dlgW - textW) / 2));
-        ImGui::TextColored(ImVec4(0.8f, 0.9f, 1.0f, 1.0f), "%s", text.c_str());
-
-        ImGui::Spacing();
-        ImGui::Spacing();
-
-        float btnW = 100.0f;
-        float spacing = 20.0f;
-        ImGui::SetCursorPosX((dlgW - btnW * 2 - spacing) / 2);
-
-        ImGui::PushStyleColor(ImGuiCol_Button, colors::kBtnDkGreen);
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colors::kBtnDkGreenHover);
-        if (ImGui::Button("Accept", ImVec2(btnW, 30))) {
-            gameHandler.acceptResurrect();
-        }
-        ImGui::PopStyleColor(2);
-
-        ImGui::SameLine(0, spacing);
-
-        ImGui::PushStyleColor(ImGuiCol_Button, colors::kBtnDkRed);
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colors::kBtnDkRedHover);
-        if (ImGui::Button("Decline", ImVec2(btnW, 30))) {
-            gameHandler.declineResurrect();
-        }
-        ImGui::PopStyleColor(2);
-    }
-    ImGui::End();
-    ImGui::PopStyleColor(2);
-    ImGui::PopStyleVar();
-}
-
-// ============================================================
-// Talent Wipe Confirm Dialog
-// ============================================================
-
-void DialogManager::renderTalentWipeConfirmDialog(game::GameHandler& gameHandler) {
-    if (!gameHandler.showTalentWipeConfirmDialog()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    float dlgW = 340.0f;
-    float dlgH = 130.0f;
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - dlgW / 2, screenH * 0.3f), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(dlgW, dlgH), ImGuiCond_Always);
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.0f);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.1f, 0.1f, 0.15f, 0.95f));
-    ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.8f, 0.7f, 0.2f, 1.0f));
-
-    if (ImGui::Begin("##TalentWipeDialog", nullptr,
-            ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-            ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar)) {
-
-        ImGui::Spacing();
-        uint32_t cost = gameHandler.getTalentWipeCost();
-        uint32_t gold = cost / 10000;
-        uint32_t silver = (cost % 10000) / 100;
-        uint32_t copper = cost % 100;
-        char costStr[64];
-        if (gold > 0)
-            std::snprintf(costStr, sizeof(costStr), "%ug %us %uc", gold, silver, copper);
-        else if (silver > 0)
-            std::snprintf(costStr, sizeof(costStr), "%us %uc", silver, copper);
-        else
-            std::snprintf(costStr, sizeof(costStr), "%uc", copper);
-
-        std::string text = "Reset your talents for ";
-        text += costStr;
-        text += "?";
-        float textW = ImGui::CalcTextSize(text.c_str()).x;
-        ImGui::SetCursorPosX(std::max(4.0f, (dlgW - textW) / 2));
-        ImGui::TextColored(ImVec4(1.0f, 0.9f, 0.4f, 1.0f), "%s", text.c_str());
-
-        ImGui::Spacing();
-        ImGui::SetCursorPosX(8.0f);
-        ImGui::TextDisabled("All talent points will be refunded.");
-        ImGui::Spacing();
-
-        float btnW = 110.0f;
-        float spacing = 20.0f;
-        ImGui::SetCursorPosX((dlgW - btnW * 2 - spacing) / 2);
-
-        ImGui::PushStyleColor(ImGuiCol_Button, colors::kBtnDkGreen);
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colors::kBtnDkGreenHover);
-        if (ImGui::Button("Confirm", ImVec2(btnW, 30))) {
-            gameHandler.confirmTalentWipe();
-        }
-        ImGui::PopStyleColor(2);
-
-        ImGui::SameLine(0, spacing);
-
-        ImGui::PushStyleColor(ImGuiCol_Button, colors::kBtnDkRed);
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colors::kBtnDkRedHover);
-        if (ImGui::Button("Cancel", ImVec2(btnW, 30))) {
-            gameHandler.cancelTalentWipe();
-        }
-        ImGui::PopStyleColor(2);
-    }
-    ImGui::End();
-    ImGui::PopStyleColor(2);
-    ImGui::PopStyleVar();
-}
-
-void DialogManager::renderPetUnlearnConfirmDialog(game::GameHandler& gameHandler) {
-    if (!gameHandler.showPetUnlearnDialog()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    float dlgW = 340.0f;
-    float dlgH = 130.0f;
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - dlgW / 2, screenH * 0.3f), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(dlgW, dlgH), ImGuiCond_Always);
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.0f);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.1f, 0.1f, 0.15f, 0.95f));
-    ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.8f, 0.7f, 0.2f, 1.0f));
-
-    if (ImGui::Begin("##PetUnlearnDialog", nullptr,
-            ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-            ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar)) {
-
-        ImGui::Spacing();
-        uint32_t cost = gameHandler.getPetUnlearnCost();
-        uint32_t gold = cost / 10000;
-        uint32_t silver = (cost % 10000) / 100;
-        uint32_t copper = cost % 100;
-        char costStr[64];
-        if (gold > 0)
-            std::snprintf(costStr, sizeof(costStr), "%ug %us %uc", gold, silver, copper);
-        else if (silver > 0)
-            std::snprintf(costStr, sizeof(costStr), "%us %uc", silver, copper);
-        else
-            std::snprintf(costStr, sizeof(costStr), "%uc", copper);
-
-        std::string text = std::string("Reset your pet's talents for ") + costStr + "?";
-        float textW = ImGui::CalcTextSize(text.c_str()).x;
-        ImGui::SetCursorPosX(std::max(4.0f, (dlgW - textW) / 2));
-        ImGui::TextColored(ImVec4(1.0f, 0.9f, 0.4f, 1.0f), "%s", text.c_str());
-
-        ImGui::Spacing();
-        ImGui::SetCursorPosX(8.0f);
-        ImGui::TextDisabled("All pet talent points will be refunded.");
-        ImGui::Spacing();
-
-        float btnW = 110.0f;
-        float spacing = 20.0f;
-        ImGui::SetCursorPosX((dlgW - btnW * 2 - spacing) / 2);
-
-        ImGui::PushStyleColor(ImGuiCol_Button, colors::kBtnDkGreen);
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colors::kBtnDkGreenHover);
-        if (ImGui::Button("Confirm##petunlearn", ImVec2(btnW, 30))) {
-            gameHandler.confirmPetUnlearn();
-        }
-        ImGui::PopStyleColor(2);
-
-        ImGui::SameLine(0, spacing);
-
-        ImGui::PushStyleColor(ImGuiCol_Button, colors::kBtnDkRed);
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colors::kBtnDkRedHover);
-        if (ImGui::Button("Cancel##petunlearn", ImVec2(btnW, 30))) {
-            gameHandler.cancelPetUnlearn();
-        }
-        ImGui::PopStyleColor(2);
-    }
-    ImGui::End();
-    ImGui::PopStyleColor(2);
-    ImGui::PopStyleVar();
-}
-
-} // namespace ui
-} // namespace wowee
diff --git a/src/ui/game_screen.cpp b/src/ui/game_screen.cpp
index 68954608..f5ab928e 100644
--- a/src/ui/game_screen.cpp
+++ b/src/ui/game_screen.cpp
@@ -1,14 +1,11 @@
 #include "ui/game_screen.hpp"
-#include "ui/ui_colors.hpp"
-#include "ui/ui_helpers.hpp"
+#include "rendering/character_preview.hpp"
 #include "rendering/vk_context.hpp"
 #include "core/application.hpp"
-#include "core/appearance_composer.hpp"
-#include "addons/addon_manager.hpp"
 #include "core/coordinates.hpp"
+#include "core/spawn_presets.hpp"
 #include "core/input.hpp"
 #include "rendering/renderer.hpp"
-#include "rendering/animation_controller.hpp"
 #include "rendering/wmo_renderer.hpp"
 #include "rendering/terrain_manager.hpp"
 #include "rendering/minimap.hpp"
@@ -16,7 +13,6 @@
 #include "rendering/character_renderer.hpp"
 #include "rendering/camera.hpp"
 #include "rendering/camera_controller.hpp"
-#include "audio/audio_coordinator.hpp"
 #include "audio/audio_engine.hpp"
 #include "audio/music_manager.hpp"
 #include "game/zone_manager.hpp"
@@ -31,44 +27,72 @@
 #include "audio/movement_sound_manager.hpp"
 #include "pipeline/asset_manager.hpp"
 #include "pipeline/dbc_loader.hpp"
+#include "pipeline/blp_loader.hpp"
 #include "pipeline/dbc_layout.hpp"
 
 #include "game/expansion_profile.hpp"
-#include "game/character.hpp"
 #include "core/logger.hpp"
 #include <imgui.h>
 #include <imgui_internal.h>
 #include <algorithm>
 #include <cmath>
 #include <cstring>
-#include <sstream>
 #include <cstdlib>
 #include <filesystem>
 #include <fstream>
 #include <cctype>
 #include <chrono>
 #include <ctime>
-
 #include <unordered_set>
 
 namespace {
-    using namespace wowee::ui::colors;
-    using namespace wowee::ui::helpers;
-    constexpr auto& kColorRed        = kRed;
-    constexpr auto& kColorGreen      = kGreen;
-    constexpr auto& kColorBrightGreen= kBrightGreen;
-    constexpr auto& kColorYellow     = kYellow;
-    constexpr auto& kColorGray       = kGray;
-    constexpr auto& kColorDarkGray   = kDarkGray;
+    std::string trim(const std::string& s) {
+        size_t first = s.find_first_not_of(" \t\r\n");
+        if (first == std::string::npos) return "";
+        size_t last = s.find_last_not_of(" \t\r\n");
+        return s.substr(first, last - first + 1);
+    }
 
-    // Abbreviated month names (indexed 0-11)
-    constexpr const char* kMonthAbbrev[12] = {
-        "Jan","Feb","Mar","Apr","May","Jun",
-        "Jul","Aug","Sep","Oct","Nov","Dec"
-    };
+    std::string toLower(std::string s) {
+        std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) {
+            return static_cast<char>(std::tolower(c));
+        });
+        return s;
+    }
 
-    // Common ImGui window flags for popup dialogs
-    const ImGuiWindowFlags kDialogFlags = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize;
+    bool isPortBotTarget(const std::string& target) {
+        std::string t = toLower(trim(target));
+        return t == "portbot" || t == "gmbot" || t == "telebot";
+    }
+
+    std::string buildPortBotCommand(const std::string& rawInput) {
+        std::string input = trim(rawInput);
+        if (input.empty()) return "";
+
+        std::string lower = toLower(input);
+        if (lower == "help" || lower == "?") {
+            return "__help__";
+        }
+
+        if (lower.rfind(".tele ", 0) == 0 || lower.rfind(".go ", 0) == 0) {
+            return input;
+        }
+
+        if (lower.rfind("xyz ", 0) == 0) {
+            return ".go " + input;
+        }
+
+        if (lower == "sw" || lower == "stormwind") return ".tele stormwind";
+        if (lower == "if" || lower == "ironforge") return ".tele ironforge";
+        if (lower == "darn" || lower == "darnassus") return ".tele darnassus";
+        if (lower == "org" || lower == "orgrimmar") return ".tele orgrimmar";
+        if (lower == "tb" || lower == "thunderbluff") return ".tele thunderbluff";
+        if (lower == "uc" || lower == "undercity") return ".tele undercity";
+        if (lower == "shatt" || lower == "shattrath") return ".tele shattrath";
+        if (lower == "dal" || lower == "dalaran") return ".tele dalaran";
+
+        return ".tele " + input;
+    }
 
     bool raySphereIntersect(const wowee::rendering::Ray& ray, const glm::vec3& center, float radius, float& tOut) {
         glm::vec3 oc = ray.origin - center;
@@ -96,210 +120,254 @@ namespace {
         }
         return "Unknown";
     }
-
 }
 
 namespace wowee { namespace ui {
 
 GameScreen::GameScreen() {
     loadSettings();
+    initChatTabs();
 }
 
-// Set UI services and propagate to child components
-void GameScreen::setServices(const UIServices& services) {
-    services_ = services;
-    // Update legacy pointer for compatibility
-    appearanceComposer_ = services.appearanceComposer;
-    // Propagate to child panels
-    chatPanel_.setServices(services);
-    toastManager_.setServices(services);
-    dialogManager_.setServices(services);
-    settingsPanel_.setServices(services);
-    combatUI_.setServices(services);
-    socialPanel_.setServices(services);
-    actionBarPanel_.setServices(services);
-    windowManager_.setServices(services);
+void GameScreen::initChatTabs() {
+    chatTabs_.clear();
+    // General tab: shows everything
+    chatTabs_.push_back({"General", 0xFFFFFFFF});
+    // Combat tab: system + loot messages
+    chatTabs_.push_back({"Combat", (1u << static_cast<uint8_t>(game::ChatType::SYSTEM)) |
+                                    (1u << static_cast<uint8_t>(game::ChatType::LOOT))});
+    // Whispers tab
+    chatTabs_.push_back({"Whispers", (1u << static_cast<uint8_t>(game::ChatType::WHISPER)) |
+                                      (1u << static_cast<uint8_t>(game::ChatType::WHISPER_INFORM))});
+    // Trade/LFG tab: channel messages
+    chatTabs_.push_back({"Trade/LFG", (1u << static_cast<uint8_t>(game::ChatType::CHANNEL))});
+}
+
+bool GameScreen::shouldShowMessage(const game::MessageChatData& msg, int tabIndex) const {
+    if (tabIndex < 0 || tabIndex >= static_cast<int>(chatTabs_.size())) return true;
+    const auto& tab = chatTabs_[tabIndex];
+    if (tab.typeMask == 0xFFFFFFFF) return true;  // General tab shows all
+
+    uint32_t typeBit = 1u << static_cast<uint8_t>(msg.type);
+
+    // For Trade/LFG tab, also filter by channel name
+    if (tabIndex == 3 && msg.type == game::ChatType::CHANNEL) {
+        const std::string& ch = msg.channelName;
+        if (ch.find("Trade") == std::string::npos &&
+            ch.find("General") == std::string::npos &&
+            ch.find("LookingForGroup") == std::string::npos &&
+            ch.find("Local") == std::string::npos) {
+            return false;
+        }
+        return true;
+    }
+
+    return (tab.typeMask & typeBit) != 0;
 }
 
 void GameScreen::render(game::GameHandler& gameHandler) {
-    // Set up chat bubble callback (once) and cache game handler in ChatPanel
-    chatPanel_.setupCallbacks(gameHandler);
-    toastManager_.setupCallbacks(gameHandler);
+    // Set up chat bubble callback (once)
+    if (!chatBubbleCallbackSet_) {
+        gameHandler.setChatBubbleCallback([this](uint64_t guid, const std::string& msg, bool isYell) {
+            float duration = 8.0f + static_cast<float>(msg.size()) * 0.06f;
+            if (isYell) duration += 2.0f;
+            if (duration > 15.0f) duration = 15.0f;
 
-    // Set up appearance-changed callback to refresh inventory preview (barber shop, etc.)
-    if (!appearanceCallbackSet_) {
-        gameHandler.setAppearanceChangedCallback([this]() {
-            inventoryScreenCharGuid_ = 0;  // force preview re-sync on next frame
-        });
-        appearanceCallbackSet_ = true;
-    }
-
-    // Set up UI error frame callback (once)
-    if (!uiErrorCallbackSet_) {
-        gameHandler.setUIErrorCallback([this](const std::string& msg) {
-            uiErrors_.push_back({msg, 0.0f});
-            if (uiErrors_.size() > 5) uiErrors_.erase(uiErrors_.begin());
-            // Play error sound for each new error (rate-limited by deque cap of 5)
-            if (auto* ac = services_.audioCoordinator) {
-                if (auto* sfx = ac->getUiSoundManager()) sfx->playError();
+            // Replace existing bubble for same sender
+            for (auto& b : chatBubbles_) {
+                if (b.senderGuid == guid) {
+                    b.message = msg;
+                    b.timeRemaining = duration;
+                    b.totalDuration = duration;
+                    b.isYell = isYell;
+                    return;
+                }
             }
+            // Evict oldest if too many
+            if (chatBubbles_.size() >= 10) {
+                chatBubbles_.erase(chatBubbles_.begin());
+            }
+            chatBubbles_.push_back({guid, msg, duration, duration, isYell});
         });
-        uiErrorCallbackSet_ = true;
-    }
-
-    // Flash the action bar button whose spell just failed (0.5 s red overlay).
-    if (!castFailedCallbackSet_) {
-        gameHandler.setSpellCastFailedCallback([this](uint32_t spellId) {
-            if (spellId == 0) return;
-            float now = static_cast<float>(ImGui::GetTime());
-            actionBarPanel_.actionFlashEndTimes_[spellId] = now + actionBarPanel_.kActionFlashDuration;
-        });
-        castFailedCallbackSet_ = true;
+        chatBubbleCallbackSet_ = true;
     }
 
     // Apply UI transparency setting
     float prevAlpha = ImGui::GetStyle().Alpha;
-    ImGui::GetStyle().Alpha = settingsPanel_.uiOpacity_;
+    ImGui::GetStyle().Alpha = uiOpacity_;
 
     // Sync minimap opacity with UI opacity
     {
-        auto* renderer = services_.renderer;
+        auto* renderer = core::Application::getInstance().getRenderer();
         if (renderer) {
             if (auto* minimap = renderer->getMinimap()) {
-                minimap->setOpacity(settingsPanel_.uiOpacity_);
+                minimap->setOpacity(uiOpacity_);
             }
         }
     }
 
     // Apply initial settings when renderer becomes available
-    if (!settingsPanel_.minimapSettingsApplied_) {
-        auto* renderer = services_.renderer;
+    if (!minimapSettingsApplied_) {
+        auto* renderer = core::Application::getInstance().getRenderer();
         if (renderer) {
             if (auto* minimap = renderer->getMinimap()) {
-                settingsPanel_.minimapRotate_ = false;
-                settingsPanel_.pendingMinimapRotate = false;
+                minimapRotate_ = false;
+                pendingMinimapRotate = false;
                 minimap->setRotateWithCamera(false);
-                minimap->setSquareShape(settingsPanel_.minimapSquare_);
-                settingsPanel_.minimapSettingsApplied_ = true;
+                minimap->setSquareShape(minimapSquare_);
+                minimapSettingsApplied_ = true;
             }
             if (auto* zm = renderer->getZoneManager()) {
-                zm->setUseOriginalSoundtrack(settingsPanel_.pendingUseOriginalSoundtrack);
+                zm->setUseOriginalSoundtrack(pendingUseOriginalSoundtrack);
             }
             if (auto* tm = renderer->getTerrainManager()) {
-                tm->setGroundClutterDensityScale(static_cast<float>(settingsPanel_.pendingGroundClutterDensity) / 100.0f);
+                tm->setGroundClutterDensityScale(static_cast<float>(pendingGroundClutterDensity) / 100.0f);
             }
             // Restore mute state: save actual master volume first, then apply mute
-            if (settingsPanel_.soundMuted_) {
+            if (soundMuted_) {
                 float actual = audio::AudioEngine::instance().getMasterVolume();
-                settingsPanel_.preMuteVolume_ = (actual > 0.0f) ? actual
-                    : static_cast<float>(settingsPanel_.pendingMasterVolume) / 100.0f;
+                preMuteVolume_ = (actual > 0.0f) ? actual
+                    : static_cast<float>(pendingMasterVolume) / 100.0f;
                 audio::AudioEngine::instance().setMasterVolume(0.0f);
             }
         }
     }
 
     // Apply saved volume settings once when audio managers first become available
-    if (!settingsPanel_.volumeSettingsApplied_) {
-        auto* ac = services_.audioCoordinator;
-        if (ac && ac->getUiSoundManager()) {
-            settingsPanel_.applyAudioVolumes(ac);
-            settingsPanel_.volumeSettingsApplied_ = true;
+    if (!volumeSettingsApplied_) {
+        auto* renderer = core::Application::getInstance().getRenderer();
+        if (renderer && renderer->getUiSoundManager()) {
+            float masterScale = soundMuted_ ? 0.0f : static_cast<float>(pendingMasterVolume) / 100.0f;
+            audio::AudioEngine::instance().setMasterVolume(masterScale);
+            if (auto* music = renderer->getMusicManager()) {
+                music->setVolume(pendingMusicVolume);
+            }
+            if (auto* ambient = renderer->getAmbientSoundManager()) {
+                ambient->setVolumeScale(pendingAmbientVolume / 100.0f);
+            }
+            if (auto* ui = renderer->getUiSoundManager()) {
+                ui->setVolumeScale(pendingUiVolume / 100.0f);
+            }
+            if (auto* combat = renderer->getCombatSoundManager()) {
+                combat->setVolumeScale(pendingCombatVolume / 100.0f);
+            }
+            if (auto* spell = renderer->getSpellSoundManager()) {
+                spell->setVolumeScale(pendingSpellVolume / 100.0f);
+            }
+            if (auto* movement = renderer->getMovementSoundManager()) {
+                movement->setVolumeScale(pendingMovementVolume / 100.0f);
+            }
+            if (auto* footstep = renderer->getFootstepManager()) {
+                footstep->setVolumeScale(pendingFootstepVolume / 100.0f);
+            }
+            if (auto* npcVoice = renderer->getNpcVoiceManager()) {
+                npcVoice->setVolumeScale(pendingNpcVoiceVolume / 100.0f);
+            }
+            if (auto* mount = renderer->getMountSoundManager()) {
+                mount->setVolumeScale(pendingMountVolume / 100.0f);
+            }
+            if (auto* activity = renderer->getActivitySoundManager()) {
+                activity->setVolumeScale(pendingActivityVolume / 100.0f);
+            }
+            volumeSettingsApplied_ = true;
         }
     }
 
     // Apply saved MSAA setting once when renderer is available
-    if (!settingsPanel_.msaaSettingsApplied_ && settingsPanel_.pendingAntiAliasing > 0) {
-        auto* renderer = services_.renderer;
+    if (!msaaSettingsApplied_ && pendingAntiAliasing > 0) {
+        auto* renderer = core::Application::getInstance().getRenderer();
         if (renderer) {
             static const VkSampleCountFlagBits aaSamples[] = {
                 VK_SAMPLE_COUNT_1_BIT, VK_SAMPLE_COUNT_2_BIT,
                 VK_SAMPLE_COUNT_4_BIT, VK_SAMPLE_COUNT_8_BIT
             };
-            renderer->setMsaaSamples(aaSamples[settingsPanel_.pendingAntiAliasing]);
-            settingsPanel_.msaaSettingsApplied_ = true;
+            renderer->setMsaaSamples(aaSamples[pendingAntiAliasing]);
+            msaaSettingsApplied_ = true;
         }
     } else {
-        settingsPanel_.msaaSettingsApplied_ = true;
-    }
-
-    // Apply saved FXAA setting once when renderer is available
-    if (!settingsPanel_.fxaaSettingsApplied_) {
-        auto* renderer = services_.renderer;
-        if (renderer) {
-            renderer->setFXAAEnabled(settingsPanel_.pendingFXAA);
-            settingsPanel_.fxaaSettingsApplied_ = true;
-        }
+        msaaSettingsApplied_ = true;
     }
 
     // Apply saved water refraction setting once when renderer is available
-    if (!settingsPanel_.waterRefractionApplied_) {
-        auto* renderer = services_.renderer;
+    if (!waterRefractionApplied_) {
+        auto* renderer = core::Application::getInstance().getRenderer();
         if (renderer) {
-            renderer->setWaterRefractionEnabled(settingsPanel_.pendingWaterRefraction);
-            settingsPanel_.waterRefractionApplied_ = true;
+            renderer->setWaterRefractionEnabled(pendingWaterRefraction);
+            waterRefractionApplied_ = true;
         }
     }
 
     // Apply saved normal mapping / POM settings once when WMO renderer is available
-    if (!settingsPanel_.normalMapSettingsApplied_) {
-        auto* renderer = services_.renderer;
+    if (!normalMapSettingsApplied_) {
+        auto* renderer = core::Application::getInstance().getRenderer();
         if (renderer) {
             if (auto* wr = renderer->getWMORenderer()) {
-                wr->setNormalMappingEnabled(settingsPanel_.pendingNormalMapping);
-                wr->setNormalMapStrength(settingsPanel_.pendingNormalMapStrength);
-                wr->setPOMEnabled(settingsPanel_.pendingPOM);
-                wr->setPOMQuality(settingsPanel_.pendingPOMQuality);
+                wr->setNormalMappingEnabled(pendingNormalMapping);
+                wr->setNormalMapStrength(pendingNormalMapStrength);
+                wr->setPOMEnabled(pendingPOM);
+                wr->setPOMQuality(pendingPOMQuality);
                 if (auto* cr = renderer->getCharacterRenderer()) {
-                    cr->setNormalMappingEnabled(settingsPanel_.pendingNormalMapping);
-                    cr->setNormalMapStrength(settingsPanel_.pendingNormalMapStrength);
-                    cr->setPOMEnabled(settingsPanel_.pendingPOM);
-                    cr->setPOMQuality(settingsPanel_.pendingPOMQuality);
+                    cr->setNormalMappingEnabled(pendingNormalMapping);
+                    cr->setNormalMapStrength(pendingNormalMapStrength);
+                    cr->setPOMEnabled(pendingPOM);
+                    cr->setPOMQuality(pendingPOMQuality);
                 }
-                settingsPanel_.normalMapSettingsApplied_ = true;
+                normalMapSettingsApplied_ = true;
             }
         }
     }
 
     // Apply saved upscaling setting once when renderer is available
-    if (!settingsPanel_.fsrSettingsApplied_) {
-        auto* renderer = services_.renderer;
+    if (!fsrSettingsApplied_) {
+        auto* renderer = core::Application::getInstance().getRenderer();
         if (renderer) {
-            static constexpr float fsrScales[] = { 0.77f, 0.67f, 0.59f, 1.00f };
-            settingsPanel_.pendingFSRQuality = std::clamp(settingsPanel_.pendingFSRQuality, 0, 3);
-            renderer->setFSRQuality(fsrScales[settingsPanel_.pendingFSRQuality]);
-            renderer->setFSRSharpness(settingsPanel_.pendingFSRSharpness);
-            renderer->setFSR2DebugTuning(settingsPanel_.pendingFSR2JitterSign, settingsPanel_.pendingFSR2MotionVecScaleX, settingsPanel_.pendingFSR2MotionVecScaleY);
-            renderer->setAmdFsr3FramegenEnabled(settingsPanel_.pendingAMDFramegen);
-            int effectiveMode = settingsPanel_.pendingUpscalingMode;
+            static const float fsrScales[] = { 0.77f, 0.67f, 0.59f, 1.00f };
+            pendingFSRQuality = std::clamp(pendingFSRQuality, 0, 3);
+            renderer->setFSRQuality(fsrScales[pendingFSRQuality]);
+            renderer->setFSRSharpness(pendingFSRSharpness);
+            renderer->setFSR2DebugTuning(pendingFSR2JitterSign, pendingFSR2MotionVecScaleX, pendingFSR2MotionVecScaleY);
+            renderer->setAmdFsr3FramegenEnabled(pendingAMDFramegen);
+            // Safety fallback: persisted FSR2 can still hang on some systems during startup.
+            // Require explicit opt-in for startup FSR2; otherwise fall back to FSR1.
+            const bool allowStartupFsr2 = (std::getenv("WOWEE_ALLOW_STARTUP_FSR2") != nullptr);
+            int effectiveMode = pendingUpscalingMode;
+            if (effectiveMode == 2 && !allowStartupFsr2) {
+                static bool warnedStartupFsr2Fallback = false;
+                if (!warnedStartupFsr2Fallback) {
+                    LOG_WARNING("Startup FSR2 is disabled by default for stability; falling back to FSR1. Set WOWEE_ALLOW_STARTUP_FSR2=1 to override.");
+                    warnedStartupFsr2Fallback = true;
+                }
+                effectiveMode = 1;
+                pendingUpscalingMode = 1;
+                pendingFSR = true;
+            }
 
-            // Defer FSR2/FSR3 activation until fully in-world to avoid
-            // init issues during login/character selection screens.
+            // If explicitly enabled, still defer FSR2 until fully in-world.
             if (effectiveMode == 2 && gameHandler.getState() != game::WorldState::IN_WORLD) {
                 renderer->setFSREnabled(false);
                 renderer->setFSR2Enabled(false);
             } else {
                 renderer->setFSREnabled(effectiveMode == 1);
                 renderer->setFSR2Enabled(effectiveMode == 2);
-                settingsPanel_.fsrSettingsApplied_ = true;
+                fsrSettingsApplied_ = true;
             }
         }
     }
 
-    // Apply auto-loot / auto-sell settings to GameHandler every frame (cheap bool sync)
-    gameHandler.setAutoLoot(settingsPanel_.pendingAutoLoot);
-    gameHandler.setAutoSellGrey(settingsPanel_.pendingAutoSellGrey);
-    gameHandler.setAutoRepair(settingsPanel_.pendingAutoRepair);
+    // Apply auto-loot setting to GameHandler every frame (cheap bool sync)
+    gameHandler.setAutoLoot(pendingAutoLoot);
 
     // Sync chat auto-join settings to GameHandler
-    gameHandler.chatAutoJoin.general = chatPanel_.chatAutoJoinGeneral;
-    gameHandler.chatAutoJoin.trade = chatPanel_.chatAutoJoinTrade;
-    gameHandler.chatAutoJoin.localDefense = chatPanel_.chatAutoJoinLocalDefense;
-    gameHandler.chatAutoJoin.lfg = chatPanel_.chatAutoJoinLFG;
-    gameHandler.chatAutoJoin.local = chatPanel_.chatAutoJoinLocal;
+    gameHandler.chatAutoJoin.general = chatAutoJoinGeneral_;
+    gameHandler.chatAutoJoin.trade = chatAutoJoinTrade_;
+    gameHandler.chatAutoJoin.localDefense = chatAutoJoinLocalDefense_;
+    gameHandler.chatAutoJoin.lfg = chatAutoJoinLFG_;
+    gameHandler.chatAutoJoin.local = chatAutoJoinLocal_;
 
     // Process targeting input before UI windows
     processTargetInput(gameHandler);
 
+    // Player unit frame (top-left)
     renderPlayerFrame(gameHandler);
 
     // Pet frame (below player frame, only when player has an active pet)
@@ -307,27 +375,11 @@ void GameScreen::render(game::GameHandler& gameHandler) {
         renderPetFrame(gameHandler);
     }
 
-    // Auto-open pet rename modal when server signals the pet is renameable (first tame)
-    if (gameHandler.consumePetRenameablePending()) {
-        petRenameOpen_ = true;
-        petRenameBuf_[0] = '\0';
-    }
-
-    // Totem frame (Shaman only, when any totem is active)
-    if (gameHandler.getPlayerClass() == 7) {
-        renderTotemFrame(gameHandler);
-    }
-
     // Target frame (only when we have a target)
     if (gameHandler.hasTarget()) {
         renderTargetFrame(gameHandler);
     }
 
-    // Focus target frame (only when we have a focus)
-    if (gameHandler.hasFocus()) {
-        renderFocusFrame(gameHandler);
-    }
-
     // Render windows
     if (showPlayerInfo) {
         renderPlayerInfo(gameHandler);
@@ -338,106 +390,65 @@ void GameScreen::render(game::GameHandler& gameHandler) {
     }
 
     if (showChatWindow) {
-        chatPanel_.getSpellIcon = [this](uint32_t id, pipeline::AssetManager* am) {
-            return getSpellIcon(id, am);
-        };
-        chatPanel_.render(gameHandler, inventoryScreen, spellbookScreen, questLogScreen);
-        // Process slash commands that affect GameScreen state
-        auto cmds = chatPanel_.consumeSlashCommands();
-        if (cmds.showInspect) socialPanel_.showInspectWindow_ = true;
-        if (cmds.toggleThreat) combatUI_.showThreatWindow_ = !combatUI_.showThreatWindow_;
-        if (cmds.showBgScore) combatUI_.showBgScoreboard_ = !combatUI_.showBgScoreboard_;
-        if (cmds.showGmTicket) windowManager_.showGmTicketWindow_ = true;
-        if (cmds.showWho) socialPanel_.showWhoWindow_ = true;
-        if (cmds.toggleCombatLog) combatUI_.showCombatLog_ = !combatUI_.showCombatLog_;
-        if (cmds.takeScreenshot) takeScreenshot(gameHandler);
+        renderChatWindow(gameHandler);
     }
 
     // ---- New UI elements ----
-    actionBarPanel_.renderActionBar(gameHandler, settingsPanel_, chatPanel_,
-        inventoryScreen, spellbookScreen, questLogScreen,
-        [this](uint32_t id, pipeline::AssetManager* am) { return getSpellIcon(id, am); });
-    actionBarPanel_.renderStanceBar(gameHandler, settingsPanel_, spellbookScreen,
-        [this](uint32_t id, pipeline::AssetManager* am) { return getSpellIcon(id, am); });
-    actionBarPanel_.renderBagBar(gameHandler, settingsPanel_, inventoryScreen);
-    actionBarPanel_.renderXpBar(gameHandler, settingsPanel_);
-    actionBarPanel_.renderRepBar(gameHandler, settingsPanel_);
-    auto spellIconFn = [this](uint32_t id, pipeline::AssetManager* am) { return getSpellIcon(id, am); };
-    combatUI_.renderCastBar(gameHandler, spellIconFn);
+    renderActionBar(gameHandler);
+    renderBagBar(gameHandler);
+    renderXpBar(gameHandler);
+    renderCastBar(gameHandler);
     renderMirrorTimers(gameHandler);
-    combatUI_.renderCooldownTracker(gameHandler, settingsPanel_, spellIconFn);
     renderQuestObjectiveTracker(gameHandler);
-    renderNameplates(gameHandler);  // player names always shown; NPC plates gated by showNameplates_
-    combatUI_.renderBattlegroundScore(gameHandler);
-    combatUI_.renderRaidWarningOverlay(gameHandler);
-    combatUI_.renderCombatText(gameHandler);
-    combatUI_.renderDPSMeter(gameHandler, settingsPanel_);
-    renderDurabilityWarning(gameHandler);
-    renderUIErrors(gameHandler, ImGui::GetIO().DeltaTime);
-    toastManager_.renderEarlyToasts(ImGui::GetIO().DeltaTime, gameHandler);
-    if (socialPanel_.showRaidFrames_) {
-        socialPanel_.renderPartyFrames(gameHandler, chatPanel_, spellIconFn);
-    }
-    socialPanel_.renderBossFrames(gameHandler, spellbookScreen, spellIconFn);
-    dialogManager_.renderDialogs(gameHandler, inventoryScreen, chatPanel_);
-    socialPanel_.renderGuildRoster(gameHandler, chatPanel_);
-    socialPanel_.renderSocialFrame(gameHandler, chatPanel_);
-    combatUI_.renderBuffBar(gameHandler, spellbookScreen, spellIconFn);
-    windowManager_.renderLootWindow(gameHandler, inventoryScreen, chatPanel_);
-    windowManager_.renderGossipWindow(gameHandler, chatPanel_);
-    windowManager_.renderQuestDetailsWindow(gameHandler, chatPanel_, inventoryScreen);
-    windowManager_.renderQuestRequestItemsWindow(gameHandler, chatPanel_, inventoryScreen);
-    windowManager_.renderQuestOfferRewardWindow(gameHandler, chatPanel_, inventoryScreen);
-    windowManager_.renderVendorWindow(gameHandler, inventoryScreen, chatPanel_);
-    windowManager_.renderTrainerWindow(gameHandler,
-        [this](uint32_t id, pipeline::AssetManager* am) { return getSpellIcon(id, am); });
-    windowManager_.renderBarberShopWindow(gameHandler);
-    windowManager_.renderStableWindow(gameHandler);
-    windowManager_.renderTaxiWindow(gameHandler);
-    windowManager_.renderMailWindow(gameHandler, inventoryScreen, chatPanel_);
-    windowManager_.renderMailComposeWindow(gameHandler, inventoryScreen);
-    windowManager_.renderBankWindow(gameHandler, inventoryScreen, chatPanel_);
-    windowManager_.renderGuildBankWindow(gameHandler, inventoryScreen, chatPanel_);
-    windowManager_.renderAuctionHouseWindow(gameHandler, inventoryScreen, chatPanel_);
-    socialPanel_.renderDungeonFinderWindow(gameHandler, chatPanel_);
-    windowManager_.renderInstanceLockouts(gameHandler);
-    socialPanel_.renderWhoWindow(gameHandler, chatPanel_);
-    combatUI_.renderCombatLog(gameHandler, spellbookScreen);
-    windowManager_.renderAchievementWindow(gameHandler);
-    windowManager_.renderSkillsWindow(gameHandler);
-    windowManager_.renderTitlesWindow(gameHandler);
-    windowManager_.renderEquipSetWindow(gameHandler);
-    windowManager_.renderGmTicketWindow(gameHandler);
-    socialPanel_.renderInspectWindow(gameHandler, inventoryScreen);
-    windowManager_.renderBookWindow(gameHandler);
-    combatUI_.renderThreatWindow(gameHandler);
-    combatUI_.renderBgScoreboard(gameHandler);
-    if (showMinimap_) {
-        renderMinimapMarkers(gameHandler);
-    }
-    windowManager_.renderLogoutCountdown(gameHandler);
-    windowManager_.renderDeathScreen(gameHandler);
-    windowManager_.renderReclaimCorpseButton(gameHandler);
-    dialogManager_.renderLateDialogs(gameHandler);
-    chatPanel_.renderBubbles(gameHandler);
-    windowManager_.renderEscapeMenu(settingsPanel_);
-    settingsPanel_.renderSettingsWindow(inventoryScreen, chatPanel_, [this]() { saveSettings(); });
-    toastManager_.renderLateToasts(gameHandler);
-    renderWeatherOverlay(gameHandler);
+    if (showNameplates_) renderNameplates(gameHandler);
+    renderCombatText(gameHandler);
+    renderPartyFrames(gameHandler);
+    renderBossFrames(gameHandler);
+    renderGroupInvitePopup(gameHandler);
+    renderDuelRequestPopup(gameHandler);
+    renderLootRollPopup(gameHandler);
+    renderTradeRequestPopup(gameHandler);
+    renderSummonRequestPopup(gameHandler);
+    renderSharedQuestPopup(gameHandler);
+    renderItemTextWindow(gameHandler);
+    renderGuildInvitePopup(gameHandler);
+    renderReadyCheckPopup(gameHandler);
+    renderGuildRoster(gameHandler);
+    renderBuffBar(gameHandler);
+    renderLootWindow(gameHandler);
+    renderGossipWindow(gameHandler);
+    renderQuestDetailsWindow(gameHandler);
+    renderQuestRequestItemsWindow(gameHandler);
+    renderQuestOfferRewardWindow(gameHandler);
+    renderVendorWindow(gameHandler);
+    renderTrainerWindow(gameHandler);
+    renderTaxiWindow(gameHandler);
+    renderMailWindow(gameHandler);
+    renderMailComposeWindow(gameHandler);
+    renderBankWindow(gameHandler);
+    renderGuildBankWindow(gameHandler);
+    renderAuctionHouseWindow(gameHandler);
+    renderDungeonFinderWindow(gameHandler);
+    renderInstanceLockouts(gameHandler);
+    // renderQuestMarkers(gameHandler);  // Disabled - using 3D billboard markers now
+    renderMinimapMarkers(gameHandler);
+    renderDeathScreen(gameHandler);
+    renderResurrectDialog(gameHandler);
+    renderChatBubbles(gameHandler);
+    renderEscapeMenu();
+    renderSettingsWindow();
+    renderDingEffect();
+    renderAchievementToast();
+    renderZoneText();
 
+    // World map (M key toggle handled inside)
     renderWorldMap(gameHandler);
 
-    questLogScreen.render(gameHandler, inventoryScreen);
+    // Quest Log (L key toggle handled inside)
+    questLogScreen.render(gameHandler);
 
-    spellbookScreen.render(gameHandler, services_.assetManager);
-
-    // Insert spell link into chat if player shift-clicked a spellbook entry
-    {
-        std::string pendingSpellLink = spellbookScreen.getAndClearPendingChatLink();
-        if (!pendingSpellLink.empty()) {
-            chatPanel_.insertChatLink(pendingSpellLink);
-        }
-    }
+    // Spellbook (P key toggle handled inside)
+    spellbookScreen.render(gameHandler, core::Application::getInstance().getAssetManager());
 
     // Talents (N key toggle handled inside)
     talentScreen.render(gameHandler);
@@ -446,7 +457,7 @@ void GameScreen::render(game::GameHandler& gameHandler) {
     {
         uint64_t activeGuid = gameHandler.getActiveCharacterGuid();
         if (activeGuid != 0 && activeGuid != inventoryScreenCharGuid_) {
-            auto* am = services_.assetManager;
+            auto* am = core::Application::getInstance().getAssetManager();
             if (am) {
                 inventoryScreen.setAssetManager(am);
                 const auto* ch = gameHandler.getActiveCharacter();
@@ -469,8 +480,8 @@ void GameScreen::render(game::GameHandler& gameHandler) {
 
     // Auto-open bags once when vendor window first opens
     if (gameHandler.isVendorWindowOpen()) {
-        if (!windowManager_.vendorBagsOpened_) {
-            windowManager_.vendorBagsOpened_ = true;
+        if (!vendorBagsOpened_) {
+            vendorBagsOpened_ = true;
             if (inventoryScreen.isSeparateBags()) {
                 inventoryScreen.openAllBags();
             } else if (!inventoryScreen.isOpen()) {
@@ -478,109 +489,42 @@ void GameScreen::render(game::GameHandler& gameHandler) {
             }
         }
     } else {
-        windowManager_.vendorBagsOpened_ = false;
+        vendorBagsOpened_ = false;
     }
 
+    // Bags (B key toggle handled inside)
     inventoryScreen.setGameHandler(&gameHandler);
     inventoryScreen.render(gameHandler.getInventory(), gameHandler.getMoneyCopper());
 
     // Character screen (C key toggle handled inside render())
     inventoryScreen.renderCharacterScreen(gameHandler);
 
-    // Insert item link into chat if player shift-clicked any inventory/equipment slot
-    {
-        std::string pendingLink = inventoryScreen.getAndClearPendingChatLink();
-        if (!pendingLink.empty()) {
-            chatPanel_.insertChatLink(pendingLink);
-        }
-    }
-
     if (inventoryScreen.consumeEquipmentDirty() || gameHandler.consumeOnlineEquipmentDirty()) {
         updateCharacterGeosets(gameHandler.getInventory());
         updateCharacterTextures(gameHandler.getInventory());
-        if (appearanceComposer_) appearanceComposer_->loadEquippedWeapons();
+        core::Application::getInstance().loadEquippedWeapons();
         inventoryScreen.markPreviewDirty();
         // Update renderer weapon type for animation selection
-        auto* r = services_.renderer;
+        auto* r = core::Application::getInstance().getRenderer();
         if (r) {
             const auto& mh = gameHandler.getInventory().getEquipSlot(game::EquipSlot::MAIN_HAND);
-            const auto& oh = gameHandler.getInventory().getEquipSlot(game::EquipSlot::OFF_HAND);
-            if (mh.empty()) {
-                r->setEquippedWeaponType(0, false);
-            } else {
-                // Polearms and staves use ATTACK_2H_LOOSE instead of ATTACK_2H
-                bool is2HLoose = (mh.item.subclassName == "Polearm" || mh.item.subclassName == "Staff");
-                bool isFist = (mh.item.subclassName == "Fist Weapon");
-                bool isDagger = (mh.item.subclassName == "Dagger");
-                bool hasOffHand = !oh.empty() &&
-                    (oh.item.inventoryType == game::InvType::ONE_HAND ||
-                     oh.item.subclassName == "Fist Weapon");
-                bool hasShield = !oh.empty() && oh.item.inventoryType == game::InvType::SHIELD;
-                r->setEquippedWeaponType(mh.item.inventoryType, is2HLoose, isFist, isDagger, hasOffHand, hasShield);
-            }
-            // Detect ranged weapon type from RANGED slot
-            const auto& rangedSlot = gameHandler.getInventory().getEquipSlot(game::EquipSlot::RANGED);
-            if (rangedSlot.empty()) {
-                r->setEquippedRangedType(rendering::RangedWeaponType::NONE);
-            } else if (rangedSlot.item.inventoryType == game::InvType::RANGED_BOW) {
-                // subclassName distinguishes Bow vs Crossbow
-                if (rangedSlot.item.subclassName == "Crossbow")
-                    r->setEquippedRangedType(rendering::RangedWeaponType::CROSSBOW);
-                else
-                    r->setEquippedRangedType(rendering::RangedWeaponType::BOW);
-            } else if (rangedSlot.item.inventoryType == game::InvType::RANGED_GUN) {
-                r->setEquippedRangedType(rendering::RangedWeaponType::GUN);
-            } else if (rangedSlot.item.inventoryType == game::InvType::THROWN) {
-                r->setEquippedRangedType(rendering::RangedWeaponType::THROWN);
-            } else {
-                r->setEquippedRangedType(rendering::RangedWeaponType::NONE);
-            }
+            r->setEquippedWeaponType(mh.empty() ? 0 : mh.item.inventoryType);
         }
     }
 
     // Update renderer face-target position and selection circle
-    auto* renderer = services_.renderer;
+    auto* renderer = core::Application::getInstance().getRenderer();
     if (renderer) {
-        renderer->setInCombat(gameHandler.isInCombat() &&
-                              !gameHandler.isPlayerDead() &&
-                              !gameHandler.isPlayerGhost());
-        if (auto* cr = renderer->getCharacterRenderer()) {
-            uint32_t charInstId = renderer->getCharacterInstanceId();
-            if (charInstId != 0) {
-                const bool isGhost = gameHandler.isPlayerGhost();
-                if (!ghostOpacityStateKnown_ ||
-                    ghostOpacityLastState_ != isGhost ||
-                    ghostOpacityLastInstanceId_ != charInstId) {
-                    cr->setInstanceOpacity(charInstId, isGhost ? 0.5f : 1.0f);
-                    ghostOpacityStateKnown_ = true;
-                    ghostOpacityLastState_ = isGhost;
-                    ghostOpacityLastInstanceId_ = charInstId;
-                }
-            }
-        }
+        renderer->setInCombat(gameHandler.isInCombat());
         static glm::vec3 targetGLPos;
         if (gameHandler.hasTarget()) {
             auto target = gameHandler.getTarget();
             if (target) {
-                // Prefer the renderer's actual instance position so the selection
-                // circle tracks the rendered model (not a parallel entity-space
-                // interpolator that can drift from the visual position).
-                glm::vec3 instPos;
-                if (core::Application::getInstance().getRenderPositionForGuid(target->getGuid(), instPos)) {
-                    targetGLPos = instPos;
-                    // Override Z with foot position to sit the circle on the ground.
-                    float footZ = 0.0f;
-                    if (core::Application::getInstance().getRenderFootZForGuid(target->getGuid(), footZ)) {
-                        targetGLPos.z = footZ;
-                    }
-                } else {
-                    // Fallback: entity game-logic position (no CharacterRenderer instance yet)
-                    targetGLPos = core::coords::canonicalToRender(
-                        glm::vec3(target->getX(), target->getY(), target->getZ()));
-                    float footZ = 0.0f;
-                    if (core::Application::getInstance().getRenderFootZForGuid(target->getGuid(), footZ)) {
-                        targetGLPos.z = footZ;
-                    }
+                targetGLPos = core::coords::canonicalToRender(
+                    glm::vec3(target->getX(), target->getY(), target->getZ()));
+                float footZ = 0.0f;
+                if (core::Application::getInstance().getRenderFootZForGuid(target->getGuid(), footZ)) {
+                    targetGLPos.z = footZ;
                 }
                 renderer->setTargetPosition(&targetGLPos);
 
@@ -638,128 +582,6 @@ void GameScreen::render(game::GameHandler& gameHandler) {
         }
     }
 
-    // Screen edge damage flash — red vignette that fires on HP decrease
-    {
-        auto playerEntity = gameHandler.getEntityManager().getEntity(gameHandler.getPlayerGuid());
-        uint32_t currentHp = 0;
-        if (playerEntity && (playerEntity->getType() == game::ObjectType::PLAYER ||
-                             playerEntity->getType() == game::ObjectType::UNIT)) {
-            auto unit = std::static_pointer_cast<game::Unit>(playerEntity);
-            if (unit->getMaxHealth() > 0)
-                currentHp = unit->getHealth();
-        }
-
-        // Detect HP drop (ignore transitions from 0 — entity just spawned or uninitialized)
-        if (settingsPanel_.damageFlashEnabled_ && lastPlayerHp_ > 0 && currentHp < lastPlayerHp_ && currentHp > 0)
-            damageFlashAlpha_ = 1.0f;
-        lastPlayerHp_ = currentHp;
-
-        // Fade out over ~0.5 seconds
-        if (damageFlashAlpha_ > 0.0f) {
-            damageFlashAlpha_ -= ImGui::GetIO().DeltaTime * 2.0f;
-            if (damageFlashAlpha_ < 0.0f) damageFlashAlpha_ = 0.0f;
-
-            // Draw four red gradient rectangles along each screen edge (vignette style)
-            ImDrawList* fg = ImGui::GetForegroundDrawList();
-            ImGuiIO& io = ImGui::GetIO();
-            const float W = io.DisplaySize.x;
-            const float H = io.DisplaySize.y;
-            const int alpha = static_cast<int>(damageFlashAlpha_ * 100.0f);
-            const ImU32 edgeCol  = IM_COL32(200, 0, 0, alpha);
-            const ImU32 fadeCol  = IM_COL32(200, 0, 0, 0);
-            const float thickness = std::min(W, H) * 0.12f;
-
-            // Top
-            fg->AddRectFilledMultiColor(ImVec2(0, 0), ImVec2(W, thickness),
-                                        edgeCol, edgeCol, fadeCol, fadeCol);
-            // Bottom
-            fg->AddRectFilledMultiColor(ImVec2(0, H - thickness), ImVec2(W, H),
-                                        fadeCol, fadeCol, edgeCol, edgeCol);
-            // Left
-            fg->AddRectFilledMultiColor(ImVec2(0, 0), ImVec2(thickness, H),
-                                        edgeCol, fadeCol, fadeCol, edgeCol);
-            // Right
-            fg->AddRectFilledMultiColor(ImVec2(W - thickness, 0), ImVec2(W, H),
-                                        fadeCol, edgeCol, edgeCol, fadeCol);
-        }
-    }
-
-    // Persistent low-health vignette — pulsing red edges when HP < 20%
-    {
-        auto playerEntity = gameHandler.getEntityManager().getEntity(gameHandler.getPlayerGuid());
-        bool isDead = gameHandler.isPlayerDead();
-        float hpPct = 1.0f;
-        if (!isDead && playerEntity &&
-            (playerEntity->getType() == game::ObjectType::PLAYER ||
-             playerEntity->getType() == game::ObjectType::UNIT)) {
-            auto unit = std::static_pointer_cast<game::Unit>(playerEntity);
-            if (unit->getMaxHealth() > 0)
-                hpPct = static_cast<float>(unit->getHealth()) / static_cast<float>(unit->getMaxHealth());
-        }
-
-        // Only show when alive and below 20% HP; intensity increases as HP drops
-        if (settingsPanel_.lowHealthVignetteEnabled_ && !isDead && hpPct < 0.20f && hpPct > 0.0f) {
-            // Base intensity from HP deficit (0 at 20%, 1 at 0%); pulse at ~1.5 Hz
-            float danger = (0.20f - hpPct) / 0.20f;
-            float pulse  = 0.55f + 0.45f * std::sin(static_cast<float>(ImGui::GetTime()) * 9.4f);
-            int   alpha  = static_cast<int>(danger * pulse * 90.0f);  // max ~90 alpha, subtle
-            if (alpha > 0) {
-                ImDrawList* fg = ImGui::GetForegroundDrawList();
-                ImGuiIO& io = ImGui::GetIO();
-                const float W = io.DisplaySize.x;
-                const float H = io.DisplaySize.y;
-                const float thickness = std::min(W, H) * 0.15f;
-                const ImU32 edgeCol = IM_COL32(200, 0, 0, alpha);
-                const ImU32 fadeCol = IM_COL32(200, 0, 0, 0);
-                fg->AddRectFilledMultiColor(ImVec2(0, 0), ImVec2(W, thickness),
-                                            edgeCol, edgeCol, fadeCol, fadeCol);
-                fg->AddRectFilledMultiColor(ImVec2(0, H - thickness), ImVec2(W, H),
-                                            fadeCol, fadeCol, edgeCol, edgeCol);
-                fg->AddRectFilledMultiColor(ImVec2(0, 0), ImVec2(thickness, H),
-                                            edgeCol, fadeCol, fadeCol, edgeCol);
-                fg->AddRectFilledMultiColor(ImVec2(W - thickness, 0), ImVec2(W, H),
-                                            fadeCol, edgeCol, edgeCol, fadeCol);
-            }
-        }
-    }
-
-    // Level-up golden burst overlay
-    if (toastManager_.levelUpFlashAlpha > 0.0f) {
-        toastManager_.levelUpFlashAlpha -= ImGui::GetIO().DeltaTime * 1.0f;  // fade over ~1 second
-        if (toastManager_.levelUpFlashAlpha < 0.0f) toastManager_.levelUpFlashAlpha = 0.0f;
-
-        ImDrawList* fg = ImGui::GetForegroundDrawList();
-        ImGuiIO& io = ImGui::GetIO();
-        const float W = io.DisplaySize.x;
-        const float H = io.DisplaySize.y;
-        const int alpha = static_cast<int>(toastManager_.levelUpFlashAlpha * 160.0f);
-        const ImU32 goldEdge = IM_COL32(255, 210, 50, alpha);
-        const ImU32 goldFade = IM_COL32(255, 210, 50, 0);
-        const float thickness = std::min(W, H) * 0.18f;
-
-        // Four golden gradient edges
-        fg->AddRectFilledMultiColor(ImVec2(0, 0), ImVec2(W, thickness),
-                                    goldEdge, goldEdge, goldFade, goldFade);
-        fg->AddRectFilledMultiColor(ImVec2(0, H - thickness), ImVec2(W, H),
-                                    goldFade, goldFade, goldEdge, goldEdge);
-        fg->AddRectFilledMultiColor(ImVec2(0, 0), ImVec2(thickness, H),
-                                    goldEdge, goldFade, goldFade, goldEdge);
-        fg->AddRectFilledMultiColor(ImVec2(W - thickness, 0), ImVec2(W, H),
-                                    goldFade, goldEdge, goldEdge, goldFade);
-
-        // "Level X!" text in the center during the first half of the animation
-        if (toastManager_.levelUpFlashAlpha > 0.5f && toastManager_.levelUpDisplayLevel > 0) {
-            char lvlText[32];
-            snprintf(lvlText, sizeof(lvlText), "Level %u!", toastManager_.levelUpDisplayLevel);
-            ImVec2 ts = ImGui::CalcTextSize(lvlText);
-            float tx = (W - ts.x) * 0.5f;
-            float ty = H * 0.35f;
-            // Large shadow + bright gold text
-            fg->AddText(nullptr, 28.0f, ImVec2(tx + 2, ty + 2), IM_COL32(0, 0, 0, alpha), lvlText);
-            fg->AddText(nullptr, 28.0f, ImVec2(tx, ty), IM_COL32(255, 230, 80, alpha), lvlText);
-        }
-    }
-
     // Restore previous alpha
     ImGui::GetStyle().Alpha = prevAlpha;
 }
@@ -800,16 +622,16 @@ void GameScreen::renderPlayerInfo(game::GameHandler& gameHandler) {
     auto state = gameHandler.getState();
     switch (state) {
         case game::WorldState::IN_WORLD:
-            ImGui::TextColored(kColorBrightGreen, "In World");
+            ImGui::TextColored(ImVec4(0.3f, 1.0f, 0.3f, 1.0f), "In World");
             break;
         case game::WorldState::AUTHENTICATED:
-            ImGui::TextColored(kColorYellow, "Authenticated");
+            ImGui::TextColored(ImVec4(1.0f, 1.0f, 0.3f, 1.0f), "Authenticated");
             break;
         case game::WorldState::ENTERING_WORLD:
-            ImGui::TextColored(kColorYellow, "Entering World...");
+            ImGui::TextColored(ImVec4(1.0f, 1.0f, 0.3f, 1.0f), "Entering World...");
             break;
         default:
-            ImGui::TextColored(kColorRed, "State: %d", static_cast<int>(state));
+            ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f), "State: %d", static_cast<int>(state));
             break;
     }
     ImGui::Unindent();
@@ -859,10 +681,10 @@ void GameScreen::renderEntityList(game::GameHandler& gameHandler) {
                 ImGui::TableSetColumnIndex(1);
                 switch (entity->getType()) {
                     case game::ObjectType::PLAYER:
-                        ImGui::TextColored(kColorBrightGreen, "Player");
+                        ImGui::TextColored(ImVec4(0.3f, 1.0f, 0.3f, 1.0f), "Player");
                         break;
                     case game::ObjectType::UNIT:
-                        ImGui::TextColored(kColorYellow, "Unit");
+                        ImGui::TextColored(ImVec4(1.0f, 1.0f, 0.3f, 1.0f), "Unit");
                         break;
                     case game::ObjectType::GAMEOBJECT:
                         ImGui::TextColored(ImVec4(0.3f, 0.8f, 1.0f, 1.0f), "GameObject");
@@ -908,220 +730,740 @@ void GameScreen::renderEntityList(game::GameHandler& gameHandler) {
     ImGui::End();
 }
 
+void GameScreen::renderChatWindow(game::GameHandler& gameHandler) {
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
+    float chatW = std::min(500.0f, screenW * 0.4f);
+    float chatH = 220.0f;
+    float chatX = 8.0f;
+    float chatY = screenH - chatH - 80.0f;  // Above action bar
+    if (chatWindowLocked) {
+        // Always recompute position from current window size when locked
+        chatWindowPos_ = ImVec2(chatX, chatY);
+        ImGui::SetNextWindowSize(ImVec2(chatW, chatH), ImGuiCond_Always);
+        ImGui::SetNextWindowPos(chatWindowPos_, ImGuiCond_Always);
+    } else {
+        if (!chatWindowPosInit_) {
+            chatWindowPos_ = ImVec2(chatX, chatY);
+            chatWindowPosInit_ = true;
+        }
+        ImGui::SetNextWindowSize(ImVec2(chatW, chatH), ImGuiCond_FirstUseEver);
+        ImGui::SetNextWindowPos(chatWindowPos_, ImGuiCond_FirstUseEver);
+    }
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize;
+    if (chatWindowLocked) {
+        flags |= ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar;
+    }
+    ImGui::Begin("Chat", nullptr, flags);
+
+    if (!chatWindowLocked) {
+        chatWindowPos_ = ImGui::GetWindowPos();
+    }
+
+    // Chat tabs
+    if (ImGui::BeginTabBar("ChatTabs")) {
+        for (int i = 0; i < static_cast<int>(chatTabs_.size()); ++i) {
+            if (ImGui::BeginTabItem(chatTabs_[i].name.c_str())) {
+                activeChatTab_ = i;
+                ImGui::EndTabItem();
+            }
+        }
+        ImGui::EndTabBar();
+    }
+
+    // Chat history
+    const auto& chatHistory = gameHandler.getChatHistory();
+
+    // Apply chat font size scaling
+    float chatScale = chatFontSize_ == 0 ? 0.85f : (chatFontSize_ == 2 ? 1.2f : 1.0f);
+    ImGui::SetWindowFontScale(chatScale);
+
+    ImGui::BeginChild("ChatHistory", ImVec2(0, -70), true, ImGuiWindowFlags_HorizontalScrollbar);
+    bool chatHistoryHovered = ImGui::IsWindowHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem);
+
+    // Helper: parse WoW color code |cAARRGGBB → ImVec4
+    auto parseWowColor = [](const std::string& text, size_t pos) -> ImVec4 {
+        // |cAARRGGBB (10 chars total: |c + 8 hex)
+        if (pos + 10 > text.size()) return ImVec4(1, 1, 1, 1);
+        auto hexByte = [&](size_t offset) -> float {
+            const char* s = text.c_str() + pos + offset;
+            char buf[3] = {s[0], s[1], '\0'};
+            return static_cast<float>(strtol(buf, nullptr, 16)) / 255.0f;
+        };
+        float a = hexByte(2);
+        float r = hexByte(4);
+        float g = hexByte(6);
+        float b = hexByte(8);
+        return ImVec4(r, g, b, a);
+    };
+
+    // Helper: render an item tooltip from ItemQueryResponseData
+    auto renderItemLinkTooltip = [&](uint32_t itemEntry) {
+        const auto* info = gameHandler.getItemInfo(itemEntry);
+        if (!info || !info->valid) return;
+        auto findComparableEquipped = [&](uint8_t inventoryType) -> const game::ItemSlot* {
+            using ES = game::EquipSlot;
+            const auto& inv = gameHandler.getInventory();
+            auto slotPtr = [&](ES slot) -> const game::ItemSlot* {
+                const auto& s = inv.getEquipSlot(slot);
+                return s.empty() ? nullptr : &s;
+            };
+            switch (inventoryType) {
+                case 1: return slotPtr(ES::HEAD);
+                case 2: return slotPtr(ES::NECK);
+                case 3: return slotPtr(ES::SHOULDERS);
+                case 4: return slotPtr(ES::SHIRT);
+                case 5:
+                case 20: return slotPtr(ES::CHEST);
+                case 6: return slotPtr(ES::WAIST);
+                case 7: return slotPtr(ES::LEGS);
+                case 8: return slotPtr(ES::FEET);
+                case 9: return slotPtr(ES::WRISTS);
+                case 10: return slotPtr(ES::HANDS);
+                case 11: {
+                    if (auto* s = slotPtr(ES::RING1)) return s;
+                    return slotPtr(ES::RING2);
+                }
+                case 12: {
+                    if (auto* s = slotPtr(ES::TRINKET1)) return s;
+                    return slotPtr(ES::TRINKET2);
+                }
+                case 13:
+                    if (auto* s = slotPtr(ES::MAIN_HAND)) return s;
+                    return slotPtr(ES::OFF_HAND);
+                case 14:
+                case 22:
+                case 23: return slotPtr(ES::OFF_HAND);
+                case 15:
+                case 25:
+                case 26: return slotPtr(ES::RANGED);
+                case 16: return slotPtr(ES::BACK);
+                case 17:
+                case 21: return slotPtr(ES::MAIN_HAND);
+                case 18:
+                    for (int i = 0; i < game::Inventory::NUM_BAG_SLOTS; ++i) {
+                        auto slot = static_cast<ES>(static_cast<int>(ES::BAG1) + i);
+                        if (auto* s = slotPtr(slot)) return s;
+                    }
+                    return nullptr;
+                case 19: return slotPtr(ES::TABARD);
+                default: return nullptr;
+            }
+        };
+
+        ImGui::BeginTooltip();
+        // Quality color for name
+        ImVec4 qColor(1, 1, 1, 1);
+        switch (info->quality) {
+            case 0: qColor = ImVec4(0.62f, 0.62f, 0.62f, 1.0f); break; // Poor
+            case 1: qColor = ImVec4(1.0f, 1.0f, 1.0f, 1.0f); break;    // Common
+            case 2: qColor = ImVec4(0.12f, 1.0f, 0.0f, 1.0f); break;   // Uncommon
+            case 3: qColor = ImVec4(0.0f, 0.44f, 0.87f, 1.0f); break;  // Rare
+            case 4: qColor = ImVec4(0.64f, 0.21f, 0.93f, 1.0f); break; // Epic
+            case 5: qColor = ImVec4(1.0f, 0.50f, 0.0f, 1.0f); break;   // Legendary
+        }
+        ImGui::TextColored(qColor, "%s", info->name.c_str());
+
+        // Slot type
+        if (info->inventoryType > 0) {
+            const char* slotName = "";
+            switch (info->inventoryType) {
+                case 1:  slotName = "Head"; break;
+                case 2:  slotName = "Neck"; break;
+                case 3:  slotName = "Shoulder"; break;
+                case 4:  slotName = "Shirt"; break;
+                case 5:  slotName = "Chest"; break;
+                case 6:  slotName = "Waist"; break;
+                case 7:  slotName = "Legs"; break;
+                case 8:  slotName = "Feet"; break;
+                case 9:  slotName = "Wrist"; break;
+                case 10: slotName = "Hands"; break;
+                case 11: slotName = "Finger"; break;
+                case 12: slotName = "Trinket"; break;
+                case 13: slotName = "One-Hand"; break;
+                case 14: slotName = "Shield"; break;
+                case 15: slotName = "Ranged"; break;
+                case 16: slotName = "Back"; break;
+                case 17: slotName = "Two-Hand"; break;
+                case 18: slotName = "Bag"; break;
+                case 19: slotName = "Tabard"; break;
+                case 20: slotName = "Robe"; break;
+                case 21: slotName = "Main Hand"; break;
+                case 22: slotName = "Off Hand"; break;
+                case 23: slotName = "Held In Off-hand"; break;
+                case 25: slotName = "Thrown"; break;
+                case 26: slotName = "Ranged"; break;
+            }
+            if (slotName[0]) {
+                if (!info->subclassName.empty())
+                    ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f), "%s  %s", slotName, info->subclassName.c_str());
+                else
+                    ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f), "%s", slotName);
+            }
+        }
+        auto isWeaponInventoryType = [](uint32_t invType) {
+            switch (invType) {
+                case 13: // One-Hand
+                case 15: // Ranged
+                case 17: // Two-Hand
+                case 21: // Main Hand
+                case 25: // Thrown
+                case 26: // Ranged Right
+                    return true;
+                default:
+                    return false;
+            }
+        };
+        const bool isWeapon = isWeaponInventoryType(info->inventoryType);
+
+        if (isWeapon && info->damageMax > 0.0f && info->delayMs > 0) {
+            float speed = static_cast<float>(info->delayMs) / 1000.0f;
+            float dps = ((info->damageMin + info->damageMax) * 0.5f) / speed;
+            ImGui::Text("%.1f DPS", dps);
+        }
+        ImVec4 green(0.0f, 1.0f, 0.0f, 1.0f);
+        auto appendBonus = [](std::string& out, int32_t val, const char* shortName) {
+            if (val <= 0) return;
+            if (!out.empty()) out += "  ";
+            out += "+" + std::to_string(val) + " ";
+            out += shortName;
+        };
+        std::string bonusLine;
+        appendBonus(bonusLine, info->strength, "Str");
+        appendBonus(bonusLine, info->agility, "Agi");
+        appendBonus(bonusLine, info->stamina, "Sta");
+        appendBonus(bonusLine, info->intellect, "Int");
+        appendBonus(bonusLine, info->spirit, "Spi");
+        if (!bonusLine.empty()) {
+            ImGui::TextColored(green, "%s", bonusLine.c_str());
+        }
+        if (info->armor > 0) {
+            ImGui::Text("%d Armor", info->armor);
+        }
+        if (info->sellPrice > 0) {
+            uint32_t g = info->sellPrice / 10000;
+            uint32_t s = (info->sellPrice / 100) % 100;
+            uint32_t c = info->sellPrice % 100;
+            ImGui::TextColored(ImVec4(1.0f, 0.84f, 0.0f, 1.0f), "Sell: %ug %us %uc", g, s, c);
+        }
+
+        if (ImGui::GetIO().KeyShift && info->inventoryType > 0) {
+            if (const auto* eq = findComparableEquipped(static_cast<uint8_t>(info->inventoryType))) {
+                ImGui::Separator();
+                ImGui::TextDisabled("Equipped:");
+                VkDescriptorSet eqIcon = inventoryScreen.getItemIcon(eq->item.displayInfoId);
+                if (eqIcon) {
+                    ImGui::Image((ImTextureID)(uintptr_t)eqIcon, ImVec2(18.0f, 18.0f));
+                    ImGui::SameLine();
+                }
+                ImGui::TextColored(InventoryScreen::getQualityColor(eq->item.quality), "%s", eq->item.name.c_str());
+                if (isWeaponInventoryType(eq->item.inventoryType) &&
+                    eq->item.damageMax > 0.0f && eq->item.delayMs > 0) {
+                    float speed = static_cast<float>(eq->item.delayMs) / 1000.0f;
+                    float dps = ((eq->item.damageMin + eq->item.damageMax) * 0.5f) / speed;
+                    ImGui::Text("%.1f DPS", dps);
+                }
+                if (eq->item.armor > 0) {
+                    ImGui::Text("%d Armor", eq->item.armor);
+                }
+                std::string eqBonusLine;
+                appendBonus(eqBonusLine, eq->item.strength, "Str");
+                appendBonus(eqBonusLine, eq->item.agility, "Agi");
+                appendBonus(eqBonusLine, eq->item.stamina, "Sta");
+                appendBonus(eqBonusLine, eq->item.intellect, "Int");
+                appendBonus(eqBonusLine, eq->item.spirit, "Spi");
+                if (!eqBonusLine.empty()) {
+                    ImGui::TextColored(green, "%s", eqBonusLine.c_str());
+                }
+            }
+        }
+        ImGui::EndTooltip();
+    };
+
+    // Helper: render text with clickable URLs and WoW item links
+    auto renderTextWithLinks = [&](const std::string& text, const ImVec4& color) {
+        size_t pos = 0;
+        while (pos < text.size()) {
+            // Find next special element: URL or WoW link
+            size_t urlStart = text.find("https://", pos);
+
+            // Find next WoW item link: |cXXXXXXXX|Hitem:ENTRY:...|h[Name]|h|r
+            size_t linkStart = text.find("|c", pos);
+            // Also handle bare |Hitem: without color prefix
+            size_t bareLinkStart = text.find("|Hitem:", pos);
+
+            // Determine which comes first
+            size_t nextSpecial = std::min({urlStart, linkStart, bareLinkStart});
+
+            if (nextSpecial == std::string::npos) {
+                // No more special elements, render remaining text
+                std::string remaining = text.substr(pos);
+                if (!remaining.empty()) {
+                    ImGui::PushStyleColor(ImGuiCol_Text, color);
+                    ImGui::TextWrapped("%s", remaining.c_str());
+                    ImGui::PopStyleColor();
+                }
+                break;
+            }
+
+            // Render plain text before special element
+            if (nextSpecial > pos) {
+                std::string before = text.substr(pos, nextSpecial - pos);
+                ImGui::PushStyleColor(ImGuiCol_Text, color);
+                ImGui::TextWrapped("%s", before.c_str());
+                ImGui::PopStyleColor();
+                ImGui::SameLine(0, 0);
+            }
+
+            // Handle WoW item link
+            if (nextSpecial == linkStart || nextSpecial == bareLinkStart) {
+                ImVec4 linkColor = color;
+                size_t hStart = std::string::npos;
+
+                if (nextSpecial == linkStart && text.size() > linkStart + 10) {
+                    // Parse |cAARRGGBB color
+                    linkColor = parseWowColor(text, linkStart);
+                    hStart = text.find("|Hitem:", linkStart + 10);
+                } else if (nextSpecial == bareLinkStart) {
+                    hStart = bareLinkStart;
+                }
+
+                if (hStart != std::string::npos) {
+                    // Parse item entry: |Hitem:ENTRY:...
+                    size_t entryStart = hStart + 7; // skip "|Hitem:"
+                    size_t entryEnd = text.find(':', entryStart);
+                    uint32_t itemEntry = 0;
+                    if (entryEnd != std::string::npos) {
+                        itemEntry = static_cast<uint32_t>(strtoul(
+                            text.substr(entryStart, entryEnd - entryStart).c_str(), nullptr, 10));
+                    }
+
+                    // Find display name: |h[Name]|h
+                    size_t nameTagStart = text.find("|h[", hStart);
+                    size_t nameTagEnd = (nameTagStart != std::string::npos)
+                        ? text.find("]|h", nameTagStart + 3) : std::string::npos;
+
+                    std::string itemName = "Unknown Item";
+                    if (nameTagStart != std::string::npos && nameTagEnd != std::string::npos) {
+                        itemName = text.substr(nameTagStart + 3, nameTagEnd - nameTagStart - 3);
+                    }
+
+                    // Find end of entire link sequence (|r or after ]|h)
+                    size_t linkEnd = (nameTagEnd != std::string::npos) ? nameTagEnd + 3 : hStart + 7;
+                    size_t resetPos = text.find("|r", linkEnd);
+                    if (resetPos != std::string::npos && resetPos <= linkEnd + 2) {
+                        linkEnd = resetPos + 2;
+                    }
+
+                    // Ensure item info is cached (trigger query if needed)
+                    if (itemEntry > 0) {
+                        gameHandler.ensureItemInfo(itemEntry);
+                    }
+
+                    // Render bracketed item name in quality color
+                    std::string display = "[" + itemName + "]";
+                    ImGui::PushStyleColor(ImGuiCol_Text, linkColor);
+                    ImGui::TextWrapped("%s", display.c_str());
+                    ImGui::PopStyleColor();
+
+                    if (ImGui::IsItemHovered()) {
+                        ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
+                        if (itemEntry > 0) {
+                            renderItemLinkTooltip(itemEntry);
+                        }
+                    }
+
+                    // Shift-click: insert item link into chat input
+                    if (ImGui::IsItemClicked() && ImGui::GetIO().KeyShift) {
+                        std::string linkText = text.substr(nextSpecial, linkEnd - nextSpecial);
+                        size_t curLen = strlen(chatInputBuffer);
+                        if (curLen + linkText.size() + 1 < sizeof(chatInputBuffer)) {
+                            strncat(chatInputBuffer, linkText.c_str(), sizeof(chatInputBuffer) - curLen - 1);
+                            chatInputMoveCursorToEnd = true;
+                        }
+                    }
+
+                    pos = linkEnd;
+                    continue;
+                }
+
+                // Not an item link — treat as colored text: |cAARRGGBB...text...|r
+                if (nextSpecial == linkStart && text.size() > linkStart + 10) {
+                    ImVec4 cColor = parseWowColor(text, linkStart);
+                    size_t textStart = linkStart + 10; // after |cAARRGGBB
+                    size_t resetPos2 = text.find("|r", textStart);
+                    std::string coloredText;
+                    if (resetPos2 != std::string::npos) {
+                        coloredText = text.substr(textStart, resetPos2 - textStart);
+                        pos = resetPos2 + 2; // skip |r
+                    } else {
+                        coloredText = text.substr(textStart);
+                        pos = text.size();
+                    }
+                    // Strip any remaining WoW markup from the colored segment
+                    // (e.g. |H...|h pairs that aren't item links)
+                    std::string clean;
+                    for (size_t i = 0; i < coloredText.size(); i++) {
+                        if (coloredText[i] == '|' && i + 1 < coloredText.size()) {
+                            char next = coloredText[i + 1];
+                            if (next == 'H') {
+                                // Skip |H...|h
+                                size_t hEnd = coloredText.find("|h", i + 2);
+                                if (hEnd != std::string::npos) { i = hEnd + 1; continue; }
+                            } else if (next == 'h') {
+                                i += 1; continue; // skip |h
+                            } else if (next == 'r') {
+                                i += 1; continue; // skip |r
+                            }
+                        }
+                        clean += coloredText[i];
+                    }
+                    if (!clean.empty()) {
+                        ImGui::PushStyleColor(ImGuiCol_Text, cColor);
+                        ImGui::TextWrapped("%s", clean.c_str());
+                        ImGui::PopStyleColor();
+                        ImGui::SameLine(0, 0);
+                    }
+                } else {
+                    // Bare |c without enough chars for color — render literally
+                    ImGui::PushStyleColor(ImGuiCol_Text, color);
+                    ImGui::TextWrapped("|c");
+                    ImGui::PopStyleColor();
+                    ImGui::SameLine(0, 0);
+                    pos = nextSpecial + 2;
+                }
+                continue;
+            }
+
+            // Handle URL
+            if (nextSpecial == urlStart) {
+                size_t urlEnd = text.find_first_of(" \t\n\r", urlStart);
+                if (urlEnd == std::string::npos) urlEnd = text.size();
+                std::string url = text.substr(urlStart, urlEnd - urlStart);
+
+                ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.4f, 0.7f, 1.0f, 1.0f));
+                ImGui::TextWrapped("%s", url.c_str());
+                if (ImGui::IsItemHovered()) {
+                    ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
+                    ImGui::SetTooltip("Open: %s", url.c_str());
+                }
+                if (ImGui::IsItemClicked()) {
+                    std::string cmd = "xdg-open '" + url + "' &";
+                    [[maybe_unused]] int result = system(cmd.c_str());
+                }
+                ImGui::PopStyleColor();
+
+                pos = urlEnd;
+                continue;
+            }
+        }
+    };
+
+    for (const auto& msg : chatHistory) {
+        if (!shouldShowMessage(msg, activeChatTab_)) continue;
+        std::string processedMessage = replaceGenderPlaceholders(msg.message, gameHandler);
+
+        ImVec4 color = getChatTypeColor(msg.type);
+
+        // Optional timestamp prefix
+        std::string tsPrefix;
+        if (chatShowTimestamps_) {
+            auto tt = std::chrono::system_clock::to_time_t(msg.timestamp);
+            std::tm tm{};
+#ifdef _WIN32
+            localtime_s(&tm, &tt);
+#else
+            localtime_r(&tt, &tm);
+#endif
+            char tsBuf[16];
+            snprintf(tsBuf, sizeof(tsBuf), "[%02d:%02d] ", tm.tm_hour, tm.tm_min);
+            tsPrefix = tsBuf;
+        }
+
+        if (msg.type == game::ChatType::SYSTEM) {
+            renderTextWithLinks(tsPrefix + processedMessage, color);
+        } else if (msg.type == game::ChatType::TEXT_EMOTE) {
+            renderTextWithLinks(tsPrefix + processedMessage, color);
+        } else if (!msg.senderName.empty()) {
+            if (msg.type == game::ChatType::MONSTER_SAY || msg.type == game::ChatType::MONSTER_PARTY) {
+                std::string fullMsg = tsPrefix + msg.senderName + " says: " + processedMessage;
+                renderTextWithLinks(fullMsg, color);
+            } else if (msg.type == game::ChatType::MONSTER_YELL) {
+                std::string fullMsg = tsPrefix + msg.senderName + " yells: " + processedMessage;
+                renderTextWithLinks(fullMsg, color);
+            } else if (msg.type == game::ChatType::MONSTER_WHISPER || msg.type == game::ChatType::RAID_BOSS_WHISPER) {
+                std::string fullMsg = tsPrefix + msg.senderName + " whispers: " + processedMessage;
+                renderTextWithLinks(fullMsg, color);
+            } else if (msg.type == game::ChatType::MONSTER_EMOTE || msg.type == game::ChatType::RAID_BOSS_EMOTE) {
+                std::string fullMsg = tsPrefix + msg.senderName + " " + processedMessage;
+                renderTextWithLinks(fullMsg, color);
+            } else if (msg.type == game::ChatType::CHANNEL && !msg.channelName.empty()) {
+                int chIdx = gameHandler.getChannelIndex(msg.channelName);
+                std::string chDisplay = chIdx > 0
+                    ? "[" + std::to_string(chIdx) + ". " + msg.channelName + "]"
+                    : "[" + msg.channelName + "]";
+                std::string fullMsg = tsPrefix + chDisplay + " [" + msg.senderName + "]: " + processedMessage;
+                renderTextWithLinks(fullMsg, color);
+            } else {
+                std::string fullMsg = tsPrefix + "[" + std::string(getChatTypeName(msg.type)) + "] " + msg.senderName + ": " + processedMessage;
+                renderTextWithLinks(fullMsg, color);
+            }
+        } else {
+            std::string fullMsg = tsPrefix + "[" + std::string(getChatTypeName(msg.type)) + "] " + processedMessage;
+            renderTextWithLinks(fullMsg, color);
+        }
+    }
+
+    // Auto-scroll to bottom
+    if (ImGui::GetScrollY() >= ImGui::GetScrollMaxY()) {
+        ImGui::SetScrollHereY(1.0f);
+    }
+
+    ImGui::EndChild();
+
+    // Reset font scale after chat history
+    ImGui::SetWindowFontScale(1.0f);
+
+    ImGui::Spacing();
+    ImGui::Separator();
+    ImGui::Spacing();
+    // Lock toggle
+    ImGui::Checkbox("Lock", &chatWindowLocked);
+    ImGui::SameLine();
+    ImGui::TextDisabled(chatWindowLocked ? "(locked)" : "(movable)");
+
+    // Chat input
+    ImGui::Text("Type:");
+    ImGui::SameLine();
+    ImGui::SetNextItemWidth(100);
+    const char* chatTypes[] = { "SAY", "YELL", "PARTY", "GUILD", "WHISPER", "RAID", "OFFICER", "BATTLEGROUND", "RAID WARNING", "INSTANCE" };
+    ImGui::Combo("##ChatType", &selectedChatType, chatTypes, 10);
+
+    // Auto-fill whisper target when switching to WHISPER mode
+    if (selectedChatType == 4 && lastChatType != 4) {
+        // Just switched to WHISPER mode
+        if (gameHandler.hasTarget()) {
+            auto target = gameHandler.getTarget();
+            if (target && target->getType() == game::ObjectType::PLAYER) {
+                auto player = std::static_pointer_cast<game::Player>(target);
+                if (!player->getName().empty()) {
+                    strncpy(whisperTargetBuffer, player->getName().c_str(), sizeof(whisperTargetBuffer) - 1);
+                    whisperTargetBuffer[sizeof(whisperTargetBuffer) - 1] = '\0';
+                }
+            }
+        }
+    }
+    lastChatType = selectedChatType;
+
+    // Show whisper target field if WHISPER is selected
+    if (selectedChatType == 4) {
+        ImGui::SameLine();
+        ImGui::Text("To:");
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth(120);
+        ImGui::InputText("##WhisperTarget", whisperTargetBuffer, sizeof(whisperTargetBuffer));
+    }
+
+    ImGui::SameLine();
+    ImGui::Text("Message:");
+    ImGui::SameLine();
+
+    ImGui::SetNextItemWidth(-1);
+    if (refocusChatInput) {
+        ImGui::SetKeyboardFocusHere();
+        refocusChatInput = false;
+    }
+
+    // Detect chat channel prefix as user types and switch the dropdown
+    {
+        std::string buf(chatInputBuffer);
+        if (buf.size() >= 2 && buf[0] == '/') {
+            // Find the command and check if there's a space after it
+            size_t sp = buf.find(' ', 1);
+            if (sp != std::string::npos) {
+                std::string cmd = buf.substr(1, sp - 1);
+                for (char& c : cmd) c = std::tolower(c);
+                int detected = -1;
+                if (cmd == "s" || cmd == "say") detected = 0;
+                else if (cmd == "y" || cmd == "yell" || cmd == "shout") detected = 1;
+                else if (cmd == "p" || cmd == "party") detected = 2;
+                else if (cmd == "g" || cmd == "guild") detected = 3;
+                else if (cmd == "w" || cmd == "whisper" || cmd == "tell" || cmd == "t") detected = 4;
+                else if (cmd == "raid" || cmd == "rsay" || cmd == "ra") detected = 5;
+                else if (cmd == "o" || cmd == "officer" || cmd == "osay") detected = 6;
+                else if (cmd == "bg" || cmd == "battleground") detected = 7;
+                else if (cmd == "rw" || cmd == "raidwarning") detected = 8;
+                else if (cmd == "i" || cmd == "instance") detected = 9;
+                if (detected >= 0 && selectedChatType != detected) {
+                    selectedChatType = detected;
+                    // Strip the prefix, keep only the message part
+                    std::string remaining = buf.substr(sp + 1);
+                    // For whisper, first word after /w is the target
+                    if (detected == 4) {
+                        size_t msgStart = remaining.find(' ');
+                        if (msgStart != std::string::npos) {
+                            std::string wTarget = remaining.substr(0, msgStart);
+                            strncpy(whisperTargetBuffer, wTarget.c_str(), sizeof(whisperTargetBuffer) - 1);
+                            whisperTargetBuffer[sizeof(whisperTargetBuffer) - 1] = '\0';
+                            remaining = remaining.substr(msgStart + 1);
+                        } else {
+                            // Just the target name so far, no message yet
+                            strncpy(whisperTargetBuffer, remaining.c_str(), sizeof(whisperTargetBuffer) - 1);
+                            whisperTargetBuffer[sizeof(whisperTargetBuffer) - 1] = '\0';
+                            remaining = "";
+                        }
+                    }
+                    strncpy(chatInputBuffer, remaining.c_str(), sizeof(chatInputBuffer) - 1);
+                    chatInputBuffer[sizeof(chatInputBuffer) - 1] = '\0';
+                    chatInputMoveCursorToEnd = true;
+                }
+            }
+        }
+    }
+
+    // Color the input text based on current chat type
+    ImVec4 inputColor;
+    switch (selectedChatType) {
+        case 1: inputColor = ImVec4(1.0f, 0.3f, 0.3f, 1.0f); break;  // YELL - red
+        case 2: inputColor = ImVec4(0.4f, 0.6f, 1.0f, 1.0f); break;  // PARTY - blue
+        case 3: inputColor = ImVec4(0.3f, 1.0f, 0.3f, 1.0f); break;  // GUILD - green
+        case 4: inputColor = ImVec4(1.0f, 0.5f, 1.0f, 1.0f); break;  // WHISPER - pink
+        case 5: inputColor = ImVec4(1.0f, 0.5f, 0.0f, 1.0f); break;  // RAID - orange
+        case 6: inputColor = ImVec4(0.3f, 1.0f, 0.3f, 1.0f); break;  // OFFICER - green
+        case 7: inputColor = ImVec4(1.0f, 0.5f, 0.0f, 1.0f); break;  // BG - orange
+        case 8: inputColor = ImVec4(1.0f, 0.3f, 0.0f, 1.0f); break;  // RAID WARNING - red-orange
+        case 9: inputColor = ImVec4(0.4f, 0.6f, 1.0f, 1.0f); break;  // INSTANCE - blue
+        default: inputColor = ImVec4(1.0f, 1.0f, 1.0f, 1.0f); break; // SAY - white
+    }
+    ImGui::PushStyleColor(ImGuiCol_Text, inputColor);
+
+    auto inputCallback = [](ImGuiInputTextCallbackData* data) -> int {
+        auto* self = static_cast<GameScreen*>(data->UserData);
+        if (self && self->chatInputMoveCursorToEnd) {
+            int len = static_cast<int>(std::strlen(data->Buf));
+            data->CursorPos = len;
+            data->SelectionStart = len;
+            data->SelectionEnd = len;
+            self->chatInputMoveCursorToEnd = false;
+        }
+        return 0;
+    };
+
+    ImGuiInputTextFlags inputFlags = ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_CallbackAlways;
+    if (ImGui::InputText("##ChatInput", chatInputBuffer, sizeof(chatInputBuffer), inputFlags, inputCallback, this)) {
+        sendChatMessage(gameHandler);
+        // Close chat input on send so movement keys work immediately.
+        refocusChatInput = false;
+        ImGui::ClearActiveID();
+    }
+    ImGui::PopStyleColor();
+
+    if (ImGui::IsItemActive()) {
+        chatInputActive = true;
+    } else {
+        chatInputActive = false;
+    }
+
+    // Click in chat history area (received messages) → focus input.
+    {
+        if (chatHistoryHovered && ImGui::IsMouseClicked(0)) {
+            refocusChatInput = true;
+        }
+    }
+
+    ImGui::End();
+}
+
 void GameScreen::processTargetInput(game::GameHandler& gameHandler) {
     auto& io = ImGui::GetIO();
     auto& input = core::Input::getInstance();
 
-    // If the user is typing (or about to focus chat this frame), do not allow
-    // A-Z or 1-0 shortcuts to fire.
-    if (!io.WantTextInput && !chatPanel_.isChatInputActive() && input.isKeyJustPressed(SDL_SCANCODE_SLASH)) {
-        chatPanel_.activateSlashInput();
-    }
-    if (!io.WantTextInput && !chatPanel_.isChatInputActive() &&
-        KeybindingManager::getInstance().isActionPressed(KeybindingManager::Action::TOGGLE_CHAT, true)) {
-        chatPanel_.activateInput();
-    }
-
-    const bool textFocus = chatPanel_.isChatInputActive() || io.WantTextInput;
-
     // Tab targeting (when keyboard not captured by UI)
     if (!io.WantCaptureKeyboard) {
-        // When typing in chat (or any text input), never treat keys as gameplay/UI shortcuts.
-        if (!textFocus && input.isKeyJustPressed(SDL_SCANCODE_TAB)) {
+        if (input.isKeyJustPressed(SDL_SCANCODE_TAB)) {
             const auto& movement = gameHandler.getMovementInfo();
             gameHandler.tabTarget(movement.x, movement.y, movement.z);
         }
 
-        if (KeybindingManager::getInstance().isActionPressed(KeybindingManager::Action::TOGGLE_SETTINGS, true)) {
-            if (settingsPanel_.showSettingsWindow) {
-                settingsPanel_.showSettingsWindow = false;
-            } else if (windowManager_.showEscapeMenu) {
-                windowManager_.showEscapeMenu = false;
-                settingsPanel_.showEscapeSettingsNotice = false;
+        if (input.isKeyJustPressed(SDL_SCANCODE_ESCAPE)) {
+            if (showSettingsWindow) {
+                // Close settings window if open
+                showSettingsWindow = false;
+            } else if (showEscapeMenu) {
+                showEscapeMenu = false;
+                showEscapeSettingsNotice = false;
             } else if (gameHandler.isCasting()) {
                 gameHandler.cancelCast();
             } else if (gameHandler.isLootWindowOpen()) {
                 gameHandler.closeLoot();
             } else if (gameHandler.isGossipWindowOpen()) {
                 gameHandler.closeGossip();
-            } else if (gameHandler.isVendorWindowOpen()) {
-                gameHandler.closeVendor();
-            } else if (gameHandler.isBarberShopOpen()) {
-                gameHandler.closeBarberShop();
-            } else if (gameHandler.isBankOpen()) {
-                gameHandler.closeBank();
-            } else if (gameHandler.isTrainerWindowOpen()) {
-                gameHandler.closeTrainer();
-            } else if (gameHandler.isMailboxOpen()) {
-                gameHandler.closeMailbox();
-            } else if (gameHandler.isAuctionHouseOpen()) {
-                gameHandler.closeAuctionHouse();
-            } else if (gameHandler.isQuestDetailsOpen()) {
-                gameHandler.declineQuest();
-            } else if (gameHandler.isQuestOfferRewardOpen()) {
-                gameHandler.closeQuestOfferReward();
-            } else if (gameHandler.isQuestRequestItemsOpen()) {
-                gameHandler.closeQuestRequestItems();
-            } else if (gameHandler.isTradeOpen()) {
-                gameHandler.cancelTrade();
-            } else if (socialPanel_.showWhoWindow_) {
-                socialPanel_.showWhoWindow_ = false;
-            } else if (combatUI_.showCombatLog_) {
-                combatUI_.showCombatLog_ = false;
-            } else if (socialPanel_.showSocialFrame_) {
-                socialPanel_.showSocialFrame_ = false;
-            } else if (talentScreen.isOpen()) {
-                talentScreen.setOpen(false);
-            } else if (spellbookScreen.isOpen()) {
-                spellbookScreen.setOpen(false);
-            } else if (questLogScreen.isOpen()) {
-                questLogScreen.setOpen(false);
-            } else if (inventoryScreen.isCharacterOpen()) {
-                inventoryScreen.toggleCharacter();
-            } else if (inventoryScreen.isOpen()) {
-                inventoryScreen.setOpen(false);
-            } else if (showWorldMap_) {
-                showWorldMap_ = false;
             } else {
-                windowManager_.showEscapeMenu = true;
+                showEscapeMenu = true;
             }
         }
 
-        if (!textFocus) {
-            // Toggle character screen (C) and inventory/bags (I)
-            if (KeybindingManager::getInstance().isActionPressed(KeybindingManager::Action::TOGGLE_CHARACTER_SCREEN)) {
-                const bool wasOpen = inventoryScreen.isCharacterOpen();
-                inventoryScreen.toggleCharacter();
-                if (!wasOpen && gameHandler.isConnected()) {
-                    gameHandler.requestPlayedTime();
-                }
-            }
+        // V — toggle nameplates (WoW default keybinding)
+        if (input.isKeyJustPressed(SDL_SCANCODE_V)) {
+            showNameplates_ = !showNameplates_;
+        }
 
-            if (KeybindingManager::getInstance().isActionPressed(KeybindingManager::Action::TOGGLE_INVENTORY)) {
-                inventoryScreen.toggle();
-            }
-
-            if (KeybindingManager::getInstance().isActionPressed(KeybindingManager::Action::TOGGLE_NAMEPLATES)) {
-                if (ImGui::GetIO().KeyShift)
-                    settingsPanel_.showFriendlyNameplates_ = !settingsPanel_.showFriendlyNameplates_;
-                else
-                    showNameplates_ = !showNameplates_;
-            }
-
-            if (KeybindingManager::getInstance().isActionPressed(KeybindingManager::Action::TOGGLE_WORLD_MAP)) {
-                showWorldMap_ = !showWorldMap_;
-            }
-
-            if (KeybindingManager::getInstance().isActionPressed(KeybindingManager::Action::TOGGLE_MINIMAP)) {
-                showMinimap_ = !showMinimap_;
-            }
-
-            if (KeybindingManager::getInstance().isActionPressed(KeybindingManager::Action::TOGGLE_RAID_FRAMES)) {
-                socialPanel_.showRaidFrames_ = !socialPanel_.showRaidFrames_;
-            }
-
-            if (KeybindingManager::getInstance().isActionPressed(KeybindingManager::Action::TOGGLE_ACHIEVEMENTS)) {
-                windowManager_.showAchievementWindow_ = !windowManager_.showAchievementWindow_;
-            }
-            if (KeybindingManager::getInstance().isActionPressed(KeybindingManager::Action::TOGGLE_SKILLS)) {
-                windowManager_.showSkillsWindow_ = !windowManager_.showSkillsWindow_;
-            }
-
-            // Toggle Titles window with H (hero/title screen — no conflicting keybinding)
-            if (input.isKeyJustPressed(SDL_SCANCODE_H) && !ImGui::GetIO().WantCaptureKeyboard) {
-                windowManager_.showTitlesWindow_ = !windowManager_.showTitlesWindow_;
-            }
-
-            // Screenshot (PrintScreen key)
-            if (input.isKeyJustPressed(SDL_SCANCODE_PRINTSCREEN)) {
-                takeScreenshot(gameHandler);
-            }
-
-            // Action bar keys (1-9, 0, -, =)
-            static const SDL_Scancode actionBarKeys[] = {
-                SDL_SCANCODE_1, SDL_SCANCODE_2, SDL_SCANCODE_3, SDL_SCANCODE_4,
-                SDL_SCANCODE_5, SDL_SCANCODE_6, SDL_SCANCODE_7, SDL_SCANCODE_8,
-                SDL_SCANCODE_9, SDL_SCANCODE_0, SDL_SCANCODE_MINUS, SDL_SCANCODE_EQUALS
-            };
-            const bool shiftDown = input.isKeyPressed(SDL_SCANCODE_LSHIFT) || input.isKeyPressed(SDL_SCANCODE_RSHIFT);
-            const bool ctrlDown  = input.isKeyPressed(SDL_SCANCODE_LCTRL)  || input.isKeyPressed(SDL_SCANCODE_RCTRL);
-            const auto& bar = gameHandler.getActionBar();
-
-            // Ctrl+1..Ctrl+8 → switch stance/form/presence (WoW default bindings).
-            // Only fires for classes that use a stance bar; same slot ordering as
-            // renderStanceBar: Warrior, DK, Druid, Rogue, Priest.
-            if (ctrlDown) {
-                static const uint32_t warriorStances[]  = { 2457, 71, 2458 };
-                static const uint32_t dkPresences[]     = { 48266, 48263, 48265 };
-                static const uint32_t druidForms[]      = { 5487, 9634, 768, 783, 1066, 24858, 33891, 33943, 40120 };
-                static const uint32_t rogueForms[]      = { 1784 };
-                static const uint32_t priestForms[]     = { 15473 };
-                const uint32_t* stArr = nullptr; int stCnt = 0;
-                switch (gameHandler.getPlayerClass()) {
-                    case 1:  stArr = warriorStances; stCnt = 3; break;
-                    case 6:  stArr = dkPresences;    stCnt = 3; break;
-                    case 11: stArr = druidForms;     stCnt = 9; break;
-                    case 4:  stArr = rogueForms;     stCnt = 1; break;
-                    case 5:  stArr = priestForms;    stCnt = 1; break;
-                }
-                if (stArr) {
-                    const auto& known = gameHandler.getKnownSpells();
-                    // Build available list (same order as UI)
-                    std::vector<uint32_t> avail;
-                    avail.reserve(stCnt);
-                    for (int i = 0; i < stCnt; ++i)
-                        if (known.count(stArr[i])) avail.push_back(stArr[i]);
-                    // Ctrl+1 = first stance, Ctrl+2 = second, …
-                    for (int i = 0; i < static_cast<int>(avail.size()) && i < 8; ++i) {
-                        if (input.isKeyJustPressed(actionBarKeys[i]))
-                            gameHandler.castSpell(avail[i]);
-                    }
-                }
-            }
-
-            for (int i = 0; i < game::GameHandler::SLOTS_PER_BAR; ++i) {
-                if (!ctrlDown && input.isKeyJustPressed(actionBarKeys[i])) {
-                    int slotIdx = shiftDown ? (game::GameHandler::SLOTS_PER_BAR + i) : i;
-                    if (bar[slotIdx].type == game::ActionBarSlot::SPELL && bar[slotIdx].isReady()) {
-                        uint64_t target = gameHandler.hasTarget() ? gameHandler.getTargetGuid() : 0;
-                        gameHandler.castSpell(bar[slotIdx].id, target);
-                    } else if (bar[slotIdx].type == game::ActionBarSlot::ITEM && bar[slotIdx].id != 0) {
-                        gameHandler.useItemById(bar[slotIdx].id);
-                    } else if (bar[slotIdx].type == game::ActionBarSlot::MACRO) {
-                        chatPanel_.executeMacroText(gameHandler, inventoryScreen, spellbookScreen, questLogScreen, gameHandler.getMacroText(bar[slotIdx].id));
-                    }
+        // Action bar keys (1-9, 0, -, =)
+        static const SDL_Scancode actionBarKeys[] = {
+            SDL_SCANCODE_1, SDL_SCANCODE_2, SDL_SCANCODE_3, SDL_SCANCODE_4,
+            SDL_SCANCODE_5, SDL_SCANCODE_6, SDL_SCANCODE_7, SDL_SCANCODE_8,
+            SDL_SCANCODE_9, SDL_SCANCODE_0, SDL_SCANCODE_MINUS, SDL_SCANCODE_EQUALS
+        };
+        for (int i = 0; i < 12; ++i) {
+            if (input.isKeyJustPressed(actionBarKeys[i])) {
+                const auto& bar = gameHandler.getActionBar();
+                if (bar[i].type == game::ActionBarSlot::SPELL && bar[i].isReady()) {
+                    uint64_t target = gameHandler.hasTarget() ? gameHandler.getTargetGuid() : 0;
+                    gameHandler.castSpell(bar[i].id, target);
+                } else if (bar[i].type == game::ActionBarSlot::ITEM && bar[i].id != 0) {
+                    gameHandler.useItemById(bar[i].id);
                 }
             }
         }
 
     }
 
-    // Cursor affordance: show hand cursor over interactable entities.
+    // Slash key: focus chat input — always works unless already typing in chat
+    if (!chatInputActive && input.isKeyJustPressed(SDL_SCANCODE_SLASH)) {
+        refocusChatInput = true;
+        chatInputBuffer[0] = '/';
+        chatInputBuffer[1] = '\0';
+        chatInputMoveCursorToEnd = true;
+    }
+
+    // Enter key: focus chat input (empty) — always works unless already typing
+    if (!chatInputActive && input.isKeyJustPressed(SDL_SCANCODE_RETURN)) {
+        refocusChatInput = true;
+    }
+
+    // Cursor affordance: show hand cursor over interactable game objects.
     if (!io.WantCaptureMouse) {
-        auto* renderer = services_.renderer;
+        auto* renderer = core::Application::getInstance().getRenderer();
         auto* camera = renderer ? renderer->getCamera() : nullptr;
-        auto* window = services_.window;
+        auto* window = core::Application::getInstance().getWindow();
         if (camera && window) {
             glm::vec2 mousePos = input.getMousePosition();
             float screenW = static_cast<float>(window->getWidth());
             float screenH = static_cast<float>(window->getHeight());
             rendering::Ray ray = camera->screenToWorldRay(mousePos.x, mousePos.y, screenW, screenH);
             float closestT = 1e30f;
-            bool hoverInteractable = false;
+            bool hoverInteractableGo = false;
             for (const auto& [guid, entity] : gameHandler.getEntityManager().getEntities()) {
-                bool isGo   = (entity->getType() == game::ObjectType::GAMEOBJECT);
-                bool isUnit = (entity->getType() == game::ObjectType::UNIT);
-                bool isPlayer = (entity->getType() == game::ObjectType::PLAYER);
-                if (!isGo && !isUnit && !isPlayer) continue;
-                if (guid == gameHandler.getPlayerGuid()) continue; // skip self
+                if (entity->getType() != game::ObjectType::GAMEOBJECT) continue;
 
                 glm::vec3 hitCenter;
                 float hitRadius = 0.0f;
                 bool hasBounds = core::Application::getInstance().getRenderBoundsForGuid(guid, hitCenter, hitRadius);
                 if (!hasBounds) {
-                    hitRadius = isGo ? 2.5f : 1.8f;
+                    hitRadius = 2.5f;
                     hitCenter = core::coords::canonicalToRender(glm::vec3(entity->getX(), entity->getY(), entity->getZ()));
-                    hitCenter.z += isGo ? 1.2f : 1.0f;
+                    hitCenter.z += 1.2f;
                 } else {
                     hitRadius = std::max(hitRadius * 1.1f, 0.8f);
                 }
@@ -1129,10 +1471,10 @@ void GameScreen::processTargetInput(game::GameHandler& gameHandler) {
                 float hitT;
                 if (raySphereIntersect(ray, hitCenter, hitRadius, hitT) && hitT < closestT) {
                     closestT = hitT;
-                    hoverInteractable = true;
+                    hoverInteractableGo = true;
                 }
             }
-            if (hoverInteractable) {
+            if (hoverInteractableGo) {
                 ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
             }
         }
@@ -1149,14 +1491,13 @@ void GameScreen::processTargetInput(game::GameHandler& gameHandler) {
     if (leftClickWasPress_ && input.isMouseButtonJustReleased(SDL_BUTTON_LEFT)) {
         leftClickWasPress_ = false;
         glm::vec2 releasePos = input.getMousePosition();
-        glm::vec2 dragDelta = releasePos - leftClickPressPos_;
-        float dragDistSq = glm::dot(dragDelta, dragDelta);
+        float dragDist = glm::length(releasePos - leftClickPressPos_);
         constexpr float CLICK_THRESHOLD = 5.0f;  // pixels
 
-        if (dragDistSq < CLICK_THRESHOLD * CLICK_THRESHOLD) {
-            auto* renderer = services_.renderer;
+        if (dragDist < CLICK_THRESHOLD) {
+            auto* renderer = core::Application::getInstance().getRenderer();
             auto* camera = renderer ? renderer->getCamera() : nullptr;
-            auto* window = services_.window;
+            auto* window = core::Application::getInstance().getWindow();
 
             if (camera && window) {
                 float screenW = static_cast<float>(window->getWidth());
@@ -1241,8 +1582,6 @@ void GameScreen::processTargetInput(game::GameHandler& gameHandler) {
         if (gameHandler.hasTarget()) {
             auto target = gameHandler.getTarget();
             if (target && target->getType() == game::ObjectType::GAMEOBJECT) {
-                LOG_WARNING("[GO-DIAG] Right-click: re-interacting with targeted GO 0x",
-                            std::hex, target->getGuid(), std::dec);
                 gameHandler.setTarget(target->getGuid());
                 gameHandler.interactWithGameObject(target->getGuid());
                 return;
@@ -1251,29 +1590,10 @@ void GameScreen::processTargetInput(game::GameHandler& gameHandler) {
 
         // If no target or right-clicking in world, try to pick one under cursor
         {
-            auto* renderer = services_.renderer;
+            auto* renderer = core::Application::getInstance().getRenderer();
             auto* camera = renderer ? renderer->getCamera() : nullptr;
-            auto* window = services_.window;
+            auto* window = core::Application::getInstance().getWindow();
             if (camera && window) {
-                // If a quest objective gameobject is under the cursor, prefer it over
-                // hostile units so quest pickups (e.g. "Bundle of Wood") are reliable.
-                std::unordered_set<uint32_t> questObjectiveGoEntries;
-                {
-                    const auto& ql = gameHandler.getQuestLog();
-                    questObjectiveGoEntries.reserve(32);
-                    for (const auto& q : ql) {
-                        if (q.complete) continue;
-                        for (const auto& obj : q.killObjectives) {
-                            if (obj.npcOrGoId >= 0 || obj.required == 0) continue;
-                            uint32_t entry = static_cast<uint32_t>(-obj.npcOrGoId);
-                            uint32_t cur = 0;
-                            auto it = q.killCounts.find(entry);
-                            if (it != q.killCounts.end()) cur = it->second.first;
-                            if (cur < obj.required) questObjectiveGoEntries.insert(entry);
-                        }
-                    }
-                }
-
                 glm::vec2 mousePos = input.getMousePosition();
                 float screenW = static_cast<float>(window->getWidth());
                 float screenH = static_cast<float>(window->getHeight());
@@ -1283,19 +1603,13 @@ void GameScreen::processTargetInput(game::GameHandler& gameHandler) {
                 game::ObjectType closestType = game::ObjectType::OBJECT;
                 float closestHostileUnitT = 1e30f;
                 uint64_t closestHostileUnitGuid = 0;
-                float closestQuestGoT = 1e30f;
-                uint64_t closestQuestGoGuid = 0;
-                float closestGoT = 1e30f;
-                uint64_t closestGoGuid = 0;
                 const uint64_t myGuid = gameHandler.getPlayerGuid();
                 for (const auto& [guid, entity] : gameHandler.getEntityManager().getEntities()) {
                     auto t = entity->getType();
                     if (t != game::ObjectType::UNIT &&
                         t != game::ObjectType::PLAYER &&
-                        t != game::ObjectType::GAMEOBJECT)
-                        continue;
+                        t != game::ObjectType::GAMEOBJECT) continue;
                     if (guid == myGuid) continue;
-
                     glm::vec3 hitCenter;
                     float hitRadius = 0.0f;
                     bool hasBounds = core::Application::getInstance().getRenderBoundsForGuid(guid, hitCenter, hitRadius);
@@ -1309,28 +1623,18 @@ void GameScreen::processTargetInput(game::GameHandler& gameHandler) {
                                 heightOffset = 0.3f;
                             }
                         } else if (t == game::ObjectType::GAMEOBJECT) {
+                            // Do not hard-filter by GO type here. Some realms/content
+                            // classify usable objects (including some chests) with types
+                            // that look decorative in cache data.
                             hitRadius = 2.5f;
                             heightOffset = 1.2f;
                         }
                         hitCenter = core::coords::canonicalToRender(
                             glm::vec3(entity->getX(), entity->getY(), entity->getZ()));
                         hitCenter.z += heightOffset;
-                        // Log each unique GO's raypick position once
-                        if (t == game::ObjectType::GAMEOBJECT) {
-                            static std::unordered_set<uint64_t> goPickLog;
-                            if (goPickLog.insert(guid).second) {
-                                auto go = std::static_pointer_cast<game::GameObject>(entity);
-                                LOG_WARNING("[GO-DIAG] Raypick GO: guid=0x", std::hex, guid, std::dec,
-                                            " entry=", go->getEntry(), " name='", go->getName(),
-                                            "' pos=(", entity->getX(), ",", entity->getY(), ",", entity->getZ(),
-                                            ") center=(", hitCenter.x, ",", hitCenter.y, ",", hitCenter.z,
-                                            ") r=", hitRadius);
-                            }
-                        }
                     } else {
                         hitRadius = std::max(hitRadius * 1.1f, 0.6f);
                     }
-
                     float hitT;
                     if (raySphereIntersect(ray, hitCenter, hitRadius, hitT)) {
                         if (t == game::ObjectType::UNIT) {
@@ -1341,21 +1645,6 @@ void GameScreen::processTargetInput(game::GameHandler& gameHandler) {
                                 closestHostileUnitGuid = guid;
                             }
                         }
-                        if (t == game::ObjectType::GAMEOBJECT) {
-                            if (hitT < closestGoT) {
-                                closestGoT = hitT;
-                                closestGoGuid = guid;
-                            }
-                            if (!questObjectiveGoEntries.empty()) {
-                                auto go = std::static_pointer_cast<game::GameObject>(entity);
-                                if (questObjectiveGoEntries.count(go->getEntry())) {
-                                    if (hitT < closestQuestGoT) {
-                                        closestQuestGoT = hitT;
-                                        closestQuestGoGuid = guid;
-                                    }
-                                }
-                            }
-                        }
                         if (hitT < closestT) {
                             closestT = hitT;
                             closestGuid = guid;
@@ -1363,32 +1652,13 @@ void GameScreen::processTargetInput(game::GameHandler& gameHandler) {
                         }
                     }
                 }
-
-                // Priority: quest GO > closer of (GO, hostile unit) > closest anything.
-                if (closestQuestGoGuid != 0) {
-                    closestGuid = closestQuestGoGuid;
-                    closestType = game::ObjectType::GAMEOBJECT;
-                } else if (closestGoGuid != 0 && closestHostileUnitGuid != 0) {
-                    // Both a GO and hostile unit were hit — prefer whichever is closer.
-                    if (closestGoT <= closestHostileUnitT) {
-                        closestGuid = closestGoGuid;
-                        closestType = game::ObjectType::GAMEOBJECT;
-                    } else {
-                        closestGuid = closestHostileUnitGuid;
-                        closestType = game::ObjectType::UNIT;
-                    }
-                } else if (closestGoGuid != 0) {
-                    closestGuid = closestGoGuid;
-                    closestType = game::ObjectType::GAMEOBJECT;
-                } else if (closestHostileUnitGuid != 0) {
+                // Prefer hostile monsters over nearby gameobjects/others when right-click picking.
+                if (closestHostileUnitGuid != 0) {
                     closestGuid = closestHostileUnitGuid;
                     closestType = game::ObjectType::UNIT;
                 }
-
                 if (closestGuid != 0) {
                     if (closestType == game::ObjectType::GAMEOBJECT) {
-                        LOG_WARNING("[GO-DIAG] Right-click: raypick hit GO 0x",
-                                    std::hex, closestGuid, std::dec);
                         gameHandler.setTarget(closestGuid);
                         gameHandler.interactWithGameObject(closestGuid);
                         return;
@@ -1453,9 +1723,9 @@ void GameScreen::renderPlayerFrame(game::GameHandler& gameHandler) {
     const bool inCombatConfirmed = gameHandler.isInCombat();
     const bool attackIntentOnly = gameHandler.hasAutoAttackIntent() && !inCombatConfirmed;
     ImVec4 playerBorder = isDead
-        ? kColorDarkGray
+        ? ImVec4(0.5f, 0.5f, 0.5f, 1.0f)
         : (inCombatConfirmed
-            ? colors::kBrightRed
+            ? ImVec4(1.0f, 0.2f, 0.2f, 1.0f)
             : (attackIntentOnly
                 ? ImVec4(1.0f, 0.7f, 0.2f, 1.0f)
                 : ImVec4(0.4f, 0.4f, 0.4f, 1.0f)));
@@ -1485,91 +1755,17 @@ void GameScreen::renderPlayerFrame(game::GameHandler& gameHandler) {
             playerHp = playerMaxHp;
         }
 
-        // Derive class color via shared helper
-        ImVec4 classColor = activeChar
-            ? classColorVec4(static_cast<uint8_t>(activeChar->characterClass))
-            : kColorBrightGreen;
-
-        // Name in class color — clickable for self-target, right-click for menu
-        ImGui::PushStyleColor(ImGuiCol_Text, classColor);
+        // Name in green (friendly player color) — clickable for self-target
+        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.3f, 1.0f, 0.3f, 1.0f));
         if (ImGui::Selectable(playerName.c_str(), false, 0, ImVec2(0, 0))) {
             gameHandler.setTarget(gameHandler.getPlayerGuid());
         }
-        if (ImGui::BeginPopupContextItem("PlayerSelfCtx")) {
-            ImGui::TextDisabled("%s", playerName.c_str());
-            ImGui::Separator();
-            if (ImGui::MenuItem("Open Character")) {
-                inventoryScreen.setCharacterOpen(true);
-            }
-            if (ImGui::MenuItem("Toggle PvP")) {
-                gameHandler.togglePvp();
-            }
-            ImGui::Separator();
-            bool afk = gameHandler.isAfk();
-            bool dnd = gameHandler.isDnd();
-            if (ImGui::MenuItem(afk ? "Cancel AFK" : "Set AFK")) {
-                gameHandler.toggleAfk();
-            }
-            if (ImGui::MenuItem(dnd ? "Cancel DND" : "Set DND")) {
-                gameHandler.toggleDnd();
-            }
-            if (gameHandler.isInGroup()) {
-                ImGui::Separator();
-                if (ImGui::MenuItem("Leave Group")) {
-                    gameHandler.leaveGroup();
-                }
-            }
-            ImGui::EndPopup();
-        }
         ImGui::PopStyleColor();
         ImGui::SameLine();
         ImGui::TextDisabled("Lv %u", playerLevel);
         if (isDead) {
             ImGui::SameLine();
-            ImGui::TextColored(colors::kDarkRed, "DEAD");
-        }
-        // Group leader crown on self frame when you lead the party/raid
-        if (gameHandler.isInGroup() &&
-            gameHandler.getPartyData().leaderGuid == gameHandler.getPlayerGuid()) {
-            ImGui::SameLine(0, 4);
-            ImGui::TextColored(colors::kSymbolGold, "\xe2\x99\x9b");
-            if (ImGui::IsItemHovered()) ImGui::SetTooltip("You are the group leader");
-        }
-        if (gameHandler.isAfk()) {
-            ImGui::SameLine();
-            ImGui::TextColored(ImVec4(0.8f, 0.8f, 0.3f, 1.0f), "<AFK>");
-            if (ImGui::IsItemHovered()) ImGui::SetTooltip("Away from keyboard — /afk to cancel");
-        } else if (gameHandler.isDnd()) {
-            ImGui::SameLine();
-            ImGui::TextColored(ImVec4(0.9f, 0.5f, 0.2f, 1.0f), "<DND>");
-            if (ImGui::IsItemHovered()) ImGui::SetTooltip("Do not disturb — /dnd to cancel");
-        }
-        if (auto* ren = services_.renderer) {
-            if (auto* cam = ren->getCameraController()) {
-                if (cam->isAutoRunning()) {
-                    ImGui::SameLine();
-                    ImGui::TextColored(ImVec4(0.4f, 0.9f, 1.0f, 1.0f), "[Auto-Run]");
-                    if (ImGui::IsItemHovered()) ImGui::SetTooltip("Auto-running — press ` or NumLock to stop");
-                }
-            }
-        }
-        if (inCombatConfirmed && !isDead) {
-            float combatPulse = 0.75f + 0.25f * std::sin(static_cast<float>(ImGui::GetTime()) * 4.0f);
-            ImGui::SameLine();
-            ImGui::TextColored(ImVec4(1.0f, 0.2f * combatPulse, 0.2f * combatPulse, 1.0f), "[Combat]");
-            if (ImGui::IsItemHovered()) ImGui::SetTooltip("You are in combat");
-        }
-
-        // Active title — shown in gold below the name/level line
-        {
-            int32_t titleBit = gameHandler.getChosenTitleBit();
-            if (titleBit >= 0) {
-                const std::string titleText = gameHandler.getFormattedTitle(
-                    static_cast<uint32_t>(titleBit));
-                if (!titleText.empty()) {
-                    ImGui::TextColored(ImVec4(1.0f, 0.84f, 0.0f, 0.9f), "%s", titleText.c_str());
-                }
-            }
+            ImGui::TextColored(ImVec4(0.9f, 0.2f, 0.2f, 1.0f), "DEAD");
         }
 
         // Try to get real HP/mana from the player entity
@@ -1582,21 +1778,9 @@ void GameScreen::renderPlayerFrame(game::GameHandler& gameHandler) {
             }
         }
 
-        // Health bar — color transitions green→yellow→red as HP drops
+        // Health bar
         float pct = static_cast<float>(playerHp) / static_cast<float>(playerMaxHp);
-        ImVec4 hpColor;
-        if (isDead) {
-            hpColor = kColorDarkGray;
-        } else if (pct > 0.5f) {
-            hpColor = colors::kHealthGreen;              // green
-        } else if (pct > 0.2f) {
-            float t = (pct - 0.2f) / 0.3f;  // 0 at 20%, 1 at 50%
-            hpColor = ImVec4(0.9f - 0.7f * t, 0.4f + 0.4f * t, 0.0f, 1.0f); // orange→yellow
-        } else {
-            // Critical — pulse red when < 20%
-            float pulse = 0.7f + 0.3f * std::sin(static_cast<float>(ImGui::GetTime()) * 3.5f);
-            hpColor = ImVec4(0.9f * pulse, 0.05f, 0.05f, 1.0f);    // pulsing red
-        }
+        ImVec4 hpColor = isDead ? ImVec4(0.5f, 0.5f, 0.5f, 1.0f) : ImVec4(0.2f, 0.8f, 0.2f, 1.0f);
         ImGui::PushStyleColor(ImGuiCol_PlotHistogram, hpColor);
         char overlay[64];
         snprintf(overlay, sizeof(overlay), "%u / %u", playerHp, playerMaxHp);
@@ -1616,23 +1800,14 @@ void GameScreen::renderPlayerFrame(game::GameHandler& gameHandler) {
                 float mpPct = static_cast<float>(power) / static_cast<float>(maxPower);
                 ImVec4 powerColor;
                 switch (powerType) {
-                    case 0: {
-                        // Mana: pulse desaturated blue when critically low (< 20%)
-                        if (mpPct < 0.2f) {
-                            float pulse = 0.6f + 0.4f * std::sin(static_cast<float>(ImGui::GetTime()) * 3.0f);
-                            powerColor = ImVec4(0.1f, 0.1f, 0.8f * pulse, 1.0f);
-                        } else {
-                            powerColor = colors::kManaBlue;
-                        }
-                        break;
-                    }
-                    case 1: powerColor = colors::kDarkRed; break; // Rage (red)
-                    case 2: powerColor = colors::kOrange; break; // Focus (orange)
-                    case 3: powerColor = colors::kEnergyYellow; break; // Energy (yellow)
-                    case 4: powerColor = colors::kHappinessGreen; break; // Happiness (green)
-                    case 6: powerColor = colors::kRunicRed; break; // Runic Power (crimson)
-                    case 7: powerColor = colors::kSoulShardPurple; break; // Soul Shards (purple)
-                    default: powerColor = colors::kManaBlue; break;
+                    case 0: powerColor = ImVec4(0.2f, 0.2f, 0.9f, 1.0f); break; // Mana (blue)
+                    case 1: powerColor = ImVec4(0.9f, 0.2f, 0.2f, 1.0f); break; // Rage (red)
+                    case 2: powerColor = ImVec4(0.9f, 0.6f, 0.1f, 1.0f); break; // Focus (orange)
+                    case 3: powerColor = ImVec4(0.9f, 0.9f, 0.2f, 1.0f); break; // Energy (yellow)
+                    case 4: powerColor = ImVec4(0.5f, 0.9f, 0.3f, 1.0f); break; // Happiness (green)
+                    case 6: powerColor = ImVec4(0.8f, 0.1f, 0.2f, 1.0f); break; // Runic Power (crimson)
+                    case 7: powerColor = ImVec4(0.4f, 0.1f, 0.6f, 1.0f); break; // Soul Shards (purple)
+                    default: powerColor = ImVec4(0.2f, 0.2f, 0.9f, 1.0f); break;
                 }
                 ImGui::PushStyleColor(ImGuiCol_PlotHistogram, powerColor);
                 char mpOverlay[64];
@@ -1691,159 +1866,7 @@ void GameScreen::renderPlayerFrame(game::GameHandler& gameHandler) {
             }
             ImGui::Dummy(ImVec2(totalW, squareH));
         }
-
-        // Combo point display — Rogue (4) and Druid (11) in Cat Form
-        {
-            uint8_t cls = gameHandler.getPlayerClass();
-            const bool isRogue  = (cls == 4);
-            const bool isDruid  = (cls == 11);
-            if (isRogue || isDruid) {
-                uint8_t cp = gameHandler.getComboPoints();
-                if (cp > 0 || isRogue) {  // always show for rogue; only when non-zero for druid
-                    ImGui::Spacing();
-                    ImVec2 cursor = ImGui::GetCursorScreenPos();
-                    float totalW  = ImGui::GetContentRegionAvail().x;
-                    constexpr int MAX_CP = 5;
-                    constexpr float DOT_R = 7.0f;
-                    constexpr float SPACING = 4.0f;
-                    float totalDotsW = MAX_CP * (DOT_R * 2.0f) + (MAX_CP - 1) * SPACING;
-                    float startX = cursor.x + (totalW - totalDotsW) * 0.5f;
-                    float cy = cursor.y + DOT_R;
-                    ImDrawList* dl = ImGui::GetWindowDrawList();
-                    for (int i = 0; i < MAX_CP; ++i) {
-                        float cx = startX + i * (DOT_R * 2.0f + SPACING) + DOT_R;
-                        ImU32 col = (i < static_cast<int>(cp))
-                            ? IM_COL32(255, 210, 0, 240)   // bright gold — active
-                            : IM_COL32(60,  60, 60, 160);  // dark — empty
-                        dl->AddCircleFilled(ImVec2(cx, cy), DOT_R, col);
-                        dl->AddCircle(ImVec2(cx, cy), DOT_R, IM_COL32(160, 140, 0, 180), 0, 1.5f);
-                    }
-                    ImGui::Dummy(ImVec2(totalW, DOT_R * 2.0f));
-                }
-            }
-        }
-
-        // Shaman totem bar (class 7) — 4 slots: Earth, Fire, Water, Air
-        if (gameHandler.getPlayerClass() == 7) {
-            static constexpr ImVec4 kTotemColors[] = {
-                ImVec4(0.80f, 0.55f, 0.25f, 1.0f), // Earth — brown
-                ImVec4(1.00f, 0.35f, 0.10f, 1.0f), // Fire  — orange-red
-                ImVec4(0.20f, 0.55f, 0.90f, 1.0f), // Water — blue
-                ImVec4(0.70f, 0.90f, 1.00f, 1.0f), // Air   — pale sky
-            };
-            static constexpr const char* kTotemNames[] = { "Earth", "Fire", "Water", "Air" };
-
-            ImGui::Spacing();
-            ImVec2 cursor = ImGui::GetCursorScreenPos();
-            float totalW  = ImGui::GetContentRegionAvail().x;
-            float spacing = 3.0f;
-            float slotW   = (totalW - spacing * 3.0f) / 4.0f;
-            float slotH   = 14.0f;
-            ImDrawList* tdl = ImGui::GetWindowDrawList();
-
-            for (int i = 0; i < game::GameHandler::NUM_TOTEM_SLOTS; i++) {
-                const auto& ts = gameHandler.getTotemSlot(i);
-                float x0 = cursor.x + i * (slotW + spacing);
-                float y0 = cursor.y;
-                float x1 = x0 + slotW;
-                float y1 = y0 + slotH;
-
-                // Background
-                tdl->AddRectFilled(ImVec2(x0, y0), ImVec2(x1, y1), IM_COL32(20, 20, 20, 200), 2.0f);
-
-                if (ts.active()) {
-                    float rem = ts.remainingMs();
-                    float frac = rem / static_cast<float>(ts.durationMs);
-                    float fillX = x0 + (x1 - x0) * frac;
-                    tdl->AddRectFilled(ImVec2(x0, y0), ImVec2(fillX, y1),
-                                      ImGui::ColorConvertFloat4ToU32(kTotemColors[i]), 2.0f);
-                    // Remaining seconds label
-                    char secBuf[16];
-                    snprintf(secBuf, sizeof(secBuf), "%.0f", rem / 1000.0f);
-                    ImVec2 tsz = ImGui::CalcTextSize(secBuf);
-                    float lx = x0 + (slotW - tsz.x) * 0.5f;
-                    float ly = y0 + (slotH - tsz.y) * 0.5f;
-                    tdl->AddText(ImVec2(lx + 1, ly + 1), IM_COL32(0, 0, 0, 180), secBuf);
-                    tdl->AddText(ImVec2(lx, ly), IM_COL32(255, 255, 255, 230), secBuf);
-                } else {
-                    // Inactive — show element letter
-                    const char* letter = kTotemNames[i];
-                    char single[2] = { letter[0], '\0' };
-                    ImVec2 tsz = ImGui::CalcTextSize(single);
-                    float lx = x0 + (slotW - tsz.x) * 0.5f;
-                    float ly = y0 + (slotH - tsz.y) * 0.5f;
-                    tdl->AddText(ImVec2(lx, ly), IM_COL32(80, 80, 80, 200), single);
-                }
-
-                // Border
-                ImU32 borderCol = ts.active()
-                    ? ImGui::ColorConvertFloat4ToU32(kTotemColors[i])
-                    : IM_COL32(60, 60, 60, 160);
-                tdl->AddRect(ImVec2(x0, y0), ImVec2(x1, y1), borderCol, 2.0f);
-
-                // Tooltip on hover
-                ImGui::SetCursorScreenPos(ImVec2(x0, y0));
-                char totemBtnId[16]; snprintf(totemBtnId, sizeof(totemBtnId), "##totem%d", i);
-                ImGui::InvisibleButton(totemBtnId, ImVec2(slotW, slotH));
-                if (ImGui::IsItemHovered()) {
-                    ImGui::BeginTooltip();
-                    if (ts.active()) {
-                        const std::string& spellNm = gameHandler.getSpellName(ts.spellId);
-                        ImGui::TextColored(ImVec4(kTotemColors[i].x, kTotemColors[i].y,
-                                                  kTotemColors[i].z, 1.0f),
-                                           "%s Totem", kTotemNames[i]);
-                        if (!spellNm.empty()) ImGui::Text("%s", spellNm.c_str());
-                        ImGui::Text("%.1fs remaining", ts.remainingMs() / 1000.0f);
-                    } else {
-                        ImGui::TextDisabled("%s Totem (empty)", kTotemNames[i]);
-                    }
-                    ImGui::EndTooltip();
-                }
-            }
-            ImGui::SetCursorScreenPos(ImVec2(cursor.x, cursor.y + slotH + 2.0f));
-        }
     }
-
-    // Melee swing timer — shown when player is auto-attacking
-    if (gameHandler.isAutoAttacking()) {
-        const uint64_t lastSwingMs = gameHandler.getLastMeleeSwingMs();
-        if (lastSwingMs > 0) {
-            // Determine weapon speed from the equipped main-hand weapon
-            uint32_t weaponDelayMs = 2000;  // Default: 2.0s unarmed
-            const auto& mainSlot = gameHandler.getInventory().getEquipSlot(game::EquipSlot::MAIN_HAND);
-            if (!mainSlot.empty() && mainSlot.item.itemId != 0) {
-                const auto* info = gameHandler.getItemInfo(mainSlot.item.itemId);
-                if (info && info->delayMs > 0) {
-                    weaponDelayMs = info->delayMs;
-                }
-            }
-
-            // Compute elapsed since last swing
-            uint64_t nowMs = static_cast<uint64_t>(
-                std::chrono::duration_cast<std::chrono::milliseconds>(
-                    std::chrono::system_clock::now().time_since_epoch()).count());
-            uint64_t elapsedMs = (nowMs >= lastSwingMs) ? (nowMs - lastSwingMs) : 0;
-
-            // Clamp to weapon delay (cap at 1.0 so the bar fills but doesn't exceed)
-            float pct = std::min(static_cast<float>(elapsedMs) / static_cast<float>(weaponDelayMs), 1.0f);
-
-            // Light silver-orange color indicating auto-attack readiness
-            ImVec4 swingColor = (pct >= 0.95f)
-                ? ImVec4(1.0f, 0.75f, 0.15f, 1.0f)   // gold when ready to swing
-                : ImVec4(0.65f, 0.55f, 0.40f, 1.0f);  // muted brown-orange while filling
-            ImGui::PushStyleColor(ImGuiCol_PlotHistogram, swingColor);
-            ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(0.15f, 0.12f, 0.08f, 0.8f));
-            char swingLabel[24];
-            float remainSec = std::max(0.0f, (weaponDelayMs - static_cast<float>(elapsedMs)) / 1000.0f);
-            if (pct >= 0.98f)
-                snprintf(swingLabel, sizeof(swingLabel), "Swing!");
-            else
-                snprintf(swingLabel, sizeof(swingLabel), "%.1fs", remainSec);
-            ImGui::ProgressBar(pct, ImVec2(-1.0f, 8.0f), swingLabel);
-            ImGui::PopStyleColor(2);
-        }
-    }
-
     ImGui::End();
 
     ImGui::PopStyleColor(2);
@@ -1856,7 +1879,7 @@ void GameScreen::renderPetFrame(game::GameHandler& gameHandler) {
 
     auto petEntity = gameHandler.getEntityManager().getEntity(petGuid);
     if (!petEntity) return;
-    auto* petUnit = petEntity->isUnit() ? static_cast<game::Unit*>(petEntity.get()) : nullptr;
+    auto* petUnit = dynamic_cast<game::Unit*>(petEntity.get());
     if (!petUnit) return;
 
     // Position below player frame. If in a group, push below party frames
@@ -1890,48 +1913,6 @@ void GameScreen::renderPetFrame(game::GameHandler& gameHandler) {
         if (ImGui::Selectable(petLabel, false, 0, ImVec2(0, 0))) {
             gameHandler.setTarget(petGuid);
         }
-        // Right-click context menu on pet name
-        if (ImGui::BeginPopupContextItem("PetNameCtx")) {
-            ImGui::TextDisabled("%s", petLabel);
-            ImGui::Separator();
-            if (ImGui::MenuItem("Target Pet")) {
-                gameHandler.setTarget(petGuid);
-            }
-            if (ImGui::MenuItem("Rename Pet")) {
-                ImGui::CloseCurrentPopup();
-                petRenameOpen_ = true;
-                petRenameBuf_[0] = '\0';
-            }
-            if (ImGui::MenuItem("Dismiss Pet")) {
-                gameHandler.dismissPet();
-            }
-            ImGui::EndPopup();
-        }
-        // Pet rename modal (opened via context menu)
-        if (petRenameOpen_) {
-            ImGui::OpenPopup("Rename Pet###PetRename");
-            petRenameOpen_ = false;
-        }
-        if (ImGui::BeginPopupModal("Rename Pet###PetRename", nullptr,
-                                   ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse)) {
-            ImGui::Text("Enter new pet name (max 12 characters):");
-            ImGui::SetNextItemWidth(180.0f);
-            bool submitted = ImGui::InputText("##PetRenameInput", petRenameBuf_, sizeof(petRenameBuf_),
-                                              ImGuiInputTextFlags_EnterReturnsTrue);
-            ImGui::SameLine();
-            if (ImGui::Button("OK") || submitted) {
-                std::string newName(petRenameBuf_);
-                if (!newName.empty() && newName.size() <= 12) {
-                    gameHandler.renamePet(newName);
-                }
-                ImGui::CloseCurrentPopup();
-            }
-            ImGui::SameLine();
-            if (ImGui::Button("Cancel")) {
-                ImGui::CloseCurrentPopup();
-            }
-            ImGui::EndPopup();
-        }
         ImGui::PopStyleColor();
         if (petLevel > 0) {
             ImGui::SameLine();
@@ -1943,10 +1924,7 @@ void GameScreen::renderPetFrame(game::GameHandler& gameHandler) {
         uint32_t maxHp = petUnit->getMaxHealth();
         if (maxHp > 0) {
             float pct = static_cast<float>(hp) / static_cast<float>(maxHp);
-            ImVec4 petHpColor = pct > 0.5f ? colors::kHealthGreen
-                              : pct > 0.2f ? ImVec4(0.9f, 0.6f, 0.0f, 1.0f)
-                              :              ImVec4(0.9f, 0.15f, 0.15f, 1.0f);
-            ImGui::PushStyleColor(ImGuiCol_PlotHistogram, petHpColor);
+            ImGui::PushStyleColor(ImGuiCol_PlotHistogram, ImVec4(0.2f, 0.8f, 0.2f, 1.0f));
             char hpText[32];
             snprintf(hpText, sizeof(hpText), "%u/%u", hp, maxHp);
             ImGui::ProgressBar(pct, ImVec2(-1, 14), hpText);
@@ -1962,11 +1940,11 @@ void GameScreen::renderPetFrame(game::GameHandler& gameHandler) {
             float mpPct = static_cast<float>(power) / static_cast<float>(maxPower);
             ImVec4 powerColor;
             switch (powerType) {
-                case 0: powerColor = colors::kManaBlue; break; // Mana
-                case 1: powerColor = colors::kDarkRed; break; // Rage
-                case 2: powerColor = colors::kOrange; break; // Focus (hunter pets)
-                case 3: powerColor = colors::kEnergyYellow; break; // Energy
-                default: powerColor = colors::kManaBlue; break;
+                case 0: powerColor = ImVec4(0.2f, 0.2f, 0.9f, 1.0f); break; // Mana
+                case 1: powerColor = ImVec4(0.9f, 0.2f, 0.2f, 1.0f); break; // Rage
+                case 2: powerColor = ImVec4(0.9f, 0.6f, 0.1f, 1.0f); break; // Focus (hunter pets)
+                case 3: powerColor = ImVec4(0.9f, 0.9f, 0.2f, 1.0f); break; // Energy
+                default: powerColor = ImVec4(0.2f, 0.2f, 0.9f, 1.0f); break;
             }
             ImGui::PushStyleColor(ImGuiCol_PlotHistogram, powerColor);
             char mpText[32];
@@ -1975,234 +1953,10 @@ void GameScreen::renderPetFrame(game::GameHandler& gameHandler) {
             ImGui::PopStyleColor();
         }
 
-        // Happiness bar — hunter pets store happiness as power type 4
-        {
-            uint32_t happiness = petUnit->getPowerByType(4);
-            uint32_t maxHappiness = petUnit->getMaxPowerByType(4);
-            if (maxHappiness > 0 && happiness > 0) {
-                float hapPct = static_cast<float>(happiness) / static_cast<float>(maxHappiness);
-                // Tier: < 33% = Unhappy (red), < 67% = Content (yellow), >= 67% = Happy (green)
-                ImVec4 hapColor = hapPct >= 0.667f ? ImVec4(0.2f, 0.85f, 0.2f, 1.0f)
-                                : hapPct >= 0.333f ? ImVec4(0.9f, 0.75f, 0.1f, 1.0f)
-                                :                   ImVec4(0.85f, 0.2f, 0.2f, 1.0f);
-                const char* hapLabel = hapPct >= 0.667f ? "Happy" : hapPct >= 0.333f ? "Content" : "Unhappy";
-                ImGui::PushStyleColor(ImGuiCol_PlotHistogram, hapColor);
-                ImGui::ProgressBar(hapPct, ImVec2(-1, 8), hapLabel);
-                ImGui::PopStyleColor();
-            }
-        }
-
-        // Pet cast bar
-        if (auto* pcs = gameHandler.getUnitCastState(petGuid)) {
-            float castPct = (pcs->timeTotal > 0.0f)
-                ? (pcs->timeTotal - pcs->timeRemaining) / pcs->timeTotal : 0.0f;
-            // Orange color to distinguish from health/power bars
-            ImGui::PushStyleColor(ImGuiCol_PlotHistogram, ImVec4(0.85f, 0.55f, 0.1f, 1.0f));
-            char petCastLabel[48];
-            const std::string& spellNm = gameHandler.getSpellName(pcs->spellId);
-            if (!spellNm.empty())
-                snprintf(petCastLabel, sizeof(petCastLabel), "%s (%.1fs)", spellNm.c_str(), pcs->timeRemaining);
-            else
-                snprintf(petCastLabel, sizeof(petCastLabel), "Casting... (%.1fs)", pcs->timeRemaining);
-            ImGui::ProgressBar(castPct, ImVec2(-1, 10), petCastLabel);
-            ImGui::PopStyleColor();
-        }
-
-        // Stance row: Passive / Defensive / Aggressive — with Dismiss right-aligned
-        {
-            static constexpr const char* kReactLabels[]     = { "Psv", "Def", "Agg" };
-            static constexpr const char* kReactTooltips[]   = { "Passive", "Defensive", "Aggressive" };
-            static constexpr ImVec4 kReactColors[]    = {
-                colors::kLightBlue,  // passive  — blue
-                ImVec4(0.3f, 0.85f, 0.3f, 1.0f), // defensive — green
-                colors::kHostileRed,// aggressive — red
-            };
-            static constexpr ImVec4 kReactDimColors[] = {
-                ImVec4(0.15f, 0.2f, 0.4f, 0.8f),
-                ImVec4(0.1f, 0.3f, 0.1f, 0.8f),
-                ImVec4(0.4f, 0.1f, 0.1f, 0.8f),
-            };
-            uint8_t curReact = gameHandler.getPetReact(); // 0=passive,1=defensive,2=aggressive
-
-            // Find each react-type slot in the action bar by known built-in IDs:
-            // 1=Passive, 4=Defensive, 6=Aggressive (WoW wire protocol)
-            static const uint32_t kReactActionIds[] = { 1u, 4u, 6u };
-            uint32_t reactSlotVals[3] = { 0, 0, 0 };
-            const int slotTotal = game::GameHandler::PET_ACTION_BAR_SLOTS;
-            for (int i = 0; i < slotTotal; ++i) {
-                uint32_t sv = gameHandler.getPetActionSlot(i);
-                uint32_t aid = sv & 0x00FFFFFFu;
-                for (int r = 0; r < 3; ++r) {
-                    if (aid == kReactActionIds[r]) { reactSlotVals[r] = sv; break; }
-                }
-            }
-
-            for (int r = 0; r < 3; ++r) {
-                if (r > 0) ImGui::SameLine(0.0f, 3.0f);
-                bool active = (curReact == static_cast<uint8_t>(r));
-                ImVec4 btnCol = active ? kReactColors[r] : kReactDimColors[r];
-                ImGui::PushID(r + 1000);
-                ImGui::PushStyleColor(ImGuiCol_Button,        btnCol);
-                ImGui::PushStyleColor(ImGuiCol_ButtonHovered, kReactColors[r]);
-                ImGui::PushStyleColor(ImGuiCol_ButtonActive,  kReactColors[r]);
-                if (ImGui::Button(kReactLabels[r], ImVec2(34.0f, 16.0f))) {
-                    // Use server-provided slot value if available; fall back to raw ID
-                    uint32_t action = (reactSlotVals[r] != 0)
-                        ? reactSlotVals[r]
-                        : kReactActionIds[r];
-                    gameHandler.sendPetAction(action, 0);
-                }
-                ImGui::PopStyleColor(3);
-                if (ImGui::IsItemHovered())
-                    ImGui::SetTooltip("%s", kReactTooltips[r]);
-                ImGui::PopID();
-            }
-
-            // Dismiss button right-aligned on the same row
-            ImGui::SameLine(ImGui::GetContentRegionAvail().x - 58.0f);
-            if (ImGui::SmallButton("Dismiss")) {
-                gameHandler.dismissPet();
-            }
-        }
-
-        // Pet action bar — show up to 10 action slots from SMSG_PET_SPELLS
-        {
-            const int slotCount = game::GameHandler::PET_ACTION_BAR_SLOTS;
-            // Filter to non-zero slots; lay them out as small icon/text buttons.
-            // Raw slot value layout (WotLK 3.3.5): low 24 bits = spell/action ID,
-            // high byte = flag (0x80=autocast on, 0x40=can-autocast, 0x0C=type).
-            // Built-in commands: id=2 follow, id=3 stay/move, id=5 attack.
-            auto* assetMgr = services_.assetManager;
-            const float iconSz = 20.0f;
-            const float spacing = 2.0f;
-            ImGui::Separator();
-
-            int rendered = 0;
-            for (int i = 0; i < slotCount; ++i) {
-                uint32_t slotVal = gameHandler.getPetActionSlot(i);
-                if (slotVal == 0) continue;
-
-                uint32_t actionId = slotVal & 0x00FFFFFFu;
-                // Use the authoritative autocast set from SMSG_PET_SPELLS spell list flags.
-                bool autocastOn   = gameHandler.isPetSpellAutocast(actionId);
-
-                // Cooldown tracking for pet spells (actionId > 6 are spell IDs)
-                float petCd = (actionId > 6) ? gameHandler.getSpellCooldown(actionId) : 0.0f;
-                bool petOnCd = (petCd > 0.0f);
-
-                ImGui::PushID(i);
-                if (rendered > 0) ImGui::SameLine(0.0f, spacing);
-
-                // Try to show spell icon; fall back to abbreviated text label.
-                VkDescriptorSet iconTex = VK_NULL_HANDLE;
-                const char* builtinLabel = nullptr;
-                if      (actionId == 1) builtinLabel = "Psv";
-                else if (actionId == 2) builtinLabel = "Fol";
-                else if (actionId == 3) builtinLabel = "Sty";
-                else if (actionId == 4) builtinLabel = "Def";
-                else if (actionId == 5) builtinLabel = "Atk";
-                else if (actionId == 6) builtinLabel = "Agg";
-                else if (assetMgr)      iconTex = getSpellIcon(actionId, assetMgr);
-
-                // Dim when on cooldown; tint green when autocast is on
-                ImVec4 tint = petOnCd
-                    ? ImVec4(0.35f, 0.35f, 0.35f, 0.7f)
-                    : (autocastOn ? colors::kLightGreen : ui::colors::kWhite);
-                bool clicked = false;
-                if (iconTex) {
-                    clicked = ImGui::ImageButton("##pa",
-                        (ImTextureID)(uintptr_t)iconTex,
-                        ImVec2(iconSz, iconSz),
-                        ImVec2(0,0), ImVec2(1,1),
-                        ImVec4(0.1f,0.1f,0.1f,0.9f), tint);
-                } else {
-                    char label[8];
-                    if (builtinLabel) {
-                        snprintf(label, sizeof(label), "%s", builtinLabel);
-                    } else {
-                        // Show first 3 chars of spell name or spell ID.
-                        std::string nm = gameHandler.getSpellName(actionId);
-                        if (nm.empty()) snprintf(label, sizeof(label), "?%u", actionId % 100);
-                        else            snprintf(label, sizeof(label), "%.3s", nm.c_str());
-                    }
-                    ImVec4 btnCol = petOnCd ? ImVec4(0.1f,0.1f,0.15f,0.9f)
-                                   : (autocastOn ? ImVec4(0.2f,0.5f,0.2f,0.9f)
-                                                 : ImVec4(0.2f,0.2f,0.3f,0.9f));
-                    ImGui::PushStyleColor(ImGuiCol_Button, btnCol);
-                    clicked = ImGui::Button(label, ImVec2(iconSz + 4.0f, iconSz));
-                    ImGui::PopStyleColor();
-                }
-
-                // Cooldown overlay: dark fill + time text centered on the button
-                if (petOnCd && !builtinLabel) {
-                    ImVec2 bMin = ImGui::GetItemRectMin();
-                    ImVec2 bMax = ImGui::GetItemRectMax();
-                    auto* cdDL = ImGui::GetWindowDrawList();
-                    cdDL->AddRectFilled(bMin, bMax, IM_COL32(0, 0, 0, 140));
-                    char cdTxt[8];
-                    if (petCd >= 60.0f)
-                        snprintf(cdTxt, sizeof(cdTxt), "%dm", static_cast<int>(petCd / 60.0f));
-                    else if (petCd >= 1.0f)
-                        snprintf(cdTxt, sizeof(cdTxt), "%d", static_cast<int>(petCd));
-                    else
-                        snprintf(cdTxt, sizeof(cdTxt), "%.1f", petCd);
-                    ImVec2 tsz = ImGui::CalcTextSize(cdTxt);
-                    float cx = (bMin.x + bMax.x) * 0.5f;
-                    float cy = (bMin.y + bMax.y) * 0.5f;
-                    cdDL->AddText(ImVec2(cx - tsz.x * 0.5f, cy - tsz.y * 0.5f),
-                                  IM_COL32(255, 255, 255, 230), cdTxt);
-                }
-
-                if (clicked && !petOnCd) {
-                    // Send pet action; use current target for spells.
-                    uint64_t targetGuid = (actionId > 5) ? gameHandler.getTargetGuid() : 0u;
-                    gameHandler.sendPetAction(slotVal, targetGuid);
-                }
-                // Right-click toggles autocast for castable pet spells (actionId > 6)
-                if (actionId > 6 && ImGui::IsItemClicked(ImGuiMouseButton_Right)) {
-                    gameHandler.togglePetSpellAutocast(actionId);
-                }
-
-                // Tooltip: rich spell info for pet spells, simple label for built-in commands
-                if (ImGui::IsItemHovered()) {
-                    if (builtinLabel) {
-                        const char* tip = nullptr;
-                        if      (actionId == 1) tip = "Passive";
-                        else if (actionId == 2) tip = "Follow";
-                        else if (actionId == 3) tip = "Stay";
-                        else if (actionId == 4) tip = "Defensive";
-                        else if (actionId == 5) tip = "Attack";
-                        else if (actionId == 6) tip = "Aggressive";
-                        if (tip) ImGui::SetTooltip("%s", tip);
-                    } else if (actionId > 6) {
-                        auto* spellAsset = services_.assetManager;
-                        ImGui::BeginTooltip();
-                        bool richOk = spellbookScreen.renderSpellInfoTooltip(actionId, gameHandler, spellAsset);
-                        if (!richOk) {
-                            std::string nm = gameHandler.getSpellName(actionId);
-                            if (nm.empty()) nm = "Spell #" + std::to_string(actionId);
-                            ImGui::Text("%s", nm.c_str());
-                        }
-                        ImGui::TextColored(autocastOn
-                            ? kColorGreen
-                            : kColorGray,
-                            "Autocast: %s (right-click to toggle)", autocastOn ? "On" : "Off");
-                        if (petOnCd) {
-                            if (petCd >= 60.0f)
-                                ImGui::TextColored(kColorRed,
-                                    "Cooldown: %d min %d sec",
-                                    static_cast<int>(petCd) / 60, static_cast<int>(petCd) % 60);
-                            else
-                                ImGui::TextColored(kColorRed,
-                                    "Cooldown: %.1f sec", petCd);
-                        }
-                        ImGui::EndTooltip();
-                    }
-                }
-
-                ImGui::PopID();
-                ++rendered;
-            }
+        // Dismiss button (compact, right-aligned)
+        ImGui::SameLine(ImGui::GetContentRegionAvail().x - 60.0f);
+        if (ImGui::SmallButton("Dismiss")) {
+            gameHandler.dismissPet();
         }
     }
     ImGui::End();
@@ -2211,92 +1965,11 @@ void GameScreen::renderPetFrame(game::GameHandler& gameHandler) {
     ImGui::PopStyleVar();
 }
 
-// ============================================================
-// Totem Frame (Shaman — below pet frame / player frame)
-// ============================================================
-
-void GameScreen::renderTotemFrame(game::GameHandler& gameHandler) {
-    // Only show if at least one totem is active
-    bool anyActive = false;
-    for (int i = 0; i < game::GameHandler::NUM_TOTEM_SLOTS; ++i) {
-        if (gameHandler.getTotemSlot(i).active()) { anyActive = true; break; }
-    }
-    if (!anyActive) return;
-
-    static constexpr struct { const char* name; ImU32 color; } kTotemInfo[4] = {
-        { "Earth", IM_COL32(139, 90,  43, 255) },   // brown
-        { "Fire",  IM_COL32(220, 80,  30, 255) },   // red-orange
-        { "Water", IM_COL32( 30,120, 220, 255) },   // blue
-        { "Air",   IM_COL32(180,220, 255, 255) },   // light blue
-    };
-
-    // Position: below pet frame / player frame, left side
-    // Pet frame is at ~y=200 if active, player frame is at y=20; totem frame near y=300
-    // We anchor relative to screen left edge like pet frame
-    ImGui::SetNextWindowPos(ImVec2(8.0f, 300.0f), ImGuiCond_FirstUseEver);
-    ImGui::SetNextWindowSize(ImVec2(130.0f, 0.0f), ImGuiCond_Always);
-
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
-                             ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_AlwaysAutoResize |
-                             ImGuiWindowFlags_NoTitleBar;
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.1f, 0.08f, 0.06f, 0.88f));
-
-    if (ImGui::Begin("##TotemFrame", nullptr, flags)) {
-        ImGui::TextColored(ImVec4(0.9f, 0.75f, 0.3f, 1.0f), "Totems");
-        ImGui::Separator();
-
-        for (int i = 0; i < game::GameHandler::NUM_TOTEM_SLOTS; ++i) {
-            const auto& slot = gameHandler.getTotemSlot(i);
-            if (!slot.active()) continue;
-
-            ImGui::PushID(i);
-
-            // Colored element dot
-            ImVec2 dotPos = ImGui::GetCursorScreenPos();
-            dotPos.x += 4.0f; dotPos.y += 6.0f;
-            ImGui::GetWindowDrawList()->AddCircleFilled(
-                ImVec2(dotPos.x + 4.0f, dotPos.y + 4.0f), 4.0f, kTotemInfo[i].color);
-            ImGui::SetCursorPosX(ImGui::GetCursorPosX() + 14.0f);
-
-            // Totem name or spell name
-            const std::string& spellName = gameHandler.getSpellName(slot.spellId);
-            const char* displayName = spellName.empty() ? kTotemInfo[i].name : spellName.c_str();
-            ImGui::Text("%s", displayName);
-
-            // Duration countdown bar
-            float remMs  = slot.remainingMs();
-            float totMs  = static_cast<float>(slot.durationMs);
-            float frac   = (totMs > 0.0f) ? std::min(remMs / totMs, 1.0f) : 0.0f;
-            float remSec = remMs / 1000.0f;
-
-            // Color bar with totem element tint
-            ImVec4 barCol(
-                static_cast<float>((kTotemInfo[i].color >> IM_COL32_R_SHIFT) & 0xFF) / 255.0f,
-                static_cast<float>((kTotemInfo[i].color >> IM_COL32_G_SHIFT) & 0xFF) / 255.0f,
-                static_cast<float>((kTotemInfo[i].color >> IM_COL32_B_SHIFT) & 0xFF) / 255.0f,
-                0.9f);
-            ImGui::PushStyleColor(ImGuiCol_PlotHistogram, barCol);
-            char timeBuf[16];
-            snprintf(timeBuf, sizeof(timeBuf), "%.0fs", remSec);
-            ImGui::ProgressBar(frac, ImVec2(-1, 8), timeBuf);
-            ImGui::PopStyleColor();
-
-            ImGui::PopID();
-        }
-    }
-    ImGui::End();
-
-    ImGui::PopStyleColor();
-    ImGui::PopStyleVar();
-}
-
 void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
     auto target = gameHandler.getTarget();
     if (!target) return;
 
-    auto* window = services_.window;
+    auto* window = core::Application::getInstance().getWindow();
     float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
 
     float frameW = 250.0f;
@@ -2312,41 +1985,29 @@ void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
     // Determine hostility/level color for border and name (WoW-canonical)
     ImVec4 hostileColor(0.7f, 0.7f, 0.7f, 1.0f);
     if (target->getType() == game::ObjectType::PLAYER) {
-        hostileColor = kColorBrightGreen;
+        hostileColor = ImVec4(0.3f, 1.0f, 0.3f, 1.0f);
     } else if (target->getType() == game::ObjectType::UNIT) {
         auto u = std::static_pointer_cast<game::Unit>(target);
         if (u->getHealth() == 0 && u->getMaxHealth() > 0) {
-            hostileColor = kColorDarkGray;
+            hostileColor = ImVec4(0.5f, 0.5f, 0.5f, 1.0f);
         } else if (u->isHostile()) {
-            // Check tapped-by-other: grey name for mobs tagged by someone else
-            uint32_t tgtDynFlags = u->getDynamicFlags();
-            bool tgtTapped = (tgtDynFlags & 0x0004) != 0 && (tgtDynFlags & 0x0008) == 0;
-            if (tgtTapped) {
-                hostileColor = kColorGray; // Grey — tapped by other
-            } else {
             // WoW level-based color for hostile mobs
             uint32_t playerLv = gameHandler.getPlayerLevel();
             uint32_t mobLv = u->getLevel();
-            if (mobLv == 0) {
-                // Level 0 = unknown/?? (e.g. high-level raid bosses) — always skull red
-                hostileColor = ImVec4(1.0f, 0.1f, 0.1f, 1.0f);
+            int32_t diff = static_cast<int32_t>(mobLv) - static_cast<int32_t>(playerLv);
+            if (game::GameHandler::killXp(playerLv, mobLv) == 0) {
+                hostileColor = ImVec4(0.6f, 0.6f, 0.6f, 1.0f); // Grey - no XP
+            } else if (diff >= 10) {
+                hostileColor = ImVec4(1.0f, 0.1f, 0.1f, 1.0f); // Red - skull/very hard
+            } else if (diff >= 5) {
+                hostileColor = ImVec4(1.0f, 0.5f, 0.1f, 1.0f); // Orange - hard
+            } else if (diff >= -2) {
+                hostileColor = ImVec4(1.0f, 1.0f, 0.1f, 1.0f); // Yellow - even
             } else {
-                int32_t diff = static_cast<int32_t>(mobLv) - static_cast<int32_t>(playerLv);
-                if (game::GameHandler::killXp(playerLv, mobLv) == 0) {
-                    hostileColor = kColorGray; // Grey - no XP
-                } else if (diff >= 10) {
-                    hostileColor = ImVec4(1.0f, 0.1f, 0.1f, 1.0f); // Red - skull/very hard
-                } else if (diff >= 5) {
-                    hostileColor = ImVec4(1.0f, 0.5f, 0.1f, 1.0f); // Orange - hard
-                } else if (diff >= -2) {
-                    hostileColor = ImVec4(1.0f, 1.0f, 0.1f, 1.0f); // Yellow - even
-                } else {
-                    hostileColor = kColorBrightGreen; // Green - easy
-                }
+                hostileColor = ImVec4(0.3f, 1.0f, 0.3f, 1.0f); // Green - easy
             }
-            } // end tapped else
         } else {
-            hostileColor = kColorBrightGreen; // Friendly
+            hostileColor = ImVec4(0.3f, 1.0f, 0.3f, 1.0f); // Friendly
         }
     }
 
@@ -2369,203 +2030,12 @@ void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
     ImGui::PushStyleColor(ImGuiCol_Border, borderColor);
 
     if (ImGui::Begin("##TargetFrame", nullptr, flags)) {
-        // Raid mark icon (Star/Circle/Diamond/Triangle/Moon/Square/Cross/Skull)
-        static constexpr struct { const char* sym; ImU32 col; } kRaidMarks[] = {
-            { "\xe2\x98\x85", IM_COL32(255, 220,  50, 255) },  // 0 Star     (yellow)
-            { "\xe2\x97\x8f", IM_COL32(255, 140,   0, 255) },  // 1 Circle   (orange)
-            { "\xe2\x97\x86", IM_COL32(160,  32, 240, 255) },  // 2 Diamond  (purple)
-            { "\xe2\x96\xb2", IM_COL32( 50, 200,  50, 255) },  // 3 Triangle (green)
-            { "\xe2\x97\x8c", IM_COL32( 80, 160, 255, 255) },  // 4 Moon     (blue)
-            { "\xe2\x96\xa0", IM_COL32( 50, 200, 220, 255) },  // 5 Square   (teal)
-            { "\xe2\x9c\x9d", IM_COL32(255,  80,  80, 255) },  // 6 Cross    (red)
-            { "\xe2\x98\xa0", IM_COL32(255, 255, 255, 255) },  // 7 Skull    (white)
-        };
-        uint8_t mark = gameHandler.getEntityRaidMark(target->getGuid());
-        if (mark < game::GameHandler::kRaidMarkCount) {
-            ImGui::GetWindowDrawList()->AddText(
-                ImGui::GetCursorScreenPos(),
-                kRaidMarks[mark].col, kRaidMarks[mark].sym);
-            ImGui::SetCursorPosX(ImGui::GetCursorPosX() + 18.0f);
-        }
-
-        // Entity name and type — Selectable so we can attach a right-click context menu
+        // Entity name and type
         std::string name = getEntityName(target);
 
-        // Player targets: use class color instead of the generic green
         ImVec4 nameColor = hostileColor;
-        if (target->getType() == game::ObjectType::PLAYER) {
-            uint8_t cid = entityClassId(target.get());
-            if (cid != 0) nameColor = classColorVec4(cid);
-        }
 
-        ImGui::SameLine(0.0f, 0.0f);
-        ImGui::PushStyleColor(ImGuiCol_Text, nameColor);
-        ImGui::PushStyleColor(ImGuiCol_Header,        ImVec4(0,0,0,0));
-        ImGui::PushStyleColor(ImGuiCol_HeaderHovered, ImVec4(1,1,1,0.08f));
-        ImGui::PushStyleColor(ImGuiCol_HeaderActive,  ImVec4(1,1,1,0.12f));
-        ImGui::Selectable(name.c_str(), false, ImGuiSelectableFlags_DontClosePopups,
-                          ImVec2(ImGui::CalcTextSize(name.c_str()).x, 0));
-        ImGui::PopStyleColor(4);
-
-        // Right-click context menu on target frame
-        if (ImGui::BeginPopupContextItem("##TargetFrameCtx")) {
-            const bool isPlayer = (target->getType() == game::ObjectType::PLAYER);
-            const uint64_t tGuid = target->getGuid();
-
-            ImGui::TextDisabled("%s", name.c_str());
-            ImGui::Separator();
-
-            if (ImGui::MenuItem("Set Focus"))
-                gameHandler.setFocus(tGuid);
-            if (ImGui::MenuItem("Clear Target"))
-                gameHandler.clearTarget();
-            if (isPlayer) {
-                ImGui::Separator();
-                if (ImGui::MenuItem("Whisper")) {
-                    chatPanel_.setWhisperTarget(name);
-                }
-                if (ImGui::MenuItem("Follow"))
-                    gameHandler.followTarget();
-                if (ImGui::MenuItem("Invite to Group"))
-                    gameHandler.inviteToGroup(name);
-                if (ImGui::MenuItem("Trade"))
-                    gameHandler.initiateTrade(tGuid);
-                if (ImGui::MenuItem("Duel"))
-                    gameHandler.proposeDuel(tGuid);
-                if (ImGui::MenuItem("Inspect")) {
-                    gameHandler.inspectTarget();
-                    socialPanel_.showInspectWindow_ = true;
-                }
-                ImGui::Separator();
-                if (ImGui::MenuItem("Add Friend"))
-                    gameHandler.addFriend(name);
-                if (ImGui::MenuItem("Ignore"))
-                    gameHandler.addIgnore(name);
-                if (ImGui::MenuItem("Report Player"))
-                    gameHandler.reportPlayer(tGuid, "Reported via UI");
-            }
-            ImGui::Separator();
-            if (ImGui::BeginMenu("Set Raid Mark")) {
-                for (int mi = 0; mi < 8; ++mi) {
-                    if (ImGui::MenuItem(kRaidMarkNames[mi]))
-                        gameHandler.setRaidMark(tGuid, static_cast<uint8_t>(mi));
-                }
-                ImGui::Separator();
-                if (ImGui::MenuItem("Clear Mark"))
-                    gameHandler.setRaidMark(tGuid, 0xFF);
-                ImGui::EndMenu();
-            }
-            ImGui::EndPopup();
-        }
-
-        // Group leader crown — golden ♛ when the targeted player is the party/raid leader
-        if (gameHandler.isInGroup() && target->getType() == game::ObjectType::PLAYER) {
-            if (gameHandler.getPartyData().leaderGuid == target->getGuid()) {
-                ImGui::SameLine(0, 4);
-                ImGui::TextColored(colors::kSymbolGold, "\xe2\x99\x9b");
-                if (ImGui::IsItemHovered()) ImGui::SetTooltip("Group Leader");
-            }
-        }
-
-        // Quest giver indicator — "!" for available quests, "?" for completable quests
-        {
-            using QGS = game::QuestGiverStatus;
-            QGS qgs = gameHandler.getQuestGiverStatus(target->getGuid());
-            if (qgs == QGS::AVAILABLE) {
-                ImGui::SameLine(0, 4);
-                ImGui::TextColored(colors::kBrightGold, "!");
-                if (ImGui::IsItemHovered()) ImGui::SetTooltip("Has a quest available");
-            } else if (qgs == QGS::AVAILABLE_LOW) {
-                ImGui::SameLine(0, 4);
-                ImGui::TextColored(kColorGray, "!");
-                if (ImGui::IsItemHovered()) ImGui::SetTooltip("Has a low-level quest available");
-            } else if (qgs == QGS::REWARD || qgs == QGS::REWARD_REP) {
-                ImGui::SameLine(0, 4);
-                ImGui::TextColored(colors::kBrightGold, "?");
-                if (ImGui::IsItemHovered()) ImGui::SetTooltip("Quest ready to turn in");
-            } else if (qgs == QGS::INCOMPLETE) {
-                ImGui::SameLine(0, 4);
-                ImGui::TextColored(kColorGray, "?");
-                if (ImGui::IsItemHovered()) ImGui::SetTooltip("Quest incomplete");
-            }
-        }
-
-        // Creature subtitle (e.g. "<Warchief of the Horde>", "Captain of the Guard")
-        if (target->getType() == game::ObjectType::UNIT) {
-            auto unit = std::static_pointer_cast<game::Unit>(target);
-            const std::string sub = gameHandler.getCachedCreatureSubName(unit->getEntry());
-            if (!sub.empty()) {
-                ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 0.9f), "<%s>", sub.c_str());
-            }
-        }
-
-        // Player guild name (e.g. "<My Guild>") — mirrors NPC subtitle styling
-        if (target->getType() == game::ObjectType::PLAYER) {
-            uint32_t guildId = gameHandler.getEntityGuildId(target->getGuid());
-            if (guildId != 0) {
-                const std::string& gn = gameHandler.lookupGuildName(guildId);
-                if (!gn.empty()) {
-                    ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 0.9f), "<%s>", gn.c_str());
-                }
-            }
-        }
-
-        // Right-click context menu on the target name
-        if (ImGui::BeginPopupContextItem("##TargetNameCtx")) {
-            const bool isPlayer = (target->getType() == game::ObjectType::PLAYER);
-            const uint64_t tGuid = target->getGuid();
-
-            ImGui::TextDisabled("%s", name.c_str());
-            ImGui::Separator();
-
-            if (ImGui::MenuItem("Set Focus")) {
-                gameHandler.setFocus(tGuid);
-            }
-            if (ImGui::MenuItem("Clear Target")) {
-                gameHandler.clearTarget();
-            }
-            if (isPlayer) {
-                ImGui::Separator();
-                if (ImGui::MenuItem("Whisper")) {
-                    chatPanel_.setWhisperTarget(name);
-                }
-                if (ImGui::MenuItem("Follow")) {
-                    gameHandler.followTarget();
-                }
-                if (ImGui::MenuItem("Invite to Group")) {
-                    gameHandler.inviteToGroup(name);
-                }
-                if (ImGui::MenuItem("Trade")) {
-                    gameHandler.initiateTrade(tGuid);
-                }
-                if (ImGui::MenuItem("Duel")) {
-                    gameHandler.proposeDuel(tGuid);
-                }
-                if (ImGui::MenuItem("Inspect")) {
-                    gameHandler.inspectTarget();
-                    socialPanel_.showInspectWindow_ = true;
-                }
-                ImGui::Separator();
-                if (ImGui::MenuItem("Add Friend")) {
-                    gameHandler.addFriend(name);
-                }
-                if (ImGui::MenuItem("Ignore")) {
-                    gameHandler.addIgnore(name);
-                }
-            }
-            ImGui::Separator();
-            if (ImGui::BeginMenu("Set Raid Mark")) {
-                for (int mi = 0; mi < 8; ++mi) {
-                    if (ImGui::MenuItem(kRaidMarkNames[mi]))
-                        gameHandler.setRaidMark(tGuid, static_cast<uint8_t>(mi));
-                }
-                ImGui::Separator();
-                if (ImGui::MenuItem("Clear Mark"))
-                    gameHandler.setRaidMark(tGuid, 0xFF);
-                ImGui::EndMenu();
-            }
-            ImGui::EndPopup();
-        }
+        ImGui::TextColored(nameColor, "%s", name.c_str());
 
         // Level (for units/players) — colored by difficulty
         if (target->getType() == game::ObjectType::UNIT || target->getType() == game::ObjectType::PLAYER) {
@@ -2574,63 +2044,9 @@ void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
             // Level color matches the hostility/difficulty color
             ImVec4 levelColor = hostileColor;
             if (target->getType() == game::ObjectType::PLAYER) {
-                levelColor = ui::colors::kLightGray;
-            }
-            if (unit->getLevel() == 0)
-                ImGui::TextColored(levelColor, "Lv ??");
-            else
-                ImGui::TextColored(levelColor, "Lv %u", unit->getLevel());
-            // Classification badge: Elite / Rare Elite / Boss / Rare
-            if (target->getType() == game::ObjectType::UNIT) {
-                int rank = gameHandler.getCreatureRank(unit->getEntry());
-                if (rank == 1) {
-                    ImGui::SameLine(0, 4);
-                    ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.2f, 1.0f), "[Elite]");
-                    if (ImGui::IsItemHovered()) ImGui::SetTooltip("Elite — requires a group");
-                } else if (rank == 2) {
-                    ImGui::SameLine(0, 4);
-                    ImGui::TextColored(ImVec4(0.8f, 0.4f, 1.0f, 1.0f), "[Rare Elite]");
-                    if (ImGui::IsItemHovered()) ImGui::SetTooltip("Rare Elite — uncommon spawn, group recommended");
-                } else if (rank == 3) {
-                    ImGui::SameLine(0, 4);
-                    ImGui::TextColored(kColorRed, "[Boss]");
-                    if (ImGui::IsItemHovered()) ImGui::SetTooltip("Boss — raid / dungeon boss");
-                } else if (rank == 4) {
-                    ImGui::SameLine(0, 4);
-                    ImGui::TextColored(ImVec4(0.5f, 0.9f, 1.0f, 1.0f), "[Rare]");
-                    if (ImGui::IsItemHovered()) ImGui::SetTooltip("Rare — uncommon spawn with better loot");
-                }
-            }
-            // Creature type label (Beast, Humanoid, Demon, etc.)
-            if (target->getType() == game::ObjectType::UNIT) {
-                uint32_t ctype = gameHandler.getCreatureType(unit->getEntry());
-                const char* ctypeName = nullptr;
-                switch (ctype) {
-                    case 1:  ctypeName = "Beast"; break;
-                    case 2:  ctypeName = "Dragonkin"; break;
-                    case 3:  ctypeName = "Demon"; break;
-                    case 4:  ctypeName = "Elemental"; break;
-                    case 5:  ctypeName = "Giant"; break;
-                    case 6:  ctypeName = "Undead"; break;
-                    case 7:  ctypeName = "Humanoid"; break;
-                    case 8:  ctypeName = "Critter"; break;
-                    case 9:  ctypeName = "Mechanical"; break;
-                    case 11: ctypeName = "Totem"; break;
-                    case 12: ctypeName = "Non-combat Pet"; break;
-                    case 13: ctypeName = "Gas Cloud"; break;
-                    default: break;
-                }
-                if (ctypeName) {
-                    ImGui::SameLine(0, 4);
-                    ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 0.9f), "(%s)", ctypeName);
-                }
-            }
-            if (confirmedCombatWithTarget) {
-                float cPulse = 0.75f + 0.25f * std::sin(static_cast<float>(ImGui::GetTime()) * 4.0f);
-                ImGui::SameLine();
-                ImGui::TextColored(ImVec4(1.0f, 0.2f * cPulse, 0.2f * cPulse, 1.0f), "[Attacking]");
-                if (ImGui::IsItemHovered()) ImGui::SetTooltip("Engaged in combat with this target");
+                levelColor = ImVec4(0.7f, 0.7f, 0.7f, 1.0f);
             }
+            ImGui::TextColored(levelColor, "Lv %u", unit->getLevel());
 
             // Health bar
             uint32_t hp = unit->getHealth();
@@ -2638,9 +2054,9 @@ void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
             if (maxHp > 0) {
                 float pct = static_cast<float>(hp) / static_cast<float>(maxHp);
                 ImGui::PushStyleColor(ImGuiCol_PlotHistogram,
-                    pct > 0.5f ? colors::kHealthGreen :
-                    pct > 0.2f ? colors::kMidHealthYellow :
-                                 colors::kLowHealthRed);
+                    pct > 0.5f ? ImVec4(0.2f, 0.8f, 0.2f, 1.0f) :
+                    pct > 0.2f ? ImVec4(0.8f, 0.8f, 0.2f, 1.0f) :
+                                 ImVec4(0.8f, 0.2f, 0.2f, 1.0f));
 
                 char overlay[64];
                 snprintf(overlay, sizeof(overlay), "%u / %u", hp, maxHp);
@@ -2655,14 +2071,14 @@ void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
                     float mpPct = static_cast<float>(targetPower) / static_cast<float>(targetMaxPower);
                     ImVec4 targetPowerColor;
                     switch (targetPowerType) {
-                        case 0: targetPowerColor = colors::kManaBlue; break; // Mana (blue)
-                        case 1: targetPowerColor = colors::kDarkRed; break; // Rage (red)
-                        case 2: targetPowerColor = colors::kOrange; break; // Focus (orange)
-                        case 3: targetPowerColor = colors::kEnergyYellow; break; // Energy (yellow)
-                        case 4: targetPowerColor = colors::kHappinessGreen; break; // Happiness (green)
-                        case 6: targetPowerColor = colors::kRunicRed; break; // Runic Power (crimson)
-                        case 7: targetPowerColor = colors::kSoulShardPurple; break; // Soul Shards (purple)
-                        default: targetPowerColor = colors::kManaBlue; break;
+                        case 0: targetPowerColor = ImVec4(0.2f, 0.2f, 0.9f, 1.0f); break; // Mana (blue)
+                        case 1: targetPowerColor = ImVec4(0.9f, 0.2f, 0.2f, 1.0f); break; // Rage (red)
+                        case 2: targetPowerColor = ImVec4(0.9f, 0.6f, 0.1f, 1.0f); break; // Focus (orange)
+                        case 3: targetPowerColor = ImVec4(0.9f, 0.9f, 0.2f, 1.0f); break; // Energy (yellow)
+                        case 4: targetPowerColor = ImVec4(0.5f, 0.9f, 0.3f, 1.0f); break; // Happiness (green)
+                        case 6: targetPowerColor = ImVec4(0.8f, 0.1f, 0.2f, 1.0f); break; // Runic Power (crimson)
+                        case 7: targetPowerColor = ImVec4(0.4f, 0.1f, 0.6f, 1.0f); break; // Soul Shards (purple)
+                        default: targetPowerColor = ImVec4(0.2f, 0.2f, 0.9f, 1.0f); break;
                     }
                     ImGui::PushStyleColor(ImGuiCol_PlotHistogram, targetPowerColor);
                     char mpOverlay[64];
@@ -2675,139 +2091,6 @@ void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
             }
         }
 
-        // Combo points — shown when the player has combo points on this target
-        {
-            uint8_t cp = gameHandler.getComboPoints();
-            if (cp > 0 && gameHandler.getComboTarget() == target->getGuid()) {
-                const float dotSize = 12.0f;
-                const float dotSpacing = 4.0f;
-                const int maxCP = 5;
-                float totalW = maxCP * dotSize + (maxCP - 1) * dotSpacing;
-                float startX = (frameW - totalW) * 0.5f;
-                ImGui::SetCursorPosX(startX);
-                ImVec2 cursor = ImGui::GetCursorScreenPos();
-                ImDrawList* dl = ImGui::GetWindowDrawList();
-                for (int ci = 0; ci < maxCP; ++ci) {
-                    float cx = cursor.x + ci * (dotSize + dotSpacing) + dotSize * 0.5f;
-                    float cy = cursor.y + dotSize * 0.5f;
-                    if (ci < static_cast<int>(cp)) {
-                        // Lit: yellow for 1-4, red glow for 5
-                        ImU32 col = (cp >= 5)
-                            ? IM_COL32(255, 50, 30, 255)
-                            : IM_COL32(255, 210, 30, 255);
-                        dl->AddCircleFilled(ImVec2(cx, cy), dotSize * 0.45f, col);
-                        // Subtle glow
-                        dl->AddCircle(ImVec2(cx, cy), dotSize * 0.5f, IM_COL32(255, 255, 200, 80), 0, 1.5f);
-                    } else {
-                        // Unlit: dark outline
-                        dl->AddCircle(ImVec2(cx, cy), dotSize * 0.4f, IM_COL32(80, 80, 80, 180), 0, 1.5f);
-                    }
-                }
-                ImGui::Dummy(ImVec2(totalW, dotSize + 2.0f));
-            }
-        }
-
-        // Target cast bar — shown when the target is casting
-        if (gameHandler.isTargetCasting()) {
-            float castPct   = gameHandler.getTargetCastProgress();
-            float castLeft  = gameHandler.getTargetCastTimeRemaining();
-            uint32_t tspell = gameHandler.getTargetCastSpellId();
-            bool interruptible = gameHandler.isTargetCastInterruptible();
-            const std::string& castName = (tspell != 0) ? gameHandler.getSpellName(tspell) : "";
-            // Color: interruptible = green (can Kick/CS), not interruptible = red, both pulse when >80%
-            ImVec4 castBarColor;
-            if (castPct > 0.8f) {
-                float pulse = 0.7f + 0.3f * std::sin(static_cast<float>(ImGui::GetTime()) * 8.0f);
-                if (interruptible)
-                    castBarColor = ImVec4(0.2f * pulse, 0.9f * pulse, 0.2f * pulse, 1.0f);  // green pulse
-                else
-                    castBarColor = ImVec4(1.0f * pulse, 0.1f * pulse, 0.1f * pulse, 1.0f);  // red pulse
-            } else {
-                castBarColor = interruptible ? colors::kCastGreen   // green = can interrupt
-                                             : ImVec4(0.85f, 0.15f, 0.15f, 1.0f); // red = uninterruptible
-            }
-            ImGui::PushStyleColor(ImGuiCol_PlotHistogram, castBarColor);
-            char castLabel[72];
-            if (!castName.empty())
-                snprintf(castLabel, sizeof(castLabel), "%s (%.1fs)", castName.c_str(), castLeft);
-            else if (tspell != 0)
-                snprintf(castLabel, sizeof(castLabel), "Spell #%u (%.1fs)", tspell, castLeft);
-            else
-                snprintf(castLabel, sizeof(castLabel), "Casting... (%.1fs)", castLeft);
-            {
-                auto* tcastAsset = services_.assetManager;
-                VkDescriptorSet tIcon = (tspell != 0 && tcastAsset)
-                    ? getSpellIcon(tspell, tcastAsset) : VK_NULL_HANDLE;
-                if (tIcon) {
-                    ImGui::Image((ImTextureID)(uintptr_t)tIcon, ImVec2(14, 14));
-                    ImGui::SameLine(0, 2);
-                    ImGui::ProgressBar(castPct, ImVec2(-1, 14), castLabel);
-                } else {
-                    ImGui::ProgressBar(castPct, ImVec2(-1, 14), castLabel);
-                }
-            }
-            ImGui::PopStyleColor();
-        }
-
-        // Target-of-Target (ToT): show who the current target is targeting
-        {
-            uint64_t totGuid = 0;
-            const auto& tFields = target->getFields();
-            auto itLo = tFields.find(game::fieldIndex(game::UF::UNIT_FIELD_TARGET_LO));
-            if (itLo != tFields.end()) {
-                totGuid = itLo->second;
-                auto itHi = tFields.find(game::fieldIndex(game::UF::UNIT_FIELD_TARGET_HI));
-                if (itHi != tFields.end())
-                    totGuid |= (static_cast<uint64_t>(itHi->second) << 32);
-            }
-            if (totGuid != 0) {
-                auto totEnt = gameHandler.getEntityManager().getEntity(totGuid);
-                std::string totName;
-                ImVec4 totColor(0.7f, 0.7f, 0.7f, 1.0f);
-                if (totGuid == gameHandler.getPlayerGuid()) {
-                    auto playerEnt = gameHandler.getEntityManager().getEntity(totGuid);
-                    totName = playerEnt ? getEntityName(playerEnt) : "You";
-                    totColor = kColorBrightGreen;
-                } else if (totEnt) {
-                    totName = getEntityName(totEnt);
-                    uint8_t cid = entityClassId(totEnt.get());
-                    if (cid != 0) totColor = classColorVec4(cid);
-                }
-                if (!totName.empty()) {
-                    ImGui::TextDisabled("▶");
-                    ImGui::SameLine(0, 2);
-                    ImGui::TextColored(totColor, "%s", totName.c_str());
-                    if (ImGui::IsItemHovered()) {
-                        ImGui::SetTooltip("Target's target: %s\nClick to target", totName.c_str());
-                    }
-                    if (ImGui::IsItemClicked()) {
-                        gameHandler.setTarget(totGuid);
-                    }
-
-                    // Compact health bar for the ToT — essential for healers tracking boss target
-                    if (totEnt) {
-                        auto totUnit = std::dynamic_pointer_cast<game::Unit>(totEnt);
-                        if (totUnit && totUnit->getMaxHealth() > 0) {
-                            uint32_t totHp    = totUnit->getHealth();
-                            uint32_t totMaxHp = totUnit->getMaxHealth();
-                            float totPct = static_cast<float>(totHp) / static_cast<float>(totMaxHp);
-                            ImVec4 totBarColor =
-                                totPct > 0.5f ? colors::kCastGreen :
-                                totPct > 0.2f ? ImVec4(0.75f, 0.75f, 0.2f, 1.0f) :
-                                               ImVec4(0.75f, 0.2f, 0.2f, 1.0f);
-                            ImGui::PushStyleColor(ImGuiCol_PlotHistogram, totBarColor);
-                            ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(0.15f, 0.15f, 0.15f, 0.8f));
-                            char totOverlay[32];
-                            snprintf(totOverlay, sizeof(totOverlay), "%u%%",
-                                     static_cast<unsigned>(totPct * 100.0f + 0.5f));
-                            ImGui::ProgressBar(totPct, ImVec2(-1, 10), totOverlay);
-                            ImGui::PopStyleColor(2);
-                        }
-                    }
-                }
-            }
-        }
-
         // Distance
         const auto& movement = gameHandler.getMovementInfo();
         float dx = target->getX() - movement.x;
@@ -2816,15 +2099,6 @@ void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
         float distance = std::sqrt(dx*dx + dy*dy + dz*dz);
         ImGui::TextDisabled("%.1f yd", distance);
 
-        // Threat button (shown when in combat and threat data is available)
-        if (gameHandler.getTargetThreatList()) {
-            ImGui::SameLine();
-            ImGui::PushStyleColor(ImGuiCol_Button,        ImVec4(0.5f, 0.1f, 0.1f, 0.8f));
-            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.7f, 0.2f, 0.2f, 0.9f));
-            if (ImGui::SmallButton("Threat")) combatUI_.showThreatWindow_ = !combatUI_.showThreatWindow_;
-            ImGui::PopStyleColor(2);
-        }
-
         // Target auras (buffs/debuffs)
         const auto& targetAuras = gameHandler.getTargetAuras();
         int activeAuras = 0;
@@ -2832,37 +2106,14 @@ void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
             if (!a.isEmpty()) activeAuras++;
         }
         if (activeAuras > 0) {
-            auto* assetMgr = services_.assetManager;
+            auto* assetMgr = core::Application::getInstance().getAssetManager();
             constexpr float ICON_SIZE = 24.0f;
             constexpr int ICONS_PER_ROW = 8;
 
             ImGui::Separator();
 
-            // Build sorted index list: debuffs before buffs, shorter duration first
-            uint64_t tNowSort = static_cast<uint64_t>(
-                std::chrono::duration_cast<std::chrono::milliseconds>(
-                    std::chrono::steady_clock::now().time_since_epoch()).count());
-            std::vector<size_t> sortedIdx;
-            sortedIdx.reserve(targetAuras.size());
-            for (size_t i = 0; i < targetAuras.size(); ++i)
-                if (!targetAuras[i].isEmpty()) sortedIdx.push_back(i);
-            std::sort(sortedIdx.begin(), sortedIdx.end(), [&](size_t a, size_t b) {
-                const auto& aa = targetAuras[a]; const auto& ab = targetAuras[b];
-                bool aDebuff = (aa.flags & 0x80) != 0;
-                bool bDebuff = (ab.flags & 0x80) != 0;
-                if (aDebuff != bDebuff) return aDebuff > bDebuff; // debuffs first
-                int32_t ra = aa.getRemainingMs(tNowSort);
-                int32_t rb = ab.getRemainingMs(tNowSort);
-                // Permanent (-1) goes last; shorter remaining goes first
-                if (ra < 0 && rb < 0) return false;
-                if (ra < 0) return false;
-                if (rb < 0) return true;
-                return ra < rb;
-            });
-
             int shown = 0;
-            for (size_t si = 0; si < sortedIdx.size() && shown < 16; ++si) {
-                size_t i = sortedIdx[si];
+            for (size_t i = 0; i < targetAuras.size() && shown < 16; ++i) {
                 const auto& aura = targetAuras[i];
                 if (aura.isEmpty()) continue;
 
@@ -2871,20 +2122,7 @@ void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
                 ImGui::PushID(static_cast<int>(10000 + i));
 
                 bool isBuff = (aura.flags & 0x80) == 0;
-                ImVec4 auraBorderColor;
-                if (isBuff) {
-                    auraBorderColor = ImVec4(0.2f, 0.8f, 0.2f, 0.9f);
-                } else {
-                    // Debuff: color by dispel type, matching player buff bar convention
-                    uint8_t dt = gameHandler.getSpellDispelType(aura.spellId);
-                    switch (dt) {
-                        case 1:  auraBorderColor = ImVec4(0.15f, 0.50f, 1.00f, 0.9f); break; // magic: blue
-                        case 2:  auraBorderColor = ImVec4(0.70f, 0.20f, 0.90f, 0.9f); break; // curse: purple
-                        case 3:  auraBorderColor = ImVec4(0.55f, 0.30f, 0.10f, 0.9f); break; // disease: brown
-                        case 4:  auraBorderColor = ImVec4(0.10f, 0.70f, 0.10f, 0.9f); break; // poison: green
-                        default: auraBorderColor = ImVec4(0.80f, 0.20f, 0.20f, 0.9f); break; // other: red
-                    }
-                }
+                ImVec4 auraBorderColor = isBuff ? ImVec4(0.2f, 0.8f, 0.2f, 0.9f) : ImVec4(0.8f, 0.2f, 0.2f, 0.9f);
 
                 VkDescriptorSet iconTex = VK_NULL_HANDLE;
                 if (assetMgr) {
@@ -2901,12 +2139,8 @@ void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
                     ImGui::PopStyleColor();
                 } else {
                     ImGui::PushStyleColor(ImGuiCol_Button, auraBorderColor);
-                    const std::string& tAuraName = gameHandler.getSpellName(aura.spellId);
-                    char label[32];
-                    if (!tAuraName.empty())
-                        snprintf(label, sizeof(label), "%.6s", tAuraName.c_str());
-                    else
-                        snprintf(label, sizeof(label), "%u", aura.spellId);
+                    char label[8];
+                    snprintf(label, sizeof(label), "%u", aura.spellId);
                     ImGui::Button(label, ImVec2(ICON_SIZE, ICON_SIZE));
                     ImGui::PopStyleColor();
                 }
@@ -2917,32 +2151,6 @@ void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
                         std::chrono::steady_clock::now().time_since_epoch()).count());
                 int32_t tRemainMs = aura.getRemainingMs(tNowMs);
 
-                // Clock-sweep overlay (elapsed = dark area, WoW style)
-                if (tRemainMs > 0 && aura.maxDurationMs > 0) {
-                    ImVec2 tIconMin = ImGui::GetItemRectMin();
-                    ImVec2 tIconMax = ImGui::GetItemRectMax();
-                    float tcx = (tIconMin.x + tIconMax.x) * 0.5f;
-                    float tcy = (tIconMin.y + tIconMax.y) * 0.5f;
-                    float tR  = (tIconMax.x - tIconMin.x) * 0.5f;
-                    float tTot = static_cast<float>(aura.maxDurationMs);
-                    float tFrac = std::clamp(
-                        1.0f - static_cast<float>(tRemainMs) / tTot, 0.0f, 1.0f);
-                    if (tFrac > 0.005f) {
-                        constexpr int TSEGS = 24;
-                        float tSa = -IM_PI * 0.5f;
-                        float tEa = tSa + tFrac * 2.0f * IM_PI;
-                        ImVec2 tPts[TSEGS + 2];
-                        tPts[0] = ImVec2(tcx, tcy);
-                        for (int s = 0; s <= TSEGS; ++s) {
-                            float a = tSa + (tEa - tSa) * s / static_cast<float>(TSEGS);
-                            tPts[s + 1] = ImVec2(tcx + std::cos(a) * tR,
-                                                 tcy + std::sin(a) * tR);
-                        }
-                        ImGui::GetWindowDrawList()->AddConvexPolyFilled(
-                            tPts, TSEGS + 2, IM_COL32(0, 0, 0, 145));
-                    }
-                }
-
                 // Duration countdown overlay
                 if (tRemainMs > 0) {
                     ImVec2 iconMin = ImGui::GetItemRectMin();
@@ -2958,24 +2166,10 @@ void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
                     ImVec2 textSize = ImGui::CalcTextSize(timeStr);
                     float cx = iconMin.x + (iconMax.x - iconMin.x - textSize.x) * 0.5f;
                     float cy = iconMax.y - textSize.y - 1.0f;
-                    // Color by urgency (matches player buff bar)
-                    ImU32 tTimerColor;
-                    if (tRemainMs < 10000) {
-                        float pulse = 0.7f + 0.3f * std::sin(
-                            static_cast<float>(ImGui::GetTime()) * 6.0f);
-                        tTimerColor = IM_COL32(
-                            static_cast<int>(255 * pulse),
-                            static_cast<int>(80 * pulse),
-                            static_cast<int>(60 * pulse), 255);
-                    } else if (tRemainMs < 30000) {
-                        tTimerColor = IM_COL32(255, 165, 0, 255);
-                    } else {
-                        tTimerColor = IM_COL32(255, 255, 255, 255);
-                    }
                     ImGui::GetWindowDrawList()->AddText(ImVec2(cx + 1, cy + 1),
                         IM_COL32(0, 0, 0, 200), timeStr);
                     ImGui::GetWindowDrawList()->AddText(ImVec2(cx, cy),
-                        tTimerColor, timeStr);
+                        IM_COL32(255, 255, 255, 255), timeStr);
                 }
 
                 // Stack / charge count — upper-left corner
@@ -2989,17 +2183,20 @@ void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
                         IM_COL32(255, 220, 50, 255), chargeStr);
                 }
 
-                // Tooltip: rich spell info + remaining duration
+                // Tooltip
                 if (ImGui::IsItemHovered()) {
-                    ImGui::BeginTooltip();
-                    bool richOk = spellbookScreen.renderSpellInfoTooltip(aura.spellId, gameHandler, assetMgr);
-                    if (!richOk) {
-                        std::string name = spellbookScreen.lookupSpellName(aura.spellId, assetMgr);
-                        if (name.empty()) name = "Spell #" + std::to_string(aura.spellId);
-                        ImGui::Text("%s", name.c_str());
+                    std::string name = spellbookScreen.lookupSpellName(aura.spellId, assetMgr);
+                    if (name.empty()) name = "Spell #" + std::to_string(aura.spellId);
+                    if (tRemainMs > 0) {
+                        int seconds = tRemainMs / 1000;
+                        if (seconds < 60) {
+                            ImGui::SetTooltip("%s (%ds)", name.c_str(), seconds);
+                        } else {
+                            ImGui::SetTooltip("%s (%dm %ds)", name.c_str(), seconds / 60, seconds % 60);
+                        }
+                    } else {
+                        ImGui::SetTooltip("%s", name.c_str());
                     }
-                    renderAuraRemaining(tRemainMs);
-                    ImGui::EndTooltip();
                 }
 
                 ImGui::PopID();
@@ -3043,195 +2240,22 @@ void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
                         ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
                         ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoScrollbar)) {
                     std::string totName = getEntityName(totEntity);
-                    // Class color for players; gray for NPCs
-                    ImVec4 totNameColor = colors::kSilver;
-                    if (totEntity->getType() == game::ObjectType::PLAYER) {
-                        uint8_t cid = entityClassId(totEntity.get());
-                        if (cid != 0) totNameColor = classColorVec4(cid);
-                    }
-                    // Selectable so we can attach a right-click context menu
-                    ImGui::PushStyleColor(ImGuiCol_Text, totNameColor);
-                    ImGui::PushStyleColor(ImGuiCol_Header,        ImVec4(0,0,0,0));
-                    ImGui::PushStyleColor(ImGuiCol_HeaderHovered, ImVec4(1,1,1,0.08f));
-                    ImGui::PushStyleColor(ImGuiCol_HeaderActive,  ImVec4(1,1,1,0.12f));
-                    if (ImGui::Selectable(totName.c_str(), false,
-                            ImGuiSelectableFlags_DontClosePopups,
-                            ImVec2(ImGui::CalcTextSize(totName.c_str()).x, 0))) {
-                        gameHandler.setTarget(totGuid);
-                    }
-                    ImGui::PopStyleColor(4);
-
-                    if (ImGui::BeginPopupContextItem("##ToTCtx")) {
-                        ImGui::TextDisabled("%s", totName.c_str());
-                        ImGui::Separator();
-                        if (ImGui::MenuItem("Target"))
-                            gameHandler.setTarget(totGuid);
-                        if (ImGui::MenuItem("Set Focus"))
-                            gameHandler.setFocus(totGuid);
-                        ImGui::EndPopup();
-                    }
+                    ImGui::TextColored(ImVec4(0.8f, 0.8f, 0.8f, 1.0f), "%s", totName.c_str());
 
                     if (totEntity->getType() == game::ObjectType::UNIT ||
                         totEntity->getType() == game::ObjectType::PLAYER) {
                         auto totUnit = std::static_pointer_cast<game::Unit>(totEntity);
-                        if (totUnit->getLevel() > 0) {
-                            ImGui::SameLine();
-                            ImGui::TextDisabled("Lv%u", totUnit->getLevel());
-                        }
                         uint32_t hp = totUnit->getHealth();
                         uint32_t maxHp = totUnit->getMaxHealth();
                         if (maxHp > 0) {
                             float pct = static_cast<float>(hp) / static_cast<float>(maxHp);
                             ImGui::PushStyleColor(ImGuiCol_PlotHistogram,
-                                pct > 0.5f ? colors::kFriendlyGreen :
+                                pct > 0.5f ? ImVec4(0.2f, 0.7f, 0.2f, 1.0f) :
                                 pct > 0.2f ? ImVec4(0.7f, 0.7f, 0.2f, 1.0f) :
-                                             colors::kDangerRed);
+                                             ImVec4(0.7f, 0.2f, 0.2f, 1.0f));
                             ImGui::ProgressBar(pct, ImVec2(-1, 10), "");
                             ImGui::PopStyleColor();
                         }
-
-                        // ToT cast bar — green if interruptible, red if not; pulses near completion
-                        if (auto* totCs = gameHandler.getUnitCastState(totGuid)) {
-                            float totCastPct = (totCs->timeTotal > 0.0f)
-                                ? (totCs->timeTotal - totCs->timeRemaining) / totCs->timeTotal : 0.0f;
-                            ImVec4 tcColor;
-                            if (totCastPct > 0.8f) {
-                                float pulse = 0.7f + 0.3f * std::sin(static_cast<float>(ImGui::GetTime()) * 8.0f);
-                                tcColor = totCs->interruptible
-                                    ? ImVec4(0.2f * pulse, 0.9f * pulse, 0.2f * pulse, 1.0f)
-                                    : ImVec4(1.0f * pulse, 0.1f * pulse, 0.1f * pulse, 1.0f);
-                            } else {
-                                tcColor = totCs->interruptible
-                                    ? colors::kCastGreen
-                                    : ImVec4(0.85f, 0.15f, 0.15f, 1.0f);
-                            }
-                            ImGui::PushStyleColor(ImGuiCol_PlotHistogram, tcColor);
-                            char tcLabel[48];
-                            const std::string& tcName = gameHandler.getSpellName(totCs->spellId);
-                            if (!tcName.empty())
-                                snprintf(tcLabel, sizeof(tcLabel), "%s (%.1fs)", tcName.c_str(), totCs->timeRemaining);
-                            else
-                                snprintf(tcLabel, sizeof(tcLabel), "Casting... (%.1fs)", totCs->timeRemaining);
-                            ImGui::ProgressBar(totCastPct, ImVec2(-1, 8), tcLabel);
-                            ImGui::PopStyleColor();
-                        }
-
-                        // ToT aura row — compact icons, debuffs first
-                        {
-                            const std::vector<game::AuraSlot>* totAuras = nullptr;
-                            if (totGuid == gameHandler.getPlayerGuid())
-                                totAuras = &gameHandler.getPlayerAuras();
-                            else if (totGuid == gameHandler.getTargetGuid())
-                                totAuras = &gameHandler.getTargetAuras();
-                            else
-                                totAuras = gameHandler.getUnitAuras(totGuid);
-
-                            if (totAuras) {
-                                int totActive = 0;
-                                for (const auto& a : *totAuras) if (!a.isEmpty()) totActive++;
-                                if (totActive > 0) {
-                                    auto* totAsset = services_.assetManager;
-                                    constexpr float TA_ICON = 16.0f;
-                                    constexpr int   TA_PER_ROW = 8;
-
-                                    ImGui::Separator();
-
-                                    uint64_t taNowMs = static_cast<uint64_t>(
-                                        std::chrono::duration_cast<std::chrono::milliseconds>(
-                                            std::chrono::steady_clock::now().time_since_epoch()).count());
-
-                                    std::vector<size_t> taIdx;
-                                    taIdx.reserve(totAuras->size());
-                                    for (size_t i = 0; i < totAuras->size(); ++i)
-                                        if (!(*totAuras)[i].isEmpty()) taIdx.push_back(i);
-                                    std::sort(taIdx.begin(), taIdx.end(), [&](size_t a, size_t b) {
-                                        bool aD = ((*totAuras)[a].flags & 0x80) != 0;
-                                        bool bD = ((*totAuras)[b].flags & 0x80) != 0;
-                                        if (aD != bD) return aD > bD;
-                                        int32_t ra = (*totAuras)[a].getRemainingMs(taNowMs);
-                                        int32_t rb = (*totAuras)[b].getRemainingMs(taNowMs);
-                                        if (ra < 0 && rb < 0) return false;
-                                        if (ra < 0) return false;
-                                        if (rb < 0) return true;
-                                        return ra < rb;
-                                    });
-
-                                    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(2.0f, 2.0f));
-                                    int taShown = 0;
-                                    for (size_t si = 0; si < taIdx.size() && taShown < 16; ++si) {
-                                        const auto& aura = (*totAuras)[taIdx[si]];
-                                        bool isBuff = (aura.flags & 0x80) == 0;
-
-                                        if (taShown > 0 && taShown % TA_PER_ROW != 0) ImGui::SameLine();
-                                        ImGui::PushID(static_cast<int>(taIdx[si]) + 5000);
-
-                                        ImVec4 borderCol;
-                                        if (isBuff) {
-                                            borderCol = ImVec4(0.2f, 0.8f, 0.2f, 0.9f);
-                                        } else {
-                                            uint8_t dt = gameHandler.getSpellDispelType(aura.spellId);
-                                            switch (dt) {
-                                                case 1: borderCol = ImVec4(0.15f, 0.50f, 1.00f, 0.9f); break;
-                                                case 2: borderCol = ImVec4(0.70f, 0.20f, 0.90f, 0.9f); break;
-                                                case 3: borderCol = ImVec4(0.55f, 0.30f, 0.10f, 0.9f); break;
-                                                case 4: borderCol = ImVec4(0.10f, 0.70f, 0.10f, 0.9f); break;
-                                                default: borderCol = ImVec4(0.80f, 0.20f, 0.20f, 0.9f); break;
-                                            }
-                                        }
-
-                                        VkDescriptorSet taIcon = (totAsset)
-                                            ? getSpellIcon(aura.spellId, totAsset) : VK_NULL_HANDLE;
-                                        if (taIcon) {
-                                            ImGui::PushStyleColor(ImGuiCol_Button, borderCol);
-                                            ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(1, 1));
-                                            ImGui::ImageButton("##taura",
-                                                (ImTextureID)(uintptr_t)taIcon,
-                                                ImVec2(TA_ICON - 2, TA_ICON - 2));
-                                            ImGui::PopStyleVar();
-                                            ImGui::PopStyleColor();
-                                        } else {
-                                            ImGui::PushStyleColor(ImGuiCol_Button, borderCol);
-                                            char lab[8];
-                                            snprintf(lab, sizeof(lab), "%u", aura.spellId % 10000);
-                                            ImGui::Button(lab, ImVec2(TA_ICON, TA_ICON));
-                                            ImGui::PopStyleColor();
-                                        }
-
-                                        // Duration overlay
-                                        int32_t taRemain = aura.getRemainingMs(taNowMs);
-                                        if (taRemain > 0) {
-                                            ImVec2 imin = ImGui::GetItemRectMin();
-                                            ImVec2 imax = ImGui::GetItemRectMax();
-                                            char ts[12];
-                                            fmtDurationCompact(ts, sizeof(ts), (taRemain + 999) / 1000);
-                                            ImVec2 tsz = ImGui::CalcTextSize(ts);
-                                            float cx = imin.x + (imax.x - imin.x - tsz.x) * 0.5f;
-                                            float cy = imax.y - tsz.y;
-                                            ImGui::GetWindowDrawList()->AddText(ImVec2(cx + 1, cy + 1), IM_COL32(0, 0, 0, 180), ts);
-                                            ImGui::GetWindowDrawList()->AddText(ImVec2(cx, cy), IM_COL32(255, 255, 255, 220), ts);
-                                        }
-
-                                        // Tooltip
-                                        if (ImGui::IsItemHovered()) {
-                                            ImGui::BeginTooltip();
-                                            bool richOk = spellbookScreen.renderSpellInfoTooltip(
-                                                aura.spellId, gameHandler, totAsset);
-                                            if (!richOk) {
-                                                std::string nm = spellbookScreen.lookupSpellName(aura.spellId, totAsset);
-                                                if (nm.empty()) nm = "Spell #" + std::to_string(aura.spellId);
-                                                ImGui::Text("%s", nm.c_str());
-                                            }
-                                            renderAuraRemaining(taRemain);
-                                            ImGui::EndTooltip();
-                                        }
-
-                                        ImGui::PopID();
-                                        taShown++;
-                                    }
-                                    ImGui::PopStyleVar();
-                                }
-                            }
-                        }
                     }
                 }
                 ImGui::End();
@@ -3242,527 +2266,1100 @@ void GameScreen::renderTargetFrame(game::GameHandler& gameHandler) {
     }
 }
 
-void GameScreen::renderFocusFrame(game::GameHandler& gameHandler) {
-    auto focus = gameHandler.getFocus();
-    if (!focus) return;
+void GameScreen::sendChatMessage(game::GameHandler& gameHandler) {
+    if (strlen(chatInputBuffer) > 0) {
+        std::string input(chatInputBuffer);
+        game::ChatType type = game::ChatType::SAY;
+        std::string message = input;
+        std::string target;
 
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+        // Track if a channel shortcut should change the chat type dropdown
+        int switchChatType = -1;
 
-    // Position: right side of screen, mirroring the target frame on the opposite side
-    float frameW = 200.0f;
-    float frameX = screenW - frameW - 10.0f;
+        // Check for slash commands
+        if (input.size() > 1 && input[0] == '/') {
+            std::string command = input.substr(1);
+            size_t spacePos = command.find(' ');
+            std::string cmd = (spacePos != std::string::npos) ? command.substr(0, spacePos) : command;
 
-    ImGui::SetNextWindowPos(ImVec2(frameX, 30.0f), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(frameW, 0.0f), ImGuiCond_Always);
+            // Convert command to lowercase for comparison
+            std::string cmdLower = cmd;
+            for (char& c : cmdLower) c = std::tolower(c);
 
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
-                             ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_AlwaysAutoResize;
-
-    // Determine color based on relation (same logic as target frame)
-    ImVec4 focusColor(0.7f, 0.7f, 0.7f, 1.0f);
-    if (focus->getType() == game::ObjectType::PLAYER) {
-        // Use class color for player focus targets
-        uint8_t cid = entityClassId(focus.get());
-        focusColor = (cid != 0) ? classColorVec4(cid) : kColorBrightGreen;
-    } else if (focus->getType() == game::ObjectType::UNIT) {
-        auto u = std::static_pointer_cast<game::Unit>(focus);
-        if (u->getHealth() == 0 && u->getMaxHealth() > 0) {
-            focusColor = kColorDarkGray;
-        } else if (u->isHostile()) {
-            // Tapped-by-other: grey focus frame name
-            uint32_t focDynFlags = u->getDynamicFlags();
-            bool focTapped = (focDynFlags & 0x0004) != 0 && (focDynFlags & 0x0008) == 0;
-            if (focTapped) {
-                focusColor = kColorGray;
-            } else {
-            uint32_t playerLv = gameHandler.getPlayerLevel();
-            uint32_t mobLv = u->getLevel();
-            if (mobLv == 0) {
-                focusColor = ImVec4(1.0f, 0.1f, 0.1f, 1.0f); // ?? level = skull red
-            } else {
-                int32_t diff = static_cast<int32_t>(mobLv) - static_cast<int32_t>(playerLv);
-                if (game::GameHandler::killXp(playerLv, mobLv) == 0)
-                    focusColor = kColorGray;
-                else if (diff >= 10)
-                    focusColor = ImVec4(1.0f, 0.1f, 0.1f, 1.0f);
-                else if (diff >= 5)
-                    focusColor = ImVec4(1.0f, 0.5f, 0.1f, 1.0f);
-                else if (diff >= -2)
-                    focusColor = ImVec4(1.0f, 1.0f, 0.1f, 1.0f);
-                else
-                    focusColor = kColorBrightGreen;
-            }
-            } // end tapped else
-        } else {
-            focusColor = kColorBrightGreen;
-        }
-    }
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.08f, 0.08f, 0.15f, 0.85f));
-    ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.5f, 0.5f, 0.9f, 0.8f));  // Blue tint = focus
-
-    if (ImGui::Begin("##FocusFrame", nullptr, flags)) {
-        // "Focus" label
-        ImGui::TextDisabled("[Focus]");
-        ImGui::SameLine();
-
-        // Raid mark icon (star, circle, diamond, …) preceding the name
-        {
-            static constexpr struct { const char* sym; ImU32 col; } kFocusMarks[] = {
-                { "\xe2\x98\x85", IM_COL32(255, 204,   0, 255) },  // 0 Star     (yellow)
-                { "\xe2\x97\x8f", IM_COL32(255, 103,   0, 255) },  // 1 Circle   (orange)
-                { "\xe2\x97\x86", IM_COL32(160,  32, 240, 255) },  // 2 Diamond  (purple)
-                { "\xe2\x96\xb2", IM_COL32( 50, 200,  50, 255) },  // 3 Triangle (green)
-                { "\xe2\x97\x8c", IM_COL32( 80, 160, 255, 255) },  // 4 Moon     (blue)
-                { "\xe2\x96\xa0", IM_COL32( 50, 200, 220, 255) },  // 5 Square   (teal)
-                { "\xe2\x9c\x9d", IM_COL32(255,  80,  80, 255) },  // 6 Cross    (red)
-                { "\xe2\x98\xa0", IM_COL32(255, 255, 255, 255) },  // 7 Skull    (white)
-            };
-            uint8_t fmark = gameHandler.getEntityRaidMark(focus->getGuid());
-            if (fmark < game::GameHandler::kRaidMarkCount) {
-                ImGui::GetWindowDrawList()->AddText(
-                    ImGui::GetCursorScreenPos(),
-                    kFocusMarks[fmark].col, kFocusMarks[fmark].sym);
-                ImGui::SetCursorPosX(ImGui::GetCursorPosX() + 18.0f);
-            }
-        }
-
-        std::string focusName = getEntityName(focus);
-        ImGui::PushStyleColor(ImGuiCol_Text, focusColor);
-        ImGui::PushStyleColor(ImGuiCol_Header,        ImVec4(0,0,0,0));
-        ImGui::PushStyleColor(ImGuiCol_HeaderHovered, ImVec4(1,1,1,0.08f));
-        ImGui::PushStyleColor(ImGuiCol_HeaderActive,  ImVec4(1,1,1,0.12f));
-        ImGui::Selectable(focusName.c_str(), false, ImGuiSelectableFlags_DontClosePopups,
-                          ImVec2(ImGui::CalcTextSize(focusName.c_str()).x, 0));
-        ImGui::PopStyleColor(4);
-
-        // Right-click context menu on focus frame
-        if (ImGui::BeginPopupContextItem("##FocusFrameCtx")) {
-            ImGui::TextDisabled("%s", focusName.c_str());
-            ImGui::Separator();
-            if (ImGui::MenuItem("Target"))
-                gameHandler.setTarget(focus->getGuid());
-            if (ImGui::MenuItem("Clear Focus"))
-                gameHandler.clearFocus();
-            if (focus->getType() == game::ObjectType::PLAYER) {
-                ImGui::Separator();
-                if (ImGui::MenuItem("Whisper")) {
-                    chatPanel_.setWhisperTarget(focusName);
-                }
-                if (ImGui::MenuItem("Invite to Group"))
-                    gameHandler.inviteToGroup(focusName);
-                if (ImGui::MenuItem("Trade"))
-                    gameHandler.initiateTrade(focus->getGuid());
-                if (ImGui::MenuItem("Duel"))
-                    gameHandler.proposeDuel(focus->getGuid());
-                if (ImGui::MenuItem("Inspect")) {
-                    gameHandler.setTarget(focus->getGuid());
-                    gameHandler.inspectTarget();
-                    socialPanel_.showInspectWindow_ = true;
-                }
-                ImGui::Separator();
-                if (ImGui::MenuItem("Add Friend"))
-                    gameHandler.addFriend(focusName);
-                if (ImGui::MenuItem("Ignore"))
-                    gameHandler.addIgnore(focusName);
-            }
-            ImGui::EndPopup();
-        }
-
-        // Group leader crown — golden ♛ when the focused player is the party/raid leader
-        if (gameHandler.isInGroup() && focus->getType() == game::ObjectType::PLAYER) {
-            if (gameHandler.getPartyData().leaderGuid == focus->getGuid()) {
-                ImGui::SameLine(0, 4);
-                ImGui::TextColored(colors::kSymbolGold, "\xe2\x99\x9b");
-                if (ImGui::IsItemHovered()) ImGui::SetTooltip("Group Leader");
-            }
-        }
-
-        // Quest giver indicator and classification badge for NPC focus targets
-        if (focus->getType() == game::ObjectType::UNIT) {
-            auto focusUnit = std::static_pointer_cast<game::Unit>(focus);
-
-            // Quest indicator: ! / ?
-            {
-                using QGS = game::QuestGiverStatus;
-                QGS qgs = gameHandler.getQuestGiverStatus(focus->getGuid());
-                if (qgs == QGS::AVAILABLE) {
-                    ImGui::SameLine(0, 4);
-                    ImGui::TextColored(colors::kBrightGold, "!");
-                } else if (qgs == QGS::AVAILABLE_LOW) {
-                    ImGui::SameLine(0, 4);
-                    ImGui::TextColored(kColorGray, "!");
-                } else if (qgs == QGS::REWARD || qgs == QGS::REWARD_REP) {
-                    ImGui::SameLine(0, 4);
-                    ImGui::TextColored(colors::kBrightGold, "?");
-                } else if (qgs == QGS::INCOMPLETE) {
-                    ImGui::SameLine(0, 4);
-                    ImGui::TextColored(kColorGray, "?");
-                }
+            // Special commands
+            if (cmdLower == "logout") {
+                core::Application::getInstance().logoutToLogin();
+                chatInputBuffer[0] = '\0';
+                return;
             }
 
-            // Classification badge
-            int fRank = gameHandler.getCreatureRank(focusUnit->getEntry());
-            if (fRank == 1)      { ImGui::SameLine(0,4); ImGui::TextColored(ImVec4(1.0f,0.8f,0.2f,1.0f), "[Elite]"); }
-            else if (fRank == 2) { ImGui::SameLine(0,4); ImGui::TextColored(ImVec4(0.8f,0.4f,1.0f,1.0f), "[Rare Elite]"); }
-            else if (fRank == 3) { ImGui::SameLine(0,4); ImGui::TextColored(colors::kRed, "[Boss]"); }
-            else if (fRank == 4) { ImGui::SameLine(0,4); ImGui::TextColored(ImVec4(0.5f,0.9f,1.0f,1.0f), "[Rare]"); }
-
-            // Creature type
-            {
-                uint32_t fctype = gameHandler.getCreatureType(focusUnit->getEntry());
-                const char* fctName = nullptr;
-                switch (fctype) {
-                    case 1: fctName="Beast"; break;     case 2: fctName="Dragonkin"; break;
-                    case 3: fctName="Demon"; break;     case 4: fctName="Elemental"; break;
-                    case 5: fctName="Giant"; break;     case 6: fctName="Undead"; break;
-                    case 7: fctName="Humanoid"; break;  case 8: fctName="Critter"; break;
-                    case 9: fctName="Mechanical"; break; case 11: fctName="Totem"; break;
-                    case 12: fctName="Non-combat Pet"; break; case 13: fctName="Gas Cloud"; break;
-                    default: break;
-                }
-                if (fctName) {
-                    ImGui::SameLine(0, 4);
-                    ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 0.9f), "(%s)", fctName);
-                }
+            // /invite command
+            if (cmdLower == "invite" && spacePos != std::string::npos) {
+                std::string targetName = command.substr(spacePos + 1);
+                gameHandler.inviteToGroup(targetName);
+                chatInputBuffer[0] = '\0';
+                return;
             }
 
-            // Creature subtitle
-            const std::string fSub = gameHandler.getCachedCreatureSubName(focusUnit->getEntry());
-            if (!fSub.empty())
-                ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 0.9f), "<%s>", fSub.c_str());
-        }
-
-        // Player guild name on focus frame
-        if (focus->getType() == game::ObjectType::PLAYER) {
-            uint32_t guildId = gameHandler.getEntityGuildId(focus->getGuid());
-            if (guildId != 0) {
-                const std::string& gn = gameHandler.lookupGuildName(guildId);
-                if (!gn.empty()) {
-                    ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 0.9f), "<%s>", gn.c_str());
-                }
-            }
-        }
-
-        if (ImGui::BeginPopupContextItem("##FocusNameCtx")) {
-            const bool focusIsPlayer = (focus->getType() == game::ObjectType::PLAYER);
-            const uint64_t fGuid = focus->getGuid();
-            ImGui::TextDisabled("%s", focusName.c_str());
-            ImGui::Separator();
-            if (ImGui::MenuItem("Target"))
-                gameHandler.setTarget(fGuid);
-            if (ImGui::MenuItem("Clear Focus"))
-                gameHandler.clearFocus();
-            if (focusIsPlayer) {
-                ImGui::Separator();
-                if (ImGui::MenuItem("Whisper")) {
-                    chatPanel_.setWhisperTarget(focusName);
-                }
-                if (ImGui::MenuItem("Invite to Group"))
-                    gameHandler.inviteToGroup(focusName);
-                if (ImGui::MenuItem("Trade"))
-                    gameHandler.initiateTrade(fGuid);
-                if (ImGui::MenuItem("Duel"))
-                    gameHandler.proposeDuel(fGuid);
-                if (ImGui::MenuItem("Inspect")) {
-                    gameHandler.setTarget(fGuid);
-                    gameHandler.inspectTarget();
-                    socialPanel_.showInspectWindow_ = true;
-                }
-                ImGui::Separator();
-                if (ImGui::MenuItem("Add Friend"))
-                    gameHandler.addFriend(focusName);
-                if (ImGui::MenuItem("Ignore"))
-                    gameHandler.addIgnore(focusName);
-            }
-            ImGui::EndPopup();
-        }
-
-        if (focus->getType() == game::ObjectType::UNIT ||
-            focus->getType() == game::ObjectType::PLAYER) {
-            auto unit = std::static_pointer_cast<game::Unit>(focus);
-
-            // Level + health on same row
-            ImGui::SameLine();
-            if (unit->getLevel() == 0)
-                ImGui::TextDisabled("Lv ??");
-            else
-                ImGui::TextDisabled("Lv %u", unit->getLevel());
-
-            uint32_t hp = unit->getHealth();
-            uint32_t maxHp = unit->getMaxHealth();
-            if (maxHp > 0) {
-                float pct = static_cast<float>(hp) / static_cast<float>(maxHp);
-                ImGui::PushStyleColor(ImGuiCol_PlotHistogram,
-                    pct > 0.5f ? colors::kFriendlyGreen :
-                    pct > 0.2f ? ImVec4(0.7f, 0.7f, 0.2f, 1.0f) :
-                                 colors::kDangerRed);
-                char overlay[32];
-                snprintf(overlay, sizeof(overlay), "%u / %u", hp, maxHp);
-                ImGui::ProgressBar(pct, ImVec2(-1, 14), overlay);
-                ImGui::PopStyleColor();
-
-                // Power bar
-                uint8_t pType = unit->getPowerType();
-                uint32_t pwr = unit->getPower();
-                uint32_t maxPwr = unit->getMaxPower();
-                if (maxPwr == 0 && (pType == 1 || pType == 3)) maxPwr = 100;
-                if (maxPwr > 0) {
-                    float mpPct = static_cast<float>(pwr) / static_cast<float>(maxPwr);
-                    ImVec4 pwrColor;
-                    switch (pType) {
-                        case 0: pwrColor = colors::kManaBlue; break;
-                        case 1: pwrColor = colors::kDarkRed; break;
-                        case 3: pwrColor = colors::kEnergyYellow; break;
-                        case 6: pwrColor = colors::kRunicRed; break;
-                        default: pwrColor = colors::kManaBlue; break;
-                    }
-                    ImGui::PushStyleColor(ImGuiCol_PlotHistogram, pwrColor);
-                    ImGui::ProgressBar(mpPct, ImVec2(-1, 10), "");
-                    ImGui::PopStyleColor();
-                }
+            // /inspect command
+            if (cmdLower == "inspect") {
+                gameHandler.inspectTarget();
+                chatInputBuffer[0] = '\0';
+                return;
             }
 
-            // Focus cast bar
-            const auto* focusCast = gameHandler.getUnitCastState(focus->getGuid());
-            if (focusCast) {
-                float total = focusCast->timeTotal > 0.f ? focusCast->timeTotal : 1.f;
-                float rem   = focusCast->timeRemaining;
-                float prog  = std::clamp(1.0f - rem / total, 0.f, 1.f);
-                const std::string& spName = gameHandler.getSpellName(focusCast->spellId);
-                // Pulse orange when > 80% complete — interrupt window closing
-                ImVec4 focusCastColor;
-                if (prog > 0.8f) {
-                    float pulse = 0.7f + 0.3f * std::sin(static_cast<float>(ImGui::GetTime()) * 8.0f);
-                    focusCastColor = ImVec4(1.0f * pulse, 0.5f * pulse, 0.0f, 1.0f);
-                } else {
-                    focusCastColor = ImVec4(0.9f, 0.3f, 0.2f, 1.0f);
-                }
-                ImGui::PushStyleColor(ImGuiCol_PlotHistogram, focusCastColor);
-                char castBuf[64];
-                if (!spName.empty())
-                    snprintf(castBuf, sizeof(castBuf), "%s (%.1fs)", spName.c_str(), rem);
-                else
-                    snprintf(castBuf, sizeof(castBuf), "Casting... (%.1fs)", rem);
-                {
-                    auto* fcAsset = services_.assetManager;
-                    VkDescriptorSet fcIcon = (focusCast->spellId != 0 && fcAsset)
-                        ? getSpellIcon(focusCast->spellId, fcAsset) : VK_NULL_HANDLE;
-                    if (fcIcon) {
-                        ImGui::Image((ImTextureID)(uintptr_t)fcIcon, ImVec2(12, 12));
-                        ImGui::SameLine(0, 2);
-                        ImGui::ProgressBar(prog, ImVec2(-1, 12), castBuf);
+            // /time command
+            if (cmdLower == "time") {
+                gameHandler.queryServerTime();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /played command
+            if (cmdLower == "played") {
+                gameHandler.requestPlayedTime();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /who commands
+            if (cmdLower == "who" || cmdLower == "whois" || cmdLower == "online" || cmdLower == "players") {
+                std::string query;
+                if (spacePos != std::string::npos) {
+                    query = command.substr(spacePos + 1);
+                    // Trim leading/trailing whitespace
+                    size_t first = query.find_first_not_of(" \t\r\n");
+                    if (first == std::string::npos) {
+                        query.clear();
                     } else {
-                        ImGui::ProgressBar(prog, ImVec2(-1, 12), castBuf);
+                        size_t last = query.find_last_not_of(" \t\r\n");
+                        query = query.substr(first, last - first + 1);
                     }
                 }
-                ImGui::PopStyleColor();
-            }
-        }
 
-        // Focus auras — buffs first, then debuffs, up to 8 icons wide
-        {
-            const std::vector<game::AuraSlot>* focusAuras =
-                (focus->getGuid() == gameHandler.getTargetGuid())
-                    ? &gameHandler.getTargetAuras()
-                    : gameHandler.getUnitAuras(focus->getGuid());
-
-            if (focusAuras) {
-                int activeCount = 0;
-                for (const auto& a : *focusAuras) if (!a.isEmpty()) activeCount++;
-                if (activeCount > 0) {
-                    auto* focusAsset = services_.assetManager;
-                    constexpr float FA_ICON = 20.0f;
-                    constexpr int   FA_PER_ROW = 10;
-
-                    ImGui::Separator();
-
-                    uint64_t faNowMs = static_cast<uint64_t>(
-                        std::chrono::duration_cast<std::chrono::milliseconds>(
-                            std::chrono::steady_clock::now().time_since_epoch()).count());
-
-                    // Sort: debuffs first (so hostile-caster info is prominent), then buffs
-                    std::vector<size_t> faIdx;
-                    faIdx.reserve(focusAuras->size());
-                    for (size_t i = 0; i < focusAuras->size(); ++i)
-                        if (!(*focusAuras)[i].isEmpty()) faIdx.push_back(i);
-                    std::sort(faIdx.begin(), faIdx.end(), [&](size_t a, size_t b) {
-                        bool aD = ((*focusAuras)[a].flags & 0x80) != 0;
-                        bool bD = ((*focusAuras)[b].flags & 0x80) != 0;
-                        if (aD != bD) return aD > bD; // debuffs first
-                        int32_t ra = (*focusAuras)[a].getRemainingMs(faNowMs);
-                        int32_t rb = (*focusAuras)[b].getRemainingMs(faNowMs);
-                        if (ra < 0 && rb < 0) return false;
-                        if (ra < 0) return false;
-                        if (rb < 0) return true;
-                        return ra < rb;
-                    });
-
-                    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(2.0f, 2.0f));
-                    int faShown = 0;
-                    for (size_t si = 0; si < faIdx.size() && faShown < 20; ++si) {
-                        const auto& aura = (*focusAuras)[faIdx[si]];
-                        bool isBuff = (aura.flags & 0x80) == 0;
-
-                        if (faShown > 0 && faShown % FA_PER_ROW != 0) ImGui::SameLine();
-                        ImGui::PushID(static_cast<int>(faIdx[si]) + 3000);
-
-                        ImVec4 borderCol;
-                        if (isBuff) {
-                            borderCol = ImVec4(0.2f, 0.8f, 0.2f, 0.9f);
-                        } else {
-                            uint8_t dt = gameHandler.getSpellDispelType(aura.spellId);
-                            switch (dt) {
-                                case 1: borderCol = ImVec4(0.15f, 0.50f, 1.00f, 0.9f); break;
-                                case 2: borderCol = ImVec4(0.70f, 0.20f, 0.90f, 0.9f); break;
-                                case 3: borderCol = ImVec4(0.55f, 0.30f, 0.10f, 0.9f); break;
-                                case 4: borderCol = ImVec4(0.10f, 0.70f, 0.10f, 0.9f); break;
-                                default: borderCol = ImVec4(0.80f, 0.20f, 0.20f, 0.9f); break;
-                            }
-                        }
-
-                        VkDescriptorSet faIcon = (focusAsset)
-                            ? getSpellIcon(aura.spellId, focusAsset) : VK_NULL_HANDLE;
-                        if (faIcon) {
-                            ImGui::PushStyleColor(ImGuiCol_Button, borderCol);
-                            ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(1, 1));
-                            ImGui::ImageButton("##faura",
-                                (ImTextureID)(uintptr_t)faIcon,
-                                ImVec2(FA_ICON - 2, FA_ICON - 2));
-                            ImGui::PopStyleVar();
-                            ImGui::PopStyleColor();
-                        } else {
-                            ImGui::PushStyleColor(ImGuiCol_Button, borderCol);
-                            char lab[8];
-                            snprintf(lab, sizeof(lab), "%u", aura.spellId);
-                            ImGui::Button(lab, ImVec2(FA_ICON, FA_ICON));
-                            ImGui::PopStyleColor();
-                        }
-
-                        // Duration overlay
-                        int32_t faRemain = aura.getRemainingMs(faNowMs);
-                        if (faRemain > 0) {
-                            ImVec2 imin = ImGui::GetItemRectMin();
-                            ImVec2 imax = ImGui::GetItemRectMax();
-                            char ts[12];
-                            fmtDurationCompact(ts, sizeof(ts), (faRemain + 999) / 1000);
-                            ImVec2 tsz = ImGui::CalcTextSize(ts);
-                            float cx = imin.x + (imax.x - imin.x - tsz.x) * 0.5f;
-                            float cy = imax.y - tsz.y - 1.0f;
-                            ImGui::GetWindowDrawList()->AddText(ImVec2(cx + 1, cy + 1), IM_COL32(0, 0, 0, 180), ts);
-                            ImGui::GetWindowDrawList()->AddText(ImVec2(cx, cy), IM_COL32(255, 255, 255, 220), ts);
-                        }
-
-                        // Stack / charge count — upper-left corner (parity with target frame)
-                        if (aura.charges > 1) {
-                            ImVec2 faMin = ImGui::GetItemRectMin();
-                            char chargeStr[8];
-                            snprintf(chargeStr, sizeof(chargeStr), "%u", static_cast<unsigned>(aura.charges));
-                            ImGui::GetWindowDrawList()->AddText(ImVec2(faMin.x + 3, faMin.y + 3),
-                                IM_COL32(0, 0, 0, 200), chargeStr);
-                            ImGui::GetWindowDrawList()->AddText(ImVec2(faMin.x + 2, faMin.y + 2),
-                                IM_COL32(255, 220, 50, 255), chargeStr);
-                        }
-
-                        // Tooltip
-                        if (ImGui::IsItemHovered()) {
-                            ImGui::BeginTooltip();
-                            bool richOk = spellbookScreen.renderSpellInfoTooltip(
-                                aura.spellId, gameHandler, focusAsset);
-                            if (!richOk) {
-                                std::string nm = spellbookScreen.lookupSpellName(aura.spellId, focusAsset);
-                                if (nm.empty()) nm = "Spell #" + std::to_string(aura.spellId);
-                                ImGui::Text("%s", nm.c_str());
-                            }
-                            renderAuraRemaining(faRemain);
-                            ImGui::EndTooltip();
-                        }
-
-                        ImGui::PopID();
-                        faShown++;
-                    }
-                    ImGui::PopStyleVar();
+                if ((cmdLower == "whois") && query.empty()) {
+                    game::MessageChatData msg;
+                    msg.type = game::ChatType::SYSTEM;
+                    msg.language = game::ChatLanguage::UNIVERSAL;
+                    msg.message = "Usage: /whois <playerName>";
+                    gameHandler.addLocalChatMessage(msg);
+                    chatInputBuffer[0] = '\0';
+                    return;
                 }
-            }
-        }
 
-        // Target-of-Focus: who the focus target is currently targeting
-        {
-            uint64_t fofGuid = 0;
-            const auto& fFields = focus->getFields();
-            auto fItLo = fFields.find(game::fieldIndex(game::UF::UNIT_FIELD_TARGET_LO));
-            if (fItLo != fFields.end()) {
-                fofGuid = fItLo->second;
-                auto fItHi = fFields.find(game::fieldIndex(game::UF::UNIT_FIELD_TARGET_HI));
-                if (fItHi != fFields.end())
-                    fofGuid |= (static_cast<uint64_t>(fItHi->second) << 32);
-            }
-            if (fofGuid != 0) {
-                auto fofEnt = gameHandler.getEntityManager().getEntity(fofGuid);
-                std::string fofName;
-                ImVec4 fofColor(0.7f, 0.7f, 0.7f, 1.0f);
-                if (fofGuid == gameHandler.getPlayerGuid()) {
-                    fofName = "You";
-                    fofColor = kColorBrightGreen;
-                } else if (fofEnt) {
-                    fofName = getEntityName(fofEnt);
-                    uint8_t fcid = entityClassId(fofEnt.get());
-                    if (fcid != 0) fofColor = classColorVec4(fcid);
+                if (cmdLower == "who" && (query == "help" || query == "?")) {
+                    game::MessageChatData msg;
+                    msg.type = game::ChatType::SYSTEM;
+                    msg.language = game::ChatLanguage::UNIVERSAL;
+                    msg.message = "Who commands: /who [name/filter], /whois <name>, /online";
+                    gameHandler.addLocalChatMessage(msg);
+                    chatInputBuffer[0] = '\0';
+                    return;
                 }
-                if (!fofName.empty()) {
-                    ImGui::TextDisabled("▶");
-                    ImGui::SameLine(0, 2);
-                    ImGui::TextColored(fofColor, "%s", fofName.c_str());
-                    if (ImGui::IsItemHovered())
-                        ImGui::SetTooltip("Focus's target: %s\nClick to target", fofName.c_str());
-                    if (ImGui::IsItemClicked())
-                        gameHandler.setTarget(fofGuid);
 
-                    // Compact health bar for target-of-focus
-                    if (fofEnt) {
-                        auto fofUnit = std::dynamic_pointer_cast<game::Unit>(fofEnt);
-                        if (fofUnit && fofUnit->getMaxHealth() > 0) {
-                            float fofPct = static_cast<float>(fofUnit->getHealth()) /
-                                           static_cast<float>(fofUnit->getMaxHealth());
-                            ImVec4 fofBarColor =
-                                fofPct > 0.5f ? colors::kCastGreen :
-                                fofPct > 0.2f ? ImVec4(0.75f, 0.75f, 0.2f, 1.0f) :
-                                               ImVec4(0.75f, 0.2f, 0.2f, 1.0f);
-                            ImGui::PushStyleColor(ImGuiCol_PlotHistogram, fofBarColor);
-                            ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(0.15f, 0.15f, 0.15f, 0.8f));
-                            char fofOverlay[32];
-                            snprintf(fofOverlay, sizeof(fofOverlay), "%u%%",
-                                     static_cast<unsigned>(fofPct * 100.0f + 0.5f));
-                            ImGui::ProgressBar(fofPct, ImVec2(-1, 10), fofOverlay);
-                            ImGui::PopStyleColor(2);
-                        }
+                gameHandler.queryWho(query);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /roll command
+            if (cmdLower == "roll" || cmdLower == "random" || cmdLower == "rnd") {
+                uint32_t minRoll = 1;
+                uint32_t maxRoll = 100;
+
+                if (spacePos != std::string::npos) {
+                    std::string args = command.substr(spacePos + 1);
+                    size_t dashPos = args.find('-');
+                    size_t spacePos2 = args.find(' ');
+
+                    if (dashPos != std::string::npos) {
+                        // Format: /roll 1-100
+                        try {
+                            minRoll = std::stoul(args.substr(0, dashPos));
+                            maxRoll = std::stoul(args.substr(dashPos + 1));
+                        } catch (...) {}
+                    } else if (spacePos2 != std::string::npos) {
+                        // Format: /roll 1 100
+                        try {
+                            minRoll = std::stoul(args.substr(0, spacePos2));
+                            maxRoll = std::stoul(args.substr(spacePos2 + 1));
+                        } catch (...) {}
+                    } else {
+                        // Format: /roll 100 (means 1-100)
+                        try {
+                            maxRoll = std::stoul(args);
+                        } catch (...) {}
                     }
                 }
+
+                gameHandler.randomRoll(minRoll, maxRoll);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /friend or /addfriend command
+            if (cmdLower == "friend" || cmdLower == "addfriend") {
+                if (spacePos != std::string::npos) {
+                    std::string args = command.substr(spacePos + 1);
+                    size_t subCmdSpace = args.find(' ');
+
+                    if (cmdLower == "friend" && subCmdSpace != std::string::npos) {
+                        std::string subCmd = args.substr(0, subCmdSpace);
+                        std::transform(subCmd.begin(), subCmd.end(), subCmd.begin(), ::tolower);
+
+                        if (subCmd == "add") {
+                            std::string playerName = args.substr(subCmdSpace + 1);
+                            gameHandler.addFriend(playerName);
+                            chatInputBuffer[0] = '\0';
+                            return;
+                        } else if (subCmd == "remove" || subCmd == "delete" || subCmd == "rem") {
+                            std::string playerName = args.substr(subCmdSpace + 1);
+                            gameHandler.removeFriend(playerName);
+                            chatInputBuffer[0] = '\0';
+                            return;
+                        }
+                    } else {
+                        // /addfriend name or /friend name (assume add)
+                        gameHandler.addFriend(args);
+                        chatInputBuffer[0] = '\0';
+                        return;
+                    }
+                }
+
+                game::MessageChatData msg;
+                msg.type = game::ChatType::SYSTEM;
+                msg.language = game::ChatLanguage::UNIVERSAL;
+                msg.message = "Usage: /friend add <name> or /friend remove <name>";
+                gameHandler.addLocalChatMessage(msg);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /removefriend or /delfriend command
+            if (cmdLower == "removefriend" || cmdLower == "delfriend" || cmdLower == "remfriend") {
+                if (spacePos != std::string::npos) {
+                    std::string playerName = command.substr(spacePos + 1);
+                    gameHandler.removeFriend(playerName);
+                    chatInputBuffer[0] = '\0';
+                    return;
+                }
+
+                game::MessageChatData msg;
+                msg.type = game::ChatType::SYSTEM;
+                msg.language = game::ChatLanguage::UNIVERSAL;
+                msg.message = "Usage: /removefriend <name>";
+                gameHandler.addLocalChatMessage(msg);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /ignore command
+            if (cmdLower == "ignore") {
+                if (spacePos != std::string::npos) {
+                    std::string playerName = command.substr(spacePos + 1);
+                    gameHandler.addIgnore(playerName);
+                    chatInputBuffer[0] = '\0';
+                    return;
+                }
+
+                game::MessageChatData msg;
+                msg.type = game::ChatType::SYSTEM;
+                msg.language = game::ChatLanguage::UNIVERSAL;
+                msg.message = "Usage: /ignore <name>";
+                gameHandler.addLocalChatMessage(msg);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /unignore command
+            if (cmdLower == "unignore") {
+                if (spacePos != std::string::npos) {
+                    std::string playerName = command.substr(spacePos + 1);
+                    gameHandler.removeIgnore(playerName);
+                    chatInputBuffer[0] = '\0';
+                    return;
+                }
+
+                game::MessageChatData msg;
+                msg.type = game::ChatType::SYSTEM;
+                msg.language = game::ChatLanguage::UNIVERSAL;
+                msg.message = "Usage: /unignore <name>";
+                gameHandler.addLocalChatMessage(msg);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /dismount command
+            if (cmdLower == "dismount") {
+                gameHandler.dismount();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /sit command
+            if (cmdLower == "sit") {
+                gameHandler.setStandState(1);  // 1 = sit
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /stand command
+            if (cmdLower == "stand") {
+                gameHandler.setStandState(0);  // 0 = stand
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /kneel command
+            if (cmdLower == "kneel") {
+                gameHandler.setStandState(8);  // 8 = kneel
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /logout command (already exists but using /logout instead of going to login)
+            if (cmdLower == "logout" || cmdLower == "camp") {
+                gameHandler.requestLogout();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /cancellogout command
+            if (cmdLower == "cancellogout") {
+                gameHandler.cancelLogout();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /helm command
+            if (cmdLower == "helm" || cmdLower == "helmet" || cmdLower == "showhelm") {
+                gameHandler.toggleHelm();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /cloak command
+            if (cmdLower == "cloak" || cmdLower == "showcloak") {
+                gameHandler.toggleCloak();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /follow command
+            if (cmdLower == "follow" || cmdLower == "f") {
+                gameHandler.followTarget();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /assist command
+            if (cmdLower == "assist") {
+                gameHandler.assistTarget();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /pvp command
+            if (cmdLower == "pvp") {
+                gameHandler.togglePvp();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /ginfo command
+            if (cmdLower == "ginfo" || cmdLower == "guildinfo") {
+                gameHandler.requestGuildInfo();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /groster command
+            if (cmdLower == "groster" || cmdLower == "guildroster") {
+                gameHandler.requestGuildRoster();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /gmotd command
+            if (cmdLower == "gmotd" || cmdLower == "guildmotd") {
+                if (spacePos != std::string::npos) {
+                    std::string motd = command.substr(spacePos + 1);
+                    gameHandler.setGuildMotd(motd);
+                    chatInputBuffer[0] = '\0';
+                    return;
+                }
+
+                game::MessageChatData msg;
+                msg.type = game::ChatType::SYSTEM;
+                msg.language = game::ChatLanguage::UNIVERSAL;
+                msg.message = "Usage: /gmotd <message>";
+                gameHandler.addLocalChatMessage(msg);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /gpromote command
+            if (cmdLower == "gpromote" || cmdLower == "guildpromote") {
+                if (spacePos != std::string::npos) {
+                    std::string playerName = command.substr(spacePos + 1);
+                    gameHandler.promoteGuildMember(playerName);
+                    chatInputBuffer[0] = '\0';
+                    return;
+                }
+
+                game::MessageChatData msg;
+                msg.type = game::ChatType::SYSTEM;
+                msg.language = game::ChatLanguage::UNIVERSAL;
+                msg.message = "Usage: /gpromote <player>";
+                gameHandler.addLocalChatMessage(msg);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /gdemote command
+            if (cmdLower == "gdemote" || cmdLower == "guilddemote") {
+                if (spacePos != std::string::npos) {
+                    std::string playerName = command.substr(spacePos + 1);
+                    gameHandler.demoteGuildMember(playerName);
+                    chatInputBuffer[0] = '\0';
+                    return;
+                }
+
+                game::MessageChatData msg;
+                msg.type = game::ChatType::SYSTEM;
+                msg.language = game::ChatLanguage::UNIVERSAL;
+                msg.message = "Usage: /gdemote <player>";
+                gameHandler.addLocalChatMessage(msg);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /gquit command
+            if (cmdLower == "gquit" || cmdLower == "guildquit" || cmdLower == "leaveguild") {
+                gameHandler.leaveGuild();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /ginvite command
+            if (cmdLower == "ginvite" || cmdLower == "guildinvite") {
+                if (spacePos != std::string::npos) {
+                    std::string playerName = command.substr(spacePos + 1);
+                    gameHandler.inviteToGuild(playerName);
+                    chatInputBuffer[0] = '\0';
+                    return;
+                }
+
+                game::MessageChatData msg;
+                msg.type = game::ChatType::SYSTEM;
+                msg.language = game::ChatLanguage::UNIVERSAL;
+                msg.message = "Usage: /ginvite <player>";
+                gameHandler.addLocalChatMessage(msg);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /gkick command
+            if (cmdLower == "gkick" || cmdLower == "guildkick") {
+                if (spacePos != std::string::npos) {
+                    std::string playerName = command.substr(spacePos + 1);
+                    gameHandler.kickGuildMember(playerName);
+                    chatInputBuffer[0] = '\0';
+                    return;
+                }
+
+                game::MessageChatData msg;
+                msg.type = game::ChatType::SYSTEM;
+                msg.language = game::ChatLanguage::UNIVERSAL;
+                msg.message = "Usage: /gkick <player>";
+                gameHandler.addLocalChatMessage(msg);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /gcreate command
+            if (cmdLower == "gcreate" || cmdLower == "guildcreate") {
+                if (spacePos != std::string::npos) {
+                    std::string guildName = command.substr(spacePos + 1);
+                    gameHandler.createGuild(guildName);
+                    chatInputBuffer[0] = '\0';
+                    return;
+                }
+
+                game::MessageChatData msg;
+                msg.type = game::ChatType::SYSTEM;
+                msg.language = game::ChatLanguage::UNIVERSAL;
+                msg.message = "Usage: /gcreate <guild name>";
+                gameHandler.addLocalChatMessage(msg);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /gdisband command
+            if (cmdLower == "gdisband" || cmdLower == "guilddisband") {
+                gameHandler.disbandGuild();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /gleader command
+            if (cmdLower == "gleader" || cmdLower == "guildleader") {
+                if (spacePos != std::string::npos) {
+                    std::string playerName = command.substr(spacePos + 1);
+                    gameHandler.setGuildLeader(playerName);
+                    chatInputBuffer[0] = '\0';
+                    return;
+                }
+
+                game::MessageChatData msg;
+                msg.type = game::ChatType::SYSTEM;
+                msg.language = game::ChatLanguage::UNIVERSAL;
+                msg.message = "Usage: /gleader <player>";
+                gameHandler.addLocalChatMessage(msg);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /readycheck command
+            if (cmdLower == "readycheck" || cmdLower == "rc") {
+                gameHandler.initiateReadyCheck();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /ready command (respond yes to ready check)
+            if (cmdLower == "ready") {
+                gameHandler.respondToReadyCheck(true);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /notready command (respond no to ready check)
+            if (cmdLower == "notready" || cmdLower == "nr") {
+                gameHandler.respondToReadyCheck(false);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /yield or /forfeit command
+            if (cmdLower == "yield" || cmdLower == "forfeit" || cmdLower == "surrender") {
+                gameHandler.forfeitDuel();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // AFK command
+            if (cmdLower == "afk" || cmdLower == "away") {
+                std::string afkMsg = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
+                gameHandler.toggleAfk(afkMsg);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // DND command
+            if (cmdLower == "dnd" || cmdLower == "busy") {
+                std::string dndMsg = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
+                gameHandler.toggleDnd(dndMsg);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // Reply command
+            if (cmdLower == "r" || cmdLower == "reply") {
+                std::string lastSender = gameHandler.getLastWhisperSender();
+                if (lastSender.empty()) {
+                    game::MessageChatData errMsg;
+                    errMsg.type = game::ChatType::SYSTEM;
+                    errMsg.language = game::ChatLanguage::UNIVERSAL;
+                    errMsg.message = "No one has whispered you yet.";
+                    gameHandler.addLocalChatMessage(errMsg);
+                    chatInputBuffer[0] = '\0';
+                    return;
+                }
+                // Set whisper target to last whisper sender
+                strncpy(whisperTargetBuffer, lastSender.c_str(), sizeof(whisperTargetBuffer) - 1);
+                whisperTargetBuffer[sizeof(whisperTargetBuffer) - 1] = '\0';
+                if (spacePos != std::string::npos) {
+                    // /r message — send reply immediately
+                    std::string replyMsg = command.substr(spacePos + 1);
+                    gameHandler.sendChatMessage(game::ChatType::WHISPER, replyMsg, lastSender);
+                }
+                // Switch to whisper tab
+                selectedChatType = 4;
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // Party/Raid management commands
+            if (cmdLower == "uninvite" || cmdLower == "kick") {
+                if (spacePos != std::string::npos) {
+                    std::string playerName = command.substr(spacePos + 1);
+                    gameHandler.uninvitePlayer(playerName);
+                } else {
+                    game::MessageChatData msg;
+                    msg.type = game::ChatType::SYSTEM;
+                    msg.language = game::ChatLanguage::UNIVERSAL;
+                    msg.message = "Usage: /uninvite <player name>";
+                    gameHandler.addLocalChatMessage(msg);
+                }
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "leave" || cmdLower == "leaveparty") {
+                gameHandler.leaveParty();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "maintank" || cmdLower == "mt") {
+                if (gameHandler.hasTarget()) {
+                    gameHandler.setMainTank(gameHandler.getTargetGuid());
+                } else {
+                    game::MessageChatData msg;
+                    msg.type = game::ChatType::SYSTEM;
+                    msg.language = game::ChatLanguage::UNIVERSAL;
+                    msg.message = "You must target a player to set as main tank.";
+                    gameHandler.addLocalChatMessage(msg);
+                }
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "mainassist" || cmdLower == "ma") {
+                if (gameHandler.hasTarget()) {
+                    gameHandler.setMainAssist(gameHandler.getTargetGuid());
+                } else {
+                    game::MessageChatData msg;
+                    msg.type = game::ChatType::SYSTEM;
+                    msg.language = game::ChatLanguage::UNIVERSAL;
+                    msg.message = "You must target a player to set as main assist.";
+                    gameHandler.addLocalChatMessage(msg);
+                }
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "clearmaintank") {
+                gameHandler.clearMainTank();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "clearmainassist") {
+                gameHandler.clearMainAssist();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "raidinfo") {
+                gameHandler.requestRaidInfo();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // Combat and Trade commands
+            if (cmdLower == "duel") {
+                if (gameHandler.hasTarget()) {
+                    gameHandler.proposeDuel(gameHandler.getTargetGuid());
+                } else if (spacePos != std::string::npos) {
+                    // Target player by name (would need name-to-GUID lookup)
+                    game::MessageChatData msg;
+                    msg.type = game::ChatType::SYSTEM;
+                    msg.language = game::ChatLanguage::UNIVERSAL;
+                    msg.message = "You must target a player to challenge to a duel.";
+                    gameHandler.addLocalChatMessage(msg);
+                } else {
+                    game::MessageChatData msg;
+                    msg.type = game::ChatType::SYSTEM;
+                    msg.language = game::ChatLanguage::UNIVERSAL;
+                    msg.message = "You must target a player to challenge to a duel.";
+                    gameHandler.addLocalChatMessage(msg);
+                }
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "trade") {
+                if (gameHandler.hasTarget()) {
+                    gameHandler.initiateTrade(gameHandler.getTargetGuid());
+                } else {
+                    game::MessageChatData msg;
+                    msg.type = game::ChatType::SYSTEM;
+                    msg.language = game::ChatLanguage::UNIVERSAL;
+                    msg.message = "You must target a player to trade with.";
+                    gameHandler.addLocalChatMessage(msg);
+                }
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "startattack") {
+                if (gameHandler.hasTarget()) {
+                    gameHandler.startAutoAttack(gameHandler.getTargetGuid());
+                } else {
+                    game::MessageChatData msg;
+                    msg.type = game::ChatType::SYSTEM;
+                    msg.language = game::ChatLanguage::UNIVERSAL;
+                    msg.message = "You have no target.";
+                    gameHandler.addLocalChatMessage(msg);
+                }
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "stopattack") {
+                gameHandler.stopAutoAttack();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "stopcasting") {
+                gameHandler.stopCasting();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // Targeting commands
+            if (cmdLower == "cleartarget") {
+                gameHandler.clearTarget();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "targetenemy") {
+                gameHandler.targetEnemy(false);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "targetfriend") {
+                gameHandler.targetFriend(false);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "targetlasttarget" || cmdLower == "targetlast") {
+                gameHandler.targetLastTarget();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "targetlastenemy") {
+                gameHandler.targetEnemy(true);  // Reverse direction
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "targetlastfriend") {
+                gameHandler.targetFriend(true);  // Reverse direction
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "focus") {
+                if (gameHandler.hasTarget()) {
+                    gameHandler.setFocus(gameHandler.getTargetGuid());
+                } else {
+                    game::MessageChatData msg;
+                    msg.type = game::ChatType::SYSTEM;
+                    msg.language = game::ChatLanguage::UNIVERSAL;
+                    msg.message = "You must target a unit to set as focus.";
+                    gameHandler.addLocalChatMessage(msg);
+                }
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            if (cmdLower == "clearfocus") {
+                gameHandler.clearFocus();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /unstuck command — resets player position to floor height
+            if (cmdLower == "unstuck") {
+                gameHandler.unstuck();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+            // /unstuckgy command — move to nearest graveyard
+            if (cmdLower == "unstuckgy") {
+                gameHandler.unstuckGy();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+            // /unstuckhearth command — teleport to hearthstone bind point
+            if (cmdLower == "unstuckhearth") {
+                gameHandler.unstuckHearth();
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /transport board — board test transport
+            if (cmdLower == "transport board") {
+                auto* tm = gameHandler.getTransportManager();
+                if (tm) {
+                    // Test transport GUID
+                    uint64_t testTransportGuid = 0x1000000000000001ULL;
+                    // Place player at center of deck (rough estimate)
+                    glm::vec3 deckCenter(0.0f, 0.0f, 5.0f);
+                    gameHandler.setPlayerOnTransport(testTransportGuid, deckCenter);
+                    game::MessageChatData msg;
+                    msg.type = game::ChatType::SYSTEM;
+                    msg.language = game::ChatLanguage::UNIVERSAL;
+                    msg.message = "Boarded test transport. Use '/transport leave' to disembark.";
+                    gameHandler.addLocalChatMessage(msg);
+                } else {
+                    game::MessageChatData msg;
+                    msg.type = game::ChatType::SYSTEM;
+                    msg.language = game::ChatLanguage::UNIVERSAL;
+                    msg.message = "Transport system not available.";
+                    gameHandler.addLocalChatMessage(msg);
+                }
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // /transport leave — disembark from transport
+            if (cmdLower == "transport leave") {
+                if (gameHandler.isOnTransport()) {
+                    gameHandler.clearPlayerTransport();
+                    game::MessageChatData msg;
+                    msg.type = game::ChatType::SYSTEM;
+                    msg.language = game::ChatLanguage::UNIVERSAL;
+                    msg.message = "Disembarked from transport.";
+                    gameHandler.addLocalChatMessage(msg);
+                } else {
+                    game::MessageChatData msg;
+                    msg.type = game::ChatType::SYSTEM;
+                    msg.language = game::ChatLanguage::UNIVERSAL;
+                    msg.message = "You are not on a transport.";
+                    gameHandler.addLocalChatMessage(msg);
+                }
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            // Chat channel slash commands
+            // If used without a message (e.g. just "/s"), switch the chat type dropdown
+            bool isChannelCommand = false;
+            if (cmdLower == "s" || cmdLower == "say") {
+                type = game::ChatType::SAY;
+                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
+                isChannelCommand = true;
+                switchChatType = 0;
+            } else if (cmdLower == "y" || cmdLower == "yell" || cmdLower == "shout") {
+                type = game::ChatType::YELL;
+                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
+                isChannelCommand = true;
+                switchChatType = 1;
+            } else if (cmdLower == "p" || cmdLower == "party") {
+                type = game::ChatType::PARTY;
+                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
+                isChannelCommand = true;
+                switchChatType = 2;
+            } else if (cmdLower == "g" || cmdLower == "guild") {
+                type = game::ChatType::GUILD;
+                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
+                isChannelCommand = true;
+                switchChatType = 3;
+            } else if (cmdLower == "raid" || cmdLower == "rsay" || cmdLower == "ra") {
+                type = game::ChatType::RAID;
+                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
+                isChannelCommand = true;
+                switchChatType = 5;
+            } else if (cmdLower == "raidwarning" || cmdLower == "rw") {
+                type = game::ChatType::RAID_WARNING;
+                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
+                isChannelCommand = true;
+                switchChatType = 8;
+            } else if (cmdLower == "officer" || cmdLower == "o" || cmdLower == "osay") {
+                type = game::ChatType::OFFICER;
+                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
+                isChannelCommand = true;
+                switchChatType = 6;
+            } else if (cmdLower == "battleground" || cmdLower == "bg") {
+                type = game::ChatType::BATTLEGROUND;
+                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
+                isChannelCommand = true;
+                switchChatType = 7;
+            } else if (cmdLower == "instance" || cmdLower == "i") {
+                // Instance chat uses PARTY chat type
+                type = game::ChatType::PARTY;
+                message = (spacePos != std::string::npos) ? command.substr(spacePos + 1) : "";
+                isChannelCommand = true;
+                switchChatType = 9;
+            } else if (cmdLower == "join") {
+                // /join with no args: accept pending BG invite if any
+                if (spacePos == std::string::npos && gameHandler.hasPendingBgInvite()) {
+                    gameHandler.acceptBattlefield();
+                    chatInputBuffer[0] = '\0';
+                    return;
+                }
+                // /join ChannelName [password]
+                if (spacePos != std::string::npos) {
+                    std::string rest = command.substr(spacePos + 1);
+                    size_t pwStart = rest.find(' ');
+                    std::string channelName = (pwStart != std::string::npos) ? rest.substr(0, pwStart) : rest;
+                    std::string password = (pwStart != std::string::npos) ? rest.substr(pwStart + 1) : "";
+                    gameHandler.joinChannel(channelName, password);
+                }
+                chatInputBuffer[0] = '\0';
+                return;
+            } else if (cmdLower == "leave") {
+                // /leave ChannelName
+                if (spacePos != std::string::npos) {
+                    std::string channelName = command.substr(spacePos + 1);
+                    gameHandler.leaveChannel(channelName);
+                }
+                chatInputBuffer[0] = '\0';
+                return;
+            } else if (cmdLower.size() == 1 && cmdLower[0] >= '1' && cmdLower[0] <= '9') {
+                // /1 msg, /2 msg — channel shortcuts
+                int channelIdx = cmdLower[0] - '0';
+                std::string channelName = gameHandler.getChannelByIndex(channelIdx);
+                if (!channelName.empty() && spacePos != std::string::npos) {
+                    message = command.substr(spacePos + 1);
+                    type = game::ChatType::CHANNEL;
+                    target = channelName;
+                    isChannelCommand = true;
+                } else if (channelName.empty()) {
+                    game::MessageChatData errMsg;
+                    errMsg.type = game::ChatType::SYSTEM;
+                    errMsg.message = "You are not in channel " + std::to_string(channelIdx) + ".";
+                    gameHandler.addLocalChatMessage(errMsg);
+                    chatInputBuffer[0] = '\0';
+                    return;
+                } else {
+                    chatInputBuffer[0] = '\0';
+                    return;
+                }
+            } else if (cmdLower == "w" || cmdLower == "whisper" || cmdLower == "tell" || cmdLower == "t") {
+                switchChatType = 4;
+                if (spacePos != std::string::npos) {
+                    std::string rest = command.substr(spacePos + 1);
+                    size_t msgStart = rest.find(' ');
+                    if (msgStart != std::string::npos) {
+                        // /w PlayerName message — send whisper immediately
+                        target = rest.substr(0, msgStart);
+                        message = rest.substr(msgStart + 1);
+                        type = game::ChatType::WHISPER;
+                        isChannelCommand = true;
+                        // Set whisper target for future messages
+                        strncpy(whisperTargetBuffer, target.c_str(), sizeof(whisperTargetBuffer) - 1);
+                        whisperTargetBuffer[sizeof(whisperTargetBuffer) - 1] = '\0';
+                    } else {
+                        // /w PlayerName — switch to whisper mode with target set
+                        strncpy(whisperTargetBuffer, rest.c_str(), sizeof(whisperTargetBuffer) - 1);
+                        whisperTargetBuffer[sizeof(whisperTargetBuffer) - 1] = '\0';
+                        message = "";
+                        isChannelCommand = true;
+                    }
+                } else {
+                    // Just "/w" — switch to whisper mode
+                    message = "";
+                    isChannelCommand = true;
+                }
+            }
+
+            // Check for emote commands
+            if (!isChannelCommand) {
+                std::string targetName;
+                const std::string* targetNamePtr = nullptr;
+                if (gameHandler.hasTarget()) {
+                    auto targetEntity = gameHandler.getTarget();
+                    if (targetEntity) {
+                        targetName = getEntityName(targetEntity);
+                        if (!targetName.empty()) targetNamePtr = &targetName;
+                    }
+                }
+
+                std::string emoteText = rendering::Renderer::getEmoteText(cmdLower, targetNamePtr);
+                if (!emoteText.empty()) {
+                    // Play the emote animation
+                    auto* renderer = core::Application::getInstance().getRenderer();
+                    if (renderer) {
+                        renderer->playEmote(cmdLower);
+                    }
+
+                    // Send CMSG_TEXT_EMOTE to server
+                    uint32_t dbcId = rendering::Renderer::getEmoteDbcId(cmdLower);
+                    if (dbcId != 0) {
+                        uint64_t targetGuid = gameHandler.hasTarget() ? gameHandler.getTargetGuid() : 0;
+                        gameHandler.sendTextEmote(dbcId, targetGuid);
+                    }
+
+                    // Add local chat message
+                    game::MessageChatData msg;
+                    msg.type = game::ChatType::TEXT_EMOTE;
+                    msg.language = game::ChatLanguage::COMMON;
+                    msg.message = emoteText;
+                    gameHandler.addLocalChatMessage(msg);
+
+                    chatInputBuffer[0] = '\0';
+                    return;
+                }
+
+                // Not a recognized command — fall through and send as normal chat
+                if (!isChannelCommand) {
+                    message = input;
+                }
+            }
+
+            // If no valid command found and starts with /, just send as-is
+            if (!isChannelCommand && message == input) {
+                // Use the selected chat type from dropdown
+                switch (selectedChatType) {
+                    case 0: type = game::ChatType::SAY; break;
+                    case 1: type = game::ChatType::YELL; break;
+                    case 2: type = game::ChatType::PARTY; break;
+                    case 3: type = game::ChatType::GUILD; break;
+                    case 4: type = game::ChatType::WHISPER; target = whisperTargetBuffer; break;
+                    case 5: type = game::ChatType::RAID; break;
+                    case 6: type = game::ChatType::OFFICER; break;
+                    case 7: type = game::ChatType::BATTLEGROUND; break;
+                    case 8: type = game::ChatType::RAID_WARNING; break;
+                    case 9: type = game::ChatType::PARTY; break; // INSTANCE uses PARTY
+                    default: type = game::ChatType::SAY; break;
+                }
+            }
+        } else {
+            // No slash command, use the selected chat type from dropdown
+            switch (selectedChatType) {
+                case 0: type = game::ChatType::SAY; break;
+                case 1: type = game::ChatType::YELL; break;
+                case 2: type = game::ChatType::PARTY; break;
+                case 3: type = game::ChatType::GUILD; break;
+                case 4: type = game::ChatType::WHISPER; target = whisperTargetBuffer; break;
+                case 5: type = game::ChatType::RAID; break;
+                case 6: type = game::ChatType::OFFICER; break;
+                case 7: type = game::ChatType::BATTLEGROUND; break;
+                case 8: type = game::ChatType::RAID_WARNING; break;
+                case 9: type = game::ChatType::PARTY; break; // INSTANCE uses PARTY
+                default: type = game::ChatType::SAY; break;
             }
         }
 
-        // Distance to focus target
-        {
-            const auto& mv = gameHandler.getMovementInfo();
-            float fdx = focus->getX() - mv.x;
-            float fdy = focus->getY() - mv.y;
-            float fdz = focus->getZ() - mv.z;
-            float fdist = std::sqrt(fdx * fdx + fdy * fdy + fdz * fdz);
-            ImGui::TextDisabled("%.1f yd", fdist);
+        // Whisper shortcuts to PortBot/GMBot: translate to GM teleport commands.
+        if (type == game::ChatType::WHISPER && isPortBotTarget(target)) {
+            std::string cmd = buildPortBotCommand(message);
+            game::MessageChatData msg;
+            msg.type = game::ChatType::SYSTEM;
+            msg.language = game::ChatLanguage::UNIVERSAL;
+            if (cmd.empty() || cmd == "__help__") {
+                msg.message = "PortBot: /w PortBot <dest>. Aliases: sw if darn org tb uc shatt dal. Also supports '.tele ...' or 'xyz x y z [map [o]]'.";
+                gameHandler.addLocalChatMessage(msg);
+                chatInputBuffer[0] = '\0';
+                return;
+            }
+
+            gameHandler.sendChatMessage(game::ChatType::SAY, cmd, "");
+            msg.message = "PortBot executed: " + cmd;
+            gameHandler.addLocalChatMessage(msg);
+            chatInputBuffer[0] = '\0';
+            return;
         }
 
-        // Clicking the focus frame targets it
-        if (ImGui::IsWindowHovered() && ImGui::IsMouseClicked(0)) {
-            gameHandler.setTarget(focus->getGuid());
+        // Validate whisper has a target
+        if (type == game::ChatType::WHISPER && target.empty()) {
+            game::MessageChatData msg;
+            msg.type = game::ChatType::SYSTEM;
+            msg.language = game::ChatLanguage::UNIVERSAL;
+            msg.message = "You must specify a player name for whisper.";
+            gameHandler.addLocalChatMessage(msg);
+            chatInputBuffer[0] = '\0';
+            return;
         }
+
+        // Don't send empty messages — but switch chat type if a channel shortcut was used
+        if (!message.empty()) {
+            gameHandler.sendChatMessage(type, message, target);
+        }
+
+        // Switch chat type dropdown when channel shortcut used (with or without message)
+        if (switchChatType >= 0) {
+            selectedChatType = switchChatType;
+        }
+
+        // Clear input
+        chatInputBuffer[0] = '\0';
     }
-    ImGui::End();
+}
 
-    ImGui::PopStyleColor(2);
-    ImGui::PopStyleVar();
+const char* GameScreen::getChatTypeName(game::ChatType type) const {
+    switch (type) {
+        case game::ChatType::SAY: return "SAY";
+        case game::ChatType::YELL: return "YELL";
+        case game::ChatType::EMOTE: return "EMOTE";
+        case game::ChatType::TEXT_EMOTE: return "EMOTE";
+        case game::ChatType::PARTY: return "PARTY";
+        case game::ChatType::GUILD: return "GUILD";
+        case game::ChatType::OFFICER: return "OFFICER";
+        case game::ChatType::RAID: return "RAID";
+        case game::ChatType::RAID_LEADER: return "RAID LEADER";
+        case game::ChatType::RAID_WARNING: return "RAID WARNING";
+        case game::ChatType::BATTLEGROUND: return "BATTLEGROUND";
+        case game::ChatType::BATTLEGROUND_LEADER: return "BG LEADER";
+        case game::ChatType::WHISPER: return "WHISPER";
+        case game::ChatType::WHISPER_INFORM: return "TO";
+        case game::ChatType::SYSTEM: return "SYSTEM";
+        case game::ChatType::MONSTER_SAY: return "SAY";
+        case game::ChatType::MONSTER_YELL: return "YELL";
+        case game::ChatType::MONSTER_EMOTE: return "EMOTE";
+        case game::ChatType::CHANNEL: return "CHANNEL";
+        case game::ChatType::ACHIEVEMENT: return "ACHIEVEMENT";
+        case game::ChatType::DND: return "DND";
+        case game::ChatType::AFK: return "AFK";
+        default: return "UNKNOWN";
+    }
+}
+
+ImVec4 GameScreen::getChatTypeColor(game::ChatType type) const {
+    switch (type) {
+        case game::ChatType::SAY:
+            return ImVec4(1.0f, 1.0f, 1.0f, 1.0f);  // White
+        case game::ChatType::YELL:
+            return ImVec4(1.0f, 0.3f, 0.3f, 1.0f);  // Red
+        case game::ChatType::EMOTE:
+            return ImVec4(1.0f, 0.7f, 0.3f, 1.0f);  // Orange
+        case game::ChatType::TEXT_EMOTE:
+            return ImVec4(1.0f, 0.7f, 0.3f, 1.0f);  // Orange
+        case game::ChatType::PARTY:
+            return ImVec4(0.5f, 0.5f, 1.0f, 1.0f);  // Light blue
+        case game::ChatType::GUILD:
+            return ImVec4(0.3f, 1.0f, 0.3f, 1.0f);  // Green
+        case game::ChatType::OFFICER:
+            return ImVec4(0.3f, 0.8f, 0.3f, 1.0f);  // Dark green
+        case game::ChatType::RAID:
+            return ImVec4(1.0f, 0.5f, 0.0f, 1.0f);  // Orange
+        case game::ChatType::RAID_LEADER:
+            return ImVec4(1.0f, 0.4f, 0.0f, 1.0f);  // Darker orange
+        case game::ChatType::RAID_WARNING:
+            return ImVec4(1.0f, 0.0f, 0.0f, 1.0f);  // Red
+        case game::ChatType::BATTLEGROUND:
+            return ImVec4(1.0f, 0.6f, 0.0f, 1.0f);  // Orange-gold
+        case game::ChatType::BATTLEGROUND_LEADER:
+            return ImVec4(1.0f, 0.5f, 0.0f, 1.0f);  // Orange
+        case game::ChatType::WHISPER:
+            return ImVec4(1.0f, 0.5f, 1.0f, 1.0f);  // Pink
+        case game::ChatType::WHISPER_INFORM:
+            return ImVec4(1.0f, 0.5f, 1.0f, 1.0f);  // Pink
+        case game::ChatType::SYSTEM:
+            return ImVec4(1.0f, 1.0f, 0.3f, 1.0f);  // Yellow
+        case game::ChatType::MONSTER_SAY:
+            return ImVec4(1.0f, 1.0f, 1.0f, 1.0f);  // White (same as SAY)
+        case game::ChatType::MONSTER_YELL:
+            return ImVec4(1.0f, 0.3f, 0.3f, 1.0f);  // Red (same as YELL)
+        case game::ChatType::MONSTER_EMOTE:
+            return ImVec4(1.0f, 0.7f, 0.3f, 1.0f);  // Orange (same as EMOTE)
+        case game::ChatType::CHANNEL:
+            return ImVec4(1.0f, 0.7f, 0.7f, 1.0f);  // Light pink
+        case game::ChatType::ACHIEVEMENT:
+            return ImVec4(1.0f, 1.0f, 0.0f, 1.0f);  // Bright yellow
+        default:
+            return ImVec4(0.7f, 0.7f, 0.7f, 1.0f);  // Gray
+    }
 }
 
 void GameScreen::updateCharacterGeosets(game::Inventory& inventory) {
@@ -3925,7 +3522,7 @@ void GameScreen::updateCharacterTextures(game::Inventory& inventory) {
     if (bodySkinPath.empty()) return;
 
     // Component directory names indexed by region
-    static constexpr const char* componentDirs[] = {
+    static const char* componentDirs[] = {
         "ArmUpperTexture",   // 0
         "ArmLowerTexture",   // 1
         "HandTexture",       // 2
@@ -3941,8 +3538,18 @@ void GameScreen::updateCharacterTextures(game::Inventory& inventory) {
     if (!displayInfoDbc) return;
     const auto* idiL = pipeline::getActiveDBCLayout()
         ? pipeline::getActiveDBCLayout()->getLayout("ItemDisplayInfo") : nullptr;
-    uint32_t texRegionFields[8];
-    pipeline::getItemDisplayInfoTextureFields(*displayInfoDbc, idiL, texRegionFields);
+    // Texture component region fields (8 regions: ArmUpper..Foot)
+    // Binary DBC (23 fields) has textures at 14+
+    const uint32_t texRegionFields[8] = {
+        idiL ? (*idiL)["TextureArmUpper"]  : 14u,
+        idiL ? (*idiL)["TextureArmLower"]  : 15u,
+        idiL ? (*idiL)["TextureHand"]      : 16u,
+        idiL ? (*idiL)["TextureTorsoUpper"]: 17u,
+        idiL ? (*idiL)["TextureTorsoLower"]: 18u,
+        idiL ? (*idiL)["TextureLegUpper"]  : 19u,
+        idiL ? (*idiL)["TextureLegLower"]  : 20u,
+        idiL ? (*idiL)["TextureFoot"]      : 21u,
+    };
 
     // Collect equipment texture regions from all equipped items
     std::vector<std::pair<int, std::string>> regionLayers;
@@ -4036,8 +3643,6 @@ void GameScreen::updateCharacterTextures(game::Inventory& inventory) {
 // ============================================================
 
 void GameScreen::renderWorldMap(game::GameHandler& gameHandler) {
-    if (!showWorldMap_) return;
-
     auto& app = core::Application::getInstance();
     auto* renderer = app.getRenderer();
     if (!renderer) return;
@@ -4054,87 +3659,15 @@ void GameScreen::renderWorldMap(game::GameHandler& gameHandler) {
         gameHandler.getPlayerExploredZoneMasks(),
         gameHandler.hasPlayerExploredZoneMasks());
 
-    // Party member dots on world map
-    {
-        std::vector<rendering::WorldMapPartyDot> dots;
-        if (gameHandler.isInGroup()) {
-            const auto& partyData = gameHandler.getPartyData();
-            for (const auto& member : partyData.members) {
-                if (!member.isOnline || !member.hasPartyStats) continue;
-                if (member.posX == 0 && member.posY == 0) continue;
-                // posY → canonical X (north), posX → canonical Y (west)
-                float wowX = static_cast<float>(member.posY);
-                float wowY = static_cast<float>(member.posX);
-                glm::vec3 rpos = core::coords::canonicalToRender(glm::vec3(wowX, wowY, 0.0f));
-                auto ent = gameHandler.getEntityManager().getEntity(member.guid);
-                uint8_t cid = entityClassId(ent.get());
-                ImU32 col = (cid != 0)
-                    ? classColorU32(cid, 230)
-                    : (member.guid == partyData.leaderGuid
-                       ? IM_COL32(255, 210, 0, 230)
-                       : IM_COL32(100, 180, 255, 230));
-                dots.push_back({ rpos, col, member.name });
-            }
-        }
-        wm->setPartyDots(std::move(dots));
-    }
-
-    // Taxi node markers on world map
-    {
-        std::vector<rendering::WorldMapTaxiNode> taxiNodes;
-        const auto& nodes = gameHandler.getTaxiNodes();
-        taxiNodes.reserve(nodes.size());
-        for (const auto& [id, node] : nodes) {
-            rendering::WorldMapTaxiNode wtn;
-            wtn.id    = node.id;
-            wtn.mapId = node.mapId;
-            wtn.wowX  = node.x;
-            wtn.wowY  = node.y;
-            wtn.wowZ  = node.z;
-            wtn.name  = node.name;
-            wtn.known = gameHandler.isKnownTaxiNode(id);
-            taxiNodes.push_back(std::move(wtn));
-        }
-        wm->setTaxiNodes(std::move(taxiNodes));
-    }
-
-    // Quest POI markers on world map (from SMSG_QUEST_POI_QUERY_RESPONSE / gossip POIs)
-    {
-        std::vector<rendering::WorldMap::QuestPoi> qpois;
-        for (const auto& poi : gameHandler.getGossipPois()) {
-            rendering::WorldMap::QuestPoi qp;
-            qp.wowX = poi.x;
-            qp.wowY = poi.y;
-            qp.name = poi.name;
-            qpois.push_back(std::move(qp));
-        }
-        wm->setQuestPois(std::move(qpois));
-    }
-
-    // Corpse marker: show skull X on world map when ghost with unclaimed corpse
-    {
-        float corpseCanX = 0.0f, corpseCanY = 0.0f;
-        bool ghostWithCorpse = gameHandler.isPlayerGhost() &&
-                               gameHandler.getCorpseCanonicalPos(corpseCanX, corpseCanY);
-        glm::vec3 corpseRender = ghostWithCorpse
-            ? core::coords::canonicalToRender(glm::vec3(corpseCanX, corpseCanY, 0.0f))
-            : glm::vec3{};
-        wm->setCorpsePos(ghostWithCorpse, corpseRender);
-    }
-
     glm::vec3 playerPos = renderer->getCharacterPosition();
-    float playerYaw = renderer->getCharacterYaw();
     auto* window = app.getWindow();
     int screenW = window ? window->getWidth() : 1280;
     int screenH = window ? window->getHeight() : 720;
-    wm->render(playerPos, screenW, screenH, playerYaw);
-
-    // Sync showWorldMap_ if the map closed itself (e.g. ESC key inside the overlay).
-    if (!wm->isOpen()) showWorldMap_ = false;
+    wm->render(playerPos, screenW, screenH);
 }
 
 // ============================================================
-// Action Bar
+// Action Bar (Phase 3)
 // ============================================================
 
 VkDescriptorSet GameScreen::getSpellIcon(uint32_t spellId, pipeline::AssetManager* am) {
@@ -4166,7 +3699,7 @@ VkDescriptorSet GameScreen::getSpellIcon(uint32_t spellId, pipeline::AssetManage
         const auto* spellL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("Spell") : nullptr;
         if (spellDbc && spellDbc->isLoaded()) {
             uint32_t fieldCount = spellDbc->getFieldCount();
-            // Helper to load icons for a given field layout
+            // Try expansion layout first
             auto tryLoadIcons = [&](uint32_t idField, uint32_t iconField) {
                 spellIconIds_.clear();
                 if (iconField >= fieldCount) return;
@@ -4178,35 +3711,21 @@ VkDescriptorSet GameScreen::getSpellIcon(uint32_t spellId, pipeline::AssetManage
                     }
                 }
             };
-
-            // Use expansion-aware layout if available AND the DBC field count
-            // matches the expansion's expected format.  Classic=173, TBC=216,
-            // WotLK=234 fields.  When Classic is active but the base WotLK DBC
-            // is loaded (234 fields), field 117 is NOT IconID — we must use
-            // the WotLK field 133 instead.
-            uint32_t iconField = 133; // WotLK default
-            uint32_t idField = 0;
-            if (spellL) {
-                uint32_t layoutIcon = (*spellL)["IconID"];
-                // Only trust the expansion layout if the DBC has a compatible
-                // field count (within ~20 of the layout's icon field).
-                if (layoutIcon < fieldCount && fieldCount <= layoutIcon + 20) {
-                    iconField = layoutIcon;
-                    idField = (*spellL)["ID"];
-                }
+            // If the DBC has WotLK-range field count (≥200 fields), it's the binary
+            // WotLK Spell.dbc (CSV fallback). Use WotLK layout regardless of expansion,
+            // since Turtle/Classic CSV files are garbled and fall back to WotLK binary.
+            if (fieldCount >= 200) {
+                tryLoadIcons(0, 133); // WotLK IconID field
+            } else if (spellL) {
+                tryLoadIcons((*spellL)["ID"], (*spellL)["IconID"]);
+            }
+            // Fallback to WotLK field 133 if expansion layout yielded nothing
+            if (spellIconIds_.empty() && fieldCount > 133) {
+                tryLoadIcons(0, 133);
             }
-            tryLoadIcons(idField, iconField);
         }
     }
 
-    // Rate-limit GPU uploads per frame to prevent stalls when many icons are uncached
-    // (e.g., first login, after loading screen, or many new auras appearing at once).
-    static int gsLoadsThisFrame = 0;
-    static int gsLastImGuiFrame = -1;
-    int gsCurFrame = ImGui::GetFrameCount();
-    if (gsCurFrame != gsLastImGuiFrame) { gsLoadsThisFrame = 0; gsLastImGuiFrame = gsCurFrame; }
-    if (gsLoadsThisFrame >= 4) return VK_NULL_HANDLE;  // defer — do NOT cache null here
-
     // Look up spellId -> SpellIconID -> icon path
     auto iit = spellIconIds_.find(spellId);
     if (iit == spellIconIds_.end()) {
@@ -4235,32 +3754,698 @@ VkDescriptorSet GameScreen::getSpellIcon(uint32_t spellId, pipeline::AssetManage
     }
 
     // Upload to Vulkan via VkContext
-    auto* window = services_.window;
+    auto* window = core::Application::getInstance().getWindow();
     auto* vkCtx = window ? window->getVkContext() : nullptr;
     if (!vkCtx) {
         spellIconCache_[spellId] = VK_NULL_HANDLE;
         return VK_NULL_HANDLE;
     }
 
-    ++gsLoadsThisFrame;
     VkDescriptorSet ds = vkCtx->uploadImGuiTexture(image.data.data(), image.width, image.height);
     spellIconCache_[spellId] = ds;
     return ds;
 }
 
+void GameScreen::renderActionBar(game::GameHandler& gameHandler) {
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
+    auto* assetMgr = core::Application::getInstance().getAssetManager();
+
+    float slotSize = 48.0f;
+    float spacing = 4.0f;
+    float padding = 8.0f;
+    float barW = 12 * slotSize + 11 * spacing + padding * 2;
+    float barH = slotSize + 24.0f;
+    float barX = (screenW - barW) / 2.0f;
+    float barY = screenH - barH;
+
+    ImGui::SetNextWindowPos(ImVec2(barX, barY), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(barW, barH), ImGuiCond_Always);
+
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
+                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
+                             ImGuiWindowFlags_NoScrollbar;
+
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(padding, padding));
+    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0.0f, 0.0f));
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
+    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.05f, 0.05f, 0.05f, 0.9f));
+
+    if (ImGui::Begin("##ActionBar", nullptr, flags)) {
+        const auto& bar = gameHandler.getActionBar();
+        static const char* keyLabels[] = {"1","2","3","4","5","6","7","8","9","0","-","="};
+
+        for (int i = 0; i < 12; ++i) {
+            if (i > 0) ImGui::SameLine(0, spacing);
+
+            ImGui::BeginGroup();
+            ImGui::PushID(i);
+
+            const auto& slot = bar[i];
+            bool onCooldown = !slot.isReady();
+
+            auto getSpellName = [&](uint32_t spellId) -> std::string {
+                std::string name = spellbookScreen.lookupSpellName(spellId, assetMgr);
+                if (!name.empty()) return name;
+                return "Spell #" + std::to_string(spellId);
+            };
+
+            // Try to get icon texture for this slot
+            VkDescriptorSet iconTex = VK_NULL_HANDLE;
+            const game::ItemDef* barItemDef = nullptr;
+            uint32_t itemDisplayInfoId = 0;
+            std::string itemNameFromQuery;
+            if (slot.type == game::ActionBarSlot::SPELL && slot.id != 0) {
+                iconTex = getSpellIcon(slot.id, assetMgr);
+            } else if (slot.type == game::ActionBarSlot::ITEM && slot.id != 0) {
+                // Search backpack
+                auto& inv = gameHandler.getInventory();
+                for (int bi = 0; bi < inv.getBackpackSize(); bi++) {
+                    const auto& bs = inv.getBackpackSlot(bi);
+                    if (!bs.empty() && bs.item.itemId == slot.id) {
+                        barItemDef = &bs.item;
+                        break;
+                    }
+                }
+                // Search equipped slots
+                if (!barItemDef) {
+                    for (int ei = 0; ei < game::Inventory::NUM_EQUIP_SLOTS; ei++) {
+                        const auto& es = inv.getEquipSlot(static_cast<game::EquipSlot>(ei));
+                        if (!es.empty() && es.item.itemId == slot.id) {
+                            barItemDef = &es.item;
+                            break;
+                        }
+                    }
+                }
+                // Search extra bags
+                if (!barItemDef) {
+                    for (int bag = 0; bag < game::Inventory::NUM_BAG_SLOTS && !barItemDef; bag++) {
+                        for (int si = 0; si < inv.getBagSize(bag); si++) {
+                            const auto& bs = inv.getBagSlot(bag, si);
+                            if (!bs.empty() && bs.item.itemId == slot.id) {
+                                barItemDef = &bs.item;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (barItemDef && barItemDef->displayInfoId != 0) {
+                    itemDisplayInfoId = barItemDef->displayInfoId;
+                }
+                // Fallback: use item info cache (from server query responses)
+                if (itemDisplayInfoId == 0) {
+                    if (auto* info = gameHandler.getItemInfo(slot.id)) {
+                        itemDisplayInfoId = info->displayInfoId;
+                        if (itemNameFromQuery.empty() && !info->name.empty())
+                            itemNameFromQuery = info->name;
+                    }
+                }
+                if (itemDisplayInfoId != 0) {
+                    iconTex = inventoryScreen.getItemIcon(itemDisplayInfoId);
+                }
+            }
+
+            bool clicked = false;
+            if (iconTex) {
+                // Render icon-based button
+                ImVec4 tintColor(1, 1, 1, 1);
+                ImVec4 bgColor(0.1f, 0.1f, 0.1f, 0.9f);
+                if (onCooldown) {
+                    tintColor = ImVec4(0.4f, 0.4f, 0.4f, 0.8f);
+                    bgColor = ImVec4(0.1f, 0.1f, 0.1f, 0.8f);
+                }
+                clicked = ImGui::ImageButton("##icon",
+                    (ImTextureID)(uintptr_t)iconTex,
+                    ImVec2(slotSize, slotSize),
+                    ImVec2(0, 0), ImVec2(1, 1),
+                    bgColor, tintColor);
+            } else {
+                // Fallback to text button
+                if (onCooldown) {
+                    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.2f, 0.2f, 0.2f, 0.8f));
+                } else if (slot.isEmpty()) {
+                    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.15f, 0.15f, 0.15f, 0.8f));
+                } else {
+                    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.3f, 0.3f, 0.5f, 0.9f));
+                }
+
+                char label[32];
+                if (slot.type == game::ActionBarSlot::SPELL) {
+                    std::string spellName = getSpellName(slot.id);
+                    if (spellName.size() > 6) spellName = spellName.substr(0, 6);
+                    snprintf(label, sizeof(label), "%s", spellName.c_str());
+                } else if (slot.type == game::ActionBarSlot::ITEM && barItemDef) {
+                    std::string itemName = barItemDef->name;
+                    if (itemName.size() > 6) itemName = itemName.substr(0, 6);
+                    snprintf(label, sizeof(label), "%s", itemName.c_str());
+                } else if (slot.type == game::ActionBarSlot::ITEM) {
+                    snprintf(label, sizeof(label), "Item");
+                } else if (slot.type == game::ActionBarSlot::MACRO) {
+                    snprintf(label, sizeof(label), "Macro");
+                } else {
+                    snprintf(label, sizeof(label), "--");
+                }
+
+                clicked = ImGui::Button(label, ImVec2(slotSize, slotSize));
+                ImGui::PopStyleColor();
+            }
+
+            bool rightClicked = ImGui::IsItemClicked(ImGuiMouseButton_Right);
+            bool hoveredOnRelease = ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem) &&
+                                    ImGui::IsMouseReleased(ImGuiMouseButton_Left);
+
+            // Drop dragged spell from spellbook onto this slot
+            // (mouse release over slot — button click won't fire since press was in spellbook)
+            if (hoveredOnRelease && spellbookScreen.isDraggingSpell()) {
+                gameHandler.setActionBarSlot(i, game::ActionBarSlot::SPELL,
+                    spellbookScreen.getDragSpellId());
+                spellbookScreen.consumeDragSpell();
+            } else if (hoveredOnRelease && inventoryScreen.isHoldingItem()) {
+                // Drop held item from inventory onto action bar
+                const auto& held = inventoryScreen.getHeldItem();
+                gameHandler.setActionBarSlot(i, game::ActionBarSlot::ITEM, held.itemId);
+                inventoryScreen.returnHeldItem(gameHandler.getInventory());
+            } else if (clicked && actionBarDragSlot_ >= 0) {
+                // Dropping a dragged action bar slot onto another slot - swap or place
+                if (i != actionBarDragSlot_) {
+                    const auto& dragSrc = bar[actionBarDragSlot_];
+                    auto srcType = dragSrc.type;
+                    auto srcId = dragSrc.id;
+                    gameHandler.setActionBarSlot(actionBarDragSlot_, slot.type, slot.id);
+                    gameHandler.setActionBarSlot(i, srcType, srcId);
+                }
+                actionBarDragSlot_ = -1;
+                actionBarDragIcon_ = 0;
+            } else if (clicked && !slot.isEmpty()) {
+                // Left-click on non-empty slot: cast spell or use item
+                if (slot.type == game::ActionBarSlot::SPELL && slot.isReady()) {
+                    uint64_t target = gameHandler.hasTarget() ? gameHandler.getTargetGuid() : 0;
+                    gameHandler.castSpell(slot.id, target);
+                } else if (slot.type == game::ActionBarSlot::ITEM && slot.id != 0) {
+                    gameHandler.useItemById(slot.id);
+                }
+            } else if (rightClicked && !slot.isEmpty()) {
+                // Right-click on non-empty slot: pick up for dragging
+                actionBarDragSlot_ = i;
+                actionBarDragIcon_ = iconTex;
+            }
+
+            // Tooltip
+            if (ImGui::IsItemHovered() && !slot.isEmpty() && slot.id != 0) {
+                ImGui::BeginTooltip();
+                if (slot.type == game::ActionBarSlot::SPELL) {
+                    std::string fullName = getSpellName(slot.id);
+                    ImGui::Text("%s", fullName.c_str());
+                    // Hearthstone: show bind point info
+                    if (slot.id == 8690) {
+                        uint32_t mapId = 0;
+                        glm::vec3 pos;
+                        if (gameHandler.getHomeBind(mapId, pos)) {
+                            const char* mapName = "Unknown";
+                            switch (mapId) {
+                                case 0:   mapName = "Eastern Kingdoms"; break;
+                                case 1:   mapName = "Kalimdor"; break;
+                                case 530:  mapName = "Outland"; break;
+                                case 571:  mapName = "Northrend"; break;
+                            }
+                            ImGui::TextColored(ImVec4(0.8f, 0.9f, 1.0f, 1.0f),
+                                "Home: %s", mapName);
+                        }
+                        ImGui::TextDisabled("Use: Teleport home");
+                    }
+                } else if (slot.type == game::ActionBarSlot::ITEM) {
+                    if (barItemDef && !barItemDef->name.empty()) {
+                        ImGui::Text("%s", barItemDef->name.c_str());
+                    } else if (!itemNameFromQuery.empty()) {
+                        ImGui::Text("%s", itemNameFromQuery.c_str());
+                    } else {
+                        ImGui::Text("Item #%u", slot.id);
+                    }
+                }
+                // Show cooldown time remaining
+                if (onCooldown) {
+                    float cd = slot.cooldownRemaining;
+                    if (cd >= 60.0f) {
+                        int mins = static_cast<int>(cd) / 60;
+                        int secs = static_cast<int>(cd) % 60;
+                        ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.2f, 1.0f),
+                            "Cooldown: %d min %d sec", mins, secs);
+                    } else {
+                        ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.2f, 1.0f),
+                            "Cooldown: %.1f sec", cd);
+                    }
+                }
+                ImGui::EndTooltip();
+            }
+
+            // Cooldown overlay
+            if (onCooldown && iconTex) {
+                // Draw cooldown text centered over the icon
+                ImVec2 btnMin = ImGui::GetItemRectMin();
+                ImVec2 btnMax = ImGui::GetItemRectMax();
+                char cdText[16];
+                snprintf(cdText, sizeof(cdText), "%.0f", slot.cooldownRemaining);
+                ImVec2 textSize = ImGui::CalcTextSize(cdText);
+                float cx = btnMin.x + (btnMax.x - btnMin.x - textSize.x) * 0.5f;
+                float cy = btnMin.y + (btnMax.y - btnMin.y - textSize.y) * 0.5f;
+                ImGui::GetWindowDrawList()->AddText(ImVec2(cx, cy),
+                    IM_COL32(255, 255, 0, 255), cdText);
+            } else if (onCooldown) {
+                char cdText[16];
+                snprintf(cdText, sizeof(cdText), "%.0f", slot.cooldownRemaining);
+                ImGui::SetCursorPosY(ImGui::GetCursorPosY() - slotSize / 2 - 8);
+                ImGui::TextColored(ImVec4(1, 1, 0, 1), "%s", cdText);
+            }
+
+            // Key label below
+            ImGui::TextDisabled("%s", keyLabels[i]);
+
+            ImGui::PopID();
+            ImGui::EndGroup();
+        }
+    }
+    ImGui::End();
+
+    ImGui::PopStyleColor();
+    ImGui::PopStyleVar(4);
+
+    // Handle action bar drag: render icon at cursor and detect drop outside
+    if (actionBarDragSlot_ >= 0) {
+        ImVec2 mousePos = ImGui::GetMousePos();
+
+        // Draw dragged icon at cursor
+        if (actionBarDragIcon_) {
+            ImGui::GetForegroundDrawList()->AddImage(
+                (ImTextureID)(uintptr_t)actionBarDragIcon_,
+                ImVec2(mousePos.x - 20, mousePos.y - 20),
+                ImVec2(mousePos.x + 20, mousePos.y + 20));
+        } else {
+            ImGui::GetForegroundDrawList()->AddRectFilled(
+                ImVec2(mousePos.x - 20, mousePos.y - 20),
+                ImVec2(mousePos.x + 20, mousePos.y + 20),
+                IM_COL32(80, 80, 120, 180));
+        }
+
+        // On right mouse release, check if outside the action bar area
+        if (ImGui::IsMouseReleased(ImGuiMouseButton_Right)) {
+            bool insideBar = (mousePos.x >= barX && mousePos.x <= barX + barW &&
+                              mousePos.y >= barY && mousePos.y <= barY + barH);
+            if (!insideBar) {
+                // Dropped outside - clear the slot
+                gameHandler.setActionBarSlot(actionBarDragSlot_, game::ActionBarSlot::EMPTY, 0);
+            }
+            actionBarDragSlot_ = -1;
+            actionBarDragIcon_ = 0;
+        }
+    }
+}
+
+// ============================================================
+// Bag Bar
+// ============================================================
+
+void GameScreen::renderBagBar(game::GameHandler& gameHandler) {
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
+    auto* assetMgr = core::Application::getInstance().getAssetManager();
+
+    float slotSize = 42.0f;
+    float spacing = 4.0f;
+    float padding = 6.0f;
+
+    // 5 slots: backpack + 4 bags
+    float barW = 5 * slotSize + 4 * spacing + padding * 2;
+    float barH = slotSize + padding * 2;
+
+    // Position in bottom right corner
+    float barX = screenW - barW - 10.0f;
+    float barY = screenH - barH - 10.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(barX, barY), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(barW, barH), ImGuiCond_Always);
+
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
+                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
+                             ImGuiWindowFlags_NoScrollbar;
+
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(padding, padding));
+    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0.0f, 0.0f));
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
+    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.05f, 0.05f, 0.05f, 0.9f));
+
+    if (ImGui::Begin("##BagBar", nullptr, flags)) {
+        auto& inv = gameHandler.getInventory();
+
+        // Load backpack icon if needed
+        if (!backpackIconTexture_ && assetMgr && assetMgr->isInitialized()) {
+            auto blpData = assetMgr->readFile("Interface\\Buttons\\Button-Backpack-Up.blp");
+            if (!blpData.empty()) {
+                auto image = pipeline::BLPLoader::load(blpData);
+                if (image.isValid()) {
+                    auto* w = core::Application::getInstance().getWindow();
+                    auto* vkCtx = w ? w->getVkContext() : nullptr;
+                    if (vkCtx)
+                        backpackIconTexture_ = vkCtx->uploadImGuiTexture(image.data.data(), image.width, image.height);
+                }
+            }
+        }
+
+        // Track bag slot screen rects for drop detection
+        ImVec2 bagSlotMins[4], bagSlotMaxs[4];
+
+        // Slots 1-4: Bag slots (leftmost)
+        for (int i = 0; i < 4; ++i) {
+            if (i > 0) ImGui::SameLine(0, spacing);
+            ImGui::PushID(i + 1);
+
+            game::EquipSlot bagSlot = static_cast<game::EquipSlot>(static_cast<int>(game::EquipSlot::BAG1) + i);
+            const auto& bagItem = inv.getEquipSlot(bagSlot);
+
+            VkDescriptorSet bagIcon = VK_NULL_HANDLE;
+            if (!bagItem.empty() && bagItem.item.displayInfoId != 0) {
+                bagIcon = inventoryScreen.getItemIcon(bagItem.item.displayInfoId);
+            }
+            // Render the slot as an invisible button so we control all interaction
+            ImVec2 cpos = ImGui::GetCursorScreenPos();
+            ImGui::InvisibleButton("##bagSlot", ImVec2(slotSize, slotSize));
+            bagSlotMins[i] = cpos;
+            bagSlotMaxs[i] = ImVec2(cpos.x + slotSize, cpos.y + slotSize);
+
+            ImDrawList* dl = ImGui::GetWindowDrawList();
+
+            // Draw background + icon
+            if (bagIcon) {
+                dl->AddRectFilled(bagSlotMins[i], bagSlotMaxs[i], IM_COL32(25, 25, 25, 230));
+                dl->AddImage((ImTextureID)(uintptr_t)bagIcon, bagSlotMins[i], bagSlotMaxs[i]);
+            } else {
+                dl->AddRectFilled(bagSlotMins[i], bagSlotMaxs[i], IM_COL32(38, 38, 38, 204));
+            }
+
+            // Hover highlight
+            bool hovered = ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem);
+            if (hovered && bagBarPickedSlot_ < 0) {
+                dl->AddRect(bagSlotMins[i], bagSlotMaxs[i], IM_COL32(255, 255, 255, 100));
+            }
+
+            // Track which slot was pressed for drag detection
+            if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left) && bagBarPickedSlot_ < 0 && bagIcon) {
+                bagBarDragSource_ = i;
+            }
+
+            // Click toggles bag open/close (handled in mouse release section below)
+
+            // Dim the slot being dragged
+            if (bagBarPickedSlot_ == i) {
+                dl->AddRectFilled(bagSlotMins[i], bagSlotMaxs[i], IM_COL32(0, 0, 0, 150));
+            }
+
+            // Tooltip
+            if (hovered && bagBarPickedSlot_ < 0) {
+                if (bagIcon)
+                    ImGui::SetTooltip("%s", bagItem.item.name.c_str());
+                else
+                    ImGui::SetTooltip("Empty Bag Slot");
+            }
+
+            // Open bag indicator
+            if (inventoryScreen.isSeparateBags() && inventoryScreen.isBagOpen(i)) {
+                dl->AddRect(bagSlotMins[i], bagSlotMaxs[i], IM_COL32(255, 255, 255, 255), 3.0f, 0, 2.0f);
+            }
+
+            // Accept dragged item from inventory
+            if (hovered && inventoryScreen.isHoldingItem()) {
+                const auto& heldItem = inventoryScreen.getHeldItem();
+                if ((heldItem.inventoryType == 18 || heldItem.bagSlots > 0) &&
+                    ImGui::IsMouseReleased(ImGuiMouseButton_Left)) {
+                    auto& inventory = gameHandler.getInventory();
+                    inventoryScreen.dropHeldItemToEquipSlot(inventory, bagSlot);
+                }
+            }
+
+            ImGui::PopID();
+        }
+
+        // Drag lifecycle: press on a slot sets bagBarDragSource_,
+        // dragging 3+ pixels promotes to bagBarPickedSlot_ (visual drag),
+        // releasing completes swap or click
+        if (bagBarDragSource_ >= 0) {
+            if (ImGui::IsMouseDragging(ImGuiMouseButton_Left, 3.0f) && bagBarPickedSlot_ < 0) {
+                // If an inventory window is open, hand off drag to inventory held-item
+                // so the bag can be dropped into backpack/bag slots.
+                if (inventoryScreen.isOpen() || inventoryScreen.isCharacterOpen()) {
+                    auto equip = static_cast<game::EquipSlot>(
+                        static_cast<int>(game::EquipSlot::BAG1) + bagBarDragSource_);
+                    if (inventoryScreen.beginPickupFromEquipSlot(inv, equip)) {
+                        bagBarDragSource_ = -1;
+                    } else {
+                        bagBarPickedSlot_ = bagBarDragSource_;
+                    }
+                } else {
+                    // Mouse moved enough — start visual drag
+                    bagBarPickedSlot_ = bagBarDragSource_;
+                }
+            }
+            if (ImGui::IsMouseReleased(ImGuiMouseButton_Left)) {
+                if (bagBarPickedSlot_ >= 0) {
+                    // Was dragging — check for drop target
+                    ImVec2 mousePos = ImGui::GetIO().MousePos;
+                    int dropTarget = -1;
+                    for (int j = 0; j < 4; ++j) {
+                        if (j == bagBarPickedSlot_) continue;
+                        if (mousePos.x >= bagSlotMins[j].x && mousePos.x <= bagSlotMaxs[j].x &&
+                            mousePos.y >= bagSlotMins[j].y && mousePos.y <= bagSlotMaxs[j].y) {
+                            dropTarget = j;
+                            break;
+                        }
+                    }
+                    if (dropTarget >= 0) {
+                        gameHandler.swapBagSlots(bagBarPickedSlot_, dropTarget);
+                    }
+                    bagBarPickedSlot_ = -1;
+                } else {
+                    // Was just a click (no drag) — toggle bag
+                    int slot = bagBarDragSource_;
+                    auto equip = static_cast<game::EquipSlot>(static_cast<int>(game::EquipSlot::BAG1) + slot);
+                    if (!inv.getEquipSlot(equip).empty()) {
+                        if (inventoryScreen.isSeparateBags())
+                            inventoryScreen.toggleBag(slot);
+                        else
+                            inventoryScreen.toggle();
+                    }
+                }
+                bagBarDragSource_ = -1;
+            }
+        }
+
+        // Backpack (rightmost slot)
+        ImGui::SameLine(0, spacing);
+        ImGui::PushID(0);
+        if (backpackIconTexture_) {
+            if (ImGui::ImageButton("##backpack", (ImTextureID)(uintptr_t)backpackIconTexture_,
+                                   ImVec2(slotSize, slotSize),
+                                   ImVec2(0, 0), ImVec2(1, 1),
+                                   ImVec4(0.1f, 0.1f, 0.1f, 0.9f),
+                                   ImVec4(1, 1, 1, 1))) {
+                if (inventoryScreen.isSeparateBags())
+                    inventoryScreen.toggleBackpack();
+                else
+                    inventoryScreen.toggle();
+            }
+        } else {
+            if (ImGui::Button("B", ImVec2(slotSize, slotSize))) {
+                if (inventoryScreen.isSeparateBags())
+                    inventoryScreen.toggleBackpack();
+                else
+                    inventoryScreen.toggle();
+            }
+        }
+        if (ImGui::IsItemHovered()) {
+            ImGui::SetTooltip("Backpack");
+        }
+        if (inventoryScreen.isSeparateBags() &&
+            inventoryScreen.isBackpackOpen()) {
+            ImDrawList* dl = ImGui::GetWindowDrawList();
+            ImVec2 r0 = ImGui::GetItemRectMin();
+            ImVec2 r1 = ImGui::GetItemRectMax();
+            dl->AddRect(r0, r1, IM_COL32(255, 255, 255, 255), 3.0f, 0, 2.0f);
+        }
+        ImGui::PopID();
+
+    }
+    ImGui::End();
+
+    ImGui::PopStyleColor();
+    ImGui::PopStyleVar(4);
+
+    // Draw dragged bag icon following cursor
+    if (bagBarPickedSlot_ >= 0) {
+        auto& inv2 = gameHandler.getInventory();
+        auto pickedEquip = static_cast<game::EquipSlot>(
+            static_cast<int>(game::EquipSlot::BAG1) + bagBarPickedSlot_);
+        const auto& pickedItem = inv2.getEquipSlot(pickedEquip);
+        VkDescriptorSet pickedIcon = VK_NULL_HANDLE;
+        if (!pickedItem.empty() && pickedItem.item.displayInfoId != 0) {
+            pickedIcon = inventoryScreen.getItemIcon(pickedItem.item.displayInfoId);
+        }
+        if (pickedIcon) {
+            ImVec2 mousePos = ImGui::GetIO().MousePos;
+            float sz = 40.0f;
+            ImVec2 p0(mousePos.x - sz * 0.5f, mousePos.y - sz * 0.5f);
+            ImVec2 p1(mousePos.x + sz * 0.5f, mousePos.y + sz * 0.5f);
+            ImDrawList* fg = ImGui::GetForegroundDrawList();
+            fg->AddImage((ImTextureID)(uintptr_t)pickedIcon, p0, p1);
+            fg->AddRect(p0, p1, IM_COL32(200, 200, 200, 255), 0.0f, 0, 2.0f);
+        }
+    }
+}
+
+// ============================================================
+// XP Bar
+// ============================================================
+
+void GameScreen::renderXpBar(game::GameHandler& gameHandler) {
+    uint32_t nextLevelXp = gameHandler.getPlayerNextLevelXp();
+    if (nextLevelXp == 0) return; // No XP data yet (level 80 or not initialized)
+
+    uint32_t currentXp = gameHandler.getPlayerXp();
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
+
+    // Position just above the action bar
+    float slotSize = 48.0f;
+    float spacing = 4.0f;
+    float padding = 8.0f;
+    float barW = 12 * slotSize + 11 * spacing + padding * 2;
+    float barH = slotSize + 24.0f;
+    float actionBarY = screenH - barH;
+
+    float xpBarH = 20.0f;
+    float xpBarW = barW;
+    float xpBarX = (screenW - xpBarW) / 2.0f;
+    float xpBarY = actionBarY - xpBarH - 2.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(xpBarX, xpBarY), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(xpBarW, xpBarH + 4.0f), ImGuiCond_Always);
+
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
+                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
+                             ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_AlwaysAutoResize;
+
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 2.0f);
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(2.0f, 2.0f));
+    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.05f, 0.05f, 0.05f, 0.9f));
+    ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.3f, 0.3f, 0.3f, 0.8f));
+
+    if (ImGui::Begin("##XpBar", nullptr, flags)) {
+        float pct = static_cast<float>(currentXp) / static_cast<float>(nextLevelXp);
+        if (pct > 1.0f) pct = 1.0f;
+
+        // Custom segmented XP bar (20 bubbles)
+        ImVec2 barMin = ImGui::GetCursorScreenPos();
+        ImVec2 barSize = ImVec2(ImGui::GetContentRegionAvail().x, xpBarH - 4.0f);
+        ImVec2 barMax = ImVec2(barMin.x + barSize.x, barMin.y + barSize.y);
+        auto* drawList = ImGui::GetWindowDrawList();
+
+        ImU32 bg = IM_COL32(15, 15, 20, 220);
+        ImU32 fg = IM_COL32(148, 51, 238, 255);
+        ImU32 seg = IM_COL32(35, 35, 45, 255);
+        drawList->AddRectFilled(barMin, barMax, bg, 2.0f);
+        drawList->AddRect(barMin, barMax, IM_COL32(80, 80, 90, 220), 2.0f);
+
+        float fillW = barSize.x * pct;
+        if (fillW > 0.0f) {
+            drawList->AddRectFilled(barMin, ImVec2(barMin.x + fillW, barMax.y), fg, 2.0f);
+        }
+
+        const int segments = 20;
+        float segW = barSize.x / static_cast<float>(segments);
+        for (int i = 1; i < segments; ++i) {
+            float x = barMin.x + segW * i;
+            drawList->AddLine(ImVec2(x, barMin.y + 1.0f), ImVec2(x, barMax.y - 1.0f), seg, 1.0f);
+        }
+
+        char overlay[96];
+        snprintf(overlay, sizeof(overlay), "%u / %u XP", currentXp, nextLevelXp);
+        ImVec2 textSize = ImGui::CalcTextSize(overlay);
+        float tx = barMin.x + (barSize.x - textSize.x) * 0.5f;
+        float ty = barMin.y + (barSize.y - textSize.y) * 0.5f;
+        drawList->AddText(ImVec2(tx, ty), IM_COL32(230, 230, 230, 255), overlay);
+
+        ImGui::Dummy(barSize);
+    }
+    ImGui::End();
+
+    ImGui::PopStyleColor(2);
+    ImGui::PopStyleVar(2);
+}
+
+// ============================================================
+// Cast Bar (Phase 3)
+// ============================================================
+
+void GameScreen::renderCastBar(game::GameHandler& gameHandler) {
+    if (!gameHandler.isCasting()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
+
+    float barW = 300.0f;
+    float barX = (screenW - barW) / 2.0f;
+    float barY = screenH - 120.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(barX, barY), ImGuiCond_FirstUseEver);
+    ImGui::SetNextWindowSize(ImVec2(barW, 40), ImGuiCond_Always);
+
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize |
+                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
+                             ImGuiWindowFlags_NoScrollbar;
+
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
+    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.1f, 0.1f, 0.1f, 0.9f));
+
+    if (ImGui::Begin("##CastBar", nullptr, flags)) {
+        float progress = gameHandler.getCastProgress();
+        ImGui::PushStyleColor(ImGuiCol_PlotHistogram, ImVec4(0.8f, 0.6f, 0.2f, 1.0f));
+
+        char overlay[64];
+        uint32_t currentSpellId = gameHandler.getCurrentCastSpellId();
+        if (gameHandler.getCurrentCastSpellId() == 0) {
+            snprintf(overlay, sizeof(overlay), "Opening... (%.1fs)", gameHandler.getCastTimeRemaining());
+        } else {
+            const std::string& spellName = gameHandler.getSpellName(currentSpellId);
+            if (!spellName.empty())
+                snprintf(overlay, sizeof(overlay), "%s (%.1fs)", spellName.c_str(), gameHandler.getCastTimeRemaining());
+            else
+                snprintf(overlay, sizeof(overlay), "Casting... (%.1fs)", gameHandler.getCastTimeRemaining());
+        }
+        ImGui::ProgressBar(progress, ImVec2(-1, 20), overlay);
+        ImGui::PopStyleColor();
+    }
+    ImGui::End();
+
+    ImGui::PopStyleColor();
+    ImGui::PopStyleVar();
+}
+
 // ============================================================
 // Mirror Timers (breath / fatigue / feign death)
 // ============================================================
 
 void GameScreen::renderMirrorTimers(game::GameHandler& gameHandler) {
-    ImVec2 displaySize = ImGui::GetIO().DisplaySize;
-    float screenW = displaySize.x > 0.0f ? displaySize.x : 1280.0f;
-    float screenH = displaySize.y > 0.0f ? displaySize.y : 720.0f;
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth())  : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
 
-    static constexpr struct { const char* label; ImVec4 color; } kTimerInfo[3] = {
+    static const struct { const char* label; ImVec4 color; } kTimerInfo[3] = {
         { "Fatigue", ImVec4(0.8f, 0.4f, 0.1f, 1.0f) },
         { "Breath",  ImVec4(0.2f, 0.5f, 1.0f, 1.0f) },
-        { "Feign",   kColorGray },
+        { "Feign",   ImVec4(0.6f, 0.6f, 0.6f, 1.0f) },
     };
 
     float barW  = 280.0f;
@@ -4300,10 +4485,6 @@ void GameScreen::renderMirrorTimers(game::GameHandler& gameHandler) {
     }
 }
 
-// ============================================================
-// Cooldown Tracker — floating panel showing all active spell CDs
-// ============================================================
-
 // ============================================================
 // Quest Objective Tracker (right-side HUD)
 // ============================================================
@@ -4312,177 +4493,64 @@ void GameScreen::renderQuestObjectiveTracker(game::GameHandler& gameHandler) {
     const auto& questLog = gameHandler.getQuestLog();
     if (questLog.empty()) return;
 
-    auto* window = services_.window;
+    auto* window = core::Application::getInstance().getWindow();
     float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
 
     constexpr float TRACKER_W = 220.0f;
     constexpr float RIGHT_MARGIN = 10.0f;
     constexpr int   MAX_QUESTS = 5;
 
-    // Build display list: tracked quests only, or all quests if none tracked
-    const auto& trackedIds = gameHandler.getTrackedQuestIds();
-    std::vector<const game::GameHandler::QuestLogEntry*> toShow;
-    toShow.reserve(MAX_QUESTS);
-    if (!trackedIds.empty()) {
-        for (const auto& q : questLog) {
-            if (q.questId == 0) continue;
-            if (trackedIds.count(q.questId)) toShow.push_back(&q);
-            if (static_cast<int>(toShow.size()) >= MAX_QUESTS) break;
-        }
-    }
-    // Fallback: show all quests if nothing is tracked
-    if (toShow.empty()) {
-        for (const auto& q : questLog) {
-            if (q.questId == 0) continue;
-            toShow.push_back(&q);
-            if (static_cast<int>(toShow.size()) >= MAX_QUESTS) break;
-        }
-    }
-    if (toShow.empty()) return;
+    float x = screenW - TRACKER_W - RIGHT_MARGIN;
+    float y = 200.0f;  // below minimap area
 
-    float screenH = ImGui::GetIO().DisplaySize.y > 0.0f ? ImGui::GetIO().DisplaySize.y : 720.0f;
+    ImGui::SetNextWindowPos(ImVec2(x, y), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(TRACKER_W, 0), ImGuiCond_Always);
 
-    // Default position: top-right, below minimap + buff bar space.
-    // questTrackerRightOffset_ stores pixels from the right edge so the tracker
-    // stays anchored to the right side when the window is resized.
-    if (!questTrackerPosInit_ || questTrackerRightOffset_ < 0.0f) {
-        questTrackerRightOffset_ = TRACKER_W + RIGHT_MARGIN; // default: right-aligned
-        questTrackerPos_.y = 320.0f;
-        questTrackerPosInit_ = true;
-    }
-    // Recompute X from right offset every frame (handles window resize)
-    questTrackerPos_.x = screenW - questTrackerRightOffset_;
-
-    ImGui::SetNextWindowPos(questTrackerPos_, ImGuiCond_Always);
-    ImGui::SetNextWindowSize(questTrackerSize_, ImGuiCond_FirstUseEver);
-
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoTitleBar |
-                             ImGuiWindowFlags_NoScrollbar |
-                             ImGuiWindowFlags_NoCollapse |
-                             ImGuiWindowFlags_NoNav |
-                             ImGuiWindowFlags_NoBringToFrontOnFocus;
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoInputs |
+                             ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoMove |
+                             ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoBringToFrontOnFocus;
 
     ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.0f, 0.0f, 0.0f, 0.55f));
     ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(6.0f, 6.0f));
     ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(4.0f, 2.0f));
 
     if (ImGui::Begin("##QuestTracker", nullptr, flags)) {
-        for (int i = 0; i < static_cast<int>(toShow.size()); ++i) {
-            const auto& q = *toShow[i];
+        int shown = 0;
+        for (const auto& q : questLog) {
+            if (q.questId == 0) continue;
+            if (shown >= MAX_QUESTS) break;
 
-            // Clickable quest title — opens quest log
-            ImGui::PushID(q.questId);
-            ImVec4 titleCol = q.complete ? colors::kWarmGold
+            // Quest title in yellow (gold) if complete, white if in progress
+            ImVec4 titleCol = q.complete ? ImVec4(1.0f, 0.84f, 0.0f, 1.0f)
                                          : ImVec4(1.0f, 1.0f, 0.85f, 1.0f);
-            ImGui::PushStyleColor(ImGuiCol_Text, titleCol);
-            if (ImGui::Selectable(q.title.c_str(), false,
-                                   ImGuiSelectableFlags_DontClosePopups, ImVec2(ImGui::GetContentRegionAvail().x, 0))) {
-                questLogScreen.openAndSelectQuest(q.questId);
-            }
-            if (ImGui::IsItemHovered() && !ImGui::IsPopupOpen("##QTCtx")) {
-                ImGui::SetTooltip("Click: open Quest Log  |  Right-click: tracking options");
-            }
-            ImGui::PopStyleColor();
-
-            // Right-click context menu for quest tracker entry
-            if (ImGui::BeginPopupContextItem("##QTCtx")) {
-                ImGui::TextDisabled("%s", q.title.c_str());
-                ImGui::Separator();
-                if (ImGui::MenuItem("Open in Quest Log")) {
-                    questLogScreen.openAndSelectQuest(q.questId);
-                }
-                bool tracked = gameHandler.isQuestTracked(q.questId);
-                if (tracked) {
-                    if (ImGui::MenuItem("Stop Tracking")) {
-                        gameHandler.setQuestTracked(q.questId, false);
-                    }
-                } else {
-                    if (ImGui::MenuItem("Track")) {
-                        gameHandler.setQuestTracked(q.questId, true);
-                    }
-                }
-                if (gameHandler.isInGroup() && !q.complete) {
-                    if (ImGui::MenuItem("Share Quest")) {
-                        gameHandler.shareQuestWithParty(q.questId);
-                    }
-                }
-                if (!q.complete) {
-                    ImGui::Separator();
-                    if (ImGui::MenuItem("Abandon Quest")) {
-                        gameHandler.abandonQuest(q.questId);
-                        gameHandler.setQuestTracked(q.questId, false);
-                    }
-                }
-                ImGui::EndPopup();
-            }
-            ImGui::PopID();
+            ImGui::TextColored(titleCol, "%s", q.title.c_str());
 
             // Objectives line (condensed)
             if (q.complete) {
-                ImGui::TextColored(colors::kActiveGreen, "  (Complete)");
+                ImGui::TextColored(ImVec4(0.5f, 1.0f, 0.5f, 1.0f), "  (Complete)");
             } else {
-                // Kill counts — green when complete, gray when in progress
+                // Kill counts
                 for (const auto& [entry, progress] : q.killCounts) {
-                    bool objDone = (progress.first >= progress.second && progress.second > 0);
-                    ImVec4 objColor = objDone ? kColorGreen
-                                              : ImVec4(0.75f, 0.75f, 0.75f, 1.0f);
-                    std::string name = gameHandler.getCachedCreatureName(entry);
-                    if (name.empty()) {
-                        const auto* goInfo = gameHandler.getCachedGameObjectInfo(entry);
-                        if (goInfo && !goInfo->name.empty()) name = goInfo->name;
-                    }
-                    if (!name.empty()) {
-                        ImGui::TextColored(objColor,
-                                           "  %s: %u/%u", name.c_str(),
-                                           progress.first, progress.second);
-                    } else {
-                        ImGui::TextColored(objColor,
-                                           "  %u/%u", progress.first, progress.second);
-                    }
+                    ImGui::TextColored(ImVec4(0.75f, 0.75f, 0.75f, 1.0f),
+                                       "  %u/%u", progress.first, progress.second);
                 }
-                // Item counts — green when complete, gray when in progress
+                // Item counts
                 for (const auto& [itemId, count] : q.itemCounts) {
                     uint32_t required = 1;
                     auto reqIt = q.requiredItemCounts.find(itemId);
                     if (reqIt != q.requiredItemCounts.end()) required = reqIt->second;
-                    bool objDone = (count >= required);
-                    ImVec4 objColor = objDone ? kColorGreen
-                                              : ImVec4(0.75f, 0.75f, 0.75f, 1.0f);
                     const auto* info = gameHandler.getItemInfo(itemId);
                     const char* itemName = (info && !info->name.empty()) ? info->name.c_str() : nullptr;
-
-                    // Show small icon if available
-                    uint32_t dispId = (info && info->displayInfoId) ? info->displayInfoId : 0;
-                    VkDescriptorSet iconTex = dispId ? inventoryScreen.getItemIcon(dispId) : VK_NULL_HANDLE;
-                    if (iconTex) {
-                        ImGui::Image((ImTextureID)(uintptr_t)iconTex, ImVec2(12, 12));
-                        if (info && info->valid && ImGui::IsItemHovered()) {
-                            ImGui::BeginTooltip();
-                            inventoryScreen.renderItemTooltip(*info);
-                            ImGui::EndTooltip();
-                        }
-                        ImGui::SameLine(0, 3);
-                        ImGui::TextColored(objColor,
-                                           "%s: %u/%u", itemName ? itemName : "Item", count, required);
-                        if (info && info->valid && ImGui::IsItemHovered()) {
-                            ImGui::BeginTooltip();
-                            inventoryScreen.renderItemTooltip(*info);
-                            ImGui::EndTooltip();
-                        }
-                    } else if (itemName) {
-                        ImGui::TextColored(objColor,
+                    if (itemName) {
+                        ImGui::TextColored(ImVec4(0.75f, 0.75f, 0.75f, 1.0f),
                                            "  %s: %u/%u", itemName, count, required);
-                        if (info && info->valid && ImGui::IsItemHovered()) {
-                            ImGui::BeginTooltip();
-                            inventoryScreen.renderItemTooltip(*info);
-                            ImGui::EndTooltip();
-                        }
                     } else {
-                        ImGui::TextColored(objColor,
+                        ImGui::TextColored(ImVec4(0.75f, 0.75f, 0.75f, 1.0f),
                                            "  Item: %u/%u", count, required);
                     }
                 }
                 if (q.killCounts.empty() && q.itemCounts.empty() && !q.objectives.empty()) {
+                    // Show the raw objectives text, truncated if needed
                     const std::string& obj = q.objectives;
                     if (obj.size() > 40) {
                         ImGui::TextColored(ImVec4(0.75f, 0.75f, 0.75f, 1.0f),
@@ -4494,33 +4562,11 @@ void GameScreen::renderQuestObjectiveTracker(game::GameHandler& gameHandler) {
                 }
             }
 
-            if (i < static_cast<int>(toShow.size()) - 1) {
+            if (shown < MAX_QUESTS - 1 && shown < static_cast<int>(questLog.size()) - 1) {
                 ImGui::Spacing();
             }
+            ++shown;
         }
-
-        // Capture position and size after drag/resize
-        ImVec2 newPos  = ImGui::GetWindowPos();
-        ImVec2 newSize = ImGui::GetWindowSize();
-        bool changed = false;
-
-        // Clamp within screen
-        newPos.x = std::clamp(newPos.x, 0.0f, screenW - newSize.x);
-        newPos.y = std::clamp(newPos.y, 0.0f, screenH - 40.0f);
-
-        if (std::abs(newPos.x - questTrackerPos_.x) > 0.5f ||
-            std::abs(newPos.y - questTrackerPos_.y) > 0.5f) {
-            questTrackerPos_ = newPos;
-            // Update right offset so resizes keep the new position anchored
-            questTrackerRightOffset_ = screenW - newPos.x;
-            changed = true;
-        }
-        if (std::abs(newSize.x - questTrackerSize_.x) > 0.5f ||
-            std::abs(newSize.y - questTrackerSize_.y) > 0.5f) {
-            questTrackerSize_ = newSize;
-            changed = true;
-        }
-        if (changed) saveSettings();
     }
     ImGui::End();
 
@@ -4528,6 +4574,125 @@ void GameScreen::renderQuestObjectiveTracker(game::GameHandler& gameHandler) {
     ImGui::PopStyleColor();
 }
 
+// ============================================================
+// Floating Combat Text (Phase 2)
+// ============================================================
+
+void GameScreen::renderCombatText(game::GameHandler& gameHandler) {
+    const auto& entries = gameHandler.getCombatText();
+    if (entries.empty()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+
+    // Render combat text entries overlaid on screen
+    ImGui::SetNextWindowPos(ImVec2(0, 0));
+    ImGui::SetNextWindowSize(ImVec2(screenW, 400));
+
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoDecoration |
+                             ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoNav;
+
+    if (ImGui::Begin("##CombatText", nullptr, flags)) {
+        // Incoming events (enemy attacks player) float near screen center (over the player).
+        // Outgoing events (player attacks enemy) float on the right side (near the target).
+        const float incomingX = screenW * 0.40f;
+        const float outgoingX = screenW * 0.68f;
+
+        int inIdx = 0, outIdx = 0;
+        for (const auto& entry : entries) {
+            float alpha = 1.0f - (entry.age / game::CombatTextEntry::LIFETIME);
+            float yOffset = 200.0f - entry.age * 60.0f;
+            const bool outgoing = entry.isPlayerSource;
+
+            ImVec4 color;
+            char text[64];
+            switch (entry.type) {
+                case game::CombatTextEntry::MELEE_DAMAGE:
+                case game::CombatTextEntry::SPELL_DAMAGE:
+                    snprintf(text, sizeof(text), "-%d", entry.amount);
+                    color = outgoing ?
+                        ImVec4(1.0f, 1.0f, 0.3f, alpha) :   // Outgoing = yellow
+                        ImVec4(1.0f, 0.3f, 0.3f, alpha);     // Incoming = red
+                    break;
+                case game::CombatTextEntry::CRIT_DAMAGE:
+                    snprintf(text, sizeof(text), "-%d!", entry.amount);
+                    color = outgoing ?
+                        ImVec4(1.0f, 0.8f, 0.0f, alpha) :   // Outgoing crit = bright yellow
+                        ImVec4(1.0f, 0.5f, 0.0f, alpha);     // Incoming crit = orange
+                    break;
+                case game::CombatTextEntry::HEAL:
+                    snprintf(text, sizeof(text), "+%d", entry.amount);
+                    color = ImVec4(0.3f, 1.0f, 0.3f, alpha);
+                    break;
+                case game::CombatTextEntry::CRIT_HEAL:
+                    snprintf(text, sizeof(text), "+%d!", entry.amount);
+                    color = ImVec4(0.3f, 1.0f, 0.3f, alpha);
+                    break;
+                case game::CombatTextEntry::MISS:
+                    snprintf(text, sizeof(text), "Miss");
+                    color = ImVec4(0.7f, 0.7f, 0.7f, alpha);
+                    break;
+                case game::CombatTextEntry::DODGE:
+                    // outgoing=true: enemy dodged player's attack
+                    // outgoing=false: player dodged incoming attack
+                    snprintf(text, sizeof(text), outgoing ? "Dodge" : "You Dodge");
+                    color = outgoing ? ImVec4(0.6f, 0.6f, 0.6f, alpha)
+                                     : ImVec4(0.4f, 0.9f, 1.0f, alpha);
+                    break;
+                case game::CombatTextEntry::PARRY:
+                    snprintf(text, sizeof(text), outgoing ? "Parry" : "You Parry");
+                    color = outgoing ? ImVec4(0.6f, 0.6f, 0.6f, alpha)
+                                     : ImVec4(0.4f, 0.9f, 1.0f, alpha);
+                    break;
+                case game::CombatTextEntry::BLOCK:
+                    snprintf(text, sizeof(text), outgoing ? "Block" : "You Block");
+                    color = outgoing ? ImVec4(0.6f, 0.6f, 0.6f, alpha)
+                                     : ImVec4(0.4f, 0.9f, 1.0f, alpha);
+                    break;
+                case game::CombatTextEntry::PERIODIC_DAMAGE:
+                    snprintf(text, sizeof(text), "-%d", entry.amount);
+                    color = outgoing ?
+                        ImVec4(1.0f, 0.9f, 0.3f, alpha) :   // Outgoing DoT = pale yellow
+                        ImVec4(1.0f, 0.4f, 0.4f, alpha);     // Incoming DoT = pale red
+                    break;
+                case game::CombatTextEntry::PERIODIC_HEAL:
+                    snprintf(text, sizeof(text), "+%d", entry.amount);
+                    color = ImVec4(0.4f, 1.0f, 0.5f, alpha);
+                    break;
+                case game::CombatTextEntry::ENVIRONMENTAL:
+                    snprintf(text, sizeof(text), "-%d", entry.amount);
+                    color = ImVec4(0.9f, 0.5f, 0.2f, alpha);  // Orange for environmental
+                    break;
+                case game::CombatTextEntry::ENERGIZE:
+                    snprintf(text, sizeof(text), "+%d", entry.amount);
+                    color = ImVec4(0.3f, 0.6f, 1.0f, alpha);  // Blue for mana/energy
+                    break;
+                case game::CombatTextEntry::XP_GAIN:
+                    snprintf(text, sizeof(text), "+%d XP", entry.amount);
+                    color = ImVec4(0.7f, 0.3f, 1.0f, alpha);  // Purple for XP
+                    break;
+                case game::CombatTextEntry::IMMUNE:
+                    snprintf(text, sizeof(text), "Immune!");
+                    color = ImVec4(0.9f, 0.9f, 0.9f, alpha);  // White for immune
+                    break;
+                default:
+                    snprintf(text, sizeof(text), "%d", entry.amount);
+                    color = ImVec4(1.0f, 1.0f, 1.0f, alpha);
+                    break;
+            }
+
+            // Outgoing → right side (near target), incoming → center-left (near player)
+            int& idx = outgoing ? outIdx : inIdx;
+            float baseX = outgoing ? outgoingX : incomingX;
+            float xOffset = baseX + (idx % 3 - 1) * 60.0f;
+            ++idx;
+            ImGui::SetCursorPos(ImVec2(xOffset, yOffset));
+            ImGui::TextColored(color, "%s", text);
+        }
+    }
+    ImGui::End();
+}
+
 // ============================================================
 // Nameplates — world-space health bars projected to screen
 // ============================================================
@@ -4535,15 +4700,12 @@ void GameScreen::renderQuestObjectiveTracker(game::GameHandler& gameHandler) {
 void GameScreen::renderNameplates(game::GameHandler& gameHandler) {
     if (gameHandler.getState() != game::WorldState::IN_WORLD) return;
 
-    // Reset mouseover each frame; we'll set it below when the cursor is over a nameplate
-    gameHandler.setMouseoverGuid(0);
-
-    auto* appRenderer = services_.renderer;
+    auto* appRenderer = core::Application::getInstance().getRenderer();
     if (!appRenderer) return;
     rendering::Camera* camera = appRenderer->getCamera();
     if (!camera) return;
 
-    auto* window = services_.window;
+    auto* window = core::Application::getInstance().getWindow();
     if (!window) return;
     const float screenW = static_cast<float>(window->getWidth());
     const float screenH = static_cast<float>(window->getHeight());
@@ -4553,61 +4715,25 @@ void GameScreen::renderNameplates(game::GameHandler& gameHandler) {
     const uint64_t  playerGuid = gameHandler.getPlayerGuid();
     const uint64_t  targetGuid = gameHandler.getTargetGuid();
 
-    // Build set of creature entries that are kill objectives in active (incomplete) quests.
-    std::unordered_set<uint32_t> questKillEntries;
-    {
-        const auto& questLog = gameHandler.getQuestLog();
-        const auto& trackedIds = gameHandler.getTrackedQuestIds();
-        for (const auto& q : questLog) {
-            if (q.complete || q.questId == 0) continue;
-            // Only highlight for tracked quests (or all if nothing tracked).
-            if (!trackedIds.empty() && !trackedIds.count(q.questId)) continue;
-            for (const auto& obj : q.killObjectives) {
-                if (obj.npcOrGoId > 0 && obj.required > 0) {
-                    // Check if not already completed.
-                    auto it = q.killCounts.find(static_cast<uint32_t>(obj.npcOrGoId));
-                    if (it == q.killCounts.end() || it->second.first < it->second.second) {
-                        questKillEntries.insert(static_cast<uint32_t>(obj.npcOrGoId));
-                    }
-                }
-            }
-        }
-    }
-
     ImDrawList* drawList = ImGui::GetBackgroundDrawList();
 
     for (const auto& [guid, entityPtr] : gameHandler.getEntityManager().getEntities()) {
         if (!entityPtr || guid == playerGuid) continue;
 
-        if (!entityPtr->isUnit()) continue;
-        auto* unit = static_cast<game::Unit*>(entityPtr.get());
-        if (unit->getMaxHealth() == 0) continue;
+        auto* unit = dynamic_cast<game::Unit*>(entityPtr.get());
+        if (!unit || unit->getMaxHealth() == 0) continue;
 
-        bool isPlayer = (entityPtr->getType() == game::ObjectType::PLAYER);
-        bool isTarget = (guid == targetGuid);
+        // Only show nameplate for the currently targeted unit
+        if (guid != targetGuid) continue;
 
-        // Player nameplates use Shift+V toggle; NPC/enemy nameplates use V toggle
-        if (isPlayer && !settingsPanel_.showFriendlyNameplates_) continue;
-        if (!isPlayer && !showNameplates_) continue;
-
-        // For corpses (dead units), only show a minimal grey nameplate if selected
-        bool isCorpse = (unit->getHealth() == 0);
-        if (isCorpse && !isTarget) continue;
-
-        // Prefer the renderer's actual instance position so the nameplate tracks the
-        // rendered model exactly (avoids drift from the parallel entity interpolator).
-        glm::vec3 renderPos;
-        if (!core::Application::getInstance().getRenderPositionForGuid(guid, renderPos)) {
-            renderPos = core::coords::canonicalToRender(
-                glm::vec3(unit->getX(), unit->getY(), unit->getZ()));
-        }
+        // Convert canonical WoW position → render space, raise to head height
+        glm::vec3 renderPos = core::coords::canonicalToRender(
+            glm::vec3(unit->getX(), unit->getY(), unit->getZ()));
         renderPos.z += 2.3f;
 
-        // Cull distance: target or other players up to 40 units; NPC others up to 20 units
-        glm::vec3 nameDelta = renderPos - camPos;
-        float distSq = glm::dot(nameDelta, nameDelta);
-        float cullDist = (isTarget || isPlayer) ? 40.0f : 20.0f;
-        if (distSq > cullDist * cullDist) continue;
+        // Cull if too far (render units ≈ WoW yards)
+        float dist = glm::length(renderPos - camPos);
+        if (dist > 40.0f) continue;
 
         // Project to clip space
         glm::vec4 clipPos = viewProj * glm::vec4(renderPos, 1.0f);
@@ -4623,688 +4749,3083 @@ void GameScreen::renderNameplates(game::GameHandler& gameHandler) {
         float sx = (ndc.x * 0.5f + 0.5f) * screenW;
         float sy = (ndc.y * 0.5f + 0.5f) * screenH;
 
-        // Fade out in the last 5 units of cull range
-        float fadeSq = (cullDist - 5.0f) * (cullDist - 5.0f);
-        float dist = std::sqrt(distSq);
-        float alpha = distSq < fadeSq ? 1.0f : 1.0f - (dist - (cullDist - 5.0f)) / 5.0f;
+        // Fade out in the last 5 units of range
+        float alpha = dist < 35.0f ? 1.0f : 1.0f - (dist - 35.0f) / 5.0f;
         auto A = [&](int v) { return static_cast<int>(v * alpha); };
 
-        // Bar colour by hostility (grey for corpses)
+        // Bar colour by hostility
         ImU32 barColor, bgColor;
-        if (isCorpse) {
-            // Minimal grey bar for selected corpses (loot/skin targets)
-            barColor = IM_COL32(140, 140, 140, A(200));
-            bgColor  = IM_COL32(70,  70,  70,  A(160));
-        } else if (unit->isHostile()) {
-            // Check if mob is tapped by another player (grey nameplate)
-            uint32_t dynFlags = unit->getDynamicFlags();
-            bool tappedByOther = (dynFlags & 0x0004) != 0 && (dynFlags & 0x0008) == 0; // TAPPED but not TAPPED_BY_ALL_THREAT_LIST
-            if (tappedByOther) {
-                barColor = IM_COL32(160, 160, 160, A(200));
-                bgColor  = IM_COL32(80,  80,  80,  A(160));
-            } else {
-                barColor = IM_COL32(220, 60,  60,  A(200));
-                bgColor  = IM_COL32(100, 25,  25,  A(160));
-            }
-        } else if (isPlayer) {
-            // Player nameplates: use class color for easy identification
-            uint8_t cid = entityClassId(unit);
-            if (cid != 0) {
-                ImVec4 cv = classColorVec4(cid);
-                barColor = IM_COL32(
-                    static_cast<int>(cv.x * 255),
-                    static_cast<int>(cv.y * 255),
-                    static_cast<int>(cv.z * 255), A(210));
-                bgColor  = IM_COL32(
-                    static_cast<int>(cv.x * 80),
-                    static_cast<int>(cv.y * 80),
-                    static_cast<int>(cv.z * 80), A(160));
-            } else {
-                barColor = IM_COL32(60,  200, 80,  A(200));
-                bgColor  = IM_COL32(25,  100, 35,  A(160));
-            }
+        if (unit->isHostile()) {
+            barColor = IM_COL32(220, 60,  60,  A(200));
+            bgColor  = IM_COL32(100, 25,  25,  A(160));
         } else {
             barColor = IM_COL32(60,  200, 80,  A(200));
             bgColor  = IM_COL32(25,  100, 35,  A(160));
         }
-        // Check if this unit is targeting the local player (threat indicator)
-        bool isTargetingPlayer = false;
-        if (unit->isHostile() && !isCorpse) {
-            const auto& fields = entityPtr->getFields();
-            auto loIt = fields.find(game::fieldIndex(game::UF::UNIT_FIELD_TARGET_LO));
-            if (loIt != fields.end() && loIt->second != 0) {
-                uint64_t unitTarget = loIt->second;
-                auto hiIt = fields.find(game::fieldIndex(game::UF::UNIT_FIELD_TARGET_HI));
-                if (hiIt != fields.end())
-                    unitTarget |= (static_cast<uint64_t>(hiIt->second) << 32);
-                isTargetingPlayer = (unitTarget == playerGuid);
-            }
-        }
-        // Creature rank for border styling (Elite=gold double border, Boss=red, Rare=silver)
-        int creatureRank = -1;
-        if (!isPlayer) creatureRank = gameHandler.getCreatureRank(unit->getEntry());
-
-        // Border: gold = currently selected, orange = targeting player, dark = default
-        ImU32 borderColor = isTarget
+        ImU32 borderColor = (guid == targetGuid)
             ? IM_COL32(255, 215, 0,  A(255))
-            : isTargetingPlayer
-              ? IM_COL32(255, 140, 0,  A(220))   // orange = this mob is targeting you
-              : IM_COL32(20,  20,  20, A(180));
+            : IM_COL32(20,  20,  20, A(180));
 
         // Bar geometry
-        const float barW = 80.0f * settingsPanel_.nameplateScale_;
-        const float barH = 8.0f * settingsPanel_.nameplateScale_;
+        constexpr float barW = 80.0f;
+        constexpr float barH = 8.0f;
         const float barX = sx - barW * 0.5f;
 
-        // Guard against division by zero when maxHealth hasn't been populated yet
-        // (freshly spawned entity with default fields). 0/0 produces NaN which
-        // poisons all downstream geometry; +inf is clamped but still wasteful.
-        float healthPct = (unit->getMaxHealth() > 0)
-            ? std::clamp(static_cast<float>(unit->getHealth()) / static_cast<float>(unit->getMaxHealth()), 0.0f, 1.0f)
-            : 0.0f;
+        float healthPct = std::clamp(
+            static_cast<float>(unit->getHealth()) / static_cast<float>(unit->getMaxHealth()),
+            0.0f, 1.0f);
 
         drawList->AddRectFilled(ImVec2(barX,                 sy), ImVec2(barX + barW,               sy + barH), bgColor,    2.0f);
-        // For corpses, don't fill health bar (just show grey background)
-        if (!isCorpse) {
-            drawList->AddRectFilled(ImVec2(barX,                 sy), ImVec2(barX + barW * healthPct,   sy + barH), barColor,   2.0f);
-        }
+        drawList->AddRectFilled(ImVec2(barX,                 sy), ImVec2(barX + barW * healthPct,   sy + barH), barColor,   2.0f);
         drawList->AddRect       (ImVec2(barX - 1.0f, sy - 1.0f), ImVec2(barX + barW + 1.0f, sy + barH + 1.0f), borderColor, 2.0f);
 
-        // Elite/Boss/Rare decoration: extra outer border with rank-specific color
-        if (creatureRank == 1 || creatureRank == 2) {
-            // Elite / Rare Elite: gold double border
-            drawList->AddRect(ImVec2(barX - 3.0f, sy - 3.0f),
-                              ImVec2(barX + barW + 3.0f, sy + barH + 3.0f),
-                              IM_COL32(255, 200, 50, A(200)), 3.0f);
-        } else if (creatureRank == 3) {
-            // Boss: red double border
-            drawList->AddRect(ImVec2(barX - 3.0f, sy - 3.0f),
-                              ImVec2(barX + barW + 3.0f, sy + barH + 3.0f),
-                              IM_COL32(255, 40, 40, A(200)), 3.0f);
-        } else if (creatureRank == 4) {
-            // Rare: silver double border
-            drawList->AddRect(ImVec2(barX - 3.0f, sy - 3.0f),
-                              ImVec2(barX + barW + 3.0f, sy + barH + 3.0f),
-                              IM_COL32(170, 200, 230, A(200)), 3.0f);
-        }
-
-        // HP % text centered on health bar (non-corpse, non-full-health for readability)
-        if (!isCorpse && unit->getMaxHealth() > 0) {
-            int hpPct = static_cast<int>(healthPct * 100.0f + 0.5f);
-            char hpBuf[8];
-            snprintf(hpBuf, sizeof(hpBuf), "%d%%", hpPct);
-            ImVec2 hpTextSz = ImGui::CalcTextSize(hpBuf);
-            float hpTx = sx - hpTextSz.x * 0.5f;
-            float hpTy = sy + (barH - hpTextSz.y) * 0.5f;
-            drawList->AddText(ImVec2(hpTx + 1.0f, hpTy + 1.0f), IM_COL32(0, 0, 0, A(140)), hpBuf);
-            drawList->AddText(ImVec2(hpTx,         hpTy),         IM_COL32(255, 255, 255, A(200)), hpBuf);
-        }
-
-        // Cast bar below health bar when unit is casting
-        float castBarBaseY = sy + barH + 2.0f;
-        float nameplateBottom = castBarBaseY;  // tracks lowest drawn element for debuff dots
-        {
-            const auto* cs = gameHandler.getUnitCastState(guid);
-            if (cs && cs->casting && cs->timeTotal > 0.0f) {
-                float castPct = std::clamp((cs->timeTotal - cs->timeRemaining) / cs->timeTotal, 0.0f, 1.0f);
-                const float cbH = 6.0f * settingsPanel_.nameplateScale_;
-
-                // Spell icon + name above the cast bar
-                const std::string& spellName = gameHandler.getSpellName(cs->spellId);
-                {
-                    auto* castAm = services_.assetManager;
-                    VkDescriptorSet castIcon = (cs->spellId && castAm)
-                        ? getSpellIcon(cs->spellId, castAm) : VK_NULL_HANDLE;
-                    float iconSz = cbH + 8.0f;
-                    if (castIcon) {
-                        // Draw icon to the left of the cast bar
-                        float iconX = barX - iconSz - 2.0f;
-                        float iconY = castBarBaseY;
-                        drawList->AddImage((ImTextureID)(uintptr_t)castIcon,
-                                           ImVec2(iconX, iconY),
-                                           ImVec2(iconX + iconSz, iconY + iconSz));
-                        drawList->AddRect(ImVec2(iconX - 1.0f, iconY - 1.0f),
-                                          ImVec2(iconX + iconSz + 1.0f, iconY + iconSz + 1.0f),
-                                          IM_COL32(0, 0, 0, A(180)), 1.0f);
-                    }
-                    if (!spellName.empty()) {
-                        ImVec2 snSz = ImGui::CalcTextSize(spellName.c_str());
-                        float snX = sx - snSz.x * 0.5f;
-                        float snY = castBarBaseY;
-                        drawList->AddText(ImVec2(snX + 1.0f, snY + 1.0f), IM_COL32(0, 0, 0, A(140)), spellName.c_str());
-                        drawList->AddText(ImVec2(snX,         snY),         IM_COL32(255, 210, 100, A(220)), spellName.c_str());
-                        castBarBaseY += snSz.y + 2.0f;
-                    }
-                }
-
-                // Cast bar: green = interruptible, red = uninterruptible; both pulse when >80% complete
-                ImU32 cbBg = IM_COL32(30, 25, 40, A(180));
-                ImU32 cbFill;
-                if (castPct > 0.8f && unit->isHostile()) {
-                    float pulse = 0.7f + 0.3f * std::sin(static_cast<float>(ImGui::GetTime()) * 8.0f);
-                    cbFill = cs->interruptible
-                        ? IM_COL32(static_cast<int>(40  * pulse), static_cast<int>(220 * pulse), static_cast<int>(40  * pulse), A(220))  // green pulse
-                        : IM_COL32(static_cast<int>(255 * pulse), static_cast<int>(30  * pulse), static_cast<int>(30  * pulse), A(220)); // red pulse
-                } else {
-                    cbFill = cs->interruptible
-                        ? IM_COL32(50,  190, 50,  A(200))   // green = interruptible
-                        : IM_COL32(190, 40,  40,  A(200));  // red = uninterruptible
-                }
-                drawList->AddRectFilled(ImVec2(barX,                   castBarBaseY),
-                                        ImVec2(barX + barW,             castBarBaseY + cbH), cbBg,    2.0f);
-                drawList->AddRectFilled(ImVec2(barX,                   castBarBaseY),
-                                        ImVec2(barX + barW * castPct,   castBarBaseY + cbH), cbFill,  2.0f);
-                drawList->AddRect      (ImVec2(barX - 1.0f, castBarBaseY - 1.0f),
-                                        ImVec2(barX + barW + 1.0f, castBarBaseY + cbH + 1.0f),
-                                        IM_COL32(20, 10, 40, A(200)), 2.0f);
-
-                // Time remaining text
-                char timeBuf[12];
-                snprintf(timeBuf, sizeof(timeBuf), "%.1fs", cs->timeRemaining);
-                ImVec2 timeSz = ImGui::CalcTextSize(timeBuf);
-                float timeX = sx - timeSz.x * 0.5f;
-                float timeY = castBarBaseY + (cbH - timeSz.y) * 0.5f;
-                drawList->AddText(ImVec2(timeX + 1.0f, timeY + 1.0f), IM_COL32(0, 0, 0, A(140)), timeBuf);
-                drawList->AddText(ImVec2(timeX,         timeY),         IM_COL32(220, 200, 255, A(220)), timeBuf);
-                nameplateBottom = castBarBaseY + cbH + 2.0f;
-            }
-        }
-
-        // Debuff dot indicators: small colored squares below the nameplate showing
-        // player-applied auras on the current hostile target.
-        // Colors: Magic=blue, Curse=purple, Disease=yellow, Poison=green, Other=grey
-        if (isTarget && unit->isHostile() && !isCorpse) {
-            const auto& auras = gameHandler.getTargetAuras();
-            const uint64_t pguid = gameHandler.getPlayerGuid();
-            const float dotSize = 6.0f * settingsPanel_.nameplateScale_;
-            const float dotGap  = 2.0f;
-            float dotX = barX;
-            for (const auto& aura : auras) {
-                if (aura.isEmpty() || aura.casterGuid != pguid) continue;
-                uint8_t dispelType = gameHandler.getSpellDispelType(aura.spellId);
-                ImU32 dotCol;
-                switch (dispelType) {
-                    case 1:  dotCol = IM_COL32( 64, 128, 255, A(210)); break; // Magic   - blue
-                    case 2:  dotCol = IM_COL32(160,  32, 240, A(210)); break; // Curse   - purple
-                    case 3:  dotCol = IM_COL32(180, 140,  40, A(210)); break; // Disease - yellow-brown
-                    case 4:  dotCol = IM_COL32( 50, 200,  50, A(210)); break; // Poison  - green
-                    default: dotCol = IM_COL32(170, 170, 170, A(170)); break; // Other   - grey
-                }
-                drawList->AddRectFilled(ImVec2(dotX,          nameplateBottom),
-                                        ImVec2(dotX + dotSize, nameplateBottom + dotSize), dotCol, 1.0f);
-                drawList->AddRect      (ImVec2(dotX - 1.0f,          nameplateBottom - 1.0f),
-                                        ImVec2(dotX + dotSize + 1.0f, nameplateBottom + dotSize + 1.0f),
-                                        IM_COL32(0, 0, 0, A(150)), 1.0f);
-
-                // Duration clock-sweep overlay (like target frame auras)
-                uint64_t nowMs = static_cast<uint64_t>(
-                    std::chrono::duration_cast<std::chrono::milliseconds>(
-                        std::chrono::steady_clock::now().time_since_epoch()).count());
-                int32_t remainMs = aura.getRemainingMs(nowMs);
-                if (aura.maxDurationMs > 0 && remainMs > 0) {
-                    float pct = 1.0f - static_cast<float>(remainMs) / static_cast<float>(aura.maxDurationMs);
-                    pct = std::clamp(pct, 0.0f, 1.0f);
-                    float cx = dotX + dotSize * 0.5f;
-                    float cy = nameplateBottom + dotSize * 0.5f;
-                    float r  = dotSize * 0.5f;
-                    float startAngle = -IM_PI * 0.5f;
-                    float endAngle   = startAngle + pct * IM_PI * 2.0f;
-                    ImVec2 center(cx, cy);
-                    const int segments = 12;
-                    for (int seg = 0; seg < segments; seg++) {
-                        float a0 = startAngle + (endAngle - startAngle) * seg / segments;
-                        float a1 = startAngle + (endAngle - startAngle) * (seg + 1) / segments;
-                        drawList->AddTriangleFilled(
-                            center,
-                            ImVec2(cx + r * std::cos(a0), cy + r * std::sin(a0)),
-                            ImVec2(cx + r * std::cos(a1), cy + r * std::sin(a1)),
-                            IM_COL32(0, 0, 0, A(100)));
-                    }
-                }
-
-                // Stack count on dot (upper-left corner)
-                if (aura.charges > 1) {
-                    char stackBuf[8];
-                    snprintf(stackBuf, sizeof(stackBuf), "%d", aura.charges);
-                    drawList->AddText(ImVec2(dotX + 1.0f, nameplateBottom), IM_COL32(0, 0, 0, A(200)), stackBuf);
-                    drawList->AddText(ImVec2(dotX,         nameplateBottom - 1.0f), IM_COL32(255, 255, 255, A(240)), stackBuf);
-                }
-
-                // Duration text below dot
-                if (remainMs > 0) {
-                    char durBuf[8];
-                    if (remainMs >= 60000)
-                        snprintf(durBuf, sizeof(durBuf), "%dm", remainMs / 60000);
-                    else
-                        snprintf(durBuf, sizeof(durBuf), "%d", remainMs / 1000);
-                    ImVec2 durSz = ImGui::CalcTextSize(durBuf);
-                    float durX = dotX + (dotSize - durSz.x) * 0.5f;
-                    float durY = nameplateBottom + dotSize + 1.0f;
-                    drawList->AddText(ImVec2(durX + 1.0f, durY + 1.0f), IM_COL32(0, 0, 0, A(180)), durBuf);
-                    // Color: red if < 5s, yellow if < 15s, white otherwise
-                    ImU32 durCol = remainMs < 5000 ? IM_COL32(255, 60, 60, A(240))
-                                 : remainMs < 15000 ? IM_COL32(255, 200, 60, A(240))
-                                 : IM_COL32(230, 230, 230, A(220));
-                    drawList->AddText(ImVec2(durX, durY), durCol, durBuf);
-                }
-
-                // Spell name + duration tooltip on hover
-                {
-                    ImVec2 mouse = ImGui::GetMousePos();
-                    if (mouse.x >= dotX && mouse.x < dotX + dotSize &&
-                        mouse.y >= nameplateBottom && mouse.y < nameplateBottom + dotSize) {
-                        const std::string& dotSpellName = gameHandler.getSpellName(aura.spellId);
-                        if (!dotSpellName.empty()) {
-                            if (remainMs > 0) {
-                                int secs = remainMs / 1000;
-                                int mins = secs / 60;
-                                secs %= 60;
-                                char tipBuf[128];
-                                if (mins > 0)
-                                    snprintf(tipBuf, sizeof(tipBuf), "%s (%dm %ds)", dotSpellName.c_str(), mins, secs);
-                                else
-                                    snprintf(tipBuf, sizeof(tipBuf), "%s (%ds)", dotSpellName.c_str(), secs);
-                                ImGui::SetTooltip("%s", tipBuf);
-                            } else {
-                                ImGui::SetTooltip("%s", dotSpellName.c_str());
-                            }
-                        }
-                    }
-                }
-
-                dotX += dotSize + dotGap;
-                if (dotX + dotSize > barX + barW) break;
-            }
-        }
-
         // Name + level label above health bar
         uint32_t level = unit->getLevel();
-        const std::string& unitName = unit->getName();
         char labelBuf[96];
-        if (isPlayer) {
-            // Player nameplates: show name only (no level clutter).
-            // Fall back to level as placeholder while the name query is pending.
-            if (!unitName.empty())
-                snprintf(labelBuf, sizeof(labelBuf), "%s", unitName.c_str());
-            else {
-                // Name query may be pending; request it now to ensure it gets resolved
-                gameHandler.queryPlayerName(unit->getGuid());
-                if (level > 0)
-                    snprintf(labelBuf, sizeof(labelBuf), "Player (%u)", level);
-                else
-                    snprintf(labelBuf, sizeof(labelBuf), "Player");
-            }
-        } else if (level > 0) {
+        if (level > 0) {
             uint32_t playerLevel = gameHandler.getPlayerLevel();
             // Show skull for units more than 10 levels above the player
             if (playerLevel > 0 && level > playerLevel + 10)
-                snprintf(labelBuf, sizeof(labelBuf), "?? %s", unitName.c_str());
+                snprintf(labelBuf, sizeof(labelBuf), "?? %s", unit->getName().c_str());
             else
-                snprintf(labelBuf, sizeof(labelBuf), "%u %s", level, unitName.c_str());
+                snprintf(labelBuf, sizeof(labelBuf), "%u %s", level, unit->getName().c_str());
         } else {
-            snprintf(labelBuf, sizeof(labelBuf), "%s", unitName.c_str());
+            snprintf(labelBuf, sizeof(labelBuf), "%s", unit->getName().c_str());
         }
         ImVec2 textSize = ImGui::CalcTextSize(labelBuf);
         float nameX = sx - textSize.x * 0.5f;
         float nameY = sy - barH - 12.0f;
-        // Name color: players get WoW class colors; NPCs use hostility (red/yellow)
-        ImU32 nameColor;
-        if (isPlayer) {
-            // Class color with cyan fallback for unknown class
-            uint8_t cid = entityClassId(unit);
-            ImVec4 cc = (cid != 0) ? classColorVec4(cid) : ImVec4(0.31f, 0.78f, 1.0f, 1.0f);
-            nameColor = IM_COL32(static_cast<int>(cc.x*255), static_cast<int>(cc.y*255),
-                                  static_cast<int>(cc.z*255), A(230));
-        } else {
-            nameColor = unit->isHostile()
-                ? IM_COL32(220,  80,  80, A(230))   // red  — hostile NPC
-                : IM_COL32(240, 200, 100, A(230));  // yellow — friendly NPC
-        }
-        // Sub-label below the name: guild tag for players, subtitle for NPCs
-        std::string subLabel;
-        if (isPlayer) {
-            uint32_t guildId = gameHandler.getEntityGuildId(guid);
-            if (guildId != 0) {
-                const std::string& gn = gameHandler.lookupGuildName(guildId);
-                if (!gn.empty()) subLabel = "<" + gn + ">";
-            }
-        } else {
-            // NPC subtitle (e.g. "<Reagent Vendor>", "<Innkeeper>")
-            std::string sub = gameHandler.getCachedCreatureSubName(unit->getEntry());
-            if (!sub.empty()) subLabel = "<" + sub + ">";
-        }
-        if (!subLabel.empty()) nameY -= 10.0f;  // shift name up for sub-label line
-
+        // Name color: hostile=red, non-hostile=yellow (WoW convention)
+        ImU32 nameColor = unit->isHostile()
+            ? IM_COL32(220, 80,  80,  A(230))
+            : IM_COL32(240, 200, 100, A(230));
         drawList->AddText(ImVec2(nameX + 1.0f, nameY + 1.0f), IM_COL32(0, 0, 0, A(160)), labelBuf);
         drawList->AddText(ImVec2(nameX,         nameY),         nameColor, labelBuf);
-
-        // Sub-label below the name (WoW-style <Guild Name> or <NPC Title> in lighter color)
-        if (!subLabel.empty()) {
-            ImVec2 subSz = ImGui::CalcTextSize(subLabel.c_str());
-            float subX = sx - subSz.x * 0.5f;
-            float subY = nameY + textSize.y + 1.0f;
-            drawList->AddText(ImVec2(subX + 1.0f, subY + 1.0f), IM_COL32(0, 0, 0, A(120)), subLabel.c_str());
-            drawList->AddText(ImVec2(subX,         subY),         IM_COL32(180, 180, 180, A(200)), subLabel.c_str());
-        }
-
-        // Group leader crown to the right of the name on player nameplates
-        if (isPlayer && gameHandler.isInGroup() &&
-            gameHandler.getPartyData().leaderGuid == guid) {
-            float crownX = nameX + textSize.x + 3.0f;
-            const char* crownSym = "\xe2\x99\x9b";  // ♛
-            drawList->AddText(ImVec2(crownX + 1.0f, nameY + 1.0f), IM_COL32(0, 0, 0, A(160)), crownSym);
-            drawList->AddText(ImVec2(crownX,         nameY),         IM_COL32(255, 215, 0, A(240)), crownSym);
-        }
-
-        // Raid mark (if any) to the left of the name
-        {
-            static constexpr struct { const char* sym; ImU32 col; } kNPMarks[] = {
-                { "\xe2\x98\x85", IM_COL32(255,220, 50,230) },  // Star
-                { "\xe2\x97\x8f", IM_COL32(255,140,  0,230) },  // Circle
-                { "\xe2\x97\x86", IM_COL32(160, 32,240,230) },  // Diamond
-                { "\xe2\x96\xb2", IM_COL32( 50,200, 50,230) },  // Triangle
-                { "\xe2\x97\x8c", IM_COL32( 80,160,255,230) },  // Moon
-                { "\xe2\x96\xa0", IM_COL32( 50,200,220,230) },  // Square
-                { "\xe2\x9c\x9d", IM_COL32(255, 80, 80,230) },  // Cross
-                { "\xe2\x98\xa0", IM_COL32(255,255,255,230) },  // Skull
-            };
-            uint8_t raidMark = gameHandler.getEntityRaidMark(guid);
-            if (raidMark < game::GameHandler::kRaidMarkCount) {
-                float markX = nameX - 14.0f;
-                drawList->AddText(ImVec2(markX + 1.0f, nameY + 1.0f), IM_COL32(0,0,0,120), kNPMarks[raidMark].sym);
-                drawList->AddText(ImVec2(markX,         nameY),        kNPMarks[raidMark].col, kNPMarks[raidMark].sym);
-            }
-
-            // Quest kill objective indicator: small yellow sword icon to the right of the name
-            float questIconX = nameX + textSize.x + 4.0f;
-            if (!isPlayer && questKillEntries.count(unit->getEntry())) {
-                const char* objSym = "\xe2\x9a\x94";  // ⚔ crossed swords (UTF-8)
-                drawList->AddText(ImVec2(questIconX + 1.0f, nameY + 1.0f), IM_COL32(0, 0, 0, A(160)), objSym);
-                drawList->AddText(ImVec2(questIconX,         nameY),         IM_COL32(255, 220, 0, A(230)), objSym);
-                questIconX += ImGui::CalcTextSize("\xe2\x9a\x94").x + 2.0f;
-            }
-
-            // Quest giver indicator: "!" for available quests, "?" for completable/incomplete
-            if (!isPlayer) {
-                using QGS = game::QuestGiverStatus;
-                QGS qgs = gameHandler.getQuestGiverStatus(guid);
-                const char* qSym = nullptr;
-                ImU32 qCol = IM_COL32(255, 210, 0, A(255));
-                if (qgs == QGS::AVAILABLE) {
-                    qSym = "!";
-                } else if (qgs == QGS::AVAILABLE_LOW) {
-                    qSym = "!";
-                    qCol = IM_COL32(160, 160, 160, A(220));
-                } else if (qgs == QGS::REWARD || qgs == QGS::REWARD_REP) {
-                    qSym = "?";
-                } else if (qgs == QGS::INCOMPLETE) {
-                    qSym = "?";
-                    qCol = IM_COL32(160, 160, 160, A(220));
-                }
-                if (qSym) {
-                    drawList->AddText(ImVec2(questIconX + 1.0f, nameY + 1.0f), IM_COL32(0, 0, 0, A(160)), qSym);
-                    drawList->AddText(ImVec2(questIconX,         nameY),         qCol, qSym);
-                }
-            }
-        }
-
-        // Click to target / right-click context: detect clicks inside the nameplate region.
-        // Use the wider of name text or health bar for the horizontal hit area so short
-        // names like "Wolf" don't produce a tiny clickable strip narrower than the bar.
-        if (!ImGui::GetIO().WantCaptureMouse) {
-            ImVec2 mouse = ImGui::GetIO().MousePos;
-            float hitLeft  = std::min(nameX, barX) - 2.0f;
-            float hitRight = std::max(nameX + textSize.x, barX + barW) + 2.0f;
-            float ny0 = nameY - 1.0f;
-            float ny1 = sy + barH + 2.0f;
-            float nx0 = hitLeft;
-            float nx1 = hitRight;
-            if (mouse.x >= nx0 && mouse.x <= nx1 && mouse.y >= ny0 && mouse.y <= ny1) {
-                // Track mouseover for [target=mouseover] macro conditionals
-                gameHandler.setMouseoverGuid(guid);
-                // Hover tooltip: name, level/class, guild
-                ImGui::BeginTooltip();
-                ImGui::TextUnformatted(unitName.c_str());
-                if (isPlayer) {
-                    uint8_t cid = entityClassId(unit);
-                    ImGui::Text("Level %u %s", level, classNameStr(cid));
-                } else if (level > 0) {
-                    ImGui::Text("Level %u", level);
-                }
-                if (!subLabel.empty()) ImGui::TextColored(ImVec4(0.7f,0.7f,0.7f,1.0f), "%s", subLabel.c_str());
-                ImGui::EndTooltip();
-                if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
-                    gameHandler.setTarget(guid);
-                } else if (ImGui::IsMouseClicked(ImGuiMouseButton_Right)) {
-                    nameplateCtxGuid_ = guid;
-                    nameplateCtxPos_  = mouse;
-                    ImGui::OpenPopup("##NameplateCtx");
-                }
-            }
-        }
-    }
-
-    // Render nameplate context popup (uses a tiny overlay window as host)
-    if (nameplateCtxGuid_ != 0) {
-        ImGui::SetNextWindowPos(nameplateCtxPos_, ImGuiCond_Appearing);
-        ImGui::SetNextWindowSize(ImVec2(0, 0), ImGuiCond_Always);
-        ImGuiWindowFlags ctxHostFlags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
-                                         ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar |
-                                         ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoFocusOnAppearing |
-                                         ImGuiWindowFlags_AlwaysAutoResize;
-        if (ImGui::Begin("##NameplateCtxHost", nullptr, ctxHostFlags)) {
-            if (ImGui::BeginPopup("##NameplateCtx")) {
-                auto entityPtr = gameHandler.getEntityManager().getEntity(nameplateCtxGuid_);
-                std::string ctxName = entityPtr ? getEntityName(entityPtr) : "";
-                if (!ctxName.empty()) {
-                    ImGui::TextDisabled("%s", ctxName.c_str());
-                    ImGui::Separator();
-                }
-                if (ImGui::MenuItem("Target"))
-                    gameHandler.setTarget(nameplateCtxGuid_);
-                if (ImGui::MenuItem("Set Focus"))
-                    gameHandler.setFocus(nameplateCtxGuid_);
-                bool isPlayer = entityPtr && entityPtr->getType() == game::ObjectType::PLAYER;
-                if (isPlayer && !ctxName.empty()) {
-                    ImGui::Separator();
-                    if (ImGui::MenuItem("Whisper")) {
-                        chatPanel_.setWhisperTarget(ctxName);
-                    }
-                    if (ImGui::MenuItem("Invite to Group"))
-                        gameHandler.inviteToGroup(ctxName);
-                    if (ImGui::MenuItem("Trade"))
-                        gameHandler.initiateTrade(nameplateCtxGuid_);
-                    if (ImGui::MenuItem("Duel"))
-                        gameHandler.proposeDuel(nameplateCtxGuid_);
-                    if (ImGui::MenuItem("Inspect")) {
-                        gameHandler.setTarget(nameplateCtxGuid_);
-                        gameHandler.inspectTarget();
-                        socialPanel_.showInspectWindow_ = true;
-                    }
-                    ImGui::Separator();
-                    if (ImGui::MenuItem("Add Friend"))
-                        gameHandler.addFriend(ctxName);
-                    if (ImGui::MenuItem("Ignore"))
-                        gameHandler.addIgnore(ctxName);
-                }
-                ImGui::EndPopup();
-            } else {
-                nameplateCtxGuid_ = 0;
-            }
-        }
-        ImGui::End();
     }
 }
 
 // ============================================================
-// Durability Warning (equipment damage indicator)
+// Party Frames (Phase 4)
 // ============================================================
 
-void GameScreen::takeScreenshot(game::GameHandler& /*gameHandler*/) {
-    auto* renderer = services_.renderer;
-    if (!renderer) return;
+void GameScreen::renderPartyFrames(game::GameHandler& gameHandler) {
+    if (!gameHandler.isInGroup()) return;
 
-    // Build path: ~/.wowee/screenshots/WoWee_YYYYMMDD_HHMMSS.png
-    const char* home = std::getenv("HOME");
-    if (!home) home = std::getenv("USERPROFILE");
-    if (!home) home = "/tmp";
-    std::string dir = std::string(home) + "/.wowee/screenshots";
+    const auto& partyData = gameHandler.getPartyData();
+    float frameY = 120.0f;
 
-    auto now = std::chrono::system_clock::now();
-    auto tt  = std::chrono::system_clock::to_time_t(now);
-    std::tm tm{};
-#ifdef _WIN32
-    localtime_s(&tm, &tt);
-#else
-    localtime_r(&tt, &tm);
-#endif
+    ImGui::SetNextWindowPos(ImVec2(10.0f, frameY), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(200.0f, 0.0f), ImGuiCond_Always);
 
-    char filename[128];
-    std::snprintf(filename, sizeof(filename),
-                  "WoWee_%04d%02d%02d_%02d%02d%02d.png",
-                  tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
-                  tm.tm_hour, tm.tm_min, tm.tm_sec);
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
+                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
+                             ImGuiWindowFlags_AlwaysAutoResize;
 
-    std::string path = dir + "/" + filename;
-
-    if (renderer->captureScreenshot(path)) {
-        game::MessageChatData sysMsg;
-        sysMsg.type = game::ChatType::SYSTEM;
-        sysMsg.language = game::ChatLanguage::UNIVERSAL;
-        sysMsg.message = "Screenshot saved: " + path;
-        services_.gameHandler->addLocalChatMessage(sysMsg);
-    }
-}
-
-void GameScreen::renderDurabilityWarning(game::GameHandler& gameHandler) {
-    if (gameHandler.getPlayerGuid() == 0) return;
-
-    const auto& inv = gameHandler.getInventory();
-
-    // Scan all equipment slots (skip bag slots which have no durability)
-    float minDurPct = 1.0f;
-    bool hasBroken = false;
-
-    for (int i = static_cast<int>(game::EquipSlot::HEAD);
-             i < static_cast<int>(game::EquipSlot::BAG1); ++i) {
-        const auto& slot = inv.getEquipSlot(static_cast<game::EquipSlot>(i));
-        if (slot.empty() || slot.item.maxDurability == 0) continue;
-        if (slot.item.curDurability == 0) {
-            hasBroken = true;
-        }
-        float pct = static_cast<float>(slot.item.curDurability) /
-                    static_cast<float>(slot.item.maxDurability);
-        if (pct < minDurPct) minDurPct = pct;
-    }
-
-    // Only show warning below 20%
-    if (minDurPct >= 0.2f && !hasBroken) return;
-
-    ImGuiIO& io = ImGui::GetIO();
-    const float screenW = io.DisplaySize.x;
-    const float screenH = io.DisplaySize.y;
-
-    // Position: just above the XP bar / action bar area (bottom-center)
-    const float warningW = 220.0f;
-    const float warningH = 26.0f;
-    const float posX = (screenW - warningW) * 0.5f;
-    const float posY = screenH - 140.0f;  // above action bar
-
-    ImGui::SetNextWindowPos(ImVec2(posX, posY), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(warningW, warningH), ImGuiCond_Always);
-    ImGui::SetNextWindowBgAlpha(0.75f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(6, 4));
     ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowMinSize, ImVec2(0, 0));
+    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.1f, 0.1f, 0.1f, 0.8f));
 
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
-                             ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoInputs |
-                             ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings |
-                             ImGuiWindowFlags_NoBringToFrontOnFocus;
+    if (ImGui::Begin("##PartyFrames", nullptr, flags)) {
+        for (const auto& member : partyData.members) {
+            ImGui::PushID(static_cast<int>(member.guid));
 
-    if (ImGui::Begin("##durability_warn", nullptr, flags)) {
-        if (hasBroken) {
-            ImGui::TextColored(ImVec4(1.0f, 0.15f, 0.15f, 1.0f),
-                               "\xef\x94\x9b Gear broken! Visit a repair NPC");
-        } else {
-            int pctInt = static_cast<int>(minDurPct * 100.0f);
-            ImGui::TextColored(colors::kSymbolGold,
-                               "\xef\x94\x9b Low durability: %d%%", pctInt);
+            // Name with level and status info
+            std::string label = member.name;
+            if (member.hasPartyStats && member.level > 0) {
+                label += " [" + std::to_string(member.level) + "]";
+            }
+            if (member.hasPartyStats) {
+                bool isOnline = (member.onlineStatus & 0x0001) != 0;
+                bool isDead = (member.onlineStatus & 0x0020) != 0;
+                bool isGhost = (member.onlineStatus & 0x0010) != 0;
+                if (!isOnline) label += " (offline)";
+                else if (isDead || isGhost) label += " (dead)";
+            }
+
+            // Clickable name to target
+            if (ImGui::Selectable(label.c_str(), gameHandler.getTargetGuid() == member.guid)) {
+                gameHandler.setTarget(member.guid);
+            }
+
+            // Health bar: prefer party stats, fall back to entity
+            uint32_t hp = 0, maxHp = 0;
+            if (member.hasPartyStats && member.maxHealth > 0) {
+                hp = member.curHealth;
+                maxHp = member.maxHealth;
+            } else {
+                auto entity = gameHandler.getEntityManager().getEntity(member.guid);
+                if (entity && (entity->getType() == game::ObjectType::PLAYER || entity->getType() == game::ObjectType::UNIT)) {
+                    auto unit = std::static_pointer_cast<game::Unit>(entity);
+                    hp = unit->getHealth();
+                    maxHp = unit->getMaxHealth();
+                }
+            }
+            if (maxHp > 0) {
+                float pct = static_cast<float>(hp) / static_cast<float>(maxHp);
+                ImGui::PushStyleColor(ImGuiCol_PlotHistogram,
+                    pct > 0.5f ? ImVec4(0.2f, 0.8f, 0.2f, 1.0f) :
+                    pct > 0.2f ? ImVec4(0.8f, 0.8f, 0.2f, 1.0f) :
+                                 ImVec4(0.8f, 0.2f, 0.2f, 1.0f));
+                ImGui::ProgressBar(pct, ImVec2(-1, 12), "");
+                ImGui::PopStyleColor();
+            }
+
+            // Power bar (mana/rage/energy) from party stats
+            if (member.hasPartyStats && member.maxPower > 0) {
+                float powerPct = static_cast<float>(member.curPower) / static_cast<float>(member.maxPower);
+                ImVec4 powerColor;
+                switch (member.powerType) {
+                    case 0: powerColor = ImVec4(0.2f, 0.2f, 0.9f, 1.0f); break; // Mana (blue)
+                    case 1: powerColor = ImVec4(0.9f, 0.2f, 0.2f, 1.0f); break; // Rage (red)
+                    case 2: powerColor = ImVec4(0.9f, 0.6f, 0.1f, 1.0f); break; // Focus (orange)
+                    case 3: powerColor = ImVec4(0.9f, 0.9f, 0.2f, 1.0f); break; // Energy (yellow)
+                    case 4: powerColor = ImVec4(0.5f, 0.9f, 0.3f, 1.0f); break; // Happiness (green)
+                    case 6: powerColor = ImVec4(0.8f, 0.1f, 0.2f, 1.0f); break; // Runic Power (crimson)
+                    case 7: powerColor = ImVec4(0.4f, 0.1f, 0.6f, 1.0f); break; // Soul Shards (purple)
+                    default: powerColor = ImVec4(0.5f, 0.5f, 0.5f, 1.0f); break;
+                }
+                ImGui::PushStyleColor(ImGuiCol_PlotHistogram, powerColor);
+                ImGui::ProgressBar(powerPct, ImVec2(-1, 8), "");
+                ImGui::PopStyleColor();
+            }
+
+            ImGui::Separator();
+            ImGui::PopID();
         }
-        if (ImGui::IsWindowHovered())
-            ImGui::SetTooltip("Your equipment is damaged. Visit any blacksmith or repair NPC.");
     }
     ImGui::End();
-    ImGui::PopStyleVar(3);
+
+    ImGui::PopStyleColor();
+    ImGui::PopStyleVar();
 }
 
 // ============================================================
-// UI Error Frame (WoW-style center-bottom error overlay)
+// Boss Encounter Frames
 // ============================================================
 
-void GameScreen::renderUIErrors(game::GameHandler& /*gameHandler*/, float deltaTime) {
-    // Age out old entries
-    for (auto& e : uiErrors_) e.age += deltaTime;
-    uiErrors_.erase(
-        std::remove_if(uiErrors_.begin(), uiErrors_.end(),
-            [](const UIErrorEntry& e) { return e.age >= kUIErrorLifetime; }),
-        uiErrors_.end());
+void GameScreen::renderBossFrames(game::GameHandler& gameHandler) {
+    // Collect active boss unit slots
+    struct BossSlot { uint32_t slot; uint64_t guid; };
+    std::vector<BossSlot> active;
+    for (uint32_t s = 0; s < game::GameHandler::kMaxEncounterSlots; ++s) {
+        uint64_t g = gameHandler.getEncounterUnitGuid(s);
+        if (g != 0) active.push_back({s, g});
+    }
+    if (active.empty()) return;
 
-    if (uiErrors_.empty()) return;
+    const float frameW = 200.0f;
+    const float startX = ImGui::GetIO().DisplaySize.x - frameW - 10.0f;
+    float frameY = 120.0f;
 
-    auto* window = services_.window;
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
+                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
+                             ImGuiWindowFlags_AlwaysAutoResize;
+
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
+    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.15f, 0.05f, 0.05f, 0.85f));
+
+    ImGui::SetNextWindowPos(ImVec2(startX, frameY), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(frameW, 0.0f), ImGuiCond_Always);
+
+    if (ImGui::Begin("##BossFrames", nullptr, flags)) {
+        for (const auto& bs : active) {
+            ImGui::PushID(static_cast<int>(bs.guid));
+
+            // Try to resolve name and health from entity manager
+            std::string name = "Boss";
+            uint32_t hp = 0, maxHp = 0;
+            auto entity = gameHandler.getEntityManager().getEntity(bs.guid);
+            if (entity && (entity->getType() == game::ObjectType::UNIT ||
+                           entity->getType() == game::ObjectType::PLAYER)) {
+                auto unit = std::static_pointer_cast<game::Unit>(entity);
+                const auto& n = unit->getName();
+                if (!n.empty()) name = n;
+                hp    = unit->getHealth();
+                maxHp = unit->getMaxHealth();
+            }
+
+            // Clickable name to target
+            if (ImGui::Selectable(name.c_str(), gameHandler.getTargetGuid() == bs.guid)) {
+                gameHandler.setTarget(bs.guid);
+            }
+
+            if (maxHp > 0) {
+                float pct = static_cast<float>(hp) / static_cast<float>(maxHp);
+                // Boss health bar in red shades
+                ImGui::PushStyleColor(ImGuiCol_PlotHistogram,
+                    pct > 0.5f ? ImVec4(0.8f, 0.2f, 0.2f, 1.0f) :
+                    pct > 0.2f ? ImVec4(0.9f, 0.5f, 0.1f, 1.0f) :
+                                 ImVec4(1.0f, 0.8f, 0.1f, 1.0f));
+                char label[32];
+                std::snprintf(label, sizeof(label), "%u / %u", hp, maxHp);
+                ImGui::ProgressBar(pct, ImVec2(-1, 14), label);
+                ImGui::PopStyleColor();
+            }
+
+            ImGui::PopID();
+            ImGui::Spacing();
+        }
+    }
+    ImGui::End();
+
+    ImGui::PopStyleColor();
+    ImGui::PopStyleVar();
+}
+
+// ============================================================
+// Group Invite Popup (Phase 4)
+// ============================================================
+
+void GameScreen::renderGroupInvitePopup(game::GameHandler& gameHandler) {
+    if (!gameHandler.hasPendingGroupInvite()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 150, 200), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(300, 0), ImGuiCond_Always);
+
+    if (ImGui::Begin("Group Invite", nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize)) {
+        ImGui::Text("%s has invited you to a group.", gameHandler.getPendingInviterName().c_str());
+        ImGui::Spacing();
+
+        if (ImGui::Button("Accept", ImVec2(130, 30))) {
+            gameHandler.acceptGroupInvite();
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Decline", ImVec2(130, 30))) {
+            gameHandler.declineGroupInvite();
+        }
+    }
+    ImGui::End();
+}
+
+void GameScreen::renderDuelRequestPopup(game::GameHandler& gameHandler) {
+    if (!gameHandler.hasPendingDuelRequest()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 150, 250), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(300, 0), ImGuiCond_Always);
+
+    if (ImGui::Begin("Duel Request", nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize)) {
+        ImGui::Text("%s challenges you to a duel!", gameHandler.getDuelChallengerName().c_str());
+        ImGui::Spacing();
+
+        if (ImGui::Button("Accept", ImVec2(130, 30))) {
+            gameHandler.acceptDuel();
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Decline", ImVec2(130, 30))) {
+            gameHandler.forfeitDuel();
+        }
+    }
+    ImGui::End();
+}
+
+void GameScreen::renderItemTextWindow(game::GameHandler& gameHandler) {
+    if (!gameHandler.isItemTextOpen()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
     float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
     float screenH = window ? static_cast<float>(window->getHeight()) :  720.0f;
 
-    // Fixed invisible overlay
-    ImGui::SetNextWindowPos(ImVec2(0, 0));
-    ImGui::SetNextWindowSize(ImVec2(screenW, screenH));
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoDecoration |
-                             ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoNav |
-                             ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar;
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
-    if (ImGui::Begin("##UIErrors", nullptr, flags)) {
-        // Render messages stacked above the action bar (~200px from bottom)
-        // The newest message is on top; older ones fade below it.
-        const float baseY = screenH - 200.0f;
-        const float lineH = 20.0f;
-        const int   count = static_cast<int>(uiErrors_.size());
+    ImGui::SetNextWindowPos(ImVec2(screenW * 0.5f - 200, screenH * 0.15f),
+                            ImGuiCond_FirstUseEver);
+    ImGui::SetNextWindowSize(ImVec2(400, 300), ImGuiCond_FirstUseEver);
 
-        ImDrawList* draw = ImGui::GetWindowDrawList();
-        for (int i = count - 1; i >= 0; --i) {
-            const auto& e = uiErrors_[i];
-            float alpha = 1.0f - (e.age / kUIErrorLifetime);
-            alpha = std::max(0.0f, std::min(1.0f, alpha));
+    bool open = true;
+    if (!ImGui::Begin("Book", &open, ImGuiWindowFlags_NoCollapse)) {
+        ImGui::End();
+        if (!open) gameHandler.closeItemText();
+        return;
+    }
+    if (!open) {
+        ImGui::End();
+        gameHandler.closeItemText();
+        return;
+    }
 
-            // Fade fast in the last 0.5 s
-            if (e.age > kUIErrorLifetime - 0.5f)
-                alpha *= (kUIErrorLifetime - e.age) / 0.5f;
+    // Parchment-toned background text
+    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.2f, 0.1f, 0.0f, 1.0f));
+    ImGui::TextWrapped("%s", gameHandler.getItemText().c_str());
+    ImGui::PopStyleColor();
 
-            uint8_t a8 = static_cast<uint8_t>(alpha * 255.0f);
-            ImU32 textCol  = IM_COL32(255, 50,  50, a8);
-            ImU32 shadowCol= IM_COL32(  0,  0,   0, static_cast<uint8_t>(alpha * 180));
+    ImGui::Spacing();
+    if (ImGui::Button("Close", ImVec2(80, 0))) {
+        gameHandler.closeItemText();
+    }
 
-            const char* txt = e.text.c_str();
-            ImVec2 sz = ImGui::CalcTextSize(txt);
-            float x = std::round((screenW - sz.x) * 0.5f);
-            float y = std::round(baseY - (count - 1 - i) * lineH);
+    ImGui::End();
+}
 
-            // Drop shadow
-            draw->AddText(ImVec2(x + 1, y + 1), shadowCol, txt);
-            draw->AddText(ImVec2(x, y), textCol, txt);
+void GameScreen::renderSharedQuestPopup(game::GameHandler& gameHandler) {
+    if (!gameHandler.hasPendingSharedQuest()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 175, 490), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(350, 0), ImGuiCond_Always);
+
+    if (ImGui::Begin("Shared Quest", nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize)) {
+        ImGui::Text("%s has shared a quest with you:", gameHandler.getSharedQuestSharerName().c_str());
+        ImGui::TextColored(ImVec4(1.0f, 0.85f, 0.0f, 1.0f), "\"%s\"", gameHandler.getSharedQuestTitle().c_str());
+        ImGui::Spacing();
+
+        if (ImGui::Button("Accept", ImVec2(130, 30))) {
+            gameHandler.acceptSharedQuest();
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Decline", ImVec2(130, 30))) {
+            gameHandler.declineSharedQuest();
         }
     }
     ImGui::End();
+}
+
+void GameScreen::renderSummonRequestPopup(game::GameHandler& gameHandler) {
+    if (!gameHandler.hasPendingSummonRequest()) return;
+
+    // Tick the timeout down
+    float dt = ImGui::GetIO().DeltaTime;
+    gameHandler.tickSummonTimeout(dt);
+    if (!gameHandler.hasPendingSummonRequest()) return;  // expired
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 175, 430), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(350, 0), ImGuiCond_Always);
+
+    if (ImGui::Begin("Summon Request", nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize)) {
+        ImGui::Text("%s is summoning you.", gameHandler.getSummonerName().c_str());
+        float t = gameHandler.getSummonTimeoutSec();
+        if (t > 0.0f) {
+            ImGui::Text("Time remaining: %.0fs", t);
+        }
+        ImGui::Spacing();
+
+        if (ImGui::Button("Accept", ImVec2(130, 30))) {
+            gameHandler.acceptSummon();
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Decline", ImVec2(130, 30))) {
+            gameHandler.declineSummon();
+        }
+    }
+    ImGui::End();
+}
+
+void GameScreen::renderTradeRequestPopup(game::GameHandler& gameHandler) {
+    if (!gameHandler.hasPendingTradeRequest()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 150, 370), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(300, 0), ImGuiCond_Always);
+
+    if (ImGui::Begin("Trade Request", nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize)) {
+        ImGui::Text("%s wants to trade with you.", gameHandler.getTradePeerName().c_str());
+        ImGui::Spacing();
+
+        if (ImGui::Button("Accept", ImVec2(130, 30))) {
+            gameHandler.acceptTradeRequest();
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Decline", ImVec2(130, 30))) {
+            gameHandler.declineTradeRequest();
+        }
+    }
+    ImGui::End();
+}
+
+void GameScreen::renderLootRollPopup(game::GameHandler& gameHandler) {
+    if (!gameHandler.hasPendingLootRoll()) return;
+
+    const auto& roll = gameHandler.getPendingLootRoll();
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 175, 310), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(350, 0), ImGuiCond_Always);
+
+    if (ImGui::Begin("Loot Roll", nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize)) {
+        // Quality color for item name
+        static const ImVec4 kQualityColors[] = {
+            ImVec4(0.6f, 0.6f, 0.6f, 1.0f),  // 0=poor (grey)
+            ImVec4(1.0f, 1.0f, 1.0f, 1.0f),  // 1=common (white)
+            ImVec4(0.1f, 1.0f, 0.1f, 1.0f),  // 2=uncommon (green)
+            ImVec4(0.0f, 0.44f, 0.87f, 1.0f),// 3=rare (blue)
+            ImVec4(0.64f, 0.21f, 0.93f, 1.0f),// 4=epic (purple)
+            ImVec4(1.0f, 0.5f, 0.0f, 1.0f),  // 5=legendary (orange)
+        };
+        uint8_t q = roll.itemQuality;
+        ImVec4 col = (q < 6) ? kQualityColors[q] : kQualityColors[1];
+
+        ImGui::Text("An item is up for rolls:");
+        ImGui::TextColored(col, "[%s]", roll.itemName.c_str());
+        ImGui::Spacing();
+
+        if (ImGui::Button("Need", ImVec2(80, 30))) {
+            gameHandler.sendLootRoll(roll.objectGuid, roll.slot, 0);
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Greed", ImVec2(80, 30))) {
+            gameHandler.sendLootRoll(roll.objectGuid, roll.slot, 1);
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Disenchant", ImVec2(95, 30))) {
+            gameHandler.sendLootRoll(roll.objectGuid, roll.slot, 2);
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Pass", ImVec2(70, 30))) {
+            gameHandler.sendLootRoll(roll.objectGuid, roll.slot, 96);
+        }
+    }
+    ImGui::End();
+}
+
+void GameScreen::renderGuildInvitePopup(game::GameHandler& gameHandler) {
+    if (!gameHandler.hasPendingGuildInvite()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 175, 250), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(350, 0), ImGuiCond_Always);
+
+    if (ImGui::Begin("Guild Invite", nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize)) {
+        ImGui::TextWrapped("%s has invited you to join %s.",
+                           gameHandler.getPendingGuildInviterName().c_str(),
+                           gameHandler.getPendingGuildInviteGuildName().c_str());
+        ImGui::Spacing();
+
+        if (ImGui::Button("Accept", ImVec2(155, 30))) {
+            gameHandler.acceptGuildInvite();
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Decline", ImVec2(155, 30))) {
+            gameHandler.declineGuildInvite();
+        }
+    }
+    ImGui::End();
+}
+
+void GameScreen::renderReadyCheckPopup(game::GameHandler& gameHandler) {
+    if (!gameHandler.hasPendingReadyCheck()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 175, screenH / 2 - 60), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(350, 0), ImGuiCond_Always);
+
+    if (ImGui::Begin("Ready Check", nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize)) {
+        const std::string& initiator = gameHandler.getReadyCheckInitiator();
+        if (initiator.empty()) {
+            ImGui::Text("A ready check has been initiated!");
+        } else {
+            ImGui::TextWrapped("%s has initiated a ready check!", initiator.c_str());
+        }
+        ImGui::Spacing();
+
+        if (ImGui::Button("Ready", ImVec2(155, 30))) {
+            gameHandler.respondToReadyCheck(true);
+            gameHandler.dismissReadyCheck();
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Not Ready", ImVec2(155, 30))) {
+            gameHandler.respondToReadyCheck(false);
+            gameHandler.dismissReadyCheck();
+        }
+    }
+    ImGui::End();
+}
+
+void GameScreen::renderGuildRoster(game::GameHandler& gameHandler) {
+    // O key toggle (WoW default Social/Guild keybind)
+    if (!ImGui::GetIO().WantCaptureKeyboard && ImGui::IsKeyPressed(ImGuiKey_O)) {
+        showGuildRoster_ = !showGuildRoster_;
+        if (showGuildRoster_) {
+            if (!gameHandler.isInGuild()) {
+                gameHandler.addLocalChatMessage(game::MessageChatData{
+                    game::ChatType::SYSTEM, game::ChatLanguage::UNIVERSAL, 0, "", 0, "", "You are not in a guild.", "", 0});
+                showGuildRoster_ = false;
+                return;
+            }
+            // Re-query guild name if we have guildId but no name yet
+            if (gameHandler.getGuildName().empty()) {
+                const auto* ch = gameHandler.getActiveCharacter();
+                if (ch && ch->hasGuild()) {
+                    gameHandler.queryGuildInfo(ch->guildId);
+                }
+            }
+            gameHandler.requestGuildRoster();
+            gameHandler.requestGuildInfo();
+        }
+    }
+
+    // Petition creation dialog (shown when NPC sends SMSG_PETITION_SHOWLIST)
+    if (gameHandler.hasPetitionShowlist()) {
+        ImGui::OpenPopup("CreateGuildPetition");
+        gameHandler.clearPetitionDialog();
+    }
+    if (ImGui::BeginPopupModal("CreateGuildPetition", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
+        ImGui::Text("Create Guild Charter");
+        ImGui::Separator();
+        uint32_t cost = gameHandler.getPetitionCost();
+        uint32_t gold = cost / 10000;
+        uint32_t silver = (cost % 10000) / 100;
+        uint32_t copper = cost % 100;
+        ImGui::Text("Cost: %ug %us %uc", gold, silver, copper);
+        ImGui::Spacing();
+        ImGui::Text("Guild Name:");
+        ImGui::InputText("##petitionname", petitionNameBuffer_, sizeof(petitionNameBuffer_));
+        ImGui::Spacing();
+        if (ImGui::Button("Create", ImVec2(120, 0))) {
+            if (petitionNameBuffer_[0] != '\0') {
+                gameHandler.buyPetition(gameHandler.getPetitionNpcGuid(), petitionNameBuffer_);
+                petitionNameBuffer_[0] = '\0';
+                ImGui::CloseCurrentPopup();
+            }
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Cancel", ImVec2(120, 0))) {
+            petitionNameBuffer_[0] = '\0';
+            ImGui::CloseCurrentPopup();
+        }
+        ImGui::EndPopup();
+    }
+
+    if (!showGuildRoster_) return;
+
+    // Get zone manager for name lookup
+    game::ZoneManager* zoneManager = nullptr;
+    if (auto* renderer = core::Application::getInstance().getRenderer()) {
+        zoneManager = renderer->getZoneManager();
+    }
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 375, screenH / 2 - 250), ImGuiCond_Once);
+    ImGui::SetNextWindowSize(ImVec2(750, 500), ImGuiCond_Once);
+
+    std::string title = gameHandler.isInGuild() ? (gameHandler.getGuildName() + " - Guild") : "Guild";
+    bool open = showGuildRoster_;
+    if (ImGui::Begin(title.c_str(), &open, ImGuiWindowFlags_NoCollapse)) {
+        // Tab bar: Roster | Guild Info
+        if (ImGui::BeginTabBar("GuildTabs")) {
+            if (ImGui::BeginTabItem("Roster")) {
+                guildRosterTab_ = 0;
+                if (!gameHandler.hasGuildRoster()) {
+                    ImGui::Text("Loading roster...");
+                } else {
+                    const auto& roster = gameHandler.getGuildRoster();
+
+                    // MOTD
+                    if (!roster.motd.empty()) {
+                        ImGui::TextColored(ImVec4(0.0f, 1.0f, 0.0f, 1.0f), "MOTD: %s", roster.motd.c_str());
+                        ImGui::Separator();
+                    }
+
+                    // Count online
+                    int onlineCount = 0;
+                    for (const auto& m : roster.members) {
+                        if (m.online) ++onlineCount;
+                    }
+                    ImGui::Text("%d members (%d online)", (int)roster.members.size(), onlineCount);
+                    ImGui::Separator();
+
+                    const auto& rankNames = gameHandler.getGuildRankNames();
+
+                    // Table
+                    if (ImGui::BeginTable("GuildRoster", 7,
+                            ImGuiTableFlags_ScrollY | ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersInnerV |
+                            ImGuiTableFlags_Sortable)) {
+                        ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_DefaultSort);
+                        ImGui::TableSetupColumn("Rank");
+                        ImGui::TableSetupColumn("Level", ImGuiTableColumnFlags_WidthFixed, 40.0f);
+                        ImGui::TableSetupColumn("Class", ImGuiTableColumnFlags_WidthFixed, 70.0f);
+                        ImGui::TableSetupColumn("Zone", ImGuiTableColumnFlags_WidthFixed, 120.0f);
+                        ImGui::TableSetupColumn("Note");
+                        ImGui::TableSetupColumn("Officer Note");
+                        ImGui::TableHeadersRow();
+
+                        // Online members first, then offline
+                        auto sortedMembers = roster.members;
+                        std::sort(sortedMembers.begin(), sortedMembers.end(), [](const auto& a, const auto& b) {
+                            if (a.online != b.online) return a.online > b.online;
+                            return a.name < b.name;
+                        });
+
+                        static const char* classNames[] = {
+                            "Unknown", "Warrior", "Paladin", "Hunter", "Rogue",
+                            "Priest", "Death Knight", "Shaman", "Mage", "Warlock",
+                            "", "Druid"
+                        };
+
+                        for (const auto& m : sortedMembers) {
+                            ImGui::TableNextRow();
+                            ImVec4 textColor = m.online ? ImVec4(1.0f, 1.0f, 1.0f, 1.0f)
+                                                        : ImVec4(0.5f, 0.5f, 0.5f, 1.0f);
+
+                            ImGui::TableNextColumn();
+                            ImGui::TextColored(textColor, "%s", m.name.c_str());
+
+                            // Right-click context menu
+                            if (ImGui::IsItemClicked(ImGuiMouseButton_Right)) {
+                                selectedGuildMember_ = m.name;
+                                ImGui::OpenPopup("GuildMemberContext");
+                            }
+
+                            ImGui::TableNextColumn();
+                            // Show rank name instead of index
+                            if (m.rankIndex < rankNames.size()) {
+                                ImGui::TextColored(textColor, "%s", rankNames[m.rankIndex].c_str());
+                            } else {
+                                ImGui::TextColored(textColor, "Rank %u", m.rankIndex);
+                            }
+
+                            ImGui::TableNextColumn();
+                            ImGui::TextColored(textColor, "%u", m.level);
+
+                            ImGui::TableNextColumn();
+                            const char* className = (m.classId < 12) ? classNames[m.classId] : "Unknown";
+                            ImGui::TextColored(textColor, "%s", className);
+
+                            ImGui::TableNextColumn();
+                            // Zone name lookup
+                            if (zoneManager) {
+                                const auto* zoneInfo = zoneManager->getZoneInfo(m.zoneId);
+                                if (zoneInfo && !zoneInfo->name.empty()) {
+                                    ImGui::TextColored(textColor, "%s", zoneInfo->name.c_str());
+                                } else {
+                                    ImGui::TextColored(textColor, "%u", m.zoneId);
+                                }
+                            } else {
+                                ImGui::TextColored(textColor, "%u", m.zoneId);
+                            }
+
+                            ImGui::TableNextColumn();
+                            ImGui::TextColored(textColor, "%s", m.publicNote.c_str());
+
+                            ImGui::TableNextColumn();
+                            ImGui::TextColored(textColor, "%s", m.officerNote.c_str());
+                        }
+                        ImGui::EndTable();
+                    }
+
+                    // Context menu popup
+                    if (ImGui::BeginPopup("GuildMemberContext")) {
+                        ImGui::Text("%s", selectedGuildMember_.c_str());
+                        ImGui::Separator();
+                        if (ImGui::MenuItem("Promote")) {
+                            gameHandler.promoteGuildMember(selectedGuildMember_);
+                        }
+                        if (ImGui::MenuItem("Demote")) {
+                            gameHandler.demoteGuildMember(selectedGuildMember_);
+                        }
+                        if (ImGui::MenuItem("Kick")) {
+                            gameHandler.kickGuildMember(selectedGuildMember_);
+                        }
+                        ImGui::Separator();
+                        if (ImGui::MenuItem("Set Public Note...")) {
+                            showGuildNoteEdit_ = true;
+                            editingOfficerNote_ = false;
+                            guildNoteEditBuffer_[0] = '\0';
+                            // Pre-fill with existing note
+                            for (const auto& mem : roster.members) {
+                                if (mem.name == selectedGuildMember_) {
+                                    snprintf(guildNoteEditBuffer_, sizeof(guildNoteEditBuffer_), "%s", mem.publicNote.c_str());
+                                    break;
+                                }
+                            }
+                        }
+                        if (ImGui::MenuItem("Set Officer Note...")) {
+                            showGuildNoteEdit_ = true;
+                            editingOfficerNote_ = true;
+                            guildNoteEditBuffer_[0] = '\0';
+                            for (const auto& mem : roster.members) {
+                                if (mem.name == selectedGuildMember_) {
+                                    snprintf(guildNoteEditBuffer_, sizeof(guildNoteEditBuffer_), "%s", mem.officerNote.c_str());
+                                    break;
+                                }
+                            }
+                        }
+                        ImGui::Separator();
+                        if (ImGui::MenuItem("Set as Leader")) {
+                            gameHandler.setGuildLeader(selectedGuildMember_);
+                        }
+                        ImGui::EndPopup();
+                    }
+
+                    // Note edit modal
+                    if (showGuildNoteEdit_) {
+                        ImGui::OpenPopup("EditGuildNote");
+                        showGuildNoteEdit_ = false;
+                    }
+                    if (ImGui::BeginPopupModal("EditGuildNote", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
+                        ImGui::Text("%s %s for %s:",
+                            editingOfficerNote_ ? "Officer" : "Public", "Note", selectedGuildMember_.c_str());
+                        ImGui::InputText("##guildnote", guildNoteEditBuffer_, sizeof(guildNoteEditBuffer_));
+                        if (ImGui::Button("Save")) {
+                            if (editingOfficerNote_) {
+                                gameHandler.setGuildOfficerNote(selectedGuildMember_, guildNoteEditBuffer_);
+                            } else {
+                                gameHandler.setGuildPublicNote(selectedGuildMember_, guildNoteEditBuffer_);
+                            }
+                            ImGui::CloseCurrentPopup();
+                        }
+                        ImGui::SameLine();
+                        if (ImGui::Button("Cancel")) {
+                            ImGui::CloseCurrentPopup();
+                        }
+                        ImGui::EndPopup();
+                    }
+                }
+                ImGui::EndTabItem();
+            }
+
+            if (ImGui::BeginTabItem("Guild Info")) {
+                guildRosterTab_ = 1;
+                const auto& infoData = gameHandler.getGuildInfoData();
+                const auto& queryData = gameHandler.getGuildQueryData();
+                const auto& roster = gameHandler.getGuildRoster();
+                const auto& rankNames = gameHandler.getGuildRankNames();
+
+                // Guild name (large, gold)
+                ImGui::PushFont(nullptr);  // default font
+                ImGui::TextColored(ImVec4(1.0f, 0.82f, 0.0f, 1.0f), "<%s>", gameHandler.getGuildName().c_str());
+                ImGui::PopFont();
+                ImGui::Separator();
+
+                // Creation date
+                if (infoData.isValid()) {
+                    ImGui::Text("Created: %u/%u/%u", infoData.creationDay, infoData.creationMonth, infoData.creationYear);
+                    ImGui::Text("Members: %u  |  Accounts: %u", infoData.numMembers, infoData.numAccounts);
+                }
+                ImGui::Spacing();
+
+                // Guild description / info text
+                if (!roster.guildInfo.empty()) {
+                    ImGui::TextColored(ImVec4(0.8f, 0.8f, 0.8f, 1.0f), "Description:");
+                    ImGui::TextWrapped("%s", roster.guildInfo.c_str());
+                }
+                ImGui::Spacing();
+
+                // MOTD with edit button
+                ImGui::TextColored(ImVec4(0.0f, 1.0f, 0.0f, 1.0f), "MOTD:");
+                ImGui::SameLine();
+                if (!roster.motd.empty()) {
+                    ImGui::TextWrapped("%s", roster.motd.c_str());
+                } else {
+                    ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "(not set)");
+                }
+                if (ImGui::Button("Set MOTD")) {
+                    showMotdEdit_ = true;
+                    snprintf(guildMotdEditBuffer_, sizeof(guildMotdEditBuffer_), "%s", roster.motd.c_str());
+                }
+                ImGui::Spacing();
+
+                // MOTD edit modal
+                if (showMotdEdit_) {
+                    ImGui::OpenPopup("EditMotd");
+                    showMotdEdit_ = false;
+                }
+                if (ImGui::BeginPopupModal("EditMotd", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
+                    ImGui::Text("Set Message of the Day:");
+                    ImGui::InputText("##motdinput", guildMotdEditBuffer_, sizeof(guildMotdEditBuffer_));
+                    if (ImGui::Button("Save", ImVec2(120, 0))) {
+                        gameHandler.setGuildMotd(guildMotdEditBuffer_);
+                        ImGui::CloseCurrentPopup();
+                    }
+                    ImGui::SameLine();
+                    if (ImGui::Button("Cancel", ImVec2(120, 0))) {
+                        ImGui::CloseCurrentPopup();
+                    }
+                    ImGui::EndPopup();
+                }
+
+                // Emblem info
+                if (queryData.isValid()) {
+                    ImGui::Separator();
+                    ImGui::Text("Emblem: Style %u, Color %u  |  Border: Style %u, Color %u  |  BG: %u",
+                        queryData.emblemStyle, queryData.emblemColor,
+                        queryData.borderStyle, queryData.borderColor, queryData.backgroundColor);
+                }
+
+                // Rank list
+                ImGui::Separator();
+                ImGui::TextColored(ImVec4(1.0f, 0.82f, 0.0f, 1.0f), "Ranks:");
+                for (size_t i = 0; i < rankNames.size(); ++i) {
+                    if (rankNames[i].empty()) continue;
+                    // Show rank permission summary from roster data
+                    if (i < roster.ranks.size()) {
+                        uint32_t rights = roster.ranks[i].rights;
+                        std::string perms;
+                        if (rights & 0x01) perms += "Invite ";
+                        if (rights & 0x02) perms += "Remove ";
+                        if (rights & 0x40) perms += "Promote ";
+                        if (rights & 0x80) perms += "Demote ";
+                        if (rights & 0x04) perms += "OChat ";
+                        if (rights & 0x10) perms += "MOTD ";
+                        ImGui::Text("  %zu. %s", i + 1, rankNames[i].c_str());
+                        if (!perms.empty()) {
+                            ImGui::SameLine();
+                            ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "[%s]", perms.c_str());
+                        }
+                    } else {
+                        ImGui::Text("  %zu. %s", i + 1, rankNames[i].c_str());
+                    }
+                }
+
+                // Rank management buttons
+                ImGui::Spacing();
+                if (ImGui::Button("Add Rank")) {
+                    showAddRankModal_ = true;
+                    addRankNameBuffer_[0] = '\0';
+                }
+                ImGui::SameLine();
+                if (ImGui::Button("Delete Last Rank")) {
+                    gameHandler.deleteGuildRank();
+                }
+
+                // Add rank modal
+                if (showAddRankModal_) {
+                    ImGui::OpenPopup("AddGuildRank");
+                    showAddRankModal_ = false;
+                }
+                if (ImGui::BeginPopupModal("AddGuildRank", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
+                    ImGui::Text("New Rank Name:");
+                    ImGui::InputText("##rankname", addRankNameBuffer_, sizeof(addRankNameBuffer_));
+                    if (ImGui::Button("Add", ImVec2(120, 0))) {
+                        if (addRankNameBuffer_[0] != '\0') {
+                            gameHandler.addGuildRank(addRankNameBuffer_);
+                            ImGui::CloseCurrentPopup();
+                        }
+                    }
+                    ImGui::SameLine();
+                    if (ImGui::Button("Cancel", ImVec2(120, 0))) {
+                        ImGui::CloseCurrentPopup();
+                    }
+                    ImGui::EndPopup();
+                }
+
+                ImGui::EndTabItem();
+            }
+
+            ImGui::EndTabBar();
+        }
+    }
+    ImGui::End();
+    showGuildRoster_ = open;
+}
+
+// ============================================================
+// Buff/Debuff Bar (Phase 3)
+// ============================================================
+
+void GameScreen::renderBuffBar(game::GameHandler& gameHandler) {
+    const auto& auras = gameHandler.getPlayerAuras();
+
+    // Count non-empty auras
+    int activeCount = 0;
+    for (const auto& a : auras) {
+        if (!a.isEmpty()) activeCount++;
+    }
+    if (activeCount == 0 && !gameHandler.hasPet()) return;
+
+    auto* assetMgr = core::Application::getInstance().getAssetManager();
+
+    // Position below the player frame in top-left
+    constexpr float ICON_SIZE = 32.0f;
+    constexpr int ICONS_PER_ROW = 8;
+    float barW = ICONS_PER_ROW * (ICON_SIZE + 4.0f) + 8.0f;
+    // Dock under player frame in top-left (player frame is at 10, 30 with ~110px height)
+    ImGui::SetNextWindowPos(ImVec2(10.0f, 145.0f), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(barW, 0), ImGuiCond_Always);
+
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
+                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
+                             ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoScrollbar;
+
+    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.0f, 0.0f, 0.0f, 0.0f));
+    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(2.0f, 2.0f));
+
+    if (ImGui::Begin("##BuffBar", nullptr, flags)) {
+        int shown = 0;
+        for (size_t i = 0; i < auras.size() && shown < 16; ++i) {
+            const auto& aura = auras[i];
+            if (aura.isEmpty()) continue;
+
+            if (shown > 0 && shown % ICONS_PER_ROW != 0) ImGui::SameLine();
+
+            ImGui::PushID(static_cast<int>(i));
+
+            bool isBuff = (aura.flags & 0x80) == 0;  // 0x80 = negative/debuff flag
+            ImVec4 borderColor = isBuff ? ImVec4(0.2f, 0.8f, 0.2f, 0.9f) : ImVec4(0.8f, 0.2f, 0.2f, 0.9f);
+
+            // Try to get spell icon
+            VkDescriptorSet iconTex = VK_NULL_HANDLE;
+            if (assetMgr) {
+                iconTex = getSpellIcon(aura.spellId, assetMgr);
+            }
+
+            if (iconTex) {
+                ImGui::PushStyleColor(ImGuiCol_Button, borderColor);
+                ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(2, 2));
+                ImGui::ImageButton("##aura",
+                    (ImTextureID)(uintptr_t)iconTex,
+                    ImVec2(ICON_SIZE - 4, ICON_SIZE - 4));
+                ImGui::PopStyleVar();
+                ImGui::PopStyleColor();
+            } else {
+                ImGui::PushStyleColor(ImGuiCol_Button, borderColor);
+                char label[8];
+                snprintf(label, sizeof(label), "%u", aura.spellId);
+                ImGui::Button(label, ImVec2(ICON_SIZE, ICON_SIZE));
+                ImGui::PopStyleColor();
+            }
+
+            // Compute remaining duration once (shared by overlay and tooltip)
+            uint64_t nowMs = static_cast<uint64_t>(
+                std::chrono::duration_cast<std::chrono::milliseconds>(
+                    std::chrono::steady_clock::now().time_since_epoch()).count());
+            int32_t remainMs = aura.getRemainingMs(nowMs);
+
+            // Duration countdown overlay — always visible on the icon bottom
+            if (remainMs > 0) {
+                ImVec2 iconMin = ImGui::GetItemRectMin();
+                ImVec2 iconMax = ImGui::GetItemRectMax();
+                char timeStr[12];
+                int secs = (remainMs + 999) / 1000;  // ceiling seconds
+                if (secs >= 3600)
+                    snprintf(timeStr, sizeof(timeStr), "%dh", secs / 3600);
+                else if (secs >= 60)
+                    snprintf(timeStr, sizeof(timeStr), "%d:%02d", secs / 60, secs % 60);
+                else
+                    snprintf(timeStr, sizeof(timeStr), "%d", secs);
+                ImVec2 textSize = ImGui::CalcTextSize(timeStr);
+                float cx = iconMin.x + (iconMax.x - iconMin.x - textSize.x) * 0.5f;
+                float cy = iconMax.y - textSize.y - 2.0f;
+                // Drop shadow for readability over any icon colour
+                ImGui::GetWindowDrawList()->AddText(ImVec2(cx + 1, cy + 1),
+                    IM_COL32(0, 0, 0, 200), timeStr);
+                ImGui::GetWindowDrawList()->AddText(ImVec2(cx, cy),
+                    IM_COL32(255, 255, 255, 255), timeStr);
+            }
+
+            // Stack / charge count overlay — upper-left corner of the icon
+            if (aura.charges > 1) {
+                ImVec2 iconMin = ImGui::GetItemRectMin();
+                char chargeStr[8];
+                snprintf(chargeStr, sizeof(chargeStr), "%u", static_cast<unsigned>(aura.charges));
+                // Drop shadow then bright yellow text
+                ImGui::GetWindowDrawList()->AddText(ImVec2(iconMin.x + 3, iconMin.y + 3),
+                    IM_COL32(0, 0, 0, 200), chargeStr);
+                ImGui::GetWindowDrawList()->AddText(ImVec2(iconMin.x + 2, iconMin.y + 2),
+                    IM_COL32(255, 220, 50, 255), chargeStr);
+            }
+
+            // Right-click to cancel buffs / dismount
+            if (ImGui::IsItemClicked(ImGuiMouseButton_Right)) {
+                if (gameHandler.isMounted()) {
+                    gameHandler.dismount();
+                } else if (isBuff) {
+                    gameHandler.cancelAura(aura.spellId);
+                }
+            }
+
+            // Tooltip with spell name and countdown
+            if (ImGui::IsItemHovered()) {
+                std::string name = spellbookScreen.lookupSpellName(aura.spellId, assetMgr);
+                if (name.empty()) name = "Spell #" + std::to_string(aura.spellId);
+                if (remainMs > 0) {
+                    int seconds = remainMs / 1000;
+                    if (seconds < 60) {
+                        ImGui::SetTooltip("%s (%ds)", name.c_str(), seconds);
+                    } else {
+                        ImGui::SetTooltip("%s (%dm %ds)", name.c_str(), seconds / 60, seconds % 60);
+                    }
+                } else {
+                    ImGui::SetTooltip("%s", name.c_str());
+                }
+            }
+
+            ImGui::PopID();
+            shown++;
+        }
+        // Dismiss Pet button
+        if (gameHandler.hasPet()) {
+            if (shown > 0) ImGui::Spacing();
+            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.6f, 0.2f, 0.2f, 0.9f));
+            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.8f, 0.3f, 0.3f, 1.0f));
+            if (ImGui::Button("Dismiss Pet", ImVec2(-1, 0))) {
+                gameHandler.dismissPet();
+            }
+            ImGui::PopStyleColor(2);
+        }
+    }
+    ImGui::End();
+
     ImGui::PopStyleVar();
+    ImGui::PopStyleColor();
+}
+
+// ============================================================
+// Loot Window (Phase 5)
+// ============================================================
+
+void GameScreen::renderLootWindow(game::GameHandler& gameHandler) {
+    if (!gameHandler.isLootWindowOpen()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 150, 200), ImGuiCond_Appearing);
+    ImGui::SetNextWindowSize(ImVec2(300, 0), ImGuiCond_Always);
+
+    bool open = true;
+    if (ImGui::Begin("Loot", &open, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize)) {
+        const auto& loot = gameHandler.getCurrentLoot();
+
+        // Gold
+        if (loot.gold > 0) {
+            ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.0f, 1.0f), "%ug %us %uc",
+                               loot.getGold(), loot.getSilver(), loot.getCopper());
+            ImGui::Separator();
+        }
+
+        // Items with icons and labels
+        constexpr float iconSize = 32.0f;
+        int lootSlotClicked = -1;  // defer loot pickup to avoid iterator invalidation
+        for (const auto& item : loot.items) {
+            ImGui::PushID(item.slotIndex);
+
+            // Get item info for name and quality
+            const auto* info = gameHandler.getItemInfo(item.itemId);
+            std::string itemName;
+            game::ItemQuality quality = game::ItemQuality::COMMON;
+            if (info && !info->name.empty()) {
+                itemName = info->name;
+                quality = static_cast<game::ItemQuality>(info->quality);
+            } else {
+                itemName = "Item #" + std::to_string(item.itemId);
+            }
+            ImVec4 qColor = InventoryScreen::getQualityColor(quality);
+
+            // Get item icon
+            uint32_t displayId = item.displayInfoId;
+            if (displayId == 0 && info) displayId = info->displayInfoId;
+            VkDescriptorSet iconTex = inventoryScreen.getItemIcon(displayId);
+
+            ImVec2 cursor = ImGui::GetCursorScreenPos();
+            float rowH = std::max(iconSize, ImGui::GetTextLineHeight() * 2.0f);
+
+            // Invisible selectable for click handling
+            if (ImGui::Selectable("##loot", false, 0, ImVec2(0, rowH))) {
+                lootSlotClicked = item.slotIndex;
+            }
+            if (ImGui::IsItemClicked(ImGuiMouseButton_Right)) {
+                lootSlotClicked = item.slotIndex;
+            }
+            bool hovered = ImGui::IsItemHovered();
+
+            ImDrawList* drawList = ImGui::GetWindowDrawList();
+
+            // Draw hover highlight
+            if (hovered) {
+                drawList->AddRectFilled(cursor,
+                    ImVec2(cursor.x + ImGui::GetContentRegionAvail().x + iconSize + 8.0f,
+                           cursor.y + rowH),
+                    IM_COL32(255, 255, 255, 30));
+            }
+
+            // Draw icon
+            if (iconTex) {
+                drawList->AddImage((ImTextureID)(uintptr_t)iconTex,
+                    cursor, ImVec2(cursor.x + iconSize, cursor.y + iconSize));
+                drawList->AddRect(cursor, ImVec2(cursor.x + iconSize, cursor.y + iconSize),
+                    ImGui::ColorConvertFloat4ToU32(qColor));
+            } else {
+                drawList->AddRectFilled(cursor,
+                    ImVec2(cursor.x + iconSize, cursor.y + iconSize),
+                    IM_COL32(40, 40, 50, 200));
+                drawList->AddRect(cursor, ImVec2(cursor.x + iconSize, cursor.y + iconSize),
+                    IM_COL32(80, 80, 80, 200));
+            }
+
+            // Draw item name
+            float textX = cursor.x + iconSize + 6.0f;
+            float textY = cursor.y + 2.0f;
+            drawList->AddText(ImVec2(textX, textY),
+                ImGui::ColorConvertFloat4ToU32(qColor), itemName.c_str());
+
+            // Draw count if > 1
+            if (item.count > 1) {
+                char countStr[32];
+                snprintf(countStr, sizeof(countStr), "x%u", item.count);
+                float countY = textY + ImGui::GetTextLineHeight();
+                drawList->AddText(ImVec2(textX, countY), IM_COL32(200, 200, 200, 220), countStr);
+            }
+
+            ImGui::PopID();
+        }
+
+        // Process deferred loot pickup (after loop to avoid iterator invalidation)
+        if (lootSlotClicked >= 0) {
+            gameHandler.lootItem(static_cast<uint8_t>(lootSlotClicked));
+        }
+
+        if (loot.items.empty() && loot.gold == 0) {
+            gameHandler.closeLoot();
+        }
+
+        ImGui::Spacing();
+        if (ImGui::Button("Close", ImVec2(-1, 0))) {
+            gameHandler.closeLoot();
+        }
+    }
+    ImGui::End();
+
+    if (!open) {
+        gameHandler.closeLoot();
+    }
+}
+
+// ============================================================
+// Gossip Window (Phase 5)
+// ============================================================
+
+void GameScreen::renderGossipWindow(game::GameHandler& gameHandler) {
+    if (!gameHandler.isGossipWindowOpen()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 200, 150), ImGuiCond_Appearing);
+    ImGui::SetNextWindowSize(ImVec2(400, 0), ImGuiCond_Always);
+
+    bool open = true;
+    if (ImGui::Begin("NPC Dialog", &open, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize)) {
+        const auto& gossip = gameHandler.getCurrentGossip();
+
+        // NPC name (from creature cache)
+        auto npcEntity = gameHandler.getEntityManager().getEntity(gossip.npcGuid);
+        if (npcEntity && npcEntity->getType() == game::ObjectType::UNIT) {
+            auto unit = std::static_pointer_cast<game::Unit>(npcEntity);
+            if (!unit->getName().empty()) {
+                ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.0f, 1.0f), "%s", unit->getName().c_str());
+                ImGui::Separator();
+            }
+        }
+
+        ImGui::Spacing();
+
+        // Gossip option icons - matches WoW GossipOptionIcon enum
+        static const char* gossipIcons[] = {
+            "[Chat]",          // 0 = GOSSIP_ICON_CHAT
+            "[Vendor]",        // 1 = GOSSIP_ICON_VENDOR
+            "[Taxi]",          // 2 = GOSSIP_ICON_TAXI
+            "[Trainer]",       // 3 = GOSSIP_ICON_TRAINER
+            "[Interact]",      // 4 = GOSSIP_ICON_INTERACT_1
+            "[Interact]",      // 5 = GOSSIP_ICON_INTERACT_2
+            "[Banker]",        // 6 = GOSSIP_ICON_MONEY_BAG (banker)
+            "[Chat]",          // 7 = GOSSIP_ICON_TALK
+            "[Tabard]",        // 8 = GOSSIP_ICON_TABARD
+            "[Battlemaster]",  // 9 = GOSSIP_ICON_BATTLE
+            "[Option]",        // 10 = GOSSIP_ICON_DOT
+        };
+
+        // Default text for server-sent gossip option placeholders
+        static const std::unordered_map<std::string, std::string> gossipPlaceholders = {
+            {"GOSSIP_OPTION_BANKER", "I would like to check my deposit box."},
+            {"GOSSIP_OPTION_AUCTIONEER", "I'd like to browse your auctions."},
+            {"GOSSIP_OPTION_VENDOR", "I want to browse your goods."},
+            {"GOSSIP_OPTION_TAXIVENDOR", "I'd like to fly."},
+            {"GOSSIP_OPTION_TRAINER", "I seek training."},
+            {"GOSSIP_OPTION_INNKEEPER", "Make this inn your home."},
+            {"GOSSIP_OPTION_SPIRITGUIDE", "Return me to life."},
+            {"GOSSIP_OPTION_SPIRITHEALER", "Bring me back to life."},
+            {"GOSSIP_OPTION_STABLEPET", "I'd like to stable my pet."},
+            {"GOSSIP_OPTION_ARMORER", "I need to repair my equipment."},
+            {"GOSSIP_OPTION_GOSSIP", "What can you tell me?"},
+            {"GOSSIP_OPTION_BATTLEFIELD", "I'd like to go to the battleground."},
+            {"GOSSIP_OPTION_TABARDDESIGNER", "I want to create a guild tabard."},
+            {"GOSSIP_OPTION_PETITIONER", "I want to create a guild."},
+        };
+
+        for (const auto& opt : gossip.options) {
+            ImGui::PushID(static_cast<int>(opt.id));
+
+            // Determine icon label - use text-based detection for shared icons
+            const char* icon = (opt.icon < 11) ? gossipIcons[opt.icon] : "[Option]";
+            if (opt.text == "GOSSIP_OPTION_AUCTIONEER") icon = "[Auctioneer]";
+            else if (opt.text == "GOSSIP_OPTION_BANKER") icon = "[Banker]";
+            else if (opt.text == "GOSSIP_OPTION_VENDOR") icon = "[Vendor]";
+            else if (opt.text == "GOSSIP_OPTION_TRAINER") icon = "[Trainer]";
+            else if (opt.text == "GOSSIP_OPTION_INNKEEPER") icon = "[Innkeeper]";
+            else if (opt.text == "GOSSIP_OPTION_STABLEPET") icon = "[Stable Master]";
+            else if (opt.text == "GOSSIP_OPTION_ARMORER") icon = "[Repair]";
+
+            // Resolve placeholder text from server
+            std::string displayText = opt.text;
+            auto placeholderIt = gossipPlaceholders.find(displayText);
+            if (placeholderIt != gossipPlaceholders.end()) {
+                displayText = placeholderIt->second;
+            }
+
+            std::string processedText = replaceGenderPlaceholders(displayText, gameHandler);
+            std::string label = std::string(icon) + " " + processedText;
+            if (ImGui::Selectable(label.c_str())) {
+                gameHandler.selectGossipOption(opt.id);
+            }
+            ImGui::PopID();
+        }
+
+        // Fallback: some spirit healers don't send gossip options.
+        if (gossip.options.empty() && gameHandler.isPlayerGhost()) {
+            bool isSpirit = false;
+            if (npcEntity && npcEntity->getType() == game::ObjectType::UNIT) {
+                auto unit = std::static_pointer_cast<game::Unit>(npcEntity);
+                std::string name = unit->getName();
+                std::transform(name.begin(), name.end(), name.begin(),
+                               [](unsigned char c){ return static_cast<char>(std::tolower(c)); });
+                if (name.find("spirit healer") != std::string::npos ||
+                    name.find("spirit guide") != std::string::npos) {
+                    isSpirit = true;
+                }
+            }
+            if (isSpirit) {
+                if (ImGui::Selectable("[Spiritguide] Return to Graveyard")) {
+                    gameHandler.activateSpiritHealer(gossip.npcGuid);
+                    gameHandler.closeGossip();
+                }
+            }
+        }
+
+        // Quest items
+        if (!gossip.quests.empty()) {
+            ImGui::Spacing();
+            ImGui::Separator();
+            ImGui::TextColored(ImVec4(1.0f, 1.0f, 0.3f, 1.0f), "Quests:");
+            for (size_t qi = 0; qi < gossip.quests.size(); qi++) {
+                const auto& quest = gossip.quests[qi];
+                ImGui::PushID(static_cast<int>(qi));
+                char qlabel[256];
+                snprintf(qlabel, sizeof(qlabel), "[%d] %s", quest.questLevel, quest.title.c_str());
+                ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 1.0f, 0.3f, 1.0f));
+                if (ImGui::Selectable(qlabel)) {
+                    gameHandler.selectGossipQuest(quest.questId);
+                }
+                ImGui::PopStyleColor();
+                ImGui::PopID();
+            }
+        }
+
+        ImGui::Spacing();
+        if (ImGui::Button("Close", ImVec2(-1, 0))) {
+            gameHandler.closeGossip();
+        }
+    }
+    ImGui::End();
+
+    if (!open) {
+        gameHandler.closeGossip();
+    }
+}
+
+// ============================================================
+// Quest Details Window
+// ============================================================
+
+void GameScreen::renderQuestDetailsWindow(game::GameHandler& gameHandler) {
+    if (!gameHandler.isQuestDetailsOpen()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 225, screenH / 2 - 200), ImGuiCond_Appearing);
+    ImGui::SetNextWindowSize(ImVec2(450, 400), ImGuiCond_Appearing);
+
+    bool open = true;
+    const auto& quest = gameHandler.getQuestDetails();
+    std::string processedTitle = replaceGenderPlaceholders(quest.title, gameHandler);
+    if (ImGui::Begin(processedTitle.c_str(), &open)) {
+        // Quest description
+        if (!quest.details.empty()) {
+            std::string processedDetails = replaceGenderPlaceholders(quest.details, gameHandler);
+            ImGui::TextWrapped("%s", processedDetails.c_str());
+        }
+
+        // Objectives
+        if (!quest.objectives.empty()) {
+            ImGui::Spacing();
+            ImGui::Separator();
+            ImGui::TextColored(ImVec4(1.0f, 0.82f, 0.0f, 1.0f), "Objectives:");
+            std::string processedObjectives = replaceGenderPlaceholders(quest.objectives, gameHandler);
+            ImGui::TextWrapped("%s", processedObjectives.c_str());
+        }
+
+        // Rewards
+        if (quest.rewardXp > 0 || quest.rewardMoney > 0) {
+            ImGui::Spacing();
+            ImGui::Separator();
+            ImGui::TextColored(ImVec4(1.0f, 0.82f, 0.0f, 1.0f), "Rewards:");
+            if (quest.rewardXp > 0) {
+                ImGui::Text("  %u experience", quest.rewardXp);
+            }
+            if (quest.rewardMoney > 0) {
+                uint32_t gold = quest.rewardMoney / 10000;
+                uint32_t silver = (quest.rewardMoney % 10000) / 100;
+                uint32_t copper = quest.rewardMoney % 100;
+                if (gold > 0) ImGui::Text("  %ug %us %uc", gold, silver, copper);
+                else if (silver > 0) ImGui::Text("  %us %uc", silver, copper);
+                else ImGui::Text("  %uc", copper);
+            }
+        }
+
+        if (quest.suggestedPlayers > 1) {
+            ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f),
+                "Suggested players: %u", quest.suggestedPlayers);
+        }
+
+        // Accept / Decline buttons
+        ImGui::Spacing();
+        ImGui::Separator();
+        ImGui::Spacing();
+        float buttonW = (ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x) * 0.5f;
+        if (ImGui::Button("Accept", ImVec2(buttonW, 0))) {
+            gameHandler.acceptQuest();
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Decline", ImVec2(buttonW, 0))) {
+            gameHandler.declineQuest();
+        }
+    }
+    ImGui::End();
+
+    if (!open) {
+        gameHandler.declineQuest();
+    }
+}
+
+// ============================================================
+// Quest Request Items Window (turn-in progress check)
+// ============================================================
+
+void GameScreen::renderQuestRequestItemsWindow(game::GameHandler& gameHandler) {
+    if (!gameHandler.isQuestRequestItemsOpen()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 225, screenH / 2 - 200), ImGuiCond_Appearing);
+    ImGui::SetNextWindowSize(ImVec2(450, 350), ImGuiCond_Appearing);
+
+    bool open = true;
+    const auto& quest = gameHandler.getQuestRequestItems();
+    auto countItemInInventory = [&](uint32_t itemId) -> uint32_t {
+        const auto& inv = gameHandler.getInventory();
+        uint32_t total = 0;
+        for (int i = 0; i < inv.getBackpackSize(); ++i) {
+            const auto& slot = inv.getBackpackSlot(i);
+            if (!slot.empty() && slot.item.itemId == itemId) total += slot.item.stackCount;
+        }
+        for (int bag = 0; bag < game::Inventory::NUM_BAG_SLOTS; ++bag) {
+            int bagSize = inv.getBagSize(bag);
+            for (int s = 0; s < bagSize; ++s) {
+                const auto& slot = inv.getBagSlot(bag, s);
+                if (!slot.empty() && slot.item.itemId == itemId) total += slot.item.stackCount;
+            }
+        }
+        return total;
+    };
+
+    std::string processedTitle = replaceGenderPlaceholders(quest.title, gameHandler);
+    if (ImGui::Begin(processedTitle.c_str(), &open, ImGuiWindowFlags_NoCollapse)) {
+        if (!quest.completionText.empty()) {
+            std::string processedCompletionText = replaceGenderPlaceholders(quest.completionText, gameHandler);
+            ImGui::TextWrapped("%s", processedCompletionText.c_str());
+        }
+
+        // Required items
+        if (!quest.requiredItems.empty()) {
+            ImGui::Spacing();
+            ImGui::Separator();
+            ImGui::TextColored(ImVec4(1.0f, 0.82f, 0.0f, 1.0f), "Required Items:");
+            for (const auto& item : quest.requiredItems) {
+                uint32_t have = countItemInInventory(item.itemId);
+                bool enough = have >= item.count;
+                auto* info = gameHandler.getItemInfo(item.itemId);
+                const char* name = (info && info->valid) ? info->name.c_str() : nullptr;
+                if (name && *name) {
+                    ImGui::TextColored(enough ? ImVec4(0.6f, 1.0f, 0.6f, 1.0f) : ImVec4(1.0f, 0.6f, 0.6f, 1.0f),
+                                       "  %s  %u/%u", name, have, item.count);
+                } else {
+                    ImGui::TextColored(enough ? ImVec4(0.6f, 1.0f, 0.6f, 1.0f) : ImVec4(1.0f, 0.6f, 0.6f, 1.0f),
+                                       "  Item %u  %u/%u", item.itemId, have, item.count);
+                }
+            }
+        }
+
+        if (quest.requiredMoney > 0) {
+            ImGui::Spacing();
+            uint32_t g = quest.requiredMoney / 10000;
+            uint32_t s = (quest.requiredMoney % 10000) / 100;
+            uint32_t c = quest.requiredMoney % 100;
+            ImGui::Text("Required money: %ug %us %uc", g, s, c);
+        }
+
+        // Complete / Cancel buttons
+        ImGui::Spacing();
+        ImGui::Separator();
+        ImGui::Spacing();
+        float buttonW = (ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x) * 0.5f;
+        if (ImGui::Button("Complete Quest", ImVec2(buttonW, 0))) {
+            gameHandler.completeQuest();
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Cancel", ImVec2(buttonW, 0))) {
+            gameHandler.closeQuestRequestItems();
+        }
+
+        if (!quest.isCompletable()) {
+            ImGui::TextDisabled("Server flagged this quest as incomplete; completion will be server-validated.");
+        }
+    }
+    ImGui::End();
+
+    if (!open) {
+        gameHandler.closeQuestRequestItems();
+    }
+}
+
+// ============================================================
+// Quest Offer Reward Window (choose reward)
+// ============================================================
+
+void GameScreen::renderQuestOfferRewardWindow(game::GameHandler& gameHandler) {
+    if (!gameHandler.isQuestOfferRewardOpen()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 225, screenH / 2 - 200), ImGuiCond_Appearing);
+    ImGui::SetNextWindowSize(ImVec2(450, 400), ImGuiCond_Appearing);
+
+    bool open = true;
+    const auto& quest = gameHandler.getQuestOfferReward();
+    static int selectedChoice = -1;
+
+    // Auto-select if only one choice reward
+    if (quest.choiceRewards.size() == 1 && selectedChoice == -1) {
+        selectedChoice = 0;
+    }
+
+    std::string processedTitle = replaceGenderPlaceholders(quest.title, gameHandler);
+    if (ImGui::Begin(processedTitle.c_str(), &open, ImGuiWindowFlags_NoCollapse)) {
+        if (!quest.rewardText.empty()) {
+            std::string processedRewardText = replaceGenderPlaceholders(quest.rewardText, gameHandler);
+            ImGui::TextWrapped("%s", processedRewardText.c_str());
+        }
+
+        // Choice rewards (pick one)
+        if (!quest.choiceRewards.empty()) {
+            ImGui::Spacing();
+            ImGui::Separator();
+            ImGui::TextColored(ImVec4(1.0f, 0.82f, 0.0f, 1.0f), "Choose a reward:");
+
+            for (size_t i = 0; i < quest.choiceRewards.size(); ++i) {
+                const auto& item = quest.choiceRewards[i];
+                auto* info = gameHandler.getItemInfo(item.itemId);
+
+                bool selected = (selectedChoice == static_cast<int>(i));
+
+                // Get item icon if we have displayInfoId
+                VkDescriptorSet iconTex = VK_NULL_HANDLE;
+                if (info && info->valid && info->displayInfoId != 0) {
+                    iconTex = inventoryScreen.getItemIcon(info->displayInfoId);
+                }
+
+                // Quality color
+                ImVec4 qualityColor = ImVec4(1.0f, 1.0f, 1.0f, 1.0f); // White (poor)
+                if (info && info->valid) {
+                    switch (info->quality) {
+                        case 1: qualityColor = ImVec4(1.0f, 1.0f, 1.0f, 1.0f); break; // Common (white)
+                        case 2: qualityColor = ImVec4(0.0f, 1.0f, 0.0f, 1.0f); break; // Uncommon (green)
+                        case 3: qualityColor = ImVec4(0.0f, 0.5f, 1.0f, 1.0f); break; // Rare (blue)
+                        case 4: qualityColor = ImVec4(0.64f, 0.21f, 0.93f, 1.0f); break; // Epic (purple)
+                        case 5: qualityColor = ImVec4(1.0f, 0.5f, 0.0f, 1.0f); break; // Legendary (orange)
+                    }
+                }
+
+                // Render item with icon + visible selectable label
+                ImGui::PushID(static_cast<int>(i));
+                std::string label;
+                if (info && info->valid && !info->name.empty()) {
+                    label = info->name;
+                } else {
+                    label = "Item " + std::to_string(item.itemId);
+                }
+                if (item.count > 1) {
+                    label += " x" + std::to_string(item.count);
+                }
+                if (ImGui::Selectable(label.c_str(), selected, 0, ImVec2(0, 24))) {
+                    selectedChoice = static_cast<int>(i);
+                }
+                if (ImGui::IsItemHovered() && iconTex) {
+                    ImGui::SetTooltip("Reward option");
+                }
+                if (iconTex) {
+                    ImGui::SameLine();
+                    ImGui::Image((void*)(intptr_t)iconTex, ImVec2(18, 18));
+                }
+                ImGui::PopID();
+            }
+        }
+
+        // Fixed rewards (always given)
+        if (!quest.fixedRewards.empty()) {
+            ImGui::Spacing();
+            ImGui::Separator();
+            ImGui::TextColored(ImVec4(1.0f, 0.82f, 0.0f, 1.0f), "You will also receive:");
+            for (const auto& item : quest.fixedRewards) {
+                auto* info = gameHandler.getItemInfo(item.itemId);
+                if (info && info->valid)
+                    ImGui::Text("  %s x%u", info->name.c_str(), item.count);
+                else
+                    ImGui::Text("  Item %u x%u", item.itemId, item.count);
+            }
+        }
+
+        // Money / XP rewards
+        if (quest.rewardXp > 0 || quest.rewardMoney > 0) {
+            ImGui::Spacing();
+            ImGui::Separator();
+            ImGui::TextColored(ImVec4(1.0f, 0.82f, 0.0f, 1.0f), "Rewards:");
+            if (quest.rewardXp > 0)
+                ImGui::Text("  %u experience", quest.rewardXp);
+            if (quest.rewardMoney > 0) {
+                uint32_t g = quest.rewardMoney / 10000;
+                uint32_t s = (quest.rewardMoney % 10000) / 100;
+                uint32_t c = quest.rewardMoney % 100;
+                if (g > 0) ImGui::Text("  %ug %us %uc", g, s, c);
+                else if (s > 0) ImGui::Text("  %us %uc", s, c);
+                else ImGui::Text("  %uc", c);
+            }
+        }
+
+        // Complete button
+        ImGui::Spacing();
+        ImGui::Separator();
+        ImGui::Spacing();
+        float buttonW = (ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x) * 0.5f;
+
+        bool canComplete = quest.choiceRewards.empty() || selectedChoice >= 0;
+        if (!canComplete) ImGui::BeginDisabled();
+        if (ImGui::Button("Complete Quest", ImVec2(buttonW, 0))) {
+            uint32_t rewardIdx = 0;
+            if (!quest.choiceRewards.empty() && selectedChoice >= 0 &&
+                selectedChoice < static_cast<int>(quest.choiceRewards.size())) {
+                // Server expects the original slot index from its fixed-size reward array.
+                rewardIdx = quest.choiceRewards[static_cast<size_t>(selectedChoice)].choiceSlot;
+            }
+            gameHandler.chooseQuestReward(rewardIdx);
+            selectedChoice = -1;
+        }
+        if (!canComplete) ImGui::EndDisabled();
+
+        ImGui::SameLine();
+        if (ImGui::Button("Cancel", ImVec2(buttonW, 0))) {
+            gameHandler.closeQuestOfferReward();
+            selectedChoice = -1;
+        }
+    }
+    ImGui::End();
+
+    if (!open) {
+        gameHandler.closeQuestOfferReward();
+        selectedChoice = -1;
+    }
+}
+
+// ============================================================
+// Vendor Window (Phase 5)
+// ============================================================
+
+void GameScreen::renderVendorWindow(game::GameHandler& gameHandler) {
+    if (!gameHandler.isVendorWindowOpen()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 200, 100), ImGuiCond_Appearing);
+    ImGui::SetNextWindowSize(ImVec2(450, 400), ImGuiCond_Appearing);
+
+    bool open = true;
+    if (ImGui::Begin("Vendor", &open)) {
+        const auto& vendor = gameHandler.getVendorItems();
+
+        // Show player money
+        uint64_t money = gameHandler.getMoneyCopper();
+        uint32_t mg = static_cast<uint32_t>(money / 10000);
+        uint32_t ms = static_cast<uint32_t>((money / 100) % 100);
+        uint32_t mc = static_cast<uint32_t>(money % 100);
+        ImGui::Text("Your money: %ug %us %uc", mg, ms, mc);
+        ImGui::Separator();
+
+        ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f), "Right-click bag items to sell");
+        ImGui::Separator();
+
+        const auto& buyback = gameHandler.getBuybackItems();
+        if (!buyback.empty()) {
+            ImGui::TextColored(ImVec4(1.0f, 0.82f, 0.0f, 1.0f), "Buy Back");
+            if (ImGui::BeginTable("BuybackTable", 3, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg)) {
+                ImGui::TableSetupColumn("Item", ImGuiTableColumnFlags_WidthStretch);
+                ImGui::TableSetupColumn("Price", ImGuiTableColumnFlags_WidthFixed, 110.0f);
+                ImGui::TableSetupColumn("Buy", ImGuiTableColumnFlags_WidthFixed, 62.0f);
+                ImGui::TableHeadersRow();
+                // Show only the most recently sold item (LIFO).
+                const int i = 0;
+                const auto& entry = buyback[0];
+                uint32_t sellPrice = entry.item.sellPrice;
+                if (sellPrice == 0) {
+                    if (auto* info = gameHandler.getItemInfo(entry.item.itemId); info && info->valid) {
+                        sellPrice = info->sellPrice;
+                    }
+                }
+                uint64_t price = static_cast<uint64_t>(sellPrice) *
+                                 static_cast<uint64_t>(entry.count > 0 ? entry.count : 1);
+                uint32_t g = static_cast<uint32_t>(price / 10000);
+                uint32_t s = static_cast<uint32_t>((price / 100) % 100);
+                uint32_t c = static_cast<uint32_t>(price % 100);
+                bool canAfford = money >= price;
+
+                ImGui::TableNextRow();
+                ImGui::PushID(8000 + i);
+                ImGui::TableSetColumnIndex(0);
+                const char* name = entry.item.name.empty() ? "Unknown Item" : entry.item.name.c_str();
+                if (entry.count > 1) {
+                    ImGui::Text("%s x%u", name, entry.count);
+                } else {
+                    ImGui::Text("%s", name);
+                }
+                ImGui::TableSetColumnIndex(1);
+                if (!canAfford) ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.3f, 0.3f, 1.0f));
+                ImGui::Text("%ug %us %uc", g, s, c);
+                if (!canAfford) ImGui::PopStyleColor();
+                ImGui::TableSetColumnIndex(2);
+                if (!canAfford) ImGui::BeginDisabled();
+                if (ImGui::SmallButton("Buy Back##buyback_0")) {
+                    gameHandler.buyBackItem(0);
+                }
+                if (!canAfford) ImGui::EndDisabled();
+                ImGui::PopID();
+                ImGui::EndTable();
+            }
+            ImGui::Separator();
+        }
+
+        if (vendor.items.empty()) {
+            ImGui::TextDisabled("This vendor has nothing for sale.");
+        } else {
+            if (ImGui::BeginTable("VendorTable", 4, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
+                ImGui::TableSetupColumn("Item", ImGuiTableColumnFlags_WidthStretch);
+                ImGui::TableSetupColumn("Price", ImGuiTableColumnFlags_WidthFixed, 120.0f);
+                ImGui::TableSetupColumn("Stock", ImGuiTableColumnFlags_WidthFixed, 60.0f);
+                ImGui::TableSetupColumn("Buy", ImGuiTableColumnFlags_WidthFixed, 50.0f);
+                ImGui::TableHeadersRow();
+
+                // Quality colors (matching WoW)
+                static const ImVec4 qualityColors[] = {
+                    ImVec4(0.6f, 0.6f, 0.6f, 1.0f),  // 0 Poor (gray)
+                    ImVec4(1.0f, 1.0f, 1.0f, 1.0f),  // 1 Common (white)
+                    ImVec4(0.12f, 1.0f, 0.0f, 1.0f),  // 2 Uncommon (green)
+                    ImVec4(0.0f, 0.44f, 0.87f, 1.0f), // 3 Rare (blue)
+                    ImVec4(0.64f, 0.21f, 0.93f, 1.0f),// 4 Epic (purple)
+                    ImVec4(1.0f, 0.5f, 0.0f, 1.0f),   // 5 Legendary (orange)
+                };
+
+                for (int vi = 0; vi < static_cast<int>(vendor.items.size()); ++vi) {
+                    const auto& item = vendor.items[vi];
+                    ImGui::TableNextRow();
+                    ImGui::PushID(vi);
+
+                    ImGui::TableSetColumnIndex(0);
+                    auto* info = gameHandler.getItemInfo(item.itemId);
+                    if (info && info->valid) {
+                        uint32_t q = info->quality < 6 ? info->quality : 1;
+                        ImGui::TextColored(qualityColors[q], "%s", info->name.c_str());
+                        // Tooltip with stats on hover
+                        if (ImGui::IsItemHovered()) {
+                            ImGui::BeginTooltip();
+                            ImGui::TextColored(qualityColors[q], "%s", info->name.c_str());
+                            if (info->damageMax > 0.0f) {
+                                ImGui::Text("%.0f - %.0f Damage", info->damageMin, info->damageMax);
+                                if (info->delayMs > 0) {
+                                    float speed = static_cast<float>(info->delayMs) / 1000.0f;
+                                    float dps = ((info->damageMin + info->damageMax) * 0.5f) / speed;
+                                    ImGui::Text("Speed %.2f", speed);
+                                    ImGui::Text("%.1f damage per second", dps);
+                                }
+                            }
+                            if (info->armor > 0) ImGui::Text("Armor: %d", info->armor);
+                            if (info->stamina > 0) ImGui::Text("+%d Stamina", info->stamina);
+                            if (info->strength > 0) ImGui::Text("+%d Strength", info->strength);
+                            if (info->agility > 0) ImGui::Text("+%d Agility", info->agility);
+                            if (info->intellect > 0) ImGui::Text("+%d Intellect", info->intellect);
+                            if (info->spirit > 0) ImGui::Text("+%d Spirit", info->spirit);
+                            ImGui::EndTooltip();
+                        }
+                    } else {
+                        ImGui::Text("Item %u", item.itemId);
+                    }
+
+                    ImGui::TableSetColumnIndex(1);
+                    if (item.buyPrice == 0 && item.extendedCost != 0) {
+                        // Token-only item (no gold cost)
+                        ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "[Tokens]");
+                    } else {
+                        uint32_t g = item.buyPrice / 10000;
+                        uint32_t s = (item.buyPrice / 100) % 100;
+                        uint32_t c = item.buyPrice % 100;
+                        bool canAfford = money >= item.buyPrice;
+                        if (!canAfford) ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.3f, 0.3f, 1.0f));
+                        ImGui::Text("%ug %us %uc", g, s, c);
+                        if (!canAfford) ImGui::PopStyleColor();
+                    }
+
+                    ImGui::TableSetColumnIndex(2);
+                    if (item.maxCount < 0) {
+                        ImGui::Text("Inf");
+                    } else {
+                        ImGui::Text("%d", item.maxCount);
+                    }
+
+                    ImGui::TableSetColumnIndex(3);
+                    std::string buyBtnId = "Buy##vendor_" + std::to_string(vi);
+                    if (ImGui::SmallButton(buyBtnId.c_str())) {
+                        gameHandler.buyItem(vendor.vendorGuid, item.itemId, item.slot, 1);
+                    }
+
+                    ImGui::PopID();
+                }
+
+                ImGui::EndTable();
+            }
+        }
+    }
+    ImGui::End();
+
+    if (!open) {
+        gameHandler.closeVendor();
+    }
+}
+
+// ============================================================
+// Trainer
+// ============================================================
+
+void GameScreen::renderTrainerWindow(game::GameHandler& gameHandler) {
+    if (!gameHandler.isTrainerWindowOpen()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 225, 100), ImGuiCond_Appearing);
+    ImGui::SetNextWindowSize(ImVec2(500, 450), ImGuiCond_Appearing);
+
+    bool open = true;
+    if (ImGui::Begin("Trainer", &open)) {
+        const auto& trainer = gameHandler.getTrainerSpells();
+
+        // NPC name
+        auto npcEntity = gameHandler.getEntityManager().getEntity(trainer.trainerGuid);
+        if (npcEntity && npcEntity->getType() == game::ObjectType::UNIT) {
+            auto unit = std::static_pointer_cast<game::Unit>(npcEntity);
+            if (!unit->getName().empty()) {
+                ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.0f, 1.0f), "%s", unit->getName().c_str());
+            }
+        }
+
+        // Greeting
+        if (!trainer.greeting.empty()) {
+            ImGui::TextWrapped("%s", trainer.greeting.c_str());
+        }
+        ImGui::Separator();
+
+        // Player money
+        uint64_t money = gameHandler.getMoneyCopper();
+        uint32_t mg = static_cast<uint32_t>(money / 10000);
+        uint32_t ms = static_cast<uint32_t>((money / 100) % 100);
+        uint32_t mc = static_cast<uint32_t>(money % 100);
+        ImGui::Text("Your money: %ug %us %uc", mg, ms, mc);
+
+        // Filter checkbox
+        static bool showUnavailable = false;
+        ImGui::Checkbox("Show unavailable spells", &showUnavailable);
+        ImGui::Separator();
+
+        if (trainer.spells.empty()) {
+            ImGui::TextDisabled("This trainer has nothing to teach you.");
+        } else {
+            // Known spells for checking
+            const auto& knownSpells = gameHandler.getKnownSpells();
+            auto isKnown = [&](uint32_t id) {
+                if (id == 0) return true;
+                // Check if spell is in knownSpells list
+                bool found = knownSpells.count(id);
+                if (found) return true;
+
+                // Also check if spell is in trainer list with state=2 (explicitly known)
+                // state=0 means unavailable (could be no prereqs, wrong level, etc.) - don't count as known
+                for (const auto& ts : trainer.spells) {
+                    if (ts.spellId == id && ts.state == 2) {
+                        return true;
+                    }
+                }
+                return false;
+            };
+            uint32_t playerLevel = gameHandler.getPlayerLevel();
+
+            // Renders spell rows into the current table
+            auto renderSpellRows = [&](const std::vector<const game::TrainerSpell*>& spells) {
+                for (const auto* spell : spells) {
+                    // Check prerequisites client-side first
+                    bool prereq1Met = isKnown(spell->chainNode1);
+                    bool prereq2Met = isKnown(spell->chainNode2);
+                    bool prereq3Met = isKnown(spell->chainNode3);
+                    bool prereqsMet = prereq1Met && prereq2Met && prereq3Met;
+                    bool levelMet = (spell->reqLevel == 0 || playerLevel >= spell->reqLevel);
+                    bool alreadyKnown = isKnown(spell->spellId);
+
+                    // Dynamically determine effective state based on current prerequisites
+                    // Server sends state, but we override if prerequisites are now met
+                    uint8_t effectiveState = spell->state;
+                    if (spell->state == 1 && prereqsMet && levelMet) {
+                        // Server said unavailable, but we now meet all requirements
+                        effectiveState = 0;  // Treat as available
+                    }
+
+                    // Filter: skip unavailable spells if checkbox is unchecked
+                    // Use effectiveState so spells with newly met prereqs aren't filtered
+                    if (!showUnavailable && effectiveState == 1) {
+                        continue;
+                    }
+
+                    ImGui::TableNextRow();
+                    ImGui::PushID(static_cast<int>(spell->spellId));
+
+                    ImVec4 color;
+                    const char* statusLabel;
+                    // WotLK trainer states: 0=available, 1=unavailable, 2=known
+                    if (effectiveState == 2 || alreadyKnown) {
+                        color = ImVec4(0.3f, 0.9f, 0.3f, 1.0f);
+                        statusLabel = "Known";
+                    } else if (effectiveState == 0) {
+                        color = ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
+                        statusLabel = "Available";
+                    } else {
+                        color = ImVec4(0.6f, 0.3f, 0.3f, 1.0f);
+                        statusLabel = "Unavailable";
+                    }
+
+                    // Spell name
+                    ImGui::TableSetColumnIndex(0);
+                    const std::string& name = gameHandler.getSpellName(spell->spellId);
+                    const std::string& rank = gameHandler.getSpellRank(spell->spellId);
+                    if (!name.empty()) {
+                        if (!rank.empty())
+                            ImGui::TextColored(color, "%s (%s)", name.c_str(), rank.c_str());
+                        else
+                            ImGui::TextColored(color, "%s", name.c_str());
+                    } else {
+                        ImGui::TextColored(color, "Spell #%u", spell->spellId);
+                    }
+
+                    if (ImGui::IsItemHovered()) {
+                        ImGui::BeginTooltip();
+                        if (!name.empty()) {
+                            ImGui::Text("%s", name.c_str());
+                            if (!rank.empty()) ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f), "%s", rank.c_str());
+                        }
+                        ImGui::Text("Status: %s", statusLabel);
+                        if (spell->reqLevel > 0) {
+                            ImVec4 lvlColor = levelMet ? ImVec4(0.7f, 0.7f, 0.7f, 1.0f) : ImVec4(1.0f, 0.3f, 0.3f, 1.0f);
+                            ImGui::TextColored(lvlColor, "Required Level: %u", spell->reqLevel);
+                        }
+                        if (spell->reqSkill > 0) ImGui::Text("Required Skill: %u (value %u)", spell->reqSkill, spell->reqSkillValue);
+                        auto showPrereq = [&](uint32_t node) {
+                            if (node == 0) return;
+                            bool met = isKnown(node);
+                            const std::string& pname = gameHandler.getSpellName(node);
+                            ImVec4 pcolor = met ? ImVec4(0.3f, 0.9f, 0.3f, 1.0f) : ImVec4(1.0f, 0.3f, 0.3f, 1.0f);
+                            if (!pname.empty())
+                                ImGui::TextColored(pcolor, "Requires: %s%s", pname.c_str(), met ? " (known)" : "");
+                            else
+                                ImGui::TextColored(pcolor, "Requires: Spell #%u%s", node, met ? " (known)" : "");
+                        };
+                        showPrereq(spell->chainNode1);
+                        showPrereq(spell->chainNode2);
+                        showPrereq(spell->chainNode3);
+                        ImGui::EndTooltip();
+                    }
+
+                    // Level
+                    ImGui::TableSetColumnIndex(1);
+                    ImGui::TextColored(color, "%u", spell->reqLevel);
+
+                    // Cost
+                    ImGui::TableSetColumnIndex(2);
+                    if (spell->spellCost > 0) {
+                        uint32_t g = spell->spellCost / 10000;
+                        uint32_t s = (spell->spellCost / 100) % 100;
+                        uint32_t c = spell->spellCost % 100;
+                        bool canAfford = money >= spell->spellCost;
+                        ImVec4 costColor = canAfford ? color : ImVec4(1.0f, 0.3f, 0.3f, 1.0f);
+                        ImGui::TextColored(costColor, "%ug %us %uc", g, s, c);
+                    } else {
+                        ImGui::TextColored(color, "Free");
+                    }
+
+                    // Train button - only enabled if available, affordable, prereqs met
+                    ImGui::TableSetColumnIndex(3);
+                    // Use effectiveState so newly available spells (after learning prereqs) can be trained
+                    bool canTrain = !alreadyKnown && effectiveState == 0
+                                  && prereqsMet && levelMet
+                                  && (money >= spell->spellCost);
+
+                    // Debug logging for first 3 spells to see why buttons are disabled
+                    static int logCount = 0;
+                    static uint64_t lastTrainerGuid = 0;
+                    if (trainer.trainerGuid != lastTrainerGuid) {
+                        logCount = 0;
+                        lastTrainerGuid = trainer.trainerGuid;
+                    }
+                    if (logCount < 3) {
+                        LOG_INFO("Trainer button debug: spellId=", spell->spellId,
+                                " alreadyKnown=", alreadyKnown, " state=", (int)spell->state,
+                                " prereqsMet=", prereqsMet, " (", prereq1Met, ",", prereq2Met, ",", prereq3Met, ")",
+                                " levelMet=", levelMet,
+                                " reqLevel=", spell->reqLevel, " playerLevel=", playerLevel,
+                                " chain1=", spell->chainNode1, " chain2=", spell->chainNode2, " chain3=", spell->chainNode3,
+                                " canAfford=", (money >= spell->spellCost),
+                                " canTrain=", canTrain);
+                        logCount++;
+                    }
+
+                    if (!canTrain) ImGui::BeginDisabled();
+                    if (ImGui::SmallButton("Train")) {
+                        gameHandler.trainSpell(spell->spellId);
+                    }
+                    if (!canTrain) ImGui::EndDisabled();
+
+                    ImGui::PopID();
+                }
+            };
+
+            auto renderSpellTable = [&](const char* tableId, const std::vector<const game::TrainerSpell*>& spells) {
+                if (ImGui::BeginTable(tableId, 4,
+                        ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
+                    ImGui::TableSetupColumn("Spell", ImGuiTableColumnFlags_WidthStretch);
+                    ImGui::TableSetupColumn("Level", ImGuiTableColumnFlags_WidthFixed, 40.0f);
+                    ImGui::TableSetupColumn("Cost", ImGuiTableColumnFlags_WidthFixed, 120.0f);
+                    ImGui::TableSetupColumn("##action", ImGuiTableColumnFlags_WidthFixed, 55.0f);
+                    ImGui::TableHeadersRow();
+                    renderSpellRows(spells);
+                    ImGui::EndTable();
+                }
+            };
+
+            const auto& tabs = gameHandler.getTrainerTabs();
+            if (tabs.size() > 1) {
+                // Multiple tabs - show tab bar
+                if (ImGui::BeginTabBar("TrainerTabs")) {
+                    for (size_t i = 0; i < tabs.size(); i++) {
+                        char tabLabel[64];
+                        snprintf(tabLabel, sizeof(tabLabel), "%s (%zu)",
+                            tabs[i].name.c_str(), tabs[i].spells.size());
+
+                        if (ImGui::BeginTabItem(tabLabel)) {
+                            char tableId[32];
+                            snprintf(tableId, sizeof(tableId), "TT%zu", i);
+                            renderSpellTable(tableId, tabs[i].spells);
+                            ImGui::EndTabItem();
+                        }
+                    }
+                    ImGui::EndTabBar();
+                }
+            } else {
+                // Single tab or no categorization - flat list
+                std::vector<const game::TrainerSpell*> allSpells;
+                allSpells.reserve(trainer.spells.size());
+                for (const auto& spell : trainer.spells) {
+                    allSpells.push_back(&spell);
+                }
+                renderSpellTable("TrainerTable", allSpells);
+            }
+        }
+    }
+    ImGui::End();
+
+    if (!open) {
+        gameHandler.closeTrainer();
+    }
+}
+
+// ============================================================
+// Teleporter Panel
+// ============================================================
+
+// ============================================================
+// Escape Menu
+// ============================================================
+
+void GameScreen::renderEscapeMenu() {
+    if (!showEscapeMenu) return;
+
+    ImGuiIO& io = ImGui::GetIO();
+    float screenW = io.DisplaySize.x;
+    float screenH = io.DisplaySize.y;
+    ImVec2 size(260.0f, 220.0f);
+    ImVec2 pos((screenW - size.x) * 0.5f, (screenH - size.y) * 0.5f);
+
+    ImGui::SetNextWindowPos(pos, ImGuiCond_Always);
+    ImGui::SetNextWindowSize(size, ImGuiCond_Always);
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
+                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar;
+
+    if (ImGui::Begin("##EscapeMenu", nullptr, flags)) {
+        ImGui::Text("Game Menu");
+        ImGui::Separator();
+
+        if (ImGui::Button("Logout", ImVec2(-1, 0))) {
+            core::Application::getInstance().logoutToLogin();
+            showEscapeMenu = false;
+            showEscapeSettingsNotice = false;
+        }
+        if (ImGui::Button("Quit", ImVec2(-1, 0))) {
+            auto* renderer = core::Application::getInstance().getRenderer();
+            if (renderer) {
+                if (auto* music = renderer->getMusicManager()) {
+                    music->stopMusic(0.0f);
+                }
+            }
+            core::Application::getInstance().shutdown();
+        }
+        if (ImGui::Button("Settings", ImVec2(-1, 0))) {
+            showEscapeSettingsNotice = false;
+            showSettingsWindow = true;
+            settingsInit = false;
+            showEscapeMenu = false;
+        }
+        if (ImGui::Button("Instance Lockouts", ImVec2(-1, 0))) {
+            showInstanceLockouts_ = true;
+            showEscapeMenu = false;
+        }
+
+        ImGui::Spacing();
+        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(10.0f, 10.0f));
+        if (ImGui::Button("Back to Game", ImVec2(-1, 0))) {
+            showEscapeMenu = false;
+            showEscapeSettingsNotice = false;
+        }
+        ImGui::PopStyleVar();
+    }
+    ImGui::End();
+}
+
+// ============================================================
+// Taxi Window
+// ============================================================
+
+void GameScreen::renderTaxiWindow(game::GameHandler& gameHandler) {
+    if (!gameHandler.isTaxiWindowOpen()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 200, 150), ImGuiCond_Appearing);
+    ImGui::SetNextWindowSize(ImVec2(400, 0), ImGuiCond_Always);
+
+    bool open = true;
+    if (ImGui::Begin("Flight Master", &open, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize)) {
+        const auto& taxiData = gameHandler.getTaxiData();
+        const auto& nodes = gameHandler.getTaxiNodes();
+        uint32_t currentNode = gameHandler.getTaxiCurrentNode();
+
+        // Get current node's map to filter destinations
+        uint32_t currentMapId = 0;
+        auto curIt = nodes.find(currentNode);
+        if (curIt != nodes.end()) {
+            currentMapId = curIt->second.mapId;
+            ImGui::TextColored(ImVec4(0.5f, 1.0f, 0.5f, 1.0f), "Current: %s", curIt->second.name.c_str());
+            ImGui::Separator();
+        }
+
+        ImGui::Text("Select a destination:");
+        ImGui::Spacing();
+
+        static uint32_t selectedNodeId = 0;
+        int destCount = 0;
+        if (ImGui::BeginTable("TaxiNodes", 3, ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_RowBg)) {
+            ImGui::TableSetupColumn("Destination", ImGuiTableColumnFlags_WidthStretch);
+            ImGui::TableSetupColumn("Cost", ImGuiTableColumnFlags_WidthFixed, 120.0f);
+            ImGui::TableSetupColumn("Action", ImGuiTableColumnFlags_WidthFixed, 60.0f);
+            ImGui::TableHeadersRow();
+
+            for (const auto& [nodeId, node] : nodes) {
+                if (nodeId == currentNode) continue;
+                if (node.mapId != currentMapId) continue;
+                if (!taxiData.isNodeKnown(nodeId)) continue;
+
+                uint32_t costCopper = gameHandler.getTaxiCostTo(nodeId);
+                uint32_t gold = costCopper / 10000;
+                uint32_t silver = (costCopper / 100) % 100;
+                uint32_t copper = costCopper % 100;
+
+                ImGui::PushID(static_cast<int>(nodeId));
+                ImGui::TableNextRow();
+
+                ImGui::TableSetColumnIndex(0);
+                bool isSelected = (selectedNodeId == nodeId);
+                if (ImGui::Selectable(node.name.c_str(), isSelected,
+                                      ImGuiSelectableFlags_SpanAllColumns |
+                                      ImGuiSelectableFlags_AllowDoubleClick)) {
+                    selectedNodeId = nodeId;
+                    LOG_INFO("Taxi UI: Selected dest=", nodeId);
+                    if (ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) {
+                        LOG_INFO("Taxi UI: Double-click activate dest=", nodeId);
+                        gameHandler.activateTaxi(nodeId);
+                    }
+                }
+
+                ImGui::TableSetColumnIndex(1);
+                if (gold > 0) {
+                    ImGui::TextColored(ImVec4(0.9f, 0.8f, 0.3f, 1.0f), "%ug %us %uc", gold, silver, copper);
+                } else if (silver > 0) {
+                    ImGui::TextColored(ImVec4(0.75f, 0.75f, 0.75f, 1.0f), "%us %uc", silver, copper);
+                } else {
+                    ImGui::TextColored(ImVec4(0.72f, 0.45f, 0.2f, 1.0f), "%uc", copper);
+                }
+
+                ImGui::TableSetColumnIndex(2);
+                if (ImGui::SmallButton("Fly")) {
+                    selectedNodeId = nodeId;
+                    LOG_INFO("Taxi UI: Fly clicked dest=", nodeId);
+                    gameHandler.activateTaxi(nodeId);
+                }
+
+                ImGui::PopID();
+                destCount++;
+            }
+            ImGui::EndTable();
+        }
+
+        if (destCount == 0) {
+            ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f), "No destinations available.");
+        }
+
+        ImGui::Spacing();
+        ImGui::Separator();
+        if (selectedNodeId != 0 && ImGui::Button("Fly Selected", ImVec2(-1, 0))) {
+            LOG_INFO("Taxi UI: Fly Selected dest=", selectedNodeId);
+            gameHandler.activateTaxi(selectedNodeId);
+        }
+        if (ImGui::Button("Close", ImVec2(-1, 0))) {
+            gameHandler.closeTaxi();
+        }
+    }
+    ImGui::End();
+
+    if (!open) {
+        gameHandler.closeTaxi();
+    }
+}
+
+// ============================================================
+// Death Screen
+// ============================================================
+
+void GameScreen::renderDeathScreen(game::GameHandler& gameHandler) {
+    if (!gameHandler.showDeathDialog()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
+
+    // Dark red overlay covering the whole screen
+    ImGui::SetNextWindowPos(ImVec2(0, 0));
+    ImGui::SetNextWindowSize(ImVec2(screenW, screenH));
+    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.15f, 0.0f, 0.0f, 0.45f));
+    ImGui::Begin("##DeathOverlay", nullptr,
+        ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoInputs |
+        ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoFocusOnAppearing);
+    ImGui::End();
+    ImGui::PopStyleColor();
+
+    // "Release Spirit" dialog centered on screen
+    float dlgW = 280.0f;
+    float dlgH = 100.0f;
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - dlgW / 2, screenH * 0.35f), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(dlgW, dlgH), ImGuiCond_Always);
+
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.0f);
+    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.1f, 0.0f, 0.0f, 0.9f));
+    ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.6f, 0.1f, 0.1f, 1.0f));
+
+    if (ImGui::Begin("##DeathDialog", nullptr,
+            ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
+            ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar)) {
+
+        ImGui::Spacing();
+        // Center "You are dead." text
+        const char* deathText = "You are dead.";
+        float textW = ImGui::CalcTextSize(deathText).x;
+        ImGui::SetCursorPosX((dlgW - textW) / 2);
+        ImGui::TextColored(ImVec4(1.0f, 0.2f, 0.2f, 1.0f), "%s", deathText);
+
+        ImGui::Spacing();
+        ImGui::Spacing();
+
+        // Center the Release Spirit button
+        float btnW = 180.0f;
+        ImGui::SetCursorPosX((dlgW - btnW) / 2);
+        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.5f, 0.1f, 0.1f, 1.0f));
+        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.7f, 0.15f, 0.15f, 1.0f));
+        if (ImGui::Button("Release Spirit", ImVec2(btnW, 30))) {
+            gameHandler.releaseSpirit();
+        }
+        ImGui::PopStyleColor(2);
+    }
+    ImGui::End();
+    ImGui::PopStyleColor(2);
+    ImGui::PopStyleVar();
+}
+
+void GameScreen::renderResurrectDialog(game::GameHandler& gameHandler) {
+    if (!gameHandler.showResurrectDialog()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
+
+    float dlgW = 300.0f;
+    float dlgH = 110.0f;
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - dlgW / 2, screenH * 0.3f), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(dlgW, dlgH), ImGuiCond_Always);
+
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.0f);
+    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.1f, 0.1f, 0.15f, 0.95f));
+    ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.4f, 0.4f, 0.8f, 1.0f));
+
+    if (ImGui::Begin("##ResurrectDialog", nullptr,
+            ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
+            ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar)) {
+
+        ImGui::Spacing();
+        const char* text = "Return to life?";
+        float textW = ImGui::CalcTextSize(text).x;
+        ImGui::SetCursorPosX((dlgW - textW) / 2);
+        ImGui::TextColored(ImVec4(0.8f, 0.9f, 1.0f, 1.0f), "%s", text);
+
+        ImGui::Spacing();
+        ImGui::Spacing();
+
+        float btnW = 100.0f;
+        float spacing = 20.0f;
+        ImGui::SetCursorPosX((dlgW - btnW * 2 - spacing) / 2);
+
+        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.2f, 0.5f, 0.2f, 1.0f));
+        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.3f, 0.7f, 0.3f, 1.0f));
+        if (ImGui::Button("Accept", ImVec2(btnW, 30))) {
+            gameHandler.acceptResurrect();
+        }
+        ImGui::PopStyleColor(2);
+
+        ImGui::SameLine(0, spacing);
+
+        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.5f, 0.2f, 0.2f, 1.0f));
+        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.7f, 0.3f, 0.3f, 1.0f));
+        if (ImGui::Button("Decline", ImVec2(btnW, 30))) {
+            gameHandler.declineResurrect();
+        }
+        ImGui::PopStyleColor(2);
+    }
+    ImGui::End();
+    ImGui::PopStyleColor(2);
+    ImGui::PopStyleVar();
+}
+
+// ============================================================
+// Settings Window
+// ============================================================
+
+void GameScreen::renderSettingsWindow() {
+    if (!showSettingsWindow) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    auto* renderer = core::Application::getInstance().getRenderer();
+    if (!window) return;
+
+    static const int kResolutions[][2] = {
+        {1280, 720},
+        {1600, 900},
+        {1920, 1080},
+        {2560, 1440},
+        {3840, 2160},
+    };
+    static const int kResCount = sizeof(kResolutions) / sizeof(kResolutions[0]);
+    constexpr int kDefaultResW = 1920;
+    constexpr int kDefaultResH = 1080;
+    constexpr bool kDefaultFullscreen = false;
+    constexpr bool kDefaultVsync = true;
+    constexpr bool kDefaultShadows = true;
+    constexpr int kDefaultMusicVolume = 30;
+    constexpr float kDefaultMouseSensitivity = 0.2f;
+    constexpr bool kDefaultInvertMouse = false;
+    constexpr int kDefaultGroundClutterDensity = 100;
+
+    int defaultResIndex = 0;
+    for (int i = 0; i < kResCount; i++) {
+        if (kResolutions[i][0] == kDefaultResW && kResolutions[i][1] == kDefaultResH) {
+            defaultResIndex = i;
+            break;
+        }
+    }
+
+    if (!settingsInit) {
+        pendingFullscreen = window->isFullscreen();
+        pendingVsync = window->isVsyncEnabled();
+        if (renderer) {
+            renderer->setShadowsEnabled(pendingShadows);
+            renderer->setShadowDistance(pendingShadowDistance);
+            // Read non-volume settings from actual state (volumes come from saved settings)
+            if (auto* cameraController = renderer->getCameraController()) {
+                pendingMouseSensitivity = cameraController->getMouseSensitivity();
+                pendingInvertMouse = cameraController->isInvertMouse();
+                cameraController->setExtendedZoom(pendingExtendedZoom);
+            }
+        }
+        pendingResIndex = 0;
+        int curW = window->getWidth();
+        int curH = window->getHeight();
+        for (int i = 0; i < kResCount; i++) {
+            if (kResolutions[i][0] == curW && kResolutions[i][1] == curH) {
+                pendingResIndex = i;
+                break;
+            }
+        }
+        pendingUiOpacity = static_cast<int>(std::lround(uiOpacity_ * 100.0f));
+        pendingMinimapRotate = minimapRotate_;
+        pendingMinimapSquare = minimapSquare_;
+        pendingMinimapNpcDots = minimapNpcDots_;
+        if (renderer) {
+            if (auto* minimap = renderer->getMinimap()) {
+                minimap->setRotateWithCamera(minimapRotate_);
+                minimap->setSquareShape(minimapSquare_);
+            }
+            if (auto* zm = renderer->getZoneManager()) {
+                pendingUseOriginalSoundtrack = zm->getUseOriginalSoundtrack();
+            }
+        }
+        settingsInit = true;
+    }
+
+    ImGuiIO& io = ImGui::GetIO();
+    float screenW = io.DisplaySize.x;
+    float screenH = io.DisplaySize.y;
+    ImVec2 size(520.0f, std::min(screenH * 0.9f, 720.0f));
+    ImVec2 pos((screenW - size.x) * 0.5f, (screenH - size.y) * 0.5f);
+
+    ImGui::SetNextWindowPos(pos, ImGuiCond_Always);
+    ImGui::SetNextWindowSize(size, ImGuiCond_Always);
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
+                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar;
+
+    if (ImGui::Begin("##SettingsWindow", nullptr, flags)) {
+        ImGui::Text("Settings");
+        ImGui::Separator();
+
+        if (ImGui::BeginTabBar("SettingsTabs", ImGuiTabBarFlags_None)) {
+            // ============================================================
+            // VIDEO TAB
+            // ============================================================
+            if (ImGui::BeginTabItem("Video")) {
+                ImGui::Spacing();
+
+                if (ImGui::Checkbox("Fullscreen", &pendingFullscreen)) {
+                    window->setFullscreen(pendingFullscreen);
+                    saveSettings();
+                }
+                if (ImGui::Checkbox("VSync", &pendingVsync)) {
+                    window->setVsync(pendingVsync);
+                    saveSettings();
+                }
+                if (ImGui::Checkbox("Shadows", &pendingShadows)) {
+                    if (renderer) renderer->setShadowsEnabled(pendingShadows);
+                    saveSettings();
+                }
+                if (pendingShadows) {
+                    ImGui::SameLine();
+                    ImGui::SetNextItemWidth(150.0f);
+                    if (ImGui::SliderFloat("Distance##shadow", &pendingShadowDistance, 40.0f, 500.0f, "%.0f")) {
+                        if (renderer) renderer->setShadowDistance(pendingShadowDistance);
+                        saveSettings();
+                    }
+                }
+                if (ImGui::Checkbox("Water Refraction", &pendingWaterRefraction)) {
+                    if (renderer) renderer->setWaterRefractionEnabled(pendingWaterRefraction);
+                    saveSettings();
+                }
+                {
+                    const char* aaLabels[] = { "Off", "2x MSAA", "4x MSAA", "8x MSAA" };
+                    bool fsr2Active = renderer && renderer->isFSR2Enabled();
+                    if (fsr2Active) {
+                        ImGui::BeginDisabled();
+                        int disabled = 0;
+                        ImGui::Combo("Anti-Aliasing (FSR3)", &disabled, "Off (FSR3 active)\0", 1);
+                        ImGui::EndDisabled();
+                    } else if (ImGui::Combo("Anti-Aliasing", &pendingAntiAliasing, aaLabels, 4)) {
+                        static const VkSampleCountFlagBits aaSamples[] = {
+                            VK_SAMPLE_COUNT_1_BIT, VK_SAMPLE_COUNT_2_BIT,
+                            VK_SAMPLE_COUNT_4_BIT, VK_SAMPLE_COUNT_8_BIT
+                        };
+                        if (renderer) renderer->setMsaaSamples(aaSamples[pendingAntiAliasing]);
+                        saveSettings();
+                    }
+                }
+                // FSR Upscaling
+                {
+                    // FSR mode selection: Off, FSR 1.0 (Spatial), FSR 3.x (Temporal)
+                    const char* fsrModeLabels[] = { "Off", "FSR 1.0 (Spatial)", "FSR 3.x (Temporal)" };
+                    int fsrMode = pendingUpscalingMode;
+                    if (ImGui::Combo("Upscaling", &fsrMode, fsrModeLabels, 3)) {
+                        pendingUpscalingMode = fsrMode;
+                        pendingFSR = (fsrMode == 1);
+                        if (renderer) {
+                            renderer->setFSREnabled(fsrMode == 1);
+                            renderer->setFSR2Enabled(fsrMode == 2);
+                        }
+                        saveSettings();
+                    }
+                    if (fsrMode > 0) {
+                        if (fsrMode == 2 && renderer) {
+                            ImGui::TextDisabled("FSR3 backend: %s",
+                                renderer->isAmdFsr2SdkAvailable() ? "AMD FidelityFX SDK" : "Internal fallback");
+                            if (renderer->isAmdFsr3FramegenSdkAvailable()) {
+                                if (ImGui::Checkbox("AMD FSR3 Frame Generation (Experimental)", &pendingAMDFramegen)) {
+                                    renderer->setAmdFsr3FramegenEnabled(pendingAMDFramegen);
+                                    saveSettings();
+                                }
+                                const char* runtimeStatus = "Unavailable";
+                                if (renderer->isAmdFsr3FramegenRuntimeActive()) {
+                                    runtimeStatus = "Active";
+                                } else if (renderer->isAmdFsr3FramegenRuntimeReady()) {
+                                    runtimeStatus = "Ready";
+                                } else {
+                                    runtimeStatus = "Unavailable";
+                                }
+                                ImGui::TextDisabled("Runtime: %s (%s)",
+                                    runtimeStatus, renderer->getAmdFsr3FramegenRuntimePath());
+                                if (!renderer->isAmdFsr3FramegenRuntimeReady()) {
+                                    const std::string& runtimeErr = renderer->getAmdFsr3FramegenRuntimeError();
+                                    if (!runtimeErr.empty()) {
+                                        ImGui::TextDisabled("Reason: %s", runtimeErr.c_str());
+                                    }
+                                }
+                            } else {
+                                ImGui::BeginDisabled();
+                                bool disabledFg = false;
+                                ImGui::Checkbox("AMD FSR3 Frame Generation (Experimental)", &disabledFg);
+                                ImGui::EndDisabled();
+                                ImGui::TextDisabled("Requires FidelityFX-SDK framegen headers.");
+                            }
+                        }
+                        const char* fsrQualityLabels[] = { "Native (100%)", "Ultra Quality (77%)", "Quality (67%)", "Balanced (59%)" };
+                        static const float fsrScaleFactors[] = { 0.77f, 0.67f, 0.59f, 1.00f };
+                        static const int displayToInternal[] = { 3, 0, 1, 2 };
+                        pendingFSRQuality = std::clamp(pendingFSRQuality, 0, 3);
+                        int fsrQualityDisplay = 0;
+                        for (int i = 0; i < 4; ++i) {
+                            if (displayToInternal[i] == pendingFSRQuality) {
+                                fsrQualityDisplay = i;
+                                break;
+                            }
+                        }
+                        if (ImGui::Combo("FSR Quality", &fsrQualityDisplay, fsrQualityLabels, 4)) {
+                            pendingFSRQuality = displayToInternal[fsrQualityDisplay];
+                            if (renderer) renderer->setFSRQuality(fsrScaleFactors[pendingFSRQuality]);
+                            saveSettings();
+                        }
+                        if (ImGui::SliderFloat("FSR Sharpness", &pendingFSRSharpness, 0.0f, 2.0f, "%.1f")) {
+                            if (renderer) renderer->setFSRSharpness(pendingFSRSharpness);
+                            saveSettings();
+                        }
+                        if (fsrMode == 2) {
+                            ImGui::SeparatorText("FSR3 Tuning");
+                            if (ImGui::SliderFloat("Jitter Sign", &pendingFSR2JitterSign, -2.0f, 2.0f, "%.2f")) {
+                                if (renderer) {
+                                    renderer->setFSR2DebugTuning(
+                                        pendingFSR2JitterSign,
+                                        pendingFSR2MotionVecScaleX,
+                                        pendingFSR2MotionVecScaleY);
+                                }
+                                saveSettings();
+                            }
+                            ImGui::TextDisabled("Tip: 0.38 is the current recommended default.");
+                        }
+                    }
+                }
+                if (ImGui::SliderInt("Ground Clutter Density", &pendingGroundClutterDensity, 0, 150, "%d%%")) {
+                    if (renderer) {
+                        if (auto* tm = renderer->getTerrainManager()) {
+                            tm->setGroundClutterDensityScale(static_cast<float>(pendingGroundClutterDensity) / 100.0f);
+                        }
+                    }
+                    saveSettings();
+                }
+                if (ImGui::Checkbox("Normal Mapping", &pendingNormalMapping)) {
+                    if (renderer) {
+                        if (auto* wr = renderer->getWMORenderer()) {
+                            wr->setNormalMappingEnabled(pendingNormalMapping);
+                        }
+                        if (auto* cr = renderer->getCharacterRenderer()) {
+                            cr->setNormalMappingEnabled(pendingNormalMapping);
+                        }
+                    }
+                    saveSettings();
+                }
+                if (pendingNormalMapping) {
+                    if (ImGui::SliderFloat("Normal Map Strength", &pendingNormalMapStrength, 0.0f, 2.0f, "%.1f")) {
+                        if (renderer) {
+                            if (auto* wr = renderer->getWMORenderer()) {
+                                wr->setNormalMapStrength(pendingNormalMapStrength);
+                            }
+                            if (auto* cr = renderer->getCharacterRenderer()) {
+                                cr->setNormalMapStrength(pendingNormalMapStrength);
+                            }
+                        }
+                        saveSettings();
+                    }
+                }
+                if (ImGui::Checkbox("Parallax Mapping", &pendingPOM)) {
+                    if (renderer) {
+                        if (auto* wr = renderer->getWMORenderer()) {
+                            wr->setPOMEnabled(pendingPOM);
+                        }
+                        if (auto* cr = renderer->getCharacterRenderer()) {
+                            cr->setPOMEnabled(pendingPOM);
+                        }
+                    }
+                    saveSettings();
+                }
+                if (pendingPOM) {
+                    const char* pomLabels[] = { "Low", "Medium", "High" };
+                    if (ImGui::Combo("Parallax Quality", &pendingPOMQuality, pomLabels, 3)) {
+                        if (renderer) {
+                            if (auto* wr = renderer->getWMORenderer()) {
+                                wr->setPOMQuality(pendingPOMQuality);
+                            }
+                            if (auto* cr = renderer->getCharacterRenderer()) {
+                                cr->setPOMQuality(pendingPOMQuality);
+                            }
+                        }
+                        saveSettings();
+                    }
+                }
+
+                const char* resLabel = "Resolution";
+                const char* resItems[kResCount];
+                char resBuf[kResCount][16];
+                for (int i = 0; i < kResCount; i++) {
+                    snprintf(resBuf[i], sizeof(resBuf[i]), "%dx%d", kResolutions[i][0], kResolutions[i][1]);
+                    resItems[i] = resBuf[i];
+                }
+                if (ImGui::Combo(resLabel, &pendingResIndex, resItems, kResCount)) {
+                    window->applyResolution(kResolutions[pendingResIndex][0], kResolutions[pendingResIndex][1]);
+                    saveSettings();
+                }
+
+                ImGui::Spacing();
+                ImGui::Separator();
+                ImGui::Spacing();
+
+                if (ImGui::Button("Restore Video Defaults", ImVec2(-1, 0))) {
+                    pendingFullscreen = kDefaultFullscreen;
+                    pendingVsync = kDefaultVsync;
+                    pendingShadows = kDefaultShadows;
+                    pendingShadowDistance = 300.0f;
+                    pendingGroundClutterDensity = kDefaultGroundClutterDensity;
+                    pendingAntiAliasing = 0;
+                    pendingNormalMapping = true;
+                    pendingNormalMapStrength = 0.8f;
+                    pendingPOM = true;
+                    pendingPOMQuality = 1;
+                    pendingResIndex = defaultResIndex;
+                    window->setFullscreen(pendingFullscreen);
+                    window->setVsync(pendingVsync);
+                    window->applyResolution(kResolutions[pendingResIndex][0], kResolutions[pendingResIndex][1]);
+                    pendingWaterRefraction = false;
+                    if (renderer) {
+                        renderer->setShadowsEnabled(pendingShadows);
+                        renderer->setShadowDistance(pendingShadowDistance);
+                    }
+                    if (renderer) renderer->setWaterRefractionEnabled(pendingWaterRefraction);
+                    if (renderer) renderer->setMsaaSamples(VK_SAMPLE_COUNT_1_BIT);
+                    if (renderer) {
+                        if (auto* tm = renderer->getTerrainManager()) {
+                            tm->setGroundClutterDensityScale(static_cast<float>(pendingGroundClutterDensity) / 100.0f);
+                        }
+                    }
+                    if (renderer) {
+                        if (auto* wr = renderer->getWMORenderer()) {
+                            wr->setNormalMappingEnabled(pendingNormalMapping);
+                            wr->setNormalMapStrength(pendingNormalMapStrength);
+                            wr->setPOMEnabled(pendingPOM);
+                            wr->setPOMQuality(pendingPOMQuality);
+                        }
+                        if (auto* cr = renderer->getCharacterRenderer()) {
+                            cr->setNormalMappingEnabled(pendingNormalMapping);
+                            cr->setNormalMapStrength(pendingNormalMapStrength);
+                            cr->setPOMEnabled(pendingPOM);
+                            cr->setPOMQuality(pendingPOMQuality);
+                        }
+                    }
+                    saveSettings();
+                }
+
+                ImGui::EndTabItem();
+            }
+
+            // ============================================================
+            // AUDIO TAB
+            // ============================================================
+            if (ImGui::BeginTabItem("Audio")) {
+                ImGui::Spacing();
+                ImGui::BeginChild("AudioSettings", ImVec2(0, 360), true);
+
+                // Helper lambda to apply audio settings
+                auto applyAudioSettings = [&]() {
+                    if (!renderer) return;
+                    float masterScale = soundMuted_ ? 0.0f : static_cast<float>(pendingMasterVolume) / 100.0f;
+                    audio::AudioEngine::instance().setMasterVolume(masterScale);
+                    if (auto* music = renderer->getMusicManager()) {
+                        music->setVolume(pendingMusicVolume);
+                    }
+                    if (auto* ambient = renderer->getAmbientSoundManager()) {
+                        ambient->setVolumeScale(pendingAmbientVolume / 100.0f);
+                    }
+                    if (auto* ui = renderer->getUiSoundManager()) {
+                        ui->setVolumeScale(pendingUiVolume / 100.0f);
+                    }
+                    if (auto* combat = renderer->getCombatSoundManager()) {
+                        combat->setVolumeScale(pendingCombatVolume / 100.0f);
+                    }
+                    if (auto* spell = renderer->getSpellSoundManager()) {
+                        spell->setVolumeScale(pendingSpellVolume / 100.0f);
+                    }
+                    if (auto* movement = renderer->getMovementSoundManager()) {
+                        movement->setVolumeScale(pendingMovementVolume / 100.0f);
+                    }
+                    if (auto* footstep = renderer->getFootstepManager()) {
+                        footstep->setVolumeScale(pendingFootstepVolume / 100.0f);
+                    }
+                    if (auto* npcVoice = renderer->getNpcVoiceManager()) {
+                        npcVoice->setVolumeScale(pendingNpcVoiceVolume / 100.0f);
+                    }
+                    if (auto* mount = renderer->getMountSoundManager()) {
+                        mount->setVolumeScale(pendingMountVolume / 100.0f);
+                    }
+                    if (auto* activity = renderer->getActivitySoundManager()) {
+                        activity->setVolumeScale(pendingActivityVolume / 100.0f);
+                    }
+                    saveSettings();
+                };
+
+                ImGui::Text("Master Volume");
+                if (ImGui::SliderInt("##MasterVolume", &pendingMasterVolume, 0, 100, "%d%%")) {
+                    applyAudioSettings();
+                }
+                ImGui::Separator();
+
+                if (ImGui::Checkbox("Enable WoWee Music", &pendingUseOriginalSoundtrack)) {
+                    if (renderer) {
+                        if (auto* zm = renderer->getZoneManager()) {
+                            zm->setUseOriginalSoundtrack(pendingUseOriginalSoundtrack);
+                        }
+                    }
+                    saveSettings();
+                }
+                if (ImGui::IsItemHovered())
+                    ImGui::SetTooltip("Include WoWee music tracks in zone music rotation");
+                ImGui::Separator();
+
+                ImGui::Text("Music");
+                if (ImGui::SliderInt("##MusicVolume", &pendingMusicVolume, 0, 100, "%d%%")) {
+                    applyAudioSettings();
+                }
+
+                ImGui::Spacing();
+                ImGui::Text("Ambient Sounds");
+                if (ImGui::SliderInt("##AmbientVolume", &pendingAmbientVolume, 0, 100, "%d%%")) {
+                    applyAudioSettings();
+                }
+                ImGui::TextWrapped("Weather, zones, cities, emitters");
+
+                ImGui::Spacing();
+                ImGui::Text("UI Sounds");
+                if (ImGui::SliderInt("##UiVolume", &pendingUiVolume, 0, 100, "%d%%")) {
+                    applyAudioSettings();
+                }
+                ImGui::TextWrapped("Buttons, loot, quest complete");
+
+                ImGui::Spacing();
+                ImGui::Text("Combat Sounds");
+                if (ImGui::SliderInt("##CombatVolume", &pendingCombatVolume, 0, 100, "%d%%")) {
+                    applyAudioSettings();
+                }
+                ImGui::TextWrapped("Weapon swings, impacts, grunts");
+
+                ImGui::Spacing();
+                ImGui::Text("Spell Sounds");
+                if (ImGui::SliderInt("##SpellVolume", &pendingSpellVolume, 0, 100, "%d%%")) {
+                    applyAudioSettings();
+                }
+                ImGui::TextWrapped("Magic casting and impacts");
+
+                ImGui::Spacing();
+                ImGui::Text("Movement Sounds");
+                if (ImGui::SliderInt("##MovementVolume", &pendingMovementVolume, 0, 100, "%d%%")) {
+                    applyAudioSettings();
+                }
+                ImGui::TextWrapped("Water splashes, jump/land");
+
+                ImGui::Spacing();
+                ImGui::Text("Footsteps");
+                if (ImGui::SliderInt("##FootstepVolume", &pendingFootstepVolume, 0, 100, "%d%%")) {
+                    applyAudioSettings();
+                }
+
+                ImGui::Spacing();
+                ImGui::Text("NPC Voices");
+                if (ImGui::SliderInt("##NpcVoiceVolume", &pendingNpcVoiceVolume, 0, 100, "%d%%")) {
+                    applyAudioSettings();
+                }
+
+                ImGui::Spacing();
+                ImGui::Text("Mount Sounds");
+                if (ImGui::SliderInt("##MountVolume", &pendingMountVolume, 0, 100, "%d%%")) {
+                    applyAudioSettings();
+                }
+
+                ImGui::Spacing();
+                ImGui::Text("Activity Sounds");
+                if (ImGui::SliderInt("##ActivityVolume", &pendingActivityVolume, 0, 100, "%d%%")) {
+                    applyAudioSettings();
+                }
+                ImGui::TextWrapped("Swimming, eating, drinking");
+
+                ImGui::EndChild();
+
+                if (ImGui::Button("Restore Audio Defaults", ImVec2(-1, 0))) {
+                    pendingMasterVolume = 100;
+                    pendingMusicVolume = kDefaultMusicVolume;
+                    pendingAmbientVolume = 100;
+                    pendingUiVolume = 100;
+                    pendingCombatVolume = 100;
+                    pendingSpellVolume = 100;
+                    pendingMovementVolume = 100;
+                    pendingFootstepVolume = 100;
+                    pendingNpcVoiceVolume = 100;
+                    pendingMountVolume = 100;
+                    pendingActivityVolume = 100;
+                    applyAudioSettings();
+                }
+
+                ImGui::EndTabItem();
+            }
+
+            // ============================================================
+            // GAMEPLAY TAB
+            // ============================================================
+            if (ImGui::BeginTabItem("Gameplay")) {
+                ImGui::Spacing();
+
+                ImGui::Text("Controls");
+                ImGui::Separator();
+                if (ImGui::SliderFloat("Mouse Sensitivity", &pendingMouseSensitivity, 0.05f, 1.0f, "%.2f")) {
+                    if (renderer) {
+                        if (auto* cameraController = renderer->getCameraController()) {
+                            cameraController->setMouseSensitivity(pendingMouseSensitivity);
+                        }
+                    }
+                    saveSettings();
+                }
+                if (ImGui::Checkbox("Invert Mouse", &pendingInvertMouse)) {
+                    if (renderer) {
+                        if (auto* cameraController = renderer->getCameraController()) {
+                            cameraController->setInvertMouse(pendingInvertMouse);
+                        }
+                    }
+                    saveSettings();
+                }
+                if (ImGui::Checkbox("Extended Camera Zoom", &pendingExtendedZoom)) {
+                    if (renderer) {
+                        if (auto* cameraController = renderer->getCameraController()) {
+                            cameraController->setExtendedZoom(pendingExtendedZoom);
+                        }
+                    }
+                    saveSettings();
+                }
+                if (ImGui::IsItemHovered())
+                    ImGui::SetTooltip("Allow the camera to zoom out further than normal");
+
+                ImGui::Spacing();
+                ImGui::Spacing();
+
+                ImGui::Text("Interface");
+                ImGui::Separator();
+                if (ImGui::SliderInt("UI Opacity", &pendingUiOpacity, 20, 100, "%d%%")) {
+                    uiOpacity_ = static_cast<float>(pendingUiOpacity) / 100.0f;
+                    saveSettings();
+                }
+                if (ImGui::Checkbox("Rotate Minimap", &pendingMinimapRotate)) {
+                    // Force north-up minimap.
+                    minimapRotate_ = false;
+                    pendingMinimapRotate = false;
+                    if (renderer) {
+                        if (auto* minimap = renderer->getMinimap()) {
+                            minimap->setRotateWithCamera(false);
+                        }
+                    }
+                    saveSettings();
+                }
+                if (ImGui::Checkbox("Square Minimap", &pendingMinimapSquare)) {
+                    minimapSquare_ = pendingMinimapSquare;
+                    if (renderer) {
+                        if (auto* minimap = renderer->getMinimap()) {
+                            minimap->setSquareShape(minimapSquare_);
+                        }
+                    }
+                    saveSettings();
+                }
+                if (ImGui::Checkbox("Show Nearby NPC Dots", &pendingMinimapNpcDots)) {
+                    minimapNpcDots_ = pendingMinimapNpcDots;
+                    saveSettings();
+                }
+                // Zoom controls
+                ImGui::Text("Minimap Zoom:");
+                ImGui::SameLine();
+                if (ImGui::Button("  -  ")) {
+                    if (renderer) {
+                        if (auto* minimap = renderer->getMinimap()) {
+                            minimap->zoomOut();
+                            saveSettings();
+                        }
+                    }
+                }
+                ImGui::SameLine();
+                if (ImGui::Button("  +  ")) {
+                    if (renderer) {
+                        if (auto* minimap = renderer->getMinimap()) {
+                            minimap->zoomIn();
+                            saveSettings();
+                        }
+                    }
+                }
+
+                ImGui::Spacing();
+                ImGui::Text("Loot");
+                ImGui::Separator();
+                if (ImGui::Checkbox("Auto Loot", &pendingAutoLoot)) {
+                    saveSettings();  // per-frame sync applies pendingAutoLoot to gameHandler
+                }
+                if (ImGui::IsItemHovered())
+                    ImGui::SetTooltip("Automatically pick up all items when looting");
+
+                ImGui::Spacing();
+                ImGui::Text("Bags");
+                ImGui::Separator();
+                if (ImGui::Checkbox("Separate Bag Windows", &pendingSeparateBags)) {
+                    inventoryScreen.setSeparateBags(pendingSeparateBags);
+                    saveSettings();
+                }
+
+                ImGui::Spacing();
+                ImGui::Separator();
+                ImGui::Spacing();
+
+                if (ImGui::Button("Restore Gameplay Defaults", ImVec2(-1, 0))) {
+                    pendingMouseSensitivity = kDefaultMouseSensitivity;
+                    pendingInvertMouse = kDefaultInvertMouse;
+                    pendingExtendedZoom = false;
+                    pendingUiOpacity = 65;
+                    pendingMinimapRotate = false;
+                    pendingMinimapSquare = false;
+                    pendingMinimapNpcDots = false;
+                    pendingSeparateBags = true;
+                    inventoryScreen.setSeparateBags(true);
+                    uiOpacity_ = 0.65f;
+                    minimapRotate_ = false;
+                    minimapSquare_ = false;
+                    minimapNpcDots_ = false;
+                    if (renderer) {
+                        if (auto* cameraController = renderer->getCameraController()) {
+                            cameraController->setMouseSensitivity(pendingMouseSensitivity);
+                            cameraController->setInvertMouse(pendingInvertMouse);
+                            cameraController->setExtendedZoom(pendingExtendedZoom);
+                        }
+                        if (auto* minimap = renderer->getMinimap()) {
+                            minimap->setRotateWithCamera(minimapRotate_);
+                            minimap->setSquareShape(minimapSquare_);
+                        }
+                    }
+                    saveSettings();
+                }
+
+                ImGui::EndTabItem();
+            }
+
+            // ============================================================
+            // CHAT TAB
+            // ============================================================
+            if (ImGui::BeginTabItem("Chat")) {
+                ImGui::Spacing();
+
+                ImGui::Text("Appearance");
+                ImGui::Separator();
+
+                if (ImGui::Checkbox("Show Timestamps", &chatShowTimestamps_)) {
+                    saveSettings();
+                }
+                ImGui::SetItemTooltip("Show [HH:MM] before each chat message");
+
+                const char* fontSizes[] = { "Small", "Medium", "Large" };
+                if (ImGui::Combo("Chat Font Size", &chatFontSize_, fontSizes, 3)) {
+                    saveSettings();
+                }
+
+                ImGui::Spacing();
+                ImGui::Spacing();
+                ImGui::Text("Auto-Join Channels");
+                ImGui::Separator();
+
+                if (ImGui::Checkbox("General", &chatAutoJoinGeneral_)) saveSettings();
+                if (ImGui::Checkbox("Trade", &chatAutoJoinTrade_)) saveSettings();
+                if (ImGui::Checkbox("LocalDefense", &chatAutoJoinLocalDefense_)) saveSettings();
+                if (ImGui::Checkbox("LookingForGroup", &chatAutoJoinLFG_)) saveSettings();
+                if (ImGui::Checkbox("Local", &chatAutoJoinLocal_)) saveSettings();
+
+                ImGui::Spacing();
+                ImGui::Spacing();
+                ImGui::Text("Joined Channels");
+                ImGui::Separator();
+
+                ImGui::TextDisabled("Use /join and /leave commands in chat to manage channels.");
+
+                ImGui::Spacing();
+                ImGui::Separator();
+                ImGui::Spacing();
+
+                if (ImGui::Button("Restore Chat Defaults", ImVec2(-1, 0))) {
+                    chatShowTimestamps_ = false;
+                    chatFontSize_ = 1;
+                    chatAutoJoinGeneral_ = true;
+                    chatAutoJoinTrade_ = true;
+                    chatAutoJoinLocalDefense_ = true;
+                    chatAutoJoinLFG_ = true;
+                    chatAutoJoinLocal_ = true;
+                    saveSettings();
+                }
+
+                ImGui::EndTabItem();
+            }
+
+            // ============================================================
+            // ABOUT TAB
+            // ============================================================
+            if (ImGui::BeginTabItem("About")) {
+                ImGui::Spacing();
+                ImGui::Spacing();
+
+                ImGui::TextWrapped("WoWee - World of Warcraft Client Emulator");
+                ImGui::Spacing();
+                ImGui::Separator();
+                ImGui::Spacing();
+
+                ImGui::Text("Developer");
+                ImGui::Indent();
+                ImGui::Text("Kelsi Davis");
+                ImGui::Unindent();
+                ImGui::Spacing();
+
+                ImGui::Text("GitHub");
+                ImGui::Indent();
+                ImGui::TextColored(ImVec4(0.4f, 0.7f, 1.0f, 1.0f), "https://github.com/Kelsidavis/WoWee");
+                if (ImGui::IsItemHovered()) {
+                    ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
+                    ImGui::SetTooltip("Click to copy");
+                }
+                if (ImGui::IsItemClicked()) {
+                    ImGui::SetClipboardText("https://github.com/Kelsidavis/WoWee");
+                }
+                ImGui::Unindent();
+                ImGui::Spacing();
+
+                ImGui::Text("Contact");
+                ImGui::Indent();
+                ImGui::TextColored(ImVec4(0.4f, 0.7f, 1.0f, 1.0f), "github.com/Kelsidavis");
+                if (ImGui::IsItemHovered()) {
+                    ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
+                    ImGui::SetTooltip("Click to copy");
+                }
+                if (ImGui::IsItemClicked()) {
+                    ImGui::SetClipboardText("https://github.com/Kelsidavis");
+                }
+                ImGui::Unindent();
+
+                ImGui::Spacing();
+                ImGui::Separator();
+                ImGui::Spacing();
+
+                ImGui::TextWrapped("A multi-expansion WoW client supporting Classic, TBC, and WotLK (3.3.5a).");
+                ImGui::Spacing();
+                ImGui::TextDisabled("Built with Vulkan, SDL2, and ImGui");
+
+                ImGui::EndTabItem();
+            }
+
+            ImGui::EndTabBar();
+        }
+
+        ImGui::Spacing();
+        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(10.0f, 10.0f));
+        if (ImGui::Button("Back to Game", ImVec2(-1, 0))) {
+            showSettingsWindow = false;
+        }
+        ImGui::PopStyleVar();
+    }
+    ImGui::End();
 }
 
 void GameScreen::renderQuestMarkers(game::GameHandler& gameHandler) {
     const auto& statuses = gameHandler.getNpcQuestStatuses();
     if (statuses.empty()) return;
 
-    auto* renderer = services_.renderer;
+    auto* renderer = core::Application::getInstance().getRenderer();
     auto* camera = renderer ? renderer->getCamera() : nullptr;
-    auto* window = services_.window;
+    auto* window = core::Application::getInstance().getWindow();
     if (!camera || !window) return;
 
     float screenW = static_cast<float>(window->getWidth());
@@ -5380,10 +7901,10 @@ void GameScreen::renderQuestMarkers(game::GameHandler& gameHandler) {
 
 void GameScreen::renderMinimapMarkers(game::GameHandler& gameHandler) {
     const auto& statuses = gameHandler.getNpcQuestStatuses();
-    auto* renderer = services_.renderer;
+    auto* renderer = core::Application::getInstance().getRenderer();
     auto* camera = renderer ? renderer->getCamera() : nullptr;
     auto* minimap = renderer ? renderer->getMinimap() : nullptr;
-    auto* window = services_.window;
+    auto* window = core::Application::getInstance().getWindow();
     if (!camera || !minimap || !window) return;
 
     float screenW = static_cast<float>(window->getWidth());
@@ -5408,9 +7929,7 @@ void GameScreen::renderMinimapMarkers(game::GameHandler& gameHandler) {
     float sinB = 0.0f;
     if (minimap->isRotateWithCamera()) {
         glm::vec3 fwd = camera->getForward();
-        // Render space: +X=West, +Y=North. Camera fwd=(cos(yaw),sin(yaw)).
-        // Clockwise bearing from North: atan2(fwd.y, -fwd.x).
-        bearing = std::atan2(fwd.y, -fwd.x);
+        bearing = std::atan2(-fwd.x, fwd.y);
         cosB = std::cos(bearing);
         sinB = std::sin(bearing);
     }
@@ -5421,13 +7940,10 @@ void GameScreen::renderMinimapMarkers(game::GameHandler& gameHandler) {
         float dx = worldRenderPos.x - playerRender.x;
         float dy = worldRenderPos.y - playerRender.y;
 
-        // Exact inverse of minimap display shader:
-        //   shader: mapUV = playerUV + vec2(-rotated.x, rotated.y) * zoom * 2
-        //   where rotated = R(bearing) * center, center in [-0.5, 0.5]
-        // Inverse: center = R^-1(bearing) * (-deltaUV.x, deltaUV.y) / (zoom*2)
-        // With deltaUV.x ∝ +dx (render +X=west=larger U) and deltaUV.y ∝ -dy (V increases south):
-        float rx = -(dx * cosB + dy * sinB);
-        float ry =   dx * sinB - dy * cosB;
+        // Match minimap shader transform exactly.
+        // Render axes: +X=west, +Y=north. Minimap screen axes: +X=right(east), +Y=down(south).
+        float rx = -dx * cosB + dy * sinB;
+        float ry = -dx * sinB - dy * cosB;
 
         // Scale to minimap pixels
         float px = rx / viewRadius * mapRadius;
@@ -5443,36 +7959,8 @@ void GameScreen::renderMinimapMarkers(game::GameHandler& gameHandler) {
         return true;
     };
 
-    // Build sets of entries that are incomplete objectives for tracked quests.
-    // minimapQuestEntries: NPC creature entries (npcOrGoId > 0)
-    // minimapQuestGoEntries: game object entries (npcOrGoId < 0, stored as abs value)
-    std::unordered_set<uint32_t> minimapQuestEntries;
-    std::unordered_set<uint32_t> minimapQuestGoEntries;
-    {
-        const auto& ql = gameHandler.getQuestLog();
-        const auto& tq = gameHandler.getTrackedQuestIds();
-        for (const auto& q : ql) {
-            if (q.complete || q.questId == 0) continue;
-            if (!tq.empty() && !tq.count(q.questId)) continue;
-            for (const auto& obj : q.killObjectives) {
-                if (obj.required == 0) continue;
-                if (obj.npcOrGoId > 0) {
-                    auto it = q.killCounts.find(static_cast<uint32_t>(obj.npcOrGoId));
-                    if (it == q.killCounts.end() || it->second.first < it->second.second)
-                        minimapQuestEntries.insert(static_cast<uint32_t>(obj.npcOrGoId));
-                } else if (obj.npcOrGoId < 0) {
-                    uint32_t goEntry = static_cast<uint32_t>(-obj.npcOrGoId);
-                    auto it = q.killCounts.find(goEntry);
-                    if (it == q.killCounts.end() || it->second.first < it->second.second)
-                        minimapQuestGoEntries.insert(goEntry);
-                }
-            }
-        }
-    }
-
     // Optional base nearby NPC dots (independent of quest status packets).
-    if (settingsPanel_.minimapNpcDots_) {
-        ImVec2 mouse = ImGui::GetMousePos();
+    if (minimapNpcDots_) {
         for (const auto& [guid, entity] : gameHandler.getEntityManager().getEntities()) {
             if (!entity || entity->getType() != game::ObjectType::UNIT) continue;
 
@@ -5483,186 +7971,8 @@ void GameScreen::renderMinimapMarkers(game::GameHandler& gameHandler) {
             float sx = 0.0f, sy = 0.0f;
             if (!projectToMinimap(npcRender, sx, sy)) continue;
 
-            bool isQuestTarget = minimapQuestEntries.count(unit->getEntry()) != 0;
-            if (isQuestTarget) {
-                // Quest kill objective: larger gold dot with dark outline
-                drawList->AddCircleFilled(ImVec2(sx, sy), 3.5f, IM_COL32(255, 210, 30, 240));
-                drawList->AddCircle(ImVec2(sx, sy), 3.5f, IM_COL32(80, 50, 0, 180), 0, 1.0f);
-                // Tooltip on hover showing unit name
-                float mdx = mouse.x - sx, mdy = mouse.y - sy;
-                if (mdx * mdx + mdy * mdy < 64.0f) {
-                    const std::string& nm = unit->getName();
-                    if (!nm.empty()) ImGui::SetTooltip("%s (quest)", nm.c_str());
-                }
-            } else {
-                ImU32 baseDot = unit->isHostile() ? IM_COL32(220, 70, 70, 220) : IM_COL32(245, 245, 245, 210);
-                drawList->AddCircleFilled(ImVec2(sx, sy), 1.0f, baseDot);
-            }
-        }
-    }
-
-    // Nearby other-player dots — shown when NPC dots are enabled.
-    // Party members are already drawn as squares above; other players get a small circle.
-    if (settingsPanel_.minimapNpcDots_) {
-        const uint64_t selfGuid = gameHandler.getPlayerGuid();
-        const auto& partyData = gameHandler.getPartyData();
-        for (const auto& [guid, entity] : gameHandler.getEntityManager().getEntities()) {
-            if (!entity || entity->getType() != game::ObjectType::PLAYER) continue;
-            if (entity->getGuid() == selfGuid) continue;  // skip self (already drawn as arrow)
-
-            // Skip party members (already drawn as squares above)
-            bool isPartyMember = false;
-            for (const auto& m : partyData.members) {
-                if (m.guid == guid) { isPartyMember = true; break; }
-            }
-            if (isPartyMember) continue;
-
-            glm::vec3 pRender = core::coords::canonicalToRender(
-                glm::vec3(entity->getX(), entity->getY(), entity->getZ()));
-            float sx = 0.0f, sy = 0.0f;
-            if (!projectToMinimap(pRender, sx, sy)) continue;
-
-            // Blue dot for other nearby players
-            drawList->AddCircleFilled(ImVec2(sx, sy), 2.0f, IM_COL32(80, 160, 255, 220));
-        }
-    }
-
-    // Lootable corpse dots: small yellow-green diamonds on dead, lootable units.
-    // Shown whenever NPC dots are enabled (or always, since they're always useful).
-    {
-        constexpr uint32_t UNIT_DYNFLAG_LOOTABLE = 0x0001;
-        for (const auto& [guid, entity] : gameHandler.getEntityManager().getEntities()) {
-            if (!entity || entity->getType() != game::ObjectType::UNIT) continue;
-            auto unit = std::static_pointer_cast<game::Unit>(entity);
-            if (!unit) continue;
-            // Must be dead (health == 0) and marked lootable
-            if (unit->getHealth() != 0) continue;
-            if (!(unit->getDynamicFlags() & UNIT_DYNFLAG_LOOTABLE)) continue;
-
-            glm::vec3 npcRender = core::coords::canonicalToRender(
-                glm::vec3(entity->getX(), entity->getY(), entity->getZ()));
-            float sx = 0.0f, sy = 0.0f;
-            if (!projectToMinimap(npcRender, sx, sy)) continue;
-
-            // Draw a small diamond (rotated square) in light yellow-green
-            const float dr = 3.5f;
-            ImVec2 top  (sx,      sy - dr);
-            ImVec2 right(sx + dr, sy     );
-            ImVec2 bot  (sx,      sy + dr);
-            ImVec2 left (sx - dr, sy     );
-            drawList->AddQuadFilled(top, right, bot, left, IM_COL32(180, 230, 80, 230));
-            drawList->AddQuad      (top, right, bot, left, IM_COL32(60,  80,  20, 200), 1.0f);
-
-            // Tooltip on hover
-            if (ImGui::IsMouseHoveringRect(ImVec2(sx - dr, sy - dr), ImVec2(sx + dr, sy + dr))) {
-                const std::string& nm = unit->getName();
-                ImGui::BeginTooltip();
-                ImGui::TextColored(ImVec4(0.7f, 0.9f, 0.3f, 1.0f), "%s",
-                                   nm.empty() ? "Lootable corpse" : nm.c_str());
-                ImGui::EndTooltip();
-            }
-        }
-    }
-
-    // Interactable game object dots (chests, resource nodes) when NPC dots are enabled.
-    // Shown as small orange triangles to distinguish from unit dots and loot corpses.
-    if (settingsPanel_.minimapNpcDots_) {
-        ImVec2 mouse = ImGui::GetMousePos();
-        for (const auto& [guid, entity] : gameHandler.getEntityManager().getEntities()) {
-            if (!entity || entity->getType() != game::ObjectType::GAMEOBJECT) continue;
-
-            // Only show objects that are likely interactive (chests/nodes: type 3;
-            // also show type 0=Door when open, but filter by dynamic-flag ACTIVATED).
-            // For simplicity, show all game objects that have a non-empty cached name.
-            auto go = std::static_pointer_cast<game::GameObject>(entity);
-            if (!go) continue;
-
-            // Only show if we have name data (avoids cluttering with unknown objects)
-            const auto* goInfo = gameHandler.getCachedGameObjectInfo(go->getEntry());
-            if (!goInfo || !goInfo->isValid()) continue;
-            // Skip transport objects (boats/zeppelins): type 15 = MO_TRANSPORT, 11 = TRANSPORT
-            if (goInfo->type == 11 || goInfo->type == 15) continue;
-
-            glm::vec3 goRender = core::coords::canonicalToRender(
-                glm::vec3(entity->getX(), entity->getY(), entity->getZ()));
-            float sx = 0.0f, sy = 0.0f;
-            if (!projectToMinimap(goRender, sx, sy)) continue;
-
-            // Triangle size and color: bright cyan for quest objectives, amber for others
-            bool isQuestGO = minimapQuestGoEntries.count(go->getEntry()) != 0;
-            const float ts = isQuestGO ? 4.5f : 3.5f;
-            ImVec2 goTip  (sx,        sy - ts);
-            ImVec2 goLeft (sx - ts,   sy + ts * 0.6f);
-            ImVec2 goRight(sx + ts,   sy + ts * 0.6f);
-            if (isQuestGO) {
-                drawList->AddTriangleFilled(goTip, goLeft, goRight, IM_COL32(50, 230, 255, 240));
-                drawList->AddTriangle(goTip, goLeft, goRight, IM_COL32(0, 60, 80, 200), 1.5f);
-            } else {
-                drawList->AddTriangleFilled(goTip, goLeft, goRight, IM_COL32(255, 185, 30, 220));
-                drawList->AddTriangle(goTip, goLeft, goRight, IM_COL32(100, 60, 0, 180), 1.0f);
-            }
-
-            // Tooltip on hover
-            float mdx = mouse.x - sx, mdy = mouse.y - sy;
-            if (mdx * mdx + mdy * mdy < 64.0f) {
-                if (isQuestGO)
-                    ImGui::SetTooltip("%s (quest)", goInfo->name.c_str());
-                else
-                    ImGui::SetTooltip("%s", goInfo->name.c_str());
-            }
-        }
-    }
-
-    // Party member dots on minimap — small colored squares with name tooltip on hover
-    if (gameHandler.isInGroup()) {
-        const auto& partyData = gameHandler.getPartyData();
-        ImVec2 mouse = ImGui::GetMousePos();
-        for (const auto& member : partyData.members) {
-            if (!member.hasPartyStats) continue;
-            bool isOnline = (member.onlineStatus & 0x0001) != 0;
-            bool isDead   = (member.onlineStatus & 0x0020) != 0;
-            bool isGhost  = (member.onlineStatus & 0x0010) != 0;
-            if (!isOnline) continue;
-            if (member.posX == 0 && member.posY == 0) continue;
-
-            // Party stat positions: posY = canonical X (north), posX = canonical Y (west)
-            glm::vec3 memberRender = core::coords::canonicalToRender(
-                glm::vec3(static_cast<float>(member.posY),
-                          static_cast<float>(member.posX), 0.0f));
-            float sx = 0.0f, sy = 0.0f;
-            if (!projectToMinimap(memberRender, sx, sy)) continue;
-
-            // Determine dot color: class color > leader gold > light blue
-            ImU32 dotCol;
-            if (isDead || isGhost) {
-                dotCol = IM_COL32(140, 140, 140, 200);  // gray for dead
-            } else {
-                auto mEnt = gameHandler.getEntityManager().getEntity(member.guid);
-                uint8_t cid = entityClassId(mEnt.get());
-                if (cid != 0) {
-                    ImVec4 cv = classColorVec4(cid);
-                    dotCol = IM_COL32(
-                        static_cast<int>(cv.x * 255),
-                        static_cast<int>(cv.y * 255),
-                        static_cast<int>(cv.z * 255), 230);
-                } else if (member.guid == partyData.leaderGuid) {
-                    dotCol = IM_COL32(255, 210, 0, 230);  // gold for leader
-                } else {
-                    dotCol = IM_COL32(100, 180, 255, 230); // blue for others
-                }
-            }
-
-            // Draw a small square (WoW-style party member dot)
-            const float hs = 3.5f;
-            drawList->AddRectFilled(ImVec2(sx - hs, sy - hs), ImVec2(sx + hs, sy + hs), dotCol, 1.0f);
-            drawList->AddRect(ImVec2(sx - hs, sy - hs), ImVec2(sx + hs, sy + hs),
-                              IM_COL32(0, 0, 0, 180), 1.0f, 0, 1.0f);
-
-            // Name tooltip on hover
-            float mdx = mouse.x - sx, mdy = mouse.y - sy;
-            if (mdx * mdx + mdy * mdy < 64.0f && !member.name.empty()) {
-                ImGui::SetTooltip("%s", member.name.c_str());
-            }
+            ImU32 baseDot = unit->isHostile() ? IM_COL32(220, 70, 70, 220) : IM_COL32(245, 245, 245, 210);
+            drawList->AddCircleFilled(ImVec2(sx, sy), 1.0f, baseDot);
         }
     }
 
@@ -5702,87 +8012,6 @@ void GameScreen::renderMinimapMarkers(game::GameHandler& gameHandler) {
         drawList->AddText(font, 11.0f,
             ImVec2(sx - textSize.x * 0.5f, sy - textSize.y * 0.5f),
             IM_COL32(0, 0, 0, 255), marker);
-
-        // Show NPC name and quest status on hover
-        {
-            ImVec2 mouse = ImGui::GetMousePos();
-            float mdx = mouse.x - sx, mdy = mouse.y - sy;
-            if (mdx * mdx + mdy * mdy < 64.0f) {
-                std::string npcName;
-                if (entity->getType() == game::ObjectType::UNIT) {
-                    auto npcUnit = std::static_pointer_cast<game::Unit>(entity);
-                    npcName = npcUnit->getName();
-                }
-                if (!npcName.empty()) {
-                    bool hasQuest = (status == game::QuestGiverStatus::AVAILABLE ||
-                                     status == game::QuestGiverStatus::AVAILABLE_LOW);
-                    ImGui::SetTooltip("%s\n%s", npcName.c_str(),
-                                      hasQuest ? "Has a quest for you" : "Quest ready to turn in");
-                }
-            }
-        }
-    }
-
-    // Quest kill objective markers — highlight live NPCs matching active quest kill objectives
-    {
-        // Build map of NPC entry → (quest title, current, required) for tooltips
-        struct KillInfo { std::string questTitle; uint32_t current = 0; uint32_t required = 0; };
-        std::unordered_map<uint32_t, KillInfo> killInfoMap;
-        const auto& trackedIds = gameHandler.getTrackedQuestIds();
-        for (const auto& quest : gameHandler.getQuestLog()) {
-            if (quest.complete) continue;
-            if (!trackedIds.empty() && !trackedIds.count(quest.questId)) continue;
-            for (const auto& obj : quest.killObjectives) {
-                if (obj.npcOrGoId <= 0 || obj.required == 0) continue;
-                uint32_t npcEntry = static_cast<uint32_t>(obj.npcOrGoId);
-                auto it = quest.killCounts.find(npcEntry);
-                uint32_t current = (it != quest.killCounts.end()) ? it->second.first : 0;
-                if (current < obj.required) {
-                    killInfoMap[npcEntry] = { quest.title, current, obj.required };
-                }
-            }
-        }
-
-        if (!killInfoMap.empty()) {
-            ImVec2 mouse = ImGui::GetMousePos();
-            for (const auto& [guid, entity] : gameHandler.getEntityManager().getEntities()) {
-                if (!entity || entity->getType() != game::ObjectType::UNIT) continue;
-                auto unit = std::static_pointer_cast<game::Unit>(entity);
-                if (!unit || unit->getHealth() == 0) continue;
-                auto infoIt = killInfoMap.find(unit->getEntry());
-                if (infoIt == killInfoMap.end()) continue;
-
-                glm::vec3 unitRender = core::coords::canonicalToRender(
-                    glm::vec3(entity->getX(), entity->getY(), entity->getZ()));
-                float sx = 0.0f, sy = 0.0f;
-                if (!projectToMinimap(unitRender, sx, sy)) continue;
-
-                // Gold circle with a dark "x" mark — indicates a quest kill target
-                drawList->AddCircleFilled(ImVec2(sx, sy), 5.0f, IM_COL32(255, 185, 0, 240));
-                drawList->AddCircle(ImVec2(sx, sy), 5.5f, IM_COL32(0, 0, 0, 180), 12, 1.0f);
-                drawList->AddLine(ImVec2(sx - 2.5f, sy - 2.5f), ImVec2(sx + 2.5f, sy + 2.5f),
-                                  IM_COL32(20, 20, 20, 230), 1.2f);
-                drawList->AddLine(ImVec2(sx + 2.5f, sy - 2.5f), ImVec2(sx - 2.5f, sy + 2.5f),
-                                  IM_COL32(20, 20, 20, 230), 1.2f);
-
-                // Tooltip on hover
-                float mdx = mouse.x - sx, mdy = mouse.y - sy;
-                if (mdx * mdx + mdy * mdy < 64.0f) {
-                    const auto& ki = infoIt->second;
-                    const std::string& npcName = unit->getName();
-                    if (!npcName.empty()) {
-                        ImGui::SetTooltip("%s\n%s: %u/%u",
-                            npcName.c_str(),
-                            ki.questTitle.empty() ? "Quest" : ki.questTitle.c_str(),
-                            ki.current, ki.required);
-                    } else {
-                        ImGui::SetTooltip("%s: %u/%u",
-                            ki.questTitle.empty() ? "Quest" : ki.questTitle.c_str(),
-                            ki.current, ki.required);
-                    }
-                }
-            }
-        }
     }
 
     // Gossip POI markers (quest / NPC navigation targets)
@@ -5811,542 +8040,43 @@ void GameScreen::renderMinimapMarkers(game::GameHandler& gameHandler) {
         }
     }
 
-    // Minimap pings from party members
-    for (const auto& ping : gameHandler.getMinimapPings()) {
-        glm::vec3 pingRender = core::coords::canonicalToRender(glm::vec3(ping.wowX, ping.wowY, 0.0f));
-        float sx = 0.0f, sy = 0.0f;
-        if (!projectToMinimap(pingRender, sx, sy)) continue;
-
-        float t = ping.age / game::GameHandler::MinimapPing::LIFETIME;
-        float alpha = 1.0f - t;
-        float pulse = 1.0f + 1.5f * t;  // expands outward as it fades
-
-        ImU32 col  = IM_COL32(255, 220, 0, static_cast<int>(alpha * 200));
-        ImU32 col2 = IM_COL32(255, 150, 0, static_cast<int>(alpha * 100));
-        float r1 = 4.0f * pulse;
-        float r2 = 8.0f * pulse;
-        drawList->AddCircle(ImVec2(sx, sy), r1, col, 16, 2.0f);
-        drawList->AddCircle(ImVec2(sx, sy), r2, col2, 16, 1.0f);
-        drawList->AddCircleFilled(ImVec2(sx, sy), 2.5f, col);
-    }
-
-    // Party member dots on minimap
-    {
-        const auto& partyData = gameHandler.getPartyData();
-        const uint64_t leaderGuid = partyData.leaderGuid;
-        for (const auto& member : partyData.members) {
-            if (!member.isOnline || !member.hasPartyStats) continue;
-            if (member.posX == 0 && member.posY == 0) continue;
-
-            // posX/posY follow same server axis convention as minimap pings:
-            // server posX = east/west axis → canonical Y (west)
-            // server posY = north/south axis → canonical X (north)
-            float wowX = static_cast<float>(member.posY);
-            float wowY = static_cast<float>(member.posX);
-            glm::vec3 memberRender = core::coords::canonicalToRender(glm::vec3(wowX, wowY, 0.0f));
-
-            float sx = 0.0f, sy = 0.0f;
-            if (!projectToMinimap(memberRender, sx, sy)) continue;
-
-            ImU32 dotColor;
-            {
-                auto mEnt = gameHandler.getEntityManager().getEntity(member.guid);
-                uint8_t cid = entityClassId(mEnt.get());
-                dotColor = (cid != 0)
-                    ? classColorU32(cid, 235)
-                    : (member.guid == leaderGuid)
-                        ? IM_COL32(255, 210, 0, 235)
-                        : IM_COL32(100, 180, 255, 235);
-            }
-            drawList->AddCircleFilled(ImVec2(sx, sy), 4.0f, dotColor);
-            drawList->AddCircle(ImVec2(sx, sy), 4.0f, IM_COL32(255, 255, 255, 160), 12, 1.0f);
-
-            // Raid mark: tiny symbol drawn above the dot
-            {
-                static constexpr struct { const char* sym; ImU32 col; } kMMMarks[] = {
-                    { "\xe2\x98\x85", IM_COL32(255, 220,  50, 255) },
-                    { "\xe2\x97\x8f", IM_COL32(255, 140,   0, 255) },
-                    { "\xe2\x97\x86", IM_COL32(160,  32, 240, 255) },
-                    { "\xe2\x96\xb2", IM_COL32( 50, 200,  50, 255) },
-                    { "\xe2\x97\x8c", IM_COL32( 80, 160, 255, 255) },
-                    { "\xe2\x96\xa0", IM_COL32( 50, 200, 220, 255) },
-                    { "\xe2\x9c\x9d", IM_COL32(255,  80,  80, 255) },
-                    { "\xe2\x98\xa0", IM_COL32(255, 255, 255, 255) },
-                };
-                uint8_t pmk = gameHandler.getEntityRaidMark(member.guid);
-                if (pmk < game::GameHandler::kRaidMarkCount) {
-                    ImFont* mmFont = ImGui::GetFont();
-                    ImVec2 msz = mmFont->CalcTextSizeA(9.0f, FLT_MAX, 0.0f, kMMMarks[pmk].sym);
-                    drawList->AddText(mmFont, 9.0f,
-                        ImVec2(sx - msz.x * 0.5f, sy - 4.0f - msz.y),
-                        kMMMarks[pmk].col, kMMMarks[pmk].sym);
-                }
-            }
-
-            ImVec2 cursorPos = ImGui::GetMousePos();
-            float mdx = cursorPos.x - sx, mdy = cursorPos.y - sy;
-            if (!member.name.empty() && (mdx * mdx + mdy * mdy) < 64.0f) {
-                uint8_t pmk2 = gameHandler.getEntityRaidMark(member.guid);
-                if (pmk2 < game::GameHandler::kRaidMarkCount) {
-                    static constexpr const char* kMarkNames[] = {
-                        "Star", "Circle", "Diamond", "Triangle",
-                        "Moon", "Square", "Cross", "Skull"
-                    };
-                    ImGui::SetTooltip("%s {%s}", member.name.c_str(), kMarkNames[pmk2]);
-                } else {
-                    ImGui::SetTooltip("%s", member.name.c_str());
-                }
-            }
-        }
-    }
-
-    // BG flag carrier / important player positions (MSG_BATTLEGROUND_PLAYER_POSITIONS)
-    {
-        const auto& bgPositions = gameHandler.getBgPlayerPositions();
-        if (!bgPositions.empty()) {
-            ImVec2 mouse = ImGui::GetMousePos();
-            // group 0 = typically ally-held flag / first list; group 1 = enemy
-            static const ImU32 kBgGroupColors[2] = {
-                IM_COL32( 80, 180, 255, 240),  // group 0: blue (alliance)
-                IM_COL32(220,  50,  50, 240),  // group 1: red  (horde)
-            };
-            for (const auto& bp : bgPositions) {
-                // Packet coords: wowX=canonical X (north), wowY=canonical Y (west)
-                glm::vec3 bpRender = core::coords::canonicalToRender(glm::vec3(bp.wowX, bp.wowY, 0.0f));
-                float sx = 0.0f, sy = 0.0f;
-                if (!projectToMinimap(bpRender, sx, sy)) continue;
-
-                ImU32 col = kBgGroupColors[bp.group & 1];
-
-                // Draw a flag-like diamond icon
-                const float r = 5.0f;
-                ImVec2 top  (sx,       sy - r);
-                ImVec2 right(sx + r,   sy    );
-                ImVec2 bot  (sx,       sy + r);
-                ImVec2 left (sx - r,   sy    );
-                drawList->AddQuadFilled(top, right, bot, left, col);
-                drawList->AddQuad(top, right, bot, left, IM_COL32(255, 255, 255, 180), 1.0f);
-
-                float mdx = mouse.x - sx, mdy = mouse.y - sy;
-                if (mdx * mdx + mdy * mdy < 64.0f) {
-                    // Show entity name if available, otherwise guid
-                    auto ent = gameHandler.getEntityManager().getEntity(bp.guid);
-                    if (ent) {
-                        std::string nm;
-                        if (ent->getType() == game::ObjectType::PLAYER) {
-                            auto pl = std::static_pointer_cast<game::Unit>(ent);
-                            nm = pl ? pl->getName() : "";
-                        }
-                        if (!nm.empty())
-                            ImGui::SetTooltip("Flag carrier: %s", nm.c_str());
-                        else
-                            ImGui::SetTooltip("Flag carrier");
-                    } else {
-                        ImGui::SetTooltip("Flag carrier");
-                    }
-                }
-            }
-        }
-    }
-
-    // Corpse direction indicator — shown when player is a ghost
-    if (gameHandler.isPlayerGhost()) {
-        float corpseCanX = 0.0f, corpseCanY = 0.0f;
-        if (gameHandler.getCorpseCanonicalPos(corpseCanX, corpseCanY)) {
-            glm::vec3 corpseRender = core::coords::canonicalToRender(glm::vec3(corpseCanX, corpseCanY, 0.0f));
-            float csx = 0.0f, csy = 0.0f;
-            bool onMap = projectToMinimap(corpseRender, csx, csy);
-
-            if (onMap) {
-                // Draw a small skull-like X marker at the corpse position
-                const float r = 5.0f;
-                drawList->AddCircleFilled(ImVec2(csx, csy), r + 1.0f, IM_COL32(0, 0, 0, 140), 12);
-                drawList->AddCircle(ImVec2(csx, csy), r + 1.0f, IM_COL32(200, 200, 220, 220), 12, 1.5f);
-                // Draw an X in the circle
-                drawList->AddLine(ImVec2(csx - 3.0f, csy - 3.0f), ImVec2(csx + 3.0f, csy + 3.0f),
-                                  IM_COL32(180, 180, 220, 255), 1.5f);
-                drawList->AddLine(ImVec2(csx + 3.0f, csy - 3.0f), ImVec2(csx - 3.0f, csy + 3.0f),
-                                  IM_COL32(180, 180, 220, 255), 1.5f);
-                // Tooltip on hover
-                ImVec2 mouse = ImGui::GetMousePos();
-                float mdx = mouse.x - csx, mdy = mouse.y - csy;
-                if (mdx * mdx + mdy * mdy < 64.0f) {
-                    float dist = gameHandler.getCorpseDistance();
-                    if (dist >= 0.0f)
-                        ImGui::SetTooltip("Your corpse (%.0f yd)", dist);
-                    else
-                        ImGui::SetTooltip("Your corpse");
-                }
-            } else {
-                // Corpse is outside minimap — draw an edge arrow pointing toward it
-                float dx = corpseRender.x - playerRender.x;
-                float dy = corpseRender.y - playerRender.y;
-                // Rotate delta into minimap frame (same as projectToMinimap)
-                float rx = -(dx * cosB + dy * sinB);
-                float ry =   dx * sinB - dy * cosB;
-                float len = std::sqrt(rx * rx + ry * ry);
-                if (len > 0.001f) {
-                    float nx = rx / len;
-                    float ny = ry / len;
-                    // Place arrow at the minimap edge
-                    float edgeR = mapRadius - 7.0f;
-                    float ax = centerX + nx * edgeR;
-                    float ay = centerY + ny * edgeR;
-                    // Arrow pointing outward (toward corpse)
-                    float arrowLen = 6.0f;
-                    float arrowW = 3.5f;
-                    ImVec2 tip(ax + nx * arrowLen, ay + ny * arrowLen);
-                    ImVec2 left(ax - ny * arrowW - nx * arrowLen * 0.4f,
-                                ay + nx * arrowW - ny * arrowLen * 0.4f);
-                    ImVec2 right(ax + ny * arrowW - nx * arrowLen * 0.4f,
-                                 ay - nx * arrowW - ny * arrowLen * 0.4f);
-                    drawList->AddTriangleFilled(tip, left, right, IM_COL32(180, 180, 240, 230));
-                    drawList->AddTriangle(tip, left, right, IM_COL32(0, 0, 0, 180), 1.0f);
-                    // Tooltip on hover
-                    ImVec2 mouse = ImGui::GetMousePos();
-                    float mdx = mouse.x - ax, mdy = mouse.y - ay;
-                    if (mdx * mdx + mdy * mdy < 100.0f) {
-                        float dist = gameHandler.getCorpseDistance();
-                        if (dist >= 0.0f)
-                            ImGui::SetTooltip("Your corpse (%.0f yd)", dist);
-                        else
-                            ImGui::SetTooltip("Your corpse");
-                    }
-                }
-            }
-        }
-    }
-
-    // Player position arrow at minimap center, pointing in camera facing direction.
-    // On a rotating minimap the map already turns so forward = screen-up; on a fixed
-    // minimap we rotate the arrow to match the player's compass heading.
-    {
-        // Compute screen-space facing direction for the arrow.
-        // bearing = clockwise angle from screen-north (0 = facing north/up).
-        float arrowAngle = 0.0f; // 0 = pointing up (north)
-        if (!minimap->isRotateWithCamera()) {
-            // Fixed minimap: arrow must show actual facing relative to north.
-            glm::vec3 fwd = camera->getForward();
-            // +render_y = north = screen-up, +render_x = west = screen-left.
-            // bearing from north clockwise: atan2(-fwd.x_west, fwd.y_north)
-            //   => sin=east component, cos=north component
-            //   In render coords west=+x, east=-x, so sin(bearing)=east=-fwd.x
-            arrowAngle = std::atan2(-fwd.x, fwd.y); // clockwise from north in screen space
-        }
-        // Screen direction the arrow tip points toward
-        float nx =  std::sin(arrowAngle); // screen +X = east
-        float ny = -std::cos(arrowAngle); // screen -Y = north
-
-        // Draw a chevron-style arrow: tip, two base corners, and a notch at the back
-        const float tipLen  = 8.0f;  // tip forward distance
-        const float baseW   = 5.0f;  // half-width at base
-        const float notchIn = 3.0f;  // how far back the center notch sits
-        // Perpendicular direction (rotated 90°)
-        float px =  ny; // perpendicular x
-        float py = -nx; // perpendicular y
-
-        ImVec2 tip  (centerX + nx * tipLen,  centerY + ny * tipLen);
-        ImVec2 baseL(centerX - nx * baseW + px * baseW,  centerY - ny * baseW + py * baseW);
-        ImVec2 baseR(centerX - nx * baseW - px * baseW,  centerY - ny * baseW - py * baseW);
-        ImVec2 notch(centerX - nx * (baseW - notchIn),   centerY - ny * (baseW - notchIn));
-
-        // Fill: bright white with slight gold tint, dark outline for readability
-        drawList->AddTriangleFilled(tip, baseL, notch, IM_COL32(255, 248, 200, 245));
-        drawList->AddTriangleFilled(tip, notch, baseR, IM_COL32(255, 248, 200, 245));
-        drawList->AddTriangle(tip, baseL, notch, IM_COL32(60, 40, 0, 200), 1.2f);
-        drawList->AddTriangle(tip, notch, baseR, IM_COL32(60, 40, 0, 200), 1.2f);
-    }
-
-    // Scroll wheel over minimap → zoom in/out
-    {
-        float wheel = ImGui::GetIO().MouseWheel;
-        if (wheel != 0.0f) {
-            ImVec2 mouse = ImGui::GetMousePos();
-            float mdx = mouse.x - centerX;
-            float mdy = mouse.y - centerY;
-            if (mdx * mdx + mdy * mdy <= mapRadius * mapRadius) {
-                if (wheel > 0.0f)
-                    minimap->zoomIn();
-                else
-                    minimap->zoomOut();
-            }
-        }
-    }
-
-    // Ctrl+click on minimap → send minimap ping to party
-    if (ImGui::IsMouseClicked(0) && ImGui::GetIO().KeyCtrl) {
-        ImVec2 mouse = ImGui::GetMousePos();
-        float mdx = mouse.x - centerX;
-        float mdy = mouse.y - centerY;
-        float distSq = mdx * mdx + mdy * mdy;
-        if (distSq <= mapRadius * mapRadius) {
-            // Invert projectToMinimap: px=mdx, py=mdy → rx=px*viewRadius/mapRadius
-            float rx = mdx * viewRadius / mapRadius;
-            float ry = mdy * viewRadius / mapRadius;
-            // rx/ry are in rotated frame; unrotate to get world dx/dy
-            // rx = -(dx*cosB + dy*sinB), ry = dx*sinB - dy*cosB
-            // Solving: dx = -(rx*cosB - ry*sinB), dy = -(rx*sinB + ry*cosB)
-            float wdx = -(rx * cosB - ry * sinB);
-            float wdy = -(rx * sinB + ry * cosB);
-            // playerRender is in render coords; add delta to get render position then convert to canonical
-            glm::vec3 clickRender = playerRender + glm::vec3(wdx, wdy, 0.0f);
-            glm::vec3 clickCanon = core::coords::renderToCanonical(clickRender);
-            gameHandler.sendMinimapPing(clickCanon.x, clickCanon.y);
-        }
-    }
-
-    // Persistent coordinate display below the minimap
-    {
-        glm::vec3 playerCanon = core::coords::renderToCanonical(playerRender);
-        char coordBuf[32];
-        std::snprintf(coordBuf, sizeof(coordBuf), "%.1f, %.1f", playerCanon.x, playerCanon.y);
-
-        ImFont* font = ImGui::GetFont();
-        float fontSize = ImGui::GetFontSize();
-        ImVec2 textSz = font->CalcTextSizeA(fontSize, FLT_MAX, 0.0f, coordBuf);
-
-        float tx = centerX - textSz.x * 0.5f;
-        float ty = centerY + mapRadius + 3.0f;
-
-        // Semi-transparent dark background pill
-        float pad = 3.0f;
-        drawList->AddRectFilled(
-            ImVec2(tx - pad, ty - pad),
-            ImVec2(tx + textSz.x + pad, ty + textSz.y + pad),
-            IM_COL32(0, 0, 0, 140), 4.0f);
-        // Coordinate text in warm yellow
-        drawList->AddText(font, fontSize, ImVec2(tx, ty), IM_COL32(230, 220, 140, 255), coordBuf);
-    }
-
-    // Local time clock — displayed just below the coordinate label
-    {
-        auto now = std::chrono::system_clock::now();
-        std::time_t tt = std::chrono::system_clock::to_time_t(now);
-        std::tm tmLocal{};
-#if defined(_WIN32)
-        localtime_s(&tmLocal, &tt);
-#else
-        localtime_r(&tt, &tmLocal);
-#endif
-        char clockBuf[16];
-        std::snprintf(clockBuf, sizeof(clockBuf), "%02d:%02d",
-                      tmLocal.tm_hour, tmLocal.tm_min);
-
-        ImFont* font = ImGui::GetFont();
-        float fontSize = ImGui::GetFontSize() * 0.9f;  // slightly smaller than coords
-        ImVec2 clockSz = font->CalcTextSizeA(fontSize, FLT_MAX, 0.0f, clockBuf);
-
-        float tx = centerX - clockSz.x * 0.5f;
-        // Position below the coordinate line (+fontSize of coord + 2px gap)
-        float coordLineH = ImGui::GetFontSize();
-        float ty = centerY + mapRadius + 3.0f + coordLineH + 2.0f;
-
-        float pad = 2.0f;
-        drawList->AddRectFilled(
-            ImVec2(tx - pad, ty - pad),
-            ImVec2(tx + clockSz.x + pad, ty + clockSz.y + pad),
-            IM_COL32(0, 0, 0, 120), 3.0f);
-        drawList->AddText(font, fontSize, ImVec2(tx, ty), IM_COL32(200, 200, 220, 220), clockBuf);
-    }
-
-    // Zone name display — drawn inside the top edge of the minimap circle
-    {
-        auto* zmRenderer = renderer ? renderer->getZoneManager() : nullptr;
-        uint32_t zoneId = gameHandler.getWorldStateZoneId();
-        const game::ZoneInfo* zi = (zmRenderer && zoneId != 0) ? zmRenderer->getZoneInfo(zoneId) : nullptr;
-        if (zi && !zi->name.empty()) {
-            ImFont* font = ImGui::GetFont();
-            float fontSize = ImGui::GetFontSize();
-            ImVec2 ts = font->CalcTextSizeA(fontSize, FLT_MAX, 0.0f, zi->name.c_str());
-            float tx = centerX - ts.x * 0.5f;
-            float ty = centerY - mapRadius + 4.0f;  // just inside top edge of the circle
-            float pad = 2.0f;
-            drawList->AddRectFilled(
-                ImVec2(tx - pad, ty - pad),
-                ImVec2(tx + ts.x + pad, ty + ts.y + pad),
-                IM_COL32(0, 0, 0, 160), 2.0f);
-            drawList->AddText(font, fontSize, ImVec2(tx + 1.0f, ty + 1.0f),
-                              IM_COL32(0, 0, 0, 180), zi->name.c_str());
-            drawList->AddText(font, fontSize, ImVec2(tx, ty),
-                              IM_COL32(255, 230, 150, 220), zi->name.c_str());
-        }
-    }
-
-    // Instance difficulty indicator — just below zone name, inside minimap top edge
-    if (gameHandler.isInInstance()) {
-        static constexpr const char* kDiffLabels[] = {"Normal", "Heroic", "25 Normal", "25 Heroic"};
-        uint32_t diff = gameHandler.getInstanceDifficulty();
-        const char* label = (diff < 4) ? kDiffLabels[diff] : "Unknown";
-
-        ImFont* font = ImGui::GetFont();
-        float fontSize = ImGui::GetFontSize() * 0.85f;
-        ImVec2 ts = font->CalcTextSizeA(fontSize, FLT_MAX, 0.0f, label);
-        float tx = centerX - ts.x * 0.5f;
-        // Position below zone name: top edge + zone font size + small gap
-        float ty = centerY - mapRadius + 4.0f + ImGui::GetFontSize() + 2.0f;
-        float pad = 2.0f;
-
-        // Color-code: heroic=orange, normal=light gray
-        ImU32 bgCol = gameHandler.isInstanceHeroic() ? IM_COL32(120, 60, 0, 180) : IM_COL32(0, 0, 0, 160);
-        ImU32 textCol = gameHandler.isInstanceHeroic() ? IM_COL32(255, 180, 50, 255) : IM_COL32(200, 200, 200, 220);
-
-        drawList->AddRectFilled(
-            ImVec2(tx - pad, ty - pad),
-            ImVec2(tx + ts.x + pad, ty + ts.y + pad),
-            bgCol, 2.0f);
-        drawList->AddText(font, fontSize, ImVec2(tx, ty), textCol, label);
-    }
-
-    // Hover tooltip and right-click context menu
-    {
-        ImVec2 mouse = ImGui::GetMousePos();
-        float mdx = mouse.x - centerX;
-        float mdy = mouse.y - centerY;
-        bool overMinimap = (mdx * mdx + mdy * mdy <= mapRadius * mapRadius);
-
-        if (overMinimap) {
-            ImGui::BeginTooltip();
-            // Compute the world coordinate under the mouse cursor
-            // Inverse of projectToMinimap: pixel offset → world offset in render space → canonical
-            float rxW = mdx / mapRadius * viewRadius;
-            float ryW = mdy / mapRadius * viewRadius;
-            // Un-rotate: [dx, dy] = R^-1 * [rxW, ryW]
-            //  where R applied: rx = -(dx*cosB + dy*sinB), ry = dx*sinB - dy*cosB
-            float hoverDx = -cosB * rxW + sinB * ryW;
-            float hoverDy = -sinB * rxW - cosB * ryW;
-            glm::vec3 hoverRender(playerRender.x + hoverDx, playerRender.y + hoverDy, playerRender.z);
-            glm::vec3 hoverCanon = core::coords::renderToCanonical(hoverRender);
-            ImGui::TextColored(ImVec4(0.9f, 0.85f, 0.5f, 1.0f), "%.1f, %.1f", hoverCanon.x, hoverCanon.y);
-            ImGui::TextColored(colors::kMediumGray, "Ctrl+click to ping");
-            ImGui::EndTooltip();
-
-            if (ImGui::IsMouseClicked(ImGuiMouseButton_Right)) {
-                ImGui::OpenPopup("##minimapContextMenu");
-            }
-        }
-
-        if (ImGui::BeginPopup("##minimapContextMenu")) {
-            ImGui::TextColored(ui::colors::kTooltipGold, "Minimap");
-            ImGui::Separator();
-
-            // Zoom controls
-            if (ImGui::MenuItem("Zoom In")) {
-                minimap->zoomIn();
-            }
-            if (ImGui::MenuItem("Zoom Out")) {
-                minimap->zoomOut();
-            }
-
-            ImGui::Separator();
-
-            // Toggle options with checkmarks
-            bool rotWithCam = minimap->isRotateWithCamera();
-            if (ImGui::MenuItem("Rotate with Camera", nullptr, rotWithCam)) {
-                minimap->setRotateWithCamera(!rotWithCam);
-            }
-
-            bool squareShape = minimap->isSquareShape();
-            if (ImGui::MenuItem("Square Shape", nullptr, squareShape)) {
-                minimap->setSquareShape(!squareShape);
-            }
-
-            bool npcDots = settingsPanel_.minimapNpcDots_;
-            if (ImGui::MenuItem("Show NPC Dots", nullptr, npcDots)) {
-                settingsPanel_.minimapNpcDots_ = !settingsPanel_.minimapNpcDots_;
-            }
-
-            ImGui::EndPopup();
-        }
-    }
-
     auto applyMuteState = [&]() {
-        auto* ac = services_.audioCoordinator;
-        float masterScale = settingsPanel_.soundMuted_ ? 0.0f : static_cast<float>(settingsPanel_.pendingMasterVolume) / 100.0f;
+        auto* activeRenderer = core::Application::getInstance().getRenderer();
+        float masterScale = soundMuted_ ? 0.0f : static_cast<float>(pendingMasterVolume) / 100.0f;
         audio::AudioEngine::instance().setMasterVolume(masterScale);
-        if (!ac) return;
-        if (auto* music = ac->getMusicManager()) {
-            music->setVolume(settingsPanel_.pendingMusicVolume);
+        if (!activeRenderer) return;
+        if (auto* music = activeRenderer->getMusicManager()) {
+            music->setVolume(pendingMusicVolume);
         }
-        if (auto* ambient = ac->getAmbientSoundManager()) {
-            ambient->setVolumeScale(settingsPanel_.pendingAmbientVolume / 100.0f);
+        if (auto* ambient = activeRenderer->getAmbientSoundManager()) {
+            ambient->setVolumeScale(pendingAmbientVolume / 100.0f);
         }
-        if (auto* ui = ac->getUiSoundManager()) {
-            ui->setVolumeScale(settingsPanel_.pendingUiVolume / 100.0f);
+        if (auto* ui = activeRenderer->getUiSoundManager()) {
+            ui->setVolumeScale(pendingUiVolume / 100.0f);
         }
-        if (auto* combat = ac->getCombatSoundManager()) {
-            combat->setVolumeScale(settingsPanel_.pendingCombatVolume / 100.0f);
+        if (auto* combat = activeRenderer->getCombatSoundManager()) {
+            combat->setVolumeScale(pendingCombatVolume / 100.0f);
         }
-        if (auto* spell = ac->getSpellSoundManager()) {
-            spell->setVolumeScale(settingsPanel_.pendingSpellVolume / 100.0f);
+        if (auto* spell = activeRenderer->getSpellSoundManager()) {
+            spell->setVolumeScale(pendingSpellVolume / 100.0f);
         }
-        if (auto* movement = ac->getMovementSoundManager()) {
-            movement->setVolumeScale(settingsPanel_.pendingMovementVolume / 100.0f);
+        if (auto* movement = activeRenderer->getMovementSoundManager()) {
+            movement->setVolumeScale(pendingMovementVolume / 100.0f);
         }
-        if (auto* footstep = ac->getFootstepManager()) {
-            footstep->setVolumeScale(settingsPanel_.pendingFootstepVolume / 100.0f);
+        if (auto* footstep = activeRenderer->getFootstepManager()) {
+            footstep->setVolumeScale(pendingFootstepVolume / 100.0f);
         }
-        if (auto* npcVoice = ac->getNpcVoiceManager()) {
-            npcVoice->setVolumeScale(settingsPanel_.pendingNpcVoiceVolume / 100.0f);
+        if (auto* npcVoice = activeRenderer->getNpcVoiceManager()) {
+            npcVoice->setVolumeScale(pendingNpcVoiceVolume / 100.0f);
         }
-        if (auto* mount = ac->getMountSoundManager()) {
-            mount->setVolumeScale(settingsPanel_.pendingMountVolume / 100.0f);
+        if (auto* mount = activeRenderer->getMountSoundManager()) {
+            mount->setVolumeScale(pendingMountVolume / 100.0f);
         }
-        if (auto* activity = ac->getActivitySoundManager()) {
-            activity->setVolumeScale(settingsPanel_.pendingActivityVolume / 100.0f);
+        if (auto* activity = activeRenderer->getActivitySoundManager()) {
+            activity->setVolumeScale(pendingActivityVolume / 100.0f);
         }
     };
 
-    // Zone name label above the minimap (centered, WoW-style)
-    // Prefer the server-reported zone/area name (from SMSG_INIT_WORLD_STATES) so sub-zones
-    // like Ironforge or Wailing Caverns display correctly; fall back to renderer zone name.
-    {
-        std::string wsZoneName;
-        uint32_t wsZoneId = gameHandler.getWorldStateZoneId();
-        if (wsZoneId != 0)
-            wsZoneName = gameHandler.getWhoAreaName(wsZoneId);
-        const std::string& rendererZoneName = renderer ? renderer->getCurrentZoneName() : std::string{};
-        const std::string& zoneName = !wsZoneName.empty() ? wsZoneName : rendererZoneName;
-        if (!zoneName.empty()) {
-            auto* fgDl = ImGui::GetForegroundDrawList();
-            float zoneTextY = centerY - mapRadius - 16.0f;
-            ImFont* font = ImGui::GetFont();
-
-            // Weather icon appended to zone name when active
-            uint32_t wType = gameHandler.getWeatherType();
-            float wIntensity = gameHandler.getWeatherIntensity();
-            const char* weatherIcon = nullptr;
-            ImU32 weatherColor = IM_COL32(255, 255, 255, 200);
-            if (wType == 1 && wIntensity > 0.05f) {           // Rain
-                weatherIcon = " \xe2\x9b\x86";               // U+26C6 ⛆
-                weatherColor = IM_COL32(140, 180, 240, 220);
-            } else if (wType == 2 && wIntensity > 0.05f) {    // Snow
-                weatherIcon = " \xe2\x9d\x84";               // U+2744 ❄
-                weatherColor = IM_COL32(210, 230, 255, 220);
-            } else if (wType == 3 && wIntensity > 0.05f) {    // Storm/Fog
-                weatherIcon = " \xe2\x98\x81";               // U+2601 ☁
-                weatherColor = IM_COL32(160, 160, 190, 220);
-            }
-
-            std::string displayName = zoneName;
-            // Build combined string if weather active
-            std::string fullLabel = weatherIcon ? (zoneName + weatherIcon) : zoneName;
-            ImVec2 tsz = font->CalcTextSizeA(12.0f, FLT_MAX, 0.0f, fullLabel.c_str());
-            float tzx = centerX - tsz.x * 0.5f;
-
-            // Shadow pass
-            fgDl->AddText(font, 12.0f, ImVec2(tzx + 1.0f, zoneTextY + 1.0f),
-                IM_COL32(0, 0, 0, 180), zoneName.c_str());
-            // Zone name in gold
-            fgDl->AddText(font, 12.0f, ImVec2(tzx, zoneTextY),
-                IM_COL32(255, 220, 120, 230), zoneName.c_str());
-            // Weather symbol in its own color appended after
-            if (weatherIcon) {
-                ImVec2 nameSz = font->CalcTextSizeA(12.0f, FLT_MAX, 0.0f, zoneName.c_str());
-                fgDl->AddText(font, 12.0f, ImVec2(tzx + nameSz.x, zoneTextY), weatherColor, weatherIcon);
-            }
-        }
-    }
-
     // Speaker mute button at the minimap top-right corner
     ImGui::SetNextWindowPos(ImVec2(centerX + mapRadius - 26.0f, centerY - mapRadius + 4.0f), ImGuiCond_Always);
     ImGui::SetNextWindowSize(ImVec2(22.0f, 22.0f), ImGuiCond_Always);
@@ -6358,16 +8088,16 @@ void GameScreen::renderMinimapMarkers(game::GameHandler& gameHandler) {
         ImVec2 p = ImGui::GetCursorScreenPos();
         ImVec2 size(20.0f, 20.0f);
         if (ImGui::InvisibleButton("##MinimapMuteButton", size)) {
-            settingsPanel_.soundMuted_ = !settingsPanel_.soundMuted_;
-            if (settingsPanel_.soundMuted_) {
-                settingsPanel_.preMuteVolume_ = audio::AudioEngine::instance().getMasterVolume();
+            soundMuted_ = !soundMuted_;
+            if (soundMuted_) {
+                preMuteVolume_ = audio::AudioEngine::instance().getMasterVolume();
             }
             applyMuteState();
             saveSettings();
         }
         bool hovered = ImGui::IsItemHovered();
-        ImU32 bg = settingsPanel_.soundMuted_ ? IM_COL32(135, 42, 42, 230) : IM_COL32(38, 38, 38, 210);
-        if (hovered) bg = settingsPanel_.soundMuted_ ? IM_COL32(160, 58, 58, 230) : IM_COL32(65, 65, 65, 220);
+        ImU32 bg = soundMuted_ ? IM_COL32(135, 42, 42, 230) : IM_COL32(38, 38, 38, 210);
+        if (hovered) bg = soundMuted_ ? IM_COL32(160, 58, 58, 230) : IM_COL32(65, 65, 65, 220);
         ImU32 fg = IM_COL32(255, 255, 255, 245);
         draw->AddRectFilled(p, ImVec2(p.x + size.x, p.y + size.y), bg, 4.0f);
         draw->AddRect(ImVec2(p.x + 0.5f, p.y + 0.5f), ImVec2(p.x + size.x - 0.5f, p.y + size.y - 0.5f),
@@ -6376,7 +8106,7 @@ void GameScreen::renderMinimapMarkers(game::GameHandler& gameHandler) {
         draw->AddTriangleFilled(ImVec2(p.x + 7.0f, p.y + 7.0f),
                                 ImVec2(p.x + 7.0f, p.y + 13.0f),
                                 ImVec2(p.x + 11.8f, p.y + 10.0f), fg);
-        if (settingsPanel_.soundMuted_) {
+        if (soundMuted_) {
             draw->AddLine(ImVec2(p.x + 13.5f, p.y + 6.2f), ImVec2(p.x + 17.2f, p.y + 13.8f), fg, 1.8f);
             draw->AddLine(ImVec2(p.x + 17.2f, p.y + 6.2f), ImVec2(p.x + 13.5f, p.y + 13.8f), fg, 1.8f);
         } else {
@@ -6385,60 +8115,10 @@ void GameScreen::renderMinimapMarkers(game::GameHandler& gameHandler) {
             draw->PathArcTo(ImVec2(p.x + 11.8f, p.y + 10.0f), 5.5f, -0.7f, 0.7f, 12);
             draw->PathStroke(fg, 0, 1.2f);
         }
-        if (hovered) ImGui::SetTooltip(settingsPanel_.soundMuted_ ? "Unmute" : "Mute");
+        if (hovered) ImGui::SetTooltip(soundMuted_ ? "Unmute" : "Mute");
     }
     ImGui::End();
 
-    // Friends button at top-left of minimap
-    {
-        const auto& contacts = gameHandler.getContacts();
-        int onlineCount = 0;
-        for (const auto& c : contacts)
-            if (c.isFriend() && c.isOnline()) ++onlineCount;
-
-        ImGui::SetNextWindowPos(ImVec2(centerX - mapRadius + 4.0f, centerY - mapRadius + 4.0f), ImGuiCond_Always);
-        ImGui::SetNextWindowSize(ImVec2(22.0f, 22.0f), ImGuiCond_Always);
-        ImGuiWindowFlags friendsBtnFlags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
-                                           ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar |
-                                           ImGuiWindowFlags_NoBackground;
-        if (ImGui::Begin("##MinimapFriendsBtn", nullptr, friendsBtnFlags)) {
-            ImDrawList* draw = ImGui::GetWindowDrawList();
-            ImVec2 p = ImGui::GetCursorScreenPos();
-            ImVec2 sz(20.0f, 20.0f);
-            if (ImGui::InvisibleButton("##FriendsBtnInv", sz)) {
-                socialPanel_.showSocialFrame_ = !socialPanel_.showSocialFrame_;
-            }
-            bool hovered = ImGui::IsItemHovered();
-            ImU32 bg = socialPanel_.showSocialFrame_
-                ? IM_COL32(42, 100, 42, 230)
-                : IM_COL32(38, 38, 38, 210);
-            if (hovered) bg = socialPanel_.showSocialFrame_ ? IM_COL32(58, 130, 58, 230) : IM_COL32(65, 65, 65, 220);
-            draw->AddRectFilled(p, ImVec2(p.x + sz.x, p.y + sz.y), bg, 4.0f);
-            draw->AddRect(ImVec2(p.x + 0.5f, p.y + 0.5f),
-                          ImVec2(p.x + sz.x - 0.5f, p.y + sz.y - 0.5f),
-                          IM_COL32(255, 255, 255, 42), 4.0f);
-            // Simple smiley-face dots as "social" icon
-            ImU32 fg = IM_COL32(255, 255, 255, 245);
-            draw->AddCircle(ImVec2(p.x + 10.0f, p.y + 10.0f), 6.5f, fg, 16, 1.2f);
-            draw->AddCircleFilled(ImVec2(p.x + 7.5f, p.y + 8.0f), 1.2f, fg);
-            draw->AddCircleFilled(ImVec2(p.x + 12.5f, p.y + 8.0f), 1.2f, fg);
-            draw->PathArcTo(ImVec2(p.x + 10.0f, p.y + 11.5f), 3.0f, 0.2f, 2.9f, 8);
-            draw->PathStroke(fg, 0, 1.2f);
-            // Small green dot if friends online
-            if (onlineCount > 0) {
-                draw->AddCircleFilled(ImVec2(p.x + sz.x - 3.5f, p.y + 3.5f),
-                                      3.5f, IM_COL32(50, 220, 50, 255));
-            }
-            if (hovered) {
-                if (onlineCount > 0)
-                    ImGui::SetTooltip("Friends (%d online)", onlineCount);
-                else
-                    ImGui::SetTooltip("Friends");
-            }
-        }
-        ImGui::End();
-    }
-
     // Zoom buttons at the bottom edge of the minimap
     ImGui::SetNextWindowPos(ImVec2(centerX - 22, centerY + mapRadius - 30), ImGuiCond_Always);
     ImGui::SetNextWindowSize(ImVec2(44, 24), ImGuiCond_Always);
@@ -6459,286 +8139,251 @@ void GameScreen::renderMinimapMarkers(game::GameHandler& gameHandler) {
     }
     ImGui::End();
 
-    // Clock display at bottom-right of minimap (local time)
-    {
-        auto now = std::chrono::system_clock::now();
-        auto tt  = std::chrono::system_clock::to_time_t(now);
-        std::tm tmBuf{};
-#ifdef _WIN32
-        localtime_s(&tmBuf, &tt);
-#else
-        localtime_r(&tt, &tmBuf);
-#endif
-        char clockText[16];
-        std::snprintf(clockText, sizeof(clockText), "%d:%02d %s",
-                      (tmBuf.tm_hour % 12 == 0) ? 12 : tmBuf.tm_hour % 12,
-                      tmBuf.tm_min,
-                      tmBuf.tm_hour >= 12 ? "PM" : "AM");
-        ImVec2 clockSz = ImGui::CalcTextSize(clockText);
-        float clockW = clockSz.x + 10.0f;
-        float clockH = clockSz.y + 6.0f;
-        ImGui::SetNextWindowPos(ImVec2(centerX + mapRadius - clockW - 2.0f,
-                                       centerY + mapRadius - clockH - 2.0f), ImGuiCond_Always);
-        ImGui::SetNextWindowSize(ImVec2(clockW, clockH), ImGuiCond_Always);
-        ImGui::SetNextWindowBgAlpha(0.45f);
-        ImGuiWindowFlags clockFlags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
-                                      ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar |
-                                      ImGuiWindowFlags_NoInputs;
-        if (ImGui::Begin("##MinimapClock", nullptr, clockFlags)) {
-            ImGui::TextColored(ImVec4(0.9f, 0.9f, 0.8f, 0.85f), "%s", clockText);
-        }
-        ImGui::End();
-    }
-
-    // Indicators below the minimap (stacked: new mail, then BG queue, then latency)
-    float indicatorX = centerX - mapRadius;
-    float nextIndicatorY = centerY + mapRadius + 4.0f;
-    const float indicatorW = mapRadius * 2.0f;
-    constexpr float kIndicatorH = 22.0f;
-    ImGuiWindowFlags indicatorFlags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
-                                       ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar |
-                                       ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoInputs;
-
-    // "New Mail" indicator
+    // "New Mail" indicator below the minimap
     if (gameHandler.hasNewMail()) {
-        ImGui::SetNextWindowPos(ImVec2(indicatorX, nextIndicatorY), ImGuiCond_Always);
-        ImGui::SetNextWindowSize(ImVec2(indicatorW, kIndicatorH), ImGuiCond_Always);
-        if (ImGui::Begin("##NewMailIndicator", nullptr, indicatorFlags)) {
+        float indicatorX = centerX - mapRadius;
+        float indicatorY = centerY + mapRadius + 4.0f;
+        ImGui::SetNextWindowPos(ImVec2(indicatorX, indicatorY), ImGuiCond_Always);
+        ImGui::SetNextWindowSize(ImVec2(mapRadius * 2.0f, 22), ImGuiCond_Always);
+        ImGuiWindowFlags mailFlags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
+                                      ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar |
+                                      ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoInputs;
+        if (ImGui::Begin("##NewMailIndicator", nullptr, mailFlags)) {
+            // Pulsing effect
             float pulse = 0.7f + 0.3f * std::sin(static_cast<float>(ImGui::GetTime()) * 3.0f);
             ImGui::TextColored(ImVec4(1.0f, 0.85f, 0.0f, pulse), "New Mail!");
         }
         ImGui::End();
-        nextIndicatorY += kIndicatorH;
-    }
-
-    // Unspent talent points indicator
-    {
-        uint8_t unspent = gameHandler.getUnspentTalentPoints();
-        if (unspent > 0) {
-            ImGui::SetNextWindowPos(ImVec2(indicatorX, nextIndicatorY), ImGuiCond_Always);
-            ImGui::SetNextWindowSize(ImVec2(indicatorW, kIndicatorH), ImGuiCond_Always);
-            if (ImGui::Begin("##TalentIndicator", nullptr, indicatorFlags)) {
-                float pulse = 0.7f + 0.3f * std::sin(static_cast<float>(ImGui::GetTime()) * 2.5f);
-                char talentBuf[40];
-                snprintf(talentBuf, sizeof(talentBuf), "! %u Talent Point%s Available",
-                         static_cast<unsigned>(unspent), unspent == 1 ? "" : "s");
-                ImGui::TextColored(ImVec4(0.3f, 1.0f, 0.3f * pulse, pulse), "%s", talentBuf);
-            }
-            ImGui::End();
-            nextIndicatorY += kIndicatorH;
-        }
-    }
-
-    // BG queue status indicator (when in queue but not yet invited)
-    for (const auto& slot : gameHandler.getBgQueues()) {
-        if (slot.statusId != 1) continue;  // STATUS_WAIT_QUEUE only
-
-        std::string bgName;
-        if (slot.arenaType > 0) {
-            bgName = std::to_string(slot.arenaType) + "v" + std::to_string(slot.arenaType) + " Arena";
-        } else {
-            switch (slot.bgTypeId) {
-                case 1: bgName = "AV"; break;
-                case 2: bgName = "WSG"; break;
-                case 3: bgName = "AB"; break;
-                case 7: bgName = "EotS"; break;
-                case 9: bgName = "SotA"; break;
-                case 11: bgName = "IoC"; break;
-                default: bgName = "BG"; break;
-            }
-        }
-
-        ImGui::SetNextWindowPos(ImVec2(indicatorX, nextIndicatorY), ImGuiCond_Always);
-        ImGui::SetNextWindowSize(ImVec2(indicatorW, kIndicatorH), ImGuiCond_Always);
-        if (ImGui::Begin("##BgQueueIndicator", nullptr, indicatorFlags)) {
-            float pulse = 0.6f + 0.4f * std::sin(static_cast<float>(ImGui::GetTime()) * 1.5f);
-            if (slot.avgWaitTimeSec > 0) {
-                int avgMin = static_cast<int>(slot.avgWaitTimeSec) / 60;
-                int avgSec = static_cast<int>(slot.avgWaitTimeSec) % 60;
-                ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, pulse),
-                    "Queue: %s (~%d:%02d)", bgName.c_str(), avgMin, avgSec);
-            } else {
-                ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, pulse),
-                    "In Queue: %s", bgName.c_str());
-            }
-        }
-        ImGui::End();
-        nextIndicatorY += kIndicatorH;
-        break;  // Show at most one queue slot indicator
-    }
-
-    // LFG queue indicator — shown when Dungeon Finder queue is active (Queued or RoleCheck)
-    {
-        using LfgState = game::GameHandler::LfgState;
-        LfgState lfgSt = gameHandler.getLfgState();
-        if (lfgSt == LfgState::Queued || lfgSt == LfgState::RoleCheck) {
-            ImGui::SetNextWindowPos(ImVec2(indicatorX, nextIndicatorY), ImGuiCond_Always);
-            ImGui::SetNextWindowSize(ImVec2(indicatorW, kIndicatorH), ImGuiCond_Always);
-            if (ImGui::Begin("##LfgQueueIndicator", nullptr, indicatorFlags)) {
-                if (lfgSt == LfgState::RoleCheck) {
-                    float pulse = 0.6f + 0.4f * std::sin(static_cast<float>(ImGui::GetTime()) * 3.0f);
-                    ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.2f, pulse), "LFG: Role Check...");
-                } else {
-                    uint32_t qMs  = gameHandler.getLfgTimeInQueueMs();
-                    int      qMin = static_cast<int>(qMs / 60000);
-                    int      qSec = static_cast<int>((qMs % 60000) / 1000);
-                    float pulse = 0.6f + 0.4f * std::sin(static_cast<float>(ImGui::GetTime()) * 1.2f);
-                    ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, pulse),
-                        "LFG: %d:%02d", qMin, qSec);
-                }
-            }
-            ImGui::End();
-            nextIndicatorY += kIndicatorH;
-        }
-    }
-
-    // Calendar pending invites indicator (WotLK only)
-    {
-        auto* expReg = services_.expansionRegistry;
-        bool isWotLK = expReg && expReg->getActive() && expReg->getActive()->id == "wotlk";
-        if (isWotLK) {
-            uint32_t calPending = gameHandler.getCalendarPendingInvites();
-            if (calPending > 0) {
-                ImGui::SetNextWindowPos(ImVec2(indicatorX, nextIndicatorY), ImGuiCond_Always);
-                ImGui::SetNextWindowSize(ImVec2(indicatorW, kIndicatorH), ImGuiCond_Always);
-                if (ImGui::Begin("##CalendarIndicator", nullptr, indicatorFlags)) {
-                    float pulse = 0.7f + 0.3f * std::sin(static_cast<float>(ImGui::GetTime()) * 2.0f);
-                    char calBuf[48];
-                    snprintf(calBuf, sizeof(calBuf), "Calendar: %u Invite%s",
-                             calPending, calPending == 1 ? "" : "s");
-                    ImGui::TextColored(ImVec4(0.6f, 0.5f, 1.0f, pulse), "%s", calBuf);
-                }
-                ImGui::End();
-                nextIndicatorY += kIndicatorH;
-            }
-        }
-    }
-
-    // Taxi flight indicator — shown while on a flight path
-    if (gameHandler.isOnTaxiFlight()) {
-        ImGui::SetNextWindowPos(ImVec2(indicatorX, nextIndicatorY), ImGuiCond_Always);
-        ImGui::SetNextWindowSize(ImVec2(indicatorW, kIndicatorH), ImGuiCond_Always);
-        if (ImGui::Begin("##TaxiIndicator", nullptr, indicatorFlags)) {
-            const std::string& dest = gameHandler.getTaxiDestName();
-            float pulse = 0.7f + 0.3f * std::sin(static_cast<float>(ImGui::GetTime()) * 1.0f);
-            if (dest.empty()) {
-                ImGui::TextColored(ImVec4(0.6f, 0.85f, 1.0f, pulse), "\xe2\x9c\x88 In Flight");
-            } else {
-                char buf[64];
-                snprintf(buf, sizeof(buf), "\xe2\x9c\x88 \xe2\x86\x92 %s", dest.c_str());
-                ImGui::TextColored(ImVec4(0.6f, 0.85f, 1.0f, pulse), "%s", buf);
-            }
-        }
-        ImGui::End();
-        nextIndicatorY += kIndicatorH;
-    }
-
-    // Latency + FPS indicator — centered at top of screen
-    uint32_t latMs = gameHandler.getLatencyMs();
-    if (settingsPanel_.showLatencyMeter_ && gameHandler.getState() == game::WorldState::IN_WORLD) {
-        float currentFps = ImGui::GetIO().Framerate;
-        ImVec4 latColor;
-        if      (latMs < 100) latColor = ImVec4(0.3f, 1.0f, 0.3f, 0.9f);
-        else if (latMs < 250) latColor = ImVec4(1.0f, 1.0f, 0.3f, 0.9f);
-        else if (latMs < 500) latColor = ImVec4(1.0f, 0.6f, 0.1f, 0.9f);
-        else                  latColor = ImVec4(1.0f, 0.2f, 0.2f, 0.9f);
-
-        ImVec4 fpsColor;
-        if      (currentFps >= 60.0f) fpsColor = ImVec4(0.3f, 1.0f, 0.3f, 0.9f);
-        else if (currentFps >= 30.0f) fpsColor = ImVec4(1.0f, 1.0f, 0.3f, 0.9f);
-        else                          fpsColor = ImVec4(1.0f, 0.3f, 0.3f, 0.9f);
-
-        char infoText[64];
-        if (latMs > 0)
-            snprintf(infoText, sizeof(infoText), "%.0f fps  |  %u ms", currentFps, latMs);
-        else
-            snprintf(infoText, sizeof(infoText), "%.0f fps", currentFps);
-
-        ImVec2 textSize = ImGui::CalcTextSize(infoText);
-        float latW = textSize.x + 16.0f;
-        float latH = textSize.y + 8.0f;
-        ImGuiIO& lio = ImGui::GetIO();
-        float latX = (lio.DisplaySize.x - latW) * 0.5f;
-        ImGui::SetNextWindowPos(ImVec2(latX, 4.0f), ImGuiCond_Always);
-        ImGui::SetNextWindowSize(ImVec2(latW, latH), ImGuiCond_Always);
-        ImGui::SetNextWindowBgAlpha(0.45f);
-        if (ImGui::Begin("##LatencyIndicator", nullptr, indicatorFlags)) {
-            // Color the FPS and latency portions differently
-            ImGui::TextColored(fpsColor, "%.0f fps", currentFps);
-            if (latMs > 0) {
-                ImGui::SameLine(0, 4);
-                ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 0.7f), "|");
-                ImGui::SameLine(0, 4);
-                ImGui::TextColored(latColor, "%u ms", latMs);
-            }
-        }
-        ImGui::End();
-    }
-
-    // Low durability warning — shown when any equipped item has < 20% durability
-    if (gameHandler.getState() == game::WorldState::IN_WORLD) {
-        const auto& inv = gameHandler.getInventory();
-        float lowestDurPct = 1.0f;
-        for (int i = 0; i < game::Inventory::NUM_EQUIP_SLOTS; ++i) {
-            const auto& slot = inv.getEquipSlot(static_cast<game::EquipSlot>(i));
-            if (slot.empty()) continue;
-            const auto& it = slot.item;
-            if (it.maxDurability > 0) {
-                float pct = static_cast<float>(it.curDurability) / static_cast<float>(it.maxDurability);
-                if (pct < lowestDurPct) lowestDurPct = pct;
-            }
-        }
-        if (lowestDurPct < 0.20f) {
-            bool critical = (lowestDurPct < 0.05f);
-            float pulse = critical
-                ? (0.7f + 0.3f * std::sin(static_cast<float>(ImGui::GetTime()) * 4.0f))
-                : 1.0f;
-            ImVec4 durWarnColor = critical
-                ? ImVec4(1.0f, 0.2f, 0.2f, pulse)
-                : ImVec4(1.0f, 0.65f, 0.1f, 0.9f);
-            const char* durWarnText = critical ? "Item breaking!" : "Low durability";
-
-            ImGui::SetNextWindowPos(ImVec2(indicatorX, nextIndicatorY), ImGuiCond_Always);
-            ImGui::SetNextWindowSize(ImVec2(indicatorW, kIndicatorH), ImGuiCond_Always);
-            if (ImGui::Begin("##DurabilityIndicator", nullptr, indicatorFlags)) {
-                ImGui::TextColored(durWarnColor, "%s", durWarnText);
-            }
-            ImGui::End();
-            nextIndicatorY += kIndicatorH;
-        }
-    }
-
-    // Local time clock — always visible below minimap indicators
-    {
-        auto now = std::chrono::system_clock::now();
-        std::time_t tt = std::chrono::system_clock::to_time_t(now);
-        struct tm tmBuf;
-#ifdef _WIN32
-        localtime_s(&tmBuf, &tt);
-#else
-        localtime_r(&tt, &tmBuf);
-#endif
-        char clockStr[16];
-        snprintf(clockStr, sizeof(clockStr), "%02d:%02d", tmBuf.tm_hour, tmBuf.tm_min);
-
-        ImGui::SetNextWindowPos(ImVec2(indicatorX, nextIndicatorY), ImGuiCond_Always);
-        ImGui::SetNextWindowSize(ImVec2(indicatorW, kIndicatorH), ImGuiCond_Always);
-        ImGuiWindowFlags clockFlags = indicatorFlags & ~ImGuiWindowFlags_NoInputs;
-        if (ImGui::Begin("##ClockIndicator", nullptr, clockFlags)) {
-            ImGui::TextColored(ImVec4(0.85f, 0.85f, 0.85f, 0.75f), "%s", clockStr);
-            if (ImGui::IsItemHovered()) {
-                char fullTime[32];
-                snprintf(fullTime, sizeof(fullTime), "%02d:%02d:%02d (local)",
-                         tmBuf.tm_hour, tmBuf.tm_min, tmBuf.tm_sec);
-                ImGui::SetTooltip("%s", fullTime);
-            }
-        }
-        ImGui::End();
+    }
+}
+
+std::string GameScreen::getSettingsPath() {
+    std::string dir;
+#ifdef _WIN32
+    const char* appdata = std::getenv("APPDATA");
+    dir = appdata ? std::string(appdata) + "\\wowee" : ".";
+#else
+    const char* home = std::getenv("HOME");
+    dir = home ? std::string(home) + "/.wowee" : ".";
+#endif
+    return dir + "/settings.cfg";
+}
+
+std::string GameScreen::replaceGenderPlaceholders(const std::string& text, game::GameHandler& gameHandler) {
+    // Get player gender, pronouns, and name
+    game::Gender gender = game::Gender::NONBINARY;
+    std::string playerName = "Adventurer";
+    const auto* character = gameHandler.getActiveCharacter();
+    if (character) {
+        gender = character->gender;
+        if (!character->name.empty()) {
+            playerName = character->name;
+        }
+    }
+    game::Pronouns pronouns = game::Pronouns::forGender(gender);
+
+    std::string result = text;
+
+    // Helper to trim whitespace
+    auto trim = [](std::string& s) {
+        const char* ws = " \t\n\r";
+        size_t start = s.find_first_not_of(ws);
+        if (start == std::string::npos) { s.clear(); return; }
+        size_t end = s.find_last_not_of(ws);
+        s = s.substr(start, end - start + 1);
+    };
+
+    // Replace $g/$G placeholders first.
+    size_t pos = 0;
+    while ((pos = result.find('$', pos)) != std::string::npos) {
+        if (pos + 1 >= result.length()) break;
+        char marker = result[pos + 1];
+        if (marker != 'g' && marker != 'G') { pos++; continue; }
+
+        size_t endPos = result.find(';', pos);
+        if (endPos == std::string::npos) { pos += 2; continue; }
+
+        std::string placeholder = result.substr(pos + 2, endPos - pos - 2);
+
+        // Split by colons
+        std::vector<std::string> parts;
+        size_t start = 0;
+        size_t colonPos;
+        while ((colonPos = placeholder.find(':', start)) != std::string::npos) {
+            std::string part = placeholder.substr(start, colonPos - start);
+            trim(part);
+            parts.push_back(part);
+            start = colonPos + 1;
+        }
+        // Add the last part
+        std::string lastPart = placeholder.substr(start);
+        trim(lastPart);
+        parts.push_back(lastPart);
+
+        // Select appropriate text based on gender
+        std::string replacement;
+        if (parts.size() >= 3) {
+            // Three options: male, female, nonbinary
+            switch (gender) {
+                case game::Gender::MALE:
+                    replacement = parts[0];
+                    break;
+                case game::Gender::FEMALE:
+                    replacement = parts[1];
+                    break;
+                case game::Gender::NONBINARY:
+                    replacement = parts[2];
+                    break;
+            }
+        } else if (parts.size() >= 2) {
+            // Two options: male, female (use first for nonbinary)
+            switch (gender) {
+                case game::Gender::MALE:
+                    replacement = parts[0];
+                    break;
+                case game::Gender::FEMALE:
+                    replacement = parts[1];
+                    break;
+                case game::Gender::NONBINARY:
+                    // Default to gender-neutral: use the shorter/simpler option
+                    replacement = parts[0].length() <= parts[1].length() ? parts[0] : parts[1];
+                    break;
+            }
+        } else {
+            // Malformed placeholder
+            pos = endPos + 1;
+            continue;
+        }
+
+        result.replace(pos, endPos - pos + 1, replacement);
+        pos += replacement.length();
+    }
+
+    // Replace simple placeholders.
+    // $n = player name
+    // $p = subject pronoun (he/she/they)
+    // $o = object pronoun (him/her/them)
+    // $s = possessive adjective (his/her/their)
+    // $S = possessive pronoun (his/hers/theirs)
+    // $b/$B = line break
+    pos = 0;
+    while ((pos = result.find('$', pos)) != std::string::npos) {
+        if (pos + 1 >= result.length()) break;
+
+        char code = result[pos + 1];
+        std::string replacement;
+        switch (code) {
+            case 'n': case 'N': replacement = playerName; break;
+            case 'p': replacement = pronouns.subject; break;
+            case 'o': replacement = pronouns.object; break;
+            case 's': replacement = pronouns.possessive; break;
+            case 'S': replacement = pronouns.possessiveP; break;
+            case 'b': case 'B': replacement = "\n"; break;
+            case 'g': case 'G': pos++; continue;
+            default: pos++; continue;
+        }
+
+        result.replace(pos, 2, replacement);
+        pos += replacement.length();
+    }
+
+    // WoW markup linebreak token.
+    pos = 0;
+    while ((pos = result.find("|n", pos)) != std::string::npos) {
+        result.replace(pos, 2, "\n");
+        pos += 1;
+    }
+    pos = 0;
+    while ((pos = result.find("|N", pos)) != std::string::npos) {
+        result.replace(pos, 2, "\n");
+        pos += 1;
+    }
+
+    return result;
+}
+
+void GameScreen::renderChatBubbles(game::GameHandler& gameHandler) {
+    if (chatBubbles_.empty()) return;
+
+    auto* renderer = core::Application::getInstance().getRenderer();
+    auto* camera = renderer ? renderer->getCamera() : nullptr;
+    if (!camera) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
+
+    // Get delta time from ImGui
+    float dt = ImGui::GetIO().DeltaTime;
+
+    glm::mat4 viewProj = camera->getProjectionMatrix() * camera->getViewMatrix();
+
+    // Update and render bubbles
+    for (int i = static_cast<int>(chatBubbles_.size()) - 1; i >= 0; --i) {
+        auto& bubble = chatBubbles_[i];
+        bubble.timeRemaining -= dt;
+        if (bubble.timeRemaining <= 0.0f) {
+            chatBubbles_.erase(chatBubbles_.begin() + i);
+            continue;
+        }
+
+        // Get entity position
+        auto entity = gameHandler.getEntityManager().getEntity(bubble.senderGuid);
+        if (!entity) continue;
+
+        // Convert canonical → render coordinates, offset up by 2.5 units for bubble above head
+        glm::vec3 canonical(entity->getX(), entity->getY(), entity->getZ() + 2.5f);
+        glm::vec3 renderPos = core::coords::canonicalToRender(canonical);
+
+        // Project to screen
+        glm::vec4 clipPos = viewProj * glm::vec4(renderPos, 1.0f);
+        if (clipPos.w <= 0.0f) continue;  // Behind camera
+
+        glm::vec2 ndc(clipPos.x / clipPos.w, clipPos.y / clipPos.w);
+        float screenX = (ndc.x * 0.5f + 0.5f) * screenW;
+        float screenY = (1.0f - (ndc.y * 0.5f + 0.5f)) * screenH;  // Flip Y
+
+        // Skip if off-screen
+        if (screenX < -200.0f || screenX > screenW + 200.0f ||
+            screenY < -100.0f || screenY > screenH + 100.0f) continue;
+
+        // Fade alpha over last 2 seconds
+        float alpha = 1.0f;
+        if (bubble.timeRemaining < 2.0f) {
+            alpha = bubble.timeRemaining / 2.0f;
+        }
+
+        // Draw bubble window
+        std::string winId = "##ChatBubble" + std::to_string(bubble.senderGuid);
+        ImGui::SetNextWindowPos(ImVec2(screenX, screenY), ImGuiCond_Always, ImVec2(0.5f, 1.0f));
+        ImGui::SetNextWindowBgAlpha(0.7f * alpha);
+        ImGuiWindowFlags flags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
+            ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar |
+            ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoInputs |
+            ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav;
+
+        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.0f);
+        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(8, 4));
+
+        ImGui::Begin(winId.c_str(), nullptr, flags);
+
+        ImVec4 textColor = bubble.isYell
+            ? ImVec4(1.0f, 0.2f, 0.2f, alpha)
+            : ImVec4(1.0f, 1.0f, 1.0f, alpha);
+
+        ImGui::PushStyleColor(ImGuiCol_Text, textColor);
+        ImGui::PushTextWrapPos(200.0f);
+        ImGui::TextWrapped("%s", bubble.message.c_str());
+        ImGui::PopTextWrapPos();
+        ImGui::PopStyleColor();
+
+        ImGui::End();
+        ImGui::PopStyleVar(2);
     }
 }
 
 void GameScreen::saveSettings() {
-    std::string path = SettingsPanel::getSettingsPath();
+    std::string path = getSettingsPath();
     std::filesystem::path dir = std::filesystem::path(path).parent_path();
     std::error_code ec;
     std::filesystem::create_directories(dir, ec);
@@ -6750,102 +8395,67 @@ void GameScreen::saveSettings() {
     }
 
     // Interface
-    out << "ui_opacity=" << settingsPanel_.pendingUiOpacity << "\n";
-    out << "minimap_rotate=" << (settingsPanel_.pendingMinimapRotate ? 1 : 0) << "\n";
-    out << "minimap_square=" << (settingsPanel_.pendingMinimapSquare ? 1 : 0) << "\n";
-    out << "minimap_npc_dots=" << (settingsPanel_.pendingMinimapNpcDots ? 1 : 0) << "\n";
-    out << "show_latency_meter=" << (settingsPanel_.pendingShowLatencyMeter ? 1 : 0) << "\n";
-    out << "show_dps_meter=" << (settingsPanel_.showDPSMeter_ ? 1 : 0) << "\n";
-    out << "show_cooldown_tracker=" << (settingsPanel_.showCooldownTracker_ ? 1 : 0) << "\n";
-    out << "separate_bags=" << (settingsPanel_.pendingSeparateBags ? 1 : 0) << "\n";
-    out << "show_keyring=" << (settingsPanel_.pendingShowKeyring ? 1 : 0) << "\n";
-    out << "action_bar_scale=" << settingsPanel_.pendingActionBarScale << "\n";
-    out << "nameplate_scale=" << settingsPanel_.nameplateScale_ << "\n";
-    out << "show_friendly_nameplates=" << (settingsPanel_.showFriendlyNameplates_ ? 1 : 0) << "\n";
-    out << "show_action_bar2=" << (settingsPanel_.pendingShowActionBar2 ? 1 : 0) << "\n";
-    out << "action_bar2_offset_x=" << settingsPanel_.pendingActionBar2OffsetX << "\n";
-    out << "action_bar2_offset_y=" << settingsPanel_.pendingActionBar2OffsetY << "\n";
-    out << "show_right_bar=" << (settingsPanel_.pendingShowRightBar ? 1 : 0) << "\n";
-    out << "show_left_bar=" << (settingsPanel_.pendingShowLeftBar ? 1 : 0) << "\n";
-    out << "right_bar_offset_y=" << settingsPanel_.pendingRightBarOffsetY << "\n";
-    out << "left_bar_offset_y=" << settingsPanel_.pendingLeftBarOffsetY << "\n";
-    out << "damage_flash=" << (settingsPanel_.damageFlashEnabled_ ? 1 : 0) << "\n";
-    out << "low_health_vignette=" << (settingsPanel_.lowHealthVignetteEnabled_ ? 1 : 0) << "\n";
+    out << "ui_opacity=" << pendingUiOpacity << "\n";
+    out << "minimap_rotate=" << (pendingMinimapRotate ? 1 : 0) << "\n";
+    out << "minimap_square=" << (pendingMinimapSquare ? 1 : 0) << "\n";
+    out << "minimap_npc_dots=" << (pendingMinimapNpcDots ? 1 : 0) << "\n";
+    out << "separate_bags=" << (pendingSeparateBags ? 1 : 0) << "\n";
 
     // Audio
-    out << "sound_muted=" << (settingsPanel_.soundMuted_ ? 1 : 0) << "\n";
-    out << "use_original_soundtrack=" << (settingsPanel_.pendingUseOriginalSoundtrack ? 1 : 0) << "\n";
-    out << "master_volume=" << settingsPanel_.pendingMasterVolume << "\n";
-    out << "music_volume=" << settingsPanel_.pendingMusicVolume << "\n";
-    out << "ambient_volume=" << settingsPanel_.pendingAmbientVolume << "\n";
-    out << "ui_volume=" << settingsPanel_.pendingUiVolume << "\n";
-    out << "combat_volume=" << settingsPanel_.pendingCombatVolume << "\n";
-    out << "spell_volume=" << settingsPanel_.pendingSpellVolume << "\n";
-    out << "movement_volume=" << settingsPanel_.pendingMovementVolume << "\n";
-    out << "footstep_volume=" << settingsPanel_.pendingFootstepVolume << "\n";
-    out << "npc_voice_volume=" << settingsPanel_.pendingNpcVoiceVolume << "\n";
-    out << "mount_volume=" << settingsPanel_.pendingMountVolume << "\n";
-    out << "activity_volume=" << settingsPanel_.pendingActivityVolume << "\n";
+    out << "sound_muted=" << (soundMuted_ ? 1 : 0) << "\n";
+    out << "use_original_soundtrack=" << (pendingUseOriginalSoundtrack ? 1 : 0) << "\n";
+    out << "master_volume=" << pendingMasterVolume << "\n";
+    out << "music_volume=" << pendingMusicVolume << "\n";
+    out << "ambient_volume=" << pendingAmbientVolume << "\n";
+    out << "ui_volume=" << pendingUiVolume << "\n";
+    out << "combat_volume=" << pendingCombatVolume << "\n";
+    out << "spell_volume=" << pendingSpellVolume << "\n";
+    out << "movement_volume=" << pendingMovementVolume << "\n";
+    out << "footstep_volume=" << pendingFootstepVolume << "\n";
+    out << "npc_voice_volume=" << pendingNpcVoiceVolume << "\n";
+    out << "mount_volume=" << pendingMountVolume << "\n";
+    out << "activity_volume=" << pendingActivityVolume << "\n";
 
     // Gameplay
-    out << "auto_loot=" << (settingsPanel_.pendingAutoLoot ? 1 : 0) << "\n";
-    out << "auto_sell_grey=" << (settingsPanel_.pendingAutoSellGrey ? 1 : 0) << "\n";
-    out << "auto_repair=" << (settingsPanel_.pendingAutoRepair ? 1 : 0) << "\n";
-    out << "graphics_preset=" << static_cast<int>(settingsPanel_.currentGraphicsPreset) << "\n";
-    out << "ground_clutter_density=" << settingsPanel_.pendingGroundClutterDensity << "\n";
-    out << "shadows=" << (settingsPanel_.pendingShadows ? 1 : 0) << "\n";
-    out << "shadow_distance=" << settingsPanel_.pendingShadowDistance << "\n";
-    out << "brightness=" << settingsPanel_.pendingBrightness << "\n";
-    out << "water_refraction=" << (settingsPanel_.pendingWaterRefraction ? 1 : 0) << "\n";
-    out << "antialiasing=" << settingsPanel_.pendingAntiAliasing << "\n";
-    out << "fxaa=" << (settingsPanel_.pendingFXAA ? 1 : 0) << "\n";
-    out << "normal_mapping=" << (settingsPanel_.pendingNormalMapping ? 1 : 0) << "\n";
-    out << "normal_map_strength=" << settingsPanel_.pendingNormalMapStrength << "\n";
-    out << "pom=" << (settingsPanel_.pendingPOM ? 1 : 0) << "\n";
-    out << "pom_quality=" << settingsPanel_.pendingPOMQuality << "\n";
-    out << "upscaling_mode=" << settingsPanel_.pendingUpscalingMode << "\n";
-    out << "fsr=" << (settingsPanel_.pendingFSR ? 1 : 0) << "\n";
-    out << "fsr_quality=" << settingsPanel_.pendingFSRQuality << "\n";
-    out << "fsr_sharpness=" << settingsPanel_.pendingFSRSharpness << "\n";
-    out << "fsr2_jitter_sign=" << settingsPanel_.pendingFSR2JitterSign << "\n";
-    out << "fsr2_mv_scale_x=" << settingsPanel_.pendingFSR2MotionVecScaleX << "\n";
-    out << "fsr2_mv_scale_y=" << settingsPanel_.pendingFSR2MotionVecScaleY << "\n";
-    out << "amd_fsr3_framegen=" << (settingsPanel_.pendingAMDFramegen ? 1 : 0) << "\n";
+    out << "auto_loot=" << (pendingAutoLoot ? 1 : 0) << "\n";
+    out << "ground_clutter_density=" << pendingGroundClutterDensity << "\n";
+    out << "shadows=" << (pendingShadows ? 1 : 0) << "\n";
+    out << "shadow_distance=" << pendingShadowDistance << "\n";
+    out << "water_refraction=" << (pendingWaterRefraction ? 1 : 0) << "\n";
+    out << "antialiasing=" << pendingAntiAliasing << "\n";
+    out << "normal_mapping=" << (pendingNormalMapping ? 1 : 0) << "\n";
+    out << "normal_map_strength=" << pendingNormalMapStrength << "\n";
+    out << "pom=" << (pendingPOM ? 1 : 0) << "\n";
+    out << "pom_quality=" << pendingPOMQuality << "\n";
+    out << "upscaling_mode=" << pendingUpscalingMode << "\n";
+    out << "fsr=" << (pendingFSR ? 1 : 0) << "\n";
+    out << "fsr_quality=" << pendingFSRQuality << "\n";
+    out << "fsr_sharpness=" << pendingFSRSharpness << "\n";
+    out << "fsr2_jitter_sign=" << pendingFSR2JitterSign << "\n";
+    out << "fsr2_mv_scale_x=" << pendingFSR2MotionVecScaleX << "\n";
+    out << "fsr2_mv_scale_y=" << pendingFSR2MotionVecScaleY << "\n";
+    out << "amd_fsr3_framegen=" << (pendingAMDFramegen ? 1 : 0) << "\n";
 
     // Controls
-    out << "mouse_sensitivity=" << settingsPanel_.pendingMouseSensitivity << "\n";
-    out << "invert_mouse=" << (settingsPanel_.pendingInvertMouse ? 1 : 0) << "\n";
-    out << "extended_zoom=" << (settingsPanel_.pendingExtendedZoom ? 1 : 0) << "\n";
-    out << "camera_stiffness=" << settingsPanel_.pendingCameraStiffness << "\n";
-    out << "camera_pivot_height=" << settingsPanel_.pendingPivotHeight << "\n";
-    out << "fov=" << settingsPanel_.pendingFov << "\n";
-
-    // Quest tracker position/size
-    out << "quest_tracker_right_offset=" << questTrackerRightOffset_ << "\n";
-    out << "quest_tracker_y=" << questTrackerPos_.y << "\n";
-    out << "quest_tracker_w=" << questTrackerSize_.x << "\n";
-    out << "quest_tracker_h=" << questTrackerSize_.y << "\n";
+    out << "mouse_sensitivity=" << pendingMouseSensitivity << "\n";
+    out << "invert_mouse=" << (pendingInvertMouse ? 1 : 0) << "\n";
+    out << "extended_zoom=" << (pendingExtendedZoom ? 1 : 0) << "\n";
 
     // Chat
-    out << "chat_active_tab=" << chatPanel_.activeChatTab << "\n";
-    out << "chat_timestamps=" << (chatPanel_.chatShowTimestamps ? 1 : 0) << "\n";
-    out << "chat_font_size=" << chatPanel_.chatFontSize << "\n";
-    out << "chat_autojoin_general=" << (chatPanel_.chatAutoJoinGeneral ? 1 : 0) << "\n";
-    out << "chat_autojoin_trade=" << (chatPanel_.chatAutoJoinTrade ? 1 : 0) << "\n";
-    out << "chat_autojoin_localdefense=" << (chatPanel_.chatAutoJoinLocalDefense ? 1 : 0) << "\n";
-    out << "chat_autojoin_lfg=" << (chatPanel_.chatAutoJoinLFG ? 1 : 0) << "\n";
-    out << "chat_autojoin_local=" << (chatPanel_.chatAutoJoinLocal ? 1 : 0) << "\n";
-
-    out.close();
-
-    // Save keybindings to the same config file (appends [Keybindings] section)
-    KeybindingManager::getInstance().saveToConfigFile(path);
+    out << "chat_active_tab=" << activeChatTab_ << "\n";
+    out << "chat_timestamps=" << (chatShowTimestamps_ ? 1 : 0) << "\n";
+    out << "chat_font_size=" << chatFontSize_ << "\n";
+    out << "chat_autojoin_general=" << (chatAutoJoinGeneral_ ? 1 : 0) << "\n";
+    out << "chat_autojoin_trade=" << (chatAutoJoinTrade_ ? 1 : 0) << "\n";
+    out << "chat_autojoin_localdefense=" << (chatAutoJoinLocalDefense_ ? 1 : 0) << "\n";
+    out << "chat_autojoin_lfg=" << (chatAutoJoinLFG_ ? 1 : 0) << "\n";
+    out << "chat_autojoin_local=" << (chatAutoJoinLocal_ ? 1 : 0) << "\n";
 
     LOG_INFO("Settings saved to ", path);
 }
 
 void GameScreen::loadSettings() {
-    std::string path = SettingsPanel::getSettingsPath();
+    std::string path = getSettingsPath();
     std::ifstream in(path);
     if (!in.is_open()) return;
 
@@ -6861,163 +8471,85 @@ void GameScreen::loadSettings() {
             if (key == "ui_opacity") {
                 int v = std::stoi(val);
                 if (v >= 20 && v <= 100) {
-                    settingsPanel_.pendingUiOpacity = v;
-                    settingsPanel_.uiOpacity_ = static_cast<float>(v) / 100.0f;
+                    pendingUiOpacity = v;
+                    uiOpacity_ = static_cast<float>(v) / 100.0f;
                 }
             } else if (key == "minimap_rotate") {
                 // Ignore persisted rotate state; keep north-up.
-                settingsPanel_.minimapRotate_ = false;
-                settingsPanel_.pendingMinimapRotate = false;
+                minimapRotate_ = false;
+                pendingMinimapRotate = false;
             } else if (key == "minimap_square") {
                 int v = std::stoi(val);
-                settingsPanel_.minimapSquare_ = (v != 0);
-                settingsPanel_.pendingMinimapSquare = settingsPanel_.minimapSquare_;
+                minimapSquare_ = (v != 0);
+                pendingMinimapSquare = minimapSquare_;
             } else if (key == "minimap_npc_dots") {
                 int v = std::stoi(val);
-                settingsPanel_.minimapNpcDots_ = (v != 0);
-                settingsPanel_.pendingMinimapNpcDots = settingsPanel_.minimapNpcDots_;
-            } else if (key == "show_latency_meter") {
-                settingsPanel_.showLatencyMeter_ = (std::stoi(val) != 0);
-                settingsPanel_.pendingShowLatencyMeter = settingsPanel_.showLatencyMeter_;
-            } else if (key == "show_dps_meter") {
-                settingsPanel_.showDPSMeter_ = (std::stoi(val) != 0);
-            } else if (key == "show_cooldown_tracker") {
-                settingsPanel_.showCooldownTracker_ = (std::stoi(val) != 0);
+                minimapNpcDots_ = (v != 0);
+                pendingMinimapNpcDots = minimapNpcDots_;
             } else if (key == "separate_bags") {
-                settingsPanel_.pendingSeparateBags = (std::stoi(val) != 0);
-                inventoryScreen.setSeparateBags(settingsPanel_.pendingSeparateBags);
-            } else if (key == "show_keyring") {
-                settingsPanel_.pendingShowKeyring = (std::stoi(val) != 0);
-                inventoryScreen.setShowKeyring(settingsPanel_.pendingShowKeyring);
-            } else if (key == "action_bar_scale") {
-                settingsPanel_.pendingActionBarScale = std::clamp(std::stof(val), 0.5f, 1.5f);
-            } else if (key == "nameplate_scale") {
-                settingsPanel_.nameplateScale_ = std::clamp(std::stof(val), 0.5f, 2.0f);
-            } else if (key == "show_friendly_nameplates") {
-                settingsPanel_.showFriendlyNameplates_ = (std::stoi(val) != 0);
-            } else if (key == "show_action_bar2") {
-                settingsPanel_.pendingShowActionBar2 = (std::stoi(val) != 0);
-            } else if (key == "action_bar2_offset_x") {
-                settingsPanel_.pendingActionBar2OffsetX = std::clamp(std::stof(val), -600.0f, 600.0f);
-            } else if (key == "action_bar2_offset_y") {
-                settingsPanel_.pendingActionBar2OffsetY = std::clamp(std::stof(val), -400.0f, 400.0f);
-            } else if (key == "show_right_bar") {
-                settingsPanel_.pendingShowRightBar = (std::stoi(val) != 0);
-            } else if (key == "show_left_bar") {
-                settingsPanel_.pendingShowLeftBar = (std::stoi(val) != 0);
-            } else if (key == "right_bar_offset_y") {
-                settingsPanel_.pendingRightBarOffsetY = std::clamp(std::stof(val), -400.0f, 400.0f);
-            } else if (key == "left_bar_offset_y") {
-                settingsPanel_.pendingLeftBarOffsetY = std::clamp(std::stof(val), -400.0f, 400.0f);
-            } else if (key == "damage_flash") {
-                settingsPanel_.damageFlashEnabled_ = (std::stoi(val) != 0);
-            } else if (key == "low_health_vignette") {
-                settingsPanel_.lowHealthVignetteEnabled_ = (std::stoi(val) != 0);
+                pendingSeparateBags = (std::stoi(val) != 0);
+                inventoryScreen.setSeparateBags(pendingSeparateBags);
             }
             // Audio
             else if (key == "sound_muted") {
-                settingsPanel_.soundMuted_ = (std::stoi(val) != 0);
-                if (settingsPanel_.soundMuted_) {
-                    // Apply mute on load; settingsPanel_.preMuteVolume_ will be set when AudioEngine is available
+                soundMuted_ = (std::stoi(val) != 0);
+                if (soundMuted_) {
+                    // Apply mute on load; preMuteVolume_ will be set when AudioEngine is available
                     audio::AudioEngine::instance().setMasterVolume(0.0f);
                 }
             }
-            else if (key == "use_original_soundtrack") settingsPanel_.pendingUseOriginalSoundtrack = (std::stoi(val) != 0);
-            else if (key == "master_volume") settingsPanel_.pendingMasterVolume = std::clamp(std::stoi(val), 0, 100);
-            else if (key == "music_volume") settingsPanel_.pendingMusicVolume = std::clamp(std::stoi(val), 0, 100);
-            else if (key == "ambient_volume") settingsPanel_.pendingAmbientVolume = std::clamp(std::stoi(val), 0, 100);
-            else if (key == "ui_volume") settingsPanel_.pendingUiVolume = std::clamp(std::stoi(val), 0, 100);
-            else if (key == "combat_volume") settingsPanel_.pendingCombatVolume = std::clamp(std::stoi(val), 0, 100);
-            else if (key == "spell_volume") settingsPanel_.pendingSpellVolume = std::clamp(std::stoi(val), 0, 100);
-            else if (key == "movement_volume") settingsPanel_.pendingMovementVolume = std::clamp(std::stoi(val), 0, 100);
-            else if (key == "footstep_volume") settingsPanel_.pendingFootstepVolume = std::clamp(std::stoi(val), 0, 100);
-            else if (key == "npc_voice_volume") settingsPanel_.pendingNpcVoiceVolume = std::clamp(std::stoi(val), 0, 100);
-            else if (key == "mount_volume") settingsPanel_.pendingMountVolume = std::clamp(std::stoi(val), 0, 100);
-            else if (key == "activity_volume") settingsPanel_.pendingActivityVolume = std::clamp(std::stoi(val), 0, 100);
+            else if (key == "use_original_soundtrack") pendingUseOriginalSoundtrack = (std::stoi(val) != 0);
+            else if (key == "master_volume") pendingMasterVolume = std::clamp(std::stoi(val), 0, 100);
+            else if (key == "music_volume") pendingMusicVolume = std::clamp(std::stoi(val), 0, 100);
+            else if (key == "ambient_volume") pendingAmbientVolume = std::clamp(std::stoi(val), 0, 100);
+            else if (key == "ui_volume") pendingUiVolume = std::clamp(std::stoi(val), 0, 100);
+            else if (key == "combat_volume") pendingCombatVolume = std::clamp(std::stoi(val), 0, 100);
+            else if (key == "spell_volume") pendingSpellVolume = std::clamp(std::stoi(val), 0, 100);
+            else if (key == "movement_volume") pendingMovementVolume = std::clamp(std::stoi(val), 0, 100);
+            else if (key == "footstep_volume") pendingFootstepVolume = std::clamp(std::stoi(val), 0, 100);
+            else if (key == "npc_voice_volume") pendingNpcVoiceVolume = std::clamp(std::stoi(val), 0, 100);
+            else if (key == "mount_volume") pendingMountVolume = std::clamp(std::stoi(val), 0, 100);
+            else if (key == "activity_volume") pendingActivityVolume = std::clamp(std::stoi(val), 0, 100);
             // Gameplay
-            else if (key == "auto_loot") settingsPanel_.pendingAutoLoot = (std::stoi(val) != 0);
-            else if (key == "auto_sell_grey") settingsPanel_.pendingAutoSellGrey = (std::stoi(val) != 0);
-            else if (key == "auto_repair") settingsPanel_.pendingAutoRepair = (std::stoi(val) != 0);
-            else if (key == "graphics_preset") {
-                int presetVal = std::clamp(std::stoi(val), 0, 4);
-                settingsPanel_.currentGraphicsPreset = static_cast<SettingsPanel::GraphicsPreset>(presetVal);
-                settingsPanel_.pendingGraphicsPreset = settingsPanel_.currentGraphicsPreset;
-            }
-            else if (key == "ground_clutter_density") settingsPanel_.pendingGroundClutterDensity = std::clamp(std::stoi(val), 0, 150);
-            else if (key == "shadows") settingsPanel_.pendingShadows = (std::stoi(val) != 0);
-            else if (key == "shadow_distance") settingsPanel_.pendingShadowDistance = std::clamp(std::stof(val), 40.0f, 500.0f);
-            else if (key == "brightness") {
-                settingsPanel_.pendingBrightness = std::clamp(std::stoi(val), 0, 100);
-                if (auto* r = services_.renderer)
-                    r->setBrightness(static_cast<float>(settingsPanel_.pendingBrightness) / 50.0f);
-            }
-            else if (key == "water_refraction") settingsPanel_.pendingWaterRefraction = (std::stoi(val) != 0);
-            else if (key == "antialiasing") settingsPanel_.pendingAntiAliasing = std::clamp(std::stoi(val), 0, 3);
-            else if (key == "fxaa") settingsPanel_.pendingFXAA = (std::stoi(val) != 0);
-            else if (key == "normal_mapping") settingsPanel_.pendingNormalMapping = (std::stoi(val) != 0);
-            else if (key == "normal_map_strength") settingsPanel_.pendingNormalMapStrength = std::clamp(std::stof(val), 0.0f, 2.0f);
-            else if (key == "pom") settingsPanel_.pendingPOM = (std::stoi(val) != 0);
-            else if (key == "pom_quality") settingsPanel_.pendingPOMQuality = std::clamp(std::stoi(val), 0, 2);
+            else if (key == "auto_loot") pendingAutoLoot = (std::stoi(val) != 0);
+            else if (key == "ground_clutter_density") pendingGroundClutterDensity = std::clamp(std::stoi(val), 0, 150);
+            else if (key == "shadows") pendingShadows = (std::stoi(val) != 0);
+            else if (key == "shadow_distance") pendingShadowDistance = std::clamp(std::stof(val), 40.0f, 500.0f);
+            else if (key == "water_refraction") pendingWaterRefraction = (std::stoi(val) != 0);
+            else if (key == "antialiasing") pendingAntiAliasing = std::clamp(std::stoi(val), 0, 3);
+            else if (key == "normal_mapping") pendingNormalMapping = (std::stoi(val) != 0);
+            else if (key == "normal_map_strength") pendingNormalMapStrength = std::clamp(std::stof(val), 0.0f, 2.0f);
+            else if (key == "pom") pendingPOM = (std::stoi(val) != 0);
+            else if (key == "pom_quality") pendingPOMQuality = std::clamp(std::stoi(val), 0, 2);
             else if (key == "upscaling_mode") {
-                settingsPanel_.pendingUpscalingMode = std::clamp(std::stoi(val), 0, 2);
-                settingsPanel_.pendingFSR = (settingsPanel_.pendingUpscalingMode == 1);
+                pendingUpscalingMode = std::clamp(std::stoi(val), 0, 2);
+                pendingFSR = (pendingUpscalingMode == 1);
             } else if (key == "fsr") {
-                settingsPanel_.pendingFSR = (std::stoi(val) != 0);
+                pendingFSR = (std::stoi(val) != 0);
                 // Backward compatibility: old configs only had fsr=0/1.
-                if (settingsPanel_.pendingUpscalingMode == 0 && settingsPanel_.pendingFSR) settingsPanel_.pendingUpscalingMode = 1;
+                if (pendingUpscalingMode == 0 && pendingFSR) pendingUpscalingMode = 1;
             }
-            else if (key == "fsr_quality") settingsPanel_.pendingFSRQuality = std::clamp(std::stoi(val), 0, 3);
-            else if (key == "fsr_sharpness") settingsPanel_.pendingFSRSharpness = std::clamp(std::stof(val), 0.0f, 2.0f);
-            else if (key == "fsr2_jitter_sign") settingsPanel_.pendingFSR2JitterSign = std::clamp(std::stof(val), -2.0f, 2.0f);
-            else if (key == "fsr2_mv_scale_x") settingsPanel_.pendingFSR2MotionVecScaleX = std::clamp(std::stof(val), -2.0f, 2.0f);
-            else if (key == "fsr2_mv_scale_y") settingsPanel_.pendingFSR2MotionVecScaleY = std::clamp(std::stof(val), -2.0f, 2.0f);
-            else if (key == "amd_fsr3_framegen") settingsPanel_.pendingAMDFramegen = (std::stoi(val) != 0);
+            else if (key == "fsr_quality") pendingFSRQuality = std::clamp(std::stoi(val), 0, 3);
+            else if (key == "fsr_sharpness") pendingFSRSharpness = std::clamp(std::stof(val), 0.0f, 2.0f);
+            else if (key == "fsr2_jitter_sign") pendingFSR2JitterSign = std::clamp(std::stof(val), -2.0f, 2.0f);
+            else if (key == "fsr2_mv_scale_x") pendingFSR2MotionVecScaleX = std::clamp(std::stof(val), -2.0f, 2.0f);
+            else if (key == "fsr2_mv_scale_y") pendingFSR2MotionVecScaleY = std::clamp(std::stof(val), -2.0f, 2.0f);
+            else if (key == "amd_fsr3_framegen") pendingAMDFramegen = (std::stoi(val) != 0);
             // Controls
-            else if (key == "mouse_sensitivity") settingsPanel_.pendingMouseSensitivity = std::clamp(std::stof(val), 0.05f, 1.0f);
-            else if (key == "invert_mouse") settingsPanel_.pendingInvertMouse = (std::stoi(val) != 0);
-            else if (key == "extended_zoom") settingsPanel_.pendingExtendedZoom = (std::stoi(val) != 0);
-            else if (key == "camera_stiffness") settingsPanel_.pendingCameraStiffness = std::clamp(std::stof(val), 5.0f, 100.0f);
-            else if (key == "camera_pivot_height") settingsPanel_.pendingPivotHeight = std::clamp(std::stof(val), 0.0f, 3.0f);
-            else if (key == "fov") {
-                settingsPanel_.pendingFov = std::clamp(std::stof(val), 45.0f, 110.0f);
-                if (auto* renderer = services_.renderer) {
-                    if (auto* camera = renderer->getCamera()) camera->setFov(settingsPanel_.pendingFov);
-                }
-            }
-            // Quest tracker position/size
-            else if (key == "quest_tracker_x") {
-                // Legacy: ignore absolute X (right_offset supersedes it)
-                (void)val;
-            }
-            else if (key == "quest_tracker_right_offset") {
-                questTrackerRightOffset_ = std::stof(val);
-                questTrackerPosInit_ = true;
-            }
-            else if (key == "quest_tracker_y") {
-                questTrackerPos_.y = std::stof(val);
-                questTrackerPosInit_ = true;
-            }
-            else if (key == "quest_tracker_w") {
-                questTrackerSize_.x = std::max(100.0f, std::stof(val));
-            }
-            else if (key == "quest_tracker_h") {
-                questTrackerSize_.y = std::max(60.0f, std::stof(val));
-            }
+            else if (key == "mouse_sensitivity") pendingMouseSensitivity = std::clamp(std::stof(val), 0.05f, 1.0f);
+            else if (key == "invert_mouse") pendingInvertMouse = (std::stoi(val) != 0);
+            else if (key == "extended_zoom") pendingExtendedZoom = (std::stoi(val) != 0);
             // Chat
-            else if (key == "chat_active_tab") chatPanel_.activeChatTab = std::clamp(std::stoi(val), 0, 3);
-            else if (key == "chat_timestamps") chatPanel_.chatShowTimestamps = (std::stoi(val) != 0);
-            else if (key == "chat_font_size") chatPanel_.chatFontSize = std::clamp(std::stoi(val), 0, 2);
-            else if (key == "chat_autojoin_general") chatPanel_.chatAutoJoinGeneral = (std::stoi(val) != 0);
-            else if (key == "chat_autojoin_trade") chatPanel_.chatAutoJoinTrade = (std::stoi(val) != 0);
-            else if (key == "chat_autojoin_localdefense") chatPanel_.chatAutoJoinLocalDefense = (std::stoi(val) != 0);
-            else if (key == "chat_autojoin_lfg") chatPanel_.chatAutoJoinLFG = (std::stoi(val) != 0);
-            else if (key == "chat_autojoin_local") chatPanel_.chatAutoJoinLocal = (std::stoi(val) != 0);
+            else if (key == "chat_active_tab") activeChatTab_ = std::clamp(std::stoi(val), 0, 3);
+            else if (key == "chat_timestamps") chatShowTimestamps_ = (std::stoi(val) != 0);
+            else if (key == "chat_font_size") chatFontSize_ = std::clamp(std::stoi(val), 0, 2);
+            else if (key == "chat_autojoin_general") chatAutoJoinGeneral_ = (std::stoi(val) != 0);
+            else if (key == "chat_autojoin_trade") chatAutoJoinTrade_ = (std::stoi(val) != 0);
+            else if (key == "chat_autojoin_localdefense") chatAutoJoinLocalDefense_ = (std::stoi(val) != 0);
+            else if (key == "chat_autojoin_lfg") chatAutoJoinLFG_ = (std::stoi(val) != 0);
+            else if (key == "chat_autojoin_local") chatAutoJoinLocal_ = (std::stoi(val) != 0);
         } catch (...) {}
     }
-
-    // Load keybindings from the same config file
-    KeybindingManager::getInstance().loadFromConfigFile(path);
-
     LOG_INFO("Settings loaded from ", path);
 }
 
@@ -7025,170 +8557,1682 @@ void GameScreen::loadSettings() {
 // Mail Window
 // ============================================================
 
+void GameScreen::renderMailWindow(game::GameHandler& gameHandler) {
+    if (!gameHandler.isMailboxOpen()) return;
 
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 250, 80), ImGuiCond_Appearing);
+    ImGui::SetNextWindowSize(ImVec2(600, 500), ImGuiCond_Appearing);
+
+    bool open = true;
+    if (ImGui::Begin("Mailbox", &open)) {
+        const auto& inbox = gameHandler.getMailInbox();
+
+        // Top bar: money + compose button
+        uint64_t money = gameHandler.getMoneyCopper();
+        uint32_t mg = static_cast<uint32_t>(money / 10000);
+        uint32_t ms = static_cast<uint32_t>((money / 100) % 100);
+        uint32_t mc = static_cast<uint32_t>(money % 100);
+        ImGui::Text("Your money: %ug %us %uc", mg, ms, mc);
+        ImGui::SameLine(ImGui::GetWindowWidth() - 100);
+        if (ImGui::Button("Compose")) {
+            mailRecipientBuffer_[0] = '\0';
+            mailSubjectBuffer_[0] = '\0';
+            mailBodyBuffer_[0] = '\0';
+            mailComposeMoney_[0] = 0;
+            mailComposeMoney_[1] = 0;
+            mailComposeMoney_[2] = 0;
+            gameHandler.openMailCompose();
+        }
+        ImGui::Separator();
+
+        if (inbox.empty()) {
+            ImGui::TextDisabled("No mail.");
+        } else {
+            // Two-panel layout: left = mail list, right = selected mail detail
+            float listWidth = 220.0f;
+
+            // Left panel - mail list
+            ImGui::BeginChild("MailList", ImVec2(listWidth, 0), true);
+            for (size_t i = 0; i < inbox.size(); ++i) {
+                const auto& mail = inbox[i];
+                ImGui::PushID(static_cast<int>(i));
+
+                bool selected = (gameHandler.getSelectedMailIndex() == static_cast<int>(i));
+                std::string label = mail.subject.empty() ? "(No Subject)" : mail.subject;
+
+                // Unread indicator
+                if (!mail.read) {
+                    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 1.0f, 0.5f, 1.0f));
+                }
+
+                if (ImGui::Selectable(label.c_str(), selected)) {
+                    gameHandler.setSelectedMailIndex(static_cast<int>(i));
+                    // Mark as read
+                    if (!mail.read) {
+                        gameHandler.mailMarkAsRead(mail.messageId);
+                    }
+                }
+
+                if (!mail.read) {
+                    ImGui::PopStyleColor();
+                }
+
+                // Sub-info line
+                ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "  From: %s", mail.senderName.c_str());
+                if (mail.money > 0) {
+                    ImGui::SameLine();
+                    ImGui::TextColored(ImVec4(1.0f, 0.84f, 0.0f, 1.0f), " [G]");
+                }
+                if (!mail.attachments.empty()) {
+                    ImGui::SameLine();
+                    ImGui::TextColored(ImVec4(0.5f, 0.8f, 1.0f, 1.0f), " [A]");
+                }
+
+                ImGui::PopID();
+            }
+            ImGui::EndChild();
+
+            ImGui::SameLine();
+
+            // Right panel - selected mail detail
+            ImGui::BeginChild("MailDetail", ImVec2(0, 0), true);
+            int sel = gameHandler.getSelectedMailIndex();
+            if (sel >= 0 && sel < static_cast<int>(inbox.size())) {
+                const auto& mail = inbox[sel];
+
+                ImGui::TextColored(ImVec4(1.0f, 0.84f, 0.0f, 1.0f), "%s",
+                    mail.subject.empty() ? "(No Subject)" : mail.subject.c_str());
+                ImGui::Text("From: %s", mail.senderName.c_str());
+
+                if (mail.messageType == 2) {
+                    ImGui::TextColored(ImVec4(0.8f, 0.6f, 0.2f, 1.0f), "[Auction House]");
+                }
+                ImGui::Separator();
+
+                // Body text
+                if (!mail.body.empty()) {
+                    ImGui::TextWrapped("%s", mail.body.c_str());
+                    ImGui::Separator();
+                }
+
+                // Money
+                if (mail.money > 0) {
+                    uint32_t g = mail.money / 10000;
+                    uint32_t s = (mail.money / 100) % 100;
+                    uint32_t c = mail.money % 100;
+                    ImGui::Text("Money: %ug %us %uc", g, s, c);
+                    ImGui::SameLine();
+                    if (ImGui::SmallButton("Take Money")) {
+                        gameHandler.mailTakeMoney(mail.messageId);
+                    }
+                }
+
+                // COD warning
+                if (mail.cod > 0) {
+                    uint32_t g = mail.cod / 10000;
+                    uint32_t s = (mail.cod / 100) % 100;
+                    uint32_t c = mail.cod % 100;
+                    ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f),
+                        "COD: %ug %us %uc (you pay this to take items)", g, s, c);
+                }
+
+                // Attachments
+                if (!mail.attachments.empty()) {
+                    ImGui::Text("Attachments: %zu", mail.attachments.size());
+                    for (size_t j = 0; j < mail.attachments.size(); ++j) {
+                        const auto& att = mail.attachments[j];
+                        ImGui::PushID(static_cast<int>(j));
+
+                        auto* info = gameHandler.getItemInfo(att.itemId);
+                        if (info && info->valid) {
+                            ImGui::BulletText("%s x%u", info->name.c_str(), att.stackCount);
+                        } else {
+                            ImGui::BulletText("Item %u x%u", att.itemId, att.stackCount);
+                            gameHandler.ensureItemInfo(att.itemId);
+                        }
+                        ImGui::SameLine();
+                        if (ImGui::SmallButton("Take")) {
+                            gameHandler.mailTakeItem(mail.messageId, att.slot);
+                        }
+
+                        ImGui::PopID();
+                    }
+                }
+
+                ImGui::Spacing();
+                ImGui::Separator();
+
+                // Action buttons
+                if (ImGui::Button("Delete")) {
+                    gameHandler.mailDelete(mail.messageId);
+                }
+                ImGui::SameLine();
+                if (mail.messageType == 0 && ImGui::Button("Reply")) {
+                    // Pre-fill compose with sender as recipient
+                    strncpy(mailRecipientBuffer_, mail.senderName.c_str(), sizeof(mailRecipientBuffer_) - 1);
+                    mailRecipientBuffer_[sizeof(mailRecipientBuffer_) - 1] = '\0';
+                    std::string reSubject = "Re: " + mail.subject;
+                    strncpy(mailSubjectBuffer_, reSubject.c_str(), sizeof(mailSubjectBuffer_) - 1);
+                    mailSubjectBuffer_[sizeof(mailSubjectBuffer_) - 1] = '\0';
+                    mailBodyBuffer_[0] = '\0';
+                    mailComposeMoney_[0] = 0;
+                    mailComposeMoney_[1] = 0;
+                    mailComposeMoney_[2] = 0;
+                    gameHandler.openMailCompose();
+                }
+            } else {
+                ImGui::TextDisabled("Select a mail to read.");
+            }
+            ImGui::EndChild();
+        }
+    }
+    ImGui::End();
+
+    if (!open) {
+        gameHandler.closeMailbox();
+    }
+}
+
+void GameScreen::renderMailComposeWindow(game::GameHandler& gameHandler) {
+    if (!gameHandler.isMailComposeOpen()) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 190, screenH / 2 - 250), ImGuiCond_Appearing);
+    ImGui::SetNextWindowSize(ImVec2(400, 500), ImGuiCond_Appearing);
+
+    bool open = true;
+    if (ImGui::Begin("Send Mail", &open)) {
+        ImGui::Text("To:");
+        ImGui::SameLine(60);
+        ImGui::SetNextItemWidth(-1);
+        ImGui::InputText("##MailTo", mailRecipientBuffer_, sizeof(mailRecipientBuffer_));
+
+        ImGui::Text("Subject:");
+        ImGui::SameLine(60);
+        ImGui::SetNextItemWidth(-1);
+        ImGui::InputText("##MailSubject", mailSubjectBuffer_, sizeof(mailSubjectBuffer_));
+
+        ImGui::Text("Body:");
+        ImGui::InputTextMultiline("##MailBody", mailBodyBuffer_, sizeof(mailBodyBuffer_),
+                                   ImVec2(-1, 120));
+
+        // Attachments section
+        int attachCount = gameHandler.getMailAttachmentCount();
+        ImGui::Text("Attachments (%d/12):", attachCount);
+        ImGui::SameLine();
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Right-click items in bags to attach");
+
+        const auto& attachments = gameHandler.getMailAttachments();
+        // Show attachment slots in a grid (6 per row)
+        for (int i = 0; i < game::GameHandler::MAIL_MAX_ATTACHMENTS; ++i) {
+            if (i % 6 != 0) ImGui::SameLine();
+            ImGui::PushID(i + 5000);
+            const auto& att = attachments[i];
+            if (att.occupied()) {
+                // Show item with quality color border
+                ImVec4 qualColor = ui::InventoryScreen::getQualityColor(att.item.quality);
+                ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(qualColor.x * 0.3f, qualColor.y * 0.3f, qualColor.z * 0.3f, 0.8f));
+                ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(qualColor.x * 0.5f, qualColor.y * 0.5f, qualColor.z * 0.5f, 0.9f));
+
+                // Try to show icon
+                VkDescriptorSet icon = inventoryScreen.getItemIcon(att.item.displayInfoId);
+                bool clicked = false;
+                if (icon) {
+                    clicked = ImGui::ImageButton("##att", (ImTextureID)icon, ImVec2(30, 30));
+                } else {
+                    // Truncate name to fit
+                    std::string label = att.item.name.substr(0, 4);
+                    clicked = ImGui::Button(label.c_str(), ImVec2(36, 36));
+                }
+                ImGui::PopStyleColor(2);
+
+                if (clicked) {
+                    gameHandler.detachMailAttachment(i);
+                }
+                if (ImGui::IsItemHovered()) {
+                    ImGui::BeginTooltip();
+                    ImGui::TextColored(qualColor, "%s", att.item.name.c_str());
+                    ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f), "Click to remove");
+                    ImGui::EndTooltip();
+                }
+            } else {
+                ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.15f, 0.15f, 0.15f, 0.5f));
+                ImGui::Button("##empty", ImVec2(36, 36));
+                ImGui::PopStyleColor();
+            }
+            ImGui::PopID();
+        }
+
+        ImGui::Spacing();
+        ImGui::Text("Money:");
+        ImGui::SameLine(60);
+        ImGui::SetNextItemWidth(60);
+        ImGui::InputInt("##MailGold", &mailComposeMoney_[0], 0, 0);
+        if (mailComposeMoney_[0] < 0) mailComposeMoney_[0] = 0;
+        ImGui::SameLine();
+        ImGui::Text("g");
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth(40);
+        ImGui::InputInt("##MailSilver", &mailComposeMoney_[1], 0, 0);
+        if (mailComposeMoney_[1] < 0) mailComposeMoney_[1] = 0;
+        if (mailComposeMoney_[1] > 99) mailComposeMoney_[1] = 99;
+        ImGui::SameLine();
+        ImGui::Text("s");
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth(40);
+        ImGui::InputInt("##MailCopper", &mailComposeMoney_[2], 0, 0);
+        if (mailComposeMoney_[2] < 0) mailComposeMoney_[2] = 0;
+        if (mailComposeMoney_[2] > 99) mailComposeMoney_[2] = 99;
+        ImGui::SameLine();
+        ImGui::Text("c");
+
+        uint32_t totalMoney = static_cast<uint32_t>(mailComposeMoney_[0]) * 10000 +
+                              static_cast<uint32_t>(mailComposeMoney_[1]) * 100 +
+                              static_cast<uint32_t>(mailComposeMoney_[2]);
+
+        uint32_t sendCost = attachCount > 0 ? static_cast<uint32_t>(30 * attachCount) : 30u;
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Sending cost: %uc", sendCost);
+
+        ImGui::Spacing();
+        bool canSend = (strlen(mailRecipientBuffer_) > 0);
+        if (!canSend) ImGui::BeginDisabled();
+        if (ImGui::Button("Send", ImVec2(80, 0))) {
+            gameHandler.sendMail(mailRecipientBuffer_, mailSubjectBuffer_,
+                                 mailBodyBuffer_, totalMoney);
+        }
+        if (!canSend) ImGui::EndDisabled();
+
+        ImGui::SameLine();
+        if (ImGui::Button("Cancel", ImVec2(80, 0))) {
+            gameHandler.closeMailCompose();
+        }
+    }
+    ImGui::End();
+
+    if (!open) {
+        gameHandler.closeMailCompose();
+    }
+}
 
 // ============================================================
 // Bank Window
 // ============================================================
 
+void GameScreen::renderBankWindow(game::GameHandler& gameHandler) {
+    if (!gameHandler.isBankOpen()) return;
+
+    bool open = true;
+    ImGui::SetNextWindowSize(ImVec2(480, 420), ImGuiCond_FirstUseEver);
+    if (!ImGui::Begin("Bank", &open)) {
+        ImGui::End();
+        if (!open) gameHandler.closeBank();
+        return;
+    }
+
+    auto& inv = gameHandler.getInventory();
+    bool isHolding = inventoryScreen.isHoldingItem();
+    constexpr float SLOT_SIZE = 42.0f;
+    static constexpr float kBankPickupHold = 0.10f; // seconds
+    // Persistent pickup tracking for bank (mirrors inventory_screen's pickupPending_)
+    static bool bankPickupPending = false;
+    static float bankPickupPressTime = 0.0f;
+    static int bankPickupType = 0; // 0=main bank, 1=bank bag slot, 2=bank bag equip slot
+    static int bankPickupIndex = -1;
+    static int bankPickupBagIndex = -1;
+    static int bankPickupBagSlotIndex = -1;
+
+    // Helper: render a bank item slot with icon, click-and-hold pickup, drop, tooltip
+    auto renderBankItemSlot = [&](const game::ItemSlot& slot, int pickType, int mainIdx,
+                                   int bagIdx, int bagSlotIdx, uint8_t dstBag, uint8_t dstSlot) {
+        ImDrawList* drawList = ImGui::GetWindowDrawList();
+        ImVec2 pos = ImGui::GetCursorScreenPos();
+
+        if (slot.empty()) {
+            ImU32 bgCol = IM_COL32(30, 30, 30, 200);
+            ImU32 borderCol = IM_COL32(60, 60, 60, 200);
+            if (isHolding) {
+                bgCol = IM_COL32(20, 50, 20, 200);
+                borderCol = IM_COL32(0, 180, 0, 200);
+            }
+            drawList->AddRectFilled(pos, ImVec2(pos.x + SLOT_SIZE, pos.y + SLOT_SIZE), bgCol);
+            drawList->AddRect(pos, ImVec2(pos.x + SLOT_SIZE, pos.y + SLOT_SIZE), borderCol);
+            ImGui::InvisibleButton("slot", ImVec2(SLOT_SIZE, SLOT_SIZE));
+            if (isHolding && ImGui::IsItemHovered() && ImGui::IsMouseReleased(ImGuiMouseButton_Left)) {
+                inventoryScreen.dropIntoBankSlot(gameHandler, dstBag, dstSlot);
+            }
+        } else {
+            const auto& item = slot.item;
+            ImVec4 qc = InventoryScreen::getQualityColor(item.quality);
+            ImU32 borderCol = ImGui::ColorConvertFloat4ToU32(qc);
+            VkDescriptorSet iconTex = inventoryScreen.getItemIcon(item.displayInfoId);
+
+            if (iconTex) {
+                drawList->AddImage((ImTextureID)(uintptr_t)iconTex, pos,
+                                   ImVec2(pos.x + SLOT_SIZE, pos.y + SLOT_SIZE));
+                drawList->AddRect(pos, ImVec2(pos.x + SLOT_SIZE, pos.y + SLOT_SIZE),
+                                  borderCol, 0.0f, 0, 2.0f);
+            } else {
+                ImU32 bgCol = IM_COL32(40, 35, 30, 220);
+                drawList->AddRectFilled(pos, ImVec2(pos.x + SLOT_SIZE, pos.y + SLOT_SIZE), bgCol);
+                drawList->AddRect(pos, ImVec2(pos.x + SLOT_SIZE, pos.y + SLOT_SIZE),
+                                  borderCol, 0.0f, 0, 2.0f);
+                if (!item.name.empty()) {
+                    char abbr[3] = { item.name[0], item.name.size() > 1 ? item.name[1] : '\0', '\0' };
+                    float tw = ImGui::CalcTextSize(abbr).x;
+                    drawList->AddText(ImVec2(pos.x + (SLOT_SIZE - tw) * 0.5f, pos.y + 2.0f),
+                                      ImGui::ColorConvertFloat4ToU32(qc), abbr);
+                }
+            }
+
+            if (item.stackCount > 1) {
+                char countStr[16];
+                snprintf(countStr, sizeof(countStr), "%u", item.stackCount);
+                float cw = ImGui::CalcTextSize(countStr).x;
+                drawList->AddText(ImVec2(pos.x + SLOT_SIZE - cw - 2.0f, pos.y + SLOT_SIZE - 14.0f),
+                                  IM_COL32(255, 255, 255, 220), countStr);
+            }
+
+            ImGui::InvisibleButton("slot", ImVec2(SLOT_SIZE, SLOT_SIZE));
+
+            if (!isHolding) {
+                // Start pickup tracking on mouse press
+                if (ImGui::IsItemClicked(ImGuiMouseButton_Left)) {
+                    bankPickupPending = true;
+                    bankPickupPressTime = ImGui::GetTime();
+                    bankPickupType = pickType;
+                    bankPickupIndex = mainIdx;
+                    bankPickupBagIndex = bagIdx;
+                    bankPickupBagSlotIndex = bagSlotIdx;
+                }
+                // Check if held long enough to pick up
+                if (bankPickupPending && ImGui::IsMouseDown(ImGuiMouseButton_Left) &&
+                    (ImGui::GetTime() - bankPickupPressTime) >= kBankPickupHold) {
+                    bool sameSlot = (bankPickupType == pickType);
+                    if (pickType == 0)
+                        sameSlot = sameSlot && (bankPickupIndex == mainIdx);
+                    else if (pickType == 1)
+                        sameSlot = sameSlot && (bankPickupBagIndex == bagIdx) && (bankPickupBagSlotIndex == bagSlotIdx);
+                    else if (pickType == 2)
+                        sameSlot = sameSlot && (bankPickupIndex == mainIdx);
+
+                    if (sameSlot && ImGui::IsItemHovered()) {
+                        bankPickupPending = false;
+                        if (pickType == 0) {
+                            inventoryScreen.pickupFromBank(inv, mainIdx);
+                        } else if (pickType == 1) {
+                            inventoryScreen.pickupFromBankBag(inv, bagIdx, bagSlotIdx);
+                        } else if (pickType == 2) {
+                            inventoryScreen.pickupFromBankBagEquip(inv, mainIdx);
+                        }
+                    }
+                }
+            } else {
+                // Drop/swap on mouse release
+                if (ImGui::IsItemHovered() && ImGui::IsMouseReleased(ImGuiMouseButton_Left)) {
+                    inventoryScreen.dropIntoBankSlot(gameHandler, dstBag, dstSlot);
+                }
+            }
+
+            // Tooltip
+            if (ImGui::IsItemHovered() && !isHolding) {
+                ImGui::BeginTooltip();
+                ImGui::TextColored(qc, "%s", item.name.c_str());
+                if (item.stackCount > 1) ImGui::Text("Count: %u", item.stackCount);
+                ImGui::EndTooltip();
+            }
+        }
+    };
+
+    // Main bank slots (24 for Classic, 28 for TBC/WotLK)
+    int bankSlotCount = gameHandler.getEffectiveBankSlots();
+    int bankBagCount = gameHandler.getEffectiveBankBagSlots();
+    ImGui::Text("Bank Slots");
+    ImGui::Separator();
+    for (int i = 0; i < bankSlotCount; i++) {
+        if (i % 7 != 0) ImGui::SameLine();
+        ImGui::PushID(i + 1000);
+        renderBankItemSlot(inv.getBankSlot(i), 0, i, -1, -1, 0xFF, static_cast<uint8_t>(39 + i));
+        ImGui::PopID();
+    }
+
+    // Bank bag equip slots — show bag icon with pickup/drop, or "Buy Slot"
+    ImGui::Spacing();
+    ImGui::Separator();
+    ImGui::Text("Bank Bags");
+    uint8_t purchased = inv.getPurchasedBankBagSlots();
+    for (int i = 0; i < bankBagCount; i++) {
+        if (i > 0) ImGui::SameLine();
+        ImGui::PushID(i + 2000);
+
+        int bagSize = inv.getBankBagSize(i);
+        if (i < purchased || bagSize > 0) {
+            const auto& bagSlot = inv.getBankBagItem(i);
+            // Render as an item slot: icon with pickup/drop (pickType=2 for bag equip)
+            renderBankItemSlot(bagSlot, 2, i, -1, -1, 0xFF, static_cast<uint8_t>(67 + i));
+        } else {
+            if (ImGui::Button("Buy Slot", ImVec2(50, 30))) {
+                gameHandler.buyBankSlot();
+            }
+        }
+        ImGui::PopID();
+    }
+
+    // Show expanded bank bag contents
+    for (int bagIdx = 0; bagIdx < bankBagCount; bagIdx++) {
+        int bagSize = inv.getBankBagSize(bagIdx);
+        if (bagSize <= 0) continue;
+
+        ImGui::Spacing();
+        ImGui::Text("Bank Bag %d (%d slots)", bagIdx + 1, bagSize);
+        for (int s = 0; s < bagSize; s++) {
+            if (s % 7 != 0) ImGui::SameLine();
+            ImGui::PushID(3000 + bagIdx * 100 + s);
+            renderBankItemSlot(inv.getBankBagSlot(bagIdx, s), 1, -1, bagIdx, s,
+                               static_cast<uint8_t>(67 + bagIdx), static_cast<uint8_t>(s));
+            ImGui::PopID();
+        }
+    }
+
+    ImGui::End();
+
+    if (!open) gameHandler.closeBank();
+}
 
 // ============================================================
 // Guild Bank Window
 // ============================================================
 
+void GameScreen::renderGuildBankWindow(game::GameHandler& gameHandler) {
+    if (!gameHandler.isGuildBankOpen()) return;
+
+    bool open = true;
+    ImGui::SetNextWindowSize(ImVec2(520, 500), ImGuiCond_FirstUseEver);
+    if (!ImGui::Begin("Guild Bank", &open)) {
+        ImGui::End();
+        if (!open) gameHandler.closeGuildBank();
+        return;
+    }
+
+    const auto& data = gameHandler.getGuildBankData();
+    uint8_t activeTab = gameHandler.getGuildBankActiveTab();
+
+    // Money display
+    uint32_t gold = static_cast<uint32_t>(data.money / 10000);
+    uint32_t silver = static_cast<uint32_t>((data.money / 100) % 100);
+    uint32_t copper = static_cast<uint32_t>(data.money % 100);
+    ImGui::Text("Guild Bank Money: ");
+    ImGui::SameLine();
+    ImGui::TextColored(ImVec4(0.9f, 0.8f, 0.3f, 1.0f), "%ug %us %uc", gold, silver, copper);
+
+    // Tab bar
+    if (!data.tabs.empty()) {
+        for (size_t i = 0; i < data.tabs.size(); i++) {
+            if (i > 0) ImGui::SameLine();
+            bool selected = (i == activeTab);
+            if (selected) ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.3f, 0.5f, 0.8f, 1.0f));
+            std::string tabLabel = data.tabs[i].tabName.empty() ? ("Tab " + std::to_string(i + 1)) : data.tabs[i].tabName;
+            if (ImGui::Button(tabLabel.c_str())) {
+                gameHandler.queryGuildBankTab(static_cast<uint8_t>(i));
+            }
+            if (selected) ImGui::PopStyleColor();
+        }
+    }
+
+    // Buy tab button
+    if (data.tabs.size() < 6) {
+        ImGui::SameLine();
+        if (ImGui::Button("Buy Tab")) {
+            gameHandler.buyGuildBankTab();
+        }
+    }
+
+    ImGui::Separator();
+
+    // Tab items (98 slots = 14 columns × 7 rows)
+    for (size_t i = 0; i < data.tabItems.size(); i++) {
+        if (i % 14 != 0) ImGui::SameLine();
+        const auto& item = data.tabItems[i];
+        ImGui::PushID(static_cast<int>(i) + 5000);
+
+        if (item.itemEntry == 0) {
+            ImGui::Button("##gb", ImVec2(34, 34));
+        } else {
+            auto* info = gameHandler.getItemInfo(item.itemEntry);
+            game::ItemQuality quality = game::ItemQuality::COMMON;
+            std::string name = "Item " + std::to_string(item.itemEntry);
+            if (info) {
+                quality = static_cast<game::ItemQuality>(info->quality);
+                name = info->name;
+            }
+            ImVec4 qc = InventoryScreen::getQualityColor(quality);
+            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(qc.x * 0.3f, qc.y * 0.3f, qc.z * 0.3f, 0.8f));
+            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(qc.x * 0.5f, qc.y * 0.5f, qc.z * 0.5f, 0.9f));
+            std::string lbl = item.stackCount > 1 ? std::to_string(item.stackCount) : ("##gi" + std::to_string(i));
+            if (ImGui::Button(lbl.c_str(), ImVec2(34, 34))) {
+                // Withdraw: auto-store to first free bag slot
+                gameHandler.guildBankWithdrawItem(activeTab, item.slotId, 0xFF, 0);
+            }
+            ImGui::PopStyleColor(2);
+            if (ImGui::IsItemHovered()) {
+                ImGui::BeginTooltip();
+                ImGui::TextColored(qc, "%s", name.c_str());
+                if (item.stackCount > 1) ImGui::Text("Count: %u", item.stackCount);
+                ImGui::EndTooltip();
+            }
+        }
+        ImGui::PopID();
+    }
+
+    // Money deposit/withdraw
+    ImGui::Separator();
+    ImGui::Text("Money:");
+    ImGui::SameLine();
+    ImGui::SetNextItemWidth(60);
+    ImGui::InputInt("##gbg", &guildBankMoneyInput_[0], 0); ImGui::SameLine(); ImGui::Text("g");
+    ImGui::SameLine();
+    ImGui::SetNextItemWidth(40);
+    ImGui::InputInt("##gbs", &guildBankMoneyInput_[1], 0); ImGui::SameLine(); ImGui::Text("s");
+    ImGui::SameLine();
+    ImGui::SetNextItemWidth(40);
+    ImGui::InputInt("##gbc", &guildBankMoneyInput_[2], 0); ImGui::SameLine(); ImGui::Text("c");
+
+    ImGui::SameLine();
+    if (ImGui::Button("Deposit")) {
+        uint32_t amount = guildBankMoneyInput_[0] * 10000 + guildBankMoneyInput_[1] * 100 + guildBankMoneyInput_[2];
+        if (amount > 0) gameHandler.depositGuildBankMoney(amount);
+    }
+    ImGui::SameLine();
+    if (ImGui::Button("Withdraw")) {
+        uint32_t amount = guildBankMoneyInput_[0] * 10000 + guildBankMoneyInput_[1] * 100 + guildBankMoneyInput_[2];
+        if (amount > 0) gameHandler.withdrawGuildBankMoney(amount);
+    }
+
+    if (data.withdrawAmount >= 0) {
+        ImGui::Text("Remaining withdrawals: %d", data.withdrawAmount);
+    }
+
+    ImGui::End();
+
+    if (!open) gameHandler.closeGuildBank();
+}
 
 // ============================================================
 // Auction House Window
 // ============================================================
 
+void GameScreen::renderAuctionHouseWindow(game::GameHandler& gameHandler) {
+    if (!gameHandler.isAuctionHouseOpen()) return;
 
+    bool open = true;
+    ImGui::SetNextWindowSize(ImVec2(650, 500), ImGuiCond_FirstUseEver);
+    if (!ImGui::Begin("Auction House", &open)) {
+        ImGui::End();
+        if (!open) gameHandler.closeAuctionHouse();
+        return;
+    }
 
-// ---------------------------------------------------------------------------
-// Screen-space weather overlay (rain / snow / storm)
-// ---------------------------------------------------------------------------
-void GameScreen::renderWeatherOverlay(game::GameHandler& gameHandler) {
-    uint32_t wType     = gameHandler.getWeatherType();
-    float    intensity = gameHandler.getWeatherIntensity();
-    if (wType == 0 || intensity < 0.05f) return;
+    int tab = gameHandler.getAuctionActiveTab();
 
-    const ImGuiIO& io = ImGui::GetIO();
-    float sw = io.DisplaySize.x;
-    float sh = io.DisplaySize.y;
-    if (sw <= 0.0f || sh <= 0.0f) return;
+    // Tab buttons
+    const char* tabNames[] = {"Browse", "Bids", "Auctions"};
+    for (int i = 0; i < 3; i++) {
+        if (i > 0) ImGui::SameLine();
+        bool selected = (tab == i);
+        if (selected) ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.3f, 0.5f, 0.8f, 1.0f));
+        if (ImGui::Button(tabNames[i], ImVec2(100, 0))) {
+            gameHandler.setAuctionActiveTab(i);
+            if (i == 1) gameHandler.auctionListBidderItems();
+            else if (i == 2) gameHandler.auctionListOwnerItems();
+        }
+        if (selected) ImGui::PopStyleColor();
+    }
 
-    // Seeded RNG for weather particle positions — replaces std::rand() which
-    // shares global state and has modulo bias.
-    static std::mt19937 wxRng(std::random_device{}());
-    auto wxRandInt = [](int maxExcl) {
-        return std::uniform_int_distribution<int>(0, std::max(0, maxExcl - 1))(wxRng);
-    };
+    ImGui::Separator();
 
-    ImDrawList* dl = ImGui::GetForegroundDrawList();
-    const float dt = std::min(io.DeltaTime, 0.05f);   // cap delta at 50ms to avoid teleporting particles
+    if (tab == 0) {
+        // Browse tab - Search filters
 
-    if (wType == 1 || wType == 3) {
-        // ── Rain / Storm ─────────────────────────────────────────────────────
-        constexpr int MAX_DROPS = 300;
-        struct RainState {
-            float x[MAX_DROPS], y[MAX_DROPS];
-            bool  initialized = false;
-            uint32_t lastType = 0;
-            float lastW = 0.0f, lastH = 0.0f;
+        // --- Helper: resolve current UI filter state into wire-format search params ---
+        // WoW 3.3.5a item class IDs:
+        //   0=Consumable, 1=Container, 2=Weapon, 3=Gem, 4=Armor,
+        //   7=Projectile/TradeGoods, 9=Recipe, 11=Quiver, 15=Miscellaneous
+        struct AHClassMapping { const char* label; uint32_t classId; };
+        static const AHClassMapping classMappings[] = {
+            {"All",         0xFFFFFFFF},
+            {"Weapon",      2},
+            {"Armor",       4},
+            {"Container",   1},
+            {"Consumable",  0},
+            {"Trade Goods", 7},
+            {"Gem",         3},
+            {"Recipe",      9},
+            {"Quiver",      11},
+            {"Miscellaneous", 15},
         };
-        static RainState rs;
+        static constexpr int NUM_CLASSES = 10;
 
-        // Re-seed if weather type or screen size changed
-        if (!rs.initialized || rs.lastType != wType ||
-            rs.lastW != sw   || rs.lastH != sh) {
-            for (int i = 0; i < MAX_DROPS; ++i) {
-                rs.x[i] = static_cast<float>(wxRandInt(static_cast<int>(sw) + 200)) - 100.0f;
-                rs.y[i] = static_cast<float>(wxRandInt(static_cast<int>(sh)));
-            }
-            rs.initialized = true;
-            rs.lastType = wType;
-            rs.lastW = sw;
-            rs.lastH = sh;
-        }
-
-        const float fallSpeed = (wType == 3) ? 680.0f : 440.0f;
-        const float windSpeed = (wType == 3) ? 110.0f :  65.0f;
-        const int   numDrops  = static_cast<int>(MAX_DROPS * std::min(1.0f, intensity));
-        const float alpha     = std::min(1.0f, 0.28f + intensity * 0.38f);
-        const uint8_t alphaU8 = static_cast<uint8_t>(alpha * 255.0f);
-        const ImU32  dropCol  = IM_COL32(175, 195, 225, alphaU8);
-        const float  dropLen  = 7.0f + intensity * 7.0f;
-        // Normalised wind direction for the trail endpoint
-        const float invSpeed  = 1.0f / std::sqrt(fallSpeed * fallSpeed + windSpeed * windSpeed);
-        const float trailDx   = -windSpeed * invSpeed * dropLen;
-        const float trailDy   = -fallSpeed * invSpeed * dropLen;
-
-        for (int i = 0; i < numDrops; ++i) {
-            rs.x[i] += windSpeed * dt;
-            rs.y[i] += fallSpeed * dt;
-            if (rs.y[i] > sh + 10.0f) {
-                rs.y[i] = -10.0f;
-                rs.x[i] = static_cast<float>(wxRandInt(static_cast<int>(sw) + 200)) - 100.0f;
-            }
-            if (rs.x[i] > sw + 100.0f) rs.x[i] -= sw + 200.0f;
-            dl->AddLine(ImVec2(rs.x[i], rs.y[i]),
-                        ImVec2(rs.x[i] + trailDx, rs.y[i] + trailDy),
-                        dropCol, 1.0f);
-        }
-
-        // Storm: dark fog-vignette at screen edges
-        if (wType == 3) {
-            const float vigAlpha = std::min(1.0f, 0.12f + intensity * 0.18f);
-            const ImU32 vigCol   = IM_COL32(60, 65, 80, static_cast<uint8_t>(vigAlpha * 255.0f));
-            const float vigW = sw * 0.22f;
-            const float vigH = sh * 0.22f;
-            dl->AddRectFilledMultiColor(ImVec2(0,       0),      ImVec2(vigW, sh),     vigCol, IM_COL32_BLACK_TRANS, IM_COL32_BLACK_TRANS, vigCol);
-            dl->AddRectFilledMultiColor(ImVec2(sw-vigW, 0),      ImVec2(sw,   sh),     IM_COL32_BLACK_TRANS, vigCol, vigCol, IM_COL32_BLACK_TRANS);
-            dl->AddRectFilledMultiColor(ImVec2(0,       0),      ImVec2(sw,   vigH),   vigCol, vigCol, IM_COL32_BLACK_TRANS, IM_COL32_BLACK_TRANS);
-            dl->AddRectFilledMultiColor(ImVec2(0,       sh-vigH),ImVec2(sw,   sh),     IM_COL32_BLACK_TRANS, IM_COL32_BLACK_TRANS, vigCol, vigCol);
-        }
-
-    } else if (wType == 2) {
-        // ── Snow ─────────────────────────────────────────────────────────────
-        constexpr int MAX_FLAKES = 120;
-        struct SnowState {
-            float x[MAX_FLAKES], y[MAX_FLAKES], phase[MAX_FLAKES];
-            bool  initialized = false;
-            float lastW = 0.0f, lastH = 0.0f;
+        // Weapon subclass IDs (WoW 3.3.5a)
+        struct AHSubMapping { const char* label; uint32_t subId; };
+        static const AHSubMapping weaponSubs[] = {
+            {"All", 0xFFFFFFFF}, {"Axe (1H)", 0}, {"Axe (2H)", 1}, {"Bow", 2},
+            {"Gun", 3}, {"Mace (1H)", 4}, {"Mace (2H)", 5}, {"Polearm", 6},
+            {"Sword (1H)", 7}, {"Sword (2H)", 8}, {"Staff", 10},
+            {"Fist Weapon", 13}, {"Dagger", 15}, {"Thrown", 16},
+            {"Crossbow", 18}, {"Wand", 19},
         };
-        static SnowState ss;
+        static constexpr int NUM_WEAPON_SUBS = 16;
 
-        if (!ss.initialized || ss.lastW != sw || ss.lastH != sh) {
-            for (int i = 0; i < MAX_FLAKES; ++i) {
-                ss.x[i]     = static_cast<float>(wxRandInt(static_cast<int>(sw)));
-                ss.y[i]     = static_cast<float>(wxRandInt(static_cast<int>(sh)));
-                ss.phase[i] = static_cast<float>(wxRandInt(628)) * 0.01f;
-            }
-            ss.initialized = true;
-            ss.lastW = sw;
-            ss.lastH = sh;
+        // Armor subclass IDs
+        static const AHSubMapping armorSubs[] = {
+            {"All", 0xFFFFFFFF}, {"Cloth", 1}, {"Leather", 2}, {"Mail", 3},
+            {"Plate", 4}, {"Shield", 6}, {"Miscellaneous", 0},
+        };
+        static constexpr int NUM_ARMOR_SUBS = 7;
+
+        auto getSearchClassId = [&]() -> uint32_t {
+            if (auctionItemClass_ < 0 || auctionItemClass_ >= NUM_CLASSES) return 0xFFFFFFFF;
+            return classMappings[auctionItemClass_].classId;
+        };
+
+        auto getSearchSubClassId = [&]() -> uint32_t {
+            if (auctionItemSubClass_ < 0) return 0xFFFFFFFF;
+            uint32_t cid = getSearchClassId();
+            if (cid == 2 && auctionItemSubClass_ < NUM_WEAPON_SUBS)
+                return weaponSubs[auctionItemSubClass_].subId;
+            if (cid == 4 && auctionItemSubClass_ < NUM_ARMOR_SUBS)
+                return armorSubs[auctionItemSubClass_].subId;
+            return 0xFFFFFFFF;
+        };
+
+        auto doSearch = [&](uint32_t offset) {
+            auctionBrowseOffset_ = offset;
+            if (auctionLevelMin_ < 0) auctionLevelMin_ = 0;
+            if (auctionLevelMax_ < 0) auctionLevelMax_ = 0;
+            uint32_t q = auctionQuality_ > 0 ? static_cast<uint32_t>(auctionQuality_ - 1) : 0xFFFFFFFF;
+            gameHandler.auctionSearch(auctionSearchName_,
+                static_cast<uint8_t>(auctionLevelMin_),
+                static_cast<uint8_t>(auctionLevelMax_),
+                q, getSearchClassId(), getSearchSubClassId(), 0, 0, offset);
+        };
+
+        // Row 1: Name + Level range
+        ImGui::SetNextItemWidth(200);
+        bool enterPressed = ImGui::InputText("Name", auctionSearchName_, sizeof(auctionSearchName_),
+                                              ImGuiInputTextFlags_EnterReturnsTrue);
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth(50);
+        ImGui::InputInt("Min Lv", &auctionLevelMin_, 0);
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth(50);
+        ImGui::InputInt("Max Lv", &auctionLevelMax_, 0);
+
+        // Row 2: Quality + Category + Subcategory + Search button
+        const char* qualities[] = {"All", "Poor", "Common", "Uncommon", "Rare", "Epic", "Legendary"};
+        ImGui::SetNextItemWidth(100);
+        ImGui::Combo("Quality", &auctionQuality_, qualities, 7);
+
+        ImGui::SameLine();
+        // Build class label list from mappings
+        const char* classLabels[NUM_CLASSES];
+        for (int c = 0; c < NUM_CLASSES; c++) classLabels[c] = classMappings[c].label;
+        ImGui::SetNextItemWidth(120);
+        int classIdx = auctionItemClass_ < 0 ? 0 : auctionItemClass_;
+        if (ImGui::Combo("Category", &classIdx, classLabels, NUM_CLASSES)) {
+            if (classIdx != auctionItemClass_) auctionItemSubClass_ = -1;
+            auctionItemClass_ = classIdx;
         }
 
-        const float fallSpeed = 45.0f + intensity * 45.0f;
-        const int   numFlakes = static_cast<int>(MAX_FLAKES * std::min(1.0f, intensity));
-        const float alpha     = std::min(1.0f, 0.5f + intensity * 0.3f);
-        const uint8_t alphaU8 = static_cast<uint8_t>(alpha * 255.0f);
-        const float   radius  = 1.5f + intensity * 1.5f;
-        const float   time    = static_cast<float>(ImGui::GetTime());
-
-        for (int i = 0; i < numFlakes; ++i) {
-            float sway = std::sin(time * 0.7f + ss.phase[i]) * 18.0f;
-            ss.x[i] += sway * dt;
-            ss.y[i] += fallSpeed * dt;
-            ss.phase[i] += dt * 0.25f;
-            if (ss.y[i] > sh + 5.0f) {
-                ss.y[i] = -5.0f;
-                ss.x[i] = static_cast<float>(wxRandInt(static_cast<int>(sw)));
+        // Subcategory (only for Weapon and Armor)
+        uint32_t curClassId = getSearchClassId();
+        if (curClassId == 2 || curClassId == 4) {
+            const AHSubMapping* subs = (curClassId == 2) ? weaponSubs : armorSubs;
+            int numSubs = (curClassId == 2) ? NUM_WEAPON_SUBS : NUM_ARMOR_SUBS;
+            const char* subLabels[20];
+            for (int s = 0; s < numSubs && s < 20; s++) subLabels[s] = subs[s].label;
+            int subIdx = auctionItemSubClass_ + 1;  // -1 → 0 ("All")
+            if (subIdx < 0 || subIdx >= numSubs) subIdx = 0;
+            ImGui::SameLine();
+            ImGui::SetNextItemWidth(110);
+            if (ImGui::Combo("Subcat", &subIdx, subLabels, numSubs)) {
+                auctionItemSubClass_ = subIdx - 1;  // 0 → -1 ("All")
             }
-            if (ss.x[i] < -5.0f) ss.x[i] += sw + 10.0f;
-            if (ss.x[i] > sw + 5.0f) ss.x[i] -= sw + 10.0f;
-            // Two-tone: bright centre dot + transparent outer ring for depth
-            dl->AddCircleFilled(ImVec2(ss.x[i], ss.y[i]), radius, IM_COL32(220, 235, 255, alphaU8));
-            dl->AddCircleFilled(ImVec2(ss.x[i], ss.y[i]), radius * 0.45f, IM_COL32(245, 250, 255, std::min(255, alphaU8 + 30)));
+        }
+
+        ImGui::SameLine();
+        float delay = gameHandler.getAuctionSearchDelay();
+        if (delay > 0.0f) {
+            char delayBuf[32];
+            snprintf(delayBuf, sizeof(delayBuf), "Search (%.0fs)", delay);
+            ImGui::BeginDisabled();
+            ImGui::Button(delayBuf);
+            ImGui::EndDisabled();
+        } else {
+            if (ImGui::Button("Search") || enterPressed) {
+                doSearch(0);
+            }
+        }
+
+        ImGui::Separator();
+
+        // Results table
+        const auto& results = gameHandler.getAuctionBrowseResults();
+        constexpr uint32_t AH_PAGE_SIZE = 50;
+        ImGui::Text("%zu results (of %u total)", results.auctions.size(), results.totalCount);
+
+        // Pagination
+        if (results.totalCount > AH_PAGE_SIZE) {
+            ImGui::SameLine();
+            uint32_t page = auctionBrowseOffset_ / AH_PAGE_SIZE + 1;
+            uint32_t totalPages = (results.totalCount + AH_PAGE_SIZE - 1) / AH_PAGE_SIZE;
+
+            if (auctionBrowseOffset_ == 0) ImGui::BeginDisabled();
+            if (ImGui::SmallButton("< Prev")) {
+                uint32_t newOff = (auctionBrowseOffset_ >= AH_PAGE_SIZE) ? auctionBrowseOffset_ - AH_PAGE_SIZE : 0;
+                doSearch(newOff);
+            }
+            if (auctionBrowseOffset_ == 0) ImGui::EndDisabled();
+
+            ImGui::SameLine();
+            ImGui::Text("Page %u/%u", page, totalPages);
+
+            ImGui::SameLine();
+            if (auctionBrowseOffset_ + AH_PAGE_SIZE >= results.totalCount) ImGui::BeginDisabled();
+            if (ImGui::SmallButton("Next >")) {
+                doSearch(auctionBrowseOffset_ + AH_PAGE_SIZE);
+            }
+            if (auctionBrowseOffset_ + AH_PAGE_SIZE >= results.totalCount) ImGui::EndDisabled();
+        }
+
+        if (ImGui::BeginChild("AuctionResults", ImVec2(0, -110), true)) {
+            if (ImGui::BeginTable("AuctionTable", 6, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
+                ImGui::TableSetupColumn("Item", ImGuiTableColumnFlags_WidthStretch);
+                ImGui::TableSetupColumn("Qty", ImGuiTableColumnFlags_WidthFixed, 40);
+                ImGui::TableSetupColumn("Time", ImGuiTableColumnFlags_WidthFixed, 60);
+                ImGui::TableSetupColumn("Bid", ImGuiTableColumnFlags_WidthFixed, 90);
+                ImGui::TableSetupColumn("Buyout", ImGuiTableColumnFlags_WidthFixed, 90);
+                ImGui::TableSetupColumn("##act", ImGuiTableColumnFlags_WidthFixed, 60);
+                ImGui::TableHeadersRow();
+
+                for (size_t i = 0; i < results.auctions.size(); i++) {
+                    const auto& auction = results.auctions[i];
+                    auto* info = gameHandler.getItemInfo(auction.itemEntry);
+                    std::string name = info ? info->name : ("Item #" + std::to_string(auction.itemEntry));
+                    game::ItemQuality quality = info ? static_cast<game::ItemQuality>(info->quality) : game::ItemQuality::COMMON;
+                    ImVec4 qc = InventoryScreen::getQualityColor(quality);
+
+                    ImGui::TableNextRow();
+                    ImGui::TableSetColumnIndex(0);
+                    // Item icon
+                    if (info && info->valid && info->displayInfoId != 0) {
+                        VkDescriptorSet iconTex = inventoryScreen.getItemIcon(info->displayInfoId);
+                        if (iconTex) {
+                            ImGui::Image((void*)(intptr_t)iconTex, ImVec2(16, 16));
+                            ImGui::SameLine();
+                        }
+                    }
+                    ImGui::TextColored(qc, "%s", name.c_str());
+                    // Item tooltip on hover
+                    if (ImGui::IsItemHovered() && info && info->valid) {
+                        ImGui::BeginTooltip();
+                        ImGui::TextColored(qc, "%s", info->name.c_str());
+                        if (info->inventoryType > 0) {
+                            if (!info->subclassName.empty())
+                                ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1), "%s", info->subclassName.c_str());
+                        }
+                        if (info->armor > 0) ImGui::Text("%d Armor", info->armor);
+                        if (info->damageMax > 0.0f && info->delayMs > 0) {
+                            float speed = static_cast<float>(info->delayMs) / 1000.0f;
+                            ImGui::Text("%.0f - %.0f Damage  Speed %.2f", info->damageMin, info->damageMax, speed);
+                        }
+                        ImVec4 green(0.0f, 1.0f, 0.0f, 1.0f);
+                        std::string bonusLine;
+                        auto appendStat = [](std::string& out, int32_t val, const char* n) {
+                            if (val <= 0) return;
+                            if (!out.empty()) out += "  ";
+                            out += "+" + std::to_string(val) + " " + n;
+                        };
+                        appendStat(bonusLine, info->strength, "Str");
+                        appendStat(bonusLine, info->agility, "Agi");
+                        appendStat(bonusLine, info->stamina, "Sta");
+                        appendStat(bonusLine, info->intellect, "Int");
+                        appendStat(bonusLine, info->spirit, "Spi");
+                        if (!bonusLine.empty()) ImGui::TextColored(green, "%s", bonusLine.c_str());
+                        if (info->sellPrice > 0) {
+                            ImGui::TextColored(ImVec4(1, 0.84f, 0, 1), "Sell: %ug %us %uc",
+                                info->sellPrice / 10000, (info->sellPrice / 100) % 100, info->sellPrice % 100);
+                        }
+                        ImGui::EndTooltip();
+                    }
+
+                    ImGui::TableSetColumnIndex(1);
+                    ImGui::Text("%u", auction.stackCount);
+
+                    ImGui::TableSetColumnIndex(2);
+                    // Time left display
+                    uint32_t mins = auction.timeLeftMs / 60000;
+                    if (mins > 720) ImGui::Text("Long");
+                    else if (mins > 120) ImGui::Text("Medium");
+                    else ImGui::TextColored(ImVec4(1, 0.3f, 0.3f, 1), "Short");
+
+                    ImGui::TableSetColumnIndex(3);
+                    {
+                        uint32_t bid = auction.currentBid > 0 ? auction.currentBid : auction.startBid;
+                        ImGui::Text("%ug%us%uc", bid / 10000, (bid / 100) % 100, bid % 100);
+                    }
+
+                    ImGui::TableSetColumnIndex(4);
+                    if (auction.buyoutPrice > 0) {
+                        ImGui::Text("%ug%us%uc", auction.buyoutPrice / 10000,
+                                    (auction.buyoutPrice / 100) % 100, auction.buyoutPrice % 100);
+                    } else {
+                        ImGui::TextDisabled("--");
+                    }
+
+                    ImGui::TableSetColumnIndex(5);
+                    ImGui::PushID(static_cast<int>(i) + 7000);
+                    if (auction.buyoutPrice > 0 && ImGui::SmallButton("Buy")) {
+                        gameHandler.auctionBuyout(auction.auctionId, auction.buyoutPrice);
+                    }
+                    if (auction.buyoutPrice > 0) ImGui::SameLine();
+                    if (ImGui::SmallButton("Bid")) {
+                        uint32_t bidAmt = auction.currentBid > 0
+                            ? auction.currentBid + auction.minBidIncrement
+                            : auction.startBid;
+                        gameHandler.auctionPlaceBid(auction.auctionId, bidAmt);
+                    }
+                    ImGui::PopID();
+                }
+                ImGui::EndTable();
+            }
+        }
+        ImGui::EndChild();
+
+        // Sell section
+        ImGui::Separator();
+        ImGui::Text("Sell Item:");
+
+        // Item picker from backpack
+        {
+            auto& inv = gameHandler.getInventory();
+            // Build list of non-empty backpack slots
+            std::string preview = (auctionSellSlotIndex_ >= 0)
+                ? ([&]() -> std::string {
+                    const auto& slot = inv.getBackpackSlot(auctionSellSlotIndex_);
+                    if (!slot.empty()) {
+                        std::string s = slot.item.name;
+                        if (slot.item.stackCount > 1) s += " x" + std::to_string(slot.item.stackCount);
+                        return s;
+                    }
+                    return "Select item...";
+                })()
+                : "Select item...";
+
+            ImGui::SetNextItemWidth(250);
+            if (ImGui::BeginCombo("##sellitem", preview.c_str())) {
+                for (int i = 0; i < game::Inventory::BACKPACK_SLOTS; i++) {
+                    const auto& slot = inv.getBackpackSlot(i);
+                    if (slot.empty()) continue;
+                    ImGui::PushID(i + 9000);
+                    // Item icon
+                    if (slot.item.displayInfoId != 0) {
+                        VkDescriptorSet sIcon = inventoryScreen.getItemIcon(slot.item.displayInfoId);
+                        if (sIcon) {
+                            ImGui::Image((void*)(intptr_t)sIcon, ImVec2(16, 16));
+                            ImGui::SameLine();
+                        }
+                    }
+                    std::string label = slot.item.name;
+                    if (slot.item.stackCount > 1) label += " x" + std::to_string(slot.item.stackCount);
+                    ImVec4 iqc = InventoryScreen::getQualityColor(slot.item.quality);
+                    ImGui::PushStyleColor(ImGuiCol_Text, iqc);
+                    if (ImGui::Selectable(label.c_str(), auctionSellSlotIndex_ == i)) {
+                        auctionSellSlotIndex_ = i;
+                    }
+                    ImGui::PopStyleColor();
+                    ImGui::PopID();
+                }
+                ImGui::EndCombo();
+            }
+        }
+
+        ImGui::Text("Bid:");
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth(50);
+        ImGui::InputInt("##sbg", &auctionSellBid_[0], 0); ImGui::SameLine(); ImGui::Text("g");
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth(35);
+        ImGui::InputInt("##sbs", &auctionSellBid_[1], 0); ImGui::SameLine(); ImGui::Text("s");
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth(35);
+        ImGui::InputInt("##sbc", &auctionSellBid_[2], 0); ImGui::SameLine(); ImGui::Text("c");
+
+        ImGui::SameLine(0, 20);
+        ImGui::Text("Buyout:");
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth(50);
+        ImGui::InputInt("##sbog", &auctionSellBuyout_[0], 0); ImGui::SameLine(); ImGui::Text("g");
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth(35);
+        ImGui::InputInt("##sbos", &auctionSellBuyout_[1], 0); ImGui::SameLine(); ImGui::Text("s");
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth(35);
+        ImGui::InputInt("##sboc", &auctionSellBuyout_[2], 0); ImGui::SameLine(); ImGui::Text("c");
+
+        const char* durations[] = {"12 hours", "24 hours", "48 hours"};
+        ImGui::SetNextItemWidth(90);
+        ImGui::Combo("##dur", &auctionSellDuration_, durations, 3);
+        ImGui::SameLine();
+
+        // Create Auction button
+        bool canCreate = auctionSellSlotIndex_ >= 0 &&
+                         !gameHandler.getInventory().getBackpackSlot(auctionSellSlotIndex_).empty() &&
+                         (auctionSellBid_[0] > 0 || auctionSellBid_[1] > 0 || auctionSellBid_[2] > 0);
+        if (!canCreate) ImGui::BeginDisabled();
+        if (ImGui::Button("Create Auction")) {
+            uint32_t bidCopper = static_cast<uint32_t>(auctionSellBid_[0]) * 10000
+                               + static_cast<uint32_t>(auctionSellBid_[1]) * 100
+                               + static_cast<uint32_t>(auctionSellBid_[2]);
+            uint32_t buyoutCopper = static_cast<uint32_t>(auctionSellBuyout_[0]) * 10000
+                                  + static_cast<uint32_t>(auctionSellBuyout_[1]) * 100
+                                  + static_cast<uint32_t>(auctionSellBuyout_[2]);
+            const uint32_t durationMins[] = {720, 1440, 2880};
+            uint32_t dur = durationMins[auctionSellDuration_];
+            uint64_t itemGuid = gameHandler.getBackpackItemGuid(auctionSellSlotIndex_);
+            const auto& slot = gameHandler.getInventory().getBackpackSlot(auctionSellSlotIndex_);
+            uint32_t stackCount = slot.item.stackCount;
+            if (itemGuid != 0) {
+                gameHandler.auctionSellItem(itemGuid, stackCount, bidCopper, buyoutCopper, dur);
+                // Clear sell inputs
+                auctionSellSlotIndex_ = -1;
+                auctionSellBid_[0] = auctionSellBid_[1] = auctionSellBid_[2] = 0;
+                auctionSellBuyout_[0] = auctionSellBuyout_[1] = auctionSellBuyout_[2] = 0;
+            }
+        }
+        if (!canCreate) ImGui::EndDisabled();
+
+    } else if (tab == 1) {
+        // Bids tab
+        const auto& results = gameHandler.getAuctionBidderResults();
+        ImGui::Text("Your Bids: %zu items", results.auctions.size());
+
+        if (ImGui::BeginTable("BidTable", 6, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg)) {
+            ImGui::TableSetupColumn("Item", ImGuiTableColumnFlags_WidthStretch);
+            ImGui::TableSetupColumn("Qty", ImGuiTableColumnFlags_WidthFixed, 40);
+            ImGui::TableSetupColumn("Your Bid", ImGuiTableColumnFlags_WidthFixed, 90);
+            ImGui::TableSetupColumn("Buyout", ImGuiTableColumnFlags_WidthFixed, 90);
+            ImGui::TableSetupColumn("Time", ImGuiTableColumnFlags_WidthFixed, 60);
+            ImGui::TableSetupColumn("##act", ImGuiTableColumnFlags_WidthFixed, 60);
+            ImGui::TableHeadersRow();
+
+            for (size_t bi = 0; bi < results.auctions.size(); bi++) {
+                const auto& a = results.auctions[bi];
+                auto* info = gameHandler.getItemInfo(a.itemEntry);
+                std::string name = info ? info->name : ("Item #" + std::to_string(a.itemEntry));
+                game::ItemQuality quality = info ? static_cast<game::ItemQuality>(info->quality) : game::ItemQuality::COMMON;
+                ImVec4 bqc = InventoryScreen::getQualityColor(quality);
+
+                ImGui::TableNextRow();
+                ImGui::TableSetColumnIndex(0);
+                if (info && info->valid && info->displayInfoId != 0) {
+                    VkDescriptorSet bIcon = inventoryScreen.getItemIcon(info->displayInfoId);
+                    if (bIcon) {
+                        ImGui::Image((void*)(intptr_t)bIcon, ImVec2(16, 16));
+                        ImGui::SameLine();
+                    }
+                }
+                ImGui::TextColored(bqc, "%s", name.c_str());
+                // Tooltip
+                if (ImGui::IsItemHovered() && info && info->valid) {
+                    ImGui::BeginTooltip();
+                    ImGui::TextColored(bqc, "%s", info->name.c_str());
+                    if (info->armor > 0) ImGui::Text("%d Armor", info->armor);
+                    if (info->damageMax > 0.0f && info->delayMs > 0) {
+                        float speed = static_cast<float>(info->delayMs) / 1000.0f;
+                        ImGui::Text("%.0f - %.0f Damage  Speed %.2f", info->damageMin, info->damageMax, speed);
+                    }
+                    std::string bl;
+                    auto appS = [](std::string& o, int32_t v, const char* n) {
+                        if (v <= 0) return;
+                        if (!o.empty()) o += "  ";
+                        o += "+" + std::to_string(v) + " " + n;
+                    };
+                    appS(bl, info->strength, "Str"); appS(bl, info->agility, "Agi");
+                    appS(bl, info->stamina, "Sta"); appS(bl, info->intellect, "Int");
+                    appS(bl, info->spirit, "Spi");
+                    if (!bl.empty()) ImGui::TextColored(ImVec4(0,1,0,1), "%s", bl.c_str());
+                    if (info->sellPrice > 0)
+                        ImGui::TextColored(ImVec4(1,0.84f,0,1), "Sell: %ug %us %uc",
+                            info->sellPrice/10000, (info->sellPrice/100)%100, info->sellPrice%100);
+                    ImGui::EndTooltip();
+                }
+                ImGui::TableSetColumnIndex(1);
+                ImGui::Text("%u", a.stackCount);
+                ImGui::TableSetColumnIndex(2);
+                ImGui::Text("%ug%us%uc", a.currentBid / 10000, (a.currentBid / 100) % 100, a.currentBid % 100);
+                ImGui::TableSetColumnIndex(3);
+                if (a.buyoutPrice > 0)
+                    ImGui::Text("%ug%us%uc", a.buyoutPrice / 10000, (a.buyoutPrice / 100) % 100, a.buyoutPrice % 100);
+                else
+                    ImGui::TextDisabled("--");
+                ImGui::TableSetColumnIndex(4);
+                uint32_t mins = a.timeLeftMs / 60000;
+                if (mins > 720) ImGui::Text("Long");
+                else if (mins > 120) ImGui::Text("Medium");
+                else ImGui::TextColored(ImVec4(1, 0.3f, 0.3f, 1), "Short");
+
+                ImGui::TableSetColumnIndex(5);
+                ImGui::PushID(static_cast<int>(bi) + 7500);
+                if (a.buyoutPrice > 0 && ImGui::SmallButton("Buy")) {
+                    gameHandler.auctionBuyout(a.auctionId, a.buyoutPrice);
+                }
+                if (a.buyoutPrice > 0) ImGui::SameLine();
+                if (ImGui::SmallButton("Bid")) {
+                    uint32_t bidAmt = a.currentBid > 0
+                        ? a.currentBid + a.minBidIncrement
+                        : a.startBid;
+                    gameHandler.auctionPlaceBid(a.auctionId, bidAmt);
+                }
+                ImGui::PopID();
+            }
+            ImGui::EndTable();
+        }
+
+    } else if (tab == 2) {
+        // Auctions tab (your listings)
+        const auto& results = gameHandler.getAuctionOwnerResults();
+        ImGui::Text("Your Auctions: %zu items", results.auctions.size());
+
+        if (ImGui::BeginTable("OwnerTable", 5, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg)) {
+            ImGui::TableSetupColumn("Item", ImGuiTableColumnFlags_WidthStretch);
+            ImGui::TableSetupColumn("Qty", ImGuiTableColumnFlags_WidthFixed, 40);
+            ImGui::TableSetupColumn("Bid", ImGuiTableColumnFlags_WidthFixed, 90);
+            ImGui::TableSetupColumn("Buyout", ImGuiTableColumnFlags_WidthFixed, 90);
+            ImGui::TableSetupColumn("##cancel", ImGuiTableColumnFlags_WidthFixed, 60);
+            ImGui::TableHeadersRow();
+
+            for (size_t i = 0; i < results.auctions.size(); i++) {
+                const auto& a = results.auctions[i];
+                auto* info = gameHandler.getItemInfo(a.itemEntry);
+                std::string name = info ? info->name : ("Item #" + std::to_string(a.itemEntry));
+                game::ItemQuality quality = info ? static_cast<game::ItemQuality>(info->quality) : game::ItemQuality::COMMON;
+
+                ImGui::TableNextRow();
+                ImGui::TableSetColumnIndex(0);
+                ImVec4 oqc = InventoryScreen::getQualityColor(quality);
+                if (info && info->valid && info->displayInfoId != 0) {
+                    VkDescriptorSet oIcon = inventoryScreen.getItemIcon(info->displayInfoId);
+                    if (oIcon) {
+                        ImGui::Image((void*)(intptr_t)oIcon, ImVec2(16, 16));
+                        ImGui::SameLine();
+                    }
+                }
+                ImGui::TextColored(oqc, "%s", name.c_str());
+                if (ImGui::IsItemHovered() && info && info->valid) {
+                    ImGui::BeginTooltip();
+                    ImGui::TextColored(oqc, "%s", info->name.c_str());
+                    if (info->armor > 0) ImGui::Text("%d Armor", info->armor);
+                    if (info->damageMax > 0.0f && info->delayMs > 0) {
+                        float speed = static_cast<float>(info->delayMs) / 1000.0f;
+                        ImGui::Text("%.0f - %.0f Damage  Speed %.2f", info->damageMin, info->damageMax, speed);
+                    }
+                    std::string ol;
+                    auto appO = [](std::string& o, int32_t v, const char* n) {
+                        if (v <= 0) return;
+                        if (!o.empty()) o += "  ";
+                        o += "+" + std::to_string(v) + " " + n;
+                    };
+                    appO(ol, info->strength, "Str"); appO(ol, info->agility, "Agi");
+                    appO(ol, info->stamina, "Sta"); appO(ol, info->intellect, "Int");
+                    appO(ol, info->spirit, "Spi");
+                    if (!ol.empty()) ImGui::TextColored(ImVec4(0,1,0,1), "%s", ol.c_str());
+                    if (info->sellPrice > 0)
+                        ImGui::TextColored(ImVec4(1,0.84f,0,1), "Sell: %ug %us %uc",
+                            info->sellPrice/10000, (info->sellPrice/100)%100, info->sellPrice%100);
+                    ImGui::EndTooltip();
+                }
+                ImGui::TableSetColumnIndex(1);
+                ImGui::Text("%u", a.stackCount);
+                ImGui::TableSetColumnIndex(2);
+                {
+                    uint32_t bid = a.currentBid > 0 ? a.currentBid : a.startBid;
+                    ImGui::Text("%ug%us%uc", bid / 10000, (bid / 100) % 100, bid % 100);
+                }
+                ImGui::TableSetColumnIndex(3);
+                if (a.buyoutPrice > 0)
+                    ImGui::Text("%ug%us%uc", a.buyoutPrice / 10000, (a.buyoutPrice / 100) % 100, a.buyoutPrice % 100);
+                else
+                    ImGui::TextDisabled("--");
+                ImGui::TableSetColumnIndex(4);
+                ImGui::PushID(static_cast<int>(i) + 8000);
+                if (ImGui::SmallButton("Cancel")) {
+                    gameHandler.auctionCancelItem(a.auctionId);
+                }
+                ImGui::PopID();
+            }
+            ImGui::EndTable();
         }
     }
+
+    ImGui::End();
+
+    if (!open) gameHandler.closeAuctionHouse();
+}
+
+// ============================================================
+// Level-Up Ding Animation
+// ============================================================
+
+void GameScreen::triggerDing(uint32_t newLevel) {
+    dingTimer_ = DING_DURATION;
+    dingLevel_ = newLevel;
+
+    auto* renderer = core::Application::getInstance().getRenderer();
+    if (renderer) {
+        if (auto* sfx = renderer->getUiSoundManager()) {
+            sfx->playLevelUp();
+        }
+        renderer->playEmote("cheer");
+    }
+}
+
+void GameScreen::renderDingEffect() {
+    if (dingTimer_ <= 0.0f) return;
+
+    float dt = ImGui::GetIO().DeltaTime;
+    dingTimer_ -= dt;
+    if (dingTimer_ < 0.0f) dingTimer_ = 0.0f;
+
+    float alpha    = dingTimer_ < 0.8f ? (dingTimer_ / 0.8f) : 1.0f;  // fade out last 0.8s
+
+    ImGuiIO& io = ImGui::GetIO();
+    float cx = io.DisplaySize.x * 0.5f;
+    float cy = io.DisplaySize.y * 0.5f;
+
+    ImDrawList* draw = ImGui::GetForegroundDrawList();
+
+    // "LEVEL X!" text — visible for first 2.2s
+    if (dingTimer_ > 0.8f) {
+        ImFont* font = ImGui::GetFont();
+        float baseSize = ImGui::GetFontSize();
+        float fontSize = baseSize * 2.8f;
+
+        char buf[32];
+        snprintf(buf, sizeof(buf), "LEVEL %u!", dingLevel_);
+
+        ImVec2 sz = font->CalcTextSizeA(fontSize, FLT_MAX, 0.0f, buf);
+        float tx = cx - sz.x * 0.5f;
+        float ty = cy - sz.y * 0.5f - 20.0f;
+
+        // Drop shadow
+        draw->AddText(font, fontSize, ImVec2(tx + 3, ty + 3),
+                      IM_COL32(0, 0, 0, (int)(alpha * 200)), buf);
+        // Gold text
+        draw->AddText(font, fontSize, ImVec2(tx, ty),
+                      IM_COL32(255, 215, 0, (int)(alpha * 255)), buf);
+
+        // "DING!" subtitle
+        const char* ding = "DING!";
+        float dingSize = baseSize * 1.8f;
+        ImVec2 dingSz = font->CalcTextSizeA(dingSize, FLT_MAX, 0.0f, ding);
+        float dx = cx - dingSz.x * 0.5f;
+        float dy = ty + sz.y + 6.0f;
+        draw->AddText(font, dingSize, ImVec2(dx + 2, dy + 2),
+                      IM_COL32(0, 0, 0, (int)(alpha * 180)), ding);
+        draw->AddText(font, dingSize, ImVec2(dx, dy),
+                      IM_COL32(255, 255, 150, (int)(alpha * 255)), ding);
+    }
+}
+
+void GameScreen::triggerAchievementToast(uint32_t achievementId) {
+    achievementToastId_    = achievementId;
+    achievementToastTimer_ = ACHIEVEMENT_TOAST_DURATION;
+
+    // Play a UI sound if available
+    auto* renderer = core::Application::getInstance().getRenderer();
+    if (renderer) {
+        if (auto* sfx = renderer->getUiSoundManager()) {
+            sfx->playAchievementAlert();
+        }
+    }
+}
+
+void GameScreen::renderAchievementToast() {
+    if (achievementToastTimer_ <= 0.0f) return;
+
+    float dt = ImGui::GetIO().DeltaTime;
+    achievementToastTimer_ -= dt;
+    if (achievementToastTimer_ < 0.0f) achievementToastTimer_ = 0.0f;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth())  : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) :  720.0f;
+
+    // Slide in from the right — fully visible for most of the duration, slides out at end
+    constexpr float SLIDE_TIME = 0.4f;
+    float  slideIn  = std::min(achievementToastTimer_, ACHIEVEMENT_TOAST_DURATION - achievementToastTimer_);
+    float  slideFrac = (ACHIEVEMENT_TOAST_DURATION > 0.0f && SLIDE_TIME > 0.0f)
+                         ? std::min(slideIn / SLIDE_TIME, 1.0f)
+                         : 1.0f;
+
+    constexpr float TOAST_W = 280.0f;
+    constexpr float TOAST_H =  60.0f;
+    float xFull   = screenW - TOAST_W - 20.0f;
+    float xHidden = screenW + 10.0f;
+    float toastX  = xHidden + (xFull - xHidden) * slideFrac;
+    float toastY  = screenH - TOAST_H - 80.0f;  // above action bar area
+
+    float alpha = std::min(1.0f, achievementToastTimer_ / 0.5f);  // fade at very end
+
+    ImDrawList* draw = ImGui::GetForegroundDrawList();
+
+    // Background panel (gold border, dark fill)
+    ImVec2 tl(toastX,            toastY);
+    ImVec2 br(toastX + TOAST_W,  toastY + TOAST_H);
+    draw->AddRectFilled(tl, br, IM_COL32(30, 20, 10, (int)(alpha * 230)), 6.0f);
+    draw->AddRect(tl, br, IM_COL32(200, 170, 50, (int)(alpha * 255)), 6.0f, 0, 2.0f);
+
+    // Title
+    ImFont* font = ImGui::GetFont();
+    float   titleSize = 14.0f;
+    float   bodySize  = 12.0f;
+    const char* title = "Achievement Earned!";
+    float titleW = font->CalcTextSizeA(titleSize, FLT_MAX, 0.0f, title).x;
+    float titleX = toastX + (TOAST_W - titleW) * 0.5f;
+    draw->AddText(font, titleSize, ImVec2(titleX + 1, toastY + 8 + 1),
+                  IM_COL32(0, 0, 0, (int)(alpha * 180)), title);
+    draw->AddText(font, titleSize, ImVec2(titleX, toastY + 8),
+                  IM_COL32(255, 215, 0, (int)(alpha * 255)), title);
+
+    // Achievement ID line (until we have Achievement.dbc name lookup)
+    char idBuf[64];
+    std::snprintf(idBuf, sizeof(idBuf), "Achievement #%u", achievementToastId_);
+    float idW = font->CalcTextSizeA(bodySize, FLT_MAX, 0.0f, idBuf).x;
+    float idX = toastX + (TOAST_W - idW) * 0.5f;
+    draw->AddText(font, bodySize, ImVec2(idX, toastY + 28),
+                  IM_COL32(220, 200, 150, (int)(alpha * 255)), idBuf);
+}
+
+// ---------------------------------------------------------------------------
+// Zone discovery text — "Entering: <ZoneName>" fades in/out at screen centre
+// ---------------------------------------------------------------------------
+
+void GameScreen::renderZoneText() {
+    // Poll the renderer for zone name changes
+    auto* appRenderer = core::Application::getInstance().getRenderer();
+    if (appRenderer) {
+        const std::string& zoneName = appRenderer->getCurrentZoneName();
+        if (!zoneName.empty() && zoneName != lastKnownZoneName_) {
+            lastKnownZoneName_ = zoneName;
+            zoneTextName_  = zoneName;
+            zoneTextTimer_ = ZONE_TEXT_DURATION;
+        }
+    }
+
+    if (zoneTextTimer_ <= 0.0f || zoneTextName_.empty()) return;
+
+    float dt = ImGui::GetIO().DeltaTime;
+    zoneTextTimer_ -= dt;
+    if (zoneTextTimer_ < 0.0f) zoneTextTimer_ = 0.0f;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth())  : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) :  720.0f;
+
+    // Fade: ramp up in first 0.5 s, hold, fade out in last 1.0 s
+    float alpha;
+    if (zoneTextTimer_ > ZONE_TEXT_DURATION - 0.5f)
+        alpha = 1.0f - (zoneTextTimer_ - (ZONE_TEXT_DURATION - 0.5f)) / 0.5f;
+    else if (zoneTextTimer_ < 1.0f)
+        alpha = zoneTextTimer_;
+    else
+        alpha = 1.0f;
+    alpha = std::clamp(alpha, 0.0f, 1.0f);
+
+    ImFont* font = ImGui::GetFont();
+
+    // "Entering:" header
+    const char* header = "Entering:";
+    float headerSize = 16.0f;
+    float nameSize   = 26.0f;
+
+    ImVec2 headerDim = font->CalcTextSizeA(headerSize, FLT_MAX, 0.0f, header);
+    ImVec2 nameDim   = font->CalcTextSizeA(nameSize,   FLT_MAX, 0.0f, zoneTextName_.c_str());
+
+    float centreY = screenH * 0.30f;  // upper third, like WoW
+    float headerX = (screenW - headerDim.x) * 0.5f;
+    float nameX   = (screenW - nameDim.x)   * 0.5f;
+    float headerY = centreY;
+    float nameY   = centreY + headerDim.y + 4.0f;
+
+    ImDrawList* draw = ImGui::GetForegroundDrawList();
+
+    // "Entering:" in gold
+    draw->AddText(font, headerSize, ImVec2(headerX + 1, headerY + 1),
+                  IM_COL32(0, 0, 0, (int)(alpha * 160)), header);
+    draw->AddText(font, headerSize, ImVec2(headerX, headerY),
+                  IM_COL32(255, 215, 0, (int)(alpha * 255)), header);
+
+    // Zone name in white
+    draw->AddText(font, nameSize, ImVec2(nameX + 1, nameY + 1),
+                  IM_COL32(0, 0, 0, (int)(alpha * 160)), zoneTextName_.c_str());
+    draw->AddText(font, nameSize, ImVec2(nameX, nameY),
+                  IM_COL32(255, 255, 255, (int)(alpha * 255)), zoneTextName_.c_str());
 }
 
 // ---------------------------------------------------------------------------
 // Dungeon Finder window (toggle with hotkey or bag-bar button)
 // ---------------------------------------------------------------------------
+void GameScreen::renderDungeonFinderWindow(game::GameHandler& gameHandler) {
+    // Toggle on I key when not typing
+    if (!chatInputActive && ImGui::IsKeyPressed(ImGuiKey_I, false)) {
+        showDungeonFinder_ = !showDungeonFinder_;
+    }
+
+    if (!showDungeonFinder_) return;
+
+    auto* window = core::Application::getInstance().getWindow();
+    float screenW = window ? static_cast<float>(window->getWidth())  : 1280.0f;
+    float screenH = window ? static_cast<float>(window->getHeight()) :  720.0f;
+
+    ImGui::SetNextWindowPos(ImVec2(screenW * 0.5f - 175.0f, screenH * 0.2f),
+                            ImGuiCond_FirstUseEver);
+    ImGui::SetNextWindowSize(ImVec2(350, 0), ImGuiCond_Always);
+
+    bool open = true;
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize;
+    if (!ImGui::Begin("Dungeon Finder", &open, flags)) {
+        ImGui::End();
+        if (!open) showDungeonFinder_ = false;
+        return;
+    }
+    if (!open) {
+        ImGui::End();
+        showDungeonFinder_ = false;
+        return;
+    }
+
+    using LfgState = game::GameHandler::LfgState;
+    LfgState state = gameHandler.getLfgState();
+
+    // ---- Status banner ----
+    switch (state) {
+        case LfgState::None:
+            ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Status: Not queued");
+            break;
+        case LfgState::RoleCheck:
+            ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.2f, 1.0f), "Status: Role check in progress...");
+            break;
+        case LfgState::Queued: {
+            int32_t avgSec  = gameHandler.getLfgAvgWaitSec();
+            uint32_t qMs    = gameHandler.getLfgTimeInQueueMs();
+            int      qMin   = static_cast<int>(qMs / 60000);
+            int      qSec   = static_cast<int>((qMs % 60000) / 1000);
+            ImGui::TextColored(ImVec4(0.3f, 0.9f, 0.3f, 1.0f), "Status: In queue (%d:%02d)", qMin, qSec);
+            if (avgSec >= 0) {
+                int aMin = avgSec / 60;
+                int aSec = avgSec % 60;
+                ImGui::TextColored(ImVec4(0.8f, 0.8f, 0.8f, 1.0f),
+                                   "Avg wait: %d:%02d", aMin, aSec);
+            }
+            break;
+        }
+        case LfgState::Proposal:
+            ImGui::TextColored(ImVec4(1.0f, 0.5f, 0.1f, 1.0f), "Status: Group found!");
+            break;
+        case LfgState::Boot:
+            ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f), "Status: Vote kick in progress");
+            break;
+        case LfgState::InDungeon:
+            ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "Status: In dungeon");
+            break;
+        case LfgState::FinishedDungeon:
+            ImGui::TextColored(ImVec4(0.6f, 1.0f, 0.6f, 1.0f), "Status: Dungeon complete");
+            break;
+        case LfgState::RaidBrowser:
+            ImGui::TextColored(ImVec4(0.8f, 0.6f, 1.0f, 1.0f), "Status: Raid browser");
+            break;
+    }
+
+    ImGui::Separator();
+
+    // ---- Proposal accept/decline ----
+    if (state == LfgState::Proposal) {
+        ImGui::TextColored(ImVec4(1.0f, 0.9f, 0.3f, 1.0f),
+                           "A group has been found for your dungeon!");
+        ImGui::Spacing();
+        if (ImGui::Button("Accept", ImVec2(120, 0))) {
+            gameHandler.lfgAcceptProposal(gameHandler.getLfgProposalId(), true);
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Decline", ImVec2(120, 0))) {
+            gameHandler.lfgAcceptProposal(gameHandler.getLfgProposalId(), false);
+        }
+        ImGui::Separator();
+    }
+
+    // ---- Teleport button (in dungeon) ----
+    if (state == LfgState::InDungeon) {
+        if (ImGui::Button("Teleport to Dungeon", ImVec2(-1, 0))) {
+            gameHandler.lfgTeleport(true);
+        }
+        ImGui::Separator();
+    }
+
+    // ---- Role selection (only when not queued/in dungeon) ----
+    bool canConfigure = (state == LfgState::None || state == LfgState::FinishedDungeon);
+
+    if (canConfigure) {
+        ImGui::Text("Role:");
+        ImGui::SameLine();
+        bool isTank   = (lfgRoles_ & 0x02) != 0;
+        bool isHealer = (lfgRoles_ & 0x04) != 0;
+        bool isDps    = (lfgRoles_ & 0x08) != 0;
+        if (ImGui::Checkbox("Tank",   &isTank))   lfgRoles_ = (lfgRoles_ & ~0x02) | (isTank   ? 0x02 : 0);
+        ImGui::SameLine();
+        if (ImGui::Checkbox("Healer", &isHealer)) lfgRoles_ = (lfgRoles_ & ~0x04) | (isHealer ? 0x04 : 0);
+        ImGui::SameLine();
+        if (ImGui::Checkbox("DPS",    &isDps))    lfgRoles_ = (lfgRoles_ & ~0x08) | (isDps    ? 0x08 : 0);
+
+        ImGui::Spacing();
+
+        // ---- Dungeon selection ----
+        ImGui::Text("Dungeon:");
+
+        struct DungeonEntry { uint32_t id; const char* name; };
+        static const DungeonEntry kDungeons[] = {
+            { 861, "Random Dungeon" },
+            { 862, "Random Heroic" },
+            // Vanilla classics
+            {  36, "Deadmines" },
+            {  43, "Ragefire Chasm" },
+            {  47, "Razorfen Kraul" },
+            {  48, "Blackfathom Deeps" },
+            {  52, "Uldaman" },
+            {  57, "Dire Maul: East" },
+            {  70, "Onyxia's Lair" },
+            // TBC heroics
+            { 264, "The Blood Furnace" },
+            { 269, "The Shattered Halls" },
+            // WotLK normals/heroics
+            { 576, "The Nexus" },
+            { 578, "The Oculus" },
+            { 595, "The Culling of Stratholme" },
+            { 599, "Halls of Stone" },
+            { 600, "Drak'Tharon Keep" },
+            { 601, "Azjol-Nerub" },
+            { 604, "Gundrak" },
+            { 608, "Violet Hold" },
+            { 619, "Ahn'kahet: Old Kingdom" },
+            { 623, "Halls of Lightning" },
+            { 632, "The Forge of Souls" },
+            { 650, "Trial of the Champion" },
+            { 658, "Pit of Saron" },
+            { 668, "Halls of Reflection" },
+        };
+
+        // Find current index
+        int curIdx = 0;
+        for (int i = 0; i < (int)(sizeof(kDungeons)/sizeof(kDungeons[0])); ++i) {
+            if (kDungeons[i].id == lfgSelectedDungeon_) { curIdx = i; break; }
+        }
+
+        ImGui::SetNextItemWidth(-1);
+        if (ImGui::BeginCombo("##dungeon", kDungeons[curIdx].name)) {
+            for (int i = 0; i < (int)(sizeof(kDungeons)/sizeof(kDungeons[0])); ++i) {
+                bool selected = (kDungeons[i].id == lfgSelectedDungeon_);
+                if (ImGui::Selectable(kDungeons[i].name, selected))
+                    lfgSelectedDungeon_ = kDungeons[i].id;
+                if (selected) ImGui::SetItemDefaultFocus();
+            }
+            ImGui::EndCombo();
+        }
+
+        ImGui::Spacing();
+
+        // ---- Join button ----
+        bool rolesOk = (lfgRoles_ != 0);
+        if (!rolesOk) {
+            ImGui::BeginDisabled();
+        }
+        if (ImGui::Button("Join Dungeon Finder", ImVec2(-1, 0))) {
+            gameHandler.lfgJoin(lfgSelectedDungeon_, lfgRoles_);
+        }
+        if (!rolesOk) {
+            ImGui::EndDisabled();
+            ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f), "Select at least one role.");
+        }
+    }
+
+    // ---- Leave button (when queued or role check) ----
+    if (state == LfgState::Queued || state == LfgState::RoleCheck) {
+        if (ImGui::Button("Leave Queue", ImVec2(-1, 0))) {
+            gameHandler.lfgLeave();
+        }
+    }
+
+    ImGui::End();
+}
+
 // ============================================================
 // Instance Lockouts
 // ============================================================
 
+void GameScreen::renderInstanceLockouts(game::GameHandler& gameHandler) {
+    if (!showInstanceLockouts_) return;
 
+    ImGui::SetNextWindowSize(ImVec2(480, 0), ImGuiCond_Appearing);
+    ImGui::SetNextWindowPos(
+        ImVec2(ImGui::GetIO().DisplaySize.x / 2 - 240, 140), ImGuiCond_Appearing);
 
+    if (!ImGui::Begin("Instance Lockouts", &showInstanceLockouts_,
+                      ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize)) {
+        ImGui::End();
+        return;
+    }
 
-// ─── Threat Window ────────────────────────────────────────────────────────────
-// ─── BG Scoreboard ────────────────────────────────────────────────────────────
+    const auto& lockouts = gameHandler.getInstanceLockouts();
 
+    if (lockouts.empty()) {
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "No active instance lockouts.");
+    } else {
+        // Build map name lookup from Map.dbc (cached after first call)
+        static std::unordered_map<uint32_t, std::string> sMapNames;
+        static bool sMapNamesLoaded = false;
+        if (!sMapNamesLoaded) {
+            sMapNamesLoaded = true;
+            if (auto* am = core::Application::getInstance().getAssetManager()) {
+                if (auto dbc = am->loadDBC("Map.dbc"); dbc && dbc->isLoaded()) {
+                    for (uint32_t i = 0; i < dbc->getRecordCount(); ++i) {
+                        uint32_t id = dbc->getUInt32(i, 0);
+                        // Field 2 = MapName_enUS (first localized), field 1 = InternalName
+                        std::string name = dbc->getString(i, 2);
+                        if (name.empty()) name = dbc->getString(i, 1);
+                        if (!name.empty()) sMapNames[id] = std::move(name);
+                    }
+                }
+            }
+        }
 
+        auto difficultyLabel = [](uint32_t diff) -> const char* {
+            switch (diff) {
+                case 0: return "Normal";
+                case 1: return "Heroic";
+                case 2: return "25-Man";
+                case 3: return "25-Man Heroic";
+                default: return "Unknown";
+            }
+        };
 
+        // Current UTC time for reset countdown
+        auto nowSec = static_cast<uint64_t>(std::time(nullptr));
 
+        if (ImGui::BeginTable("lockouts", 4,
+                              ImGuiTableFlags_SizingStretchProp |
+                              ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersOuter)) {
+            ImGui::TableSetupColumn("Instance",   ImGuiTableColumnFlags_WidthStretch);
+            ImGui::TableSetupColumn("Difficulty", ImGuiTableColumnFlags_WidthFixed, 110.0f);
+            ImGui::TableSetupColumn("Resets In",  ImGuiTableColumnFlags_WidthFixed, 100.0f);
+            ImGui::TableSetupColumn("Status",     ImGuiTableColumnFlags_WidthFixed, 60.0f);
+            ImGui::TableHeadersRow();
 
+            for (const auto& lo : lockouts) {
+                ImGui::TableNextRow();
+
+                // Instance name
+                ImGui::TableSetColumnIndex(0);
+                auto it = sMapNames.find(lo.mapId);
+                if (it != sMapNames.end()) {
+                    ImGui::TextUnformatted(it->second.c_str());
+                } else {
+                    ImGui::Text("Map %u", lo.mapId);
+                }
+
+                // Difficulty
+                ImGui::TableSetColumnIndex(1);
+                ImGui::TextUnformatted(difficultyLabel(lo.difficulty));
+
+                // Reset countdown
+                ImGui::TableSetColumnIndex(2);
+                if (lo.resetTime > nowSec) {
+                    uint64_t remaining = lo.resetTime - nowSec;
+                    uint64_t days  = remaining / 86400;
+                    uint64_t hours = (remaining % 86400) / 3600;
+                    if (days > 0) {
+                        ImGui::Text("%llud %lluh",
+                            static_cast<unsigned long long>(days),
+                            static_cast<unsigned long long>(hours));
+                    } else {
+                        uint64_t mins = (remaining % 3600) / 60;
+                        ImGui::Text("%lluh %llum",
+                            static_cast<unsigned long long>(hours),
+                            static_cast<unsigned long long>(mins));
+                    }
+                } else {
+                    ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "Expired");
+                }
+
+                // Locked / Extended status
+                ImGui::TableSetColumnIndex(3);
+                if (lo.extended) {
+                    ImGui::TextColored(ImVec4(0.3f, 0.7f, 1.0f, 1.0f), "Ext");
+                } else if (lo.locked) {
+                    ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f), "Locked");
+                } else {
+                    ImGui::TextColored(ImVec4(0.5f, 0.9f, 0.5f, 1.0f), "Open");
+                }
+            }
+
+            ImGui::EndTable();
+        }
+    }
+
+    ImGui::End();
+}
 
 }} // namespace wowee::ui
diff --git a/src/ui/inventory_screen.cpp b/src/ui/inventory_screen.cpp
index eb030e09..320fc316 100644
--- a/src/ui/inventory_screen.cpp
+++ b/src/ui/inventory_screen.cpp
@@ -1,6 +1,4 @@
 #include "ui/inventory_screen.hpp"
-#include "ui/ui_colors.hpp"
-#include "ui/keybinding_manager.hpp"
 #include "game/game_handler.hpp"
 #include "core/application.hpp"
 #include "rendering/vk_context.hpp"
@@ -18,67 +16,12 @@
 #include <algorithm>
 #include <cstdio>
 #include <cstring>
-#include <cmath>
 #include <unordered_set>
 
 namespace wowee {
 namespace ui {
 
 namespace {
-
-// Reputation rank names (indexed 0-7: Hated..Exalted)
-constexpr const char* kRepRankNames[8] = {
-    "Hated", "Hostile", "Unfriendly", "Neutral",
-    "Friendly", "Honored", "Revered", "Exalted"
-};
-
-// Resistance stat names (indexed 0-5: Holy..Arcane)
-constexpr const char* kResistNames[6] = {
-    "Holy Resistance", "Fire Resistance", "Nature Resistance",
-    "Frost Resistance", "Shadow Resistance", "Arcane Resistance"
-};
-
-// Render "Classes: Warrior, Paladin" or "Races: Human, Orc" restriction text.
-// Shared between quest info and item info tooltips — both use the same WoW
-// allowableClass/allowableRace bitmask format with identical display logic.
-void renderClassRestriction(uint32_t allowableMask, uint8_t playerClass) {
-    const auto& entries = ui::kClassMasks;
-    int mc = 0;
-    for (const auto& e : entries) if (allowableMask & e.mask) ++mc;
-    if (mc <= 0 || mc >= 10) return;  // all classes allowed or none matched
-    char buf[128] = "Classes: "; bool first = true;
-    for (const auto& e : entries) {
-        if (!(allowableMask & e.mask)) continue;
-        if (!first) strncat(buf, ", ", sizeof(buf) - strlen(buf) - 1);
-        strncat(buf, e.name, sizeof(buf) - strlen(buf) - 1);
-        first = false;
-    }
-    uint32_t pm = (playerClass > 0 && playerClass <= 10) ? (1u << (playerClass - 1)) : 0;
-    bool ok = (pm == 0 || (allowableMask & pm));
-    ImGui::TextColored(ok ? ImVec4(1,1,1,0.75f) : colors::kPaleRed, "%s", buf);
-}
-
-void renderRaceRestriction(uint32_t allowableMask, uint8_t playerRace) {
-    constexpr uint32_t kAllPlayable = 1|2|4|8|16|32|64|128|512|1024;
-    if ((allowableMask & kAllPlayable) == kAllPlayable) return;
-    const auto& entries = ui::kRaceMasks;
-    int mc = 0;
-    for (const auto& e : entries) if (allowableMask & e.mask) ++mc;
-    if (mc <= 0) return;
-    char buf[160] = "Races: "; bool first = true;
-    for (const auto& e : entries) {
-        if (!(allowableMask & e.mask)) continue;
-        if (!first) strncat(buf, ", ", sizeof(buf) - strlen(buf) - 1);
-        strncat(buf, e.name, sizeof(buf) - strlen(buf) - 1);
-        first = false;
-    }
-    uint32_t pm = (playerRace > 0 && playerRace <= 11) ? (1u << (playerRace - 1)) : 0;
-    bool ok = (pm == 0 || (allowableMask & pm));
-    ImGui::TextColored(ok ? ImVec4(1,1,1,0.75f) : colors::kPaleRed, "%s", buf);
-}
-
-// Socket types from shared ui_colors.hpp (ui::kSocketTypes)
-
 const game::ItemSlot* findComparableEquipped(const game::Inventory& inventory, uint8_t inventoryType) {
     using ES = game::EquipSlot;
     auto slotPtr = [&](ES slot) -> const game::ItemSlot* {
@@ -128,7 +71,6 @@ const game::ItemSlot* findComparableEquipped(const game::Inventory& inventory, u
         default: return nullptr;
     }
 }
-
 } // namespace
 
 InventoryScreen::~InventoryScreen() {
@@ -137,7 +79,15 @@ InventoryScreen::~InventoryScreen() {
 }
 
 ImVec4 InventoryScreen::getQualityColor(game::ItemQuality quality) {
-    return ui::getQualityColor(quality);
+    switch (quality) {
+        case game::ItemQuality::POOR:      return ImVec4(0.62f, 0.62f, 0.62f, 1.0f); // Grey
+        case game::ItemQuality::COMMON:    return ImVec4(1.0f, 1.0f, 1.0f, 1.0f);    // White
+        case game::ItemQuality::UNCOMMON:  return ImVec4(0.12f, 1.0f, 0.0f, 1.0f);   // Green
+        case game::ItemQuality::RARE:      return ImVec4(0.0f, 0.44f, 0.87f, 1.0f);  // Blue
+        case game::ItemQuality::EPIC:      return ImVec4(0.64f, 0.21f, 0.93f, 1.0f); // Purple
+        case game::ItemQuality::LEGENDARY: return ImVec4(1.0f, 0.50f, 0.0f, 1.0f);   // Orange
+        default:                           return ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
+    }
 }
 
 // ============================================================
@@ -150,14 +100,6 @@ VkDescriptorSet InventoryScreen::getItemIcon(uint32_t displayInfoId) {
     auto it = iconCache_.find(displayInfoId);
     if (it != iconCache_.end()) return it->second;
 
-    // Rate-limit GPU uploads per frame to avoid stalling when many items appear at once
-    // (e.g., opening a full bag, vendor window, or loot from a boss with many drops).
-    static int iiLoadsThisFrame = 0;
-    static int iiLastImGuiFrame = -1;
-    int iiCurFrame = ImGui::GetFrameCount();
-    if (iiCurFrame != iiLastImGuiFrame) { iiLoadsThisFrame = 0; iiLastImGuiFrame = iiCurFrame; }
-    if (iiLoadsThisFrame >= 4) return VK_NULL_HANDLE;  // defer — do NOT cache null here
-
     // Load ItemDisplayInfo.dbc
     auto displayInfoDbc = assetManager_->loadDBC("ItemDisplayInfo.dbc");
     if (!displayInfoDbc) {
@@ -200,7 +142,6 @@ VkDescriptorSet InventoryScreen::getItemIcon(uint32_t displayInfoId) {
         return VK_NULL_HANDLE;
     }
 
-    ++iiLoadsThisFrame;
     VkDescriptorSet ds = vkCtx->uploadImGuiTexture(image.data.data(), image.width, image.height);
     iconCache_[displayInfoId] = ds;
     return ds;
@@ -741,6 +682,10 @@ void InventoryScreen::toggleBackpack() {
 void InventoryScreen::toggleBag(int idx) {
     if (idx >= 0 && idx < 4) {
         bagOpen_[idx] = !bagOpen_[idx];
+        if (bagOpen_[idx]) {
+            // Keep backpack as the anchor window at the bottom of the stack.
+            backpackOpen_ = true;
+        }
     }
 }
 
@@ -764,13 +709,18 @@ bool InventoryScreen::bagHasAnyItems(const game::Inventory& inventory, int bagIn
 }
 
 void InventoryScreen::render(game::Inventory& inventory, uint64_t moneyCopper) {
-    // Bags toggle (B key, edge-triggered)
-    bool bagsDown = KeybindingManager::getInstance().isActionPressed(
-        KeybindingManager::Action::TOGGLE_BAGS, false);
-    bool bToggled = bagsDown && !bKeyWasDown;
-    bKeyWasDown = bagsDown;
-
+    // B key toggle (edge-triggered)
     bool wantsTextInput = ImGui::GetIO().WantTextInput;
+    bool bDown = !wantsTextInput && core::Input::getInstance().isKeyPressed(SDL_SCANCODE_B);
+    bool bToggled = bDown && !bKeyWasDown;
+    bKeyWasDown = bDown;
+
+    // C key toggle for character screen (edge-triggered)
+    bool cDown = !wantsTextInput && core::Input::getInstance().isKeyPressed(SDL_SCANCODE_C);
+    if (cDown && !cKeyWasDown) {
+        characterOpen = !characterOpen;
+    }
+    cKeyWasDown = cDown;
 
     if (separateBags_) {
         if (bToggled) {
@@ -871,62 +821,6 @@ void InventoryScreen::render(game::Inventory& inventory, uint64_t moneyCopper) {
         ImGui::EndPopup();
     }
 
-    // Shift+right-click destroy confirmation popup
-    if (destroyConfirmOpen_) {
-        ImVec2 mousePos = ImGui::GetIO().MousePos;
-        ImGui::SetNextWindowPos(ImVec2(mousePos.x - 80.0f, mousePos.y - 20.0f), ImGuiCond_Always);
-        ImGui::OpenPopup("##DestroyItem");
-        destroyConfirmOpen_ = false;
-    }
-    if (ImGui::BeginPopup("##DestroyItem", ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar)) {
-        ImGui::TextColored(ui::colors::kSoftRed, "Destroy");
-        ImGui::TextUnformatted(destroyItemName_.c_str());
-        ImGui::Spacing();
-        if (ImGui::Button("Yes, Destroy", ImVec2(110, 0))) {
-            if (gameHandler_) {
-                gameHandler_->destroyItem(destroyBag_, destroySlot_, destroyCount_);
-            }
-            destroyItemName_.clear();
-            inventoryDirty = true;
-            ImGui::CloseCurrentPopup();
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Cancel", ImVec2(70, 0))) {
-            destroyItemName_.clear();
-            ImGui::CloseCurrentPopup();
-        }
-        ImGui::EndPopup();
-    }
-
-    // Stack split popup
-    if (splitConfirmOpen_) {
-        ImVec2 mousePos = ImGui::GetIO().MousePos;
-        ImGui::SetNextWindowPos(ImVec2(mousePos.x - 80.0f, mousePos.y - 20.0f), ImGuiCond_Always);
-        ImGui::OpenPopup("##SplitStack");
-        splitConfirmOpen_ = false;
-    }
-    if (ImGui::BeginPopup("##SplitStack", ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar)) {
-        ImGui::Text("Split %s", splitItemName_.c_str());
-        ImGui::Spacing();
-        ImGui::SetNextItemWidth(120.0f);
-        ImGui::SliderInt("##splitcount", &splitCount_, 1, splitMax_ - 1);
-        ImGui::Spacing();
-        if (ImGui::Button("OK", ImVec2(55, 0))) {
-            if (gameHandler_ && splitCount_ > 0 && splitCount_ < splitMax_) {
-                gameHandler_->splitItem(splitBag_, splitSlot_, static_cast<uint8_t>(splitCount_));
-            }
-            splitItemName_.clear();
-            inventoryDirty = true;
-            ImGui::CloseCurrentPopup();
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Cancel", ImVec2(55, 0))) {
-            splitItemName_.clear();
-            ImGui::CloseCurrentPopup();
-        }
-        ImGui::EndPopup();
-    }
-
     // Draw held item at cursor
     renderHeldItem();
 }
@@ -959,30 +853,22 @@ void InventoryScreen::renderAggregateBags(game::Inventory& inventory, uint64_t m
     float posX = screenW - windowW - 10.0f;
     float posY = screenH - windowH - 60.0f;
 
-    ImGui::SetNextWindowPos(ImVec2(posX, posY), ImGuiCond_FirstUseEver);
+    ImGui::SetNextWindowPos(ImVec2(posX, posY), ImGuiCond_Always);
     ImGui::SetNextWindowSize(ImVec2(windowW, windowH), ImGuiCond_Always);
 
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize;
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
     if (!ImGui::Begin("Bags", &open, flags)) {
         ImGui::End();
         return;
     }
 
-    // Reset to bottom-right if the window ended up outside the screen (resolution change)
-    ImVec2 winPos = ImGui::GetWindowPos();
-    ImVec2 winSize = ImGui::GetWindowSize();
-    if (winPos.x > screenW || winPos.y > screenH ||
-        winPos.x + winSize.x < 0 || winPos.y + winSize.y < 0) {
-        ImGui::SetWindowPos(ImVec2(posX, posY));
-    }
-
     renderBackpackPanel(inventory, compactBags_);
 
     ImGui::Spacing();
     uint64_t gold = moneyCopper / 10000;
     uint64_t silver = (moneyCopper / 100) % 100;
     uint64_t copper = moneyCopper % 100;
-    ImGui::TextColored(ui::colors::kWarmGold, "%llug %llus %lluc",
+    ImGui::TextColored(ImVec4(1.0f, 0.84f, 0.0f, 1.0f), "%llug %llus %lluc",
                        static_cast<unsigned long long>(gold),
                        static_cast<unsigned long long>(silver),
                        static_cast<unsigned long long>(copper));
@@ -1014,7 +900,11 @@ void InventoryScreen::renderSeparateBags(game::Inventory& inventory, uint64_t mo
     constexpr int columns = 6;
     constexpr float baseWindowW = columns * (slotSize + 4.0f) + 30.0f;
 
-    // Each bag window is independently closable — no forced backpack constraint.
+    bool anyBagOpen = std::any_of(bagOpen_.begin(), bagOpen_.end(), [](bool b) { return b; });
+    if (anyBagOpen && !backpackOpen_) {
+        // Enforce backpack as the bottom-most stack window when any bag is open.
+        backpackOpen_ = true;
+    }
 
     // Anchor stack to the bag bar (bottom-right), opening upward.
     const float bagBarTop = screenH - (42.0f + 12.0f) - 10.0f;
@@ -1024,15 +914,10 @@ void InventoryScreen::renderSeparateBags(game::Inventory& inventory, uint64_t mo
 
     // Backpack window (bottom of stack)
     if (backpackOpen_) {
-        int bpTotal = inventory.getBackpackSize();
-        int bpUsed = 0;
-        for (int i = 0; i < bpTotal; ++i) if (!inventory.getBackpackSlot(i).empty()) ++bpUsed;
-        char bpTitle[64];
-        snprintf(bpTitle, sizeof(bpTitle), "Backpack (%d/%d)##backpack", bpUsed, bpTotal);
-        int bpRows = (bpTotal + columns - 1) / columns;
+        int bpRows = (inventory.getBackpackSize() + columns - 1) / columns;
         float bpH = bpRows * (slotSize + 4.0f) + 80.0f; // header + money + padding
         float defaultY = stackBottom - bpH;
-        renderBagWindow(bpTitle, backpackOpen_, inventory, -1, stackX, defaultY, moneyCopper);
+        renderBagWindow("Backpack", backpackOpen_, inventory, -1, stackX, defaultY, moneyCopper);
         stackBottom = defaultY - stackGap;
     }
 
@@ -1054,16 +939,14 @@ void InventoryScreen::renderSeparateBags(game::Inventory& inventory, uint64_t mo
         float defaultY = stackBottom - bagH;
         stackBottom = defaultY - stackGap;
 
-        // Build title from equipped bag item name, with used/total slot counts
-        int bagUsed = 0;
-        for (int si = 0; si < bagSize; ++si) if (!inventory.getBagSlot(bag, si).empty()) ++bagUsed;
-        char title[96];
+        // Build title from equipped bag item name
+        char title[64];
         game::EquipSlot bagSlot = static_cast<game::EquipSlot>(static_cast<int>(game::EquipSlot::BAG1) + bag);
         const auto& bagItem = inventory.getEquipSlot(bagSlot);
         if (!bagItem.empty() && !bagItem.item.name.empty()) {
-            snprintf(title, sizeof(title), "%s (%d/%d)##bag%d", bagItem.item.name.c_str(), bagUsed, bagSize, bag);
+            snprintf(title, sizeof(title), "%s##bag%d", bagItem.item.name.c_str(), bag);
         } else {
-            snprintf(title, sizeof(title), "Bag Slot %d (%d/%d)##bag%d", bag + 1, bagUsed, bagSize, bag);
+            snprintf(title, sizeof(title), "Bag Slot %d##bag%d", bag + 1, bag);
         }
 
         renderBagWindow(title, bagOpen_[bag], inventory, bag, stackX, defaultY, 0);
@@ -1084,11 +967,7 @@ void InventoryScreen::renderBagWindow(const char* title, bool& isOpen,
 
     int rows = (numSlots + columns - 1) / columns;
     float contentH = rows * (slotSize + 4.0f) + 10.0f;
-    if (bagIndex < 0) {
-        int keyringRows = (inventory.getKeyringSize() + columns - 1) / columns;
-        contentH += 36.0f; // separator + sort button + money display
-        contentH += 30.0f + keyringRows * (slotSize + 4.0f); // keyring header + slots
-    }
+    if (bagIndex < 0) contentH += 25.0f; // money display for backpack
     float gridW = columns * (slotSize + 4.0f) + 30.0f;
     // Ensure window is wide enough for the title + close button
     const char* displayTitle = title;
@@ -1097,7 +976,8 @@ void InventoryScreen::renderBagWindow(const char* title, bool& isOpen,
     float windowW = std::max(gridW, titleW);
     float windowH = contentH + 40.0f; // title bar + padding
 
-    ImGui::SetNextWindowPos(ImVec2(defaultX, defaultY), ImGuiCond_FirstUseEver);
+    // Keep separate bag windows anchored to the bag-bar stack.
+    ImGui::SetNextWindowPos(ImVec2(defaultX, defaultY), ImGuiCond_Always);
     ImGui::SetNextWindowSize(ImVec2(windowW, windowH), ImGuiCond_Always);
 
     ImGuiWindowFlags flags = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize;
@@ -1106,16 +986,6 @@ void InventoryScreen::renderBagWindow(const char* title, bool& isOpen,
         return;
     }
 
-    // Reset position if the window ended up outside the screen (resolution change)
-    ImVec2 winPos = ImGui::GetWindowPos();
-    ImVec2 winSize = ImGui::GetWindowSize();
-    float scrW = ImGui::GetIO().DisplaySize.x;
-    float scrH = ImGui::GetIO().DisplaySize.y;
-    if (winPos.x > scrW || winPos.y > scrH ||
-        winPos.x + winSize.x < 0 || winPos.y + winSize.y < 0) {
-        ImGui::SetWindowPos(ImVec2(defaultX, defaultY));
-    }
-
     // Render item slots in 4-column grid
     for (int i = 0; i < numSlots; i++) {
         if (i % columns != 0) ImGui::SameLine();
@@ -1145,73 +1015,16 @@ void InventoryScreen::renderBagWindow(const char* title, bool& isOpen,
         ImGui::PopID();
     }
 
-    if (bagIndex < 0 && showKeyring_) {
-        constexpr float keySlotSize = 24.0f;
-        constexpr int keyCols = 8;
-        // Only show rows that contain items (round up to full row)
-        int lastOccupied = -1;
-        for (int i = inventory.getKeyringSize() - 1; i >= 0; --i) {
-            if (!inventory.getKeyringSlot(i).empty()) { lastOccupied = i; break; }
-        }
-        int visibleSlots = (lastOccupied < 0) ? 0 : ((lastOccupied / keyCols) + 1) * keyCols;
-        if (visibleSlots > 0) {
-            ImGui::Spacing();
-            ImGui::Separator();
-            ImGui::TextColored(ui::colors::kDarkYellow, "Keyring");
-            for (int i = 0; i < visibleSlots; ++i) {
-                if (i % keyCols != 0) ImGui::SameLine();
-                const auto& slot = inventory.getKeyringSlot(i);
-                char id[32];
-                snprintf(id, sizeof(id), "##skr_%d", i);
-                ImGui::PushID(id);
-                renderItemSlot(inventory, slot, keySlotSize, nullptr,
-                               SlotKind::BACKPACK, -1, game::EquipSlot::NUM_SLOTS);
-                ImGui::PopID();
-            }
-        }
-    }
-
-    // Footer for backpack: sort button + money display
-    if (bagIndex < 0) {
+    // Money display at bottom of backpack
+    if (bagIndex < 0 && moneyCopper > 0) {
         ImGui::Spacing();
-        ImGui::Separator();
-
-        // Sort Bags button — compute swaps, apply client-side preview, queue server packets
-        {
-            bool sorting = !sortSwapQueue_.empty();
-            if (sorting) ImGui::BeginDisabled();
-            if (ImGui::SmallButton(sorting ? "Sorting..." : "Sort Bags")) {
-                // Compute the swap operations before modifying local state
-                auto swaps = inventory.computeSortSwaps();
-                // Apply local preview immediately
-                inventory.sortBags();
-                // Queue server-side swaps (one per frame)
-                for (auto& s : swaps)
-                    sortSwapQueue_.push_back(s);
-            }
-            if (sorting) ImGui::EndDisabled();
-            if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
-                ImGui::SetTooltip("Sort all bag slots by quality (highest first),\nthen by item ID, then by stack size.");
-            }
-
-            // Process one queued swap per frame
-            if (!sortSwapQueue_.empty() && gameHandler_) {
-                auto op = sortSwapQueue_.front();
-                sortSwapQueue_.pop_front();
-                gameHandler_->swapContainerItems(op.srcBag, op.srcSlot, op.dstBag, op.dstSlot);
-            }
-        }
-
-        if (moneyCopper > 0) {
-            ImGui::SameLine();
-            uint64_t gold   = moneyCopper / 10000;
-            uint64_t silver = (moneyCopper / 100) % 100;
-            uint64_t copper = moneyCopper % 100;
-            ImGui::TextColored(ui::colors::kWarmGold, "%llug %llus %lluc",
-                               static_cast<unsigned long long>(gold),
-                               static_cast<unsigned long long>(silver),
-                               static_cast<unsigned long long>(copper));
-        }
+        uint64_t gold = moneyCopper / 10000;
+        uint64_t silver = (moneyCopper / 100) % 100;
+        uint64_t copper = moneyCopper % 100;
+        ImGui::TextColored(ImVec4(1.0f, 0.84f, 0.0f, 1.0f), "%llug %llus %lluc",
+                           static_cast<unsigned long long>(gold),
+                           static_cast<unsigned long long>(silver),
+                           static_cast<unsigned long long>(copper));
     }
 
     ImGui::End();
@@ -1268,69 +1081,12 @@ void InventoryScreen::renderCharacterScreen(game::GameHandler& gameHandler) {
     if (ImGui::BeginTabBar("##CharacterTabs")) {
         if (ImGui::BeginTabItem("Equipment")) {
             renderEquipmentPanel(inventory);
-            ImGui::Spacing();
-            ImGui::Separator();
-            // Appearance visibility toggles
-            bool helmVis = gameHandler.isHelmVisible();
-            bool cloakVis = gameHandler.isCloakVisible();
-            if (ImGui::Checkbox("Show Helm", &helmVis)) {
-                gameHandler.toggleHelm();
-            }
-            ImGui::SameLine();
-            if (ImGui::Checkbox("Show Cloak", &cloakVis)) {
-                gameHandler.toggleCloak();
-            }
             ImGui::EndTabItem();
         }
 
         if (ImGui::BeginTabItem("Stats")) {
             ImGui::Spacing();
-            int32_t stats[5];
-            for (int i = 0; i < 5; ++i) stats[i] = gameHandler.getPlayerStat(i);
-            const int32_t* serverStats = (stats[0] >= 0) ? stats : nullptr;
-            int32_t resists[6];
-            for (int i = 0; i < 6; ++i) resists[i] = gameHandler.getResistance(i + 1);
-            renderStatsPanel(inventory, gameHandler.getPlayerLevel(), gameHandler.getArmorRating(), serverStats, resists, &gameHandler);
-
-            // Played time (shown if available, fetched on character screen open)
-            uint32_t totalSec = gameHandler.getTotalTimePlayed();
-            uint32_t levelSec = gameHandler.getLevelTimePlayed();
-            if (totalSec > 0 || levelSec > 0) {
-                ImGui::Separator();
-                // Helper lambda to format seconds as "Xd Xh Xm"
-                auto fmtTime = [](uint32_t sec) -> std::string {
-                    uint32_t d = sec / 86400, h = (sec % 86400) / 3600, m = (sec % 3600) / 60;
-                    char buf[48];
-                    if (d > 0) snprintf(buf, sizeof(buf), "%ud %uh %um", d, h, m);
-                    else if (h > 0) snprintf(buf, sizeof(buf), "%uh %um", h, m);
-                    else snprintf(buf, sizeof(buf), "%um", m);
-                    return buf;
-                };
-                ImGui::TextDisabled("Time Played");
-                ImGui::Columns(2, "##playtime", false);
-                ImGui::SetColumnWidth(0, 130);
-                ImGui::Text("Total:");    ImGui::NextColumn();
-                ImGui::Text("%s", fmtTime(totalSec).c_str()); ImGui::NextColumn();
-                ImGui::Text("This level:"); ImGui::NextColumn();
-                ImGui::Text("%s", fmtTime(levelSec).c_str()); ImGui::NextColumn();
-                ImGui::Columns(1);
-            }
-
-            // PvP Currency (TBC/WotLK only)
-            uint32_t honor = gameHandler.getHonorPoints();
-            uint32_t arena = gameHandler.getArenaPoints();
-            if (honor > 0 || arena > 0) {
-                ImGui::Separator();
-                ImGui::TextDisabled("PvP Currency");
-                ImGui::Columns(2, "##pvpcurrency", false);
-                ImGui::SetColumnWidth(0, 130);
-                ImGui::Text("Honor Points:"); ImGui::NextColumn();
-                ImGui::TextColored(ImVec4(0.9f, 0.75f, 0.2f, 1.0f), "%u", honor); ImGui::NextColumn();
-                ImGui::Text("Arena Points:"); ImGui::NextColumn();
-                ImGui::TextColored(ImVec4(0.9f, 0.75f, 0.2f, 1.0f), "%u", arena); ImGui::NextColumn();
-                ImGui::Columns(1);
-            }
-
+            renderStatsPanel(inventory, gameHandler.getPlayerLevel(), gameHandler.getArmorRating());
             ImGui::EndTabItem();
         }
 
@@ -1349,7 +1105,7 @@ void InventoryScreen::renderCharacterScreen(game::GameHandler& gameHandler) {
                     const char* label;
                     uint32_t categoryId;
                 };
-                static constexpr CategoryGroup groups[] = {
+                static const CategoryGroup groups[] = {
                     { "Weapon Skills", 6 },
                     { "Armor Skills", 8 },
                     { "Secondary Skills", 10 },
@@ -1387,35 +1143,18 @@ void InventoryScreen::renderCharacterScreen(game::GameHandler& gameHandler) {
                                 snprintf(label, sizeof(label), "%s", name.c_str());
                             }
 
-                            // Effective value includes temporary and permanent bonuses
-                            uint16_t effective = skill->effectiveValue();
-                            uint16_t bonus = skill->bonusTemp + skill->bonusPerm;
-
-                            // Progress bar reflects effective / max; cap visual fill at 1.0
+                            // Show progress bar with value/max overlay
                             float ratio = (skill->maxValue > 0)
-                                ? std::min(1.0f, static_cast<float>(effective) / static_cast<float>(skill->maxValue))
+                                ? static_cast<float>(skill->value) / static_cast<float>(skill->maxValue)
                                 : 0.0f;
 
                             char overlay[64];
-                            if (bonus > 0)
-                                snprintf(overlay, sizeof(overlay), "%u / %u (+%u)", effective, skill->maxValue, bonus);
-                            else
-                                snprintf(overlay, sizeof(overlay), "%u / %u", effective, skill->maxValue);
+                            snprintf(overlay, sizeof(overlay), "%u / %u", skill->value, skill->maxValue);
 
-                            // Gold name when maxed out, cyan when buffed above base, default otherwise
-                            bool isMaxed  = (effective >= skill->maxValue && skill->maxValue > 0);
-                            bool isBuffed = (bonus > 0);
-                            ImVec4 nameColor = isMaxed  ? ui::colors::kTooltipGold
-                                             : isBuffed ? ImVec4(0.4f, 0.9f,  1.0f, 1.0f)
-                                             :            ui::colors::kVeryLightGray;
-                            ImGui::TextColored(nameColor, "%s", label);
+                            ImGui::Text("%s", label);
                             ImGui::SameLine(180.0f);
                             ImGui::SetNextItemWidth(-1.0f);
-                            // Bar color: gold when maxed, green otherwise
-                            ImVec4 barColor = isMaxed ? ui::colors::kTooltipGold : ui::colors::kFriendlyGreen;
-                            ImGui::PushStyleColor(ImGuiCol_PlotHistogram, barColor);
                             ImGui::ProgressBar(ratio, ImVec2(0, 14.0f), overlay);
-                            ImGui::PopStyleColor();
                         }
                     }
                 }
@@ -1425,135 +1164,6 @@ void InventoryScreen::renderCharacterScreen(game::GameHandler& gameHandler) {
             ImGui::EndTabItem();
         }
 
-        if (ImGui::BeginTabItem("Achievements")) {
-            const auto& earned = gameHandler.getEarnedAchievements();
-            if (earned.empty()) {
-                ImGui::Spacing();
-                ImGui::TextDisabled("No achievements earned yet.");
-            } else {
-                static char achieveFilter[128] = {};
-                ImGui::SetNextItemWidth(-1.0f);
-                ImGui::InputTextWithHint("##achsearch", "Search achievements...",
-                                         achieveFilter, sizeof(achieveFilter));
-                ImGui::Separator();
-
-                char filterLower[128];
-                for (size_t i = 0; i < sizeof(achieveFilter); ++i)
-                    filterLower[i] = static_cast<char>(tolower(static_cast<unsigned char>(achieveFilter[i])));
-
-                ImGui::BeginChild("##AchList", ImVec2(0, 0), false);
-                // Sort by ID for stable ordering
-                std::vector<uint32_t> sortedIds(earned.begin(), earned.end());
-                std::sort(sortedIds.begin(), sortedIds.end());
-                int shown = 0;
-                for (uint32_t id : sortedIds) {
-                    const std::string& name = gameHandler.getAchievementName(id);
-                    const char* displayName = name.empty() ? nullptr : name.c_str();
-                    if (displayName == nullptr) continue;  // skip unknown achievements
-
-                    // Apply filter
-                    if (filterLower[0] != '\0') {
-                        // simple case-insensitive substring match
-                        std::string lower;
-                        lower.reserve(name.size());
-                        for (char c : name) lower += static_cast<char>(tolower(static_cast<unsigned char>(c)));
-                        if (lower.find(filterLower) == std::string::npos) continue;
-                    }
-
-                    ImGui::PushID(static_cast<int>(id));
-                    ImGui::TextColored(ui::colors::kWarmGold, "[Achievement]");
-                    ImGui::SameLine();
-                    ImGui::Text("%s", displayName);
-                    ImGui::PopID();
-                    ++shown;
-                }
-                if (shown == 0 && filterLower[0] != '\0') {
-                    ImGui::TextDisabled("No achievements match the filter.");
-                }
-                ImGui::Text("Total: %d", static_cast<int>(earned.size()));
-                ImGui::EndChild();
-            }
-            ImGui::EndTabItem();
-        }
-
-        if (ImGui::BeginTabItem("PvP")) {
-            const auto& arenaStats = gameHandler.getArenaTeamStats();
-            if (arenaStats.empty()) {
-                ImGui::Spacing();
-                ImGui::TextDisabled("Not a member of any Arena team.");
-            } else {
-                for (const auto& team : arenaStats) {
-                    ImGui::PushID(static_cast<int>(team.teamId));
-                    char header[64];
-                    snprintf(header, sizeof(header), "Team ID %u  (Rating: %u)", team.teamId, team.rating);
-                    if (ImGui::CollapsingHeader(header, ImGuiTreeNodeFlags_DefaultOpen)) {
-                        ImGui::Columns(2, "##arenacols", false);
-                        ImGui::Text("Rating:");     ImGui::NextColumn();
-                        ImGui::Text("%u", team.rating);    ImGui::NextColumn();
-                        ImGui::Text("Rank:");       ImGui::NextColumn();
-                        ImGui::Text("#%u", team.rank);     ImGui::NextColumn();
-                        ImGui::Text("This week:");  ImGui::NextColumn();
-                        ImGui::Text("%u / %u (W/G)", team.weekWins, team.weekGames); ImGui::NextColumn();
-                        ImGui::Text("Season:");     ImGui::NextColumn();
-                        ImGui::Text("%u / %u (W/G)", team.seasonWins, team.seasonGames); ImGui::NextColumn();
-                        ImGui::Columns(1);
-                    }
-                    ImGui::PopID();
-                }
-            }
-            ImGui::EndTabItem();
-        }
-
-        // Equipment Sets tab (WotLK only — requires server support)
-        if (gameHandler.supportsEquipmentSets() && ImGui::BeginTabItem("Outfits")) {
-            ImGui::Spacing();
-
-            // Save current gear as new set
-            static char newSetName[64] = {};
-            ImGui::SetNextItemWidth(160.0f);
-            ImGui::InputTextWithHint("##newsetname", "New set name...", newSetName, sizeof(newSetName));
-            ImGui::SameLine();
-            bool canSave = (newSetName[0] != '\0');
-            if (!canSave) ImGui::BeginDisabled();
-            if (ImGui::SmallButton("Save Current Gear")) {
-                gameHandler.saveEquipmentSet(newSetName);
-                newSetName[0] = '\0';
-            }
-            if (!canSave) ImGui::EndDisabled();
-
-            ImGui::Separator();
-
-            const auto& eqSets = gameHandler.getEquipmentSets();
-            if (eqSets.empty()) {
-                ImGui::TextDisabled("No saved equipment sets.");
-            } else {
-                ImGui::BeginChild("##EqSetsList", ImVec2(0, 0), false);
-                for (const auto& es : eqSets) {
-                    ImGui::PushID(static_cast<int>(es.setId));
-                    const char* displayName = es.name.empty() ? "(Unnamed)" : es.name.c_str();
-                    ImGui::Text("%s", displayName);
-                    float btnAreaW = 150.0f;
-                    ImGui::SameLine(ImGui::GetContentRegionAvail().x - btnAreaW + ImGui::GetCursorPosX());
-                    if (ImGui::SmallButton("Equip")) {
-                        gameHandler.useEquipmentSet(es.setId);
-                    }
-                    ImGui::SameLine();
-                    if (ImGui::SmallButton("Update")) {
-                        gameHandler.saveEquipmentSet(es.name, es.iconName, es.setGuid, es.setId);
-                    }
-                    ImGui::SameLine();
-                    if (ImGui::SmallButton("Delete")) {
-                        gameHandler.deleteEquipmentSet(es.setGuid);
-                        ImGui::PopID();
-                        break;  // Iterator invalidated
-                    }
-                    ImGui::PopID();
-                }
-                ImGui::EndChild();
-            }
-            ImGui::EndTabItem();
-        }
-
         ImGui::EndTabBar();
     }
 
@@ -1583,20 +1193,19 @@ void InventoryScreen::renderReputationPanel(game::GameHandler& gameHandler) {
         int32_t     ceiling; // raw value where the next tier begins
         ImVec4      color;
     };
-    static constexpr RepTier tiers[] = {
+    static const RepTier tiers[] = {
         { "Hated",       -42000, -6001, ImVec4(0.6f, 0.1f, 0.1f, 1.0f) },
         { "Hostile",      -6000, -3001, ImVec4(0.8f, 0.2f, 0.1f, 1.0f) },
         { "Unfriendly",   -3000,    -1, ImVec4(0.9f, 0.5f, 0.1f, 1.0f) },
         { "Neutral",          0,  2999, ImVec4(0.8f, 0.8f, 0.2f, 1.0f) },
-        { "Friendly",      3000,  8999, ui::colors::kFriendlyGreen },
+        { "Friendly",      3000,  8999, ImVec4(0.2f, 0.7f, 0.2f, 1.0f) },
         { "Honored",       9000, 20999, ImVec4(0.2f, 0.8f, 0.5f, 1.0f) },
         { "Revered",      21000, 41999, ImVec4(0.3f, 0.6f, 1.0f, 1.0f) },
-        { "Exalted",      42000, 42000, ui::colors::kWarmGold },
+        { "Exalted",      42000, 42000, ImVec4(1.0f, 0.84f, 0.0f, 1.0f) },
     };
 
-    constexpr int kNumTiers = static_cast<int>(sizeof(tiers) / sizeof(tiers[0]));
     auto getTier = [&](int32_t val) -> const RepTier& {
-        for (int i = kNumTiers - 1; i >= 0; --i) {
+        for (int i = 6; i >= 0; --i) {
             if (val >= tiers[i].floor) return tiers[i];
         }
         return tiers[0];
@@ -1604,13 +1213,10 @@ void InventoryScreen::renderReputationPanel(game::GameHandler& gameHandler) {
 
     ImGui::BeginChild("##ReputationList", ImVec2(0, 0), true);
 
-    // Sort: watched faction first, then alphabetically by name
-    uint32_t watchedFactionId = gameHandler.getWatchedFactionId();
+    // Sort factions alphabetically by name
     std::vector<std::pair<uint32_t, int32_t>> sortedFactions(standings.begin(), standings.end());
     std::sort(sortedFactions.begin(), sortedFactions.end(),
         [&](const auto& a, const auto& b) {
-            if (a.first == watchedFactionId) return true;
-            if (b.first == watchedFactionId) return false;
             const std::string& na = gameHandler.getFactionNamePublic(a.first);
             const std::string& nb = gameHandler.getFactionNamePublic(b.first);
             return na < nb;
@@ -1622,27 +1228,10 @@ void InventoryScreen::renderReputationPanel(game::GameHandler& gameHandler) {
         const std::string& factionName = gameHandler.getFactionNamePublic(factionId);
         const char* displayName = factionName.empty() ? "Unknown Faction" : factionName.c_str();
 
-        // Determine at-war status via repListId lookup
-        uint32_t repListId = gameHandler.getRepListIdByFactionId(factionId);
-        bool atWar = (repListId != 0xFFFFFFFFu) && gameHandler.isFactionAtWar(repListId);
-        bool isWatched = (factionId == watchedFactionId);
-
-        ImGui::PushID(static_cast<int>(factionId));
-
-        // Faction name + tier label on same line; mark at-war and watched factions
+        // Faction name + tier label on same line
         ImGui::TextColored(tier.color, "[%s]", tier.name);
         ImGui::SameLine(90.0f);
-        if (atWar) {
-            ImGui::TextColored(ui::colors::kRed, "%s", displayName);
-            ImGui::SameLine();
-            ImGui::TextColored(ui::colors::kRed, "(At War)");
-        } else if (isWatched) {
-            ImGui::TextColored(ImVec4(1.0f, 0.9f, 0.5f, 1.0f), "%s", displayName);
-            ImGui::SameLine();
-            ImGui::TextDisabled("(Tracked)");
-        } else {
-            ImGui::Text("%s", displayName);
-        }
+        ImGui::Text("%s", displayName);
 
         // Progress bar showing position within current tier
         float ratio = 0.0f;
@@ -1664,39 +1253,23 @@ void InventoryScreen::renderReputationPanel(game::GameHandler& gameHandler) {
         ImGui::SetNextItemWidth(-1.0f);
         ImGui::ProgressBar(ratio, ImVec2(0, 12.0f), overlay);
         ImGui::PopStyleColor();
-
-        // Right-click context menu on the progress bar
-        if (ImGui::BeginPopupContextItem("##RepCtx")) {
-            ImGui::TextDisabled("%s", displayName);
-            ImGui::Separator();
-            if (isWatched) {
-                if (ImGui::MenuItem("Untrack"))
-                    gameHandler.setWatchedFactionId(0);
-            } else {
-                if (ImGui::MenuItem("Track on Rep Bar"))
-                    gameHandler.setWatchedFactionId(factionId);
-            }
-            ImGui::EndPopup();
-        }
-
         ImGui::Spacing();
-        ImGui::PopID();
     }
 
     ImGui::EndChild();
 }
 
 void InventoryScreen::renderEquipmentPanel(game::Inventory& inventory) {
-    ImGui::TextColored(ui::colors::kWarmGold, "Equipment");
+    ImGui::TextColored(ImVec4(1.0f, 0.84f, 0.0f, 1.0f), "Equipment");
     ImGui::Separator();
 
-    static constexpr game::EquipSlot leftSlots[] = {
+    static const game::EquipSlot leftSlots[] = {
         game::EquipSlot::HEAD, game::EquipSlot::NECK,
         game::EquipSlot::SHOULDERS, game::EquipSlot::BACK,
         game::EquipSlot::CHEST, game::EquipSlot::SHIRT,
         game::EquipSlot::TABARD, game::EquipSlot::WRISTS,
     };
-    static constexpr game::EquipSlot rightSlots[] = {
+    static const game::EquipSlot rightSlots[] = {
         game::EquipSlot::HANDS, game::EquipSlot::WAIST,
         game::EquipSlot::LEGS, game::EquipSlot::FEET,
         game::EquipSlot::RING1, game::EquipSlot::RING2,
@@ -1777,18 +1350,15 @@ void InventoryScreen::renderEquipmentPanel(game::Inventory& inventory) {
         }
     }
 
-    // Weapon row - positioned to the right of left column to avoid crowding main equipment
+    // Weapon row
     ImGui::Spacing();
     ImGui::Separator();
 
-    static constexpr game::EquipSlot weaponSlots[] = {
+    static const game::EquipSlot weaponSlots[] = {
         game::EquipSlot::MAIN_HAND,
         game::EquipSlot::OFF_HAND,
         game::EquipSlot::RANGED,
     };
-
-    // Position weapons in center column area (after left column, 3D preview renders on top)
-    ImGui::SetCursorPosX(contentStartX + slotSize + 8.0f);
     for (int i = 0; i < 3; i++) {
         if (i > 0) ImGui::SameLine();
         const auto& slot = inventory.getEquipSlot(weaponSlots[i]);
@@ -1806,46 +1376,18 @@ void InventoryScreen::renderEquipmentPanel(game::Inventory& inventory) {
 // Stats Panel
 // ============================================================
 
-void InventoryScreen::renderStatsPanel(game::Inventory& inventory, uint32_t playerLevel,
-                                        int32_t serverArmor, const int32_t* serverStats,
-                                        const int32_t* serverResists,
-                                        const game::GameHandler* gh) {
-    // Sum equipment stats for item-query bonus display
-    int32_t itemStr = 0, itemAgi = 0, itemSta = 0, itemInt = 0, itemSpi = 0;
-    // Secondary stat sums from extraStats
-    int32_t itemAP = 0, itemSP = 0, itemHit = 0, itemCrit = 0, itemHaste = 0;
-    int32_t itemResil = 0, itemExpertise = 0, itemMp5 = 0, itemHp5 = 0;
-    int32_t itemDefense = 0, itemDodge = 0, itemParry = 0, itemBlock = 0, itemBlockVal = 0;
-    int32_t itemArmorPen = 0, itemSpellPen = 0;
+void InventoryScreen::renderStatsPanel(game::Inventory& inventory, uint32_t playerLevel, int32_t serverArmor) {
+    // Sum equipment stats
+    int32_t totalStr = 0, totalAgi = 0, totalSta = 0, totalInt = 0, totalSpi = 0;
+
     for (int s = 0; s < game::Inventory::NUM_EQUIP_SLOTS; s++) {
         const auto& slot = inventory.getEquipSlot(static_cast<game::EquipSlot>(s));
         if (slot.empty()) continue;
-        itemStr += slot.item.strength;
-        itemAgi += slot.item.agility;
-        itemSta += slot.item.stamina;
-        itemInt += slot.item.intellect;
-        itemSpi += slot.item.spirit;
-        for (const auto& es : slot.item.extraStats) {
-            switch (es.statType) {
-                case 12:                             itemDefense  += es.statValue; break;
-                case 13:                             itemDodge    += es.statValue; break;
-                case 14:                             itemParry    += es.statValue; break;
-                case 15:                             itemBlock    += es.statValue; break;
-                case 16: case 17: case 18: case 31: itemHit      += es.statValue; break;
-                case 19: case 20: case 21: case 32: itemCrit     += es.statValue; break;
-                case 28: case 29: case 30: case 36: itemHaste    += es.statValue; break;
-                case 35:                             itemResil    += es.statValue; break;
-                case 37:                             itemExpertise += es.statValue; break;
-                case 38: case 39:                    itemAP       += es.statValue; break;
-                case 41: case 42: case 45:           itemSP       += es.statValue; break;
-                case 43:                             itemMp5      += es.statValue; break;
-                case 44:                             itemArmorPen += es.statValue; break;
-                case 46:                             itemHp5      += es.statValue; break;
-                case 47:                             itemSpellPen += es.statValue; break;
-                case 48:                             itemBlockVal += es.statValue; break;
-                default: break;
-            }
-        }
+        totalStr += slot.item.strength;
+        totalAgi += slot.item.agility;
+        totalSta += slot.item.stamina;
+        totalInt += slot.item.intellect;
+        totalSpi += slot.item.spirit;
     }
 
     // Use server-authoritative armor from UNIT_FIELD_RESISTANCES when available.
@@ -1857,332 +1399,42 @@ void InventoryScreen::renderStatsPanel(game::Inventory& inventory, uint32_t play
     }
     int32_t totalArmor = (serverArmor > 0) ? serverArmor : itemQueryArmor;
 
-    // Average item level (exclude shirt/tabard as WoW convention)
-    {
-        uint32_t iLvlSum = 0;
-        int iLvlCount = 0;
-        for (int s = 0; s < game::Inventory::NUM_EQUIP_SLOTS; s++) {
-            auto eslot = static_cast<game::EquipSlot>(s);
-            if (eslot == game::EquipSlot::SHIRT || eslot == game::EquipSlot::TABARD) continue;
-            const auto& slot = inventory.getEquipSlot(eslot);
-            if (!slot.empty() && slot.item.itemLevel > 0) {
-                iLvlSum += slot.item.itemLevel;
-                ++iLvlCount;
-            }
-        }
-        if (iLvlCount > 0) {
-            float avg = static_cast<float>(iLvlSum) / static_cast<float>(iLvlCount);
-            ImGui::TextColored(ImVec4(0.7f, 0.9f, 1.0f, 1.0f),
-                "Average Item Level: %.1f  (%d/%d slots)", avg, iLvlCount,
-                game::Inventory::NUM_EQUIP_SLOTS - 2);  // -2 for shirt/tabard
-        }
-        ImGui::Separator();
-    }
+    // Base stats: 20 + level
+    int32_t baseStat = 20 + static_cast<int32_t>(playerLevel);
 
     ImVec4 green(0.0f, 1.0f, 0.0f, 1.0f);
     ImVec4 white(1.0f, 1.0f, 1.0f, 1.0f);
     ImVec4 gold(1.0f, 0.84f, 0.0f, 1.0f);
     ImVec4 gray(0.6f, 0.6f, 0.6f, 1.0f);
 
-    static constexpr const char* kStatTooltips[5] = {
-        "Increases your melee attack power by 2.\nIncreases your block value.",
-        "Increases your Armor.\nIncreases ranged attack power by 2.\nIncreases your chance to dodge attacks and score critical strikes.",
-        "Increases Health by 10 per point.",
-        "Increases your Mana pool.\nIncreases your chance to score a critical strike with spells.",
-        "Increases Health and Mana regeneration."
-    };
-
     // Armor (no base)
-    ImGui::BeginGroup();
     if (totalArmor > 0) {
         ImGui::TextColored(gold, "Armor: %d", totalArmor);
     } else {
         ImGui::TextColored(gray, "Armor: 0");
     }
-    ImGui::EndGroup();
-    if (ImGui::IsItemHovered()) {
-        ImGui::BeginTooltip();
-        ImGui::TextWrapped("Reduces damage taken from physical attacks.");
-        ImGui::EndTooltip();
-    }
 
-    if (serverStats) {
-        // Server-authoritative stats from UNIT_FIELD_STAT0-4: show total and item bonus.
-        // serverStats[i] is the server's effective base stat (items included, buffs excluded).
-        const char* statNames[5] = {"Strength", "Agility", "Stamina", "Intellect", "Spirit"};
-        const int32_t itemBonuses[5] = {itemStr, itemAgi, itemSta, itemInt, itemSpi};
-        for (int i = 0; i < 5; ++i) {
-            int32_t total = serverStats[i];
-            int32_t bonus = itemBonuses[i];
-            ImGui::BeginGroup();
-            if (bonus > 0) {
-                ImGui::TextColored(white, "%s: %d", statNames[i], total);
-                ImGui::SameLine();
-                ImGui::TextColored(green, "(+%d)", bonus);
-            } else {
-                ImGui::TextColored(gray, "%s: %d", statNames[i], total);
-            }
-            ImGui::EndGroup();
-            if (ImGui::IsItemHovered()) {
-                ImGui::BeginTooltip();
-                ImGui::TextWrapped("%s", kStatTooltips[i]);
-                ImGui::EndTooltip();
-            }
+    // Helper to render a stat line
+    auto renderStat = [&](const char* name, int32_t equipBonus) {
+        int32_t total = baseStat + equipBonus;
+        if (equipBonus > 0) {
+            ImGui::TextColored(white, "%s: %d", name, total);
+            ImGui::SameLine();
+            ImGui::TextColored(green, "(+%d)", equipBonus);
+        } else {
+            ImGui::TextColored(gray, "%s: %d", name, total);
         }
-    } else {
-        // Fallback: estimated base (20 + level) plus item query bonuses.
-        int32_t baseStat = 20 + static_cast<int32_t>(playerLevel);
-        auto renderStat = [&](const char* name, int32_t equipBonus, const char* tooltip) {
-            int32_t total = baseStat + equipBonus;
-            ImGui::BeginGroup();
-            if (equipBonus > 0) {
-                ImGui::TextColored(white, "%s: %d", name, total);
-                ImGui::SameLine();
-                ImGui::TextColored(green, "(+%d)", equipBonus);
-            } else {
-                ImGui::TextColored(gray, "%s: %d", name, total);
-            }
-            ImGui::EndGroup();
-            if (ImGui::IsItemHovered()) {
-                ImGui::BeginTooltip();
-                ImGui::TextWrapped("%s", tooltip);
-                ImGui::EndTooltip();
-            }
-        };
-        renderStat("Strength",  itemStr, kStatTooltips[0]);
-        renderStat("Agility",   itemAgi, kStatTooltips[1]);
-        renderStat("Stamina",   itemSta, kStatTooltips[2]);
-        renderStat("Intellect", itemInt, kStatTooltips[3]);
-        renderStat("Spirit",    itemSpi, kStatTooltips[4]);
-    }
+    };
 
-    // Secondary stats from equipped items
-    bool hasSecondary = itemAP || itemSP || itemHit || itemCrit || itemHaste ||
-                        itemResil || itemExpertise || itemMp5 || itemHp5 ||
-                        itemDefense || itemDodge || itemParry || itemBlock || itemBlockVal ||
-                        itemArmorPen || itemSpellPen;
-    if (hasSecondary) {
-        ImGui::Spacing();
-        ImGui::Separator();
-        auto renderSecondary = [&](const char* name, int32_t val, const char* tooltip) {
-            if (val > 0) {
-                ImGui::BeginGroup();
-                ImGui::TextColored(green, "+%d %s", val, name);
-                ImGui::EndGroup();
-                if (ImGui::IsItemHovered()) {
-                    ImGui::BeginTooltip();
-                    ImGui::TextWrapped("%s", tooltip);
-                    ImGui::EndTooltip();
-                }
-            }
-        };
-        renderSecondary("Attack Power",     itemAP,       "Increases the damage of your melee and ranged attacks.");
-        renderSecondary("Spell Power",      itemSP,       "Increases the damage and healing of your spells.");
-        renderSecondary("Hit Rating",       itemHit,      "Reduces the chance your attacks will miss.");
-        renderSecondary("Crit Rating",      itemCrit,     "Increases your critical strike chance.");
-        renderSecondary("Haste Rating",     itemHaste,    "Increases attack speed and spell casting speed.");
-        renderSecondary("Resilience",       itemResil,    "Reduces the chance you will be critically hit.\nReduces damage taken from critical hits.");
-        renderSecondary("Expertise",        itemExpertise,"Reduces the chance your attacks will be dodged or parried.");
-        renderSecondary("Defense Rating",   itemDefense,  "Reduces the chance enemies will critically hit you.");
-        renderSecondary("Dodge Rating",     itemDodge,    "Increases your chance to dodge attacks.");
-        renderSecondary("Parry Rating",     itemParry,    "Increases your chance to parry attacks.");
-        renderSecondary("Block Rating",     itemBlock,    "Increases your chance to block attacks with your shield.");
-        renderSecondary("Block Value",      itemBlockVal, "Increases the amount of damage your shield blocks.");
-        renderSecondary("Armor Penetration",itemArmorPen, "Reduces the armor of your target.");
-        renderSecondary("Spell Penetration",itemSpellPen, "Reduces your target's resistance to your spells.");
-        renderSecondary("Mana per 5 sec",   itemMp5,      "Restores mana every 5 seconds, even while casting.");
-        renderSecondary("Health per 5 sec", itemHp5,      "Restores health every 5 seconds.");
-    }
-
-    // Elemental resistances from server update fields
-    if (serverResists) {
-        bool hasResist = false;
-        for (int i = 0; i < 6; ++i) {
-            if (serverResists[i] > 0) { hasResist = true; break; }
-        }
-        if (hasResist) {
-            ImGui::Spacing();
-            ImGui::Separator();
-            for (int i = 0; i < 6; ++i) {
-                if (serverResists[i] > 0) {
-                    ImGui::TextColored(ImVec4(0.7f, 0.85f, 1.0f, 1.0f),
-                        "%s: %d", kResistNames[i], serverResists[i]);
-                }
-            }
-        }
-    }
-
-    // Server-authoritative combat stats (WotLK update fields — only shown when received)
-    if (gh) {
-        int32_t meleeAP   = gh->getMeleeAttackPower();
-        int32_t rangedAP  = gh->getRangedAttackPower();
-        int32_t spellPow  = gh->getSpellPower();
-        int32_t healPow   = gh->getHealingPower();
-        float dodgePct    = gh->getDodgePct();
-        float parryPct   = gh->getParryPct();
-        float blockPct   = gh->getBlockPct();
-        float critPct    = gh->getCritPct();
-        float rCritPct   = gh->getRangedCritPct();
-        float sCritPct   = gh->getSpellCritPct(1);  // Holy school (avg proxy for spell crit)
-        // Hit rating: CR_HIT_MELEE=5, CR_HIT_RANGED=6, CR_HIT_SPELL=7
-        // Haste rating: CR_HASTE_MELEE=17, CR_HASTE_RANGED=18, CR_HASTE_SPELL=19
-        // Other: CR_EXPERTISE=23, CR_ARMOR_PENETRATION=24, CR_CRIT_TAKEN_MELEE=14
-        int32_t hitRating     = gh->getCombatRating(5);
-        int32_t hitRangedR    = gh->getCombatRating(6);
-        int32_t hitSpellR     = gh->getCombatRating(7);
-        int32_t expertiseR    = gh->getCombatRating(23);
-        int32_t hasteR        = gh->getCombatRating(17);
-        int32_t hasteRangedR  = gh->getCombatRating(18);
-        int32_t hasteSpellR   = gh->getCombatRating(19);
-        int32_t armorPenR     = gh->getCombatRating(24);
-        int32_t resilR        = gh->getCombatRating(14);  // CR_CRIT_TAKEN_MELEE = Resilience
-
-        bool hasAny = (meleeAP >= 0 || spellPow >= 0 || dodgePct >= 0.0f || parryPct >= 0.0f ||
-                       blockPct >= 0.0f || critPct >= 0.0f || hitRating >= 0);
-        if (hasAny) {
-            ImGui::Spacing();
-            ImGui::Separator();
-            ImGui::TextColored(ui::colors::kWarmGold, "Combat");
-            ImVec4 cyan(0.5f, 0.9f, 1.0f, 1.0f);
-            if (meleeAP  >= 0) ImGui::TextColored(cyan, "Attack Power: %d", meleeAP);
-            if (rangedAP >= 0 && rangedAP != meleeAP)
-                ImGui::TextColored(cyan, "Ranged Attack Power: %d", rangedAP);
-            if (spellPow  >= 0) ImGui::TextColored(cyan, "Spell Power: %d", spellPow);
-            if (healPow   >= 0 && healPow != spellPow)
-                ImGui::TextColored(cyan, "Healing Power: %d", healPow);
-            if (dodgePct  >= 0.0f) ImGui::TextColored(cyan, "Dodge: %.2f%%", dodgePct);
-            if (parryPct  >= 0.0f) ImGui::TextColored(cyan, "Parry: %.2f%%", parryPct);
-            if (blockPct  >= 0.0f) ImGui::TextColored(cyan, "Block: %.2f%%", blockPct);
-            if (critPct   >= 0.0f) ImGui::TextColored(cyan, "Melee Crit: %.2f%%", critPct);
-            if (rCritPct  >= 0.0f) ImGui::TextColored(cyan, "Ranged Crit: %.2f%%", rCritPct);
-            if (sCritPct  >= 0.0f) ImGui::TextColored(cyan, "Spell Crit: %.2f%%", sCritPct);
-
-            // Combat ratings with percentage conversion (WotLK level-80 divisors scaled by level).
-            // Formula: pct = rating / (divisorAt80 * pow(level/80.0, 0.93))
-            // Level-80 divisors derived from gtCombatRatings.dbc (well-known WotLK constants):
-            //   Hit: 26.23,  Expertise: 8.19/expertise (0.25% each),
-            //   Haste: 32.79,  ArmorPen: 13.99,  Resilience: 94.27
-            uint32_t level = playerLevel > 0 ? playerLevel : gh->getPlayerLevel();
-            if (level == 0) level = 80;
-            double lvlScale = level <= 80
-                ? std::pow(static_cast<double>(level) / 80.0, 0.93)
-                : 1.0;
-
-            auto ratingPct = [&](int32_t rating, double divisorAt80) -> float {
-                if (rating < 0 || divisorAt80 <= 0.0) return -1.0f;
-                double d = divisorAt80 * lvlScale;
-                return static_cast<float>(rating / d);
-            };
-
-            if (hitRating >= 0) {
-                float pct = ratingPct(hitRating, 26.23);
-                if (pct >= 0.0f)
-                    ImGui::TextColored(cyan, "Hit Rating: %d (%.2f%%)", hitRating, pct);
-                else
-                    ImGui::TextColored(cyan, "Hit Rating: %d", hitRating);
-            }
-            // Show ranged/spell hit only when they differ from melee hit
-            if (hitRangedR >= 0 && hitRangedR != hitRating) {
-                float pct = ratingPct(hitRangedR, 26.23);
-                if (pct >= 0.0f)
-                    ImGui::TextColored(cyan, "Ranged Hit Rating: %d (%.2f%%)", hitRangedR, pct);
-                else
-                    ImGui::TextColored(cyan, "Ranged Hit Rating: %d", hitRangedR);
-            }
-            if (hitSpellR >= 0 && hitSpellR != hitRating) {
-                // Spell hit cap at 17% (446 rating at 80); divisor same as melee hit
-                float pct = ratingPct(hitSpellR, 26.23);
-                if (pct >= 0.0f)
-                    ImGui::TextColored(cyan, "Spell Hit Rating: %d (%.2f%%)", hitSpellR, pct);
-                else
-                    ImGui::TextColored(cyan, "Spell Hit Rating: %d", hitSpellR);
-            }
-            if (expertiseR >= 0) {
-                // Each expertise point reduces dodge and parry chance by 0.25%
-                // expertise_points = rating / 8.19
-                float exp_pts = ratingPct(expertiseR, 8.19);
-                if (exp_pts >= 0.0f) {
-                    float exp_pct = exp_pts * 0.25f;  // % dodge/parry reduction
-                    ImGui::TextColored(cyan, "Expertise: %d (%.1f / %.2f%%)",
-                                       expertiseR, exp_pts, exp_pct);
-                } else {
-                    ImGui::TextColored(cyan, "Expertise Rating: %d", expertiseR);
-                }
-            }
-            if (hasteR >= 0) {
-                float pct = ratingPct(hasteR, 32.79);
-                if (pct >= 0.0f)
-                    ImGui::TextColored(cyan, "Haste Rating: %d (%.2f%%)", hasteR, pct);
-                else
-                    ImGui::TextColored(cyan, "Haste Rating: %d", hasteR);
-            }
-            if (hasteRangedR >= 0 && hasteRangedR != hasteR) {
-                float pct = ratingPct(hasteRangedR, 32.79);
-                if (pct >= 0.0f)
-                    ImGui::TextColored(cyan, "Ranged Haste Rating: %d (%.2f%%)", hasteRangedR, pct);
-                else
-                    ImGui::TextColored(cyan, "Ranged Haste Rating: %d", hasteRangedR);
-            }
-            if (hasteSpellR >= 0 && hasteSpellR != hasteR) {
-                float pct = ratingPct(hasteSpellR, 32.79);
-                if (pct >= 0.0f)
-                    ImGui::TextColored(cyan, "Spell Haste Rating: %d (%.2f%%)", hasteSpellR, pct);
-                else
-                    ImGui::TextColored(cyan, "Spell Haste Rating: %d", hasteSpellR);
-            }
-            if (armorPenR >= 0) {
-                float pct = ratingPct(armorPenR, 13.99);
-                if (pct >= 0.0f)
-                    ImGui::TextColored(cyan, "Armor Pen: %d (%.2f%%)", armorPenR, pct);
-                else
-                    ImGui::TextColored(cyan, "Armor Penetration: %d", armorPenR);
-            }
-            if (resilR >= 0) {
-                // Resilience: reduces crit chance against you by pct%, and crit damage by 2*pct%
-                float pct = ratingPct(resilR, 94.27);
-                if (pct >= 0.0f)
-                    ImGui::TextColored(cyan, "Resilience: %d (%.2f%%)", resilR, pct);
-                else
-                    ImGui::TextColored(cyan, "Resilience: %d", resilR);
-            }
-        }
-
-        // Movement speeds (always show when non-default)
-        {
-            constexpr float kBaseRun    = 7.0f;
-            constexpr float kBaseFlight = 7.0f;
-            float runSpeed    = gh->getServerRunSpeed();
-            float flightSpeed = gh->getServerFlightSpeed();
-            float swimSpeed   = gh->getServerSwimSpeed();
-
-            bool showRun    = runSpeed    > 0.0f && std::fabs(runSpeed    - kBaseRun)    > 0.05f;
-            bool showFlight = flightSpeed > 0.0f && std::fabs(flightSpeed - kBaseFlight) > 0.05f;
-            bool showSwim   = swimSpeed   > 0.0f && std::fabs(swimSpeed   - 4.722f)      > 0.05f;
-
-            if (showRun || showFlight || showSwim) {
-                ImGui::Spacing();
-                ImGui::Separator();
-                ImGui::TextColored(ui::colors::kWarmGold, "Movement");
-                ImVec4 speedColor(0.6f, 1.0f, 0.8f, 1.0f);
-                if (showRun) {
-                    float pct = (runSpeed / kBaseRun) * 100.0f;
-                    ImGui::TextColored(speedColor, "Run Speed: %.1f%%", pct);
-                }
-                if (showFlight) {
-                    float pct = (flightSpeed / kBaseFlight) * 100.0f;
-                    ImGui::TextColored(speedColor, "Flight Speed: %.1f%%", pct);
-                }
-                if (showSwim) {
-                    float pct = (swimSpeed / 4.722f) * 100.0f;
-                    ImGui::TextColored(speedColor, "Swim Speed: %.1f%%", pct);
-                }
-            }
-        }
-    }
+    renderStat("Strength", totalStr);
+    renderStat("Agility", totalAgi);
+    renderStat("Stamina", totalSta);
+    renderStat("Intellect", totalInt);
+    renderStat("Spirit", totalSpi);
 }
 
 void InventoryScreen::renderBackpackPanel(game::Inventory& inventory, bool collapseEmptySections) {
-    ImGui::TextColored(ui::colors::kWarmGold, "Backpack");
+    ImGui::TextColored(ImVec4(1.0f, 0.84f, 0.0f, 1.0f), "Backpack");
     ImGui::Separator();
 
     constexpr float slotSize = 40.0f;
@@ -2213,7 +1465,7 @@ void InventoryScreen::renderBackpackPanel(game::Inventory& inventory, bool colla
         std::string bagLabel = (!bagItem.empty() && !bagItem.item.name.empty())
             ? bagItem.item.name
             : ("Bag Slot " + std::to_string(bag + 1));
-        ImGui::TextColored(ui::colors::kDarkYellow, "%s", bagLabel.c_str());
+        ImGui::TextColored(ImVec4(0.8f, 0.8f, 0.0f, 1.0f), "%s", bagLabel.c_str());
 
         for (int s = 0; s < bagSize; s++) {
             if (s % columns != 0) ImGui::SameLine();
@@ -2227,31 +1479,6 @@ void InventoryScreen::renderBackpackPanel(game::Inventory& inventory, bool colla
             ImGui::PopID();
         }
     }
-
-    if (showKeyring_) {
-        constexpr float keySlotSize = 24.0f;
-        constexpr int keyCols = 8;
-        int lastOccupied = -1;
-        for (int i = inventory.getKeyringSize() - 1; i >= 0; --i) {
-            if (!inventory.getKeyringSlot(i).empty()) { lastOccupied = i; break; }
-        }
-        int visibleSlots = (lastOccupied < 0) ? 0 : ((lastOccupied / keyCols) + 1) * keyCols;
-        if (visibleSlots > 0) {
-            ImGui::Spacing();
-            ImGui::Separator();
-            ImGui::TextColored(ui::colors::kDarkYellow, "Keyring");
-            for (int i = 0; i < visibleSlots; ++i) {
-                if (i % keyCols != 0) ImGui::SameLine();
-                const auto& slot = inventory.getKeyringSlot(i);
-                char sid[32];
-                snprintf(sid, sizeof(sid), "##keyring_%d", i);
-                ImGui::PushID(sid);
-                renderItemSlot(inventory, slot, keySlotSize, nullptr,
-                               SlotKind::BACKPACK, -1, game::EquipSlot::NUM_SLOTS);
-                ImGui::PopID();
-            }
-        }
-    }
 }
 
 void InventoryScreen::renderItemSlot(game::Inventory& inventory, const game::ItemSlot& slot,
@@ -2322,7 +1549,7 @@ void InventoryScreen::renderItemSlot(game::Inventory& inventory, const game::Ite
 
         if (label && ImGui::IsItemHovered()) {
             ImGui::BeginTooltip();
-            ImGui::TextColored(ui::colors::kDarkGray, "%s", label);
+            ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "%s", label);
             ImGui::TextColored(ImVec4(0.4f, 0.4f, 0.4f, 1.0f), "Empty");
             ImGui::EndTooltip();
         }
@@ -2367,20 +1594,6 @@ void InventoryScreen::renderItemSlot(game::Inventory& inventory, const game::Ite
                               IM_COL32(255, 255, 255, 220), countStr);
         }
 
-        // Durability bar on equipment slots (3px strip at bottom of slot icon)
-        if (kind == SlotKind::EQUIPMENT && item.maxDurability > 0) {
-            float durPct = static_cast<float>(item.curDurability) /
-                           static_cast<float>(item.maxDurability);
-            ImU32 durCol;
-            if (durPct > 0.5f)       durCol = IM_COL32(0, 200, 0, 220);
-            else if (durPct > 0.25f) durCol = IM_COL32(220, 220, 0, 220);
-            else                     durCol = IM_COL32(220, 40, 40, 220);
-            float barW = size * durPct;
-            drawList->AddRectFilled(ImVec2(pos.x, pos.y + size - 3.0f),
-                                    ImVec2(pos.x + barW, pos.y + size),
-                                    durCol);
-        }
-
         ImGui::InvisibleButton("slot", ImVec2(size, size));
 
         // Left mouse: hold to pick up, release to drop/swap
@@ -2431,51 +1644,15 @@ void InventoryScreen::renderItemSlot(game::Inventory& inventory, const game::Ite
             }
         }
 
-        // Shift+right-click: split stack (if stackable >1) or destroy confirmation
-        if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Right) &&
-            !holdingItem && ImGui::GetIO().KeyShift && item.itemId != 0) {
-            if (item.stackCount > 1 && item.maxStack > 1) {
-                // Open split popup for stackable items
-                splitConfirmOpen_ = true;
-                splitItemName_ = item.name;
-                splitMax_ = static_cast<int>(item.stackCount);
-                splitCount_ = splitMax_ / 2;
-                if (splitCount_ < 1) splitCount_ = 1;
-                if (kind == SlotKind::BACKPACK && backpackIndex >= 0) {
-                    splitBag_ = 0xFF;
-                    splitSlot_ = static_cast<uint8_t>(23 + backpackIndex);
-                } else if (kind == SlotKind::BACKPACK && isBagSlot) {
-                    splitBag_ = static_cast<uint8_t>(19 + bagIndex);
-                    splitSlot_ = static_cast<uint8_t>(bagSlotIndex);
-                }
-            } else if (item.bindType != 4) {
-                // Destroy confirmation for non-quest, non-stackable items
-                destroyConfirmOpen_ = true;
-                destroyItemName_ = item.name;
-                destroyCount_ = static_cast<uint8_t>(std::clamp<uint32_t>(
-                    std::max<uint32_t>(1u, item.stackCount), 1u, 255u));
-                if (kind == SlotKind::BACKPACK && backpackIndex >= 0) {
-                    destroyBag_ = 0xFF;
-                    destroySlot_ = static_cast<uint8_t>(23 + backpackIndex);
-                } else if (kind == SlotKind::BACKPACK && isBagSlot) {
-                    destroyBag_ = static_cast<uint8_t>(19 + bagIndex);
-                    destroySlot_ = static_cast<uint8_t>(bagSlotIndex);
-                } else if (kind == SlotKind::EQUIPMENT) {
-                    destroyBag_ = 0xFF;
-                    destroySlot_ = static_cast<uint8_t>(equipSlot);
-                }
-            }
-        }
-
         // Right-click: bank deposit (if bank open), vendor sell (if vendor mode), or auto-equip/use
         // Note: InvisibleButton only tracks left-click by default, so use IsItemHovered+IsMouseClicked
-        if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Right) && !holdingItem && !ImGui::GetIO().KeyShift && gameHandler_) {
-            LOG_WARNING("Right-click slot: kind=", static_cast<int>(kind),
+        if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Right) && !holdingItem && gameHandler_) {
+            LOG_WARNING("Right-click slot: kind=", (int)kind,
                      " backpackIndex=", backpackIndex,
                      " bagIndex=", bagIndex, " bagSlotIndex=", bagSlotIndex,
                      " vendorMode=", vendorMode_,
                      " bankOpen=", gameHandler_->isBankOpen(),
-                     " item='", item.name, "' invType=", static_cast<int>(item.inventoryType));
+                     " item='", item.name, "' invType=", (int)item.inventoryType);
             if (gameHandler_->isMailComposeOpen() && kind == SlotKind::BACKPACK && backpackIndex >= 0) {
                 gameHandler_->attachItemFromBackpack(backpackIndex);
             } else if (gameHandler_->isMailComposeOpen() && kind == SlotKind::BACKPACK && isBagSlot) {
@@ -2489,188 +1666,97 @@ void InventoryScreen::renderItemSlot(game::Inventory& inventory, const game::Ite
             } else if (vendorMode_ && kind == SlotKind::BACKPACK && isBagSlot) {
                 gameHandler_->sellItemInBag(bagIndex, bagSlotIndex);
             } else if (kind == SlotKind::EQUIPMENT) {
-                LOG_INFO("UI unequip request: equipSlot=", static_cast<int>(equipSlot));
+                LOG_INFO("UI unequip request: equipSlot=", (int)equipSlot);
                 gameHandler_->unequipToBackpack(equipSlot);
             } else if (kind == SlotKind::BACKPACK && backpackIndex >= 0) {
                 LOG_INFO("Right-click backpack item: name='", item.name,
-                         "' inventoryType=", static_cast<int>(item.inventoryType),
-                         " itemId=", item.itemId,
-                         " startQuestId=", item.startQuestId);
-                if (item.startQuestId != 0) {
-                    uint64_t iGuid = gameHandler_->getBackpackItemGuid(backpackIndex);
-                    gameHandler_->offerQuestFromItem(iGuid, item.startQuestId);
-                } else if (item.inventoryType > 0) {
+                         "' inventoryType=", (int)item.inventoryType,
+                         " itemId=", item.itemId);
+                if (item.inventoryType > 0) {
                     gameHandler_->autoEquipItemBySlot(backpackIndex);
                 } else {
-                    // itemClass==1 (Container) with inventoryType==0 means a lockbox;
-                    // use CMSG_OPEN_ITEM so the server checks keyring automatically.
-                    auto* info = gameHandler_->getItemInfo(item.itemId);
-                    if (info && info->valid && info->itemClass == 1) {
-                        gameHandler_->openItemBySlot(backpackIndex);
-                    } else {
-                        gameHandler_->useItemBySlot(backpackIndex);
-                    }
+                    gameHandler_->useItemBySlot(backpackIndex);
                 }
             } else if (kind == SlotKind::BACKPACK && isBagSlot) {
                 LOG_INFO("Right-click bag item: name='", item.name,
-                         "' inventoryType=", static_cast<int>(item.inventoryType),
-                         " bagIndex=", bagIndex, " slotIndex=", bagSlotIndex,
-                         " startQuestId=", item.startQuestId);
-                if (item.startQuestId != 0) {
-                    uint64_t iGuid = gameHandler_->getBagItemGuid(bagIndex, bagSlotIndex);
-                    gameHandler_->offerQuestFromItem(iGuid, item.startQuestId);
-                } else if (item.inventoryType > 0) {
+                         "' inventoryType=", (int)item.inventoryType,
+                         " bagIndex=", bagIndex, " slotIndex=", bagSlotIndex);
+                if (item.inventoryType > 0) {
                     gameHandler_->autoEquipItemInBag(bagIndex, bagSlotIndex);
                 } else {
-                    auto* info = gameHandler_->getItemInfo(item.itemId);
-                    if (info && info->valid && info->itemClass == 1) {
-                        gameHandler_->openItemInBag(bagIndex, bagSlotIndex);
-                    } else {
-                        gameHandler_->useItemInBag(bagIndex, bagSlotIndex);
-                    }
+                    gameHandler_->useItemInBag(bagIndex, bagSlotIndex);
                 }
             }
         }
 
-        // Shift+left-click: insert item link into chat input
-        if (ImGui::IsItemHovered() && !holdingItem &&
-            ImGui::IsMouseClicked(ImGuiMouseButton_Left) &&
-            ImGui::GetIO().KeyShift &&
-            item.itemId != 0 && !item.name.empty()) {
-            // Build WoW item link: |cff<qualHex>|Hitem:<id>:0:0:0:0:0:0:0:0|h[<name>]|h|r
-            const char* qualHex = "9d9d9d";
-            switch (item.quality) {
-                case game::ItemQuality::COMMON:    qualHex = "ffffff"; break;
-                case game::ItemQuality::UNCOMMON:  qualHex = "1eff00"; break;
-                case game::ItemQuality::RARE:      qualHex = "0070dd"; break;
-                case game::ItemQuality::EPIC:      qualHex = "a335ee"; break;
-                case game::ItemQuality::LEGENDARY: qualHex = "ff8000"; break;
-                case game::ItemQuality::ARTIFACT:  qualHex = "e6cc80"; break;
-                case game::ItemQuality::HEIRLOOM:  qualHex = "e6cc80"; break;
-                default: break;
-            }
-            char linkBuf[512];
-            snprintf(linkBuf, sizeof(linkBuf),
-                     "|cff%s|Hitem:%u:0:0:0:0:0:0:0:0|h[%s]|h|r",
-                     qualHex, item.itemId, item.name.c_str());
-            pendingChatItemLink_ = linkBuf;
-        }
-
         if (ImGui::IsItemHovered() && !holdingItem) {
-            // Pass inventory for backpack/bag items only; equipped items compare against themselves otherwise
-            const game::Inventory* tooltipInv = (kind == SlotKind::EQUIPMENT) ? nullptr : &inventory;
-            uint64_t slotGuid = 0;
-            if (kind == SlotKind::EQUIPMENT && gameHandler_)
-                slotGuid = gameHandler_->getEquipSlotGuid(static_cast<int>(equipSlot));
-            renderItemTooltip(item, tooltipInv, slotGuid);
+            renderItemTooltip(item, &inventory);
         }
     }
 }
 
-const std::unordered_map<uint32_t, std::string>& InventoryScreen::getEnchantmentNames() {
-    static std::unordered_map<uint32_t, std::string> s_cache;
-    static bool s_loaded = false;
-    if (!s_loaded && assetManager_) {
-        s_loaded = true;
-        auto dbc = assetManager_->loadDBC("SpellItemEnchantment.dbc");
-        if (dbc && dbc->isLoaded()) {
-            const auto* lay = pipeline::getActiveDBCLayout()
-                ? pipeline::getActiveDBCLayout()->getLayout("SpellItemEnchantment") : nullptr;
-            uint32_t nf = lay ? lay->field("Name") : 8u;
-            if (nf == 0xFFFFFFFF) nf = 8;
-            uint32_t fc = dbc->getFieldCount();
-            for (uint32_t r = 0; r < dbc->getRecordCount(); ++r) {
-                uint32_t eid = dbc->getUInt32(r, 0);
-                if (eid == 0 || nf >= fc) continue;
-                std::string en = dbc->getString(r, nf);
-                if (!en.empty()) s_cache[eid] = std::move(en);
-            }
-        }
-    }
-    return s_cache;
-}
-
-void InventoryScreen::renderItemTooltip(const game::ItemDef& item, const game::Inventory* inventory, uint64_t itemGuid) {
-    const auto& s_enchLookupB = getEnchantmentNames();
-
+void InventoryScreen::renderItemTooltip(const game::ItemDef& item, const game::Inventory* inventory) {
     ImGui::BeginTooltip();
 
     ImVec4 qColor = getQualityColor(item.quality);
     ImGui::TextColored(qColor, "%s", item.name.c_str());
-    if (item.itemLevel > 0) {
-        ImGui::TextColored(ImVec4(1.0f, 1.0f, 1.0f, 0.7f), "Item Level %u", item.itemLevel);
-    }
-
-    // Heroic / Unique / Unique-Equipped indicators
-    if (gameHandler_) {
-        const auto* qi = gameHandler_->getItemInfo(item.itemId);
-        if (qi && qi->valid) {
-            constexpr uint32_t kFlagHeroic         = 0x8;
-            constexpr uint32_t kFlagUniqueEquipped = 0x1000000;
-            if (qi->itemFlags & kFlagHeroic) {
-                ImGui::TextColored(ImVec4(0.0f, 0.8f, 0.0f, 1.0f), "Heroic");
-            }
-            if (qi->maxCount == 1) {
-                ImGui::TextColored(ui::colors::kTooltipGold, "Unique");
-            } else if (qi->itemFlags & kFlagUniqueEquipped) {
-                ImGui::TextColored(ui::colors::kTooltipGold, "Unique-Equipped");
-            }
-        }
-    }
-
-    // Binding type
-    ui::renderBindingType(item.bindType);
 
     if (item.itemId == 6948 && gameHandler_) {
         uint32_t mapId = 0;
         glm::vec3 pos;
         if (gameHandler_->getHomeBind(mapId, pos)) {
-            std::string homeLocation;
-            // Prefer the specific zone name from the bind-point zone ID
-            uint32_t zoneId = gameHandler_->getHomeBindZoneId();
-            if (zoneId != 0)
-                homeLocation = gameHandler_->getWhoAreaName(zoneId);
-            // Fall back to continent name if zone unavailable
-            if (homeLocation.empty()) {
-                switch (mapId) {
-                    case 0:   homeLocation = "Eastern Kingdoms"; break;
-                    case 1:   homeLocation = "Kalimdor"; break;
-                    case 530: homeLocation = "Outland"; break;
-                    case 571: homeLocation = "Northrend"; break;
-                    case 13:  homeLocation = "Test"; break;
-                    case 169: homeLocation = "Emerald Dream"; break;
-                    default:  homeLocation = "Unknown"; break;
-                }
+            const char* mapName = "Unknown";
+            switch (mapId) {
+                case 0:   mapName = "Eastern Kingdoms"; break;
+                case 1:   mapName = "Kalimdor"; break;
+                case 530:  mapName = "Outland"; break;
+                case 571:  mapName = "Northrend"; break;
+                case 13:   mapName = "Test"; break;
+                case 169:  mapName = "Emerald Dream"; break;
             }
-            ImGui::TextColored(ImVec4(0.8f, 0.9f, 1.0f, 1.0f), "Home: %s", homeLocation.c_str());
+            ImGui::TextColored(ImVec4(0.8f, 0.9f, 1.0f, 1.0f), "Home: %s", mapName);
         } else {
-            ImGui::TextColored(ui::colors::kLightGray, "Home: not set");
+            ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f), "Home: not set");
         }
         ImGui::TextDisabled("Use: Teleport home");
     }
 
     // Slot type
     if (item.inventoryType > 0) {
-        const char* slotName = ui::getInventorySlotName(item.inventoryType);
+        const char* slotName = "";
+        switch (item.inventoryType) {
+            case 1:  slotName = "Head"; break;
+            case 2:  slotName = "Neck"; break;
+            case 3:  slotName = "Shoulder"; break;
+            case 4:  slotName = "Shirt"; break;
+            case 5:  slotName = "Chest"; break;
+            case 6:  slotName = "Waist"; break;
+            case 7:  slotName = "Legs"; break;
+            case 8:  slotName = "Feet"; break;
+            case 9:  slotName = "Wrist"; break;
+            case 10: slotName = "Hands"; break;
+            case 11: slotName = "Finger"; break;
+            case 12: slotName = "Trinket"; break;
+            case 13: slotName = "One-Hand"; break;
+            case 14: slotName = "Shield"; break;
+            case 15: slotName = "Ranged"; break;
+            case 16: slotName = "Back"; break;
+            case 17: slotName = "Two-Hand"; break;
+            case 18: slotName = "Bag"; break;
+            case 19: slotName = "Tabard"; break;
+            case 20: slotName = "Robe"; break;
+            case 21: slotName = "Main Hand"; break;
+            case 22: slotName = "Off Hand"; break;
+            case 23: slotName = "Held In Off-hand"; break;
+            case 25: slotName = "Thrown"; break;
+            case 26: slotName = "Ranged"; break;
+            default: slotName = ""; break;
+        }
         if (slotName[0]) {
             if (!item.subclassName.empty()) {
-                ImGui::TextColored(ui::colors::kLightGray, "%s  %s", slotName, item.subclassName.c_str());
+                ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f), "%s  %s", slotName, item.subclassName.c_str());
             } else {
-                ImGui::TextColored(ui::colors::kLightGray, "%s", slotName);
-            }
-        }
-
-        // Show red warning if player lacks proficiency for this weapon/armor type
-        if (gameHandler_) {
-            const auto* qi = gameHandler_->getItemInfo(item.itemId);
-            if (qi && qi->valid) {
-                bool canUse = true;
-                if (qi->itemClass == 2) // Weapon
-                    canUse = gameHandler_->canUseWeaponSubclass(qi->subClass);
-                else if (qi->itemClass == 4 && qi->subClass > 0) // Armor (skip subclass 0 = misc)
-                    canUse = gameHandler_->canUseArmorSubclass(qi->subClass);
-                if (!canUse)
-                    ImGui::TextColored(ui::colors::kBrightRed, "You can't use this type of item.");
+                ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f), "%s", slotName);
             }
         }
     }
@@ -2690,15 +1776,13 @@ void InventoryScreen::renderItemTooltip(const game::ItemDef& item, const game::I
     };
     const bool isWeapon = isWeaponInventoryType(item.inventoryType);
 
-    // Compact stats view for weapons: damage range + speed + DPS
+    // Compact stats view for weapons: DPS + condensed stat bonuses.
+    // Non-weapons keep armor/sell info visible.
     ImVec4 green(0.0f, 1.0f, 0.0f, 1.0f);
     if (isWeapon && item.damageMax > 0.0f && item.delayMs > 0) {
         float speed = static_cast<float>(item.delayMs) / 1000.0f;
         float dps = ((item.damageMin + item.damageMax) * 0.5f) / speed;
-        ImGui::Text("%.0f - %.0f Damage", item.damageMin, item.damageMax);
-        ImGui::SameLine(160.0f);
-        ImGui::TextDisabled("Speed %.2f", speed);
-        ImGui::TextColored(ui::colors::kLightGray, "(%.1f damage per second)", dps);
+        ImGui::Text("%.1f DPS", dps);
     }
 
     // Armor appears before stat bonuses — matches WoW tooltip order
@@ -2706,17 +1790,6 @@ void InventoryScreen::renderItemTooltip(const game::ItemDef& item, const game::I
         ImGui::Text("%d Armor", item.armor);
     }
 
-    // Elemental resistances from item query cache (fire resist gear, nature resist gear, etc.)
-    if (gameHandler_) {
-        const auto* qi = gameHandler_->getItemInfo(item.itemId);
-        if (qi && qi->valid) {
-            const int32_t resValsI[6] = { qi->holyRes, qi->fireRes, qi->natureRes,
-                                          qi->frostRes, qi->shadowRes, qi->arcaneRes };
-            for (int i = 0; i < 6; ++i)
-                if (resValsI[i] > 0) ImGui::Text("+%d %s", resValsI[i], kResistNames[i]);
-        }
-    }
-
     auto appendBonus = [](std::string& out, int32_t val, const char* shortName) {
         if (val <= 0) return;
         if (!out.empty()) out += "  ";
@@ -2732,313 +1805,11 @@ void InventoryScreen::renderItemTooltip(const game::ItemDef& item, const game::I
     if (!bonusLine.empty()) {
         ImGui::TextColored(green, "%s", bonusLine.c_str());
     }
-
-    // Extra stats (hit, crit, haste, AP, SP, etc.) — one line each
-    for (const auto& es : item.extraStats) {
-        const char* statName = nullptr;
-        switch (es.statType) {
-            case 0:  statName = "Mana"; break;
-            case 1:  statName = "Health"; break;
-            case 12: statName = "Defense Rating"; break;
-            case 13: statName = "Dodge Rating"; break;
-            case 14: statName = "Parry Rating"; break;
-            case 15: statName = "Block Rating"; break;
-            case 16: statName = "Hit Rating"; break;
-            case 17: statName = "Hit Rating"; break;
-            case 18: statName = "Hit Rating"; break;
-            case 19: statName = "Crit Rating"; break;
-            case 20: statName = "Crit Rating"; break;
-            case 21: statName = "Crit Rating"; break;
-            case 28: statName = "Haste Rating"; break;
-            case 29: statName = "Haste Rating"; break;
-            case 30: statName = "Haste Rating"; break;
-            case 31: statName = "Hit Rating"; break;
-            case 32: statName = "Crit Rating"; break;
-            case 35: statName = "Resilience"; break;
-            case 36: statName = "Haste Rating"; break;
-            case 37: statName = "Expertise Rating"; break;
-            case 38: statName = "Attack Power"; break;
-            case 39: statName = "Ranged Attack Power"; break;
-            case 41: statName = "Healing Power"; break;
-            case 42: statName = "Spell Damage"; break;
-            case 43: statName = "Mana per 5 sec"; break;
-            case 44: statName = "Armor Penetration"; break;
-            case 45: statName = "Spell Power"; break;
-            case 46: statName = "Health per 5 sec"; break;
-            case 47: statName = "Spell Penetration"; break;
-            case 48: statName = "Block Value"; break;
-            default: statName = nullptr; break;
-        }
-        char buf[64];
-        if (statName) {
-            std::snprintf(buf, sizeof(buf), "%+d %s", es.statValue, statName);
-        } else {
-            std::snprintf(buf, sizeof(buf), "%+d (stat %u)", es.statValue, es.statType);
-        }
-        ImGui::TextColored(green, "%s", buf);
-    }
-
-    if (item.requiredLevel > 1) {
-        uint32_t playerLvl = gameHandler_ ? gameHandler_->getPlayerLevel() : 0;
-        bool meetsReq = (playerLvl >= item.requiredLevel);
-        ImVec4 reqColor = meetsReq ? ImVec4(1.0f, 1.0f, 1.0f, 0.75f) : ui::colors::kPaleRed;
-        ImGui::TextColored(reqColor, "Requires Level %u", item.requiredLevel);
-    }
-    if (item.maxDurability > 0) {
-        float durPct = static_cast<float>(item.curDurability) / static_cast<float>(item.maxDurability);
-        ImVec4 durColor;
-        if (durPct > 0.5f)       durColor = ImVec4(0.1f, 1.0f, 0.1f, 1.0f);  // green
-        else if (durPct > 0.25f) durColor = ImVec4(1.0f, 1.0f, 0.0f, 1.0f);  // yellow
-        else                     durColor = ui::colors::kBrightRed;  // red
-        ImGui::TextColored(durColor, "Durability %u / %u",
-                           item.curDurability, item.maxDurability);
-    }
-    // Item spell effects (Use/Equip/Chance on Hit)
-    if (gameHandler_) {
-        auto* info = gameHandler_->getItemInfo(item.itemId);
-        if (info) {
-            for (const auto& sp : info->spells) {
-                if (sp.spellId == 0) continue;
-                const char* trigger = nullptr;
-                switch (sp.spellTrigger) {
-                    case 0: trigger = "Use"; break;        // on use
-                    case 1: trigger = "Equip"; break;      // on equip
-                    case 2: trigger = "Chance on Hit"; break; // proc on melee hit
-                    case 4: trigger = "Use"; break;        // soulstone (still shows as Use)
-                    case 5: trigger = "Use"; break;        // on use, no delay
-                    case 6: trigger = "Use"; break;        // learn spell (recipe/pattern)
-                    default: break;
-                }
-                if (!trigger) continue;
-                const std::string& spDesc = gameHandler_->getSpellDescription(sp.spellId);
-                const std::string& spText = spDesc.empty() ? gameHandler_->getSpellName(sp.spellId) : spDesc;
-                if (!spText.empty()) {
-                    ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + 320.0f);
-                    ImGui::TextColored(ui::colors::kCyan,
-                                       "%s: %s", trigger, spText.c_str());
-                    ImGui::PopTextWrapPos();
-                } else {
-                    ImGui::TextColored(ui::colors::kCyan,
-                                       "%s: Spell #%u", trigger, sp.spellId);
-                }
-            }
-        }
-    }
-
-    // Skill / reputation requirements from item query cache
-    if (gameHandler_) {
-        const auto* qInfo = gameHandler_->getItemInfo(item.itemId);
-        if (qInfo && qInfo->valid) {
-            if (qInfo->requiredSkill != 0 && qInfo->requiredSkillRank > 0) {
-                static std::unordered_map<uint32_t, std::string> s_skillNamesB;
-                static bool s_skillNamesLoadedB = false;
-                if (!s_skillNamesLoadedB && assetManager_) {
-                    s_skillNamesLoadedB = true;
-                    auto dbc = assetManager_->loadDBC("SkillLine.dbc");
-                    if (dbc && dbc->isLoaded()) {
-                        const auto* layout = pipeline::getActiveDBCLayout()
-                            ? pipeline::getActiveDBCLayout()->getLayout("SkillLine") : nullptr;
-                        uint32_t idF   = layout ? (*layout)["ID"]   : 0;
-                        uint32_t nameF = layout ? (*layout)["Name"] : 2;
-                        for (uint32_t r = 0; r < dbc->getRecordCount(); ++r) {
-                            uint32_t sid = dbc->getUInt32(r, idF);
-                            if (!sid) continue;
-                            std::string sname = dbc->getString(r, nameF);
-                            if (!sname.empty()) s_skillNamesB[sid] = std::move(sname);
-                        }
-                    }
-                }
-                uint32_t playerSkillVal = 0;
-                const auto& skills = gameHandler_->getPlayerSkills();
-                auto skPit = skills.find(qInfo->requiredSkill);
-                if (skPit != skills.end()) playerSkillVal = skPit->second.effectiveValue();
-                bool meetsSkill = (playerSkillVal == 0 || playerSkillVal >= qInfo->requiredSkillRank);
-                ImVec4 skColor = meetsSkill ? ImVec4(1.0f, 1.0f, 1.0f, 0.75f) : ui::colors::kPaleRed;
-                auto skIt = s_skillNamesB.find(qInfo->requiredSkill);
-                if (skIt != s_skillNamesB.end())
-                    ImGui::TextColored(skColor, "Requires %s (%u)", skIt->second.c_str(), qInfo->requiredSkillRank);
-                else
-                    ImGui::TextColored(skColor, "Requires Skill %u (%u)", qInfo->requiredSkill, qInfo->requiredSkillRank);
-            }
-            if (qInfo->requiredReputationFaction != 0 && qInfo->requiredReputationRank > 0) {
-                static std::unordered_map<uint32_t, std::string> s_factionNamesB;
-                static bool s_factionNamesLoadedB = false;
-                if (!s_factionNamesLoadedB && assetManager_) {
-                    s_factionNamesLoadedB = true;
-                    auto dbc = assetManager_->loadDBC("Faction.dbc");
-                    if (dbc && dbc->isLoaded()) {
-                        const auto* layout = pipeline::getActiveDBCLayout()
-                            ? pipeline::getActiveDBCLayout()->getLayout("Faction") : nullptr;
-                        uint32_t idF   = layout ? (*layout)["ID"]   : 0;
-                        uint32_t nameF = layout ? (*layout)["Name"] : 20;
-                        for (uint32_t r = 0; r < dbc->getRecordCount(); ++r) {
-                            uint32_t fid = dbc->getUInt32(r, idF);
-                            if (!fid) continue;
-                            std::string fname = dbc->getString(r, nameF);
-                            if (!fname.empty()) s_factionNamesB[fid] = std::move(fname);
-                        }
-                    }
-                }
-                const char* rankName = (qInfo->requiredReputationRank < 8)
-                    ? kRepRankNames[qInfo->requiredReputationRank] : "Unknown";
-                auto fIt = s_factionNamesB.find(qInfo->requiredReputationFaction);
-                ImGui::TextColored(ImVec4(1.0f, 1.0f, 1.0f, 0.75f), "Requires %s with %s",
-                    rankName,
-                    fIt != s_factionNamesB.end() ? fIt->second.c_str() : "Unknown Faction");
-            }
-            if (qInfo->allowableClass != 0)
-                renderClassRestriction(qInfo->allowableClass, gameHandler_->getPlayerClass());
-            if (qInfo->allowableRace != 0)
-                renderRaceRestriction(qInfo->allowableRace, gameHandler_->getPlayerRace());
-        }
-    }
-
-    // Gem socket slots and item set — look up from query cache
-    if (gameHandler_) {
-        const auto* qi2 = gameHandler_->getItemInfo(item.itemId);
-        if (qi2 && qi2->valid) {
-            // Gem sockets
-            {
-                // Get socket gem enchant IDs for this item (filled from item update fields)
-                std::array<uint32_t, 3> sockGems{};
-                if (itemGuid != 0 && gameHandler_)
-                    sockGems = gameHandler_->getItemSocketEnchantIds(itemGuid);
-
-                bool hasSocket = false;
-                for (int i = 0; i < 3; ++i) {
-                    if (qi2->socketColor[i] == 0) continue;
-                    if (!hasSocket) { ImGui::Spacing(); hasSocket = true; }
-                    for (const auto& st : kSocketTypes) {
-                        if (qi2->socketColor[i] & st.mask) {
-                            if (sockGems[i] != 0) {
-                                auto git = s_enchLookupB.find(sockGems[i]);
-                                if (git != s_enchLookupB.end())
-                                    ImGui::TextColored(st.col, "%s: %s", st.label, git->second.c_str());
-                                else
-                                    ImGui::TextColored(st.col, "%s: (gem %u)", st.label, sockGems[i]);
-                            } else {
-                                ImGui::TextColored(st.col, "%s", st.label);
-                            }
-                            break;
-                        }
-                    }
-                }
-                if (hasSocket && qi2->socketBonus != 0) {
-                    auto enchIt = s_enchLookupB.find(qi2->socketBonus);
-                    if (enchIt != s_enchLookupB.end())
-                        ImGui::TextColored(ui::colors::kSocketGreen, "Socket Bonus: %s", enchIt->second.c_str());
-                    else
-                        ImGui::TextColored(ui::colors::kSocketGreen, "Socket Bonus: (id %u)", qi2->socketBonus);
-                }
-            }
-            // Item set membership
-            if (qi2->itemSetId != 0) {
-                struct SetEntryD {
-                    std::string name;
-                    std::array<uint32_t, 10> itemIds{};
-                    std::array<uint32_t, 10> spellIds{};
-                    std::array<uint32_t, 10> thresholds{};
-                };
-                static std::unordered_map<uint32_t, SetEntryD> s_setDataD;
-                static bool s_setDataLoadedD = false;
-                if (!s_setDataLoadedD && assetManager_) {
-                    s_setDataLoadedD = true;
-                    auto dbc = assetManager_->loadDBC("ItemSet.dbc");
-                    if (dbc && dbc->isLoaded()) {
-                        const auto* layout = pipeline::getActiveDBCLayout()
-                            ? pipeline::getActiveDBCLayout()->getLayout("ItemSet") : nullptr;
-                        auto lf = [&](const char* k, uint32_t def) -> uint32_t {
-                            return layout ? (*layout)[k] : def;
-                        };
-                        uint32_t idF = lf("ID", 0), nameF = lf("Name", 1);
-                        const auto& itemKeys = ui::kItemSetItemKeys;
-                        const auto& spellKeys = ui::kItemSetSpellKeys;
-                        const auto& thrKeys = ui::kItemSetThresholdKeys;
-                        uint32_t itemFB[10], spellFB[10], thrFB[10];
-                        for (int i = 0; i < 10; ++i) {
-                            itemFB[i] = 18+i; spellFB[i] = 28+i; thrFB[i] = 38+i;
-                        }
-                        for (uint32_t r = 0; r < dbc->getRecordCount(); ++r) {
-                            uint32_t id = dbc->getUInt32(r, idF);
-                            if (!id) continue;
-                            SetEntryD e;
-                            e.name = dbc->getString(r, nameF);
-                            for (int i = 0; i < 10; ++i) {
-                                e.itemIds[i]    = dbc->getUInt32(r, layout ? (*layout)[itemKeys[i]]  : itemFB[i]);
-                                e.spellIds[i]   = dbc->getUInt32(r, layout ? (*layout)[spellKeys[i]] : spellFB[i]);
-                                e.thresholds[i] = dbc->getUInt32(r, layout ? (*layout)[thrKeys[i]]   : thrFB[i]);
-                            }
-                            s_setDataD[id] = std::move(e);
-                        }
-                    }
-                }
-                auto setIt = s_setDataD.find(qi2->itemSetId);
-                ImGui::Spacing();
-                if (setIt != s_setDataD.end()) {
-                    const SetEntryD& se = setIt->second;
-                    int equipped = 0, total = 0;
-                    for (int i = 0; i < 10; ++i) {
-                        if (se.itemIds[i] == 0) continue;
-                        ++total;
-                        if (inventory) {
-                            for (int s = 0; s < game::Inventory::NUM_EQUIP_SLOTS; s++) {
-                                const auto& eSlot = inventory->getEquipSlot(static_cast<game::EquipSlot>(s));
-                                if (!eSlot.empty() && eSlot.item.itemId == se.itemIds[i]) { ++equipped; break; }
-                            }
-                        }
-                    }
-                    if (total > 0) {
-                        ImGui::TextColored(ui::colors::kTooltipGold,
-                            "%s (%d/%d)", se.name.empty() ? "Set" : se.name.c_str(), equipped, total);
-                    } else if (!se.name.empty()) {
-                        ImGui::TextColored(ui::colors::kTooltipGold, "%s", se.name.c_str());
-                    }
-                    for (int i = 0; i < 10; ++i) {
-                        if (se.spellIds[i] == 0 || se.thresholds[i] == 0) continue;
-                        const std::string& bname = gameHandler_->getSpellName(se.spellIds[i]);
-                        bool active = (equipped >= static_cast<int>(se.thresholds[i]));
-                        ImVec4 col = active ? ui::colors::kActiveGreen
-                                           : ui::colors::kInactiveGray;
-                        if (!bname.empty())
-                            ImGui::TextColored(col, "(%u) %s", se.thresholds[i], bname.c_str());
-                        else
-                            ImGui::TextColored(col, "(%u) Set Bonus", se.thresholds[i]);
-                    }
-                } else {
-                    ImGui::TextColored(ui::colors::kTooltipGold, "Set (id %u)", qi2->itemSetId);
-                }
-            }
-        }
-    }
-
-    // Weapon/armor enchant display for equipped items (reads from item update fields)
-    if (itemGuid != 0 && gameHandler_) {
-        auto [permId, tempId] = gameHandler_->getItemEnchantIds(itemGuid);
-        if (permId != 0) {
-            auto it2 = s_enchLookupB.find(permId);
-            const char* ename = (it2 != s_enchLookupB.end()) ? it2->second.c_str() : nullptr;
-            if (ename) ImGui::TextColored(ui::colors::kCyan, "Enchanted: %s", ename);
-        }
-        if (tempId != 0) {
-            auto it2 = s_enchLookupB.find(tempId);
-            const char* ename = (it2 != s_enchLookupB.end()) ? it2->second.c_str() : nullptr;
-            if (ename) ImGui::TextColored(ImVec4(0.8f, 1.0f, 0.4f, 1.0f), "%s (temporary)", ename);
-        }
-    }
-
-    // "Begins a Quest" line (shown in yellow-green like the game)
-    if (item.startQuestId != 0) {
-        ImGui::TextColored(ui::colors::kTooltipGold, "Begins a Quest");
-    }
-
-    // Flavor / lore text (italic yellow in WoW, just yellow here)
-    if (!item.description.empty()) {
-        ImGui::TextColored(ImVec4(1.0f, 0.9f, 0.5f, 0.9f), "\"%s\"", item.description.c_str());
-    }
-
     if (item.sellPrice > 0) {
-        ImGui::TextDisabled("Sell:"); ImGui::SameLine(0, 4);
-        renderCoinsFromCopper(item.sellPrice);
+        uint32_t g = item.sellPrice / 10000;
+        uint32_t s = (item.sellPrice / 100) % 100;
+        uint32_t c = item.sellPrice % 100;
+        ImGui::TextColored(ImVec4(1.0f, 0.84f, 0.0f, 1.0f), "Sell: %ug %us %uc", g, s, c);
     }
 
     // Shift-hover comparison with currently equipped equivalent.
@@ -3053,591 +1824,25 @@ void InventoryScreen::renderItemTooltip(const game::ItemDef& item, const game::I
             }
             ImGui::TextColored(getQualityColor(eq->item.quality), "%s", eq->item.name.c_str());
 
-            // Item level comparison (always shown when different)
-            if (eq->item.itemLevel > 0 || item.itemLevel > 0) {
-                char ilvlBuf[64];
-                float diff = static_cast<float>(item.itemLevel) - static_cast<float>(eq->item.itemLevel);
-                if (diff > 0.0f)
-                    std::snprintf(ilvlBuf, sizeof(ilvlBuf), "Item Level: %u (▲%.0f)", item.itemLevel, diff);
-                else if (diff < 0.0f)
-                    std::snprintf(ilvlBuf, sizeof(ilvlBuf), "Item Level: %u (▼%.0f)", item.itemLevel, -diff);
-                else
-                    std::snprintf(ilvlBuf, sizeof(ilvlBuf), "Item Level: %u (=)", item.itemLevel);
-                ImVec4 ilvlColor = (diff > 0.0f) ? ImVec4(0.0f, 1.0f, 0.0f, 1.0f)
-                                 : (diff < 0.0f) ? ui::colors::kRed
-                                 : ui::colors::kLightGray;
-                ImGui::TextColored(ilvlColor, "%s", ilvlBuf);
+            if (isWeaponInventoryType(eq->item.inventoryType) &&
+                eq->item.damageMax > 0.0f && eq->item.delayMs > 0) {
+                float speed = static_cast<float>(eq->item.delayMs) / 1000.0f;
+                float dps = ((eq->item.damageMin + eq->item.damageMax) * 0.5f) / speed;
+                ImGui::Text("%.1f DPS", dps);
             }
-
-            // Helper: render a numeric stat diff line
-            auto showDiff = [](const char* label, float newVal, float eqVal) {
-                if (newVal == 0.0f && eqVal == 0.0f) return;
-                float diff = newVal - eqVal;
-                char buf[128];
-                if (diff > 0.0f) {
-                    std::snprintf(buf, sizeof(buf), "%s: %.0f (▲%.0f)", label, newVal, diff);
-                    ImGui::TextColored(ImVec4(0.0f, 1.0f, 0.0f, 1.0f), "%s", buf);
-                } else if (diff < 0.0f) {
-                    std::snprintf(buf, sizeof(buf), "%s: %.0f (▼%.0f)", label, newVal, -diff);
-                    ImGui::TextColored(ui::colors::kRed, "%s", buf);
-                } else {
-                    std::snprintf(buf, sizeof(buf), "%s: %.0f (=)", label, newVal);
-                    ImGui::TextColored(ui::colors::kLightGray, "%s", buf);
-                }
-            };
-
-            // DPS comparison for weapons
-            if (isWeaponInventoryType(item.inventoryType) && isWeaponInventoryType(eq->item.inventoryType)) {
-                float newDps = 0.0f, eqDps = 0.0f;
-                if (item.damageMax > 0.0f && item.delayMs > 0)
-                    newDps = ((item.damageMin + item.damageMax) * 0.5f) / (item.delayMs / 1000.0f);
-                if (eq->item.damageMax > 0.0f && eq->item.delayMs > 0)
-                    eqDps = ((eq->item.damageMin + eq->item.damageMax) * 0.5f) / (eq->item.delayMs / 1000.0f);
-                showDiff("DPS", newDps, eqDps);
+            if (eq->item.armor > 0) {
+                ImGui::Text("%d Armor", eq->item.armor);
             }
-
-            // Armor
-            showDiff("Armor", static_cast<float>(item.armor), static_cast<float>(eq->item.armor));
-
-            // Primary stats
-            showDiff("Str",   static_cast<float>(item.strength),  static_cast<float>(eq->item.strength));
-            showDiff("Agi",   static_cast<float>(item.agility),   static_cast<float>(eq->item.agility));
-            showDiff("Sta",   static_cast<float>(item.stamina),   static_cast<float>(eq->item.stamina));
-            showDiff("Int",   static_cast<float>(item.intellect), static_cast<float>(eq->item.intellect));
-            showDiff("Spi",   static_cast<float>(item.spirit),    static_cast<float>(eq->item.spirit));
-
-            // Extra stats diff — union of stat types from both items
-            auto findExtraStat = [](const game::ItemDef& it, uint32_t type) -> int32_t {
-                for (const auto& es : it.extraStats)
-                    if (es.statType == type) return es.statValue;
-                return 0;
-            };
-            // Collect all extra stat types
-            std::vector<uint32_t> allTypes;
-            for (const auto& es : item.extraStats) allTypes.push_back(es.statType);
-            for (const auto& es : eq->item.extraStats) {
-                bool found = false;
-                for (uint32_t t : allTypes) if (t == es.statType) { found = true; break; }
-                if (!found) allTypes.push_back(es.statType);
-            }
-            for (uint32_t t : allTypes) {
-                int32_t nv = findExtraStat(item, t);
-                int32_t ev = findExtraStat(eq->item, t);
-                // Find a label for this stat type
-                const char* lbl = nullptr;
-                switch (t) {
-                    case 0:  lbl = "Mana"; break;
-                    case 1:  lbl = "Health"; break;
-                    case 12: lbl = "Defense"; break;
-                    case 13: lbl = "Dodge"; break;
-                    case 14: lbl = "Parry"; break;
-                    case 15: lbl = "Block Rating"; break;
-                    case 16: case 17: case 18: case 31: lbl = "Hit"; break;
-                    case 19: case 20: case 21: case 32: lbl = "Crit"; break;
-                    case 28: case 29: case 30: case 36: lbl = "Haste"; break;
-                    case 35: lbl = "Resilience"; break;
-                    case 37: lbl = "Expertise"; break;
-                    case 38: lbl = "Attack Power"; break;
-                    case 39: lbl = "Ranged AP"; break;
-                    case 41: lbl = "Healing"; break;
-                    case 42: lbl = "Spell Damage"; break;
-                    case 43: lbl = "MP5"; break;
-                    case 44: lbl = "Armor Pen"; break;
-                    case 45: lbl = "Spell Power"; break;
-                    case 46: lbl = "HP5"; break;
-                    case 47: lbl = "Spell Pen"; break;
-                    case 48: lbl = "Block Value"; break;
-                    default: lbl = nullptr; break;
-                }
-                if (!lbl) continue;
-                showDiff(lbl, static_cast<float>(nv), static_cast<float>(ev));
+            std::string eqBonusLine;
+            appendBonus(eqBonusLine, eq->item.strength, "Str");
+            appendBonus(eqBonusLine, eq->item.agility, "Agi");
+            appendBonus(eqBonusLine, eq->item.stamina, "Sta");
+            appendBonus(eqBonusLine, eq->item.intellect, "Int");
+            appendBonus(eqBonusLine, eq->item.spirit, "Spi");
+            if (!eqBonusLine.empty()) {
+                ImGui::TextColored(green, "%s", eqBonusLine.c_str());
             }
         }
-    } else if (inventory && !ImGui::GetIO().KeyShift && item.inventoryType > 0) {
-        if (findComparableEquipped(*inventory, item.inventoryType)) {
-            ImGui::TextDisabled("Hold Shift to compare");
-        }
-    }
-
-    // Destroy hint (not shown for quest items)
-    if (item.itemId != 0 && item.bindType != 4) {
-        ImGui::Spacing();
-        if (ImGui::GetIO().KeyShift) {
-            ImGui::TextColored(ImVec4(1.0f, 0.45f, 0.45f, 0.9f), "Shift+RClick to destroy");
-        } else {
-            ImGui::TextDisabled("Shift+RClick to destroy");
-        }
-    }
-
-    ImGui::EndTooltip();
-}
-
-// ---------------------------------------------------------------------------
-// Tooltip overload for ItemQueryResponseData (used by loot window, etc.)
-// ---------------------------------------------------------------------------
-void InventoryScreen::renderItemTooltip(const game::ItemQueryResponseData& info, const game::Inventory* inventory, uint64_t itemGuid) {
-    const auto& s_enchLookup = getEnchantmentNames();
-
-    ImGui::BeginTooltip();
-
-    ImVec4 qColor = getQualityColor(static_cast<game::ItemQuality>(info.quality));
-    ImGui::TextColored(qColor, "%s", info.name.c_str());
-    if (info.itemLevel > 0) {
-        ImGui::TextColored(ImVec4(1.0f, 1.0f, 1.0f, 0.7f), "Item Level %u", info.itemLevel);
-    }
-
-    // Unique / Heroic indicators
-    constexpr uint32_t kFlagHeroic          = 0x8;         // ITEM_FLAG_HEROIC_TOOLTIP
-    constexpr uint32_t kFlagUniqueEquipped  = 0x1000000;   // ITEM_FLAG_UNIQUE_EQUIPPABLE
-    if (info.itemFlags & kFlagHeroic) {
-        ImGui::TextColored(ImVec4(0.0f, 0.8f, 0.0f, 1.0f), "Heroic");
-    }
-    if (info.maxCount == 1) {
-        ImGui::TextColored(ui::colors::kTooltipGold, "Unique");
-    } else if (info.itemFlags & kFlagUniqueEquipped) {
-        ImGui::TextColored(ui::colors::kTooltipGold, "Unique-Equipped");
-    }
-
-    // Binding type
-    ui::renderBindingType(info.bindType);
-
-    // Slot / subclass
-    if (info.inventoryType > 0) {
-        const char* slotName = ui::getInventorySlotName(info.inventoryType);
-        if (slotName[0]) {
-            if (!info.subclassName.empty())
-                ImGui::TextColored(ui::colors::kLightGray, "%s  %s", slotName, info.subclassName.c_str());
-            else
-                ImGui::TextColored(ui::colors::kLightGray, "%s", slotName);
-        }
-
-        // Proficiency check for vendor/loot tooltips (ItemQueryResponseData has itemClass/subClass)
-        if (gameHandler_) {
-            bool canUse = true;
-            if (info.itemClass == 2) // Weapon
-                canUse = gameHandler_->canUseWeaponSubclass(info.subClass);
-            else if (info.itemClass == 4 && info.subClass > 0) // Armor (skip subclass 0 = misc)
-                canUse = gameHandler_->canUseArmorSubclass(info.subClass);
-            if (!canUse)
-                ImGui::TextColored(ui::colors::kBrightRed, "You can't use this type of item.");
-        }
-    }
-
-    // Weapon stats
-    auto isWeaponInvType = [](uint32_t t) {
-        return t == 13 || t == 15 || t == 17 || t == 21 || t == 25 || t == 26;
-    };
-    ImVec4 green(0.0f, 1.0f, 0.0f, 1.0f);
-    if (isWeaponInvType(info.inventoryType) && info.damageMax > 0.0f && info.delayMs > 0) {
-        float speed = static_cast<float>(info.delayMs) / 1000.0f;
-        float dps = ((info.damageMin + info.damageMax) * 0.5f) / speed;
-        ImGui::Text("%.0f - %.0f Damage", info.damageMin, info.damageMax);
-        ImGui::SameLine(160.0f);
-        ImGui::TextDisabled("Speed %.2f", speed);
-        ImGui::TextColored(ui::colors::kLightGray, "(%.1f damage per second)", dps);
-    }
-
-    if (info.armor > 0) ImGui::Text("%d Armor", info.armor);
-
-    // Elemental resistances (fire resist gear, nature resist gear, etc.)
-    {
-        const int32_t resVals[6]  = { info.holyRes, info.fireRes, info.natureRes,
-                                      info.frostRes, info.shadowRes, info.arcaneRes };
-        for (int i = 0; i < 6; ++i)
-            if (resVals[i] > 0) ImGui::Text("+%d %s", resVals[i], kResistNames[i]);
-    }
-
-    auto appendBonus = [](std::string& out, int32_t val, const char* name) {
-        if (val <= 0) return;
-        if (!out.empty()) out += "  ";
-        out += "+" + std::to_string(val) + " " + name;
-    };
-    std::string bonusLine;
-    appendBonus(bonusLine, info.strength,  "Str");
-    appendBonus(bonusLine, info.agility,   "Agi");
-    appendBonus(bonusLine, info.stamina,   "Sta");
-    appendBonus(bonusLine, info.intellect, "Int");
-    appendBonus(bonusLine, info.spirit,    "Spi");
-    if (!bonusLine.empty()) ImGui::TextColored(green, "%s", bonusLine.c_str());
-
-    // Extra stats
-    for (const auto& es : info.extraStats) {
-        const char* statName = nullptr;
-        switch (es.statType) {
-            case 12: statName = "Defense Rating"; break;
-            case 13: statName = "Dodge Rating"; break;
-            case 14: statName = "Parry Rating"; break;
-            case 16: case 17: case 18: case 31: statName = "Hit Rating"; break;
-            case 19: case 20: case 21: case 32: statName = "Crit Rating"; break;
-            case 28: case 29: case 30: case 36: statName = "Haste Rating"; break;
-            case 35: statName = "Resilience"; break;
-            case 37: statName = "Expertise Rating"; break;
-            case 38: statName = "Attack Power"; break;
-            case 39: statName = "Ranged Attack Power"; break;
-            case 41: statName = "Healing Power"; break;
-            case 42: statName = "Spell Damage"; break;
-            case 43: statName = "Mana per 5 sec"; break;
-            case 44: statName = "Armor Penetration"; break;
-            case 45: statName = "Spell Power"; break;
-            case 46: statName = "Health per 5 sec"; break;
-            case 47: statName = "Spell Penetration"; break;
-            case 48: statName = "Block Value"; break;
-            default: statName = nullptr; break;
-        }
-        char buf[64];
-        if (statName)
-            std::snprintf(buf, sizeof(buf), "%+d %s", es.statValue, statName);
-        else
-            std::snprintf(buf, sizeof(buf), "%+d (stat %u)", es.statValue, es.statType);
-        ImGui::TextColored(green, "%s", buf);
-    }
-
-    if (info.requiredLevel > 1) {
-        uint32_t playerLvl = gameHandler_ ? gameHandler_->getPlayerLevel() : 0;
-        bool meetsReq = (playerLvl >= info.requiredLevel);
-        ImVec4 reqColor = meetsReq ? ImVec4(1.0f, 1.0f, 1.0f, 0.75f) : ui::colors::kPaleRed;
-        ImGui::TextColored(reqColor, "Requires Level %u", info.requiredLevel);
-    }
-
-    // Required skill (e.g. "Requires Engineering (300)")
-    if (info.requiredSkill != 0 && info.requiredSkillRank > 0) {
-        // Lazy-load SkillLine.dbc names
-        static std::unordered_map<uint32_t, std::string> s_skillNames;
-        static bool s_skillNamesLoaded = false;
-        if (!s_skillNamesLoaded && assetManager_) {
-            s_skillNamesLoaded = true;
-            auto dbc = assetManager_->loadDBC("SkillLine.dbc");
-            if (dbc && dbc->isLoaded()) {
-                const auto* layout = pipeline::getActiveDBCLayout()
-                    ? pipeline::getActiveDBCLayout()->getLayout("SkillLine") : nullptr;
-                uint32_t idF   = layout ? (*layout)["ID"]   : 0;
-                uint32_t nameF = layout ? (*layout)["Name"] : 2;
-                for (uint32_t r = 0; r < dbc->getRecordCount(); ++r) {
-                    uint32_t sid = dbc->getUInt32(r, idF);
-                    if (!sid) continue;
-                    std::string sname = dbc->getString(r, nameF);
-                    if (!sname.empty()) s_skillNames[sid] = std::move(sname);
-                }
-            }
-        }
-        uint32_t playerSkillVal = 0;
-        if (gameHandler_) {
-            const auto& skills = gameHandler_->getPlayerSkills();
-            auto skPit = skills.find(info.requiredSkill);
-            if (skPit != skills.end()) playerSkillVal = skPit->second.effectiveValue();
-        }
-        bool meetsSkill = (playerSkillVal == 0 || playerSkillVal >= info.requiredSkillRank);
-        ImVec4 skColor = meetsSkill ? ImVec4(1.0f, 1.0f, 1.0f, 0.75f) : ui::colors::kPaleRed;
-        auto skIt = s_skillNames.find(info.requiredSkill);
-        if (skIt != s_skillNames.end())
-            ImGui::TextColored(skColor, "Requires %s (%u)", skIt->second.c_str(), info.requiredSkillRank);
-        else
-            ImGui::TextColored(skColor, "Requires Skill %u (%u)", info.requiredSkill, info.requiredSkillRank);
-    }
-
-    // Required reputation (e.g. "Requires Exalted with Argent Dawn")
-    if (info.requiredReputationFaction != 0 && info.requiredReputationRank > 0) {
-        static std::unordered_map<uint32_t, std::string> s_factionNames;
-        static bool s_factionNamesLoaded = false;
-        if (!s_factionNamesLoaded && assetManager_) {
-            s_factionNamesLoaded = true;
-            auto dbc = assetManager_->loadDBC("Faction.dbc");
-            if (dbc && dbc->isLoaded()) {
-                const auto* layout = pipeline::getActiveDBCLayout()
-                    ? pipeline::getActiveDBCLayout()->getLayout("Faction") : nullptr;
-                uint32_t idF   = layout ? (*layout)["ID"]   : 0;
-                uint32_t nameF = layout ? (*layout)["Name"] : 20;
-                for (uint32_t r = 0; r < dbc->getRecordCount(); ++r) {
-                    uint32_t fid = dbc->getUInt32(r, idF);
-                    if (!fid) continue;
-                    std::string fname = dbc->getString(r, nameF);
-                    if (!fname.empty()) s_factionNames[fid] = std::move(fname);
-                }
-            }
-        }
-        const char* rankName = (info.requiredReputationRank < 8)
-            ? kRepRankNames[info.requiredReputationRank] : "Unknown";
-        auto fIt = s_factionNames.find(info.requiredReputationFaction);
-        ImGui::TextColored(ImVec4(1.0f, 1.0f, 1.0f, 0.75f), "Requires %s with %s",
-            rankName,
-            fIt != s_factionNames.end() ? fIt->second.c_str() : "Unknown Faction");
-    }
-
-    if (info.allowableClass != 0 && gameHandler_)
-        renderClassRestriction(info.allowableClass, gameHandler_->getPlayerClass());
-    if (info.allowableRace != 0 && gameHandler_)
-        renderRaceRestriction(info.allowableRace, gameHandler_->getPlayerRace());
-
-    // Spell effects
-    for (const auto& sp : info.spells) {
-        if (sp.spellId == 0) continue;
-        const char* trigger = nullptr;
-        switch (sp.spellTrigger) {
-            case 0: trigger = "Use"; break;        // on use
-            case 1: trigger = "Equip"; break;      // on equip
-            case 2: trigger = "Chance on Hit"; break; // proc on melee hit
-            case 4: trigger = "Use"; break;        // soulstone (still shows as Use)
-            case 5: trigger = "Use"; break;        // on use, no delay
-            case 6: trigger = "Use"; break;        // learn spell (recipe/pattern)
-            default: break;
-        }
-        if (!trigger) continue;
-        if (gameHandler_) {
-            // Prefer the spell's tooltip text (the actual effect description).
-            // Fall back to the spell name if the description is empty.
-            const std::string& spDesc = gameHandler_->getSpellDescription(sp.spellId);
-            const std::string& spName = spDesc.empty() ? gameHandler_->getSpellName(sp.spellId) : spDesc;
-            if (!spName.empty()) {
-                ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + 320.0f);
-                ImGui::TextColored(ui::colors::kCyan, "%s: %s", trigger, spName.c_str());
-                ImGui::PopTextWrapPos();
-            } else {
-                ImGui::TextColored(ui::colors::kCyan, "%s: Spell #%u", trigger, sp.spellId);
-            }
-        }
-    }
-
-    // Gem socket slots
-    {
-        // Get socket gem enchant IDs for this item (filled from item update fields)
-        std::array<uint32_t, 3> sockGems{};
-        if (itemGuid != 0 && gameHandler_)
-            sockGems = gameHandler_->getItemSocketEnchantIds(itemGuid);
-
-        bool hasSocket = false;
-        for (int i = 0; i < 3; ++i) {
-            if (info.socketColor[i] == 0) continue;
-            if (!hasSocket) { ImGui::Spacing(); hasSocket = true; }
-            for (const auto& st : kSocketTypes) {
-                if (info.socketColor[i] & st.mask) {
-                    if (sockGems[i] != 0) {
-                        auto git = s_enchLookup.find(sockGems[i]);
-                        if (git != s_enchLookup.end())
-                            ImGui::TextColored(st.col, "%s: %s", st.label, git->second.c_str());
-                        else
-                            ImGui::TextColored(st.col, "%s: (gem %u)", st.label, sockGems[i]);
-                    } else {
-                        ImGui::TextColored(st.col, "%s", st.label);
-                    }
-                    break;
-                }
-            }
-        }
-        if (hasSocket && info.socketBonus != 0) {
-            auto enchIt = s_enchLookup.find(info.socketBonus);
-            if (enchIt != s_enchLookup.end())
-                ImGui::TextColored(ui::colors::kSocketGreen, "Socket Bonus: %s", enchIt->second.c_str());
-            else
-                ImGui::TextColored(ui::colors::kSocketGreen, "Socket Bonus: (id %u)", info.socketBonus);
-        }
-    }
-
-    // Weapon/armor enchant display for equipped items
-    if (itemGuid != 0 && gameHandler_) {
-        auto [permId, tempId] = gameHandler_->getItemEnchantIds(itemGuid);
-        if (permId != 0) {
-            auto it2 = s_enchLookup.find(permId);
-            const char* ename = (it2 != s_enchLookup.end()) ? it2->second.c_str() : nullptr;
-            if (ename) ImGui::TextColored(ui::colors::kCyan, "Enchanted: %s", ename);
-        }
-        if (tempId != 0) {
-            auto it2 = s_enchLookup.find(tempId);
-            const char* ename = (it2 != s_enchLookup.end()) ? it2->second.c_str() : nullptr;
-            if (ename) ImGui::TextColored(ImVec4(0.8f, 1.0f, 0.4f, 1.0f), "%s (temporary)", ename);
-        }
-    }
-
-    // Item set membership
-    if (info.itemSetId != 0) {
-        // Lazy-load full ItemSet.dbc data (name + item IDs + bonus spells/thresholds)
-        struct SetEntry {
-            std::string name;
-            std::array<uint32_t, 10> itemIds{};
-            std::array<uint32_t, 10> spellIds{};
-            std::array<uint32_t, 10> thresholds{};
-        };
-        static std::unordered_map<uint32_t, SetEntry> s_setData;
-        static bool s_setDataLoaded = false;
-        if (!s_setDataLoaded && assetManager_) {
-            s_setDataLoaded = true;
-            auto dbc = assetManager_->loadDBC("ItemSet.dbc");
-            if (dbc && dbc->isLoaded()) {
-                const auto* layout = pipeline::getActiveDBCLayout()
-                    ? pipeline::getActiveDBCLayout()->getLayout("ItemSet") : nullptr;
-                auto lf = [&](const char* k, uint32_t def) -> uint32_t {
-                    return layout ? (*layout)[k] : def;
-                };
-                uint32_t idF = lf("ID", 0), nameF = lf("Name", 1);
-                const auto& itemKeys = ui::kItemSetItemKeys;
-                const auto& spellKeys = ui::kItemSetSpellKeys;
-                const auto& thrKeys = ui::kItemSetThresholdKeys;
-                uint32_t itemFallback[10], spellFallback[10], thrFallback[10];
-                for (int i = 0; i < 10; ++i) {
-                    itemFallback[i]  = 18 + i;
-                    spellFallback[i] = 28 + i;
-                    thrFallback[i]   = 38 + i;
-                }
-                for (uint32_t r = 0; r < dbc->getRecordCount(); ++r) {
-                    uint32_t id = dbc->getUInt32(r, idF);
-                    if (!id) continue;
-                    SetEntry e;
-                    e.name = dbc->getString(r, nameF);
-                    for (int i = 0; i < 10; ++i) {
-                        e.itemIds[i]    = dbc->getUInt32(r, layout ? (*layout)[itemKeys[i]]  : itemFallback[i]);
-                        e.spellIds[i]   = dbc->getUInt32(r, layout ? (*layout)[spellKeys[i]] : spellFallback[i]);
-                        e.thresholds[i] = dbc->getUInt32(r, layout ? (*layout)[thrKeys[i]]   : thrFallback[i]);
-                    }
-                    s_setData[id] = std::move(e);
-                }
-            }
-        }
-
-        auto setIt = s_setData.find(info.itemSetId);
-        ImGui::Spacing();
-        if (setIt != s_setData.end()) {
-            const SetEntry& se = setIt->second;
-            // Count equipped pieces
-            int equipped = 0, total = 0;
-            for (int i = 0; i < 10; ++i) {
-                if (se.itemIds[i] == 0) continue;
-                ++total;
-                if (inventory) {
-                    for (int s = 0; s < game::Inventory::NUM_EQUIP_SLOTS; s++) {
-                        const auto& eSlot = inventory->getEquipSlot(static_cast<game::EquipSlot>(s));
-                        if (!eSlot.empty() && eSlot.item.itemId == se.itemIds[i]) { ++equipped; break; }
-                    }
-                }
-            }
-            if (total > 0) {
-                ImGui::TextColored(ui::colors::kTooltipGold,
-                    "%s (%d/%d)", se.name.empty() ? "Set" : se.name.c_str(), equipped, total);
-            } else {
-                if (!se.name.empty())
-                    ImGui::TextColored(ui::colors::kTooltipGold, "%s", se.name.c_str());
-            }
-            // Show set bonuses: gray if not reached, green if active
-            if (gameHandler_) {
-                for (int i = 0; i < 10; ++i) {
-                    if (se.spellIds[i] == 0 || se.thresholds[i] == 0) continue;
-                    const std::string& bname = gameHandler_->getSpellName(se.spellIds[i]);
-                    bool active = (equipped >= static_cast<int>(se.thresholds[i]));
-                    ImVec4 col = active ? ui::colors::kActiveGreen
-                                       : ui::colors::kInactiveGray;
-                    if (!bname.empty())
-                        ImGui::TextColored(col, "(%u) %s", se.thresholds[i], bname.c_str());
-                    else
-                        ImGui::TextColored(col, "(%u) Set Bonus", se.thresholds[i]);
-                }
-            }
-        } else {
-            ImGui::TextColored(ui::colors::kTooltipGold, "Set (id %u)", info.itemSetId);
-        }
-    }
-
-    if (info.startQuestId != 0) {
-        ImGui::TextColored(ui::colors::kTooltipGold, "Begins a Quest");
-    }
-    if (!info.description.empty()) {
-        ImGui::TextColored(ImVec4(1.0f, 0.9f, 0.5f, 0.9f), "\"%s\"", info.description.c_str());
-    }
-
-    if (info.sellPrice > 0) {
-        ImGui::TextDisabled("Sell:"); ImGui::SameLine(0, 4);
-        renderCoinsFromCopper(info.sellPrice);
-    }
-
-    // Shift-hover: compare with currently equipped item
-    if (inventory && ImGui::GetIO().KeyShift && info.inventoryType > 0) {
-        if (const game::ItemSlot* eq = findComparableEquipped(*inventory, static_cast<uint8_t>(info.inventoryType))) {
-            ImGui::Separator();
-            ImGui::TextDisabled("Equipped:");
-            VkDescriptorSet eqIcon = getItemIcon(eq->item.displayInfoId);
-            if (eqIcon) { ImGui::Image((ImTextureID)(uintptr_t)eqIcon, ImVec2(18.0f, 18.0f)); ImGui::SameLine(); }
-            ImGui::TextColored(getQualityColor(eq->item.quality), "%s", eq->item.name.c_str());
-
-            auto showDiff = [](const char* label, float nv, float ev) {
-                if (nv == 0.0f && ev == 0.0f) return;
-                float diff = nv - ev;
-                char buf[96];
-                if (diff > 0.0f) { std::snprintf(buf, sizeof(buf), "%s: %.0f (▲%.0f)", label, nv, diff);  ImGui::TextColored(ImVec4(0.0f,1.0f,0.0f,1.0f), "%s", buf); }
-                else if (diff < 0.0f) { std::snprintf(buf, sizeof(buf), "%s: %.0f (▼%.0f)", label, nv, -diff); ImGui::TextColored(ui::colors::kRed, "%s", buf); }
-                else { std::snprintf(buf, sizeof(buf), "%s: %.0f (=)", label, nv); ImGui::TextColored(ui::colors::kLightGray, "%s", buf); }
-            };
-
-            float ilvlDiff = static_cast<float>(info.itemLevel) - static_cast<float>(eq->item.itemLevel);
-            if (info.itemLevel > 0 || eq->item.itemLevel > 0) {
-                char ilvlBuf[64];
-                if (ilvlDiff > 0)      std::snprintf(ilvlBuf, sizeof(ilvlBuf), "Item Level: %u (▲%.0f)", info.itemLevel, ilvlDiff);
-                else if (ilvlDiff < 0) std::snprintf(ilvlBuf, sizeof(ilvlBuf), "Item Level: %u (▼%.0f)", info.itemLevel, -ilvlDiff);
-                else                   std::snprintf(ilvlBuf, sizeof(ilvlBuf), "Item Level: %u (=)", info.itemLevel);
-                ImVec4 ic = ilvlDiff > 0 ? ImVec4(0,1,0,1) : ilvlDiff < 0 ? ImVec4(1,0.3f,0.3f,1) : ImVec4(0.7f,0.7f,0.7f,1);
-                ImGui::TextColored(ic, "%s", ilvlBuf);
-            }
-
-            // DPS comparison for weapons
-            if (isWeaponInvType(info.inventoryType) && isWeaponInvType(eq->item.inventoryType)) {
-                float newDps = 0.0f, eqDps = 0.0f;
-                if (info.damageMax > 0.0f && info.delayMs > 0)
-                    newDps = ((info.damageMin + info.damageMax) * 0.5f) / (info.delayMs / 1000.0f);
-                if (eq->item.damageMax > 0.0f && eq->item.delayMs > 0)
-                    eqDps = ((eq->item.damageMin + eq->item.damageMax) * 0.5f) / (eq->item.delayMs / 1000.0f);
-                showDiff("DPS", newDps, eqDps);
-            }
-
-            showDiff("Armor", static_cast<float>(info.armor),     static_cast<float>(eq->item.armor));
-            showDiff("Str",   static_cast<float>(info.strength),  static_cast<float>(eq->item.strength));
-            showDiff("Agi",   static_cast<float>(info.agility),   static_cast<float>(eq->item.agility));
-            showDiff("Sta",   static_cast<float>(info.stamina),   static_cast<float>(eq->item.stamina));
-            showDiff("Int",   static_cast<float>(info.intellect), static_cast<float>(eq->item.intellect));
-            showDiff("Spi",   static_cast<float>(info.spirit),    static_cast<float>(eq->item.spirit));
-
-            // Extra stats diff — union of stat types from both items
-            auto findExtraStat = [](const auto& it, uint32_t type) -> int32_t {
-                for (const auto& es : it.extraStats)
-                    if (es.statType == type) return es.statValue;
-                return 0;
-            };
-            std::vector<uint32_t> allTypes;
-            for (const auto& es : info.extraStats) allTypes.push_back(es.statType);
-            for (const auto& es : eq->item.extraStats) {
-                bool found = false;
-                for (uint32_t t : allTypes) if (t == es.statType) { found = true; break; }
-                if (!found) allTypes.push_back(es.statType);
-            }
-            for (uint32_t t : allTypes) {
-                int32_t nv = findExtraStat(info, t);
-                int32_t ev = findExtraStat(eq->item, t);
-                const char* lbl = nullptr;
-                switch (t) {
-                    case 0:  lbl = "Mana"; break;
-                    case 1:  lbl = "Health"; break;
-                    case 12: lbl = "Defense"; break;
-                    case 13: lbl = "Dodge"; break;
-                    case 14: lbl = "Parry"; break;
-                    case 15: lbl = "Block Rating"; break;
-                    case 16: case 17: case 18: case 31: lbl = "Hit"; break;
-                    case 19: case 20: case 21: case 32: lbl = "Crit"; break;
-                    case 28: case 29: case 30: case 36: lbl = "Haste"; break;
-                    case 35: lbl = "Resilience"; break;
-                    case 37: lbl = "Expertise"; break;
-                    case 38: lbl = "Attack Power"; break;
-                    case 39: lbl = "Ranged AP"; break;
-                    case 41: lbl = "Healing"; break;
-                    case 42: lbl = "Spell Damage"; break;
-                    case 43: lbl = "MP5"; break;
-                    case 44: lbl = "Armor Pen"; break;
-                    case 45: lbl = "Spell Power"; break;
-                    case 46: lbl = "HP5"; break;
-                    case 47: lbl = "Spell Pen"; break;
-                    case 48: lbl = "Block Value"; break;
-                    default: lbl = nullptr; break;
-                }
-                if (!lbl) continue;
-                showDiff(lbl, static_cast<float>(nv), static_cast<float>(ev));
-            }
-        }
-    } else if (info.inventoryType > 0) {
-        ImGui::TextDisabled("Hold Shift to compare");
     }
 
     ImGui::EndTooltip();
diff --git a/src/ui/keybinding_manager.cpp b/src/ui/keybinding_manager.cpp
deleted file mode 100644
index c7a7737f..00000000
--- a/src/ui/keybinding_manager.cpp
+++ /dev/null
@@ -1,316 +0,0 @@
-#include "ui/keybinding_manager.hpp"
-#include "core/logger.hpp"
-#include <fstream>
-#include <sstream>
-
-namespace wowee::ui {
-
-static bool isReservedMovementKey(ImGuiKey key) {
-    return key == ImGuiKey_W || key == ImGuiKey_A || key == ImGuiKey_S ||
-           key == ImGuiKey_D || key == ImGuiKey_Q || key == ImGuiKey_E;
-}
-
-KeybindingManager& KeybindingManager::getInstance() {
-    static KeybindingManager instance;
-    return instance;
-}
-
-KeybindingManager::KeybindingManager() {
-    initializeDefaults();
-}
-
-void KeybindingManager::initializeDefaults() {
-    // Set default keybindings
-    bindings_[static_cast<int>(Action::TOGGLE_CHARACTER_SCREEN)] = ImGuiKey_C;
-    bindings_[static_cast<int>(Action::TOGGLE_INVENTORY)] = ImGuiKey_I;
-    bindings_[static_cast<int>(Action::TOGGLE_BAGS)] = ImGuiKey_B;
-    bindings_[static_cast<int>(Action::TOGGLE_SPELLBOOK)] = ImGuiKey_P;  // WoW standard key
-    bindings_[static_cast<int>(Action::TOGGLE_TALENTS)] = ImGuiKey_N;     // WoW standard key
-    bindings_[static_cast<int>(Action::TOGGLE_QUESTS)] = ImGuiKey_L;
-    bindings_[static_cast<int>(Action::TOGGLE_MINIMAP)] = ImGuiKey_None;  // minimap is always visible; no default toggle
-    bindings_[static_cast<int>(Action::TOGGLE_SETTINGS)] = ImGuiKey_Escape;
-    bindings_[static_cast<int>(Action::TOGGLE_CHAT)] = ImGuiKey_Enter;
-    bindings_[static_cast<int>(Action::TOGGLE_GUILD_ROSTER)] = ImGuiKey_O;
-    bindings_[static_cast<int>(Action::TOGGLE_DUNGEON_FINDER)] = ImGuiKey_J;  // Originally I, reassigned to avoid conflict
-    bindings_[static_cast<int>(Action::TOGGLE_WORLD_MAP)] = ImGuiKey_M;  // WoW standard: M opens world map
-    bindings_[static_cast<int>(Action::TOGGLE_NAMEPLATES)] = ImGuiKey_V;
-    bindings_[static_cast<int>(Action::TOGGLE_RAID_FRAMES)] = ImGuiKey_F;  // Reassigned from R (now camera reset)
-    bindings_[static_cast<int>(Action::TOGGLE_ACHIEVEMENTS)] = ImGuiKey_Y;  // WoW standard key (Shift+Y in retail)
-    bindings_[static_cast<int>(Action::TOGGLE_SKILLS)]      = ImGuiKey_K;  // WoW standard: K opens Skills/Professions
-}
-
-bool KeybindingManager::isActionPressed(Action action, bool repeat) {
-    auto it = bindings_.find(static_cast<int>(action));
-    if (it == bindings_.end()) return false;
-    ImGuiKey key = it->second;
-    if (key == ImGuiKey_None) return false;
-
-    // When typing in a text field (e.g. chat input), never treat A-Z or 0-9 as shortcuts.
-    const ImGuiIO& io = ImGui::GetIO();
-    if (io.WantTextInput) {
-        if ((key >= ImGuiKey_A && key <= ImGuiKey_Z) ||
-            (key >= ImGuiKey_0 && key <= ImGuiKey_9)) {
-            return false;
-        }
-    }
-
-    return ImGui::IsKeyPressed(key, repeat);
-}
-
-ImGuiKey KeybindingManager::getKeyForAction(Action action) const {
-    auto it = bindings_.find(static_cast<int>(action));
-    if (it == bindings_.end()) return ImGuiKey_None;
-    return it->second;
-}
-
-void KeybindingManager::setKeyForAction(Action action, ImGuiKey key) {
-    // Reserve movement keys so they cannot be used as UI shortcuts.
-    (void)action;
-    if (isReservedMovementKey(key)) {
-        key = ImGuiKey_None;
-    }
-    bindings_[static_cast<int>(action)] = key;
-}
-
-void KeybindingManager::resetToDefaults() {
-    bindings_.clear();
-    initializeDefaults();
-}
-
-const char* KeybindingManager::getActionName(Action action) {
-    switch (action) {
-        case Action::TOGGLE_CHARACTER_SCREEN: return "Character Screen";
-        case Action::TOGGLE_INVENTORY: return "Inventory";
-        case Action::TOGGLE_BAGS: return "Bags";
-        case Action::TOGGLE_SPELLBOOK: return "Spellbook";
-        case Action::TOGGLE_TALENTS: return "Talents";
-        case Action::TOGGLE_QUESTS: return "Quests";
-        case Action::TOGGLE_MINIMAP: return "Minimap";
-        case Action::TOGGLE_SETTINGS: return "Settings";
-        case Action::TOGGLE_CHAT: return "Chat";
-        case Action::TOGGLE_GUILD_ROSTER: return "Guild Roster / Social";
-        case Action::TOGGLE_DUNGEON_FINDER: return "Dungeon Finder";
-        case Action::TOGGLE_WORLD_MAP: return "World Map";
-        case Action::TOGGLE_NAMEPLATES: return "Nameplates";
-        case Action::TOGGLE_RAID_FRAMES: return "Raid Frames";
-        case Action::TOGGLE_ACHIEVEMENTS: return "Achievements";
-        case Action::TOGGLE_SKILLS: return "Skills / Professions";
-        case Action::ACTION_COUNT: break;
-    }
-    return "Unknown";
-}
-
-void KeybindingManager::loadFromConfigFile(const std::string& filePath) {
-    std::ifstream file(filePath);
-    if (!file.is_open()) {
-        LOG_ERROR("KeybindingManager: Failed to open config file: ", filePath);
-        return;
-    }
-
-    std::string line;
-    bool inKeybindingsSection = false;
-
-    while (std::getline(file, line)) {
-        // Trim whitespace
-        size_t start = line.find_first_not_of(" \t\r\n");
-        size_t end = line.find_last_not_of(" \t\r\n");
-        if (start == std::string::npos) continue;
-        line = line.substr(start, end - start + 1);
-
-        // Check for section header
-        if (line == "[Keybindings]") {
-            inKeybindingsSection = true;
-            continue;
-        } else if (line[0] == '[') {
-            inKeybindingsSection = false;
-            continue;
-        }
-
-        if (!inKeybindingsSection || line.empty() || line[0] == ';' || line[0] == '#') continue;
-
-        // Parse key=value pair
-        size_t eqPos = line.find('=');
-        if (eqPos == std::string::npos) continue;
-
-        std::string action = line.substr(0, eqPos);
-        std::string keyStr = line.substr(eqPos + 1);
-
-        // Trim key string
-        size_t kStart = keyStr.find_first_not_of(" \t");
-        size_t kEnd = keyStr.find_last_not_of(" \t");
-        if (kStart != std::string::npos) {
-            keyStr = keyStr.substr(kStart, kEnd - kStart + 1);
-        }
-
-        // Map action name to enum (simplified mapping)
-        int actionIdx = -1;
-        if (action == "toggle_character_screen") actionIdx = static_cast<int>(Action::TOGGLE_CHARACTER_SCREEN);
-        else if (action == "toggle_inventory") actionIdx = static_cast<int>(Action::TOGGLE_INVENTORY);
-        else if (action == "toggle_bags") actionIdx = static_cast<int>(Action::TOGGLE_BAGS);
-        else if (action == "toggle_spellbook") actionIdx = static_cast<int>(Action::TOGGLE_SPELLBOOK);
-        else if (action == "toggle_talents") actionIdx = static_cast<int>(Action::TOGGLE_TALENTS);
-        else if (action == "toggle_quests") actionIdx = static_cast<int>(Action::TOGGLE_QUESTS);
-        else if (action == "toggle_minimap") actionIdx = static_cast<int>(Action::TOGGLE_MINIMAP);
-        else if (action == "toggle_settings") actionIdx = static_cast<int>(Action::TOGGLE_SETTINGS);
-        else if (action == "toggle_chat") actionIdx = static_cast<int>(Action::TOGGLE_CHAT);
-        else if (action == "toggle_guild_roster") actionIdx = static_cast<int>(Action::TOGGLE_GUILD_ROSTER);
-        else if (action == "toggle_dungeon_finder") actionIdx = static_cast<int>(Action::TOGGLE_DUNGEON_FINDER);
-        else if (action == "toggle_world_map") actionIdx = static_cast<int>(Action::TOGGLE_WORLD_MAP);
-        else if (action == "toggle_nameplates") actionIdx = static_cast<int>(Action::TOGGLE_NAMEPLATES);
-        else if (action == "toggle_raid_frames") actionIdx = static_cast<int>(Action::TOGGLE_RAID_FRAMES);
-        else if (action == "toggle_quest_log") actionIdx = static_cast<int>(Action::TOGGLE_QUESTS);  // legacy alias
-        else if (action == "toggle_achievements") actionIdx = static_cast<int>(Action::TOGGLE_ACHIEVEMENTS);
-        else if (action == "toggle_skills") actionIdx = static_cast<int>(Action::TOGGLE_SKILLS);
-
-        if (actionIdx < 0) continue;
-
-        // Parse key string to ImGuiKey (simple mapping of common keys)
-        ImGuiKey key = ImGuiKey_None;
-        if (keyStr.length() == 1) {
-            // Single character key (A-Z, 0-9)
-            char c = keyStr[0];
-            if (c >= 'A' && c <= 'Z') {
-                key = static_cast<ImGuiKey>(ImGuiKey_A + (c - 'A'));
-            } else if (c >= '0' && c <= '9') {
-                key = static_cast<ImGuiKey>(ImGuiKey_0 + (c - '0'));
-            }
-        } else if (keyStr == "Escape") {
-            key = ImGuiKey_Escape;
-        } else if (keyStr == "Enter") {
-            key = ImGuiKey_Enter;
-        } else if (keyStr == "Tab") {
-            key = ImGuiKey_Tab;
-        } else if (keyStr == "Backspace") {
-            key = ImGuiKey_Backspace;
-        } else if (keyStr == "Space") {
-            key = ImGuiKey_Space;
-        } else if (keyStr == "Delete") {
-            key = ImGuiKey_Delete;
-        } else if (keyStr == "Home") {
-            key = ImGuiKey_Home;
-        } else if (keyStr == "End") {
-            key = ImGuiKey_End;
-        } else if (keyStr.find("F") == 0 && keyStr.length() <= 3) {
-            // F1-F12 keys
-            try {
-                int fNum = std::stoi(keyStr.substr(1));
-                if (fNum >= 1 && fNum <= 12) {
-                    key = static_cast<ImGuiKey>(ImGuiKey_F1 + (fNum - 1));
-                }
-            } catch (...) {}
-        }
-
-        if (key == ImGuiKey_None) continue;
-
-        // Reserve movement keys so they cannot be used as UI shortcuts.
-        if (isReservedMovementKey(key)) {
-            continue;
-        }
-
-        bindings_[actionIdx] = key;
-    }
-
-    file.close();
-    LOG_INFO("KeybindingManager: Loaded keybindings from ", filePath);
-}
-
-void KeybindingManager::saveToConfigFile(const std::string& filePath) const {
-    std::ifstream inFile(filePath);
-    std::string content;
-    std::string line;
-
-    // Read existing file, removing [Keybindings] section if it exists
-    bool inKeybindingsSection = false;
-    if (inFile.is_open()) {
-        while (std::getline(inFile, line)) {
-            if (line == "[Keybindings]") {
-                inKeybindingsSection = true;
-                continue;
-            } else if (line[0] == '[') {
-                inKeybindingsSection = false;
-            }
-
-            if (!inKeybindingsSection) {
-                content += line + "\n";
-            }
-        }
-        inFile.close();
-    }
-
-    // Append new Keybindings section
-    content += "[Keybindings]\n";
-
-    static constexpr struct {
-        Action action;
-        const char* name;
-    } actionMap[] = {
-        {Action::TOGGLE_CHARACTER_SCREEN, "toggle_character_screen"},
-        {Action::TOGGLE_INVENTORY, "toggle_inventory"},
-        {Action::TOGGLE_BAGS, "toggle_bags"},
-        {Action::TOGGLE_SPELLBOOK, "toggle_spellbook"},
-        {Action::TOGGLE_TALENTS, "toggle_talents"},
-        {Action::TOGGLE_QUESTS, "toggle_quests"},
-        {Action::TOGGLE_MINIMAP, "toggle_minimap"},
-        {Action::TOGGLE_SETTINGS, "toggle_settings"},
-        {Action::TOGGLE_CHAT, "toggle_chat"},
-        {Action::TOGGLE_GUILD_ROSTER, "toggle_guild_roster"},
-        {Action::TOGGLE_DUNGEON_FINDER, "toggle_dungeon_finder"},
-        {Action::TOGGLE_WORLD_MAP, "toggle_world_map"},
-        {Action::TOGGLE_NAMEPLATES, "toggle_nameplates"},
-        {Action::TOGGLE_RAID_FRAMES, "toggle_raid_frames"},
-        {Action::TOGGLE_ACHIEVEMENTS, "toggle_achievements"},
-        {Action::TOGGLE_SKILLS, "toggle_skills"},
-    };
-
-    for (const auto& [action, nameStr] : actionMap) {
-        auto it = bindings_.find(static_cast<int>(action));
-        if (it == bindings_.end()) continue;
-
-        ImGuiKey key = it->second;
-        std::string keyStr;
-
-        // Convert ImGuiKey to string
-        if (key >= ImGuiKey_A && key <= ImGuiKey_Z) {
-            keyStr += static_cast<char>('A' + (key - ImGuiKey_A));
-        } else if (key >= ImGuiKey_0 && key <= ImGuiKey_9) {
-            keyStr += static_cast<char>('0' + (key - ImGuiKey_0));
-        } else if (key == ImGuiKey_Escape) {
-            keyStr = "Escape";
-        } else if (key == ImGuiKey_Enter) {
-            keyStr = "Enter";
-        } else if (key == ImGuiKey_Tab) {
-            keyStr = "Tab";
-        } else if (key == ImGuiKey_Backspace) {
-            keyStr = "Backspace";
-        } else if (key == ImGuiKey_Space) {
-            keyStr = "Space";
-        } else if (key == ImGuiKey_Delete) {
-            keyStr = "Delete";
-        } else if (key == ImGuiKey_Home) {
-            keyStr = "Home";
-        } else if (key == ImGuiKey_End) {
-            keyStr = "End";
-        } else if (key >= ImGuiKey_F1 && key <= ImGuiKey_F12) {
-            keyStr = "F" + std::to_string(1 + (key - ImGuiKey_F1));
-        }
-
-        if (!keyStr.empty()) {
-            content += nameStr;
-            content += "=";
-            content += keyStr;
-            content += "\n";
-        }
-    }
-
-    // Write back to file
-    std::ofstream outFile(filePath);
-    if (outFile.is_open()) {
-        outFile << content;
-        outFile.close();
-        LOG_INFO("KeybindingManager: Saved keybindings to ", filePath);
-    } else {
-        LOG_ERROR("KeybindingManager: Failed to write config file: ", filePath);
-    }
-}
-
-}  // namespace wowee::ui
diff --git a/src/ui/quest_log_screen.cpp b/src/ui/quest_log_screen.cpp
index 1ce53ed7..ad7df081 100644
--- a/src/ui/quest_log_screen.cpp
+++ b/src/ui/quest_log_screen.cpp
@@ -1,7 +1,4 @@
 #include "ui/quest_log_screen.hpp"
-#include "ui/ui_colors.hpp"
-#include "ui/inventory_screen.hpp"
-#include "ui/keybinding_manager.hpp"
 #include "core/application.hpp"
 #include "core/input.hpp"
 #include <imgui.h>
@@ -35,6 +32,7 @@ std::string replaceGenderPlaceholders(const std::string& text, game::GameHandler
 
     // Replace $g placeholders
     size_t pos = 0;
+    pos = 0;
     while ((pos = result.find('$', pos)) != std::string::npos) {
         if (pos + 1 >= result.length()) break;
         char marker = result[pos + 1];
@@ -82,14 +80,6 @@ std::string replaceGenderPlaceholders(const std::string& text, game::GameHandler
         pos += replacement.length();
     }
 
-    // Resolve class and race names for $C and $R placeholders
-    std::string className = "Adventurer";
-    std::string raceName = "Unknown";
-    if (character) {
-        className = game::getClassName(character->characterClass);
-        raceName = game::getRaceName(character->race);
-    }
-
     // Replace simple placeholders
     pos = 0;
     while ((pos = result.find('$', pos)) != std::string::npos) {
@@ -100,12 +90,11 @@ std::string replaceGenderPlaceholders(const std::string& text, game::GameHandler
 
         switch (code) {
             case 'n': case 'N': replacement = playerName; break;
-            case 'c': case 'C': replacement = className; break;
-            case 'r': case 'R': replacement = raceName; break;
             case 'p': replacement = pronouns.subject; break;
             case 'o': replacement = pronouns.object; break;
             case 's': replacement = pronouns.possessive; break;
             case 'S': replacement = pronouns.possessiveP; break;
+            case 'r': replacement = pronouns.object; break;
             case 'b': case 'B': replacement = "\n"; break;
             case 'g': case 'G': pos++; continue;
             default: pos++; continue;
@@ -214,18 +203,16 @@ std::string cleanQuestTitleForUi(const std::string& raw, uint32_t questId) {
     if (s.size() > 72) s = s.substr(0, 72) + "...";
     return s;
 }
-
 } // anonymous namespace
 
-void QuestLogScreen::render(game::GameHandler& gameHandler, InventoryScreen& invScreen) {
-    // Quests toggle via keybinding (edge-triggered)
-    // Customizable key (default: L) from KeybindingManager
-    bool questsDown = KeybindingManager::getInstance().isActionPressed(
-        KeybindingManager::Action::TOGGLE_QUESTS, false);
-    if (questsDown && !lKeyWasDown) {
+void QuestLogScreen::render(game::GameHandler& gameHandler) {
+    // L key toggle (edge-triggered)
+    ImGuiIO& io = ImGui::GetIO();
+    bool lDown = !io.WantTextInput && core::Input::getInstance().isKeyPressed(SDL_SCANCODE_L);
+    if (lDown && !lKeyWasDown) {
         open = !open;
     }
-    lKeyWasDown = questsDown;
+    lKeyWasDown = lDown;
 
     if (!open) return;
 
@@ -258,17 +245,6 @@ void QuestLogScreen::render(game::GameHandler& gameHandler, InventoryScreen& inv
             else activeCount++;
         }
 
-        // Search bar + filter buttons on one row
-        ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x - 210.0f);
-        ImGui::InputTextWithHint("##qsearch", "Search quests...", questSearchFilter_, sizeof(questSearchFilter_));
-        ImGui::SameLine();
-        if (ImGui::RadioButton("All", questFilterMode_ == 0))     questFilterMode_ = 0;
-        ImGui::SameLine();
-        if (ImGui::RadioButton("Active", questFilterMode_ == 1))  questFilterMode_ = 1;
-        ImGui::SameLine();
-        if (ImGui::RadioButton("Ready", questFilterMode_ == 2))   questFilterMode_ = 2;
-
-        // Summary counts
         ImGui::TextColored(ImVec4(0.95f, 0.85f, 0.35f, 1.0f), "Active: %d", activeCount);
         ImGui::SameLine();
         ImGui::TextColored(ImVec4(0.45f, 0.95f, 0.45f, 1.0f), "Ready: %d", completeCount);
@@ -285,42 +261,8 @@ void QuestLogScreen::render(game::GameHandler& gameHandler, InventoryScreen& inv
             ImGui::BeginChild("QuestListPane", ImVec2(paneW, 0), true);
             ImGui::TextColored(ImVec4(0.85f, 0.82f, 0.74f, 1.0f), "Quest List");
             ImGui::Separator();
-
-            // Resolve pending select from tracker click
-            if (pendingSelectQuestId_ != 0) {
-                for (size_t i = 0; i < quests.size(); i++) {
-                    if (quests[i].questId == pendingSelectQuestId_) {
-                        selectedIndex = static_cast<int>(i);
-                        // Clear filter so the target quest is visible
-                        questSearchFilter_[0] = '\0';
-                        questFilterMode_ = 0;
-                        break;
-                    }
-                }
-                pendingSelectQuestId_ = 0;
-            }
-
-            // Build a case-insensitive lowercase copy of the search filter once
-            char filterLower[64] = {};
-            for (size_t fi = 0; fi < sizeof(questSearchFilter_) && questSearchFilter_[fi]; ++fi)
-                filterLower[fi] = static_cast<char>(std::tolower(static_cast<unsigned char>(questSearchFilter_[fi])));
-
-            int visibleQuestCount = 0;
             for (size_t i = 0; i < quests.size(); i++) {
                 const auto& q = quests[i];
-
-                // Apply mode filter
-                if (questFilterMode_ == 1 && q.complete) continue;
-                if (questFilterMode_ == 2 && !q.complete) continue;
-
-                // Apply name search filter
-                if (filterLower[0]) {
-                    std::string titleLower = cleanQuestTitleForUi(q.title, q.questId);
-                    for (char& c : titleLower) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                    if (titleLower.find(filterLower) == std::string::npos) continue;
-                }
-
-                visibleQuestCount++;
                 ImGui::PushID(static_cast<int>(i));
 
                 bool selected = (selectedIndex == static_cast<int>(i));
@@ -332,11 +274,6 @@ void QuestLogScreen::render(game::GameHandler& gameHandler, InventoryScreen& inv
                 if (rowW < 1.0f) rowW = 1.0f;
                 bool clicked = ImGui::InvisibleButton("questRowBtn", ImVec2(rowW, rowH));
                 bool hovered = ImGui::IsItemHovered();
-                // Scroll to selected quest on the first frame after openAndSelectQuest()
-                if (selected && scrollToSelected_) {
-                    ImGui::SetScrollHereY(0.5f);
-                    scrollToSelected_ = false;
-                }
 
                 ImVec2 rowMin = ImGui::GetItemRectMin();
                 ImVec2 rowMax = ImGui::GetItemRectMax();
@@ -362,41 +299,8 @@ void QuestLogScreen::render(game::GameHandler& gameHandler, InventoryScreen& inv
                         questDetailQueryNoResponse_.erase(q.questId);
                     }
                 }
-
-                // Right-click context menu on quest row
-                if (ImGui::BeginPopupContextItem("QuestRowCtx")) {
-                    selectedIndex = static_cast<int>(i); // select on right-click too
-                    ImGui::TextDisabled("%s", displayTitle.c_str());
-                    ImGui::Separator();
-                    bool tracked = gameHandler.isQuestTracked(q.questId);
-                    if (ImGui::MenuItem(tracked ? "Untrack" : "Track")) {
-                        gameHandler.setQuestTracked(q.questId, !tracked);
-                    }
-                    if (gameHandler.isInGroup() && !q.complete) {
-                        if (ImGui::MenuItem("Share Quest")) {
-                            gameHandler.shareQuestWithParty(q.questId);
-                        }
-                    }
-                    if (!q.complete) {
-                        ImGui::Separator();
-                        if (ImGui::MenuItem("Abandon Quest")) {
-                            gameHandler.abandonQuest(q.questId);
-                            gameHandler.setQuestTracked(q.questId, false);
-                            selectedIndex = -1;
-                        }
-                    }
-                    ImGui::EndPopup();
-                }
-
                 ImGui::PopID();
             }
-            if (visibleQuestCount == 0) {
-                ImGui::Spacing();
-                if (filterLower[0] || questFilterMode_ != 0)
-                    ImGui::TextDisabled("No quests match the filter.");
-                else
-                    ImGui::TextDisabled("No active quests.");
-            }
             ImGui::EndChild();
 
             ImGui::SameLine();
@@ -458,151 +362,22 @@ void QuestLogScreen::render(game::GameHandler& gameHandler, InventoryScreen& inv
                     ImGui::Separator();
                     ImGui::TextColored(ImVec4(0.8f, 0.9f, 1.0f, 1.0f), "Tracked Progress");
                     for (const auto& [entry, progress] : sel.killCounts) {
-                        std::string name = gameHandler.getCachedCreatureName(entry);
-                        if (name.empty()) {
-                            // Game object objective: fall back to GO name cache.
-                            const auto* goInfo = gameHandler.getCachedGameObjectInfo(entry);
-                            if (goInfo && !goInfo->name.empty()) name = goInfo->name;
-                        }
-                        if (name.empty()) name = "Unknown (" + std::to_string(entry) + ")";
-                        ImGui::BulletText("%s: %u/%u", name.c_str(), progress.first, progress.second);
+                        ImGui::BulletText("Kill %u: %u/%u", entry, progress.first, progress.second);
                     }
                     for (const auto& [itemId, count] : sel.itemCounts) {
                         std::string itemLabel = "Item " + std::to_string(itemId);
-                        uint32_t dispId = 0;
                         if (const auto* info = gameHandler.getItemInfo(itemId)) {
                             if (!info->name.empty()) itemLabel = info->name;
-                            dispId = info->displayInfoId;
-                        } else {
-                            gameHandler.ensureItemInfo(itemId);
-                        }
-                        uint32_t required = 1;
-                        auto reqIt = sel.requiredItemCounts.find(itemId);
-                        if (reqIt != sel.requiredItemCounts.end()) required = reqIt->second;
-                        VkDescriptorSet iconTex = dispId ? invScreen.getItemIcon(dispId) : VK_NULL_HANDLE;
-                        const auto* objInfo = gameHandler.getItemInfo(itemId);
-                        if (iconTex) {
-                            ImGui::Image((ImTextureID)(uintptr_t)iconTex, ImVec2(14, 14));
-                            if (objInfo && objInfo->valid && ImGui::IsItemHovered()) {
-                                ImGui::BeginTooltip();
-                                invScreen.renderItemTooltip(*objInfo);
-                                ImGui::EndTooltip();
-                            }
-                            ImGui::SameLine();
-                            ImGui::Text("%s: %u/%u", itemLabel.c_str(), count, required);
-                            if (objInfo && objInfo->valid && ImGui::IsItemHovered()) {
-                                ImGui::BeginTooltip();
-                                invScreen.renderItemTooltip(*objInfo);
-                                ImGui::EndTooltip();
-                            }
-                        } else {
-                            ImGui::BulletText("%s: %u/%u", itemLabel.c_str(), count, required);
-                            if (objInfo && objInfo->valid && ImGui::IsItemHovered()) {
-                                ImGui::BeginTooltip();
-                                invScreen.renderItemTooltip(*objInfo);
-                                ImGui::EndTooltip();
-                            }
                         }
+                        ImGui::BulletText("%s: %u", itemLabel.c_str(), count);
                     }
                 }
 
-                // Reward summary
-                bool hasAnyReward = (sel.rewardMoney != 0);
-                for (const auto& ri : sel.rewardItems)       if (ri.itemId) hasAnyReward = true;
-                for (const auto& ri : sel.rewardChoiceItems) if (ri.itemId) hasAnyReward = true;
-                if (hasAnyReward) {
-                    ImGui::Separator();
-                    ImGui::TextColored(ImVec4(1.0f, 0.9f, 0.5f, 1.0f), "Rewards");
-
-                    // Money reward
-                    if (sel.rewardMoney > 0) {
-                        uint32_t rg = static_cast<uint32_t>(sel.rewardMoney) / 10000;
-                        uint32_t rs = static_cast<uint32_t>(sel.rewardMoney % 10000) / 100;
-                        uint32_t rc = static_cast<uint32_t>(sel.rewardMoney % 100);
-                        renderCoinsText(rg, rs, rc);
-                    }
-
-                    // Guaranteed reward items
-                    bool anyFixed = false;
-                    for (const auto& ri : sel.rewardItems) if (ri.itemId) { anyFixed = true; break; }
-                    if (anyFixed) {
-                        ImGui::TextDisabled("You will receive:");
-                        for (const auto& ri : sel.rewardItems) {
-                            if (!ri.itemId) continue;
-                            std::string name = "Item " + std::to_string(ri.itemId);
-                            uint32_t dispId = 0;
-                            const auto* info = gameHandler.getItemInfo(ri.itemId);
-                            if (info && info->valid) {
-                                if (!info->name.empty()) name = info->name;
-                                dispId = info->displayInfoId;
-                            }
-                            VkDescriptorSet icon = dispId ? invScreen.getItemIcon(dispId) : VK_NULL_HANDLE;
-                            if (icon) {
-                                ImGui::Image((ImTextureID)(uintptr_t)icon, ImVec2(16, 16));
-                                ImGui::SameLine();
-                            }
-                            if (ri.count > 1)
-                                ImGui::Text("%s x%u", name.c_str(), ri.count);
-                            else
-                                ImGui::Text("%s", name.c_str());
-                            if (info && info->valid && ImGui::IsItemHovered()) {
-                                ImGui::BeginTooltip();
-                                invScreen.renderItemTooltip(*info);
-                                ImGui::EndTooltip();
-                            }
-                        }
-                    }
-
-                    // Choice reward items
-                    bool anyChoice = false;
-                    for (const auto& ri : sel.rewardChoiceItems) if (ri.itemId) { anyChoice = true; break; }
-                    if (anyChoice) {
-                        ImGui::TextDisabled("Choose one of:");
-                        for (const auto& ri : sel.rewardChoiceItems) {
-                            if (!ri.itemId) continue;
-                            std::string name = "Item " + std::to_string(ri.itemId);
-                            uint32_t dispId = 0;
-                            const auto* info = gameHandler.getItemInfo(ri.itemId);
-                            if (info && info->valid) {
-                                if (!info->name.empty()) name = info->name;
-                                dispId = info->displayInfoId;
-                            }
-                            VkDescriptorSet icon = dispId ? invScreen.getItemIcon(dispId) : VK_NULL_HANDLE;
-                            if (icon) {
-                                ImGui::Image((ImTextureID)(uintptr_t)icon, ImVec2(16, 16));
-                                ImGui::SameLine();
-                            }
-                            if (ri.count > 1)
-                                ImGui::Text("%s x%u", name.c_str(), ri.count);
-                            else
-                                ImGui::Text("%s", name.c_str());
-                            if (info && info->valid && ImGui::IsItemHovered()) {
-                                ImGui::BeginTooltip();
-                                invScreen.renderItemTooltip(*info);
-                                ImGui::EndTooltip();
-                            }
-                        }
-                    }
-                }
-
-                // Track / Share / Abandon buttons
-                ImGui::Separator();
-                bool isTracked = gameHandler.isQuestTracked(sel.questId);
-                if (ImGui::Button(isTracked ? "Untrack" : "Track", ImVec2(100.0f, 0.0f))) {
-                    gameHandler.setQuestTracked(sel.questId, !isTracked);
-                }
-                if (gameHandler.isInGroup() && !sel.complete) {
-                    ImGui::SameLine();
-                    if (ImGui::Button("Share", ImVec2(80.0f, 0.0f))) {
-                        gameHandler.shareQuestWithParty(sel.questId);
-                    }
-                    if (ImGui::IsItemHovered()) ImGui::SetTooltip("Share this quest with your party");
-                }
+                // Abandon button
                 if (!sel.complete) {
-                    ImGui::SameLine();
+                    ImGui::Separator();
                     if (ImGui::Button("Abandon Quest", ImVec2(150.0f, 0.0f))) {
                         gameHandler.abandonQuest(sel.questId);
-                        gameHandler.setQuestTracked(sel.questId, false);
                         selectedIndex = -1;
                     }
                 }
diff --git a/src/ui/realm_screen.cpp b/src/ui/realm_screen.cpp
index 4df8a80f..589634a1 100644
--- a/src/ui/realm_screen.cpp
+++ b/src/ui/realm_screen.cpp
@@ -1,5 +1,4 @@
 #include "ui/realm_screen.hpp"
-#include "ui/ui_colors.hpp"
 #include <imgui.h>
 
 namespace wowee { namespace ui {
@@ -33,7 +32,7 @@ void RealmScreen::render(auth::AuthHandler& authHandler) {
 
     // Status message
     if (!statusMessage.empty()) {
-        ImGui::PushStyleColor(ImGuiCol_Text, ui::colors::kBrightGreen);
+        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.3f, 1.0f, 0.3f, 1.0f));
         ImGui::TextWrapped("%s", statusMessage.c_str());
         ImGui::PopStyleColor();
         ImGui::Spacing();
@@ -154,9 +153,9 @@ void RealmScreen::render(auth::AuthHandler& authHandler) {
                 ImGui::TableSetColumnIndex(4);
                 const char* status = getRealmStatus(realm.flags);
                 if (realm.lock) {
-                    ImGui::TextColored(ui::colors::kRed, "Locked");
+                    ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f), "Locked");
                 } else {
-                    ImGui::TextColored(ui::colors::kBrightGreen, "%s", status);
+                    ImGui::TextColored(ImVec4(0.3f, 1.0f, 0.3f, 1.0f), "%s", status);
                 }
             }
 
@@ -203,7 +202,7 @@ void RealmScreen::render(auth::AuthHandler& authHandler) {
                 }
                 ImGui::PopStyleColor(2);
             } else {
-                ImGui::PushStyleColor(ImGuiCol_Button, ui::colors::kDarkGray);
+                ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.5f, 0.5f, 0.5f, 1.0f));
                 ImGui::Button("Realm Locked", ImVec2(200, 40));
                 ImGui::PopStyleColor();
             }
@@ -238,13 +237,13 @@ const char* RealmScreen::getRealmStatus(uint8_t flags) const {
 
 ImVec4 RealmScreen::getPopulationColor(float population) const {
     if (population < 0.5f) {
-        return ui::colors::kBrightGreen;  // Green - Low
+        return ImVec4(0.3f, 1.0f, 0.3f, 1.0f);  // Green - Low
     } else if (population < 1.5f) {
-        return ui::colors::kYellow;  // Yellow - Medium
+        return ImVec4(1.0f, 1.0f, 0.3f, 1.0f);  // Yellow - Medium
     } else if (population < 2.5f) {
         return ImVec4(1.0f, 0.6f, 0.0f, 1.0f);  // Orange - High
     } else {
-        return ui::colors::kRed;  // Red - Full
+        return ImVec4(1.0f, 0.3f, 0.3f, 1.0f);  // Red - Full
     }
 }
 
diff --git a/src/ui/settings_panel.cpp b/src/ui/settings_panel.cpp
deleted file mode 100644
index f6353942..00000000
--- a/src/ui/settings_panel.cpp
+++ /dev/null
@@ -1,1259 +0,0 @@
-// ============================================================
-// SettingsPanel — extracted from GameScreen
-// Owns all settings UI rendering, settings state, and
-// graphics preset logic.
-// ============================================================
-#include "ui/settings_panel.hpp"
-#include "ui/inventory_screen.hpp"
-#include "ui/chat_panel.hpp"
-#include "ui/keybinding_manager.hpp"
-#include "core/application.hpp"
-#include "core/logger.hpp"
-#include "rendering/renderer.hpp"
-#include "rendering/camera.hpp"
-#include "rendering/camera_controller.hpp"
-#include "rendering/minimap.hpp"
-#include "rendering/terrain_manager.hpp"
-#include "rendering/wmo_renderer.hpp"
-#include "rendering/character_renderer.hpp"
-#include "game/zone_manager.hpp"
-#include "audio/audio_coordinator.hpp"
-#include "audio/audio_engine.hpp"
-#include "audio/music_manager.hpp"
-#include "audio/ambient_sound_manager.hpp"
-#include "audio/ui_sound_manager.hpp"
-#include "audio/combat_sound_manager.hpp"
-#include "audio/spell_sound_manager.hpp"
-#include "audio/movement_sound_manager.hpp"
-#include "audio/footstep_manager.hpp"
-#include "audio/npc_voice_manager.hpp"
-#include "audio/mount_sound_manager.hpp"
-#include "audio/activity_sound_manager.hpp"
-#include <imgui.h>
-#include <imgui_internal.h>
-#include <algorithm>
-#include <cmath>
-#include <cstdio>
-#include <cstdlib>
-#include <filesystem>
-#include <fstream>
-#include <string>
-
-namespace wowee { namespace ui {
-
-void SettingsPanel::renderSettingsInterfaceTab(std::function<void()> saveCallback) {
-ImGui::Spacing();
-ImGui::BeginChild("InterfaceSettings", ImVec2(0, 360), true);
-
-ImGui::SeparatorText("Action Bars");
-ImGui::Spacing();
-ImGui::SetNextItemWidth(200.0f);
-if (ImGui::SliderFloat("Action Bar Scale", &pendingActionBarScale, 0.5f, 1.5f, "%.2fx")) {
-    saveCallback();
-}
-ImGui::Spacing();
-
-if (ImGui::Checkbox("Show Second Action Bar", &pendingShowActionBar2)) {
-    saveCallback();
-}
-ImGui::SameLine();
-ImGui::TextDisabled("(Shift+1 through Shift+=)");
-
-if (pendingShowActionBar2) {
-    ImGui::Spacing();
-    ImGui::TextUnformatted("Second Bar Position Offset");
-    ImGui::SetNextItemWidth(160.0f);
-    if (ImGui::SliderFloat("Horizontal##bar2x", &pendingActionBar2OffsetX, -600.0f, 600.0f, "%.0f px")) {
-        saveCallback();
-    }
-    ImGui::SetNextItemWidth(160.0f);
-    if (ImGui::SliderFloat("Vertical##bar2y", &pendingActionBar2OffsetY, -400.0f, 400.0f, "%.0f px")) {
-        saveCallback();
-    }
-    if (ImGui::Button("Reset Position##bar2")) {
-        pendingActionBar2OffsetX = 0.0f;
-        pendingActionBar2OffsetY = 0.0f;
-        saveCallback();
-    }
-}
-
-ImGui::Spacing();
-if (ImGui::Checkbox("Show Right Side Bar", &pendingShowRightBar)) {
-    saveCallback();
-}
-ImGui::SameLine();
-ImGui::TextDisabled("(Slots 25-36)");
-if (pendingShowRightBar) {
-    ImGui::SetNextItemWidth(160.0f);
-    if (ImGui::SliderFloat("Vertical Offset##rbar", &pendingRightBarOffsetY, -400.0f, 400.0f, "%.0f px")) {
-        saveCallback();
-    }
-}
-
-ImGui::Spacing();
-if (ImGui::Checkbox("Show Left Side Bar", &pendingShowLeftBar)) {
-    saveCallback();
-}
-ImGui::SameLine();
-ImGui::TextDisabled("(Slots 37-48)");
-if (pendingShowLeftBar) {
-    ImGui::SetNextItemWidth(160.0f);
-    if (ImGui::SliderFloat("Vertical Offset##lbar", &pendingLeftBarOffsetY, -400.0f, 400.0f, "%.0f px")) {
-        saveCallback();
-    }
-}
-
-ImGui::Spacing();
-ImGui::SeparatorText("Nameplates");
-ImGui::Spacing();
-ImGui::SetNextItemWidth(200.0f);
-if (ImGui::SliderFloat("Nameplate Scale", &nameplateScale_, 0.5f, 2.0f, "%.2fx")) {
-    saveCallback();
-}
-
-ImGui::Spacing();
-ImGui::SeparatorText("Network");
-ImGui::Spacing();
-if (ImGui::Checkbox("Show Latency Meter", &pendingShowLatencyMeter)) {
-    showLatencyMeter_ = pendingShowLatencyMeter;
-    saveCallback();
-}
-ImGui::SameLine();
-ImGui::TextDisabled("(ms indicator near minimap)");
-
-if (ImGui::Checkbox("Show DPS/HPS Meter", &showDPSMeter_)) {
-    saveCallback();
-}
-ImGui::SameLine();
-ImGui::TextDisabled("(damage/healing per second above action bar)");
-
-if (ImGui::Checkbox("Show Cooldown Tracker", &showCooldownTracker_)) {
-    saveCallback();
-}
-ImGui::SameLine();
-ImGui::TextDisabled("(active spell cooldowns near action bar)");
-
-ImGui::Spacing();
-ImGui::SeparatorText("Screen Effects");
-ImGui::Spacing();
-if (ImGui::Checkbox("Damage Flash", &damageFlashEnabled_)) {
-    saveCallback();
-}
-ImGui::SameLine();
-ImGui::TextDisabled("(red vignette on taking damage)");
-
-if (ImGui::Checkbox("Low Health Vignette", &lowHealthVignetteEnabled_)) {
-    saveCallback();
-}
-ImGui::SameLine();
-ImGui::TextDisabled("(pulsing red edges below 20%% HP)");
-
-ImGui::EndChild();
-}
-
-void SettingsPanel::renderSettingsGameplayTab(InventoryScreen& inventoryScreen,
-                                                  std::function<void()> saveCallback) {
-    auto* renderer = services_.renderer;
-ImGui::Spacing();
-
-ImGui::Text("Controls");
-ImGui::Separator();
-if (ImGui::SliderFloat("Mouse Sensitivity", &pendingMouseSensitivity, 0.05f, 1.0f, "%.2f")) {
-    if (renderer) {
-        if (auto* cameraController = renderer->getCameraController()) {
-            cameraController->setMouseSensitivity(pendingMouseSensitivity);
-        }
-    }
-    saveCallback();
-}
-if (ImGui::Checkbox("Invert Mouse", &pendingInvertMouse)) {
-    if (renderer) {
-        if (auto* cameraController = renderer->getCameraController()) {
-            cameraController->setInvertMouse(pendingInvertMouse);
-        }
-    }
-    saveCallback();
-}
-if (ImGui::Checkbox("Extended Camera Zoom", &pendingExtendedZoom)) {
-    if (renderer) {
-        if (auto* cameraController = renderer->getCameraController()) {
-            cameraController->setExtendedZoom(pendingExtendedZoom);
-        }
-    }
-    saveCallback();
-}
-if (ImGui::SliderFloat("Camera Stiffness", &pendingCameraStiffness, 5.0f, 100.0f, "%.0f")) {
-    if (renderer) {
-        if (auto* cameraController = renderer->getCameraController()) {
-            cameraController->setCameraSmoothSpeed(pendingCameraStiffness);
-        }
-    }
-    saveCallback();
-}
-ImGui::SetItemTooltip("Higher = tighter camera with less sway. Default: 30");
-if (ImGui::SliderFloat("Camera Pivot Height", &pendingPivotHeight, 0.0f, 3.0f, "%.1f")) {
-    if (renderer) {
-        if (auto* cameraController = renderer->getCameraController()) {
-            cameraController->setPivotHeight(pendingPivotHeight);
-        }
-    }
-    saveCallback();
-}
-ImGui::SetItemTooltip("Height of camera orbit point above feet. Lower = less detached feel. Default: 1.8");
-if (ImGui::IsItemHovered())
-    ImGui::SetTooltip("Allow the camera to zoom out further than normal");
-
-if (ImGui::SliderFloat("Field of View", &pendingFov, 45.0f, 110.0f, "%.0f°")) {
-    if (renderer) {
-        if (auto* camera = renderer->getCamera()) {
-            camera->setFov(pendingFov);
-        }
-    }
-    saveCallback();
-}
-if (ImGui::IsItemHovered())
-    ImGui::SetTooltip("Camera field of view in degrees (default: 70)");
-
-ImGui::Spacing();
-ImGui::Spacing();
-
-ImGui::Text("Interface");
-ImGui::Separator();
-if (ImGui::SliderInt("UI Opacity", &pendingUiOpacity, 20, 100, "%d%%")) {
-    uiOpacity_ = static_cast<float>(pendingUiOpacity) / 100.0f;
-    saveCallback();
-}
-if (ImGui::Checkbox("Rotate Minimap", &pendingMinimapRotate)) {
-    // Force north-up minimap.
-    minimapRotate_ = false;
-    pendingMinimapRotate = false;
-    if (renderer) {
-        if (auto* minimap = renderer->getMinimap()) {
-            minimap->setRotateWithCamera(false);
-        }
-    }
-    saveCallback();
-}
-if (ImGui::Checkbox("Square Minimap", &pendingMinimapSquare)) {
-    minimapSquare_ = pendingMinimapSquare;
-    if (renderer) {
-        if (auto* minimap = renderer->getMinimap()) {
-            minimap->setSquareShape(minimapSquare_);
-        }
-    }
-    saveCallback();
-}
-if (ImGui::Checkbox("Show Nearby NPC Dots", &pendingMinimapNpcDots)) {
-    minimapNpcDots_ = pendingMinimapNpcDots;
-    saveCallback();
-}
-// Zoom controls
-ImGui::Text("Minimap Zoom:");
-ImGui::SameLine();
-if (ImGui::Button("  -  ")) {
-    if (renderer) {
-        if (auto* minimap = renderer->getMinimap()) {
-            minimap->zoomOut();
-            saveCallback();
-        }
-    }
-}
-ImGui::SameLine();
-if (ImGui::Button("  +  ")) {
-    if (renderer) {
-        if (auto* minimap = renderer->getMinimap()) {
-            minimap->zoomIn();
-            saveCallback();
-        }
-    }
-}
-
-ImGui::Spacing();
-ImGui::Text("Loot");
-ImGui::Separator();
-if (ImGui::Checkbox("Auto Loot", &pendingAutoLoot)) {
-    saveCallback();  // per-frame sync applies pendingAutoLoot to gameHandler
-}
-if (ImGui::IsItemHovered())
-    ImGui::SetTooltip("Automatically pick up all items when looting");
-if (ImGui::Checkbox("Auto Sell Greys", &pendingAutoSellGrey)) {
-    saveCallback();
-}
-if (ImGui::IsItemHovered())
-    ImGui::SetTooltip("Automatically sell all grey (poor quality) items when opening a vendor");
-if (ImGui::Checkbox("Auto Repair", &pendingAutoRepair)) {
-    saveCallback();
-}
-if (ImGui::IsItemHovered())
-    ImGui::SetTooltip("Automatically repair all damaged equipment when opening an armorer vendor");
-
-ImGui::Spacing();
-ImGui::Text("Bags");
-ImGui::Separator();
-if (ImGui::Checkbox("Separate Bag Windows", &pendingSeparateBags)) {
-    inventoryScreen.setSeparateBags(pendingSeparateBags);
-    saveCallback();
-}
-if (ImGui::Checkbox("Show Key Ring", &pendingShowKeyring)) {
-    inventoryScreen.setShowKeyring(pendingShowKeyring);
-    saveCallback();
-}
-
-ImGui::Spacing();
-ImGui::Separator();
-ImGui::Spacing();
-
-if (ImGui::Button("Restore Gameplay Defaults", ImVec2(-1, 0))) {
-    pendingMouseSensitivity = 0.2f;
-    pendingInvertMouse = false;
-    pendingExtendedZoom = false;
-    pendingUiOpacity = 65;
-    pendingMinimapRotate = false;
-    pendingMinimapSquare = false;
-    pendingMinimapNpcDots = false;
-    pendingSeparateBags = true;
-    inventoryScreen.setSeparateBags(true);
-    pendingShowKeyring = true;
-    inventoryScreen.setShowKeyring(true);
-    uiOpacity_ = 0.65f;
-    minimapRotate_ = false;
-    minimapSquare_ = false;
-    minimapNpcDots_ = false;
-    if (renderer) {
-        if (auto* cameraController = renderer->getCameraController()) {
-            cameraController->setMouseSensitivity(pendingMouseSensitivity);
-            cameraController->setInvertMouse(pendingInvertMouse);
-            cameraController->setExtendedZoom(pendingExtendedZoom);
-        }
-        if (auto* minimap = renderer->getMinimap()) {
-            minimap->setRotateWithCamera(minimapRotate_);
-            minimap->setSquareShape(minimapSquare_);
-        }
-    }
-    saveCallback();
-}
-
-}
-
-void SettingsPanel::renderSettingsControlsTab(std::function<void()> saveCallback) {
-ImGui::Spacing();
-
-ImGui::Text("Keybindings");
-ImGui::Separator();
-
-auto& km = ui::KeybindingManager::getInstance();
-int numActions = km.getActionCount();
-
-for (int i = 0; i < numActions; ++i) {
-    auto action = static_cast<ui::KeybindingManager::Action>(i);
-    const char* actionName = km.getActionName(action);
-    ImGuiKey currentKey = km.getKeyForAction(action);
-
-    // Display current binding
-    ImGui::Text("%s:", actionName);
-    ImGui::SameLine(200);
-
-    // Get human-readable key name (basic implementation)
-    const char* keyName = "Unknown";
-    if (currentKey >= ImGuiKey_A && currentKey <= ImGuiKey_Z) {
-        static char keyBuf[16];
-        snprintf(keyBuf, sizeof(keyBuf), "%c", 'A' + (currentKey - ImGuiKey_A));
-        keyName = keyBuf;
-    } else if (currentKey >= ImGuiKey_0 && currentKey <= ImGuiKey_9) {
-        static char keyBuf[16];
-        snprintf(keyBuf, sizeof(keyBuf), "%c", '0' + (currentKey - ImGuiKey_0));
-        keyName = keyBuf;
-    } else if (currentKey == ImGuiKey_Escape) {
-        keyName = "Escape";
-    } else if (currentKey == ImGuiKey_Enter) {
-        keyName = "Enter";
-    } else if (currentKey == ImGuiKey_Tab) {
-        keyName = "Tab";
-    } else if (currentKey == ImGuiKey_Space) {
-        keyName = "Space";
-    } else if (currentKey >= ImGuiKey_F1 && currentKey <= ImGuiKey_F12) {
-        static char keyBuf[16];
-        snprintf(keyBuf, sizeof(keyBuf), "F%d", 1 + (currentKey - ImGuiKey_F1));
-        keyName = keyBuf;
-    }
-
-    ImGui::Text("[%s]", keyName);
-
-    // Rebind button
-    ImGui::SameLine(350);
-    if (ImGui::Button(awaitingKeyPress_ && pendingRebindAction_ == i ? "Waiting..." : "Rebind", ImVec2(100, 0))) {
-        pendingRebindAction_ = i;
-        awaitingKeyPress_ = true;
-    }
-}
-
-// Handle key press during rebinding
-if (awaitingKeyPress_ && pendingRebindAction_ >= 0) {
-    ImGui::Spacing();
-    ImGui::Separator();
-    ImGui::Text("Press any key to bind to this action (Esc to cancel)...");
-
-    // Check for any key press
-    bool foundKey = false;
-    ImGuiKey newKey = ImGuiKey_None;
-    for (int k = ImGuiKey_NamedKey_BEGIN; k < ImGuiKey_NamedKey_END; ++k) {
-        if (ImGui::IsKeyPressed(static_cast<ImGuiKey>(k), false)) {
-            if (k == ImGuiKey_Escape) {
-                // Cancel rebinding
-                awaitingKeyPress_ = false;
-                pendingRebindAction_ = -1;
-                foundKey = true;
-                break;
-            }
-            newKey = static_cast<ImGuiKey>(k);
-            foundKey = true;
-            break;
-        }
-    }
-
-    if (foundKey && newKey != ImGuiKey_None) {
-        auto action = static_cast<ui::KeybindingManager::Action>(pendingRebindAction_);
-        km.setKeyForAction(action, newKey);
-        awaitingKeyPress_ = false;
-        pendingRebindAction_ = -1;
-        saveCallback();
-    }
-}
-
-ImGui::Spacing();
-ImGui::Separator();
-ImGui::Spacing();
-
-if (ImGui::Button("Reset to Defaults", ImVec2(-1, 0))) {
-    km.resetToDefaults();
-    awaitingKeyPress_ = false;
-    pendingRebindAction_ = -1;
-    saveCallback();
-}
-
-}
-
-void SettingsPanel::renderSettingsAudioTab(std::function<void()> saveCallback) {
-    auto* renderer = services_.renderer;
-ImGui::Spacing();
-ImGui::BeginChild("AudioSettings", ImVec2(0, 360), true);
-
-// Helper lambda to apply audio settings
-auto applyAudioSettings = [&]() {
-    applyAudioVolumes(services_.audioCoordinator);
-    saveCallback();
-};
-
-ImGui::Text("Master Volume");
-if (ImGui::SliderInt("##MasterVolume", &pendingMasterVolume, 0, 100, "%d%%")) {
-    applyAudioSettings();
-}
-ImGui::Separator();
-
-if (ImGui::Checkbox("Enable WoWee Music", &pendingUseOriginalSoundtrack)) {
-    if (renderer) {
-        if (auto* zm = renderer->getZoneManager()) {
-            zm->setUseOriginalSoundtrack(pendingUseOriginalSoundtrack);
-        }
-    }
-    saveCallback();
-}
-if (ImGui::IsItemHovered())
-    ImGui::SetTooltip("Include WoWee music tracks in zone music rotation");
-ImGui::Separator();
-
-ImGui::Text("Music");
-if (ImGui::SliderInt("##MusicVolume", &pendingMusicVolume, 0, 100, "%d%%")) {
-    applyAudioSettings();
-}
-
-ImGui::Spacing();
-ImGui::Text("Ambient Sounds");
-if (ImGui::SliderInt("##AmbientVolume", &pendingAmbientVolume, 0, 100, "%d%%")) {
-    applyAudioSettings();
-}
-ImGui::TextWrapped("Weather, zones, cities, emitters");
-
-ImGui::Spacing();
-ImGui::Text("UI Sounds");
-if (ImGui::SliderInt("##UiVolume", &pendingUiVolume, 0, 100, "%d%%")) {
-    applyAudioSettings();
-}
-ImGui::TextWrapped("Buttons, loot, quest complete");
-
-ImGui::Spacing();
-ImGui::Text("Combat Sounds");
-if (ImGui::SliderInt("##CombatVolume", &pendingCombatVolume, 0, 100, "%d%%")) {
-    applyAudioSettings();
-}
-ImGui::TextWrapped("Weapon swings, impacts, grunts");
-
-ImGui::Spacing();
-ImGui::Text("Spell Sounds");
-if (ImGui::SliderInt("##SpellVolume", &pendingSpellVolume, 0, 100, "%d%%")) {
-    applyAudioSettings();
-}
-ImGui::TextWrapped("Magic casting and impacts");
-
-ImGui::Spacing();
-ImGui::Text("Movement Sounds");
-if (ImGui::SliderInt("##MovementVolume", &pendingMovementVolume, 0, 100, "%d%%")) {
-    applyAudioSettings();
-}
-ImGui::TextWrapped("Water splashes, jump/land");
-
-ImGui::Spacing();
-ImGui::Text("Footsteps");
-if (ImGui::SliderInt("##FootstepVolume", &pendingFootstepVolume, 0, 100, "%d%%")) {
-    applyAudioSettings();
-}
-
-ImGui::Spacing();
-ImGui::Text("NPC Voices");
-if (ImGui::SliderInt("##NpcVoiceVolume", &pendingNpcVoiceVolume, 0, 100, "%d%%")) {
-    applyAudioSettings();
-}
-
-ImGui::Spacing();
-ImGui::Text("Mount Sounds");
-if (ImGui::SliderInt("##MountVolume", &pendingMountVolume, 0, 100, "%d%%")) {
-    applyAudioSettings();
-}
-
-ImGui::Spacing();
-ImGui::Text("Activity Sounds");
-if (ImGui::SliderInt("##ActivityVolume", &pendingActivityVolume, 0, 100, "%d%%")) {
-    applyAudioSettings();
-}
-ImGui::TextWrapped("Swimming, eating, drinking");
-
-ImGui::EndChild();
-
-if (ImGui::Button("Restore Audio Defaults", ImVec2(-1, 0))) {
-    pendingMasterVolume = 100;
-    pendingMusicVolume = 30; // default music volume
-    pendingAmbientVolume = 100;
-    pendingUiVolume = 100;
-    pendingCombatVolume = 100;
-    pendingSpellVolume = 100;
-    pendingMovementVolume = 100;
-    pendingFootstepVolume = 100;
-    pendingNpcVoiceVolume = 100;
-    pendingMountVolume = 100;
-    pendingActivityVolume = 100;
-    applyAudioSettings();
-}
-
-}
-
-void SettingsPanel::renderSettingsAboutTab() {
-ImGui::Spacing();
-ImGui::Spacing();
-
-ImGui::TextWrapped("WoWee - World of Warcraft Client Emulator");
-ImGui::Spacing();
-ImGui::Separator();
-ImGui::Spacing();
-
-ImGui::Text("Developer");
-ImGui::Indent();
-ImGui::Text("Kelsi Davis");
-ImGui::Unindent();
-ImGui::Spacing();
-
-ImGui::Text("GitHub");
-ImGui::Indent();
-ImGui::TextColored(ImVec4(0.4f, 0.7f, 1.0f, 1.0f), "https://github.com/Kelsidavis/WoWee");
-if (ImGui::IsItemHovered()) {
-    ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
-    ImGui::SetTooltip("Click to copy");
-}
-if (ImGui::IsItemClicked()) {
-    ImGui::SetClipboardText("https://github.com/Kelsidavis/WoWee");
-}
-ImGui::Unindent();
-ImGui::Spacing();
-
-ImGui::Text("Contact");
-ImGui::Indent();
-ImGui::TextColored(ImVec4(0.4f, 0.7f, 1.0f, 1.0f), "github.com/Kelsidavis");
-if (ImGui::IsItemHovered()) {
-    ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
-    ImGui::SetTooltip("Click to copy");
-}
-if (ImGui::IsItemClicked()) {
-    ImGui::SetClipboardText("https://github.com/Kelsidavis");
-}
-ImGui::Unindent();
-
-ImGui::Spacing();
-ImGui::Separator();
-ImGui::Spacing();
-
-ImGui::TextWrapped("A multi-expansion WoW client supporting Classic, TBC, and WotLK (3.3.5a).");
-ImGui::Spacing();
-ImGui::TextDisabled("Built with Vulkan, SDL2, and ImGui");
-
-}
-
-void SettingsPanel::renderSettingsWindow(InventoryScreen& inventoryScreen, ChatPanel& chatPanel,
-                                             std::function<void()> saveCallback) {
-    if (!showSettingsWindow) return;
-
-    auto* window = services_.window;
-    auto* renderer = services_.renderer;
-    if (!window) return;
-
-    static constexpr int kResolutions[][2] = {
-        {1280, 720},
-        {1600, 900},
-        {1920, 1080},
-        {2560, 1440},
-        {3840, 2160},
-    };
-    static constexpr int kResCount = sizeof(kResolutions) / sizeof(kResolutions[0]);
-    constexpr int kDefaultResW = 1920;
-    constexpr int kDefaultResH = 1080;
-    constexpr bool kDefaultFullscreen = false;
-    constexpr bool kDefaultVsync = true;
-    constexpr bool kDefaultShadows = true;
-    constexpr int kDefaultGroundClutterDensity = 100;
-
-    int defaultResIndex = 0;
-    for (int i = 0; i < kResCount; i++) {
-        if (kResolutions[i][0] == kDefaultResW && kResolutions[i][1] == kDefaultResH) {
-            defaultResIndex = i;
-            break;
-        }
-    }
-
-    if (!settingsInit) {
-        pendingFullscreen = window->isFullscreen();
-        pendingVsync = window->isVsyncEnabled();
-        if (renderer) {
-            renderer->setShadowsEnabled(pendingShadows);
-            renderer->setShadowDistance(pendingShadowDistance);
-            // Read non-volume settings from actual state (volumes come from saved settings)
-            if (auto* cameraController = renderer->getCameraController()) {
-                pendingMouseSensitivity = cameraController->getMouseSensitivity();
-                pendingInvertMouse = cameraController->isInvertMouse();
-                cameraController->setExtendedZoom(pendingExtendedZoom);
-            }
-        }
-        pendingResIndex = 0;
-        int curW = window->getWidth();
-        int curH = window->getHeight();
-        for (int i = 0; i < kResCount; i++) {
-            if (kResolutions[i][0] == curW && kResolutions[i][1] == curH) {
-                pendingResIndex = i;
-                break;
-            }
-        }
-        pendingUiOpacity = static_cast<int>(std::lround(uiOpacity_ * 100.0f));
-        pendingMinimapRotate = minimapRotate_;
-        pendingMinimapSquare = minimapSquare_;
-        pendingMinimapNpcDots = minimapNpcDots_;
-        pendingShowLatencyMeter = showLatencyMeter_;
-        if (renderer) {
-            if (auto* minimap = renderer->getMinimap()) {
-                minimap->setRotateWithCamera(minimapRotate_);
-                minimap->setSquareShape(minimapSquare_);
-            }
-            if (auto* zm = renderer->getZoneManager()) {
-                pendingUseOriginalSoundtrack = zm->getUseOriginalSoundtrack();
-            }
-        }
-        settingsInit = true;
-    }
-
-    ImGuiIO& io = ImGui::GetIO();
-    float screenW = io.DisplaySize.x;
-    float screenH = io.DisplaySize.y;
-    ImVec2 size(520.0f, std::min(screenH * 0.9f, 720.0f));
-    ImVec2 pos((screenW - size.x) * 0.5f, (screenH - size.y) * 0.5f);
-
-    ImGui::SetNextWindowPos(pos, ImGuiCond_Always);
-    ImGui::SetNextWindowSize(size, ImGuiCond_Always);
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar;
-
-    if (ImGui::Begin("##SettingsWindow", nullptr, flags)) {
-        ImGui::Text("Settings");
-        ImGui::Separator();
-
-        if (ImGui::BeginTabBar("SettingsTabs", ImGuiTabBarFlags_None)) {
-            // ============================================================
-            // VIDEO TAB
-            // ============================================================
-            if (ImGui::BeginTabItem("Video")) {
-                ImGui::Spacing();
-
-                // Graphics Quality Presets
-                {
-                    const char* presetLabels[] = { "Custom", "Low", "Medium", "High", "Ultra" };
-                    int presetIdx = static_cast<int>(pendingGraphicsPreset);
-                    if (ImGui::Combo("Quality Preset", &presetIdx, presetLabels, 5)) {
-                        pendingGraphicsPreset = static_cast<GraphicsPreset>(presetIdx);
-                        if (pendingGraphicsPreset != GraphicsPreset::CUSTOM) {
-                            applyGraphicsPreset(pendingGraphicsPreset);
-                            saveCallback();
-                        }
-                    }
-                    ImGui::TextDisabled("Adjust these for custom settings");
-                }
-
-                ImGui::Spacing();
-                ImGui::Separator();
-                ImGui::Spacing();
-
-                if (ImGui::Checkbox("Fullscreen", &pendingFullscreen)) {
-                    window->setFullscreen(pendingFullscreen);
-                    updateGraphicsPresetFromCurrentSettings();
-                    saveCallback();
-                }
-                if (ImGui::Checkbox("VSync", &pendingVsync)) {
-                    window->setVsync(pendingVsync);
-                    updateGraphicsPresetFromCurrentSettings();
-                    saveCallback();
-                }
-                if (ImGui::Checkbox("Shadows", &pendingShadows)) {
-                    if (renderer) renderer->setShadowsEnabled(pendingShadows);
-                    updateGraphicsPresetFromCurrentSettings();
-                    saveCallback();
-                }
-                if (pendingShadows) {
-                    ImGui::SameLine();
-                    ImGui::SetNextItemWidth(150.0f);
-                    if (ImGui::SliderFloat("Distance##shadow", &pendingShadowDistance, 40.0f, 500.0f, "%.0f")) {
-                        if (renderer) renderer->setShadowDistance(pendingShadowDistance);
-                        updateGraphicsPresetFromCurrentSettings();
-                        saveCallback();
-                    }
-                }
-                {
-                    if (ImGui::Checkbox("Water Refraction", &pendingWaterRefraction)) {
-                        if (renderer) renderer->setWaterRefractionEnabled(pendingWaterRefraction);
-                        updateGraphicsPresetFromCurrentSettings();
-                        saveCallback();
-                    }
-                }
-                {
-                    const char* aaLabels[] = { "Off", "2x MSAA", "4x MSAA", "8x MSAA" };
-                    bool fsr2Active = renderer && renderer->isFSR2Enabled();
-                    if (fsr2Active) {
-                        ImGui::BeginDisabled();
-                        int disabled = 0;
-                        ImGui::Combo("Anti-Aliasing (FSR3)", &disabled, "Off (FSR3 active)\0", 1);
-                        ImGui::EndDisabled();
-                    } else if (ImGui::Combo("Anti-Aliasing", &pendingAntiAliasing, aaLabels, 4)) {
-                        static const VkSampleCountFlagBits aaSamples[] = {
-                            VK_SAMPLE_COUNT_1_BIT, VK_SAMPLE_COUNT_2_BIT,
-                            VK_SAMPLE_COUNT_4_BIT, VK_SAMPLE_COUNT_8_BIT
-                        };
-                        if (renderer) renderer->setMsaaSamples(aaSamples[pendingAntiAliasing]);
-                        updateGraphicsPresetFromCurrentSettings();
-                        saveCallback();
-                    }
-                    // FXAA — post-process, combinable with MSAA or FSR3
-                    {
-                        if (ImGui::Checkbox("FXAA (post-process)", &pendingFXAA)) {
-                            if (renderer) renderer->setFXAAEnabled(pendingFXAA);
-                            updateGraphicsPresetFromCurrentSettings();
-                            saveCallback();
-                        }
-                        if (ImGui::IsItemHovered()) {
-                            if (fsr2Active)
-                                ImGui::SetTooltip("FXAA applies spatial anti-aliasing after FSR3 upscaling.\nFSR3 + FXAA is the recommended ultra-quality combination.");
-                            else
-                                ImGui::SetTooltip("FXAA smooths jagged edges as a post-process pass.\nCan be combined with MSAA for extra quality.");
-                        }
-                    }
-                }
-                // FSR Upscaling
-                {
-                    // FSR mode selection: Off, FSR 1.0 (Spatial), FSR 3.x (Temporal)
-                    const char* fsrModeLabels[] = { "Off", "FSR 1.0 (Spatial)", "FSR 3.x (Temporal)" };
-                    int fsrMode = pendingUpscalingMode;
-                    if (ImGui::Combo("Upscaling", &fsrMode, fsrModeLabels, 3)) {
-                        pendingUpscalingMode = fsrMode;
-                        pendingFSR = (fsrMode == 1);
-                        if (renderer) {
-                            renderer->setFSREnabled(fsrMode == 1);
-                            renderer->setFSR2Enabled(fsrMode == 2);
-                        }
-                        saveCallback();
-                    }
-                    if (fsrMode > 0) {
-                        if (fsrMode == 2 && renderer) {
-                            ImGui::TextDisabled("FSR3 backend: %s",
-                                renderer->isAmdFsr2SdkAvailable() ? "AMD FidelityFX SDK" : "Internal fallback");
-                            if (renderer->isAmdFsr3FramegenSdkAvailable()) {
-                                if (ImGui::Checkbox("AMD FSR3 Frame Generation (Experimental)", &pendingAMDFramegen)) {
-                                    renderer->setAmdFsr3FramegenEnabled(pendingAMDFramegen);
-                                    saveCallback();
-                                }
-                                const char* runtimeStatus = "Unavailable";
-                                if (renderer->isAmdFsr3FramegenRuntimeActive()) {
-                                    runtimeStatus = "Active";
-                                } else if (renderer->isAmdFsr3FramegenRuntimeReady()) {
-                                    runtimeStatus = "Ready";
-                                } else {
-                                    runtimeStatus = "Unavailable";
-                                }
-                                ImGui::TextDisabled("Runtime: %s (%s)",
-                                    runtimeStatus, renderer->getAmdFsr3FramegenRuntimePath());
-                                if (!renderer->isAmdFsr3FramegenRuntimeReady()) {
-                                    const std::string& runtimeErr = renderer->getAmdFsr3FramegenRuntimeError();
-                                    if (!runtimeErr.empty()) {
-                                        ImGui::TextDisabled("Reason: %s", runtimeErr.c_str());
-                                    }
-                                }
-                            } else {
-                                ImGui::BeginDisabled();
-                                bool disabledFg = false;
-                                ImGui::Checkbox("AMD FSR3 Frame Generation (Experimental)", &disabledFg);
-                                ImGui::EndDisabled();
-                                ImGui::TextDisabled("Requires FidelityFX-SDK framegen headers.");
-                            }
-                        }
-                        const char* fsrQualityLabels[] = { "Native (100%)", "Ultra Quality (77%)", "Quality (67%)", "Balanced (59%)" };
-                        static constexpr float fsrScaleFactors[] = { 0.77f, 0.67f, 0.59f, 1.00f };
-                        static constexpr int displayToInternal[] = { 3, 0, 1, 2 };
-                        pendingFSRQuality = std::clamp(pendingFSRQuality, 0, 3);
-                        int fsrQualityDisplay = 0;
-                        for (int i = 0; i < 4; ++i) {
-                            if (displayToInternal[i] == pendingFSRQuality) {
-                                fsrQualityDisplay = i;
-                                break;
-                            }
-                        }
-                        if (ImGui::Combo("FSR Quality", &fsrQualityDisplay, fsrQualityLabels, 4)) {
-                            pendingFSRQuality = displayToInternal[fsrQualityDisplay];
-                            if (renderer) renderer->setFSRQuality(fsrScaleFactors[pendingFSRQuality]);
-                            saveCallback();
-                        }
-                        if (ImGui::SliderFloat("FSR Sharpness", &pendingFSRSharpness, 0.0f, 2.0f, "%.1f")) {
-                            if (renderer) renderer->setFSRSharpness(pendingFSRSharpness);
-                            saveCallback();
-                        }
-                        if (fsrMode == 2) {
-                            ImGui::SeparatorText("FSR3 Tuning");
-                            if (ImGui::SliderFloat("Jitter Sign", &pendingFSR2JitterSign, -2.0f, 2.0f, "%.2f")) {
-                                if (renderer) {
-                                    renderer->setFSR2DebugTuning(
-                                        pendingFSR2JitterSign,
-                                        pendingFSR2MotionVecScaleX,
-                                        pendingFSR2MotionVecScaleY);
-                                }
-                                saveCallback();
-                            }
-                            ImGui::TextDisabled("Tip: 0.38 is the current recommended default.");
-                        }
-                    }
-                }
-                if (ImGui::SliderInt("Ground Clutter Density", &pendingGroundClutterDensity, 0, 150, "%d%%")) {
-                    if (renderer) {
-                        if (auto* tm = renderer->getTerrainManager()) {
-                            tm->setGroundClutterDensityScale(static_cast<float>(pendingGroundClutterDensity) / 100.0f);
-                        }
-                    }
-                    saveCallback();
-                }
-                if (ImGui::Checkbox("Normal Mapping", &pendingNormalMapping)) {
-                    if (renderer) {
-                        if (auto* wr = renderer->getWMORenderer()) {
-                            wr->setNormalMappingEnabled(pendingNormalMapping);
-                        }
-                        if (auto* cr = renderer->getCharacterRenderer()) {
-                            cr->setNormalMappingEnabled(pendingNormalMapping);
-                        }
-                    }
-                    saveCallback();
-                }
-                if (pendingNormalMapping) {
-                    if (ImGui::SliderFloat("Normal Map Strength", &pendingNormalMapStrength, 0.0f, 2.0f, "%.1f")) {
-                        if (renderer) {
-                            if (auto* wr = renderer->getWMORenderer()) {
-                                wr->setNormalMapStrength(pendingNormalMapStrength);
-                            }
-                            if (auto* cr = renderer->getCharacterRenderer()) {
-                                cr->setNormalMapStrength(pendingNormalMapStrength);
-                            }
-                        }
-                        saveCallback();
-                    }
-                }
-                if (ImGui::Checkbox("Parallax Mapping", &pendingPOM)) {
-                    if (renderer) {
-                        if (auto* wr = renderer->getWMORenderer()) {
-                            wr->setPOMEnabled(pendingPOM);
-                        }
-                        if (auto* cr = renderer->getCharacterRenderer()) {
-                            cr->setPOMEnabled(pendingPOM);
-                        }
-                    }
-                    saveCallback();
-                }
-                if (pendingPOM) {
-                    const char* pomLabels[] = { "Low", "Medium", "High" };
-                    if (ImGui::Combo("Parallax Quality", &pendingPOMQuality, pomLabels, 3)) {
-                        if (renderer) {
-                            if (auto* wr = renderer->getWMORenderer()) {
-                                wr->setPOMQuality(pendingPOMQuality);
-                            }
-                            if (auto* cr = renderer->getCharacterRenderer()) {
-                                cr->setPOMQuality(pendingPOMQuality);
-                            }
-                        }
-                        saveCallback();
-                    }
-                }
-
-                const char* resLabel = "Resolution";
-                const char* resItems[kResCount];
-                char resBuf[kResCount][16];
-                for (int i = 0; i < kResCount; i++) {
-                    snprintf(resBuf[i], sizeof(resBuf[i]), "%dx%d", kResolutions[i][0], kResolutions[i][1]);
-                    resItems[i] = resBuf[i];
-                }
-                if (ImGui::Combo(resLabel, &pendingResIndex, resItems, kResCount)) {
-                    window->applyResolution(kResolutions[pendingResIndex][0], kResolutions[pendingResIndex][1]);
-                    saveCallback();
-                }
-
-                ImGui::Spacing();
-                ImGui::Separator();
-                ImGui::Spacing();
-
-                ImGui::SetNextItemWidth(200.0f);
-                if (ImGui::SliderInt("Brightness", &pendingBrightness, 0, 100, "%d%%")) {
-                    if (renderer) renderer->setBrightness(static_cast<float>(pendingBrightness) / 50.0f);
-                    saveCallback();
-                }
-
-                ImGui::Spacing();
-                ImGui::Separator();
-                ImGui::Spacing();
-
-                if (ImGui::Button("Restore Video Defaults", ImVec2(-1, 0))) {
-                    pendingFullscreen = kDefaultFullscreen;
-                    pendingVsync = kDefaultVsync;
-                    pendingShadows = kDefaultShadows;
-                    pendingShadowDistance = 300.0f;
-                    pendingGroundClutterDensity = kDefaultGroundClutterDensity;
-                    pendingAntiAliasing = 0;
-                    pendingNormalMapping = true;
-                    pendingNormalMapStrength = 0.8f;
-                    pendingPOM = true;
-                    pendingPOMQuality = 1;
-                    pendingResIndex = defaultResIndex;
-                    pendingBrightness = 50;
-                    window->setFullscreen(pendingFullscreen);
-                    window->setVsync(pendingVsync);
-                    window->applyResolution(kResolutions[pendingResIndex][0], kResolutions[pendingResIndex][1]);
-                    if (renderer) renderer->setBrightness(1.0f);
-                    pendingWaterRefraction = false;
-                    if (renderer) {
-                        renderer->setShadowsEnabled(pendingShadows);
-                        renderer->setShadowDistance(pendingShadowDistance);
-                    }
-                    if (renderer) renderer->setWaterRefractionEnabled(pendingWaterRefraction);
-                    if (renderer) renderer->setMsaaSamples(VK_SAMPLE_COUNT_1_BIT);
-                    if (renderer) {
-                        if (auto* tm = renderer->getTerrainManager()) {
-                            tm->setGroundClutterDensityScale(static_cast<float>(pendingGroundClutterDensity) / 100.0f);
-                        }
-                    }
-                    if (renderer) {
-                        if (auto* wr = renderer->getWMORenderer()) {
-                            wr->setNormalMappingEnabled(pendingNormalMapping);
-                            wr->setNormalMapStrength(pendingNormalMapStrength);
-                            wr->setPOMEnabled(pendingPOM);
-                            wr->setPOMQuality(pendingPOMQuality);
-                        }
-                        if (auto* cr = renderer->getCharacterRenderer()) {
-                            cr->setNormalMappingEnabled(pendingNormalMapping);
-                            cr->setNormalMapStrength(pendingNormalMapStrength);
-                            cr->setPOMEnabled(pendingPOM);
-                            cr->setPOMQuality(pendingPOMQuality);
-                        }
-                    }
-                    saveCallback();
-                }
-
-                ImGui::EndTabItem();
-            }
-
-            // ============================================================
-            // INTERFACE TAB
-            // ============================================================
-            if (ImGui::BeginTabItem("Interface")) {
-                renderSettingsInterfaceTab(saveCallback);
-                ImGui::EndTabItem();
-            }
-
-            // ============================================================
-            // AUDIO TAB
-            // ============================================================
-            if (ImGui::BeginTabItem("Audio")) {
-                renderSettingsAudioTab(saveCallback);
-                ImGui::EndTabItem();
-            }
-
-            // ============================================================
-            // GAMEPLAY TAB
-            // ============================================================
-            if (ImGui::BeginTabItem("Gameplay")) {
-                renderSettingsGameplayTab(inventoryScreen, saveCallback);
-                ImGui::EndTabItem();
-            }
-
-            // ============================================================
-            // CONTROLS TAB
-            // ============================================================
-            if (ImGui::BeginTabItem("Controls")) {
-                renderSettingsControlsTab(saveCallback);
-                ImGui::EndTabItem();
-            }
-
-            // ============================================================
-            // CHAT TAB
-            // ============================================================
-            if (ImGui::BeginTabItem("Chat")) {
-                chatPanel.renderSettingsTab(saveCallback);
-                ImGui::EndTabItem();
-            }
-
-            // ============================================================
-            // ABOUT TAB
-            // ============================================================
-            if (ImGui::BeginTabItem("About")) {
-                renderSettingsAboutTab();
-                ImGui::EndTabItem();
-            }
-
-            ImGui::EndTabBar();
-        }
-
-        ImGui::Spacing();
-        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(10.0f, 10.0f));
-        if (ImGui::Button("Back to Game", ImVec2(-1, 0))) {
-            showSettingsWindow = false;
-        }
-        ImGui::PopStyleVar();
-    }
-    ImGui::End();
-}
-
-void SettingsPanel::applyGraphicsPreset(GraphicsPreset preset) {
-    auto* renderer = services_.renderer;
-
-    // Define preset values based on quality level
-    switch (preset) {
-        case GraphicsPreset::LOW: {
-            pendingShadows = false;
-            pendingShadowDistance = 100.0f;
-            pendingAntiAliasing = 0;  // Off
-            pendingNormalMapping = false;
-            pendingPOM = false;
-            pendingGroundClutterDensity = 25;
-            if (renderer) {
-                renderer->setShadowsEnabled(false);
-                renderer->setMsaaSamples(VK_SAMPLE_COUNT_1_BIT);
-                if (auto* wr = renderer->getWMORenderer()) {
-                    wr->setNormalMappingEnabled(false);
-                    wr->setPOMEnabled(false);
-                }
-                if (auto* cr = renderer->getCharacterRenderer()) {
-                    cr->setNormalMappingEnabled(false);
-                    cr->setPOMEnabled(false);
-                }
-                if (auto* tm = renderer->getTerrainManager()) {
-                    tm->setGroundClutterDensityScale(0.25f);
-                }
-            }
-            break;
-        }
-        case GraphicsPreset::MEDIUM: {
-            pendingShadows = true;
-            pendingShadowDistance = 200.0f;
-            pendingAntiAliasing = 1;  // 2x MSAA
-            pendingNormalMapping = true;
-            pendingNormalMapStrength = 0.6f;
-            pendingPOM = true;
-            pendingPOMQuality = 0;  // Low
-            pendingGroundClutterDensity = 60;
-            if (renderer) {
-                renderer->setShadowsEnabled(true);
-                renderer->setShadowDistance(200.0f);
-                renderer->setMsaaSamples(VK_SAMPLE_COUNT_2_BIT);
-                if (auto* wr = renderer->getWMORenderer()) {
-                    wr->setNormalMappingEnabled(true);
-                    wr->setNormalMapStrength(0.6f);
-                    wr->setPOMEnabled(true);
-                    wr->setPOMQuality(0);
-                }
-                if (auto* cr = renderer->getCharacterRenderer()) {
-                    cr->setNormalMappingEnabled(true);
-                    cr->setNormalMapStrength(0.6f);
-                    cr->setPOMEnabled(true);
-                    cr->setPOMQuality(0);
-                }
-                if (auto* tm = renderer->getTerrainManager()) {
-                    tm->setGroundClutterDensityScale(0.60f);
-                }
-            }
-            break;
-        }
-        case GraphicsPreset::HIGH: {
-            pendingShadows = true;
-            pendingShadowDistance = 350.0f;
-            pendingAntiAliasing = 2;  // 4x MSAA
-            pendingNormalMapping = true;
-            pendingNormalMapStrength = 0.8f;
-            pendingPOM = true;
-            pendingPOMQuality = 1;  // Medium
-            pendingGroundClutterDensity = 100;
-            if (renderer) {
-                renderer->setShadowsEnabled(true);
-                renderer->setShadowDistance(350.0f);
-                renderer->setMsaaSamples(VK_SAMPLE_COUNT_4_BIT);
-                if (auto* wr = renderer->getWMORenderer()) {
-                    wr->setNormalMappingEnabled(true);
-                    wr->setNormalMapStrength(0.8f);
-                    wr->setPOMEnabled(true);
-                    wr->setPOMQuality(1);
-                }
-                if (auto* cr = renderer->getCharacterRenderer()) {
-                    cr->setNormalMappingEnabled(true);
-                    cr->setNormalMapStrength(0.8f);
-                    cr->setPOMEnabled(true);
-                    cr->setPOMQuality(1);
-                }
-                if (auto* tm = renderer->getTerrainManager()) {
-                    tm->setGroundClutterDensityScale(1.0f);
-                }
-            }
-            break;
-        }
-        case GraphicsPreset::ULTRA: {
-            pendingShadows = true;
-            pendingShadowDistance = 500.0f;
-            pendingAntiAliasing = 3;  // 8x MSAA
-            pendingFXAA = true;       // FXAA on top of MSAA for maximum smoothness
-            pendingNormalMapping = true;
-            pendingNormalMapStrength = 1.2f;
-            pendingPOM = true;
-            pendingPOMQuality = 2;  // High
-            pendingGroundClutterDensity = 150;
-            if (renderer) {
-                renderer->setShadowsEnabled(true);
-                renderer->setShadowDistance(500.0f);
-                renderer->setMsaaSamples(VK_SAMPLE_COUNT_8_BIT);
-                renderer->setFXAAEnabled(true);
-                if (auto* wr = renderer->getWMORenderer()) {
-                    wr->setNormalMappingEnabled(true);
-                    wr->setNormalMapStrength(1.2f);
-                    wr->setPOMEnabled(true);
-                    wr->setPOMQuality(2);
-                }
-                if (auto* cr = renderer->getCharacterRenderer()) {
-                    cr->setNormalMappingEnabled(true);
-                    cr->setNormalMapStrength(1.2f);
-                    cr->setPOMEnabled(true);
-                    cr->setPOMQuality(2);
-                }
-                if (auto* tm = renderer->getTerrainManager()) {
-                    tm->setGroundClutterDensityScale(1.5f);
-                }
-            }
-            break;
-        }
-        default:
-            break;
-    }
-
-    currentGraphicsPreset = preset;
-    pendingGraphicsPreset = preset;
-}
-
-void SettingsPanel::updateGraphicsPresetFromCurrentSettings() {
-    // Check if current settings match any preset, otherwise mark as CUSTOM
-    // This is a simplified check; could be enhanced with more detailed matching
-
-    auto matchesPreset = [this](GraphicsPreset preset) -> bool {
-        switch (preset) {
-            case GraphicsPreset::LOW:
-                return !pendingShadows && pendingAntiAliasing == 0 && !pendingNormalMapping && !pendingPOM &&
-                       pendingGroundClutterDensity <= 30;
-            case GraphicsPreset::MEDIUM:
-                return pendingShadows && pendingShadowDistance >= 180 && pendingShadowDistance <= 220 &&
-                       pendingAntiAliasing == 1 && pendingNormalMapping && pendingPOM &&
-                       pendingGroundClutterDensity >= 50 && pendingGroundClutterDensity <= 70;
-            case GraphicsPreset::HIGH:
-                return pendingShadows && pendingShadowDistance >= 330 && pendingShadowDistance <= 370 &&
-                       pendingAntiAliasing == 2 && pendingNormalMapping && pendingPOM &&
-                       pendingGroundClutterDensity >= 90 && pendingGroundClutterDensity <= 110;
-            case GraphicsPreset::ULTRA:
-                return pendingShadows && pendingShadowDistance >= 480 && pendingAntiAliasing == 3 &&
-                       pendingFXAA && pendingNormalMapping && pendingPOM && pendingGroundClutterDensity >= 140;
-            default:
-                return false;
-        }
-    };
-
-    // Try to match a preset, otherwise mark as custom
-    if (matchesPreset(GraphicsPreset::LOW)) {
-        pendingGraphicsPreset = GraphicsPreset::LOW;
-    } else if (matchesPreset(GraphicsPreset::MEDIUM)) {
-        pendingGraphicsPreset = GraphicsPreset::MEDIUM;
-    } else if (matchesPreset(GraphicsPreset::HIGH)) {
-        pendingGraphicsPreset = GraphicsPreset::HIGH;
-    } else if (matchesPreset(GraphicsPreset::ULTRA)) {
-        pendingGraphicsPreset = GraphicsPreset::ULTRA;
-    } else {
-        pendingGraphicsPreset = GraphicsPreset::CUSTOM;
-    }
-}
-
-std::string SettingsPanel::getSettingsPath() {
-    std::string dir;
-#ifdef _WIN32
-    const char* appdata = std::getenv("APPDATA");
-    dir = appdata ? std::string(appdata) + "\\wowee" : ".";
-#else
-    const char* home = std::getenv("HOME");
-    dir = home ? std::string(home) + "/.wowee" : ".";
-#endif
-    return dir + "/settings.cfg";
-}
-
-void SettingsPanel::applyAudioVolumes(audio::AudioCoordinator* ac) {
-    if (!ac) return;
-    float masterScale = soundMuted_ ? 0.0f : static_cast<float>(pendingMasterVolume) / 100.0f;
-    audio::AudioEngine::instance().setMasterVolume(masterScale);
-    if (auto* music = ac->getMusicManager())
-        music->setVolume(pendingMusicVolume);
-    if (auto* ambient = ac->getAmbientSoundManager())
-        ambient->setVolumeScale(pendingAmbientVolume / 100.0f);
-    if (auto* ui = ac->getUiSoundManager())
-        ui->setVolumeScale(pendingUiVolume / 100.0f);
-    if (auto* combat = ac->getCombatSoundManager())
-        combat->setVolumeScale(pendingCombatVolume / 100.0f);
-    if (auto* spell = ac->getSpellSoundManager())
-        spell->setVolumeScale(pendingSpellVolume / 100.0f);
-    if (auto* movement = ac->getMovementSoundManager())
-        movement->setVolumeScale(pendingMovementVolume / 100.0f);
-    if (auto* footstep = ac->getFootstepManager())
-        footstep->setVolumeScale(pendingFootstepVolume / 100.0f);
-    if (auto* npcVoice = ac->getNpcVoiceManager())
-        npcVoice->setVolumeScale(pendingNpcVoiceVolume / 100.0f);
-    if (auto* mount = ac->getMountSoundManager())
-        mount->setVolumeScale(pendingMountVolume / 100.0f);
-    if (auto* activity = ac->getActivitySoundManager())
-        activity->setVolumeScale(pendingActivityVolume / 100.0f);
-}
-
-
-} // namespace ui
-} // namespace wowee
diff --git a/src/ui/social_panel.cpp b/src/ui/social_panel.cpp
deleted file mode 100644
index 6d9af7c9..00000000
--- a/src/ui/social_panel.cpp
+++ /dev/null
@@ -1,2585 +0,0 @@
-// ============================================================
-// SocialPanel — extracted from GameScreen
-// Owns all social/group-related UI rendering: party frames,
-// boss frames, guild roster, social/friends frame, dungeon finder,
-// who window, inspect window.
-// ============================================================
-#include "ui/social_panel.hpp"
-#include "ui/chat_panel.hpp"
-#include "ui/spellbook_screen.hpp"
-#include "ui/inventory_screen.hpp"
-#include "ui/ui_colors.hpp"
-#include "ui/ui_helpers.hpp"
-#include "core/application.hpp"
-#include "core/logger.hpp"
-#include "rendering/renderer.hpp"
-#include "game/game_handler.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "pipeline/dbc_layout.hpp"
-#include "ui/keybinding_manager.hpp"
-#include "game/zone_manager.hpp"
-#include <imgui.h>
-#include <imgui_internal.h>
-#include <algorithm>
-#include <cmath>
-#include <cstdio>
-#include <string>
-
-namespace {
-    using namespace wowee::ui::colors;
-    using namespace wowee::ui::helpers;
-    constexpr auto& kColorRed         = kRed;
-    constexpr auto& kColorGreen       = kGreen;
-    constexpr auto& kColorBrightGreen = kBrightGreen;
-    constexpr auto& kColorYellow      = kYellow;
-    constexpr auto& kColorGray        = kGray;
-    constexpr auto& kColorDarkGray    = kDarkGray;
-} // anonymous namespace
-
-namespace wowee {
-namespace ui {
-
-
-void SocialPanel::renderPartyFrames(game::GameHandler& gameHandler,
-                                       ChatPanel& chatPanel,
-                                       SpellIconFn getSpellIcon) {
-    if (!gameHandler.isInGroup()) return;
-
-    auto* assetMgr = services_.assetManager;
-    const auto& partyData = gameHandler.getPartyData();
-    const bool isRaid = (partyData.groupType == 1);
-    float frameY = 120.0f;
-
-    // ---- Raid frame layout ----
-    if (isRaid) {
-        // Organize members by subgroup (0-7, up to 5 members each)
-        constexpr int MAX_SUBGROUPS = 8;
-        constexpr int MAX_PER_GROUP = 5;
-        std::vector<const game::GroupMember*> subgroups[MAX_SUBGROUPS];
-        for (const auto& m : partyData.members) {
-            int sg = m.subGroup < MAX_SUBGROUPS ? m.subGroup : 0;
-            if (static_cast<int>(subgroups[sg].size()) < MAX_PER_GROUP)
-                subgroups[sg].push_back(&m);
-        }
-
-        // Count non-empty subgroups to determine layout
-        int activeSgs = 0;
-        for (int sg = 0; sg < MAX_SUBGROUPS; sg++)
-            if (!subgroups[sg].empty()) activeSgs++;
-
-        // Compact raid cell: name + 2 narrow bars
-        constexpr float CELL_W = 90.0f;
-        constexpr float CELL_H = 42.0f;
-        constexpr float BAR_H  = 7.0f;
-        constexpr float CELL_PAD = 3.0f;
-
-        float winW = activeSgs * (CELL_W + CELL_PAD) + CELL_PAD + 8.0f;
-        float winH = MAX_PER_GROUP * (CELL_H + CELL_PAD) + CELL_PAD + 20.0f;
-
-        auto* window = services_.window;
-        float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-        float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-        float raidX = (screenW - winW) / 2.0f;
-        float raidY = screenH - winH - 120.0f;  // above action bar area
-
-        ImGui::SetNextWindowPos(ImVec2(raidX, raidY), ImGuiCond_Always);
-        ImGui::SetNextWindowSize(ImVec2(winW, winH), ImGuiCond_Always);
-
-        ImGuiWindowFlags raidFlags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-                                     ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
-                                     ImGuiWindowFlags_NoScrollbar;
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(CELL_PAD, CELL_PAD));
-        ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.07f, 0.07f, 0.1f, 0.85f));
-
-        if (ImGui::Begin("##RaidFrames", nullptr, raidFlags)) {
-            ImDrawList* draw = ImGui::GetWindowDrawList();
-            ImVec2 winPos = ImGui::GetWindowPos();
-
-            int colIdx = 0;
-            for (int sg = 0; sg < MAX_SUBGROUPS; sg++) {
-                if (subgroups[sg].empty()) continue;
-
-                float colX = winPos.x + CELL_PAD + colIdx * (CELL_W + CELL_PAD);
-
-                for (int row = 0; row < static_cast<int>(subgroups[sg].size()); row++) {
-                    const auto& m = *subgroups[sg][row];
-                    float cellY = winPos.y + CELL_PAD + 14.0f + row * (CELL_H + CELL_PAD);
-
-                    ImVec2 cellMin(colX, cellY);
-                    ImVec2 cellMax(colX + CELL_W, cellY + CELL_H);
-
-                    // Cell background
-                    bool isTarget = (gameHandler.getTargetGuid() == m.guid);
-                    ImU32 bg = isTarget ? IM_COL32(60, 80, 120, 200) : IM_COL32(30, 30, 40, 180);
-                    draw->AddRectFilled(cellMin, cellMax, bg, 3.0f);
-                    if (isTarget)
-                        draw->AddRect(cellMin, cellMax, IM_COL32(100, 150, 255, 200), 3.0f);
-
-                    // Dead/ghost overlay
-                    bool isOnline = (m.onlineStatus & 0x0001) != 0;
-                    bool isDead   = (m.onlineStatus & 0x0020) != 0;
-                    bool isGhost  = (m.onlineStatus & 0x0010) != 0;
-
-                    // Out-of-range check (40 yard threshold)
-                    bool isOOR = false;
-                    if (m.hasPartyStats && isOnline && !isDead && !isGhost && m.zoneId != 0) {
-                        auto playerEnt = gameHandler.getEntityManager().getEntity(gameHandler.getPlayerGuid());
-                        if (playerEnt) {
-                            float dx = playerEnt->getX() - static_cast<float>(m.posX);
-                            float dy = playerEnt->getY() - static_cast<float>(m.posY);
-                            isOOR = (dx * dx + dy * dy) > (40.0f * 40.0f);
-                        }
-                    }
-                    // Dim cell overlay when out of range
-                    if (isOOR)
-                        draw->AddRectFilled(cellMin, cellMax, IM_COL32(0, 0, 0, 80), 3.0f);
-
-                    // Name text (truncated) — class color when alive+online, gray when dead/offline
-                    char truncName[16];
-                    snprintf(truncName, sizeof(truncName), "%.12s", m.name.c_str());
-                    bool isMemberLeader = (m.guid == partyData.leaderGuid);
-                    ImU32 nameCol;
-                    if (!isOnline || isDead || isGhost) {
-                        nameCol = IM_COL32(140, 140, 140, 200); // gray for dead/offline
-                    } else {
-                        // Default: gold for leader, light gray for others
-                        nameCol = isMemberLeader ? IM_COL32(255, 215, 0, 255) : IM_COL32(220, 220, 220, 255);
-                        // Override with WoW class color if entity is loaded
-                        auto mEnt = gameHandler.getEntityManager().getEntity(m.guid);
-                        uint8_t cid = entityClassId(mEnt.get());
-                        if (cid != 0) nameCol = classColorU32(cid);
-                    }
-                    draw->AddText(ImVec2(cellMin.x + 4.0f, cellMin.y + 3.0f), nameCol, truncName);
-
-                    // Leader crown star in top-right of cell
-                    if (isMemberLeader)
-                        draw->AddText(ImVec2(cellMax.x - 10.0f, cellMin.y + 2.0f), IM_COL32(255, 215, 0, 255), "*");
-
-                    // Raid mark symbol — small, just to the left of the leader crown
-                    {
-                        static constexpr struct { const char* sym; ImU32 col; } kCellMarks[] = {
-                            { "\xe2\x98\x85", IM_COL32(255, 220,  50, 255) },
-                            { "\xe2\x97\x8f", IM_COL32(255, 140,   0, 255) },
-                            { "\xe2\x97\x86", IM_COL32(160,  32, 240, 255) },
-                            { "\xe2\x96\xb2", IM_COL32( 50, 200,  50, 255) },
-                            { "\xe2\x97\x8c", IM_COL32( 80, 160, 255, 255) },
-                            { "\xe2\x96\xa0", IM_COL32( 50, 200, 220, 255) },
-                            { "\xe2\x9c\x9d", IM_COL32(255,  80,  80, 255) },
-                            { "\xe2\x98\xa0", IM_COL32(255, 255, 255, 255) },
-                        };
-                        uint8_t rmk = gameHandler.getEntityRaidMark(m.guid);
-                        if (rmk < game::GameHandler::kRaidMarkCount) {
-                            ImFont* rmFont = ImGui::GetFont();
-                            ImVec2 rmsz = rmFont->CalcTextSizeA(9.0f, FLT_MAX, 0.0f, kCellMarks[rmk].sym);
-                            float rmX = cellMax.x - 10.0f - 2.0f - rmsz.x;
-                            draw->AddText(rmFont, 9.0f,
-                                ImVec2(rmX, cellMin.y + 2.0f),
-                                kCellMarks[rmk].col, kCellMarks[rmk].sym);
-                        }
-                    }
-
-                    // LFG role badge in bottom-right corner of cell
-                    if (m.roles & 0x02)
-                        draw->AddText(ImVec2(cellMax.x - 11.0f, cellMax.y - 11.0f), IM_COL32(80, 130, 255, 230), "T");
-                    else if (m.roles & 0x04)
-                        draw->AddText(ImVec2(cellMax.x - 11.0f, cellMax.y - 11.0f), IM_COL32(60, 220, 80, 230), "H");
-                    else if (m.roles & 0x08)
-                        draw->AddText(ImVec2(cellMax.x - 11.0f, cellMax.y - 11.0f), IM_COL32(220, 80, 80, 230), "D");
-
-                    // Tactical role badge in bottom-left corner (flags from SMSG_GROUP_LIST / SMSG_REAL_GROUP_UPDATE)
-                    // 0x01=Assistant, 0x02=Main Tank, 0x04=Main Assist
-                    if (m.flags & 0x02)
-                        draw->AddText(ImVec2(cellMin.x + 2.0f, cellMax.y - 11.0f), IM_COL32(255, 140, 0, 230), "MT");
-                    else if (m.flags & 0x04)
-                        draw->AddText(ImVec2(cellMin.x + 2.0f, cellMax.y - 11.0f), IM_COL32(100, 180, 255, 230), "MA");
-                    else if (m.flags & 0x01)
-                        draw->AddText(ImVec2(cellMin.x + 2.0f, cellMax.y - 11.0f), IM_COL32(180, 215, 255, 180), "A");
-
-                    // Health bar
-                    uint32_t hp = m.hasPartyStats ? m.curHealth : 0;
-                    uint32_t maxHp = m.hasPartyStats ? m.maxHealth : 0;
-                    if (maxHp > 0) {
-                        float pct = static_cast<float>(hp) / static_cast<float>(maxHp);
-                        float barY = cellMin.y + 16.0f;
-                        ImVec2 barBg(cellMin.x + 3.0f, barY);
-                        ImVec2 barBgEnd(cellMax.x - 3.0f, barY + BAR_H);
-                        draw->AddRectFilled(barBg, barBgEnd, IM_COL32(40, 40, 40, 200), 2.0f);
-                        ImVec2 barFill(barBg.x, barBg.y);
-                        ImVec2 barFillEnd(barBg.x + (barBgEnd.x - barBg.x) * pct, barBgEnd.y);
-                        ImU32 hpCol = isOOR ? IM_COL32(100, 100, 100, 160) :
-                                     pct > 0.5f ? IM_COL32(60, 180, 60, 255) :
-                                     pct > 0.2f ? IM_COL32(200, 180, 50, 255) :
-                                                  IM_COL32(200, 60, 60, 255);
-                        draw->AddRectFilled(barFill, barFillEnd, hpCol, 2.0f);
-                        // HP percentage or OOR text centered on bar
-                        char hpPct[8];
-                        if (isOOR)
-                            snprintf(hpPct, sizeof(hpPct), "OOR");
-                        else
-                            snprintf(hpPct, sizeof(hpPct), "%d%%", static_cast<int>(pct * 100.0f + 0.5f));
-                        ImVec2 ts = ImGui::CalcTextSize(hpPct);
-                        float tx = (barBg.x + barBgEnd.x - ts.x) * 0.5f;
-                        float ty = barBg.y + (BAR_H - ts.y) * 0.5f;
-                        draw->AddText(ImVec2(tx + 1.0f, ty + 1.0f), IM_COL32(0, 0, 0, 180), hpPct);
-                        draw->AddText(ImVec2(tx, ty), IM_COL32(255, 255, 255, 230), hpPct);
-                    }
-
-                    // Power bar
-                    if (m.hasPartyStats && m.maxPower > 0) {
-                        float pct = static_cast<float>(m.curPower) / static_cast<float>(m.maxPower);
-                        float barY = cellMin.y + 16.0f + BAR_H + 2.0f;
-                        ImVec2 barBg(cellMin.x + 3.0f, barY);
-                        ImVec2 barBgEnd(cellMax.x - 3.0f, barY + BAR_H - 2.0f);
-                        draw->AddRectFilled(barBg, barBgEnd, IM_COL32(30, 30, 40, 200), 2.0f);
-                        ImVec2 barFill(barBg.x, barBg.y);
-                        ImVec2 barFillEnd(barBg.x + (barBgEnd.x - barBg.x) * pct, barBgEnd.y);
-                        ImU32 pwrCol;
-                        switch (m.powerType) {
-                            case 0: pwrCol = IM_COL32(50, 80, 220, 255); break; // Mana
-                            case 1: pwrCol = IM_COL32(200, 50, 50, 255); break; // Rage
-                            case 3: pwrCol = IM_COL32(220, 210, 50, 255); break; // Energy
-                            case 6: pwrCol = IM_COL32(180, 30, 50, 255); break; // Runic Power
-                            default: pwrCol = IM_COL32(80, 120, 80, 255); break;
-                        }
-                        draw->AddRectFilled(barFill, barFillEnd, pwrCol, 2.0f);
-                    }
-
-                    // Dispellable debuff dots at the bottom of the raid cell
-                    // Mirrors party frame debuff indicators for healers in 25/40-man raids
-                    if (!isDead && !isGhost) {
-                        const std::vector<game::AuraSlot>* unitAuras = nullptr;
-                        if (m.guid == gameHandler.getPlayerGuid())
-                            unitAuras = &gameHandler.getPlayerAuras();
-                        else if (m.guid == gameHandler.getTargetGuid())
-                            unitAuras = &gameHandler.getTargetAuras();
-                        else
-                            unitAuras = gameHandler.getUnitAuras(m.guid);
-
-                        if (unitAuras) {
-                            bool shown[5] = {};
-                            float dotX = cellMin.x + 4.0f;
-                            const float dotY  = cellMax.y - 5.0f;
-                            const float DOT_R = 3.5f;
-                            ImVec2 mouse = ImGui::GetMousePos();
-                            for (const auto& aura : *unitAuras) {
-                                if (aura.isEmpty()) continue;
-                                if ((aura.flags & 0x80) == 0) continue; // debuffs only
-                                uint8_t dt = gameHandler.getSpellDispelType(aura.spellId);
-                                if (dt == 0 || dt > 4 || shown[dt]) continue;
-                                shown[dt] = true;
-                                ImVec4 dc;
-                                switch (dt) {
-                                    case 1: dc = ImVec4(0.25f, 0.50f, 1.00f, 0.90f); break; // Magic: blue
-                                    case 2: dc = ImVec4(0.70f, 0.15f, 0.90f, 0.90f); break; // Curse: purple
-                                    case 3: dc = ImVec4(0.65f, 0.45f, 0.10f, 0.90f); break; // Disease: brown
-                                    case 4: dc = ImVec4(0.10f, 0.75f, 0.10f, 0.90f); break; // Poison: green
-                                    default: continue;
-                                }
-                                ImU32 dotColU = ImGui::ColorConvertFloat4ToU32(dc);
-                                draw->AddCircleFilled(ImVec2(dotX, dotY), DOT_R, dotColU);
-                                draw->AddCircle(ImVec2(dotX, dotY), DOT_R + 0.5f, IM_COL32(0, 0, 0, 160), 8, 1.0f);
-
-                                float mdx = mouse.x - dotX, mdy = mouse.y - dotY;
-                                if (mdx * mdx + mdy * mdy < (DOT_R + 4.0f) * (DOT_R + 4.0f)) {
-                                    ImGui::BeginTooltip();
-                                    ImGui::TextColored(dc, "%s", kDispelNames[dt]);
-                                    for (const auto& da : *unitAuras) {
-                                        if (da.isEmpty() || (da.flags & 0x80) == 0) continue;
-                                        if (gameHandler.getSpellDispelType(da.spellId) != dt) continue;
-                                        const std::string& dName = gameHandler.getSpellName(da.spellId);
-                                        if (!dName.empty())
-                                            ImGui::Text("  %s", dName.c_str());
-                                    }
-                                    ImGui::EndTooltip();
-                                }
-                                dotX += 9.0f;
-                            }
-                        }
-                    }
-
-                    // Clickable invisible region over the whole cell
-                    ImGui::SetCursorScreenPos(cellMin);
-                    ImGui::PushID(static_cast<int>(m.guid));
-                    if (ImGui::InvisibleButton("raidCell", ImVec2(CELL_W, CELL_H))) {
-                        gameHandler.setTarget(m.guid);
-                    }
-                    if (ImGui::IsItemHovered()) {
-                        gameHandler.setMouseoverGuid(m.guid);
-                    }
-                    if (ImGui::BeginPopupContextItem("RaidMemberCtx")) {
-                        ImGui::TextDisabled("%s", m.name.c_str());
-                        ImGui::Separator();
-                        if (ImGui::MenuItem("Target"))
-                            gameHandler.setTarget(m.guid);
-                        if (ImGui::MenuItem("Set Focus"))
-                            gameHandler.setFocus(m.guid);
-                        if (ImGui::MenuItem("Whisper")) {
-                            chatPanel.setWhisperTarget(m.name);
-                        }
-                        if (ImGui::MenuItem("Trade"))
-                            gameHandler.initiateTrade(m.guid);
-                        if (ImGui::MenuItem("Inspect")) {
-                            gameHandler.setTarget(m.guid);
-                            gameHandler.inspectTarget();
-                            showInspectWindow_ = true;
-                        }
-                        bool isLeader = (partyData.leaderGuid == gameHandler.getPlayerGuid());
-                        if (isLeader) {
-                            ImGui::Separator();
-                            if (ImGui::MenuItem("Kick from Raid"))
-                                gameHandler.uninvitePlayer(m.name);
-                        }
-                        ImGui::Separator();
-                        if (ImGui::BeginMenu("Set Raid Mark")) {
-                            for (int mi = 0; mi < 8; ++mi) {
-                                if (ImGui::MenuItem(kRaidMarkNames[mi]))
-                                    gameHandler.setRaidMark(m.guid, static_cast<uint8_t>(mi));
-                            }
-                            ImGui::Separator();
-                            if (ImGui::MenuItem("Clear Mark"))
-                                gameHandler.setRaidMark(m.guid, 0xFF);
-                            ImGui::EndMenu();
-                        }
-                        ImGui::EndPopup();
-                    }
-                    ImGui::PopID();
-                }
-                colIdx++;
-            }
-
-            // Subgroup header row
-            colIdx = 0;
-            for (int sg = 0; sg < MAX_SUBGROUPS; sg++) {
-                if (subgroups[sg].empty()) continue;
-                float colX = winPos.x + CELL_PAD + colIdx * (CELL_W + CELL_PAD);
-                char sgLabel[8];
-                snprintf(sgLabel, sizeof(sgLabel), "G%d", sg + 1);
-                draw->AddText(ImVec2(colX + CELL_W / 2 - 8.0f, winPos.y + CELL_PAD), IM_COL32(160, 160, 180, 200), sgLabel);
-                colIdx++;
-            }
-        }
-        ImGui::End();
-        ImGui::PopStyleColor();
-        ImGui::PopStyleVar(2);
-        return;
-    }
-
-    // ---- Party frame layout (5-man) ----
-    ImGui::SetNextWindowPos(ImVec2(10.0f, frameY), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(200.0f, 0.0f), ImGuiCond_Always);
-
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
-                             ImGuiWindowFlags_AlwaysAutoResize;
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.1f, 0.1f, 0.1f, 0.8f));
-
-    if (ImGui::Begin("##PartyFrames", nullptr, flags)) {
-        const uint64_t leaderGuid = partyData.leaderGuid;
-        for (const auto& member : partyData.members) {
-            ImGui::PushID(static_cast<int>(member.guid));
-
-            bool isLeader = (member.guid == leaderGuid);
-
-            // Name with level and status info — leader gets a gold star prefix
-            std::string label = (isLeader ? "* " : "  ") + member.name;
-            if (member.hasPartyStats && member.level > 0) {
-                label += " [" + std::to_string(member.level) + "]";
-            }
-            if (member.hasPartyStats) {
-                bool isOnline = (member.onlineStatus & 0x0001) != 0;
-                bool isDead = (member.onlineStatus & 0x0020) != 0;
-                bool isGhost = (member.onlineStatus & 0x0010) != 0;
-                if (!isOnline) label += " (offline)";
-                else if (isDead || isGhost) label += " (dead)";
-            }
-
-            // Clickable name to target — use WoW class colors when entity is loaded,
-            // fall back to gold for leader / light gray for others
-            ImVec4 nameColor = isLeader
-                ? colors::kBrightGold
-                : colors::kVeryLightGray;
-            {
-                auto memberEntity = gameHandler.getEntityManager().getEntity(member.guid);
-                uint8_t cid = entityClassId(memberEntity.get());
-                if (cid != 0) nameColor = classColorVec4(cid);
-            }
-            ImGui::PushStyleColor(ImGuiCol_Text, nameColor);
-            if (ImGui::Selectable(label.c_str(), gameHandler.getTargetGuid() == member.guid)) {
-                gameHandler.setTarget(member.guid);
-            }
-            // Set mouseover for [target=mouseover] macro conditionals
-            if (ImGui::IsItemHovered()) {
-                gameHandler.setMouseoverGuid(member.guid);
-            }
-            // Zone tooltip on name hover
-            if (ImGui::IsItemHovered() && member.hasPartyStats && member.zoneId != 0) {
-                std::string zoneName = gameHandler.getWhoAreaName(member.zoneId);
-                if (!zoneName.empty())
-                    ImGui::SetTooltip("%s", zoneName.c_str());
-            }
-            ImGui::PopStyleColor();
-
-            // LFG role badge (Tank/Healer/DPS) — shown on same line as name when set
-            if (member.roles != 0) {
-                ImGui::SameLine();
-                if (member.roles & 0x02) ImGui::TextColored(ImVec4(0.3f, 0.5f, 1.0f, 1.0f), "[T]");
-                if (member.roles & 0x04) { ImGui::SameLine(); ImGui::TextColored(ImVec4(0.2f, 0.9f, 0.3f, 1.0f), "[H]"); }
-                if (member.roles & 0x08) { ImGui::SameLine(); ImGui::TextColored(ImVec4(0.9f, 0.3f, 0.3f, 1.0f), "[D]"); }
-            }
-
-            // Tactical role badge (MT/MA/Asst) from group flags
-            if (member.flags & 0x02) {
-                ImGui::SameLine();
-                ImGui::TextColored(ImVec4(1.0f, 0.55f, 0.0f, 0.9f), "[MT]");
-            } else if (member.flags & 0x04) {
-                ImGui::SameLine();
-                ImGui::TextColored(ImVec4(0.4f, 0.7f, 1.0f, 0.9f), "[MA]");
-            } else if (member.flags & 0x01) {
-                ImGui::SameLine();
-                ImGui::TextColored(ImVec4(0.7f, 0.85f, 1.0f, 0.7f), "[A]");
-            }
-
-            // Raid mark symbol — shown on same line as name when this party member has a mark
-            {
-                static constexpr struct { const char* sym; ImU32 col; } kPartyMarks[] = {
-                    { "\xe2\x98\x85", IM_COL32(255, 220,  50, 255) },  // 0 Star
-                    { "\xe2\x97\x8f", IM_COL32(255, 140,   0, 255) },  // 1 Circle
-                    { "\xe2\x97\x86", IM_COL32(160,  32, 240, 255) },  // 2 Diamond
-                    { "\xe2\x96\xb2", IM_COL32( 50, 200,  50, 255) },  // 3 Triangle
-                    { "\xe2\x97\x8c", IM_COL32( 80, 160, 255, 255) },  // 4 Moon
-                    { "\xe2\x96\xa0", IM_COL32( 50, 200, 220, 255) },  // 5 Square
-                    { "\xe2\x9c\x9d", IM_COL32(255,  80,  80, 255) },  // 6 Cross
-                    { "\xe2\x98\xa0", IM_COL32(255, 255, 255, 255) },  // 7 Skull
-                };
-                uint8_t pmk = gameHandler.getEntityRaidMark(member.guid);
-                if (pmk < game::GameHandler::kRaidMarkCount) {
-                    ImGui::SameLine();
-                    ImGui::TextColored(
-                        ImGui::ColorConvertU32ToFloat4(kPartyMarks[pmk].col),
-                        "%s", kPartyMarks[pmk].sym);
-                }
-            }
-
-            // Health bar: prefer party stats, fall back to entity
-            uint32_t hp = 0, maxHp = 0;
-            if (member.hasPartyStats && member.maxHealth > 0) {
-                hp = member.curHealth;
-                maxHp = member.maxHealth;
-            } else {
-                auto entity = gameHandler.getEntityManager().getEntity(member.guid);
-                if (entity && (entity->getType() == game::ObjectType::PLAYER || entity->getType() == game::ObjectType::UNIT)) {
-                    auto unit = std::static_pointer_cast<game::Unit>(entity);
-                    hp = unit->getHealth();
-                    maxHp = unit->getMaxHealth();
-                }
-            }
-            // Check dead/ghost state for health bar rendering
-            bool memberDead = false;
-            bool memberOffline = false;
-            if (member.hasPartyStats) {
-                bool isOnline2 = (member.onlineStatus & 0x0001) != 0;
-                bool isDead2   = (member.onlineStatus & 0x0020) != 0;
-                bool isGhost2  = (member.onlineStatus & 0x0010) != 0;
-                memberDead    = isDead2 || isGhost2;
-                memberOffline = !isOnline2;
-            }
-
-            // Out-of-range check: compare player position to member's reported position
-            // Range threshold: 40 yards (standard heal/spell range)
-            bool memberOutOfRange = false;
-            if (member.hasPartyStats && !memberOffline && !memberDead &&
-                member.zoneId != 0) {
-                // Same map: use 2D Euclidean distance in WoW coordinates (yards)
-                auto playerEntity = gameHandler.getEntityManager().getEntity(gameHandler.getPlayerGuid());
-                if (playerEntity) {
-                    float dx = playerEntity->getX() - static_cast<float>(member.posX);
-                    float dy = playerEntity->getY() - static_cast<float>(member.posY);
-                    float distSq = dx * dx + dy * dy;
-                    memberOutOfRange = (distSq > 40.0f * 40.0f);
-                }
-            }
-
-            if (memberDead) {
-                // Gray "Dead" bar for fallen party members
-                ImGui::PushStyleColor(ImGuiCol_PlotHistogram, ImVec4(0.35f, 0.35f, 0.35f, 1.0f));
-                ImGui::PushStyleColor(ImGuiCol_FrameBg,       ImVec4(0.15f, 0.15f, 0.15f, 1.0f));
-                ImGui::ProgressBar(0.0f, ImVec2(-1, 14), "Dead");
-                ImGui::PopStyleColor(2);
-            } else if (memberOffline) {
-                // Dim bar for offline members
-                ImGui::PushStyleColor(ImGuiCol_PlotHistogram, ImVec4(0.25f, 0.25f, 0.25f, 0.6f));
-                ImGui::PushStyleColor(ImGuiCol_FrameBg,       ImVec4(0.1f, 0.1f, 0.1f, 0.6f));
-                ImGui::ProgressBar(0.0f, ImVec2(-1, 14), "Offline");
-                ImGui::PopStyleColor(2);
-            } else if (maxHp > 0) {
-                float pct = static_cast<float>(hp) / static_cast<float>(maxHp);
-                // Out-of-range: desaturate health bar to gray
-                ImVec4 hpBarColor = memberOutOfRange
-                    ? ImVec4(0.45f, 0.45f, 0.45f, 0.7f)
-                    : (pct > 0.5f ? colors::kHealthGreen :
-                       pct > 0.2f ? colors::kMidHealthYellow :
-                                    colors::kLowHealthRed);
-                ImGui::PushStyleColor(ImGuiCol_PlotHistogram, hpBarColor);
-                char hpText[32];
-                if (memberOutOfRange) {
-                    snprintf(hpText, sizeof(hpText), "OOR");
-                } else if (maxHp >= 10000) {
-                    snprintf(hpText, sizeof(hpText), "%dk/%dk",
-                             static_cast<int>(hp) / 1000, static_cast<int>(maxHp) / 1000);
-                } else {
-                    snprintf(hpText, sizeof(hpText), "%u/%u", hp, maxHp);
-                }
-                ImGui::ProgressBar(pct, ImVec2(-1, 14), hpText);
-                ImGui::PopStyleColor();
-            }
-
-            // Power bar (mana/rage/energy) from party stats — hidden for dead/offline/OOR
-            if (!memberDead && !memberOffline && member.hasPartyStats && member.maxPower > 0) {
-                float powerPct = static_cast<float>(member.curPower) / static_cast<float>(member.maxPower);
-                ImVec4 powerColor;
-                switch (member.powerType) {
-                    case 0: powerColor = colors::kManaBlue; break; // Mana (blue)
-                    case 1: powerColor = colors::kDarkRed; break; // Rage (red)
-                    case 2: powerColor = colors::kOrange; break; // Focus (orange)
-                    case 3: powerColor = colors::kEnergyYellow; break; // Energy (yellow)
-                    case 4: powerColor = colors::kHappinessGreen; break; // Happiness (green)
-                    case 6: powerColor = colors::kRunicRed; break; // Runic Power (crimson)
-                    case 7: powerColor = colors::kSoulShardPurple; break; // Soul Shards (purple)
-                    default: powerColor = kColorDarkGray; break;
-                }
-                ImGui::PushStyleColor(ImGuiCol_PlotHistogram, powerColor);
-                ImGui::ProgressBar(powerPct, ImVec2(-1, 8), "");
-                ImGui::PopStyleColor();
-            }
-
-            // Dispellable debuff indicators — small colored dots for party member debuffs
-            // Only show magic/curse/disease/poison (types 1-4); skip non-dispellable
-            if (!memberDead && !memberOffline) {
-                const std::vector<game::AuraSlot>* unitAuras = nullptr;
-                if (member.guid == gameHandler.getPlayerGuid())
-                    unitAuras = &gameHandler.getPlayerAuras();
-                else if (member.guid == gameHandler.getTargetGuid())
-                    unitAuras = &gameHandler.getTargetAuras();
-                else
-                    unitAuras = gameHandler.getUnitAuras(member.guid);
-
-                if (unitAuras) {
-                    bool anyDebuff = false;
-                    for (const auto& aura : *unitAuras) {
-                        if (aura.isEmpty()) continue;
-                        if ((aura.flags & 0x80) == 0) continue; // only debuffs
-                        uint8_t dt = gameHandler.getSpellDispelType(aura.spellId);
-                        if (dt == 0) continue; // skip non-dispellable
-                        anyDebuff = true;
-                        break;
-                    }
-                    if (anyDebuff) {
-                        // Render one dot per unique dispel type present
-                        bool shown[5] = {};
-                        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(2.0f, 1.0f));
-                        for (const auto& aura : *unitAuras) {
-                            if (aura.isEmpty()) continue;
-                            if ((aura.flags & 0x80) == 0) continue;
-                            uint8_t dt = gameHandler.getSpellDispelType(aura.spellId);
-                            if (dt == 0 || dt > 4 || shown[dt]) continue;
-                            shown[dt] = true;
-                            ImVec4 dotCol;
-                            switch (dt) {
-                                case 1: dotCol = ImVec4(0.25f, 0.50f, 1.00f, 1.0f); break; // Magic: blue
-                                case 2: dotCol = ImVec4(0.70f, 0.15f, 0.90f, 1.0f); break; // Curse: purple
-                                case 3: dotCol = ImVec4(0.65f, 0.45f, 0.10f, 1.0f); break; // Disease: brown
-                                case 4: dotCol = ImVec4(0.10f, 0.75f, 0.10f, 1.0f); break; // Poison: green
-                                default: break;
-                            }
-                            ImGui::PushStyleColor(ImGuiCol_Button, dotCol);
-                            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, dotCol);
-                            ImGui::Button("##d", ImVec2(8.0f, 8.0f));
-                            ImGui::PopStyleColor(2);
-                            if (ImGui::IsItemHovered()) {
-                                // Find spell name(s) of this dispel type
-                                ImGui::BeginTooltip();
-                                ImGui::TextColored(dotCol, "%s", kDispelNames[dt]);
-                                for (const auto& da : *unitAuras) {
-                                    if (da.isEmpty() || (da.flags & 0x80) == 0) continue;
-                                    if (gameHandler.getSpellDispelType(da.spellId) != dt) continue;
-                                    const std::string& dName = gameHandler.getSpellName(da.spellId);
-                                    if (!dName.empty())
-                                        ImGui::Text("  %s", dName.c_str());
-                                }
-                                ImGui::EndTooltip();
-                            }
-                            ImGui::SameLine();
-                        }
-                        ImGui::NewLine();
-                        ImGui::PopStyleVar();
-                    }
-                }
-            }
-
-            // Party member cast bar — shows when the party member is casting
-            if (auto* cs = gameHandler.getUnitCastState(member.guid)) {
-                float castPct = (cs->timeTotal > 0.0f)
-                    ? (cs->timeTotal - cs->timeRemaining) / cs->timeTotal : 0.0f;
-                ImGui::PushStyleColor(ImGuiCol_PlotHistogram, colors::kMidHealthYellow);
-                char pcastLabel[48];
-                const std::string& spellNm = gameHandler.getSpellName(cs->spellId);
-                if (!spellNm.empty())
-                    snprintf(pcastLabel, sizeof(pcastLabel), "%s (%.1fs)", spellNm.c_str(), cs->timeRemaining);
-                else
-                    snprintf(pcastLabel, sizeof(pcastLabel), "Casting... (%.1fs)", cs->timeRemaining);
-                {
-                    VkDescriptorSet pIcon = (cs->spellId != 0 && assetMgr)
-                        ? getSpellIcon(cs->spellId, assetMgr) : VK_NULL_HANDLE;
-                    if (pIcon) {
-                        ImGui::Image((ImTextureID)(uintptr_t)pIcon, ImVec2(10, 10));
-                        ImGui::SameLine(0, 2);
-                        ImGui::ProgressBar(castPct, ImVec2(-1, 10), pcastLabel);
-                    } else {
-                        ImGui::ProgressBar(castPct, ImVec2(-1, 10), pcastLabel);
-                    }
-                }
-                ImGui::PopStyleColor();
-            }
-
-            // Right-click context menu for party member actions
-            if (ImGui::BeginPopupContextItem("PartyMemberCtx")) {
-                ImGui::TextDisabled("%s", member.name.c_str());
-                ImGui::Separator();
-                if (ImGui::MenuItem("Target")) {
-                    gameHandler.setTarget(member.guid);
-                }
-                if (ImGui::MenuItem("Set Focus")) {
-                    gameHandler.setFocus(member.guid);
-                }
-                if (ImGui::MenuItem("Whisper")) {
-                    chatPanel.setWhisperTarget(member.name);
-                }
-                if (ImGui::MenuItem("Follow")) {
-                    gameHandler.setTarget(member.guid);
-                    gameHandler.followTarget();
-                }
-                if (ImGui::MenuItem("Trade")) {
-                    gameHandler.initiateTrade(member.guid);
-                }
-                if (ImGui::MenuItem("Duel")) {
-                    gameHandler.proposeDuel(member.guid);
-                }
-                if (ImGui::MenuItem("Inspect")) {
-                    gameHandler.setTarget(member.guid);
-                    gameHandler.inspectTarget();
-                    showInspectWindow_ = true;
-                }
-                ImGui::Separator();
-                if (!member.name.empty()) {
-                    if (ImGui::MenuItem("Add Friend")) {
-                        gameHandler.addFriend(member.name);
-                    }
-                    if (ImGui::MenuItem("Ignore")) {
-                        gameHandler.addIgnore(member.name);
-                    }
-                }
-                // Leader-only actions
-                bool isLeader = (gameHandler.getPartyData().leaderGuid == gameHandler.getPlayerGuid());
-                if (isLeader) {
-                    ImGui::Separator();
-                    if (ImGui::MenuItem("Kick from Group")) {
-                        gameHandler.uninvitePlayer(member.name);
-                    }
-                }
-                ImGui::Separator();
-                if (ImGui::BeginMenu("Set Raid Mark")) {
-                    for (int mi = 0; mi < 8; ++mi) {
-                        if (ImGui::MenuItem(kRaidMarkNames[mi]))
-                            gameHandler.setRaidMark(member.guid, static_cast<uint8_t>(mi));
-                    }
-                    ImGui::Separator();
-                    if (ImGui::MenuItem("Clear Mark"))
-                        gameHandler.setRaidMark(member.guid, 0xFF);
-                    ImGui::EndMenu();
-                }
-                ImGui::EndPopup();
-            }
-
-            ImGui::Separator();
-            ImGui::PopID();
-        }
-    }
-    ImGui::End();
-
-    ImGui::PopStyleColor();
-    ImGui::PopStyleVar();
-}
-
-void SocialPanel::renderBossFrames(game::GameHandler& gameHandler,
-                                      SpellbookScreen& spellbookScreen,
-                                      SpellIconFn getSpellIcon) {
-    auto* assetMgr = services_.assetManager;
-
-    // Collect active boss unit slots
-    struct BossSlot { uint32_t slot; uint64_t guid; };
-    std::vector<BossSlot> active;
-    for (uint32_t s = 0; s < game::GameHandler::kMaxEncounterSlots; ++s) {
-        uint64_t g = gameHandler.getEncounterUnitGuid(s);
-        if (g != 0) active.push_back({s, g});
-    }
-    if (active.empty()) return;
-
-    const float frameW = 200.0f;
-    const float startX = ImGui::GetIO().DisplaySize.x - frameW - 10.0f;
-    float frameY = 120.0f;
-
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
-                             ImGuiWindowFlags_AlwaysAutoResize;
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.15f, 0.05f, 0.05f, 0.85f));
-
-    ImGui::SetNextWindowPos(ImVec2(startX, frameY), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(frameW, 0.0f), ImGuiCond_Always);
-
-    if (ImGui::Begin("##BossFrames", nullptr, flags)) {
-        for (const auto& bs : active) {
-            ImGui::PushID(static_cast<int>(bs.guid));
-
-            // Try to resolve name, health, and power from entity manager
-            std::string name = "Boss";
-            uint32_t hp = 0, maxHp = 0;
-            uint8_t  bossPowerType = 0;
-            uint32_t bossPower = 0, bossMaxPower = 0;
-            auto entity = gameHandler.getEntityManager().getEntity(bs.guid);
-            if (entity && (entity->getType() == game::ObjectType::UNIT ||
-                           entity->getType() == game::ObjectType::PLAYER)) {
-                auto unit = std::static_pointer_cast<game::Unit>(entity);
-                const auto& n = unit->getName();
-                if (!n.empty()) name = n;
-                hp           = unit->getHealth();
-                maxHp        = unit->getMaxHealth();
-                bossPowerType = unit->getPowerType();
-                bossPower     = unit->getPower();
-                bossMaxPower  = unit->getMaxPower();
-            }
-
-            // Clickable name to target
-            if (ImGui::Selectable(name.c_str(), gameHandler.getTargetGuid() == bs.guid)) {
-                gameHandler.setTarget(bs.guid);
-            }
-
-            if (maxHp > 0) {
-                float pct = static_cast<float>(hp) / static_cast<float>(maxHp);
-                // Boss health bar in red shades
-                ImGui::PushStyleColor(ImGuiCol_PlotHistogram,
-                    pct > 0.5f ? colors::kLowHealthRed :
-                    pct > 0.2f ? ImVec4(0.9f, 0.5f, 0.1f, 1.0f) :
-                                 ImVec4(1.0f, 0.8f, 0.1f, 1.0f));
-                char label[32];
-                std::snprintf(label, sizeof(label), "%u / %u", hp, maxHp);
-                ImGui::ProgressBar(pct, ImVec2(-1, 14), label);
-                ImGui::PopStyleColor();
-            }
-
-            // Boss power bar — shown when boss has a non-zero power pool
-            // Energy bosses (type 3) are particularly important: full energy signals ability use
-            if (bossMaxPower > 0 && bossPower > 0) {
-                float bpPct = static_cast<float>(bossPower) / static_cast<float>(bossMaxPower);
-                ImVec4 bpColor;
-                switch (bossPowerType) {
-                    case 0: bpColor = ImVec4(0.2f, 0.3f, 0.9f, 1.0f); break; // Mana: blue
-                    case 1: bpColor = colors::kDarkRed; break; // Rage: red
-                    case 2: bpColor = colors::kOrange; break; // Focus: orange
-                    case 3: bpColor = ImVec4(0.9f, 0.9f, 0.1f, 1.0f); break; // Energy: yellow
-                    default: bpColor = ImVec4(0.4f, 0.8f, 0.4f, 1.0f); break;
-                }
-                ImGui::PushStyleColor(ImGuiCol_PlotHistogram, bpColor);
-                char bpLabel[24];
-                std::snprintf(bpLabel, sizeof(bpLabel), "%u", bossPower);
-                ImGui::ProgressBar(bpPct, ImVec2(-1, 6), bpLabel);
-                ImGui::PopStyleColor();
-            }
-
-            // Boss cast bar — shown when the boss is casting (critical for interrupt)
-            if (auto* cs = gameHandler.getUnitCastState(bs.guid)) {
-                float castPct  = (cs->timeTotal > 0.0f)
-                    ? (cs->timeTotal - cs->timeRemaining) / cs->timeTotal : 0.0f;
-                uint32_t bspell = cs->spellId;
-                const std::string& bcastName = (bspell != 0)
-                    ? gameHandler.getSpellName(bspell) : "";
-                // Green = interruptible, Red = immune; pulse when > 80% complete
-                ImVec4 bcastColor;
-                if (castPct > 0.8f) {
-                    float pulse = 0.7f + 0.3f * std::sin(static_cast<float>(ImGui::GetTime()) * 8.0f);
-                    bcastColor = cs->interruptible
-                        ? ImVec4(0.2f * pulse, 0.9f * pulse, 0.2f * pulse, 1.0f)
-                        : ImVec4(1.0f * pulse, 0.1f * pulse, 0.1f * pulse, 1.0f);
-                } else {
-                    bcastColor = cs->interruptible
-                        ? colors::kCastGreen
-                        : ImVec4(0.9f, 0.15f, 0.15f, 1.0f);
-                }
-                ImGui::PushStyleColor(ImGuiCol_PlotHistogram, bcastColor);
-                char bcastLabel[72];
-                if (!bcastName.empty())
-                    snprintf(bcastLabel, sizeof(bcastLabel), "%s (%.1fs)",
-                             bcastName.c_str(), cs->timeRemaining);
-                else
-                    snprintf(bcastLabel, sizeof(bcastLabel), "Casting... (%.1fs)", cs->timeRemaining);
-                {
-                    VkDescriptorSet bIcon = (bspell != 0 && assetMgr)
-                        ? getSpellIcon(bspell, assetMgr) : VK_NULL_HANDLE;
-                    if (bIcon) {
-                        ImGui::Image((ImTextureID)(uintptr_t)bIcon, ImVec2(12, 12));
-                        ImGui::SameLine(0, 2);
-                        ImGui::ProgressBar(castPct, ImVec2(-1, 12), bcastLabel);
-                    } else {
-                        ImGui::ProgressBar(castPct, ImVec2(-1, 12), bcastLabel);
-                    }
-                }
-                ImGui::PopStyleColor();
-            }
-
-            // Boss aura row: debuffs first (player DoTs), then boss buffs
-            {
-                const std::vector<game::AuraSlot>* bossAuras = nullptr;
-                if (bs.guid == gameHandler.getTargetGuid())
-                    bossAuras = &gameHandler.getTargetAuras();
-                else
-                    bossAuras = gameHandler.getUnitAuras(bs.guid);
-
-                if (bossAuras) {
-                    int bossActive = 0;
-                    for (const auto& a : *bossAuras) if (!a.isEmpty()) bossActive++;
-                    if (bossActive > 0) {
-                        constexpr float BA_ICON = 16.0f;
-                        constexpr int   BA_PER_ROW = 10;
-
-                        uint64_t baNowMs = static_cast<uint64_t>(
-                            std::chrono::duration_cast<std::chrono::milliseconds>(
-                                std::chrono::steady_clock::now().time_since_epoch()).count());
-
-                        // Sort: player-applied debuffs first (most relevant), then others
-                        const uint64_t pguid = gameHandler.getPlayerGuid();
-                        std::vector<size_t> baIdx;
-                        baIdx.reserve(bossAuras->size());
-                        for (size_t i = 0; i < bossAuras->size(); ++i)
-                            if (!(*bossAuras)[i].isEmpty()) baIdx.push_back(i);
-                        std::sort(baIdx.begin(), baIdx.end(), [&](size_t a, size_t b) {
-                            const auto& aa = (*bossAuras)[a];
-                            const auto& ab = (*bossAuras)[b];
-                            bool aPlayerDot = (aa.flags & 0x80) != 0 && aa.casterGuid == pguid;
-                            bool bPlayerDot = (ab.flags & 0x80) != 0 && ab.casterGuid == pguid;
-                            if (aPlayerDot != bPlayerDot) return aPlayerDot > bPlayerDot;
-                            bool aDebuff = (aa.flags & 0x80) != 0;
-                            bool bDebuff = (ab.flags & 0x80) != 0;
-                            if (aDebuff != bDebuff) return aDebuff > bDebuff;
-                            int32_t ra = aa.getRemainingMs(baNowMs);
-                            int32_t rb = ab.getRemainingMs(baNowMs);
-                            if (ra < 0 && rb < 0) return false;
-                            if (ra < 0) return false;
-                            if (rb < 0) return true;
-                            return ra < rb;
-                        });
-
-                        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(2.0f, 2.0f));
-                        int baShown = 0;
-                        for (size_t si = 0; si < baIdx.size() && baShown < 20; ++si) {
-                            const auto& aura = (*bossAuras)[baIdx[si]];
-                            bool isBuff = (aura.flags & 0x80) == 0;
-                            bool isPlayerCast = (aura.casterGuid == pguid);
-
-                            if (baShown > 0 && baShown % BA_PER_ROW != 0) ImGui::SameLine();
-                            ImGui::PushID(static_cast<int>(baIdx[si]) + 7000);
-
-                            ImVec4 borderCol;
-                            if (isBuff) {
-                                // Boss buffs: gold for important enrage/shield types
-                                borderCol = ImVec4(0.8f, 0.6f, 0.1f, 0.9f);
-                            } else {
-                                uint8_t dt = gameHandler.getSpellDispelType(aura.spellId);
-                                switch (dt) {
-                                    case 1: borderCol = ImVec4(0.15f, 0.50f, 1.00f, 0.9f); break;
-                                    case 2: borderCol = ImVec4(0.70f, 0.20f, 0.90f, 0.9f); break;
-                                    case 3: borderCol = ImVec4(0.55f, 0.30f, 0.10f, 0.9f); break;
-                                    case 4: borderCol = ImVec4(0.10f, 0.70f, 0.10f, 0.9f); break;
-                                    default: borderCol = isPlayerCast
-                                        ? ImVec4(0.90f, 0.30f, 0.10f, 0.9f)   // player DoT: orange-red
-                                        : ImVec4(0.60f, 0.20f, 0.20f, 0.9f);  // other debuff: dark red
-                                        break;
-                                }
-                            }
-
-                            VkDescriptorSet baIcon = assetMgr
-                                ? getSpellIcon(aura.spellId, assetMgr) : VK_NULL_HANDLE;
-                            if (baIcon) {
-                                ImGui::PushStyleColor(ImGuiCol_Button, borderCol);
-                                ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(1, 1));
-                                ImGui::ImageButton("##baura",
-                                    (ImTextureID)(uintptr_t)baIcon,
-                                    ImVec2(BA_ICON - 2, BA_ICON - 2));
-                                ImGui::PopStyleVar();
-                                ImGui::PopStyleColor();
-                            } else {
-                                ImGui::PushStyleColor(ImGuiCol_Button, borderCol);
-                                char lab[8];
-                                snprintf(lab, sizeof(lab), "%u", aura.spellId % 10000);
-                                ImGui::Button(lab, ImVec2(BA_ICON, BA_ICON));
-                                ImGui::PopStyleColor();
-                            }
-
-                            // Duration overlay
-                            int32_t baRemain = aura.getRemainingMs(baNowMs);
-                            if (baRemain > 0) {
-                                ImVec2 imin = ImGui::GetItemRectMin();
-                                ImVec2 imax = ImGui::GetItemRectMax();
-                                char ts[12];
-                                fmtDurationCompact(ts, sizeof(ts), (baRemain + 999) / 1000);
-                                ImVec2 tsz = ImGui::CalcTextSize(ts);
-                                float cx = imin.x + (imax.x - imin.x - tsz.x) * 0.5f;
-                                float cy = imax.y - tsz.y;
-                                ImGui::GetWindowDrawList()->AddText(ImVec2(cx + 1, cy + 1), IM_COL32(0, 0, 0, 180), ts);
-                                ImGui::GetWindowDrawList()->AddText(ImVec2(cx, cy), IM_COL32(255, 255, 255, 220), ts);
-                            }
-
-                            // Stack / charge count — upper-left corner (parity with target/focus frames)
-                            if (aura.charges > 1) {
-                                ImVec2 baMin = ImGui::GetItemRectMin();
-                                char chargeStr[8];
-                                snprintf(chargeStr, sizeof(chargeStr), "%u", static_cast<unsigned>(aura.charges));
-                                ImGui::GetWindowDrawList()->AddText(ImVec2(baMin.x + 2, baMin.y + 2),
-                                    IM_COL32(0, 0, 0, 200), chargeStr);
-                                ImGui::GetWindowDrawList()->AddText(ImVec2(baMin.x + 1, baMin.y + 1),
-                                    IM_COL32(255, 220, 50, 255), chargeStr);
-                            }
-
-                            // Tooltip
-                            if (ImGui::IsItemHovered()) {
-                                ImGui::BeginTooltip();
-                                bool richOk = spellbookScreen.renderSpellInfoTooltip(
-                                    aura.spellId, gameHandler, assetMgr);
-                                if (!richOk) {
-                                    std::string nm = spellbookScreen.lookupSpellName(aura.spellId, assetMgr);
-                                    if (nm.empty()) nm = "Spell #" + std::to_string(aura.spellId);
-                                    ImGui::Text("%s", nm.c_str());
-                                }
-                                if (isPlayerCast && !isBuff)
-                                    ImGui::TextColored(ImVec4(0.9f, 0.7f, 0.3f, 1.0f), "Your DoT");
-                                renderAuraRemaining(baRemain);
-                                ImGui::EndTooltip();
-                            }
-
-                            ImGui::PopID();
-                            baShown++;
-                        }
-                        ImGui::PopStyleVar();
-                    }
-                }
-            }
-
-            ImGui::PopID();
-            ImGui::Spacing();
-        }
-    }
-    ImGui::End();
-
-    ImGui::PopStyleColor();
-    ImGui::PopStyleVar();
-}
-
-void SocialPanel::renderGuildRoster(game::GameHandler& gameHandler,
-                                       ChatPanel& chatPanel) {
-    // Guild Roster toggle (customizable keybind)
-    if (!chatPanel.isChatInputActive() && !ImGui::GetIO().WantTextInput &&
-        !ImGui::GetIO().WantCaptureKeyboard &&
-        KeybindingManager::getInstance().isActionPressed(KeybindingManager::Action::TOGGLE_GUILD_ROSTER)) {
-        showGuildRoster_ = !showGuildRoster_;
-        if (showGuildRoster_) {
-            // Open friends tab directly if not in guild
-            if (!gameHandler.isInGuild()) {
-                guildRosterTab_ = 2;  // Friends tab
-            } else {
-                // Re-query guild name if we have guildId but no name yet
-                if (gameHandler.getGuildName().empty()) {
-                    const auto* ch = gameHandler.getActiveCharacter();
-                    if (ch && ch->hasGuild()) {
-                        gameHandler.queryGuildInfo(ch->guildId);
-                    }
-                }
-                gameHandler.requestGuildRoster();
-                gameHandler.requestGuildInfo();
-            }
-        }
-    }
-
-    // Petition creation dialog (shown when NPC sends SMSG_PETITION_SHOWLIST)
-    if (gameHandler.hasPetitionShowlist()) {
-        ImGui::OpenPopup("CreateGuildPetition");
-        gameHandler.clearPetitionDialog();
-    }
-    if (ImGui::BeginPopupModal("CreateGuildPetition", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
-        ImGui::Text("Create Guild Charter");
-        ImGui::Separator();
-        uint32_t cost = gameHandler.getPetitionCost();
-        ImGui::TextDisabled("Cost:"); ImGui::SameLine(0, 4);
-        renderCoinsFromCopper(cost);
-        ImGui::Spacing();
-        ImGui::Text("Guild Name:");
-        ImGui::InputText("##petitionname", petitionNameBuffer_, sizeof(petitionNameBuffer_));
-        ImGui::Spacing();
-        if (ImGui::Button("Create", ImVec2(120, 0))) {
-            if (petitionNameBuffer_[0] != '\0') {
-                gameHandler.buyPetition(gameHandler.getPetitionNpcGuid(), petitionNameBuffer_);
-                petitionNameBuffer_[0] = '\0';
-                ImGui::CloseCurrentPopup();
-            }
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Cancel", ImVec2(120, 0))) {
-            petitionNameBuffer_[0] = '\0';
-            ImGui::CloseCurrentPopup();
-        }
-        ImGui::EndPopup();
-    }
-
-    // Petition signatures window (shown when a petition item is used or offered)
-    if (gameHandler.hasPetitionSignaturesUI()) {
-        ImGui::OpenPopup("PetitionSignatures");
-        gameHandler.clearPetitionSignaturesUI();
-    }
-    if (ImGui::BeginPopupModal("PetitionSignatures", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
-        const auto& pInfo = gameHandler.getPetitionInfo();
-        if (!pInfo.guildName.empty())
-            ImGui::Text("Guild Charter: %s", pInfo.guildName.c_str());
-        else
-            ImGui::Text("Guild Charter");
-        ImGui::Separator();
-
-        ImGui::Text("Signatures: %u / %u", pInfo.signatureCount, pInfo.signaturesRequired);
-        ImGui::Spacing();
-
-        if (!pInfo.signatures.empty()) {
-            for (size_t i = 0; i < pInfo.signatures.size(); ++i) {
-                const auto& sig = pInfo.signatures[i];
-                // Try to resolve name from entity manager
-                std::string sigName;
-                if (sig.playerGuid != 0) {
-                    auto entity = gameHandler.getEntityManager().getEntity(sig.playerGuid);
-                    if (entity) {
-                        auto* unit = entity->isUnit() ? static_cast<game::Unit*>(entity.get()) : nullptr;
-                        if (unit) sigName = unit->getName();
-                    }
-                }
-                if (sigName.empty())
-                    sigName = "Player " + std::to_string(i + 1);
-                ImGui::BulletText("%s", sigName.c_str());
-            }
-            ImGui::Spacing();
-        }
-
-        // If we're not the owner, show Sign button
-        bool isOwner = (pInfo.ownerGuid == gameHandler.getPlayerGuid());
-        if (!isOwner) {
-            if (ImGui::Button("Sign", ImVec2(120, 0))) {
-                gameHandler.signPetition(pInfo.petitionGuid);
-                ImGui::CloseCurrentPopup();
-            }
-            ImGui::SameLine();
-        } else if (pInfo.signatureCount >= pInfo.signaturesRequired) {
-            // Owner with enough sigs — turn in
-            if (ImGui::Button("Turn In", ImVec2(120, 0))) {
-                gameHandler.turnInPetition(pInfo.petitionGuid);
-                ImGui::CloseCurrentPopup();
-            }
-            ImGui::SameLine();
-        }
-        if (ImGui::Button("Close", ImVec2(120, 0)))
-            ImGui::CloseCurrentPopup();
-        ImGui::EndPopup();
-    }
-
-    if (!showGuildRoster_) return;
-
-    // Get zone manager for name lookup
-    game::ZoneManager* zoneManager = nullptr;
-    if (auto* renderer = services_.renderer) {
-        zoneManager = renderer->getZoneManager();
-    }
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 375, screenH / 2 - 250), ImGuiCond_Once);
-    ImGui::SetNextWindowSize(ImVec2(750, 500), ImGuiCond_Once);
-
-    std::string title = gameHandler.isInGuild() ? (gameHandler.getGuildName() + " - Social") : "Social";
-    bool open = showGuildRoster_;
-    if (ImGui::Begin(title.c_str(), &open, ImGuiWindowFlags_NoCollapse)) {
-        // Tab bar: Roster | Guild Info
-        if (ImGui::BeginTabBar("GuildTabs")) {
-            if (ImGui::BeginTabItem("Roster")) {
-                guildRosterTab_ = 0;
-                if (!gameHandler.hasGuildRoster()) {
-                    ImGui::Text("Loading roster...");
-                } else {
-                    const auto& roster = gameHandler.getGuildRoster();
-
-                    // MOTD
-                    if (!roster.motd.empty()) {
-                        ImGui::TextColored(ImVec4(0.0f, 1.0f, 0.0f, 1.0f), "MOTD: %s", roster.motd.c_str());
-                        ImGui::Separator();
-                    }
-
-                    // Count online
-                    int onlineCount = 0;
-                    for (const auto& m : roster.members) {
-                        if (m.online) ++onlineCount;
-                    }
-                    ImGui::Text("%d members (%d online)", static_cast<int>(roster.members.size()), onlineCount);
-                    ImGui::Separator();
-
-                    const auto& rankNames = gameHandler.getGuildRankNames();
-
-                    // Table
-                    if (ImGui::BeginTable("GuildRoster", 7,
-                            ImGuiTableFlags_ScrollY | ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersInnerV |
-                            ImGuiTableFlags_Sortable)) {
-                        ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_DefaultSort);
-                        ImGui::TableSetupColumn("Rank");
-                        ImGui::TableSetupColumn("Level", ImGuiTableColumnFlags_WidthFixed, 40.0f);
-                        ImGui::TableSetupColumn("Class", ImGuiTableColumnFlags_WidthFixed, 70.0f);
-                        ImGui::TableSetupColumn("Zone", ImGuiTableColumnFlags_WidthFixed, 120.0f);
-                        ImGui::TableSetupColumn("Note");
-                        ImGui::TableSetupColumn("Officer Note");
-                        ImGui::TableHeadersRow();
-
-                        // Online members first, then offline
-                        auto sortedMembers = roster.members;
-                        std::sort(sortedMembers.begin(), sortedMembers.end(), [](const auto& a, const auto& b) {
-                            if (a.online != b.online) return a.online > b.online;
-                            return a.name < b.name;
-                        });
-
-                        for (const auto& m : sortedMembers) {
-                            ImGui::TableNextRow();
-                            ImVec4 textColor = m.online ? ui::colors::kWhite
-                                                        : kColorDarkGray;
-                            ImVec4 nameColor = m.online ? classColorVec4(m.classId) : textColor;
-
-                            ImGui::TableNextColumn();
-                            ImGui::TextColored(nameColor, "%s", m.name.c_str());
-
-                            // Right-click context menu
-                            if (ImGui::IsItemClicked(ImGuiMouseButton_Right)) {
-                                selectedGuildMember_ = m.name;
-                                ImGui::OpenPopup("GuildMemberContext");
-                            }
-
-                            ImGui::TableNextColumn();
-                            // Show rank name instead of index
-                            if (m.rankIndex < rankNames.size()) {
-                                ImGui::TextColored(textColor, "%s", rankNames[m.rankIndex].c_str());
-                            } else {
-                                ImGui::TextColored(textColor, "Rank %u", m.rankIndex);
-                            }
-
-                            ImGui::TableNextColumn();
-                            ImGui::TextColored(textColor, "%u", m.level);
-
-                            ImGui::TableNextColumn();
-                            const char* className = classNameStr(m.classId);
-                            ImVec4 classCol = m.online ? classColorVec4(m.classId) : textColor;
-                            ImGui::TextColored(classCol, "%s", className);
-
-                            ImGui::TableNextColumn();
-                            // Zone name lookup
-                            if (zoneManager) {
-                                const auto* zoneInfo = zoneManager->getZoneInfo(m.zoneId);
-                                if (zoneInfo && !zoneInfo->name.empty()) {
-                                    ImGui::TextColored(textColor, "%s", zoneInfo->name.c_str());
-                                } else {
-                                    ImGui::TextColored(textColor, "%u", m.zoneId);
-                                }
-                            } else {
-                                ImGui::TextColored(textColor, "%u", m.zoneId);
-                            }
-
-                            ImGui::TableNextColumn();
-                            ImGui::TextColored(textColor, "%s", m.publicNote.c_str());
-
-                            ImGui::TableNextColumn();
-                            ImGui::TextColored(textColor, "%s", m.officerNote.c_str());
-                        }
-                        ImGui::EndTable();
-                    }
-
-                    // Context menu popup
-                    if (ImGui::BeginPopup("GuildMemberContext")) {
-                        ImGui::TextDisabled("%s", selectedGuildMember_.c_str());
-                        ImGui::Separator();
-                        // Social actions — only for online members
-                        bool memberOnline = false;
-                        for (const auto& mem : roster.members) {
-                            if (mem.name == selectedGuildMember_) { memberOnline = mem.online; break; }
-                        }
-                        if (memberOnline) {
-                            if (ImGui::MenuItem("Whisper")) {
-                                chatPanel.setWhisperTarget(selectedGuildMember_);
-                            }
-                            if (ImGui::MenuItem("Invite to Group")) {
-                                gameHandler.inviteToGroup(selectedGuildMember_);
-                            }
-                            ImGui::Separator();
-                        }
-                        if (!selectedGuildMember_.empty()) {
-                            if (ImGui::MenuItem("Add Friend"))
-                                gameHandler.addFriend(selectedGuildMember_);
-                            if (ImGui::MenuItem("Ignore"))
-                                gameHandler.addIgnore(selectedGuildMember_);
-                            ImGui::Separator();
-                        }
-                        if (ImGui::MenuItem("Promote")) {
-                            gameHandler.promoteGuildMember(selectedGuildMember_);
-                        }
-                        if (ImGui::MenuItem("Demote")) {
-                            gameHandler.demoteGuildMember(selectedGuildMember_);
-                        }
-                        if (ImGui::MenuItem("Kick")) {
-                            gameHandler.kickGuildMember(selectedGuildMember_);
-                        }
-                        ImGui::Separator();
-                        if (ImGui::MenuItem("Set Public Note...")) {
-                            showGuildNoteEdit_ = true;
-                            editingOfficerNote_ = false;
-                            guildNoteEditBuffer_[0] = '\0';
-                            // Pre-fill with existing note
-                            for (const auto& mem : roster.members) {
-                                if (mem.name == selectedGuildMember_) {
-                                    snprintf(guildNoteEditBuffer_, sizeof(guildNoteEditBuffer_), "%s", mem.publicNote.c_str());
-                                    break;
-                                }
-                            }
-                        }
-                        if (ImGui::MenuItem("Set Officer Note...")) {
-                            showGuildNoteEdit_ = true;
-                            editingOfficerNote_ = true;
-                            guildNoteEditBuffer_[0] = '\0';
-                            for (const auto& mem : roster.members) {
-                                if (mem.name == selectedGuildMember_) {
-                                    snprintf(guildNoteEditBuffer_, sizeof(guildNoteEditBuffer_), "%s", mem.officerNote.c_str());
-                                    break;
-                                }
-                            }
-                        }
-                        ImGui::Separator();
-                        if (ImGui::MenuItem("Set as Leader")) {
-                            gameHandler.setGuildLeader(selectedGuildMember_);
-                        }
-                        ImGui::EndPopup();
-                    }
-
-                    // Note edit modal
-                    if (showGuildNoteEdit_) {
-                        ImGui::OpenPopup("EditGuildNote");
-                        showGuildNoteEdit_ = false;
-                    }
-                    if (ImGui::BeginPopupModal("EditGuildNote", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
-                        ImGui::Text("%s %s for %s:",
-                            editingOfficerNote_ ? "Officer" : "Public", "Note", selectedGuildMember_.c_str());
-                        ImGui::InputText("##guildnote", guildNoteEditBuffer_, sizeof(guildNoteEditBuffer_));
-                        if (ImGui::Button("Save")) {
-                            if (editingOfficerNote_) {
-                                gameHandler.setGuildOfficerNote(selectedGuildMember_, guildNoteEditBuffer_);
-                            } else {
-                                gameHandler.setGuildPublicNote(selectedGuildMember_, guildNoteEditBuffer_);
-                            }
-                            ImGui::CloseCurrentPopup();
-                        }
-                        ImGui::SameLine();
-                        if (ImGui::Button("Cancel")) {
-                            ImGui::CloseCurrentPopup();
-                        }
-                        ImGui::EndPopup();
-                    }
-                }
-                ImGui::EndTabItem();
-            }
-
-            if (ImGui::BeginTabItem("Guild Info")) {
-                guildRosterTab_ = 1;
-                const auto& infoData = gameHandler.getGuildInfoData();
-                const auto& queryData = gameHandler.getGuildQueryData();
-                const auto& roster = gameHandler.getGuildRoster();
-                const auto& rankNames = gameHandler.getGuildRankNames();
-
-                // Guild name (large, gold)
-                ImGui::PushFont(nullptr);  // default font
-                ImGui::TextColored(ui::colors::kTooltipGold, "<%s>", gameHandler.getGuildName().c_str());
-                ImGui::PopFont();
-                ImGui::Separator();
-
-                // Creation date
-                if (infoData.isValid()) {
-                    ImGui::Text("Created: %u/%u/%u", infoData.creationDay, infoData.creationMonth, infoData.creationYear);
-                    ImGui::Text("Members: %u  |  Accounts: %u", infoData.numMembers, infoData.numAccounts);
-                }
-                ImGui::Spacing();
-
-                // Guild description / info text
-                if (!roster.guildInfo.empty()) {
-                    ImGui::TextColored(colors::kSilver, "Description:");
-                    ImGui::TextWrapped("%s", roster.guildInfo.c_str());
-                }
-                ImGui::Spacing();
-
-                // MOTD with edit button
-                ImGui::TextColored(ImVec4(0.0f, 1.0f, 0.0f, 1.0f), "MOTD:");
-                ImGui::SameLine();
-                if (!roster.motd.empty()) {
-                    ImGui::TextWrapped("%s", roster.motd.c_str());
-                } else {
-                    ImGui::TextColored(kColorDarkGray, "(not set)");
-                }
-                if (ImGui::Button("Set MOTD")) {
-                    showMotdEdit_ = true;
-                    snprintf(guildMotdEditBuffer_, sizeof(guildMotdEditBuffer_), "%s", roster.motd.c_str());
-                }
-                ImGui::Spacing();
-
-                // MOTD edit modal
-                if (showMotdEdit_) {
-                    ImGui::OpenPopup("EditMotd");
-                    showMotdEdit_ = false;
-                }
-                if (ImGui::BeginPopupModal("EditMotd", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
-                    ImGui::Text("Set Message of the Day:");
-                    ImGui::InputText("##motdinput", guildMotdEditBuffer_, sizeof(guildMotdEditBuffer_));
-                    if (ImGui::Button("Save", ImVec2(120, 0))) {
-                        gameHandler.setGuildMotd(guildMotdEditBuffer_);
-                        ImGui::CloseCurrentPopup();
-                    }
-                    ImGui::SameLine();
-                    if (ImGui::Button("Cancel", ImVec2(120, 0))) {
-                        ImGui::CloseCurrentPopup();
-                    }
-                    ImGui::EndPopup();
-                }
-
-                // Emblem info
-                if (queryData.isValid()) {
-                    ImGui::Separator();
-                    ImGui::Text("Emblem: Style %u, Color %u  |  Border: Style %u, Color %u  |  BG: %u",
-                        queryData.emblemStyle, queryData.emblemColor,
-                        queryData.borderStyle, queryData.borderColor, queryData.backgroundColor);
-                }
-
-                // Rank list
-                ImGui::Separator();
-                ImGui::TextColored(ui::colors::kTooltipGold, "Ranks:");
-                for (size_t i = 0; i < rankNames.size(); ++i) {
-                    if (rankNames[i].empty()) continue;
-                    // Show rank permission summary from roster data
-                    if (i < roster.ranks.size()) {
-                        uint32_t rights = roster.ranks[i].rights;
-                        std::string perms;
-                        if (rights & 0x01) perms += "Invite ";
-                        if (rights & 0x02) perms += "Remove ";
-                        if (rights & 0x40) perms += "Promote ";
-                        if (rights & 0x80) perms += "Demote ";
-                        if (rights & 0x04) perms += "OChat ";
-                        if (rights & 0x10) perms += "MOTD ";
-                        ImGui::Text("  %zu. %s", i + 1, rankNames[i].c_str());
-                        if (!perms.empty()) {
-                            ImGui::SameLine();
-                            ImGui::TextColored(kColorDarkGray, "[%s]", perms.c_str());
-                        }
-                    } else {
-                        ImGui::Text("  %zu. %s", i + 1, rankNames[i].c_str());
-                    }
-                }
-
-                // Rank management buttons
-                ImGui::Spacing();
-                if (ImGui::Button("Add Rank")) {
-                    showAddRankModal_ = true;
-                    addRankNameBuffer_[0] = '\0';
-                }
-                ImGui::SameLine();
-                if (ImGui::Button("Delete Last Rank")) {
-                    gameHandler.deleteGuildRank();
-                }
-
-                // Add rank modal
-                if (showAddRankModal_) {
-                    ImGui::OpenPopup("AddGuildRank");
-                    showAddRankModal_ = false;
-                }
-                if (ImGui::BeginPopupModal("AddGuildRank", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
-                    ImGui::Text("New Rank Name:");
-                    ImGui::InputText("##rankname", addRankNameBuffer_, sizeof(addRankNameBuffer_));
-                    if (ImGui::Button("Add", ImVec2(120, 0))) {
-                        if (addRankNameBuffer_[0] != '\0') {
-                            gameHandler.addGuildRank(addRankNameBuffer_);
-                            ImGui::CloseCurrentPopup();
-                        }
-                    }
-                    ImGui::SameLine();
-                    if (ImGui::Button("Cancel", ImVec2(120, 0))) {
-                        ImGui::CloseCurrentPopup();
-                    }
-                    ImGui::EndPopup();
-                }
-
-                ImGui::EndTabItem();
-            }
-
-            // ---- Friends tab ----
-            if (ImGui::BeginTabItem("Friends")) {
-                guildRosterTab_ = 2;
-                const auto& contacts = gameHandler.getContacts();
-
-                // Add Friend row
-                static char addFriendBuf[64] = {};
-                ImGui::SetNextItemWidth(180.0f);
-                ImGui::InputText("##addfriend", addFriendBuf, sizeof(addFriendBuf));
-                ImGui::SameLine();
-                if (ImGui::Button("Add Friend") && addFriendBuf[0] != '\0') {
-                    gameHandler.addFriend(addFriendBuf);
-                    addFriendBuf[0] = '\0';
-                }
-                ImGui::Separator();
-
-                // Note-edit state
-                static std::string friendNoteTarget;
-                static char friendNoteBuf[256] = {};
-                static bool openNotePopup = false;
-
-                // Filter to friends only
-                int friendCount = 0;
-                for (size_t ci = 0; ci < contacts.size(); ++ci) {
-                    const auto& c = contacts[ci];
-                    if (!c.isFriend()) continue;
-                    ++friendCount;
-
-                    ImGui::PushID(static_cast<int>(ci));
-
-                    // Status dot
-                    ImU32 dotColor = c.isOnline()
-                        ? IM_COL32(80, 200, 80, 255)
-                        : IM_COL32(120, 120, 120, 255);
-                    ImVec2 cursor = ImGui::GetCursorScreenPos();
-                    ImGui::GetWindowDrawList()->AddCircleFilled(
-                        ImVec2(cursor.x + 6.0f, cursor.y + 8.0f), 5.0f, dotColor);
-                    ImGui::Dummy(ImVec2(14.0f, 0.0f));
-                    ImGui::SameLine();
-
-                    // Name as Selectable for right-click context menu
-                    const char* displayName = c.name.empty() ? "(unknown)" : c.name.c_str();
-                    ImVec4 nameCol = c.isOnline()
-                        ? ui::colors::kWhite
-                        : colors::kInactiveGray;
-                    ImGui::PushStyleColor(ImGuiCol_Text, nameCol);
-                    ImGui::Selectable(displayName, false, ImGuiSelectableFlags_AllowOverlap, ImVec2(130.0f, 0.0f));
-                    ImGui::PopStyleColor();
-
-                    // Double-click to whisper
-                    if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)
-                        && !c.name.empty()) {
-                        chatPanel.setWhisperTarget(c.name);
-                    }
-
-                    // Right-click context menu
-                    if (ImGui::BeginPopupContextItem("FriendCtx")) {
-                        ImGui::TextDisabled("%s", displayName);
-                        ImGui::Separator();
-                        if (ImGui::MenuItem("Whisper") && !c.name.empty()) {
-                            chatPanel.setWhisperTarget(c.name);
-                        }
-                        if (c.isOnline() && ImGui::MenuItem("Invite to Group") && !c.name.empty()) {
-                            gameHandler.inviteToGroup(c.name);
-                        }
-                        if (ImGui::MenuItem("Edit Note")) {
-                            friendNoteTarget = c.name;
-                            strncpy(friendNoteBuf, c.note.c_str(), sizeof(friendNoteBuf) - 1);
-                            friendNoteBuf[sizeof(friendNoteBuf) - 1] = '\0';
-                            openNotePopup = true;
-                        }
-                        ImGui::Separator();
-                        if (ImGui::MenuItem("Remove Friend")) {
-                            gameHandler.removeFriend(c.name);
-                        }
-                        ImGui::EndPopup();
-                    }
-
-                    // Note tooltip on hover
-                    if (ImGui::IsItemHovered() && !c.note.empty()) {
-                        ImGui::BeginTooltip();
-                        ImGui::TextDisabled("Note: %s", c.note.c_str());
-                        ImGui::EndTooltip();
-                    }
-
-                    // Level, class, and status
-                    if (c.isOnline()) {
-                        ImGui::SameLine(150.0f);
-                        const char* statusLabel =
-                            (c.status == 2) ? " (AFK)" :
-                            (c.status == 3) ? " (DND)" : "";
-                        // Class color for the level/class display
-                        ImVec4 friendClassCol = classColorVec4(static_cast<uint8_t>(c.classId));
-                        const char* friendClassName = classNameStr(static_cast<uint8_t>(c.classId));
-                        if (c.level > 0 && c.classId > 0) {
-                            ImGui::TextColored(friendClassCol, "Lv%u %s%s", c.level, friendClassName, statusLabel);
-                        } else if (c.level > 0) {
-                            ImGui::TextDisabled("Lv %u%s", c.level, statusLabel);
-                        } else if (*statusLabel) {
-                            ImGui::TextDisabled("%s", statusLabel + 1);
-                        }
-
-                        // Tooltip: zone info
-                        if (ImGui::IsItemHovered() && c.areaId != 0) {
-                            ImGui::BeginTooltip();
-                            if (zoneManager) {
-                                const auto* zi = zoneManager->getZoneInfo(c.areaId);
-                                if (zi && !zi->name.empty())
-                                    ImGui::Text("Zone: %s", zi->name.c_str());
-                                else
-                                    ImGui::TextDisabled("Area ID: %u", c.areaId);
-                            } else {
-                                ImGui::TextDisabled("Area ID: %u", c.areaId);
-                            }
-                            ImGui::EndTooltip();
-                        }
-                    }
-
-                    ImGui::PopID();
-                }
-
-                if (friendCount == 0) {
-                    ImGui::TextDisabled("No friends found.");
-                }
-
-                // Note edit modal
-                if (openNotePopup) {
-                    ImGui::OpenPopup("EditFriendNote");
-                    openNotePopup = false;
-                }
-                if (ImGui::BeginPopupModal("EditFriendNote", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
-                    ImGui::Text("Note for %s:", friendNoteTarget.c_str());
-                    ImGui::SetNextItemWidth(240.0f);
-                    ImGui::InputText("##fnote", friendNoteBuf, sizeof(friendNoteBuf));
-                    if (ImGui::Button("Save", ImVec2(110, 0))) {
-                        gameHandler.setFriendNote(friendNoteTarget, friendNoteBuf);
-                        ImGui::CloseCurrentPopup();
-                    }
-                    ImGui::SameLine();
-                    if (ImGui::Button("Cancel", ImVec2(110, 0))) {
-                        ImGui::CloseCurrentPopup();
-                    }
-                    ImGui::EndPopup();
-                }
-
-                ImGui::EndTabItem();
-            }
-
-            // ---- Ignore List tab ----
-            if (ImGui::BeginTabItem("Ignore")) {
-                guildRosterTab_ = 3;
-                const auto& contacts = gameHandler.getContacts();
-
-                // Add Ignore row
-                static char addIgnoreBuf[64] = {};
-                ImGui::SetNextItemWidth(180.0f);
-                ImGui::InputText("##addignore", addIgnoreBuf, sizeof(addIgnoreBuf));
-                ImGui::SameLine();
-                if (ImGui::Button("Ignore Player") && addIgnoreBuf[0] != '\0') {
-                    gameHandler.addIgnore(addIgnoreBuf);
-                    addIgnoreBuf[0] = '\0';
-                }
-                ImGui::Separator();
-
-                int ignoreCount = 0;
-                for (size_t ci = 0; ci < contacts.size(); ++ci) {
-                    const auto& c = contacts[ci];
-                    if (!c.isIgnored()) continue;
-                    ++ignoreCount;
-
-                    ImGui::PushID(static_cast<int>(ci) + 10000);
-                    const char* displayName = c.name.empty() ? "(unknown)" : c.name.c_str();
-                    ImGui::Selectable(displayName, false, ImGuiSelectableFlags_AllowOverlap);
-                    if (ImGui::BeginPopupContextItem("IgnoreCtx")) {
-                        ImGui::TextDisabled("%s", displayName);
-                        ImGui::Separator();
-                        if (ImGui::MenuItem("Remove Ignore")) {
-                            gameHandler.removeIgnore(c.name);
-                        }
-                        ImGui::EndPopup();
-                    }
-                    ImGui::PopID();
-                }
-
-                if (ignoreCount == 0) {
-                    ImGui::TextDisabled("Ignore list is empty.");
-                }
-
-                ImGui::EndTabItem();
-            }
-
-            ImGui::EndTabBar();
-        }
-    }
-    ImGui::End();
-    showGuildRoster_ = open;
-}
-
-void SocialPanel::renderSocialFrame(game::GameHandler& gameHandler,
-                                       ChatPanel& chatPanel) {
-    if (!showSocialFrame_) return;
-
-    const auto& contacts = gameHandler.getContacts();
-    // Count online friends for early-out
-    int onlineCount = 0;
-    for (const auto& c : contacts)
-        if (c.isFriend() && c.isOnline()) ++onlineCount;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW - 230.0f, 240.0f), ImGuiCond_Once);
-    ImGui::SetNextWindowSize(ImVec2(220.0f, 0.0f), ImGuiCond_Always);
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.1f, 0.1f, 0.1f, 0.92f));
-
-    // State for "Set Note" inline editing
-    static int  noteEditContactIdx = -1;
-    static char noteEditBuf[128]   = {};
-
-    bool open = showSocialFrame_;
-    char socialTitle[32];
-    snprintf(socialTitle, sizeof(socialTitle), "Social (%d online)##SocialFrame", onlineCount);
-    if (ImGui::Begin(socialTitle, &open,
-            ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
-            ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoScrollbar)) {
-
-        // Get zone manager for area name lookups
-        game::ZoneManager* socialZoneMgr = nullptr;
-        if (auto* rend = services_.renderer)
-            socialZoneMgr = rend->getZoneManager();
-
-        if (ImGui::BeginTabBar("##SocialTabs")) {
-            // ---- Friends tab ----
-            if (ImGui::BeginTabItem("Friends")) {
-                ImGui::BeginChild("##FriendsList", ImVec2(200, 200), false);
-
-                // Online friends first
-                int shown = 0;
-                for (int pass = 0; pass < 2; ++pass) {
-                    bool wantOnline = (pass == 0);
-                    for (size_t ci = 0; ci < contacts.size(); ++ci) {
-                        const auto& c = contacts[ci];
-                        if (!c.isFriend()) continue;
-                        if (c.isOnline() != wantOnline) continue;
-
-                        ImGui::PushID(static_cast<int>(ci));
-
-                        // Status dot
-                        ImU32 dotColor;
-                        if (!c.isOnline())        dotColor = IM_COL32(100, 100, 100, 200);
-                        else if (c.status == 2)   dotColor = IM_COL32(255, 200,  50, 255); // AFK
-                        else if (c.status == 3)   dotColor = IM_COL32(255, 120,  50, 255); // DND
-                        else                      dotColor = IM_COL32( 50, 220,  50, 255); // online
-
-                        ImVec2 dotMin = ImGui::GetCursorScreenPos();
-                        dotMin.y += 4.0f;
-                        ImGui::GetWindowDrawList()->AddCircleFilled(
-                            ImVec2(dotMin.x + 5.0f, dotMin.y + 5.0f), 4.5f, dotColor);
-                        ImGui::SetCursorPosX(ImGui::GetCursorPosX() + 14.0f);
-
-                        const char* displayName = c.name.empty() ? "(unknown)" : c.name.c_str();
-                        ImVec4 nameCol = c.isOnline()
-                            ? classColorVec4(static_cast<uint8_t>(c.classId))
-                            : kColorDarkGray;
-                        ImGui::TextColored(nameCol, "%s", displayName);
-
-                        if (c.isOnline() && c.level > 0) {
-                            ImGui::SameLine();
-                            // Show level and class name in class color
-                            ImGui::TextColored(classColorVec4(static_cast<uint8_t>(c.classId)),
-                                "Lv%u %s", c.level, classNameStr(static_cast<uint8_t>(c.classId)));
-                        }
-
-                        // Tooltip: zone info and note
-                        if (ImGui::IsItemHovered() || (c.isOnline() && ImGui::IsItemHovered())) {
-                            if (c.isOnline() && (c.areaId != 0 || !c.note.empty())) {
-                                ImGui::BeginTooltip();
-                                if (c.areaId != 0) {
-                                    const char* zoneName = nullptr;
-                                    if (socialZoneMgr) {
-                                        const auto* zi = socialZoneMgr->getZoneInfo(c.areaId);
-                                        if (zi && !zi->name.empty()) zoneName = zi->name.c_str();
-                                    }
-                                    if (zoneName)
-                                        ImGui::Text("Zone: %s", zoneName);
-                                    else
-                                        ImGui::Text("Area ID: %u", c.areaId);
-                                }
-                                if (!c.note.empty())
-                                    ImGui::TextDisabled("Note: %s", c.note.c_str());
-                                ImGui::EndTooltip();
-                            }
-                        }
-
-                        // Right-click context menu
-                        if (ImGui::BeginPopupContextItem("FriendCtx")) {
-                            ImGui::TextDisabled("%s", displayName);
-                            ImGui::Separator();
-                            if (c.isOnline()) {
-                                if (ImGui::MenuItem("Whisper")) {
-                                    showSocialFrame_ = false;
-                                    chatPanel.setWhisperTarget(c.name);
-                                }
-                                if (ImGui::MenuItem("Invite to Group"))
-                                    gameHandler.inviteToGroup(c.name);
-                                if (c.guid != 0 && ImGui::MenuItem("Trade"))
-                                    gameHandler.initiateTrade(c.guid);
-                            }
-                            if (ImGui::MenuItem("Set Note")) {
-                                noteEditContactIdx = static_cast<int>(ci);
-                                strncpy(noteEditBuf, c.note.c_str(), sizeof(noteEditBuf) - 1);
-                                noteEditBuf[sizeof(noteEditBuf) - 1] = '\0';
-                                ImGui::OpenPopup("##SetFriendNote");
-                            }
-                            if (ImGui::MenuItem("Remove Friend"))
-                                gameHandler.removeFriend(c.name);
-                            ImGui::EndPopup();
-                        }
-
-                        ++shown;
-                        ImGui::PopID();
-                    }
-                    // Separator between online and offline if there are both
-                    if (pass == 0 && shown > 0) {
-                        ImGui::Separator();
-                    }
-                }
-
-                if (shown == 0) {
-                    ImGui::TextDisabled("No friends yet.");
-                }
-
-                ImGui::EndChild();
-
-                // "Set Note" modal popup
-                if (ImGui::BeginPopup("##SetFriendNote")) {
-                    const std::string& noteName = (noteEditContactIdx >= 0 &&
-                        noteEditContactIdx < static_cast<int>(contacts.size()))
-                        ? contacts[noteEditContactIdx].name : "";
-                    ImGui::TextDisabled("Note for %s:", noteName.c_str());
-                    ImGui::SetNextItemWidth(180.0f);
-                    bool confirm = ImGui::InputText("##noteinput", noteEditBuf, sizeof(noteEditBuf),
-                        ImGuiInputTextFlags_EnterReturnsTrue);
-                    ImGui::SameLine();
-                    if (confirm || ImGui::Button("OK")) {
-                        if (!noteName.empty())
-                            gameHandler.setFriendNote(noteName, noteEditBuf);
-                        noteEditContactIdx = -1;
-                        ImGui::CloseCurrentPopup();
-                    }
-                    ImGui::SameLine();
-                    if (ImGui::Button("Cancel")) {
-                        noteEditContactIdx = -1;
-                        ImGui::CloseCurrentPopup();
-                    }
-                    ImGui::EndPopup();
-                }
-
-                ImGui::Separator();
-
-                // Add friend
-                static char addFriendBuf[64] = {};
-                ImGui::SetNextItemWidth(140.0f);
-                ImGui::InputText("##sf_addfriend", addFriendBuf, sizeof(addFriendBuf));
-                ImGui::SameLine();
-                if (ImGui::Button("+##addfriend") && addFriendBuf[0] != '\0') {
-                    gameHandler.addFriend(addFriendBuf);
-                    addFriendBuf[0] = '\0';
-                }
-
-                ImGui::EndTabItem();
-            }
-
-            // ---- Ignore tab ----
-            if (ImGui::BeginTabItem("Ignore")) {
-                const auto& ignores = gameHandler.getIgnoreCache();
-                ImGui::BeginChild("##IgnoreList", ImVec2(200, 200), false);
-
-                if (ignores.empty()) {
-                    ImGui::TextDisabled("Ignore list is empty.");
-                } else {
-                    for (const auto& kv : ignores) {
-                        ImGui::PushID(kv.first.c_str());
-                        ImGui::TextUnformatted(kv.first.c_str());
-                        if (ImGui::BeginPopupContextItem("IgnoreCtx")) {
-                            ImGui::TextDisabled("%s", kv.first.c_str());
-                            ImGui::Separator();
-                            if (ImGui::MenuItem("Unignore"))
-                                gameHandler.removeIgnore(kv.first);
-                            ImGui::EndPopup();
-                        }
-                        ImGui::PopID();
-                    }
-                }
-
-                ImGui::EndChild();
-                ImGui::Separator();
-
-                // Add ignore
-                static char addIgnBuf[64] = {};
-                ImGui::SetNextItemWidth(140.0f);
-                ImGui::InputText("##sf_addignore", addIgnBuf, sizeof(addIgnBuf));
-                ImGui::SameLine();
-                if (ImGui::Button("+##addignore") && addIgnBuf[0] != '\0') {
-                    gameHandler.addIgnore(addIgnBuf);
-                    addIgnBuf[0] = '\0';
-                }
-
-                ImGui::EndTabItem();
-            }
-
-            // ---- Channels tab ----
-            if (ImGui::BeginTabItem("Channels")) {
-                const auto& channels = gameHandler.getJoinedChannels();
-                ImGui::BeginChild("##ChannelList", ImVec2(200, 200), false);
-
-                if (channels.empty()) {
-                    ImGui::TextDisabled("Not in any channels.");
-                } else {
-                    for (size_t ci = 0; ci < channels.size(); ++ci) {
-                        ImGui::PushID(static_cast<int>(ci));
-                        ImGui::TextUnformatted(channels[ci].c_str());
-                        if (ImGui::BeginPopupContextItem("ChanCtx")) {
-                            ImGui::TextDisabled("%s", channels[ci].c_str());
-                            ImGui::Separator();
-                            if (ImGui::MenuItem("Leave Channel"))
-                                gameHandler.leaveChannel(channels[ci]);
-                            ImGui::EndPopup();
-                        }
-                        ImGui::PopID();
-                    }
-                }
-
-                ImGui::EndChild();
-                ImGui::Separator();
-
-                // Join a channel
-                static char joinChanBuf[64] = {};
-                ImGui::SetNextItemWidth(140.0f);
-                ImGui::InputText("##sf_joinchan", joinChanBuf, sizeof(joinChanBuf));
-                ImGui::SameLine();
-                if (ImGui::Button("+##joinchan") && joinChanBuf[0] != '\0') {
-                    gameHandler.joinChannel(joinChanBuf);
-                    joinChanBuf[0] = '\0';
-                }
-
-                ImGui::EndTabItem();
-            }
-
-            // ---- Arena tab (WotLK: shows per-team rating/record + roster) ----
-            const auto& arenaStats = gameHandler.getArenaTeamStats();
-            if (!arenaStats.empty()) {
-                if (ImGui::BeginTabItem("Arena")) {
-                    ImGui::BeginChild("##ArenaList", ImVec2(0, 0), false);
-
-                    for (size_t ai = 0; ai < arenaStats.size(); ++ai) {
-                        const auto& ts = arenaStats[ai];
-                        ImGui::PushID(static_cast<int>(ai));
-
-                        // Team header: "2v2: Team Name" or fallback "Team #id"
-                        std::string teamLabel;
-                        if (ts.teamType > 0)
-                            teamLabel = std::to_string(ts.teamType) + "v" + std::to_string(ts.teamType) + ": ";
-                        if (!ts.teamName.empty())
-                            teamLabel += ts.teamName;
-                        else
-                            teamLabel += "Team #" + std::to_string(ts.teamId);
-                        ImGui::TextColored(ImVec4(1.0f, 0.85f, 0.2f, 1.0f), "%s", teamLabel.c_str());
-
-                        ImGui::Indent(8.0f);
-                        // Rating and rank
-                        ImGui::Text("Rating: %u", ts.rating);
-                        if (ts.rank > 0) {
-                            ImGui::SameLine(0, 6);
-                            ImGui::TextDisabled("(Rank #%u)", ts.rank);
-                        }
-
-                        // Weekly record
-                        uint32_t weekLosses = ts.weekGames > ts.weekWins
-                                              ? ts.weekGames - ts.weekWins : 0;
-                        ImGui::Text("Week:   %u W / %u L", ts.weekWins, weekLosses);
-
-                        // Season record
-                        uint32_t seasLosses = ts.seasonGames > ts.seasonWins
-                                              ? ts.seasonGames - ts.seasonWins : 0;
-                        ImGui::Text("Season: %u W / %u L", ts.seasonWins, seasLosses);
-
-                        // Roster members (from SMSG_ARENA_TEAM_ROSTER)
-                        const auto* roster = gameHandler.getArenaTeamRoster(ts.teamId);
-                        if (roster && !roster->members.empty()) {
-                            ImGui::Spacing();
-                            ImGui::TextDisabled("-- Roster (%zu members) --",
-                                                roster->members.size());
-                            ImGui::SameLine();
-                            if (ImGui::SmallButton("Refresh"))
-                                gameHandler.requestArenaTeamRoster(ts.teamId);
-
-                            // Column headers
-                            ImGui::Columns(4, "##arenaRosterCols", false);
-                            ImGui::SetColumnWidth(0, 110.0f);
-                            ImGui::SetColumnWidth(1, 60.0f);
-                            ImGui::SetColumnWidth(2, 60.0f);
-                            ImGui::SetColumnWidth(3, 60.0f);
-                            ImGui::TextDisabled("Name");      ImGui::NextColumn();
-                            ImGui::TextDisabled("Rating");    ImGui::NextColumn();
-                            ImGui::TextDisabled("Week");      ImGui::NextColumn();
-                            ImGui::TextDisabled("Season");    ImGui::NextColumn();
-                            ImGui::Separator();
-
-                            for (const auto& m : roster->members) {
-                                // Name coloured green (online) or grey (offline)
-                                if (m.online)
-                                    ImGui::TextColored(ImVec4(0.4f,1.0f,0.4f,1.0f),
-                                                       "%s", m.name.c_str());
-                                else
-                                    ImGui::TextDisabled("%s", m.name.c_str());
-                                ImGui::NextColumn();
-
-                                ImGui::Text("%u", m.personalRating);
-                                ImGui::NextColumn();
-
-                                uint32_t wL = m.weekGames > m.weekWins
-                                              ? m.weekGames - m.weekWins : 0;
-                                ImGui::Text("%uW/%uL", m.weekWins, wL);
-                                ImGui::NextColumn();
-
-                                uint32_t sL = m.seasonGames > m.seasonWins
-                                              ? m.seasonGames - m.seasonWins : 0;
-                                ImGui::Text("%uW/%uL", m.seasonWins, sL);
-                                ImGui::NextColumn();
-                            }
-                            ImGui::Columns(1);
-                        } else {
-                            ImGui::Spacing();
-                            if (ImGui::SmallButton("Load Roster"))
-                                gameHandler.requestArenaTeamRoster(ts.teamId);
-                        }
-
-                        ImGui::Unindent(8.0f);
-
-                        if (ai + 1 < arenaStats.size())
-                            ImGui::Separator();
-
-                        ImGui::PopID();
-                    }
-
-                    ImGui::EndChild();
-                    ImGui::EndTabItem();
-                }
-            }
-
-            ImGui::EndTabBar();
-        }
-    }
-    ImGui::End();
-    showSocialFrame_ = open;
-
-    ImGui::PopStyleColor();
-    ImGui::PopStyleVar();
-}
-
-void SocialPanel::renderDungeonFinderWindow(game::GameHandler& gameHandler,
-                                               ChatPanel& chatPanel) {
-    // Toggle Dungeon Finder (customizable keybind)
-    if (!chatPanel.isChatInputActive() && !ImGui::GetIO().WantTextInput &&
-        KeybindingManager::getInstance().isActionPressed(KeybindingManager::Action::TOGGLE_DUNGEON_FINDER)) {
-        showDungeonFinder_ = !showDungeonFinder_;
-    }
-
-    if (!showDungeonFinder_) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth())  : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) :  720.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW * 0.5f - 175.0f, screenH * 0.2f),
-                            ImGuiCond_FirstUseEver);
-    ImGui::SetNextWindowSize(ImVec2(350, 0), ImGuiCond_Always);
-
-    bool open = true;
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize;
-    if (!ImGui::Begin("Dungeon Finder", &open, flags)) {
-        ImGui::End();
-        if (!open) showDungeonFinder_ = false;
-        return;
-    }
-    if (!open) {
-        ImGui::End();
-        showDungeonFinder_ = false;
-        return;
-    }
-
-    using LfgState = game::GameHandler::LfgState;
-    LfgState state = gameHandler.getLfgState();
-
-    // ---- Status banner ----
-    switch (state) {
-        case LfgState::None:
-            ImGui::TextColored(kColorGray, "Status: Not queued");
-            break;
-        case LfgState::RoleCheck:
-            ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.2f, 1.0f), "Status: Role check in progress...");
-            break;
-        case LfgState::Queued: {
-            int32_t avgSec  = gameHandler.getLfgAvgWaitSec();
-            uint32_t qMs    = gameHandler.getLfgTimeInQueueMs();
-            int      qMin   = static_cast<int>(qMs / 60000);
-            int      qSec   = static_cast<int>((qMs % 60000) / 1000);
-            std::string dName = gameHandler.getCurrentLfgDungeonName();
-            if (!dName.empty())
-                ImGui::TextColored(colors::kQueueGreen,
-                                   "Status: In queue for %s (%d:%02d)", dName.c_str(), qMin, qSec);
-            else
-                ImGui::TextColored(colors::kQueueGreen, "Status: In queue (%d:%02d)", qMin, qSec);
-            if (avgSec >= 0) {
-                int aMin = avgSec / 60;
-                int aSec = avgSec % 60;
-                ImGui::TextColored(colors::kSilver,
-                                   "Avg wait: %d:%02d", aMin, aSec);
-            }
-            break;
-        }
-        case LfgState::Proposal: {
-            std::string dName = gameHandler.getCurrentLfgDungeonName();
-            if (!dName.empty())
-                ImGui::TextColored(ImVec4(1.0f, 0.5f, 0.1f, 1.0f), "Status: Group found for %s!", dName.c_str());
-            else
-                ImGui::TextColored(ImVec4(1.0f, 0.5f, 0.1f, 1.0f), "Status: Group found!");
-            break;
-        }
-        case LfgState::Boot:
-            ImGui::TextColored(kColorRed, "Status: Vote kick in progress");
-            break;
-        case LfgState::InDungeon: {
-            std::string dName = gameHandler.getCurrentLfgDungeonName();
-            if (!dName.empty())
-                ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "Status: In dungeon (%s)", dName.c_str());
-            else
-                ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "Status: In dungeon");
-            break;
-        }
-        case LfgState::FinishedDungeon: {
-            std::string dName = gameHandler.getCurrentLfgDungeonName();
-            if (!dName.empty())
-                ImGui::TextColored(colors::kLightGreen, "Status: %s complete", dName.c_str());
-            else
-                ImGui::TextColored(colors::kLightGreen, "Status: Dungeon complete");
-            break;
-        }
-        case LfgState::RaidBrowser:
-            ImGui::TextColored(ImVec4(0.8f, 0.6f, 1.0f, 1.0f), "Status: Raid browser");
-            break;
-    }
-
-    ImGui::Separator();
-
-    // ---- Proposal accept/decline ----
-    if (state == LfgState::Proposal) {
-        std::string dName = gameHandler.getCurrentLfgDungeonName();
-        if (!dName.empty())
-            ImGui::TextColored(ImVec4(1.0f, 0.9f, 0.3f, 1.0f),
-                               "A group has been found for %s!", dName.c_str());
-        else
-            ImGui::TextColored(ImVec4(1.0f, 0.9f, 0.3f, 1.0f),
-                               "A group has been found for your dungeon!");
-        ImGui::Spacing();
-        if (ImGui::Button("Accept", ImVec2(120, 0))) {
-            gameHandler.lfgAcceptProposal(gameHandler.getLfgProposalId(), true);
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Decline", ImVec2(120, 0))) {
-            gameHandler.lfgAcceptProposal(gameHandler.getLfgProposalId(), false);
-        }
-        ImGui::Separator();
-    }
-
-    // ---- Vote-to-kick buttons ----
-    if (state == LfgState::Boot) {
-        ImGui::TextColored(kColorRed, "Vote to kick in progress:");
-        const std::string& bootTarget = gameHandler.getLfgBootTargetName();
-        const std::string& bootReason = gameHandler.getLfgBootReason();
-        if (!bootTarget.empty()) {
-            ImGui::Text("Player: ");
-            ImGui::SameLine();
-            ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.3f, 1.0f), "%s", bootTarget.c_str());
-        }
-        if (!bootReason.empty()) {
-            ImGui::Text("Reason: ");
-            ImGui::SameLine();
-            ImGui::TextWrapped("%s", bootReason.c_str());
-        }
-        uint32_t bootVotes   = gameHandler.getLfgBootVotes();
-        uint32_t bootTotal   = gameHandler.getLfgBootTotal();
-        uint32_t bootNeeded  = gameHandler.getLfgBootNeeded();
-        uint32_t bootTimeLeft= gameHandler.getLfgBootTimeLeft();
-        if (bootNeeded > 0) {
-            ImGui::Text("Votes: %u / %u  (need %u)   %us left",
-                        bootVotes, bootTotal, bootNeeded, bootTimeLeft);
-        }
-        ImGui::Spacing();
-        if (ImGui::Button("Vote Yes (kick)", ImVec2(140, 0))) {
-            gameHandler.lfgSetBootVote(true);
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Vote No (keep)", ImVec2(140, 0))) {
-            gameHandler.lfgSetBootVote(false);
-        }
-        ImGui::Separator();
-    }
-
-    // ---- Teleport button (in dungeon) ----
-    if (state == LfgState::InDungeon) {
-        if (ImGui::Button("Teleport to Dungeon", ImVec2(-1, 0))) {
-            gameHandler.lfgTeleport(true);
-        }
-        ImGui::Separator();
-    }
-
-    // ---- Role selection (only when not queued/in dungeon) ----
-    bool canConfigure = (state == LfgState::None || state == LfgState::FinishedDungeon);
-
-    if (canConfigure) {
-        ImGui::Text("Role:");
-        ImGui::SameLine();
-        bool isTank   = (lfgRoles_ & 0x02) != 0;
-        bool isHealer = (lfgRoles_ & 0x04) != 0;
-        bool isDps    = (lfgRoles_ & 0x08) != 0;
-        if (ImGui::Checkbox("Tank",   &isTank))   lfgRoles_ = (lfgRoles_ & ~0x02) | (isTank   ? 0x02 : 0);
-        ImGui::SameLine();
-        if (ImGui::Checkbox("Healer", &isHealer)) lfgRoles_ = (lfgRoles_ & ~0x04) | (isHealer ? 0x04 : 0);
-        ImGui::SameLine();
-        if (ImGui::Checkbox("DPS",    &isDps))    lfgRoles_ = (lfgRoles_ & ~0x08) | (isDps    ? 0x08 : 0);
-
-        ImGui::Spacing();
-
-        // ---- Dungeon selection ----
-        ImGui::Text("Dungeon:");
-
-        struct DungeonEntry { uint32_t id; const char* name; };
-        // Category 0=Random, 1=Classic, 2=TBC, 3=WotLK
-        struct DungeonEntryEx { uint32_t id; const char* name; uint8_t cat; };
-        static const DungeonEntryEx kDungeons[] = {
-            { 861, "Random Dungeon",               0 },
-            { 862, "Random Heroic",                0 },
-            {  36, "Deadmines",                    1 },
-            {  43, "Ragefire Chasm",               1 },
-            {  47, "Razorfen Kraul",               1 },
-            {  48, "Blackfathom Deeps",            1 },
-            {  52, "Uldaman",                      1 },
-            {  57, "Dire Maul: East",              1 },
-            {  70, "Onyxia's Lair",                1 },
-            { 264, "The Blood Furnace",            2 },
-            { 269, "The Shattered Halls",          2 },
-            { 576, "The Nexus",                    3 },
-            { 578, "The Oculus",                   3 },
-            { 595, "The Culling of Stratholme",    3 },
-            { 599, "Halls of Stone",               3 },
-            { 600, "Drak'Tharon Keep",             3 },
-            { 601, "Azjol-Nerub",                  3 },
-            { 604, "Gundrak",                      3 },
-            { 608, "Violet Hold",                  3 },
-            { 619, "Ahn'kahet: Old Kingdom",       3 },
-            { 623, "Halls of Lightning",           3 },
-            { 632, "The Forge of Souls",           3 },
-            { 650, "Trial of the Champion",        3 },
-            { 658, "Pit of Saron",                 3 },
-            { 668, "Halls of Reflection",          3 },
-        };
-        static constexpr const char* kCatHeaders[] = { nullptr, "-- Classic --", "-- TBC --", "-- WotLK --" };
-
-        // Find current index
-        int curIdx = 0;
-        for (int i = 0; i < static_cast<int>(sizeof(kDungeons)/sizeof(kDungeons[0])); ++i) {
-            if (kDungeons[i].id == lfgSelectedDungeon_) { curIdx = i; break; }
-        }
-
-        ImGui::SetNextItemWidth(-1);
-        if (ImGui::BeginCombo("##dungeon", kDungeons[curIdx].name)) {
-            uint8_t lastCat = 255;
-            for (int i = 0; i < static_cast<int>(sizeof(kDungeons)/sizeof(kDungeons[0])); ++i) {
-                if (kDungeons[i].cat != lastCat && kCatHeaders[kDungeons[i].cat]) {
-                    if (lastCat != 255) ImGui::Separator();
-                    ImGui::TextDisabled("%s", kCatHeaders[kDungeons[i].cat]);
-                    lastCat = kDungeons[i].cat;
-                } else if (kDungeons[i].cat != lastCat) {
-                    lastCat = kDungeons[i].cat;
-                }
-                bool selected = (kDungeons[i].id == lfgSelectedDungeon_);
-                if (ImGui::Selectable(kDungeons[i].name, selected))
-                    lfgSelectedDungeon_ = kDungeons[i].id;
-                if (selected) ImGui::SetItemDefaultFocus();
-            }
-            ImGui::EndCombo();
-        }
-
-        ImGui::Spacing();
-
-        // ---- Join button ----
-        bool rolesOk = (lfgRoles_ != 0);
-        if (!rolesOk) {
-            ImGui::BeginDisabled();
-        }
-        if (ImGui::Button("Join Dungeon Finder", ImVec2(-1, 0))) {
-            gameHandler.lfgJoin(lfgSelectedDungeon_, lfgRoles_);
-        }
-        if (!rolesOk) {
-            ImGui::EndDisabled();
-            ImGui::TextColored(colors::kSoftRed, "Select at least one role.");
-        }
-    }
-
-    // ---- Leave button (when queued or role check) ----
-    if (state == LfgState::Queued || state == LfgState::RoleCheck) {
-        if (ImGui::Button("Leave Queue", ImVec2(-1, 0))) {
-            gameHandler.lfgLeave();
-        }
-    }
-
-    ImGui::End();
-}
-
-void SocialPanel::renderWhoWindow(game::GameHandler& gameHandler,
-                                     ChatPanel& chatPanel) {
-    if (!showWhoWindow_) return;
-
-    const auto& results = gameHandler.getWhoResults();
-
-    ImGui::SetNextWindowSize(ImVec2(500, 300), ImGuiCond_FirstUseEver);
-    ImGui::SetNextWindowPos(ImVec2(200, 180), ImGuiCond_FirstUseEver);
-
-    char title[64];
-    uint32_t onlineCount = gameHandler.getWhoOnlineCount();
-    if (onlineCount > 0)
-        snprintf(title, sizeof(title), "Players Online: %u###WhoWindow", onlineCount);
-    else
-        snprintf(title, sizeof(title), "Who###WhoWindow");
-
-    if (!ImGui::Begin(title, &showWhoWindow_)) {
-        ImGui::End();
-        return;
-    }
-
-    // Search bar with Send button
-    static char whoSearchBuf[64] = {};
-    bool doSearch = false;
-    ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x - 60.0f);
-    if (ImGui::InputTextWithHint("##whosearch", "Search players...", whoSearchBuf, sizeof(whoSearchBuf),
-            ImGuiInputTextFlags_EnterReturnsTrue))
-        doSearch = true;
-    ImGui::SameLine();
-    if (ImGui::Button("Search", ImVec2(-1, 0)))
-        doSearch = true;
-    if (doSearch) {
-        gameHandler.queryWho(std::string(whoSearchBuf));
-    }
-    ImGui::Separator();
-
-    if (results.empty()) {
-        ImGui::TextDisabled("No results. Type a filter above or use /who [filter].");
-        ImGui::End();
-        return;
-    }
-
-    // Table: Name | Guild | Level | Class | Zone
-    if (ImGui::BeginTable("##WhoTable", 5,
-            ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |
-            ImGuiTableFlags_ScrollY | ImGuiTableFlags_SizingStretchProp,
-            ImVec2(0, 0))) {
-        ImGui::TableSetupScrollFreeze(0, 1);
-        ImGui::TableSetupColumn("Name",  ImGuiTableColumnFlags_WidthStretch, 0.22f);
-        ImGui::TableSetupColumn("Guild", ImGuiTableColumnFlags_WidthStretch, 0.20f);
-        ImGui::TableSetupColumn("Level", ImGuiTableColumnFlags_WidthFixed,   40.0f);
-        ImGui::TableSetupColumn("Class", ImGuiTableColumnFlags_WidthStretch, 0.20f);
-        ImGui::TableSetupColumn("Zone",  ImGuiTableColumnFlags_WidthStretch, 0.28f);
-        ImGui::TableHeadersRow();
-
-        for (size_t i = 0; i < results.size(); ++i) {
-            const auto& e = results[i];
-            ImGui::TableNextRow();
-            ImGui::PushID(static_cast<int>(i));
-
-            // Name (class-colored if class is known)
-            ImGui::TableSetColumnIndex(0);
-            uint8_t cid = static_cast<uint8_t>(e.classId);
-            ImVec4 nameCol = classColorVec4(cid);
-            ImGui::TextColored(nameCol, "%s", e.name.c_str());
-
-            // Right-click context menu on the name
-            if (ImGui::BeginPopupContextItem("##WhoCtx")) {
-                ImGui::TextDisabled("%s", e.name.c_str());
-                ImGui::Separator();
-                if (ImGui::MenuItem("Whisper")) {
-                    chatPanel.setWhisperTarget(e.name);
-                }
-                if (ImGui::MenuItem("Invite to Group"))
-                    gameHandler.inviteToGroup(e.name);
-                if (ImGui::MenuItem("Add Friend"))
-                    gameHandler.addFriend(e.name);
-                if (ImGui::MenuItem("Ignore"))
-                    gameHandler.addIgnore(e.name);
-                ImGui::EndPopup();
-            }
-
-            // Guild
-            ImGui::TableSetColumnIndex(1);
-            if (!e.guildName.empty())
-                ImGui::TextDisabled("<%s>", e.guildName.c_str());
-
-            // Level
-            ImGui::TableSetColumnIndex(2);
-            ImGui::Text("%u", e.level);
-
-            // Class
-            ImGui::TableSetColumnIndex(3);
-            const char* className = game::getClassName(static_cast<game::Class>(e.classId));
-            ImGui::TextColored(nameCol, "%s", className);
-
-            // Zone
-            ImGui::TableSetColumnIndex(4);
-            if (e.zoneId != 0) {
-                std::string zoneName = gameHandler.getWhoAreaName(e.zoneId);
-                if (!zoneName.empty())
-                    ImGui::TextUnformatted(zoneName.c_str());
-                else {
-                    char zfb[32];
-                    snprintf(zfb, sizeof(zfb), "Zone #%u", e.zoneId);
-                    ImGui::TextUnformatted(zfb);
-                }
-            }
-
-            ImGui::PopID();
-        }
-
-        ImGui::EndTable();
-    }
-
-    ImGui::End();
-}
-
-void SocialPanel::renderInspectWindow(game::GameHandler& gameHandler,
-                                         InventoryScreen& inventoryScreen) {
-    if (!showInspectWindow_) return;
-
-    // Lazy-load SpellItemEnchantment.dbc for enchant name lookup
-    static std::unordered_map<uint32_t, std::string> s_enchantNames;
-    static bool s_enchantDbLoaded = false;
-    auto* assetMgrEnchant = services_.assetManager;
-    if (!s_enchantDbLoaded && assetMgrEnchant && assetMgrEnchant->isInitialized()) {
-        s_enchantDbLoaded = true;
-        auto dbc = assetMgrEnchant->loadDBC("SpellItemEnchantment.dbc");
-        if (dbc && dbc->isLoaded()) {
-            const auto* layout = pipeline::getActiveDBCLayout()
-                                 ? pipeline::getActiveDBCLayout()->getLayout("SpellItemEnchantment")
-                                 : nullptr;
-            uint32_t idField   = layout ? (*layout)["ID"]   : 0;
-            uint32_t nameField = layout ? (*layout)["Name"] : 8;
-            for (uint32_t i = 0; i < dbc->getRecordCount(); ++i) {
-                uint32_t id = dbc->getUInt32(i, idField);
-                if (id == 0) continue;
-                std::string nm = dbc->getString(i, nameField);
-                if (!nm.empty()) s_enchantNames[id] = std::move(nm);
-            }
-        }
-    }
-
-    // Slot index 0..18 maps to equipment slots 1..19 (WoW convention: slot 0 unused on server)
-    static constexpr const char* kSlotNames[19] = {
-        "Head", "Neck", "Shoulder", "Shirt", "Chest",
-        "Waist", "Legs", "Feet", "Wrist", "Hands",
-        "Finger 1", "Finger 2", "Trinket 1", "Trinket 2", "Back",
-        "Main Hand", "Off Hand", "Ranged", "Tabard"
-    };
-
-    ImGui::SetNextWindowSize(ImVec2(360, 440), ImGuiCond_FirstUseEver);
-    ImGui::SetNextWindowPos(ImVec2(350, 120), ImGuiCond_FirstUseEver);
-
-    const game::GameHandler::InspectResult* result = gameHandler.getInspectResult();
-
-    std::string title = result ? ("Inspect: " + result->playerName + "###InspectWin")
-                                : "Inspect###InspectWin";
-    if (!ImGui::Begin(title.c_str(), &showInspectWindow_, ImGuiWindowFlags_NoCollapse)) {
-        ImGui::End();
-        return;
-    }
-
-    if (!result) {
-        ImGui::TextDisabled("No inspect data yet. Target a player and use Inspect.");
-        ImGui::End();
-        return;
-    }
-
-    // Player name — class-colored if entity is loaded, else gold
-    {
-        auto ent = gameHandler.getEntityManager().getEntity(result->guid);
-        uint8_t cid = entityClassId(ent.get());
-        ImVec4 nameColor = (cid != 0) ? classColorVec4(cid) : ui::colors::kTooltipGold;
-        ImGui::PushStyleColor(ImGuiCol_Text, nameColor);
-        ImGui::Text("%s", result->playerName.c_str());
-        ImGui::PopStyleColor();
-        if (cid != 0) {
-            ImGui::SameLine();
-            ImGui::TextColored(classColorVec4(cid), "(%s)", classNameStr(cid));
-        }
-    }
-    ImGui::SameLine();
-    ImGui::TextDisabled("  %u talent pts", result->totalTalents);
-    if (result->unspentTalents > 0) {
-        ImGui::SameLine();
-        ImGui::TextColored(colors::kSoftRed, "(%u unspent)", result->unspentTalents);
-    }
-    if (result->talentGroups > 1) {
-        ImGui::SameLine();
-        ImGui::TextDisabled("  Dual spec (active %u)", static_cast<unsigned>(result->activeTalentGroup) + 1);
-    }
-
-    ImGui::Separator();
-
-    // Equipment list
-    bool hasAnyGear = false;
-    for (int s = 0; s < 19; ++s) {
-        if (result->itemEntries[s] != 0) { hasAnyGear = true; break; }
-    }
-
-    if (!hasAnyGear) {
-        ImGui::TextDisabled("Equipment data not yet available.");
-        ImGui::TextDisabled("(Gear loads after the player is inspected in-range)");
-    } else {
-        // Average item level (only slots that have loaded info and are not shirt/tabard)
-        // Shirt=slot3, Tabard=slot18 — excluded from gear score by WoW convention
-        uint32_t iLevelSum = 0;
-        int iLevelCount = 0;
-        for (int s = 0; s < 19; ++s) {
-            if (s == 3 || s == 18) continue; // shirt, tabard
-            uint32_t entry = result->itemEntries[s];
-            if (entry == 0) continue;
-            const game::ItemQueryResponseData* info = gameHandler.getItemInfo(entry);
-            if (info && info->valid && info->itemLevel > 0) {
-                iLevelSum += info->itemLevel;
-                ++iLevelCount;
-            }
-        }
-        if (iLevelCount > 0) {
-            float avgIlvl = static_cast<float>(iLevelSum) / static_cast<float>(iLevelCount);
-            ImGui::TextColored(ImVec4(0.8f, 0.9f, 1.0f, 1.0f), "Avg iLvl: %.1f", avgIlvl);
-            ImGui::SameLine();
-            ImGui::TextDisabled("(%d/%d slots loaded)", iLevelCount,
-                [&]{ int c=0; for(int s=0;s<19;++s){if(s==3||s==18)continue;if(result->itemEntries[s])++c;} return c; }());
-        }
-        if (ImGui::BeginChild("##inspect_gear", ImVec2(0, 0), false)) {
-            constexpr float kIconSz = 28.0f;
-            for (int s = 0; s < 19; ++s) {
-                uint32_t entry = result->itemEntries[s];
-                if (entry == 0) continue;
-
-                const game::ItemQueryResponseData* info = gameHandler.getItemInfo(entry);
-                if (!info) {
-                    gameHandler.ensureItemInfo(entry);
-                    ImGui::PushID(s);
-                    ImGui::TextDisabled("[%s]  (loading…)", kSlotNames[s]);
-                    ImGui::PopID();
-                    continue;
-                }
-
-                ImGui::PushID(s);
-                auto qColor = InventoryScreen::getQualityColor(
-                    static_cast<game::ItemQuality>(info->quality));
-                uint16_t enchantId = result->enchantIds[s];
-
-                // Item icon
-                VkDescriptorSet iconTex = inventoryScreen.getItemIcon(info->displayInfoId);
-                if (iconTex) {
-                    ImGui::Image((ImTextureID)(uintptr_t)iconTex, ImVec2(kIconSz, kIconSz),
-                                 ImVec2(0,0), ImVec2(1,1),
-                                 colors::kWhite, qColor);
-                } else {
-                    ImGui::GetWindowDrawList()->AddRectFilled(
-                        ImGui::GetCursorScreenPos(),
-                        ImVec2(ImGui::GetCursorScreenPos().x + kIconSz,
-                               ImGui::GetCursorScreenPos().y + kIconSz),
-                        IM_COL32(40, 40, 50, 200));
-                    ImGui::Dummy(ImVec2(kIconSz, kIconSz));
-                }
-                bool hovered = ImGui::IsItemHovered();
-
-                ImGui::SameLine();
-                ImGui::SetCursorPosY(ImGui::GetCursorPosY() + (kIconSz - ImGui::GetTextLineHeight()) * 0.5f);
-                ImGui::BeginGroup();
-                ImGui::TextDisabled("%s", kSlotNames[s]);
-                ImGui::TextColored(qColor, "%s", info->name.c_str());
-                // Enchant indicator on the same row as the name
-                if (enchantId != 0) {
-                    auto enchIt = s_enchantNames.find(enchantId);
-                    const std::string& enchName = (enchIt != s_enchantNames.end())
-                                                  ? enchIt->second : std::string{};
-                    ImGui::SameLine();
-                    if (!enchName.empty()) {
-                        ImGui::TextColored(ImVec4(0.6f, 0.85f, 1.0f, 1.0f),
-                            "\xe2\x9c\xa6 %s", enchName.c_str());  // UTF-8 ✦
-                    } else {
-                        ImGui::TextColored(ImVec4(0.6f, 0.85f, 1.0f, 1.0f), "\xe2\x9c\xa6");
-                        if (ImGui::IsItemHovered())
-                            ImGui::SetTooltip("Enchanted (ID %u)", static_cast<unsigned>(enchantId));
-                    }
-                }
-                ImGui::EndGroup();
-                hovered = hovered || ImGui::IsItemHovered();
-
-                if (hovered && info->valid) {
-                    inventoryScreen.renderItemTooltip(*info);
-                } else if (hovered) {
-                    ImGui::SetTooltip("%s", info->name.c_str());
-                }
-
-                ImGui::PopID();
-                ImGui::Spacing();
-            }
-        }
-        ImGui::EndChild();
-    }
-
-    // Arena teams (WotLK — from MSG_INSPECT_ARENA_TEAMS)
-    if (!result->arenaTeams.empty()) {
-        ImGui::Separator();
-        ImGui::TextColored(ImVec4(1.0f, 0.75f, 0.2f, 1.0f), "Arena Teams");
-        ImGui::Spacing();
-        for (const auto& team : result->arenaTeams) {
-            const char* bracket = (team.type == 2) ? "2v2"
-                                : (team.type == 3) ? "3v3"
-                                : (team.type == 5) ? "5v5" : "?v?";
-            ImGui::TextColored(ImVec4(0.9f, 0.9f, 0.9f, 1.0f),
-                               "[%s]  %s", bracket, team.name.c_str());
-            ImGui::SameLine();
-            ImGui::TextColored(ImVec4(0.4f, 0.85f, 1.0f, 1.0f),
-                               "  Rating: %u", team.personalRating);
-            if (team.weekGames > 0 || team.seasonGames > 0) {
-                ImGui::TextDisabled("    Week: %u/%u  Season: %u/%u",
-                                    team.weekWins, team.weekGames,
-                                    team.seasonWins, team.seasonGames);
-            }
-        }
-    }
-
-    ImGui::End();
-}
-
-} // namespace ui
-} // namespace wowee
diff --git a/src/ui/spellbook_screen.cpp b/src/ui/spellbook_screen.cpp
index 22b3a8c1..6e857d73 100644
--- a/src/ui/spellbook_screen.cpp
+++ b/src/ui/spellbook_screen.cpp
@@ -1,6 +1,4 @@
 #include "ui/spellbook_screen.hpp"
-#include "ui/ui_colors.hpp"
-#include "ui/keybinding_manager.hpp"
 #include "core/input.hpp"
 #include "core/application.hpp"
 #include "rendering/vk_context.hpp"
@@ -47,66 +45,18 @@ void SpellbookScreen::loadSpellDBC(pipeline::AssetManager* assetManager) {
     }
 
     uint32_t fieldCount = dbc->getFieldCount();
-    // Classic 1.12 Spell.dbc has 148 fields (Tooltip at index 147), TBC has ~220+ (SchoolMask at 215), WotLK has 234.
-    // Require at least 148 fields so all expansions can load spell names/icons via the DBC layout.
-    if (fieldCount < 148) {
-        LOG_WARNING("Spellbook: Spell.dbc has ", fieldCount, " fields, too few to load");
+    if (fieldCount < 154) {
+        LOG_WARNING("Spellbook: Spell.dbc has ", fieldCount, " fields, expected 234+");
         return;
     }
 
     const auto* spellL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("Spell") : nullptr;
 
-    // Load SpellCastTimes.dbc: field 0=ID, field 1=Base(ms), field 2=PerLevel, field 3=Minimum
-    std::unordered_map<uint32_t, uint32_t> castTimeMap;  // index → base ms
-    auto castTimeDbc = assetManager->loadDBC("SpellCastTimes.dbc");
-    if (castTimeDbc && castTimeDbc->isLoaded()) {
-        for (uint32_t i = 0; i < castTimeDbc->getRecordCount(); ++i) {
-            uint32_t id   = castTimeDbc->getUInt32(i, 0);
-            int32_t  base = static_cast<int32_t>(castTimeDbc->getUInt32(i, 1));
-            if (id > 0 && base > 0)
-                castTimeMap[id] = static_cast<uint32_t>(base);
-        }
-    }
-
-    // Load SpellRange.dbc.  Field layout differs by expansion:
-    //   Classic 1.12:  0=ID, 1=MinRange, 2=MaxRange, 3=Flags, 4+=strings
-    //   TBC / WotLK:   0=ID, 1=MinRangeFriendly, 2=MinRangeHostile,
-    //                  3=MaxRangeFriendly, 4=MaxRangeHostile, 5=Flags, 6+=strings
-    // The correct field is declared in each expansion's dbc_layouts.json.
-    uint32_t spellRangeMaxField = 4;  // WotLK / TBC default: MaxRangeHostile
-    const auto* spellRangeL = pipeline::getActiveDBCLayout()
-                              ? pipeline::getActiveDBCLayout()->getLayout("SpellRange")
-                              : nullptr;
-    if (spellRangeL) {
-        try { spellRangeMaxField = (*spellRangeL)["MaxRange"]; } catch (...) {}
-    }
-    std::unordered_map<uint32_t, float> rangeMap;  // index → max yards
-    auto rangeDbc = assetManager->loadDBC("SpellRange.dbc");
-    if (rangeDbc && rangeDbc->isLoaded()) {
-        uint32_t rangeFieldCount = rangeDbc->getFieldCount();
-        if (rangeFieldCount > spellRangeMaxField) {
-            for (uint32_t i = 0; i < rangeDbc->getRecordCount(); ++i) {
-                uint32_t id = rangeDbc->getUInt32(i, 0);
-                float maxRange = rangeDbc->getFloat(i, spellRangeMaxField);
-                if (id > 0 && maxRange > 0.0f)
-                    rangeMap[id] = maxRange;
-            }
-        }
-    }
-
-    // schoolField / isSchoolEnum are declared before the lambda so the WotLK fallback path
-    // can override them before the second tryLoad call.
-    uint32_t schoolField_  = UINT32_MAX;
-    bool     isSchoolEnum_ = false;
-
     auto tryLoad = [&](uint32_t idField, uint32_t attrField, uint32_t iconField,
                        uint32_t nameField, uint32_t rankField, uint32_t tooltipField,
-                       uint32_t powerTypeField, uint32_t manaCostField,
-                       uint32_t castTimeIndexField, uint32_t rangeIndexField,
                        const char* label) {
         spellData.clear();
         uint32_t count = dbc->getRecordCount();
-        const uint32_t fc = dbc->getFieldCount();
         for (uint32_t i = 0; i < count; ++i) {
             uint32_t spellId = dbc->getUInt32(i, idField);
             if (spellId == 0) continue;
@@ -116,31 +66,8 @@ void SpellbookScreen::loadSpellDBC(pipeline::AssetManager* assetManager) {
             info.attributes = dbc->getUInt32(i, attrField);
             info.iconId = dbc->getUInt32(i, iconField);
             info.name = dbc->getString(i, nameField);
-            if (rankField < fc)    info.rank = dbc->getString(i, rankField);
-            if (tooltipField < fc) info.description = dbc->getString(i, tooltipField);
-            // Optional fields: only read if field index is valid for this DBC version
-            if (powerTypeField < fc)   info.powerType = dbc->getUInt32(i, powerTypeField);
-            if (manaCostField  < fc)   info.manaCost  = dbc->getUInt32(i, manaCostField);
-            if (castTimeIndexField < fc) {
-                uint32_t ctIdx = dbc->getUInt32(i, castTimeIndexField);
-                if (ctIdx > 0) {
-                    auto ctIt = castTimeMap.find(ctIdx);
-                    if (ctIt != castTimeMap.end()) info.castTimeMs = ctIt->second;
-                }
-            }
-            if (rangeIndexField < fc) {
-                uint32_t rangeIdx = dbc->getUInt32(i, rangeIndexField);
-                if (rangeIdx > 0) {
-                    auto rangeIt = rangeMap.find(rangeIdx);
-                    if (rangeIt != rangeMap.end()) info.rangeIndex = static_cast<uint32_t>(rangeIt->second);
-                }
-            }
-            if (schoolField_ < fc) {
-                uint32_t raw = dbc->getUInt32(i, schoolField_);
-                // Classic/Turtle use a 0-6 school enum; TBC/WotLK use a bitmask.
-                // enum→mask: schoolEnum N maps to bit (1u << N), e.g. 0→1 (physical), 4→16 (frost).
-                info.schoolMask = isSchoolEnum_ ? (raw <= 6 ? (1u << raw) : 0u) : raw;
-            }
+            info.rank = dbc->getString(i, rankField);
+            info.description = dbc->getString(i, tooltipField);
 
             if (!info.name.empty()) {
                 spellData[spellId] = std::move(info);
@@ -150,53 +77,21 @@ void SpellbookScreen::loadSpellDBC(pipeline::AssetManager* assetManager) {
     };
 
     if (spellL) {
-        // Default to UINT32_MAX for optional fields; tryLoad will skip them if >= fieldCount.
-        // Avoids reading wrong data from expansion DBCs that lack these fields (e.g. Classic/TBC).
-        uint32_t tooltipField      = UINT32_MAX;
-        uint32_t powerTypeField    = UINT32_MAX;
-        uint32_t manaCostField     = UINT32_MAX;
-        uint32_t castTimeIdxField  = UINT32_MAX;
-        uint32_t rangeIdxField     = UINT32_MAX;
-        try { tooltipField     = (*spellL)["Tooltip"]; } catch (...) {}
-        try { powerTypeField   = (*spellL)["PowerType"]; } catch (...) {}
-        try { manaCostField    = (*spellL)["ManaCost"]; } catch (...) {}
-        try { castTimeIdxField = (*spellL)["CastingTimeIndex"]; } catch (...) {}
-        try { rangeIdxField    = (*spellL)["RangeIndex"]; } catch (...) {}
-        // Try SchoolMask (TBC/WotLK bitmask) then SchoolEnum (Classic/Turtle 0-6 value)
-        schoolField_  = UINT32_MAX;
-        isSchoolEnum_ = false;
-        try { schoolField_ = (*spellL)["SchoolMask"]; } catch (...) {}
-        if (schoolField_ == UINT32_MAX) {
-            try { schoolField_ = (*spellL)["SchoolEnum"]; isSchoolEnum_ = true; } catch (...) {}
-        }
+        uint32_t tooltipField = 139;
+        // Try to get Tooltip field from layout, fall back to 139
+        try { tooltipField = (*spellL)["Tooltip"]; } catch (...) {}
         tryLoad((*spellL)["ID"], (*spellL)["Attributes"], (*spellL)["IconID"],
-                (*spellL)["Name"], (*spellL)["Rank"], tooltipField,
-                powerTypeField, manaCostField, castTimeIdxField, rangeIdxField,
-                "expansion layout");
+                (*spellL)["Name"], (*spellL)["Rank"], tooltipField, "expansion layout");
     }
 
-    // If dbc_layouts.json was missing or its field names didn't match, retry with
-    // hard-coded WotLK field indices as a safety net. fieldCount >= 200 distinguishes
-    // WotLK (234 fields) from Classic (148) to avoid misreading shorter DBCs.
     if (spellData.empty() && fieldCount >= 200) {
         LOG_INFO("Spellbook: Retrying with WotLK field indices (DBC has ", fieldCount, " fields)");
-        schoolField_  = 225;
-        isSchoolEnum_ = false;
-        tryLoad(0, 4, 133, 136, 153, 139, 14, 39, 47, 49, "WotLK fallback");
+        tryLoad(0, 4, 133, 136, 153, 139, "WotLK fallback");
     }
 
     dbcLoaded = !spellData.empty();
 }
 
-bool SpellbookScreen::renderSpellInfoTooltip(uint32_t spellId, game::GameHandler& gameHandler,
-                                              pipeline::AssetManager* assetManager) {
-    if (!dbcLoadAttempted) loadSpellDBC(assetManager);
-    const SpellInfo* info = getSpellInfo(spellId);
-    if (!info) return false;
-    renderSpellTooltip(info, gameHandler, /*showUsageHints=*/false);
-    return true;
-}
-
 std::string SpellbookScreen::lookupSpellName(uint32_t spellId, pipeline::AssetManager* assetManager) {
     if (!dbcLoadAttempted) {
         loadSpellDBC(assetManager);
@@ -206,29 +101,6 @@ std::string SpellbookScreen::lookupSpellName(uint32_t spellId, pipeline::AssetMa
     return {};
 }
 
-uint32_t SpellbookScreen::getSpellMaxRange(uint32_t spellId, pipeline::AssetManager* assetManager) {
-    if (!dbcLoadAttempted) {
-        loadSpellDBC(assetManager);
-    }
-    auto it = spellData.find(spellId);
-    if (it != spellData.end()) return it->second.rangeIndex;
-    return 0;
-}
-
-void SpellbookScreen::getSpellPowerInfo(uint32_t spellId, pipeline::AssetManager* assetManager,
-                                        uint32_t& outCost, uint32_t& outPowerType) {
-    outCost = 0;
-    outPowerType = 0;
-    if (!dbcLoadAttempted) {
-        loadSpellDBC(assetManager);
-    }
-    auto it = spellData.find(spellId);
-    if (it != spellData.end()) {
-        outCost = it->second.manaCost;
-        outPowerType = it->second.powerType;
-    }
-}
-
 void SpellbookScreen::loadSpellIconDBC(pipeline::AssetManager* assetManager) {
     if (iconDbLoaded) return;
     iconDbLoaded = true;
@@ -437,16 +309,6 @@ VkDescriptorSet SpellbookScreen::getSpellIcon(uint32_t iconId, pipeline::AssetMa
     auto cit = spellIconCache.find(iconId);
     if (cit != spellIconCache.end()) return cit->second;
 
-    // Rate-limit GPU uploads to avoid a multi-frame stall when switching tabs.
-    // Icons not loaded this frame will be retried next frame (progressive load).
-    static int loadsThisFrame = 0;
-    static int lastImGuiFrame = -1;
-    int curFrame = ImGui::GetFrameCount();
-    if (curFrame != lastImGuiFrame) { loadsThisFrame = 0; lastImGuiFrame = curFrame; }
-    // Defer without caching — returning null here allows retry next frame when
-    // the budget resets, rather than permanently blacklisting the icon as missing
-    if (loadsThisFrame >= 4) return VK_NULL_HANDLE;
-
     auto pit = spellIconPaths.find(iconId);
     if (pit == spellIconPaths.end()) {
         spellIconCache[iconId] = VK_NULL_HANDLE;
@@ -473,7 +335,6 @@ VkDescriptorSet SpellbookScreen::getSpellIcon(uint32_t iconId, pipeline::AssetMa
         return VK_NULL_HANDLE;
     }
 
-    ++loadsThisFrame;
     VkDescriptorSet ds = vkCtx->uploadImGuiTexture(image.data.data(), image.width, image.height);
     spellIconCache[iconId] = ds;
     return ds;
@@ -484,17 +345,17 @@ const SpellInfo* SpellbookScreen::getSpellInfo(uint32_t spellId) const {
     return (it != spellData.end()) ? &it->second : nullptr;
 }
 
-void SpellbookScreen::renderSpellTooltip(const SpellInfo* info, game::GameHandler& gameHandler, bool showUsageHints) {
+void SpellbookScreen::renderSpellTooltip(const SpellInfo* info, game::GameHandler& gameHandler) {
     ImGui::BeginTooltip();
     ImGui::PushTextWrapPos(320.0f);
 
     // Spell name in yellow
-    ImGui::TextColored(ui::colors::kYellow, "%s", info->name.c_str());
+    ImGui::TextColored(ImVec4(1.0f, 1.0f, 0.3f, 1.0f), "%s", info->name.c_str());
 
     // Rank in gray
     if (!info->rank.empty()) {
         ImGui::SameLine();
-        ImGui::TextColored(ui::colors::kGray, "(%s)", info->rank.c_str());
+        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "(%s)", info->rank.c_str());
     }
 
     // Passive indicator
@@ -502,95 +363,10 @@ void SpellbookScreen::renderSpellTooltip(const SpellInfo* info, game::GameHandle
         ImGui::TextColored(ImVec4(1.0f, 1.0f, 0.0f, 1.0f), "Passive");
     }
 
-    // Spell school — only show for non-physical schools (physical is the default/implicit)
-    if (info->schoolMask != 0 && info->schoolMask != 1 /*physical*/) {
-        struct SchoolEntry { uint32_t mask; const char* name; ImVec4 color; };
-        static constexpr SchoolEntry kSchools[] = {
-            { 2,  "Holy",    { 1.0f, 1.0f, 0.6f, 1.0f } },
-            { 4,  "Fire",    { 1.0f, 0.5f, 0.1f, 1.0f } },
-            { 8,  "Nature",  { 0.4f, 0.9f, 0.3f, 1.0f } },
-            { 16, "Frost",   { 0.5f, 0.8f, 1.0f, 1.0f } },
-            { 32, "Shadow",  { 0.7f, 0.4f, 1.0f, 1.0f } },
-            { 64, "Arcane",  { 0.9f, 0.5f, 1.0f, 1.0f } },
-        };
-        bool first = true;
-        for (const auto& s : kSchools) {
-            if (info->schoolMask & s.mask) {
-                if (!first) ImGui::SameLine(0, 0);
-                if (first) {
-                    ImGui::TextColored(s.color, "%s", s.name);
-                    first = false;
-                } else {
-                    ImGui::SameLine(0, 2);
-                    ImGui::TextColored(s.color, "/%s", s.name);
-                }
-            }
-        }
-    }
-
-    // Resource cost + cast time on same row (WoW style)
-    if (!info->isPassive()) {
-        // Left: resource cost (with talent flat/pct modifier applied)
-        char costBuf[64] = "";
-        if (info->manaCost > 0) {
-            const char* powerName = "Mana";
-            switch (info->powerType) {
-                case 1: powerName = "Rage";   break;
-                case 3: powerName = "Energy"; break;
-                case 4: powerName = "Focus";  break;
-                default: break;
-            }
-            // Apply SMSG_SET_FLAT/PCT_SPELL_MODIFIER Cost modifier (SpellModOp::Cost = 14)
-            int32_t flatCost = gameHandler.getSpellFlatMod(game::GameHandler::SpellModOp::Cost);
-            int32_t pctCost  = gameHandler.getSpellPctMod(game::GameHandler::SpellModOp::Cost);
-            uint32_t displayCost = static_cast<uint32_t>(
-                game::GameHandler::applySpellMod(static_cast<int32_t>(info->manaCost), flatCost, pctCost));
-            std::snprintf(costBuf, sizeof(costBuf), "%u %s", displayCost, powerName);
-        }
-
-        // Right: cast time (with talent CastingTime modifier applied)
-        char castBuf[32] = "";
-        if (info->castTimeMs == 0) {
-            std::snprintf(castBuf, sizeof(castBuf), "Instant cast");
-        } else {
-            // Apply SpellModOp::CastingTime (10) modifiers
-            int32_t flatCT = gameHandler.getSpellFlatMod(game::GameHandler::SpellModOp::CastingTime);
-            int32_t pctCT  = gameHandler.getSpellPctMod(game::GameHandler::SpellModOp::CastingTime);
-            int32_t modCT  = game::GameHandler::applySpellMod(
-                static_cast<int32_t>(info->castTimeMs), flatCT, pctCT);
-            float secs = static_cast<float>(modCT) / 1000.0f;
-            std::snprintf(castBuf, sizeof(castBuf), "%.1f sec cast", secs > 0.0f ? secs : 0.0f);
-        }
-
-        if (costBuf[0] || castBuf[0]) {
-            float wrapW = 320.0f;
-            if (costBuf[0] && castBuf[0]) {
-                float castW = ImGui::CalcTextSize(castBuf).x;
-                ImGui::Text("%s", costBuf);
-                ImGui::SameLine(wrapW - castW);
-                ImGui::Text("%s", castBuf);
-            } else if (castBuf[0]) {
-                ImGui::Text("%s", castBuf);
-            } else {
-                ImGui::Text("%s", costBuf);
-            }
-        }
-
-        // Range
-        if (info->rangeIndex > 0) {
-            char rangeBuf[32];
-            if (info->rangeIndex <= 5)
-                std::snprintf(rangeBuf, sizeof(rangeBuf), "Melee range");
-            else
-                std::snprintf(rangeBuf, sizeof(rangeBuf), "%u yd range", info->rangeIndex);
-            ImGui::Text("%s", rangeBuf);
-        }
-    }
-
     // Cooldown if active
     float cd = gameHandler.getSpellCooldown(info->spellId);
     if (cd > 0.0f) {
-        ImGui::TextColored(ui::colors::kRed, "Cooldown: %.1fs", cd);
+        ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f), "Cooldown: %.1fs", cd);
     }
 
     // Description
@@ -599,11 +375,11 @@ void SpellbookScreen::renderSpellTooltip(const SpellInfo* info, game::GameHandle
         ImGui::TextWrapped("%s", info->description.c_str());
     }
 
-    // Usage hints — only shown when browsing the spellbook, not on action bar hover
-    if (!info->isPassive() && showUsageHints) {
+    // Usage hints
+    if (!info->isPassive()) {
         ImGui::Spacing();
-        ImGui::TextColored(ui::colors::kBrightGreen, "Drag to action bar");
-        ImGui::TextColored(ui::colors::kBrightGreen, "Double-click to cast");
+        ImGui::TextColored(ImVec4(0.3f, 1.0f, 0.3f, 1.0f), "Drag to action bar");
+        ImGui::TextColored(ImVec4(0.3f, 1.0f, 0.3f, 1.0f), "Double-click to cast");
     }
 
     ImGui::PopTextWrapPos();
@@ -611,14 +387,13 @@ void SpellbookScreen::renderSpellTooltip(const SpellInfo* info, game::GameHandle
 }
 
 void SpellbookScreen::render(game::GameHandler& gameHandler, pipeline::AssetManager* assetManager) {
-    // Spellbook toggle via keybinding (edge-triggered)
-    // Customizable key (default: P) from KeybindingManager
-    bool spellbookDown = KeybindingManager::getInstance().isActionPressed(
-        KeybindingManager::Action::TOGGLE_SPELLBOOK, false);
-    if (spellbookDown && !pKeyWasDown) {
+    // P key toggle (edge-triggered)
+    bool wantsTextInput = ImGui::GetIO().WantTextInput;
+    bool pDown = !wantsTextInput && core::Input::getInstance().isKeyPressed(SDL_SCANCODE_P);
+    if (pDown && !pKeyWasDown) {
         open = !open;
     }
-    pKeyWasDown = spellbookDown;
+    pKeyWasDown = pDown;
 
     if (!open) return;
 
@@ -704,49 +479,9 @@ void SpellbookScreen::render(game::GameHandler& gameHandler, pipeline::AssetMana
 
                         // Row selectable
                         ImGui::Selectable("##row", false,
-                            ImGuiSelectableFlags_AllowDoubleClick | ImGuiSelectableFlags_DontClosePopups,
-                            ImVec2(0, rowHeight));
+                            ImGuiSelectableFlags_AllowDoubleClick, ImVec2(0, rowHeight));
                         bool rowHovered = ImGui::IsItemHovered();
                         bool rowClicked = ImGui::IsItemClicked(0);
-
-                        // Right-click context menu
-                        if (ImGui::BeginPopupContextItem("##SpellCtx")) {
-                            ImGui::TextDisabled("%s", info->name.c_str());
-                            if (!info->rank.empty()) {
-                                ImGui::SameLine();
-                                ImGui::TextDisabled("(%s)", info->rank.c_str());
-                            }
-                            ImGui::Separator();
-                            if (!isPassive) {
-                                if (onCooldown) ImGui::BeginDisabled();
-                                if (ImGui::MenuItem("Cast")) {
-                                    uint64_t tgt = gameHandler.hasTarget() ? gameHandler.getTargetGuid() : 0;
-                                    gameHandler.castSpell(info->spellId, tgt);
-                                }
-                                if (onCooldown) ImGui::EndDisabled();
-                            }
-                            if (!isPassive) {
-                                if (ImGui::MenuItem("Add to Action Bar")) {
-                                    const auto& bar = gameHandler.getActionBar();
-                                    int firstEmpty = -1;
-                                    for (int si = 0; si < game::GameHandler::SLOTS_PER_BAR; ++si) {
-                                        if (bar[si].isEmpty()) { firstEmpty = si; break; }
-                                    }
-                                    if (firstEmpty >= 0) {
-                                        gameHandler.setActionBarSlot(firstEmpty,
-                                            game::ActionBarSlot::SPELL, info->spellId);
-                                    }
-                                }
-                            }
-                            if (ImGui::MenuItem("Copy Spell Link")) {
-                                char linkBuf[256];
-                                snprintf(linkBuf, sizeof(linkBuf),
-                                    "|cffffd000|Hspell:%u|h[%s]|h|r",
-                                    info->spellId, info->name.c_str());
-                                pendingChatSpellLink_ = linkBuf;
-                            }
-                            ImGui::EndPopup();
-                        }
                         ImVec2 rMin = ImGui::GetItemRectMin();
                         ImVec2 rMax = ImGui::GetItemRectMax();
                         auto* dl = ImGui::GetWindowDrawList();
@@ -835,25 +570,15 @@ void SpellbookScreen::render(game::GameHandler& gameHandler, pipeline::AssetMana
 
                         // Interaction
                         if (rowHovered) {
-                            // Shift-click to insert spell link into chat
-                            if (rowClicked && ImGui::GetIO().KeyShift && !info->name.empty()) {
-                                // WoW spell link format: |cffffd000|Hspell:<spellId>|h[Name]|h|r
-                                char linkBuf[256];
-                                snprintf(linkBuf, sizeof(linkBuf),
-                                    "|cffffd000|Hspell:%u|h[%s]|h|r",
-                                    info->spellId, info->name.c_str());
-                                pendingChatSpellLink_ = linkBuf;
-                            }
-                            // Start drag on click (not passive, not shift-click)
-                            else if (rowClicked && !isPassive && !ImGui::GetIO().KeyShift) {
+                            // Start drag on click (not passive)
+                            if (rowClicked && !isPassive) {
                                 draggingSpell_ = true;
                                 dragSpellId_ = info->spellId;
                                 dragSpellIconTex_ = iconTex;
                             }
 
                             // Double-click to cast
-                            if (ImGui::IsMouseDoubleClicked(0) && !isPassive && !onCooldown
-                                && !ImGui::GetIO().KeyShift) {
+                            if (ImGui::IsMouseDoubleClicked(0) && !isPassive && !onCooldown) {
                                 draggingSpell_ = false;
                                 dragSpellId_ = 0;
                                 dragSpellIconTex_ = VK_NULL_HANDLE;
diff --git a/src/ui/talent_screen.cpp b/src/ui/talent_screen.cpp
index 3afc6fd9..eeff7c41 100644
--- a/src/ui/talent_screen.cpp
+++ b/src/ui/talent_screen.cpp
@@ -1,6 +1,4 @@
 #include "ui/talent_screen.hpp"
-#include "ui/ui_colors.hpp"
-#include "ui/keybinding_manager.hpp"
 #include "core/input.hpp"
 #include "core/application.hpp"
 #include "core/logger.hpp"
@@ -13,15 +11,24 @@
 
 namespace wowee { namespace ui {
 
+// WoW class names indexed by class ID (1-11)
+static const char* classNames[] = {
+    "Unknown", "Warrior", "Paladin", "Hunter", "Rogue", "Priest",
+    "Death Knight", "Shaman", "Mage", "Warlock", "Unknown", "Druid"
+};
+
+static const char* getClassName(uint8_t classId) {
+    return (classId >= 1 && classId <= 11) ? classNames[classId] : "Unknown";
+}
+
 void TalentScreen::render(game::GameHandler& gameHandler) {
-    // Talents toggle via keybinding (edge-triggered)
-    // Customizable key (default: N) from KeybindingManager
-    bool talentsDown = KeybindingManager::getInstance().isActionPressed(
-        KeybindingManager::Action::TOGGLE_TALENTS, false);
-    if (talentsDown && !nKeyWasDown) {
+    // N key toggle (edge-triggered)
+    bool wantsTextInput = ImGui::GetIO().WantTextInput;
+    bool nDown = !wantsTextInput && core::Input::getInstance().isKeyPressed(SDL_SCANCODE_N);
+    if (nDown && !nKeyWasDown) {
         open = !open;
     }
-    nKeyWasDown = talentsDown;
+    nKeyWasDown = nDown;
 
     if (!open) return;
 
@@ -41,7 +48,7 @@ void TalentScreen::render(game::GameHandler& gameHandler) {
     uint8_t playerClass = gameHandler.getPlayerClass();
     std::string title = "Talents";
     if (playerClass > 0) {
-        title = std::string(game::getClassName(static_cast<game::Class>(playerClass))) + " Talents";
+        title = std::string(getClassName(playerClass)) + " Talents";
     }
 
     bool windowOpen = open;
@@ -67,7 +74,6 @@ void TalentScreen::renderTalentTrees(game::GameHandler& gameHandler) {
         gameHandler.loadTalentDbc();
         loadSpellDBC(assetManager);
         loadSpellIconDBC(assetManager);
-        loadGlyphPropertiesDBC(assetManager);
     }
 
     uint8_t playerClass = gameHandler.getPlayerClass();
@@ -76,9 +82,7 @@ void TalentScreen::renderTalentTrees(game::GameHandler& gameHandler) {
         return;
     }
 
-    // Get talent tabs for this class, sorted by orderIndex.
-    // WoW class IDs are 1-indexed (Warrior=1..Druid=11); convert to bitmask for
-    // TalentTab.classMask matching (Warrior=0x1, Paladin=0x2, Hunter=0x4, etc.)
+    // Get talent tabs for this class, sorted by orderIndex
     uint32_t classMask = 1u << (playerClass - 1);
     std::vector<const game::GameHandler::TalentTabEntry*> classTabs;
     for (const auto& [tabId, tab] : gameHandler.getAllTalentTabs()) {
@@ -134,10 +138,10 @@ void TalentScreen::renderTalentTrees(game::GameHandler& gameHandler) {
     // Unspent points
     ImGui::SameLine(0, 20);
     if (unspent > 0) {
-        ImGui::TextColored(ui::colors::kBrightGreen, "%u point%s available",
+        ImGui::TextColored(ImVec4(0.3f, 1.0f, 0.3f, 1.0f), "%u point%s available",
                           unspent, unspent > 1 ? "s" : "");
     } else {
-        ImGui::TextColored(ui::colors::kDarkGray, "No points available");
+        ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "No points available");
     }
 
     ImGui::Separator();
@@ -155,43 +159,8 @@ void TalentScreen::renderTalentTrees(game::GameHandler& gameHandler) {
                 ImGui::EndTabItem();
             }
         }
-
-        // Glyphs tab (WotLK only — visible when any glyph slot is populated or DBC data loaded)
-        if (!glyphProperties_.empty() || [&]() {
-                const auto& g = gameHandler.getGlyphs();
-                for (auto id : g) if (id != 0) return true;
-                return false; }()) {
-            if (ImGui::BeginTabItem("Glyphs")) {
-                renderGlyphs(gameHandler);
-                ImGui::EndTabItem();
-            }
-        }
-
         ImGui::EndTabBar();
     }
-
-    // Talent learn confirmation popup
-    if (talentConfirmOpen_) {
-        ImGui::OpenPopup("Learn Talent?##talent_confirm");
-        talentConfirmOpen_ = false;
-    }
-    if (ImGui::BeginPopupModal("Learn Talent?##talent_confirm", nullptr,
-                               ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove)) {
-        ImGui::TextColored(ui::colors::kYellow, "%s", pendingTalentName_.c_str());
-        ImGui::Text("Rank %u", pendingTalentRank_ + 1);
-        ImGui::Spacing();
-        ImGui::TextWrapped("Spend a talent point?");
-        ImGui::Spacing();
-        if (ImGui::Button("Learn", ImVec2(80, 0))) {
-            gameHandler.learnTalent(pendingTalentId_, pendingTalentRank_);
-            ImGui::CloseCurrentPopup();
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Cancel", ImVec2(80, 0))) {
-            ImGui::CloseCurrentPopup();
-        }
-        ImGui::EndPopup();
-    }
 }
 
 void TalentScreen::renderTalentTree(game::GameHandler& gameHandler, uint32_t tabId,
@@ -217,23 +186,20 @@ void TalentScreen::renderTalentTree(game::GameHandler& gameHandler, uint32_t tab
         return a->column < b->column;
     });
 
-    // Find grid dimensions — use int to avoid uint8_t wrap-around infinite loops
-    int maxRow = 0, maxCol = 0;
+    // Find grid dimensions
+    uint8_t maxRow = 0, maxCol = 0;
     for (const auto* talent : talents) {
-        maxRow = std::max(maxRow, static_cast<int>(talent->row));
-        maxCol = std::max(maxCol, static_cast<int>(talent->column));
+        maxRow = std::max(maxRow, talent->row);
+        maxCol = std::max(maxCol, talent->column);
     }
-    // Sanity-cap to prevent runaway loops from corrupt/unexpected DBC data
-    maxRow = std::min(maxRow, 15);
-    maxCol = std::min(maxCol, 15);
     // WoW talent grids are always 4 columns wide
     if (maxCol < 3) maxCol = 3;
 
     const float iconSize = 40.0f;
     const float spacing = 8.0f;
     const float cellSize = iconSize + spacing;
-    const float gridWidth = static_cast<float>(maxCol + 1) * cellSize + spacing;
-    const float gridHeight = static_cast<float>(maxRow + 1) * cellSize + spacing;
+    const float gridWidth = (maxCol + 1) * cellSize + spacing;
+    const float gridHeight = (maxRow + 1) * cellSize + spacing;
 
     // Points in this tree
     uint32_t pointsInTree = 0;
@@ -248,9 +214,7 @@ void TalentScreen::renderTalentTree(game::GameHandler& gameHandler, uint32_t tab
     float availW = ImGui::GetContentRegionAvail().x;
     float offsetX = std::max(0.0f, (availW - gridWidth) * 0.5f);
 
-    char childId[32];
-    snprintf(childId, sizeof(childId), "TalentGrid_%u", tabId);
-    ImGui::BeginChild(childId, ImVec2(0, 0), false);
+    ImGui::BeginChild("TalentGrid", ImVec2(0, 0), false);
 
     ImVec2 gridOrigin = ImGui::GetCursorScreenPos();
     gridOrigin.x += offsetX;
@@ -262,9 +226,9 @@ void TalentScreen::renderTalentTree(game::GameHandler& gameHandler, uint32_t tab
         if (bgIt != bgTextureCache_.end()) {
             bgTex = bgIt->second;
         } else {
-            // Only load the background if icon uploads aren't saturating this frame.
-            // Background is cosmetic; skip if we're already loading icons this frame.
+            // Try to load the background texture
             std::string bgPath = bgFile;
+            // Normalize path separators
             for (auto& c : bgPath) { if (c == '\\') c = '/'; }
             bgPath += ".blp";
             auto blpData = assetManager->readFile(bgPath);
@@ -278,7 +242,6 @@ void TalentScreen::renderTalentTree(game::GameHandler& gameHandler, uint32_t tab
                     }
                 }
             }
-            // Cache even if null to avoid retrying every frame on missing files
             bgTextureCache_[tabId] = bgTex;
         }
 
@@ -319,7 +282,7 @@ void TalentScreen::renderTalentTree(game::GameHandler& gameHandler, uint32_t tab
             if (fromIt == talentPositions.end() || toIt == talentPositions.end()) continue;
 
             uint8_t prereqRank = gameHandler.getTalentRank(talent->prereqTalent[i]);
-            bool met = prereqRank > talent->prereqRank[i]; // storage 1-indexed, DBC 0-indexed
+            bool met = prereqRank >= talent->prereqRank[i];
             ImU32 lineCol = met ? IM_COL32(100, 220, 100, 200) : IM_COL32(120, 120, 120, 150);
 
             ImVec2 from = fromIt->second.center;
@@ -341,8 +304,8 @@ void TalentScreen::renderTalentTree(game::GameHandler& gameHandler, uint32_t tab
     }
 
     // Render talent icons
-    for (int row = 0; row <= maxRow; ++row) {
-        for (int col = 0; col <= maxCol; ++col) {
+    for (uint8_t row = 0; row <= maxRow; ++row) {
+        for (uint8_t col = 0; col <= maxCol; ++col) {
             const game::GameHandler::TalentEntry* talent = nullptr;
             for (const auto* t : talents) {
                 if (t->row == row && t->column == col) {
@@ -360,9 +323,8 @@ void TalentScreen::renderTalentTree(game::GameHandler& gameHandler, uint32_t tab
                 renderTalent(gameHandler, *talent, pointsInTree);
             } else {
                 // Empty cell — invisible placeholder
-                char emptyId[32];
-                snprintf(emptyId, sizeof(emptyId), "e_%u_%u_%u", tabId, row, col);
-                ImGui::InvisibleButton(emptyId, ImVec2(iconSize, iconSize));
+                ImGui::InvisibleButton(("e_" + std::to_string(row) + "_" + std::to_string(col)).c_str(),
+                                       ImVec2(iconSize, iconSize));
             }
         }
     }
@@ -390,7 +352,7 @@ void TalentScreen::renderTalent(game::GameHandler& gameHandler,
     for (int i = 0; i < 3; ++i) {
         if (talent.prereqTalent[i] != 0) {
             uint8_t prereqRank = gameHandler.getTalentRank(talent.prereqTalent[i]);
-            if (prereqRank <= talent.prereqRank[i]) { // storage 1-indexed, DBC 0-indexed
+            if (prereqRank < talent.prereqRank[i]) {
                 prereqsMet = false;
                 canLearn = false;
                 break;
@@ -423,9 +385,9 @@ void TalentScreen::renderTalent(game::GameHandler& gameHandler,
     ImVec4 borderColor;
     ImVec4 tint;
     switch (state) {
-        case MAXED:    borderColor = ImVec4(0.2f, 0.9f, 0.2f, 1.0f); tint = ui::colors::kWhite; break;
-        case PARTIAL:  borderColor = ui::colors::kHealthGreen; tint = ui::colors::kWhite; break;
-        case AVAILABLE:borderColor = ImVec4(1.0f, 1.0f, 1.0f, 0.8f); tint = ui::colors::kWhite; break;
+        case MAXED:    borderColor = ImVec4(0.2f, 0.9f, 0.2f, 1.0f); tint = ImVec4(1,1,1,1); break;
+        case PARTIAL:  borderColor = ImVec4(0.2f, 0.8f, 0.2f, 1.0f); tint = ImVec4(1,1,1,1); break;
+        case AVAILABLE:borderColor = ImVec4(1.0f, 1.0f, 1.0f, 0.8f); tint = ImVec4(1,1,1,1); break;
         case LOCKED:   borderColor = ImVec4(0.4f, 0.4f, 0.4f, 0.8f); tint = ImVec4(0.4f,0.4f,0.4f,1); break;
     }
 
@@ -516,16 +478,16 @@ void TalentScreen::renderTalent(game::GameHandler& gameHandler,
         // Spell name
         const std::string& spellName = gameHandler.getSpellName(spellId);
         if (!spellName.empty()) {
-            ImGui::TextColored(ui::colors::kYellow, "%s", spellName.c_str());
+            ImGui::TextColored(ImVec4(1.0f, 1.0f, 0.3f, 1.0f), "%s", spellName.c_str());
         } else {
-            ImGui::TextColored(ui::colors::kYellow, "Talent #%u", talent.talentId);
+            ImGui::TextColored(ImVec4(1.0f, 1.0f, 0.3f, 1.0f), "Talent #%u", talent.talentId);
         }
 
         // Rank display
         ImVec4 rankColor;
         switch (state) {
-            case MAXED:   rankColor = ui::colors::kQueueGreen; break;
-            case PARTIAL: rankColor = ui::colors::kQueueGreen; break;
+            case MAXED:   rankColor = ImVec4(0.3f, 0.9f, 0.3f, 1); break;
+            case PARTIAL: rankColor = ImVec4(0.3f, 0.9f, 0.3f, 1); break;
             default:      rankColor = ImVec4(0.7f, 0.7f, 0.7f, 1); break;
         }
         ImGui::TextColored(rankColor, "Rank %u/%u", currentRank, talent.maxRank);
@@ -535,7 +497,7 @@ void TalentScreen::renderTalent(game::GameHandler& gameHandler,
             auto tooltipIt = spellTooltips.find(talent.rankSpells[currentRank - 1]);
             if (tooltipIt != spellTooltips.end() && !tooltipIt->second.empty()) {
                 ImGui::Spacing();
-                ImGui::TextColored(ui::colors::kTooltipGold, "Current:");
+                ImGui::TextColored(ImVec4(1.0f, 0.82f, 0.0f, 1.0f), "Current:");
                 ImGui::TextWrapped("%s", tooltipIt->second.c_str());
             }
         }
@@ -545,7 +507,7 @@ void TalentScreen::renderTalent(game::GameHandler& gameHandler,
             auto tooltipIt = spellTooltips.find(talent.rankSpells[currentRank]);
             if (tooltipIt != spellTooltips.end() && !tooltipIt->second.empty()) {
                 ImGui::Spacing();
-                ImGui::TextColored(ui::colors::kBrightGreen, "Next Rank:");
+                ImGui::TextColored(ImVec4(0.3f, 1.0f, 0.3f, 1.0f), "Next Rank:");
                 ImGui::TextWrapped("%s", tooltipIt->second.c_str());
             }
         }
@@ -557,15 +519,14 @@ void TalentScreen::renderTalent(game::GameHandler& gameHandler,
             if (!prereq || prereq->rankSpells[0] == 0) continue;
 
             uint8_t prereqCurrentRank = gameHandler.getTalentRank(talent.prereqTalent[i]);
-            bool met = prereqCurrentRank > talent.prereqRank[i]; // storage 1-indexed, DBC 0-indexed
-            ImVec4 pColor = met ? ui::colors::kQueueGreen : ui::colors::kRed;
+            bool met = prereqCurrentRank >= talent.prereqRank[i];
+            ImVec4 pColor = met ? ImVec4(0.3f, 0.9f, 0.3f, 1) : ImVec4(1.0f, 0.3f, 0.3f, 1);
 
             const std::string& prereqName = gameHandler.getSpellName(prereq->rankSpells[0]);
             ImGui::Spacing();
-            const uint8_t reqRankDisplay = talent.prereqRank[i] + 1u; // DBC 0-indexed → display 1-indexed
             ImGui::TextColored(pColor, "Requires %u point%s in %s",
-                reqRankDisplay,
-                reqRankDisplay > 1 ? "s" : "",
+                talent.prereqRank[i],
+                talent.prereqRank[i] > 1 ? "s" : "",
                 prereqName.empty() ? "prerequisite" : prereqName.c_str());
         }
 
@@ -574,7 +535,7 @@ void TalentScreen::renderTalent(game::GameHandler& gameHandler,
             uint32_t requiredPoints = talent.row * 5;
             if (pointsInTree < requiredPoints) {
                 ImGui::Spacing();
-                ImGui::TextColored(ui::colors::kRed,
+                ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f),
                     "Requires %u points in this tree (%u/%u)",
                     requiredPoints, pointsInTree, requiredPoints);
             }
@@ -583,22 +544,23 @@ void TalentScreen::renderTalent(game::GameHandler& gameHandler,
         // Action hint
         if (canLearn && prereqsMet) {
             ImGui::Spacing();
-            ImGui::TextColored(ui::colors::kBrightGreen, "Click to learn");
+            ImGui::TextColored(ImVec4(0.3f, 1.0f, 0.3f, 1.0f), "Click to learn");
         }
 
         ImGui::PopTextWrapPos();
         ImGui::EndTooltip();
     }
 
-    // Handle click — open confirmation dialog instead of learning directly
+    // Handle click
     if (clicked && canLearn && prereqsMet) {
-        talentConfirmOpen_ = true;
-        pendingTalentId_ = talent.talentId;
-        pendingTalentRank_ = currentRank;
-        uint32_t nextSpell = (currentRank < 5) ? talent.rankSpells[currentRank] : 0;
-        pendingTalentName_ = nextSpell ? gameHandler.getSpellName(nextSpell) : "";
-        if (pendingTalentName_.empty())
-            pendingTalentName_ = spellId ? gameHandler.getSpellName(spellId) : "Talent";
+        const auto& learned = gameHandler.getLearnedTalents();
+        uint8_t desiredRank;
+        if (learned.find(talent.talentId) == learned.end()) {
+            desiredRank = 0;  // First rank (0-indexed on wire)
+        } else {
+            desiredRank = currentRank;  // currentRank is already the next 0-indexed rank to learn
+        }
+        gameHandler.learnTalent(talent.talentId, desiredRank);
     }
 
     ImGui::PopID();
@@ -614,27 +576,15 @@ void TalentScreen::loadSpellDBC(pipeline::AssetManager* assetManager) {
     if (!dbc || !dbc->isLoaded()) return;
 
     const auto* spellL = pipeline::getActiveDBCLayout() ? pipeline::getActiveDBCLayout()->getLayout("Spell") : nullptr;
-    uint32_t fieldCount = dbc->getFieldCount();
-    // Detect DBC/layout mismatch: Classic layout expects ~173 fields but we may
-    // load the WotLK base DBC (234 fields).  Use WotLK field indices in that case.
-    uint32_t idField = 0, iconField = 133, tooltipField = 139;
-    if (spellL) {
-        uint32_t layoutIcon = (*spellL)["IconID"];
-        if (layoutIcon < fieldCount && fieldCount <= layoutIcon + 20) {
-            idField = (*spellL)["ID"];
-            iconField = layoutIcon;
-            try { tooltipField = (*spellL)["Tooltip"]; } catch (...) {}
-        }
-    }
     uint32_t count = dbc->getRecordCount();
     for (uint32_t i = 0; i < count; ++i) {
-        uint32_t spellId = dbc->getUInt32(i, idField);
+        uint32_t spellId = dbc->getUInt32(i, spellL ? (*spellL)["ID"] : 0);
         if (spellId == 0) continue;
 
-        uint32_t iconId = dbc->getUInt32(i, iconField);
+        uint32_t iconId = dbc->getUInt32(i, spellL ? (*spellL)["IconID"] : 133);
         spellIconIds[spellId] = iconId;
 
-        std::string tooltip = dbc->getString(i, tooltipField);
+        std::string tooltip = dbc->getString(i, spellL ? (*spellL)["Tooltip"] : 139);
         if (!tooltip.empty()) {
             spellTooltips[spellId] = tooltip;
         }
@@ -660,116 +610,12 @@ void TalentScreen::loadSpellIconDBC(pipeline::AssetManager* assetManager) {
     }
 }
 
-void TalentScreen::loadGlyphPropertiesDBC(pipeline::AssetManager* assetManager) {
-    if (glyphDbcLoaded) return;
-    glyphDbcLoaded = true;
-
-    if (!assetManager || !assetManager->isInitialized()) return;
-
-    auto dbc = assetManager->loadDBC("GlyphProperties.dbc");
-    if (!dbc || !dbc->isLoaded()) return;
-
-    // GlyphProperties.dbc: field 0=ID, field 1=SpellID, field 2=GlyphSlotFlags (1=minor), field 3=SpellIconID
-    for (uint32_t i = 0; i < dbc->getRecordCount(); i++) {
-        uint32_t id      = dbc->getUInt32(i, 0);
-        uint32_t spellId = dbc->getUInt32(i, 1);
-        uint32_t flags   = dbc->getUInt32(i, 2);
-        if (id == 0) continue;
-        GlyphInfo info;
-        info.spellId = spellId;
-        info.isMajor = (flags == 0);  // flag 0 = major, flag 1 = minor
-        glyphProperties_[id] = info;
-    }
-}
-
-void TalentScreen::renderGlyphs(game::GameHandler& gameHandler) {
-    auto* assetManager = core::Application::getInstance().getAssetManager();
-    const auto& glyphs = gameHandler.getGlyphs();
-
-    ImGui::Spacing();
-    ImGui::TextColored(ui::colors::kBrightGold, "Major Glyphs");
-    ImGui::Separator();
-
-    // WotLK: 6 glyph slots total. Slots 0,2,4 are major by convention from the server,
-    // but we check GlyphProperties.dbc flags when available.
-    // Display all 6 slots grouped: show major (non-minor) first, then minor.
-    std::vector<std::pair<int, bool>> majorSlots, minorSlots;
-    for (int i = 0; i < game::GameHandler::MAX_GLYPH_SLOTS; i++) {
-        uint16_t glyphId = glyphs[i];
-        bool isMajor = true;
-        if (glyphId != 0) {
-            auto git = glyphProperties_.find(glyphId);
-            if (git != glyphProperties_.end()) isMajor = git->second.isMajor;
-            else isMajor = (i % 2 == 0);  // fallback: even slots = major
-        } else {
-            isMajor = (i % 2 == 0);  // empty slots follow same pattern
-        }
-        if (isMajor) majorSlots.push_back({i, true});
-        else         minorSlots.push_back({i, false});
-    }
-
-    auto renderGlyphSlot = [&](int slotIdx) {
-        uint16_t glyphId = glyphs[slotIdx];
-        char label[64];
-        if (glyphId == 0) {
-            snprintf(label, sizeof(label), "Slot %d  [Empty]", slotIdx + 1);
-            ImGui::TextDisabled("%s", label);
-            return;
-        }
-
-        uint32_t spellId = 0;
-        uint32_t iconId  = 0;
-        auto git = glyphProperties_.find(glyphId);
-        if (git != glyphProperties_.end()) {
-            spellId = git->second.spellId;
-            auto iit = spellIconIds.find(spellId);
-            if (iit != spellIconIds.end()) iconId = iit->second;
-        }
-
-        // Icon (24x24)
-        VkDescriptorSet icon = getSpellIcon(iconId, assetManager);
-        if (icon != VK_NULL_HANDLE) {
-            ImGui::Image((ImTextureID)(uintptr_t)icon, ImVec2(24, 24));
-            ImGui::SameLine(0, 6);
-        } else {
-            ImGui::Dummy(ImVec2(24, 24));
-            ImGui::SameLine(0, 6);
-        }
-
-        // Spell name
-        const std::string& name = spellId ? gameHandler.getSpellName(spellId) : "";
-        if (!name.empty()) {
-            ImGui::TextColored(ImVec4(0.9f, 0.9f, 0.9f, 1.0f), "%s", name.c_str());
-        } else {
-            ImGui::TextColored(ui::colors::kLightGray, "Glyph #%u", static_cast<uint32_t>(glyphId));
-        }
-    };
-
-    for (auto& [idx, major] : majorSlots) renderGlyphSlot(idx);
-
-    ImGui::Spacing();
-    ImGui::TextColored(ImVec4(0.6f, 0.8f, 1.0f, 1.0f), "Minor Glyphs");
-    ImGui::Separator();
-    for (auto& [idx, major] : minorSlots) renderGlyphSlot(idx);
-}
-
 VkDescriptorSet TalentScreen::getSpellIcon(uint32_t iconId, pipeline::AssetManager* assetManager) {
     if (iconId == 0 || !assetManager) return VK_NULL_HANDLE;
 
     auto cit = spellIconCache.find(iconId);
     if (cit != spellIconCache.end()) return cit->second;
 
-    // Rate-limit texture uploads to avoid multi-hundred-ms stalls when switching
-    // to a tab whose icons are not yet cached (each upload is a blocking GPU op).
-    // Allow at most 4 new icon loads per frame; the rest show a blank icon and
-    // load on the next frame, spreading the cost across ~5 frames.
-    static int loadsThisFrame = 0;
-    static int lastImGuiFrame = -1;
-    int curFrame = ImGui::GetFrameCount();
-    if (curFrame != lastImGuiFrame) { loadsThisFrame = 0; lastImGuiFrame = curFrame; }
-    if (loadsThisFrame >= 4) return VK_NULL_HANDLE;  // defer, don't cache null
-    ++loadsThisFrame;
-
     auto pit = spellIconPaths.find(iconId);
     if (pit == spellIconPaths.end()) {
         spellIconCache[iconId] = VK_NULL_HANDLE;
diff --git a/src/ui/toast_manager.cpp b/src/ui/toast_manager.cpp
deleted file mode 100644
index 957f5e2a..00000000
--- a/src/ui/toast_manager.cpp
+++ /dev/null
@@ -1,1253 +0,0 @@
-#include "ui/toast_manager.hpp"
-#include "game/game_handler.hpp"
-#include "core/application.hpp"
-#include "rendering/renderer.hpp"
-#include "audio/audio_coordinator.hpp"
-#include "audio/ui_sound_manager.hpp"
-
-#include <imgui.h>
-#include <algorithm>
-#include <cstdio>
-#include <cmath>
-
-namespace wowee { namespace ui {
-
-// ---------------------------------------------------------------------------
-// Setup toast callbacks on GameHandler (idempotent — safe to call every frame)
-// ---------------------------------------------------------------------------
-void ToastManager::setupCallbacks(game::GameHandler& gameHandler) {
-    // NOTE: Level-up and achievement callbacks are registered by Application
-    // (which also triggers the 3D level-up effect).  Application routes to
-    // triggerDing() / triggerAchievementToast() via the public API.
-
-    // Area discovery toast callback
-    if (!areaDiscoveryCallbackSet_) {
-        gameHandler.setAreaDiscoveryCallback([this](const std::string& areaName, uint32_t xpGained) {
-            discoveryToastName_ = areaName.empty() ? "New Area" : areaName;
-            discoveryToastXP_   = xpGained;
-            discoveryToastTimer_ = DISCOVERY_TOAST_DURATION;
-        });
-        areaDiscoveryCallbackSet_ = true;
-    }
-
-    // Quest objective progress toast callback
-    if (!questProgressCallbackSet_) {
-        gameHandler.setQuestProgressCallback([this](const std::string& questTitle,
-                                                    const std::string& objectiveName,
-                                                    uint32_t current, uint32_t required) {
-            for (auto& t : questToasts_) {
-                if (t.questTitle == questTitle && t.objectiveName == objectiveName) {
-                    t.current  = current;
-                    t.required = required;
-                    t.age      = 0.0f;
-                    return;
-                }
-            }
-            if (questToasts_.size() >= 4) questToasts_.erase(questToasts_.begin());
-            questToasts_.push_back({questTitle, objectiveName, current, required, 0.0f});
-        });
-        questProgressCallbackSet_ = true;
-    }
-
-    // Other-player level-up toast callback
-    if (!otherPlayerLevelUpCallbackSet_) {
-        gameHandler.setOtherPlayerLevelUpCallback([this](uint64_t guid, uint32_t newLevel) {
-            for (auto& t : playerLevelUpToasts_) {
-                if (t.guid == guid) {
-                    t.newLevel = newLevel;
-                    t.age = 0.0f;
-                    return;
-                }
-            }
-            if (playerLevelUpToasts_.size() >= 3)
-                playerLevelUpToasts_.erase(playerLevelUpToasts_.begin());
-            playerLevelUpToasts_.push_back({guid, "", newLevel, 0.0f});
-        });
-        otherPlayerLevelUpCallbackSet_ = true;
-    }
-
-    // PvP honor credit toast callback
-    if (!pvpHonorCallbackSet_) {
-        gameHandler.setPvpHonorCallback([this](uint32_t honor, uint64_t /*victimGuid*/, uint32_t rank) {
-            if (honor == 0) return;
-            pvpHonorToasts_.push_back({honor, rank, 0.0f});
-            if (pvpHonorToasts_.size() > 4)
-                pvpHonorToasts_.erase(pvpHonorToasts_.begin());
-        });
-        pvpHonorCallbackSet_ = true;
-    }
-
-    // Item loot toast callback
-    if (!itemLootCallbackSet_) {
-        gameHandler.setItemLootCallback([this](uint32_t itemId, uint32_t count,
-                                               uint32_t quality, const std::string& name) {
-            for (auto& t : itemLootToasts_) {
-                if (t.itemId == itemId) {
-                    t.count += count;
-                    t.age = 0.0f;
-                    return;
-                }
-            }
-            if (itemLootToasts_.size() >= 5)
-                itemLootToasts_.erase(itemLootToasts_.begin());
-            itemLootToasts_.push_back({itemId, count, quality, name, 0.0f});
-        });
-        itemLootCallbackSet_ = true;
-    }
-
-    // Ghost-state callback to flash "You have been resurrected!" on revival
-    if (!ghostStateCallbackSet_) {
-        gameHandler.setGhostStateCallback([this](bool isGhost) {
-            if (!isGhost) {
-                resurrectFlashTimer_ = kResurrectFlashDuration;
-            }
-        });
-        ghostStateCallbackSet_ = true;
-    }
-
-    // Reputation change toast callback
-    if (!repChangeCallbackSet_) {
-        gameHandler.setRepChangeCallback([this](const std::string& name, int32_t delta, int32_t standing) {
-            repToasts_.push_back({name, delta, standing, 0.0f});
-            if (repToasts_.size() > 4) repToasts_.erase(repToasts_.begin());
-        });
-        repChangeCallbackSet_ = true;
-    }
-
-    // Quest completion toast callback
-    if (!questCompleteCallbackSet_) {
-        gameHandler.setQuestCompleteCallback([this](uint32_t id, const std::string& title) {
-            questCompleteToasts_.push_back({id, title, 0.0f});
-            if (questCompleteToasts_.size() > 3) questCompleteToasts_.erase(questCompleteToasts_.begin());
-        });
-        questCompleteCallbackSet_ = true;
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Render early toasts (before action bars)
-// ---------------------------------------------------------------------------
-void ToastManager::renderEarlyToasts(float deltaTime, game::GameHandler& gameHandler) {
-    // Zone entry detection — fire a toast when the renderer's zone name changes
-    if (auto* rend = services_.renderer) {
-        const std::string& curZone = rend->getCurrentZoneName();
-        if (!curZone.empty() && curZone != lastKnownZone_) {
-            if (!lastKnownZone_.empty()) {
-                zoneToasts_.push_back({curZone, 0.0f});
-                if (zoneToasts_.size() > 3)
-                    zoneToasts_.erase(zoneToasts_.begin());
-            }
-            lastKnownZone_ = curZone;
-        }
-    }
-
-    renderRepToasts(deltaTime);
-    renderQuestCompleteToasts(deltaTime);
-    renderZoneToasts(deltaTime);
-    renderAreaTriggerToasts(deltaTime, gameHandler);
-}
-
-// ---------------------------------------------------------------------------
-// Render late toasts (after escape menu / settings)
-// ---------------------------------------------------------------------------
-void ToastManager::renderLateToasts(game::GameHandler& gameHandler) {
-    renderDingEffect();
-    renderAchievementToast();
-    renderDiscoveryToast();
-    renderWhisperToasts();
-    renderQuestProgressToasts();
-    renderPlayerLevelUpToasts(gameHandler);
-    renderPvpHonorToasts();
-    renderItemLootToasts();
-    renderResurrectFlash();
-    renderZoneText(gameHandler);
-}
-
-// ============================================================
-// Reputation change toasts
-// ============================================================
-
-void ToastManager::renderRepToasts(float deltaTime) {
-    for (auto& e : repToasts_) e.age += deltaTime;
-    repToasts_.erase(
-        std::remove_if(repToasts_.begin(), repToasts_.end(),
-            [](const RepToastEntry& e) { return e.age >= kRepToastLifetime; }),
-        repToasts_.end());
-
-    if (repToasts_.empty()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    // Stack toasts in the lower-right corner (above the action bar), newest on top
-    const float toastW = 220.0f;
-    const float toastH = 26.0f;
-    const float padY   = 4.0f;
-    const float rightEdge = screenW - 14.0f;
-    const float baseY = screenH - 180.0f;
-
-    const int count = static_cast<int>(repToasts_.size());
-
-    ImDrawList* draw = ImGui::GetForegroundDrawList();
-    ImFont* font = ImGui::GetFont();
-    float fontSize = ImGui::GetFontSize();
-
-    // Compute standing tier label (Exalted, Revered, Honored, Friendly, Neutral, Unfriendly, Hostile, Hated)
-    auto standingLabel = [](int32_t s) -> const char* {
-        if (s >= 42000) return "Exalted";
-        if (s >= 21000) return "Revered";
-        if (s >= 9000)  return "Honored";
-        if (s >= 3000)  return "Friendly";
-        if (s >= 0)     return "Neutral";
-        if (s >= -3000) return "Unfriendly";
-        if (s >= -6000) return "Hostile";
-        return "Hated";
-    };
-
-    for (int i = 0; i < count; ++i) {
-        const auto& e = repToasts_[i];
-        // Slide in from right on appear, slide out at end
-        constexpr float kSlideDur = 0.3f;
-        float slideIn  = std::min(e.age, kSlideDur) / kSlideDur;
-        float slideOut = std::min(std::max(0.0f, kRepToastLifetime - e.age), kSlideDur) / kSlideDur;
-        float slide    = std::min(slideIn, slideOut);
-
-        float alpha = std::clamp(slide, 0.0f, 1.0f);
-        float xFull  = rightEdge - toastW;
-        float xStart = screenW + 10.0f;
-        float toastX = xStart + (xFull - xStart) * slide;
-        float toastY = baseY - i * (toastH + padY);
-
-        ImVec2 tl(toastX, toastY);
-        ImVec2 br(toastX + toastW, toastY + toastH);
-
-        // Background
-        draw->AddRectFilled(tl, br, IM_COL32(15, 15, 20, static_cast<int>(alpha * 200)), 4.0f);
-        // Border: green for gain, red for loss
-        ImU32 borderCol = (e.delta > 0)
-            ? IM_COL32(80, 200, 80, static_cast<int>(alpha * 220))
-            : IM_COL32(200, 60, 60, static_cast<int>(alpha * 220));
-        draw->AddRect(tl, br, borderCol, 4.0f, 0, 1.5f);
-
-        // Delta text: "+250" or "-250"
-        char deltaBuf[16];
-        snprintf(deltaBuf, sizeof(deltaBuf), "%+d", e.delta);
-        ImU32 deltaCol = (e.delta > 0) ? IM_COL32(80, 220, 80, static_cast<int>(alpha * 255))
-                                       : IM_COL32(220, 70, 70, static_cast<int>(alpha * 255));
-        draw->AddText(font, fontSize, ImVec2(tl.x + 6.0f, tl.y + (toastH - fontSize) * 0.5f),
-                      deltaCol, deltaBuf);
-
-        // Faction name + standing
-        char nameBuf[64];
-        snprintf(nameBuf, sizeof(nameBuf), "%s (%s)", e.factionName.c_str(), standingLabel(e.standing));
-        draw->AddText(font, fontSize * 0.85f, ImVec2(tl.x + 44.0f, tl.y + (toastH - fontSize * 0.85f) * 0.5f),
-                      IM_COL32(210, 210, 210, static_cast<int>(alpha * 220)), nameBuf);
-    }
-}
-
-void ToastManager::renderQuestCompleteToasts(float deltaTime) {
-    for (auto& e : questCompleteToasts_) e.age += deltaTime;
-    questCompleteToasts_.erase(
-        std::remove_if(questCompleteToasts_.begin(), questCompleteToasts_.end(),
-            [](const QuestCompleteToastEntry& e) { return e.age >= kQuestCompleteToastLifetime; }),
-        questCompleteToasts_.end());
-
-    if (questCompleteToasts_.empty()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    const float toastW = 260.0f;
-    const float toastH = 40.0f;
-    const float padY   = 4.0f;
-    const float baseY  = screenH - 220.0f;  // above rep toasts
-
-    ImDrawList* draw = ImGui::GetForegroundDrawList();
-    ImFont* font = ImGui::GetFont();
-    float fontSize = ImGui::GetFontSize();
-
-    for (int i = 0; i < static_cast<int>(questCompleteToasts_.size()); ++i) {
-        const auto& e = questCompleteToasts_[i];
-        constexpr float kSlideDur = 0.3f;
-        float slideIn  = std::min(e.age, kSlideDur) / kSlideDur;
-        float slideOut = std::min(std::max(0.0f, kQuestCompleteToastLifetime - e.age), kSlideDur) / kSlideDur;
-        float slide    = std::min(slideIn, slideOut);
-        float alpha    = std::clamp(slide, 0.0f, 1.0f);
-
-        float xFull  = screenW - 14.0f - toastW;
-        float xStart = screenW + 10.0f;
-        float toastX = xStart + (xFull - xStart) * slide;
-        float toastY = baseY - i * (toastH + padY);
-
-        ImVec2 tl(toastX, toastY);
-        ImVec2 br(toastX + toastW, toastY + toastH);
-
-        // Background + gold border (quest completion)
-        draw->AddRectFilled(tl, br, IM_COL32(20, 18, 8, static_cast<int>(alpha * 210)), 5.0f);
-        draw->AddRect(tl, br, IM_COL32(220, 180, 30, static_cast<int>(alpha * 230)), 5.0f, 0, 1.5f);
-
-        // Scroll icon placeholder (gold diamond)
-        float iconCx = tl.x + 18.0f;
-        float iconCy = tl.y + toastH * 0.5f;
-        draw->AddCircleFilled(ImVec2(iconCx, iconCy), 7.0f, IM_COL32(210, 170, 20, static_cast<int>(alpha * 230)));
-        draw->AddCircle      (ImVec2(iconCx, iconCy), 7.0f, IM_COL32(255, 220, 50, static_cast<int>(alpha * 200)));
-
-        // "Quest Complete" header in gold
-        const char* header = "Quest Complete";
-        draw->AddText(font, fontSize * 0.78f,
-                      ImVec2(tl.x + 34.0f, tl.y + 4.0f),
-                      IM_COL32(240, 200, 40, static_cast<int>(alpha * 240)), header);
-
-        // Quest title in off-white
-        const char* titleStr = e.title.empty() ? "Unknown Quest" : e.title.c_str();
-        draw->AddText(font, fontSize * 0.82f,
-                      ImVec2(tl.x + 34.0f, tl.y + toastH * 0.5f + 1.0f),
-                      IM_COL32(220, 215, 195, static_cast<int>(alpha * 220)), titleStr);
-    }
-}
-
-// ============================================================
-// Zone Entry Toast
-// ============================================================
-
-void ToastManager::renderZoneToasts(float deltaTime) {
-    for (auto& e : zoneToasts_) e.age += deltaTime;
-    zoneToasts_.erase(
-        std::remove_if(zoneToasts_.begin(), zoneToasts_.end(),
-            [](const ZoneToastEntry& e) { return e.age >= kZoneToastLifetime; }),
-        zoneToasts_.end());
-
-    // Suppress toasts while the zone text overlay is showing the same zone —
-    // avoids duplicate "Entering: Stormwind City" messages.
-    if (zoneTextTimer_ > 0.0f) {
-        zoneToasts_.erase(
-            std::remove_if(zoneToasts_.begin(), zoneToasts_.end(),
-                [this](const ZoneToastEntry& e) { return e.zoneName == zoneTextName_; }),
-            zoneToasts_.end());
-    }
-
-    if (zoneToasts_.empty()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-
-    ImDrawList* draw = ImGui::GetForegroundDrawList();
-    ImFont* font = ImGui::GetFont();
-
-    for (int i = 0; i < static_cast<int>(zoneToasts_.size()); ++i) {
-        const auto& e = zoneToasts_[i];
-        constexpr float kSlideDur = 0.35f;
-        float slideIn  = std::min(e.age, kSlideDur) / kSlideDur;
-        float slideOut = std::min(std::max(0.0f, kZoneToastLifetime - e.age), kSlideDur) / kSlideDur;
-        float slide    = std::min(slideIn, slideOut);
-        float alpha    = std::clamp(slide, 0.0f, 1.0f);
-
-        // Measure text to size the toast
-        ImVec2 nameSz = font->CalcTextSizeA(14.0f, FLT_MAX, 0.0f, e.zoneName.c_str());
-        const char* header = "Entering:";
-        ImVec2 hdrSz = font->CalcTextSizeA(11.0f, FLT_MAX, 0.0f, header);
-
-        float toastW = std::max(nameSz.x, hdrSz.x) + 28.0f;
-        float toastH = 42.0f;
-
-        // Center the toast horizontally, appear just below the zone name area (top-center)
-        float toastX = (screenW - toastW) * 0.5f;
-        float toastY = 56.0f + i * (toastH + 4.0f);
-        // Slide down from above
-        float offY = (1.0f - slide) * (-toastH - 10.0f);
-        toastY += offY;
-
-        ImVec2 tl(toastX, toastY);
-        ImVec2 br(toastX + toastW, toastY + toastH);
-
-        draw->AddRectFilled(tl, br, IM_COL32(10, 10, 16, static_cast<int>(alpha * 200)), 6.0f);
-        draw->AddRect(tl, br, IM_COL32(160, 140, 80, static_cast<int>(alpha * 220)), 6.0f, 0, 1.2f);
-
-        float cx = tl.x + toastW * 0.5f;
-        draw->AddText(font, 11.0f,
-            ImVec2(cx - hdrSz.x * 0.5f, tl.y + 5.0f),
-            IM_COL32(180, 170, 120, static_cast<int>(alpha * 200)), header);
-        draw->AddText(font, 14.0f,
-            ImVec2(cx - nameSz.x * 0.5f, tl.y + toastH * 0.5f + 1.0f),
-            IM_COL32(255, 230, 140, static_cast<int>(alpha * 240)), e.zoneName.c_str());
-    }
-}
-
-// ─── Area Trigger Message Toasts ─────────────────────────────────────────────
-void ToastManager::renderAreaTriggerToasts(float deltaTime, game::GameHandler& gameHandler) {
-    // Drain any pending messages from GameHandler
-    while (gameHandler.hasAreaTriggerMsg()) {
-        AreaTriggerToast t;
-        t.text = gameHandler.popAreaTriggerMsg();
-        t.age  = 0.0f;
-        areaTriggerToasts_.push_back(std::move(t));
-        if (areaTriggerToasts_.size() > 4)
-            areaTriggerToasts_.erase(areaTriggerToasts_.begin());
-    }
-
-    // Age and prune
-    constexpr float kLifetime = 4.5f;
-    for (auto& t : areaTriggerToasts_) t.age += deltaTime;
-    areaTriggerToasts_.erase(
-        std::remove_if(areaTriggerToasts_.begin(), areaTriggerToasts_.end(),
-                       [](const AreaTriggerToast& t) { return t.age >= kLifetime; }),
-        areaTriggerToasts_.end());
-    if (areaTriggerToasts_.empty()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth())  : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) :  720.0f;
-
-    ImDrawList* draw = ImGui::GetForegroundDrawList();
-    ImFont* font = ImGui::GetFont();
-    constexpr float kSlideDur = 0.35f;
-
-    for (int i = 0; i < static_cast<int>(areaTriggerToasts_.size()); ++i) {
-        const auto& t = areaTriggerToasts_[i];
-
-        float slideIn  = std::min(t.age, kSlideDur) / kSlideDur;
-        float slideOut = std::min(std::max(0.0f, kLifetime - t.age), kSlideDur) / kSlideDur;
-        float alpha    = std::clamp(std::min(slideIn, slideOut), 0.0f, 1.0f);
-
-        // Measure text
-        ImVec2 txtSz = font->CalcTextSizeA(13.0f, FLT_MAX, 0.0f, t.text.c_str());
-        float toastW = txtSz.x + 30.0f;
-        float toastH = 30.0f;
-
-        // Center horizontally, place below zone text (center of lower-third)
-        float toastX = (screenW - toastW) * 0.5f;
-        float toastY = screenH * 0.62f + i * (toastH + 3.0f);
-        // Slide up from below
-        float offY = (1.0f - std::min(slideIn, slideOut)) * (toastH + 12.0f);
-        toastY += offY;
-
-        ImVec2 tl(toastX, toastY);
-        ImVec2 br(toastX + toastW, toastY + toastH);
-
-        draw->AddRectFilled(tl, br, IM_COL32(8, 12, 22, static_cast<int>(alpha * 190)), 5.0f);
-        draw->AddRect(tl, br, IM_COL32(100, 160, 220, static_cast<int>(alpha * 200)), 5.0f, 0, 1.0f);
-
-        float cx = tl.x + toastW * 0.5f;
-        // Shadow
-        draw->AddText(font, 13.0f,
-            ImVec2(cx - txtSz.x * 0.5f + 1, tl.y + (toastH - txtSz.y) * 0.5f + 1),
-            IM_COL32(0, 0, 0, static_cast<int>(alpha * 180)), t.text.c_str());
-        // Text in light blue
-        draw->AddText(font, 13.0f,
-            ImVec2(cx - txtSz.x * 0.5f, tl.y + (toastH - txtSz.y) * 0.5f),
-            IM_COL32(180, 220, 255, static_cast<int>(alpha * 240)), t.text.c_str());
-    }
-}
-
-// ============================================================
-// Level-Up Ding Animation
-// ============================================================
-
-void ToastManager::triggerDing(uint32_t newLevel, uint32_t hpDelta, uint32_t manaDelta,
-                              uint32_t str, uint32_t agi, uint32_t sta,
-                              uint32_t intel, uint32_t spi) {
-    // Set golden burst overlay state (consumed by GameScreen)
-    levelUpFlashAlpha = 1.0f;
-    levelUpDisplayLevel = newLevel;
-
-    dingTimer_     = DING_DURATION;
-    dingLevel_     = newLevel;
-    dingHpDelta_   = hpDelta;
-    dingManaDelta_ = manaDelta;
-    dingStats_[0]  = str;
-    dingStats_[1]  = agi;
-    dingStats_[2]  = sta;
-    dingStats_[3]  = intel;
-    dingStats_[4]  = spi;
-
-    auto* ac = services_.audioCoordinator;
-    if (ac) {
-        if (auto* sfx = ac->getUiSoundManager()) {
-            sfx->playLevelUp();
-        }
-    }
-    if (auto* renderer = services_.renderer) {
-        renderer->playEmote("cheer");
-    }
-}
-
-void ToastManager::renderDingEffect() {
-    if (dingTimer_ <= 0.0f) return;
-
-    float dt = ImGui::GetIO().DeltaTime;
-    dingTimer_ -= dt;
-    if (dingTimer_ < 0.0f) dingTimer_ = 0.0f;
-
-    // Show "You have reached level X!" for the first 2.5s, fade out over last 0.5s.
-    // The 3D visual effect is handled by Renderer::triggerLevelUpEffect (LevelUp.m2).
-    constexpr float kFadeTime = 0.5f;
-    float alpha = dingTimer_ < kFadeTime ? (dingTimer_ / kFadeTime) : 1.0f;
-    if (alpha <= 0.0f) return;
-
-    ImGuiIO& io = ImGui::GetIO();
-    float cx = io.DisplaySize.x * 0.5f;
-    float cy = io.DisplaySize.y * 0.38f;  // Upper-center, like WoW
-
-    ImDrawList* draw = ImGui::GetForegroundDrawList();
-    ImFont* font = ImGui::GetFont();
-    float baseSize = ImGui::GetFontSize();
-    float fontSize = baseSize * 1.8f;
-
-    char buf[64];
-    snprintf(buf, sizeof(buf), "You have reached level %u!", dingLevel_);
-
-    ImVec2 sz = font->CalcTextSizeA(fontSize, FLT_MAX, 0.0f, buf);
-    float tx = cx - sz.x * 0.5f;
-    float ty = cy - sz.y * 0.5f;
-
-    // Slight black outline for readability
-    draw->AddText(font, fontSize, ImVec2(tx + 2, ty + 2),
-                  IM_COL32(0, 0, 0, static_cast<int>(alpha * 180)), buf);
-    // Gold text
-    draw->AddText(font, fontSize, ImVec2(tx, ty),
-                  IM_COL32(255, 210, 0, static_cast<int>(alpha * 255)), buf);
-
-    // Stat gains below the main text (shown only if server sent deltas)
-    bool hasStatGains = (dingHpDelta_ > 0 || dingManaDelta_ > 0 ||
-                         dingStats_[0] || dingStats_[1] || dingStats_[2] ||
-                         dingStats_[3] || dingStats_[4]);
-    if (hasStatGains) {
-        float smallSize = baseSize * 0.95f;
-        float yOff = ty + sz.y + 6.0f;
-
-        // Build stat delta string: "+150 HP  +80 Mana  +2 Str  +2 Agi ..."
-        static constexpr const char* kStatLabels[] = { "Str", "Agi", "Sta", "Int", "Spi" };
-        char statBuf[128];
-        int written = 0;
-        if (dingHpDelta_ > 0)
-            written += snprintf(statBuf + written, sizeof(statBuf) - written,
-                                "+%u HP  ", dingHpDelta_);
-        if (dingManaDelta_ > 0)
-            written += snprintf(statBuf + written, sizeof(statBuf) - written,
-                                "+%u Mana  ", dingManaDelta_);
-        for (int i = 0; i < 5 && written < static_cast<int>(sizeof(statBuf)) - 1; ++i) {
-            if (dingStats_[i] > 0)
-                written += snprintf(statBuf + written, sizeof(statBuf) - written,
-                                    "+%u %s  ", dingStats_[i], kStatLabels[i]);
-        }
-        // Trim trailing spaces
-        while (written > 0 && statBuf[written - 1] == ' ') --written;
-        statBuf[written] = '\0';
-
-        if (written > 0) {
-            ImVec2 ssz = font->CalcTextSizeA(smallSize, FLT_MAX, 0.0f, statBuf);
-            float stx = cx - ssz.x * 0.5f;
-            draw->AddText(font, smallSize, ImVec2(stx + 1, yOff + 1),
-                          IM_COL32(0, 0, 0, static_cast<int>(alpha * 160)), statBuf);
-            draw->AddText(font, smallSize, ImVec2(stx, yOff),
-                          IM_COL32(100, 220, 100, static_cast<int>(alpha * 230)), statBuf);
-        }
-    }
-}
-
-void ToastManager::triggerAchievementToast(uint32_t achievementId, std::string name) {
-    achievementToastId_    = achievementId;
-    achievementToastName_  = std::move(name);
-    achievementToastTimer_ = ACHIEVEMENT_TOAST_DURATION;
-
-    // Play a UI sound if available
-    auto* ac = services_.audioCoordinator;
-    if (ac) {
-        if (auto* sfx = ac->getUiSoundManager()) {
-            sfx->playAchievementAlert();
-        }
-    }
-}
-
-void ToastManager::renderAchievementToast() {
-    if (achievementToastTimer_ <= 0.0f) return;
-
-    float dt = ImGui::GetIO().DeltaTime;
-    achievementToastTimer_ -= dt;
-    if (achievementToastTimer_ < 0.0f) achievementToastTimer_ = 0.0f;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth())  : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) :  720.0f;
-
-    // Slide in from the right — fully visible for most of the duration, slides out at end
-    constexpr float SLIDE_TIME = 0.4f;
-    float  slideIn  = std::min(achievementToastTimer_, ACHIEVEMENT_TOAST_DURATION - achievementToastTimer_);
-    float  slideFrac = (ACHIEVEMENT_TOAST_DURATION > 0.0f && SLIDE_TIME > 0.0f)
-                         ? std::min(slideIn / SLIDE_TIME, 1.0f)
-                         : 1.0f;
-
-    constexpr float TOAST_W = 280.0f;
-    constexpr float TOAST_H =  60.0f;
-    float xFull   = screenW - TOAST_W - 20.0f;
-    float xHidden = screenW + 10.0f;
-    float toastX  = xHidden + (xFull - xHidden) * slideFrac;
-    float toastY  = screenH - TOAST_H - 80.0f;  // above action bar area
-
-    float alpha = std::min(1.0f, achievementToastTimer_ / 0.5f);  // fade at very end
-
-    ImDrawList* draw = ImGui::GetForegroundDrawList();
-
-    // Background panel (gold border, dark fill)
-    ImVec2 tl(toastX,            toastY);
-    ImVec2 br(toastX + TOAST_W,  toastY + TOAST_H);
-    draw->AddRectFilled(tl, br, IM_COL32(30, 20, 10, static_cast<int>(alpha * 230)), 6.0f);
-    draw->AddRect(tl, br, IM_COL32(200, 170, 50, static_cast<int>(alpha * 255)), 6.0f, 0, 2.0f);
-
-    // Title
-    ImFont* font = ImGui::GetFont();
-    float   titleSize = 14.0f;
-    float   bodySize  = 12.0f;
-    const char* title = "Achievement Earned!";
-    float titleW = font->CalcTextSizeA(titleSize, FLT_MAX, 0.0f, title).x;
-    float titleX = toastX + (TOAST_W - titleW) * 0.5f;
-    draw->AddText(font, titleSize, ImVec2(titleX + 1, toastY + 8 + 1),
-                  IM_COL32(0, 0, 0, static_cast<int>(alpha * 180)), title);
-    draw->AddText(font, titleSize, ImVec2(titleX, toastY + 8),
-                  IM_COL32(255, 215, 0, static_cast<int>(alpha * 255)), title);
-
-    // Achievement name (falls back to ID if name not available)
-    char idBuf[256];
-    const char* achText = achievementToastName_.empty()
-        ? nullptr : achievementToastName_.c_str();
-    if (achText) {
-        std::snprintf(idBuf, sizeof(idBuf), "%s", achText);
-    } else {
-        std::snprintf(idBuf, sizeof(idBuf), "Achievement #%u", achievementToastId_);
-    }
-    float idW = font->CalcTextSizeA(bodySize, FLT_MAX, 0.0f, idBuf).x;
-    float idX = toastX + (TOAST_W - idW) * 0.5f;
-    draw->AddText(font, bodySize, ImVec2(idX, toastY + 28),
-                  IM_COL32(220, 200, 150, static_cast<int>(alpha * 255)), idBuf);
-}
-
-// ---------------------------------------------------------------------------
-// Area discovery toast — "Discovered: <AreaName>! (+XP XP)" centered on screen
-// ---------------------------------------------------------------------------
-
-void ToastManager::renderDiscoveryToast() {
-    if (discoveryToastTimer_ <= 0.0f) return;
-
-    float dt = ImGui::GetIO().DeltaTime;
-    discoveryToastTimer_ -= dt;
-    if (discoveryToastTimer_ < 0.0f) discoveryToastTimer_ = 0.0f;
-
-    // Fade: ramp up in first 0.4s, hold, fade out in last 1.0s
-    float alpha;
-    if (discoveryToastTimer_ > DISCOVERY_TOAST_DURATION - 0.4f)
-        alpha = 1.0f - (discoveryToastTimer_ - (DISCOVERY_TOAST_DURATION - 0.4f)) / 0.4f;
-    else if (discoveryToastTimer_ < 1.0f)
-        alpha = discoveryToastTimer_;
-    else
-        alpha = 1.0f;
-    alpha = std::clamp(alpha, 0.0f, 1.0f);
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth())  : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) :  720.0f;
-
-    ImFont* font = ImGui::GetFont();
-    ImDrawList* draw = ImGui::GetForegroundDrawList();
-
-    const char* header   = "Discovered!";
-    float headerSize     = 16.0f;
-    float nameSize       = 28.0f;
-    float xpSize         = 14.0f;
-
-    ImVec2 headerDim = font->CalcTextSizeA(headerSize, FLT_MAX, 0.0f, header);
-    ImVec2 nameDim   = font->CalcTextSizeA(nameSize,   FLT_MAX, 0.0f, discoveryToastName_.c_str());
-
-    char xpBuf[48];
-    if (discoveryToastXP_ > 0)
-        snprintf(xpBuf, sizeof(xpBuf), "+%u XP", discoveryToastXP_);
-    else
-        xpBuf[0] = '\0';
-    ImVec2 xpDim = font->CalcTextSizeA(xpSize, FLT_MAX, 0.0f, xpBuf);
-
-    // Position slightly below zone text (at 37% down screen)
-    float centreY = screenH * 0.37f;
-    float headerX = (screenW - headerDim.x) * 0.5f;
-    float nameX   = (screenW - nameDim.x)   * 0.5f;
-    float xpX     = (screenW - xpDim.x)     * 0.5f;
-    float headerY = centreY;
-    float nameY   = centreY + headerDim.y + 4.0f;
-    float xpY     = nameY + nameDim.y + 4.0f;
-
-    // "Discovered!" in gold
-    draw->AddText(font, headerSize, ImVec2(headerX + 1, headerY + 1),
-                  IM_COL32(0, 0, 0, static_cast<int>(alpha * 160)), header);
-    draw->AddText(font, headerSize, ImVec2(headerX, headerY),
-                  IM_COL32(255, 215, 0, static_cast<int>(alpha * 255)), header);
-
-    // Area name in white
-    draw->AddText(font, nameSize, ImVec2(nameX + 1, nameY + 1),
-                  IM_COL32(0, 0, 0, static_cast<int>(alpha * 160)), discoveryToastName_.c_str());
-    draw->AddText(font, nameSize, ImVec2(nameX, nameY),
-                  IM_COL32(255, 255, 255, static_cast<int>(alpha * 255)), discoveryToastName_.c_str());
-
-    // XP gain in light green (if any)
-    if (xpBuf[0] != '\0') {
-        draw->AddText(font, xpSize, ImVec2(xpX + 1, xpY + 1),
-                      IM_COL32(0, 0, 0, static_cast<int>(alpha * 140)), xpBuf);
-        draw->AddText(font, xpSize, ImVec2(xpX, xpY),
-                      IM_COL32(100, 220, 100, static_cast<int>(alpha * 230)), xpBuf);
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Quest objective progress toasts — shown at screen bottom-right on kill/item updates
-// ---------------------------------------------------------------------------
-
-void ToastManager::renderQuestProgressToasts() {
-    if (questToasts_.empty()) return;
-
-    float dt = ImGui::GetIO().DeltaTime;
-    for (auto& t : questToasts_) t.age += dt;
-    questToasts_.erase(
-        std::remove_if(questToasts_.begin(), questToasts_.end(),
-            [](const QuestProgressToastEntry& t) { return t.age >= QUEST_TOAST_DURATION; }),
-        questToasts_.end());
-    if (questToasts_.empty()) return;
-
-    ImVec2 displaySize = ImGui::GetIO().DisplaySize;
-    float screenW = displaySize.x > 0.0f ? displaySize.x : 1280.0f;
-    float screenH = displaySize.y > 0.0f ? displaySize.y : 720.0f;
-
-    // Stack at bottom-right, just above action bar area
-    constexpr float TOAST_W   = 240.0f;
-    constexpr float TOAST_H   = 48.0f;
-    constexpr float TOAST_GAP = 4.0f;
-    float baseY = screenH * 0.72f;
-    float toastX = screenW - TOAST_W - 14.0f;
-
-    ImDrawList* bgDL = ImGui::GetBackgroundDrawList();
-    const int count = static_cast<int>(questToasts_.size());
-
-    for (int i = 0; i < count; ++i) {
-        const auto& toast = questToasts_[i];
-
-        float remaining = QUEST_TOAST_DURATION - toast.age;
-        float alpha;
-        if (toast.age < 0.2f)
-            alpha = toast.age / 0.2f;
-        else if (remaining < 1.0f)
-            alpha = remaining;
-        else
-            alpha = 1.0f;
-        alpha = std::clamp(alpha, 0.0f, 1.0f);
-
-        float ty = baseY - (count - i) * (TOAST_H + TOAST_GAP);
-
-        uint8_t bgA = static_cast<uint8_t>(200 * alpha);
-        uint8_t fgA = static_cast<uint8_t>(255 * alpha);
-
-        // Background: dark amber tint (quest color convention)
-        bgDL->AddRectFilled(ImVec2(toastX, ty), ImVec2(toastX + TOAST_W, ty + TOAST_H),
-                            IM_COL32(35, 25, 5, bgA), 5.0f);
-        bgDL->AddRect(ImVec2(toastX, ty), ImVec2(toastX + TOAST_W, ty + TOAST_H),
-                      IM_COL32(200, 160, 30, static_cast<uint8_t>(160 * alpha)), 5.0f, 0, 1.5f);
-
-        // Quest title (gold, small)
-        bgDL->AddText(ImVec2(toastX + 8.0f, ty + 5.0f),
-                      IM_COL32(220, 180, 50, fgA), toast.questTitle.c_str());
-
-        // Progress bar + text: "ObjectiveName X / Y"
-        float barY  = ty + 21.0f;
-        float barX0 = toastX + 8.0f;
-        float barX1 = toastX + TOAST_W - 8.0f;
-        float barH  = 8.0f;
-        float pct   = (toast.required > 0)
-            ? std::min(1.0f, static_cast<float>(toast.current) / static_cast<float>(toast.required))
-            : 1.0f;
-        // Bar background
-        bgDL->AddRectFilled(ImVec2(barX0, barY), ImVec2(barX1, barY + barH),
-                            IM_COL32(50, 40, 10, static_cast<uint8_t>(180 * alpha)), 3.0f);
-        // Bar fill — green when complete, amber otherwise
-        ImU32 barCol = (pct >= 1.0f) ? IM_COL32(60, 220, 80, fgA) : IM_COL32(200, 160, 30, fgA);
-        bgDL->AddRectFilled(ImVec2(barX0, barY),
-                            ImVec2(barX0 + (barX1 - barX0) * pct, barY + barH),
-                            barCol, 3.0f);
-
-        // Objective name + count
-        char progBuf[48];
-        if (!toast.objectiveName.empty())
-            snprintf(progBuf, sizeof(progBuf), "%.22s: %u/%u",
-                     toast.objectiveName.c_str(), toast.current, toast.required);
-        else
-            snprintf(progBuf, sizeof(progBuf), "%u/%u", toast.current, toast.required);
-        bgDL->AddText(ImVec2(toastX + 8.0f, ty + 32.0f),
-                      IM_COL32(220, 220, 200, static_cast<uint8_t>(210 * alpha)), progBuf);
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Item loot toasts — quality-coloured strip at bottom-left when item received
-// ---------------------------------------------------------------------------
-
-void ToastManager::renderItemLootToasts() {
-    if (itemLootToasts_.empty()) return;
-
-    float dt = ImGui::GetIO().DeltaTime;
-    for (auto& t : itemLootToasts_) t.age += dt;
-    itemLootToasts_.erase(
-        std::remove_if(itemLootToasts_.begin(), itemLootToasts_.end(),
-            [](const ItemLootToastEntry& t) { return t.age >= ITEM_LOOT_TOAST_DURATION; }),
-        itemLootToasts_.end());
-    if (itemLootToasts_.empty()) return;
-
-    ImVec2 displaySize = ImGui::GetIO().DisplaySize;
-    float screenH = displaySize.y > 0.0f ? displaySize.y : 720.0f;
-
-    // Quality colours (matching WoW convention)
-    static const ImU32 kQualityColors[] = {
-        IM_COL32(157, 157, 157, 255),  // 0 grey (poor)
-        IM_COL32(255, 255, 255, 255),  // 1 white (common)
-        IM_COL32( 30, 255,  30, 255),  // 2 green (uncommon)
-        IM_COL32(  0, 112, 221, 255),  // 3 blue (rare)
-        IM_COL32(163,  53, 238, 255),  // 4 purple (epic)
-        IM_COL32(255, 128,   0, 255),  // 5 orange (legendary)
-        IM_COL32(230, 204, 128, 255),  // 6 light gold (artifact)
-        IM_COL32(230, 204, 128, 255),  // 7 light gold (heirloom)
-    };
-
-    // Stack at bottom-left above action bars; each item is 24 px tall
-    constexpr float TOAST_W   = 260.0f;
-    constexpr float TOAST_H   = 24.0f;
-    constexpr float TOAST_GAP = 2.0f;
-    constexpr float TOAST_X   = 14.0f;
-    float baseY = screenH * 0.68f;  // slightly above the whisper toasts
-
-    ImDrawList* bgDL = ImGui::GetBackgroundDrawList();
-    const int count = static_cast<int>(itemLootToasts_.size());
-
-    for (int i = 0; i < count; ++i) {
-        const auto& toast = itemLootToasts_[i];
-
-        float remaining = ITEM_LOOT_TOAST_DURATION - toast.age;
-        float alpha;
-        if (toast.age < 0.15f)
-            alpha = toast.age / 0.15f;
-        else if (remaining < 0.7f)
-            alpha = remaining / 0.7f;
-        else
-            alpha = 1.0f;
-        alpha = std::clamp(alpha, 0.0f, 1.0f);
-
-        // Slide-in from left
-        float slideX = (toast.age < 0.15f) ? (TOAST_W * (1.0f - toast.age / 0.15f)) : 0.0f;
-        float tx = TOAST_X - slideX;
-        float ty = baseY - (count - i) * (TOAST_H + TOAST_GAP);
-
-        uint8_t bgA = static_cast<uint8_t>(180 * alpha);
-        uint8_t fgA = static_cast<uint8_t>(255 * alpha);
-
-        // Background: very dark with quality-tinted left border accent
-        bgDL->AddRectFilled(ImVec2(tx, ty), ImVec2(tx + TOAST_W, ty + TOAST_H),
-                            IM_COL32(12, 12, 12, bgA), 3.0f);
-
-        // Quality colour accent bar on left edge (3px wide)
-        ImU32 qualCol = kQualityColors[std::min(static_cast<uint32_t>(7u), toast.quality)];
-        ImU32 qualColA = (qualCol & 0x00FFFFFFu) | (static_cast<uint32_t>(fgA) << 24u);
-        bgDL->AddRectFilled(ImVec2(tx, ty), ImVec2(tx + 3.0f, ty + TOAST_H), qualColA, 3.0f);
-
-        // "Loot:" label in dim white
-        bgDL->AddText(ImVec2(tx + 7.0f, ty + 5.0f),
-                      IM_COL32(160, 160, 160, static_cast<uint8_t>(200 * alpha)), "Loot:");
-
-        // Item name in quality colour
-        std::string displayName = toast.name.empty() ? ("Item #" + std::to_string(toast.itemId)) : toast.name;
-        if (displayName.size() > 26) { displayName.resize(23); displayName += "..."; }
-        bgDL->AddText(ImVec2(tx + 42.0f, ty + 5.0f), qualColA, displayName.c_str());
-
-        // Count (if > 1)
-        if (toast.count > 1) {
-            char countBuf[12];
-            snprintf(countBuf, sizeof(countBuf), "x%u", toast.count);
-            bgDL->AddText(ImVec2(tx + TOAST_W - 34.0f, ty + 5.0f),
-                          IM_COL32(200, 200, 200, static_cast<uint8_t>(200 * alpha)), countBuf);
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------
-// PvP honor credit toasts — shown at screen top-right on honorable kill
-// ---------------------------------------------------------------------------
-
-void ToastManager::renderPvpHonorToasts() {
-    if (pvpHonorToasts_.empty()) return;
-
-    float dt = ImGui::GetIO().DeltaTime;
-    for (auto& t : pvpHonorToasts_) t.age += dt;
-    pvpHonorToasts_.erase(
-        std::remove_if(pvpHonorToasts_.begin(), pvpHonorToasts_.end(),
-            [](const PvpHonorToastEntry& t) { return t.age >= PVP_HONOR_TOAST_DURATION; }),
-        pvpHonorToasts_.end());
-    if (pvpHonorToasts_.empty()) return;
-
-    ImVec2 displaySize = ImGui::GetIO().DisplaySize;
-    float screenW = displaySize.x > 0.0f ? displaySize.x : 1280.0f;
-
-    // Stack toasts at top-right, below any minimap area
-    constexpr float TOAST_W   = 180.0f;
-    constexpr float TOAST_H   = 30.0f;
-    constexpr float TOAST_GAP = 3.0f;
-    constexpr float TOAST_TOP = 10.0f;
-    float toastX = screenW - TOAST_W - 10.0f;
-
-    ImDrawList* bgDL = ImGui::GetBackgroundDrawList();
-    const int count = static_cast<int>(pvpHonorToasts_.size());
-
-    for (int i = 0; i < count; ++i) {
-        const auto& toast = pvpHonorToasts_[i];
-
-        float remaining = PVP_HONOR_TOAST_DURATION - toast.age;
-        float alpha;
-        if (toast.age < 0.15f)
-            alpha = toast.age / 0.15f;
-        else if (remaining < 0.8f)
-            alpha = remaining / 0.8f;
-        else
-            alpha = 1.0f;
-        alpha = std::clamp(alpha, 0.0f, 1.0f);
-
-        float ty = TOAST_TOP + i * (TOAST_H + TOAST_GAP);
-
-        uint8_t bgA = static_cast<uint8_t>(190 * alpha);
-        uint8_t fgA = static_cast<uint8_t>(255 * alpha);
-
-        // Background: dark red (PvP theme)
-        bgDL->AddRectFilled(ImVec2(toastX, ty), ImVec2(toastX + TOAST_W, ty + TOAST_H),
-                            IM_COL32(28, 5, 5, bgA), 4.0f);
-        bgDL->AddRect(ImVec2(toastX, ty), ImVec2(toastX + TOAST_W, ty + TOAST_H),
-                      IM_COL32(200, 50, 50, static_cast<uint8_t>(160 * alpha)), 4.0f, 0, 1.2f);
-
-        // Sword ⚔ icon (U+2694, UTF-8: e2 9a 94)
-        bgDL->AddText(ImVec2(toastX + 7.0f, ty + 7.0f),
-                      IM_COL32(220, 80, 80, fgA), "\xe2\x9a\x94");
-
-        // "+N Honor" text in gold
-        char buf[40];
-        snprintf(buf, sizeof(buf), "+%u Honor", toast.honor);
-        bgDL->AddText(ImVec2(toastX + 24.0f, ty + 8.0f),
-                      IM_COL32(255, 210, 50, fgA), buf);
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Nearby player level-up toasts — shown at screen bottom-centre
-// ---------------------------------------------------------------------------
-
-void ToastManager::renderPlayerLevelUpToasts(game::GameHandler& gameHandler) {
-    if (playerLevelUpToasts_.empty()) return;
-
-    float dt = ImGui::GetIO().DeltaTime;
-    for (auto& t : playerLevelUpToasts_) {
-        t.age += dt;
-        // Lazy name resolution — fill in once the name cache has it
-        if (t.playerName.empty() && t.guid != 0) {
-            t.playerName = gameHandler.lookupName(t.guid);
-        }
-    }
-    playerLevelUpToasts_.erase(
-        std::remove_if(playerLevelUpToasts_.begin(), playerLevelUpToasts_.end(),
-            [](const PlayerLevelUpToastEntry& t) {
-                return t.age >= PLAYER_LEVELUP_TOAST_DURATION;
-            }),
-        playerLevelUpToasts_.end());
-    if (playerLevelUpToasts_.empty()) return;
-
-    ImVec2 displaySize = ImGui::GetIO().DisplaySize;
-    float screenW = displaySize.x > 0.0f ? displaySize.x : 1280.0f;
-    float screenH = displaySize.y > 0.0f ? displaySize.y : 720.0f;
-
-    // Stack toasts at screen bottom-centre, above action bars
-    constexpr float TOAST_W   = 230.0f;
-    constexpr float TOAST_H   = 38.0f;
-    constexpr float TOAST_GAP = 4.0f;
-    float baseY  = screenH * 0.72f;
-    float toastX = (screenW - TOAST_W) * 0.5f;
-
-    ImDrawList* bgDL = ImGui::GetBackgroundDrawList();
-    const int count = static_cast<int>(playerLevelUpToasts_.size());
-
-    for (int i = 0; i < count; ++i) {
-        const auto& toast = playerLevelUpToasts_[i];
-
-        float remaining = PLAYER_LEVELUP_TOAST_DURATION - toast.age;
-        float alpha;
-        if (toast.age < 0.2f)
-            alpha = toast.age / 0.2f;
-        else if (remaining < 1.0f)
-            alpha = remaining;
-        else
-            alpha = 1.0f;
-        alpha = std::clamp(alpha, 0.0f, 1.0f);
-
-        // Subtle pop-up from below during first 0.2s
-        float slideY = (toast.age < 0.2f) ? (TOAST_H * (1.0f - toast.age / 0.2f)) : 0.0f;
-        float ty = baseY - (count - i) * (TOAST_H + TOAST_GAP) + slideY;
-
-        uint8_t bgA = static_cast<uint8_t>(200 * alpha);
-        uint8_t fgA = static_cast<uint8_t>(255 * alpha);
-
-        // Background: dark gold tint
-        bgDL->AddRectFilled(ImVec2(toastX, ty), ImVec2(toastX + TOAST_W, ty + TOAST_H),
-                            IM_COL32(30, 22, 5, bgA), 5.0f);
-        // Gold border with glow at peak
-        float glowStr = (toast.age < 0.5f) ? (1.0f - toast.age / 0.5f) : 0.0f;
-        uint8_t borderA = static_cast<uint8_t>((160 + 80 * glowStr) * alpha);
-        bgDL->AddRect(ImVec2(toastX, ty), ImVec2(toastX + TOAST_W, ty + TOAST_H),
-                      IM_COL32(255, 210, 50, borderA), 5.0f, 0, 1.5f + glowStr * 1.5f);
-
-        // Star ★ icon on left
-        bgDL->AddText(ImVec2(toastX + 8.0f, ty + 10.0f),
-                      IM_COL32(255, 220, 60, fgA), "\xe2\x98\x85");  // UTF-8 ★
-
-        // "<Name> is now level X!" text
-        const char* displayName = toast.playerName.empty() ? "A player" : toast.playerName.c_str();
-        char buf[64];
-        snprintf(buf, sizeof(buf), "%.18s is now level %u!", displayName, toast.newLevel);
-        bgDL->AddText(ImVec2(toastX + 26.0f, ty + 11.0f),
-                      IM_COL32(255, 230, 100, fgA), buf);
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Resurrection flash — brief screen brightening + "You have been resurrected!"
-// banner when the player transitions from ghost back to alive.
-// ---------------------------------------------------------------------------
-
-void ToastManager::renderResurrectFlash() {
-    if (resurrectFlashTimer_ <= 0.0f) return;
-
-    float dt = ImGui::GetIO().DeltaTime;
-    resurrectFlashTimer_ -= dt;
-    if (resurrectFlashTimer_ <= 0.0f) {
-        resurrectFlashTimer_ = 0.0f;
-        return;
-    }
-
-    ImVec2 displaySize = ImGui::GetIO().DisplaySize;
-    float screenW = displaySize.x > 0.0f ? displaySize.x : 1280.0f;
-    float screenH = displaySize.y > 0.0f ? displaySize.y : 720.0f;
-
-    // Normalised age in [0, 1] (0 = just fired, 1 = fully elapsed)
-    float t = 1.0f - resurrectFlashTimer_ / kResurrectFlashDuration;
-
-    // Alpha envelope: fast fade-in (first 0.15s), hold, then fade-out (last 0.8s)
-    float alpha;
-    const float fadeIn  = 0.15f / kResurrectFlashDuration;   // ~5% of lifetime
-    const float fadeOut = 0.8f  / kResurrectFlashDuration;   // ~27% of lifetime
-    if (t < fadeIn)
-        alpha = t / fadeIn;
-    else if (t < 1.0f - fadeOut)
-        alpha = 1.0f;
-    else
-        alpha = (1.0f - t) / fadeOut;
-    alpha = std::clamp(alpha, 0.0f, 1.0f);
-
-    ImDrawList* bg = ImGui::GetBackgroundDrawList();
-
-    // Soft golden/white vignette — brightening instead of darkening
-    uint8_t vigA = static_cast<uint8_t>(50 * alpha);
-    bg->AddRectFilled(ImVec2(0, 0), ImVec2(screenW, screenH),
-                      IM_COL32(200, 230, 255, vigA));
-
-    // Centered banner panel
-    constexpr float PANEL_W = 360.0f;
-    constexpr float PANEL_H = 52.0f;
-    float px = (screenW - PANEL_W) * 0.5f;
-    float py = screenH * 0.34f;
-
-    uint8_t bgA     = static_cast<uint8_t>(210 * alpha);
-    uint8_t borderA = static_cast<uint8_t>(255 * alpha);
-    uint8_t textA   = static_cast<uint8_t>(255 * alpha);
-
-    // Background: deep blue-black
-    bg->AddRectFilled(ImVec2(px, py), ImVec2(px + PANEL_W, py + PANEL_H),
-                      IM_COL32(10, 18, 40, bgA), 8.0f);
-
-    // Border glow: bright holy gold
-    bg->AddRect(ImVec2(px, py), ImVec2(px + PANEL_W, py + PANEL_H),
-                IM_COL32(200, 230, 100, borderA), 8.0f, 0, 2.0f);
-    // Inner halo line
-    bg->AddRect(ImVec2(px + 3.0f, py + 3.0f), ImVec2(px + PANEL_W - 3.0f, py + PANEL_H - 3.0f),
-                IM_COL32(255, 255, 180, static_cast<uint8_t>(80 * alpha)), 6.0f, 0, 1.0f);
-
-    // "✦ You have been resurrected! ✦" centered
-    // UTF-8 heavy four-pointed star U+2726: \xe2\x9c\xa6
-    const char* banner = "\xe2\x9c\xa6 You have been resurrected! \xe2\x9c\xa6";
-    ImFont* font = ImGui::GetFont();
-    float fontSize = ImGui::GetFontSize();
-    ImVec2 textSz = font->CalcTextSizeA(fontSize, FLT_MAX, 0.0f, banner);
-    float tx = px + (PANEL_W - textSz.x) * 0.5f;
-    float ty = py + (PANEL_H - textSz.y) * 0.5f;
-
-    // Drop shadow
-    bg->AddText(font, fontSize, ImVec2(tx + 1.0f, ty + 1.0f),
-                IM_COL32(0, 0, 0, static_cast<uint8_t>(180 * alpha)), banner);
-    // Main text in warm gold
-    bg->AddText(font, fontSize, ImVec2(tx, ty),
-                IM_COL32(255, 240, 120, textA), banner);
-}
-
-// ---------------------------------------------------------------------------
-// Whisper toast notifications — brief overlay when a player whispers you
-// ---------------------------------------------------------------------------
-
-void ToastManager::renderWhisperToasts() {
-    if (whisperToasts_.empty()) return;
-
-    float dt = ImGui::GetIO().DeltaTime;
-
-    // Age and prune expired toasts
-    for (auto& t : whisperToasts_) t.age += dt;
-    whisperToasts_.erase(
-        std::remove_if(whisperToasts_.begin(), whisperToasts_.end(),
-            [](const WhisperToastEntry& t) { return t.age >= WHISPER_TOAST_DURATION; }),
-        whisperToasts_.end());
-    if (whisperToasts_.empty()) return;
-
-    ImVec2 displaySize = ImGui::GetIO().DisplaySize;
-    float screenH = displaySize.y > 0.0f ? displaySize.y : 720.0f;
-
-    // Stack toasts at bottom-left, above the action bars (y ≈ screenH * 0.72)
-    // Each toast is ~56px tall with a 4px gap between them.
-    constexpr float TOAST_W   = 280.0f;
-    constexpr float TOAST_H   = 56.0f;
-    constexpr float TOAST_GAP = 4.0f;
-    constexpr float TOAST_X   = 14.0f;  // left edge (won't cover action bars)
-    float baseY = screenH * 0.72f;
-
-    ImDrawList* bgDL = ImGui::GetBackgroundDrawList();
-
-    const int count = static_cast<int>(whisperToasts_.size());
-    for (int i = 0; i < count; ++i) {
-        auto& toast = whisperToasts_[i];
-
-        // Fade in over 0.25s; fade out in last 1.0s
-        float alpha;
-        float remaining = WHISPER_TOAST_DURATION - toast.age;
-        if (toast.age < 0.25f)
-            alpha = toast.age / 0.25f;
-        else if (remaining < 1.0f)
-            alpha = remaining;
-        else
-            alpha = 1.0f;
-        alpha = std::clamp(alpha, 0.0f, 1.0f);
-
-        // Slide-in from left: offset 0→0 after 0.25s
-        float slideX = (toast.age < 0.25f) ? (TOAST_W * (1.0f - toast.age / 0.25f)) : 0.0f;
-        float tx = TOAST_X - slideX;
-        float ty = baseY - (count - i) * (TOAST_H + TOAST_GAP);
-
-        uint8_t bgA = static_cast<uint8_t>(210 * alpha);
-        uint8_t fgA = static_cast<uint8_t>(255 * alpha);
-
-        // Background panel — dark purple tint (whisper color convention)
-        bgDL->AddRectFilled(ImVec2(tx, ty), ImVec2(tx + TOAST_W, ty + TOAST_H),
-                            IM_COL32(25, 10, 40, bgA), 6.0f);
-        // Purple border
-        bgDL->AddRect(ImVec2(tx, ty), ImVec2(tx + TOAST_W, ty + TOAST_H),
-                      IM_COL32(160, 80, 220, static_cast<uint8_t>(180 * alpha)), 6.0f, 0, 1.5f);
-
-        // "Whisper" label (small, purple-ish)
-        bgDL->AddText(ImVec2(tx + 10.0f, ty + 6.0f),
-                      IM_COL32(190, 110, 255, fgA), "Whisper from:");
-
-        // Sender name (gold)
-        bgDL->AddText(ImVec2(tx + 10.0f, ty + 20.0f),
-                      IM_COL32(255, 210, 50, fgA), toast.sender.c_str());
-
-        // Message preview (white, dimmer)
-        bgDL->AddText(ImVec2(tx + 10.0f, ty + 36.0f),
-                      IM_COL32(220, 220, 220, static_cast<uint8_t>(200 * alpha)),
-                      toast.preview.c_str());
-    }
-}
-
-// Zone discovery text — "Entering: <ZoneName>" fades in/out at screen centre
-// ---------------------------------------------------------------------------
-
-void ToastManager::renderZoneText(game::GameHandler& gameHandler) {
-    // Poll worldStateZoneId for server-driven zone changes (fires on every zone crossing,
-    // including sub-zones like Ironforge within Dun Morogh).
-    uint32_t wsZoneId = gameHandler.getWorldStateZoneId();
-    if (wsZoneId != 0 && wsZoneId != lastKnownWorldStateZoneId_) {
-        lastKnownWorldStateZoneId_ = wsZoneId;
-        std::string wsName = gameHandler.getWhoAreaName(wsZoneId);
-        if (!wsName.empty()) {
-            zoneTextName_  = wsName;
-            zoneTextTimer_ = ZONE_TEXT_DURATION;
-        }
-    }
-
-    // Also poll the renderer for zone name changes (covers map-level transitions
-    // where worldStateZoneId may not change immediately).
-    auto* appRenderer = services_.renderer;
-    if (appRenderer) {
-        const std::string& zoneName = appRenderer->getCurrentZoneName();
-        if (!zoneName.empty() && zoneName != lastKnownZoneName_) {
-            lastKnownZoneName_ = zoneName;
-            // Only override if the worldState hasn't already queued this zone
-            if (zoneTextName_ != zoneName) {
-                zoneTextName_  = zoneName;
-                zoneTextTimer_ = ZONE_TEXT_DURATION;
-            }
-        }
-    }
-
-    if (zoneTextTimer_ <= 0.0f || zoneTextName_.empty()) return;
-
-    float dt = ImGui::GetIO().DeltaTime;
-    zoneTextTimer_ -= dt;
-    if (zoneTextTimer_ < 0.0f) zoneTextTimer_ = 0.0f;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth())  : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) :  720.0f;
-
-    // Fade: ramp up in first 0.5 s, hold, fade out in last 1.0 s
-    float alpha;
-    if (zoneTextTimer_ > ZONE_TEXT_DURATION - 0.5f)
-        alpha = 1.0f - (zoneTextTimer_ - (ZONE_TEXT_DURATION - 0.5f)) / 0.5f;
-    else if (zoneTextTimer_ < 1.0f)
-        alpha = zoneTextTimer_;
-    else
-        alpha = 1.0f;
-    alpha = std::clamp(alpha, 0.0f, 1.0f);
-
-    ImFont* font = ImGui::GetFont();
-
-    // "Entering:" header
-    const char* header = "Entering:";
-    float headerSize = 16.0f;
-    float nameSize   = 26.0f;
-
-    ImVec2 headerDim = font->CalcTextSizeA(headerSize, FLT_MAX, 0.0f, header);
-    ImVec2 nameDim   = font->CalcTextSizeA(nameSize,   FLT_MAX, 0.0f, zoneTextName_.c_str());
-
-    float centreY = screenH * 0.30f;  // upper third, like WoW
-    float headerX = (screenW - headerDim.x) * 0.5f;
-    float nameX   = (screenW - nameDim.x)   * 0.5f;
-    float headerY = centreY;
-    float nameY   = centreY + headerDim.y + 4.0f;
-
-    ImDrawList* draw = ImGui::GetForegroundDrawList();
-
-    // "Entering:" in gold
-    draw->AddText(font, headerSize, ImVec2(headerX + 1, headerY + 1),
-                  IM_COL32(0, 0, 0, static_cast<int>(alpha * 160)), header);
-    draw->AddText(font, headerSize, ImVec2(headerX, headerY),
-                  IM_COL32(255, 215, 0, static_cast<int>(alpha * 255)), header);
-
-    // Zone name in white
-    draw->AddText(font, nameSize, ImVec2(nameX + 1, nameY + 1),
-                  IM_COL32(0, 0, 0, static_cast<int>(alpha * 160)), zoneTextName_.c_str());
-    draw->AddText(font, nameSize, ImVec2(nameX, nameY),
-                  IM_COL32(255, 255, 255, static_cast<int>(alpha * 255)), zoneTextName_.c_str());
-}
-
-} } // namespace wowee::ui
diff --git a/src/ui/ui_manager.cpp b/src/ui/ui_manager.cpp
index cbb8997e..305bb7de 100644
--- a/src/ui/ui_manager.cpp
+++ b/src/ui/ui_manager.cpp
@@ -78,10 +78,6 @@ bool UIManager::initialize(core::Window* win) {
     initInfo.ImageCount = vkCtx->getSwapchainImageCount();
     initInfo.PipelineInfoMain.RenderPass = vkCtx->getImGuiRenderPass();
     initInfo.PipelineInfoMain.MSAASamples = vkCtx->getMsaaSamples();
-    initInfo.CheckVkResultFn = [](VkResult err) {
-        if (err != VK_SUCCESS)
-            LOG_ERROR("ImGui Vulkan error: ", static_cast<int>(err));
-    };
 
     ImGui_ImplVulkan_Init(&initInfo);
 
diff --git a/src/ui/window_manager.cpp b/src/ui/window_manager.cpp
deleted file mode 100644
index 0ddbedeb..00000000
--- a/src/ui/window_manager.cpp
+++ /dev/null
@@ -1,4246 +0,0 @@
-// ============================================================
-// WindowManager — extracted from GameScreen
-// Owns all NPC interaction windows, popup dialogs, etc.
-// ============================================================
-#include "ui/window_manager.hpp"
-#include "ui/chat_panel.hpp"
-#include "ui/settings_panel.hpp"
-#include "ui/spellbook_screen.hpp"
-#include "ui/inventory_screen.hpp"
-#include "ui/ui_colors.hpp"
-#include "core/application.hpp"
-#include "core/logger.hpp"
-#include "rendering/renderer.hpp"
-#include "rendering/vk_context.hpp"
-#include "core/window.hpp"
-#include "game/game_handler.hpp"
-#include "pipeline/asset_manager.hpp"
-#include "pipeline/dbc_layout.hpp"
-#include "audio/audio_coordinator.hpp"
-#include "audio/ui_sound_manager.hpp"
-#include "audio/music_manager.hpp"
-#include <imgui.h>
-#include <imgui_internal.h>
-#include <algorithm>
-#include <cmath>
-#include <cstdio>
-#include <string>
-#include <fstream>
-
-namespace {
-    using namespace wowee::ui::colors;
-
-    // Abbreviated month names (indexed 0-11)
-    constexpr const char* kMonthAbbrev[12] = {
-        "Jan","Feb","Mar","Apr","May","Jun",
-        "Jul","Aug","Sep","Oct","Nov","Dec"
-    };
-
-    constexpr auto& kColorRed         = kRed;
-    constexpr auto& kColorGreen       = kGreen;
-    constexpr auto& kColorBrightGreen = kBrightGreen;
-    constexpr auto& kColorYellow      = kYellow;
-    constexpr auto& kColorGray        = kGray;
-    constexpr auto& kColorDarkGray    = kDarkGray;
-
-    // Common ImGui window flags for popup dialogs
-    const ImGuiWindowFlags kDialogFlags = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize;
-
-    // Build a WoW-format item link string for chat insertion.
-    std::string buildItemChatLink(uint32_t itemId, uint8_t quality, const std::string& name) {
-        static constexpr const char* kQualHex[] = {"9d9d9d","ffffff","1eff00","0070dd","a335ee","ff8000","e6cc80","e6cc80"};
-        uint8_t qi = quality < 8 ? quality : 1;
-        char buf[512];
-        snprintf(buf, sizeof(buf), "|cff%s|Hitem:%u:0:0:0:0:0:0:0:0|h[%s]|h|r",
-                 kQualHex[qi], itemId, name.c_str());
-        return buf;
-    }
-} // anonymous namespace
-
-namespace wowee {
-namespace ui {
-
-void WindowManager::renderLootWindow(game::GameHandler& gameHandler,
-                              InventoryScreen& inventoryScreen,
-                              ChatPanel& chatPanel) {
-    if (!gameHandler.isLootWindowOpen()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 150, 200), ImGuiCond_Appearing);
-    ImGui::SetNextWindowSize(ImVec2(300, 0), ImGuiCond_Always);
-
-    bool open = true;
-    if (ImGui::Begin("Loot", &open, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize)) {
-        const auto& loot = gameHandler.getCurrentLoot();
-
-        // Gold (auto-looted on open; shown for feedback)
-        if (loot.gold > 0) {
-            ImGui::TextDisabled("Gold:");
-            ImGui::SameLine(0, 4);
-            renderCoinsText(loot.getGold(), loot.getSilver(), loot.getCopper());
-            ImGui::Separator();
-        }
-
-        // Items with icons and labels
-        constexpr float iconSize = 32.0f;
-        int lootSlotClicked = -1;  // defer loot pickup to avoid iterator invalidation
-        for (const auto& item : loot.items) {
-            ImGui::PushID(item.slotIndex);
-
-            // Get item info for name and quality
-            const auto* info = gameHandler.getItemInfo(item.itemId);
-            std::string itemName;
-            game::ItemQuality quality = game::ItemQuality::COMMON;
-            if (info && !info->name.empty()) {
-                itemName = info->name;
-                quality = static_cast<game::ItemQuality>(info->quality);
-            } else {
-                itemName = "Item #" + std::to_string(item.itemId);
-            }
-            ImVec4 qColor = InventoryScreen::getQualityColor(quality);
-            bool startsQuest = (info && info->startQuestId != 0);
-
-            // Get item icon
-            uint32_t displayId = item.displayInfoId;
-            if (displayId == 0 && info) displayId = info->displayInfoId;
-            VkDescriptorSet iconTex = inventoryScreen.getItemIcon(displayId);
-
-            ImVec2 cursor = ImGui::GetCursorScreenPos();
-            float rowH = std::max(iconSize, ImGui::GetTextLineHeight() * 2.0f);
-
-            // Invisible selectable for click handling
-            if (ImGui::Selectable("##loot", false, 0, ImVec2(0, rowH))) {
-                if (ImGui::GetIO().KeyShift && info && !info->name.empty()) {
-                    // Shift-click: insert item link into chat
-                    std::string link = buildItemChatLink(info->entry, info->quality, info->name);
-                    chatPanel.insertChatLink(link);
-                } else {
-                    lootSlotClicked = item.slotIndex;
-                }
-            }
-            if (ImGui::IsItemClicked(ImGuiMouseButton_Right)) {
-                lootSlotClicked = item.slotIndex;
-            }
-            bool hovered = ImGui::IsItemHovered();
-
-            // Show item tooltip on hover
-            if (hovered && info && info->valid) {
-                inventoryScreen.renderItemTooltip(*info);
-            } else if (hovered && info && !info->name.empty()) {
-                // Item info received but not yet fully valid — show name at minimum
-                ImGui::SetTooltip("%s", info->name.c_str());
-            }
-
-            ImDrawList* drawList = ImGui::GetWindowDrawList();
-
-            // Draw hover highlight
-            if (hovered) {
-                drawList->AddRectFilled(cursor,
-                    ImVec2(cursor.x + ImGui::GetContentRegionAvail().x + iconSize + 8.0f,
-                           cursor.y + rowH),
-                    IM_COL32(255, 255, 255, 30));
-            }
-
-            // Draw icon
-            if (iconTex) {
-                drawList->AddImage((ImTextureID)(uintptr_t)iconTex,
-                    cursor, ImVec2(cursor.x + iconSize, cursor.y + iconSize));
-                drawList->AddRect(cursor, ImVec2(cursor.x + iconSize, cursor.y + iconSize),
-                    ImGui::ColorConvertFloat4ToU32(qColor));
-            } else {
-                drawList->AddRectFilled(cursor,
-                    ImVec2(cursor.x + iconSize, cursor.y + iconSize),
-                    IM_COL32(40, 40, 50, 200));
-                drawList->AddRect(cursor, ImVec2(cursor.x + iconSize, cursor.y + iconSize),
-                    IM_COL32(80, 80, 80, 200));
-            }
-            // Quest-starter: gold outer glow border + "!" badge on top-right corner
-            if (startsQuest) {
-                drawList->AddRect(ImVec2(cursor.x - 2.0f, cursor.y - 2.0f),
-                    ImVec2(cursor.x + iconSize + 2.0f, cursor.y + iconSize + 2.0f),
-                    IM_COL32(255, 210, 0, 210), 0.0f, 0, 2.0f);
-                drawList->AddText(ImVec2(cursor.x + iconSize - 10.0f, cursor.y + 1.0f),
-                    IM_COL32(255, 210, 0, 255), "!");
-            }
-
-            // Draw item name
-            float textX = cursor.x + iconSize + 6.0f;
-            float textY = cursor.y + 2.0f;
-            drawList->AddText(ImVec2(textX, textY),
-                ImGui::ColorConvertFloat4ToU32(qColor), itemName.c_str());
-
-            // Draw count or "Begins a Quest" label on second line
-            float secondLineY = textY + ImGui::GetTextLineHeight();
-            if (startsQuest) {
-                drawList->AddText(ImVec2(textX, secondLineY),
-                    IM_COL32(255, 210, 0, 255), "Begins a Quest");
-            } else if (item.count > 1) {
-                char countStr[32];
-                snprintf(countStr, sizeof(countStr), "x%u", item.count);
-                drawList->AddText(ImVec2(textX, secondLineY), IM_COL32(200, 200, 200, 220), countStr);
-            }
-
-            ImGui::PopID();
-        }
-
-        // Process deferred loot pickup (after loop to avoid iterator invalidation)
-        if (lootSlotClicked >= 0) {
-            if (gameHandler.hasMasterLootCandidates()) {
-                // Master looter: open popup to choose recipient
-                char popupId[32];
-                snprintf(popupId, sizeof(popupId), "##MLGive%d", lootSlotClicked);
-                ImGui::OpenPopup(popupId);
-            } else {
-                gameHandler.lootItem(static_cast<uint8_t>(lootSlotClicked));
-            }
-        }
-
-        // Master loot "Give to" popups
-        if (gameHandler.hasMasterLootCandidates()) {
-            for (const auto& item : loot.items) {
-                char popupId[32];
-                snprintf(popupId, sizeof(popupId), "##MLGive%d", item.slotIndex);
-                if (ImGui::BeginPopup(popupId)) {
-                    ImGui::TextDisabled("Give to:");
-                    ImGui::Separator();
-                    const auto& candidates = gameHandler.getMasterLootCandidates();
-                    for (uint64_t candidateGuid : candidates) {
-                        auto entity = gameHandler.getEntityManager().getEntity(candidateGuid);
-                        auto* unit = (entity && entity->isUnit()) ? static_cast<game::Unit*>(entity.get()) : nullptr;
-                        const char* cName = unit ? unit->getName().c_str() : nullptr;
-                        char nameBuf[64];
-                        if (!cName || cName[0] == '\0') {
-                            snprintf(nameBuf, sizeof(nameBuf), "Player 0x%llx",
-                                     static_cast<unsigned long long>(candidateGuid));
-                            cName = nameBuf;
-                        }
-                        if (ImGui::MenuItem(cName)) {
-                            gameHandler.lootMasterGive(item.slotIndex, candidateGuid);
-                            ImGui::CloseCurrentPopup();
-                        }
-                    }
-                    ImGui::EndPopup();
-                }
-            }
-        }
-
-        if (loot.items.empty() && loot.gold == 0) {
-            gameHandler.closeLoot();
-        }
-
-        ImGui::Spacing();
-        bool hasItems = !loot.items.empty();
-        if (hasItems) {
-            if (ImGui::Button("Loot All", ImVec2(-1, 0))) {
-                for (const auto& item : loot.items) {
-                    gameHandler.lootItem(item.slotIndex);
-                }
-            }
-            ImGui::Spacing();
-        }
-        if (ImGui::Button("Close", ImVec2(-1, 0))) {
-            gameHandler.closeLoot();
-        }
-    }
-    ImGui::End();
-
-    if (!open) {
-        gameHandler.closeLoot();
-    }
-}
-
-void WindowManager::renderGossipWindow(game::GameHandler& gameHandler,
-                               ChatPanel& chatPanel) {
-    if (!gameHandler.isGossipWindowOpen()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 200, 150), ImGuiCond_Appearing);
-    ImGui::SetNextWindowSize(ImVec2(400, 0), ImGuiCond_Always);
-
-    bool open = true;
-    if (ImGui::Begin("NPC Dialog", &open, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize)) {
-        const auto& gossip = gameHandler.getCurrentGossip();
-
-        // NPC name (from creature cache)
-        auto npcEntity = gameHandler.getEntityManager().getEntity(gossip.npcGuid);
-        if (npcEntity && npcEntity->getType() == game::ObjectType::UNIT) {
-            auto unit = std::static_pointer_cast<game::Unit>(npcEntity);
-            if (!unit->getName().empty()) {
-                ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.0f, 1.0f), "%s", unit->getName().c_str());
-                ImGui::Separator();
-            }
-        }
-
-        ImGui::Spacing();
-
-        // Gossip option icons - matches WoW GossipOptionIcon enum
-        static constexpr const char* gossipIcons[] = {
-            "[Chat]",          // 0 = GOSSIP_ICON_CHAT
-            "[Vendor]",        // 1 = GOSSIP_ICON_VENDOR
-            "[Taxi]",          // 2 = GOSSIP_ICON_TAXI
-            "[Trainer]",       // 3 = GOSSIP_ICON_TRAINER
-            "[Interact]",      // 4 = GOSSIP_ICON_INTERACT_1
-            "[Interact]",      // 5 = GOSSIP_ICON_INTERACT_2
-            "[Banker]",        // 6 = GOSSIP_ICON_MONEY_BAG (banker)
-            "[Chat]",          // 7 = GOSSIP_ICON_TALK
-            "[Tabard]",        // 8 = GOSSIP_ICON_TABARD
-            "[Battlemaster]",  // 9 = GOSSIP_ICON_BATTLE
-            "[Option]",        // 10 = GOSSIP_ICON_DOT
-        };
-
-        // Default text for server-sent gossip option placeholders
-        static const std::unordered_map<std::string, std::string> gossipPlaceholders = {
-            {"GOSSIP_OPTION_BANKER", "I would like to check my deposit box."},
-            {"GOSSIP_OPTION_AUCTIONEER", "I'd like to browse your auctions."},
-            {"GOSSIP_OPTION_VENDOR", "I want to browse your goods."},
-            {"GOSSIP_OPTION_TAXIVENDOR", "I'd like to fly."},
-            {"GOSSIP_OPTION_TRAINER", "I seek training."},
-            {"GOSSIP_OPTION_INNKEEPER", "Make this inn your home."},
-            {"GOSSIP_OPTION_SPIRITGUIDE", "Return me to life."},
-            {"GOSSIP_OPTION_SPIRITHEALER", "Bring me back to life."},
-            {"GOSSIP_OPTION_STABLEPET", "I'd like to stable my pet."},
-            {"GOSSIP_OPTION_ARMORER", "I need to repair my equipment."},
-            {"GOSSIP_OPTION_GOSSIP", "What can you tell me?"},
-            {"GOSSIP_OPTION_BATTLEFIELD", "I'd like to go to the battleground."},
-            {"GOSSIP_OPTION_TABARDDESIGNER", "I want to create a guild tabard."},
-            {"GOSSIP_OPTION_PETITIONER", "I want to create a guild."},
-        };
-
-        for (const auto& opt : gossip.options) {
-            ImGui::PushID(static_cast<int>(opt.id));
-
-            // Determine icon label - use text-based detection for shared icons
-            const char* icon = (opt.icon < 11) ? gossipIcons[opt.icon] : "[Option]";
-            if (opt.text == "GOSSIP_OPTION_AUCTIONEER") icon = "[Auctioneer]";
-            else if (opt.text == "GOSSIP_OPTION_BANKER") icon = "[Banker]";
-            else if (opt.text == "GOSSIP_OPTION_VENDOR") icon = "[Vendor]";
-            else if (opt.text == "GOSSIP_OPTION_TRAINER") icon = "[Trainer]";
-            else if (opt.text == "GOSSIP_OPTION_INNKEEPER") icon = "[Innkeeper]";
-            else if (opt.text == "GOSSIP_OPTION_STABLEPET") icon = "[Stable Master]";
-            else if (opt.text == "GOSSIP_OPTION_ARMORER") icon = "[Repair]";
-
-            // Resolve placeholder text from server
-            std::string displayText = opt.text;
-            auto placeholderIt = gossipPlaceholders.find(displayText);
-            if (placeholderIt != gossipPlaceholders.end()) {
-                displayText = placeholderIt->second;
-            }
-
-            std::string processedText = chatPanel.replaceGenderPlaceholders(displayText, gameHandler);
-            std::string label = std::string(icon) + " " + processedText;
-            if (ImGui::Selectable(label.c_str())) {
-                if (opt.text == "GOSSIP_OPTION_ARMORER") {
-                    gameHandler.setVendorCanRepair(true);
-                }
-                gameHandler.selectGossipOption(opt.id);
-            }
-            ImGui::PopID();
-        }
-
-        // Fallback: some spirit healers don't send gossip options.
-        if (gossip.options.empty() && gameHandler.isPlayerGhost()) {
-            bool isSpirit = false;
-            if (npcEntity && npcEntity->getType() == game::ObjectType::UNIT) {
-                auto unit = std::static_pointer_cast<game::Unit>(npcEntity);
-                std::string name = unit->getName();
-                std::transform(name.begin(), name.end(), name.begin(),
-                               [](unsigned char c){ return static_cast<char>(std::tolower(c)); });
-                if (name.find("spirit healer") != std::string::npos ||
-                    name.find("spirit guide") != std::string::npos) {
-                    isSpirit = true;
-                }
-            }
-            if (isSpirit) {
-                if (ImGui::Selectable("[Spiritguide] Return to Graveyard")) {
-                    gameHandler.activateSpiritHealer(gossip.npcGuid);
-                    gameHandler.closeGossip();
-                }
-            }
-        }
-
-        // Quest items
-        if (!gossip.quests.empty()) {
-            ImGui::Spacing();
-            ImGui::Separator();
-            ImGui::TextColored(kColorYellow, "Quests:");
-            for (size_t qi = 0; qi < gossip.quests.size(); qi++) {
-                const auto& quest = gossip.quests[qi];
-                ImGui::PushID(static_cast<int>(qi));
-
-                // Determine icon and color based on QuestGiverStatus stored in questIcon
-                // 5=INCOMPLETE (gray?), 6=REWARD_REP (yellow?), 7=AVAILABLE_LOW (gray!),
-                // 8=AVAILABLE (yellow!), 10=REWARD (yellow?)
-                const char* statusIcon = "!";
-                ImVec4 statusColor = kColorYellow; // yellow
-                switch (quest.questIcon) {
-                    case 5:  // INCOMPLETE — in progress but not done
-                        statusIcon = "?";
-                        statusColor = colors::kMediumGray; // gray
-                        break;
-                    case 6:  // REWARD_REP — repeatable, ready to turn in
-                    case 10: // REWARD — ready to turn in
-                        statusIcon = "?";
-                        statusColor = kColorYellow; // yellow
-                        break;
-                    case 7:  // AVAILABLE_LOW — available but gray (low-level)
-                        statusIcon = "!";
-                        statusColor = colors::kMediumGray; // gray
-                        break;
-                    default: // AVAILABLE (8) and any others
-                        statusIcon = "!";
-                        statusColor = kColorYellow; // yellow
-                        break;
-                }
-
-                // Render: colored icon glyph then [Lv] Title
-                ImGui::TextColored(statusColor, "%s", statusIcon);
-                ImGui::SameLine(0, 4);
-                char qlabel[256];
-                snprintf(qlabel, sizeof(qlabel), "[%d] %s", quest.questLevel, quest.title.c_str());
-                ImGui::PushStyleColor(ImGuiCol_Text, statusColor);
-                if (ImGui::Selectable(qlabel)) {
-                    gameHandler.selectGossipQuest(quest.questId);
-                }
-                ImGui::PopStyleColor();
-                ImGui::PopID();
-            }
-        }
-
-        ImGui::Spacing();
-        if (ImGui::Button("Close", ImVec2(-1, 0))) {
-            gameHandler.closeGossip();
-        }
-    }
-    ImGui::End();
-
-    if (!open) {
-        gameHandler.closeGossip();
-    }
-}
-
-void WindowManager::renderQuestDetailsWindow(game::GameHandler& gameHandler,
-                                          ChatPanel& chatPanel,
-                                          InventoryScreen& inventoryScreen) {
-    if (!gameHandler.isQuestDetailsOpen()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 225, screenH / 2 - 200), ImGuiCond_Appearing);
-    ImGui::SetNextWindowSize(ImVec2(450, 400), ImGuiCond_Appearing);
-
-    bool open = true;
-    const auto& quest = gameHandler.getQuestDetails();
-    std::string processedTitle = chatPanel.replaceGenderPlaceholders(quest.title, gameHandler);
-    if (ImGui::Begin(processedTitle.c_str(), &open)) {
-        // Quest description
-        if (!quest.details.empty()) {
-            std::string processedDetails = chatPanel.replaceGenderPlaceholders(quest.details, gameHandler);
-            ImGui::TextWrapped("%s", processedDetails.c_str());
-        }
-
-        // Objectives
-        if (!quest.objectives.empty()) {
-            ImGui::Spacing();
-            ImGui::Separator();
-            ImGui::TextColored(ui::colors::kTooltipGold, "Objectives:");
-            std::string processedObjectives = chatPanel.replaceGenderPlaceholders(quest.objectives, gameHandler);
-            ImGui::TextWrapped("%s", processedObjectives.c_str());
-        }
-
-        // Choice reward items (player picks one)
-        auto renderQuestRewardItem = [&](const game::QuestRewardItem& ri) {
-            gameHandler.ensureItemInfo(ri.itemId);
-            auto* info = gameHandler.getItemInfo(ri.itemId);
-            VkDescriptorSet iconTex = VK_NULL_HANDLE;
-            uint32_t dispId = ri.displayInfoId;
-            if (info && info->valid && info->displayInfoId != 0) dispId = info->displayInfoId;
-            if (dispId != 0) iconTex = inventoryScreen.getItemIcon(dispId);
-
-            std::string label;
-            ImVec4 nameCol = ui::colors::kWhite;
-            if (info && info->valid && !info->name.empty()) {
-                label = info->name;
-                nameCol = InventoryScreen::getQualityColor(static_cast<game::ItemQuality>(info->quality));
-            } else {
-                label = "Item " + std::to_string(ri.itemId);
-            }
-            if (ri.count > 1) label += " x" + std::to_string(ri.count);
-
-            if (iconTex) {
-                ImGui::Image((void*)(intptr_t)iconTex, ImVec2(18, 18));
-                if (ImGui::IsItemHovered() && info && info->valid)
-                    inventoryScreen.renderItemTooltip(*info);
-                ImGui::SameLine();
-            }
-            ImGui::TextColored(nameCol, "  %s", label.c_str());
-            if (ImGui::IsItemHovered() && info && info->valid)
-                inventoryScreen.renderItemTooltip(*info);
-            if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left) &&
-                ImGui::GetIO().KeyShift && info && info->valid && !info->name.empty()) {
-                std::string link = buildItemChatLink(info->entry, info->quality, info->name);
-                chatPanel.insertChatLink(link);
-            }
-        };
-
-        if (!quest.rewardChoiceItems.empty()) {
-            ImGui::Spacing();
-            ImGui::Separator();
-            ImGui::TextColored(ui::colors::kTooltipGold, "Choose one reward:");
-            for (const auto& ri : quest.rewardChoiceItems) {
-                renderQuestRewardItem(ri);
-            }
-        }
-
-        // Fixed reward items (always given)
-        if (!quest.rewardItems.empty()) {
-            ImGui::Spacing();
-            ImGui::Separator();
-            ImGui::TextColored(ui::colors::kTooltipGold, "You will receive:");
-            for (const auto& ri : quest.rewardItems) {
-                renderQuestRewardItem(ri);
-            }
-        }
-
-        // XP and money rewards
-        if (quest.rewardXp > 0 || quest.rewardMoney > 0) {
-            ImGui::Spacing();
-            ImGui::Separator();
-            ImGui::TextColored(ui::colors::kTooltipGold, "Rewards:");
-            if (quest.rewardXp > 0) {
-                ImGui::Text("  %u experience", quest.rewardXp);
-            }
-            if (quest.rewardMoney > 0) {
-                ImGui::TextDisabled("  Money:"); ImGui::SameLine(0, 4);
-                renderCoinsFromCopper(quest.rewardMoney);
-            }
-        }
-
-        if (quest.suggestedPlayers > 1) {
-            ImGui::TextColored(ui::colors::kLightGray,
-                "Suggested players: %u", quest.suggestedPlayers);
-        }
-
-        // Accept / Decline buttons
-        ImGui::Spacing();
-        ImGui::Separator();
-        ImGui::Spacing();
-        float buttonW = (ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x) * 0.5f;
-        if (ImGui::Button("Accept", ImVec2(buttonW, 0))) {
-            gameHandler.acceptQuest();
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Decline", ImVec2(buttonW, 0))) {
-            gameHandler.declineQuest();
-        }
-    }
-    ImGui::End();
-
-    if (!open) {
-        gameHandler.declineQuest();
-    }
-}
-
-void WindowManager::renderQuestRequestItemsWindow(game::GameHandler& gameHandler,
-                                               ChatPanel& chatPanel,
-                                               InventoryScreen& inventoryScreen) {
-    if (!gameHandler.isQuestRequestItemsOpen()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 225, screenH / 2 - 200), ImGuiCond_Appearing);
-    ImGui::SetNextWindowSize(ImVec2(450, 350), ImGuiCond_Appearing);
-
-    bool open = true;
-    const auto& quest = gameHandler.getQuestRequestItems();
-    auto countItemInInventory = [&](uint32_t itemId) -> uint32_t {
-        const auto& inv = gameHandler.getInventory();
-        uint32_t total = 0;
-        for (int i = 0; i < inv.getBackpackSize(); ++i) {
-            const auto& slot = inv.getBackpackSlot(i);
-            if (!slot.empty() && slot.item.itemId == itemId) total += slot.item.stackCount;
-        }
-        for (int bag = 0; bag < game::Inventory::NUM_BAG_SLOTS; ++bag) {
-            int bagSize = inv.getBagSize(bag);
-            for (int s = 0; s < bagSize; ++s) {
-                const auto& slot = inv.getBagSlot(bag, s);
-                if (!slot.empty() && slot.item.itemId == itemId) total += slot.item.stackCount;
-            }
-        }
-        return total;
-    };
-
-    std::string processedTitle = chatPanel.replaceGenderPlaceholders(quest.title, gameHandler);
-    if (ImGui::Begin(processedTitle.c_str(), &open, ImGuiWindowFlags_NoCollapse)) {
-        if (!quest.completionText.empty()) {
-            std::string processedCompletionText = chatPanel.replaceGenderPlaceholders(quest.completionText, gameHandler);
-            ImGui::TextWrapped("%s", processedCompletionText.c_str());
-        }
-
-        // Required items
-        if (!quest.requiredItems.empty()) {
-            ImGui::Spacing();
-            ImGui::Separator();
-            ImGui::TextColored(ui::colors::kTooltipGold, "Required Items:");
-            for (const auto& item : quest.requiredItems) {
-                uint32_t have = countItemInInventory(item.itemId);
-                bool enough = have >= item.count;
-                ImVec4 textCol = enough ? colors::kLightGreen : ImVec4(1.0f, 0.6f, 0.6f, 1.0f);
-                auto* info = gameHandler.getItemInfo(item.itemId);
-                const char* name = (info && info->valid) ? info->name.c_str() : nullptr;
-
-                // Show icon if display info is available
-                uint32_t dispId = item.displayInfoId;
-                if (info && info->valid && info->displayInfoId != 0) dispId = info->displayInfoId;
-                if (dispId != 0) {
-                    VkDescriptorSet iconTex = inventoryScreen.getItemIcon(dispId);
-                    if (iconTex) {
-                        ImGui::Image((ImTextureID)(uintptr_t)iconTex, ImVec2(18, 18));
-                        ImGui::SameLine();
-                    }
-                }
-                if (name && *name) {
-                    ImGui::TextColored(textCol, "%s  %u/%u", name, have, item.count);
-                } else {
-                    ImGui::TextColored(textCol, "Item %u  %u/%u", item.itemId, have, item.count);
-                }
-                if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left) &&
-                    ImGui::GetIO().KeyShift && info && info->valid && !info->name.empty()) {
-                    std::string link = buildItemChatLink(info->entry, info->quality, info->name);
-                    chatPanel.insertChatLink(link);
-                }
-            }
-        }
-
-        if (quest.requiredMoney > 0) {
-            ImGui::Spacing();
-            ImGui::TextDisabled("Required money:"); ImGui::SameLine(0, 4);
-            renderCoinsFromCopper(quest.requiredMoney);
-        }
-
-        // Complete / Cancel buttons
-        ImGui::Spacing();
-        ImGui::Separator();
-        ImGui::Spacing();
-        float buttonW = (ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x) * 0.5f;
-        if (ImGui::Button("Complete Quest", ImVec2(buttonW, 0))) {
-            gameHandler.completeQuest();
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Cancel", ImVec2(buttonW, 0))) {
-            gameHandler.closeQuestRequestItems();
-        }
-
-        if (!quest.isCompletable()) {
-            ImGui::TextDisabled("Server flagged this quest as incomplete; completion will be server-validated.");
-        }
-    }
-    ImGui::End();
-
-    if (!open) {
-        gameHandler.closeQuestRequestItems();
-    }
-}
-
-void WindowManager::renderQuestOfferRewardWindow(game::GameHandler& gameHandler,
-                                              ChatPanel& chatPanel,
-                                              InventoryScreen& inventoryScreen) {
-    if (!gameHandler.isQuestOfferRewardOpen()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 225, screenH / 2 - 200), ImGuiCond_Appearing);
-    ImGui::SetNextWindowSize(ImVec2(450, 400), ImGuiCond_Appearing);
-
-    bool open = true;
-    const auto& quest = gameHandler.getQuestOfferReward();
-    static int selectedChoice = -1;
-
-    // Auto-select if only one choice reward
-    if (quest.choiceRewards.size() == 1 && selectedChoice == -1) {
-        selectedChoice = 0;
-    }
-
-    std::string processedTitle = chatPanel.replaceGenderPlaceholders(quest.title, gameHandler);
-    if (ImGui::Begin(processedTitle.c_str(), &open, ImGuiWindowFlags_NoCollapse)) {
-        if (!quest.rewardText.empty()) {
-            std::string processedRewardText = chatPanel.replaceGenderPlaceholders(quest.rewardText, gameHandler);
-            ImGui::TextWrapped("%s", processedRewardText.c_str());
-        }
-
-        // Choice rewards (pick one)
-        // Trigger item info fetch for all reward items
-        for (const auto& item : quest.choiceRewards) gameHandler.ensureItemInfo(item.itemId);
-        for (const auto& item : quest.fixedRewards)  gameHandler.ensureItemInfo(item.itemId);
-
-        // Helper: resolve icon tex + quality color for a reward item
-        auto resolveRewardItemVis = [&](const game::QuestRewardItem& ri)
-            -> std::pair<VkDescriptorSet, ImVec4>
-        {
-            auto* info = gameHandler.getItemInfo(ri.itemId);
-            uint32_t dispId = ri.displayInfoId;
-            if (info && info->valid && info->displayInfoId != 0) dispId = info->displayInfoId;
-            VkDescriptorSet iconTex = dispId ? inventoryScreen.getItemIcon(dispId) : VK_NULL_HANDLE;
-            ImVec4 col = (info && info->valid)
-                ? InventoryScreen::getQualityColor(static_cast<game::ItemQuality>(info->quality))
-                : ui::colors::kWhite;
-            return {iconTex, col};
-        };
-
-        // Helper: show full item tooltip (reuses InventoryScreen's rich tooltip)
-        auto rewardItemTooltip = [&](const game::QuestRewardItem& ri, ImVec4 /*nameCol*/) {
-            auto* info = gameHandler.getItemInfo(ri.itemId);
-            if (!info || !info->valid) {
-                ImGui::BeginTooltip();
-                ImGui::TextDisabled("Loading item data...");
-                ImGui::EndTooltip();
-                return;
-            }
-            inventoryScreen.renderItemTooltip(*info);
-        };
-
-        if (!quest.choiceRewards.empty()) {
-            ImGui::Spacing();
-            ImGui::Separator();
-            ImGui::TextColored(ui::colors::kTooltipGold, "Choose a reward:");
-
-            for (size_t i = 0; i < quest.choiceRewards.size(); ++i) {
-                const auto& item = quest.choiceRewards[i];
-                auto* info = gameHandler.getItemInfo(item.itemId);
-                auto [iconTex, qualityColor] = resolveRewardItemVis(item);
-
-                std::string label;
-                if (info && info->valid && !info->name.empty()) label = info->name;
-                else label = "Item " + std::to_string(item.itemId);
-                if (item.count > 1) label += " x" + std::to_string(item.count);
-
-                bool selected = (selectedChoice == static_cast<int>(i));
-                ImGui::PushID(static_cast<int>(i));
-
-                // Icon then selectable on same line
-                if (iconTex) {
-                    ImGui::Image((void*)(intptr_t)iconTex, ImVec2(20, 20));
-                    if (ImGui::IsItemHovered()) rewardItemTooltip(item, qualityColor);
-                    ImGui::SameLine();
-                }
-                ImGui::PushStyleColor(ImGuiCol_Text, qualityColor);
-                if (ImGui::Selectable(label.c_str(), selected, 0, ImVec2(0, 20))) {
-                    if (ImGui::GetIO().KeyShift && info && info->valid && !info->name.empty()) {
-                        std::string link = buildItemChatLink(info->entry, info->quality, info->name);
-                        chatPanel.insertChatLink(link);
-                    } else {
-                        selectedChoice = static_cast<int>(i);
-                    }
-                }
-                ImGui::PopStyleColor();
-                if (ImGui::IsItemHovered()) rewardItemTooltip(item, qualityColor);
-
-                ImGui::PopID();
-            }
-        }
-
-        // Fixed rewards (always given)
-        if (!quest.fixedRewards.empty()) {
-            ImGui::Spacing();
-            ImGui::Separator();
-            ImGui::TextColored(ui::colors::kTooltipGold, "You will also receive:");
-            for (const auto& item : quest.fixedRewards) {
-                auto* info = gameHandler.getItemInfo(item.itemId);
-                auto [iconTex, qualityColor] = resolveRewardItemVis(item);
-
-                std::string label;
-                if (info && info->valid && !info->name.empty()) label = info->name;
-                else label = "Item " + std::to_string(item.itemId);
-                if (item.count > 1) label += " x" + std::to_string(item.count);
-
-                if (iconTex) {
-                    ImGui::Image((void*)(intptr_t)iconTex, ImVec2(18, 18));
-                    if (ImGui::IsItemHovered()) rewardItemTooltip(item, qualityColor);
-                    ImGui::SameLine();
-                }
-                ImGui::TextColored(qualityColor, "  %s", label.c_str());
-                if (ImGui::IsItemHovered()) rewardItemTooltip(item, qualityColor);
-                if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left) &&
-                    ImGui::GetIO().KeyShift && info && info->valid && !info->name.empty()) {
-                    std::string link = buildItemChatLink(info->entry, info->quality, info->name);
-                    chatPanel.insertChatLink(link);
-                }
-            }
-        }
-
-        // Money / XP rewards
-        if (quest.rewardXp > 0 || quest.rewardMoney > 0) {
-            ImGui::Spacing();
-            ImGui::Separator();
-            ImGui::TextColored(ui::colors::kTooltipGold, "Rewards:");
-            if (quest.rewardXp > 0)
-                ImGui::Text("  %u experience", quest.rewardXp);
-            if (quest.rewardMoney > 0) {
-                ImGui::TextDisabled("  Money:"); ImGui::SameLine(0, 4);
-                renderCoinsFromCopper(quest.rewardMoney);
-            }
-        }
-
-        // Complete button
-        ImGui::Spacing();
-        ImGui::Separator();
-        ImGui::Spacing();
-        float buttonW = (ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x) * 0.5f;
-
-        bool canComplete = quest.choiceRewards.empty() || selectedChoice >= 0;
-        if (!canComplete) ImGui::BeginDisabled();
-        if (ImGui::Button("Complete Quest", ImVec2(buttonW, 0))) {
-            uint32_t rewardIdx = 0;
-            if (!quest.choiceRewards.empty() && selectedChoice >= 0 &&
-                selectedChoice < static_cast<int>(quest.choiceRewards.size())) {
-                // Server expects the original slot index from its fixed-size reward array.
-                rewardIdx = quest.choiceRewards[static_cast<size_t>(selectedChoice)].choiceSlot;
-            }
-            gameHandler.chooseQuestReward(rewardIdx);
-            selectedChoice = -1;
-        }
-        if (!canComplete) ImGui::EndDisabled();
-
-        ImGui::SameLine();
-        if (ImGui::Button("Cancel", ImVec2(buttonW, 0))) {
-            gameHandler.closeQuestOfferReward();
-            selectedChoice = -1;
-        }
-    }
-    ImGui::End();
-
-    if (!open) {
-        gameHandler.closeQuestOfferReward();
-        selectedChoice = -1;
-    }
-}
-
-void WindowManager::loadExtendedCostDBC() {
-    if (extendedCostDbLoaded_) return;
-    extendedCostDbLoaded_ = true;
-    auto* am = services_.assetManager;
-    if (!am || !am->isInitialized()) return;
-    auto dbc = am->loadDBC("ItemExtendedCost.dbc");
-    if (!dbc || !dbc->isLoaded()) return;
-    // WotLK ItemExtendedCost.dbc: field 0=ID, 1=honorPoints, 2=arenaPoints,
-    // 3=arenaSlotRestrictions, 4-8=itemId[5], 9-13=itemCount[5], 14=reqRating, 15=purchaseGroup
-    for (uint32_t i = 0; i < dbc->getRecordCount(); ++i) {
-        uint32_t id = dbc->getUInt32(i, 0);
-        if (id == 0) continue;
-        ExtendedCostEntry e;
-        e.honorPoints = dbc->getUInt32(i, 1);
-        e.arenaPoints = dbc->getUInt32(i, 2);
-        for (int j = 0; j < 5; ++j) {
-            e.itemId[j]    = dbc->getUInt32(i, 4 + j);
-            e.itemCount[j] = dbc->getUInt32(i, 9 + j);
-        }
-        extendedCostCache_[id] = e;
-    }
-    LOG_INFO("ItemExtendedCost.dbc: loaded ", extendedCostCache_.size(), " entries");
-}
-
-std::string WindowManager::formatExtendedCost(uint32_t extendedCostId, game::GameHandler& gameHandler) {
-    loadExtendedCostDBC();
-    auto it = extendedCostCache_.find(extendedCostId);
-    if (it == extendedCostCache_.end()) return "[Tokens]";
-    const auto& e = it->second;
-    std::string result;
-    if (e.honorPoints > 0) {
-        result += std::to_string(e.honorPoints) + " Honor";
-    }
-    if (e.arenaPoints > 0) {
-        if (!result.empty()) result += ", ";
-        result += std::to_string(e.arenaPoints) + " Arena";
-    }
-    for (int j = 0; j < 5; ++j) {
-        if (e.itemId[j] == 0 || e.itemCount[j] == 0) continue;
-        if (!result.empty()) result += ", ";
-        gameHandler.ensureItemInfo(e.itemId[j]);  // query if not cached
-        const auto* itemInfo = gameHandler.getItemInfo(e.itemId[j]);
-        if (itemInfo && itemInfo->valid && !itemInfo->name.empty()) {
-            result += std::to_string(e.itemCount[j]) + "x " + itemInfo->name;
-        } else {
-            result += std::to_string(e.itemCount[j]) + "x Item#" + std::to_string(e.itemId[j]);
-        }
-    }
-    return result.empty() ? "[Tokens]" : result;
-}
-
-void WindowManager::renderVendorWindow(game::GameHandler& gameHandler,
-                               InventoryScreen& inventoryScreen,
-                               ChatPanel& chatPanel) {
-    if (!gameHandler.isVendorWindowOpen()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 200, 100), ImGuiCond_Appearing);
-    ImGui::SetNextWindowSize(ImVec2(450, 400), ImGuiCond_Appearing);
-
-    bool open = true;
-    if (ImGui::Begin("Vendor", &open)) {
-        const auto& vendor = gameHandler.getVendorItems();
-
-        // Show player money
-        uint64_t money = gameHandler.getMoneyCopper();
-        ImGui::TextDisabled("Your money:"); ImGui::SameLine(0, 4);
-        renderCoinsFromCopper(money);
-
-        if (vendor.canRepair) {
-            uint32_t repairCost = gameHandler.estimateRepairAllCost();
-            ImGui::SameLine();
-            ImGui::SetCursorPosX(ImGui::GetCursorPosX() + 8.0f);
-            if (ImGui::SmallButton("Repair All")) {
-                gameHandler.repairAll(vendor.vendorGuid, false);
-            }
-            if (repairCost > 0) {
-                ImGui::SameLine(0, 4);
-                renderCoinsFromCopper(repairCost);
-            }
-            if (ImGui::IsItemHovered()) {
-                // Show durability summary of all equipment
-                const auto& inv = gameHandler.getInventory();
-                int damagedCount = 0;
-                int brokenCount = 0;
-                for (int s = 0; s < static_cast<int>(game::EquipSlot::BAG1); s++) {
-                    const auto& slot = inv.getEquipSlot(static_cast<game::EquipSlot>(s));
-                    if (slot.empty() || slot.item.maxDurability == 0) continue;
-                    if (slot.item.curDurability == 0) brokenCount++;
-                    else if (slot.item.curDurability < slot.item.maxDurability) damagedCount++;
-                }
-                if (brokenCount > 0)
-                    ImGui::SetTooltip("Repair all equipped items\n%d damaged, %d broken", damagedCount, brokenCount);
-                else if (damagedCount > 0)
-                    ImGui::SetTooltip("Repair all equipped items\n%d item%s need repair", damagedCount, damagedCount > 1 ? "s" : "");
-                else
-                    ImGui::SetTooltip("All equipment is in good condition");
-            }
-            if (gameHandler.isInGuild()) {
-                ImGui::SameLine();
-                if (ImGui::SmallButton("Repair (Guild)")) {
-                    gameHandler.repairAll(vendor.vendorGuid, true);
-                }
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Repair all items using guild bank funds");
-                }
-            }
-        }
-        ImGui::Separator();
-
-        ImGui::TextColored(ui::colors::kLightGray, "Right-click bag items to sell");
-
-        // Count grey (POOR quality) sellable items across backpack and bags
-        const auto& inv = gameHandler.getInventory();
-        int junkCount = 0;
-        for (int i = 0; i < inv.getBackpackSize(); ++i) {
-            const auto& sl = inv.getBackpackSlot(i);
-            if (!sl.empty() && sl.item.quality == game::ItemQuality::POOR && sl.item.sellPrice > 0)
-                ++junkCount;
-        }
-        for (int b = 0; b < game::Inventory::NUM_BAG_SLOTS; ++b) {
-            for (int s = 0; s < inv.getBagSize(b); ++s) {
-                const auto& sl = inv.getBagSlot(b, s);
-                if (!sl.empty() && sl.item.quality == game::ItemQuality::POOR && sl.item.sellPrice > 0)
-                    ++junkCount;
-            }
-        }
-        if (junkCount > 0) {
-            char junkLabel[64];
-            snprintf(junkLabel, sizeof(junkLabel), "Sell All Junk (%d item%s)",
-                     junkCount, junkCount == 1 ? "" : "s");
-            if (ImGui::Button(junkLabel, ImVec2(-1, 0))) {
-                for (int i = 0; i < inv.getBackpackSize(); ++i) {
-                    const auto& sl = inv.getBackpackSlot(i);
-                    if (!sl.empty() && sl.item.quality == game::ItemQuality::POOR && sl.item.sellPrice > 0)
-                        gameHandler.sellItemBySlot(i);
-                }
-                for (int b = 0; b < game::Inventory::NUM_BAG_SLOTS; ++b) {
-                    for (int s = 0; s < inv.getBagSize(b); ++s) {
-                        const auto& sl = inv.getBagSlot(b, s);
-                        if (!sl.empty() && sl.item.quality == game::ItemQuality::POOR && sl.item.sellPrice > 0)
-                            gameHandler.sellItemInBag(b, s);
-                    }
-                }
-            }
-        }
-        ImGui::Separator();
-
-        const auto& buyback = gameHandler.getBuybackItems();
-        if (!buyback.empty()) {
-            ImGui::TextColored(ui::colors::kTooltipGold, "Buy Back");
-            if (ImGui::BeginTable("BuybackTable", 4, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg)) {
-                ImGui::TableSetupColumn("##icon", ImGuiTableColumnFlags_WidthFixed, 22.0f);
-                ImGui::TableSetupColumn("Item", ImGuiTableColumnFlags_WidthStretch);
-                ImGui::TableSetupColumn("Price", ImGuiTableColumnFlags_WidthFixed, 110.0f);
-                ImGui::TableSetupColumn("Buy", ImGuiTableColumnFlags_WidthFixed, 62.0f);
-                ImGui::TableHeadersRow();
-                // Show all buyback items (most recently sold first)
-                for (int i = 0; i < static_cast<int>(buyback.size()); ++i) {
-                    const auto& entry = buyback[i];
-                    gameHandler.ensureItemInfo(entry.item.itemId);
-                    auto* bbInfo = gameHandler.getItemInfo(entry.item.itemId);
-                    uint32_t sellPrice = entry.item.sellPrice;
-                    if (sellPrice == 0) {
-                        if (bbInfo && bbInfo->valid) sellPrice = bbInfo->sellPrice;
-                    }
-                    uint64_t price = static_cast<uint64_t>(sellPrice) *
-                                     static_cast<uint64_t>(entry.count > 0 ? entry.count : 1);
-                    uint32_t g = static_cast<uint32_t>(price / 10000);
-                    uint32_t s = static_cast<uint32_t>((price / 100) % 100);
-                    uint32_t c = static_cast<uint32_t>(price % 100);
-                    bool canAfford = money >= price;
-
-                    ImGui::TableNextRow();
-                    ImGui::PushID(8000 + i);
-                    ImGui::TableSetColumnIndex(0);
-                    {
-                        uint32_t dispId = entry.item.displayInfoId;
-                        if (bbInfo && bbInfo->valid && bbInfo->displayInfoId != 0) dispId = bbInfo->displayInfoId;
-                        if (dispId != 0) {
-                            VkDescriptorSet iconTex = inventoryScreen.getItemIcon(dispId);
-                            if (iconTex) ImGui::Image((ImTextureID)(uintptr_t)iconTex, ImVec2(18, 18));
-                        }
-                    }
-                    ImGui::TableSetColumnIndex(1);
-                    game::ItemQuality bbQuality = entry.item.quality;
-                    if (bbInfo && bbInfo->valid) bbQuality = static_cast<game::ItemQuality>(bbInfo->quality);
-                    ImVec4 bbQc = InventoryScreen::getQualityColor(bbQuality);
-                    const char* name = entry.item.name.empty() ? "Unknown Item" : entry.item.name.c_str();
-                    if (entry.count > 1) {
-                        ImGui::TextColored(bbQc, "%s x%u", name, entry.count);
-                    } else {
-                        ImGui::TextColored(bbQc, "%s", name);
-                    }
-                    if (ImGui::IsItemHovered() && bbInfo && bbInfo->valid)
-                        inventoryScreen.renderItemTooltip(*bbInfo);
-                    ImGui::TableSetColumnIndex(2);
-                    if (canAfford) {
-                        renderCoinsText(g, s, c);
-                    } else {
-                        ImGui::TextColored(kColorRed, "%ug %us %uc", g, s, c);
-                    }
-                    ImGui::TableSetColumnIndex(3);
-                    if (!canAfford) ImGui::BeginDisabled();
-                    char bbLabel[32];
-                    snprintf(bbLabel, sizeof(bbLabel), "Buy Back##bb%d", i);
-                    if (ImGui::SmallButton(bbLabel)) {
-                        gameHandler.buyBackItem(static_cast<uint32_t>(i));
-                    }
-                    if (!canAfford) ImGui::EndDisabled();
-                    ImGui::PopID();
-                }
-                ImGui::EndTable();
-            }
-            ImGui::Separator();
-        }
-
-        if (vendor.items.empty()) {
-            ImGui::TextDisabled("This vendor has nothing for sale.");
-        } else {
-            // Search + quantity controls on one row
-            ImGui::SetNextItemWidth(200.0f);
-            ImGui::InputTextWithHint("##VendorSearch", "Search...", vendorSearchFilter_, sizeof(vendorSearchFilter_));
-            ImGui::SameLine();
-            ImGui::Text("Qty:");
-            ImGui::SameLine();
-            ImGui::SetNextItemWidth(60.0f);
-            static int vendorBuyQty = 1;
-            ImGui::InputInt("##VendorQty", &vendorBuyQty, 1, 5);
-            if (vendorBuyQty < 1) vendorBuyQty = 1;
-            if (vendorBuyQty > 99) vendorBuyQty = 99;
-            ImGui::Spacing();
-
-            if (ImGui::BeginTable("VendorTable", 5, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
-                ImGui::TableSetupColumn("##icon", ImGuiTableColumnFlags_WidthFixed, 22.0f);
-                ImGui::TableSetupColumn("Item", ImGuiTableColumnFlags_WidthStretch);
-                ImGui::TableSetupColumn("Price", ImGuiTableColumnFlags_WidthFixed, 120.0f);
-                ImGui::TableSetupColumn("Stock", ImGuiTableColumnFlags_WidthFixed, 60.0f);
-                ImGui::TableSetupColumn("Buy", ImGuiTableColumnFlags_WidthFixed, 50.0f);
-                ImGui::TableHeadersRow();
-
-                std::string vendorFilter(vendorSearchFilter_);
-                // Lowercase filter for case-insensitive match
-                for (char& c : vendorFilter) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-
-                for (int vi = 0; vi < static_cast<int>(vendor.items.size()); ++vi) {
-                    const auto& item = vendor.items[vi];
-
-                    // Proactively ensure vendor item info is loaded
-                    gameHandler.ensureItemInfo(item.itemId);
-                    auto* info = gameHandler.getItemInfo(item.itemId);
-
-                    // Apply search filter
-                    if (!vendorFilter.empty()) {
-                        std::string nameLC = info && info->valid ? info->name : ("Item " + std::to_string(item.itemId));
-                        for (char& c : nameLC) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        if (nameLC.find(vendorFilter) == std::string::npos) {
-                            ImGui::PushID(vi);
-                            ImGui::PopID();
-                            continue;
-                        }
-                    }
-
-                    ImGui::TableNextRow();
-                    ImGui::PushID(vi);
-
-                    // Icon column
-                    ImGui::TableSetColumnIndex(0);
-                    {
-                        uint32_t dispId = item.displayInfoId;
-                        if (info && info->valid && info->displayInfoId != 0) dispId = info->displayInfoId;
-                        if (dispId != 0) {
-                            VkDescriptorSet iconTex = inventoryScreen.getItemIcon(dispId);
-                            if (iconTex) ImGui::Image((ImTextureID)(uintptr_t)iconTex, ImVec2(18, 18));
-                        }
-                    }
-
-                    // Name column
-                    ImGui::TableSetColumnIndex(1);
-                    if (info && info->valid) {
-                        ImVec4 qc = InventoryScreen::getQualityColor(static_cast<game::ItemQuality>(info->quality));
-                        ImGui::TextColored(qc, "%s", info->name.c_str());
-                        if (ImGui::IsItemHovered()) {
-                            inventoryScreen.renderItemTooltip(*info, &gameHandler.getInventory());
-                        }
-                        // Shift-click: insert item link into chat
-                        if (ImGui::IsItemClicked() && ImGui::GetIO().KeyShift) {
-                            std::string link = buildItemChatLink(info->entry, info->quality, info->name);
-                            chatPanel.insertChatLink(link);
-                        }
-                    } else {
-                        ImGui::Text("Item %u", item.itemId);
-                    }
-
-                    ImGui::TableSetColumnIndex(2);
-                    if (item.buyPrice == 0 && item.extendedCost != 0) {
-                        // Token-only item — show detailed cost from ItemExtendedCost.dbc
-                        std::string costStr = formatExtendedCost(item.extendedCost, gameHandler);
-                        ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "%s", costStr.c_str());
-                    } else {
-                        uint32_t g = item.buyPrice / 10000;
-                        uint32_t s = (item.buyPrice / 100) % 100;
-                        uint32_t c = item.buyPrice % 100;
-                        bool canAfford = money >= item.buyPrice;
-                        if (canAfford) {
-                            renderCoinsText(g, s, c);
-                        } else {
-                            ImGui::TextColored(kColorRed, "%ug %us %uc", g, s, c);
-                        }
-                        // Show additional token cost if both gold and tokens are required
-                        if (item.extendedCost != 0) {
-                            std::string costStr = formatExtendedCost(item.extendedCost, gameHandler);
-                            if (costStr != "[Tokens]") {
-                                ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 0.8f), "+ %s", costStr.c_str());
-                            }
-                        }
-                    }
-
-                    ImGui::TableSetColumnIndex(3);
-                    if (item.maxCount < 0) {
-                        ImGui::TextDisabled("Inf");
-                    } else if (item.maxCount == 0) {
-                        ImGui::TextColored(kColorRed, "Out");
-                    } else if (item.maxCount <= 5) {
-                        ImGui::TextColored(ImVec4(1.0f, 0.6f, 0.1f, 1.0f), "%d", item.maxCount);
-                    } else {
-                        ImGui::Text("%d", item.maxCount);
-                    }
-
-                    ImGui::TableSetColumnIndex(4);
-                    bool outOfStock = (item.maxCount == 0);
-                    if (outOfStock) ImGui::BeginDisabled();
-                    std::string buyBtnId = "Buy##vendor_" + std::to_string(vi);
-                    if (ImGui::SmallButton(buyBtnId.c_str())) {
-                        int qty = vendorBuyQty;
-                        if (item.maxCount > 0 && qty > item.maxCount) qty = item.maxCount;
-                        uint32_t totalCost = item.buyPrice * static_cast<uint32_t>(qty);
-                        if (totalCost >= 10000) { // >= 1 gold: confirm
-                            vendorConfirmOpen_ = true;
-                            vendorConfirmGuid_ = vendor.vendorGuid;
-                            vendorConfirmItemId_ = item.itemId;
-                            vendorConfirmSlot_ = item.slot;
-                            vendorConfirmQty_ = static_cast<uint32_t>(qty);
-                            vendorConfirmPrice_ = totalCost;
-                            vendorConfirmItemName_ = (info && info->valid) ? info->name : "Item";
-                        } else {
-                            gameHandler.buyItem(vendor.vendorGuid, item.itemId, item.slot,
-                                                static_cast<uint32_t>(qty));
-                        }
-                    }
-                    if (outOfStock) ImGui::EndDisabled();
-
-                    ImGui::PopID();
-                }
-
-                ImGui::EndTable();
-            }
-        }
-    }
-    ImGui::End();
-
-    if (!open) {
-        gameHandler.closeVendor();
-    }
-
-    // Vendor purchase confirmation popup for expensive items
-    if (vendorConfirmOpen_) {
-        ImGui::OpenPopup("Confirm Purchase##vendor");
-        vendorConfirmOpen_ = false;
-    }
-    if (ImGui::BeginPopupModal("Confirm Purchase##vendor", nullptr,
-                               ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove)) {
-        ImGui::Text("Buy %s", vendorConfirmItemName_.c_str());
-        if (vendorConfirmQty_ > 1)
-            ImGui::Text("Quantity: %u", vendorConfirmQty_);
-        uint32_t g = vendorConfirmPrice_ / 10000;
-        uint32_t s = (vendorConfirmPrice_ / 100) % 100;
-        uint32_t c = vendorConfirmPrice_ % 100;
-        ImGui::Text("Cost: %ug %us %uc", g, s, c);
-        ImGui::Spacing();
-        if (ImGui::Button("Buy", ImVec2(80, 0))) {
-            gameHandler.buyItem(vendorConfirmGuid_, vendorConfirmItemId_,
-                                vendorConfirmSlot_, vendorConfirmQty_);
-            ImGui::CloseCurrentPopup();
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Cancel", ImVec2(80, 0))) {
-            ImGui::CloseCurrentPopup();
-        }
-        ImGui::EndPopup();
-    }
-}
-
-void WindowManager::renderTrainerWindow(game::GameHandler& gameHandler,
-                                SpellIconFn getSpellIcon) {
-    if (!gameHandler.isTrainerWindowOpen()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    auto* assetMgr = services_.assetManager;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 225, 100), ImGuiCond_Appearing);
-    ImGui::SetNextWindowSize(ImVec2(500, 450), ImGuiCond_Appearing);
-
-    bool open = true;
-    if (ImGui::Begin("Trainer", &open)) {
-        // If user clicked window close, short-circuit before rendering large trainer tables.
-        if (!open) {
-            ImGui::End();
-            gameHandler.closeTrainer();
-            return;
-        }
-
-        const auto& trainer = gameHandler.getTrainerSpells();
-        const bool isProfessionTrainer = (trainer.trainerType == 2);
-
-        // NPC name
-        auto npcEntity = gameHandler.getEntityManager().getEntity(trainer.trainerGuid);
-        if (npcEntity && npcEntity->getType() == game::ObjectType::UNIT) {
-            auto unit = std::static_pointer_cast<game::Unit>(npcEntity);
-            if (!unit->getName().empty()) {
-                ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.0f, 1.0f), "%s", unit->getName().c_str());
-            }
-        }
-
-        // Greeting
-        if (!trainer.greeting.empty()) {
-            ImGui::TextWrapped("%s", trainer.greeting.c_str());
-        }
-        ImGui::Separator();
-
-        // Player money
-        uint64_t money = gameHandler.getMoneyCopper();
-        ImGui::TextDisabled("Your money:"); ImGui::SameLine(0, 4);
-        renderCoinsFromCopper(money);
-
-        // Filter controls
-        static bool showUnavailable = false;
-        ImGui::Checkbox("Show unavailable spells", &showUnavailable);
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(-1.0f);
-        ImGui::InputTextWithHint("##TrainerSearch", "Search...", trainerSearchFilter_, sizeof(trainerSearchFilter_));
-        ImGui::Separator();
-
-        if (trainer.spells.empty()) {
-            ImGui::TextDisabled("This trainer has nothing to teach you.");
-        } else {
-            // Known spells for checking
-            const auto& knownSpells = gameHandler.getKnownSpells();
-            auto isKnown = [&](uint32_t id) {
-                if (id == 0) return true;
-                // Check if spell is in knownSpells list
-                bool found = knownSpells.count(id);
-                if (found) return true;
-
-                // Also check if spell is in trainer list with state=2 (explicitly known)
-                // state=0 means unavailable (could be no prereqs, wrong level, etc.) - don't count as known
-                for (const auto& ts : trainer.spells) {
-                    if (ts.spellId == id && ts.state == 2) {
-                        return true;
-                    }
-                }
-                return false;
-            };
-            uint32_t playerLevel = gameHandler.getPlayerLevel();
-
-            // Renders spell rows into the current table
-            auto renderSpellRows = [&](const std::vector<const game::TrainerSpell*>& spells) {
-                for (const auto* spell : spells) {
-                    // Check prerequisites client-side first
-                    bool prereq1Met = isKnown(spell->chainNode1);
-                    bool prereq2Met = isKnown(spell->chainNode2);
-                    bool prereq3Met = isKnown(spell->chainNode3);
-                    bool prereqsMet = prereq1Met && prereq2Met && prereq3Met;
-                    bool levelMet = (spell->reqLevel == 0 || playerLevel >= spell->reqLevel);
-                    bool alreadyKnown = isKnown(spell->spellId);
-
-                    // Dynamically determine effective state based on current prerequisites
-                    // Server sends state, but we override if prerequisites are now met
-                    uint8_t effectiveState = spell->state;
-                    if (spell->state == 1 && prereqsMet && levelMet) {
-                        // Server said unavailable, but we now meet all requirements
-                        effectiveState = 0;  // Treat as available
-                    }
-
-                    // Filter: skip unavailable spells if checkbox is unchecked
-                    // Use effectiveState so spells with newly met prereqs aren't filtered
-                    if (!showUnavailable && effectiveState == 1) {
-                        continue;
-                    }
-
-                    // Apply text search filter
-                    if (trainerSearchFilter_[0] != '\0') {
-                        std::string trainerFilter(trainerSearchFilter_);
-                        for (char& c : trainerFilter) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        const std::string& spellName = gameHandler.getSpellName(spell->spellId);
-                        std::string nameLC = spellName.empty() ? std::to_string(spell->spellId) : spellName;
-                        for (char& c : nameLC) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-                        if (nameLC.find(trainerFilter) == std::string::npos) {
-                            ImGui::PushID(static_cast<int>(spell->spellId));
-                            ImGui::PopID();
-                            continue;
-                        }
-                    }
-
-                    ImGui::TableNextRow();
-                    ImGui::PushID(static_cast<int>(spell->spellId));
-
-                    ImVec4 color;
-                    const char* statusLabel;
-                    // WotLK trainer states: 0=available, 1=unavailable, 2=known
-                    if (effectiveState == 2 || alreadyKnown) {
-                        color = colors::kQueueGreen;
-                        statusLabel = "Known";
-                    } else if (effectiveState == 0) {
-                        color = ui::colors::kWhite;
-                        statusLabel = "Available";
-                    } else {
-                        color = ImVec4(0.6f, 0.3f, 0.3f, 1.0f);
-                        statusLabel = "Unavailable";
-                    }
-
-                    // Icon column
-                    ImGui::TableSetColumnIndex(0);
-                    {
-                        VkDescriptorSet spellIcon = getSpellIcon(spell->spellId, assetMgr);
-                        if (spellIcon) {
-                            if (effectiveState == 1 && !alreadyKnown) {
-                                ImGui::ImageWithBg((ImTextureID)(uintptr_t)spellIcon, ImVec2(18, 18),
-                                    ImVec2(0, 0), ImVec2(1, 1),
-                                    ImVec4(0, 0, 0, 0), ImVec4(0.5f, 0.5f, 0.5f, 0.6f));
-                            } else {
-                                ImGui::Image((ImTextureID)(uintptr_t)spellIcon, ImVec2(18, 18));
-                            }
-                        }
-                    }
-
-                    // Spell name
-                    ImGui::TableSetColumnIndex(1);
-                    const std::string& name = gameHandler.getSpellName(spell->spellId);
-                    const std::string& rank = gameHandler.getSpellRank(spell->spellId);
-                    if (!name.empty()) {
-                        if (!rank.empty())
-                            ImGui::TextColored(color, "%s (%s)", name.c_str(), rank.c_str());
-                        else
-                            ImGui::TextColored(color, "%s", name.c_str());
-                    } else {
-                        ImGui::TextColored(color, "Spell #%u", spell->spellId);
-                    }
-
-                    if (ImGui::IsItemHovered()) {
-                        ImGui::BeginTooltip();
-                        if (!name.empty()) {
-                            ImGui::TextColored(kColorYellow, "%s", name.c_str());
-                            if (!rank.empty()) ImGui::TextColored(kColorGray, "%s", rank.c_str());
-                        }
-                        const std::string& spDesc = gameHandler.getSpellDescription(spell->spellId);
-                        if (!spDesc.empty()) {
-                            ImGui::Spacing();
-                            ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + 300.0f);
-                            ImGui::TextWrapped("%s", spDesc.c_str());
-                            ImGui::PopTextWrapPos();
-                            ImGui::Spacing();
-                        }
-                        ImGui::TextDisabled("Status: %s", statusLabel);
-                        if (spell->reqLevel > 0) {
-                            ImVec4 lvlColor = levelMet ? ui::colors::kLightGray : kColorRed;
-                            ImGui::TextColored(lvlColor, "Required Level: %u", spell->reqLevel);
-                        }
-                        if (spell->reqSkill > 0) ImGui::Text("Required Skill: %u (value %u)", spell->reqSkill, spell->reqSkillValue);
-                        auto showPrereq = [&](uint32_t node) {
-                            if (node == 0) return;
-                            bool met = isKnown(node);
-                            const std::string& pname = gameHandler.getSpellName(node);
-                            ImVec4 pcolor = met ? colors::kQueueGreen : kColorRed;
-                            if (!pname.empty())
-                                ImGui::TextColored(pcolor, "Requires: %s%s", pname.c_str(), met ? " (known)" : "");
-                            else
-                                ImGui::TextColored(pcolor, "Requires: Spell #%u%s", node, met ? " (known)" : "");
-                        };
-                        showPrereq(spell->chainNode1);
-                        showPrereq(spell->chainNode2);
-                        showPrereq(spell->chainNode3);
-                        ImGui::EndTooltip();
-                    }
-
-                    // Level
-                    ImGui::TableSetColumnIndex(2);
-                    ImGui::TextColored(color, "%u", spell->reqLevel);
-
-                    // Cost
-                    ImGui::TableSetColumnIndex(3);
-                    if (spell->spellCost > 0) {
-                        uint32_t g = spell->spellCost / 10000;
-                        uint32_t s = (spell->spellCost / 100) % 100;
-                        uint32_t c = spell->spellCost % 100;
-                        bool canAfford = money >= spell->spellCost;
-                        if (canAfford) {
-                            renderCoinsText(g, s, c);
-                        } else {
-                            ImGui::TextColored(kColorRed, "%ug %us %uc", g, s, c);
-                        }
-                    } else {
-                        ImGui::TextColored(color, "Free");
-                    }
-
-                    // Train button - only enabled if available, affordable, prereqs met
-                    ImGui::TableSetColumnIndex(4);
-                    // Use effectiveState so newly available spells (after learning prereqs) can be trained
-                    bool canTrain = !alreadyKnown && effectiveState == 0
-                                  && prereqsMet && levelMet
-                                  && (money >= spell->spellCost);
-
-                    // Debug logging for first 3 spells to see why buttons are disabled
-                    static int logCount = 0;
-                    static uint64_t lastTrainerGuid = 0;
-                    if (trainer.trainerGuid != lastTrainerGuid) {
-                        logCount = 0;
-                        lastTrainerGuid = trainer.trainerGuid;
-                    }
-                    if (logCount < 3) {
-                        LOG_INFO("Trainer button debug: spellId=", spell->spellId,
-                                " alreadyKnown=", alreadyKnown, " state=", static_cast<int>(spell->state),
-                                " prereqsMet=", prereqsMet, " (", prereq1Met, ",", prereq2Met, ",", prereq3Met, ")",
-                                " levelMet=", levelMet,
-                                " reqLevel=", spell->reqLevel, " playerLevel=", playerLevel,
-                                " chain1=", spell->chainNode1, " chain2=", spell->chainNode2, " chain3=", spell->chainNode3,
-                                " canAfford=", (money >= spell->spellCost),
-                                " canTrain=", canTrain);
-                        logCount++;
-                    }
-
-                    if (isProfessionTrainer && alreadyKnown) {
-                        // Profession trainer: known recipes show "Create" button to craft
-                        bool isCasting = gameHandler.isCasting();
-                        if (isCasting) ImGui::BeginDisabled();
-                        if (ImGui::SmallButton("Create")) {
-                            gameHandler.castSpell(spell->spellId, 0);
-                        }
-                        if (isCasting) ImGui::EndDisabled();
-                    } else {
-                        if (!canTrain) ImGui::BeginDisabled();
-                        if (ImGui::SmallButton("Train")) {
-                            gameHandler.trainSpell(spell->spellId);
-                        }
-                        if (!canTrain) ImGui::EndDisabled();
-                    }
-
-                    ImGui::PopID();
-                }
-            };
-
-            auto renderSpellTable = [&](const char* tableId, const std::vector<const game::TrainerSpell*>& spells) {
-                if (ImGui::BeginTable(tableId, 5,
-                        ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
-                    ImGui::TableSetupColumn("##icon", ImGuiTableColumnFlags_WidthFixed, 22.0f);
-                    ImGui::TableSetupColumn("Spell", ImGuiTableColumnFlags_WidthStretch);
-                    ImGui::TableSetupColumn("Level", ImGuiTableColumnFlags_WidthFixed, 40.0f);
-                    ImGui::TableSetupColumn("Cost", ImGuiTableColumnFlags_WidthFixed, 120.0f);
-                    ImGui::TableSetupColumn("##action", ImGuiTableColumnFlags_WidthFixed, 55.0f);
-                    ImGui::TableHeadersRow();
-                    renderSpellRows(spells);
-                    ImGui::EndTable();
-                }
-            };
-
-            const auto& tabs = gameHandler.getTrainerTabs();
-            if (tabs.size() > 1) {
-                // Multiple tabs - show tab bar
-                if (ImGui::BeginTabBar("TrainerTabs")) {
-                    for (size_t i = 0; i < tabs.size(); i++) {
-                        char tabLabel[64];
-                        snprintf(tabLabel, sizeof(tabLabel), "%s (%zu)",
-                            tabs[i].name.c_str(), tabs[i].spells.size());
-
-                        if (ImGui::BeginTabItem(tabLabel)) {
-                            char tableId[32];
-                            snprintf(tableId, sizeof(tableId), "TT%zu", i);
-                            renderSpellTable(tableId, tabs[i].spells);
-                            ImGui::EndTabItem();
-                        }
-                    }
-                    ImGui::EndTabBar();
-                }
-            } else {
-                // Single tab or no categorization - flat list
-                std::vector<const game::TrainerSpell*> allSpells;
-                allSpells.reserve(trainer.spells.size());
-                for (const auto& spell : trainer.spells) {
-                    allSpells.push_back(&spell);
-                }
-                renderSpellTable("TrainerTable", allSpells);
-            }
-
-            // Count how many spells are trainable right now
-            int trainableCount = 0;
-            uint64_t totalCost = 0;
-            for (const auto& spell : trainer.spells) {
-                bool prereq1Met = isKnown(spell.chainNode1);
-                bool prereq2Met = isKnown(spell.chainNode2);
-                bool prereq3Met = isKnown(spell.chainNode3);
-                bool prereqsMet = prereq1Met && prereq2Met && prereq3Met;
-                bool levelMet = (spell.reqLevel == 0 || playerLevel >= spell.reqLevel);
-                bool alreadyKnown = isKnown(spell.spellId);
-                uint8_t effectiveState = spell.state;
-                if (spell.state == 1 && prereqsMet && levelMet) effectiveState = 0;
-                bool canTrain = !alreadyKnown && effectiveState == 0
-                               && prereqsMet && levelMet
-                               && (money >= spell.spellCost);
-                if (canTrain) {
-                    ++trainableCount;
-                    totalCost += spell.spellCost;
-                }
-            }
-
-            ImGui::Separator();
-            bool canAffordAll = (money >= totalCost);
-            bool hasTrainable = (trainableCount > 0) && canAffordAll;
-            if (!hasTrainable) ImGui::BeginDisabled();
-            uint32_t tag = static_cast<uint32_t>(totalCost / 10000);
-            uint32_t tas = static_cast<uint32_t>((totalCost / 100) % 100);
-            uint32_t tac = static_cast<uint32_t>(totalCost % 100);
-            char trainAllLabel[80];
-            if (trainableCount == 0) {
-                snprintf(trainAllLabel, sizeof(trainAllLabel), "Train All Available (none)");
-            } else {
-                snprintf(trainAllLabel, sizeof(trainAllLabel),
-                         "Train All Available (%d spell%s, %ug %us %uc)",
-                         trainableCount, trainableCount == 1 ? "" : "s",
-                         tag, tas, tac);
-            }
-            if (ImGui::Button(trainAllLabel, ImVec2(-1.0f, 0.0f))) {
-                for (const auto& spell : trainer.spells) {
-                    bool prereq1Met = isKnown(spell.chainNode1);
-                    bool prereq2Met = isKnown(spell.chainNode2);
-                    bool prereq3Met = isKnown(spell.chainNode3);
-                    bool prereqsMet = prereq1Met && prereq2Met && prereq3Met;
-                    bool levelMet = (spell.reqLevel == 0 || playerLevel >= spell.reqLevel);
-                    bool alreadyKnown = isKnown(spell.spellId);
-                    uint8_t effectiveState = spell.state;
-                    if (spell.state == 1 && prereqsMet && levelMet) effectiveState = 0;
-                    bool canTrain = !alreadyKnown && effectiveState == 0
-                                   && prereqsMet && levelMet
-                                   && (money >= spell.spellCost);
-                    if (canTrain) {
-                        gameHandler.trainSpell(spell.spellId);
-                    }
-                }
-            }
-            if (!hasTrainable) ImGui::EndDisabled();
-
-            // Profession trainer: craft quantity controls
-            if (isProfessionTrainer) {
-                ImGui::Separator();
-                static int craftQuantity = 1;
-                static uint32_t selectedCraftSpell = 0;
-
-                // Show craft queue status if active
-                int queueRemaining = gameHandler.getCraftQueueRemaining();
-                if (queueRemaining > 0) {
-                    ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.0f, 1.0f),
-                        "Crafting... %d remaining", queueRemaining);
-                    ImGui::SameLine();
-                    if (ImGui::SmallButton("Stop")) {
-                        gameHandler.cancelCraftQueue();
-                        gameHandler.cancelCast();
-                    }
-                } else {
-                    // Spell selector + quantity input
-                    // Build list of known (craftable) spells
-                    std::vector<const game::TrainerSpell*> craftable;
-                    for (const auto& spell : trainer.spells) {
-                        if (isKnown(spell.spellId)) {
-                            craftable.push_back(&spell);
-                        }
-                    }
-                    if (!craftable.empty()) {
-                        // Combo box for recipe selection
-                        const char* previewName = "Select recipe...";
-                        for (const auto* sp : craftable) {
-                            if (sp->spellId == selectedCraftSpell) {
-                                const std::string& n = gameHandler.getSpellName(sp->spellId);
-                                if (!n.empty()) previewName = n.c_str();
-                                break;
-                            }
-                        }
-                        ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x * 0.55f);
-                        if (ImGui::BeginCombo("##CraftSelect", previewName)) {
-                            for (const auto* sp : craftable) {
-                                const std::string& n = gameHandler.getSpellName(sp->spellId);
-                                const std::string& r = gameHandler.getSpellRank(sp->spellId);
-                                char label[128];
-                                if (!r.empty())
-                                    snprintf(label, sizeof(label), "%s (%s)##%u",
-                                        n.empty() ? "???" : n.c_str(), r.c_str(), sp->spellId);
-                                else
-                                    snprintf(label, sizeof(label), "%s##%u",
-                                        n.empty() ? "???" : n.c_str(), sp->spellId);
-                                if (ImGui::Selectable(label, sp->spellId == selectedCraftSpell)) {
-                                    selectedCraftSpell = sp->spellId;
-                                }
-                            }
-                            ImGui::EndCombo();
-                        }
-                        ImGui::SameLine();
-                        ImGui::SetNextItemWidth(50.0f);
-                        ImGui::InputInt("##CraftQty", &craftQuantity, 0, 0);
-                        if (craftQuantity < 1) craftQuantity = 1;
-                        if (craftQuantity > 99) craftQuantity = 99;
-                        ImGui::SameLine();
-                        bool canCraft = selectedCraftSpell != 0 && !gameHandler.isCasting();
-                        if (!canCraft) ImGui::BeginDisabled();
-                        if (ImGui::Button("Create")) {
-                            if (craftQuantity == 1) {
-                                gameHandler.castSpell(selectedCraftSpell, 0);
-                            } else {
-                                gameHandler.startCraftQueue(selectedCraftSpell, craftQuantity);
-                            }
-                        }
-                        ImGui::SameLine();
-                        if (ImGui::Button("Create All")) {
-                            // Queue a large count — server stops the queue automatically
-                            // when materials run out (sends SPELL_FAILED_REAGENTS).
-                            gameHandler.startCraftQueue(selectedCraftSpell, 999);
-                        }
-                        if (!canCraft) ImGui::EndDisabled();
-                    }
-                }
-            }
-        }
-    }
-    ImGui::End();
-
-    if (!open) {
-        gameHandler.closeTrainer();
-    }
-}
-
-void WindowManager::renderEscapeMenu(SettingsPanel& settingsPanel) {
-    if (!showEscapeMenu) return;
-
-    ImGuiIO& io = ImGui::GetIO();
-    float screenW = io.DisplaySize.x;
-    float screenH = io.DisplaySize.y;
-    ImVec2 size(260.0f, 248.0f);
-    ImVec2 pos((screenW - size.x) * 0.5f, (screenH - size.y) * 0.5f);
-
-    ImGui::SetNextWindowPos(pos, ImGuiCond_Always);
-    ImGui::SetNextWindowSize(size, ImGuiCond_Always);
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-                             ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar;
-
-    if (ImGui::Begin("##EscapeMenu", nullptr, flags)) {
-        ImGui::Text("Game Menu");
-        ImGui::Separator();
-
-        if (ImGui::Button("Logout", ImVec2(-1, 0))) {
-            core::Application::getInstance().logoutToLogin();
-            showEscapeMenu = false;
-            settingsPanel.showEscapeSettingsNotice = false;
-        }
-        if (ImGui::Button("Quit", ImVec2(-1, 0))) {
-            auto* ac = services_.audioCoordinator;
-            if (ac) {
-                if (auto* music = ac->getMusicManager()) {
-                    music->stopMusic(0.0f);
-                }
-            }
-            core::Application::getInstance().shutdown();
-        }
-        if (ImGui::Button("Settings", ImVec2(-1, 0))) {
-            settingsPanel.showEscapeSettingsNotice = false;
-            settingsPanel.showSettingsWindow = true;
-            settingsPanel.settingsInit = false;
-            showEscapeMenu = false;
-        }
-        if (ImGui::Button("Instance Lockouts", ImVec2(-1, 0))) {
-            showInstanceLockouts_ = true;
-            showEscapeMenu = false;
-        }
-        if (ImGui::Button("Help / GM Ticket", ImVec2(-1, 0))) {
-            showGmTicketWindow_ = true;
-            showEscapeMenu = false;
-        }
-
-        ImGui::Spacing();
-        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(10.0f, 10.0f));
-        if (ImGui::Button("Back to Game", ImVec2(-1, 0))) {
-            showEscapeMenu = false;
-            settingsPanel.showEscapeSettingsNotice = false;
-        }
-        ImGui::PopStyleVar();
-    }
-    ImGui::End();
-}
-
-void WindowManager::renderBarberShopWindow(game::GameHandler& gameHandler) {
-    if (!gameHandler.isBarberShopOpen()) {
-        barberInitialized_ = false;
-        return;
-    }
-
-    const auto* ch = gameHandler.getActiveCharacter();
-    if (!ch) return;
-
-    uint8_t race = static_cast<uint8_t>(ch->race);
-    game::Gender gender = ch->gender;
-    game::Race raceEnum = ch->race;
-
-    // Initialize sliders from current appearance
-    if (!barberInitialized_) {
-        barberOrigHairStyle_ = static_cast<int>((ch->appearanceBytes >> 16) & 0xFF);
-        barberOrigHairColor_ = static_cast<int>((ch->appearanceBytes >> 24) & 0xFF);
-        barberOrigFacialHair_ = static_cast<int>(ch->facialFeatures);
-        barberHairStyle_ = barberOrigHairStyle_;
-        barberHairColor_ = barberOrigHairColor_;
-        barberFacialHair_ = barberOrigFacialHair_;
-        barberInitialized_ = true;
-    }
-
-    int maxHairStyle = static_cast<int>(game::getMaxHairStyle(raceEnum, gender));
-    int maxHairColor = static_cast<int>(game::getMaxHairColor(raceEnum, gender));
-    int maxFacialHair = static_cast<int>(game::getMaxFacialFeature(raceEnum, gender));
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-    float winW = 300.0f;
-    float winH = 220.0f;
-    ImGui::SetNextWindowPos(ImVec2((screenW - winW) / 2.0f, (screenH - winH) / 2.0f), ImGuiCond_Appearing);
-    ImGui::SetNextWindowSize(ImVec2(winW, winH), ImGuiCond_Appearing);
-
-    ImGuiWindowFlags flags = ImGuiWindowFlags_NoCollapse;
-    bool open = true;
-    if (ImGui::Begin("Barber Shop", &open, flags)) {
-        ImGui::Text("Choose your new look:");
-        ImGui::Separator();
-        ImGui::Spacing();
-
-        ImGui::PushItemWidth(-1);
-
-        // Hair Style
-        ImGui::Text("Hair Style");
-        ImGui::SliderInt("##HairStyle", &barberHairStyle_, 0, maxHairStyle,
-                         "%d");
-
-        // Hair Color
-        ImGui::Text("Hair Color");
-        ImGui::SliderInt("##HairColor", &barberHairColor_, 0, maxHairColor,
-                         "%d");
-
-        // Facial Hair / Piercings / Markings
-        const char* facialLabel = (gender == game::Gender::FEMALE) ? "Piercings" : "Facial Hair";
-        // Some races use "Markings" or "Tusks" etc.
-        if (race == 8 || race == 6) facialLabel = "Features"; // Trolls, Tauren
-        ImGui::Text("%s", facialLabel);
-        ImGui::SliderInt("##FacialHair", &barberFacialHair_, 0, maxFacialHair,
-                         "%d");
-
-        ImGui::PopItemWidth();
-
-        ImGui::Spacing();
-        ImGui::Separator();
-
-        // Show whether anything changed
-        bool changed = (barberHairStyle_ != barberOrigHairStyle_ ||
-                        barberHairColor_ != barberOrigHairColor_ ||
-                        barberFacialHair_ != barberOrigFacialHair_);
-
-        // OK / Reset / Cancel buttons
-        float btnW = 80.0f;
-        float totalW = btnW * 3 + ImGui::GetStyle().ItemSpacing.x * 2;
-        ImGui::SetCursorPosX((ImGui::GetWindowWidth() - totalW) / 2.0f);
-
-        if (!changed) ImGui::BeginDisabled();
-        if (ImGui::Button("OK", ImVec2(btnW, 0))) {
-            gameHandler.sendAlterAppearance(
-                static_cast<uint32_t>(barberHairStyle_),
-                static_cast<uint32_t>(barberHairColor_),
-                static_cast<uint32_t>(barberFacialHair_));
-            // Keep window open — server will respond with SMSG_BARBER_SHOP_RESULT
-        }
-        if (!changed) ImGui::EndDisabled();
-
-        ImGui::SameLine();
-        if (!changed) ImGui::BeginDisabled();
-        if (ImGui::Button("Reset", ImVec2(btnW, 0))) {
-            barberHairStyle_ = barberOrigHairStyle_;
-            barberHairColor_ = barberOrigHairColor_;
-            barberFacialHair_ = barberOrigFacialHair_;
-        }
-        if (!changed) ImGui::EndDisabled();
-
-        ImGui::SameLine();
-        if (ImGui::Button("Cancel", ImVec2(btnW, 0))) {
-            gameHandler.closeBarberShop();
-        }
-    }
-    ImGui::End();
-
-    if (!open) {
-        gameHandler.closeBarberShop();
-    }
-}
-
-void WindowManager::renderStableWindow(game::GameHandler& gameHandler) {
-    if (!gameHandler.isStableWindowOpen()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth())  : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2.0f - 240.0f, screenH / 2.0f - 180.0f),
-                            ImGuiCond_Once);
-    ImGui::SetNextWindowSize(ImVec2(480.0f, 360.0f), ImGuiCond_Once);
-
-    bool open = true;
-    if (!ImGui::Begin("Pet Stable", &open,
-                      kDialogFlags)) {
-        ImGui::End();
-        if (!open) {
-            // User closed the window; clear stable state
-            gameHandler.closeStableWindow();
-        }
-        return;
-    }
-
-    const auto& pets      = gameHandler.getStabledPets();
-    uint8_t numSlots      = gameHandler.getStableSlots();
-
-    ImGui::TextDisabled("Stable slots: %u", static_cast<unsigned>(numSlots));
-    ImGui::Separator();
-
-    // Active pets section
-    bool hasActivePets = false;
-    for (const auto& p : pets) {
-        if (p.isActive) { hasActivePets = true; break; }
-    }
-
-    if (hasActivePets) {
-        ImGui::TextColored(ImVec4(0.4f, 0.9f, 0.4f, 1.0f), "Active / Summoned");
-        for (const auto& p : pets) {
-            if (!p.isActive) continue;
-            ImGui::PushID(static_cast<int>(p.petNumber) * -1 - 1);
-
-            const std::string displayName = p.name.empty()
-                ? ("Pet #" + std::to_string(p.petNumber))
-                : p.name;
-            ImGui::Text("  %s  (Level %u)", displayName.c_str(), p.level);
-            ImGui::SameLine();
-            ImGui::TextDisabled("[Active]");
-
-            // Offer to stable the active pet if there are free slots
-            uint8_t usedSlots = 0;
-            for (const auto& sp : pets) { if (!sp.isActive) ++usedSlots; }
-            if (usedSlots < numSlots) {
-                ImGui::SameLine();
-                if (ImGui::SmallButton("Store in stable")) {
-                    // Slot 1 is first stable slot; server handles free slot assignment.
-                    gameHandler.stablePet(1);
-                }
-            }
-            ImGui::PopID();
-        }
-        ImGui::Separator();
-    }
-
-    // Stabled pets section
-    ImGui::TextColored(ImVec4(0.9f, 0.8f, 0.4f, 1.0f), "Stabled Pets");
-
-    bool hasStabledPets = false;
-    for (const auto& p : pets) {
-        if (!p.isActive) { hasStabledPets = true; break; }
-    }
-
-    if (!hasStabledPets) {
-        ImGui::TextDisabled("  (No pets in stable)");
-    } else {
-        for (const auto& p : pets) {
-            if (p.isActive) continue;
-            ImGui::PushID(static_cast<int>(p.petNumber));
-
-            const std::string displayName = p.name.empty()
-                ? ("Pet #" + std::to_string(p.petNumber))
-                : p.name;
-            ImGui::Text("  %s  (Level %u, Entry %u)",
-                        displayName.c_str(), p.level, p.entry);
-            ImGui::SameLine();
-            if (ImGui::SmallButton("Retrieve")) {
-                gameHandler.unstablePet(p.petNumber);
-            }
-            ImGui::PopID();
-        }
-    }
-
-    // Empty slots
-    uint8_t usedStableSlots = 0;
-    for (const auto& p : pets) { if (!p.isActive) ++usedStableSlots; }
-    if (usedStableSlots < numSlots) {
-        ImGui::TextDisabled("  %u empty slot(s) available",
-                            static_cast<unsigned>(numSlots - usedStableSlots));
-    }
-
-    ImGui::Separator();
-    if (ImGui::Button("Refresh")) {
-        gameHandler.requestStabledPetList();
-    }
-    ImGui::SameLine();
-    if (ImGui::Button("Close")) {
-        gameHandler.closeStableWindow();
-    }
-
-    ImGui::End();
-    if (!open) {
-        gameHandler.closeStableWindow();
-    }
-}
-
-void WindowManager::renderTaxiWindow(game::GameHandler& gameHandler) {
-    if (!gameHandler.isTaxiWindowOpen()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 200, 150), ImGuiCond_Appearing);
-    ImGui::SetNextWindowSize(ImVec2(400, 0), ImGuiCond_Always);
-
-    bool open = true;
-    if (ImGui::Begin("Flight Master", &open, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize)) {
-        const auto& taxiData = gameHandler.getTaxiData();
-        const auto& nodes = gameHandler.getTaxiNodes();
-        uint32_t currentNode = gameHandler.getTaxiCurrentNode();
-
-        // Get current node's map to filter destinations
-        uint32_t currentMapId = 0;
-        auto curIt = nodes.find(currentNode);
-        if (curIt != nodes.end()) {
-            currentMapId = curIt->second.mapId;
-            ImGui::TextColored(colors::kActiveGreen, "Current: %s", curIt->second.name.c_str());
-            ImGui::Separator();
-        }
-
-        ImGui::Text("Select a destination:");
-        ImGui::Spacing();
-
-        static uint32_t selectedNodeId = 0;
-        int destCount = 0;
-        if (ImGui::BeginTable("TaxiNodes", 3, ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_RowBg)) {
-            ImGui::TableSetupColumn("Destination", ImGuiTableColumnFlags_WidthStretch);
-            ImGui::TableSetupColumn("Cost", ImGuiTableColumnFlags_WidthFixed, 120.0f);
-            ImGui::TableSetupColumn("Action", ImGuiTableColumnFlags_WidthFixed, 60.0f);
-            ImGui::TableHeadersRow();
-
-            for (const auto& [nodeId, node] : nodes) {
-                if (nodeId == currentNode) continue;
-                if (node.mapId != currentMapId) continue;
-                if (!taxiData.isNodeKnown(nodeId)) continue;
-
-                uint32_t costCopper = gameHandler.getTaxiCostTo(nodeId);
-                uint32_t gold = costCopper / 10000;
-                uint32_t silver = (costCopper / 100) % 100;
-                uint32_t copper = costCopper % 100;
-
-                ImGui::PushID(static_cast<int>(nodeId));
-                ImGui::TableNextRow();
-
-                ImGui::TableSetColumnIndex(0);
-                bool isSelected = (selectedNodeId == nodeId);
-                if (ImGui::Selectable(node.name.c_str(), isSelected,
-                                      ImGuiSelectableFlags_SpanAllColumns |
-                                      ImGuiSelectableFlags_AllowDoubleClick)) {
-                    selectedNodeId = nodeId;
-                    LOG_INFO("Taxi UI: Selected dest=", nodeId);
-                    if (ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) {
-                        LOG_INFO("Taxi UI: Double-click activate dest=", nodeId);
-                        gameHandler.activateTaxi(nodeId);
-                    }
-                }
-
-                ImGui::TableSetColumnIndex(1);
-                renderCoinsText(gold, silver, copper);
-
-                ImGui::TableSetColumnIndex(2);
-                if (ImGui::SmallButton("Fly")) {
-                    selectedNodeId = nodeId;
-                    LOG_INFO("Taxi UI: Fly clicked dest=", nodeId);
-                    gameHandler.activateTaxi(nodeId);
-                }
-
-                ImGui::PopID();
-                destCount++;
-            }
-            ImGui::EndTable();
-        }
-
-        if (destCount == 0) {
-            ImGui::TextColored(ui::colors::kLightGray, "No destinations available.");
-        }
-
-        ImGui::Spacing();
-        ImGui::Separator();
-        if (selectedNodeId != 0 && ImGui::Button("Fly Selected", ImVec2(-1, 0))) {
-            LOG_INFO("Taxi UI: Fly Selected dest=", selectedNodeId);
-            gameHandler.activateTaxi(selectedNodeId);
-        }
-        if (ImGui::Button("Close", ImVec2(-1, 0))) {
-            gameHandler.closeTaxi();
-        }
-    }
-    ImGui::End();
-
-    if (!open) {
-        gameHandler.closeTaxi();
-    }
-}
-
-void WindowManager::renderLogoutCountdown(game::GameHandler& gameHandler) {
-    if (!gameHandler.isLoggingOut()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth())  : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    constexpr float W = 280.0f;
-    constexpr float H = 80.0f;
-    ImGui::SetNextWindowPos(ImVec2((screenW - W) * 0.5f, screenH * 0.5f - H * 0.5f - 60.0f),
-                            ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(W, H), ImGuiCond_Always);
-    ImGui::SetNextWindowBgAlpha(0.88f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 6.0f);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.08f, 0.08f, 0.18f, 0.95f));
-    ImGui::PushStyleColor(ImGuiCol_Border,   ImVec4(0.5f, 0.5f, 0.8f, 1.0f));
-
-    if (ImGui::Begin("##LogoutCountdown", nullptr,
-            ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-            ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoBringToFrontOnFocus)) {
-
-        float cd = gameHandler.getLogoutCountdown();
-        if (cd > 0.0f) {
-            ImGui::SetCursorPosY(ImGui::GetCursorPosY() + 6.0f);
-            ImGui::SetCursorPosX((W - ImGui::CalcTextSize("Logging out in 20s...").x) * 0.5f);
-            ImGui::TextColored(ImVec4(1.0f, 0.85f, 0.3f, 1.0f),
-                               "Logging out in %ds...", static_cast<int>(std::ceil(cd)));
-
-            // Progress bar (20 second countdown)
-            float frac = 1.0f - std::min(cd / 20.0f, 1.0f);
-            ImGui::PushStyleColor(ImGuiCol_PlotHistogram, ImVec4(0.5f, 0.5f, 0.9f, 1.0f));
-            ImGui::ProgressBar(frac, ImVec2(-1.0f, 8.0f), "");
-            ImGui::PopStyleColor();
-            ImGui::Spacing();
-        } else {
-            ImGui::SetCursorPosY(ImGui::GetCursorPosY() + 14.0f);
-            ImGui::SetCursorPosX((W - ImGui::CalcTextSize("Logging out...").x) * 0.5f);
-            ImGui::TextColored(ImVec4(1.0f, 0.85f, 0.3f, 1.0f), "Logging out...");
-            ImGui::Spacing();
-        }
-
-        // Cancel button — only while countdown is still running
-        if (cd > 0.0f) {
-            float btnW = 100.0f;
-            ImGui::SetCursorPosX((W - btnW) * 0.5f);
-            ImGui::PushStyleColor(ImGuiCol_Button,        ImVec4(0.5f, 0.1f, 0.1f, 1.0f));
-            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.7f, 0.15f, 0.15f, 1.0f));
-            if (ImGui::Button("Cancel", ImVec2(btnW, 0))) {
-                gameHandler.cancelLogout();
-            }
-            ImGui::PopStyleColor(2);
-        }
-    }
-    ImGui::End();
-    ImGui::PopStyleColor(2);
-    ImGui::PopStyleVar();
-}
-
-void WindowManager::renderDeathScreen(game::GameHandler& gameHandler) {
-    if (!gameHandler.showDeathDialog()) {
-        deathTimerRunning_ = false;
-        deathElapsed_ = 0.0f;
-        return;
-    }
-    float dt = ImGui::GetIO().DeltaTime;
-    if (!deathTimerRunning_) {
-        deathElapsed_ = 0.0f;
-        deathTimerRunning_ = true;
-    } else {
-        deathElapsed_ += dt;
-    }
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    // Dark red overlay covering the whole screen
-    ImGui::SetNextWindowPos(ImVec2(0, 0));
-    ImGui::SetNextWindowSize(ImVec2(screenW, screenH));
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.15f, 0.0f, 0.0f, 0.45f));
-    ImGui::Begin("##DeathOverlay", nullptr,
-        ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoInputs |
-        ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoFocusOnAppearing);
-    ImGui::End();
-    ImGui::PopStyleColor();
-
-    // "Release Spirit" dialog centered on screen
-    const bool hasSelfRes = gameHandler.canSelfRes();
-    float dlgW = 280.0f;
-    // Extra height when self-res button is available; +20 for the "wait for res" hint
-    float dlgH = hasSelfRes ? 190.0f : 150.0f;
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - dlgW / 2, screenH * 0.35f), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(dlgW, dlgH), ImGuiCond_Always);
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.0f);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.1f, 0.0f, 0.0f, 0.9f));
-    ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.6f, 0.1f, 0.1f, 1.0f));
-
-    if (ImGui::Begin("##DeathDialog", nullptr,
-            ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-            ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar)) {
-
-        ImGui::Spacing();
-        // Center "You are dead." text
-        const char* deathText = "You are dead.";
-        float textW = ImGui::CalcTextSize(deathText).x;
-        ImGui::SetCursorPosX((dlgW - textW) / 2);
-        ImGui::TextColored(colors::kBrightRed, "%s", deathText);
-
-        // Respawn timer: show how long until the server auto-releases the spirit
-        float timeLeft = kForcedReleaseSec - deathElapsed_;
-        if (timeLeft > 0.0f) {
-            int mins = static_cast<int>(timeLeft) / 60;
-            int secs = static_cast<int>(timeLeft) % 60;
-            char timerBuf[48];
-            snprintf(timerBuf, sizeof(timerBuf), "Auto-release in %d:%02d", mins, secs);
-            float tw = ImGui::CalcTextSize(timerBuf).x;
-            ImGui::SetCursorPosX((dlgW - tw) / 2);
-            ImGui::TextColored(colors::kMediumGray, "%s", timerBuf);
-        }
-
-        ImGui::Spacing();
-        ImGui::Spacing();
-
-        // Self-resurrection button (Reincarnation / Twisting Nether / Deathpact)
-        if (hasSelfRes) {
-            float btnW2 = 220.0f;
-            ImGui::SetCursorPosX((dlgW - btnW2) / 2);
-            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.15f, 0.35f, 0.55f, 1.0f));
-            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.2f, 0.5f, 0.75f, 1.0f));
-            if (ImGui::Button("Use Self-Resurrection", ImVec2(btnW2, 30))) {
-                gameHandler.useSelfRes();
-            }
-            ImGui::PopStyleColor(2);
-            ImGui::Spacing();
-        }
-
-        // Center the Release Spirit button
-        float btnW = 180.0f;
-        ImGui::SetCursorPosX((dlgW - btnW) / 2);
-        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.5f, 0.1f, 0.1f, 1.0f));
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.7f, 0.15f, 0.15f, 1.0f));
-        if (ImGui::Button("Release Spirit", ImVec2(btnW, 30))) {
-            gameHandler.releaseSpirit();
-        }
-        ImGui::PopStyleColor(2);
-
-        // Hint: player can stay dead and wait for another player to cast Resurrection
-        const char* resHint = "Or wait for a player to resurrect you.";
-        float hw = ImGui::CalcTextSize(resHint).x;
-        ImGui::SetCursorPosX((dlgW - hw) / 2);
-        ImGui::TextColored(ImVec4(0.5f, 0.6f, 0.5f, 0.85f), "%s", resHint);
-    }
-    ImGui::End();
-    ImGui::PopStyleColor(2);
-    ImGui::PopStyleVar();
-}
-
-void WindowManager::renderReclaimCorpseButton(game::GameHandler& gameHandler) {
-    if (!gameHandler.isPlayerGhost() || !gameHandler.canReclaimCorpse()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    float delaySec = gameHandler.getCorpseReclaimDelaySec();
-    bool onDelay = (delaySec > 0.0f);
-
-    float btnW = 220.0f, btnH = 36.0f;
-    float winH = btnH + 16.0f + (onDelay ? 20.0f : 0.0f);
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - btnW / 2, screenH * 0.72f), ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(btnW + 16.0f, winH), ImGuiCond_Always);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 6.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(8.0f, 8.0f));
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.0f, 0.0f, 0.0f, 0.7f));
-    if (ImGui::Begin("##ReclaimCorpse", nullptr,
-            ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-            ImGuiWindowFlags_NoBringToFrontOnFocus)) {
-        if (onDelay) {
-            // Greyed-out button while PvP reclaim timer ticks down
-            ImGui::PushStyleColor(ImGuiCol_Button,        ImVec4(0.25f, 0.25f, 0.25f, 1.0f));
-            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.25f, 0.25f, 0.25f, 1.0f));
-            ImGui::BeginDisabled(true);
-            char delayLabel[64];
-            snprintf(delayLabel, sizeof(delayLabel), "Resurrect from Corpse (%.0fs)", delaySec);
-            ImGui::Button(delayLabel, ImVec2(btnW, btnH));
-            ImGui::EndDisabled();
-            ImGui::PopStyleColor(2);
-            const char* waitMsg = "You cannot reclaim your corpse yet.";
-            float tw = ImGui::CalcTextSize(waitMsg).x;
-            ImGui::SetCursorPosX((btnW + 16.0f - tw) * 0.5f);
-            ImGui::TextColored(ImVec4(0.8f, 0.5f, 0.2f, 1.0f), "%s", waitMsg);
-        } else {
-            ImGui::PushStyleColor(ImGuiCol_Button,        ImVec4(0.15f, 0.35f, 0.15f, 1.0f));
-            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.25f, 0.55f, 0.25f, 1.0f));
-            if (ImGui::Button("Resurrect from Corpse", ImVec2(btnW, btnH))) {
-                gameHandler.reclaimCorpse();
-            }
-            ImGui::PopStyleColor(2);
-            float corpDist = gameHandler.getCorpseDistance();
-            if (corpDist >= 0.0f) {
-                char distBuf[48];
-                snprintf(distBuf, sizeof(distBuf), "Corpse: %.0f yards away", corpDist);
-                float dw = ImGui::CalcTextSize(distBuf).x;
-                ImGui::SetCursorPosX((btnW + 16.0f - dw) * 0.5f);
-                ImGui::TextDisabled("%s", distBuf);
-            }
-        }
-    }
-    ImGui::End();
-    ImGui::PopStyleColor();
-    ImGui::PopStyleVar(2);
-}
-
-void WindowManager::renderMailWindow(game::GameHandler& gameHandler,
-                             InventoryScreen& inventoryScreen,
-                             ChatPanel& chatPanel) {
-    if (!gameHandler.isMailboxOpen()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 250, 80), ImGuiCond_Appearing);
-    ImGui::SetNextWindowSize(ImVec2(600, 500), ImGuiCond_Appearing);
-
-    bool open = true;
-    if (ImGui::Begin("Mailbox", &open)) {
-        const auto& inbox = gameHandler.getMailInbox();
-
-        // Top bar: money + compose button
-        ImGui::TextDisabled("Your money:"); ImGui::SameLine(0, 4);
-        renderCoinsFromCopper(gameHandler.getMoneyCopper());
-        ImGui::SameLine(ImGui::GetWindowWidth() - 100);
-        if (ImGui::Button("Compose")) {
-            mailRecipientBuffer_[0] = '\0';
-            mailSubjectBuffer_[0] = '\0';
-            mailBodyBuffer_[0] = '\0';
-            mailComposeMoney_[0] = 0;
-            mailComposeMoney_[1] = 0;
-            mailComposeMoney_[2] = 0;
-            gameHandler.openMailCompose();
-        }
-        ImGui::Separator();
-
-        if (inbox.empty()) {
-            ImGui::TextDisabled("No mail.");
-        } else {
-            // Two-panel layout: left = mail list, right = selected mail detail
-            float listWidth = 220.0f;
-
-            // Left panel - mail list
-            ImGui::BeginChild("MailList", ImVec2(listWidth, 0), true);
-            for (size_t i = 0; i < inbox.size(); ++i) {
-                const auto& mail = inbox[i];
-                ImGui::PushID(static_cast<int>(i));
-
-                bool selected = (gameHandler.getSelectedMailIndex() == static_cast<int>(i));
-                std::string label = mail.subject.empty() ? "(No Subject)" : mail.subject;
-
-                // Unread indicator
-                if (!mail.read) {
-                    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 1.0f, 0.5f, 1.0f));
-                }
-
-                if (ImGui::Selectable(label.c_str(), selected)) {
-                    gameHandler.setSelectedMailIndex(static_cast<int>(i));
-                    // Mark as read
-                    if (!mail.read) {
-                        gameHandler.mailMarkAsRead(mail.messageId);
-                    }
-                }
-
-                if (!mail.read) {
-                    ImGui::PopStyleColor();
-                }
-
-                // Sub-info line
-                ImGui::TextColored(kColorGray, "  From: %s", mail.senderName.c_str());
-                if (mail.money > 0) {
-                    ImGui::SameLine();
-                    ImGui::TextColored(colors::kWarmGold, " [G]");
-                }
-                if (!mail.attachments.empty()) {
-                    ImGui::SameLine();
-                    ImGui::TextColored(ImVec4(0.5f, 0.8f, 1.0f, 1.0f), " [A]");
-                }
-                // Expiry warning if within 3 days
-                if (mail.expirationTime > 0.0f) {
-                    auto nowSec = static_cast<float>(std::time(nullptr));
-                    float secsLeft = mail.expirationTime - nowSec;
-                    if (secsLeft < 3.0f * 86400.0f && secsLeft > 0.0f) {
-                        ImGui::SameLine();
-                        int daysLeft = static_cast<int>(secsLeft / 86400.0f);
-                        if (daysLeft == 0) {
-                            ImGui::TextColored(colors::kBrightRed, " [expires today!]");
-                        } else {
-                            ImGui::TextColored(ImVec4(1.0f, 0.6f, 0.1f, 1.0f),
-                                " [expires in %dd]", daysLeft);
-                        }
-                    }
-                }
-
-                ImGui::PopID();
-            }
-            ImGui::EndChild();
-
-            ImGui::SameLine();
-
-            // Right panel - selected mail detail
-            ImGui::BeginChild("MailDetail", ImVec2(0, 0), true);
-            int sel = gameHandler.getSelectedMailIndex();
-            if (sel >= 0 && sel < static_cast<int>(inbox.size())) {
-                const auto& mail = inbox[sel];
-
-                ImGui::TextColored(colors::kWarmGold, "%s",
-                    mail.subject.empty() ? "(No Subject)" : mail.subject.c_str());
-                ImGui::Text("From: %s", mail.senderName.c_str());
-
-                if (mail.messageType == 2) {
-                    ImGui::TextColored(ImVec4(0.8f, 0.6f, 0.2f, 1.0f), "[Auction House]");
-                }
-
-                // Show expiry date in the detail panel
-                if (mail.expirationTime > 0.0f) {
-                    auto nowSec = static_cast<float>(std::time(nullptr));
-                    float secsLeft = mail.expirationTime - nowSec;
-                    // Format absolute expiry as a date using struct tm
-                    time_t expT = static_cast<time_t>(mail.expirationTime);
-                    struct tm* tmExp = std::localtime(&expT);
-                    if (tmExp) {
-                        const char* mname = kMonthAbbrev[tmExp->tm_mon];
-                        int daysLeft = static_cast<int>(secsLeft / 86400.0f);
-                        if (secsLeft <= 0.0f) {
-                            ImGui::TextColored(kColorGray,
-                                "Expired: %s %d, %d", mname, tmExp->tm_mday, 1900 + tmExp->tm_year);
-                        } else if (secsLeft < 3.0f * 86400.0f) {
-                            ImGui::TextColored(kColorRed,
-                                "Expires: %s %d, %d (%d day%s!)",
-                                mname, tmExp->tm_mday, 1900 + tmExp->tm_year,
-                                daysLeft, daysLeft == 1 ? "" : "s");
-                        } else {
-                            ImGui::TextDisabled("Expires: %s %d, %d",
-                                mname, tmExp->tm_mday, 1900 + tmExp->tm_year);
-                        }
-                    }
-                }
-                ImGui::Separator();
-
-                // Body text
-                if (!mail.body.empty()) {
-                    ImGui::TextWrapped("%s", mail.body.c_str());
-                    ImGui::Separator();
-                }
-
-                // Money
-                if (mail.money > 0) {
-                    ImGui::TextDisabled("Money:"); ImGui::SameLine(0, 4);
-                    renderCoinsFromCopper(mail.money);
-                    ImGui::SameLine();
-                    if (ImGui::SmallButton("Take Money")) {
-                        gameHandler.mailTakeMoney(mail.messageId);
-                    }
-                }
-
-                // COD warning
-                if (mail.cod > 0) {
-                    uint64_t g = mail.cod / 10000;
-                    uint64_t s = (mail.cod / 100) % 100;
-                    uint64_t c = mail.cod % 100;
-                    ImGui::TextColored(kColorRed,
-                        "COD: %llug %llus %lluc (you pay this to take items)",
-                        static_cast<unsigned long long>(g),
-                        static_cast<unsigned long long>(s),
-                        static_cast<unsigned long long>(c));
-                }
-
-                // Attachments
-                if (!mail.attachments.empty()) {
-                    ImGui::Text("Attachments: %zu", mail.attachments.size());
-                    ImDrawList* mailDraw = ImGui::GetWindowDrawList();
-                    constexpr float MAIL_SLOT = 34.0f;
-                    for (size_t j = 0; j < mail.attachments.size(); ++j) {
-                        const auto& att = mail.attachments[j];
-                        ImGui::PushID(static_cast<int>(j));
-
-                        auto* info = gameHandler.getItemInfo(att.itemId);
-                        game::ItemQuality quality = game::ItemQuality::COMMON;
-                        std::string name = "Item " + std::to_string(att.itemId);
-                        uint32_t displayInfoId = 0;
-                        if (info && info->valid) {
-                            quality = static_cast<game::ItemQuality>(info->quality);
-                            name = info->name;
-                            displayInfoId = info->displayInfoId;
-                        } else {
-                            gameHandler.ensureItemInfo(att.itemId);
-                        }
-                        ImVec4 qc = InventoryScreen::getQualityColor(quality);
-                        ImU32 borderCol = ImGui::ColorConvertFloat4ToU32(qc);
-
-                        ImVec2 pos = ImGui::GetCursorScreenPos();
-                        VkDescriptorSet iconTex = displayInfoId
-                            ? inventoryScreen.getItemIcon(displayInfoId) : VK_NULL_HANDLE;
-                        if (iconTex) {
-                            mailDraw->AddImage((ImTextureID)(uintptr_t)iconTex, pos,
-                                              ImVec2(pos.x + MAIL_SLOT, pos.y + MAIL_SLOT));
-                            mailDraw->AddRect(pos, ImVec2(pos.x + MAIL_SLOT, pos.y + MAIL_SLOT),
-                                             borderCol, 0.0f, 0, 1.5f);
-                        } else {
-                            mailDraw->AddRectFilled(pos,
-                                ImVec2(pos.x + MAIL_SLOT, pos.y + MAIL_SLOT),
-                                IM_COL32(40, 35, 30, 220));
-                            mailDraw->AddRect(pos,
-                                ImVec2(pos.x + MAIL_SLOT, pos.y + MAIL_SLOT),
-                                borderCol, 0.0f, 0, 1.5f);
-                        }
-                        if (att.stackCount > 1) {
-                            char cnt[16];
-                            snprintf(cnt, sizeof(cnt), "%u", att.stackCount);
-                            float cw = ImGui::CalcTextSize(cnt).x;
-                            mailDraw->AddText(ImVec2(pos.x + 1.0f, pos.y + 1.0f),
-                                             IM_COL32(0, 0, 0, 200), cnt);
-                            mailDraw->AddText(
-                                ImVec2(pos.x + MAIL_SLOT - cw - 2.0f, pos.y + MAIL_SLOT - 14.0f),
-                                IM_COL32(255, 255, 255, 220), cnt);
-                        }
-
-                        ImGui::InvisibleButton("##mailatt", ImVec2(MAIL_SLOT, MAIL_SLOT));
-                        if (ImGui::IsItemHovered() && info && info->valid)
-                            inventoryScreen.renderItemTooltip(*info);
-                        if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left) &&
-                            ImGui::GetIO().KeyShift && info && info->valid && !info->name.empty()) {
-                            std::string link = buildItemChatLink(info->entry, info->quality, info->name);
-                            chatPanel.insertChatLink(link);
-                        }
-                        ImGui::SameLine();
-                        ImGui::TextColored(qc, "%s", name.c_str());
-                        if (ImGui::IsItemHovered() && info && info->valid)
-                            inventoryScreen.renderItemTooltip(*info);
-                        if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left) &&
-                            ImGui::GetIO().KeyShift && info && info->valid && !info->name.empty()) {
-                            std::string link = buildItemChatLink(info->entry, info->quality, info->name);
-                            chatPanel.insertChatLink(link);
-                        }
-                        ImGui::SameLine();
-                        if (ImGui::SmallButton("Take")) {
-                            gameHandler.mailTakeItem(mail.messageId, att.itemGuidLow);
-                        }
-
-                        ImGui::PopID();
-                    }
-                    // "Take All" button when there are multiple attachments
-                    if (mail.attachments.size() > 1) {
-                        if (ImGui::SmallButton("Take All")) {
-                            for (const auto& att2 : mail.attachments) {
-                                gameHandler.mailTakeItem(mail.messageId, att2.itemGuidLow);
-                            }
-                        }
-                    }
-                }
-
-                ImGui::Spacing();
-                ImGui::Separator();
-
-                // Action buttons
-                if (ImGui::Button("Delete")) {
-                    gameHandler.mailDelete(mail.messageId);
-                }
-                ImGui::SameLine();
-                if (mail.messageType == 0 && ImGui::Button("Reply")) {
-                    // Pre-fill compose with sender as recipient
-                    strncpy(mailRecipientBuffer_, mail.senderName.c_str(), sizeof(mailRecipientBuffer_) - 1);
-                    mailRecipientBuffer_[sizeof(mailRecipientBuffer_) - 1] = '\0';
-                    std::string reSubject = "Re: " + mail.subject;
-                    strncpy(mailSubjectBuffer_, reSubject.c_str(), sizeof(mailSubjectBuffer_) - 1);
-                    mailSubjectBuffer_[sizeof(mailSubjectBuffer_) - 1] = '\0';
-                    mailBodyBuffer_[0] = '\0';
-                    mailComposeMoney_[0] = 0;
-                    mailComposeMoney_[1] = 0;
-                    mailComposeMoney_[2] = 0;
-                    gameHandler.openMailCompose();
-                }
-            } else {
-                ImGui::TextDisabled("Select a mail to read.");
-            }
-            ImGui::EndChild();
-        }
-    }
-    ImGui::End();
-
-    if (!open) {
-        gameHandler.closeMailbox();
-    }
-}
-
-void WindowManager::renderMailComposeWindow(game::GameHandler& gameHandler,
-                                   InventoryScreen& inventoryScreen) {
-    if (!gameHandler.isMailComposeOpen()) return;
-
-    auto* window = services_.window;
-    float screenW = window ? static_cast<float>(window->getWidth()) : 1280.0f;
-    float screenH = window ? static_cast<float>(window->getHeight()) : 720.0f;
-
-    ImGui::SetNextWindowPos(ImVec2(screenW / 2 - 190, screenH / 2 - 250), ImGuiCond_Appearing);
-    ImGui::SetNextWindowSize(ImVec2(400, 500), ImGuiCond_Appearing);
-
-    bool open = true;
-    if (ImGui::Begin("Send Mail", &open)) {
-        ImGui::Text("To:");
-        ImGui::SameLine(60);
-        ImGui::SetNextItemWidth(-1);
-        ImGui::InputText("##MailTo", mailRecipientBuffer_, sizeof(mailRecipientBuffer_));
-
-        ImGui::Text("Subject:");
-        ImGui::SameLine(60);
-        ImGui::SetNextItemWidth(-1);
-        ImGui::InputText("##MailSubject", mailSubjectBuffer_, sizeof(mailSubjectBuffer_));
-
-        ImGui::Text("Body:");
-        ImGui::InputTextMultiline("##MailBody", mailBodyBuffer_, sizeof(mailBodyBuffer_),
-                                   ImVec2(-1, 120));
-
-        // Attachments section
-        int attachCount = gameHandler.getMailAttachmentCount();
-        ImGui::Text("Attachments (%d/12):", attachCount);
-        ImGui::SameLine();
-        ImGui::TextColored(kColorGray, "Right-click items in bags to attach");
-
-        const auto& attachments = gameHandler.getMailAttachments();
-        // Show attachment slots in a grid (6 per row)
-        for (int i = 0; i < game::GameHandler::MAIL_MAX_ATTACHMENTS; ++i) {
-            if (i % 6 != 0) ImGui::SameLine();
-            ImGui::PushID(i + 5000);
-            const auto& att = attachments[i];
-            if (att.occupied()) {
-                // Show item with quality color border
-                ImVec4 qualColor = ui::InventoryScreen::getQualityColor(att.item.quality);
-                ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(qualColor.x * 0.3f, qualColor.y * 0.3f, qualColor.z * 0.3f, 0.8f));
-                ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(qualColor.x * 0.5f, qualColor.y * 0.5f, qualColor.z * 0.5f, 0.9f));
-
-                // Try to show icon
-                VkDescriptorSet icon = inventoryScreen.getItemIcon(att.item.displayInfoId);
-                bool clicked = false;
-                if (icon) {
-                    clicked = ImGui::ImageButton("##att", (ImTextureID)icon, ImVec2(30, 30));
-                } else {
-                    // Truncate name to fit
-                    std::string label = att.item.name.substr(0, 4);
-                    clicked = ImGui::Button(label.c_str(), ImVec2(36, 36));
-                }
-                ImGui::PopStyleColor(2);
-
-                if (clicked) {
-                    gameHandler.detachMailAttachment(i);
-                }
-                if (ImGui::IsItemHovered()) {
-                    ImGui::BeginTooltip();
-                    ImGui::TextColored(qualColor, "%s", att.item.name.c_str());
-                    ImGui::TextColored(ui::colors::kLightGray, "Click to remove");
-                    ImGui::EndTooltip();
-                }
-            } else {
-                ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.15f, 0.15f, 0.15f, 0.5f));
-                ImGui::Button("##empty", ImVec2(36, 36));
-                ImGui::PopStyleColor();
-            }
-            ImGui::PopID();
-        }
-
-        ImGui::Spacing();
-        ImGui::Text("Money:");
-        ImGui::SameLine(60);
-        ImGui::SetNextItemWidth(60);
-        ImGui::InputInt("##MailGold", &mailComposeMoney_[0], 0, 0);
-        if (mailComposeMoney_[0] < 0) mailComposeMoney_[0] = 0;
-        ImGui::SameLine();
-        ImGui::Text("g");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(40);
-        ImGui::InputInt("##MailSilver", &mailComposeMoney_[1], 0, 0);
-        if (mailComposeMoney_[1] < 0) mailComposeMoney_[1] = 0;
-        if (mailComposeMoney_[1] > 99) mailComposeMoney_[1] = 99;
-        ImGui::SameLine();
-        ImGui::Text("s");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(40);
-        ImGui::InputInt("##MailCopper", &mailComposeMoney_[2], 0, 0);
-        if (mailComposeMoney_[2] < 0) mailComposeMoney_[2] = 0;
-        if (mailComposeMoney_[2] > 99) mailComposeMoney_[2] = 99;
-        ImGui::SameLine();
-        ImGui::Text("c");
-
-        uint64_t totalMoney = static_cast<uint64_t>(mailComposeMoney_[0]) * 10000 +
-                              static_cast<uint64_t>(mailComposeMoney_[1]) * 100 +
-                              static_cast<uint64_t>(mailComposeMoney_[2]);
-
-        uint32_t sendCost = attachCount > 0 ? static_cast<uint32_t>(30 * attachCount) : 30u;
-        ImGui::TextColored(kColorGray, "Sending cost: %uc", sendCost);
-
-        ImGui::Spacing();
-        bool canSend = (strlen(mailRecipientBuffer_) > 0);
-        if (!canSend) ImGui::BeginDisabled();
-        if (ImGui::Button("Send", ImVec2(80, 0))) {
-            gameHandler.sendMail(mailRecipientBuffer_, mailSubjectBuffer_,
-                                 mailBodyBuffer_, totalMoney);
-        }
-        if (!canSend) ImGui::EndDisabled();
-
-        ImGui::SameLine();
-        if (ImGui::Button("Cancel", ImVec2(80, 0))) {
-            gameHandler.closeMailCompose();
-        }
-    }
-    ImGui::End();
-
-    if (!open) {
-        gameHandler.closeMailCompose();
-    }
-}
-
-void WindowManager::renderBankWindow(game::GameHandler& gameHandler,
-                             InventoryScreen& inventoryScreen,
-                             ChatPanel& chatPanel) {
-    if (!gameHandler.isBankOpen()) return;
-
-    bool open = true;
-    ImGui::SetNextWindowSize(ImVec2(480, 420), ImGuiCond_FirstUseEver);
-    if (!ImGui::Begin("Bank", &open)) {
-        ImGui::End();
-        if (!open) gameHandler.closeBank();
-        return;
-    }
-
-    auto& inv = gameHandler.getInventory();
-    bool isHolding = inventoryScreen.isHoldingItem();
-    constexpr float SLOT_SIZE = 42.0f;
-    static constexpr float kBankPickupHold = 0.10f; // seconds
-    // Persistent pickup tracking for bank (mirrors inventory_screen's pickupPending_)
-    static bool bankPickupPending = false;
-    static float bankPickupPressTime = 0.0f;
-    static int bankPickupType = 0; // 0=main bank, 1=bank bag slot, 2=bank bag equip slot
-    static int bankPickupIndex = -1;
-    static int bankPickupBagIndex = -1;
-    static int bankPickupBagSlotIndex = -1;
-
-    // Helper: render a bank item slot with icon, click-and-hold pickup, drop, tooltip
-    auto renderBankItemSlot = [&](const game::ItemSlot& slot, int pickType, int mainIdx,
-                                   int bagIdx, int bagSlotIdx, uint8_t dstBag, uint8_t dstSlot) {
-        ImDrawList* drawList = ImGui::GetWindowDrawList();
-        ImVec2 pos = ImGui::GetCursorScreenPos();
-
-        if (slot.empty()) {
-            ImU32 bgCol = IM_COL32(30, 30, 30, 200);
-            ImU32 borderCol = IM_COL32(60, 60, 60, 200);
-            if (isHolding) {
-                bgCol = IM_COL32(20, 50, 20, 200);
-                borderCol = IM_COL32(0, 180, 0, 200);
-            }
-            drawList->AddRectFilled(pos, ImVec2(pos.x + SLOT_SIZE, pos.y + SLOT_SIZE), bgCol);
-            drawList->AddRect(pos, ImVec2(pos.x + SLOT_SIZE, pos.y + SLOT_SIZE), borderCol);
-            ImGui::InvisibleButton("slot", ImVec2(SLOT_SIZE, SLOT_SIZE));
-            if (isHolding && ImGui::IsItemHovered() && ImGui::IsMouseReleased(ImGuiMouseButton_Left)) {
-                inventoryScreen.dropIntoBankSlot(gameHandler, dstBag, dstSlot);
-            }
-        } else {
-            const auto& item = slot.item;
-            ImVec4 qc = InventoryScreen::getQualityColor(item.quality);
-            ImU32 borderCol = ImGui::ColorConvertFloat4ToU32(qc);
-            VkDescriptorSet iconTex = inventoryScreen.getItemIcon(item.displayInfoId);
-
-            if (iconTex) {
-                drawList->AddImage((ImTextureID)(uintptr_t)iconTex, pos,
-                                   ImVec2(pos.x + SLOT_SIZE, pos.y + SLOT_SIZE));
-                drawList->AddRect(pos, ImVec2(pos.x + SLOT_SIZE, pos.y + SLOT_SIZE),
-                                  borderCol, 0.0f, 0, 2.0f);
-            } else {
-                ImU32 bgCol = IM_COL32(40, 35, 30, 220);
-                drawList->AddRectFilled(pos, ImVec2(pos.x + SLOT_SIZE, pos.y + SLOT_SIZE), bgCol);
-                drawList->AddRect(pos, ImVec2(pos.x + SLOT_SIZE, pos.y + SLOT_SIZE),
-                                  borderCol, 0.0f, 0, 2.0f);
-                if (!item.name.empty()) {
-                    char abbr[3] = { item.name[0], item.name.size() > 1 ? item.name[1] : '\0', '\0' };
-                    float tw = ImGui::CalcTextSize(abbr).x;
-                    drawList->AddText(ImVec2(pos.x + (SLOT_SIZE - tw) * 0.5f, pos.y + 2.0f),
-                                      ImGui::ColorConvertFloat4ToU32(qc), abbr);
-                }
-            }
-
-            if (item.stackCount > 1) {
-                char countStr[16];
-                snprintf(countStr, sizeof(countStr), "%u", item.stackCount);
-                float cw = ImGui::CalcTextSize(countStr).x;
-                drawList->AddText(ImVec2(pos.x + SLOT_SIZE - cw - 2.0f, pos.y + SLOT_SIZE - 14.0f),
-                                  IM_COL32(255, 255, 255, 220), countStr);
-            }
-
-            ImGui::InvisibleButton("slot", ImVec2(SLOT_SIZE, SLOT_SIZE));
-
-            if (!isHolding) {
-                // Start pickup tracking on mouse press
-                if (ImGui::IsItemClicked(ImGuiMouseButton_Left)) {
-                    bankPickupPending = true;
-                    bankPickupPressTime = ImGui::GetTime();
-                    bankPickupType = pickType;
-                    bankPickupIndex = mainIdx;
-                    bankPickupBagIndex = bagIdx;
-                    bankPickupBagSlotIndex = bagSlotIdx;
-                }
-                // Check if held long enough to pick up
-                if (bankPickupPending && ImGui::IsMouseDown(ImGuiMouseButton_Left) &&
-                    (ImGui::GetTime() - bankPickupPressTime) >= kBankPickupHold) {
-                    bool sameSlot = (bankPickupType == pickType);
-                    if (pickType == 0)
-                        sameSlot = sameSlot && (bankPickupIndex == mainIdx);
-                    else if (pickType == 1)
-                        sameSlot = sameSlot && (bankPickupBagIndex == bagIdx) && (bankPickupBagSlotIndex == bagSlotIdx);
-                    else if (pickType == 2)
-                        sameSlot = sameSlot && (bankPickupIndex == mainIdx);
-
-                    if (sameSlot && ImGui::IsItemHovered()) {
-                        bankPickupPending = false;
-                        if (pickType == 0) {
-                            inventoryScreen.pickupFromBank(inv, mainIdx);
-                        } else if (pickType == 1) {
-                            inventoryScreen.pickupFromBankBag(inv, bagIdx, bagSlotIdx);
-                        } else if (pickType == 2) {
-                            inventoryScreen.pickupFromBankBagEquip(inv, mainIdx);
-                        }
-                    }
-                }
-            } else {
-                // Drop/swap on mouse release
-                if (ImGui::IsItemHovered() && ImGui::IsMouseReleased(ImGuiMouseButton_Left)) {
-                    inventoryScreen.dropIntoBankSlot(gameHandler, dstBag, dstSlot);
-                }
-            }
-
-            // Tooltip
-            if (ImGui::IsItemHovered() && !isHolding) {
-                auto* info = gameHandler.getItemInfo(item.itemId);
-                if (info && info->valid)
-                    inventoryScreen.renderItemTooltip(*info);
-                else {
-                    ImGui::BeginTooltip();
-                    ImGui::TextColored(qc, "%s", item.name.c_str());
-                    ImGui::EndTooltip();
-                }
-
-                // Shift-click to insert item link into chat
-                if (ImGui::IsMouseClicked(ImGuiMouseButton_Left) && ImGui::GetIO().KeyShift
-                    && !item.name.empty()) {
-                    auto* info2 = gameHandler.getItemInfo(item.itemId);
-                    uint8_t q = (info2 && info2->valid)
-                        ? static_cast<uint8_t>(info2->quality)
-                        : static_cast<uint8_t>(item.quality);
-                    const std::string& lname = (info2 && info2->valid && !info2->name.empty())
-                        ? info2->name : item.name;
-                    std::string link = buildItemChatLink(item.itemId, q, lname);
-                    chatPanel.insertChatLink(link);
-                }
-            }
-        }
-    };
-
-    // Main bank slots (24 for Classic, 28 for TBC/WotLK)
-    int bankSlotCount = gameHandler.getEffectiveBankSlots();
-    int bankBagCount = gameHandler.getEffectiveBankBagSlots();
-    ImGui::Text("Bank Slots");
-    ImGui::Separator();
-    for (int i = 0; i < bankSlotCount; i++) {
-        if (i % 7 != 0) ImGui::SameLine();
-        ImGui::PushID(i + 1000);
-        renderBankItemSlot(inv.getBankSlot(i), 0, i, -1, -1, 0xFF, static_cast<uint8_t>(39 + i));
-        ImGui::PopID();
-    }
-
-    // Bank bag equip slots — show bag icon with pickup/drop, or "Buy Slot"
-    ImGui::Spacing();
-    ImGui::Separator();
-    ImGui::Text("Bank Bags");
-    uint8_t purchased = inv.getPurchasedBankBagSlots();
-    for (int i = 0; i < bankBagCount; i++) {
-        if (i > 0) ImGui::SameLine();
-        ImGui::PushID(i + 2000);
-
-        int bagSize = inv.getBankBagSize(i);
-        if (i < purchased || bagSize > 0) {
-            const auto& bagSlot = inv.getBankBagItem(i);
-            // Render as an item slot: icon with pickup/drop (pickType=2 for bag equip)
-            renderBankItemSlot(bagSlot, 2, i, -1, -1, 0xFF, static_cast<uint8_t>(67 + i));
-        } else {
-            if (ImGui::Button("Buy Slot", ImVec2(50, 30))) {
-                gameHandler.buyBankSlot();
-            }
-        }
-        ImGui::PopID();
-    }
-
-    // Show expanded bank bag contents
-    for (int bagIdx = 0; bagIdx < bankBagCount; bagIdx++) {
-        int bagSize = inv.getBankBagSize(bagIdx);
-        if (bagSize <= 0) continue;
-
-        ImGui::Spacing();
-        ImGui::Text("Bank Bag %d (%d slots)", bagIdx + 1, bagSize);
-        for (int s = 0; s < bagSize; s++) {
-            if (s % 7 != 0) ImGui::SameLine();
-            ImGui::PushID(3000 + bagIdx * 100 + s);
-            renderBankItemSlot(inv.getBankBagSlot(bagIdx, s), 1, -1, bagIdx, s,
-                               static_cast<uint8_t>(67 + bagIdx), static_cast<uint8_t>(s));
-            ImGui::PopID();
-        }
-    }
-
-    ImGui::End();
-
-    if (!open) gameHandler.closeBank();
-}
-
-void WindowManager::renderGuildBankWindow(game::GameHandler& gameHandler,
-                                  InventoryScreen& inventoryScreen,
-                                  ChatPanel& chatPanel) {
-    if (!gameHandler.isGuildBankOpen()) return;
-
-    bool open = true;
-    ImGui::SetNextWindowSize(ImVec2(520, 500), ImGuiCond_FirstUseEver);
-    if (!ImGui::Begin("Guild Bank", &open)) {
-        ImGui::End();
-        if (!open) gameHandler.closeGuildBank();
-        return;
-    }
-
-    const auto& data = gameHandler.getGuildBankData();
-    uint8_t activeTab = gameHandler.getGuildBankActiveTab();
-
-    // Money display
-    uint32_t gold = static_cast<uint32_t>(data.money / 10000);
-    uint32_t silver = static_cast<uint32_t>((data.money / 100) % 100);
-    uint32_t copper = static_cast<uint32_t>(data.money % 100);
-    ImGui::TextDisabled("Guild Bank Money:"); ImGui::SameLine(0, 4);
-    renderCoinsText(gold, silver, copper);
-
-    // Tab bar
-    if (!data.tabs.empty()) {
-        for (size_t i = 0; i < data.tabs.size(); i++) {
-            if (i > 0) ImGui::SameLine();
-            bool selected = (i == activeTab);
-            if (selected) ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.3f, 0.5f, 0.8f, 1.0f));
-            std::string tabLabel = data.tabs[i].tabName.empty() ? ("Tab " + std::to_string(i + 1)) : data.tabs[i].tabName;
-            if (ImGui::Button(tabLabel.c_str())) {
-                gameHandler.queryGuildBankTab(static_cast<uint8_t>(i));
-            }
-            if (selected) ImGui::PopStyleColor();
-        }
-    }
-
-    // Buy tab button
-    if (data.tabs.size() < 6) {
-        ImGui::SameLine();
-        if (ImGui::Button("Buy Tab")) {
-            gameHandler.buyGuildBankTab();
-        }
-    }
-
-    ImGui::Separator();
-
-    // Tab items (98 slots = 14 columns × 7 rows)
-    constexpr float GB_SLOT = 34.0f;
-    ImDrawList* gbDraw = ImGui::GetWindowDrawList();
-    for (size_t i = 0; i < data.tabItems.size(); i++) {
-        if (i % 14 != 0) ImGui::SameLine(0.0f, 2.0f);
-        const auto& item = data.tabItems[i];
-        ImGui::PushID(static_cast<int>(i) + 5000);
-
-        ImVec2 pos = ImGui::GetCursorScreenPos();
-
-        if (item.itemEntry == 0) {
-            gbDraw->AddRectFilled(pos, ImVec2(pos.x + GB_SLOT, pos.y + GB_SLOT),
-                                  IM_COL32(30, 30, 30, 200));
-            gbDraw->AddRect(pos, ImVec2(pos.x + GB_SLOT, pos.y + GB_SLOT),
-                            IM_COL32(60, 60, 60, 180));
-            ImGui::InvisibleButton("##gbempty", ImVec2(GB_SLOT, GB_SLOT));
-        } else {
-            auto* info = gameHandler.getItemInfo(item.itemEntry);
-            game::ItemQuality quality = game::ItemQuality::COMMON;
-            std::string name = "Item " + std::to_string(item.itemEntry);
-            uint32_t displayInfoId = 0;
-            if (info) {
-                quality = static_cast<game::ItemQuality>(info->quality);
-                name = info->name;
-                displayInfoId = info->displayInfoId;
-            }
-            ImVec4 qc = InventoryScreen::getQualityColor(quality);
-            ImU32 borderCol = ImGui::ColorConvertFloat4ToU32(qc);
-
-            VkDescriptorSet iconTex = displayInfoId ? inventoryScreen.getItemIcon(displayInfoId) : VK_NULL_HANDLE;
-            if (iconTex) {
-                gbDraw->AddImage((ImTextureID)(uintptr_t)iconTex, pos,
-                                 ImVec2(pos.x + GB_SLOT, pos.y + GB_SLOT));
-                gbDraw->AddRect(pos, ImVec2(pos.x + GB_SLOT, pos.y + GB_SLOT),
-                                borderCol, 0.0f, 0, 1.5f);
-            } else {
-                gbDraw->AddRectFilled(pos, ImVec2(pos.x + GB_SLOT, pos.y + GB_SLOT),
-                                      IM_COL32(40, 35, 30, 220));
-                gbDraw->AddRect(pos, ImVec2(pos.x + GB_SLOT, pos.y + GB_SLOT),
-                                borderCol, 0.0f, 0, 1.5f);
-                if (!name.empty() && name[0] != 'I') {
-                    char abbr[3] = { name[0], name.size() > 1 ? name[1] : '\0', '\0' };
-                    float tw = ImGui::CalcTextSize(abbr).x;
-                    gbDraw->AddText(ImVec2(pos.x + (GB_SLOT - tw) * 0.5f, pos.y + 2.0f),
-                                    borderCol, abbr);
-                }
-            }
-
-            if (item.stackCount > 1) {
-                char cnt[16];
-                snprintf(cnt, sizeof(cnt), "%u", item.stackCount);
-                float cw = ImGui::CalcTextSize(cnt).x;
-                gbDraw->AddText(ImVec2(pos.x + 1.0f, pos.y + 1.0f), IM_COL32(0, 0, 0, 200), cnt);
-                gbDraw->AddText(ImVec2(pos.x + GB_SLOT - cw - 2.0f, pos.y + GB_SLOT - 14.0f),
-                                IM_COL32(255, 255, 255, 220), cnt);
-            }
-
-            ImGui::InvisibleButton("##gbslot", ImVec2(GB_SLOT, GB_SLOT));
-            if (ImGui::IsItemClicked(ImGuiMouseButton_Left) && !ImGui::GetIO().KeyShift) {
-                gameHandler.guildBankWithdrawItem(activeTab, item.slotId, 0xFF, 0);
-            }
-            if (ImGui::IsItemHovered()) {
-                if (info && info->valid)
-                    inventoryScreen.renderItemTooltip(*info);
-                // Shift-click to insert item link into chat
-                if (ImGui::IsMouseClicked(ImGuiMouseButton_Left) && ImGui::GetIO().KeyShift
-                    && !name.empty() && item.itemEntry != 0) {
-                    uint8_t q = static_cast<uint8_t>(quality);
-                    std::string link = buildItemChatLink(item.itemEntry, q, name);
-                    chatPanel.insertChatLink(link);
-                }
-            }
-        }
-        ImGui::PopID();
-    }
-
-    // Money deposit/withdraw
-    ImGui::Separator();
-    ImGui::Text("Money:");
-    ImGui::SameLine();
-    ImGui::SetNextItemWidth(60);
-    ImGui::InputInt("##gbg", &guildBankMoneyInput_[0], 0); ImGui::SameLine(); ImGui::Text("g");
-    ImGui::SameLine();
-    ImGui::SetNextItemWidth(40);
-    ImGui::InputInt("##gbs", &guildBankMoneyInput_[1], 0); ImGui::SameLine(); ImGui::Text("s");
-    ImGui::SameLine();
-    ImGui::SetNextItemWidth(40);
-    ImGui::InputInt("##gbc", &guildBankMoneyInput_[2], 0); ImGui::SameLine(); ImGui::Text("c");
-
-    ImGui::SameLine();
-    if (ImGui::Button("Deposit")) {
-        uint32_t amount = guildBankMoneyInput_[0] * 10000 + guildBankMoneyInput_[1] * 100 + guildBankMoneyInput_[2];
-        if (amount > 0) gameHandler.depositGuildBankMoney(amount);
-    }
-    ImGui::SameLine();
-    if (ImGui::Button("Withdraw")) {
-        uint32_t amount = guildBankMoneyInput_[0] * 10000 + guildBankMoneyInput_[1] * 100 + guildBankMoneyInput_[2];
-        if (amount > 0) gameHandler.withdrawGuildBankMoney(amount);
-    }
-
-    if (data.withdrawAmount >= 0) {
-        ImGui::Text("Remaining withdrawals: %d", data.withdrawAmount);
-    }
-
-    ImGui::End();
-
-    if (!open) gameHandler.closeGuildBank();
-}
-
-void WindowManager::renderAuctionHouseWindow(game::GameHandler& gameHandler,
-                                     InventoryScreen& inventoryScreen,
-                                     ChatPanel& chatPanel) {
-    if (!gameHandler.isAuctionHouseOpen()) return;
-
-    bool open = true;
-    ImGui::SetNextWindowSize(ImVec2(650, 500), ImGuiCond_FirstUseEver);
-    if (!ImGui::Begin("Auction House", &open)) {
-        ImGui::End();
-        if (!open) gameHandler.closeAuctionHouse();
-        return;
-    }
-
-    int tab = gameHandler.getAuctionActiveTab();
-
-    // Tab buttons
-    const char* tabNames[] = {"Browse", "Bids", "Auctions"};
-    for (int i = 0; i < 3; i++) {
-        if (i > 0) ImGui::SameLine();
-        bool selected = (tab == i);
-        if (selected) ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.3f, 0.5f, 0.8f, 1.0f));
-        if (ImGui::Button(tabNames[i], ImVec2(100, 0))) {
-            gameHandler.setAuctionActiveTab(i);
-            if (i == 1) gameHandler.auctionListBidderItems();
-            else if (i == 2) gameHandler.auctionListOwnerItems();
-        }
-        if (selected) ImGui::PopStyleColor();
-    }
-
-    ImGui::Separator();
-
-    if (tab == 0) {
-        // Browse tab - Search filters
-
-        // --- Helper: resolve current UI filter state into wire-format search params ---
-        // WoW 3.3.5a item class IDs:
-        //   0=Consumable, 1=Container, 2=Weapon, 3=Gem, 4=Armor,
-        //   7=Projectile/TradeGoods, 9=Recipe, 11=Quiver, 15=Miscellaneous
-        struct AHClassMapping { const char* label; uint32_t classId; };
-        static const AHClassMapping classMappings[] = {
-            {"All",         0xFFFFFFFF},
-            {"Weapon",      2},
-            {"Armor",       4},
-            {"Container",   1},
-            {"Consumable",  0},
-            {"Trade Goods", 7},
-            {"Gem",         3},
-            {"Recipe",      9},
-            {"Quiver",      11},
-            {"Miscellaneous", 15},
-        };
-        static constexpr int NUM_CLASSES = 10;
-
-        // Weapon subclass IDs (WoW 3.3.5a)
-        struct AHSubMapping { const char* label; uint32_t subId; };
-        static const AHSubMapping weaponSubs[] = {
-            {"All", 0xFFFFFFFF}, {"Axe (1H)", 0}, {"Axe (2H)", 1}, {"Bow", 2},
-            {"Gun", 3}, {"Mace (1H)", 4}, {"Mace (2H)", 5}, {"Polearm", 6},
-            {"Sword (1H)", 7}, {"Sword (2H)", 8}, {"Staff", 10},
-            {"Fist Weapon", 13}, {"Dagger", 15}, {"Thrown", 16},
-            {"Crossbow", 18}, {"Wand", 19},
-        };
-        static constexpr int NUM_WEAPON_SUBS = 16;
-
-        // Armor subclass IDs
-        static const AHSubMapping armorSubs[] = {
-            {"All", 0xFFFFFFFF}, {"Cloth", 1}, {"Leather", 2}, {"Mail", 3},
-            {"Plate", 4}, {"Shield", 6}, {"Miscellaneous", 0},
-        };
-        static constexpr int NUM_ARMOR_SUBS = 7;
-
-        auto getSearchClassId = [&]() -> uint32_t {
-            if (auctionItemClass_ < 0 || auctionItemClass_ >= NUM_CLASSES) return 0xFFFFFFFF;
-            return classMappings[auctionItemClass_].classId;
-        };
-
-        auto getSearchSubClassId = [&]() -> uint32_t {
-            if (auctionItemSubClass_ < 0) return 0xFFFFFFFF;
-            uint32_t cid = getSearchClassId();
-            if (cid == 2 && auctionItemSubClass_ < NUM_WEAPON_SUBS)
-                return weaponSubs[auctionItemSubClass_].subId;
-            if (cid == 4 && auctionItemSubClass_ < NUM_ARMOR_SUBS)
-                return armorSubs[auctionItemSubClass_].subId;
-            return 0xFFFFFFFF;
-        };
-
-        auto doSearch = [&](uint32_t offset) {
-            auctionBrowseOffset_ = offset;
-            if (auctionLevelMin_ < 0) auctionLevelMin_ = 0;
-            if (auctionLevelMax_ < 0) auctionLevelMax_ = 0;
-            uint32_t q = auctionQuality_ > 0 ? static_cast<uint32_t>(auctionQuality_ - 1) : 0xFFFFFFFF;
-            gameHandler.auctionSearch(auctionSearchName_,
-                static_cast<uint8_t>(auctionLevelMin_),
-                static_cast<uint8_t>(auctionLevelMax_),
-                q, getSearchClassId(), getSearchSubClassId(), 0,
-                auctionUsableOnly_ ? 1 : 0, offset);
-        };
-
-        // Row 1: Name + Level range
-        ImGui::SetNextItemWidth(200);
-        bool enterPressed = ImGui::InputText("Name", auctionSearchName_, sizeof(auctionSearchName_),
-                                              ImGuiInputTextFlags_EnterReturnsTrue);
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(50);
-        ImGui::InputInt("Min Lv", &auctionLevelMin_, 0);
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(50);
-        ImGui::InputInt("Max Lv", &auctionLevelMax_, 0);
-
-        // Row 2: Quality + Category + Subcategory + Search button
-        const char* qualities[] = {"All", "Poor", "Common", "Uncommon", "Rare", "Epic", "Legendary"};
-        ImGui::SetNextItemWidth(100);
-        ImGui::Combo("Quality", &auctionQuality_, qualities, 7);
-
-        ImGui::SameLine();
-        // Build class label list from mappings
-        const char* classLabels[NUM_CLASSES];
-        for (int c = 0; c < NUM_CLASSES; c++) classLabels[c] = classMappings[c].label;
-        ImGui::SetNextItemWidth(120);
-        int classIdx = auctionItemClass_ < 0 ? 0 : auctionItemClass_;
-        if (ImGui::Combo("Category", &classIdx, classLabels, NUM_CLASSES)) {
-            if (classIdx != auctionItemClass_) auctionItemSubClass_ = -1;
-            auctionItemClass_ = classIdx;
-        }
-
-        // Subcategory (only for Weapon and Armor)
-        uint32_t curClassId = getSearchClassId();
-        if (curClassId == 2 || curClassId == 4) {
-            const AHSubMapping* subs = (curClassId == 2) ? weaponSubs : armorSubs;
-            int numSubs = (curClassId == 2) ? NUM_WEAPON_SUBS : NUM_ARMOR_SUBS;
-            const char* subLabels[20];
-            for (int s = 0; s < numSubs && s < 20; s++) subLabels[s] = subs[s].label;
-            int subIdx = auctionItemSubClass_ + 1;  // -1 → 0 ("All")
-            if (subIdx < 0 || subIdx >= numSubs) subIdx = 0;
-            ImGui::SameLine();
-            ImGui::SetNextItemWidth(110);
-            if (ImGui::Combo("Subcat", &subIdx, subLabels, numSubs)) {
-                auctionItemSubClass_ = subIdx - 1;  // 0 → -1 ("All")
-            }
-        }
-
-        ImGui::SameLine();
-        ImGui::Checkbox("Usable", &auctionUsableOnly_);
-        ImGui::SameLine();
-        float delay = gameHandler.getAuctionSearchDelay();
-        if (delay > 0.0f) {
-            char delayBuf[32];
-            snprintf(delayBuf, sizeof(delayBuf), "Search (%.0fs)", delay);
-            ImGui::BeginDisabled();
-            ImGui::Button(delayBuf);
-            ImGui::EndDisabled();
-        } else {
-            if (ImGui::Button("Search") || enterPressed) {
-                doSearch(0);
-            }
-        }
-
-        ImGui::Separator();
-
-        // Results table
-        const auto& results = gameHandler.getAuctionBrowseResults();
-        constexpr uint32_t AH_PAGE_SIZE = 50;
-        ImGui::Text("%zu results (of %u total)", results.auctions.size(), results.totalCount);
-
-        // Pagination
-        if (results.totalCount > AH_PAGE_SIZE) {
-            ImGui::SameLine();
-            uint32_t page = auctionBrowseOffset_ / AH_PAGE_SIZE + 1;
-            uint32_t totalPages = (results.totalCount + AH_PAGE_SIZE - 1) / AH_PAGE_SIZE;
-
-            if (auctionBrowseOffset_ == 0) ImGui::BeginDisabled();
-            if (ImGui::SmallButton("< Prev")) {
-                uint32_t newOff = (auctionBrowseOffset_ >= AH_PAGE_SIZE) ? auctionBrowseOffset_ - AH_PAGE_SIZE : 0;
-                doSearch(newOff);
-            }
-            if (auctionBrowseOffset_ == 0) ImGui::EndDisabled();
-
-            ImGui::SameLine();
-            ImGui::Text("Page %u/%u", page, totalPages);
-
-            ImGui::SameLine();
-            if (auctionBrowseOffset_ + AH_PAGE_SIZE >= results.totalCount) ImGui::BeginDisabled();
-            if (ImGui::SmallButton("Next >")) {
-                doSearch(auctionBrowseOffset_ + AH_PAGE_SIZE);
-            }
-            if (auctionBrowseOffset_ + AH_PAGE_SIZE >= results.totalCount) ImGui::EndDisabled();
-        }
-
-        if (ImGui::BeginChild("AuctionResults", ImVec2(0, -110), true)) {
-            if (ImGui::BeginTable("AuctionTable", 6, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
-                ImGui::TableSetupColumn("Item", ImGuiTableColumnFlags_WidthStretch);
-                ImGui::TableSetupColumn("Qty", ImGuiTableColumnFlags_WidthFixed, 40);
-                ImGui::TableSetupColumn("Time", ImGuiTableColumnFlags_WidthFixed, 60);
-                ImGui::TableSetupColumn("Bid", ImGuiTableColumnFlags_WidthFixed, 90);
-                ImGui::TableSetupColumn("Buyout", ImGuiTableColumnFlags_WidthFixed, 90);
-                ImGui::TableSetupColumn("##act", ImGuiTableColumnFlags_WidthFixed, 60);
-                ImGui::TableHeadersRow();
-
-                for (size_t i = 0; i < results.auctions.size(); i++) {
-                    const auto& auction = results.auctions[i];
-                    auto* info = gameHandler.getItemInfo(auction.itemEntry);
-                    std::string name = info ? info->name : ("Item #" + std::to_string(auction.itemEntry));
-                    // Append random suffix name (e.g., "of the Eagle") if present
-                    if (auction.randomPropertyId != 0) {
-                        std::string suffix = gameHandler.getRandomPropertyName(
-                            static_cast<int32_t>(auction.randomPropertyId));
-                        if (!suffix.empty()) name += " " + suffix;
-                    }
-                    game::ItemQuality quality = info ? static_cast<game::ItemQuality>(info->quality) : game::ItemQuality::COMMON;
-                    ImVec4 qc = InventoryScreen::getQualityColor(quality);
-
-                    ImGui::TableNextRow();
-                    ImGui::TableSetColumnIndex(0);
-                    // Item icon
-                    if (info && info->valid && info->displayInfoId != 0) {
-                        VkDescriptorSet iconTex = inventoryScreen.getItemIcon(info->displayInfoId);
-                        if (iconTex) {
-                            ImGui::Image((void*)(intptr_t)iconTex, ImVec2(16, 16));
-                            ImGui::SameLine();
-                        }
-                    }
-                    ImGui::TextColored(qc, "%s", name.c_str());
-                    // Item tooltip on hover; shift-click to insert chat link
-                    if (ImGui::IsItemHovered() && info && info->valid) {
-                        inventoryScreen.renderItemTooltip(*info);
-                    }
-                    if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left) &&
-                        ImGui::GetIO().KeyShift && info && info->valid && !info->name.empty()) {
-                        std::string link = buildItemChatLink(info->entry, info->quality, info->name);
-                        chatPanel.insertChatLink(link);
-                    }
-
-                    ImGui::TableSetColumnIndex(1);
-                    ImGui::Text("%u", auction.stackCount);
-
-                    ImGui::TableSetColumnIndex(2);
-                    // Time left display
-                    uint32_t mins = auction.timeLeftMs / 60000;
-                    if (mins > 720) ImGui::Text("Long");
-                    else if (mins > 120) ImGui::Text("Medium");
-                    else ImGui::TextColored(ImVec4(1, 0.3f, 0.3f, 1), "Short");
-
-                    ImGui::TableSetColumnIndex(3);
-                    {
-                        uint32_t bid = auction.currentBid > 0 ? auction.currentBid : auction.startBid;
-                        renderCoinsFromCopper(bid);
-                    }
-
-                    ImGui::TableSetColumnIndex(4);
-                    if (auction.buyoutPrice > 0) {
-                        renderCoinsFromCopper(auction.buyoutPrice);
-                    } else {
-                        ImGui::TextDisabled("--");
-                    }
-
-                    ImGui::TableSetColumnIndex(5);
-                    ImGui::PushID(static_cast<int>(i) + 7000);
-                    if (auction.buyoutPrice > 0 && ImGui::SmallButton("Buy")) {
-                        gameHandler.auctionBuyout(auction.auctionId, auction.buyoutPrice);
-                    }
-                    if (auction.buyoutPrice > 0) ImGui::SameLine();
-                    if (ImGui::SmallButton("Bid")) {
-                        uint32_t bidAmt = auction.currentBid > 0
-                            ? auction.currentBid + auction.minBidIncrement
-                            : auction.startBid;
-                        gameHandler.auctionPlaceBid(auction.auctionId, bidAmt);
-                    }
-                    ImGui::PopID();
-                }
-                ImGui::EndTable();
-            }
-        }
-        ImGui::EndChild();
-
-        // Sell section
-        ImGui::Separator();
-        ImGui::Text("Sell Item:");
-
-        // Item picker from backpack
-        {
-            auto& inv = gameHandler.getInventory();
-            // Build list of non-empty backpack slots
-            std::string preview = (auctionSellSlotIndex_ >= 0)
-                ? ([&]() -> std::string {
-                    const auto& slot = inv.getBackpackSlot(auctionSellSlotIndex_);
-                    if (!slot.empty()) {
-                        std::string s = slot.item.name;
-                        if (slot.item.stackCount > 1) s += " x" + std::to_string(slot.item.stackCount);
-                        return s;
-                    }
-                    return "Select item...";
-                })()
-                : "Select item...";
-
-            ImGui::SetNextItemWidth(250);
-            if (ImGui::BeginCombo("##sellitem", preview.c_str())) {
-                for (int i = 0; i < game::Inventory::BACKPACK_SLOTS; i++) {
-                    const auto& slot = inv.getBackpackSlot(i);
-                    if (slot.empty()) continue;
-                    ImGui::PushID(i + 9000);
-                    // Item icon
-                    if (slot.item.displayInfoId != 0) {
-                        VkDescriptorSet sIcon = inventoryScreen.getItemIcon(slot.item.displayInfoId);
-                        if (sIcon) {
-                            ImGui::Image((void*)(intptr_t)sIcon, ImVec2(16, 16));
-                            ImGui::SameLine();
-                        }
-                    }
-                    std::string label = slot.item.name;
-                    if (slot.item.stackCount > 1) label += " x" + std::to_string(slot.item.stackCount);
-                    ImVec4 iqc = InventoryScreen::getQualityColor(slot.item.quality);
-                    ImGui::PushStyleColor(ImGuiCol_Text, iqc);
-                    if (ImGui::Selectable(label.c_str(), auctionSellSlotIndex_ == i)) {
-                        auctionSellSlotIndex_ = i;
-                    }
-                    ImGui::PopStyleColor();
-                    ImGui::PopID();
-                }
-                ImGui::EndCombo();
-            }
-        }
-
-        ImGui::Text("Bid:");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(50);
-        ImGui::InputInt("##sbg", &auctionSellBid_[0], 0); ImGui::SameLine(); ImGui::Text("g");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(35);
-        ImGui::InputInt("##sbs", &auctionSellBid_[1], 0); ImGui::SameLine(); ImGui::Text("s");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(35);
-        ImGui::InputInt("##sbc", &auctionSellBid_[2], 0); ImGui::SameLine(); ImGui::Text("c");
-
-        ImGui::SameLine(0, 20);
-        ImGui::Text("Buyout:");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(50);
-        ImGui::InputInt("##sbog", &auctionSellBuyout_[0], 0); ImGui::SameLine(); ImGui::Text("g");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(35);
-        ImGui::InputInt("##sbos", &auctionSellBuyout_[1], 0); ImGui::SameLine(); ImGui::Text("s");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(35);
-        ImGui::InputInt("##sboc", &auctionSellBuyout_[2], 0); ImGui::SameLine(); ImGui::Text("c");
-
-        const char* durations[] = {"12 hours", "24 hours", "48 hours"};
-        ImGui::SetNextItemWidth(90);
-        ImGui::Combo("##dur", &auctionSellDuration_, durations, 3);
-        ImGui::SameLine();
-
-        // Create Auction button
-        bool canCreate = auctionSellSlotIndex_ >= 0 &&
-                         !gameHandler.getInventory().getBackpackSlot(auctionSellSlotIndex_).empty() &&
-                         (auctionSellBid_[0] > 0 || auctionSellBid_[1] > 0 || auctionSellBid_[2] > 0);
-        if (!canCreate) ImGui::BeginDisabled();
-        if (ImGui::Button("Create Auction")) {
-            uint32_t bidCopper = static_cast<uint32_t>(auctionSellBid_[0]) * 10000
-                               + static_cast<uint32_t>(auctionSellBid_[1]) * 100
-                               + static_cast<uint32_t>(auctionSellBid_[2]);
-            uint32_t buyoutCopper = static_cast<uint32_t>(auctionSellBuyout_[0]) * 10000
-                                  + static_cast<uint32_t>(auctionSellBuyout_[1]) * 100
-                                  + static_cast<uint32_t>(auctionSellBuyout_[2]);
-            const uint32_t durationMins[] = {720, 1440, 2880};
-            uint32_t dur = durationMins[auctionSellDuration_];
-            gameHandler.auctionSellItem(auctionSellSlotIndex_, bidCopper, buyoutCopper, dur);
-            // Clear sell inputs
-            auctionSellSlotIndex_ = -1;
-            auctionSellBid_[0] = auctionSellBid_[1] = auctionSellBid_[2] = 0;
-            auctionSellBuyout_[0] = auctionSellBuyout_[1] = auctionSellBuyout_[2] = 0;
-        }
-        if (!canCreate) ImGui::EndDisabled();
-
-    } else if (tab == 1) {
-        // Bids tab
-        const auto& results = gameHandler.getAuctionBidderResults();
-        ImGui::Text("Your Bids: %zu items", results.auctions.size());
-
-        if (ImGui::BeginTable("BidTable", 6, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg)) {
-            ImGui::TableSetupColumn("Item", ImGuiTableColumnFlags_WidthStretch);
-            ImGui::TableSetupColumn("Qty", ImGuiTableColumnFlags_WidthFixed, 40);
-            ImGui::TableSetupColumn("Your Bid", ImGuiTableColumnFlags_WidthFixed, 90);
-            ImGui::TableSetupColumn("Buyout", ImGuiTableColumnFlags_WidthFixed, 90);
-            ImGui::TableSetupColumn("Time", ImGuiTableColumnFlags_WidthFixed, 60);
-            ImGui::TableSetupColumn("##act", ImGuiTableColumnFlags_WidthFixed, 60);
-            ImGui::TableHeadersRow();
-
-            for (size_t bi = 0; bi < results.auctions.size(); bi++) {
-                const auto& a = results.auctions[bi];
-                auto* info = gameHandler.getItemInfo(a.itemEntry);
-                std::string name = info ? info->name : ("Item #" + std::to_string(a.itemEntry));
-                if (a.randomPropertyId != 0) {
-                    std::string suffix = gameHandler.getRandomPropertyName(
-                        static_cast<int32_t>(a.randomPropertyId));
-                    if (!suffix.empty()) name += " " + suffix;
-                }
-                game::ItemQuality quality = info ? static_cast<game::ItemQuality>(info->quality) : game::ItemQuality::COMMON;
-                ImVec4 bqc = InventoryScreen::getQualityColor(quality);
-
-                ImGui::TableNextRow();
-                ImGui::TableSetColumnIndex(0);
-                if (info && info->valid && info->displayInfoId != 0) {
-                    VkDescriptorSet bIcon = inventoryScreen.getItemIcon(info->displayInfoId);
-                    if (bIcon) {
-                        ImGui::Image((void*)(intptr_t)bIcon, ImVec2(16, 16));
-                        ImGui::SameLine();
-                    }
-                }
-                // High bidder indicator
-                bool isHighBidder = (a.bidderGuid != 0 && a.bidderGuid == gameHandler.getPlayerGuid());
-                if (isHighBidder) {
-                    ImGui::TextColored(ImVec4(0.2f, 0.9f, 0.2f, 1.0f), "[Winning]");
-                    ImGui::SameLine();
-                } else if (a.bidderGuid != 0) {
-                    ImGui::TextColored(ImVec4(0.9f, 0.3f, 0.3f, 1.0f), "[Outbid]");
-                    ImGui::SameLine();
-                }
-                ImGui::TextColored(bqc, "%s", name.c_str());
-                // Tooltip and shift-click
-                if (ImGui::IsItemHovered() && info && info->valid)
-                    inventoryScreen.renderItemTooltip(*info);
-                if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left) &&
-                    ImGui::GetIO().KeyShift && info && info->valid && !info->name.empty()) {
-                    std::string link = buildItemChatLink(info->entry, info->quality, info->name);
-                    chatPanel.insertChatLink(link);
-                }
-                ImGui::TableSetColumnIndex(1);
-                ImGui::Text("%u", a.stackCount);
-                ImGui::TableSetColumnIndex(2);
-                renderCoinsFromCopper(a.currentBid);
-                ImGui::TableSetColumnIndex(3);
-                if (a.buyoutPrice > 0)
-                    renderCoinsFromCopper(a.buyoutPrice);
-                else
-                    ImGui::TextDisabled("--");
-                ImGui::TableSetColumnIndex(4);
-                uint32_t mins = a.timeLeftMs / 60000;
-                if (mins > 720) ImGui::Text("Long");
-                else if (mins > 120) ImGui::Text("Medium");
-                else ImGui::TextColored(ImVec4(1, 0.3f, 0.3f, 1), "Short");
-
-                ImGui::TableSetColumnIndex(5);
-                ImGui::PushID(static_cast<int>(bi) + 7500);
-                if (a.buyoutPrice > 0 && ImGui::SmallButton("Buy")) {
-                    gameHandler.auctionBuyout(a.auctionId, a.buyoutPrice);
-                }
-                if (a.buyoutPrice > 0) ImGui::SameLine();
-                if (ImGui::SmallButton("Bid")) {
-                    uint32_t bidAmt = a.currentBid > 0
-                        ? a.currentBid + a.minBidIncrement
-                        : a.startBid;
-                    gameHandler.auctionPlaceBid(a.auctionId, bidAmt);
-                }
-                ImGui::PopID();
-            }
-            ImGui::EndTable();
-        }
-
-    } else if (tab == 2) {
-        // Auctions tab (your listings)
-        const auto& results = gameHandler.getAuctionOwnerResults();
-        ImGui::Text("Your Auctions: %zu items", results.auctions.size());
-
-        if (ImGui::BeginTable("OwnerTable", 5, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg)) {
-            ImGui::TableSetupColumn("Item", ImGuiTableColumnFlags_WidthStretch);
-            ImGui::TableSetupColumn("Qty", ImGuiTableColumnFlags_WidthFixed, 40);
-            ImGui::TableSetupColumn("Bid", ImGuiTableColumnFlags_WidthFixed, 90);
-            ImGui::TableSetupColumn("Buyout", ImGuiTableColumnFlags_WidthFixed, 90);
-            ImGui::TableSetupColumn("##cancel", ImGuiTableColumnFlags_WidthFixed, 60);
-            ImGui::TableHeadersRow();
-
-            for (size_t i = 0; i < results.auctions.size(); i++) {
-                const auto& a = results.auctions[i];
-                auto* info = gameHandler.getItemInfo(a.itemEntry);
-                std::string name = info ? info->name : ("Item #" + std::to_string(a.itemEntry));
-                if (a.randomPropertyId != 0) {
-                    std::string suffix = gameHandler.getRandomPropertyName(
-                        static_cast<int32_t>(a.randomPropertyId));
-                    if (!suffix.empty()) name += " " + suffix;
-                }
-                game::ItemQuality quality = info ? static_cast<game::ItemQuality>(info->quality) : game::ItemQuality::COMMON;
-
-                ImGui::TableNextRow();
-                ImGui::TableSetColumnIndex(0);
-                ImVec4 oqc = InventoryScreen::getQualityColor(quality);
-                if (info && info->valid && info->displayInfoId != 0) {
-                    VkDescriptorSet oIcon = inventoryScreen.getItemIcon(info->displayInfoId);
-                    if (oIcon) {
-                        ImGui::Image((void*)(intptr_t)oIcon, ImVec2(16, 16));
-                        ImGui::SameLine();
-                    }
-                }
-                // Bid activity indicator for seller
-                if (a.bidderGuid != 0) {
-                    ImGui::TextColored(ImVec4(1.0f, 0.85f, 0.2f, 1.0f), "[Bid]");
-                    ImGui::SameLine();
-                }
-                ImGui::TextColored(oqc, "%s", name.c_str());
-                if (ImGui::IsItemHovered() && info && info->valid)
-                    inventoryScreen.renderItemTooltip(*info);
-                if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left) &&
-                    ImGui::GetIO().KeyShift && info && info->valid && !info->name.empty()) {
-                    std::string link = buildItemChatLink(info->entry, info->quality, info->name);
-                    chatPanel.insertChatLink(link);
-                }
-                ImGui::TableSetColumnIndex(1);
-                ImGui::Text("%u", a.stackCount);
-                ImGui::TableSetColumnIndex(2);
-                {
-                    uint32_t bid = a.currentBid > 0 ? a.currentBid : a.startBid;
-                    renderCoinsFromCopper(bid);
-                }
-                ImGui::TableSetColumnIndex(3);
-                if (a.buyoutPrice > 0)
-                    renderCoinsFromCopper(a.buyoutPrice);
-                else
-                    ImGui::TextDisabled("--");
-                ImGui::TableSetColumnIndex(4);
-                ImGui::PushID(static_cast<int>(i) + 8000);
-                if (ImGui::SmallButton("Cancel")) {
-                    gameHandler.auctionCancelItem(a.auctionId);
-                }
-                ImGui::PopID();
-            }
-            ImGui::EndTable();
-        }
-    }
-
-    ImGui::End();
-
-    if (!open) gameHandler.closeAuctionHouse();
-}
-
-void WindowManager::renderInstanceLockouts(game::GameHandler& gameHandler) {
-    if (!showInstanceLockouts_) return;
-
-    ImGui::SetNextWindowSize(ImVec2(480, 0), ImGuiCond_Appearing);
-    ImGui::SetNextWindowPos(
-        ImVec2(ImGui::GetIO().DisplaySize.x / 2 - 240, 140), ImGuiCond_Appearing);
-
-    if (!ImGui::Begin("Instance Lockouts", &showInstanceLockouts_,
-                      ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize)) {
-        ImGui::End();
-        return;
-    }
-
-    const auto& lockouts = gameHandler.getInstanceLockouts();
-
-    if (lockouts.empty()) {
-        ImGui::TextColored(kColorGray, "No active instance lockouts.");
-    } else {
-        auto difficultyLabel = [](uint32_t diff) -> const char* {
-            switch (diff) {
-                case 0: return "Normal";
-                case 1: return "Heroic";
-                case 2: return "25-Man";
-                case 3: return "25-Man Heroic";
-                default: return "Unknown";
-            }
-        };
-
-        // Current UTC time for reset countdown
-        auto nowSec = static_cast<uint64_t>(std::time(nullptr));
-
-        if (ImGui::BeginTable("lockouts", 4,
-                              ImGuiTableFlags_SizingStretchProp |
-                              ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersOuter)) {
-            ImGui::TableSetupColumn("Instance",   ImGuiTableColumnFlags_WidthStretch);
-            ImGui::TableSetupColumn("Difficulty", ImGuiTableColumnFlags_WidthFixed, 110.0f);
-            ImGui::TableSetupColumn("Resets In",  ImGuiTableColumnFlags_WidthFixed, 100.0f);
-            ImGui::TableSetupColumn("Status",     ImGuiTableColumnFlags_WidthFixed, 60.0f);
-            ImGui::TableHeadersRow();
-
-            for (const auto& lo : lockouts) {
-                ImGui::TableNextRow();
-
-                // Instance name — use GameHandler's Map.dbc cache (avoids duplicate DBC load)
-                ImGui::TableSetColumnIndex(0);
-                std::string mapName = gameHandler.getMapName(lo.mapId);
-                if (!mapName.empty()) {
-                    ImGui::TextUnformatted(mapName.c_str());
-                } else {
-                    ImGui::Text("Map %u", lo.mapId);
-                }
-
-                // Difficulty
-                ImGui::TableSetColumnIndex(1);
-                ImGui::TextUnformatted(difficultyLabel(lo.difficulty));
-
-                // Reset countdown
-                ImGui::TableSetColumnIndex(2);
-                if (lo.resetTime > nowSec) {
-                    uint64_t remaining = lo.resetTime - nowSec;
-                    uint64_t days  = remaining / 86400;
-                    uint64_t hours = (remaining % 86400) / 3600;
-                    if (days > 0) {
-                        ImGui::Text("%llud %lluh",
-                            static_cast<unsigned long long>(days),
-                            static_cast<unsigned long long>(hours));
-                    } else {
-                        uint64_t mins = (remaining % 3600) / 60;
-                        ImGui::Text("%lluh %llum",
-                            static_cast<unsigned long long>(hours),
-                            static_cast<unsigned long long>(mins));
-                    }
-                } else {
-                    ImGui::TextColored(kColorDarkGray, "Expired");
-                }
-
-                // Locked / Extended status
-                ImGui::TableSetColumnIndex(3);
-                if (lo.extended) {
-                    ImGui::TextColored(ImVec4(0.3f, 0.7f, 1.0f, 1.0f), "Ext");
-                } else if (lo.locked) {
-                    ImGui::TextColored(colors::kSoftRed, "Locked");
-                } else {
-                    ImGui::TextColored(ImVec4(0.5f, 0.9f, 0.5f, 1.0f), "Open");
-                }
-            }
-
-            ImGui::EndTable();
-        }
-    }
-
-    ImGui::End();
-}
-
-// ============================================================================
-// Battleground score frame
-//
-// Displays the current score for the player's battleground using world states.
-// Shown in the top-centre of the screen whenever SMSG_INIT_WORLD_STATES has
-// been received for a known BG map.  The layout adapts per battleground:
-//
-//   WSG  489 – Alliance / Horde flag captures (max 3)
-//   AB   529 – Alliance / Horde resource scores (max 1600)
-//   AV    30 – Alliance / Horde reinforcements
-//   EotS 566 – Alliance / Horde resource scores (max 1600)
-// ============================================================================
-// ─── Who Results Window ───────────────────────────────────────────────────────
-// ─── Combat Log Window ────────────────────────────────────────────────────────
-// ─── Achievement Window ───────────────────────────────────────────────────────
-void WindowManager::renderAchievementWindow(game::GameHandler& gameHandler) {
-    if (!showAchievementWindow_) return;
-
-    ImGui::SetNextWindowSize(ImVec2(420, 480), ImGuiCond_FirstUseEver);
-    ImGui::SetNextWindowPos(ImVec2(200, 150), ImGuiCond_FirstUseEver);
-
-    if (!ImGui::Begin("Achievements", &showAchievementWindow_)) {
-        ImGui::End();
-        return;
-    }
-
-    const auto& earned = gameHandler.getEarnedAchievements();
-    const auto& criteria = gameHandler.getCriteriaProgress();
-
-    ImGui::SetNextItemWidth(180.0f);
-    ImGui::InputText("##achsearch", achievementSearchBuf_, sizeof(achievementSearchBuf_));
-    ImGui::SameLine();
-    if (ImGui::Button("Clear")) achievementSearchBuf_[0] = '\0';
-    ImGui::Separator();
-
-    std::string filter(achievementSearchBuf_);
-    for (char& c : filter) c = static_cast<char>(tolower(static_cast<unsigned char>(c)));
-
-    if (ImGui::BeginTabBar("##achtabs")) {
-        // --- Earned tab ---
-        char earnedLabel[32];
-        snprintf(earnedLabel, sizeof(earnedLabel), "Earned (%u)###earned", static_cast<unsigned>(earned.size()));
-        if (ImGui::BeginTabItem(earnedLabel)) {
-            if (earned.empty()) {
-                ImGui::TextDisabled("No achievements earned yet.");
-            } else {
-                ImGui::BeginChild("##achlist", ImVec2(0, 0), false);
-                std::vector<uint32_t> ids(earned.begin(), earned.end());
-                std::sort(ids.begin(), ids.end());
-                for (uint32_t id : ids) {
-                    const std::string& name = gameHandler.getAchievementName(id);
-                    const std::string& display = name.empty() ? std::to_string(id) : name;
-                    if (!filter.empty()) {
-                        std::string lower = display;
-                        for (char& c : lower) c = static_cast<char>(tolower(static_cast<unsigned char>(c)));
-                        if (lower.find(filter) == std::string::npos) continue;
-                    }
-                    ImGui::PushID(static_cast<int>(id));
-                    ImGui::TextColored(colors::kBrightGold, "\xE2\x98\x85");
-                    ImGui::SameLine();
-                    ImGui::TextUnformatted(display.c_str());
-                    if (ImGui::IsItemHovered()) {
-                        ImGui::BeginTooltip();
-                        // Points badge
-                        uint32_t pts = gameHandler.getAchievementPoints(id);
-                        if (pts > 0) {
-                            ImGui::TextColored(colors::kBrightGold,
-                                "%u Achievement Point%s", pts, pts == 1 ? "" : "s");
-                            ImGui::Separator();
-                        }
-                        // Description
-                        const std::string& desc = gameHandler.getAchievementDescription(id);
-                        if (!desc.empty()) {
-                            ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + 320.0f);
-                            ImGui::TextUnformatted(desc.c_str());
-                            ImGui::PopTextWrapPos();
-                            ImGui::Spacing();
-                        }
-                        // Earn date
-                        uint32_t packed = gameHandler.getAchievementDate(id);
-                        if (packed != 0) {
-                            // WoW PackedTime: year[31:25] month[24:21] day[20:17] weekday[16:14] hour[13:9] minute[8:3]
-                            int minute  = (packed >>  3) & 0x3F;
-                            int hour    = (packed >>  9) & 0x1F;
-                            int day     = (packed >> 17) & 0x1F;
-                            int month   = (packed >> 21) & 0x0F;
-                            int year    = ((packed >> 25) & 0x7F) + 2000;
-                            const char* mname = (month >= 1 && month <= 12) ? kMonthAbbrev[month - 1] : "?";
-                            ImGui::TextDisabled("Earned: %s %d, %d  %02d:%02d", mname, day, year, hour, minute);
-                        }
-                        ImGui::EndTooltip();
-                    }
-                    ImGui::PopID();
-                }
-                ImGui::EndChild();
-            }
-            ImGui::EndTabItem();
-        }
-
-        // --- Criteria progress tab ---
-        char critLabel[32];
-        snprintf(critLabel, sizeof(critLabel), "Criteria (%u)###crit", static_cast<unsigned>(criteria.size()));
-        if (ImGui::BeginTabItem(critLabel)) {
-            // Lazy-load AchievementCriteria.dbc for descriptions
-            struct CriteriaEntry { uint32_t achievementId; uint64_t quantity; std::string description; };
-            static std::unordered_map<uint32_t, CriteriaEntry> s_criteriaData;
-            static bool s_criteriaDataLoaded = false;
-            if (!s_criteriaDataLoaded) {
-                s_criteriaDataLoaded = true;
-                auto* am = services_.assetManager;
-                if (am && am->isInitialized()) {
-                    auto dbc = am->loadDBC("AchievementCriteria.dbc");
-                    if (dbc && dbc->isLoaded() && dbc->getFieldCount() >= 10) {
-                        const auto* acL = pipeline::getActiveDBCLayout()
-                            ? pipeline::getActiveDBCLayout()->getLayout("AchievementCriteria") : nullptr;
-                        uint32_t achField  = acL ? acL->field("AchievementID") : 1u;
-                        uint32_t qtyField  = acL ? acL->field("Quantity")      : 4u;
-                        uint32_t descField = acL ? acL->field("Description")   : 9u;
-                        if (achField  == 0xFFFFFFFF) achField  = 1;
-                        if (qtyField  == 0xFFFFFFFF) qtyField  = 4;
-                        if (descField == 0xFFFFFFFF) descField = 9;
-                        uint32_t fc = dbc->getFieldCount();
-                        for (uint32_t r = 0; r < dbc->getRecordCount(); ++r) {
-                            uint32_t cid = dbc->getUInt32(r, 0);
-                            if (cid == 0) continue;
-                            CriteriaEntry ce;
-                            ce.achievementId = (achField  < fc) ? dbc->getUInt32(r, achField)  : 0;
-                            ce.quantity      = (qtyField  < fc) ? dbc->getUInt32(r, qtyField)  : 0;
-                            ce.description   = (descField < fc) ? dbc->getString(r, descField) : std::string{};
-                            s_criteriaData[cid] = std::move(ce);
-                        }
-                    }
-                }
-            }
-
-            if (criteria.empty()) {
-                ImGui::TextDisabled("No criteria progress received yet.");
-            } else {
-                ImGui::BeginChild("##critlist", ImVec2(0, 0), false);
-                std::vector<std::pair<uint32_t, uint64_t>> clist(criteria.begin(), criteria.end());
-                std::sort(clist.begin(), clist.end());
-                for (const auto& [cid, cval] : clist) {
-                    auto ceIt = s_criteriaData.find(cid);
-
-                    // Build display text for filtering
-                    std::string display;
-                    if (ceIt != s_criteriaData.end() && !ceIt->second.description.empty()) {
-                        display = ceIt->second.description;
-                    } else {
-                        display = std::to_string(cid);
-                    }
-                    if (!filter.empty()) {
-                        std::string lower = display;
-                        for (char& c : lower) c = static_cast<char>(tolower(static_cast<unsigned char>(c)));
-                        // Also allow filtering by achievement name
-                        if (lower.find(filter) == std::string::npos && ceIt != s_criteriaData.end()) {
-                            const std::string& achName = gameHandler.getAchievementName(ceIt->second.achievementId);
-                            std::string achLower = achName;
-                            for (char& c : achLower) c = static_cast<char>(tolower(static_cast<unsigned char>(c)));
-                            if (achLower.find(filter) == std::string::npos) continue;
-                        } else if (lower.find(filter) == std::string::npos) {
-                            continue;
-                        }
-                    }
-
-                    ImGui::PushID(static_cast<int>(cid));
-                    if (ceIt != s_criteriaData.end()) {
-                        // Show achievement name as header (dim)
-                        const std::string& achName = gameHandler.getAchievementName(ceIt->second.achievementId);
-                        if (!achName.empty()) {
-                            ImGui::TextColored(ImVec4(1.0f, 0.85f, 0.0f, 0.8f), "%s", achName.c_str());
-                            ImGui::SameLine();
-                            ImGui::TextDisabled(">");
-                            ImGui::SameLine();
-                        }
-                        if (!ceIt->second.description.empty()) {
-                            ImGui::TextUnformatted(ceIt->second.description.c_str());
-                        } else {
-                            ImGui::TextDisabled("Criteria %u", cid);
-                        }
-                        ImGui::SameLine();
-                        if (ceIt->second.quantity > 0) {
-                            ImGui::TextColored(colors::kLightGreen,
-                                "%llu/%llu",
-                                static_cast<unsigned long long>(cval),
-                                static_cast<unsigned long long>(ceIt->second.quantity));
-                        } else {
-                            ImGui::TextColored(colors::kLightGreen,
-                                "%llu", static_cast<unsigned long long>(cval));
-                        }
-                    } else {
-                        ImGui::TextDisabled("Criteria %u:", cid);
-                        ImGui::SameLine();
-                        ImGui::Text("%llu", static_cast<unsigned long long>(cval));
-                    }
-                    ImGui::PopID();
-                }
-                ImGui::EndChild();
-            }
-            ImGui::EndTabItem();
-        }
-        ImGui::EndTabBar();
-    }
-
-    ImGui::End();
-}
-
-// ─── GM Ticket Window ─────────────────────────────────────────────────────────
-void WindowManager::renderGmTicketWindow(game::GameHandler& gameHandler) {
-    // Fire a one-shot query when the window first becomes visible
-    if (showGmTicketWindow_ && !gmTicketWindowWasOpen_) {
-        gameHandler.requestGmTicket();
-    }
-    gmTicketWindowWasOpen_ = showGmTicketWindow_;
-
-    if (!showGmTicketWindow_) return;
-
-    ImGui::SetNextWindowSize(ImVec2(440, 320), ImGuiCond_FirstUseEver);
-    ImGui::SetNextWindowPos(ImVec2(300, 200), ImGuiCond_FirstUseEver);
-
-    if (!ImGui::Begin("GM Ticket", &showGmTicketWindow_,
-                      ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize)) {
-        ImGui::End();
-        return;
-    }
-
-    // Show GM support availability
-    if (!gameHandler.isGmSupportAvailable()) {
-        ImGui::TextColored(colors::kSoftRed, "GM support is currently unavailable.");
-        ImGui::Spacing();
-    }
-
-    // Show existing open ticket if any
-    if (gameHandler.hasActiveGmTicket()) {
-        ImGui::TextColored(kColorGreen, "You have an open GM ticket.");
-        const std::string& existingText = gameHandler.getGmTicketText();
-        if (!existingText.empty()) {
-            ImGui::TextWrapped("Current ticket: %s", existingText.c_str());
-        }
-        float waitHours = gameHandler.getGmTicketWaitHours();
-        if (waitHours > 0.0f) {
-            char waitBuf[64];
-            std::snprintf(waitBuf, sizeof(waitBuf), "Estimated wait: %.1f hours", waitHours);
-            ImGui::TextColored(ImVec4(0.8f, 0.8f, 0.4f, 1.0f), "%s", waitBuf);
-        }
-        ImGui::Separator();
-        ImGui::Spacing();
-    }
-
-    ImGui::TextWrapped("Describe your issue and a Game Master will contact you.");
-    ImGui::Spacing();
-    ImGui::InputTextMultiline("##gmticket_body", gmTicketBuf_, sizeof(gmTicketBuf_),
-                               ImVec2(-1, 120));
-    ImGui::Spacing();
-
-    bool hasText = (gmTicketBuf_[0] != '\0');
-    if (!hasText) ImGui::BeginDisabled();
-    if (ImGui::Button("Submit Ticket", ImVec2(160, 0))) {
-        gameHandler.submitGmTicket(gmTicketBuf_);
-        gmTicketBuf_[0] = '\0';
-        showGmTicketWindow_ = false;
-    }
-    if (!hasText) ImGui::EndDisabled();
-
-    ImGui::SameLine();
-    if (ImGui::Button("Cancel", ImVec2(80, 0))) {
-        showGmTicketWindow_ = false;
-    }
-    ImGui::SameLine();
-    if (gameHandler.hasActiveGmTicket()) {
-        if (ImGui::Button("Delete Ticket", ImVec2(110, 0))) {
-            gameHandler.deleteGmTicket();
-            showGmTicketWindow_ = false;
-        }
-    }
-
-    ImGui::End();
-}
-
-// ─── Book / Scroll / Note Window ──────────────────────────────────────────────
-void WindowManager::renderBookWindow(game::GameHandler& gameHandler) {
-    // Auto-open when new pages arrive
-    if (gameHandler.hasBookOpen() && !showBookWindow_) {
-        showBookWindow_  = true;
-        bookCurrentPage_ = 0;
-    }
-    if (!showBookWindow_) return;
-
-    const auto& pages = gameHandler.getBookPages();
-    if (pages.empty()) { showBookWindow_ = false; return; }
-
-    // Clamp page index
-    if (bookCurrentPage_ < 0) bookCurrentPage_ = 0;
-    if (bookCurrentPage_ >= static_cast<int>(pages.size()))
-        bookCurrentPage_ = static_cast<int>(pages.size()) - 1;
-
-    ImGui::SetNextWindowSize(ImVec2(420, 340), ImGuiCond_Appearing);
-    ImGui::SetNextWindowPos(ImVec2(400, 180), ImGuiCond_Appearing);
-
-    bool open = showBookWindow_;
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.12f, 0.09f, 0.06f, 0.98f));
-    ImGui::PushStyleColor(ImGuiCol_TitleBgActive, ImVec4(0.25f, 0.18f, 0.08f, 1.0f));
-    ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.5f, 0.37f, 0.18f, 1.0f));
-
-    char title[64];
-    if (pages.size() > 1)
-        snprintf(title, sizeof(title), "Page %d / %d###BookWin",
-                 bookCurrentPage_ + 1, static_cast<int>(pages.size()));
-    else
-        snprintf(title, sizeof(title), "###BookWin");
-
-    if (ImGui::Begin(title, &open, ImGuiWindowFlags_NoCollapse)) {
-        // Parchment text colour
-        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.85f, 0.78f, 0.62f, 1.0f));
-
-        const std::string& text = pages[bookCurrentPage_].text;
-        // Use a child region with word-wrap
-        ImGui::SetNextWindowContentSize(ImVec2(ImGui::GetContentRegionAvail().x, 0));
-        if (ImGui::BeginChild("##BookText",
-                              ImVec2(0, ImGui::GetContentRegionAvail().y - 34),
-                              false, ImGuiWindowFlags_HorizontalScrollbar)) {
-            ImGui::SetNextItemWidth(-1);
-            ImGui::TextWrapped("%s", text.c_str());
-        }
-        ImGui::EndChild();
-        ImGui::PopStyleColor();
-
-        // Navigation row
-        ImGui::Separator();
-        bool canPrev = (bookCurrentPage_ > 0);
-        bool canNext = (bookCurrentPage_ < static_cast<int>(pages.size()) - 1);
-
-        if (!canPrev) ImGui::BeginDisabled();
-        if (ImGui::Button("< Prev", ImVec2(80, 0))) bookCurrentPage_--;
-        if (!canPrev) ImGui::EndDisabled();
-
-        ImGui::SameLine();
-        if (!canNext) ImGui::BeginDisabled();
-        if (ImGui::Button("Next >", ImVec2(80, 0))) bookCurrentPage_++;
-        if (!canNext) ImGui::EndDisabled();
-
-        ImGui::SameLine(ImGui::GetContentRegionAvail().x - 60);
-        if (ImGui::Button("Close", ImVec2(60, 0))) {
-            open = false;
-        }
-    }
-    ImGui::End();
-    ImGui::PopStyleColor(3);
-
-    if (!open) {
-        showBookWindow_ = false;
-        gameHandler.clearBook();
-    }
-}
-
-// ─── Inspect Window ───────────────────────────────────────────────────────────
-// ─── Titles Window ────────────────────────────────────────────────────────────
-void WindowManager::renderTitlesWindow(game::GameHandler& gameHandler) {
-    if (!showTitlesWindow_) return;
-
-    ImGui::SetNextWindowSize(ImVec2(320, 400), ImGuiCond_FirstUseEver);
-    ImGui::SetNextWindowPos(ImVec2(240, 170), ImGuiCond_FirstUseEver);
-
-    if (!ImGui::Begin("Titles", &showTitlesWindow_)) {
-        ImGui::End();
-        return;
-    }
-
-    const auto& knownBits = gameHandler.getKnownTitleBits();
-    const int32_t chosen  = gameHandler.getChosenTitleBit();
-
-    if (knownBits.empty()) {
-        ImGui::TextDisabled("No titles earned yet.");
-        ImGui::End();
-        return;
-    }
-
-    ImGui::TextUnformatted("Select a title to display:");
-    ImGui::Separator();
-
-    // "No Title" option
-    bool noTitle = (chosen < 0);
-    if (ImGui::Selectable("(No Title)", noTitle)) {
-        if (!noTitle) gameHandler.sendSetTitle(-1);
-    }
-    if (noTitle) {
-        ImGui::SameLine();
-        ImGui::TextColored(colors::kBrightGold, "<-- active");
-    }
-
-    ImGui::Separator();
-
-    // Sort known bits for stable display order
-    std::vector<uint32_t> sortedBits(knownBits.begin(), knownBits.end());
-    std::sort(sortedBits.begin(), sortedBits.end());
-
-    ImGui::BeginChild("##titlelist", ImVec2(0, 0), false);
-    for (uint32_t bit : sortedBits) {
-        const std::string title = gameHandler.getFormattedTitle(bit);
-        const std::string display = title.empty()
-            ? ("Title #" + std::to_string(bit)) : title;
-
-        bool isActive = (chosen >= 0 && static_cast<uint32_t>(chosen) == bit);
-        ImGui::PushID(static_cast<int>(bit));
-
-        if (isActive) {
-            ImGui::PushStyleColor(ImGuiCol_Text, colors::kBrightGold);
-        }
-        if (ImGui::Selectable(display.c_str(), isActive)) {
-            if (!isActive) gameHandler.sendSetTitle(static_cast<int32_t>(bit));
-        }
-        if (isActive) {
-            ImGui::PopStyleColor();
-            ImGui::SameLine();
-            ImGui::TextDisabled("<-- active");
-        }
-
-        ImGui::PopID();
-    }
-    ImGui::EndChild();
-
-    ImGui::End();
-}
-
-// ─── Equipment Set Manager Window ─────────────────────────────────────────────
-void WindowManager::renderEquipSetWindow(game::GameHandler& gameHandler) {
-    if (!showEquipSetWindow_) return;
-
-    ImGui::SetNextWindowSize(ImVec2(280, 320), ImGuiCond_FirstUseEver);
-    ImGui::SetNextWindowPos(ImVec2(260, 180), ImGuiCond_FirstUseEver);
-
-    if (!ImGui::Begin("Equipment Sets##equipsets", &showEquipSetWindow_)) {
-        ImGui::End();
-        return;
-    }
-
-    const auto& sets = gameHandler.getEquipmentSets();
-
-    if (sets.empty()) {
-        ImGui::TextDisabled("No equipment sets saved.");
-        ImGui::Spacing();
-        ImGui::TextWrapped("Create equipment sets in-game using the default WoW equipment manager (Shift+click the Equipment Sets button).");
-        ImGui::End();
-        return;
-    }
-
-    ImGui::TextUnformatted("Click a set to equip it:");
-    ImGui::Separator();
-    ImGui::Spacing();
-
-    ImGui::BeginChild("##equipsetlist", ImVec2(0, 0), false);
-    for (const auto& set : sets) {
-        ImGui::PushID(static_cast<int>(set.setId));
-
-        // Icon placeholder (use a coloured square if no icon texture available)
-        ImVec2 iconSize(32.0f, 32.0f);
-        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.25f, 0.20f, 0.10f, 1.0f));
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.40f, 0.30f, 0.15f, 1.0f));
-        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.60f, 0.45f, 0.20f, 1.0f));
-        if (ImGui::Button("##icon", iconSize)) {
-            gameHandler.useEquipmentSet(set.setId);
-        }
-        ImGui::PopStyleColor(3);
-
-        if (ImGui::IsItemHovered()) {
-            ImGui::SetTooltip("Equip set: %s", set.name.c_str());
-        }
-
-        ImGui::SameLine();
-
-        // Name and equip button
-        ImGui::BeginGroup();
-        ImGui::TextUnformatted(set.name.c_str());
-        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.20f, 0.35f, 0.15f, 1.0f));
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.30f, 0.50f, 0.22f, 1.0f));
-        if (ImGui::SmallButton("Equip")) {
-            gameHandler.useEquipmentSet(set.setId);
-        }
-        ImGui::PopStyleColor(2);
-        ImGui::EndGroup();
-
-        ImGui::Spacing();
-        ImGui::PopID();
-    }
-    ImGui::EndChild();
-
-    ImGui::End();
-}
-
-void WindowManager::renderSkillsWindow(game::GameHandler& gameHandler) {
-    if (!showSkillsWindow_) return;
-
-    ImGui::SetNextWindowSize(ImVec2(380, 480), ImGuiCond_FirstUseEver);
-    ImGui::SetNextWindowPos(ImVec2(220, 130), ImGuiCond_FirstUseEver);
-
-    if (!ImGui::Begin("Skills & Professions", &showSkillsWindow_)) {
-        ImGui::End();
-        return;
-    }
-
-    const auto& skills = gameHandler.getPlayerSkills();
-    if (skills.empty()) {
-        ImGui::TextDisabled("No skill data received yet.");
-        ImGui::End();
-        return;
-    }
-
-    // Organise skills by category
-    // WoW SkillLine.dbc categories: 6=Weapon, 7=Class, 8=Armor, 9=Secondary, 11=Professions, others=Misc
-    struct SkillEntry {
-        uint32_t skillId;
-        const game::PlayerSkill* skill;
-    };
-    std::map<uint32_t, std::vector<SkillEntry>> byCategory;
-    for (const auto& [id, sk] : skills) {
-        uint32_t cat = gameHandler.getSkillCategory(id);
-        byCategory[cat].push_back({id, &sk});
-    }
-
-    static constexpr struct { uint32_t cat; const char* label; } kCatOrder[] = {
-        {11, "Professions"},
-        { 9, "Secondary Skills"},
-        { 7, "Class Skills"},
-        { 6, "Weapon Skills"},
-        { 8, "Armor"},
-        { 5, "Languages"},
-        { 0, "Other"},
-    };
-
-    // Collect handled categories to fall back to "Other" for unknowns
-    static const uint32_t kKnownCats[] = {11, 9, 7, 6, 8, 5};
-
-    // Redirect unknown categories into bucket 0
-    for (auto& [cat, vec] : byCategory) {
-        bool known = false;
-        for (uint32_t kc : kKnownCats) if (cat == kc) { known = true; break; }
-        if (!known && cat != 0) {
-            auto& other = byCategory[0];
-            other.insert(other.end(), vec.begin(), vec.end());
-            vec.clear();
-        }
-    }
-
-    ImGui::BeginChild("##skillscroll", ImVec2(0, 0), false);
-
-    for (const auto& [cat, label] : kCatOrder) {
-        auto it = byCategory.find(cat);
-        if (it == byCategory.end() || it->second.empty()) continue;
-
-        auto& entries = it->second;
-        // Sort alphabetically within each category
-        std::sort(entries.begin(), entries.end(), [&](const SkillEntry& a, const SkillEntry& b) {
-            return gameHandler.getSkillName(a.skillId) < gameHandler.getSkillName(b.skillId);
-        });
-
-        if (ImGui::CollapsingHeader(label, ImGuiTreeNodeFlags_DefaultOpen)) {
-            for (const auto& e : entries) {
-                const std::string& name = gameHandler.getSkillName(e.skillId);
-                const char* displayName = name.empty() ? "Unknown" : name.c_str();
-                uint16_t val = e.skill->effectiveValue();
-                uint16_t maxVal = e.skill->maxValue;
-
-                ImGui::PushID(static_cast<int>(e.skillId));
-
-                // Name column
-                ImGui::TextUnformatted(displayName);
-                ImGui::SameLine(170.0f);
-
-                // Progress bar
-                float fraction = (maxVal > 0) ? static_cast<float>(val) / static_cast<float>(maxVal) : 0.0f;
-                char overlay[32];
-                snprintf(overlay, sizeof(overlay), "%u / %u", val, maxVal);
-                ImGui::PushStyleColor(ImGuiCol_PlotHistogram, ImVec4(0.20f, 0.55f, 0.20f, 1.0f));
-                ImGui::ProgressBar(fraction, ImVec2(160.0f, 14.0f), overlay);
-                ImGui::PopStyleColor();
-
-                if (ImGui::IsItemHovered()) {
-                    ImGui::BeginTooltip();
-                    ImGui::Text("%s", displayName);
-                    ImGui::Separator();
-                    ImGui::Text("Base: %u", e.skill->value);
-                    if (e.skill->bonusPerm > 0)
-                        ImGui::Text("Permanent bonus: +%u", e.skill->bonusPerm);
-                    if (e.skill->bonusTemp > 0)
-                        ImGui::Text("Temporary bonus: +%u", e.skill->bonusTemp);
-                    ImGui::Text("Max: %u", maxVal);
-                    ImGui::EndTooltip();
-                }
-
-                ImGui::PopID();
-            }
-            ImGui::Spacing();
-        }
-    }
-
-    ImGui::EndChild();
-    ImGui::End();
-}
-
-
-} // namespace ui
-} // namespace wowee
diff --git a/test.sh b/test.sh
deleted file mode 100755
index e8d8b536..00000000
--- a/test.sh
+++ /dev/null
@@ -1,238 +0,0 @@
-#!/usr/bin/env bash
-# test.sh — Run the Catch2 unit tests and/or clang-tidy linter.
-#
-# Usage:
-#   ./test.sh                    # run both lint and tests (default)
-#   ./test.sh --lint             # run clang-tidy only
-#   ./test.sh --test             # run ctest unit tests only
-#   ./test.sh --lint --test      # explicit: run both
-#   ./test.sh --asan             # run ctest under ASAN/UBSan (requires build_asan/)
-#   ./test.sh --test --asan      # same as above
-#   FIX=1 ./test.sh --lint       # apply clang-tidy fix suggestions (use with care)
-#
-# Exit code is non-zero if any lint diagnostic or test failure is reported.
-#
-# Build directories:
-#   build/       — Release build used for normal ctest  (cmake -DCMAKE_BUILD_TYPE=Release)
-#   build_asan/  — Debug+ASAN build used with --asan    (cmake -DCMAKE_BUILD_TYPE=Debug
-#                                                              -DWOWEE_ENABLE_ASAN=ON
-#                                                              -DWOWEE_BUILD_TESTS=ON)
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-cd "$SCRIPT_DIR"
-
-# ---------------------------------------------------------------------------
-# Argument parsing
-# ---------------------------------------------------------------------------
-RUN_LINT=0
-RUN_TEST=0
-RUN_ASAN=0
-
-for arg in "$@"; do
-    case "$arg" in
-        --lint) RUN_LINT=1 ;;
-        --test) RUN_TEST=1 ;;
-        --asan) RUN_ASAN=1; RUN_TEST=1 ;;
-        --help|-h)
-            sed -n '2,18p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'
-            exit 0
-            ;;
-        *)
-            echo "Unknown argument: $arg"
-            echo "Usage: $0 [--lint] [--test] [--asan]"
-            exit 1
-            ;;
-    esac
-done
-
-# Default: run both when no flags provided
-if [[ $RUN_LINT -eq 0 && $RUN_TEST -eq 0 ]]; then
-    RUN_LINT=1
-    RUN_TEST=1
-fi
-
-# ---------------------------------------------------------------------------
-# ── UNIT TESTS ─────────────────────────────────────────────────────────────
-# ---------------------------------------------------------------------------
-OVERALL_FAILED=0
-
-if [[ $RUN_TEST -eq 1 ]]; then
-    if [[ $RUN_ASAN -eq 1 ]]; then
-        BUILD_TEST_DIR="$SCRIPT_DIR/build_asan"
-        TEST_LABEL="ASAN+UBSan"
-    else
-        BUILD_TEST_DIR="$SCRIPT_DIR/build"
-        TEST_LABEL="Release"
-    fi
-
-    if [[ ! -d "$BUILD_TEST_DIR" ]]; then
-        echo "Build directory not found: $BUILD_TEST_DIR"
-        if [[ $RUN_ASAN -eq 1 ]]; then
-            echo "Configure it with:"
-            echo "  cmake -B build_asan -DCMAKE_BUILD_TYPE=Debug -DWOWEE_ENABLE_ASAN=ON -DWOWEE_BUILD_TESTS=ON"
-        else
-            echo "Run cmake first:  cmake -B build -DCMAKE_BUILD_TYPE=Release -DWOWEE_BUILD_TESTS=ON"
-        fi
-        exit 1
-    fi
-
-    # Check that CTestTestfile.cmake exists (tests were configured)
-    if [[ ! -f "$BUILD_TEST_DIR/CTestTestfile.cmake" ]]; then
-        echo "CTestTestfile.cmake not found in $BUILD_TEST_DIR — tests not configured."
-        echo "Re-run cmake with -DWOWEE_BUILD_TESTS=ON"
-        exit 1
-    fi
-
-    echo "──────────────────────────────────────────────"
-    echo " Running unit tests [$TEST_LABEL]"
-    echo "──────────────────────────────────────────────"
-    if ! (cd "$BUILD_TEST_DIR" && ctest --output-on-failure); then
-        OVERALL_FAILED=1
-        echo ""
-        echo "One or more unit tests FAILED."
-    else
-        echo ""
-        echo "All unit tests passed."
-    fi
-fi
-
-# ---------------------------------------------------------------------------
-# ── LINT ───────────────────────────────────────────────────────────────────
-# ---------------------------------------------------------------------------
-if [[ $RUN_LINT -eq 0 ]]; then
-    exit $OVERALL_FAILED
-fi
-
-# Dependency check
-CLANG_TIDY=""
-for candidate in clang-tidy clang-tidy-18 clang-tidy-17 clang-tidy-16 clang-tidy-15 clang-tidy-14; do
-    if command -v "$candidate" >/dev/null 2>&1; then
-        CLANG_TIDY="$candidate"
-        break
-    fi
-done
-
-if [[ -z "$CLANG_TIDY" ]]; then
-    echo "clang-tidy not found. Install it with:"
-    echo "  sudo apt-get install clang-tidy"
-    exit 1
-fi
-
-echo "──────────────────────────────────────────────"
-echo " Running clang-tidy lint"
-echo "──────────────────────────────────────────────"
-echo "Using: $($CLANG_TIDY --version | head -1)"
-
-# run-clang-tidy runs checks in parallel; fall back to sequential if absent.
-RUN_CLANG_TIDY=""
-for candidate in run-clang-tidy run-clang-tidy-18 run-clang-tidy-17 run-clang-tidy-16 run-clang-tidy-15 run-clang-tidy-14; do
-    if command -v "$candidate" >/dev/null 2>&1; then
-        RUN_CLANG_TIDY="$candidate"
-        break
-    fi
-done
-
-# Build database check
-COMPILE_COMMANDS="$SCRIPT_DIR/build/compile_commands.json"
-if [[ ! -f "$COMPILE_COMMANDS" ]]; then
-    echo "compile_commands.json not found at $COMPILE_COMMANDS"
-    echo "Run cmake first:  cmake -B build -DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
-    exit 1
-fi
-
-# ---------------------------------------------------------------------------
-# Source files to check (first-party only)
-# ---------------------------------------------------------------------------
-mapfile -t SOURCE_FILES < <(
-    find "$SCRIPT_DIR/src" -type f \( -name '*.cpp' -o -name '*.cxx' -o -name '*.cc' \) | sort
-)
-
-if [[ ${#SOURCE_FILES[@]} -eq 0 ]]; then
-    echo "No source files found in src/"
-    exit 0
-fi
-
-echo "Linting ${#SOURCE_FILES[@]} source files..."
-
-# ---------------------------------------------------------------------------
-# Resolve GCC C++ stdlib include paths for clang-tidy
-#
-# compile_commands.json is generated by GCC. When clang-tidy processes those
-# commands with its own clang driver it cannot locate GCC's libstdc++ headers.
-# We query GCC for its include search list and forward each path as an
-# -isystem extra argument so clang-tidy can find <vector>, <string>, etc.
-# ---------------------------------------------------------------------------
-EXTRA_TIDY_ARGS=()   # for direct clang-tidy:  --extra-arg=...
-EXTRA_RUN_ARGS=()    # for run-clang-tidy:     -extra-arg=...
-if command -v gcc >/dev/null 2>&1; then
-    # Prepend clang's own resource include dir first so clang uses its own
-    # versions of xmmintrin.h, ia32intrin.h, etc. rather than GCC's.
-    clang_resource_inc="$($CLANG_TIDY -print-resource-dir 2>/dev/null || true)/include"
-    if [[ -d "$clang_resource_inc" ]]; then
-        EXTRA_TIDY_ARGS+=("--extra-arg=-isystem${clang_resource_inc}")
-        EXTRA_RUN_ARGS+=("-extra-arg=-isystem${clang_resource_inc}")
-    fi
-
-    while IFS= read -r inc_path; do
-        [[ -d "$inc_path" ]] || continue
-        # Skip the GCC compiler built-in include dir — clang's resource dir above
-        # provides compatible replacements for xmmintrin.h, ia32intrin.h, etc.
-        [[ "$inc_path" == */gcc/* ]] && continue
-        EXTRA_TIDY_ARGS+=("--extra-arg=-isystem${inc_path}")
-        EXTRA_RUN_ARGS+=("-extra-arg=-isystem${inc_path}")
-    done < <(
-        gcc -E -x c++ - -v < /dev/null 2>&1 \
-        | sed -n '/#include <\.\.\.> search starts here:/,/End of search list\./p' \
-        | grep '^ ' \
-        | sed 's/^ //'
-    )
-fi
-
-# ---------------------------------------------------------------------------
-# Run
-# ---------------------------------------------------------------------------
-FIX="${FIX:-0}"
-FIX_FLAG=""
-if [[ "$FIX" == "1" ]]; then
-    FIX_FLAG="-fix"
-    echo "Fix mode enabled — applying suggested fixes."
-fi
-
-LINT_FAILED=0
-
-if [[ -n "$RUN_CLANG_TIDY" ]]; then
-    echo "Running via $RUN_CLANG_TIDY (parallel)..."
-    # run-clang-tidy takes a source-file regex; match our src/ tree
-    SRC_REGEX="$(echo "$SCRIPT_DIR/src" | sed 's|/|\\/|g')"
-    "$RUN_CLANG_TIDY" \
-        -clang-tidy-binary "$CLANG_TIDY" \
-        -p "$SCRIPT_DIR/build" \
-        $FIX_FLAG \
-        "${EXTRA_RUN_ARGS[@]}" \
-        "$SRC_REGEX" || LINT_FAILED=$?
-else
-    echo "run-clang-tidy not found; running sequentially..."
-    for f in "${SOURCE_FILES[@]}"; do
-        "$CLANG_TIDY" \
-            -p "$SCRIPT_DIR/build" \
-            $FIX_FLAG \
-            "${EXTRA_TIDY_ARGS[@]}" \
-            "$f" || LINT_FAILED=$?
-    done
-fi
-
-# ---------------------------------------------------------------------------
-# Result
-# ---------------------------------------------------------------------------
-if [[ $LINT_FAILED -ne 0 ]]; then
-    echo ""
-    echo "clang-tidy reported issues. Fix them or add suppressions in .clang-tidy."
-    OVERALL_FAILED=1
-else
-    echo ""
-    echo "Lint passed."
-fi
-
-exit $OVERALL_FAILED
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
deleted file mode 100644
index b5773534..00000000
--- a/tests/CMakeLists.txt
+++ /dev/null
@@ -1,210 +0,0 @@
-# Unit test infrastructure using Catch2 v3 (amalgamated)
-
-# Catch2 amalgamated as a library target
-add_library(catch2_main STATIC
-    ${CMAKE_SOURCE_DIR}/extern/catch2/catch_amalgamated.cpp
-)
-target_include_directories(catch2_main PUBLIC
-    ${CMAKE_SOURCE_DIR}/extern/catch2
-)
-# Catch2 v3 needs C++17 minimum
-target_compile_features(catch2_main PUBLIC cxx_std_17)
-
-# ── ASAN / UBSan propagation ────────────────────────────────
-# Collect all test target names so we can apply sanitizer flags at the end.
-set(ALL_TEST_TARGETS "")
-
-# Helper: register a test target for ASAN/UBSan if enabled.
-macro(register_test_target _target)
-    list(APPEND ALL_TEST_TARGETS ${_target})
-endmacro()
-
-# Shared source files used across multiple tests
-set(TEST_COMMON_SOURCES
-    ${CMAKE_SOURCE_DIR}/src/core/logger.cpp
-)
-
-# Include directories matching the main target
-set(TEST_INCLUDE_DIRS
-    ${CMAKE_SOURCE_DIR}/include
-    ${CMAKE_SOURCE_DIR}/src
-)
-set(TEST_SYSTEM_INCLUDE_DIRS
-    ${CMAKE_SOURCE_DIR}/extern
-)
-
-# ── test_packet ──────────────────────────────────────────────
-add_executable(test_packet
-    test_packet.cpp
-    ${TEST_COMMON_SOURCES}
-    ${CMAKE_SOURCE_DIR}/src/network/packet.cpp
-)
-target_include_directories(test_packet PRIVATE ${TEST_INCLUDE_DIRS})
-target_include_directories(test_packet SYSTEM PRIVATE ${TEST_SYSTEM_INCLUDE_DIRS})
-target_link_libraries(test_packet PRIVATE catch2_main)
-add_test(NAME packet COMMAND test_packet)
-register_test_target(test_packet)
-
-# ── test_srp ─────────────────────────────────────────────────
-add_executable(test_srp
-    test_srp.cpp
-    ${TEST_COMMON_SOURCES}
-    ${CMAKE_SOURCE_DIR}/src/auth/srp.cpp
-    ${CMAKE_SOURCE_DIR}/src/auth/big_num.cpp
-    ${CMAKE_SOURCE_DIR}/src/auth/crypto.cpp
-)
-target_include_directories(test_srp PRIVATE ${TEST_INCLUDE_DIRS})
-target_include_directories(test_srp SYSTEM PRIVATE ${TEST_SYSTEM_INCLUDE_DIRS})
-target_link_libraries(test_srp PRIVATE catch2_main OpenSSL::SSL OpenSSL::Crypto)
-add_test(NAME srp COMMAND test_srp)
-register_test_target(test_srp)
-
-# ── test_opcode_table ────────────────────────────────────────
-add_executable(test_opcode_table
-    test_opcode_table.cpp
-    ${TEST_COMMON_SOURCES}
-    ${CMAKE_SOURCE_DIR}/src/game/opcode_table.cpp
-)
-target_include_directories(test_opcode_table PRIVATE ${TEST_INCLUDE_DIRS})
-target_include_directories(test_opcode_table SYSTEM PRIVATE ${TEST_SYSTEM_INCLUDE_DIRS})
-target_link_libraries(test_opcode_table PRIVATE catch2_main)
-add_test(NAME opcode_table COMMAND test_opcode_table)
-register_test_target(test_opcode_table)
-
-# ── test_entity ──────────────────────────────────────────────
-add_executable(test_entity
-    test_entity.cpp
-    ${TEST_COMMON_SOURCES}
-    ${CMAKE_SOURCE_DIR}/src/game/entity.cpp
-)
-target_include_directories(test_entity PRIVATE ${TEST_INCLUDE_DIRS})
-target_include_directories(test_entity SYSTEM PRIVATE ${TEST_SYSTEM_INCLUDE_DIRS})
-target_link_libraries(test_entity PRIVATE catch2_main)
-add_test(NAME entity COMMAND test_entity)
-register_test_target(test_entity)
-
-# ── test_dbc_loader ──────────────────────────────────────────
-add_executable(test_dbc_loader
-    test_dbc_loader.cpp
-    ${TEST_COMMON_SOURCES}
-    ${CMAKE_SOURCE_DIR}/src/pipeline/dbc_loader.cpp
-)
-target_include_directories(test_dbc_loader PRIVATE ${TEST_INCLUDE_DIRS})
-target_include_directories(test_dbc_loader SYSTEM PRIVATE ${TEST_SYSTEM_INCLUDE_DIRS})
-target_link_libraries(test_dbc_loader PRIVATE catch2_main)
-add_test(NAME dbc_loader COMMAND test_dbc_loader)
-register_test_target(test_dbc_loader)
-
-# ── test_m2_structs ──────────────────────────────────────────
-# Header-only struct layout tests — no source files needed
-add_executable(test_m2_structs
-    test_m2_structs.cpp
-)
-target_include_directories(test_m2_structs PRIVATE ${TEST_INCLUDE_DIRS})
-target_include_directories(test_m2_structs SYSTEM PRIVATE ${TEST_SYSTEM_INCLUDE_DIRS})
-target_link_libraries(test_m2_structs PRIVATE catch2_main)
-if(TARGET glm::glm)
-    target_link_libraries(test_m2_structs PRIVATE glm::glm)
-endif()
-add_test(NAME m2_structs COMMAND test_m2_structs)
-register_test_target(test_m2_structs)
-
-# ── test_blp_loader ──────────────────────────────────────────
-add_executable(test_blp_loader
-    test_blp_loader.cpp
-    ${TEST_COMMON_SOURCES}
-    ${CMAKE_SOURCE_DIR}/src/pipeline/blp_loader.cpp
-)
-target_include_directories(test_blp_loader PRIVATE ${TEST_INCLUDE_DIRS})
-target_include_directories(test_blp_loader SYSTEM PRIVATE ${TEST_SYSTEM_INCLUDE_DIRS})
-target_link_libraries(test_blp_loader PRIVATE catch2_main)
-add_test(NAME blp_loader COMMAND test_blp_loader)
-register_test_target(test_blp_loader)
-
-# ── test_frustum ─────────────────────────────────────────────
-add_executable(test_frustum
-    test_frustum.cpp
-    ${CMAKE_SOURCE_DIR}/src/rendering/frustum.cpp
-)
-target_include_directories(test_frustum PRIVATE ${TEST_INCLUDE_DIRS})
-target_include_directories(test_frustum SYSTEM PRIVATE ${TEST_SYSTEM_INCLUDE_DIRS})
-target_link_libraries(test_frustum PRIVATE catch2_main)
-if(TARGET glm::glm)
-    target_link_libraries(test_frustum PRIVATE glm::glm)
-endif()
-add_test(NAME frustum COMMAND test_frustum)
-register_test_target(test_frustum)
-
-# ── test_animation_ids ───────────────────────────────────────
-add_executable(test_animation_ids
-    test_animation_ids.cpp
-    ${TEST_COMMON_SOURCES}
-    ${CMAKE_SOURCE_DIR}/src/rendering/animation/animation_ids.cpp
-    ${CMAKE_SOURCE_DIR}/src/pipeline/dbc_loader.cpp
-)
-target_include_directories(test_animation_ids PRIVATE ${TEST_INCLUDE_DIRS})
-target_include_directories(test_animation_ids SYSTEM PRIVATE ${TEST_SYSTEM_INCLUDE_DIRS})
-target_link_libraries(test_animation_ids PRIVATE catch2_main)
-add_test(NAME animation_ids COMMAND test_animation_ids)
-register_test_target(test_animation_ids)
-
-# ── test_locomotion_fsm ──────────────────────────────────────
-add_executable(test_locomotion_fsm
-    test_locomotion_fsm.cpp
-    ${TEST_COMMON_SOURCES}
-    ${CMAKE_SOURCE_DIR}/src/rendering/animation/locomotion_fsm.cpp
-)
-target_include_directories(test_locomotion_fsm PRIVATE ${TEST_INCLUDE_DIRS})
-target_include_directories(test_locomotion_fsm SYSTEM PRIVATE ${TEST_SYSTEM_INCLUDE_DIRS})
-target_link_libraries(test_locomotion_fsm PRIVATE catch2_main)
-add_test(NAME locomotion_fsm COMMAND test_locomotion_fsm)
-register_test_target(test_locomotion_fsm)
-
-# ── test_combat_fsm ──────────────────────────────────────────
-add_executable(test_combat_fsm
-    test_combat_fsm.cpp
-    ${TEST_COMMON_SOURCES}
-    ${CMAKE_SOURCE_DIR}/src/rendering/animation/combat_fsm.cpp
-)
-target_include_directories(test_combat_fsm PRIVATE ${TEST_INCLUDE_DIRS})
-target_include_directories(test_combat_fsm SYSTEM PRIVATE ${TEST_SYSTEM_INCLUDE_DIRS})
-target_link_libraries(test_combat_fsm PRIVATE catch2_main)
-add_test(NAME combat_fsm COMMAND test_combat_fsm)
-register_test_target(test_combat_fsm)
-
-# ── test_activity_fsm ────────────────────────────────────────
-add_executable(test_activity_fsm
-    test_activity_fsm.cpp
-    ${TEST_COMMON_SOURCES}
-    ${CMAKE_SOURCE_DIR}/src/rendering/animation/activity_fsm.cpp
-)
-target_include_directories(test_activity_fsm PRIVATE ${TEST_INCLUDE_DIRS})
-target_include_directories(test_activity_fsm SYSTEM PRIVATE ${TEST_SYSTEM_INCLUDE_DIRS})
-target_link_libraries(test_activity_fsm PRIVATE catch2_main)
-add_test(NAME activity_fsm COMMAND test_activity_fsm)
-register_test_target(test_activity_fsm)
-
-# NPC animator tests removed — NpcAnimator replaced by generic CharacterAnimator
-
-# ── test_anim_capability ─────────────────────────────────────
-# Header-only struct tests — no source files needed
-add_executable(test_anim_capability
-    test_anim_capability.cpp
-)
-target_include_directories(test_anim_capability PRIVATE ${TEST_INCLUDE_DIRS})
-target_include_directories(test_anim_capability SYSTEM PRIVATE ${TEST_SYSTEM_INCLUDE_DIRS})
-target_link_libraries(test_anim_capability PRIVATE catch2_main)
-add_test(NAME anim_capability COMMAND test_anim_capability)
-register_test_target(test_anim_capability)
-
-# ── ASAN / UBSan for test targets ────────────────────────────
-if(WOWEE_ENABLE_ASAN AND NOT MSVC)
-    foreach(_t IN LISTS ALL_TEST_TARGETS)
-        target_compile_options(${_t} PRIVATE -fsanitize=address,undefined -fno-omit-frame-pointer)
-        target_link_options(${_t} PRIVATE -fsanitize=address,undefined)
-    endforeach()
-    # catch2_main must also be compiled with the same flags
-    target_compile_options(catch2_main PRIVATE -fsanitize=address,undefined -fno-omit-frame-pointer)
-    target_link_options(catch2_main PRIVATE -fsanitize=address,undefined)
-    message(STATUS "Test targets: ASAN + UBSan ENABLED")
-endif()
diff --git a/tests/test_activity_fsm.cpp b/tests/test_activity_fsm.cpp
deleted file mode 100644
index baad15e7..00000000
--- a/tests/test_activity_fsm.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-// ActivityFSM unit tests
-#include <catch_amalgamated.hpp>
-#include "rendering/animation/activity_fsm.hpp"
-#include "rendering/animation/animation_ids.hpp"
-
-using namespace wowee::rendering;
-namespace anim = wowee::rendering::anim;
-
-static AnimCapabilitySet makeActivityCaps() {
-    AnimCapabilitySet caps;
-    caps.resolvedStand = anim::STAND;
-    caps.resolvedSitDown = anim::SIT_GROUND_DOWN;
-    caps.resolvedSitLoop = anim::SITTING;
-    caps.resolvedSitUp = anim::SIT_GROUND_UP;
-    caps.resolvedKneel = anim::KNEEL_LOOP;
-    caps.resolvedLoot = anim::LOOT;
-    return caps;
-}
-
-static ActivityFSM::Input idleInput() {
-    ActivityFSM::Input in;
-    in.grounded = true;
-    return in;
-}
-
-TEST_CASE("ActivityFSM: NONE by default", "[activity]") {
-    ActivityFSM fsm;
-    CHECK(fsm.getState() == ActivityFSM::State::NONE);
-    CHECK_FALSE(fsm.isActive());
-}
-
-TEST_CASE("ActivityFSM: emote starts and returns valid output", "[activity]") {
-    ActivityFSM fsm;
-    auto caps = makeActivityCaps();
-
-    fsm.startEmote(anim::EMOTE_WAVE, false);
-    CHECK(fsm.getState() == ActivityFSM::State::EMOTE);
-    CHECK(fsm.isEmoteActive());
-
-    auto in = idleInput();
-    auto out = fsm.resolve(in, caps);
-    REQUIRE(out.valid);
-    CHECK(out.animId == anim::EMOTE_WAVE);
-    CHECK(out.loop == false);
-}
-
-TEST_CASE("ActivityFSM: emote cancelled by movement", "[activity]") {
-    ActivityFSM fsm;
-    auto caps = makeActivityCaps();
-
-    fsm.startEmote(anim::EMOTE_WAVE, false);
-
-    auto in = idleInput();
-    in.moving = true;
-    auto out = fsm.resolve(in, caps);
-
-    // After movement, emote should be cancelled
-    CHECK_FALSE(fsm.isEmoteActive());
-    CHECK(fsm.getState() == ActivityFSM::State::NONE);
-}
-
-TEST_CASE("ActivityFSM: looting starts and stops", "[activity]") {
-    ActivityFSM fsm;
-    auto caps = makeActivityCaps();
-
-    fsm.startLooting();
-    CHECK(fsm.getState() == ActivityFSM::State::LOOTING);
-
-    auto in = idleInput();
-    auto out = fsm.resolve(in, caps);
-    REQUIRE(out.valid);
-
-    // stopLooting transitions through LOOT_END (KNEEL_END one-shot) before NONE
-    fsm.stopLooting();
-    CHECK(fsm.getState() == ActivityFSM::State::LOOT_END);
-}
-
-TEST_CASE("ActivityFSM: sit stand state triggers sit down", "[activity]") {
-    ActivityFSM fsm;
-    auto caps = makeActivityCaps();
-
-    fsm.setStandState(ActivityFSM::STAND_STATE_SIT);
-    CHECK(fsm.getState() == ActivityFSM::State::SIT_DOWN);
-
-    auto in = idleInput();
-    in.sitting = true;
-    auto out = fsm.resolve(in, caps);
-    REQUIRE(out.valid);
-}
-
-TEST_CASE("ActivityFSM: cancel emote explicitly", "[activity]") {
-    ActivityFSM fsm;
-    auto caps = makeActivityCaps();
-
-    fsm.startEmote(anim::EMOTE_DANCE, true);
-    CHECK(fsm.isEmoteActive());
-    CHECK(fsm.getEmoteAnimId() == anim::EMOTE_DANCE);
-
-    fsm.cancelEmote();
-    CHECK_FALSE(fsm.isEmoteActive());
-    CHECK(fsm.getState() == ActivityFSM::State::NONE);
-}
-
-TEST_CASE("ActivityFSM: reset clears all state", "[activity]") {
-    ActivityFSM fsm;
-    fsm.startEmote(anim::EMOTE_WAVE, false);
-    CHECK(fsm.isActive());
-
-    fsm.reset();
-    CHECK(fsm.getState() == ActivityFSM::State::NONE);
-    CHECK_FALSE(fsm.isActive());
-}
diff --git a/tests/test_anim_capability.cpp b/tests/test_anim_capability.cpp
deleted file mode 100644
index acf51b41..00000000
--- a/tests/test_anim_capability.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-// AnimCapabilitySet unit tests
-#include <catch_amalgamated.hpp>
-#include "rendering/animation/anim_capability_set.hpp"
-
-using namespace wowee::rendering;
-
-TEST_CASE("AnimCapabilitySet: default-constructed has all zero IDs", "[capability]") {
-    AnimCapabilitySet caps;
-
-    CHECK(caps.resolvedStand == 0);
-    CHECK(caps.resolvedWalk == 0);
-    CHECK(caps.resolvedRun == 0);
-    CHECK(caps.resolvedSprint == 0);
-    CHECK(caps.resolvedJumpStart == 0);
-    CHECK(caps.resolvedJump == 0);
-    CHECK(caps.resolvedJumpEnd == 0);
-    CHECK(caps.resolvedSwimIdle == 0);
-    CHECK(caps.resolvedSwim == 0);
-    CHECK(caps.resolvedCombatIdle == 0);
-    CHECK(caps.resolvedMelee1H == 0);
-    CHECK(caps.resolvedMelee2H == 0);
-    CHECK(caps.resolvedStun == 0);
-    CHECK(caps.resolvedMount == 0);
-    CHECK(caps.resolvedStealthIdle == 0);
-    CHECK(caps.resolvedLoot == 0);
-}
-
-TEST_CASE("AnimCapabilitySet: default-constructed has all flags false", "[capability]") {
-    AnimCapabilitySet caps;
-
-    CHECK_FALSE(caps.hasStand);
-    CHECK_FALSE(caps.hasWalk);
-    CHECK_FALSE(caps.hasRun);
-    CHECK_FALSE(caps.hasSprint);
-    CHECK_FALSE(caps.hasWalkBackwards);
-    CHECK_FALSE(caps.hasJump);
-    CHECK_FALSE(caps.hasSwim);
-    CHECK_FALSE(caps.hasMelee);
-    CHECK_FALSE(caps.hasStealth);
-    CHECK_FALSE(caps.hasDeath);
-    CHECK_FALSE(caps.hasMount);
-}
-
-TEST_CASE("AnimOutput::ok creates valid output", "[capability]") {
-    auto out = AnimOutput::ok(42, true);
-    CHECK(out.valid);
-    CHECK(out.animId == 42);
-    CHECK(out.loop == true);
-}
-
-TEST_CASE("AnimOutput::stay creates invalid output", "[capability]") {
-    auto out = AnimOutput::stay();
-    CHECK_FALSE(out.valid);
-    CHECK(out.animId == 0);
-    CHECK(out.loop == false);
-}
diff --git a/tests/test_animation_ids.cpp b/tests/test_animation_ids.cpp
deleted file mode 100644
index 4bb53790..00000000
--- a/tests/test_animation_ids.cpp
+++ /dev/null
@@ -1,184 +0,0 @@
-// Animation ID validation tests — covers nameFromId() and validateAgainstDBC()
-#include <catch_amalgamated.hpp>
-#include "rendering/animation/animation_ids.hpp"
-#include "pipeline/dbc_loader.hpp"
-#include <cstring>
-#include <vector>
-
-using wowee::pipeline::DBCFile;
-namespace anim = wowee::rendering::anim;
-
-// Build a synthetic AnimationData.dbc in memory.
-// AnimationData.dbc layout: each record has at least 1 field (the animation ID).
-// We use numFields=2 (id + dummy) to mirror the real DBC which has multiple fields.
-static std::vector<uint8_t> buildAnimationDBC(const std::vector<uint32_t>& animIds) {
-    const uint32_t numRecords = static_cast<uint32_t>(animIds.size());
-    const uint32_t numFields = 2;  // id + a dummy field
-    const uint32_t recordSize = numFields * 4;
-    const uint32_t stringBlockSize = 1; // single null byte
-
-    std::vector<uint8_t> data;
-    data.reserve(20 + numRecords * recordSize + stringBlockSize);
-
-    // Magic "WDBC"
-    data.push_back('W'); data.push_back('D'); data.push_back('B'); data.push_back('C');
-
-    auto writeU32 = [&](uint32_t v) {
-        data.push_back(static_cast<uint8_t>(v & 0xFF));
-        data.push_back(static_cast<uint8_t>((v >> 8) & 0xFF));
-        data.push_back(static_cast<uint8_t>((v >> 16) & 0xFF));
-        data.push_back(static_cast<uint8_t>((v >> 24) & 0xFF));
-    };
-
-    writeU32(numRecords);
-    writeU32(numFields);
-    writeU32(recordSize);
-    writeU32(stringBlockSize);
-
-    // Records: [animId, 0]
-    for (uint32_t id : animIds) {
-        writeU32(id);
-        writeU32(0);
-    }
-
-    // String block: single null
-    data.push_back('\0');
-
-    return data;
-}
-
-// ── nameFromId tests ────────────────────────────────────────────────────────
-
-TEST_CASE("nameFromId returns correct names for known IDs", "[animation]") {
-    REQUIRE(std::string(anim::nameFromId(anim::STAND)) == "STAND");
-    REQUIRE(std::string(anim::nameFromId(anim::DEATH)) == "DEATH");
-    REQUIRE(std::string(anim::nameFromId(anim::WALK)) == "WALK");
-    REQUIRE(std::string(anim::nameFromId(anim::RUN)) == "RUN");
-    REQUIRE(std::string(anim::nameFromId(anim::ATTACK_UNARMED)) == "ATTACK_UNARMED");
-    REQUIRE(std::string(anim::nameFromId(anim::ATTACK_1H)) == "ATTACK_1H");
-    REQUIRE(std::string(anim::nameFromId(anim::ATTACK_2H)) == "ATTACK_2H");
-    REQUIRE(std::string(anim::nameFromId(anim::ATTACK_2H_LOOSE)) == "ATTACK_2H_LOOSE");
-    REQUIRE(std::string(anim::nameFromId(anim::SPELL_CAST_DIRECTED)) == "SPELL_CAST_DIRECTED");
-    REQUIRE(std::string(anim::nameFromId(anim::SPELL_CAST_OMNI)) == "SPELL_CAST_OMNI");
-    REQUIRE(std::string(anim::nameFromId(anim::READY_1H)) == "READY_1H");
-    REQUIRE(std::string(anim::nameFromId(anim::READY_2H)) == "READY_2H");
-    REQUIRE(std::string(anim::nameFromId(anim::READY_2H_LOOSE)) == "READY_2H_LOOSE");
-    REQUIRE(std::string(anim::nameFromId(anim::READY_UNARMED)) == "READY_UNARMED");
-    REQUIRE(std::string(anim::nameFromId(anim::EMOTE_DANCE)) == "EMOTE_DANCE");
-}
-
-TEST_CASE("nameFromId returns UNKNOWN for out-of-range IDs", "[animation]") {
-    REQUIRE(std::string(anim::nameFromId(anim::ANIM_COUNT)) == "UNKNOWN");
-    REQUIRE(std::string(anim::nameFromId(anim::ANIM_COUNT + 1)) == "UNKNOWN");
-    REQUIRE(std::string(anim::nameFromId(9999)) == "UNKNOWN");
-    REQUIRE(std::string(anim::nameFromId(UINT32_MAX)) == "UNKNOWN");
-}
-
-TEST_CASE("nameFromId covers first and last IDs", "[animation]") {
-    REQUIRE(std::string(anim::nameFromId(0)) == "STAND");
-    REQUIRE(std::string(anim::nameFromId(anim::ANIM_COUNT - 1)) == "FLY_GUILD_CHAMPION_2");
-}
-
-// ── validateAgainstDBC tests ────────────────────────────────────────────────
-
-TEST_CASE("validateAgainstDBC handles null DBC", "[animation][dbc]") {
-    // Should not crash — just logs a warning
-    anim::validateAgainstDBC(nullptr);
-}
-
-TEST_CASE("validateAgainstDBC handles unloaded DBC", "[animation][dbc]") {
-    auto dbc = std::make_shared<DBCFile>();
-    REQUIRE_FALSE(dbc->isLoaded());
-    // Should not crash — just logs a warning
-    anim::validateAgainstDBC(dbc);
-}
-
-TEST_CASE("validateAgainstDBC with perfect match", "[animation][dbc]") {
-    // Build a DBC containing IDs 0..ANIM_COUNT-1 (exact match)
-    std::vector<uint32_t> allIds;
-    for (uint32_t i = 0; i < anim::ANIM_COUNT; ++i) {
-        allIds.push_back(i);
-    }
-    auto data = buildAnimationDBC(allIds);
-
-    auto dbc = std::make_shared<DBCFile>();
-    REQUIRE(dbc->load(data));
-    REQUIRE(dbc->getRecordCount() == anim::ANIM_COUNT);
-
-    // Should complete without crashing — all IDs match
-    anim::validateAgainstDBC(dbc);
-}
-
-TEST_CASE("validateAgainstDBC with missing IDs in DBC", "[animation][dbc]") {
-    // DBC only contains a subset of IDs — misses many
-    std::vector<uint32_t> partialIds = {0, 1, 2, 4, 5};
-    auto data = buildAnimationDBC(partialIds);
-
-    auto dbc = std::make_shared<DBCFile>();
-    REQUIRE(dbc->load(data));
-    REQUIRE(dbc->getRecordCount() == 5);
-
-    // Should log warnings for missing IDs but not crash
-    anim::validateAgainstDBC(dbc);
-}
-
-TEST_CASE("validateAgainstDBC with extra IDs beyond range", "[animation][dbc]") {
-    // DBC has some IDs beyond ANIM_COUNT
-    std::vector<uint32_t> extraIds = {0, 1, 500, 600, 1000};
-    auto data = buildAnimationDBC(extraIds);
-
-    auto dbc = std::make_shared<DBCFile>();
-    REQUIRE(dbc->load(data));
-    REQUIRE(dbc->getRecordCount() == 5);
-
-    // Should log info about extra DBC-only IDs but not crash
-    anim::validateAgainstDBC(dbc);
-}
-
-TEST_CASE("validateAgainstDBC with empty DBC", "[animation][dbc]") {
-    // DBC with zero records
-    auto data = buildAnimationDBC({});
-
-    auto dbc = std::make_shared<DBCFile>();
-    REQUIRE(dbc->load(data));
-    REQUIRE(dbc->getRecordCount() == 0);
-
-    // Should log warnings for all ANIM_COUNT missing IDs but not crash
-    anim::validateAgainstDBC(dbc);
-}
-
-TEST_CASE("validateAgainstDBC with single ID", "[animation][dbc]") {
-    // DBC with just STAND (id=0)
-    auto data = buildAnimationDBC({0});
-
-    auto dbc = std::make_shared<DBCFile>();
-    REQUIRE(dbc->load(data));
-    REQUIRE(dbc->getRecordCount() == 1);
-
-    anim::validateAgainstDBC(dbc);
-}
-
-TEST_CASE("ANIM_COUNT matches expected value", "[animation]") {
-    REQUIRE(anim::ANIM_COUNT == 452);
-}
-
-TEST_CASE("Animation constant IDs are unique and sequential from documentation", "[animation]") {
-    // Verify key animation ID values match WoW's AnimationData.dbc layout
-    REQUIRE(anim::STAND == 0);
-    REQUIRE(anim::DEATH == 1);
-    REQUIRE(anim::SPELL == 2);
-    REQUIRE(anim::ATTACK_UNARMED == 16);
-    REQUIRE(anim::ATTACK_1H == 17);
-    REQUIRE(anim::ATTACK_2H == 18);
-    REQUIRE(anim::ATTACK_2H_LOOSE == 19);
-    REQUIRE(anim::READY_UNARMED == 25);
-    REQUIRE(anim::READY_1H == 26);
-    REQUIRE(anim::READY_2H == 27);
-    REQUIRE(anim::READY_2H_LOOSE == 28);
-    REQUIRE(anim::SPELL_CAST == 32);
-    REQUIRE(anim::SPELL_CAST_DIRECTED == 53);
-    REQUIRE(anim::SPELL_CAST_OMNI == 54);
-    REQUIRE(anim::CHANNEL_CAST_DIRECTED == 124);
-    REQUIRE(anim::CHANNEL_CAST_OMNI == 125);
-    REQUIRE(anim::EMOTE_DANCE == 69);
-}
diff --git a/tests/test_blp_loader.cpp b/tests/test_blp_loader.cpp
deleted file mode 100644
index 6d6a80af..00000000
--- a/tests/test_blp_loader.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-// BLP loader tests: isValid, format names, invalid data handling
-#include <catch_amalgamated.hpp>
-#include "pipeline/blp_loader.hpp"
-
-using wowee::pipeline::BLPLoader;
-using wowee::pipeline::BLPImage;
-using wowee::pipeline::BLPFormat;
-using wowee::pipeline::BLPCompression;
-
-TEST_CASE("BLPImage default is invalid", "[blp]") {
-    BLPImage img;
-    REQUIRE_FALSE(img.isValid());
-    REQUIRE(img.width == 0);
-    REQUIRE(img.height == 0);
-    REQUIRE(img.format == BLPFormat::UNKNOWN);
-    REQUIRE(img.compression == BLPCompression::NONE);
-}
-
-TEST_CASE("BLPImage isValid with data", "[blp]") {
-    BLPImage img;
-    img.width = 64;
-    img.height = 64;
-    img.data.resize(64 * 64 * 4, 0xFF);  // RGBA
-    REQUIRE(img.isValid());
-}
-
-TEST_CASE("BLPImage isValid requires non-empty data", "[blp]") {
-    BLPImage img;
-    img.width = 64;
-    img.height = 64;
-    // data is empty
-    REQUIRE_FALSE(img.isValid());
-}
-
-TEST_CASE("BLPLoader::load empty data returns invalid", "[blp]") {
-    std::vector<uint8_t> empty;
-    auto img = BLPLoader::load(empty);
-    REQUIRE_FALSE(img.isValid());
-}
-
-TEST_CASE("BLPLoader::load too small data returns invalid", "[blp]") {
-    std::vector<uint8_t> tiny = {0x42, 0x4C, 0x50}; // BLP but truncated
-    auto img = BLPLoader::load(tiny);
-    REQUIRE_FALSE(img.isValid());
-}
-
-TEST_CASE("BLPLoader::load invalid magic returns invalid", "[blp]") {
-    // Provide enough bytes but with wrong magic
-    std::vector<uint8_t> bad(256, 0);
-    bad[0] = 'N'; bad[1] = 'O'; bad[2] = 'T'; bad[3] = '!';
-    auto img = BLPLoader::load(bad);
-    REQUIRE_FALSE(img.isValid());
-}
-
-TEST_CASE("BLPLoader getFormatName returns non-null", "[blp]") {
-    REQUIRE(BLPLoader::getFormatName(BLPFormat::UNKNOWN) != nullptr);
-    REQUIRE(BLPLoader::getFormatName(BLPFormat::BLP1) != nullptr);
-    REQUIRE(BLPLoader::getFormatName(BLPFormat::BLP2) != nullptr);
-
-    // Check that names are distinct
-    REQUIRE(std::string(BLPLoader::getFormatName(BLPFormat::BLP1)) !=
-            std::string(BLPLoader::getFormatName(BLPFormat::BLP2)));
-}
-
-TEST_CASE("BLPLoader getCompressionName returns non-null", "[blp]") {
-    REQUIRE(BLPLoader::getCompressionName(BLPCompression::NONE) != nullptr);
-    REQUIRE(BLPLoader::getCompressionName(BLPCompression::DXT1) != nullptr);
-    REQUIRE(BLPLoader::getCompressionName(BLPCompression::DXT3) != nullptr);
-    REQUIRE(BLPLoader::getCompressionName(BLPCompression::DXT5) != nullptr);
-    REQUIRE(BLPLoader::getCompressionName(BLPCompression::PALETTE) != nullptr);
-    REQUIRE(BLPLoader::getCompressionName(BLPCompression::ARGB8888) != nullptr);
-
-    // Check that DXT names differ
-    REQUIRE(std::string(BLPLoader::getCompressionName(BLPCompression::DXT1)) !=
-            std::string(BLPLoader::getCompressionName(BLPCompression::DXT5)));
-}
-
-TEST_CASE("BLPImage mipmap storage", "[blp]") {
-    BLPImage img;
-    img.width = 128;
-    img.height = 128;
-    img.data.resize(128 * 128 * 4, 0);
-    img.mipLevels = 3;
-
-    // Add mipmap data
-    img.mipmaps.push_back(std::vector<uint8_t>(64 * 64 * 4, 0));
-    img.mipmaps.push_back(std::vector<uint8_t>(32 * 32 * 4, 0));
-    img.mipmaps.push_back(std::vector<uint8_t>(16 * 16 * 4, 0));
-
-    REQUIRE(img.isValid());
-    REQUIRE(img.mipmaps.size() == 3);
-}
diff --git a/tests/test_combat_fsm.cpp b/tests/test_combat_fsm.cpp
deleted file mode 100644
index bc206e9a..00000000
--- a/tests/test_combat_fsm.cpp
+++ /dev/null
@@ -1,125 +0,0 @@
-// CombatFSM unit tests
-#include <catch_amalgamated.hpp>
-#include "rendering/animation/combat_fsm.hpp"
-#include "rendering/animation/animation_ids.hpp"
-
-using namespace wowee::rendering;
-namespace anim = wowee::rendering::anim;
-
-static AnimCapabilitySet makeCombatCaps() {
-    AnimCapabilitySet caps;
-    caps.resolvedStand = anim::STAND;
-    caps.resolvedCombatIdle = anim::READY_UNARMED;
-    caps.resolvedMelee1H = anim::ATTACK_1H;
-    caps.resolvedMelee2H = anim::ATTACK_2H;
-    caps.resolvedMeleeUnarmed = anim::ATTACK_UNARMED;
-    caps.resolvedStun = anim::STUN;
-    caps.resolvedUnsheathe = anim::UNSHEATHE;
-    caps.resolvedSheathe = anim::SHEATHE;
-    caps.hasMelee = true;
-    return caps;
-}
-
-static CombatFSM::Input combatInput() {
-    CombatFSM::Input in;
-    in.inCombat = true;
-    in.grounded = true;
-    return in;
-}
-
-static WeaponLoadout unarmedLoadout() {
-    return WeaponLoadout{}; // Default is unarmed (inventoryType=0)
-}
-
-TEST_CASE("CombatFSM: INACTIVE by default", "[combat]") {
-    CombatFSM fsm;
-    CHECK(fsm.getState() == CombatFSM::State::INACTIVE);
-    CHECK_FALSE(fsm.isActive());
-}
-
-TEST_CASE("CombatFSM: INACTIVE → UNSHEATHE on COMBAT_ENTER event", "[combat]") {
-    CombatFSM fsm;
-    fsm.onEvent(AnimEvent::COMBAT_ENTER);
-    CHECK(fsm.getState() == CombatFSM::State::UNSHEATHE);
-    CHECK(fsm.isActive());
-}
-
-TEST_CASE("CombatFSM: stun overrides active combat", "[combat]") {
-    CombatFSM fsm;
-    auto caps = makeCombatCaps();
-    auto wl = unarmedLoadout();
-
-    // Enter combat
-    fsm.onEvent(AnimEvent::COMBAT_ENTER);
-
-    // Stun
-    fsm.setStunned(true);
-    auto in = combatInput();
-    auto out = fsm.resolve(in, caps, wl);
-
-    CHECK(fsm.isStunned());
-    REQUIRE(out.valid);
-    CHECK(out.animId == anim::STUN);
-}
-
-TEST_CASE("CombatFSM: stun does not override swimming", "[combat]") {
-    CombatFSM fsm;
-    auto caps = makeCombatCaps();
-    auto wl = unarmedLoadout();
-
-    fsm.setStunned(true);
-    auto in = combatInput();
-    in.swimming = true;
-    auto out = fsm.resolve(in, caps, wl);
-
-    // Swimming overrides combat entirely — FSM should go inactive
-    // The exact behavior depends on implementation, but stun should not
-    // force an animation while swimming
-    CHECK(fsm.getState() != CombatFSM::State::STUNNED);
-}
-
-TEST_CASE("CombatFSM: spell cast sequence", "[combat]") {
-    CombatFSM fsm;
-    auto caps = makeCombatCaps();
-    auto wl = unarmedLoadout();
-
-    fsm.startSpellCast(anim::SPELL_PRECAST, anim::SPELL, true, anim::SPELL_CAST);
-    CHECK(fsm.getState() == CombatFSM::State::SPELL_PRECAST);
-
-    auto in = combatInput();
-    auto out = fsm.resolve(in, caps, wl);
-    REQUIRE(out.valid);
-    CHECK(out.animId == anim::SPELL_PRECAST);
-}
-
-TEST_CASE("CombatFSM: stopSpellCast transitions to finalize", "[combat]") {
-    CombatFSM fsm;
-    auto caps = makeCombatCaps();
-    auto wl = unarmedLoadout();
-
-    fsm.startSpellCast(0, anim::SPELL, true, anim::SPELL_CAST);
-    // Skip precast (animId=0), go to casting
-    fsm.setState(CombatFSM::State::SPELL_CASTING);
-
-    fsm.stopSpellCast();
-    CHECK(fsm.getState() == CombatFSM::State::SPELL_FINALIZE);
-}
-
-TEST_CASE("CombatFSM: hit reaction", "[combat]") {
-    CombatFSM fsm;
-    auto caps = makeCombatCaps();
-    auto wl = unarmedLoadout();
-
-    fsm.triggerHitReaction(anim::COMBAT_WOUND);
-    CHECK(fsm.getState() == CombatFSM::State::HIT_REACTION);
-}
-
-TEST_CASE("CombatFSM: reset clears all state", "[combat]") {
-    CombatFSM fsm;
-    fsm.onEvent(AnimEvent::COMBAT_ENTER);
-    fsm.setStunned(true);
-
-    fsm.reset();
-    CHECK(fsm.getState() == CombatFSM::State::INACTIVE);
-    CHECK_FALSE(fsm.isStunned());
-}
diff --git a/tests/test_dbc_loader.cpp b/tests/test_dbc_loader.cpp
deleted file mode 100644
index 6a6fcea1..00000000
--- a/tests/test_dbc_loader.cpp
+++ /dev/null
@@ -1,208 +0,0 @@
-// DBC binary parsing tests with synthetic data
-#include <catch_amalgamated.hpp>
-#include "pipeline/dbc_loader.hpp"
-#include <cstring>
-
-using wowee::pipeline::DBCFile;
-
-// Build a minimal valid DBC in memory:
-//   Header: "WDBC" + recordCount(uint32) + fieldCount(uint32) + recordSize(uint32) + stringBlockSize(uint32)
-//   Records: contiguous fixed-size rows
-//   String block: null-terminated strings
-static std::vector<uint8_t> buildSyntheticDBC(
-    uint32_t numRecords, uint32_t numFields,
-    const std::vector<std::vector<uint32_t>>& records,
-    const std::string& stringBlock)
-{
-    const uint32_t recordSize = numFields * 4;
-    const uint32_t stringBlockSize = static_cast<uint32_t>(stringBlock.size());
-
-    std::vector<uint8_t> data;
-    // Reserve enough space
-    data.reserve(20 + numRecords * recordSize + stringBlockSize);
-
-    // Magic
-    data.push_back('W'); data.push_back('D'); data.push_back('B'); data.push_back('C');
-
-    auto writeU32 = [&](uint32_t v) {
-        data.push_back(static_cast<uint8_t>(v & 0xFF));
-        data.push_back(static_cast<uint8_t>((v >> 8) & 0xFF));
-        data.push_back(static_cast<uint8_t>((v >> 16) & 0xFF));
-        data.push_back(static_cast<uint8_t>((v >> 24) & 0xFF));
-    };
-
-    writeU32(numRecords);
-    writeU32(numFields);
-    writeU32(recordSize);
-    writeU32(stringBlockSize);
-
-    // Records
-    for (const auto& rec : records) {
-        for (uint32_t field : rec) {
-            writeU32(field);
-        }
-    }
-
-    // String block
-    for (char c : stringBlock) {
-        data.push_back(static_cast<uint8_t>(c));
-    }
-
-    return data;
-}
-
-TEST_CASE("DBCFile default state", "[dbc]") {
-    DBCFile dbc;
-    REQUIRE_FALSE(dbc.isLoaded());
-    REQUIRE(dbc.getRecordCount() == 0);
-    REQUIRE(dbc.getFieldCount() == 0);
-}
-
-TEST_CASE("DBCFile load valid DBC", "[dbc]") {
-    // 2 records, 3 fields each: [id, intVal, stringOffset]
-    // String block: "\0Hello\0World\0" → offset 0="" 1="Hello" 7="World"
-    std::string strings;
-    strings += '\0';             // offset 0: empty string
-    strings += "Hello";
-    strings += '\0';             // offset 1-6: "Hello"
-    strings += "World";
-    strings += '\0';             // offset 7-12: "World"
-
-    auto data = buildSyntheticDBC(2, 3,
-        {
-            {1, 100, 1},   // Record 0: id=1, intVal=100, stringOffset=1 → "Hello"
-            {2, 200, 7},   // Record 1: id=2, intVal=200, stringOffset=7 → "World"
-        },
-        strings);
-
-    DBCFile dbc;
-    REQUIRE(dbc.load(data));
-    REQUIRE(dbc.isLoaded());
-    REQUIRE(dbc.getRecordCount() == 2);
-    REQUIRE(dbc.getFieldCount() == 3);
-    REQUIRE(dbc.getRecordSize() == 12);
-    REQUIRE(dbc.getStringBlockSize() == strings.size());
-}
-
-TEST_CASE("DBCFile getUInt32 and getInt32", "[dbc]") {
-    auto data = buildSyntheticDBC(1, 2,
-        { {42, 0xFFFFFFFF} },
-        std::string(1, '\0'));
-
-    DBCFile dbc;
-    REQUIRE(dbc.load(data));
-
-    REQUIRE(dbc.getUInt32(0, 0) == 42);
-    REQUIRE(dbc.getUInt32(0, 1) == 0xFFFFFFFF);
-    REQUIRE(dbc.getInt32(0, 1) == -1);
-}
-
-TEST_CASE("DBCFile getFloat", "[dbc]") {
-    float testVal = 3.14f;
-    uint32_t bits;
-    std::memcpy(&bits, &testVal, 4);
-
-    auto data = buildSyntheticDBC(1, 2,
-        { {1, bits} },
-        std::string(1, '\0'));
-
-    DBCFile dbc;
-    REQUIRE(dbc.load(data));
-    REQUIRE(dbc.getFloat(0, 1) == Catch::Approx(3.14f));
-}
-
-TEST_CASE("DBCFile getString", "[dbc]") {
-    std::string strings;
-    strings += '\0';
-    strings += "TestString";
-    strings += '\0';
-
-    auto data = buildSyntheticDBC(1, 2,
-        { {1, 1} },  // field 1 = string offset 1 → "TestString"
-        strings);
-
-    DBCFile dbc;
-    REQUIRE(dbc.load(data));
-    REQUIRE(dbc.getString(0, 1) == "TestString");
-}
-
-TEST_CASE("DBCFile getStringView", "[dbc]") {
-    std::string strings;
-    strings += '\0';
-    strings += "ViewTest";
-    strings += '\0';
-
-    auto data = buildSyntheticDBC(1, 2,
-        { {1, 1} },
-        strings);
-
-    DBCFile dbc;
-    REQUIRE(dbc.load(data));
-    REQUIRE(dbc.getStringView(0, 1) == "ViewTest");
-}
-
-TEST_CASE("DBCFile findRecordById", "[dbc]") {
-    auto data = buildSyntheticDBC(3, 2,
-        {
-            {10, 100},
-            {20, 200},
-            {30, 300},
-        },
-        std::string(1, '\0'));
-
-    DBCFile dbc;
-    REQUIRE(dbc.load(data));
-
-    REQUIRE(dbc.findRecordById(10) == 0);
-    REQUIRE(dbc.findRecordById(20) == 1);
-    REQUIRE(dbc.findRecordById(30) == 2);
-    REQUIRE(dbc.findRecordById(99) == -1);
-}
-
-TEST_CASE("DBCFile getRecord returns pointer", "[dbc]") {
-    auto data = buildSyntheticDBC(1, 2,
-        { {0xAB, 0xCD} },
-        std::string(1, '\0'));
-
-    DBCFile dbc;
-    REQUIRE(dbc.load(data));
-
-    const uint8_t* rec = dbc.getRecord(0);
-    REQUIRE(rec != nullptr);
-
-    // First field should be 0xAB in little-endian
-    uint32_t val;
-    std::memcpy(&val, rec, 4);
-    REQUIRE(val == 0xAB);
-}
-
-TEST_CASE("DBCFile load too small data", "[dbc]") {
-    std::vector<uint8_t> tiny = {'W', 'D', 'B'};
-    DBCFile dbc;
-    REQUIRE_FALSE(dbc.load(tiny));
-}
-
-TEST_CASE("DBCFile load wrong magic", "[dbc]") {
-    auto data = buildSyntheticDBC(0, 1, {}, std::string(1, '\0'));
-    // Corrupt magic
-    data[0] = 'X';
-
-    DBCFile dbc;
-    REQUIRE_FALSE(dbc.load(data));
-}
-
-TEST_CASE("DBCFile getStringByOffset", "[dbc]") {
-    std::string strings;
-    strings += '\0';
-    strings += "Offset5";  // This would be at offset 1 actually, let me be precise
-    strings += '\0';
-
-    auto data = buildSyntheticDBC(1, 1,
-        { {0} },
-        strings);
-
-    DBCFile dbc;
-    REQUIRE(dbc.load(data));
-    REQUIRE(dbc.getStringByOffset(1) == "Offset5");
-    REQUIRE(dbc.getStringByOffset(0).empty());
-}
diff --git a/tests/test_entity.cpp b/tests/test_entity.cpp
deleted file mode 100644
index 98de8dde..00000000
--- a/tests/test_entity.cpp
+++ /dev/null
@@ -1,220 +0,0 @@
-// Entity, Unit, Player, GameObject, EntityManager tests
-#include <catch_amalgamated.hpp>
-#include "game/entity.hpp"
-#include <memory>
-
-using namespace wowee::game;
-
-TEST_CASE("Entity default construction", "[entity]") {
-    Entity e;
-    REQUIRE(e.getGuid() == 0);
-    REQUIRE(e.getType() == ObjectType::OBJECT);
-    REQUIRE(e.getX() == 0.0f);
-    REQUIRE(e.getY() == 0.0f);
-    REQUIRE(e.getZ() == 0.0f);
-    REQUIRE(e.getOrientation() == 0.0f);
-}
-
-TEST_CASE("Entity GUID constructor", "[entity]") {
-    Entity e(0xDEADBEEF);
-    REQUIRE(e.getGuid() == 0xDEADBEEF);
-}
-
-TEST_CASE("Entity position set/get", "[entity]") {
-    Entity e;
-    e.setPosition(1.0f, 2.0f, 3.0f, 1.57f);
-    REQUIRE(e.getX() == Catch::Approx(1.0f));
-    REQUIRE(e.getY() == Catch::Approx(2.0f));
-    REQUIRE(e.getZ() == Catch::Approx(3.0f));
-    REQUIRE(e.getOrientation() == Catch::Approx(1.57f));
-}
-
-TEST_CASE("Entity field set/get/has", "[entity]") {
-    Entity e;
-    REQUIRE_FALSE(e.hasField(10));
-
-    e.setField(10, 0xCAFE);
-    REQUIRE(e.hasField(10));
-    REQUIRE(e.getField(10) == 0xCAFE);
-
-    // Overwrite
-    e.setField(10, 0xBEEF);
-    REQUIRE(e.getField(10) == 0xBEEF);
-
-    // Non-existent returns 0
-    REQUIRE(e.getField(999) == 0);
-}
-
-TEST_CASE("Unit construction and type", "[entity]") {
-    Unit u;
-    REQUIRE(u.getType() == ObjectType::UNIT);
-
-    Unit u2(0x123);
-    REQUIRE(u2.getGuid() == 0x123);
-    REQUIRE(u2.getType() == ObjectType::UNIT);
-}
-
-TEST_CASE("Unit name", "[entity]") {
-    Unit u;
-    REQUIRE(u.getName().empty());
-    u.setName("Hogger");
-    REQUIRE(u.getName() == "Hogger");
-}
-
-TEST_CASE("Unit health", "[entity]") {
-    Unit u;
-    REQUIRE(u.getHealth() == 0);
-    REQUIRE(u.getMaxHealth() == 0);
-
-    u.setHealth(500);
-    u.setMaxHealth(1000);
-    REQUIRE(u.getHealth() == 500);
-    REQUIRE(u.getMaxHealth() == 1000);
-}
-
-TEST_CASE("Unit power by type", "[entity]") {
-    Unit u;
-    u.setPowerType(0); // mana
-    u.setPower(200);
-    u.setMaxPower(500);
-
-    REQUIRE(u.getPower() == 200);
-    REQUIRE(u.getMaxPower() == 500);
-    REQUIRE(u.getPowerByType(0) == 200);
-    REQUIRE(u.getMaxPowerByType(0) == 500);
-
-    // Set rage (type 1)
-    u.setPowerByType(1, 50);
-    u.setMaxPowerByType(1, 100);
-    REQUIRE(u.getPowerByType(1) == 50);
-    REQUIRE(u.getMaxPowerByType(1) == 100);
-
-    // Out of bounds clamps
-    REQUIRE(u.getPowerByType(7) == 0);
-    REQUIRE(u.getMaxPowerByType(7) == 0);
-}
-
-TEST_CASE("Unit level, entry, displayId", "[entity]") {
-    Unit u;
-    REQUIRE(u.getLevel() == 1); // default
-    u.setLevel(80);
-    REQUIRE(u.getLevel() == 80);
-
-    u.setEntry(1234);
-    REQUIRE(u.getEntry() == 1234);
-
-    u.setDisplayId(5678);
-    REQUIRE(u.getDisplayId() == 5678);
-}
-
-TEST_CASE("Unit flags", "[entity]") {
-    Unit u;
-    u.setUnitFlags(0x01);
-    REQUIRE(u.getUnitFlags() == 0x01);
-
-    u.setDynamicFlags(0x02);
-    REQUIRE(u.getDynamicFlags() == 0x02);
-
-    u.setNpcFlags(0x04);
-    REQUIRE(u.getNpcFlags() == 0x04);
-    REQUIRE(u.isInteractable());
-
-    u.setNpcFlags(0);
-    REQUIRE_FALSE(u.isInteractable());
-}
-
-TEST_CASE("Unit faction and hostility", "[entity]") {
-    Unit u;
-    u.setFactionTemplate(14); // Undercity
-    REQUIRE(u.getFactionTemplate() == 14);
-
-    REQUIRE_FALSE(u.isHostile());
-    u.setHostile(true);
-    REQUIRE(u.isHostile());
-}
-
-TEST_CASE("Unit mount display ID", "[entity]") {
-    Unit u;
-    REQUIRE(u.getMountDisplayId() == 0);
-    u.setMountDisplayId(14374);
-    REQUIRE(u.getMountDisplayId() == 14374);
-}
-
-TEST_CASE("Player inherits Unit", "[entity]") {
-    Player p(0xABC);
-    REQUIRE(p.getType() == ObjectType::PLAYER);
-    REQUIRE(p.getGuid() == 0xABC);
-
-    // Player inherits Unit name — regression test for the shadowed-field fix
-    p.setName("Arthas");
-    REQUIRE(p.getName() == "Arthas");
-
-    p.setLevel(80);
-    REQUIRE(p.getLevel() == 80);
-}
-
-TEST_CASE("GameObject construction", "[entity]") {
-    GameObject go(0x999);
-    REQUIRE(go.getType() == ObjectType::GAMEOBJECT);
-    REQUIRE(go.getGuid() == 0x999);
-
-    go.setName("Mailbox");
-    REQUIRE(go.getName() == "Mailbox");
-
-    go.setEntry(42);
-    REQUIRE(go.getEntry() == 42);
-
-    go.setDisplayId(100);
-    REQUIRE(go.getDisplayId() == 100);
-}
-
-TEST_CASE("EntityManager add/get/has/remove", "[entity]") {
-    EntityManager mgr;
-    REQUIRE(mgr.getEntityCount() == 0);
-
-    auto unit = std::make_shared<Unit>(1);
-    unit->setName("TestUnit");
-    mgr.addEntity(1, unit);
-
-    REQUIRE(mgr.getEntityCount() == 1);
-    REQUIRE(mgr.hasEntity(1));
-    REQUIRE_FALSE(mgr.hasEntity(2));
-
-    auto retrieved = mgr.getEntity(1);
-    REQUIRE(retrieved != nullptr);
-    REQUIRE(retrieved->getGuid() == 1);
-
-    mgr.removeEntity(1);
-    REQUIRE_FALSE(mgr.hasEntity(1));
-    REQUIRE(mgr.getEntityCount() == 0);
-}
-
-TEST_CASE("EntityManager clear", "[entity]") {
-    EntityManager mgr;
-    mgr.addEntity(1, std::make_shared<Entity>(1));
-    mgr.addEntity(2, std::make_shared<Entity>(2));
-    REQUIRE(mgr.getEntityCount() == 2);
-
-    mgr.clear();
-    REQUIRE(mgr.getEntityCount() == 0);
-}
-
-TEST_CASE("EntityManager null entity rejected", "[entity]") {
-    EntityManager mgr;
-    mgr.addEntity(1, nullptr);
-    // Null should be rejected (logged warning, not stored)
-    REQUIRE(mgr.getEntityCount() == 0);
-}
-
-TEST_CASE("EntityManager getEntities returns all", "[entity]") {
-    EntityManager mgr;
-    mgr.addEntity(10, std::make_shared<Unit>(10));
-    mgr.addEntity(20, std::make_shared<Player>(20));
-    mgr.addEntity(30, std::make_shared<GameObject>(30));
-
-    const auto& all = mgr.getEntities();
-    REQUIRE(all.size() == 3);
-    REQUIRE(all.count(10) == 1);
-    REQUIRE(all.count(20) == 1);
-    REQUIRE(all.count(30) == 1);
-}
diff --git a/tests/test_frustum.cpp b/tests/test_frustum.cpp
deleted file mode 100644
index 7de37188..00000000
--- a/tests/test_frustum.cpp
+++ /dev/null
@@ -1,132 +0,0 @@
-// Frustum plane extraction and intersection tests
-#include <catch_amalgamated.hpp>
-#include "rendering/frustum.hpp"
-
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-
-using wowee::rendering::Frustum;
-using wowee::rendering::Plane;
-
-TEST_CASE("Plane distanceToPoint", "[frustum]") {
-    // Plane facing +Y at y=5
-    Plane p(glm::vec3(0.0f, 1.0f, 0.0f), -5.0f);
-
-    // Point at y=10 → distance = 10 + (-5) = 5 (in front)
-    REQUIRE(p.distanceToPoint(glm::vec3(0, 10, 0)) == Catch::Approx(5.0f));
-
-    // Point at y=5 → distance = 0 (on plane)
-    REQUIRE(p.distanceToPoint(glm::vec3(0, 5, 0)) == Catch::Approx(0.0f));
-
-    // Point at y=0 → distance = -5 (behind)
-    REQUIRE(p.distanceToPoint(glm::vec3(0, 0, 0)) == Catch::Approx(-5.0f));
-}
-
-TEST_CASE("Frustum extractFromMatrix with identity", "[frustum]") {
-    Frustum f;
-    f.extractFromMatrix(glm::mat4(1.0f));
-
-    // Identity matrix gives clip-space frustum: [-1,1]^3 (or [0,1] for z)
-    // The origin should be inside
-    REQUIRE(f.containsPoint(glm::vec3(0.0f, 0.0f, 0.5f)));
-}
-
-TEST_CASE("Frustum containsPoint perspective", "[frustum]") {
-    // Create a typical perspective projection and look-at
-    glm::mat4 proj = glm::perspective(glm::radians(90.0f), 1.0f, 0.1f, 100.0f);
-    glm::mat4 view = glm::lookAt(
-        glm::vec3(0, 0, 0),   // eye
-        glm::vec3(0, 0, -1),  // center (looking -Z)
-        glm::vec3(0, 1, 0)    // up
-    );
-    glm::mat4 vp = proj * view;
-
-    Frustum f;
-    f.extractFromMatrix(vp);
-
-    // Point in front (at -Z)
-    REQUIRE(f.containsPoint(glm::vec3(0, 0, -10)));
-
-    // Point behind camera (at +Z) should be outside
-    REQUIRE_FALSE(f.containsPoint(glm::vec3(0, 0, 10)));
-
-    // Point very far away inside the frustum
-    REQUIRE(f.containsPoint(glm::vec3(0, 0, -50)));
-
-    // Point beyond far plane
-    REQUIRE_FALSE(f.containsPoint(glm::vec3(0, 0, -200)));
-}
-
-TEST_CASE("Frustum intersectsSphere", "[frustum]") {
-    glm::mat4 proj = glm::perspective(glm::radians(60.0f), 1.0f, 1.0f, 100.0f);
-    glm::mat4 view = glm::lookAt(
-        glm::vec3(0, 0, 0),
-        glm::vec3(0, 0, -1),
-        glm::vec3(0, 1, 0)
-    );
-    Frustum f;
-    f.extractFromMatrix(proj * view);
-
-    // Sphere clearly inside
-    REQUIRE(f.intersectsSphere(glm::vec3(0, 0, -10), 1.0f));
-
-    // Sphere behind camera
-    REQUIRE_FALSE(f.intersectsSphere(glm::vec3(0, 0, 50), 1.0f));
-
-    // Large sphere that straddles the near plane
-    REQUIRE(f.intersectsSphere(glm::vec3(0, 0, 0), 5.0f));
-
-    // Sphere at edge of frustum — large radius should still intersect
-    REQUIRE(f.intersectsSphere(glm::vec3(0, 0, -105), 10.0f));
-}
-
-TEST_CASE("Frustum intersectsAABB", "[frustum]") {
-    glm::mat4 proj = glm::perspective(glm::radians(60.0f), 1.0f, 1.0f, 100.0f);
-    glm::mat4 view = glm::lookAt(
-        glm::vec3(0, 0, 0),
-        glm::vec3(0, 0, -1),
-        glm::vec3(0, 1, 0)
-    );
-    Frustum f;
-    f.extractFromMatrix(proj * view);
-
-    // Box inside frustum
-    REQUIRE(f.intersectsAABB(glm::vec3(-1, -1, -11), glm::vec3(1, 1, -9)));
-
-    // Box behind camera
-    REQUIRE_FALSE(f.intersectsAABB(glm::vec3(-1, -1, 5), glm::vec3(1, 1, 10)));
-
-    // Box beyond far plane
-    REQUIRE_FALSE(f.intersectsAABB(glm::vec3(-1, -1, -200), glm::vec3(1, 1, -150)));
-
-    // Large box straddling near/far
-    REQUIRE(f.intersectsAABB(glm::vec3(-5, -5, -50), glm::vec3(5, 5, 0)));
-}
-
-TEST_CASE("Frustum getPlane returns 6 planes", "[frustum]") {
-    glm::mat4 proj = glm::perspective(glm::radians(90.0f), 1.0f, 1.0f, 100.0f);
-    Frustum f;
-    f.extractFromMatrix(proj);
-
-    // Access all 6 planes — should not crash
-    for (int i = 0; i < 6; ++i) {
-        const auto& p = f.getPlane(static_cast<Frustum::Side>(i));
-        // Normal should be a unit vector (after normalization)
-        float len = glm::length(p.normal);
-        REQUIRE(len == Catch::Approx(1.0f).margin(0.01f));
-    }
-}
-
-TEST_CASE("Frustum box far right is outside", "[frustum]") {
-    glm::mat4 proj = glm::perspective(glm::radians(45.0f), 1.0f, 1.0f, 100.0f);
-    glm::mat4 view = glm::lookAt(
-        glm::vec3(0, 0, 0),
-        glm::vec3(0, 0, -1),
-        glm::vec3(0, 1, 0)
-    );
-    Frustum f;
-    f.extractFromMatrix(proj * view);
-
-    // Box far off to the right — outside the frustum
-    REQUIRE_FALSE(f.intersectsAABB(glm::vec3(200, 0, -10), glm::vec3(201, 1, -9)));
-}
diff --git a/tests/test_locomotion_fsm.cpp b/tests/test_locomotion_fsm.cpp
deleted file mode 100644
index 07e6cbd8..00000000
--- a/tests/test_locomotion_fsm.cpp
+++ /dev/null
@@ -1,167 +0,0 @@
-// LocomotionFSM unit tests
-#include <catch_amalgamated.hpp>
-#include "rendering/animation/locomotion_fsm.hpp"
-#include "rendering/animation/animation_ids.hpp"
-
-using namespace wowee::rendering;
-namespace anim = wowee::rendering::anim;
-
-// Helper: create a capability set with basic locomotion resolved
-static AnimCapabilitySet makeLocoCaps() {
-    AnimCapabilitySet caps;
-    caps.resolvedStand = anim::STAND;
-    caps.resolvedWalk = anim::WALK;
-    caps.resolvedRun = anim::RUN;
-    caps.resolvedSprint = anim::SPRINT;
-    caps.resolvedWalkBackwards = anim::WALK_BACKWARDS;
-    caps.resolvedStrafeLeft = anim::SHUFFLE_LEFT;
-    caps.resolvedStrafeRight = anim::SHUFFLE_RIGHT;
-    caps.resolvedJumpStart = anim::JUMP_START;
-    caps.resolvedJump = anim::JUMP;
-    caps.resolvedJumpEnd = anim::JUMP_END;
-    caps.resolvedSwimIdle = anim::SWIM_IDLE;
-    caps.resolvedSwim = anim::SWIM;
-    caps.hasStand = true;
-    caps.hasWalk = true;
-    caps.hasRun = true;
-    caps.hasSprint = true;
-    caps.hasWalkBackwards = true;
-    caps.hasJump = true;
-    caps.hasSwim = true;
-    return caps;
-}
-
-static LocomotionFSM::Input idle() {
-    LocomotionFSM::Input in;
-    in.deltaTime = 0.016f;
-    return in;
-}
-
-TEST_CASE("LocomotionFSM: IDLE → WALK on move start (non-sprinting)", "[locomotion]") {
-    LocomotionFSM fsm;
-    auto caps = makeLocoCaps();
-
-    auto in = idle();
-    in.moving = true;
-    auto out = fsm.resolve(in, caps);
-
-    REQUIRE(out.valid);
-    REQUIRE(out.animId == anim::WALK);
-    REQUIRE(out.loop == true);
-    CHECK(fsm.getState() == LocomotionFSM::State::WALK);
-}
-
-TEST_CASE("LocomotionFSM: IDLE → RUN on move start (sprinting)", "[locomotion]") {
-    LocomotionFSM fsm;
-    auto caps = makeLocoCaps();
-
-    auto in = idle();
-    in.moving = true;
-    in.sprinting = true;
-    auto out = fsm.resolve(in, caps);
-
-    REQUIRE(out.valid);
-    REQUIRE(out.animId == anim::RUN);
-    CHECK(fsm.getState() == LocomotionFSM::State::RUN);
-}
-
-TEST_CASE("LocomotionFSM: WALK → IDLE on move stop (after grace)", "[locomotion]") {
-    LocomotionFSM fsm;
-    auto caps = makeLocoCaps();
-
-    // Start walking
-    auto in = idle();
-    in.moving = true;
-    fsm.resolve(in, caps);
-    CHECK(fsm.getState() == LocomotionFSM::State::WALK);
-
-    // Stop moving — grace timer keeps walk for a bit
-    in.moving = false;
-    in.deltaTime = 0.2f; // > grace period (0.12s)
-    auto out = fsm.resolve(in, caps);
-
-    CHECK(fsm.getState() == LocomotionFSM::State::IDLE);
-}
-
-TEST_CASE("LocomotionFSM: WALK → JUMP_START on jump", "[locomotion]") {
-    LocomotionFSM fsm;
-    auto caps = makeLocoCaps();
-
-    // Start walking
-    auto in = idle();
-    in.moving = true;
-    fsm.resolve(in, caps);
-
-    // Jump
-    in.jumping = true;
-    in.grounded = false;
-    auto out = fsm.resolve(in, caps);
-
-    REQUIRE(out.valid);
-    REQUIRE(out.animId == anim::JUMP_START);
-    CHECK(fsm.getState() == LocomotionFSM::State::JUMP_START);
-}
-
-TEST_CASE("LocomotionFSM: SWIM_IDLE → SWIM on move start while swimming", "[locomotion]") {
-    LocomotionFSM fsm;
-    auto caps = makeLocoCaps();
-
-    // Enter swim idle
-    auto in = idle();
-    in.swimming = true;
-    fsm.resolve(in, caps);
-    CHECK(fsm.getState() == LocomotionFSM::State::SWIM_IDLE);
-
-    // Start swimming
-    in.moving = true;
-    auto out = fsm.resolve(in, caps);
-
-    REQUIRE(out.valid);
-    REQUIRE(out.animId == anim::SWIM);
-    CHECK(fsm.getState() == LocomotionFSM::State::SWIM);
-}
-
-TEST_CASE("LocomotionFSM: backward walking resolves WALK_BACKWARDS", "[locomotion]") {
-    LocomotionFSM fsm;
-    auto caps = makeLocoCaps();
-
-    auto in = idle();
-    in.moving = true;
-    in.movingBackward = true;
-    auto out = fsm.resolve(in, caps);
-
-    REQUIRE(out.valid);
-    // Should use WALK_BACKWARDS when available
-    CHECK(out.animId == anim::WALK_BACKWARDS);
-}
-
-TEST_CASE("LocomotionFSM: STAY when WALK_BACKWARDS missing from caps", "[locomotion]") {
-    LocomotionFSM fsm;
-    AnimCapabilitySet caps;
-    caps.resolvedStand = anim::STAND;
-    caps.resolvedWalk = anim::WALK;
-    caps.hasStand = true;
-    caps.hasWalk = true;
-    // No WALK_BACKWARDS in caps
-
-    auto in = idle();
-    in.moving = true;
-    in.movingBackward = true;
-    auto out = fsm.resolve(in, caps);
-
-    // Should still resolve something — falls back to walk
-    REQUIRE(out.valid);
-}
-
-TEST_CASE("LocomotionFSM: reset restores IDLE", "[locomotion]") {
-    LocomotionFSM fsm;
-    auto caps = makeLocoCaps();
-
-    auto in = idle();
-    in.moving = true;
-    fsm.resolve(in, caps);
-    CHECK(fsm.getState() == LocomotionFSM::State::WALK);
-
-    fsm.reset();
-    CHECK(fsm.getState() == LocomotionFSM::State::IDLE);
-}
diff --git a/tests/test_m2_structs.cpp b/tests/test_m2_structs.cpp
deleted file mode 100644
index 236861e0..00000000
--- a/tests/test_m2_structs.cpp
+++ /dev/null
@@ -1,164 +0,0 @@
-// M2 struct layout and field tests (header-only, no loader source)
-#include <catch_amalgamated.hpp>
-#include "pipeline/m2_loader.hpp"
-#include <cstring>
-
-using namespace wowee::pipeline;
-
-TEST_CASE("M2Sequence fields are default-initialized", "[m2]") {
-    M2Sequence seq{};
-    REQUIRE(seq.id == 0);
-    REQUIRE(seq.duration == 0);
-    REQUIRE(seq.movingSpeed == 0.0f);
-    REQUIRE(seq.flags == 0);
-    REQUIRE(seq.blendTime == 0);
-    REQUIRE(seq.boundRadius == 0.0f);
-}
-
-TEST_CASE("M2AnimationTrack hasData", "[m2]") {
-    M2AnimationTrack track;
-    REQUIRE_FALSE(track.hasData());
-
-    track.sequences.push_back({});
-    REQUIRE(track.hasData());
-}
-
-TEST_CASE("M2AnimationTrack default interpolation", "[m2]") {
-    M2AnimationTrack track;
-    REQUIRE(track.interpolationType == 0);
-    REQUIRE(track.globalSequence == -1);
-}
-
-TEST_CASE("M2Bone parent defaults to root", "[m2]") {
-    M2Bone bone{};
-    bone.parentBone = -1;
-    REQUIRE(bone.parentBone == -1);
-    REQUIRE(bone.keyBoneId == 0);
-}
-
-TEST_CASE("M2Vertex layout", "[m2]") {
-    M2Vertex vert{};
-    vert.position = glm::vec3(1.0f, 2.0f, 3.0f);
-    vert.boneWeights[0] = 255;
-    vert.boneWeights[1] = 0;
-    vert.boneWeights[2] = 0;
-    vert.boneWeights[3] = 0;
-    vert.boneIndices[0] = 5;
-    vert.normal = glm::vec3(0.0f, 1.0f, 0.0f);
-    vert.texCoords[0] = glm::vec2(0.5f, 0.5f);
-
-    REQUIRE(vert.position.x == 1.0f);
-    REQUIRE(vert.boneWeights[0] == 255);
-    REQUIRE(vert.boneIndices[0] == 5);
-    REQUIRE(vert.normal.y == 1.0f);
-    REQUIRE(vert.texCoords[0].x == 0.5f);
-}
-
-TEST_CASE("M2Texture stores filename", "[m2]") {
-    M2Texture tex{};
-    tex.type = 1;
-    tex.filename = "Creature\\Hogger\\Hogger.blp";
-    REQUIRE(tex.filename == "Creature\\Hogger\\Hogger.blp");
-}
-
-TEST_CASE("M2Batch submesh fields", "[m2]") {
-    M2Batch batch{};
-    batch.skinSectionIndex = 3;
-    batch.textureCount = 2;
-    batch.indexStart = 100;
-    batch.indexCount = 300;
-    batch.vertexStart = 0;
-    batch.vertexCount = 150;
-    batch.submeshId = 0;
-    batch.submeshLevel = 0;
-
-    REQUIRE(batch.skinSectionIndex == 3);
-    REQUIRE(batch.textureCount == 2);
-    REQUIRE(batch.indexCount == 300);
-    REQUIRE(batch.vertexCount == 150);
-}
-
-TEST_CASE("M2Material blend modes", "[m2]") {
-    M2Material mat{};
-    mat.flags = 0;
-    mat.blendMode = 2;  // Alpha blend
-    REQUIRE(mat.blendMode == 2);
-
-    mat.blendMode = 0;  // Opaque
-    REQUIRE(mat.blendMode == 0);
-}
-
-TEST_CASE("M2Model isValid", "[m2]") {
-    M2Model model{};
-    REQUIRE_FALSE(model.isValid()); // no vertices or indices
-
-    model.vertices.push_back({});
-    REQUIRE_FALSE(model.isValid()); // vertices but no indices
-
-    model.indices.push_back(0);
-    REQUIRE(model.isValid()); // both present
-}
-
-TEST_CASE("M2Model bounding box", "[m2]") {
-    M2Model model{};
-    model.boundMin = glm::vec3(-1.0f, -2.0f, -3.0f);
-    model.boundMax = glm::vec3(1.0f, 2.0f, 3.0f);
-    model.boundRadius = 5.0f;
-
-    glm::vec3 center = (model.boundMin + model.boundMax) * 0.5f;
-    REQUIRE(center.x == Catch::Approx(0.0f));
-    REQUIRE(center.y == Catch::Approx(0.0f));
-    REQUIRE(center.z == Catch::Approx(0.0f));
-}
-
-TEST_CASE("M2ParticleEmitter defaults", "[m2]") {
-    M2ParticleEmitter emitter{};
-    emitter.textureRows = 1;
-    emitter.textureCols = 1;
-    emitter.enabled = true;
-    REQUIRE(emitter.textureRows == 1);
-    REQUIRE(emitter.textureCols == 1);
-    REQUIRE(emitter.enabled);
-}
-
-TEST_CASE("M2RibbonEmitter defaults", "[m2]") {
-    M2RibbonEmitter ribbon{};
-    REQUIRE(ribbon.edgesPerSecond == Catch::Approx(15.0f));
-    REQUIRE(ribbon.edgeLifetime == Catch::Approx(0.5f));
-    REQUIRE(ribbon.gravity == Catch::Approx(0.0f));
-}
-
-TEST_CASE("M2Attachment position", "[m2]") {
-    M2Attachment att{};
-    att.id = 1;  // Right hand
-    att.bone = 42;
-    att.position = glm::vec3(0.1f, 0.2f, 0.3f);
-
-    REQUIRE(att.id == 1);
-    REQUIRE(att.bone == 42);
-    REQUIRE(att.position.z == Catch::Approx(0.3f));
-}
-
-TEST_CASE("M2Model collections", "[m2]") {
-    M2Model model{};
-
-    // Bones
-    model.bones.push_back({});
-    model.bones[0].parentBone = -1;
-    model.bones[0].pivot = glm::vec3(0, 0, 0);
-
-    // Sequences
-    model.sequences.push_back({});
-    model.sequences[0].id = 0; // Stand
-    model.sequences[0].duration = 1000;
-
-    // Textures
-    model.textures.push_back({});
-    model.textures[0].type = 0;
-    model.textures[0].filename = "test.blp";
-
-    REQUIRE(model.bones.size() == 1);
-    REQUIRE(model.sequences.size() == 1);
-    REQUIRE(model.textures.size() == 1);
-    REQUIRE(model.sequences[0].duration == 1000);
-}
diff --git a/tests/test_opcode_table.cpp b/tests/test_opcode_table.cpp
deleted file mode 100644
index ce2a1cac..00000000
--- a/tests/test_opcode_table.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-// OpcodeTable load from JSON, toWire/fromWire mapping
-#include <catch_amalgamated.hpp>
-#include "game/opcode_table.hpp"
-#include <fstream>
-#include <filesystem>
-#include <cstdio>
-
-using wowee::game::OpcodeTable;
-using wowee::game::LogicalOpcode;
-
-// Helper: write a temporary JSON file and return its path.
-// Uses the executable's directory to avoid permission issues.
-static std::string writeTempJson(const std::string& content) {
-    auto path = std::filesystem::temp_directory_path() / "wowee_test_opcodes.json";
-    std::ofstream f(path);
-    f << content;
-    f.close();
-    return path.string();
-}
-
-TEST_CASE("OpcodeTable loadFromJson basic mapping", "[opcode_table]") {
-    // CMSG_PING and SMSG_PONG are canonical opcodes present in the generated enum.
-    std::string json = R"({
-        "CMSG_PING": "0x1DC",
-        "SMSG_PONG": "0x1DD"
-    })";
-    auto path = writeTempJson(json);
-
-    OpcodeTable table;
-    REQUIRE(table.loadFromJson(path));
-
-    REQUIRE(table.size() == 2);
-    REQUIRE(table.hasOpcode(LogicalOpcode::CMSG_PING));
-    REQUIRE(table.toWire(LogicalOpcode::CMSG_PING) == 0x1DC);
-    REQUIRE(table.toWire(LogicalOpcode::SMSG_PONG) == 0x1DD);
-
-    std::remove(path.c_str());
-}
-
-TEST_CASE("OpcodeTable fromWire reverse lookup", "[opcode_table]") {
-    std::string json = R"({ "CMSG_PING": "0x1DC" })";
-    auto path = writeTempJson(json);
-
-    OpcodeTable table;
-    table.loadFromJson(path);
-
-    auto result = table.fromWire(0x1DC);
-    REQUIRE(result.has_value());
-    REQUIRE(*result == LogicalOpcode::CMSG_PING);
-
-    std::remove(path.c_str());
-}
-
-TEST_CASE("OpcodeTable unknown wire returns nullopt", "[opcode_table]") {
-    std::string json = R"({ "CMSG_PING": "0x1DC" })";
-    auto path = writeTempJson(json);
-
-    OpcodeTable table;
-    table.loadFromJson(path);
-
-    auto result = table.fromWire(0x9999);
-    REQUIRE_FALSE(result.has_value());
-
-    std::remove(path.c_str());
-}
-
-TEST_CASE("OpcodeTable unknown logical returns 0xFFFF", "[opcode_table]") {
-    std::string json = R"({ "CMSG_PING": "0x1DC" })";
-    auto path = writeTempJson(json);
-
-    OpcodeTable table;
-    table.loadFromJson(path);
-
-    // SMSG_AUTH_CHALLENGE should not be in this table
-    REQUIRE(table.toWire(LogicalOpcode::SMSG_AUTH_CHALLENGE) == 0xFFFF);
-
-    std::remove(path.c_str());
-}
-
-TEST_CASE("OpcodeTable loadFromJson nonexistent file", "[opcode_table]") {
-    OpcodeTable table;
-    REQUIRE_FALSE(table.loadFromJson("/nonexistent/path/opcodes.json"));
-    REQUIRE(table.size() == 0);
-}
-
-TEST_CASE("OpcodeTable logicalToName returns enum name", "[opcode_table]") {
-    const char* name = OpcodeTable::logicalToName(LogicalOpcode::CMSG_PING);
-    REQUIRE(name != nullptr);
-    REQUIRE(std::string(name) == "CMSG_PING");
-}
-
-TEST_CASE("OpcodeTable decimal wire values", "[opcode_table]") {
-    std::string json = R"({ "CMSG_PING": "476" })";
-    auto path = writeTempJson(json);
-
-    OpcodeTable table;
-    REQUIRE(table.loadFromJson(path));
-    REQUIRE(table.toWire(LogicalOpcode::CMSG_PING) == 476);
-
-    std::remove(path.c_str());
-}
-
-TEST_CASE("Global active opcode table", "[opcode_table]") {
-    OpcodeTable table;
-    std::string json = R"({ "CMSG_PING": "0x1DC" })";
-    auto path = writeTempJson(json);
-    table.loadFromJson(path);
-
-    wowee::game::setActiveOpcodeTable(&table);
-    REQUIRE(wowee::game::getActiveOpcodeTable() == &table);
-    REQUIRE(wowee::game::wireOpcode(LogicalOpcode::CMSG_PING) == 0x1DC);
-
-    // Reset
-    wowee::game::setActiveOpcodeTable(nullptr);
-    REQUIRE(wowee::game::wireOpcode(LogicalOpcode::CMSG_PING) == 0xFFFF);
-
-    std::remove(path.c_str());
-}
diff --git a/tests/test_packet.cpp b/tests/test_packet.cpp
deleted file mode 100644
index d8899ec1..00000000
--- a/tests/test_packet.cpp
+++ /dev/null
@@ -1,192 +0,0 @@
-// Packet read/write round-trip, packed GUID, bounds checks
-#include <catch_amalgamated.hpp>
-#include "network/packet.hpp"
-
-using wowee::network::Packet;
-
-TEST_CASE("Packet default constructor", "[packet]") {
-    Packet p;
-    REQUIRE(p.getOpcode() == 0);
-    REQUIRE(p.getSize() == 0);
-    REQUIRE(p.getReadPos() == 0);
-    REQUIRE(p.getRemainingSize() == 0);
-    REQUIRE_FALSE(p.hasData());
-}
-
-TEST_CASE("Packet opcode constructor", "[packet]") {
-    Packet p(0x1DC);
-    REQUIRE(p.getOpcode() == 0x1DC);
-    REQUIRE(p.getSize() == 0);
-}
-
-TEST_CASE("Packet write/read UInt8 round-trip", "[packet]") {
-    Packet p(1);
-    p.writeUInt8(0);
-    p.writeUInt8(127);
-    p.writeUInt8(255);
-    REQUIRE(p.getSize() == 3);
-
-    REQUIRE(p.readUInt8() == 0);
-    REQUIRE(p.readUInt8() == 127);
-    REQUIRE(p.readUInt8() == 255);
-    REQUIRE_FALSE(p.hasData());
-}
-
-TEST_CASE("Packet write/read UInt16 round-trip", "[packet]") {
-    Packet p(1);
-    p.writeUInt16(0);
-    p.writeUInt16(0xBEEF);
-    p.writeUInt16(0xFFFF);
-    REQUIRE(p.getSize() == 6);
-
-    REQUIRE(p.readUInt16() == 0);
-    REQUIRE(p.readUInt16() == 0xBEEF);
-    REQUIRE(p.readUInt16() == 0xFFFF);
-}
-
-TEST_CASE("Packet write/read UInt32 round-trip", "[packet]") {
-    Packet p(1);
-    p.writeUInt32(0xDEADBEEF);
-    REQUIRE(p.readUInt32() == 0xDEADBEEF);
-}
-
-TEST_CASE("Packet write/read UInt64 round-trip", "[packet]") {
-    Packet p(1);
-    p.writeUInt64(0x0123456789ABCDEFULL);
-    REQUIRE(p.readUInt64() == 0x0123456789ABCDEFULL);
-}
-
-TEST_CASE("Packet write/read float round-trip", "[packet]") {
-    Packet p(1);
-    p.writeFloat(3.14f);
-    p.writeFloat(-0.0f);
-    p.writeFloat(1e10f);
-    REQUIRE(p.readFloat() == Catch::Approx(3.14f));
-    REQUIRE(p.readFloat() == -0.0f);
-    REQUIRE(p.readFloat() == Catch::Approx(1e10f));
-}
-
-TEST_CASE("Packet write/read string round-trip", "[packet]") {
-    Packet p(1);
-    p.writeString("Hello WoW");
-    p.writeString("");  // empty string
-    REQUIRE(p.readString() == "Hello WoW");
-    REQUIRE(p.readString() == "");
-}
-
-TEST_CASE("Packet writeBytes / readUInt8 array", "[packet]") {
-    Packet p(1);
-    const uint8_t buf[] = {0xAA, 0xBB, 0xCC};
-    p.writeBytes(buf, 3);
-    REQUIRE(p.getSize() == 3);
-    REQUIRE(p.readUInt8() == 0xAA);
-    REQUIRE(p.readUInt8() == 0xBB);
-    REQUIRE(p.readUInt8() == 0xCC);
-}
-
-TEST_CASE("Packet packed GUID round-trip", "[packet]") {
-    SECTION("Zero GUID") {
-        Packet p(1);
-        p.writePackedGuid(0);
-        REQUIRE(p.hasFullPackedGuid());
-        REQUIRE(p.readPackedGuid() == 0);
-    }
-
-    SECTION("Low GUID (single byte)") {
-        Packet p(1);
-        p.writePackedGuid(0x42);
-        REQUIRE(p.readPackedGuid() == 0x42);
-    }
-
-    SECTION("Full 64-bit GUID") {
-        Packet p(1);
-        uint64_t guid = 0x0102030405060708ULL;
-        p.writePackedGuid(guid);
-        REQUIRE(p.readPackedGuid() == guid);
-    }
-
-    SECTION("Max GUID") {
-        Packet p(1);
-        uint64_t guid = 0xFFFFFFFFFFFFFFFFULL;
-        p.writePackedGuid(guid);
-        REQUIRE(p.readPackedGuid() == guid);
-    }
-}
-
-TEST_CASE("Packet getRemainingSize and hasRemaining", "[packet]") {
-    Packet p(1);
-    p.writeUInt32(100);
-    p.writeUInt32(200);
-    REQUIRE(p.getRemainingSize() == 8);
-    REQUIRE(p.hasRemaining(8));
-    REQUIRE_FALSE(p.hasRemaining(9));
-
-    p.readUInt32();
-    REQUIRE(p.getRemainingSize() == 4);
-    REQUIRE(p.hasRemaining(4));
-    REQUIRE_FALSE(p.hasRemaining(5));
-
-    p.readUInt32();
-    REQUIRE(p.getRemainingSize() == 0);
-    REQUIRE(p.hasRemaining(0));
-    REQUIRE_FALSE(p.hasRemaining(1));
-}
-
-TEST_CASE("Packet setReadPos and skipAll", "[packet]") {
-    Packet p(1);
-    p.writeUInt8(10);
-    p.writeUInt8(20);
-    p.writeUInt8(30);
-
-    p.readUInt8(); // pos = 1
-    p.setReadPos(0);
-    REQUIRE(p.readUInt8() == 10);
-
-    p.skipAll();
-    REQUIRE(p.getRemainingSize() == 0);
-    REQUIRE_FALSE(p.hasData());
-}
-
-TEST_CASE("Packet constructed with data vector", "[packet]") {
-    std::vector<uint8_t> raw = {0x01, 0x02, 0x03};
-    Packet p(42, raw);
-    REQUIRE(p.getOpcode() == 42);
-    REQUIRE(p.getSize() == 3);
-    REQUIRE(p.readUInt8() == 0x01);
-}
-
-TEST_CASE("Packet constructed with rvalue data", "[packet]") {
-    Packet p(99, std::vector<uint8_t>{0xFF, 0xFE});
-    REQUIRE(p.getSize() == 2);
-    REQUIRE(p.readUInt8() == 0xFF);
-    REQUIRE(p.readUInt8() == 0xFE);
-}
-
-TEST_CASE("Packet mixed types interleaved", "[packet]") {
-    Packet p(1);
-    p.writeUInt8(0xAA);
-    p.writeUInt32(0xDEADBEEF);
-    p.writeString("test");
-    p.writeFloat(2.5f);
-    p.writeUInt16(0x1234);
-
-    REQUIRE(p.readUInt8() == 0xAA);
-    REQUIRE(p.readUInt32() == 0xDEADBEEF);
-    REQUIRE(p.readString() == "test");
-    REQUIRE(p.readFloat() == Catch::Approx(2.5f));
-    REQUIRE(p.readUInt16() == 0x1234);
-    REQUIRE_FALSE(p.hasData());
-}
-
-TEST_CASE("Packet hasFullPackedGuid returns false on empty", "[packet]") {
-    Packet p(1);
-    REQUIRE_FALSE(p.hasFullPackedGuid());
-}
-
-TEST_CASE("Packet getRemainingSize clamps after overshoot", "[packet]") {
-    Packet p(1);
-    p.writeUInt8(1);
-    p.setReadPos(999);
-    REQUIRE(p.getRemainingSize() == 0);
-    REQUIRE_FALSE(p.hasRemaining(1));
-}
diff --git a/tests/test_srp.cpp b/tests/test_srp.cpp
deleted file mode 100644
index 019faf5f..00000000
--- a/tests/test_srp.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-// SRP6a challenge/proof smoke tests
-#include <catch_amalgamated.hpp>
-#include "auth/srp.hpp"
-#include "auth/crypto.hpp"
-
-using wowee::auth::SRP;
-using wowee::auth::Crypto;
-
-// WoW 3.3.5a uses well-known SRP6a parameters.
-// Generator g = 7, N = a large 32-byte safe prime.
-// We use the canonical WoW values for integration-level tests.
-
-static const std::vector<uint8_t> kWoWGenerator = { 7 };
-
-// WoW's 32-byte large safe prime (little-endian)
-static const std::vector<uint8_t> kWoWPrime = {
-    0xB7, 0x9B, 0x3E, 0x2A, 0x87, 0x82, 0x3C, 0xAB,
-    0x8F, 0x5E, 0xBF, 0xBF, 0x8E, 0xB1, 0x01, 0x08,
-    0x53, 0x50, 0x06, 0x29, 0x8B, 0x5B, 0xAD, 0xBD,
-    0x5B, 0x53, 0xE1, 0x89, 0x5E, 0x64, 0x4B, 0x89
-};
-
-TEST_CASE("SRP initialize stores credentials", "[srp]") {
-    SRP srp;
-    // Should not throw
-    REQUIRE_NOTHROW(srp.initialize("TEST", "PASSWORD"));
-}
-
-TEST_CASE("SRP initializeWithHash accepts pre-computed hash", "[srp]") {
-    // Pre-compute SHA1("TEST:PASSWORD")
-    auto hash = Crypto::sha1(std::string("TEST:PASSWORD"));
-    REQUIRE(hash.size() == 20);
-
-    SRP srp;
-    REQUIRE_NOTHROW(srp.initializeWithHash("TEST", hash));
-}
-
-TEST_CASE("SRP feed produces A and M1 of correct sizes", "[srp]") {
-    SRP srp;
-    srp.initialize("TEST", "PASSWORD");
-
-    // Fabricate a server B (32 bytes, non-zero to avoid SRP abort)
-    std::vector<uint8_t> B(32, 0);
-    B[0] = 0x42; // Non-zero
-
-    std::vector<uint8_t> salt(32, 0xAA);
-
-    srp.feed(B, kWoWGenerator, kWoWPrime, salt);
-
-    auto A = srp.getA();
-    auto M1 = srp.getM1();
-    auto K = srp.getSessionKey();
-
-    // A should be 32 bytes (same size as N)
-    REQUIRE(A.size() == 32);
-    // M1 is SHA1 → 20 bytes
-    REQUIRE(M1.size() == 20);
-    // K is the interleaved session key → 40 bytes
-    REQUIRE(K.size() == 40);
-}
-
-TEST_CASE("SRP A is non-zero", "[srp]") {
-    SRP srp;
-    srp.initialize("PLAYER", "SECRET");
-
-    std::vector<uint8_t> B(32, 0);
-    B[3] = 0x01;
-    std::vector<uint8_t> salt(32, 0xBB);
-
-    srp.feed(B, kWoWGenerator, kWoWPrime, salt);
-
-    auto A = srp.getA();
-    bool allZero = true;
-    for (auto b : A) {
-        if (b != 0) { allZero = false; break; }
-    }
-    REQUIRE_FALSE(allZero);
-}
-
-TEST_CASE("SRP different passwords produce different M1", "[srp]") {
-    auto runSrp = [](const std::string& pass) {
-        SRP srp;
-        srp.initialize("TESTUSER", pass);
-        std::vector<uint8_t> B(32, 0);
-        B[0] = 0x11;
-        std::vector<uint8_t> salt(32, 0xCC);
-        srp.feed(B, kWoWGenerator, kWoWPrime, salt);
-        return srp.getM1();
-    };
-
-    auto m1a = runSrp("PASSWORD1");
-    auto m1b = runSrp("PASSWORD2");
-    REQUIRE(m1a != m1b);
-}
-
-TEST_CASE("SRP verifyServerProof rejects wrong proof", "[srp]") {
-    SRP srp;
-    srp.initialize("TEST", "PASSWORD");
-
-    std::vector<uint8_t> B(32, 0);
-    B[0] = 0x55;
-    std::vector<uint8_t> salt(32, 0xDD);
-
-    srp.feed(B, kWoWGenerator, kWoWPrime, salt);
-
-    // Random 20 bytes should not match the expected M2
-    std::vector<uint8_t> fakeM2(20, 0xFF);
-    REQUIRE_FALSE(srp.verifyServerProof(fakeM2));
-}
-
-TEST_CASE("SRP setUseHashedK changes behavior", "[srp]") {
-    auto runWithHashedK = [](bool useHashed) {
-        SRP srp;
-        srp.setUseHashedK(useHashed);
-        srp.initialize("TEST", "PASSWORD");
-        std::vector<uint8_t> B(32, 0);
-        B[0] = 0x22;
-        std::vector<uint8_t> salt(32, 0xEE);
-        srp.feed(B, kWoWGenerator, kWoWPrime, salt);
-        return srp.getM1();
-    };
-
-    auto m1_default = runWithHashedK(false);
-    auto m1_hashed = runWithHashedK(true);
-    // Different k derivation → different M1
-    REQUIRE(m1_default != m1_hashed);
-}
diff --git a/tools/asset_extract/extractor.cpp b/tools/asset_extract/extractor.cpp
index 0612c6fa..615b43b9 100644
--- a/tools/asset_extract/extractor.cpp
+++ b/tools/asset_extract/extractor.cpp
@@ -14,6 +14,7 @@
 #include <iostream>
 #include <mutex>
 #include <set>
+#include <sstream>
 #include <thread>
 #include <unordered_map>
 #include <unordered_set>
@@ -31,6 +32,12 @@ namespace tools {
 namespace fs = std::filesystem;
 using wowee::pipeline::DBCFile;
 
+// Archive descriptor for priority-based loading
+struct ArchiveDesc {
+    std::string path;
+    int priority;
+};
+
 static std::string toLowerStr(std::string s) {
     std::transform(s.begin(), s.end(), s.begin(),
                    [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
@@ -69,29 +76,8 @@ static std::vector<uint8_t> readFileBytes(const std::string& path) {
     return buf;
 }
 
-// Precompute the set of valid string-boundary offsets in the string block.
-// An offset is a valid boundary if it is 0 or immediately follows a null byte.
-// This prevents small integer values (e.g. RaceID=1, 2, 3) from being falsely
-// detected as string offsets just because they land in the middle of a longer
-// string that starts at a lower offset.
-static std::set<uint32_t> computeStringBoundaries(const std::vector<uint8_t>& stringBlock) {
-    std::set<uint32_t> boundaries;
-    if (stringBlock.empty()) return boundaries;
-    boundaries.insert(0);
-    for (size_t i = 0; i + 1 < stringBlock.size(); ++i) {
-        if (stringBlock[i] == 0) {
-            boundaries.insert(static_cast<uint32_t>(i + 1));
-        }
-    }
-    return boundaries;
-}
-
-static bool isValidStringOffset(const std::vector<uint8_t>& stringBlock,
-                                const std::set<uint32_t>& boundaries,
-                                uint32_t offset) {
+static bool isValidStringOffset(const std::vector<uint8_t>& stringBlock, uint32_t offset) {
     if (offset >= stringBlock.size()) return false;
-    // Must start at a string boundary (offset 0 or right after a null byte).
-    if (!boundaries.count(offset)) return false;
     for (size_t i = offset; i < stringBlock.size(); ++i) {
         uint8_t c = stringBlock[i];
         if (c == 0) return true;
@@ -119,33 +105,21 @@ static std::set<uint32_t> detectStringColumns(const DBCFile& dbc,
     std::set<uint32_t> cols;
     if (stringBlock.size() <= 1) return cols;
 
-    auto boundaries = computeStringBoundaries(stringBlock);
-
     for (uint32_t col = 0; col < fieldCount; ++col) {
         bool allZeroOrValid = true;
         bool hasNonZero = false;
-        std::set<std::string> distinctStrings;
 
         for (uint32_t row = 0; row < recordCount; ++row) {
             uint32_t val = dbc.getUInt32(row, col);
             if (val == 0) continue;
             hasNonZero = true;
-            if (!isValidStringOffset(stringBlock, boundaries, val)) {
+            if (!isValidStringOffset(stringBlock, val)) {
                 allZeroOrValid = false;
                 break;
             }
-            // Collect distinct non-empty strings for diversity check.
-            const char* s = reinterpret_cast<const char*>(stringBlock.data() + val);
-            if (*s != '\0') {
-                distinctStrings.insert(std::string(s, strnlen(s, 256)));
-            }
         }
 
-        // Require at least 2 distinct non-empty string values.  Columns that
-        // only ever point to a single string (e.g. SexID=1 always resolves to
-        // the same path fragment at offset 1 in the block) are almost certainly
-        // integer fields whose small values accidentally land at a string boundary.
-        if (allZeroOrValid && hasNonZero && distinctStrings.size() >= 2) {
+        if (allZeroOrValid && hasNonZero) {
             cols.insert(col);
         }
     }
@@ -387,188 +361,153 @@ std::string Extractor::detectExpansion(const std::string& mpqDir) {
     return "";
 }
 
-static std::string findCaseInsensitiveDirectory(const std::string& parentDir,
-                                                   const std::string& directoryName) {
-    if (!fs::exists(parentDir) || !fs::is_directory(parentDir)) return "";
-    std::string lowerDirectoryName = toLowerStr(directoryName);
-    for (const auto& entry : fs::directory_iterator(parentDir)) {
-        if (!entry.is_directory()) continue;
-        std::string name = entry.path().filename().string();
-        if (toLowerStr(name) == lowerDirectoryName) {
-            return name;
-        }
-    }
-    return "";
-}
-
 std::string Extractor::detectLocale(const std::string& mpqDir) {
-    if (!fs::exists(mpqDir) || !fs::is_directory(mpqDir)) return "";
-    for (const auto& entry : fs::directory_iterator(mpqDir)) {
-        if (!entry.is_directory()) continue;
-        std::string name = entry.path().filename().string();
-        std::string lower = toLowerStr(name);
-        for (const auto& loc : kKnownLocales) {
-            if (toLowerStr(loc) == lower) {
-                return name;
-            }
-        }
+    for (const auto& loc : kKnownLocales) {
+        if (fs::is_directory(mpqDir + "/" + loc))
+            return loc;
     }
     return "";
 }
 
-static std::unordered_map<std::string, std::string> buildCaseMap(const std::string& dir) {
-    std::unordered_map<std::string, std::string> map;
-    if (!fs::exists(dir) || !fs::is_directory(dir)) return map;
-    for (const auto& entry : fs::directory_iterator(dir)) {
-        if (entry.is_regular_file()) {
-            std::string filename = entry.path().filename().string();
-            if (filename.rfind("._", 0) == 0) {
-                continue;
-            }
-            std::string ext = toLowerStr(entry.path().extension().string());
-            if (ext == ".mpq") {
-                std::string lower = toLowerStr(filename);
-                map[lower] = filename;
-            }
-        }
-    }
-    return map;
-}
-
 // Discover archive files with expansion-specific and locale-aware loading
-static std::vector<std::string> discoverArchives(const std::string& mpqDir,
+static std::vector<ArchiveDesc> discoverArchives(const std::string& mpqDir,
                                                   const std::string& expansion,
                                                   const std::string& locale) {
-    std::vector<std::string> result;
+    std::vector<ArchiveDesc> result;
 
-    auto caseMap = buildCaseMap(mpqDir);
-    std::string lowerLocale = toLowerStr(locale);
-    if (!locale.empty()) {
-        std::string actualLocaleDir = findCaseInsensitiveDirectory(mpqDir, locale);
-        if (actualLocaleDir.empty()) {
-            actualLocaleDir = locale;
-        }
-        fs::path localeDirPath = fs::path(mpqDir) / actualLocaleDir;
-        std::string localeDir = localeDirPath.string();
-        auto localeMap = buildCaseMap(localeDir);
-        for (auto& [name, realName] : localeMap) {
-            fs::path fullPath = fs::path(actualLocaleDir) / realName;
-            caseMap[lowerLocale + "/" + name] = fullPath.string();
-        }
-    }
-
-    std::vector<std::string> baseSequence;
-    std::vector<std::string> localeSequence;
-
-    if (expansion == "classic" || expansion == "turtle") {
-        baseSequence = {
-            "base.mpq", "backup.mpq", "dbc.mpq", "fonts.mpq",
-            "interface.mpq", "misc.mpq", "model.mpq", "sound.mpq",
-            "speech.mpq", "terrain.mpq", "texture.mpq", "wmo.mpq"
-        };
-    } else if (expansion == "tbc") {
-        baseSequence = { "common.mpq", "expansion.mpq" };
-        if (!locale.empty()) {
-            localeSequence = {
-                lowerLocale + "/backup-" + lowerLocale + ".mpq",
-                lowerLocale + "/base-" + lowerLocale + ".mpq",
-                lowerLocale + "/locale-" + lowerLocale + ".mpq",
-                lowerLocale + "/speech-" + lowerLocale + ".mpq",
-                lowerLocale + "/expansion-locale-" + lowerLocale + ".mpq",
-                lowerLocale + "/expansion-speech-" + lowerLocale + ".mpq",
-            };
-        }
-    } else {
-        baseSequence = { "common.mpq", "common-2.mpq", "expansion.mpq", "lichking.mpq" };
-        if (!locale.empty()) {
-            localeSequence = {
-                lowerLocale + "/backup-" + lowerLocale + ".mpq",
-                lowerLocale + "/base-" + lowerLocale + ".mpq",
-                lowerLocale + "/locale-" + lowerLocale + ".mpq",
-                lowerLocale + "/speech-" + lowerLocale + ".mpq",
-                lowerLocale + "/expansion-locale-" + lowerLocale + ".mpq",
-                lowerLocale + "/expansion-speech-" + lowerLocale + ".mpq",
-                lowerLocale + "/lichking-locale-" + lowerLocale + ".mpq",
-                lowerLocale + "/lichking-speech-" + lowerLocale + ".mpq",
-            };
-        }
-    }
-
-    std::vector<std::string> sequence;
-    for (const auto& name : baseSequence) {
-        sequence.push_back(name);
-    }
-    for (const auto& name : localeSequence) {
-        sequence.push_back(name);
-    }
-
-    // Interleave patches: base patch then locale patch for each tier
-    std::vector<std::string> patchSuffixes = {""};
-    for (int i = 2; i <= 9; ++i) {
-        patchSuffixes.push_back(std::string("-") + std::to_string(i));
-    }
-    for (char c = 'a'; c <= 'z'; ++c) {
-        patchSuffixes.push_back(std::string("-") + c);
-    }
-
-    for (const auto& suffix : patchSuffixes) {
-        sequence.push_back("patch" + suffix + ".mpq");
-        if (!locale.empty()) {
-            sequence.push_back(lowerLocale + "/patch-" + lowerLocale + suffix + ".mpq");
-        }
-    }
-
-    auto addIfPresent = [&](const std::string& expected) {
-        auto it = caseMap.find(toLowerStr(expected));
-        if (it != caseMap.end()) {
-            fs::path fullPath = fs::path(mpqDir) / it->second;
-            result.push_back(fullPath.string());
+    auto tryAdd = [&](const std::string& name, int prio) {
+        std::string fullPath = mpqDir + "/" + name;
+        if (fs::exists(fullPath)) {
+            result.push_back({fullPath, prio});
         }
     };
 
-    for (const auto& entry : sequence) {
-        addIfPresent(entry);
+    if (expansion == "classic" || expansion == "turtle") {
+        // Vanilla-era base archives (also used by Turtle WoW clients)
+        tryAdd("base.MPQ", 90);
+        tryAdd("base.mpq", 90);
+        tryAdd("backup.MPQ", 95);
+        tryAdd("backup.mpq", 95);
+        tryAdd("dbc.MPQ", 100);
+        tryAdd("dbc.mpq", 100);
+        tryAdd("fonts.MPQ", 100);
+        tryAdd("fonts.mpq", 100);
+        tryAdd("interface.MPQ", 100);
+        tryAdd("interface.mpq", 100);
+        tryAdd("misc.MPQ", 100);
+        tryAdd("misc.mpq", 100);
+        tryAdd("model.MPQ", 100);
+        tryAdd("model.mpq", 100);
+        tryAdd("sound.MPQ", 100);
+        tryAdd("sound.mpq", 100);
+        tryAdd("speech.MPQ", 100);
+        tryAdd("speech.mpq", 100);
+        tryAdd("terrain.MPQ", 100);
+        tryAdd("terrain.mpq", 100);
+        tryAdd("texture.MPQ", 100);
+        tryAdd("texture.mpq", 100);
+        tryAdd("wmo.MPQ", 100);
+        tryAdd("wmo.mpq", 100);
+
+        // Patches
+        tryAdd("patch.MPQ", 150);
+        tryAdd("patch.mpq", 150);
+        for (int i = 1; i <= 9; ++i) {
+            tryAdd("patch-" + std::to_string(i) + ".MPQ", 160 + (i * 10));
+            tryAdd("patch-" + std::to_string(i) + ".mpq", 160 + (i * 10));
+        }
+        // Turtle WoW uses letter patch MPQs (patch-a.mpq ... patch-z.mpq).
+        for (char c = 'a'; c <= 'z'; ++c) {
+            tryAdd(std::string("patch-") + c + ".mpq", 800 + (c - 'a'));
+            tryAdd(std::string("Patch-") + static_cast<char>(std::toupper(c)) + ".mpq", 900 + (c - 'a'));
+        }
+
+        // Locale
+        if (!locale.empty()) {
+            tryAdd(locale + "/base-" + locale + ".MPQ", 230);
+            tryAdd(locale + "/speech-" + locale + ".MPQ", 240);
+            tryAdd(locale + "/locale-" + locale + ".MPQ", 250);
+            tryAdd(locale + "/patch-" + locale + ".MPQ", 450);
+        }
+    } else if (expansion == "tbc") {
+        // TBC 2.4.x base archives
+        tryAdd("common.MPQ", 100);
+        tryAdd("common-2.MPQ", 100);
+        tryAdd("expansion.MPQ", 100);
+
+        // Patches
+        tryAdd("patch.MPQ", 150);
+        tryAdd("patch-2.MPQ", 200);
+        tryAdd("patch-3.MPQ", 300);
+        tryAdd("patch-4.MPQ", 400);
+        tryAdd("patch-5.MPQ", 500);
+
+        // Letter patches
+        for (char c = 'a'; c <= 'z'; ++c) {
+            tryAdd(std::string("patch-") + c + ".mpq", 800 + (c - 'a'));
+            tryAdd(std::string("Patch-") + static_cast<char>(std::toupper(c)) + ".mpq", 900 + (c - 'a'));
+        }
+
+        // Locale
+        if (!locale.empty()) {
+            tryAdd(locale + "/backup-" + locale + ".MPQ", 225);
+            tryAdd(locale + "/base-" + locale + ".MPQ", 230);
+            tryAdd(locale + "/speech-" + locale + ".MPQ", 240);
+            tryAdd(locale + "/expansion-speech-" + locale + ".MPQ", 245);
+            tryAdd(locale + "/expansion-locale-" + locale + ".MPQ", 246);
+            tryAdd(locale + "/locale-" + locale + ".MPQ", 250);
+            tryAdd(locale + "/patch-" + locale + ".MPQ", 450);
+            tryAdd(locale + "/patch-" + locale + "-2.MPQ", 460);
+            tryAdd(locale + "/patch-" + locale + "-3.MPQ", 470);
+        }
+    } else {
+        // WotLK 3.3.5a (default)
+        tryAdd("common.MPQ", 100);
+        tryAdd("common-2.MPQ", 100);
+        tryAdd("expansion.MPQ", 100);
+        tryAdd("lichking.MPQ", 100);
+
+        // Patches
+        tryAdd("patch.MPQ", 150);
+        tryAdd("patch-2.MPQ", 200);
+        tryAdd("patch-3.MPQ", 300);
+        tryAdd("patch-4.MPQ", 400);
+        tryAdd("patch-5.MPQ", 500);
+
+        // Letter patches
+        for (char c = 'a'; c <= 'z'; ++c) {
+            tryAdd(std::string("patch-") + c + ".mpq", 800 + (c - 'a'));
+            tryAdd(std::string("Patch-") + static_cast<char>(std::toupper(c)) + ".mpq", 900 + (c - 'a'));
+        }
+
+        // Locale
+        if (!locale.empty()) {
+            tryAdd(locale + "/backup-" + locale + ".MPQ", 225);
+            tryAdd(locale + "/base-" + locale + ".MPQ", 230);
+            tryAdd(locale + "/speech-" + locale + ".MPQ", 240);
+            tryAdd(locale + "/expansion-speech-" + locale + ".MPQ", 245);
+            tryAdd(locale + "/expansion-locale-" + locale + ".MPQ", 246);
+            tryAdd(locale + "/lichking-speech-" + locale + ".MPQ", 248);
+            tryAdd(locale + "/lichking-locale-" + locale + ".MPQ", 249);
+            tryAdd(locale + "/locale-" + locale + ".MPQ", 250);
+            tryAdd(locale + "/patch-" + locale + ".MPQ", 450);
+            tryAdd(locale + "/patch-" + locale + "-2.MPQ", 460);
+            tryAdd(locale + "/patch-" + locale + "-3.MPQ", 470);
+        }
     }
 
+    // Sort by priority so highest-priority archives are last
+    // (we'll iterate highest-prio first when extracting)
+    std::sort(result.begin(), result.end(),
+              [](const ArchiveDesc& a, const ArchiveDesc& b) { return a.priority < b.priority; });
+
     return result;
 }
 
-// Extract the (listfile) from an MPQ archive into a set of filenames
-static void extractInternalListfile(HANDLE hMpq, std::set<std::string>& out) {
-    HANDLE hFile = nullptr;
-    if (!SFileOpenFileEx(hMpq, "(listfile)", 0, &hFile)) return;
-
-    DWORD size = SFileGetFileSize(hFile, nullptr);
-    if (size == SFILE_INVALID_SIZE || size == 0) {
-        SFileCloseFile(hFile);
-        return;
-    }
-
-    std::vector<char> buf(size);
-    DWORD bytesRead = 0;
-    if (!SFileReadFile(hFile, buf.data(), size, &bytesRead, nullptr)) {
-        SFileCloseFile(hFile);
-        return;
-    }
-    SFileCloseFile(hFile);
-
-    // Parse newline/CR-delimited entries
-    std::string entry;
-    for (DWORD i = 0; i < bytesRead; ++i) {
-        if (buf[i] == '\n' || buf[i] == '\r') {
-            if (!entry.empty()) {
-                out.insert(std::move(entry));
-                entry.clear();
-            }
-        } else {
-            entry += buf[i];
-        }
-    }
-    if (!entry.empty()) out.insert(std::move(entry));
-}
-
 bool Extractor::enumerateFiles(const Options& opts,
                                std::vector<std::string>& outFiles) {
+    // Open all archives, enumerate files from highest priority to lowest.
+    // Use a set to deduplicate (highest-priority version wins).
     auto archives = discoverArchives(opts.mpqDir, opts.expansion, opts.locale);
     if (archives.empty()) {
         std::cerr << "No MPQ archives found in: " << opts.mpqDir << "\n";
@@ -577,31 +516,21 @@ bool Extractor::enumerateFiles(const Options& opts,
 
     std::cout << "Found " << archives.size() << " MPQ archives\n";
 
-    const bool haveExternalListFile = !opts.listFile.empty();
-    if (haveExternalListFile) {
-        std::cout << "  Using external listfile: " << opts.listFile << "\n";
-    }
-
     const auto wantedDbcs = buildWantedDbcSet(opts);
-    std::set<std::string> seenNormalized;
 
     // Enumerate from highest priority first so first-seen files win
+    std::set<std::string> seenNormalized;
+    std::vector<std::pair<std::string, std::string>> fileList; // (original name, archive path)
+
     for (auto it = archives.rbegin(); it != archives.rend(); ++it) {
         HANDLE hMpq = nullptr;
-        if (!SFileOpenArchive(it->c_str(), 0, 0, &hMpq)) {
-            std::cerr << "  Failed to open: " << *it << "\n";
+        if (!SFileOpenArchive(it->path.c_str(), 0, 0, &hMpq)) {
+            std::cerr << "  Failed to open: " << it->path << "\n";
             continue;
         }
 
-        // Inject external listfile into archive's in-memory name table.
-        // SFileAddListFile reads the file and hashes names against the
-        // archive's hash table.
-        if (haveExternalListFile) {
-            SFileAddListFile(hMpq, opts.listFile.c_str());
-        }
-
         if (opts.verbose) {
-            std::cout << "  Scanning: " << *it << "\n";
+            std::cout << "  Scanning: " << it->path << " (priority " << it->priority << ")\n";
         }
 
         SFILE_FIND_DATA findData;
@@ -609,20 +538,28 @@ bool Extractor::enumerateFiles(const Options& opts,
         if (hFind) {
             do {
                 std::string fileName = findData.cFileName;
+                // Skip internal listfile/attributes
                 if (fileName == "(listfile)" || fileName == "(attributes)" ||
                     fileName == "(signature)" || fileName == "(patch_metadata)") {
                     continue;
                 }
 
-                if (shouldSkipFile(opts, fileName)) continue;
+                if (shouldSkipFile(opts, fileName)) {
+                    continue;
+                }
 
-                if (!SFileHasFile(hMpq, fileName.c_str())) continue;
+                // Verify file actually exists in this archive's hash table
+                // (listfiles can reference files from other archives)
+                if (!SFileHasFile(hMpq, fileName.c_str())) {
+                    continue;
+                }
 
                 std::string norm = normalizeWowPath(fileName);
                 if (opts.onlyUsedDbcs && !wantedDbcs.empty() && !wantedDbcs.contains(norm)) {
                     continue;
                 }
                 if (seenNormalized.insert(norm).second) {
+                    // First time seeing this file — this is the highest-priority version
                     outFiles.push_back(fileName);
                 }
             } while (SFileFindNextFile(hFind, &findData));
@@ -697,18 +634,16 @@ bool Extractor::run(const Options& opts) {
     // thread-safe even with separate handles, so we serialize all MPQ reads.
     struct SharedArchive {
         HANDLE handle;
+        int priority;
         std::string path;
     };
     std::vector<SharedArchive> sharedHandles;
-    for (const auto& path : archives) {
+    for (const auto& ad : archives) {
         HANDLE h = nullptr;
-        if (SFileOpenArchive(path.c_str(), 0, 0, &h)) {
-            if (!opts.listFile.empty()) {
-                SFileAddListFile(h, opts.listFile.c_str());
-            }
-            sharedHandles.push_back({h, path});
+        if (SFileOpenArchive(ad.path.c_str(), 0, 0, &h)) {
+            sharedHandles.push_back({h, ad.priority, ad.path});
         } else {
-            std::cerr << "  Failed to open archive: " << path << "\n";
+            std::cerr << "  Failed to open archive: " << ad.path << "\n";
         }
     }
     if (sharedHandles.empty()) {
@@ -735,7 +670,7 @@ bool Extractor::run(const Options& opts) {
 
             // Map to new filesystem path
             std::string mappedPath = PathMapper::mapPath(wowPath);
-            fs::path fullOutputPath = fs::path(effectiveOutputDir) / mappedPath;
+            std::string fullOutputPath = effectiveOutputDir + "/" + mappedPath;
 
             // Read file data from MPQ under lock
             std::vector<uint8_t> data;
@@ -864,9 +799,9 @@ bool Extractor::run(const Options& opts) {
     }
 
     // Merge with existing manifest so partial extractions don't nuke prior entries
-    fs::path manifestPath = fs::path(effectiveOutputDir) / "manifest.json";
+    std::string manifestPath = effectiveOutputDir + "/manifest.json";
     if (fs::exists(manifestPath)) {
-        auto existing = loadManifestEntries(manifestPath.string());
+        auto existing = loadManifestEntries(manifestPath);
         if (!existing.empty()) {
             // New entries override existing ones with same key
             for (auto& entry : manifestEntries) {
@@ -889,7 +824,7 @@ bool Extractor::run(const Options& opts) {
               });
 
     // basePath is "." since manifest sits inside the output directory
-    if (!ManifestWriter::write(manifestPath.string(), ".", manifestEntries)) {
+    if (!ManifestWriter::write(manifestPath, ".", manifestEntries)) {
         std::cerr << "Failed to write manifest: " << manifestPath << "\n";
         return false;
     }
@@ -901,7 +836,7 @@ bool Extractor::run(const Options& opts) {
         std::cout << "Verifying extracted files...\n";
         uint64_t verified = 0, verifyFailed = 0;
         for (const auto& entry : manifestEntries) {
-            fs::path fsPath = fs::path(effectiveOutputDir) / entry.filesystemPath;
+            std::string fsPath = effectiveOutputDir + "/" + entry.filesystemPath;
             std::ifstream f(fsPath, std::ios::binary | std::ios::ate);
             if (!f.is_open()) {
                 std::cerr << "  MISSING: " << fsPath << "\n";
diff --git a/tools/asset_extract/extractor.hpp b/tools/asset_extract/extractor.hpp
index 48588273..e9aa646d 100644
--- a/tools/asset_extract/extractor.hpp
+++ b/tools/asset_extract/extractor.hpp
@@ -26,7 +26,6 @@ public:
         bool onlyUsedDbcs = false; // Extract only the DBC files wowee uses (implies DBFilesClient/*.dbc filter)
         std::string dbcCsvOutputDir; // When set, write CSVs into this directory instead of outputDir/expansions/<exp>/db
         std::string referenceManifest; // If set, only extract files NOT in this manifest (delta extraction)
-        std::string listFile;         // External listfile for MPQ enumeration (resolves unnamed hash entries)
     };
 
     struct Stats {
diff --git a/tools/asset_extract/main.cpp b/tools/asset_extract/main.cpp
index 0add3e99..6d9c27f5 100644
--- a/tools/asset_extract/main.cpp
+++ b/tools/asset_extract/main.cpp
@@ -20,7 +20,6 @@ static void printUsage(const char* prog) {
               << "  --skip-dbc          Do not extract DBFilesClient/*.dbc (visual assets only)\n"
               << "  --dbc-csv           Convert selected DBFilesClient/*.dbc to CSV under\n"
               << "                      <output>/expansions/<expansion>/db/*.csv (for committing)\n"
-              << "  --listfile <path>   External listfile for MPQ file enumeration (auto-detected)\n"
               << "  --reference-manifest <path>\n"
               << "                      Only extract files NOT in this manifest (delta extraction)\n"
               << "  --dbc-csv-out <dir> Write CSV DBCs into <dir> (overrides default output path)\n"
@@ -54,8 +53,6 @@ int main(int argc, char** argv) {
             opts.generateDbcCsv = true;
         } else if (std::strcmp(argv[i], "--dbc-csv-out") == 0 && i + 1 < argc) {
             opts.dbcCsvOutputDir = argv[++i];
-        } else if (std::strcmp(argv[i], "--listfile") == 0 && i + 1 < argc) {
-            opts.listFile = argv[++i];
         } else if (std::strcmp(argv[i], "--reference-manifest") == 0 && i + 1 < argc) {
             opts.referenceManifest = argv[++i];
         } else if (std::strcmp(argv[i], "--verify") == 0) {
@@ -102,24 +99,6 @@ int main(int argc, char** argv) {
     }
     opts.locale = locale;
 
-    // Auto-detect external listfile if not specified
-    if (opts.listFile.empty()) {
-        // Look next to the binary, then in the source tree
-        namespace fs = std::filesystem;
-        std::string binDir = fs::path(argv[0]).parent_path().string();
-        for (const auto& candidate : {
-            binDir + "/listfile.txt",
-            binDir + "/../../../tools/asset_extract/listfile.txt",
-            opts.mpqDir + "/listfile.txt",
-        }) {
-            if (fs::exists(candidate)) {
-                opts.listFile = candidate;
-                std::cout << "Auto-detected listfile: " << candidate << "\n";
-                break;
-            }
-        }
-    }
-
     std::cout << "=== Wowee Asset Extractor ===\n";
     std::cout << "MPQ directory: " << opts.mpqDir << "\n";
     std::cout << "Output:        " << opts.outputDir << "\n";
diff --git a/tools/asset_extract/path_mapper.cpp b/tools/asset_extract/path_mapper.cpp
index 85a5ebe0..e4e1c8c4 100644
--- a/tools/asset_extract/path_mapper.cpp
+++ b/tools/asset_extract/path_mapper.cpp
@@ -18,10 +18,189 @@ std::string PathMapper::toForwardSlash(const std::string& str) {
     return result;
 }
 
+bool PathMapper::startsWithCI(const std::string& str, const std::string& prefix) {
+    if (str.size() < prefix.size()) return false;
+    for (size_t i = 0; i < prefix.size(); ++i) {
+        if (std::tolower(static_cast<unsigned char>(str[i])) !=
+            std::tolower(static_cast<unsigned char>(prefix[i]))) {
+            return false;
+        }
+    }
+    return true;
+}
+
+std::string PathMapper::extractAfterPrefix(const std::string& path, size_t prefixLen) {
+    if (prefixLen >= path.size()) return {};
+    return path.substr(prefixLen);
+}
+
 std::string PathMapper::mapPath(const std::string& wowPath) {
-    // Lowercase entire output path — WoW archives contain mixed-case variants
-    // of the same path which create duplicate directories on case-sensitive filesystems.
-    return toLower(toForwardSlash(wowPath));
+    // Preserve original casing in the remainder for filesystem readability
+    std::string rest;
+
+    // DBFilesClient\ → db/
+    if (startsWithCI(wowPath, "DBFilesClient\\")) {
+        rest = extractAfterPrefix(wowPath, 14);
+        return "db/" + toForwardSlash(rest);
+    }
+
+    // Character\{Race}\{Gender}\ → character/{race}/{gender}/
+    if (startsWithCI(wowPath, "Character\\")) {
+        rest = extractAfterPrefix(wowPath, 10);
+        std::string lowered = toLower(rest);
+        return "character/" + toForwardSlash(lowered);
+    }
+
+    // Creature\{Name}\ → creature/{name}/
+    if (startsWithCI(wowPath, "Creature\\")) {
+        rest = extractAfterPrefix(wowPath, 9);
+        // Keep first component lowercase for directory, preserve filename case
+        std::string fwd = toForwardSlash(rest);
+        auto slash = fwd.find('/');
+        if (slash != std::string::npos) {
+            return "creature/" + toLower(fwd.substr(0, slash)) + "/" + fwd.substr(slash + 1);
+        }
+        return "creature/" + fwd;
+    }
+
+    // Item\ObjectComponents\{Type}\ → item/{type}/
+    if (startsWithCI(wowPath, "Item\\ObjectComponents\\")) {
+        rest = extractAfterPrefix(wowPath, 22);
+        std::string fwd = toForwardSlash(rest);
+        auto slash = fwd.find('/');
+        if (slash != std::string::npos) {
+            return "item/" + toLower(fwd.substr(0, slash)) + "/" + fwd.substr(slash + 1);
+        }
+        return "item/" + fwd;
+    }
+
+    // Item\TextureComponents\ → item/texture/
+    if (startsWithCI(wowPath, "Item\\TextureComponents\\")) {
+        rest = extractAfterPrefix(wowPath, 23);
+        return "item/texture/" + toForwardSlash(rest);
+    }
+
+    // Interface\Icons\ → interface/icons/
+    if (startsWithCI(wowPath, "Interface\\Icons\\")) {
+        rest = extractAfterPrefix(wowPath, 16);
+        return "interface/icons/" + toForwardSlash(rest);
+    }
+
+    // Interface\GossipFrame\ → interface/gossip/
+    if (startsWithCI(wowPath, "Interface\\GossipFrame\\")) {
+        rest = extractAfterPrefix(wowPath, 21);
+        return "interface/gossip/" + toForwardSlash(rest);
+    }
+
+    // Interface\{rest} → interface/{rest}/
+    if (startsWithCI(wowPath, "Interface\\")) {
+        rest = extractAfterPrefix(wowPath, 10);
+        return "interface/" + toForwardSlash(rest);
+    }
+
+    // Textures\Minimap\ → terrain/minimap/
+    if (startsWithCI(wowPath, "Textures\\Minimap\\")) {
+        rest = extractAfterPrefix(wowPath, 17);
+        return "terrain/minimap/" + toForwardSlash(rest);
+    }
+
+    // Textures\BakedNpcTextures\ → creature/baked/
+    if (startsWithCI(wowPath, "Textures\\BakedNpcTextures\\")) {
+        rest = extractAfterPrefix(wowPath, 25);
+        return "creature/baked/" + toForwardSlash(rest);
+    }
+
+    // Textures\{rest} → terrain/textures/{rest}
+    if (startsWithCI(wowPath, "Textures\\")) {
+        rest = extractAfterPrefix(wowPath, 9);
+        return "terrain/textures/" + toForwardSlash(rest);
+    }
+
+    // World\Maps\{Map}\ → terrain/maps/{map}/
+    if (startsWithCI(wowPath, "World\\Maps\\")) {
+        rest = extractAfterPrefix(wowPath, 11);
+        std::string fwd = toForwardSlash(rest);
+        auto slash = fwd.find('/');
+        if (slash != std::string::npos) {
+            return "terrain/maps/" + toLower(fwd.substr(0, slash)) + "/" + fwd.substr(slash + 1);
+        }
+        return "terrain/maps/" + fwd;
+    }
+
+    // World\wmo\ → world/wmo/ (preserve subpath)
+    if (startsWithCI(wowPath, "World\\wmo\\")) {
+        rest = extractAfterPrefix(wowPath, 10);
+        return "world/wmo/" + toForwardSlash(rest);
+    }
+
+    // World\Doodads\ → world/doodads/
+    if (startsWithCI(wowPath, "World\\Doodads\\")) {
+        rest = extractAfterPrefix(wowPath, 14);
+        return "world/doodads/" + toForwardSlash(rest);
+    }
+
+    // World\{rest} → world/{rest}/
+    if (startsWithCI(wowPath, "World\\")) {
+        rest = extractAfterPrefix(wowPath, 6);
+        return "world/" + toForwardSlash(rest);
+    }
+
+    // Environments\ → environment/
+    if (startsWithCI(wowPath, "Environments\\")) {
+        rest = extractAfterPrefix(wowPath, 13);
+        return "environment/" + toForwardSlash(rest);
+    }
+
+    // Sound\Ambience\ → sound/ambient/
+    if (startsWithCI(wowPath, "Sound\\Ambience\\")) {
+        rest = extractAfterPrefix(wowPath, 15);
+        return "sound/ambient/" + toForwardSlash(rest);
+    }
+
+    // Sound\Character\ → sound/character/
+    if (startsWithCI(wowPath, "Sound\\Character\\")) {
+        rest = extractAfterPrefix(wowPath, 16);
+        return "sound/character/" + toForwardSlash(rest);
+    }
+
+    // Sound\Doodad\ → sound/doodad/
+    if (startsWithCI(wowPath, "Sound\\Doodad\\")) {
+        rest = extractAfterPrefix(wowPath, 13);
+        return "sound/doodad/" + toForwardSlash(rest);
+    }
+
+    // Sound\Creature\ → sound/creature/
+    if (startsWithCI(wowPath, "Sound\\Creature\\")) {
+        rest = extractAfterPrefix(wowPath, 15);
+        return "sound/creature/" + toForwardSlash(rest);
+    }
+
+    // Sound\Spells\ → sound/spell/
+    if (startsWithCI(wowPath, "Sound\\Spells\\")) {
+        rest = extractAfterPrefix(wowPath, 13);
+        return "sound/spell/" + toForwardSlash(rest);
+    }
+
+    // Sound\Music\ → sound/music/
+    if (startsWithCI(wowPath, "Sound\\Music\\")) {
+        rest = extractAfterPrefix(wowPath, 12);
+        return "sound/music/" + toForwardSlash(rest);
+    }
+
+    // Sound\{rest} → sound/{rest}/
+    if (startsWithCI(wowPath, "Sound\\")) {
+        rest = extractAfterPrefix(wowPath, 6);
+        return "sound/" + toForwardSlash(rest);
+    }
+
+    // Spells\ → spell/
+    if (startsWithCI(wowPath, "Spells\\")) {
+        rest = extractAfterPrefix(wowPath, 7);
+        return "spell/" + toForwardSlash(rest);
+    }
+
+    // Everything else → misc/{original_path}
+    return "misc/" + toForwardSlash(wowPath);
 }
 
 } // namespace tools
diff --git a/tools/asset_extract/path_mapper.hpp b/tools/asset_extract/path_mapper.hpp
index c5db03d1..cad31c57 100644
--- a/tools/asset_extract/path_mapper.hpp
+++ b/tools/asset_extract/path_mapper.hpp
@@ -6,7 +6,7 @@ namespace wowee {
 namespace tools {
 
 /**
- * Maps WoW virtual paths to organized filesystem categories.
+ * Maps WoW virtual paths to reorganized filesystem categories.
  *
  * Input:  WoW virtual path (e.g., "Creature\\Bear\\BearSkin.blp")
  * Output: Category-based relative path (e.g., "creature/bear/BearSkin.blp")
@@ -14,15 +14,18 @@ namespace tools {
 class PathMapper {
 public:
     /**
-     * Map a WoW virtual path to a organized filesystem path.
+     * Map a WoW virtual path to a reorganized filesystem path.
      * @param wowPath Original WoW virtual path (backslash-separated)
-     * @return Organized relative path (forward-slash separated, fully lowercased)
+     * @return Reorganized relative path (forward-slash separated, original casing preserved)
      */
     static std::string mapPath(const std::string& wowPath);
 
 private:
+    // Helpers for prefix matching (case-insensitive)
+    static bool startsWithCI(const std::string& str, const std::string& prefix);
     static std::string toLower(const std::string& str);
     static std::string toForwardSlash(const std::string& str);
+    static std::string extractAfterPrefix(const std::string& path, size_t prefixLen);
 };
 
 } // namespace tools
diff --git a/tools/asset_pipeline_gui.py b/tools/asset_pipeline_gui.py
index 62022c21..965b36e0 100755
--- a/tools/asset_pipeline_gui.py
+++ b/tools/asset_pipeline_gui.py
@@ -873,217 +873,24 @@ class AssetPipelineGUI:
 
     # ── M2 Preview (wireframe + textures + animations) ──
 
-    # Common animation ID names — complete list from animation_ids.hpp (452 entries)
+    # Common animation ID names
     _ANIM_NAMES: dict[int, str] = {
-        # ── Classic (Vanilla WoW 1.x) — IDs 0–145 ──
-        0: "STAND", 1: "DEATH", 2: "SPELL", 3: "STOP", 4: "WALK", 5: "RUN",
-        6: "DEAD", 7: "RISE", 8: "STAND_WOUND", 9: "COMBAT_WOUND",
-        10: "COMBAT_CRITICAL", 11: "SHUFFLE_LEFT", 12: "SHUFFLE_RIGHT",
-        13: "WALK_BACKWARDS", 14: "STUN", 15: "HANDS_CLOSED",
-        16: "ATTACK_UNARMED", 17: "ATTACK_1H", 18: "ATTACK_2H",
-        19: "ATTACK_2H_LOOSE", 20: "PARRY_UNARMED", 21: "PARRY_1H",
-        22: "PARRY_2H", 23: "PARRY_2H_LOOSE", 24: "SHIELD_BLOCK",
-        25: "READY_UNARMED", 26: "READY_1H", 27: "READY_2H",
-        28: "READY_2H_LOOSE", 29: "READY_BOW", 30: "DODGE",
-        31: "SPELL_PRECAST", 32: "SPELL_CAST", 33: "SPELL_CAST_AREA",
-        34: "NPC_WELCOME", 35: "NPC_GOODBYE", 36: "BLOCK",
-        37: "JUMP_START", 38: "JUMP", 39: "JUMP_END", 40: "FALL",
-        41: "SWIM_IDLE", 42: "SWIM", 43: "SWIM_LEFT", 44: "SWIM_RIGHT",
-        45: "SWIM_BACKWARDS", 46: "ATTACK_BOW", 47: "FIRE_BOW",
-        48: "READY_RIFLE", 49: "ATTACK_RIFLE", 50: "LOOT",
-        51: "READY_SPELL_DIRECTED", 52: "READY_SPELL_OMNI",
-        53: "SPELL_CAST_DIRECTED", 54: "SPELL_CAST_OMNI", 55: "BATTLE_ROAR",
-        56: "READY_ABILITY", 57: "SPECIAL_1H", 58: "SPECIAL_2H",
-        59: "SHIELD_BASH", 60: "EMOTE_TALK", 61: "EMOTE_EAT",
-        62: "EMOTE_WORK", 63: "EMOTE_USE_STANDING", 64: "EMOTE_EXCLAMATION",
-        65: "EMOTE_QUESTION", 66: "EMOTE_BOW", 67: "EMOTE_WAVE",
-        68: "EMOTE_CHEER", 69: "EMOTE_DANCE", 70: "EMOTE_LAUGH",
-        71: "EMOTE_SLEEP", 72: "EMOTE_SIT_GROUND", 73: "EMOTE_RUDE",
-        74: "EMOTE_ROAR", 75: "EMOTE_KNEEL", 76: "EMOTE_KISS",
-        77: "EMOTE_CRY", 78: "EMOTE_CHICKEN", 79: "EMOTE_BEG",
-        80: "EMOTE_APPLAUD", 81: "EMOTE_SHOUT", 82: "EMOTE_FLEX",
-        83: "EMOTE_SHY", 84: "EMOTE_POINT", 85: "ATTACK_1H_PIERCE",
-        86: "ATTACK_2H_LOOSE_PIERCE", 87: "ATTACK_OFF",
-        88: "ATTACK_OFF_PIERCE", 89: "SHEATHE", 90: "HIP_SHEATHE",
-        91: "MOUNT", 92: "RUN_RIGHT", 93: "RUN_LEFT",
-        94: "MOUNT_SPECIAL", 95: "KICK", 96: "SIT_GROUND_DOWN",
-        97: "SITTING", 98: "SIT_GROUND_UP", 99: "SLEEP_DOWN",
-        100: "SLEEP", 101: "SLEEP_UP", 102: "SIT_CHAIR_LOW",
-        103: "SIT_CHAIR_MED", 104: "SIT_CHAIR_HIGH", 105: "LOAD_BOW",
-        106: "LOAD_RIFLE", 107: "ATTACK_THROWN", 108: "READY_THROWN",
-        109: "HOLD_BOW", 110: "HOLD_RIFLE", 111: "HOLD_THROWN",
-        112: "LOAD_THROWN", 113: "EMOTE_SALUTE", 114: "KNEEL_START",
-        115: "KNEEL_LOOP", 116: "KNEEL_END", 117: "ATTACK_UNARMED_OFF",
-        118: "SPECIAL_UNARMED", 119: "STEALTH_WALK", 120: "STEALTH_STAND",
-        121: "KNOCKDOWN", 122: "EATING_LOOP", 123: "USE_STANDING_LOOP",
-        124: "CHANNEL_CAST_DIRECTED", 125: "CHANNEL_CAST_OMNI",
-        126: "WHIRLWIND", 127: "BIRTH", 128: "USE_STANDING_START",
-        129: "USE_STANDING_END", 130: "CREATURE_SPECIAL", 131: "DROWN",
-        132: "DROWNED", 133: "FISHING_CAST", 134: "FISHING_LOOP",
-        135: "FLY", 136: "EMOTE_WORK_NO_SHEATHE",
-        137: "EMOTE_STUN_NO_SHEATHE", 138: "EMOTE_USE_STANDING_NO_SHEATHE",
-        139: "SPELL_SLEEP_DOWN", 140: "SPELL_KNEEL_START",
-        141: "SPELL_KNEEL_LOOP", 142: "SPELL_KNEEL_END", 143: "SPRINT",
-        144: "IN_FLIGHT", 145: "SPAWN",
-        # ── The Burning Crusade (TBC 2.x) — IDs 146–199 ──
-        146: "CLOSE", 147: "CLOSED", 148: "OPEN", 149: "DESTROY",
-        150: "DESTROYED", 151: "UNSHEATHE", 152: "SHEATHE_ALT",
-        153: "ATTACK_UNARMED_NO_SHEATHE", 154: "STEALTH_RUN",
-        155: "READY_CROSSBOW", 156: "ATTACK_CROSSBOW",
-        157: "EMOTE_TALK_EXCLAMATION", 158: "FLY_IDLE", 159: "FLY_FORWARD",
-        160: "FLY_BACKWARDS", 161: "FLY_LEFT", 162: "FLY_RIGHT",
-        163: "FLY_UP", 164: "FLY_DOWN", 165: "FLY_LAND_START",
-        166: "FLY_LAND_RUN", 167: "FLY_LAND_END",
-        168: "EMOTE_TALK_QUESTION", 169: "EMOTE_READ",
-        170: "EMOTE_SHIELDBLOCK", 171: "EMOTE_CHOP",
-        172: "EMOTE_HOLDRIFLE", 173: "EMOTE_HOLDBOW",
-        174: "EMOTE_HOLDTHROWN", 175: "CUSTOM_SPELL_02",
-        176: "CUSTOM_SPELL_03", 177: "CUSTOM_SPELL_04",
-        178: "CUSTOM_SPELL_05", 179: "CUSTOM_SPELL_06",
-        180: "CUSTOM_SPELL_07", 181: "CUSTOM_SPELL_08",
-        182: "CUSTOM_SPELL_09", 183: "CUSTOM_SPELL_10",
-        184: "EMOTE_STATE_DANCE",
-        # ── Wrath of the Lich King (WotLK 3.x) — IDs 185+ ──
-        185: "FLY_STAND", 186: "EMOTE_STATE_LAUGH",
-        187: "EMOTE_STATE_POINT", 188: "EMOTE_STATE_EAT",
-        189: "EMOTE_STATE_WORK", 190: "EMOTE_STATE_SIT_GROUND",
-        191: "EMOTE_STATE_HOLD_BOW", 192: "EMOTE_STATE_HOLD_RIFLE",
-        193: "EMOTE_STATE_HOLD_THROWN", 194: "FLY_COMBAT_WOUND",
-        195: "FLY_COMBAT_CRITICAL", 196: "RECLINED",
-        197: "EMOTE_STATE_ROAR", 198: "EMOTE_USE_STANDING_LOOP_2",
-        199: "EMOTE_STATE_APPLAUD", 200: "READY_FIST",
-        201: "SPELL_CHANNEL_DIRECTED_OMNI", 202: "SPECIAL_ATTACK_1H_OFF",
-        203: "ATTACK_FIST_1H", 204: "ATTACK_FIST_1H_OFF",
-        205: "PARRY_FIST_1H", 206: "READY_FIST_1H",
-        207: "EMOTE_STATE_READ_AND_TALK",
-        208: "EMOTE_STATE_WORK_NO_SHEATHE", 209: "FLY_RUN",
-        210: "EMOTE_STATE_KNEEL_2", 211: "EMOTE_STATE_SPELL_KNEEL",
-        212: "EMOTE_STATE_USE_STANDING", 213: "EMOTE_STATE_STUN",
-        214: "EMOTE_STATE_STUN_NO_SHEATHE", 215: "EMOTE_TRAIN",
-        216: "EMOTE_DEAD", 217: "EMOTE_STATE_DANCE_ONCE",
-        218: "FLY_DEATH", 219: "FLY_STAND_WOUND",
-        220: "FLY_SHUFFLE_LEFT", 221: "FLY_SHUFFLE_RIGHT",
-        222: "FLY_WALK_BACKWARDS", 223: "FLY_STUN",
-        224: "FLY_HANDS_CLOSED", 225: "FLY_ATTACK_UNARMED",
-        226: "FLY_ATTACK_1H", 227: "FLY_ATTACK_2H",
-        228: "FLY_ATTACK_2H_LOOSE", 229: "FLY_SPELL", 230: "FLY_STOP",
-        231: "FLY_WALK", 232: "FLY_DEAD", 233: "FLY_RISE",
-        234: "FLY_RUN_2", 235: "FLY_FALL", 236: "FLY_SWIM_IDLE",
-        237: "FLY_SWIM", 238: "FLY_SWIM_LEFT", 239: "FLY_SWIM_RIGHT",
-        240: "FLY_SWIM_BACKWARDS", 241: "FLY_ATTACK_BOW",
-        242: "FLY_FIRE_BOW", 243: "FLY_READY_RIFLE",
-        244: "FLY_ATTACK_RIFLE", 245: "TOTEM_SMALL", 246: "TOTEM_MEDIUM",
-        247: "TOTEM_LARGE", 248: "FLY_LOOT",
-        249: "FLY_READY_SPELL_DIRECTED", 250: "FLY_READY_SPELL_OMNI",
-        251: "FLY_SPELL_CAST_DIRECTED", 252: "FLY_SPELL_CAST_OMNI",
-        253: "FLY_BATTLE_ROAR", 254: "FLY_READY_ABILITY",
-        255: "FLY_SPECIAL_1H", 256: "FLY_SPECIAL_2H",
-        257: "FLY_SHIELD_BASH", 258: "FLY_EMOTE_TALK",
-        259: "FLY_EMOTE_EAT", 260: "FLY_EMOTE_WORK",
-        261: "FLY_EMOTE_USE_STANDING", 262: "FLY_EMOTE_BOW",
-        263: "FLY_EMOTE_WAVE", 264: "FLY_EMOTE_CHEER",
-        265: "FLY_EMOTE_DANCE", 266: "FLY_EMOTE_LAUGH",
-        267: "FLY_EMOTE_SLEEP", 268: "FLY_EMOTE_SIT_GROUND",
-        269: "FLY_EMOTE_RUDE", 270: "FLY_EMOTE_ROAR",
-        271: "FLY_EMOTE_KNEEL", 272: "FLY_EMOTE_KISS",
-        273: "FLY_EMOTE_CRY", 274: "FLY_EMOTE_CHICKEN",
-        275: "FLY_EMOTE_BEG", 276: "FLY_EMOTE_APPLAUD",
-        277: "FLY_EMOTE_SHOUT", 278: "FLY_EMOTE_FLEX",
-        279: "FLY_EMOTE_SHY", 280: "FLY_EMOTE_POINT",
-        281: "FLY_ATTACK_1H_PIERCE", 282: "FLY_ATTACK_2H_LOOSE_PIERCE",
-        283: "FLY_ATTACK_OFF", 284: "FLY_ATTACK_OFF_PIERCE",
-        285: "FLY_SHEATHE", 286: "FLY_HIP_SHEATHE", 287: "FLY_MOUNT",
-        288: "FLY_RUN_RIGHT", 289: "FLY_RUN_LEFT",
-        290: "FLY_MOUNT_SPECIAL", 291: "FLY_KICK",
-        292: "FLY_SIT_GROUND_DOWN", 293: "FLY_SITTING",
-        294: "FLY_SIT_GROUND_UP", 295: "FLY_SLEEP_DOWN",
-        296: "FLY_SLEEP", 297: "FLY_SLEEP_UP",
-        298: "FLY_SIT_CHAIR_LOW", 299: "FLY_SIT_CHAIR_MED",
-        300: "FLY_SIT_CHAIR_HIGH", 301: "FLY_LOAD_BOW",
-        302: "FLY_LOAD_RIFLE", 303: "FLY_ATTACK_THROWN",
-        304: "FLY_READY_THROWN", 305: "FLY_HOLD_BOW",
-        306: "FLY_HOLD_RIFLE", 307: "FLY_HOLD_THROWN",
-        308: "FLY_LOAD_THROWN", 309: "FLY_EMOTE_SALUTE",
-        310: "FLY_KNEEL_START", 311: "FLY_KNEEL_LOOP",
-        312: "FLY_KNEEL_END", 313: "FLY_ATTACK_UNARMED_OFF",
-        314: "FLY_SPECIAL_UNARMED", 315: "FLY_STEALTH_WALK",
-        316: "FLY_STEALTH_STAND", 317: "FLY_KNOCKDOWN",
-        318: "FLY_EATING_LOOP", 319: "FLY_USE_STANDING_LOOP",
-        320: "FLY_CHANNEL_CAST_DIRECTED", 321: "FLY_CHANNEL_CAST_OMNI",
-        322: "FLY_WHIRLWIND", 323: "FLY_BIRTH",
-        324: "FLY_USE_STANDING_START", 325: "FLY_USE_STANDING_END",
-        326: "FLY_CREATURE_SPECIAL", 327: "FLY_DROWN",
-        328: "FLY_DROWNED", 329: "FLY_FISHING_CAST",
-        330: "FLY_FISHING_LOOP", 331: "FLY_FLY",
-        332: "FLY_EMOTE_WORK_NO_SHEATHE",
-        333: "FLY_EMOTE_STUN_NO_SHEATHE",
-        334: "FLY_EMOTE_USE_STANDING_NO_SHEATHE",
-        335: "FLY_SPELL_SLEEP_DOWN", 336: "FLY_SPELL_KNEEL_START",
-        337: "FLY_SPELL_KNEEL_LOOP", 338: "FLY_SPELL_KNEEL_END",
-        339: "FLY_SPRINT", 340: "FLY_IN_FLIGHT", 341: "FLY_SPAWN",
-        342: "FLY_CLOSE", 343: "FLY_CLOSED", 344: "FLY_OPEN",
-        345: "FLY_DESTROY", 346: "FLY_DESTROYED", 347: "FLY_UNSHEATHE",
-        348: "FLY_SHEATHE_ALT", 349: "FLY_ATTACK_UNARMED_NO_SHEATHE",
-        350: "FLY_STEALTH_RUN", 351: "FLY_READY_CROSSBOW",
-        352: "FLY_ATTACK_CROSSBOW", 353: "FLY_EMOTE_TALK_EXCLAMATION",
-        354: "FLY_EMOTE_TALK_QUESTION", 355: "FLY_EMOTE_READ",
-        356: "EMOTE_HOLD_CROSSBOW", 357: "FLY_EMOTE_HOLD_BOW",
-        358: "FLY_EMOTE_HOLD_RIFLE", 359: "FLY_EMOTE_HOLD_THROWN",
-        360: "FLY_EMOTE_HOLD_CROSSBOW", 361: "FLY_CUSTOM_SPELL_02",
-        362: "FLY_CUSTOM_SPELL_03", 363: "FLY_CUSTOM_SPELL_04",
-        364: "FLY_CUSTOM_SPELL_05", 365: "FLY_CUSTOM_SPELL_06",
-        366: "FLY_CUSTOM_SPELL_07", 367: "FLY_CUSTOM_SPELL_08",
-        368: "FLY_CUSTOM_SPELL_09", 369: "FLY_CUSTOM_SPELL_10",
-        370: "FLY_EMOTE_STATE_DANCE", 371: "EMOTE_EAT_NO_SHEATHE",
-        372: "MOUNT_RUN_RIGHT", 373: "MOUNT_RUN_LEFT",
-        374: "MOUNT_WALK_BACKWARDS", 375: "MOUNT_SWIM_IDLE",
-        376: "MOUNT_SWIM", 377: "MOUNT_SWIM_LEFT",
-        378: "MOUNT_SWIM_RIGHT", 379: "MOUNT_SWIM_BACKWARDS",
-        380: "MOUNT_FLIGHT_IDLE", 381: "MOUNT_FLIGHT_FORWARD",
-        382: "MOUNT_FLIGHT_BACKWARDS", 383: "MOUNT_FLIGHT_LEFT",
-        384: "MOUNT_FLIGHT_RIGHT", 385: "MOUNT_FLIGHT_UP",
-        386: "MOUNT_FLIGHT_DOWN", 387: "MOUNT_FLIGHT_LAND_START",
-        388: "MOUNT_FLIGHT_LAND_RUN", 389: "MOUNT_FLIGHT_LAND_END",
-        390: "FLY_EMOTE_STATE_LAUGH", 391: "FLY_EMOTE_STATE_POINT",
-        392: "FLY_EMOTE_STATE_EAT", 393: "FLY_EMOTE_STATE_WORK",
-        394: "FLY_EMOTE_STATE_SIT_GROUND",
-        395: "FLY_EMOTE_STATE_HOLD_BOW",
-        396: "FLY_EMOTE_STATE_HOLD_RIFLE",
-        397: "FLY_EMOTE_STATE_HOLD_THROWN",
-        398: "FLY_EMOTE_STATE_ROAR", 399: "FLY_RECLINED",
-        400: "EMOTE_TRAIN_2", 401: "EMOTE_DEAD_2",
-        402: "FLY_EMOTE_USE_STANDING_LOOP_2",
-        403: "FLY_EMOTE_STATE_APPLAUD", 404: "FLY_READY_FIST",
-        405: "FLY_SPELL_CHANNEL_DIRECTED_OMNI",
-        406: "FLY_SPECIAL_ATTACK_1H_OFF", 407: "FLY_ATTACK_FIST_1H",
-        408: "FLY_ATTACK_FIST_1H_OFF", 409: "FLY_PARRY_FIST_1H",
-        410: "FLY_READY_FIST_1H", 411: "FLY_EMOTE_STATE_READ_AND_TALK",
-        412: "FLY_EMOTE_STATE_WORK_NO_SHEATHE",
-        413: "FLY_EMOTE_STATE_KNEEL_2",
-        414: "FLY_EMOTE_STATE_SPELL_KNEEL",
-        415: "FLY_EMOTE_STATE_USE_STANDING",
-        416: "FLY_EMOTE_STATE_STUN",
-        417: "FLY_EMOTE_STATE_STUN_NO_SHEATHE",
-        418: "FLY_EMOTE_TRAIN", 419: "FLY_EMOTE_DEAD",
-        420: "FLY_EMOTE_STATE_DANCE_ONCE",
-        421: "FLY_EMOTE_EAT_NO_SHEATHE", 422: "FLY_MOUNT_RUN_RIGHT",
-        423: "FLY_MOUNT_RUN_LEFT", 424: "FLY_MOUNT_WALK_BACKWARDS",
-        425: "FLY_MOUNT_SWIM_IDLE", 426: "FLY_MOUNT_SWIM",
-        427: "FLY_MOUNT_SWIM_LEFT", 428: "FLY_MOUNT_SWIM_RIGHT",
-        429: "FLY_MOUNT_SWIM_BACKWARDS", 430: "FLY_MOUNT_FLIGHT_IDLE",
-        431: "FLY_MOUNT_FLIGHT_FORWARD",
-        432: "FLY_MOUNT_FLIGHT_BACKWARDS",
-        433: "FLY_MOUNT_FLIGHT_LEFT", 434: "FLY_MOUNT_FLIGHT_RIGHT",
-        435: "FLY_MOUNT_FLIGHT_UP", 436: "FLY_MOUNT_FLIGHT_DOWN",
-        437: "FLY_MOUNT_FLIGHT_LAND_START",
-        438: "FLY_MOUNT_FLIGHT_LAND_RUN",
-        439: "FLY_MOUNT_FLIGHT_LAND_END", 440: "FLY_TOTEM_SMALL",
-        441: "FLY_TOTEM_MEDIUM", 442: "FLY_TOTEM_LARGE",
-        443: "FLY_EMOTE_HOLD_CROSSBOW_2", 444: "VEHICLE_GRAB",
-        445: "VEHICLE_THROW", 446: "FLY_VEHICLE_GRAB",
-        447: "FLY_VEHICLE_THROW", 448: "GUILD_CHAMPION_1",
-        449: "GUILD_CHAMPION_2", 450: "FLY_GUILD_CHAMPION_1",
-        451: "FLY_GUILD_CHAMPION_2",
+        0: "Stand", 1: "Death", 2: "Spell", 3: "Stop", 4: "Walk", 5: "Run",
+        6: "Dead", 7: "Rise", 8: "StandWound", 9: "CombatWound", 10: "CombatCritical",
+        11: "ShuffleLeft", 12: "ShuffleRight", 13: "Walkbackwards", 14: "Stun",
+        15: "HandsClosed", 16: "AttackUnarmed", 17: "Attack1H", 18: "Attack2H",
+        19: "Attack2HL", 20: "ParryUnarmed", 21: "Parry1H", 22: "Parry2H",
+        23: "Parry2HL", 24: "ShieldBlock", 25: "ReadyUnarmed", 26: "Ready1H",
+        27: "Ready2H", 28: "Ready2HL", 29: "ReadyBow", 30: "Dodge",
+        31: "SpellPrecast", 32: "SpellCast", 33: "SpellCastArea",
+        34: "NPCWelcome", 35: "NPCGoodbye", 36: "Block", 37: "JumpStart",
+        38: "Jump", 39: "JumpEnd", 40: "Fall", 41: "SwimIdle", 42: "Swim",
+        43: "SwimLeft", 44: "SwimRight", 45: "SwimBackwards",
+        60: "SpellChannelDirected", 61: "SpellChannelOmni",
+        69: "CombatAbility", 70: "CombatAbility2H",
+        94: "Kneel", 113: "Loot",
+        135: "ReadyRifle", 138: "Fly", 143: "CustomSpell01",
+        157: "EmoteTalk", 185: "FlyIdle",
     }
 
     # Texture type names for non-filename textures
diff --git a/tools/dbc_to_csv/main.cpp b/tools/dbc_to_csv/main.cpp
index 53e28bf8..514d5a40 100644
--- a/tools/dbc_to_csv/main.cpp
+++ b/tools/dbc_to_csv/main.cpp
@@ -41,31 +41,9 @@ std::vector<uint8_t> readFileBytes(const std::string& path) {
     return buf;
 }
 
-// Precompute the set of valid string-boundary offsets in the string block.
-// An offset is a valid boundary if it is 0 or immediately follows a null byte.
-// This prevents small integer values (e.g. RaceID=1, 2, 3) from being falsely
-// detected as string offsets just because they land in the middle of a longer
-// string that starts at a lower offset.
-std::set<uint32_t> computeStringBoundaries(const std::vector<uint8_t>& stringBlock) {
-    std::set<uint32_t> boundaries;
-    if (stringBlock.empty()) return boundaries;
-    boundaries.insert(0); // offset 0 is always a valid start
-    for (size_t i = 0; i + 1 < stringBlock.size(); ++i) {
-        if (stringBlock[i] == 0) {
-            boundaries.insert(static_cast<uint32_t>(i + 1));
-        }
-    }
-    return boundaries;
-}
-
-// Check whether offset points to a valid string-boundary position in the block
-// and that the string there is printable and null-terminated.
-bool isValidStringOffset(const std::vector<uint8_t>& stringBlock,
-                         const std::set<uint32_t>& boundaries,
-                         uint32_t offset) {
+// Check whether offset points to a plausible string in the string block.
+bool isValidStringOffset(const std::vector<uint8_t>& stringBlock, uint32_t offset) {
     if (offset >= stringBlock.size()) return false;
-    // Must start at a string boundary (offset 0 or right after a null byte).
-    if (!boundaries.count(offset)) return false;
     // Must be null-terminated within the block and contain only printable/whitespace bytes.
     for (size_t i = offset; i < stringBlock.size(); ++i) {
         uint8_t c = stringBlock[i];
@@ -97,35 +75,21 @@ std::set<uint32_t> detectStringColumns(const DBCFile& dbc,
     // If no string block (or trivial size), no string columns.
     if (stringBlock.size() <= 1) return stringCols;
 
-    // Precompute valid string-start boundaries to avoid false positives from
-    // integer fields whose small values accidentally land inside longer strings.
-    auto boundaries = computeStringBoundaries(stringBlock);
-
     for (uint32_t col = 0; col < fieldCount; ++col) {
         bool allZeroOrValid = true;
         bool hasNonZero = false;
-        std::set<std::string> distinctStrings;
 
         for (uint32_t row = 0; row < recordCount; ++row) {
             uint32_t val = dbc.getUInt32(row, col);
             if (val == 0) continue;
             hasNonZero = true;
-            if (!isValidStringOffset(stringBlock, boundaries, val)) {
+            if (!isValidStringOffset(stringBlock, val)) {
                 allZeroOrValid = false;
                 break;
             }
-            // Collect distinct non-empty strings for diversity check.
-            const char* s = reinterpret_cast<const char*>(stringBlock.data() + val);
-            if (*s != '\0') {
-                distinctStrings.insert(std::string(s, strnlen(s, 256)));
-            }
         }
 
-        // Require at least 2 distinct non-empty string values.  Columns that
-        // only ever point to a single string (e.g. SexID=1 always resolves to
-        // the same path fragment at offset 1 in the block) are almost certainly
-        // integer fields whose small values accidentally land at a string boundary.
-        if (allZeroOrValid && hasNonZero && distinctStrings.size() >= 2) {
+        if (allZeroOrValid && hasNonZero) {
             stringCols.insert(col);
         }
     }
diff --git a/tools/diff_classic_turtle_opcodes.py b/tools/diff_classic_turtle_opcodes.py
deleted file mode 100755
index 0e548b47..00000000
--- a/tools/diff_classic_turtle_opcodes.py
+++ /dev/null
@@ -1,175 +0,0 @@
-#!/usr/bin/env python3
-"""
-Report the semantic opcode diff between the Classic and Turtle expansion maps.
-
-The report normalizes:
-- hex formatting differences (0x67 vs 0x067)
-- alias names that collapse to the same canonical opcode
-
-It highlights:
-- true wire differences for the same canonical opcode
-- canonical opcodes present only in Classic or only in Turtle
-- name-only differences where the wire matches after aliasing
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import re
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Dict, Iterable, List, Tuple
-
-from opcode_map_utils import load_opcode_map
-
-
-RE_OPCODE_NAME = re.compile(r"^(?:CMSG|SMSG|MSG)_[A-Z0-9_]+$")
-
-
-def read_aliases(path: Path) -> Dict[str, str]:
-    data = json.loads(path.read_text())
-    aliases = data.get("aliases", {})
-    out: Dict[str, str] = {}
-    for key, value in aliases.items():
-        if isinstance(key, str) and isinstance(value, str):
-            out[key] = value
-    return out
-
-
-def canonicalize(name: str, aliases: Dict[str, str]) -> str:
-    seen = set()
-    current = name
-    while current in aliases and current not in seen:
-        seen.add(current)
-        current = aliases[current]
-    return current
-
-
-def load_map(path: Path) -> Dict[str, int]:
-    data = load_opcode_map(path)
-    out: Dict[str, int] = {}
-    for key, value in data.items():
-        if not isinstance(key, str) or not RE_OPCODE_NAME.match(key):
-            continue
-        if not isinstance(value, str) or not value.lower().startswith("0x"):
-            continue
-        out[key] = int(value, 16)
-    return out
-
-
-@dataclass(frozen=True)
-class CanonicalEntry:
-    canonical_name: str
-    raw_value: int
-    raw_names: Tuple[str, ...]
-
-
-def build_canonical_entries(
-    raw_map: Dict[str, int], aliases: Dict[str, str]
-) -> Dict[str, CanonicalEntry]:
-    grouped: Dict[str, List[Tuple[str, int]]] = {}
-    for raw_name, raw_value in raw_map.items():
-        canonical_name = canonicalize(raw_name, aliases)
-        grouped.setdefault(canonical_name, []).append((raw_name, raw_value))
-
-    out: Dict[str, CanonicalEntry] = {}
-    for canonical_name, entries in grouped.items():
-        raw_values = {raw_value for _, raw_value in entries}
-        if len(raw_values) != 1:
-            formatted = ", ".join(
-                f"{name}=0x{raw_value:03X}" for name, raw_value in sorted(entries)
-            )
-            raise ValueError(
-                f"Expansion map contains multiple wires for canonical opcode "
-                f"{canonical_name}: {formatted}"
-            )
-        raw_value = next(iter(raw_values))
-        raw_names = tuple(sorted(name for name, _ in entries))
-        out[canonical_name] = CanonicalEntry(canonical_name, raw_value, raw_names)
-    return out
-
-
-def format_hex(raw_value: int) -> str:
-    return f"0x{raw_value:03X}"
-
-
-def emit_section(title: str, rows: Iterable[str], limit: int | None) -> None:
-    rows = list(rows)
-    print(f"{title}: {len(rows)}")
-    if not rows:
-        return
-    shown = rows if limit is None else rows[:limit]
-    for row in shown:
-        print(f"  {row}")
-    if limit is not None and len(rows) > limit:
-        print(f"  ... {len(rows) - limit} more")
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--root", default=".")
-    parser.add_argument(
-        "--limit",
-        type=int,
-        default=80,
-        help="Maximum rows to print per section; use -1 for no limit.",
-    )
-    args = parser.parse_args()
-
-    root = Path(args.root).resolve()
-    aliases = read_aliases(root / "Data/opcodes/aliases.json")
-    classic_raw = load_map(root / "Data/expansions/classic/opcodes.json")
-    turtle_raw = load_map(root / "Data/expansions/turtle/opcodes.json")
-
-    classic = build_canonical_entries(classic_raw, aliases)
-    turtle = build_canonical_entries(turtle_raw, aliases)
-
-    classic_names = set(classic)
-    turtle_names = set(turtle)
-    shared_names = classic_names & turtle_names
-
-    different_wire = []
-    same_wire_name_only = []
-    for canonical_name in sorted(shared_names):
-        c = classic[canonical_name]
-        t = turtle[canonical_name]
-        if c.raw_value != t.raw_value:
-            different_wire.append(
-                f"{canonical_name}: classic={format_hex(c.raw_value)} "
-                f"turtle={format_hex(t.raw_value)}"
-            )
-        elif c.raw_names != t.raw_names:
-            same_wire_name_only.append(
-                f"{canonical_name}: wire={format_hex(c.raw_value)} "
-                f"classic_names={list(c.raw_names)} turtle_names={list(t.raw_names)}"
-            )
-
-    classic_only = [
-        f"{name}: {format_hex(classic[name].raw_value)} names={list(classic[name].raw_names)}"
-        for name in sorted(classic_names - turtle_names)
-    ]
-    turtle_only = [
-        f"{name}: {format_hex(turtle[name].raw_value)} names={list(turtle[name].raw_names)}"
-        for name in sorted(turtle_names - classic_names)
-    ]
-
-    limit = None if args.limit < 0 else args.limit
-
-    print(f"classic canonical entries: {len(classic)}")
-    print(f"turtle canonical entries: {len(turtle)}")
-    print(f"shared canonical entries: {len(shared_names)}")
-    print()
-    emit_section("Different wire", different_wire, limit)
-    print()
-    emit_section("Classic only", classic_only, limit)
-    print()
-    emit_section("Turtle only", turtle_only, limit)
-    print()
-    emit_section("Same wire, name-only differences", same_wire_name_only, limit)
-
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
diff --git a/tools/gen_opcode_registry.py b/tools/gen_opcode_registry.py
old mode 100755
new mode 100644
diff --git a/tools/m2_viewer.py b/tools/m2_viewer.py
old mode 100755
new mode 100644
index fa20d609..8648948f
--- a/tools/m2_viewer.py
+++ b/tools/m2_viewer.py
@@ -538,196 +538,15 @@ class M2Parser:
 # ---------------------------------------------------------------------------
 
 _ANIM_NAMES: dict[int, str] = {
-    # ── Classic (Vanilla WoW 1.x) — IDs 0–145 ──
-    0: "STAND", 1: "DEATH", 2: "SPELL", 3: "STOP", 4: "WALK", 5: "RUN",
-    6: "DEAD", 7: "RISE", 8: "STAND_WOUND", 9: "COMBAT_WOUND",
-    10: "COMBAT_CRITICAL", 11: "SHUFFLE_LEFT", 12: "SHUFFLE_RIGHT",
-    13: "WALK_BACKWARDS", 14: "STUN", 15: "HANDS_CLOSED",
-    16: "ATTACK_UNARMED", 17: "ATTACK_1H", 18: "ATTACK_2H",
-    19: "ATTACK_2H_LOOSE", 20: "PARRY_UNARMED", 21: "PARRY_1H",
-    22: "PARRY_2H", 23: "PARRY_2H_LOOSE", 24: "SHIELD_BLOCK",
-    25: "READY_UNARMED", 26: "READY_1H", 27: "READY_2H",
-    28: "READY_2H_LOOSE", 29: "READY_BOW", 30: "DODGE",
-    31: "SPELL_PRECAST", 32: "SPELL_CAST", 33: "SPELL_CAST_AREA",
-    34: "NPC_WELCOME", 35: "NPC_GOODBYE", 36: "BLOCK",
-    37: "JUMP_START", 38: "JUMP", 39: "JUMP_END", 40: "FALL",
-    41: "SWIM_IDLE", 42: "SWIM", 43: "SWIM_LEFT", 44: "SWIM_RIGHT",
-    45: "SWIM_BACKWARDS", 46: "ATTACK_BOW", 47: "FIRE_BOW",
-    48: "READY_RIFLE", 49: "ATTACK_RIFLE", 50: "LOOT",
-    51: "READY_SPELL_DIRECTED", 52: "READY_SPELL_OMNI",
-    53: "SPELL_CAST_DIRECTED", 54: "SPELL_CAST_OMNI", 55: "BATTLE_ROAR",
-    56: "READY_ABILITY", 57: "SPECIAL_1H", 58: "SPECIAL_2H",
-    59: "SHIELD_BASH", 60: "EMOTE_TALK", 61: "EMOTE_EAT",
-    62: "EMOTE_WORK", 63: "EMOTE_USE_STANDING", 64: "EMOTE_EXCLAMATION",
-    65: "EMOTE_QUESTION", 66: "EMOTE_BOW", 67: "EMOTE_WAVE",
-    68: "EMOTE_CHEER", 69: "EMOTE_DANCE", 70: "EMOTE_LAUGH",
-    71: "EMOTE_SLEEP", 72: "EMOTE_SIT_GROUND", 73: "EMOTE_RUDE",
-    74: "EMOTE_ROAR", 75: "EMOTE_KNEEL", 76: "EMOTE_KISS",
-    77: "EMOTE_CRY", 78: "EMOTE_CHICKEN", 79: "EMOTE_BEG",
-    80: "EMOTE_APPLAUD", 81: "EMOTE_SHOUT", 82: "EMOTE_FLEX",
-    83: "EMOTE_SHY", 84: "EMOTE_POINT", 85: "ATTACK_1H_PIERCE",
-    86: "ATTACK_2H_LOOSE_PIERCE", 87: "ATTACK_OFF", 88: "ATTACK_OFF_PIERCE",
-    89: "SHEATHE", 90: "HIP_SHEATHE", 91: "MOUNT",
-    92: "RUN_RIGHT", 93: "RUN_LEFT", 94: "MOUNT_SPECIAL", 95: "KICK",
-    96: "SIT_GROUND_DOWN", 97: "SITTING", 98: "SIT_GROUND_UP",
-    99: "SLEEP_DOWN", 100: "SLEEP", 101: "SLEEP_UP",
-    102: "SIT_CHAIR_LOW", 103: "SIT_CHAIR_MED", 104: "SIT_CHAIR_HIGH",
-    105: "LOAD_BOW", 106: "LOAD_RIFLE", 107: "ATTACK_THROWN",
-    108: "READY_THROWN", 109: "HOLD_BOW", 110: "HOLD_RIFLE",
-    111: "HOLD_THROWN", 112: "LOAD_THROWN", 113: "EMOTE_SALUTE",
-    114: "KNEEL_START", 115: "KNEEL_LOOP", 116: "KNEEL_END",
-    117: "ATTACK_UNARMED_OFF", 118: "SPECIAL_UNARMED",
-    119: "STEALTH_WALK", 120: "STEALTH_STAND", 121: "KNOCKDOWN",
-    122: "EATING_LOOP", 123: "USE_STANDING_LOOP",
-    124: "CHANNEL_CAST_DIRECTED", 125: "CHANNEL_CAST_OMNI",
-    126: "WHIRLWIND", 127: "BIRTH", 128: "USE_STANDING_START",
-    129: "USE_STANDING_END", 130: "CREATURE_SPECIAL", 131: "DROWN",
-    132: "DROWNED", 133: "FISHING_CAST", 134: "FISHING_LOOP", 135: "FLY",
-    136: "EMOTE_WORK_NO_SHEATHE", 137: "EMOTE_STUN_NO_SHEATHE",
-    138: "EMOTE_USE_STANDING_NO_SHEATHE", 139: "SPELL_SLEEP_DOWN",
-    140: "SPELL_KNEEL_START", 141: "SPELL_KNEEL_LOOP",
-    142: "SPELL_KNEEL_END", 143: "SPRINT", 144: "IN_FLIGHT", 145: "SPAWN",
-    # ── The Burning Crusade (TBC 2.x) — IDs 146–199 ──
-    146: "CLOSE", 147: "CLOSED", 148: "OPEN", 149: "DESTROY",
-    150: "DESTROYED", 151: "UNSHEATHE", 152: "SHEATHE_ALT",
-    153: "ATTACK_UNARMED_NO_SHEATHE", 154: "STEALTH_RUN",
-    155: "READY_CROSSBOW", 156: "ATTACK_CROSSBOW",
-    157: "EMOTE_TALK_EXCLAMATION", 158: "FLY_IDLE", 159: "FLY_FORWARD",
-    160: "FLY_BACKWARDS", 161: "FLY_LEFT", 162: "FLY_RIGHT",
-    163: "FLY_UP", 164: "FLY_DOWN", 165: "FLY_LAND_START",
-    166: "FLY_LAND_RUN", 167: "FLY_LAND_END",
-    168: "EMOTE_TALK_QUESTION", 169: "EMOTE_READ",
-    170: "EMOTE_SHIELDBLOCK", 171: "EMOTE_CHOP", 172: "EMOTE_HOLDRIFLE",
-    173: "EMOTE_HOLDBOW", 174: "EMOTE_HOLDTHROWN",
-    175: "CUSTOM_SPELL_02", 176: "CUSTOM_SPELL_03", 177: "CUSTOM_SPELL_04",
-    178: "CUSTOM_SPELL_05", 179: "CUSTOM_SPELL_06", 180: "CUSTOM_SPELL_07",
-    181: "CUSTOM_SPELL_08", 182: "CUSTOM_SPELL_09", 183: "CUSTOM_SPELL_10",
-    184: "EMOTE_STATE_DANCE",
-    # ── Wrath of the Lich King (WotLK 3.x) — IDs 185+ ──
-    185: "FLY_STAND", 186: "EMOTE_STATE_LAUGH", 187: "EMOTE_STATE_POINT",
-    188: "EMOTE_STATE_EAT", 189: "EMOTE_STATE_WORK",
-    190: "EMOTE_STATE_SIT_GROUND", 191: "EMOTE_STATE_HOLD_BOW",
-    192: "EMOTE_STATE_HOLD_RIFLE", 193: "EMOTE_STATE_HOLD_THROWN",
-    194: "FLY_COMBAT_WOUND", 195: "FLY_COMBAT_CRITICAL", 196: "RECLINED",
-    197: "EMOTE_STATE_ROAR", 198: "EMOTE_USE_STANDING_LOOP_2",
-    199: "EMOTE_STATE_APPLAUD", 200: "READY_FIST",
-    201: "SPELL_CHANNEL_DIRECTED_OMNI", 202: "SPECIAL_ATTACK_1H_OFF",
-    203: "ATTACK_FIST_1H", 204: "ATTACK_FIST_1H_OFF",
-    205: "PARRY_FIST_1H", 206: "READY_FIST_1H",
-    207: "EMOTE_STATE_READ_AND_TALK", 208: "EMOTE_STATE_WORK_NO_SHEATHE",
-    209: "FLY_RUN", 210: "EMOTE_STATE_KNEEL_2",
-    211: "EMOTE_STATE_SPELL_KNEEL", 212: "EMOTE_STATE_USE_STANDING",
-    213: "EMOTE_STATE_STUN", 214: "EMOTE_STATE_STUN_NO_SHEATHE",
-    215: "EMOTE_TRAIN", 216: "EMOTE_DEAD",
-    217: "EMOTE_STATE_DANCE_ONCE", 218: "FLY_DEATH",
-    219: "FLY_STAND_WOUND", 220: "FLY_SHUFFLE_LEFT",
-    221: "FLY_SHUFFLE_RIGHT", 222: "FLY_WALK_BACKWARDS",
-    223: "FLY_STUN", 224: "FLY_HANDS_CLOSED", 225: "FLY_ATTACK_UNARMED",
-    226: "FLY_ATTACK_1H", 227: "FLY_ATTACK_2H",
-    228: "FLY_ATTACK_2H_LOOSE", 229: "FLY_SPELL", 230: "FLY_STOP",
-    231: "FLY_WALK", 232: "FLY_DEAD", 233: "FLY_RISE", 234: "FLY_RUN_2",
-    235: "FLY_FALL", 236: "FLY_SWIM_IDLE", 237: "FLY_SWIM",
-    238: "FLY_SWIM_LEFT", 239: "FLY_SWIM_RIGHT",
-    240: "FLY_SWIM_BACKWARDS", 241: "FLY_ATTACK_BOW",
-    242: "FLY_FIRE_BOW", 243: "FLY_READY_RIFLE",
-    244: "FLY_ATTACK_RIFLE", 245: "TOTEM_SMALL", 246: "TOTEM_MEDIUM",
-    247: "TOTEM_LARGE", 248: "FLY_LOOT",
-    249: "FLY_READY_SPELL_DIRECTED", 250: "FLY_READY_SPELL_OMNI",
-    251: "FLY_SPELL_CAST_DIRECTED", 252: "FLY_SPELL_CAST_OMNI",
-    253: "FLY_BATTLE_ROAR", 254: "FLY_READY_ABILITY",
-    255: "FLY_SPECIAL_1H", 256: "FLY_SPECIAL_2H",
-    257: "FLY_SHIELD_BASH", 258: "FLY_EMOTE_TALK", 259: "FLY_EMOTE_EAT",
-    260: "FLY_EMOTE_WORK", 261: "FLY_EMOTE_USE_STANDING",
-    262: "FLY_EMOTE_BOW", 263: "FLY_EMOTE_WAVE", 264: "FLY_EMOTE_CHEER",
-    265: "FLY_EMOTE_DANCE", 266: "FLY_EMOTE_LAUGH",
-    267: "FLY_EMOTE_SLEEP", 268: "FLY_EMOTE_SIT_GROUND",
-    269: "FLY_EMOTE_RUDE", 270: "FLY_EMOTE_ROAR",
-    271: "FLY_EMOTE_KNEEL", 272: "FLY_EMOTE_KISS", 273: "FLY_EMOTE_CRY",
-    274: "FLY_EMOTE_CHICKEN", 275: "FLY_EMOTE_BEG",
-    276: "FLY_EMOTE_APPLAUD", 277: "FLY_EMOTE_SHOUT",
-    278: "FLY_EMOTE_FLEX", 279: "FLY_EMOTE_SHY", 280: "FLY_EMOTE_POINT",
-    281: "FLY_ATTACK_1H_PIERCE", 282: "FLY_ATTACK_2H_LOOSE_PIERCE",
-    283: "FLY_ATTACK_OFF", 284: "FLY_ATTACK_OFF_PIERCE",
-    285: "FLY_SHEATHE", 286: "FLY_HIP_SHEATHE", 287: "FLY_MOUNT",
-    288: "FLY_RUN_RIGHT", 289: "FLY_RUN_LEFT",
-    290: "FLY_MOUNT_SPECIAL", 291: "FLY_KICK",
-    292: "FLY_SIT_GROUND_DOWN", 293: "FLY_SITTING",
-    294: "FLY_SIT_GROUND_UP", 295: "FLY_SLEEP_DOWN", 296: "FLY_SLEEP",
-    297: "FLY_SLEEP_UP", 298: "FLY_SIT_CHAIR_LOW",
-    299: "FLY_SIT_CHAIR_MED", 300: "FLY_SIT_CHAIR_HIGH",
-    301: "FLY_LOAD_BOW", 302: "FLY_LOAD_RIFLE",
-    303: "FLY_ATTACK_THROWN", 304: "FLY_READY_THROWN",
-    305: "FLY_HOLD_BOW", 306: "FLY_HOLD_RIFLE", 307: "FLY_HOLD_THROWN",
-    308: "FLY_LOAD_THROWN", 309: "FLY_EMOTE_SALUTE",
-    310: "FLY_KNEEL_START", 311: "FLY_KNEEL_LOOP", 312: "FLY_KNEEL_END",
-    313: "FLY_ATTACK_UNARMED_OFF", 314: "FLY_SPECIAL_UNARMED",
-    315: "FLY_STEALTH_WALK", 316: "FLY_STEALTH_STAND",
-    317: "FLY_KNOCKDOWN", 318: "FLY_EATING_LOOP",
-    319: "FLY_USE_STANDING_LOOP", 320: "FLY_CHANNEL_CAST_DIRECTED",
-    321: "FLY_CHANNEL_CAST_OMNI", 322: "FLY_WHIRLWIND",
-    323: "FLY_BIRTH", 324: "FLY_USE_STANDING_START",
-    325: "FLY_USE_STANDING_END", 326: "FLY_CREATURE_SPECIAL",
-    327: "FLY_DROWN", 328: "FLY_DROWNED", 329: "FLY_FISHING_CAST",
-    330: "FLY_FISHING_LOOP", 331: "FLY_FLY",
-    332: "FLY_EMOTE_WORK_NO_SHEATHE", 333: "FLY_EMOTE_STUN_NO_SHEATHE",
-    334: "FLY_EMOTE_USE_STANDING_NO_SHEATHE",
-    335: "FLY_SPELL_SLEEP_DOWN", 336: "FLY_SPELL_KNEEL_START",
-    337: "FLY_SPELL_KNEEL_LOOP", 338: "FLY_SPELL_KNEEL_END",
-    339: "FLY_SPRINT", 340: "FLY_IN_FLIGHT", 341: "FLY_SPAWN",
-    342: "FLY_CLOSE", 343: "FLY_CLOSED", 344: "FLY_OPEN",
-    345: "FLY_DESTROY", 346: "FLY_DESTROYED", 347: "FLY_UNSHEATHE",
-    348: "FLY_SHEATHE_ALT", 349: "FLY_ATTACK_UNARMED_NO_SHEATHE",
-    350: "FLY_STEALTH_RUN", 351: "FLY_READY_CROSSBOW",
-    352: "FLY_ATTACK_CROSSBOW", 353: "FLY_EMOTE_TALK_EXCLAMATION",
-    354: "FLY_EMOTE_TALK_QUESTION", 355: "FLY_EMOTE_READ",
-    356: "EMOTE_HOLD_CROSSBOW", 357: "FLY_EMOTE_HOLD_BOW",
-    358: "FLY_EMOTE_HOLD_RIFLE", 359: "FLY_EMOTE_HOLD_THROWN",
-    360: "FLY_EMOTE_HOLD_CROSSBOW", 361: "FLY_CUSTOM_SPELL_02",
-    362: "FLY_CUSTOM_SPELL_03", 363: "FLY_CUSTOM_SPELL_04",
-    364: "FLY_CUSTOM_SPELL_05", 365: "FLY_CUSTOM_SPELL_06",
-    366: "FLY_CUSTOM_SPELL_07", 367: "FLY_CUSTOM_SPELL_08",
-    368: "FLY_CUSTOM_SPELL_09", 369: "FLY_CUSTOM_SPELL_10",
-    370: "FLY_EMOTE_STATE_DANCE", 371: "EMOTE_EAT_NO_SHEATHE",
-    372: "MOUNT_RUN_RIGHT", 373: "MOUNT_RUN_LEFT",
-    374: "MOUNT_WALK_BACKWARDS", 375: "MOUNT_SWIM_IDLE",
-    376: "MOUNT_SWIM", 377: "MOUNT_SWIM_LEFT", 378: "MOUNT_SWIM_RIGHT",
-    379: "MOUNT_SWIM_BACKWARDS", 380: "MOUNT_FLIGHT_IDLE",
-    381: "MOUNT_FLIGHT_FORWARD", 382: "MOUNT_FLIGHT_BACKWARDS",
-    383: "MOUNT_FLIGHT_LEFT", 384: "MOUNT_FLIGHT_RIGHT",
-    385: "MOUNT_FLIGHT_UP", 386: "MOUNT_FLIGHT_DOWN",
-    387: "MOUNT_FLIGHT_LAND_START", 388: "MOUNT_FLIGHT_LAND_RUN",
-    389: "MOUNT_FLIGHT_LAND_END", 390: "FLY_EMOTE_STATE_LAUGH",
-    391: "FLY_EMOTE_STATE_POINT", 392: "FLY_EMOTE_STATE_EAT",
-    393: "FLY_EMOTE_STATE_WORK", 394: "FLY_EMOTE_STATE_SIT_GROUND",
-    395: "FLY_EMOTE_STATE_HOLD_BOW", 396: "FLY_EMOTE_STATE_HOLD_RIFLE",
-    397: "FLY_EMOTE_STATE_HOLD_THROWN", 398: "FLY_EMOTE_STATE_ROAR",
-    399: "FLY_RECLINED", 400: "EMOTE_TRAIN_2", 401: "EMOTE_DEAD_2",
-    402: "FLY_EMOTE_USE_STANDING_LOOP_2", 403: "FLY_EMOTE_STATE_APPLAUD",
-    404: "FLY_READY_FIST", 405: "FLY_SPELL_CHANNEL_DIRECTED_OMNI",
-    406: "FLY_SPECIAL_ATTACK_1H_OFF", 407: "FLY_ATTACK_FIST_1H",
-    408: "FLY_ATTACK_FIST_1H_OFF", 409: "FLY_PARRY_FIST_1H",
-    410: "FLY_READY_FIST_1H", 411: "FLY_EMOTE_STATE_READ_AND_TALK",
-    412: "FLY_EMOTE_STATE_WORK_NO_SHEATHE",
-    413: "FLY_EMOTE_STATE_KNEEL_2", 414: "FLY_EMOTE_STATE_SPELL_KNEEL",
-    415: "FLY_EMOTE_STATE_USE_STANDING", 416: "FLY_EMOTE_STATE_STUN",
-    417: "FLY_EMOTE_STATE_STUN_NO_SHEATHE", 418: "FLY_EMOTE_TRAIN",
-    419: "FLY_EMOTE_DEAD", 420: "FLY_EMOTE_STATE_DANCE_ONCE",
-    421: "FLY_EMOTE_EAT_NO_SHEATHE", 422: "FLY_MOUNT_RUN_RIGHT",
-    423: "FLY_MOUNT_RUN_LEFT", 424: "FLY_MOUNT_WALK_BACKWARDS",
-    425: "FLY_MOUNT_SWIM_IDLE", 426: "FLY_MOUNT_SWIM",
-    427: "FLY_MOUNT_SWIM_LEFT", 428: "FLY_MOUNT_SWIM_RIGHT",
-    429: "FLY_MOUNT_SWIM_BACKWARDS", 430: "FLY_MOUNT_FLIGHT_IDLE",
-    431: "FLY_MOUNT_FLIGHT_FORWARD", 432: "FLY_MOUNT_FLIGHT_BACKWARDS",
-    433: "FLY_MOUNT_FLIGHT_LEFT", 434: "FLY_MOUNT_FLIGHT_RIGHT",
-    435: "FLY_MOUNT_FLIGHT_UP", 436: "FLY_MOUNT_FLIGHT_DOWN",
-    437: "FLY_MOUNT_FLIGHT_LAND_START", 438: "FLY_MOUNT_FLIGHT_LAND_RUN",
-    439: "FLY_MOUNT_FLIGHT_LAND_END", 440: "FLY_TOTEM_SMALL",
-    441: "FLY_TOTEM_MEDIUM", 442: "FLY_TOTEM_LARGE",
-    443: "FLY_EMOTE_HOLD_CROSSBOW_2", 444: "VEHICLE_GRAB",
-    445: "VEHICLE_THROW", 446: "FLY_VEHICLE_GRAB",
-    447: "FLY_VEHICLE_THROW", 448: "GUILD_CHAMPION_1",
-    449: "GUILD_CHAMPION_2", 450: "FLY_GUILD_CHAMPION_1",
-    451: "FLY_GUILD_CHAMPION_2",
+    0: "Stand", 1: "Death", 2: "Spell", 3: "Stop", 4: "Walk", 5: "Run",
+    6: "Dead", 7: "Rise", 8: "StandWound", 9: "CombatWound", 10: "CombatCritical",
+    11: "ShuffleLeft", 12: "ShuffleRight", 13: "Walkbackwards", 14: "Stun",
+    15: "HandsClosed", 16: "AttackUnarmed", 17: "Attack1H", 18: "Attack2H",
+    24: "ShieldBlock", 25: "ReadyUnarmed", 26: "Ready1H",
+    27: "Ready2H", 34: "NPCWelcome", 35: "NPCGoodbye",
+    37: "JumpStart", 38: "Jump", 39: "JumpEnd", 40: "Fall",
+    41: "SwimIdle", 42: "Swim", 60: "SpellChannelDirected",
+    69: "CombatAbility", 138: "Fly", 157: "EmoteTalk", 185: "FlyIdle",
 }
 
 
diff --git a/tools/opcode_map_utils.py b/tools/opcode_map_utils.py
deleted file mode 100755
index c3566057..00000000
--- a/tools/opcode_map_utils.py
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/usr/bin/env python3
-
-from __future__ import annotations
-
-import json
-import re
-from pathlib import Path
-from typing import Dict, Set
-
-
-RE_OPCODE_NAME = re.compile(r"^(?:CMSG|SMSG|MSG)_[A-Z0-9_]+$")
-
-
-def load_opcode_map(path: Path, _seen: Set[Path] | None = None) -> Dict[str, str]:
-    if _seen is None:
-        _seen = set()
-
-    path = path.resolve()
-    if path in _seen:
-        chain = " -> ".join(str(p) for p in list(_seen) + [path])
-        raise ValueError(f"Opcode map inheritance cycle: {chain}")
-    _seen.add(path)
-
-    data = json.loads(path.read_text())
-    merged: Dict[str, str] = {}
-
-    extends = data.get("_extends")
-    if isinstance(extends, str) and extends:
-        merged.update(load_opcode_map(path.parent / extends, _seen))
-
-    remove = data.get("_remove", [])
-    if isinstance(remove, list):
-        for name in remove:
-            if isinstance(name, str):
-                merged.pop(name, None)
-
-    for key, value in data.items():
-        if not isinstance(key, str) or not RE_OPCODE_NAME.match(key):
-            continue
-        if isinstance(value, str):
-            merged[key] = value
-        elif isinstance(value, int):
-            merged[key] = str(value)
-
-    _seen.remove(path)
-    return merged
diff --git a/tools/validate_opcode_maps.py b/tools/validate_opcode_maps.py
old mode 100755
new mode 100644
index 7acb62ed..a562439b
--- a/tools/validate_opcode_maps.py
+++ b/tools/validate_opcode_maps.py
@@ -17,8 +17,6 @@ import re
 from pathlib import Path
 from typing import Dict, Iterable, List, Set
 
-from opcode_map_utils import load_opcode_map
-
 
 RE_OPCODE_NAME = re.compile(r"^(?:CMSG|SMSG|MSG)_[A-Z0-9_]+$")
 RE_CODE_REF = re.compile(r"\bOpcode::((?:CMSG|SMSG|MSG)_[A-Z0-9_]+)\b")
@@ -55,8 +53,12 @@ def iter_expansion_files(expansions_dir: Path) -> Iterable[Path]:
 
 
 def load_expansion_names(path: Path) -> Dict[str, str]:
-    data = load_opcode_map(path)
-    return {k: str(v) for k, v in data.items() if RE_OPCODE_NAME.match(k)}
+    data = json.loads(path.read_text())
+    out: Dict[str, str] = {}
+    for k, v in data.items():
+        if RE_OPCODE_NAME.match(k):
+            out[k] = str(v)
+    return out
 
 
 def collect_code_refs(root: Path) -> Set[str]:
diff --git a/vcpkg.json b/vcpkg.json
index 7399d6ff..60b8639e 100644
--- a/vcpkg.json
+++ b/vcpkg.json
@@ -10,7 +10,6 @@
     "glew",
     "glm",
     "zlib",
-    "ffmpeg",
-    "vulkan-headers"
+    "ffmpeg"
   ]
 }